2018. június 18., hétfő

Pallindrom


Nádasi K. Ottó Kis-Adán, májusi szerdán e levelem írám. A mottó: Szivedig ime visz irás, kellemest író! Szinlelő sziv rám kacsintál! De messzi visz szemed… Az álmok (ó csaló szirének ezek, ó csodaadók) elé les. Irok ime messze távol. Barnám! Lám e szivindulat Öné. S im e sziv, e vér ezeket ereszti ki: Szivem! Ime leveled előttem, eszemet letevő! Kicsike! Szava remegne ott? – Öleli karom át, Édesem! Lereszket évasziv rám. Szivem imád s áldozni kér réveden – régi gyerekistenem. Les im. Előtte visz szived is. Ég. Érte reszketek, szeret rég és ide visz. Szivet – tőlem is elmenet – siker egy igérne, de vérré kinzod (lásd ám: ime visz már, visz a vétek!) szerelmesedét. Ámor (aki lelőtt ó engem, e ravasz, e kicsi!) Követeltem eszemet tőled! E levelem ime viszi… Kit szeretek ezer éve, viszem is én őt, aludni viszem. Álmán rablóvá tesz szeme. Mikor is e lélekodaado csók ezeken éri, szól: A csókom láza de messzi visz!… Szemed látni csak már!… Visz ölelni!… Szoríts!… Emellek Sári szivemig. Ide visz Ottó. Ma már ím e levelen ádresz is uj ám: Nádasi K. Ottó Kis-Adán.

Belő darálók sittesze, vesz e társas toll. Ó, ha mesék éberek is, olasz a nő, az alig ír, buta. Klappol a gúny, a para, ha jászberényi se réved. Ede vérröge rémes, na. Bán lábasok elé lerakat, üresek. Erős inka hasában rab, mozog a marása, ha kormos. Aszú hóra, szerkőn ő rőt. E Szécsi Pál a halápi csészetörő, nőkre szaró húszasom róka hasára magozom. Barnabás, a hakni söre keserűt akar! Elél e kos a bálnában, s e méregőr réved. Ede, véres íny ér, eb szája harap. Anyu, galoppalkatú Brigi laza önaszaló, sikere békés-e? Ma hollót sas rátesz, e veszett iskolára dől eb.

Eső, hódara, merő jégeres a Tisza, tar rák, szorul a huroksík. Gém, a mamád beszárít Ági-töreket, lefesti remekül a gebe. Rőzsedalú imára ír ki mimóza tulajjal utazó mimikri, arámiul a Dezső rebeg, a lüke merítse! Felteker, ötig átír ász, eb, dáma! Ma még kiskorú halúr Oszkárra taszít, a seregély őre marad, ó, hős-e?

Ön óv Ottót, a vak asszír is. Rí szotyoladobó, bánt is e mentolos út. Táci e régi bor, a vakolatjel, ó, néz rám székilile-szem. Eldob a hatóság agya, kelet rekkenő híre, botkocsány. Ég el a bálozó, rí vargabetű, tar ausztrál vekni. Csikósé a bér, ó, halkan hasít Elek. Panel, Ági-ridikül lemarad, óh, ki se lógat Nagy Ernő, ó, Ida, magőr ő. Cserre néző kósza lett erők, mór kajakosok, tufa te is, a járóletét gélelegye is ómódi. Kis, ámori patak a bálon a horkantó, Benőt, agutit, Natit, Antit ugat. Ön e botnak rohanó láb. A Kata-pír, ó, másik idom, ó, sí, egyel elégtétel órája. Siet a futkosó kaja króm körettel, a szóközén erre csörög ama dió. Önre gyantagól esik, hódaramellű, ki dirigál e napkeleti sahnak Lahoréba. És, ó, kicsin kevlárt szú arat, üt, eb, a gravírozó lába. Legényács, októberi hőnek kertelek agyagásót. A habod lemeszel, Ili, kész már Zénó. Lejt a ló kavaró bigére, Icát, tusolót nemesít nábobod. A lotyó szír, s Írisz szakavatott óvónő.


Rág ló botló barettet, ledob, ó, bánatos irtóra, ma Nóri zsalugátere őt űzi. Mert Tomanek a Dóri, a merő lápadó kölök üszkösön tör előre. Békavőn lóg a mocsári gólyahír, éle Kelemené. Menórák, kóser ekék ízöle véres. Öl e vendég, e sóláp, Akropolisz ős-Ilibe dől. Mór, ó, Bátaszék, a rákos strófa meszel le szemafort, s sokára kész a táborom. Lő debilis őszi ló, porkapáló segédnevelő serével őzikék ere sok. Káró, nem én emelek, eléri, ha jógi rácsomagol. Nő vak éber öle rőt, nősök, szűkölök, oda Pál őre ma! Ír odaken, amott remiz ütőere tágul a zsíron. A maró trisót a nábobod eltette, raboltó bolgár.



2018. június 9., szombat

A mai órán káoszelmélettel fogunk foglalkozni

 Ha nem látunk át egy komplex rendszert akkor azt káosznak nevezzük. A számítástechnika alapépítőkövei a 0 és az 1 és ezekből elő tudjuk állítani a legbonyolultabb struktúrákat is és így válik a káosz visszavezetve az alapokhoz érthető és áttekinthető rendszerré. Nézzük ezt kiszélesítve egy kicsit.  A számítástechnika fejlődése lehetővé tette számítási felhők alkalmazását és ezáltal komplex rendszerek modellezését egy rövid t idő intervallumban. A komplex rendszerek működésének pontos meghatározása azért nem volt lehetséges mert túl sok ismeretlen tényező formálja, és elég egy tényező apró változása ahhoz, hogy t idő múlva egy nem reguláris eredmény szülessen, ezt nevezik a pillangóhatásnak. A bonyolult rendszereknek bonyolult lehet a viselkedésük is. A káoszelméletemmel igazolni fogom, hogy az egyszerű, néhány állapotjelzővel leírható determinisztikus rendszerek is mutathatnak összetett, megjósolhatatlan viselkedést, mert a statikusan leírható tényezőket is befolyásolják olyan tényezők amelyeket nem ismerünk és már kaotikus lett a legkisebb feltételrendszer is. A káosz a viselkedés lokális instabilitásának és a globális keveredésnek az együttese, ami nem rendetlenséget, csupán az összefüggések átláthatatlanságát vagy a tényezők egymásra gyakorolt hatását jelenti. A viselkedés lokálisan instabil, ha egymáshoz közeli kezdőhelyzetből indítva a rendszert a kis különbségek is az idő tényező hatására gyorsan nőnek, ami globális keveredéshez vezet és az összes lehetséges állapothoz közel kerül a rendszer, ha elég hosszú időt hagyunk neki. A determinisztikus rendszerek mellett a nem determinisztikus rendszerek felé is elfordulhatunk ami már a kvantumkáosz-elmélet irányába sodor bennünket és láthatjuk még az elméletünk is két irányba mutat ahogy belép egy újabb tényező, ami kísértetiesen hasonlítani kezd egy fraktálra egy permutációra és egy exponenciális matematikai képletre, ami tudjuk hogy az idő tényező előrehaladtával egy kaotikus állapot felé halad. A hópihe is fraktál, a fraktáloknak az a furcsa tulajdonsága, hogy nagyon egyszerű szabályokkal leírhatók, mégis nagyon bonyolult alakzatokat eredményeznek. Most következik az a látszólagos paradoxonom, hogy az ember elég buta ahhoz, hogy azt képzelje magáról hogy elég okos ahhoz, hogy megjósolja a jövőt. Ugyan szeretné tudni a jövőt, miközben nem ismeri a jövő formálásában résztvevő valamennyi tényezőt, minta egy vakembert kérnénk meg rá rajzolja le milyen a virágzó mező, miközben sohasem látta. Analógiára és ismétlésre építjük teóriánkat, miközben a káoszelmélet olyan nemlineáris dinamikus összetett rendszerek viselkedését írja le, ahol az őket meghatározó determinisztikus törvényszerűségek csak ritkán érvényesek és akkor sem olyan gyakorisággal ahogyan azt a diszkrét matematikával igazolhatnánk. Azt mondják valószínűségre építenek, nézzünk rá egy példát, annak valószínűsége hogy 6-szor dobok hatost szinte 0, és mégis képes vagyok hatost dobni egymás után hatszor, vagyis vannak ismétlések, de azok között nincsenek törvényszerűségek. Ezek ismeretében, azokat az embereket akik meg akarják jósolni a jövőheti nyerőszámokat minek nevezzem? Mi is írtunk programokat amik meghatározzák a folyamat végeredményét, de a mi programjaink egyszerű függvényekkel leírhatók és véges számú lépésekből állnak.
Az általunk vizsgált dinamikai rendszert folytonos differenciál egyenletekkel tudjuk leírni a kapott eredmény a fázistérben hibás lesz, mert bizonyos adott időközönként jegyezzük fel a rendszer fázistérbeli helyzetét illetve pillanatnyi állapotát. Számtalan leképezéselmélet létezik de mindegyik sántít az itt leírtak miatt. A kaotikus rendszer tehát gyakran szabálytalan mozgást eredményez, a kis kezdeti eltérések exponenciálisan nőnek az idő függvényében és a komplex rendszerekre jellemző bonyolult fázistérbeli geometria alakzatokkal írható le topológikus entrópiával, mint a fraktálelméletek. A periodikus pályák száma exponenciálisan nő a periódus hosszának növekedésével
a kaotikus disszipatív rendszerekben a mozgás hosszú idő után egy bonyolult geometriájú alakzaton, különös attraktoron zajlik, ezt a struktúrát a fraktáldimenzióval elég nehéz leírni. A konzervatív erőknek különleges szerepük van a fizikában, mert csak ilyen erők által végzett munka független az úttól, továbbá a mechanikai energia is csak konzervatív erők esetén állandó. A természetben azonban találkozunk olyan erőkkel is, amelyek nem konzervatívak, mint a keletkezett hő vagy a súrlódási erő, az időtől vagy a tömegpont sebességétől függő erő. Ezek a nem konzervatív tényezők tovább igazolják a káoszelméletemet. Persze a tévesen konzervatív rendszerként kezelt komplex rendszerek nem mutatnak fraktáltulajdonságot, a reguláris szigetek úgynevezett kövér fraktált alkotnak, ami téves következtetéseket eredményez, lásd a meteorológiát. A határérték számítás segítségével kitudjuk számolni a görbe vonalak által határolt területet, de még azt is csak némi hibaszázalékkal,és azt képzeljük magunkról megtudjuk határozni egy ciklon irányát, miközben több ezer általunk nem ismert pillangóhatás befolyásolja, mi ez ha nem az emberi butaság superlativusa. Differencia egyenletet használnak modellezésére és ha találnak egy ismétlést ami permutáció eredménye törvényszerűséget építenek fölé. Az absztrakt algebrában és a kombinatorikában egy a halmaz permutációján annak önmagára vett bijektív leképezését értjük, de az lehet egy végtelen halmaz is ami a mi modellezésünkben persze véges, ami egy téves konklúzióhoz vezet, mert az elemek egy meghatározott ponton vizsgált  átrendezését látjuk, de ez korántsem a végeredmény. Viszont a kaotikus esetben abszolúte nem lehet megjósolni egy adott kiindulópontból, hogy mi lesz a következmény, látható, hogy a kiindulóállapotban egy aprónak tűnő momentum is az időtényező változásával egy merőben más eredményt hoz.

