Übungsaufgaben — gestaffelt nach Schwierigkeit

Diese Seite bündelt Übungsaufgaben zu if ... elif ... else, while, random und Funktionen — von leichten Abwandlungen bekannter Aufgaben bis hin zu kleinen Mini-Projekten, die alles kombinieren. Lassen Sie sich Zeit, und schauen Sie nur in die Lösung, wenn Sie wirklich nicht weiterkommen.

Die Seite habe ich grösstenteils mit KI generiert. Ich hoffe, die Aufgaben sind cool und spannend!

Aufgabe 1 — Gerade oder ungerade?

Auto-Grading

Schreiben Sie eine Funktion gerade_oder_ungerade(zahl), die für eine Zahl "gerade" oder "ungerade" zurückgibt.
Tipp: Eine Zahl ist genau dann gerade, wenn zahl % 2 == 0.

Loading editor...

Mögliche Lösung
def gerade_oder_ungerade(zahl):
    if zahl % 2 == 0:
        return "gerade"
    else:
        return "ungerade"
Der Modulo % 2 ergibt 0 bei geraden Zahlen und 1 bei ungeraden — ein klassisches if/else reicht für die Entscheidung.

Aufgabe 2 — Sparen mit Zinseszins

Auto-Grading

Sie legen 1'000 Franken auf einem Konto mit 5 % Zins pro Jahr an. Nach jedem Jahr wächst Ihr Guthaben also um 5 %. Wie viele Jahre dauert es, bis sich Ihr Geld verdoppelt hat (also mindestens 2'000 Franken erreicht)?
Schreiben Sie eine Funktion jahre_bis_verdoppelt(zinssatz), die für einen gegebenen Zinssatz (z.B. 0.05 für 5 %) die Anzahl Jahre zurückgibt, bis sich das Startguthaben verdoppelt hat.

Loading editor...

Mögliche Lösung
def jahre_bis_verdoppelt(zinssatz):
    guthaben = 1000
    jahre = 0
    while guthaben < 2000:
        guthaben = guthaben * (1 + zinssatz)
        jahre += 1
    return jahre
Das ist die klassische Zinseszins-Rechnung: In jedem Jahr wächst das Guthaben um den Zinsfaktor (1 + zinssatz). Bei 5 % Zins wird aus 1'000 nach einem Jahr 1'050, nach zwei Jahren 1'102.50, und so weiter — multiplikativ statt additiv.
Bankenformel-Faustregel: Mit der 72er-Regel kann man die Verdopplungszeit grob abschätzen, indem man 72 / Zinssatz in % rechnet. Bei 5 % wäre das 72/5 ≈ 14.4 Jahre — die exakte Antwort (15 Jahre, weil wir aufrunden) liegt sehr nahe dran.

Aufgabe 3 — Würfelwurf als Funktion

Auto-Grading

Schreiben Sie eine Funktion wuerfel(seiten), die einen Würfelwurf mit seiten Seiten simuliert (Standardwürfel: 6 Seiten). Die Funktion soll eine ganze Zufallszahl zwischen 1 und seiten (inklusive) zurückgeben.
Tipp: random.randint(a, b) zieht eine ganze Zahl zwischen a und b inklusive.

Loading editor...

Mögliche Lösung
import random

def wuerfel(seiten):
    return random.randint(1, seiten)
Ein Einzeiler — random.randint(a, b) macht genau das, was wir brauchen: eine ganze Zufallszahl zwischen a und b inklusive. Die Funktion ist generisch genug für alle Würfeltypen, von 4-seitig (D&D) bis 100-seitig.

Aufgabe 4 — Modulo-Summe

Auto-Grading

Addieren Sie alle Zahlen bis 200, die restlos durch 7 teilbar sind, und speichern Sie das Ergebnis in der Variable summe.

Loading editor...

Mögliche Lösung
summe = 0
for i in range(1, 201):
    if i % 7 == 0:
        summe = summe + i
print(summe)
Praktisch identisch zur Modulo-Summe-Aufgabe aus der if ... else-Lektion — nur mit 7 statt 3 und Obergrenze 200 statt 100.

Aufgabe 5 — Notenstufen umgekehrt

Auto-Grading

Schreiben Sie eine Funktion note_zu_text(note), die eine Schweizer Schulnote von 1 bis 6 erhält und das passende Prädikat zurückgibt mit return:

6: "sehr gut"

5 oder 5.5: "gut"

4 oder 4.5: "genügend"

unter 4: "ungenügend"

Tipp: Mit if ... elif ... else müssen Sie nicht jede Stufe einzeln prüfen. Beginnen Sie bei der höchsten und arbeiten Sie sich nach unten.

Loading editor...

Mögliche Lösung
def note_zu_text(note):
    if note >= 6:
        return "sehr gut"
    elif note >= 5:
        return "gut"
    elif note >= 4:
        return "genügend"
    else:
        return "ungenügend"
Wir starten oben und gehen mit elif nach unten. Sobald eine Bedingung zutrifft, springt die Funktion mit return direkt raus — die nachfolgenden elifs werden gar nicht mehr geprüft. So sparen wir uns lästige Obergrenzen wie if note >= 5 and note < 6.

Aufgabe 6 — Erste Zahl mit Eigenschaft finden

Auto-Grading

Schreiben Sie eine Funktion kleinste_gemeinsam_teilbar(a, b, c), die die kleinste natürliche Zahl zurückgibt, die durch a, b und c gleichzeitig teilbar ist.

Loading editor...

Mögliche Lösung
def kleinste_gemeinsam_teilbar(a, b, c):
    i = 1
    while not (i % a == 0 and i % b == 0 and i % c == 0):
        i += 1 # Die Kurzform von i = i + 1
    return i
