érettségi feladat - címke

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

2023. augusztus 5.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.

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.

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.

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

2023. augusztus 4.2021. május 4. Szerző: Kaczur Sándor

A 2021-es középszintű matematika érettségi feladatsor 12. feladata inspirált arra, hogy a programozás eszköztárával oldjuk meg ezt a feladatot. Szükséges hozzá néhány programozási tétel: sorozatszámítás, eldöntés, megszámolás, kiválogatás. Többféle megoldás/megközelítés 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.

12. feladat

A háromjegyű pozitív egész számok közül véletlenszerűen kiválasztunk egyet. Mennyi annak a valószínűsége, hogy a kiválasztott szám számjegyei különbözők? Megoldását részletezze!

1. megoldás

static void feladat12Megoldas1() {

int db=0;

for(int szazas=1; szazas<=9; szazas++)

for(int tizes=0; tizes<=9; tizes++)

for(int egyes=0; egyes<=9; egyes++)

if(szazas!=tizes && tizes!=egyes && szazas!=egyes)

db++;

System.out.println("1. megoldás: "+db/900.0);

}

Az 1. megoldás egymásba ágyazott ciklusokkal behelyettesíti a szóba jöhető 900 db háromjegyű szám számjegyeit. A feltétel 648 esetben teljesül. Három számjegy azonosságát két részfeltétel és kapcsolatával eldönthetnénk a trichotómia miatt. Három számjegy különbözőségéhez három részfeltétel és kapcsolatából áll össze a feltétel. A válasz a kedvező és összes eset aránya/hányadosa, azaz 0,72. Másképpen 648 db szám a 900 db háromjegyű szám közül. A megoldás lépésszáma 900.

2. megoldás

static void feladat12Megoldas2() {

int db=0;

for(int szazas=1; szazas<=9; szazas++)

for(int tizes=0; tizes<=9; tizes++)

if(szazas!=tizes)

for(int egyes=0; egyes<=9; egyes++)

if(tizes!=egyes && szazas!=egyes)

db++;

System.out.println("2. megoldás: "+db/900.0);

}

Az egymásba ágyazott ciklusok lépésszáma összeszorzódik. A legbelső ciklus az előtte lévő feltételtől függően kevesebbszer is végrehajtódhat, hiszen a százas és tízes helyiértéken lévő számjegyek egyezése esetén nincs értelme az egyes helyiértéken lévő számjegy vizsgálatának. Így a 2. megoldás lépésszáma 810, azaz 10%-kal kevesebb. Ez a három részből álló feltétel két részre bontásával érhető el.

3. megoldás

static void feladat12Megoldas3() {

int db=0;

for(int i=100; i<=999; i++) {

int szazas=i/100;

int tizes=i%100/10;

int egyes=i%100%10;

if(szazas!=tizes && tizes!=egyes && szazas!=egyes)

db++;

}

System.out.println("3. megoldás: "+db/900.0);

}

A 3. megoldásban egyetlen ciklus végzi a vizsgálatot, a megszámolást. A ciklusváltozó már nem számjegy, hanem maga a háromjegyű szám, amiről döntést kell hozni: különbözik-e mindegyik számjegye vagy sem. Három beszédes nevű segédváltozó segít értelmezni a Java forráskódot. Ezek az egész osztás és a maradékos osztás műveleteivel állíthatók elő.

4. megoldás

static boolean kulonbozoSzamjegyek(int i) {

int szazas=i/100;

int tizes=i%100/10;

if(szazas==tizes)

return false;

int egyes=i%100%10;

if(tizes==egyes || szazas==egyes)

return false;

return true;

}

static void feladat12Megoldas4() {

int db=0;

for(int i=100; i<=999; i++)

if(kulonbozoSzamjegyek(i))

db++;

System.out.println("4. megoldás: "+db/900.0);

}