A természetes rendszerek többsége (mint pl. az időjárás) olyan, mint az állatpopuláció kaotikus r értékkel. Ebben az esetben pedig már egy nagyon kicsi eltérés is a kezdeti feltételekben elég ahhoz, hogy a közeli jövő teljesen megváltozzon. Az, hogy a pillangó meglebegteti-e a szárnyát vagy sem, apró, látszólag jelentéktelen eltérés. Ám a jövő módosul, és többé senki nem tudja megjósolni, hogy az eső esni fog-e vagy sem. A gyakorlatban nem tudunk minden apró részletet figyelembe venni, ám mivel az apró részletek is megjósolhatatlanná teszik a jövőt egy kaotikus rendszerben, lehetetlen hosszú távon jövőbe látni. Néhány napnál hosszabb előrejelzéseket soha nem adnak, vagy csak nagy vonalakban, mert nagy a szórás. Pedig az időjárást leíró fizikai képleteket nagyon jól ismerjük, és vannak elég gyors számítógépek ahhoz, hogy akármekkora távra előre kiszámolják a jövő időjárását a jelen helyzetből kiindulva, de a befolyásolótényezők is fraktálban vannak és ezért ott is gigantikus variációk és permutációk alakítják a végeredményt. A differenciális egyenletekkel akarjuk leírni a nem differenciális valóságot. Íme egy hipotézisem; a világ körökből áll. Bizonyítsa be valaki az ellenkezőjét, bizony beletörik a bicskája a nagy Nobeldíjjas tudósoknak, pedig én csak egy egyszerű ember vagyok aki felvetett egy elméletet. Lássuk az én érvelésemet; A gömb a legegyszerűbb 3D alakzat, amit a legkönnyebb leírni egy függvénnyel és most azt állítom minden körökből épül fel. Végtelen kicsi pontok, amik valójában gömbök.  A fraktálelmélet értelmében végtelen bonyolult alakzatok állíthatók elő belőle, végtelen permutációk és változatok, az idő múlásával. A gömb végtelen körből épül fel, amivel tovább bontom az elméletemet. Ezért hiba lineáris egyenletekkel leírni nem lineáris kompex rendszerek működését.
A káosz szó használata megtévesztő lehet arra a jelenségre, amit a tudományos életben kaotikusnak nevezünk. A káosz mindennapi értelemben zűrzavart jelent, ami a tudományos értelmezésben félreértésre adhat okot. Ekkor a káosz jelenség merőben eltér a hétköznapi értelemben vett jelentésétől. Sőt, ha megnézzük a szó eredeti görög jelentését is, ami üresség vagy semmi, akkor fokozottan igaz ez. A tudományos közfelfogásban tárgyalt káosz jelentése merőben más, és nehezen is definiálható.
Általában úgy gondoljuk, hogy valamilyen matematikai, vagy fizikai jelenségről van szó. De a káosz sokkal több ennél, átszövi az életünk minden területét, ezáltal, a matematika, a fizika mellett, a közgazdaságtan, biológia, ökológia, szociológia tudományok szótárában is megtaláljuk. És bár a káosz természettudományos következményei alapvetően újak és fontosak, nem sajátíthatja ki emiatt egyetlen tudomány sem. A káosz minden természettudomány, sőt minden olyan tudomány sajátja, melyben a matematikai leírás hasznosnak bizonyul.
Ebből is következik, hogy a káosz fogalmára pontos definíció nem létezik, de a fogalom tisztázásának érdekében fontos annak értelmezése. A legegyszerűbb, és a matematikusok által javasolt meghatározás így hangzik: A káosz a determinisztikus rendszerekben előforduló sztochasztikus viselkedés. Mint említettük a káosz fogalmára nem találunk egzakt definíciót.     Egyfajta periodikusság nélküli rend. Látszólag véletlenszerűen ismétlődő viselkedés egy egyszerű determinisztikus (óraműszerűen viselkedő) rendszeren belül. A determinisztikus nemlineáris dinamikus rendszereken belüli instabil, aperiodikus viselkedés kvalitatív tanulmányozása. Az egyszerű, beépített véletlenszerű vonások nélküli modellek azon képessége, hogy nagyon szabálytalan viselkedést tanúsítsanak, vagyis jelenség amelyben szabályszerűséget keresünk, és megpróbáljuk leírni lineáris egyenletekkel. A fraktál egy olyan topológia, amely egyszerű szabályokkal leírható, ám minden szinten ismétli önmagát így végtelenségig növelhető. A fázisdiagram egy rendszer összes tulajdonságát együtt tartalmazó ábra, amely a rendszer lehetséges állapotait tükrözi.A pillangó-effektus kaotikus rendszerekben gyakori, hogy a kiindulási feltételek kismértékű megváltoztatása is nagy mértékű változásokat idéz elő egy rendszer állapotában x időn belül.A differencia egyenlet egy olyan képlet, amelynek segítségével egy rendszer jelenlegi állapotát ismerve a következő megkapható, vagyis aminek a segítségével sorozat alkotható. Pl.:   xn+1 = r xn (1 - xn ) így a differenciál egyenlet képlete ami a rendszer pillanatnyi állapotát és annak változását írja le. A nemlineáris egyenletek olyan differenciálegyenlet, amelyben a függő változó végtelen sok értéket vehet fel a tényezők nagy száma miatt egy exponenciálisan változó hibás eredményt ad.
A káoszelmélet egy új, kialakulóban lévő tudomány, amelynek a fókuszában a nemlineáris rendszerek vannak. A káosz fogalom értelmezéséből is láthatjuk, hogy a káoszelmélet inerdiszciplináris tudomány. A káoszelmélet átlépi a tudományágak határait, s a rendszerek általános természetének tudománya lévén, közelebb hozza egymáshoz a korábban szigorúan elkülönült területek kutatóit. A káosz kutatása nagyon sok olyan kérdést vet fel, amely a tudomány szokásos kutatási módszereinek lehetőségeit meghaladja. Az elmélet jól csengő nevén túl számtalan új fogalommal gazdagította eddig is a képünket a világról. Az egész tehát több mint a részek összessége! A bonyolult rendszerek, a kaotikus jelenségek mint a felhők mozgása, a villámlás irányvonala, a vérerek mikroszkopikus összefonódása, a csillagok galaktikus tömörülése és a tőzsdei árfolyam-ingadozások a lottósorsolás, a cunamik, a földrengések, az aszteroidák mozgása mind felvetnek kérdéseket amikre választ nehéz adni. Kijelenthetem hogy a káosz ott kezdődik, ahol a klasszikus tudomány véget ér.Természetéből adódóan a káosz dinamikus jelenség, akkor fordul elő, amikor valami megváltozik. A változásnak ebben az értelemben két formáját határozhatjuk meg egyrészt a klasszikus fizika és dinamika által vizsgált változásokat, másrészt a kaotikus változásokat. Azokat a dolgokat, amelyek egy adott szituációban megváltozhatnak a káoszelméletben is változóknak nevezzük. Az egyszerűség és komplexitás, illetve a rendezettség és rendezetlenség közötti mélyen rejlő összefüggések feltárása révén összekapcsolja mindennapos tapasztalatainkat a természet törvényeivel. Olyan világegyetemet mutat be, ami egyszerre determinisztikus és a fizika alaptörvényeinek engedelmeskedik, ám ugyanakkor képes arra is, hogy rendezetlen, komplex és előrejelezhetetlen legyen. Megmutatja, hogy az előrejelezhetőség ritka jelenség, s csak azokon a határokon belül működik, amelyeket a tudomány kiszűrt összetett világunk sokféleségéből.     Lehetőséget teremt arra, hogy leegyszerűsítsünk komplex jelenségeket. Egyesíti a képzeletgazdag matematikát a modern számítógépek lenyűgöző számító kapacitásával. Kétségbe vonja a tudomány hagyományos modellépítő eljárásait. Megmutatja, hogy a megértésnek és a jövőbeli események előrejelzésének minden összetettségi szinten önmagukból fakadó korlátai vannak.
    A lélegzetelállító számítókapacitás, ami lehetővé teszi a kutatók számára, hogy másodpercek alatt akár több száz millió bonyolult számítást is elvégezzenek. A számítókapacitás növekedésével együtt megnőtt a tudományos érdeklődés az olyan rendhagyó jelenségek iránt, mint pl.:
        az időjárás véletlenszerű változásai,
        a járványok terjedése,
        a sejtek anyagcseréje,
        a rovarok és madarak számának ingadozása,
        a civilizációk felemelkedése és bukása,
        az impulzusok terjedése az idegek mentén stb.
    A káoszelmélet akkor született meg, amikor az említett fejlemények a geometriai matematika egy új ágában egyesültek, amely túllépett az euklideszi geometria ismert alakzatain és eljutott a fraktál geometria nem euklideszi struktúráiig.
