ciklusok - címke - it-tanfolyam.hu

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.

Fibonacci-sorozat

2023. január 3.2022. november 23. Szerző: Kiss Balázs

Ma van (november 23.) a Fibonacci nap (újra). Fibonacci középkori matematikus volt, ő tette közismertté a Fibonacci-sorozat-ot. A (0), 1, 1, 2, 3, 5, 8, 13, 21, 34, … sorozat igen népszerű azok közében is, akik programozást tanulnak. A sorozat első két eleme 1 és 1 (ha szükséges, akkor nulladik elemmel is dolgozhatunk), és minden további elem az előző két elem összege.

Korábban is blogoltak a kollégáim a témában:

Kaczur Sándor: Fibonacci nap,
Balogh Péter: Fibonacci-spirál.

Következzen most az én öt különböző megoldásom Java forráskódja, rövid magyarázattal. Mindegyik a Fibonacci-sorozat első tíz elemét állítja elő.

1. megoldás

private void solution1(int n) {

System.out.println("Az első "+n+" Fibonacci szám:");

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

list.add(1);

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

list.add(list.get(i-1)+list.get(i-2));

System.out.println(list);

}

Az első megoldás generikus listát épít. Az első két elemet elhelyezi a lista elején ( list.add(1)). Ezek a lista nulladik és első elemei lesznek. Ezután a metódus a maradék 8 elemmel 2-től n-1-ig fiktív indexként hivatkozva az előző két elem összegeként ( list.get(i-1)+list.get(i-2)) index nélkül bővíti a listát.

2. megoldás

private static int fib(int n) {

if(n<=1)

return n;

return fib(n-1)+fib(n-2);

}

private void solution2(int n) {

System.out.println("Az első "+n+" Fibonacci szám:");

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

System.out.println(fib(i));

}

A második megoldás a tipikusan nem hatékony rekurzív módszert implementálja. A rekurzív fib() függvény a sorozat egyetlen elemét adja vissza, amit (a függvényt) a ciklus sokszor meghív ahelyett, hogy a ciklus vagy a rekurzió „emlékezne” az előző elemekre.

3. megoldás

private void solution3(int n) {

System.out.println("Az első "+n+" Fibonacci szám:");

Stream.iterate(

new int[] {0, 1}, f->new int[] {f[1], f[0]+f[1]}).

limit(n).

map(f->f[1]).

forEach(System.out::println);

}

A harmadik megoldás funkcionális nyelvi elemeket (Stream API) használ. A folyamba kétdimenziós tömbre történő hivatkozással ( …f-> new int[]… ), közvetlen hozzárendeléssel/leképezéssel ( map()), kerülnek be a sorozat elemei.

4. megoldás

private void solution4(int n) {

System.out.println("Az első "+n+" Fibonacci szám:");

final double SQRT5=Math.sqrt(5);

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

int f=(int)((Math.pow(1+SQRT5, i)-Math.pow(1-SQRT5, i))/

(SQRT5*Math.pow(2, i)));

System.out.println(f);

}

A negyedik megoldás a Fibonacci-számok zárt alakját használja. Másképpen ez a Binet-formula:

Ezzel a képlettel a sorozat elemei közvetlenül megadhatók, azaz nem szükséges más elemekre való hivatkozás. A ciklus adja meg, hogy a sorozat 1-10-ig indexelt elemei szükségesek.

5. megoldás

private void solution5(int n) {

System.out.println("5 Az első "+n+" Fibonacci szám:");

final double SQRT5=Math.sqrt(5);

IntStream.iterate(1, i->i+1).

limit(n).

map(i->(int)((Math.pow(1+SQRT5, i)-Math.pow(1-SQRT5, i))/

(SQRT5*Math.pow(2, i)))).

forEach(System.out::println);

}

Az ötödik megoldás szintén Stream API-t használ. Először előállít egy sorozatot 1-10-ig, amiket a leképezésnél ( map()) inputként használ és alkalmazza rájuk a Binet-formulát. Hagyományos ciklus utasítás nem szükséges.

Eredmény

Mindegyik megoldás a konzolra írja szövegesen az eredményt, azaz a Fibonacci-sorozat első tíz elemét: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55. Érdemes elemezni a hatékonyság klasszikus három szempontja (időigény/lépésszám, tárigény, bonyolultság) alapján a különböző megoldásokat. Ezek mérésével könnyen kiegészíthetők a fenti metódusok, vagy az azokat meghívó osztályban a vezérlés.

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

Tankocka – Egyszerű sorbarendezés: Java forráskód

2022. szeptember 24.2022. július 1. Szerző: Kiss Balázs

Folytatjuk Tankockák blog bejegyzés sorozatunkat. A feladatban helyes sorrendbe kell állítani a Java forráskód sorait. Ez főként a Java SE szoftverfejlesztő tanfolyamunk tematikájához kötődik.

A Java program véletlenszerű ötöslottó szelvényt állít elő. Adatszerkezetként generikus listát használ. Amikor csak lehet, épít a kollekció beépített képességeire (eldöntés, sorozatszámítás, rendezés). A szakterületnek megfelelően az ötöslottó szelvényen tárolt számok „emelkedő számsorrendben” jelennek meg. A forráskódban nincs jelölve a csomag, importok, behúzás, tagolás, igazítás.

Tankocka – Hang/Film felirattal: a barátkozás algoritmusa Dr. Sheldon Cooper szerint

2023. január 28.2022. április 1. Szerző: Kaczur Sándor

