algoritmus - címke - Oldal 2 a 7-ből

Galéria véletlen sorrendben

2023. november 2.2023. augusztus 11. Szerző: Kiss Balázs

Adott egy mappában lévő sok-sok képfájl, többféle formátumban, kiterjesztéssel. A feladat az, hogy időzítve jelenítsük meg ezeket a képeket véletlen sorrendben saját fejlesztésű Java program segítségével. A tervezés során áttekintünk többféle lehetőséget. Bemutatjuk a megoldáshoz szükséges lépéseket és a program működését.

A program tervezése

A szükséges bemeneti adatok

Egy mappa, abszolút vagy relatív útvonal, ahol a képfájlok megtalálhatók. A mappa átvehető a program paramétereként (ha parancssorban meghívva átadjuk) vagy lehet az aktuális mappa (ahonnan a programot jar fájlként elindítjuk). A program a mappában közvetlenül megtalálható képeket olvassa be. Az ott található almappákba nem megy bele.
A képfájlok különböző kiterjesztéseit tárolni kell. Többféle is lehet, így ehhez szükséges alkalmas adatszerkezet. A listában nem szereplő kiterjesztéssel rendelkező fájlok nem kerülnek feldolgozásra.
Érdemes a képfájlokat egy lépésben betölteni a memóriába. Így a program takarékos erőforrásként bánik a tárhellyel (merevlemez, pen-drive, SSD, hálózati meghajtó). Csak egyszer dolgozza fel (olvassa végig) a mappát. Feltételezzük, hogy a képfájlok beférnek a memóriába.
A program teljes képernyős, amiből elérhető a rendelkezésre álló terület mérete, ahol megjeleníthetők a képek. A program a betöltött képfájlok méreteihez is hozzáfér. Ez a méret kétféle lehet: bájtban kifejezhető a képfájl elfoglalt tárhelye, illetve pixelben kifejezhető a képfájl dimenziója (másképpen a megjelentéséhez szükséges terület mérete a képernyőn).

Hogyan működik a program?

Egyszerre egy kép jelenik meg. Időzítő befolyásolja a képfájlok közötti váltást. Meghatározza, hogy a képfájlok meddig látszanak (másképpen: eltelt idő, késleltetés, várakoztatás). A swing GUI-hoz tartozó időzítőt kell hozzá használni.
A program alkalmazkodik a képernyő, kijelző felbontásához, képarányához. A program végtelenítve működik, Alt + F4 billentyűkombinációval lehet kilépni belőle.
A képfájlok megjelenítésük során optimálisan, dinamikusan kitöltik a rendelkezésre álló téglalap alakú területet. A túl kicsi képeket nagyítani kell. A túl nagy képeket kicsinyíteni kell. Mindezt úgy, hogy a képarányt (aspect ratio) meg kell tartani, hogy a képek ne torzuljanak el. Az alábbi három példa balról-jobbra mutatja az optimális kitöltést, illetve azt a két esetet, ami akkor történik, amikor a kép méretéhez képest a megjelenítésre használható terület túl magas vagy túl széles:
A galériába tartozó képek közötti véletlen sorrendet meg kell oldani. A program a memóriába betöltött képek sorszámai alapján valósítja meg a véletlenszerű kiválasztást. A sorszámok összekeverednek. Egymás után nem jöhet ugyanaz a kép többször. Ha a képek „elfogynak”, akkor a program végtelenített működése szerint a képek sorszámai újra összekeverednek és „lejátszásra kerülnek”.

A program megvalósítása

A mappát a java.io csomag File osztályából létrehozott folder objektum tárolja (a "./" szövegliterál jelöli az aktuális mappát). A feldolgozandó képfájlok kiterjesztéseinek listáját egy dinamikus tömbből létrehozott generikus lista oldja meg: ArrayList<String> imageFileExtensionList=new ArrayList<>(Arrays.asList("JPG", "JPEG", "PNG", "GIF")). Egy képfájl memóriabeli tárolását a java.awt.image.BufferedImage típus valósítja meg, amelyekből szintén generikus lista épül: ArrayList<BufferedImage> imageList. A grafikus felhasználói felülethez tartozó javax.swing csomagbeli Timer osztály szükséges, például 2 mp-es várakoztatás és eseménykezelés: timer=new Timer(2000, (ActionEvent) -> { showRandomImage(); }). A GUI JFrame leszármazott keretobjektum. A grafikus felhasználói felület a teljes képernyőt elfoglalja: setExtendedState(MAXIMIZED_BOTH) és setUndecorated(true). A keretre egyetlen JLabel típusú, fekete hátterű lbImage objektum kerül, az alapértelmezett határmenti elrendezésmenedzser közepére (vízszintesen és függőlegesen egyaránt). A képfájlok sorszámai (a későbbi véletlen kiválasztáshoz) az imageIndexList generikus listába/kollekcióba kerülnek. Az index változó jelöli az aktuális, memóriába betöltött képfájl sorszámát, ami kezdetben nulláról indul.

