becslés - címke - it-tanfolyam.hu

Rómeó és Júlia

2023. január 1.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.

Hány éves a kapitány?

2023. január 1.2018. március 22. Szerző: Kaczur Sándor

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.

Lássunk egyet a népszerű „Hány éves a kapitány?” típusú feladatok közül!

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?

Hogyan használhatnánk a feladat megoldásához programozáshoz kötődő ismereteinket?

Állítsunk elő olyan három szorzótényezőt, amelyek szorzata 2450 és egyben írassuk ki az összegüket is a konzolra!

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:

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?

Az egyszer előforduló összegeket ki kell zárni, mert abból az első tiszt tudná az elefántok életkorát. Többször előforduló összegként marad a 64. Tehát az elefántok lehetnek 5, 10, 49, illetve 7, 7, 50 évesek. Mivel a kapitánynál idősebb az egyik elefánt, így a kapitány nem lehet 48 éves vagy fiatalabb (mert ekkor nem lenne egyértelmű az életkora), illetve nem lehet 50 éves vagy idősebb (mert ekkor nem lenne nála idősebb elefánt). Tehát a kapitány 49 éves.

(Másképpen megközelítve: a 2450 prímtényezős felbontása 2*5²*7², amiből ugyanezekre a következtetésekre juthatunk.)

A feladat további változatai

Egy hajó hosszának, az árbóc magasságának, a kapitány kisfia életkorának és a kapitány életkorának szorzata 303335. Hány éves a kapitány?
A kapitány most kétszer annyi idős, mint a hajója volt akkor, amikor a kapitány kétszer volt annyi idős, mint most a hajója. A kapitány és a hajója összesen 70 éves. Hány éves a kapitány?
A Fekete Kalóz néven elhíresült kalózkapitány egyik sikeres kalandja után kiszámíttatta saját maga és kisfia életkorának, valamint hajója hosszának a szorzatát. Az eredmény 26 159 lett, amelyet mint szerencseszámot egy medálra vésetett és mindig a nyakában hordott. Hány éves a kapitány? (A hajóhosszt méterekben mérték, és a mérőszám egész szám!)
Te vezeted az utasszállító repülőt. Budapesten felszáll 11 utas. Bécsben leszáll 5 és felszáll 9. Párizsban 1 kivételével mindenki leszáll. Hány éves a kapitány?
A kapitány hajója most 40 éves. Kétszer annyi idős, mint amennyi a kapitány volt akkor, amikor a hajó annyi idős volt, mint a kapitány most. Hány éves a kapitány?

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.

Ajánlott irodalom

Aki kedvet kapott és beszerezne néhány könyvet – tele érdekes, gondolkodtató, kreatív, logikai feladatokkal – ajánlom az alábbiakat:

Katona, R. (szerk): Logikai egypercesek – az elme játékai, 2. kiadás, DFT-Hungária Könyvkiadó, Budapest, 2006, ISBN 963 9473 55 3
Róka, S.: 2×2 néha 5? – Paradoxonok, hibás bizonyítások, Tóth Könyvkereskedés és Kiadó Kft., Debrecen, 2008, ISBN 963 5965 24 3
Károlyi, Zs.: Csak logIQsan!, 2. javított kiadás, Typotex Elektronikus Kiadó Kft., Budapest, 2017, ISBN 963 279 693 5
Róka, S.: Egypercesek – Feladatok matematikából 14-18 éveseknek, Tóth Könyvkereskedés Kft., Debrecen, 1997
G. Nagy, L.: A világ legújabb logikai rejtvényei, Magyar Könyvklub, H. n., 2001, ISBN 963 547 512 8

Haladóknak ajánlom

Smullyan, R.: A hölgy vagy a tigris? – és egyéb logikai feladatok, 2. javított kiadás, Typotex Kiadó Kft., Budapest, 2002, ISBN 963 7546 63 4
Smullyan, R.: Mi a címe ennek a könyvnek? – Drakula rejtélye és más logikai feladványok, Typotex Elektronikus Kiadó Kft., Budapest, 1996, ISBN 963 7546 64 2
Shasha, D.: Dr. Ecco talányos kalandjai, Typotex Kiadó – SHL Hungary Kft., 2000, ISBN 963 9132 72 1

