Kontrollstrukturen in C: Übungen – Informatik Klasse 9

A1

Von Python nach C

AFB I

Du kennst Schleifen und Verzweigungen schon aus Python. Ordne jeder Python-Zeile die gleichwertige C-Zeile zu.

Klicke links einen Eintrag an und dann rechts den passenden — es entsteht eine Verbindungslinie. Mit der Tastatur: Enter zum Auswählen, ↑/↓ zum Wandern.

Häufigster Fehler: range(2, 8) mit i <= 8 übersetzen. Die Endgrenze von range gehört nicht mehr dazu, deshalb steht in C <. Bei negativer Schrittweite dreht sich der Vergleich um: i > 0. Aus and, or, not werden in C &&, ||, !.

Ansatz: Die C-for-Schleife hat drei Teile: Start; Bedingung; Schritt. Lies sie aus dem range ab.

Weiter: Der zweite Wert von range ist die erste Zahl, die nicht mehr drankommt.

A2

switch und Wahrheitswerte

AFB I

Gib die fehlenden Begriffe an — zwei Wörter bleiben übrig.

Wort anklicken, dann Lücke anklicken (oder umgekehrt) — mit Tab und Enter geht es genauso. Ein Klick auf eine gefüllte Lücke legt das Wort zurück.

In einem switch springt das Programm zu dem , dessen Wert passt. Fehlt dort ein , läuft es einfach in den nächsten Fall weiter. Passt kein Fall, werden die Anweisungen bei ausgeführt. Eine do … while-Schleife prüft ihre Bedingung jedes Durchlaufs und läuft deshalb mindestens einmal. In C gilt nur der Wert als falsch, jede andere Zahl als wahr.

Die Ablenker „am Anfang“ und „1“ gehören zu verbreiteten Fehlvorstellungen: Eine while-Schleife prüft am Anfang, eine do … while-Schleife am Ende. Und „wahr“ ist in C nicht nur die 1 — auch 7 oder −2 gelten als wahr. Nur 0 ist falsch.

Ansatz: Beim switch gibt es drei Schlüsselwörter: eins für jeden Fall, eins zum Verlassen, eins für „sonst“.

Weiter: Bei do … while steht die Bedingung im Quelltext hinter dem Rumpf.

A3

Stimmt's? — Bedingungen

AFB I

Fünf Behauptungen über Bedingungen und Schleifen in C. Nenne jeweils, ob sie stimmt.

Fünf Aussagen nacheinander. Eine falsche Einschätzung reicht — dann startest du die Serie mit „Neue Runde“ neu.

Aussage 1 von 5

Am häufigsten wird die dritte Aussage falsch eingeschätzt: Beim Verneinen einer Bedingung kippt > zu <=, nicht zu <. Teste solche Umformungen immer mit dem Grenzwert — hier x = 3.

Ansatz: Setze für x konkrete Zahlen ein, z. B. 2, 3 und 4, und vergleiche beide Seiten.

Weiter: switch vergleicht nur auf Gleichheit mit festen Werten.

A4

Tracetabelle: Quersumme

AFB II

Der Ausschnitt berechnet die Quersumme einer Zahl.

C · Ausschnitt

int zahl = 4735;
int summe = 0;
while (zahl > 0) {
    summe = summe + zahl % 10;
    zahl = zahl / 10;
}

Stelle den Ablauf als Tracetabelle dar: Trag für jeden Schleifendurchlauf die Werte ein.

Füll alle Felder aus und prüfe dann. Enter in einem Feld prüft ebenfalls.

Durchlauf	`zahl % 10`	`summe` danach	`zahl` danach
1
2
3
4

zahl % 10 liefert immer die letzte Ziffer, zahl / 10 streicht sie (Ganzzahldivision!). Nach dem vierten Durchlauf ist zahl gleich 0, die Bedingung zahl > 0 ist falsch — Quersumme 19. Typischer Fehler: im letzten Durchlauf 0.4 statt 0 eintragen. Bei int gibt es keine Nachkommastellen.

Ansatz: Rechne pro Zeile erst den Rest, dann die neue Summe, dann die neue Zahl.

Weiter: 4735 % 10 = 5 und 4735 / 10 = 473 — der Rest fällt bei int weg.

A5

Schleife mit Filter

AFB II

Gewünschte Ausgabe

20 16 8 4

Die Schleife soll rückwärts in Viererschritten zählen und dabei alle Zahlen überspringen, die durch 3 teilbar sind. Ergänze die Lücken.

Wähle in jedem Menü den passenden Eintrag und prüfe dann alle auf einmal.

C · Ausschnitt

for (int i = ; i  4; ) {
    if (i % 3  0) {
        printf("%d ", i);
    }
}
printf("\n");

Zwei Stellen sind knifflig: Mit i > 4 oder i != 4 fehlt am Ende die 4 — die Schleife bricht ab, bevor sie ausgegeben wird. Im if muss != stehen: Ausgegeben werden die Zahlen, bei denen der Rest nicht 0 ist. Ein einzelnes = wäre eine Zuweisung, keine Frage.

Ansatz: Die 12 fehlt in der Ausgabe. Welche Eigenschaft hat die 12, die 20, 16, 8 und 4 nicht haben?

Weiter: Prüfe den letzten Durchlauf: Bei i = 4 muss die Bedingung noch wahr sein.

A6

Wie oft wird gezählt?

AFB II

C · Ausschnitt

int z = 0;
for (int i = 1; i <= 30; i++) {
    if (i % 4 == 0 || i % 6 == 0) {
        z++;
    }
}
printf("%d\n", z);

Berechne, welche Zahl das Programm ausgibt.

Rechne selbst und trage das Ergebnis ein — Enter prüft direkt.

