🥇Hogyan tanítsuk meg leküzdeni a nehézségeket, miközben ciklusokat is írnunk kell

Bár az egyik alapvető témáról lesz szó, ez a cikk tapasztalt szakembereknek készült. A cél az, hogy bemutassuk, milyen tévképzetek merülhetnek fel az újoncokban a programozás terén. A gyakorló fejlesztők ezek a problémák már régóta megoldottak, elfeledtek vagy egyszerűen figyelmen kívül hagyják őket. A cikk hasznos lehet, ha esetleg segítenie kell valakinek e téma elsajátításában. A cikk párhuzamokat von a programozással foglalkozó különböző könyvek, például Schilde, Stroustrup és Okulov műveivel.

A ciklusokról való téma választása azért történt, mert ezen a területen sok ember elakad a programozás elsajátítása során.

Ez a módszer gyenge diákok számára készült. Általában a erősebb diákok nem akadnak el ezen a témán, és nem szükséges számukra külön módszert kidolgozni. A cikk másodlagos célja, hogy ezt a módszert áttranszformálja a "működik minden diáknál, de csak egy tanár esetében" kategóriából a "működik minden diáknál, minden tanár számára" kategóriába. Nem igényel teljes eredetiséget. Ha már hasonló módszert alkalmaz, kérjük, ossza meg, miben különbözik az Ön változata. Ha alkalmazni kívánja, kérjük, számoljon be az eredményekről. Ha hasonló módszert talál a könyvek valamelyikében, kérjük, írja meg a címét.

Ezt a módszert négy évig dolgoztam ki, miközben különböző szintű hallgatókkal foglalkoztam. Összesen körülbelül ötven diák és kétezer órányi foglalkozás. Kezdetben a diákok örökre elakadtak ezen a témán, és távoztak. Minden egyes diák után a módszert és az anyagokat kiigazították. Az utolsó évben a diákok már nem akadtak el ezen a témán, ezért úgy döntöttem, hogy megosztom az eredményeimet.

Miért ennyi betű? A ciklusok pedig alapvető dolgok!

Ahogy már említettem, a gyakorló fejlesztők és a erősebb diákok számára a ciklusok koncepciójának bonyolultságát alulértékelhetjük. Például tarthatunk egy hosszú előadást, láthatjuk a bólintó fejeket és az értelmes szemeket. De amikor próbálják megoldani a feladatokat, hirtelen megállás és megmagyarázhatatlan problémák merülnek fel. Az előadás után a diákok biztosan csak részleges megértéssel rendelkeznek. A helyzetet súlyosbítja, hogy a diákok nem tudják pontosan megfogalmazni, miben tévedtek.
Egyszer észrevettem, hogy a diákjaim a példáimat hieroglifaként értelmezik. Vagyis olyan szövegdarabokként, amelyekbe bele kell írni egy "varázslatos" betűt, és akkor működni fog.
Néha azt vettem észre, hogy a diákok azt gondolják, hogy egy adott feladat megoldásához szükség van valami más szerkezetre, amit egyszerűen még nem mondtam el. Holott a megoldáshoz csak annyit kellett volna módosítani a példán.

Ezért arra az ötletre jutottam, hogy a fő figyelmet nem az kifejezések szintaxisára, hanem a ciklusokkal való ismétlődő kód refaktorálásának koncepciójára kell helyezni. Amint a tanulók elsajátítják ezt a gondolatot, bármilyen szintaxis a megfelelő gyakorlás segítségével azonnal elsajátítható.

Kinek és miért tanítok

Mivel nincsenek felvételi vizsgák, az órákon lehetnek erős és nagyon gyenge diákok egyaránt. Részletesebben a diákjaimról a cikkben lehet olvasni Az esti kurzusok hallgatóinak portréja
Az volt a célom, hogy a programozást mindenki elsajátíthassa, aki ezt szeretné.
Az óráim egyéniek, és a diák saját pénzét fizeti minden alkalommal. Látszólag a diákok optimalizálni fogják a költségeket és minimumot fognak követelni. Azonban az emberek nem csak a tudásért járnak személyes oktatóval tartott órákra, hanem azért a bizalomért, hogy amit elsajátítottak, valóban így van, a fejlődés érzése és az oktató (szakértő) jóváhagyása miatt. Ha a diákok nem érzik a fejlődést a tanulmányi előrehaladásukban, el fognak menni. Általánosságban az órákat úgy lehet felépíteni, hogy a diákok a megismert szerkezetek számának növekedését érzékeljék. Először részletesen tanulmányozzuk a while-t, aztán a for-t, majd a do while-t, és így létrehozunk egy ezer és egy éjszaka kurzust, amely két hónapig foglalkozik csak a ciklusokkal, míg a végén a diák egy standard könyvtárat írt le diktálásra. Azonban a gyakorlati problémák megoldásához nemcsak az anyag ismerete szükséges, hanem a függetlenség az alkalmazásában és az új információk keresésében. Ezért az egyéni kurzusok esetében helyesnek tartom azt az elvet, hogy minimális ismereteket adjak át és ösztönözzem a részletek és kapcsolódó témák önálló tanulmányozását. A ciklusokról szóló témában a minimális ismeretnek a while szerkezetét tartom. Ezen keresztül megérthető az elv. Az elv ismeretében pedig a for- és do-while szerkezeteket önállóan is elsajátíthatják.

