{"id":40208,"date":"2020-02-01T06:04:35","date_gmt":"2020-02-01T03:04:35","guid":{"rendered":"https:\/\/prohoster.info\/blog\/blog_prohoster\/kak-nauchit-preodolevat-trudnosti-a-zaodno-i-pisat-czikly"},"modified":"2020-02-01T06:04:35","modified_gmt":"2020-02-01T03:04:35","slug":"kak-nauchit-preodolevat-trudnosti-a-zaodno-i-pisat-czikly","status":"publish","type":"post","link":"https:\/\/prohoster.info\/de\/blog\/kak-nauchit-preodolevat-trudnosti-a-zaodno-i-pisat-czikly","title":{"rendered":"Wie man lernt, Schwierigkeiten zu \u00fcberwinden und zugleich Schleifen zu schreiben","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"

Auch wenn es sich um eines der grundlegendsten Themen handelt, ist dieser Artikel f\u00fcr erfahrene Fachleute geschrieben. Ziel ist es, aufzuzeigen, welche Missverst\u00e4ndnisse h\u00e4ufig bei Anf\u00e4ngern im Programmieren auftreten. F\u00fcr praktizierende Entwickler sind diese Probleme l\u00e4ngst gel\u00f6st, vergessen oder werden gar nicht mehr wahrgenommen. Der Artikel kann n\u00fctzlich sein, falls Sie pl\u00f6tzlich jemandem in diesem Thema helfen m\u00fcssen. Es werden Parallelen zu Materialien aus verschiedenen B\u00fcchern \u00fcber Programmierung der Autoren Schildt, Stroustrup, Okulov gezogen.<\/p>\n

Das Thema \u00fcber Schleifen wurde gew\u00e4hlt, weil sich dabei viele Menschen beim Erlernen der Programmierung schwer tun.<\/p>\n

Diese Methode richtet sich an schwache Studenten. In der Regel bleiben st\u00e4rkere an diesem Thema nicht h\u00e4ngen, und es ist keine speziellen Methoden f\u00fcr sie erforderlich. Ein sekund\u00e4res Ziel des Artikels ist es, diese Methode von der Klasse \"funktioniert bei allen Studenten, aber nur bei einem Lehrer\" in die Klasse \"funktioniert f\u00fcr alle Studenten, alle Lehrer\" zu \u00fcbertragen. Ich beanspruche keine absolute Originalit\u00e4t. Falls Sie bereits eine \u00e4hnliche 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 \u00e4hnliche Methode in einem Buch beschrieben ist, teilen Sie mir bitte den Titel mit.<\/p>\n

<\/a><\/noindex>
\nDiese Methode habe ich \u00fcber 4 Jahre getestet, indem ich individuell mit Studenten unterschiedlicher Vorbildung gearbeitet habe. Insgesamt etwa f\u00fcnfzig Studenten und zweitausend Stunden Unterricht. Anfangs blieben die Studenten bei diesem Thema oft h\u00e4ngen 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\u00e4ngen, sodass ich beschlossen habe, meine Erfahrungen zu teilen.<\/p>\n

Warum so viele Buchstaben? Schleifen sind doch einfach!<\/h4>\n

\nWie ich bereits oben erw\u00e4hnt habe, kann die Schwierigkeit des Konzepts der Schleifen von praktizierenden Entwicklern und starken Studenten untersch\u00e4tzt werden. Man k\u00f6nnte eine lange Vorlesung halten, nicken sehen und kluge Augen erleben. Doch beim Versuch, ein Problem zu l\u00f6sen, kommt es zu einem Stillstand und unerkl\u00e4rlichen Schwierigkeiten. Nach der Vorlesung haben die Studenten sicher nur ein teilweises Verst\u00e4ndnis gewonnen. Die Situation wird dadurch versch\u00e4rft, dass die Studenten nicht in der Lage sind zu \u00e4u\u00dfern, wo genau ihr Missverst\u00e4ndnis liegt.
\nEines Tages wurde mir klar, dass die Studierenden meine Beispiele wie Hieroglyphen betrachten. Das hei\u00dft, als unteilbare Textst\u00fccke, in denen man irgendeinen 'magischen' Buchstaben hinzuf\u00fcgen muss, und es wird funktionieren.
\nManchmal bemerkte ich, dass die Studierenden denken, dass f\u00fcr die L\u00f6sung einer bestimmten Aufgabe irgendeine andere<\/i> Konstruktion erforderlich sei, die ich einfach noch nicht erkl\u00e4rt habe. Dabei ben\u00f6tigte man lediglich eine kleine Modifikation des Beispiels.<\/p>\n

Deshalb kam ich auf die Idee, dass der Schwerpunkt nicht auf der Syntax der Ausdr\u00fccke liegen sollte, sondern auf der Idee des Refactorings wiederkehrenden Codes mit Hilfe von Schleifen. Sobald die Sch\u00fcler diese Idee verstanden haben, wird jede Syntax durch kleine \u00dcbungen erlernt.<\/p>\n

Wem und warum ich unterrichte<\/h4>\n

\nDa es keine Aufnahmepr\u00fcfungen gibt, k\u00f6nnen im Unterricht sowohl starke als auch sehr schwache Studierende sein. Mehr \u00fcber meine Studierenden kann man in dem Artikel lesen Portr\u00e4t der Zuh\u00f6rer der Abendkurse<\/a><\/noindex>
\nIch strebte danach, dass jeder, der es m\u00f6chte, Programmieren lernen kann.
\nMeine Kurse finden individuell statt, und der Student bezahlt sein Geld f\u00fcr jede Einheit. Man k\u00f6nnte denken, dass die Studierenden versuchen werden, die Kosten zu optimieren und das Minimum zu fordern. Doch die Menschen besuchen Pr\u00e4senzkurse bei einem Live-Lehrer nicht nur wegen des Wissens, sondern auch wegen des Gef\u00fchls der Gewissheit, dass sie das Material verstanden haben, wegen des Gef\u00fchls des Fortschritts und der Best\u00e4tigung durch einen Experten (Lehrer). Wenn die Studierenden keinen Fortschritt in ihrem Lernen f\u00fchlen, werden sie aufh\u00f6ren zu kommen. Im Allgemeinen kann man den Unterricht so gestalten, dass die Studierenden ihren Fortschritt im Erlernen bekannter Konstruktionen sp\u00fcren. Wir lernen zuerst ausf\u00fchrlich die while-Schleife, dann die for-Schleife, dann die do-while-Schleife, und pl\u00f6tzlich haben wir einen Kurs f\u00fcr Tausendundeine Nacht, in dem zwei Monate lang nur Schleifen behandelt werden, und am Ende haben wir einen Studenten, der aus dem Ged\u00e4chtnis die Standardbibliothek niedergeschrieben hat. Um jedoch praktische Probleme zu l\u00f6sen, ben\u00f6tigt man nicht nur Wissen \u00fcber das Material, sondern auch die Eigenst\u00e4ndigkeit in der Anwendung und der Suche nach neuen Informationen. Daher halte ich f\u00fcr Pr\u00e4senzkurse den Grundsatz f\u00fcr richtig, mindestens zu lehren und eigenst\u00e4ndiges Lernen von Feinheiten und verwandten Themen zu f\u00f6rdern. 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\u00e4ndig die for- und do-while-Schleifen erlernen.<\/p>\n

Um das Material schwacher Studenten zu vermitteln, reicht es nicht aus, die Syntax zu beschreiben. Man muss vielf\u00e4ltige, einfache Aufgaben stellen und die Beispiele n\u00e4her erl\u00e4utern. Letztendlich wird die Geschwindigkeit des Lernens durch die F\u00e4higkeit des Studenten, Ausdr\u00fccke umzuformen und Muster zu erkennen, begrenzt. F\u00fcr 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\u00f6st werden. Mein Material ist auf meinem GitHub<\/a><\/noindex>einsehbar. Zwar sieht das Repository mehr wie ein grimoire eines Schwarzmagiers aus \u2014 niemand au\u00dfer mir wird verstehen, wo was zu finden ist, und wenn man die Pr\u00fcfung nicht besteht, kann man verr\u00fcckt werden.<\/p>\n

Die Methode ist praxisorientiert.<\/h4>\n

\nDie Theorie wird anhand der L\u00f6sung einer Aufgabe erkl\u00e4rt. In den Unterrichtseinheiten zu den Grundlagen der Programmierung, in denen Verzweigungen und Schleifen behandelt werden, l\u00e4sst sich einfach keine n\u00fctzliche Vorlesung zu einem Thema f\u00fcr eine ganze Stunde halten. 15-20 Minuten reichen aus, um das Konzept zu erkl\u00e4ren. Die gr\u00f6\u00dften Schwierigkeiten treten bei der Bearbeitung praktischer Aufgaben auf.
\nAnf\u00e4ngerlehrer k\u00f6nnen Operatoren, Verzweigungen, Schleifen und Arrays in einer einzigen Vorlesung behandeln. Doch die Studenten werden dabei Schwierigkeiten haben, diese Informationen zu verarbeiten.
\nEs reicht schlie\u00dflich nicht aus, das Material nur zu pr\u00e4sentieren, man muss auch sicherstellen, dass die Zuh\u00f6rer es verstanden haben.<\/p>\n

Der Grad des Verst\u00e4ndnisses des Themas zeigt sich daran, wie der Student selbstst\u00e4ndig an Aufgaben arbeitet.
\nWenn es dem Studenten gelingt, eine Aufgabe zum Thema ohne Hilfe des Lehrers zu l\u00f6sen, wurde das Thema verstanden. Um eine selbstst\u00e4ndige \u00dcberpr\u00fcfung zu erm\u00f6glichen, wird f\u00fcr 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\u00e4chsten zu wechseln. Diese ist noch schwieriger. Damit der Student die aktuelle schwierige Aufgabe bew\u00e4ltigen kann, werden ihm mehrere Methoden anhand der ersten Aufgabe erkl\u00e4rt. Tats\u00e4chlich reduziert sich der gesamte Inhalt des Themas auf Methoden zur \u00dcberwindung von Schwierigkeiten. Schleifen sind dabei eher ein Nebeneffekt.<\/p>\n

Die erste Aufgabe ist immer ein Beispiel. Die zweite unterscheidet sich nur geringf\u00fcgig und wird \u201eselbstst\u00e4ndig\u201c sofort nach der ersten unter Aufsicht des Lehrers durchgef\u00fchrt. Alle nachfolgenden Aufgaben haben das Ziel, auf verschiedene Kleinigkeiten hinzuweisen, die zu Missverst\u00e4ndnissen f\u00fchren k\u00f6nnen.<\/p>\n

Die Erkl\u00e4rung des Beispiels stellt einen Dialog dar, in dem der Student die R\u00fcckpropagation und Kreuzvalidierung aufrufen muss, um sicherzustellen, dass er den Materialteil verstanden hat.<\/p>\n

Ich werde banal sein und sagen, dass das erste Beispiel zu dem Thema sehr wichtig ist. Bei Vorhandensein von Material f\u00fcr umfangreiche selbst\u00e4ndige Arbeiten k\u00f6nnen Vers\u00e4umnisse des ersten Beispiels behoben werden. Wenn es au\u00dfer dem Beispiel nichts gibt, wird der Student das Thema wahrscheinlich nicht meistern.<\/p>\n

While oder for?<\/h4>\n

\nEine der umstrittenen Fragen ist die Wahl der Konstruktion f\u00fcr das Beispiel: while oder for. Eines Tages hat ein bekannter praktizierender Entwickler ohne Lehrerfahrung mich eine Stunde lang davon \u00fcberzeugt, dass die for-Schleife die einfachste zu verstehende ist. Die Argumente beschr\u00e4nkten sich auf \"darin ist alles klar und gut strukturiert\". Das eigentliche Problem f\u00fcr echte Anf\u00e4nger 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.<\/p>\n

In meinen Materialien folgt das Thema Schleifen dem Thema Verzweigungen. Die \u00e4u\u00dfere \u00c4hnlichkeit von if und while erlaubt es, eine direkte Analogie zu ziehen: \"Wenn die Bedingung im Header wahr ist, wird der K\u00f6rper ausgef\u00fchrt\". Das Besondere an der Schleife ist nur, dass der K\u00f6rper mehrmals ausgef\u00fchrt wird.<\/p>\n

Mein zweites Argument ist, dass while weniger Gestaltung erfordert als for. Weniger Gestaltung bedeutet weniger dumme Fehler mit fehlenden Kommas und Klammern. Bei Anf\u00e4ngern ist die Aufmerksamkeit und Detailgenauigkeit noch nicht so ausgepr\u00e4gt, dass sie automatisch syntaktische Fehler vermeiden.
\nDas dritte Argument ist, dass in vielen guten B\u00fcchern while zuerst erkl\u00e4rt wird.<\/p>\n

Wenn es dem Studenten leicht f\u00e4llt, Ausdr\u00fccke zu transformieren, kann man nebenbei von for erz\u00e4hlen. Der Student wird selbst w\u00e4hlen, was ihm besser gef\u00e4llt. Wenn die Transformationen jedoch Schwierigkeiten bereiten, ist es besser, die Aufmerksamkeit nicht zu zerstreuen. Lassen Sie den Studenten zuerst alles mit while l\u00f6sen. Wenn das Thema Schleifen gemeistert ist, kann man die L\u00f6sungen umschreiben, um die Transformation von while nach for zu \u00fcben.
\nSchleifen mit Post-Bedingungen sind ziemlich seltene F\u00e4lle. Ich verschwende daf\u00fcr \u00fcberhaupt keine Zeit. Wenn der Student die Ideen zur Erkennung von Mustern und zur Transformation von Ausdr\u00fccken gemeistert hat, kann er sich ohne meine Hilfe zurechtfinden.<\/p>\n

Bei der Demonstration des ersten Beispiels an starken Studierenden weise ich darauf hin, dass es wichtig ist, im ersten Beispiel nicht nur die L\u00f6sung, sondern auch die gesamte Kette von Schritten festzuhalten, die zum Ergebnis gef\u00fchrt haben. Faulen Studierenden k\u00f6nnte es verleitet sein, das Schreiben zu vernachl\u00e4ssigen und nur den endg\u00fcltigen Algorithmus zu \u00fcbernehmen. Sie m\u00fcssen davon \u00fcberzeugt werden, dass auch f\u00fcr sie eines Tages eine komplexe Aufgabe kommen wird. Um diese zu l\u00f6sen, wird es notwendig sein, Schritt f\u00fcr Schritt wie in diesem Beispiel vorzugehen. Deshalb ist es wichtig, alle Phasen festzuhalten. In den n\u00e4chsten Aufgaben kann nur die finale L\u00f6sung belassen werden.<\/p>\n

Die Grundidee der Automatisierung ist, dass wir dem Computer die Routinearbeit des Menschen \u00fcbertragen. Eine der grundlegenden Techniken ist das Schreiben von Schleifen. Dies wird angewendet, wenn in einem Programm mehrere identische wiederkehrende Aktionen nacheinander ausgef\u00fchrt werden.<\/p>\n

Explizit ist besser als implizit<\/h4>\n

\nEs mag eine gute Idee erscheinen, in der ersten Aufgabe zu Schleifen einen identischen Satz mehrere Male auszugeben. Zum Beispiel:<\/p>\n

Hurra, es funktioniert!
\nHurra, es funktioniert!
\nHurra, es funktioniert!
\nHurra, es funktioniert!
\nHurra, es funktioniert!
\nHurra, es funktioniert!
\nHurra, es funktioniert!
\nHurra, es funktioniert!\n<\/p><\/blockquote>\n

\nDiese Variante ist schlecht, da im Output der Wert des Z\u00e4hlers nicht sichtbar ist. Das ist ein Problem f\u00fcr Anf\u00e4nger. Man sollte es nicht untersch\u00e4tzen. Zun\u00e4chst war diese Aufgabe die erste, und die Aufgabe zum Ausgeben einer Zahlenreihe in aufsteigender Reihenfolge die zweite. Es mussten zus\u00e4tzliche Begriffe wie \"Schleife N Mal\" und \"Schleife von A bis B\" eingef\u00fchrt werden, die im Grunde das Gleiche sind. Um \u00fcberfl\u00fcssige Entit\u00e4ten zu vermeiden, habe ich mich entschieden, nur das Beispiel mit der Ausgabe einer Zahlenreihe zu zeigen. Nur wenigen gelingt es ohne Vorbereitung, den Z\u00e4hler im Kopf zu behalten und das Programmverhalten mental zu simulieren. Einige Studierende begegnen dem \u201ementalen\u201c Modellieren zum ersten Mal beim Thema Schleifen.
\nNach etwas \u00dcbung gebe ich die Aufgabe, den identischen Text zu wiederholen, zur eigenst\u00e4ndigen L\u00f6sung. Wenn man zuerst einen sichtbaren Z\u00e4hler und dann einen unsichtbaren gibt, haben die Studierenden weniger Probleme. Manchmal reicht der Hinweis: \u201eSchreibe den Z\u00e4hler nicht auf den Bildschirm\u201c.<\/p>\n

Wie wird es bei anderen erkl\u00e4rt?<\/h4>\n

\nIn den meisten Online-Lernmaterialien wird die Syntax von Schleifen im Rahmen einer \u201eVorlesung\u201c vermittelt. Zum Beispiel auf developer.mozilla.org (aktuell) werden zusammen mit der while-Schleife noch mehrere andere Konstruktionen beschrieben. Dabei werden ausschlie\u00dflich die Konstruktionen in Form von Vorlagen gegeben. Das Ergebnis ihrer Ausf\u00fchrung wird in Worten beschrieben, eine Illustration fehlt. Meiner Meinung nach vermindert eine solche Pr\u00e4sentation den Nutzen solcher Materialien auf null. Ein Sch\u00fcler kann den Code abschreiben und selbst ausf\u00fchren, aber dennoch wird ein Referenzpunkt ben\u00f6tigt. Wie kann man verstehen, dass das Beispiel korrekt abgeschrieben wurde, wenn man das Ergebnis mit nichts vergleichen kann?
\nWenn nur eine Vorlage gegeben wird, ohne Beispiel, wird es f\u00fcr den Studenten noch schwieriger. Wie kann man verstehen, dass die Codefragmente in der Vorlage richtig angeordnet sind? Man kann versuchen, irgendwie<\/i>, und dann ausf\u00fchren. Aber wenn kein Referenzpunkt f\u00fcr den Ergebnisvergleich vorhanden ist, hilft die Ausf\u00fchrung auch nicht.<\/p>\n

Im C++-Kurs wird die Syntax von Schleifen auf der dritten Seite der Vorlesung 4 zum Thema \u201eOperatoren\u201c behandelt. Bei der Erkl\u00e4rung der Syntax von Schleifen wird besonders auf den Begriff \u201eOperator\u201c hingewiesen. Dieser Begriff wird in Form von Fakten pr\u00e4sentiert, wie \u201eSymbol; das ist ein Operator\u201c, \u201e{} ist ein zusammengesetzter Operator\u201c und \u201eder K\u00f6rper der Schleife muss ein Operator sein\u201c. Mir gef\u00e4llt dieser Ansatz nicht, da er wichtige Zusammenh\u00e4nge hinter einem einzigen Begriff verbirgt. Die Analyse des Quellcodes auf dieser Ebene ist f\u00fcr Compilerentwickler erforderlich, um die Sprache zu implementieren, jedoch nicht f\u00fcr Studenten in der ersten Ann\u00e4herung. Anf\u00e4nger in der Programmierung haben selten die Sorgfalt, um Begriffe so genau zu betrachten. Nur selten merkt sich jemand neue W\u00f6rter beim ersten Mal und versteht sie. Praktisch niemand kann einen Begriff, den er gerade gelernt hat, korrekt anwenden. Daher entsteht bei den Studenten eine Vielzahl von Fehlern, wie zum Beispiel \u201eich habe while(a<7);{ geschrieben, aber das Programm funktioniert nicht.\u201c
\nMeiner Meinung nach sollte zu Beginn die Syntax der Konstruktion sofort mit den Klammern gegeben werden. Die Variante ohne Klammern sollte nur erkl\u00e4rt werden, wenn der Sch\u00fcler eine spezifische Frage hat: \u201eWarum funktioniert es hier ohne Klammern?\u201c<\/p>\n

In dem Buch von Okulov \"Grundlagen der Programmierung\" aus dem Jahr 2012 beginnt die Einf\u00fchrung 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\u00fcr die kleine Gruppe sehr begabter Sch\u00fcler geschrieben wurde, die selten zu meinen Kursen kommen.<\/p>\n

In popul\u00e4ren B\u00fcchern 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 \u2013 das Ergebnis der Ausf\u00fchrung.<\/p>\n

Als Beispiel betrachten wir eine While-Schleife, in der ein Countdown von 10 ausgef\u00fchrt wird und genau 10 Zeilen \"Takte\" ausgegeben werden:
\nNach dem Start gibt dieses Programm zehn \"Takte\" wie folgt aus: <\/p>\n

\/\/\u041f\u0440\u043e\u0434\u0435\u043c\u043e\u043d\u0441\u0442\u0440\u0438\u0440\u043e\u0432\u0430\u0442\u044c \u043f\u0440\u0438\u043c\u0435\u043d\u0435\u043d\u0438\u0435 \u043e\u043f\u0435\u0440\u0430\u0442\u043e\u0440\u0430 \u0446\u0438\u043a\u043b\u0430 while\nclass While {\n    public static void main(String args []) {\n        int n = 10;\n        while (n > 0) {\n            System.out.println("\u0442\u0430\u043a\u0442 " + n);\n            n--;\n        }\n    }\n}<\/code><\/pre>\n
\nDer Ansatz mit der Beschreibung des Templates, des Programmbeispiels und des Ergebnisses dieser Programmarbeit wird auch im Buch \"JavaScript f\u00fcr Kinder\" und im js-Kurs auf w3schools.com verwendet. Das Format der Webseite erm\u00f6glicht es sogar, dieses Beispiel interaktiv zu gestalten.
\nTakt 10
\nTakt 9
\nTakt 8
\nTakt 7
\nTakt 6
\nTakt 5
\nTakt 4
\nTakt 3
\nTakt 2
\nTakt 1<\/code><\/p><\/blockquote>\n
\nIn dem Buch von Stroustrup \"Grunds\u00e4tze und Praxis mit C++\" aus dem Jahr 2016 geht der Autor noch weiter. Zuerst wird erkl\u00e4rt, welches Ergebnis erwartet wird, und erst danach wird der Text des Programms angezeigt. Au\u00dferdem wird als Beispiel nicht einfach ein zuf\u00e4lliges Programm genommen, sondern ein historischer \u00dcberblick 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.\"<\/p>\n
Als Beispiel f\u00fcr Iteration betrachten wir das erste Programm, das auf einer Maschine mit gespeicherter Programmierung (EDSAC) ausgef\u00fchrt wurde. Es wurde von David Wheeler in der Computerlaborschule der Universit\u00e4t Cambridge (Cambridge University, England) am 6. Mai 1949 geschrieben. Dieses Programm berechnet und druckt eine einfache Liste von Quadraten aus.<\/p>\n
Hier enth\u00e4lt jede Zeile eine Zahl, gefolgt von einem Tabulatorzeichen ('t') und dem Quadrat dieser Zahl. Die Version dieses Programms in C++ sieht so aus:
\n0 0
\n1 1
\n2 4
\n3 9
\n4 16
\n...
\n98 9604
\n99 9801<\/code>
\nHier steht in jeder Zeile eine Zahl, gefolgt von einem Tabulatorzeichen (\u2018t\u2019) und dem Quadrat dieser Zahl. Die Version dieses Programms in C++ sieht so aus:<\/p>\n
\/\/\u0412\u044b\u0447\u0438\u0441\u043b\u044f\u0435\u043c \u0438 \u0440\u0430\u0441\u043f\u0435\u0447\u0430\u0442\u044b\u0432\u0430\u0435\u043c \u0442\u0430\u0431\u043b\u0438\u0446\u0443 \u043a\u0432\u0430\u0434\u0440\u0430\u0442\u043e\u0432 \u0447\u0438\u0441\u0435\u043b 0-99\nint main()\n{\n    int i = 0; \/\/ \u041d\u0430\u0447\u0438\u043d\u0430\u0435\u043c \u0441 \u043d\u0443\u043b\u044f\n    while(i < 100){\n        cout << i << 't' << square(i) << 'n';\n        ++i;\n    }\n}<\/code><\/pre>\n<\/blockquote>\n
\n) besonderen Wert darauf, dass er den Intellekt seiner Studenten respektiert. M\u00f6glicherweise gilt die F\u00e4higkeit, ein Template in mehreren Beispielen zu erkennen, als Ausdruck dieses Intellekts.\u00dcbersetzung<\/a><\/noindex>Wie ich selbst erkl\u00e4re<\/p>\n
Wie ich es selbst erkl\u00e4re<\/h4>\n
\nDer Ansatz von Stroustrup: Zuerst die Beschreibung des Ergebnisses, dann die L\u00f6sung des Problems und anschlie\u00dfend die selbstst\u00e4ndige Analyse durch den Studenten - scheint am durchdachtesten zu sein. Daher habe ich beschlossen, genau diesen Ansatz zu w\u00e4hlen, aber mit einem weniger historischen Beispiel - der Aufgabe zur Ausgabe des \"Inhaltsverzeichnisses\". Dies bildet einen erkennbaren Anker, um sp\u00e4ter zu sagen: \"Erinnere dich an die Aufgabe \u00fcber das Inhaltsverzeichnis\" und damit die Studenten genau dieses Beispiel im Kopf haben. In meinem Beispiel habe ich versucht, auch zwei der h\u00e4ufigsten Missverst\u00e4ndnisse anzusprechen. Weiter unten werde ich genauer dar\u00fcber schreiben.<\/p>\n
In dieser Aufgabe lernen wir Methoden zur L\u00f6sung komplexer Probleme kennen. Die erste L\u00f6sung sollte einfach und primitiv sein. Danach kann man \u00fcberlegen, wie man diese L\u00f6sung verbessern kann.
\nEinf\u00fchrung
\nKapitel 1
\nKapitel 2
\nKapitel 3
\nKapitel 4
\nKapitel 5
\nKapitel 6
\nKapitel 7
\nFazit<\/code><\/p><\/blockquote>\n
\nMeiner Beobachtung nach f\u00fchrt der Ansatz \u201eVorlage-Beispiel-Ergebnis\u201c in verschiedenen Kombinationen dazu, dass Studenten Schleifen als Hieroglyphen wahrnehmen. Dies \u00e4u\u00dferte sich darin, dass sie nicht verstanden, warum sie eine Bedingung schreiben sollten, wie sie zwischen i++ und i\u2013 w\u00e4hlen sollten und andere scheinbar offensichtliche Dinge. Um solchen Missverst\u00e4ndnissen vorzubeugen, sollte der Zugang zur Erkl\u00e4rung von Schleifen den Sinn der Wiederholung gleicher Aktionen betonen und erst danach die formale Gestaltung durch Konstruktionen. Bevor also die Syntax von Schleifen vermittelt wird, sollte die Aufgabe \u201edirekt\u201c gel\u00f6st werden. Eine primitive L\u00f6sung der Inhaltsverzeichnisaufgabe sieht so aus:<\/p>\n
Console.WriteLine(\"Einleitung\");\nConsole.WriteLine(\"Kapitel 1\");\nConsole.WriteLine(\"Kapitel 2\");\nConsole.WriteLine(\"Kapitel 3\");\nConsole.WriteLine(\"Kapitel 4\");\nConsole.WriteLine(\"Kapitel 5\");\nConsole.WriteLine(\"Kapitel 6\");\nConsole.WriteLine(\"Kapitel 7\");\nConsole.WriteLine(\"Schlussfolgerung\");\n<\/code><\/pre>\n
\nWie kann man es verbessern?
\nEint\u00f6nige Aktionen durch einen Zyklus ersetzen.
\nWelche Aktionen wiederholen sich hier hintereinander ohne \u00c4nderungen?
\nIn diesem Fragment gibt es keine. Die Befehle zur Ausgabe des Wortes \u201eKapitel\u201c mit der Nummer sind sich jedoch sehr \u00e4hnlich.
\nDer n\u00e4chste Schritt ist daher, die Unterschiede zwischen den Fragmenten zu suchen. Nur in dieser Aufgabe ist alles offensichtlich, sp\u00e4ter werden nicht einzelne Befehle wiederholt, sondern Codebl\u00f6cke von 5 Zeilen und mehr. Man muss nicht nur in der Befehlsliste suchen, sondern auch in den Verzweigungs- oder Schleifen-Konstruktionen.
\nIm Beispiel liegt der Unterschied zwischen den Befehlen in der Zahl nach dem Wort \u201eKapitel\u201c.
\nSobald der Unterschied gefunden ist, muss man das Muster der Ver\u00e4nderung verstehen. Ist das abweichende Fragment eine Zahl? Nimmt sie konstant zu oder ab? Wie ver\u00e4ndert sich der Wert der Zahl zwischen zwei benachbarten Befehlen?
\nIn diesem Beispiel erh\u00f6ht sich die Zahl nach dem Wort \u201eKapitel\u201c um 1. Der Unterschied wurde gefunden, das Muster erkannt. Jetzt kann der variierende Teil durch eine Variable ersetzt werden.
\nEine solche Variable muss vor dem ersten der sich wiederholenden Teile deklariert werden. Diese Variable wird normalerweise I oder j oder etwas ausf\u00fchrlicher genannt. Ihr Anfangswert sollte dem ersten auf dem Bildschirm angezeigten Wert entsprechen. Im Beispiel ist der erste Wert 1. 
\nWelchen Anfangswert m\u00fcssen wir verwenden, um die Zahlenreihe \u201e100, 101, 102, 103, 104, 105\u201c auszugeben?
\nIn dieser Reihe ist die erste Zahl 100.
\nNach jedem Ausgabe-Befehl muss der Wert dieser Variable um 1 erh\u00f6ht werden. Diese Eins ist der Schritt der \u00c4nderung.
\nWie gro\u00df ist der Schritt in der Zahlenreihe \u201e100, 102, 104, 106\u201c?
\nIn dieser Reihe betr\u00e4gt der Schritt 2.
\nNach dem Ersetzen des verschiedenen Teils durch eine Variable sieht der Code so aus:<\/p>\n
Console.WriteLine(\"Einleitung\");\nint i;\ni = 0;\nConsole.WriteLine(\"Kapitel \" + i);\ni = i + 1;\nConsole.WriteLine(\"Kapitel \" + i);\ni = i + 1;\nConsole.WriteLine(\"Kapitel \" + i);\ni = i + 1;\nConsole.WriteLine(\"Kapitel \" + i);\ni = i + 1;\nConsole.WriteLine(\"Kapitel \" + i);\ni = i + 1;\nConsole.WriteLine(\"Kapitel \" + i);\ni = i + 1;\nConsole.WriteLine(\"Kapitel \" + i);\ni = i + 1;\nConsole.WriteLine(\"Schlussfolgerung\");\n<\/code><\/pre>\n
\nNach der Anwendung der Methode \u201eMuster in einer Variable ausdr\u00fccken\u201c entsteht im Code mehrere Gruppen identischer Aktionen, die nacheinander erfolgen. Jetzt k\u00f6nnen die wiederholenden Handlungen durch eine Schleife ersetzt werden.<\/p>\n
Der Ablauf zur L\u00f6sung des Problems, bei dem Schleifen verwendet werden m\u00fcssen, besteht aus folgenden Schritten:<\/p>\n
    \n
  1. Die L\u00f6sung \u201eauf gut Gl\u00fcck\u201c mit vielen einzelnen Befehlen<\/li>\n
  2. Das Muster finden<\/li>\n
  3. Das Muster in einer Variable ausdr\u00fccken<\/li>\n
  4. In einer Schleife darstellen<\/li>\n<\/ol>\n
    Zudem werden neue Begriffe eingef\u00fchrt, damit der Student nicht in die Situation ger\u00e4t: \u201eIch verstehe alles, kann es aber nicht sagen\u201c:
    \n \u2014 Z\u00e4hler \u2014 immer eine Variable, die ben\u00f6tigt wird, um die Anzahl der Schleifen-Schritte zu verfolgen. Normalerweise eine ganze Zahl, die mit einer Grenze verglichen wird.
    \n \u2014 Schritt des Z\u00e4hlers \u2014 Beschreibung des Musters der Ver\u00e4nderung des Z\u00e4hlers.
    \n \u2014 Grenze \u2014 Zahl oder Variable, mit der der Z\u00e4hler verglichen wird, damit der Algorithmus endlich ist. Der Wert des Z\u00e4hlers \u00e4ndert sich so, dass er sich der Grenze n\u00e4hert.
    \n \u2014 Schleifenbody \u2014 eine Reihe von Befehlen, die wiederholt werden. Wenn gesagt wird \u201eDer Befehl ist innerhalb der Schleife geschrieben\u201c, ist genau der Body gemeint.
    \n \u2014 Schleifeniteration \u2014 einmalige Ausf\u00fchrung des Schleifenbodys.
    \n \u2014 Die Schleifenbedingung \u2014 ein logischer Ausdruck, von dem abh\u00e4ngt, ob eine weitere Iteration durchgef\u00fchrt wird. (Hier kann es Verwirrung mit Verzweigungskonstruktionen geben)
    \nMan muss darauf vorbereitet sein, dass die Studenten zun\u00e4chst die Begriffe nicht korrekt verwenden werden. Das betrifft sowohl die Starken als auch die Schwachen. Eine gemeinsame Sprache zu finden, ist eine Kunst f\u00fcr sich. Ich schreibe es kurz: Man muss die Aufgabe stellen \u201emarkiere den Codeabschnitt mit \u201c und selbst diese Begriffe im Gespr\u00e4ch korrekt verwenden.
    \nNach der Umwandlung mit einer Schleife ergibt sich der folgende Abschnitt:<\/p>\n
    Console.WriteLine(\"Einf\u00fchrung\");\nint i = 0;\nwhile (i < 7) {\n    Console.WriteLine("Kapitel " + i);\n    i = i + 1;\n}\nConsole.WriteLine("Schlussfolgerung");<\/code><\/pre>\n
    Die h\u00e4ufigste Fehlannahme<\/h4>\n
    \nEin verbreiteter Irrtum bei Studenten ist, dass sie in einer Schleifenkonstruktion solche Aktionen einf\u00fcgen, die nur einmal ausgef\u00fchrt werden sollen. Zum Beispiel so:<\/p>\n
    ;\nint i = 0;\nwhile (i < 7) {\n    Console.WriteLine("Einf\u00fchrung")\n    Console.WriteLine("Kapitel " + i);\n    i = i + 1;\n    Console.WriteLine("Schlussfolgerung");\n}\n<\/code><\/pre>\n
    \nSch\u00fcler sto\u00dfen st\u00e4ndig auf dieses Problem, sowohl am Anfang als auch bei komplexeren Aufgaben.
    \nDer goldene Hinweis in diesem Fall:<\/p>\n
    Wie oft muss man den Befehl schreiben: einmal oder mehrfach?\n<\/p><\/blockquote>\n
    \nDie Ausgaben \"Einf\u00fchrung\" und \"Schlussfolgerung\" sowie die Deklaration und Initialisierung der Variable i sind nicht wie andere wiederholte Aktionen. Sie werden nur einmal ausgef\u00fchrt, das hei\u00dft, sie sollten au\u00dferhalb des Schleifenk\u00f6rpers geschrieben werden.<\/p>\n
    Im Code m\u00fcssen alle drei Phasen der L\u00f6sung verbleiben, um sp\u00e4ter Bezug auf sie nehmen zu k\u00f6nnen, falls Schwierigkeiten auftreten. Die ersten zwei Varianten sollten ausreichend kommentiert werden, damit sie nicht st\u00f6ren.
    \nDie Aufmerksamkeit der Studenten sollte auf folgende Fakten gelenkt werden:
    \n \u2014 In der Schleifenbedingung wird normalerweise der Z\u00e4hler mit der Grenze verglichen. Der Z\u00e4hler kann sich im Schleifenk\u00f6rper \u00e4ndern, die Grenze nicht. Um diese Regel zu brechen, m\u00fcssen triftige Gr\u00fcnde formuliert werden.
    \n \u2014 Die Befehle zum Ausgeben der W\u00f6rter \"Einf\u00fchrung\" und \"Schlussfolgerung\" befinden sich au\u00dferhalb des Schleifenk\u00f6rpers. Wir m\u00fcssen sie einmal ausf\u00fchren. \"Einf\u00fchrung\" \u2014 vor der Wiederholung der Aktionen, \"Schlussfolgerung\" \u2014 danach.
    \nIm Verlauf der Festigung dieses Themas, des Erlernens der Folgenden sowie der Kl\u00e4rung von Schwierigkeiten ist es sogar f\u00fcr starke Studenten hilfreich, die Frage zu stellen: \u201eUnd wie oft muss diese Aktion durchgef\u00fchrt werden? Einmal oder mehrmals?\u201c.<\/p>\n
    Entwicklung zus\u00e4tzlicher F\u00e4higkeiten<\/h4>\n
    \nIm Verlauf des Studiums von Schleifen entwickeln die Studierenden auch ihre F\u00e4higkeiten zur Diagnose und Probleml\u00f6sung. Um eine Diagnose zu stellen, muss der Student das gew\u00fcnschte Ergebnis darstellen und es mit dem tats\u00e4chlichen Ergebnis vergleichen. Die Ma\u00dfnahmen zur Korrektur h\u00e4ngen von den Differenzen zwischen diesen Ergebnissen ab.
    \nDa die Studierenden in dieser Phase noch kein klares Verst\u00e4ndnis des \u201egew\u00fcnschten\u201c Ergebnisses haben, k\u00f6nnen 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\u00f6sungsm\u00f6glichkeiten zur Notiz in das Heft. Die Auswahl der am besten geeigneten L\u00f6sung ist die Aufgabe des Studenten.
    \nDie Aufzeichnung ist notwendig, um zu fragen: \u201eIst das erreicht worden, was erwartet wurde?\u201c, \u201eWelche dieser Situationen hat sich jetzt ergeben?\u201c, \u201eHat die angewandte L\u00f6sung geholfen?\u201c.<\/p>\n
      \n
    1. Die Anzahl der Aktionen ist um 1 weniger oder mehr als erwartet. L\u00f6sungsm\u00f6glichkeiten:
      \n \u2014 Erh\u00f6hen Sie den Anfangswert des Z\u00e4hlers um 1.
      \n \u2014 Ersetzen Sie den strengen Vergleichsoperator (< oder >) durch einen nicht-strengen (<= oder >=).
      \n \u2014 \u00c4ndern Sie den Wert der Grenze um 1.<\/li>\n
    2. Die Aktionen in der Schleife werden ohne Unterbrechung unendlich ausgef\u00fchrt. L\u00f6sungsm\u00f6glichkeiten:
      \n \u2014 F\u00fcgen Sie einen Befehl zur \u00c4nderung des Z\u00e4hlers hinzu, falls dieser fehlt.
      \n \u2014 Korrigieren Sie den Befehl zur \u00c4nderung des Z\u00e4hlers, damit sein Wert n\u00e4her an die Grenze kommt.
      \n \u2014 Entfernen Sie den Befehl zur \u00c4nderung der Grenze, falls dieser im Schleifenblock enthalten ist.<\/li>\n
    3. 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\u00fchrt. Zun\u00e4chst m\u00fcssen die tats\u00e4chlichen Werte der Variablen direkt vor Beginn der Schleife ermittelt werden. L\u00f6sungsm\u00f6glichkeiten:
      \n \u2014 \u00c4ndern Sie den Anfangswert der Grenze.
      \n \u2014 \u00c4ndern Sie den Anfangswert des Z\u00e4hlers.<\/li>\n<\/ol>\n
      \nNormalerweise ist Problem 3 mit der Verwendung einer falschen Variablen oder einem unerledigten Z\u00e4hler verbunden.<\/p>\n
      Nach dieser Erkl\u00e4rung kann der Student noch verschiedene Missverst\u00e4ndnisse hinsichtlich der Funktionsweise von Schleifen haben.
      \nUm die h\u00e4ufigsten Missverst\u00e4ndnisse auszur\u00e4umen, gebe ich Aufgaben:<\/p>\n
        \n
      1. In denen die Grenze, der Anfangswert des Z\u00e4hlers oder der Schritt des Z\u00e4hlers vom Benutzer eingegeben wird.<\/li>\n
      2. In denen der Z\u00e4hlerwert in einem arithmetischen Ausdruck verwendet werden muss. Ideal w\u00e4re es, den Z\u00e4hler in einem untergeordneten Ausdruck oder im Nenner zu verwenden, damit die Differenz nicht-linear ist.<\/li>\n
      3. In der die Z\u00e4hlervalue nicht w\u00e4hrend des Arbeitszyklus auf dem Bildschirm angezeigt wird. Zum Beispiel, um die gew\u00fcnschte Anzahl identischer Textfragmente auszugeben oder eine Figur mit Schalentortengrafik zu zeichnen.<\/li>\n
      4. In der zuerst einige sich wiederholende Aktionen und dann andere ausgef\u00fchrt werden m\u00fcssen.<\/li>\n
      5. In der andere Aktionen vor und nach den sich wiederholenden ausgef\u00fchrt werden m\u00fcssen.<\/li>\n<\/ol>\n
        \nF\u00fcr jede Aufgabe m\u00fcssen Testdaten und das erwartete Ergebnis bereitgestellt werden.<\/p>\n
        Um zu verstehen, wie schnell man arbeiten kann, sollte man die Bedingungen dieser Aufgaben durchlesen lassen und fragen: \u201eWorin unterscheiden sie sich vom Beispiel?\u201c, \u201eWas muss am Beispiel ge\u00e4ndert werden, um sie zu l\u00f6sen?\u201c. Wenn der Student sinnvoll antwortet, kann er mindestens eine im Unterricht l\u00f6sen und die restlichen zu Hause selbst\u00e4ndig erledigen. Wenn die L\u00f6sung erfolgreich ist, kann man mit der Erkl\u00e4rung \u00fcber die Bedingungen innerhalb der Schleifen beginnen.
        \nWenn es Schwierigkeiten bei der selbst\u00e4ndigen L\u00f6sung gibt, m\u00fcssen alle im Unterricht bearbeitet werden. Damit die L\u00f6sung der Aufgabe nicht wie das Zeichnen einer Eule aussieht, empfehle ich, die Aufgabe zun\u00e4chst nicht universell zu l\u00f6sen. Das hei\u00dft, so zu l\u00f6sen, dass die L\u00f6sung den ersten Test besteht und keine Schleifen-Konstruktion verwendet wird. Erst dann sollten Transformationen angewendet werden, um eine universelle L\u00f6sung zu erreichen.<\/p>\n
        Schleifen und Verzweigungen<\/h4>\n
        \nMeiner Meinung nach ist es sinnvoll, das Thema \u201eSchleifen innerhalb von Verzweigungen\u201c separat zu behandeln. So sollte anschlie\u00dfend der Unterschied zwischen mehrfacher Bedingungspr\u00fcfung und einfacher Bedingungspr\u00fcfung deutlich werden.
        \nDie Aufgaben zur Festigung werden das Ausgeben von Zahlen von A bis B betreffen, die vom Benutzer eingegeben werden:
        \n \u2013 immer in aufsteigender Reihenfolge.
        \n \u2013 je nach den Werten von A und B in aufsteigender oder absteigender Reihenfolge.<\/p>\n
        Der \u00dcbergang zum Thema \u201eVerzweigung innerhalb von Schleifen\u201c sollte erst erfolgen, nachdem der Student die Techniken \u201eErsetzen von Mustern durch Variablen\u201c und \u201eErsetzen wiederholter Aktionen durch Schleifen\u201c beherrscht hat.
        \nDer Hauptgrund f\u00fcr die Anwendung von Verzweigungen innerhalb von Schleifen sind Anomalien im Muster. In der Mitte wird es je nach Eingangsdaten gest\u00f6rt.
        \nDen Studenten, die in der Lage sind, L\u00f6sungen durch Kombination einfacher Techniken zu suchen, reicht es zu sagen: \u201eVerzweigungen k\u00f6nnen innerhalb von Schleifen geschrieben werden\u201c und die Aufgabe \u201ezum Beispiel\u201c vollst\u00e4ndig zur selbst\u00e4ndigen L\u00f6sung zu geben.
        \nAufgabe zum Beispiel:<\/p>\n
        Der Benutzer gibt die Zahl X ein. Geben Sie die Zahlen von 0 bis 9 in einer Spalte aus und setzen Sie das Zeichen \u2018+\u2019 neben die Zahl, die X entspricht.<\/p><\/blockquote>\n
        \nWenn die 0 eingegeben wurde<\/b>0+
        \n1
        \n2
        \n3
        \n4
        \n5
        \n6
        \n7
        \n8
        \n9<\/p>\n
        Wenn 6 eingegeben wurde<\/b>0
        \n1
        \n2
        \n3
        \n4
        \n5
        \n6+
        \n7
        \n8
        \n9<\/p>\n
        Wenn 9 eingegeben wurde<\/b>0
        \n1
        \n2
        \n3
        \n4
        \n5
        \n6
        \n7
        \n8
        \n9+<\/p>\n
        Wenn 777 eingegeben wurde<\/b>0
        \n1
        \n2
        \n3
        \n4
        \n5
        \n6
        \n7
        \n8
        \n9<\/p>\n
        Wenn eine kurze Erkl\u00e4rung fehlt, um mit einer Schleife zu schreiben, dann sollte ein universelles L\u00f6sung dieser Aufgabe ohne Schleife angestrebt werden.
        \nEs gibt zwei m\u00f6gliche Optionen:
        \nGew\u00fcnscht<\/b><\/p>\n
        string temp;\ntemp = Console.ReadLine();\nint x;\nx = int.Parse(temp);\nif (x==0) {\n    Console.WriteLine(0 + \"+\");\n} else {\n    Console.WriteLine(0);\n}\nif (x==1) {\n    Console.WriteLine(1 + \"+\");\n} else {\n    Console.WriteLine(1);\n}\nif (x==2) {\n    Console.WriteLine(2 + \"+\");\n} else {\n    Console.WriteLine(2);\n}\nif (x==3) {\n    Console.WriteLine(3 + \"+\");\n} else {\n    Console.WriteLine(3);\n}\nif (x==4) {\n    Console.WriteLine(4 + \"+\");\n} else {\n    Console.WriteLine(4);\n}\nif (x==5) {\n    Console.WriteLine(5 + \"+\");\n} else {\n    Console.WriteLine(5);\n}\nif (x==6) {\n    Console.WriteLine(6 + \"+\");\n} else {\n    Console.WriteLine(6);\n}\nif (x==7) {\n    Console.WriteLine(7 + \"+\");\n} else {\n    Console.WriteLine(7);\n}\nif (x==8) {\n    Console.WriteLine(8 + \"+\");\n} else {\n    Console.WriteLine(8);\n}\nif (x==9) {\n    Console.WriteLine(9 + \"+\");\n} else {\n    Console.WriteLine(9);\n}\n<\/code><\/pre>\n
        M\u00f6glich<\/b><\/p>\n
        string temp;\ntemp = Console.ReadLine();\nint x;\nx = int.Parse(temp);\nif (x==0) {\n    Console.WriteLine(\"0+n1n2n3n4n5n6n7n8n9\");\n}\nif (x==1) {\n    Console.WriteLine(\"0n1+n2n3n4n5n6n7n8n9\");\n}\nif (x==2) {\n    Console.WriteLine(\"0n1n2+n3n4n5n6n7n8n9\");\n}\nif (x==3) {\n    Console.WriteLine(\"0n1n2n3+n4n5n6n7n8n9\");\n}\nif (x==4) {\n    Console.WriteLine(\"0n1n2n3n4+n5n6n7n8n9\");\n}\nif (x==5) {\n    Console.WriteLine(\"0n1n2n3n4n5+n6n7n8n9\");\n}\nif (x==6) {\n    Console.WriteLine(\"0n1n2n3n4n5n6+n7n8n9\");\n}\nif (x==7) {\n    Console.WriteLine(\"0n1n2n3n4n5n6n7+n8n9\");\n}\nif (x==8) {\n    Console.WriteLine(\"0n1n2n3n4n5n6n7n8+n9\");\n}\nif (x==9) {\n    Console.WriteLine(\"0n1n2n3n4n5n6n7n8n9+\");\n}\n<\/code><\/pre>\n
        Eine \u00e4hnliche Aufgabe gebe ich im Voraus w\u00e4hrend des Lernens \u00fcber Verzweigungen.
        \nWenn der Student eine \"m\u00f6gliche\" L\u00f6sung erhalten hat, sollte erkl\u00e4rt werden, dass es f\u00fcr die gleiche Aufgabe viele L\u00f6sungen geben kann. Sie unterscheiden sich jedoch in ihrer Stabilit\u00e4t gegen\u00fcber \u00c4nderungen der Anforderungen. Stellen Sie die Frage: \"Wie viele Stellen im Code m\u00fcssen ge\u00e4ndert werden, wenn eine weitere Zahl hinzugef\u00fcgt werden muss?\" In der \"m\u00f6glichen\" Variante muss eine weitere Verzweigung hinzugef\u00fcgt und an 10 anderen Stellen die neue Zahl eingetragen werden. In der \"gew\u00fcnschten\" Variante muss nur eine Verzweigung hinzugef\u00fcgt werden.
        \nFormulieren Sie die Aufgabe, die \"gew\u00fcnschte\" Variante zu reproduzieren, finden Sie dann im Code ein Muster, f\u00fchren Sie die Variablenumgebung durch und schreiben Sie eine Schleife.
        \nWenn Sie eine Idee haben, wie man diese Aufgabe ohne Schleife auf andere Weise l\u00f6sen kann, schreiben Sie bitte in die Kommentare.<\/p>\n
        Schleifen innerhalb von Schleifen<\/h4>\n
        \nIn diesem Thema sollte beachtet werden, dass:
        \n \u2014 die Z\u00e4hler f\u00fcr die innere und \u00e4u\u00dfere Schleife unterschiedliche Variablen sein sollten.
        \n \u2014 der Z\u00e4hler f\u00fcr die innere Schleife muss mehrere Male zur\u00fcckgesetzt werden (also im K\u00f6rper der \u00e4u\u00dferen Schleife).
        \n In den Aufgaben zur Textausgabe darf man nicht zuerst einen Buchstaben in mehreren Zeilen schreiben und dann den zweiten. Zuerst m\u00fcssen alle Buchstaben der ersten Zeile ausgegeben werden, dann alle Buchstaben der zweiten und so weiter.<\/p>\n
        Es ist am besten, das Thema zu Schleifen innerhalb von Schleifen mit der Erkl\u00e4rung der Wichtigkeit der R\u00fccksetzung des Z\u00e4hlers zu beginnen.
        \nAufgabe zum Beispiel:<\/p>\n
        Der Benutzer gibt zwei Zahlen ein: R und T. Geben Sie zwei Zeilen von Symbolen \"#\" aus. In der ersten Zeile sollten R Zeichen sein und in der zweiten T Zeichen. Wenn eine der Zahlen negativ ist, geben Sie eine Fehlermeldung aus.<\/p><\/blockquote>\n
        \nR=5, T=11<\/b>#####
        \n###########<\/p>\n
        R=20, T=3<\/b>####################
        \n###<\/p>\n
        R=-1, T=6<\/b>Der Wert von R muss nicht negativ sein<\/p>\n
        R=6, T=-2<\/b>Der Wert von T muss nicht negativ sein<\/p>\n
        Offensichtlich hat dieses Problem auch mindestens zwei L\u00f6sungsm\u00f6glichkeiten.
        \nGew\u00fcnscht<\/b><\/p>\n
        string temp;\nint R;\nint T;\ntemp = Console.ReadLine();\nR = int.Parse(temp);\ntemp = Console.ReadLine();\nT = int.Parse(temp);\nint i = 0;\nwhile (i < R)\n{\n    Console.Write("#");\n    i = i + 1;\n}\nConsole.WriteLine();\ni = 0;\nwhile (i < T)\n{\n    Console.Write("#");\n    i = i + 1;\n}\n<\/code><\/pre>\n
        M\u00f6glichkeit Nr. 1<\/b><\/p>\n
        string temp;\nint R;\nint T;\ntemp = Console.ReadLine();\nR = int.Parse(temp);\ntemp = Console.ReadLine();\nT = int.Parse(temp);\nint i = 0;\nwhile (i < R)\n{\n    Console.Write("#");\n    i = i + 1;\n}\nConsole.WriteLine();\nint j = 0;\nj = 0;\nwhile (j < T)\n{\n    Console.Write("#");\n    j = j + 1;\n}\n<\/code><\/pre>\n
        Der Unterschied besteht darin, dass in der \"m\u00f6glichen\" L\u00f6sung f\u00fcr die Ausgabe der zweiten Zeile eine zweite Variable verwendet wurde. Man muss darauf bestehen, dass die gleiche Variable f\u00fcr beide Schleifen verwendet wird. Man kann dieses Limit damit begr\u00fcnden, dass die L\u00f6sung mit einem Z\u00e4hler f\u00fcr zwei Schleifen eine Veranschaulichung des Begriffs \"R\u00fccksetzung des Z\u00e4hlers\" sein wird. Das Verst\u00e4ndnis dieses Begriffs ist wichtig f\u00fcr die L\u00f6sung der n\u00e4chsten Aufgaben. Als Kompromiss kann man beide L\u00f6sungen der Aufgabe beibehalten.<\/p>\n
        Ein typisches Problem bei der Verwendung einer Z\u00e4hler-Variable f\u00fcr zwei Schleifen \u00e4u\u00dfert sich folgenderma\u00dfen:
        \nR=5, T=11<\/b>#####
        \n######<\/p>\n
        Die Anzahl der Zeichen in der zweiten Zeile entspricht nicht dem Wert von T. Wenn Hilfe mit diesem Problem ben\u00f6tigt wird, sollte man \"auf die Nase\" in den Notizen \u00fcber h\u00e4ufige Probleme mit Schleifen zeigen. Das ist Symptom Nr. 3. Es wird diagnostiziert, wenn man den Wert des Z\u00e4hlers direkt vor der zweiten Schleife ausgibt. Es wird durch R\u00fccksetzung behoben. Aber das sollte man besser nicht sofort erz\u00e4hlen. Der Student sollte versuchen, zumindest eine Hypothese zu formulieren.<\/p>\n
        Es gibt nat\u00fcrlich auch diese L\u00f6sungsm\u00f6glichkeit. Aber ich habe sie bei den Studenten noch nie gesehen. Bei der Einf\u00fchrung in Schleifen w\u00fcrde eine Erz\u00e4hlung dar\u00fcber die Aufmerksamkeit zerstreuen. Man kann sp\u00e4ter darauf zur\u00fcckkommen, bei der Behandlung von Funktionen zur Bearbeitung von Zeichenfolgen.
        \nM\u00f6glichkeit Nr. 2<\/b><\/p>\n
        string temp;\nint R;\nint T;\ntemp = Console.ReadLine();\nR = int.Parse(temp);\ntemp = Console.ReadLine();\nT = int.Parse(temp);\nConsole.WriteLine(new String('#', R));\nConsole.WriteLine(new String('#', T));\n<\/code><\/pre>\n
        \nDie n\u00e4chste Pflichtaufgabe:<\/p>\n
        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 \u00fcber die Tastatur eingegeben.<\/p><\/blockquote>\n
        \nW=1<\/b>0
        \n1
        \n2
        \n3
        \n4
        \n5
        \n6
        \n7
        \n8
        \n9<\/p>\n
        W=10<\/b>0000000000
        \n1111111111
        \n2222222222
        \n3333333333
        \n4444444444
        \n5555555555
        \n6666666666
        \n7777777777
        \n8888888888
        \n9999999999<\/code><\/p>\n
        Wenn der Student die Technik des Variablenwechsels beherrscht, wird er ziemlich schnell zurechtkommen. Ein m\u00f6gliches Problem wird wieder das Zur\u00fccksetzen der Variablen sein. Wenn er mit der Umwandlung Schwierigkeiten hat, bedeutet das, dass er sich gehetzt hat und einfachere Aufgaben l\u00f6sen sollte.<\/p>\n
        Danke f\u00fcr Ihre Aufmerksamkeit. Geben Sie Likes, abonnieren Sie den Kanal.<\/p>\n
        P.S. Wenn Sie Tippfehler oder Fehler im Text gefunden haben, lassen Sie es mich bitte wissen. Sie k\u00f6nnen dies tun, indem Sie einen Teil des Textes markieren und auf einem Mac \u201e\u2318 + Enter\u201c oder auf klassischen Tastaturen \u201eCtrl \/ Enter\u201c dr\u00fccken, oder \u00fcber pers\u00f6nliche Nachrichten. Wenn diese Optionen nicht verf\u00fcgbar sind, schreiben Sie die Fehler in die Kommentare. Vielen Dank!<\/p>\n
        Nur registrierte Benutzer k\u00f6nnen an der Umfrage teilnehmen. Bitte einloggen<\/a><\/noindex>.<\/p>\n
        Umfrage f\u00fcr Leser ohne Karma<\/h2>\n