A kaotikus rendszer állapotaira jellemző, hogy mozgásegyenletekkel, nem lineáris differenciál egyenletekkel írható le mozgásegyenlet egyik állapotból egy másik állapotba viszi a rendszert a rendszer viselkedését nyomon követjük bizonyos állapotfejlődési görbék, trajektóriák segítségével a trajektóriák (idő utak, időösvények) viselkedéséből következtetni lehet arra, hogy a rendszer káoszmentes vagy kaotikus a viselkedése. Kaotikus viselkedés esetén a két trajektória a fázistérben gyorsan, exponenciálisan távolodik, divergál egymástól az idő múlásával. A kaotikus rendszerek erősen és gyengén kaotikus rendszerek lehetnek. Az erősen kaotikus rendszerekben a trajektóriák exponenciális görbe mentén távolodnak egymástól, a kis hibák felerősödnek az exponenciális hibaerősítő mentén. A gyengén kaotikus rendszerekben a trajektóriák parabolikus görbe mentén távolodnak egymástól. A káosz határát súrolják, de nem érik el. A gyengén kaotikus rendszerek nyílt rendszerek, amelyek kölcsönhatásban vannak a környezettel. Sohasem kerülnek egyensúlyi állapotba, hanem egyik metastabil állapotból jutnak a másikba. Ezek a rendszerek tulajdonképpen stabilak, mert fennmaradnak a változó körülmények mellett is, hiszen rugalmasan reagálnak a megváltozott feltételekre. Kaotikus viselkedés esetén csak rövid távra lehet egzakt előrejelzést készíteni. Hosszú távon a trajektóriák exponenciálisan távolodnak egymástól, s nehéz következtetni hol létükre. A távolodás sebessége 0-hoz konvergál. Hosszú távú előrejelzés csak a kezdeti feltételek végtelen pontosságú ismeretében lenne lehetséges. Nem-kaotikus viselkedés esetén a jelenben egymáshoz közeli két trajektória nem távolodik egymástól, illetve a távolodás kicsiny mértéke hosszabb távon is lehetőséget ad az egzakt előrejelzéshez. A kaotikus viselkedés oka a rendszer nemlineáris természete. Ez azt jelenti, hogy a rendszer valamely, input paraméterének megváltozására adott válasza nem arányos a szóban forgó változással. Nemlineáris természetű pl. az időjárás, a folyadékok turbulens áramlása. A nem-linearitással kapcsolatos problémák tehát a fizika, a kémia, sőt a biológia és a társadalomtudományok területén is megjelentek. Ezért e tudományok a nem-linearitást, mint a társadalom számos területén megjelenő, azonos jellemzőkkel leírható interdiszciplináris jelenséget kezdték vizsgálni. A nemlineáris rendszerek rendkívül érzékenyek a kezdőfeltételekre. A kezdőfeltételekre való érzékenység jól érzékelhető az ún. pillangóeffektussal. A pillangóeffektus kifejezéssel szimbolizált érzékenység úgy illusztrálható, hogy egy pillangó finom szárnycsapásai egy távolabbi régióban hatalmas szélviharokat, hurrikánokat idézhetnek elő. Azaz a mikroszkopikus méretű változások makroszkopikus méretűvé transzformálódnak. Ezt a jelenséget a kis okok (generálta) nagy hatások jelenségének is nevezik. Kaotikus viselkedés esetén a jövőre vonatkozóan különböző pályák jelennek meg, vagyis bekövetkezik a bifurkáció jelensége, ami kettéágazást jelent. Ha a nemlineáris rendszerek viselkedését leíró differencia- és differenciálegyenletekben az egyensúlyi pont instabillá válik, akkor alakul ki a bifurkáció. Úgy is fogalmazhatjuk, hogy nemlineáris egyenletek esetén előálló, minőségileg eltérő megoldások együttese. Bifurkáció esetén tehát a periodikus kettőződés jelensége áll fenn, amit további perióduskettőződések sorozata követhet. A rendszer két, egymástól lényegesen eltérő állapotú viselkedési formát vehet fel. A periódus-kettőződés a káoszhoz vezető egyik út, aminek során egy oszcilláló rendszer periódusa ismétlődően megduplázódik valamely paraméterének megváltoztatása folytán. A bifurkáció kialakulásakor egy dinamikus rendszer átalakulása megy végbe, általában stabilabb és egyszerűbb állapotából kevésbé stabil és komplexebb állapotába. Szemléletesen is ábrázolható, hogy egy adott szervezettségi szinten stabil rendszert a felerősödő fluktuációk kibillentik stabil egyensúlyi állapotából, és kritikus instabil helyzetbe vezérelhetik. A kritikus instabil helyzetből többféle átmeneti út (bifurkációk) vezetheti el a rendszert általában magasabb szervezettségi szinten megjelenő új stabil állapotba. A bifurkáció alábbi típusai különböztethetők meg: finom hajszálnyi - sima és egyenletes átalakulás,     katasztrofális - hirtelen átalakulás, explozív - hirtelen és nem-folytonos tényezők a rendszert egyik állapotból egy másikba transzformálják.

Bifurkáció esetén a periódus-kettőződés jelensége áll fenn, amit további perióduskettőződések sorozata követhet. A periódus-kettőződés a káoszhoz vezető egyik út, aminek során egy oszcilláló rendszer periódusa ismétlődően megduplázódik valamely paraméterének megváltoztatása folytán. A periódus-kettőződés révén kaotikussá váló periodikus rendszerek esetében a rendszer állapotának periódusa újra meg újra megduplázódik (amíg a periódus végtelen hosszúvá nem válik). Másként fogalmazva, ha egy rendszer egy vagy több paraméter megváltoztatásának hatására nem-periodikus időfüggésűvé válik, akkor a rendszer a káosz felé tart. Az attraktor a rendszer viselkedését hosszú távon mutató geometriai forma, a stabil fixpontok által alkotott ciklusok. Az attraktor - mint ponthalmaz - magához vonzza azokat, a különböző kiindulási feltételekhez tartozó trajektóriákat, amelyek pályája a rendszert érő enyhe zavar esetén végül visszatér az attraktorhoz. Egy rendszerhez több attraktor is tartozhat, hiszen különböző kiinduló feltételek eltérő attraktorokat hozhatnak létre.
A matematikai algoritmusokat a számítógépes programok transzformálják geometriai formákká.

Az attraktoroknak két fajtája ismeretes: az egyszerű és a különös attraktor. Az egyszerű, nem-kaotikus attraktor kétféle formában jelenik meg:  csillapodó oszcilláció, másképpen fixpontú attraktor = stacionárius állapot, periodikus oszcilláció = oszcilláció a stacionárius állapot körül.

A különös attraktor kaotikus attraktorként ismert. Ez esetben az explozív oszcilláció nem-stacionárius állapotot idéz elő a nem lineáris rendszerekben. A jól ismert Lorenz attraktor számítógépes rajzai szemléletesen mutatják, hogy a káosznak struktúrája van, ami elegendő számú számítógépes futással kimutatható. A fraktálok tört dimenziójú kaotikus attraktorok, nem egész dimenziójú matematikai struktúrát vagy görbét jelölnek. Tulajdonságuk, hogy önhasonlóak, struktúra-ismétlőek. Ez azt jelenti, hogy bármely apró részletük ugyanolyan felépítésű, mint az egész rendszer. A fraktálok adják a káosz építőköveit, blokkjait. A természet által generált fraktálok között pl. különböző levélminták, hópehelyminták találhatók. Az emberi szervezetben a levegő- és a véráramlás útjai mutatnak érdekes fraktál hálózatot. Ezek olyan alakzatok, amelyek nem írhatók le az euklideszi geometria segítségével, mert túlzottan szabálytalanok A káosz geometriája a fraktálgeometria. Fontos, hogy egy fraktálkép, amit látunk az soha sem az egész kép. Soha sem lehet megjeleníteni az egészet, mert a műveletet mindig el lehet végezni újra. Ez azt jelenti, hogy valóban végtelen, és a végtelen nem fér bele az idő és a tér véges korlátai közé. A teljes kép kizárólag a művelettel írható le. Maga az utasítássorozat jelenti a teljes képet, ha fraktálnak tekintünk egy halmazt, amely finom felépítésű, tetszőleges kicsi léptékre nézve további részleteket mutat, túlságosan szabálytalan, hogy a hagyományos geometria nyelvén leírható legyen, gyakran az önhasonlóság valamilyen formájával rendelkezik, esetleg közelítő vagy statisztikus értelemben, általában (valamilyen módon definiált) “fraktál dimenziója” amely többnyire egy nem egész szám, eltér a szokásos értelemben vett térbeli dimenziójától, a legtöbb érdeklődésre számot tartó esetben rendkívül egyszerűen előállítható, például rekurzívan, azaz minden új eleme a korábban meghatározottak segítségével felírható. Ezt alkalmazzuk a programozásban is. Ha a természetből akarunk példát nézzük meg a páfrány leveleit vagy a korallokat.

2018. június 8., péntek

Tömbök és mátrixok

A tömb, mint összetett adattípus az előző anyagokból már ismerős lehet. Míg a tömbök egy adatsort tartalmaznak, a többdimenziós tömbök pedig többet. A többdimenziós tömbök valójában tömbök tömbjei. A dimenziók száma elméletileg nincs korlátozva, gyakorlatilag 3 dimenziónál többel dolgozni nem feltétlenül praktikus.

Egy általános tömb deklarációja a következőképp néz ki:
// deklarálás és inicializálás, ami csak 0 értékekkel tölti fel a tömböt
int[] tomb = new int[10];

// deklarálás és azonnali kezdőérték adás
int[] tomb = {1,2,3,4,5,6,7,8,9,10};

// adott indexű elem kiválasztása
tomb[5]

Ez a többdimenziós tömbök esetén is hasonló, de mivel ezek tömbök tömbjei, ezért ezt formailag is jelezni kell.
Kétdimenziós tömbök
// kétdimenziós tömb deklarálása és inicializálása
int[][] tomb = new int[2][3];

// kétdimenziós tömb adott elemének kiválasztása
tomb[1][2]

