érettségi feladat - címke

Programozási Hét 2024 – CodeWeek.eu

2024. november 3.2024. október 26. Szerző: Kiss Balázs

Az Európai Programozási Hét idén 2024. október 14-27-ig kerül megrendezésre. Ez egy önkéntesek által működtetett, alulról szerveződő kezdeményezés. Az önkéntesek saját országukban a Programozási Hét nagyköveteként népszerűsítik a programozást. Ehhez nyílt és ingyenes (online és offline) eseményeket hirdetnek meg a CodeWeek.eu weboldalon.

A Programozási Hét célja

a programozással való alkotás megünneplése,
az emberek felvértezése képességekkel,
az emberek összekapcsolása,
még több ember érdeklődésének felkeltése a tudomány, a technológia, a mérnöki ismeretek és a matematika iránt.

Miért jó ez az érdeklődőknek/résztvevőknek?

A programozás szórakoztató!
Programozni kreatív tevékenység! Az emberiség a kezdetektől fogva alkot: agyagból, kőből, téglából, papírból vagy fából. Manapság programozással is alkotunk.
A programozás felvértez! Sokkal többre is képesek vagyunk annál, hogy csak fogyasszuk a digitális tartalmat; programozással sokféle dolgot alkothatunk, és azokat milliók számára elérhetővé tehetjük. Létrehozhatunk weboldalakat, játékokat, irányíthatunk egy számítógépet vagy egy robotot.
Értsük meg a világot! Manapság egyre több minden össze van kapcsolva. Ha némi rálátásunk van arra, hogy mi történik a színfalak mögött, akkor a világot is jobban megérthetjük.
A programozás ötleteket kelt életre és alapvető kompetenciákat fejleszt. Megtanítja nekünk a számítógépes gondolkodást, fejleszti a problémamegoldást, kreativitást, kritikus érvelést, analitikus gondolkodást, valamint csapatmunkára késztet.
A programozás alakítja a jövőnket. Manapság a munkahelyek 90%-a digitális készségeket, köztük programozási ismereteket követel a munkavállalóktól.

2015-től veszünk részt az esemény szervezésében, programozást népszerűsítő előadások, laborgyakorlatok meghirdetésével és megtartásával. 2023-ban világszerte 80+ országban 4+ millió érdeklődő résztvevő csatlakozott. Ajánljuk korábbi beszámolóinkat is szakmai blogunkból, lásd: CodeWeek.eu címke.

Meghirdetett eseményeink

2024-ben nyolc it-tanfolyam.hu-s eseményt hirdettünk meg a Programozási Hét 2024 rendezvényen.
Helyszín: 1056 Budapest, Váci utca 47., 3. emelet, megközelítés
Dátum és időpont: 2024. október 26. 9:00-12:00-ig
Az események ingyenesek voltak, de a részvétel előzetes regisztrációhoz kötött.

Rendezvényünk plakátja

A rendezvény jó hangulatban telt, 50+ érdeklődőt vonzott. Többen rendszeresen visszatérő vendégek voltak, például a tavaszi Digitális Témahét, vagy a szeptember végi Kutatók éjszakája rendezvényeinkről. Eltérő belső motivációval érkeztek, ezek kulcsszavakban: kíváncsiság, pályaorientáció, karrierváltás, mesterséges intelligencia, programozási trükkök, robotika. Igazán tartalmasan telt el idén is ez a rendezvényre szánt három óra. Köszönöm oktató kollégáimnak és 2 korábbi hallgatónknak, hogy előadóként részt vettek a Programozási hét 2024 – CodeWeek.eu rendezvényünkön. Prezentációinkat tanfolyamaink hallgatói számára – a témához kapcsolódó témakörökhöz, ILIAS-ra feltöltve – tesszük elérhetővé.

9:00-9:40 – Szegedi Kristóf: Játékprogramok heurisztikáinak elemzése
A tudásalapú rendszerek elméleti alapjaihoz tartoznak a mesterséges intelligencia különböző megoldáskereső módszerei, az állapottér-reprezentáció és a klasszikus keresési stratégiák, heurisztikák. Egy játék állapotait valahogyan nyilvántartjuk egy adatszerkezetben. Lehet, hogy néhány lépést előre kalkulálunk (kiterjesztünk) és ezek elágazásaiból fát (fa adatszerkezet) tudunk építeni. Ezeket hatékonyan karban kell tartani konstrukciós és szelekciós műveletekkel. Heurisztika alapján döntéseket is kell hozni. Vajon melyik állapot a jobb, vagy kevésbé rossz, legalább olyan jó mint ahol járunk? Ki kell értékelni és abba az irányba érdemes haladni, amelyben végül a döntések sokasága igazolja és egyben adja a nyerő stratégiát. Ha ez nem megy, akkor még mindig játszhatunk nem vesztő stratégiával, azaz lehet cél a hosszabb játékmenet, vagy akár a döntetlen állapot is. Az előadás ismertet néhány tipikus problémaszituációt, játékteret leképező reprezentációs gráfbeli navigációt és összehasonlít néhány fabejáró/gráfbejáró stratégiát. A program mindhárom Java tanfolyamunk orientáló moduljához kötődik. Előismeretként feltételezünk némi jártasságot a programozási alapismeretek, programozási tételek, ciklusok, metódusok, tömbök témakörökből.

9:45-10:25 – Kaczur Sándor: Euler állatos feladatának megoldása hatékonyan programozva és geometriai megközelítéssel
Az Euler állatos feladataként ismert matematikai/logikai feladvány megoldási lehetőségeit mutatja be az előadó. Kétféleképpen közelítünk. Az egyik út a programozás eszköztárára és a hatékonyságra fókuszálva, Java nyelven kódolva, konzolos programot fejlesztve, egyre kevesebb lépésben oldja meg a feladatot. A másik út a geometriai megközelítés, amelyet szintén Java nyelven, de már grafikus felhasználói felülettel rendelkező program által, a megoldáshoz fokozatosan közelítve ábrázolja a szükséges lépéseket. A program a Java SE szoftverfejlesztő tanfolyamunk tematikájához kapcsolódik. Előismeretként feltételezünk némi jártasságot programozási ismeretek, programozási tételek, ciklusok, metódusok, tömbök, listák, halmazok, lambda kifejezések, grafikus felhasználói felület témakörökből.

10:30-11:10 – Kiss Balázs: A kognitív robotika szakterülete
Kiindulunk két problémából. Az egyik: az ipari robotok – többnyire a balesetveszély miatt – az emberektől elzárt területeken működnek. A másik: sok algoritmus nagyon erőforrás- és számításigényes. Áttekintjük, milyen együttes megoldások léteznek az említett problémákra. Vajon hogyan kapcsolódik össze ez a két különböző probléma? Mutatunk rájuk néhány példát. Érintjük az ember-robot interakció tipikus lehetőségeit, és az evolúciós robotika határait, lehetőségeit. A gépi tanulásban rejlő potenciálra 3-3 markáns kiváló és téves példát is mutatunk. Tipikus problémaszituációkon keresztül tekintjük át, hogyan érdemes modellezni, tervezni, amikor a kognitív robotika eszköztárával szeretnénk megoldani egy feladatot, problémát – akár KKV szinten is. A program mindhárom Java tanfolyamunk orientáló moduljához kötődik.

