Annak ellenére, hogy az egyik alapvető témáról fogunk beszélni, ez a cikk tapasztalt szakemberek számára készült. A cél az, hogy bemutassuk, milyen tévhitek vannak a kezdőknek a programozás terén. A gyakorló fejlesztők számára ezek a problémák már régóta megoldódtak, elfelejtettek vagy egyáltalán nem vettek észre. A cikk jól jöhet, ha hirtelen valakinek segítenie kell ebben a témában. A cikk párhuzamot von Schildt, Stroustrup, Okulov programozásról szóló könyveinek anyagával.
A ciklusokról szóló témára azért esett a választás, mert a programozás elsajátítása során elég sokan ki vannak zárva belőle.
Ez a technika gyenge tanulók számára készült. Az erős emberek általában nem ragadnak le ennél a témánál, és nincs szükség speciális technikák kidolgozására számukra. A cikk másodlagos célja, hogy ezt a technikát a „minden diáknak működik, de csak egy tanárnak” osztályból áthelyezze a „minden diáknak, minden tanárnak dolgozik” osztályba. Nem állítom az abszolút eredetiséget. Ha már használ hasonló módszertant a téma oktatásához, kérjük, írja meg, miben tér el az Ön verziója. Ha úgy dönt, hogy használja, mondja el nekünk, hogyan sikerült. Ha egy könyvben hasonló technikát írnak le, kérjük, írja be a nevét.
4 évig dolgoztam ezen a technikán, egyénileg tanultam különböző képzettségi szintű hallgatókkal. Összesen mintegy ötven diák és kétezer óra tanóra van. Eleinte a diákok mindig elakadtak ennél a témánál, és elmentek. Minden tanuló után a módszertan és az anyagok igazítása megtörtént. Az elmúlt év során a hallgatók már nem ragadtak le ennél a témánál, ezért úgy döntöttem, megosztom eredményeimet.
Miért ennyi levél? A ciklusok olyan elemiek!
Ahogy fentebb is írtam, gyakorló fejlesztők és erős hallgatók számára a hurkok fogalmának összetettsége alábecsülhető. Például tarthat egy hosszú előadást, láthat bólogató fejeket és intelligens szemeket. De amikor megpróbálunk bármilyen problémát megoldani, kábulat és megmagyarázhatatlan problémák kezdődnek. Az előadás után a hallgatóknak valószínűleg csak részleges volt a megértése. A helyzetet súlyosbítja, hogy a tanulók maguk sem tudják elmondani, mi is pontosan a téveszméjük.
Egy nap rájöttem, hogy a hallgatók hieroglifáknak tekintik a példáimat. Vagyis olyan, mint az oszthatatlan szövegrészek, amelyekhez hozzá kell adni valamilyen „varázslatos” betűt, és működni fog.
Néha észrevettem, hogy a hallgatók úgy gondolják, hogy egy adott probléma megoldásához szükség van valami más olyan dizájnt, amivel még nem foglalkoztam. Bár a megoldás csak a példa enyhe módosítását igényelte.
Ezért arra az ötletre jutottam, hogy a hangsúlyt nem a kifejezések szintaxisára kell helyezni, hanem az ismétlődő kód ciklusok segítségével történő újrafeldolgozásának ötletére. Miután a tanulók elsajátították ezt az ötletet, kis gyakorlással bármilyen szintaxis javítható.
Kit és miért tanítok?
Mivel nincsenek felvételi vizsgák, az osztályokba erős és nagyon gyenge tanulók is lehetnek. Tanítványaimról bővebben a cikkben olvashat
Arra törekedtem, hogy mindenki megtanulhassa a programozást, aki szeretne tanulni.
Az óráimat egyénileg tartom, és a diák mindegyikért a saját pénzét fizeti. Úgy tűnik, hogy a diákok optimalizálják a költségeket, és a minimumot követelik. Az emberek azonban nem magáért a tudásért, hanem a tanultak magabiztosságáért, a haladás érzéséért és a szakértő (tanár) jóváhagyásáért mennek az élő tanárral folytatott személyes órákra. Ha a tanulók nem éreznek előrehaladást a tanulásban, akkor távoznak. Általában az osztályokat úgy lehet felépíteni, hogy a tanulók előrelépést érezzenek az ismert struktúrák számának növelésében. Vagyis először tanulunk amíg részletesen, utána tanulunk, utána csinálunk, és most már készen áll az ezeregyéjszakás kurzus, amelyben két hónapig csak ciklusokat tanulunk, a végén pedig egy diák, aki írt. szabványos könyvtár diktálás alatt. A gyakorlati problémák megoldásához azonban nemcsak az anyag ismeretére van szükség, hanem az alkalmazásában és az új információk felkutatásában való önállóságra is. Ezért a személyes kurzusoknál azt gondolom, hogy a helyes elv a minimum tanítása és az árnyalatok és a kapcsolódó témák önálló tanulmányozásának ösztönzése. A hurkok témakörében a while konstrukciót tartom a minimumnak. Az elvet meg lehet érteni belőle. Az alapelv ismeretében elsajátíthatja mind a saját maga számára, mind a munka közben.
Ahhoz, hogy a gyenge tanulók elsajátítsák az anyagot, nem elég a szintaxis leírása. Szükséges egyszerűbb, de változatosabb feladatok megadása, példák részletesebb ismertetése. Végső soron a fejlődés sebességét korlátozza a tanuló képessége a kifejezések átalakítására és a minták keresésére. Az okos tanulók számára a legtöbb feladat unalmas lesz. Amikor velük tanulsz, nem kell ragaszkodnod a problémák 100%-os megoldásához. Anyagom megtekinthető a címen . Igaz, a repository inkább egy warlock grimoire - rajtam kívül senki nem fogja megérteni, hogy hol van, és ha nem sikerül az ellenőrzésen, megőrülhetsz
A módszertan gyakorlatorientált
Az elmélet magyarázata a probléma megoldásának példáján keresztül történik. Egy olyan programozási órán, ahol ágakat és hurkokat tanítanak, egyszerűen nem lehet egy témában egy egész órán keresztül hasznos előadást tartani. 15-20 perc elég a fogalom magyarázatához. A fő nehézségek a gyakorlati feladatok végrehajtása során jelentkeznek.
A pályakezdő tanárok egy előadáson belül zöröghetnek le operátorokat, ágakat, hurkokat és tömböket. De a tanítványaik szembesülnek majd az információ beolvasztásának problémájával.
Nemcsak elmondani kell az anyagot, hanem arról is gondoskodni kell, hogy a hallgatók megértsék.
A téma elsajátításának tényét az határozza meg, hogy a tanuló hogyan boldogul az önálló munkával.
Ha egy tanulónak tanári segítség nélkül sikerült megoldania egy feladatot egy témában, akkor a témát elsajátította. Az önellenőrzés biztosítása érdekében az egyes feladatokat egy táblázatban ismertetjük tesztforgatókönyvekkel. A feladatoknak egyértelmű sorrendje van. A feladatok kihagyása nem javasolt. Ha az aktuális feladat túl nehéz, akkor haszontalan továbblépni a következőre. Ez még bonyolultabb. Annak érdekében, hogy a tanuló elsajátítsa az aktuális összetett feladatot, több technikát is elmagyaráznak neki az első feladat példáján keresztül. Valójában a téma teljes tartalma a nehézségek leküzdésének technikáitól függ. A ciklusok inkább mellékhatások.
Az első feladat mindig egy példa. A második kissé eltér, és „önállóan” kerül végrehajtásra közvetlenül az első után, tanári felügyelet mellett. Minden további feladat arra irányul, hogy figyeljünk különféle apróságokra, amelyek tévhiteket okozhatnak.
A példa magyarázata egy párbeszéd, amelyben a tanulónak vissza kell hívnia a terjesztést és a keresztellenőrzést, hogy megbizonyosodjon arról, hogy az anyag egy részét elsajátította.
Banális leszek, és azt mondom, hogy az első példa a témában nagyon fontos. Ha megvan a terjedelmes önálló munkához szükséges anyag, az első példa kihagyásai javíthatók. Ha a példán kívül nincs más, akkor a hallgató nagy valószínűséggel nem fogja elsajátítani a témát.
Amíg vagy időre?
Az egyik vitatott kérdés a példa konstrukciójának megválasztása: while vagy for. Egyszer egy gyakorló fejlesztő barátom, akinek nem volt tanítási tapasztalata, egy órán keresztül meggyőzött arról, hogy a for ciklus a legkönnyebben érthető. Az érvek abban torlódnak, hogy „minden benne van, és minden a helyén van”. Az igazi kezdők nehézségeinek kiváltó oka azonban maga a ciklus ötlete, és nem annak írása. Ha valaki nem érti ezt a gondolatot, akkor nehézségei lesznek a szintaxissal. Amint az ötlet megvalósul, a kódtervezés problémái maguktól eltűnnek.
Anyagaimban a hurkok témája követi az elágazás témáját. Az if és while külső hasonlósága közvetlen hasonlatot tesz lehetővé: „ha a fejlécben szereplő feltétel igaz, akkor a törzs végrehajtódik”. A ciklus egyetlen sajátossága, hogy a testet sokszor végrehajtják.
A második érvem az, hogy a while kevesebb formázást igényel, mint a for. Kevesebb formázás kevesebb hülyeséget jelent a hiányzó vesszőkkel és zárójelekkel. A kezdők még nem fejlesztették ki elég figyelmességet és aprólékosságot ahhoz, hogy automatikusan elkerüljék a szintaktikai hibákat.
A harmadik érvet sok jó könyvben az első érvként magyarázzák.
Ha a tanuló könnyen át tudja alakítani a kifejezéseket, akkor mellékesen beszélhet róla. Ezután a tanuló kiválasztja, hogy mi tetszik neki a legjobban. Ha az átalakítások nehézségeket okoznak, akkor jobb, ha nem vonja el a figyelmét. A tanuló először oldjon meg mindent a while használatával. Miután elsajátította a hurkok témáját, átírhatja a megoldásokat, hogy gyakorolja a while konvertálást for-ra.
A feltételes hurkok meglehetősen ritka vadállatok. Egyáltalán nem szánok rá időt. Ha egy tanuló elsajátította a minták azonosításának és a kifejezések átalakításának ötletét, akkor segítségem nélkül is kitalálja.
Az első példa erős tanulók előtti bemutatásakor felhívom a figyelmet arra, hogy az első példában nem csak a megoldást fontos rögzíteni, hanem az eredményhez vezető cselekvések teljes láncolatát is. A lusta tanulók elhanyagolhatják az írást, és csak a végső algoritmust másolhatják le. Meg kell őket győzni arról, hogy egy napon nehéz feladat vár rájuk. A megoldáshoz kövesse az ebben a példában szereplő lépéseket. Ezért fontos minden szakasz rögzítése. A következő problémáknál csak a megoldás végleges változatát lehet hagyni.
Az automatizálás lényege, hogy egy számítógépre bízzuk a rutinmunkát az ember helyett. Az egyik alapvető technika a hurkok írása. Akkor használatos, ha egy programban egymás után több azonos ismétlődő művelet van írva.
Az explicit jobb, mint az implicit
Jó ötletnek tűnhet ugyanazt a kifejezést többször megjeleníteni az első ciklusos feladatban. Például:
Hurrá, működik!
Hurrá, működik!
Hurrá, működik!
Hurrá, működik!
Hurrá, működik!
Hurrá, működik!
Hurrá, működik!
Hurrá, működik!
Ez az opció rossz, mert a számláló értéke nem látható a kimenetben. Ez a kezdők problémája. Ne becsüld alá őt. Eleinte ez a feladat volt az első, a második pedig a számsorok növekvő sorrendben történő származtatása. Szükség volt további „N-szeres ciklus” és „ciklus A-ból B-be” kifejezések bevezetésére, amelyek lényegében ugyanazok. Annak érdekében, hogy ne hozzunk létre felesleges entitásokat, úgy döntöttem, hogy csak egy példát mutatok be egy számsorozat kimenetével. Kevés embernek sikerül felkészülés nélkül megtanulnia, hogyan kell számlálót a fejében tartani, és fejben modellezni egy program viselkedését. Néhány diák először a ciklusok témájában találkozik mentális modellezéssel.
Némi gyakorlás után ugyanazon szöveg megismétlését adom önállóan megoldandó feladatnak. Ha először egy látható számlálót ad meg, majd egy láthatatlant, akkor a tanulóknak kevesebb problémájuk lesz. Néha elég a „ne írd a számlálót a képernyőre” tipp.
Hogyan magyarázzák mások?
A legtöbb internetes oktatási anyagban a ciklus szintaxisát egy „előadás” részeként adják meg. Például a developer.mozilla.org webhelyen (jelenleg) számos más konstrukció is le van írva a while ciklus mellett. Ebben az esetben csak magukat a terveket adjuk meg sablonok formájában. Indításuk eredményét szavakkal leírják, de nincs illusztráció. Véleményem szerint a téma ilyen bemutatása nullával szorozza meg az ilyen anyagok hasznosságát. A tanuló átírhatja a kódot és lefuttathatja saját maga, de ehhez még szüksége van egy szabványra az összehasonlításhoz. Hogyan lehet megérteni, hogy egy példát helyesen írtak át, ha nincs mihez hasonlítani az eredményt?
Ha csak egy sablon van megadva, példa nélkül, még nehezebbé válik a tanuló számára. Hogyan lehet megérteni, hogy a kódrészletek helyesen vannak-e elhelyezve a sablonban? Megpróbálhatsz írni valahogy, majd fuss. De ha nincs szabvány az eredmény összehasonlítására, akkor az indítás sem segít.
Az Intuitív C++ kurzusban a ciklus szintaxisa a 4. előadás harmadik oldalán van eltemetve az „operátorok” témakörben. A ciklusok szintaxisának magyarázata során különös hangsúlyt kap az „operátor” kifejezés. A kifejezés tények halmazaként jelenik meg, mint például a „szimbólum; ez egy utasítás", "{} egy összetett utasítás", "a ciklus törzsének utasításnak kell lennie". Nem szeretem ezt a megközelítést, mert úgy tűnik, fontos kapcsolatokat rejt egy kifejezés mögé. A program forráskódjának kifejezésekre ezen a szinten történő elemzésére a fordítóprogram-fejlesztőknek van szükségük a nyelvi specifikáció megvalósításához, de nem a hallgatóknak első közelítésként. A programozásban újoncok ritkán elég aprólékosak ahhoz, hogy ennyire odafigyeljenek a kifejezésekre. Ritka ember, aki először emlékszik meg és érti meg az új szavakat. Szinte senki sem tudja helyesen alkalmazni az imént tanult kifejezést. Emiatt a tanulók sok olyan hibát kapnak, mint például: "Írtam, míg(a<7);{, de a program nem működik."
Véleményem szerint az elején jobb, ha azonnal zárójelben megadjuk a szerkezet szintaxisát. A zárójel nélküli opciót csak akkor érdemes megmagyarázni, ha a tanulónak konkrét kérdése van: „miért nincs zárójel, és működik”.
Okulov 2012-es „A programozás alapjai” című könyvében a hurkok bevezetése a for mintával kezdődik, majd ajánlásokat ad a használatára, majd azonnal a lecke kísérleti részéhez nyúlik. Megértem, hogy a könyvet a nagyon tehetséges tanulók azon kisebbségének írták, akik ritkán jönnek az óráimra.
A népszerű könyvekben a kódrészletek eredménye mindig le van írva. Például Shildt „Java 8. The Complete Guide” 2015-ös kiadása. Először egy sablont adunk meg, majd egy példaprogramot, és közvetlenül utána - a végrehajtás eredménye.
Példaként vegyünk egy while ciklust, amely fordítva működik
a visszaszámlálás 10-től kezdve, és pontosan 10 sornyi „mérték” jelenik meg://Продемонстрировать применение оператора цикла while class While { public static void main(String args []) { int n = 10; while (n > 0) { System.out.println("такт " + n); n--; } } }A futás után a program tíz "ciklust" ad ki az alábbiak szerint:
такт 10
такт 9
такт 8
такт 7
такт 6
такт 5
такт 4
такт 3
такт 2
такт 1
A sablon, a példaprogram és a program eredménye leírásának megközelítését a „Javascript gyerekeknek” című könyv és a w3schools.com webhely js-tanfolyama is alkalmazza. A weboldal formátuma még azt is lehetővé teszi, hogy ez a példa interaktív legyen.
Stroustrup 2016-os, Principles and Practice Using C++ című könyve még ennél is tovább ment. Első lépésként el kell magyarázni, hogy milyen eredményt kell elérni, majd ezt követően megjelenik a program szövege. Sőt, nem csak egy véletlenszerű programot vesznek példaként, hanem kirándulást tesznek a történelembe. Ez segít felhívni rá a figyelmet: „Nézd, ez nem csak egy haszontalan szöveg. Látsz valami értelmeset."
Az iteráció példájaként vegyük a tárolt programgépen (EDSAC) végrehajtott első programot. David Wheeler írta a Cambridge-i Egyetem Számítógépes Laboratóriumában, 6. május 1949-án. Ez a program kiszámítja és kinyomtatja a négyzetek egyszerű listáját.
0 0
1 1
2 4
3 9
4 16
...
98 9604
99 9801
Itt minden sor egy számot tartalmaz, amelyet egy tabulátor karakter („t”) követ, és a szám négyzete. A program C++ verziója így néz ki://Вычисляем и распечатываем таблицу квадратов чисел 0-99 int main() { int i = 0; // Начинаем с нуля while(i < 100){ cout << i << 't' << square(i) << 'n'; ++i; } }
Érdekes módon a szintaktikai mintát ez a könyv nem írja le. Stroustrup az oktatói kézikönyvben () hangsúlyozza, hogy tiszteletben tartja diákjai intelligenciáját. Talán egy ilyen intelligencia megnyilvánulásának tekinthető a több példában szereplő minta azonosításának képessége.
Ahogy kifejtem magam
Stroustrup megközelítése: az eredmény leírása, majd a probléma megoldása, majd a tanuló önálló elemzése – tűnik a legátgondoltabbnak. Ezért úgy döntöttem, hogy alapul veszem, de egy kevésbé történelmi példával mondom el - a „tartalomjegyzék” levezetésének feladatával. Felismerhető horgonyt képez, így azt mondhatja, hogy „emlékezzen a tartalomjegyzékkel kapcsolatos feladatra”, és hogy a tanulók pontosan emlékezzenek erre. Példámban megpróbáltam megelőzni még két leggyakoribb tévhitet. Legközelebb róluk írok részletesebben.
Ebben a feladatban komplex problémák megoldásának technikáival ismerkedünk meg. A kezdeti döntést primitíven és egyszerűvé kell tenni. Nos, akkor elgondolkodhat azon, hogyan javíthatja ezt a megoldást.
Введение
Глава 1
Глава 2
Глава 3
Глава 4
Глава 5
Глава 6
Глава 7
Заключение
Megfigyeléseim szerint a „sablon-példa-eredmény” megközelítés változatos kombinációkban továbbra is oda vezet, hogy a tanulók hieroglifaként érzékelik a ciklust. Ez abban nyilvánult meg, hogy nem értették, miért van feltétel, hogy oda írjanak, hogyan kell választani az i++ és az i— és egyéb nyilvánvalónak tűnő dolgok között. E tévhitek elkerülése érdekében a ciklusokról beszélő megközelítésnek hangsúlyoznia kell az azonos cselekvések megismétlését, és csak azután formalizálni kell őket egy szerkezettel. Ezért a ciklus szintaxisának megadása előtt meg kell oldania a problémát. A tartalomjegyzék probléma primitív megoldása így néz ki:
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("Заключение");
Hogyan lehet javítani?
Cserélje le a monoton cselekvéseket ciklusra.
Milyen műveletek ismétlődnek meg sorban változtatás nélkül?
Ebben a töredékben ilyenek nincsenek. A „Fejezet” szó számmal történő megjelenítésére szolgáló parancsok azonban nagyon hasonlóak egymáshoz.
Ezért a következő lépés a töredékek közötti különbség megtalálása. Csak ebben a feladatban minden nyilvánvaló, akkor nem egyedi parancsok ismétlődnek, hanem 5 vagy több soros kódblokkok. Nem csak a parancsok listájában kell keresnie, hanem elágazó vagy hurok konstrukciókban is.
A példában a parancsok közötti különbség a „Fejezet” szó utáni számban van.
Miután megtalálta a különbséget, meg kell értenie a változás mintáját. A különböző töredék a szám? Folyamatosan növekszik vagy csökken? Hogyan változik egy szám értéke két egymás melletti csapat között?
A példában a „Fejezet” szó utáni szám 1-gyel növekszik. Megtaláljuk a különbséget, feltárjuk a mintát. Most már helyettesítheti az eltérő töredéket egy változóval.
Egy ilyen változót az első ismétlődő töredék előtt kell deklarálnia. Az ilyen változókat általában I-nek vagy j-nek, vagy valami részletesebbnek nevezik. Kezdő értékének meg kell egyeznie a képernyőn megjelenő első értékkel. A példában az első érték 1.
Milyen kezdeti értéket kell venni a „100, 101, 102, 103, 104, 105” számsorok megjelenítéséhez?
A sorozat első száma a 100.
Minden kimeneti parancs után növelni kell ennek a változónak az értékét 1-gyel. Ez az egység a változás lépése.
Milyen lépés lesz a „100, 102, 104, 106” számsorban?
2. lépés ebben a sorban.
Miután az eltérő töredéket változóra cseréli, a kód így fog kinézni:
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("Заключение");
Miután alkalmazta a „változó mintájának kifejezése” technikát a kódban, több azonos műveletcsoportot kap, amelyek egymás után mennek. Most az ismétlődő műveletek helyettesíthetők ciklussal.
A hurkokat használó probléma megoldásának sorrendje a következő lépésekből áll:
- Oldja meg a „fejjel” sok különálló paranccsal
- Keressen egy mintát
- Fejezd ki egy változó mintázatát
- Tervezés mint ciklus
Ezután új kifejezéseket vezetnek be, hogy a hallgató ne találja magát a „Mindent értek, de nem mondhatok ki” helyzetbe:
— a számláló mindig egy változó, amely a ciklus lépéseinek számának követéséhez szükséges. Általában egy egész szám, amelyet a megszorításhoz hasonlítanak.
— számlálólépés — a számlálóváltások mintájának leírása.
- megszorítás - egy szám vagy változó, amellyel a számlálót összehasonlítják, hogy az algoritmus végleges legyen. A számláló értéke a határértékhez közelítve változik.
— loop body — ismétlődő parancsok halmaza. Amikor azt mondják, hogy „a parancs egy hurkon belül van írva”, a törzsre gondolnak.
— hurokiteráció — a ciklustörzs egyszeri végrehajtása.
— ciklusfeltétel — egy logikai kifejezés, amely meghatározza, hogy egy újabb iteráció végrehajtásra kerüljön-e. (Az elágazó struktúrákkal itt összetéveszthető)
Fel kell készülnie arra a tényre, hogy a hallgatók eleinte más célokra használják a kifejezéseket. Ez az erősekre és a gyengékre egyaránt vonatkozik. A közös nyelv kialakítása művészet. Most röviden leírom: be kell állítania a „kiemelje ki a kódrészletet a <term>-vel” feladatot, és helyesen használja ezeket a kifejezéseket a beszélgetésben.
A hurokkal történő átalakítás után a fragmentumot kapjuk:
Console.WriteLine("Введение");
int i = 0;
while (i < 7) {
Console.WriteLine("Глава " + i);
i = i + 1;
}
Console.WriteLine("Заключение");A fő tévhit
Az egyik népszerű tévhit a diákok körében az, hogy olyan műveleteket helyeznek el egy hurkon belül, amelyeket csak egyszer kell elvégezni. Például így:
;
int i = 0;
while (i < 7) {
Console.WriteLine("Введение")
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Заключение");
}
A hallgatók folyamatosan találkoznak ezzel a problémával, mind az elején, mind a bonyolultabb problémák során.
A legfontosabb tipp ebben az esetben:
Hányszor ismételje meg a parancsot: egyszer vagy többször?
A „Bevezetés” és „Következtetés” szavak kinyomtatására, valamint az i változó deklarálására és inicializálására szolgáló parancsok nem olyanok, mint a többi ismétlődő művelet. Csak egyszer hajtódnak végre, ami azt jelenti, hogy a ciklustörzsön kívülre kell írni őket.
A megoldás mindhárom szakaszának a kódban kell maradnia, hogy később nehézségek esetén hivatkozhasson rájuk. Elég az első két lehetőséget kommentálni, hogy ne zavarjanak.
A tanuló figyelmét a következő tényekre kell felhívni:
— Hurokállapotban egy számlálót és egy limitet szoktak összehasonlítani. A számláló változhat a hurok törzsében, de a limit nem. Ennek a szabálynak a megszegéséhez nyomós indokokat kell megfogalmaznia.
— A „Bevezetés” és a „Befejezés” szavak megjelenítésére szolgáló parancsok a hurok törzsén kívül találhatók. 1 alkalommal kell végrehajtanunk őket. „Bevezetés” - a műveletek megismétlése előtt, „Következtetés” - után.
Ennek a témakörnek a megszilárdítása, a következőek elsajátítása, valamint a nehézségek kezelése során még az erős tanulóknak is hasznos feltenni a kérdést: „Hányszor kell ezt a műveletet végrehajtani? Egy vagy sok?
További készségek fejlesztése
A ciklusok tanulása során a tanulók a problémafeltáró és -megoldó képességet is fejlesztik. A diagnosztika elvégzéséhez a hallgatónak be kell mutatnia a kívánt eredményt, és össze kell vetnie azt a tényleges eredménnyel. A korrekciós intézkedések a köztük lévő különbségtől függenek.
Mivel a tanulóknak ebben a szakaszban még kevés fogalmuk van a „kívánt” eredményről, a tesztadatokra összpontosíthatnak. Általános szabály, hogy ebben a szakaszban még senki sem érti, mi lehet a baj, és hogyan kell kezelni. Ezért egy jegyzetfüzetben leírom a tipikus problémákat és azok megoldási módjait. A legmegfelelőbb kiválasztása magának a tanulónak a feladata.
Feljegyzésre van szükség ahhoz, hogy megkérdezzük: „megtörtént, amit vártunk?”, „Melyik eset történt most?”, „Segített az alkalmazott megoldás?”
- A műveletek száma 1-gyel kevesebb vagy több a vártnál. Megoldások:
— növelje a számláló kezdeti értékét 1-gyel.
— cserélje ki a szigorú összehasonlító operátort (< vagy >) egy nem szigorúra (<= vagy >=).
— módosítsa a határértéket 1-re. - A ciklusban végzett műveletek megállás nélkül, korlátlanul hajthatók végre. Megoldások:
— adjon hozzá egy számlálómódosítási parancsot, ha az hiányzik.
— rögzítse a számlálóváltási parancsot úgy, hogy értéke közelebb kerüljön a határértékhez.
— távolítsa el a kényszerváltoztatási parancsot, ha az a ciklus törzsében található. - A ciklusban a műveletek száma több mint 1-gyel kevesebb vagy több a vártnál. A ciklusban végrehajtott műveletet még egyszer sem hajtották végre. Először meg kell találnia a változók tényleges értékét közvetlenül a ciklus megkezdése előtt. Megoldások:
— módosítsa a kényszer kezdeti értékét
— módosítsa a számláló kezdeti értékét
A 3. probléma általában nem megfelelő változó használatával vagy a számláló nullázására való visszaállításával jár.
E magyarázat után a hallgatónak még mindig lehetnek tévképzetei a hurkok működésével kapcsolatban.
A leggyakoribbak eloszlatására a következő feladatokat adom:
- Amelyben a határértéket, a kezdeti számlálóértéket vagy a számlálólépést adja meg a felhasználó.
- Amelyben a számláló értéket kell használni valamilyen aritmetikai kifejezésben. Célszerű számlálót használni a gyök kifejezésben vagy a nevezőben, hogy a különbség nemlineáris legyen.
- Amelyben a számláló értéke nem jelenik meg a képernyőn, miközben a hurok fut. Például a szükséges számú egyforma szövegrészlet megjelenítése vagy egy ábra rajzolása teknős grafikával.
- Amelyben először néhány ismétlődő műveletet kell végrehajtania, majd másokat.
- Amelyben más műveleteket kell végrehajtania az ismétlés előtt és után
Minden feladathoz meg kell adni a tesztadatokat és a várt eredményt.
Ahhoz, hogy megértse, milyen gyorsan tud mozogni, el kell olvasnia ezeknek a problémáknak a feltételeit, és meg kell kérdeznie: „Miben különböznek a példától?”, „Mit kell megváltoztatni a példában a megoldáshoz?” Ha értelmesen válaszol a tanuló, akkor legalább egyet az órán oldjon meg, a többit otthon egyedül. Ha a megoldás sikeres, akkor elkezdhetjük a hurkon belüli feltételek magyarázatát.
Ha problémái vannak a problémák önálló megoldásával, mindent át kell dolgoznia az órán. Annak elkerülése érdekében, hogy a probléma megoldása bagoly rajzolására emlékeztetjen, azt javaslom, hogy először oldja meg a problémát nem univerzális módon. Vagyis úgy, hogy a megoldás átmegy az első teszten, és ne használja a hurokkonstrukciót. Nos, akkor alkalmazzon átalakításokat a megoldás egyetemességének eléréséhez.
Hurok és ágak
Véleményem szerint célszerű külön megadni a „ciklusok az ágakon belül” témát. Így később láthatja a különbséget a feltétel többszöri és egyszeri ellenőrzése között.
A konszolidáció feladatai a felhasználó által beírt számok A-tól B-ig történő kiadásáról szólnak:
- mindig növekvő sorrendben.
- növekvő vagy csökkenő A és B értékétől függően.
A „hurkokon belüli elágazás” témával csak akkor szabad továbblépni, ha a tanuló elsajátította a technikákat: „minta cseréje változóval” és „ismétlődő cselekvések ciklussal való helyettesítése”.
A hurkon belüli ágak használatának fő oka a minta anomáliái. Középen a kezdeti adatoktól függően megszakad.
Azoknak a hallgatóknak, akik egyszerű technikák kombinálásával is képesek megoldást keresni, elég annyit mondani, hogy „elágazás hurkon belül írható”, és a feladatot „például” teljesen önállóan megoldani.
Példa feladat:
A felhasználó beírja az X számot. Jelenítse meg a 0 és 9 közötti számokat egy oszlopban, és tegyen egy „+” jelet az X-szel egyenlő szám elé.
Ha 0 lett beírva0+
1
2
3
4
5
6
7
8
9
Ha 6 lett beírva0
1
2
3
4
5
6+
7
8
9
Ha 9 lett beírva0
1
2
3
4
5
6
7
8
9+
Ha 777 lett beírva0
1
2
3
4
5
6
7
8
9
Ha egy rövid magyarázat nem elég a ciklusos íráshoz, akkor ugyanarra a problémára univerzális megoldást kell elérnie ciklus nélkül.
Két lehetőség közül választhat:
Kívánatos
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);
}
Lehetséges
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+");
}
Hasonló feladatot adok előre, az elágazás témakör tanulmányozása közben.
Ha a hallgató egy „lehetséges” opcióval áll elő, akkor el kell mondania neki, hogy ugyanarra a problémára többféle megoldás is lehet. Különböznek azonban a követelmények változásával szembeni ellenállásukban. Tegye fel a kérdést: „Hány helyen kellene javítani a kódban, ha újabb számot kellene hozzáadnom?” A „lehetséges” verzióban még egy ágat kell hozzáadnia, és 10 másik helyen új számot kell hozzáadnia. A „kívánt” mezőben elegendő csak egy ágat hozzáadni.
Állítsa be a feladatot a „kívánt” opció reprodukálására, majd keressen egy mintát a kódban, hajtsa végre a változócserét, és írjon egy ciklust.
Ha van ötlete, hogyan lehet ezt a problémát hurok nélkül más módon megoldani, kérjük, írja meg a megjegyzésekben.
Hurok a hurkon belül
Ebben a témában a következőkre kell figyelni:
— a belső és a külső hurok számlálóinak különböző változóknak kell lenniük.
— a belső hurok számlálóját sokszor vissza kell állítani (azaz a külső hurok törzsében).
— a szövegkiadási feladatokban nem lehet először egy betűt több sorba írni, majd a másodikat. Először ki kell nyomtatnia az első sor összes betűjét, majd a második sor összes betűjét, és így tovább.
A legjobb, ha a hurkon belüli hurkok témáját a számláló nullára állításának fontosságának elmagyarázásával kezdi.
Példa feladat:
A felhasználó két számot ír be: R és T. Nyomtasson ki két "#" karaktersort. Az első sornak R karaktert kell tartalmaznia. A második sor T-darabokat tartalmaz. Ha bármelyik szám negatív, jelenítsen meg egy hibaüzenetet.
R=5, T=11#####
#############
R=20, T=3######################
###
R=-1, T=6Az R értéknek nem negatívnak kell lennie
R=6, T=-2A T értéknek nem negatívnak kell lennie
Nyilván ennek a problémának is van legalább két megoldása.
Kívánatos
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;
}
Lehetséges #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;
}
A különbség az, hogy a "lehetséges" megoldásban egy második változót használtak a második sor kimenetére. Ragaszkodnia kell ahhoz, hogy mindkét ciklushoz ugyanazt a változót használja. Ez a korlát azzal indokolható, hogy a két cikluson keresztül egy számlálóval rendelkező megoldás a „számláló nullázása” kifejezést illusztrálja. Ennek a kifejezésnek a megértése szükséges a következő problémák megoldásához. Kompromisszumként mindkét megoldást elmentheti a probléma megoldására.
Egy tipikus probléma, ha egy számlálóváltozót használunk két hurokhoz, így jelenik meg:
R=5, T=11#####
######
A második sorban lévő karakterek száma nem egyezik meg a T értékével. Ha segítségre van szüksége ebben a problémában, akkor nézze meg a ciklusokkal kapcsolatos tipikus problémákkal kapcsolatos megjegyzéseket. Ez a 3-as tünet. A rendszer akkor diagnosztizálja, ha közvetlenül a második ciklus előtt hozzáad egy számlálóérték kimenetet. Resettel javítva. De jobb ezt nem azonnal elmondani. A hallgatónak meg kell próbálnia legalább egy hipotézist megfogalmazni.
Természetesen van más megoldás is. De még soha nem láttam a diákok között. A ciklusok tanulmányozásának szakaszában a róla szóló történet elvonja a figyelmet. Később visszatérhet rá a karakterlánc-függvények megismerésekor.
Lehetséges #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));
Következő kötelező feladat:
Jelenítse meg a 0-tól 9-ig terjedő számokat. Minden számnak a saját sorában kell lennie. A sorban lévő számjegyek számát (W) a billentyűzetről kell beírni.
W=10
1
2
3
4
5
6
7
8
9
W=100000000000
1111111111
2222222222
3333333333
4444444444
5555555555
6666666666
7777777777
8888888888
9999999999
Ha egy diák elsajátította a változó cseréjének technikáját, akkor elég gyorsan megbirkózik. Egy lehetséges probléma ismét a változó visszaállításával lesz. Ha nem tudod kezelni az átalakulást, az azt jelenti, hogy siettél, és egyszerűbb problémákat kell megoldanod.
Köszönöm a figyelmet. Lájkold és iratkozz fel a csatornára.
PS Ha elírást vagy hibát talál a szövegben, kérem jelezze. Ezt úgy teheti meg, hogy kijelöli a szöveg egy részét, és megnyomja a „⌘ + Enter” billentyűt Mac-en, illetve a „Ctrl / Enter” billentyűket klasszikus billentyűzeteken, vagy privát üzenetben. Ha ezek a lehetőségek nem állnak rendelkezésre, írjon a hibákról a megjegyzésekben. Köszönöm!
A felmérésben csak regisztrált felhasználók vehetnek részt. , kérem.
Szavazás karma nélküli olvasóknak
-
20,0%Szakszerűen tanítok, +12
-
10,0%Szakszerűen tanítok, -11
-
70,0%Nem tanítok, +17
-
0,0%Nem tanítok, -10
-
0,0%Egyéb0
10 felhasználó szavazott. 5 felhasználó tartózkodott.
Forrás: will.com