A 4. megoldás logikai visszatérési értékű segédfüggvényt alkalmaz. Ez egy menekülőutas megoldás. Ha kizáró feltétel szerint már döntést tudunk hozni (például megegyezik a százas és a tízes helyiértéken lévő számjegy), akkor hamis értékkel menekülünk. Egyébként ág nélkül ezután következhet az egyes helyiértéken lévő számjegy összehasonlítása a többivel. A második feltétel az eddigiekhez képest tagadott, mert a menekülés a cél. Ha nincs menekülés amiatt, hogy volt két megegyező számjegy, akkor – a feltételek egymásra épülése miatt – nincs más hátra, mint igaz értékkel visszatérni (ami azt jelenti, hogy nem volt egyezés, azaz minden számjegy különbözött).

5. megoldás

static long kulonbozoSzamjegyDb(int i) {

return IntStream.of(i/100, i%100/10, i%100%10).distinct().count();

}

static void feladat12Megoldas5() {

int db=0;

for(int i=100; i<=999; i++)

if(kulonbozoSzamjegyDb(i)==3)

db++;

System.out.println("5. megoldás: "+db/900.0);

}

Az 5. megoldás segédfüggvénye a háromjegyű szám esetén a különböző számjegyek darabszámával tér vissza. A röptében előállított százaz, tízes, egyes helyiértékeken lévő számjegyekből folyam adatszerkezet készül, aminek feldolgozását a Stream API műveletei (egyediesítő, megszámoló) végzik el. Ezt a vezérlő ciklusban hárommal összehasonlítva léptethető a megszámolást megvalósító változó, hiszen ha teljesül a feltétel, akkor eggyel több megfelelő szám van, mint előtte volt.

6. megoldás

static void feladat12Megoldas6() {

int db=0;

for(int i=100; i<=999; i++) {

int szazas=i/100;

int tizes=i%100/10;

int egyes=i%100%10;

if(szazas==tizes || tizes==egyes || szazas==egyes)

db++;

}

System.out.println("6. megoldás: "+(900-db)/900.0);

}

Az 6. megoldás újra másképpen közelít. Ha könnyebbnek tűnik az a feltétel, hogy mikor nem jó (kedvezőtlen) nekünk egy szám, akkor beépíthetjük ezt is. Megszámoljuk azokat a háromjegyű számokat, amelyeknél egy vagy két számjegy azonos, majd ez kivonjuk a háromjegyű számok darabszámából.

7. megoldás

static void feladat12Megoldas7() {

long db=IntStream.range(100, 1000).

filter(i -> IntStream.of(i/100, i%100/10, i%100%10).

distinct().count()==3).count();

System.out.println("7. megoldás: "+db/900.0);

}

A 7. megoldás már mindent folyamokkal old meg, azok képességeire építve. Az összes háromjegyű számot előállítja, majd rajtuk kiválogatás programozási tételt (szűrőt) használ (az 5. megoldás segédfüggvényére építve), végül a folyamban maradó számokat megszámolja. Ez a megoldás már olyan haladóknak való, akik magabiztosan építik össze a Stream API műveleteit és a lambda kifejezéseket. Mindent egyben. Persze hol itt a hatékonyság? Hozzászólásokban megbeszélhetjük.

8. megoldás

static void feladat12Megoldas8() {

long db=IntStream.range(100, 1000).

filter(i -> !(i/100==i%100/10 && i%100/10==i%100%10)). //1. szűrő

filter(i -> !(i/100==i%100/10)). //2. szűrő

filter(i -> !(i%100/10==i%100%10)). //3. szűrő

filter(i -> !(i/100==i%100%10)). //4. szűrő

count();

System.out.println("8. megoldás: "+db/900.0);

}

A 8. megoldás szintén folyam adatszerkezettel működik, de négy egymást követő lépésben végez szűrést (kiválogatást). A 900 db háromjegyű számból indulunk ki. Az 1. szűrő kihagyja a 9 db AAA számot, amelyek számjegyei azonosak és így marad utána 891 db szám. A 2. szűrő után marad 810 db szám, mert kimarad az a 81 db AAB alakú szám (ahol a százas és tízes helyiértéken lévő számjegyek megegyeznek) az összesen 90 db-ból, ami még a folyamban maradt az 1. szűrő után. A 3. szűrő kihagy 81 db ABB alakú számot és meghagy 729 db számot. A 4. szűrő kihagy 80 db ABA alakú számot és meghagy 648 db ABC alakú számot.

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, 13-16. óra: Tömbök, valamint 21-24. óra: Objektumorientált programozás, 2. és 3. rész alkalmaihoz kötődik.

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