11:15-11:55 – Hollós Gábor: Gondolkodjunk logikusan!
Az előadás során áttekintjük az intelligencia, a kreatív problémamegoldó és logikus gondolkodás összefüggéseit és izgalmas feladatokból válogatva közösen megoldunk néhány fejtörő feladatot. Néhány példa: Hány éves a kapitány?, CHOO + CHOO = TRAIN, Logikus gondolkodás teszt. Minden feladathoz adunk rávezető példákat – ha esetleg egyik-másik nem menne, akkor ebből megtudod, miket érdemes gyakorolni, hogy menjen. A program mindhárom Java tanfolyamunk orientáló moduljához kötődik. Előismeretként feltételezünk némi jártasságot az algoritmusok, programozási alapismeretek, programozási tételek témakörökből.

9:00-9:45 – Kiss Balázs: Képekből Java eszközökkel készített átmeneti animáció lehetőségei
Az előadó példákon keresztül mutatja be az animációkészítés lehetőségeit. Eszközként a Java beépített grafikus API szolgáltatásaiból indul ki, majd áttér többféle kiegészítő API funkcióira. Összehasonlítást is tesz: kitér az előnyökre/hátrányokra és konkrét javaslatokat tesz saját tapasztalataira építve. Megkülönbözteti a fixen kódolt és az interaktív módon, eseménykezelést is tartalmazó animációk különbségeire, lehetőségeire, korlátaira. A bemutatott és kipróbálható példák kiválóan használhatók élményszerű gyakorlásra, rendszerező összefoglalásra grafikus felhasználói felületű Java szoftverfejlesztés, Java programozás témában (asztali és webes alkalmazások készítésétől függetlenül). A program mindhárom Java tanfolyamunk szakmai moduljához kötődik.

9:50-10:25 – Hollós Gábor: Gráfbejáró algoritmusok hatékonyságának elemzése
Az előadás összehasonlítja a 12 db programozási tétel iteratív, rekurzív és funkcionális megvalósításainak hatékonyságát. Fókuszba a funkcionális megoldásokat helyezi. A bemutatott keretrendszer mér lépésszámot, memóriaigényt és bonyolultságot. Nem egyértelműen a jó, jobb, rossz, rosszabb értékelés a cél, hanem inkább az, hogy tudjunk a programozási tételek közül megfelelőt választani adott problémához, feladathoz, algoritmushoz, adatszerkezethez. A program a Java SE szoftverfejlesztő tanfolyamunk és a Java EE szoftverfejlesztő tanfolyamunk tematikájához kötődik. Előismeretként feltételezünk némi jártasságot a programozási alapismeretek, programozási tételek, ciklusok, metódusok, tömbök, listák, halmazok, lambda kifejezések témakörökből.

10:30-11:10 – Kaczur Sándor: Számítástechnika vs. informatika vs. digitális kultúra
Az előadás áttekinti az elmúlt 30 év terminológiai változásait. A fókusz a tanárképzésre és az egyes tantervekre kerül. Néhány kérdésre megpróbálunk választ keresni/találni. Mi indokolta a változásokat? Mi miről-mire változott? Hová került a hangsúly? Mi volt az innovációnak tekinthető változás? Hogyan alakult a szabályozás, a jogi háttér? Hogyan alakultak át a tankönyvek és az online tananyagok? Milyen kompetencia- és tudáselemek kerültek ki a tematikából és kerültek be a tematikába? Hol tartunk most a NAT 2020-ban? Mi várható el attól a fiataltól, aki korábban informatikából érettségizett? És attól, aki már digitális kultúrából érettségizett? Milyen eltérések vannak a digitális kultúra tantárgy középszintű és az emelt szintű érettségi vizsga követelményeiben?

11:15-11:55 – Hatvani Bence, Hatvani Luca: Friss munkaerőpiaci tapasztalataink szoftverfejlesztőként
Mennyire könnyű ma szoftverfejlesztőként elhelyezkedni szakirányú felsőfokú végzettség nélkül? Milyen kihívásokkal találkozhatunk a felvételi folyamat során? Milyen elvárásokat támasztanak a munkaadók egy junior szakemberrel szemben? Hogyan telnek a beilleszkedés után a hétköznapok junior fejlesztőként kis létszámmal működő informatikai profilú kisvállalkozásnál? A tanfolyamainkon 2021-ben és 2023-ban végzett előadók karrierváltó junior szakemberként személyes tapasztalataikról számolnak be és válaszolnak a kérdésekre. A program a Java tanfolyamaink orientáló moduljához kötődik.

Egy matematika érettségi feladat megoldása programozással 2024

2024. május 18.2024. május 7. Szerző: Kaczur Sándor

A 2024-es középszintű matematika érettségi feladatsorból az 12. feladata inspirált arra, hogy elkészítsem a grafikus ábrázolását Java nyelven. A korábbi Kígyókocka grafikus felületen esettanulmány kiváló alapot, „keretrendszert” adott a továbbfejlesztésre. Érdekes belegondolni, hogy mennyire más lehetne a problémamegoldás, ha programozhatnánk a matematika érettségi vizsgán. A teljes feladatsor letölthető az oktatas.hu-ról.

12. feladat

Egy piros, egy fekete és egy fehér szabályos dobókockával egyszerre dobunk. Határozza meg annak a valószínűségét, hogy a dobás eredménye három különböző szám lesz! Megoldását részletezze!

1. megoldás

public static void main(String[] args) {

int dbKulonbozo=0, dbOsszes=0;

for(int i=1; i<=6; i++)

for(int j=1; j<=6; j++)

for(int k=1; k<=6; k++) {

if(!((i==j && j==k) ||

(i==j && i!=k && j!=k) || (i==k && i!=j && j!=k) ||

(j==k && i!=j && i!=k))) {

// System.out.println(i+"-"+j+"-"+k);

dbKulonbozo++;

}

dbOsszes++;

}

System.out.println(

"mindhárom kockakodobás különbözik: "+dbKulonbozo+" db"+

"\nösszes kockadobás: "+dbOsszes+" db");

double p=1.0*dbKulonbozo/dbOsszes;

System.out.println("A keresett valószínűség: "+p);

}

A kedvező /összes eset száma ad választ a kérdésre. Az egymásba ágyazott ciklusok – i-j-k számhármasokként – előállítják az összes esetet. Ezek száma 216, rendre: 1-1-1, 1-1-2, …, 1-1-6, 1-2-1, …, 6-6-5, 6-6-6-ig. A összes eset között megtalálhatók a kedvező esetek. Ezek száma 120, rendre: 1-2-3, 1-2-4, 1-2-5, 1-2-6, 1-3-2, 1-3-4, 1-3-5, 1-3-6, 1-4-2, 1-4-3, 1-4-5, 1-4-6, 1-5-2, 1-5-3, 1-5-4, 1-5-6, 1-6-2, 1-6-3, 1-6-4, 1-6-5, 2-1-3, 2-1-4, 2-1-5, 2-1-6, 2-3-1, 2-3-4, 2-3-5, 2-3-6, 2-4-1, 2-4-3, 2-4-5, 2-4-6, 2-5-1, 2-5-3, 2-5-4, 2-5-6, 2-6-1, 2-6-3, 2-6-4, 2-6-5, 3-1-2, 3-1-4, 3-1-5, 3-1-6, 3-2-1, 3-2-4, 3-2-5, 3-2-6, 3-4-1, 3-4-2, 3-4-5, 3-4-6, 3-5-1, 3-5-2, 3-5-4, 3-5-6, 3-6-1, 3-6-2, 3-6-4, 3-6-5, 4-1-2, 4-1-3, 4-1-5, 4-1-6, 4-2-1, 4-2-3, 4-2-5, 4-2-6, 4-3-1, 4-3-2, 4-3-5, 4-3-6, 4-5-1, 4-5-2, 4-5-3, 4-5-6, 4-6-1, 4-6-2, 4-6-3, 4-6-5, 5-1-2, 5-1-3, 5-1-4, 5-1-6, 5-2-1, 5-2-3, 5-2-4, 5-2-6, 5-3-1, 5-3-2, 5-3-4, 5-3-6, 5-4-1, 5-4-2, 5-4-3, 5-4-6, 5-6-1, 5-6-2, 5-6-3, 5-6-4, 6-1-2, 6-1-3, 6-1-4, 6-1-5, 6-2-1, 6-2-3, 6-2-4, 6-2-5, 6-3-1, 6-3-2, 6-3-4, 6-3-5, 6-4-1, 6-4-2, 6-4-3, 6-4-5, 6-5-1, 6-5-2, 6-5-3, 6-5-4.

