🥇Wie man Schwierigkeiten überwindet und gleichzeitig Schleifen schreibt

Auch wenn es sich um eines der grundlegendsten Themen handelt, ist dieser Artikel für erfahrene Fachleute geschrieben. Ziel ist es, aufzuzeigen, welche Missverständnisse häufig bei Anfängern im Programmieren auftreten. Für praktizierende Entwickler sind diese Probleme längst gelöst, vergessen oder werden gar nicht mehr wahrgenommen. Der Artikel kann nützlich sein, falls Sie plötzlich jemandem in diesem Thema helfen müssen. Es werden Parallelen zu Materialien aus verschiedenen Büchern über Programmierung der Autoren Schildt, Stroustrup, Okulov gezogen.

Das Thema über Schleifen wurde gewählt, weil sich dabei viele Menschen beim Erlernen der Programmierung schwer tun.

Diese Methode richtet sich an schwache Studenten. In der Regel bleiben stärkere an diesem Thema nicht hängen, und es ist keine speziellen Methoden für sie erforderlich. Ein sekundäres Ziel des Artikels ist es, diese Methode von der Klasse "funktioniert bei allen Studenten, aber nur bei einem Lehrer" in die Klasse "funktioniert für alle Studenten, alle Lehrer" zu übertragen. Ich beanspruche keine absolute Originalität. Falls 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 nach Abschluss, wie es 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 getestet, indem ich individuell mit Studenten unterschiedlicher Vorbildung gearbeitet habe. Insgesamt etwa fünfzig Studenten und zweitausend Stunden Unterricht. Anfangs blieben die Studenten bei diesem Thema oft hängen und brachen ab. Nach jedem Studenten wurden die Methode und die Materialien angepasst. Im letzten Jahr bleiben die Studenten bei diesem Thema nicht mehr hängen, sodass ich beschlossen habe, meine Erfahrungen zu teilen.

Warum so viele Buchstaben? Schleifen sind doch einfach!

Wie ich bereits oben erwähnt habe, kann die Schwierigkeit des Konzepts der Schleifen von praktizierenden Entwicklern und starken Studenten unterschätzt werden. Man könnte eine lange Vorlesung halten, nicken sehen und kluge Augen erleben. Doch beim Versuch, ein Problem zu lösen, kommt es zu einem Stillstand und unerklärlichen Schwierigkeiten. Nach der Vorlesung haben die Studenten sicher nur ein teilweises Verständnis gewonnen. Die Situation wird dadurch verschärft, dass die Studenten nicht in der Lage sind zu äußern, wo genau ihr Missverständnis liegt.
Eines Tages wurde mir klar, dass die Studierenden meine Beispiele wie Hieroglyphen betrachten. Das heißt, als unteilbare Textstücke, in denen man irgendeinen 'magischen' Buchstaben hinzufügen muss, und es wird funktionieren.
Manchmal bemerkte ich, dass die Studierenden denken, dass für die Lösung einer bestimmten Aufgabe irgendeine andere Konstruktion erforderlich sei, die ich einfach noch nicht erklärt habe. Dabei benötigte man lediglich eine kleine Modifikation des Beispiels.

Deshalb kam ich auf die Idee, dass der Schwerpunkt nicht auf der Syntax der Ausdrücke liegen sollte, sondern auf der Idee des Refactorings wiederkehrenden Codes mit Hilfe von Schleifen. Sobald die Schüler diese Idee verstanden haben, wird jede Syntax durch kleine Übungen erlernt.

Wem und warum ich unterrichte

Da es keine Aufnahmeprüfungen gibt, können im Unterricht sowohl starke als auch sehr schwache Studierende sein. Mehr über meine Studierenden kann man in dem Artikel lesen Porträt der Zuhörer der Abendkurse
Ich strebte danach, dass jeder, der es möchte, Programmieren lernen kann.
Meine Kurse finden individuell statt, und der Student bezahlt sein Geld für jede Einheit. Man könnte denken, dass die Studierenden versuchen werden, die Kosten zu optimieren und das Minimum zu fordern. Doch die Menschen besuchen Präsenzkurse bei einem Live-Lehrer nicht nur wegen des Wissens, sondern auch wegen des Gefühls der Gewissheit, dass sie das Material verstanden haben, wegen des Gefühls des Fortschritts und der Bestätigung durch einen Experten (Lehrer). Wenn die Studierenden keinen Fortschritt in ihrem Lernen fühlen, werden sie aufhören zu kommen. Im Allgemeinen kann man den Unterricht so gestalten, dass die Studierenden ihren Fortschritt im Erlernen bekannter Konstruktionen spüren. Wir lernen zuerst ausführlich die while-Schleife, dann die for-Schleife, dann die do-while-Schleife, und plötzlich haben wir einen Kurs für Tausendundeine Nacht, in dem zwei Monate lang nur Schleifen behandelt werden, und am Ende haben wir einen Studenten, der aus dem Gedächtnis die Standardbibliothek niedergeschrieben hat. Um jedoch praktische Probleme zu lösen, benötigt man nicht nur Wissen über das Material, sondern auch die Eigenständigkeit in der Anwendung und der Suche nach neuen Informationen. Daher halte ich für Präsenzkurse den Grundsatz für richtig, mindestens zu lehren und eigenständiges Lernen von Feinheiten und verwandten Themen zu fördern. Im Kontext der Schleifen betrachte ich die while-Konstruktion als das Minimum. Auf ihr kann man das Prinzip verstehen. Wenn man das Prinzip kennt, kann man auch selbstständig die for- und do-while-Schleifen erlernen.

