.: Németh Imre Általános Iskola :.
Programozási alapok a Kódszerkesztőjével - online tankönyv
Creative Commons Licenc
A "Programozási alapok a BLOCKLY Kódszerkesztőjével - online tankönyv" Creative Commons Nevezd meg! - Ne add el! - Így add tovább! 4.0 Nemzetközi Licenc alatt van.
TARTALOMJEGYZÉK

Ugráshoz klikk a Tartalomjegyzékben a megfelelő sorra!

00. fejezet, ahol a linkre kattintva ismétlési lehetőséged nyílik BLOCKLY Teknőccel...

01. fejezet, melyben szó lesz az algoritmusról, az algoritmus leírásának típusairól, és megkezdjük az ismerkedést a Blockly Kódszerkesztővel...
02. fejezet, melyben ismerkedünk a sztring, a változó és az értékadás fogalmával, szerkezeti diagramot készítünk, és első programjaidat is megírhatod...
03. fejezet, melyben szó lesz a konstansról, szövegek (karakterek és sztringek) kezeléséről, és természetesen további programokat is készíthetsz...
04. fejezet, melyben egyszerű és kicsit bonyolultabb matematikai műveletek programozását gyakoroljuk, de szó lesz egy kicsit a fizikáról is...
05. fejezet, melyben elméletben szó lesz az elágazások típusairól, gyakorlatban az egyszerű v. kétirányú elágazást ismerheted meg...
06. fejezet, melyben folytatjuk az elágazások megismerését, csak egy fokkal már bonyolultabb példákkal...
07. fejezet, melyben megismerkedünk a ciklusok típusaival és elkészítjük az első olyan blockly-s programot, mely ciklust is tartalmaz...
08. fejezet, melyben folytatjuk a ciklusokkal való ismerkedést, de most már inkább csak gyakorlatban, és egyre bonyolultabb algoritmusokat oldunk meg...
09. fejezet, melyben megtudhatod, mi az eljárás (más néven alprogram), hogyan lehet ilyet készíteni, és mikor érdemes ezt az eszközt alkalmazni...
10. fejezet, melyben a paraméteres eljárásokkal ismerkedünk, és szó lesz a lokális (helyi) és globális változókról...
11. fejezet, melyben a rekurzió a téma, majd rekurzív eljárást tartalmazó programot is készítünk...
12. fejezet, melyben az adatok rendezésével ismerkedünk, majd adatainkat megpróbáljuk sorba is állítani...
13. fejezet, melyben érdekes feladatok következnek, a BLOCKLY néhány újabb lehetőségével ismerkedhetsz, a gyakorlatban mélyítheted tudásod...
14. fejezet, melyben kiderül, hogy aki egy adott programozási nyelven az alapokat már elsajátította, az más programozási nyelvet is képes megtanulni...
15. fejezet, melyben folytatjuk a BLOCKLY és PASCAL programok összehasonlítását, ezzel is bővítve programozási alapismereteinket...
16. fejezet, "merre tovább, melyik úton?" - javaslatok a továbblépéshez...

1. BLOCK(LY)

01. fejezet, melyben szó lesz az algoritmusról, az algoritmus leírásának típusairól, és megkezdjük az ismerkedést a Blockly Kódszerkesztővel...

1.1. Bár nagy valószínűséggel találkoztál már rajzos programozási feladatokkal őkelme a LOGO Teknőc, vagy a BLOCKLY Teknőc segítségével, most egy más típusú programozásnak állunk neki. Érdemes ezért a programozás elméleti alapjaival kezdened az ismerkedést! A legfontosabb általános ismeretek összefoglalásra kerültek "Az algoritmusról (bevezetés a programozáshoz)" nevű pdf bemutatóban, melyet alább letölthetsz!

1.2. Ismerkedjünk meg azzal a fejlesztői környezettel amit használni fogunk! A BLOCKLY-t - ezt az online, vizuális programozási környezetet - 2012. június elején mutatta be a Google szoftveróriás, és azóta is fejleszti. Amivel mi dolgozni fogunk, az a BLOCKLY Demos Kódszerkesztő, amit a néhány sorral alábbi linkről elérhetsz. Nem magyarázok sokat, valószínű az egyes - a képernyőn található - elemek feladatát gyorsan megtalálod majd. Három dolgot előzetesen:
1. A baloldali eszköztárakból érheted el a BLOCKLY jellemző - puzzle darabokra hasonlító - blokkjait, ezek segítségével - mint építőkockákból - építhetjük fel programunkat. Ezek az ezköztárak tartalmazzák a BLOCKLY Kódszerkesztő alapvető utasításkészletét is.
2. A felső fülek segítségével bármikor megtekinthetjük azt, hogyan is néz ki programunk valamelyik elérhető forráskód alapú nyelvben (JavaSript, Python, XML).
3. A jobb felső sarokban a vezérlőgombok a BLOCKLY Teknőc felületéről már részben ismerősek lehetnek, ezekkel törölhetsz, hozhatsz létre hivatkozást, és futtathatod a blokkokból felépített programot...

1.3 A középső vezérlőgomb (Hivatkozás létrehozása) azért hasznos, mert segítségével a böngésző címsorába generálódik egy hivatkozás, amit egy külső fájlba menthetsz, és segít abban, hogy később is előhívhasd elkészült, vagy félbehagyott programodat! Ezen oktató anyag hivatkozásait is így készítettem...

Hf-1/1. Ismételd át a BLOCKLY Games Labirintusát!
Hf-1/2. Ismételd át a BLOCKLY Games Teknőc szintjeit!
Hf-1/3. Ismételd át a BLOCKLY Demos Repülőgép alkalmazás szintjeit!
Hf-1/4. Az elméleti tanulnivaló a BLOCK(LY) 1. fejezet, illetve "Az algoritmusról (bevezetés a programozáshoz)" PDF bemutató 2-10. és 22-27. dia
Hf-1/5. Ismételj át BLOCKLY Teknőc rajzos programozási feladatokat!

2. BLOCK(LY)

02. fejezet, melyben ismerkedünk a sztring, a változó és az értékadás fogalmával, szerkezeti diagramot készítünk, és első programjaidat is megírhatod...

2.1. "Helló világ!" A wikipédián találtam a következő gondolatokat: "A „Helló, világ!” programok olyan számítógépes programok, melyek egyszerűen kiírják a megjelenítőeszközre: „Helló, világ!” (angolul: „Hello world!”). Sok bevezető programozási nyelvi oktatóanyagban szerepel ez, és sok tanuló használja egy nyelvben való első lépés gyanánt." Található a wikipédián egy olyan szócikk ("Helló világ!" programpéldák listája), ami sok-sok eltérő programozási nyelv szabályai szerint mutatja meg, hogyan kell megfogalmazni ezt az egyszerű mondatot. Érdemes rákeresni!

Álljunk neki, és készítsük el első programunkat BLOCKLY Kódszerkesztőben! A 'Sztring műveletek' eszköztárból kell kiválasztani a megfelelő blokkokat, ahogy az alábbi mintában láthatod! Miután sikerült neked is elkészítened, futtasd a jobb felső sarokban lévő piros alapú nyíl ikonnal!

2.2 Érdemes a kész program forráskódját megtekinteni JavaScript, Python Dart és XML alatt! Húú, ha XML-ben kéne megírni programunkat a blokkok használata helyett, hányszor kéne nekifutni, mire jó lenne!

2.3. Használtam egy "csúnya" szót: "sztring" - karakterláncot jelent, a programozásban a szöveges adatokkal, adattípussal kapcsolatban használt kifejezés.

2.4. A változók fogalma és használata. Ahhoz, hogy tovább léphessünk meg kell ismerkednünk a változó fogalmával. Mit is jelent? Egyszerűen fogalmazva, hogy te is megértsd, aki nem vagy programozó matematikus, olyan adatot képes tárolni a változó, mely adat értéke a program futása során, vagy a program újbóli futásakor megváltozhat. Ezért nem állandó, hanem változó... :-) A változóknak a programban nevet kell adni, ez lehet egy-egy betű, vagy rövid - a benne tárolt adatra utaló - szó. Érdemes hozzászoknod, hogy a változóknál nem használsz ékezetes karaktereket, mert vannak olyan programozási nyelvek - és a komolyabbak ilyenek -, amelyek nem tűrik az ékezetes karaktereket a változók nevében.
A BLOCKLY-ban elég egyszerű a változók használata, de itt is megismerkedhetünk matematikai (szám) típusú, logikai típusú és sztring (szöveg) típusú változókkal. Forráskód alapú programozási nyelvekben (mint például a régebben az oktatásban használt Turbo Pascal) ezek használata sokkal bonyolultabb volt...

2.5. Következő programunkban a háromszög területét fogjuk kiszámolni billentyűzetről bevitt input adatok segítségével (alap és magasság), melyek bevitt értékét a megfelelően megadott változók fogják tárolni.
Újból használtam egy "csúnya" szót: input adat - a program számára bevitt adatot jelent, a beviteli eszköz leggyakrabban a billentyűzet. Ellentéte az output adat, mely a program által kiadott (gyakran a képernyőn vagy nyomtatón megjelenített) adatot, választ jelenti.

2.6. Az értékadás azt jelenti, hogy egy adott változóhoz értéket társítunk. Az értékadás lehet konkrét, megadott értékű (szám vagy szöveg), de ennél izgalmasabb az, amikor a változó értékének egy kifejezés értékét adjuk. BLOCKLY programunkban a változót jelképező blokk felvételével kezdünk, majd jobbról illesztjük hozzá az értéket, tehát egy konkrét értéket, matematikai kifejezést, vagy az input adat bekérését.

Feladat-1. Milyen változók használatával készítsük el a háromszög területét kiszámító programot? Mely változóknak adjunk értéket input adattal és melyik legyen az, amelynek értékadása matematikai kifejezéssel történjen?
Feladat-2. A tervezéshez készíts struktogramot (szerkezeti diagramot)! A szerkezeti diagram készítésének alapvető szabályaival a blokk elején ismerkedhettél az algoritmusról szóló PDF bemutató segítségével.

Feladat-3. Miután elemzésre került a fenti blockly-s programkód, önállóan is próbáld meg elkészíteni úgy, hogy először csak a program vázát készíted el (adat bekérése szöveges üzenet nélkül, értékadás, eredmény megjelenítés)! Futtasd a megfelelő vezérlőgombbal!
Feladat-4. Amennyiben a program váza már jól működik, tedd felhasználóbaráttá programodat azzal, hogy a szöveges üzenetek megjelenítésével is kiegészíted!

Hf-2/1. Az elméleti tudásban a BLOCK(LY) 2. fejezet, illetve "Az algoritmusról (bevezetés a programozáshoz)" PDF bemutató 15-17. diák segítségével tudsz elmélyedni.
Hf-2/2. Készíts struktogramokat (szerkezeti diagramokat) melyeken megtervezed a téglalap kerületét, illetve területét kiszámító programokat!
Hf-2/3. Készíts programot mely a téglalap kerületét számítja ki, input adatként megadott "a" és "b" oldal értékével! (változók: "a", "b", "kerulet")
Hf-2/4. Készíts programot mely a téglalap területét számítja ki, input adatként megadott "a" és "b" oldal étékével! (változók: "a", "b", "terulet")
Hf-2/5. Készíts struktogramokat (szerkezeti diagramokat) melyeken megtervezed a kör kerületét, illetve területét kiszámító programokat!
Hf-2/6. Készíts programot mely a kör kerületét számítja ki, input adatként megadott sugár értékével! (változók: "sugar", "kerulet")
Hf-2/7. Készíts programot mely a kör területét számítja ki, input adatként megadott sugár értékével! (változók: "sugar", "terulet")
Hf-2/8. Készíts programot, mely a négyzet kerületét és területét számolja ki! (változók: "a", "kerulet", "terulet")

3. BLOCK(LY)

3. fejezet, melyben szó lesz a konstansról, szövegek (karakterek és sztringek) kezeléséről, és természetesen további programokat is készíthetsz...

3.1. Kezdjük azzal, hogy az előző fejezetben megfogalmazott (házi) feladatokat kissé megvariáljuk. Lássuk, hogyan lehet egy programban az input adatokat többször felhasználva kiszámítani a téglalap kerületét és területét is.

3.2. Most nézzük meg, hogyan lehet - hasonlóan az előzőekhez - kiszámítani a kör kerületét és területét. Ha matematikai ismereteidet jól használod, itt találkozni fogsz a "pí" problémájával. A "pí"-t konstans (állandó) értékként beszúrhatjuk a blockly-s értékadásba a Kódszerkesztő 'Matematikai műveletek' eszköztárából. Ilyen módon nem kell változóként felvennünk, bár ez is egy lehetséges jó megoldása lenne a blockly-s programnak. Na, de egy változó aminek az értéke állandó, az hogy néz már ki...? (Igazából később, amikor mi magunk definiálunk konstansokat, erre a 'Változók' eszköztár blokkjait tudjuk majd használni... :-))

3.3. Biztosan feltűnt, hogy mind a szerkezetei diagramokban, mind a blockly-s programokban elhelyezésre került egy első sor, mely utal a leírt algoritmus, illetve program tartalmára. Nevezhetjük ezt a "program neve" sornak. Sok fejlesztői rendszerben a program fejlécében kell meghatározni például a program nevét, a használt változókat, használt konstansokat, esetleg olyan külső modulokat, amiket a program futása során meghív. A BLOCKLY-ban ezekre nincs szükség, jelezzük azonban azt, hogy egy algoritmus leírásának, vagy a programnak ilyen kötelező részei is lehetnek azzal, hogy a program nevét ilyen módon felvesszük!