Folytatjuk Tankockák blog bejegyzés sorozatunkat. A feladatban válaszolni kell a videóban megjelenő hat kérdésre. A kérdések algoritmusokhoz kapcsolódnak. A videó a népszerű Agymenők (The Big Bang Theory) című sorozat 2. évad 13. epizódjából való, melynek címe: A barátkozás módszertana (The Friendship Algorithm). Ez a témakör főként az alapozó tanfolyamunkhoz kötődik: Java SE szoftverfejlesztő tanfolyam.

Az algoritmusok a tipikusan programozási nyelvtől független, konvertálható tudást jelentik. Mindig szükség van rájuk. Többféle jelölésrendszer is kapcsolódik hozzájuk. Például folyamatábra, mondatszerű leírás, struktogram, Jackson-ábra. Az UML jelölésrendszer elemei közül az objektumok kommunikációját, viselkedését leíró ábrák is algoritmusleíró eszköznek tekinthetők.

Skandináv lottó demóprogram

2023. január 1.2021. augusztus 17. Szerző: Kaczur Sándor

Skandináv lottó (heteslottó) demóprogramot tervezünk és írunk meg Java nyelven. Lépésenként mutatja meg, hogy mi történik a háttérben: hogyan állítja elő véletlenszerűen a lottószelvényt.

Az emlékezet egy logikai tömb. Ebben 36 elem van. A nulladik elem nem számít, és legyen a többi elem (1-35-ig indexelve) kezdetben mind hamis. A cél: legyen a tömbben pontosan 7 db igaz érték. Másképpen: a logikai tömb a lottószelvényen megjátszható számok kiválasztottságát jelöli, igen vagy nem. A heteslottó-szelvény 7 db 1 és 35 közötti különböző egész számból áll.

Mindig 1 és 35 közötti egész véletlenszámot tippelünk. Kezdetben jóSzámDb=0. Az első tipp biztosan jó és jóSzámDb=1. A többi tipp esetén vizsgálni kell, hogy már kiválasztott-e. Ha igen, akkor nincs teendőnk. Ha nem, akkor meg kell jegyezni (kiválasztottá kell tenni, azaz igazzá kell állítani a logikai tömbben) és a jóSzámDb++ (növelhető). Mindezt ciklusban ismételjük, amíg a jóSzámDb<7 feltétel teljesül (másképpen: amíg nincs elegendő kiválasztott szám a szelvényen). Mindez biztosítja az egyediséget, különbözőséget. Ha jóSzámDb==7, akkor kiírjuk a lottószelvényre kerülő számokat az alapján, hol (melyik indexen) van a logikai tömbben igaz érték.

Tekintsük át az alkalmazott módszer hátrányait és előnyeit. Hátrány, hogy 36 logikai érték szükséges ahhoz, hogy 7 különböző számot előállítsunk. Előny, hogy egyszerű az algoritmus (nem kell keresés és megszámolás programozási tétel) és nincs szükség rendezésre sem, mert a szakterületre jellemző „emelkedő számsorrend” a logikai tömb bejárásával önkéntelenül is adódik. Hangsúlyozzuk, hogy ez csupán egyetlen módszer a nagyon sok izgalmas közül, amikkel generálható egy véletlenszerű lottószelvény.

A megvalósítás, Java forráskód egyszerű. Íme egy függvény, amely visszaadja azt kiválasztottságot jelölő logikai tömböt, amiből megfelelően indexelve kiíratható a véletlenszerűen generált lottószelvény:

private static Boolean[] heteslottoSzelveny() {

Boolean[] logikaiTomb=Stream.generate(()->Boolean.FALSE).

limit(1+35).toArray(Boolean[]::new);

int joSzamDb=0;

while(joSzamDb<7) {

int tipp=(int)(Math.random()*35+1);

if(!logikaiTomb[tipp]) {

logikaiTomb[tipp]=true;

joSzamDb++;

}

return logikaiTomb;

}

Egy demóprogram, szimulációs program, oktatóprogram esetén nem is a konkrét feladat megoldása a cél/probléma. Sokkal inkább a lépésenkénti bemutatás, sok-sok konzolos kiírással vagy grafikus szemléltetéssel. Sokszor időzítővel késleltetjük, lassítjuk, gyorsítjuk a folyamatot, de előfordul az is, hogy rengetegszer megismételjük a tevékenységet és a kapott adatokat elemezzük, következtetünk belőlük. Most például a ciklust ki kell cserélni olyan léptetésre, ami a felhasználó kattintásához kötődik. Ha kéri a következő tippet a lottószelvényre, akkor megkapja. Ha nem kattint, akkor nem kapja meg. Az is egy csalás/lehetőség lenne, hogy a háttérben nem is logikai tömb adatszerkezet van, csupán a vizualizáció miatt tűnik annak.

Az elkészült demóprogram megvalósítja a fenti algoritmust. Az alábbi képernyőképeken végiglapozható a demóprogram működése. Nem is az algoritmus megvalósítása a kihívás és a cél, hanem a folyamat lépésenkénti megjelenítése. Java swing grafikus felület készült el.

A demóprogram Start állapottal indul. Olyan a lépésenként tesztesetek sorozata, hogy a lottószelvény nem sikerül rögtön elsőre. Az egyik szám már előfordult korábban. A demóprogram Stop állapottal ér véget. A demóprogram pénztárszalagszerűen időnként jelzi, hol tart éppen. A demóprogram képes egymás után több lottószelvényt is előállítani és az emlékezete egyetlen szelvényre korlátozódik.

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 szimulációs programot tervezni, kódolni, tesztelni. A Java EE szoftverfejlesztő tanfolyamunkon, a szakmai modul 33-40. óra Java Server Pages alkalmain már a program böngészőben futó változatát is el tudjuk készíteni.