metódus - címke - it-tanfolyam.hu

Skandináv lottó előállítása változókkal és rekurzióval

2025. június 15.2024. augusztus 19. Szerző: Kiss Balázs

Újra skandináv lottó (heteslottó) szelvényt generálunk Java programmal. Két különböző elven megvalósuló megoldást hasonlítunk össze. A megoldást lépésenként bemutató, grafikus felhasználói felületű, saját fejlesztésű programunkról blogoltunk már: Skandináv lottó demóprogram. Most másképpen gondolkodunk – reméljük közösen.

Építünk az alábbi tipp() függvényre:

static int tipp() {

return (int)(Math.random()*35+1);

}

Ennek a függvénynek lokális felelőssége van, azaz előállít egyetlen olyan véletlenszámot, ami megfelelő a skandináv lottószelvényre. Másképpen 1 és 35 közötti (zárt intervallum) egész szám.

A globális felelősség a megoldások során azt biztosítja, hogy minden szám egyedi/különböző legyen és 7 db véletlenszám legyen.

1. megoldás

Az első megoldás során csupán egyszerű változók jelentik az emlékezetet. Külön adatszerkezet (tömb, lista, halmaz) nincs. A lotto1() metódus valósítja meg az alábbiak szerint:

static void lotto1() {

int a=tipp(), b, c, d, e, f, g;

b=tipp();

while(a==b);

c=tipp();

while(a==c || b==c);

d=tipp();

while(a==d || b==d || c==d);

e=tipp();

while(a==e || b==e || c==e || d==e);

f=tipp();

while(a==f || b==f || c==f || d==f || e==f);

g=tipp();

while(a==g || b==g || c==g || d==g || e==g || f==g);

System.out.println("Lottószelvény: "+

a+", "+b+", "+c+", "+d+", "+e+", "+f+", "+g);

}

Az a egész ( int) típusú változó ellenőrzés nélkül előállítható, mert az első szám biztosan egyedi. A b változót csak az a-val kell összehasonlítani. Célszerű a do while hátultesztelő ciklus alkalmazása. A b-t addig tippeltetjük újra és újra, amíg szükséges. Másképpen: amíg a megegyezik b-vel ( a==b), addig nem jó a b és ezért újra kell generálni. A c változó esetében már a korábban előállított a-val és b-vel is össze kell hasonlítani, hiszen c-nek mindkettőtől különböznie kell. Másképpen (1): amíg a==c vagy b==c, addig nem jó a c és ezért újra kell generálni. Másképpen (2): amíg nem igaz, hogy a különbözik c-től és b is különbözik c-től, addig meg kell ismételni a c előállítását. Kiválóan megérhető a gondolatmenet alapján a megoldás során használt De Morgan azonosság. És így tovább a többi változóval is: d, e, f, g. Nehézkes a sok változó külön-külön való kezelése és figyelmesen kell megírni Java nyelven a hosszú forráskódot. Az eredmény a konzolon jelenik meg, például így:

1	Lottószelvény: 10, 26, 1, 17, 23, 2, 32

Kompromisszum, hogy a lottószelvényre kerülő véletlenszámok sorrendje is véletlen. Másképpen: a véletlenszámok nem „emelkedő számsorrendben” jelennek meg.

2. megoldás

Most nem használunk ciklus utasítást. Persze a lottószelvényre kerülő véletlenszámok előállítása megköveteli az ismétlést a vezérlés megvalósítása során. Az ismétlést rekurzív vezérlés oldja meg. Az emlékezetet most TreeSet jelenti. Ez egy generikus, Integer típusú adatszerkezet, amely a java.util csomagbeli kollekció keretrendszer része. Rendezett halmazként működik. Cím szerinti paraméterátadással kapja meg a metódus és kezdetben üres. Addig kell beletenni újonnan előállított véletlenszámot, amíg „egyszer csak” eléri az elemszáma a 7-et. Ha olyan elem kerül a halmazba, ami már benne van, akkor az add() halmazbővítő művelet hatástalan.

static TreeSet<Integer> lotto2(TreeSet<Integer> halmaz) {

if(halmaz.size()==7)

return halmaz;

halmaz.add(tipp());

return lotto2(halmaz);

}

