Notebooks from ckaufmann/akis-python-framework@2a6cd272

580b66a0 · Christof Kaufmann · 858efcc3 · 580b66a0 · 580b66a0 · 580b66a0
Commit 580b66a0 authored 1 year ago by Christof Kaufmann
--- a/09-schleifen/05-primzahl-sol.ipynb
+++ b/09-schleifen/05-primzahl-sol.ipynb
@@ -6,20 +6,20 @@
   "source": [
    "# Primzahlüberprüfung\n",
    "\n",
-    "Schreibe ein Python-Programm, das eine gegebene Zahl überprüft und\n",
+    "Schreibe Python-Code, der eine gegebene Ganzzahl überprüft und\n",
-    "feststellt, ob sie eine Primzahl ist. Gib eine entsprechende Meldung\n",
+    "feststellt, ob sie eine Primzahl ist oder nicht. Gib eine entsprechende\n",
-    "aus.\n",
+    "Meldung aus.\n",
    "\n",
    "## Lösung\n",
    "\n",
-    "Das Programm überprüft, ob die gegebene Zahl eine Primzahl ist. Es\n",
+    "Das Programm überprüft, ob die gegebene Zahl eine Primzahl ist. Dazu\n",
-    "verwendet eine Schleife, um alle möglichen Teiler der Zahl zu\n",
+    "verwendet es eine Schleife, um alle möglichen Teiler der Zahl zu\n",
    "überprüfen. Wenn die Zahl größer als 1 ist und keine Teiler außer 1 und\n",
    "sich selbst hat, wird sie als Primzahl betrachtet.\n",
    "\n",
-    "Beispiel mit Eingabe der Zahl 17:"
+    "Beispiel mit der Zahl 17 (gerne ändern und ausprobieren):"
   ],
-   "id": "0004-45abbed0cc5f9665dc07c60e20b740be01af3ede8a2dd581c1a798065cd"
+   "id": "0004-631a272375d1f77e15d62eb115731c6f3edd197f858405d535382567123"
  },
  {
   "cell_type": "code",
@@ -30,23 +30,23 @@
     "output_type": "stream",
     "name": "stdout",
     "text": [
-      "Die Zahl ist eine Primzahl."
+      "Die Zahl 17 ist eine Primzahl."
     ]
    }
   ],
   "source": [
-    "number = int(input())\n",
+    "number = 17\n",
    "if number > 1:\n",
    "    for i in range(2, number):\n",
    "        if (number % i) == 0:\n",
-    "            print(\"Die Zahl ist keine Primzahl.\")\n",
+    "            print(f\"Die Zahl {number} ist keine Primzahl.\")\n",
    "            break\n",
    "    else:\n",
-    "        print(\"Die Zahl ist eine Primzahl.\")\n",
+    "        print(f\"Die Zahl {number} ist eine Primzahl.\")\n",
    "else:\n",
    "    print(\"Bitte eine Zahl > 1 eingeben!\")"
   ],
-   "id": "0005-d412019f7c5565c46ffe8cd2b5485e99ac1381b0fe32fc2a14f1fe6bed1"
+   "id": "0005-a263726b8bf87321e708402bc93e8d0e57dffd4d388fb87811288b9a068"
  }
 ],
 "nbformat": 4,

-%% Cell type:markdown id:0004-45abbed0cc5f9665dc07c60e20b740be01af3ede8a2dd581c1a798065cd tags:
+%% Cell type:markdown id:0004-631a272375d1f77e15d62eb115731c6f3edd197f858405d535382567123 tags:
 # Primzahlüberprüfung
-Schreibe ein Python-Programm, das eine gegebene Zahl überprüft und
+Schreibe Python-Code, der eine gegebene Ganzzahl überprüft und
-feststellt, ob sie eine Primzahl ist. Gib eine entsprechende Meldung
+feststellt, ob sie eine Primzahl ist oder nicht. Gib eine entsprechende
-aus.
+Meldung aus.
 ## Lösung
-Das Programm überprüft, ob die gegebene Zahl eine Primzahl ist. Es
+Das Programm überprüft, ob die gegebene Zahl eine Primzahl ist. Dazu
-verwendet eine Schleife, um alle möglichen Teiler der Zahl zu
+verwendet es eine Schleife, um alle möglichen Teiler der Zahl zu
 überprüfen. Wenn die Zahl größer als 1 ist und keine Teiler außer 1 und
 sich selbst hat, wird sie als Primzahl betrachtet.
