programozási tételek - címke - Oldal 4 a 6-ből

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

2023. augusztus 4.2021. május 4. Szerző: Kaczur Sándor

A 2021-es középszintű matematika érettségi feladatsor 12. feladata inspirált arra, hogy a programozás eszköztárával oldjuk meg ezt a feladatot. Szükséges hozzá néhány programozási tétel: sorozatszámítás, eldöntés, megszámolás, kiválogatás. Többféle megoldás/megközelítés is előkerül. Érdekes belegondolni, hogy mennyire más lehetne a problémamegoldás, ha programozhatnánk a matematika érettségi vizsgán. A teljes feladatsor a megoldásokkal együtt letölthető az oktatas.hu-ról.

12. feladat

A háromjegyű pozitív egész számok közül véletlenszerűen kiválasztunk egyet. Mennyi annak a valószínűsége, hogy a kiválasztott szám számjegyei különbözők? Megoldását részletezze!

1. megoldás

static void feladat12Megoldas1() {

int db=0;

for(int szazas=1; szazas<=9; szazas++)

for(int tizes=0; tizes<=9; tizes++)

for(int egyes=0; egyes<=9; egyes++)

if(szazas!=tizes && tizes!=egyes && szazas!=egyes)

db++;

System.out.println("1. megoldás: "+db/900.0);

}

Az 1. megoldás egymásba ágyazott ciklusokkal behelyettesíti a szóba jöhető 900 db háromjegyű szám számjegyeit. A feltétel 648 esetben teljesül. Három számjegy azonosságát két részfeltétel és kapcsolatával eldönthetnénk a trichotómia miatt. Három számjegy különbözőségéhez három részfeltétel és kapcsolatából áll össze a feltétel. A válasz a kedvező és összes eset aránya/hányadosa, azaz 0,72. Másképpen 648 db szám a 900 db háromjegyű szám közül. A megoldás lépésszáma 900.

2. megoldás

static void feladat12Megoldas2() {

int db=0;

for(int szazas=1; szazas<=9; szazas++)

for(int tizes=0; tizes<=9; tizes++)

if(szazas!=tizes)

for(int egyes=0; egyes<=9; egyes++)

if(tizes!=egyes && szazas!=egyes)

db++;

System.out.println("2. megoldás: "+db/900.0);

}

Az egymásba ágyazott ciklusok lépésszáma összeszorzódik. A legbelső ciklus az előtte lévő feltételtől függően kevesebbszer is végrehajtódhat, hiszen a százas és tízes helyiértéken lévő számjegyek egyezése esetén nincs értelme az egyes helyiértéken lévő számjegy vizsgálatának. Így a 2. megoldás lépésszáma 810, azaz 10%-kal kevesebb. Ez a három részből álló feltétel két részre bontásával érhető el.

3. megoldás

static void feladat12Megoldas3() {

int db=0;

for(int i=100; i<=999; i++) {

int szazas=i/100;

int tizes=i%100/10;

int egyes=i%100%10;

if(szazas!=tizes && tizes!=egyes && szazas!=egyes)

db++;

}

System.out.println("3. megoldás: "+db/900.0);

}

A 3. megoldásban egyetlen ciklus végzi a vizsgálatot, a megszámolást. A ciklusváltozó már nem számjegy, hanem maga a háromjegyű szám, amiről döntést kell hozni: különbözik-e mindegyik számjegye vagy sem. Három beszédes nevű segédváltozó segít értelmezni a Java forráskódot. Ezek az egész osztás és a maradékos osztás műveleteivel állíthatók elő.

4. megoldás

static boolean kulonbozoSzamjegyek(int i) {

int szazas=i/100;

int tizes=i%100/10;

if(szazas==tizes)

return false;

int egyes=i%100%10;

if(tizes==egyes || szazas==egyes)

return false;

return true;

}

static void feladat12Megoldas4() {

int db=0;

for(int i=100; i<=999; i++)

if(kulonbozoSzamjegyek(i))

db++;

System.out.println("4. megoldás: "+db/900.0);

}

A 4. megoldás logikai visszatérési értékű segédfüggvényt alkalmaz. Ez egy menekülőutas megoldás. Ha kizáró feltétel szerint már döntést tudunk hozni (például megegyezik a százas és a tízes helyiértéken lévő számjegy), akkor hamis értékkel menekülünk. Egyébként ág nélkül ezután következhet az egyes helyiértéken lévő számjegy összehasonlítása a többivel. A második feltétel az eddigiekhez képest tagadott, mert a menekülés a cél. Ha nincs menekülés amiatt, hogy volt két megegyező számjegy, akkor – a feltételek egymásra épülése miatt – nincs más hátra, mint igaz értékkel visszatérni (ami azt jelenti, hogy nem volt egyezés, azaz minden számjegy különbözött).

5. megoldás

static long kulonbozoSzamjegyDb(int i) {

return IntStream.of(i/100, i%100/10, i%100%10).distinct().count();

}

static void feladat12Megoldas5() {

int db=0;

for(int i=100; i<=999; i++)

if(kulonbozoSzamjegyDb(i)==3)

db++;

System.out.println("5. megoldás: "+db/900.0);

}

Az 5. megoldás segédfüggvénye a háromjegyű szám esetén a különböző számjegyek darabszámával tér vissza. A röptében előállított százaz, tízes, egyes helyiértékeken lévő számjegyekből folyam adatszerkezet készül, aminek feldolgozását a Stream API műveletei (egyediesítő, megszámoló) végzik el. Ezt a vezérlő ciklusban hárommal összehasonlítva léptethető a megszámolást megvalósító változó, hiszen ha teljesül a feltétel, akkor eggyel több megfelelő szám van, mint előtte volt.

6. megoldás

static void feladat12Megoldas6() {

int db=0;

for(int i=100; i<=999; i++) {

int szazas=i/100;

int tizes=i%100/10;

int egyes=i%100%10;

if(szazas==tizes || tizes==egyes || szazas==egyes)

db++;

}

System.out.println("6. megoldás: "+(900-db)/900.0);

}

Az 6. megoldás újra másképpen közelít. Ha könnyebbnek tűnik az a feltétel, hogy mikor nem jó (kedvezőtlen) nekünk egy szám, akkor beépíthetjük ezt is. Megszámoljuk azokat a háromjegyű számokat, amelyeknél egy vagy két számjegy azonos, majd ez kivonjuk a háromjegyű számok darabszámából.

7. megoldás

static void feladat12Megoldas7() {

long db=IntStream.range(100, 1000).

filter(i -> IntStream.of(i/100, i%100/10, i%100%10).

distinct().count()==3).count();

System.out.println("7. megoldás: "+db/900.0);

}

A 7. megoldás már mindent folyamokkal old meg, azok képességeire építve. Az összes háromjegyű számot előállítja, majd rajtuk kiválogatás programozási tételt (szűrőt) használ (az 5. megoldás segédfüggvényére építve), végül a folyamban maradó számokat megszámolja. Ez a megoldás már olyan haladóknak való, akik magabiztosan építik össze a Stream API műveleteit és a lambda kifejezéseket. Mindent egyben. Persze hol itt a hatékonyság? Hozzászólásokban megbeszélhetjük.