A gyengébb diákok anyagának elsajátításához nem elegendő a szintaxis leírása. Több egyszerű, de változatos feladatot kell adni, és részletesebben kell példákat bemutatni. Végső soron az elsajátítás sebességét a diák kifejezések átalakítási képessége és az összefüggések keresése korlátozza. Az éleseszű diákok számára a legtöbb feladat unalmas lesz. Velük együtt dolgozva nem szükséges a 100%-os feladatmegoldásra ragaszkodni. Az anyagomat megtekintheti a GitHubomon. Igaz, a tároló inkább egy fekete könyv grimuarjára hasonlít — senki más, csak én nem értem, hogy mi hol található, és ha az ellenőrzés megbukik, az őrületbe kergethet.

A módszer a gyakorlatra összpontosít.

A teorát a feladatok megoldásának példáján magyarázzák el. A programozás alapjain csupán egy órás előadás keretein belül nem lehet hasznos előadást tartani egy adott témáról. 15-20 perc elegendő a koncepció elmagyarázásához. A legnagyobb nehézségek a gyakorlati feladatok elvégzésekor merülnek fel.
A kezdő pedagógusok egy előadáson elmondhatják az operátorokat, ágonkénti elágazásokat, ciklusokat és tömböket. De a diákok ezzel a tudással szembesülnek az információ megszerzésének problémájával.
Nemcsak elmondani kell az anyagot, hanem meg is győződni róla, hogy a hallgatók megértették azt.

A téma elsajátításának ténye az alapján dől el, hogy a diák önállóan hogyan oldja meg a feladatot.
Ha a diák sikeresen megoldja a problémát a téma alapján tanár segítsége nélkül, akkor a téma elsajátítva van. Az önálló ellenőrzés biztosítása érdekében minden feladathoz teszt-forgatókönyv táblázatot tartalmaz. A feladatoknak kifejezett sorrendje van. A feladatok kihagyása nem ajánlott. Ha a jelenlegi feladat túl nehéz, akkor a következő feladat megoldására lépni felesleges, mert az még nehezebb. Ahhoz, hogy a diák meg tudja oldani a jelenlegi nehéz feladatot, néhány praktikát kell elmagyaráznunk az első feladat példáján. Tulajdonképpen a téma összes tartalma a nehézségek leküzdésére összpontosít. A ciklusok inkább mellékhatások.

Az első feladat mindig példa. A második csak kis mértékben különbözik, és azonnal az első után „önállóan” készül el a tanár felügyelete alatt. Minden további feladat célja, hogy felhívja a figyelmet azokra a különféle apróságokra, amelyek félreértéseket okozhatnak.

A példa magyarázata egy párbeszéd, ahol a diáknek visszafelé terjesztenie és keresztellenőrzéseket kell végeznie, hogy biztosan elsajátítsa az anyagrészletet.

Banalitás lesz, ha azt mondom, hogy az első példa a témában nagyon fontos. Ha van anyag a jelentős önálló munkához, az első példa hiányosságait lehet pótolni. Ha csak példa van, valószínűleg a diák nem fogja elsajátítani a témát.

While vagy for?

Az egyik vitatott kérdés a példában a szerkezet választása: while vagy for. Egyszer egy ismerősöm, aki gyakorló fejlesztő, de nincs tanítási tapasztalata, egy órán keresztül győzködött, hogy a for ciklus a legérthetőbb. Az érvei az voltak, hogy "minden világos benne, és mindent a helyére rakott". Azonban a valódi újoncok nehézségeinek alapja a ciklus ötletében rejlik, nem pedig a megírásában. Ha valaki nem érti ezt az ötletet, akkor a szintaxisban is nehézségei lesznek. Amint az ötlet megértésre kerül, a kódformázással kapcsolatos problémák maguktól megszűnnek.

