Programmieren mit Python: Verzweigungen & while-Schleifen [KSR Wiki]

Diese Seite ist nicht editierbar. Du kannst den Quelltext sehen, jedoch nicht verändern. Kontaktiere den Administrator, wenn du glaubst, dass hier ein Fehler vorliegt.
====== - Programmieren mit Python: Verzweigungen & while-Schleifen ======

In diesem Dossier wiederholen wir die **Grundwerkzeuge** des Programmierens. Wir beschränken uns bewusst auf sehr wenige Sprachelemente: Variablen, Ein-/Ausgabe, **Verzweigungen** (`if`/`elif`/`else`) und **while-Schleifen**. Alles andere (`for`-Schleifen, Funktionen, Listen, Dictionaries) ist //nicht// erlaubt – ausser in den Zusatzaufgaben ganz am Schluss.

Das mag zuerst nach einer Einschränkung aussehen. Tatsächlich ist es aber genau umgekehrt: Mit diesen wenigen Bausteinen lässt sich **jedes** Programm schreiben. Wer sie sicher beherrscht, hat das Fundament gelegt.

Die Aufgaben werden von Kapitel zu Kapitel anspruchsvoller. Löse sie der Reihe nach und schaue dir die Lösung erst an, wenn du selbst einen ernsthaften Versuch unternommen hast.

++++Wichtige Python-Befehle|

<code python>
# Ausgabe
print("Hallo Welt")
print("Die Summe ist", summe)              # mehrere Dinge mit Komma trennen
print("Die Summe ist " + str(summe))       # oder als String zusammenhängen
print(f"Die Summe ist {summe}")            # f-String (elegant)
print("kein Zeilenumbruch", end=" ")       # Zeilenumbruch unterdrücken

# Eingabe (input() liefert IMMER einen String!)
name = input("Wie heisst du? ")
zahl = int(input("Gib eine ganze Zahl ein: "))
kommazahl = float(input("Gib eine Kommazahl ein: "))

# Rechenoperatoren
7 + 3      # 10   Addition
7 - 3      # 4    Subtraktion
7 * 3      # 21   Multiplikation
7 / 3      # 2.333...  Division (ergibt immer einen float!)
7 // 3     # 2    Ganzzahldivision (schneidet den Rest ab)
7 % 3      # 1    Modulo: der Rest bei der Division
7 ** 3     # 343  Potenz

# Vergleichsoperatoren (ergeben True oder False)
a == b     # gleich  (ACHTUNG: zwei Gleichheitszeichen!)
a != b     # ungleich
a < b      # kleiner
a <= b     # kleiner oder gleich
a > b      # grösser
a >= b     # grösser oder gleich

# Logische Verknüpfungen
a > 0 and b > 0     # beide Bedingungen müssen erfüllt sein
a > 0 or b > 0      # mindestens eine Bedingung muss erfüllt sein
not (a > 0)         # Umkehrung

# Verzweigung (beachte: elif und else sind optional. Man kann auch alleine verwenden: if, if-else, if-elif
if temperatur > 25:
    print("heiss")
elif temperatur > 15:
    print("angenehm")
else:
    print("kalt")

# while-Schleife
i = 1
while i <= 10:
    print(i)
    i = i + 1

# Zufallszahlen
import random
random.randint(1, 100)      # ganze Zufallszahl zwischen 1 und 100 (beide inklusive)

# Nützliches
abs(-3.5)          # 3.5   Betrag
round(3.14159, 2)  # 3.14  runden
"*" * 5            # "*****"  String vervielfachen
</code>

++++

++++Der Werkzeugkasten: 6 Muster, die du auswendig können musst|

Fast jede Aufgabe in diesem Dossier ist eine Kombination der folgenden Muster. Präge sie dir gut ein!

**1. Der Zähler** – zählt, wie oft etwas passiert ist:
<code python>
anzahl = 0                    # Startwert: noch nichts gezählt
...
anzahl = anzahl + 1           # ein Treffer mehr
</code>

**2. Der Summierer (Akkumulator)** – addiert Werte auf:
<code python>
summe = 0                     # Startwert: 0, denn 0 ändert bei der Addition nichts
...
summe = summe + zahl
</code>

**3. Der Multiplizierer** – multipliziert Werte auf:
<code python>
produkt = 1                   # Startwert: 1, denn 1 ändert bei der Multiplikation nichts. Fehler: 0 anstelle 1
...
produkt = produkt * zahl
</code>

**4. Die Laufvariable** – zählt die Schleifendurchgänge:
<code python>
i = 1
while i <= n:
    ...
    i = i + 1                 # Vergisst man diese Zeile -> Endlosschleife!
</code>

**5. Das Maximum (bzw. Minimum)** – merkt sich den bisher besten Wert:
<code python>
maximum = erste_zahl          # der erste Wert ist der bisher beste
...
if zahl > maximum:
    maximum = zahl
</code>

**6. Das Flag (die Merk-Variable)** – merkt sich, ob etwas eingetreten ist:
<code python>
gefunden = False              # bis jetzt haben wir nichts gefunden
...
if bedingung:
    gefunden = True
</code>

++++

===== - Aufwärmen: Variablen, Ein- und Ausgabe =====

Wir starten ganz gemütlich. Hier geht es nur darum, wieder ein Gefühl für Variablen, `input()` und `print()` zu bekommen.

<box 100%>
**Aufgabe:** Schreibe ein Programm, das nach dem Namen und dem Geburtsjahr fragt und dann ausgibt: ``Hallo Anna, du wirst dieses Jahr 17 Jahre alt.``

++++Lösung|
<code python>
name = input("Wie heisst du? ")
geburtsjahr = int(input("In welchem Jahr bist du geboren? "))

alter = 2026 - geburtsjahr

print("Hallo " + name + ", du wirst dieses Jahr " + str(alter) + " Jahre alt.")
</code>

Beachte: `input()` liefert immer einen **String**. Willst du damit rechnen, musst du ihn mit `int()` in eine Zahl umwandeln. Umgekehrt musst du beim Zusammenhängen mit `+` die Zahl mit `str()` wieder zu einem String machen.