8. megoldás

static void feladat12Megoldas8() {

long db=IntStream.range(100, 1000).

filter(i -> !(i/100==i%100/10 && i%100/10==i%100%10)). //1. szűrő

filter(i -> !(i/100==i%100/10)). //2. szűrő

filter(i -> !(i%100/10==i%100%10)). //3. szűrő

filter(i -> !(i/100==i%100%10)). //4. szűrő

count();

System.out.println("8. megoldás: "+db/900.0);

}

A 8. megoldás szintén folyam adatszerkezettel működik, de négy egymást követő lépésben végez szűrést (kiválogatást). A 900 db háromjegyű számból indulunk ki. Az 1. szűrő kihagyja a 9 db AAA számot, amelyek számjegyei azonosak és így marad utána 891 db szám. A 2. szűrő után marad 810 db szám, mert kimarad az a 81 db AAB alakú szám (ahol a százas és tízes helyiértéken lévő számjegyek megegyeznek) az összesen 90 db-ból, ami még a folyamban maradt az 1. szűrő után. A 3. szűrő kihagy 81 db ABB alakú számot és meghagy 729 db számot. A 4. szűrő kihagy 80 db ABA alakú számot és meghagy 648 db ABC alakú számot.

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, 13-16. óra: Tömbök, valamint 21-24. óra: Objektumorientált programozás, 2. és 3. rész alkalmaihoz kötődik.

Rómeó és Júlia

2023. augusztus 4.2021. február 14. Szerző: Kaczur Sándor

Vajon hogyan kerül elő a Rómeó és Júlia az it-tanfolyam.hu szakmai blogban témaként? Hiszen mégiscsak egy Shakespeare színműről/tragédiáról van szó. Vajon mit programozhatunk Java nyelven ehhez kötődően épp Valentin-napon? Mindjárt kiderül.

Tegyünk fel egy kérdést és próbáljunk rá válaszolni! Vajon ki szereti jobban a másikat? Rómeó vagy Júlia?

Induljunk el az adatforrásból, amihez alkalmazkodnunk kell. A színmű angol nyelven publikusan elérhető XML formátumban: The Tragedy of Romeo and Juliet. Az XML fájlok könnyen feldolgozhatók Java nyelven. Részletek a fájlból (görgethető):

<?xml version="1.0"?>

<LINE>Two households, both alike in dignity,</LINE>

<LINE>In fair Verona, where we lay our scene,</LINE>

<LINE>From ancient grudge break to new mutiny,</LINE>

<LINE>Where civil blood makes civil hands unclean.</LINE>

...

</SPEECH>

<SPEAKER>ROMEO</SPEAKER>

<LINE>Is the day so young?</LINE>

</SPEECH>

<SPEAKER>ROMEO</SPEAKER>

<LINE>Stay, fellow; I can read.</LINE>

<STAGEDIR>Reads</STAGEDIR>

<LINE>'Signior Martino and his wife and daughters;</LINE>

<LINE>County Anselme and his beauteous sisters; the lady</LINE>

...

<LINE>assembly: whither should they come?</LINE>

</SPEECH>

<SPEAKER>ROMEO</SPEAKER>

<LINE><STAGEDIR>To JULIET</STAGEDIR> If I profane with my unworthiest hand</LINE>

<LINE>This holy shrine, the gentle fine is this:</LINE>

<LINE>My lips, two blushing pilgrims, ready stand</LINE>

<LINE>To smooth that rough touch with a tender kiss.</LINE>

</SPEECH>

<STAGEDIR>Enter JULIET</STAGEDIR>

</ACT>

Az XML fájl felépítését tanulmányozva (1-5 alapján) megállapíthatóak az alábbiak:

A színmű öt felvonásból áll, ezeket <ACT></ACT> csomópontok jelölik.
Egy „adagnyi” beszédet a <SPEECH></SPEECH> csomópont fog össze.
A csomópontban található, hogy ki beszél: ez a <SPEAKER></SPEAKER> elem. A mesélő, kar esetén ez az elem üres, és a null-t nem szabad feldolgozni.
A csomópontban találhatók a szabadvers kimondott sorai: ezek a <LINE></LINE> elemek. Legalább egy sor minden beszédben van, és nem tudjuk előre a számukat.
Nem következetes helyen a DOM-ban, többféleképpen beágyazva és önállóan is előfordulhatnak <STAGEDIR></STAGEDIR> elemek. Ezek a színmű Kosztolányi-féle magyar fordításában dőlt betűvel megjelenő – cselekvésre utaló – színpadi utasítások. Van köztük csók is, amit az XML-ből nem szabad feldolgozni, bár erősen ráutaló magatartás. 🙂
Nem tudjuk előre, hogy hány csomópont található a fájlban.

A Java program készítése, tesztelése közben – mintegy mellékesen – megtudhatjuk, hogy Rómeó 612 sorban 24075 betűnyi, Júlia 544 sorban 21855 betűnyi szöveget mond. Persze nem mindet egymásnak mondják. Eközben vajon hányszor mondják ki a szeret, szeretem, szeretlek szavakat? A ragoktól, toldalékoktól, kis- és nagybetűket nem megkülönböztetve és attól is eltekintve, hogy éppen kinek/kiknek mondják amit éppen mondanak, egy becsléshez elegendő, ha a love szóra fókuszálunk (számíthatna a loving alak is).

Az alábbi Java forráskód betölti az XML fájlt a memóriába. Ezután kiválogatja a beszédeket. Ha a beszélő élő ember (szereplő), akkor érdekes, hogy mit/miket mond. Ha ROMEO vagy JULIET mondja az adott sort, akkor azt a program kiválogatja két generikus listába ( romeoLineList és julietLineList) beszédnyi adagokban. Ez nem szétválogatás programozási tétel, mert nem minden beszéd minden sora kerül valahová. A kivételkezelés nem kidolgozott.

private static ArrayList<String> getLineList(final Node SPEECH) {

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

NodeList nodeList=((Element)SPEECH).getElementsByTagName("LINE");

for(int i=0; i<nodeList.getLength(); i++) {

String line=

((Element)nodeList.item(i)).getFirstChild().getNodeValue();

lineList.add(line);

}

return lineList;

}

