Kaczur Sándor informatikus mérnök, matematika-informatika-közgazdásztanár, az it-tanfolyam.hu alapítója és oktatói csapatának szakmai vezetője. Részletes bemutatkozása az Oktatók lapon található. 2017 óta blogol velünk.
Az it-tanfolyam.hu szakmai blogjába 111 bejegyzést írt:
A Koch-görbe egyike a legrégebben ismert egyszerű fraktáloknak. Mint ilyen, önhasonlóan rekurzív. Az önhasonlóság azt jelenti, hogy az ábra tetszőleges részét felnagyítva mindig hasonló/ugyanolyan részek jelennek meg (a méretaránytól függetlenül). Az
n=1 szinten a Koch-görbe kiindulópontja egy szabályos háromszög. A
n+1-edik szinten az
n-edik szinten található szakaszokat harmadoljuk, és a középső szakasz helyére egy harmad akkora háromszög két szárát illesztjük (az alapját kihagyjuk). Ezt rekurzívan folytatva kapjuk meg a Koch-görbét, másképpen Koch-féle hópelyhet.
Írtam egy egyszerű Java programot, amely n=1-től 9-ig paraméterezhetően kirajzolja a Koch-görbét egy grafikus felületre. Így működik:
A program elkészítéséhez néhány alapvető dolgot kell csupán tudni:
|
1 2 3 4 5 6 7 8 |
@Override protected void paintComponent(Graphics g) { super.paintComponent(g); g.setColor(Color.BLUE); koch(n, 200, 51, 60, 300, g); koch(n, 60, 300, 340, 300, g); koch(n, 340, 300, 200, 51, g); } |
A szakasz négy darab harmad akkora szakaszra osztását a megfelelően paraméterezett rekurzív metódushívások oldják meg az alábbi lépéseket követve:
A rekurzív rajzolást a koch() metódus végzi el, ahol a fraktál szabályának megfelelően szakaszharmadolás és a szükséges pontok koordinátáinak (szakaszok végpontjai) kiszámítása történik:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
private void koch(int n, int x1, int y1, int x5, int y5, Graphics g) { if(n==1) g.drawLine(x1, y1, x5, y5); else { double gy=Math.sqrt(3)/6; int dx=x5-x1, dy=y5-y1, x2=x1+dx/3, y2=y1+dy/3, x3=(int)((x1+x5)/2+gy*(y1-y5)), y3=(int)((y1+y5)/2+gy*(x5-x1)), x4=x1+dx*2/3, y4=y1+dy*2/3; koch(n-1, x1, y1, x2, y2, g); koch(n-1, x2, y2, x3, y3, g); koch(n-1, x3, y3, x4, y4, g); koch(n-1, x4, y4, x5, y5, g); } } |
A Koch-görbének van néhány érdekes tulajdonsága:
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ó alkalomra építő 29-36. Grafikus felhasználói felület alkalomhoz kötődik.
A Digitális Témahét 2016-ban indult országos rendezvénysorozat. Fő célja a digitális pedagógia módszertanának népszerűsítése és elterjesztése. A program fontos törekvése, hogy a digitáliskompetencia-fejlesztés az informatikán túl kiterjedjen más tantárgyakra is. A résztvevő pedagógusok és diákok változatos és kreatív iskolai projektek keretében fejleszthetik képességeiket technológiával támogatott tanulás során. A Digitális Témahét rendezvény minden meghirdetett programja ingyenes. A 2016/2017-es tanévben több mint ezer intézmény csatlakozott a programhoz, 7600 tanár és 129000 diák közel 3500 digitális projektet valósított meg. Miről szól egy digitális pedagógiai projekt? Projektpedagógiáról, csapatmunkáról, tantárgyak integrációjáról, kreatív alkotómunkáról, az önálló gondolkodás fejlesztéséről, IT eszközök helyes használatáról, digitális készségek fejlesztéséről, a lehetőségek kitágításáról.
A 2017/2018-as tanévben a rendezvény április 9-13. között valósult meg. Kiemelt témakörök/szempontok:
Az it-tanfolyam.hu 2018-ban csatlakozott a rendezvénysorozathoz. Meghirdettünk öt programot a https://digitalistemahet.hu weblapon. A programjainkra 2018. április 13-án 18:00-21:00 óráig került sor. A részvétel ingyenes, de előzetes regisztrációhoz kötött volt.
Köszönöm oktató kollégáimnak, hogy örömmel csatlakoztak szakmai előadással, interaktív pályaorientációs beszélgetéssel. Jól éreztük magunkat. A program szoros menetrendben zajlott. A szünetekben élénk szakmai párbeszéd alakult ki. Köszönjük a részvevő érdeklődőinknek, hogy eljöttek és aktívan közreműködtek. Jövőre is szívesen csatlakozunk a Digitális Témahét rendezvénysorozathoz.
A problémamegoldó, logikus gondolkodásra nevelő képzések anyagában, illetve felvételi feladatsorokban is sokszor megtalálható – többféle változatban is.
Három elefántot kell berakodnunk – szólt a hajóskapitány az első tiszthez.
És hány évesek ezek az elefántok? – kérdezte az első tiszt.
Mindegyik elmúlt már két éves és életkoraik szorzata 2450 – volt a válasz.
Hát életkoraik összege?
Azt fölösleges elárulnom, mert abból még nem tudnád megállapítani életkorukat – mondta a kapitány, majd hozzátette: Az egyikük idősebb nálam.
Akkor már tudom, hogy hány évesek az elefántok – mondta az első tiszt.
Feltéve, hogy tényleg tudta; … hány éves a kapitány?
Állítsunk elő olyan három szorzótényezőt, amelyek szorzata 2450 és egyben írassuk ki az összegüket is a konzolra!
|
1 2 3 4 5 6 7 8 9 10 |
public class Kapitany { public static void main(String[] args) { for(int i=3; i<=100; i++) for(int j=i; j<=100; j++) for(int k=j; k<=100; k++) if(i*j*k==2450) System.out.println( i+"*"+j+"*"+k+"=2450\t"+i+"+"+j+"+"+k+"="+(i+j+k)); } } |
Az i, j, k a három elefánt életkorát jelöli. Mivel mindegyik elmúlt két éves (és feltételezzük, hogy életkoraik egész számmal kifejezhetők), így i=3-ról indul. Az elefántok lehetnek egyidősek, ezért j=i-ről és k=j-ről indul. Nincs kizárt életkor, így a változók léptethetők egyesével. Az i, j, k monoton növekvő sorozatot alkot, ezért a kiírásban nem lesznek olyan sorok, amelyek csupán a szorzótényezők sorrendjében térnek el. Durva felső becslés a 100, hiszen az elefántok általában 60-70 évig élnek. Eredményül ezt kapjuk:
|
1 2 3 4 5 6 7 |
5*5*98=2450 5+5+98=108 5*7*70=2450 5+7+70=82 5*10*49=2450 5+10+49=64 5*14*35=2450 5+14+35=54 7*7*50=2450 7+7+50=64 7*10*35=2450 7+10+35=52 7*14*25=2450 7+14+25=46 |
Az eredményből milyen következtetés(eke)t lehet levonni és mi a megoldás?
A bejegyzéshez tartozó 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 5-8. óra: Vezérlési szerkezetek alkalmához kötődik.
Aki kedvet kapott és beszerezne néhány könyvet – tele érdekes, gondolkodtató, kreatív, logikai feladatokkal – ajánlom az alábbiakat:
A Pi-t (π) mindenki ismeri. Talán sokaknak kedvenc története is van a π-vel kapcsolatosan, amelyet iskolában vagy utazásai alatt szerzett. A π Euklidesz geometriájában a kör kerületének és átmérőjének arányát jelöli. A π irracionális szám, azaz végtelen, nem szakaszos tizedestört; másképpen számjegyei között nincs ismétlődés. A π értékével a hétköznapokban 3,14-dal szokás számolni, de a tudomány területén ennél sokkal pontosabb közelítést szokás alkalmazni. A π közelítése az informatikának köszönhetően akár több millió tizedesjegyig is lehetséges (például: S. Memphill: Pi to 1,000,000 places).
A nemzetközi Pi nap alkalmából (március 14) megvalósítottunk néhány – végtelen összeggel és szorzattal – π közelítésre való képletet, algoritmust Java nyelven.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
private static void megold1() { //Viète-féle sor double p=1, pi=1; for(int i=11; i>1; i--) { p=2; for(int j=1; j<i; j++) p=2+Math.sqrt(p); p=Math.sqrt(p); pi=pi*p/2; } pi*=Math.sqrt(2)/2; pi=2/pi; System.out.println(pi); } |
A módszer néhány eredménye: i=5 esetén 3.140331156954752 (2 tizedesjegyre pontos), i=10-nél 3.1415914215112 (5 tizedesjegyre pontos), i=11 esetén 3.1415923455701176 (6 tizedesjegyre pontos).
|
1 2 3 4 5 6 7 |
public static void megold2() { //Leibniz-féle sor double s=0; for(int i=0; i<=2500; i++) s+=Math.pow(-1, i)/(2*i+1); double pi=s*4; System.out.println(pi); } |
A módszer néhány eredménye: a 24. lépéstől stabil 1 tizedesjegyre, a 626. lépéstől stabil 2. tizedesjegyre, a 2453. lépéstől stabil 3 tizedesjegyre (hiszen alternál).
|
1 2 3 4 5 6 7 |
public static void megold3() { //Wallis-formula double p=1; for(int i=2; i<=17000; i+=2) p*=(1.0*i/(i-1)*(1.0*i/(i+1))); double pi=p*2; System.out.println(pi); } |
A módszer néhány eredménye: A 38. lépéstől 1, a 986. lépéstől 2, a 2650. lépéstől 3, a 16954. lépéstől már 4 tizedesjegyre pontos.
|
1 2 3 4 5 6 7 |
private static void megold8() { //Csebisev-sor, V1 double s=0; for(int k=0; k<=20; k++) s+=(Math.pow(-1, k)*Math.pow(Math.sqrt(2)-1, 2*k+1))/(2*k+1); double pi=s*8; System.out.println(pi); } |
A módszer k=10-re már 8 tizedesjegyig pontos.
A bejegyzéshez tartozó teljes forráskódot – további 8 közelítő módszer implementációjával együtt – 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ési szerkezetek alkalmához kötődik.
A grafikus felülettel rendelkező Java programok (Swing, FX, webkomponensek, HTML+CSS) fejlesztése során igény adódhat arra, hogy a GUI komponensek saját beépített rajzoló/renderelő képességét felülírjuk/-definiáljuk, hogy egy-egy nyomógomb, menüpont, rádiógomb másképpen nézzen ki. Léteznek beépített rajzoló funkciók is.
Ha például grafikont kell beilleszteni egy alkalmazásba, akkor használjunk és igényeink szerint szabjunk testre egy JFreeChart csomagbeli grafikont, illetve előfordulhat, hogy találhatunk egy olyat a JFreeChart Demo-ban, ami éppen megfelel a megrendelő igényeinek.
Persze a műfaj nem ér itt véget. Időnként kreatívabb ábrák, rajzok, grafikák megjelenítésére is használhatjuk a beépített – általában téglalap alakú – komponenseket. Ehhez egyszerűen csak felül kell írni/definiálni a paint() metódusukat és vászontechnikával, a megszokott képernyős koordináta-rendszerben, grafikai primitíveket (pont, téglalap, ellipszis) és színeket kell megfelelően paraméterezni.
Az optikai csalódások igen népszerűek, és az egyszerűbb fiziológiai és kognitív illúziók könnyen lerajzolhatók a fenti eszköztárral, hiszen csupán színek, alakzatok, kontraszt, távolság, mélység, térhatás segítségével valósulnak meg.
Íme három egyszerű példa, hogyan állítható elő optikai csalódás Java implementációval!
|
1 2 3 4 5 6 7 8 9 10 11 12 |
@Override public void paint(Graphics g) { int egyseg=20, sorDb=10, oszlopDb=20; for(int i=1; i<=sorDb; i++) { int eltolas=(i%2==1)?0:egyseg/2; g.setColor(Color.BLACK); for(int j=1; j<=oszlopDb; j+=2) g.fillRect(eltolas+(j-1)*egyseg, (i-1)*egyseg+i, egyseg, egyseg); g.setColor(Color.LIGHT_GRAY); g.drawLine(0, (i-1)*egyseg+i-1, egyseg*(oszlopDb-1), (i-1)*egyseg+i-1); } } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
@Override public void paint(Graphics g) { int egyseg=50, koz=10, sorDb=6, oszlopDb=8; g.setColor(Color.LIGHT_GRAY); g.fillRect(0, 0, oszlopDb*(egyseg+koz)-koz, sorDb*(egyseg+koz)-koz); g.setColor(Color.BLACK); for(int i=1; i<=sorDb; i++) for(int j=1; j<=oszlopDb; j++) g.fillRect((j-1)*(egyseg+koz), (i-1)*(egyseg+koz), egyseg, egyseg); g.setColor(Color.WHITE); for(int i=1; i<sorDb; i++) for(int j=1; j<oszlopDb; j++) g.fillOval(j*(egyseg+koz)-koz-2, i*(egyseg+koz)-koz-2, koz+4, koz+4); } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 |
@Override public void paint(Graphics g) { Point hely; for(int i=1; i<=4; i++) for(int j=1; j<=4; j++) { hely=new Point((i-1)*180, (j-1)*120); if((i+j)%2==1) minta1(g, hely); else minta2(g, hely); } } private void minta1(Graphics g, Point hely) { Point pozicio; for(int i=1; i<=4; i++) for(int j=1; j<=4; j++) { pozicio=new Point(hely.x+(i-1)*45, hely.y+(j-1)*30); if((i+j)%2==1) mintaAlap1(g, pozicio, Color.MAGENTA, Color.YELLOW); else mintaAlap2(g, pozicio, Color.YELLOW, Color.MAGENTA); } } private void minta2(Graphics g, Point hely) { Point pozicio; for(int i=1; i<=4; i++) for(int j=1; j<=4; j++) { pozicio=new Point(hely.x+(i-1)*45, hely.y+(j-1)*30); if((i+j)%2==1) mintaAlap2(g, pozicio, Color.MAGENTA, Color.YELLOW); else mintaAlap1(g, pozicio, Color.YELLOW, Color.MAGENTA); } } private void mintaAlap1(Graphics g, Point hely, Color kitolt, Color szin) { g.setColor(kitolt); g.fillRect(hely.x, hely.y, 45, 30); g.setColor(szin); g.fillRect(hely.x+2, hely.y+2, 13, 9); g.fillRect(hely.x+30, hely.y+19, 13, 9); } private void mintaAlap2(Graphics g, Point hely, Color kitolt, Color szin) { g.setColor(kitolt); g.fillRect(hely.x, hely.y, 45, 30); g.setColor(szin); g.fillRect(hely.x+30, hely.y+2, 13, 9); g.fillRect(hely.x+2, hely.y+19, 13, 9); } |
A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.
Aki ezek után kedvet kapott, keressen hasonló ábrákat és tervezve, kódolva, tesztelve gyakoroljon! Ajánlom ezeket a weboldalakat:
Hasonló feladatok megoldásához a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 29-36. Grafikus felhasználói felület alkalma után bátran hozzá lehet fogni, illetve érintjük még a GUI témakört a Java adatbázis-kezelő tanfolyam 33-40. óra: Grafikus kliensalkalmazás fejlesztése JDBC alapon alkalommal is.