-Beispiel mit Eingabe der Zahl 17:
+Beispiel mit der Zahl 17 (gerne ändern und ausprobieren):
-%% Cell type:code id:0005-d412019f7c5565c46ffe8cd2b5485e99ac1381b0fe32fc2a14f1fe6bed1 tags:
+%% Cell type:code id:0005-a263726b8bf87321e708402bc93e8d0e57dffd4d388fb87811288b9a068 tags:
 ``` 
-number = int(input())
+number = 17
 if number > 1:
    for i in range(2, number):
        if (number % i) == 0:
-            print("Die Zahl ist keine Primzahl.")
+            print(f"Die Zahl {number} ist keine Primzahl.")
            break
    else:
-        print("Die Zahl ist eine Primzahl.")
+        print(f"Die Zahl {number} ist eine Primzahl.")
 else:
    print("Bitte eine Zahl > 1 eingeben!")
 ```
 %% Output
-    Die Zahl ist eine Primzahl.
+    Die Zahl 17 ist eine Primzahl.

--- a/09-schleifen/05-primzahl.ipynb
+++ b/09-schleifen/05-primzahl.ipynb
@@ -6,13 +6,14 @@
   "source": [
    "# Primzahlüberprüfung\n",
    "\n",
-    "Schreibe ein Python-Programm, das eine gegebene Zahl überprüft und\n",
+    "Schreibe Python-Code, der eine gegebene Ganzzahl überprüft und\n",
-    "feststellt, ob sie eine Primzahl ist. Gib eine entsprechende Meldung\n",
+    "feststellt, ob sie eine Primzahl ist oder nicht. Gib eine entsprechende\n",
-    "aus.\n",
+    "Meldung aus.\n",
    "\n",
-    "Hier Ihr Code:"
+    "Hier der Start-Code mit der gegebenen Zahl. Ändere die Zahl um deinen\n",
+    "Code zu Testen"
   ],
-   "id": "0002-f170f4b48aae3449041a3aa0e522f0127ddf1d1db5ad05cd2fe73316840"
+   "id": "0002-8a9302f131e7b9c874ff5436c864987d87eae16881b9087929e44679f3e"
  },
  {
   "cell_type": "code",
@@ -21,8 +22,11 @@
    "style": "python"
   },
   "outputs": [],
-   "source": [],
+   "source": [
-   "id": "0003-44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    "number = 17\n",
+    "# TODO: Hier soll der Code folgen, um zu überprüfen, ob number eine Primzahl ist."
+   ],
+   "id": "0003-44b1ad186bf018f0e425b2d94de1b7eca507d8af0952d035ea65a941dc4"
  }
 ],
 "nbformat": 4,

-%% Cell type:markdown id:0002-f170f4b48aae3449041a3aa0e522f0127ddf1d1db5ad05cd2fe73316840 tags:
+%% Cell type:markdown id:0002-8a9302f131e7b9c874ff5436c864987d87eae16881b9087929e44679f3e tags:
 # Primzahlüberprüfung
-Schreibe ein Python-Programm, das eine gegebene Zahl überprüft und
+Schreibe Python-Code, der eine gegebene Ganzzahl überprüft und
-feststellt, ob sie eine Primzahl ist. Gib eine entsprechende Meldung
+feststellt, ob sie eine Primzahl ist oder nicht. Gib eine entsprechende
-aus.
+Meldung aus.
-Hier Ihr Code:
+Hier der Start-Code mit der gegebenen Zahl. Ändere die Zahl um deinen
+Code zu Testen
-%% Cell type:code id:0003-44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 tags:
+%% Cell type:code id:0003-44b1ad186bf018f0e425b2d94de1b7eca507d8af0952d035ea65a941dc4 tags:
 ``` 
+number = 17
+# TODO: Hier soll der Code folgen, um zu überprüfen, ob number eine Primzahl ist.
 ```

--- a/09-schleifen/10-ziffern-sol.ipynb
+++ b/09-schleifen/10-ziffern-sol.ipynb
@@ -10,15 +10,15 @@
    "natürlichen Zahl zählt und zurück gibt. Zum Beispiel hat die Zahl 36793\n",
    "5 Ziffern.\n",
    "\n",
-    "*Hinweis: Überlegen Sie was passiert, wenn Sie die Zahl mehrmals durch\n",
+    "*Hinweis: Eine Möglichkeit ist die Zahl mit einer `while`-Schleife durch\n",
-    "10 teilen.*\n",
+    "10 zu teilen.*\n",
    "\n",
    "## Lösung\n",
    "\n",
    "Wir können zählen, wie oft wir die Zahl durch 10 teilen können bis Sie\n",
    "kleiner als 1 ist:"
   ],
