{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DS 2 – Operatoren: rechnen, vergleichen, verknüpfen\n",
    "**Informatik 10 – MINT-Zweig | Textuelle Programmierung und Datenstrukturen**\n",
    "\n",
    "## Lernziele\n",
    "Ich kann\n",
    "- die Rechenoperatoren `//`, `%` und `**` benutzen und erklären, was sie berechnen,\n",
    "- mit `//` und `%` Minuten in Stunden und Minuten umrechnen und prüfen, ob eine Zahl gerade ist,\n",
    "- zwei Werte mit `==`, `!=`, `<`, `>`, `<=` und `>=` vergleichen,\n",
    "- Wahrheitswerte mit `and`, `or` und `not` verknüpfen und das Ergebnis vorhersagen,\n",
    "- die Zuweisung `=` und den Vergleich `==` sicher unterscheiden."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "sprachhilfe"
    ]
   },
   "source": [
    "## 🗣️ Sprachhilfe\n",
    "- *„Da kommt True raus.“* → „Für `zahl = 7` liefert der Vergleich `zahl > 4` den Wahrheitswert `True`, weil 7 größer als 4 ist.“\n",
    "- *„Ich bekomme raus, ob die Zahl größer als 4 ist.“* → „Die Anweisung prüft, ob eine Zahl größer als 4 ist, und gibt das Ergebnis als Wahrheitswert aus.“\n",
    "- *„Prozent rechnet den Rest.“* → „Der Modulo-Operator `%` liefert den Rest der Ganzzahldivision.“"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Worum es geht\n",
    "Ein Film dauert 135 Minuten. Wie viele Stunden und Minuten sind das? Ist eine Zahl gerade? Darf eine 15-Jährige ohne Ausweis ins Kino? Für solche Fragen muss ein Programm **rechnen**, **vergleichen** und Aussagen **verknüpfen**. Die Zeichen dafür heißen **Operatoren**.\n",
    "\n",
    "> 📌 **Definition:** Ein **Operator** ist ein Zeichen oder Wort, das mit einem oder mehreren Werten (den **Operanden**) einen neuen Wert berechnet. In `7 + 3` ist `+` der Operator, `7` und `3` sind die Operanden. Eine solche Verbindung heißt **Ausdruck**.\n",
    "\n",
    "## 1 Arithmetische Operatoren\n",
    "\n",
    "| Operator | Name | Beispiel | Ergebnis |\n",
    "|:-:|:--|:-:|:-:|\n",
    "| `+` | Addition | `7 + 3` | `10` |\n",
    "| `-` | Subtraktion | `7 - 3` | `4` |\n",
    "| `*` | Multiplikation | `7 * 3` | `21` |\n",
    "| `/` | Division | `7 / 3` | `2.3333333333333335` |\n",
    "| `//` | Ganzzahldivision | `7 // 3` | `2` |\n",
    "| `%` | Modulo (Rest) | `7 % 3` | `1` |\n",
    "| `**` | Potenz | `7 ** 3` | `343` |\n",
    "\n",
    "### Ganzzahldivision `//` und Rest `%`\n",
    "17 Kekse werden gerecht an 5 Kinder verteilt. Jedes Kind bekommt 3 Kekse, 2 bleiben übrig: 17 : 5 = 3 Rest 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(17 // 5)\n",
    "print(17 % 5)\n",
    "print(17 / 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 1:** `//` gibt an, wie oft die 5 **ganz** in die 17 passt: 3-mal.\n",
    "- **Zeile 2:** `%` (**Modulo**) liefert den **Rest**: 17 − 3 · 5 = 2.\n",
    "- **Zeile 3:** Die normale Division `/` rechnet mit Nachkommastellen.\n",
    "\n",
    "Probe: 3 · 5 + 2 = 17. Das Zeichen `%` hat in Python **nichts mit Prozent** zu tun.\n",
    "\n",
    "### Anwendung: Minuten in Stunden und Minuten"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "minuten_gesamt = int(input(\"Wie viele Minuten dauert der Film? \"))\n",
    "stunden = minuten_gesamt // 60\n",
    "minuten = minuten_gesamt % 60\n",
    "print(minuten_gesamt, \"Minuten sind\", stunden, \"Stunden und\",\n",
    "      minuten, \"Minuten.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 2:** `135 // 60` ergibt `2`, die 60 passt zweimal ganz in die 135.\n",
    "- **Zeile 3:** `135 % 60` ergibt `15`, denn 135 − 2 · 60 = 15.\n",
    "- **Zeilen 4–5:** Innerhalb der Klammern von `print` darf man in der nächsten Zeile weiterschreiben.\n",
    "\n",
    "**🧪 Probiere es aus:** Starte mit `60`, `59` und `600`. Was passiert bei `0`?\n",
    "\n",
    "### Anwendung: Ist eine Zahl gerade?\n",
    "Eine Zahl ist **gerade**, wenn beim Teilen durch 2 der Rest `0` bleibt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(14 % 2, 15 % 2, 2024 % 4, 2026 % 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 📌 **Merksatz:** Eine Zahl `a` ist genau dann durch `b` teilbar, wenn `a % b` den Wert `0` ergibt. Eine Zahl ist gerade, wenn `zahl % 2` gleich `0` ist.\n",
    "\n",
    "### Potenzieren mit `**`\n",
    "`2 ** 3` bedeutet 2³ = 2 · 2 · 2 = 8. Die erste Zahl ist die Basis, die zweite der Exponent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(2 ** 3, 10 ** 6, 5 ** 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ⚠️ Stolperstein: `^` ist nicht „hoch“\n",
    "In Tabellenkalkulationen schreibt man „hoch“ mit `^`. In Python gibt das **keine** Fehlermeldung, aber ein falsches Ergebnis. **🔮 Vorhersage:** Was kommt heraus?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(2 ^ 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Für Potenzen brauchst du in Python immer `**`.\n",
    "\n",
    "> 📌 **Merksatz:** Arithmetische Operatoren: `+`, `-`, `*`, `/` (Ergebnis immer `float`), `//` (Ganzzahldivision), `%` (Rest) und `**` (Potenz).\n",
    "\n",
    "### Was wird zuerst gerechnet?\n",
    "Klammern, dann `**`, dann Punktrechnung (`*`, `/`, `//`, `%`), zuletzt `+` und `-`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(2 + 3 ** 2)\n",
    "print((2 + 3) ** 2)\n",
    "print(10 - 7 % 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 1:** Erst 3² = 9, dann 2 + 9 = 11.\n",
    "- **Zeile 2:** Erst die Klammer 2 + 3 = 5, dann 5² = 25.\n",
    "- **Zeile 3:** Erst `7 % 4` = 3, dann 10 − 3 = 7.\n",
    "\n",
    "Wenn du unsicher bist, setze Klammern. Sie schaden nie.\n",
    "\n",
    "### 🔮 Übung 1 – Rechenausdrücke\n",
    "Bestimme jedes Ergebnis **zuerst im Kopf**, dann überprüfe in der Codezelle.\n",
    "\n",
    "| Ausdruck | `23 // 4` | `23 % 4` | `23 / 4` | `2 ** 5` | `10 % 2` | `7 % 10` | `3 + 2 ** 3` | `(3 + 2) ** 2` |\n",
    "|:--|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|\n",
    "| Ergebnis | | | | | | | | |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(23 // 4)\n",
    "# TODO: die übrigen sieben Ausdrücke prüfen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Vergleichsoperatoren: wahr oder falsch?\n",
    "Viele Fragen beantwortet man mit Ja oder Nein. Python antwortet mit einem **Wahrheitswert**: `True` oder `False` (Datentyp `bool`).\n",
    "\n",
    "| Operator | Bedeutung | Beispiel | Ergebnis |\n",
    "|:-:|:--|:-:|:-:|\n",
    "| `==` | ist gleich | `7 == 3` | `False` |\n",
    "| `!=` | ist ungleich | `7 != 3` | `True` |\n",
    "| `<` | ist kleiner als | `7 < 3` | `False` |\n",
    "| `>` | ist größer als | `7 > 3` | `True` |\n",
    "| `<=` | ist kleiner oder gleich | `7 <= 7` | `True` |\n",
    "| `>=` | ist größer oder gleich | `3 >= 7` | `False` |\n",
    "\n",
    "`!=` liest man „ungleich“. Bei `<=` und `>=` steht das Gleichheitszeichen immer **rechts**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 7\n",
    "b = 3\n",
    "print(a > b)\n",
    "print(a == b)\n",
    "print(a != b)\n",
    "print(a <= 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ergebnisse von Vergleichen speichern\n",
    "Ein Wahrheitswert ist ein ganz normaler Wert und kann in einer Variablen gespeichert werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alter = int(input(\"Wie alt bist du? \"))\n",
    "ist_volljaehrig = alter >= 18\n",
    "print(\"Volljährig:\", ist_volljaehrig)\n",
    "print(type(ist_volljaehrig))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 2:** Zuerst wird die rechte Seite ausgewertet: Ist 15 ≥ 18? Nein, also `False`. Dann wird der Wert gespeichert.\n",
    "\n",
    "Für solche Variablen wählt man Namen wie eine Ja-Nein-Frage: `ist_volljaehrig`, `hat_ausweis`, `ist_gerade`.\n",
    "\n",
    "### Texte vergleichen\n",
    "Es kommt auf jedes Zeichen an, auch auf Groß- und Kleinschreibung und Leerzeichen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"ja\" == \"ja\", \"Ja\" == \"ja\", \"ja \" == \"ja\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ⚠️ Stolperstein: Eingabe nicht umgewandelt\n",
    "**🔮 Vorhersage:** Gib `7` ein. Was gibt das Programm aus?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahl = input(\"Gib eine Zahl ein: \")\n",
    "print(zahl == 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Keine Fehlermeldung, aber immer `False`: Der Text `\"7\"` ist nicht die Zahl `7`. Abhilfe: `zahl = int(input(...))`.\n",
    "\n",
    "### ⚠️ Zuweisung `=` oder Vergleich `==`?\n",
    "- `x = 5` ist eine **Zuweisung**: „`x` bekommt den Wert 5.“ Es wird nichts geprüft.\n",
    "- `x == 5` ist ein **Vergleich**: „Ist `x` gleich 5?“ Es wird nichts verändert.\n",
    "\n",
    "Führe die Zelle aus und lies die Fehlermeldung."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(7 = 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`SyntaxError: expression cannot contain assignment, perhaps you meant \"==\"?` heißt: „Ein Ausdruck darf keine Zuweisung enthalten. Meintest du `==`?“\n",
    "\n",
    "> 📌 **Merksatz:** Vergleichsoperatoren liefern immer einen Wahrheitswert (`True` oder `False`): `==`, `!=`, `<`, `>`, `<=`, `>=`. Verwechsle nicht `=` (Zuweisung) und `==` (Vergleich)!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Logische Operatoren: `and`, `or` und `not`\n",
    "Ein Film ist ab 12, und an der Kasse wird ein Ausweis verlangt. Du darfst nur hinein, wenn **beide** Bedingungen erfüllt sind.\n",
    "\n",
    "- `and` („und“): nur `True`, wenn **beide** Seiten `True` sind.\n",
    "- `or` („oder“): `True`, wenn **mindestens eine** Seite `True` ist, also **auch, wenn beide** wahr sind. Anders als „entweder … oder“ im Alltag!\n",
    "- `not` („nicht“): steht **vor** einem Wahrheitswert und kehrt ihn um."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(True and False)\n",
    "print(True or False)\n",
    "print(not True)\n",
    "print(not 7 > 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 4:** Zuerst der Vergleich: `7 > 3` ist `True`. Dann kehrt `not` das um.\n",
    "\n",
    "| `A` | `B` | `A and B` | `A or B` | `not A` |\n",
    "|:-:|:-:|:-:|:-:|:-:|\n",
    "| `False` | `False` | `False` | `False` | `True` |\n",
    "| `False` | `True` | `False` | `True` | `True` |\n",
    "| `True` | `False` | `False` | `True` | `False` |\n",
    "| `True` | `True` | `True` | `True` | `False` |\n",
    "\n",
    "> 📌 **Merksatz:** `and`: beide Bedingungen müssen wahr sein. `or`: mindestens eine muss wahr sein. `not`: kehrt einen Wahrheitswert um.\n",
    "\n",
    "### Vergleiche verknüpfen\n",
    "Ist eine Person jugendlich, also mindestens 13 und jünger als 18?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alter = int(input(\"Wie alt bist du? \"))\n",
    "ist_jugendlich = alter >= 13 and alter < 18\n",
    "print(\"Jugendlich:\", ist_jugendlich)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python wertet Zeile 2 so aus:\n",
    "1. `15 >= 13` ergibt `True`.\n",
    "2. `15 < 18` ergibt `True`.\n",
    "3. `True and True` ergibt `True`.\n",
    "\n",
    "Rechnungen und Vergleiche kommen **vor** den logischen Operatoren. Unter ihnen gilt: erst `not`, dann `and`, zuletzt `or`.\n",
    "\n",
    "### ⚠️ Stolperstein: halber Vergleich\n",
    "Im Deutschen sagt man „älter als 12 und jünger als 18“. Python braucht auf **beiden** Seiten von `and` einen vollständigen Vergleich."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alter = 15\n",
    "print(alter > 12 and < 18)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Richtig ist `alter > 12 and alter < 18`.\n",
    "\n",
    "### 🔮 Übung 2 – Wahr oder falsch?\n",
    "Es gilt `x = 5` und `y = 10`. Bestimme **zuerst im Kopf**, ob jeder Ausdruck `True` oder `False` ergibt.\n",
    "\n",
    "| Ausdruck | Ergebnis |\n",
    "|:--|:--|\n",
    "| `x < y` | |\n",
    "| `x == 5 and y == 5` | |\n",
    "| `x == 5 or y == 5` | |\n",
    "| `not x > y` | |\n",
    "| `x % 2 == 0` | |\n",
    "| `x + y >= 15 and not y == 10` | |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "y = 10\n",
    "print(x < y)\n",
    "# TODO: die übrigen fünf Ausdrücke prüfen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 Klammern entscheiden: Darf ich zocken?\n",
    "- `A` = Die Hausaufgaben sind fertig.\n",
    "- `B` = Das Zimmer ist aufgeräumt.\n",
    "- `C` = Es ist Wochenende.\n",
    "\n",
    "Zwei Eltern formulieren ihre Regel unterschiedlich:\n",
    "- **Regel 1:** `(A and B) or C`: Hausaufgaben **und** Zimmer, **oder** Wochenende. Am Wochenende reicht `C` allein.\n",
    "- **Regel 2:** `A and (B or C)`: Hausaufgaben **immer**, dazu Zimmer **oder** Wochenende.\n",
    "\n",
    "**🔮 Vorhersage:** Hausaufgaben nicht fertig, Zimmer nicht aufgeräumt, aber Wochenende. Wer darf zocken?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = False   # Hausaufgaben sind fertig\n",
    "B = False   # Zimmer ist aufgeräumt\n",
    "C = True    # Es ist Wochenende\n",
    "\n",
    "ausdruck_1 = (A and B) or C\n",
    "ausdruck_2 = A and (B or C)\n",
    "\n",
    "print(\"(A and B) or C =\", ausdruck_1)\n",
    "print(\"A and (B or C) =\", ausdruck_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 5:** Erst die Klammer: `False and False` ergibt `False`. Dann `False or True`, also `True`.\n",
    "- **Zeile 6:** Erst die Klammer: `False or True` ergibt `True`. Dann `False and True`, also `False`.\n",
    "\n",
    "Die Tabelle zeigt alle acht Möglichkeiten:\n",
    "\n",
    "| `A` | `B` | `C` | `A and B` | `B or C` | `(A and B) or C` | `A and (B or C)` |\n",
    "|:-:|:-:|:-:|:-:|:-:|:-:|:-:|\n",
    "| `False` | `False` | `False` | `False` | `False` | `False` | `False` |\n",
    "| `False` | `False` | `True` | `False` | `True` | `True` | `False` |\n",
    "| `False` | `True` | `False` | `False` | `True` | `False` | `False` |\n",
    "| `False` | `True` | `True` | `False` | `True` | `True` | `False` |\n",
    "| `True` | `False` | `False` | `False` | `False` | `False` | `False` |\n",
    "| `True` | `False` | `True` | `False` | `True` | `True` | `True` |\n",
    "| `True` | `True` | `False` | `True` | `True` | `True` | `True` |\n",
    "| `True` | `True` | `True` | `True` | `True` | `True` | `True` |\n",
    "\n",
    "In vier Zeilen unterscheiden sich die beiden letzten Spalten: Die Ausdrücke sind **nicht äquivalent**.\n",
    "\n",
    "> 📌 **Merksatz:** Klammern bestimmen, welcher Teilausdruck zuerst ausgewertet wird. Setze immer Klammern, wenn du `and` und `or` mischst.\n",
    "\n",
    "### Bedingungen verneinen: die Regeln von De Morgan\n",
    "Ist eine Person **nicht** jugendlich?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alter = 20\n",
    "print(not (alter >= 13 and alter < 18))\n",
    "print(alter < 13 or alter >= 18)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Beide Zeilen liefern für **jedes** Alter dasselbe. Probiere es mit `alter = 15` und `alter = 9`. Beim Umformen wurde jeder Vergleich verneint (`>=` wird `<`, `<` wird `>=`), und aus `and` wurde `or`.\n",
    "\n",
    "> 📌 **Regeln von De Morgan:** `not (A and B)` ist dasselbe wie `not A or not B`. `not (A or B)` ist dasselbe wie `not A and not B`. Verneint man eine verknüpfte Bedingung, wird **jede** Teilbedingung verneint, und aus `and` wird `or` (und umgekehrt).\n",
    "\n",
    "| Vergleich | verneint |\n",
    "|:-:|:-:|\n",
    "| `a == b` | `a != b` |\n",
    "| `a < b` | `a >= b` |\n",
    "| `a > b` | `a <= b` |\n",
    "\n",
    "> ⚠️ **Stolperstein:** `alter < 13 and alter >= 18` ist **immer** `False`, denn niemand ist gleichzeitig jünger als 13 und mindestens 18. Beim Verneinen wird aus `and` ein `or`!\n",
    "\n",
    "### ✏️ Übung 3 – Bedingungen verneinen\n",
    "Schreibe zu jeder Bedingung eine Bedingung **ohne** `not`, die das Gegenteil prüft. Teste in der Codezelle: Beide Werte einer Zeile müssen gleich sein.\n",
    "1. `zahl >= 1 and zahl <= 6` (eine Würfelzahl)\n",
    "2. `note == 1 or note == 2`\n",
    "3. `not (temperatur > 30 or regen)` (`regen` ist ein Wahrheitswert, „nicht `regen`“ darf als `not regen` stehen bleiben)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahl = 7\n",
    "print(not (zahl >= 1 and zahl <= 6), ___)\n",
    "note = 2\n",
    "print(not (note == 1 or note == 2), ___)\n",
    "temperatur = 25\n",
    "regen = False\n",
    "print(not (temperatur > 30 or regen), ___)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📝 Übungen: Schritt für Schritt selbstständig\n",
    "Das **Musterbeispiel** ist ganz vorgemacht. Bei Übung 4 füllst du Lücken `___`, bei Übung 5 steht nur noch ein Gerüst aus Kommentaren, die Zusatzaufgabe schreibst du allein.\n",
    "\n",
    "| Schritt | Frage |\n",
    "|:-:|:--|\n",
    "| 1 | **Eingabe:** Was wird eingelesen? Als welcher Datentyp? |\n",
    "| 2 | **Verarbeitung:** Welcher Operator beantwortet die Frage? |\n",
    "| 3 | **Ausgabe:** Was soll auf dem Bildschirm stehen? |\n",
    "\n",
    "### 🧩 Musterbeispiel (vorgemacht) – Durch 3 teilbar?\n",
    "Aufgabe: Das Programm liest eine Ganzzahl ein und gibt als Wahrheitswert aus, ob sie durch 3 teilbar ist.\n",
    "\n",
    "1. **Eingabe:** eine ganze Zahl, also `int(input(...))`.\n",
    "2. **Verarbeitung:** „durch 3 teilbar“ heißt „Rest beim Teilen durch 3 ist 0“: `zahl % 3 == 0`. Python rechnet erst `%`, dann vergleicht es mit `==`.\n",
    "3. **Ausgabe:** Text und Wahrheitswert, mit Komma getrennt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Schritt 1: Eingabe\n",
    "zahl = int(input(\"Ganzzahl eingeben: \"))\n",
    "\n",
    "# Schritt 2: Verarbeitung\n",
    "ist_teilbar = zahl % 3 == 0\n",
    "\n",
    "# Schritt 3: Ausgabe\n",
    "print(\"Durch 3 teilbar:\", ist_teilbar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Teste mit 12 (`True`), 13 (`False`) und 0 (`True`).\n",
    "\n",
    "### 📝 Übung 4 – Gerade oder ungerade? (Lücken füllen)\n",
    "Das Programm liest eine Ganzzahl ein und gibt als Wahrheitswert aus, ob sie gerade ist. Ersetze jedes `___`. Kontrolle: 14 → `Ist gerade: True`, 7 → `Ist gerade: False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahl = ___(input(\"Ganzzahl eingeben: \"))\n",
    "ist_gerade = zahl ___ 2 ___ 0\n",
    "print(\"Ist gerade:\", ist_gerade)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 📝 Übung 5 – Schaltjahr-Check (mit Gerüst)\n",
    "Ein Jahr ist ein Schaltjahr, wenn es durch 4 teilbar ist, aber nicht durch 100, **außer** es ist auch durch 400 teilbar. Du brauchst nur Operatoren. Ersetze die Kommentare durch Programmzeilen.\n",
    "\n",
    "Kontrolle: 2024 → `True`, 2023 → `False`, 1900 → `False`, 2000 → `True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jahreszahl als Ganzzahl einlesen\n",
    "# A = durch 4 teilbar?\n",
    "# B = durch 100 teilbar?\n",
    "# C = durch 400 teilbar?\n",
    "# schaltjahr = durch 4 und nicht durch 100, oder durch 400 (Klammern setzen!)\n",
    "# alle Zwischenergebnisse und das Ergebnis ausgeben"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🚀 Zusatzaufgabe – Sekunden umrechnen (selbstständig)\n",
    "Lies eine Anzahl von Sekunden ein und gib aus, wie viele volle Stunden, Minuten und Sekunden das sind. Kontrolle: 3725 Sekunden sind 1 Stunden, 2 Minuten und 5 Sekunden. Tipp: Eine Stunde hat 3600 Sekunden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Zusatzaufgabe – Sekunden umrechnen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📌 Das Wichtigste in Kürze\n",
    "- `//` Ganzzahldivision, `%` Rest, `**` Potenz. `^` ist **nicht** „hoch“.\n",
    "- `a % b == 0` heißt: `a` ist durch `b` teilbar.\n",
    "- Vergleiche `==`, `!=`, `<`, `>`, `<=`, `>=` liefern `True` oder `False`. `=` weist zu, `==` vergleicht.\n",
    "- `and`: beide wahr. `or`: mindestens eins wahr. `not`: umkehren. Beim Mischen Klammern setzen.\n",
    "- De Morgan: Beim Verneinen jede Teilbedingung verneinen und `and` ↔ `or` tauschen.\n",
    "\n",
    "Zum Weiterüben: `DS02_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
}