.svg)
Die erste Programmier-Klausur prüft selten exotisches Sprachwissen. Ob das Modul Info 1, Einführung in die Informatik oder Programmierung 1 heißt – gefragt sind fast immer dieselben Bausteine: Variablen, Schleifen, Funktionen, dazu ein wenig Rekursion und Binärdarstellung. Und vor allem eine Fähigkeit, die viele unterschätzen: einen gegebenen Ablauf im Kopf Schritt für Schritt durchzuspielen und vorherzusagen, welcher Wert am Ende in welcher Variable steht. Wer programmieren lernen will, trainiert genau das – nicht das Auswendiglernen von Syntax.
Diese Zusammenfassung führt in der Reihenfolge durch den Stoff, in der die Konzepte aufeinander aufbauen: vom Algorithmus-Begriff über Variablen, Datentypen und Zuweisungen zu Ausdrücken und logischen Bedingungen, dann zu Verzweigungen und Schleifen, zu Funktionen mit Parametern und Gültigkeitsbereichen, zu Listen und Zeichenketten, zu einfachen Algorithmen wie der linearen Suche, zu Rekursion, Fehlersuche und zum Binärsystem. Jedes Rechenbeispiel ist durchgespielt, jeder Ablauf in nachvollziehbaren Schritten erklärt. Besonderes Gewicht liegt auf den Klassikern, die in Klausuren Punkte kosten: der Unterschied zwischen Zuweisung und Gleichung, Ganzzahl- gegen Gleitkommadivision, die Frage, warum 0,1 + 0,2 nicht exakt 0,3 ergibt, und der Off-by-one-Fehler bei Indizes, die bei 0 beginnen.
Zur Vorbereitung auf die Info-1-Klausur gehören außerdem Lernkarten zu Variablen, Schleifen und Funktionen sowie Übungsfragen, die wie echte Klausuraufgaben gestellt sind: Abläufe auswerten, Fehler finden, Zahlen umrechnen. Wenn du die Inhalte in Learnboost übernimmst, wiederholt Spaced Repetition jede Karte kurz bevor du sie vergisst, der Lernplan verteilt den Stoff bis zur Klausur, und der KI-Tutor beantwortet Rückfragen – etwa warum eine bestimmte Schleife nicht terminiert.
Übernimm diese Inhalte kostenfrei in deinen Learnboost Account — dann arbeiten sie für dich weiter: Spaced Repetition bringt jede Karte zurück, kurz bevor du sie vergisst. So stehst du zur nächsten Klausur nicht wieder am Anfang.
Kostenlos starten · Keine Kreditkarte · Deine eigenen Unterlagen bleiben privat
Programmieren heißt, ein Problem in Schritte zu zerlegen, die ein Rechner ausführen kann. Die Schreibweise dieser Zusammenfassung ist an Python angelehnt; alle Konzepte gelten sprachunabhängig.
Am Anfang steht der Algorithmus: eine endliche, eindeutig beschriebene Folge von Schritten, die ein Problem löst. Drei Eigenschaften sind klausurrelevant: Eindeutigkeit (jeder Schritt ist präzise festgelegt – ein Rezept mit „nach Gefühl würzen“ wäre keiner), Ausführbarkeit (jeder Schritt ist elementar genug, um ihn tatsächlich auszuführen) und Endlichkeit bzw. Terminierung (das Verfahren endet nach endlich vielen Schritten).
Ein Programm ist ein Algorithmus in einer Programmiersprache. Den menschenlesbaren Quelltext übersetzt entweder ein Compiler komplett vor der Ausführung in Maschinencode (so arbeitet C), oder ein Interpreter führt ihn zur Laufzeit Anweisung für Anweisung aus (so arbeitet Python). Die Laufzeitumgebung stellt beim Ausführen Dienste wie Speicherverwaltung und Betriebssystemzugriff bereit.
Eine Variable ist ein benannter Speicherplatz. Bei der Zuweisung x = 5 wird immer zuerst die rechte Seite ausgewertet, dann das Ergebnis links gespeichert. Deshalb ist x = x + 1 keine mathematische Gleichung – als Gleichung wäre sie unlösbar. Als Anweisung heißt sie: Nimm den aktuellen Wert von x, addiere 1, speichere das Ergebnis wieder in x – aus 7 wird 8. Der Klassiker daneben: Das einfache = weist zu, das doppelte == vergleicht. Wer in einer Bedingung zuweist, verändert Werte, statt sie zu prüfen.
Elementare Datentypen: ganze Zahlen (42), Gleitkommazahlen (3,14), Wahrheitswerte (wahr oder falsch) und Zeichenketten („Hallo“). Umwandlungen passieren explizit (du wandelst die Zeichenkette „42“ selbst in die Zahl 42) oder implizit durch die Sprache: 3 + 2,5 ergibt die Gleitkommazahl 5,5. Vorsicht: Die Umwandlung von Gleitkomma- in ganze Zahlen schneidet ab, aus 3,9 wird 3 – gerundet wird nicht.
Die Ganzzahldivision liefert nur den ganzzahligen Anteil: 7 ganzzahlig durch 2 ergibt 3, denn 2 passt dreimal in 7; die Gleitkommadivision liefert 3,5. Der Modulo-Operator liefert den Rest: 7 mod 2 ergibt 1; 17 mod 5 ergibt 2, denn 17 ist 3 mal 5 plus 2. Typische Anwendungen: n ist genau dann gerade, wenn n mod 2 gleich 0 ist; n mod 10 liefert die letzte Ziffer.
Gleitkommazahlen speichert der Rechner binär, und 0,1 ist binär ein unendlicher periodischer Bruch – wie 1/3 im Dezimalsystem; gespeichert wird eine gerundete Näherung. Deshalb ergibt 0,1 + 0,2 nicht exakt 0,3, sondern 0,30000000000000004. Konsequenz: Gleitkommazahlen nie mit == vergleichen, sondern prüfen, ob der Abstand zweier Werte kleiner als eine winzige Toleranz ist.
Ausdrücke kombinieren arithmetische Operatoren, Vergleiche und die logischen Verknüpfungen und, oder, nicht. Es gilt Punkt- vor Strichrechnung, Vergleiche vor Logik; Klammern schlagen alles. Die Kurzschlussauswertung spart den zweiten Teil: Bei „A und B“ wird B nicht mehr ausgewertet, wenn A falsch ist – erst prüfen, ob die Liste Elemente hat, dann aufs erste zugreifen. Zum Verneinen hilft die De-Morgan-Regel: „nicht (A und B)“ ist „(nicht A) oder (nicht B)“ – wer nicht volljährig und Mitglied ist, ist minderjährig oder kein Mitglied.
Jeder Ablauf besteht aus Sequenz (Anweisungen nacheinander), Verzweigung und Schleife. Die Verzweigung führt je nach Bedingung den Wenn- oder Sonst-Zweig aus; Bedingungen lassen sich verschachteln, und die Mehrfachauswahl „wenn – sonst wenn – sonst“ führt genau den ersten zutreffenden Zweig aus.
Die kopfgesteuerte Schleife (while) prüft die Bedingung vor jedem Durchlauf und läuft daher auch null-mal. Die zählergesteuerte Schleife (for) durchläuft einen festen Bereich oder eine Sammlung. Die fußgesteuerte Schleife prüft erst nach dem Durchlauf und läuft mindestens einmal. Eine Endlosschleife entsteht, wenn die Bedingung nie falsch wird – typisch: Die Laufvariable wird im Rumpf nicht verändert, oder die Abbruchbedingung wird übersprungen, etwa wenn ein Zähler in Dreierschritten wächst, aber „ungleich 10“ geprüft wird. Denkwerkzeug ist die Schleifeninvariante, eine Aussage, die nach jedem Durchlauf gilt – beim Aufsummieren etwa: summe enthält die Summe aller bisher besuchten Elemente.
DIE Fehlerquelle ist der Off-by-one-Fehler, das Danebenliegen um genau eins. Er hängt an der 0-basierten Indizierung: Das letzte Element einer Liste der Länge n hat den Index n − 1. Zählbeispiel: Startet ein Zähler bei 0 und läuft, solange er kleiner als 3 ist, gibt es Durchläufe mit 0, 1 und 2 – drei Stück; mit „kleiner oder gleich 3“ wären es vier. Wer bei einer Liste der Länge 5 den Index 5 anspricht, greift hinter das Ende – Laufzeitfehler.
Eine Funktion bündelt Anweisungen unter einem Namen – für Wiederverwendung und Struktur. In der Definition stehen Parameter als Platzhalter; beim Aufruf übergibst du konkrete Argumente, und der Rückgabewert transportiert das Ergebnis zurück. Variablen aus dem Funktionsinneren sind lokal und existieren nur während des Aufrufs; Variablen außerhalb sind global. Verwirrbeispiel: Die globale Variable punktestand enthält 10; eine Funktion setzt eine gleichnamige lokale Variable auf 99 und gibt 99 aus – nach dem Aufruf steht global weiterhin 10, die lokale hat sie nur verdeckt.
Verändert eine Funktion Zustand außerhalb ihres Bereichs – globale Variablen, übergebene Listen, Ausgaben –, ist das ein Seiteneffekt. Zahlen kommen als Kopie an: Erhöht die Funktion ihren Parameter, bleibt die Variable außen unverändert. Listen kommen als Verweis auf dasselbe Objekt an: Hängt die Funktion ein Element an, sieht es auch die aufrufende Stelle.
Eine Liste (Array) reiht Werte geordnet auf; der Index beginnt bei 0, bei Länge 8 sind also 0 bis 7 gültig. Jede Liste kennt ihre Länge; eine Schleife läuft die Elemente der Reihe nach durch. Zeichenketten sind Folgen einzelner Zeichen mit demselben Indexprinzip: In „Informatik“ steht an Index 0 das I, an Index 2 das f. Drittes Grundkonzept sind Schlüssel-Wert-Paare: Zugriff über einen Schlüssel statt eine Position, etwa per Matrikelnummer auf den Namen – vertieft auf der Schwesterseite zu Datenstrukturen und Algorithmen.
Vier Muster decken die meisten Aufgaben ab. Summe und Durchschnitt: summe startet bei 0, jedes Element wird addiert, am Ende durch die Anzahl geteilt – für 4, 7 und 1 wächst summe von 0 über 4 und 11 auf 12, der Durchschnitt ist 12 durch 3, also 4. Minimum und Maximum: Eine Merkvariable startet mit dem ersten Element; jedes weitere ersetzt sie, wenn es kleiner bzw. größer ist. Die Falle: Wer mit 0 initialisiert, bekommt bei der Maximumsuche über −3, −8 und −1 das Ergebnis 0 – eine Zahl, die gar nicht in der Liste vorkommt; richtig wäre −1. Der Minimumsuche passiert dasselbe bei rein positiven Werten. Lineare Suche: das Gesuchte der Reihe nach mit jedem Element vergleichen, beim ersten Treffer mit dessen Index abbrechen, sonst „nicht gefunden“ melden – wie schnell das bei großen Datenmengen bleibt, ist Thema der Schwesterseite. Zählen und Filtern: Ein Zähler wird nur erhöht bzw. ein Element nur übernommen, wenn es eine Bedingung erfüllt.
Eine Funktion ist rekursiv, wenn sie sich selbst aufruft – mit einem kleineren Teilproblem. Zwingend nötig ist ein Basisfall, der ohne Selbstaufruf auskommt; fehlt er, terminiert die Rekursion nie, und das Programm bricht ab, wenn der Speicher für die offenen Aufrufe erschöpft ist. Standardbeispiel Fakultät: fakultät(n) ist n mal fakultät(n − 1), Basisfall fakultät(0) gleich 1. Der Aufruf fakultät(4) steigt ab über fakultät(3), fakultät(2) und fakultät(1) bis fakultät(0); dort greift der Basisfall, und auf dem Rückweg wird multipliziert: 1 mal 1 ist 1, mal 2 ist 2, mal 3 ist 6, mal 4 ist 24. Jede Rekursion lässt sich auch als Schleife schreiben – die Schleife spart Verwaltungsaufwand, die Rekursion ist bei selbstähnlichen Problemen das natürlichere Denkmuster.
Syntaxfehler verstoßen gegen die Grammatik der Sprache – das Programm startet gar nicht. Laufzeitfehler treten während der Ausführung auf, etwa Division durch 0 oder ein Zugriff hinter das Listenende. Logikfehler sind die tückischste Klasse: Das Programm läuft ohne Fehlermeldung durch, aber das Ergebnis ist falsch – wie bei der Maximumsuche mit Startwert 0. Dagegen hilft systematisches Eingrenzen: Zwischenwerte ausgeben und mit der Erwartung vergleichen, das Beispiel von Hand durchspielbar klein machen, Randfälle testen – leere Liste, ein Element, Null, negative Werte.
Rechner speichern alles in Bits, den Ziffern 0 und 1. Im Binärsystem haben die Stellen von rechts die Wertigkeiten 1, 2, 4, 8, 16 und so weiter. Von binär nach dezimal addierst du die Wertigkeiten der Einsen: 1011 ist 8 plus 2 plus 1, also 11. Umgekehrt teilst du wiederholt ganzzahlig durch 2 und notierst die Reste: 13 durch 2 ist 6 Rest 1, dann 3 Rest 0, dann 1 Rest 1, dann 0 Rest 1 – die Reste rückwärts gelesen ergeben 1101. Acht Bits sind ein Byte mit 256 Werten, vorzeichenlos 0 bis 255. Wer zum Maximum 1 addiert, erzeugt einen Überlauf – begrenzte Bits bedeuten immer einen begrenzten Zahlenbereich.
Vier Regeln reichen für den Anfang: sprechende Namen (anzahlVersuche statt av), kleine Funktionen mit genau einer Aufgabe, Kommentare für das Warum – was der Code tut, sieht man ihm an – und Konsistenz bei Benennung und Formatierung im gesamten Programm.
Arbeite mit dieser Zusammenfassung weiter — kostenfrei in deinem Learnboost Account.
Zusammenfassung übernehmenFrage antippen, um die Antwort aufzudecken.
Ein Algorithmus ist eine endliche, eindeutig beschriebene Folge von Schritten zur Lösung eines Problems. Er muss eindeutig sein (jeder Schritt ist präzise festgelegt), ausführbar (jeder Schritt ist elementar genug, um ihn tatsächlich auszuführen) und endlich bzw. terminierend (er endet nach endlich vielen Schritten).
Ein Compiler übersetzt den gesamten Quelltext vor der Ausführung in Maschinencode (Beispiel: C). Ein Interpreter führt den Quelltext zur Laufzeit Anweisung für Anweisung aus (Beispiel: Python). Kompilierte Programme laufen meist schneller, interpretierte lassen sich ohne Übersetzungsschritt direkt ausprobieren.
Der Quelltext ist das vom Menschen geschriebene, lesbare Programm. Maschinencode ist die Folge von Prozessorbefehlen, die der Rechner tatsächlich ausführt; Quelltext muss dafür übersetzt oder interpretiert werden. Die Laufzeitumgebung stellt während der Ausführung benötigte Dienste bereit, etwa Speicherverwaltung und den Zugriff auf das Betriebssystem.
Eine Variable ist ein benannter Speicherplatz für einen Wert. Bei einer Zuweisung wird zuerst der Ausdruck auf der rechten Seite vollständig ausgewertet, dann wird das Ergebnis in der Variablen auf der linken Seite gespeichert. Der alte Wert der Variablen wird dabei überschrieben.
Als Gleichung wäre x = x + 1 unlösbar. Als Anweisung bedeutet sie: Werte die rechte Seite mit dem aktuellen Wert von x aus und speichere das Ergebnis wieder in x — aus 7 wird 8. Das einfache = ist der Zuweisungsoperator, das doppelte == der Vergleichsoperator, der prüft, ob zwei Werte gleich sind. Die Verwechslung ist ein Klassiker: Wer in einer Bedingung zuweist statt zu vergleichen, verändert den Wert, statt ihn zu prüfen.
Ganze Zahl (z. B. 42), Gleitkommazahl (z. B. 3,14), Wahrheitswert (wahr oder falsch) und Zeichenkette (z. B. der Text „Hallo“). Der Datentyp legt fest, welche Werte eine Variable annehmen kann und welche Operationen darauf erlaubt sind.
Gleitkommazahlen werden binär gespeichert, und 0,1 ist im Binärsystem ein unendlicher periodischer Bruch — gespeichert wird nur eine gerundete Näherung. Die Summe ist deshalb 0,30000000000000004. Konsequenz: Gleitkommazahlen nie mit == auf exakte Gleichheit prüfen, sondern testen, ob der Abstand zweier Werte kleiner als eine winzige Toleranz ist.
Bei „A und B“ wird B nicht mehr ausgewertet, wenn A bereits falsch ist; bei „A oder B“ nicht mehr, wenn A bereits wahr ist — das Gesamtergebnis steht ja schon fest. Man nutzt das als Schutz: erst prüfen, ob eine Liste Elemente enthält, und nur dann auf das erste Element zugreifen. Der riskante zweite Teil wird so gar nicht erst ausgeführt.
„nicht (A und B)“ ist gleichbedeutend mit „(nicht A) oder (nicht B)“ — beim Verneinen kippt das Und in ein Oder, und beide Teile werden verneint. Beispiel: Wer nicht volljährig und Mitglied ist, ist minderjährig oder kein Mitglied. Analog gilt: „nicht (A oder B)“ ist „(nicht A) und (nicht B)“.
Die kopfgesteuerte Schleife (while) prüft die Bedingung vor jedem Durchlauf und kann daher auch null-mal laufen. Die zählergesteuerte Schleife (for) durchläuft einen festen Bereich oder eine Sammlung Element für Element. Die fußgesteuerte Schleife prüft die Bedingung erst nach dem Durchlauf und läuft deshalb mindestens einmal.
Ein Off-by-one-Fehler liegt vor, wenn ein Ablauf um genau einen Schritt oder Index danebenliegt — die Schleife läuft einmal zu oft oder zu selten, oder ein Index zeigt ein Element zu weit. Da Indizes bei 0 beginnen, hat das letzte Element einer Liste der Länge n den Index n − 1. Wer bis Index n läuft, greift hinter das Listenende und löst einen Laufzeitfehler aus.
Lokale Variablen werden innerhalb einer Funktion angelegt und existieren nur während des Aufrufs; globale Variablen existieren außerhalb und darüber hinaus. Verwirrbeispiel: Die globale Variable punktestand enthält 10. Eine Funktion legt eine gleichnamige lokale Variable an und setzt sie auf 99 — in der Funktion wird 99 ausgegeben, aber nach dem Aufruf enthält die globale Variable weiterhin 10. Die lokale Variable hat die globale nur verdeckt, nicht verändert.
Die lineare Suche vergleicht den gesuchten Wert der Reihe nach mit jedem Element der Liste, beginnend bei Index 0. Beim ersten Treffer bricht sie ab und liefert den Index; erreicht sie das Ende ohne Treffer, meldet sie „nicht gefunden“. Wie schnell Suchverfahren bei großen Datenmengen sind, ist Thema der Datenstrukturen und Algorithmen.
Mit Startwert 0 vergleicht man gegen einen Wert, der womöglich gar nicht in der Liste vorkommt. Bei der Maximumsuche über −3, −8 und −1 bliebe die Merkvariable auf 0 stehen, obwohl das echte Maximum −1 ist; bei der Minimumsuche über rein positive Werte bliebe sie ebenfalls fälschlich auf 0. Startet man mit dem ersten Element, ist das Ergebnis garantiert ein Wert aus der Liste.
Eine rekursive Funktion ruft sich selbst auf, jeweils mit einem kleineren Teilproblem. Der Basisfall ist der Fall, der ohne weiteren Selbstaufruf direkt ein Ergebnis liefert — bei der Fakultät ist fakultät(0) gleich 1. Ohne Basisfall reißt die Kette der Selbstaufrufe nie ab: Die Rekursion terminiert nicht, und das Programm bricht ab, wenn der Speicher für die offenen Aufrufe erschöpft ist.
Ein Syntaxfehler verstößt gegen die Grammatik der Sprache — das Programm startet gar nicht. Ein Laufzeitfehler tritt während der Ausführung auf, etwa bei einer Division durch 0 oder einem Zugriff hinter das Listenende. Ein Logikfehler ist die tückischste Klasse: Das Programm läuft ohne Fehlermeldung durch, liefert aber ein falsches Ergebnis — es gibt keinen Hinweis, wo der Fehler steckt.
Lerne diese Karten mit Spaced Repetition weiter — kostenfrei in deinem Learnboost Account.
Lernkarten übernehmen5
4
15
8
Lösung:
Nach der ersten Zuweisung enthält x den Wert 7. Die Verdopplung ergibt 14. Der Rest der Division von 14 durch 5 ist 4, denn 14 ist 2 mal 5 plus 4. Die letzte Anweisung erhöht 4 um 1 — am Ende steht 5 in x.
Solche Abläufe prüfen genau eine Fähigkeit: den Zustand einer Variablen über mehrere Zuweisungen hinweg zu verfolgen. Wer 15 erhält, hat den Modulo-Schritt übersprungen; wer 4 erhält, die letzte Erhöhung vergessen. Der Modulo-Operator liefert immer den Rest, nie den Quotienten der Division.
10
6
15
4
Lösung:
Die Schleife läuft mit den Zählerwerten 1, 2, 3 und 4. Die Summe wächst dabei von 0 auf 1, dann auf 3, dann auf 6 und schließlich auf 10. Beim Zählerwert 5 ist die Bedingung verletzt, der Rumpf läuft nicht mehr — summe enthält 10.
Die Bedingung „kleiner oder gleich 4“ schließt den Wert 4 ein — die Schleife läuft viermal. Wer 6 erhält, hat den letzten Durchlauf unterschlagen (Off-by-one), wer 15 erhält, einen Durchlauf mit dem Wert 5 zu viel gerechnet. Als Schleifeninvariante gilt: Nach jedem Durchlauf enthält summe die Summe aller bisher besuchten Zählerwerte.
Die Anweisung x = x + 1 erhöht den in x gespeicherten Wert um 1.
Als mathematische Gleichung gelesen wäre x = x + 1 unlösbar.
Das doppelte Gleichheitszeichen == weist einer Variablen einen Wert zu.
Bei einer Zuweisung wird zuerst die rechte Seite ausgewertet und das Ergebnis dann in der Variablen links gespeichert.
Lösung:
Richtig sind die Aussagen, dass x = x + 1 den gespeicherten Wert um 1 erhöht, dass dieselbe Zeile als Gleichung unlösbar wäre und dass bei einer Zuweisung erst die rechte Seite ausgewertet und dann gespeichert wird. Falsch ist die Aussage zum doppelten Gleichheitszeichen: == vergleicht zwei Werte und liefert einen Wahrheitswert — zuweisen tut das einfache =.
Die Verwechslung von = und == ist einer der häufigsten Anfängerfehler überhaupt. Merke: Die Zuweisung ist eine Handlung mit Richtung — rechts rechnen, links speichern —, der Vergleich ist eine Frage mit Ja-Nein-Antwort. Deshalb ist x = x + 1 sinnvoll, obwohl es mathematisch widersprüchlich aussieht.
Ein Off-by-one-Fehler: Beim Index n greift der Ablauf hinter das Listenende, denn der letzte gültige Index ist n − 1 — es kommt zu einem Laufzeitfehler.
Kein Fehler: Eine Liste der Länge n hat die Indizes 0 bis n.
Ein Syntaxfehler: Die Schleifenbedingung ist grammatikalisch falsch formuliert.
Eine Endlosschleife, weil der Zähler nie verändert wird.
Lösung:
Die Liste hat die gültigen Indizes 0 bis n − 1. Die Bedingung „kleiner oder gleich n“ lässt die Schleife aber auch mit dem Zählerwert n laufen — dieser Zugriff liegt hinter dem Listenende und löst einen Laufzeitfehler aus. Korrekt wäre die Bedingung „kleiner als n“: Dann läuft die Schleife genau n-mal über die Indizes 0 bis n − 1.
Das ist der Off-by-one-Fehler in seiner häufigsten Form. Bei 0-basierter Indizierung gilt immer: Länge n bedeutet letzter Index n − 1. Ein Syntaxfehler scheidet aus, weil der Ablauf startet, und eine Endlosschleife scheidet aus, weil der Zähler in jedem Durchlauf erhöht wird — der Fehler zeigt sich erst zur Laufzeit beim Zugriff auf den ungültigen Index.
Die Schleife terminiert nie: x nimmt die Werte 0, 3, 6, 9, 12 und so weiter an und ist nie exakt 10.
Mit der Bedingung „solange x kleiner als 10“ würde die Schleife terminieren.
Die Schleife endet nach dem vierten Durchlauf, weil x dann 12 ist.
Endlosschleifen entstehen ausschließlich dann, wenn die Laufvariable überhaupt nicht verändert wird.
Lösung:
Richtig ist: Die Schleife terminiert nie, denn x durchläuft 0, 3, 6, 9, 12, 15 und so weiter — der Wert 10 wird übersprungen, die Bedingung „ungleich 10“ bleibt für immer wahr. Richtig ist auch, dass die Bedingung „kleiner als 10“ das Problem behebt: Nach den Durchläufen mit x gleich 0, 3, 6 und 9 steht x auf 12, die Bedingung ist verletzt, die Schleife endet. Falsch sind die beiden übrigen Aussagen: Mit „ungleich 10“ endet die Schleife gerade nicht bei 12, und eine Endlosschleife entsteht nicht nur bei unveränderter Laufvariable, sondern auch — wie hier — wenn die Abbruchbedingung übersprungen wird.
Die Aufgabe zeigt die zweite große Ursache für Endlosschleifen neben der unveränderten Laufvariable: eine Gleichheits- oder Ungleichheitsbedingung, deren Zielwert übersprungen wird. Robuste Schleifenbedingungen formulieren deshalb einen Bereich („kleiner als“) statt eines exakten Werts („ungleich“).
Lösung:
Durchspielen des fehlerhaften Ablaufs: Die Merkvariable startet bei 0. Der Vergleich fragt jeweils, ob das Element größer als die Merkvariable ist: −4 ist nicht größer als 0, −9 nicht, −2 nicht — kein Element ersetzt die Merkvariable, das Ergebnis ist 0. Das ist ein Logikfehler: 0 kommt in der Liste gar nicht vor, das echte Maximum ist −2.
Korrekte Fassung: Die Merkvariable wird mit dem ersten Element initialisiert, also mit −4, und die Schleife beginnt beim zweiten Element. −9 ist nicht größer als −4, die Merkvariable bleibt; −2 ist größer als −4, die Merkvariable wird zu −2. Ergebnis: −2 — garantiert ein Wert aus der Liste.
Volle Punktzahl verlangt drei Bestandteile: das durchgespielte falsche Ergebnis 0, die Einordnung als Logikfehler durch falsche Initialisierung — das Programm läuft ja fehlerfrei durch — und die Korrektur mit dem ersten Element als Startwert samt Ergebnis −2. Der Startwert 0 scheitert immer dann, wenn alle Werte negativ sind; bei der Minimumsuche scheitert er entsprechend bei rein positiven Werten.
Lösung:
Abstieg: fakultät(4) braucht fakultät(3), das braucht fakultät(2), das braucht fakultät(1), das braucht fakultät(0). Erst dort greift der Basisfall und liefert direkt 1, ohne weiteren Selbstaufruf.
Rückweg: fakultät(1) ist 1 mal 1, also 1; fakultät(2) ist 2 mal 1, also 2; fakultät(3) ist 3 mal 2, also 6; fakultät(4) ist 4 mal 6, also 24.
Ohne Basisfall würde die Kette bei fakultät(0) nicht stoppen, sondern mit fakultät(−1), fakultät(−2) und so weiter endlos absteigen. Jeder offene Aufruf belegt Speicher, bis das Programm mit einem Laufzeitfehler abbricht — die Rekursion terminiert nie.
Bewertet werden die vollständige Aufrufkette bis zum Basisfall, die korrekten Zwischenergebnisse 1, 1, 2, 6 und 24 auf dem Rückweg und die Begründung der Terminierung: Der Basisfall ist die einzige Stelle, die ohne Selbstaufruf auskommt — fehlt er, reißt die Kette nie ab. Jede Rekursion ließe sich auch als Schleife formulieren; die rekursive Fassung spiegelt hier direkt die mathematische Definition.
10110
10101
11010
1011
Lösung:
Über die Wertigkeiten: 22 ist 16 plus 4 plus 2 — also eine 1 bei den Wertigkeiten 16, 4 und 2 und eine 0 bei 8 und 1: 10110. Oder über wiederholtes Teilen: 22 durch 2 ist 11 Rest 0, 11 durch 2 ist 5 Rest 1, 5 durch 2 ist 2 Rest 1, 2 durch 2 ist 1 Rest 0, 1 durch 2 ist 0 Rest 1. Die Reste rückwärts gelesen ergeben 10110.
Beide Wege müssen dasselbe liefern — das ist eine gute Selbstkontrolle in der Klausur. Zur Probe rückwärts rechnen: 10110 ist 16 plus 4 plus 2, also 22. Die Verwechslungsgefahr liegt beim Ablesen der Reste: Sie fallen von der niederwertigsten Stelle her an und müssen rückwärts notiert werden.
Lösung:
Zielwert 3: Erster Vergleich am Index 0 — 8 ist nicht 3. Zweiter Vergleich am Index 1 — 3 ist 3, Treffer. Die Suche liefert den Index 1 und braucht 2 Vergleiche.
Zielwert 5: Alle fünf Elemente werden verglichen — 8, 3, 12, 3 und 7 sind alle ungleich 5. Nach 5 Vergleichen ist das Ende erreicht, die Suche meldet „nicht gefunden“, üblicherweise über einen speziellen Rückgabewert wie −1.
Die zweite 3 am Index 3 wird nie erreicht, weil die Suche beim ersten Treffer abbricht — sie liefert immer den Index des ersten Vorkommens.
Bewertet werden drei Punkte: der Index 1 mit 2 Vergleichen — nicht Index 2, die Zählung beginnt bei 0 —, der erfolglose Fall mit 5 Vergleichen und einem klaren „nicht gefunden“-Ergebnis sowie die Abbruchlogik, die das erste Vorkommen liefert. Im schlechtesten Fall wächst die Zahl der Vergleiche mit der Listenlänge; wie man Suchen bei großen Datenmengen beschleunigt, behandelt das Thema Datenstrukturen und Algorithmen.
7 ganzzahlig geteilt durch 2 ergibt 3, und der Rest 7 mod 2 ist 1.
Die Gleitkommadivision von 7 durch 2 ergibt 3,5.
Der Vergleich, ob 0,1 + 0,2 gleich 0,3 ist, liefert mit == den Wert wahr.
Eine ganze Zahl n ist genau dann gerade, wenn n mod 2 gleich 0 ist.
Lösung:
Richtig sind die Aussagen zur Ganzzahldivision mit Rest (2 passt dreimal in 7, es bleibt 1), zur Gleitkommadivision mit dem Ergebnis 3,5 und zum Geradheitstest über n mod 2 gleich 0. Falsch ist die Aussage zum Gleichheitsvergleich: 0,1 + 0,2 ergibt binär gespeichert 0,30000000000000004, der Vergleich mit 0,3 liefert deshalb falsch — Gleitkommazahlen prüft man über eine kleine Toleranz.
Ganzzahl- und Gleitkommadivision sind zwei verschiedene Operationen mit verschiedenen Ergebnissen — welche ausgeführt wird, hängt von Operator und Datentypen ab. Der Modulo-Operator liefert den Rest und ist das Standardwerkzeug für Geradheit, letzte Ziffern und zyklische Muster. Und für Gleitkommazahlen gilt die eiserne Regel: keine exakten Gleichheitsvergleiche.
Übe diese Probeklausur interaktiv — kostenfrei in deinem Learnboost Account.
Probeklausur übernehmenAlles auf dieser Seite kannst du kostenfrei in deinen Learnboost Account übernehmen — und dort deutlich mehr daraus machen:
Bessere Noten beginnen bei Learnboost.
Erstellt von Learnboost-Redaktion. KI-gestützt erstelltes Originalwerk, redaktionell geprüft.
Inhalte melden: content@learnboost.tech
