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+"  ");
  }
}

2018. június 6., szerda

A legolcsóbb mobilnet internetes telefonáláshoz


Az olcsó mobiltelefonálás mindenkinek lehetséges internetes szolgáltatókon keresztül. Erről itt írtam, hogyan csökkentsd radikálisan a telefonszámlád: Hívj mobilt 1,2 forintért.

VOIP (internetes) telefonálással jóformán nem lesz kiadásod. (Mi hárman közösen fogyasztottunk el négy és fél hónap alatt 10 dollárt (2.300 Ft-ot), igaz, az idő harmadában még 23 fillér (!) volt egy perc hívás díja, most már a tízszerese, 2,3 forint. De így sem költünk többet havi 4-500 forintnál fejenként. Ez fejenként 150-200 perc havonta, de vezetékes hívás esetén ennek a tízszerese.)

Azonban mobilnet nélkül csak wifi kapcsolat mellett tudod használni telefonálásra a feltöltött egyenlegedet.
Szerencsére havi 100 forintból is meg tudod úszni a netet, ennyit megér, hogy bármikor tudj telefonálni.
Mielőtt megnéznénk, hol ilyen olcsó a net, fontos pár dolgot tisztázni.
Az egyik, hogy kétféleképpen tudsz telefonálni interneten keresztül. Az egyik módja, hogy tárcsázol és interneten keresztül zajlik a kommunikáció. Ez a hagyományos módja a netes telefonálásnak. Ekkor a megállapított percdíjat fizeted (a fenti cikkben 2,3 Ft/perc magyar mobil irányba).
Itt két probléma szokott fellépni. Az egyik az adatforgalom nagysága, bár ez nem olyan komoly tétel. Egy perc beszélgetés a méréseim szerint 0,37 MB adatforgalmat generál, vagyis egy 100 MB-os csomag durván 250 percre elegendő, ha másra nem használod a netet egyáltalán. (Ez elég valószínűtlen egy okostelefonnál.)
A másik komolyabb probléma, hogy a szolgáltatók az olcsóbb csomagokban, főleg a telefonszám mellé kérhető kiegészítő netnél szándékosan akadályozzák a VOIP telefonálás lehetőségét. Magyarul: használhatatlan lesz a netkapcsolatod a telefonálásra.
Ezt úgy hívják, hogy nem hálózatsemleges a netkapcsolatod.
Ha T-mobile-os vagy, ide kattintva tudod ellenőrizni, hogy a te előfizetésed alkalmas-e internetes telefonálásra.
A Telenornál nincs ilyen egységes táblázat, itt írd be a Google-be, hogy Telenor hálózatsemlegesség és az internet-előfizetésed neve, mondjuk Klikk. (link ehhez a csomaghoz). Eszerint a Klikk előfizetés nem alkalmas netes telefonálásra.

A Vodafone összefoglaló táblázata itt.

Mindkét problémára megoldás az előző cikkben leírt program úgynevezett “Call Back” funkciója. Ha a netelőfizetésed nagyon kevés forgalmat tartalmaz, vagy tiltják a VOIP telefonálást a csomagodban, akkor tárcsázásnál használd a “Call Back” funkciót. Ezt a tárcsázó alatt tudod átállítani a hívásindítás előtt (VOIP Call – Call Back – Local Access).

Ilyenkor a hívás nem a te netkapcsolatodon épül fel, hanem a cég központján keresztül. A net csak annyira kell, hogy elküld az igényedet a központnak. Felhívnak először téged a rendes mobilodon, aztán azt, akit hívni szerettél volna.

Előnye, hogy szinte semmi netforgalmat nem generál, a hívás minősége sem függ a te netkapcsolatod mínőségétől. (Ez akkor is jól jön, ha a világ végén vagy, ahol nincs rendes mobilnet.)

Hátránya, hogy te fizeted mind a két hívás költségét (hogy téged felhívtak és azt is, akit hívni akartál), illetve fizetsz egy kapcsolási díjat is, ez jelenleg 3,9 dollárcent/alkalom (9 forint). Így egy háromperces mobilhívás 23 forint, vagyis bő 7 forint percenként. Azért ezt ki lehet bírni, ha más lehetőséged nincs beszélni. (Mert az 55 Ft/perc, amit átlagosan elkérnek a mobilszolgáltatók egy feltöltőkártyánál, az nem opció. De a T-mobile-nál 99(!!!) Ft egy perc az alapcsomagban, ráadásul percalapon.)

