Bemelegítő feladatok

  1. Készíts “Helló világ” programot.
  2. Írd ki a parancssori paraméterek számát.
  3. Írd ki a parancssori paramétereket
    1. sorban
    2. sorszámozva
    3. fordított sorrendben
    4. csak a hosszaikat
    5. az összegüket (tfh mind szám)
    6. a párosakat
    7. sorrendben (tfh mind szöveg)
    8. sorrendben (tfh mind szám)
    9. azokat, amelyikekből több is található
  4. Írd ki a Fibonacci-sorozat első n elemét. Az n parancssori paraméter.
    1. oldd meg függvénnyel is
    2. … legalább három különböző megközelítés jöhet szóba
    3. készíts olyan függvényt is, amely a megadott paraméterig visszaadja az összes Fibonacci-értéket valamilyen adatszerkezetben
  5. Add meg egy parancssori paraméterként kapott szám összes osztóját.
  6. Vonj négyzetgyököt egy parancssori paraméterként kapott számból.

  7. A parancssori paraméterek lengyel formában adott kifejezést írnak le. A kifejezésben a négy alapművelet szerepelhet. Számítsd ki az eredményt.

    Pl. 1 2 3 * + eredménye (3 * 2) + 1, azaz 7

Bemelegítő feladatok 2.

Az alábbiak feladatok úgy is megoldhatók, hogy a “parancssori paraméterek” helyett a sztenderd bemenetről olvassuk be a paramétereket.

  1. A parancssori paraméterek a sík pontjait írják le. Add meg, melyik van legtávolabb az origótól.

    1. Add meg, hogy melyik pont van legközelebb a legelső ponthoz. (Saját maga kivételével, természetesen. Legalább két pontunk van.)

  2. Írd ki a parancssori paramétereket egy sorban úgy, hogy a paraméterekben az egymás utáni ‘a’ betűket egyetlen ‘a’ betűre cseréled.

    1. reguláris kifejezés használatával
    2. regkif nélkül, a StringBuilder osztály felhasználásával elkészítve az új szavakat

  3. A parancssori paraméterek emberek neveit tartalmazzák (egy családnév + egy utónév). Írd ki az emberek neveit családnév szerint csoportosítva.

  4. Írd ki a Pascal-háromszög első n sorát. Az n szám parancssori paraméter.

  5. Az első két paraméter, n és m, egy tábla méreteit leíró két egész szám. A további paraméterpárok a táblára leadott lövések koordinátái. Rajzold ki a táblát úgy, hogy X jelöli a találatokat, . pedig a többi mezőt.

  6. Az első parancssori paraméter egy szöveg, a többi paraméterpár pedig egy-egy karaktert tartalmaz. Cseréld le a szövegben a párok első felében szereplő karaktereket a másodikakra.

  7. Egy egyenes kieséses tornát szimulálunk. A parancssori paraméterek a következőképpen néznek ki. Az első paraméter a játékosok száma (n), ez kettő valamelyik hatványa. A következő n paraméter a játékosok neveit írja le. A következő n/2 paraméter az első kör eredményeit írja le: a szomszédos játékosok játszanak, 1 jelenti azt, hogy az első játékos győz, 2 azt, ha a második. Az így kialakuló n/2 játékos közötti n/4 meccs eredményeit, majd az abból kijövő n/8, n/16 stb. mérkőzés eredményeit a további paraméterek írják le.

A program írja ki a torna mérkőzéseit fordulónként vizualizálva (lásd a példát), illetve meccsekre bontva is. A fordulónkénti ábrázolás első oszlopában az összes játékos a felsorolt sorrendben található meg. A második oszlopban már csak a játékosok fele szerepel, akik győztek az első fordulóban stb.

Példa: ha a bemenet 8 J1 J2 J3 J4 J5 J6 J7 J8 1 1 1 2 1 2 2 akkor a kimenet alakja az alábbi legyen:

J1 J1 J1 J8
J2
J3 J3
J4
J5 J5 J8
J6
J7 J8
J8

a kimenet értelmezéséhez:

1. fordulo, J1-J2 gyoztese: J1
1. fordulo, J3-J4 gyoztese: J3
1. fordulo, J5-J6 gyoztese: J5
1. fordulo, J7-J8 gyoztese: J8
2. fordulo, J1-J3 gyoztese: J1
2. fordulo, J5-J8 gyoztese: J8
donto, J1-J8 gyoztese: J8