Um das Material schwacher Studenten zu vermitteln, reicht es nicht aus, die Syntax zu beschreiben. Man muss vielfältige, einfache Aufgaben stellen und die Beispiele näher erläutern. Letztendlich wird die Geschwindigkeit des Lernens durch die Fähigkeit des Studenten, Ausdrücke umzuformen und Muster zu erkennen, begrenzt. Für schnelle Studenten werden die meisten Aufgaben langweilig sein. Bei der Arbeit mit ihnen kann man darauf verzichten, darauf zu bestehen, dass 100 % der Aufgaben gelöst werden. Mein Material ist auf meinem GitHubeinsehbar. Zwar sieht das Repository mehr wie ein grimoire eines Schwarzmagiers aus — niemand außer mir wird verstehen, wo was zu finden ist, und wenn man die Prüfung nicht besteht, kann man verrückt werden.

Die Methode ist praxisorientiert.

Die Theorie wird anhand der Lösung einer Aufgabe erklärt. In den Unterrichtseinheiten zu den Grundlagen der Programmierung, in denen Verzweigungen und Schleifen behandelt werden, lässt sich einfach keine nützliche Vorlesung zu einem Thema für eine ganze Stunde halten. 15-20 Minuten reichen aus, um das Konzept zu erklären. Die größten Schwierigkeiten treten bei der Bearbeitung praktischer Aufgaben auf.
Anfängerlehrer können Operatoren, Verzweigungen, Schleifen und Arrays in einer einzigen Vorlesung behandeln. Doch die Studenten werden dabei Schwierigkeiten haben, diese Informationen zu verarbeiten.
Es reicht schließlich nicht aus, das Material nur zu präsentieren, man muss auch sicherstellen, dass die Zuhörer es verstanden haben.

Der Grad des Verständnisses des Themas zeigt sich daran, wie der Student selbstständig an Aufgaben arbeitet.
Wenn es dem Studenten gelingt, eine Aufgabe zum Thema ohne Hilfe des Lehrers zu lösen, wurde das Thema verstanden. Um eine selbstständige Überprüfung zu ermöglichen, wird für jede Aufgabe eine Tabelle mit Test-Szenarien beschrieben. Die Aufgaben haben eine klar erkennbare Reihenfolge. Es wird nicht empfohlen, Aufgaben auszulassen. Wenn die aktuelle Aufgabe zu schwierig ist, macht es keinen Sinn, zur nächsten zu wechseln. Diese ist noch schwieriger. Damit der Student die aktuelle schwierige Aufgabe bewältigen kann, werden ihm mehrere Methoden anhand der ersten Aufgabe erklärt. Tatsächlich reduziert sich der gesamte Inhalt des Themas auf Methoden zur Überwindung von Schwierigkeiten. Schleifen sind dabei eher ein Nebeneffekt.

Die erste Aufgabe ist immer ein Beispiel. Die zweite unterscheidet sich nur geringfügig und wird „selbstständig“ sofort nach der ersten unter Aufsicht des Lehrers durchgeführt. Alle nachfolgenden Aufgaben haben das Ziel, auf verschiedene Kleinigkeiten hinzuweisen, die zu Missverständnissen führen können.

Die Erklärung des Beispiels stellt einen Dialog dar, in dem der Student die Rückpropagation und Kreuzvalidierung aufrufen muss, um sicherzustellen, dass er den Materialteil verstanden hat.

Ich werde banal sein und sagen, dass das erste Beispiel zu dem Thema sehr wichtig ist. Bei Vorhandensein von Material für umfangreiche selbständige Arbeiten können Versäumnisse des ersten Beispiels behoben werden. Wenn es außer dem Beispiel nichts gibt, wird der Student das Thema wahrscheinlich nicht meistern.

While oder for?

Eine der umstrittenen Fragen ist die Wahl der Konstruktion für das Beispiel: while oder for. Eines Tages hat ein bekannter praktizierender Entwickler ohne Lehrerfahrung mich eine Stunde lang davon überzeugt, dass die for-Schleife die einfachste zu verstehende ist. Die Argumente beschränkten sich auf "darin ist alles klar und gut strukturiert". Das eigentliche Problem für echte Anfänger liegt jedoch in der Idee der Schleife, nicht in ihrer Schreibweise. Wenn ein Mensch diese Idee nicht versteht, wird er Schwierigkeiten mit der Syntax haben. Sobald die Idee begriffen ist, verschwinden die Probleme mit der Codegestaltung von selbst.