Nemzetközi Pi nap

2023. január 1.2018. március 14. Szerző: Kaczur Sándor

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. Viète-féle sor

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).

2. Leibniz-féle sor

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).

3. Wallis-formula

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.

4. Csebisev-sor

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.

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

2023. január 3.2017. május 11. Szerző: Kaczur Sándor

A 2017-es középszintű matematika érettségi feladatsor 12. feladata inspirált egy Java program megírására. Szükséges hozzá néhány programozási tétel: sorozatszámítás, megszámolás, valamint adatszerkezetként ideális egy kétdimenziós tömb. É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

Egy kockával kétszer egymás után dobunk. Adja meg annak a valószínűségét, hogy a két dobott szám összege 7 lesz! Válaszát indokolja!

Matematikai megoldás

A feladat nagyon egyszerű. Két megoldást ismertet a javítási-értékelési útmutató:

Összesen 6 * 6 = 36-féleképpen dobhatunk. Hat olyan dobáspár van, amelyben 7 az összeg: (1; 6), (2; 5), (3; 4), (4; 3), (5; 2) és (6; 1). A keresett valószínűség 6/36-od, vagyis egyhatod.
Bármennyit is dobunk elsőre, ezt a második dobás egyféleképpen egészítheti ki 7-re. Így a második dobásnál a hat lehetséges értékből egy lesz számunkra kedvező. A keresett valószínűség egyhatod.

Közelítő megoldások szimulációval

Egy alkalom két kockadobást jelent egymás után. A dobások sorrendje nem számít (alkalmanként és összességében sem). Minél több alkalommal végezzük el a kockadobásokat, annál jobban megközelítjük a fenti valószínűséget (várható értéket, bővebben: nagy számok törvénye). Az egyhatod közelítő értéke a Java double adattípusával 0.16666666666666666.

1. megoldás

Ha nem akarunk emlékezni a dobásokra, összegükre, csupán megszámolnánk, hogy hány olyan dobáspár van, amelyben 7 az összeg, akkor ehhez mindössze egy számláló ciklus kell, aminek a ciklusmagjában két véletlen kockadobás összegét előállítjuk és növelünk egy számlálót/gyűjtőt, ha az éppen 7. Az eredményt a számláló és a ciklus lépésszámának hányadosa adja meg. Például meghívhatjuk a metódust így: kockadobas1(5000); és kaphatjuk eredményül ezt: 5000 alkalomból 7 összegként 836 alkalommal fordult elő. Valószínűség: 0.1672 . A metódus kivételt dob, ha értelmetlen a paramétere. Íme a metódus Java forráskódja:

static void kockadobas1(int alkalomDb) {

if(alkalomDb<=0)

throw new IllegalArgumentException("Hiba: alkalomDb<=0");

int osszeg7db=0;

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

int dobas1=(int)(Math.random()*6+1);

int dobas2=(int)(Math.random()*6+1);

if(dobas1+dobas2==7)

osszeg7db++;

}

System.out.println(

alkalomDb+" alkalomból 7 összegként "+

osszeg7db+" alkalommal fordult elő. Valószínűség: "+

((double)osszeg7db/alkalomDb));

}

2. megoldás

Ha egy 13 elemű egész típusú tömböt használhatunk emlékezetként. Kezdetben 2-től 12-ig indexelve nullázzuk ki, így csoportos gyűjtést tudunk megvalósítani. A nullázás most inicializáló blokkal történt, mert nem sok eleme van a tömbnek (sok elemnél inkább használjunk erre ciklust). A tömb első két elemét nem használjuk semmire. Mi történik a ciklusban? Például dobas1=3 és dobas2=4 esetén a dobasDbTomb[7] elemét növeli (mindegy mi volt ott korábban, de inkrementálódjon). Most több adatot tárolunk, mint amiből megválaszolható a feladatban megfogalmazott konkrét kérdés, de ezt tekinthetjük strukturális tartaléknak.