Az én anyagaimban a ciklusokról szóló téma a elágazásokkal foglalkozó téma után következik. Az if és while külső hasonlósága közvetlen párhuzamot vonhat: "amikor a feltétel igaz a fejlécben, akkor a test végrehajtódik". A ciklus különbsége csupán annyi, hogy a test sokszor végrehajtódik.

A második érvem az, hogy a while kevesebb formázást igényel, mint a for. Kevesebb formázás — kevesebb buta hiba a kihagyott vesszők és zárójelek miatt. Az újoncok figyelme és részletessége még nem eléggé fejlett ahhoz, hogy automatikusan elkerüljék a szintaktikai hibákat.
A harmadik érvem az, hogy sok jó könyvben a while-t először magyarázzák el.

Ha a diák könnyen tudja átalakítani a kifejezéseket, akkor megemlíthetjük a for-t futólag. A diák később magának választja ki, mi tetszik neki. Ha azonban az átalakítások nehézséget okoznak, akkor jobb nem elvonni a figyelmét. Először nézze meg mindent while-lal. Amikor a ciklusok témája elsajátítva van, átírhatjuk a megoldásokat, hogy gyakorolhassuk a while-ból for-ra való átalakítást.
A posztfeltételes ciklusok meglehetősen ritka jelenség. Erre egyáltalán nem vesztegetek időt. Ha a diák elsajátította a minták felfedezésének és a kifejezések átalakításának ötleteit, akkor képes lesz önállóan is eldönteni.

Amikor bemutatom az első példát a tehetséges diákoknak, felhívom a figyelmet arra, hogy az első példában nemcsak a megoldás, hanem az összes lépés is fontos, amely az eredményhez vezetett. A lustább diákok hajlamosak elhagyni a részletes leírást, és csak a végső algoritmust átkonvertálni maguknak. Meg kell győzni őket arról, hogy egyszer nekik is szembe kell nézniük egy nehéz feladattal. Annak megoldásához lépésről lépésre kell haladni, mint ebben a példában. Ezért fontos, hogy minden lépést rögzítsünk. A következő feladatoknál már csak a végső megoldást lehet bemutatni.

Az automatizálás alapgondolata az, hogy a gépre bízzuk a rutinszerű munkák elvégzését az ember helyett. Az egyik alapvető technika a ciklusok írása. Ezt alkalmazzuk, amikor a programban egymás után több azonos, ismétlődő lépést írunk le.

Az egyértelmű jobb, mint a homályos

Jónak tűnhet, ha az első ciklusokkal kapcsolatos feladatban többször kinyomtatunk egy azonos kifejezést. 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 a megoldás azzal a hátránnyal bír, hogy a kimenetben nem látszik a számláló értéke. Ez kezdők számára problémát jelent. Ezt nem szabad alábecsülni. Eleinte ez a feladat volt az első, míg a számok növekvő sorrendjének kiírása a második. Be kellett vezetnem a kifejezéseket: „ciklus N alkalommal” és „ciklus A-tól B-ig”, amelyek lényegében ugyanazt jelentik. Hogy ne teremtsünk felesleges entitásokat, úgy döntöttem, hogy csak a számok sorozatának kiírásával kapcsolatos példát mutatom be. Kevesen tudnak felkészülés nélkül megtanulni a számláló fejben tartását és a program viselkedésének modellezését. Néhány diák először a ciklusok témájánál találkozik a „fejben végzett” modellezéssel.
Néhány gyakorlás után az azonos szöveg ismétlésére vonatkozó feladatot önálló megoldásra adom. Ha először látható számlálót adunk, majd láthatatlant, akkor a diákoknak kevesebb problémájuk van. Néha elegendő a „ne írd ki a számlálót a képernyőre” utasítás.

Hogyan magyarázzák mások?

Az internetes oktatási anyagok többségében a ciklus szintaxisát "előadás" keretében mutatják be. Például a developer.mozilla.org-on (jelenleg) a while ciklussal együtt több más konstrukciót is tárgyalnak. Kizárólag a konstrukciókat adják meg sablon formájában. Az indításuk eredményét szavakkal írják le, és a szemléltetés hiányzik. Véleményem szerint egy ilyen téma prezentációja teljesen értéktelenné teszi az ilyen anyagokat. A tanuló átkonvertálhatja a kódot és futtathatja magát, de a megfelelő referencia még így is szükséges. Hogyan érthetjük meg, hogy a példa helyesen van átírva, ha nincs mivel összehasonlítani az eredményt?
Amikor csak egy sablont kapunk példa nélkül, a diáknak még nehezebb dolga van. Hogyan lehet megérteni, hogy a kóddarabok helyesen vannak-e elhelyezve a sablonban? Megpróbálhatunk írni valahogyan, majd futtatni. De ha nincs referencia az eredmény összehasonlítására, akkor a futtatás sem segít.

