🥇Wie man Schwierigkeiten überwindet und gleichzeitig Schleifen schreibt

Obwohl es sich um ein grundlegendes Thema handelt, richtet sich dieser Artikel an erfahrene Fachleute. Das Ziel ist es, die verbreiteten Missverständnisse zu zeigen, mit denen Anfänger in der Programmierung konfrontiert sind. Für praktizierende Entwickler sind diese Probleme längst gelöst, vergessen oder werden überhaupt nicht mehr beachtet. Der Artikel kann nützlich sein, falls Sie jemandem bei diesem Thema helfen müssen. Es werden Parallelen zu Materialien aus verschiedenen Programmierbüchern von Autoren wie Schildt, Stroustrup und Okulov gezogen.

Das Thema über Schleifen wurde gewählt, weil viele Menschen an diesem Punkt aussteigen, wenn sie die Programmierung erlernen.

Diese Methode richtet sich an schwächere Studierende. In der Regel bleiben stärkere hier nicht hängen, und es ist keine spezielle Methode für sie erforderlich. Ein zweites Ziel des Artikels ist es, diese Methode von der Kategorie "funktioniert bei allen Studierenden, aber nur bei einem Lehrer" in die Kategorie "funktioniert bei allen Studierenden und allen Lehrern" zu verschieben. Ich beanspruche keine absolute Originalität. Wenn Sie bereits eine ähnliche Methode zum Lehren dieses Themas anwenden, lassen Sie mich bitte wissen, wie sich Ihre Variante unterscheidet. Wenn Sie sich entscheiden, sie anzuwenden, berichten Sie bitte im Anschluss, wie alles gelaufen ist. Wenn eine ähnliche Methode in einem Buch beschrieben ist, teilen Sie mir bitte den Titel mit.

Diese Methode habe ich über 4 Jahre entwickelt, indem ich individuell mit Studierenden unterschiedlicher Leistungsniveaus gearbeitet habe. Insgesamt etwa fünfzig Studierende und zweitausend Stunden Unterricht. Zu Beginn hingen die Studierenden oft bei diesem Thema fest und gaben auf. Nach jedem Studierenden wurden die Methode und die Materialien angepasst. Im letzten Jahr bleiben die Studierenden bereits nicht mehr an diesem Thema hängen, weshalb ich meine Erfahrungen teilen möchte.

Warum so viele Buchstaben? Schleifen sind doch ganz einfach!

Wie ich bereits erwähnt habe, kann die Komplexität des Konzepts von Schleifen von praktizierenden Entwicklern und starken Studenten oft unterschätzt werden. Man kann eine lange Vorlesung halten, viele zustimmende Köpfe und aufmerksame Augen sehen. Doch wenn es darum geht, eine Aufgabe zu lösen, kommt es zu Verwirrung und unerklärlichen Problemen. Nach der Vorlesung bleibt den Studenten meist nur ein teilweises Verständnis zurück.
Eines Tages wurde mir klar, dass die Studenten meine Beispiele wie Hieroglyphen wahrnahmen. Das bedeutet, sie betrachteten sie als unteilbare Textstücke, bei denen sie irgendeinen 'magischen' Buchstaben ergänzen mussten, damit es funktioniert.
Manchmal fiel mir auf, dass die Studenten dachten, für die Lösung einer bestimmten Aufgabe sei eine weitere Konstruktion nötig, die ich einfach noch nicht erklärt hatte. Dabei hätte es lediglich einer kleinen Modifikation des Beispiels bedurft.

Deshalb bin ich zu der Erkenntnis gekommen, dass der Fokus nicht auf der Syntax von Ausdrücken liegen sollte, sondern auf der Idee, wiederholten Code mithilfe von Schleifen zu refaktorisieren. Sobald die Schüler dieses Konzept beherrschen, wird jede Syntax durch kleine Übungen erlernt.

Wem und warum ich unterrichte

Da es keine Aufnahmeprüfungen gibt, können in meinen Kursen sowohl starke als auch sehr schwache Studenten sein. Weitere Informationen über meine Studenten finden Sie im Artikel Porträt der Teilnehmer der Abendkurse
Ich habe angestrebt, dass das Programmieren von allen erlernt werden kann, die dies möchten.
Meine Kurse finden individuell statt und der Student bezahlt sein Geld für jede Stunde. Auf den ersten Blick könnte man denken, die Studierenden würden ihre Ausgaben optimieren und Minimales verlangen. Doch die Menschen besuchen Präsenzkurse mit einem echten Lehrer nicht nur wegen des Wissens, sondern auch wegen des Vertrauens, dass sie es geschafft haben, wegen des Gefühls des Fortschritts und der Bestätigung durch einen Experten (Lehrer). Wenn die Studierenden keinen Fortschritt in ihrem Lernen spüren, werden sie aufhören. Im Großen und Ganzen kann man die Kurse so gestalten, dass die Studierenden Fortschritte im Verständnis von mehr und mehr bekannten Konstruktionen wahrnehmen. Zuerst lernen wir ausführlich die while-Schleife, dann die for-Schleife und dann die do-while-Schleife, und schon haben wir einen Kurs für zweitausend und eine Nacht, in dem zwei Monate lang nur Schleifen behandelt werden, und am Ende haben wir einen Studenten, der die Standardbibliothek aus dem Gedächtnis niedergeschrieben hat. Doch um praktische Aufgaben zu lösen, benötigt man nicht nur Wissen über den Stoff, sondern auch Selbstständigkeit in der Anwendung und in der Recherche neuer Informationen. Daher halte ich es für richtig, in Präsenzkursen das Minimum zu lehren und die selbstständige Erforschung von Nuancen und verwandten Themen zu fördern. In Bezug auf Schleifen betrachte ich das Minimum als die while-Konstruktion. Damit kann man das Prinzip verstehen. Mit dem Wissen um das Prinzip kann man auch for und do-while selbstständig erlernen.

