MINT lernen

Übungen: Arrays & Strings

Ein Byte zu wenig, und das Endezeichen fehlt — hier lernst du, Arrays und Zeichenketten sicher zu bändigen.

Dein Fortschritt:
0 / 0 Aufgaben
1

Übungsaufgaben

Zehn Übungen zu Arrays, Indizes und Zeichenketten — von AFB I bis AFB III. Jede Übung gibt dir sofort Rückmeldung; wenn du nicht weiterkommst, helfen die gestuften Tipps.

A1
Lückentext: Arrays und Zeichenketten
AFB I

Nenne die fehlenden Begriffe, indem du sie in die Lücken setzt — 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.

Ein Array fasst mehrere Werte unter einem Namen zusammen. Der erste Index ist immer ; bei int tage[7]; ist der letzte gültige Index . Eine Zeichenkette ist ein char-Array, das mit dem abschließt. Wie viele Zeichen davor stehen, liefert . Ob zwei Zeichenketten gleich sind, prüfst du mit .

Die Ablenker sind die zwei häufigsten Fehler: 7 als letzten Index einzusetzen (es gibt 7 Elemente, aber sie heißen tage[0] bis tage[6]) und Zeichenketten mit == zu vergleichen — das vergleicht nur die Adressen.
Ansatz: Zähle beim Index ab 0: Das erste Element ist Nummer 0.
Weiter: Für Zeichenketten gibt es in <string.h> eigene Funktionen — zum Messen und zum Vergleichen.
A2
Index im Index
AFB I
C · noten.c
int noten[] = {2, 1, 3, 2, 4, 1};

Gib den Wert des Ausdrucks noten[noten[2]] + noten[5] an.

Überlege selbst und trage das Ergebnis ein — Enter prüft direkt.
Von innen nach außen: noten[2] ist 3 (drittes Element!), also wird noten[3] = 2 gelesen. Dazu kommt noten[5] = 1, zusammen 3. Typischer Fehler: noten[2] als zweites Element (1) lesen — dann ergibt sich noten[1] + noten[5] = 2.
Ansatz: Werte zuerst den inneren Ausdruck noten[2] aus — Index ab 0 zählen.
Weiter: Schreib dir die Indizes 0 bis 5 unter die Werte: 2 1 3 2 4 1.
A3
Was steckt in tier?
AFB I
C · tier.c
char tier[] = "Katze";

Ordne jedem Ausdruck seinen Wert zu.

Ansatz: Schreib die Zeichen mit ihren Indizes auf: K=0, a=1, t=2, z=3, e=4 — und dann?
Weiter: sizeof misst den belegten Speicher in Byte, strlen zählt die Zeichen bis zum Endezeichen.
A4
Tracetabelle: das Maximum suchen
AFB II
C · maximum.c
int z[5] = {5, 2, 7, 7, 3};
int max = z[0], pos = 0;
for (int i = 1; i < 5; i++) {
    if (z[i] > max) {
        max = z[i];
        pos = i;
    }
}

Stelle den Ablauf als Tracetabelle dar: Werte am Ende jedes Schleifendurchlaufs.

Fülle alle Felder aus und prüfe dann. Enter in einem Feld prüft ebenfalls.
iz[i]maxpos
1
2
3
4
Der Knackpunkt ist i = 3: z[3] ist wieder 7, aber 7 > 7 ist falsch — pos bleibt 2. Das Programm merkt sich also das erste Vorkommen des Maximums. Mit >= wäre es das letzte (pos = 3). Typischer Fehler: pos = 3 eintragen.
Ansatz: Die Schleife beginnt bei i = 1, weil z[0] schon als Startwert in max steht.
Weiter: Prüfe bei jedem Durchlauf genau z[i] > max — echt größer, nicht größer-gleich.
A5
Buchstaben zählen
AFB II

Die Funktion zaehle soll zählen, wie oft das Zeichen z in der Zeichenkette s vorkommt. Ergänze die Lücken.

Wähle in jedem Menü den passenden Eintrag und prüfe dann alle auf einmal.
C · zaehle.c
int zaehle(char s[], char z) {
    int n = 0;
    for (int i = 0; ; i++) {
        if () {
            n++;
        }
    }
    return n;
}

int main(void) {
    printf("%d\n", zaehle("Mississippi", ));   // Ausgabe: 4
    return 0;
}
Die Schleife läuft, bis das Endezeichen erreicht ist — so funktioniert sie für jede Länge. Einzelne Zeichen stehen in einfachen Anführungszeichen: "\0" und "s" wären Zeichenketten, also Adressen. Typischer Fehler: s[i] = z — eine Zuweisung, die fast immer „wahr“ ist. Und die Ausgabe 4 gilt nur für kleines s; 'S' käme gar nicht vor.
Ansatz: Eine Zeichenkette hat keine gespeicherte Länge — die Schleife muss am Endezeichen anhalten.
Weiter: Einzelnes Zeichen: 'x'. Zeichenkette: "x". Vergleich: ==.
A6
Zwei Wörter in einem Array?
AFB II Trick
C · gruss.c
char gruss[] = "Moin\0Moin";
printf("%zu\n", sizeof(gruss) - strlen(gruss));