public static void main(String[] args) {

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

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

try {

NodeList speechList=DocumentBuilderFactory.newInstance().

newDocumentBuilder().parse(new File("./files/r_and_j.xml")).

getDocumentElement().getElementsByTagName("SPEECH");

for(int i=0; i<speechList.getLength(); i++) {

Node speech=speechList.item(i);

Node speaker=((Element)speech).getElementsByTagName("SPEAKER").

item(0).getFirstChild();

if(speaker!=null)

switch(speaker.getNodeValue()) {

case "ROMEO":

romeoLineList.addAll(getLineList(speech));

break;

case "JULIET":

julietLineList.addAll(getLineList(speech));

}

catch(ParserConfigurationException | SAXException | IOException e) {

e.printStackTrace();

}

//...

}

Könnyen megkaphatjuk, hogy Rómeó hány darab olyan sort mond, amely tartalmazza a love szót. Például ennek a lambda kifejezésnek kiíratva az eredményét a konzolra:

romeoLineList.stream().

filter(f->f!=null).filter(f->f.toLowerCase().contains("love")).

count();

Könnyen megkaphatjuk Rómeótól a 53 sornyi szöveget is így:

romeoLineList.stream().

filter(f->f!=null).filter(f->f.toLowerCase().contains("love")).

forEach(line->System.out.println(line));

Íme Rómeó kiválogatott sorai (az 5. sorban kétszer is előfordul a love, de ez most nem számít):

Out of her favour, where I am in love.

Alas, that love, whose view is muffled still,

Here's much to do with hate, but more with love.

Why, then, O brawling love! O loving hate!

This love feel I, that feel no love in this.

Why, such is love's transgression.

With more of thine: this love that thou hast shown

Love is a smoke raised with the fume of sighs;

Being purged, a fire sparkling in lovers' eyes;

Being vex'd a sea nourish'd with lovers' tears:

In sadness, cousin, I do love a woman.

A right good mark-man! And she's fair I love.

From love's weak childish bow she lives unharm'd.

She hath forsworn to love, and in that vow

widow of Vitravio; Signior Placentio and his lovely

One fairer than my love! the all-seeing sun

Under love's heavy burden do I sink.

Is love a tender thing? it is too rough,

Did my heart love till now? forswear it, sight!

It is my lady, O, it is my love!

O, that I were a glove upon that hand,

Call me but love, and I'll be new baptized;

With love's light wings did I o'er-perch these walls;

For stony limits cannot hold love out,

And what love can do that dares love attempt;

And but thou love me, let them find me here:

Than death prorogued, wanting of thy love.

By love, who first did prompt me to inquire;

If my heart's dear love--

The exchange of thy love's faithful vow for mine.

Wouldst thou withdraw it? for what purpose, love?

Love goes toward love, as schoolboys from

But love from love, toward school with heavy looks.

How silver-sweet sound lovers' tongues by night,

Then plainly know my heart's dear love is set

And bad'st me bury love.

I pray thee, chide not; she whom I love now

Doth grace for grace and love for love allow;

A gentleman, nurse, that loves to hear himself talk,

Then love-devouring death do what he dare;

Tybalt, the reason that I have to love thee

But love thee better than thou canst devise,

Till thou shalt know the reason of my love:

Wert thou as young as I, Juliet thy love,

My conceal'd lady to our cancell'd love?

No nightingale: look, love, what envious streaks

That may convey my greetings, love, to thee.

And trust me, love, in my eye so do you:

Ah me! how sweet is love itself possess'd,

When but love's shadows are so rich in joy!

By heaven, I love thee better than myself;

Call this a lightning? O my love! my wife!

Here's to my love!

Hasonlóan megkaphatjuk Júlia 38 kiválogatott sorát is:

My only love sprung from my only hate!

Prodigious birth of love it is to me,

That I must love a loathed enemy.

Or, if thou wilt not, be but sworn my love,

Dost thou love me? I know thou wilt say 'Ay,'

Thou mayst prove false; at lovers' perjuries

If thou dost love, pronounce it faithfully:

My true love's passion: therefore pardon me,

And not impute this yielding to light love,

Lest that thy love prove likewise variable.

This bud of love, by summer's ripening breath,

My love as deep; the more I give to thee,

I hear some noise within; dear love, adieu!

If that thy bent of love be honourable,

Remembering how I love thy company.

O, she is lame! love's heralds should be thoughts,

Therefore do nimble-pinion'd doves draw love,

My words would bandy her to my sweet love,

Sweet, sweet, sweet nurse, tell me, what says my love?

'Your love says, like an honest gentleman,

But my true love is grown to such excess

Spread thy close curtain, love-performing night,

Lovers can see to do their amorous rites

By their own beauties; or, if love be blind,

With thy black mantle; till strange love, grown bold,

Think true love acted simple modesty.

That all the world will be in love with night

O, I have bought the mansion of a love,

My dear-loved cousin, and my dearer lord?

Believe me, love, it was the nightingale.

Art thou gone so? love, lord, ay, husband, friend!

To wreak the love I bore my cousin

But thankful even for hate, that is meant love.

I will confess to you that I love him.

To live an unstain'd wife to my sweet love.

Love give me strength! and strength shall help afford.

And gave him what becomed love I might,

What's here? a cup, closed in my true love's hand?

Próbáljunk válaszolni a fentiek alapján a feltett kérdésre! Következtethetünk arra, hogy Rómeó jobban szereti Júliát. Legalábbis többször említi. 53>38. Persze tudjuk, hogy mindez nem ilyen egyszerű. 🙂

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 21-24. óra: Objektumorientált programozás 2. rész, 25-28. óra: Objektumorientált programozás 3. rész, valamint a Java EE szoftverfejlesztő tanfolyam szakmai moduljának 9-12. óra: XML feldolgozás alkalmaihoz kötődik.

Nagyon különböző megoldásokat készíthetünk és szerteágazóan gyakorolhatunk, ha:

az XML fájlt kézzel mentjük a webről és utána a helyi fájlrendszerből dolgozzuk fel,
az XML fájlt közvetlenül a webről, dinamikusan olvassuk,
csak beépített XML-feldolgozást használunk,
külső XML API-t használunk,
DOM, SAX, XSL, van-e DTD,
XPath kifejezésekkel adunk választ a kérdésre,
a fenti didaktikusan egyszerű megoldás helyett haladóbb eszközöket (például: Stream API-t) használunk.

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

2023. január 3.2020. május 6. Szerző: Kaczur Sándor

A 2020-as emelt szintű matematika érettségi feladatsor 9. feladata inspirált arra, hogy a programozás eszköztárával oldjuk meg ezt a feladatot. Szükséges hozzá kollekció adatszerkezet és néhány programozási tétel. Érdekes belegondolni, hogy mennyire más lehetne a problémamegoldás, ha programozhatnánk a matematika érettségi vizsgán. A teljes feladatsor a megoldásokkal együtt letölthető az oktatas.hu-ról.

2018-ban és 2019-ben is kiválasztottam egy-egy matematika érettségi feladatot a középszintű feladatlapról és megoldottam Java nyelven. 2020-ban az emelt szintű feladatsornál lelkesedtem eléggé, hogy blogoljak róla.

9. feladat

Egy városban a közösségi közlekedést kizárólag vonaljeggyel lehet igénybe venni, minden utazáshoz egy vonaljegyet kell váltani. A vonaljegy ára jelenleg 300 tallér. Az utazások száma naponta átlagosan 100 ezer. Ismert az is, hogy ennek kb. 10%-ában nem váltanak jegyet (bliccelnek).
A városi közlekedési társaság vezetői hatástanulmányt készíttettek a vonaljegy árának esetleges megváltoztatásáról. A vonaljegy árát 5 talléronként lehet emelni vagy csökkenteni. A hatástanulmány szerint a vonaljegy árának 5 talléros emelése várhatóan 1000-rel csökkenti a napi utazások számát, és 1 százalékponttal növeli a jegy nélküli utazások (bliccelések) arányát. (Tehát például 310 talléros jegyár esetén naponta 98000 utazás lenne, és ennek 12%-a lenne bliccelés.) Ugyanez fordítva is igaz: a vonaljegy árának minden 5 talléros csökkentése 1000-rel növelné a napi utazások számát, és 1 százalékponttal csökkentené a bliccelések arányát. A tanulmány az alkalmazott modellben csak a 245 tallérnál drágább, de 455 tallérnál olcsóbb lehetséges jegyárakat vizsgálta.

a) Mekkora lenne a közlekedési társaság vonaljegyekből származó napi bevétele a hatástanulmány becslései alapján, ha 350 tallérra emelnék a vonaljegyek árát?
b) Hány talléros vonaljegy esetén lenne maximális a napi bevétel?

