Ondanks het feit dat we het over een van de basisonderwerpen zullen hebben, is dit artikel geschreven voor ervaren professionals. Het doel is om te laten zien welke misvattingen beginners hebben bij het programmeren. Voor praktiserende ontwikkelaars zijn deze problemen al lang opgelost, vergeten of helemaal niet opgemerkt. Het artikel kan van pas komen als u plotseling iemand met dit onderwerp moet helpen. Het artikel trekt parallellen met materiaal uit verschillende boeken over programmeren van Schildt, Stroustrup, Okulov.
Het onderwerp over cycli is gekozen omdat nogal wat mensen ervan worden uitgesloten bij het beheersen van programmeren.
Deze techniek is bedoeld voor zwakke studenten. In de regel blijven sterke mensen niet hangen in dit onderwerp en is het niet nodig om speciale technieken voor hen te bedenken. Het secundaire doel van het artikel is om deze techniek te verplaatsen van de klas ‘werkt voor alle leerlingen, maar slechts één leraar’ naar de klas ‘werkt voor alle leerlingen, alle leraren’. Ik claim geen absolute originaliteit. Als u al een vergelijkbare methodologie gebruikt om dit onderwerp te onderwijzen, schrijf dan op waarin uw versie verschilt. Als je besluit er gebruik van te maken, vertel ons dan hoe het ging. Als een soortgelijke techniek in een boek wordt beschreven, noteer dan de naam.
Ik heb 4 jaar aan deze techniek gewerkt, waarbij ik individueel studeerde met studenten van verschillende opleidingsniveaus. In totaal zijn er ongeveer vijftig studenten en tweeduizend lesuren. In het begin bleven studenten altijd bij dit onderwerp hangen en vertrokken. Na elke leerling werden de methodiek en materialen aangepast. Het afgelopen jaar zaten studenten niet meer vast aan dit onderwerp, dus besloot ik mijn bevindingen te delen.
Waarom zoveel brieven? Cycli zijn zo elementair!
Zoals ik hierboven schreef, kan voor praktiserende ontwikkelaars en voor sterke studenten de complexiteit van het concept van loops worden onderschat. Je kunt bijvoorbeeld een lange lezing houden, knikkende hoofden en intelligente ogen zien. Maar wanneer je een probleem probeert op te lossen, beginnen verdoving en onverklaarbare problemen. Na de lezing hadden de studenten waarschijnlijk slechts een gedeeltelijk begrip. De situatie wordt verergerd door het feit dat studenten zelf niet kunnen zeggen wat hun waanvoorstelling precies is.
Op een dag besefte ik dat studenten mijn voorbeelden als hiërogliefen zagen. Dat wil zeggen, als ondeelbare stukjes tekst waarin je een ‘magische’ letter moet toevoegen en het zal werken.
Soms merkte ik dat studenten denken dat je dat nodig hebt om een specifiek probleem op te lossen iets anders een ontwerp dat ik nog niet heb behandeld. Hoewel de oplossing slechts een kleine wijziging van het voorbeeld vereiste.
Zo kwam ik op het idee dat de nadruk niet op de syntaxis van uitdrukkingen moest liggen, maar op het idee van het refactoreren van repetitieve code met behulp van lussen. Zodra leerlingen dit idee onder de knie hebben, kan elke syntaxis met weinig oefening worden verbeterd.
Wie en waarom geef ik les?
Omdat er geen toelatingsexamens zijn, kunnen er zowel sterke als zeer zwakke studenten in de lessen zitten. In het artikel leest u meer over mijn studenten
Ik heb ernaar gestreefd ervoor te zorgen dat iedereen die programmeren wil leren, het kan leren.
Mijn lessen worden individueel gegeven en de student betaalt voor elke les zijn eigen geld. Het lijkt erop dat studenten de kosten zullen optimaliseren en het minimum zullen eisen. Mensen gaan echter naar face-to-face lessen met een live leraar, niet voor de kennis zelf, maar voor het vertrouwen in wat ze hebben geleerd, voor een gevoel van vooruitgang en voor goedkeuring van de expert (leraar). Als leerlingen geen vooruitgang in hun leerproces voelen, zullen ze vertrekken. Over het algemeen kunnen de lessen zo worden gestructureerd dat leerlingen vooruitgang voelen bij het vergroten van het aantal bekende structuren. Dat wil zeggen, eerst studeren we in detail, dan studeren we voor, doen dan een tijdje, en nu hebben we een cursus van duizend en één nacht klaar, waarin alleen cycli twee maanden lang worden bestudeerd, en aan het einde - een student die schreef een standaardbibliotheek onder dictaat. Om praktische problemen op te lossen heb je echter niet alleen kennis van de stof nodig, maar ook onafhankelijkheid bij de toepassing ervan en bij het zoeken naar nieuwe informatie. Daarom denk ik dat het juiste principe voor face-to-face cursussen is om het minimum te onderwijzen en onafhankelijke studie van nuances en aanverwante onderwerpen aan te moedigen. Wat betreft lussen beschouw ik de while-constructie als het minimum. Je kunt het principe ervan begrijpen. Als u het principe kent, kunt u zowel voor als voor doe-het-zelf onder de knie krijgen.
Om de stof onder de knie te krijgen bij zwakke leerlingen is het beschrijven van de syntaxis niet voldoende. Het is noodzakelijk om eenvoudigere maar gevarieerdere taken te geven en voorbeelden gedetailleerder te beschrijven. Uiteindelijk wordt de snelheid van de ontwikkeling beperkt door het vermogen van de leerling om uitdrukkingen te transformeren en naar patronen te zoeken. Voor slimme studenten zullen de meeste opdrachten saai zijn. Als je bij hen studeert, hoef je niet aan te dringen op het oplossen van 100% van de problemen. Mijn materiaal is te bekijken op . Toegegeven, de repository lijkt meer op de grimoire van een tovenaar - niemand behalve ik zal begrijpen wat waar is, en als je de controle niet doorstaat, kun je gek worden
De methodiek is praktijkgericht
De theorie wordt uitgelegd aan de hand van het voorbeeld van het oplossen van een probleem. In een les grondbeginselen van programmeren, waar vertakkingen en lussen worden onderwezen, is het eenvoudigweg niet mogelijk om een heel uur lang een nuttige lezing over één onderwerp te geven. 15-20 minuten is voldoende om het concept uit te leggen. De belangrijkste moeilijkheden doen zich voor bij het uitvoeren van praktische taken.
Beginnende docenten kunnen in één lezing operatoren, vertakkingen, lussen en arrays aframmelen. Maar hun studenten zullen geconfronteerd worden met het probleem van het assimileren van deze informatie.
Het is niet alleen nodig om het materiaal te vertellen, maar ook om ervoor te zorgen dat de luisteraars het begrijpen.
Het beheersen van een onderwerp wordt bepaald door de manier waarop de student omgaat met zelfstandig werk.
Als een leerling erin slaagt een probleem over een onderwerp op te lossen zonder de hulp van een leraar, dan heeft hij het onderwerp onder de knie. Om zelftesten te garanderen, wordt elke taak beschreven in een tabel met testscenario's. De taken hebben een duidelijke volgorde. Het overslaan van taken wordt niet aanbevolen. Als de huidige taak te moeilijk is, heeft het geen zin om door te gaan naar de volgende. Het is nog ingewikkelder. Zodat de student de huidige complexe taak onder de knie kan krijgen, worden hem verschillende technieken uitgelegd aan de hand van het voorbeeld van het eerste probleem. Eigenlijk komt de hele inhoud van het onderwerp neer op technieken om moeilijkheden te overwinnen. Cycli zijn meer een bijwerking.
De eerste taak is altijd een voorbeeld. De tweede wijkt enigszins af en wordt direct na de eerste “zelfstandig” uitgevoerd onder begeleiding van een docent. Alle volgende taken zijn gericht op het letten op verschillende kleine dingen die misvattingen kunnen veroorzaken.
De uitleg van het voorbeeld is een dialoog waarin de student propagatie en kruisvalidatie moet terugroepen om er zeker van te zijn dat hij een deel van de stof onder de knie heeft.
Ik zal banaal zijn en zeggen dat het eerste voorbeeld over dit onderwerp erg belangrijk is. Als u over het materiaal beschikt voor uitgebreid zelfstandig werk, kunnen de weglatingen van het eerste voorbeeld worden gecorrigeerd. Als er naast het voorbeeld niets anders is, zal de student het onderwerp waarschijnlijk niet beheersen.
Terwijl of voor?
Een van de controversiële kwesties is de constructiekeuze voor het voorbeeld: while of for. Een praktiserende vriend van mij, zonder leservaring, heeft mij er een uur lang van overtuigd dat de for-lus het gemakkelijkst te begrijpen was. De argumenten kwamen neer op ‘alles erin is duidelijk en op zijn plaats gelegd’. De oorzaak van de moeilijkheden voor echte beginners is echter het idee van de cyclus zelf, en niet het schrijven ervan. Als een persoon dit idee niet begrijpt, zal hij moeite hebben met de syntaxis. Zodra het idee gerealiseerd is, verdwijnen de problemen van codeontwerp vanzelf.
In mijn materialen volgt het thema van loops het thema van vertakkingen. De externe gelijkenis van if en while stelt ons in staat een directe analogie te trekken: “wanneer de voorwaarde in de header waar is, wordt de body uitgevoerd.” De enige bijzonderheid van de cyclus is dat het lichaam vele malen wordt uitgevoerd.
Mijn tweede argument is dat while minder opmaak vereist dan for. Minder opmaak betekent minder domme fouten met ontbrekende komma's en haakjes. Beginners hebben nog niet voldoende aandacht en nauwgezetheid ontwikkeld om automatisch syntaxisfouten te voorkomen.
Het derde argument wordt in veel goede boeken uitgelegd als het eerste argument.
Als de leerling uitdrukkingen gemakkelijk kan transformeren, kun je er terloops over praten. De leerling kiest dan wat hij het leukst vindt. Als transformaties moeilijkheden veroorzaken, is het beter om uw aandacht niet af te leiden. Laat de leerling eerst alles oplossen met while. Als u het onderwerp loops eenmaal onder de knie heeft, kunt u de oplossingen herschrijven om te oefenen met het converteren van while naar for.
Postcondition-loops zijn een vrij zeldzaam beest. Ik besteed er helemaal geen tijd aan. Als een student de ideeën van het identificeren van patronen en het transformeren van uitdrukkingen onder de knie heeft, kan hij dit zonder mijn hulp uitzoeken.
Bij het demonstreren van het eerste voorbeeld aan sterke studenten vestig ik de aandacht op het feit dat het in het eerste voorbeeld belangrijk is om niet alleen de oplossing vast te leggen, maar ook de hele keten van acties die tot het resultaat hebben geleid. Luie studenten kunnen het schrijven verwaarlozen en alleen het uiteindelijke algoritme kopiëren. Ze moeten ervan overtuigd worden dat er op een dag een moeilijke taak op hun pad zal komen. Om het op te lossen, moet u de stappen volgen zoals in dit voorbeeld. Daarom is het belangrijk om alle etappes vast te leggen. Bij de volgende problemen is het mogelijk alleen de definitieve versie van de oplossing over te laten.
Het belangrijkste idee van automatisering is dat we een computer het routinewerk voor een persoon toevertrouwen. Een van de basistechnieken is het schrijven van loops. Het wordt gebruikt wanneer meerdere identieke herhalende acties achter elkaar in een programma worden geschreven.
Expliciet is beter dan impliciet
Het lijkt misschien een goed idee om dezelfde zin meerdere keren weer te geven in de eerste lus-taak. Bijvoorbeeld:
Hoera, het werkt!
Hoera, het werkt!
Hoera, het werkt!
Hoera, het werkt!
Hoera, het werkt!
Hoera, het werkt!
Hoera, het werkt!
Hoera, het werkt!
Deze optie is slecht omdat de tellerwaarde niet zichtbaar is in de uitvoer. Dit is een probleem voor beginners. Onderschat haar niet. In eerste instantie was deze taak de eerste, en de taak om een reeks getallen in oplopende volgorde af te leiden was de tweede. Het was nodig om aanvullende termen “N keer fietsen” en “cyclus van A naar B” te introduceren, die in wezen hetzelfde zijn. Om geen onnodige entiteiten te creëren, heb ik besloten alleen een voorbeeld te laten zien met de uitvoer van een reeks getallen. Weinig mensen slagen erin zonder voorbereiding een teller in hun hoofd te houden en het gedrag van een programma in hun hoofd te modelleren. Sommige studenten komen voor het eerst in aanraking met mentale modellering op het gebied van cycli.
Na wat oefenen geef ik de taak om dezelfde tekst te herhalen om deze zelfstandig op te lossen. Als je eerst een zichtbare teller geeft en daarna een onzichtbare, hebben studenten minder problemen. Soms is de hint “schrijf de teller niet op het scherm” voldoende.
Hoe leggen anderen het uit?
In de meeste educatieve materialen op internet wordt de syntaxis van de cyclus gegeven als onderdeel van een “lezing”. Op developer.mozilla.org (momenteel) worden bijvoorbeeld verschillende andere constructies beschreven, samen met de while-lus. In dit geval worden alleen de ontwerpen zelf in de vorm van sjablonen weergegeven. Het resultaat van hun lancering wordt in woorden beschreven, maar er is geen illustratie. Naar mijn mening vermenigvuldigt een dergelijke presentatie van het onderwerp het nut van dergelijke materialen met nul. De student kan de code herschrijven en zelf uitvoeren, maar hij heeft nog steeds een standaard ter vergelijking nodig. Hoe kun je begrijpen dat een voorbeeld correct is herschreven als er niets is om het resultaat mee te vergelijken?
Wanneer alleen een sjabloon wordt gegeven, zonder voorbeeld, wordt het voor de leerling nog lastiger. Hoe kunt u begrijpen dat de codefragmenten correct in de sjabloon zijn geplaatst? Je kunt proberen te schrijven op de een of andere manier, en dan rennen. Maar als er geen standaard is om het resultaat te vergelijken, zal lanceren ook niet helpen.
In de C++-cursus over Intuïtief wordt de lussyntaxis begraven op de derde pagina van Lezing 4 over het onderwerp “operatoren”. Bij het uitleggen van de syntaxis van lussen wordt speciale nadruk gelegd op de term “operator”. De term wordt gepresenteerd als een reeks feiten zoals ‘symbool; dit is een statement", "{} is een samengestelde statement", "de body van de lus moet een statement zijn". Ik hou niet van deze aanpak omdat het belangrijke relaties achter één term lijkt te verbergen. Het ontleden van de broncode van een programma in termen op dit niveau is nodig voor compilerontwikkelaars om de taalspecificatie te implementeren, maar niet voor studenten als eerste benadering. Nieuwkomers in het programmeren zijn zelden nauwgezet genoeg om zoveel aandacht aan de termen te besteden. Het is een zeldzame persoon die de eerste keer nieuwe woorden onthoudt en begrijpt. Bijna niemand kan een term die hij zojuist heeft geleerd correct toepassen. Daarom krijgen leerlingen veel fouten, zoals “Ik schreef while(a<7);{, maar het programma werkt niet.”
Naar mijn mening is het in het begin beter om de syntaxis van de constructie direct tussen haakjes te geven. De optie zonder haakjes mag alleen uitgelegd worden als de leerling een specifieke vraag heeft: “waarom staan er geen haakjes en het werkt.”
In Okulovs boek 'Fundamentals of Programming' uit 2012 begint een inleiding tot loops met het for-patroon, geeft vervolgens aanbevelingen voor het gebruik ervan en gaat dan onmiddellijk naar het experimentele gedeelte van de les. Ik begrijp dat het boek is geschreven voor die minderheid van zeer capabele studenten die zelden naar mijn lessen komen.
In populaire boeken wordt altijd het resultaat van codefragmenten geschreven. Bijvoorbeeld Shildt's "Java 8. The Complete Guide" 2015-editie. Eerst wordt een sjabloon gegeven, vervolgens een voorbeeldprogramma en onmiddellijk daarna het resultaat van de uitvoering.
Beschouw als voorbeeld een while-lus die het omgekeerde doet
Er wordt afgeteld vanaf 10, en er worden exact 10 regels met “maatregelen” weergegeven://Продемонстрировать применение оператора цикла while class While { public static void main(String args []) { int n = 10; while (n > 0) { System.out.println("такт " + n); n--; } } }Eenmaal uitgevoerd, voert dit programma als volgt tien "cycli" uit:
такт 10
такт 9
такт 8
такт 7
такт 6
такт 5
такт 4
такт 3
такт 2
такт 1
De aanpak van het beschrijven van een template, een voorbeeldprogramma en het resultaat van het programma wordt ook gebruikt in het boek “Javascript for Kids” en in de js-cursus op w3schools.com. Het webpaginaformaat maakt het zelfs mogelijk dat dit voorbeeld interactief is.
Stroustrups boek Principles and Practice Using C++ uit 2016 ging zelfs nog verder. De eerste stap is het uitleggen welk resultaat er moet worden behaald, waarna de tekst van het programma wordt getoond. Bovendien nemen ze niet zomaar een willekeurig programma als voorbeeld, maar geven ze een excursie in de geschiedenis. Dit helpt om de aandacht erop te vestigen: “Kijk, dit is niet zomaar een nutteloze tekst. Je ziet iets betekenisvols."
Beschouw als voorbeeld van iteratie het eerste programma dat wordt uitgevoerd op een opgeslagen programmamachine (EDSAC). Het werd op 6 mei 1949 geschreven door David Wheeler van het computerlaboratorium van de universiteit van Cambridge, Engeland. Dit programma berekent en drukt een eenvoudige lijst met vierkanten af.
0 0
1 1
2 4
3 9
4 16
...
98 9604
99 9801
Hier bevat elke regel een getal gevolgd door een tabteken ('t') en het kwadraat van dat getal. De C++-versie van dit programma ziet er als volgt uit://Вычисляем и распечатываем таблицу квадратов чисел 0-99 int main() { int i = 0; // Начинаем с нуля while(i < 100){ cout << i << 't' << square(i) << 'n'; ++i; } }
Interessant genoeg wordt het syntaxispatroon in dit boek niet beschreven. Stroustrup in de docentenhandleiding () benadrukt dat zij de intelligentie van haar studenten respecteert. Misschien wordt het vermogen om een patroon in verschillende voorbeelden te identificeren beschouwd als een manifestatie van dergelijke intelligentie.
Zoals ik mezelf uitleg
De aanpak van Stroustrup: het resultaat beschrijven, vervolgens het probleem oplossen en vervolgens een onafhankelijke analyse door de student uitvoeren, lijkt het meest doordacht. Daarom besloot ik het als basis te nemen, maar het te vertellen aan de hand van een minder historisch voorbeeld: de taak om een "inhoudsopgave" af te leiden. Het vormt een herkenbaar anker zodat je vervolgens kunt zeggen ‘onthoud de opdracht over de inhoudsopgave’ en zodat leerlingen dit precies onthouden. In mijn voorbeeld probeerde ik nog twee van de meest voorkomende misvattingen te voorkomen. Vervolgens zal ik er meer in detail over schrijven.
In deze taak maken we kennis met technieken voor het oplossen van complexe problemen. De initiële beslissing moet primitief en eenvoudig worden gemaakt. Welnu, dan kunt u nadenken over hoe u deze oplossing kunt verbeteren.
Введение
Глава 1
Глава 2
Глава 3
Глава 4
Глава 5
Глава 6
Глава 7
Заключение
Volgens mijn observaties leidt de “sjabloon-voorbeeld-resultaat”-benadering in verschillende combinaties er nog steeds toe dat studenten de cyclus als een hiëroglief waarnemen. Dit kwam tot uiting in het feit dat ze niet begrepen waarom er een voorwaarde was om daar te schrijven, hoe ze moesten kiezen tussen i++ en i – en andere ogenschijnlijk voor de hand liggende dingen. Om deze misvattingen te vermijden, zou de benadering van het praten over cycli de nadruk moeten leggen op de betekenis van het herhalen van identieke acties en deze pas daarna te formaliseren met behulp van een structuur. Voordat u de syntaxis van de lus geeft, moet u daarom het probleem direct oplossen. Een primitieve oplossing voor het inhoudsopgaveprobleem ziet er als volgt uit:
Console.WriteLine("Введение");
Console.WriteLine("Глава 1");
Console.WriteLine("Глава 2");
Console.WriteLine("Глава 3");
Console.WriteLine("Глава 4");
Console.WriteLine("Глава 5");
Console.WriteLine("Глава 6");
Console.WriteLine("Глава 7");
Console.WriteLine("Заключение");
Hoe kan het verbeterd worden?
Vervang monotone acties door een cyclus.
Welke acties worden achter elkaar herhaald zonder wijzigingen?
In dit fragment zijn er geen. De opdrachten voor het weergeven van het woord “Hoofdstuk” met een nummer lijken echter sterk op elkaar.
Daarom is de volgende fase het vinden van het verschil tussen de fragmenten. Alleen bij deze taak is alles duidelijk, dan worden geen enkele opdrachten herhaald, maar codeblokken van 5 regels of meer. U zult niet alleen in de lijst met opdrachten moeten zoeken, maar ook in vertakkingen of lusconstructies.
In het voorbeeld zit het verschil tussen de opdrachten in het getal na het woord “Hoofdstuk”.
Zodra het verschil is gevonden, moet u het veranderingspatroon begrijpen. Het verschillende fragment is het nummer? Neemt het voortdurend toe of af? Hoe verandert de waarde van een getal tussen twee teams naast elkaar?
In het voorbeeld wordt het getal na het woord ‘Hoofdstuk’ verhoogd in stappen van 1. Het verschil wordt gevonden, het patroon wordt onthuld. Nu kunt u het afwijkende fragment vervangen door een variabele.
U moet een dergelijke variabele declareren vóór het eerste van de zich herhalende fragmenten. Zo'n variabele wordt gewoonlijk I of j genoemd, of iets gedetailleerder. De initiële waarde moet gelijk zijn aan de eerste waarde die op het scherm wordt weergegeven. In het voorbeeld is de eerste waarde 1.
Welke beginwaarde moet worden gebruikt om de reeks getallen “100, 101, 102, 103, 104, 105” weer te geven?
Het eerste getal in deze serie is 100.
Na elk uitvoercommando moet u de waarde van deze variabele met 1 verhogen. Deze eenheid is de wijzigingsstap.
Welke stap zal er zijn in de reeks getallen "100, 102, 104, 106"?
Stap 2 in deze rij.
Nadat het afwijkende fragment is vervangen door een variabele, ziet de code er als volgt uit:
Console.WriteLine("Введение");
int i;
i = 0;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Заключение");
Nadat je de techniek ‘druk het patroon van een variabele uit’ in de code hebt toegepast, krijg je verschillende groepen identieke acties die op een rij staan. Nu kunnen herhalende acties worden vervangen door een lus.
De volgorde van het oplossen van een probleem waarbij u lussen moet gebruiken, bestaat uit de volgende stappen:
- Los het ‘frontaal’ op met veel afzonderlijke opdrachten
- Zoek een patroon
- Geef het patroon van een variabele weer
- Ontwerp als een cyclus
Vervolgens worden nieuwe termen geïntroduceerd zodat de leerling niet in de situatie terechtkomt van “Ik begrijp alles, maar ik kan het niet zeggen”:
— een teller is altijd een variabele die nodig is om het aantal stappen in een lus bij te houden. Meestal een geheel getal dat wordt vergeleken met de beperking.
— tegenstap — beschrijving van het patroon van tegenveranderingen.
- beperking - een getal of variabele waarmee de teller wordt vergeleken, zodat het algoritme definitief is. De tellerwaarde verandert om de limiet te benaderen.
— loop body — een reeks opdrachten die worden herhaald. Als ze zeggen ‘het commando is in een lus geschreven’, bedoelen ze de hoofdtekst.
— lus-iteratie — eenmalige uitvoering van de lusbody.
— lusvoorwaarde — een logische expressie die bepaalt of er nog een iteratie zal worden uitgevoerd. (Er kan hier verwarring zijn met vertakkende structuren)
Je moet erop voorbereid zijn dat studenten termen in eerste instantie voor andere doeleinden zullen gebruiken. Dit geldt voor zowel de sterken als de zwakken. Het tot stand brengen van een gemeenschappelijke taal is een kunst. Nu zal ik kort schrijven: je moet de taak instellen “markeer het codefragment met <term>” en deze termen zelf correct gebruiken in een gesprek.
Na transformatie met een lus wordt het fragment verkregen:
Console.WriteLine("Введение");
int i = 0;
while (i < 7) {
Console.WriteLine("Глава " + i);
i = i + 1;
}
Console.WriteLine("Заключение");De belangrijkste misvatting
Een populaire misvatting onder leerlingen is dat ze acties in een lus plaatsen die slechts één keer hoeft te worden uitgevoerd. Bijvoorbeeld als volgt:
;
int i = 0;
while (i < 7) {
Console.WriteLine("Введение")
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Заключение");
}
Studenten komen dit probleem voortdurend tegen, zowel in het begin als bij complexere problemen.
Belangrijke tip in dit geval:
Hoe vaak moet je het commando herhalen: één keer of meerdere keren?
De opdrachten voor het afdrukken van de woorden "Inleiding" en "Conclusie" en het declareren en initialiseren van de variabele i zijn niet zoals andere repetitieve acties. Ze worden slechts één keer uitgevoerd, wat betekent dat ze buiten de lusbody moeten worden geschreven.
Alle drie fasen van de oplossing moeten in de code blijven staan, zodat u ze later kunt raadplegen in geval van problemen. Het is voldoende om de eerste twee opties te becommentariëren, zodat ze zich niet met elkaar bemoeien.
De aandacht van de student moet worden gevestigd op de volgende feiten:
— In een lusconditie worden gewoonlijk een teller en een limiet vergeleken. De teller kan veranderen in het lichaam van de lus, maar de limiet niet. Om deze regel te overtreden, moet je dwingende redenen formuleren.
— Commando’s voor het weergeven van de woorden “Introductie” en “Conclusie” bevinden zich buiten het lichaam van de lus. We moeten ze 1 keer uitvoeren. "Inleiding" - vóór het herhalen van de acties, "Conclusie" - daarna.
Bij het consolideren van dit onderwerp, het beheersen van de volgende en het omgaan met moeilijkheden, is het zelfs voor sterke studenten nuttig om de vraag te stellen: “Hoe vaak moet deze actie worden uitgevoerd? Eén of veel?
Ontwikkeling van aanvullende vaardigheden
Tijdens het bestuderen van cycli ontwikkelen studenten ook de vaardigheid om problemen te diagnosticeren en op te lossen. Om diagnostiek uit te voeren, moet de student het gewenste resultaat presenteren en vergelijken met het daadwerkelijke resultaat. Corrigerende acties zijn afhankelijk van het verschil daartussen.
Omdat studenten in deze fase nog weinig zicht hebben op het “gewenste” resultaat, kunnen zij zich richten op toetsdata. In de regel begrijpt nog niemand in dit stadium wat er mis kan gaan en hoe daarmee om te gaan. Daarom schrijf ik in een notitieboekje een beschrijving van typische problemen en verschillende manieren om ze op te lossen. Het kiezen van de meest geschikte is de taak van de student zelf.
Er is een registratie nodig om te vragen: “Is er gebeurd wat werd verwacht?”, “Welke van deze situaties is nu gebeurd?”, “Heeft de toegepaste oplossing geholpen?”
- Het aantal acties is 1 minder of meer dan verwacht. Oplossingen:
— verhoog de beginwaarde van de teller met 1.
— vervang de strikte vergelijkingsoperator (< of >) door een niet-strikte operator (<= of >=).
— verander de grenswaarde naar 1. - Acties in een lus worden uitgevoerd zonder te stoppen, voor onbepaalde tijd. Oplossingen:
— voeg een tellerwisselcommando toe als dit ontbreekt.
— repareer het commando voor het wijzigen van de teller zodat de waarde ervan dichter bij de limiet komt.
— verwijder de opdracht voor het wijzigen van de beperking als deze zich in de hoofdtekst van de lus bevindt. - Het aantal acties in een lus is meer dan 1 minder of meer dan verwacht. De actie in de lus werd niet één keer uitgevoerd. Eerst moet je de werkelijke waarden van de variabelen achterhalen, net voordat de lus begint. Oplossingen:
— verander de initiële waarde van de beperking
— verander de beginwaarde van de teller
Probleem 3 houdt meestal in dat u de verkeerde variabele gebruikt of dat u de teller niet op nul zet.
Na deze uitleg kan de leerling nog steeds verschillende misvattingen hebben over hoe lussen werken.
Om de meest voorkomende te verdrijven, geef ik je de volgende taken:
- Waarbij de limiet, initiële tellerwaarde of tellerstap door de gebruiker wordt ingevoerd.
- Waarin de tellerwaarde in een rekenkundige uitdrukking moet worden gebruikt. Het is raadzaam om een teller te gebruiken in de radicaaluitdrukking of in de noemer, zodat het verschil niet-lineair is.
- Waarbij de tellerwaarde niet op het scherm wordt weergegeven terwijl de lus loopt. Bijvoorbeeld het weergeven van het benodigde aantal identieke tekstfragmenten of het tekenen van een figuur met schildpadafbeeldingen.
- Waarbij je eerst enkele repetitieve acties moet uitvoeren, en dan andere.
- Waarin je voor en na het herhalen andere acties moet uitvoeren
Voor elke taak moet u testgegevens en het verwachte resultaat opgeven.
Om te begrijpen hoe snel u kunt handelen, moet u de termen van deze problemen lezen en vragen: "Hoe verschillen ze van het voorbeeld?", "Wat moet er in het voorbeeld worden veranderd om ze op te lossen?" Als de leerling zinvol antwoordt, laat hem er dan minstens één in de klas oplossen, en de rest thuis alleen. Als de oplossing succesvol is, kunnen we beginnen met het uitleggen van de omstandigheden binnen de lussen.
Als u problemen ondervindt bij het zelfstandig oplossen van problemen, moet u alles in de klas doornemen. Om te voorkomen dat het oplossen van het probleem doet denken aan het tekenen van een uil, raad ik aan het probleem eerst op een niet-universele manier op te lossen. Dat wil zeggen, zodat de oplossing de eerste test doorstaat en geen gebruik maakt van de lusconstructie. Pas dan transformaties toe om de universaliteit van de oplossing te bereiken.
Lussen en takken
Naar mijn mening is het nuttig om het onderwerp “cycli binnen branches” apart te behandelen. Zodat je later het verschil kunt zien tussen het meerdere keren controleren van een voorwaarde en het één keer controleren.
De taken voor consolidatie gaan over het uitvoeren van getallen van A naar B, die door de gebruiker worden ingevoerd:
- altijd in oplopende volgorde.
- oplopend of aflopend afhankelijk van de waarden van A en B.
Het onderwerp ‘vertakking binnen lussen’ mag pas verder worden besproken nadat de leerling de technieken onder de knie heeft: ‘een patroon vervangen door een variabele’ en ‘repeterende acties vervangen door een cyclus’.
De belangrijkste reden voor het gebruik van vertakkingen binnen lussen zijn afwijkingen in het patroon. In het midden breekt het afhankelijk van de initiële gegevens.
Voor die studenten die in staat zijn een oplossing te zoeken door eenvoudige technieken te combineren, is het voldoende om te zeggen "vertakkingen kunnen in lussen worden geschreven" en het probleem "bijvoorbeeld" volledig zelfstandig op te lossen.
Voorbeeldtaak:
De gebruiker voert het getal X in. Geef de getallen van 0 tot en met 9 weer in een kolom en zet een ‘+’ teken tegenover het getal dat gelijk is aan X.
Als 0 is ingevoerd0+
1
2
3
4
5
6
7
8
9
Als 6 is ingevoerd0
1
2
3
4
5
6+
7
8
9
Als 9 is ingevoerd0
1
2
3
4
5
6
7
8
9+
Als 777 is ingevoerd0
1
2
3
4
5
6
7
8
9
Als een korte uitleg niet genoeg is om met een lus te schrijven, dan moet je zonder lus een universele oplossing voor hetzelfde probleem vinden.
U krijgt een van de twee opties:
Gewenst
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);
}
Mogelijk
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+");
}
Ik geef van tevoren een soortgelijke taak, terwijl ik het onderwerp vertakking bestudeer.
Als de leerling met een “mogelijke” optie komt, moet je hem vertellen dat er voor hetzelfde probleem veel oplossingen kunnen zijn. Ze verschillen echter in hun weerstand tegen veranderingen in de eisen. Stel de vraag: “Hoeveel plaatsen in de code zouden moeten worden gecorrigeerd als ik nog een nummer zou moeten toevoegen?” In de “mogelijke” versie moet u nog een filiaal toevoegen en op 10 andere plaatsen een nieuw nummer toevoegen. In het "gewenste" volstaat het om slechts één tak toe te voegen.
Stel de taak in om de "gewenste" optie te reproduceren, zoek vervolgens een patroon in de code, voer een variabele vervanging uit en schrijf een lus.
Als je een idee hebt hoe je dit probleem op een andere manier zonder lus kunt oplossen, schrijf dan in de reacties.
Lussen binnen Lussen
In dit onderwerp moet u op het volgende letten:
— tellers voor de binnenste en buitenste lussen moeten verschillende variabelen zijn.
— de teller voor de binnenste lus moet vele malen worden gereset (dat wil zeggen, in het lichaam van de buitenste lus).
— bij tekstuitvoertaken kunt u niet eerst één letter in meerdere regels schrijven, en dan de tweede. U moet eerst alle letters van de eerste regel afdrukken, vervolgens alle letters van de tweede, enzovoort.
Het is het beste om het onderwerp lussen binnen lussen uit te leggen door uit te leggen hoe belangrijk het is om de teller op nul te zetten.
Voorbeeldtaak:
De gebruiker voert twee cijfers in: R en T. Druk twee regels met "#"-tekens af. De eerste regel moet R-tekens bevatten. De tweede regel bevat T-stukken. Als een getal negatief is, wordt er een foutmelding weergegeven.
R=5, T=11#####
R=20, T=3####################
###
R=-1, T=6De R-waarde moet niet-negatief zijn
R=6, T=-2De T-waarde moet niet-negatief zijn
Uiteraard heeft dit probleem ook minstens twee oplossingen.
Gewenst
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;
}
Mogelijk #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;
}
Het verschil is dat in de "mogelijke" oplossing een tweede variabele werd gebruikt om de tweede regel uit te voeren. U moet erop staan dat u voor beide lussen dezelfde variabele gebruikt. Deze beperking kan worden gerechtvaardigd door het feit dat een oplossing met één teller voor twee cycli een illustratie zal zijn van de term “teller resetten”. Het begrijpen van deze term is noodzakelijk bij het oplossen van de volgende problemen. Als compromis kunt u beide oplossingen voor het probleem opslaan.
Een typisch probleem bij het gebruik van één tellervariabele voor twee lussen ziet er als volgt uit:
R=5, T=11#####
######
Het aantal tekens op de tweede regel komt niet overeen met de waarde van T. Als je hulp nodig hebt bij dit probleem, moet je de opmerkingen over typische problemen met lussen bekijken. Dit is symptoom #3. De diagnose wordt gesteld als u vlak voor de tweede cyclus een tellerwaarde-uitvoer toevoegt. Gecorrigeerd door resetten. Maar het is beter om dit niet meteen te vertellen. De student moet proberen minstens één hypothese te formuleren.
Er is uiteraard nog een andere oplossing. Maar ik heb het nog nooit onder studenten gezien. In de fase van het bestuderen van cycli zal het verhaal erover de aandacht afleiden. Je kunt er later op terugkomen als je meer te weten komt over stringfuncties.
Mogelijk #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));
Volgende vereiste taak:
Geef de cijfers van 0 tot en met 9 weer. Elk nummer moet op een eigen regel staan. Het aantal cijfers in een regel (W) wordt via het toetsenbord ingevoerd.
W = 10
1
2
3
4
5
6
7
8
9
W = 100000000000
1111111111
2222222222
3333333333
4444444444
5555555555
6666666666
7777777777
8888888888
9999999999
Als een student de techniek van het vervangen van een variabele onder de knie heeft, zal hij er vrij snel mee om kunnen gaan. Een mogelijk probleem zal opnieuw het resetten van de variabele zijn. Als je de transformatie niet aankunt, betekent dit dat je haast had en eenvoudigere problemen moet oplossen.
Bedankt voor uw aandacht. Like en abonneer je op het kanaal.
PS Mocht u typefouten of fouten in de tekst tegenkomen, laat het mij dan weten. Dit kan gedaan worden door een deel van de tekst te selecteren en op “⌘ + Enter” op de Mac, en op “Ctrl / Enter” op klassieke toetsenborden te drukken, of via privéberichten. Als deze opties niet beschikbaar zijn, schrijf dan over fouten in de opmerkingen. Bedankt!
Alleen geregistreerde gebruikers kunnen deelnemen aan het onderzoek. , Alsjeblieft.
Poll voor lezers zonder karma
-
20,0%Ik geef professioneel les, +12
-
10,0%Ik geef professioneel les, -11
-
70,0%Ik geef geen les, +17
-
0,0%Ik geef geen les, -10
-
0,0%Overige0
10 gebruikers hebben gestemd. 5 gebruikers onthielden zich van stemming.
Bron: www.habr.com