A rekurzió során a lotto2() függvény saját magát hívja meg. Működése során kihasználja, hogy az adatszerkezet „menet közben” megváltozik (bővül). A lottószelvényre kerülő véletlenszámok sorrendje egyfajta mellékhatásként valósul meg, mert a TreeSet típusú kollekció automatikus képessége. Az eredmény a konzolon jelenik meg, például így:

1	Lottószelvény: [3, 8, 10, 11, 15, 27, 29]

Ha érdekelnek bennünket a részletek, akkor a rekurzív vezérlés kiegészíthető a lotto3() metódusnál látható szint paraméterrel és néhány kiírással az alábbiak szerint:

static TreeSet<Integer> lotto3(TreeSet<Integer> halmaz, int szint) {

if(halmaz.size()==7)

return halmaz;

System.out.print("szint: "+szint);

int tipp=tipp();

System.out.print(", tipp: "+tipp);

halmaz.add(tipp);

System.out.println(", halmaz: "+halmaz);

return lotto3(halmaz, szint+1);

}

Az önmagyarázóvá tett forráskód például az alábbi eredményt írhatja ki a konzolra:

szint: 0, tipp: 15, halmaz: [15]

szint: 1, tipp: 14, halmaz: [14, 15]

szint: 2, tipp: 5, halmaz: [5, 14, 15]

szint: 3, tipp: 9, halmaz: [5, 9, 14, 15]

szint: 4, tipp: 5, halmaz: [5, 9, 14, 15]

szint: 5, tipp: 7, halmaz: [5, 7, 9, 14, 15]

szint: 6, tipp: 15, halmaz: [5, 7, 9, 14, 15]

szint: 7, tipp: 14, halmaz: [5, 7, 9, 14, 15]

szint: 8, tipp: 15, halmaz: [5, 7, 9, 14, 15]

szint: 9, tipp: 34, halmaz: [5, 7, 9, 14, 15, 34]

szint: 10, tipp: 13, halmaz: [5, 7, 9, 13, 14, 15, 34]

Lottószelvény: [5, 7, 9, 13, 14, 15, 34]

Jól látható, hogy mennyi lépést igényel a lottószelvény előállítása, mikor fordult elő ismétlődés a véletlenszámok előállítása során.

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

A feladat a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 9-12. óra: Metódusok, rekurzió alkalomhoz, illetve a 21-24. óra: Objektumorientált programozás, 2. rész alkalomhoz kötődik.

Dátumok csoportosítása

2025. június 15.2024. július 8. Szerző: Kiss Balázs

Ebben a Java projektben dátumok csoportosítását oldjuk meg, többféleképpen is. Mikor van erre szükség? Jelentés, kimutatás, riport, lista készítése során.

Példaként tekintsünk egy blogot. A blogban rendszeresen jelenik meg új tartalom (bejegyzés, poszt). Azért, hogy a blog hosszabb távon, sok bejegyzéssel is könnyen kereshető, átlátható, böngészhető legyen/maradjon a felhasználók, látogatók számára, célszerű:

taxonómia kialakítása. Ez kategóriákat és címkéket jelent. Ebből címkefelhő vagy szófelhő is készíthető, ahogyan erről blogoltunk már: Címkefelhő generálása.
marketing analitika használata. Ezek általában toplisták valamilyen könnyen hozzáférhető adat alapján. Például: látogatottság, népszerűség, eltöltött idő, hozzászólások száma, megosztások száma, egérmutató mozgása alapján hőtérkép. Ezek általában toplisták, amelyek eleje listázódik csökkenő sorrendben.
dátum szerint is csoportosítani a blog bejegyzéseit. Érdemes megjeleníteni a legújabbtól a régebbi felé haladó (retrospektív) listát, hierarchikus fa struktúrát, lenyíló panelt. Mindez kombinálható toplistával. A csoportosítás elvégezhető igény szerint tetszőlegesen, például évente, negyedévente, havonta.

Lássuk, hogyan lehet megvalósítani a dátumok csoportosítását Java programozás nyelven!

Milyen adatokra van szükség?

Egy megadott zárt dátumtartományban véletlenszerűen előállítunk néhány dátumot. Nem számít, hogy különböznek-e. A dátumokat tároló listát érdemes csökkenő sorrendben tárolni. Minden dátum múltbeli, így ez a sorrend a jelenhez legközelebbitől halad a legtávolabbi felé. Például a Java program ezekkel a dátumokkal dolgozik (lapozható):