Um schwächeren Studierenden das Material verständlich zu machen, reicht es nicht aus, die Syntax zu beschreiben. Man sollte mehr einfache, aber vielfältige Aufgaben geben und die Beispiele ausführlicher darstellen. Letztendlich wird die Geschwindigkeit des Lernens durch die Fähigkeit des Studierenden, Ausdrücke zu transformieren und Muster zu erkennen, eingeschränkt. Für cleverere Studierende werden die meisten Aufgaben langweilig sein. Wenn man mit ihnen arbeitet, muss man nicht darauf bestehen, 100 % der Aufgaben zu lösen. Mein Material kann auf meinem GitHub-Accounteingesehen werden. Allerdings sieht das Repository mehr aus wie das Grimoire eines Dunkelmagiers — niemand versteht außer mir, wo was ist, und wenn man die Kontrolle über das Material verpasst, kann man verrückt werden.

Die Methodik ist auf die Praxis ausgerichtet.

Die Theorie wird anhand der Lösung von Aufgaben erklärt. In den Grundlagenkursen zum Programmieren, wo Zweige und Schleifen behandelt werden, ist es einfach nicht möglich, eine nützliche Vorlesung zu einem einzigen Thema über eine ganze Stunde zu halten. 15 bis 20 Minuten reichen aus, um das Konzept zu erklären. Die größten Schwierigkeiten treten bei der Durchführung praktischer Aufgaben auf.
Neue Lehrkräfte können Operatoren, Verzweigungen, Schleifen und Arrays in nur einer Vorlesung behandeln. Dabei stehen die Studierenden jedoch vor der Herausforderung, diese Informationen zu verarbeiten.
Es ist nicht nur wichtig, den Stoff zu vermitteln, sondern auch sicherzustellen, dass die Zuhörer ihn verstanden haben.

Der Lernfortschritt eines Themas zeigt sich darin, wie gut der Studierende selbstständig arbeitet.
Wenn es dem Studierenden gelingt, eine Aufgabe zum Thema ohne Hilfe des Lehrers zu lösen, ist das Thema verstanden. Um eine Selbstkontrolle zu ermöglichen, wird für jede Aufgabe eine Tabelle mit Test-Szenarien bereitgestellt. Die Aufgaben haben eine klare Reihenfolge. Das Überspringen von Aufgaben wird nicht empfohlen. Ist die aktuelle Aufgabe zu schwierig, ist der nächste Schritt sinnlos. Diese ist noch schwieriger. Damit der Studierende die aktuelle komplexe Aufgabe bewältigen kann, werden ihm anhand der ersten Aufgabe mehrere Techniken erklärt. Letztendlich dreht sich der gesamte Inhalt des Themas um Strategien zur Überwindung von Schwierigkeiten. Schleifen sind eher ein Nebeneffekt.

Die erste Aufgabe ist immer ein Beispiel. Die zweite weicht nur geringfügig ab und wird "selbstständig" unmittelbar nach der ersten unter Anleitung des Lehrers durchgeführt. Alle nachfolgenden Aufgaben zielen darauf ab, auf verschiedene Kleinigkeiten aufmerksam zu machen, die Missverständnisse hervorrufen können.

Die Erklärung des Beispiels besteht aus einem Dialog, in dem der Student Backpropagation und Kreuzvalidierung anfordern muss, um sicherzustellen, dass er den Stoff verinnerlicht hat.

Ich werde banal sein und behaupten, dass das erste Beispiel zum Thema sehr wichtig ist. Wenn es Materialien für umfassende selbstständige Arbeiten gibt, können Versäumnisse beim ersten Beispiel nachgeholt werden. Wenn es außer dem Beispiel nichts gibt, wird der Student das Thema wahrscheinlich nicht beherrschen.

While oder for?

Eine der umstrittenen Fragen ist die Wahl der Schleife für das Beispiel: while oder for. Einmal hat mich ein Bekannter, ein praktikierender Entwickler ohne Lehrerfahrung, eine ganze Stunde davon überzeugt, dass die for-Schleife die einfachste zu verstehen sei. Seine Argumente beschränkten sich darauf, dass "alles klar und an seinem Platz" sei. Doch die eigentliche Ursache der Schwierigkeiten für echte Anfänger liegt in der Idee der Schleife selbst, nicht in ihrem Schreiben. Wenn jemand diese Idee nicht versteht, wird er Schwierigkeiten mit der Syntax haben. Sobald die Idee begriffen ist, verschwinden die Probleme mit der Code-Formatierung von selbst.

In meinen Materialien folgt das Thema Schleifen dem Thema Verzweigungen. Die äußere Ähnlichkeit von if und while erlaubt eine direkte Analogie: "Wenn die Bedingung im Kopf wahr ist, dann wird der Block ausgeführt." Der Unterschied bei der Schleife besteht lediglich darin, dass der Block mehrfach ausgeführt wird.

Mein zweites Argument ist, dass while weniger Formatierung benötigt als for. Weniger Formatierung bedeutet weniger dumme Fehler durch vergessene Kommata und Klammern. Anfänger haben oft noch nicht das Maß an Aufmerksamkeit und Sorgfalt entwickelt, um syntaktische Fehler automatisch zu vermeiden.
Das dritte Argument ist, dass in vielen guten Büchern while zuerst erklärt wird.

Wenn es einem Studenten gelingt, Ausdrücke problemlos umzuformen, kann man nebenbei über for sprechen. Der Student kann dann selbst wählen, was ihm besser gefällt. Wenn die Umformungen jedoch Schwierigkeiten bereiten, ist es besser, die Aufmerksamkeit nicht zu zerstreuen. Lassen Sie den Studenten zunächst alles mit while lösen. Nachdem das Thema Schleifen beherrscht ist, können die Lösungen umgeschrieben werden, um das Umformen von while in for zu üben.
Schleifen mit einer Nachbedingung sind eine eher seltene Spezies. Darauf verwende ich gar keine Zeit. Wenn der Student die Konzepte zur Erkennung von Mustern und zur Umformung von Ausdrücken verstanden hat, wird er ohne meine Hilfe zurechtkommen.

