{"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\/nl\/blog\/kak-nauchit-preodolevat-trudnosti-a-zaodno-i-pisat-czikly","title":{"rendered":"Hoe moeilijkheden te overwinnen en tegelijkertijd loops te schrijven","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"

Hoewel het hier om een van de basis onderwerpen gaat, is dit artikel geschreven voor ervaren professionals. Het doel is om de misverstanden te laten zien die beginners in programmeren kunnen hebben. Voor praktiserende ontwikkelaars zijn deze problemen al lang opgelost, vergeten of worden ze totaal niet opgemerkt. Het artikel kan nuttig zijn als je ooit iemand moet helpen met dit onderwerp. Er worden parallellen getrokken met materiaal uit verschillende boeken over programmeren door auteurs als Schildt, Stroustrup en Okulov.<\/p>\n

Het onderwerp over lussen is gekozen omdat veel mensen daarover struikelen bij het leren van programmeren.<\/p>\n

Deze methode is gericht op zwakkere studenten. Over het algemeen blijven sterke studenten niet bij dit onderwerp hangen en hoeft er geen speciale methode voor hen te worden ontwikkeld. Een secundair doel van het artikel is om deze methode te vertalen van de categorie 'werkt voor alle studenten, maar alleen bij \u00e9\u00e9n docent' naar de categorie 'werkt voor alle studenten, bij alle docenten'. Ik claim niet dat het absoluut origineel is. Als je al een soortgelijke methode toepast om dit onderwerp te onderwijzen, laat dan alsjeblieft weten wat jouw variant anders maakt. Als je besluit het toe te passen, vertel dan als het klaar is hoe het ging. Als een vergelijkbare methode in een boek wordt beschreven, laat dan alsjeblieft de titel weten.<\/p>\n

<\/a><\/noindex>
\nIk heb deze methode vier jaar lang ontwikkeld, terwijl ik individueel met studenten van verschillende niveaus werkte. In totaal zo'n vijftig studenten en twee duizend uur aan lessen. Aanvankelijk bleven studenten voor altijd vastzitten op dit onderwerp en gingen ze weg. Na elke student werden de methode en de materialen aangepast. In het afgelopen jaar blijven studenten niet meer vastzitten op dit onderwerp, dus besloot ik mijn bevindingen te delen.<\/p>\n

Waarom zoveel tekst? Lussen zijn toch simpel!<\/h4>\n

\nZoals ik hierboven al schreef, kan de complexiteit van de concepten van lussen voor praktiserende ontwikkelaars en sterke studenten worden onderschat. Je zou bijvoorbeeld een lange lezing kunnen geven, knikkende hoofden en slimme blikken kunnen zien. Maar bij het proberen om een probleem op te lossen, komt de blokkade en onverklaarbare problemen. Na de lezing hebben studenten vermoedelijk slechts een gedeeltelijk begrip. De situatie wordt verergerd doordat studenten niet in staat zijn om zelf te verwoorden waar precies hun misverstand ligt.
\nOp een gegeven moment realiseerde ik me dat studenten mijn voorbeelden beschouwen als hi\u00ebrogliefen. Dat wil zeggen, als ondeelbare stukken tekst waar ze een of ander 'magisch' letterteken aan moeten toevoegen om het te laten werken.
\nSoms merkte ik op dat studenten dachten dat voor het oplossen van een specifieke taak een bepaalde andere<\/i> structuur nodig was, die ik gewoon nog niet had besproken. Terwijl voor de oplossing slechts een kleine wijziging van het voorbeeld nodig was.<\/p>\n

Daarom kwam ik op het idee dat de focus niet op de syntaxis van de uitdrukkingen moet liggen, maar op het idee van het refactoren van herhalende code met behulp van lussen. Zodra de leerlingen dit idee begrijpen, kan elke syntaxis worden aangeleerd door middel van enkele eenvoudige oefeningen.<\/p>\n

Aan wie en waarom geef ik les<\/h4>\n

\nAangezien er geen toelatingsexamens zijn, kunnen er zowel sterke als zeer zwakke studenten in de lessen zitten. Meer over mijn studenten is te lezen in het artikel Het portret van de bezoekers van de avondcursussen<\/a><\/noindex>
\nIk streefde ernaar dat iedereen die het wilde, de kunst van het programmeren zou beheersen.
\nMijn lessen zijn individueel en de student betaalt zijn eigen geld voor elke les. Het zou logisch zijn dat studenten hun kosten optimaliseren en het minimum eisen. Echter, mensen komen naar de fysieke lessen met een levende docent niet alleen voor de kennis, maar voor de zekerheid dat ze het goed hebben begrepen, voor het gevoel van vooruitgang en voor de goedkeuring van de expert (docent). Als studenten geen vooruitgang voelen in hun leerproces, zullen ze vertrekken. Over het algemeen kun je lessen structureren zodat studenten vooruitgang voelen in het aantal bekende structuren. Dat wil zeggen, we bestuderen eerst in detail de while-lus, dan leren we de for-lus, en dan de do-while-lus, en zo hebben we een cursus van duizend-en-\u00e9\u00e9n nacht, waarin twee maanden alleen de lussen worden bestudeerd, en aan het eind is er een student die de standaardbibliotheek kan schrijven uit dictaat. Maar om praktische taken op te lossen, heb je niet alleen kennis van de stof nodig, maar ook zelfstandigheid in het toepassen ervan en het zoeken naar nieuwe informatie. Daarom beschouw ik het als een goed principe voor fysieke cursussen om het minimum te onderwijzen en zelfstandig leren van nuances en gerelateerde onderwerpen aan te moedigen. Bij het onderwerp van lussen beschouw ik de while-constructie als het minimum. Daarop kan het principe worden begrepen. Als je het principe begrijpt, kun je ook de for-lus en de do-while-lus zelfstandig leren.<\/p>\n

Om zwakke studenten de stof te laten beheersen, is het niet genoeg om alleen de syntaxis te beschrijven. Het is belangrijk om meer simpele, maar gevarieerde opdrachten te geven en voorbeelden uitgebreider uit te werken. Uiteindelijk wordt de snelheid van het leren beperkt door het vermogen van de student om uitdrukkingen om te zetten en patronen te herkennen. Voor slimme studenten zullen de meeste opdrachten saai zijn. Tijdens lessen met hen kan men zich veroorloven niet op het oplossen van 100% van de opdrachten aan te dringen. Mijn materiaal is te vinden op mijn github<\/a><\/noindex>. Het is echter meer een grimoire van een tovenaar \u2014 niemand, behalve ik, begrijpt waar wat zich bevindt, en als de controle mislukt, kan men gek worden.<\/p>\n

De methode is gericht op praktijk<\/h4>\n

\nDe theorie wordt uitgelegd aan de hand van het oplossen van taken. In de programmeerlessen, waar vertakkingen en lussen worden bestudeerd, is het gewoon niet mogelijk om een nuttige lezing over \u00e9\u00e9n onderwerp een uur lang te organiseren. 15-20 minuten is genoeg om het concept uit te leggen. De belangrijkste moeilijkheden ontstaan bij het uitvoeren van praktische opdrachten.
\nStartende docenten kunnen operators, vertakkingen, lussen en arrays in \u00e9\u00e9n lezing behandelen. Maar studenten zullen dan tegen de uitdaging aanlopen deze informatie te begrijpen.
\nHet is immers niet alleen belangrijk om de stof te vertellen, maar ook om te zorgen dat de luisteraars het begrijpen.<\/p>\n

Het feit dat de student het onderwerp heeft begrepen, blijkt uit hoe hij het zelfstandig werk aanpakt.
\nAls de student erin geslaagd is de taak over het onderwerp zonder hulp van de docent op te lossen, betekent dat dat het onderwerp is begrepen. Om zelfevaluatie mogelijk te maken, heeft elke taak een tabel met testscripts. De taken hebben een duidelijk gedefinieerde volgorde. Het is niet aan te raden om taken over te slaan. Als de huidige taak te moeilijk is, is het zinloos om naar de volgende over te gaan. Deze is namelijk nog moeilijker. Om de student te helpen de huidige moeilijke taak te begrijpen, worden enkele technieken uitgelegd aan de hand van de eerste taak. Eigenlijk komt alle inhoud van het onderwerp neer op technieken om moeilijkheden te overwinnen. Lussen zijn eerder een bijeffect.<\/p>\n

De eerste taak is altijd een voorbeeld. De tweede verschilt niet significant en wordt 'zelfstandig' uitgevoerd direct na de eerste, onder toezicht van de docent. Alle daaropvolgende taken zijn gericht op het attenderen op verschillende details die misverstanden kunnen veroorzaken.<\/p>\n

De uitleg van het voorbeeld is een dialoog waarin de student backpropagation en cross-validatie moet aanroepen om te bevestigen dat een deel van het materiaal is begrepen.<\/p>\n

Ik zal banaal zijn en zeggen dat het eerste voorbeeld over het onderwerp heel belangrijk is. Als er materiaal is voor uitgebreide zelfstandige studie, kunnen eventuele tekortkomingen in het eerste voorbeeld worden hersteld. Als er verder niets is dan het voorbeeld, zal de student waarschijnlijk het onderwerp niet begrijpen.<\/p>\n

While of for?<\/h4>\n

\nEen van de discutabele vragen is de keuze van de constructie voor het voorbeeld: while of for. Een keer probeerde een vriend van mij, een praktijkontwikkelaar zonder onderwijservaring, me een uur lang ervan te overtuigen dat de for-lus de eenvoudigste is om te begrijpen. De argumenten kwamen neer op 'alles is duidelijk en goed gestructureerd'. Echter, de echte oorzaak van de moeilijkheden voor echte beginners ligt in het idee van de lus zelf, en niet in de syntaxis. Als iemand dit idee niet begrijpt, zal hij moeite hebben met de syntaxis. Zodra het idee duidelijk is, verdwijnen de problemen met de codering vanzelf.<\/p>\n

In mijn materialen volgt het onderwerp lussen na het onderwerp vertakkingen. De uiterlijke gelijkenis tussen if en while maakt een directe analogie mogelijk: 'wanneer de voorwaarde in de kop waar is, wordt de body uitgevoerd'. Het enige specialiteit van de lus is dat de body meerdere keren wordt uitgevoerd.<\/p>\n

Mijn tweede argument is dat while minder opmaak vereist dan for. Minder opmaak betekent dat er minder domme fouten zijn door gemiste komma's en haakjes. Beginners hebben nog niet voldoende aandacht en nauwgezetheid ontwikkeld om automatisch syntactische fouten te vermijden.
\nHet derde argument is dat in veel goede boeken while als eerste wordt uitgelegd.<\/p>\n

Als de student gemakkelijk uitdrukkingen kan omzetten, kan ik while in het voorbijgaan uitleggen. De student zal zelf kiezen wat hij het leukst vindt. Als de omzettingen echter moeilijk zijn, is het beter om de aandacht niet te verspreiden. Laat de student eerst alles met while oplossen. Zodra het onderwerp lussen is begrepen, kan hij de oplossingen herschrijven om de omzetting van while naar for te oefenen.
\nLussen met een post-condition zijn een vrij zeldzaam fenomeen. Ik besteed daar helemaal geen tijd aan. Als de student de idee\u00ebn van patroonherkenning en uitdrukkingstransformaties beheerst, zal hij zonder mijn hulp in staat zijn om het te begrijpen.<\/p>\n

Bij het demonstreren van het eerste voorbeeld aan sterke studenten, wijs ik erop dat het in dit voorbeeld belangrijk is om niet alleen de oplossing vast te leggen, maar ook de gehele reeks acties die leidde tot het resultaat. Luie studenten kunnen zich beperken tot een eindalgoritme en de uitwerking negeren. Ze moeten overtuigd worden dat ze ooit een complexe taak zullen tegenkomen. Om deze op te lossen, moeten ze stappen volgen zoals in dit voorbeeld. Daarom is het belangrijk om alle stappen vast te leggen. In de volgende taken kan alleen de definitieve oplossing worden gepresenteerd.<\/p>\n

Het hoofddoel van automatisering is dat we computers de routinematige taken van mensen laten uitvoeren. Een van de basisprincipes is het schrijven van lussen. Dit wordt toegepast wanneer in het programma verschillende gelijke herhalende handelingen achter elkaar worden geschreven.<\/p>\n

Expliciet is beter dan impliciet<\/h4>\n

\nHet kan een goed idee lijken om in de eerste lusopdracht een bepaalde zin meerdere keren op het scherm te tonen. Bijvoorbeeld:<\/p>\n

Hoera, het werkt!
\nHoera, het werkt!
\nHoera, het werkt!
\nHoera, het werkt!
\nHoera, het werkt!
\nHoera, het werkt!
\nHoera, het werkt!
\nHoera, het werkt!\n<\/p><\/blockquote>\n

\nDeze optie is slecht omdat de waarde van de teller niet zichtbaar is in de uitvoer. Dit is een probleem voor beginners. Dit moet niet worden onderschat. Aanvankelijk was deze taak de eerste, en de taak over het weergeven van een rij getallen in oplopende volgorde was de tweede. Het was nodig om extra termen in te voeren zoals 'lus N keer' en 'lus van A tot B', die in feite hetzelfde zijn. Om overbodige entiteiten te vermijden, heb ik besloten alleen het voorbeeld van het weergeven van de rij getallen te tonen. Niet veel mensen slagen erin om zonder voorbereiding het tellen in hun hoofd te houden en het gedrag van het programma in hun hoofd te modelleren. Sommige studenten worden voor het eerst geconfronteerd met 'denken in' op het onderwerp van lussen.
\nNa enige oefening geef ik de taak om een gelijke tekst te herhalen als zelfstandig probleemoplossing. Als ik eerst een zichtbare teller geef en daarna een onzichtbare, hebben studenten minder problemen. Soms is een aanwijzing als 'schrijf de teller niet naar het scherm' voldoende.<\/p>\n

Hoe wordt het uitgelegd door anderen?<\/h4>\n

\nIn de meeste lesmaterialen op internet wordt de syntaxis van de loop gepresenteerd in de vorm van een 'lezing'. Bijvoorbeeld op developer.mozilla.org (op dit moment) worden samen met de while-lus nog enkele andere constructies beschreven. Daarbij worden uitsluitend de constructies zelf als sjablonen gegeven. Het resultaat van hun uitvoering wordt in woorden beschreven, maar er ontbreekt een illustratie. Naar mijn mening reduceert zo'n presentatie de bruikbaarheid van dergelijke materialen tot nul. Een leerling kan de code overtypen en zelf uitvoeren, maar er is wel een referentie nodig om te vergelijken. Hoe kan je begrijpen dat het voorbeeld goed is herschreven als er niets is om het resultaat mee te vergelijken?
\nWanneer alleen een sjabloon wordt gegeven, zonder voorbeeld, wordt het nog moeilijker voor de student. Hoe moet je begrijpen dat de codefragmenten goed in het sjabloon zijn geplaatst? Je kunt proberen om ergens<\/i>, dit later uit te voeren. Maar als er geen referentie is om het resultaat mee te vergelijken, helpt de uitvoering ook niet.<\/p>\n

In de C++-cursus is de syntaxis van de lus verborgen in de derde pagina van lezing 4 over het onderwerp 'operatoren'. Bij de uitleg van de syntaxis van lussen wordt bijzondere nadruk gelegd op de term 'operator'. De term wordt neergezet als een set feiten zoals 'symbool; dit is een operator', '{ } is een samengestelde operator', 'de body van de lus moet een operator zijn'. Ik vind deze aanpak niet prettig omdat het belangrijke verbanden achter \u00e9\u00e9n term verbergt. De analyse van de broncode van een programma op termen op dit niveau is nodig voor compilerontwikkelaars om de specificaties van de taal te implementeren, maar zeker niet voor studenten in een eerste benadering. Beginners in programmeren hebben zelden voldoende aandacht om zo nauwkeurig met termen om te gaan. Zelden onthoudt en begrijpt iemand nieuwe woorden bij de eerste keer. Praktisch niemand kan een term correct toepassen die hij net geleerd heeft. Daarom maken studenten vaak fouten zoals 'ik schreef while(a<7);{, maar het programma werkt niet'.
\nNaar mijn mening is het beter om in het begin de syntaxis van de constructie meteen met haakjes te geven. Een variant zonder haakjes moet alleen worden uitgelegd als de leerling een specifieke vraag heeft als 'waarom werken we hier zonder haakjes'.<\/p>\n

In het boek van Okulov \"Basisprincipes van programmeren\" uit 2012 begint de kennismaking met loops met het for-sjabloon, gevolgd door aanbevelingen voor gebruik, en daarna volgt onmiddellijk een experimenteel gedeelte van de les. Ik begrijp dat het boek is geschreven voor die minderheid van zeer bekwame leerlingen die zelden op mijn lessen verschijnen.<\/p>\n

In populaire boeken wordt altijd het resultaat van codefragmenten vermeld. Bijvoorbeeld in het boek van Schildt \"Java 8. Volledige gids\" uit 2015. Eerst wordt er een sjabloon gegeven, dan een voorbeeldprogramma en direct daarna het resultaat van de uitvoering.<\/p>\n

Als voorbeeld nemen we de while-lus, waarin een terugteldfunctie wordt uitgevoerd,
\nbeginnende bij 10, en precies 10 regels \"beats\" worden weergegeven: <\/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
\nNa het starten geeft dit programma tien \"beats\" als volgt weer:
\ntak 10
\ntak 9
\ntak 8
\ntak 7
\ntak 6
\ntak 5
\ntak 4
\ntak 3
\ntak 2
\ntak 1<\/code><\/p><\/blockquote>\n
\nDe aanpak met het beschrijven van een sjabloon, voorbeeldprogramma en het resultaat van dat programma wordt ook gebruikt in het boek \"Javascript voor kinderen\" en in de js-cursus op w3schools.com. Het formaat van de webpagina maakt het zelfs mogelijk om dit voorbeeld interactief te maken.<\/p>\n
In het boek van Stroustrup \"Principes en praktijk met C++\" uit 2016 gaat de auteur nog verder. Eerst wordt uitgelegd welk resultaat moet worden behaald, en pas daarna wordt de programmatext getoond. Bovendien nemen ze als voorbeeld niet zomaar een willekeurig programma, maar geven ze een excursie in de geschiedenis. Dit helpt om aandacht te vestigen op: \"Kijk, dit is geen nutteloze tekst. Je ziet iets betekenisvols.\"<\/p>\n
Als voorbeeld van iteratie beschouwen we het eerste programma dat is uitgevoerd op een machine met opgeslagen programma's (EDSAC). Het werd geschreven door David Wheeler in het computerlaboratorium van de Universiteit van Cambridge (Cambridge University, Engeland) op 6 mei 1949. Dit programma berekent en print een eenvoudige lijst van kwadraten.
\n0 0
\n1 1
\n2 4
\n3 9
\n4 16
\n...
\n98 9604
\n99 9801<\/code>
\nHier staat in elke regel een nummer, gevolgd door een tabteken (\u2018t\u2019) en het kwadraat van dat nummer. De versie van dit programma in de C++-taal ziet er als volgt uit:<\/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
\nHet is opmerkelijk dat het syntaxis-sjabloon in dit boek niet wordt beschreven. Stroustrup benadrukt in de instructeurhandleiding (vertaling<\/a><\/noindex>) dat hij het intellect van zijn studenten respecteert. Misschien wordt de vaardigheid om het sjabloon in verschillende voorbeelden te herkennen beschouwd als een uiting van dat intellect.<\/p>\n
Zoals ik het zelf uitleg<\/h4>\n
\nDe aanpak van Stroustrup: eerst de beschrijving van het resultaat, dan de oplossing van de taak, en tenslotte de zelfstandige analyse door de student \u2014 lijkt de meest doordachte te zijn. Daarom heb ik besloten om zijn aanpak als basis te nemen, maar dan te vertellen over een minder historisch voorbeeld \u2014 de taak om een \u2018inhoudsopgave\u2019 weer te geven. Dit cre\u00ebert een herkenbaar anker, zodat we later kunnen zeggen \u2018vergeet de taak over de inhoudsopgave niet\u2019 en de studenten dit voorbeeld ook daadwerkelijk kunnen herinneren. In mijn voorbeeld heb ik geprobeerd nog twee van de meest voorkomende misvattingen te vermijden. Daarover zal ik verderop meer schrijven.<\/p>\n
Bij deze taak maken we kennis met technieken voor het oplossen van complexe problemen. De eerste oplossing moet primitief en eenvoudig zijn. Vervolgens kunnen we nadenken over hoe we deze oplossing kunnen verbeteren.
\nInleiding
\nHoofdstuk 1
\nHoofdstuk 2
\nHoofdstuk 3
\nHoofdstuk 4
\nHoofdstuk 5
\nHoofdstuk 6
\nHoofdstuk 7
\nConclusie<\/code><\/p><\/blockquote>\n
\nVolgens mijn waarnemingen leidt de aanpak 'sjabloon-voorbeeld-resultaat' in verschillende combinaties er nog steeds toe dat studenten de lus als een hi\u00ebroglief beschouwen. Dit bleek uit het feit dat ze niet begrepen waarom ze daar een voorwaarde moesten schrijven, hoe te kiezen tussen i++ en i--, en andere schijnbaar voor de hand liggende dingen. Om deze misverstanden te voorkomen, moet de aanpak om over lussen te vertellen de betekenis van het herhalen van dezelfde handelingen benadrukken, en pas daarna de vormgeving ervan met behulp van de constructie. Daarom moet, voordat de syntaxis van de lus wordt gegeven, de 'directe' taak worden opgelost. Een primitieve oplossing voor de taak over de inhoudsopgave ziet er als volgt uit:<\/p>\n
Console.WriteLine(\"Inleiding\");\nConsole.WriteLine(\"Hoofdstuk 1\");\nConsole.WriteLine(\"Hoofdstuk 2\");\nConsole.WriteLine(\"Hoofdstuk 3\");\nConsole.WriteLine(\"Hoofdstuk 4\");\nConsole.WriteLine(\"Hoofdstuk 5\");\nConsole.WriteLine(\"Hoofdstuk 6\");\nConsole.WriteLine(\"Hoofdstuk 7\");\nConsole.WriteLine(\"Conclusie\");\n<\/code><\/pre>\n
\nHoe kan dit worden verbeterd?
\nVervang eentonige handelingen door een lus.
\nWelke handelingen worden hier achtereenvolgens herhaald zonder wijzigingen?
\nIn dit fragment zijn er geen. De commando's voor het weergeven van het woord \u2018Hoofdstuk\u2019 met het nummer zijn echter zeer vergelijkbaar.
\nDaarom is de volgende stap het zoeken naar verschillen tussen de fragmenten. Dit is alleen duidelijk in deze taak; later zullen niet enkele commando's zich herhalen, maar blokken code van 5 regels of meer. Je zult moeten zoeken, niet alleen in de lijst van commando's, maar in vertakkingen of lussen.
\nIn het voorbeeld ligt het verschil tussen de commando's in het getal na het woord \u2018Hoofdstuk\u2019.
\nZodra het verschil is gevonden, moet je de patroon van verandering begrijpen. Is het afwijkende fragment een nummer? Verhoogt of vermindert het constant? Hoe verandert de waarde van het nummer tussen twee commando's naast elkaar?
\nIn the example, the number after the word \"Hoofdstuk\" increases by increments of 1. The difference has been found, and the pattern has been identified. Now the differing fragment can be replaced with a variable.
\nSuch a variable should be declared before the first of the repeated fragments. This variable is usually called i or j or something more descriptive. Its initial value must be equal to the first value output on the screen. In the example, the first value is 1. 
\nWhat initial value should be taken to display the series of numbers \"100, 101, 102, 103, 104, 105\"?
\nIn this series, the first number is 100.
\nAfter each output command, the value of this variable needs to be incremented by 1. This unit represents the step of change.
\nWhat step will there be in the series of numbers \"100, 102, 104, 106\"?
\nIn this series, the step is 2.
\nAfter replacing the differing fragment with a variable, the code will look like this:<\/p>\n
Console.WriteLine(\"Inleiding\");\nint i;\ni = 0;\nConsole.WriteLine(\"Hoofdstuk \" + i);\ni = i + 1;\nConsole.WriteLine(\"Hoofdstuk \" + i);\ni = i + 1;\nConsole.WriteLine(\"Hoofdstuk \" + i);\ni = i + 1;\nConsole.WriteLine(\"Hoofdstuk \" + i);\ni = i + 1;\nConsole.WriteLine(\"Hoofdstuk \" + i);\ni = i + 1;\nConsole.WriteLine(\"Hoofdstuk \" + i);\ni = i + 1;\nConsole.WriteLine(\"Hoofdstuk \" + i);\ni = i + 1;\nConsole.WriteLine(\"Conclusie\");\n<\/code><\/pre>\n
\nAfter applying the method \"express the pattern as a variable,\" the code results in several groups of identical actions that occur consecutively. Now, the repeated actions can be replaced with a loop.<\/p>\n
The sequence for solving the problem where loops need to be used consists of the following stages:<\/p>\n
    \n
  1. Solve \"directly\" with a multitude of separate commands<\/li>\n
  2. Find the pattern<\/li>\n
  3. Express the pattern as a variable<\/li>\n
  4. Format as a loop<\/li>\n<\/ol>\n
    Next, new terms are introduced so that the student does not find themselves in a situation of \"I understand everything, but cannot express it\":
    \n \u2014 counter \u2014 always a variable needed to track the number of steps in the loop. Usually an integer that is compared with a limit.
    \n \u2014 counter step \u2014 a description of the pattern of the counter's change.
    \n \u2014 limit \u2014 a number or variable with which the counter is compared, so that the algorithm is finite. The value of the counter changes to approach the limit.
    \n \u2014 body of the loop \u2014 a set of commands that will be repeated. When it is said that \"a command is written inside the loop,\" it refers specifically to the body.
    \n \u2014 loop iteration \u2014 a single execution of the body of the loop.
    \n \u2014 de voorwaarde van de lus \u2014 een logische uitdrukking waarvan afhankelijk is of er nog een iteratie zal worden uitgevoerd. (Hier kan verwarring ontstaan met vertakkingstructuren)
    \nWees voorbereid op het feit dat studenten in het begin termen verkeerd zullen gebruiken. Dit geldt voor zowel sterke als zwakke studenten. Het opbouwen van een gedeelde taal is een ware kunst. Hier volgt een korte samenvatting: stel de opdracht \"markeer het codefragment met \" en gebruik deze termen zelf correct in gesprekken.
    \nNa de transformatie met de lus ontstaat het fragment:<\/p>\n
    Console.WriteLine("Inleiding");\nint i = 0;\nwhile (i < 7) {\n    Console.WriteLine("Hoofdstuk " + i);\n    i = i + 1;\n}\nConsole.WriteLine("Conclusie");<\/code><\/pre>\n
    De belangrijkste misvatting<\/h4>\n
    \nEen populaire misvatting onder studenten is dat ze binnen de lus constructies plaatsen voor handelingen die maar \u00e9\u00e9n keer moeten worden uitgevoerd. Bijvoorbeeld zo:<\/p>\n
    ;\nint i = 0;\nwhile (i < 7) {\n    Console.WriteLine("Inleiding")\n    Console.WriteLine("Hoofdstuk " + i);\n    i = i + 1;\n    Console.WriteLine("Conclusie");\n}\n<\/code><\/pre>\n
    \nLeerlingen stuiten voortdurend op dit probleem, zowel in het begin als bij complexere taken.
    \nDe gouden tip in dit geval:<\/p>\n
    Hoe vaak moet de uitvoeringsopdracht worden herhaald: \u00e9\u00e9n keer of veel?\n<\/p><\/blockquote>\n
    \nDe uitvoeringsopdrachten voor de woorden \"Inleiding\" en \"Conclusie\", evenals de declaratie en initialisatie van de variabele i, verschillen van andere herhalende acties. Ze worden slechts \u00e9\u00e9n keer uitgevoerd, dus ze moeten buiten de lichaam van de lus worden geschreven.<\/p>\n
    In de code moeten alle drie de fasen van de oplossing blijven, zodat we er later naar kunnen verwijzen bij moeilijkheden. De eerste twee versies kunnen gewoon worden gecommentarieerd zodat ze niet in de weg zitten.
    \nDe aandacht van de student moet worden gevestigd op de volgende feiten:
    \n \u2014 In de voorwaarde van de lus wordt meestal de teller vergeleken met de limiet. De teller kan binnen de lus veranderen, maar de limiet niet. Om deze regel te schenden, moeten er goede redenen worden gegeven.
    \n \u2014 De opdrachten voor de uitvoer van de woorden \"Inleiding\" en \"Conclusie\" bevinden zich buiten de lichaam van de lus. Deze moet eenmaal worden uitgevoerd. \"Inleiding\" \u2014 v\u00f3\u00f3r de herhaling van acties, \"Conclusie\" \u2014 erna.
    \nTijdens het verankeren van dit onderwerp, het beheersen van de volgende, en het oplossen van moeilijkheden, is het zelfs voor sterke studenten nuttig om de vraag te stellen: \"Hoe vaak moet deze actie worden uitgevoerd? E\u00e9n of veel?\".<\/p>\n
    Ontwikkeling van aanvullende vaardigheden<\/h4>\n
    \nTijdens het bestuderen van loops ontwikkelen studenten ook hun vaardigheden in diagnose en probleemoplossing. Voor de diagnose moet de student het gewenste resultaat voorstellen en dit vergelijken met het feitelijke resultaat. De acties die nodig zijn om dit te corrigeren, hangen af van het verschil tussen deze twee.
    \nAangezien studenten zich in dit stadium nog onvoldoende een 'geweldig' resultaat kunnen voorstellen, kunnen ze zich baseren op testgegevens. Over het algemeen begrijpt niemand in deze fase wat er fout kan gaan en hoe hiermee om te gaan. Daarom geef ik een beschrijving van typische problemen en enkele oplossingen om op te schrijven in hun schrift. Het kiezen van de meest geschikte oplossing is de taak van de student zelf.
    \nDe notities zijn nodig om te vragen: 'is het resultaat dat ik verwachtte bereikt?', 'Wat is de huidige situatie?', 'Heeft de toegepaste oplossing geholpen?'.<\/p>\n
      \n
    1. Het aantal acties is 1 minder of meer dan verwacht. Oplossingen:
      \n \u2014 verhoog de beginwaarde van de teller met 1.
      \n \u2014 vervang de strikte vergelijkingsoperator (< of >) door een niet-strikte (<= of >=).
      \n \u2014 wijzig de waarde van de beperking met 1.<\/li>\n
    2. De acties in de loop worden eindeloos uitgevoerd. Oplossingen:
      \n \u2014 voeg een wijzigingsopdracht voor de teller toe, indien deze ontbreekt.
      \n \u2014 corrigeer de wijzigingsopdracht voor de teller zodat de waarde dichter bij de beperking komt.
      \n \u2014 verwijder de wijzigingsopdracht voor de beperking, als deze in de loop is.<\/li>\n
    3. Het aantal acties in de loop is meer dan 1 minder of meer dan verwacht. De actie in de loop is geen enkele keer uitgevoerd. Eerst moet je de feitelijke waarden van de variabelen achterhalen net voor de start van de loop. Oplossingen:
      \n \u2014 wijzig de beginwaarde van de beperking.
      \n \u2014 wijzig de beginwaarde van de teller.<\/li>\n<\/ol>\n
      \nGewoonlijk is probleem 3 verbonden met het gebruik van de verkeerde variabele of het niet resetten van de teller.<\/p>\n
      Na deze uitleg kunnen studenten nog steeds verschillende misvattingen hebben over hoe loops werken.
      \nOm de meest voorkomende te ontkrachten, geef ik de volgende taken:<\/p>\n
        \n
      1. Waarbij de beperking, beginwaarde van de teller of stapgrootte door de gebruiker wordt ingevoerd.<\/li>\n
      2. Waarbij de waarde van de teller in een wiskundige uitdrukking moet worden gebruikt. Bij voorkeur met de teller in een worteluitdrukking of in de noemer, zodat het verschil niet-lineair is.<\/li>\n
      3. Waar de waarde van de teller niet op het scherm wordt weergegeven tijdens de uitvoering van de lus. Bijvoorbeeld het weergeven van het benodigde aantal gelijke tekstfragmenten of het tekenen van een figuur met schildpadgrafiek.<\/li>\n
      4. Waar je eerst bepaalde herhalende acties moet uitvoeren, en daarna andere.<\/li>\n
      5. Waar je andere acties moet uitvoeren voor en na de herhalende acties.<\/li>\n<\/ol>\n
        \nVoor elke taak moeten testgegevens en het verwachte resultaat worden opgegeven.<\/p>\n
        Om te begrijpen hoe snel je kunt bewegen, moet je de voorwaarden van deze taken laten lezen en vragen: \"Hoe verschillen ze van het voorbeeld?\", \"Wat moet er in het voorbeeld worden veranderd om ze op te lossen?\". Als de student begrijpend antwoordt, laat hem dan in ieder geval \u00e9\u00e9n op de les oplossen, terwijl de anderen thuis zelfstandig worden gemaakt. Als de oplossing succesvol is, kunnen we beginnen met uitleggen over de voorwaarden binnen lussen.
        \nAls er problemen zijn met de zelfoplossing, moeten we alles op de les oefenen. Om te voorkomen dat het oplossen van de taak lijkt op het tekenen van een uil, raad ik aan om de taak eerst niet universeel op te lossen. Dat wil zeggen, zodat de oplossing de eerste test doorstaat en geen lusconstructie gebruikt. En pas daarna aan te passen om universaliteit in de oplossing te bereiken.<\/p>\n
        Lussen en takken<\/h4>\n
        \nMijns inziens is het nuttig om het onderwerp \"lussen binnen takken\" apart aan te bieden. Zodat het vervolgens duidelijk is wat het verschil is tussen meervoudige voorwaardecontroles en enkele.
        \nDe opdrachten voor consolidatie zullen over het weergeven van getallen van A tot B gaan, die door de gebruiker worden ingevoerd:
        \n \u2014 altijd in oplopende volgorde.
        \n \u2014 in oplopende of aflopende volgorde, afhankelijk van de waarden van A en B.<\/p>\n
        De overgang naar het onderwerp \"vertakkingen binnen loops\" moet pas plaatsvinden nadat de student de technieken \"patronen vervangen door variabelen\" en "herhaalde acties vervangen door een loop" heeft beheerst.
        \nDe belangrijkste reden voor het toepassen van takken binnen lussen is anomalie\u00ebn in het patroon. Het wordt in het midden geschonden afhankelijk van de oorspronkelijke gegevens.
        \nVoor studenten die in staat zijn om door combinaties van eenvoudige technieken naar oplossingen te zoeken, is het voldoende om te zeggen \"takken kunnen binnen lussen worden geschreven\" en geef hen de taak \"voorbeeld\" volledig zelf op te lossen.
        \nTaak voor een voorbeeld:<\/p>\n
        De gebruiker voert een getal X in. Geef de getallen van 0 tot 9 weer in kolomvorm en plaats het teken ‘+’ naast het getal dat gelijk is aan X.<\/p><\/blockquote>\n
        \nAls 0 is ingevoerd<\/b>0+
        \n1
        \n2
        \n3
        \n4
        \n5
        \n6
        \n7
        \n8
        \n9<\/p>\n
        Als er 6 is ingevoerd<\/b>0
        \n1
        \n2
        \n3
        \n4
        \n5
        \n6+
        \n7
        \n8
        \n9<\/p>\n
        Als er 9 is ingevoerd<\/b>0
        \n1
        \n2
        \n3
        \n4
        \n5
        \n6
        \n7
        \n8
        \n9+<\/p>\n
        Als er 777 is ingevoerd<\/b>0
        \n1
        \n2
        \n3
        \n4
        \n5
        \n6
        \n7
        \n8
        \n9<\/p>\n
        Als een korte uitleg niet voldoende is om met een lus te schrijven, dan moet je een universele oplossing voor dezelfde taak zonder lus vinden.
        \nEr komen twee mogelijkheden:
        \nGewenst<\/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
        Mogelijk<\/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
        Een soortgelijke taak geef ik van tevoren tijdens het bestuderen van het onderwerp over takken.
        \nAls de student een \"mogelijke\" optie heeft, moet hij uitleggen dat er meerdere oplossingen voor dezelfde taak kunnen zijn. Echter, ze verschillen in stabiliteit tegenover veranderingen in de vereisten. Stel de vraag: \"Hoeveel plekken in de code moeten worden aangepast als er nog een getal bij moet worden gevoegd?\" In de \"mogelijke\" variant moet er nog een tak worden toegevoegd en dit bij 10 andere plekken het nieuwe getal worden geschreven. In de \"gewilde\" variant hoeft er slechts \u00e9\u00e9n tak te worden toegevoegd.
        \nStel de taak om de \"gewilde\" variant te reproduceren, vind vervolgens de regulariteit in de code, vervang de variabele en schrijf een lus.
        \nAls je een idee hebt om deze taak zonder lus op een andere manier op te lossen, schrijf het dan alstublieft in de reacties.<\/p>\n
        Lussen binnen lussen<\/h4>\n
        \nIn dit onderwerp moet je aandacht besteden aan het feit dat:
        \n \u2014 de tellers voor de binnenste en buitenste lus verschillende variabelen moeten zijn.
        \n \u2014 de teller voor de binnenste lus moet vaak worden gereset (dat wil zeggen binnen het lichaam van de buitenste lus).
        \n In de tekstuitvoertaken kan je niet eerst \u00e9\u00e9n letter op meerdere regels schrijven en dan de tweede. Je moet eerst alle letters van de eerste regel weergeven, daarna alle letters van de tweede regel, enzovoort.<\/p>\n
        De uitleg van het onderwerp over lussen in lussen begint het beste met het belang van het resetten van de teller.
        \nTaak voor een voorbeeld:<\/p>\n
        De gebruiker voert twee getallen in: R en T. Geef twee rijen met het teken "#". In de eerste rij moeten R symbolen staan. In de tweede rij T symbolen. Als een van de getallen negatief is, geef dan een foutmelding.<\/p><\/blockquote>\n
        \nR=5, T=11<\/b>#####
        \n###########<\/p>\n
        R=20, T=3<\/b>####################
        \n###<\/p>\n
        R=-1, T=6<\/b>De waarde van R moet niet-negatief zijn.<\/p>\n
        R=6, T=-2<\/b>De waarde van T moet niet-negatief zijn.<\/p>\n
        Het is duidelijk dat deze taak ook minstens twee mogelijke oplossingen heeft.
        \nGewenst<\/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
        Mogelijk \u21161<\/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
        Het verschil is dat in de \"mogelijke\" oplossing voor het weergeven van de tweede regel een tweede variabele wordt gebruikt. Het is nodig om vast te houden aan het gebruik van dezelfde variabele voor beide lussen. Dit argument kan worden onderbouwd met het idee dat een oplossing met \u00e9\u00e9n teller voor twee lussen een illustratie van de term \"resetten van de teller\" zal zijn. Het begrijpen van deze term is nodig bij het oplossen van volgende taken. Als compromis kunnen beide oplossingen van de taak worden behouden.<\/p>\n
        Een typisch probleem met het gebruik van \u00e9\u00e9n teller voor twee lussen manifesteert zich als volgt:
        \nR=5, T=11<\/b>#####
        \n######<\/p>\n
        Het aantal symbolen in de tweede regel komt niet overeen met de waarde van T. Als hulp nodig is met dit probleem, moet men \"de neus drukken\" in het aantekeningenboekje over typische problemen met lussen. Dit is symptoom \u21163. Het kan worden gediagnosticeerd door de waarde van de teller direct voor de tweede lus weer te geven. Het kan worden verholpen door deze te resetten. Maar dit moet je beter niet meteen vertellen. De student moet proberen ten minste \u00e9\u00e9n hypothese te formuleren.<\/p>\n
        Er is natuurlijk nog een oplossing mogelijk. Maar ik heb het nooit bij studenten gezien. Tijdens de studie van lussen zou het bespreken ervan de aandacht kunnen afleiden. We kunnen later terugkomen op deze oplossing bij het bestuderen van functies voor tekstbewerking.
        \nMogelijk \u21162<\/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
        \nDe volgende verplichte taak:<\/p>\n
        Geef de cijfers van 0 tot 9 weer. Elk cijfer moet op een aparte regel staan. Het aantal cijfers per regel (W) wordt via de toetsenbord ingevoerd.<\/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
        Als de student de techniek met het vervangen van variabelen beheerst, zal hij dit vrij snel kunnen doen. Een mogelijk probleem zal opnieuw zijn om de variabele te resetten. Als je niet in staat bent om om te zetten, heb je je waarschijnlijk gehaast en moet je eenvoudigere taken oplossen.<\/p>\n
        Bedankt voor je aandacht. Geef een duim omhoog en abonneer je op het kanaal.<\/p>\n
        P.S. Als je typfouten of fouten in de tekst hebt gevonden, laat het me dan weten. Dit kan door een deel van de tekst te markeren en op Mac \"\u2318 + Enter\" te drukken, of op klassieke toetsenborden \"Ctrl \/ Enter\", of via persoonlijke berichten. Als deze opties niet beschikbaar zijn, schrijf dan over de fouten in de reacties. Bedankt!<\/p>\n
        Alleen geregistreerde gebruikers kunnen deelnemen aan de enqu\u00eate. Log in<\/a><\/noindex>, alstublieft.<\/p>\n
        Peiling voor lezers zonder karma<\/h2>\n