matematika - címke - Oldal 2 a 8-ből

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.

Szívgörbe ábrázolása

2025. június 15.2024. február 14. Szerző: Kiss Balázs

Szívgörbét ábrázolunk Java programmal. A Valentin-nap inspirálta ezt a feladatot. Számos matematikai görbe ismert, amelyek szívformához (kardioid) hasonlítanak. Szükséges egy megfelelő paraméteres görbe. A függvény szív formájú ábrája/grafikonja és egyenletrendszere alapján is nagy a választék.

Ábrázoljuk ezt a paraméteres szívgörbét Java swing GUI felületen!

A szívgörbe ábrázolásához felhasználom az StdDraw osztályt, amely ennek a tankönyvnek a példatárából származik: Robert Sedgewick, Kevin Wayne: Computer Science: An Interdisciplinary Approach, 1st edition, Princeton University, Addison-Wesley Professional, 2016, ISBN 978-0134076423. Az osztály metódusaival könnyen beállítható a nézőpont, a vízszintes/függőleges skála, a rajzoláshoz használt toll mérete/színe és a grafikai primitívek közül csak a pont ábrázolása szükséges.

Négy megoldást mutatok. Mindegyik azonos szívgörbét rajzol a fenti egyenletrendszer alapján. Mindegyik metódus átveszi az N paramétert, amely az összetartozó x és y koordinátapárok számát jelenti. Az N db pont meghatározása/kiszámolása szükséges a szívgörbe ábrázolásához. A szívgörbe ábrázolása önálló ablakban – grafikus felhasználói felületen – jelenik meg. A feladat matematikai jellegéből adódik, hogy tipikus a t nevű ciklusváltozó használata. A metódusokat a vezérlés az 512 paraméterrel hívja meg.

1. megoldás

static void heartCurveDraw1(final int N) {

double[] x=new double[N];

double[] y=new double[N];

for(int t=0; t<N; t++) {

x[t]=Math.sqrt(2)*Math.pow(Math.sin(t), 3);

y[t]=-Math.pow(Math.cos(t), 3)-Math.pow(Math.cos(t), 2)+

2*Math.cos(t);

}

for(int t=0; t<N; t++)

StdDraw.point(x[t], y[t]);

}

A heartCurveDraw1() metódus a kiszámolt x és y koordinátákat két párhuzamos, double típusú tömb adatszerkezetben tárolja. A két tömbbe összesen 2*N db double típusú szám kerül. Azonos index jelöli az összetartozó koordinátapárokat. Az egymást követő két ciklus közül az első előállítja az adatszerkezetet és a második megjeleníti a pontokat.

2. megoldás

static void heartCurveDraw2(final int N) {

Point2D[] point=new Point2D[N];

for(int t=0; t<N; t++)

point[t]=new Point2D.Double(

Math.sqrt(2)*Math.pow(Math.sin(t), 3),

-Math.pow(Math.cos(t), 3)-Math.pow(Math.cos(t), 2)+

2*Math.cos(t));

for(int i=0; i<N; i++)

StdDraw.point(point[i].getX(), point[i].getY());

}

A heartCurveDraw2() metódus a párhuzamos tömbök helyett adatszerkezetként egyetlen tömböt használ. A java.awt.geom csomag Point2D osztályú objektumai kerülnek a tömbbe. Mivel a Point2D absztrakt osztály, így a Double() osztálymetódusával (factory method) példányosítható úgy, hogy a szükséges koordinátapárokat megfelelően tudja tárolni. A tömbbe N db objektum kerül.

3. megoldás