2023. január 3.2020. május 6. Szerző: Kaczur Sándor

A 2020-as emelt szintű matematika érettségi feladatsor 9. feladata inspirált arra, hogy a programozás eszköztárával oldjuk meg ezt a feladatot. Szükséges hozzá kollekció adatszerkezet és néhány programozási tétel. É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.

2018-ban és 2019-ben is kiválasztottam egy-egy matematika érettségi feladatot a középszintű feladatlapról és megoldottam Java nyelven. 2020-ban az emelt szintű feladatsornál lelkesedtem eléggé, hogy blogoljak róla.

9. feladat

Egy városban a közösségi közlekedést kizárólag vonaljeggyel lehet igénybe venni, minden utazáshoz egy vonaljegyet kell váltani. A vonaljegy ára jelenleg 300 tallér. Az utazások száma naponta átlagosan 100 ezer. Ismert az is, hogy ennek kb. 10%-ában nem váltanak jegyet (bliccelnek).
A városi közlekedési társaság vezetői hatástanulmányt készíttettek a vonaljegy árának esetleges megváltoztatásáról. A vonaljegy árát 5 talléronként lehet emelni vagy csökkenteni. A hatástanulmány szerint a vonaljegy árának 5 talléros emelése várhatóan 1000-rel csökkenti a napi utazások számát, és 1 százalékponttal növeli a jegy nélküli utazások (bliccelések) arányát. (Tehát például 310 talléros jegyár esetén naponta 98000 utazás lenne, és ennek 12%-a lenne bliccelés.) Ugyanez fordítva is igaz: a vonaljegy árának minden 5 talléros csökkentése 1000-rel növelné a napi utazások számát, és 1 százalékponttal csökkentené a bliccelések arányát. A tanulmány az alkalmazott modellben csak a 245 tallérnál drágább, de 455 tallérnál olcsóbb lehetséges jegyárakat vizsgálta.

a) Mekkora lenne a közlekedési társaság vonaljegyekből származó napi bevétele a hatástanulmány becslései alapján, ha 350 tallérra emelnék a vonaljegyek árát?
b) Hány talléros vonaljegy esetén lenne maximális a napi bevétel?

Tervezés

Értelmezve a feladatot és a feltett kérdéseket: adódik, hogy a megoldáshoz szükséges egy POJO, ami az összetartozó adatokat fogja egybe objektumként. Mivel több kell belőle, célszerű egy indexelhető adatszerkezet, például tömb vagy lista. Ékezettelen magyar elnevezéseket fogok használni. A POJO osztály neve legyen Kozlekedes és a beszédes nevű tulajdonságai legyenek a következők: vonaljegyAr, napiUtasszam, bliccelesSzazalek, napiBevetel. Mindegyik nemnegatív egész szám és belefér az int primitív típus számábrázolási tartományába.

Ha a konstruktor paraméterként átveszi az input vonaljegyAr-at, akkor abból a többi adatot egyszerű képletekkel előállíthatja. Hasznos, ha a konstruktor ellenőrzést is végez. A tanulmány az alkalmazott modellben limitálja a vonaljegy árát (250 és 450 közötti öttel osztható számként). Az öttel oszthatóság az emelés/árváltozás mértékéből adódik. Ha a vonaljegy ára nem megfelelő, akkor a konstruktor kivételt dob, amivel megakadályozza, hogy az alkalmazott modellhez nem illeszkedő tulajdonságokkal rendelkező objektum létrejöjjön.