Kliens-szerver

  1. Készíts egy szervert és egy klienst. A szerver induljon el egy porton (ami parancssori paraméterként adott), a kliens csatlakozzon hozzá, és küldjön át egy üzenetet. A szerver írja ki az üzenetet a sztenderd kimenetére.

  2. A szerver küldje vissza a kliensnek az üzenetet, és a kliens írja ki azt.

  3. A szerver paraméterként kapjon egy szöveget is. A kliens küldjön át egy számot; a szerver egy sorban válaszoljon egy olyan szöveggel, amely a paraméterként kapott szövegét ennyiszer tartalmazza.

    1. A feladatnak van egy egyszerű nem túl hatékony (azaz: rossz futási karakterisztikájú) megoldása. Ha a kliens által küldött szám n, akkor milyen nagyságrendű lépést tesz meg (és mekkora memóriát foglal) ez a megoldás?

    2. Van két hatékony megoldás is, ami természetesen adódik, az egyik hasonlít az előzőleg említett megoldásra, a másik nem.

      • Ezek milyen nagyságrendűek?
      • Próbáld ki sok adattal őket annak igazolására, hogy sokkal hatékonyabbak.
      • A kettő közül hatékonyabb-e egyik a másiknál?

  4. A kliens küldjön át sorban egész számokat a szervernek. A számokat a kliens egy fájlból olvassa be. A szerver mindegyik számra meghív egy függvényt, ami egész számot készít (mondjuk n ↦ 2*n+1), majd az eredményt visszaküldi a kliensnek. A kliens a visszakapott eredményeket egy fájlba írja ki sorban. Ha a 0 szám következne a kliensoldalon, akkor a kliens kilép.

    1. A kliens most küldje át az összes adatot a szervernek, és csak utána fogadja a visszaérkező számokat; hasonlóan, a szerver fogadja az összes számot, és csak utána küldje el őket átalakítva a kliensnek.
    2. A szerver várakozzon a kliens kilépése után új kliensre, és ez ismétlődjön a végtelenségig.

  5. A kliens átküld egy fájlnevet a szervernek. A szerver küldje vissza a fájl tartalmát soronként, ha a fájl létezik, különben pedig egy szöveges hibaüzenetet.

  6. A szerver tárolja el, hogy hány kliens kapcsolódott már hozzá. Amikor egy kliens kapcsolódik, a szerver írja ezt vissza neki, majd rögtön bontsa a kapcsolatot, és várakozzon újabb kliensre.

  7. A szerver tároljon el egy számot, ennek értéke legyen kezdetben 0. Miután kapcsolódott, a kliens egymás után egész számokat küld át a szervernek; a szerver a kapott értékkel megnöveli a benne tárolt értéket, és ezt át is küldi a kliensnek. A kliens ki is léphet (pl. ha nullát küldene), ekkor a szerver kezdjen várakozni egy újabb klienstől jövő kapcsolatra. A tárolt szám maradjon meg, ne törlődjön.

  8. A kliens kapcsolódjon a 12345 porton futó szerverhez. Ez egy fájlból portszámokat olvas fel, és sorban átküldi őket a kliensnek. Amikor a kliens megkap egy portszámot, csatlakozik az azon a porton futó szerverhez (közben megtartja a kapcsolatát az első szerverrel). Ez a szerver egy fájlból néhány számot olvas fel, ezeket átküldi a kliensnek, majd bontja vele a kapcsolatot. A kliens minden megkapott szám fogadása után kiírja egy fájlba az összes eddig megkapott szám összegét.

  9. A szerverhez kapcsolódjon két kliens egymás után (ugyanazon a porton) úgy, hogy a szerver mindkét kapcsolatot egyszerre tartja nyitva. A kliensek először egy-egy sorban a saját nevüket küldik át, majd felváltva írhatnak be egy-egy sornyi szöveget. A beírt üzeneteket küldje át a szerver a másik kliensnek ilyen alakban: <másik kliens neve>: <másik kliens üzenete>. Ha valamelyik kliens bontja a kapcsolatot, akkor a szerver zárja be a másik klienssel a kapcsolatot, és lépjen ki.

    1. Ha az egyik kliens bontja a kapcsolatot, akkor a szerver várakozzon egy újabb kliensre, aki kapcsolódás után átveszi az előző helyét. Természetesen az új kliens is először a saját nevét küldi át.

    2. A porton tetszőlegesen sok kliens kapcsolódhat, és bármikor ki is léphetnek. A szerver sorban engedi szóhoz jutni a klienseket, azonban az üzeneteket nem azonnal küldi el mindegyik másik kliensnek. Ehelyett a szerver összegyűjti az üzeneteket, és csak akkor küldi el az adott kliens számára szóló üzeneteket, amikor az éppen szóhoz jut.