Bei der Demonstration des ersten Beispiels an leistungsstarken Studierenden weise ich darauf hin, dass es im ersten Beispiel wichtig ist, nicht nur die Lösung festzuhalten, sondern auch die gesamte Kette der Schritte, die zu dem Ergebnis führen. Faule Studierende neigen dazu, das Schreiben zu ignorieren und sich nur den endgültigen Algorithmus zu merken. Sie müssen überzeugt werden, dass einmal auch für sie eine komplexe Aufgabe anstehen könnte. Um diese zu lösen, ist es notwendig, Schritt für Schritt vorzugehen, wie in diesem Beispiel. Deshalb ist es wichtig, alle Phasen festzuhalten. In den nächsten Aufgaben kann dann nur die finale Lösung präsentiert werden.

Die Hauptidee der Automatisierung besteht darin, dass wir dem Computer die Routinearbeit abgeben. Eine der grundlegendsten Methoden ist das Schreiben von Schleifen. Diese wird angewendet, wenn im Programm mehrere identische, sich wiederholende Aktionen hintereinander ausgeführt werden.

Eindeutig ist besser als mehrdeutig

Es könnte eine gute Idee erscheinen, in der ersten Aufgabe zu Schleifen denselben Satz mehrfach auf dem Bildschirm auszugeben. Zum Beispiel:

Hurra, es funktioniert!
Hurra, es funktioniert!
Hurra, es funktioniert!
Hurra, es funktioniert!
Hurra, es funktioniert!
Hurra, es funktioniert!
Hurra, es funktioniert!
Hurra, es funktioniert!

Diese Option ist problematisch, da der Wert des Zählers nicht angezeigt wird. Dies kann für Anfänger eine Herausforderung darstellen, die nicht unterschätzt werden sollte. Ursprünglich war diese Aufgabe die erste, während die Aufgabe zum Ausgeben einer Reihe von Zahlen in aufsteigender Reihenfolge die zweite war. Hier mussten zusätzliche Begriffe wie "Schleife N Mal" und "Schleife von A bis B" eingeführt werden, die im Grunde dasselbe bedeuten. Um überflüssige Elemente zu vermeiden, beschloss ich, nur das Beispiel mit der Ausgabe einer Zahlreihe zu zeigen. Es gelingt nur wenigen ohne Vorbereitung, sich einen Zähler vorzustellen und das Verhalten eines Programms im Kopf zu simulieren. Einige Studierende begegnen dem Konzept des "mentalen Modellierens" zum ersten Mal genau bei dem Thema Schleifen.
Nach etwas Übung gebe ich die Aufgabe zur Wiederholung des gleichen Textes zur eigenständigen Bearbeitung. Wenn man zunächst einen sichtbaren Zähler und dann einen unsichtbaren bereitstellt, treten bei den Studierenden weniger Probleme auf. Manchmal reicht der Hinweis "Schreibe den Zähler nicht auf den Bildschirm" aus.

Wie wird das von anderen erklärt?

In den meisten Online-Lernmaterialien wird die Syntax von Schleifen im Rahmen von «Vorlesungen» vermittelt. Zum Beispiel auf developer.mozilla.org (zum aktuellen Zeitpunkt) werden neben der while-Schleife auch mehrere andere Konstruktionen beschrieben. Dabei werden ausschließlich die Konstruktionen in Form von Vorlagen presented. Die Ergebnisse ihrer Ausführung werden in Worten beschrieben, und Illustrationen fehlen. Meiner Meinung nach mindert diese Präsentationsweise den Nutzen solcher Materialien erheblich. Ein Schüler kann den Code abschreiben und selbst ausführen, aber ein Referenzbeispiel zum Vergleich ist immer noch notwendig. Wie soll man verstehen, ob das Beispiel richtig abgeschrieben wurde, wenn man kein Ergebnis hat, mit dem man vergleichen kann?
Wenn nur die Vorlage ohne Beispiel gegeben wird, wird es für den Studenten noch schwieriger. Wie kann man sicher sein, dass die Codefragmente in der Vorlage richtig platziert sind? Man kann versuchen, irgendetwas zu schreiben irgendwie, und dann ausführen. Aber wenn es kein Referenzbeispiel für den Vergleich des Ergebnisses gibt, wird auch die Ausführung nicht helfen.

Im C++-Kurs wird die Syntax der Schleifen auf der dritten Seite der Vorlesung 4 zum Thema "Operatoren" behandelt. Bei der Erklärung der Syntax von Schleifen wird besonders auf den Begriff "Operator" hingewiesen. Der Begriff wird in Form von Fakten präsentiert, wie "Symbol; dies ist ein Operator", "{} ist ein zusammengesetzter Operator" und "Der Schleifeninhalt muss ein Operator sein". Mir persönlich gefällt dieser Ansatz nicht, da er wichtige Zusammenhänge hinter einem einzigen Begriff verbirgt. Die Analyse des Quellcodes auf diesem Detailniveau ist für Compiler-Entwickler wichtig, um die Sprache zu spezifizieren, jedoch nicht für Studenten in der Anfangsphase. Programmieranfänger haben selten die Sorgfalt, um so genau auf Begriffe zu achten. Selten speichert und versteht jemand neue Wörter beim ersten Mal. Fast niemand kann einen gerade erst gelernten Begriff korrekt anwenden. Daher entstehen bei den Studenten zahlreiche Fehler wie "while(a<7);{ geschrieben, aber das Programm funktioniert nicht".
Meiner Meinung nach ist es besser, zu Beginn die Syntax der Konstruktion sofort mit Klammern zu präsentieren. Die Variante ohne Klammern sollte nur erklärt werden, wenn der Schüler eine konkrete Frage stellt: „Warum funktioniert es hier ohne Klammern?“