A C++ kurzus során az Intuit-nél a ciklus szintaxisát a 4. lecke harmadik oldalán tematikailag „operátorok” alatt rejtik el. A ciklusok szintaxisának magyarázata során különös hangsúlyt fektetnek a „operátor” kifejezésre. A kifejezés egy tények halmazaként van bemutatva, mint például „a szimbólum; ez operátor”, "{} ez összetett operátor", „a ciklus törzsének operátornak kell lennie”. Nem tetszik ez a megközelítés, mert mintha az egyes terminusok mögé fontos összefüggéseket rejtene. A program forráskódjának ilyen szintű bontása a nyelv specifikációjának megvalósításához szükséges a fordítók fejlesztői számára, de nem a diákok szempontjából az első közelítésben. A programozásban kezdők ritkán rendelkeznek elegendő alapossággal ahhoz, hogy ilyen figyelmesen kezeljék a kifejezéseket. Ritka, hogy valaki egyből megjegyez és megért új szavakat. Gyakorlatilag senki sem tudja helyesen alkalmazni egy újonnan tanult kifejezést. Ezért a diákok között számos hiba keletkezik, mint például „írtam while(a<7);{, de a program nem működik”.
Véleményem szerint először jobb lenne az összeszerelés szintaxisát azonnal zárójelekkel bemutatni. A zárójelek nélküli változatot csak akkor érdemes magyarázni, ha a diáknak konkrét kérdése van, mint például „miért működik így zárójelek nélkül”.

Okulov könyvében, "Programozás alapjai", 2012-ből, a ciklusok bemutatása a for sablonnal kezdődik, majd ajánlások következnek a használatára, és ezt követi az órák kísérleti része. Úgy értem, a könyvet azok számára írták, akik rendkívül tehetségesek, és ritkán járnak az óráimra.

A népszerű könyvekben mindig szerepel a kód töredékek kimenetele. Például Schilde "Java 8. Teljes útmutató", 2015-ös kiadásában. Először megadják a sablont, majd a program példáját, és azonnal utána — a végrehajtás eredményét.

Példaként vizsgáljuk meg a while ciklust, amelyben visszafelé számolunk,
kezdve a 10-től, és pontosan 10 sort "ütést" írunk ki:
//Продемонстрировать применение оператора цикла while
class While {
    public static void main(String args []) {
        int n = 10;
        while (n > 0) {
            System.out.println("такт " + n);
            n--;
        }
    }
}
A program elindítása után tíz "ütést" az alábbi módon ír ki:
takt 10 takt 9 takt 8 takt 7 takt 6 takt 5 takt 4 takt 3 takt 2 takt 1

A sablon leírásával, a program példájával és a program eredményével kapcsolatos megközelítést használják a "JavaScript gyerekeknek" című könyvben, valamint a w3schools.com js tanfolyamán. A weboldal formátuma lehetővé teszi, hogy ez a példa interaktív legyen.

A Stroustrup "C++ használatának alapelvei és gyakorlata", 2016-os könyvében az író még tovább ment. Először is elmagyarázza, hogy milyen eredményt kell elérni, és csak utána mutatja be a program szövegét. Ráadásul nem csupán egy véletlenszerű programot választanak, hanem történeti áttekintést adnak. Ez segít felhívni rá a figyelmet: "Nézd, ez nem csupán egy haszontalan szöveg. Valami jelentőséget látsz benne."

Példaként vegyük a programozás első iterációját, amelyet tárolt programmal rendelkező gépen (EDSAC) hajtottak végre. Ezt David Wheeler írta a Cambridge-i Egyetem számítógépes laboratóriumában, 1949. május 6-án. Ez a program egyszerű négyzetlistát számol ki és nyomtat ki.
0 0 1 1 2 4 3 9 4 16 ... 98 9604 99 9801
Itt minden sorban szerepel egy szám, amit egy tabulátor (‘t’) és a szám négyzetének értéke követ. Ennek a programnak a 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, hogy a könyvben a szintaxis sablonja nincs leírva. Stroustrup az oktatói útmutatóban (fordítás) hangsúlyozza, hogy tiszteletben tartja a diákjai intelligenciáját. Talán a sablonok azonosítása több példa alapján valóban a intelligencia megnyilvánulásának számít.

Ahogyan én magam magyarázom

A Stroustrup-approach: describing the result, then solving the problem, and then having the student analyze it independently — seems the most thought-out. That’s why I decided to base my explanation on it, but to illustrate it with a less historical example — the task of outputting a 'table of contents'. It creates a recognizable anchor so that later I can say, 'remember the task about the table of contents' and the students will recall it specifically. In my example, I aimed to address two of the most common misconceptions as well. I will discuss them in more detail below.

In this task, we familiarize ourselves with methods for solving complex problems. The initial solution should be primitive and straightforward. Then we can think about how to improve that solution.
Bevezetés 1. fejezet 2. fejezet 3. fejezet 4. fejezet 5. fejezet 6. fejezet 7. fejezet Zárás

From my observations, the 'template-example-result' approach in different combinations still leads students to perceive the loop as hieroglyphs. This manifested in them not understanding why they should write a condition, how to choose between i++ and i–, and other seemingly obvious things. To avoid these misconceptions, the approach to explaining loops should emphasize the meaning of repeating the same actions and only then — formatting them using a construct. Therefore, before providing the syntax of the loop, a direct problem needs to be solved. A primitive solution for the table of contents task looks like this:

Console.WriteLine("Bevezetés");
Console.WriteLine("1. fejezet");
Console.WriteLine("2. fejezet");
Console.WriteLine("3. fejezet");
Console.WriteLine("4. fejezet");
Console.WriteLine("5. fejezet");
Console.WriteLine("6. fejezet");
Console.WriteLine("7. fejezet");
Console.WriteLine("Zárszó");

How can it be improved?
Replace repetitive actions with a loop.
Which actions are repeated here consecutively without changes?
There are none in this fragment. However, the commands for outputting the word 'Chapter' with a number are very similar to each other.
Therefore, the next step is to find the differences between the fragments. It's only in this task that everything is obvious; later, not single commands will repeat, but blocks of code with five lines or more. Searching will have to be done not just in a list of commands, but in branching or loop constructs.
In the example, the difference between the commands is the number after the word 'Chapter'.
Once the difference is found, it is necessary to understand the pattern of change. Is the differing fragment a number? Does it consistently increase or decrease? How does the value of the number change between two commands next to each other?
A példában a «Fejezet» szó utáni szám 1-es lépésekben növekszik. A különbség felfedezve, a szabályosság azonosítva. Most kicserélhetjük a különböző részt egy változóra.
Egy ilyen változót a repetitív részek első megjelenése előtt kell deklarálni. Ezt a változót általában i-nek vagy j-nek nevezik, vagy valamilyen bővebb névvel. Kezdeti értéke legyen megegyező az első megjelenített é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ámok sorozatának megjelenítéséhez?
Ebben a sorozatban az első szám 100.
Minden kiírás után ezt a változót 1-gyel kell növelni. Ez az egység a változtatás lépése.
Milyen lépés lesz a „100, 102, 104, 106” számok sorozatában?
Ebben a sorozatban a lépés 2.
A különböző rész kicserélése után a kód a következőképpen fog kinézni:

Console.WriteLine("Bevezetés");
int i;
i = 0;
Console.WriteLine("Fejezet " + i);
i = i + 1;
Console.WriteLine("Fejezet " + i);
i = i + 1;
Console.WriteLine("Fejezet " + i);
i = i + 1;
Console.WriteLine("Fejezet " + i);
i = i + 1;
Console.WriteLine("Fejezet " + i);
i = i + 1;
Console.WriteLine("Fejezet " + i);
i = i + 1;
Console.WriteLine("Fejezet " + i);
i = i + 1;
Console.WriteLine("Zárás");

A «szabályosság változóként kifejezése» módszer alkalmazása után a kódban több azonos cselekvéscsoport következik egymás után. Most a repetitív cselekvéseket ciklussal helyettesíthetjük.

A feladat megoldásának folyamata, ahol ciklusokat kell használni, a következő lépésekből áll:

Megoldani «nyíltan» sok külön parancs által
Felfedezni a szabályosságot
Kifejezni a szabályosságot változóként
Ciklusba foglalni

Ezután új kifejezések kerülnek bevezetésre, hogy a hallgató ne kerüljön abba a helyzetbe, hogy «mindent értek, de nem tudom elmondani»:
— számláló — mindig egy változó, amely a ciklus lépéseinek számát nyomon követi. Általában egy egész szám, amelyet egy határral összehasonlítanak.
— számláló lépése — a számláló változásának szabályosságát leíró.
— határ — szám vagy változó, amellyel a számlálót összemérjük, hogy az algoritmus véges legyen. A számláló értéke úgy változik, hogy közelít a határhoz.
— ciklus teste — a parancsok halmaza, amelyek ismétlődnek. Amikor azt mondják, hogy «a parancs a cikluson belül van megírva», akkor a testre gondolnak.
— ciklus iteráció — a ciklus testének egyszeri végrehajtása.
— a ciklus feltétele — logikai kifejezés, amelytől függ, hogy végrehajtódik-e egy új iteráció. (Itt zavar keletkezhet az ágazó szerkezetekkel kapcsolatban)
Készen kell állni arra, hogy az első időszakban a diákok nem a megfelelő értelemben használják a kifejezéseket. Ez mind a erős, mind a gyenge diákokra vonatkozik. A közös nyelv kialakítása teljes művészet. Most röviden írom: fel kell tenni a feladatot „emeld ki a kód egy darabját a ” és saját magunknak helyesen kell használnunk ezeket a kifejezéseket a beszélgetés során.
A ciklussal történő átalakítás után a következő kódmaradvány keletkezik:

Console.WriteLine("Bevezetés");
int i = 0;
while (i < 7) {
    Console.WriteLine("Fejezet " + i);
    i = i + 1;
}
Console.WriteLine("Záró gondolat");

A legfőbb tévhit

Egy népszerű tévhit a diákok körében, hogy a ciklus szerkezetén belül olyan tevékenységeket helyeznek el, amelyeket egyszer kell csak megtenni. Például így:

;
int i = 0;
while (i < 7) {
    Console.WriteLine("Bevezetés")
    Console.WriteLine("Fejezet " + i);
    i = i + 1;
    Console.WriteLine("Záró gondolat");
}

A diákok folyamatosan találkoznak ezzel a problémával, mind a kezdeti, mind a bonyolultabb feladatok során.
A koronás tipp ebben az esetben:

Hányszor szükséges a parancs írását megismételni: egyszer vagy többször?

A "Bevezetés" és "Záró gondolat" szavak kiírása, valamint az i változó deklarációja és inicializálása nem hasonlít a többi ismétlődő tevékenységre. Ezeket egyszer hajtjuk végre, tehát azokat a ciklus testen kívül kell írni.

A kódban mindhárom lépésnek meg kell maradnia a megoldás érdekében, hogy utólag hivatkozhassunk rájuk. Az első két variációt elég kommentálni, hogy ne zavarják a folyamatot.
A diák figyelmét az alábbi tényekre kell irányítani:
— A ciklus feltételében általában a számláló és a határérték összehasonlítása történik. A számláló módosulhat a ciklus testen belül, a határérték azonban nem. E szabály megsértéséhez komoly okokat kell megfogalmazni.
— A "Bevezetés" és "Záró gondolat" testi kiírásai a ciklus testen kívül helyezkednek el. Ezeket egyszer kell végrehajtanunk. A "Bevezetés" — a tevékenységek megismétlése előtt, a "Záró gondolat" — pedig az után.
A téma megértése, a következőek elsajátítása, valamint a nehézségek tisztázása során még a erős diákoknak is hasznos feltenni a kérdést: „Ez a tevékenység hányszor szükséges? Egyszer vagy többször?”.

További készségek fejlesztése

A ciklusok tanulmányozása során a diákok továbbra is gyakorolják a diagnosztizálás és a problémamegoldás képességét. A diagnózis felállításához a diákoknak el kell képzelniük a kívánt eredményt, és össze kell hasonlítaniuk azt a tényleges eredménnyel. A kettő közötti eltérés határozza meg a szükséges lépéseket a hiba korrigálásához.
Mivel ebben a szakaszban a diákok még nem rendelkeznek jól megformált elképzelésekkel a kívánt eredményről, gyakran tesztadatokra támaszkodhatnak. Általában ezen a szakaszon senki sem érti, hogy mi mehet rosszul, és hogyan kell ezzel megbirkózni. Ezért írásban megadom a leggyakoribb problémák leírását és néhány megoldási módot. A legmegfelelőbb kiválasztása a diák feladata.
Az írás szükséges ahhoz, hogy a diákok megkérdezhessék: "Az elvárt eredmény megvalósult?", "Melyik helyzet állt elő most?", "Segített-e az alkalmazott megoldás?".

Egy lépés végrehajtása egyel kevesebb vagy több, mint ami várható. Megoldási lehetőségek:
— növelje a számláló kezdeti értékét 1-gyel.
— cserélje le a szigorú összehasonlító operátort (< vagy >) egy nem szigorú operátorra (<= vagy >=).
— módosítsa a korlátozás értékét 1-gyel.
A cikluson belüli cselekvések megállás nélkül, végtelenségig hajtódnak végre. Megoldási lehetőségek:
— adja hozzá a számláló változtatására szolgáló parancsot, ha az hiányzik.
— javítsa ki a számláló változtatására szolgáló parancsot, hogy az értéke közelebb kerüljön a határértékhez.
— távolítsa el a határérték módosítására vonatkozó parancsot, ha az a ciklus törzsében van.
A ciklusban végrehajtott lépések száma több, mint 1-gyel kevesebb vagy több, mint ami várható. A ciklusban egyetlen lépés sem valósult meg. Először a változók tényleges értékeit kell feltárni közvetlenül a ciklus megkezdése előtt. Megoldási lehetőségek:
— módosítsa a korlátozás kezdeti értékét
— módosítsa a számláló kezdeti értékét

Általában a 3. probléma azzal függ össze, hogy nem a megfelelő változót használják, vagy a számláló nincs nullázva.

E magyarázat után a diákoknak továbbra is lehetnek téves elképzeléseik a ciklusok működéséről.
A leggyakoribb kételyek eloszlatására feladatokat adok:

Amelyben a korlátozást, a számláló kezdeti értékét vagy a számláló lépését a felhasználó adja meg.
Amelyben a számláló értékét valamilyen aritmetikai kifejezésben kell használni. Lehetőleg a számláló legyen a nevezőben, hogy a különbség nemlineáris legyen.
Amelyben a számláló értéke nem jelenik meg a ciklus futása alatt. Például a szükséges számú azonos szövegrészlet kibocsátása vagy figura rajzolása teknős grafikával.
Amelyben először egyes ismétlődő feladatokat kell elvégezni, majd másokat.
Amelyben más feladatokat kell elvégezni az ismétlődők előtt és után.

Minden feladathoz tesztadatokat és várt eredményt kell megadni.

Ahhoz, hogy megértsük, milyen gyorsan lehet haladni, meg kell adni az adott feladatok feltételeit, és megkérdezni: „miben különböznek a példától?”, „mit kell megváltoztatni a példában, hogy megoldhatóak legyenek?” Ha a diák értelmesen válaszol, akkor próbáljon megoldani legalább egyet az órán, a többit pedig otthon önállóan. Ha a megoldás sikeres, akkor lehet elkezdeni a ciklusok belső feltételeinek magyarázatát.
Ha a önálló megoldással nehézségek merülnek fel, akkor mindent az órán kell gyakorolni. Annak érdekében, hogy a feladat megoldása ne hasonlítson a baglyot rajzolására, javaslom, hogy először ne általános megoldást találjunk. Azaz úgy, hogy a megoldás megfeleljen az első tesztnek, és ne használja a ciklus szerkezetét. Majd később alkalmazzunk átalakításokat az általános megoldás eléréséhez.

Ciklusok és elágazások

Szerintem hasznos lenne a „ciklusok elágazásokon belül” témát külön bemutatni. Így később láthatóvá válik a különbség a feltételek többszöri ellenőrzése és egyszeri ellenőrzése között.
A gyakorló feladatok a felhasználó által megadott A és B közötti számok kinyomtatására vonatkoznak:
— mindig növekvő sorrendben.
— növekvő vagy csökkenő sorrendben A és B értékétől függően.

A „ciklusokon belüli elágazások” témára csak akkor szabad áttérni, miután a diák elsajátította a következő módszereket: „a szabályszerűség változóval való helyettesítése” és „az ismétlődő folyamatok ciklussal való helyettesítése”.
A ciklusokon belüli elágazások alkalmazásának fő oka — a szabályszerűségek anomáliái. Középen ez megszakad a bemeneti adatok függvényében.
Azoknak a diákoknak, akik képesek arra, hogy egyszerű módszerek kombinálásával keressenek megoldásokra, elegendő azt mondani, hogy „az elágazásokat lehet ciklusokba írni”, és adni kell egy mintafeladatot, amelyet teljesen önállóan kell megoldani.
Minta feladat:

A felhasználó megad egy X számot. Írja ki egy oszlopban a 0-tól 9-ig terjedő számokat, és helyezzen egy ‘+’ jelet arra a számra, amely egyenlő X-sel.

Ha 0-t adtak meg0+
1
2
3
4
5
6
7
8
9

Ha 6 szerepelt0
1
2
3
4
5
6+
7
8
9

Ha 9 szerepelt0
1
2
3
4
5
6
7
8
9+

Ha 777 szerepelt0
1
2
3
4
5
6
7
8
9

Ha hiányzik a rövid magyarázat ahhoz, hogy ciklussal írhassuk meg, akkor el kell érnünk ezt a feladatot ciklus nélkül egy univerzális megoldással.
Az alábbi két variáció közül az egyik fog megvalósulni:
Kívánt

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 előre adok, miközben a feltételes utasításokról tanulunk.
Ha a hallgatónak a "lehetséges" variáció jött ki, akkor el kell mondani, hogy ugyanannak a feladatnak számos megoldása lehet. Azonban ezek eltérnek a követelmények változásaival szembeni ellenállóságtól. Kérdezd meg: "Hány helyet kell majd javítani a kódban, ha még egy számot kell hozzáadni?" A "lehetséges" variációhoz egy új ágat kell hozzáadni, és 10 másik helyen fel kell tüntetni az új számot. A "kívánt" variációhoz elég egy új ágat hozzáadni.
Állítsd fel a feladatot reprodukálni a "kívánt" variációt, majd találd meg a kódban a szabályosságot, végezz el egy változó cserét és írj egy ciklust.
Ha van ötletem arra, hogyan lehetne ezt a feladatot ciklus nélkül más módon megoldani, kérlek, írd meg a megjegyzésekben.

Ciklusok ciklusokon belül

Ebben a témában figyelni kell arra, hogy:
— a belső és külső ciklus számlálóinak különböző változóknak kell lenniük.
— a belső ciklus számlálóját többször is nullázni kell (azaz a külső ciklus törzsében).
A feladatokban nem lehet először egy betűt több sorba írni, majd a másodikat. Először az első sor összes betűjét kell kiírni, majd a második sor összes betűjét, és így tovább.

A ciklusokba ágyazott ciklusok témájának magyarázatát a számláló nullázásának fontosságával érdemes kezdeni.
Minta feladat:

A felhasználó két számot ad meg: R és T. Két "#" karakterből álló sort kell kiírni. Az első sorban R darab karakternek kell lennie. A második sorban T darabnak. Ha bármelyik szám negatív, hibaüzenetet kell kiírni.

R=5, T=11#####
###########

R=20, T=3####################
###

R=-1, T=6Az R értéke nem lehet negatív.

R=6, T=-2A T értéke nem lehet negatív.

Nyilvánvaló, hogy ennek a feladatnak is legalább két megoldási lehetősége van.
Kívánt

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 a második sor kiírásához egy második változót használtak. Ki kellene tartani amellett, hogy ugyanazt a változót használjuk mindkét ciklushoz. Ezt a korlátozást azzal lehet érvelni, hogy a két ciklushoz egy számlálóval történő megoldás illusztrálja a "számláló nullázásának" fogalmát. Ennek a fogalomnak a megértése szükséges a következő feladatok megoldásához. Kompromisszumként mindkét megoldást lehetővé lehet tenni.

A tipikus probléma, amely egy számláló változó egy ciklusban való használatából adódik, így jelentkezik:
R=5, T=11#####
######

A második sorban a karakterek száma nem felel meg a T értékének. Ha ebben a problémában segítségre van szükség, akkor "rá kell mutatni" a ciklusokkal kapcsolatos tipikus problémák jegyzetére. Ez a 3. tünet. Diagnosztizálható, ha közvetlenül a második ciklus előtt kiírjuk a számláló értékét. Nullázással javítható. De ezt jobb azonnal nem elmondani. A hallgatónak meg kell próbálnia legalább egy hipotézist megfogalmazni.

Természetesen van más megoldási lehetőség is. De ezt a hallgatóimnál még sosem láttam. A ciklusok tanulmányozásának szakaszában róla való beszélgetés elvonhatja a figyelmet. Később visszatérhetünk rá, a karakterműveletek tanulmányozásakor.
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));

