{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DS 7 – Übung: for- oder while-Schleife?\n",
    "**Informatik 10 – MINT-Zweig | Textuelle Programmierung und Datenstrukturen**\n",
    "\n",
    "## Lernziele\n",
    "Ich kann\n",
    "- für eine Aufgabe begründet zwischen for- und while-Schleife wählen,\n",
    "- ein Programm mit Schleife lesen und seine Ausgabe vorhersagen,\n",
    "- Summen und Produkte mit einer Schleife berechnen,\n",
    "- Eingaben mit einer while-Schleife wiederholen lassen,\n",
    "- meine Programme mit sinnvoll gewählten Testfällen überprüfen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "sprachhilfe"
    ]
   },
   "source": [
    "## 🗣️ Sprachhilfe\n",
    "- *„Ich nehme for, weil das besser ist.“* → „Ich verwende eine for-Schleife, weil die Anzahl der Durchläufe beim Start feststeht: Es werden genau `n` Zahlen multipliziert.“\n",
    "- *„Ich nehme while, weil man nicht weiß, wie oft.“* → „Ich verwende eine while-Schleife, weil das Ende von der Eingabe abhängt: Sie läuft, solange das Passwort falsch ist.“\n",
    "- *„Es hört auf.“* → „Die Schleife terminiert, weil `zahl` in jedem Durchlauf größer wird.“"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Worum es geht\n",
    "Du kennst zwei Schleifenarten. Heute übst du, beide sicher einzusetzen. Bei jeder Aufgabe überlegst du **zuerst**, welche Schleifenart besser passt, und begründest deine Wahl. Erst dann programmierst du.\n",
    "\n",
    "## 1 Das brauchst du\n",
    "\n",
    "| | for-Schleife | while-Schleife |\n",
    "|:--|:--|:--|\n",
    "| Wann? | Anzahl der Durchläufe steht beim Start fest | Ende hängt von einer Bedingung ab |\n",
    "| Kopf | `for i in range(1, 6):` | `while zahl != 0:` |\n",
    "| Startwert | steckt in `range` | vor der Schleife selbst setzen |\n",
    "| Veränderung | automatisch | im Rumpf selbst programmieren |\n",
    "| Gefahr | Stoppwert gehört nicht dazu | Endlosschleife |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1, 4):\n",
    "    print(\"Durchlauf\", i)\n",
    "\n",
    "zahl = 1\n",
    "while zahl < 10:\n",
    "    print(\"zahl ist\", zahl)\n",
    "    zahl = zahl * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 📌 **Merksatz:** **for-Schleife:** Die Anzahl der Durchläufe steht vorher fest. **while-Schleife:** Das Ende hängt von einer Bedingung ab. Überlege bei jeder Aufgabe **zuerst**, welche Schleifenart passt!\n",
    "\n",
    "Zwei Muster brauchst du immer wieder:\n",
    "- **Zusammenzählen:** Summenvariable **vor** der Schleife auf `0`, **in** der Schleife erhöhen, **nach** der Schleife ausgeben.\n",
    "- **Eingaben wiederholen:** erste Eingabe **vor** der while-Schleife, Bedingung prüft die Eingabe, nächste Eingabe **am Ende** des Rumpfs.\n",
    "\n",
    "> 💡 **So testest du ein Programm mit Schleife:** nicht nur eine „normale“ Eingabe, sondern auch die kleinste erlaubte Zahl (oft 0 oder 1), eine Eingabe, bei der die Schleife **gar nicht** läuft, und eine, bei der sie sehr oft läuft. Rechne das erwartete Ergebnis **vorher** von Hand aus.\n",
    "\n",
    "### 🔮 Übung 1 – Programm lesen\n",
    "Lies das Programm, **ohne** es auszuführen.\n",
    "1. Was gibt es aus?\n",
    "2. Wie oft wird der Schleifenrumpf ausgeführt? Lege dazu ein Ablaufprotokoll an.\n",
    "3. Warum wird hier eine while-Schleife verwendet?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahl = 1\n",
    "while zahl < 50:\n",
    "    zahl = zahl * 3\n",
    "print(zahl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Schritt | Zeile | Anweisung | `zahl` |\n",
    "|:-:|:-:|:--|:-:|\n",
    "| 1 | 1 | `zahl = 1` | `1` |\n",
    "| 2 | 2 | `while zahl < 50:` | |\n",
    "| 3 | 3 | `zahl = zahl * 3` | |\n",
    "| … | | | |\n",
    "\n",
    "**Meine Antworten:**\n",
    "\n",
    "…"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📝 Übungen: Schritt für Schritt selbstständig\n",
    "Das **Musterbeispiel** ist ganz vorgemacht. Bei Übung 2 füllst du Lücken `___`, bei Übung 3 steht nur noch ein Gerüst aus Kommentaren, Übung 4 und die Zusatzaufgabe schreibst du allein.\n",
    "\n",
    "| Schritt | Frage |\n",
    "|:-:|:--|\n",
    "| 0 | **Schleifenart wählen und begründen:** Steht beim Start fest, wie oft wiederholt wird? |\n",
    "| 1 | **Vor der Schleife:** Welche Variablen brauchen einen Startwert? Welche erste Eingabe? |\n",
    "| 2 | **Schleifenkopf:** `range(...)` oder Bedingung? |\n",
    "| 3 | **Rumpf:** Was passiert pro Durchlauf? |\n",
    "| 4 | **Nach der Schleife:** Was wird ausgegeben? Testfälle mit Grenzfällen. |\n",
    "\n",
    "### 🧩 Musterbeispiel (vorgemacht) – Notendurchschnitt\n",
    "Aufgabe: Das Programm fragt, wie viele Noten es sind. Dann liest es die Noten ein und gibt den Durchschnitt aus.\n",
    "\n",
    "0. **Begründung:** Eine for-Schleife passt. Sobald die Anzahl `n` eingegeben ist, steht fest, dass genau `n` Noten eingelesen werden.\n",
    "1. **Vor der Schleife:** `n` einlesen, Summenvariable `summe = 0`.\n",
    "2. **Schleifenkopf:** `for i in range(1, n + 1):`, damit `i` die Nummer der Note ist (1 bis `n`).\n",
    "3. **Rumpf:** eine Note einlesen und zur Summe addieren.\n",
    "4. **Nach der Schleife:** Durchschnitt `summe / n` ausgeben, auf zwei Stellen gerundet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Schritt 1: vor der Schleife\n",
    "n = int(input(\"Wie viele Noten? \"))\n",
    "summe = 0\n",
    "\n",
    "# Schritt 2 und 3: Schleifenkopf und Rumpf\n",
    "for i in range(1, n + 1):\n",
    "    note = int(input(\"Note \" + str(i) + \": \"))\n",
    "    summe += note\n",
    "\n",
    "# Schritt 4: nach der Schleife\n",
    "print(\"Durchschnitt:\", round(summe / n, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Testfälle: Noten 2, 3, 1 → Durchschnitt 2.0. Eine einzige Note 4 → 4.0 (die Schleife läuft genau einmal). Bei `n = 0` bricht das Programm mit `ZeroDivisionError` ab: Wie könnte man das mit einer Verzweigung abfangen?\n",
    "\n",
    "### 📝 Übung 2 – Passwortabfrage (Lücken füllen)\n",
    "Frage so lange nach einem Passwort, bis `informatik10` eingegeben wurde. Gib danach „Zugang gewährt“ aus.\n",
    "\n",
    "1. **Begründe zuerst:** Welche Schleifenart passt?\n",
    "2. Ersetze jedes `___`.\n",
    "\n",
    "Testfälle: sofort richtig; `geheim`, dann `Informatik10`, dann `informatik10` (Python unterscheidet Groß- und Kleinschreibung).\n",
    "\n",
    "**Begründung:** …"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "passwort = ___(\"Passwort eingeben: \")\n",
    "while passwort ___ \"informatik10\":\n",
    "    passwort = ___(\"Falsch! Erneut versuchen: \")\n",
    "print(___)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 📝 Übung 3 – Fakultät (mit Gerüst)\n",
    "In der Mathematik schreibt man $n!$ („n Fakultät“) für das Produkt aller ganzen Zahlen von 1 bis $n$: $4! = 1 \\cdot 2 \\cdot 3 \\cdot 4 = 24$. Für $0!$ legt man den Wert 1 fest. Die Fakultät gibt zum Beispiel an, auf wie viele Arten man $n$ Personen in einer Reihe aufstellen kann.\n",
    "\n",
    "1. **Begründe zuerst:** Welche Schleifenart passt?\n",
    "2. Ersetze die Kommentare durch Programmzeilen.\n",
    "\n",
    "> 💡 **Tipp:** Die Fakultät berechnest du fast wie eine Summe, nur wird multipliziert. Mit welchem Wert muss die Produktvariable **vor** der Schleife starten? Was passiert mit 0?\n",
    "\n",
    "Kontrolle: 5 → `5! = 120`, 1 → `1! = 1`, 0 → `0! = 1`, 10 → `10! = 3628800`.\n",
    "\n",
    "**Begründung:** …"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# n als Ganzzahl einlesen\n",
    "# Produktvariable mit passendem Startwert\n",
    "# Schleife: i von 1 bis einschließlich n\n",
    "#     Produkt mit i multiplizieren\n",
    "# Ergebnis ausgeben, z. B. 5! = 120"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 📝 Übung 4 – Primzahl-Test (selbstständig)\n",
    "Eine **Primzahl** ist eine natürliche Zahl größer als 1, die nur durch 1 und durch sich selbst teilbar ist: 2, 3, 5, 7, 11, 13, … Die 9 ist keine, weil sie durch 3 teilbar ist. Die 1 ist nach Festlegung keine Primzahl.\n",
    "\n",
    "Prüfe, ob eine eingegebene Zahl eine Primzahl ist. Teste dazu, ob sie durch eine Zahl zwischen 2 und sich selbst minus 1 teilbar ist (`zahl % teiler == 0`).\n",
    "\n",
    "> 💡 **Tipp:** Arbeite mit einer Variablen, die sich ein Ergebnis merkt. Nimm zuerst an, die Zahl **ist** eine Primzahl: `ist_primzahl = True`. Findest du einen Teiler, war die Annahme falsch. Denke an den Sonderfall 1.\n",
    "\n",
    "Lege zuerst die Testfälle fest:\n",
    "\n",
    "| Eingabe | erwartete Ausgabe | Warum testen? |\n",
    "|:-:|:--|:--|\n",
    "| `7` | | |\n",
    "| `9` | | |\n",
    "| `2` | | |\n",
    "| `1` | | |\n",
    "| `97` | | |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Übung 4 – Primzahl-Test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🚀 Zusatzaufgabe – Sparziel (selbstständig)\n",
    "Auf einem Sparkonto liegen 100 €. Jedes Jahr kommen 5 % Zinsen dazu, das Guthaben wird also mit 1.05 multipliziert. Nach wie vielen Jahren beträgt es zum ersten Mal mindestens 200 €? Gib die Anzahl der Jahre und das Guthaben auf Cent gerundet aus. Begründe deine Wahl der Schleifenart.\n",
    "\n",
    "Für Schnelle: Beim Primzahl-Test prüft die for-Schleife weiter, auch wenn längst ein Teiler gefunden ist. Schreibe eine Fassung mit while, die beim ersten Teiler aufhört."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Zusatzaufgabe – Sparziel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📌 Das Wichtigste in Kürze\n",
    "- Erst die Schleifenart wählen und begründen: Steht die Anzahl beim Start fest → `for`, sonst → `while`.\n",
    "- Summe startet bei `0`, Produkt startet bei `1`.\n",
    "- Eingaben wiederholen: erste Eingabe vor der Schleife, nächste am Ende des Rumpfs.\n",
    "- „Annahme-Variable“: `ist_primzahl = True` annehmen, beim Gegenbeispiel auf `False` setzen.\n",
    "- Testen mit Grenzfällen: Schleife läuft gar nicht, genau einmal, sehr oft.\n",
    "\n",
    "Zum Weiterüben: `DS07_Weitere_Uebungen.ipynb`."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.11"
  },
  "v3_revision": {
   "basis": "MINT-Lehrplan Informatik 10 (2026)",
   "didaktik": "fragend-entwickelnder Kern, kurzer Transfer, flexible Reserve",
   "lerngruppe": "11 SuS"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}