Mit einem f-String geht es kürzer:
<code python>
print(f"Hallo {name}, du wirst dieses Jahr {alter} Jahre alt.")
</code>
++++
</box>

<box 100%>
**Aufgabe:** Frage die Länge und die Breite eines Rechtecks ab und gib Fläche und Umfang aus.

++++Lösung|
<code python>
laenge = float(input("Länge: "))
breite = float(input("Breite: "))

flaeche = laenge * breite
umfang = 2 * (laenge + breite)

print("Fläche:", flaeche)
print("Umfang:", umfang)
</code>

Hier verwenden wir `float()` statt `int()`, damit auch Kommazahlen wie `3.5` eingegeben werden können.
++++
</box>

<box 100%>
**Aufgabe:** Eine Anzahl Sekunden wird eingegeben (z.B. $3'750$). Gib sie im Format ``1 h 2 min 30 s`` aus.

//Tipp:// Du brauchst die Ganzzahldivision `//` und den Modulo-Operator `%`.

++++Lösung|
<code python>
total = int(input("Sekunden: "))

stunden = total // 3600          # wie viele ganze Stunden stecken drin?
rest = total % 3600              # was bleibt danach übrig?

minuten = rest // 60
sekunden = rest % 60

print(stunden, "h", minuten, "min", sekunden, "s")
</code>

Das Paar `//` und `%` ist eines der wichtigsten Werkzeuge überhaupt: `//` liefert, //wie oft// etwas hineinpasst, `%` liefert, //was übrig bleibt//. Wir werden es noch oft brauchen.
++++
</box>

===== - Verzweigungen =====

Ein Programm soll nicht immer dasselbe tun. Mit `if`, `elif` und `else` treffen wir Entscheidungen.

<box 100%>
**Aufgabe:** Lies eine ganze Zahl ein und gib aus, ob sie **gerade** oder **ungerade** ist.

++++Lösung|
<code python>
zahl = int(input("Zahl: "))

if zahl % 2 == 0:
    print("gerade")
else:
    print("ungerade")
</code>

Eine Zahl ist genau dann gerade, wenn sie bei der Division durch $2$ den Rest $0$ lässt. Der Test `zahl % 2 == 0` ist //der// Standardtrick für "gerade" und wird dir immer wieder begegnen.
++++
</box>

<box 100%>
**Aufgabe:** Lies eine ganze Zahl ein und gib aus, ob sie **positiv**, **negativ** oder **null** ist.

++++Lösung|
<code python>
zahl = int(input("Zahl: "))

if zahl > 0:
    print("positiv")
elif zahl < 0:
    print("negativ")
else:
    print("null")
</code>

Wichtig: Sobald ein Zweig zutrifft, werden **alle folgenden** `elif`/`else` übersprungen. Wenn also `zahl > 0` wahr ist, wird `zahl < 0` gar nicht mehr geprüft.
++++
</box>

<box 100%>
**Aufgabe:** Lies drei Zahlen ein und gib die **grösste** aus. Verwende dazu nur `if`/`elif`/`else` (kein `max()`).

++++Lösung|
<code python>
a = float(input("1. Zahl: "))
b = float(input("2. Zahl: "))
c = float(input("3. Zahl: "))

if a >= b and a >= c:
    print("Die grösste Zahl ist", a)
elif b >= a and b >= c:
    print("Die grösste Zahl ist", b)
else:
    print("Die grösste Zahl ist", c)
</code>

Eine elegantere Variante nach dem **Maximum-Muster** aus dem Werkzeugkasten – die wird später bei vielen Zahlen unentbehrlich:
<code python>
maximum = a                  # a ist vorläufig die grösste
if b > maximum:
    maximum = b
if c > maximum:
    maximum = c
print("Die grösste Zahl ist", maximum)
</code>
++++
</box>

<box 100%>
**Aufgabe:** Lies eine Punktzahl zwischen $0$ und $100$ ein und gib die Note nach folgender Tabelle aus:

^ Punkte ^ Note ^
| 90–100 | 6 |
| 75–89 | 5 |
| 60–74 | 4 |
| 40–59 | 3 |
| 0–39 | 2 |

Fange auch ungültige Eingaben (kleiner als $0$ oder grösser als $100$) ab.

++++Lösung|
<code python>
punkte = int(input("Punkte: "))

if punkte < 0 or punkte > 100:
    print("Ungültige Eingabe!")
elif punkte >= 90:
    print("Note 6")
elif punkte >= 75:
    print("Note 5")
elif punkte >= 60:
    print("Note 4")
elif punkte >= 40:
    print("Note 3")
else:
    print("Note 2")
</code>

Der Trick bei einer solchen `elif`-Kette: Wir prüfen **von oben nach unten** und müssen die untere Grenze jeweils gar nicht mehr testen. Kommt Python zur Zeile `elif punkte >= 75:`, dann //weiss// es bereits, dass `punkte < 90` gilt.
++++
</box>

<box 100%>
**Aufgabe:** Lies ein Jahr ein und gib aus, ob es ein **Schaltjahr** ist. Regel:
   * Durch $4$ teilbar → Schaltjahr,
   * ausser durch $100$ teilbar → kein Schaltjahr,
   * ausser durch $400$ teilbar → doch Schaltjahr.

Teste dein Programm mit $2024$, $1900$, $2000$ und $2023$.

++++Lösung|
Die Reihenfolge ist entscheidend: Wir müssen die **speziellste** Regel zuerst prüfen.

<code python>
jahr = int(input("Jahr: "))

if jahr % 400 == 0:
    print("Schaltjahr")
elif jahr % 100 == 0:
    print("kein Schaltjahr")
elif jahr % 4 == 0:
    print("Schaltjahr")
else:
    print("kein Schaltjahr")
</code>

Ergebnisse: $2024$ Schaltjahr, $1900$ kein Schaltjahr, $2000$ Schaltjahr, $2023$ kein Schaltjahr.

Alternativ mit einer einzigen logischen Bedingung:
<code python>
if (jahr % 4 == 0 and jahr % 100 != 0) or jahr % 400 == 0:
    print("Schaltjahr")
else:
    print("kein Schaltjahr")
</code>
++++
</box>

===== - Erste while-Schleifen =====

Eine `while`-Schleife wiederholt einen Block **solange** eine Bedingung wahr ist. Drei Dinge gehören immer dazu:
   - **Initialisierung:** die Laufvariable vor der Schleife setzen
   - **Bedingung:** wann soll weitergemacht werden?
   - **Veränderung:** die Laufvariable im Schleifenkörper verändern

Vergisst du Punkt 3, läuft dein Programm ewig. Mit ``Ctrl + C`` brichst du eine Endlosschleife ab.

<box 100%>
**Aufgabe:** Gib die Zahlen von $1$ bis $10$ aus, jede auf einer eigenen Zeile.

++++Lösung|
<code python>
i = 1                    # Initialisierung
while i <= 10:           # Bedingung
    print(i)
    i = i + 1            # Veränderung
</code>

Verfolge im Kopf, was passiert: `i` ist zuerst $1$, wird ausgegeben, dann auf $2$ erhöht. Beim Durchgang mit $i = 10$ wird noch ausgegeben, dann wird `i` auf $11$ gesetzt – und die Bedingung `11 <= 10` ist falsch. Die Schleife endet.
++++
</box>

<box 100%>
**Aufgabe:** Lies eine Zahl $n$ ein und mache einen **Countdown** von $n$ bis $0$. Am Schluss soll ``Start!`` ausgegeben werden.

++++Lösung|
<code python>
n = int(input("Von welcher Zahl soll der Countdown starten? "))

while n >= 0:
    print(n)
    n = n - 1

print("Start!")
</code>

Hier zählen wir **rückwärts**. Entsprechend dreht sich auch die Bedingung um: `n >= 0` statt `n <= 10`.
++++
</box>

<box 100%>
**Aufgabe:** Gib alle **Vielfachen von $7$** aus, die kleiner als $100$ sind.

Löse die Aufgabe auf **zwei** Arten:
   - mit einer Laufvariablen, die in Siebnerschritten wächst
   - mit einer Laufvariablen, die in Einerschritten wächst, plus einer Verzweigung

++++Lösung|
**Variante 1 – direkt in Siebnerschritten:**
<code python>
v = 7
while v < 100:
    print(v)
    v = v + 7
</code>

**Variante 2 – jede Zahl prüfen:**
<code python>
i = 1
while i < 100:
    if i % 7 == 0:
        print(i)
    i = i + 1
</code>

Variante 1 ist deutlich effizienter (sie macht 14 statt 99 Durchgänge). Variante 2 ist dafür flexibler: Sie lässt sich sofort auf kompliziertere Bedingungen erweitern, etwa "durch 7 //oder// durch 5 teilbar".
++++
</box>

<box 100%>
**Aufgabe:** Gib alle **Zweierpotenzen** aus, die höchstens $1000$ sind: $1, 2, 4, 8, \ldots$

++++Lösung|
<code python>
z = 1
while z <= 1000:
    print(z)
    z = z * 2
</code>

Ausgabe: $1, 2, 4, \ldots, 512$. Die Laufvariable muss sich **nicht** immer um einen festen Betrag ändern – hier wird sie verdoppelt. Dadurch wächst sie sehr schnell, und die Schleife ist nach 10 Durchgängen fertig.
++++
</box>

<box 100%>
**Aufgabe:** Gib eine Tabelle der Quadratzahlen und Kubikzahlen von $1$ bis $12$ aus:

<code>
 n     n^2     n^3
 1       1       1
 2       4       8
 3       9      27
 ...
</code>

//Tipp:// Mit `\t` erzeugst du einen Tabulator.

++++Lösung|
<code python>
print("n\tn^2\tn^3")

n = 1
while n <= 12:
    print(n, "\t", n**2, "\t", n**3)
    n = n + 1
</code>

Die Ausgabezeile lässt sich auch mit einem f-String schreiben, was besonders bei fixen Spaltenbreiten schöner aussieht:
<code python>
    print(f"{n:3} {n**2:6} {n**3:6}")
</code>
Dabei bedeutet `{n:3}`, dass die Zahl auf eine Breite von 3 Zeichen rechtsbündig ausgerichtet wird.
++++
</box>

===== - Aufsummieren und Aufmultiplizieren =====

Jetzt kommt das wohl wichtigste Muster überhaupt: der **Akkumulator**. Wir legen eine Variable an, die das Zwischenergebnis speichert, und verändern sie in jedem Schleifendurchgang.

<box 100%>
**Aufgabe:** Lies eine Zahl $n$ ein und berechne die Summe $1 + 2 + 3 + \ldots + n$.

++++Lösung|
<code python>
n = int(input("n: "))

summe = 0                     # noch nichts addiert
i = 1

while i <= n:
    summe = summe + i         # das ist der Kern des Ganzen
    i = i + 1

print("Die Summe ist", summe)
</code>

Die Zeile `summe = summe + i` liest sich anfangs seltsam. In der Mathematik wäre das eine unlösbare Gleichung! In der Programmierung bedeutet `=` aber **zuweisen**, nicht "ist gleich": Berechne die rechte Seite mit dem //alten// Wert von `summe` und speichere das Ergebnis als //neuen// Wert von `summe`.

Kürzer schreibt man dasselbe als `summe += i`.

//Kontrolle:// Für $n = 100$ muss $5050$ herauskommen (Gauss lässt grüssen).
++++
</box>

<box 100%>
**Aufgabe:** Berechne die **Fakultät** $n! = 1 \cdot 2 \cdot 3 \cdot \ldots \cdot n$.

++++Lösung|
<code python>
n = int(input("n: "))

produkt = 1                   # Startwert 1, NICHT 0!
i = 1

while i <= n:
    produkt = produkt * i
    i = i + 1

print(n, "! =", produkt)
</code>

Der häufigste Fehler hier: `produkt = 0` als Startwert. Dann bleibt das Ergebnis für immer $0$. Beim Summieren ist $0$ das neutrale Element, beim Multiplizieren ist es $1$.

//Kontrolle:// $5! = 120$, $10! = 3'628'800$.
++++
</box>

<box 100%>
**Aufgabe:** Berechne die Summe aller **geraden** Zahlen von $1$ bis $n$, und gleichzeitig die Summe aller **ungeraden**. Gib beide aus.

++++Lösung|
<code python>
n = int(input("n: "))

summe_gerade = 0
summe_ungerade = 0
i = 1

while i <= n:
    if i % 2 == 0:
        summe_gerade = summe_gerade + i
    else:
        summe_ungerade = summe_ungerade + i
    i = i + 1

print("gerade:  ", summe_gerade)
print("ungerade:", summe_ungerade)
</code>

Hier kombinieren wir zum ersten Mal Schleife und Verzweigung: Die Schleife besucht **jede** Zahl, die Verzweigung entscheidet, **welcher** Akkumulator erhöht wird. Zwei Akkumulatoren nebeneinander zu führen ist völlig üblich.
++++
</box>

<box 100%>
**Aufgabe:** Du legst $1000$ Franken zu $2\%$ Zins pro Jahr an. Nach wie vielen Jahren hast du zum ersten Mal mehr als $2000$ Franken? Gib auch den Kontostand nach jedem Jahr aus.

++++Lösung|
<code python>
kapital = 1000
jahre = 0

while kapital < 2000:
    kapital = kapital * 1.02
    jahre = jahre + 1
    print("Jahr", jahre, ":", round(kapital, 2))

print("Nach", jahre, "Jahren ist das Kapital verdoppelt.")
</code>

Antwort: nach **36** Jahren.

Das ist ein neuer Typ von Schleife! Bisher wussten wir vorher, wie oft sie läuft. Hier wissen wir es **nicht** – die Schleife läuft, bis eine Bedingung erfüllt ist. Genau dafür ist `while` gemacht, und genau hier wäre eine `for`-Schleife das falsche Werkzeug.
++++
</box>

===== - Eingabeschleifen: Abbruch durch den Benutzer =====

Bis jetzt haben wir immer eine feste Anzahl Zahlen verarbeitet. Nun soll der Benutzer selbst entscheiden, wann Schluss ist. Dazu vereinbart man einen **Abbruchwert** (engl. //sentinel//), z.B. die $0$.

<box 100%>
**Aufgabe:** Lies so lange Zahlen ein, bis der Benutzer $0$ eingibt. Gib danach die **Summe** aller eingegebenen Zahlen aus.

++++Lösung|
<code python>
summe = 0

zahl = int(input("Zahl (0 = Ende): "))      # erste Eingabe VOR der Schleife

while zahl != 0:
    summe = summe + zahl
    zahl = int(input("Zahl (0 = Ende): "))  # nächste Eingabe am ENDE der Schleife

print("Summe:", summe)
</code>

Dieses Muster heisst **"Lies vor der Schleife, lies am Ende der Schleife"**. Es sieht unschön aus, weil die `input()`-Zeile zweimal vorkommt, ist aber der saubere Standardweg: Die Bedingung `zahl != 0` kann nur geprüft werden, wenn bereits eine Zahl vorliegt.

Wichtig: Die $0$ selbst wird **nicht** mitgezählt – sobald sie eingegeben wird, bricht die Schleife ab, bevor sie addiert wird.
++++
</box>

<box 100%>
**Aufgabe:** Erweitere das vorige Programm: Gib zusätzlich die **Anzahl** der eingegebenen Zahlen und den **Mittelwert** aus. Achte darauf, dass dein Programm nicht abstürzt, wenn der Benutzer sofort $0$ eingibt.

++++Lösung|
<code python>
summe = 0
anzahl = 0

zahl = int(input("Zahl (0 = Ende): "))

while zahl != 0:
    summe = summe + zahl
    anzahl = anzahl + 1                     # der Zähler aus dem Werkzeugkasten
    zahl = int(input("Zahl (0 = Ende): "))

print("Anzahl:", anzahl)
print("Summe: ", summe)

if anzahl > 0:
    print("Mittelwert:", summe / anzahl)
else:
    print("Keine Zahlen eingegeben.")
</code>

Der Zähler und der Summierer laufen hier **parallel** mit. Die abschliessende Verzweigung ist kein Schönheitsfehler, sondern notwendig: Ohne sie würde `summe / anzahl` bei $0$ Eingaben eine Division durch null verursachen und das Programm abstürzen lassen. Solche **Randfälle** (engl. //edge cases//) mitzudenken gehört zum Handwerk.
++++
</box>

<box 100%>
**Aufgabe:** Lies wieder Zahlen ein, bis $0$ eingegeben wird. Gib die **grösste** und die **kleinste** eingegebene Zahl aus. Es dürfen auch negative Zahlen eingegeben werden!

++++Lösung|
<code python>
zahl = int(input("Zahl (0 = Ende): "))

if zahl == 0:
    print("Keine Zahlen eingegeben.")
else:
    maximum = zahl               # die erste Zahl ist vorläufig grösste UND kleinste
    minimum = zahl

    while zahl != 0:
        if zahl > maximum:
            maximum = zahl
        if zahl < minimum:
            minimum = zahl
        zahl = int(input("Zahl (0 = Ende): "))

    print("Grösste:", maximum)
    print("Kleinste:", minimum)
</code>

Der entscheidende Punkt ist die **Initialisierung**: Wir setzen `maximum = 0` **nicht**! Gibt der Benutzer nur negative Zahlen ein, wäre sonst $0$ das falsche Ergebnis. Der einzig sichere Startwert ist der **erste tatsächlich eingegebene Wert**.

Beachte auch, dass zwei aufeinanderfolgende `if` verwendet werden und **kein** `elif`. Beim allerersten Durchgang müssen ja beide Vergleiche stattfinden können.
++++
</box>

<box 100%>
**Aufgabe:** Programmiere eine Passwortabfrage. Das Passwort lautet ``python``. Der Benutzer hat **höchstens drei Versuche**. Bei richtigem Passwort: ``Willkommen!``, nach drei Fehlversuchen: ``Zugang gesperrt.``

++++Lösung|
<code python>
passwort = "python"
versuche = 1

eingabe = input("Passwort: ")

while eingabe != passwort and versuche < 3:
    versuche = versuche + 1
    eingabe = input("Falsch. Passwort: ")

if eingabe == passwort:
    print("Willkommen!")
else:
    print("Zugang gesperrt.")
</code>

Neu ist hier die **zusammengesetzte Bedingung**: Die Schleife läuft nur weiter, wenn das Passwort falsch ist **und** noch Versuche übrig sind. Sobald eine der beiden Bedingungen kippt, ist Schluss.

Nach der Schleife wissen wir aber nicht, //welche// der beiden Bedingungen zum Abbruch geführt hat. Deshalb müssen wir das mit einem abschliessenden `if` nachträglich herausfinden. Das ist ein sehr typisches Vorgehen.
++++
</box>

===== - Schleife und Verzweigung kombiniert =====

Jetzt wird es interessant: Innerhalb der Schleife treffen wir Entscheidungen.

<box 100%>
**Aufgabe:** Wie viele Zahlen von $1$ bis $100$ sind durch $3$ teilbar, aber **nicht** durch $5$? Lass das Programm die Antwort berechnen.

++++Lösung|
<code python>
i = 1
anzahl = 0

while i <= 100:
    if i % 3 == 0 and i % 5 != 0:
        anzahl = anzahl + 1
    i = i + 1

print("Anzahl:", anzahl)
</code>

Antwort: **27**.

Nachrechnen: Von $1$ bis $100$ gibt es $33$ Vielfache von $3$. Davon sind $6$ auch durch $5$ teilbar (nämlich die Vielfachen von $15$: $15, 30, 45, 60, 75, 90$). Bleiben $33 - 6 = 27$.
++++
</box>

<box 100%>
**Aufgabe:** Der Computer denkt sich eine Zufallszahl zwischen $1$ und $100$. Der Benutzer rät. Nach jedem Tipp gibt das Programm ``zu klein`` oder ``zu gross`` aus. Bei richtigem Tipp wird die Anzahl der Versuche ausgegeben.

++++Lösung|
<code python>
import random

zahl = random.randint(1, 100)

tipp = int(input("Dein Tipp: "))
versuche = 1

while tipp != zahl:
    if tipp < zahl:
        print("Zu klein!")
    else:
        print("Zu gross!")
    tipp = int(input("Dein Tipp: "))
    versuche = versuche + 1

print("Richtig! Du hast", versuche, "Versuche gebraucht.")
</code>

Wieder dasselbe Muster wie bei der Eingabeschleife: erste Eingabe vor der Schleife, weitere Eingaben am Ende des Schleifenkörpers.

//Übrigens:// Wer geschickt rät (immer in der Mitte des verbleibenden Bereichs), braucht **nie mehr als 7 Versuche**. Denn $2^7 = 128 > 100$. Diese Strategie heisst **binäre Suche** – sie kommt in der letzten Zusatzaufgabe wieder vor.
++++
</box>

<box 100%>
**Aufgabe (Collatz):** Lies eine natürliche Zahl $n > 0$ ein und wende folgende Regel wiederholt an:
   * Ist $n$ gerade, ersetze $n$ durch $n/2$.
   * Ist $n$ ungerade, ersetze $n$ durch $3n+1$.

Gib jeden Zwischenschritt aus und höre auf, sobald $n = 1$ erreicht ist. Zähle die Schritte.

Probiere danach $n = 27$ aus.

++++Lösung|
<code python>
n = int(input("Startzahl: "))
schritte = 0

while n != 1:
    if n % 2 == 0:
        n = n // 2               # Ganzzahldivision, damit kein float entsteht
    else:
        n = 3 * n + 1
    schritte = schritte + 1
    print(n)

print("Anzahl Schritte:", schritte)
</code>

Für $n = 27$ braucht man **111 Schritte**, und zwischendurch klettert die Zahl bis auf $9232$ hinauf – obwohl sie so klein startet.

Das Bemerkenswerte an dieser Aufgabe: Es ist bis heute **unbewiesen**, ob die Schleife für jede Startzahl überhaupt terminiert. Das ist die berühmte //Collatz-Vermutung//. Man hat sie für sehr grosse Zahlen per Computer überprüft, aber niemand konnte sie bisher allgemein beweisen. Du schreibst hier also ein Programm, von dem niemand weiss, ob es immer anhält.
++++
</box>

<box 100%>
**Aufgabe:** Berechne die **Quersumme** einer eingegebenen Zahl. Beispiel: $4271 \rightarrow 4+2+7+1 = 14$.

//Tipp:// Mit `n % 10` bekommst du die **letzte** Ziffer, mit `n // 10` schneidest du sie ab.

++++Lösung|
<code python>
n = int(input("Zahl: "))

quersumme = 0

while n > 0:
    quersumme = quersumme + n % 10      # letzte Ziffer dazuzählen
    n = n // 10                         # letzte Ziffer abschneiden

print("Quersumme:", quersumme)
</code>

Verfolge es an $4271$ Schritt für Schritt:

^ Durchgang ^ n ^ n % 10 ^ quersumme ^
| Start | 4271 | – | 0 |
| 1 | 427 | 1 | 1 |
| 2 | 42 | 7 | 8 |
| 3 | 4 | 2 | 10 |
| 4 | 0 | 4 | 14 |

Sobald `n` den Wert $0$ erreicht, ist die Zahl "aufgebraucht" und die Schleife endet. Diese Technik, eine Zahl **ziffernweise zu zerlegen**, ist extrem nützlich – merke sie dir gut.
++++
</box>

<box 100%>
**Aufgabe:** Drehe eine eingegebene Zahl um: $4271 \rightarrow 1724$. Das Ergebnis soll eine **Zahl** sein, kein String.

++++Lösung|
<code python>
n = int(input("Zahl: "))

rueckwaerts = 0

while n > 0:
    ziffer = n % 10
    rueckwaerts = rueckwaerts * 10 + ziffer   # bisheriges Ergebnis "nach links schieben"
    n = n // 10

print("Umgekehrt:", rueckwaerts)
</code>

Der Trick steckt in `rueckwaerts * 10 + ziffer`: Die Multiplikation mit $10$ schiebt alle bisherigen Ziffern eine Stelle nach links und macht rechts Platz für die neue.

Ablauf für $4271$: $0 \rightarrow 1 \rightarrow 17 \rightarrow 172 \rightarrow 1724$.

//Zusatz:// Baue das Programm so um, dass es prüft, ob eine Zahl ein **Palindrom** ist (vorwärts wie rückwärts gleich, z.B. $12321$). Du musst dir dazu die ursprüngliche Zahl in einer zweiten Variablen merken, bevor du sie in der Schleife zerstörst!
++++
</box>

===== - Anspruchsvollere Aufgaben =====

<box 100%>
**Aufgabe:** Lies eine Zahl $n \geq 2$ ein und prüfe, ob sie eine **Primzahl** ist.

++++Lösung|
<code python>
n = int(input("Zahl: "))

ist_prim = True              # Flag: wir gehen erst mal davon aus, dass es eine Primzahl ist
teiler = 2

while teiler < n:
    if n % teiler == 0:
        ist_prim = False     # ein Teiler gefunden -> doch keine Primzahl
    teiler = teiler + 1

if ist_prim:
    print(n, "ist eine Primzahl.")
else:
    print(n, "ist keine Primzahl.")
</code>

Das ist die erste Anwendung des **Flag-Musters**: Eine Wahrheitswert-Variable merkt sich, ob während der Schleife etwas passiert ist. Nach der Schleife wird sie ausgewertet.

**Verbesserung:** Man muss nur bis zur Wurzel von $n$ testen. Denn wenn $n = a \cdot b$ mit $a \leq b$, dann ist zwingend $a \leq \sqrt{n}$. Statt `math.sqrt` zu verwenden, quadriert man einfach den Teiler:
<code python>
while teiler * teiler <= n:
    if n % teiler == 0:
        ist_prim = False
    teiler = teiler + 1
</code>
Für $n = 1'000'003$ sind das statt einer Million nur noch rund tausend Durchgänge. Ein spürbarer Unterschied!
++++
</box>

<box 100%>
**Aufgabe:** Gib **alle Primzahlen bis $100$** aus. Du brauchst dazu zwei ineinander verschachtelte while-Schleifen.

++++Lösung|
<code python>
n = 2                                    # äussere Schleife: die Kandidaten

while n <= 100:

    ist_prim = True
    teiler = 2                           # innere Schleife: die möglichen Teiler

    while teiler * teiler <= n:
        if n % teiler == 0:
            ist_prim = False
        teiler = teiler + 1

    if ist_prim:
        print(n, end=" ")

    n = n + 1
</code>

Ausgabe: ``2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97``

**Der wichtigste Punkt bei verschachtelten Schleifen:** Die Variablen der inneren Schleife (`teiler` und `ist_prim`) müssen **innerhalb** der äusseren Schleife zurückgesetzt werden. Setzt man sie versehentlich ganz nach oben, funktioniert nur der erste Durchgang – ein Klassiker unter den Fehlern.
++++
</box>

<box 100%>
**Aufgabe:** Berechne den **grössten gemeinsamen Teiler** zweier Zahlen mit dem euklidischen Algorithmus:

Ersetze wiederholt das Paar $(a, b)$ durch $(b,\ a \bmod b)$, bis $b = 0$ ist. Dann ist $a$ der ggT.

++++Lösung|
<code python>
a = int(input("a: "))
b = int(input("b: "))

while b != 0:
    rest = a % b
    a = b
    b = rest

print("Der ggT ist", a)
</code>

Die Hilfsvariable `rest` ist unverzichtbar: Würde man direkt `a = b` schreiben, wäre der alte Wert von `a` verloren, bevor man ihn für `a % b` braucht. Dieses **Zwischenspeichern beim Vertauschen** ist eine Standardtechnik.

Ablauf für $a = 48$, $b = 18$: $(48,18) \rightarrow (18,12) \rightarrow (12,6) \rightarrow (6,0)$. Ergebnis: $6$.

Der Algorithmus ist über 2000 Jahre alt und immer noch der schnellste bekannte Weg – er stammt aus Euklids //Elementen//.
++++
</box>

<box 100%>
**Aufgabe:** Berechne die **Quadratwurzel** einer positiven Zahl $x$ mit dem Heron-Verfahren, ohne `math.sqrt` zu verwenden.

Starte mit einer Näherung $g = x/2$ und verbessere sie wiederholt mit
$$g_{\text{neu}} = \frac{1}{2}\left(g + \frac{x}{g}\right)$$
bis sich der Wert kaum mehr ändert.

++++Lösung|
<code python>
x = float(input("Zahl: "))

g = x / 2
schritte = 0

while abs(g * g - x) > 0.000001:      # solange das Quadrat noch zu weit weg ist
    g = (g + x / g) / 2
    schritte = schritte + 1
    print(schritte, ":", g)

print("Wurzel aus", x, "ist ungefähr", g)
</code>

Für $x = 2$ ist man nach vier Schritten schon bei $1.41421356\ldots$ – das Verfahren **verdoppelt die Anzahl korrekter Stellen** mit jedem Schritt.

Zwei Dinge sind hier wichtig:
   * Der Abbruch erfolgt über eine **Toleranz**, nicht über Gleichheit. `while g * g != x` würde bei Kommazahlen fast nie terminieren, weil floats gerundet gespeichert werden.
   * Für $x = 0$ würde das Programm mit einer Division durch null abstürzen. Ein sauberes Programm fängt das vorher ab.
++++
</box>

<box 100%>
**Aufgabe:** Wandle eine eingegebene Dezimalzahl in ihre **Binärdarstellung** um, ohne `bin()` zu verwenden.

//Tipp:// Teile wiederholt durch $2$ und sammle die Reste ein – aber achte auf die Reihenfolge!

++++Lösung|
<code python>
n = int(input("Dezimalzahl: "))

binaer = ""

while n > 0:
    binaer = str(n % 2) + binaer      # neue Ziffer VORNE anfügen
    n = n // 2

if binaer == "":                      # Sonderfall: die Eingabe war 0
    binaer = "0"

print("Binär:", binaer)
</code>

Der springende Punkt ist `str(n % 2) + binaer` statt `binaer + str(n % 2)`: Die Reste fallen bei der Division von **hinten nach vorne** an, also müssen sie vorne angehängt werden.

Ablauf für $13$: Reste $1, 0, 1, 1$ – der String wächst als ``"1"``, ``"01"``, ``"101"``, ``"1101"``. Und tatsächlich ist $13 = 8 + 4 + 1 = 1101_2$.

Der Sonderfall $n = 0$ muss extra behandelt werden, weil die Schleife dann gar nie durchlaufen wird und der String leer bleibt.
++++
</box>

<box 100%>
**Aufgabe:** Gib mit verschachtelten while-Schleifen folgende Figuren aus. Die Höhe $n$ wird eingelesen.

<code>
*            Figur 1:        *****      Figur 2:          *
**                           ****                        ***
***                          ***                        *****
****                         **                        *******
*****                        *
</code>

++++Lösung|
**Figur 1** – wachsendes Dreieck, ganz ohne innere Schleife:
<code python>
n = int(input("Höhe: "))

zeile = 1
while zeile <= n:
    print("*" * zeile)
    zeile = zeile + 1
</code>

**Figur 2** – schrumpfendes Dreieck:
<code python>
zeile = n
while zeile >= 1:
    print("*" * zeile)
    zeile = zeile - 1
</code>

**Figur 3** – die Pyramide braucht zusätzlich führende Leerzeichen. In Zeile $z$ stehen $n - z$ Leerzeichen und $2z - 1$ Sterne:
<code python>
zeile = 1
while zeile <= n:
    print(" " * (n - zeile) + "*" * (2 * zeile - 1))
    zeile = zeile + 1
</code>

Wer den Trick `"*" * zeile` nicht verwenden darf, baut die Zeile mit einer **inneren Schleife** zusammen:
<code python>
zeile = 1
while zeile <= n:
    ausgabe = ""
    spalte = 1
    while spalte <= zeile:
        ausgabe = ausgabe + "*"
        spalte = spalte + 1
    print(ausgabe)
    zeile = zeile + 1
</code>
Das ist wieder der **Akkumulator** – diesmal aber mit einem String statt einer Zahl.
++++
</box>

<box 100%>
**Aufgabe:** Gib die kleine Einmaleins-Tabelle ($1$ bis $10$) als sauberes Gitter aus.

++++Lösung|
<code python>
zeile = 1

while zeile <= 10:

    ausgabe = ""
    spalte = 1

    while spalte <= 10:
        ausgabe = ausgabe + str(zeile * spalte) + "\t"
        spalte = spalte + 1

    print(ausgabe)
    zeile = zeile + 1
</code>

Zwei Beobachtungen:
   * Die **innere** Schleife läuft vollständig durch, bevor die äussere einen Schritt weitergeht. Insgesamt gibt es $10 \cdot 10 = 100$ Durchgänge der inneren Schleife.
   * Die Variable `spalte` und der String `ausgabe` werden bei jedem äusseren Durchgang **neu initialisiert**. Genau wie bei der Primzahl-Aufgabe.

Alternativ kann man auch direkt ausgeben und den Zeilenumbruch unterdrücken:
<code python>
    while spalte <= 10:
        print(zeile * spalte, end="\t")
        spalte = spalte + 1
    print()                        # leeres print() erzeugt den Zeilenumbruch
</code>
++++
</box>

<box 100%>
**Aufgabe (Knacknuss):** Ein Bauer hat Hühner und Kaninchen. Zusammen haben die Tiere $35$ Köpfe und $94$ Beine. Wie viele Tiere jeder Sorte hat er? Löse die Aufgabe mit einer **while-Schleife durch systematisches Ausprobieren** – nicht mit einem Gleichungssystem.

++++Lösung|
<code python>
koepfe = 35
beine = 94

huehner = 0

while huehner <= koepfe:
    kaninchen = koepfe - huehner              # der Rest muss Kaninchen sein
    if 2 * huehner + 4 * kaninchen == beine:
        print("Hühner:", huehner, " Kaninchen:", kaninchen)
    huehner = huehner + 1
</code>

Ergebnis: **23 Hühner und 12 Kaninchen**.

Diese Technik heisst **Brute Force** (rohe Gewalt): Man probiert einfach alle Möglichkeiten durch und prüft jede. Für einen Menschen wäre das mühsam, für einen Computer sind $36$ Durchgänge ein Klacks.

Beachte den Trick, dass nur **eine** Grösse durchprobiert wird – die zweite ergibt sich aus der Kopfzahl. Mit zwei verschachtelten Schleifen ginge es auch, wäre aber unnötig aufwendig.
++++
</box>

===== - Zusatzaufgaben (Listen erlaubt) =====

Wer alles Bisherige gelöst hat, darf sich hier austoben. Ab jetzt sind **Listen** erlaubt. Die wichtigsten Befehle:

<code python>
liste = []                    # leere Liste
liste = [3, 1, 4, 1, 5]       # Liste mit Startwerten

liste.append(9)               # Element hinten anfügen
liste[0]                      # erstes Element (Zählung beginnt bei 0!)
liste[-1]                     # letztes Element
len(liste)                    # Anzahl Elemente
liste[2] = 7                  # Element überschreiben
liste.pop(1)                  # Element an Position 1 entfernen
</code>

<box 100%>
**Aufgabe:** Lies Zahlen ein, bis $0$ eingegeben wird, und speichere sie in einer **Liste**. Gib danach aus: Anzahl, Summe, Mittelwert, Maximum und Minimum – und zwar alles selbst berechnet mit while-Schleifen, ohne `sum()`, `max()` oder `min()`.

++++Lösung|
<code python>
zahlen = []

zahl = int(input("Zahl (0 = Ende): "))
while zahl != 0:
    zahlen.append(zahl)
    zahl = int(input("Zahl (0 = Ende): "))

if len(zahlen) == 0:
    print("Keine Zahlen eingegeben.")
else:
    summe = 0
    maximum = zahlen[0]
    minimum = zahlen[0]

    i = 0
    while i < len(zahlen):
        summe = summe + zahlen[i]
        if zahlen[i] > maximum:
            maximum = zahlen[i]
        if zahlen[i] < minimum:
            minimum = zahlen[i]
        i = i + 1

    print("Anzahl:    ", len(zahlen))
    print("Summe:     ", summe)
    print("Mittelwert:", summe / len(zahlen))
    print("Maximum:   ", maximum)
    print("Minimum:   ", minimum)
</code>

Achte auf die Bedingung `i < len(zahlen)` mit **echt kleiner**: Bei einer Liste mit $5$ Elementen sind die gültigen Indizes $0$ bis $4$. Ein `<=` würde einen Zugriffsfehler auslösen – der berühmte //off-by-one error//.

Der Vorteil der Liste: Wir können die Zahlen **mehrfach** durchgehen. Ohne Liste ist jede Zahl nach der Verarbeitung für immer weg.
++++
</box>

<box 100%>
**Aufgabe:** Sortiere eine Liste von Zahlen mit **Bubble Sort**: Gehe die Liste wiederholt durch und vertausche benachbarte Elemente, wenn sie in der falschen Reihenfolge stehen. Wiederhole, bis kein Tausch mehr nötig war.

++++Lösung|
<code python>
zahlen = [5, 2, 9, 1, 7, 3]

getauscht = True                              # Flag

while getauscht:
    getauscht = False                         # Annahme: diesmal ist alles sortiert

    i = 0
    while i < len(zahlen) - 1:
        if zahlen[i] > zahlen[i + 1]:
            merker = zahlen[i]                # Vertauschen mit Hilfsvariable
            zahlen[i] = zahlen[i + 1]
            zahlen[i + 1] = merker
            getauscht = True                  # doch nicht sortiert!
        i = i + 1

    print(zahlen)                             # Zwischenstand anschauen

print("Sortiert:", zahlen)
</code>

Das Flag `getauscht` steuert hier die **äussere** Schleife. Solange in einem Durchgang noch getauscht wurde, kann die Liste nicht sortiert sein. Ging ein ganzer Durchgang ohne Tausch vorbei, sind wir fertig.

In Python kann man übrigens eleganter tauschen: `zahlen[i], zahlen[i+1] = zahlen[i+1], zahlen[i]`. Die Variante mit dem Merker funktioniert dafür in **jeder** Programmiersprache – und du solltest sie kennen.
++++
</box>

<box 100%>
**Aufgabe (Sieb des Eratosthenes):** Finde alle Primzahlen bis $100$, ohne eine einzige Division durchzuführen.

Idee: Schreibe alle Zahlen von $2$ bis $100$ auf. Nimm die erste unmarkierte Zahl – sie ist prim. Streiche danach alle ihre Vielfachen. Wiederhole.

++++Lösung|
<code python>
n = 100

ist_prim = [True] * (n + 1)       # ist_prim[k] sagt, ob k prim ist
ist_prim[0] = False
ist_prim[1] = False

p = 2
while p * p <= n:
    if ist_prim[p]:
        vielfaches = p * p        # alles Kleinere wurde schon gestrichen
        while vielfaches <= n:
            ist_prim[vielfaches] = False
            vielfaches = vielfaches + p     # ADDIEREN, nicht dividieren!
    p = p + 1

k = 2
while k <= n:
    if ist_prim[k]:
        print(k, end=" ")
    k = k + 1
</code>

Der Clou ist die Zeile `vielfaches = vielfaches + p`: Statt für jede Zahl zu prüfen, //ob// sie durch $p$ teilbar ist, springen wir direkt von Vielfachem zu Vielfachem. Das Sieb ist deshalb dramatisch schneller als das Durchprobieren aller Teiler.

Warum startet die innere Schleife bei $p \cdot p$ und nicht bei $2p$? Weil alle kleineren Vielfachen von $p$ bereits einen kleineren Primfaktor haben und darum schon gestrichen wurden. Zum Beispiel wurde $3 \cdot 5 = 15$ schon beim Sieben mit $3$ erwischt.
++++
</box>

<box 100%>
**Aufgabe (Umgekehrtes Zahlenraten):** Jetzt denkt //du// dir eine Zahl zwischen $1$ und $1000$, und der **Computer** rät. Nach jedem Tipp antwortest du mit ``k`` (zu klein), ``g`` (zu gross) oder ``r`` (richtig).

Programmiere den Computer so, dass er möglichst wenige Versuche braucht.

++++Lösung|
<code python>
unten = 1
oben = 1000
versuche = 0
antwort = ""

while antwort != "r":
    tipp = (unten + oben) // 2            # immer die Mitte des Bereichs!
    versuche = versuche + 1

    print("Ist es", tipp, "?")
    antwort = input("k = zu klein, g = zu gross, r = richtig: ")

    if antwort == "k":
        unten = tipp + 1                  # untere Hälfte ausschliessen
    elif antwort == "g":
        oben = tipp - 1                   # obere Hälfte ausschliessen

print("Gefunden nach", versuche, "Versuchen!")
</code>

Das ist die **binäre Suche**. Bei jedem Tipp halbiert sich der verbleibende Bereich: $1000 \rightarrow 500 \rightarrow 250 \rightarrow 125 \rightarrow \ldots$ Nach höchstens **10 Versuchen** ist die Zahl gefunden, denn $2^{10} = 1024 > 1000$.

Zum Vergleich: Würde der Computer stur $1, 2, 3, \ldots$ durchprobieren, bräuchte er im Mittel $500$ Versuche. Ein gut gewählter Algorithmus schlägt rohe Rechenkraft um Längen.

//Zum Weiterdenken:// Was passiert, wenn du beim Antworten schummelst? Der Bereich schrumpft dann irgendwann auf nichts zusammen, und `unten` wird grösser als `oben`. Ein robustes Programm würde das erkennen und dich des Betrugs bezichtigen.
++++
</box>