-   "id": "0004-ba8273a61cd5ee3cf29fb1725c1d209207a51b26af46ba984c24cd4e311"
+   "id": "0004-09d92a001128b5a1d52bd908462d13a3b5bbe3b15a4d6bf5403dcfc3101"
  },
  {
   "cell_type": "code",
@@ -28,15 +28,15 @@
   },
   "outputs": [],
   "source": [
-    "def num_digits(n):\n",
+    "def num_digits(number):\n",
-    "    count = 0\n",
+    "    digits = 0\n",
-    "    while n >= 1:\n",
+    "    while number >= 1:\n",
-    "        n /= 10\n",
+    "        number /= 10\n",
-    "        count += 1\n",
+    "        digits += 1\n",
    "\n",
-    "    return count"
+    "    return digits"
   ],
-   "id": "0005-3d52751bec5b374417e3808541b20015bf77698213526b0d5cc9f4de9cb"
+   "id": "0005-970c8e4bdc1e768b5cc6cdcb9dea95b96b95e0ebb725dd565c6c2a256c8"
  },
  {
   "cell_type": "markdown",
@@ -57,10 +57,10 @@
   "source": [
    "import math\n",
    "\n",
-    "def num_digits_log(n):\n",
+    "def num_digits_log(number):\n",
-    "    return math.floor(math.log10(n)) + 1"
+    "    return math.floor(math.log10(number)) + 1"
   ],
-   "id": "0007-d26ff8e32ba5ca68f1ae86ee9350e7a046e481be83b704735bdf2754151"
+   "id": "0007-a6668ee66acc394f7e0967942435ff6cdd1eb458cad0f6c08aba2b5a09d"
  },
  {
   "cell_type": "code",
@@ -204,9 +204,67 @@
    "Wenn negative Zahlen auch funktionieren sollen, müssten wir den\n",
    "Absolutwert der Zahl nehmen.\n",
    "\n",
+    "Eine weitere Möglichkeit für positive Ganzzahlen wäre die Zahl als\n",
+    "String umzuwandeln und die Länge des Strings zurückzugeben:"
+   ],
+   "id": "0017-16273a683278601f5847a7a4cce7c35fbc2dc31a0646ea0e028fd092ab7"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "style": "python"
+   },
+   "outputs": [],
+   "source": [
+    "def num_digits_str(number):\n",
+    "    return len(str(number))"
+   ],
+   "id": "0018-e2125b7eebe7242eefe3027a1208ca8d85d933756b9e53de9d0ffcfa9bd"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "2"
+     ]
+    }
+   ],
+   "source": [
+    "num_digits_str(99)"
+   ],
+   "id": "0019-b4bbfa70ae17178aeda7340e73c5244cc0e8230c31577a3f9528aea97f8"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "3"
+     ]
+    }
+   ],
+   "source": [
+    "num_digits_str(100)"
+   ],
+   "id": "0020-4433bc0812db6e77d1a7949b6d2d42f17ad314d378f2be0c0227180b2a7"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
    "## Tests"
   ],
-   "id": "0017-ce6bf6070cae9f3c08ac3f283618ec70b0ce4a92d49b96d641bd3ac8802"
+   "id": "0021-372eb0d1de051c603302b93ade3cf670777fb8a6b5cf61edddc34915eba"
  },
  {
   "cell_type": "code",
@@ -224,7 +282,7 @@
   "source": [
    "num_digits(768943)"
   ],
-   "id": "0018-68bcd2dd43e415b496a5c62b9cef8c019a704e8b292ca7b42ab02ca4a8b"
+   "id": "0022-68bcd2dd43e415b496a5c62b9cef8c019a704e8b292ca7b42ab02ca4a8b"
  },
  {
   "cell_type": "code",
@@ -242,7 +300,7 @@
   "source": [
    "num_digits(99)"
   ],
-   "id": "0019-88a912f6cf444a79b47e8e5069f83c8c349304af9dccfa0d55f0e54b4a6"
+   "id": "0023-88a912f6cf444a79b47e8e5069f83c8c349304af9dccfa0d55f0e54b4a6"
  },
  {
   "cell_type": "code",
@@ -260,7 +318,7 @@
   "source": [
    "num_digits(100)"
   ],
-   "id": "0020-b61c7af3abe0d56725627a05f5c42c40ac637aebd6ce46514fe7aa5397b"
+   "id": "0024-b61c7af3abe0d56725627a05f5c42c40ac637aebd6ce46514fe7aa5397b"
  },
  {
   "cell_type": "code",
@@ -278,7 +336,7 @@
   "source": [
    "num_digits(101)"
   ],
-   "id": "0021-86a532d95a0bd5125fc6216d917337a4d720942b686eb070896976dcfa9"
+   "id": "0025-86a532d95a0bd5125fc6216d917337a4d720942b686eb070896976dcfa9"
  }
 ],
 "nbformat": 4,