Tehát ha nincs lehetőséged nagy csomagra előfizetni, egy 10-15 MB-os csomaggal is elkaristolsz egy hónapig, ha csak telefonálásra használod.

Azonban vigyázz, az okostelefonod akkor is zabálja a megabájtokat, amikor nem tudsz róla. A háttérben frissít, lekérdezi a leveleket, időjárást. Az ingyenes programokban futó reklámok is megabájt-gyilkosok.

Néhány tipp, hogy ne fogyjon el a havi kereted, mielőtt még elkezdenéd használni azt:

– A legegyszerűbb mód: mindig tartsd kikapcsolva a mobilnetet, csak telefonáláshoz kapcsold be és utána ne felejtsd el kikapcsolni. (Beállítások > Adathasználat > kikapcsolás)

– Ugyanitt látod újabb androidos telefonoknál, hogy melyik program mennyi adatot használt. Kattints a programra és pipáld ki a “Háttéradatok korlátozása” lehetőséget, hogy ne küldjön és fogadjon ész nélkül adatokat a program. Ugyanezt tedd meg a Play áruháznál is és tiltsd le az automatikus frissítését minden programnak.

– Tegyél fel még egy böngészőt a telefonodra, amelyiket mobilnettel használsz csak. Itt kapcsold ki a képeket. Egy index.hu főoldal képek nélkül is élvezhető, csak éppen huszadannyi adatforgalmat generál. Az Opera Mini jó lehet második böngészőnek.

– Ha nem idegenkedsz a technikai megoldásoktól és a telefonod sem garanciális már, könnyen root-olhatod is azt. Ez nem egy nagy wasistdas, de ha még a telefon menüjébe sem mersz belépni, nehogy elronts valamit, akkor inkább ne csináld. Ha mégis megteszed, egy tűzfallal te magad tudod szabályozni, melyik program érheti el a netet és mikor (soha, mindig, csak wifi esetén.) Így nem ér az a meglepetés, hogy a programok a háttérben elhasználták a havi keretedet, mielőtt még te használni tudtad volna.

Ennyi bevezető után nézzük, hogyan tudod fillérekből megúszni a mobilnetet.

Két lehetőséged van: a beszélgetésre is használt kártyád mellé kérsz kiegészítő net csomagot aranyáron, vagy külön kártyát használsz kizárólag mobilnetre.

A második eshetőséghez vagy az kell, hogy az okostelefonodba teszed a netkártyát (úgyis ezen böngészel, telefonálsz VOIP-on keresztül, stb.) és az a kártya, amin téged hívnak, egy 3.000 forintos butamobilba kerül. Ezt már úgyis csak hívásfogadásra fogod használni.

Alternatív lehetőség a kétkártyás mobil vétele, ilyen telefont már nagy cégek is kínálnak, mint például a Samsung.

Következő lépés, hogy mi a fontos? Legyen minél olcsóbb, vagy inkább egyszerűbb? Elég a minimális pár megabájt, vagy azért többre vágysz?

Először nézzük az olcsó lehetőségeket.

Azt használjuk ki, hogy az aranyáron mért internet-hozzáférést az új kártyákhoz beetető jelleggel az első pár hónapban szinte ingyen adják az eldobható feltöltőkártyás előfizetésekhez is.

A legolcsóbb lehetőség egyike a Telenor Klikk szolgáltatása, amely 100 MB netet ad, az első három hónapban ingyen. Veszel egy Telenor SIM kártyát bármelyik hiperben 300 Ft-ért (Vigyázz, a Telenor üzletekben ez sokkal drágább!), aktiválod a kártya után a Klikk netszolgáltatást is és máris van havi 100 MB-od, száz forintért havonta. Sajnos ez közvetlen telefonálásra nem alkalmas, csak Call Back hívásokra.