Feladat-1. Néhány programot már átnéztél, megírtál. Nézd át a fejezet eddigi programjait még egyszer, és próbáld meg kevesebb sorral és változóval megoldani a feladatokat! Vigyázz azonban arra, hogy módosított programjaid futásuk során ugyanazt a végeredményeket adják, mint a megismert példaprogramok!

3.4. Ezek után álljunk neki a szövegek (karakterek és sztringek) kezelése problémakör megismerésének. A legaktívabb módja ennek, ha rögtön példaprogramokon keresztül ismerkedsz a megoldási lehetőségekkel. Itt érkezünk el a programozás egy nagyon szép tulajdonságához. Még egy konkrét fejlesztői környezet szabályai szerint is (esetünkben BLOCKLY Kódszerkesztő) általában több jó megoldás vezethet a célhoz. Alább monogram generálását végző programokat látsz kissé eltérő megoldásokkal.

Feladat-2. Figyeld meg, hogy a változók szöveges (karakteres és sztring) értéket is kaphatnak, illetve azt, hogy az üzenetként megjelenített output adatokat milyen módon tudod összefűzni!

3.5. Na, ez a második már elég combos volt! Nézzünk egy egyszerűbb algoritmus leírást, mely kiszámolja a neved karakterekben mért hosszát. Azért itt is tanulunk újat: a Kódszerkesztő 'Sztring műveletek' eszköztárába beépített "hossz" blokk segítségével karakterlánc hosszát kapjuk eredményként.

Hf-3/1. Készíts struktogramokat (szerkezeti diagramokat) a monogram készítő, és a neved hosszát megállapító programokhoz!
Hf-3/2. Készítsd el "A neved hossza" programot egy sorral rövidebb formában, úgy, hogy csak egy változót használsz! (Azt, hogy melyiket, neked kell kigondolni!)
Hf-3/3. Ismerek egy olyan gimit, ahol a tanárok becenevei - akkor, ha erre nyelvileg a teljes nevük alkalmas - vezeték-, és keresztnevük első kettő-kettő betűjéből áll össze. Készíts programot mely ilyen beceneveket generál (hogy értsd: Kocsis Laura - KoLa, amiből persze az élő beszédben gyorsan "kóla" lesz...)!
Hf-3/4. Biztos ismered a medve sajtot! A kör alakú dobozban 8 darab sajtszelet van. Mekkora 1 darab medvesajt térfogata (cm3-ben), ha a sajt hosszú oldala 5,2 cm, és magassága 1,5 cm? Tervezd meg az algoritmust és számoltasd ki az eredményt BLOCKLY program segítségével! Vigyázz! Amennyiben a BLOCKLY-nak input adanként tizedesvesszővel adod meg a számot, csak az egész értékekkel fog számolni. Amennyiben tizedes törtet adsz meg input adatként, használj tizedes pontot!
Hf-3/5. Az elméleti tudásanyagot a BLOCK(LY) 3. fejezete tartalmazza.

4. BLOCK(LY)

4. fejezet, melyben egyszerű és kicsit bonyolultabb matematikai műveletek programozását gyakoroljuk, de szó lesz egy kicsit a fizikáról is...

4.1. Az eddigi ismeretek tudatában nem okozhat problémát, néhány egyszerűbb matematikai műveletet végző program elkészítése. Lássunk neki!

4.2. A következő azért combosabb lesz... Számoljuk ki Gergő bérét, ha tudjuk az óradíjat, a ledolgozott időt órákban és percekben.

Feladat-1. Határozd meg, hogy milyen változók használatával lehetne a feladatot megoldani?
Feladat-2. Figyeld meg a kész programban, hogy használunk egy "kerekítés" matematikai műveletet. Próbáld meg ennek a blokknak az eltávolítása után is futtatni a programot! Vajon mi lesz a módosítás következménye a kapott eredményre nézve?

4.3. Most készítsünk programot, mely kiszámolja a melegített víz belső energiaváltozását fajhő (fajho), a tömeg (tomeg) a kiindulási hőmérséklet (homers1), és a felmelegített hőmérséklet (homers2) adataiból. A "fajho" változó kapjon konstans értéket a víz fajhőjének megfelelően (4.2), a többi adatot inputként adjuk meg! Szükség lesz ezeken kívül még egy változóra, melynek az értékét keressük, és kiszámítása után ezt fogjuk megjeleníteni. Legyen ennek a változónak a neve: ergvalt
Segítségképp az alábbi feladatok megoldásához az energiaváltozás kiszámításának fizikai képlete:
Energiaváltozás = (fajhő x tömeg) x hőmérsékletkülönbség

Feladat-3. Készítsd el a program szerkezeti diagramját!
Feladat-4. Készítsd el a blockly-s programot!

4.4. Biztos feltűnt, hogy a kész program különböző blokkjain megjelentek eddig még nem látott kék kérdőjelek. Ezekre kattintva megjegyzések olvashatók, melyek újabb kattintásra eltüntethetőek. A legtöbb programozási nyelvben van lehetőség a kommentek - megjegyzések - elhelyezésére. Ez hasznos lehet akkor, amikor régebbi programjainkat újból áttekintjük. A BLOCKLY Kódszerkesztőben a kommentelni kívánt blokkon jobb gombbal kattintva helyi menü jelenik meg, itt kell választani a "Megjegyzés hozzáadása" opciót...

Hf-4/1. Készíts programot, mely megadott fejadagból és létszámból (ezek az input számadatok) kiszámítja, és megjeleníti a vásárlandó mennyiséget! A vásárlandó mennyiség megjelenítésénél alkalmazz kerekítést, hiszen a fejadag tizedes tört is lehet (és ebben az esetben az eredmény is lehet tizedes tört)! Vigyázz, futtatás során az input adatoknál a BLOCKLY és több más fejlesztő környezet sem viseli el a tizedes vesszőt, helyette tizedes pontot vár!
Hf-4/2. Készíts programot, mely azt számolja ki, hogy az osztálykiránduláson mennyi az egy főre eső buszköltség. Ehhez használd a következő változókat: letszam, kmdij, km, buszkoltsegperfo... Most ne nézzen ide, hanem gondolkozzon az alkalmazandó képleten, akinek a matek jobban megy! Az egyéni buszkoltség=(kilométerdíj*megtett kilométer)/osztálylétszám
Hf-4/3. Készíts BLOCKLY programot, melynek segítségével kiszámolod a szobádba telepítendő radiátor teljesítményét. Ehhez le kell mérned szobád adatait, és ki kell számolnod a térfogatát, tehát azt, hogy hány légköbmétert kell fűteni. Az interneten található adatok szerint a szoba elhelyezkedésének, tájolásának, a szigetelés minőségének alapján 30-50 W a légköbméterenkénti fűtési igény. Ha a programod jól számol majd, megtudhatod, mekkora teljesítményű radiátor felszerelése biztosítja az optimális megoldást. (Az alkalmazott légköbméterenkénti watt teljesítményt becsüld a megadott értékhatárok [30-50 W] közt. 30 W a jól szigetelt, körbe fűtött, délies tájolású szoba hőigénye/m3, 50 W a zord, rosszul szigetelt, szabadon álló, északias fekvésű szoba hőigénye/m3...)
Hf-4/4. Az elméleti tanulnivalót a BLOCK(LY) 4. fejezete tartalmazza.

5. BLOCK(LY)

5. fejezet, melyben elméletben szó lesz az elágazások típusairól, gyakorlatban az egyszerű v. kétirányú elágazást ismerheted meg...

5.1. Elérkeztünk az elágazások kérdéséhez. Amennyiben még emlékszel arra, mit olvastál az 1. BLOCK(LY) általános programozási ismereteket összefoglaló PDF-jéből, akkor emlékezhetsz az elágazás szerkezeti diagramjának képére is. Arról van szó, hogy a program nem mindig csak egyszerű utasításokkal csordogál előre, van olyan, hogy egy adott feltétel teljesülését kell megvizsgálnunk, és az eredménytől függően más-más lesz a program további menete. Egy példa: Megvizsgálunk egy adott pozitív egész számot, hogy maradék nélkül osztható-e kettővel? Amennyiben igen, akkor páros számról van szó, ellenkező esetben a szám páratlan...

Feladat-1. Próbáld meg a fenti páros, páratlan szám kérdést szerkezeti diagramon megjeleníteni!

5.2. Figyeld meg az egyszerű v. kétirányú elágazás jellegzetes szerkezeti diagrami képét! Jegyezd meg, hogy a fejtetőre állított háromszögbe mindig a vizsgálandó feltétel kerül! Az "igen" és a "nem" válaszok alatt jelenítjük meg a lehetséges válasz-utasításokat. Itt ágazik el a program. Találkozhatsz majd olyan esettel is, amikor csak a feltétel teljesülése esetén kell valaminek történnie. Ilyenkor a másik ág üres, a program az elágazás utáni utasítással folytatódik. Ebben az esetben a "Ha" blokkot alapértelmezett formájában használhatod, nincs szükség arra, hogy azt a blokkon található fogaskerékre kattintva kiegészítsd.

5.3. Mielőtt tovább lépünk, nyiss egy üres oldalt a BLOCKLY Kódszerkesztőben, és próbálgass! A 'Logikai műveletek' eszköztárral még nem dolgoztál eddig. Most válaszd ki innen a legfelső blokkot, azt, amire az van írva, "Ha"! Ennek a blokknak a segítségével tudsz majd elágazásokat késziteni programjaidba. A blokkon levő fogaskerékre kattintva módosíthatod az eredeti elágazás-blokkot, és akár nagyon összetett elágazás típusokat is deffiniálhatsz így. A BLOCKLY-ban tehát ugyanaz a blokk-eszköz szolgál az egyszerű-kétirányú és a többirányú elágazások kezelésére.

Feladat-2. Ezek után próbáld meg a fenti páros, páratlan szám kérdést leprogramozni! (Húú, de csúnya kifejezés, ez a "leprogramozni", de hát a profik is használják...)

Feladat-3. Biztos feltűnt (vagy, ha nem hát most szólok...), hogy az előző program neve végén jelzést láthattál, hogy ez az 1. verzió. Most készítsük el ugyanezt a programot egy-egy speciális eszközzel, a logikai kifejezéssel és a logikai változóval! Ezek segítségével vizsgáljuk input adatunkat, az egész számot (szam). Amennyiben az elágazásban logikai kifejezésünk vagy logikai változónk "igaz" értékkel tér vissza, számunk páros, ellentétes esetben páratlan. Arra is érdemes felfigyelned, hogy a BLOCKLY beépített függvényeket-eljárásokat is tartalmaz! Ilyet alkalmazunk akkor, amikor a 'Matematikai műveletek' eszköztárból választjuk azt a blokkot, amit a páros-páratlan szám vizsgálatához használunk. Lássuk tehát a program 2. és 3. verzióját! Neked melyik tetszik jobban?

Hf-5/1. Készíts struktogram típusú programtervet, mely a hárommal való oszthatóságot vizsgálja input adatként megadott pozitív egész szám esetében!
Hf-5/2. Készíts blockly-s programot, mely a hárommal való oszthatóságot vizsgálja input adatként megadott pozitív egész szám esetében!
Hf-5/3. Készíts szerkezeti diagramot, mely a kettővel és a néggyel való oszthatóságot is vizsgálja input adatként megadott pozitív egész szám esetében! Elég megállapítani, hogy osztható-e az input szám mindkét osztóval (2 és 4). :-)
Hf-5/4. Készíts blockly-s programot, mely a kettővel és a néggyel való oszthatóságot is vizsgálja input adatként megadott pozitív egész szám esetében! Elég megállapítani, hogy osztható-e az input szám mindkét osztóval (2 és 4). :-)
Hf-5/5. Az elméleti tudásanyagot a BLOCK(LY) 5. fejezete, illetve "Az algoritmusról (bevezetés a programozáshoz)" PDF bemutató 10. és 19. diák tartalmazzák.

6. BLOCK(LY)

6. fejezet, melyben folytatjuk az elágazások megismerését, csak egy fokkal már bonyolultabb példákkal...

6.1. Folytassuk az elágazások megismerését! Nézzünk példát újból a matematika világából, még mindig az oszthatóság témaköréből! Az öttel és a tízzel való oszthatóságot vizsgáljuk két (na, jó: három) példán. A blokkok közül legfontosabb számodra a 'Logikai műveletek' eszköztárból a Ha-akkor-különben felépítettségű blokk lesz.
Súgok! Az első feladatban elég lesz az egyszerű Ha-akkor-különben blokk, tehát ez egy egyszerű v. kétirányú elágazással megoldható feladat. A második feladatnál viszont az elágazás típusa már többirányú elágazás lesz, itt bonyolultabb blokkot kell építened. Ebben segít az alapértelmezett blokk kék fogaskerék jele.
A feladat megoldásához 'Logikai műveletek' eszköztárból a "Ha" blokkon túl további blokkokat is használnod kell. Figyelj arra, hogy ezeknek a blokkoknak a közepén a logikai művelet jellege állítható!
Az osztás maradékának vizsgálatát a már régebben megismert, a 'Matematikai műveletek' eszköztárban található blokk segítségével tudod megoldani!

Feladat-1. Először készítsük el a programot úgy, hogy az a feladat, hogy azt állapítsuk meg a program segítségével, osztható e az inputként megadott szám öttel és tízzel is!
Feladat-2. Másodszor már bonyolítsunk! Állapítsa meg programunk az inputként megadott számról, hogy osztható-e öttel és tízzel is; osztható-e öttel, de tízzel nem; esetleg az input szám sem öttel, sem tízzel nem osztható!

6.2. Most mutatok valamit! Ennek a programnak a nevében mosolygó is található. Rájössz miért?

