MINT lernen

Typische Fehler — was oft schiefgeht

Zwölf Stolperstellen aus Pseudocode, Java und Python — vom Gleichheitszeichen bis zum Index, der bei 0 beginnt.

Hier sind die 12 häufigsten Fehler aus Klausuren und Übungen zu diesem Kapitel — vom vertauschten Gleichheitszeichen bis zur Ziffer, die eigentlich ein Zeichen ist. Jede Karte zeigt links ein kurzes Beispiel „falsch“ und „richtig“. Wer einen Fehler kennt, macht ihn seltener.

!

Die 12 häufigsten Fehler

1= statt == beim Vergleichen

✗ falsch · Java
if (note = 1) {
    System.out.println("Sehr gut");
}
✓ richtig · Java
if (note == 1) {
    System.out.println("Sehr gut");
}
Ein Zeichen zu wenig — und aus dem Vergleich wird eine Zuweisung.

So steht es oft da: if (note = 1) — gemeint ist „wenn note gleich 1 ist“.

Richtig ist: if (note == 1). In Java und Python bedeutet = „weise zu“, verglichen wird mit ==. Java bricht bei note = 1 mit einem Compilerfehler ab (int ist kein boolean), Python mit einem Syntaxfehler.

Ein Gleichheitszeichen speichert, zwei vergleichen. Im Pseudocode speichert ←, verglichen wird mit =.

2Das erste Zeichen hat den Index 1

✗ falsch · Java
String name = "Mia";
char erstes = name.charAt(1);  // 'i'
✓ richtig · Java
String name = "Mia";
char erstes = name.charAt(0);  // 'M'
Die Positionen von „Mia“ sind 0, 1 und 2.

So steht es oft da: name.charAt(1) für den Anfangsbuchstaben — das liefert aber das zweite Zeichen 'i'.

Richtig ist: name.charAt(0) bzw. in Python name[0] liefert 'M'. Das k-te Zeichen steht an Position k − 1.

Die Zählung beginnt bei 0 — der letzte Index ist länge − 1.

3≤ statt < in der Schleife über einen String

✗ falsch · Java
for (int i = 0; i <= s.length(); i++) {
    System.out.println(s.charAt(i));
}
✓ richtig · Java
for (int i = 0; i < s.length(); i++) {
    System.out.println(s.charAt(i));
}
Ein einziges Zeichen entscheidet über einen Durchlauf zu viel.

So steht es oft da: i <= s.length() — dann läuft die Schleife einmal zu oft, und s.charAt(s.length()) bricht mit einer StringIndexOutOfBoundsException ab.

Richtig ist: i < s.length(); im Pseudocode für i von 0 bis länge(s) − 1. So läuft die Schleife genau länge-mal.

Vor jeder Schleife prüfen: Wie heißt der erste, wie der letzte Wert der Zählvariablen?

4Die Schleife ändert ihre Bedingung nie

✗ falsch · Pseudocode
summe ← 0
i ← 1
solange i ≤ n wiederhole
  summe ← summe + i
ende solange
✓ richtig · Pseudocode
summe ← 0
i ← 1
solange i ≤ n wiederhole
  summe ← summe + i
  i ← i + 1
ende solange
Ohne i ← i + 1 bleibt i für immer 1.

So steht es oft da: Im Rumpf wird nur die Summe erhöht. i bleibt 1, die Bedingung i ≤ n bleibt wahr — die Schleife terminiert nicht.

Richtig ist: Im Rumpf muss sich die Variable der Bedingung ändern: i ← i + 1. Nach n Durchläufen ist i = n + 1 und die Schleife endet.

Jede Schleife braucht eine Anweisung, die sie dem Abbruch näherbringt.

5Startwert innerhalb der Schleife gesetzt

✗ falsch
✓ richtig
Nur was im eingerückten Rumpf steht, wird wiederholt.

So steht es oft da: summe ← 0 steht im Rumpf. Jeder Durchlauf beginnt wieder bei 0 — für n = 4 kommt 4 heraus statt 10.

Richtig ist: Der Startwert steht vor der Schleife. Dann sammelt summe auf: 1 + 2 + 3 + 4 = 10.

Initialisieren vor der Schleife, aufsammeln in der Schleife, ausgeben nach der Schleife.

6wahr- und falsch-Zweig vertauscht

✗ falsch
✓ richtig
Links steht immer der Zweig, der gilt, wenn die Bedingung wahr ist.

So steht es oft da: Der Fall „bestanden“ wird rechts eingetragen, weil er sich „richtig“ anfühlt. Rechts steht aber der falsch-Zweig — der Algorithmus gibt jetzt alles verkehrt herum aus.

Richtig ist: Im Dreieck steht die Bedingung punkte ≥ 50. Was gilt, wenn sie wahr ist, kommt nach links, der Rest nach rechts.