Az output meghatározásához az a) és b) feladatban megfogalmazott kérdésekből kell kiindulni. Ezekből adódik, hogy szükséges két getter metódus a POJO-ba: getVonaljegyAr() és getNapiBevetel(). Persze könnyen generáltatható az összes getter is, de setter nem kell. Ezeken kívül a tesztelés megkönnyítésére hasznos egy toString() metódus is, amellyel a 4 összetartozó adat hozzáférhető és megjeleníthető a konzolon.

A belépési pont és egyben a vezérlés egy másik osztályban valósul meg. Itt feltöltjük a tanulmány alkalmazott modelljének megfelelően előállított objektumokkal (memóriacímeikkel) a generikus listát, amit programozási tételekkel (kiválasztás, szélsőérték-kiválasztás) dolgozunk fel.

A POJO osztály forráskódja

public class Kozlekedes {

private int vonaljegyAr; //pl.: 300 tallér

private int napiUtasszam; //pl.: 100000 fő

private int bliccelesSzazalek; //pl.: 10%

private int napiBevetel; //pl.: 27000000 tallér

public Kozlekedes(int vonaljegyAr) {

if(vonaljegyAr<=245 || vonaljegyAr>=455 || vonaljegyAr%5!=0)

throw new IllegalArgumentException(

"A vonaljegy ára nem megfelelő. (Hibakód: 32596)");

this.vonaljegyAr=vonaljegyAr;

napiUtasszam=100000-(vonaljegyAr-300)/5*1000;

bliccelesSzazalek=10+(vonaljegyAr-300)/5;

napiBevetel=(vonaljegyAr*

(int)(napiUtasszam*(100-bliccelesSzazalek)/100.0));

}

public int getVonaljegyAr() {

return vonaljegyAr;

}

public int getNapiBevetel() {

return napiBevetel;

}

@Override

public String toString() {

return

"Közlekedés {\n"+

" vonaljegy ár: "+vonaljegyAr+" tallér\n"+

" napi utasszám: "+napiUtasszam+" fő\n"+

" bliccelés: "+bliccelesSzazalek+"%\n"+

" napi bevétel: "+napiBevetel+" tallér\n"+

"}";

}

A vezérlő osztály forráskódja

public class MatErettsegi2020EmeltFeladat9 {

private static void feladat9(List<Kozlekedes> lista) {

//a) feladat

int i=0;

while(lista.get(i).getVonaljegyAr()!=350)

i++;

System.out.println(

"a) Mekkora lenne a közlekedési társaság vonaljegyekből\n"+

"származó napi bevétele a hatástanulmány becslései alapján,\n"+

"ha 350 tallérra emelnék a vonaljegyek árát?\n"+

lista.get(i).getNapiBevetel()+" tallér lenne a napi bevétel.\n");

//b) feladat

int maxIndex=0;

for(i=1; i<lista.size(); i++)

if(lista.get(i).getNapiBevetel()>

lista.get(maxIndex).getNapiBevetel())

maxIndex=i;

System.out.println(

"b) Hány talléros vonaljegy esetén lenne maximális "+

"a napi bevétel?\nHa a vonaljegy ára "+

lista.get(maxIndex).getVonaljegyAr()+" tallér lenne.\n");

}

public static void main(String[] args) {

List<Kozlekedes> lista=new ArrayList<>();

for(int vonaljegyAr=250; vonaljegyAr<=450; vonaljegyAr+=5)

lista.add(new Kozlekedes(vonaljegyAr));

// for (Kozlekedes kozlekedes : lista)

// System.out.println(kozlekedes);

// System.out.println();

feladat9Megoldas1(lista);

// feladat9Megoldas2();

}

A main() metódus feltölti a generikus lista adatszerkezetet az alkalmazott modellben lehetséges/előforduló vonaljegyAr alapján létrehozott objektumokkal (a memóriacímükkel). A feladat9Megoldas1() metódus paraméterként átveszi a feldolgozandó listát.

Az a) feladatra a választ kiválasztás programozási tétellel kapjuk meg. A kérdés így szól: melyik az (első) olyan objektum, amelyben a vonaljegyAr egyenlő 350-nel? A ciklust követően megkapjuk, hogy az i-edik az, amelyikre igaz a feltétel. (Az nem merül fel, hogy van-e ilyen objektum, hiszen tudjuk, hogy van. Csak az a kérdés, hogy melyik az. Több sem lehet.) A lista.get(i).getNapiBevetel() művelettel elkérjük az i-edik objektumtól a válaszadáshoz szükséges napi bevételt.

A b) feladatra a választ szélsőérték-kiválasztás programozási tétellel kapjuk meg. A kérdés így szól: melyik az (első) olyan objektum, amelyben a napiBevetel a maximális? (Mivel a lista nem üres, így létezik a legnagyobb napi bevétel. Mivel nem biztos, hogy a legnagyobb napi bevétel egyedi, ezért merül fel az első a kérdésben.) Tegyük fel, hogy a nulladik objektumra igaz a feltétel: azaz maxIndex=0. Később a ciklusban változtassuk meg a maxIndex-et, ha a feldolgozás során találunk nagyobb értéket. Szélsőérték-kiválasztásnál a kezdeti elemet nem hasonlítjuk össze saját magával (hiszen úgysem különbözne), ezért indul a for ciklus 1-ről. A ciklust követően a lista.get(maxIndex).getVonaljegyAr() művelettel elkérhetjük a maxIndex-edik objektumtól a válaszadáshoz szükséges vonaljegy árát.