static void kockadobas2(int alkalomDb) {

if(alkalomDb<=0)

throw new IllegalArgumentException("Hiba: alkalomDb<=0");

int[] dobasDbTomb={-1, -1,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

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

int dobas1=(int)(Math.random()*6+1);

int dobas2=(int)(Math.random()*6+1);

dobasDbTomb[dobas1+dobas2]++;

}

System.out.println(

alkalomDb+" alkalomból 7 összegként "+

dobasDbTomb[7]+" alkalommal fordult elő. Valószínűség: "+

((double)dobasDbTomb[7]/alkalomDb));

}

Hasonló, egydimenziós tömbbel történő belső adattárolást megvalósító elosztott alkalmazásról blogoltunk már: Kockadobás kliens-szerver alkalmazás.

3. megoldás

Ez az igazi szimuláció, swing GUI grafikus környezetben, ahogyan az alábbi képernyőképen látható. A megvalósítás kétdimenziós tömböt használ adatszerkezetként. Álljon 7 sorból és 7 oszlopból és legyen i a sor- és j az oszlopindex. A tömb [0][0]-dik elemét nem használjuk semmire. Az első oszlopába ( j=0 és i>0) bekerülhetnek a dobókockán előforduló számok 1-től 6-ig. Hasonlóan az első sorba ( i=0 és j>0) is. Ezek a dobott számok alapján indexek lesznek és az ábrán zöld hátterű cellákba kerültek. A tömb többi eleme kezdetben 0 (nulla), ezek az ábrán fehér hátterű cellák. A szürke hátterű cellák (mellékátló) esetén a dobott számok összege 7 és jól látszik, hogy ez hatféleképpen fordulhat elő a 36-féle eset közül. Például a 2. sor 5. oszlopában lévő szám mutatja, hogy a 10000 alkalomból 274-szer fordult elő az, hogy a dobáspár a (2; 5) lett. A tömb két indexe felcserélhető lenne, mert ez a mellékátlóban lévő számok összegét nem befolyásolja.

A programban kiválasztható néhány alkalomból amit szeretnénk, és a Dob nyomógombra kattintva indul el időzítővel a folyamat. Várakoztatás/menet közben piros színnel kiemelve látszik/megfigyelhető, hogy az éppen aktuális dobás hol növeli az értéket/előfordulást/darabszámot. A képernyőképen befejeződött állapot látható. Az eredményt a szürke cellákban lévő számok összegének és az alkalmak számának hányadosa adja meg. Ezt a háttérbeli kétdimenziós tömbben összesítéssel az alábbi Java forráskód-részlet adja meg:

int osszeg7db=0;

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

osszeg7db+=dobasTomb[i][7-i];

String eredmeny=alkalomDb+" alkalomból 7 összegként "+

osszeg7db+" alkalommal fordult elő.";

Most lényegesen több adatot tárolunk, mint ami a konkrét válaszhoz kell, de cserébe jól érzékeltethető a csoportos gyűjtés/megszámolás működése. A program grafikus felhasználói felületének felépítését és az eseménykezelés megvalósítását most nem részletezzük.

Eszünkbe juthatna, hogy a program miért dob kétszer 1 és 6 közötti számot egymás után és ezt összegzi, amikor egyetlen 2 és 12 közötti dobással (véletlenszám generálással) megkaphatnánk a dobáspár összegét. Hiszen két db 1 és 6 közötti szám összege mindig 2 és 12 közötti szám. Jó lenne ez az ötlet/megvalósítás? Igen? Nem? Miért? A hozzászólásokhoz várjuk az indoklást.

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

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

A feladat a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 17-28. óra: Objektumorientált programozás alkalmaira épülő 29-36. óra: Grafikus felhasználói felület alkalmaihoz kötődik.