Im Struktogramm gilt immer: wahr links, falsch rechts.

7substring: das Ende mitgezählt

✗ falsch · Java
String s = "Informatik";
String t = s.substring(2, 5);  // "for"
✓ richtig · Java
String s = "Informatik";
String t = s.substring(2, 6);  // "form"
Gesucht war das Wort „form“ ab Position 2.

So steht es oft da: „form“ steht an den Positionen 2 bis 5, also s.substring(2, 5). Das liefert aber nur "for".

Richtig ist: Das Ende b ist die erste Position, die nicht mehr dazugehört: s.substring(2, 6) bzw. s[2:6] liefert "form" — genau 6 − 2 = 4 Zeichen.

substring(a, b) liefert die Zeichen a bis b − 1, also b − a Zeichen.

8Ausgabe statt Rückgabe

✗ falsch · Python
def quadrat(x):
    print(x * x)

q = quadrat(5) + 1   # TypeError
✓ richtig · Python
def quadrat(x):
    return x * x

q = quadrat(5) + 1   # 26
print zeigt an, return liefert — nur mit dem Rückgabewert kann man weiterrechnen.

So steht es oft da: Die Funktion gibt das Ergebnis mit print aus. Ohne return liefert sie None, und None + 1 bricht ab. In Java wäre das eine void-Methode, die man gar nicht in eine Rechnung einsetzen darf.

Richtig ist: return x * x (Pseudocode: zurück x · x). Dann ersetzt der Rückgabewert 25 den Aufruf, und q wird 26.

Verlangt die Aufgabe „liefert …“ oder „gibt zurück“, gehört ein return in die Operation — kein print.

9Lokale Variable nach dem Aufruf benutzt

✗ falsch · Java
void verdoppeln(int n) {
    int ergebnis = n * 2;
}
// Aufrufer:
verdoppeln(4);
System.out.println(ergebnis);
✓ richtig · Java
int verdoppeln(int n) {
    return n * 2;
}
// Aufrufer:
int ergebnis = verdoppeln(4);
System.out.println(ergebnis);  // 8
ergebnis gibt es nur, solange verdoppeln läuft.

So steht es oft da: ergebnis wird in der Methode berechnet und danach beim Aufrufer ausgegeben. Der Compiler meldet „cannot find symbol“ — außerhalb der Methode ist die Variable unbekannt.

Richtig ist: Die Methode liefert den Wert mit return, der Aufrufer speichert ihn in einer eigenen Variablen.

Lokale Variablen verschwinden, wenn die Operation endet. Daten gehen über Parameter hinein und über return heraus.

10Python: / statt // für ganze Zahlen

✗ falsch · Python
minuten = 150
stunden = minuten / 60    # 2.5
rest = minuten % 60       # 30
✓ richtig · Python
minuten = 150
stunden = minuten // 60   # 2
rest = minuten % 60       # 30
150 Minuten sind 2 Stunden und 30 Minuten — nicht 2,5 Stunden und 30 Minuten.

So steht es oft da: minuten / 60 wie in Java. In Python liefert / aber immer eine Kommazahl: 2.5.

Richtig ist: Die Ganzzahldivision heißt in Python //: 150 // 60 = 2, dazu der Rest 150 % 60 = 30. In Java teilt / zwei int-Werte ganzzahlig.

Pseudocode a / b und Java mit int-Werten: ganzzahlig. Python: / ist Kommadivision, // ist ganzzahlig.

11Java: Strings mit == verglichen

✗ falsch · Java
if (antwort == "ja") {
    weiter = true;
}
✓ richtig · Java
if (antwort.equals("ja")) {
    weiter = true;
}
Zwei Strings mit gleichem Text können zwei verschiedene Objekte sein.

So steht es oft da: antwort == "ja". Das prüft in Java nur, ob beide Seiten dasselbe Objekt sind. Eine eingelesene Antwort „ja“ ist ein neues Objekt — der Vergleich ergibt dann false.

Richtig ist: antwort.equals("ja") vergleicht die Zeichen. In Python ist antwort == "ja" dagegen richtig.

Java-Strings immer mit equals vergleichen, für die Reihenfolge compareTo — nie mit ==.

12Das Zeichen '7' als Zahl 7 gerechnet

✗ falsch · Java
char c = '7';
int wert = c;          // 55
✓ richtig · Java
char c = '7';
int wert = c - '0';    // 7
Im Speicher steht für '7' der ASCII-Wert 55.

So steht es oft da: int wert = c; für die Ziffer '7'. Java wandelt das Zeichen in seinen ASCII-Wert um: 55.

Richtig ist: c - '0' = 55 − 48 = 7. In Python: ord(c) - ord('0') oder int(c).

Ziffernzeichen sind nicht ihre Zahl: '0' bis '9' haben die ASCII-Werte 48 bis 57.