Másik nyerő lehetőség a Lidl-ben kapható Blue Mobile kártya. Az ezer forintos kártyán (néha akcióban olcsóbb) aktiválhatod a netet, két hónapig 90 Ft-ért, 133 MB/hó. VOIP hívására alkalmas! Túlforgalmazás lehetséges, hónap végéig lassítás mellett.

Sőt, most akcióban minden aktivált kártyához hat hónapig ingyen jár 15 MB.

Így már 500 Ft a mobilnet költsége havonta, de tudsz telefonálni közvetlenül is, sőt még 4 hónapig kapsz 15 MB-ot, ami havi mintegy 35 perc netes beszélgetésre elég, ha másra nem használod.



Elég havi 10 MB, hogy tudd használni a Call Back funkciót? Válaszd a Tesco Mobile-t, ott minden hónapban kapsz 10 MB-ot ingyen, ha aktív a kártyád. Emlékeim szerint az új kártya ezer forint és egy évig aktív. Utána minimum 3.500 forinttal kellene feltölteni, az már nem éri meg a net miatt.

Amire figyelj, hogy egy-egy szolgáltatónál általában csak évi két előfizetést vehetsz. Ezért ha ebből kifutottál, szét kell nézni a családban, kinek nincs még ilyen eldobható előfizetése.

Nem akarsz ezzel játszani? Válaszd a szintén feltöltőkártyás Telenor Mobilinternetet  Itt minden megabájt 5 Ft-ba kerül, de nincs havidíj. Így egy perc VOIP beszélgetéshez durván két forintért kapsz internetet. (VOIP hívásra alkalmas). Egyetlen hátulütője, hogy félévente-évente fel kell tölteni az egyenleget, hasonlóan a többi feltöltőkártyához, egyébként az egyenleged elvész. De hát csak elhasználsz ennyi adatot fél év alatt.

Szeretnél egyébként is internetezni útközben?

Ha van Digi előfizető a családban, havi 1.500 Ft-ért kapsz 1 GB internetet, részletek itt.

További tipp az olvasóktól: Töltsd fel a feltöltőkártyádat 5.000 Ft-tal a Vodafone PercNet csomagjában 1 GB internetért, de ne letelefonáld az egyenlegedet, hanem költsd el mondjuk vonatjegy vásárlására. A Telenornál ugyanilyen módon 3.000 Ft feltöltéséért 150 MB net jár. Így is ingyen van a net. Annyiszor feltöltöd a meglévő kártyát, ahányszor kell a net, csak éppen levásárlod a keretet és nem letelefonálod.

Amint látod, egy kis utánajárással már tényleg bárhol telefonálhatsz 2-3 forintos percdíjakkal.

2018. június 5., kedd

