# Quiz: Kontrollstrukturen & einfache Funktionen

Kurzes Quiz zu `if`/`elif`/`else`, `for`/`while`-Schleifen und Funktionsgrundlagen.
Lösungen stehen ganz unten.

## Teil 1: Kontrollstrukturen

**1.** Was gibt folgender Code aus?
```python
x = 5
if x > 10:
    print("groß")
elif x > 3:
    print("mittel")
else:
    print("klein")
```

**2.** Wie oft wird `"hallo"` ausgegeben?
```python
for i in range(3):
    print("hallo")
```

**3.** Was ist die Endlosschleifen-Gefahr in diesem Code, und wie behebt man sie?
```python
i = 0
while i < 5:
    print(i)
```

**4.** Was gibt dieser Code aus? (Vorsicht, Falle!)
```python
for i in [1, 2, 3]:
    if i == 2:
        continue
    print(i)
```

**5.** Was ist der Unterschied zwischen `break` und `continue` in einer Schleife?

**6.** Was gibt folgender Code aus?
```python
for i in range(5):
    if i == 3:
        break
    print(i)
else:
    print("fertig ohne break")
```

## Teil 2: Einfache Funktionen

**7.** Schreibe eine Funktion `verdoppeln(x)`, die eine Zahl verdoppelt zurückgibt.

**8.** Was ist an dieser Funktion falsch (kein Fehler, aber ein häufiger Bug)?
```python
def addiere(a, b):
    print(a + b)

ergebnis = addiere(2, 3)
print(ergebnis + 1)
```

**9.** Was gibt folgender Code aus?
```python
def gruss(name="Welt"):
    return f"Hallo, {name}!"

print(gruss())
print(gruss("Anna"))
```

**10.** Was ist der Unterschied zwischen einem Parameter und einem Argument?

**11.** Was gibt folgender Code aus? (Scoping-Frage)
```python
x = 10

def zeige():
    x = 20
    print(x)

zeige()
print(x)
```

**12.** Schreibe eine Funktion `ist_gerade(n)`, die `True` zurückgibt, wenn `n` gerade ist, sonst `False`.

---

## Lösungen

1. `mittel` (5 ist nicht > 10, aber > 3)
2. 3-mal
3. `i` wird nie erhöht → Endlosschleife. Fix: `i += 1` am Ende der Schleife ergänzen.
4. `1` und `3` (die `2` wird durch `continue` übersprungen)
5. `break` beendet die Schleife komplett, `continue` überspringt nur den aktuellen Durchlauf und macht mit dem nächsten weiter.
6. `0 1 2` und danach `fertig ohne break` wird **nicht** ausgegeben, weil `break` ausgelöst wurde (das `else` einer Schleife läuft nur, wenn sie ohne `break` durchläuft).
7.
   ```python
   def verdoppeln(x):
       return x * 2
   ```
8. `addiere` gibt nichts zurück (`return` fehlt), sie nutzt nur `print`. `ergebnis` ist daher `None`, und `ergebnis + 1` wirft einen `TypeError`.
9. `Hallo, Welt!` und `Hallo, Anna!`
10. Der **Parameter** ist der Name in der Funktionsdefinition (`name` in `def gruss(name)`), das **Argument** ist der konkrete Wert, der beim Aufruf übergeben wird (`"Anna"` in `gruss("Anna")`).
11. `20` dann `10` — die lokale Variable `x` in `zeige()` überschreibt nur innerhalb der Funktion, die globale `x` bleibt unverändert.
12.
    ```python
    def ist_gerade(n):
        return n % 2 == 0
    ```