6.3. Hagyjuk most egy kicsit a számokat! Következzenek a karakterek, azon belül is a betűk! Olyan programot fogunk most készíteni, mely a beütött betűkarakterről megállapítja, hogy NAGYBETŰS vagy kisbetűs. Ehhez használd a 'Sztring műveletek' eszköztárból azt a blokkot, ami alapértelmezetten "NAGYBETŰS" opcióra van állítva! És hát az elágazás típusa: tipikus "Ha-akkor-különben". Vigyázz! A "különben" ágat neked kell beépítened a blokkba!

6.4. Nézzünk most egy olyan programot, mely megállapítja két számról, hogy melyik a nagyobb! Itt is "Ha-akkor-különben" típusú egyszerű v. kétirányú elágazást használunk.

6.5. Elhagyjuk egy kicsit a "Ha-akkor-különben" típusú egyszerű v. kétirányú elágazásokat, következzenek a több irányú elágazások! Más programnyelvekben is jellemző több "Ha-akkor" egymás alá elhelyezése. Ilyenkor hiányzik a "különben" sor. Ezt láthatod a következő programokban.

6.6. Ennek a BLOCK(LY)-nak [fejezetnek] az utolsó példája következik. A 6.4. alpontban két szám közül választottuk ki a nagyobbat. Most három szám esetében kell ugyanezt megtenni. Figyeld meg, hogy itt is többirányú elágazást alkalmaz a megoldás. Szemben azonban az előbbi (életkoros) példával, itt egy blokká van összeépítve a rendszer, köszönhetően a BLOCKLY grafikus lehetőségeinek.

Hf-6/1. Lehet, hogy könnyebben megy a blokkokkal való programozás, mint a struktogramos papírmunka... Bár megértelek (én is jobban szeretem), azonban ezt is gyakorolnod kell, hisz lehet, kiváló programozó lesz belőled, ez lesz a munkád! Akkor a tervezés bizony követelmény lesz! Készíts struktogramot, Az "Öttel-tízzel való oszthatóság (ver.2)" programhoz!
Hf-6/2. Fejleszd tovább a NAGYBETŰ-kisbetű programot úgy, hogy amennyiben kisbetűt adsz meg, a program átalakítsa azt NAGYBETŰS karakterré, majd írja ki az eredményt a képernyőre!
Hf-6/3. Készíts programot, mely a megadott egész számról megállapítja, hogy pozitív, negatív, vagy netán nulla!
Hf-6/4. Készítsd el a "Tanácsadó ver.2" programot! Módosítsd az 1. verziót, úgy, hogy esős idő esetén kérje be a program, hogy hány forintod van, és amennyiben 1000 Ft, vagy a feletti, akkor tanácsolja azt, hogy "Menj moziba!", ellenkező esetben a tanács legyen "Maradj otthon!". Ezt a feladatot újabb "Ha-akkor-különben" blokk beillesztésével tudod megoldani.
Hf-6/5. Készíts számológép programot! A program kérjen be egy "szam1" és egy "szam2" változóba számokat, illetve egy "muvelet" változóba a műveleti jelet. Vizsgáld a műveleti jel típusát több irányú elágazások feltétel soraiban, az elágazás utasítás sorában a megadott műveletet alapján az eredmény kiszámítása történjen meg. A program végén írasd ki a teljes műveletsort az eredménnyel együtt!
Hf-6/6. Az elméleti ismeretanyag a BLOCK(LY) 6. fejezetének tartalma.

7. BLOCK(LY)

7. fejezet, melyben megismerkedünk a ciklusok típusaival és elkészítjük az első olyan blockly-s programot, mely ciklust is tartalmaz...

7.1. Újabb programozási eszközzel kezdünk ismerkedni, melyet akkor használhatunk, ha az algoritmusunkban ismétlődéseket kell kezelni. Az új eszköz neve: ciklus. A meghatározása következik abból, amit eddig megtudhattál róla: az algoritmusos ismétlődéseket ciklusoknak hívjuk.
A ciklusoknak 3 alaptípusát kell megismerned:

A) az elől tesztelő ciklus, mely a nevét onnan kapta, hogy a ciklusutasítások végrehajtásának feltétele a ciklus elején kerül megfogalmazásra.
B) a hátul tesztelő ciklus, mely a nevét onnan kapta, hogy a ciklusutasítások végrehajtásának feltétele a ciklus végén kerül megfogalmazásra.
C) a számláló ciklus, mely lényegében az elől tesztelő ciklusnak egy olyan változata, ahol a feltétel azt adja meg, hogy hány alkalommal ismétlődjenek a ciklusba ágyazott utasítások.

Feladat-1. Azért, hogy látványosabb legyen számodra ez az egész, a ciklusok ábrázolását tekintsd át a szerkezeti diagramokon (struktogramokon) is!

7.2. Ezek után nézzünk egy aránylag nem túl bonyolult problémát, melyet számláló ciklus alkalmazásával tudunk megoldani. A téma mindenki számára ismerős: ötös lottó sorsolása. Készítsük el struktogramját, majd írjuk meg a blockly-s programot!

Figyelmedbe ajánlok három dolgot:
A) A 'Matematikai műveletek' eszköztárból választhatsz olyan blokkot, melynek segítségével véletlenszámot generálhatsz általad megadott tartományon belül! (A véletlenszám generátor más programnyelvekben is alapértelmezett eszközként megtalálható...)
B) A megjelenő példaprogramot úgy mentettem, hogy mellette találhatsz egy - a 'Matematikai műveletek' eszköztárból választható - blokkot arra is, hogy az i:=i+1 értékadást még egyszerűbben el tudd végezni. Ezzel kapcsolatban osztom meg veled a véleményemet: Az a programozás egyik szépsége, hogy több jó megoldás vezethet el az eredményhez. Remélem, hogy hamarosan te is előállsz az én megoldásaim mellé a saját alternatíváiddal!
C) Vannak olyan szám típusú változók melyeknek a szerepe technikai jellegű a programban, tehát például nem életkori, lottószám vagy bér adatokat tárolunk bennük, hanem olyan, illetve hasonló szerepük van, mint a számláló ciklusunkban az i-nek. Ezeket nevezzük segédváltozóknak. Míg az előbb említett életkor, lottószám, bér adatok beszédes változóneveket kapnak (eletkor, szam, ber), addig a segédváltozók általában egy-egy betűkaraktert kapnak névként. A programozásban kialakult az a hagyomány, hogy ezeket a változókat i-től kezdve (i, j, k, l, m, n, stb...) jelölik. Bár ez nem kötelező, de legyünk tisztelői a nálunk okosabbak szokásainak! Van ebben ráció!

Feladat-2. Miután futtattad az elkészített programot, cseréld ki az utolsó ciklusba ágyazott utasítást (i:=i+1) a mellette lévő - az algoritmusba eredetileg be nem illesztett - utasítás sorral, és vizsgáld meg, az eredmény szempontjából valóban változatlanul működik-e, futtatható-e így is?

7.3. Következő példánkban szintén számláló ciklust alkalmazunk. Ez az algoritmus osztályátlagot számít ki. Lássuk, hogyan lehet ezt a feladatot BLOCKLY Kódszerkesztő segítségével megoldani!

Feladat-3. Határozzuk meg a szükséges változókat! Hány beszédes változót használjunk, milyen adattartalommal fognak rendelkezni? Melyek azok, amelyek input adatként lesznek megadva, lesz-e olyan amelyiknek az értékét a processzor fogja kiszámítani? Szükségünk van-e segédváltozó(k)ra?
Feladat-4. Alkossuk meg együtt az osztályátlag számítására alkalmas programot, használjunk számláló ciklust!

7.4. Folytassuk a munkát az elől tesztelő ciklussal! Itt jegyezném meg, hogy a BLOCKLY cikluskezelése kicsit más mint a hagyományos programozási nyelveké. A BLOCKLY egy blokk elemmel oldja meg a repeat-until (ismételd-amíg) típusú hátultesztelő ciklus, és az elől tesztelő do-while (csináld-amíg) típusú algoritmusos ismétlődéseket. Mivel ennek a blokknak a feltételvizsgáló része elől helyezkedik el, kezeljük elől tesztelő ciklusként!
Ennek az algoritmusnak a jellegzetessége lesz még, hogy a ciklusba nem csak egyszerű utasításokat illesztünk be, hanem a cikluson belül még egy többirányú elágazást is alkalmazni kell. Ehhez a 'Logikai műveletek' eszköztárból tudjuk felépíteni a megfelelő "Ha" blokkot.

Feladat-5. Készítsük el a Gondoltam egy számot programhoz először a struktogramot, majd folytassuk a munkát a program megalkotásával! Miért nem lehet a feladatot egyszerű (kétirányú) elágazással megoldani?

Hf-7/1. Készíts szerkezeti diagramot az osztályátlag kiszámításának algoritmusához!
Hf-7/2. Fejleszd tovább a Gondoltam egy számot! programot! A cikluson belül egy változóban (tippek_szama) tárold el a leadott tippek számát, növekedjen az értéke a ciklus minden egyes végrehajtása során, majd a program fejeződjön be egy olyan üzenettel, mely az "Eltaláltad!" mellett tippjeid számát is kiírja a képernyőre! Legyen ez az üzenet összefűzött, tehát egy üzenetben legyen kiírva az összes információ ("Eltaláltad, a tippjeid száma: ennyi")!
Hf-7/3. Az elméleti tanulnivaló a BLOCK(LY) 7. fejezet, illetve "Az algoritmusról (bevezetés a programozáshoz)" PDF bemutató 10-13. és 18.dia

8. BLOCK(LY)

8. fejezet, melyben folytatjuk a ciklusokkal való ismerkedést, de most már inkább csak gyakorlatban, és egyre bonyolultabb algoritmusokat oldunk meg...

8.1. Folytassuk a ciklusokkal való ismerkedést! Készítsünk blockly-s programot, mely az induló tőke (toke) az éves kamatláb (kamatlab) és az évek (evek) ismeretében kiszámítja, hogy a lekötési idő végére kezdeti tőkénk mekkorára duzzad!

Segítségképp az első év végén jellemző tőke kiszámításának módja: tőke[új] = tőke[régi] x (1 + (kamatláb / 100) Ha sikerül ezt a képletet blockly-s értékadással is megfogalmaznod, és beilleszteni egy olyan ciklusba, mely annyiszor végzi el az ismétlést, ahány évig kamatozik a tőke, akkor valószínű működni fog a megoldásod! (Ennek a programnak egyébként nem is a ciklus a legfontosabb része, hanem az, hogy megértsd, hogyan működik a fenti képlet, és hogyan tudod ezt "leprogramozni"...:-))

Feladat-1. Készítsd el a szerkezeti diagramot, majd a programot!

Már a "Gondoltam egy számot!" program struktogramjánál is felfigyelhettél rá, de ennél a programnál (Tőkeszámítás) még feltűnőbb, hogy a szerkezeti diagram esetében az input adat bevitel és a hozzá kapcsolódó szöveges adatbekérés két sorban jeleníthető meg. Mint láthatod, a BLOCKLY Kódszerkesztő ezt egy sorban is kezelni képes.

8.2. A következő program a "fej vagy írás" játékot szimulálja. Az "hanyszor" változóba bekéri azt, hogy hányszor szeretnék elvégezni a pénzfeldobást, majd cikluson belül 0 és 1 közül véletlenszám generátorral választ. Ha a véletlenszám értéke 0, növeli a "fej" értékét, ha a véletlenszám értéke 1, növeli az "írás" értékét. Miután "hanyszor" alkalommal elvégezte a ciklusba ágyazott utasításokat, kiszámítja a fejek százalékos arányát a következő képlettel: százalék = 100 x (fej / hanyszor), majd egy új blokk elemet is (lista) tartalmazó üzenetben informál bennünket a fejek, az írások számáról, és a fejek százalékos arányáról.
Figyeld meg, hogy a "fej" és az "iras" változóknak a program elején kezdő értéket adunk. Ez esetünkben 0, de szükség esetén - és az aktuális program igénye alapján - egyéb kezdőérték is adható egy változónak.
Feladat-2. Ez így leírva irtó bonyolult. Segít, ha elkészíted a struktogramot! Ha kész vagy, hasonlítsd össze az én megoldásommal!

Feladat-3. Készítsd el a pénzfeldobás blockly-s programját! A program végén az "Üzenet" blokkhoz kapcsolj megfelelő számú (3) illesztési ponttal "Lista" blokkot a 'Listakezelés' eszköztárból, majd az illesztési pontokhoz összefűzve kapcsold a szöveges és az adat outputokat (fej, iras, szazalek)! Azért arra felhívom a figyelmedet, hogy a blockly-s lista adatszerkezet annál lényegesen többet tud, mint amire most használjuk. Néhány fejezettel alább ezekre a komolyabb feladatokra is láthatsz majd példákat!

8.3. Ennek a témakörnek a végén érdekes programozási hibára hívnám fel a figyelmedet. A végtelen ciklus az, ami valamennyi programozó rémálma. Ahogy a neve is utal rá, a végtelen ciklusnak nincs vége. Magyarul a program futása bennragad a ciklusban, és nem tudva onnan kilépni, az algoritmikus lépésekben való továbbhaladás lehetetlenné válik. Mi okozhatja ezt a programozási hibát? Minden esetben a ciklusfeltétel hibás megadása az ok. Mivel komolyabb programoknál szinte lehetetlen, hogy valamikor a fejlesztő - mivel ember - ne hibázzon, szokás mondani, hogy nem is igazi programozó az, aki legalább egy végtelen ciklust ne írt volna meg életében. :-))
Mi a végtelen ciklus veszélye? Egyrészt, mérhetetlenül lefoglalhatja a számítógép erőforrásait, és lefagyaszthatja azt. Azzal a veszéllyel is szembe kell nézni, hogy munkánk vész kárba, hisz esetenként - bizonyos fejlesztői rendszerekben - csak a számítógép újraindítása a megoldás. Ilyenkor - ha a programozó nem mentett futtatás előtt - utolsó módosításai elvesznek. Jegyezd meg, hogy még mindig könnyebb a hibát megkeresni, javítani, mint elölről kezdeni a teljes munkát.