2024.03.25.

2024.03.22.

2024.02.26.

2024.01.30.

2024.01.25.

2024.01.23.

2024.01.16.

2024.01.13.

2024.01.02.

2023.11.29.

2023.11.25.

2023.11.24.

2023.11.07.

2023.10.02.

2023.09.14.

2023.08.31.

2023.08.04.

2023.07.13.

2023.06.15.

2023.06.14.

2023.06.08.

2023.04.22.

2023.04.01.

2023.03.26.

2023.02.11.

2023.02.08.

2023.01.26.

2022.12.14.

2022.12.10.

2022.11.09.

2022.10.14.

2022.10.04.

2022.09.24.

2022.09.23.

2022.09.20.

2022.09.09.

2022.09.01.

2022.08.31.

2022.08.20.

2022.07.29.

2022.07.03.

2022.06.30.

2022.06.07.

2022.05.16.

2022.05.15.

2022.04.18.

2022.04.14.

Milyen eredményeket kaphatunk?

Az évenkénti csoportosítás így jelenik meg:

Csoportosítás évente

2024. év (9)

2023. év (20)

2022. év (21)

A havonkénti csoportosítás így jelenik meg (lapozható):

Csoportosítás havonta

2024. március hó (2)

2024. február hó (1)

2024. január hó (6)

2023. november hó (5)

2023. október hó (1)

2023. szeptember hó (1)

2023. augusztus hó (2)

2023. július hó (1)

2023. június hó (3)

2023. április hó (2)

2023. március hó (1)

2023. február hó (2)

2023. január hó (2)

2022. december hó (3)

2022. november hó (1)

2022. október hó (2)

2022. szeptember hó (5)

2022. augusztus hó (2)

2022. július hó (2)

2022. június hó (2)

2022. május hó (2)

2022. április hó (2)

Természetesen blog esetén gyűjtőoldalra mutató hivatkozást kell tenni a megjelenő elemekre. Azok az évek és hónapok nem jelennek meg, ahol nincs dátum (blog bejegyzés).

Hogyan kapjuk meg az eredményeket?

Természetesen Java nyelven programozva készítünk megoldást, sőt többféle megoldást. Ezek szépen összevethetők és mindenki kiválaszthatja azt, amit szívesen használna. A dátumobjektumok tárolása generikus listában történik, aminek típusa LocalDate. A dátumok formátuma: DateTimeFormatter.ofPattern("yyyy.MM.dd.").

1. megoldás

Ez a hagyományosnak tekinthető megoldás. Végigjárja a dátumobjektumokat tartalmazó dateList dátumlista adatszerkezetet. Két egymásba ágyazott ciklussal csoportváltást valósít meg. Feltételezi – nem ellenőrzi -, hogy az adatok sorrendje megegyezik az eredmény kiírásának megfelelő sorrenddel. Amíg két egymást követő dátum GROUP_BY_FORMAT formátuma azonos, addig ugyanabba a csoportba tartoznak. A csoportváltáskor az eredmény TYPE_FORMAT formátumú. Közben a beépített megszámolás programozási tétel is működik.