Az előző deklarálás azt jelenti, hogy létrehozunk egy 2 sorból és 3 oszlopból álló kétdimenziós tömböt. A sorok és oszlopok sorszámozása (indexelése) itt is 0-val indul, mint általában a tömbök esetén. Mint már említettem, a többdimenziós tömb valójában tömbök tömbje, de formailag ez hogy néz ki? Nézzük meg egy konkrét példán keresztül:
int[][] tomb = { { 2,4,6 }, { 3,7,8 } };

Mit is jelent ez? Adott két sor (a két kicsi tömb darabszáma, ami a számokat tartalmazza) és adott 3 oszlop (ami a kis tömbökben lévő számok darabszámát jelenti). Láthatod, hogy a kis tömbökben lévő számok darabszáma megegyezik, ez nem véletlen. Valójában ez a szám az oszlopok száma. Hogy jobban látható legyen, átrendezem az előző példában szereplő tömb szerkezetét:
int[][] tomb = {
                 { 2,4,6 },
                 { 3,7,8 }
               };

Így már egyértelműbb, hogy mit jelent a sorok és oszlopok száma. A két kis belső tömb jelenti a sorokat, egymás alá írva őket, valóban sorokat alkotnak. A bennük lévő elemek száma pedig kötött, mert ez jelenti az oszlopok számát. A két sort összefogó külső tömb határolóit direkt külön sorba írtam, hogy az ne zavarjon, de az is a struktúra része. Amikor hivatkozunk egy elemre (tomb[1][2]), akkor azt mondjuk meg, hogy az 1-es indexű kis tömbnek (a másodiknak) a 2-es oszlopában (a harmadikban) lévő 8-as elemre gondolunk. Ne feledd, a sor és oszlop indexelése is 0-val kezdődik.

A kétdimenziós tömbök kezeléséhez szinte minden esetben két egymásba ágyazott ciklusra van szükség, olyanokra, mint amilyeneket a rendezéseknél is láthattál. A külső ciklus a sorszámot, a belső az oszlopszámot lépteti. Nézzük meg, hogy néz ez ki:
1
2
3
4
5
6
7
  
for( int i = 0; i < tomb.length; i++ )
{
  for( int j = 0; j < tomb[i].length; j++ )
  {
    tomb[i][j] = (int)(Math.random()*10);
  }
}

Ez a példa végigmegy a tömb összes elemén, és mindegyiket egy [0;9] intervallumból sorsolt számmal tölt fel. Láthatod, hogy van egy tömbelem kiválasztás (tomb[i][j]), ami az előzőleg ismertetett módon [sor][oszlop] választja ki az adott elemet. Mivel a későbbiekben nagy valószínűséggel mindig ugyanolyan nevű változókat használsz, ezért jó ha megjegyzed, hogy az i változóval jelölöd a sorokat, és j-vel az oszlopokat. Ez a későbbiekben fontos lesz, hogy tudd, melyik melyik.
A kiemelt sorban van igazából az érdekesség, ami elsőre furcsa lehet. A tömb i indexű elemének tömbmérete? Kétdimenziós tömbben a tömb deklarálása után az inicializáláskor meg kell határozni a tömb méretét. Így van ez az alap tömbök esetén is, és így van ez itt is. A különbség az, hogy itt külön kell beállítani a sorok és oszlopok számát. Először a sorok, utána az oszlopok számát. De akkor a tomb.length melyiket adja meg a kettő közül, és hogy kapjuk meg a másikat? Tisztázzunk akkor pár sarokpontot az ilyen tömbök kezelésével kapcsolatban
tomb.length;    // sorok száma (a kis tömbök darabszáma)
tomb[1];        // az 1-es indexű sor elemei (2. sor tömbje)
tomb[i].length; // oszlopok száma (az i indexű tömbben lévő elemek száma)
tomb[3][2];     // tömbben tárolt elem, ami a 4. sor 3. oszlopában van

Az oszlopok számát miért egy i indexű sor méretéből kapjuk meg, miért nem fixen a 0 indexű sor méretéből? Azért, mert létezik egy speciális többdimenziós tömbtípus, melyet nagyon ritkán használunk, és ott eltérhet az egyes sorok (kis tömbök) mérete, így mindig az aktuális sor méretével dolgozzunk.
Kétdimenziós tömbök bejárása

    az összes elem bejárása:
    Ebben az esetben két ciklusra van szükség, amire már láttál példát a tömb feltöltésénél.
    egy sor bejárása:
    Ekkor elég csak egy konkrét soron végigmenni egyetlen ciklussal. Ebben a példában a 3. sor összes elemét írjuk ki egymás mellé. Ez a következőképp néz ki:

    for( int j = 0; j < tomb[2].length; j++ )
    {
      System.out.print(tomb[2][j]+" ");
    }

    Ebben az esetben láthatjuk, hogy a tomb[2]-re hivatkozok fixen, több helyen is. Először a ciklus fejében, ahol a 2-es indexű (3.) sor elemeit akarom kiírni. Valamint a konkrét elem kiválasztásánál is látszik, hogy csak a 2-es indexű sor szerepel, de azon belül a j-vel végiglépkedek a sor összes elemén (oszlopán). Technikailag a j helyett itt i is lehetne ciklusváltozó, a program akkor is tökéletesen működne. Logikailag azért szoktam javasolni, hogy j legyen, mert akkor jobban rögzül, hogy a j az oszlopokat jelenti, és most csak az oszlop változik, a sor kötött.
    egy oszlop bejárása:
    Az előzőhöz hasonlóan itt is elég egyetlen ciklus, hiszen egyetlen oszlopon kell csak végigmenni. Ekkor az oszlop száma kötött és csak a sorszám változik. Ez így néz ki:

    for( int i = 0; i < tomb.length; i++ )
    {
      System.out.println(tomb[i][4]);
    }

Láthatod, hogy a ciklus fejében máshogy szerepel a futási feltétel, csak tomb.length szerepel, ami a sorok számát jelenti. A ciklusmagban pedig az adott elem kiválasztásakor a oszlopszám fix (jelen esetben a 4-es indexű 5. sor) és az sorszám az, ami változik, ezért használtam i ciklusváltozót.

Most már tetszőleges kétdimenziós tömböt be tudunk járni, jöhetnek az ezzel kapcsolatos feladatok. Az első feladat a tömb feltöltése, a többi feladatban pedig ezzel a tömbbel dolgoznánk.
Gyakorló feladatok

    Tölts fel egy 3×5-ös kétdimenziós tömböt a [-10;30] intervallumból:
    int[][] tomb = new int[3][5];
   
    for( int i = 0; i < tomb.length; i++ )
    {
      for( int j = 0; j < tomb[i].length; j++ )
      {
        tomb[i][j] = (int)(Math.random()*41)-10;
      }
    }
    Írd ki a tömböt sorokba és oszlopokba rendezve:
    int[][] tomb = new int[3][5];
   
    for( int i = 0; i < tomb.length; i++ )
    {
      for( int j = 0; j < tomb[i].length; j++ )
      {
    // egymás mellé írom ki egy sor elemeit
        System.out.print(tomb[i][j]+" ");
      }
    // ha végeztem egy sor kiírásával, akkor új sort kezdek
      System.out.println();
    }
    Írd ki a tömbben szereplő számok összegét:
    int osszeg = 0;
    for( int i = 0; i < tomb.length; i++ )
    {
      for( int j = 0; j < tomb[i].length; j++ )
      {
        osszeg = osszeg + tomb[i][j];
    // vagy osszeg += tomb[i][j];
      }
    }
    System.out.println("A tomb elemeinek osszege"+osszeg);
    Írd ki a 2. sor összegét:
    int osszeg = 0;
    for( int j = 0; j < tomb[1].length; j++ )
    {
      osszeg = osszeg + tomb[1][j];
    // vagy osszeg += tomb[1][j];
    }
    System.out.println("A 2. sor osszege"+osszeg);
    Számold meg, hány negatív szám szerepel a tömbben:
    int db = 0;
    for( int i = 0; i < tomb.length; i++ )
    {
      for( int j = 0; j < tomb[i].length; j++ )
      {
        if( tomb[i][j] < 0 )
        {
          db++;
        }
      }
    }
    System.out.println("A tombben "+db+" negativ szam van.");
    Számold meg, hány páros szám található a 3. oszlopban:
    int db = 0;
    for( int i = 0; i < tomb.length; i++ )
    {
      if( tomb[i][2] % 2 == 0 )
      {
        db++;
      }
    }
    System.out.println("A tomb 3. oszlopaban "+db+" paros szam van.");
    Írd ki, melyik a legkisebb elem a tömbben:Ez a feladat nem teljesen ugyanaz, mint amit a minimumkeresésnél láthattál. Arra remélem emlékszel, hogy a minimumnak a helyét, és nem az értékét tároljuk, mert a helyéből két dologra is válaszolhatunk, ezt most nem írnám le újra. De itt a hely nem egy index, hanem kettő: [oszlop][sor]
    Két dolgot tehetsz. Vagy két változót használsz a hely tárolására (egyet a sornak, egyet az oszlopnak), vagy egy két elemű tömbben tárolod, valahogy így:

    int[] min = new int[2];
    min[0] = sor;
    min[1] = oszlop;

    Vagy tárolhatod két változóban is:
    int minI = sor;
    int minJ = oszlop;

    Rád bízom melyiket használod, a lényeg, hogy helyesen tedd. Lássunk akkor példát a bonyolultabbra:
    int[] min = new int[2];
    // ebben a két sorban állítom be, hogy az első elem az első minimum
    min[0] = 0;
    min[1] = 0;
   
    for( int i = 0; i < tomb.length; i++ )
    {
      for( int j = 0; j < tomb[i].length; j++ )
      {
    // ha a tömb aktuális eleme kisebb, mint az eddigi minimum
    // ahol a minimum elem sora min[0], oszlopa min[1]
        if( tomb[i][j] < tomb[ min[0] ][ min[1] ] )
        {
          min[0] = i;
          min[1] = j;
        }
      }
    }
    // na itt ne keverd össze a [ ] jeleket...
    System.out.println("A tomb legkisebb eleme: "+tomb[min[0]][min[1]]);

    Azért hasonlítsuk ezt össze azzal, ha két külön változóban tárolod a minimum elem sorát és oszlopát:
    // ebben a két sorban állítom be, hogy az első elem az első minimum
    int minI = 0;
    int minJ = 0;
   
    for( int i = 0; i < tomb.length; i++ )
    {
      for( int j = 0; j < tomb[i].length; j++ )
      {
    // ha a tömb aktuális eleme kisebb, mint az eddigi minimum
    // ahol a minimum elem sora min[0], oszlopa min[1]
        if( tomb[i][j] < tomb[minI][minJ] )
        {
          minI = i;
          minJ = j;
        }
      }
    }
    // na itt ne keverd össze a [ ] jeleket...
    System.out.println("A tomb legkisebb eleme: "+tomb[minI][minJ]);

    Talán a két külön változó kicsit barátságosabb.

    Ha igazán figyeltél az eddigiekben, kiszúrhattad, hogy más különbség is van a minimumkereséshez képest, azon kívül, hogy itt a minimum helyét értelemszerűen két számként tároljuk. Figyeld meg, honnan indulnak itt a ciklusok. Nem 1-től! A minimumkeresésnél emlékezhetsz, hogy az első (0 indexű) elem a legkisebb, ezért a ciklus 1-es indextől kezdődik, hogy önmagával már ne hasonlítsuk össze. Itt ezt nem tehetjük meg. Miért?

    Ha a külső ciklusban az i változó 1-től indulna, akkor az első (0 indexű) sor teljesen kimaradna a vizsgálatból. Ha a belső ciklusban a j változó indulna 1-től, akkor pedig minden sor első eleme, vagyis a teljes első (0. indexű) oszlop maradna ki. Itt kénytelenek vagyunk az első minimumot önmagával is összehasonlítani, ami azért valljuk be, nem túl nagy veszteség. De ha nem így oldod meg, akkor súlyos hiba.