A program által felépített adatszerkezet

Ha a vezérlőben aktiváljuk a megjegyzésben szereplő kiíratást, akkor a konzolon megjelennek a main() metódusban létrehozott listában lévő objektumok adatai (amilyen viselkedést a POJO toString()-jébe programoztunk. A 246 soros szöveg görgetéssel megtekinthető.

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

Közlekedés {

vonaljegy ár: 250 tallér

napi utasszám: 110000 fő

bliccelés: 0%

napi bevétel: 27500000 tallér

}

Közlekedés {

vonaljegy ár: 255 tallér

napi utasszám: 109000 fő

bliccelés: 1%

napi bevétel: 27517050 tallér

}

Közlekedés {

vonaljegy ár: 260 tallér

napi utasszám: 108000 fő

bliccelés: 2%

napi bevétel: 27518400 tallér

}

Közlekedés {

vonaljegy ár: 265 tallér

napi utasszám: 107000 fő

bliccelés: 3%

napi bevétel: 27504350 tallér

}

Közlekedés {

vonaljegy ár: 270 tallér

napi utasszám: 106000 fő

bliccelés: 4%

napi bevétel: 27475200 tallér

}

Közlekedés {

vonaljegy ár: 275 tallér

napi utasszám: 105000 fő

bliccelés: 5%

napi bevétel: 27431250 tallér

}

Közlekedés {

vonaljegy ár: 280 tallér

napi utasszám: 104000 fő

bliccelés: 6%

napi bevétel: 27372800 tallér

}

Közlekedés {

vonaljegy ár: 285 tallér

napi utasszám: 103000 fő

bliccelés: 7%

napi bevétel: 27300150 tallér

}

Közlekedés {

vonaljegy ár: 290 tallér

napi utasszám: 102000 fő

bliccelés: 8%

napi bevétel: 27213600 tallér

}

Közlekedés {

vonaljegy ár: 295 tallér

napi utasszám: 101000 fő

bliccelés: 9%

napi bevétel: 27113450 tallér

}

Közlekedés {

vonaljegy ár: 300 tallér

napi utasszám: 100000 fő

bliccelés: 10%

napi bevétel: 27000000 tallér

}

Közlekedés {

vonaljegy ár: 305 tallér

napi utasszám: 99000 fő

bliccelés: 11%

napi bevétel: 26873550 tallér

}

Közlekedés {

vonaljegy ár: 310 tallér

napi utasszám: 98000 fő

bliccelés: 12%

napi bevétel: 26734400 tallér

}

Közlekedés {

vonaljegy ár: 315 tallér

napi utasszám: 97000 fő

bliccelés: 13%

napi bevétel: 26582850 tallér

}

Közlekedés {

vonaljegy ár: 320 tallér

napi utasszám: 96000 fő

bliccelés: 14%

napi bevétel: 26419200 tallér

}

Közlekedés {

vonaljegy ár: 325 tallér

napi utasszám: 95000 fő

bliccelés: 15%

napi bevétel: 26243750 tallér

}

Közlekedés {

vonaljegy ár: 330 tallér

napi utasszám: 94000 fő

bliccelés: 16%

napi bevétel: 26056800 tallér

}

Közlekedés {

vonaljegy ár: 335 tallér

napi utasszám: 93000 fő

bliccelés: 17%

napi bevétel: 25858650 tallér

}

Közlekedés {

vonaljegy ár: 340 tallér

napi utasszám: 92000 fő

bliccelés: 18%

napi bevétel: 25649600 tallér

}

Közlekedés {

vonaljegy ár: 345 tallér

napi utasszám: 91000 fő

bliccelés: 19%

napi bevétel: 25429950 tallér

}

Közlekedés {

vonaljegy ár: 350 tallér

napi utasszám: 90000 fő

bliccelés: 20%

napi bevétel: 25200000 tallér

}

Közlekedés {

vonaljegy ár: 355 tallér

napi utasszám: 89000 fő

bliccelés: 21%

napi bevétel: 24960050 tallér

}

Közlekedés {

vonaljegy ár: 360 tallér

napi utasszám: 88000 fő

bliccelés: 22%

napi bevétel: 24710400 tallér

}

Közlekedés {

vonaljegy ár: 365 tallér

napi utasszám: 87000 fő

bliccelés: 23%

napi bevétel: 24451350 tallér

}

Közlekedés {

vonaljegy ár: 370 tallér

napi utasszám: 86000 fő

bliccelés: 24%

napi bevétel: 24183200 tallér

}

Közlekedés {

vonaljegy ár: 375 tallér

napi utasszám: 85000 fő

bliccelés: 25%

napi bevétel: 23906250 tallér

}

Közlekedés {

vonaljegy ár: 380 tallér

napi utasszám: 84000 fő

bliccelés: 26%

napi bevétel: 23620800 tallér

}

Közlekedés {

vonaljegy ár: 385 tallér

napi utasszám: 83000 fő

bliccelés: 27%

napi bevétel: 23327150 tallér

}

Közlekedés {

vonaljegy ár: 390 tallér

napi utasszám: 82000 fő

bliccelés: 28%

napi bevétel: 23025600 tallér

}

Közlekedés {

vonaljegy ár: 395 tallér

napi utasszám: 81000 fő

bliccelés: 29%

napi bevétel: 22716450 tallér

}

Közlekedés {

vonaljegy ár: 400 tallér

napi utasszám: 80000 fő

bliccelés: 30%

napi bevétel: 22400000 tallér

}

Közlekedés {

vonaljegy ár: 405 tallér

napi utasszám: 79000 fő

bliccelés: 31%

napi bevétel: 22076550 tallér

}

Közlekedés {

vonaljegy ár: 410 tallér

napi utasszám: 78000 fő

bliccelés: 32%

napi bevétel: 21746400 tallér

}

Közlekedés {

vonaljegy ár: 415 tallér

napi utasszám: 77000 fő

bliccelés: 33%

napi bevétel: 21409850 tallér

}

Közlekedés {

vonaljegy ár: 420 tallér

napi utasszám: 76000 fő

bliccelés: 34%

napi bevétel: 21067200 tallér

}

Közlekedés {

vonaljegy ár: 425 tallér

napi utasszám: 75000 fő

bliccelés: 35%

napi bevétel: 20718750 tallér

}

Közlekedés {

vonaljegy ár: 430 tallér

napi utasszám: 74000 fő

bliccelés: 36%

napi bevétel: 20364800 tallér

}

Közlekedés {

vonaljegy ár: 435 tallér

napi utasszám: 73000 fő

bliccelés: 37%

napi bevétel: 20005650 tallér

}

Közlekedés {

vonaljegy ár: 440 tallér

napi utasszám: 72000 fő

bliccelés: 38%

napi bevétel: 19641600 tallér

}

Közlekedés {

vonaljegy ár: 445 tallér

napi utasszám: 71000 fő

bliccelés: 39%

napi bevétel: 19272950 tallér

}

Közlekedés {

vonaljegy ár: 450 tallér

napi utasszám: 70000 fő

bliccelés: 40%

napi bevétel: 18900000 tallér

}

Az eredmény

A program konzolon/szövegesen jeleníti meg a válaszokat a feltett két kérdésre:

a) Mekkora lenne a közlekedési társaság vonaljegyekből