A következő kötelező feladat:

Írja ki a képernyőre a 0-tól 9-ig terjedő számokat. Minden szám új sorban jelenjen meg. A sorokban lévő számok száma (W) a billentyűzetről van beírva.

W=10
1
2
3
4
5
6
7
8
9

W=100000000000 1111111111 2222222222 3333333333 4444444444 5555555555 6666666666 7777777777 8888888888 9999999999

Ha a diák megtanulta a változócserét, akkor viszonylag gyorsan boldogulni fog. A lehetséges probléma ismét a változó nullázása lesz. Ha nem boldogul a konvertálással, akkor túl gyorsan haladt, és egyszerűbb feladatokat kell megoldania.

Köszönöm a figyelmet. Lájkoljon, iratkozzon fel a csatornára.

P.S. Ha hibát vagy elgépelést észlel a szövegben, kérem, értesítsen. Ezt megteheti, ha kijelöl egy szövegrészt, és Mac-en megnyomja a „⌘ + Enter” billentyűt, klasszikus billentyűzeteken pedig a „Ctrl / Enter” kombinációt, vagy személyes üzenetben is. Ha ezek a lehetőségek nem elérhetők, kérjük, jelezze a hibákat a megjegyzésekben. Köszönöm!

Csak a regisztrált felhasználók vehetnek részt a szavazáson. Kérem, jelentkezzen be., kérem.