Tervezés

Értelmezve a feladatot és a feltett kérdéseket: adódik, hogy a megoldáshoz szükséges egy POJO, ami az összetartozó adatokat fogja egybe objektumként. Mivel több kell belőle, célszerű egy indexelhető adatszerkezet, például tömb vagy lista. Ékezettelen magyar elnevezéseket fogok használni. A POJO osztály neve legyen Kozlekedes és a beszédes nevű tulajdonságai legyenek a következők: vonaljegyAr, napiUtasszam, bliccelesSzazalek, napiBevetel. Mindegyik nemnegatív egész szám és belefér az int primitív típus számábrázolási tartományába.

Ha a konstruktor paraméterként átveszi az input vonaljegyAr-at, akkor abból a többi adatot egyszerű képletekkel előállíthatja. Hasznos, ha a konstruktor ellenőrzést is végez. A tanulmány az alkalmazott modellben limitálja a vonaljegy árát (250 és 450 közötti öttel osztható számként). Az öttel oszthatóság az emelés/árváltozás mértékéből adódik. Ha a vonaljegy ára nem megfelelő, akkor a konstruktor kivételt dob, amivel megakadályozza, hogy az alkalmazott modellhez nem illeszkedő tulajdonságokkal rendelkező objektum létrejöjjön.

Az output meghatározásához az a) és b) feladatban megfogalmazott kérdésekből kell kiindulni. Ezekből adódik, hogy szükséges két getter metódus a POJO-ba: getVonaljegyAr() és getNapiBevetel(). Persze könnyen generáltatható az összes getter is, de setter nem kell. Ezeken kívül a tesztelés megkönnyítésére hasznos egy toString() metódus is, amellyel a 4 összetartozó adat hozzáférhető és megjeleníthető a konzolon.

A belépési pont és egyben a vezérlés egy másik osztályban valósul meg. Itt feltöltjük a tanulmány alkalmazott modelljének megfelelően előállított objektumokkal (memóriacímeikkel) a generikus listát, amit programozási tételekkel (kiválasztás, szélsőérték-kiválasztás) dolgozunk fel.

A POJO osztály forráskódja

public class Kozlekedes {

private int vonaljegyAr; //pl.: 300 tallér

private int napiUtasszam; //pl.: 100000 fő

private int bliccelesSzazalek; //pl.: 10%

private int napiBevetel; //pl.: 27000000 tallér

public Kozlekedes(int vonaljegyAr) {

if(vonaljegyAr<=245 || vonaljegyAr>=455 || vonaljegyAr%5!=0)

throw new IllegalArgumentException(

"A vonaljegy ára nem megfelelő. (Hibakód: 32596)");

this.vonaljegyAr=vonaljegyAr;

napiUtasszam=100000-(vonaljegyAr-300)/5*1000;

bliccelesSzazalek=10+(vonaljegyAr-300)/5;

napiBevetel=(vonaljegyAr*

(int)(napiUtasszam*(100-bliccelesSzazalek)/100.0));

}

public int getVonaljegyAr() {

return vonaljegyAr;

}

public int getNapiBevetel() {

return napiBevetel;

}

@Override

public String toString() {

return

"Közlekedés {\n"+

" vonaljegy ár: "+vonaljegyAr+" tallér\n"+

" napi utasszám: "+napiUtasszam+" fő\n"+

" bliccelés: "+bliccelesSzazalek+"%\n"+

" napi bevétel: "+napiBevetel+" tallér\n"+

"}";

}

A vezérlő osztály forráskódja

public class MatErettsegi2020EmeltFeladat9 {

private static void feladat9(List<Kozlekedes> lista) {

//a) feladat

int i=0;

while(lista.get(i).getVonaljegyAr()!=350)

i++;

System.out.println(

"a) Mekkora lenne a közlekedési társaság vonaljegyekből\n"+

"származó napi bevétele a hatástanulmány becslései alapján,\n"+

"ha 350 tallérra emelnék a vonaljegyek árát?\n"+

lista.get(i).getNapiBevetel()+" tallér lenne a napi bevétel.\n");

//b) feladat

int maxIndex=0;

for(i=1; i<lista.size(); i++)

if(lista.get(i).getNapiBevetel()>

lista.get(maxIndex).getNapiBevetel())

maxIndex=i;

System.out.println(

"b) Hány talléros vonaljegy esetén lenne maximális "+

"a napi bevétel?\nHa a vonaljegy ára "+

lista.get(maxIndex).getVonaljegyAr()+" tallér lenne.\n");

}

public static void main(String[] args) {

List<Kozlekedes> lista=new ArrayList<>();

for(int vonaljegyAr=250; vonaljegyAr<=450; vonaljegyAr+=5)

lista.add(new Kozlekedes(vonaljegyAr));

// for (Kozlekedes kozlekedes : lista)

// System.out.println(kozlekedes);

// System.out.println();

feladat9Megoldas1(lista);

// feladat9Megoldas2();

}

A main() metódus feltölti a generikus lista adatszerkezetet az alkalmazott modellben lehetséges/előforduló vonaljegyAr alapján létrehozott objektumokkal (a memóriacímükkel). A feladat9Megoldas1() metódus paraméterként átveszi a feldolgozandó listát.

Az a) feladatra a választ kiválasztás programozási tétellel kapjuk meg. A kérdés így szól: melyik az (első) olyan objektum, amelyben a vonaljegyAr egyenlő 350-nel? A ciklust követően megkapjuk, hogy az i-edik az, amelyikre igaz a feltétel. (Az nem merül fel, hogy van-e ilyen objektum, hiszen tudjuk, hogy van. Csak az a kérdés, hogy melyik az. Több sem lehet.) A lista.get(i).getNapiBevetel() művelettel elkérjük az i-edik objektumtól a válaszadáshoz szükséges napi bevételt.

A b) feladatra a választ szélsőérték-kiválasztás programozási tétellel kapjuk meg. A kérdés így szól: melyik az (első) olyan objektum, amelyben a napiBevetel a maximális? (Mivel a lista nem üres, így létezik a legnagyobb napi bevétel. Mivel nem biztos, hogy a legnagyobb napi bevétel egyedi, ezért merül fel az első a kérdésben.) Tegyük fel, hogy a nulladik objektumra igaz a feltétel: azaz maxIndex=0. Később a ciklusban változtassuk meg a maxIndex-et, ha a feldolgozás során találunk nagyobb értéket. Szélsőérték-kiválasztásnál a kezdeti elemet nem hasonlítjuk össze saját magával (hiszen úgysem különbözne), ezért indul a for ciklus 1-ről. A ciklust követően a lista.get(maxIndex).getVonaljegyAr() művelettel elkérhetjük a maxIndex-edik objektumtól a válaszadáshoz szükséges vonaljegy árát.