A képfájlok betöltése az alábbiak szerinti:

private void createImageList() {

File[] imageArray=folder.listFiles((File path) -> {

String extension=path.getName().toUpperCase().

substring(path.getName().lastIndexOf(".")+1);

return imageFileExtensionList.contains(extension);

});

try {

for(int i=0; i<imageArray.length; i++) {

imageList.add(ImageIO.read(imageArray[i]));

imageIndexList.add(i);

}

Collections.shuffle(imageIndexList);

}

catch(IOException e) {

}

A fájlok kiterjesztésének szűrése a FileFilter interfész accept() metódusának megvalósításával történik. A fenti forráskódban mindez tömör, lambda kifejezéssel (művelettel) valósul meg. A fájlszűrőn az képfájl megy át, aminek a nagybetűssé alakított kiterjesztését tartalmazza az imageFileExtensionList kollekció. Az i-edik képfájl memóriába való betöltését az ImageIO osztály statikus read() függvénye oldja meg. A képfájlok sorszámainak véletlen összekeverése kezdetben megtörténik: Collections.shuffle(imageIndexList). A fájlkezelés miatt kötelező kivételkezelést most – itt a szakmai blogban – nem részletezzük.

Az időzítő eseménykezelése, a 2 másodpercenkénti képváltás így valósul meg:

private void showRandomImage() {

BufferedImage img=imageList.get(imageIndexList.get(index));

Dimension d=getScaledDimension(new Dimension(

img.getWidth(), img.getHeight()), lbImage.getSize());

ImageIcon imageIcon=new ImageIcon(img.getScaledInstance(

(int)d.getWidth(), (int)d.getHeight(), Image.SCALE_SMOOTH));

lbImage.setIcon(imageIcon);

index++;

if(index==imageIndexList.size()) {

Collections.shuffle(imageIndexList);

index=0;

}

A program alábbi metódusa felel a képarányhoz kötődő műveletekért:

private Dimension getScaledDimension(

Dimension imageSize, Dimension area) {

double widthRatio=area.getWidth()/imageSize.getWidth();

double heightRatio=area.getHeight()/imageSize.getHeight();

double ratio=Math.min(widthRatio, heightRatio);

return new Dimension((int)(imageSize.width*ratio),

(int)(imageSize.height*ratio));

}

A program tesztelése

Érdemes lehet tesztelni nem ajánlott (rossz) megoldásként azt, hogy a program az időzítőnek megfelelően, dinamikusan olvasná be a képfájlokat, amivel lényegesen kevesebb memóriát igényelne.
Van-e reális korlát arra, hogy mennyi, mekkora képek „férnek el” a memóriában?
Hogyan befolyásolja a képfájlok száma és az általuk elfoglalt tárhely a program indulását?
Mi történik, ha nincs megfelelő kiterjesztésű képfájl a mappában? És ha több 1000 kép van benne?
Hogyan jelennek meg (megjelennek-e) az animációt tartalmazó képfájlok? Például a GIF képformátum nem csak statikus egyetlen képet tartalmazhat, hanem lehet animált is.
Teljesen megvalósul-e a reszponzivitás? Ha igen, mi indokolja? Ha nem, miért nem és hogyan lehetne megoldani?

Ha átmenetileg kikapcsoljuk a teljes képernyős megjelenítést, akkor könnyen tesztelhetővé válik a megvalósuló reszponzivitás. Másképpen a program dinamikusan alkalmazkodik a rendelkezésre álló (rajzolható) terület méreteihez (szélesség és magasság):

A program továbbfejlesztési lehetőségei

A program rekurzívan bejárhatná a folder által megjegyzett útvonalból kiindulva a teljes (al)mappaszerkezetet.
A program paraméterezhető lehetne a képfájlok kiterjesztéseivel. Akár konfigurációs fájlból is beolvashatná az imageFileExtensionList adatszerkezetet, például XML, JSON formátumban is.
A program ellenőrizhetné, hogy a mappában lévő összes kép befér-e a memóriába. A program kezelhetne ehhez kötődően többféle limitet: például az első 100 db képet töltené be, és/vagy csak annyi képet tölt be, ami belefér például 64 MB-ba.
A program mutathatná folyamatindikátorral induláskor a képfájlok betöltését. Vagy betölthetné például az első 5 db-ot és háttérszálon a többit, amíg az első 5-öt „lejátssza”.
Ha például a program 10 képet tölt be mappában lévő képfájlokból, akkor ezek 0-tól 9-ig sorszámozódnak. A sorszámok összekeverve következnek. Ha az első menetben az utolsó kép sorszáma például a 7 volt, akkor a következő ismétlődő menet nem kezdődhetne 7-tel.
A programból ki lehetne lépni az Esc billentyűvel is. KeyListener interfésszel megoldható.
A program kezelhetne egyéb képfájlformátumokat is: például animált GIF, statikus WebP, animált WebP.
A program könnyen kiegészíthető prezentációk diáinak időzített/felülbírált megjelenítésére.
A program által beolvasott képfájlokból generálható PDF fájl is (rácsos sablonnal, például 6 db kép laponként). A feldolgoztt mappában lévő képfájlok könnyen feltölthetők FTP szerver adott mappájába, átméretezhetőek csoportosan, elküldhetők nyomtatási sorba is.
Érdemes megismerni a JDK-n kívüli egyéb, képfájlokat kezelő osztályok, csomagok funkcióit, például: OpenIMAJ, TwelveMonkeys ImageIO.
A swing-es felület kiegészíthető mappatallózással, egyéni fájl(típus)szűrőkkel, paraméterezhető lehet a véletlenszerű kiválasztás algoritmusa, változtatható az időzítés késleltetése.
Mivel a program teljes képernyős, így elrejthető az egérmutató.
A képek „lejátszásából” lehetne generálni animált GIF-et.

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 animációs, szimulációs programot tervezni, kódolni, tesztelni.

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

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

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

5. feladat

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

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

1. megoldás

private void lnko1(int aa, int bb) {

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

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

while(m!=0) {

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

a=b;

b=m;

m=a%b;

}

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

int lnko=b;

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

}

else

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

}

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

504 = 1 * 420 + 84

420 = 5 * 84 + 0

lnko (420; 504) = 84

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

2. megoldás

private List<Integer> primtenyezok(int n) {

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

if(n>0)

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

while(n%i==0) {

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

primtenyezokLista.add(i);

n/=i;

}

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

return primtenyezokLista;

}

private String primtenyezokSzorzatkent(

List<Integer> primtenyezok) {

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

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

}

private void lnko2(int a, int b) {

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

List<Integer> aPrimtenyezok=primtenyezok(a);

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

// primtenyezokSzorzatkent(aPrimtenyezok));

List<Integer> bPrimtenyezok=primTenyezok(b);

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

// primtenyezokSzorzatkent(bPrimtenyezok));

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

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

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

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

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

if(minEgyediPrimDb>0)

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

kozosPrimtenyezok.add(prim);

});

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

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

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

}