In meinen Materialien folgt das Thema Schleifen dem Thema Verzweigungen. Die äußere Ähnlichkeit von if und while erlaubt es, eine direkte Analogie zu ziehen: "Wenn die Bedingung im Header wahr ist, wird der Körper ausgeführt". Das Besondere an der Schleife ist nur, dass der Körper mehrmals ausgeführt wird.

Mein zweites Argument ist, dass while weniger Gestaltung erfordert als for. Weniger Gestaltung bedeutet weniger dumme Fehler mit fehlenden Kommas und Klammern. Bei Anfängern ist die Aufmerksamkeit und Detailgenauigkeit noch nicht so ausgeprägt, dass sie automatisch syntaktische Fehler vermeiden.
Das dritte Argument ist, dass in vielen guten Büchern while zuerst erklärt wird.

Wenn es dem Studenten leicht fällt, Ausdrücke zu transformieren, kann man nebenbei von for erzählen. Der Student wird selbst wählen, was ihm besser gefällt. Wenn die Transformationen jedoch Schwierigkeiten bereiten, ist es besser, die Aufmerksamkeit nicht zu zerstreuen. Lassen Sie den Studenten zuerst alles mit while lösen. Wenn das Thema Schleifen gemeistert ist, kann man die Lösungen umschreiben, um die Transformation von while nach for zu üben.
Schleifen mit Post-Bedingungen sind ziemlich seltene Fälle. Ich verschwende dafür überhaupt keine Zeit. Wenn der Student die Ideen zur Erkennung von Mustern und zur Transformation von Ausdrücken gemeistert hat, kann er sich ohne meine Hilfe zurechtfinden.

Bei der Demonstration des ersten Beispiels an starken Studierenden weise ich darauf hin, dass es wichtig ist, im ersten Beispiel nicht nur die Lösung, sondern auch die gesamte Kette von Schritten festzuhalten, die zum Ergebnis geführt haben. Faulen Studierenden könnte es verleitet sein, das Schreiben zu vernachlässigen und nur den endgültigen Algorithmus zu übernehmen. Sie müssen davon überzeugt werden, dass auch für sie eines Tages eine komplexe Aufgabe kommen wird. Um diese zu lösen, wird es notwendig sein, Schritt für Schritt wie in diesem Beispiel vorzugehen. Deshalb ist es wichtig, alle Phasen festzuhalten. In den nächsten Aufgaben kann nur die finale Lösung belassen werden.

Die Grundidee der Automatisierung ist, dass wir dem Computer die Routinearbeit des Menschen übertragen. Eine der grundlegenden Techniken ist das Schreiben von Schleifen. Dies wird angewendet, wenn in einem Programm mehrere identische wiederkehrende Aktionen nacheinander ausgeführt werden.

Explizit ist besser als implizit

Es mag eine gute Idee erscheinen, in der ersten Aufgabe zu Schleifen einen identischen Satz mehrere Male 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 Variante ist schlecht, da im Output der Wert des Zählers nicht sichtbar ist. Das ist ein Problem für Anfänger. Man sollte es nicht unterschätzen. Zunächst war diese Aufgabe die erste, und die Aufgabe zum Ausgeben einer Zahlenreihe in aufsteigender Reihenfolge die zweite. Es mussten zusätzliche Begriffe wie "Schleife N Mal" und "Schleife von A bis B" eingeführt werden, die im Grunde das Gleiche sind. Um überflüssige Entitäten zu vermeiden, habe ich mich entschieden, nur das Beispiel mit der Ausgabe einer Zahlenreihe zu zeigen. Nur wenigen gelingt es ohne Vorbereitung, den Zähler im Kopf zu behalten und das Programmverhalten mental zu simulieren. Einige Studierende begegnen dem „mentalen“ Modellieren zum ersten Mal beim Thema Schleifen.
Nach etwas Übung gebe ich die Aufgabe, den identischen Text zu wiederholen, zur eigenständigen Lösung. Wenn man zuerst einen sichtbaren Zähler und dann einen unsichtbaren gibt, haben die Studierenden weniger Probleme. Manchmal reicht der Hinweis: „Schreibe den Zähler nicht auf den Bildschirm“.

Wie wird es bei anderen erklärt?