In dem Buch von Okulov „Grundlagen der Programmierung“ aus dem Jahr 2012 beginnt die Einführung in Schleifen mit der Vorlage for, dann folgen Empfehlungen zu seiner Nutzung, und anschließend kommt sofort der praktische Teil des Unterrichts. Ich verstehe, dass das Buch für das kleine, sehr talentierte Schülerkorps geschrieben wurde, das selten zu meinem Unterricht kommt.

In beliebten Büchern wird immer das Ergebnis von Codefragmenten angegeben. Zum Beispiel bei Schildt „Java 8. Das umfassende Handbuch“ aus dem Jahr 2015. Zuerst wird die Vorlage vorgestellt, dann ein Programmbeispiel, und direkt danach das Ergebnis der Ausführung.

Als Beispiel betrachten wir eine while-Schleife, in der ein Countdown von 10 durchgeführt wird und genau 10 Zeilen „Takte“ ausgegeben werden:
Nachdem diese Programme gestartet werden, gibt es zehn „Takte“folgendermaßen aus:
//Продемонстрировать применение оператора цикла while
class While {
    public static void main(String args []) {
        int n = 10;
        while (n > 0) {
            System.out.println("такт " + n);
            n--;
        }
    }
}
Nach dem Start gibt dieses Programm zehn „Takte“ wie folgt aus:
Takt 10 Takt 9 Takt 8 Takt 7 Takt 6 Takt 5 Takt 4 Takt 3 Takt 2 Takt 1

Der Ansatz mit der Beschreibung der Vorlage, dem Beispielprogramm und dem Ergebnis dieser Programmierung wird auch im Buch „JavaScript für Kinder“ und im JS-Kurs auf w3schools.com verwendet. Das Format der Webseite ermöglicht es sogar, dieses Beispiel interaktiv zu gestalten.

In dem Buch von Stroustrup „Prinzipien und Praxis mit C++“ aus dem Jahr 2016 geht der Autor noch einen Schritt weiter. Zuerst wird erklärt, welches Ergebnis erzielt werden sollte, und erst danach wird der Programmtext präsentiert. Dabei wird nicht einfach irgendein zufälliges Programm gewählt, sondern es wird ein geschichtlicher Überblick gegeben. Das hilft, die Aufmerksamkeit darauf zu lenken: „Sieh mal, das ist kein nutzloser Text. Du siehst etwas Bedeutendes.“

Als Beispiel für eine Iteration betrachten wir das erste Programm, das auf einer Maschine mit gespeichertem Programm (EDSAC) ausgeführt wurde. Es wurde von David Wheeler in dem Computerlabor der Universität Cambridge (Cambridge University, England) am 6. Mai 1949 geschrieben. Dieses Programm berechnet und druckt eine einfache Liste von Quadraten aus.
0 0 1 1 2 4 3 9 4 16 ... 98 9604 99 9801
Hier enthält jede Zeile eine Zahl, gefolgt von einem Tabulatorzeichen (‘t’) und dem Quadrat dieser Zahl. Die Version dieses Programms in C++ sieht folgendermaßen aus:
//Вычисляем и распечатываем таблицу квадратов чисел 0-99
int main()
{
    int i = 0; // Начинаем с нуля
    while(i < 100){
        cout << i << 't' << square(i) << 'n';
        ++i;
    }
}

Es ist bemerkenswert, dass das Syntaxmuster in diesem Buch nicht beschrieben wird. Stroustrup betont in seinem Handbuch für Instruktoren (Übersetzung) die Bedeutung des Respekts für die Intelligenz seiner Studenten. Die Fähigkeit, ein Muster in mehreren Beispielen zu erkennen, wird möglicherweise als Ausdruck dieser Intelligenz betrachtet.

Wie ich es selbst erkläre

Stroustrups Ansatz: Zuerst die Beschreibung des Ergebnisses, dann die Lösung des Problems und anschließend die eigenständige Analyse durch den Studenten — scheint mir der durchdachteste zu sein. Daher habe ich beschlossen, genau diese Vorgehensweise zu wählen, aber sie an einem weniger historischen Beispiel zu erläutern — einer Aufgabe zur Erstellung eines 'Inhaltsverzeichnisses'. Dieses Beispiel schafft einen wiedererkennbaren Anker, sodass ich später sagen kann: 'Erinnere dich an die Aufgabe zum Inhaltsverzeichnis', und die Studenten sich genau daran erinnern. In meinem Beispiel habe ich versucht, zwei der häufigsten Missverständnisse vorwegzunehmen. Darüber werde ich im Folgenden näher berichten.

Bei dieser Aufgabe lernen wir Techniken zur Lösung komplexer Probleme kennen. Die anfängliche Lösung sollte einfach und primitiv sein. Danach kann man darüber nachdenken, wie man diese Lösung verbessern kann.
Einführung Kapitel 1 Kapitel 2 Kapitel 3 Kapitel 4 Kapitel 5 Kapitel 6 Kapitel 7 Fazit

Meiner Beobachtung nach führt der Ansatz "Vorlage-Beispiel-Ergebnis" in verschiedenen Kombinationen dazu, dass die Studierenden den Zyklus als Hieroglyphe wahrnehmen. Dies zeigte sich darin, dass sie nicht verstanden, warum sie eine Bedingung schreiben sollten, wie sie zwischen i++ und i— wählen sollten und andere, scheinbar offensichtliche Dinge. Um solche Missverständnisse zu vermeiden, sollte der Ansatz zur Erklärung von Zyklen den Sinn der Wiederholung gleicher Aktionen betonen und erst dann die formale Struktur einführen. Daher ist es notwendig, das Syntax eines Zykels erst nach der Lösung des Problems „direkt“ zu erklären. Eine primitive Lösung für das Inhaltsverzeichnis könnte so aussehen:

