Probe-Klausur

Richtig sind: endlich viele eindeutige Schritte; Aufbau aus Sequenz, Verzweigung, Wiederholung; kopfgesteuerte Schleife ggf. null Durchläufe; x ← x + 1 überschreibt x — je 1 P. Falsch: „ein paar Mal“ ist nicht eindeutig; lokale Variablen entstehen bei jedem Aufruf neu; Java vergleicht Zeichenketten mit equals, == vergleicht nur die Referenzen. (4 P)

a) 47 = 7 · 6 + 5, Ganzzahldivision: 7 (1 P)

b) Rest: 5 (1 P)

c) −23 = (−5) · 5 + 2, der kleinste positive Rest ist 2 (Probe: −25 + 2 = −23) (2 P)

d) Java schneidet zur 0 hin ab: −23 / 5 = −4, Rest −23 − (−20) = −3 (1 P)

e) von links: 9 / 4 = 2 (ganzzahlig), 2 * 4 = 8 — nicht 9 (2 P)

f) in Python ist / nie ganzzahlig: 2,25 (1 P)

g) 'K' ist der 11. Großbuchstabe: 65 + 10 = 75 (1 P)

h) das Leerzeichen zählt mit: 9 (1 P)

i) der Cast schneidet ab, statt zu runden: 7 (1 P)

a) x wird so lange halbiert, bis 0 erreicht ist: 45 → 22 → 11 → 5 → 2 → 1 → 0, also 6 Durchläufe (2 P)

b) nach dem dritten Durchlauf: 5 (2 P)

c) e zählt die ungeraden Zwischenwerte 45, 11, 5, 1: 4. Der Algorithmus bestimmt die Anzahl der Binärstellen (z) und der Einsen (e) von 45 = 101101₂. (2 P)

a) a ← 24, b ← 6; 24 mod 6 = 0 ⇒ zurück 24 / 6 = 4 (2 P)

b) a ← 6, b ← 24; 6 mod 24 = 6 ≠ 0 ⇒ zurück 6 + 24 = 30 — die Reihenfolge der Argumente entscheidet (2 P)

c) innen zuerst: teile(35, 7) = 5; dann teile(5, 3): 5 mod 3 = 2 ≠ 0 ⇒ 5 + 3 = 8 (2 P)

a) in buchen verdeckt die lokale Variable stand die globale: lokal 4 · 2 = 8, zurück 8 + 1 = 9 (2 P)

b) die globale Variable ist noch 10; aufladen(9) ⇒ 19, aufladen(3) ⇒ 22 (2 P)

c) richtig: betrag ist jeweils ein Parameter (lokal); die lokale Variable verschwindet mit dem Ende von buchen. Falsch: buchen ändert nur die lokale Kopie; mit int stand entstünde auch in aufladen eine neue lokale Variable — die Zeile ließe sich so nicht einmal übersetzen, weil die neue lokale Variable rechts noch nicht initialisiert ist. (2 P)

a) M-i-s-s-i-s-s-i-p-p-i: 11 Zeichen, Positionen 0 bis 10 (1 P)

b) der Algorithmus zählt gleiche Nachbarzeichen: „ss“ (2/3), „ss“ (5/6), „pp“ (8/9) ⇒ 3 (2 P)

c) s[6] = 's', s[7] = 'i', s[8] = 'p' ⇒ 6 (bei Position 3 steht „sis“) (2 P)

d) s[4] = 'i' (105), s[0] = 'M' (77) ⇒ 105 − 77 = 28 (2 P)

a) 40705 → 4070 → 407 → 40 → 4 → 0: 5 Durchläufe (1 P)

b) n = 0: Die Schleife läuft nicht, zurückgegeben wird 0 — die Zahl 0 hat aber eine Ziffer. Für jedes n ≥ 1 stimmt das Ergebnis. (2 P)

c) richtig: n / 10 < n für n > 0 und n bleibt ≥ 0 (Terminierung); die fußgesteuerte Schleife liefert bei n = 0 genau einen Durchlauf, für n ≥ 1 ist die Bedingung anfangs ohnehin wahr. Falsch: Tests zeigen nur Fehler, nie Korrektheit; die beiden Zeilen im Rumpf sind voneinander unabhängig. (2 P)

a) Math.random() kann 0 liefern: (int) 0 + 5 = 5 (1 P)

b) Math.random() * 20 ist stets kleiner als 20, abgeschnitten höchstens 19: 19 + 5 = 24 (1 P)

c) 5 bis 24: 20 Werte (1 P)

d) von 10 bis 30 gibt es 30 − 10 + 1 = 21 Werte, also Faktor 21 und Verschiebung um 10; randint schließt beide Grenzen ein. Faktor 20 lässt die 30 aus, Faktor 30 reicht bis 39, randint(10, 31) bis 31. (2 P)