Feladat-3. Tanulmányozd, majd futtasd az alábbi - végtelen ciklust tartalmazó - programot! Figyeld meg, hogy a "0" választással a program kikerüli a végtelen ciklust, viszont az "1" opció választásával a végtelen ciklus kezd futni (ciklusfeltétel: ismételd amíg 0<1). A BLOCKLY-ban beépített védelemként a folyamatosan, és vég nélkül megjelenő panelen az "Ez az oldal ne nyisson meg további párbeszédablakokat" üzenet melletti jelölőnégyzetre kattintva felfüggeszthető a program futása, majd a böngészőfül bezárásával kiléphetsz a programból. A BLOCKLY másik védekezési mechanizmusa, hogy a program számára maximálja a futtatási időt. Ha ezt eléri a program, egy figyelmeztető rendszerüzenettel leáll. Ez akkor lehet hasznos, ha a végtelen ciklusban nincs olyan üzenetpanel, mint amit én beleírtam ("Ez egy végtelen ciklus!") (Ezek a blockly-s védekezési mechanizmusok tesztem szerint Chrome és Firefox böngészőkben működnek, az Internet Explorerben NEM!)
Jegyezd meg tehát egy életre nagyon jól: amennyiben új ciklusfeltételt fogalmaztál meg programozás során, futtatás előtt mindig mentsd munkádat! (BLOCKLY-ban kattints a hivatkozás vezérlőgombra és a böngésző címsorában megjelenő linket másold egy külső fájlba!) Ellenkező esetben - ha sikerült végtelen ciklust írnod - elvész addigi munkád! Persze akkor, ha a program nem tartalmaz semmilyen ciklust sem - mint a korábbi fejezetekben példaként látott programok - akkor a végtelen ciklustól sem kell tartani...:-))

A Hf-8/1. és Hf-8/2. házi feladat probléma felvetése a következő: Számold ki egy adott létszámú osztály esetében az inputként megadott tanulói átlagok felhasználásával azt, hogy hány tanuló átlaga jeles (tehát >=4.5)! Programod kérje be először az osztálylétszámot, és tárolja el az input adatot egy "letszam" nevű változóban. Ezek után számláló ciklusban kérd be a tanulói átlagokat! Vigyázz a programban, és az input megadásakor sem használhatsz tizedes vesszőt. A programozásban általában tizedes pont alkalmazása az elfogadott. Legyen egy "jelesdb" nevű változód, melynek értékét a program elején 0-ra állítod, majd a számláló ciklusban minden egyes olyan alkalommal, amikor a tanulói átlag >=4.5 növeled 1-gyel! A program végén írasd ki a képernyőre a jeles eredményű tanulók számát!

Hf-8/1. Készíts a probléma megoldására szerkezeti diagramot!
Hf-8/2. Készítsd el a blockly-s programot, mely kiszámolja az osztály jeles tanulóinak számát!
Hf-8/3. Keress megoldást a pénzfeldobás programban a nullával való osztás elvi hibája előfordulásának kezelésére! (Hogyan kezelje a program azt, ha a felhasználó a pénzfeldobások számának nullát ad meg? Ez a százalékszámításnál nullával való osztáshoz vezetne, ami értelmetlen...)
Hf-8/4. Írásban fogalmazz meg olyan feltételeket, melyek ciklusfeltételként alkalmazva végtelen ciklushoz vezetnének!
Hf-8/5. Az elméleti ismereteket a BLOCK(LY) 8. fejezet segítségével sajátíthatod el.

9. BLOCK(LY)

9. fejezet, melyben megtudhatod, mi az eljárás (más néven alprogram), hogyan lehet ilyet készíteni, és mikor érdemes ezt az eszközt alkalmazni...

9.1. Folytassuk az ismerkedést a programozás világának egy újabb eszközével, az eljárással! Az eljárás tulajdonképpen egy olyan alprogram, melynek utasítássorát külön elkészítjük, egyedi nevet adunk neki, majd főprogramunkba ennek az egyedi névnek a segítségével meghívjuk. Miért jó ez? Részint áttekinthetőbbé teszi programunkat, másrészt - és talán ez még fontosabb - sokszor ismétlődő utasítássorozatokat egyszer kell megírni, alprogramként nevet adni neki, majd akár számtalanszor beilleszthetjük a főprogramba. Időt, energiát, szellemi kapacitást spórolunk. Az emberiség sokszor a kényelem szeretetének köszönhette a haladást. Ez is kicsit így működik...

9.2. Olyannal is találkozhatunk a programozás világában, amikor előre megírt eljárásgyűjteményeket használnak a program készítői. Ilyen előre megírt eljárásgyűjtemények például a PASCAL UNIT-jai, vagy a Windows DLL fájljai, mely utóbbiakat a Visual Basic alapú programok előszeretettel használják. Megfelelően hivatkozva rájuk, meghívhatók a bennük definiált eljárások.

9.3. Lássunk konkrét példát is! Valószínűleg a BLOCKLY Teknőc-cel már megismerkedtél. Ott számtalan lehetőség volt az eljárások használatára. Most egy kis ujjgyakorlat következik ismétlésként, és az eljárás szerepének megvilágítására. Két eljárást tartalmaz a program: A "negyzet" eljárás - láss csodát(!) - négyzetet rajzol, az "abra" eljárás a "negyzet" eljárás felhasználásával 6 négyzetből álló ábrát rajzol. A főprogram az "abra" eljárások használatán túl a rajzolás színét változtatja.

Feladat-1. Futtasd a programot és elemezd ki, hogy mi a szerepe a benne foglalt eljárásoknak!

9.4. Miután a fenti kis elméleti bevezetőt és a BLOCKLY Teknőc példát elemeztük - remélve, hogy most már minden világos - térjünk vissza a BLOCKLY Kódszerkesztőhöz! Itt talán nem olyan gyakran állunk neki eljárást írni, de azért itt is előfordul majd!
Térjünk egy kicsit vissza a lottósorsolást modellező programhoz. A ma leginkább ismert háromféle lottójáték az 5-ös lottó, a 6-os lottó és a Skandináv lottó. Az 5-ös lottóban 5 számot húznak 90-ből, a 6-os lottónál 6 számot 45-ből, míg a Skandináv lottó esetében 2 x (7-et 35-ből), egyszer gépi húzással, egyszer hagyományos módon. Ezt modellezi a következő példa. A Skandináv lottó kétszeri húzása miatti ismétlődést viszont nem kell újból megírnunk, mert eljárást alkalmazunk.

Feladat-2. Készítsük el először a szerkezeti diagramot! Figyeld meg, hogy milyen módon definiáljuk az eljárást, még a főprogram előtt! A vastagon szedett szegély grafikusan is jelzi az eljárást, ezért a főprogramban azonnal látszik, hogy nem egyszerű utasítással van dolgunk...

Feladat-3. Készítsük el most a blockly-s programot! Itt is egyértelműen elkülönül az eljárás és a főprogram...

Feladat-4. Készítsünk most egy olyan programot, melynek segítségével forintot tudunk napi árfolyamon átszámítani euróra, vagy dollárra! A programnak azt a részét, mely a tényleges átváltást végzi, helyezzük el egy "atvaltas" elnevezésű eljárásban! Főprogramunkban mind az euróra váltásnál, mind a dollárra váltásnál hívjuk meg az "atvaltas" eljárást!

9.5. A 9.1. pontban beszéltem róla, hogy általában kétféle okból írnak eljárásokat a programozók. Most egy adalék, hogy - legalábbis a BLOCKLY Kódszerkesztőben - mit tehetsz még a program átláthatósága érdekében - eljárás készítése nélkül...
Nyisd meg az előzőekben készített bármely programot, és válassz egy tetszőleges - lehetőleg bonyolultabb felépítésű - blokkot! Egér jobb gombjával kattintva, megjelenő helyi menüben válaszd a "Blokk összecsukása" parancsot, és máris átláthatóbb a hosszabb program is... A helyi menü segítségével természetesen bármikor újból kibonthatod az összezárt elemet.
A jobb gombos helyi menüben hasznodra lehet még a "Blokk letiltása" parancs is. Ezt választva az adott blokk - legyen az akár egy elágazás, vagy egy ciklus - inaktívvá válik, úgymond zárójelbe kerül, futtatáskor a végrehajtó motor figyelmen kívül hagyja. Jól jöhet a program tesztelésénél!

9.5. És akkor itt álljunk meg egy pillanatra! Szóba jött a program tesztelése, ennek kapcsán szeretném összegezni a program készítésének legfontosabb lépéseit, melyek közül többel már gyakorlatban ismerkedtünk.
A) Az algoritmus megfogalmazása, szervezés - mit is szeretnénk, mit csináljon a program? A profiknál a megrendelő és a program szervezőjének egyeztetése tartozik ebbe a munkafázisba.
B) Tervezés - ezt a célt szolgálják a szerkezeti diagramok, itt tervezzük meg a használt változókat és a program működésének vázlatát. A program szervezője - többek között - elkészít egy olyan dokumentumot, melynek "a program specifikációja" - vagy valami hasonló - a neve. Ez - többek között - kódolandó folyamatok leírását, szükséges adatok definiálását, képernyőterveket tartalmaz, ez lesz a programozó számára a sorvezető a programozáshoz.
C) Kódolás - a tényleges programírás, ezt végzik a programozók valamely fejlesztői rendszer (programozási nyelv) segítségével.
D) Tesztelés - az első tesztelő a program tényleges készítője, de ez persze nem elég, külső tesztelésre, megrendelői tesztelésre is szükség van! Esetünkben a házi feladatok első tesztelője te kell legyél, én leszek a külső tesztelő... :-))
E) Dokumentálás - a program működésének leírása (sokszor már a programkódba is kommentek kerülnek dokumentációs céllal), mely elengedhetetlen annak érdekében, hogy más programozó - szükség esetén - módosítani, javítani tudja a programot. Fontos lehet a felhasználó számára is, hisz ennek segítségével könnyebb a programmal való munka megtanulása. Ezek alapján különböztetünk meg fejlesztői dokumentációt, és felhasználói dokumentációt. A fejlesztői dokumentációban van lehetőség a program fejlesztési lehetőségeinek megfogalmazására is...

Hf-9/1. Készíts BLOCKLY Teknőccel olyan programot, melyben legalább kettő darab eljárást alkalmazol úgy, hogy az első eljárás beépül a másodikba! Ilyen program lehet pl. sorminták rajzolása, házsor rajzolása kerítéssel, de választhatsz hasonló típusú programot is (természetesen más alakzattal), mint a fejezet elejei teknőcös példa.
Hf-9/2. Módosítsd a valutaváltó programot, úgy, hogy eurón és dolláron kívül svájci frankra (CHF) való váltást is végezzen!
Hf-9/3. Írj programot, mely fordított irányban végzi a váltást (eurót forintra, dollárt forintra vált)!
Hf-9/4. Az elméleti tudásanyagot a BLOCK(LY) 9. fejezete, illetve "Az algoritmusról (bevezetés a programozáshoz)" PDF bemutató 14. és 20.diák tartalmazzák.

10. BLOCK(LY)

10. fejezet, melyben a paraméteres eljárásokkal ismerkedünk, és szó lesz a lokális (helyi) és globális változókról...

10.1. A paraméteres eljárásokkal a LOGO, vagy a BLOCKLY Teknőce segítségével korábban már találkozhattál. Nézzük, mit is tudnak ezek a paraméteres eljárások! Emlékszel még a négyzet és más síkidomok rajzolására teknőccel? Amennyiben nem szerettük volna minden egyes új hosszúság adat megadása alkalmával újból megírni az eljárást, akkor paraméterezett eljárást kellett alkamazni. Az eljárás főprogramból való meghívásakor adtunk tényleges értékeket a paraméteres változóknak. Imagine LOGO-ban valahogy így nézett ki a négyzet eljárás készítése, majd egy konkrét értékkel (esetünkben 140-es oldalhosszal) az eljárás meghívása:

? eljárás négyzet :oldal
? ism 4 [e :oldal j 90]
? vége

? négyzet 140

10.2. BLOCKLY Teknőcben a négyzet eljárást szintén elkészíthetjük paraméteresen, majd a főprogramban egy ciklus segítségével akár több négyzetet is rajzolhatunk, melyek szépen mutatják azt, hogy a paraméter véletlenszám általi változtatásával más és más oldalhosszú négyzeteket kapunk. Felhívom a figyelmedet arra, hogy a ciklus után következik egy tesztelő része a programnak, melynek segítségével kiderül, hogy az "oldal" nevű változó a főprogramban nem rendelkezik értékkel, a változó értéke csak az eljárásban értelmezhető. Ezt nevezzük lokális (helyi) változónak.

Az előző program kis módosításával háromszögeket is rajzolhatunk paraméteres eljárással. Itt is mutatja a program végi tesztsor (Üzenet:=oldal), hogy eljáráson belüli lokális változóként működik az "oldal".

10.3. Következzen egy újabb BLOCKLY Teknőcben elkészített példaprogram. Sokszögeket fogunk rajzolni oly módon, hogy a sokszöget ténylegesen egy paraméteres eljárással készíttetjük el. Az eljárás lokális változókat használ: "szogszam" és "hossz".

Feladat-1. Figyeld meg, hogy a "sokszog" eljárás a főprogramban paraméterként megkapja az "i" változót a "szogszam" paraméterhez, a "j" változót a "hossz" paraméterhez. Az "i" értékét folyamatosan növeljük, a "j" értéke változatlan.