Console.WriteLine("Einführung");
Console.WriteLine("Kapitel 1");
Console.WriteLine("Kapitel 2");
Console.WriteLine("Kapitel 3");
Console.WriteLine("Kapitel 4");
Console.WriteLine("Kapitel 5");
Console.WriteLine("Kapitel 6");
Console.WriteLine("Kapitel 7");
Console.WriteLine("Fazit");

Wie lässt sich das verbessern?
Ersetze die repetitiven Aktionen durch einen Zyklus.
Welche Aktionen werden hier nacheinander ohne Änderungen wiederholt?
In diesem Ausschnitt gibt es solche nicht. Allerdings sind die Ausgabebefehle für das Wort "Kapitel" mit der Nummer einander sehr ähnlich.
Der nächste Schritt besteht daher darin, den Unterschied zwischen den Fragmenten zu suchen. In dieser Aufgabe ist alles offensichtlich, später werden nicht einzelne Befehle wiederholt, sondern Codeblöcke von 5 Zeilen und mehr. Die Suche muss nicht nur in der Liste der Befehle erfolgen, sondern auch in Verzweigungs- oder Schleifenstrukturen.
Im Beispiel liegt der Unterschied zwischen den Befehlen in der Zahl nach dem Wort 'Kapitel'.
Sobald der Unterschied gefunden ist, muss das Muster der Veränderung verstanden werden. Ist das unterschiedliche Fragment eine Zahl? Steigt oder fällt es konstant? Wie verändert sich der Wert der Zahl zwischen zwei benachbarten Befehlen?
Im Beispiel steigt die Zahl nach dem Wort 'Kapitel' in Schritten von 1. Der Unterschied ist gefunden, das Muster ist ermittelt. Jetzt kann das unterschiedliche Fragment durch eine Variable ersetzt werden.
Eine solche Variable sollte vor dem ersten der sich wiederholenden Fragmente deklariert werden. Diese Variable wird normalerweise I oder j genannt, oder etwas ausführlicher. Ihr Anfangswert sollte gleich dem ersten auf dem Bildschirm ausgegebenen Wert sein. Im Beispiel ist der erste Wert 1.
Welchen Anfangswert sollte man für die Ausgabe der Reihe von Zahlen '100, 101, 102, 103, 104, 105' wählen?
In dieser Reihe ist die erste Zahl 100.
Nach jedem Ausgabe-Befehl muss der Wert dieser Variablen um 1 erhöht werden. Diese Einheit ist der Schritt der Veränderung.
Welcher Schritt folgt in der Zahlenreihe „100, 102, 104, 106“?
In dieser Reihe beträgt der Schritt 2.
Nach dem Ersetzen des variierenden Teils durch die Variable sieht der Code folgendermaßen aus:

Console.WriteLine("Einführung");
int i;
i = 0;
Console.WriteLine("Kapitel " + i);
i = i + 1;
Console.WriteLine("Kapitel " + i);
i = i + 1;
Console.WriteLine("Kapitel " + i);
i = i + 1;
Console.WriteLine("Kapitel " + i);
i = i + 1;
Console.WriteLine("Kapitel " + i);
i = i + 1;
Console.WriteLine("Kapitel " + i);
i = i + 1;
Console.WriteLine("Kapitel " + i);
i = i + 1;
Console.WriteLine("Schlussfolgerung");

Nach der Anwendung der Technik „Muster durch eine Variable ausdrücken“ ergeben sich im Code mehrere Gruppen von identischen Aktionen, die nacheinander ablaufen. Wiederholende Aktionen können jetzt durch eine Schleife ersetzt werden.

Die Schritte zur Lösung des Problems, bei dem Schleifen verwendet werden müssen, bestehen aus den folgenden Phasen:

„Stur“ mit vielen einzelnen Kommandos lösen
Ein Muster finden
Das Muster durch eine Variable ausdrücken
In Form einer Schleife gestalten

Dann werden neue Begriffe eingeführt, damit der Student nicht in der Situation ist „Ich verstehe alles, kann es aber nicht sagen“:
— Zähler — immer eine Variable, die zur Verfolgung der Anzahl der Schleifeniterationen benötigt wird. In der Regel eine Ganzzahl, die mit einer Grenze verglichen wird.
— Zähler-Schritt — Beschreibung der Regelmäßigkeit, mit der der Zähler sich ändert.
— Grenze — eine Zahl oder Variable, mit der der Zähler verglichen wird, damit der Algorithmus endlich ist. Der Wert des Zählers wird so verändert, dass er sich der Grenze nähert.
— Schleifen-Körper — eine Menge von Anweisungen, die wiederholt werden. Wenn gesagt wird „Anweisung ist im Schleifen-Körper geschrieben“, ist genau dieser Körper gemeint.
— Schleifen-Iteration — die einmalige Ausführung des Schleifen-Körpers.
— Schleifen-Bedingung — ein logischer Ausdruck, von dem abhängt, ob eine weitere Iteration ausgeführt wird. (Hier kann Verwirrung mit Verzweigungs-Konstruktionen auftreten)
Man muss darauf vorbereitet sein, dass die Studierenden anfangs die Begriffe nicht korrekt anwenden. Dies gilt sowohl für starke als auch für schwache. Einen gemeinsamen Wortschatz zu etablieren, ist eine Kunst für sich. Kurz gesagt, es ist wichtig, die Aufgabe „hebe den Code-Fragment mit <Termin> hervor“ zu stellen und selbst diese Begriffe im Gespräch korrekt zu verwenden.
Nach der Transformation mit der Schleife ergibt sich folgendes Fragment:

Console.WriteLine("Einführung");
int i = 0;
while (i < 7) {
    Console.WriteLine("Kapitel " + i);
    i = i + 1;
}
Console.WriteLine("Fazit");

Das Hauptmissverständnis

Eine verbreitete Fehlvorstellung von Studenten besteht darin, dass sie innerhalb der Schleifenstruktur Aktionen einfügen, die nur einmal ausgeführt werden müssen. Zum Beispiel so:

;
int i = 0;
while (i < 7) {
    Console.WriteLine("Einführung")
    Console.WriteLine("Kapitel " + i);
    i = i + 1;
    Console.WriteLine("Fazit");
}

Schüler stoßen immer wieder auf dieses Problem, sowohl zu Beginn als auch bei komplizierteren Aufgaben.
Der entscheidende Hinweis in diesem Fall:

Wie oft muss der Befehl geschrieben werden: einmal oder mehrfach?

Die Ausgaben der Worte „Einführung“ und „Fazit“ sowie die Deklaration und Initialisierung der Variablen i sind nicht mit anderen sich wiederholenden Aktionen vergleichbar. Sie werden nur einmal ausgeführt, daher sollten sie außerhalb des Schleifen Körpers geschrieben werden.

Im Code sollten alle drei Phasen der Lösung erhalten bleiben, um später darauf verweisen zu können, falls Schwierigkeiten auftreten. Die ersten beiden Varianten können einfach auskommentiert werden, damit sie nicht stören.
Die Aufmerksamkeit des Schülers sollte auf folgende Fakten gelenkt werden:
— In einer Schleifenbedingung wird normalerweise der Zähler mit der Grenze verglichen. Der Zähler kann sich im Schleifenbody ändern, die Grenze jedoch nicht. Um diese Regel zu brechen, muss man triftige Gründe formulieren.
— Die Befehle zum Ausgeben der Wörter „Einführung“ und „Schlussfolgerung“ befinden sich außerhalb des Schleifenbodys. Wir müssen sie einmal ausführen. „Einführung“ vor der Wiederholung der Aktionen, „Schlussfolgerung“ danach.
Im Prozess der Vertiefung dieses Themas, dem Erlernen der nächsten sowie der Klärung von Schwierigkeiten, ist es selbst für starke Studierende hilfreich, die Frage zu stellen: „Und wie oft muss diese Handlung durchgeführt werden? Einmal oder oft?“.

Entwicklung zusätzlicher Fähigkeiten

Beim Studium der Schleifen trainieren die Studierenden zudem ihre Fähigkeiten zur Diagnose und Problemlösung. Um eine Diagnose durchzuführen, muss der Studierende das gewünschte Ergebnis vorstellen und es mit dem tatsächlichen Ergebnis vergleichen. Die Maßnahmen zur Behebung hängen von der Differenz zwischen beiden ab.
Da die Studierenden in dieser Phase noch kein klares Bild vom "gewünschten" Ergebnis haben, können sie sich an den Testdaten orientieren. In der Regel versteht in dieser Phase niemand, was schiefgehen könnte und wie man damit umgeht. Deshalb gebe ich zur Aufzeichnung in einem Notizbuch eine Beschreibung typischer Probleme und einige Lösungen. Die Auswahl der am besten geeigneten Lösung ist die Aufgabe des Studierenden.
Die Aufzeichnung ist notwendig, um zu fragen: "Hat es das erwartet Ergebnis erzielt?", "Welche dieser Situationen ist jetzt eingetreten?", "Hat die angewandte Lösung geholfen?".

Die Anzahl der Aktionen ist um 1 niedriger oder höher als erwartet. Lösungen:
— Erhöhe den Anfangswert des Zählers um 1.
— Ersetze den strikten Vergleichsoperator (< oder >) durch einen nicht strikten (<= oder >=).
— Ändere den Grenzwert um 1.
Aktionen werden in einer Schleife ohne Unterbrechung, unendlich ausgeführt. Lösungen:
— Füge einen Befehl zum Ändern des Zählers hinzu, falls er fehlt.
— Korrigiere den Befehl zum Ändern des Zählers, sodass sein Wert näher an die Grenze rückt.
— Entferne den Befehl zur Änderung der Grenze, falls er im Schleifenkörper enthalten ist.
Die Anzahl der Iterationen im Zyklus ist deutlich höher oder niedriger als erwartet. Die Aktion im Zyklus wurde nicht ausgeführt. Zuerst müssen die tatsächlichen Werte der Variablen unmittelbar vor Beginn des Zyklus ermittelt werden. Lösungsmöglichkeiten:
— den Startwert der Grenze ändern
— den Startwert des Zählers ändern

In der Regel ist Problem 3 mit der Verwendung der falschen Variable oder dem Nicht-Nullsetzen des Zählers verbunden.

Nach dieser Erklärung können beim Schüler weiterhin verschiedene Missverständnisse über die Funktionsweise von Schleifen auftreten.
Um die häufigsten Missverständnisse auszuräumen, gebe ich folgende Aufgaben:

Bei der der Benutzer das Limit, den Startwert des Zählers oder den Schritt des Zählers eingibt.
Bei der der Zähler in einem arithmetischen Ausdruck verwendet werden muss. Idealerweise mit dem Zähler im Wurzelausdruck oder im Nenner, damit die Differenz nicht linear ist.
Bei der der Zähler während der Ausführung des Zyklus nicht auf dem Bildschirm angezeigt wird. Zum Beispiel das benötigte Anzahl identischer Texteinheiten oder das Zeichnen einer Figur mit Schildkrötengrafik.
Zuerst müssen einige sich wiederholende Aufgaben erledigt werden, gefolgt von anderen.
In der Reihenfolge müssen andere Aufgaben vor und nach den sich wiederholenden Aufgaben erledigt werden.

Für jede Aufgabe sind Testdaten und das erwartete Ergebnis anzugeben.

Um zu verstehen, wie schnell man vorankommen kann, sollte man den Bedingungen dieser Aufgaben aufmerksam folgen und fragen: „Wie unterscheiden sie sich vom Beispiel?“, „Was muss im Beispiel geändert werden, um sie zu lösen?“. Wenn der Schüler sinnvoll antwortet, kann er mindestens eine während des Unterrichts lösen, während die übrigen zu Hause selbstständig bearbeitet werden. Wenn die Lösung erfolgreich ist, kann die Erklärung zu den Bedingungen innerhalb von Schleifen beginnen.
Wenn es Schwierigkeiten mit der eigenständigen Lösung gibt, sollten alle Aufgaben im Unterricht behandelt werden. Damit das Lösen der Aufgabe nicht wie das Zeichnen einer Eule wirkt, empfehle ich, die Aufgabe zunächst nicht universell zu lösen. Das heißt, so, dass die Lösung den ersten Test besteht und keine Schleifenstruktur verwendet. Erst danach können Transformationen angewandt werden, um Universalisierung der Lösung zu erreichen.