A program által felépített adatszerkezet

Ha a vezérlőben aktiváljuk a megjegyzésben szereplő kiíratást, akkor a konzolon megjelennek a main() metódusban létrehozott listában lévő objektumok adatai (amilyen viselkedést a POJO toString()-jébe programoztunk. A 246 soros szöveg görgetéssel megtekinthető.

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

Közlekedés {

vonaljegy ár: 250 tallér

napi utasszám: 110000 fő

bliccelés: 0%

napi bevétel: 27500000 tallér

}

Közlekedés {

vonaljegy ár: 255 tallér

napi utasszám: 109000 fő

bliccelés: 1%

napi bevétel: 27517050 tallér

}

Közlekedés {

vonaljegy ár: 260 tallér

napi utasszám: 108000 fő

bliccelés: 2%

napi bevétel: 27518400 tallér

}

Közlekedés {

vonaljegy ár: 265 tallér

napi utasszám: 107000 fő

bliccelés: 3%

napi bevétel: 27504350 tallér

}

Közlekedés {

vonaljegy ár: 270 tallér

napi utasszám: 106000 fő

bliccelés: 4%

napi bevétel: 27475200 tallér

}

Közlekedés {

vonaljegy ár: 275 tallér

napi utasszám: 105000 fő

bliccelés: 5%

napi bevétel: 27431250 tallér

}

Közlekedés {

vonaljegy ár: 280 tallér

napi utasszám: 104000 fő

bliccelés: 6%

napi bevétel: 27372800 tallér

}

Közlekedés {

vonaljegy ár: 285 tallér

napi utasszám: 103000 fő

bliccelés: 7%

napi bevétel: 27300150 tallér

}

Közlekedés {

vonaljegy ár: 290 tallér

napi utasszám: 102000 fő

bliccelés: 8%

napi bevétel: 27213600 tallér

}

Közlekedés {

vonaljegy ár: 295 tallér

napi utasszám: 101000 fő

bliccelés: 9%

napi bevétel: 27113450 tallér

}

Közlekedés {

vonaljegy ár: 300 tallér

napi utasszám: 100000 fő

bliccelés: 10%

napi bevétel: 27000000 tallér

}

Közlekedés {

vonaljegy ár: 305 tallér

napi utasszám: 99000 fő

bliccelés: 11%

napi bevétel: 26873550 tallér

}

Közlekedés {

vonaljegy ár: 310 tallér

napi utasszám: 98000 fő

bliccelés: 12%

napi bevétel: 26734400 tallér

}

Közlekedés {

vonaljegy ár: 315 tallér

napi utasszám: 97000 fő

bliccelés: 13%

napi bevétel: 26582850 tallér

}

Közlekedés {

vonaljegy ár: 320 tallér

napi utasszám: 96000 fő

bliccelés: 14%

napi bevétel: 26419200 tallér

}

Közlekedés {

vonaljegy ár: 325 tallér

napi utasszám: 95000 fő

bliccelés: 15%

napi bevétel: 26243750 tallér

}

Közlekedés {

vonaljegy ár: 330 tallér

napi utasszám: 94000 fő

bliccelés: 16%

napi bevétel: 26056800 tallér

}

Közlekedés {

vonaljegy ár: 335 tallér

napi utasszám: 93000 fő

bliccelés: 17%

napi bevétel: 25858650 tallér

}

Közlekedés {

vonaljegy ár: 340 tallér

napi utasszám: 92000 fő

bliccelés: 18%

napi bevétel: 25649600 tallér

}

Közlekedés {

vonaljegy ár: 345 tallér

napi utasszám: 91000 fő

bliccelés: 19%

napi bevétel: 25429950 tallér

}

Közlekedés {

vonaljegy ár: 350 tallér

napi utasszám: 90000 fő

bliccelés: 20%

napi bevétel: 25200000 tallér

}

Közlekedés {

vonaljegy ár: 355 tallér

napi utasszám: 89000 fő

bliccelés: 21%

napi bevétel: 24960050 tallér

}

Közlekedés {

vonaljegy ár: 360 tallér

napi utasszám: 88000 fő

bliccelés: 22%

napi bevétel: 24710400 tallér

}

Közlekedés {

vonaljegy ár: 365 tallér

napi utasszám: 87000 fő

bliccelés: 23%

napi bevétel: 24451350 tallér

}

Közlekedés {

vonaljegy ár: 370 tallér

napi utasszám: 86000 fő

bliccelés: 24%

napi bevétel: 24183200 tallér

}

Közlekedés {

vonaljegy ár: 375 tallér

napi utasszám: 85000 fő

bliccelés: 25%

napi bevétel: 23906250 tallér

}

Közlekedés {

vonaljegy ár: 380 tallér

napi utasszám: 84000 fő

bliccelés: 26%

napi bevétel: 23620800 tallér

}

Közlekedés {

vonaljegy ár: 385 tallér

napi utasszám: 83000 fő

bliccelés: 27%

napi bevétel: 23327150 tallér

}

Közlekedés {

vonaljegy ár: 390 tallér

napi utasszám: 82000 fő

bliccelés: 28%

napi bevétel: 23025600 tallér

}

Közlekedés {

vonaljegy ár: 395 tallér

napi utasszám: 81000 fő

bliccelés: 29%

napi bevétel: 22716450 tallér

}

Közlekedés {

vonaljegy ár: 400 tallér

napi utasszám: 80000 fő

bliccelés: 30%

napi bevétel: 22400000 tallér

}

Közlekedés {

vonaljegy ár: 405 tallér

napi utasszám: 79000 fő

bliccelés: 31%

napi bevétel: 22076550 tallér

}

Közlekedés {

vonaljegy ár: 410 tallér

napi utasszám: 78000 fő

bliccelés: 32%

napi bevétel: 21746400 tallér

}

Közlekedés {

vonaljegy ár: 415 tallér

napi utasszám: 77000 fő

bliccelés: 33%

napi bevétel: 21409850 tallér

}

Közlekedés {

vonaljegy ár: 420 tallér

napi utasszám: 76000 fő

bliccelés: 34%

napi bevétel: 21067200 tallér

}

Közlekedés {

vonaljegy ár: 425 tallér

napi utasszám: 75000 fő

bliccelés: 35%

napi bevétel: 20718750 tallér

}

Közlekedés {

vonaljegy ár: 430 tallér

napi utasszám: 74000 fő

bliccelés: 36%

napi bevétel: 20364800 tallér

}

Közlekedés {

vonaljegy ár: 435 tallér

napi utasszám: 73000 fő

bliccelés: 37%

napi bevétel: 20005650 tallér

}

Közlekedés {

vonaljegy ár: 440 tallér

napi utasszám: 72000 fő

bliccelés: 38%

napi bevétel: 19641600 tallér

}

Közlekedés {

vonaljegy ár: 445 tallér

napi utasszám: 71000 fő

bliccelés: 39%

napi bevétel: 19272950 tallér

}

Közlekedés {

vonaljegy ár: 450 tallér

napi utasszám: 70000 fő

bliccelés: 40%

napi bevétel: 18900000 tallér

}

Az eredmény

A program konzolon/szövegesen jeleníti meg a válaszokat a feltett két kérdésre:

a) Mekkora lenne a közlekedési társaság vonaljegyekből

