Ten spyte van die feit dat ons oor een van die basiese onderwerpe sal praat, is hierdie artikel geskryf vir ervare professionele persone. Die doel is om te wys watter wanopvattings beginners in programmering het. Vir praktiserende ontwikkelaars is hierdie probleme lankal opgelos, vergeet of glad nie opgemerk nie. Die artikel kan handig te pas kom as jy skielik iemand met hierdie onderwerp moet help. Die artikel trek parallelle met materiaal uit verskeie boeke oor programmering deur Schildt, Stroustrup, Okulov.
Die onderwerp oor siklusse is gekies omdat heelwat mense daarvan uitgesluit word wanneer hulle programmering bemeester.
Hierdie tegniek is ontwerp vir swak studente. As 'n reël sit sterk mense nie vas oor hierdie onderwerp nie en dit is nie nodig om spesiale tegnieke vir hulle uit te dink nie. Die sekondêre doel van die artikel is om hierdie tegniek van die "werk vir alle studente, maar slegs een onderwyser"-klas na die "werk vir alle studente, alle onderwysers"-klas te skuif. Ek maak nie aanspraak op absolute oorspronklikheid nie. As jy reeds 'n soortgelyke metodologie gebruik om hierdie onderwerp te onderrig, skryf asseblief hoe jou weergawe verskil. As jy besluit om dit te gebruik, vertel ons hoe dit gegaan het. As 'n soortgelyke tegniek in 'n boek beskryf word, skryf asseblief die naam.
Ek het vir 4 jaar aan hierdie tegniek gewerk en individueel met studente van verskillende opleidingsvlakke studeer. In totaal is daar ongeveer vyftig studente en tweeduisend uur se klasse. Aanvanklik het studente altyd oor hierdie onderwerp vasgeval en weggegaan. Na elke student is die metodologie en materiaal aangepas. Die afgelope jaar het studente nie meer vasgehaak oor hierdie onderwerp nie, daarom het ek besluit om my bevindinge te deel.
Hoekom so baie briewe? Siklusse is so elementêr!
Soos ek hierbo geskryf het, vir praktiserende ontwikkelaars en vir sterk studente, kan die kompleksiteit van die konsep van lusse onderskat word. Jy kan byvoorbeeld 'n lang lesing gee, knikkoppe en intelligente oë sien. Maar wanneer jy probeer om enige probleem op te los, begin stupor en onverklaarbare probleme. Na die lesing het die studente waarskynlik slegs 'n gedeeltelike begrip gehad. Die situasie word vererger deur die feit dat studente self nie kan uitspreek wat presies hul dwaling is nie.
Eendag het ek besef dat studente my voorbeelde as hiërogliewe beskou het. Dit wil sê, soos ondeelbare stukke teks waarin jy een of ander "magic" letter moet byvoeg en dit sal werk.
Soms het ek opgemerk dat studente dink dat jy nodig het om 'n spesifieke probleem op te los iets anders 'n ontwerp wat ek nog net nie gedek het nie. Alhoewel die oplossing slegs 'n geringe wysiging van die voorbeeld vereis het.
Ek het dus met die idee gekom dat die fokus nie op die sintaksis van uitdrukkings moet wees nie, maar op die idee om herhalende kode te herfaktoreer deur lusse te gebruik. Sodra studente hierdie idee bemeester het, kan enige sintaksis met min oefening verbeter word.
Wie en hoekom gee ek onderrig?
Aangesien daar geen toelatingseksamens is nie, kan klasse beide sterk en baie swak studente insluit. Jy kan meer oor my studente in die artikel lees
Ek het daarna gestreef om te verseker dat almal wat programmering wil leer, dit kan leer.
My klasse word individueel gehou en die student betaal sy eie geld vir elkeen. Dit wil voorkom asof studente koste sal optimeer en die minimum sal eis. Mense gaan egter na aangesig-tot-aangesig klasse met 'n lewende onderwyser nie vir die kennis self nie, maar vir die selfvertroue van wat hulle geleer het, vir 'n gevoel van vordering en vir goedkeuring van die deskundige (onderwyser). As studente nie vordering in hul leer voel nie, sal hulle vertrek. In die algemeen kan klasse so gestruktureer word dat studente vordering voel met die vermeerdering van die aantal bekende strukture. Dit wil sê, eers studeer ons terwyl in detail, dan studeer ons vir, dan doen ons, en nou het ons 'n duisend en een nag kursus gereed, waarin siklusse alleen vir twee maande bestudeer word, en aan die einde - 'n student wat geskryf het 'n standaard biblioteek onder diktee. Om praktiese probleme op te los, benodig jy egter nie net kennis van die materiaal nie, maar ook onafhanklikheid in die toepassing daarvan en in die soeke na nuwe inligting. Daarom, vir aangesig-tot-aangesig kursusse, dink ek die korrekte beginsel is om die minimum te onderrig en onafhanklike studie van nuanses en verwante onderwerpe aan te moedig. In die onderwerp van lusse beskou ek die while-konstruksie as die minimum. Jy kan die beginsel daaruit verstaan. As jy die beginsel ken, kan jy beide vir en doen-terwyl jouself bemeester.
Om die materiaal deur swak studente te bemeester, is dit nie genoeg om die sintaksis te beskryf nie. Dit is nodig om meer eenvoudige maar gevarieerde take te gee en voorbeelde in meer detail te beskryf. Uiteindelik word die spoed van ontwikkeling beperk deur die student se vermoë om uitdrukkings te transformeer en na patrone te soek. Vir slim studente sal die meeste opdragte vervelig wees. Wanneer jy saam met hulle studeer, hoef jy nie aan te dring om 100% van die probleme op te los nie. My materiaal kan besigtig word by . Dit is waar, die bewaarplek is meer soos 'n towenaar se grimoire - niemand behalwe ek sal verstaan wat waar is nie, en as jy die tjek druip, kan jy mal word
Die metodologie is praktykgerig
Die teorie word verduidelik aan die hand van die voorbeeld van die oplossing van 'n probleem. In 'n grondbeginsels van programmering klas waar takke en lusse onderrig word, is dit eenvoudig nie moontlik om 'n nuttige lesing oor een onderwerp vir 'n hele uur te gee nie. 15-20 minute is genoeg om die konsep te verduidelik. Die belangrikste probleme ontstaan wanneer praktiese take uitgevoer word.
Beginnende onderwysers kan operateurs, takke, lusse en skikkings in een lesing aframmel. Maar hul studente sal die probleem ondervind om hierdie inligting te assimileer.
Jy moet immers nie net die materiaal vertel nie, maar ook seker maak dat die luisteraars dit verstaan.
Die feit om 'n onderwerp te bemeester word bepaal deur hoe die student selfstandige werk hanteer.
As 'n student daarin geslaag het om 'n probleem oor 'n onderwerp op te los sonder die hulp van 'n onderwyser, dan is die onderwerp bemeester. Om selftoetsing te verseker, word elke taak in 'n tabel met toetsscenario's beskryf. Die take het 'n duidelike volgorde. Dit word nie aanbeveel om take oor te slaan nie. As die huidige taak te moeilik is, is dit nutteloos om na die volgende een te beweeg. Dit is selfs meer ingewikkeld. Sodat die student die huidige komplekse taak kan bemeester, word verskeie tegnieke aan hom verduidelik aan die hand van die voorbeeld van die eerste probleem. Eintlik kom die hele inhoud van die onderwerp neer op tegnieke om probleme te oorkom. Siklusse is meer 'n newe-effek.
Die eerste taak is altyd 'n voorbeeld. Die tweede verskil effens en word onmiddellik na die eerste onder toesig van 'n onderwyser "selfstandig" uitgevoer. Alle daaropvolgende take is daarop gemik om aandag te gee aan verskeie klein dingetjies wat wanopvattings kan veroorsaak.
Die verduideliking van die voorbeeld is 'n dialoog waarin die student voortplanting en kruisvalidering moet terugroep om seker te maak dat hy 'n gedeelte van die materiaal bemeester het.
Ek sal banaal wees en sê dat die eerste voorbeeld oor die onderwerp baie belangrik is. As jy die materiaal vir uitgebreide onafhanklike werk het, kan die weglatings van die eerste voorbeeld reggestel word. As daar niks anders behalwe die voorbeeld is nie, sal die student heel waarskynlik nie die onderwerp bemeester nie.
Terwyl of vir?
Een van die kontroversiële kwessies is die keuse van konstruksie vir die voorbeeld: terwyl of vir. Eenkeer het 'n praktiserende ontwikkelaarvriend van my sonder onderrigervaring 'n uur spandeer om my te oortuig dat die for-lus die maklikste is om te verstaan. Die argumente het neergekom op "alles daarin is duidelik en op sy plek uiteengesit." Die hoofoorsaak van probleme vir regte beginners is egter die idee van die siklus self, en nie die skryf daarvan nie. As 'n persoon nie hierdie idee verstaan nie, sal hy probleme ondervind met die sintaksis. Sodra die idee verwesenlik word, verdwyn die probleme van kodeontwerp vanself.
In my materiaal volg die tema van lusse die tema van vertakking. Die eksterne ooreenkoms van as en terwyl laat ons toe om 'n direkte analogie te trek: "wanneer die voorwaarde in die kopskrif waar is, dan word die liggaam uitgevoer." Die enigste eienaardigheid van die siklus is dat die liggaam baie keer uitgevoer word.
My tweede argument is dat terwyl minder formatering vereis as vir. Minder formatering beteken minder dom foute met ontbrekende kommas en hakies. Beginners het nog nie genoeg aandag en noukeurigheid ontwikkel om sintaksisfoute outomaties te vermy nie.
Die derde argument word in baie goeie boeke as die eerste argument verduidelik.
As die student uitdrukkings maklik kan transformeer, kan jy in die verbygaan daaroor praat. Die student sal dan kies waarvan hy die beste hou. As transformasies probleme veroorsaak, is dit beter om nie jou aandag af te lei nie. Laat die student eers alles oplos deur gebruik te maak van while. Sodra jy die onderwerp van lusse bemeester het, kan jy die oplossings herskryf om te oefen om te skakel terwyl na vir.
Postcondition-lusse is 'n redelik skaars dier. Ek spandeer glad nie tyd daaraan nie. As 'n student die idees bemeester het om patrone te identifiseer en uitdrukkings te transformeer, kan hy dit sonder my hulp uitvind.
Wanneer ek die eerste voorbeeld aan sterk studente demonstreer, vestig ek die aandag daarop dat dit in die eerste voorbeeld belangrik is om nie net die oplossing aan te teken nie, maar ook die hele ketting van aksies wat tot die resultaat gelei het. Lui studente kan die skryfwerk verwaarloos en slegs die finale algoritme kopieer. Hulle moet oortuig word dat daar eendag 'n moeilike taak oor hul pad sal kom. Om dit op te los, sal jy die stappe soos in hierdie voorbeeld moet volg. Daarom is dit belangrik om alle stadiums op te teken. In die volgende probleme sal dit moontlik wees om slegs die finale weergawe van die oplossing te verlaat.
Die hoofgedagte van outomatisering is dat ons 'n rekenaar toevertrou om roetinewerk vir 'n persoon te doen. Een van die basiese tegnieke is die skryf van lusse. Dit word gebruik wanneer verskeie identiese herhalende aksies in 'n program in 'n ry geskryf word.
Eksplisiet is beter as implisiet
Dit lyk dalk na 'n goeie idee om dieselfde frase verskeie kere in die eerste lus-taak te vertoon. Byvoorbeeld:
Hoera, dit werk!
Hoera, dit werk!
Hoera, dit werk!
Hoera, dit werk!
Hoera, dit werk!
Hoera, dit werk!
Hoera, dit werk!
Hoera, dit werk!
Hierdie opsie is sleg omdat die tellerwaarde nie in die uitvoer sigbaar is nie. Dit is 'n probleem vir beginners. Moenie haar onderskat nie. Aanvanklik was hierdie taak die eerste, en die taak om 'n reeks getalle in stygende volgorde af te lei was die tweede. Dit was nodig om addisionele terme "siklus N keer" en "siklus van A na B" in te voer, wat in wese dieselfde ding is. Om nie onnodige entiteite te skep nie, het ek besluit om slegs 'n voorbeeld te wys met die uitvoer van 'n reeks getalle. Min mense kry dit reg om sonder voorbereiding te leer hoe om 'n teller in hul kop te hou en die gedrag van 'n program in hul kop te modelleer. Sommige studente kry eers verstandelike modellering oor die onderwerp van siklusse.
Na 'n bietjie oefening gee ek die taak om dieselfde teks te herhaal om onafhanklik opgelos te word. As jy eers 'n sigbare toonbank gee en dan 'n onsigbare een, sal studente minder probleme hê. Soms is die wenk "moenie die toonbank op die skerm skryf nie" genoeg.
Hoe verduidelik ander dit?
In die meeste opvoedkundige materiaal op die internet word die sintaksis van die siklus gegee as deel van 'n "lesing". Byvoorbeeld, op developer.mozilla.org (tans), word verskeie ander konstrukte saam met die while-lus beskryf. In hierdie geval word slegs die ontwerpe self in die vorm van sjablone gegee. Die resultaat van hul bekendstelling word in woorde beskryf, maar daar is geen illustrasie nie. Na my mening vermenigvuldig so 'n aanbieding van die onderwerp die bruikbaarheid van sulke materiaal met nul. Die student kan die kode herskryf en dit self uitvoer, maar hy benodig steeds 'n standaard vir vergelyking. Hoe kan jy verstaan dat 'n voorbeeld korrek oorgeskryf is as daar niks is om die resultaat mee te vergelyk nie?
Wanneer slegs 'n sjabloon gegee word, sonder 'n voorbeeld, word dit nog moeiliker vir die student. Hoe om te verstaan dat die kodefragmente korrek in die sjabloon geplaas is? Jy kan probeer skryf op een of ander manier, en hardloop dan. Maar as daar geen standaard is om die resultaat te vergelyk nie, sal die bekendstelling ook nie help nie.
In die C++ kursus oor Intuïtief word die lussintaksis op die derde bladsy van Lesing 4 oor die onderwerp “operateurs” begrawe. Wanneer die sintaksis van lusse verduidelik word, word spesiale klem op die term "operateur" geplaas. Die term word aangebied as 'n stel feite soos "simbool; dit is 'n stelling", "{} is 'n saamgestelde stelling", "die liggaam van die lus moet 'n stelling wees". Ek hou nie van hierdie benadering nie, want dit lyk asof dit belangrike verhoudings agter een term wegsteek. Die ontleding van die bronkode van 'n program in terme op hierdie vlak is nodig deur samestellerontwikkelaars om die taalspesifikasie te implementeer, maar nie deur studente as 'n eerste benadering nie. Nuwelinge tot programmering is selde noukeurig genoeg om so baie aandag aan terme te gee. Dit is 'n seldsame persoon wat die eerste keer nuwe woorde onthou en verstaan. Byna niemand kan 'n term wat hulle pas geleer het, korrek toepas nie. Daarom kry studente baie foute soos "Ek het geskryf terwyl(a<7);{, maar die program werk nie."
Na my mening is dit aan die begin beter om die sintaksis van die konstruksie onmiddellik met hakies te gee. Die opsie sonder hakies moet slegs verduidelik word as die student 'n spesifieke vraag het: "hoekom is daar geen hakies nie en dit werk."
In Okulov se 2012-boek "Fundamentals of Programming," begin 'n inleiding tot lusse met die for-patroon, gee dan aanbevelings vir die gebruik daarvan, en gaan dan dadelik na die eksperimentele afdeling van die les. Ek verstaan dat die boek geskryf is vir daardie minderheid baie bekwame studente wat selde na my klasse toe kom.
In gewilde boeke word die resultaat van kodefragmente altyd geskryf. Byvoorbeeld, Shildt se "Java 8. The Complete Guide" 2015-uitgawe. Eerstens word 'n sjabloon gegee, dan 'n voorbeeldprogram en onmiddellik daarna - die resultaat van uitvoering.
As 'n voorbeeld, oorweeg 'n while-lus wat die omgekeerde doen
aftelling vanaf 10, en presies 10 reëls van "maatreëls" word vertoon://Продемонстрировать применение оператора цикла while class While { public static void main(String args []) { int n = 10; while (n > 0) { System.out.println("такт " + n); n--; } } }Sodra dit uitgevoer is, voer hierdie program tien "siklusse" soos volg uit:
такт 10
такт 9
такт 8
такт 7
такт 6
такт 5
такт 4
такт 3
такт 2
такт 1
Die benadering om 'n sjabloon, 'n voorbeeldprogram en die resultaat van die program te beskryf, word ook in die boek "Javascript for Kids" en in die js-kursus op w3schools.com gebruik. Die webbladformaat laat hierdie voorbeeld selfs interaktief wees.
Stroustrup se 2016-boek Principles and Practice Using C++ het selfs verder gegaan. Die eerste stap is om te verduidelik watter resultaat verkry moet word, en daarna word die teks van die program gewys. Boonop neem hulle nie net 'n lukrake program as voorbeeld nie, maar gee 'n uitstappie in die geskiedenis. Dit help om die aandag daarop te vestig: “Kyk, dit is nie net een of ander nuttelose teks nie. Jy sien iets betekenisvols.”
As 'n voorbeeld van iterasie, oorweeg die eerste program wat op 'n gestoorde programmasjien (EDSAC) uitgevoer is. Dit is geskryf deur David Wheeler by die Rekenaarlaboratorium van Cambridge Universiteit, Engeland op 6 Mei 1949. Hierdie program bereken en druk 'n eenvoudige lys van vierkante.
0 0
1 1
2 4
3 9
4 16
...
98 9604
99 9801
Hier bevat elke reël 'n getal gevolg deur 'n tabkarakter ('t') en die vierkant van daardie getal. Die C++ weergawe van hierdie program lyk soos volg://Вычисляем и распечатываем таблицу квадратов чисел 0-99 int main() { int i = 0; // Начинаем с нуля while(i < 100){ cout << i << 't' << square(i) << 'n'; ++i; } }
Interessant genoeg word die sintaksispatroon nie in hierdie boek beskryf nie. Stroustrup in die instrukteurshandleiding () beklemtoon dat dit die intelligensie van sy studente respekteer. Miskien word die vermoë om 'n patroon in verskeie voorbeelde te identifiseer beskou as 'n manifestasie van sulke intelligensie.
Soos ek myself verduidelik
Stroustrup se benadering: om die resultaat te beskryf, dan die probleem op te los, en dan 'n onafhanklike ontleding deur die student - lyk die mees deurdagte. Daarom het ek besluit om dit as 'n basis te neem, maar dit te vertel deur 'n minder historiese voorbeeld te gebruik - die taak om 'n "inhoudsopgawe" af te lei. Dit vorm ’n herkenbare anker sodat jy dan kan sê “onthou die taak oor die inhoudsopgawe” en sodat studente presies dit onthou. In my voorbeeld het ek probeer om nog twee van die mees algemene wanopvattings te voorkom. Volgende sal ek in meer besonderhede oor hulle skryf.
In hierdie taak word ons bekendgestel aan tegnieke om komplekse probleme op te los. Die aanvanklike besluit moet primitief en eenvoudig gemaak word. Wel, dan kan jy dink oor hoe om hierdie oplossing te verbeter.
Введение
Глава 1
Глава 2
Глава 3
Глава 4
Глава 5
Глава 6
Глава 7
Заключение
Volgens my waarnemings lei die "sjabloon-voorbeeld-resultaat"-benadering in verskeie kombinasies steeds daartoe dat studente die siklus as 'n hiëroglief beskou. Dit het gemanifesteer in die feit dat hulle nie verstaan het hoekom daar 'n voorwaarde was om daar te skryf, hoe om tussen i++ en i— en ander oënskynlik voor die hand liggende dinge te kies nie. Om hierdie wanopvattings te vermy, moet die benadering om oor siklusse te praat, die betekenis van die herhaling van identiese handelinge beklemtoon en eers dan die formalisering daarvan met behulp van 'n struktuur. Daarom, voordat u die lus-sintaksis gee, moet u die probleem reguit oplos. 'n Primitiewe oplossing vir die inhoudsopgawe probleem lyk soos volg:
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 dit verbeter word?
Vervang eentonige aksies met 'n siklus.
Watter aksies word in 'n ry herhaal sonder veranderinge?
Daar is geen in hierdie fragment nie. Die opdragte vir die vertoon van die woord "Hoofstuk" met 'n nommer is egter baie soortgelyk aan mekaar.
Daarom is die volgende fase om die verskil tussen die fragmente te vind. Dit is net in hierdie taak dat alles voor die hand liggend is, dan sal nie enkele opdragte herhaal word nie, maar blokke kode van 5 reëls of meer. Jy sal nie net in die lys van opdragte moet soek nie, maar in vertakkings- of luskonstruksies.
In die voorbeeld is die verskil tussen die opdragte in die nommer na die woord "Hoofstuk".
Sodra die verskil gevind is, moet jy die patroon van verandering verstaan. Die verskillende fragment is die getal? Neem dit voortdurend toe of neem dit af? Hoe verander die waarde van 'n getal tussen twee spanne langs mekaar?
In die voorbeeld neem die getal na die woord “Hoofstuk” toe in inkremente van 1. Die verskil word gevind, die patroon word geopenbaar. Nou kan jy die verskillende fragment met 'n veranderlike vervang.
Jy moet so 'n veranderlike verklaar voor die eerste van die herhalende fragmente. So 'n veranderlike word gewoonlik I of j of iets meer gedetailleerd genoem. Die aanvanklike waarde daarvan moet gelyk wees aan die eerste waarde wat op die skerm vertoon word. In die voorbeeld is die eerste waarde 1.
Watter aanvanklike waarde moet geneem word om die reeks getalle "100, 101, 102, 103, 104, 105" te vertoon?
Die eerste getal in hierdie reeks is 100.
Na elke uitvoerbevel moet jy die waarde van hierdie veranderlike met 1 verhoog. Hierdie eenheid is die veranderingstap.
Watter stap sal in die reeks getalle "100, 102, 104, 106" wees?
Stap 2 in hierdie ry.
Nadat die verskillende fragment met 'n veranderlike vervang is, sal die kode soos volg lyk:
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 jy die "druk die patroon van 'n veranderlike"-tegniek in die kode toegepas het, kry jy verskeie groepe identiese aksies wat in 'n ry gaan. Nou kan herhalende aksies met 'n siklus vervang word.
Die volgorde om 'n probleem op te los waar jy lusse moet gebruik, bestaan uit die volgende stappe:
- Los "kop-aan" op met baie afsonderlike opdragte
- Vind 'n patroon
- Druk die patroon van 'n veranderlike uit
- Ontwerp as 'n siklus
Vervolgens word nuwe terme ingestel sodat die student hom nie in die situasie bevind van "Ek verstaan alles, maar ek kan dit nie sê nie":
— 'n teller is altyd 'n veranderlike wat nodig is om die aantal stappe in 'n lus op te spoor. Tipies 'n heelgetal wat met die beperking vergelyk word.
— tellerstap — beskrywing van die patroon van toonbankveranderinge.
- beperking - 'n getal of veranderlike waarmee die teller vergelyk word sodat die algoritme finaal is. Die tellerwaarde verander om die limiet te nader.
— lusliggaam — 'n stel opdragte wat herhaal sal word. Wanneer hulle sê "die opdrag is binne 'n lus geskryf," bedoel hulle die liggaam.
— lusiterasie — eenmalige uitvoering van die lusliggaam.
— lustoestand — 'n logiese uitdrukking wat bepaal of 'n ander iterasie uitgevoer sal word. (Daar kan verwarring wees met vertakkingstrukture hier)
Jy moet daarop voorbereid wees dat studente aanvanklik terme vir ander doeleindes sal gebruik. Dit geld vir beide die sterk en die swak. Die vestiging van 'n gemeenskaplike taal is 'n kuns. Nou sal ek kortliks skryf: jy moet die taak stel "merk die kode fragment met <term>" en gebruik hierdie terme self korrek in gesprek.
Na transformasie met 'n lus word die fragment verkry:
Console.WriteLine("Введение");
int i = 0;
while (i < 7) {
Console.WriteLine("Глава " + i);
i = i + 1;
}
Console.WriteLine("Заключение");Die belangrikste wanopvatting
Een gewilde wanopvatting onder studente is dat hulle aksies binne 'n lus plaas wat net een keer gedoen hoef te word. Byvoorbeeld, soos volg:
;
int i = 0;
while (i < 7) {
Console.WriteLine("Введение")
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Заключение");
}
Studente loop heeltyd hierdie probleem teë, beide aan die begin en in meer komplekse probleme.
Sleutelwenk in hierdie geval:
Hoeveel keer moet jy die opdrag herhaal: een of baie keer?
Die opdragte om die woorde "Inleiding" en "Gevolgtrekking" te druk en die veranderlike i te verklaar en te inisialiseer, is nie soos ander herhalende aksies nie. Hulle word slegs een keer uitgevoer, wat beteken dat hulle buite die lusliggaam geskryf moet word.
Al drie fases van die oplossing moet in die kode bly sodat jy later daarna kan verwys in geval van probleme. Dit is genoeg om kommentaar te lewer op die eerste twee opsies sodat hulle nie inmeng nie.
Die student se aandag moet op die volgende feite gevestig word:
— In 'n lustoestand word 'n teller en 'n limiet gewoonlik vergelyk. Die teller kan in die liggaam van die lus verander, maar die limiet kan nie. Om hierdie reël te oortree, moet jy dwingende redes formuleer.
— Opdragte vir die vertoon van die woorde “Inleiding” en “Gevolgtrekking” is buite die liggaam van die lus geleë. Ons moet hulle 1 keer uitvoer. "Inleiding" - voordat die aksies herhaal word, "Gevolgtrekking" - daarna.
In die proses om hierdie onderwerp te konsolideer, die volgende te bemeester, sowel as om probleme te hanteer, is dit nuttig vir selfs sterk studente om die vraag te vra: “Hoeveel keer moet hierdie aksie uitgevoer word? Een of baie?
Ontwikkeling van bykomende vaardighede
In die proses van studiesiklusse ontwikkel studente ook die vaardigheid om probleme te diagnoseer en op te los. Om diagnose uit te voer, moet die student die gewenste resultaat aanbied en dit met die werklike resultaat vergelyk. Regstellende aksies hang af van die verskil tussen hulle.
Aangesien studente op hierdie stadium nog min idee het van die "gewenste" resultaat, kan hulle op toetsdata fokus. As 'n reël verstaan niemand in hierdie stadium nog wat verkeerd kan loop en hoe om dit te hanteer nie. Daarom skryf ek in 'n notaboek 'n beskrywing van tipiese probleme en verskeie maniere om dit op te los. Om die mees geskikte een te kies, is die taak van die student self.
'n Rekord is nodig om te vra "het wat verwag is gebeur?", "Watter van hierdie situasies het nou gebeur?", "Het die toegepaste oplossing gehelp?"
- Die aantal aksies is 1 minder of meer as wat verwag is. Oplossings:
- verhoog die aanvanklike waarde van die teller met 1.
— vervang die streng vergelykingsoperateur (< of >) met 'n nie-streng een (<= of >=).
— verander die limietwaarde na 1. - Aksies in 'n lus word sonder ophou uitgevoer, onbepaald. Oplossings:
- voeg 'n tellerverandering-opdrag by as dit ontbreek.
- maak die tellerverandering-opdrag reg sodat die waarde daarvan nader aan die limiet kom.
- verwyder die beperkingsverandering-opdrag as dit in die liggaam van die lus is. - Die aantal aksies in 'n lus is meer as 1 minder of meer as wat verwag is. Die aksie in die lus is nie een keer uitgevoer nie. Eerstens moet jy die werklike waardes van die veranderlikes uitvind net voor die lus begin. Oplossings:
— verander die aanvanklike waarde van die beperking
— verander die beginwaarde van die teller
Probleem 3 behels gewoonlik die gebruik van die verkeerde veranderlike of om die teller nie na nul terug te stel nie.
Na hierdie verduideliking kan die student steeds verskeie wanopvattings hê oor hoe lusse werk.
Om die algemeenste uit die weg te ruim, gee ek jou die volgende take:
- Waarin die limiet, aanvanklike tellerwaarde of tellerstap deur die gebruiker ingevoer word.
- Waarin die tellerwaarde in een of ander rekenkundige uitdrukking gebruik moet word. Dit is raadsaam om 'n teller in die radikale uitdrukking of in die noemer te gebruik sodat die verskil nie-lineêr is.
- Waarin die tellerwaarde nie op die skerm vertoon word terwyl die lus loop nie. Byvoorbeeld, om die vereiste aantal identiese teksfragmente te vertoon of 'n figuur met skilpadgrafika te teken.
- Waarin jy eers 'n paar herhalende aksies moet uitvoer, en dan ander.
- Waarin jy ander aksies moet uitvoer voor en na herhaling
Vir elke taak moet jy toetsdata en die verwagte resultaat verskaf.
Om te verstaan hoe vinnig jy kan beweeg, moet jy die terme van hierdie probleme lees en vra: "hoe verskil hulle van die voorbeeld?", "Wat moet in die voorbeeld verander word om dit op te los?" As die student sinvol antwoord, laat hom dan ten minste een in die klas oplos, en die res by die huis op sy eie. As die oplossing suksesvol is, kan ons die toestande binne die lusse begin verduidelik.
As jy probleme ondervind om probleme op jou eie op te los, moet jy alles in die klas deurwerk. Om te verhoed dat die oplossing van die probleem aan die teken van 'n uil herinner, beveel ek aan om eers die probleem op 'n nie-universele manier op te los. Dit wil sê, sodat die oplossing die eerste toets slaag en nie die luskonstruksie gebruik nie. Wel, pas dan transformasies toe om universaliteit van die oplossing te bereik.
Lusse en takke
Na my mening is dit nuttig om die onderwerp "siklusse binne takke" afsonderlik te gee. Sodat jy later die verskil kan sien tussen om 'n toestand verskeie kere na te gaan en om dit een keer na te gaan.
Die take vir konsolidasie gaan oor die uitvoer van getalle van A na B, wat deur die gebruiker ingevoer word:
- altyd in stygende volgorde.
- stygende of dalende, afhangende van die waardes van A en B.
Die onderwerp van "vertakking binne lusse" moet eers aanbeweeg word nadat die student die tegnieke bemeester het: "vervang 'n patroon met 'n veranderlike" en "vervang herhalende aksies met 'n siklus."
Die hoofrede vir die gebruik van takke binne lusse is anomalieë in die patroon. In die middel breek dit na gelang van die aanvanklike data.
Vir daardie studente wat in staat is om 'n oplossing te soek deur eenvoudige tegnieke te kombineer, is dit genoeg om te sê "vertakking kan binne lusse geskryf word" en gee die probleem "byvoorbeeld" heeltemal om onafhanklik op te los.
Voorbeeld taak:
Die gebruiker voer die getal X in. Vertoon die nommers van 0 tot 9 in 'n kolom en plaas 'n '+'-teken oorkant die getal wat gelyk is aan X.
As 0 ingevoer is0+
1
2
3
4
5
6
7
8
9
As 6 ingevoer is0
1
2
3
4
5
6+
7
8
9
As 9 ingevoer is0
1
2
3
4
5
6
7
8
9+
As 777 ingevoer is0
1
2
3
4
5
6
7
8
9
As 'n kort verduideliking nie genoeg is om met 'n lus te skryf nie, moet u 'n universele oplossing vir dieselfde probleem sonder 'n lus kry.
Jy sal een van twee opsies kry:
Verlang
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);
}
Moontlik
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+");
}
Ek gee vooraf 'n soortgelyke taak, terwyl ek die onderwerp van vertakking bestudeer.
As die student met 'n "moontlike" opsie vorendag kom, dan moet jy vir hulle sê dat daar baie oplossings vir dieselfde probleem kan wees. Hulle verskil egter in hul weerstand teen veranderinge in vereistes. Vra die vraag: "Hoeveel plekke in die kode sal reggestel moet word as ek nog 'n nommer moet byvoeg?" In die "moontlike" weergawe sal jy nog een tak moet byvoeg en 'n nuwe nommer op 10 ander plekke moet byvoeg. In die "gewenste" is dit genoeg om net een tak by te voeg.
Stel die taak om die "gewenste" opsie te reproduseer, vind dan 'n patroon in die kode, voer 'n veranderlike vervanging uit en skryf 'n lus.
As jy 'n idee het oor hoe om hierdie probleem op 'n ander manier sonder 'n lus op te los, skryf asseblief in die kommentaar.
Lusse binne Lusse
In hierdie onderwerp moet jy aandag gee aan die volgende:
— tellers vir die binneste en buitenste lusse moet verskillende veranderlikes wees.
— die teller vir die binnelus moet baie keer teruggestel word (dit wil sê in die liggaam van die buitenste lus).
— in teksuitvoertake kan jy nie eers een letter in verskeie reëls skryf nie, en dan die tweede. Jy moet eers al die letters van die eerste reël druk, dan al die letters van die tweede, ensovoorts.
Dit is die beste om die onderwerp van lusse binne lusse te begin verduidelik deur te verduidelik hoe belangrik dit is om die teller na nul terug te stel.
Voorbeeld taak:
Die gebruiker voer twee nommers in: R en T. Druk twee reëls van "#" karakters. Die eerste reël moet R karakters bevat. Die tweede reël bevat T-stukke. As enige getal negatief is, vertoon 'n foutboodskap.
R=5, T=11#####
###########
R=20, T=3#####################
# # #
R=-1, T=6Die R-waarde moet nie-negatief wees
R=6, T=-2T-waarde moet nie-negatief wees
Uiteraard het hierdie probleem ook ten minste twee oplossings.
Verlang
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;
}
Moontlike #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;
}
Die verskil is dat in die "moontlike" oplossing 'n tweede veranderlike gebruik is om die tweede reël uit te voer. Jy moet daarop aandring om dieselfde veranderlike vir beide lusse te gebruik. Hierdie beperking kan geregverdig word deur die feit dat 'n oplossing met een teller vir twee siklusse 'n illustrasie van die term "tellerterugstelling" sal wees. Dit is nodig om hierdie term te verstaan wanneer die volgende probleme opgelos word. As 'n kompromie kan jy albei oplossings vir die probleem stoor.
'n Tipiese probleem met die gebruik van een tellerveranderlike vir twee lusse lyk soos volg:
R=5, T=11#####
######
Die aantal karakters in die tweede reël stem nie ooreen met die waarde van T nie. As jy hulp nodig het met hierdie probleem, moet jy na die aantekeninge oor tipiese probleme met lusse kyk. Dit is simptoom #3. Dit word gediagnoseer as jy 'n tellerwaarde-uitset onmiddellik voor die tweede siklus byvoeg. Reggestel deur terug te stel. Maar dit is beter om dit nie dadelik te vertel nie. Die student moet probeer om ten minste een hipotese te formuleer.
Daar is natuurlik 'n ander oplossing. Maar ek het dit nog nooit onder studente gesien nie. In die stadium van die bestudering van siklusse sal die storie daaroor die aandag aftrek. Jy kan later terugkom na dit wanneer jy leer oor string funksies.
Moontlike #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:
Vertoon die getalle van 0 tot 9. Elke getal moet op sy eie lyn wees. Die aantal syfers in 'n reël (W) word vanaf die sleutelbord ingevoer.
W=10
1
2
3
4
5
6
7
8
9
W=100000000000
1111111111
2222222222
3333333333
4444444444
5555555555
6666666666
7777777777
8888888888
9999999999
As 'n student die tegniek bemeester het om 'n veranderlike te vervang, sal hy redelik vinnig klaarkom. 'n Moontlike probleem sal weer wees om die veranderlike terug te stel. As jy nie die transformasie kan hanteer nie, beteken dit dat jy haastig was en eenvoudiger probleme moet oplos.
Dankie vir jou aandag. Like en teken in op die kanaal.
NS As jy tikfoute of foute in die teks vind, laat weet my asseblief. Dit kan gedoen word deur 'n gedeelte van die teks te kies en "⌘ + Enter" op Mac te druk, en "Ctrl / Enter" op klassieke sleutelborde, of deur privaat boodskappe. As hierdie opsies nie beskikbaar is nie, skryf oor foute in die kommentaar. Dankie!
Slegs geregistreerde gebruikers kan aan die opname deelneem. , asseblief.
Opiniepeiling vir lesers sonder karma
-
20,0%Ek gee professioneel onderrig, +12
-
10,0%Ek gee professioneel onderrig, -11
-
70,0%Ek gee nie onderrig nie, +17
-
0,0%Ek gee nie onderrig nie, -10
-
0,0%Ander 0
10 gebruikers het gestem. 5 gebruikers het buite stemming gebly.
Bron: will.com