Reorganize code examples

.gitignore

@@ -0,0 +1,8 @@
+graphify-out/
+graphity-out
+.json
+main.pdf
+CLAUDE.md
+.idea/
+__pycache__/
+*.pyc

Code/01_vorbereitung/test_installation.py

@@ -0,0 +1,20 @@
+import sys
+import platform
+
+print("=" * 50)
+print("Installation Überprüfung")
+print("=" * 50)
+
+# Python-Version
+print(f"\n✓ Python-Version: {sys.version}")
+
+# Betriebssystem
+print(f"✓ Betriebssystem: {platform.system()}")
+
+# Architektur
+print(f"✓ Architektur: {platform.machine()}")
+
+print("\n" + "=" * 50)
+print("Alle Überprüfungen bestanden! 🎉")
+print("=" * 50)
+print("\nNächster Schritt: Lektion 2 - Hello World")

Code/02_helloworld/HelloWorld.java

@@ -0,0 +1,5 @@
+public class HelloWorld {
+    public static void main(String[] args) {
+        System.out.println("Hello World!");
+    }
+}

Code/02_helloworld/helloworld.cpp

@@ -0,0 +1,6 @@
+#include <iostream>
+
+int main() {
+    std::cout<<"Hello world!"<<std::endl;
+    return 0;
+}

Code/07_variablen_arithmetik/eingabe_zahlen.py

@@ -0,0 +1,17 @@
+# input() hält das Programm an und wartet auf eine Eingabe der Nutzerin.
+# WICHTIG: input() liefert das Eingegebene IMMER als Text (str) zurück -
+# auch dann, wenn die Nutzerin eine Zahl eingetippt hat.
+
+erste_eingabe = input("Gib eine Zahl ein: ")
+zweite_eingabe = input("Gib noch eine Zahl ein: ")
+
+# "+" verbindet zwei Texte einfach hintereinander (Konkatenation).
+# Bei den Eingaben "12" und "3" käme hier "123" heraus - nicht 15!
+print("Als Text aneinandergehängt:", erste_eingabe + zweite_eingabe)
+
+# Damit wir rechnen können, müssen wir den Text erst in eine ganze Zahl
+# umwandeln. Das erledigt die Funktion int().
+erste_zahl = int(erste_eingabe)
+zweite_zahl = int(zweite_eingabe)
+
+print("Als Zahlen addiert:", erste_zahl + zweite_zahl)

Code/07_variablen_arithmetik/rechnen.py