származó napi bevétele a hatástanulmány becslései alapján,

ha 350 tallérra emelnék a vonaljegyek árát?

25200000 tallér lenne a napi bevétel.

b) Hány talléros vonaljegy esetén lenne maximális a napi bevétel?

Ha a vonaljegy ára 260 tallér lenne.

Gondoljuk újra

Az első megoldás 41 elemű listát épít. Persze ez a lista több mindenre is jó lehet, ha több(féle) kérdést kell(ene) megválaszolni. Ezért tekinthetjük strukturális tartaléknak.

A két konkrét kérdésre azonban úgy is adhatunk választ, hogy nem építünk lista adatszerkezetet. Ez a második megoldás. A feladat9Megoldas2() metódusnak nincs paramétere és azonos eredmény ad.

Az a) feladat: egy névtelen objektumként létrehozott POJO-tól azonnal elkérhetjük a választ, ami mehet rögtön a konzolra. Ez a kiválasztás programozási tétel extrém/legjobb esete, hiszen az első objektum jó is lesz, ciklust sem kell szervezni.

A b) feladat: kiindulunk a legolcsóbb vonaljegyből és tegyük fel, hogy ekkor a legnagyobb a napi bevétel. Ciklussal léptessük a vonaljegy árát ötösével legfeljebb a legdrágábbig. Léptetés közben mindig csak azt a dinamikusan létrehozott objektumot „jegyezzük meg”, amelyiktől a röptében elkért napi bevétel a korábbihoz – az addig legnagyobbnak vélthez – képest nagyobb. Végül a megmaradó POJO-tól elkérhető a maximális napi bevételhez tartozó vonaljegy ára. Ez a szélsőérték-kiválasztás programozási tétel megvalósítása dinamikusan: kezdetben nem áll rendelkezésre az összes adat, ami alapján döntést kell hozni, ehelyett az adatokat menet/feldolgozás közben állítjuk elő és „eldobjuk” azt, ami már nem kell.

