többféle megoldás összehasonlítása - címke - Oldal 2 a 8-ből

Kép élesítése effektus működése

2023. december 22.2023. november 20. Szerző: Kaczur Sándor

Ismert számos képfeldolgozó, képjavító effektus. Az egyszerűbb effektusok elérhetők ingyenes web- és mobil alkalmazásokban, PowerPointban. Az összetettebb (művészi) effektusokhoz, szűrőkhöz már érdemes professzionális eszközt használni, ilyen például az Adobe Photoshop. Ezek a belépő szint képeffektusai kulcsszavakban: élesítés (sharpen), homályosítás (blur), elmosódás (gaussian blur), folyadékszerű rajz (liquid), olajfestmény (oil painting), öregítés (sepia), szürkeskála (grayscale).

Lássuk, hogyan valósítható meg Java programozási nyelven a kép élesítése!

A kép adatszerkezete

Adott egy képfájl. Formátuma a tipikus, feldolgozhatók (JPG, GIF, PNG, WebP) egyike. Ezek rasztergrafikus képformátumok. Lekérdezhető a dimenziója: ez képpontban (pixelben) jelenti a kép szélességét (width) és a kép magasságát (height). A vászontechnika meghatározza a kép origóját (0, 0) és a képpontok kétdimenziós koordinátapárját. A kép origója a bal felső sarokban van. A kép oszlopai (column) jobbra haladva növekvő módon, a kép sorai (row) lefelé haladva növekvő módon számozottak. Egy pixel koordinátapárja (c, r) alakban írható le. Minden pixel három szín kombinációjaként áll elő (r, g, b). Másképpen: a piros, zöld és kék összetevők aránya alapján meghatározott. A tipikus színmélység alapján a színek külön-külön 256-félék lehetnek, és ezeket 0-tól 255-ig egész szám képviseli. A 0 az adott szín hiányát, a 255 a szín teljes intenzitását jelenti.

A kép élesítéséhez használható szűrőmátrixok

A kép élesítése során szűrőt alkalmazunk a kép belső pixeleire. A kép 4 szélén lévő pixeleket nem változtatjuk. Többféle szűrő közül választhatunk, íme két példa:

A három színösszetevőre külön-külön kell alkalmazni a szűrőt. Az aktuális pixel – amire alkalmazzuk a szűrőt – a 3×3-as mátrix középső eleméhez igazítva szorzóértékeket tartalmaz. A konkrét eset: az a mátrix esetén az 5 érték a 2. sor 2. oszlopában helyezkedik el; ennek a közvetlen szomszédos pixeleire a -1 értékek, átlós szomszédaira pedig a 0 értékek vonatkoznak. Eredményül a szűrt pixel színeit kapjuk meg külön-külön. Ha a kapott értékek kisebbek 0-nál, akkor nullázzuk őket. Ha a kapott értékek nagyobbak 255-nél, akkor beállítjuk azokat 255-re. Az a szűrőmátrix kevésbé élesít, a b szűrőmátrix erősebben élesít.

Természetesen sok más képélességhez köthető szűrő is van még. Olyanok is vannak, ahol nem csak a közvetlen szomszédos pixeleket veszi figyelembe az algoritmus. További kulcsszavak a témához kötődően: digitális képfeldolgozás, lokális operátor, korreláció, konvolúció, átlagszűrő, mediánszűrő, zajszűrő, Laplace-szűrő.

A kép élesítését megvalósító Java forráskód-részlet

A fenti a mátrixot a SHARP_FILTER konstans kétdimenziós tömb tárolja. A paraméterként átvett BufferedImage típusú img1 objektum kép pixeleinek végigjárását ütközőként segíti a w szélesség és h magasság. A data egydimenziós tömb sorfolytonosan tárolja a kép pixeleit. Az if elágazó utasítás igaz ága kezeli a kép 4 szélét (változatlanul hagyott másolt színek). Az if hamis ága a belső pixelekre alkalmazza a szűrőmátrixot. A red, green, blue változók tartalmazzák az aktuális pixel színeit, amelyekbe az eredeti pixelre alkalmazott szűrő által szorzott értékek kerülnek, „belekényszerítve” a 0-255 zárt intervallumba. Végül az eredményül visszaadott img2 kép pixelei kerülnek beállításra. Az alábbi sharpenEffect() függvény mindezt megoldja az alábbiak szerint:

public static BufferedImage sharpenEffect(BufferedImage img1) {

final int[][] SHARP_FILTER={

{ 0, -1, 0},

{-1, 5, -1},

{ 0, -1, 0}

};

Color[][] colorArray=new Color[3][3];

int w=img1.getWidth(), h=img1.getHeight(), i=0;

int[] data=new int[w*h];

for(int y=0; y<h; y++)

for(int x=0; x<w; x++) {

if(y==0 || x==0 || y==h-1 || x==w-1)

data[i]=img1.getRGB(x, y);

else {

for(int c=y-1; c<=y+1; c++)

for(int r=x-1; r<=x+1; r++)

colorArray[x-r+1][y-c+1]=new Color(img1.getRGB(r, c));

int red=0, green=0, blue=0;

for(int c=0; c<=2; c++)

for(int r=0; r<=2; r++) {

red+=SHARP_FILTER[r][c]*colorArray[r][c].getRed();

green+=SHARP_FILTER[r][c]*colorArray[r][c].getGreen();

blue+=SHARP_FILTER[r][c]*colorArray[r][c].getBlue();

}

red=(red<0)?0:(red>255?255:red);

green=(green<0)?0:(green>255?255:green);

blue=(blue<0)?0:(blue>255?255:blue);

Color c2=new Color(red, green, blue);

data[i]=c2.getRGB();

}

i++;

}

BufferedImage img2=

new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);

img2.setRGB(0, 0, w, h, data, 0, w);

return img2;

}

A metódus meghívása a fájlkezelést is tartalmazó vezérlőmetódusban például így történhet:

public static void main(String[] args) {

try {

BufferedImage imageSource=ImageIO.read(

new File("./images/Traditional-Japanese-Garden.jpg"));

BufferedImage imageSharpen=sharpenEffect(imageSource);

ImageIO.write(imageSharpen, "jpg",

new File("./images/Traditional-Japanese-Garden-sharpen.jpg"));

}

catch(Exception e) {

}

Az eredeti és élesített képek összehasonlítása

A bal oldalon az eredeti kép, a jobb oldalon az a mátrixszal élesített kép látható:

A bal oldalon az eredeti kép, a jobb oldalon a b mátrixszal élesített kép látható:

A látvány alapján fontos kiemelni, hogy másképpen is lehet összehasonlítást végezni. Például: színtérkép, színmélység, színösszetevők aránya (hisztogram).

Ötletek továbbfejlesztésre

Konzolos program átvehetné parancssori paraméterként a szűrőmátrixot, vagy annak nevét, kódját, egyes értékeit.
Grafikus felületű programban vízszinten JScrollBar GUI komponens(ek) segítségével paraméterezhető, kigörgethető lehetne a szűrőmátrix szélsőértéke(i).
A fenti effektek a kép összes pixelét érintik. GUI felületen megoldható az is, hogy ki tudjuk jelölni a kép egy-egy részét, amire alkalmazni szeretnénk az effektek. Ez a kijelölés többféle lehet, például téglalap alakú, szabálytalan, átlátszó, adott vagy adotthoz hasonló árnyalatú színű, vagy valaminek a körvonala.
Egy mappában lévő összes képre alkalmazható effekt, előnézettel, képfájlonként megerősítéssel, jóváhagyással, csoportos kijelöléssel, szűrővel.

Szürkeskála effekt megvalósítása és tesztelése az alábbi forráskód-részlettel:

Color c1=new Color(img1.getRGB(x, y));

int gray=(int)

(0.21*c1.getRed()+0.72*c1.getGreen()+0.07*c1.getBlue());

Color c2=new Color(gray, gray, gray);

Homályosítás effekt megvalósítás és tesztelése a 4 élszomszéd színeinek átlagolásával, így:

Color cTop=new Color(img1.getRGB(x, y-1)),

cRight=new Color(img1.getRGB(x+1, y)),

cBottom=new Color(img1.getRGB(x, y+1)),

cLeft=new Color(img1.getRGB(x-1, y));

int r=(cTop.getRed()+cRight.getRed()+

cBottom.getRed()+cLeft.getRed())/4,

g=(cTop.getGreen()+cRight.getGreen()+

cBottom.getGreen()+cLeft.getGreen())/4,

b=(cTop.getBlue()+cRight.getBlue()+

cBottom.getBlue()+cLeft.getBlue())/4;

Color c2=new Color(r, g, b);

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 Java SE szoftverfejlesztő tanfolyamunkon, a szakmai modul Objektumorientált programozás témakörét követő 29-36. óra Grafikus felhasználói felület alkalmain már tudunk egyszerűbb GUI programot tervezni, kódolni, tesztelni, kiegészítve a 37-44. óra Fájlkezelés alkalmaihoz kötődő példaprogramokkal.

Java program memória használatának mérése

2023. november 2.2023. október 13. Szerző: Kaczur Sándor

Három különböző megközelítésben generálunk szövegeket és töltjük bele ezeket generikus listába. Olyan környezetet építünk, amely képes tesztelni/mérni a Java program/környezet memória használatát előtte/utána. A tárigény (memória, háttértár, feldolgozandó adatok mennyisége, adatforgalom) fontos eleme a hatékonyságnak. Gyakran előfordul, hogy a tárigényt csökkenteni kell egy program tervezése, implementációja vagy továbbfejlesztése során.

Feladat

A Java program előállít 100000 db 20 hosszúságú szöveget véletlen kiválasztott angol ábécé-beli betűkből. A szövegeket generikus listába tölti be. A program méri az általa felhasznált memória méretét/nagyságát úgy, hogy a műveletek előtti és utáni eredményekből különbséget számol. Egyszerű következtetéssel, becsléssel nagy mennyiségű adatra/memóriaterületre számíthatunk, így érdemes megabájt mértékegységet használni.

Közös konstansok

final int MIN_LIMIT=(int)'a';
97, a kis ‘a’ betű, a „legkisebb” generálható véletlen betű/karakter ASCII kódja
final int MAX_LIMIT=(int)'z';
122, hasonlóan a felső korlát
final int STRING_LENGTH_LIMIT=20;
a véletlenszerűen generálandó szövegek hossza
final int STRING_COUNT=1000000;
a véletlenszerűen generálandó szövegek száma, amik generikus listába kerülnek

Három különböző módszer

method1():
Az első módszer esetén String típusú szövegobjektumok keletkeznek úgy, hogy karakterenként kerülnek összefűzésre (konkatenáció) a += művelettel (operátorral). A véletlen karakterek sorszámaira int2char típuskényszerítés szükséges explicit módon (char). A vezérlés egymásba ágyazott ciklusokkal történik.
method2():
A második módszer esetén StringBuilder típusú szövegobjektumok keletkeznek. Szintén karakterenként generálva. Összefűzésüket az append() metódus végzi el. A típuskényszerítés és a vezérlés megegyezik az előző módszerrel.
method3() :
A harmadik módszer során a StringBuilder típusú szövegobjektumokból a Stream API beépített funkcionális műveletei állítják elő a generikus listát. A vezérlés egyetlen ciklusból áll.

Java forráskódok

Íme az első módszert megvalósító metódus. Futtatása 620 MB memóriát igényel:

private void method1() {

List<String> stringList=new ArrayList<>();

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

String generatedString="";

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

generatedString+=

(char)(int)(Math.random()*(MAX_LIMIT-MIN_LIMIT+1)+MIN_LIMIT);

stringList.add(generatedString);

}

//System.out.println(stringList);

}

Ez a második módszer metódusa, amely futása során 235 MB memóriát használ:

private void method2() {

List<String> stringList=new ArrayList<>();

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

StringBuilder generatedString=new StringBuilder();

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

generatedString.append(

(char)(int)(Math.random()*(MAX_LIMIT-MIN_LIMIT+1)+MIN_LIMIT));

stringList.add(generatedString.toString());

}

//System.out.println(stringList);

}

A harmadik módszer metódusa. 494 MB „memóriaterületbe kerül” lefuttatni:

private void method3() {

Random random=new Random();

List<String> stringList=new ArrayList<>();

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

String generatedString=random.ints(MIN_LIMIT, MAX_LIMIT+1)

.limit(STRING_LENGTH_LIMIT)

.collect(StringBuilder::new,

StringBuilder::appendCodePoint, StringBuilder::append)

.toString();

stringList.add(generatedString);

}

//System.out.println(stringList);

}

A metódusok hívása

private long getCurrentlyUsedMemory() {

long totalMemory=Runtime.getRuntime().totalMemory();

long freeMemory=Runtime.getRuntime().freeMemory();

System.gc();

return (totalMemory-freeMemory)/1048576;

}

void run() {

System.out.println("Felhasznált memória, adatok betöltése...");

System.out.println("1. teszt:");

long memoryStart=getCurrentlyUsedMemory();

System.out.println(" előtt: "+memoryStart+" MB");

method1();

long memoryStop=getCurrentlyUsedMemory();

System.out.println(" után: "+memoryStop+" MB");

System.out.println(" különbség: "+(memoryStop-memoryStart)+" MB");

//...

}

Eredmények

A tesztkörnyezet az alábbi eredményeket írta ki konzolosan:

Felhasznált memória, adatok betöltése...

1. teszt:

előtt: 2 MB

után: 622 MB

különbség: 620 MB

2. teszt:

előtt: 16 MB

után: 251 MB

különbség: 235 MB

3. teszt:

előtt: 17 MB

után: 511 MB

különbség: 494 MB

Más nézőpontok

Az is mérhető, hogy a program futása közben hány darab objektum keletkezik, melyik mennyi ideig „él”, melyik mennyi helyet foglal. Ez részletesebb képet nyújthat, összevetve a fenti globális helyfoglalással.
Figyelhető, hogy az automatikus szemétgyűjtő (Garbage Collector) milyen gyakran fut. Némileg befolyásolható, paraméterezhető a tevékenysége.
A forráskód bonyolultsága összefüggésben van annak karbantarthatóságával. Fontos lehet, hogy milyen könnyen dokumentálható, továbbfejleszthető.
A memóriafogyasztás szempontjából „túloptimalizált” program verzióváltás(ok) esetén több tesztelést, módosítást igényelhet. Ha egyáltalán valaki hozzá mer nyúlni. 😉
A memóriahasználat mérése során figyelembe kell venni, hogy a Java programon kívül Java futtatókörnyezet (JRE) is működik az operációs rendszeren, aminek szintén van erőforrásigénye.

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

Bemutattunk többféle módszert, illetve teszteredményeket. Részletes magyarázatot/indoklást most nem adunk a szakmai blogban. A Java SE szoftverfejlesztő tanfolyam szakmai moduljának 17-28. óra Objektumorientált programozás alkalmain természetesen széles körű áttekintést adunk a témakörrel kapcsolatosan, valamint más módszereket is bemutatunk. A hatékonyság klasszikus dimenziói: időigény, tárigény, bonyolultság. Több esettanulmányunk is van, amely egy-egy algoritmus lépésszámát méri, memória- és/vagy sávszélesség igényt mér, illetve elvi és/vagy koncepcionális bonyolultságot próbál meghatározni. Ezek közül többször redukálunk, csökkentünk tipikusan lépésszámot, memóriaigényt.

Kutatók éjszakája 2023

2023. szeptember 29. Szerző: Kaczur Sándor

A Kutatók éjszakája nemzetközi rendezvénysorozat 2005-ben indult. Magyarország 2006-ban csatlakozott. Azóta évről-évre egyre több intézmény nyitja meg hazánkban kapuit, szervez érdekes programokat, sok-sok településen, több száz helyszínen, több ezer eseményt meghirdetve sok tízezer érdeklődő/résztvevő látogatónak biztosít tartalmas estét.

Bár a kezdeményezés elsősorban a kutatói pálya népszerűsítését szolgálja, ezért leginkább a tizen- és huszonévesekre számít, az események vonzók és elég érdekesek ahhoz, hogy a kisgyerekektől a legidősebbekig mindenki megtalálja a számára izgalmas programokat. Korábban nagyobb felsőoktatási intézmények és kutatóintézetek szerepeltek döntően, de az utóbbi néhány évben egyre több kisebb intézmény, tehetséggondozással foglalkozó középiskola, cég, egyesület is csatlakozott a rendezvényhez. A Kutatók éjszakája rendezvény minden meghirdetett programja ingyenes.

Rendezvényünk plakátja

Az it-tanfolyam.hu 2023-ban is hirdetett programokat az eseményhez kötődően. Programjainkat elsődlegesen követőinknek, aktív hallgatóinknak és az alumni csoportunkban hirdettük meg, de persze nyílt rendezvényként valósult meg. Az eseményekre regisztrálni kellett a weblapon. A regisztrációs időszak másfél hétig tartott, szeptember 18-28-ig. Programjainkra szeptember 29-én 21:00-23:55-ig került sor.

21:00-21:30 – Kiss Balázs: Az ipari forradalom evolúciója: ipar 4.0 és 5.0, okos gyár
Az előadó áttekinti az ipari forradalom evolúcióját. Címszavakban: ipar 1.0 – gépek gőzzel/vízzel és ipari termelés (1780), ipar 2.0 – villamosítás és sorozatgyártás (1870), ipar 3.0 – automatizálás számítógépekkel/elektronikával (1970), ipar 4.0 – digitális transzformáció, AI, IoT, adatelemzés, kiberfizikai rendszerek (jelenleg), ipar 5.0 – emberközpontú megközelítés, fenntarthatóság, fokozott ellenálló képesség (legújabb iteráció). Az Európai Parlament 2016-os állásfoglalásából kiindulva, az okos gyárak koncepciójának ismertetésével folytatva, valamint praktikus tanácsok is előkerülhetnek zárásként – igény szerint. Az előadó évek óta foglalkozik okos architektúrák fejlődésének történetével, koncepciójával, szoftveres integrációjával és konfigurációjával. Szívesen osztja meg gondolatait, kutatási eredményeit a témáról, beszél saját kisebb és nagyobb léptékű okos projektjeiről. A program a Java tanfolyamaink orientáló moduljához kötődik.