-%% Cell type:markdown id:0004-ba8273a61cd5ee3cf29fb1725c1d209207a51b26af46ba984c24cd4e311 tags:
+%% Cell type:markdown id:0004-09d92a001128b5a1d52bd908462d13a3b5bbe3b15a4d6bf5403dcfc3101 tags:
 # Ziffern
 Schreiben Sie eine Funktion `num_digits`, die die Anzahl Ziffern einer
 natürlichen Zahl zählt und zurück gibt. Zum Beispiel hat die Zahl 36793
 5 Ziffern.
-*Hinweis: Überlegen Sie was passiert, wenn Sie die Zahl mehrmals durch
+*Hinweis: Eine Möglichkeit ist die Zahl mit einer `while`-Schleife durch
-10 teilen.*
+10 zu teilen.*
 ## Lösung
 Wir können zählen, wie oft wir die Zahl durch 10 teilen können bis Sie
 kleiner als 1 ist:
-%% Cell type:code id:0005-3d52751bec5b374417e3808541b20015bf77698213526b0d5cc9f4de9cb tags:
+%% Cell type:code id:0005-970c8e4bdc1e768b5cc6cdcb9dea95b96b95e0ebb725dd565c6c2a256c8 tags:
 ``` 
-def num_digits(n):
+def num_digits(number):
-    count = 0
+    digits = 0
-    while n >= 1:
+    while number >= 1:
-        n /= 10
+        number /= 10
-        count += 1
+        digits += 1
-    return count
+    return digits
 ```
 %% Cell type:markdown id:0006-06e9ca07978b11c95606566a74e70294d837cde8cb48399c5a6c4bc1cf0 tags:
 Alternativ kann man auch die Anzahl der Ziffern direkt mit
 $\lfloor \log_{10} n \rfloor + 1$ ausrechnen:
-%% Cell type:code id:0007-d26ff8e32ba5ca68f1ae86ee9350e7a046e481be83b704735bdf2754151 tags:
+%% Cell type:code id:0007-a6668ee66acc394f7e0967942435ff6cdd1eb458cad0f6c08aba2b5a09d tags:
 ``` 
 import math
-def num_digits_log(n):
+def num_digits_log(number):
-    return math.floor(math.log10(n)) + 1
+    return math.floor(math.log10(number)) + 1
 ```
 %% Cell type:code id:0008-05ec850732599d27ff19d943bd0f2f6636c1fad9d3477702e240e133ef3 tags:
 ``` 
 num_digits_log(99)
 ```
 %% Output
    2
 %% Cell type:code id:0009-5ba8b4daa9b5eee5e9afd9346c13d8789931992816748af8dc50d57047e tags:
 ``` 
 num_digits_log(100)
 ```
 %% Output
    3
 %% Cell type:code id:0010-f576e7e5bd6cd2d08f393567b9d3038d72e1cddcc24e522c14ae0725fb3 tags:
 ``` 
 num_digits_log(101)
 ```
 %% Output
    3
 %% Cell type:markdown id:0011-447c95814d229e0932e47587bcb1dbc9b7f96f0f332b32c94fe4be0020b tags:
 Übrigens funktionieren reelle Zahlen auch und zählt wie viele Ziffern
 vor dem Dezimalzeichen stehen:
 %% Cell type:code id:0012-f2649038ccafd224faf147ee9c2689d315d8b207e5c3110fbac901f0c8a tags:
 ``` 
 num_digits(9.8765)
 ```
 %% Output
    1
 %% Cell type:code id:0013-d672ff755babb71d675c2049f4f7bcaf6e89efa75f1ecbaeadb9b8a08ab tags:
 ``` 
 num_digits_log(9.8765)
 ```
 %% Output
    1
 %% Cell type:code id:0014-819b6d27dbea78e0cafe3bcf0c91c617cf40b4bb24c1eefc21e023c0e36 tags:
 ``` 
 num_digits(10.00001)
 ```
 %% Output
    2
 %% Cell type:code id:0015-d179d40bbd39e7a22936a4780a1fb7aa54c63e3128cb734b01e249c6280 tags:
 ``` 
 num_digits_log(10.00001)
 ```
 %% Output
    2
