Pszeudokódok

Pszeudokódok

Anime lány pszeudokódot mutat be egy táblán, programozási logika oktatáshoz

Programozási alapismeretek

Pszeudokódok

A programozás elsőre fárasztónak tűnik, rengeteg zárójel, pontosvessző és szabély, amit ha elrontunk, az egész kódunk „összeomlik.” 
Ilyenkor jön jól a pszeudokód: egy olyan eszköz, ami a program lépéseit emberi nyelven írja le – logikailag pontosan, de nyelvtanilag kötetlenül. 

Miért jó pszeudokódot használni?

  • Először is, mert egyszerű, nem kell megtanulni hozzá egy nyelv szintaxisát.
  • Átlátható, mert a program logikáját tisztán mutatja, minden sallang nélkül
  • Tervezéshez tökéletes: mielőtt ténylegesen kódolnánk, a gondolatainkat papírra (vagy képernyőre) tudjuk rendezni
  • Nyelvfüggetlen: ugyanaz a pszeudokód alapján akár Pythonban, akár C++-ban megírhatjuk a kódot. 

Hogyan néz ki a pszeudokód?

Nincsenek kőbe vésett szabályok, de van pár szokásos formai elem: 

  • Algoritmus neve: általában leírjuk, mit csinál
  • Bemenetek és kimenetek: leírjuk miket használ a program és mit ad vissza
  • Sorrendbe tesszük a lépéseket: logikailag tisztán, rövid mondatokban

Példa 1: írjunk pszeudokódot, ami eldönti, hogy egy szám páros-e vagy páratlan

Algoritmus: Páros vagy páratlan

Bemenet: N (egész szám)

Ha N osztható 2-vel
           Írjuk ki: „A szám páros”

különben
          Írjuk ki: „A szám páratlan”
Vége

Tippek pszeudokód íráshoz

  • Használj egyszerű mondatokat, mintha egy barátodnak magyaráznál.
  • Ne akard túlkomplikálni: minden sor egy lépést írjon le
  • Légy következetes, mindig ugyanazokat a szavakat használd ugyanarra a műveletre
  • Ha bonyolultabb programról van sz, bontsd részekre (függvények, modulok)

 

A pszeudokód tehát egy átjáró a hétköznapi nyelv és a programozási nyelvek között. Megtanít arra, hogyan bontsd le a problémát kisebb lépésekre, hogyan tervezz előre, és hogyan gondolkodj algoritmusokban. 

Ha szeretnél még

a programozásról olvasni, nézd meg a Programozás alapjai bejegyzéseit: 

Perifériák – monitorok

Perifériák – monitorok

A monitor a számítógép egyik legfontosabb kimeneti perifériája: ezen keresztül válik láthatóvá a digitális tartalom. A kijelzők fejlődése közben nemcsak a képminőség változott, hanem maga a képalkotás fizikája is: a katódsugárcsöves rendszerek pásztázó nyalábjától...

bővebben
Listák bejárása Pythonban

Listák bejárása Pythonban

A listák létrehozása még csak az első kör. Attól, hogy már tudsz ilyet írni: tantargyak = ["matek", "töri", "tesi", "infó"] még nem sok minden történik.A programozás ott kezd érdekes lenni, amikor végig is tudsz menni a lista elemein. Ez a lista bejárása. Nem...

bővebben
Listák létrehozása

Listák létrehozása

Ha Pythonban programozol, nagyon gyorsan eljön az a pont, amikor már nem elég egyetlen adatot eltárolni. Oké, egy név, egy szám vagy egy életkor még simán mehet egy változóba. De mi van akkor, ha több hónapot, több nevet vagy több eredményt szeretnél együtt kezelni?...

bővebben
Algoritmus – folyamatábra

Algoritmus – folyamatábra

Folyamatábra jelei: start, folyamat, döntés, be- és kimenet – két diák a táblán magyarázza a lépéseket

Programozási alapismeretek

Algoritmus - folyamatábra

Amikor egy programot vagy feladatot lépésről lépésre írunk le, gyakran szövegesen vagy pszeudókódokkal dolgozunk. Ez azonban néha túl száraz és nehéz átlátni. 
Ilyenkor segít a folyamatábra: egy rajzos eszköz, amivel vizuálisan mutatjuk meg, hogy milyen sorrendben hajtódnak végre a lépések, és hol kell dönteni. Startnál kezdünk, a nyilak mutatják az irányt, a szimbólumok pedig jelzik, hogy épp adatot olvasunk be, számolunk, döntést hozunk vagy kiírunk valamit

Miért hasznos a folyamatábra?

