{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DS 12 – Algorithmen auf Listen: Summe, Minimum und Suche\n",
    "**Informatik 10 – MINT-Zweig | Datenstrukturen**\n",
    "\n",
    "## Lernziele\n",
    "Ich kann\n",
    "- mit einer Schleife über die Elemente oder über die Indizes einer Liste laufen und die passende Art auswählen,\n",
    "- die Summe und den Mittelwert aller Elemente einer Liste berechnen,\n",
    "- das kleinste und das größte Element einer Liste bestimmen,\n",
    "- mit der linearen Suche herausfinden, ob und an welchem Index ein Wert in einer Liste vorkommt,\n",
    "- zählen, wie oft ein Wert in einer Liste vorkommt,\n",
    "- meine Ergebnisse mit `sum()`, `min()`, `max()` und `sorted()` kontrollieren."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "sprachhilfe"
    ]
   },
   "source": [
    "## 🗣️ Sprachhilfe\n",
    "- *„Die Funktion findet Tom an Stelle 2.“* → „Der Funktion `lineare_suche` werden die Liste `namen` und der Wert `\"Tom\"` übergeben. Sie durchläuft die Liste Element für Element und gibt den Index 2 zurück.“\n",
    "- *„Bei Lea kommt −1.“* → „Ist der gesuchte Wert nicht in der Liste enthalten, gibt die Funktion −1 zurück.“\n",
    "- *„maximum merkt sich die größte Zahl.“* → „Die Hilfsvariable `maximum` wird mit dem ersten Listenelement initialisiert und aktualisiert, sobald ein größeres Element gefunden wird.“"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Worum es geht\n",
    "In einer Liste stehen die Noten einer Klassenarbeit. Wie gut war die Klasse im Durchschnitt? Was war die beste Note? Wie viele Einsen gab es? Ein Computer kann nicht „auf einen Blick“ sehen. Er muss die Liste **Element für Element** durchgehen. Ein **Algorithmus** ist eine genaue Schritt-für-Schritt-Anleitung, so eindeutig, dass auch ein Computer sie ausführen kann.\n",
    "\n",
    "## 1 Zwei Arten, eine Liste zu durchlaufen\n",
    "\n",
    "| Schleife | Schleifenvariable | geeignet, wenn … |\n",
    "|:--|:--|:--|\n",
    "| `for element in liste:` | jedes **Element** | nur Werte nötig sind |\n",
    "| `for i in range(len(liste)):` | jeder **Index** | die Position nötig ist |\n",
    "\n",
    "**🔮 Vorhersage:** Beide Zellen sollen alle Preise verdoppeln. Welche schafft es?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "preise = [2.0, 3.5, 1.0]\n",
    "for i in range(len(preise)):\n",
    "    preise[i] = preise[i] * 2\n",
    "print(preise)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "preise = [2.0, 3.5, 1.0]\n",
    "for preis in preise:\n",
    "    preis = preis * 2\n",
    "print(preise)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In der ersten Zelle steht ein schreibender Zugriff `preise[i] = …`. In der zweiten bekommt `preis` in jedem Durchlauf nur den **Wert** eines Elements. `preis = preis * 2` ändert nur diese Variable, die Liste bekommt davon nichts mit. Es gibt keine Fehlermeldung, die Liste bleibt einfach gleich.\n",
    "\n",
    "> 📌 **Merksatz:** Über eine Liste kann man **über die Elemente** (`for element in liste:`) oder **über die Indizes** (`for i in range(len(liste)):`) iterieren. Zum Verändern der Liste braucht man die Indizes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Summenbildung\n",
    "An der Supermarktkasse werden die Preise nacheinander zu einer **Zwischensumme** addiert. Am Anfang steht sie auf 0, bei jedem Artikel kommt sein Preis dazu. Genauso arbeitet der Algorithmus. Die Zwischensumme ist eine **Hilfsvariable**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahlen = [7, 2, 9, 4, 1, 8]\n",
    "summe = 0\n",
    "for zahl in zahlen:\n",
    "    summe = summe + zahl\n",
    "print(\"Summe:\", summe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 2:** `summe` wird **vor** der Schleife mit 0 **initialisiert**.\n",
    "- **Zeilen 3–4:** In jedem Durchlauf wird das aktuelle Element addiert.\n",
    "- **Zeile 5:** Erst **nach** der Schleife steht das Endergebnis in `summe`.\n",
    "\n",
    "Ablaufprotokoll für die kürzere Liste `[7, 2, 9]`:\n",
    "\n",
    "| Schritt | Zeile | Anweisung | `zahl` | `summe` |\n",
    "|:-:|:-:|:--|:-:|:-:|\n",
    "| 1 | 1 | `zahlen = [7, 2, 9]` | – | – |\n",
    "| 2 | 2 | `summe = 0` | – | `0` |\n",
    "| 3 | 3 | `for zahl in zahlen:` | `7` | `0` |\n",
    "| 4 | 4 | `summe = summe + zahl` | `7` | `7` |\n",
    "| 5 | 3 | `for zahl in zahlen:` | `2` | `7` |\n",
    "| 6 | 4 | `summe = summe + zahl` | `2` | `9` |\n",
    "| 7 | 3 | `for zahl in zahlen:` | `9` | `9` |\n",
    "| 8 | 4 | `summe = summe + zahl` | `9` | `18` |\n",
    "| 9 | 3 | `for zahl in zahlen:` | `9` | `18` |\n",
    "| 10 | 5 | `print(\"Summe:\", summe)` | `9` | `18` |\n",
    "\n",
    "> ⚠️ **Stolperstein:** Steht `summe = 0` **in** der Schleife, wird die Zwischensumme bei jedem Durchlauf wieder auf 0 gesetzt. Am Ende steht dann nur das letzte Element in `summe`.\n",
    "\n",
    "### Der Mittelwert\n",
    "Den **Mittelwert** (Durchschnitt) erhältst du, wenn du die Summe durch die Anzahl `len(liste)` teilst. Das funktioniert für jede Liste, egal wie viele Noten darin stehen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "noten = [2, 3, 1, 4, 2]\n",
    "summe = 0\n",
    "for note in noten:\n",
    "    summe = summe + note\n",
    "mittelwert = summe / len(noten)\n",
    "print(\"Durchschnitt:\", mittelwert)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 📌 **Merksatz:** **Summenbildung:** Eine Hilfsvariable wird vor der Schleife auf `0` gesetzt und in jedem Durchlauf um das aktuelle Element erhöht. **Mittelwert** = Summe / `len(liste)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Maximum und Minimum\n",
    "Stell dir vor, du deckst Spielkarten nacheinander auf. Die erste Karte behältst du in der Hand. Bei jeder weiteren vergleichst du: Ist die neue Zahl größer? Dann tauschst du. Am Ende hältst du die größte Zahl in der Hand. Die „Karte in der Hand“ ist wieder eine Hilfsvariable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahlen = [7, 2, 9, 4, 1, 8]\n",
    "maximum = zahlen[0]\n",
    "for zahl in zahlen:\n",
    "    if zahl > maximum:\n",
    "        maximum = zahl\n",
    "print(\"Maximum:\", maximum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 2:** `maximum` wird mit dem **ersten Element** initialisiert, der ersten Karte.\n",
    "- **Zeilen 4–5:** Nur wenn das aktuelle Element größer ist, wird `maximum` **aktualisiert**.\n",
    "\n",
    "Für das **Minimum** dreht man den Vergleich um: `<` statt `>`.\n",
    "\n",
    "### ⚠️ Stolperstein: Warum nicht mit 0 beginnen?\n",
    "**🔮 Vorhersage:** Was gibt das Programm aus? Was wäre richtig?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "temperaturen = [-5, -2, -8]\n",
    "maximum = 0\n",
    "for t in temperaturen:\n",
    "    if t > maximum:\n",
    "        maximum = t\n",
    "print(\"Höchste Temperatur:\", maximum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Keine Temperatur ist größer als 0, also wird `maximum` nie aktualisiert. Ausgegeben wird 0, ein Wert, der gar nicht in der Liste steht. Richtig wäre −2. Mit `maximum = temperaturen[0]` stimmt das Ergebnis.\n",
    "\n",
    "> 📌 **Merksatz:** **Minimum/Maximum:** Eine Hilfsvariable wird mit dem **ersten Element** initialisiert und bei jedem kleineren bzw. größeren Fund aktualisiert."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 Lineare Suche und Zählen\n",
    "Du suchst in einem unsortierten Stapel Klassenarbeiten die von Tom. Du nimmst die oberste, schaust auf den Namen, dann die nächste, bis du Toms Arbeit gefunden hast oder der Stapel zu Ende ist. Das ist die **lineare Suche**. Die Funktion gibt den **Index** des Treffers zurück, sonst `-1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lineare_suche(liste, gesuchter_wert):\n",
    "    for i in range(len(liste)):\n",
    "        if liste[i] == gesuchter_wert:\n",
    "            return i\n",
    "    return -1\n",
    "\n",
    "namen = [\"Ben\", \"Ada\", \"Tom\", \"Mia\"]\n",
    "print(lineare_suche(namen, \"Tom\"))\n",
    "print(lineare_suche(namen, \"Lea\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 2:** Weil der Index zurückgegeben werden soll, läuft die Schleife über die **Indizes**.\n",
    "- **Zeile 4:** Bei einem Treffer beendet `return i` die Funktion **sofort**, auch mitten in der Schleife. Mia wird gar nicht mehr angeschaut.\n",
    "- **Zeile 5:** wird nur erreicht, wenn die Schleife ohne Treffer zu Ende gelaufen ist.\n",
    "\n",
    "Warum `-1`? Von vorne gezählt ist ein Index nie negativ. Aber Vorsicht: `namen[-1]` wäre `\"Mia\"`! Prüfe das Ergebnis also mit `if position == -1:`, bevor du es als Index benutzt.\n",
    "\n",
    "### ⚠️ Stolperstein: `return -1` im `else`\n",
    "**🔮 Vorhersage:** Tom steht in der Liste. Was gibt diese Fassung aus, und warum?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lineare_suche(liste, gesuchter_wert):\n",
    "    for i in range(len(liste)):\n",
    "        if liste[i] == gesuchter_wert:\n",
    "            return i\n",
    "        else:\n",
    "            return -1\n",
    "\n",
    "namen = [\"Ben\", \"Ada\", \"Tom\", \"Mia\"]\n",
    "print(lineare_suche(namen, \"Tom\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Beim ersten Element `\"Ben\"` ist der Vergleich falsch, der `else`-Teil wird ausgeführt, und `return` beendet die Funktion sofort. „Nicht gefunden“ steht erst fest, wenn **alle** Elemente verglichen wurden, also **nach** der Schleife.\n",
    "\n",
    "> 📌 **Merksatz:** **Lineare Suche:** Man durchläuft die Liste Element für Element und vergleicht mit dem Suchwert, bis er gefunden wurde oder die Liste zu Ende ist.\n",
    "\n",
    "### Zählen\n",
    "Beim Zählen führt man eine **Strichliste**: Die Hilfsvariable beginnt bei 0 und wird um **1** erhöht, wenn ein Element die Bedingung erfüllt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "noten = [2, 3, 1, 4, 2, 5, 1]\n",
    "anzahl = 0\n",
    "for note in noten:\n",
    "    if note <= 2:\n",
    "        anzahl = anzahl + 1\n",
    "print(\"Anzahl der Noten 1 oder 2:\", anzahl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 📌 **Merksatz:** **Zählen:** Hilfsvariable mit 0 beginnen und um 1 erhöhen, wenn ein Element die Bedingung erfüllt."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5 Übungen\n",
    "\n",
    "### 🧰 Werkzeug: fertige Funktionen zur Kontrolle\n",
    "Python bringt für diese Aufgaben fertige Funktionen mit. Benutze sie, um deine eigenen Funktionen zu prüfen, zum Beispiel `print(minimum(zahlen) == min(zahlen))`.\n",
    "\n",
    "| Funktion | Ergebnis |\n",
    "|:--|:--|\n",
    "| `sum(liste)` | die Summe aller Elemente |\n",
    "| `min(liste)`, `max(liste)` | das kleinste bzw. größte Element |\n",
    "| `sorted(liste)` | eine **neue**, aufsteigend sortierte Liste |\n",
    "| `wert in liste` | `True`, wenn `wert` vorkommt |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahlen = [7, 2, 9, 4, 1, 8]\n",
    "print(sum(zahlen))\n",
    "print(min(zahlen), max(zahlen))\n",
    "print(sorted(zahlen))\n",
    "print(zahlen)\n",
    "print(9 in zahlen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Schritt für Schritt selbstständig\n",
    "Vorgemacht sind die Muster **Summe** und **Maximum** oben. Bei Übung 1 füllst du Lücken `___` aus, bei Übung 2 steht ein Gerüst aus Kommentaren, bei Übung 3 nur die Kopfzeile und der Test. Übung 4 ist eine Leseaufgabe, die Zusatzaufgabe schreibst du allein.\n",
    "\n",
    "### 📝 Übung 1 – Durchschnitt berechnen (Lücken füllen)\n",
    "Schreibe eine Funktion `durchschnitt(liste)`, die den Durchschnitt aller Zahlen einer Liste zurückgibt. Kontrolle: `durchschnitt([7, 2, 9, 4, 1, 8])` ergibt etwa 5,17 (Summe 31, 6 Elemente)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def durchschnitt(liste):\n",
    "    summe = ___\n",
    "    for wert in liste:\n",
    "        summe = ___\n",
    "    return ___ / len(liste)\n",
    "\n",
    "print(durchschnitt([7, 2, 9, 4, 1, 8]), \"erwartet: etwa 5.17\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 📝 Übung 2 – Minimum finden (mit Gerüst)\n",
    "Schreibe eine Funktion `minimum(liste)`, die das kleinste Element zurückgibt, ohne `min()` zu verwenden. Teste mit `[7, 2, 9, 4, 1, 8]` und mit einer Liste aus negativen Zahlen. Vergleiche mit `min()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def minimum(liste):\n",
    "    # Hilfsvariable mit dem ersten Element initialisieren\n",
    "    # für jeden Wert in der Liste:\n",
    "    #     wenn der Wert kleiner ist als die Hilfsvariable:\n",
    "    #         Hilfsvariable aktualisieren\n",
    "    # nach der Schleife: Hilfsvariable zurückgeben\n",
    "    pass\n",
    "\n",
    "print(minimum([7, 2, 9, 4, 1, 8]), \"erwartet: 1\")\n",
    "print(minimum([-5, -2, -8]), \"erwartet: -8\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 📝 Übung 3 – Häufigkeit zählen (Kopfzeile und Test vorgegeben)\n",
    "Schreibe eine Funktion `zaehle_vorkommen(liste, wert)`, die zählt, wie oft `wert` in `liste` vorkommt. Anders als die lineare Suche soll sie **alle** Vorkommen zählen. Kontrolle: `zaehle_vorkommen([1, 2, 2, 3, 2, 4], 2)` ergibt 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def zaehle_vorkommen(liste, wert):\n",
    "    pass   # hier deine Programmzeilen (Vorbild: Zählen mit Strichliste)\n",
    "\n",
    "print(zaehle_vorkommen([1, 2, 2, 3, 2, 4], 2), \"erwartet: 3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 🔍 Übung 4 – Code lesen\n",
    "Lies die Funktion, **ohne** sie auszuführen.\n",
    "1. Gib an, was das Programm ausgibt.\n",
    "2. Beschreibe in einem Satz, was `geheim` allgemein berechnet.\n",
    "3. Erkläre, warum das Ergebnis nicht `3` ist, obwohl am Index 3 auch eine 8 steht."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def geheim(liste):\n",
    "    position = 0\n",
    "    for i in range(len(liste)):\n",
    "        if liste[i] > liste[position]:\n",
    "            position = i\n",
    "    return position\n",
    "\n",
    "print(geheim([3, 8, 5, 8, 1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Meine Antworten:**\n",
    "\n",
    "…"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🚀 Zusatzaufgabe – Zwei größte Werte (selbstständig)\n",
    "Finde mit einer Schleife die **zwei größten** Werte der Liste und gib sie aus, ohne `sorted()`. Kontrolle: 22 und 17.\n",
    "\n",
    "> 💡 **Tipp:** Merke dir in **zwei** Hilfsvariablen den größten und den zweitgrößten Wert. Initialisiere sie mit den ersten beiden Elementen, in der richtigen Reihenfolge. Ist ein weiteres Element größer als der größte Wert, oder nur größer als der zweitgrößte?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahlen = [4, 17, 9, 22, 3, 15]\n",
    "\n",
    "# Zusatzaufgabe – zwei größte Werte finden"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📌 Das Wichtigste in Kürze\n",
    "- Über eine Liste iteriert man über die Elemente (`for element in liste:`) oder über die Indizes (`for i in range(len(liste)):`). Zum Verändern braucht man die Indizes.\n",
    "- **Summe:** Hilfsvariable vor der Schleife auf 0 setzen, in jedem Durchlauf das Element addieren. **Mittelwert** = Summe / `len(liste)`.\n",
    "- **Maximum/Minimum:** Hilfsvariable mit dem ersten Element initialisieren und bei jedem größeren bzw. kleineren Element aktualisieren.\n",
    "- **Lineare Suche:** Element für Element vergleichen, bis der Wert gefunden oder die Liste zu Ende ist. Ergebnis: der Index (oder `-1`) bzw. `True`/`False`.\n",
    "- **Zählen:** Hilfsvariable mit 0 beginnen und um 1 erhöhen, wenn ein Element die Bedingung erfüllt.\n",
    "- `sum`, `min`, `max`, `sorted` und `in` erledigen das fertig, gut zur Kontrolle eigener Funktionen.\n",
    "\n",
    "Zum Weiterüben: `DS12_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
}