Háromdimenziós tömbök

Többdimenziós tömböket 3 dimenzió felett nem igazán használunk. A 3. dimenzióval még van értelme dolgozni, mondjuk térbeli koordináták, vagy képfeldolgozás esetén mondjuk egy RGB kód tárolása esetén. Ebben az esetben formailag így néz ki a tömbünk:
// háromdimenziós tömb deklarálása és inicializálása
int[][][] tomb = new int[4][5][2];

// háromdimenziós tömb adott elemének kiválasztása
tomb[1][2][1]

Itt a 3. dimenzió mondjuk mint egyfajta magasság értelmezhető térbeli pontok tárolása esetén. Színkódoknál pedig a 3 színkomponens értékét tárolhatjuk a tömbben. Ezekben az esetekben a tömb teljes bejárása értelemszerűen 3 ciklust jelent, de csak az első sorbeli magasságadatok bejárása is két ciklust igényel. Akkor van szükség egy ciklusra, ha a 3 dimenzióból 2 rögzített. Például az első sor második eleméhez tartozó pontok (a tomb[0][1] magasságoszlopa) bejárása esetén.
Fűrészfogas tömbök

Láthattad, hogy a kétdimenziós tömbök esetén az oszlopok száma minden esetben megegyezik. Ez azonban nem mindig van így. Megadható az is, hogy az egyes sorok változó (de megadásuk után fix) hosszúak legyenek. Ezt a szerkezetet fűrészfogas tömbnek is szokás nevezni. Ilyen szerkezetet nagyon speciális esetekben használunk, de a kezelése a fentiek alapján meglehetősen egyszerű. Lássuk hogyan deklaráljuk ezt:
// először csak a sorok számát adjuk meg
int[][] tomb = new int[3][];

// ezután használat előtt egyenként adjuk meg a sorok méreteit

tomb[0] = new int[5];
tomb[1] = new int[7];
tomb[2] = new int[3];

// töltsük fel a tömböt a [0;9] intervallumból
for( int i = 0; i < tomb.length; i++ )
{
  for( int j = 0; j < tomb[i].length; j++ )
  {
    tomb[i][j] = (int)(Math.random()*10);
  }
}

// írjuk ki a tömböt
for( int i = 0; i < tomb.length; i++ )
{
  for( int j = 0; j < tomb[i].length; j++ )
  {
    System.out.print(tomb[i][j]+" ");
  }
  System.out.println();
}

Láthatod, hogy a tömb sorai nem egyforma hosszúak. Itt csak arra kell vigyázni, hogy direkt hozzáféréssel soha ne hivatkozz olyan indexű elemre, ami nem létezik. Nem értelmezhető például a 4. oszlop, mivel a 3. sorban csak 3 oszlop található. De a tömb bejárása, minimum/maximum keresés, sorösszeg, tömb összeg, megszámlálások, gond nélkül kivitelezhetők a fent kidolgozott példák alapján, de csak akkor, ha ezek nem egy oszlopra korlátozódnak. Csak akkor kell nagyon figyelni, ha csak oszlopban akarunk mozogni, mert tisztázni kell előre, létezik-e teljesen az adott oszlop, vagy valamelyik sorban lyukas. Ez a fűrészfogas szerkezet 3 és több dimenzióra is létrehozható, de azzal már szinte csak elméleti síkon kell számolni.

Informatika emelt szint gyakorlati vizsga Megoldásai 2018 május

Ember osztály az adattárolásra és rövidítésre:
package tarsalgo;

public class Ember
{
  private int ora;
  private int perc;
  private int azon;
  private String irany;
  private boolean be;
 
  public Ember( String[] tomb )
  {
    ora = Integer.parseInt(tomb[0]);
    perc = Integer.parseInt(tomb[1]);
    azon = Integer.parseInt(tomb[2]);
    irany = tomb[3];
    be = tomb[3].equals("be");
  }

  public int getOra()
  {
    return ora;
  }

  public int getPerc()
  {
    return perc;
  }

  public int getAzon()
  {
    return azon;
  }

  public String getIrany()
  {
    return irany;
  }

  public boolean isBe()
  {
    return be;
  }

  @Override
  public String toString()
  {
    return "Ember{" + "ora=" + ora + ", perc=" + perc +
      ", azon=" + azon + ", irany=" + irany + ", be=" + be + '}';
  }
}
A main()-t tartalmazó osztály, mely a fájlkezelést és a feladatokat tartalmazza:
package tarsalgo;

import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.Scanner;

public class Tarsalgo
{
  public static void main(String[] args)
  {
    // 1. feladat
    Ember[] emberek = null;
   
    try
    {
      RandomAccessFile raf = new RandomAccessFile("ajto.txt","r");
      String sor;
      int db = 0;
      for( sor = raf.readLine(); sor != null; sor = raf.readLine() )
      {
        db++;
      }
     
      emberek = new Ember[db];
      raf.seek(0);
      db = 0;
      for( sor = raf.readLine(); sor != null; sor = raf.readLine() )
      {
        emberek[db] = new Ember(sor.split(" "));
        db++;
      }
      raf.close();
    }
    catch( IOException e )
    {
      System.out.println("HIBA");
    }
   
//    for( Ember e : emberek )
//    {
//      System.out.println(e);
//    }

    // 2. feladat
    System.out.println("2. feladat");
    System.out.println("Az elso belepo: "+emberek[0].getAzon());
   
    int hely = -1;
    for( int i = emberek.length-1; i >= 0; i-- )
    {
      if( !emberek[i].isBe() )
      {
        hely = i;
      }
    }
   
    if( hely != -1 )
    {
      System.out.println("Az utolso kilepo: "+emberek[hely].getAzon());
    }
    else
    {
      System.out.println("Senki nem ment ki a tarsalgobol.");
    }
   
    // 3. feladat
    int max = 0;
    for( int i = 0; i < emberek.length; i++ )
    {
      if( emberek[i].getAzon() > max )
      {
        max = emberek[i].getAzon();
      }
    }

    int[] darabok = new int[max+1];
   
    for( int i = 0; i < emberek.length; i++ )
    {
      darabok[emberek[i].getAzon()]++;
    }
   
    try
    {
      RandomAccessFile ki = new RandomAccessFile("athaladas.txt","rw");
      for( int i = 1; i < darabok.length; i++ )
      {
        ki.writeBytes(i+" "+darabok[i]+"\n");
      }
      ki.close();
    }
    catch( IOException e )
    {
      System.out.println("HIBA");
    }
   
    // 4. feladat
    System.out.println("4. feladat");
   
    int[] bent = new int[max+1];
   
    for( int i = 0; i < emberek.length; i++ )
    {
      if( emberek[i].isBe() )
      {
        bent[emberek[i].getAzon()]++;
      }
      else
      {
        bent[emberek[i].getAzon()]--;
      }
    }
    System.out.print("A vegen a tarsalgoban voltak: ");
    for( int i = 1; i < bent.length; i++ )
    {
      if( bent[i] > 0 )
      {
        System.out.print(i+" ");
      }
    }
    System.out.println();

    // 5. feladat
    System.out.println("5. feladat");

    int[] bentvannak = new int[emberek.length];
   
    int elozo = 0;
    for( int i = 0; i < emberek.length; i++ )
    {
      if( emberek[i].isBe() )
      {
        bentvannak[i] = elozo + 1;
      }
      else
      {
        bentvannak[i] = elozo - 1;
      }
      elozo = bentvannak[i];
    }
   
    max = 0;
    for( int i = 1; i < bentvannak.length; i++ )
    {
      if( bentvannak[i] > bentvannak[max] )
      {
        max = i;
      }
    }
   
    System.out.println("Peldaul: "+emberek[max].getOra()+":"+
        emberek[max].getPerc()+"-kor voltak a legtobben a tarsalgoban.");
   
    // 6. feladat
    System.out.println("6. feladat");
    System.out.print("Adja meg egy szemely azonositojat: ");
    Scanner sc = new Scanner(System.in);
    int azon = Integer.parseInt(sc.nextLine());

    // 7. feladat
    System.out.println("7. feladat");
    for( int i = 0; i < emberek.length; i++ )
    {
      if( emberek[i].getAzon() == azon )
      {
        if( emberek[i].isBe() )
        {
          System.out.print(emberek[i].getOra()+":"+
            emberek[i].getPerc()+"-");
        }
        else
        {
          System.out.println(emberek[i].getOra()+":"+
            emberek[i].getPerc());
        }
      }
    }
    System.out.println();
   
    // 8. feladat
    System.out.println("8. feladat");
   
    int osszeg = 0;
    int be = 0;
    int ki = 0;
    boolean bentvan = false;
    for( int i = 0; i < emberek.length; i++ )
    {
      if( emberek[i].getAzon() == azon )
      {
        if( emberek[i].isBe() )
        {
          be = emberek[i].getOra()*60+emberek[i].getPerc();
          bentvan = true;
        }
        else
        {
          osszeg += (emberek[i].getOra()*60+emberek[i].getPerc()) - be;
          bentvan = false;
        }
      }
    }
   
    // ha a legvegen nem jott ki, akkor az utolso bemenetel
    // es a 15:00 kozotti idot hozzaadjuk az ossz idejehez
    if( bentvan )
    {
      osszeg += (15*60)-be;
    }
   
    System.out.print("A(z) "+azon+". szemely osszesen "+osszeg+
      " percet volt bent");
   
    if( bentvan )
    {
      System.out.println(", a megfigyeles vegen a tarsalgoban volt.");
    }
    else
    {
      System.out.println(".");
    }
  }
}