Wir suchen das kleinste gemeinsame Vielfache (kgV). Bei reinen Primzahlen wie 11, 13, 17 ist es einfach das Produkt ( $2'431$ ). Bei Zahlen mit gemeinsamen Faktoren — z.B. 4, 6, 8 — ist das kgV kleiner als das Produkt, weil sich die gemeinsamen Faktoren "überlappen".

Aufgabe 7 — Münzwürfe simulieren

Auto-Grading

Schreiben Sie eine Funktion muenzwurf_simulation(versuche), die versuche viele Münzwürfe simuliert und zurückgibt, wie oft "Kopf" geworfen wurde.
Speichern Sie das Ergebnis für 1'000'000 Würfe zusätzlich in der Variable anzahl_kopf.
Tipp: Nutzen Sie für den Münzwurf random.choice(["Kopf", "Zahl"]) oder random.randint(0, 1).

Loading editor...

Mögliche Lösung
import random

def muenzwurf_simulation(versuche):
    anzahl_kopf = 0
    for _ in range(versuche): # Wenn man die Laufvariable nicht gebraucht, ist es eine Konvention, "_" zu schreiben.
        if random.choice(["Kopf", "Zahl"]) == "Kopf":
            anzahl_kopf += 1
    return anzahl_kopf

anzahl_kopf = muenzwurf_simulation(1_000_000)
print(f"Kopf: {anzahl_kopf} ({anzahl_kopf/1_000_000:.4f})")
Bei einer fairen Münze erwartet man $\frac{1}{2}$ Kopf-Würfe — also ungefähr 500'000 bei einer Million Versuchen. Die exakte Zahl variiert von Lauf zu Lauf um wenige Tausend, weil es echter Zufall ist.

Aufgabe 8 🧩 Knobelaufgabe — Wie lange bis fünf Kopf hintereinander?

Auto-Grading

Schreiben Sie eine Funktion wuerfe_bis_serie(n), die simuliert, wie viele Münzwürfe nötig sind, bis Sie n Mal hintereinander Kopf geworfen haben. Die Funktion soll die Anzahl Würfe zurückgeben.
Speichern Sie den Durchschnitt über 1'000 Durchgänge mit Serienlänge 5 in der Variable durchschnitt.

Loading editor...

Mögliche Lösung
import random

def wuerfe_bis_serie(n):
    wuerfe = 0
    serie = 0
    while serie < n:
        wuerfe += 1
        if random.randint(0, 1) == 1:
            serie += 1
        else:
            serie = 0   # bei Zahl wird die Serie zurückgesetzt
    return wuerfe
Hier verzahnen sich while (so lange werfen, bis Serie steht) und if/else (Serie hochzählen oder zurücksetzen). Mathematisch ergibt sich für n Kopf in Serie eine erwartete Anzahl Würfe von $2^{n+1} - 2$ — also $2^6 - 2 = 62$ für unsere fünf Kopf-Würfe, und $2^2 - 2 = 2$ für einen einzigen Kopf.

Aufgabe 9 🧩 Knobelaufgabe — Sammelfigur-Problem

Auto-Grading

Stellen Sie sich vor, eine Cornflakes-Packung enthält je eine von n verschiedenen Sammelfiguren, gleichverteilt zufällig.
Schreiben Sie eine Funktion packungen_bis_alle(n), die simuliert, wie viele Packungen man kaufen muss, bis man alle n Figuren besitzt — und diese Zahl zurückgibt.
Berechnen Sie dann den Durchschnitt über 1'000 Simulationen für n = 10 und speichern Sie ihn in durchschnitt.

Loading editor...

Mögliche Lösung
import random

def packungen_bis_alle(n):
    gesammelt = []
    packungen = 0
    while len(gesammelt) < n:
        figur = random.randint(1, n)
        packungen += 1
        if figur not in gesammelt:
            gesammelt.append(figur)
    return packungen
Klassisches "Coupon Collector"-Problem. Mathematisch erwartet man $n \cdot H_n$ Packungen, wobei $H_n$ die harmonische Reihe ist: für $n = 10$ ergibt das $10 \cdot \left(1 + \frac{1}{2} + \frac{1}{3} + \dots + \frac{1}{10}\right) \approx 29.29$ . Die letzten Figuren sind die mühsamsten — die 10. erwischt man durchschnittlich erst nach 10 weiteren Käufen.

Aufgabe 10 🧩 Knobelaufgabe — Random Walk

Auto-Grading

Ein Random Walker startet bei Position 0. In jedem Schritt geht er zufällig +1 oder -1.
Schreiben Sie eine Funktion random_walk(schritte), die einen Random Walk mit der angegebenen Anzahl Schritte simuliert und zurückgibt, wie oft der Walker am Startpunkt 0 vorbeikommt (ohne den Start selbst zu zählen).
Speichern Sie das Ergebnis für 1'000 Schritte in der Variable besuche_bei_null.

Loading editor...

Mögliche Lösung
import random

def random_walk(schritte):
    position = 0
    besuche = 0
    for _ in range(schritte):
        position += random.choice([-1, 1])
        if position == 0:
            besuche += 1
    return besuche
Der eindimensionale Random Walk hat eine erstaunliche Eigenschaft: Er kommt mit Wahrscheinlichkeit 1 immer wieder zum Startpunkt zurück — aber wie oft das in einer endlichen Zeit passiert, schwankt stark. Mathematisch erwartet man für $N$ Schritte ungefähr $2\sqrt{N/\pi}$ Besuche bei 0, also etwa 25 für $N = 1'000$ . Bei einer einzelnen Simulation können es aber auch nur 0 oder über 100 sein.

Aufgabe 11 🧩 Knobelaufgabe — Mini-Casino

Auto-Grading

Ein Spieler beginnt mit einem Startguthaben und setzt in jeder Runde 10 Franken auf einen Münzwurf:

bei Kopf gewinnt er 10 Franken dazu,

bei Zahl verliert er die 10 Franken.

Er spielt entweder, bis er pleite (Guthaben = 0) oder reich (Guthaben ≥ Ziel) ist.
Schreiben Sie eine Funktion spiel_simulation(start, ziel), die diesen Vorgang simuliert und True zurückgibt, wenn der Spieler reich wird — sonst False.
Berechnen Sie dann den Anteil reicher Spieler über 10'000 Versuche mit Start 100 und Ziel 200 und speichern Sie ihn in anteil_reich.

Loading editor...

Mögliche Lösung
import random

def spiel_simulation(start, ziel):
    guthaben = start
    while 0 < guthaben < ziel:
        if random.randint(0, 1) == 1:
            guthaben += 10   # Kopf: Gewinn
        else:
            guthaben -= 10   # Zahl: Verlust
    return guthaben >= ziel
Das ist das Gambler's-Ruin-Problem. Weil Start (100), Ziel (200) und Pleite-Grenze (0) symmetrisch liegen — der Spieler ist gleich weit von beiden Enden entfernt — ergibt sich bei einer fairen Münze exakt 50 %. Spannend wird's, wenn Sie das Ziel auf 110 setzen: Plötzlich werden über 90 % der Spieler reich, weil sie es nur noch einen Schritt weit haben.