@@ -0,0 +1,18 @@
+# Rechnen mit ganzen Zahlen. Python nutzt die Rechenausdrücke, die wir aus
+# der Schule kennen, plus die bereits bekannte Zuweisung mit "=".
+
+a = 18
+b = 5
+
+print("Summe:        ", a + b)   # 23
+print("Differenz:    ", a - b)   # 13
+print("Produkt:      ", a * b)   # 90
+print("Quotient:     ", a / b)   # 3.6   <- / liefert IMMER eine Kommazahl (float)
+print("Ganzzahl-Div: ", a // b)  # 3     <- // schneidet den Rest ab
+print("Rest (modulo):", a % b)   # 3     <- was bei 18 : 5 übrig bleibt
+print("Potenz:       ", a ** b)  # 1889568  <- a hoch b
+
+# Rechenreihenfolge ("Punkt vor Strich") gilt wie in der Mathematik.
+# Mit Klammern kann man sie steuern:
+print(2 + 3 * 4)     # 14
+print((2 + 3) * 4)   # 20

Code/07_variablen_arithmetik/rechner_eingabe.py

@@ -0,0 +1,13 @@
+# Ein kleines Rechenprogramm: Es nimmt zwei ganze Zahlen entgegen und gibt
+# Summe, Differenz, Produkt und Quotient aus.
+
+erste_zahl = int(input("Gib eine ganze Zahl ein: "))
+zweite_zahl = int(input("Gib noch eine ganze Zahl ein: "))
+
+print("Summe:     ", erste_zahl + zweite_zahl)
+print("Differenz: ", erste_zahl - zweite_zahl)
+print("Produkt:   ", erste_zahl * zweite_zahl)
+print("Quotient:  ", erste_zahl / zweite_zahl)
+
+# f-strings sind bequem, um Text und Werte zu mischen:
+print(f"{erste_zahl} geteilt durch {zweite_zahl} ist {erste_zahl / zweite_zahl}")

Code/07_variablen_arithmetik/variablen.py

@@ -0,0 +1,5 @@
+beschreibung = "wundervoll"
+
+print(f"Hallo, mein Tag war {beschreibung}!")
+print(f"ich habe {beschreibung} aus einem skript gelernt.")
+print(f"Ich hoffe dir geht es genauso {beschreibung}")

Code/07_variablen_arithmetik/variablen_aendern.py

@@ -0,0 +1,23 @@
+# Ein Programm ist eine Folge von Anweisungen, die von oben nach unten
+# abgearbeitet werden - keine Sammlung mathematischer Aussagen.
+
+zaehler = 0          # Lasse zaehler zuerst den Wert 0 haben.
+zaehler = zaehler + 1  # Nimm den aktuellen Wert (0), addiere 1, speichere zurueck.
+zaehler = zaehler + 1  # Und noch einmal: aus 1 wird 2.
+
+print("zaehler ist jetzt:", zaehler)
+
+# Mathematisch ergibt "zaehler = zaehler + 1" keinen Sinn.
+# Als Anweisung gelesen heisst es: "Der Name links soll ab jetzt den
+# Wert der rechten Seite tragen."
+
+# Eine Variable kann im Laufe des Programms ihren Wert - und sogar ihre
+# Art von Wert - wechseln:
+inhalt = "ein Text"
+print(inhalt, "->", type(inhalt))
+
+inhalt = 42
+print(inhalt, "->", type(inhalt))
+
+inhalt = 3.5
+print(inhalt, "->", type(inhalt))

Code/08_kontrollfluss/division_pruefen.py

@@ -0,0 +1,18 @@
+# Aus der letzten Lektion: Dieses Programm stuerzt ab, wenn die zweite
+# Zahl 0 ist (ZeroDivisionError). Jetzt fangen wir diesen Fall hoeflich ab.
+
+erste_zahl = int(input("Gib eine ganze Zahl ein: "))
+zweite_zahl = int(input("Gib noch eine ganze Zahl ein: "))
+
+# Die bedingte Anweisung: Python prueft, ob die Bedingung nach "if" wahr ist.
+if zweite_zahl == 0:
+    # Dieser Block wird NUR ausgefuehrt, wenn die Bedingung wahr ist.
+    print("Fehler: Durch 0 darf nicht geteilt werden.")
+else:
+    # Dieser Block wird ausgefuehrt, wenn die Bedingung falsch ist.
+    ergebnis = erste_zahl / zweite_zahl
+    print(f"{erste_zahl} geteilt durch {zweite_zahl} ist {ergebnis}")
+
+# Diese Zeile steht NICHT eingerueckt - sie gehoert zu keinem Block
+# und wird deshalb immer ausgefuehrt, egal wie die Eingabe war.
+print("Das Programm ist fertig.")

Code/08_kontrollfluss/einrueckung_wichtig.py

@@ -0,0 +1,23 @@
+# In Python entscheidet die EINRUECKUNG, welche Zeilen zu einem Block
+# gehoeren. Es gibt keine geschweiften Klammern wie in anderen Sprachen.
+
+alter = int(input("Wie alt bist du? "))
+
+# --- Version A: beide print-Zeilen sind eingerueckt ---------------------
+# Beide Zeilen gehoeren zum if-Block. Bei alter >= 18 werden BEIDE
+# ausgegeben, sonst KEINE.
+if alter >= 18:
+    print("Du bist volljaehrig.")
+    print("Du darfst waehlen.")
+
+# --- Zum Ausprobieren: ruecke die zweite Zeile aus --------------------
+# Wenn "Du darfst waehlen." NICHT eingerueckt ist, gehoert sie nicht mehr
+# zum if-Block. Dann wird sie IMMER ausgegeben - auch fuer eine 12.
+#
+# if alter >= 18:
+#     print("Du bist volljaehrig.")
+# print("Du darfst waehlen.")     # <- steht jetzt ausserhalb des if
+
+# Merke: Die Einrueckung ist nicht Deko, sie ist Teil der Bedeutung.
+# Ueblich sind 4 Leerzeichen pro Stufe. Alle Zeilen eines Blocks muessen
+# gleich weit eingerueckt sein.

Code/08_kontrollfluss/noten_kategorie.py

@@ -0,0 +1,23 @@
+# Mehr als zwei Faelle: mit "elif" (kurz fuer "else if") haengen wir
+# weitere Bedingungen an. Python prueft sie der Reihe nach von oben nach
+# unten und nimmt den ERSTEN Zweig, dessen Bedingung wahr ist.
+
+punkte = int(input("Wie viele Punkte hast du erreicht (0-100)? "))
+
+if punkte >= 90:
+    note = "sehr gut"
+elif punkte >= 75:
+    note = "gut"
+elif punkte >= 60:
+    note = "befriedigend"
+elif punkte >= 50:
+    note = "ausreichend"
+else:
+    # Wird nur erreicht, wenn KEINE der Bedingungen oben wahr war.
+    note = "nicht bestanden"
+
+print(f"Ergebnis: {note}")
+
+# Warum ist die Reihenfolge wichtig? Bei 95 Punkten ist auch
+# "punkte >= 75" wahr - aber Python hat den ersten passenden Zweig
+# (punkte >= 90) schon genommen und ueberspringt den Rest.

Code/08_kontrollfluss/vergleiche_und_wahrheit.py

@@ -0,0 +1,21 @@
+# Jede Bedingung ist im Kern eine Frage, die Python mit True (wahr) oder
+# False (falsch) beantwortet. True und False sind ein eigener Datentyp: bool.
+
+alter = 20
+
+print(alter == 20)   # Gleich?            -> True
+print(alter != 20)   # Ungleich?          -> False
+print(alter < 18)    # Kleiner?           -> False
+print(alter >= 18)   # Groesser-gleich?   -> True
+
+# Mit and, or und not lassen sich Bedingungen verknuepfen:
+temperatur = 24
+sonnig = True
+
+print(temperatur > 20 and sonnig)   # beide muessen wahr sein  -> True
+print(temperatur > 30 or sonnig)    # eine reicht              -> True
+print(not sonnig)                   # kehrt um                 -> False
+
+# Genau dieselben Ausdruecke stehen sonst hinter einem "if":
+if temperatur > 20 and sonnig:
+    print("Zeit fuer eine Pause draussen.")

Code/08_kontrollfluss/zahlenraten.py

@@ -0,0 +1,22 @@
+# Ein kleines Ratespiel - noch mit nur einem Versuch.
+# (In der naechsten Lektion, "Schleifen", geben wir mehrere Versuche.)
+
+GESUCHTE_ZAHL = 7
+
+tipp = int(input("Ich denke an eine Zahl von 1 bis 10. Dein Tipp? "))
+
+if tipp == GESUCHTE_ZAHL:
+    print("Volltreffer!")
+elif tipp < GESUCHTE_ZAHL:
+    print("Zu klein.")
+else:
+    print("Zu gross.")
+
+# Bonus: verschachtelte Bedingung. Der innere if steht weiter eingerueckt
+# und wird nur geprueft, wenn der aeussere if schon wahr war.
+if tipp != GESUCHTE_ZAHL:
+    abstand = GESUCHTE_ZAHL - tipp
+    if abstand < 0:
+        abstand = -abstand
+    if abstand == 1:
+        print("Aber ganz knapp daneben!")

Code/09_schleifen/teilbarkeit.py

@@ -0,0 +1,14 @@
+# Teilt die zweite Zahl die erste? Wir nutzen den Rest-Operator "%"
+# aus der letzten Lektion: Ist der Rest 0, dann ist die Division glatt
+# aufgegangen - die zweite Zahl ist ein Teiler der ersten.
+
+zahl = int(input("Zahl: "))
+teiler = int(input("Moeglicher Teiler: "))
+
+if teiler == 0:
+    print("Durch 0 teilt es sich nicht.")
+elif zahl % teiler == 0:
+    print(f"{teiler} teilt {zahl}.")
+else:
+    rest = zahl % teiler
+    print(f"{teiler} teilt {zahl} nicht (Rest {rest}).")

Lektionen/helloworld.typ

@@ -0,0 +1,116 @@
+#import "../lib/helpers.typ": *
+
+== Lektion 1: Hello World
+
+#Theorie[
+  === Was ist eine Programmiersprache?
+
+  Ein Computer versteht eigentlich nur Maschinencode – eine Abfolge von 0en und 1en. Eine Programmiersprache ist eine formale Sprache, die es Menschen ermöglicht, Anweisungen so zu schreiben, dass ein Computer sie verstehen _kann_. Sie ist ein Übersetzungssystem: Du schreibst in einer für Menschen lesbaren Syntax auf, was der Computer tun soll, und ein Programm (der Interpreter oder Compiler) übersetzt deine Anweisungen in Maschinencode.
+
+  === Warum Python?
+
+  Es gibt Hunderte von Programmiersprachen. Python hat sich für Anfänger als ideal erwiesen, weil:
+
+  1. *Lesbarkeit:* Python-Code sieht dem Englischen ähnlich. `print(“Hallo”)` ist selbsterklärend, anders als etwa #Code(“02_helloworld/helloworld.cpp”) oder #Code(“02_helloworld/helloworld.java”) .
+
+  2. *Minimalistische Syntax:* Python erzwingt saubere Formatierung durch Einrückungen. Das führt zu besseren Gewohnheiten.
+
+  3. *Unmittelbare Feedback-Schleife:* Du kannst Code schreiben und ihn sofort ausführen. Keine langen Kompilierungsschritte.
+
+  4. *Breite Anwendung:* Datenanalyse, KI, Web-Backend, Automatisierung – Python ist überall.
+
+  === Ausführung: Quellcode → Interpretation
+
+  Wenn du eine Python-Datei ausführst, passiert folgendes:
+
+  1. *Quellcode:* Du schreibst lesbare Befehle in `helloworld.py`. Das ist _Text_ – noch keine Anweisung für die CPU.
+
+  2. *Interpreter:* Python liest deine Datei zeilenweise. Für jede Zeile:
+     - Prüft Python die Syntax (ist die Syntax korrekt?)
+     - Übersetzt Python den Befehl in interne Anweisungen
+     - Führt Python den Befehl aus
+
+  3. *Ausführung:* Wenn Python `print(“Hallo Welt!”)` liest, sagt es der Konsole: “Gib diesen Text aus.” Die Konsole druckt es.
+
+  4. *Output:* Du siehst das Ergebnis.
+
+  _Wichtig:_ Python ist eine *interpretierte* Sprache. Das bedeutet: Jedes Mal, wenn du das Programm startest, wird es neu interpretiert. (Das unterscheidet sich von *kompilierten* Sprachen wie C++, die einmal übersetzt werden und dann direkt laufen.)
+
+  === Das “Hello World”-Ritual
+
+  “Hello World” ist die Tradition in der Informatik. Es ist nicht wegen der Aufgabe wichtig, sondern weil es das Fundamental-Konzept demonstriert: *Du kannst dem Computer befehlen, etwas zu tun, und er tut es.*
+
+  Das ist der Kern des Programmierens.
+]
+
+#Praxis[
+  Erstelle eine neue Datei namens `helloworld.py` und schreibe folgende Zeile:
+
+  ```python
+  print(“Hello World!”)
+  ```
+
+  Speichere und führe das Programm aus. Die Ausgabe sollte sein: `Hello World!`
+]
+
+#Code("02_helloworld/helloworld.py")
+
+=== Anatomie des Befehls
+
+#Theorie[
+  Der `print()`-Befehl zerlegt sich in drei Teile:
+
+  1. *Funktionsname:* `print` – der Name der Funktion, die wir aufrufen. Funktionen sind wiederverwendbare Bausteine, die eine spezifische Aufgabe erfüllen. Hier: Text in die Konsole schreiben.
+
+  2. *Klammern:* `()` – sie umschließen die _Argumente_ (die Eingaben für die Funktion). `print()` ohne Argumente würde eine leere Zeile drucken.
+
+  3. *Argument:* `”Hello World!”` – der String (Zeichenkette), den wir ausgeben möchten. Die Anführungszeichen sind syntaktisch erforderlich; sie teilen Python mit, dass es sich um Text handelt, nicht um Code.
+
+  _Grundregel:_ Python unterscheidet Groß- und Kleinschreibung. `print` ist korrekt, `Print` führt zu einem Fehler.
+]
+
+
+#Spiel[
+  Ihr könnt nun versuchen, den Quellcode selbst zu verändern und damit ein wenig herumzuspielen. Öffnet dazu einen Editor und öffnet die Datei. Denkt daran, nach jeder Änderung die Datei zu speichern und im Terminal neu auszuführen.
+
+  Dinge, die ihr ausprobieren könntet sind zum Beispiel:
+
+  - Was passiert, wenn ihr „Hello world!" in etwas anderes ändert?
+  - Was passiert, wenn ihr die Anführungszeichen löscht?
+  - Was passiert, wenn ihr zwei `print()`-Befehle hintereinander schreibt?
+  - Wie könnte man mehrere Sätze in einer Zeile ausgeben?
+
+  Experimentiert! Das Schöne an Python ist, dass ihr sofort Feedback bekommt, wenn etwas schiefläuf
+]
+#Quiz(answer: "Das andere wird ausgegeben" )[Was passiert, wenn ihr Hello world durch etwas anderes ersetzt?
++ Das andere wird ausgegeben
++ Es gibt einen Fehler
++ Das Programm tut garnichts mehr
++ Das Programm gibt trotzdem Hello world aus
+]
+
+=== Häufige Fehler und ihre Ursachen
+
+#Theorie[
+  Wenn dein Programm nicht läuft, liegt es an einer dieser Syntaxfehler:
+
+  *Fehler 1: Fehlende oder falsche Anführungszeichen*
+  ```python
+  print(Hallo Welt!)    # SyntaxError – kein String definiert
+  print(“Hallo Welt!”)  # Korrekt
+  ```
+
+  *Fehler 2: Falsche Großschreibung*
+  ```python
+  Print(“Hallo Welt!”)  # NameError – Python kennt Print nicht
+  print(“Hallo Welt!”)  # Korrekt
+  ```
+
+  *Fehler 3: Falsche Klammer-Typen*
+  ```python
+  print[“Hallo Welt!”]  # SyntaxError – eckige Klammern sind für Listen
+  print(“Hallo Welt!”)  # Korrekt – runde Klammern für Funktionen
+  ```
+
+  Diese Fehler sind typisch – sie passieren jedem. Der Schlüssel ist, die Fehlermeldung zu lesen. Python teilt dir präzise mit, was schiefgelaufen ist.
+]