static void heartCurveDraw3(final int N) {

for(int t=0; t<N; t++) {

Point2D p=new Point2D.Double(

Math.sqrt(2)*Math.pow(Math.sin(t), 3),

-Math.pow(Math.cos(t), 3)-Math.pow(Math.cos(t), 2)+

2*Math.cos(t));

StdDraw.point(p.getX(), p.getY());

}

A heartCurveDraw3() metódus nem használ tömb adatszerkezetet. Tehát nem emlékszik az összes pont koordinátájára. Ehelyett a ciklus röptében, egyesével létrehozza a pontobjektumokat és azonnal ki is rajzolja azokat (átmeneti az emlékezet).

4. megoldás

static void heartCurveDraw4(final int N) {

IntStream.range(0, N).

mapToObj(t -> new Point2D.Double(

Math.sqrt(2)*Math.pow(Math.sin(t), 3),

-Math.pow(Math.cos(t), 3)-Math.pow(Math.cos(t), 2)+

2*Math.cos(t))).

forEach(p -> StdDraw.point(p.getX(), p.getY()));

}

A heartCurveDraw4() metódus Stream API-t és lambda kifejezéseket használ. Az első N természetes számból készül egy sorozat, amihez röptében hozzákötődik a t-edik Point2D típusú objektum. Ezzel létrejön egy folyam adatszerkezet. Tehát van egy pillanat, amíg a program emlékszik az összes folyambeli pontobjektumra. Végül a folyam feldolgozása, bejárása során egyesével megszólítva a folyam objektumait, a pontok kirajzolódnak a vászonra.

A vezérlés

public static void main(String[] args) {

StdDraw.setPenRadius(0.01);

StdDraw.setPenColor(Color.RED);

StdDraw.setXscale(-Math.PI, Math.PI);

StdDraw.setYscale(-5.0/4*Math.PI, 3.0/4*Math.PI);

//heartCurveDraw1(512);

//heartCurveDraw2(512);

//heartCurveDraw3(512);

heartCurveDraw4(512);

}

Az eredmény

A szívgörbe önálló – swing, grafikus felhasználói felület, GUI – ablakban így jelenik meg:

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 matematikai háttértől eltekintve – a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 21-24. óra: Objektumorientált programozás 2. rész, valamint a 29-36. Grafikus felhasználói felület alkalmaihoz kötődik.

A 2D szívforma egyenletrendszerét erről a weboldalról választottam: Heart Curve – from Wolfram MathWorld. Egy merész továbbfejlesztési ötlet: a haladóknak megtalálható a 3D szívforma ábrázolása is: Heart Surface – from Wolfram MathWorld.

Sándor is blogolt már a Valentin-nap témában: Rómeó és Júlia. Ebből kiderül, hogy vajon ki szereti jobban a másikat: Rómeó vagy Júlia.

Nemzeti pizza nap

2025. június 15.2024. február 9. Szerző: Kaczur Sándor

Az USA-ban és még néhány országban február 9-én ünneplik a nemzeti pizza napot. Ehhez kötődően kreatív ötletekkel és persze finom pizzákkal vonzzák az éttermek a vendégeket.

Kreatív ötletekkel a mi oktatói csapatunk is rendelkezik. A nemzeti pizza nap inspirált bennünket az alábbi feladat megoldására.

Osszunk szét igazságosan 9 db egyforma pizzát 10 fő között!

Az igazságost úgy értelmezzük, hogy mindenkinek ugyanannyi (ugyanakkora szelet) pizza jut. Két megoldást mutatunk be grafikusan. Ötleteket adunk ahhoz, hogyan programozható le mindez Java nyelven: swing grafikus felületen, grafikai primitívekkel vagy ismert algoritmusokkal. Ábrákkal mutatjuk be a megoldásokat, színekkel kiemelve az azonos/különböző méretű pizzaszeleteket.

1. megoldás

Mind a 9 db pizzából vágjunk ki egytized méretű szeletet. Marad 9 db kilenctized méretű pizzaszelet és a 9 db egytizedből összeállítható a 10. főnek járó szintén kilenctized méretű pizzaszelet/adag.

2. megoldás

A 9 db pizzából 5 db pizzát vágjunk ketté. Keletkezik 10 db fél pizza. A maradék 4 db pizzát harmadoljunk fel. Keletkezik 12 db egyharmad pizza. A keletkező 2 db egyharmad pizzát osszuk fel 5-5 részre. Keletkezik 10 db egytizenötöd méretű pizzaszelet. Az egyharmad ötödrésze adja az egytizenötöd részt. A 10 főnek járó adaghoz rakjuk össze a 30 db részből a különbözőket: egy adag kilenctized, ami egy fél és egy harmad és egy tizenötöd részből áll össze. Másképpen: 9/10 = 27/30 = 15/30 + 10/30 + 2/30.

Ötletek a Java nyelvű megvalósításhoz

A JFrame osztályból származtatott ablak utódosztály tartalompaneljére ráhelyezhető egy öröklődés útján testre szabott JPanel utódosztályból létrehozott objektum. Ennek van grafikus vászna ( Graphics objektum), amely saját koordináta-rendszerrel és pixelszintű hozzáféréssel rendelkezik. Rendelkezésre áll számos grafikai primitív rajzolására használható metódus, például vonal/szakasz, téglalap, ellipszis. A grafikai primitíveknek rajzolható adott színű körvonala és lehetnek adott színnel kitöltöttek is. Például: drawArc(x, y, width, height, startAngle, arcAngle), vagy az azonos paraméterezésű fillArc(...) metódus. A két szög értelmezése: a startAngle az analóg órán a 3 óra irányába néz, valamint az arcAngle pozitív szög fokban megadva az óramutató járásával ellenkező irányba mutat.
A beépített grafikus primitívek helyett használhatunk klasszikus algoritmusokat is. Például a Bresenham vonalrajzoló algoritmus, vagy ennek általánosítása a Bresenham körrajzoló (felezőpont) algoritmus. Ezekhez hasznos némi koordináta-geometria és többféle koordináta-rendszer ismerete.

Ötletek továbbfejlesztéshez

Megpróbálhatjuk általánosítani a problémát: osszunk szét igazságosan n db egyforma pizzát n+1 fő között!
A statikus képek előállítását követően időzítéssel ellátott animációt is készíthetünk, amely megfelelően mozgatja, forgatja a pizzaszeleteket. Így fázisonként megmutathatók a feladat megoldásának lépései. Ehhez többrétegű vászontechnika szükséges, amelyen könnyen mozgatható a nézőhöz közelebbi réteg úgy, hogy a háttér nem változik meg.
A saját rajzolt elemek időzítővel – javax.swing.Timer – történő mozgatására példáink java.swing-ben: Hóesés szimuláció és Naprendszer szimuláció – megvalósítás Java nyelven.
A saját rajzolt elemek kézi – eseménykezelővel megvalósított – mozgatásához felhasználható példánk JavaFX-ben: Kígyókocka grafikus felületen.
A fázisokból lépésenként vezérelhetően felépülő ábrák elkészítéséhez példáink: Fibonacci-spirál és Koch-görbe rajzolása.

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

Doktoranduszok programoznak – újratöltve

2024. január 5.2024. január 5. Szerző: Kiss Balázs

it-tanfolyam.hu doktoranduszok programoznak

Saját doktorandusz csoporttársaimmal én is többször beszélgettem már arról – ahogyan Sándor is tette 2018-ban –, hogyan tudnák/tudják használni a programozás eszköztárát, módszereit, lehetőségeit saját kutatási munkájukban, beépítve a kutatási folyamat egyes lépéseibe, illetve disszertációjuk elkészítésébe.

A 7 fős csoportban mindenkinek más az alapvégzettsége, így szoftverfejlesztéshez, programozáshoz közös szókincs és terminológia haladó szinten természetesen nincs, viszont közös bennünk, hogy mindannyian alkotunk különféle modelleket és elemzünk adatokat. A csoport teljesen inhomogén, több szempontból is: ki melyik évfolyamot végzi, hol tart a kutatómunkájában, vannak-e ipari kapcsolatai, nappali vagy levelező képzésben végzi tanulmányait és persze ki mikor ér rá.

Különféle modelleket alkotunk

a mérnökök, fizikusok, geográfusok, biológusok többféle kísérletet végeznek el, szimulációkat terveznek és futtatnak, mérőeszközöket és műszereket használnak,
az informatikusok különböző matematikai eszközöket alkalmazva objektumorientált – vagy másféle – modellezést végeznek, szoftvereket terveznek, javítanak, újraírnak.

Adatokat is elemzünk, ki-ki előképzettségének megfelelően

kérdőívező szoftverekből exportálva valamit,
Excel munkalapokon, függvényekkel, adatbázis-kezelő funkciókkal, kimutatásokkal (Pivot táblák),
különböző fájlformátumokkal (CSV, XML, JSON, egyedi) dolgozunk és konvertálunk A-ból B-be,
távoli adatbázisokhoz, felhőbeli adattárházakhoz csatlakozunk, lekérdezünk és kapunk valamilyen – többnyire szabványos – adathalmazt,
matematikai, statisztikai szoftvereket használunk, például: MATLAB, Derive, Maple, SPSS.

Az öt évvel ezelőtti tematikát újragondoltuk. Kérdőívben felmértük a csoporttársak koncepcionális és konkrét igényeit. Más doktori iskolák hallgatói közül is toboroztunk. Ehhez kötődően köszönjük a DOSZ segítségét. Ezek alapján összeállítottunk egy olyan 3 részből álló tematikát, ami mindannyiunk számára hasznos. A 72 óra három 24 órás modulból áll: Java programozás, MATLAB programrendszer, mesterséges intelligencia.

Java programozás modul

1-6. óra: Objektumorientált modellezés, MVC rétegek, algoritmus- és eseményvezérelt programozás
7-12. óra: Fájlkezelés és szövegfeldolgozás (XLS, CSV, XML, JSON formátumú adatok írása, olvasása, feldolgozása), helyi és távoli adatforrásból
13-18. óra: Adatbázis-kezelés JDBC alapon (SQL parancsok, CRUD műveletek, hierarchikus lekérdezések), helyi és távoli adatforrásból, natív módon és készen kapott API-kkal
19-24. óra: Komplex adatfeldolgozási feladatok megoldása programozási tételek használatával, egyszerű statisztikai funkciók implementálásával

MATLAB programrendszer modul

1-6. óra: Bevezetés az MATLAB nyelvbe (R2012 vs. R2022), utasításkészlet, vektorok, mátrixok, szkriptek, függvények, grafika
7-12. óra: Szimulációk tervezése és készítése, numerikus módszerek áttekintése, algoritmizálása, tesztelés, analitikus megoldás, egyenletek megoldása
13-18. óra: Adatok importálása helyi és távoli adatforrásból is, fájlkezelés: szövegfájlok, Excel-fájlok, import, feldolgozás, export, statisztikai alapok
19-24. óra: Statisztikai próbák (illeszkedés- és függetlenség vizsgálata), hisztogramok készítése, differenciálegyenletek megoldása

Mesterséges intelligencia modul

1-6. óra: Klasszikus és újabb megközelítések, alap AI funkcionalitás, megerősítéses és gépi tanulás lehetőségei és korlátai, OpenAI GPT nyelvi modell
7-12. óra: Általános csevegés lehetőségei, korlátai, hasznos tanácsok; csevegés fájlok (szöveg, multimédia) tartalmáról; generatív AI funkciói; kép, ábra, grafikon, térkép, hang, animáció, videó generálása és ezek tömeges feldolgozása; programozási tételek alkalmazása multimédia analitikával együtt
13-18. óra: Statisztikai adatok elemzése AI eszközökkel, automatikus tételbizonyítás AI eszközökkel, gráfelméleti kérdések kontra AI, hatékonysághoz kötődő kérdések AI eszközök esetén
19-24. óra: Objektum- és aspektusorientált tervezés AI eszközökkel, kutatómunkát támogató AI eszközök

Mivel mindenki doktorandusz a csoportban, így a különböző MSc-s alapvégzettsége ellenére mindannyiunknak vannak strukturális programozáshoz kötődő alapismeretei, valamint adatok elemzéséhez szükséges elméleti matematikai/statisztikai alapjai.

A csoport órái szeptembertől decemberig, szombatonként zajlottak. Sándor tartotta a 24 órás Java programozás modult. Ez nagyban lefedi a Java SE szoftverfejlesztő tanfolyamunk tematikáját és kapcsolódik a Java EE szoftverfejlesztő tanfolyamunk és a Java adatbázis-kezelő tanfolyamunk tematikájához is. Én tartottam a 24 órás MATLAB programrendszer modult. Ketten közösen tartottuk a 24 órás Mesterséges intelligencia modult. Igazán tartalmas őszi időszakot jelentett számunkra ez a 12 szombat. Mindenki elvitte, amit beletett.

A koncepciót once-in-a-lifetime jelleggel dolgoztuk ki 🙂 (újratöltve) azzal a fő szándékkal, hogy hatékonyabban működjünk együtt a jövőben. A visszajelzések alapján bátran állíthatom, hogy ez gördülékenyen fog menni. Egyben köszönöm mindenkinek az aktív, konstruktív részvételt.

Kölcsönös ajándékozás véletlenszerűen

2025. június 15.2023. december 1. Szerző: Kaczur Sándor

A kölcsönös ajándékozás időről-időre több közösségben is felmerül. Munkahelyi környezetben és iskolai csoportokban is (például: Télapó, karácsony). Hagyományos megközelítésben így hangzik a szabály: „húzzunk neveket a kalapból”. Másképpen: mindenki 1 ajándékot ad, mindenki 1 ajándékot kap és a sorsolás véletlenszerűen történik.

Készítsünk Java programot, ami megoldja a kölcsönös ajándékozást véletlenszerűen!

A neveket tároljuk el szövegfájlban ( nevsor10.txt). Soronként egy nevet. Ha különböznek, akkor elegendő a keresztnév. A soroknak/neveknek különbözniük kell. Ha szükséges, akkor hozzáírjuk a vezetéknevet, a vezetéknév első betűjét vagy sorszámot. Ezt a program beolvassa és megjegyzi egy szöveg típusú generikus nevsorLista nevű indexelhető adatszerkezetben. A nevek eredeti sorrendje nem befolyásolja a kiválasztást, mert a neveket a program összekeveri (helyben, véletlenszerűen, a shuffle() metódussal). Adott elemszámú lista indexelhető nullától elemszám-1-ig ( size()-1-ig).

List<String> nevsorLista=Files.readAllLines(

Paths.get(new File("./files/nevsor10.txt").getPath()));

Collections.shuffle(nevsorLista);

A szövegfájl olvasása, tartalmának betöltése során – az ékezetes karakterek miatt – előfordulhatnak karakterkódolási problémák. Ekkor használható a readAllLines() függvény túlterhelt változata esetén a Charset típusú második paraméter, például így: Charset.forName("ISO-8859-2"). A fájlkezeléshez kötelezően kivételkezelés is szükséges (ezt most nem részletezem).

1. megoldás

Az ajándékot adó-kapó párosokat a listában egymás mellett lévő i-edik (bal) és i+1-edik (jobb) nevek adják. Az adó az elsőtől az utolsó előttiig, a kapó a másodiktól az utolsóig léptethető. Kimarad az a pár, amikor az utolsó ad és az első kap. A lista indexei szerint az adók esetében a nulladik elemétől az utolsó előtti eleméig és a kapók esetében a lista első elemétől az utolsó eleméig jelenti a kiválasztást. Mindez könnyen megoldható for számláló ciklussal. A kimaradó pár ajándékot adó tagja a lista size()-1-edik eleme és kapó tagja a lista nulladik eleme. Ez a ciklus után egyszerű kiírással megoldható.

System.out.println("Ajándékozás\nNévsor: "+nevsorLista);

for(int i=0; i<=nevsorLista.size()-2; i++)

System.out.println(

nevsorLista.get(i)+" ad -> "+

nevsorLista.get(i+1)+" kap");

System.out.println(

nevsorLista.get(nevsorLista.size()-1)+" ad -> "+

nevsorLista.get(0)+" kap");

2. megoldás

A program átmenetileg megváltoztatja a listát: az utolsó elem után bővül az első elemmel ( nevsorLista.add(nevsorLista.get(0))). Ennek köszönhetően az ajándékot adó-kapó párosokat a listában egymás mellett lévő lévő i-edik (bal) és i+1-edik nevek adják. Most nem lesz kimaradó pár, mert a korábbi utolsó elem most az utolsó előtti elem és az utolsó elem most az első. Másképpen: mindenki ad és mindenki kap.

A megoldás Stream API-t használ. Először előállít egy olyan IntStream típusú folyamot, amiben az ajándékot adó és kapó párosok adó (bal) tagjainak sorszámát/indexét tartalmazza. Ezután ezt végigjárva összefűzi a szövegeket ( mapToObj()) úgy, hogy a páros kapó (jobb) tagja az adó tag rákövetkezője. Végül a program kiírja a összefűzött szövegeket ( forEach()) a konzolra. Ha a neveket tartalmazó listát használnánk később még valamire (azaz kellene az eredeti összekevert állapota), akkor érdemes aktiválni a megjegyzésbe tett utolsó utasítást.

System.out.println("Ajándékozás\nNévsor: "+nevsorLista);

nevsorLista.add(nevsorLista.get(0));

IntStream.range(0, nevsorLista.size()-1).

mapToObj(i -> String.format("%s ad -> %s kap",

nevsorLista.get(i), nevsorLista.get(i+1))).

forEach(System.out::println);

//nevsorLista.remove(nevsorLista.size()-1);

Eredmény

A program konzolos/szöveges eredménye mindkét esetben azonos. Persze a nevek sorrendje különbözhet, hiszen az összekeverés minden futtatás esetén másképpen alakul(hat), mert véletlenszerű. Például:

Ajándékozás

Névsor: [Károly, Anna, Máté, Péter, Zoltán, Éva, Anikó, András, Lilla, Krisztina]

Károly ad -> Anna kap

Anna ad -> Máté kap

Máté ad -> Péter kap

Péter ad -> Zoltán kap

Zoltán ad -> Éva kap

Éva ad -> Anikó kap

Anikó ad -> András kap

András ad -> Lilla kap

Lilla ad -> Krisztina kap

Krisztina ad -> Károly kap

Érdemes tesztelni és átgondolni, hogy mi történne, ha üres a fájl, üres a generikus lista, 1 név van, 2 név van, illetve nem szabadna ilyet, de mi történne azonos nevek esetén. Vajon különbözik/különbözne a fenti két megoldás eredménye? Miért?

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 17-28. óra Objektumorientált programozás és 37-44. óra: Fájlkezelés alkalmaihoz kötődik.