A megszámolás programozási tétel előállítja a szükséges változókat, amik hányadosa megadja a szükséges p valószínűséget és ezt a program ki is írja a konzolra: A keresett valószínűség: 0.5555555555555556. Az esetek/lehetőségek felsorolása egyben a megoldás részletezése. A megszámoláshoz használt sokféle feltétel természetesen átfogalmazható lenne. Az egyszerűsítés többféleképpen is elvégezhető, többek között a De Morgan-azonosságok alkalmazásával.

2. megoldás

A korábbi JavaFX alapon megvalósított program módosításával könnyen állítható a megoldás grafikus/vizuális reprezentációja. Íme egy képernyőkép az elkészült program felhasználói felületéről:

A 3 db dobókockával kapott számhármasok 3D-ben, térbeli pontként jelennek meg egy kockában. A nagy piros gömbök jelölik azt a 6 db esetet, amikor mindhárom kockadobás megegyezik. Ezek a kocka egyik testálójában találhatók. A közepes narancssárga gömbök jelölik azt a 90 db lehetőséget, amikor bármely (pontosan) két kockadobás megegyezik. Végül a kis szürke gömbök jelölik a megoldást. Ez a 120 db kimaradó eset, másképpen: amikor mindhárom kockadobás különbözik. Másféle lehetőség nincs és megvan a 216 esethez tartozó összes gömb.

A megoldás implementálása a korábbi programban szinte csak egy metódus frissítését, kiegészítését igényelte. Ez a korábbi tudatos, objektumorientált, MVC szerkezetnek köszönhető és egyben a forráskód újrafelhasználása is. A createCube() metódus az alábbiak valósítja meg a feladatot:

private Node createCube() {

final int SCALE=50;

final Point3D Y_AXIS=new Point3D(0, 1, 0);

Group group=new Group();

for(int i=1; i<=6; i++)

for(int j=1; j<=6; j++)

for(int k=1; k<=6; k++) {

Point3D cp=new Point3D(i*SCALE, j*SCALE, k*SCALE);

Point3D diff=cp.subtract(cp);

Translate moveToMidpoint=new Translate(

ORIGO.getX()+cp.getX(), ORIGO.getY()+cp.getY(), cp.getZ());

Point3D axisOfRotation=diff.crossProduct(Y_AXIS);

double angle=Math.acos(diff.normalize().dotProduct(Y_AXIS));

Rotate rotateAroundCenter=

new Rotate(-Math.toDegrees(angle), axisOfRotation);

Sphere s=null;

if(i==j && j==k) {

//mindhárom kockadobás megegyezik

s=new Sphere(20);

s.setMaterial(new PhongMaterial(Color.GREEN));

}

else if((i==j && i!=k && j!=k) || (i==k && i!=j && j!=k) ||

(j==k && i!=j && i!=k)) {

//bármely két kockadobás megegyezik

s=new Sphere(15);

s.setMaterial(new PhongMaterial(Color.ORANGE));

}

else {

//mindhárom kockadobás különbözik

s=new Sphere(10);

s.setMaterial(new PhongMaterial(Color.LIGHTGREY));

}

s.getTransforms().addAll(moveToMidpoint, rotateAroundCenter);

group.getChildren().add(s);

}

return group;

}

A belépési pont, a grafikus felület építése, a nyomógombok eseménykezelése, a geometriai transzformációk, és persze a 3D -> 2D leképezés a megjelenítés során megmaradt. A virtuális térben elhelyezett objektumok változtak (pozíció, nézőpont, anyagtulajdonság). További részletes magyarázat érhető el a Kígyókocka grafikus felületen esettanulmányban.

3. megoldás

Itt most csak ötletet szeretnék mutatni. A 2022-es 6. feladat 3-7. kombinatorikai megoldásai könnyen továbbfejleszthetők és sokféle hasznos apróság gyakorolható.

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

Ajánljuk matematika érettségi feladat címkénket, mert a témában évről-évre blogolunk.

A feladat a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 5-8. óra: Vezérlési szerkezetek, 9-12. óra: Metódusok, rekurzió, valamint 17-28. óra: Objektumorientált programozás alkalmaihoz kötődik.

Beszámoló: it-tanfolyam.hu STEM nyári tábor 2023

2024. november 3.2023. július 28. Szerző: Kaczur Sándor

A STEM mozaikszó eléggé közismert: a tudományos-technológiai tudományágakat (természettudomány, technológia, mérnöki tudomány és matematika) foglalja egybe, interdiszciplináris megközelítésben. A STEM területén való elmélyedés során a hangsúly nem a mit tanulunk/tanítunk, hanem inkább a hogyan tanulunk/tanítunk. Nem azonnal ad kézzel fogható válaszokat, de kitartó próbálkozással – saját élménnyel – elérhető az eredmény.

Az it-tanfolyam.hu oktatói csapata 2023-ban először hirdetett STEM nyári tábort. Erről számolunk be röviden ebben a blog bejegyzésben. Tervezzük, hogy a jövőben rendszeresen fogunk szervezni STEM nyári tábort.

A STEM nyári tábor koncepciója

2023. nyarán 4 turnusban hirdettünk programozás fókuszú STEM nyári tábort:

1. turnus: július 3-7-ig,
2. turnus: július 10-14-ig,
3. turnus: július 17-21-ig,
4. turnus: július 24-28-ig.

Előzetes tudás- és igényfelmérést végeztünk, így alakítottunk ki 3 db csoportot, ezek: Java kezdő, Python kezdő, Python haladó. A kiinduló célcsoportot tanfolyamaink karrierváltó hallgatóinak gyermekei jelentették, akik mellé toboroztunk még. A korosztály a 16-20 éves diákok voltak a 11-14. évfolyamról. A 11-12. évfolyamosok közül sokan informatika, digitális kultúra érettségi előkészítő fakultációra jelentkeztek, jártak, járnak és ebből érettségiznek/érettségiztek. A már korábban érettségizett 13-14. évfolyamosok körülbelül fele az OKJ utód szakmajegyzékhez tartozó szakképzésben tanult.

Mindegyik turnus azonos tematikával valósult meg. Turnusonként 3 db párhuzamos, 10-12 fős csoportokat indítottunk. Voltak közös elméleti programok, szakmai kirándulás, illetve külön-külön Java és Python nyelven megvalósuló gyakorlati programok, valamint projektbemutatóra is sor került. Igyekeztünk érinteni sokféle STEM területet: fizika, kémia, biológia, csillagászat, térinformatika, mesterséges intelligencia, szimuláció, játékprogramok, matematika, orvostudomány; mindegyiket a programozáshoz kapcsolva. Végeztünk tervezést, kódolást, tesztelést is. Belefért némi pályaorientáció is.

A STEM nyári tábor órarendje

Turnusonként 4 oktató kollégával és vendégelőadókkal hétfőtől-péntekig minden nap 8 és 18 óra között biztosítottuk a jelenlétet, felügyeletet. 40 órában szakmai programokat (elmélet+gyakorlat) kínáltunk. Reggelenként és késő délutánonként 1-1 órában offline, egyéni vagy csoportos játékok voltak kipróbálhatók. Ez mindösszesen 50 órát jelentett. Délelőttönként 20, 30 és 60 perces programokat terveztünk, délutánonként 120 és 240 perceseket. Szerdára szakmai kirándulást, gyárlátogatást ütemeztünk be. Íme az órarend áttekintő formában:

Íme az órarend naponként lapozható formában, benne a részletekkel:

Hétfő

Játék1 - Offline egyéni, logikai fejtörők, ördöglakatok, logikai feladványok, kártyajátékok, társasjátékok élményszerű kipróbálása, diákok megérkezése
STEM1 - Kaczur Sándor, Kiss Balázs, Hollós Gábor, Szegedi Kristóf: A STEM tábor heti programjának ismertetése, a STEM megvalósult koncepció, a STEM bevezetése, a célok ismertetése, ILIAS megismerése
E1 - Kiss Balázs: Mi az ipar 4.0? Mi az okos gyár? Hogyan tovább: ipar 5.0?
S1 - Kaczur Sándor: Optikai csalódások, fiziológiai illúziók, kognitív illúziók, elméleti áttekintés példákon keresztül
S2 - Hollós Gábor: Sztereogramok szerkezete, készítése online eszközökkel
G1 - Szegedi Kristóf: Gondolkodjunk logikusan! - CHOO+CHOO=TRAIN
G2 - Kiss Balázs: Gondolkodjunk logikusan! - Hány éves a kapitány?
G3 - Kaczur Sándor: Gondolkodjunk logikusan! - Ki tart halat? - Einstein fejtörője - interaktív feladatmegoldás
E2 - Kiss Balázs: A szoftverfejlesztés és -tesztelés szakterületei (komolyan és mémekkel egyaránt)
Ebéd1 - Menüebéd a közeli étteremben és közös séta oda-vissza
S3 - Kaczur Sándor: Optikai csalódások programozása és tesztelése Java nyelven (Swing)
S4 - Hollós Gábor: Optikai csalódások programozása és tesztelése Python nyelven (TKinter)
S5 - Kiss Balázs: Sztereogramok programozása és tesztelése Python nyelven (TKinter)
M1 - Kiss Balázs: Matematika középszintű érettségi feladatok megoldása programozással Java nyelven
M2 - Hollós Gábor: Matematika középszintű érettségi feladatok megoldása programozással Python nyelven
NXT1 - Kaczur Sándor: Kreatív problémamegoldás robotokkal - LEGO MINDSTORMS NXT 2.0
Játék2 - Offline egyéni, logikai fejtörők, ördöglakatok, logikai feladványok, kártyajátékok és társasjátékok élményszerű kipróbálása, diákok távozása

Kedd

Játék1 - Offline egyéni, logikai fejtörők, ördöglakatok, logikai feladványok, kártyajátékok, társasjátékok élményszerű kipróbálása, diákok megérkezése
E3 - Kaczur Sándor: Algoritmus vesebeteg-donorok párosítására: lehetőségek, korlátok, hatékonyság, logisztika
S6 - Szegedi Kristóf: Gáz- és folyadékmodellek szimulációja, elméleti áttekintés példákon keresztül
S7 - Kiss Balázs: Denevérek a barlangban esettanulmány áttekintése és közös ötletelés a továbbfejlesztési lehetőségeken
S8 - Szegedi Kristóf: Hóesés szimuláció tervezése, paraméterek módosításával Python program tesztelése
Játék3 - Kiss Balázs: A World 3D játékprojekt tesztelése, különböző nehézségi szinteken, gráfbejárás algoritmusainak felfedezése
E4 - Hollós Gábor: Miért érdemes állásbörzékre járni? Miért érdemes ismerni a TIOBE, a PYPL és az IEEE Spectrum indexeit/rangsorait, valamint az Indeed és a Trendy Skills álláskereső portálokat?
E5 - Németh András, Falus Anita, Tóth-Szabó Tamás: Kezdő szoftverfejlesztők munkaerőpiaci tapasztalatai (Java tanfolyamaink alumni hallgatóinak beszámolója)
Ebéd1 - Menüebéd a közeli étteremben és közös séta oda-vissza
T1 - Kiss Balázs: Gyűjtögető robotok kommunikációjának működése, tervezése, lehetőségek áttekintése
T2 - Szegedi Kristóf: A rajintelligencia lehetőségei a robotok közötti kommunikáció testre szabása esetén
M3 - Kiss Balázs: Matematika középszintű érettségi feladatok megoldása programozással Java nyelven
M4 - Hollós Gábor: Matematika középszintű érettségi feladatok megoldása programozással Python nyelven
NXT2 - Kaczur Sándor: Kreatív problémamegoldás robotokkal - LEGO MINDSTORMS NXT 2.0 (NXT1 folytatása)
Játék2 - Offline egyéni, logikai fejtörők, ördöglakatok, logikai feladványok, kártyajátékok és társasjátékok élményszerű kipróbálása, diákok távozása

Szerda

Játék1 - Offline egyéni, logikai fejtörők, ördöglakatok, logikai feladványok, kártyajátékok, társasjátékok élményszerű kipróbálása, diákok megérkezése
E6 - Kiss Balázs: Hogyan működik a projektmenedzsment a szoftveripari gyakorlatban? Hogyan egyensúlyoz(hat)unk az idő, erőforrás, költség dimenzióiban? Milyen az optimális projekt?
S9 - Kaczur Sándor: Biológiai szimulációk működése, tervezési szempontjai, elméleti áttekintés példákon keresztül
S10 - Szegedi Kristóf: Életjáték Conway-féle szimulációja, extrém helyzetek tesztelése különböző alakú síkbeli alakzatok kitöltése során, pöttyök és csíkok tesztje, iteratív és rekurzív megoldások tesztje
S11 - Hollós Gábor: Ragadozó és zsákmány modell működése, kísérlet az optimális paraméterezésére, tesztelés ProgCont API-val
T3 - Kaczur Sándor: A mesterséges intelligenciával szembeni reális igények, elvárások, hol tartunk, milyen technológiai és etikai határok definiálhatók, ésszerűen mi várható közeljővőben
LEGO1 - Utazás autóbusszal a Budapest-Nyíregyháza útvonalon és útközben a LEGO történetéről szóló ismeretterjesztő (20 perc) és a dániai Billund városban található LEGOLAND attrakcióit bemutató (10 perc) filmek megtekintése
Ebéd2 - Szendvicsebéd az autóbuszon elfogyasztva
LEGO2 - Szakmai gyárlátogatás a LEGO Manufacturing Kft. hazai játékgyárában, gyártósor megtekintése és logisztikai folyamatok megismerése
LEGO3 - Utazás autóbusszal a Nyíregyháza-Budapest útvonalon és útközben a Végtelen határok filmsorozat A tudat folyama című epizódjának (43 perc) megtekintése és elemzése
Játék2 - Offline egyéni, logikai fejtörők, ördöglakatok, logikai feladványok, kártyajátékok és társasjátékok élményszerű kipróbálása, diákok távozása

Csütörtök

