Notebooks from ckaufmann/akis-python-framework@55ed3247

e9f081b3 · Christof Kaufmann · 9a83947f · e9f081b3 · e9f081b3 · e9f081b3
Commit e9f081b3 authored 1 year ago by Christof Kaufmann
--- a/06-strings/13-slicing-sol.ipynb
+++ b/06-strings/13-slicing-sol.ipynb
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Slicing\n",
+    "\n",
+    "Erstellen Sie eine String-Variable"
+   ],
+   "id": "0001-c1107759b26f03b04109a552d2d8a3896fdb5880d2c601ee9c254f2f0bd"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "style": "python"
+   },
+   "outputs": [],
+   "source": [
+    "s = 'Indizierung'"
+   ],
+   "id": "0002-8a0142299e4fcb32b7cb69bcfc4cc17c69ea2b52d7089841fe5da822152"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "und geben Sie sie auf dem Bildschirm aus.\n",
+    "\n",
+    "Welche Buchstaben werden mit:"
+   ],
+   "id": "0004-aa28cf08954587a4ae8337b66e8562153907eef187408331543afcd8ab2"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "style": "python"
+   },
+   "outputs": [],
+   "source": [
+    "print(s[0], s[10], s[-1], s[-11])"
+   ],
+   "id": "0005-0e9359ea3ce4fa2a486d32b20fea1af94f9a4d1a6118b426702e562095f"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "angezeigt? Und welche Strings mit:"
+   ],
+   "id": "0006-d3f00344ad7855b07a9f169cb2b850a177daf71f23362a92a6ffb33f5f7"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "style": "python"
+   },
+   "outputs": [],
+   "source": [
+    "print(s[:-9], s[-9:])"
+   ],
+   "id": "0007-85ca5e5bbd29a108727f0cd6715a3262ec5bdc7dc88a4d0675599f91c35"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Lassen Sie sich von dem String `'Indizierung'` den Teil `'zier'` auf dem\n",
+    "Bildschirm anzeigen.\n",
+    "\n",
+    "Aus dem String `'Indizierung ist leicht'` lassen Sie auf dem Bildschirm\n",
+    "das Wort `'ist'` anzeigen, ohne den String jemals vorher in eine\n",
+    "Variable zu speichern. Sie können einen String direkt indizieren.\n",
+    "\n",
+    "## Lösung\n",
+    "\n",
+    "Variable erstellen und ausgeben"
+   ],
+   "id": "0011-2cda721c4197978cd2b0e9988919481d4715e2e47d99c07657e171c28fd"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "Indizierung"
+     ]
+    }
+   ],
+   "source": [
+    "s = 'Indizierung'\n",
+    "print(s)"
+   ],
+   "id": "0012-17983cb01030e7d79fe4f22fb0ff9e820df4f295b3bad508d18dfd613a3"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Hier zur Übersicht die Vorwärts- und Rückwärtsindizes:\n",
+    "\n",
+    "|           |  I  |  n  |  d  |  i  |  z  |  i  |  e  |  r  |  u  |  n  |  g  |\n",
+    "|:---------:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|\n",
+    "| vorwärts  |  0  |  1  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |  9  | 10  |\n",
+    "| rückwärts | -11 | -10 | -9  | -8  | -7  | -6  | -5  | -4  | -3  | -2  | -1  |"
+   ],
+   "id": "0014-5a1ae75376eb4387415892718ebb95e15e7cd807f4b00bda98db827138a"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "I g g I"
+     ]
+    }
+   ],
+   "source": [
+    "print(s[0], s[10], s[-1], s[-11])"
+   ],
+   "id": "0015-0e9359ea3ce4fa2a486d32b20fea1af94f9a4d1a6118b426702e562095f"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "String bis -9 (ohne -9) und ab -9 (bis Ende)"
+   ],
+   "id": "0016-9cb2b8fffac6bf582bd37eda7e41a0928d87796ae9e8d561c95ca7713ac"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "In dizierung"
+     ]
+    }
+   ],
+   "source": [
+    "print(s[:-9], s[-9:])"
+   ],
+   "id": "0017-85ca5e5bbd29a108727f0cd6715a3262ec5bdc7dc88a4d0675599f91c35"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "String ab 4 bis 8 (ohne 8)"
+   ],
+   "id": "0018-5a4554a215fe9e7ecdfbf2635f062e893fa054a3368006fc443a573adb3"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "zier"
+     ]
+    }
+   ],
+   "source": [
+    "print(s[4:8])"
+   ],
+   "id": "0019-bddcda7f7ea3323f797aa4d3e2f27c11d96e72a22451313342dce0db9fb"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Operatoren, Methoden, Indizierung usw. lassen sich auch ohne Variable\n",
+    "direkt auf einem String anwenden."
+   ],
+   "id": "0020-c01ef8256515bb8c2633b1da30ffb4d518d270d06770e53fdb8c7ed0fcf"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "ist"
+     ]
+    }
+   ],
+   "source": [
+    "print('Indizierung ist leicht'[12:15])"
+   ],
+   "id": "0021-041ba1b12055da430fc6ee8fa633f541befdc18c48f2288969f51fe5938"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "mehrere Lösungswege möglich"
+   ],
+   "id": "0022-e1acc28ce61b1a6a990d3d6cd69652f36c479e622742272e32760eca602"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "ist"
+     ]
+    }
+   ],
+   "source": [
+    "print('Indizierung ist leicht'[-10:-7])"
+   ],
+   "id": "0023-033f51ade5d45d757aececeab832d0880833e6690f8a7e7a51ae42a6336"
+  }
+ ],
+ "nbformat": 4,
+ "nbformat_minor": 5,
+ "metadata": {}
+}
+%% Cell type:markdown id:0001-c1107759b26f03b04109a552d2d8a3896fdb5880d2c601ee9c254f2f0bd tags:
+
+# Slicing
+
+Erstellen Sie eine String-Variable
+
+%% Cell type:code id:0002-8a0142299e4fcb32b7cb69bcfc4cc17c69ea2b52d7089841fe5da822152 tags:
+
+``` 
+s = 'Indizierung'
+```
+
+%% Cell type:markdown id:0004-aa28cf08954587a4ae8337b66e8562153907eef187408331543afcd8ab2 tags:
+
+und geben Sie sie auf dem Bildschirm aus.
+
+Welche Buchstaben werden mit:
+
+%% Cell type:code id:0005-0e9359ea3ce4fa2a486d32b20fea1af94f9a4d1a6118b426702e562095f tags:
+
+``` 
+print(s[0], s[10], s[-1], s[-11])
+```
+
+%% Cell type:markdown id:0006-d3f00344ad7855b07a9f169cb2b850a177daf71f23362a92a6ffb33f5f7 tags:
+
+angezeigt? Und welche Strings mit:
+
+%% Cell type:code id:0007-85ca5e5bbd29a108727f0cd6715a3262ec5bdc7dc88a4d0675599f91c35 tags:
+
+``` 
+print(s[:-9], s[-9:])
+```
+
+%% Cell type:markdown id:0011-2cda721c4197978cd2b0e9988919481d4715e2e47d99c07657e171c28fd tags:
+
+Lassen Sie sich von dem String `'Indizierung'` den Teil `'zier'` auf dem
+Bildschirm anzeigen.
+
+Aus dem String `'Indizierung ist leicht'` lassen Sie auf dem Bildschirm
+das Wort `'ist'` anzeigen, ohne den String jemals vorher in eine
+Variable zu speichern. Sie können einen String direkt indizieren.
+
+## Lösung
+
+Variable erstellen und ausgeben
+
+%% Cell type:code id:0012-17983cb01030e7d79fe4f22fb0ff9e820df4f295b3bad508d18dfd613a3 tags:
+
+``` 
+s = 'Indizierung'
+print(s)
+```
+
+%% Output
+
+    Indizierung
+
+%% Cell type:markdown id:0014-5a1ae75376eb4387415892718ebb95e15e7cd807f4b00bda98db827138a tags:
+
+Hier zur Übersicht die Vorwärts- und Rückwärtsindizes:
+
+|           |  I  |  n  |  d  |  i  |  z  |  i  |  e  |  r  |  u  |  n  |  g  |
+|:---------:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| vorwärts  |  0  |  1  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |  9  | 10  |
+| rückwärts | -11 | -10 | -9  | -8  | -7  | -6  | -5  | -4  | -3  | -2  | -1  |
+
+%% Cell type:code id:0015-0e9359ea3ce4fa2a486d32b20fea1af94f9a4d1a6118b426702e562095f tags:
+
+``` 
+print(s[0], s[10], s[-1], s[-11])
+```
+
+%% Output
+
+    I g g I
+
+%% Cell type:markdown id:0016-9cb2b8fffac6bf582bd37eda7e41a0928d87796ae9e8d561c95ca7713ac tags:
+
+String bis -9 (ohne -9) und ab -9 (bis Ende)
+
+%% Cell type:code id:0017-85ca5e5bbd29a108727f0cd6715a3262ec5bdc7dc88a4d0675599f91c35 tags:
+
+``` 
+print(s[:-9], s[-9:])
+```
+
+%% Output
+
+    In dizierung
+
+%% Cell type:markdown id:0018-5a4554a215fe9e7ecdfbf2635f062e893fa054a3368006fc443a573adb3 tags:
+
+String ab 4 bis 8 (ohne 8)
+
+%% Cell type:code id:0019-bddcda7f7ea3323f797aa4d3e2f27c11d96e72a22451313342dce0db9fb tags:
+
+``` 
+print(s[4:8])
+```
+
+%% Output
+
+    zier
+
+%% Cell type:markdown id:0020-c01ef8256515bb8c2633b1da30ffb4d518d270d06770e53fdb8c7ed0fcf tags:
+
+Operatoren, Methoden, Indizierung usw. lassen sich auch ohne Variable
+direkt auf einem String anwenden.
+
+%% Cell type:code id:0021-041ba1b12055da430fc6ee8fa633f541befdc18c48f2288969f51fe5938 tags:
+
+``` 
+print('Indizierung ist leicht'[12:15])
+```
+
+%% Output
+
+    ist
+
+%% Cell type:markdown id:0022-e1acc28ce61b1a6a990d3d6cd69652f36c479e622742272e32760eca602 tags:
+
+mehrere Lösungswege möglich
+
+%% Cell type:code id:0023-033f51ade5d45d757aececeab832d0880833e6690f8a7e7a51ae42a6336 tags:
+
+``` 
+print('Indizierung ist leicht'[-10:-7])
+```
+
+%% Output
+
+    ist
--- a/06-strings/13-slicing.ipynb
+++ b/06-strings/13-slicing.ipynb
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Slicing\n",
+    "\n",
+    "Erstellen Sie eine String-Variable"
+   ],
+   "id": "0001-c1107759b26f03b04109a552d2d8a3896fdb5880d2c601ee9c254f2f0bd"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "style": "python"
+   },
+   "outputs": [],
+   "source": [
+    "s = 'Indizierung'"
+   ],
+   "id": "0002-8a0142299e4fcb32b7cb69bcfc4cc17c69ea2b52d7089841fe5da822152"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "und geben Sie sie auf dem Bildschirm aus.\n",
+    "\n",
+    "Welche Buchstaben werden mit:"
+   ],
+   "id": "0004-aa28cf08954587a4ae8337b66e8562153907eef187408331543afcd8ab2"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "style": "python"
+   },
+   "outputs": [],
+   "source": [
+    "print(s[0], s[10], s[-1], s[-11])"
+   ],
+   "id": "0005-0e9359ea3ce4fa2a486d32b20fea1af94f9a4d1a6118b426702e562095f"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "angezeigt? Und welche Strings mit:"
+   ],
+   "id": "0006-d3f00344ad7855b07a9f169cb2b850a177daf71f23362a92a6ffb33f5f7"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "style": "python"
+   },
+   "outputs": [],
+   "source": [
+    "print(s[:-9], s[-9:])"
+   ],
+   "id": "0007-85ca5e5bbd29a108727f0cd6715a3262ec5bdc7dc88a4d0675599f91c35"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Lassen Sie sich von dem String `'Indizierung'` den Teil `'zier'` auf dem\n",
+    "Bildschirm anzeigen.\n",
+    "\n",
+    "Aus dem String `'Indizierung ist leicht'` lassen Sie auf dem Bildschirm\n",
+    "das Wort `'ist'` anzeigen, ohne den String jemals vorher in eine\n",
+    "Variable zu speichern. Sie können einen String direkt indizieren.\n",
+    "\n",
+    "Hier Ihr Code:"
+   ],
+   "id": "0010-86baaa1becc73f0745c686498ab2c088403d371687558411b3becb0b06d"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "style": "python"
+   },
+   "outputs": [],
+   "source": [],
+   "id": "0011-44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+  }
+ ],
+ "nbformat": 4,
+ "nbformat_minor": 5,
+ "metadata": {}
+}
+%% Cell type:markdown id:0001-c1107759b26f03b04109a552d2d8a3896fdb5880d2c601ee9c254f2f0bd tags:
+
+# Slicing
+
+Erstellen Sie eine String-Variable
+
+%% Cell type:code id:0002-8a0142299e4fcb32b7cb69bcfc4cc17c69ea2b52d7089841fe5da822152 tags:
+
+``` 
+s = 'Indizierung'
+```
+
+%% Cell type:markdown id:0004-aa28cf08954587a4ae8337b66e8562153907eef187408331543afcd8ab2 tags:
+
+und geben Sie sie auf dem Bildschirm aus.
+
+Welche Buchstaben werden mit:
+
+%% Cell type:code id:0005-0e9359ea3ce4fa2a486d32b20fea1af94f9a4d1a6118b426702e562095f tags:
+
+``` 
+print(s[0], s[10], s[-1], s[-11])
+```
+
+%% Cell type:markdown id:0006-d3f00344ad7855b07a9f169cb2b850a177daf71f23362a92a6ffb33f5f7 tags:
+
+angezeigt? Und welche Strings mit:
+
+%% Cell type:code id:0007-85ca5e5bbd29a108727f0cd6715a3262ec5bdc7dc88a4d0675599f91c35 tags:
+
+``` 
+print(s[:-9], s[-9:])
+```
+
+%% Cell type:markdown id:0010-86baaa1becc73f0745c686498ab2c088403d371687558411b3becb0b06d tags:
+
+Lassen Sie sich von dem String `'Indizierung'` den Teil `'zier'` auf dem
+Bildschirm anzeigen.
+
+Aus dem String `'Indizierung ist leicht'` lassen Sie auf dem Bildschirm
+das Wort `'ist'` anzeigen, ohne den String jemals vorher in eine
+Variable zu speichern. Sie können einen String direkt indizieren.
+
+Hier Ihr Code:
+
+%% Cell type:code id:0011-44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 tags:
+
+``` 
+```
--- a/06-strings/13-grundlagen-sol.ipynb
+++ b/06-strings/13-grundlagen-sol.ipynb
--- a/06-strings/13-grundlagen.ipynb
+++ b/06-strings/13-grundlagen.ipynb
--- a/06-strings/14-grossbuchstaben-sol.ipynb
+++ b/06-strings/14-grossbuchstaben-sol.ipynb
--- a/06-strings/14-grossbuchstaben.ipynb
+++ b/06-strings/14-grossbuchstaben.ipynb
--- a/07-ausgaben/03-hoehle-sol.ipynb
+++ b/07-ausgaben/03-hoehle-sol.ipynb
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Höhlenrettung\n",
+    "\n",
+    "Sie sind in einer Höhle unter der Erde gestrandet und müssen dringend\n",
+    "Hilfe rufen. Sie haben ein Kommunikationsgerät gefunden, das nur Python\n",
+    "versteht. Verwenden Sie Python, um mit der Außenwelt zu kommunizieren.\n",
+    "Lösen Sie die folgenden Aufgaben, um gerettet zu werden.\n",
+    "\n",
+    "## Statusmeldung\n",
+    "\n",
+    "Vervollständigen Sie die Funktion `sende_position`, die Ihre aktuelle\n",
+    "Position, die Temperatur in der Höhle und den verbleibenden Sauerstoff\n",
+    "in Prozent ausgeben soll. Verwenden Sie die `print`-Funktion und\n",
+    "übergeben ihr **mehrere Argumente**. Die Informationen werden über die\n",
+    "Argumente `position`, `temperatur` und `sauerstoff` gegeben. Wenn z. B.\n",
+    "`position = \"Tief in der Höhle\"`, `temperatur = 8.5` und\n",
+    "`sauerstoff = 35` sind, sollte die Ausgabe der Funktion wie folgt\n",
+    "lauten:\n",
+    "`Aktuelle Position: Tief in der Höhle Temperatur: 8.5 °C Sauerstoff: 35 %`\n",
+    "\n",
+    "### Lösung\n",
+    "\n",
+    "`position`, `temperatur`, und `sauerstoff` sind lokale Variablen, die\n",
+    "innerhalb der Funktion definiert werden. Sie bekommen ihre Werte beim\n",
+    "Aufruf der Funktion übergeben. Mit der `print`-Funktion können wir die\n",
+    "Werte der Variablen zusammen mit entsprechenden Beschriftungen ausgeben.\n",
+    "Weil `sep` standardmäßig gleich `' '` ist, werden die Argumente durch\n",
+    "ein Leerzeichen getrennt."
+   ],
+   "id": "0005-7de491fde31e25faac36c6b2ea0a2f2722c6cdf07e7ea16ff632af01486"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "Aktuelle Position: Tief in der Höhle Temperatur: 8.5 °C Sauerstoff: 35 %"
+     ]
+    }
+   ],
+   "source": [
+    "def sende_position(position, temperatur, sauerstoff):\n",
+    "    print(\"Aktuelle Position:\", position, \"Temperatur:\", temperatur, \"°C Sauerstoff:\", sauerstoff, \"%\")\n",
+    "\n",
+    "sende_position(position=\"Tief in der Höhle\", temperatur=8.5, sauerstoff=35)"
+   ],
+   "id": "0006-8f519e91586a3a5d9ac71432fbfe58fe1a223605520a0b0b83eea9b74dc"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Telegramm\n",
+    "\n",
+    "SIE MÜSSEN IHRE NACHRICHTEN ALS TELEGRAMM VERFASSEN STOP  \n",
+    "WANDELN SIE DIE NACHRICHT `n` IN GROSSBUCHSTABEN UM STOP  \n",
+    "FÜGEN SIE NACH JEDER NACHRICHT MITTELS `end` EIN `\" STOP\\n\"` HINZU STOP\n",
+    "\n",
+    "### Lösung\n",
+    "\n",
+    "Die Nachrichten `nachrichten` werden in einer `for`-Schleife in der\n",
+    "Laufvariable `n` durchlaufen, d. h. `n` ist jeweils eine Nachricht vom\n",
+    "Typ `str`. Darauf müssen Sie die `upper`-Methode ausführen, um sie in\n",
+    "Großbuchstaben umzuwandeln und mit dem Argument `end` der\n",
+    "`print`-Funktion können Sie spezifizieren, dass nach der Nachricht ein\n",
+    "`'STOP'` ausgegeben wird. Damit jede Nachricht – wie immer – in einer\n",
+    "neuen Zeile steht, fügen Sie auch wieder ein Newline hinzu, was der\n",
+    "Standardwert von `end` war."
+   ],
+   "id": "0010-d61ccc4afc94009fd4945b9ab6e13cc2767a762f86dfabe8467d1fc9979"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "HALLO ICH BIN MAX UND ICH BRAUCHE HILFE STOP\n",
+      "WIR SIND ZU VIERT UND ES IST KALT STOP\n",
+      "DER SAUERSTOFF REICHT NICHT MEHR LANGE STOP"
+     ]
+    }
+   ],
+   "source": [
+    "def telegramm(nachrichten):\n",
+    "    for n in nachrichten:\n",
+    "        print(n.upper(), end=' STOP\\n')\n",
+    "\n",
+    "telegramm(['Hallo ich bin Max und ich brauche Hilfe',\n",
+    "           'Wir sind zu viert und es ist kalt',\n",
+    "           'Der Sauerstoff reicht nicht mehr lange'])"
+   ],
+   "id": "0011-7b00e98a16ab29d96fca37a37a93e3e256e64490b1acec5bd6814ffb006"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Sauerstoff zu viert\n",
+    "\n",
+    "Vervollständigen Sie die Funktion `berechne_sauerstoff`, die zwei Zahlen\n",
+    "dividiert und die Berechnung sowie das Ergebnis (ohne `format`-Methode)\n",
+    "ausgibt. Z. B. für `minuten = 100` und `personen = 4` soll die Ausgabe\n",
+    "der Funktion wie folgt lauten:\n",
+    "`Der Sauerstoff reicht noch für 100 / 4 = 25.0 min.`\n",
+    "\n",
+    "### Lösung\n",
+    "\n",
+    "Die Argumente werden alle mit einem Leerzeichen voneinander getrennt.\n",
+    "Also lassen sie sich die `minuten`, `personen`, deren Quotient und die\n",
+    "Strings dazwischen und am Ende einfach als weitere Argumente von `print`\n",
+    "angeben."
+   ],
+   "id": "0015-18954760bb4143dcd8ab0092bfdcf8260367fe0c58159f35800f36d03fa"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "Der Sauerstoff reicht noch für 100 / 4 = 25.0 min."
+     ]
+    }
+   ],
+   "source": [
+    "def berechne_sauerstoff(minuten, personen):\n",
+    "    print(\"Der Sauerstoff reicht noch für\",\n",
+    "          minuten, '/', personen, '=', minuten / personen, 'min.')\n",
+    "\n",
+    "berechne_sauerstoff(minuten=100, personen=4)"
+   ],
+   "id": "0016-679823113dc3583ca48dfcab010d14aaeb755322eaf9aacdadab0fcc179"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Nachricht empfangen\n",
+    "\n",
+    "Sie haben eine Nachricht empfangen, aber sie müssen die Argumente noch\n",
+    "mit der `format`-Methode in die Nachricht einsetzen, um sie vollständig\n",
+    "zu sehen.\n",
+    "\n",
+    "### Lösung\n",
+    "\n",
+    "Hier ist `nachricht` bereits ein String mit Formatplatzhaltern `{}`. Sie\n",
+    "müssen nur die `format`-Methode auf `nachricht` aufrufen und die\n",
+    "Argumente `arg1`, `arg2`, `arg3` und `arg4` übergeben. Übrigens behält\n",
+    "`arg4` sein Standardargument `''` und daher wird beim letzten `{}`\n",
+    "“nichts” eingesetzt."
+   ],
+   "id": "0020-dd88f5574f5e685504b8b3f247f38d620b9797c941343d07f41c60ca0b5"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "HIER SPRICHT DER RETTUNGSTRUPP STOP\n",
+      "WIR SENDEN IHNEN DREI PEILUNGEN STOP\n",
+      "IN KARTESISCHEN KOORDINATEN STOP"
+     ]
+    }
+   ],
+   "source": [
+    "def empfange_nachricht(nachricht, arg1='', arg2='', arg3='', arg4=''):\n",
+    "    print(nachricht.format(arg1, arg2, arg3, arg4))\n",
+    "\n",
+    "empfange_nachricht('HIER SPRICHT {} STOP\\nWIR SENDEN IHNEN {} STOP\\n{} STOP{}',\n",
+    "                   'DER RETTUNGSTRUPP', 'DREI PEILUNGEN', 'IN KARTESISCHEN KOORDINATEN')"
+   ],
+   "id": "0021-85daae17aa5e42516538cb0a5dbd6fadc9f15a0a494eec06b8c95f90012"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Peilungen berechnen\n",
+    "\n",
+    "Sie erhalten die Koordinaten. Alle Koordinaten werden mit einer\n",
+    "`for`-Schleife durchlaufen und jeweils in `x` und `y` gespeichert.\n",
+    "Benutzen Sie `math.atan2(y, x) / math.pi * 180` um die Richtung und\n",
+    "`math.sqrt(x**2 + y**2)` um die Länge zu berechnen. Geben Sie sie aus\n",
+    "und addieren Sie jeweils die Länge zur `gesamtlaenge` dazu.\n",
+    "\n",
+    "### Lösung\n",
+    "\n",
+    "Es bietet sich an lokale Variablen für die Richtung und die Länge zu\n",
+    "definieren. Die Berechnete Länge wird nicht nur ausgegeben, sondern auch\n",
+    "zur Gesamtlänge dazuaddiert."
+   ],
+   "id": "0025-f1dc6b49891f816ffef68f4f80c4601e07f06a3ebf59a8e3098e741187e"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "Richtung: -50.92669012374323 °, Länge: 1082.0\n",
+      "Richtung: 80.47271661854764 °, Länge: 145.0\n",
+      "Richtung: -36.86989764584402 °, Länge: 110.0"
+     ]
+    }
+   ],
+   "source": [
+    "import math\n",
+    "\n",
+    "def peilungen(x_coords, y_coords):\n",
+    "    gesamtlaenge = 0\n",
+    "\n",
+    "    for x, y in zip(x_coords, y_coords):\n",
+    "        richtung = math.atan2(y, x) / math.pi * 180\n",
+    "        laenge = math.sqrt(x**2 + y**2)\n",
+    "        gesamtlaenge += laenge\n",
+    "        print(\"Richtung:\", richtung, \"°, Länge:\", laenge)\n",
+    "\n",
+    "    return gesamtlaenge\n",
+    "\n",
+    "total = peilungen(x_coords=[682, 24, 88], y_coords=[-840, 143, -66])"
+   ],
+   "id": "0026-598675e35b558065cfcb3e8b34dcb556842f4eaa2dd21c680c9b8e74a6e"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Dauer\n",
+    "\n",
+    "Ihre Freunde haben Ihnen die Koordinaten gesendet aus denen Sie die\n",
+    "Gesamtlänge `total` berechnet haben. Vervollständigen Sie die Funktion\n",
+    "`berechne_zeit`, die berechnet, wie lange Sie in Abhängigkeit von der\n",
+    "Geschwindigkeit unterwegs sind. Verwenden Sie die `format`-Methode mit\n",
+    "Variablenindizes oder -namen, sodass Sie die Variablen, die mehrfach\n",
+    "ausgegeben werden, nur einmal übergeben müssen. Geben Sie die Entfernung\n",
+    "beim ersten Vorkommen gerundet (mit 0 Nachkommastellen) und das Ergebnis\n",
+    "mit 1 Nachkommastelle an. Die Ausgabe der Funktion sollte beispielsweise\n",
+    "wie folgt lauten:\n",
+    "`Entfernung: 2000 m, Geschwindigkeit 0.5 m/s, ETA: 2000.0 / 0.5 s = 4000.0 s`\n",
+    "\n",
+    "### Lösung\n",
+    "\n",
+    "Variablenbezeichner sind hier praktisch, damit wir die `laenge` und\n",
+    "`geschwindigkeit` nur einmal in die `format`-Methode übergeben müssen,\n",
+    "obwohl sie zweimal ausgegeben werden. Um die Entfernung bei der ersten\n",
+    "Ausgabe zu runden, verwenden wir als Formatspezifizierer `.0f`."
+   ],
+   "id": "0030-9c69d65933f4c9b60deccf4e526a0905cc89655a498cd7ffe25f90decb5"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "Entfernung: 1337 m, Geschwindigkeit 0.7 m/s, ETA: 1337.0 / 0.7 s = 1910.0 s"
+     ]
+    }
+   ],
+   "source": [
+    "def berechne_zeit(laenge, geschwindigkeit):\n",
+    "    dauer = laenge / geschwindigkeit\n",
+    "    print(\"Entfernung: {s:.0f} m, Geschwindigkeit {v} m/s, ETA: {s} / {v} s = {t:.1f} s\".format(s=laenge, v=geschwindigkeit, t=dauer))\n",
+    "\n",
+    "berechne_zeit(laenge=total, geschwindigkeit=0.7)"
+   ],
+   "id": "0031-12b2e6dfdfad4534fc2de9c728def346c5a6b44a3cc0be599fcdf58efcb"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Temperatur\n",
+    "\n",
+    "Je näher Sie zum Ausgang kommen, desto mehr steigt die Temperatur.\n",
+    "Verwenden Sie einen f-String um die Temperatur mit einer Nachkommastelle\n",
+    "wie folgt auszugeben: `Die aktuelle Temperatur beträgt: 9.7°C`\n",
+    "\n",
+    "### Lösung\n",
+    "\n",
+    "Ein f-String ist ähnlich wie ein Aufruf der `format`-Methode, nur dass\n",
+    "die Argumente direkt in die Formatplatzhalter `{}` geschrieben werden:"
+   ],
+   "id": "0035-f27ff2c8b07177c39f608d15ae0bf9655de38f9f121159e04519c2721d0"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "Die aktuelle Temperatur beträgt: 9.7°C"
+     ]
+    }
+   ],
+   "source": [
+    "def temperatur(temperatur):\n",
+    "    print(f\"Die aktuelle Temperatur beträgt: {temperatur:.1f}°C\")\n",
+    "\n",
+    "temperatur(temperatur=9.6789)"
+   ],
+   "id": "0036-4c2f450a2291b07552cf6c9ebb69e706c6c7294f33507e1e03e1f09eb38"
+  }
+ ],
+ "nbformat": 4,
+ "nbformat_minor": 5,
+ "metadata": {}
+}
+%% Cell type:markdown id:0005-7de491fde31e25faac36c6b2ea0a2f2722c6cdf07e7ea16ff632af01486 tags:
+
+# Höhlenrettung
+
+Sie sind in einer Höhle unter der Erde gestrandet und müssen dringend
+Hilfe rufen. Sie haben ein Kommunikationsgerät gefunden, das nur Python
+versteht. Verwenden Sie Python, um mit der Außenwelt zu kommunizieren.
+Lösen Sie die folgenden Aufgaben, um gerettet zu werden.
+
+## Statusmeldung
+
+Vervollständigen Sie die Funktion `sende_position`, die Ihre aktuelle
+Position, die Temperatur in der Höhle und den verbleibenden Sauerstoff
+in Prozent ausgeben soll. Verwenden Sie die `print`-Funktion und
+übergeben ihr **mehrere Argumente**. Die Informationen werden über die
+Argumente `position`, `temperatur` und `sauerstoff` gegeben. Wenn z. B.
+`position = "Tief in der Höhle"`, `temperatur = 8.5` und
+`sauerstoff = 35` sind, sollte die Ausgabe der Funktion wie folgt
+lauten:
+`Aktuelle Position: Tief in der Höhle Temperatur: 8.5 °C Sauerstoff: 35 %`
+
+### Lösung
+
+`position`, `temperatur`, und `sauerstoff` sind lokale Variablen, die
+innerhalb der Funktion definiert werden. Sie bekommen ihre Werte beim
+Aufruf der Funktion übergeben. Mit der `print`-Funktion können wir die
+Werte der Variablen zusammen mit entsprechenden Beschriftungen ausgeben.
+Weil `sep` standardmäßig gleich `' '` ist, werden die Argumente durch
+ein Leerzeichen getrennt.
+
+%% Cell type:code id:0006-8f519e91586a3a5d9ac71432fbfe58fe1a223605520a0b0b83eea9b74dc tags:
+
+``` 
+def sende_position(position, temperatur, sauerstoff):
+    print("Aktuelle Position:", position, "Temperatur:", temperatur, "°C Sauerstoff:", sauerstoff, "%")
+
+sende_position(position="Tief in der Höhle", temperatur=8.5, sauerstoff=35)
+```
+
+%% Output
+
+    Aktuelle Position: Tief in der Höhle Temperatur: 8.5 °C Sauerstoff: 35 %
+
+%% Cell type:markdown id:0010-d61ccc4afc94009fd4945b9ab6e13cc2767a762f86dfabe8467d1fc9979 tags:
+
+## Telegramm
+
+SIE MÜSSEN IHRE NACHRICHTEN ALS TELEGRAMM VERFASSEN STOP
+WANDELN SIE DIE NACHRICHT `n` IN GROSSBUCHSTABEN UM STOP
+FÜGEN SIE NACH JEDER NACHRICHT MITTELS `end` EIN `" STOP\n"` HINZU STOP
+
+### Lösung
+
+Die Nachrichten `nachrichten` werden in einer `for`-Schleife in der
+Laufvariable `n` durchlaufen, d. h. `n` ist jeweils eine Nachricht vom
+Typ `str`. Darauf müssen Sie die `upper`-Methode ausführen, um sie in
+Großbuchstaben umzuwandeln und mit dem Argument `end` der
+`print`-Funktion können Sie spezifizieren, dass nach der Nachricht ein
+`'STOP'` ausgegeben wird. Damit jede Nachricht – wie immer – in einer
+neuen Zeile steht, fügen Sie auch wieder ein Newline hinzu, was der
+Standardwert von `end` war.
+
+%% Cell type:code id:0011-7b00e98a16ab29d96fca37a37a93e3e256e64490b1acec5bd6814ffb006 tags:
+
+``` 
+def telegramm(nachrichten):
+    for n in nachrichten:
+        print(n.upper(), end=' STOP\n')
+
+telegramm(['Hallo ich bin Max und ich brauche Hilfe',
+           'Wir sind zu viert und es ist kalt',
+           'Der Sauerstoff reicht nicht mehr lange'])
+```
+
+%% Output
+
+    HALLO ICH BIN MAX UND ICH BRAUCHE HILFE STOP
+    WIR SIND ZU VIERT UND ES IST KALT STOP
+    DER SAUERSTOFF REICHT NICHT MEHR LANGE STOP
+
+%% Cell type:markdown id:0015-18954760bb4143dcd8ab0092bfdcf8260367fe0c58159f35800f36d03fa tags:
+
+## Sauerstoff zu viert
+
+Vervollständigen Sie die Funktion `berechne_sauerstoff`, die zwei Zahlen
+dividiert und die Berechnung sowie das Ergebnis (ohne `format`-Methode)
+ausgibt. Z. B. für `minuten = 100` und `personen = 4` soll die Ausgabe
+der Funktion wie folgt lauten:
+`Der Sauerstoff reicht noch für 100 / 4 = 25.0 min.`
+
+### Lösung
+
+Die Argumente werden alle mit einem Leerzeichen voneinander getrennt.
+Also lassen sie sich die `minuten`, `personen`, deren Quotient und die
+Strings dazwischen und am Ende einfach als weitere Argumente von `print`
+angeben.
+
+%% Cell type:code id:0016-679823113dc3583ca48dfcab010d14aaeb755322eaf9aacdadab0fcc179 tags:
+
+``` 
+def berechne_sauerstoff(minuten, personen):
+    print("Der Sauerstoff reicht noch für",
+          minuten, '/', personen, '=', minuten / personen, 'min.')
+
+berechne_sauerstoff(minuten=100, personen=4)
+```
+
+%% Output
+
+    Der Sauerstoff reicht noch für 100 / 4 = 25.0 min.
+
+%% Cell type:markdown id:0020-dd88f5574f5e685504b8b3f247f38d620b9797c941343d07f41c60ca0b5 tags:
+
+## Nachricht empfangen
+
+Sie haben eine Nachricht empfangen, aber sie müssen die Argumente noch
+mit der `format`-Methode in die Nachricht einsetzen, um sie vollständig
+zu sehen.
+
+### Lösung
+
+Hier ist `nachricht` bereits ein String mit Formatplatzhaltern `{}`. Sie
+müssen nur die `format`-Methode auf `nachricht` aufrufen und die
+Argumente `arg1`, `arg2`, `arg3` und `arg4` übergeben. Übrigens behält
+`arg4` sein Standardargument `''` und daher wird beim letzten `{}`
+“nichts” eingesetzt.
+
+%% Cell type:code id:0021-85daae17aa5e42516538cb0a5dbd6fadc9f15a0a494eec06b8c95f90012 tags:
+
+``` 
+def empfange_nachricht(nachricht, arg1='', arg2='', arg3='', arg4=''):
+    print(nachricht.format(arg1, arg2, arg3, arg4))
+
+empfange_nachricht('HIER SPRICHT {} STOP\nWIR SENDEN IHNEN {} STOP\n{} STOP{}',
+                   'DER RETTUNGSTRUPP', 'DREI PEILUNGEN', 'IN KARTESISCHEN KOORDINATEN')
+```
+
+%% Output
+
+    HIER SPRICHT DER RETTUNGSTRUPP STOP
+    WIR SENDEN IHNEN DREI PEILUNGEN STOP
+    IN KARTESISCHEN KOORDINATEN STOP
+
+%% Cell type:markdown id:0025-f1dc6b49891f816ffef68f4f80c4601e07f06a3ebf59a8e3098e741187e tags:
+
+## Peilungen berechnen
+
+Sie erhalten die Koordinaten. Alle Koordinaten werden mit einer
+`for`-Schleife durchlaufen und jeweils in `x` und `y` gespeichert.
+Benutzen Sie `math.atan2(y, x) / math.pi * 180` um die Richtung und
+`math.sqrt(x**2 + y**2)` um die Länge zu berechnen. Geben Sie sie aus
+und addieren Sie jeweils die Länge zur `gesamtlaenge` dazu.
+
+### Lösung
+
+Es bietet sich an lokale Variablen für die Richtung und die Länge zu
+definieren. Die Berechnete Länge wird nicht nur ausgegeben, sondern auch
+zur Gesamtlänge dazuaddiert.
+
+%% Cell type:code id:0026-598675e35b558065cfcb3e8b34dcb556842f4eaa2dd21c680c9b8e74a6e tags:
+
+``` 
+import math
+
+def peilungen(x_coords, y_coords):
+    gesamtlaenge = 0
+
+    for x, y in zip(x_coords, y_coords):
+        richtung = math.atan2(y, x) / math.pi * 180
+        laenge = math.sqrt(x**2 + y**2)
+        gesamtlaenge += laenge
+        print("Richtung:", richtung, "°, Länge:", laenge)
+
+    return gesamtlaenge
+
+total = peilungen(x_coords=[682, 24, 88], y_coords=[-840, 143, -66])
+```
+
+%% Output
+
+    Richtung: -50.92669012374323 °, Länge: 1082.0
+    Richtung: 80.47271661854764 °, Länge: 145.0
+    Richtung: -36.86989764584402 °, Länge: 110.0
+
+%% Cell type:markdown id:0030-9c69d65933f4c9b60deccf4e526a0905cc89655a498cd7ffe25f90decb5 tags:
+
+## Dauer
+
+Ihre Freunde haben Ihnen die Koordinaten gesendet aus denen Sie die
+Gesamtlänge `total` berechnet haben. Vervollständigen Sie die Funktion
+`berechne_zeit`, die berechnet, wie lange Sie in Abhängigkeit von der
+Geschwindigkeit unterwegs sind. Verwenden Sie die `format`-Methode mit
+Variablenindizes oder -namen, sodass Sie die Variablen, die mehrfach
+ausgegeben werden, nur einmal übergeben müssen. Geben Sie die Entfernung
+beim ersten Vorkommen gerundet (mit 0 Nachkommastellen) und das Ergebnis
+mit 1 Nachkommastelle an. Die Ausgabe der Funktion sollte beispielsweise
+wie folgt lauten:
+`Entfernung: 2000 m, Geschwindigkeit 0.5 m/s, ETA: 2000.0 / 0.5 s = 4000.0 s`
+
+### Lösung
+
+Variablenbezeichner sind hier praktisch, damit wir die `laenge` und
+`geschwindigkeit` nur einmal in die `format`-Methode übergeben müssen,
+obwohl sie zweimal ausgegeben werden. Um die Entfernung bei der ersten
+Ausgabe zu runden, verwenden wir als Formatspezifizierer `.0f`.
+
+%% Cell type:code id:0031-12b2e6dfdfad4534fc2de9c728def346c5a6b44a3cc0be599fcdf58efcb tags:
+
+``` 
+def berechne_zeit(laenge, geschwindigkeit):
+    dauer = laenge / geschwindigkeit
+    print("Entfernung: {s:.0f} m, Geschwindigkeit {v} m/s, ETA: {s} / {v} s = {t:.1f} s".format(s=laenge, v=geschwindigkeit, t=dauer))
+
+berechne_zeit(laenge=total, geschwindigkeit=0.7)
+```
+
+%% Output
+
+    Entfernung: 1337 m, Geschwindigkeit 0.7 m/s, ETA: 1337.0 / 0.7 s = 1910.0 s
+
+%% Cell type:markdown id:0035-f27ff2c8b07177c39f608d15ae0bf9655de38f9f121159e04519c2721d0 tags:
+
+## Temperatur
+
+Je näher Sie zum Ausgang kommen, desto mehr steigt die Temperatur.
+Verwenden Sie einen f-String um die Temperatur mit einer Nachkommastelle
+wie folgt auszugeben: `Die aktuelle Temperatur beträgt: 9.7°C`
+
+### Lösung
+
+Ein f-String ist ähnlich wie ein Aufruf der `format`-Methode, nur dass
+die Argumente direkt in die Formatplatzhalter `{}` geschrieben werden:
+
+%% Cell type:code id:0036-4c2f450a2291b07552cf6c9ebb69e706c6c7294f33507e1e03e1f09eb38 tags:
+
+``` 
+def temperatur(temperatur):
+    print(f"Die aktuelle Temperatur beträgt: {temperatur:.1f}°C")
+
+temperatur(temperatur=9.6789)
+```
+
+%% Output
+
+    Die aktuelle Temperatur beträgt: 9.7°C
--- a/07-ausgaben/03-hoehle.ipynb
+++ b/07-ausgaben/03-hoehle.ipynb
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Höhlenrettung\n",
+    "\n",
+    "Sie sind in einer Höhle unter der Erde gestrandet und müssen dringend\n",
+    "Hilfe rufen. Sie haben ein Kommunikationsgerät gefunden, das nur Python\n",
+    "versteht. Verwenden Sie Python, um mit der Außenwelt zu kommunizieren.\n",
+    "Lösen Sie die folgenden Aufgaben, um gerettet zu werden.\n",
+    "\n",
+    "## Statusmeldung\n",
+    "\n",
+    "Vervollständigen Sie die Funktion `sende_position`, die Ihre aktuelle\n",
+    "Position, die Temperatur in der Höhle und den verbleibenden Sauerstoff\n",
+    "in Prozent ausgeben soll. Verwenden Sie die `print`-Funktion und\n",
+    "übergeben ihr **mehrere Argumente**. Die Informationen werden über die\n",
+    "Argumente `position`, `temperatur` und `sauerstoff` gegeben. Wenn z. B.\n",
+    "`position = \"Tief in der Höhle\"`, `temperatur = 8.5` und\n",
+    "`sauerstoff = 35` sind, sollte die Ausgabe der Funktion wie folgt\n",
+    "lauten:\n",
+    "`Aktuelle Position: Tief in der Höhle Temperatur: 8.5 °C Sauerstoff: 35 %`"
+   ],
+   "id": "0003-6c5b9abc3cd82d9b962b2f7bfe07e1fde8b290aeca77d47a0a9b1f69e49"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "style": "python"
+   },
+   "outputs": [],
+   "source": [
+    "def sende_position(position, temperatur, sauerstoff):\n",
+    "    print(\"\")\n",
+    "\n",
+    "\n",
+    "sende_position(position=\"Tief in der Höhle\", temperatur=8.5, sauerstoff=35)"
+   ],
+   "id": "0004-4c00cbd508cb6e116e1e649269b0caea2b592a88f48126f375aba906ce3"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Telegramm\n",
+    "\n",
+    "SIE MÜSSEN IHRE NACHRICHTEN ALS TELEGRAMM VERFASSEN STOP  \n",
+    "WANDELN SIE DIE NACHRICHT `n` IN GROSSBUCHSTABEN UM STOP  \n",
+    "FÜGEN SIE NACH JEDER NACHRICHT MITTELS `end` EIN `\" STOP\\n\"` HINZU STOP\n",
+    "\n",
+    "## Sauerstoff zu viert\n",
+    "\n",
+    "Vervollständigen Sie die Funktion `berechne_sauerstoff`, die zwei Zahlen\n",
+    "dividiert und die Berechnung sowie das Ergebnis (ohne `format`-Methode)\n",
+    "ausgibt. Z. B. für `minuten = 100` und `personen = 4` soll die Ausgabe\n",
+    "der Funktion wie folgt lauten:\n",
+    "`Der Sauerstoff reicht noch für 100 / 4 = 25.0 min.`\n",
+    "\n",
+    "## Nachricht empfangen\n",
+    "\n",
+    "Sie haben eine Nachricht empfangen, aber sie müssen die Argumente noch\n",
+    "mit der `format`-Methode in die Nachricht einsetzen, um sie vollständig\n",
+    "zu sehen.\n",
+    "\n",
+    "## Peilungen berechnen\n",
+    "\n",
+    "Sie erhalten die Koordinaten. Alle Koordinaten werden mit einer\n",
+    "`for`-Schleife durchlaufen und jeweils in `x` und `y` gespeichert.\n",
+    "Benutzen Sie `math.atan2(y, x) / math.pi * 180` um die Richtung und\n",
+    "`math.sqrt(x**2 + y**2)` um die Länge zu berechnen. Geben Sie sie aus\n",
+    "und addieren Sie jeweils die Länge zur `gesamtlaenge` dazu.\n",
+    "\n",
+    "## Dauer\n",
+    "\n",
+    "Ihre Freunde haben Ihnen die Koordinaten gesendet aus denen Sie die\n",
+    "Gesamtlänge `total` berechnet haben. Vervollständigen Sie die Funktion\n",
+    "`berechne_zeit`, die berechnet, wie lange Sie in Abhängigkeit von der\n",
+    "Geschwindigkeit unterwegs sind. Verwenden Sie die `format`-Methode mit\n",
+    "Variablenindizes oder -namen, sodass Sie die Variablen, die mehrfach\n",
+    "ausgegeben werden, nur einmal übergeben müssen. Geben Sie die Entfernung\n",
+    "beim ersten Vorkommen gerundet (mit 0 Nachkommastellen) und das Ergebnis\n",
+    "mit 1 Nachkommastelle an. Die Ausgabe der Funktion sollte beispielsweise\n",
+    "wie folgt lauten:\n",
+    "`Entfernung: 2000 m, Geschwindigkeit 0.5 m/s, ETA: 2000.0 / 0.5 s = 4000.0 s`\n",
+    "\n",
+    "## Temperatur\n",
+    "\n",
+    "Je näher Sie zum Ausgang kommen, desto mehr steigt die Temperatur.\n",
+    "Verwenden Sie einen f-String um die Temperatur mit einer Nachkommastelle\n",
+    "wie folgt auszugeben: `Die aktuelle Temperatur beträgt: 9.7°C`"
+   ],
+   "id": "0016-2edac2813418a11a4fadcf8e885c627b6ef5dde093849fcee9cfd5cd82a"
+  }
+ ],
+ "nbformat": 4,
+ "nbformat_minor": 5,
+ "metadata": {}
+}
+%% Cell type:markdown id:0003-6c5b9abc3cd82d9b962b2f7bfe07e1fde8b290aeca77d47a0a9b1f69e49 tags:
+
+# Höhlenrettung
+
+Sie sind in einer Höhle unter der Erde gestrandet und müssen dringend
+Hilfe rufen. Sie haben ein Kommunikationsgerät gefunden, das nur Python
+versteht. Verwenden Sie Python, um mit der Außenwelt zu kommunizieren.
+Lösen Sie die folgenden Aufgaben, um gerettet zu werden.
+
+## Statusmeldung
+
+Vervollständigen Sie die Funktion `sende_position`, die Ihre aktuelle
+Position, die Temperatur in der Höhle und den verbleibenden Sauerstoff
+in Prozent ausgeben soll. Verwenden Sie die `print`-Funktion und
+übergeben ihr **mehrere Argumente**. Die Informationen werden über die
+Argumente `position`, `temperatur` und `sauerstoff` gegeben. Wenn z. B.
+`position = "Tief in der Höhle"`, `temperatur = 8.5` und
+`sauerstoff = 35` sind, sollte die Ausgabe der Funktion wie folgt
+lauten:
+`Aktuelle Position: Tief in der Höhle Temperatur: 8.5 °C Sauerstoff: 35 %`
+
+%% Cell type:code id:0004-4c00cbd508cb6e116e1e649269b0caea2b592a88f48126f375aba906ce3 tags:
+
+``` 
+def sende_position(position, temperatur, sauerstoff):
+    print("")
+
+
+sende_position(position="Tief in der Höhle", temperatur=8.5, sauerstoff=35)
+```
+
+%% Cell type:markdown id:0016-2edac2813418a11a4fadcf8e885c627b6ef5dde093849fcee9cfd5cd82a tags:
+
+## Telegramm
+
+SIE MÜSSEN IHRE NACHRICHTEN ALS TELEGRAMM VERFASSEN STOP
+WANDELN SIE DIE NACHRICHT `n` IN GROSSBUCHSTABEN UM STOP
+FÜGEN SIE NACH JEDER NACHRICHT MITTELS `end` EIN `" STOP\n"` HINZU STOP
+
+## Sauerstoff zu viert
+
+Vervollständigen Sie die Funktion `berechne_sauerstoff`, die zwei Zahlen
+dividiert und die Berechnung sowie das Ergebnis (ohne `format`-Methode)
+ausgibt. Z. B. für `minuten = 100` und `personen = 4` soll die Ausgabe
+der Funktion wie folgt lauten:
+`Der Sauerstoff reicht noch für 100 / 4 = 25.0 min.`
+
+## Nachricht empfangen
+
+Sie haben eine Nachricht empfangen, aber sie müssen die Argumente noch
+mit der `format`-Methode in die Nachricht einsetzen, um sie vollständig
+zu sehen.
+
+## Peilungen berechnen
+
+Sie erhalten die Koordinaten. Alle Koordinaten werden mit einer
+`for`-Schleife durchlaufen und jeweils in `x` und `y` gespeichert.
+Benutzen Sie `math.atan2(y, x) / math.pi * 180` um die Richtung und
+`math.sqrt(x**2 + y**2)` um die Länge zu berechnen. Geben Sie sie aus
+und addieren Sie jeweils die Länge zur `gesamtlaenge` dazu.
+
+## Dauer
+
+Ihre Freunde haben Ihnen die Koordinaten gesendet aus denen Sie die
+Gesamtlänge `total` berechnet haben. Vervollständigen Sie die Funktion
+`berechne_zeit`, die berechnet, wie lange Sie in Abhängigkeit von der
+Geschwindigkeit unterwegs sind. Verwenden Sie die `format`-Methode mit
+Variablenindizes oder -namen, sodass Sie die Variablen, die mehrfach
+ausgegeben werden, nur einmal übergeben müssen. Geben Sie die Entfernung
+beim ersten Vorkommen gerundet (mit 0 Nachkommastellen) und das Ergebnis
+mit 1 Nachkommastelle an. Die Ausgabe der Funktion sollte beispielsweise
+wie folgt lauten:
+`Entfernung: 2000 m, Geschwindigkeit 0.5 m/s, ETA: 2000.0 / 0.5 s = 4000.0 s`
+
+## Temperatur
+
+Je näher Sie zum Ausgang kommen, desto mehr steigt die Temperatur.
+Verwenden Sie einen f-String um die Temperatur mit einer Nachkommastelle
+wie folgt auszugeben: `Die aktuelle Temperatur beträgt: 9.7°C`