{
  "workbooktitle": "Rekursion mit den Mönchen von Mons Komputarius",
  "storytitle": "1a · Die Mönche von Mons Komputarius",
  "sortingtitle": "1b–1g · Rekursion verstehen",
  "countingtitle": "2 · Anwenden der Rekursion",
  "dialoguelabel": "Dialog",
  "introduction": "Ein Reisender sucht eine Lösung für seine unsortierten Karten. Die Mönche zeigen ihm einen Weg, bei dem ein Problem immer kleiner wird – und die Lösung auf dem Rückweg entsteht.\n\nDiese digitale Fassung basiert auf dem Arbeitsheft vom **29.04.2025**. Lies die Geschichte Bild für Bild; mit **Zurück** und **Weiter** kannst du jeden einzelnen Gesprächs- und Handlungsschritt erneut ansehen. In jedem Bild spricht höchstens eine Person: Ihr Mund ist geöffnet. **R** steht für den Reisenden, **M** für den Obermönch und **K** für das Kind. **...** begleitet stille Handlungen und Denkpausen.\n\nDie Karten werden auf dem Rückweg links eingefügt; die fertige Reihe ist deshalb **absteigend** sortiert. In der Fortsetzung zählt der Reisende einen Turm aus drei Steinen. Anschließend übst du selbst einen rekursiven Zeichenalgorithmus.",
  "task1a": "Schaue dir das informatische Theaterstück **„Die Mönche von Mons Komputarius“** an. Achte besonders darauf, was die Mönche mit dem Tablett und ihren Karten machen.",
  "task1b": "Die Arbeit der Mönche hat zwei Phasen – bevor und nachdem der Reisende das Tablett zurückgibt. Beschreibe, wie sich das Problem (zu sortierende Karten) und die Lösung (sortierte Karten) in beiden Phasen jeweils verändern.",
  "recursionexplanation": "**Rekursion** ist eine Programmiertechnik, die ein Problem als Parameter bekommt. Die Funktion vereinfacht das Problem zunächst. Anschließend ruft sie sich selbst mit dem vereinfachten Problem auf.\n\nDer allgemeine Aufbau aus dem Arbeitsheft lässt sich so schreiben (Pseudocode):\n\n```text\nfunktion problem_lösen(problem):\n    wenn problem bereits gelöst:                  # Abbruchbedingung\n        gib die bekannte Lösung zurück\n    sonst:\n        vereinfachung, kleineres_problem =\n            problem_vereinfachen(problem)         # Vereinfachung\n        teillösung = problem_lösen(kleineres_problem)  # Rekursiver Aufruf\n        lösung = zusammensetzen(vereinfachung, teillösung)\n                                                  # Zusammensetzen\n        gib lösung zurück\n```\n\nBeobachte den Code **vor** und **nach** dem rekursiven Aufruf. Der aufrufende Mönch wartet auf die Teillösung, bevor er fortfahren kann.",
  "task1c": "Beschreibe, wo in der Geschichte die folgenden Elemente vorkommen: **Vereinfachung**, **rekursiver Aufruf**, **Abbruchbedingung**, **Zusammensetzen**.",
  "task1d": "Begründe, weshalb jeder Mönch zu zwei unterschiedlichen Zeitpunkten etwas machen muss. Erkläre, woran man im Code erkennen kann, was in der ersten und was in der zweiten Phase passiert.",
  "task1e": "Beschreibe am Beispiel der Karten, was passieren würde, wenn die Abbruchbedingung nicht am Anfang des Codes stehen würde.",
  "task1f": "Gib den **Pseudocode für den Sortieralgorithmus** an. Verwende dieselbe Sortierrichtung wie in der Geschichte und kennzeichne die vier Bestandteile einer rekursiven Funktion.",
  "task1g": "Erkläre, weshalb der Reisende den Algorithmus auch allein ausführen kann und was er mit **„Ich habe zwar nicht genug Hände … aber auf meinem Tisch ist Platz genug“** meint.",
  "task2a": "Lies die Fortsetzung des Theaterstücks. Der Reisende ist inzwischen wieder zu Hause.",
  "task2b": "Beschreibe, wie der Reisende vorgeht, und benutze dabei die Begriffe **Vereinfachung**, **rekursiver Aufruf**, **Abbruchbedingung** und **Zusammensetzen**.",
  "task2c": "Zu Beginn der Ausführung liegt oben auf dem Tisch eine Strichliste ohne Striche. Im unteren Bereich liegt nichts. Skizziere die Situation, wobei der Reisende einen Turm mit **3 Steinen** in der Hand hält.\n\nDu kannst deine Skizze auf Papier anfertigen. Halte im Antwortfeld fest, was **oben**, **unten** und **in der Hand** zu sehen ist.",
  "task2d": "Skizziere die Situation, die bei der Ausführung **direkt vor jedem rekursiven Aufruf** existiert. Gehe vom Turm mit 3 Steinen aus.\n\nErgänze deine Skizzen auf Papier. Beschreibe im Antwortfeld für jeden Aufruf: **verbleibender Turm | abgelegte Steine | Strichliste**.",
  "task2e": "Beschreibe, wie die Strichliste technisch im Code umgesetzt werden kann.",
  "task2f": "Gib den **Pseudocode des Zählalgorithmus** des Reisenden an.",
  "task2g": "Die Mönche würden anders vorgehen: Statt eine Strichliste neben dem Tisch zu führen, würde jeder Mönch einen Stein auf das Tablett geben, bevor er es zurückgibt. Beschreibe, wie diese Art des Zählens technisch im Code umgesetzt werden kann.",
  "task2h": "**Rekursive Funktionen** sind einfach zu schreiben. Ihre Ausführung ist jedoch häufig schwerer nachzuvollziehen, da die Funktion selten „am Stück“ ausgeführt wird – also von Beginn bis zur Rückgabe, ohne zu einer anderen Stelle zu springen.\n\nEine rekursive Funktion wird meistens nur in genau einer Situation „am Stück“ ausgeführt. **In welcher und warum?**",
  "functionalexplanation": "Die Implementierung einer Funktion wird als **funktional** bezeichnet, wenn sie keinen veränderlichen Zustand besitzt, der außerhalb der Funktion gespeichert ist – beispielsweise eine Strichliste.",
  "task2i": "Begründe, ob das Vorgehen der Mönche und des Reisenden beim Zählen **funktional** ist.",
  "task2j": "Begründe, warum häufig empfohlen wird, rekursive Algorithmen auch **funktional** zu implementieren.",
  "task1atitle": "Aufgabe 1a)",
  "task1btitle": "Aufgabe 1b)",
  "task1ctitle": "Aufgabe 1c)",
  "task1dtitle": "Aufgabe 1d)",
  "task1etitle": "Aufgabe 1e)",
  "task1ftitle": "Aufgabe 1f)",
  "task1gtitle": "Aufgabe 1g)",
  "task2atitle": "Aufgabe 2a)",
  "task2btitle": "Aufgabe 2b)",
  "task2ctitle": "Aufgabe 2c)",
  "task2dtitle": "Aufgabe 2d)",
  "task2etitle": "Aufgabe 2e)",
  "task2ftitle": "Aufgabe 2f)",
  "task2gtitle": "Aufgabe 2g)",
  "task2htitle": "Aufgabe 2h)",
  "task2ititle": "Aufgabe 2i)",
  "task2jtitle": "Aufgabe 2j)",
  "silence": "...",
  "entrancedialogue": "**R:** „Meister … ich suche Lösungen!“",
  "warningdialogue": "**M:** „Das wundert mich nicht … wer so schnell zur Tat schreitet, wird zwangsläufig an allen Lösungen vorbeilaufen.“",
  "shoutdialogue": "**R:** „MEISTER!“",
  "cards-demanddialogue": "**R:** „Meine Karten! Sie müssen sortiert werden!“",
  "in-deed-onedialogue": "**M:** „In der Tat!“",
  "help-uncertaindialogue": "**R:** „Meister, ich weiß nicht wie.“",
  "help-questiondialogue": "**R:** „Könnt … könnt ihr mir helfen?“",
  "help-insistentdialogue": "**R:** „So helft mir!“",
  "journey-questiondialogue": "**M:** „Mein lieber Fremder … wie lange bist du hierhergereist?“",
  "journey-answerdialogue": "**R:** „Mit dem Flug … 20 Stunden!“",
  "return-questiondialogue": "**M:** „Und wie lange wirst du zurückreisen?“",
  "return-answerdialogue": "**R:** „… vermutlich auch 20 Stunden?“",
  "patiencedialogue": "**M:** „Mein lieber Fremder … Unsere Wege kann ich dir zeigen. Aber ob du sie verstehst … das kann ich dir nicht versprechen. Schwer sind sie nicht … doch brauchen sie eine Ruhe, die dir zu fehlen scheint …“",
  "tray-instructiondialogue": "**M:** „Leg die Karten auf das Tablett.“",
  "watchdialogue": "**M:** „Pass gut auf und lerne!“",
  "emptydialogue": "**M:** „Mein lieber Fremder … du suchst Lösungen und doch siehst du eine Lösung nicht einmal dann, wenn sie direkt vor dir steht …“",
  "givebackdialogue": "**M:** „Fremder … gib ihm das Tablett zurück!“",
  "sorteddialogue": "**M:** „Mein lieber Fremder. Du kennst nun unsere Wege. Gehe hinaus und bediene dich unseres Wissens, wann immer es nötig ist. Und hab keine Sorge: Es braucht keinen Tempel voll Mönche, um die Aufgabe zu erfüllen. Disziplin und Ruhe reichen völlig aus!“",
  "understooddialogue": "**R:** „Ich verstehe vollkommen! Ich weiß, dass ich das auch allein schaffe. Ich habe zwar nicht genug Hände … aber auf meinem Tisch ist Platz genug. Danke, großer Meister!“",
  "farewelldialogue": "**M:** „Ich sehe, du hast verstanden. Zieh nun hinfort … und gehe die Dinge in Zukunft etwas ruhiger an!“",
  "familydialogue": "**K:** „Mama, Papa, schaut mal, was ich gebaut habe!“",
  "family-father-replydialogue": "**R:** „Ja, sehr schön, mein Schatz.“",
  "family-child-questiondialogue": "**K:** „Weißt du, wie groß der ist?“",
  "family-father-hurrydialogue": "**R:** „Nein, aber wir müssen jetzt auch …“",
  "count-explanationdialogue": "**R:** „Nein, mein Schatz … Aber ich weiß, wie wir es herausfinden!“",
  "kochtitle": "3 · Rekursion selbst programmieren: die Koch-Kurve",
  "kochintroduction": "Jetzt programmierst du einen eigenen rekursiven Algorithmus. Die **Koch-Kurve** entsteht, indem jede Strecke durch vier kürzere Strecken ersetzt wird: Das mittlere Drittel wird zu einer dreieckigen Spitze. Die Gesamtlänge von Start bis Ziel bleibt **270 Schritte**.\n\nÖffne den Editor. Du kannst in **Python** oder mit eigenen **Snap-Blöcken** arbeiten. Nutze eine Funktion mit den Parametern **Länge** und **Tiefe** und übernimm sie von einer Aufgabe in die nächste. Die Vorschau zeigt die Zielzeichnung und dein Ergebnis. Die roten Pfeile der Vorlage markieren Richtungen; sie gehören nicht zur Zeichnung.",
  "koch0title": "3a · Die einfache Linie — Tiefe 0",
  "koch0": "Zeichne eine waagerechte Linie von **270 Schritten** nach rechts. Schreibe dafür eine Funktion `koch(laenge, tiefe)`. Bei `tiefe == 0` zeichnet sie eine Strecke mit `forward(laenge)` und ist fertig. Rufe sie zunächst mit Länge **270** und Tiefe **0** auf. Das ist die **Abbruchbedingung** deiner rekursiven Funktion.",
  "koch1title": "3b · Eine dreieckige Spitze — Tiefe 1",
  "koch1": "Erweitere dieselbe Funktion: Bei größerer Tiefe teilst du die Länge durch **3** und rufst `koch` **viermal** mit der kürzeren Länge und einer um **1** verringerten Tiefe auf. Zwischen den Aufrufen drehst du **60° nach links**, **120° nach rechts** und **60° nach links**. Zeichne die Zielkurve mit Länge **270** und Tiefe **1**. Jede der vier Strecken ist **90 Schritte** lang. Die Turtle zeigt am Ende wieder nach rechts. Verwende die rekursiven Aufrufe statt vier fest eingebauter `forward`-Befehle.",
  "koch2title": "3c · Jede Teilstrecke wird wieder ersetzt — Tiefe 2",
  "koch2": "Übernimm deine Funktion aus Aufgabe 3b. Ändere nur die Tiefe des ersten Aufrufs auf **2**. Jetzt wird jede der vier Teilstrecken erneut durch das gleiche Muster ersetzt: Es entstehen **16 Strecken** von je **30 Schritten**. Vergleiche deine Zeichnung mit dem Ziel. Prüfe, ob du dieselbe Funktion für Tiefe **0**, **1** und **2** verwenden kannst. Beschreibe beim Nachvollziehen für dich: Was wird vereinfacht, wann endet ein Aufruf und wie entstehen aus den vier Teilzeichnungen die nächste Kurve?"
}