21:35-22:10 – Kaczur Sándor: Algoritmusok vesebeteg-donorok párosítására
Hogyan működik 2007 óta Nagy-Britanniában a vesebeteg-donorok párosítása? Sima csere 2 pár esetén adódik. 3 pár esetén körbeadják a vesét egymásnak – ez már jóval összetettebb. A felépített óriási adatbázisban akár több száz lehetőség is adódhat. A probléma megfelelő párosítási algoritmus és számítógép nélkül, pusztán emberi erővel megoldhatatlan lenne. Az implementált algoritmus futási ideje mindössze 30 perc. A párosítást követően a következő lépés a műtétek egyidejűsége, és a donor szervek „utaztatása” minden lehetséges földi, vízi, légi úton és lehetséges közlekedési eszközzel. Hogyan működik mindez a gyakorlatban? Milyen korlátok, problémák vannak? Milyen adatok alapján dönthető el a betegek „kompatibilitása”? Ezek közül mi kapcsolódik az egészségügyhöz és a szállításhoz? Az előadó próbál válaszokat adni, de lehet, hogy a végén több lesz a kérdés, mint a válasz. Vajon egyáltalán felmerül a párosítási algoritmus hatékonysága ekkora társadalmi hasznosság mellett? A tavalyi előadás kibővült: újabb algoritmusokkal egészült ki. A program a Java tanfolyamaink orientáló moduljához kötődik.

22:15-22:40 – Kaczur Sándor: Naprendszer szimuláció: elméleti háttér, objektumorientált tervezés, megvalósítás, tesztelés Java és JavaScript nyelveken
Az előadó ismerteti a feladatspecifikációt, ennek objektumorientált tervezését, a térben elhelyezkedő objektumok pozíciójának leképezését a síkra, a tömegvonzás közelítő kiszámítását a modelltérben, és a megjelenítést. A megvalósítás során különböző technológiákat hasonlít össze, például HTML5 canvas és JavaScript, Java2D. A felépítés a szoftverfejlesztés klasszikus lépéseinek megfelel. Némi tesztelés is előkerül. Adódnak továbbfejlesztési lehetőségek is. Elengedhetetlen némi matematikai, fizikai háttér áttekintése látványosan (animáció, szimuláció, gamifikáció) történik. A program a Java SE szoftverfejlesztő tanfolyamunk tematikájához kötődik.

22:45-23:10 – Falus Anita, Tóth-Szabó Tamás, Horváth Zoltán Miklós: Karrierváltás után – az álláskeresés én néhány hónap KKV-s tapasztalatai szoftverfejlesztőként
Mennyire könnyű ma szoftverfejlesztőként elhelyezkedni szakirányú felsőfokú végzettség nélkül? Milyen kihívásokkal találkozhatunk a felvételi folyamat során? Milyen elvárásokat támasztanak a munkaadók egy junior szakemberrel szemben? Hogyan telnek a beilleszkedés után a hétköznapok junior fejlesztőként kis létszámmal működő informatikai profilú kisvállalkozásnál? A tanfolyamainkon 2021-ben és 2022-ben végzett előadók karrierváltó junior szakemberként személyes tapasztalataikról számolnak be és válaszolnak a kérdésekre. A program a Java tanfolyamaink orientáló moduljához kötődik.

23:30-23:55 – Szegedi Kristóf, Hollós Gábor: Gondolkodjunk logikusan!
Az előadás során áttekintjük az intelligencia, a kreatív problémamegoldó és logikus gondolkodás összefüggéseit és izgalmas feladatokból válogatva közösen megoldunk néhány fejtörő feladatot. Néhány példa: Hány éves a kapitány?, CHOO + CHOO = TRAIN, Logikus gondolkodás teszt. Minden feladathoz adunk rávezető példákat – ha esetleg egyik-másik nem menne, akkor ebből ki fog derülni, hogy miket érdemes gyakorolni ahhoz, hogy sikerüljön.

A programjaink népszerűek voltak. 43 érdeklődő látogatót fogadtunk. Többségükben végig velünk tartottak. Elgondolkodtató párbeszéd alakult ki a vesebeteg-donorok párosításáról, valamint sok-sok kreatív ötlet került elő a logikus gondolkodás program fejtörőivel kapcsolatosan. Néhányan megragadták a lehetőséget, hogy több budapesti helyszínt is meglátogassanak – ahogyan ez megszokott a Kutatók éjszakája rendezvényeken hosszú évek óta. Kellemes hangulatban, tartalmasan töltöttük együtt az időt, aminek igazán örülök.

Szeretném megköszönni az előadó oktató kollégák és alumni hallgatóink színvonalas munkáját, igényes felkészülését. Köszönjük mindenkinek, aki részt vett a Kutatók éjszakája 2023 rendezvényünkön. Az előadások prezentációit tanfolyamaink hallgatói számára – a témához kapcsolódó témakörökhöz, ILIAS-ra feltöltve – tesszük elérhetővé.

Születésnap-paradoxon

2023. szeptember 3.2023. szeptember 2. Szerző: Kaczur Sándor

Mennyi a valószínűsége, hogy n ember között van kettő, akiknek egy napon van a születésnapja? A meglepő a dologban az, hogy már 23 ember esetén a kérdéses valószínűség 1/2-nél nagyobb. Másképpen: már 23 ember esetén nagyobb annak az esélye, hogy megegyezik a születésnapjuk, mint az ellenkezőjének. Ez a 23 nagyon kevésnek tűnik. Ezért paradoxon.