Játék1 - Offline egyéni, logikai fejtörők, ördöglakatok, logikai feladványok, kártyajátékok, társasjátékok élményszerű kipróbálása, diákok megérkezése
VR1 - Kiss-Bakos Evelin: Repülőgép-szimulátor teszt Oculus Quest 2 VR szemüvegben, egyéni küldetés teljesítése
S12 - Szegedi Kristóf: Sakkszimultán - offline és online egyaránt
T4 - Kaczur Sándor: Heurisztikus célfüggvények gráfreprezentáció esetén, általánosan használható és csak speciális feltételek esetén működő megvalósítások tesztelése Google Cloud Platformon
E7 - Hollós Gábor: Interaktív tematikus térképek paraméterezése Java nyelven OpenWeatherMap kiegészítéssel
E8 - Hollós Gábor: Interaktív tematikus térképek paraméterezése Python nyelven OpenWeatherMap kiegészítéssel
VR2 - Kiss-Bakos Evelin: NASA űrkutatás misszió teszt Oculus Quest 2 VR szemüvegben, csoportos küldetés teljesítése
Ebéd1 - Menüebéd a közeli étteremben és közös séta oda-vissza
M5 - Kiss Balázs: Matematika középszintű érettségi feladatok megoldása programozással Java nyelven Reddit és Stack Overflow használatával
M6 - Hollós Gábor: Matematika középszintű érettségi feladatok megoldása programozással Python nyelven Reddit és Stack Overflow használatával
NXT3 - Kaczur Sándor: Kreatív problémamegoldás robotokkal - LEGO MINDSTORMS NXT 2.0 GitHub integrációval (NXT2 folytatása)
P1 - Szegedi Kristóf: Java projektfeladatok bemutatásának előkészítése, értékelési szempontok áttekintése, kooperatív csoportmunkában megvalósuló prezentáció elkészítése
P2 - Kiss Balázs: Python projektfeladatok bemutatásának előkészítése, értékelési szempontok áttekintése, kooperatív csoportmunkában megvalósuló prezentáció elkészítése, kezdő és haladó csoportok munkáinak összehasonlítása
Játék2 - Offline egyéni, logikai fejtörők, ördöglakatok, logikai feladványok, kártyajátékok és társasjátékok élményszerű kipróbálása, diákok távozása

Péntek

Játék1 - Offline egyéni, logikai fejtörők, ördöglakatok, logikai feladványok, kártyajátékok, társasjátékok élményszerű kipróbálása, diákok megérkezése
G4 - Kaczur Sándor: Logikus gondolkodás teszt
E9 - Kiss Balázs: Naprendszer szimuláció tervezése, kipróbálása, tesztelése
E10 - Kaczur Sándor: Lottószelvény-generálás Java és Python nyelveken, valamint ChatGPT segítségével, a módszerek összehasonlítása és hatékonyságuk elemzése
T5 - Hollós Gábor: Az OpenAI chat (ChatGPT) felépítése, működése (áttekintés UML-ben), használati útmutató és tesztelése
T6 - Kiss Balázs: Az OpenAI képgeneráló felépítése, működése, használati útmutató és tesztelése
P3 - Szegedi Kristóf: Java projektfeladatok bemutatásának előkészítése, kooperatív csoportmunkában megvalósuló prezentáció elkészítése (P1 folytatása)
P4 - Kiss Balázs: Python projektfeladatok bemutatásának előkészítése, kooperatív csoportmunkában megvalósuló prezentáció elkészítése, kezdő és haladó csoportok munkájának összehasonlítása (P2 folytatása)
STEM2 - Kaczur Sándor, Kiss Balázs, Hollós Gábor, Szegedi Kristóf: A STEM nyári tábor heti programjának összefoglalója, várható fejlődés, a STEM jövőbeli koncepciója, elért és távlati céljainak ismertetése
Ebéd1 - Menüebéd a közeli étteremben és közös séta oda-vissza
P5 - Szegedi Kristóf, Kiss Balázs: Java és Python projektfeladatok prezentációja (P3 és P4 folytatása), megvitatása, közös értékelése, nyílt program szülőknek, meghívott barátoknak, vendégeknek, kooperatív csoportmunka lezárása, oklevelek kiosztása, visszajelzések összegyűjtése, prezentációk, projektmunkák és fényképek archiválása ILIAS-on, beszámoló elkészítése
Játék2 - Offline egyéni, logikai fejtörők, ördöglakatok, logikai feladványok, kártyajátékok, társasjátékok élményszerű kipróbálása és diákok távozása

Előzetes tapasztalataink

Előzetes tapasztalatainkat több forrásból merítettük, inspirálódtunk:

a GINOP-3.1.1-VEKOP-15-2016-00001 projektben való részvétel során, beszámoló: Programozd a jövőd! – IT a jövőd (2016-2023)
a STE(A)M Platform pályázatban (Towards a European STE(A)M Platfom, EACEA/36/2018) való közreműködés során (2020-2022),
számtalan digitális pedagógus továbbképzésből, például amiről írtunk a szakmai blogban: LEGO Education módszertani képzés / Robotika Mindstorms EV3 robottal
a 2020/2021-es tanévben szervezett Python tanfolyamunk tervezése és megvalósítása során, amiről beszámoltunk a Multimédia az oktatásban 2021 konferencián szakmai előadás és szakmai cikk formájában,
tanfolyamaink tananyagaihoz tartozó esettanulmányaink, a nyári táborhoz főként a Java SE szoftverfejlesztő tanfolyam tematikájához kötődve, szakmai és orientáló moduljaihoz egyaránt.

Köszönetnyilvánítás

Köszönjük résztvevő diákjainknak az aktivitást, a lelkesedést, a sok-sok elgondolkodtató kérdést, az offline kapott/szerzett élményeket, a pozitív visszajelzéseket.

Szeretnék köszönetet mondani együttműködő partnereinknek: LEGO Manufacturing Kft., REGIO Játékkereskedelmi Kft., Revolt Kereskedelmi Kft., Pannon Kincstár Humán Szakképző Központ.

Végül szeretnék köszönetet mondani minden oktató kollégámnak konstruktív részvételüként, kitartásukért a projekt teljes életciklusában. A tervezési, a szponzorszerző, a promóciós és a megvalósítási szakaszokban egyaránt 2023. április elejétől július végéig. Kiemelem korábbi és az aktuális projekthez kötődő tananyagfejlesztési tevékenységüket. A sikeresen lezárt projektünket augusztusban kipihenjük. 😉

Egy matematika érettségi feladat megoldása programozással 2023

2023. május 12.2023. május 9. Szerző: Kaczur Sándor

A 2023-as középszintű matematika érettségi feladatsorból az 5. feladat alkalmasnak bizonyult arra, hogy a programozás eszköztárával oldjuk meg. Rögtön többféleképpen is, hogy összehasonlíthatóak legyenek egymással. Érdekes belegondolni, hogy mennyire más lehetne a problémamegoldás, ha programozhatnánk a matematika érettségi vizsgán. A teljes feladatsor letölthető az oktatas.hu-ról.

5. feladat

Adja meg a 420 és az 504 legnagyobb közös osztóját! Megoldását részletezze!

Íme kulcsszavakban, mit érdemes átgondolni a megoldás előtt: számelmélet alaptétele, prímfelbontás (prímtényezős felbontás, faktorizáció), osztópár, prímek szorzata, prímtényezők szorzata, kanonikus alak, euklideszi algoritmus.

1. megoldás

private void lnko1(int aa, int bb) {

if(aa>0 && bb>0) {

int a=Math.max(aa, bb), b=Math.min(aa, bb), m=a%b;

while(m!=0) {

//System.out.println(a+" = "+a/b+" * "+b+" + "+m);

a=b;

b=m;

m=a%b;

}

//System.out.println(a+" = "+a/b+" * "+b+" + "+m);

int lnko=b;

System.out.println("lnko ("+aa+"; "+bb+") = "+lnko);

}

else

System.out.println("Mindkét számnak pozitívnak kell lennie!");

}