10.4. Most térjünk át a BLOCKLY Kódszerkesztőbe! A legutóbbi - sokszögekkel kapcsolatos teknőcös - feladatot módosítsuk számolási feladatra! Paraméteres eljárás használatával készítsünk olyan eljárást, mely a sokszögek kerületét számolja ki! Az előző teknőcös programhoz képest egy globális változóra lesz szükségünk: "kerulet". Globális változónak azért nevezzük, mert az eljáráson belül és a főprogramban is valós értékkel rendelkezhet. Globális változónk még az "i" és a "j". A "szogszam" és a "hossz" változók itt is lokális változók lesznek, ennek bizonyítására a program végén két tesztsort helyeztem el, melyek a program futása végén "undefined" jelzéssel térnek vissza, magyarul ezeknek a lokális változóknak az értéke az eljárásban való szerepük után a főprogram számára elvész.

Feladat-2. Elemezd ki a programot, próbáld megérteni, hogy melyik részlete miként működik! Használhatod a helyi menüből (jobb klikk a kérdéses elemen) a "Blokk letiltása" parancsot! Esetenként ez is segíthet egyes részek szerepének tisztázásában!

10.5. BLOCKLY teknőcös példa következik megint. Házakat fogunk rajzolni egymás mellé - paraméteres eljárásokkal. Két darab paraméteres eljárást készítünk (negyzet, hazteto), mindkettőnek a "hossz" változó a paramétere. A "haziko" eljárás megrajzolja a teljes házikót, majd a főprogramban egy számláló ciklus alkalmazásával 3 darab házikót rajzolunk egymás mellé.

Feladat-3. Mivel a házikókat egymás mellé szeretnénk rajzolni, ezért a "hossz" változónak a főporgramban változtatjuk az értékét. Ebben a programban tehát a paraméterezésre használt változó egyben globális változó is. Ezt bizonyítja a főporgram végi teszt is, mely a rajzfelületre kiírja "hossz" változó utolsó valós értékét.

10.6. Újabb példánk a BLOCLY Kódszerkesztőben készül. A "K_T_teglalap" eljárás 2 lokális változó paramétert igényel: "a"-t és "b"-t. A "kerulet" és a "terulet" globális változóként értelmezhetők, mivel az eljáráson belül kapnak a megfelelő matematikai kifejezés segítségével értéket, de a főprogramnak átadják értéküket, amit megjeleníthetünk a képernyőn.

Feladat-4. Érdekességként figyeld meg, hogy lehet az eredetileg egész számot generáló véletlenszámot matematikai módszerrel "rábírni" tört szám képzésre! (Persze a BLOCKLY 'Matematikai műveletek' eszköztárban találsz erre a célra egy speciális blokkot...!)

Hf-10/1. Rajzolj BLOCKLY Teknőccel nyolcszögeket paraméteres eljárás alkalmazásával!
Hf-10/2. Készíts Kódszerkesztővel programot, mely a háromszög kerületét és területét kiszámító paraméteres eljárást tartalmaz!
Hf-10/3. Készíts Kódszerkesztővel programot, mely a kör kerületét és területét kiszámító paraméteres eljárást tartalmaz!
Hf-10/4. Készíts Kódszerkesztővel programot, mely olyan paraméteres eljárást tartalmaz, mely a főprogramban inputként megadott tartományba tartozó számokra négyzetértékeket számol (pl. kiszámolja a négyzetét az input[1]-ként megadott 2, és az input[2]-ként megadott 15 által meghatározott tartományba eső egész számoknak)!
Hf-10/5. Az elméleti tanulnivaló a BLOCK(LY) 10. fejezete.

11. BLOCK(LY)

11. fejezet, melyben a rekurzió a téma, majd rekurzív eljárást tartalmazó programot is készítünk

11.1. Ennek a fejezetnek a témája, hogy mi is az a rekurzió, illetve hogyan lehet rekurzív eljárást készíteni? A Berzsenyi Gimnázium informatika oktatási honlapján található a vicces megfogalmazás: "értelmező kéziszótár: : rekurzió --> lásd : rekurzió"
Kevésbé viccesen - és ez már nem az adott oldalról származik - olyan alprogramokat (eljárásokat) nevezünk rekurzívaknak, amelyek meghívják önmagukat. De hogyan is lehetne szemléletessé tenni azt, hogy mikor is beszélünk rekurzióról?
A) Az egyik ilyen példa Benedek Elek: Három kívánság című művének továbbgondolása. Mi lenne, ha a szegény ember harmadik kívánsága az lenne, hogy legyen még újabb három kívánsága?
B) Másik példa, amikor tükör előtt állva úgy készítünk előlapi kamerás fotót (selfie-t) magunkról, hogy az előlapi kamera a tükör felé néz. Ilyenkor "kép a képben" élményben lehet részünk.
C) Hétköznapi rekurzíó tanórákon is gyakran előfordul, amikor a felelő a megmagyarázandó fogalmat önmagával szeretné magyarázni. Természetesen ez a fajta megoldás a feleletben nem elfogadható. (pl. Rekurzió az, amikor egy eljárás rekurzívan meghívja önmagát... ((-:)

11.2. Vigyázni kell a rekurzív eljárások algoritmusos megfogalmazásával, mert az ismétlődő eljáráshívások túlterhelhetik a számítógépet (a verem túlcsordul - sicc!). Ennek elkerülésére feltételhez kell kötni a rekurzív eljárás végrehajtását, vagy érdemes paraméteres eljárásként definiálni a rekurzíót.

Feladat-1. Vizsgáld meg a következő rekurzív eljárást tartalmazó programot, és állapítsd meg, hogy feltétel megfogalmazásával, vagy paraméterezéssel biztosítja azt, hogy ne vezessen a program futása a verem túlcsordulásához, és ezzel hibaüzenethez!

11.3. Lássuk az előlapi kamerás-tükrös fotózkodás egy lehetséges algoritmizálását! A program azt számolja, hogy inputként megadott méretű tárgy, szintén input adatként megadott kicsinyítéssel, a "kép a képben" fotózkodás alapján a különbözó képi szinteken milyen méretben jelenik majd meg. Ennek a problematikának a megoldására a programban újból rekurzív eljárást alkalmazunk, amelyet azonban - a verem túlcsordulásának elkerülése érdekében :-)) - feltételhez kötve fogalmazunk meg.

Feladat-2. Elemezd a programot, állapítsd meg, hogy melyik változónak mi a szerepe! Mitől rekurzív a "kicsinyit" eljárás? Ezután futtasd a programot, majd te magad is próbáld meg emlékezetből összeállítani a BLOCKLY Kódszerkesztő felületén!

11.4. * Leonardo Pisano, ismertebb nevén Fibonacci híres munkájában (Liber Abaci) található a következő probléma, amit Fibonacci nyulaiként is gyakran emlegetnek:
Hány pár nyúlra szaporodik egy év alatt a kezdeti pár, ha tudjuk, a nyulak két hónap alatt válnak ivaréretté, és ezután minden pár minden hónapban egy új párnak ad életet és mindegyikük életben marad?

A feladat megoldásában a nyúl-párok számának időbeli alakulását kell követni. Az első hónapban egy nyúl-párunk van, és ugyanannyi lesz a másodikban is; a párok száma csak a harmadik hónapban változik egyről kettőre. A következő hónapban a szülők újabb párnak adnak életet, így a párok száma háromra nő. Az ötödik hónapban azonban már az új pár is szaporulatképes, így az új párok száma kettővel nő, és az összes párok száma ötre gyarapodik. A következő hónapban már mindkét ifjabb generáció hoz létre utódokat, és a párok száma hárommal növekedve nyolcra változik.
Az egyes hónapokhoz tartozó nyúl-párok számát leíró 1, 1, 2, 3, 5, 8, 13, 21, 34, … számsor Fibonacci-sorozat néven vonult be a matematika történetébe. A sorozat előállításának alapja az a tulajdonság, mely szerint a harmadik elemtől kezdve bármely elem az előző kettő összege. A sorozat első két elemét azonban meg kell adni; ezek értéke a Fibonacci-sorozat esetén 1. A sorozat definíciója ennek megfelelően:

a(1) = 1, a(2) = 1 és a(n) = a(n-1) + a(n-2), ha n > 2

* Forrás: A 11.4. alfejezet Fibonacci-sorozattal kapcsolatos szöveges leírása Gajdácsi Glória 2001-es JGYTF-en készített - online elérhető - "Az aranymetszés" című szakdolgozatából idézve. (http://www.jgytf.u-szeged.hu/tanszek/matematika/speckoll/2001/arany/index.html)

Feladat-3. Elemezd az alábbi programot, állapítsd meg, hogy melyik változónak mi a szerepe! Mitől rekurzív a "Fibo_nyulai" eljárás? Vajon a Fibonacci-sorozat fenti definíciója ellenére miért kellett az "a(n-2)" változónak kezdeti értékként 0-t adni? Hogyan oldanád meg azt, hogy az "a(n-2)" változó értéke is 1-gyet kapjon kezdő értékként? Mi lenne a program működésében az a kompromisszum, amit ezért meg kéne kötni?

Hf-11/1. Gyűjts hétköznapi példákat, melyekkel bemutathatod a rekurziót!
Hf-11/2. Készítsd el a szegény ember 3 kívánsága programhoz a szerkezeti diagramot!
Hf-11/3. Ha van előlapi kamerás telefonod, készítsd el a "kép a képben" fotót tükör előtt! Közelről exponálj úgy, hogy a kb. melltájékon tartott telefonod képe is rögzítésre kerüljön! Mérd le a képen az egybevágó részeket, és ez alapján határozd meg a kicsinyítés mértékét! Készítsd el a "Kép a képben" programot úgy, hogy az általad mért kicsinyítési arányt konstans - tehát nem inputként bevitt - adatként kezeld!
Hf-11/4. Módosítsd a Fibonacci nyulai programot úgy, hogy az "a(n-2)" változó kezdeti értéke 1, de a program végeredménye változatlan legyen!
Hf-11/5. A Hf-11/1. házi feladat megoldásod alapján próbáld meg elkészíteni a blockly-s programot rekurzív ötleted algoritmizálására!
Hf-11/6. Elméleti tudásodat a BLOCK(LY) 11. fejezetével bővítheted.

12. BLOCK(LY)

12. fejezet, melyben az adatok rendezésével ismerkedünk, majd adatainkat megpróbáljuk sorba is állítani...

12.1. Képzeld el, hogy az osztály tagjai életkoruk alapján sorba állnak: elől a legfiatalabb, a végén a legidősebb tanuló. A valószínűsége elhanyagolható annak, hogy ez a sorrend megegyezzen a magassági sorrenddel (tornasor), amikor a legalacsonyabb áll a sor elején, a legmagasabb pedig a sor végére kerül. Rendezzük a sort magasság alapján, tornasorba!
Nézzünk két egyszerű példát arra, hogyan tudjuk a magasság alapján újra sorba állítani - átrendezni - az osztály tagjait!
A) Az első módszer az lehet, amikor új sort alakítunk ki az új szempontnak megfelelően: Megkeressük a legalacsonyabb tanulót a sorban, ő elhagyja az eredeti sort, és az új sor első tagja lesz. A megrövidült eredeti sorban keressük ezután az ott maradtak közül a legalacsonyabbat, ő másodikként távozik és áll be az új sorba, előző társa mögé. Ezt a rendezést addig folytatjuk, míg az eredeti életkor alapján felállt sorból mindenki át nem kerül a magasság szerinti tornasorba...
B) A második módszer abban tér el, hogy nem két sorunk van, hanem az eredeti teljes sorral, illetve annak egyre csökkenő részhalmazával dolgozunk. Első lépésként megkeressük a legalacsonyabb tanulót, és őt a sor elejére állítjuk. Második lépésként a teljes sor részhalmazát vizsgáljuk sorrendben a 2. tanulótól a teljes sor végéig. A részhalmazból kiválasztjuk azt a tanulót, aki a vizsgált részhalmazban a legalacsonyabb. Ő kerül a teljes sor 2. helyére. A következő vizsgálat részhalmaza a teljes sor 3. tanulójánál kezdődik. Egészen addig végezzük a vizsgálatot, és a tanulók átirányítását az új pozícióba, míg mindenki az új helyére kerül. Könnyen belátható, hogy a vizsgálatok száma megegyezik az osztály (esetleg a csoport) létszámával.

12.2. A rendezés a programozásban gyakran előkerül. Adatokkal dolgozunk, melyek nem mindig rendezetten kerülnek bevitelre, de rendezett tárolásuk és megjelenítésük indokolt. Gondolj csak a lottó vagy keno sorsolásokra, ahol a nyerőszámok véletlenszerűen kerülnek kihúzásra, de a könnnyebb megjegyezhetőség és az átláthatóság miatt a húzás után rögtön nagyság szerint rendezve is megjelenítik őket.
A rendezési algoritmusoknak az alábbi típusai a leggyakoribbak a programozásban:

1. Minimumkiválasztásos rendezés
2. Beillesztéses rendezés
3. Összefésülő rendezés
4. Gyorsrendezés
5. Kupacrendezés
6. Buborékrendezés

12.3. No, megijedni nem kell, nem fogjuk mindet megtanulni, ez az általános iskolai informatikának nem tananyaga! Vizsgáljuk meg azonban a 12.1. fejezet példáját! Egy kicsit egyszerűsítve a problémát, tetszőlegesen megadott egész számok esetében (negatív számot is használhatunk) vizsgálódjunk! Első példánk a életkoros-tornasoros rendezés első verziójának logikáját követi. Új eszközöket (blokkokat) alkalmazunk a 'Listakezelés' eszköztár segítségével. (A lista adatszerkezet nem minden programozási nyelvben áll rendelkezésre, ezekben tömb, illetve dinamikus tömb adatszerkezeteket használhatunk, bár a lehetőségeik kicsit mások.) A példánkat minimumkiválasztásos rendezési algoritmus jellemzi.