else

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

}

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

420 | 2

210 | 2

105 | 3

35 | 5

7 | 7

1 |

420 = 2 * 2 * 3 * 5 * 7

504 | 2

252 | 2

126 | 2

63 | 3

21 | 3

7 | 7

1 |

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

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

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

Érdemes átgondolni

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

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

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

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

Kutatók éjszakája 2022

2023. augusztus 4.2022. szeptember 30. 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 2022-ben 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 két hétig tartott, szeptember 16-29-ig. Programjainkra szeptember 30-án 21:00-23:55-ig került sor.

21:00-21:35 – Kiss Balázs: Mi az ipar 4.0? Mi az okos gyár?
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. Praktikus tanácsok is előkerülhetnek – igény szerint. Egyensúlyoz a kész komponensek testre szabási lehetőségei és a saját fejlesztés határán. Utóbbi kulcsszavai: hálózati kommunikáció megvalósítása szerver-kliens között vagy peer-to-peer többféle programozási nyelven, autentikáció, autorizáció, protokoll, tömörítés, felhő architektúrák, robotika, robotprogramozás. Az előadó ismerteti az Európai Parlament 2016-os állásfoglalásából kiindulva, hogy milyen mérföldkövek voltak és jelenleg hol tartunk az ipar 4.0 és az okos gyárak tekintetében és mi várható a közeljövőben. A program a Java tanfolyamaink orientáló moduljához kötődik.