származó napi bevétele a hatástanulmány becslései alapján,

ha 350 tallérra emelnék a vonaljegyek árát?

25200000 tallér lenne a napi bevétel.

b) Hány talléros vonaljegy esetén lenne maximális a napi bevétel?

Ha a vonaljegy ára 260 tallér lenne.

Gondoljuk újra

Az első megoldás 41 elemű listát épít. Persze ez a lista több mindenre is jó lehet, ha több(féle) kérdést kell(ene) megválaszolni. Ezért tekinthetjük strukturális tartaléknak.

A két konkrét kérdésre azonban úgy is adhatunk választ, hogy nem építünk lista adatszerkezetet. Ez a második megoldás. A feladat9Megoldas2() metódusnak nincs paramétere és azonos eredmény ad.

Az a) feladat: egy névtelen objektumként létrehozott POJO-tól azonnal elkérhetjük a választ, ami mehet rögtön a konzolra. Ez a kiválasztás programozási tétel extrém/legjobb esete, hiszen az első objektum jó is lesz, ciklust sem kell szervezni.

A b) feladat: kiindulunk a legolcsóbb vonaljegyből és tegyük fel, hogy ekkor a legnagyobb a napi bevétel. Ciklussal léptessük a vonaljegy árát ötösével legfeljebb a legdrágábbig. Léptetés közben mindig csak azt a dinamikusan létrehozott objektumot „jegyezzük meg”, amelyiktől a röptében elkért napi bevétel a korábbihoz – az addig legnagyobbnak vélthez – képest nagyobb. Végül a megmaradó POJO-tól elkérhető a maximális napi bevételhez tartozó vonaljegy ára. Ez a szélsőérték-kiválasztás programozási tétel megvalósítása dinamikusan: kezdetben nem áll rendelkezésre az összes adat, ami alapján döntést kell hozni, ehelyett az adatokat menet/feldolgozás közben állítjuk elő és „eldobjuk” azt, ami már nem kell.

private static void feladat9Megoldas2() {

//a) feladat

System.out.println(

"a) Mekkora lenne a közlekedési társaság vonaljegyekből\n"+

"származó napi bevétele a hatástanulmány becslései alapján,\n"+

"ha 350 tallérra emelnék a vonaljegyek árát?\n"+

new Kozlekedes(350).getNapiBevetel()+

" tallér lenne a napi bevétel.\n");

//b) feladat

Kozlekedes kMax=new Kozlekedes(250);

for(int vonaljegyAr=255; vonaljegyAr<=450; vonaljegyAr+=5) {

Kozlekedes k=new Kozlekedes(vonaljegyAr);

if(k.getNapiBevetel()>kMax.getNapiBevetel())

kMax=k;

}

System.out.println(

"b) Hány talléros vonaljegy esetén lenne maximális "+

"a napi bevétel?\nHa a vonaljegy ára "+

kMax.getVonaljegyAr()+" tallér lenne.\n");

}

Nekem ezek a programozással való megoldások sokkal jobban tetszenek, mint az oktatas.hu-n elérhető hivatalos, matematikai megoldás, amihez differenciálszámítás is kell. Persze aki emelt szinten érettségizik matematikából, annak az sem jelenthet gondot és biztosan izgalmasnak találja.

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

Dátumtartományok kezelése

2023. január 1.2020. február 8. Szerző: Kaczur Sándor

Aki webáruházat üzemeltet és raktároz, befektet áruk raktározásába, biztosan folyamatosan követi a raktárkészlet (és egyúttal pénzügyei) alakulását különböző lekérdezésekkel. Aki online marketinggel foglalkozik, szintén mérheti/követheti/összevetheti egy-egy reklámkampány eszközeinek (Facebook hirdetés, Google Ads hirdetés, e-mail marketing, Instagram hirdetés, blog) eredményességét, hatékonyságát. Az adatok elemzése mindenképpen része a tervezésnek és folyamatosnak/periodikusnak kell lennie.

Tipikus felmerülő kérdések/problémák

Hány offline és/vagy online vásárlás/tranzakció volt eddig az aktuális hónapban?
Hogyan változott a raktárkészlet az előző hónapban? Miből kell utánrendelni? Mik a kifutó termékek?
A bevétel milyen arányban érkezett offline vagy online vásárlásból az aktuális hónapban?
Kik vásároltak az előző negyedévben nyomtatót? Küldjünk nekik e-mailt arról, most 10%-kal olcsóbban rendelhetnek tonert, ha kettőt vesznek!
Milyen értékben adtak le rendelést a webáruházban két adott dátum által megadott napon? Például hogyan alakult az utóbbi két Black Friday? Esetleg GLAMOUR-napok, húsvét, hosszú hétvége…
Kik azok a rendszeres visszatérő vásárlóink, akik nem vásároltak az előző hónapban?
Hogyan alakultak „a számok” az előző két év 3. negyedévében!

Egy webáruház raktárkészletének és számláinak nyilvántartása biztosan adatbázisban tárolódik, így könnyen megfogalmazható SQL lekérdező parancsok segíthetik a fenti kérdésekre/problémákra való válaszadást. Természetesen ezeket a műveleteket okosan ki kell vezetni a felhasználói felületre, hogy könnyen paraméterezhetők legyenek.

Lássunk néhány megoldást! A Java forráskódokból azokat a részeket mutatjuk be, amelyek egy lekérdező parancsba beágyazható dátumokra vonatkozó feltételeket kiírják. A dátumok megjelenítésére rövid formátumot használunk konstansként: SimpleDateFormat SHORT_DATE=new SimpleDateFormat("yyyy-MM-dd");.

Aktuális hónap

Érdemes készíteni két túlterhelt metódust. A paraméter nélküli változat az aktuális napot, a paraméteres változat a megadott napot tekinti maximálisnak és ehhez adja meg az adott hónap első/minimális napját. A két dátumnál az év és hónap megegyezik, a nap többnyire különbözik (ritkán megegyezik). A maxDate nem lehet jövőbeli és teljesül a minDate<=maxDate feltétel.