static void groupByDate1(String message, String groupText,

ArrayList<LocalDate> dateList,

final DateTimeFormatter GROUP_BY_FORMAT,

final DateTimeFormatter TYPE_FORMAT) {

System.out.println(message);

int i=0;

while(i<dateList.size()) {

LocalDate currentDate=dateList.get(i);

String typeGroup=currentDate.format(TYPE_FORMAT);

String currentGroup=currentDate.format(GROUP_BY_FORMAT);

int count=0;

while(i<dateList.size() && dateList.get(i).

format(GROUP_BY_FORMAT).equals(currentGroup)) {

count++;

i++;

}

System.out.println(typeGroup+groupText+" ("+count+")");

}

A groupByDate1() függvény képes az évente és havonta csoportosítás megvalósítására. Mindez a paraméterezésén múlik. Évente csoportosít, ha így hívja meg a vezérlés:

groupByDate1("Csoportosítás évente", "év", dateList,

DateTimeFormatter.ofPattern("yyyy"),

DateTimeFormatter.ofPattern("yyyy. "));

Évenkénti csoportosítás során például a 2024.02.26. és a 2024.01.30. (dátumként, nem szövegként értelmezve) azért tartozik egy csoportba, mert a dátumobjektumoktól elkért év "2024" szövegként mindkettő esetében megegyezik.

A groupByDate1() függvény havonta csoportosít, ha így hívja meg a vezérlés:

groupByDate1("Csoportosítás havonta", "hó", dateList,

DateTimeFormatter.ofPattern("yyyyMM"),

DateTimeFormatter.ofPattern("yyyy. MMMM "));

Havonkénti csoportosítás során például a 2023.06.14. és a 2023.06.08. (szintén dátumként értelmezve) azért tartozik egy csoportba, mert mindkettő illeszkedik a "202306" szövegmintára.

2. megoldás

Ez a Stream API-t és funkcionális programozást használó, újabb megoldás. Ciklus helyett beépített műveletek vannak. A groupByDate2() függvény a dátumok évenkénti csoportosítását képes megoldani:

static void groupByDate2(String message, String groupText,

ArrayList<LocalDate> dateList,

final DateTimeFormatter TYPE_FORMAT) {

System.out.println(message);

List<String> list=dateList.stream().

map(e -> e.format(TYPE_FORMAT)).

collect(Collectors.groupingBy(

Function.identity(), Collectors.counting())).

entrySet().stream().sequential().map(

e -> e.getKey()+groupText+" ("+e.getValue()+")").

sorted().

collect(Collectors.collectingAndThen(Collectors.toList(), e -> {

Collections.reverse(e);

return e;

}));

list.forEach((date) -> {

System.out.println(date);

});

}

A groupByDate3() függvény a dátumok havonkénti csoportosítására készült. A YearMonth osztály beépített ( java.time csomag). A DateCount saját POJO. Konstruktora 4 paramétert kap: YearMonth key, Long value, DateTimeFormatter format és String groupText, valamint van két hasznos metódusa. Az egyik az örökölt és felüldefiniált toString() a formázott kiíráshoz, a másik pedig a Comparable interfésztől implementált compareTo() a sorrend kialakításához szükséges összehasonlításhoz.

static void groupByDate3(String message, String groupText,

ArrayList<LocalDate> dateList,

final DateTimeFormatter TYPE_FORMAT) {

System.out.println(message);

List<DateCount> list=dateList.stream().

map(e -> YearMonth.from(e)).

collect(Collectors.groupingBy(

Function.identity(), Collectors.counting())).

entrySet().stream().map(e -> new DateCount(

e.getKey(), e.getValue(), TYPE_FORMAT, groupText)).

sorted().collect(Collectors.toList());

list.forEach((date) -> {

System.out.println(date);

});

}

A funkcionális programozáshoz kötődő lambda műveletekről többször is blogoltunk már, így azokat most nem részletezem. Helyette ajánlom a szakmai blog lambda kifejezés címkéjét.

Továbbfejlesztés

Érdemes átgondolni az 1. és 2. megoldás markáns különbözőségeit, illetve egymást kiegészítő gondolatmenetét. Zárjuk két ötlettel a továbbfejlesztésre vonatkozóan:

A 2. megoldás két függvénye megoldható egyetlen függvénnyel, amely hasonlóan paraméterezhető, mint az 1. megoldás függvénye. Ezáltal univerzális(abb)nak tekinthető megoldás is készülhetne. Aki kellően motivált és végiggyakorolja a fentieket, biztosan meg tudja oldani. Várjuk hozzászólásban, vagy az ILIAS-ban a megoldást!
A csoportosítás egyben hierarchiát jelent, amiből fa szerkezet építhető. A fa vizuális komponensen is megjeleníthető, ahogyan blogoltunk is róla: Fát építünk.

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

A feladat a Java SE szoftverfejlesztő tanfolyam, a Java EE szoftverfejlesztő tanfolyam és a Java adatbázis-kezelő tanfolyam szakmai moduljának több alkalmához és az orientáló moduljának 1-4. óra: Programozási tételek alkalmához is kötődik. A Stream API-val és a lambda kifejezésekkel sokszor foglalkozunk.

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

2025. június 15.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.

Dr. Sheldon Cooper kő-papír-olló-gyík-Spock játéka

2025. június 15.2024. április 1. Szerző: Kaczur Sándor

Dr. Sheldon Cooper karakterét nem kell bemutatni. Ha a kockáknak döntéseket kell hozniuk, akkor az Agymenők (The Big Bang Theory) sorozatban többször is előkerül a kő-papír-olló-gyík-Spock játék.

A 2. évad 8. epizódjában – amelynek címe Fogd a nőt, és fuss! (The Lizard–Spock Expansion) – ismerjük meg a játékszabályt és rögtön alkalmazásra is kerül. Raj és Sheldon megpróbálja eldönteni, hogy melyik sci-fi sorozat a (leg)jobb, illetve Howard és Sheldon így próbálnak osztozni a vacsora maradékán. Végül az 5. évad 17. epizódjában – amelynek címe Itt a festmény, hol a festmény! (The Rothman Disintegration) – újra hallhatjuk a játékszabályt. Ekkor Kripke és Sheldon egy egyetemi iroda sorsáról (kié legyen) próbál dönteni.

A kő-papír-olló-gyík-Spock játékszabály

Vajon hogyan bővül ki a klasszikus kő-papír-olló játékszabálya további két kézjel/fegyver hozzáadásával? Íme a játékszabály videóban:

Íme a játékszabály szövegesen:

Az olló elvágja a papírt,
a papír bevonja a követ,
a kő agyonüti a gyíkot,
a gyík megmarja Spockot,
Spock eltöri az ollót,
az olló lefejezi a gyíkot,
a gyík megeszi a papírt,
a papír cáfolja Spockot,
Spock feloldja a követ,
a kő eltöri az ollót.

Ugye mi sem egyszerűbb? 🙂

A játékszabálynak számos grafikus ábrázolása is van. Ezeken többnyire irányított gráf csomópontjai mutatják a kézjeleket és a nyilak iránya mutatja, hogy mi mit győz le. Például a gyíktól Spock felé mutató jelzi, hogy a gyík megmarja (azaz legyőzi) Spock-ot. Íme az egyik ábra:

A kő-papír-olló-gyík-Spock játék szimulációja Java programmal

Az objektumorientált tervezés egyik lehetősége az öröklődés beépítése. Közös pontokat, funkcionalitást keresünk. Ezeket beépítjük az ősosztályba és az utódokban kiegészítjük, testre szabjuk. Kiindulunk az alábbi absztrakt Dontes ősosztályból:

abstract class Dontes {

private static final String[] DONTES={

"kő", "papír", "olló", "gyík", "Spock"}; //-1: döntetlen

// 0 1 2 3 4

protected static int veletlenDontes() {

return (int)(Math.random()*5); //0-4

}

private String dontesEredmeny(int d) {

return d==-1 ? "döntetlen" : DONTES[d]+ " nyert";

}

protected String kiiras(int d1, int d2) {

if(d1<-1 || d1>=DONTES.length || d2<-1 || d2>=DONTES.length)

throw new IllegalArgumentException("Hiba! Érvénytelen döntés.");

return DONTES[d1]+" és "+ DONTES[d2]+": "+

dontesEredmeny(eredmeny(d1, d2));

};

protected int eredmeny(int d1, int d2, int d3) {

return eredmeny(d1, eredmeny(d2, d3));

}

public abstract int eredmeny(int dontes1, int dontes2);

}

A konstans DONTES tömb (indexelhető adatszerkezet) tárolja a kézjelek/fegyverek elnevezését. Ezek közül választ véletlenszerűen a veletlenDontes() függvény. Az eredményt ki kell tudni írni a konzolra, illetve kezelni kell a döntetlent is. Ezekért közösen felelnek a dontesEredmeny() és a kiiras() függvények. A túlterhelt metódusokként létrehozott eredmeny() függvények kezelik a 2 illetve 3 játékos esetén a döntéseket. A háromparaméteres függvény visszavezet a kétparaméteres esetre. Utóbbi metódus – mivel absztrakt – csak az utódosztályban valósul meg. Így lehetővé válik a játékszabály többféle megvalósítása.

1. megoldás

Az első megoldás során adatszerkezet nélkül valósul meg a játékszabály a KoPapirOlloGyikSpockV1 utódosztályban:

class KoPapirOlloGyikSpockV1 extends Dontes {

@Override

public int eredmeny(int d1, int d2) {

if(d1==d2) //döntetlen

return -1;

return (d1==2 && d2==1) || //Az olló elvágja a papírt,

(d1==1 && d2==0) || //a papír bevonja a követ,

(d1==0 && d2==3) || //a kő agyonüti a gyíkot,

(d1==3 && d2==4) || //a gyík megmarja Spockot,

(d1==4 && d2==2) || //Spock eltöri az ollót,

(d1==2 && d2==3) || //az olló lefejezi a gyíkot,

(d1==3 && d2==1) || //a gyík megeszi a papírt,

(d1==1 && d2==4) || //a papír cáfolja Spockot,

(d1==4 && d2==0) || //Spock feloldja a követ,

(d1==0 && d2==2) ? //a kő eltöri az ollót.

d1 : d2;

}

2. megoldás

A második megoldás során a játékszabályt konstansként deklarált MATRIX szomszédsági -, csúcsmátrix, kétdimenziós tömb adatszerkezet tárolja. Ez alapján döntést tud hozni a KoPapirOlloGyikSpockV2 utódosztály.

class KoPapirOlloGyikSpockV2 extends Dontes {

private static final int[][] MATRIX={

// kő papír olló gyík Spock

/*kő*/ {0, 0, 1, 1, 0},

//A kő eltöri az ollót, a kő agyonüti a gyíkot,

/*papír*/ {1, 0, 0, 0, 1},

//a papír bevonja a követ, a papír cáfolja Spockot,

/*olló*/ {0, 1, 0, 1, 0},

//az olló elvágja a papírt, az olló lefejezi a gyíkot,

/*gyík*/ {0, 1, 0, 0, 1},

//a gyík megeszi a papírt, a gyík megmarja Spockot,

/*Spock*/ {1, 0, 1, 0, 0}

//Spock feloldja a követ, Spock eltöri az ollót.

};

@Override

public int eredmeny(int d1, int d2) {

if(d1==d2) //döntetlen

return -1;

return MATRIX[d1][d2]==1 ? d1 : d2;

}

A játékmenetért felelős vezérlés

10 lépésből álló játékmenetet hoz létre az alábbi vezérlés:

public class KoPapirOlloGyikSpock {

public static void main(String[] args) {

KoPapirOlloGyikSpockV1 jatekV1=new KoPapirOlloGyikSpockV1();

KoPapirOlloGyikSpockV2 jatekV2=new KoPapirOlloGyikSpockV2();

for(int i=1; i<=10; i++) {

int d1=Dontes.veletlenDontes();

int d2=Dontes.veletlenDontes();

System.out.println(jatekV1.kiiras(d1, d2));

System.out.println(jatekV2.kiiras(d1, d2));

System.out.println();

}

Egyben tesztelés is: igazolja, hogy azonosan működik a két különböző megoldás.

Eredmény

Mivel minden véletlenszerűen alakul a játékban, ezért az alábbi csupán egy a sokféle lehetséges kimenet közül:

papír és gyík: gyík nyert

kő és kő: döntetlen

kő és papír: papír nyert

Spock és papír: papír nyert

olló és Spock: Spock nyert

kő és Spock: Spock nyert

papír és papír: döntetlen

gyík és Spock: gyík nyert

gyík és kő: kő nyert

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

A feladat a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 5-8. óra: Vezérlő szerkezetek, 9-12. óra: Metódusok, rekurzió, 13-16- óra: Tömbök, illetve a 17-24. óra: Objektumorientált programozás 1. és 2. rész alkalmaihoz kötődik.

PDF fájl készítése

2025. június 15.2024. március 22. Szerző: Kaczur Sándor

A PDF népszerű fájlformátum. Az Adobe cég 30+ éves szabványa. Hordozható: azaz minden eszközön, platformon ugyanúgy jelenik meg. Számos nézegető program támogatja, köztük böngészőprogramok is. A PDF rövidítés a Portable Document Format betűszava. Többnyire kimeneti formátumnak tekinthető. Az évek során folyamatosan fejlődött: ma már űrlapokat is tartalmazhat, elektronikusan aláírható, hitelesíthető, és hivatalos ügyek során is használják.

PDF fájl többféleképpen is készíthető. Például:

irodai szoftverek Mentés másként… menüpontjában,
Adobe Acrobat szoftverrel,
online alkalmazásokkal sokféle fájlformátum konvertálható PDF-be,
speciális célszoftverek is generálhatnak PDF fájlokat.

Utóbbi esetekre néhány példa:

online megvásárolt koncertjegyet e-mail csatolmányaként kapunk PDF-ben, ugyanígy számlát is róla,
online tanfolyamunk záró tesztjét követően letölthető tanúsítványt, badge-t, online IQ tesztünk eredményeként oklevelet kapunk PDF fájlként,
kérdőívek kitöltése során egyéni válaszainkat visszaigazolásként PDF-et kapunk, vagy a kérdőív kitöltési időszakának végén összesített eredményt, PDF riportot kapunk.

Java program készít PDF fájlt

Adatokra van szükség. Korábbi Munkakör, létszám, névsor lekérdezése blog bejegyzésünkben az Oracle HR sémából kétféleképpen is lekérdeztük a szükséges adatokat. Ezt érdemes előzetesen tanulmányozni, hogy a további tartalom könnyebben érthető legyen. A Java SE szoftverfejlesztő tanfolyam megközelítése alapján, az egyszerűbb SQL paranccsal előállított eredménytáblát a PDF generálása előtt még csoportosítani kell (munkakörönként). A Java adatbázis-kezelő tanfolyam megközelítése alapján, az összetettebb SQL paranccsal elkészített, denormalizált eredménytábla közvetlenül felhasználható.

A cél egy táblázat elkészítése, amely 3 oszlopból áll: munkakör, létszám és névsor. Az azonos munkakörű alkalmazottak névsora egy táblázat egyetlen cellájában legyen megjeleníthető. Az elkészült táblázatból készüljön PDF fájl.

A teendők lépésenként

Szükséges az iText csomag importálása: com.itextpdf.text. Korábbi változata az 5-ös, aktuális változata a 8-as. Előbbi nagyon elterjedt, utóbbi még kevésbé ismert. A továbbiakban a kötelező kivételkezeléshez kötődő forráskód-részletek bemutatásától eltekintünk.

Tehát adott az összes szükséges adat egy ArrayList<MunkakorLetszamNevsor> lista generikus listában. A POJO mindhárom szükséges és összetartozó tulajdonságot tárolja: String munkakor, int letszam, String nevsor.

Hasznos egy általánosan használható cella() függvény elkészítése, amely képes adott szöveget, adott betűmérettel, adott betűstílussal, adott igazítással „megjeleníteni”:

private PdfPCell cella(String szoveg, int betumeret,

boolean felkover, int igazitas)

throws DocumentException, IOException {

PdfPCell cella=new PdfPCell();

BaseFont betutipus=BaseFont.createFont(

BaseFont.HELVETICA, BaseFont.CP1250, BaseFont.EMBEDDED);

Paragraph bekezdes=new Paragraph(szoveg,

new Font(betutipus, betumeret, felkover?Font.BOLD:Font.NORMAL));

bekezdes.setAlignment(igazitas);

cella.addElement(bekezdes);

cella.setPadding(2);

cella.setVerticalAlignment(Paragraph.ALIGN_CENTER);

return cella;

}

Létre kell hozni a pdfFajl objektumot, beállítani a méretét és a margókat, illetve fájlba kell irányítani:

Document pdfFajl=new Document(PageSize.A4, 15, 15, 30, 20);

PdfWriter.getInstance(pdfFajl,

new FileOutputStream("./files/jelentes.pdf"));

pdfFajl.open();

Létre kell hozni a táblázat előtt megjelenő szöveget (ez nem a szövegszerkesztés szerinti valódi fejléc):

BaseFont betutípus=BaseFont.createFont(

BaseFont.HELVETICA, BaseFont.CP1250, BaseFont.EMBEDDED);

Paragraph fejlec=

new Paragraph("Jelentés", new Font(betutípus, 20, Font.BOLD));

fejlec.setAlignment(Paragraph.ALIGN_CENTER);

pdfFajl.add(fejlec);

Létre kell hozni a táblázatot, megfelelő beállításokkal:

PdfPTable tablazat=new PdfPTable(3);

tablazat.setWidthPercentage(85);

tablazat.setSpacingBefore(40);

tablazat.setWidths(new float[] {0.2f, 0.1f, 0.7f});

Létre kell hozni a táblázat fejlécét:

tablazat.addCell(

cella("Munkakör", 14, true, Paragraph.ALIGN_CENTER));

tablazat.addCell(

cella("Lét-\nszám", 14, true, Paragraph.ALIGN_CENTER));

tablazat.addCell(

cella("Névsor", 14, true, Paragraph.ALIGN_CENTER));

Végig kell haladni az adatokon és elő kell állítani a szükséges táblázatcellákat, végül le kell zárni a fájlt:

for(MunkakorLetszamNevsor mln: lista) {

tablazat.addCell(

cella(mln.getMunkakor(), 12, false, Paragraph.ALIGN_LEFT));

tablazat.addCell(

cella(""+mln.getLetszam(), 12, false, Paragraph.ALIGN_CENTER));

tablazat.addCell(

cella(mln.getNevsor(), 12, false, Paragraph.ALIGN_LEFT));

}

pdfFajl.add(tablazat);

pdfFajl.close();

A PDF fájl és a belekerülő táblázatobjektum szerkezete DOM-szerű, illetve azonos a grafikus felhasználói felület felépítése során használt AWT/swing konténerszemlélettel.

A felhasznált programozási tételek: sorozatszámítás, kiválasztás, megszámolás, kiválogatás, illetve kombináltan: csoportosítás, rendezés.

Az eredmény

Az elkészült PDF fájl másfél oldalas, itt letölthető, megtekinthető. A dokumentumról készült képernyőkép:

Továbbfejlesztési lehetőségek

Igényeinktől függően, illetve előzetes tapasztalatainkra és a meglévő tudásunkra építve számos ötlet merülhet fel. Mindhárom tanfolyam esetén testre tudjuk szabni azt az SQL parancsot, ami a szükséges adatokat lekérdezi. Az iText csomag helyett felfedezhetjük a PDF Clown, a PDFBox, illetve a Spire.PDF csomagok funkcionalitását is.

A Java SE szoftverfejlesztő tanfolyam tematikájához kötődve egyszerűbb dolgokat tudunk megvalósítani. Használhatunk további stílusokat: betűre, bekezdésre, cellára, táblázatra vonatkoztatva, színeket, szegélyeket. Többoldalas dokumentum esetén hozzáadhatunk oldalszámot, oldalszám / oldalak száma mezőt, tényleges fej- és láblécet, generálásra vonatkozó időbélyeget, képezhetjük szabály alapján a PDF fájl nevét, illetve tallózhatjuk annak helyét (hol jöjjön létre).
A Java EE szoftverfejlesztő tanfolyam tematikájához kötődve az előzőeken felül elhelyezhetjük a generált fájlt egy szerveren és elküldhetjük e-mailben a letöltéséhez szükséges URL-t. A letöltés korlátozható darabszámmal és időben is (például max. 3 db letöltés lehetséges a következő 48 órán belül). A PDF fájlba belekerülhet szöveges vízjel, céges logó és saját képként dinamikusan előállított grafikon. Például a JFreeChart grafikon készítése projekt swing-es GUI felületéből néhány utasítással készíthetünk JPG vagy GIF formátumú képet, ami könnyen beilleszthető PDF-be. Online, webes API szolgáltatás használatával az előállított PDF fájl tömöríthető, illetve belekerülhet QR kód, vonalkód is.
A Java adatbázis-kezelő tanfolyam tematikájához kötődve az előzőeken felül a JDBC alapú back-end kicserélhető JPA alapúra. A PDF láblécébe beleírhatjuk, hogy az adatbázis-szerveren kinek a nevében futott (DB User) az a lekérdezés, ami előállította a szükséges adatokat. Megoldható a generált PDF egyedi azonosítója, azaz kétszer nem állítható elő „ugyanaz”. Modulárisan továbbfejlesztve gyakorolhatjuk a tudatosan felépített MVC architekturális tervezési minta használatát. Limit feletti méretű PDF fájlt több kisebbre szétdarabolhatunk.

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