Vielfache von 4 bis 30: 4, 8, 12, 16, 20, 24, 28 (7 Stück). Vielfache von 6: 6, 12, 18, 24, 30 (5 Stück). 12 und 24 sind in beiden Listen, werden aber wegen || nur einmal gezählt: 7 + 5 − 2 = 10. Typischer Fehler: 12 — dabei werden die gemeinsamen Vielfachen doppelt gezählt.

Ansatz: Schreib die Vielfachen von 4 und die von 6 bis 30 als zwei Listen auf.

Weiter: Ein if mit || erhöht z pro Durchlauf höchstens einmal.

A7

Wahr oder falsch in C?

AFB II

C · Deklaration

int a = 4, b = 0, c = -2;

Ordne jeden Ausdruck danach ein, ob er in einer Bedingung als wahr oder als falsch gilt.

Ziehe jede Karte in den passenden Korb — oder wähle sie mit Enter aus und drücke dann die Ziffer des Korbs (0 legt sie zurück).

1wahr (≠ 0)

2falsch (0)

Zwei Fallen: c allein ist −2 und damit wahr — nur 0 ist falsch. Und a - 4 ergibt 0, ist also falsch, obwohl es gar kein Vergleich ist. Bei a > c && c > b ist der erste Teil wahr, der zweite (−2 > 0) aber falsch — bei && reicht das für „falsch“.

Ansatz: Rechne jeden Ausdruck zu einer Zahl aus. Ist sie 0, ist er falsch — sonst wahr.

Weiter: ! kehrt um: !0 ist 1, ! jeder anderen Zahl ist 0.

A8

Fehlersuche: Ampelsteuerung

AFB III

Das Programm soll für jede Ampelfarbe genau eine Meldung zeigen, dreimal „Blinken“ ausgeben und dann von 5 herunterzählen.

Analysiere den Code — drei Zeilen sind fehlerhaft.

In diesem Code stecken Fehler. Klicke genau die fehlerhaften Zeilen an — die richtigen musst du stehen lassen.

Tückisch an Zeile 3: Bei farbe = 2 fällt der Fehler gar nicht auf — das Programm startet ja bei case 2. Teste deshalb jeden Fall einzeln. Zeile 6 ohne break ist dagegen korrekt: Nach dem letzten Fall kommt nichts mehr, in das man „durchfallen“ könnte.

Ansatz: Spiele gedanklich jede Farbe 1, 2, 3 einmal durch und zähle, wie viele Meldungen erscheinen.

Weiter: Achte auf ein Semikolon direkt hinter einer Schleifenklammer und darauf, ob sich die Schleifenvariable auf das Ende zubewegt.

A9

Schleife trifft Ganzzahlrechnung

AFB III Mix

Hier kommen die Rechenregeln aus 2.1.2 wieder ins Spiel.

C · Ausschnitt

int summe = 0;
int k = 0;
for (int i = 7; i <= 19; i += 4) {
    summe += i % 5;
    k++;
}
double schnitt = (double) summe / k;
printf("%d %d %.2f\n", k, summe, schnitt);

Ermittle Schritt für Schritt, was bei diesem Ausschnitt herauskommt.

Arbeite die Kette Schritt für Schritt ab: Erst wenn ein Schritt stimmt, wird der nächste freigeschaltet. Enter prüft.

Wie oft läuft die Schleife? (k)
Wert von summe
Wert von schnitt
Wert von schnitt, wenn (double) fehlt

i nimmt die Werte 7, 11, 15, 19 an (23 ist zu groß) — also 4 Durchläufe. Die Reste bei Division durch 5 sind 2, 1, 0, 4, Summe 7. Mit cast: 7 / 4 = 1.75. Ohne cast rechnet C 7 / 4 ganzzahlig = 1, erst danach wird 1.0 daraus. Typischer Fehler: 15 % 5 übersehen und 1 statt 0 eintragen.

Ansatz: Schreib zuerst alle Werte von i auf, bis die Bedingung i <= 19 falsch wird.

Weiter: Reste bei Division durch 5: 7 → 2, 11 → 1, …

A10

Wie oft erscheint das x?

AFB III Trick

Jede Zeile ist ein kurzer Ausschnitt. Beurteile ohne Ausprobieren, wie oft x ausgegeben wird.

Wähle für jede Zeile eine Stufe: 1 = gar nicht, 2 = einmal, 3 = zweimal, 4 = dreimal, 5 = endlos. Mit der Tastatur: Tab zur Zeile, ←/→ zwischen den Stufen, Enter setzt.

1 = gar nicht5 = endlos

int i = 5; while (i < 5) { printf("x"); i++; }

int i = 3; do { printf("x"); i += 2; } while (i < 6);

for (int i = 0; i < 6; i += 2) printf("x");

int i = 1; while (i != 8) { printf("x"); i += 2; }

for (int i = 1; i <= 1; i++) printf("x");

int i = 0; while (i < 3); { printf("x"); i++; }

Zwei Fallen: Bei while (i != 8) springt i von 7 direkt auf 9 und trifft die 8 nie — die Bedingung bleibt immer wahr. Und das Semikolon hinter while (i < 3); ist selbst der (leere) Rumpf: i wird nie erhöht, das Programm hängt, bevor es ein einziges x ausgibt. Diese Falle meldet übrigens gcc -Wall als Warnung (misleading indentation). Die do … while-Schleife läuft für i = 3 und i = 5, also zweimal.

Ansatz: Schreib für jede Schleife die Werte von i auf, bevor die Bedingung geprüft wird.

Weiter: Achte auf != mit Schrittweite 2 und auf ein Semikolon direkt hinter der Bedingung.

Übungen: Verzweigung & Schleife

Übungsaufgaben