private void previousMonth() {

previousMonth(new GregorianCalendar());

}

private void currentMonth(GregorianCalendar date) {

String maxDate=SHORT_DATE.format(date.getTime());

System.out.print(maxDate+" -> ");

int year=date.get(Calendar.YEAR);

int month=date.get(Calendar.MONTH);

int day=1;

GregorianCalendar currentMonthStartDay=

new GregorianCalendar(year, month, day);

String minDate=SHORT_DATE.format(currentMonthStartDay.getTime());

System.out.println("DATE BETWEEN '"+minDate+"' AND '"+maxDate+"'");

}

Előző hónap

Itt is érdemes készíteni két túlterhelt metódust. A paraméter nélküli változat az aktuális napot, a paraméteres változat a megadott napot tekinti kiinduló napnak, és ehhez adja meg az előző hónap első és utolsó napját. A két dátumnál az év és hónap megegyezik, a nap mindig különbözik. Mindkét dátum múltbeli és teljesül a minDate<maxDate feltétel. A megvalósítás kezeli az eltérő hosszúságú hónapokat és a szökőévet is. Ha a kiinduló dátum az adott év első hónapjába esik, akkor az előző hónap az előző év utolsó hónapja (ez most automatikusan teljesül, külön nem kell rá figyelni). Hasznos a dátumobjektum add() metódusa, ami az első paraméterében megadott dátummező alapján a második paraméterében megadott értékkel tudja változtatni a dátumot.

private void previousMonth() {

previousMonth(new GregorianCalendar());

}

private void previousMonth(GregorianCalendar date) {

System.out.print(SHORT_DATE.format(date.getTime())+" -> ");

date.add(Calendar.MONTH, -1); //előző hónap

int year=date.get(Calendar.YEAR);

int month=date.get(Calendar.MONTH);

int minDay=1;

int maxDay=date.getActualMaximum(Calendar.DAY_OF_MONTH);

String minDate=SHORT_DATE.format(

new GregorianCalendar(year, month, minDay).getTime());

String maxDate=SHORT_DATE.format(

new GregorianCalendar(year, month, maxDay).getTime());

System.out.println("DATE BETWEEN '"+minDate+"' AND '"+maxDate+"'");

}

Előző negyedév

Itt is hasznos lehet a két túlterhelt metódus. A paraméter nélküli változat az aktuális napot, a paraméteres változat a megadott napot tekinti kiinduló napnak, és ehhez adja meg az előző negyedév első hónapjának első napját és az előző negyedév utolsó hónapjának utolsó napját. A két dátumnál az év megegyezik, a hónap és a nap mindig különbözik. Mindkét dátum múltbeli és teljesül a minDate<maxDate feltétel. A megvalósítás kezeli az eltérő hosszúságú hónapokat. A szökőév most nem számít. Ha a kiinduló dátum az adott év első negyedévébe esik, akkor az előző negyedév az előző év utolsó negyedéve (erre most külön figyelni kell). A negyedév ( quarter) képletén látszik, hogy épít arra, hogy a dátumobjektumtól elkért hónap ( month) 0 bázisú.

private void previousQuarter() {

previousQuarter(new GregorianCalendar());

}

private void previousQuarter(GregorianCalendar date) {

System.out.print(SHORT_DATE.format(date.getTime())+" -> ");

int year=date.get(Calendar.YEAR);

int month=date.get(Calendar.MONTH); //0-11

int quarter=month/3+1

if(quarter==1) {

year--;

quarter=4;

}

else

quarter--;

//negyedév első hónapjának 1. napja

int minMonth=(quarter-1)*3;

int minDay=1;

GregorianCalendar min=new GregorianCalendar(year, minMonth, minDay);

String minDate=SHORT_DATE.format(min.getTime());

//negyedév utolsó hónapjának utolsó napja

int maxMonth=minMonth+2;

min.add(Calendar.MONTH, 2);

int maxDay=min.getActualMaximum(Calendar.DAY_OF_MONTH);

GregorianCalendar max=new GregorianCalendar(year, maxMonth, maxDay);

String maxDate=SHORT_DATE.format(max.getTime());

System.out.println("DATE BETWEEN '"+minDate+"' AND '"+maxDate+"'");

}

Eredmény

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 21-24. óra: Objektumorientált programozás, 2. rész kapcsolódik alapvetően, de a két visszakapott dátum használható több programozási tétellel (kiválogatás, szétválogatás) tömbbel, lambda kifejezésekkel kollekciókkal, SQL lekérdező parancsban adatbázis-kezeléshez kötődően.

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

2023. január 3.2019. május 9. Szerző: Kaczur Sándor

A 2019-es középszintű matematika érettségi feladatsor 16. feladata inspirált arra, hogy a programozás eszköztárával oldjuk meg ezt a feladatot. Szükséges hozzá néhány programozási tétel: sorozatszámítás, eldöntés, szélsőérték-kiválasztás, másolás. Érdekes belegondolni, hogy mennyire más lehetne a problémamegoldás, ha programozhatnánk a matematika érettségi vizsgán. A teljes feladatsor a megoldásokkal együtt letölthető az oktatas.hu-ról.

16. a) feladat

Péter elhatározza, hogy összegyűjt 3,5 millió Ft-ot egy használt elektromos autó vásárlására, mégpedig úgy, hogy havonta egyre több pénzt tesz félre a takarékszámláján. Az első hónapban 50000 Ft-ot tesz félre, majd minden hónapban 1000 Ft-tal többet, mint az azt megelőző hónapban. (A számlán gyűjtött összeg kamatozásával Péter nem számol.) Össze tud-e így gyűjteni Péter 4 év alatt 3,5 millió forintot?

1. megoldás

static void feladat16a1() {

int n=48, a1=50000, d=1000, an=a1+(n-1)*d,

sn=(a1+an)*n/2;

System.out.println("1. megoldás: összeg = "+sn);

}

Az 1. megoldás egyszerűen behelyettesít a számtani sorozat n-edik elemének ( an) és n-edik összegének ( sn) képleteibe. A kérdés (eldöntés): eléri-e az összeg a 3,5 millió Ft-ot? A válasz igen: a 48. iteráció/hónap után 3528000 Ft-ot kapunk.

2. megoldás

static void feladat16a2() {

int n=48, a1=50000, d=1000, sn=0;

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

int an=a1+(i-1)*d;

sn+=an;

}

System.out.println("2. megoldás: összeg = "+sn);

}

A 2. megoldás a sorozatszámítás programozási tételt használja. Minden hónapra (1-től 48-ig) meghatározzuk az aktuális havi összeget ( an) és növeljük vele a gyűjtőt ( sn).

3. megoldás

static void feladat16a3() {

int n=48, a1=50000, d=1000,

elozoHaviOsszeg=a1, sn=elozoHaviOsszeg;

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

int haviOsszeg=elozoHaviOsszeg+d;

sn+=haviOsszeg;

elozoHaviOsszeg=haviOsszeg;

}

