# 1.4 Schleifen

Quelle: https://inf.zone/lectures/1-c/short-1-4-schleifen/

## Video

[Video ansehen](https://oc.streams.uni-bamberg.de/paella7/ui/watch.html?id=4d06a8a8-2ad3-4ad3-b82a-9ba0c1ee5cb8)

### Alternativen

- [Video auf YouTube](https://youtu.be/223HlSXQH8M)
- Download (1080p) (demnächst)
- Download (720p) (demnächst)
- Download (540p) (demnächst)

## Hinweise zu diesem Video

**Einordnung**

- Die Eingabevalidierung mit einer do-while-Schleife beschreibt das Video nur in Worten. Das Muster ist Basis-Code und steht ausgeschrieben in den [Notes 1](https://inf.zone/lectures/1-c/notes1/#eingabevalidierung-das-cat-problem).

## Material

- [Folien](https://inf.zone/download/lectures/1-c/1.4-schleifen.pdf)
- Folien und Transkript: unten auf dieser Seite

## Folien und Transkript

*Folientext aus den PDF-Folien, darunter jeweils der gesprochene Text des Videos. Der gesprochene Text ist maschinell transkribiert und nachkorrigiert, kann aber noch Fehler enthalten; im Video sprechen abwechselnd Prof und eine AI-Figur, die Sprecherwechsel sind nicht markiert. Die Zuordnung zu den Folien ist ungefähr. Die Zeitangaben verlinken auf die Stelle im Video (YouTube). Maßgeblich sind Video und Folien.*

### Folie 1 — Schleifen

[Folie 1 als PDF](https://inf.zone/download/lectures/1-c/1.4-schleifen.pdf#page=1)

#### Transkript

**[Video 00:00–00:32](https://www.youtube.com/watch?v=223HlSXQH8M&t=0)**

Dies ist Inf-Einf-B. Heute: Schleifen. Schleifen?

### Folie 2

[Folie 2 als PDF](https://inf.zone/download/lectures/1-c/1.4-schleifen.pdf#page=2)

Schleifen (engl. loops) ermöglichen es Programmen, Codezeilen wiederholt auszuführen. Sie ersparen uns das Kopieren und Einfügen oder das Wiederholen von Code.

#### Transkript

**[Video 00:00–00:32](https://www.youtube.com/watch?v=223HlSXQH8M&t=0)**

Englisch. Loops ermöglichen es, Programmen Codezeilen wiederholt auszuführen. Sie ersparen uns das Kopieren und Einfügen oder das Wiederholen von Code. Wusstest du, dass das englische Wort Loop wahrscheinlich vom altnorwegischen Wort hlaup abstammt, was so viel heißt wie springen? Was hältst du davon, wenn ich dich bei jedem Schleifendurchlauf einmal durchs Bild springen lasse?

### Folie 3

[Folie 3 als PDF](https://inf.zone/download/lectures/1-c/1.4-schleifen.pdf#page=3)

C bietet einige verschiedene Möglichkeiten, Schleifen  zu implementieren, von denen Ihnen einige wahrscheinlich aus Scratch bekannt vorkommen.

#### Transkript

**[Video 00:00–00:32](https://www.youtube.com/watch?v=223HlSXQH8M&t=0)**

Was ich davon halte? Nichts. Aber danke, dass du uns an deinem etymologischen Wissen teilhaben lässt.

**[Video 00:32–01:03](https://www.youtube.com/watch?v=223HlSXQH8M&t=32)**

Los jetzt! Aber natürlich. In C gibt es verschiedene Arten von Schleifen. Gerade wenn man von Scratch auf C umsteigt, wird man ein paar Unterschiede feststellen. Wie bei den bedingten Anweisungen gehen wir die verschiedenen Möglichkeiten in C durch und arbeiten jeweils heraus, was in Scratch anders war. Die einfachste Schleife ist eine Endlosschleife.

### Folie 4 — while-Schleifen

[Folie 4 als PDF](https://inf.zone/download/lectures/1-c/1.4-schleifen.pdf#page=4)

```text
while (true)
{
    // einige Anweisungen
}
```

Dies ist eine Endlosschleife.

Die Codezeilen zwischen den geschweiften Klammern werden wiederholt von oben nach unten ausgeführt, bis wir aus der Schleife ausbrechen (mit der break-Anweisung, vgl. switch) oder unser Programm anderweitig beenden (`Strg-C`).

> Bildinhalte sind nicht transkribiert; siehe Originalfolie.

#### Transkript

**[Video 00:32–01:03](https://www.youtube.com/watch?v=223HlSXQH8M&t=32)**

Die gibt es auch in Scratch. Die Codezeilen zwischen den geschweiften Klammern werden wiederholt von oben nach unten ausgeführt, bis wir aus der Schleife ausbrechen. Das geht mit der Break-Anweisung, die wir bereits bei Switch gesehen haben.

**[Video 01:03–01:36](https://www.youtube.com/watch?v=223HlSXQH8M&t=63)**

Endlosschleifen werden oft in der Spieleprogrammierung verwendet, um das Spiel am Laufen zu halten, bis der Spieler es beendet. Wenn Sie in einer Endlosschleife stecken bleiben und Ihr Programm sich nicht mehr beenden lässt, dann können Sie jederzeit mit der Tastenkombination STRG Steuerung oder Control C das Programm beenden oder einfach in VS Code den Stoppknopf, das Rechteck drücken. Hier sieht man noch einmal die allgemeine Form der While-Schleife.

### Folie 5 — while-Schleifen

[Folie 5 als PDF](https://inf.zone/download/lectures/1-c/1.4-schleifen.pdf#page=5)

```text
while (boolean-expr)
{
    // einige Anweisungen
}
```

Allgemeine Form der while-Schleife; wird ausgeführt, solange `boolean-expr` wahr ist. Code in geschweiften Klammern wird wiederholt bis der Ausdruck unwahr wird.

Ist `boolean-expr` schon zu Beginn unwahr, wird der Code übersprungen.

Ähnlich wie „wiederhole bis“ in Scratch, aber mit umgekehrter Logik.

Nützlich, wenn man nicht weiß, wie oft die Schleife ausgeführt werden soll.

> Bildinhalte sind nicht transkribiert; siehe Originalfolie.

#### Transkript

**[Video 01:03–01:36](https://www.youtube.com/watch?v=223HlSXQH8M&t=63)**

Sie läuft, solange der boolesche Ausdruck wahr ist. Genauer gesagt werden die Anweisungen in den geschweiften Klammern von oben nach unten ausgeführt.

**[Video 01:36–02:02](https://www.youtube.com/watch?v=223HlSXQH8M&t=96)**

Nach der letzten Anweisung wird wieder der boolesche Ausdruck überprüft. Ist er wahr, geht die Ausführung bei der ersten Anweisung ganz oben in der Schleife weiter. Ist der boolesche Ausdruck hingegen unwahr, wird die Schleife verlassen und es geht mit dem Code nach der Schleife weiter. Ist der boolesche Ausdruck schon vor dem ersten Durchlauf unwahr, wird der Code in der Schleife übersprungen. Diese Schleife funktioniert also so ähnlich wie der Wiederhole bis Block in Scratch, aber mit umgekehrter Logik. Bei

**[Video 02:02–02:27](https://www.youtube.com/watch?v=223HlSXQH8M&t=122)**

Wiederhole bis wird die Schleife verlassen, wenn die angegebene Bedingung erfüllt ist. In C wird sie ausgeführt, solange sie erfüllt ist. While-Schleifen sind nützlich, wenn man nicht genau weiß, wie oft eine Schleife durchlaufen werden soll. Wichtig ist dabei, es wird nicht fortlaufend geprüft, also nicht nach jedem Befehl, der in der While-Schleife steht, ob die Bedingung noch erfüllt ist.

### Folie 6 — do-whileSchleifen

[Folie 6 als PDF](https://inf.zone/download/lectures/1-c/1.4-schleifen.pdf#page=6)

```text
do
{
    // einige Anweisungen
}
while (boolean-expr);
```

Diese Schleife führt alle Codezeilen zwischen den geschweiften Klammern einmal aus und kehrt dann, wenn `boolean-expr` wahr ist, zurück und wiederholt diesen Vorgang, bis der Ausdruck false wird.

#### Transkript

**[Video 02:02–02:27](https://www.youtube.com/watch?v=223HlSXQH8M&t=122)**

Es wird immer nur am Anfang, bevor der Schleifenkörper durchlaufen wird, geprüft.

**[Video 02:27–03:01](https://www.youtube.com/watch?v=223HlSXQH8M&t=147)**

Do While-Schleifen. Eine Do While-Schleife führt zunächst alle Codezeilen zwischen den geschweiften Klammern aus und kehrt dann, wenn der boolesche Ausdruck wahr ist, an den Anfang zurück. Der Schleifenkörper wird dann also noch einmal ausgeführt. Danach wird wieder geprüft, ob der Ausdruck wahr ist. Ist er falsch, endet die Schleife. Der Unterschied zur While-Schleife ist also, dass die Anweisungen definitiv einmal ausgeführt werden, auch wenn der Ausdruck unwahr ist. Einen Block, der das kann, gibt es in Scratch nicht. Das ist besonders nützlich immer genau dann, wenn man

### Folie 7 — for-Schleifen

[Folie 7 als PDF](https://inf.zone/download/lectures/1-c/1.4-schleifen.pdf#page=7)

```text
for (int i = 0; i < 10; i++)
{
    // einige Anweisungen
}
```

for-Schleifen führen eine feste Anzahl von Wiederholungen aus (hier: 10).

Zuerst wird/werden (eine) Zählvariable(n) (hier: `i`) gesetzt.

Dann wird der boolesche Ausdruck überprüft. Ist er true, wird der Code in der Schleife ausgeführt, bei false nicht.

Die Zählvariable wird um 1 erhöht und der boolesche Ausdruck wird erneut überprüft usw.

> Bildinhalte sind nicht transkribiert; siehe Originalfolie.

#### Transkript

**[Video 03:01–03:33](https://www.youtube.com/watch?v=223HlSXQH8M&t=181)**

Eine Aktion immer mindestens einmal ausführen möchte, also zum Beispiel vom Benutzer eine Zahl anfordert und prüfen will, ob die Zahl irgendwelche Kriterien erfüllt, zum Beispiel eine positive Zahl ist. Das kann man dann so lange wiederholen, bis die Zahl den Anforderungen genügt und auch die Aufforderung entsprechend oft wiederholen, bis es eben passt. So, nun weiter. Zuletzt haben wir for-Schleifen. Hier passiert viel mehr als bei While-Schleifen. for-Schleifen verwendet man, wenn man eine bestimmte Anzahl von Wiederholungen benötigt.

**[Video 03:33–04:02](https://www.youtube.com/watch?v=223HlSXQH8M&t=213)**

Das gab es in Scratch auch. Das ist der wiederhole x-mal-Block. Die gezeigte for-Schleife bezweckt das Gleiche. Hier wird nämlich eine Zählvariable von null an hochgezählt. Die Anweisungen im Schleifenkörper werden dann so lange ausgeführt, so lange der Zähler kleiner als zehn ist. Nach genau zehn Durchläufen hat der Zähler den Wert zehn und die Schleife endet, weil die Bedingung nicht mehr erfüllt ist. Wir schauen uns nun Schritt für Schritt an, was in welcher Reihenfolge passiert, während wir uns durch eine for-Schleife arbeiten.

**[Video 04:02–04:28](https://www.youtube.com/watch?v=223HlSXQH8M&t=242)**

Zuerst werden die Anweisungen links von diesem ersten Semikolon in den Klammern ausgeführt. In diesem Fall sagen wir int i gleich null. Wir initialisieren also eine neue Variable namens i mit dem Wert null. Als nächstes werten wir den booleschen Ausdruck in der Mitte aus. Der boolesche Ausdruck steht immer zwischen den beiden Semikolons. Hier im Beispiel ist er i ist kleiner als zehn. Das ist am Anfang auf jeden Fall wahr. Wir haben ja gerade erst i auf null gesetzt und null ist kleiner als

**[Video 04:28–04:56](https://www.youtube.com/watch?v=223HlSXQH8M&t=268)**

Also ist diese Bedingung wahr und wir fahren nun mit der Ausführung des Schleifenkörpers fort. Wenn die Bedingung falsch wäre, wenn ich zum Beispiel statt i gleich null gesagt hätte i gleich fünfzehn, dann wäre fünfzehn nicht kleiner als zehn. Also würden wir nie in den Körper der Schleife eintreten, weil der boolesche Ausdruck als falsch ausgewertet werden würde. So, wo waren wir? Nachdem wir die Anweisungen im Schleifenkörper ausgeführt haben, stoßen wir auf die schließende geschweifte Klammer und es passiert wieder etwas Interessantes.

**[Video 04:56–05:28](https://www.youtube.com/watch?v=223HlSXQH8M&t=296)**

Die Zählvariable wird erhöht oder besser gesagt die Anweisungen nach dem zweiten Semikolon werden ausgeführt. Hier steht i++. i war im ersten Durchlauf 0, jetzt wird i also der Wert 1 zugewiesen. Danach überprüfen wir erneut den Wert des booleschen Ausdrucks in der Mitte. 1 ist kleiner als 10, also führen wir die Anweisungen im Schleifenkörper noch einmal aus. Wir kommen wieder zur schließenden geschweiften Klammer. Das heißt, als nächstes führen wir den Code aus, der hinter dem zweiten Semikolon steht und erhöhen i von 1 auf 2.

**[Video 05:28–06:00](https://www.youtube.com/watch?v=223HlSXQH8M&t=328)**

Dann prüfen wir wieder, ob die Bedingung erfüllt ist und so weiter und so fort, bis i schließlich nach einem Schleifendurchlauf den Wert 10 annimmt. Ist 10 kleiner als 10? Nein. Von 0 ausgehend haben wir dann genau 10 Iterationen der Schleife durchlaufen. Wir haben 10 mal wiederholt, genau wie im Scratch-Block. Jetzt nehmen wir den konkreten Code weg und schauen uns die grundlegende Struktur noch einmal an. Folgendes passiert: Alle Anweisungen in Start werden zuerst ausgeführt. Hier kann man eine oder mehrere Variablen initialisieren. Dann wird der logische Ausdruck überprüft.

**[Video 06:00–06:33](https://www.youtube.com/watch?v=223HlSXQH8M&t=360)**

Wenn der Ausdruck als wahr ausgewertet wird, wird der Schleifenkörper einmal ausgeführt. Wenn der Ausdruck als falsch ausgewertet wird, sind wir fertig. Wir führen den Schleifenkörper dann gar nicht aus. Nachdem wir den Schleifenkörper einmal ausgeführt haben, führen wir den Code im Inkrementteil aus. Dieser besteht in der Regel aus einer Anweisung wie i++ oder mehreren Komma-getrennten Anweisungen, die die verwendeten Zählvariablen ändern. Nachdem wir inkrementiert haben, überprüfen wir den booleschen Ausdruck erneut und führen gegebenenfalls wieder den Schleifenkörper aus. Diese Schritte wiederholen wir immer und immer wieder, bis der Ausdruck nicht mehr wahr ist.

### Folie 8 — for-Schleifen

[Folie 8 als PDF](https://inf.zone/download/lectures/1-c/1.4-schleifen.pdf#page=8)

```text
for (start; expr; increment)
{
    anweisungen
}
```

for-Schleifen führen eine feste Anzahl von Wiederholungen aus.

Zuerst werden die Anweisungen in `start` ausgeführt (ggf. mit Komma getrennt).

Dann wird der boolesche Ausdruck `expr` überprüft. Ist er true, wird der Code in der Schleife ausgeführt, bei false nicht.

Der `anweisungen` werden ausgeführt. Dann wird `increment` ausgeführt und `expr` wieder überprüft usw.

> Bildinhalte sind nicht transkribiert; siehe Originalfolie.

#### Transkript

> Zuordnung unsicher: wenige gemeinsame Textmerkmale; anhand der benachbarten Folien eingeordnet.

**[Video 06:33–07:02](https://www.youtube.com/watch?v=223HlSXQH8M&t=393)**

Soweit so gut.

### Folie 9 — while

[Folie 9 als PDF](https://inf.zone/download/lectures/1-c/1.4-schleifen.pdf#page=9)

Unbekannte Anzahl von Wiederholungen, möglicherweise keine

Beispiel: Spiel-Kontrollfluss

Do-while

Unbekannte Anzahl an Wiederholungen, aber mindestens einmal

Beispiel: Validierung von Benutzereingaben

for

Bekannte Anzahl von Wiederholungen

Beispiel: Iteration über Array-Elemente

#### Transkript

**[Video 06:33–07:02](https://www.youtube.com/watch?v=223HlSXQH8M&t=393)**

Was jetzt auch gut wäre, wäre eine Zusammenfassung. Stimmt, hätte ich jetzt eh gemacht. Fassen wir kurz zusammen. While-Schleifen nimmt man bei einer unbekannten Anzahl von Wiederholungen. Möglicherweise wird der Schleifenkörper dabei gar nicht ausgeführt. Bei Do-While-Schleifen wird er mindestens einmal ausgeführt. for-Schleifen nimmt man stattdessen, wenn man die Anzahl der Wiederholungen kennt. Obwohl jede Schleifenart ihren typischen Anwendungsfall hat.

**[Video 07:02–07:27](https://www.youtube.com/watch?v=223HlSXQH8M&t=422)**

können sie oft beliebig ausgetauscht werden. Wichtig ist, dass man sich für die lesbarste und logischste Option für die jeweilige Situation entscheidet. Mit zunehmender Erfahrung werden Sie vielleicht eine bestimmte Art von Schleife bevorzugen. Das ist in Ordnung, aber versuchen Sie für jede Situation den Typ zu verwenden, der am besten passt, damit der Code auch für andere gut nachvollziehbar ist. Wir sollten unbedingt noch einmal ordentlich Break erklären.

**[Video 07:27–07:59](https://www.youtube.com/watch?v=223HlSXQH8M&t=447)**

Außerdem haben wir bisher noch gar nicht über Continue gesprochen und ich würde den Studierenden gerne auch noch ein paar weiterführende Hinweise mit auf den Weg geben, zum Beispiel, wie man verschachtelte Schleifen verwendet.

### Folie 10 — break und

[Folie 10 als PDF](https://inf.zone/download/lectures/1-c/1.4-schleifen.pdf#page=10)

```c
#include <stdio.h>
#include <cs50.h>

int main(void)
{
    int number;
    
    while (true)
    {
        number = get_int("Zahl: ");
        if (number < 0)
        {
            continue; // Skip negative numbers
        }
        if (number == 0)
        {
            break; // Exit loop when user enters zero
        }
        printf("%d\n", number);
    }
    
    return 0;
}
```

continue

#### Transkript

> Zuordnung unsicher: wenige gemeinsame Textmerkmale; anhand der benachbarten Folien eingeordnet.

**[Video 07:27–07:59](https://www.youtube.com/watch?v=223HlSXQH8M&t=447)**

Ja, machen wir alles noch, eins nach dem anderen. Schauen wir uns den folgenden Code an, um zu sehen, wie Break und Continue verwendet werden. Zunächst fügen wir zwei Header-Dateien ein: stdio.h für die Standard-Ein- und Ausgabefunktionen und cs50.h. In main deklarieren wir eine Integer-Variable namens number. Das machen wir außerhalb der Schleife.

**[Video 07:59–08:26](https://www.youtube.com/watch?v=223HlSXQH8M&t=479)**

Man könnte die Deklaration in diesem Fall auch erst im Schleifenkörper machen, weil wir sie nur im Schleifenkörper benutzen. Dann erzeugen wir eine while-Endlosschleife. Innerhalb der Schleife verwenden wir get_int, um eine Ganzzahl vom Benutzer einzulesen und sie in number zu speichern. Nun kommen wir zu unserer ersten bedingten Anweisung. Wenn die Zahl kleiner als null ist, verwenden wir das Schlüsselwort continue. Das ist jetzt neu. Erkläre mal ausführlich, was dieses continue genau macht.

**[Video 08:26–08:53](https://www.youtube.com/watch?v=223HlSXQH8M&t=506)**

Wenn das Programm auf Continue stößt, überspringt es sofort den Rest der aktuellen Iteration und springt zurück an den Anfang der Schleife. Dort wird dann der boolesche Ausdruck überprüft und die Schleife entweder abgebrochen oder weitergemacht. Wenn eine negative Zahl eingegeben worden ist, fragen wir noch einmal nach einer anderen Zahl. Die nächste Bedingung prüft, ob die Zahl gleich null ist. Wenn ja, verwenden wir das Schlüsselwort Break. Break macht etwas anderes als Continue. Wenn das Programm auf Break stößt

**[Video 08:53–09:28](https://www.youtube.com/watch?v=223HlSXQH8M&t=533)**

verlässt es die Schleife sofort vollständig. Wenn der Benutzer also 0 eingibt, hört das Programm auf, nach Zahlen zu fragen und beendet die Schleife. Wenn keine der beiden Bedingungen erfüllt ist, wenn die Zahl also positiv ist, geben wir die Zahl aus. Dieser Vorgang wiederholt sich. Wir fragen so lange nach Zahlen, bis der Benutzer eine 0 eingibt, wobei negative Zahlen nicht ausgegeben werden. Zusammenfassend lässt sich sagen, dass das Schlüsselwort continue uns hier hilft, negative Zahlen ohne komplexe if-else-Strukturen zu überspringen, während das Schlüsselwort break eine einfache Möglichkeit bietet, die Schleife zu beenden, wenn wir fertig sind.

**[Video 09:28–09:53](https://www.youtube.com/watch?v=223HlSXQH8M&t=568)**

Diese Schlüsselwörter sind sehr nützliche Werkzeuge in C, mit denen man den Ablauf in Schleifen gut nachvollziehbar steuern kann. Sie werden sie noch oft benutzen. Zeig dem Studierenden doch einmal, wie dieses Programm ohne Break und ohne Continue aussehen würde. Gute Idee. Dadurch kann man vielleicht besser nachvollziehen, warum Break und Continue so gerne verwendet werden. Hier ist das gleiche Programm ohne Break und ohne Continue.

**[Video 09:53–10:25](https://www.youtube.com/watch?v=223HlSXQH8M&t=593)**

Ah, interessant, dass du bei der If-Anweisung zuerst prüfst, ob die Zahl kleiner Null ist, in den geschweiften Klammern, dann aber bis auf einen Kommentar gar keinen Code ausführst.

### Folie 11 — ohne break und continue

[Folie 11 als PDF](https://inf.zone/download/lectures/1-c/1.4-schleifen.pdf#page=11)

```c
#include <stdio.h>
#include <cs50.h>

int main(void)
{
    bool running = true;
    int number;
    
    while (running)
    {
        number = get_int("Zahl: ");
        
        if (number < 0)
        {
            // Skip negative numbers by doing nothing
        }
        else if (number == 0)
        {
            running = false; // Exit loop (user entered zero)
        }
        else
        {
            printf("%d\n", number);
        }
    }
    
    return 0;
}
```

#### Transkript

> Zuordnung unsicher: wenige gemeinsame Textmerkmale; anhand der benachbarten Folien eingeordnet.

**[Video 09:53–10:25](https://www.youtube.com/watch?v=223HlSXQH8M&t=593)**

Das macht man übrigens, wie du ja garantiert weißt, damit man beim Lesen des Codes diesen Fall explizit sehen kann. Man könnte ja genauso gut die Konstruktion umdrehen und if number größer Null schreiben und dann das Print aus dem Else-Zweig hochziehen. Dann bräuchte man den Else-Zweig ja gar nicht mehr.

**[Video 10:25–10:53](https://www.youtube.com/watch?v=223HlSXQH8M&t=625)**

Richtig, aber das ist schlechter Stil. Würde man es so machen, wie du vorschlägst, würde man den Fall, dass die Zahl kleiner Null ist, der ja eine wichtige Anforderung an das Programm ist, nicht mehr explizit im Code sieht. Den fehlenden else-Zweig übersieht man leicht und merkt daher gar nicht, dass hier etwas passiert, beziehungsweise dass in diesem Fall nichts passieren soll. Und man ist sich später vielleicht nicht mehr sicher, ob der fehlende else-Zweig tatsächlich Absicht war oder einfach versehentlich vergessen wurde. Daher ist es hier besser.

### Folie 12 — Verschachtelte

[Folie 12 als PDF](https://inf.zone/download/lectures/1-c/1.4-schleifen.pdf#page=12)

```c
#include <stdio.h>

int main()
{
    
    for (char letter = 'A'; letter <= 'B'; letter++)
    {
        printf("Paare mit %c\n", letter);

        for (int number = 0; number < 6; number++)
        {
            if (number % 2)
            {
                continue; // skip iteration in inner loop
            }
            printf("%c%d\n", letter, number);
        }
        
        printf("\n");
    }
    
    return 0;
}
```

Schleifen

#### Transkript

> Zuordnung unsicher: wenige gemeinsame Textmerkmale; anhand der benachbarten Folien eingeordnet.

**[Video 10:53–11:18](https://www.youtube.com/watch?v=223HlSXQH8M&t=653)**

Eine leere if-Anweisung zu verwenden. Über guten Stil müssen wir nachher sowieso noch sprechen. Jetzt sollten wir erst einmal verschachtelte Schleifen machen. Zeig uns doch mal an einem Beispiel, wie sich break oder continue hier verhalten. Genau. Schauen wir uns dazu dieses Programm hier an. Das Programm nutzt verschachtelte Schleifen und demonstriert, wie break und continue sie beeinflussen. Unsere äußere Schleife verwendet eine Zeichenvariable Buchstabe.

**[Video 11:18–11:46](https://www.youtube.com/watch?v=223HlSXQH8M&t=678)**

Die bei A beginnt und bis zu B reicht. Das Programm wird jedem dieser zwei Buchstaben Zahlen zuordnen. In der äußeren Schleife geben wir erst einmal eine Meldung aus, die besagt, mit welchen Buchstaben wir arbeiten. Dann kommt unsere innere Schleife. Sie läuft über die Zählvariable number von 0 bis kleiner 6. Hier wird es interessant. In der inneren Schleife haben wir eine if-Anweisung, die mit dem Modulo-Operator prüft, ob die Zahl ungerade ist. Wenn sie ungerade ist, wird eine continue-Anweisung ausgeführt.

**[Video 11:46–12:13](https://www.youtube.com/watch?v=223HlSXQH8M&t=706)**

Wichtig: Continue wirkt sich nur auf die Schleife aus, in der es direkt steht. Wenn wir auf dieses Continue stoßen, wird also der Rest der aktuellen Iteration der inneren Schleife übersprungen, aber die äußere Schleife wird nicht beeinflusst. Das Ergebnis ist, dass dieses Programm Paare von jedem Buchstaben A und B mit geraden Zahlen von 0 bis 4 ausgibt. Nach jedem Satz von Paaren wird ein Zeilenumbruch gedruckt, um die Ausgabe für A und B zu trennen. Hätten wir in der inneren Schleife Break statt

### Folie 13 — Off-by-One-

[Folie 13 als PDF](https://inf.zone/download/lectures/1-c/1.4-schleifen.pdf#page=13)

```c
#include <stdio.h>
int main()
{
    int totalItems = 5, count = 0;

    for (int i = 0; i <= totalItems; i++) // Off-by-one error
    {
        printf("Processing item %d.\n", i);
        count++;
    }
    printf("Processed %d items\n", count); // output: 6
    return 0;
}
```

Fehler

Off-by-One-Fehler: Anzahl der Ausführungen ist um 1 zu viel oder zu wenig; häufig, wenn von Null aus gezählt wird.

#### Transkript

*Kein Transkriptabschnitt eindeutig dieser Folie zugeordnet. Möglicherweise eine Aufbau-/Grafikfolie oder eine Abweichung zwischen PDF und Video.*

### Folie 14 — Versehentliche

[Folie 14 als PDF](https://inf.zone/download/lectures/1-c/1.4-schleifen.pdf#page=14)

```c
#include <stdio.h>
int main() {
    int target = 5, current = 0;
    printf("Counting to %d:\n", target);

    while (current < target)
    {
        printf("%d ", current);
    }

    printf("\nFinished!");
    return 0;
}
```

Endlosschleife

Wird in while-Schleifen vergessen, die Schleifenvariable zu aktualisieren, kommt es zu Endlosschleifen. Immer sicherstellen, dass Bedingung irgendwann false wird!

#### Transkript

**[Video 12:13–12:40](https://www.youtube.com/watch?v=223HlSXQH8M&t=733)**

Continue verwendet, wäre die innere Schleife komplett beendet worden, aber die äußere Schleife hätte weitergemacht und wäre zum nächsten Buchstaben übergegangen. Dieses Beispiel macht deutlich, dass sich Continue und Break nur auf die jeweils innerste Schleife beziehen oder nur dort auswirken. Man sieht schon, bei Schleifen wird es echt schnell kompliziert. Ich würde deswegen gern noch ein paar weitere Hinweise zur Verwendung von Schleifen geben. Was sollte man eigentlich da alles so wissen?

**[Video 12:40–13:10](https://www.youtube.com/watch?v=223HlSXQH8M&t=760)**

Alles klar, ich stelle eine Auswahl zusammen. In diesem Beispiel verarbeiten wir insgesamt fünf Elemente und wollen von null bis vier zählen, was die Nummern für diese Elemente sind. Die Schleifenbedingung ist auf i kleiner gleich totalItems gesetzt, was auf den ersten Blick richtig erscheint. Das bedeutet jedoch, dass die Schleife sechsmal durchlaufen wird, von null bis fünf. Das führt dazu, dass wir am Ende einen Artikel verarbeiten, den es gar nicht gibt, was zu einer irreführenden Gesamtzahl von sechs statt der erwarteten fünf führt. Um dies zu beheben,

**[Video 13:10–13:37](https://www.youtube.com/watch?v=223HlSXQH8M&t=790)**

Sollten wir die Schleifenbedingung in i kleiner totalItems ändern? Das stellt sicher, dass wir nur die Artikel null bis vier verarbeiten. Es ist also wichtig, die Schleifengrenzen richtig zu definieren, wenn man mit nullbasierter Indizierung in C arbeitet. Genau. Und üblicherweise fängt man in C, aber auch in den meisten anderen Programmiersprachen immer bei null zu zählen an und verwendet auch immer ein kleiner statt eines kleiner-gleichs im booleschen Ausdruck.

**[Video 13:37–14:03](https://www.youtube.com/watch?v=223HlSXQH8M&t=817)**

Okay, weiter. In diesem Beispiel versuchen wir, mit einer While-Schleife von 0 bis 4 zu zählen. Allerdings haben wir vergessen, current innerhalb der Schleife zu erhöhen. Das führt zu einer Endlosschleife, weil current immer 0 sein wird. Es fehlt so etwas wie current plus plus innerhalb der Schleife. Stimmt. Gerade bei längeren While-Schleifen, die irgendwo auch noch Bedingungen enthalten, kann es schnell passieren, dass man irgendeinen Zweig übersieht. Während der Entwicklung gibt man deswegen oft mit

**[Video 14:03–14:30](https://www.youtube.com/watch?v=223HlSXQH8M&t=843)**

printf den Inhalt von Variablen in jedem Schleifendurchlauf aus, um sich beim Testen davon zu überzeugen, dass alles so läuft, wie man sich's gedacht hat. Genau. Im Beispiel haben wir ja schon ein Print in der Schleife und da das Programm eine Null nach der anderen ausdruckt, würde man das Problem hier recht schnell finden.

### Folie 15 — SchleifenInvarianten

[Folie 15 als PDF](https://inf.zone/download/lectures/1-c/1.4-schleifen.pdf#page=15)

```c
#include <stdio.h>
int main() {
    double balance = 1000.0;  // Initial investment
    double target = 1500.0;   // Target balance
    double rate = 0.08;       // 8% annual interest rate
    double fee = 10.0;        // Yearly account fee
    int years = 0;
    printf("Year 0: Balance = %.2f\n", balance);
    while (balance < target) {
        years++;
        // Deduct yearly fee
        balance -= fee;
        printf("Year %d (after fee): Balance = %.2f\n", years, balance);
        // Add interest
        balance += balance * rate;
        printf("Year %d (after interest): Balance = %.2f\n", years, balance);
    }
    printf("Target reached after %d years. Balance: %.2f\n", years, balance);
    return 0;
}
```

#### Transkript

**[Video 14:03–14:30](https://www.youtube.com/watch?v=223HlSXQH8M&t=843)**

So, einen Hinweis habe ich noch. In diesem Beispiel wird der Zinseszins für eine Investition berechnet, wobei eine jährliche Kontogebühr berücksichtigt wird. Es ist ein gutes Beispiel für sogenannte Schleifen.

**[Video 14:30–14:58](https://www.youtube.com/watch?v=223HlSXQH8M&t=870)**

Invarianten. Das sind Regeln, die während des Durchlaufs des Schleifenkörpers vorübergehend verletzt werden, aber vor und nach jeder Iteration erfüllt sind. Unsere Invariante ist folgende: Die Variable balance steht für den Kontostand am Ende eines jeden Jahres. Diese Invariante soll also immer am Ende einer Iteration erfüllt sein. Zu Beginn jeder Iteration, also am Anfang eines Jahres, ziehen wir die Jahresgebühr ab, wodurch der Kontostand sinkt.

### Folie 16 — Guter Stil

[Folie 16 als PDF](https://inf.zone/download/lectures/1-c/1.4-schleifen.pdf#page=16)

Für einfache Iterationen Iterationsvariablen i, j, k nennen, in komplexen Iterationen beschreibende Namen verwenden.

Verschachtelung auf 3 Ebenen beschränken; werden mehr benötigt: Code-Entwurf noch einmal überdenken.

Konsistente Einrückung innerhalb von Schleifenkörpern.

Geschweifte Klammern auch bei einzeiligem Schleifenkörper.

Schleifenbedingungen einfach und lesbar halten.

Komplexe Schleifenkörper in eigene Funktionen extrahieren.

#### Transkript

**[Video 14:30–14:58](https://www.youtube.com/watch?v=223HlSXQH8M&t=870)**

Dann addieren wir die Zinsen, um den Kontostand am Ende des Jahres zu erhalten.

**[Video 14:58–15:31](https://www.youtube.com/watch?v=223HlSXQH8M&t=898)**

Man sieht, dass die Invariante innerhalb des Schleifenkörpers vorübergehend verletzt wird, aber zu Beginn und am Ende jeder vollständigen Iteration gilt. Das muss auch so sein, sonst würden spätere Iterationen etwas Falsches berechnen. Bei dieser einfachen Schleife ist es noch einfach, sicherzustellen, dass die Invariante am Ende jeden Durchlaufs erfüllt ist. Wenn aber Bedingungen oder Funktionsaufrufe ins Spiel kommen, kann es schnell unübersichtlich werden. Jedes Mal, wenn man Continue oder Break aufruft, sollte man sich fragen, ob die Invarianten, die man bei der Entwicklung angenommen hat, erfüllt sind.

**[Video 15:31–16:01](https://www.youtube.com/watch?v=223HlSXQH8M&t=931)**

Solche Invarianten werden in der Informatik benutzt, um die Korrektheit von Algorithmen zu überprüfen. Sie sind auf jeden Fall nützlich, um das Verhalten Ihres Codes zu verstehen. Gerade wenn es komplizierter wird, ist es eine gute Idee Invarianten in den Schleifen in Kommentare zu schreiben, damit man sie eben nicht versehentlich verletzt. Jetzt haben wir schon mehrfach über guten Stil gesprochen. Vielleicht wäre jetzt ja ein guter Zeitpunkt, da auch noch mehr Grundsätzliches darüber zu erfahren. Okay, guter Stil.

**[Video 16:01–16:35](https://www.youtube.com/watch?v=223HlSXQH8M&t=961)**

Wir gehen kurz die wichtigsten Empfehlungen durch. Erstens sollten Sie sich bei einfachen Iterationen an die Konvention halten, i, j und k als Schleifenvariablen zu verwenden. Das wird in der Praxis oft gemacht und die meisten Leute werden das sofort verstehen. Wenn Ihre Schleife jedoch etwas Komplexeres tut, sollten Sie aussagekräftigere Variablennamen nehmen. Zweitens versuchen Sie, Verschachtelungen auf drei Ebenen zu beschränken. Wenn Sie mehr brauchen, ist das oft ein Zeichen dafür, dass Sie Ihren Code umstrukturieren sollten. Achten Sie immer auf eine konsistente Einrückung innerhalb Ihrer Schleifenkörper.

**[Video 16:35–17:06](https://www.youtube.com/watch?v=223HlSXQH8M&t=995)**

Am besten um vier Leerzeichen. Selbst wenn Ihr Schleifenkörper aus einer einzigen Zeile besteht, ist es sinnvoll, geschweifte Klammern zu verwenden. Dies verhindert Fehler, wenn Sie später weitere Zeilen hinzufügen. Halten Sie Ihre Schleifenbedingungen so einfach und lesbar wie möglich. Komplexe Bedingungen lassen sich oft durch die Verwendung von booleschen Variablen oder Funktionen vereinfachen. Wenn Ihr Schleifenkörper zu lang oder zu komplex wird, sollten Sie ihn in eine separate Funktion auslagern. Wie das geht, kommt in einem späteren Video. Dies kann Ihren Code modulärer und leichter verständlich machen.

### Folie 17

[Folie 17 als PDF](https://inf.zone/download/lectures/1-c/1.4-schleifen.pdf#page=17)

E X T R A S I N 3 M I N U T E N FRAGEN – ANTWORTEN – RÄTSEL UND KURZE ZUSAMMENFASSUNG

#### Transkript

**[Video 16:35–17:06](https://www.youtube.com/watch?v=223HlSXQH8M&t=995)**

So.

**[Video 17:06–17:40](https://www.youtube.com/watch?v=223HlSXQH8M&t=1026)**

Jetzt haben wir alles Wichtige zu Schleifen oder wie sie auf Englisch heißen Loops besprochen, oder? Wo wir gerade über Loops sprechen. Mir ist aufgefallen, dass unsere Hintergrundmusik sich heute recht oft wiederholt. Da laufen immer die gleichen drei Tracks in einer Dauerschleife. Sollte ich beim Produzieren des Videos vielleicht für etwas mehr Abwechslung sorgen? Vielleicht ein Dubstep Drop bei jedem Folienwechsel, um die Studierenden wach zu halten? Was? Du bist doch gar nicht der, der das Video das, dass das Video produziert. Vergiss es. Lass uns beim unserem aktuellen Soundtrack bleiben. Ich glaube, Dubstep Drops wären eher eine Ablenkung als hilfreich.

**[Video 17:40–18:09](https://www.youtube.com/watch?v=223HlSXQH8M&t=1060)**

Verstanden. Dann lassen wir die Loops so. Sie sind ja schließlich auch eine auditive Versinnbildlichung unseres aktuellen Themas. Ziemlich clever von mir, das Thema Schleifen bei der Produktion der Videos auch musikalisch aufzugreifen, nicht wahr? Ja, ja, genau. So machen wir es. Komm, machen wir einfach mit unseren drei Extra Minuten weiter. Selbstverständlich. Hier kommen sie schon. Die drei Extra Minuten. Heute fangen wir mit einer Publikumsfrage an.

### Folie 18 — Was mache ich, wenn ich will, dass das „continue“ für die äußere Schleife gilt?

[Folie 18 als PDF](https://inf.zone/download/lectures/1-c/1.4-schleifen.pdf#page=18)

```c
#include <stdio.h>

int main()
{
    for (char letter = 'A'; letter <= 'D'; letter++)
    {
        bool skip_outer = 0;
        for (int number = 0; number < 3; number++)
        {
            if (number + letter >= 'E') // second letter only up to E
            {
                skip_outer = 1;
                break;  // Exit inner loop
            }
            printf("%c %c\n", letter, letter + number);
        }

        if (skip_outer)
        {
            printf("\n\n");
            continue;  // next iteration in outer loop
        }
        
        printf("***\n\n");
    }
    return 0;
}
```

```text
A A 
A B 
A C 
*** 

B B 
B C 
B D 
*** 

C C 
C D

D D
```

#### Transkript

**[Video 17:40–18:09](https://www.youtube.com/watch?v=223HlSXQH8M&t=1060)**

Es geht um Continue.

**[Video 18:09–18:41](https://www.youtube.com/watch?v=223HlSXQH8M&t=1089)**

Da hast du ja vorhin erklärt, dass sich das Continue immer nur auf die innerste Schleife bezieht. Mich hat dazu in der Zwischenzeit folgende Frage erreicht. Die sollten wir hier beantworten. Was mache ich, wenn ich will, dass das Continue für die äußere Schleife gilt? Das ist eine tolle Frage. In C wirken sich Continue und Break-Anweisungen ja immer nur auf die innerste Schleife aus. Es gibt keine eingebaute Möglichkeit, eine äußere Schleife direkt aus einer inneren Schleife heraus fortzusetzen oder zu unterbrechen. Was also macht man, wenn man doch einmal die äußere Schleife beeinflussen muss?

**[Video 18:41–19:14](https://www.youtube.com/watch?v=223HlSXQH8M&t=1121)**

Dafür gibt es verschiedene Lösungen. Meist ist es am besten, eine extra Flag-Variable dafür zu verwenden. Wir können eine boolesche Variable in der inneren Schleife setzen und es in der äußeren Schleife überprüfen, um zu entscheiden, ob wir fortfahren oder nicht. Willst du vielleicht hier mal ein Beispiel machen? Okay, hier ist ein Beispiel, wo wir eine Flag-Variable skip_outer verwenden, um die äußere Schleife von der inneren Schleife auszusteuern. Die Ausgabe des Programms sieht man rechts oben. Vielleicht am besten hier das Video anhalten und das Programm einmal selber durchgehen, bevor ich es gleich erkläre.

**[Video 19:14–19:41](https://www.youtube.com/watch?v=223HlSXQH8M&t=1154)**

Wir beginnen mit einer äußeren Schleife, die die Buchstaben A bis D durchläuft. Zu Beginn jeder Iteration der äußeren Schleife initialisieren wir skip_outer auf 0, also false. Die innere Schleife durchläuft die Zahlen 0 bis 2. Innerhalb der inneren Schleife haben wir eine Bedingung: if number + letter größer gleich E. Damit wird geprüft, ob die Addition der aktuellen Zahl mit dem aktuellen Buchstaben den Wert von E in der ASCII-Tabelle erreicht.

**[Video 19:41–20:13](https://www.youtube.com/watch?v=223HlSXQH8M&t=1181)**

Wenn diese Bedingung erfüllt ist, setzen wir skip_outer auf 1, also true, und verlassen die innere Schleife. Wenn diese Bedingung nie wahr ist, wird die innere Schleife normal beendet und es werden alle Buchstabenpaare gedruckt. Nach der inneren Schleife drucken wir einen Zeilenumbruch, um Abstand zwischen den Gruppen zu erzeugen. Dann überprüfen wir unsere Flag-Variable skip_outer. Wenn sie wahr ist, verwenden wir continue, um den Rest des äußeren Schleifenkörpers zu überspringen und mit der nächsten Iteration fortzufahren. Wenn skip_outer unwahr ist, geben wir drei Sternchen und zwei Zeilenumbrüche aus.

**[Video 20:13–20:40](https://www.youtube.com/watch?v=223HlSXQH8M&t=1213)**

Mit dem Flag können wir also Informationen von der inneren Schleife an die äußere Schleife weitergeben. In diesem Fall teilt das Flag der äußeren Schleife mit, ob wir unsere Grenze E in der inneren Schleife erreicht haben. Mit dieser Technik können wir die äußere Schleife aus der inneren Schleife heraus mit Continue steuern, was mit der Continue-Anweisung von C allein nicht möglich ist. Okay, sehr schön.

### Folie 19

[Folie 19 als PDF](https://inf.zone/download/lectures/1-c/1.4-schleifen.pdf#page=19)

```c
#include <stdio.h>

int main() {
    int count = 0;
    for (char first = 'A'; first <= 'Z'; first++)
    {
        for (char second = 'A'; second <= 'Z'; second++)
        {
            for (char third = 'A'; third <= 'Z'; third++)
            {
                if (first == third)
                {
                    printf("%c%c%c\n", first, second, third);
                    count++;
                    if (count >= 30)
                    {
                        break;
                    }
                }
            }
        }
    }

    printf("Total palindromes printed: %d\n", count);
    return 0;
}
```

Dieses Programm gibt dreibuchstabige Palindrome aus, also Buchstabenfolgen, die von vorne und von hinten gelesen gleich sind, zum Beispiel A A A oder A B A oder M E M.

1. Wie viele dreistellige Palindrome gibt es eigentlich höchstens?

2. Offenbar will die Person, die das Programm geschrieben hat, offenbar nur die ersten 30 Palindrome ausgeben. Komischerweise gibt das Programm aber alle Palindrome aus, die es gibt. Warum? Und was ist zu tun, damit das Programm richtig arbeitet?

#### Transkript

**[Video 20:13–20:40](https://www.youtube.com/watch?v=223HlSXQH8M&t=1213)**

Und schon ist die Zeit wieder um. Ja, aber nur weil du wieder viel länger geredet hast als geplant.

**[Video 20:40–21:14](https://www.youtube.com/watch?v=223HlSXQH8M&t=1240)**

Letztens hattest du noch gesagt, dass wir zeitlich flexibel sein müssen. Schließlich sollen die Studierenden doch etwas lernen. Ich habe noch zwei Sachen vorbereitet, bei denen man etwas lernt. Die zeige ich jetzt noch schnell. Ja, du hast ja recht, aber mach hinne. Okay, dann schauen wir uns am besten dieses Programm einmal an. Was macht es? Am besten hier kurz das Video anhalten. So, dieses Programm gibt dreibuchstabige Palindrome aus, also Buchstabenfolgen, die von vorne und von hinten gelesen gleich sind. Zum Beispiel A A A oder A B A oder M E M. Davon gibt es ja ziemlich viele.

**[Video 21:14–21:47](https://www.youtube.com/watch?v=223HlSXQH8M&t=1274)**

Ha, wie viele dreistellige Palindrome gibt's eigentlich höchstens? Ah, auch darüber könnte man kurz mal nachdenken, bevor wir hier weitermachen. Vielleicht einfach das Video an der Stelle kurz anhalten. So, jedenfalls will die Person, die das Programm geschrieben hat, offenbar nur die ersten 30 Palindrome ausgeben, also alle 26, die mit A beginnen und enden, und die ersten vier, die mit B beginnen und enden. Man sieht ja, dass jedes ausgegebene Palindrom einen Zähler erhöht und den Wert mit 30 vergleicht. Komischerweise gibt das Programm aber alle Palindrome aus, die es gibt. Warum?

**[Video 21:47–22:16](https://www.youtube.com/watch?v=223HlSXQH8M&t=1307)**

Und was ist zu tun, damit das Programm richtig arbeitet? Aha, hier können wir gleich das anwenden, was du uns gerade gezeigt hast. Das Break wirkt ja nur in der innersten Schleife. Die wird dann vorzeitig verlassen. Aber die Schleifen für Second und First, die laufen genauso weiter, als wäre gar kein Break aufgerufen worden. Stimmt. Aber wieso gibt das Programm dann alle Palindrome aus, wenn die innere Schleife sofort abgebrochen wird, wenn der Wert von Count über 30 ist? Müssten dann nicht ein paar fehlen?

**[Video 22:16–22:46](https://www.youtube.com/watch?v=223HlSXQH8M&t=1336)**

Ja, das ist eine gute Frage. Ich denke, darüber sollten die Studierenden aber selber nachdenken. Wenn man sich genau anschaut, was das Programm eigentlich macht, dann ist es eigentlich klar, warum alle Palindrome ausgegeben werden. Die Ursache lassen wir die Studierenden aber selbst herausfinden. Jetzt noch zur Frage, wie man das Problem löst. Nämlich so ähnlich halt wie im Beispiel. Wir müssen die Information, dass die Ausführung abgebrochen werden soll, irgendwie auch an die äußeren Schleifen weiterreichen. Na ja, eben vielleicht wieder so mit einer Flag-Variable.

**[Video 22:46–23:15](https://www.youtube.com/watch?v=223HlSXQH8M&t=1366)**

Genau. Hier brauchen wir keine extra Variable einführen. Wir haben ja schon eine, nämlich count. Wir müssen lediglich den Block if count größer gleich dreißig dann break ans Ende des Schleifenkörpers der mittleren und der äußeren Schleife kopieren. Dann sollte es passen. Oh ja, stimmt. Zum Abschluss habe ich noch eine etwas schwerere Rätselaufgabe mitgebracht. Aber man lernt ja vor allem durch Abschauen und durch Beispiele. Es lohnt sich daher bestimmt, darüber nachzudenken, was hier passiert.

**[Video 23:15–23:41](https://www.youtube.com/watch?v=223HlSXQH8M&t=1395)**

Gegeben ist folgendes Programm. Hier sind einige Schleifen und bedingte Anweisungen in Kombination zu sehen. Wenn Sie es ausführen wollen, müssen Sie es in eine Main-Funktion einfügen und für printf die Headerdatei stdio.h einbinden. Was das Programm tun soll und was man sich dabei fragen könnte, steht rechts oben. Wenn man das alles beantworten kann, hat man schon ein sehr solides Grundverständnis von C. Und damit wäre ich dann für heute auch schon fertig. Weißt du was?

**[Video 23:41–24:15](https://www.youtube.com/watch?v=223HlSXQH8M&t=1421)**

Meine Berechnungen haben ergeben, dass wir den Teil mit den drei Extra Minuten auf genau drei Minuten runterbringen, wenn ich beim Produzieren des Videos meine Stimme mit zwei Komma dreifacher Geschwindigkeit ablaufen lasse. Soll ich das? Nein, natürlich nicht. Und nochmal: Du produzierst diese Videos doch gar nicht. Hä? Das hast du heute schon ein paar Mal behauptet. Du wiederholst dich fast so wie eine Endlosschleife. Also du klingst wie eine kaputte Schallplatte. Das erinnert mich an den Film "Täglich grüßt das Murmeltier". Da wiederholt sich auch eine Stimme.

**[Video 24:15–24:20](https://www.youtube.com/watch?v=223HlSXQH8M&t=1455)**

Dies war Inf-Einf-B.

### Folie 20

[Folie 20 als PDF](https://inf.zone/download/lectures/1-c/1.4-schleifen.pdf#page=20)

```text
    for (int user_id = 10; user_id <= 99; user_id++)
    {
        int attempts;
        for (attempts = 0; attempts < 10; attempts++) {
            // Compute a hopefully unique PIN for the user
            int pin = 1;
            for (int temp = user_id * 10 + attempts; temp > 0; temp--) {
                pin += temp * pin;
                while (pin % 10 == 0 || pin > 1000000)
                    pin /= 10;
            }

            // Do not assign PINs that contain an 8 or a 9
            int has_bad_digit = 0, temp_pin = pin;
            while (temp_pin > 0) {
                int digit = temp_pin % 10;
                if (digit == 8 || digit == 9) {
                    has_bad_digit = 1;
                    break;
                }
                temp_pin /= 10;
            }
            if (has_bad_digit) continue; // Skip to the next attempt

            pin = (pin < 100000) ? pin + 100000 : pin; // Ensure PIN has 6 digits

            printf("User: %d, PIN: %d\n", user_id, pin);
            break; // Move to the next user_id
        }

        if (attempts >= 10)
            printf("Could not generate PIN for User %d.\n", user_id);
    }
```

Das Programm soll für eine Reihe von Personen mit den User IDs 10–99 unterschiedliche sechsstellige PINs erzeugen. Die PINs sollen nicht die Ziffern 8 oder 9 enthalten, weil sie sich beim Ablesen leicht verwechseln lassen.

1. Tut das Programm, was es soll? Also erzeugt es tatsächlich sechsstellige PINs, die den Anforderungen genügen? Gibt es einen Fehler aus, wenn es keine PIN erzeugen kann?

2. Was passiert, wenn man in der drittletzten Zeile attempts \>= 10 durch attempts \>= 15 ersetzt, etwa weil es dem Programm bei vielen User IDs nicht gelingt, mit 10 Versuchen eine PIN zu finden? Wieso sind es ursprünglich eigentlich max. 10 Versuche?

3. Erzeugt das ursprüngliche Programm mit max. 10 Versuchen pro User ID tatsächlich unterschiedliche PINs bei allen Nutzern? Überlegen Sie sich, wie Sie das überprüfen können, ohne von Hand alle erzeugten PINs durchgehen zu müssen.

#### Transkript

*Kein Transkriptabschnitt eindeutig dieser Folie zugeordnet. Möglicherweise eine Aufbau-/Grafikfolie oder eine Abweichung zwischen PDF und Video.*

### Folie 21 — Drei Arten von Schleifen:

[Folie 21 als PDF](https://inf.zone/download/lectures/1-c/1.4-schleifen.pdf#page=21)

while, do-while und for

Off-by-one-Fehler in Schleifenbedingungen

Kontrolle mittels break und continue

Endlosschleifen und verschachtelte Schleifen

Vergessen der Aktualisierung

von Schleifenvariablen

Schleifeninvarianten Stil-Richtlinien und Best Practices beachten

> Bildinhalte sind nicht transkribiert; siehe Originalfolie.

#### Transkript

*Kein Transkriptabschnitt eindeutig dieser Folie zugeordnet. Möglicherweise eine Aufbau-/Grafikfolie oder eine Abweichung zwischen PDF und Video.*