21:40-22:15 – Kaczur Sándor: Algoritmus 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 probléma. 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 úton – földön, vízen, levegőben –, minden 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 mi 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 program a Java tanfolyamaink orientáló moduljához kötődik.

22:20-22:55 – Hollós Gábor: Objektumorientált programozás vs. funkcionális programozás Java nyelven
Az előadó ismert adatszerkezeteket és ismert programozási tételeket használva összehasonlítja a hatékonyság szempontjai alapján egy-egy feladat különböző megvalósításait. Referenciaként tekint az objektumorientált megoldásokra és ehhez képest kiderül, hogy a Java 8-tól elérhető funkcionális elemek milyen változásokat jelenthetnek. Vajon kevesebb memóriát használnak? Gyorsabbak? Egyszerűbbek/bonyolultabbak? Könnyebben megérthetőek, karbantarthatóak, dokumentálhatóak? Hogyan érdemes egyensúlyozni az általunk leprogramozott, a kollekciók hagyományos beépített műveleteit használó és a lambda kifejezések között? Kiderül. A program a Java SE szoftverfejlesztő tanfolyamunk tematikájához kötődik.

23:00-23:25 – Németh András, Tóth-Szabó Tamás: Karrierváltás utá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 2020-ban és 2021-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: 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. Közel 40 érdeklődő látogatót fogadtunk. Többségükben végig velünk tartottak. Néhányan kifejezetten egy-egy adott program iránt érdeklődtek és már késő délutántól úton voltak kora hajnalig. 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ó 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 2022 rendezvényünkön. Az aktív kérdező csapatot külön is kiemelem. 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é.

Tankocka – Szókereső: rendezési algoritmusok

2023. november 2.2022. szeptember 1. Szerző: Kiss Balázs

Folytatjuk Tankockák blog bejegyzés sorozatunkat. A feladatban 8 db rendezési algoritmus nevét kell megtalálni a szókeresőben. Ez a témakör főként a Java SE szoftverfejlesztő tanfolyamunkhoz kötődik. A rendezési algoritmusok alapvető működését akkor is érdemes ismerni, ha tudjuk, hogy van sokféle beépített, implementált megoldás a Java JDK-ban, a Stream API-ban.

Érdemes tudni jellemezni a rendezési algoritmusokat a hatékonyság klasszikus szempontjai alapján: lépésszám, tárigény, bonyolultság. Azt is hasznos tudni, hogy egyes beépített rendezési algoritmusok hogyan működnek. Valójában milyen implementált algoritmus fut, ha meghívunk például egy sort() metódust, vagy egy ORDER BY záradékot? Többféleképpen csoportosíthatók a rendezési algoritmusok: vannak iteratívak és rekurzívak, helyben rendezők és kiegészítő helyet használók, egyszerűek (buták) és optimalizáltak (ellenőrzéseket végzők). Ezeken kívül a rendezési algoritmusok futása során létezik legrosszabb eset, átlagos eset, legjobb eset. Hasznos teljes képernyőn megjeleníteni ezt a tankockát.

Tankocka – Keresztrejtvény: programozási tételek

2023. augusztus 3.2022. augusztus 1. Szerző: Kaczur Sándor

Folytatjuk Tankockák blog bejegyzés sorozatunkat. A feladatban a 12 db programozási tétel nevének beírásával meg kell fejteni a keresztrejtvényt. Ez a témakör főként a Java SE szoftverfejlesztő tanfolyamunkhoz kötődik. A programozási tételek olyan alapfeladatok, amelyek univerzálisan használható építőkövek és bizonyított, hogy mindegyikük helyes. A programozási tételek fontosak a programozáshoz szükséges gondolkodásmód kialakításához, formálásához.

A programozási tételeket csoportosíthatjuk: elemi és összetett. Az elemi programozási tételek közös jellemzője, hogy bemenetük egy sorozat és kimenetük egyetlen adat (ami nem feltétlenül része/eleme a sorozatnak). Az összetett programozási tételek már több sorozattal működnek: lehet több bemenetük és több kimenetük is. Például egy bemeneti sorozatból előállítanak 2-3-több (nem biztos, hogy előre tudjuk, hogy hány darab) kimeneti sorozatot (vagy éppen fordítva). Más is lehet a csoportosítás alapja, például egyediek a sorozat elemei vagy lehetnek azonos elemek a sorozatban, számít az elemek sorrendje vagy nem. No vajon mi a keresztrejtvény megfejtése?