System.out.println("3. megoldás: összeg = "+sn);

}

A 3. megoldás során az első hónapot külön kezeljük és a d differenciát/növekményt is folyamatosan – az előző havi összegből kiindulva – növeljük a ciklusban a 2.-tól a 48. hónapig 1000 Ft-tal.

4. megoldás

static void feladat16a4() {

int n=0, a1=50000, d=1000, sn=0, maxOsszeg=3500000;

while(sn<maxOsszeg) {

int an=a1+n*d;

sn+=an;

n++;

}

System.out.println(

"4. megoldás: összeg = "+sn+", hónap = "+n);

}

A 4. megoldás során megváltozik a kérdés: hányadik hónapban érjük el (vagy haladjuk meg) a 3,5 millió Ft-ot? A válasz: a 48. hónap/iteráció után és 3528000 Ft-ot kapunk.

16. b) feladat

A világon gyártott elektromos autók számának 2012 és 2017 közötti alakulását az alábbi táblázat mutatja.

Szemléltesse a táblázat adatait oszlopdiagramon!

Ezt most itt nem részletezem, mert hasonló grafikonrajzolásról blogoltunk máshol/máskor lásd:

16. c) feladat

Péter az előző táblázat adatai alapján olyan matematikai modellt alkotott, amely az elektromos autók számát exponenciálisan növekedőnek tekinti. E szerint, ha a 2012 óta eltelt évek száma x, akkor az elektromos autók számát (millió darabra) megközelítőleg az f(x)=0,122*2^0,822x összefüggés adja meg. A modell alapján számolva melyik évben érheti el az elektromos autók száma a 25 millió darabot?

1. megoldás

static void feladat16c1() {

double x=Math.log(25/0.122)/Math.log(2)/0.822;

System.out.println("x: "+x);

}

Egyszerű átrendezést és behelyettesítést követően az x: 9.341731310065603 eredményt kapjuk. Ebből következtethető, hogy 2012 után a 10. évben (azaz 2022-ben) érheti el az elektromos autók száma a 25 millió darabot.

2. megoldás

static void feladat16c2() {

double f=0, x=0;

while(f<25) {

f=0.122*Math.pow(2, 0.822*x);

System.out.println("x: "+String.format("%.2f", x)+

", f: "+String.format("%.2f", f));

x+=0.1;

}

A függvény behelyettesítését tizedenként közelítve végzi a ciklus, amíg el nem éri a 25-öt. Az utolsó eredményből ( x: 9,40, f: 25,84) ugyanaz következtethető, mint az 1. megoldásnál.

16. d) feladat

Egy elektromos autókat gyártó cég öt különböző típusú autót gyárt. A készülő reklámfüzet fedőlapjára az ötféle típus közül egy vagy több (akár mind az öt) autótípus képét szeretné elhelyezni a grafikus. Hány lehetőség közül választhat a tervezés során? (Két lehetőség különböző, ha az egyikben szerepel olyan autótípus, amely a másikban nem.)

static void feladat16d() {

String[] autoTomb={

"Hyundai Kona Electric", "Kia Soul EV", "Nissan Leaf",

"Peugeot iOn", "Renault Zoe"};

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

String i2=String.format("%05d",

new BigInteger(Integer.toBinaryString(i)));

System.out.print(i+"(10) = "+i2+"(2): ");

for(int j=i2.length()-1; j>=0; j--)

if(i2.charAt(j)=='1')

System.out.print(autoTomb[autoTomb.length-1-j]+", ");

System.out.println();

}

A metódust futtatva az alábbi eredményt kapjuk. 31-féle különböző reklámfüzet fedőlap készíthető:

1(10) = 00001(2): Hyundai Kona Electric,

2(10) = 00010(2): Kia Soul EV,

3(10) = 00011(2): Hyundai Kona Electric, Kia Soul EV,

4(10) = 00100(2): Nissan Leaf,

5(10) = 00101(2): Hyundai Kona Electric, Nissan Leaf,

6(10) = 00110(2): Kia Soul EV, Nissan Leaf,

7(10) = 00111(2): Hyundai Kona Electric, Kia Soul EV, Nissan Leaf,

8(10) = 01000(2): Peugeot iOn,

9(10) = 01001(2): Hyundai Kona Electric, Peugeot iOn,

10(10) = 01010(2): Kia Soul EV, Peugeot iOn,

11(10) = 01011(2): Hyundai Kona Electric, Kia Soul EV, Peugeot iOn,

12(10) = 01100(2): Nissan Leaf, Peugeot iOn,

13(10) = 01101(2): Hyundai Kona Electric, Nissan Leaf, Peugeot iOn,

14(10) = 01110(2): Kia Soul EV, Nissan Leaf, Peugeot iOn,

15(10) = 01111(2): Hyundai Kona Electric, Kia Soul EV, Nissan Leaf, Peugeot iOn,

16(10) = 10000(2): Renault Zoe,

17(10) = 10001(2): Hyundai Kona Electric, Renault Zoe,

18(10) = 10010(2): Kia Soul EV, Renault Zoe,

19(10) = 10011(2): Hyundai Kona Electric, Kia Soul EV, Renault Zoe,

20(10) = 10100(2): Nissan Leaf, Renault Zoe,

21(10) = 10101(2): Hyundai Kona Electric, Nissan Leaf, Renault Zoe,

22(10) = 10110(2): Kia Soul EV, Nissan Leaf, Renault Zoe,

23(10) = 10111(2): Hyundai Kona Electric, Kia Soul EV, Nissan Leaf, Renault Zoe,

24(10) = 11000(2): Peugeot iOn, Renault Zoe,

25(10) = 11001(2): Hyundai Kona Electric, Peugeot iOn, Renault Zoe,

26(10) = 11010(2): Kia Soul EV, Peugeot iOn, Renault Zoe,

27(10) = 11011(2): Hyundai Kona Electric, Kia Soul EV, Peugeot iOn, Renault Zoe,

28(10) = 11100(2): Nissan Leaf, Peugeot iOn, Renault Zoe,

29(10) = 11101(2): Hyundai Kona Electric, Nissan Leaf, Peugeot iOn, Renault Zoe,

30(10) = 11110(2): Kia Soul EV, Nissan Leaf, Peugeot iOn, Renault Zoe,

31(10) = 11111(2): Hyundai Kona Electric, Kia Soul EV, Nissan Leaf, Peugeot iOn, Renault Zoe,

A megoldást valósnak tekinthető adatokkal konkretizáltam. Az autók nevét ötelemű tömb ( autoTomb) tárolja. A számok 1-től 31-ig (tízes számrendszerben) öt biten 00001-től 11111-ig ábrázolhatók (vezető nullákkal) kettes számrendszerben. A bináris alakban előforduló 1-es bit jelöli a kiválasztott autó nevének autoTomb.length-1-j képlettel korrigált indexét (0-tól 4-ig) a tömbben.

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.