Schleifen und Verzweigungen

Meiner Meinung nach ist es sinnvoll, das Thema „Schleifen innerhalb von Verzweigungen“ separat zu behandeln. So wird später der Unterschied zwischen mehrfacher und einmaliger Bedingungsprüfung deutlich.
Die Übungsaufgaben beziehen sich auf die Ausgabe von Zahlen von A bis B, die vom Benutzer eingegeben werden:
— immer in aufsteigender Reihenfolge.
— je nach den Werten von A und B in aufsteigender oder absteigender Reihenfolge.

Das Thema „Verzweigungen innerhalb von Schleifen“ sollte erst behandelt werden, nachdem der Schüler die Techniken „Muster durch Variablen ersetzen“ und „wiederholte Aktionen durch Schleifen ersetzen“ beherrscht.
Der Hauptgrund für den Einsatz von Verzweigungen innerhalb von Schleifen sind Anomalien im Muster. In der Mitte wird es je nach Eingabedaten unterbrochen.
Wenn die Studenten in der Lage sind, Lösungen durch Kombination einfacher Techniken zu finden, reicht es, zu sagen, dass „Verzweigungen innerhalb von Schleifen geschrieben werden können“ und eine Aufgabe „zum Beispiel“ vollständig zur selbstständigen Lösung zu geben.
Beispielaufgabe:

Der Benutzer gibt die Zahl X ein. Geben Sie die Zahlen von 0 bis 9 in einer Spalte aus und setzen Sie das Zeichen ‚+‘ neben die Zahl, die gleich X ist.

Wenn 0 eingegeben wurde0+
1
2
3
4
5
6
7
8
9

Wenn 6 eingegeben wurde0
1
2
3
4
5
6+
7
8
9

Wenn 9 eingegeben wurde0
1
2
3
4
5
6
7
8
9+

Wenn 777 eingegeben wurde0
1
2
3
4
5
6
7
8
9

Wenn eine kurze Erklärung nicht ausreicht, um mit einer Schleife zu arbeiten, sollte das Ziel sein, eine universelle Lösung für dasselbe Problem ohne Schleife zu finden.
Es gibt zwei mögliche Varianten:
Gewünscht

string temp;
temp = Console.ReadLine();
int x;
x = int.Parse(temp);
if (x==0) {
    Console.WriteLine(0 + "+");
} else {
    Console.WriteLine(0);
}
if (x==1) {
    Console.WriteLine(1 + "+");
} else {
    Console.WriteLine(1);
}
if (x==2) {
    Console.WriteLine(2 + "+");
} else {
    Console.WriteLine(2);
}
if (x==3) {
    Console.WriteLine(3 + "+");
} else {
    Console.WriteLine(3);
}
if (x==4) {
    Console.WriteLine(4 + "+");
} else {
    Console.WriteLine(4);
}
if (x==5) {
    Console.WriteLine(5 + "+");
} else {
    Console.WriteLine(5);
}
if (x==6) {
    Console.WriteLine(6 + "+");
} else {
    Console.WriteLine(6);
}
if (x==7) {
    Console.WriteLine(7 + "+");
} else {
    Console.WriteLine(7);
}
if (x==8) {
    Console.WriteLine(8 + "+");
} else {
    Console.WriteLine(8);
}
if (x==9) {
    Console.WriteLine(9 + "+");
} else {
    Console.WriteLine(9);
}

Möglich

string temp;
temp = Console.ReadLine();
int x;
x = int.Parse(temp);
if (x==0) {
    Console.WriteLine("0+n1n2n3n4n5n6n7n8n9");
}
if (x==1) {
    Console.WriteLine("0n1+n2n3n4n5n6n7n8n9");
}
if (x==2) {
    Console.WriteLine("0n1n2+n3n4n5n6n7n8n9");
}
if (x==3) {
    Console.WriteLine("0n1n2n3+n4n5n6n7n8n9");
}
if (x==4) {
    Console.WriteLine("0n1n2n3n4+n5n6n7n8n9");
}
if (x==5) {
    Console.WriteLine("0n1n2n3n4n5+n6n7n8n9");
}
if (x==6) {
    Console.WriteLine("0n1n2n3n4n5n6+n7n8n9");
}
if (x==7) {
    Console.WriteLine("0n1n2n3n4n5n6n7+n8n9");
}
if (x==8) {
    Console.WriteLine("0n1n2n3n4n5n6n7n8+n9");
}
if (x==9) {
    Console.WriteLine("0n1n2n3n4n5n6n7n8n9+");
}

Eine ähnliche Aufgabe gebe ich im Voraus während des Themas über Verzweigungen.
Wenn der Student eine „mögliche“ Lösung gefunden hat, sollte erklärt werden, dass es für dasselbe Problem viele Lösungen geben kann. Diese unterscheiden sich jedoch in ihrer Stabilität gegenüber Änderungen der Anforderungen. Stellen Sie die Frage: „Wie viele Stellen im Code müssen geändert werden, wenn eine weitere Zahl hinzugefügt werden muss?“ In der „möglichen“ Variante müsste ein weiteres Verzweigung hinzugefügt und an 10 anderen Stellen die neue Zahl geschrieben werden. In der „gewünschten“ Variante reicht es aus, nur eine Verzweigung hinzuzufügen.
Formulieren Sie die Aufgabe, die „gewünschte“ Variante zu reproduzieren, dann das Muster im Code zu finden, die Variable zu ersetzen und eine Schleife zu schreiben.
Wenn Sie eine Idee haben, wie man diese Aufgabe ohne Schleife auf andere Weise lösen kann, schreiben Sie bitte in die Kommentare.