ITömbös megoldás:
Vasarlas osztály az adattárolásra és rövidítésre:
package webotlet_16maj_otszaz_tomb;

/**
 *
 * https://webotlet.hu
 */

import java.util.Arrays;

public class Vasarlas
{
  private String[] termekek;
  private int osszeg;
 
  public Vasarlas( String[] tomb )
  {
    for( int i = 0; i < tomb.length; i++ )
    {
      if( tomb[i] == null )
      {
        termekek = new String[i];
        for( int j = 0; j < i; j++ )
        {
          termekek[j] = tomb[j];
        }
        break;
      }
    }
   
    // azert rendezem a termekek neveit nevsorba,
    // hogy az azonos nevuek egymas melle keruljenek,
    // igy majd konnyen meghatarozhatom, melyikbol hany darab van
    String csere;
    for( int i = 0; i < termekek.length-1; i++ )
    {
      for( int j = i+1; j < termekek.length; j++ )
      {
        if( termekek[i].compareTo(termekek[j]) > 0 )
        {
          csere = termekek[i];
          termekek[i] = termekek[j];
          termekek[j] = csere;
        }
      }
    }
   
    // termekek aranak osszege (melyikbol hany darab van)
    // nem lenyeges, hogy mi az a termek,
    // csak a darabszamuk a lenyeg, pl:
    // 2, 2, 1, 3 -> (950 + 950 + 500 + 1350)
    int db = 1;
    for( int i = 1; i < termekek.length; i++ )
    {
      if( !termekek[i].equals(termekek[i-1]) )
      {
        System.out.println(db+" "+termekek[i-1]);
       
        osszeg += ertek(db);
        db = 1;
      }
      else
      {
        db++;
      }
    }
    osszeg += ertek(db);
  }

  public String[] getTermekek()
  {
    return termekek;
  }

  public int getOsszeg()
  {
    return osszeg;
  }
 
  // megkeressuk, van-e adott termek a vasaroltak kozott
  public boolean vettek( String mit )
  {
    boolean van = false;
    for( int i = 0; i < termekek.length; i++ )
    {
      if( termekek[i].equals(mit) )
      {
        van = true;
        break;
      }
    }
    return van;
  }

  @Override
  public String toString()
  {
    return "Vasarlas{" + "termekek=" + Arrays.toString(termekek) +
      ", osszeg=" + osszeg + '}';
  }

// osztalymetodus, ami akkor is meghívhato, ha nincs peldany belole
  public static int ertek( int db )
  {
    if( db == 1 )
    {
      return 500;
    }
    else if( db == 2 )
    {
      return 950;
    }
    else
    {
      return 950+(db-2)*400;
    }
  }
}
A main()-t tartalmazó osztály, mely a fájlkezelést és a feladatokat tartalmazza:
package webotlet_16maj_otszaz_tomb;

/**
 *
 * https://webotlet.hu
 */

import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.Scanner;

public class Webotlet_16maj_otszaz_tomb
{
  public static void main(String[] args)
  {
       
    Vasarlas[] vasarlasok = null;
   
    try
    {
      RandomAccessFile raf = new RandomAccessFile("penztar.txt","r");
      String sor;
      int db = 0;
      for( sor = raf.readLine(); sor != null; sor = raf.readLine() )
      {
        if( sor.equals("F") )
        {
          db++;
        }
      }
     
      vasarlasok = new Vasarlas[db];
      raf.seek(0);

      db = 0;
      String[] termekek = new String[20];
      int tetelszam = 0;
      for( sor = raf.readLine(); sor != null; sor = raf.readLine() )
      {
        if( sor.equals("F") )
        {
          vasarlasok[db] = new Vasarlas(termekek);
          db++;
          termekek = new String[20];
          tetelszam = 0;
        }
        else
        {
          termekek[tetelszam] = sor;
          tetelszam++;
        }
      }
     
      raf.close();
    }
    catch( IOException e )
    {
      System.out.println("HIBA");
    }

    // 2. feladat
    System.out.println("2. feladat");
    System.out.println("A fizetesek szama: "+vasarlasok.length);

    // 3. feladat
    System.out.println("3. feladat");
    System.out.println("Az elso vasarlo "+
      vasarlasok[0].getTermekek().length+
      " darab arucikket vasarolt.");

    // 4. feladat
    System.out.println("4. feladat");
    Scanner sc = new Scanner(System.in);
   
    System.out.print("Adja meg egy vasarlas sorszamat! ");
    int sorszam = sc.nextInt();
    System.out.print("Adja meg egy arucikk nevet! ");

// szam utan String-et bekerni nyugos, ezert a szam utani sortorest
// beolvassuk, hogy atlepjunk rajta
    sc.nextLine();
    String cikk = sc.nextLine();
    System.out.print("Adja meg a vasarolt darabszamot! ");
    int darab = sc.nextInt();

    // 5. feladat
    System.out.println("5. feladat");
   
    for( int i = 0; i < vasarlasok.length; i++ )
    {
      if( vasarlasok[i].vettek(cikk) )
      {
        System.out.println("Az elso vasarlas sorszama: "+(i+1));
        break;
      }
    }

    for( int i = vasarlasok.length-1; i >= 0; i-- )
    {
      if( vasarlasok[i].vettek(cikk) )
      {
        System.out.println("Az elso vasarlas sorszama: "+(i+1));
        break;
      }
    }
   
    int db = 0;
    for( int i = 0; i < vasarlasok.length; i++ )
    {
      if( vasarlasok[i].vettek(cikk) )
      {
        db++;
      }
    }

    System.out.println(db+" vasarlas soran vettek belole.");

    // 6. feladat
    System.out.println("6. feladat");
    System.out.println(darab+" darab vetelekor fizetendo: "+
      Vasarlas.ertek(darab)); // osztalymetodus meghivasa

    // 7. feladat
    System.out.println("7. feladat");
    String[] termekek = vasarlasok[sorszam-1].getTermekek();
    db = 1;
    for( int i = 1; i < termekek.length; i++ )
    {
      if( !termekek[i].equals(termekek[i-1]) )
      {
        System.out.println(db+" "+termekek[i-1]);
        db = 1;
      }
      else
      {
        db++;
      }
    }
    System.out.println(db+" "+termekek[termekek.length-1]);

    try
    {
      RandomAccessFile raf = new RandomAccessFile("osszeg.txt","rw");
      for( int i = 0; i < vasarlasok.length; i++ )
      {
        raf.writeBytes((i+1)+": "+vasarlasok[i].getOsszeg()+"\n");
      }
      raf.close();
    }
    catch( IOException e )
    {
      System.out.println("HIBA");
    }
  }
}
Listás megoldás:
Vasarlas osztály az adattárolásra és rövidítésre:
package webotlet_16maj_otszaz_lista;

/**
 *
 * https://webotlet.hu
 */

import java.util.ArrayList;

public class Vasarlas
{
  private ArrayList<String> termekek;
  private int osszeg;
 
  public Vasarlas( ArrayList<String> tmp )
  {
    termekek = tmp;
   
    // azert rendezem a termekek neveit nevsorba,
    // hogy az azonos nevuek egymas melle keruljenek,
    // igy majd konnyen meghatarozhatom, melyikbol hany darab van
    String csere;
    for( int i = 0; i < termekek.size()-1; i++ )
    {
      for( int j = i+1; j < termekek.size(); j++ )
      {
        if( termekek.get(i).compareTo(termekek.get(j)) > 0 )
        {
          csere = termekek.get(i);
          termekek.set(i, termekek.get(j));
          termekek.set(j, csere);
        }
      }
    }
   
    // termekek aranak osszege (melyikbol hany darab van)
    // nem lenyeges, hogy mi az a termek,
    // csak a darabszamuk a lenyeg, pl:
    // 2, 2, 1, 3 -> (950 + 950 + 500 + 1350)
    int db = 1;
    for( int i = 1; i < termekek.size(); i++ )
    {
      if( !termekek.get(i).equals(termekek.get(i-1)) )
      {
        System.out.println(db+" "+termekek.get(i-1));
       
        osszeg += ertek(db);
        db = 1;
      }
      else
      {
        db++;
      }
    }
    osszeg += ertek(db);
  }

  public ArrayList<String> getTermekek()
  {
    return termekek;
  }

  public int getOsszeg()
  {
    return osszeg;
  }

  @Override
  public String toString()
  {
    return "Vasarlas{" + "termekek=" + termekek +
      ", osszeg=" + osszeg + '}';
  }

// osztalymetodus, ami akkor is meghívhato, ha nincs peldany belole
  public static int ertek( int db )
  {
    if( db == 1 )
    {
      return 500;
    }
    else if( db == 2 )
    {
      return 950;
    }
    else
    {
      return 950+(db-2)*400;
    }
  }
}
A main()-t tartalmazó osztály, mely a fájlkezelést és a feladatokat tartalmazza:
package webotlet_16maj_otszaz_lista;

