{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DS 13 – Teamprojekt: Verschlüsselung mit der Caesar-Chiffre (Teil 1)\n",
    "**Informatik 10 – MINT-Zweig | Projektarbeit**\n",
    "\n",
    "## Lernziele\n",
    "Ich kann\n",
    "- das Verfahren der Caesar-Chiffre beschreiben und von Hand anwenden,\n",
    "- die Position eines Buchstabens im Alphabet bestimmen und mit `% 26` am Ende des Alphabets vorne weiterzählen,\n",
    "- Funktionen zum Verschlüsseln eines Buchstabens und eines ganzen Textes implementieren und systematisch testen,\n",
    "- ein Programmierprojekt im Team planen, Teilaufgaben verteilen und die Ergebnisse zusammenführen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "sprachhilfe"
    ]
   },
   "source": [
    "## 🗣️ Sprachhilfe\n",
    "- „Der Buchstabe … hat im Alphabet die Position … . Mit dem Schlüssel … ergibt sich die Position …, also der Buchstabe … .“\n",
    "- „Am Ende des Alphabets rechnen wir `% 26`, damit nach Z wieder A kommt: … % 26 ergibt … .“\n",
    "- „Die Funktion … bekommt die Parameter … und gibt … zurück. Das ist ihre Schnittstelle.“\n",
    "- „Wir haben mit dem Randfall … getestet, weil dort am ehesten ein Fehler steckt.“"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 Wie die Caesar-Chiffre funktioniert\n",
    "Wie verschickt man eine Nachricht so, dass nur Eingeweihte sie lesen können? Julius Caesar soll ein einfaches Verfahren benutzt haben: Jeder Buchstabe wird im Alphabet um eine feste Anzahl von Stellen nach hinten verschoben. Diese Anzahl ist der **Schlüssel**. Am Ende des Alphabets geht es vorne weiter.\n",
    "\n",
    "Schlüssel 3:\n",
    "\n",
    "| Klartext | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z |\n",
    "|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|\n",
    "| Geheimtext | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | **A** | **B** | **C** |\n",
    "\n",
    "So wird aus dem **Klartext** `HALLO` der **Geheimtext** `KDOOR`: H → K, A → D, L → O, L → O, O → R. Wer den Schlüssel kennt, entschlüsselt, indem er jeden Buchstaben um 3 Stellen **zurück** verschiebt.\n",
    "\n",
    "> 📌 **Definition:** Beim **Verschlüsseln** wird ein lesbarer **Klartext** mithilfe eines **Schlüssels** in einen **Geheimtext** umgewandelt. Beim **Entschlüsseln** wird aus dem Geheimtext mit dem Schlüssel wieder der Klartext.\n",
    "\n",
    "### ✏️ Übung 1 – Von Hand verschlüsseln\n",
    "Benutze die Tabelle oben.\n",
    "1. Verschlüssele das Wort `INFORMATIK`.\n",
    "2. Entschlüssele den Geheimtext `ZDVVHU`.\n",
    "3. Beschreibe in einem Satz, wie du beim Entschlüsseln vorgegangen bist.\n",
    "\n",
    "| I | N | F | O | R | M | A | T | I | K |\n",
    "|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|\n",
    "| | | | | | | | | | |\n",
    "\n",
    "**Meine Antworten zu 2 und 3:**\n",
    "\n",
    "…"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Das Projekt im Team planen\n",
    "Professionelle Softwareteams tippen nicht alle gleichzeitig drauflos. Sie gehen in Schritten vor:\n",
    "1. **Verstehen und planen:** Was soll das Programm können? Wie löst man das Problem erst einmal ohne Computer?\n",
    "2. **Zerlegen und verteilen:** Für jede Teilaufgabe wird eine Funktion geplant, jede Person übernimmt eine.\n",
    "3. **Umsetzen und testen:** Jede Funktion wird mit vorher festgelegten Beispielen getestet.\n",
    "4. **Zusammenführen:** Die Funktionen werden zu einem Programm zusammengesetzt und gemeinsam getestet.\n",
    "5. **Dokumentieren und vorstellen.**\n",
    "\n",
    "Damit ihr gleichzeitig arbeiten könnt, legt ihr **vorher** fest, wie jede Funktion heißt, welche Parameter sie bekommt und was sie zurückgibt.\n",
    "\n",
    "> 📌 **Definition:** Die **Schnittstelle** einer Funktion legt fest, wie sie heißt, welche Parameter sie erwartet und welchen Rückgabewert sie liefert. Wer die Funktion benutzt, muss nur die Schnittstelle kennen.\n",
    "\n",
    "| Teil | Funktion mit Parametern | Rückgabewert |\n",
    "|:-:|:--|:--|\n",
    "| A | `verschluessle_buchstabe(buchstabe, schluessel)` | der verschobene Buchstabe |\n",
    "| B | `verschluessle_text(text, schluessel)` | der Geheimtext |\n",
    "| C | Hauptprogramm (keine Funktion) | – (fragt ab und gibt aus) |\n",
    "\n",
    "B benutzt A. Trotzdem kann man B schon programmieren, bevor A fertig ist: Man kennt ja die Schnittstelle von A.\n",
    "\n",
    "### ✏️ Übung 2 – Projektplan\n",
    "Plant gemeinsam auf Papier, **bevor** ihr programmiert:\n",
    "1. Wie ermittelt man zu einem Buchstaben seine Position im Alphabet?\n",
    "2. Wie kommt man von der Position zurück zum (verschobenen) Buchstaben?\n",
    "3. Was passiert am Ende des Alphabets, z. B. bei `Z` mit dem Schlüssel 3?\n",
    "\n",
    "Verteilt dann die Teilaufgaben. Niemand testet die eigene Funktion allein.\n",
    "\n",
    "| Teilaufgabe | programmiert von | getestet von | fertig? |\n",
    "|:--|:--|:--|:-:|\n",
    "| A: einen Buchstaben verschlüsseln | | | |\n",
    "| B: einen Text verschlüsseln | | | |\n",
    "| C: interaktives Programm | | | |\n",
    "\n",
    "**Unsere Antworten zu den Fragen 1 bis 3:**\n",
    "\n",
    "…"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Werkzeuge für das Projekt\n",
    "\n",
    "### Das Alphabet als Zeichenkette\n",
    "Den Index eines Zeichens findet ihr mit `.index()`, das kennt ihr von den Listen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alphabet = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n",
    "print(alphabet)\n",
    "print(\"Position von C:\", alphabet.index(\"C\"))\n",
    "print(\"Buchstabe an Position 5:\", alphabet[5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`alphabet.index(\"C\")` geht vom **Zeichen** zur **Position** (2), `alphabet[5]` von der **Position** zum **Zeichen** (F).\n",
    "\n",
    "### ⚠️ Stolperstein: Zeichen, die nicht im Alphabet stehen\n",
    "Führe die Zelle aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alphabet = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n",
    "print(alphabet.index(\"a\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`ValueError: substring not found` heißt „Teilzeichenkette nicht gefunden“. Prüft deshalb vorher mit `zeichen in alphabet`, ob das Zeichen ein Großbuchstabe ist.\n",
    "\n",
    "### Am Ende des Alphabets: der Rest-Operator\n",
    "X hat die Position 23, um 3 verschoben ergibt das 26. Die gibt es nicht. Nach Z soll es wieder bei A weitergehen, wie auf einer Uhr nach 12 wieder die 1 kommt. Das leistet der **Rest-Operator** `%`: Für Zahlen von 0 bis 25 ändert sich nichts, aus 26 wird 0, aus 27 wird 1.\n",
    "\n",
    "**🔮 Vorhersage:** Welche vier Zeilen gibt die Schleife aus?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for position in range(22, 26):\n",
    "    neue_position = (position + 3) % 26\n",
    "    print(position, \"->\", neue_position)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W (22) wird zu Z (25), X (23) zu A (0), Y zu B, Z zu C. Die Klammern sind wichtig: erst addieren, dann den Rest bilden.\n",
    "\n",
    "> 📌 **Merksatz:** Mit `(position + schluessel) % 26` erhält man immer eine gültige Position von 0 bis 25. Am Ende des Alphabets geht es dadurch vorne weiter.\n",
    "\n",
    "> 🧰 **Zweiter Weg (freiwillig):** Der Computer speichert jedes Zeichen als Zahl. `ord(\"A\")` ist 65, `chr(68)` ist `\"D\"`. Die Position im Alphabet ist `ord(buchstabe) - ord(\"A\")`, zurück geht es mit `chr(position + ord(\"A\"))`. Entscheidet euch im Team für **einen** Weg."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 Teilaufgabe A – einen Buchstaben verschlüsseln (Lücken füllen)\n",
    "Die Teilaufgaben werden schrittweise selbstständiger: A ist ein Lückencode, B hat ein Gerüst aus Kommentaren, C setzt ihr allein zusammen.\n",
    "\n",
    "Schreibt eine Funktion `verschluessle_buchstabe(buchstabe, schluessel)`, die **einen** Großbuchstaben um `schluessel` Stellen verschiebt und den neuen Buchstaben zurückgibt. Die drei Schritte kennt ihr aus Übung 2 (Projektplan): Position finden, verschieben und mit `% 26` umlaufen lassen, Buchstaben ablesen. Ersetzt jedes `___`.\n",
    "\n",
    "> 💡 **Tipp:** Gute Tests prüfen nicht nur den **Normalfall** (A → D), sondern auch die **Randfälle**: das Ende des Alphabets (X, Y, Z) und besondere Schlüssel wie 0 oder 25.\n",
    "\n",
    "| Aufruf | erwartet | tatsächlich | ✓ oder ✗ |\n",
    "|:--|:-:|:-:|:-:|\n",
    "| `verschluessle_buchstabe(\"A\", 3)` | `D` | | |\n",
    "| `verschluessle_buchstabe(\"X\", 3)` | `A` | | |\n",
    "| `verschluessle_buchstabe(\"Z\", 1)` | `A` | | |\n",
    "| `verschluessle_buchstabe(\"M\", 0)` | `M` | | |\n",
    "| `verschluessle_buchstabe(\"B\", 25)` | `A` | | |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alphabet = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n",
    "\n",
    "def verschluessle_buchstabe(buchstabe, schluessel):\n",
    "    position = alphabet.index(___)\n",
    "    neue_position = (___ + ___) % 26\n",
    "    return alphabet[___]\n",
    "\n",
    "print(verschluessle_buchstabe(\"A\", 3))    # erwartet: D\n",
    "print(verschluessle_buchstabe(\"X\", 3))    # erwartet: A\n",
    "print(verschluessle_buchstabe(\"Z\", 1))    # erwartet: A\n",
    "print(verschluessle_buchstabe(\"M\", 0))    # erwartet: M\n",
    "print(verschluessle_buchstabe(\"B\", 25))   # erwartet: A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5 Teilaufgabe B – einen ganzen Text verschlüsseln (mit Gerüst)\n",
    "Ihr braucht das Muster *Einen neuen Text aufbauen* aus DS 10. Es funktioniert wie die Summenbildung, nur mit Text: Man beginnt mit `\"\"` und hängt in der Schleife mit `+` Zeichen an."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"ABC\"\n",
    "ergebnis = \"\"\n",
    "for zeichen in text:\n",
    "    ergebnis = ergebnis + zeichen + zeichen\n",
    "print(ergebnis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Schreibt eine Funktion `verschluessle_text(text, schluessel)`, die in einer Schleife jeden Buchstaben mit `verschluessle_buchstabe` verschlüsselt und den Geheimtext zurückgibt. Kontrolle: `verschluessle_text(\"HALLO\", 3)` ergibt `KDOOR`.\n",
    "2. **Zusatz-Herausforderung:** Was passiert bei `\"Hallo Welt!\"`? Überlegt euch im Team eine Lösung, z. B. Leerzeichen und Satzzeichen unverändert lassen und den Text vorher mit `.upper()` umwandeln. Kontrolle: `KDOOR ZHOW!`.\n",
    "\n",
    "Die Zelle benutzt eure Funktion aus Teilaufgabe A. Führt die Zelle oben deshalb zuerst aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def verschluessle_text(text, schluessel):\n",
    "    # ergebnis beginnt als leere Zeichenkette\n",
    "    # für jedes Zeichen im Text:\n",
    "    #     das Zeichen mit verschluessle_buchstabe verschlüsseln\n",
    "    #     und an ergebnis anhängen\n",
    "    # ergebnis zurückgeben\n",
    "    pass\n",
    "\n",
    "print(verschluessle_text(\"HALLO\", 3), \"erwartet: KDOOR\")\n",
    "# Zusatz-Herausforderung:\n",
    "# print(verschluessle_text(\"Hallo Welt!\", 3), \"erwartet: KDOOR ZHOW!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6 Teilaufgabe C – das interaktive Programm (selbstständig)\n",
    "Setzt beide Funktionen zu einem vollständigen Programm zusammen, in dieser Reihenfolge: Alphabet, Funktion A, Funktion B, Hauptprogramm. Das Hauptprogramm fragt Klartext und Schlüssel mit `input()` ab und gibt den Geheimtext aus. Testet mit mindestens drei Eingaben. Kontrolle: „Treffen um acht“ mit Schlüssel 5 ergibt `YWJKKJS ZR FHMY`.\n",
    "\n",
    "Schreibt an den Anfang einen **Kommentar** mit dem Programmnamen, eurem Team und einem Satz dazu, was das Programm tut."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Caesar-Chiffre: Texte verschlüsseln\n",
    "# Team:\n",
    "# Was das Programm tut:\n",
    "\n",
    "# TODO: Teilaufgabe C – Alphabet, Funktion A, Funktion B, Hauptprogramm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📒 Projekttagebuch\n",
    "Tragt am Ende der Arbeitsphase ein, was ihr geschafft habt, welche Probleme aufgetreten sind und was als Nächstes kommt. Ihr braucht es in DS 14.\n",
    "\n",
    "| Datum | erledigt | Probleme und wie wir sie gelöst haben | nächster Schritt |\n",
    "|:--|:--|:--|:--|\n",
    "| | | | |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📌 Das Wichtigste in Kürze\n",
    "- Die **Caesar-Chiffre** verschiebt jeden Buchstaben um eine feste Anzahl von Stellen (den **Schlüssel**) im Alphabet. Aus dem **Klartext** wird der **Geheimtext**.\n",
    "- Die Position eines Buchstabens ist sein Index in `\"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"` (oder `ord(buchstabe) - ord(\"A\")`).\n",
    "- `(position + schluessel) % 26` sorgt dafür, dass es nach Z wieder bei A weitergeht.\n",
    "- Einen neuen Text baut man auf, indem man mit `\"\"` beginnt und in einer Schleife Zeichen anhängt.\n",
    "- Im Team zerlegt man das Problem in Teilaufgaben, legt vorher die **Schnittstellen** fest, testet jede Funktion mit Normal- und Randfällen und führt die Teile am Ende zusammen.\n",
    "\n",
    "> **In DS 14** entwickelt ihr die passende **Entschlüsselung** und recherchiert Berufsfelder rund um die Softwareentwicklung. Zum Weiterüben: `DS13_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
}