Átlátható: könnyebb megérteni egy algoritmust, ha rajzban látjuk
Könnyen tanítható: a gyerekek hamar felismerik a jeleket
Programozási nyelvtől független: ugyanaz a jelölés Scratch-ben, C++-ban vagy Pythonban is értelmezhető

    Jel Neve Jelentése / tipikus felirat Példa használat
    Ovális Start / Stop Folyamat kezdete / vége Start • Stop
    Paralelogramma Be / Ki Bemenet vagy kimenet
    „BE: a, b” • „KI: Eredmény”
    Olvasd be a számot • Írd ki az összeget
    Téglalap Művelet Feldolgozás, számolás
    „osszeg := a+b”
    Értékadás, változó frissítése
    Rombusz Döntés Elágazás igaz/hamis (Igen/Nem) „a > b ?” → Igen/Nem ág
    Nyíl Irány Végrehajtási sorrend Következő lépésre mutat
    Kis kör / csatlakozó Csatlakozó Ábra folytatása másik helyen „A” → lap másik része

    A folyamatábra jelei

    START

    Start / Stop

    • Jel: ellipszis (ovális)
    • Mit jelent? – A folyamat kezdetét vagy végét mutatja
    • Példa: Start – a program indul, Stop – a program befejeződik
    BE / KI

    Be- és kimenet

    • Jel: paralelogramma
    • Mit jelent? – Adatok bevitele (BE) vagy eredmények kiírása (KI)
    • Példa: BE: szám, név; KI: eredmény, üdvözlő szöveg
    osszeg := a + b

    Művelet

    • Jel: téglalap
    • Mit jelent? – Valamilyen számítás, feldolgozás, tevékenység
    • Példa: osszeg := a + b, atlag := osszeg / 3
    a > b ? Nem Igen

    Döntés (feltétel

    • Jel: rombusz
    • Mit jelent? – Egy kérdés, aminél két út lehetséges: igen vagy nem
    • Példa: a > b? -> igen, nagyobb az „a” vagy nem, nagyobb a „b”

    Művelet

    • Jel: vonal,nyílheggyel
    • Mit jelent? A vezérlés, a program menetének iránya
    • Példa: Start -> beolvasás -> művelet
    A

    Csatlakozó

    • Jel: kis kör, benne egy betű vagy szám
    • Mit jelent? – a folyamatábra összekapcsolását segíti, ha a rajz túl hosszú, vagy több oldalra kerül
    • Példa: „A” -> mutatja, hogy innen a másik oldalon / ábra másik részén folytatódik a folyamat. 

    Döntések rajzban: így születik a folyamatábra

    Folyamatábra döntési szerkezettel – ha süt a nap, akkor strand, különben vége a programnak

    Ha … akkor

    A programozásban és az algoritmusokban gyakran előfordul, hogy egy feltétel alapján többféle út körül kell választanunk. Ilyenkor használjuk a döntési szerkezetet, melyet a folyamatábrán a rombusz jelképez.

    Példa: ha süt a nap, akkor irány a strand!

    Ez egy „ha … akkor” folyamatábra.
    A program a Startból indul ki, megvizsgálja a feltételt: Süt a nap? 
    Ha igaz: a Strand blokk következik.
    Ha hamis, akkor kihagyjuk ezt a lépést és egyből a Stop-hoz jutunk

    Ha … akkor…különben

    Ez már egy bővített döntési szerkezet, két lehetséges utat is ad.

    • Igaz ág (akkor): a feltétel teljesül -> végrehajtjuk az első tevékenységet
    • Hamis ág (különben): a feltétel nem teljesül -> másik tevékenység következik

    A példában az időjárás szerint döntünk: feltétel (rombusz): süt a nap? 
    Akkor (igaz ág – téglalap): irány a strand
    Különben (hamis ág – téglalap): olvasás
    Végül mindkét ág a STOP-ba fut.  

     

    Folyamatábra „ha … akkor … különben” döntéssel: „Süt a nap?” – igaz ág strand, hamis ág benti program, majd Stop

    Ciklus (iteráció) – ismétlés okosan

    Mi az iteráció?
    Ugyanazt a műveletsort többször szeretnénk elvégeztetni. Nem írjuk le százszor, hanem ciklust használunk. A ciklust egy feltétel vezérli: amíg a feltétel igaz, ismétlünk. Ha hamis, kilépünk. Erről bővebben itt olvashatsz: Algoritmus – ciklusok

    Folyamatábra előtesztelős ciklushoz – a feltétel vizsgálata igaz esetben ismétléssel, hamis esetben kilépéssel


    Előtesztelős ciklus

    Jel: rombuszban a feltétel + egy téglalapban a ciklusmag (utasítás)
    Működés: először megvizsgálja a feltételt, ami ha igaz, végrehajtja a ciklusmagot, majd visszatér a feltételhez.
    Ha hamis, kilép a ciklusból.
    Ha a feltétel rögtön hamis, egyszer sem fut le a ciklusmag. 
    Például: 
    Feltétel: amíg a szám ≤ 5
    Utasítás: kiírjuk a számot, majd növeljük eggyel.
    Lépések: 1 -> 2 -> 3 -> 4 -> 5
    Amikor a szám 6 lesz, a feltétel hamissá válik, a ciklus kilép

    Hátultesztelős ciklus

    Jel: téglalap az utasításnak, rombusz a feltételnek
    Működés: A program mindig végrehajtja az utasítást legalább egyszer, ezután ellenőrzi a feltételt: ha igaz, ismét végrehajtja az utasítást és újra ellenőrzi a feltételt. 
    Ha hamis, kilép a ciklusból. 
    Például: 
    kockadobás játék. Addig dobj a kockával, amíg hatost nem dobsz. 
    A dobás mindig megtörténik egyszer, akkor is, ha az első rögtön hatos.

    Háttultesztelős ciklus folyamatábra – utasítás végrehajtása, majd feltétel vizsgálata (igaz → ismétlés, hamis → kilépés)
    Algoritmus ciklusok

    Algoritmus ciklusok

    Anime stílusú illusztráció két diákkal, akik az algoritmus ciklusok típusait tanulják – for, while és do while ábrával a táblán.

    Programozási alapismeretek

    Algoritmus ciklusok

    Az algoritmus ciklusok arra szolgálnak, hogy ne kelljen ugyanazt a műveletsort újra és újra leírnunk, hanem a számítógép ismételje meg helyettünk. 
    A programozásban három alapvető ciklus típust különböztetünk meg: számlálós, elöltesztelős és hátultesztelős ciklusokat. Ezek mind segítenek abban, hogy hatékony, rövid és jól átlátható programokat írjunk. 

    Ciklustípusok

    A programozásban többféle ciklus létezik – attól függően, hogy előre tudjuk-e, hányszor kell ismételni az utasításokat, vagy csak futtatás közben derül ki, mikor kell megállni. Nézzük a három fajtáját:

      1. Számlálós ciklus(for)

      Lényege: pontosan meghatározzuk, hányszor fusson le a ciklus. Előre tudjuk, hogy „n” számú ismétlés kell👉 Példa:

      Ciklus i := 1-től 10-ig egyesével
      KI: i
      Ciklus vége

      2. Elöltesztelős ciklus (while)

      Lényege: addig fut aciklus, amíg a feltétel igaz. Akkor jó, ha nem tudjuk előre, hányszor kell ismételni

      👉 Példa:
      a := 1
      Ciklus amíg a <=10
      KI: a
      a := a+1
      Ciklus vége

      3. Hátultesztelős ciklus (do-while)

      Lényege: a ciklus legalább egyszer lefut, utána akkor ismétli, ha a feltétel igaz. Tipikus, ha előbb futtatni kell, és csak utána vizsgáljuk a feltételt. 

      👉 Példa:
      a := 1
      Ciklus 
      KI: a
      a := a+1
      Amíg a <= 10

      Típus Mikor használd? Lefut legalább egyszer? Pszeudokód Scratch blokk C++ minta Tipikus hiba
      Számlálós (for) Előre ismert N ismétlés. Nem garantált
      Ciklus i := 1..N
        KI: i
      Ciklus vége
      „ismételd N-szer”
      for(int i=1;i<=N;i++){ cout<
      i növelés kihagyása; rossz határ (`<` vs `<=`).
      Elöltesztelős (while) Amíg a feltétel igaz. Nem garantált
      a := 1
      Amíg a <= 10
        KI: a
        a := a+1
      Ciklus vége
      „amíg igaz … ismételd”
      int a=1;
      while(a<=10){ cout<
      Végtelen ciklus (feltétel nem változik).
      Hátultesztelős (do–while) Legalább egyszer futnia kell. Igen
      a := 1
      Ciklus
        KI: a
        a := a+1
      Amíg a <= 10
      nincs natív; if+repeat kombináció
      int a=1;
      do{ cout<
      Feltétel a végén → könnyű túlfutni.

      Mini példák - pszeudókóddal

      1. Számoljunk 1-től 10-ig!
      Írj pszeudókódot, ami az algoritmus ciklusok segítségével kiírja az 1 ... 10 számokat egymás után 

      A megoldáshoz kattints ide

      Ciklus i := 1..10
      KI: i
      Ciklus vége

      Magyarázat: a számlálós ciklusnál az alapértelmezett lépésköz 1. 
      A := pszeudókódban az értékadás jele

      Zöld kapucnis anime fiú a táblánál, aki az algoritmus ciklusok mini példáit (for, while, do-while) magyarázza

      2. Kérj be egy számot (N), majd az algoritmus ciklusok segítségével számold ki az 1-től N-ig terjedő számok összegét! A végén írd ki az összeget. 

      A megoldáshoz kattints ide

      BE: N
      i := 1
      osszeg := 0
      Amíg i <= N
      osszeg := osszeg + i
      i := 1 + 1
      Ciklus vége
      KI: "Összeg:", osszeg

      Magyarázat: 

      BE - bekérünk egy számot. Ez lesz a felső határ

      i := 1 - elindítjuk a számlálónkat 1-ről. Ezzel fogunk végigsétálni az 1..N tartományon

      osszeg := 0 -az induló összeg 0, ide gyűjtjük a részösszegeket

      amíg i <=N - előltesztelős ciklus, addig fut, amíg igaz,hogy i nem nagyobb, mint N. Ha rögtön hamis (pl.: N=0), a többi már nem fut le

      osszeg := osszeg + i - Hozzáadjuk az aktuális i-t az összeghez (értékadás: jobb oldalt kiszámoljuk, bal oldalt eltesszük)

      i := i + 1 - léptetés: továbblépünk a következő számra. Ha ezt kihagyod, végtelen lesz a ciklus
      ciklus vége: visszaugrás a feltételhez (i <= N). Ha még igaz, jön a következő kör

      KI: "Összeg:", osszeg - kiírjuk a végeredményt

       

      Kör i (belépéskor) Hozzáadott érték osszeg (kilépéskor) i léptetés után
      1 1 +1 1 2
      2 2 +2 3 3
      3 3 +3 6 4
      4 4 +4 10 5
      5 5 +5 15 6
      6 6 — (nem fut) 15

      A 6. ellenőrzésnél az i ≤ N már hamis (6 ≤ 5), ezért kilépünk, és kiírjuk: Összeg: 15.

      3. Olvass be egy nemnegatív egész számot (pl. 325) és számold ki a számjegyeinek az összegét (3+2+5 = 10). Ehhez az algoritmus ciklusok közül egy elöltesztelős ciklust használunk, mert minden számjegyet sorban meg kell vizsgálni. 
      Mini tudásdoboz:
      x mod 10 -> az osztás maradéka. 17 mod 3 = 2 (17-ben a 3 megvan ötször, marad a 2)
      x div 10 -> lefelé kerekít, pontosabban eldobja a tört részt. 49 div 10 = 4 (49-ben a 10 = 4,9, csak a 4 marad)

      A megoldáshoz kattints ide

      BE: x
      osszeg := 0
      amíg x > 0
         osszeg := osszeg + (x mod 10)
         x := x div 10
      ciklus vége
      KI: "A számjegyek összege:", osszeg

      Magyarázat - a példa: x = 325
      BE: x  //beolvassuk a számot, x=325

      osszeg := 0 // a kiinduló összeg üres, még nem adtunk hozzá semmit

      Amíg x > 0 // a 325 nagyobb, mint 0, belépünk a ciklusba

      osszeg := osszeg + (x mod 10) // x mod 10 = 5 (325-ben a 10 megvan 32,5-tel, az ötöt megtartja. Az  osszeg = 0+5 = 5

      x := x div 10 // 325 div 10 = 32. Ezzel zárjuk az első kört

      2. kör: x = 32, ami nagyobb mint 0, belép újra a ciklusba
      osszeg = 5 + 32 mod 10 =  5+2 (32-t osztom tízzel, marad a kettő) = 7
      x = 32 div 10 = 3

      3. kör x = 3, ami nagyobb, mint 0, belép a ciklusba
      osszeg = 7 + (3 mod 10) = 7+3 = 10 (Hármat elosztom tízzel. A három kisebb, mint 10, így maga a 3 a maradék. 3 mod 10 = 3)

      Kilépés: x = 0, így a feltétel hamis, vége a ciklusnak. Az összeg = 10. 

      4. Kérj be egy számot (pl. 7) és írasd ki a szorzótábláját 1-től 10-ig!

      A megoldáshoz kattints ide

      BE: n
      i := 1
      Amíg i <= 10
      KI: n, " * ", i, " = ", n*i
      i := i + 1
      Ciklus vége

      Magyarázat

      BE: n // bekérjük azt a számot, amelynek a szorzótábláját szeretnénk kiírni. Például n = 7

      i := 1 //ez lesz a számlálónk, innen indulunk. A szorzótáblát mindig 1-től kezdjük

      Amíg i <= 10 // a ciklus addig fut, amíg i nem nagyobb, mint 10

      KI: n, " * ", i, " = ", n*i // kiírjuk az aktuális sort a szorzótáblából. Példa: ha n=7 és i=3, akkor a kimenet 7*3 = 21

      i := i + 1 //lépünk a következő számra (i =2, i = 3, ..., i = 10)

      Ciklus vége: visszatérünk a feltételhez (i <= 10) és újra futtatjuk, amíg el nem érjük a 10-et.

       

      Kör i (belépéskor) Kimenet i léptetés után
      1 1 3 * 1 = 3 2
      2 2 3 * 2 = 6 3
      3 3 3 * 3 = 9 4
      4 4 3 * 4 = 12 5
      5 5 3 * 5 = 15 6
      6 6 3 * 6 = 18 7
      7 7 3 * 7 = 21 8
      8 8 3 * 8 = 24 9
      9 9 3 * 9 = 27 10
      10 10 3 * 10 = 30 11 (→ kilép)

      Amikor i = 11, a feltétel i ≤ 10 hamis, így a ciklus leáll.

      5. Olvass be egy számot (N), és számold ki az 1..N közötti páros számok összegét 

      A megoldáshoz kattints ide

      BE: N
      osszeg := 0
      i := 2
      amíg i <= N
      osszeg := osszeg + i
      i := i + 2
      Ciklus vége
      KI: "Páros számok összege", osszeg

      Magyarázat

      BE: N // bekérjük a felső határt, pl. N = 10

      osszeg := 0 // előkészítjük az összegváltozót

      i := 2 //a számláló induljon kettőről, mert ez az első páros szám

      Amíg i <= N //a ciklus addig fut, amíg nem lépjük től az N-t.

      osszeg := osszeg + i // mindig hozzáadjuk az aktuális páros számot

      i := i + 2 // kettesével léptetünk, így mindig páros számot kapunk

      Ciklus vége // újraellenőrizzük a feltételt, és ha igaz, jön a következő kör

      KI: // a végén kiírjuk az összeget

       

      Kör i (belépéskor) Hozzáadott érték osszeg (kilépéskor) i léptetés után
      1 2 +2 2 4
      2 4 +4 6 6
      3 6 +6 12 8
      4 8 +8 20 10
      5 10 +10 30 12 (→ kilép)

      A ciklus 12-nél megáll, mert i ≤ N (12 ≤ 10) hamis. Végeredmény: 30.

      6. Olvass be egy természetes számot (N), és írd ki növekvő sorrendben az összes osztóját

      A megoldáshoz kattints ide
      BE: N i := 1 Amíg i <= N Ha N mod i = 0 akkor KI: i i := i + 1 Ciklus vége   Magyarázat: i := 1 // innen indulunk (1 minden N-nek osztója) Amíg i <= N //addig megyünk, amíg el nem érjük N-t Ha N mod i = 0 //ha a maradék 0, akkor i osztó Ki: i //kiírjukaz osztót i := i + 1 // lépünk a következő jelöltre
      Kör i (jelölt) 12 mod i Osztó? Kiírt osztók (eddig) i léptetés után
      1 1 0 igen 1 2
      2 2 0 igen 1, 2 3
      3 3 0 igen 1, 2, 3 4
      4 4 0 igen 1, 2, 3, 4 5
      5 5 2 nem 1, 2, 3, 4 6
      6 6 0 igen 1, 2, 3, 4, 6 7
      7 7 5 nem 1, 2, 3, 4, 6 8
      8 8 4 nem 1, 2, 3, 4, 6 9
      9 9 3 nem 1, 2, 3, 4, 6 10
      10 10 2 nem 1, 2, 3, 4, 6 11
      11 11 1 nem 1, 2, 3, 4, 6 12
      12 12 0 igen 1, 2, 3, 4, 6, 12 13 (→ kilép)

      Végső kimenet: 1, 2, 3, 4, 6, 12. A ciklus i ≤ N után áll le.

      Mi az algoritmus? – anime stílusú lány, aki végzett a leckével a Programozási alapismeretek cikkhez
      Algoritmus struktúrák

      Algoritmus struktúrák

      Algoritmus – anime stílusú fiú a táblán teljes folyamatábrával (Start–End).

      Programozási alapismeretek

      Algoritmus struktúrák

      Az algoritmusok világában eddig megnéztük az alapokat: hogyan írjuk le egyszerűen a lépéseket, mik azok az adatok, és hogyan használjuk a változókat, konstansokat vagy éppen a műveleti sorrendet. Most azonban elérkeztünk ahhoz a ponthoz, ahol az algoritmusok igazán izgalmassá válnak: nemcsak egymás után hajtjuk végre az utasításokat, hanem döntéseket is hozunk, és akár ismételhetünk bizonyos lépéseket.

      Ebben a részben megismerkedünk az algoritmusok három legfontosabb építőelemével:

      • Szekvencia – amikor szépen sorban végrehajtjuk az utasításokat.

      • Elágazás – amikor feltételek alapján választjuk ki, merre haladjon tovább a program.

      • Ciklus – amikor valamit újra és újra ismételünk, amíg szükséges.

      Ha ezeket megérted, már tényleg úgy fogsz gondolkodni, mint egy programozó!

      Algoritmus struktúrái

      1. Szekvencia

      A legegyszerűbb algoritmus-szerkezet. Az utasítások egymás után hajtódnak végre, pontosan abban a sorrendben, ahogy leírtuk őket.
      👉 Példa:

      • Add össze a két számot!

      • Írd ki az eredményt!

      2. Elágazás

      Itt már döntési helyzet van. Egy feltétel alapján választjuk ki, melyik utasítást hajtsa végre a program.

      • Egyirányú elágazás: csak akkor hajtódik végre valami, ha a feltétel igaz.

      • Kétirányú elágazás: ha igaz, akkor az egyik utasítást hajtja végre, ha hamis, akkor a másikat.

      • Többirányú elágazás: több feltétel közül választjuk ki a megfelelőt.

      👉 Példa:
      Ha a jegyed nagyobb vagy egyenlő 5-tel, akkor „Sikeres vizsga!”, különben „Még gyakorolni kell.”

      3. Ciklus

      Amikor egy feladatot többször kell megismételni. A ciklus addig fut, amíg teljesül egy feltétel, vagy amíg végig nem érünk az előre megadott ismétlésszámon.

      👉 Példa:
      Számolj 1-től 10-ig, és írd ki a számokat!

      Minden algoritmus felépíthető a három alapstruktúrából. Ezt hívjuk struktúrált programnak

      Elágazások (feltételes utasítások)

      Az elágazás akkor kell, amikor döntést hoz a program: ha a feltétel igaz, egyik irányba megyünk. ha hamis, a másikba. Pont, mint amikor egy erdei ösvény kettéágazik. 

      Alapfogalom

      Feltétel: egy kifejezés, amelynek értéke igaz vagy hamis (logikai)

      Egyirányú elágazás (if)
      Ha a feltétel igaz, hajtsd végre az utasítást.

      Ha <feltétel> akkor <utasítás>

      Tanulók magyarázzák az algoritmus fogalmát a BE és KI utasításokon keresztül a táblánál.

      Kétirányú elágazás (if-else)

      Ha igaz -> utasítás1, különben -> utasítás2 
      példa:
      BE: jegy
      Ha jegy = 5 akkor
      KI: „Jeles”
      különben
      KI: „Gyakorolnod kéne”

      Többirányú elágazás

      Az első igaz feltétel utasítása fut le, különben az „egyéb” ág.
      BE: t (hány fok van)
      t <= 0 esetén KI: „fagy”
      1 <= t <=10 esetén KI „hideg”
      11 <= t <=20 esetén KI „hűvös”
      21 <= t <=28 esetén KI „kellemes”
      egyéb esetén KI „meleg”
      elágazás vége

      Tipikus hibák

      • „=” vs „==”: értékadás (=) NEM egyenlőségvizsgálat (==).

      • Feltétel helye: csak olyat írj a feltételbe, ami igaz/hamis értéket ad.

      • Tartományok átfedése: többirányúnál ügyelj, hogy a sávok ne fedjék egymást (és legyen „egyéb” ág).

      • Zárójelek: összetett feltételeknél tegyél zárójeleket, pl. (t >= 1 && t <= 10).

      Mi az algoritmus? – anime stílusú lány, aki végzett a leckével a Programozási alapismeretek cikkhez
      Algoritmus fogalma

      Algoritmus fogalma

      Algoritmus – anime stílusú fiú a táblán teljes folyamatábrával (Start–End).

      Programozási alapismeretek

      Algoritmusok fogalma

      Az előző részben megnéztük, mi is az az algoritmus, honnan ered a szó, és hogyan találkozunk vele a hétköznapokban. Most itt az ideje, hogy kicsit közelebb menjünk a programozás világához, és megtanuljuk az alapfogalmakat, amelyek nélkül nem tudunk algoritmust írni.

      Ezek elsőre talán ijesztően hangzanak – változó, konstans, értékadás –, de ha belegondolsz, mindennapi dolgokat fednek le.

      Egy változó olyan, mint a bögréd: ma teát töltesz bele, holnap kakaót – a tartalma változik, de maga a bögre ugyanaz marad.

      Egy konstans olyan, mint a hét napjai: mindig ugyanaz a sorrend, hétfő után kedd jön, ezen nem tudsz változtatni.

      Az értékadás pedig olyan, mint amikor beállítod az ébresztőt a telefonodon: kiválasztasz egy számot (mondjuk 6:30), és onnantól kezdve a telefon ehhez tartja magát.

      Ebben a fejezetben tehát sorra vesszük:

      • hogyan írhatunk le egy algoritmust mondatszerűen,

      • mik azok az adatok, amelyeket a számítógép kezel,

      • mit jelent a Be és Ki utasítás,

      • hogyan működik az értékadás,

      • és miért fontos a műveleti sorrend és a logika.

      A végére tisztább lesz a kép, és meglátod: az algoritmusok világa sokkal barátságosabb, mint amilyennek elsőre tűnik. 😉

      Mondatszerű leírás

      Az algoritmus lépéseit természetes nyelven írjuk le. Akkor jó, ha pontosan meghatározza:

      • mit kap (BE – bemenet)

      • mit ad vissza (KI – kimenet)

      • milyen lépésekben halad végig

      Példa:
      „Kérj be két számot, add össze, és írd ki az eredményt.”

      Ez egy mondatszerű leírás, ami gyorsan és könnyen érthető.

      Előnye: egyszerű, bárki számára érthető, nem kell hozzá programozói tudás.
      Hátránya: könnyű homályosan fogalmazni („számolj ki valamit” → de mit is pontosan?). Ezért a programozásban rövid, egyértelmű, utasító mondatokat és fix formátumot használunk.

      👉 Példa a homályos vs. pontos megfogalmazásra:

      • Homályos: „Számítsd ki a diák átlagát.”

      • Pontos: „Olvasd be a három jegyet, add össze, oszd el hárommal, és írd ki az eredményt.”

      Milyen egy jó adatleírás?

      Amikor programot írunk, fontos pontosan meghatározni, hogy milyen adatokkal dolgozunk. Ez segít a számítógépnek abban, hogy értse, mit szeretnénk vele számoltatni vagy feldolgoztatni.

      Van egy változója – olyan memóriahely, melynek értéke változhat a program futása közben. Formája: Név : típus
      Példa:
      szám : egész
      átlag : valós
      név : szöveg
      siker : logikai                        // igaz vagy hamis

      Van egy konstans értéke – Olyan adat, amihez nem nyúlunk hozzá: értéke a program futása alatt nem változhat. Olyan, mint a hét napjai száma (mindig 7), vagy a pi értéke.
      Példa:
      napokHet : egész(7)
      PI : valós(3.14159)

      Meghatározott típusa van – milyen fajta adat lehet
      Meghatározza, milyen értéket tárolhatunk és milyen műveletek értelmesek rajta. 
      Alapok: egész, valós, szöveg, logikai
      Összetett típusok: tömb (lista), rekord (adatcsomag)
      Formája: Típus típusNév = (struktúra).
      Példa:
      Típus Diak = Rekord {nev : szöveg, eletkor: egész, atlag: valós}
      Típus SzamLista = Tömb(1..10 : egész)          //10 elemű egész lista

      Tipp:

      • Adj típust minden változónak
      • Konstans értéket nem módosítunk
      • Tömbnél figyelj az indextartományra (1..10)
      • A változónév legyen beszédes: jegyek, pontok

      Beolvasó (BE) és kiíró (KI) utasítások

      A számítógép önmagában nem tudja, honnan vegyen adatokat, és mit kezdjen velük. Ezért kell BE és KI utasításokat használnunk.

      Mit jelentenek?

      BE: kérünk/olvasunk értéket és eltesszük változókba
      KI: kiírunk szöveget vagy számolt értéket a képernyőre

      Formájuk:
      BE: változók felsorolása
      KI: kifejezések felsorolása

      Változók = amibe olvassuk (pl. a, b, nev)
      Kifejezések = amit kiírunk (pl. Összeg: )

      Példa:

      Két szám összege
      BE: a, b
      KI: „Összeg: „, a+b

      Üdvözlő szöveg
      BE: nev
      KI: „Szia, „, nev, „!

      Tanulók magyarázzák az algoritmus fogalmát a BE és KI utasításokon keresztül a táblánál.

      Értékadó utasítás (assignment)

      Mit jelent? 

      Az értékadás azt jelenti, hogy egy változó felveszi egy kifejezés pillanatnyi értékét.
      Formája: 
      változó := kifejezés

      Bal oldalon mindig változó (vagy tömb-elem, pl. jegyek), jobb oldalon mindig valami számolható áll: a+b, max(a,b) stb.

      Fontos különbség: 
      := (értékadás) nem ugyanat, mint = (egyenlőség vizsgálat a feltételekben)

      • := → értékadás (új értéket teszünk a változóba)

      • = → összehasonlítás (pl. „egyenlő-e két szám?” – ezt a feltételekben használjuk)

      Például:

      • x := 5 → a változó mostantól az 5 értéket tárolja.

      • x = 5 → logikai vizsgálat, igaz vagy hamis választ ad.

      Példa – átlag 3 jegyből
      BE: J1, J2, J3
      osszeg := J1 + J2 + J3
      atlag := osszeg / 3
      KI: „Átlag:”, atlag

      Ha a beolvasott jegyek: 4, 5, 3, akkor:

      • osszeg := 4+5+3 = 12

      • atlag := 12 / 3 = 4

      • KI: „Átlag: 4”

      Algoritmus fogalma – értékadó utasítás (:=) magyarázata a táblán, két diák szemlélteti.

      Műveleti sorrend

      Amikor a számítógépnek több műveletet kell elvégeznie, mindig tudnia kell, melyikkel kezdje. Ha nem tartanánk be a sorrendet, teljesen más eredményeket kapnánk.

      Alapszabály: balról jobbra haladunk, kivéve, ha a zárójelek mást mondanak.
      👉 Ha bizonytalan vagy, inkább zárójelezz!

      Sorrend:

      Függvények – pl. abs(x), max(a,b), round(x)

      Egyoperandusú (unáris) műveletek – pl. -x (előjeles mínusz), nem x (logikai negálás)

      Kétoperandusú (bináris) műveletek – pl. *, /, div, mod, +, -

      Relációk (összehasonlítások) – pl. =, <, >, , ,

      Logikai műveletek sorrendje:
      nem → erősebb, mint az és, ami erősebb, mint a vagy.

      Példák:

      Szorzás előbb van, mint az összeadás

      KI: 2+3*4                 //3*4 = 12, majd 2+12 -> 14
      KI: (2+3)*4             //zárójel előbb: 5*4 -> 20

      Unáris mínusz vs zárójel

      KI: -(3+1)             //előbb 3+1=4, majd unáris mínusz -> -4

      Függvény előbb, mint művelet

      KI: max(3, 7) -2   //max ->7, majd 7-2 -> 5

      Relációk a legvégén

      BE: a, b
      KI: a+2 > b  //előbb a+2, utána hasonlítunk b-hez -> igaz/hamis
      példa: a=5, b=7 -> a+2=7 -> 7>7? -> hamis

      Logika
      Általános gyakorlat: a nem erősebb, mint az és, ami erősebb, mint a vagy

      Algoritmus fogalma – műveleti sorrend és logikai műveletek magyarázata két diákkal a táblánál.
      Mi az algoritmus? – anime stílusú lány, aki végzett a leckével a Programozási alapismeretek cikkhez
      Algoritmusok és követelmények

      Algoritmusok és követelmények

      Algoritmus – anime stílusú fiú a táblán teljes folyamatábrával (Start–End).

      Programozási alapismeretek

      Algoritmusok és követelmények

      Az algoritmus elsőre bonyolultnak hangozhat, de valójában mindannyian használjuk a hétköznapokban. Amikor elkészíted a reggelidet, vagy eldöntöd, hogyan jutsz el az iskolába, máris egy algoritmust követsz: lépések sorozatát, mely elvezet a célhoz.
      A számítógép világában az algoritmus ugyanezt jelenti – pontos, logikus utasítások rendszere, mely megmondja a gépnek, hogyan oldjon meg egy feladatot.

      Az algoritmus szó eredete

      Az algoritmus kifejezés nem a modern kor találmánya. A szó a 9. századi perzsa tudós, Muhammad ibn Mūsā al-Khwarizmī nevéből származik. Ő volt az, aki műveiben bemutatta az indiai számjegyek s a tízes számrendszer használatát, és ezzel megalapozta a ma ismert matematikai számolási módszereket. Latin fordításban a neve Algorithmi alakban jelent meg, innen ered a mai algoritmus szó.

      Algoritmus a mindennapokban

      Lehet, hogy elsőre úgy tűnik, az algoritmus csak a számítógéphez és a programozáshoz kapcsolódik, de valójában a hétköznapjainkat is átszövi. Gondolj csak bele:

      • Reggeli készítése: előveszed a kenyeret, megvajazod, ráteszed a sajtot vagy lekvárt – ez egy pontos lépéssorozat, vagyis algoritmus.

      • Útvonal kiválasztása: ha elindulsz otthonról, eldöntöd, merre mész – ha piros a lámpa, megállsz, ha zöld, mész tovább. Ez is egy elágazásokkal teli algoritmus.

      Mindezek ugyanúgy algoritmusok, csak éppen nem számítógép hajtja végre őket, hanem te magad.

      Tisztázzunk le néhány fogalmat

      Programozás

      A programozás azt jelenti, hogy megtervezzük, megvalósítjuk a számítógép számára érthető módon az algoritmusokat és adatszerkezeteket. Ehhez programozási nyelveket használunk (pl. Scratch, C++, Python, C#)
      Röviden: a programozás = gondolatból kód készítés

      Algoritmus

      Az algoritmus egy bizonyos feladattípus megoldására szolgáló utasítások sorozata. Ez a sorozat:

      • véges – nem tart örökké, van befejezése
      • világos – minden lépés egyértelmű
      • megcsinálható – a gép és / vagy ember ténylegesen végre tudja hajtani

      Röviden: algoritmus = pontos recept egy feladatra

      Anime stílusú illusztráció: egy 8. osztályos diáklány lila pulcsiban, laptopot tartva, a digitális kultúra 8 tanmenet témájához.
      Algoritmus – a programkészítés lépései folyamatábrán: specifikáció, tervezés (algoritmus-, adatszerkezet-, nyelvválasztás), kódolás, tesztelés, dokumentáció.

      Specifiáció – mit kell megoldani?

      Ez az a rész, amikor pontosítjuk a feladatot. 
      Példa: szeretnék egy appot, ami kiszámolja egy téglalap kerületét és területét.

      Tervezés – hogyan oldjuk meg?

      Ebben a fázisban döntéseket hozunk: 

      • algoritmus választása – milyen lépéseken keresztül érjük el a célt?
      • adatszerkezetek választása – miben tároljuk az adatokat? (pl.: változók, listák)
      • nyelv választása – mivel kódoljuk le? (pl. Scratch, C++, Python)

      Kódolás – a tervből kód lesz

      lefordítjuk az algoritmust a választott nyelv utasításaivá

      Tesztelés, hibajavítás – működik-e?

      Itt derül ki, hogy a program úgy fut-e, ahogy szerettük volna. Ha nem, javítjuk.
      Példa: ha negatív oldalhosszt adtál be, hibaüzenet kell. Két típusa: 
      1. szintaktikai – formai szabályok megsértése, pl. lemarad egy zárójel
      2. szemantikai – formailag jó, de nem azt csinálja, amit szeretnénk, hanem amire utasítottuk. 

      Dokumentáció – hogy más is értse

      Leírás készítése a programhoz, hogy ne csak a készítő értse, mit miért csinált. Szólhat a felhasználónak és a fejlesztőnek is. 

      Mi az algoritmus? – anime stílusú lány, aki végzett a leckével a Programozási alapismeretek cikkhez