Bestimme die Ausgabe. (%zu gibt den Wert von sizeof als ganze Zahl aus.)

Überlege selbst und trage das Ergebnis ein — Enter prüft direkt.
Der Compiler legt alle 9 Zeichen zwischen den Anführungszeichen ab (das \0 in der Mitte zählt als ein Zeichen) und hängt ein weiteres Endezeichen an: sizeof = 10. strlen hört aber am ersten '\0' auf: 4. Ergebnis 10 − 4 = 6. Typischer Fehler: 1 — als wäre sizeof immer strlen + 1.
Ansatz: \0 ist ein einzelnes Zeichen mit dem Wert 0 — auch mitten im Text.
Weiter: sizeof: alle Zeichen im Literal plus das angehängte Endezeichen. strlen: Zeichen bis zum ersten Endezeichen.
A7
Zeiger auf ein Array
AFB II Mix

Hier treffen Zeiger aus 2.2.2 auf Arrays: Der Array-Name steht für die Adresse des ersten Elements.

C · feldzeiger.c
int v[4] = {10, 20, 30, 40};
int *p = v;          // Zeile 2
*p = *p + 5;         // Zeile 3
p = &v[2];           // Zeile 4
*p = v[1] * 2;       // Zeile 5
v[3] = *p - v[0];    // Zeile 6

Ermittle die Werte Schritt für Schritt.

Arbeite die Kette Schritt für Schritt ab: Erst wenn ein Schritt stimmt, wird der nächste freigeschaltet. Enter prüft.
  1. v[0] nach Zeile 3
  2. *p nach Zeile 4
  3. v[2] nach Zeile 5
  4. v[3] nach Zeile 6
int *p = v; bedeutet dasselbe wie int *p = &v[0]; — deshalb ändert Zeile 3 das erste Element. Zeile 5 schreibt über p in v[2]: 20 · 2 = 40. Zeile 6: 40 − 15 = 25. Typischer Fehler: in Zeile 6 mit dem alten Wert v[0] = 10 rechnen.
Ansatz: Ersetze *p in jeder Zeile durch das Element, auf das p gerade zeigt.
Weiter: Bis Zeile 3 zeigt p auf v[0], ab Zeile 4 auf v[2].
A8
Fehlersuche: Wort umdrehen
AFB III

Das Programm soll Regal rückwärts in rueck kopieren und umgedreht: lageR ausgeben. Überprüfe den Code — drei Zeilen sind fehlerhaft.

In diesem Code stecken Fehler. Klicke genau die fehlerhaften Zeilen an — die richtigen musst du stehen lassen.
Der Fehler in Zeile 6 ist besonders gemein: rueck[0] wird zum Endezeichen, und printf würde eine leere Zeichenkette ausgeben. Zeile 8 ist dagegen richtig und wichtig — ohne sie fehlt rueck das Endezeichen.
Ansatz: Rechne für i = 0 aus, welcher Index von wort gelesen wird, und zähle, wie viele Byte rueck braucht.
Weiter: Drei Fehlerarten: Platz fürs Endezeichen, ein Index um eins daneben und ein falscher Vergleich.
A9
Zeichenketten vergleichen und zuweisen
AFB III
C · farben.c
char a[10] = "Rot";
char b[10] = "Rot";

Beurteile die Aussagen über Zeilen, die danach folgen könnten, und markiere alle zutreffenden.

Mehrere Antworten sind richtig. Markiere alle zutreffenden und klicke dann auf „Prüfen“.
a und b sind zwei verschiedene Arrays an verschiedenen Adressen — == ist deshalb falsch (gcc warnt sogar „comparison between two arrays“). Einem Array kann man nichts zuweisen; kopiert wird mit strcpy. Tückisch ist die letzte Aussage: strcmp liefert bei Gleichheit 0, und 0 ist in C „falsch“.
Ansatz: Unterscheide: Inhalt (Zeichen) gegen Adresse (Array-Name), und belegter Platz (sizeof) gegen Textlänge (strlen).
Weiter: strcmp liefert 0 bei Gleichheit — denk an die Wahrheitswerte aus 2.1.3.
A10
Erlaubt, verboten oder gefährlich?
AFB III
C · felder.c
int t[4];
char n[6] = "Anna";

Bewerte jede folgende Zeile und lege sie in den passenden Korb.

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).
1korrekt
2Übersetzungsfehler
3übersetzt, aber Zugriff außerhalb
C prüft Array-Grenzen nicht: t[4] und t[-1] übersetzt gcc ohne Fehler, sie überschreiben aber fremden Speicher (undefiniertes Verhalten). "Annika" braucht 7 Byte, n hat nur 6. Die geschweiften Klammern gibt es nur bei der Initialisierung, danach kann man einem Array nichts mehr zuweisen. Typischer Fehler: n[5] = 'x'; für verboten halten — Index 5 ist bei 6 Byte der letzte gültige.
Ansatz: Gültige Indizes bei t: 0 bis 3, bei n: 0 bis 5.
Weiter: Ein Array als Ganzes steht nie links vom = (außer bei der Deklaration).