Az első megoldás az euklideszi algoritmus alkalmazása. A metódus paraméterezhető. Pozitív paramétereket vár és képes kiírni a konzolra a két szám legnagyobb közös osztóját. A módszer alapötlete: a legnagyobb közös osztó nem változik, ha a nagyobb számot a két szám különbségével helyettesítjük. Ezzel csökken a nagyobb szám, így a cserék ismétlésével egyre kisebb számokat kapunk, amíg a két szám egyenlővé nem válik. Ez az eddigi számpároknak, így az eredeti számpárnak is a legnagyobb közös osztója. Az eredményt az utolsó nem nulla maradék while(m!=0) adja meg int lnko=b;. Az algoritmus lépésszáma csökkenthető, ha a>b, de ennek ellenőrzése nélkül is működik. Mivel a feladat kéri a megoldás részletezését, így aktiválva a megjegyzésbe tett forráskódokat, a kiírásból könnyen érthető, mi és hogyan történik:

504 = 1 * 420 + 84

420 = 5 * 84 + 0

lnko (420; 504) = 84

A konkrét esetben a metódus eredménye: lnko (420; 504) = 84. Nagyobb számok esetében „beszédesebb” a program kiírása, több lépésben írja ki a megoldáshoz vezető utat, ezért érdemes többféle paraméterrel is tesztelni a metódust.

2. megoldás

private List<Integer> primtenyezok(int n) {

List<Integer> primtenyezokLista=new ArrayList<>();

if(n>0)

for(int i=2; i<=n; i++)

while(n%i==0) {

//System.out.printf("%5d | %d\n", n, i);

primtenyezokLista.add(i);

n/=i;

}

//System.out.printf("%5d | \n", n);

return primtenyezokLista;

}

private String primtenyezokSzorzatkent(

List<Integer> primtenyezok) {

return primtenyezok.stream().map(i->i.toString()).

collect(Collectors.joining(" * "));

}

private void lnko2(int a, int b) {

if(a>0 && b>0) {

List<Integer> aPrimtenyezok=primtenyezok(a);

//System.out.println(a+" = "+

// primtenyezokSzorzatkent(aPrimtenyezok));

List<Integer> bPrimtenyezok=primTenyezok(b);

//System.out.println(b+" = "+

// primtenyezokSzorzatkent(bPrimtenyezok));

List<Integer> kozosPrimtenyezok=new ArrayList<>();

aPrimtenyezok.stream().distinct().forEach((prim)->{

long aPrimDb=aPrimtenyezok.stream().filter(p->p==prim).count();

long bPrimDb=bPrimtenyezok.stream().filter(p->p==prim).count();

long minEgyediPrimDb=Math.min(aPrimDb, bPrimDb);

if(minEgyediPrimDb>0)

for(int i=1; i<=minEgyediPrimDb; i++)

kozosPrimtenyezok.add(prim);

});

int lnko=kozosPrimtenyezok.stream().reduce(1, (p1, p2)->p1*p2);

System.out.println("lnko ("+a+"; "+b+") = "+

/*primtenyezokSzorzatkent(kozosPrimtenyezok)+" = "+*/lnko);

}

else

System.out.println("Mindkét számnak pozitívnak kell lennie!");

}

A második megoldás a prímtényezős felbontásokon alapul. Mindkét szám esetén gyűjtsük össze listában ezeket, majd vegyük a két lista közös részét. (Ha lista helyett halmazok lennének, akkor metszet programozási tétel lenne.) A generikus listákba prímszámok kerülnek és bármelyik többször is előfordulhat. (Ezért most a leghosszabb közös részsorozat(ok) előállítása szükséges.) Addig osztjuk a számot 2-vel, amíg lehet, utána következik a többi prímosztó, amíg vannak. Érdemes több metódusra szétosztani a megoldást, mert jóval áttekinthetőbb és karbantarthatóbb Java forráskódot eredményez. A beszédes változó, objektum és metódusnevek is segítenek a megértésben. A második megoldás természetesen ugyanazt az eredményt adja, mint az első megoldás. Aktiválva a megjegyzésbe tett forráskódokat, a kiírásból most is könnyen érthetővé válik (középiskolás matematikaóra-szerűen), mi és hogyan történik:

420 | 2

210 | 2

105 | 3

35 | 5

7 | 7

1 |

420 = 2 * 2 * 3 * 5 * 7

504 | 2

252 | 2

126 | 2

63 | 3

21 | 3

7 | 7

1 |

504 = 2 * 2 * 2 * 3 * 3 * 7

lnko (420; 504) = 2 * 2 * 3 * 7 = 84

Kanonikus alakban: 420 = 2² * 3 * 5 * 7, 504 = 2³ * 3² * 7, így lnko (420; 504) = 2² * 3 * 7. Azaz összeszorozzuk a közös prímtényezőket az előforduló legkisebb hatványon.
A megoldás erősen épít a generikus kollekciók esetén jól használható Stream API lambda kifejezéseire. Ezeket most nem részletezem, helyette ajánlom a szakmai blogból a lambda kifejezés címkét.

Érdemes átgondolni

Nagy prímszámok esetén az euklideszi algoritmus nem hatékony. Az algoritmus végrehajtása kifejezetten lassú például a Fibonacci-számok esetén. A prímtényezőkre bontás feltételezett bonyolultságát számos kriptográfiai algoritmus használja ki. Vannak különleges esetek is, például: egyforma számok, az egyik szám 1, a két szám egymás többszöröse.
A feladat nem kérte a legkisebb közös többszörös meghatározását, de ha tudjuk a lnko(a, b)-t, akkor abból könnyen adódik a lkkt(a, b)=a*b/lnko(a, b).
A legnagyobb közös osztó tulajdonságait megismerve az euklideszi algoritmus könnyen optimalizálható. Számos esetben ellenőrzést végezhetünk, illetve triviális alapesetek is vannak. Létezik kiterjesztett euklideszi algoritmus is.

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

Ajánljuk matematika érettségi feladat címkénket, mert a témában évről-évre blogolunk.

Egy matematika érettségi feladat megoldása programozással 2022

2023. augusztus 4.2022. május 3. Szerző: Kaczur Sándor

A 2022-es középszintű matematika érettségi feladatsor eléggé egyszerű volt, de azért a 6. feladata inspirált arra, hogy a programozás eszköztárával oldjuk meg ezt a feladatot. Szükséges hozzá a megszámolás programozási tétel. Többféle megoldás/megközelítés (iteratív és rekurzív) is előkerül. Érdekes belegondolni, hogy mennyire más lehetne a problémamegoldás, ha programozhatnánk a matematika érettségi vizsgán. A teljes feladatsor a megoldásokkal együtt letölthető az oktatas.hu-ról.

6. feladat

Egy feleletválasztós teszt 5 kérdésből áll, minden kérdésnél négy válaszlehetőség van. Hányféleképpen lehet az 5 kérdésből álló tesztet kitölteni, ha minden kérdésnél egy választ kell megjelölni?

1. megoldás

static void feladat6Megoldas1() {

System.out.println((int)Math.pow(4, 5));

}

Rögtön tudjuk, hogy ez kombinatorika, n elem k-ad osztályú ismétléses variációja, amelynek paraméterei: n=4, k=5. A hatványozás azonosságainak ismeretében fejből is tudjuk a megoldást: 4⁵=2¹⁰=1024. A Java forráskód elvégzi a hatványozást. A Math.pow() függvény általánosabb, mint amire most szükségünk van. Fogad double valós paramétereket és double típusú értékkel tér vissza. Ezért hasznos az (int) explicit típuskényszerítés.

Másképpen: négy elemű halmazból öt elemet kiválasztunk és ezeket sorba rendezzük (permutáljuk) és egy elemet egy csoportban akár ötször is felhasználhatunk. Számít a sorrend. A lehetséges variációk száma: 1024.

2. megoldás