Schleifen innerhalb von Schleifen

In diesem Thema sollte man auf Folgendes achten:
— die Zähler für die innere und äußere Schleife sollten unterschiedliche Variablen sein.
— der Zähler für die innere Schleife muss mehrfach zurückgesetzt werden (d.h. im Körper der äußeren Schleife).
In den Aufgaben zur Textausgabe dürfen die Buchstaben nicht zuerst in mehreren Zeilen, dann die Buchstaben der nächsten Zeile geschrieben werden. Zuerst müssen alle Buchstaben der ersten Zeile ausgegeben werden, dann alle Buchstaben der zweiten Zeile und so weiter.

Am besten beginnt man die Erklärung des Themas zu Schleifen in Schleifen mit der Wichtigkeit der Rücksetzung des Zählers.
Beispielaufgabe:

Der Benutzer gibt zwei Zahlen ein: R und T. Zwei Zeilen mit dem Zeichen "#" sollen ausgegeben werden. In der ersten Zeile sollen R Zeichen sein. In der zweiten Zeile T Zeichen. Wenn irgendeine Zahl negativ ist, soll eine Fehlermeldung ausgegeben werden.

R=5, T=11#####
###########

R=20, T=3####################
###

R=-1, T=6Der Wert von R muss nicht negativ sein.

R=6, T=-2Der Wert von T muss nicht negativ sein.

Offensichtlich gibt es mindestens zwei Lösungsmöglichkeiten für diese Aufgabe.
Gewünscht

string temp;
int R;
int T;
temp = Console.ReadLine();
R = int.Parse(temp);
temp = Console.ReadLine();
T = int.Parse(temp);
int i = 0;
while (i < R)
{
    Console.Write("#");
    i = i + 1;
}
Console.WriteLine();
i = 0;
while (i < T)
{
    Console.Write("#");
    i = i + 1;
}

Möglichkeit Nr. 1

string temp;
int R;
int T;
temp = Console.ReadLine();
R = int.Parse(temp);
temp = Console.ReadLine();
T = int.Parse(temp);
int i = 0;
while (i < R)
{
    Console.Write("#");
    i = i + 1;
}
Console.WriteLine();
int j = 0;
j = 0;
while (j < T)
{
    Console.Write("#");
    j = j + 1;
}

Der Unterschied liegt darin, dass im "möglichen" Lösungsansatz zur Ausgabe der zweiten Zeile die zweite Variable verwendet wurde. Es sollte darauf bestanden werden, dass für beide Schleifen dieselbe Variable verwendet wird. Dieses Beschränkung kann damit begründet werden, dass eine Lösung mit einem Zähler für zwei Schleifen eine Illustration des Begriffs "Zähler-Reset" ist. Dieses Verständnis ist notwendig für die Lösung der nächsten Aufgaben. Als Kompromiss können beide Lösungen der Aufgabe beibehalten werden.

Ein typisches Problem bei der Verwendung einer Zähler-Variable für zwei Schleifen zeigt sich so:
R=5, T=11#####
######

Die Anzahl der Zeichen in der zweiten Zeile stimmt nicht mit dem Wert T überein. Wenn bei diesem Problem Hilfe benötigt wird, sollte man auf das Protokoll über typische Schleifenprobleme hinweisen. Das ist Symptom Nr. 3. Es wird diagnostiziert, wenn man den Wert des Zählers direkt vor der zweiten Schleife ausgibt. Es wird behoben, indem der Zähler zurückgesetzt wird. Aber das sollte man besser nicht sofort erwähnen. Der Student sollte versuchen, zumindest eine Hypothese zu formulieren.

Es gibt natürlich auch diese Lösungsmöglichkeit. Aber ich habe sie bei den Studenten noch nie gesehen. In der Phase des Lernens von Schleifen würde der Hinweis darauf ablenken. Man kann später darauf zurückkommen, wenn es um die Funktionen zur Arbeit mit Zeichenfolgen geht.
Möglichkeit Nr. 2

string temp;
int R;
int T;
temp = Console.ReadLine();
R = int.Parse(temp);
temp = Console.ReadLine();
T = int.Parse(temp);
Console.WriteLine(new String('#', R));
Console.WriteLine(new String('#', T));

Die nächste Pflichtaufgabe:

Geben Sie die Ziffern von 0 bis 9 aus. Jede Ziffer sollte in einer eigenen Zeile stehen. Die Anzahl der Ziffern in der Zeile (W) wird von der Tastatur eingegeben.

W=10
1
2
3
4
5
6
7
8
9

W=100000000000 1111111111 2222222222 3333333333 4444444444 5555555555 6666666666 7777777777 8888888888 9999999999

Wenn der Student die Technik mit der Variablenersetzung beherrscht, wird er ziemlich schnell vorankommen. Ein mögliches Problem könnte wieder im Zurücksetzen der Variablen liegen. Wenn er mit der Umwandlung nicht zurechtkommt, haben Sie sich geirrt und sollten einfachere Aufgaben lösen.

Vielen Dank für Ihre Aufmerksamkeit. Hinterlassen Sie ein Gefällt mir, abonnieren Sie den Kanal.

P.S. Wenn Sie Tippfehler oder Fehler im Text gefunden haben, lassen Sie es mich bitte wissen. Sie können dies tun, indem Sie einen Teil des Textes markieren und auf Mac „⌘ + Enter“ oder auf klassischen Tastaturen „Ctrl / Enter“ drücken, oder über persönliche Nachrichten. Wenn diese Optionen nicht verfügbar sind, schreiben Sie die Fehler bitte in die Kommentare. Vielen Dank!

Nur registrierte Benutzer können an der Umfrage teilnehmen. Bitte melden Sie sich an.Sind Sie an Contour interessiert?