/**
 *
 * https://webotlet.hu
 */

import java.io.RandomAccessFile;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;

public class Webotlet_16maj_otszaz_lista
{
  public static void main(String[] args)
  {
    ArrayList< Vasarlas > vasarlasok = new ArrayList<>();
   
    try
    {
      RandomAccessFile raf = new RandomAccessFile("penztar.txt","r");
      String sor;
     
      ArrayList<String> lista = new ArrayList<>();
      for( sor = raf.readLine(); sor != null; sor = raf.readLine() )
      {
        if( !sor.equals("F") )
        {
          lista.add(sor);
        }
        else
        {
          vasarlasok.add(new Vasarlas(lista));
          lista = new ArrayList<>();
        }
      }
     
      raf.close();
    }
    catch( IOException e )
    {
      System.out.println("HIBA");
    }

    // 2. feladat
    System.out.println("2. feladat");
    System.out.println("A fizetesek szama: "+vasarlasok.size());
   
    // 3. feladat
    System.out.println("3. feladat");
    System.out.println("Az elso vasarlo "+
      vasarlasok.get(0).getTermekek().size()+
      " darab arucikket vasarolt.");

    // 4. feladat
    System.out.println("4. feladat");
   
    Scanner sc = new Scanner(System.in);
   
    System.out.print("Adja meg egy vasarlas sorszamat! ");
    int sorszam = sc.nextInt();
    System.out.print("Adja meg egy arucikk nevet! ");

// szam utan String-et bekerni nyugos, ezert a szam utani sortorest
// beolvassuk, hogy atlepjunk rajta
    sc.nextLine();
    String cikk = sc.nextLine();
    System.out.print("Adja meg a vasarolt darabszamot! ");
    int darab = sc.nextInt();
   
    // 5. feladat
    System.out.println("5. feladat");
   
    for( int i = 0; i < vasarlasok.size(); i++ )
    {
      if( vasarlasok.get(i).getTermekek().contains(cikk) )
      {
        System.out.println("Az elso vasarlas sorszama: "+(i+1));
        break;
      }
    }

    for( int i = vasarlasok.size()-1; i >= 0; i-- )
    {
      if( vasarlasok.get(i).getTermekek().contains(cikk) )
      {
        System.out.println("Az utolso vasarlas sorszama: "+(i+1));
        break;
      }
    }
   
    int db = 0;
    for( int i = 0; i < vasarlasok.size(); i++ )
    {
      if( vasarlasok.get(i).getTermekek().contains(cikk) )
      {
        db++;
      }
    }
   
    System.out.println(db+" vasarlas soran vettek belole.");

    // 6. feladat
    System.out.println("6. feladat");
    System.out.println(darab+" darab vetelekor fizetendo: "+
      Vasarlas.ertek(darab)); // osztalymetodus meghivasa

    // 7. feladat
    System.out.println("7. feladat");
    ArrayList<String> lista = vasarlasok.get(sorszam-1).getTermekek();
    db = 1;
    for( int i = 1; i < lista.size(); i++ )
    {
      if( !lista.get(i).equals(lista.get(i-1)) )
      {
        System.out.println(db+" "+lista.get(i-1));
        db = 1;
      }
      else
      {
        db++;
      }
    }
    System.out.println(db+" "+lista.get(lista.size()-1));

    // 8. feladat
    try
    {
      RandomAccessFile raf = new RandomAccessFile("osszeg.txt","rw");
      for( int i = 0; i < vasarlasok.size(); i++ )
      {
        raf.writeBytes((i+1)+": "+vasarlasok.get(i).getOsszeg()+"\n");
      }
      raf.close();
    }
    catch( IOException e )
    {
      System.out.println("HIBA");
    }
  }
}

Interaktív program adatbekéréssel

Ahogy előre haladunk a programozás tanulásában egyre inkább felmerül az az igény, hogy ne csak előre megadott adatokkal dolgozzon a program, hanem menet közben mi is adhassunk neki munkát. Vagy egyszerűen csak befolyásoljuk a program működését. Az is szempont lehet, hogy adatbekéréssel tesztelésre szolgáló bemeneti értékekkel kideríthessük az esetleges szemantikai hibákat.

Az adatbekérést többféle módon is megoldhatjuk, én maradok az egyik egyszerű, direkt erre a feladattípusra készített osztály, a Scanner használatával. Látni fogjuk, hogy ez rugalmasan használható többféle típusú adat bevitelére is, és a használata meglehetősen egyszerű.

Mivel ez a Scanner egy előre megírt osztály, a program elkészítésének első lépése importálni azt a készítendő kódunkba, még a program osztályainak megadása előtt: import java.util.Scanner;

Ha ez megvan, ettől a ponttól kezdve deklarálhatunk Scanner típusú változót, és létrehozhatunk belőle egy Scanner objektumot, ami az adatbekérésben segítségünkre lesz. Nézzünk akkor egy példakódot, amiben lépésenként elmagyarázom, hogy melyik kiemelt sornak mi a szerepe.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
  
import java.util.Scanner;

public class Adatbekeres
{
  public static void main( String[] args )
  {
    Scanner sc;

    sc = new Scanner(System.in);

    int szam;
    szam = sc.nextInt();

    sc.close();

    System.out.println("A bekert szam ketszerese: "+szam*2);
  }
}

A lényegi részeket kiemelve nézzük meg a program részeit:

    A kód elején a Scanner osztály importálásával kezdünk, mert enélkül nem tudjuk használni.
    Ha már használhatjuk, akkor létre kell hoznunk egy Scanner objektumot, ami majd az adatbekérést fogja végrehajtani. Ez történik meg a 7. sorban.
    A létrehozott Scanner objektumunkat egy sc nevű változóban fogjuk tárolni, így bármikor egyszerűen elérhetjük. Természetesen más nevet is megadhatunk neki, de lustaságból én nem adok meg hosszabb nevet, minek annyit gépelni
    A Scanner osztálynak meghívjuk a konstruktorát, és odaadjuk neki a System.in bemenetet, ami alapértelmezetten a billentyűzet. Ettől kezdve az objektumunk a billentyűzetről fogja beolvasni az általunk megadott adatokat.
    A Scanner objektumnak meghívjuk a nextInt() metódusát, amely a begépelt és Enter billentyűvel lezárt adatbevitel esetén a begépelt számot azonnal eltárolja egy int típusú változóba.
    Lezárjuk a Scanner-t, miután már nincs rá szükségünk.

Scanner-rel többféle típusú adatot is bekérhetünk. Ez csak a használt metódustól függ. Példaként álljon itt néhány úgy, hogy előtte szerepeljen a változó is, amiben eltároljuk a beírt adatot:

    String s = sc.nextLine();
    float f = sc.nextFloat();
    double d = sc.nextDouble();
    byte b = sc.nextByte();
    long l = sc.nextLong();

A Scanner használható arra is, hogy egy adatbekérésnél egy adott határoló mintát megadva darabolva kérjünk be valamit, mondjuk neveket szóközzel elválasztva. Erre azonban majd a Stringek split() metódusát fogjuk használni, így erre külön most nem térnék ki.


#include <stdio.h>
#include <math.h>

int main(){
        int oszto, szam, i, prim_e;

        printf("A szam: ");
        scanf("%d",&szam);
        printf("\n");
        for(i=1; i<=szam; i++){
                prim_e=1;
                for(oszto=2; (oszto<=sqrt(i)) && (prim_e==1); oszto++){
                        if(i%oszto==0){
                                prim_e=0;
                        }
                }
                if(prim_e==1){
                        printf("%d\n", i);
                }
        }


        return 0;

}

import extra.*;
public class Prímszámok {

static boolean prím(int x) {
if(x<2)
return false;

int xgyöke = (int)Math.sqrt(x);
int osztókSzáma=1;
for(int i=2;i<=xgyöke;i++) {
if(x%i==0) {
osztókSzáma++;
}
}
return (osztókSzáma==1)?true:false; // a szám gyökéig
}

static boolean prím2(long x) {
if(x<2)
return false;

if(x==2)
return true;

if(x%2==0)
return false;

int xgyöke = (int)Math.sqrt(x);
int osztókSzáma=1;
for(int i=3;i<=xgyöke;i+=2) {
if(x%i==0) {
osztókSzáma++;
}
}
return (osztókSzáma==1)?true:false; // a szám gyökéig
}

public static void main(String[] args) {
System.out.println("Prímszám vagy sem? ");
int szám=Console.readInt("Szám: ");

if(szám<100 || szám>150)
System.out.println("A számnak 100 és 150 közé kell esnije!\nÍrjon be egy másik számot!");
szám=Console.readInt("Szám: ");

if (prím2(szám))
System.out.println(szám+": prímszám");
else
System.out.println(szám+": nem prímszám");



Órai gyakorló feladatok







Adat bekérés Jávában

Bekért számok összege;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int szam = 0;
        int osszeg = 0;
        do {
            System.out.print("Adjon meg egy számot vagy kérje az összeget 0-val!\n");
            String szamString = in.nextLine();
            szam = Integer.parseInt(szamString);
            osszeg += szam;
        } while (szam != 0);
    System.out. println("Az összeg: " + osszeg);
    }
}
 
Bekért számok maximuma;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    int szam = 0;
    int maximum = 0;
    do {
        System.out.print("Adjon meg egy számot vagy kérje a maximumot 0-val!\n");

        String szamString = in.nextLine();
        szam = Integer.parseInt(szamString);
        if(szam > maximum){

           maximum = szam;

        }
    } while (szam != 0);
    System.out. println("Maximum: " + maximum);
    }
}

Kérje be a főnöke fizetését, aztán a sajátját. Hasonlítsa össze a két fizetés:
írjon ki egy-egy megjegyzést, ha a főnöke fizetése nagyobb, ha a sajátja nagyobb,
illetve ha egyenlő!

import extra.*;

public class Gyak2_1 {
  public static void main(String[] args) {
    int fizFonok = Console.readInt("Fonokenek fizetese: ");
    int fizSajat = Console.readInt("On fizetese: ");
    if (fizFonok > fizSajat)
      System.out.println("A fonok fizetese nagyobb, ez nem meglepo!");
    else if (fizFonok < fizSajat)
      System.out.println("Tobbet keresek, mint a fonok! Mi van itten?");
    else
      System.out.println("Ugyanannyit keresek, mint a fonok!");
  }
}