Párhuzamosság

  1. Készíts programot, ami párhuzamosan indít két szálat, amelyek a Hello és a világ szövegeket írják ki felváltva.

    1. A szálak most karakterenként írják ki a szövegeket.

    2. Mint a., de működjön jól a program.

  2. Két kecske egy szakadékon átívelő palló két oldalára ér. A palló n hosszú (n parancssori paraméter), a közepén találkoznak. A kecskék 0.5 és 2 mp közötti, véletlenszerű időközönként öklelnek egyet a másikon, így eggyel odébb kerülnek. Mindkét kecskének az a célja, hogy kilökje a másikat a palló túlvégén. A sztenderd kimenetre írj ki minden öklelést, illetve azt, hogy melyik kecske jutott át a pallón.

    1. A feladatnak kétféle jellemző ábrázolása van, találd meg mindkét megoldást.

  3. Készíts telnet klienst, ami párhuzamosan képes továbbítani a szerver által küldött üzeneteket a sztenderd kimenetre, illetve a sztenderd bemeneten érkező üzeneteket a szerverhez.

  4. Készíts olyan chat alkalmazást, amelyben a két kliensnek nem kell egymásra várnia soronként, hanem bármikor beszélhetnek egymáshoz, és ez azonnal kiíródik a másik kliensnél.

    1. Készíts chat szervert, amelyhez tetszőleges számú kliens kapcsolódhat, illetve bármikor bonthatják is a kapcsolatot. Minden kliens először a nevét közli egy sorban. A kliensek bármikor beszélhessenek, ami azonnal íródjon ki minden kapcsolódott kliensnél.

    2. A szerver, ha két parancssori paramétert kap, akkor a megadott gépen/porton levő másik szerverhez kapcsolódik, és névként “kliens” szerver nevet küld át; ebből a másik szerver tudja, hogy szerver kapcsolódott hozzá. A rendszer továbbra is működjön chat-szerverként, azaz bármelyik szerver bármelyik kliense üzenetét kapja meg mindegyik olyan kliens, aki a rendszerbe tartozik.

  5. Írj egyszerű HTTP szervert. Ehhez ismerni kell a HTTP protokollt, amelyet el lehet olvasni a protokoll dokumentációjából. Ehelyett most kezeld a protokollt fekete dobozként: a szervert úgy készítsd el, hogy megfigyeled egy valódi szerver működését (pl. www.elte.hu), és utánzod azt.

    1. A szerver legyen többszálú.

Szerializáció

  1. Készíts olyan programot, ami egy fájlba véletlenszerűen beleír Integer és Double objektumokat, összesen száz darabot.

    1. Készíts olyan programot, ami képes kiolvasni az előbbi fájlból az értékeket, és megadja, hány Integer és hány Double volt a fájlban, és mi az összegük.

  2. Készíts olyan osztályt, amely egy egész számokat tartalmazó bináris fát ábrázol. A fa legyen a lehető legegyszerűbb szerkezetű: csupán három adattag kell hozzá, valamint a hozzájuk tartozó getterek/setterek és két konstruktor.

    1. A főprogramba vegyél fel egy fát 4-5 csúccsal, és mentsd el egy fájlba ObjectOutputStream segítségével, majd töltsd be ObjectInputStream-mel.
      • Ha a fának megfelelő konstruktorai vannak, akkor kényelmesen építhető fel: a forráskódban is jól látszik a fa alakja.
      • Készíts olyan konstruktort is, amely egy szöveges fájlból beolvas egy teljes bináris fát, és azzal dolgozik a továbbiakban.
    2. A főprogram legyen kliens, amely kapcsolódjon egy szerverhez, és küldje át a fát. A szerver végezzen valamilyen műveletet a fával, és küldje vissza az eredményét. Néhány egyszerű művelet:
      • Tükrözd a bináris fa csúcsait: cserélődjön fel a jobb és a bal oldal.
      • Alakítsd át az összes csúcsot valamilyen függvény segítségével, pl. növeld meg minden csúcs értékét eggyel.
      • Számítsd ki a fa magasságát. (Itt egy számot küld vissza a szerver, az előző két esetben bináris fát.)

Távoli metódushívás

  1. Készíts RMI számológépet. Jegyezz be egy olyan szervert, amely egy számot tárol (a számológépen kijelzett szám), és a számológépek szokásos műveletei érhetőek el rajta (összeadás, szorzás stb.). Mindegyik művelet első operandusa a tárolt szám, a többi operandust meg kell adni a számológépnek. A műveletek eredménye lesz az új tárolt érték, valamint a műveletek visszatérési értéke is ez.

  2. Egy lottójáték a következőképpen van megvalósítva.
    1. Készíts olyan RMI klienst, amely lekérdezi a katalógusból azt, hogy a LottoDeploy milyen nevekre jegyezte be a számgolyókat, majd találd meg a nyerőszámokat.
      • A LottoDeploy véletlenszerűen sorsolja ki a nyerőszámokat, ezért újraindítás után más lesz az eredmény.
    2. Készíts saját LottoDeploy implementációt. Ez használjon külső névjegyzéket. Minden esetben működjön jól a program, pl. 10-ből 10 nyerőszám esetén is.

Adatbáziskezelés

  1. Készíts olyan programot, amely egy adatbázisban létrehoz egy logins táblát, és abban felvesz néhány felhasználónevet és hozzá tartozó jelszót. (Biztonságos rendszerben nem magát a jelszót tárolnánk.)
  2. Készíts olyan szervert, amely klienseket fogad egymás után. A kliensek szövegesen elküldik a nevüket és a jelszavukat. A szerver döntse el az adatbázis segítségével, hogy ismert-e a kliens és ha igen, helyes-e a jelszó, és erről küldjön üzenetet a kliensnek.
  3. Ha a kliens sikeresen bejelentkezett, kezdjen el vásárolni.