private static void feladat9Megoldas2() {

//a) feladat

System.out.println(

"a) Mekkora lenne a közlekedési társaság vonaljegyekből\n"+

"származó napi bevétele a hatástanulmány becslései alapján,\n"+

"ha 350 tallérra emelnék a vonaljegyek árát?\n"+

new Kozlekedes(350).getNapiBevetel()+

" tallér lenne a napi bevétel.\n");

//b) feladat

Kozlekedes kMax=new Kozlekedes(250);

for(int vonaljegyAr=255; vonaljegyAr<=450; vonaljegyAr+=5) {

Kozlekedes k=new Kozlekedes(vonaljegyAr);

if(k.getNapiBevetel()>kMax.getNapiBevetel())

kMax=k;

}

System.out.println(

"b) Hány talléros vonaljegy esetén lenne maximális "+

"a napi bevétel?\nHa a vonaljegy ára "+

kMax.getVonaljegyAr()+" tallér lenne.\n");

}

Nekem ezek a programozással való megoldások sokkal jobban tetszenek, mint az oktatas.hu-n elérhető hivatalos, matematikai megoldás, amihez differenciálszámítás is kell. Persze aki emelt szinten érettségizik matematikából, annak az sem jelenthet gondot és biztosan izgalmasnak találja.

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-24. óra: Objektumorientált programozás alkalmaihoz kötődik.