Feladat-1. Figyeld meg a példaként megadott minimumkiválasztásos rendezésben azt, hogy mi a szerepe a két listának (lista1 és lista2)! Vajon miért kell törölni a "lista1"-ből a "lista2"-be áthelyezett számot? A program második ciklusának első sorában átállíthatod-e az "állítsd be" opciót "szúrd be" opcióra úgy, hogy a program futásában az ne okozzon zavart? Ha igen, miért - ha nem, miért nem?

12.4. Ennek a fejezetnek a második példájában úgy módosul a rendezés algoritmusa, amint azt a életkoros-tornasoros rendezés második variációja mutatta. Itt nem külön listákkal dolgozunk, hanem a teljes listán kívül annak egyre csökkenő részhalmazával.

Feladat-2. Figyeld meg az újabb minimumkiválasztásos rendezésben azt, hogy mi a szerepe a teljes- és a részlistának! Vajon miért kell törölni a program egy adott pontján elemet a teljes- és a részlistából is? A program második ciklusának első sorában átállíthatod-e az "szúrd be" opciót "állítsd be" opcióra úgy, hogy a program futásában az ne okozzon zavart? Ha igen, miért - ha nem, miért nem?

12.5. Lássuk most a rendezéssel kiegészítve egy korábbi - a lottósorsolásos - programunkat! A program először a húzás sorrendjében megjeleníti a nyerőszámokat, majd a következő - második - ciklusba ágyazva elvégzi a rendezést, így a program végén már növekvő sorrendben jeleníti meg a nyerőszámokat. A program hiányossága még, hogy a véletlenszám generátor többször is kihúzhatja ugyanazt a számot. Van viszont egy fontos eltérés az eredeti lottósorsolásos megoldáshoz képest. Ha megfigyeled, ebbe a megoldásba már beépítésre került a rekurzió. Mind a "sorsolas", mind pedig a "rendezes" eljárások rekurzívak: önmagukat is meghívják.

12.6. Ennek a fejezetnek a végén egy másik rendezési mód, a beillesztéses rendezés példaprogramját láthatod. Hogy megértsd a működését, képzeld el, hogy a életkoros-tornasoros példánál olyan rendezési módot választunk, amikor a sor elejétől kezdve mindenkinek a testmagasságát az eggyel mellette lévő magasságával hasonlítjuk össze hátrafelé haladva a sorban, majd minden egyes lépésnél az alacsonyabb helyet cserél a nálánál magasabbal.
Mivel ez a rendezés lényegesen bonyolultabb, ezért nem mélyedünk bele az elemzésébe, azonban érdemes egy kicsit elidőzni azon, hogy a program mely része miként működik! Különös figyelmet érdemel a beillesztéses rendezési agoritmus!

Hf-12/1. Módosítsd a minimumkiválasztásos rendezés-1. programot úgy, hogy a ciklusokat rekurzív eljárásokra cseréled!
Hf-12/2. Módosítsd a minimumkiválasztásos rendezés-2. programot úgy, hogy a ciklusokat rekurzív eljárásokra cseréled!
Hf-12/3. Fejleszd tovább a lottósorsolás minimumkiválasztásos rendezéssel programot úgy, hogy ne tartalmazhassanak a nyerőszámok számismétlődést!
Hf-12/4. Fejleszd tovább az 5. fejezet Feladat-3. pontja alatt található lottósorsolás programot (5-ös, 6-os, Skandináv) úgy, hogy a kihúzott nyerőszámokat a program sorba rendezze! A feladat megoldásához használj rekurzív eljárást "rendezes" néven!
Hf-12/5. Az elsajátítandó elméletet a BLOCK(LY) 12. fejezetében találod.

13. BLOCK(LY)

13. fejezet, melyben érdekes feladatok következnek, a BLOCKLY néhány újabb lehetőségével ismerkedhetsz, a gyakorlatban mélyítheted tudásod...

13.1. Látogassunk el a prímszámok világába! Három idevágó programot vizsgálhatunk meg az alábbiakban:
- Az első a prímszám meghatározásának matematikáját ragadja meg, ez alapján dönti el az adott számról, prímszám vagy sem.
- A második program a BLOCKLY beépített eljárását használja ahhoz, hogy megállapítsa egy adott számról, hogy prímszám vagy sem. Az ehhez szükséges blokkot a 'Matematikai műveletek' eszköztárban találod!
- A harmadik program a megtalált prímszámokat egy listába menti, majd a listát kiírja a képernyőre. (Amennyiben a megadott tartomány, melyben a prímszámokat keresi a program túl nagy, a lista csak a tartomány elejéről és végéről jeleníti meg a prímszámokat...)

13.2. A következő tombolasorsoló program eljárást tartalmaz "sorsolas" néven. Ez volt az az eset, ahol a program megjeleníthetősége, átláthatósága miatt készült az eljárás. (Így elfér egy képernyőn...:-)))

13.3. A következőkben cimletezünk. Három idevágó programot vizsgálhatunk meg az alábbiakban:
- Az első programban megadott összeg, illetve kétféle cimlet esetében keresi a lehetséges megoldásokat (Összesen 3500 forint; a bankjegy 500 forintos, az érme 200 forintos)
- A második program esetében a cimletezendő összeget, illetve a bankjegy és az érme értékét is input segítségével határozzuk meg.
- A harmadik program nem egyenként írja ki a lehetséges cimletezést, hanem listát készít, és azt jeleníti meg.

13.4. Elemezd az alábbi programot! A feladatkijelölés a következő: Felvettünk H forint hitelt, ebből havonta törlesztünk T forintot. Év végén a maradék tartozásunk p%-kal növekszik. Hány hónap múlva törlesztettük a teljes tartozást?

13.5. A következő program tízes számrendszerből váltja át az inputként megadott számot kettes számrendszerbe, majd az eredményt megjeleníti a képernyőn...

13.6. Van egy kockajáték, melynek a szabályai a következők:
- A gép a játsza a bank szerepét, a játékos közli a tét összegét, majd "dob" a két kockával.
- Ha a dobások összege: 2, 7, 12: a játékos a tétnek megfelelő zsetont nyeri. A 3, 5, 9, 11: nem nyer, nem veszít, a tőke változatlan. 4, 6, 8, 10: a játékos veszti a tétet.
Lássuk ennek a kockajátéknak a blockly-s algoritmusát!

13.7. 2004 óta a műkorcsolya értékelésekor tíz bíró pontoz, és közülük hét osztályzatát választja ki véletlenszerűen a számítógép. A legmagasabb és a legalacsonyabb pontszám kiesik, a maradék öt átlaga adja a pontszámot. A pontszám 0-tól 10-ig, 0.25-ös skálán mozog.
A program 5 eljárást alkalmaz a feladat megoldásakor. Először bekéri az értékelendő versenyzők számát, majd egyenként kéri a bírói pontszámokat. Ekkor figyeli azt, hogy a pontszámok az értékelhető tartományon belüliek-e (0-10 között), illetve, hogy megfelelnek-e a 0.25-ös skála követelményének. Hibás pontszám megadása esetén újra bekéri azt. Miután az összes input adat tárolásra került lista adatszerkezetekben, a program elvégzi a fenti algoritmus szerinti pontozást, majd a versenyzőket helyezési sorrendben értékeli, megadva a helyezés mellett a versenyző sorszámát is.
Érdekes tapasztalat a lista adatszerkezetek blockly-s működésével kapcsolatosan, hogy amennyiben a főprogramban lévő ciklus és "helyezes" eljárás közé illesztünk egy értékadó sort, melyben az "atlagpontszam" listával azonos tartalmúként definiáljuk az "atlagpontszam1" listát, akkor a "helyezes" eljárásban az "atlagpontszam" listából való elem törlésével egyidőben az "atlagpontszam1" lista is automatikusan rövidül, annak ellenére, hogy az eljárásba ilyen utasítást nem kódolunk. Mivel a program működése szempontjából ez hibás eredményhez vezet (a versenyzők sorszámának kiírása esetenként hibás), ezért kell a főprogram ciklusában mindkét listát egymástól függetlenül felépíteni.

13+1 Ráadás

14. BLOCK(LY)

14. fejezet, melyben kiderül, hogy aki egy adott programozási nyelven az alapokat már elsajátította, az más programozási nyelvet is képes megtanulni...

14.1. Ha idáig eljutottál, felmerülhet az a kérdés, vajon tudod-e hasznosítani azokat az ismereteket, amelyket a BLOCKLY-ban szereztél, más programozási környezetekben is? Ahogy arra, ennek a fejezetnek a rövid leírása is utal, a progamozás elmélete, logikája, az egyéb fejlesztői környzetekben is hasonló. Már eddig is megnézhetted blockly-s programjaidat egyéb - forráskód alapú - nyelvekben, mert ha a felületen átkattintottál a "JavaSript", a "Python", a "Dart", illetve az "XML" fülekre, láthattad a BLOCKLY által generált forráskódokat.

14.2. Most viszont valami mást mutatok neked! Ahogy arról az 1. fejezet PDF bemutatójában olvashattál, 1968-ban született meg a PASCAL programozási nyelv. Ennek a fejlesztői környezetnek freeware változata a FreePascal. Mivel ingyenesen elérhető, sokan tanulnak segítségével programozni, még középiskolai és főiskolai-egyetemi szinten is. Alább eddigi blockly-s programjaink "pascalos" átiratait töltheted le. Rájössz majd, hogy amennyiben néhány speciális pascalos szabályt elsajátítasz, érteni fogod ezt a programozási nyelvet is. Mert a lényeg, hogy a program működési logikáját, tartalmát értsd (ezt nevezik úgy a programozásban, hogy szemantika, a többi "csak" a programozási nyelv helyesírása (szintaktika), ami - legalábbis alapszinten - gyorsan elsajátítható.

14.3. Nézzünk néhány alapismeretet a teljesség igénye nélkül, annyit, hogy elindulhassunk:
A) A 3.3. alfejezetben volt róla szó, hogy a programnak általában van egy fejléce, melyet a PASCAL-ban kötelező létrehozni. Ennek része a program neve sor, mely nem tartalmazhat ékezetes karakter.
B) A fejlécben kell meghatározni - többek között - a változókat és azoknak típusait. Ezek a "var" sorok. A BLOCKLY-ban egyszerű dolgunk volt, mert általában "szám" vagy "szöveg" vagy "logikai" változóval dolgoztunk. A PASCAL-ban a szám típusú változó sokféle lehet, más és más értelmezési tartományokkal. Ne ijedj meg, mindig a konkrét programnál figyeljük majd meg, hogy miért pont azt a változó típust választjuk, így szép lassan haladunk majd a megismerésben, a gyakorlati példák segítségével!
C) Szintén a program fejlécében találsz általában egy sort: "uses crt;". Ez a sor meghív egy eljárásgyűjteményt (PASCAL-ban ezeket nevezik UNIT-oknak), melynek a neve CRT. Azért jó ez, mert így használhatunk a PASCAL alaputasításain kívül olyan eljárásokat - egyszerűen nevükkel meghívva őket főprogramunkba - amik a UNIT-ban vannak meghatározva. Ilyen eljárás pl. a "clrscr" (képernyőtörlés), mely a program elején biztosítja nekünk a zavaró, régebben kiírt adatok nélküli tiszta képernyőt.
D) Általában a pascalos programok utasítássorainak a végét ";" (pontosvessző) karakterrel zárjuk. Látni fogod majd, a szabály alól van néhány kivétel!
E) A program fejléce után a főprogram BEGIN kulcsszóval kezdődik. Főprogramunk END. kulcsszóval végződik, és itt a pont karakter is fontos.
F) Az adatbeolvasó utasítások a read és a readln, az "ln" végződés a kurzort új sorba küldi. Képernyőre kiírató utasítások a write és a writeln, az "ln" szerepe ugyanaz, mint az előbb.
G) A PASCAL-ban magyar ékezetes karaktereket csak képernyőre történő szöveg kiírásakor (write és writeln után idézőjelek közti rész...) lehet alkalmazni. Az alábbi példáknál mégis eltekintettem ettől, hogy a letöltött PAS fájlok böngészőben vagy jegyzettömbben megnyitva is olvashatók legyenek, ne csak a PASCAL editorában, illetve futtatáskor...

14.4. Szükséged van a fejlesztő eszközre (FreePascal). Az alábbi linken tudod letölteni a telepítőjét. Letöltés után telepítsd, és kezdődhet a munka! Érdemes a telepítő által az asztalra létrehozott parancsikonon jobb klikkel megjelenő helyi menüben a "Tulajdonságok..."-at választani, a betűtípust 12X16-ra állítani, illetve a panel "Parancsikon" fülén a "Teljes méret" opciót választani! Nekem ez jött be :-))

Az alább letölthető pascalos példafájlok kiterjesztése PAS, amely fájltípus megnyitásához társíthatod a FreePascal-t. Érdemes a letöltött példafájlokat egy külön mappába másolnod! A PAS-ba mentett programkódokat a FreePascal editorában szerkesztheted, és Ctrl+F9 billentyűparanccsal futtathatod. Kicsit várni kell, amíg a fordító megjeleníti a fekete karakteres képernyőn a program első üzenetét! Minden egyes futtatáskor a FreePascal generál egy EXE kiterjesztésű állományt, melyet akár olyan gépen is futtatni tudsz, melyen nincs telepítve a fejlesztői környezet...