In den meisten Online-Lernmaterialien wird die Syntax von Schleifen im Rahmen einer „Vorlesung“ vermittelt. Zum Beispiel auf developer.mozilla.org (aktuell) werden zusammen mit der while-Schleife noch mehrere andere Konstruktionen beschrieben. Dabei werden ausschließlich die Konstruktionen in Form von Vorlagen gegeben. Das Ergebnis ihrer Ausführung wird in Worten beschrieben, eine Illustration fehlt. Meiner Meinung nach vermindert eine solche Präsentation den Nutzen solcher Materialien auf null. Ein Schüler kann den Code abschreiben und selbst ausführen, aber dennoch wird ein Referenzpunkt benötigt. Wie kann man verstehen, dass das Beispiel korrekt abgeschrieben wurde, wenn man das Ergebnis mit nichts vergleichen kann?
Wenn nur eine Vorlage gegeben wird, ohne Beispiel, wird es für den Studenten noch schwieriger. Wie kann man verstehen, dass die Codefragmente in der Vorlage richtig angeordnet sind? Man kann versuchen, irgendwie, und dann ausführen. Aber wenn kein Referenzpunkt für den Ergebnisvergleich vorhanden ist, hilft die Ausführung auch nicht.

Im C++-Kurs auf Intuite ist die Syntax der Schleife auf der dritten Seite der Vorlesung 4 zum Thema „Operatoren“ vergraben. Bei der Erklärung der Syntax von Schleifen wird besonderer Wert auf den Begriff „Operator“ gelegt. Der Begriff wird in Form einer Ansammlung von Fakten präsentiert wie „Symbol; das ist ein Operator“, "{} ist ein zusammengesetzter Operator", „Der Schleifeninhalt muss ein Operator sein“. Mir gefällt dieser Ansatz nicht, da er wichtige Zusammenhänge hinter einem einzigen Begriff zu verstecken scheint. Die Analyse des Quellcodes eines Programms in solche Terme ist auf dieser Ebene für Compilerentwickler notwendig, um die Sprachspezifikation umzusetzen, aber ganz und gar nicht für Studenten im ersten Annäherung. Programmierneulinge haben selten die erforderliche Genauigkeit, um die Begriffe so aufmerksam zu behandeln. Nur wenige Menschen merken sich neue Wörter beim ersten Mal und verstehen sie. Praktisch niemand kann einen Begriff korrekt anwenden, den er gerade erst gelernt hat. Daher entstehen bei Studenten viele Fehler wie „ich habe while(a<7);{ geschrieben, und das Programm funktioniert nicht“.
Meiner Meinung nach sollte zu Beginn die Syntax der Konstruktion sofort mit den Klammern gegeben werden. Die Variante ohne Klammern sollte nur erklärt werden, wenn der Schüler eine spezifische Frage hat: „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 dem For-Template, gefolgt von Empfehlungen zur Anwendung, und direkt danach folgt der experimentelle Abschnitt des Unterrichts. Ich verstehe, dass das Buch für die kleine Gruppe sehr begabter Schüler geschrieben wurde, die selten zu meinen Kursen kommen.

In populären Büchern wird immer das Ergebnis von Codefragmenten gezeigt. Zum Beispiel bei Schildts "Java 8. Das umfassende Handbuch" aus dem Jahr 2015. Zuerst wird das Template gegeben, dann ein Beispielprogramm und unmittelbar danach – das Ergebnis der Ausführung.

Als Beispiel betrachten wir eine While-Schleife, in der ein Countdown von 10 ausgeführt wird und genau 10 Zeilen "Takte" ausgegeben werden:
Nach dem Start gibt dieses Programm zehn "Takte" wie folgt aus:
//Продемонстрировать применение оператора цикла while
class While {
    public static void main(String args []) {
        int n = 10;
        while (n > 0) {
            System.out.println("такт " + n);
            n--;
        }
    }
}
Der Ansatz mit der Beschreibung des Templates, des Programmbeispiels und des Ergebnisses dieser Programmarbeit 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.
Takt 10 Takt 9 Takt 8 Takt 7 Takt 6 Takt 5 Takt 4 Takt 3 Takt 2 Takt 1

In dem Buch von Stroustrup "Grundsätze und Praxis mit C++" aus dem Jahr 2016 geht der Autor noch weiter. Zuerst wird erklärt, welches Ergebnis erwartet wird, und erst danach wird der Text des Programms angezeigt. Außerdem wird als Beispiel nicht einfach ein zufälliges Programm genommen, sondern ein historischer Überblick gegeben. Das hilft, die Aufmerksamkeit auf das zu lenken: "Sieh mal, das ist nicht einfach nur irgendein nutzloser Text. Siehst du, da ist etwas Bedeutendes."

Als Beispiel für Iteration betrachten wir das erste Programm, das auf einer Maschine mit gespeicherter Programmierung (EDSAC) ausgeführt wurde. Es wurde von David Wheeler in der Computerlaborschule der Universität Cambridge (Cambridge University, England) am 6. Mai 1949 geschrieben. Dieses Programm berechnet und druckt eine einfache Liste von Quadraten aus.

Hier enthält jede Zeile eine Zahl, gefolgt von einem Tabulatorzeichen ('t') und dem Quadrat dieser Zahl. Die Version dieses Programms in C++ sieht so aus:
0 0 1 1 2 4 3 9 4 16 ... 98 9604 99 9801
Interessanterweise wird das Template-Syntax in diesem Buch nicht beschrieben. Stroustrup legt im Leitfaden für Dozenten (
//Вычисляем и распечатываем таблицу квадратов чисел 0-99
int main()
{
    int i = 0; // Начинаем с нуля
    while(i < 100){
        cout << i << 't' << square(i) << 'n';
        ++i;
    }
}

) besonderen Wert darauf, dass er den Intellekt seiner Studenten respektiert. Möglicherweise gilt die Fähigkeit, ein Template in mehreren Beispielen zu erkennen, als Ausdruck dieses Intellekts.ÜbersetzungWie ich selbst erkläre

Wie ich es selbst erkläre

Der Ansatz von Stroustrup: Zuerst die Beschreibung des Ergebnisses, dann die Lösung des Problems und anschließend die selbstständige Analyse durch den Studenten - scheint am durchdachtesten zu sein. Daher habe ich beschlossen, genau diesen Ansatz zu wählen, aber mit einem weniger historischen Beispiel - der Aufgabe zur Ausgabe des "Inhaltsverzeichnisses". Dies bildet einen erkennbaren Anker, um später zu sagen: "Erinnere dich an die Aufgabe über das Inhaltsverzeichnis" und damit die Studenten genau dieses Beispiel im Kopf haben. In meinem Beispiel habe ich versucht, auch zwei der häufigsten Missverständnisse anzusprechen. Weiter unten werde ich genauer darüber schreiben.

In dieser Aufgabe lernen wir Methoden zur Lösung komplexer Probleme kennen. Die erste Lösung sollte einfach und primitiv sein. Danach kann man überlegen, wie man diese Lösung verbessern kann.
Einführung Kapitel 1 Kapitel 2 Kapitel 3 Kapitel 4 Kapitel 5 Kapitel 6 Kapitel 7 Fazit

Nach meinen Beobachtungen führt der Ansatz „Vorlage-Beispiel-Ergebnis“ in verschiedenen Kombinationen dennoch dazu, dass die Studenten den Zyklus als hieroglyphisch wahrnehmen. Das zeigte sich darin, dass sie nicht verstanden, warum dort eine Bedingung geschrieben werden muss, wie man zwischen i++ und i— wählt und andere scheinbar offensichtliche Dinge. Um solche Missverständnisse zu vermeiden, sollte der Zugang zur Erklärung von Zyklen den Sinn der Wiederholung identischer Aktionen betonen und erst danach ihre Formulierung mittels der Konstruktion. Daher muss man das Syntax des Zyklus erst einführen, nachdem das Problem „direkt“ gelöst wurde. Eine primitive Lösung der Aufgabe über das Inhaltsverzeichnis sieht so aus:

Console.WriteLine("Einleitung");
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("Schlussfolgerung");

Wie kann man es verbessern?
Eintönige Aktionen durch einen Zyklus ersetzen.
Welche Aktionen wiederholen sich hier hintereinander ohne Änderungen?
In diesem Fragment gibt es keine. Die Befehle zur Ausgabe des Wortes „Kapitel“ mit der Nummer sind sich jedoch sehr ähnlich.
Der nächste Schritt ist daher, die Unterschiede zwischen den Fragmenten zu suchen. Nur in dieser Aufgabe ist alles offensichtlich, später werden nicht einzelne Befehle wiederholt, sondern Codeblöcke von 5 Zeilen und mehr. Man muss nicht nur in der Befehlsliste suchen, sondern auch in den Verzweigungs- oder Schleifen-Konstruktionen.
Im Beispiel liegt der Unterschied zwischen den Befehlen in der Zahl nach dem Wort „Kapitel“.
Sobald der Unterschied gefunden ist, muss man das Muster der Veränderung verstehen. Ist das abweichende Fragment eine Zahl? Nimmt sie konstant zu oder ab? Wie verändert sich der Wert der Zahl zwischen zwei benachbarten Befehlen?
In diesem Beispiel erhöht sich die Zahl nach dem Wort „Kapitel“ um 1. Der Unterschied wurde gefunden, das Muster erkannt. Jetzt kann der variierende Teil durch eine Variable ersetzt werden.
Eine solche Variable muss vor dem ersten der sich wiederholenden Teile deklariert werden. Diese Variable wird normalerweise I oder j oder etwas ausführlicher genannt. Ihr Anfangswert sollte dem ersten auf dem Bildschirm angezeigten Wert entsprechen. Im Beispiel ist der erste Wert 1.
Welchen Anfangswert müssen wir verwenden, um die Zahlenreihe „100, 101, 102, 103, 104, 105“ auszugeben?
In dieser Reihe ist die erste Zahl 100.
Nach jedem Ausgabe-Befehl muss der Wert dieser Variable um 1 erhöht werden. Diese Eins ist der Schritt der Änderung.
Wie groß ist der Schritt in der Zahlenreihe „100, 102, 104, 106“?
In dieser Reihe beträgt der Schritt 2.
Nach dem Ersetzen des verschiedenen Teils durch eine Variable sieht der Code so aus:

Console.WriteLine("Einleitung");
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 Methode „Muster in einer Variable ausdrücken“ entsteht im Code mehrere Gruppen identischer Aktionen, die nacheinander erfolgen. Jetzt können die wiederholenden Handlungen durch eine Schleife ersetzt werden.

Der Ablauf zur Lösung des Problems, bei dem Schleifen verwendet werden müssen, besteht aus folgenden Schritten:

Die Lösung „auf gut Glück“ mit vielen einzelnen Befehlen
Das Muster finden
Das Muster in einer Variable ausdrücken
In einer Schleife darstellen

Zudem werden neue Begriffe eingeführt, damit der Student nicht in die Situation gerät: „Ich verstehe alles, kann es aber nicht sagen“:
— Zähler — immer eine Variable, die benötigt wird, um die Anzahl der Schleifen-Schritte zu verfolgen. Normalerweise eine ganze Zahl, die mit einer Grenze verglichen wird.
— Schritt des Zählers — Beschreibung des Musters der Veränderung des Zählers.
— Grenze — Zahl oder Variable, mit der der Zähler verglichen wird, damit der Algorithmus endlich ist. Der Wert des Zählers ändert sich so, dass er sich der Grenze nähert.
— Schleifenbody — eine Reihe von Befehlen, die wiederholt werden. Wenn gesagt wird „Der Befehl ist innerhalb der Schleife geschrieben“, ist genau der Body gemeint.
— Schleifeniteration — einmalige Ausführung des Schleifenbodys.
— Die Schleifenbedingung — ein logischer Ausdruck, von dem abhängt, ob eine weitere Iteration durchgeführt wird. (Hier kann es Verwirrung mit Verzweigungskonstruktionen geben)
Man muss darauf vorbereitet sein, dass die Studenten zunächst die Begriffe nicht korrekt verwenden werden. Das betrifft sowohl die Starken als auch die Schwachen. Eine gemeinsame Sprache zu finden, ist eine Kunst für sich. Ich schreibe es kurz: Man muss die Aufgabe stellen „markiere den Codeabschnitt mit “ und selbst diese Begriffe im Gespräch korrekt verwenden.
Nach der Umwandlung mit einer Schleife ergibt sich der folgende Abschnitt:

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

Die häufigste Fehlannahme

Ein verbreiteter Irrtum bei Studenten ist, dass sie in einer Schleifenkonstruktion solche Aktionen einfügen, die nur einmal ausgeführt werden sollen. Zum Beispiel so:

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

Schüler stoßen ständig auf dieses Problem, sowohl am Anfang als auch bei komplexeren Aufgaben.
Der goldene Hinweis in diesem Fall:

Wie oft muss man den Befehl schreiben: einmal oder mehrfach?

Die Ausgaben "Einführung" und "Schlussfolgerung" sowie die Deklaration und Initialisierung der Variable i sind nicht wie andere wiederholte Aktionen. Sie werden nur einmal ausgeführt, das heißt, sie sollten außerhalb des Schleifenkörpers geschrieben werden.

Im Code müssen alle drei Phasen der Lösung verbleiben, um später Bezug auf sie nehmen zu können, falls Schwierigkeiten auftreten. Die ersten zwei Varianten sollten ausreichend kommentiert werden, damit sie nicht stören.
Die Aufmerksamkeit der Studenten sollte auf folgende Fakten gelenkt werden:
— In der Schleifenbedingung wird normalerweise der Zähler mit der Grenze verglichen. Der Zähler kann sich im Schleifenkörper ändern, die Grenze nicht. Um diese Regel zu brechen, müssen triftige Gründe formuliert werden.
— Die Befehle zum Ausgeben der Wörter "Einführung" und "Schlussfolgerung" befinden sich außerhalb des Schleifenkörpers. Wir müssen sie einmal ausführen. "Einführung" — vor der Wiederholung der Aktionen, "Schlussfolgerung" — danach.
Im Verlauf der Festigung dieses Themas, des Erlernens der Folgenden sowie der Klärung von Schwierigkeiten ist es sogar für starke Studenten hilfreich, die Frage zu stellen: „Und wie oft muss diese Aktion durchgeführt werden? Einmal oder mehrmals?“.

Entwicklung zusätzlicher Fähigkeiten

Im Verlauf des Studiums von Schleifen entwickeln die Studierenden auch ihre Fähigkeiten zur Diagnose und Problemlösung. Um eine Diagnose zu stellen, muss der Student das gewünschte Ergebnis darstellen und es mit dem tatsächlichen Ergebnis vergleichen. Die Maßnahmen zur Korrektur hängen von den Differenzen zwischen diesen Ergebnissen ab.
Da die Studierenden in dieser Phase noch kein klares Verständnis des „gewünschten“ Ergebnisses haben, können sie sich auf die Testdaten beziehen. In der Regel versteht in diesem Stadium niemand, was schiefgehen kann und wie man damit umgeht. Daher gebe ich eine Beschreibung typischer Probleme und einige Lösungsmöglichkeiten zur Notiz in das Heft. Die Auswahl der am besten geeigneten Lösung ist die Aufgabe des Studenten.
Die Aufzeichnung ist notwendig, um zu fragen: „Ist das erreicht worden, was erwartet wurde?“, „Welche dieser Situationen hat sich jetzt ergeben?“, „Hat die angewandte Lösung geholfen?“.

Die Anzahl der Aktionen ist um 1 weniger oder mehr als erwartet. Lösungsmöglichkeiten:
— Erhöhen Sie den Anfangswert des Zählers um 1.
— Ersetzen Sie den strengen Vergleichsoperator (< oder >) durch einen nicht-strengen (<= oder >=).
— Ändern Sie den Wert der Grenze um 1.
Die Aktionen in der Schleife werden ohne Unterbrechung unendlich ausgeführt. Lösungsmöglichkeiten:
— Fügen Sie einen Befehl zur Änderung des Zählers hinzu, falls dieser fehlt.
— Korrigieren Sie den Befehl zur Änderung des Zählers, damit sein Wert näher an die Grenze kommt.
— Entfernen Sie den Befehl zur Änderung der Grenze, falls dieser im Schleifenblock enthalten ist.
Die Anzahl der Aktionen in der Schleife ist um mehr als 1 weniger oder mehr als erwartet. Die Aktion in der Schleife wurde kein einziges Mal ausgeführt. Zunächst müssen die tatsächlichen Werte der Variablen direkt vor Beginn der Schleife ermittelt werden. Lösungsmöglichkeiten:
— Ändern Sie den Anfangswert der Grenze.
— Ändern Sie den Anfangswert des Zählers.

Normalerweise ist Problem 3 mit der Verwendung einer falschen Variablen oder einem unerledigten Zähler verbunden.

Nach dieser Erklärung kann der Student noch verschiedene Missverständnisse hinsichtlich der Funktionsweise von Schleifen haben.
Um die häufigsten Missverständnisse auszuräumen, gebe ich Aufgaben:

In denen die Grenze, der Anfangswert des Zählers oder der Schritt des Zählers vom Benutzer eingegeben wird.
In denen der Zählerwert in einem arithmetischen Ausdruck verwendet werden muss. Ideal wäre es, den Zähler in einem untergeordneten Ausdruck oder im Nenner zu verwenden, damit die Differenz nicht-linear ist.
In der die Zählervalue nicht während des Arbeitszyklus auf dem Bildschirm angezeigt wird. Zum Beispiel, um die gewünschte Anzahl identischer Textfragmente auszugeben oder eine Figur mit Schalentortengrafik zu zeichnen.
In der zuerst einige sich wiederholende Aktionen und dann andere ausgeführt werden müssen.
In der andere Aktionen vor und nach den sich wiederholenden ausgeführt werden müssen.

Für jede Aufgabe müssen Testdaten und das erwartete Ergebnis bereitgestellt werden.

Um zu verstehen, wie schnell man arbeiten kann, sollte man die Bedingungen dieser Aufgaben durchlesen lassen und fragen: „Worin unterscheiden sie sich vom Beispiel?“, „Was muss am Beispiel geändert werden, um sie zu lösen?“. Wenn der Student sinnvoll antwortet, kann er mindestens eine im Unterricht lösen und die restlichen zu Hause selbständig erledigen. Wenn die Lösung erfolgreich ist, kann man mit der Erklärung über die Bedingungen innerhalb der Schleifen beginnen.
Wenn es Schwierigkeiten bei der selbständigen Lösung gibt, müssen alle im Unterricht bearbeitet werden. Damit die Lösung der Aufgabe nicht wie das Zeichnen einer Eule aussieht, empfehle ich, die Aufgabe zunächst nicht universell zu lösen. Das heißt, so zu lösen, dass die Lösung den ersten Test besteht und keine Schleifen-Konstruktion verwendet wird. Erst dann sollten Transformationen angewendet werden, um eine universelle Lösung zu erreichen.

Schleifen und Verzweigungen

Meiner Meinung nach ist es sinnvoll, das Thema „Schleifen innerhalb von Verzweigungen“ separat zu behandeln. So sollte anschließend der Unterschied zwischen mehrfacher Bedingungsprüfung und einfacher Bedingungsprüfung deutlich werden.
Die Aufgaben zur Festigung werden das Ausgeben von Zahlen von A bis B betreffen, die vom Benutzer eingegeben werden:
– immer in aufsteigender Reihenfolge.
– je nach den Werten von A und B in aufsteigender oder absteigender Reihenfolge.

Zum Thema „Verzweigungen innerhalb von Schleifen“ sollte erst übergegangen werden, nachdem der Student die Techniken „Ersatz eines Musters durch eine Variable“ und „Ersatz sich wiederholender Aktionen durch eine Schleife“ beherrscht hat.
Der Hauptgrund für die Anwendung von Verzweigungen innerhalb von Schleifen sind Anomalien im Muster. In der Mitte wird es je nach Eingangsdaten gestört.
Den Studenten, die in der Lage sind, Lösungen durch Kombination einfacher Techniken zu suchen, reicht es zu sagen: „Verzweigungen können innerhalb von Schleifen geschrieben werden“ und die Aufgabe „zum Beispiel“ vollständig zur selbständigen Lösung zu geben.
Aufgabe zum Beispiel:

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

Wenn die 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 fehlt, um mit einer Schleife zu schreiben, dann sollte ein universelles Lösung dieser Aufgabe ohne Schleife angestrebt werden.
Es gibt zwei mögliche Optionen:
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 Lernens über Verzweigungen.
Wenn der Student eine "mögliche" Lösung erhalten hat, sollte erklärt werden, dass es für die gleiche Aufgabe viele Lösungen geben kann. Sie 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 muss eine weitere Verzweigung hinzugefügt und an 10 anderen Stellen die neue Zahl eingetragen werden. In der "gewünschten" Variante muss nur eine Verzweigung hinzugefügt werden.
Formulieren Sie die Aufgabe, die "gewünschte" Variante zu reproduzieren, finden Sie dann im Code ein Muster, führen Sie die Variablenumgebung durch und schreiben Sie eine Schleife.
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 beachtet werden, dass:
— die Zähler für die innere und äußere Schleife unterschiedliche Variablen sein sollten.
— der Zähler für die innere Schleife muss mehrere Male zurückgesetzt werden (also im Körper der äußeren Schleife).
In den Aufgaben zur Textausgabe darf man nicht zuerst einen Buchstaben in mehreren Zeilen schreiben und dann den zweiten. Zuerst müssen alle Buchstaben der ersten Zeile ausgegeben werden, dann alle Buchstaben der zweiten und so weiter.

Es ist am besten, das Thema zu Schleifen innerhalb von Schleifen mit der Erklärung der Wichtigkeit der Rücksetzung des Zählers zu beginnen.
Aufgabe zum Beispiel:

Der Benutzer gibt zwei Zahlen ein: R und T. Geben Sie zwei Zeilen mit den Zeichen "#" aus. In der ersten Zeile sollten es R Stücke von Zeichen sein. In der zweiten Zeile T Stücke. Wenn eine der Zahlen negativ ist, geben Sie eine Fehlermeldung aus.

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 hat dieses Problem auch mindestens zwei Lösungsmöglichkeiten.
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 besteht darin, dass in der "möglichen" Lösung für die Ausgabe der zweiten Zeile eine zweite Variable verwendet wurde. Man muss darauf bestehen, dass die gleiche Variable für beide Schleifen verwendet wird. Man kann dieses Limit damit begründen, dass die Lösung mit einem Zähler für zwei Schleifen eine Veranschaulichung des Begriffs "Rücksetzung des Zählers" sein wird. Das Verständnis dieses Begriffs ist wichtig für die Lösung der nächsten Aufgaben. Als Kompromiss kann man beide Lösungen der Aufgabe beibehalten.

Ein typisches Problem bei der Verwendung einer Zähler-Variable für zwei Schleifen äußert sich folgendermaßen:
R=5, T=11#####
######

Die Anzahl der Zeichen in der zweiten Zeile entspricht nicht dem Wert von T. Wenn Hilfe mit diesem Problem benötigt wird, sollte man "auf die Nase" in den Notizen über häufige Probleme mit Schleifen zeigen. Das ist Symptom Nr. 3. Es wird diagnostiziert, wenn man den Wert des Zählers direkt vor der zweiten Schleife ausgibt. Es wird durch Rücksetzung behoben. Aber das sollte man besser nicht sofort erzählen. 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. Bei der Einführung in Schleifen würde eine Erzählung darüber die Aufmerksamkeit zerstreuen. Man kann später darauf zurückkommen, bei der Behandlung von Funktionen zur Bearbeitung von Zeichenfolgen.
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 auf dem Bildschirm aus. Jede Ziffer sollte in einer eigenen Zeile stehen. Die Anzahl der Ziffern in einer Zeile (W) wird über die 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 des Variablenwechsels beherrscht, wird er ziemlich schnell zurechtkommen. Ein mögliches Problem wird wieder das Zurücksetzen der Variablen sein. Wenn er mit der Umwandlung Schwierigkeiten hat, bedeutet das, dass er sich gehetzt hat und einfachere Aufgaben lösen sollte.

Danke für Ihre Aufmerksamkeit. Geben Sie Likes, 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 einem 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 in die Kommentare. Vielen Dank!

Nur registrierte Benutzer können an der Umfrage teilnehmen. Bitte einloggen.