-%% Cell type:markdown id:0017-ce6bf6070cae9f3c08ac3f283618ec70b0ce4a92d49b96d641bd3ac8802 tags:
+%% Cell type:markdown id:0017-16273a683278601f5847a7a4cce7c35fbc2dc31a0646ea0e028fd092ab7 tags:
 Wenn negative Zahlen auch funktionieren sollen, müssten wir den
 Absolutwert der Zahl nehmen.
+Eine weitere Möglichkeit für positive Ganzzahlen wäre die Zahl als
+String umzuwandeln und die Länge des Strings zurückzugeben:
+%% Cell type:code id:0018-e2125b7eebe7242eefe3027a1208ca8d85d933756b9e53de9d0ffcfa9bd tags:
+``` 
+def num_digits_str(number):
+    return len(str(number))
+```
+%% Cell type:code id:0019-b4bbfa70ae17178aeda7340e73c5244cc0e8230c31577a3f9528aea97f8 tags:
+``` 
+num_digits_str(99)
+```
+%% Output
+    2
+%% Cell type:code id:0020-4433bc0812db6e77d1a7949b6d2d42f17ad314d378f2be0c0227180b2a7 tags:
+``` 
+num_digits_str(100)
+```
+%% Output
+    3
+%% Cell type:markdown id:0021-372eb0d1de051c603302b93ade3cf670777fb8a6b5cf61edddc34915eba tags:
 ## Tests
-%% Cell type:code id:0018-68bcd2dd43e415b496a5c62b9cef8c019a704e8b292ca7b42ab02ca4a8b tags:
+%% Cell type:code id:0022-68bcd2dd43e415b496a5c62b9cef8c019a704e8b292ca7b42ab02ca4a8b tags:
 ``` 
 num_digits(768943)
 ```
 %% Output
    6
-%% Cell type:code id:0019-88a912f6cf444a79b47e8e5069f83c8c349304af9dccfa0d55f0e54b4a6 tags:
+%% Cell type:code id:0023-88a912f6cf444a79b47e8e5069f83c8c349304af9dccfa0d55f0e54b4a6 tags:
 ``` 
 num_digits(99)
 ```
 %% Output
    2
-%% Cell type:code id:0020-b61c7af3abe0d56725627a05f5c42c40ac637aebd6ce46514fe7aa5397b tags:
+%% Cell type:code id:0024-b61c7af3abe0d56725627a05f5c42c40ac637aebd6ce46514fe7aa5397b tags:
 ``` 
 num_digits(100)
 ```
 %% Output
    3
-%% Cell type:code id:0021-86a532d95a0bd5125fc6216d917337a4d720942b686eb070896976dcfa9 tags:
+%% Cell type:code id:0025-86a532d95a0bd5125fc6216d917337a4d720942b686eb070896976dcfa9 tags:
 ``` 
 num_digits(101)
 ```
 %% Output
    3

--- a/09-schleifen/10-ziffern.ipynb
+++ b/09-schleifen/10-ziffern.ipynb
@@ -10,12 +10,12 @@
    "natürlichen Zahl zählt und zurück gibt. Zum Beispiel hat die Zahl 36793\n",
    "5 Ziffern.\n",
    "\n",
-    "*Hinweis: Überlegen Sie was passiert, wenn Sie die Zahl mehrmals durch\n",
+    "*Hinweis: Eine Möglichkeit ist die Zahl mit einer `while`-Schleife durch\n",
-    "10 teilen.*\n",
+    "10 zu teilen.*\n",
    "\n",
-    "Hier Ihr Code:"
+    "Hier der Startcode, indem `digits` die Anzahl ziffern enthalten soll."
   ],
-   "id": "0003-7075471035d2df931c3730f5f8176b13bc5bbcf8f31a946a79c268a52cc"
+   "id": "0003-fabf949d7df98be055f96351c14edc12217b6c59af637a71aadb268a513"
  },
  {
   "cell_type": "code",
@@ -24,8 +24,15 @@
    "style": "python"
   },
   "outputs": [],