Cloud computing paradigma II.

 A rendszerben önálló számítógépek futnak, magas üzemeltetési költséggel és alacsony kihasználtsággal, általában magas rendelkezésre állási rendszerek nélkül, hiszen az ilyen rendszer kiépítése további költségekkel jár. A rendszer igény szerinti méretezhetősége szintén bonyolult, a szolgáltatás bővítése rendszerint további kiszolgálók üzembe helyezésével valósul meg.Egy kis- és középvállalat nem mindig engedheti meg magának, hogy további anyagi forrásoksegítségével garantálja a különböző rendszerek rendelkezésre állását és itt a jól felkészült üzemeltetői  szakemberekkel még nem is számoltunk. Azokról a szakemberekről, akik bevezetik, és később pedig üzemeltetik ezeket a rendszereket. Amikor felhő alapú szolgáltatásokról beszélünk, az emberek nagy része valami megfoghatatlan, értelmezhetetlen dologra gondol, pedig semmi más, mint a meglévő szolgáltatások megfelelő kombinációja egy egységes, komplex rendszer kialakítására. Beszélhetünk nyilvános felhőről, ahol a kiszolgálókat, szolgáltatásokat egy külső cégnél – akár a Microsoftnál – futtatjuk, illetve a felhő-szolgáltató több ügyfélnek szolgáltat infrastruktúra, platform, vagy szolgáltatás-csomagokat, és beszélhetünk privát felhőről, amikor mi magunk hozzuk létre a megfelelő infrastruktúrát a saját alkalmazásaink futtatásához. A publikus felhő előnye, hogy nem kell bonyolult infrastruktúrát kiépíteni, sőt, bizonyos esetekben semmiféle infrastruktúrára nincs szükségünk. A számunkra szükséges szolgáltatásokat – pl. levelezés, csoportmunka, vállalatirányítás – béreljük a különböző szolgáltatóktól. A privát felhő abban az esetben lehet előnyös, ha van megfelelő infrastruktúránk – hardver és szoftver – a rendszer kiépítéséhez, vagy a céges belső információkat nem szeretnénk a felhőben tárolni, vagy nincs megfelelő gyors és stabil sávszélességünk a publikus felhő használatához. Az infrastruktúra nagyjából ugyanaz, a különbség csupán annyi, hogy a publikus felhőt különböző cégek, mint előfizetést használják, a privát felhőt pedig a saját szolgáltatásaink futtatására használjuk. Bizonyos esetekben szükségünk lehet arra, hogy adataink és szolgáltatásaink egy része a belső infrastruktúrán működjön tovább, bizonyos részét pedig migráljuk a felhőbe. Az ilyen hibrid rendszereknél szükségünk lesz a beállítások – címtár, felhasználók, levelezési beállítások – folyamatos szinkronizálására. Az Office 365-ben lévő Exchange jó példája a hibrid rendszernek, hiszen a felhasználók egy része a helyi hálózaton lévő levelezést használja, másik részük a felhőben lévő Exchange Servert. A két rendszer kapcsolatban van egymással, de egységes egészként tekinthetünk rájuk.  Szolgáltatások a felhőben software as a Service (SaaS) – alkalmazás futtatása a felhőben, lehetővé teszi, hogy a felhasználók helytől és eszköztől függetlenül elérjék az adott alkalmazást. A rendszergazdáknak nem kell kiépíteni a futtatáshoz szükséges infrastruktúrát. Akkor hasznos, ha általános alkalmazásokat akarunk futtatni, pl. levelezést, csoportmunkát, CRM rendszert. Tipikus példája az Office 365, ahol – szemben a helyi infrastruktúra üzemeltetésével – nincs szükségünk saját kiszolgálóra, nem kell Windows-t, Exchange-et, vírusirtót, tanúsítványt, tűzfalat, stb. telepítenünk, csak egyszerűen létrehozzuk a felhasználóinkat, akik azonnal használhatják az Exchange, SharePoint és a CRM rendszer teljes funkc ionalitását. SaaS környezetben minimális üzemeltetési feladatunk, deezzel szemben kevesebb lehetőségünk is van.  Platform as a Service (PaaS) Alkalmazásával platformot kapunk a saját rendszerünk üzemeltetéséhez a felhőben. Ez a platform lehet tárterület, adatbázis-hozzáférés, futtatási környezet, stb. PaaS használatával a fejlesztőknek lehetőséget adunk, hogy alkalmazásaikat a felhőben teszteljék és futtassák. Az SQL Azure tipikus példája a PaaS rendszernek, ahol az alap infrastruktúrát, a Windows és SQL Server környezetet béreljük, itt tudunk adatbázisokat futtatni, illetve össze is köthetjük a saját infrastruktúránkon futó alkalmazásainkkal.  Infrastructure as a Service (IaaS): Ebben az esetben alap infrastruktúrát kapunk, virtuális gépeket, tárterületet és hálózati hozzáférést, így lehetőségünk van egyéni feladatokat megvalósítani, vagy meglévő hálózatunkat beköltöztetni a felhőbe. Nincs szükségünk saját hardverre vagy internet-kapcsolatra az infrastruktúránk futtatásához. Az IaaS rendszerek biztosítják a folyamatos elérhetőséget, a magas rendelkezésre állást, a mentési folyamatokat, mi pedig használat után fizetünk, illetve bármikor, rugalmasan bővíthetjük gépeinket vagy igényelhetünk újabbakat. A Microsoft Azure IaaS alapja aHyper-V technológia és a System Center család. A felhő nem a jövő hanem jelen és lassan a múlt.