static int ismetlesesVariacio(int n, int k) {

return (int)(Math.pow(n, k));

}

static void feladat6Megoldas2() {

System.out.println(ismetlesesVariacio(4, 5));

}

Ha hasznos lenne egy általános metódus az ismétléses variáció kiszámítására, akkor ez egy tipikus megoldás lehet erre. Kiegészítendő még a két paraméter előjelének ellenőrzésével.

3. megoldás

static void feladat6Megoldas3() {

for(char k1='a'; k1<='d'; k1++)

for(char k2='a'; k2<='d'; k2++)

for(char k3='a'; k3<='d'; k3++)

for(char k4='a'; k4<='d'; k4++)

for(char k5='a'; k5<='d'; k5++)

System.out.print(""+k1+k2+k3+k4+k5+" ");

System.out.println();

}

Ha a megértést segíti, akkor a teljes leszámolás (brute force) módszerével, egymásba ágyazott ciklusokkal könnyen kiírathatjuk a konzolra az 1024 db különböző válaszlehetőséget. A k-val kezdődő sorszámozott ciklusváltozók jelölik az öt kérdést, azon belül az 'a'-tól 'd'-ig karakterek adják a válaszlehetőségeket. Eredményül ezt kapjuk (görgethető):

100

101

102

103

aaaaa aaaab aaaac aaaad aaaba aaabb aaabc aaabd aaaca aaacb

aaacc aaacd aaada aaadb aaadc aaadd aabaa aabab aabac aabad

aabba aabbb aabbc aabbd aabca aabcb aabcc aabcd aabda aabdb

aabdc aabdd aacaa aacab aacac aacad aacba aacbb aacbc aacbd

aacca aaccb aaccc aaccd aacda aacdb aacdc aacdd aadaa aadab

aadac aadad aadba aadbb aadbc aadbd aadca aadcb aadcc aadcd

aadda aaddb aaddc aaddd abaaa abaab abaac abaad ababa ababb

ababc ababd abaca abacb abacc abacd abada abadb abadc abadd

abbaa abbab abbac abbad abbba abbbb abbbc abbbd abbca abbcb

abbcc abbcd abbda abbdb abbdc abbdd abcaa abcab abcac abcad

abcba abcbb abcbc abcbd abcca abccb abccc abccd abcda abcdb

abcdc abcdd abdaa abdab abdac abdad abdba abdbb abdbc abdbd

abdca abdcb abdcc abdcd abdda abddb abddc abddd acaaa acaab

acaac acaad acaba acabb acabc acabd acaca acacb acacc acacd

acada acadb acadc acadd acbaa acbab acbac acbad acbba acbbb

acbbc acbbd acbca acbcb acbcc acbcd acbda acbdb acbdc acbdd

accaa accab accac accad accba accbb accbc accbd accca acccb

acccc acccd accda accdb accdc accdd acdaa acdab acdac acdad

acdba acdbb acdbc acdbd acdca acdcb acdcc acdcd acdda acddb

acddc acddd adaaa adaab adaac adaad adaba adabb adabc adabd

adaca adacb adacc adacd adada adadb adadc adadd adbaa adbab

adbac adbad adbba adbbb adbbc adbbd adbca adbcb adbcc adbcd

adbda adbdb adbdc adbdd adcaa adcab adcac adcad adcba adcbb

adcbc adcbd adcca adccb adccc adccd adcda adcdb adcdc adcdd

addaa addab addac addad addba addbb addbc addbd addca addcb

addcc addcd addda adddb adddc adddd baaaa baaab baaac baaad

baaba baabb baabc baabd baaca baacb baacc baacd baada baadb

baadc baadd babaa babab babac babad babba babbb babbc babbd

babca babcb babcc babcd babda babdb babdc babdd bacaa bacab

bacac bacad bacba bacbb bacbc bacbd bacca baccb baccc baccd

bacda bacdb bacdc bacdd badaa badab badac badad badba badbb

badbc badbd badca badcb badcc badcd badda baddb baddc baddd

bbaaa bbaab bbaac bbaad bbaba bbabb bbabc bbabd bbaca bbacb

bbacc bbacd bbada bbadb bbadc bbadd bbbaa bbbab bbbac bbbad

bbbba bbbbb bbbbc bbbbd bbbca bbbcb bbbcc bbbcd bbbda bbbdb

bbbdc bbbdd bbcaa bbcab bbcac bbcad bbcba bbcbb bbcbc bbcbd

bbcca bbccb bbccc bbccd bbcda bbcdb bbcdc bbcdd bbdaa bbdab

bbdac bbdad bbdba bbdbb bbdbc bbdbd bbdca bbdcb bbdcc bbdcd

bbdda bbddb bbddc bbddd bcaaa bcaab bcaac bcaad bcaba bcabb

bcabc bcabd bcaca bcacb bcacc bcacd bcada bcadb bcadc bcadd

bcbaa bcbab bcbac bcbad bcbba bcbbb bcbbc bcbbd bcbca bcbcb

bcbcc bcbcd bcbda bcbdb bcbdc bcbdd bccaa bccab bccac bccad

bccba bccbb bccbc bccbd bccca bcccb bcccc bcccd bccda bccdb

bccdc bccdd bcdaa bcdab bcdac bcdad bcdba bcdbb bcdbc bcdbd

bcdca bcdcb bcdcc bcdcd bcdda bcddb bcddc bcddd bdaaa bdaab

bdaac bdaad bdaba bdabb bdabc bdabd bdaca bdacb bdacc bdacd

bdada bdadb bdadc bdadd bdbaa bdbab bdbac bdbad bdbba bdbbb

bdbbc bdbbd bdbca bdbcb bdbcc bdbcd bdbda bdbdb bdbdc bdbdd

bdcaa bdcab bdcac bdcad bdcba bdcbb bdcbc bdcbd bdcca bdccb

bdccc bdccd bdcda bdcdb bdcdc bdcdd bddaa bddab bddac bddad

bddba bddbb bddbc bddbd bddca bddcb bddcc bddcd bddda bdddb

bdddc bdddd caaaa caaab caaac caaad caaba caabb caabc caabd

caaca caacb caacc caacd caada caadb caadc caadd cabaa cabab

cabac cabad cabba cabbb cabbc cabbd cabca cabcb cabcc cabcd

cabda cabdb cabdc cabdd cacaa cacab cacac cacad cacba cacbb

cacbc cacbd cacca caccb caccc caccd cacda cacdb cacdc cacdd

cadaa cadab cadac cadad cadba cadbb cadbc cadbd cadca cadcb

cadcc cadcd cadda caddb caddc caddd cbaaa cbaab cbaac cbaad

cbaba cbabb cbabc cbabd cbaca cbacb cbacc cbacd cbada cbadb

cbadc cbadd cbbaa cbbab cbbac cbbad cbbba cbbbb cbbbc cbbbd

cbbca cbbcb cbbcc cbbcd cbbda cbbdb cbbdc cbbdd cbcaa cbcab

cbcac cbcad cbcba cbcbb cbcbc cbcbd cbcca cbccb cbccc cbccd

cbcda cbcdb cbcdc cbcdd cbdaa cbdab cbdac cbdad cbdba cbdbb

cbdbc cbdbd cbdca cbdcb cbdcc cbdcd cbdda cbddb cbddc cbddd

ccaaa ccaab ccaac ccaad ccaba ccabb ccabc ccabd ccaca ccacb

ccacc ccacd ccada ccadb ccadc ccadd ccbaa ccbab ccbac ccbad

ccbba ccbbb ccbbc ccbbd ccbca ccbcb ccbcc ccbcd ccbda ccbdb

ccbdc ccbdd cccaa cccab cccac cccad cccba cccbb cccbc cccbd