-   "source": [],
+   "source": [
-   "id": "0004-44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    "def num_digits(number):\n",
+    "    digits = 0\n",
+    "    # TODO: zählen Sie hier in digits die Anzahl Ziffern von number\n",
+    "\n",
+    "\n",
+    "    return digits"
+   ],
+   "id": "0004-ff1bbeedb545d7cfe7c76d6b42df9dc13458c61720c5e6e4d5dd21e3312"
  },
  {
   "cell_type": "markdown",

-%% Cell type:markdown id:0003-7075471035d2df931c3730f5f8176b13bc5bbcf8f31a946a79c268a52cc tags:
+%% Cell type:markdown id:0003-fabf949d7df98be055f96351c14edc12217b6c59af637a71aadb268a513 tags:
 # Ziffern
 Schreiben Sie eine Funktion `num_digits`, die die Anzahl Ziffern einer
 natürlichen Zahl zählt und zurück gibt. Zum Beispiel hat die Zahl 36793
 5 Ziffern.
-*Hinweis: Überlegen Sie was passiert, wenn Sie die Zahl mehrmals durch
+*Hinweis: Eine Möglichkeit ist die Zahl mit einer `while`-Schleife durch
-10 teilen.*
+10 zu teilen.*
-Hier Ihr Code:
+Hier der Startcode, indem `digits` die Anzahl ziffern enthalten soll.
-%% Cell type:code id:0004-44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 tags:
+%% Cell type:code id:0004-ff1bbeedb545d7cfe7c76d6b42df9dc13458c61720c5e6e4d5dd21e3312 tags:
 ``` 
+def num_digits(number):
+    digits = 0
+    # TODO: zählen Sie hier in digits die Anzahl Ziffern von number
+    return digits
 ```
 %% Cell type:markdown id:0005-372eb0d1de051c603302b93ade3cf670777fb8a6b5cf61edddc34915eba tags:
 ## Tests
 %% Cell type:code id:0006-68bcd2dd43e415b496a5c62b9cef8c019a704e8b292ca7b42ab02ca4a8b tags:
 ``` 
 num_digits(768943)
 ```
 %% Output
    6
 %% Cell type:code id:0007-88a912f6cf444a79b47e8e5069f83c8c349304af9dccfa0d55f0e54b4a6 tags:
 ``` 
 num_digits(99)
 ```
 %% Output
    2
 %% Cell type:code id:0008-b61c7af3abe0d56725627a05f5c42c40ac637aebd6ce46514fe7aa5397b tags:
 ``` 
 num_digits(100)
 ```
 %% Output
    3
 %% Cell type:code id:0009-86a532d95a0bd5125fc6216d917337a4d720942b686eb070896976dcfa9 tags:
 ``` 
 num_digits(101)
 ```
 %% Output
    3

--- a/09-schleifen/11-kasse-sol.ipynb
+++ b/09-schleifen/11-kasse-sol.ipynb
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Kasse\n",
+    "\n",
+    "Schreiben Sie Python-Code um Preise aufzusummieren. Die Preise werden\n",
+    "jeweils\n",
+    "\n",
+    "-   vom Prompt mittels `input('Preis: ')` als String eingelesen,\n",
+    "-   zu `float` umgewandelt,\n",
+    "-   auf die bestehende Summe dazuaddiert und\n",
+    "-   anschließend wird die Summe mit zwei Nachkommastellen ausgegeben.\n",
+    "\n",
+    "Das alles wird so lange wiederholt, bis eine leere Eingabe (`''`) kommt.\n",
+    "Beispielverlauf:\n",
+    "\n",
+    "``` output\n",
+    "Kasse. Geben Sie Preise ein um sie aufzusummieren.\n",
+    "Preis: 5      # Hier wurde 5 eingegeben\n",
+    "Summe: 5.00\n",
+    "Preis: 7      # Hier wurde 7 eingegeben\n",
+    "Summe: 12.00\n",
+    "Preis: 3.666  # Hier wurde 3.666 eingegeben\n",
+    "Summe: 15.67\n",
+    "Preis:        # leere Eingabe heißt Ende\n",
+    "```\n",
+    "\n",
+    "*Hinweis: Nutzen Sie entweder eine `while True`-Schleife und brechen im\n",
+    "Falle eines leeren Inputs die Schleife mittels `break` ab oder verwenden\n",
+    "Sie eine `while`-Schleife mit Zuweisungsausdruck (assignment\n",
+    "expression).*\n",
+    "\n",
+    "## Lösung\n",
+    "\n",
+    "Ein Lösungsvorschlag mit den Eingaben aus dem Beispiel der\n",
+    "Aufgabenstellung:"
+   ],
+   "id": "0007-567f8e1c3c1d90a43a30b8dbd7ebf23b782e78f00aef2594cbcca27c62c"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "Kasse. Geben Sie Preise ein um sie aufzusummieren."
+     ]
+    }
+   ],
+   "source": [
+    "print('Kasse. Geben Sie Preise ein um sie aufzusummieren.')"
+   ],
+   "id": "0008-a69bc793a8cc96b00cea5a6e92015d19588e63b6330bf6abfd74c268505"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "Preis: 5\n",
+      "Summe: 5.00\n",
+      "Preis: 7\n",
+      "Summe: 12.00\n",
+      "Preis: 3.666\n",
+      "Summe: 15.67\n",
+      "Preis:"
+     ]
+    }
+   ],
+   "source": [
+    "sum = 0\n",
+    "while True:\n",
+    "    s = input('Preis: ')\n",
+    "    if s == '':\n",
+    "        break\n",
+    "\n",
+    "    price = float(s)\n",
+    "    sum += price\n",
+    "    print(f'Summe: {sum:.2f}')"
+   ],
+   "id": "0009-ce08d3c32e88ff20e39989450ab5f157f470ad6807dbc147eb358fef144"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Das ganze lässt sich mit ähnlichem Verhalten auch mit\n",
+    "Zuweisungsausdrücken (assignment expressions) etwas kürzer schreiben:"
+   ],
+   "id": "0010-6bfd8393679c8628e3939a981f76bfdb5f5ff4845d0b9cafc8649cc7f1f"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "Preis: 5\n",
+      "Summe: 5.00\n",
+      "Preis: 7\n",
+      "Summe: 12.00\n",
+      "Preis: 3.666\n",
+      "Summe: 15.67\n",
+      "Preis:"
+     ]
+    }
+   ],
+   "source": [
+    "sum = 0\n",
+    "while s := input('Preis: '):\n",
+    "    price = float(s)\n",
+    "    sum += price\n",
+    "    print(f'Summe: {sum:.2f}')"
+   ],
+   "id": "0011-1e7ce8efe99b38ee4c78433dca285e375570ca523dde6c43ef7496f58e3"
+  }
+ ],
+ "nbformat": 4,
+ "nbformat_minor": 5,
+ "metadata": {}
+}
+%% Cell type:markdown id:0007-567f8e1c3c1d90a43a30b8dbd7ebf23b782e78f00aef2594cbcca27c62c tags:
+# Kasse
+Schreiben Sie Python-Code um Preise aufzusummieren. Die Preise werden
+jeweils
+-   vom Prompt mittels `input('Preis: ')` als String eingelesen,
+-   zu `float` umgewandelt,
+-   auf die bestehende Summe dazuaddiert und
+-   anschließend wird die Summe mit zwei Nachkommastellen ausgegeben.
+Das alles wird so lange wiederholt, bis eine leere Eingabe (`''`) kommt.
+Beispielverlauf:
+``` output
+Kasse. Geben Sie Preise ein um sie aufzusummieren.
+Preis: 5      # Hier wurde 5 eingegeben
+Summe: 5.00
+Preis: 7      # Hier wurde 7 eingegeben
+Summe: 12.00
+Preis: 3.666  # Hier wurde 3.666 eingegeben
+Summe: 15.67
+Preis:        # leere Eingabe heißt Ende
+```
+*Hinweis: Nutzen Sie entweder eine `while True`-Schleife und brechen im
+Falle eines leeren Inputs die Schleife mittels `break` ab oder verwenden
+Sie eine `while`-Schleife mit Zuweisungsausdruck (assignment
+expression).*
+## Lösung
+Ein Lösungsvorschlag mit den Eingaben aus dem Beispiel der
+Aufgabenstellung:
+%% Cell type:code id:0008-a69bc793a8cc96b00cea5a6e92015d19588e63b6330bf6abfd74c268505 tags:
+``` 
+print('Kasse. Geben Sie Preise ein um sie aufzusummieren.')
+```
+%% Output
+    Kasse. Geben Sie Preise ein um sie aufzusummieren.
+%% Cell type:code id:0009-ce08d3c32e88ff20e39989450ab5f157f470ad6807dbc147eb358fef144 tags:
+``` 
+sum = 0
+while True:
+    s = input('Preis: ')
+    if s == '':
+        break
+    price = float(s)
+    sum += price
+    print(f'Summe: {sum:.2f}')
+```
+%% Output
+    Preis: 5
+    Summe: 5.00
+    Preis: 7
+    Summe: 12.00
+    Preis: 3.666
+    Summe: 15.67
+    Preis:
+%% Cell type:markdown id:0010-6bfd8393679c8628e3939a981f76bfdb5f5ff4845d0b9cafc8649cc7f1f tags:
+Das ganze lässt sich mit ähnlichem Verhalten auch mit
+Zuweisungsausdrücken (assignment expressions) etwas kürzer schreiben:
+%% Cell type:code id:0011-1e7ce8efe99b38ee4c78433dca285e375570ca523dde6c43ef7496f58e3 tags:
+``` 
+sum = 0
+while s := input('Preis: '):
+    price = float(s)
+    sum += price
+    print(f'Summe: {sum:.2f}')
+```
+%% Output
+    Preis: 5
+    Summe: 5.00
+    Preis: 7
+    Summe: 12.00
+    Preis: 3.666
+    Summe: 15.67
+    Preis:
--- a/09-schleifen/11-kasse.ipynb
+++ b/09-schleifen/11-kasse.ipynb
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Kasse\n",
+    "\n",
+    "Schreiben Sie Python-Code um Preise aufzusummieren. Die Preise werden\n",
+    "jeweils\n",
+    "\n",
+    "-   vom Prompt mittels `input('Preis: ')` als String eingelesen,\n",
+    "-   zu `float` umgewandelt,\n",
+    "-   auf die bestehende Summe dazuaddiert und\n",
+    "-   anschließend wird die Summe mit zwei Nachkommastellen ausgegeben.\n",
+    "\n",
+    "Das alles wird so lange wiederholt, bis eine leere Eingabe (`''`) kommt.\n",
+    "Beispielverlauf:\n",
+    "\n",
+    "``` output\n",
+    "Kasse. Geben Sie Preise ein um sie aufzusummieren.\n",
+    "Preis: 5      # Hier wurde 5 eingegeben\n",
+    "Summe: 5.00\n",
+    "Preis: 7      # Hier wurde 7 eingegeben\n",
+    "Summe: 12.00\n",
+    "Preis: 3.666  # Hier wurde 3.666 eingegeben\n",
+    "Summe: 15.67\n",
+    "Preis:        # leere Eingabe heißt Ende\n",
+    "```\n",
+    "\n",
+    "*Hinweis: Nutzen Sie entweder eine `while True`-Schleife und brechen im\n",
+    "Falle eines leeren Inputs die Schleife mittels `break` ab oder verwenden\n",
+    "Sie eine `while`-Schleife mit Zuweisungsausdruck (assignment\n",
+    "expression).*\n",
+    "\n",
+    "Hier ihr Code:"
+   ],
+   "id": "0006-715feb4ca62eadf660c7420c11689bc8cc39a6788bdc5197167ef8847cc"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "style": "python"
+   },
+   "outputs": [],
+   "source": [
+    "print('Kasse. Geben Sie Zahlen ein um sie zu summieren.')\n",
+    "sum = 0"
+   ],
+   "id": "0007-73aa935cf10f9c2f580e227af7700bd0680fae4b3ff8f9dcefd1307e5e9"
+  }
+ ],
+ "nbformat": 4,
+ "nbformat_minor": 5,
+ "metadata": {}
+}
+%% Cell type:markdown id:0006-715feb4ca62eadf660c7420c11689bc8cc39a6788bdc5197167ef8847cc tags:
+# Kasse
+Schreiben Sie Python-Code um Preise aufzusummieren. Die Preise werden
+jeweils
+-   vom Prompt mittels `input('Preis: ')` als String eingelesen,
+-   zu `float` umgewandelt,
+-   auf die bestehende Summe dazuaddiert und
+-   anschließend wird die Summe mit zwei Nachkommastellen ausgegeben.
+Das alles wird so lange wiederholt, bis eine leere Eingabe (`''`) kommt.
+Beispielverlauf:
+``` output
+Kasse. Geben Sie Preise ein um sie aufzusummieren.
+Preis: 5      # Hier wurde 5 eingegeben
+Summe: 5.00
+Preis: 7      # Hier wurde 7 eingegeben
+Summe: 12.00
+Preis: 3.666  # Hier wurde 3.666 eingegeben
+Summe: 15.67
+Preis:        # leere Eingabe heißt Ende
+```
+*Hinweis: Nutzen Sie entweder eine `while True`-Schleife und brechen im
+Falle eines leeren Inputs die Schleife mittels `break` ab oder verwenden
+Sie eine `while`-Schleife mit Zuweisungsausdruck (assignment
+expression).*
+Hier ihr Code:
+%% Cell type:code id:0007-73aa935cf10f9c2f580e227af7700bd0680fae4b3ff8f9dcefd1307e5e9 tags:
+``` 
+print('Kasse. Geben Sie Zahlen ein um sie zu summieren.')
+sum = 0
+```
--- a/09-schleifen/11-klammernpaare-sol.ipynb
+++ b/09-schleifen/11-klammernpaare-sol.ipynb
--- a/09-schleifen/11-klammernpaare.ipynb
+++ b/09-schleifen/11-klammernpaare.ipynb