Közismert néhány hétköznapi valószínűség. Íme néhány szabályos eset. A pénzfeldobás során 1/2 az esélye a fej és 1/2 az esélye az írás eredménynek (másképpen 50%-50%, azaz fifty-fifty). A kockadobás esetén 1/6 az esélye bármelyik számnak 1-től 6-ig. Két kocka esetén blogoltam már a dobott számok összegének alakulásáról, eloszlásáról: Kockadobás kliens-szerver alkalmazás.

Néhány egyszerűsítés

Az év 365 napból áll. Nem számítanak a 366 napos szökőévek.
A születések eloszlása egyenletes, azaz minden nap körülbelül ugyanannyian születnek. Nem számít, hogy hétköznap, hétvége, ünnepnap. Az áramszüneti városi legendák sem.
Nem vesszük figyelembe az azonos napon született ikreket. Persze ikrek születhetnek különböző napokon is.

Azonos születésnap valószínűsége grafikonon

Lássuk, hogyan alakul az azonos születésnap valószínűsége az emberek számától függően! Grafikonon ábrázolva:

A fenti grafikonhoz szükséges adatok könnyen előállíthatók az alábbi Java forráskóddal:

private static String scatterChartData() {

List<String> list=IntStream.range(1, 71).boxed().

map(n->String.format(Locale.US,

"%10c[ %d, %.4f ]", ' ', n, 1-Math.pow(364.0/365, n*(n-1)/2))).

collect(Collectors.toList());

return String.join(",\n", list);

}

A fenti Google Chart típusú szórásgrafikon (Scatter Chart, korrelációs diagram) megjelenítéséhez adatpárok sorozata szükséges. Ezek a konkrétumok (70 db adatpár), görgethető:

[ 1, 0.0000 ],

[ 2, 0.0027 ],

[ 3, 0.0082 ],

[ 4, 0.0163 ],

[ 5, 0.0271 ],

[ 6, 0.0403 ],

[ 7, 0.0560 ],

[ 8, 0.0739 ],

[ 9, 0.0940 ],

[ 10, 0.1161 ],

[ 11, 0.1401 ],

[ 12, 0.1656 ],

[ 13, 0.1926 ],

[ 14, 0.2209 ],

[ 15, 0.2503 ],

[ 16, 0.2805 ],

[ 17, 0.3114 ],

[ 18, 0.3428 ],

[ 19, 0.3745 ],

[ 20, 0.4062 ],

[ 21, 0.4379 ],

[ 22, 0.4694 ],

[ 23, 0.5005 ],

[ 24, 0.5310 ],

[ 25, 0.5609 ],

[ 26, 0.5900 ],

[ 27, 0.6182 ],

[ 28, 0.6455 ],

[ 29, 0.6717 ],

[ 30, 0.6968 ],

[ 31, 0.7208 ],

[ 32, 0.7435 ],

[ 33, 0.7651 ],

[ 34, 0.7854 ],

[ 35, 0.8045 ],

[ 36, 0.8224 ],

[ 37, 0.8391 ],

[ 38, 0.8547 ],

[ 39, 0.8690 ],

[ 40, 0.8823 ],

[ 41, 0.8946 ],

[ 42, 0.9058 ],

[ 43, 0.9160 ],

[ 44, 0.9254 ],

[ 45, 0.9339 ],

[ 46, 0.9415 ],

[ 47, 0.9485 ],

[ 48, 0.9547 ],

[ 49, 0.9603 ],

[ 50, 0.9653 ],

[ 51, 0.9697 ],

[ 52, 0.9737 ],

[ 53, 0.9772 ],

[ 54, 0.9803 ],

[ 55, 0.9830 ],

[ 56, 0.9854 ],

[ 57, 0.9875 ],

[ 58, 0.9893 ],

[ 59, 0.9909 ],

[ 60, 0.9922 ],

[ 61, 0.9934 ],

[ 62, 0.9944 ],

[ 63, 0.9953 ],

[ 64, 0.9960 ],

[ 65, 0.9967 ],

[ 66, 0.9972 ],

[ 67, 0.9977 ],

[ 68, 0.9981 ],

[ 69, 0.9984 ],

[ 70, 0.9987 ]

Hasonló grafikon készítéséről szintén blogoltam már: Céline Dion – Courage World Tour.

Párok előállítása

Az emberek születésnapjainak összehasonlítása párokban történik. 23 ember esetén 23*22/2=253 pár van. Általános esetben n ember esetén (n*(n-1))/2 pár adódik. A levezetés részletei a források között megtalálható. 59 ember esetén 1711 pár adódik és szinte garantált az előforduló azonos születésnap, hiszen már 0,99 ennek a valószínűsége.

Az alábbi Java forráskód – rekurzív módon – előállítja a 23 konkrét esetre a párokat, az embereket 1-23-ig sorszámozva. Kombinációk:

private static void combinationsInternal(

List<Integer> input, int k,

List<List<Integer>> output,

ArrayList<Integer> acc, int i) {

int needToAcc=k-acc.size(), canAcc=input.size()-i;

if(acc.size()==k)

output.add(new ArrayList<>(acc));

else if(needToAcc<=canAcc) {

combinationsInternal(input, k, output, acc, i + 1);

acc.add(input.get(i));

combinationsInternal(input, k, output, acc, i + 1);

acc.remove(acc.size()-1);

}

public static List<List<Integer>> combinations(

List<Integer> input, int k) {

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

combinationsInternal(input, k, output, new ArrayList<>(), 0);

return output;

}

public static void main(String[] args) {

for(int i=23; i<=23; i++) {

List<Integer> list=IntStream.range(1, i+1).

mapToObj(x->x).collect(Collectors.toList());

List<List<Integer>> combinationList=combinations(list, 2);

Collections.reverse(combinationList);

System.out.println(

i+" db elemből:\n"+

list+"\n"+

combinationList.size()+" db pár:\n"+

combinationList);

}

A main() metódusban az i változó paraméterezhető és a konkrét eset könnyen intervallumra változtatható. Eredményül ezt írja ki a program a konzolra, görgethető:

23 db elemből:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]

253 db pár:

[[1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [1, 7], [1, 8], [1, 9], [1, 10], [1, 11], [1, 12], [1, 13], [1, 14], [1, 15], [1, 16], [1, 17], [1, 18], [1, 19], [1, 20], [1, 21], [1, 22], [1, 23],

[2, 3], [2, 4], [2, 5], [2, 6], [2, 7], [2, 8], [2, 9], [2, 10], [2, 11], [2, 12], [2, 13], [2, 14], [2, 15], [2, 16], [2, 17], [2, 18], [2, 19], [2, 20], [2, 21], [2, 22], [2, 23],

[3, 4], [3, 5], [3, 6], [3, 7], [3, 8], [3, 9], [3, 10], [3, 11], [3, 12], [3, 13], [3, 14], [3, 15], [3, 16], [3, 17], [3, 18], [3, 19], [3, 20], [3, 21], [3, 22], [3, 23],

[4, 5], [4, 6], [4, 7], [4, 8], [4, 9], [4, 10], [4, 11], [4, 12], [4, 13], [4, 14], [4, 15], [4, 16], [4, 17], [4, 18], [4, 19], [4, 20], [4, 21], [4, 22], [4, 23],

[5, 6], [5, 7], [5, 8], [5, 9], [5, 10], [5, 11], [5, 12], [5, 13], [5, 14], [5, 15], [5, 16], [5, 17], [5, 18], [5, 19], [5, 20], [5, 21], [5, 22], [5, 23],

[6, 7], [6, 8], [6, 9], [6, 10], [6, 11], [6, 12], [6, 13], [6, 14], [6, 15], [6, 16], [6, 17], [6, 18], [6, 19], [6, 20], [6, 21], [6, 22], [6, 23],

[7, 8], [7, 9], [7, 10], [7, 11], [7, 12], [7, 13], [7, 14], [7, 15], [7, 16], [7, 17], [7, 18], [7, 19], [7, 20], [7, 21], [7, 22], [7, 23],

[8, 9], [8, 10], [8, 11], [8, 12], [8, 13], [8, 14], [8, 15], [8, 16], [8, 17], [8, 18], [8, 19], [8, 20], [8, 21], [8, 22], [8, 23],

[9, 10], [9, 11], [9, 12], [9, 13], [9, 14], [9, 15], [9, 16], [9, 17], [9, 18], [9, 19], [9, 20], [9, 21], [9, 22], [9, 23],

[10, 11], [10, 12], [10, 13], [10, 14], [10, 15], [10, 16], [10, 17], [10, 18], [10, 19], [10, 20], [10, 21], [10, 22], [10, 23],

[11, 12], [11, 13], [11, 14], [11, 15], [11, 16], [11, 17], [11, 18], [11, 19], [11, 20], [11, 21], [11, 22], [11, 23],

[12, 13], [12, 14], [12, 15], [12, 16], [12, 17], [12, 18], [12, 19], [12, 20], [12, 21], [12, 22], [12, 23],

[13, 14], [13, 15], [13, 16], [13, 17], [13, 18], [13, 19], [13, 20], [13, 21], [13, 22], [13, 23],

[14, 15], [14, 16], [14, 17], [14, 18], [14, 19], [14, 20], [14, 21], [14, 22], [14, 23],

[15, 16], [15, 17], [15, 18], [15, 19], [15, 20], [15, 21], [15, 22], [15, 23],

[16, 17], [16, 18], [16, 19], [16, 20], [16, 21], [16, 22], [16, 23],

[17, 18], [17, 19], [17, 20], [17, 21], [17, 22], [17, 23],

[18, 19], [18, 20], [18, 21], [18, 22], [18, 23],

[19, 20], [19, 21], [19, 22], [19, 23],

[20, 21], [20, 22], [20, 23],

[21, 22], [21, 23],

[22, 23]]

Kísérleti ellenőrzés

Tekintsünk például 1000 esetet! Készítsünk Java programot, amely 23 db véletlen születésnapot generál! Legyen ez a születésnap sorszáma az évben (másképpen hányadik napon született az ember az évben). Ez lényegesen egyszerűsíti a megoldást, összevetve a dátumkezelésen alapuló megközelítéssel. Ajánljuk a szakmai blog dátumkezelés címkéjét az érdeklődőknek, ahol megtalálhatók a témához kapcsolódó Java forráskódrészletek részletes magyarázatokkal kiegészítve. Íme a többféle generikus listát és programozási tételt használó forráskód:

public static void main(String[] args) {

final int COUNT=1000;

ArrayList<String> list1=new ArrayList<>();

int count2=0;

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

ArrayList<Integer> dayList=new ArrayList<>();

for(int n=1; n<=23; n++) {

int day=(int)(Math.random()*365+1); //1-365

dayList.add(day);

}

Collections.sort(dayList);

System.out.println(dayList);

ArrayList<String> list2=new ArrayList<>();

int n=0;

while(n<dayList.size()) {

int currentDay=dayList.get(n), count1=0;

while(n<dayList.size() && dayList.get(n)==currentDay) {

count1++;

n++;

}

if(count1>1)

list2.add(i+","+currentDay+","+count1);

}

if(!list2.isEmpty()) {

list1.add(list2.toString());

count2++;

}

System.out.println("\n"+list1+"\n"+COUNT+" esetből "+

count2+" kedvező eset fordult elő");

}

Érdemes elemezni, tesztelni a fenti forráskódot: milyen lépésekben, milyen adatszerkezeteket épít. Hasznos lehet lambda kifejezésekkel kiegészíteni, módosítani a programot. Részlet a program szöveges eredményéből:

[4, 14, 31, 34, 73, 85, 88, 110, 119, 125, 132, 140, 148, 183, 241, 249, 255, 265, 272, 289, 303, 353, 355]

[7, 16, 40, 67, 72, 72, 79, 89, 96, 128, 141, 142, 203, 215, 217, 219, 230, 243, 250, 272, 273, 321, 325]

[63, 70, 70, 87, 92, 106, 112, 113, 115, 123, 124, 131, 138, 139, 164, 165, 173, 177, 179, 180, 241, 310, 357]

[45, 48, 73, 75, 94, 103, 117, 161, 168, 170, 202, 223, 231, 235, 240, 252, 254, 255, 260, 272, 274, 284, 301]

[2, 2, 3, 13, 39, 47, 66, 94, 148, 151, 153, 160, 161, 166, 179, 212, 223, 254, 280, 311, 316, 324, 340]

[5, 32, 36, 71, 74, 80, 96, 115, 120, 150, 167, 167, 169, 219, 255, 259, 283, 289, 304, 306, 317, 336, 359]

[4, 5, 17, 46, 65, 78, 78, 79, 95, 106, 116, 138, 189, 228, 251, 253, 304, 332, 332, 334, 337, 347, 362]

[12, 14, 15, 67, 76, 77, 113, 126, 154, 161, 184, 195, 204, 214, 216, 225, 225, 225, 227, 229, 235, 236, 348]

[5, 7, 18, 28, 55, 71, 83, 126, 126, 129, 150, 158, 169, 221, 224, 231, 242, 253, 267, 300, 321, 326, 329]

[19, 37, 47, 49, 80, 89, 94, 122, 145, 165, 174, 190, 211, 215, 241, 265, 286, 287, 295, 297, 325, 354, 361]

...

[[2,72,2], [3,70,2], [5,2,2], [6,167,2], [7,78,2, 7,332,2], [8,225,3], [9,126,2]...

1000 esetből 506 kedvező eset fordult elő.

A 12. sorban lévő számhármasok jelentése: esetszám 1-től, azonos nap, előfordulás száma. Például: a kísérlet során a 8. esetben az év 225. napja azonos 3 embernél. Természetesen nincs garancia arra, hogy az 1000 eset vizsgálatánál mindig 500-nál nagyobb kedvező esetet kapunk.

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 alkalmaihoz kötődik.

Források

Születésnap-paradoxon – Wikipédia
Stráhl, I. (2016): Születésnap paradoxon – lesz olyan, aki osztozik a tortán?
Kasnyik, M. (2019): Harmadával kevesebb gyerek születik hétvégéken és ünnepnapokon, mint hétköznap
J. Frost (2020): Answering the Birthday Problem in Statistics
K. Azad (2018): Understanding the Birthday Paradox
Vsause2 (2019): The Birthday Paradox – YouTube
P. Com, M. Habib, T. Suresh, L. Weinstein, C. Lin, J. Khlm, E. Ross (2022): Birthday Problem | Brilliant Math & Science Wiki
Baeldung (2022): Overview of Combinatorial Problems in Java

MAFIOK 2023

2023. augusztus 28.2023. augusztus 25. Szerző: Friedel Attila

A Matematikát, Fizikát és Informatikát Oktatók 44. Országos Konferenciája (MAFIOK 2023) a Neumann év keretében a Neumann János Egyetem GAMF Műszaki és Informatikai Karán, Kecskeméten került megrendezésre 2023. augusztus 23-25-ig.

A konferencia céljai

A rendezvény elsődleges célja annak elősegítése, hogy a felsőoktatási intézmények oktatói és kutatói a matematika, a fizika, az informatika és a logisztika korszerű és hatékony oktatásáról és tudományos eredményeiről előadások, poszter-bemutatók és személyes találkozás révén tapasztalatot cserélhessenek, valamint kapcsolatot építhessenek mind a hazai kollégákkal, mind a környező országok magyar ajkú oktatóival. A rendezvény célja továbbá, hogy fórumot adjunk PhD hallgatók eredményeinek bemutatására.

A konferencia tervezett főbb témakörei

a korszerű matematika-, fizika-, logisztika- és informatikatanítás és tanulás új útjai és távlatai, oktatásfejlesztési tapasztalatai,
a felsőoktatás alapozó tárgyainak oktatás-módszertani problémái,
mesterképzésbe való bekapcsolódás, a duális képzés gondjai és tapasztalatai,
matematika, fizika, informatika, logisztika tudományos eredményei,
új és innovatív kutatási irányok, problémák és gyakorlati alkalmazások bemutatása a fenti tudományterületeken.

A konferencia programja

A letölthető absztraktkötet tartalmazza a program- és szervezőbizottság által összeállított szakmai programot. A szerdai 5 plenáris előadást este bűvészprogram követte. Csütörtökön párhuzamos szekciókat tartottak: Matematika, Matematika oktatása, Fizika, Informatika, Logisztika, valamint poszterbemutató, mindezek után szakmai kirándulás volt Lakitelken a Hungarikum Ligetben planetáriumi bemutatóval, borkóstolóval, vacsorával. Pénteken a Matematika, Informatika szekciók után a konferenciát 2 plenáris előadás zárta. 20-nál több intézményből 100-nál több előadó regisztrált a rendezvényre.

Részt vettünk a konferencián

2023-ban két szakmai előadást tartottunk, 20-20 percben, a csütörtöki Informatika szekcióban.

Szakmai cikkeink a Gradus lektorált, online folyóiratban fognak megjelenni (ISSN 2064-8014), amely eredeti publikációkat közöl számos témakörben, beleértve a természettudományok minden területét, mindenféle műszaki tudományt, számítástechnikát, kertészetet, környezetmérnökséget, pedagógiát, didaktikát és közgazdaságtant. A számítástechnika és a matematika elméleti és alkalmazott területeit is befogadja. A folyóirat csak kutatási cikkeket közöl, és minden cikk az esettanulmányok, kísérletek, vagy a gyakorlatban már alkalmazott megközelítésekkel való szisztematikus összehasonlítások révén előrehaladó ötletek gyakorlati alkalmazását tárgyalja.

Szakmai előadásaink összefoglalói

Kaczur Sándor, Friedel Attila – Hogyan érdemes nagy tömegű adatot importálni Microsoft .NET Framework platformon?

Üzleti alkalmazások fejlesztésénél elengedhetetlen alkotóelem az adatok kezelése, tárolása. Ezt leggyakrabban valamilyen relációs adatbázis-kezelővel valósítják meg a fejlesztők. A hétköznapi munka során gyakran előforduló feladat külső forrásból történő adatok átvétele, aktualizálása. A cikk szerzői arra a kérdésre keresik a választ, hogy hogyan érdemes ezen (néha igen tetemes mennyiségű) adatokat minél gyorsabban átvenni. A bemutatásra kerülő esettanulmány Microsoft .NET Framework segítségével, a platform által kínált adatbázis-kezelési lehetőségek közül válogat. A cikk összehasonlítja a nyelvben már régóta jelen lévő alacsony szintű SQL parancsokkal végzett megvalósítást a később beépített, de szintén elterjedt objektumrelációs modell keretrendszerrel (azaz az Entity Framework-kel) történő megvalósítással, majd elemzi a kapott eredményeket.

Kaczur Sándor, Kiss Balázs – Alkalmazottak életpálya modellje – Java és SQL esettanulmány az Oracle HR sémára építve

Az objektumorientált programozás oktatásának része olyan kliensprogramok tervezése, kódolása és tesztelése, amelyek képesek adatbázishoz csatlakozni. A belépő szint csupán lekérdezés, adatok megjelenítése űrlapokon, táblázatos komponensekben, vagy grafikonokon. Haladó szinten már szükséges az adatok karbantartása is, illetve konzolos, asztali alkalmazásokról át lehet térni webes és mobil platformokra is. A szerzők cikke ebből az útból emel ki egy esettanulmányt, amely Java és SQL nyelveken készült és MVC architekturális tervezési mintát használ. A felhasznált mintaadatok az Oracle HR sémából származnak. Az elemzés betekintést nyújt a modellalkotás lehetőségeibe – többféle megközelítést alkalmazva, elvi és konkrét szinten is.

Az előadásaink témája a Java adatbázis-kezelős tanfolyam szakmai moduljához és orientáló moduljához is kapcsolódik. Az előadásaink prezentációit ILIAS e-learning tananyagban tettük elérhetővé tanfolyamaink résztvevői számára.

Korábbi MAFIOK előadásaink, cikkeink, posztereink

Kaczur S.: Az OracleHRJSP webalkalmazás működése, Matematikát, fizikát és informatikát oktatók (MAFIOK) XXXVIII. országos konferenciája, Pécs, Pécsi Tudományegyetem Pollack Mihály Műszaki és Informatikai Kar, 2014, ISBN 978-963-7298-55-4, p. 121-126 (magyar nyelvű szakcikk)
Kaczur, S.: A Gábor Dénes Tehetségpont programozáshoz kötődő diákműhelyei, Matematikát, fizikát és informatikát oktatók (MAFIOK) XXXVIII. országos konferenciája, Pécs, Pécsi Tudományegyetem Pollack Mihály Műszaki és Informatikai Kar, 2014. augusztus 25-27. (poszter hazai konferencián)
Kaczur, S.; Lengyel, B. I. (előadó: Kaczur, S.): A csomópont kiválasztás algoritmus működését bemutató oktatóprogram PLNC adatátvitel esetén, Matematikát, fizikát és informatikát oktatók (MAFIOK) XXXVIII. országos konferenciája, Pécs, Pécsi Tudományegyetem Pollack Mihály Műszaki és Informatikai Kar, 2014. augusztus 25-27. (poszter hazai konferencián)
Kaczur, S.: Nyílt forráskódú EKG analizáló algoritmusok hatékonysága (Signal analysis), Matematikát, fizikát és informatikát oktatók XXXVI. országos konferenciája (MAFIOK), Gyöngyös, Károly Róbert Főiskola, 2012. augusztus 27-29. (előadás hazai konferencián)
Kaczur, S.; Fintor, K.: Szerkezetföldtani oktatóprogram, vetőmenti elmozdulások modellezésére, Perspective, XV. évfolyam különszám, Szent István Egyetem Gazdasági Kar, 2011, ISSN 1454-9921, p. 215-222 (magyar nyelvű szakcikk)
Fintor, K.; Kaczur, S.: Vetőmozgások 3D-s szimulációjának alkalmazása a földtudományi képzésben, Perspective, XV. évfolyam különszám, Szent István Egyetem Gazdasági Kar, 2011, ISSN 1454-9921, p. 208-204 (magyar nyelvű szakcikk)
Kaczur, S.; Fintor, K. (előadó: Kaczur, S.): Szerkezetföldtani oktatóprogram, vetőmenti elmozdulások modellezésére, Matematikát, fizikát és informatikát oktatók XXXIV. konferenciája (MAFIOK), Békéscsaba, Szent István Egyetem Gazdasági Kar, 2010. augusztus 24-26. (előadás hazai konferencián)
Fintor, K.; Kaczur, S. (előadó: Fintor, K.): Vetőmozgások 3D-s szimulációjának alkalmazása a földtudományi képzésben, Matematikát, fizikát és informatikát oktatók XXXIV. konferenciája (MAFIOK), Békéscsaba, Szent István Egyetem Gazdasági Kar, 2010. augusztus 24-26. (előadás hazai konferencián)
S. Kaczur; S. Kopácsi: Practical application of coordinate and dot transformations, A GAMF Közleményei, Kecskemét, XXIII. évf., 2008, HU ISSN 1587-4400, p. 121-126 (idegen nyelvű szakcikk)
Kaczur, S.; Kopácsi, S. (előadó: Kaczur, S.): Koordináta- és ponttranszformációk alkalmazása a gyakorlatban, Felsőfokú alapképzésben matematikát, fizikát és informatikát oktatók XXXII. Konferenciája (MAFIOK), Kecskemét, Kecskeméti Főiskola, 2008. augusztus 25-27. (előadás hazai konferencián)