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: 

Komplemens képzés

Komplemens képzés

A komplemens képzés nem más, mint egy trükkös módja annak, hogy egy számot „kiegészítsünk” egy másik számmal, amivel együtt egy fix, maximális értéket adnak ki.Ez az elv működik bármilyen számrendszerben – legyen az 10-es, 8-as vagy 2-es alapú. Általánosan...

bővebben
Egész típusú számrendszer

Egész típusú számrendszer

Elgondolkodtál már azon, hogyan látja a számokat egy számítógép? 🤔 Mi emberek könnyedén használunk pozitív és negatív számokat, de a gép számára a világ csak 0 és 1.Ennek ellenére bármilyen számot, szöveget vagy képet elő tud állítani — de hogyan? Amikor...

bővebben
Adatábrázolás számítógépen

Adatábrázolás számítógépen

Amikor megnyitunk egy képet, elindítunk egy játékot vagy egyszerűen csak lementünk egy dokumentumot, ritkán gondolunk bele, hogyan tárolja a számítógép az adatokat. Pedig minden, amit a gép „tud”, az valójában nullák és egyesek végtelen sora. Ez a folyamat az, amit...

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