A megismert BLOCKLY programok összehasonlítása PASCAL programokkal...

  • A háromszög területe BLOCKLY program és PASCAL program
  • Megjegyzés-1. A Chrome alapértelmezetten új böngészőfülön nyitja meg a pascalos kódot. Ezt elkerülendő válaszd a linken a jobb klikk - Link mentése másként... opciót, illetve, ha már az új Chrome fülön látod a kódot, akkor jobb klikk - Mentés másként... paranccsal mentheted számítógépre a PAS fájlt! Firefox-ban és Internet Explorerben ilyen gond nincs, ezek a böngészők először megkérdezik, hogy szeretnéd-e a letöltést menteni lemezre, vagy azonnal megnyitnád-e böngészőben.
    Megjegyzés-2. Azért kell real - tehát valós szám típusú - változót használni, mert így tizedes törtben is megadhatjuk az adatokat (alap, magassag) A terület változója esetén (terulet) meg kötelező is lenne, hisz az osztás miatt gyakorta tört eredmény születik. A "real" másik előnye az igen széles értelmezési tartománya, ami miatt igen kicsi negatív és igen nagy pozitív számok tárolását teszi lehetőve. Ez a leggyakrabban használt valós szám típus a programozásban.Vigyázz a PASCAL-ban tizedes pont van!
    Megjegyzés-3. Ha nem akarjuk, hogy a képernyőre kiírt üzenet lebegőpontosan (pl. 1.4142E) jelenítse meg a real típusú számo(ka)t, akkor a megfelelő writeln sorban a szám mellett a megjelenés módját deklarálni kell (pl. szam:10:2 - ahol az első érték azt mutatja, hány karakteren ábrázoljuk a real típusú számot, a második érték a tizedesjegyek számát adja meg.)
    Megjegyzés-4. A PASCAL programban kettő olyan eljárás van meghívva, melyek a CRT-ben vannak deklarálva. A clrscr; sor a képernyőtörlést végzi a főprogram elején, a readkey; szerepe pedig az, hogy a program végén a kijelzőn megjelenített eredményt kimerevíti addig, amíg bármely billentyűt le nem ütjük a klaviatúrán. E nékül olyan gyorsan futna le az eredmény, hogy képtelenek lennénk az észlelésére (kipróbálhatod, hogy mi történik, ha eltávolítod ezt a sort...).

  • A téglalap kerülete, területe BLOCKLY program és PASCAL program
  • A kör kerülete, területe BLOCKLY program és PASCAL program
  • Megjegyzés. A program pascalos kódja esetében is használhatjuk a pi függvényt.

  • Monogram-1. BLOCKLY program és PASCAL program
  • Megjegyzés-1. A monogramos programokban a blockly-s szöveg típusnak a pascalos megfelelője a string (karakterlánc) típus.
    Megjegyzés-2. Szöveg - string - típusú változó esetén a [n] index a változó n-dik számú tagját adja eredményül.

  • Monogram-2. BLOCKLY program és PASCAL program
  • Megjegyzés-1. A "szokoz" változó típusa byte. Ez egy olyan egész szám típus, melynek az értelmezései tartománya 0-255.
    Megjegyzés-2. Az upcase függvény segítségével a végig kisbetűs sztringünk (jelen esetben a "neved") is NAGYBETŰSSÉ alakítható.
    Megjegyzés-3. A pos függvény segítségével tudjuk a teljes névben a szóköz helyét pozicionálni. Megállapítja, hogy hányadik karakterhelyen található a keresett karakter (jelen esetben " ", tehát a szóköz).

  • Neved hossza BLOCKLY program és PASCAL program
  • Megjegyzés. Egyetlen újdonság a length függvény, mellyel egy sztring hossza állapítható meg.

  • Szorzás BLOCKLY program és PASCAL program
  • Osztás BLOCKLY program és PASCAL program
  • Számoljuk ki Gergő bérét! BLOCKLY program és PASCAL program
  • Megjegyzés-1. Itt az "oraber", az "ora" és a "perc" változók integer - egész szám típusúak. Értelmezési tartománya -32768-tól 32767-ig tart. Kívánom, hogy a majdani béred forintban NE férjen bele az integer adattípusba, de a tartozásaid sose haladják meg ezt a tartományt! Nagyobb egész számok tárolására alkalmas a longint típus, melynek értelmezési tartománya durván -2 milliárdtól +2 milliárdig tart. (A pontos értéket megkeresheted az interneten, annak, hogy pontosan tudd, jelenleg nincs számodra jelentősége...)
    Megjegyzés-2. A kerekítésre a round függvényt használhatjuk, de a pascalos mintából az is kiderül, hogy a képernyőre kiíratás sora előtt kell használni.

  • Energiaváltozás BLOCKLY program és PASCAL program
  • Páros, páratlan szám BLOCKLY program és PASCAL program
  • Megjegyzés-1. Figyeld meg, hogy amennyiben az integer típus értelmezési tartományán kívül eső számot adunk meg inputként, a program futása hibaüzenettel leáll!

  • Páros, páratlan szám logikai változóval BLOCKLY program és PASCAL program
  • Megjegyzés-1. Az első fontos dolog ennél a programnál - a logikai változó típusa a PASCAL-ban a boolean
    Megjegyzés-2. A második fontos dolog ennél a programnál - az odd függvény szerepe: a szám páratlanságát vizsgálhatjuk a segítségével.

  • Páros, páratlan szám ráadás-1. PASCAL program while-do (elől tesztelő) ciklussal
  • Páros, páratlan szám ráadás-2. PASCAL program repeat-until (hátul tesztelő) ciklussal
  • Megjegyzés. A ráadás programok elől tesztelő (while-do) ciklussal, illetve hátul tesztelő (repeat-until) ciklussal fűszerezik az eredeti porgramot. Amennyiben nullát adunk meg vizsgálandó számként, még azt is megvizsgálja az algoritmus, majd "kiugrik" a ciklusból.

  • Oszthatóság 5-tel és 10-zel BLOCKLY program és PASCAL program
  • NAGYBETŰ-kisbetű BLOCKLY program és PASCAL program
  • Melyik a nagyobb szám? BLOCKLY program és PASCAL program
  • Tanácsadó-1. BLOCKLY program és PASCAL program
  • Mennyi az életkorod? BLOCKLY program és PASCAL program
  • Melyik a LEGNAGYOBB szám? BLOCKLY program és PASCAL program
  • Lottósorsolás-1. BLOCKLY program és PASCAL program-1A., illetve PASCAL program-1B.
  • Megjegyzés-1. Új elem az PASCAL program-1A-ban az elöl tesztelő ciklus, pascalos fajtája a while-do ciklus. A ciklusba ágyazott utasítások sorát begin kulcsszóval nyitjuk, és end;-vel zárjuk.
    Megjegyzés-2. A PASCAL program-1A elejére 1 plusz üzenetsor lett beiktatva, utána egy readkey crt-eljárás következik, így a program a kijelzőn nem az 1. sorsolt számmal jelentkezik be azonnal, hanem előtte ezt az üzenetet láthatjuk.
    Megjegyzés-3. Ami most jön, az fontos! A PASCAL véletlenszám generátora a randomize eljárás a random függvénnyel karöltve működik, de a 0 (nulla) a kezdő értéke. Ezért kell a 90 számos lottónál random(91)-et alkalmazni. Így viszont a 0 is kisorsolódhat. Ezt a problémát kezeli a 1A pascalos kódban a ciklusutasítások közé ékelt elágazás. Az eredetileg letölthető kódban ez a rész 2 darab kapcsos zárójel {} között helyezkedik el, a karakterek itt szürkék, az így jelölt rész NEM VESZ RÉSZT a program futásában. Ezért használják ezt az eszközt a programozásban kommentek elhelyzésére. Távolítsd el a kapcsos zárójeleket, és futtasd így a programot. Előbb-utóbb a random(91); bevonzza a nullát...
    Megjegyzés-4. A PASCAL program-1B számláló - for-to-do - cilussal oldja meg a feladatot. Figyeld meg, hogy ebben az esetben nincs szükség az i:=1; sorra a ciklus előtt, hisz értékadás az "i"-nek a ciklus feltétel sorában történik. A ciklus magától számol a megadott értékek (jelen esetben 1 és 5 közt, nincs szükség ciklus végén az "i" értékének növelésére sem, úgy ahogy arra a blockly-s programban és a PASCAL program-1A-ban while-do ciklus alkalmazásakor szükség volt..
    Megjegyzés-5. Figyeld meg, hogy a szam:=random(90)+1; sorral a 0 kisorsolását is el lehet kerülni, így nincs szükség a PASCAL program-1A while-do ciklusába ágyazott elágazásra.

  • Osztályátlag BLOCKLY program és PASCAL program-1., illetve PASCAL program-2A., illetve PASCAL program-2B.
  • Megjegyzés. Mivel a BLOCKLY-ban lényegileg csak elöl tesztelő (ezen belül számláló) ciklus van, ennek a programnak három pascalos változatát is láthatod. Az első számláló, for-to-do ciklussal, a következő elöl tesztelő, while-do ciklussal oldja meg a feladatot, a harmadik példa hátul tesztelő, repeat-until ciklust alkalmaz. Figyeld meg, hogy az "i" változó értékét és a ciklusfeltételt mennyiben kellett másként meghatározni! Van-e esetleg más jó megoldás is az "i" és a ciklusfeltétel összhangjára?

  • Gondoltam egy számot! BLOCKLY program és PASCAL program
  • Megjegyzés. Frappáns megoldás a lottósorsolásnál már említett random és nulla kérdésére. Módosítjuk a játékszabályt, és 0-100 közötti számot kell kitalálni...:-))

  • Tőkeszámítás BLOCKLY program és PASCAL program
  • Megjegyzés-1. Ebben a pascalos programban számláló, for-to-do ciklussal ismerkedhetünk. Mivel a ciklusba ágyazva csak egy utasítássor van: a - toke:=toke*(1+(kamatlab/100)); - sor, a ciklus begin-end-je elhagyható lenne, de több ciklusutasításnál kötelező.
    Megjegyzés-2. A pascalos számláló ciklus felépítése teszi szükségessé az "i" változó használatát. A blockly-s számláló ciklusban erre a változóra nem volt szükség.

  • Pénzfeldobás BLOCKLY program és PASCAL program
  • Végtelen ciklus BLOCKLY program és PASCAL program
  • Megjegyzés. A pascalos végtelen ciklust a folyamat ablakának bezárásával tudod megszakítani. Azért futtatás előtt a biztonság kedvéért ellenőrizd, nincs-e valamely szintén megnyitott windowsos ablakban mentetlen munkád...

15. BLOCK(LY)

15. fejezet, melyben folytatjuk a BLOCKLY és PASCAL programok összehasonlítását, ezzel is bővítve programozási alapismereteinket...

