Nettsjinsteande it feit dat wy sille prate oer ien fan de basis ûnderwerpen, dit artikel is skreaun foar betûfte professionals. It doel is om te sjen hokker misferstannen begjinners hawwe yn programmearring. Foar praktisearjende ûntwikkelders binne dizze problemen al lang oplost, fergetten of hielendal net opmurken. It artikel kin fan pas komme as jo ynienen ien helpe moatte mei dit ûnderwerp. It artikel lûkt parallellen mei materiaal út ferskate boeken oer programmearring fan Schildt, Stroustrup, Okulov.
It ûnderwerp oer syklussen is keazen om't in protte minsken der by it behearskjen fan programmearring fan útsletten wurde.
Dizze technyk is ûntwurpen foar swakke studinten. As regel, sterke minsken sitte net fêst op dit ûnderwerp en it is net nedich om te kommen mei spesjale techniken foar harren. It sekundêre doel fan it artikel is om dizze technyk te ferpleatsen fan 'e klasse "wurken foar alle studinten, mar mar ien learaar" nei de klasse "wurken foar alle studinten, alle leararen". Ik beweare gjin absolute orizjinaliteit. As jo al in ferlykbere metodyk brûke om dit ûnderwerp te learen, skriuw dan asjebleaft hoe't jo ferzje ferskilt. As jo beslute om it te brûken, fertel ús hoe't it gie. As in ferlykbere technyk beskreaun wurdt yn in boek, skriuw dan de namme.
Ik wurke oan dizze technyk foar 4 jier, studearre yndividueel mei studinten fan ferskate nivo's fan oplieding. Yn totaal binne der sa'n fyftich learlingen en twatûzen oeren les. Yn it earstoan stiene studinten altyd fêst op dit ûnderwerp en gongen fuort. Nei elke studint binne de metodyk en materialen oanpast. It ôfrûne jier binne studinten net mear fêst sitten op dit ûnderwerp, dus ik besleat myn befinings te dielen.
Wêrom safolle letters? Cycles binne sa elemintêr!
Lykas ik hjirboppe skreau, foar praktisearjende ûntwikkelders en foar sterke studinten, kin de kompleksiteit fan it konsept fan loops ûnderskatte wurde. Jo kinne bygelyks in lange lêzing jaan, knikke hollen en yntelliginte eagen sjen. Mar as jo besykje elk probleem op te lossen, begjinne stupor en ûnferklearbere problemen. Nei de lêzing hiene studinten wierskynlik mar in part ferstân. De situaasje wurdt fergrutte troch it feit dat studinten sels net kinne útsprekke wat krekt har waan is.
Op in dei realisearre ik dat studinten myn foarbylden as hiëroglyfen waarnommen. Dat is, lykas ûndielbere stikken tekst wêryn jo wat "magyske" letter moatte tafoegje en it sil wurkje.
Soms haw ik opfallen dat studinten tinke dat jo nedich binne om in spesifyk probleem op te lossen wat oars in ûntwerp dat ik gewoan noch net besprutsen haw. Hoewol't de oplossing fereasket mar in lytse feroaring fan it foarbyld.
Dat ik kaam op it idee dat de fokus net soe wêze moatte op 'e syntaksis fan útdrukkingen, mar op it idee fan refaktorearjen fan repetitive koade mei loops. Sadree't studinten hawwe behearsket dit idee, eltse syntaksis kin wurde ferbettere mei in bytsje praktyk.
Wa en wêrom lear ik?
Om't d'r gjin yngongseksamen binne, kinne klassen sawol sterke as heul swakke studinten omfetsje. Jo kinne mear lêze oer myn learlingen yn it artikel
Ik stribbe dernei om te soargjen dat elkenien dy't programmearring leare wol it leare kin.
Myn lessen wurde yndividueel hâlden en de studint betellet foar elk syn eigen jild. It liket derop dat studinten de kosten sille optimalisearje en it minimum easkje. Minsken geane lykwols nei face-to-face lessen mei in live learaar net foar de kennis sels, mar foar it fertrouwen fan wat se leard hawwe, foar in gefoel fan foarútgong en foar goedkarring fan de saakkundige (learaar). As learlingen gjin foarútgong fiele yn har learen, sille se fuortgean. Yn 't algemien kinne klassen sa struktureare wurde dat learlingen foarútgong fiele by it fergrutsjen fan it oantal fertroude struktueren. Dat is, earst studearje wy wylst yn detail, dan studearje wy foar, dan dogge wy, en no hawwe wy tûzen en ien nacht kursus klear, wêryn't twa moannen allinich syklussen bestudearre wurde, en oan 'e ein - in studint dy't skreau in standert bibleteek ûnder diktee. Om lykwols praktyske problemen op te lossen, hawwe jo net allinich kennis fan it materiaal nedich, mar ek ûnôfhinklikens yn har tapassing en yn it sykjen nei nije ynformaasje. Dêrom, foar face-to-face kursussen, tink ik dat it juste prinsipe is om it minimum te learen en unôfhinklike stúdzje fan nuânses en relatearre ûnderwerpen oan te moedigjen. Yn it ûnderwerp fan loops beskôgje ik de konstruksje wylst it minimum is. Jo kinne it prinsipe derút begripe. Troch it prinsipe te kennen, kinne jo sawol foar as dwaan-wylst josels behearskje.
Om behearsking fan it materiaal te berikken troch swakke learlingen, is it beskriuwen fan de syntaksis net genôch. It is nedich om ienfâldiger, mar farieare taken te jaan en foarbylden yn mear detail te beskriuwen. Uteinlik wurdt de snelheid fan ûntwikkeling beheind troch it fermogen fan 'e studint om útdrukkingen te transformearjen en patroanen te sykjen. Foar tûke studinten sille de measte opdrachten saai wêze. As jo mei har studearje, hoege jo net oan te stean om 100% fan 'e problemen op te lossen. Myn materiaal is te besjen op . Wier, it repository liket mear op 'e grimoire fan in warlock - gjinien útsein ik sil begripe wat wêr is, en as jo de kontrôle mislearje, kinne jo gek wurde
De metodyk is praktykrjochte
De teory wurdt útlein mei it foarbyld fan it oplossen fan in probleem. Yn in basis fan programmearring klasse dêr't tûken en loops wurde leard, is it gewoan net mooglik om te jaan in nuttige lêzing oer ien ûnderwerp foar in hiele oere. 15-20 minuten is genôch om it konsept út te lizzen. De wichtichste swierrichheden ûntsteane by it útfieren fan praktyske taken.
Begjinnende learkrêften kinne operators, tûken, loops en arrays yn ien lêzing rammelje. Mar har studinten sille it probleem hawwe om dizze ynformaasje te assimilearjen.
It is needsaaklik net allinich it materiaal te fertellen, mar ek om te soargjen dat de harkers it begripe.
It feit fan it behearjen fan in ûnderwerp wurdt bepaald troch hoe't de studint omgaat mei selsstannich wurk.
As in studint slagge om in probleem op in ûnderwerp op te lossen sûnder de help fan in learaar, dan is it ûnderwerp behearske. Om selstesten te garandearjen, wurdt elke taak beskreaun yn in tabel mei testsenario's. De taken hawwe in dúdlike oarder. It oerslaan fan taken is net oan te rieden. As de hjoeddeistige taak te dreech is, dan is it oergean nei de folgjende nutteloos. It is noch yngewikkelder. Sadat de studint kin behearskje de hjoeddeiske komplekse taak, ferskate techniken wurde útlein oan him mei help fan it foarbyld fan it earste probleem. Eins komt de hiele ynhâld fan it ûnderwerp del op techniken om swierrichheden te oerwinnen. Cycles binne mear in side-effekt.
De earste taak is altyd in foarbyld. De twadde ferskilt in bytsje en wurdt útfierd "selsstannich" fuort nei de earste ûnder tafersjoch fan in learaar. Alle folgjende taken binne rjochte op omtinken foar ferskate lytse dingen dy't misferstannen kinne feroarsaakje.
De taljochting fan it foarbyld is in dialooch wêryn't de studint propagaasje en krúsvalidaasje weromroppe moat om der wis fan te wêzen dat hy in diel fan it materiaal behearske hat.
Ik sil banaal wêze en sizze dat it earste foarbyld oer it ûnderwerp tige wichtich is. As jo it materiaal hawwe foar wiidweidich selsstannich wurk, kinne de weglatingen fan it earste foarbyld korrizjearre wurde. As d'r neat oars is as it foarbyld, dan sil de studint it ûnderwerp nei alle gedachten net behearskje.
Wylst of foar?
Ien fan de kontroversjele saken is de kar fan konstruksje foar it foarbyld: wylst of foar. Ienris hat in praktisearjende ûntwikkeldersfreon fan my sûnder learûnderfining in oere trochbrocht om my te oertsjûgjen dat de for-loop it maklikst te begripen wie. De arguminten sieten del op "alles dêryn is dúdlik en op syn plak pleatst." De woartel oarsaak fan swierrichheden foar echte begjinners is lykwols it heule idee fan 'e syklus, en net har skriuwen. As in persoan dit idee net begrypt, dan sil hy muoite hawwe mei de syntaksis. Sadree't it idee realisearre is, ferdwine de problemen fan koade-ûntwerp op har eigen.
Yn myn materialen folget it tema fan loops it tema fan branching. De eksterne oerienkomst fan as en wylst lit ús in direkte analogy tekenje: "as de betingst yn 'e koptekst wier is, dan wurdt it lichem útfierd." De ienige eigenaardichheid fan 'e syklus is dat it lichem in protte kearen útfierd wurdt.
Myn twadde argumint is dat wylst fereasket minder opmaak dan foar. Minder opmaak betsjut minder domme flaters mei ûntbrekkende komma's en haakjes. Begjinners hawwe noch net genôch oandacht en soarchfâldichheid ûntwikkele om syntaksisflaters automatysk te foarkommen.
It tredde argumint wurdt yn in protte goede boeken ferklearre as it earste argumint.
As de studint maklik útdrukkingen kin transformearje, dan kinne jo foarby prate. De studint sil dan kieze wat er it bêste fynt. As transformaasjes swierrichheden feroarsaakje, dan is it better om jo oandacht net ôf te lieden. Lit de studint earst alles oplosse mei wylst. Sadree't jo hawwe behearsket it ûnderwerp fan loops, kinne jo herskriuwe de oplossings te oefenjen konvertearjen wylst foar.
Postcondition loops binne in frij seldsum bist. Ik besteegje der hielendal gjin tiid oan. As in studint de ideeën hat behearske fan it identifisearjen fan patroanen en it transformearjen fan útdrukkingen, kin hy it útfine sûnder myn help.
By it demonstrearjen fan it earste foarbyld oan sterke studinten, meitsje ik de oandacht op it feit dat it yn it earste foarbyld wichtich is om net allinich de oplossing op te nimmen, mar ek de hiele keatling fan aksjes dy't liede ta it resultaat. Lazy studinten kinne it skriuwen negearje en allinich it definitive algoritme kopiearje. Se moatte derfan oertsjûge wurde dat der ien dei in drege taak op harren wei komt. Om it op te lossen, moatte jo de stappen folgje lykas yn dit foarbyld. Dêrom is it wichtich om alle stadia op te nimmen. Yn 'e folgjende problemen sil it mooglik wêze om allinich de definitive ferzje fan' e oplossing te ferlitten.
It haadidee fan automatisearring is dat wy in kompjûter tafertrouwe om routine wurk foar in persoan te dwaan. Ien fan 'e basistechniken is it skriuwen fan loops. It wurdt brûkt as ferskate identike werheljende aksjes wurde skreaun yn in programma op in rige.
Eksplisyt is better as ymplisyt
It kin lykje as in goed idee om deselde sin meardere kearen werjaan yn de earste looping taak. Bygelyks:
Hoera, it wurket!
Hoera, it wurket!
Hoera, it wurket!
Hoera, it wurket!
Hoera, it wurket!
Hoera, it wurket!
Hoera, it wurket!
Hoera, it wurket!
Dizze opsje is min omdat de tellerwearde net sichtber is yn 'e útfier. Dit is in probleem foar begjinners. Underskatte har net. Earst wie dizze taak de earste, en de taak om in rige nûmers yn oprinnende folchoarder ôf te lieden wie de twadde. It wie nedich om ekstra termen "syklus N kear" en "syklus fan A nei B" yn te fieren, dy't yn essinsje itselde binne. Om gjin ûnnedige entiteiten te meitsjen, besleat ik allinich in foarbyld sjen te litten mei de útfier fan in searje nûmers. Net folle minsken leare hoe't se in teller yn 'e holle hâlde en it gedrach fan in programma yn' e holle sûnder tarieding modellearje. Guon studinten komme earst mentale modellering tsjin oer it ûnderwerp fan syklusen.
Nei wat oefening jou ik de taak om deselde tekst te herheljen om selsstannich op te lossen. As jo earst in sichtbere teller jouwe en dan in ûnsichtbere, sille studinten minder problemen hawwe. Soms is de hint "skriuw de teller net op it skerm" genôch.
Hoe ferklearje oaren it?
Yn de measte edukative materialen op it ynternet wurdt de syntaksis fan 'e syklus jûn as ûnderdiel fan in "lêzing". Bygelyks, op developer.mozilla.org (op it stuit) wurde ferskate oare konstruksjes beskreaun tegearre mei de while-loop. Yn dit gefal wurde allinich de ûntwerpen sels jûn yn 'e foarm fan sjabloanen. It resultaat fan har lansearring wurdt beskreaun yn wurden, mar d'r is gjin yllustraasje. Neffens my fermannichfâldigt sa'n presintaasje fan it ûnderwerp it nut fan sokke materialen mei nul. De studint kin de koade opnij skriuwe en sels útfiere, mar hy hat noch in standert nedich foar ferliking. Hoe kinne jo begripe dat in foarbyld goed oerskreaun is as der neat is om it resultaat mei te fergelykjen?
As allinnich in sjabloan wurdt jûn, sûnder in foarbyld, wurdt it noch dreger foar de studint. Hoe te begripen dat de koade fragminten wurde pleatst korrekt yn it sjabloan? Jo kinne besykje te skriuwen ien of oare manier, en dan rinne. Mar as d'r gjin standert is om it resultaat te fergelykjen, dan sil it lansearjen ek net helpe.
Yn 'e C ++ kursus oer yntuïtyf wurdt de loopsyntaksis begroeven yn' e tredde side fan lêzing 4 oer it ûnderwerp "operators". By it ferklearjen fan de syntaksis fan loops wurdt spesjaal klam lein op de term "operator". De term wurdt presintearre as in set fan feiten lykas "symboal; dit is in ferklearring", "{} is in gearstalde ferklearring", "it lichem fan 'e lus moat in ferklearring wêze". Ik hâld net fan dizze oanpak omdat it liket te ferbergjen wichtige relaasjes efter ien term. It parsearjen fan de boarnekoade fan in programma yn termen op dit nivo is nedich troch kompilatorûntwikkelders om de taalspesifikaasje út te fieren, mar net troch studinten as in earste oanwizing. Nijkommers yn programmearring binne komselden sekuer genôch om sa goed omtinken te jaan oan termen. It is in seldsum persoan dy't de earste kear nije wurden ûnthâldt en begrypt. Hast gjinien kin in term dy't se krekt leard hawwe korrekt tapasse. Dêrom krije studinten in protte flaters lykas "Ik skreau wylst (a<7);{, mar it programma wurket net."
Neffens my is it oan it begjin better om de syntaksis fan de konstruksje daliks mei heakjes te jaan. De opsje sûnder heakjes moat allinich útlein wurde as de studint in spesifike fraach hat: "wêrom is der gjin heakjes en it wurket."
Yn Okulov's 2012-boek "Fundamentals of Programming", begjint in ynlieding foar loops mei it for-patroan, jout dan oanbefellings foar it gebrûk, en giet dan daliks nei it eksperimintele diel fan 'e les. Ik begryp dat it boek skreaun is foar dy minderheid fan tige bekwame studinten dy't komselden nei myn lessen komme.
Yn populêre boeken wurdt it resultaat fan koadefragminten altyd skreaun. Bygelyks, Shildt syn "Java 8. The Complete Guide" 2015 edysje. Earst wurdt in sjabloan jûn, dan in foarbyldprogramma en fuort dêrnei - it resultaat fan útfiering.
As foarbyld, beskôgje in while-loop dy't it omkearde docht
countdown begjinnend fan 10, en krekt 10 rigels fan "maatregels" wurde werjûn://Продемонстрировать применение оператора цикла while class While { public static void main(String args []) { int n = 10; while (n > 0) { System.out.println("такт " + n); n--; } } }Ienris útfiert dit programma tsien "syklusen" as folget:
такт 10
такт 9
такт 8
такт 7
такт 6
такт 5
такт 4
такт 3
такт 2
такт 1
De oanpak fan it beskriuwen fan in sjabloan, in foarbyldprogramma en it resultaat fan dit programma wurdt ek brûkt yn it boek "Javascript for Kids" en yn 'e js-kursus op w3schools.com. It websideformaat lit dit foarbyld sels ynteraktyf wêze.
Stroustrup's 2016-boek Principles and Practice Using C++ gie noch fierder. De earste stap is om út te lizzen hokker resultaat moat wurde krigen, en dêrnei wurdt de tekst fan it programma werjûn. Boppedat nimme se net allinnich in willekeurich programma as foarbyld, mar jouwe in ekskurzje yn de skiednis. Dat helpt om der de oandacht op te lûken: “Sjoch, dit is net samar in nuttelose tekst. Jo sjogge wat betsjuttings."
As foarbyld fan iteraasje, beskôgje it earste programma útfierd op in opslein programma masine (EDSAC). It waard skreaun troch David Wheeler oan it Computer Laboratory fan Cambridge University, Ingelân op 6 maaie 1949. Dit programma berekkent en printet in ienfâldige list mei kwadraten.
0 0
1 1
2 4
3 9
4 16
...
98 9604
99 9801
Hjir, elke rigel befettet in nûmer folge troch in ljepper karakter ('t') en it fjouwerkant fan dat getal. De C ++ ferzje fan dit programma sjocht der sa út://Вычисляем и распечатываем таблицу квадратов чисел 0-99 int main() { int i = 0; // Начинаем с нуля while(i < 100){ cout << i << 't' << square(i) << 'n'; ++i; } }
Opfallend is dat it syntaksispatroan net yn dit boek beskreaun wurdt. Stroustrup yn it ynstrukteur's hânboek () beklammet dat it de yntelliginsje fan har learlingen respektearret. Faaks wurdt de mooglikheid om in patroan te identifisearjen yn ferskate foarbylden beskôge as in manifestaasje fan sokke yntelliginsje.
As ik mysels útlizze
De oanpak fan Stroustrup: it beskriuwen fan it resultaat, dan it probleem oplosse, en dan in ûnôfhinklike analyze troch de studint - liket it meast trochtochte. Dêrom besleat ik it as basis te nimmen, mar fertel it mei in minder histoarysk foarbyld - de taak om in "ynhâldsopjefte" te heljen. It foarmet in werkenber anker sadat jo dan sizze kinne "ûnthâld de taak oer de ynhâldsopjefte" en sadat learlingen dit krekt ûnthâlde. Yn myn foarbyld besocht ik noch twa fan 'e meast foarkommende misferstannen te foarkommen. Folgjende sil ik yn mear detail oer har skriuwe.
Yn dizze taak wurde wy yntrodusearre oan techniken foar it oplossen fan komplekse problemen. It earste beslút moat primityf en ienfâldich makke wurde. No, dan kinne jo tinke oer hoe't jo dizze oplossing ferbetterje kinne.
Введение
Глава 1
Глава 2
Глава 3
Глава 4
Глава 5
Глава 6
Глава 7
Заключение
Neffens myn waarnimmings liedt de "sjabloan-foarbyld-resultaat" oanpak yn ferskate kombinaasjes noch altyd ta it feit dat learlingen de syklus as in hiëroglyf waarnimme. Dat blykte út it feit dat se net begrepen wêrom't der in betingst wie om dêr te skriuwen, hoe te kiezen tusken i++ en i— en oare skynber foar de hân lizzende dingen. Om dizze misferstannen te foarkommen, moat de oanpak fan it praten oer syklusen de betsjutting fan it werheljen fan identike aksjes beklamje en allinich dan formalisearje se mei in struktuer. Dêrom, foardat jo de loop-syntaksis jouwe, moatte jo it probleem direkt oplosse. In primitive oplossing foar it probleem mei de ynhâldsopjefte sjocht der sa út:
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 kin it ferbettere wurde?
Ferfange monotone aksjes mei in syklus.
Hokker aksjes wurde op in rige werhelle sûnder feroarings?
D'r binne gjinien yn dit fragmint. De kommando's foar it werjaan fan it wurd "Haadstik" mei in nûmer lykje lykwols tige op elkoar.
Dêrom is de folgjende poadium om it ferskil tusken de fragminten te finen. It is allinich yn dizze taak dat alles dúdlik is, dan wurde gjin inkele kommando's werhelle, mar blokken fan koade fan 5 rigels of mear. Jo moatte net allinich sykje yn 'e list mei kommando's, mar yn fertakkings- of loopkonstruksjes.
Yn it foarbyld is it ferskil tusken de kommando's yn it nûmer nei it wurd "Haadstik".
As it ferskil ienris fûn is, moatte jo it patroan fan feroaring begripe. De ferskillende fragmint is it getal? Is it hieltyd mear of minder? Hoe feroaret de wearde fan in nûmer tusken twa teams njonken inoar?
Yn it foarbyld nimt it nûmer nei it wurd "Haadstik" ta yn stappen fan 1. It ferskil is fûn, it patroan wurdt iepenbiere. No kinne jo it ferskillende fragmint ferfange troch in fariabele.
Jo moatte sa'n fariabele ferklearje foardat de earste fan 'e werhellende fragminten. Sa'n fariabele wurdt meastal I of j neamd of wat mear detaillearre. De begjinwearde moat gelyk wêze oan de earste wearde werjûn op it skerm. Yn it foarbyld is de earste wearde 1.
Hokker begjinwearde moat wurde nommen om de searje nûmers "100, 101, 102, 103, 104, 105" wer te jaan?
It earste nûmer yn dizze searje is 100.
Nei eltse útfier kommando, Jo moatte fergrutsje de wearde fan dizze fariabele mei 1. Dizze ienheid is de feroaring stap.
Hokker stap sil wêze yn 'e rige fan nûmers "100, 102, 104, 106"?
Stap 2 yn dizze rige.
Nei it ferfangen fan it ferskillende fragmint mei in fariabele, sil de koade der sa útsjen:
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("Заключение");
Nei it tapassen fan de technyk "ekspresje it patroan fan in fariabele" yn 'e koade, krije jo ferskate groepen identike aksjes dy't op in rige gean. No kinne werhelle aksjes wurde ferfongen troch in lus.
De folchoarder fan it oplossen fan in probleem wêr't jo loops moatte brûke, bestiet út de folgjende stappen:
- Oplosse head-on mei in protte aparte kommando's
- Sykje in patroan
- Express it patroan fan in fariabele
- Arrangearje as in syklus
Dêrnei wurde nije termen ynfierd, sadat de studint himsels net yn 'e situaasje fynt fan "Ik begryp alles, mar ik kin it net sizze":
- in teller is altyd in fariabele dy't nedich is om it oantal stappen yn in loop te folgjen. Typysk in hiel getal dat wurdt fergelike mei de beheining.
- counter stap - beskriuwing fan it patroan fan counter feroarings.
- beheining - in getal of fariabele wêrmei de teller wurdt fergelike sadat it algoritme is definityf. De tellerwearde feroaret om de limyt te benaderjen.
- loop body - in set fan kommando's dy't sille wurde werhelle. As se sizze "it kommando is yn in lus skreaun", betsjutte se it lichem.
- loop iteraasje - ienmalige útfiering fan it loop lichem.
- loop condition - in logyske útdrukking dy't bepaalt oft in oare iteraasje sil wurde útfierd. (D'r kin hjir betizing wêze mei fertakkingsstruktueren)
Jo moatte ree wêze op it feit dat studinten earst termen sille brûke foar oare doelen. Dat jildt foar sawol de sterke as de swakken. It oprjochtsjen fan in mienskiplike taal is in keunst. No sil ik koart skriuwe: jo moatte de taak "markearje it koadefragmint mei <term>" ynstelle en dizze termen sels korrekt brûke yn petear.
Nei transformaasje mei in loop wurdt it fragmint krigen:
Console.WriteLine("Введение");
int i = 0;
while (i < 7) {
Console.WriteLine("Глава " + i);
i = i + 1;
}
Console.WriteLine("Заключение");De wichtichste misfetting
Ien populêre misfetting ûnder studinten is dat se aksjes pleatse yn in loop dy't mar ien kear dien wurde moatte. Bygelyks as dit:
;
int i = 0;
while (i < 7) {
Console.WriteLine("Введение")
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Заключение");
}
Learlingen komme hieltyd yn dit probleem, sawol oan it begjin as yn mear komplekse problemen.
Key hint yn dit gefal:
Hoefolle kearen moatte jo it kommando werhelje: ien kear of in protte kearen?
De kommando's foar it printsjen fan de wurden "Yntroduksje" en "Konklúzje" en it ferklearjen en inisjalisearjen fan de fariabele i binne net lykas oare repetitive aksjes. Se wurde mar ien kear útfierd, wat betsjut dat se moatte wurde skreaun bûten it loop lichem.
Alle trije stadia fan 'e oplossing moatte yn' e koade bliuwe, sadat jo letter kinne ferwize nei har yn gefal fan swierrichheden. It is genôch om de earste twa opsjes te kommentearjen sadat se net bemuoie.
De oandacht fan 'e studint moat wurde lutsen op de folgjende feiten:
- Yn in loop betingst wurde meastal in teller en in limyt ferlike. De teller kin feroarje yn it lichem fan 'e loop, mar de limyt kin net. Om dizze regel te brekken, moatte jo twingende redenen formulearje.
- Kommando's foar it werjaan fan de wurden "Yntroduksje" en "Konklúzje" lizze bûten it lichem fan 'e lus. Wy moatte se 1 kear útfiere. "Yntroduksje" - foardat de aksjes werhelle wurde, "Konklúzje" - nei.
Yn it proses fan it konsolidearjen fan dit ûnderwerp, it behearskjen fan de folgjende, en ek omgean mei swierrichheden, is it nuttich foar sels sterke studinten om de fraach te freegjen: "Mar hoefolle kearen moat dizze aksje útfierd wurde? Ien of in protte?
Untwikkeling fan ekstra feardichheden
Yn it proses fan it studearjen fan syklusen ûntwikkelje studinten ek de feardigens om problemen te diagnostearjen en op te lossen. Om diagnostyk út te fieren, moat de studint it winske resultaat presintearje en it fergelykje mei it eigentlike resultaat. Korrigearjende aksjes binne ôfhinklik fan it ferskil tusken har.
Sûnt studinten op dit stadium noch in bytsje idee hawwe fan it "winske" resultaat, kinne se har rjochtsje op testgegevens. Yn 'e regel begrypt op dit stuit noch gjinien wat der mis gean kin en hoe't se dermei omgean moatte. Dêrom skriuw ik yn in notebook in beskriuwing fan typyske problemen en ferskate manieren om se op te lossen. It kiezen fan de meast geskikte is de taak fan de studint sels.
In rekord is nedich om te freegjen "Is wat der ferwachte barde?", "Hokker fan dizze situaasjes barde no?", "Hat de tapaste oplossing holpen?"
- It oantal aksjes is 1 minder of mear as ferwachte. Oplossings:
- fergrutsje de begjinwearde fan 'e teller mei 1.
- ferfange de strikte fergelikingsoperator (< of >) mei in net-streng (<= of >=).
- feroarje de limytwearde nei 1. - Aksjes yn in loop wurde útfierd sûnder stopjen, foar ûnbepaalde tiid. Oplossings:
- foegje in kommando-feroaringskommando ta as it ûntbrekt.
- reparearje it kommando foar feroaring fan teller sadat de wearde tichter by de limyt komt.
- ferwiderje it kommando feroaring fan beheining as it yn it lichem fan 'e loop is. - It oantal aksjes yn in loop is mear as 1 minder of mear as ferwachte. De aksje yn 'e loop waard net ien kear útfierd. Earst moatte jo de werklike wearden fan 'e fariabelen fine krekt foardat de loop begjint. Oplossings:
- feroarje de begjinwearde fan 'e beheining
- feroarje de begjinwearde fan de teller
Probleem 3 omfettet meastentiids it brûken fan de ferkearde fariabele of it net weromsette fan de teller op nul.
Nei dizze útlis kin de studint noch ferskate misferstannen hawwe oer hoe't loops wurkje.
Om de meast foarkommende te ferwiderjen, jou ik jo de folgjende taken:
- wêryn de limyt, inisjele tellerwearde of tellerstap wurdt ynfierd troch de brûker.
- Dêryn moat de tellerwearde brûkt wurde yn guon arithmetyske útdrukking. It is oan te rieden om in teller te brûken yn 'e radikale útdrukking of yn' e neamer, sadat it ferskil net-lineêr is.
- Dêryn wurdt de tellerwearde net werjûn op it skerm wylst de lus rint. Bygelyks, it werjaan fan it fereaske oantal identike tekstfragminten of it tekenjen fan in figuer mei turtle-grafiken.
- Dêryn moatte jo earst wat repetitive aksjes útfiere, en dan oaren.
- Yn hokker jo moatte útfiere oare aksjes foar en nei werhelling
Foar elke taak moatte jo testgegevens en it ferwachte resultaat leverje.
Om te begripen hoe fluch jo kinne bewege, moatte jo de betingsten fan dizze problemen lêze en freegje: "hoe ferskille se fan it foarbyld?", "Wat moat feroare wurde yn it foarbyld om se op te lossen?" As de studint sinfol antwurdet, lit him dan op syn minst ien yn 'e klasse oplosse, en de rest thús sels. As de oplossing suksesfol is, dan kinne wy begjinne mei it ferklearjen fan de betingsten binnen de loops.
As jo problemen hawwe om jo eigen problemen op te lossen, moatte jo alles yn 'e klasse trochwurkje. Om foar te kommen dat it oplossen fan it probleem docht tinken oan it tekenjen fan in ûle, advisearje ik it probleem earst op in net-universele manier op te lossen. Dat is, sadat de oplossing de earste test trochgiet en de loopkonstruksje net brûkt. No, tap dan transformaasjes oan om universaliteit fan 'e oplossing te berikken.
Loops en tûken
Neffens my is it nuttich om it ûnderwerp "syklusen binnen tûken" apart te jaan. Sadat jo letter it ferskil kinne sjen tusken in betingst meardere kearen kontrolearje en ien kear kontrolearje.
De taken foar konsolidaasje sille gean oer it útfieren fan nûmers fan A nei B, dy't wurde ynfierd troch de brûker:
- altyd yn oprinnende folchoarder.
- oprinnend of ôfnimmend ôfhinklik fan de wearden fan A en B.
It ûnderwerp fan "fertakking binnen loops" moat allinich ferpleatst wurde nei't de studint de techniken behearske hat: "in patroan ferfange troch in fariabele" en "repetitive aksjes ferfange troch in syklus."
De wichtichste reden foar it brûken fan tûken binnen loops binne anomalies yn it patroan. Yn 'e midden brekt it ôfhinklik fan' e earste gegevens.
Foar dy studinten dy't by steat binne om te sykjen nei in oplossing troch it kombinearjen fan ienfâldige techniken, is it genôch om te sizzen "fertakking kin wurde skreaun binnen loops" en jou it probleem "bygelyks" folslein te lossen selsstannich.
Foarbyld fan taak:
De brûker fiert it nûmer X yn. Toan de sifers fan 0 oant 9 yn in kolom en set in '+' teken tsjinoer it nûmer dat gelyk is oan X.
As 0 waard ynfierd0+
1
2
3
4
5
6
7
8
9
As 6 waard ynfierd0
1
2
3
4
5
6+
7
8
9
As 9 waard ynfierd0
1
2
3
4
5
6
7
8
9+
As 777 waard ynfierd0
1
2
3
4
5
6
7
8
9
As in koarte útlis is net genôch om te skriuwen mei in loop, dan moatte berikke in universele oplossing foar itselde probleem sûnder in loop.
Jo sille ien fan twa opsjes krije:
Winske
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);
}
Mooglik
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 jou in ferlykbere taak fan tefoaren, wylst ik it ûnderwerp fan branching studearje.
As de studint mei in "mooglike" opsje komt, dan moatte jo har fertelle dat d'r in protte oplossingen wêze kinne foar itselde probleem. Se ferskille lykwols yn har ferset tsjin feroaringen yn easken. Stel de fraach: "Hoefolle plakken yn 'e koade soene moatte wurde korrizjearre as ik in oar nûmer taheakje moast?" Yn 'e "mooglike" ferzje moatte jo noch ien tûke tafoegje en in nij nûmer tafoegje op 10 oare plakken. Yn 'e "winske" is it genôch om mar ien tûke ta te foegjen.
Stel de taak yn om de "winske" opsje te reprodusearjen, fyn dan in patroan yn 'e koade, fier in fariabele ferfanging en skriuw in loop.
As jo in idee hawwe oer hoe't jo dit probleem op in oare manier kinne oplosse sûnder in loop, skriuw dan yn 'e opmerkings.
Loops binnen Loops
Yn dit ûnderwerp moatte jo omtinken jaan oan it folgjende:
- Tellers foar de binnenste en bûtenste loops moatte ferskillende fariabelen wêze.
- de teller foar de binnenste lus moat in protte kearen weromset wurde (dat is yn it lichem fan 'e bûtenste lus).
- yn tekstútfiertaken kinne jo net earst ien letter yn ferskate rigels skriuwe, en dan de twadde. Jo moatte earst alle letters fan de earste rigel printsje, dan alle letters fan de twadde, ensfh.
It is it bêste om it ûnderwerp fan loops binnen loops te ferklearjen troch it belang te ferklearjen fan it weromsetten fan de teller op nul.
Foarbyld fan taak:
De brûker fiert twa sifers: R en T. Print twa rigels fan "#" tekens. De earste rigel moat R-tekens befetsje. De twadde rigel befettet T stikken. As in nûmer negatyf is, lit dan in flaterberjocht sjen.
R=5, T=11#####
############
R=20, T=3#####################
###
R=-1, T=6De R-wearde moat net-negatyf wêze
R=6, T=-2T-wearde moat net-negatyf wêze
Fansels hat dit probleem ek op syn minst twa oplossingen.
Winske
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;
}
Mooglik #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;
}
It ferskil is dat yn 'e "mooglike" oplossing in twadde fariabele waard brûkt om de twadde rigel út te fieren. Jo moatte insistearje op it brûken fan deselde fariabele foar beide loops. Dizze beheining kin rjochtfeardige wurde troch it feit dat in oplossing mei ien teller foar twa syklusen in yllustraasje wêze sil fan 'e term "teller reset". It begripen fan dizze term is nedich by it oplossen fan de folgjende problemen. As kompromis kinne jo beide oplossingen foar it probleem bewarje.
In typysk probleem mei it brûken fan ien tellerfariabele foar twa loops ferskynt sa:
R=5, T=11#####
######
It oantal tekens yn 'e twadde rigel komt net oerien mei de wearde fan T. As jo help nedich hawwe mei dit probleem, dan moatte jo de notysjes besjen oer typyske problemen mei loops. Dit is symptoom #3. It wurdt diagnostearre as jo tafoegje in teller wearde útfier fuortendaliks foar de twadde syklus. Korrigearre troch weromsette. Mar it is better om dit net daliks te fertellen. De studint moat besykje op syn minst ien hypoteze te formulearjen.
Der is fansels in oare oplossing. Mar ik haw it nea sjoen ûnder studinten. Op it poadium fan it studearjen fan syklusen sil it ferhaal deroer de oandacht ôfliede. Jo kinne der letter op weromkomme as jo leare oer stringfunksjes.
Mooglik #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));
Folgjende ferplichte taak:
Lit de nûmers sjen fan 0 oant 9. Elk nûmer moat op in eigen rigel stean. It oantal sifers yn in rigel (W) wurdt ynfierd fan it toetseboerd.
W=10
1
2
3
4
5
6
7
8
9
W=100000000000
1111111111
2222222222
3333333333
4444444444
5555555555
6666666666
7777777777
8888888888
9999999999
As in studint hat behearsket de technyk fan it ferfangen fan in fariabele, dan sil omgean frij fluch. In mooglik probleem sil wer wêze yn it weromsette fan de fariabele. As jo de transformaasje net kinne omgean, betsjut dit dat jo haast wiene en ienfâldiger problemen moatte oplosse.
Tank foar jo oandacht. Like en abonneer op it kanaal.
PS As jo typfouten of flaters fine yn 'e tekst, lit it my dan witte. Dit kin dien wurde troch in diel fan 'e tekst te selektearjen en op "⌘ + Enter" te drukken op Mac, en "Ctrl / Enter" op klassike toetseboerden, of fia priveeberjochten. As dizze opsjes net beskikber binne, skriuw dan oer flaters yn 'e kommentaren. Dankewol!
Allinnich registrearre brûkers kinne meidwaan oan 'e enkête. , asjebleaft.
Poll foar lêzers sûnder karma
-
20,0%Ik lear profesjoneel, +12
-
10,0%Ik lear profesjoneel, -11
-
70,0%Ik doch net les, +17
-
0,0%Ik jou net les, -10
-
0,0%oar0
10 brûkers stimden. 5 brûkers ûntholden har.
Boarne: www.habr.com