----------------------------

Kérjen be egy egész óra értéket. Ha a szám nem 0 és 24 óra között van, akkor adjon
hibaüzenetet, egyébként köszönjön el a program a napszaknak megfelelően! 4-9: Jó
reggelt!, 10-17: Jó napot!, 18-21: Jó estét!, 22-3: Jó éjszakát!

import extra.*;

public class Gyak2_2 {
  public static void main(String[] args) {
    int ora = Console.readInt("Ora: ");
    if (ora<0 || ora>24)
      System.out.println("Ez nem ora!");
    else if (ora>=4 && ora<=9)
      System.out.println("Jo reggelt!");
    else if (ora>=10 && ora<=17)
      System.out.println("Jo napot!");
    else if (ora>=18 && ora<=21)
      System.out.println("Jo estet!");
    else
      System.out.println("Jo ejszakat!");
  }
}

----------------------------

Kérjük be, hogy a héten mennyi kalóriát fogyasztottunk az egyes napokon. Írjuk ki az
összes kalóriafogyasztásunkat, valamint a napi átlagot!

import extra.*;
public class Gyak2_3{
  public static void main(String[]args){
    int sum=0;
    double atlag;
    for(int i=1;i<=7;i++)
      sum+=Console.readInt("A(z) "+i+". napi kaloria fogyasztas: ");
    atlag=sum/7.0;
    System.out.println("az atlag: "+atlag);
  }
}

----------------------------

Kérjen be egy egész számot, és állapítsa meg, hány 0 jegy szerepel benne!

import extra.*;
public class Gyak2_4{
  public static void main(String[]args){
    int a,n=0;
    a=Console.readInt("A szam: ");
    do{
      if(a%10==0) n++;
      a/=10;
    }while(a!=0);
    System.out.println(n);
  }
}

----------------------------
Írja meg a következő eljárásokat:
a, Kiír egy adott hosszúságú, adott karakterekből álló sort!
b, Konzolra írja a megadott értékhatárok közötti páros számokat!

class Gyak5_1{
 
  public static void sor(int hossz, char kar){
    for(int i=1; i<=hossz; i++)
      System.out.print(kar);
    System.out.println();
  }

  public static void parosok(int also,int felso){
    if (also%2==1) also++;
    for(int i=also; i<=felso; i+=2)
      System.out.print(i+"  ");
    System.out.println();
  }
 
  public static void main(String[]args){
    sor(33,'*');
    parosok(3,32);
  }
}

----------------------------

Írja meg a következő függvényeket:
a, A kör sugarából kiszámolja a kör kerületét!
b, Megadja, hogy a megadott szám pozitív-e!
c, Megadja két egész szám közötti összes egész szám összegét (a határokat is beleértve)!

import extra.*;
public class Gyak5_2{
 
  public static double kerulet(double r){
    return 2*r*Math.PI;
  }
 
  public static boolean pozitiv(int szam){
    return szam>0;
  }
 
  public static long osszeg(int alsoHatar, int felsoHatar) {
    long osszeg = 0;
    for(int i=alsoHatar; i<=felsoHatar; i++)
      osszeg += i;
    return osszeg;
  } 

  public static void main(String[]args){
    double r=Console.readDouble("Sugar: ");
    System.out.println("A kor terulete: "+kerulet);
  
    int b=Console.readInt("Szam: ");
    if(pozitiv(b))
      System.out.println("pozitiv");
    else
      System.out.println("nem pozitiv");
    System.out.println();
    System.out.println("1 és 100 kozotti szamok osszege: "+ osszeg(1,100));
  }
}

============================================

Kérje be egy telek oldalait méterben! Írja ki a telek területét négyszögölben
(1 négyszögöl=3,6m2)! Ha a telek 100 négyszögölnél kisebb, akkor írja ki,
hogy túl kicsi!

import extra.*;

public class Hf1 {
  public static void main(String[] args) {
    int szel  = Console.readInt("Telek szelessege(m): ");
    int hossz = Console.readInt("Telek hosszusaga(m): ");

    double ter = szel * hossz / 3.6;
    System.out.println("Terulet: "+ter+" negyszogol");
    if (ter<100)
      System.out.println("A telek tul kicsi!");
  }
}

----------------------------
Kérjen be egy évszámot! Ha a beütött szám negatív, adjon hibajelzést, ha nem,
állapítsa meg, hogy az évszám osztható-e 17-tel, vagy nem!

import extra.*;

public class Hf2 {
  public static void main(String[] args) {
    int evszam = Console.readInt("Evszam: ");
    if (evszam < 0)
      System.out.println("Negativ, nem jo evszam!");
    else {
      if (evszam%17==0)
        System.out.println(evszam + " oszthato 17-tel.");
      else
        System.out.println(evszam + " nem oszthato 17-tel.");
    }
  }
}

----------------------------

Kérjen be egy egyjegyű, nem negatív számot! Írja ki a szám szöveges formáját
(egy, kettő, stb.)!

import extra.*;

public class Hf3 {
  public static void main(String[] args) {
    int szam = Console.readInt("Egyjegyu nem negativ szam: ");
    String szoveg = "";
    switch (szam) {
      case 0: szoveg = "nulla"; break;
      case 1: szoveg = "egy"; break;
      case 2: szoveg = "ketto"; break;
      case 3: szoveg = "harom"; break;
      case 4: szoveg = "negy"; break;
      case 5: szoveg = "ot"; break;
      case 6: szoveg = "hat"; break;
      case 7: szoveg = "het"; break;
      case 8: szoveg = "nyolc"; break;
      case 9: szoveg = "kilenc"; break;
    }
    System.out.println(szam+" = "+szoveg);
 
  }
}

----------------------------

Kérjen be egy határszámot, majd írja ki eddig a számig az összes prímszámot!

import extra.*;
public class Hf4{
  public static void main(String[]args){
    int a, hatar;
    boolean prim;
    hatar=Console.readInt("Meddig: ");
    for(a=2;a<=hatar;a++){
      prim=true;
      for(int i=2; i<=Math.sqrt(a)&prim; i++)
        if(a%i==0) prim=false;
      if(prim) System.out.print(a+"  ");
    }
  }
}

----------------------------

Kérjünk be karaktereket * végjelig. Írjuk ki, hány nagybetűt, kisbetűt, számjegyet
ill. egyéb karaktert ütöttünk be!

import extra.*;
public class Hf5{
  public static void main(String[]args){
    char kar;
    int nb=0,kb=0,szj=0,egyeb=0;
    kar=Console.readChar("A karakter: ");
    while(kar!='*'){
      if('A'<=kar & kar<='Z')
        nb++;
      else if('a'<=kar & kar<='z')
        kb++;
      else if('0'<=kar & kar<='9')
        szj++;
      else
        egyeb++;
     
      kar=Console.readChar("A karakter: ");
    }
    System.out.println("Nagybetu: "+nb);
    System.out.println("Kisbetu: "+kb);
    System.out.println("Szamjegy: "+szj);
    System.out.println("Egyeb: "+egyeb);
  }
}

----------------------------

Készítsen pénzbedobó automatát. Először kérje be a bedobandó összeget. Az automata
csak 10, 20, 50, 100 Ft-os érmét fogadjon el. Az automata tájékoztasson, hogy mennyi
pénzt kell még bedobnunk, ill. túlfizetés esetén közölje a visszajáró összeget.

import extra.*;
public class Hf6{
  public static void main(String[]args){
    int be, marad;
    marad=Console.readInt("A bedobando osszeg: ");
    do{
      be=Console.readInt("Dobjon be egy ermet (meg "+marad+" Ft kell):");
      if (be==10 | be==20 | be==50 | be==100)
        marad-=be;
    }while(marad>0);
    System.out.println("Visszajar "+ -marad +"Ft");
  }
}

-----------------------------
Írja meg a következő eljárást:
Egy adott szélességű és magasságú tömör téglalapot rajzol a konzolra a megadott
karakterekkel! Például a teglalap(5,2,’@’); hívásának eredménye:
@@@@@
@@@@@

class Hf7{
 
  static void sor(int hossz, char kar){
    for(int i=1; i<=hossz; i++)
      System.out.print(kar);
    System.out.println();
  }

  static void teglalap(int hossz, int magassag, char kar){
    for(int i=1; i<=magassag; i++)
      sor(hossz, kar);
  }
 
  public static void main(String[]args){
    teglalap(40,5,'A');
  }
}

----------------------------

Írja meg a következő függvényeket:
a, Visszaadja egy szám kétszeresét!
b, Megadja, hogy a paraméterként megadott karakter benne van-e a szintén paraméterként
megadott tartományban (alsó határ, felső határ)!
Hívása pl: if (benne('a','z',kar))...
c, Kiszámítja egy szám egész hatványát
d, Eldönti egy számról, hogy az prím-e!

import extra.*;
public class Hf8{
 
  static int duplaz(int szam){
    return szam*2;
  }
 
  static boolean benne(char also, char felso, char kar){
    return also<=kar & kar <=felso;
  }
 
  static double hatvany(double alap, int kitevo){
    double h=1;
    for(int i=1; i<=kitevo; i++)
      h*=alap;
    return h;
  }

  static boolean prim(int szam){
    boolean p=true;
    for(int i=2; i<=Math.sqrt(szam)&p; i++)
      if(szam%i==0) p=false;
    return p;
  }

  public static void main(String[]args){
    int a=Console.readInt("Kerek egy szamot: ");
    System.out.println("A ketszerese: "+duplaz(a));
   
    char k=Console.readChar("A karakter: ");
    char ah=Console.readChar("Also hatar: ");
    char fh=Console.readChar("Felso hatar: ");
    if (benne(ah,fh,k))
      System.out.println("Benne van");
    else
      System.out.println("Nincs benne");
     
    System.out.println(hatvany(2.5,3));
    System.out.println();

    System.out.println("100-ig a primszamok:");
    for(int i=3;i<=100;i++)
      if(prim(i)) System.out.print(i+"  ");
  }
}