cccca ccccb ccccc ccccd cccda cccdb cccdc cccdd ccdaa ccdab

ccdac ccdad ccdba ccdbb ccdbc ccdbd ccdca ccdcb ccdcc ccdcd

ccdda ccddb ccddc ccddd cdaaa cdaab cdaac cdaad cdaba cdabb

cdabc cdabd cdaca cdacb cdacc cdacd cdada cdadb cdadc cdadd

cdbaa cdbab cdbac cdbad cdbba cdbbb cdbbc cdbbd cdbca cdbcb

cdbcc cdbcd cdbda cdbdb cdbdc cdbdd cdcaa cdcab cdcac cdcad

cdcba cdcbb cdcbc cdcbd cdcca cdccb cdccc cdccd cdcda cdcdb

cdcdc cdcdd cddaa cddab cddac cddad cddba cddbb cddbc cddbd

cddca cddcb cddcc cddcd cddda cdddb cdddc cdddd daaaa daaab

daaac daaad daaba daabb daabc daabd daaca daacb daacc daacd

daada daadb daadc daadd dabaa dabab dabac dabad dabba dabbb

dabbc dabbd dabca dabcb dabcc dabcd dabda dabdb dabdc dabdd

dacaa dacab dacac dacad dacba dacbb dacbc dacbd dacca daccb

daccc daccd dacda dacdb dacdc dacdd dadaa dadab dadac dadad

dadba dadbb dadbc dadbd dadca dadcb dadcc dadcd dadda daddb

daddc daddd dbaaa dbaab dbaac dbaad dbaba dbabb dbabc dbabd

dbaca dbacb dbacc dbacd dbada dbadb dbadc dbadd dbbaa dbbab

dbbac dbbad dbbba dbbbb dbbbc dbbbd dbbca dbbcb dbbcc dbbcd

dbbda dbbdb dbbdc dbbdd dbcaa dbcab dbcac dbcad dbcba dbcbb

dbcbc dbcbd dbcca dbccb dbccc dbccd dbcda dbcdb dbcdc dbcdd

dbdaa dbdab dbdac dbdad dbdba dbdbb dbdbc dbdbd dbdca dbdcb

dbdcc dbdcd dbdda dbddb dbddc dbddd dcaaa dcaab dcaac dcaad

dcaba dcabb dcabc dcabd dcaca dcacb dcacc dcacd dcada dcadb

dcadc dcadd dcbaa dcbab dcbac dcbad dcbba dcbbb dcbbc dcbbd

dcbca dcbcb dcbcc dcbcd dcbda dcbdb dcbdc dcbdd dccaa dccab

dccac dccad dccba dccbb dccbc dccbd dccca dcccb dcccc dcccd

dccda dccdb dccdc dccdd dcdaa dcdab dcdac dcdad dcdba dcdbb

dcdbc dcdbd dcdca dcdcb dcdcc dcdcd dcdda dcddb dcddc dcddd

ddaaa ddaab ddaac ddaad ddaba ddabb ddabc ddabd ddaca ddacb

ddacc ddacd ddada ddadb ddadc ddadd ddbaa ddbab ddbac ddbad

ddbba ddbbb ddbbc ddbbd ddbca ddbcb ddbcc ddbcd ddbda ddbdb

ddbdc ddbdd ddcaa ddcab ddcac ddcad ddcba ddcbb ddcbc ddcbd

ddcca ddccb ddccc ddccd ddcda ddcdb ddcdc ddcdd dddaa dddab

dddac dddad dddba dddbb dddbc dddbd dddca dddcb dddcc dddcd

dddda ddddb ddddc ddddd

4. megoldás

static void feladat6Megoldas4() {

int db=0;

for(char k1='a'; k1<='d'; k1++)

for(char k2='a'; k2<='d'; k2++)

for(char k3='a'; k3<='d'; k3++)

for(char k4='a'; k4<='d'; k4++)

for(char k5='a'; k5<='d'; k5++)

db++;

System.out.println(db);

}

Ha csak a végeredmény szükséges, akkor ez az iteratív megoldás a megszámolás programozási tétellel előállítja azt.

5. megoldás

static void feladat6Megoldas5(String valasz) {

if(valasz.length()==5)

System.out.print(valasz+" ");

else

for(char v='a'; v<='d'; v++)

feladat6Megoldas5(valasz+v);

}

Ez egy rekurzív megoldás. Ciklus helyett a metódus önmagát hívja meg, így valósul meg az ismételt utasításvégrehajtás. A válaszlehetőségek összefűzésével (konkatenáció) előállított válasz akkor megfelelő, ha annak hossza öt. Ez esetben kiíródik a válaszlehetőség a konzolra (mintegy mellékhatásként). Ugyanazt az eredményt kapjuk, mint a 3. megoldásnál.

6. megoldás

static int db=0;

//...

static void feladat6Megoldas6(String valasz) {

if(valasz.length()==5)

db++;

else

for(char v='a'; v<='d'; v++)

feladat6Megoldas6(valasz+v);

}

//...

public static void main(String[] args) {

feladat6Megoldas6("");

System.out.println(db);

}

Szintén, ha csak a végeredmény szükséges, akkor ez a mellékhatással rendelkező rekurzív metódus előállítja azt. A mellékhatás most az, hogy a metódus eljárás és nem függvény és szükséges hozzá a db osztályváltozó (ami a metódushoz képest globálisnak is tekinthető).

7. megoldás

static void feladat6Megoldas7() {

int n=4, k=5, nadk=(int)Math.pow(n, k);

int[][] y=new int[nadk][1];

for(int i=0; i<=nadk-1; i++) {

int m=i;

int[] x=new int[k+1];

for(int j=1; j<=k; j++) {

x[j]=m%n;

m/=n;

}

y[i]=x;

}

for(int i=0; i<nadk; i++) {

for(int j=k; j>=1; j--)

System.out.print((char)(97+y[i][j]));

System.out.print(" ");

}

Ez a megoldás a válaszlehetőségeket megfelelteti n alapú számrendszerben k számjegyből álló számoknak. A kétdimenziós tömbben számokat tárol, így:

1,…,1,1 → 0…0000
1,…,1,2 → 0…0001
1,…,1,n → 0…001(n–1)
…
1,…,2,n → 0…001(n–1)
n,…,n,n → (n–1)...(n–1)

Végül a kiíró ciklus ezeket a számokat karakterekké alakítja ( 'a' ASCII kódja 97) és fordított sorrendben írja ki, hogy ugyanazt az eredményt kapjuk, mint a 3. megoldásnál.

Továbbfejlesztési lehetőségek

A 2. megoldáshoz: teszteljük le a lehetséges túlcsordulást és az int típus helyett szükség esetén használjunk long típust!
A 3. megoldáshoz: építsünk kétdimenziós tömb adatszerkezetet, amiből később az i-edik válaszlehetőség megadható!
Előzőhöz: állítsuk elő lexikografikus sorrendben az i-edik válaszlehetőséget adatszerkezet felépítése nélkül!
A 6. megoldáshoz: valósítsuk meg a rekurzív gondolatmenetet mellékhatás nélkül!
Teszteljünk: mennyi idő alatt hajtódik végre a 4. és a 6. megoldás? Mekkora paraméterekkel érzékelhető, hogy a rekurzió jóval lassabban fut?
A 7. megoldáshoz: cseréljük le az egésztömb adatszerkezetet karaktertömbre!

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

Ajánljuk matematika érettségi feladat címkénket, mert a témában évről-évre blogolunk.

A feladat a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 5-8. óra: Vezérlési szerkezetek, valamint 21-24. óra: Objektumorientált programozás 1. rész alkalmaihoz kötődik.