15.1. A fejezet elején lássunk egy praktikus ötletet a pascalos munkához! Böngészőfülön, vagy jegyzettömbben megnyitott PASCAL kódot gyorsan elhelyezhetsz a FreePascal editorában a következő módon: Nem kell mást tenned, mint a szokásos módon kijelölni a forráskódot, majd vágólapra másolni, pl. a Ctrl+C billentyűkombinációval, vagy helyi menü segítségével. Megnyitva a FreePascal editorát válaszd az 'Edit' menüből a 'Paste from Windows' parancsot, és máris ott a kód az editorban! Mentéséhez válaszd a 'File' menü 'Save as...' parancsát!
15.2. Lehet, mire idáig jutottál a PASCAL programok tanulmányozásában, már saját algoritmusod pascalos kódolásába is belefogtál. Amennyiben a Ctrl+F9 billentyűkombinációval megpróbálod futtatni a programot, ha hiba van a kódban, az vagy nem fut le, és hibajelzéssel leáll, vagy a program megkezdi ugyan a futását, de pl. egy rossz értékadásnál (a leggyakoribb ilyen hiba a nullával való osztás) leáll.
A) szintaktikai hiba - a nyelv helyesírási hibája - esetén a program nem kezd el futni, a megjelenő hibaüzenet(ek)ben megtalálhatod, hányadik sor, mely karakterénél van a "helyesírási" hiba. Ez a hibakereső találja meg a nem megfelelően deklarált változótípust is.
B) szemantikai hiba - tartalmi, algoritmikai, értékadási hiba - esetén elképzelhető, hogy a program futása elindul, de a hibás résznél leáll. Ilyenkor tesztsorok beiktatása segítheti a hibakeresést, vagy az, ha bizonyos kódrészleteket "kikommentelve" próbálod meg szűkiteni a hiba előfordulásának kódbeli helyét.
15.3. A hibakereséshez ajánlom figyelmedbe a FreePascal "Run" menüjének "Step over" parancsát. Az F8 billentyűvel lépkedni tudsz a programkódban, ez segíthet kideríteni, melyik sorban van az a szemantikai (algoritmus, vagy értékadási) hiba, ami miatt a program azt csinálja amit írtál, és nem azt, amit szeretnél :-)) Ha biztos vagy abban, hogy a program egy darabig jól fut, és gyorsítani szeretnéd a hibakeresést, a "Debug" menüből válaszd a "Breakpoint" parancsot, ezzel megjelölheted a kód azon sorát, ameddig a program lépkedés nélkül lefut, és utána kell csak az F8 billentyű segítségével lépkedned...

  • Lottósorsolás-2. BLOCKLY program és PASCAL program
  • Megjegyzés. A program újdonsága az eljárás (procedure), melyet a főprogam előtt kell deklarálni, majd a főprogramban - a szükséges helyeken nevével meghívva - hivatkozni rá.

  • Valutaváltás BLOCKLY program és PASCAL program
  • Megjegyzés-1. Az eljárás deklarálása itt már nem lehet újdonság. Az eljárásban kerekítés round függvénnyel.
    Megjegyzés-2. A főprogramban lévő ciklus pascalos kivitelezésére, most a hátul tesztelő ciklus repeat-until volt a megoldás.

  • Szabályos sokszögek kerülete paraméteres eljárással BLOCKLY program és PASCAL program
  • Megjegyzés-1. Figyeld meg, hogy a paraméteres eljárásban hogyan történik a paraméterek típusának deklarálása.
    Megjegyzés-2. A blockly-s programban található utolsó két tesztüzenet a pascalos programban hiányzik. Ennek oka, hogy amennyiben a tesztsorok a PASCAL programba is bekerülnek, a csak az eljárásban értelmezhető logkális változók miatt a program nem fordul le, a beépített hibakereső (debugger) hibaüzenettel tér vissza.

  • Téglalap kerülete, területe paraméteres eljárással BLOCKLY program és PASCAL program-1., illetve PASCAL program-2.
  • Megjegyzés-1. Figyeld meg, hogy a véletlenszámok esetében hogyan lehet megoldani a 0 kikerülését, illetve milyen módon képzünk pascalos környezetben eredetileg egész típusú véletlenszámokból tizedes törteket!
    Megjegyzés-2. Figyeld meg, hogy a második PASCAL programban az "i" és a "j" input adatként kerülnek bevitelre, és a paraméteres eljárásban kapcsolódnak az "a" és "b" oldal értékéhez!

  • A szegény ember 3 kívánsága rekurzív eljárással BLOCKLY program és PASCAL program
  • Megjegyzés. A PASCAL programban a változónak és/vagy az eljárásnak a neve nem tartalmazhat számkaraktert, ezért ezekben - szemben a blockly-s programmal - betűkarakterekkel kellett ezeket az azonosítókat megadni.

  • Kép a képben rekurzív eljárással BLOCKLY program és PASCAL program
  • Fibonacci nyulai rekurzív eljárással BLOCKLY program és PASCAL program
  • Megjegyzés. Figyeld meg, hogy a PASCAL programban - szemben a BLOCKLY programmal - a havonkénti nyúlpárok számának megjelenítése egyszerre történik. Módosítsd a PASCAL programot úgy, hogy abban is soronként jelenítődjön meg a a nyúlpárok havi száma! Hova kell beilleszteni ehhez a plusz utasítássort, az eljárásba, vagy a főporgramba?

  • Minimumkiválasztásos rendezes-1. BLOCKLY program és PASCAL program-1., illetve PASCAL program-2.
  • Megjegyzés-1. A BLOCKLY lista adatszerkezete helyett a PASCAL programban dinamikus tömb adatszerkezetet tudunk használni. A pascalos tömbből a minimum érték törlése bonyolultabb, mint a blockly-s kód listájából. Hogy könnyebben elboldogulj a megfejtéssel, a PASCAL kód kapcsos zárójelek közti kommenteket tartalmaz. A pascalos egymásba ágyazott algoritmikus eszközöket (ciklusok, elágazások) a kód megfelelő részének beljebb kezdésével lehet átláthatóbbá tenni. A hivatásosak is gyakran alkalmazzák ezeket a módszereket azért, hogy később bárki könnyebben értelmezhesse az általuk megírt algoritmust.
    Megjegyzés-2. A BLOCKLY program melletti PASCAL program-1. inputként megadott számok rendezését végzi, kis változtatással azonban névsor kialakítására alkalmas programot is lehet belőle írni. Figyeld meg, hogy a PASCAL program-2. névsorrendezéséhez a tömböt string típusként kellet deklarálni, az egyik változó (min) pedig ShortString típusú lett!

  • Lottósorsolás minimumkiválasztásos rendezessel BLOCKLY program és PASCAL program-1., illetve PASCAL program-2.
  • Megjegyzés. Az első PASCAL programban a sorsolas és a rendezes eljárások nem tartalmaznak rekurziót, a számlálás eszköze a ciklus. A második PASCAL programban - mint ahogy a BLOCKLY programban is - mindkét eljárás rekurzív.

  • Prímszám-1. BLOCKLY program és PASCAL program
  • Megjegyzés. A PASCAL programban a nem megfelelő számok (negatív számok, a valós számok, és a logint egész típus 0 feletti értelmezési tartományánál - tehát 2147483647-nél nagyobb) számok kiszűréséhez használt módszer sikeréhez a vizsgálandó számot először real típusú változóba kell beolvasni, majd típuskonverzióval lehet longint változóvá alakítani, mellyel már működhet a prímszám keresése, a kereséshez használt dinamikus tömb is értelmezni tudja. A típuskonverzióhoz használt trunc függvény a real típusra jellemző tizedes jegyeket vágja le és alakítja át a számot egész számmá. Természetesen nagy számok esetén a prímszám keresési folyamata tovább tart, mint kisebb számok esetén.

  • Tombolasorsoló BLOCKLY program és PASCAL program
  • Megjegyzés. A PASCAL programban a delay - crt unitos eljárás paramétereként megadott milliszekundumnyi időtartamra késlelteti a program következő lépését, ez esetben a kilépés végrehajtását.

  • Cimletezes-2. BLOCKLY program és PASCAL program
  • Megjegyzés-1. A PASCAL program újdonsága a gotoxy(x,y) crt unitos eljárás, mellyel a kurzort a képernyő adott pontjára mozgathatjuk, és onnan kezdhetjük az output adatok megjelenítését.
    Megjegyzés-2. Ez a program megmutatja azt, hogy a programozónak arra is gondolnia kell, hogy a felhasználó sok esetben figyelmetlenül adja meg a szükséges input adatokat. Ennek kezelésére készült a programnak az az ága (ez a PASCAL program kommentjében is jelezve van), mely akkor fut, ha a felhasználó a feladatkiírástól eltérően a teljes összeget úgy adja meg, hogy az kevesebb, mint a legkisebb megadott bankjegy cimlet (pl. teljes összeg 900 forint, bankjegy cimlet 1000 forint).

  • Hitel törlesztési idejének számítása BLOCKLY program és PASCAL program
  • 10-es 2-es számrendszerváltó BLOCKLY program és PASCAL program
  • Kockajáték BLOCKLY program és PASCAL program
  • Megjegyzés. A PASCAL programban az exit parancs segítségével az algoritmus bármely pontján (akár ciklusból is) felfüggeszhetjük a futást. A delay a paramétereként megadott milliszekundumnyi időre késlelteti a következő utasítás (vagy akár a programból való kilépés) végrehajtását.

  • Műkorcsolya pontozása BLOCKLY program és PASCAL program
  • Megjegyzés. A PASCAL programban a lista adatszerkezet helyett egy- és kétdimenziós dinamikus tömbökkel lehetett megoldani a feladatot. Ennek következtében nem csak a program, de a segédváltozók használata is némileg bonyolultabb lett. A cursoroff és cursoron crt unit eljárások szerepét magyarázzam? :-)

  • Az 1-13. fejezet BLOCKLY programok képernyőképei egy csomagban...(ZIP-JPG)
  • A 14-15. fejezet PASCAL programjai egy csomagban...(ZIP-PAS)
16. BLOCK(LY)

16. fejezet, "merre tovább, melyik úton?" - javaslatok a továbblépéshez...

16.1. Ha idáig eljutottál, biztos vagyok benne, hogy már magad is szeretnél komolyabb programokat készíteni. Bár a tanóráknak már nem lesz anyaga amiről itt szólok, de szakkörökön elképzelhető, idáig is eljutunk. A következő logikus lépés az Objektum Orientált Programozás (OOP), melyet párhuzamos programozásnak is nevezünk. Legszemléletesebben úgy tudod ezt elképzelni, hogy pl. a mai modern grafikus programok a felhasználói felszínen (az ablakban, vagy telefon képernyőjén) gombokat, listákat, beviteli mezőket, párbeszédablakokat, stb... tartalmaznak. Ezeket az objektumokat a modern OOP programnyelvekben egyszerű módszerekkel grafikus felszínen elhelyezzük, méretezzük, szükség esetén feliratozzuk. Utána következik a tényleges programozás, azt kell megírni a kódban, mi történjen katt-ra, dupla katt-ra, jobb klikk-re, legördítésre, adatbevitelre, stb... A továbblépés iránya neked is kérdés lehet, mint ahogy a fejezet címében idézett Bródy János "Az utcán" című dal szövegében is ez az érzés fogalmazódik meg...
16.2. Amennyiben asztali gépre, laptopra szeretnél programot fejleszteni, és tetszett a PASCAL, a Lazarus programozási nyelvet ajánlom, mely ugyanannak a közösségnek az ingyenes terméke, mely a FreePascal-t is fejleszti, azzal a különbséggel, hogy a Lazarus grafikus felszínű - ablakos - program létrehozására készült, az OOP-re lényegesen alkalmasabb - korszerű - nyelv.
16.3. Amennyiben az OOP más platformon, pl. Android-on érdekel, az "App Inventor" lehet a jó megoldás. Ezzel - a BLOCKLY-hoz hasonlóan szintén vizuális kódolásra alkalmas programozási nyelvvel - elkészült applikációdat a saját telefonodon, tableteden futtathatod. A használatához egy létező Google-fiókra és belépésre van szükség. Nem kell telepíteni, ugyanúgy böngészőben fut, mint a BLOCKLY. A programozási felszín, a blokkok felépítése, a programozás menete kísértetiesen hasonlít a blockly-s programozáshoz. A BLOCKLY-val szemben azonban a fejlesztői felszín, a blokkok egyelőre még "angolul beszélnek". Újabb ok az angol tanulására...:-)

16.4. És a végére egy kis vidámság. Az fps blogon (blog.fps.hu) találtam:


Az oldalt összeállította Kovács Pál (2015). A példaként itt található blockly-s programokat Kovács Pál és Kothencz Edit készítették, illetve egyes esetekben adaptálták - egyéb programozási nyelvekben írt kódokból vagy online elérhető programozási ötletekből. A tananyag blockly-s programjainak pascalos átiratait Kovács Pál készítette. Köszönet Dörnyei Juditnak, aki esetenként hibakereséssel, ötletekkel továbblendítette a munkát...:-)

Irodalom- és online forrásjegyzék:
Kvassay Jenő MSZKI - (Sz)Ámítástechnika 1.4., TIKETT Nyomdaipari Kft. 1994
Dancsó Tünde-Végh András - Számítástechnika 6. évfolyam részére, Műszaki Kiadó 2007, p. 43-71.
Végh András - Számítástechnika 7. évfolyam részére, Műszaki Kiadó 2007, p. 97-123.
Kasza János-Seressné Barta Ibolya-Simon Gyula-Weinémer Sándor - Informatika 7. osztály, Pedellus Novitas Kft. 2001, p. 97-127.
Kasza János-Seressné Barta Ibolya-Simon Gyula-Weinémer Sándor - Informatika 8. osztály, Pedellus Novitas Kft. 2001, p. 56-119.
Fazekas Sándor-Kasza János-Ziliziné Bertalan Gabriella - Számítástechnika 7. osztály számára, Pedellus Kft. 2008, p. 85-151.
Turcsányiné Szabó Márta-Zsakó László - Comenius Logo Gyakorlatok, Kossuth Kiadó 1997
Rozgonyi-Borus Ferenc - RAM-ba zárt világ, OSKAR Kiadó 1995, p. 182-223.
Schulcz Róbert - Számítástechnika munkatankönyv 7. osztályosoknak, Comenius Kiadó Kft. 2003, p. 75-106.
Benkő Tiborné-Benkő László-Tóth Bertalan-Varga Balázs - Programozzunk Turbo Pascal nyelven!, ComputerBooks Kft. 1995
Angster Erzsébet-Kertész László - Turbo Pascal feladatgyűjtemény I., Angster Erzsébet-Kertész László 2003

https://blockly-demo.appspot.com/static/demos/index.html
https://blockly-demo.appspot.com/static/demos/code/index.html
https://blockly-games.appspot.com/?lang=hu
http://info.berzsenyi.hu/programozas/
http://prog.ide.sk/pas.php
http://prog.ide.sk/pas2.php
http://zeus.nyf.hu/~akos/pascal/pasframe.htm
http://www.kobakbt.hu/jegyzet/PascalPrg/index.htm
http://www.jgytf.u-szeged.hu/tanszek/matematika/speckoll/2001/arany/index.html
http://www.bethlen.hu/matek/mathist/forras/Fibonacci_sorozat.htm
http://www.zsuuu.hu/alapism/programozas.html
http://www2.akg.hu/info/pascal/
http://wiki.vmg.sulinet.hu/doku.php?id=informatika:programozas
http://blog.fps.hu/post/76213033035/programozo-fejleszto-reakciok-valaszok
http://w3.enternet.hu/furedi/page2nd.html
http://server.dkrmg.sulinet.hu/~lutter/pascal1/index.htm
http://tudasbazis.sulinet.hu/hu/informatika/informatika
http://tudasbazis.sulinet.hu/hu/informatika/informatika/informatika-7-evfolyam/egy-nem-logo-szeru-programozasi-nyelv-megismerese/free-pascal-letoltese
http://tudasbazis.sulinet.hu/hu/informatika/informatika/informatika-9-12-evfolyam/algoritmizalas-adatmodellezes-programozoi-ismeretek
http://www.sorting-algorithms.com/
https://www.youtube.com/user/AlgoRythmics/videos
http://imagine.elte.hu/index.php
http://www.gyakorikerdesek.hu/szamitastechnika__programozas
http://www.origo.hu/sport/egyeni/20040609ujpontozasi.html
http://www.freepascal.org/down/i386/win32-hungary.var
http://www.math.uni-leipzig.de/pool/tuts/FreePascal/fpctoc.html
http://www.lazarus-ide.org/index.php?page=downloads
http://appinventor.mit.edu/explore/
http://www.appinventor.org

http://egyszervolt.hu/estimese/benedek-elek-harom-kivansag-20160224.html