A Debreceni Egyetem programozói évkönyve

Átírás

1 A Debreceni Egyetem programozói évkönyve i A Debreceni Egyetem programozói évkönyve A 2013/14 tanév tavaszi és a 2014/15 tanév őszi szemesztere Ed. Egyetemi jegyzet, verzió

2 A Debreceni Egyetem programozói évkönyve ii Copyright 2014 Dr. Bátfai Norbert UDProg, The Yearbook of the Programmers of University of Debrecen Copyright (C) 2014, Norbert Bátfai This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see licenses/. Ez a program szabad szoftver; terjeszthető illetve módosítható a Free Software Foundation által kiadott GNU General Public License dokumentumában leírtak; akár a licenc 3-as, akár (tetszőleges) későbbi változata szerint. Ez a program abban a reményben kerül közreadásra, hogy hasznos lesz, de minden egyéb GARANCIA NÉLKÜL, az ELADHA- TÓSÁGRA vagy VALAMELY CÉLRA VALÓ ALKALMAZHATÓSÁGRA való származtatott garanciát is beleértve. További részleteket a GNU General Public License tartalmaz. A felhasználónak a programmal együtt meg kell kapnia a GNU General Public License egy példányát; ha mégsem kapta meg, akkor tekintse meg a oldalon.

3 A Debreceni Egyetem programozói évkönyve iii COLLABORATORS TITLE : A Debreceni Egyetem programozói évkönyve ACTION NAME DATE SIGNATURE WRITTEN BY Bátfai, Norbert, Bereczki, László, Sipos, Ferenc, Kakócz, Erik, Szentpéteri, Annamária, Forgács, Péter, Bak, Balázs, Kistamás, Dávid, Nagykéri, Bence, Nagy, Sándor, Kis, Dávid, Varga, Attila, Busák, Zoltán, Akai, Zsolt, Löki, Tamás, Kovács-Ferenc, Norbert, Gyügyei, Tamás, Apró, Anikó, Szálku, Tibor, Veress, Balázs, Fekete, Sándor, Ã s Fenesi, Gábor december 24. REVISION HISTORY NUMBER DATE DESCRIPTION NAME

4 A Debreceni Egyetem programozói évkönyve iv Tartalomjegyzék I. Feladatok 2 1. A kezdő szint programjai Az első C programok Végtelen ciklus Két változó értékének cseréje Pattogó labda Helló, Világ a sztenderd hibára Átlag Véletlen számok A szóhossz a gépeden BogoMIPS Környezeti változók A lexikális elemzéssel kapcsolatos első programjaid Betűk számolása Számok számolása Szavak számolása Sorok számolása Rendszerprogramozással kapcsolatos első programjaid Villa Zombi Riasztás Utolsó tennivaló Nem lokális ugrások Az első algoritmizálási programjaid Mandelbrot halmaz Elfolyik a PageRank Ellopni a PageRank értéket Alternatív tabella

5 A Debreceni Egyetem programozói évkönyve v 1.6. Az első párhuzamos programjaid Elromlik a változó Az első GNU/Linux kernellel kapcsolatos programjaid Helló, Világ! a kernelből A PCB mérete A PCB mérete modulból Az első MINIX kernellel kapcsolatos programjaid Helló, Világ! a kernelből A PCB mérete A processztábla méretének módosítása Ütemezési sorok Az első C++ programok Módosított polártranszformációs véletlen szám generátor, ez legyen az első C++ progid! Csere mutatók nélkül Komplex osztályos Mandelbrot Az első nyelvi programjaid Másoló és mozgató konstruktor és értékadás Mély és sekély másolás Másolt vektor Másolt verem Másolt lista Másolt map Másolt map Az első Qt programjaid A Mandelbrot RGB színezése Szavazás feladat: Mandelbrot szépségverseny A számítás adatai a képre Szavazás feladat: biomorf szépségverseny A számítás adatai a képre A genetikai kód-szőnyeg parancssori bemenete További élőlények a sejttérben Az első képfeldolgozással kapcsolatos programjaid Az első png++ és pngwriter könyvtárakkal kapcsolatos programjaid Kockásítás a png++ könyvtárral Kockásítás a pngwriter könyvtárral Az első Open CV-vel kapcsolatos programjaid Az első STL-el és Boost-al kapcsolatos programjaid Poszt feladat: lambda Az első Java programok Módosított polártranszformációs véletlen szám generátor, ez legyen az első Java progid!

6 A Debreceni Egyetem programozói évkönyve vi 2. A közepes szint programjai A kezdő szintű feladatokra épített példák Normálisok Normális-harang Normális-harang grafikusan Mérkőzés eredmények Pattogó labda Rendszerprogramozással kapcsolatos programjaid Glibc függvény felüldefiniálása Rendszerstatisztika Képfeldolgozó programjaid P-szálas kockásítás a png++ könyvtárral Open MP-s kockásítás a png++ könyvtárral P-szálas kockásítás a pngwriter könyvtárral Open MP-s kockásítás a pngwriter könyvtárral Az első Qt programjaid Arecibói Üzenet Mandelbrot rajzoló Mandelbrot nagyító Mandelbrot halmaz mentő A genetikai kód-szőnyeg A kód vizualizációjának mentése Sejtautomata szimulációk Sejttér mérete Sejttér mentése Slot-signal A GNU/Linux kernellel kapcsolatos programjaid Folyamatokat számláló modul Folyamatokat kiíró modul Fájlleíró modul A MINIX kernellel kapcsolatos programjaid Nyomkövetés Ütemezés Algoritmizálási programjaid BBP megvalósítás Nyelvi programjaid Saját int verem Saját int dinamikus tömb

7 A Debreceni Egyetem programozói évkönyve vii 3. A haladó szint programjai Párhuzamos programjaid Mandelbrot több szálon P-szálakkal Mandelbrot több szálon Open MP-vel Mandelbrot Intel TBB-vel Exor-törés párhuzamosítása A GNU/Linux kernellel kapcsolatos programjaid A /proc virtuális fájlrendszer Melyik az éppen futó processz? A MINIX kernellel kapcsolatos programjaid Processzek üzenetmátrixa, PCB módosítással Processzek üzenetmátrixa, saját rendszerhívással Rendszerprogramozással kapcsolatos programjaid Rendszerstatisztika folytatása Algoritmizálási programjaid Pi-számítása a kernel üzenetsoraival Képfeldolgozási programjaid Az első Open CV-vel kapcsolatos programjaid Labda követése A kiemelkedő szint programjai CUDA programok Az EXOR-kódtörés CUDA párhuzamosítása QCSS programok QCSS 2D megjelenítő QCSS szurkolói ágens RCSS programok Saját 2D RCSS csapat MINIX kernellel kapcsolatos programok MINIX 3 ütemező Algoritmizálási programjaid Pi-számítása több gépen A védések programjai A 2013/14 tanév tavaszi szemeszterének védései Az első védés: a humán genom LZW-bináris fa alapú feldolgozása A második védés: egy saját RCSS multiágens C++ implementáció A 2014/15 tanév őszi szemeszterének védései A harmadik védés: lépés a projektek felé A negyedik védés: egy céges feladat kidolgozásában részvétel

8 A Debreceni Egyetem programozói évkönyve viii 6. A labor-mérés programjaid A 2013/14 tanév tavaszi szemeszterének labor-mérései Ismerkedő labor labor Bevezető laborok A második labor Egy saját Google PageRank implementáció A harmadik labor Exor-törés A kapcsolódó laborfeladatok e.c t.c A t.c kiegészítése A negyedik labor Liv-Zempel fa építése a humán genom emberi 2. kromoszómájából A kapcsolódó laborfeladatok LZW fák z.c d.c A h.c és a g.c Labor és szorgalmi laborfeladatok Aminosav-hisztogram Még drágább aminosav-hisztogram Az aminosav-hisztogram mindig drága C-ből C PyTCAG PySzavak A nukleobázisok számolása a humán genom második kromoszómáján C++ban a Map-Reduce platformon Az aminosavak számolása a humán genom második kromoszómáján C++ban a Map-Reduce platformon Filogenetikai fa az LZW-s fa ághosszainak szórása alapján Az ötödiktől a hetedik laborig A védési program megalapozása Bináris fa mains.cpp maini.cpp binfa.h int.h

9 A Debreceni Egyetem programozói évkönyve ix int.cpp Qt programok Arecibói üzenet Mandelbrot halmaz Sejtautomata Portoljuk Androidra Programok párhuzamosítása A Mandelbrot-számoló párhuzamosítása Az exor-törés Open MP párhuzamosítása Robotfocis laborok A nyolcadik labor Kick-off Bemelegítés - legyen kapus a kapus A kilencedik labor A második védés megalapozása Saját viselkedés szögletnél A tizedik és tizenegyedik labor Laborfeladatok Kvantum-tudatos laborok A tizenkettedik labor A céges feladatok bevezetése Az utolsó labor Lespecifikált feladatok A 2014/15 tanév őszi szemeszterének labor-mérései Beszokató labor Az első labor Bevezető laborok A második labor A védési program Java és C# átirata Java performance tuning További pontgyűjtő feladatok A harmadik labor YANonymous = YANA (You Are Not Alone) + Anonymous = You Are Not Anonymous További pontgyűjtő feladatok YANO laborok A negyedik labor YANO hack További pontgyűjtő feladatok

10 A Debreceni Egyetem programozói évkönyve x Az ötödik labor YANO hack További pontgyűjtő feladatok Haladó laborok A hatodik labor Robocar City Emulator További pontgyűjtő feladatok A hetedik labor Labormérés További pontgyűjtő feladatok A nyolcadik labor Labormérés További pontgyűjtő feladatok A kilencedik labor Labormérés További pontgyűjtő feladatok A tizedik labor Labormérés További labormérés feladatok További pontgyűjtő feladatok A tizenegyedik labor Labormérés További pontgyűjtő feladatok A tizenkettedik és az utolsó labor Labormérés További pontgyűjtő feladatok Robotfocis programok Bemelegítés Legyen kapus a kapus D RCSS ágensek D RCSS multiágensek Versenynaptár Robotfoci logó Szavazás feladat Logó-forráskód generátor feladat Szuperszámítógépes programok Tízből kilencszer mi nyertünk volna

11 A Debreceni Egyetem programozói évkönyve xi 9. A só programok Genesis Patch Egyéb feladatok Operációs rendszerekkel kapcsolatos alapvető feladatok A GNU/Linux kernellel kapcsolatos feladatok Kernelfordítás Telepítéssel és virtualizációval kapcsolatos feladatok Dual-boot MINIX virtualizálás OpenSolaris virtualizálás BSD virtualizálás Az információs-távolsággal kapcsolatos feladatok Genomok összehasonlítása SZT tisztek gráfja Design-al kapcsolatos feladatok Az UDProg évkönyv logója Szavazás feladat: az UDProg évkönyv logójának szavazása Egyéb segítő feladatok Másoló konstruktor demó Mozgató konstruktor demó Promóciós feladatok Promóciós robotfoci-videó Szavazás feladat: promóciós robotfoci-videó Promóciós kurzus-videó Szavazás feladat: promóciós kurzus-videó Promóciós kurzus-prezi Szavazás feladat: promóciós kurzus-prezi Dokumentálással kapcsolatos feladatok UML Doxygen Tesztelési feladatok Tankönyvi feladatok A [STROUSTRUP] könyv feladatai X.2[1] feladat X.2[4] feladat X.2[7] feladat X.2[9] feladat

12 A Debreceni Egyetem programozói évkönyve xii X.2[10] feladat X.3[2] feladat X.3[3] feladat X.3[4] feladat X.3[5] feladat X.3[6] feladat X.3[7] feladat X.5[2] feladat X.5[3] feladat X.5[4] feladat X.5[5] feladat X.5[6] feladat X.5[7] feladat X.5[8] feladat X.5[9] feladat X.5[10] feladat X.6[2] feladat X.7[1] feladat X.7[2] feladat X.7[6] feladat X.7[7] feladat X.7[8] feladat X.7[9] feladat X.7[12] feladat X.7[13] feladat X.8[1] feladat X.8[3] feladat X.8[4] feladat X.8[5] feladat X.8[7] feladat X.8[8] feladat X.8[9] feladat X.8[10] feladat X.8[11] feladat X.8[12] feladat X.9[1] feladat X.9[2] feladat X.9[4] feladat X.10[1] feladat

13 A Debreceni Egyetem programozói évkönyve xiii X.11[1] feladat X.11[2] feladat X.11[3] feladat X.11[6] feladat X.11[10] feladat X.13[1] feladat X.13[2] feladat X.13[3] feladat X.13[4] feladat X.13[9] feladat X.13[14] feladat X.13[15] feladat X.13[20] feladat X.13[21] feladat X.17[4] feladat X.17[7] feladat X.17[8] feladat X.17[13] feladat X.19[4] feladat X.21[1] feladat X.32[1] feladat X.32[2] feladat X.32[3] feladat X.32[4] feladat X.32[5] feladat X.32[6] feladat X.37[1] feladat A [KR] könyv feladatai gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat

14 A Debreceni Egyetem programozói évkönyve xiv gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat Az [SZFCPP] könyv feladatai feladat feladat feladat feladat feladat feladat feladat

15 A Debreceni Egyetem programozói évkönyve xv feladat feladat betű számoló szám számoló filozófusok oda-vissza filozófusok másolása feladat bitbeszúrás Az [EZUST] könyv feladatai gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat gyakorlat Vizsgarendszer A 2013/14 tanév tavaszi szemeszterének vizsgái Szóbeli vizsgák A 2014/15 tanév őszi szemeszterének vizsgái Szóbeli vizsgák Királyi út a szóbeli vizsgán Nincs 13. fejezet Céges feladatok Robocar World Championship in Debrecen II. Megoldások A kezdő szint programjai Az első C programok Végtelen ciklus Két változó értékének a cseréje Két változó értékének a cseréje swap függvénnyel Két változó értékének a cseréje swap függvénnyel C-ben Pattogó labda Pattogó labda Pattogó labda

16 A Debreceni Egyetem programozói évkönyve xvi Pattogó labda Helló, Világ a sztenderd hibára Átlag Véletlen számok A szóhossz a gépeden A szóhossz a gépeden, sizeof operátorral A szóhossz a gépeden, bitműveletes módszerrel BogoMIPS Környezeti változók A lexikális elemzéssel kapcsolatos első programjaid Betűk számolása Számok számolása Szavak számolása Sorok számolása Rendszerprogramozással kapcsolatos első programjaid Villa Zombi Riasztás Utolsó tennivaló Nem lokális ugrások Az elso párhuzamos programjaid Elromlik a változó Az első algoritmizálási programjaid Mandelbrot halmaz Elfolyik a PageRank Ellopni a PageRank értéket Alternatív tabella Az első GNU/Linux kernellel kapcsolatos programjaid Helló, Világ! a kernelből A PCB mérete A PCB mérete modulból Az első MINIX kernellel kapcsolatos programjaid Helló, Világ! a kernelből A processztábla mérete Ütemezési sorok A PCB mérete Az első C++ programok Módosított polártranszformációs véletlenszám generátor, ez legyen az első C++ progid! Másolt Vektor

17 A Debreceni Egyetem programozói évkönyve xvii Másolt Verem Másolt Lista Másolt map Másolt map Komplex osztályos Mandelbrot Az első Qt programjaid A Mandelbrot RGB színezése A genetikai kód-szőnyeg parancssori bemenete További élőlények a sejttérben Az első képfeldolgozással kapcsolatos programjaid Az első png++ és pngwriter könyvtárakkal kapcsolatos programjaid Kockásítás a png++ könyvtárral Kockásítás a pngwriter könyvtárral Az első Open CV-vel kapcsolatos programjaid Az első Java programok Módosított polártranszformációs véletlenszám generátor, ez legyen az első Java progid! Labor és szorgalmi laborfeladatok Aminosav-hisztogram Filogenetikai fa az LZW-s fa ághosszainak szórása alapján A közepes szint programjai A kezdő szintű feladatokra épített példák Normálisok Normális-harang Normális-harang grafikusan Pattogó labda több szálon futó kockásítás png++ könyvtárral több szálon futó kockásítás pngwriter könyvtárral Rendszerprogramozással kapcsolatos programjaid Glibc függvény felüldefiniálása Saját top parancs Az első Qt programjaid Arecibói üzenet Mandelbrot rajzoló Mandelbrot nagyító Mandelbrot mentő A genetikai kód-szőnyeg A kód vizualizációjának mentése

18 A Debreceni Egyetem programozói évkönyve xviii Sejtautomata szimulációk Fájlleíró modul BBP megvalósítás Saját int veremosztály Saját int dinamikus tömb osztály Tömb osztály definíció Tömb osztály implementáció Tömb osztály teszt A Haladó szint programjai Párhuzamos programjaid Mandelbrot több szálon P-szálakkal Mandelbrot több szálon Open MP-vel Mandelbrot Intel TBB-vel Exor-törés párhuzamosítása Minix kernellel kapcsolatos programok Processzek üzenetmátrixa, PCB módosítással Képfeldolgozási programjaid Az első Open CV-vel kapcsolatos programjaid Labda követése A Labor-mérés prograjaid A 2014/15 tanév őszi szemeszterének labor-mérései Bevezető laborok A védési program Java és C# átirata Első védési program Python átirata Első védési program sebességteszt eredménye A BBP-s sebességteszt elvégzése Java Performance Tuning Alternatív Tabella Alternatív Tabella C# Alternatív Tabella Python Kvíz megoldások: YANonymous PeldaServlet GlassFish Sparse Table vs. StlMap Sparse Table vs. VectorBasedSparseMap Hibásan implementált RSA törés

19 A Debreceni Egyetem programozói évkönyve xix 19. Egyéb feladatok Operációs rendszerekkel kapcsolatos alapvető feladatok A GNU/Linux kernellel kapcsolatos feladatok Kernelfordítás Telepítéssel és virtualizációval kapcsolatos feladatok Dual-boot MINIX virtualizálás OpenSolaris virtualizálás BSD virtualizálás Az információs-távolsággal kapcsolatos feladatok Genomok összehasonlítása SZT tisztek gráfja Design-al kapcsolatos feladatok Az UDProg évkönyv logója Az UDProg logoterv Az UDProg logóterv Másoló konstruktor demó Fő forrásfájl Alapértelmezett másoló konstruktoros osztály Osztály-definíció Implementáció Letiltott másoló konstruktoros osztály Osztály-definíció Implementáció "Deep copy" konstruktoros osztály Osztály-definíció Implementáció Tankönyvi feladatok kidolgozása A Stroustrup könyv példái X.2[1] feladat X.2[4] feladat X.2[7] feladat X.3[2] feladat X.3[3] feladat X.3[4] feladat X.3[5] feladat X.3[6] feladat X.3[7] feladat

20 A Debreceni Egyetem programozói évkönyve xx X.5[2] feladat X.5[3] feladat X.5[4] feladat X.5[5] feladat X.5[6] feladat X.5[7] feladat X.5[7]b feladat X.5[8] feladat X.5[9] feladat X.5[10] feladat X.6[2] feladat X.7[2] feladat X.7[8] feladat X.7[9] feladat X.7[13] feladat X.8[4] feladat X.8[5] feladat X.8[7] feladat X.8[9] feladat X.8[11] feladat X.9[1] feladat X.9[2] feladat X.10[1] feladat X.11[10] feladat X.13[9] feladat X.13[14] feladat X.13[15] feladat X.13[21] feladat X.17[4] feladat X.17[7] feladat X.17[8] feladat X.17[13] feladat X.19[4] feladat X.21[1] feladat X.32[1] feladat X.32[2] feladat X.32[3] feladat X.32[4] feladat X.32[5] feladat X.32[6] feladat X.37[1] feladat

21 A Debreceni Egyetem programozói évkönyve xxi III. Laborkártyák Laborkártyák Bevezető laborkártyák A parancssori interfész (CLI) alapvető használata A kézikönyv A fordítóprogram Vektorizálás A kapcsolatszerkesztő program Az alapvető C és C++ nyelvi konstrukciók használata Nevek bevezetése a programba for először for másodszor for harmadszor if először if másodszor while const char * Paraméterátadás A szabad tár kezelése char ** C++ alapfogalmak Másoló konstruktor és másoló értékadás /source/labor/kartyak/Int1/main.cpp /source/labor/kartyak/Int1/main2.cpp /source/labor/kartyak/Int1/main3.cpp Ne hívódjon a másoló ctor /source/labor/kartyak/Int1/main5.cpp Másoló konstruktor és másoló értékadás másodszor /source/labor/kartyak/Int2/main.cpp Mi történik, ha? /source/labor/kartyak/Int2/main2.cpp Mozgató konstruktor és mozgató értékadás /source/labor/kartyak/Int4/main.cpp Rule of Five /source/labor/kartyak/Int5/main.cpp

22 A Debreceni Egyetem programozói évkönyve xxii 22. Laborkártyák kidolgozása Bevezető laborkártyák A parancssori interfész (CLI) alapvető használata A kézikönyv A fordítóprogram Vektorizálás A kapcsolatszerkesztő program Az alapvető C és C++ nyelvi konstrukciók használata Nevek bevezetése a programba for először for másodszor for harmadszor if először if másodszor while const char * Paraméterátadás A szabad tár kezelése char ** IV. Évkönyv A 2013/14 tanév A tavaszi szemeszter, avagy a prog Az évfolyam legfontosabb hallgatói - tutor rendszer Az évfolyam legfontosabb hallgatói - feladatok megoldása Az évfolyam legfontosabb hallgatói - skillek Az évfolyam kapcsolatai Önbevallások és rövid bio-k Hallgatók Kiemelkedő Haladó Közepes Kezdő Oktatók Előadó Gyakorlatvezető Gnoti se auton

23 A Debreceni Egyetem programozói évkönyve xxiii Az évfolyam legfontosabb hallgatói - tutor rendszer március 24-i hét április 7-i hét Az évfolyam legfontosabb hallgatói - feladatok megoldása Az évfolyam legfontosabb hallgatói - skillek V. Mellékletek 387 A. Mellékletek 388 A.1. A DocBook dokumentum kezelése A.1.1. Hogyan kezdjem el? A Parancssori gyorstalpaló A Fájlok módosítása A Fájlok hozzáadása A A dokumentum érvényességének ellenőrzése A A dokumentum olvashatóvá konvertálása A.1.2. Pánikgomb A.1.3. Pontozási politika A.2. Házi-versenyek A.2.1. Kolmogorovi bitfaragás A Szimmetrikusság vizsgálata A Bátfai Norbert A Nagy Sándor A Nagy Sándor A Mamenyák András A Bátfai Norbert A Mamenyák András A Nagy Sándor A Nagy Sándor A.2.2. Prog1 Robotfoci Labdarúgó Bajnokság (PLB) A Versenynaptár A A PLB lebonyolítása A.2.3. Prog1 Robotfoci Labdarúgó Kupa (PLK) A.2.4. Prog1 Robotfoci PLBPLK-Szuperkupa A.2.5. Prog1 Kvantumfoci Labdarúgó Bajnokság A.2.6. Prog1 Kvantumfoci Labdarúgó Kupa A.3. Céges feladatok A.3.1. A céges feladatok intézménye

24 A Debreceni Egyetem programozói évkönyve xxiv VI. Irodalomjegyzék Algoritmusok DocBook Programozás Tárgymutató 403

25 A Debreceni Egyetem programozói évkönyve xxv Ábrák jegyzéke 1.1. A kockásítás feladat bemenő képe A kockásítás feladat eredménye Az LZW szófa-építése a bemenetre A sejtautomata programunk egy Nexus 7-en és egy Nexus 4-en A feladat egy megoldása a Justine protóval, annak Justine Window tagjával Az A* algoritmus és a Dijkstra algoritmus eredménye ugyanarra az inputra Budapest és Debrecen között A projekt "Tetris-terve" A Mandelbrot halmaz feladat kimenete (kimenet.png) Mammals LZW szórás alapján Futtatás A sebességteszt eredménye A virtuális MINIX nevének megadás (vm1.png) Virtuális MINIX indítása (vm2.png) A rendszer betöltése lemezről (vm3.png) Genomok összehasonlítása Dinamikus tömb a tárban Pillanatkép a 10. előadásról Pillanatkép a 11. előadásról Pillanatkép a 12. előadásról soon

26 A Debreceni Egyetem programozói évkönyve xxvi

27 A Debreceni Egyetem programozói évkönyve xxvii

28 A Debreceni Egyetem programozói évkönyve xxviii Dr. Bátfai Norbert

29 A Debreceni Egyetem programozói évkönyve xxix Ajánlás Az évkönyvet azoknak a hallgatóknak ajánljuk, akik el tudják mondani, hogy utoljára milyen izgalmas programon dolgoztak.

30 A Debreceni Egyetem programozói évkönyve xxx Előszó Az évkönyv feladatai képezik a kurzus pontgyűjtésének alapját, s így végső soron a megajánlott jegy megszerzését. Ennek megfelelően az évkönyvben való szereplés nem kötelező, csak egy lehetőség a kurzus hallgatói számára. Magam az összes szereplő programot megírtam 1, ezek tipikusan elérhetőek kurzus blogjáról és részleteikben ki vannak dolgozva a kurzus környezetében, a Bátfai Norbert: Programozó Páternoszter [PP]. Bátfai Norbert, Juhász István: Javát tanítok, Bevezetés a programozásba a Turing gépektől a CORBA technológiáig hu/tartalom/tkt/javat-tanitok-javat, [JAVATTANITOK]. Bátfai Norbert: Mobil programozás, Nehogy már megint a mobilod nyomkodjon Téged! konyvek/mobp/mobp.book.xml.pdf, [MOBP]. Bátfai Norbert: Mesterséges intelligencia a gyakorlatban: bevezetés a robotfoci programozásba ~nbatfai/konyvek/mirc/mirc.book.xml.pdf, [MIRC]. Bátfai Norbert: Párhuzamos programozás GNU/Linux környezetben: SysV IPC, P-szálak, OpenMP ~nbatfai/konyvek/parp/parp.book.xml.pdf, [PARP]. Bátfai Norbert: Programozó Páternoszter újratöltve: C, C++, Java, Python és AspectJ esettanulmányok ~nbatfai/konyvek/prop/prop.book.xml.pdf [PROP]. Bátfai Norbert: Paternoster of Programmers Reloaded: C, C++, Java, Python and AspectJ Case Studies ~nbatfai/konyvek/popr/popr.book.xml.pdf, [POPR]. könyvek valamelyikében, sőt számos esetben találunk a kidolgozást élesben bemutató webcast-okat, rövid YouTube videókat is. Adott feladatnál mindig jelezzük, hogy pontosan hol. Tehát nem azt várjuk a hallgatóktól, hogy ezeket önállóan és from scratch kidolgozzák, hanem, hogy a labormérést elvégezzék ezekkel, azaz ismerjék meg ezeket! Ismerjenek meg minél több példát, legalábbis a szakma mérnöki részéből. A könyv szerkezete Az évkönyv négy nagyobb tartalmi részből épül fel. Az első a feladatokat kiíró rész, ezt követi a megoldásokat tartalmazó, majd a laborkártyákat bemutató rész. A főbb tartalmi elemek lezárásaként ezek után találjuk az évkönyv jellegű részt. A könyvet a használatot segítő melléklet, majd az irodalomjegyzék zárja. Szakmai fórum A létrehoztunk egy szakmai fórumot, konkrétan a The Yearbook of the Programmers of University of Debrecen csoportot, amellyel a blog oktatás-szervező és támogató funkcióját szeretnénk egy magasabb szinten megvalósítani, nem beszélve arról, hogy ezt a fórumot könnyen figyelemmel tudják követni az ipar esetleges felénk érdeklődő tagjai. 1 Előfordulhat, hogy adott feladat kidolgozása nagyobb erőfeszítést kíván a hallgatótól, ilyen esetre jó példa mondjuk a saját Linux rendszerhívás megírása, mert a Linux kernel egy gyorsan változó szoftver, s az általam mutatott megoldásban szereplő fájlok már sokat változtak, tehát az én megoldásom másolása ebben a feladatban önmagában biztosan kevés lesz.

31 A Debreceni Egyetem programozói évkönyve 1 / 404 A 2013/14 tanév tavaszi és a 2014/15 tanév őszi szemesztere

32 A Debreceni Egyetem programozói évkönyve 2 / 404 I. rész Feladatok

33 A Debreceni Egyetem programozói évkönyve 3 / 404 Ebben a részben az előadó és a laborvezetők az aktuális félév kidolgozható feladatait mutatják be. A feladatok tényleges kidolgozása a megoldások részben következik. Ám ezt a munkát minden félévben az érdeklődő hallgatók végzik. Ehhez természetesen kapnak egy forgatókönyvet, sőt a legtöbb esetben kész forrásokat vagy akár teljes kidolgozást is. Mégis a hallgatóé a döntés, hogy ezt tisztán reprodukálva tanul, vagy akár hozzáad ezekhez, illetve eltér ezektől. Ciki A félév elején és a félév végén az évkönyv hallgatóit kérjük, hogy önbevallás alapján, a jelen könyv évkönyv részében formálisan is sorolják be magukat a kezdő, közepes, haladó és kiemelkedő kategóriák egyikébe a vélt vagy valós programozási tudásuk alapján. A feladatokat is ezen kategóriák alapján írjuk ki. Fontos, hogy alsóbb kategóriába feladatot küldeni nem csak ciki, hanem tiltjuk is. Ezzel az a kurzus vezetésének a célja, hogy megakadályozzuk, hogy a jobbak a kisebb ellenállás irányába nyomulva learassák a könnyebb feladatokat, lásd még a témában a /12/20/magas_szintu_programozasi_nyelvek_1_indk301 poszt kommentjeit. Természetesen a magát alacsonyabb szintre önbevalló hallgató megoldhat, kidolgozhat magasabb szintre megadott feladatokat. Ám a pontok elkönyvelésénél a hegylakó elv érvényesül, miszerint csak az első számolhatja el, azaz aki kidolgozza és ezt a kidolgozást bemutatja ebben a könyvben.

34 A Debreceni Egyetem programozói évkönyve 4 / fejezet A kezdő szint programjai A következő feladatok a kurzus kezdő szintjére vannak kiírva, egészen pontosan az önmagukat kezdőnek önbevalló hallgatók számára vagy a magukat magasabb szintre önbevalló tutorok és az önmagukat kezdőnek önbevalló tutoriált hallgatók részére. Utóbbi esetben a tutor a feladat pontértékének 1.4-szeresét, a tutoriált pedig 1.2-szeresét számolhatja el magának. A tutor-tutoriált hozzárendelés egy adott feladat kapcsán egy 1:N jellegű kapcsolat, azaz egy tutornak lehet több tutoriáltja, de egy tutoriáltnak nem lehet több tutora. Különböző feladatokban lehet különböző a tutor, de ezeknek a kapcsolatoknak ki kell derülniük az évkönyv részben Az első C programok A feladatok kidolgozását megtalálod a [PP] jegyzetben, ezekre alapozd a saját megoldásaidat! Bajnokság van és minden hallgató nevezett. Feladatonként az elsőnek van lehetősége az évkönyv megoldásokat tartalmazó részébe kidolgozni és bemutatni a saját megoldását. A hosszabb forráskódok esetén a megoldásba ne vegyük fel a teljes forrást, csak az érdemi csipeteket és linkeljük relatívan a teljes forrást a source könyvtárból. Ha az adott feladat kidolgozása tutor-tutoriált modellben valósul meg, akkor a kidolgozást a tutoriált végzi a tutor támogatásával Végtelen ciklus Ki írja a legszebb végtelen ciklust? Ha megvan a ciklus, két változatot készíts belőle! Az egyik közel 100 százalékban terheljen egy magot, a másik éppen ellenkezőleg, közel 0 százalékosan terhelést jelentsen csupán a rendszerben! (5 pont.) A megoldásban szerepeljen a man 3 sleep kézikönyvlapon leírt könyvtári függvény! A feladat kidolgozását a [PP] jegyzet alapján Bátfai Norbert (oktatói szintű önbesorolás) készítette. Átnézte, ellenőrizte: itt jönnek 1 pontért azok a hallgatók, akik jónak tartják a megoldást, vagy annak adott módosítását lásd még a feladatok pontozási politikáját a mellékletben! Az évkönyv feladatkiíró részében ilyen megjegyzésekben jelezzük, hogy ki volt a feladat kidolgozója. Illetve egyfajta index-jelleggel itt jelezhetjük azokat a módosításokat, javításokat, amelyeket mások vagy akár a megoldó eszközöl a megoldás részben (csak röviden, hiszen a git komment legyen majd bő, mert abból készítünk majd ChangeLog-ot) Két változó értékének cseréje Írj programot, amely megcseréli két változója értékét, de ne használj segédváltozót és semmi feltételes (sem if utasítást, sem feltételes kifejezést, sem...) konstrukciót! (3 pont.) Íme egy megoldás:

35 A Debreceni Egyetem programozói évkönyve 5 / 404 A feladat kidolgozását Kistamás Dávid készítette. A megoldás splinttel ellenőrizve, nincs hiba. (Busák Zoltán ) A megoldás átnézve, ellenőrizve. (Nad Sabolch) Alternatív megoldásként bitenkénti XOR közvetlen értékadással (Besenczi Renátó demo célokra) Alternatív megoldás swap beépített függvény használatával feltöltve. (Készítette Pop Richárd László, Tutor volt Bereczki László.) Kód:../source/kezdo/elsocpp/valtozocsere/swap.cpp Megoldás swap függvényel C-ben. (Akai József Zsolt) Kód:../source/kezdo/elsoc/valtozocsere/ swapp.c Pattogó labda Írj programot, amely egy labdát pattogtat vissza TV játék szerűen! (15 pont.) Íme a feladat kiírása és egy megoldás: bár a megjelenítés itt nem téma, csak a koordináták. Az enyémtől teljesen eltérő további megoldások +20 pontot érnek! (Eddig két ilyen volt az előző kurzusok során.) Megoldások és megjegyzések Egy eltérő megoldás elkészítve, ami nem abszolút értékkel számolja a koordinátákat. Forrás: source/kezdo/elsoc/labda/pattog.c (Ács Raymund és Gálffy Tamás) Egy eltérő megoldás feltöltve, C++ programozási nyelven (Linux környezetre). Készítette: Szentpéteri Annamária. Tutor: Bereczki László. Forrás:../source/kezdo/elsocpp/patt_labda/patt_labda.c++ Módosítás: "unistd.h" állomány csatolása és a for ciklus iterátorait kicseréltem egy iterátorra, ezzel optimizálva a ciklusokat. (Kohlberger Péter) Szentpéteri Annamária megoldását jónak találom, egyetlen hiányosság, hogy nincs includolva az unistd.h header fájl, hiszen a program használja az usleep könyvtári függvényt. (Sipos Ferenc) RE: Hiányosság Az unistd.h header-t okkal hagytuk ki a kódból. Bár a manual azt jelöli meg a usleep headerjeként, az iostream linkelése után a fordító (g++ 4.6, Ubuntu 12.04) felismerte. Miután több gépen is ezt tapasztaltuk, feleslegesnek ítéltük. (Bereczki László) A feladatot leellenőriztem splinttel, pattog.c nevű kódot. (Józan csaba) Helló, Világ a sztenderd hibára Írj egy klasszikus Helló, Világ programot, amely a sztenderd hibakimenetre is üzen! (5 pont, további 5, ha Javában is elkészíted.) Lásd a [PP] jegyzet ugyanezen bevezető példáját! A feladat kidolgozását C -ben és Javában a [PP] jegyzet alapján Akai József Zsolt készítette. (Busák Zoltán Tutor segítségével) A megoldást ellenőriztem splinttel, nem talált hibát. (Busák Zoltán) A megoldás átnézve, ellenőrizve. (Nad Sabolch) Leírást készítettem a splint eredményéről a feladat kidolgozásánál. (Kis Dávid) Átlag Írj egy programot, amely a sztenderd inputjától olvas be számokat, majd a bemenet vége, azaz a Ctrl+d jel után kiírja a beolvasott számok átlagát! (3 pont.) Lásd a [PP] jegyzet ugyanezen bevezető példáját!

36 A Debreceni Egyetem programozói évkönyve 6 / 404 A feladat kidolgozását a [PP] jegyzet alapján Kistamás Dávid készítette. A megoldást splinttel leellenőriztem. (Busák Zoltán) A megoldás átnézve, ellenőrizve. (Nad Sabolch) Javítottam, hogy a program azt az esetet is le tudja kezelni, ha nem számot adunk meg. (Sipos Ferenc) A nem számok megadására nem kell szerintem felkészíteni a programot, mivel bemenet vége jelzi, amit fájloknál használunk. Írtam az első verzióhoz hasonló while-t (Ács Raymund) Véletlen számok Írj egy programot, amely parancssor argumentumaként kapott szám számú véletlen számot generál a [0, 10) intervallumból! (6 pont.) Mit tapasztalunk a generált számok tekintetében, ha kétszer futtatjuk a programot egymás után? Mikor hasznos ez, illetve hogyan küszöbölhető ki? A megoldásban szerepeljenek a man 3 rand kézikönyvlapon leírt könyvtári függvények! Kapcsold össze egy csővezetékkel ezt és az előző átlagszámító programot! A feladat kidolgozását a [PP] jegyzet alapján Sipos Ferenc készítette. A megoldást átnéztem, ellenőriztem. (Nad Sabolch) Splint-tel ellenőriztem a kódot. Az ellenőrzés menetét, és eredményét a feladat kidolgozásában kifejtettem. (Kis Dávid) A szóhossz a gépeden Írj egy programot, amely megmondja az őt futtató gép szóhosszát, azaz az int méretét bitekben! (6 pont.) Készíts több változatot, az egyikben csak bitműveleteket használj, a másikban akár a sizeof operátort, lásd a [PP] jegyzet ugyanezen bevezető példáját is! A feladat kidolgozását a Programozó Páternoszter alapján készítettem, a feladatban kiírt 2 különböző módszerrel. (Kis Dávid) Forrás:../source/kezdo/elsoc/szohossz/szohossz.c és../source/kezdo/ elsoc/szohossz/szohossz_sizeof.c A kódokat splint-tel ellenőriztem. Az ellenőrzés menetét, és az eredményt a feladat kidolgozásánál kifejtettem. (Kis Dávid) A megoldást átnéztem, ellenőriztem. (Nad Sabolch) BogoMIPS Fejleszd tovább az iménti progit egy egyszerű BogoMIPS programmá! (15 pont.) Tanulmányozd a működés megértéséhez a [PP] 277. oldalának grafikáját is! Illetve egy kidolgozott példát ebben a preziben találsz: megjegyzés A megoldást az előadás jegyzete alapján készítette: Szentpéteri Annamária. Dátum: A megoldást a../source/kezdo/elsoc/bogomips/bogomips.c nevű fájlban helyeztem el.

37 A Debreceni Egyetem programozói évkönyve 7 / Környezeti változók Írj olyan programot, ami kiírja a környezeti változóit, de ne használd a getenv függvényt! (3 pont.) Lásd a [PP] 272. oldalának példáját! A feladat kidolgozását Kistamás Dávid készítette Fülöp Sándor tutoriálásával. A megoldást splinttel ellenőriztem. (Busák Zoltán) 1.3. A lexikális elemzéssel kapcsolatos első programjaid A következő feladatok kizárják egymást! Nem fogadható el olyan megoldás, amely maga olvassa betűnként a bemenetet, hiszen éppen az a feladat lényege, hogy lexert használjunk, azaz óriások vállán álljunk és ne kispályázzunk! Betűk számolása Írj olyan programot, ami számolja a bemenetén a betűket, használd a lex-et! (11 pont.) Indulj ki az első előadás megfelelő fóliájából! A feladat megoldását Akai József Zsolt készítette (Busák Zoltán Tutor segítségével) Számok számolása Írj olyan programot, ami számolja a bemenetén a számokat (nem a számjegyeket), használd a lex-et! (11 pont.) Indulj ki az első előadás megfelelő fóliájából! A feladat kidolgozását az első előadás alapján készítettem. szamokszama/szamokszama.l (Kis Dávid) Forrás:../source/kezdo/elsoc/ Szavak számolása Írj olyan programot, ami számolja a bemenetén a szavakat, használd a lex-et! (11 pont.) Indulj ki az első előadás megfelelő fóliájából! A feladat kidolgozását a előadás alapján készítettem. (Orbán István)

38 A Debreceni Egyetem programozói évkönyve 8 / Sorok számolása Írj olyan programot, ami számolja a bemenetén a sorokat, használd a lex-et! (11 pont.) Indulj ki az első előadás megfelelő fóliájából! A feladat kidolgozását az első előadás alapján készítettem. (Józan Csaba) 1.4. Rendszerprogramozással kapcsolatos első programjaid A következő példák részletes kidolgozását, szinte ugyanebben a sorrendben megtalálod a [PP] jegyzetben Villa Írj egy programot, amely létrehoz egy gyerekfolyamatot, amely árvaként hal meg! (10 pont.) A feladat kidolgozását a [KR] könyv segítségével készítettem. (Józan Csaba) A feladat kidolgozásánál leírást készítettem. (Kis Dávid) Zombi Írj egy programot, amely létrehoz egy gyerekfolyamatot, amely zombi lesz! (10 pont.) A feladat kidolgozását a [PP] (Programozó Páternoszter) segítségével készítettem. (Závaczki Roland) A feladat kidolgozásánál leírást készítettem. (Kis Dávid) A kódot splint-tel ellenőriztem. Az ellenőrzés menetét, és az eredményt a feladat kidolgozásánál kifejtettem. (Csopa Tamás) Riasztás Írj egy programot, amely létrehoz egy gyerekfolyamatot, majd 5 másodperc múlva kilövi! (15 pont.) A feladat kidolgozását a Programozó Páternoszter alapján készítettem. (Kis Dávid) Forrás:../source/kezdo/ elsoc/riasztas/risztas.c Javítottam a rossz megoldást.(kis Dávid) A forráskódot splint-tel ellenőriztem. Az ellenőrzés menete és eredménye a feladat kidolgozásánál található! (Kis Dávid)

39 A Debreceni Egyetem programozói évkönyve 9 / Utolsó tennivaló Írj egy programot, amely a Ctrl+c-vel való kilövése előtt még végrehajt valamit! (5 pont.) A feladat megoldását a [KR] könyv függelékje alapján készítettem el (Sipos Ferenc) Nem lokális ugrások Írj egy programot, amely végtelen ciklusban másolja a sztenderd bemenetét a kimenetére, de egy billentyűzetről jövő Ctrl+c hatására visszaugrik a végrehajtás ez elé a ciklus elé! (15 pont.) A megoldást készítette: Ács Raymund, Tutor: Gálffy Tamás Egy másik megoldást készítettem a setjmp.h könyvtár segítségével. (Bertalan Ádám) A forráskódot splint-tel ellenőriztem. Az ellenőrzés menete és eredménye a feladat kidolgozásánál található! (Bak Balázs) 1.5. Az első algoritmizálási programjaid Mandelbrot halmaz Írj egy programot, amely kiszámolja a Mandelbrot halmazt, s az eredményt a png++ csomag használatával egy PNG képre rajzolja! (10 pont.) Kiindulhatsz ebből a megvalósításból: A feladat kidolgozását a [JAVATTANITOK] alapján készítettem. (Szabó Attila, Tuza József tutoriálásával.) Mivel a program fordítása / futtatása nem triviális, így feltöltöttem egy Makefilet. Futtatás: make. Ezután a kész.png megjelenik a mappában, és az átmeneti állományok törlődnek. Illetve ha a png++ headert nem találja a fordító, akkor ez megoldja: sudo apt-get install libpng++-dev - Bereczki László Elfolyik a PageRank Mi történik a 2. labor PageRank programjában, ha egy lapnak nincs kimenő linkje? (A program felhasználásával válaszoljunk!) Töröljük például a JP-re M-ből mutató linket! (5 pont) Lásd még a feladat kapcsán a és a adorepump/ranking-web-pages-presentation linkeket. Megoldások és megjegyzések A feladatot megoldotta: Szentpéteri Annamária. Tutor: Bereczki László. ( ) Megoldás: /source/kezdo/- elsoc/pagerank/pagerank_ c A kódot splint-tel ellenőriztem. Az ellenőrzés menetét, és az eredményt a feladat kidolgozásánál kifejtettem. (Csopa Tamás)

40 A Debreceni Egyetem programozói évkönyve 10 / Ellopni a PageRank értéket Mi történik a 2. labor PageRank ha egy lap csak magára mutat? (A program felhasználásával válaszoljunk!) A JP-re M-ből mutató linket módosítsuk M-ből M-be mutatóval! (5 pont) Lásd még a feladat kapcsán a és a adorepump/ranking-web-pages-presentation linkeket. Megoldások és megjegyzések A feladatot megoldotta: Szentpéteri Annamária. Tutor: Bereczki László. ( ) Megoldás: /source/kezdo/- elsoc/pagerank/pagerank_ c A kódot splint-tel ellenőriztem. Az ellenőrzés menetét, és az eredményt a feladat kidolgozásánál kifejtettem. (Csopa Tamás) Alternatív tabella Készíts programot, amely a 2. labor PageRank programját felhasználva elkészíti a magyar bajnokság alternatív tabelláját! (15 pont) Segít ez a poszt: De természetesen C++-ban dolgozz, ne Java-ban. További 5 pontot számolhatsz el (a feladat kidolgozója) a szorgalmi időszakban a fenti Wikipedia szócikk aktuális állapotának heti frissítéseiért. További PR alapú feladatok Számos hasonló feladatot találsz a saját közösségünk vizsgálatára az évkönyv évkönyv részében! Megoldások és megjegyzések A feladatot megoldotta: Szentpéteri Annamária. Tutor: Bereczki László. ( ) Megoldás: /source/kezdo/- elsocpp/alt_tab/pr.cpp 1.6. Az első párhuzamos programjaid Elromlik a változó Írj programot, amelyben 50 P-szál növel, 50 P-szál csökkent egy globális számlálót, majd mutasd meg, hogy a mutexel védett számláló nem romlik el, a nem védett viszont igen! (15 pont.) Indulj ki a [PP] jegyzet 66 oldalától a két szóban forgó példa kidolgozásából! A feladat kidolgozását a Programozó Páternoszter [PP] alapján készítettem.(kis Dávid) Forrás: kezdo/elsoc/elromlik_a_valtozo/zar_nelkul.c A mindkét forrást splint-el ellenőriztem!(kis Dávid)../source/

41 A Debreceni Egyetem programozói évkönyve 11 / Az első GNU/Linux kernellel kapcsolatos programjaid Helló, Világ! a kernelből Módosítsd a kernelt, hogy bootoláskor írjon ki egy Helló, Világ! üzenetet! (15 pont.) Lásd még a kernelfordításról szóló feladatot is, ám ezek egymást kizárják. A feladat kidolgozását a [PP] alapján készítettem. (Gyügyei Tamás) A PCB mérete Írasd ki a kernelből! (15 pont.) Az előző feladatot módosítsd, ezek egymást kizárják. A PCB-t az operációs rendszerek tárgyból ismerheted, ez a Process Control Block. A feladat kidolgozását a [PROP] könyv alapján készítettem. (Tamics Ádám,Tóth Máté tutoriálásával.) Megj:PCB méretét kiírja a terminal, bootolás után A PCB mérete modulból Írasd ki a egy kernel modulból! (15 pont.) 1.8. Az első MINIX kernellel kapcsolatos programjaid A következő feladatok a bemutatás és elszámolás tekintetében kizárják egymást Helló, Világ! a kernelből Módosítsd a kernelt, hogy bootoláskor írjon ki egy Helló, Világ! üzenetet! (10 pont.) Követheted a részletes kidolgozást a [PROP] könyv példájában, a megoldások alatti bemutatásnál viszont kerüld kérlek a kép alapú-pillanatképek használatát! A feladat kidolgozását a [PROP] könyv alapján készítettem. (Kis Dávid)

42 A Debreceni Egyetem programozói évkönyve 12 / A PCB mérete Írasd ki a kernelből! (10 pont.) Követheted a részletes kidolgozást a [PROP] könyv példájában, a megoldások alatti bemutatásnál viszont kerüld kérlek a kép alapú-pillanatképek használatát! A feladat kidolgozását a [PROP] könyv alapján készítettem. (Gyügyei Tamás) A processztábla méretének módosítása Növeld meg a processztábla méretét, legyen 150 processzes! (10 pont.) Követheted a részletes kidolgozást a prezentációban, a megoldások alatti bemutatásnál viszont kerüld kérlek a kép alapú-pillanatképek használatát! A feladat kidolgozását a [PP] alapján készítettem. (Gyügyei Tamás) Ütemezési sorok Növeld meg 16-ról 32-re az ütemezési sorok számát! (10 pont.) Követheted a részletes kidolgozást a prezentációban, a megoldások alatti bemutatásnál viszont kerüld kérlek a kép alapú-pillanatképek használatát! A feladat kidolgozását a [PP] alapján készítettem. (Gyügyei Tamás) 1.9. Az első C++ programok Módosított polártranszformációs véletlen szám generátor, ez legyen az első C++ progid! Írj egy olyan randomszám generátor osztályt, amely a módosított polártranszformációs algoritmust használja! A matametikai algoritmust nem kell ismerned, az megadott csak be kell zárnod egy osztályba! (20 pont.) A matematikai algoritmus alaptulajdonsága, hogy egyszeri lefuttatása 2 randomot ad, ezért kell egy lebegőpontos példánytag tárolni az egyiket és egy logikai példánytag, amely megmondja, hogy e futtatni az algoritmust, vagy visszaadható a korábbi hívás másik randomja? Indulj ki ebből a forrásból: masodikc++/src/. Megoldások és megjegyzések Megoldás feltöltve, C++ programozási nyelven (Linux környezetre). Készítette: Szentpéteri Annamária. Tutor: Bereczki László. Forrás:../source/kezdo/elsocpp/random/random.cpp

43 A Debreceni Egyetem programozói évkönyve 13 / Csere mutatók nélkül Írj olyan programot, amely tartalmaz egy olyan függvényt, amely felcseréli hívója két egész változójának értékét, de nincs a forrásszövegben csillag! (4 pont.) Lásd az alábbi előadás egyik fóliájának megoldását: A feladat kidolgozását az előadás fóliák alapján Kökéndy Tímea készítette Komplex osztályos Mandelbrot A jelen szint algoritmizálási részének feladatát írd át, hogy ne kezeld külön az algoritmus komplex számainak valós és képzetes részét, hanem használd a complex osztályt! (10 pont.) Lásd még az alábbi lapon található megoldás csipetet: Megoldások és megjegyzések A feladat módosítását Szabó Attila és Tuza József megoldása alapján Dalmadi Zoltán készítette Az első nyelvi programjaid Másoló és mozgató konstruktor és értékadás Mély és sekély másolás A következő feladatok kizárják egymást! Másolt vektor Írj olyan (rövid, pár soros) programot, amivel demonstrálni tudod, hogy mély vagy sekély másolás történik-e, ha érték szerint adod át az (std::vector) dinamikus tömböt! (5 pont.) Segít a 6-7 előadás. A feladatot elkészítettem, megoldás és forrás fájl hamarosan feltöltésre kerül (Takács Miklós) Másolt verem Írj olyan programot, amivel demonstrálni tudod, hogy mély vagy sekély másolás történik-e, ha érték szerint adod át az (std::stack) vermet! (5 pont.) Segít a 6 előadás.

44 A Debreceni Egyetem programozói évkönyve 14 / 404 A feladat megoldását Kistamás Dávid készítette, Fülöp Sándor tutoriálásával Másolt lista Írj olyan programot, amivel demonstrálni tudod, hogy mély vagy sekély másolás történik-e, ha érték szerint adod át az (std::list) láncolt listát! (5 pont.) Segít a 6-7 előadás. A feladat megoldását Akai József Zsolt készítette (Busák Zoltán Tutor segítségével) Másolt map Írj olyan programot, amivel demonstrálni tudod, hogy mély vagy sekély másolás történik-e, ha érték szerint adod át az (std::map) asszociatív tömböt! (5 pont.) Segít a 6-7 előadás. A feladat megoldását Ozsváth Jonathán készítette (Busák Zoltán Tutor segítségével) Másolt map Írj olyan programot, amivel demonstrálni tudod, hogy mély vagy sekély másolás történik-e, ha érték szerint adod át az (std::set) halmazt! (5 pont.) Segít a 6-7 előadás. A feladat megoldását Závaczki Roland készítette Az első Qt programjaid A következő programoknál az alapfeladat bemutatása nem téma, csak a módosításra kell koncentrálni a kidolgozás bemutatása során.

45 A Debreceni Egyetem programozói évkönyve 15 / A Mandelbrot RGB színezése Módosítsd úgy a közepes szintre kiírt alapfeladatot, hogy csak kék árnyalatokkal rajzoljon! (3 pont.) A feladatot Tuza József készítette el Akai József Zsolt és Busák Zoltán megoldása alapján Szavazás feladat: Mandelbrot szépségverseny A számítás adatai a képre Módosíts úgy a Mandelbrot nagyító és mentő programot, hogy a kép adatait is mentse a képre, pl. az aljára írja rá az a, b, c, d értékeket, az iterációs határt és a komplex számos algoritmust (8 pont) Szavazás feladat: biomorf szépségverseny A számítás adatai a képre Módosíts úgy a Biomorf nagyító és mentő programot, hogy a kép adatait is mentse a képre, pl. az aljára írja rá az a, b, c, d értékeket, az iterációs határt és a komplex számos algoritmust (8 pont, a hasonló Mandelbrotossal kölcsönösen egymást kizárók) A genetikai kód-szőnyeg parancssori bemenete Módosítsd úgy a közepes szintre kiírt alapfeladatot, hogy parancssor-argumentumként kapja a genetikai kódot tartalmazó állomány nevét! (5 pont.) Lásd még (az igaz csak lazán) kapcsolódó A feladat megoldását Szabó Bence készítette Akai József Zsolt megoldása alapján.../source/kezdo/elsoqt/ genetikai_bemenet/main.cpp További élőlények a sejttérben Módosítsd úgy a közepes szintre kiírt alapfeladatot, melyben további élőlényeket (például lightweight spaceship) próbálsz ki a sejttérben! (15 pont.)

46 A Debreceni Egyetem programozói évkönyve 16 / Az első képfeldolgozással kapcsolatos programjaid Az első png++ és pngwriter könyvtárakkal kapcsolatos programjaid Kockásítás a png++ könyvtárral A kis (kocka_meret) blokkokban kiszámoljuk az pixelek RGB kódjainak átlagát és az így kapott átlagos RGB értékkel színezzük (az alább specifikált kocka függvénnyel) az egész blokkot! (10 pont.) 1.1. ábra. A kockásítás feladat bemenő képe ábra. A kockásítás feladat eredménye. Ez és a következő feladat kizárja egymást! Forráskóddal is segít a poszt. Megoldás és megjegyzés A feladatot elkészítette: Dalmadi Zoltán

47 A Debreceni Egyetem programozói évkönyve 17 / Kockásítás a pngwriter könyvtárral Végezd el az iménti feladatot, de most a másik png kezelő könyvtár felhasználásával! (10 pont.) Ez és az előző feladat kizárja egymást! Forráskóddal is segít a poszt. Megoldás és megjegyzés A feladatot elkészítette: Csopa Tamás (átdolgoztam Dalmadi Zoltán előző feladatát pngwriterrel) Az első Open CV-vel kapcsolatos programjaid Az első STL-el és Boost-al kapcsolatos programjaid Poszt feladat: lambda Válassz ki a../source/binom/batfai-barki/lambda/ s1.cpp-s9.cpp fájlok közül hármat és hasonlítsd össze őket egy mesélős posztban a linkedin-en. (A forrásokat ne tedd be, csak jelezd, hogy melyikről van szó; én megpróbáltam, nem jött be: Folyosói beszélgetések: mire jó a lambda? Folyosói beszélgetések: mire jó a lambda? - folytatás Az első 10 hallgató számolhat el 15 pontot, aki felteszi a posztot, majd április 20-án megnézzük, hogy melyik szakmai poszt kapta a legtöbb lájkot, s a győztes további 15 pontot számolhat el Az első Java programok Módosított polártranszformációs véletlen szám generátor, ez legyen az első Java progid! Ugyanaz, mint az előző, de most Java-ban dolgozz! (15 pont) A megoldásul készített osztályod forrását vesd össze az Oracle (Sun és OpenJDK is) fejlesztői által készített java.util. Random osztály forrásával! Ha nem tudod, hogy ezeket hol nézheted meg, kérdezz egy kommentben a blogon! Illetve lásd például ezekben a csomagokban az src.zip kicsomagolása után: Java SE Development Kit OpenJDK A feladat megoldását Akai József Zsolt készítette (Busák Zoltán Tutor segítségével)

48 A Debreceni Egyetem programozói évkönyve 18 / fejezet A közepes szint programjai A következő feladatok a kurzus közepes szintjére vannak kiírva, egészen pontosan az önmagukat közepesnek (vagy kezdőnek) önbevalló hallgatók számára vagy a magukat magasabb szintre önbevalló tutorok és az önmagukat közepesnek (vagy kezdőnek) önbevalló tutoriált hallgatók részére. Utóbbi esetben a tutor a feladat pontértékének 1.6-szeresét, a tutoriált pedig 1.4-szeresét számolhatja el magának A kezdő szintű feladatokra épített példák Normálisok A kezdő szintű normális-generátorral készíts normálist, s az ugyancsak kezdő szintű átlag-számolóval nézd meg, mennyi az átlaguk! (10 pont.) Ha az eredmény nem zérus közeli, akkor nem vagy nyomon. A feladat kidolgozását a [PP] jegyzet alapján Veress Balázs készítette. Mivel Veress Balázs megoldása nem zérus közeli értéket generált, így feltöltöttem egy saját verziót. A programot c++ nyelven írtam, és mivel használ c++11 featuret, így fordítani a -std=c++11 kapcsolóval kell. Bereczki László. Kód:../source/kozepes/kezdore_epulo/normalisok/normalisok2.cpp Kód clean - Bereczki László Valóban nem volt jó a megoldás saját megoldásomat javítottam(veress Balázs) :../source/kozepes/ kezdore_epulo/normalisok/normalisok.c Normális-harang Az előző program normálisainak hisztogramját készítsd el! (15 pont.) Az eredményt karakteres felületen lássuk! Ha a kiírt számok nagysága nem a harang-görbére emlékeztet, akkor nem vagy nyomon. A feladat kidolgozását a [PP] jegyzet alapján Veress Balázs készítette. A kódot splint-tel ellenőriztem. Az ellenőrzés menetét, és az eredményt a feladat kidolgozásánál kifejtettem. (Csopa Tamás)

49 A Debreceni Egyetem programozói évkönyve 19 / Normális-harang grafikusan Írj Qt-s programot: az előző hisztogramot rajzold ki! (25 pont.) Ha az eredmény nem a harang-görbe, akkor nem vagy nyomon. A feladat kidolgozását az előző programok alapján készítettük. (Szabó Attila tutor, Haraszti Péter Brúnó tutorált.) Mérkőzés eredmények Írj programot, amely a bemenetéről kibányássza a hazai csapatnév -vendég csapatnév végeredmény (féli dei eredmény) részeket! (30 pont.) Teszteld úgy, hogy néhány labdarúgással kapcsolatos lapot lementesz és ráengeded a program bemenetére! A feladat kidolgozását Gálffy Tamás készítette Pattogó labda Fejleszd tovább az előző szint kapcsolódó feladatát, hogy a curses könyvtárral mutassa is a labda mozgását! (10 pont.) Íme egy megoldás: megjegyzés A megoldást készítette: Szentpéteri Annamária. Tutor: Bereczki László. A forrásfájl a../source/kozepes/patt_labda/- patt_labda_curses.c++ fájlban található Rendszerprogramozással kapcsolatos programjaid Glibc függvény felüldefiniálása Írd fölül a glibc printf függvényét, hogy sárga háttéren, pirossal írjon a terminál ablakokba! (15 pont.) Dolgozz a 3. előadás megfelelő fóliái alapján! A feladat kidolgozását a 3. előadás megfelelő fóliái alapján készítettem.(nad Sabolch) A kódot splint-tel ellenőriztem. Az ellenőrzés menetét, és az eredményt a feladat kidolgozásánál kifejtettem. (Csopa Tamás)

50 A Debreceni Egyetem programozói évkönyve 20 / Rendszerstatisztika Írj egy egyszerűsített, saját top parancsot! (15 pont.) Készítette: Szimeonov Nikolett (A feladat elkészítésében segítségemre volt a [PP].) A kódot splint-tel ellenőriztem. Az ellenőrzés menetét, és az eredményt a feladat kidolgozásánál kifejtettem. (Csopa Tamás) Ez Linux alatt egy egyszerű állománykezelési (szimpla olvasása egy fájlnak) feladat, hiszen a futó kernelt a /proc virtuális fájlrendszeren keresztül lehet monitorozni. Kiindulhatsz a [PP] 89. oldalának megoldásából, ahol még egy kis magyarázó ábrát is találsz Képfeldolgozó programjaid A következő párhuzamosítási feladatok kizárják egymást! P-szálas kockásítás a png++ könyvtárral Fejleszd tovább az előző szint kapcsolódó programját, hogy párhuzamosan dolgozzon P-szálakkal! (15 pont.) A feladatot Kakócz Erik készítette, Dalmádi Zoltán kódját alapul véve. Kód:../source/kozepes/ Pthreadkockasit/kockasitas_pthread.cpp Open MP-s kockásítás a png++ könyvtárral Fejleszd tovább az előző szint kapcsolódó programját, hogy párhuzamosan dolgozzon Open MP-vel! (15 pont.) A feladatot Tóth Máté készítette. Kód:../source/kozepes/openmpkockasit/kockapng.cpp Készítette:Csermely Attila Tutor:Takács János Az előző verzióhoz képest gyorsabb és a színeket is helyesen számolja Kód:../source/kozepes/openmpkockasit/kockasitas_OpenMP.cpp P-szálas kockásítás a pngwriter könyvtárral Fejleszd tovább az előző szint kapcsolódó programját, hogy párhuzamosan dolgozzon P-szálakkal! (15 pont.) A feladatot Csopa Tamás készítette, Dalmádi Zoltán és Kakócz Erik kódját alapul véve. Kód:../source/kozepes/ pthreadkockasitpngwriter/kockasitas_pngwriter_pthread.cpp Open MP-s kockásítás a pngwriter könyvtárral Fejleszd tovább az előző szint kapcsolódó programját, hogy párhuzamosan dolgozzon Open MP-vel! (15 pont.) 2.4. Az első Qt programjaid A feladatok iniciális forrásait megtalálod a lapon.

51 A Debreceni Egyetem programozói évkönyve 21 / Arecibói Üzenet Rajzold ki Qt-vel az Arecibói üzenetet! (5 pont.) Lásd még a korábbi posztot is: 03/05/figyelem_ez_nem_gyakorlat! A feladatot Akai József Zsolt készítette.(busák Zoltán Tutor segítségével)../source/kozepes/qt/areciboi_ uzenet/main.cpp Mandelbrot rajzoló Rajzold ki Qt-vel a Mandelbrot halmazt! (5 pont.) Lásd még a korábbi posztot is! A feladatot Akai József Zsolt készítette.(busák Zoltán Tutor segítségével)../source/kozepes/qt/ mandelbrot/main.cpp Mandelbrot nagyító Írj Qt-s programot, hogy a Mandelbrot halmaz egérrel kijelölt részét nagyítsa! (7 pont.) A feladatot Akai József Zsolt készítette.(busák Zoltán Tutor segítségével)../source/kozepes/qt/mandel_ nagyito/main.cpp Mandelbrot halmaz mentő Fejleszd tovább az előző kódot, hogy billentyű nyomására mentse is a képet! Lásd még a posztot is! Ez a feladat kizárja az első kettőt. A feladatot Deregi Diána készítette el.../source/kozepes/qt/mandel_mento/main.cpp A genetikai kód-szőnyeg Írj Qt-vel a Humán genomot vizualizáló programot! (5 pont.) Lásd még a korábbi posztot is! Az enyémtől eltérő megoldás nem esik a hegylakó-szabály hatálya alá, abből további 2 megoldás elszámolható (különböző hallgatóknak pontért). A feladatot Akai József Zsolt készítette.(busák Zoltán Tutor segítségével)../source/kozepes/qt/ genetikai/main.cpp

52 A Debreceni Egyetem programozói évkönyve 22 / A kód vizualizációjának mentése Módosítsd az iménti programot(okat), hogy billentyűkkel lehessen az adott pillanat képét fájlba lementeni! (5 pont.) A vizualizációt és ezt a mentést különböző hallgatóknak kell implementálniuk, de a tutor-rendszer természetesen támogatott. megjegyzés A megoldást elkészítette: Szentpéteri Annamária. Dátum: Forrás megtalálható: source/binom/d.diana- Sz.Annamaria/Frak2 mappában. (Konkrétan a frakablak.cpp sorában.) Sejtautomata szimulációk Írj Qt-vel a Conway-féle életjátékot szimuláló programot! (5 pont.) Lásd még a korábbi posztot is! A feladatot Akai József Zsolt készítette el.(busák Zoltán Tutor segítségével)../source/kozepes/qt/ sejtautomata/main.cpp Sejttér mérete Módosítsd az iménti programot, hogy billentyűkkel lehessen nagyítani, csökkenteni a sejtméretet, illetve a szimuláció sebességét! (5 pont.) A feladat az előzővel kizáró Sejttér mentése Módosítsd az iménti programot, hogy billentyűkkel lehessen az adott pillanat képét fájlba lementeni! (5 pont.) A feladat az előző kettővel kizáró Slot-signal A fenti 3 témában az általam adott kódok nem használják a slot-signal mechanizmust, hanem egy szimpla visszahívásos modellre építenek. Írd át ezeket slot-signalos-ra! (10 pont, természetesen programonként, de egy hallgató csak egyet írhat át.) 2.5. A GNU/Linux kernellel kapcsolatos programjaid A következő feladatok pontjainak elkönyvelése egymást kizárja, azaz egy hallgató csakis egy feladatot dolgozhat ki az évkönyvben (természetesen a tutor rendszer működhet, a szabályozás célja, hogy egy hallgató megoldja az összes, eléggé hasonló példát) Folyamatokat számláló modul Írj olyan kernelmodult, ami megmondja, hány folyamat van! (15 pont.) A feladatot Eszenyi Gábor készítette, Tóth Máté (tutor) segítségével. Kód:../source/kozepes/ folyamatszamlalo/folyszamlalo.c

53 A Debreceni Egyetem programozói évkönyve 23 / Folyamatokat kiíró modul Írj olyan kernelmodult, amely kiírja az összes folyamatot! (15 pont.) A feladatot Tóth Máté készítette. Kód:../source/kozepes/folyamatkiiro/folyamatki.c Fájlleíró modul Írj olyan kernelmodult, amely minden folyamatra megmondja, hogy melyik a következő szabad állományleíró! (15 pont.) A feladat kidolgozását Akai József Zsolt készítette.(busák Zoltán Tutor segítségével)../source/kozepes/ fajleiro/fajleiro.c 2.6. A MINIX kernellel kapcsolatos programjaid Nyomkövetés Módosítsd úgy a MINIX 3 kernelt, hogy az F1 lenyomására írja ki a processztáblából a nem üres slotokat név hány tikktakk van még hátra/időszelet tikk-takkban alakban! (20 pont.) Követheted a részletes kidolgozást a prezentációban, a megoldások alatti bemutatásnál viszont kerüld kérlek a kép alapú-pillanatképek használatát! Készítette:Csermely Attila Tutor:Takács János Minix3 kernel módosítás: az F1 lenyomására kilistázza a nem üres processeket Kód:../source/kozepes/minix3_feladatok/nyomkovetes/ Ütemezés Módosítsd úgy a MINIX 3 kernelt, hogy az F3 billentyű lenyomására listázza ki az ütemezési sorok futásra kész processzeinek nevét! (25 pont.) Lásd még a prezentációt Algoritmizálási programjaid BBP megvalósítás A [BBP] cikk algoritmusát valósítsd meg C-ben! (15 pont.) Ha megakadsz, íme az én megoldásomat a [PP] 228. oldalától találod.

54 A Debreceni Egyetem programozói évkönyve 24 / 404 A feladat megoldását Ozsváth Jonathán készítette (Busák Zoltán Tutor segítségével) A kódot splint-tel ellenőriztem. Az ellenőrzés menetét, és az eredményt a feladat kidolgozásánál kifejtettem. (Csopa Tamás) 2.8. Nyelvi programjaid A következő feladatok kizárják egymást! Saját int verem Készíts saját int verem osztályt, mély másolással másolódjon! (12 pont.) Segít a 6. előadás. A feladat megoldását készítette Kakócz Erik Saját int dinamikus tömb Készíts saját int dinamikus tömb osztályt, mély másolással másolódjon! (12 pont.) Segít a 6. előadás. A feladat megoldását készítette Balogh István Dávid, Dalmadi Zoltán tutor segítségével.

55 A Debreceni Egyetem programozói évkönyve 25 / fejezet A haladó szint programjai A következő feladatok a kurzus haladó (vagy közepes) szintjére vannak kiírva, egészen pontosan az önmagukat haladónak (vagy közepes szintre) önbevalló hallgatók számára vagy a magukat magasabb szintre önbevalló tutorok és az önmagukat haladónak önbevalló tutoriált hallgatók részére. Utóbbi esetben a tutor a feladat pontértékének 1.8-szorosát, a tutoriált pedig 1.6-szeresét számolhatja el magának. A tutor-tutoriált hozzárendelés egy adott feladat kapcsán egy 1:N jellegű kapcsolat, azaz egy tutornak lehet több tutoriáltja, de egy tutoriáltnak nem lehet több tutora. Különböző feladatokban lehet különböző a tutor, de ezeknek a kapcsolatoknak ki kell derülniük az évkönyv részben Párhuzamos programjaid A kurzusban ezek a példák lesznek az első Pthread, Open MP és Intel TBB programjaid. A feladatok iniciális forrásait megtalálod a lapon Mandelbrot több szálon P-szálakkal Fejleszd tovább a kezdő szint Mandelbrot halmaz számoló programját, hogy annyi szálon menjen a számítás, ahány mag van a gépben (a magok száma jöhet parancssori argumentumként). Használj P-szálakat! (15 pont.) Kiindulhatsz ebből a megvalósításból: A feladat kidolgozását Akai József Zsolt készítette. (Busák Zoltán Tutor segítségével) Kód :../source/halado/parhuzamositas/mandel.cpp Mandelbrot több szálon Open MP-vel Fejleszd tovább a kezdő szint Mandelbrot halmaz számoló programját, hogy annyi szálon menjen a számítás, ahány mag van a gépben (a magok száma jöhet parancssori argumentumként). Használj Open MP-t! (15 pont.) Kiindulhatsz ebből a megvalósításból: A feladat kidolgozását Akai József Zsolt készítette. (Busák Zoltán Tutor segítségével) Kód:../source/halado/parhuzamositas/openmpmandel.cpp

56 A Debreceni Egyetem programozói évkönyve 26 / Mandelbrot Intel TBB-vel Fejleszd tovább a kezdő szint Mandelbrot halmaz számoló programját, hogy annyi szálon menjen a számítás, ahány mag van a gépben (a magok száma jöhet parancssori argumentumként). Használj Intel TBB-t! (15 pont.) Kiindulhatsz ebből a megvalósításból: A feladat kidolgozását Ozsváth Jonathán készítette Busák Zoltán Tutor segítségével. parhuzamositas/mandeltbb.cpp../source/halado/ Exor-törés párhuzamosítása Párhuzamosítsd a laborfeladatok exor-törését! (20 pont.) Kiindulhatsz ebből a megvalósításból: A feladat kidolgozását Ozsváth Jonathán készítette Busák Zoltán Tutor segítségével.../source/halado/exor/ exor.c A kódot splinttel leellenőriztem. Az eredményt a feladat kidolgozásánál megadtam. (Csopa Tamás) 3.2. A GNU/Linux kernellel kapcsolatos programjaid A /proc virtuális fájlrendszer Készíts olyan kernelmodult, amely nyomkövető információkat jegyez be a rendszer állományairól a /proc virtuális fájlrendszer alá! (35 pont.) Kiindulhatsz ebből a megoldásból: A feladat kidolgozását Tóth Máté készítette, PROP alapján. A könyvben 3.5 kernelhez volt írva a modul de 3.10 óta változott a create_proc_entry -> proc_create-ra, ez a megoldás már 3.10-nél nagyobb verzió számmal rendelkező kernelhez lett elkészítve.../source/halado/perprocbejegy/proc.c Melyik az éppen futó processz? Készíts olyan kernelmodult, amely kiírja, hogy melyik az éppen futó processz! (25 pont.) Dolgozz a veremmutató alsó 13 bitjének alacsonyra állításával, kiindulhatsz ebből a megoldásból: ~nbatfai/konyvek/prop/prop.book.xml.html#id A feladat kidolgozását Tóth Máté készítette, PROP alapján kernelen tesztelve.../source/halado/ kernel_current_proc/current.c

57 A Debreceni Egyetem programozói évkönyve 27 / A MINIX kernellel kapcsolatos programjaid A következő feladatoknál követheted a részletes kidolgozást a prezentációban, a megoldások alatti bemutatásnál viszont kerüld kérlek a kép alapú-pillanatképek használatát! Processzek üzenetmátrixa, PCB módosítással Módosítsd úgy a MINIX 3 kernelt, hogy egy mátrixban számolja, hogy a j. processz hány üzenetet küldött az i. processznek, s az F4 lenyomására írja ki ezt a mátrixot! (35 pont.) Ez a Tanenbaum könyv 168. oldali 38. feladata. A megoldásodban úgy módosítsd a PCB-t, hogy tartalmazzon egy vektort, amely megmondja, hogy a processz mennyi üzenetet küldött a többieknek. A feladat kidolgozását dr. Bátfai Norbert jegyzete alapján készítette Takác Ján Processzek üzenetmátrixa, saját rendszerhívással Az előző feladatot old meg, de most a kernelszinten egy külön mátrix legyen, amely megmondja, hogy a processzek mennyi üzenetet küldtek a többieknek! (40 pont.) A feladat kidolgozását dr. Bátfai Norbert jegyzete alapján készítette Takác Ján Rendszerprogramozással kapcsolatos programjaid Rendszerstatisztika folytatása Fejleszd tovább az előző szint feladatát, legyen karakteres felületű, de curses alapú! (35 pont.) Lásd például a [PP] 101. oldalán látható progit! A feladat kidolgozását Tamics Ádám, tutor Tóth Máté készítette. Megj:Éppen futó processzeket megjelenítő statisztikai adatok.../source/halado/top/top.cpp 3.5. Algoritmizálási programjaid Pi-számítása a kernel üzenetsoraival A korábbi szint kapcsolódó BBP feladatát most párhuzamos folyamatokkal valósítsd meg, az IPC mechanizmus legyen a kernel üzenetsora! (25 pont.) Ha megakadsz, íme az én megoldásomat a [PP] 231. oldalától találod.

58 A Debreceni Egyetem programozói évkönyve 28 / Képfeldolgozási programjaid Az első Open CV-vel kapcsolatos programjaid Labda követése írj programot házi videón a labda követésére! Ilyen videók lehetnek például ezek: KMziO2TBwls. A feladat kidolgozását Fábián Kristóf készítette, Kolozsvári Dávid segítségével. Videók: Kód :../source/halado/labda_kovetese_opencv/balltracking/main.cpp

59 A Debreceni Egyetem programozói évkönyve 29 / fejezet A kiemelkedő szint programjai A következő feladatok a kurzus kiemelkedő szintjére vannak kiírva CUDA programok A feladatok iniciális forrásait megtalálod a lapon Az EXOR-kódtörés CUDA párhuzamosítása Kiemelkedő implementáció A megelőző félévek munkái közül Mamenyák András munkáját emelhetjük ki, amelyet bátran tekinthetsz kiindulási alapnak is akár: QCSS programok A QCSS (Quantum Consciousness Soccer Simulator) egy IO multiplexelt, Boost alapú UDP/IP kliens-szerver modell alapú kognitív, multiágens alapú szimulációs környezet QCSS 2D megjelenítő 2D grafikus megjelenítő írása a Quantum Consciousness Soccer Simulator - kvantum-tudatos foci szimulátorhoz C++ nyelven, Qt-vel. (40 pont.) Kiindulási alap: Kiemelkedő implementáció A megelőző félévek munkái közül Kóti Balázs munkáját emelhetjük ki, amelyet bátran tekinthetsz kiindulási alapnak is akár: QCSS szurkolói ágens Saját Quantum Consciousness Soccer Simulator multiágens foci és szurkolói csapat készítése C++ nyelven. (100 pont.)

60 A Debreceni Egyetem programozói évkönyve 30 / RCSS programok Saját 2D RCSS csapat Saját Lexer osztállyal felszerelt 2D RoboCup Soccer Simulation multiágens robotfoci csapat készítése C++ nyelven. (70 pont.) Saját Lexer osztállyal felszerelt robotfoci csapat, a viselkedése RForest alapú. Megoldotta: Kolozsvári Dávid Roland 4.4. MINIX kernellel kapcsolatos programok MINIX 3 ütemező Készítsd el a Tanenbaum könyv 237. oldali 45. feladatát, azaz módosítsa a MINIX 3 ütemezőt úgy, hogy az tartsa nyilván, melyik felhasználói processzus mennyi CPU időt kapott legutóbb. Amikor nincs futtatható taszk vagy szerver, válassza azt a felhasználói processzust, amely legutóbb a legkevesebb időt kapta!. (80 pont.) A feladat kidolgozását a Tannenbaum könyv és a minixforráskód segítségével készítette Takác Ján Algoritmizálási programjaid Pi-számítása több gépen A korábbi szint kapcsolódó BBP feladatát most több géppel valósítsd meg, az IPC mechanizmus legyen a TCP/IP! (30 pont.) Ha megakadsz, íme az én megoldásomat a [PP] 238. oldalától találod.

61 A Debreceni Egyetem programozói évkönyve 31 / fejezet A védések programjai A következő feladatok, vagy azok saját klónjai minden hallgató számára kötelezőek A 2013/14 tanév tavaszi szemeszterének védései Az első védés: a humán genom LZW-bináris fa alapú feldolgozása Írj saját C++ programot a humán genom kromoszómájának feldolgozásra vagy használd a tárolóban lévő forrásokat. A feladatok iniciális forrásait megtalálod a../source/vedes/elso/z3a7.cpp lapon A második védés: egy saját RCSS multiágens C++ implementáció Írj saját csapatot, amely legalább 2 góllal megveri a jegyzet Debrecen Round Forest FC++ referencia-csapatát. A feladatok iniciális forrásait megtalálod a lapon A 2014/15 tanév őszi szemeszterének védései A harmadik védés: lépés a projektek felé A YANonymous projekthez egy saját ág létrehozása. A YANonymous célja a felhasználók által lokális és anonim kapcsolati hálókból a szerver oldalon egy globális közösségi hálózat megbecsülése (kockáknak: a klienssel felvett kisebb gráfokból egy nagyobb gráf építése a szerver oldalon). Néhány tipp: a globális gráf előállítását segítheti a YANO gráf mellé például egy GPS koordináta felvétele az Androidos kliensben. A YANO politikai környezetre készült, konkrétan a választásokat célozta meg, amikor feltehetően lett volna felhasználói közössége. Ám a politika senkit nem fog érdekelni a következő 4 évben, ezért jó irány lehet további környezetek támogathatóságának a programba építése, például: milyen OS-t használsz, vagy melyik a kedvenc focicsapatod stb. A védéskor sikeres és a laborközösségek által támogatott ágakat fésüljük majd be a főágba. A YANO git repóját itt találod: A negyedik védés: egy céges feladat kidolgozásában részvétel Alapértelmezett feladat a Robocar World Championship in Debrecen, ahonnan 120 pontnyi feladatot kell a laborközösség előtt megvédeni.

62 A Debreceni Egyetem programozói évkönyve 32 / fejezet A labor-mérés programjaid 6.1. A 2013/14 tanév tavaszi szemeszterének labor-mérései A következő feladatok, vagy azok saját klónjai minden hallgató számára kötelezőek. Ezek is szerepelnek a pontversenyben, azaz kidolgozhatóak a megoldások részben, s nyilván itt is használhatóak az általam adott implementációk, illetve a hegylakó szabály ezekre is érvényes természetesen. A kidolgozásnál ne felejtsd el, hogy a hivatkozott posztok tipikusan a labormunkát szervezik, s a Te feladatod lényege a megoldások részben nem ez, hanem a kódcsipetek rövid, ámde lényegi bemutatása! A labor-mérések különleges feladatok, mert nemcsak az imént említett, a jelen kézikönyvben való kidolgozást értelmezzük rajtuk, hanem a labormunkán versenyben lévő laborközösség is pontokat szerezhet ezekkel: egyrészt élőben és korlátozott létszámban a laboron, másrészt akár hozhatja magával megoldva a feladatokat a hallgató a laborra, ez utóbbi esetben nincs létszámkorlát. Viszont mindkét utóbbi esetben egy kommentben erről a pontszerzésről melegében tudósítani kell! Ismerkedő labor labor Minden hallgató egyénileg és a laborvezető egyaránt bemutatkozik a laborközösségnek, a bemutatkozás sodorvonala ez legyen: milyen izgalmas programot írtam legutóbb! Majd lehet közösen értelmezni a sillabuszt, ismertetni a labor koncepciót, aki még nem ismeri, annak a jelen UDProg évkönyv használatát, az open source fogalmát, a SourceForge portált, a git verziókezelőt stb. Ezen a laboron még nem osztunk laborkártyákat, viszont lehetőség szerint egy szekvenciális végigolvasással, a nehezebb résznek érzetteken esetleg akár ugorva, gyűrjük le a [STROUSTRUP] tankönyv bevezetését, azaz az első 85 oldalt és beszéljünk ennek élményeiről a laboron! Bevezető laborok Minden bevezető labor a laborkártyák és a kötelező olvasmány gyors ellenőrzésével kezdődik! (A bevezető laborokon a megoldásokban egyaránt használható C, C++, legalábbis ahol a C egyáltalán értelmezhető.) A második labor A parancssori interfész (CLI) alapvető használata című pontok laborkártyáinak feldolgozását ellenőrizzük! Minden kezdet nehéz A második csokor laborkártyában vannak nem triviális nevek is... a második laboron elegendő, ha a hallgató még pontatlan a nehezebb nevek értelmezésében, de azt meg tudja mutatni, hogy forgatta a C++ könyvet, utána olvasott, rákeresett, rákérdezett a blogon stb. A kötelező olvasmány erre a laborra a [STROUSTRUP] tankönyv első 85 oldala.

63 A Debreceni Egyetem programozói évkönyve 33 / Egy saját Google PageRank implementáció Ez tk. egy burkolt for ciklus feladat, hiszen, ha valóban érted a PR algoritmust, akkor egyszerűen egy mátrix szorozgatása vektorral feladat ez csupán! Az algoritmust az előadáson fogod megérteni. A laboron dolgozz úgy, hogy Te magad gépeled be az egész programot például a poszt hiányos kódcsipetei kapcsán, ahol a hiányokat magad pótolod! #include <stdio.h> #include <math.h> void kiir (double tomb[], int db) /* Írasd ki a paraméterként kapott tömb elemeit! */ double tavolsag (double PR[], double PRv[], int n) /* Innen néhány deklaráció hiányzik. */ for (i = 0; i < n; ++i) osszeg += (PRv[i] - PR[i]) * (PRv[i] - PR[i]); return sqrt (osszeg); végül itt jön a fordítási egységnek (forrásfájlnak) a vége: int main (void) double L[4][4] = 0.0, 0.0, 1.0 / 3.0, 0.0, 1.0, 1.0 / 2.0, 1.0 / 3.0, 1.0, 0.0, 1.0 / 2.0, 0.0, 0.0, 0.0, 0.0, 1.0 / 3.0, 0.0 ; double PR[4] = 0.0, 0.0, 0.0, 0.0 ; double PRv[4] = 1.0 / 4.0, 1.0 / 4.0, 1.0 / 4.0, 1.0 / 4.0 ; int i, j; for (;;) /* Ide jön a mártix * vektor iteráció. */ if (tavolsag (PR, PRv, 4) < ) break; /* Itt készítjük újra elő a vektort a következő szorzáshoz.*/ kiir (PR, 4); return 0;

64 A Debreceni Egyetem programozói évkönyve 34 / 404 S ugye csak végső elkeseredésedben nyúlsz a tárolóban lévő futó../source/labor/pr/pr.c kódhoz, ezzel persze a feladat kapcsán automatikusan kivonod magad a pontversenyből! A laboron születő első 3 megoldás 5 pontot ér, ettől természetesen független a feladat aszinkron kidolgozása a megoldásokat bemutató részben. Illetve azt a szokást tartjuk, hogy aki előre megcsinálja otthon, s a laboron ezt bemutatja, az is elszámolhatja magának a pontokat, ennek egy kommentben nyomát kell hagyni a blogon is, hogy bármikor visszakereshető legyen A harmadik labor Az alapvető C és C++ nyelvi konstrukciók használata című pont laborkártyáinak feldolgozását ellenőrizzük! A kötelező olvasmány erre a laborra a [STROUSTRUP] tankönyv oldala és a [KR] könyvből durván az első 70 oldal, az alábbi fejezetek: Bevezetés Típusok, operátorok és kifejezések Vezérlési szerkezetek A labor EXOR titkosításos bevezető feladata után az Exor-töréssel foglalkozik. A munka menetét részletesen kidolgoztuk például a posztban Exor-törés A fő feladat (és egyben az írásbeli vizsga beugrója, hiszen a feladatsorodat is így titkosítva kapod majd meg) egy EXOR titkosított szöveg bruteforce törése, Kiindulhatsz ebből a megvalósításból: parp.book.xml.html#idp A kapcsolódó laborfeladatok Az alábbi szimplább feladatok vezetik be a fő feladatot e.c Önállóan írjuk meg a saját EXOR titkosítónkat, a szokásos módon a laborokon csak végső elkeseredésben forduljunk a kész../source/labor/exor/e.c kódhoz! Az első három 5 pontot kaszálhat t.c A t.c kiegészítése Az előző labor mintájára pótold az alábbi kód hiányzó részeit! Ezt mutatja be poszt. #define MAX_TITKOS 4096 #define OLVASAS_BUFFER 256 #define KULCS_MERET 8 #define _GNU_SOURCE #include <stdio.h> #include <unistd.h> #include <string.h> double atlagos_szohossz (const char *titkos, int titkos_meret) int sz = 0; for (int i = 0; i < titkos_meret; ++i)

65 A Debreceni Egyetem programozói évkönyve 35 / 404 if (titkos[i] == ) ++sz; return (double) titkos_meret / sz; int tiszta_lehet (const char *titkos, int titkos_meret) // a tiszta szoveg valszeg tartalmazza a gyakori magyar szavakat // illetve az átlagos szóhossz vizsgálatával csökkentjük a // potenciális töréseket double szohossz = atlagos_szohossz (titkos, titkos_meret); return szohossz > 6.0 && szohossz < 9.0 && strcasestr (titkos, "hogy") && strcasestr (titkos, "nem") && strcasestr (titkos, "az") && strcasestr (titkos, "ha"); void exor (const char kulcs[], int kulcs_meret, char titkos[], int titkos_meret) int kulcs_index = 0; for (int i = 0; i < titkos_meret; ++i) // Itt a hallgatóságra bízzuk az EXORozást és a // kulcson történő "fűrészfog" léptetést int exor_tores (const char kulcs[], int kulcs_meret, char titkos[], int titkos_meret) exor (kulcs, kulcs_meret, titkos, titkos_meret); return tiszta_lehet (titkos, titkos_meret); int main (void) char kulcs[kulcs_meret]; char titkos[max_titkos]; char *p = titkos; int olvasott_bajtok; // titkos fajt berantasa while ((olvasott_bajtok = read (0, (void *) p, (p - titkos + OLVASAS_BUFFER < MAX_TITKOS)? OLVASAS_BUFFER : titkos + MAX_TITKOS - p)))

66 A Debreceni Egyetem programozói évkönyve 36 / 404 p += olvasott_bajtok; // maradek hely nullazasa a titkos bufferben for (int i = 0; i < MAX_TITKOS - (p - titkos); ++i) titkos[p - titkos + i] = \0 ; // osszes kulcs eloallitasa for (int ii = 0 ; ii <= 9 ; ++ii) for (int ji = 0 ; ji <= 9 ; ++ji) for (int ki = 0 ; ki <= 9 ; ++ki) for (int li = 0 ; li <= 9 ; ++li) for (int mi = 0 ; mi <= 9 ; ++mi) for (int ni = 0 ; ni <= 9 ; ++ni) for (int oi = 0 ; oi <= 9 ; ++oi) for (int pi = 0 ; pi <= 9 ; ++pi) kulcs[0] = ii; kulcs[1] = ji; kulcs[2] = ki; kulcs[3] = li; kulcs[4] = mi; kulcs[5] = ni; kulcs[6] = oi; kulcs[7] = pi; if (exor_tores (kulcs, KULCS_MERET, titkos, p - titkos)) printf ("Kulcs: [%c%c%c%c%c%c%c%c]\ntiszta szoveg: [%s]\n", ii, ji, ki, li, mi, ni, oi, pi, titkos); // ujra EXOR-ozunk, igy nem kell egy masodik buffer exor (kulcs, KULCS_MERET, titkos, p - titkos); return 0; A teljes forráskód itt található:../source/labor/exor/t.c Csökkentsük (a tárhasználat kárára) felére a program futási idejét! Törjük ezt a titkos szöveget! A negyedik labor A kötelező olvasmány erre a laborra a [STROUSTRUP] tankönyv oldala. A szabad tár kezelése című pont laborkártyáinak feldolgozását ellenőrizzük! S természetesen visszafelé az eddigi összes laborkártya éles! Liv-Zempel fa építése a humán genom emberi 2. kromoszómájából A fő feladat (és egyben az első védés tárgya) a humán genom emberi 2. kromoszómáját bitenként feldolgozva egy Liv-Zempel fa felépítése. Kiindulhatsz ebből a megvalósításból: Aki nem ír sajátot, annak ez a forrás lesz a védendője az első védésén! De ma még csak felvezetjük ezt a programot az alábbi kapcsolódó pontokkal A kapcsolódó laborfeladatok Az alábbi szimplább feladatok vezetik be a fő (s egyben védési) feladatot.

67 A Debreceni Egyetem programozói évkönyve 37 / LZW fák Ha nem ismered a Ziv-Lempel-Welch algoritmust, akkor man compress: DESCRIPTION The compress utility shall attempt to reduce the size of the named files by using - adaptive Lempel-Ziv coding algorithm. Note: Lempel-Ziv is US Patent , issued to William Eastman, Abraham Lempel -, Jacob Ziv, Martin Cohn on August 7th, 1984, and assigned to Sperry Corporation. Lempel-Ziv-Welch compression is covered by US Patent , issued to Terry A. - Welch on December 10th, 1985, and assigned to Sperry Corporation. a szabadalmi oltalom ma már lejárt, utólag látható, hogy eredményeképpen a a gif visszaszorult, a png viszont elterjedt. Az algoritmus remek leírását találjuk a Rónyai-Iványos-Szabó Algoritmusok könyvben. Alább egy naivabb implementációt adunk a Tusnády: Sztochasztikus számítástechnika című könyv alapján: jön a 0-1 sorozat, betűnként olvassuk, ha olyan rész jön, ami még nincs a zsákban, akkor letörjük és be a zsákba : > , ennek a bekezdésnek a gondolatmenetét a korábbi posztunkban olvashatod. Bevezetésképpen végezd el az algoritmust a sorozaton a z.c forrás felhasználásával, amelynek üzeméről szól a következő, még a poszthoz készített ábra ábra. Az LZW szófa-építése a bemenetre. [nbatfai@desteny ziv]$ gcc z.c -o z -std=c99 -lm [nbatfai@desteny ziv]$ echo /z (3) (2) (1) (2) (3) (4) ---/(0) (2) (1) (2) melyseg=4

68 A Debreceni Egyetem programozói évkönyve 38 / 404 altag= szoras= z.c // z.c // // LZW fa építő // Programozó Páternoszter // // Copyright (C) 2011, Bátfai Norbert, nbatfai@inf.unideb.hu, nbatfai@gmail.com // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see < // // Ez a program szabad szoftver; terjeszthetõ illetve módosítható a // Free Software Foundation által kiadott GNU General Public License // dokumentumában leírtak; akár a licenc 3-as, akár (tetszõleges) késõbbi // változata szerint. // // Ez a program abban a reményben kerül közreadásra, hogy hasznos lesz, // de minden egyéb GARANCIA NÉLKÜL, az ELADHATÓSÁGRA vagy VALAMELY CÉLRA // VALÓ ALKALMAZHATÓSÁGRA való származtatott garanciát is beleértve. // További részleteket a GNU General Public License tartalmaz. // // A felhasználónak a programmal együtt meg kell kapnia a GNU General // Public License egy példányát; ha mégsem kapta meg, akkor // tekintse meg a < oldalon. // // // Version history: // // 0.0.1, // 0.0.2, csomópontok mutatóinak NULLázása (nem fejtette meg senki :) // 0.0.3, - labormeres_otthon_avagy_hogyan_dolgozok_fel_egy_pedat // #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <math.h> typedef struct binfa int ertek; struct binfa *bal_nulla; struct binfa *jobb_egy; BINFA, *BINFA_PTR;

69 A Debreceni Egyetem programozói évkönyve 39 / 404 BINFA_PTR uj_elem () BINFA_PTR p; if ((p = (BINFA_PTR) malloc (sizeof (BINFA))) == NULL) perror ("memoria"); exit (EXIT_FAILURE); return p; extern void kiir (BINFA_PTR elem); extern void ratlag (BINFA_PTR elem); extern void rszoras (BINFA_PTR elem); extern void szabadit (BINFA_PTR elem); int main (int argc, char **argv) char b; BINFA_PTR gyoker = uj_elem (); gyoker->ertek = / ; gyoker->bal_nulla = gyoker->jobb_egy = NULL; BINFA_PTR fa = gyoker; while (read (0, (void *) &b, 1)) // write (1, &b, 1); if (b == 0 ) if (fa->bal_nulla == NULL) fa->bal_nulla = uj_elem (); fa->bal_nulla->ertek = 0; fa->bal_nulla->bal_nulla = fa->bal_nulla->jobb_egy = NULL; fa = gyoker; else fa = fa->bal_nulla; else if (fa->jobb_egy == NULL) fa->jobb_egy = uj_elem (); fa->jobb_egy->ertek = 1; fa->jobb_egy->bal_nulla = fa->jobb_egy->jobb_egy = NULL; fa = gyoker; else fa = fa->jobb_egy;

70 A Debreceni Egyetem programozói évkönyve 40 / 404 printf ("\n"); kiir (gyoker); extern int max_melyseg, atlagosszeg, melyseg, atlagdb; extern double szorasosszeg, atlag; printf ("melyseg=%d\n", max_melyseg - 1); /* Átlagos ághossz kiszámítása */ atlagosszeg = 0; melyseg = 0; atlagdb = 0; ratlag (gyoker); // atlag = atlagosszeg / atlagdb; // (int) / (int) "elromlik", ezért casoljuk // K&R tudatlansági védelem miatt a sok () :) atlag = ((double) atlagosszeg) / atlagdb; /* Ághosszak szórásának kiszámítása */ atlagosszeg = 0; melyseg = 0; atlagdb = 0; szorasosszeg = 0.0; rszoras (gyoker); double szoras = 0.0; if (atlagdb - 1 > 0) szoras = sqrt (szorasosszeg / (atlagdb - 1)); else szoras = sqrt (szorasosszeg); printf ("altag=%f\nszoras=%f\n", atlag, szoras); szabadit (gyoker); // a Javacska ONE projekt Hetedik Szem/TudatSzamitas.java mintajara // // az atlag() hivasakor is inicializalni kell oket, a // a rekurziv bejaras hasznalja int atlagosszeg = 0, melyseg = 0, atlagdb = 0; void ratlag (BINFA_PTR fa) if (fa!= NULL) ++melyseg; ratlag (fa->jobb_egy); ratlag (fa->bal_nulla); --melyseg; if (fa->jobb_egy == NULL && fa->bal_nulla == NULL) ++atlagdb; atlagosszeg += melyseg;

71 A Debreceni Egyetem programozói évkönyve 41 / 404 // a Javacska ONE projekt Hetedik Szem/TudatSzamitas.java mintajara // // az atlag() hivasakor is inicializalni kell oket, a // a rekurziv bejaras hasznalja double szorasosszeg = 0.0, atlag = 0.0; void rszoras (BINFA_PTR fa) if (fa!= NULL) ++melyseg; rszoras (fa->jobb_egy); rszoras (fa->bal_nulla); --melyseg; if (fa->jobb_egy == NULL && fa->bal_nulla == NULL) ++atlagdb; szorasosszeg += ((melyseg - atlag) * (melyseg - atlag)); //static int melyseg = 0; int max_melyseg = 0; void kiir (BINFA_PTR elem) if (elem!= NULL) ++melyseg; if (melyseg > max_melyseg) max_melyseg = melyseg; kiir (elem->jobb_egy); // ez a postorder bejáráshoz képest // 1-el nagyobb mélység, ezért -1 for (int i = 0; i < melyseg; ++i) printf ("---"); printf ("%c(%d)\n", elem->ertek < 2? 0 + elem->ertek : elem->ertek, melyseg - 1); kiir (elem->bal_nulla); --melyseg; void szabadit (BINFA_PTR elem) if (elem!= NULL)

72 A Debreceni Egyetem programozói évkönyve 42 / 404 szabadit (elem->jobb_egy); szabadit (elem->bal_nulla); free (elem); A forráskód itt található:../source/labor/ziv/z.c d.c A z.c programmal a humán genom 2. kromoszómáját 0, 1 sorozatként szeretnénk feldolgozni, egyelőre nem direktben bitenként, amint majd a védésen, hanem írunk hozzá egy kis konvertert, amely egy 0, 1 szöveges dump-ot nyom a bináris bemenetéből. #include <stdio.h> #include <unistd.h> int main (void) int i, egy_e; unsigned char b; while (read (0, (void *) &b, sizeof (unsigned char))) for (i = 0; i < 8; ++i) egy_e = b & 0x80; if ((egy_e >> 7) == 1) printf ("1"); else printf ("0"); b <<= 1; [nbatfai@desteny ziv]$ wget ftp://ftp.ncbi.nlm.nih.gov/genomes/h_sapiens/chr_02/ - hs_alt_chm1_1.1_chr2.fa.gz [nbatfai@desteny ziv]$ gunzip hs_alt_chm1_1.1_chr2.fa.gz [nbatfai@desteny ziv]$ gcc d.c -o d [nbatfai@desteny ziv]$ cat hs_alt_chm1_1.1_chr2.fa./d>hs_alt_chm1_1.1_chr2.fa.01textdump [nbatfai@desteny ziv]$ gcc z.c -o z -std=c99 -lm [nbatfai@desteny ziv]$ time./z <hs_alt_chm1_1.1_chr2.fa.01textdump >hs_alt_chm1_1.1_chr2. - fa.01textdump.lzwtree real 9m29.787s user 3m17.285s sys 6m8.516s Nagy a program időbonyolultsága, ezért vágjunk le a humán genomi bemenet (tehát nem a dump) elejéből 10 megabájtot és a laboron azzal dolgozzunk. S ha már hekkeljük a d.c-t, akkor (a humán genomos adatokat nézegetve) ne dolgozzuk fel az újsor bájtokat a if (b == 0x0a) continue; feltétel ciklusba építésével. A fájl elejéből a kivágást egy szimpla számlálótól függő kiugratással érjük el, ha a számláló eléri a kellő 10 * 1024 * 1024 értéket.

73 A Debreceni Egyetem programozói évkönyve 43 / A h.c és a g.c A humán genomos adatállományokban a T, C, A és G betűk hármasával egy fehérjét kódolnak a genetikai kódnak megfelelően. A../source/labor/ziv/h.c két nukleotid bázisból egy hexadecimális betűt készít, lásd még ezt a posztot is! #include <stdio.h> #include <unistd.h> int main (void) char hexa_jegyek[] = A, B, C, D, E, F ; int paratlan = 0, elso = 0, masodik = 0, i = 0; while ((i = getchar ())!= EOF) switch (i) case T : masodik = 0; break; case C : masodik = 1; break; case A : masodik = 2; break; case G : masodik = 3; break; if (paratlan) int jegy = 4 * elso + masodik; if (jegy < 10) printf ("%d", jegy); else printf ("%c", hexa_jegyek[jegy - 10]); paratlan =!paratlan; elso = masodik; A../source/labor/ziv/g.c a genetikai kódnak megfelelően a kódolt aminosavakat adja meg. // g.c // // genetikai kód nyomtató // Programozó Páternoszter // // Copyright (C) 2011, Bátfai Norbert, nbatfai@inf.unideb.hu, nbatfai@gmail.com // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by

74 A Debreceni Egyetem programozói évkönyve 44 / 404 // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see < // // Ez a program szabad szoftver; terjeszthetõ illetve módosítható a // Free Software Foundation által kiadott GNU General Public License // dokumentumában leírtak; akár a licenc 3-as, akár (tetszõleges) késõbbi // változata szerint. // // Ez a program abban a reményben kerül közreadásra, hogy hasznos lesz, // de minden egyéb GARANCIA NÉLKÜL, az ELADHATÓSÁGRA vagy VALAMELY CÉLRA // VALÓ ALKALMAZHATÓSÁGRA való származtatott garanciát is beleértve. // További részleteket a GNU General Public License tartalmaz. // // A felhasználónak a programmal együtt meg kell kapnia a GNU General // Public License egy példányát; ha mégsem kapta meg, akkor // tekintse meg a < oldalon. // // Version history: szösszenet // // A poszt // bevezető kódjának alapötletét használjuk fel, de nem kettesével, // hanem most hármasával dolgozzuk fel az inputot // // Ennek a kódnak a részleteit az itteni kisbajnokikon is // kamatoztathatod: #include <stdio.h> #include <unistd.h> // Egyszerűen felsorolom, pl. az alábbi alapján: // char *amino_sav[] = "Stop", "Phe", "Leu", "Ile", "Met", "Val", "Ser", // 6. "Pro", "Thr", "Ala", "Tyr", // 10. "His", "Gln", "Asn", "Lys", "Asp", "Glu", "Cys", "Trp", // 18. "Arg", // 19. "Gly" // 20. ;

75 A Debreceni Egyetem programozói évkönyve 45 / 404 // a 3 betű melyik aminosavat kódolja? char * genetikai_kod (int triplet) int index = 0; switch (triplet) case 0: // Phe case 1: index = 1; break; case 2: // Leu case 3: case 16: case 17: case 18: case 19: index = 2; break; case 32: // Ile case 33: case 34: index = 3; break; case 35: // Met index = 4; break; // hogy jön ez? az 5 indexű a "Val" // GTT-től GTG-ig van ez, jegyekben: // 300-tól 303-ig 4-es számrendszerben // ez van átváltva, pl.: // 303(4) -> 3*16+0*4+3*1 = 51(10) case 48: case 49: case 50: case 51: index = 5; break; case 4: case 5: case 6: case 7: index = 6; break; case 20: case 21: case 22: case 23: index = 7; break; case 36: case 37: case 38: case 39: index = 8; break; case 52: case 53: case 54: case 55:

76 A Debreceni Egyetem programozói évkönyve 46 / 404 index = 9; break; case 8: case 9: index = 10; break; case 10: // Stop case 11: index = 0; break; case 24: case 25: index = 11; break; case 26: case 27: index = 12; break; case 40: case 41: index = 13; break; case 42: case 43: index = 14; break; case 56: case 57: index = 15; break; case 58: case 59: index = 16; break; case 12: // Cys case 13: index = 17; break; case 14: // Stop index = 0; break; case 15: // Trp index = 18; break; case 28: // Arg case 29: case 30: case 31: index = 19; break; case 44: // Ser case 45: index = 6; break; case 46: // Arg case 47: index = 19; break; case 60: // Gly case 61: case 62: case 63:

77 A Debreceni Egyetem programozói évkönyve 47 / 404 index = 20; break; default: // csak tesztelesre a printf printf ("Zavar az eroben %d-nel", triplet); index = 0; break; return amino_sav[index]; // a betűket 3-asával "olvasom": nem kell cifrázni! egy ciklus // elvégzi, amiben megjegyzem, hogy melyik hányadik betű volt // aki ciklusban ciklusolgat, az már bénázik :) int main (void) // hányadik betűn állok? int hanyadik_betu = -1; // azon a helyen mit olvastam? int elso = 0, masodik = 0, harmadik = 0, i = 0, jegy = 0; while ((i = getchar ())!= EOF) switch (i) case T : jegy = 0; break; case C : jegy = 1; break; case A : jegy = 2; break; case G : jegy = 3; break; hanyadik_betu = (hanyadik_betu + 1) % 3; if (!hanyadik_betu) elso = jegy; else if (!(hanyadik_betu - 1)) masodik = jegy; else harmadik = jegy; printf ("%s", genetikai_kod (elso * 16 + masodik * 4 + harmadik));

78 A Debreceni Egyetem programozói évkönyve 48 / Labor és szorgalmi laborfeladatok Aminosav-hisztogram Ez csak a kezdő szinten választható feladat, indulj ki az én megoldásomból:../source/labor/ziv/ga.c és röviden magyarázd meg a megoldások fejezetben! (3 pont.) megjegyzés A kezdő szintű programok megoldásainak legvégére beillesztve a rövid magyarázat. Szentpéteri Annamária (Szerda 10-12) Még drágább aminosav-hisztogram Ez csak a kezdő szinten választható feladat, adj az én megoldásomtól:../source/labor/ziv/ga.c különbözőt C-ben! (4 pont.) Addig nyomd, amíg nem ezt kapod a C elegáns fonalféreg 2. kromójának kódjára: [nbatfai@desteny ziv]$ wget ftp://ftp.ncbi.nlm.nih.gov/genomes/caenorhabditis_elegans/ - CHR_II/NC_ fna [nbatfai@desteny ziv]$ gcc -O3 ga.c -o ga -std=c99 [nbatfai@desteny ziv]$./ga <NC_ fna tail -n 21 Stop Phe Leu Ile Met Val Ser Pro Thr Ala Tyr His Gln Asn Lys Asp Glu Cys Trp Arg Gly Lásd még ezt a posztot is! Az aminosav-hisztogram mindig drága Ez csak a kezdő szinten és tutoriált formában választható feladat, az előző két pont programját írd át szép tiszta C++-ba! (5-5 pont.) C-ből C++ Írd át szép tiszta C++-ba a d.c (4 pont), h.c (4 pont), g.c (5 pont), z.c (15 pont) programokat! A d.c, a h.c és a g.c kódokat átírtam c++-ba.a megoldások a../source/labor/ziv/c_c++/ helyen találhatóak meg.(józan Csaba) A z.c kódot átírtam c++-ba. (Kökéndy Tímea) Megoldás szintén a fenti linken.

79 A Debreceni Egyetem programozói évkönyve 49 / PyTCAG Írd át Python-ba az LZW-s z.c-nket olyanra, hogy nem 0, 1 betűre, hanem a T, C, A, G betűkre megy! (15 pont.) PySzavak Írd át Python-ba az LZW-s z.c-nket olyanra, hogy nem 0, 1 betűre, s nem is a T, C, A, G betűkre, hanem tetszőleges szavakra menjen a fa építése. (20 pont.) A nukleobázisok számolása a humán genom második kromoszómáján C++-ban a Map-Reduce platformon Végezd el a [PARP] könyv megegyező című mérését! (30 pont.) Az aminosavak számolása a humán genom második kromoszómáján C++-ban a Map-Reduce platformon Végezd el a [PARP] könyv megegyező című mérését! (30 pont.) Filogenetikai fa az LZW-s fa ághosszainak szórása alapján A cikk vezeti be a hasonlósági metrikát, a cikkben az első ábra mutatja néhány vizsgált faj evolúciós fáját. Ezt építsük fel mi is, ami nem nehéz, hiszen ez egy példa éppen a CompLearn csomaghoz: example-mammals.html. Végül ugyanezekre a fajokra nézzük meg, hogy alakulnak az LZW fák szórásai, hogy azok közelsége alapján milyen evolúciós fát tudnánk rajzolni? (40 pont.) Érdekes eredmények esetén ez lehet a kurzus során egy keletkező kutatási munka, egy esetleges publikáció. A feladat megoldását Deregi Diána készítette Az ötödiktől a hetedik laborig A kötelező olvasmányok ezekre a laborokra sorrendben a következők a [STROUSTRUP] tankönyv , és oldalai. A [KR] könyvből pedig a Struktúrák című fejezetet olvassuk most értő olvasással el, az önhivatkozó struktúrákkal bezárólag, ahol a treeprint függvényt mindenki eméssze meg! A [STROUSTRUP] tankönyv oldalai. A [KR] könyvből pedig a Struktúrák című fejezetet olvassuk most értő olvasással el, az önhivatkozó struktúrákkal bezárólag, ahol a treeprint függvényt mindenki eméssze meg! A [STROUSTRUP] tankönyv és oldalai. A [STROUSTRUP] tankönyv oldalai. Laborkártyák tekintetében a C++ alapfogalmak című pont laborkártyáiból készüljünk! S természetesen visszafelé az eddigi összes laborkártya éles! Illetve speciális laborkártyaként az ötödik laboron ellenőrizzük, hogy mindenki felvitte-e a bio-ját az évkönyv részbe! A bio tartalmazza legalább a következő információkat: hol járt középiskolába, mit szeretne tanulni, milyen feladatokat szeretne megoldani, oldott meg, volt-e tutor, volt-e tutoriált, ha igen, akkor kivel volt ezekben a relációkban, miben van gyakorlata. a hatodik laboron ellenőrizzük, hogy a házi versenyek kolmogorovi bitfaragsába mindenki legalább olyan szinten bekapcsolódott, hogy az évkönyvbe bekerülő kódokat kipróbálta és érti.

80 A Debreceni Egyetem programozói évkönyve 50 / 404 Az 5., 6. és a 7. laboron történik az első védés, ennek megfelelően a laborok anyaga kicsit játékosabb. A védés tárgy a Liv-Zempel fa építése a humán genom emberi 2. kromoszómájából a 2. kromoszóma állományának bitenkénti (../source/vedes/ elso/z3a7.cpp ) feldolgozásával! Az 5. laboron a laborvezetők ismertetik a védendő programot, illetve az előre készülő legjobbak máris próbálkozhatnak a védéssel. A védés tulajdonképpen az előző labor z.c és d.c forrásainak egybegyúrása és átírása C++-ba, fontos, hogy védeni a C++ változatot kell. A védés az a folyamat, amikor a hallgató projektorral vetíti a kódját és soronként magyarázza annak adott helyeit a laborközösségnek. Miközben evés közben jön meg az étvágy alapon, tipikusan kis feladatot kap, amelynek védési programjába programozásával szakítja meg, majd színesíti celebrációját A védési program megalapozása Ez az egyszerű bináris fa program vezeti be a../source/vedes/elso/z3a7.cpp védési program objektum-orientált vázának a szervezését Bináris fa A bináris fánkat egyszer számokkal, máskor sztringekkel fogjuk feltölteni. Ennek megfelelően két indító állományt készítünk, amelyek a sztenderd bemenetről számokat, illetve sztringeket olvasnak be és nyomják azokat a fába mains.cpp../source/labor/binfa/mains.cpp #include <string> #include "binfa.h" int main () BinFa<std::string> binszofa; std::string s; while (std::cin >> s) binszofa << s; std::cout << binszofa; binszofa.szabadit (); return 0; Vegyük észre, hogy a binszofa fa létrehozásakor a BinFa osztályból egy típusparamétert átadva példányosítunk, azaz a BinFa template osztályból olyat példányt hozunk létre, amelybe std::string osztálybeli példányokat tudunk belepakolni. További érdekessége a kódnak, hogy a sztenderd inputról való olvasás végeztével a fát egyszerűen kishifteljük a kimenetre, azaz úgy nyomtatjuk ki, hogy elegánsan kinyomjuk a kimeneti csatorna (ostream osztálybeli) cout objektumra. Lássuk a működést! [nbatfai@desteny binfa]$ g++ mains.cpp -o mains [nbatfai@desteny binfa]$./mains korte banan alma dio alma korte alma ---korte(2, 0) dio(1, 2) banan(1, 1) alma(3, 2)

81 A Debreceni Egyetem programozói évkönyve 51 / maini.cpp../source/labor/binfa/maini.cpp #include "int.h" #include "binfa.h" int main () BinFa<Int> binszamfa; Int n; while (std::cin >> n) binszamfa << n; std::cout << binszamfa; binszamfa.szabadit (); return 0; [nbatfai@desteny binfa]$ g++ maini.cpp int.cpp -o maini [nbatfai@desteny binfa]$./maini (2, 1) ---42(2, 0) (2, 1) binfa.h A BinFa osztályt a../source/labor/binfa/binfa.h forrásban definiáljuk. Ez egy általánosított (generikus, template) osztály, amelyet a paraméterként kapott CsomopontTartalomTipus-al konkretizálunk, ahogy már láttuk az iménti két esetben például az Int vagy az std::string aktuális osztálynevekkel. template <class CsomopontTartalomTipus> class BinFa class Csomopont A kód további érdekessége, hogy a BinFa osztályon belül definiáljuk a Csomopont osztályt int.h Az Int osztály egy egész értéket csomagol be, a../source/labor/binfa/int.h forrásban definiáljuk.

82 A Debreceni Egyetem programozói évkönyve 52 / int.cpp Azokat a metódusokat, amelyeket csak deklaráltunk az osztály definíciójánál, a../source/labor/binfa/int.cpp forrásban látjuk el implementációkkal Qt programok Próbáld ki a korábbi Qt4-es egyszerű OO szerkezetű kis programokat. Az Arecibói üzenettel kezd, ez a legegyszerűbb, csak egy vásznat tartalmaz, ahová dekódolja a üzenetet, ennek a posztnak megfelelően: A többi program két, teljesen hasonlóan szervezett osztályból áll: egy ablakból és egy szálból, ahol a szálból az ablak példányosít, minek során egy magára mutató pointert is átad a szálnak. A szál bonyolítja az üzleti logikát (végszi a számításokat) és a kapott ablak-pointert az ablak visszahívására használja, hogy az ablak végezhesse az eredmények megjelenítését. (Később ezt a visszahívásos mechanizmust helyettesítjük majd a Qt szokásos slot-signal mechanizmusával, illetve az osztályok szervezését is egyszerűsítjük majd több lépésben, miközben majd Androidos eszközökre is poroljuk őket.) A Qt4-es programokat a fenti könyvtár alól tudod letölteni, miután nincs más dolgod, mint például: [nbatfai@desteny AreciboiUzenet]$ qmake -project [nbatfai@desteny AreciboiUzenet]$ qmake AreciboiUzenet.pro [nbatfai@desteny AreciboiUzenet]$ make [nbatfai@desteny AreciboiUzenet]$./AreciboiUzenet A Qt5-ös programokat a tárolóban találjátok, így járjatok el: [nbatfai@desteny AreciboiUzenet]$ qmake AreciboiUzenet.pro [nbatfai@desteny AreciboiUzenet]$ make [nbatfai@desteny AreciboiUzenet]$./AreciboiUzenet Arecibói üzenet../source/labor/qt/areciboiuzenet Mandelbrot halmaz../source/labor/qt/frak Sejtautomata../source/labor/Qt/Sejtauto Portoljuk Androidra A laborra beviszek néhány készüléket, hogy egyfajta naív portolásként a Qt-s programokat Androidos okostelefonon és tableten is be tudjuk izzítani.../source/labor/qt/sejtauto1

83 A Debreceni Egyetem programozói évkönyve 53 / ábra. A sejtautomata programunk egy Nexus 7-en és egy Nexus 4-en Programok párhuzamosítása A Mandelbrot-számoló párhuzamosítása Az exor-törés Open MP párhuzamosítása Robotfocis laborok A nyolcadik labor A kötelező olvasmány a [STROUSTRUP] tankönyv Laborkártyaként a mozgató konstruktorral és a mozgató értékadással kapcsolatos kártyákat dolgozd fel (természetesen az összes korábbi kártya is éles). Illetve speciális kártyaként írj egy olyan osztályt, amely tagként tartalmaz egy int *** mutatót és konstruktora a szabad tárban az életjáték mintájára lefoglal n darab mxk-s int mátrixnak helyet. Az n, m, k a konstruktor paramétereként jöjjön alapértelmezésben rendre legyenek 2, 60 és 40 (az életjátékban ugye ez az n kettővel lenne egyenlő; illetve tehát foglalj majd helyet int **-ok, int *-ok és int-ek megfelelő tömbjeinek). A destruktor pedig szabadítsa a tárat.

84 A Debreceni Egyetem programozói évkönyve 54 / 404 A../source/labor/kartyak/matrix.cpp laborkártyát Bereczki László elkészítette Kick-off Bemelegítés - legyen kapus a kapus Észreveheted, hogy a foresztes csapatok nem csatolnak kapust, vagyis csatolnak, csak sem ők, sem a szoftver nem tudja róluk, hogy ők a kapusok (mezőnyjátékosra van színezve a kapusunk a monitor programban). Ne hagyd ennyiben! Közösen ne hagyjuk annyiban! Első lépésként kezd el forgatni a doksit: manual pdf. Tanulmányozd a BNF-ben leírt inicializációs (init TeamName [(version VerNum)] [(goalie)]) TeamName ::= (- _ a-z A-Z 0-9)+ VerNum ::= the protocol version (e.g. 7.0) protokoll parancsot. S ennek tükrében nézd meg, hogyan csatlakozik a foresztes (például a rcssserver light5.rf.tar.bz2 Round Forest) csapat? A src/lightclient.cpp forrásban láthatod. (A labor tartalmi része ennek a forrásnak az áttekintésével indul, tehát ne aggódj, ha most nem tiszta a P-szál és az osztály kapcsolata.) std::snprintf(buf, 64, "(init %s (version 15 ))\0", team.c_str()); A BNF-ben megismert nyelvtannak megfelelően ezt kell módosítanod. Számtalan lehetőség adódik, közösen így csináljuk majd: if(role == 1) std::snprintf(buf, 64, "(init %s (version 15 ) (goalie))\0", team.c_str()); else std::snprintf(buf, 64, "(init %s (version 15 ))\0", team.c_str()); A kilencedik labor Javítandó a kötelező olvasmány feldolgozásának színvonalát összekötjük azt a laborkártyákkal az alábbi formában: a következő kérdést mindenkinek meg kell válaszolnia a binomjának (akinek időközben a társa elesett, annak önmagának) k: Hogyan próbáltad ki a [STROUSTRUP] tankönyv számológépes példáját? Milyen nehézségekkel találkoztál közben? v: A válaszban ki kell térni az esetleges kapcsolódó részekre, például: 6.1 Egy asztali számológép 142. o.; 222. o.; 253. o.; 276. oldaltól. S persze a binom könyvtárban meg kell jelennie a működő példának! (Természetesen az összes eddigi laborkártya éles.) A második védés megalapozása Saját viselkedés szögletnél A Round Forest szögletének tesztelését például ezen a videón láthatod: Találj ki egy saját viselkedést a szöglet szituációra! Ha nincs ötleted, íme itt egy konkrét a PROP könyvből: Védő a kapufához, egy támadó előre kontrához (25 pont az első ötnek a laboron, megkötések nélküli tutor rendszer támogatott).

85 A Debreceni Egyetem programozói évkönyve 55 / A tizedik és tizenegyedik labor Ez a második védések szezonja. A második védés lényege, hogy a hallgató elképzeli az ágensek egy viselkedését: mondjuk hogyan viselkedjenek a szögletkor és ezt beprogramozza. A védés természetesen most is a forráskód magyarázatát jelenti. Az a szerencsés, ha a hallgatónak van hozzáadott értéke (ez az elképzelt viselkedés és annak megvalósítása), mert ez esetben annak magyarázatával tud kezdeni, ami könnyebb, mint egy véletlen kérdés. A védés az implementált viselkedés felvételről történő bemutatásával kezdődjön, tehát RCG fájlból eleve hozva! Hogy az imént említett véletlen kérdésre is adjunk egy példát: a P-szálak C++-ban történő használatának milyen problémája van és hogyan oldottuk meg ezt a csapatunkban? A tizedik laborra a kötelező olvasmány a [STROUSTRUP] tankönyv Laborkártyaként mutassunk példát saját egyszerű kódban a Liskov-elv (LSP) sérülésére (lásd még az erről szóló beszélgetést is a fórumunkon). Illetve az előző labor laborkártyájának számológépes (tankönyvi) kódját tudjuk elmagyarázni. A tizenegyedik laborra a kötelező olvasmány a [STROUSTRUP] tankönyv Laborkártyaként mutassunk példát saját kódban másoló konstruktor mélymásoló megvalósítására az első védési programunkban, továbbá dolgozzuk fel ezt a rule of five-os példát Laborfeladatok Előtérben védünk, a háttérben ezekből a feladatokból csemegézzünk, nincs hegylakó-szabály a laborokon: A../source/binom/Batfai-Barki/vedes/z3a8.cpp mintájára írj másoló értékadást a védési programod LZW fájához, teremts olyan szituációt a programban, hogy hívódjon, magyarázd el a működését (30 pont, az első három feladat egymást kizáró az elszámolásban) A../source/binom/Batfai-Barki/vedes/z3a8.cpp mintájára írj mozgató konstruktort a védési programod LZW fájához, teremts olyan szituációt a programban, hogy hívódjon, magyarázd el a működését (20 pont, az első három feladat egymást kizáró az elszámolásban) A../source/binom/Batfai-Barki/vedes/z3a8.cpp mintájára írj mozgató értékadást a védési programod LZW fájához, teremts olyan szituációt a programban, hogy hívódjon, magyarázd el a működését (20 pont, az első három feladat egymást kizáró az elszámolásban) Készítsd el az RCSS szerver lájtosítását patch formájában! (150 pont, de csak 150 pont fölött választható/számolható el) Írd át Java-ba a védési programot! (25 pont, de csak 50 pont fölött választható/számolható el, kiindulhatsz az én teljesen mechanikus, szinte soronkénti átiratomból:../source/binom/batfai-barki/vedes/lzwbinfa.java, további 3 pont, ha végzel egy sebességösszehasonlítást) [nbatfai@desteny vedes]$ javac LZWBinFa.java [nbatfai@desteny vedes]$ wget ftp://ftp.ncbi.nlm.nih.gov/genomes/h_sapiens/chr_02/ - hs_alt_chm1_1.1_chr2.fa.gz [nbatfai@desteny vedes]$ gunzip hs_alt_chm1_1.1_chr2.fa.gz [nbatfai@desteny vedes]$ time java LZWBinFa hs_alt_chm1_1.1_chr2.fa -o kim [nbatfai@desteny vedes]$ tail -3 kim depth = 278 mean = var = Éleszd fel a YANonymous induló kódját! (20 pont a felélesztés, a tableten kipróbálás további 5 pont, de csak 100 pont fölött választható/számolható el) Ne használd a YANonymous repót, hanem dolgozz ezzez az archívummal (ez biztosan nem hálózati és teljesen leegyszerűsített, a csomagbeli README állománnyal kezd az ismerkedést és hozz létre beszélgetéseket a fórumunkon, ha valami nem tiszta) [nbatfai@desteny yanoteszt]$ wget [nbatfai@desteny yanoteszt]$ tar xvjf 1.tar.bz2 [nbatfai@desteny yanoteszt]$ cd 1/YANonymous/ [nbatfai@desteny YANonymous]$ mvn clean install...

86 A Debreceni Egyetem programozói évkönyve 56 / 404 [INFO] Installing /home/nbatfai/yanoteszt/1/yanonymous/target/yanonymous-1.apk to /home/ - nbatfai/.m2/repository/hu/unideb/inf/batfai/yanonymous1/yanonymous-1/0.0.1-prog2/ - YANonymous prog2.apk [INFO] Installing /home/nbatfai/yanoteszt/1/yanonymous/pom.xml to /home/nbatfai/.m2/ - repository/hu/unideb/inf/batfai/yanonymous1/yanonymous-1/0.0.1-prog2/yanonymous prog2.pom [INFO] Installing /home/nbatfai/yanoteszt/1/yanonymous/target/yanonymous-1.jar to /home/ - nbatfai/.m2/repository/hu/unideb/inf/batfai/yanonymous1/yanonymous-1/0.0.1-prog2/ - YANonymous prog2.jar [INFO] [INFO] BUILD SUCCESS [INFO] [INFO] Total time: 7.977s [INFO] Finished at: Fri Apr 25 11:54:37 CEST 2014 [INFO] Final Memory: 27M/499M [INFO] Ha ezt látod, akkor a target könyvtárban már létrejött az apk állomány, amelyet a táblagépedre tölthetsz, persze ehhez sok dolognak kell klappolnia, még az alkalmazás előállítását (Maven életciklusok) vezérlő pom.xml állományon is reszelni kell, erre a csipetre cseréld a gondot okozó (mert lesz vele gond: falióra lesz :) régit: <plugin> <groupid>com.jayway.maven.plugins.android.generation2</groupid> <artifactid>android-maven-plugin</artifactid> <version>3.8.0</version> <extensions>true</extensions> </plugin> Ehhez persze fel kell tenned az Android SDK-t, az ADT Bundle-t javaslom, amelyre a kicsomagolás után érdemes akár a.bashrc-ben is ráállítani az ANDROID_HOME és a PATH változókat: export ANDROID_HOME=$HOME/adt-bundle-linux-x86_ /sdk export PATH=$PATH:$ANDROID_HOME/tools:$ANDROID_HOME/platform-tools utóbbi például arra is jó, hogy elérési út nélkül ki tudd adni az android avd parancsot, amivel virtuális eszközt tudsz indítani, hogy ezen tudj tesztelni. Ha már elindul az emulált Android eszközöd, akkor (ott ahol korábban is kiadtad a Maven-es parancsot az alkalmazás elkészítéséhez, az apk előállításához) a mvn android:deploy paranccsal installálhatod a virtualizált eszközre a programot. Ha eddig eljutottál, akkor 20 pont, ha a fórumunkon magyarázod a forrásokat; 5 pont, ha a színeket megváltoztatod és 25, ha megoldod azt, hogy új csomópontokat a régiekből húzva lehessen létrehozni és ezt egy éllel is jelölje a program (ebben segít a de csak végső elkeseredésben, vagy az első benyomások megszerzése miatt nyisd ki és ne szolgaian csak másold! Kvantum-tudatos laborok A tizenkettedik labor A kötelező olvasmány a [STROUSTRUP] tankönyv Laborkártyaként dolgozzuk fel (kipróbálás, a kód olvasása és magyarázása, azaz celebrálása :) a a../source/binom/batfai-barki/lambda könyvtár s1.cpp-s9.cpp forrásait! A kvantum-tudatos kognitív modellel arra teszünk kísérletet, hogy egy saját kognitív szimulációs platformot (Quantum Consciousness Soccer Simulator) alakítsunk ki, amelyben a valóság kialakítását tudjuk vizsgálni! Éleszd fel a QCSS szimulátort és a megjelenítőjét! (10 pont, illetve 15, ha ezt egy YouTube videóban is bemutatod) Írj saját Qt-s megjelenítőt a QCSS szimulátorhoz! (50 pont felett választható, 35 pont) Kiindulhatsz az enyémből, vagy akár valamelyik tavalyiból, például

87 A Debreceni Egyetem programozói évkönyve 57 / A céges feladatok bevezetése Az utolsó labor A tanév szeptemberi szemeszterétől a Prog2 (Magasszintű programozási nyelvek 2) labor teljesítésének egyik szükséges feltétele lesz egy céges feladat kidolgozása. A céges feladat lényege, hogy érdeklődő, szoftverfejlesztésben is exponáló cég specifikál egy feladatot olyan feltételekkel, miszerint a feladat leírása, a cég neve, illetve opcionálisan egy kontakt fejlesztő neve, címe, továbbá a feladat megoldása bekerülhet a GNU GPL v3-as engedélyű UDPROG (The Yearbook of the Programmers of University of Debrecen, projektbe. k: Miért jó ez a hallgatónak? v: Mert olyan feladaton tud dolgozni, amely remek teljesítés és kölcsönös szimpátia esetén akár potenciális belépőjegye is lehet a kiíró céghez! k: Miért jó ez a cégnek? v: Mert skálázott módon (egyrészt a kontakt fejlesztő közvetlenül vizsgálhatja a céges feladatukon dolgozók aktivitását a git repóban, másrészt a kiíró cég megkaphatja csak a legjobb megoldások munkáit, vagy előre egyeztetett, akár a kiírásba is bevett anyagokat, pl.: prezi vagy videó a megoldásról, annak folyamatáról stb.) tudja megismerni, megvizsgálni néhány leendő potenciális munkatársjelöltjét. k: Miért jó ez az egyetemnek? v: Mert minél inkább közel tud kerülni egymáshoz a két fenti választ, annál inkább minket fognak választani a legjobb képességű diákok a régióban. Szervezz le egy ilyen feladatot! (50 pont felettieknek, 70 pont, nincs hegylakó-szabály, sőt egy hallgatónak is lehet több megoldása, azaz leszervezett feladata, de a cég legalább ben erősítse meg, hogy a specifikált feladata, a cég neve és a feladat megoldása megjelenhet az UDPROG tárolójában, forrásaiban és dokumentumaiban.) Az alábbi témák kiemeltek, legszerencsésebb, ha a feladatok ezekben az irányokban szóródnak, de mindenképpen Java vagy C++ feladatok jöhetnek csak szóba. C++11, C++14, Boost, Qt5 CUDA Ogre3D Java 8, Android Java Map-Reduce, Hadoop Java EE, terheléselosztás, GlassFish, Liferay, portletek, BPMN-BPEL Lespecifikált feladatok Itt csak a specifikáció szerepeljen, a specifikáció és implementáció majd a következő szemeszter évkönyvében kap helyet. Csak engedélyek birtokában Csakis akkor listázd itt a feladatot, ha a kiíró cégtől a fent hangsúlyozott engedélyeid már megvannak írásban (legalább ben)! A céges feladatok intézményének részletesebb kifejtése az appandixben található.

88 A Debreceni Egyetem programozói évkönyve 58 / A 2014/15 tanév őszi szemeszterének labor-mérései Beszokató labor Az első labor Minden hallgató egyénileg beszámol, hogy telt a nyara a programozás szempontjából. Majd közösen értelmezzük a sillabuszt, a labor koncepciót, aki még nem ismeri (esetleg lehetnek ilyenek, hiszen durván 60-an teljesítettük az udprog-os prog1 kurzust, de a jelen prog2 kurzust 80-an vették fel) annak a jelen UDProg évkönyv használatát, az open source fogalmát, a SourceForge portált, a git verziókezelőt stb. Ebben a kurzusban már nem osztunk laborkártyákat, viszont a kötelező olvasmányokat majd még ellenőrizzük Bevezető laborok Minden bevezető labor a kötelező olvasmány és néhány forráskód gyors ellenőrzésével kezdődik! A második labor A kötelező olvasmány erre a laborra a [JAVAKONYV] tankönyv első 35 oldala. Továbbá szúrópróba szerűen a laborközösség magyarázza el a poszt Java kódját (a szokásos feketézés tehát van) A védési program Java és C# átirata Az előző féléved első védési programját írd át más nyelvekre! A Java átirat minenkinek kötelező, ezt már hozd magaddal a laborra. Az átíráshoz forgasd a könyvet és az API doksit! Ha leküzdhetetlennek tűnő nehézségeid támadnak, ámde csakis ebben a végső esetben, használd az én átiratomat: LZWBinFa.java (lásd még a posztot is). Laborközösségenként 20 pont az első háromnak, de a kódnak természetesen különböznie kell az enyémtől! További 20 pont üti a markát annak az első háromnak, aki elkészíti a C# és a Python átíratokat, amelyeknek ugyanazt a kimenetet kell ugyanarra a (szokásos humán genom 2. kromoszóma) bemenetre produkálniuk. Még további pontok járhatnak annak az első háromnak, akik összehasonlító sebességteszteket futtatnak, amelyben az átiratokat vetik össze az eredeti C++ megoldással, páronként 5 pont (itt lehet több különböző C/C++ megoldást és átiratot hasonlítani az eredeti z3a7.cpp megoldáshoz). Java átirata: itt Megoldotta: Orbán István Python átirat: itt Készítette: Dalmadi Zoltán C# átirat: itt Készítette: Fenesi Gábor, Tutor: Fülöp Sándor

89 A Debreceni Egyetem programozói évkönyve 59 / 404 Sebességteszt eredménye: itt Készítette: Balkus Gergő Tutor: Fülöp Sándor Java performance tuning Ez a tulajdonképpeni labormérés: a jconsole monitor program használatának megismerése, a védési program átiratának tekintetében a részleteket lásd a tavalyi poszton (annak is Az API forgatása című pontjában)! Húsz pont az első háromnak, aki megmagyarázza a monitor programos elemzés kapcsán a poszt beállította szituációt. Megoldás itt Készítette: Sipos Ferenc További pontgyűjtő feladatok Ezeknél a feladatoknál él a hegylakó-szabály és kidolgozásuk mehet szokásosan a megoldások részbe. Írd át az első félév PageRank-os C++ alapú alternatív tabelláját Javába (20 pont) vagy C#-ba (10 pont) avagy Python-ba (10 pont)! A feladat egy megoldását megtalálod a posztban, de ez nyilván nem adható be, hanem annak érdekes, aki önmagától még nem tudta volna megírni! Java átirat: itt C# átirat: itt Megoldotta: Fenesi Gábor Tutor: Fülöp Sándor Python átirat: itt Megoldotta: Balkus Gergő Tutor: Fülöp Sándor A poszt feladatai kvíz kérdések, kérdésenként 5 pont üti a markát a válaszoló első hallgatónak. Megoldás itt Megoldotta: Fenesi Gábor Tutor: Fülöp Sándor 15 pontért végezd el a BBP-s sebességtesztet, ahol a C és a Java implementációt veted össze. További 25 pontot könyvelhetsz el magadnak, ha ehhez a 2 nyelves összehasonlításhoz további nyelveken (pl.: C#, Python, vagy teljesen saját C, C++, C# stb.) is implementálod a programot (nyilván ugyanazt adja eredményül a megoldásod). A feladat a forráskódok alapján írt Python implementációval, illetve a megadott programok alapján lett elkészítve Megoldás megtekintése: itt Megoldotta: Balkus Gergő Tutor: Fülöp Sándor

90 A Debreceni Egyetem programozói évkönyve 60 / pont, ha ezt a Maven alapú Helló Világ! szervletes példát feléleszted tetszőleges környezetben, s további 20 pont minden más környezetért (pl. az előadás fóliák alapján defaultban deployolod Tomcat-re, majd további ismerkedésként az alkalmazásszerverek használatával: GlassFish 2, GlassFish 3-ra, vagy éppen JBoss-ra). Megoldás (Előadás alapján 50pont * 1,4) itt Megoldotta: Fenesi Gábor (GlassFish) 50 pont, ha feltöröd ezt a hibásan implementált RSA-val kódolt titkos szöveget. Indulj ki az előadás fóliáiból és szótár alapon törd! Ilyen törés lesz az írásbeli vizsga szokásos beugrója, ezért szerintem semmiképen ne hagyd ki! Megoldás itt Készítette: Orbán István A harmadik labor A kötelező olvasmány erre a laborra a [JAVAKONYV] tankönyv a és a oldala. Továbbá szúrópróba szerűen a laborközösség magyarázza el a projektek egyikének Java kódját YANonymous = YANA (You Are Not Alone) + Anonymous = You Are Not Anonymous A Java gyakorlati bevezetését a YANonymous programon keresztül tesszük meg. Labormérésként éleszd fel és nézd át kódban sorrendben az első 8 esetet: Laborközösségenként az első háromnak esetenként 5 pont elszámolható. Útmutatót a Maven forráscsomagok README állományában találsz. A laborokra beviszek Androidos tableteket és okostelefonokat a valódi eszközökön történő teszteléshez. Megoldás itt Megoldotta: Fenesi Gábor Tutor: Fülöp Sándor Megoldotta: Balkus Gergő Tutor: Fülöp Sándor További pontgyűjtő feladatok Ezeknél a feladatoknál felfüggesztjük a hegylakó-szabályt, helyette időkorlátot vezettünk be a kidolgozásukra. A Városi hangya felélesztése (40 pont, tutor rendszerben készíthető, de csak szept. 30-ig). A program egyszerűen egy ikont rajzol oda, ahol éppen vagyunk a Google térképen. Fusd át a kapcsolódó korábbi posztokat és nézd meg a hivatkozott alábbi teszt-videót: A felélesztést ez alapján érdemes csinálni: mobp.book.xml.html#varosihangya. Illetve lásd még az eredeti kiírást itt: a Linkedin-es fórumunkban! Lépés a saját forgalomirányító csapat felé egy "hangya-szimuláció" elkészítése, működjön például így: hangyak/ vagy így: From sctarch dolgozz! Tehát itt nincs térkép, nincs semmi hálózati kérdés, csak hangya-szimuláció. Kiindulhatsz olyasmiből, mint tavaly az életjátékos kódunk. Java applet megoldás vagy portolása egy másik from scratch megoldásodnak 40 pont, Qt megoldás vagy portolása egy másik from scratch

91 A Debreceni Egyetem programozói évkönyve 61 / 404 megoldásodnak 40 pont, Java full screen API megoldás hasonlóan 40 pont stb., azaz más platformra is tehetsz javaslatot kommentben persze, s ha elfogadjuk, akkor az is 40 pont. A program legyen OO, legyen benne legalább egy osztály, ami a hangyát absztrahálja és ilyen példányokból bolyongjon sok :) Egy hangya vezérlő algoritmusa működjön alapban az itt leírt: "a legbüdösebb irányba megy" módon: További 15 pont, ha bemutatsz egy YouTube videót is a hangya szimulációdról (a videó leírásában hivatkozd a kurzust). Írj C++ programot, amely a libosmium ( libosmium) csomagot felhasználva Debrecen OpenStreetMap térképéről kilistázza az összes buszmegálló nevét, GPS koordinátáit és a felhasználó nevét, aki felvitte a buszmegállót. (25p) Írj az előzőhöz hasonlóan C++ programot, amely Debrecen összes utcájának a nevét kilistázza. (25p) YANO laborok Minden YANO labor az 1-8-as YANO-k forrásai ismeretének (és természetesen a kötelező olvasmány) ellenőrzésével kezdődik! A negyedik labor A kötelező olvasmány erre a laborra a [JAVAKONYV] tankönyv és értő olvasással és legalább egy-egy tartalmazott példa kidolgozásával, a egyszeri elolvasással YANO hack Labormunka a YANO-kon, vagy direktben egy saját ágon a hivatalos YANonymous repóban További pontgyűjtő feladatok Ezeknél a feladatoknál él a hegylakó-szabály és kidolgozásuk mehet szokásosan a megoldások részbe. A humán genomos programod Java átíratát vizsgáld meg részletesen (time-el futtatva, a System osztály currenttimemil lis metódusát használva és legfőképpen a hprof használatával, utóbbi esetén lásd a tankönyv 184. oldalát). 30 pont, további 10, ha az eredményeket egy Linkedin posztban is bemutatod, ahol minden érkező szakmai komment további 3 pontot ér, a like pedig további egyet. Megoldás itt,.. readme../source/labor/prog2lab/humangeomhprof/ Megoldotta: Fenesi Gábor Tutor: Balkus Gergő Írj egy saját egyszerű 2D-s Java játékot a Javát tanítok könyv példájára. 35 pont, további 10, ha az eredményeket egy Linkedin posztban is bemutatod, ahol minden érkező szakmai komment további 3 pontot ér, a like pedig további egyet. Hegylakó-szabály kikapcsolva. Megoldás../source/labor/prog2lab/2DJatek/FG/ mappában.itt Megoldotta: Fenesi Gábor, Tutor:Fülöp Sándor Írj egy Linkedin posztot az i és az i+1 (i=1,...,7) YANO csomag összevetéséről. Posztonként 10 pont, illetve minden érkező szakmai komment további 3 pontot ér, a like pedig további egyet.

92 A Debreceni Egyetem programozói évkönyve 62 / 404 Megoldás itt Megoldotta: Fenesi Gábor Tutor:Fülöp Sándor Írj egy Linkedin posztot az Object osztály wait és notify párjának összehasonlításáról! (Egy példát ezen a lapon az Esettanulmány: egy chat program című pont alatt találsz) 20 pont, illetve minden érkező szakmai komment további 3 pontot ér, a like pedig további egyet. Megoldás itt Megoldotta: Fenesi Gábor Tutor:Fülöp Sándor Az ötödik labor A kötelező olvasmány erre a laborra a [JAVAKONYV] tankönyv és értő olvasással és legalább egy-egy tartalmazott példa kidolgozásával. Mostanra mindenkinek kell egy saját ággal rendelkeznie a hivatalos YANonymous repóban! YANO hack Labormunka egy saját ágon a hivatalos YANonymous repóban További pontgyűjtő feladatok Ezeknél a feladatoknál él a hegylakó-szabály és kidolgozásuk mehet szokásosan a megoldások részbe. Itt az exponálhat, aki a fícsöre alapján meghívást kapott a készülő kéziratba, ennek szervezése a jelen évkönyv keretein kívül történik Haladó laborok A hatodik labor A kötelező olvasmány erre a laborra a [JAVAKONYV] tankönyv értő olvasással és legalább egy-egy tartalmazott példa kidolgozásával, az egyszeri elolvasással Robocar City Emulator A laboron igyekezzünk lezárni a YANO védéseket és kezdjük meg a robotautós téma tervezését! A kutatási terv Tetris terve (és a laborok kapcsolódó brain storming-jai) alapján vázold fel 1 oldalban a tervezett emulátor koncepcióját, térj ki sw architektúrára is. További aspektusok: a Debrecen OpenStreetMap olyan csomópontot tartalmaz, de vannak nagyobb városok is :) lehet autó is akár mi legyen egy jármű input/output-ja? (ez adja az emulátor jelleget) 100 pont a szóban forgó 1 oldalas koncepció, további 100, ha van Linkedin posztja, amely kap legalább 3 szakmai kommentet vagy 20 lájkot.

93 A Debreceni Egyetem programozói évkönyve 63 / További pontgyűjtő feladatok Eredetileg ezek a feladatok az 5. előadáson katalogizáltaknak voltak meghirdetve, de a nagy érdeklődés miatt mindenki előtt megnyitjuk, viszont az előadáson katalogizáltak még hozzávehetnek.4-et a szorzójukhoz (ha tehát a tutor rendszeren kívül oldják meg, akkor 1.4, ha azon belül, akkor 1.7 vagy 2.0 számukra a szorzó) 100 pont: az állapotmentes session bean GlassFish klaszteren deploy-ozásáért (további 20 pont egy posztbeli bemutatása az aktuális tapasztalatoknak és további 80 egy YouTube demó videó). 100 pont: 1) más open source alkalmazás szerverrel 50 pont: Maven alapú Hello Világ szervlet (URL-t lásd az évkönyvben, 2. labor feladatai alatt) deploy GlassFish. 50 pont: 3) más open source megoldás (pl. Tomcat stb.) 100 pont: GlassFish Apache integráció (ne látszódjon a portszám) 30 pont a GoldenTeam JUnit tesztjének (Maven projekt) felélesztése és egy posztban történő rövid jellemzése A hetedik labor A kötelező olvasmány erre a laborra a [JAVAKONYV] tankönyv és a értő olvasással és legalább három-három!!! tartalmazott példa kidolgozásával! Labormérés Az Osmium API forgatásával egészítsd ki a Malvin feladat valamelyik (pl.:../source/robotauto/elotanulmanyok/ OpenStreetMap/Norbi/bus-stops/) megoldását, hogy megszámolja, hány km összesen a buszmenetrend! (első három labor-megoldó 30 pont) A megoldásban olyan térképet használj, amelyen minden node rajta van, pl exportálj ezekkel az adatokkal: <bounds minlat=" " minlon=" " maxlat="47.652" maxlon=" "/> Ezt kell kapnod: #Stops = 125 #Kms = További pontgyűjtő feladatok Itt nem alkalmazzuk a hegylakó-szabályt. 20 pont: terjeszd ki az iménti Malvin megoldást a trolikra és a villamosra is! Megoldás a../source/robotauto/elotanulmanyok/openstreetmap/gergob/buszjarat_megallo mappában. itt Megoldotta: Balkus Gergő Megoldás a../source/robotauto/elotanulmanyok/openstreetmap/fgabor/java_buszmeg_trolley_tram_mvn mappában. Megoldotta: Fenesi Gábor

94 A Debreceni Egyetem programozói évkönyve 64 / 404 Megoldás a../source/robotauto/elotanulmanyok/openstreetmap/tantal/bus_trolleybus_tram_lines mappában. Megoldotta: Török Antal Tutor:Sípos Ferenc Megoldás a../source/binom/d.diana-sz.annamaria/malvin mappában. itt Megoldotta: Szentpéteri Annamária A nyolcadik labor A kötelező olvasmány erre a laborra a [JAVAKONYV] tankönyv II/86-98, II/ értő olvasással és legalább egy-egy tartalmazott példa kidolgozásával, az II/1-13 egyszeri elolvasással Labormérés Az úthálózat gráfját akarjuk használni, felmerül a kérdés, hogy szomszédsági mátrix vagy lista formájában reprezentáljuk. Ennek deduktív eldöntéséhez ezen a Debrecen térképen számold meg, hogy az utakon hány egyedi csomópont van (V a csúcsok száma a gráfban) és az utakon hány csomópont-csomópont kapcsolat, azaz (E) él. Majd írasd ki a V 2 /E értéket, hogy lássuk ritka vagy sűrű mátrixal lenne-e dolgunk? Ezt kell kapnod: E= V= V^2/E= További pontgyűjtő feladatok Itt nem alkalmazzuk a hegylakó-szabályt. 20 pont: a Malvin megoldásokban tipikusan szereplő osmium::index::map::sparsetable adatszerkezetet helyettesítsd osmium::index::map::stlmap-el és írasd ki a használt memóriát, mért a futási időt és hasonlítsd össze ezeket! Megoldás itt Megoldotta: Fenesi Gábor Tutor:Fülöp Sándor 40 pont: az iménti, de most helyettesítsd osmium::index::map::vectorbasedsparsemap-el! Megoldás itt Megoldotta: Sipos Ferenc 30 pont: írj egy Linkedin posztot, amelyben megmagyarázod a forrás következő csipetét

95 A Debreceni Egyetem programozói évkönyve 65 / 404 template <typename TId, typename TValue, template<typename...> class TVector> 136 class VectorBasedSparseMap : public Map<TId, TValue> public: typedef typename std::pair<tid, TValue> element_type; 141 typedef TVector<element_type> vector_type; különös tekintettel az osztály használatára! Megoldotta: Sipos Ferenc 250 pont: a Malvin vagy hasonló saját forrású C++ programba implementálj két csomópont közötti útkereső algoritmust! 400 pont: A doksi angol fordítása (hegylakó, 3 fős csapatban is készíthető). Megoldotta: Akai Zsolt, Balkus Gergő, Fenesi Gábor 300 pont: az előző angoltól különböző, tetszőleges fordítása (hegylakó, 3 fős csapatban is készíthető). Megoldotta: Józan Csaba (ukrán nyelvre) A kilencedik labor A kötelező olvasmány erre a laborra a [JAVAKONYV] tankönyvii/ értő olvasással és legalább öt tartalmazott példa kidolgozásával, a II/70-85 egyszeri elolvasással! Továbbá a [STROUSTRUP] tankönyv második kötetéből a egyszeri értő olvasással! Labormérés Az előző laborok buszmegálló-távolságát számoló programját módosítsd úgy, hogy az utakon számolja a távolságot (első három labor-megoldó 60 pont) Első lépésben tanulmányozd a OSM XML bemenetet a témában: debrecen.osm. Ezt kell kapnod, legalábbis, ha mechanikusan minden útra számolsz és nem veszel hozzá további szemantikus szűrést: 10: km 10A: km 10Y: km 11: km 11A: km 12: km

96 A Debreceni Egyetem programozói évkönyve 66 / : km 15: km 15Y: km 16: km 17: km 17A: km 18: km 18Y: km 19: km 21: km 22: km 22Y: km 23: km 23Y: km 24: km 24Y: km 25: km 25Y: km 30: km 30A: km 30I: km 30N: km 33: km 33E: km 33Y: km 34: km 34A: km 35: km 351: km 35A: km 35E: km 35Y: km 36: km 36A: km 36E: km 36Y: km 37: km 39: km 41: km 41Y: km 42: km 42Y: km 43: km 44: km 45: km 45H: km 46: km 46E: km 46Y: km 47: km 47Y: km 48: km 51E: km A1: km AU1: km AU2: km GGY: km Not specified: km

97 A Debreceni Egyetem programozói évkönyve 67 / További pontgyűjtő feladatok Itt nem alkalmazzuk a hegylakó-szabályt. 150 pont: építsd fel a szomszédsági listát a Boost BGL könyvtárával! Megoldás a../source/robotauto/elotanulmanyok/openstreetmap/fgabor/graph/ mappában Megoldotta: Fenesi Gábor Tutor: Balkus Gergő A tizedik labor A kötelező olvasmány erre a laborra a [STROUSTRUP] tankönyv második kötetéből a egyszeri értő olvasással és 5+1 példa kidolgozásával, ahol a +1 példa a bemeneti szógyakoriság számlálása legyen az std::map osztállyal! Továbbá ugyanebből a könyvből a értő olvasással Labormérés Az előző laborok buszmegálló útvonalait ábrázoljuk. Első lépésben az első három labor-megoldó 40 pont: jxmapviewer2 alapú megjelenítő (Maven projekt) összeállítása a jxmapviewer2 projekt valamelyik bevezető példája alapján, a program a Debrecen térképet mutassa További labormérés feladatok Itt természetesen alkalmazzuk a hegylakó-szabályt, illetve az első három szabályt a laborközösségekben. Mint a labormérés, de a 22-es busz megállóit mutassa (50 pont). Megoldás a../source/robotauto/elotanulmanyok/openstreetmap/gergob/labor-10/22_megallok/ mappában Megoldotta: Balkus Gergő Tutor: Fenesi Gábor Mint az előző, de a 22-es busz útvonalát mutassa (70 pont, az útvonal kinyerő is saját legyen, aminek kimenetét kapja meg a szóban forgó megjelenítő). Megoldás a../source/robotauto/elotanulmanyok/openstreetmap/gergob/labor-10/sima_utvonal/ mappában Megoldotta: Balkus Gergő Tutor: Fenesi Gábor Mint az előző, de az útvonal csomópontjait egy saját ikonnal jelzi (90 pont). Megoldás a../source/robotauto/elotanulmanyok/openstreetmap/gergob/labor-10/custom_marker/ mappában Megoldotta: Balkus Gergő Tutor: Fenesi Gábor

98 A Debreceni Egyetem programozói évkönyve 68 / ábra. A feladat egy megoldása a Justine protóval, annak Justine Window tagjával További pontgyűjtő feladatok Itt nem alkalmazzuk a hegylakó-szabályt (pontosabban csak az évkönyvbe való bekerülés kapcsán alkalmazzuk). 250 pont: az előző laboron kiírt Boost BGL-es feladatot fejleszd tovább, hogy utat keressen két adott pont között! Használd természetesen ehhez is a Boost-ot, például: Bellman-Ford, Dijkstra, de számos további közül is csemegézhetsz: Shortest Paths / Cost Minimization Algorithms. Megoldás a../source/robotauto/elotanulmanyok/openstreetmap/gergob/routing_with_bgl/ mappában Megoldotta: Balkus Gergő Próbálj ki több algoritmust az előző feladatra, röviden vesd össze az eredményeket, minden az előző feladatban választott algoritmuson túli optimalizációs algoritmus kipróbálásáért további 70 pontot könyvelhetsz el!

99 A Debreceni Egyetem programozói évkönyve 69 / ábra. Az A* algoritmus és a Dijkstra algoritmus eredménye ugyanarra az inputra Budapest és Debrecen között. Megoldotta: Balkus Gergő A tizenegyedik labor A kötelező olvasmány erre a laborra a [JAVAKONYV] tankönyvii/ értő olvasással és legalább két példa tesztelésével, illetve a egyszeri elolvasása. Továbbá a source/robotauto/elotanulmanyok/openstreetmap/norbi/justine-car-window csomagbeli Java forrásából legalább két résznek nézzünk utána (meg tudjuk mutatni, mit kerestünk és megmutatni a könyvben, hogy mit találtunk) az imént megadott Swinges olvasmányainkban! Labormérés Mennyi a justine-car-window projekt legnagyobb ciklomatikus komplexitású függvénye és mennyi pontosan a szóban forgó érték? (az első 10 pont) Az emulátor platform traffic programja debug módban fordítva szöveges üzeneteivel elrontja, hogy a kimenetét a justine-car-window úgy tudja átvenni a csővezetékből, hogy azt sikeresen meg is tudja jeleníteni... fix it! (az első három 30 pont) További pontgyűjtő feladatok A csomagból kivettem az okos autók vezérlését, azaz a SmartCar::step osztály lényegi részét, írj erre saját implementációt, hogy a rendőrök elkapják a gengsztereket: ne routing-ot használjanak, hanem egyszerűen a térkép gráfon arra az élre lépjenek, amely közelebb visz egy gengszterhez! (nem hegylakó, 80 pont) A tizenkettedik és az utolsó labor Labormérés Fejleszd tovább a rendőr ágenst, hogy ne szimpla távolság alapján válassza ki a legközelebbi gengsztert, hanem a hozzájuk vezető utak alapján számoljon! (200 pont az első 3 hallgatónak) Kvalifikáld magad a Robotautó Világbajnokság - Debrecen viadalra! Ez 100-ból 1 rendőrrel 6 gengszter elkapását jelenti 10 perc alatt. (200 pont) A kvalifikációs feltételek mellett aki x gengsztert elkap valamelyik laboron, annak (x-6)*100 pontot ajánlok fel, hogy katalizáljam a kliensek fejlesztését a verseny előtt. A kvalifikált hallgatók a laborokon játszhatnak egymással párban ugyanarra a forgalmi szerverre csatlakozva, a győztes 100 pont, a vesztes 50 (egy pár egyet játszhat, ez ugyanaz mint tavaly az edzőmeccsek).

100 A Debreceni Egyetem programozói évkönyve 70 / További pontgyűjtő feladatok Jelentkezz a Robotautó Világbajnokság - Debrecen viadalra! (max. három fős csapatok, egy fő egy csapatban lehet). (200 pont) Jelentkezz a Robotautó Világbajnokság - Debrecen viadalra! (max. három fős csapatok, de a mi kurzusunk hallgatója csak tutor ebben a csapatban, a csapat többi tagja más hazai egyetemről kell kikerüljön). (400 pont) Jelentkezz a Robotautó Világbajnokság - Debrecen viadalra! (max. három fős csapatok, de a mi kurzusunk hallgatója csak tutor ebben a csapatban, a csapat többi tagja külföldi egyetemről kell kikerüljön). (600 pont) Készíts egy promó videót a YouTube-ra a Robotautó Világbajnokság - Debrecen viadalra! (200 pont) Készíts egy promó videót a YouTube-ra a kurzusunkról (ölelje fel a prog1 és prog2-t egyaránt, akár a prog1-es hasonló videódat is kiegészítheted természetesen)! (200 pont)

101 A Debreceni Egyetem programozói évkönyve 71 / fejezet Robotfocis programok A következő feladatok a robotfocival kapcsolatosak, ha nem vagy ismerős a témában, de előre akarsz készülni, akkor indulj el erről a linkről: A reguláris képzés kapcsán lásd még a bajnokságunkat és a kupánkat! 7.1. Bemelegítés Itt a hegylakó szabály a téma fontossága miatt fel van lazítva: feladatonként az első 8 számolható el, tutorrendszer támogatott a megoldásnál és a tutor-tutoriált lehet azonos önbesorolású! Legyen kapus a kapus Ez a feladat megyegyezik 8. labor hasonló nevű feladatával (4 pont) D RCSS ágensek Készíts egy olyan 2D RCSS ágenst, amely a balhátvéd pozíciójában áll és forog egyfolytában, rövid YouTube videóban mutasd be! (6 pont) Segít: ~nbatfai/konyvek/prop/prop.book.xml.html#konnyebb oldalvonaltól oldalvonalig (hosszában) oda-vissza masírozik a pályán, rövid YouTube videóban mutasd be! (6 pont) (itt van triviális trükk, az előző help mellett olvasd el a manual pdf doksiban a dash parancs paraméterezését :) a csapat saját felállásban álljon fel, rövid YouTube videóban mutasd be! (6 pont) Segít: konyvek/prop/prop.book.xml.html#bolyongofcpp D RCSS multiágensek Készíts olyan 2D RCSS ágensekből álló robotfoci futball csapatot, amely betömörül a saját tizenhatosára, eredményként játssz egy meccset az Agent2D-vel, vagy valamelyik Forest csapattal a PROP könyvből és egy rövid kis videón mutasd be ennek részletét a YouTube-on (12 pont) betömörül a saját gólvonalára, eredményként játssz egy meccset az Agent2D-vel, vagy valamelyik Forest csapattal a PROP könyvből és egy rövid kis videón mutasd be ennek részletét a YouTube-on (12 pont)

102 A Debreceni Egyetem programozói évkönyve 72 / 404 oldalvonaltól oldalvonalig (hosszában) oda-vissza masírozik a pályán, eredményként játssz egy meccset az Agent2D-vel, vagy valamelyik Forest csapattal a PROP könyvből és egy rövid kis videón mutasd be ennek részletét a YouTube-on (10 pont) csordaként követi a labdát, eredményként játssz egy meccset az Agent2D-vel, vagy valamelyik Forest csapattal a PROP könyvből és egy rövid kis videón mutasd be ennek részletét a YouTube-on (12 pont) Segít: Versenynaptár Készíts olyan programot, amely elkészíti a versenynaptárat! (25 points) A program parancssorában kapja a csapatneveket és generálja le a bajnokság mérkőzés-beosztását. Fontos, hogy időpontokhoz - ki játszik kivel párosításokat adjon és nyilván egy hétvégén minden csapat egy meccset játsszon! Lásd például a tavalyi beosztást: a_nyolcadik_labor_anyaga. A feladat megoldását Deregi Diána készítette. A forrásfájl megtalálható a../source/kezdo/elsocpp/versenynaptar/- versenynaptar.cpp fájlban, ahol mellékelve van egy leírás az algoritmusról és a program működéséről Robotfoci logó Készítsd el robotfoci csapatod logóját! Indulj ki például megfelelő foresztes csapatból, de a logó legyen rendben szerzői jogi szempontból (nincs a tutor-tutoriált relációra önbesorolási korlátozás és nincs hegylakó szabály, az első 20 hallgató könyvelheti el, 20 pont) Szavazás feladat A mintájára, ugyanolyan pontozás mellett szervezd meg a Facebook szavazást! A 10 jelöltnek az rcssmonitor-be betöltött meccskép pillanatfelvételét kell megmutatnia és a logónak szerzői jogi szempontból rendben kelle lennie! Az oldal elkészült, lehet nevezni: (A szavazási oldalt készítette: Szálku Tibor, az oldal törlésre került a szavazás lezárulta után 1 hónappal) Logó-forráskód generátor feladat Készíts olyan programot, amely bemenetként a png logót kapja, kimenete pedig az ennek megfelelő forráskód, amelyet be lehet illeszteni az online-coach ágens kódjába! (30 pont) A feladat megoldását Tamics Ádám készítette, tutor Tóth Máté. A forrásfájl megtalálható a../source/kezdo/elsoqt/- logogenerator/logo_gui.pro fájlban/mappában.

103 A Debreceni Egyetem programozói évkönyve 73 / fejezet Szuperszámítógépes programok Ezek a feladatok nem választhatóak, hanem meghívással működnek, amely minden adott feladat esetén egyedi Tízből kilencszer mi nyertünk volna Hangzik el sokszor a mérkőzések után ez a tipikus mondat az edzői nyilatkozatokban. Hálás mondat, mert ellenőrizhetetlen: az emberekből álló játékosokkal a mérkőzés után nem lehet egy újabbat és még egy újabbat és még egy újabbat játszatni, hogy kirajzolódjon ez a tízből kilencszer arány. Meg lehet viszont tenni az ágensekkel és meg is tesszük a Debreceni szuperszámítógépen! A bajnokságunk csapatainak teljesítményét fogjuk így vizsgálni. Eredményeinket pedig tudományos közleményben publikáljuk. Ennek megfelelően ebben a feladatban az vehet részt, aki a bajnokságba sikerrel nevez és részt vesz. Az egyszerűsített szervert futtatjuk, ez korábban probléma volt a gépen, mert nem volt C++11 támogató fordító fent, most ez nem fog gondot okozni, mert láthatóan: [nbatfai@desteny ~]$ ssh -l norbi login.debrecen.hpc.niif.hu norbi@debrecen[service0] ~ (0)$ module load gcc norbi@debrecen[service0] ~ (0)$ g++ -v Using built-in specs. COLLECT_GCC=g++ COLLECT_LTO_WRAPPER=/mnt/nfs3/home/opt/nce/packages/global/gcc/4.7.2/bin/../libexec/gcc/ - x86_64-unknown-linux-gnu/4.7.2/lto-wrapper Target: x86_64-unknown-linux-gnu Configured with:./configure --prefix=/opt/nce/packages/global/gcc/4.7.2/ --with-gmp=/opt/ - nce/packages/global/gmp/ with-mpfr=/opt/nce/packages/global/mpfr/ with-mpc - =/opt/nce/packages/global/mpc/1.0.1 Thread model: posix gcc version (GCC) norbi@debrecen[service0] ~ (0)$ A Debreceni szuperszámítógépet a [PARP] könyvünk részéből ismerheted meg, ahonnan idézve: az előtét gép 4 darab 6 magos processzort (processor: 0-23) tartalmaz: norbi@debrecen[service0] ~ (0)$ more /proc/cpuinfo processor : 0 vendor_id : GenuineIntel cpu family : 6 model : 44 model name : Intel(R) Xeon(R) CPU 2.67GHz stepping : 2 microcode : 19 cpu MHz : cache size : KB

104 A Debreceni Egyetem programozói évkönyve 74 / 404 physical id : 0 siblings : 12 core id : 0 cpu cores : 6 apicid : 0 initial apicid : 0 fpu : yes fpu_exception : yes cpuid level : 11 wp : yes flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe syscall nx pdpe1gb rdt scp lm constant_tsc arch_perfmon pebs bts rep_good nopl xtopology nonstop_tsc ap erfmperf pni dtes64 monitor ds_cpl vmx smx est tm2 ssse3 cx16 xtpr pdcm pcid dca sse4_1 sse4_2 popcnt lahf_lm ida arat epb dtherm tpr_shadow vnmi flexpriority e pt vpid bogomips : clflush size : 64 cache_alignment : 64 address sizes : 40 bits physical, 48 bits virtual power management: ezen a gépen történik a programok fordítása, s innen küldjük a feladatot a szuperszámítógépre, illetve az eredményeket is itt kapjuk meg. A szuperszámítógépet tehát közvetlenül nem érjük el felhasználóként, hanem csak az előtét szerverről az Oracle Grid Engine parancsaival. A szuperszámítógép maga az SGI Altix ICE 8400 EX 256 darab 6 magos processzor, ahol az 1536=256*6 mag 128 darab 12 magos csomópontba van szervezve: norbi@debrecen[service0] ~ (0)$ qconf -sel wc -l 128

105 A Debreceni Egyetem programozói évkönyve 75 / fejezet A só programok A következő feladatok a félév sóját alkotják, bárki exponálhat bennük, aki tud Genesis Patch

106 A Debreceni Egyetem programozói évkönyve 76 / fejezet Egyéb feladatok A következő feladatok tárgya nem szükségképpen a hardcore kódolás, illetve bárki exponálhat bennük, akiben feléled adott feladat irányában az érdeklődés Operációs rendszerekkel kapcsolatos alapvető feladatok A GNU/Linux kernellel kapcsolatos feladatok Kernelfordítás Fordíts kernelt a Linux rendszereden! (10 pont.) A megoldásban ne szerepeljenek kép alapú pillanatfelvételek, de röviden térj ki az esetleges problémás lépésekre; illetve jelölj olyan custom feature-öket amelyeket beállítottál az eredményül előálló új, custom kerneledbe! Megoldás és megjegyzés A feladatot elkészítette: Gyügyei Tamás Az előadáson résztvevők közül megoldotta: Szálku Tibor, Orbán István Sándor, Tuza József, Fekete Sándor, Nad Sabolch, Nagykéri Bence, Badó Gergely József, Szabó Bence, Konyári László, Abai Richárd, Kovács-Ferenc Norbert Telepítéssel és virtualizációval kapcsolatos feladatok Dual-boot Alakítsd dual-boot-ossá a géped! (10 pont, ugyanazon a gépen párhuzamosan további rendszerek nem virtualizált telepítése újabb 10 pont rendszerenként.) Legalább az egyik rendszer legyen nyílt forráskódú. A megoldásban ne szerepeljenek kép alapú pillanatfelvételek, de röviden térj ki az esetleges problémás lépésekre, például a MBR írására. Megoldás és megjegyzés A feladatot elkészítette: Dalmadi Zoltán Feladat bizonyítása elküldve Besenczi Renátónak. Használt operációs rendszerek: Windows XP és Manjaro Linux. os-prober csomag telepítésével a grub menü helyesen létrejött, nem kellett grub repair.

107 A Debreceni Egyetem programozói évkönyve 77 / MINIX virtualizálás Virtualizálj MINIX-et! (10 pont.) A megoldásban ne szerepeljenek kép alapú pillanatfelvételek, de röviden térj ki az esetleges problémás lépésekre; illetve jelölj meg pár feature-t a legújabb MINIX verzióból! Megoldás és megjegyzés A feladat kidolgozását Kis Dávid készítette OpenSolaris virtualizálás Virtualizálj OpenSolaris-t! (10 pont.) A megoldásban ne szerepeljenek kép alapú pillanatfelvételek, de röviden térj ki az esetleges problémás lépésekre; illetve jelölj meg pár feature-t a legújabb MINIX verzióból! Megoldás és megjegyzés A feladatot elkészítette: Dalmadi Zoltán Feladat bizonyítása elküldve Besenczi Renátónak. Használt opensolaris verzió: opensolaris 11. A telepítés simán ment, viszont igen erőforrás igényes a többi virtualizált operációs rendszerhez képest. Jelentősebb új feature-ök: UEFI boot támogatás, fejlettebb csomagkezelő rendszer, felhasználóbarátabb telepítő, hálózat virtualizáció, régebbi processzorarchitektúrák támogatásának megszüntetése BSD virtualizálás Virtualizálj BSD-t! (10 pont.) A megoldásban ne szerepeljenek kép alapú pillanatfelvételek, de röviden térj ki az esetleges problémás lépésekre; illetve jelölj meg pár feature-t a legújabb MINIX verzióból! Megoldás és megjegyzés A feladatot elkészítette: Dalmadi Zoltán Feladat bizonyítása elküldve Besenczi Renátónak. Használt disztribúció: freebsd A telepítésnél nem volt probléma. Néhány jelentősebb új feature: szélesebb videókártya támogatás, új, fejlettebb csomagkezelő rendszer használata Az információs-távolsággal kapcsolatos feladatok Az alábbi feladatok kizárják egymást Genomok összehasonlítása A második előadásban megismert normalizált tömörítési távolsággal (CompLearn csomag) készítsd el a 2. kromók vizsgálatával az általad kiválasztott élőlények filogenetikai fáját! (10 pont) Lásd még a posztot is!

108 A Debreceni Egyetem programozói évkönyve 78 / 404 Megoldás és megjegyzés A feladat megoldását Deregi Diána készítette el SZT tisztek gráfja A második előadásban megismert normalizált tömörítési távolsággal (CompLearn csomag) tárd fel a szigoruantitkos.hu SZTtisztjeinek kapcsolatait! (10 pont) Lásd még a posztot is! Design-al kapcsolatos feladatok A jelen fejezet alatti pontok feladataiból több megoldás (ha mást nem írunk az adott feladatnál, akkor három) változat is bekerülhet az évkönyvbe. Az elkészített erőforrások licencéről is nyilatkoznod kell, ez legyen legalább olyan szabad, hogy ebben a könyvben is tudjuk szerepeltetni! Az UDProg évkönyv logója Készíts logót az évkönyvhöz! (5 pont.) Itt nem a hegylakó-szabály érvényes, hanem 10 tervet lehet beküldeni. Minden logónak tiszta eszközökkel kell készülnie (például GIMP) és az esetlegesen felhasznált elemek szerzői joga kapcsán is nyilatkoznia kell a készítőnek. Továbbá meg kell adnia a saját munkájának licencét, ami olyan legyen, hogy lehessen ennek a GNU-s dokumentumnak is a logója. Megoldás és megjegyzés /source/logo/evkonyv_logo_1.jpg feltöltve. - Horváth Dániel../source/logo/proud.jpg feltöltve. Kistamás Dávid../source/logo/logo1.png feltöltve. Vona Márton../source/logo/logo2.png feltöltve. Vona Márton../source/logo/logo3.png feltöltve. Vona Márton../source/logo/logo4.png feltöltve. Vona Márton../source/logo/logo5.png feltöltve. Vona Márton../source/logo/logo_8.png feltöltve. Kovács-Ferenc Norbert../source/logo/kesz.png feltöltve. Apró Anikó Szavazás feladat: az UDProg évkönyv logójának szavazása 10 pont üti a markát, aki először megszervezi a Facebook-on az évkönyv logójának megszavazását (saját profilon, külön az UDPROG-nak csak akkor hozzunk létre esetlegesen, ha ez mindennemű költség nélkül megtehető). Tehát felteszi a képeket, ahol szavaznánk azokra, a március 30-ig legtöbb lájkot kapó lesz a hivatalos logó! Az az első, aki először megírja a Facebook szavazások című beszélgetésre kommentként az URL-t. A szavazás eredményének megfelelően az aspiránsok a kevesebb lájk felé haladva 10-től kapnak további pontot, helyezésenként egyesével csökkentve. A feladatot megoldotta: Szálku Tibor, a szavazási oldal megszűnt 2 hónappal a szavazás után Egyéb segítő feladatok Másoló konstruktor demó A program szemlélteti a különbséget az alapértelmezett és az egyéni másoló konstruktorok között, valamint az ún. "shallow copy" és "deep copy" fogalmakat is (15 pont).

109 A Debreceni Egyetem programozói évkönyve 79 / 404 Megoldás és megjegyzés A demót készítette: Dalmadi Zoltán Mozgató konstruktor demó Egészítsd ki az előző feladat megoldását, hogy demózza a másoló értékadást, mozgató ctor-t és értékadást is (az előző feladat után készíthető és kizáró feladat, 10 pont)! Promóciós feladatok Ezek a feladatok a nem ebből a feladat-csokorból megszerzett 60 pont felett számolhatóak el (gyakorlatilag azok csinálhatják meg, akiknek már megvan a 60 pontjuk), viszont nincs korlátozás az elszámolók számára, azaz kvázi mindenki elkészítheti Promóciós robotfoci-videó Készítsd el például a DeadlyTeam mintájára a saját robotfoci csapatod promóciós videóját és tedd fel a YouTube-ra (40 pont) Szavazás feladat: promóciós robotfoci-videó Szervezd meg a Facebook-on az előző feladat videóinak szavazását (ha techikailag csak úgy oldható meg, akkor nevezők egy képet küldjenek a videóból és a leírásban legyen a link a YouTube-ra). A szavazó lap és a szavazás szervezéséért 15 pont, nevezés 8 pont, 10 hallgató nevezhet, a sorrend pontozása: 20, 15, 10, 5, 4, 3, 3, 2, 2, 2, a verseny lezárása május 5. Elkészítettem a szavazáshoz szükséges Facebook paget, Bereczki László Promóciós kurzus-videó Készítsd el a kurzusunk promóciós videóját és tedd fel a YouTube-ra, a videóból derüljön ki, hogy melyik tanév melyik féléve, a kurzus neve, szak, ki vagy Te, ki az előadó, ki a laborvezető, ha valakinek felhasználod erőforrásait, akkor ki a valaki (mert a kurzus példái tipikusan GPL-esek, tehát használhatod mondjuk az ilyen licencű évfolyamtársaid kódjait, mondjuk biomorfok rajzolására, hogy ilyenekkel is feldobd a videót). A videót open source eszközökkel kell készíteni, javaslom például a kdenlive szerkesztőt (amely akár kép a képben effektet is tud). Tipp: a videó tartalmazhat a repó gource-os vizualizációjából részeket, bemutathatja a félév példáit, meginterjúvolhatod, akár kép a képben a hallgató társaidat, üzenhetsz a középiskolásoknak, az iparnak (persze csak jót lehet mondani a kurzusról :) (80 pont) Szavazás feladat: promóciós kurzus-videó Szervezd meg a Facebook-on az előző feladat videóinak szavazását (ha techikailag csak úgy oldható meg, akkor nevezők egy képet küldjenek a videóból és a leírásban legyen a link a YouTube-ra). A szavazó lap és a szavazás szervezéséért 20 pont, nevezés 8 pont, 20 hallgató nevezhet, a sorrend pontozása: 30, 20, 10, 5, 4, 3, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, a verseny lezárása május 12.

110 A Debreceni Egyetem programozói évkönyve 80 / 404 Elkészítettem a szavazáshoz szükséges Facebook paget, Bereczki László Promóciós kurzus-prezi Készítsd el a kurzusunk promóciós prezijét (nyilván a prezi ingyenes részén), a videóból derüljön ki, hogy melyik tanév melyik féléve, a kurzus neve, szak, ki vagy Te, ki az előadó, ki a laborvezető, ha valakinek felhasználod erőforrásait, akkor ki a valaki (mert a kurzus példái tipikusan GPL-esek, tehát használhatod mondjuk az ilyen licencű évfolyamtársaid kódjait, mondjuk biomorfok rajzolására, hogy ilyenekkel is feldobd a videót). (30 pont) Szavazás feladat: promóciós kurzus-prezi Szervezd meg a Facebook-on az előző feladat prezijeinek szavazását (ha techikailag csak úgy oldható meg, akkor nevezők egy képet küldjenek a preziből és a leírásban legyen a link a prezire). A szavazó lap és a szavazás szervezéséért 20 pont, nevezés 8 pont, 20 hallgató nevezhet, a sorrend pontozása: 30, 20, 10, 5, 4, 3, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, a verseny lezárása május 19. A szavazás elérhető ezen a Facebook oldalon. (Deregi Diána) Dokumentálással kapcsolatos feladatok UML A kurzusbeli programoknak készítsd el (reverse engineering jelleggel a forrásból) az UML osztálydiagramját (csak OO source programokat használhatsz természetesen, mondjuk például az umbrello-t). (3 pont programonként, hegylakó szabály él, egy főnek max. 15 pont számolható el) Doxygen A kurzusbeli OO programokat kommentezd be, hogy a Doxygen-el el lehessen készíteni a jó minőségű dokumentációt. (7 pont programonként, hegylakó szabály él, egy főnek max. 28 pont számolható el) Lásd a Doxygen Documenting the code kapcsolódó doksi részletét! Illetve a..source/labor/kartyak/int5/ int.h-ban magam is elkezdtem Tesztelési feladatok Készíts a A tesztelés csóválja a kutyát mintájára teszteseteket az évkönyv programjaihoz (10 pont programonként, hegylakó szabály, tutor-rendszer él, egy hallgató maximum 30 pontot számolhat el ebből).

111 A Debreceni Egyetem programozói évkönyve 81 / fejezet Tankönyvi feladatok Ezek kezdő szinten (vagy kezdő szinten és tutor rendszerben) elszámolható feladatok A [STROUSTRUP] könyv feladatai A megoldások részben nem kell a feladatot leírni, csak a (fejezetszám stb. tagokkal) minősített sorszámát megadni. Minden feladat egységesen 5 pont, hegylakó-szabály érvényes. A megoldások kapcsán források a source/tankonyvi mappába kerüljenek egy olyan könyvtárba, ami a feladat sorszámának minősített nevével egyezik meg. Fontos, hogy a feladatok számát (és magukat a feladatokat) ne a könyvből nézzétek, hanem az egységes hivatkozás miatt innen: 4thExercises.pdf! X.2[1] feladat Mit jelent a (*2.5) egy feladat szövege előtt? A feladat megoldását Kistamás Dávid készítette X.2[4] feladat Mik a főbb programozási stílusok C++ban? A feladat megoldását Kistamás Dávid készítette X.2[7] feladat Sorold fel, hogy miket tartalmaz a C++ Standard Library-ja.

112 A Debreceni Egyetem programozói évkönyve 82 / 404 A feladat megoldását Kistamás Dávid készítette X.2[9] feladat Sorolj fel három (vagy több) előnyt attól, hogy egy könyvtár része a standard könyvtárnak. A feladat megoldását Gyügyei Tamás készítette X.2[10] feladat Sorolj fel 20 fontosabb dolgot amiből a C++ kifejlődött. A feladat megoldását Gyügyei Tamás készítette X.3[2] feladat Mit csinál a fordító? És mit a linker? A feladat megoldását Kistamás Dávid készítette X.3[3] feladat Egyszerű Hello world program fordítása és futtatása. A feladat megoldását Kistamás Dávid készítette.

113 A Debreceni Egyetem programozói évkönyve 83 / X.3[4] feladat Sorolj fel 3 C++ fordítót. A feladat megoldását Kistamás Dávid készítette X.3[5] feladat Írj ki egy bool-t, egy char-t, egy int-et, egy double-t és egy stringet cout-tal. A feladat megoldását Kistamás Dávid készítette X.3[6] feladat Olvass be egy bool-t, egy char-t, egy int-et, egy double-t és egy stringet cin-nel. A feladat megoldását Kistamás Dávid készítette X.3[7] feladat Mi az az invariáns, mire is jó tulajdonképpen? A feladat megoldását Kistamás Dávid készítette X.5[2] feladat Sorolj fel 5 Standard Library tárolót! A feladat megoldását Kistamás Dávid készítette.

114 A Debreceni Egyetem programozói évkönyve 84 / X.5[3] feladat Sorolj fel 5 Standard Library algoritmust! A feladat megoldását Kistamás Dávid készítette X.5[4] feladat Sorolj fel 5 Standard Library algoritmust! A feladat megoldását Kistamás Dávid készítette X.5[5] feladat Olvass be egy stringet (name), egy int-et (age), majd írd ki ezeket cout-tal egy sorba. A feladat megoldását Kistamás Dávid készítette X.5[6] feladat Az X.5.5 feladat forrásfájlját felhasználva tárolj néhány név és életkor párost egy osztályban. Olvasd be őket, majd írasd ki a saját beolvasó és kiíró függvényeiddel. A feladat megoldását Kistamás Dávid készítette X.5[7] feladat Inicializálj egy egész típusú vektort az 5, 9, -1, 200, 0 értékekkel, írasd ki, rendezd, majd írasd ki ismét! A feladat megoldását Kistamás Dávid készítette.

115 A Debreceni Egyetem programozói évkönyve 85 / X.5[8] feladat Írd át az előző feladatot string típusú vektorra, amelynek kezdőértékei "Kanto", "Plato", "Aristotle", "Kierkegard", és "Hume" és végezd el ugyanazt rajta. A feladat megoldását Kistamás Dávid készítette X.5[9] feladat Nyiss meg egy fájlt írási joggal, majd írass bele pár száz egész számot. A feladat megoldását Kistamás Dávid készítette X.5[10] feladat Az előzőleg elkészített fájlt nyisd meg olvasási módban és olvasd be a tartalmát. A feladat megoldását Kistamás Dávid készítette X.6[2] feladat Hello és World szavak váltakozása másodpercenként. A feladat megoldását Akai József Zsolt készítette X.7[1] feladat Futtassuk le a Helló, világ! programot ( 3.2). Ez a gyakorlat teszteli a szerkesztés és forditás helyes használatát. A feladat megoldását Gyügyei Tamás készítette.

116 A Debreceni Egyetem programozói évkönyve 86 / X.7[2] feladat Írjunk programot, amely a signed szót írja ki ha a sima karakterek (char) előjelesek az implementációdban, egyébként ha előjel nélküliek, akkor az unsigned szót írja ki. A feladat megoldását Kistamás Dávid készítette X.7[6] feladat Írjunk programot, amely kiírja az alaptípusok, néhány szabadon választott mutatótípus és néhány szabadon választott felsoroló típus méretét. Használjuk a sizeof operátort A feladat megoldását Gyügyei Tamás készítette X.7[7] feladat Írjunk programot, amely kiírja az a - z betűket és a 0-9 számjegyeket, valamint a hozzájuk tartozó egész értékeket. Végezzük el ugyanezt a többi kiírható karakterre is. Csináljuk meg ugyanezt hexadecimális jelöléssel. A feladat megoldását Gyügyei Tamás készítette X.7[8] feladat Írd ki a bool, char, short, int, long, long long, float, double, long double, unsigned és unsigned long minimális és maximális értékeit a rendszereden. A feladat megoldását Kistamás Dávid készítette X.7[9] feladat Írd ki a bool, char, short, int, long, long long, float, double, long double, unsigned és unsigned long méretét byte-ban. A feladat megoldását Kistamás Dávid készítette.

117 A Debreceni Egyetem programozói évkönyve 87 / X.7[12] feladat Mi a leghosszabb lokális név, amit a C++ programokban használhatunk a rendszerünkben? Mi a leghosszabb külsõ név, amit a C++ programokban használhatunk a rendszerünkben? Van-e megszorítás a nevekben használható karakterekre? A feladat megoldását Gyügyei Tamás készítette X.7[13] feladat Írjunk egy olyan ciklust, amely a 4, 5, 9, 17, 12 értékeket írja ki tömb vagy vektor használata nélkül. A feladat megoldását Forgács Péter készítette Haraszti Péter tutoriálásával X.8[1] feladat Vezessük be a következőket: karakterre hivatkozó mutató, 10 egészből álló tömb, 10 egészből álló tömb referenciája, karakterláncokból álló tömbre hivatkozó mutató, karakterre hivatkozó mutatóra hivatkozó mutató, konstans egész, konstans egészre hivatkozó mutató, egészre hivatkozó konstans mutató. Mindegyiknek adjunk kezdeti értéket. A feladat megoldását Gyügyei Tamás készítette X.8[3] feladat Használjunk typedef-et a következők meghatározására: unsigned char, const unsigned char, egészre hivatkozó mutató, karakterre hivatkozó mutatóra hivatkozó mutató, karaktertömbökre hivatkozó mutató; 7 elemű, egészre hivatkozó mutatókból álló tömb; 7 elemű, egészre hivatkozó mutatókból álló tömbre hivatkozó mutató; egészre hivatkozó mutatókat tartalmazó 7 elemű tömbökből álló 8 elemű tömb. A feladat megoldását Gyügyei Tamás készítette X.8[4] feladat Adott két char* típusú pointer amelyek egy tömb valamelyik elemére mutatnak. Írd ki a két pointer közötti távolságot!

118 A Debreceni Egyetem programozói évkönyve 88 / 404 A feladat megoldását Kistamás Dávid készítette X.8[5] feladat Adott két int* típusú pointer amelyek egy tömb valamelyik elemére mutatnak. Írd ki a két pointer közötti távolságot! A feladat megoldását Kistamás Dávid készítette X.8[7] feladat Két változó cseréje A feladat megoldását Akai József Zsolt készítette X.8[8] feladat Mi az str tömb mérete a következő példában? char str[ ] = "rövid karakterlánc"; Mi a "rövid karakterlánc" hossza? A feladat megoldását Gyügyei Tamás készítette X.8[9] feladat Definiálj f(char), g(charreferencia), h(const charreferencia) függvényeket, és add át nekik paraméterül a következőket: a, 49, 3300, c, uc, sc, ahol c karakter, uc előjel nélküli karakter, sc előjeles karakter. Mely függvény hívások legálisak? Melyek okozzák hogy a fordító átmeneti változót hozzon létre? A feladat megoldását Kistamás Dávid készítette.

119 A Debreceni Egyetem programozói évkönyve 89 / X.8[10] feladat Adjunk meg egy karakterláncokból álló tömböt, ahol a karakterláncok a hónapok neveit tartalmazzák. Írjuk ki ezeket. Adjuk át a tömböt egy függvénynek, amely kiírja a karakterláncokat. A feladat megoldását Gyügyei Tamás készítette X.8[11] feladat Olvassunk be szavakat a standard inputról. Használjuk a quit szót hogy megálljon a program. Írjuk ki a szavakat a begépelés sorrendjében. Ne írjunk ki egy szót kétszer. Módosítsuk a programot úgy, hogy mielőtt kiírja a szavakat, rendezze azokat. A feladat megoldását Kistamás Dávid készítette X.8[12] feladat Adott karakterek megszámolása a "xabaacbaxabb" szövegben. A feladat megoldását Akai József Zsolt készítette (Busák Zoltán Tutor segítségével) X.9[1] feladat Definiáljunk egy struktúrát bool, char, int, long, double és long double típusokkal, mindegyikből eggyel. Rendezzük sorba a tagokat úgy, hogy a lehető legnagyobb illetve legkisebb méretű struktúrát kapjuk. A feladat megoldását Forgács Péter készítette Haraszti Péter tutoriálásával X.9[2] feladat Napok kiíratása havonta A feladat megoldását Akai József Zsolt készítette (Busák Zoltán Tutor segítségével)

120 A Debreceni Egyetem programozói évkönyve 90 / X.9[4] feladat Adjunk meg egy Date struktúrát dátumok ábrázolásához. Írjunk olyan függvényt, ami Date-eket olvas be a bemenetrő1l, olyat, ami Date-eket ír a kimenetre, és olyat, ami egy dátummal ad kezdőértéket a Date-nek. Program eleje szokott módon kezdődik, iostream, namespace, struct megadása. A feladat megoldását Gyügyei Tamás készítette X.10[1] feladat Írjuk át a megadott for ciklust vele egyenértékű while ciklusra, olyanra, hogy pointert használjon a bejárásra, valamint vele egyenértékű range-for ciklusra. A feladat megoldását Kistamás Dávid készítette X.11[1] feladat Zárójelezzük teljesen a következő kifejezéseket A feladat megoldását Gyügyei Tamás készítette X.11[2] feladat Olvassuk be üres hellyel elválasztott (név- és érték) párok sorozatát, ahol a név egyetlen üres hellyel elválasztott szó, az érték pedig egy egész vagy lebegőpontos érték. Írjuk ki az összes névre vonatkozó összeget és számtani közepet. A feladat megoldását Gyügyei Tamás készítette X.11[3] feladat Írjuk meg a bitenkénti logikai operátorok ( 6.2.4) értéktáblázatát a 0 és 1 operandusok összes lehetséges párosítására. A feladat megoldását Gyügyei Tamás készítette.

121 A Debreceni Egyetem programozói évkönyve 91 / X.11[6] feladat Zárójelezzük teljesen a következő kifejezéseket A feladat megoldását Gyügyei Tamás készítette X.11[10] feladat Írjunk rev() függvényt amely tükrözi a neki paraméterül adott sztringet, azaz rev(p) esetén p első karaktere lesz az utolsó és így tovább. A feladat megoldását Kistamás Dávid készítette X.13[1] feladat Deklaráljuk a következõket: függvény, amelynek egy karakterre hivatkozó mutató és egy egészre mutató referencia paramétere van és nem ad vissza értéket; ilyen függvényre hivatkozó mutató; függvény, amelynek ilyen mutató paramétere van; függvény, amely ilyen mutatót ad vissza. Írjuk meg azt a függvényt, amelynek egy ilyen mutatójú paramétere van és visszatérési értékként paraméterét adja vissza. A feladat megoldását Monori Fanny készítette X.13[2] feladat Mit jelent a következõ sor? Mire lehet jó? typedef int (& rifii) (int, int); A feladat megoldását Monori Fanny készítette X.13[3] feladat Írjunk egy Helló, világ!-szerű programot, ami parancssori paraméterként vesz egy nevet és kiírja, hogy Helló, név!. Módosítsuk ezt a programot úgy, hogy tetszőleges számú név paramétere lehessen és mondjon hellót minden egyes névvel. A feladat megoldását Gyügyei Tamás készítette.

122 A Debreceni Egyetem programozói évkönyve 92 / X.13[4] feladat Írjunk olyan programot, amely tetszőleges számú fájlt olvas be, melyek nevei parancssori paraméterként vannak megadva, és kiírja azokat egymás után a cout-ra. Mivel ez a program összefűzi a paramétereit, hogy megkapja a kimenetet, elnevezhetjük cat-nek. A feladat megoldását Gyügyei Tamás készítette X.13[9] feladat Írj egy függvényt ami invertál egy kétdimenziós tömböt (mátrixot). A feladat megoldását Forgács Péter készítette Haraszti Péter tutoriálásával. Kistamás Dávid eredetileg feltöltött feladatát Forgács Péter átnézte és linkedinen reportolta a bugot X.13[14] feladat Nézz meg néhány programot. Ezekből szűrd le, hogy hogyan használjuk a nagybetűket és az alulvonást a nevekben, valamint mikor használunk rövid neveket, mint például i vagy x? A feladat megoldását Kistamás Dávid készítette X.13[15] feladat Mi a baj az adott makrókkal? (forrásfájlban részletesen) A feladat megoldását Kistamás Dávid készítette X.13[20] feladat Írjunk olyan faktoriális függvényt, amely nem hívja meg önmagát. A feladat megoldását Gyügyei Tamás készítette.

123 A Debreceni Egyetem programozói évkönyve 93 / X.13[21] feladat Írjunk függvényeket, melyek az X.9[4]-ben lévő dátumhoz egy napot, hónapot illetve évet adnak. Írjunk egy olyan függvényt, amely megmondja egy dátumról, hogy a hét melyik napjára esett. Írjunk egy olyan függvényt, amely egy dátum utáni hétfő dátumát adja vissza. A feladat megoldását Forgács Péter készítette Haraszti Péter tutoriálásával X.17[4] feladat Definiáljunk egy Hisztogram nevű osztályt, amely számon tartja hány szám esett bizonyos intervallumokba amelyeket a konstruktorában határozunk meg. Készítsünk hozzá egy függvényt amely kiírja a hisztogramot. Kezeljük az intervallumon kívüli elemeket. A feladat megoldását Forgács Péter készítette Haraszti Péter tutoriálásával X.17[7] feladat Hozzunk létre egy osztályt, ami int-ek csoportján tud kezelni metszetet, uniót és szimmetrikus differenciát. A feladat megoldását Forgács Péter készítette Haraszti Péter tutoriálásával X.17[8] feladat Módosítsuk az X.17.7-et úgy, hogy láncolt listát használjunk. A feladat megoldását Forgács Péter készítette Haraszti Péter tutoriálásával X.17[13] feladat Modifikáljuk a hello world programot, hogy előtte és utána írja ki, hogy Initialize illetve Clean up, anélkül, hogy a main függvényt módosítanánk. A feladat megoldását Forgács Péter készítette Haraszti Péter tutoriálásával.

124 A Debreceni Egyetem programozói évkönyve 94 / X.19[4] feladat Definiáljunk egy osztályt ami kivitelez tetszőleges pontosságú aritmetikát. Teszteljük 1000! kiszámításával. A feladat megoldását Forgács Péter készítette Haraszti Péter tutoriálásával X.21[1] feladat Definiáljuk az alábbi osztályt: class Derivedone: public Base public: void iam() cout << "Derivedone\n"; ; Származtassunk belőle két osztályt és módosítsuk az iam függvényt, hogy a megfelelő osztályneveket írja ki. Hozzunk létre két ilyen objektumot és hívjuk meg rájuk az iam függvényt. Adjunk meg származtatott osztályra mutatókat a Base* mutatónak és hívjuk meg ezeken keresztül az iam függvényt. A feladat megoldását Forgács Péter készítette Haraszti Péter tutoriálásával X.32[1] feladat Hozzunk létre karakter típusú vektort, amely az ABC betűit tartalmazza sorrendben. Írjuk ki ezt a vektort, majd írjuk ki a fordítottját is. A feladat megoldását Kistamás Dávid készítette X.32[2] feladat Hozzunk létre sztring típusú vektort, amely tartalmazza a standard inputról kapott gyümölcsök nevét. Írjuk ki ezt a vektort rendezetten. A feladat megoldását Kistamás Dávid készítette X.32[3] feladat Az X.32[2] feladat vektorát felhasználva írassuk ki úgy a vektort, hogy minden szó első betűjét helyettesítjük az "a" karakterrel. A feladat megoldását Kistamás Dávid készítette.

125 A Debreceni Egyetem programozói évkönyve 95 / X.32[4] feladat Az X.32[2] feladat vektorát felhasználva a begépelt vektorból töröljünk ki minden olyan gyümölcsöt, amely "a" betűvel kezdődik. A feladat megoldását Kistamás Dávid készítette X.32[5] feladat Az X.32[2] feladat vektorát felhasználva a begépelt vektorból töröljünk ki minden citrus gyümölcsöt. A feladat megoldását Kistamás Dávid készítette X.32[6] feladat Az X.32[2] feladat vektorát felhasználva a begépelt vektorból töröljünk ki minden olyan gyümölcsöt, amelyet nem szeretek. A feladat megoldását Kistamás Dávid készítette X.37[1] feladat Írjunk egy függvényt ami két string konkatenációját adja vissza egy ponttal középen. Írjunk ugyanilyen függvényt ami csak C-stílusú eszközöket használ. A feladat megoldását Forgács Péter készítette Haraszti Péter tutoriálásával A [KR] könyv feladatai Ugyanúgy járjunk el, mint az előző tankönyv esetén, itt egységesen 3 pont számolható el példánként.

126 A Debreceni Egyetem programozói évkönyve 96 / gyakorlat Futtassa le a "Halló mindenki!" szöveget kiíró programot a saját rendszerén! Próbálja meg a program egyes részeit elhagyni és figyelje meg milyen hibajelzést ad a rendszer! A feladat megoldását Gyügyei Tamás készítette. A megoldást ellenőriztem splint-el, nem talált hibát. (Abai Richárd) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Próbálja ki, hogy mi történik, ha a printf argumentumában a \x jelsorozat szerepel (ahol \x a fenti listában nem szereplő escape jelsorozat)! A feladat megoldását Gyügyei Tamás készítette. A megoldást ellenőriztem splint-el, nem talált hibát. (Abai Richárd) gyakorlat Módosítsuk a hőmérséklet-átalakító programot úgy, hogy a táblázat fölé fejlécet is nyomtasson! A feladat megoldását Gyügyei Tamás készítette. A megoldást ellenőriztem splint-el, a kimentet a forrás melett egy fájlba helyeztem. (Veress Balázs) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjunk programot, amely a Celsius-fokban adott értékeket alakítja Fahrenheit-fokká! A feladat megoldását Ozsváth Jonathán készítette. Ezen link sorszámozása alapján készítettem: uw.hu/krc/index.html A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat. Módosítsuk a hőmérséklet-átalakító programot úgy, hogy a táblázatot fordított sorrendben, tehát 300 foktól 0 fokig nyomtassa ki!

127 A Debreceni Egyetem programozói évkönyve 97 / 404 A feladat megoldását Akai József Zsolt készítette. Másik megoldást készítette Ozsváth Jonathán. A feladatot splint-el ellenőriztem, 1 hibát talált.a splint-elés eredményét a splint mappába helyeztem el. (Józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Igazoljuk, hogy a getchar( )!= EOF kifejezés értéke valóban 0 vagy 1! A feladat megoldását Gyügyei Tamás készítette. A feladatot splint-el ellenőriztem, 1 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjunk programot, ami kiírja az EOF értékét! A feladat megoldását Ozsváth Jonathán készítette. A feladatot splint-el ellenőriztem, 1 hibát talált.a splint-elés eredményét a splint mappába helyeztem el. (Józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjunk programot, ami megszámolja a bemenetre adott szövegben lévő szóközöket, tabulátorokat és újsor-karaktereket! A feladat megoldását Ozsváth Jonathán készítette. A feladatot splint-el ellenőriztem, 3 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjunk programot, ami a bemenetre adott szöveget úgy másolja át a kimenetre, hogy közben az egy vagy több szóközből álló karaktersorozatokat egyetlen szóközzel helyettesíti! A feladat megoldását Ozsváth Jonathán készítette. A feladatot splint-el ellenőriztem 4 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba)

128 A Debreceni Egyetem programozói évkönyve 98 / gyakorlat Írjunk programot, ami a bemenetre adott szöveget úgy másolja át a kimenetre, hogy közben a tabulátorkaraktereket \t, a visszaléptetés- (backspace) karaktereket \b és a fordított törtvonal- (backslash) karaktereket \\ karakterekkel helyettesíti! Ezzel az átírással a tabulátor- és visszaléptetés-karakterek a nyomtatásban is láthatóvá válnak. A feladat megoldását Ozsváth Jonathán készítette. A feladatot splint-el ellenőriztem 8 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjunk programot, ami a bemenetére adott szöveg minden szavát új sorba írja ki! A feladat megoldását Ozsváth Jonathán készítette. A feladatot splint-el ellenőriztem 5 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjunk olyan programot, amely kinyomtatja a bemenetén előforduló szavak hosszúságának hisztogramját! (Függőleges verzió) A feladat megoldását Abai Richárd készítette. Forrás:../source/tankonyvi/KR/1.12.h.c A feladatot splint-el ellenőriztem 0 hibát talált.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjunk olyan programot, amely a beolvasott szöveget kisbetűssé alakítja át egy olyan lower függvény segítségével, amely c-vel tér vissza, ha c nem betű, és c kisbetűs megfelelőjét adja vissza, ha c betű! A feladat megoldását Preznyák László készítette. A feladatot splint-el ellenőriztem 4 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjunk programot, ami kinyomtatja a bemenetre adott különböző karakterek előfordulási gyakoriságának hisztogramját!

129 A Debreceni Egyetem programozói évkönyve 99 / 404 A feladat megoldását Ozsváth Jonathán készítette. A feladatot splint-el ellenőriztem 3 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjunk olyan programot amely minden olyan sort megjelenít, amely 80 karakternél hosszabb! A feladat megoldását Veress Balázs készítette. A feladatot splint-el ellenőriztem 5 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjunk olyan programot, amely eltávolítja a sorvégi szóközöket és tab karaktereket a bemenet minden sorából és törli az üres sorokat! A feladat megoldását Veress Balázs készítette. A feladatot splint-el ellenőriztem 7 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjunk olyan reverse(s) függvényt, amely megfordítja az s karakterláncot! Használjuk fel ezt a függvényt olyan program megírásához, amely soronként megfordítja a bemenetet! A feladat megoldását Veress Balázs készítette. A feladatot splint-el ellenőriztem 7 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjunk detab néven programot, amely a beolvasott szövegben talált tabulátorkaraktereket annyi szóközzel helyettesíti, amennyi a következő tabulátorpozícióig hátravan! Tételezzük fel, hogy a tabulátorpozíciók adottak, pl. minden n-edik oszlopban. Az n értékét változóként vagy szimbolikus állandóként célszerű megadni? A feladat megoldását Akai József Zsolt készítette (Busák Zoltán Tutor segítségével) A feladatot splint-el ellenőriztem 4 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba)

130 A Debreceni Egyetem programozói évkönyve 100 / gyakorlat Írjunk programot, ami meghatározza a signed és unsigned minősítőjű char, short, int és long típusú változók nagyságát a szabványos header állományokból vett megfelelő értékek kiírásával és közvetlen számítással! A feladat nehezebb, ha kiszámítjuk a nagyságokat és tovább nehezíthető, ha a lebegőpontos számok nagyságát is meg akarjuk határozni. A feladat megoldását Gyügyei Tamás készítette. A feladatot splint-el ellenőriztem 3 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjuk meg a squeeze(s1, s2) olyan változatát, amely az s1 karaktersorozatból töröl minden karaktert, ami az s2 karaktersorozatban megtalálható! A feladat megoldását Gyügyei Tamás készítette. A feladatot splint-el ellenőriztem 1 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjunk any(s1, s2) néven függvényt, amely visszatérési értékként megadja az s1 karaktersorozat azon legelső helyét, ahol az s2 karaktersorozat bármelyik karaktere előfordul! A függvény visszatérési értéke legyen -1, ha s1 egyetlen s2-beli karaktert sem tartalmaz. (Az strbrk standard könyvtári függvény ugyanezt teszi, csak visszatérési értékként az adott helyet kijelölő mutatót adja.) A feladat megoldását Akai József Zsolt készítette (Busák Zoltán Tutor segítségével) A feladatot splint-el ellenőriztem 1 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjuk meg a setbits(x, p, n, y) függvényt, amely egy olyan x értékkel tér vissza, amit úgy kap, hogy az x p-edik pozíciótól jobbra eső n bitje helyébe bemásolja y jobb szélső n bitjét, a többi bitet változatlanul hagyva! A feladat megoldását Ozsváth Jonathán készítette. A feladatot splint-el ellenőriztem 14 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba)

131 A Debreceni Egyetem programozói évkönyve 101 / gyakorlat Írjunk olyan rightsh(n, b) függvényt, amely b számú bitpozícióval jobbra történő biteltolást végez az n egész típusú mennyiségen! A feladat megoldását Veress Balázs készítette. A feladatot splint-el ellenőriztem 12 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot nem tudtam lefordítani.(józan Csaba) gyakorlat Írjunk egy rightrot(x, n) függvényt, ami n bittel jobbra rotálja az x egész mennyiséget! Jobbra rotálásnál a jobb szélen kilépő bitek a bal szélen visszakerülnek a szóba. A feladat megoldását Akai József Zsolt készítette (Busák Zoltán Tutor segítségével). A feladatot splint-el ellenőriztem 20 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot felhasználóbaráttá tette és kiegészítette bináris kiíratással Kovács-Ferenc Norbert. Update: Logikai művelettel működő megoldással kiegészítettem. A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat A kettes komplemens kódú aritmetikában az x = (x-1) kifejezés törli x jobb szélső bitjét. Magyarázzuk meg, miért! Ezt kihasználva írjunk egy gyorsabb bitcount változatot! A feladat megoldását Akai József Zsolt készítette (Busák Zoltán Tutor segítségével) A feladatot splint-el ellenőriztem 1 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjuk át a nagybetűket kisbetűkké alakító lower függvényt úgy, hogy az if-else szerkezetet feltételes kifejezéssel helyettesítjük! A feladat megoldását Ozsváth Jonathán készítette. A feladatot splint-el ellenőriztem 5 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjunk expand(s1, s2) néven függvényt, amely az s1 karaktersorozatban lévő rövidítéseket s2 karaktersorozatban feloldja (pl. az a-z helyett kiírja az abc...xyz teljes listát)! A program tegye lehetővé a betűk és számjegyek kezelését, és gondoljunk olyan rövidítések feloldására is, mint a-b-c, a-z0-9 vagy -a-z is! Célszerű a kezdő vagy záró - jelet literálisként kezelni.

132 A Debreceni Egyetem programozói évkönyve 102 / 404 A feladat megoldását Akai József Zsolt készítette (Busák Zoltán Tutor segítségével) A feladatot splint-el ellenőriztem 11 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjuk meg azt az itob(n,s) függvényt, amely az n unsigned egész számot bináris karakterábrázolásban az s karakterláncba konvertálja! Írjuk meg az itoh függvényt is, amely egy egész számot hexadecimális ábrázolásmódba alakít át! A feladat megoldását Veress Balázs készítette. A feladatot splint-el ellenőriztem 11 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjuk meg az itoa függvénynek azt a változatát, amely kettő helyett három argumentumot fogad el! A harmadik argumentum a minimális mezőszélesség; az átkonvertált számot szükség esetén balról üres közökkel kell kitölteni, hogy elég széles legyen! A feladat megoldását Veress Balázs készítette. A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjunk olyan programot amely a bemenetét a kimenetére másolja, de ha a bemenetére egymás után többször érkezik ugyanaz a sor, azt csak egyszer nyomtatja ki!(egy egyszerű változata az UNIX uniq szolgáltatásának) A feladat megoldását Veress Balázs készítette. A feladatot splint-el ellenőriztem 7 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjuk meg a ungets(s) nevű rutint, amely egy teljes karakterláncot ír vissza a bemenetre! A feladat megoldását Abai Richárd készítette. Forrás:../source/tankonyvi/KR/4.4.c A feladatot splint-el ellenőriztem 9 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba)

133 A Debreceni Egyetem programozói évkönyve 103 / gyakorlat A printd-ben alkalmazott megoldások felhasználásával írjuk meg az itoa rekurzív változatát, vagyis rekurzív rutin segítségével konvertáljunk egy egész számot karakterlánccá! A feladat megoldását Sipos Ferenc készítette. Forrás:../source/tankonyvi/KR/4.7.c A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjuk meg az s karakterláncot megfordító reverse(s) függvény rekurzív változatát! A feladat megoldását Sipos Ferenc készítette. Forrás:../source/tankonyvi/KR/4.8.c A feladatot splint-el ellenőriztem 2 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Definiáljuk a swap(x, y) makrót, amely megcseréli a két int típusú argumentumát! (A blokkstruktúra segítségünkre lesz.) A feladat megoldását Sipos Ferenc készítette. Forrás:../source/tankonyvi/KR/4.9.c A feladatot splint-el ellenőriztem 2 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjuk meg a getfloat függvényt, amely a getint lebegőpontos megfelelője! Milyen típust ad vissza getfloat függvényértékként? A feladat megoldását Sipos Ferenc készítette. Forrás:../source/tankonyvi/KR/5.1.c A feladatot splint-el ellenőriztem 26 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írja meg a 2. fejezetben bemutatott strcat(s, t) függvény mutatóval megvalósított változatát! Az strcat(s, t) függvény a t karaktersorozatot az s karaktersorozat végéhez másolja. A feladat megoldását Akai József Zsolt készítette (Busák Zoltán Tutor segítségével) A feladatot splint-el ellenőriztem 4 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot nem tudtam lefordítani.(józan Csaba)

134 A Debreceni Egyetem programozói évkönyve 104 / gyakorlat Írjon strend(s, t) néven függvényt, amely 1 értékkel tér vissza, ha a t karaktersorozat megtalálható az s karaktersorozat végén, és 0 értékkel, ha nem! A feladat megoldását Akai József Zsolt készítette (Busák Zoltán Tutor segítségével) A feladatot splint-el ellenőriztem 4 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írja meg az strncpy, strncat és strncmp könyvtári függvények saját változatát! Ezek a függvények az argumentumként megadott karaktersorozat legfeljebb első n karakterével végeznek műveletet, pl. az strncpy(s, t, n) a t karaktersorozat legfeljebb első n karakterét másolja s-be. A feladat megoldását Akai József Zsolt készítette (Busák Zoltán Tutor segítségével) A feladatot splint-el ellenőriztem 7 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot nem tudtam lefordítani.(józan Csaba) gyakorlat 5.7. Gyakorlat. Írjuk meg az add nevű programot, amely kiértékel egy, a parancssorban szereplőfordított lengyel alakú kifejezést! Például add * 2 * (3+4)-et számítja ki. A feladat megoldását Sipos Ferenc készítette. Forrás:../source/tankonyvi/KR/5.7.c A feladatot splint-el ellenőriztem 15 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjunk programot, amely a hívásakor az argv[0]-ban elhelyezett paramétertől függően a nagybetűket kisbetűvé vagy a kisbetűket nagybetűvé alakítja! A feladat megoldását Akai József Zsolt készítette (Busák Zoltán Tutor segítségével) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba)

135 A Debreceni Egyetem programozói évkönyve 105 / gyakorlat Írjunk programot, amely összehasonlít két állományt, és kiírja az első olyan sort, ahol különböznek! A feladat megoldását Gyügyei Tamás készítette. A feladatot splint-el ellenőriztem 9 hibát talált.a splint-elés eredményét a splint mappába helyeztem el.(józan Csaba) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) gyakorlat Írjuk újra a 7. fejezetben megismert cat programot úgy, hogy a standard könyvtári függvények helyett a read, write, open és close függvényeket használjuk! Végezzünk kísérleteket a két változat futási idejének meghatározására! A feladat megoldását Akai József Zsolt készítette (Busák Zoltán Tutor segítségével) A feladatot valgrind-el ellenőriztem, 0 hibát.(józan Csaba) Az [SZFCPP] könyv feladatai Ugyanúgy járjunk el, mint az előző tankönyvek esetén, itt egységesen 10 pont számolható el példánként feladat Írjunk egy olyan tárolót, amelyben egész típusú értékekt (int) thtünk be, illetve vehetünk ki olyan sorrendben, amilyen sorrendben beraktuk őket. Mivel az először berakott alamet vehetjük ki elsőként, ezt a struktúrát firt is sirst out (FIFO) Tárolónak nevezzük. A megoldást Veress Balázs Készítette Gyügyei Tamás tutor segítségével feladat Írjunk komplex számokat megvalósító osztályt! Tegyük lehetővé az alábbi műveletcsoportokat! Statikus műveletek, Imaginárius egység használata, Műveletek komplex számokkal, Valós és komplex műveletek, I/O műveletek. A könyv 69. oldala. A megoldást Veress Ármin készítette Balog János Csaba tutor segítségével.

136 A Debreceni Egyetem programozói évkönyve 106 / feladat Írjunk egy egyszerű menüt megvalósító programrészletet. Írjunk egy parancsokat tartalmazó osztályt, illetve egy menüosztályt, amely meghívja a parancsokat tartalmazó osztály megfelelő parancsát! A megoldást Veress Ármin készítette Balog János Csaba tutor segítségével feladat Írjunk olyan programrészletet, amely egy munkaadói nyilvántartás részeként képes személyek adatait tárolni (név, születési év) az alkamazottak adataival együtt (név, születési év, munkába állás éve). Ettől a prototípustól mindössze annyit várunk el, hogy kiírja egy személy vagy egy alkalmazott adatait a szabványos kimenetre. A megoldást Veress Ármin készítette Balog János Csaba tutor segítségével feladat Egy matematikai program részeként körörket és téglalapokat szeretnénk egy tömbben nyilvántartani. A kör és as téglalap legyen képes kiszámolni a saját területét! A hibakeresést megkönnyítendő definiáljunk egy Print függvényt, amely kiírja, hogy a téglalapról, vagy körről van szó. A megoldást Kovács-Ferenc Norbert készítette Bereczki László tutor segítségével feladat A tankönyv 142. oldalán a feladat bemutatja az interfészimplementáció alkalmazását. A megoldást Veress Ármin készítette Balog János Csaba tutor segítségével feladat Tervezzük meg és valósítsuk meg egy String osztály konverzióit! A megoldást Veress Ármin készítette Balog János Csaba tutor segítségével.

137 A Debreceni Egyetem programozói évkönyve 107 / feladat Kérjünk be a felhasználótól egy számot és írjuk a szabványos kimenetre a reciprokát. Ha a felhasználó érvénytelen bemenetként nullát ad meg, akkor jelezzük a hibát, és írjuk ki a hiba szövegét a szabványos kimenetre. A megoldást Kovács-Ferenc Norbert készítette Bereczki László tutor segítségével feladat Írjunk egy olyan ContainerProcessor nevű osztálysablont, melynek statikus tagfüggvényei különböző műveleteket végeznek a paraméterként megkapott tároló (container) osztályon. A megoldást Veress Ármin készítette Balog János Csaba tutor segítségével betű számoló Számoljuk meg, hány h karakter található egy C stílusú sztringben! A megoldást Nagy Dávid készítette Kistamás Dávid tutoriálásával szám számoló Számoljuk meg, hányszor fordul elő a 42 egy egészeket tartalmazó tömbben! A megoldást Nagy Dávid készítette Kistamás Dávid tutoriálásával filozófusok oda-vissza Térjünk vissza a filozófusokhoz, és töltsünk fel a nevükkel egy vektort! Írassuk ki a nevüket a betétel sorrendjében, illetve fordított sorrendben! A megoldást Nagy Dávid készítette Kistamás Dávid tutoriálásával.

138 A Debreceni Egyetem programozói évkönyve 108 / filozófusok másolása Másoljuk át egy vektor tartalmát listába, majd írassuk ki a lista tartalmát. A megoldást Nagy Dávid készítette Kistamás Dávid tutoriálásával feladat Tekintsünk adottnak egy vektorobjektumot, amely egész számokkal lett feltöltve! Keressük meg az első olyan elemet, amely nagyobb vagy egyenlő, mint 3! A megoldást Balogh János Csaba készítette Veress Ármin tutor segítségével bitbeszúrás Írjunk olyan programot, amely egy bináris vektorban minden egymás után következő öt egyes után beszúr egy nullát. A megoldást Nagy Dávid készítette Kistamás Dávid tutoriálásával Az [EZUST] könyv feladatai Ugyanúgy járjunk el, mint az előző tankönyvek esetén, itt egységesen 7 pont számolható el példánként gyakorlat Módosítsuk a könyv 1.6 példáját, úgy, hogy a kimenet ez legyen: Title 1 Title 2 Cat Clothing Dog Dancing A megoldást Kovács-Ferenc Norbert készítette Bereczki László tutor segítségével.../source/tankonyvi/ezust/1.7.2.cpp

139 A Debreceni Egyetem programozói évkönyve 109 / gyakorlat Egy örök kedvenc: Írj egy rövid programot, ami bekéri a felhasználótól a hőmérsékletátváltás irányát(celsius-fahrenheit/fahrenheit- Celsius). Ezután kérj be egy alsó határt, egy felső határt és egy lépésközt. Használd ezeket, hogy létrehozd a megfelelő táblázat fejlécet. A main függvényednek viszonylag rövidnek kell lennie. A munka nagy része az általad készített függvényekben hajtódjon végre. A megoldást Kovács-Ferenc Norbert készítette Bereczki László tutor segítségével.../source/tankonyvi/ezust/1.8.1.cpp gyakorlat Ha includoljuk a <cstdlib> könyvtárat, elérjük a random() függvényt, amely pszeudó-véletlen számokat generál 0 és MAX_RANDOM számok között, amely érdekes módon használható. Úgy működik, hogy kiszámolj ap következő számot a sorban az előző generált számból. Az srandom(unsigned int seed) függvény beállítja a függvény forrását a seed értékre. Írj egy rövid programot, amely leteszteli ezt a függvényt azáltal, hogy a felhasználó adja meg a véletlen számok forrását. A megoldást Kovács-Ferenc Norbert készítette Bereczki László tutor segítségével.../source/tankonyvi/ezust/1.8.2.cpp gyakorlat Egy trükk a srandom(time(0)) használata a random függvény forrásához. Mivel a time(0) egy adott ponttól eltelt másodperceket adja vissza, így a forrás mindig más lesz, amikor lefut a program. Ezzel megjósolhatatlan minta lesz a véletlen számok generálásában. Írj egy programot, ami egy kockajátékot szimulál az alábbi szabályokkal: 1.A játékban ismételten dobunk két szabályos dobókockával. 2.Minden kockának 6 oldala van 1-6 számozva. 3.A dobás eredménye a két kocka összege. 4.Az első dobás mondja meg a játékos számát. 5.Ha ez a szám 7, vagy 11, a játékos automatikusan nyer. 6.Ha ez a szám 2, a játékos veszít. 7.Egyébként a játékos addig dob, amíg nem nyer, vagy veszít. A megoldást Kovács-Ferenc Norbert készítette Bereczki László tutor segítségével.../source/tankonyvi/ezust/1.8.3.cpp gyakorlat Írj egy programot, ami bekér két érteket a felhasználótól(vevőtől): az egyik a fizetendő összeg, a másik a ténylegesen fizetett összeg. Minden értéket tárolj el double típusú változóban. Ezután számold ki és írasd ki a visszajárót, amit kap a felhasználó. A visszajárót a következő képpen fejezd ki: $10,$5,$1,quarters,dimes,nickels, vagy pennies.(feltételezve, hogy a kimenet egy gépnek lesz elküldve, ami kiadja ezeket a bankjegyeket, vagy érméket) A megoldást Kovács-Ferenc Norbert készítette Bereczki László tutor segítségével.../source/tankonyvi/ezust/1.8.4.cpp

140 A Debreceni Egyetem programozói évkönyve 110 / gyakorlat Módosítsd a 1.19-es példát úgy, hogy csináljon valamilyen aritmetikai műveletet a jp által mutatott memóriaterületetn. Írd az eredményt az ip által mutatott helyre és írasd ki az eredményt. Írasd ki különböző helyeken a programban. Figyeld meg, hogy hogy reagál a fordító és a futó rendszer a kimenetek elhelyezésére. A megoldást Kovács-Ferenc Norbert készítette Bereczki László tutor segítségével.../source/tankonyvi/ezust/ cpp gyakorlat Definiálj egy autót reprezentáló osztályt: A konstruktor kérje be a kilométeróraállást és egy értéket az átlagos fogyasztásra mérföld/gallon alakban. A drive() függvény legyen nagyjából inteligens: 1. ne hagyja az autót vezetni, ha nincs üzemanyag. 2. jól kell hogy állítsa a kilóméteróra állást és az üzemanyagszintet. 3. adja vissza az üzemanyagtankban lévő üzemanyag mennyiségét. Az addfuel() függvény állítsa az üzemanyagszintet megfelelően és adja vissza a tankban lévő üzemanyagmennyiséget. Az addfuel(0) töltse tele a tankot. Példányosítsd az egyszerűbb tesztelés kedvéért. A megoldást Kovács-Ferenc Norbert készítette Bereczki László tutor segítségével.../source/tankonyvi/ezust/ cpp

141 A Debreceni Egyetem programozói évkönyve 111 / fejezet Vizsgarendszer A szillabusznak megfelelően bármely vizsgán bármi használható (kivéve a direkt kommunikációt a vizsga kapcsán) a saját internetes gép pedig eleve ajánlott, ennek hiányában a hallgató géptermi PC mellett dolgozhat A 2013/14 tanév tavaszi szemeszterének vizsgái Szóbeli vizsgák A félévben elvégzett gyakorlatok ellenében az alábbi kedvezményekkel lehet élni: 600 pont fölött csak egy tétel közül kell húznia (tehát nem kell húznia) a vizsgázónak, hanem szabadon választhat. 500 pont fölött csak két tétel közül kell húznia a vizsgázónak, saját maga döntheti el, hogy mely tételeket akar elkerülni. 400 pont fölött három tétel közül kell húznia a vizsgázónak, saját maga döntheti el, hogy mely tételeket akar elkerülni. 300 pont fölött négy tétel közül kell húznia a vizsgázónak, saját maga döntheti el, hogy mely tételeket akar elkerülni. 200 pont fölött hat tétel közül kell húznia a vizsgázónak, saját maga döntheti el, hogy mely tételeket akar elkerülni. 100 pont fölött hét tétel közül kell húznia a vizsgázónak, saját maga döntheti el, hogy mely tételeket akar elkerülni. 50 pont fölött tíz tétel közül kell húznia a vizsgázónak, saját maga döntheti el, hogy mely tételeket akar elkerülni, tehát egyet mindenki elkerülhet. A tételek a feladatoknak megfelelően kidolgozhatóak, (hegylakó-szabály van, 50 pont felettieknek, tételenként 40 pontért igényes kidolgozás esetén, kezdő önbesorolásúak esetén csak tutor-rendszerben). A jól kell tudni részek kidolgozása egyértelműbb, a főtéma kidolgozása szerveződjön az előadás, a labor, a szakmai fórumunk vagy saját nagyon egyszerű forráskódunk, vagy forráscsipetünk köré, nyilván mesét nem kell kidolgozni, az úgyis benne van a könyvben. Hanem sokkal inkább a könyvből feladott részek visszaköszönése a saját kódokban, csipetekben a nagyon értékes tudás! Minden tétel egy jól kell tudni résszel kezdődik, ez nem elégséges, hanem csak szükséges feltétele az elégséges vizsgajegynek, ez egyfajta beugró. 1. Jól kell tudni: mélymásoló másoló konstruktor írása az első védési program LZW binfa osztályába. Főtéma: Típusok és deklarációk, a [STROUSTRUP] tankönyv oldala. A feladat megoldását Antal Török készítette. Tutor: Fülöp Sándor

142 A Debreceni Egyetem programozói évkönyve 112 / Jól kell tudni: másoló értékadás és konstruktor összehasonlítása a mozgató értékadással és konstruktorral saját példán (akár a kapcsolódó laborkártyákon) keresztül, saját nyomkövető üzenetek nyomán. Főtéma: Mutatók, tömbök és struktúrák, a [STROUSTRUP] tankönyv oldala. A feladat megoldását Antal Török készítette. Tutor: Fülöp Sándor 3. Jól kell tudni: saját viselkedés implementálása szögletnél a saját RCSS robotfoci csapatodnál. Főtéma: Kifejezések és utasítások, a [STROUSTRUP] tankönyv oldala. A feladat megoldását Akai József Zsolt készítette. Tutor: Fülöp Sándor 4. Jól kell tudni: a Mandelbrotos vagy életjátékos Qt-s visszahívásos programunk átírása slot-signal-osra. Főtéma: Függvények, a [STROUSTRUP] tankönyv oldala. Tételt kidolgozta: Szentpéteri Annamária. Tutor: Fülöp Sándor. 5. Jól kell tudni: a [STROUSTRUP] tankönyv számológépes példája. Főtéma: Névterek és kivételek, a [STROUSTRUP] tankönyv oldala. Megoldást Tamics Ádám készítette. tutor: Fülöp Sándor. 6. Jól kell tudni: A Google C++ Test Framework használata a deriváló példánkban (lásd a kapcsolósó beszélgetést a szakmai fórumunkon). Főtéma: Forrásfájlok és programok, a [STROUSTRUP] tankönyv oldala. Megoldást Tamics Ádám készítette. tutor: Fülöp Sándor. 7. Jól kell tudni: a lambdás laborkártyák. Főtéma: Osztályok, a [STROUSTRUP] tankönyv oldala.

143 A Debreceni Egyetem programozói évkönyve 113 / 404 A feladat megoldását Tóth Máté készítette. Tutor: Fülöp Sándor 8. Jól kell tudni: saját (bármely a tárolóban lévő) Omips programod. Főtéma: Operátorok túlterhelése, a [STROUSTRUP] tankönyv oldala. Tételt kidolgozta: Szentpéteri Annamária. Tutor: Fülöp Sándor. 9. Jól kell tudni: saját (bármely a tárolóban lévő) fraktálnagyító vagy életjáték programod. Főtéma: Származtatott osztályok, a [STROUSTRUP] tankönyv oldala. 10. Jól kell tudni: egy szabadon választott robotfocis feladatunk megoldása (vagy a P-szálak használata az ágensekben). Főtéma: Sablonok, a [STROUSTRUP] tankönyv oldala. A feladat megoldását Tóth Máté készítette. Tutor: Fülöp Sándor 11. Jól kell tudni: egy szabadon választott (dinamikus memóriakezelést tartalmazó) feladatunk megoldása és elemzése statikus vagy dinamikus kódellenőrzőkkel, például a splint-el vagy valgrind-el. Főtéma: Kivételkezelés, a [STROUSTRUP] tankönyv oldala. Tételt kidolgozta: Szentpéteri Annamária. Tutor: Fülöp Sándor A 2014/15 tanév őszi szemeszterének vizsgái Szóbeli vizsgák Tekintettel arra, hogy a hibásan implementált RSA törése csupán egyetlen hallgatónknak sikerült, így írásbeli vizsgát a jelen szemeszterben nem hirdetünk, hanem csak szóbeli vizsgákat. A félévben elvégzett gyakorlatok értékében igénybe vehető kedvezmények tekintetében lásd a sillabuszt!

144 A Debreceni Egyetem programozói évkönyve 114 / pont fölött csak 3 tétel közül kell húznia a vizsgázónak, saját maga döntheti el, hogy mely tételeket akar elkerülni pont fölött csak 4 tétel közül kell húznia a vizsgázónak, saját maga döntheti el, hogy mely tételeket akar elkerülni pont fölött 5 tétel közül kell húznia a vizsgázónak, saját maga döntheti el, hogy mely tételeket akar elkerülni pont fölött 6 tétel közül kell húznia a vizsgázónak, saját maga döntheti el, hogy mely tételeket akar elkerülni. 800 pont fölött 7 tétel közül kell húznia a vizsgázónak, saját maga döntheti el, hogy mely tételeket akar elkerülni. 500 pont fölött 8 tétel közül kell húznia a vizsgázónak, saját maga döntheti el, hogy mely tételeket akar elkerülni. 200 pont fölött 9 tétel közül kell húznia a vizsgázónak, saját maga döntheti el, hogy mely tételeket akar elkerülni. A főtémak kidolgozása szerveződjön az előadás, a labor, a szakmai fórumunk vagy saját nagyon egyszerű forráskódunk, vagy forráscsipetünk köré, nyilván mesét nem kell kidolgozni, az úgyis benne van a könyvben. Sokkal inkább a könyvből feladott részek visszaköszönése a saját kódokban, kódcsipetekben a fontos! Minden tétel egy jól kell tudni résszel kezdődik, ez nem elégséges, hanem csak szükséges feltétele az elégséges vizsgajegynek, ez egyfajta beugró. 1. Jól kell tudni: SwingWorker osztály használata egy példán keresztül, pl. a robotautó/rcwin. Főtéma: A [JAVAKONYV] tankönyv a oldala. 2. Jól kell tudni: Boost BGL alapú routing a robotautóban. Főtéma: A [JAVAKONYV] tankönyv oldala. 3. Jól kell tudni: A Maven alapú Helló Világ! szervletes példa. Főtéma: A [JAVAKONYV] tankönyv oldala. 4. Jól kell tudni: Az első védés (humán genomos) C++ kódjának Java átirata. Főtéma: A [JAVAKONYV] tankönyv oldala. 5. Jól kell tudni: Egy Maven projekt (YANO vagy robotautó/rcwin) riportjai (kitérve pl. a ciklomatikus komplexitásra). Főtéma: A [JAVAKONYV] tankönyv oldala. 6. Jól kell tudni: Az Object osztály wait és notify párja pl. ezen a chat példán keresztül (az Esettanulmány: egy chat program című pont alatt). Főtéma: A [JAVAKONYV] tankönyv oldala. 7. Jól kell tudni: kvalifikációs szint elérése a január 28-i Robotautó Világbajnokságra. Főtéma: A [JAVAKONYV] tankönyv oldala. 8. Jól kell tudni: saját kliens ágens a Robotautó Világbajnokságra. Főtéma: A [JAVAKONYV] tankönyv oldala. 9. Jól kell tudni: OSM XML-ből C++ programmal a buszok útvonalának kibányászása. Főtéma: A [JAVAKONYV] tankönyvii/ oldala. 10. Jól kell tudni: OSM XML-ből kibányászott busz-útvonalak megjelenítése (Android-on, vagy xmapviewer PC-n). Főtéma: A [STROUSTRUP] tankönyv második kötetéből a oldal Királyi út a szóbeli vizsgán Lehetősége van a tételsor kiváltására annak, aki eleget tesz a következő feltételeknek: 1. kvalifikálja saját robotautó csapatát a január 28-i Robotautó Világbajnokságra 2. a platform C++ és Java forrásait védi olyan alapon, hogy a kód bármely részéből kaphat kérdést, amelyet el kell magyaráznia 3. részt is vesz a versenyen!

145 A Debreceni Egyetem programozói évkönyve 115 / fejezet Nincs 13. fejezet

146 A Debreceni Egyetem programozói évkönyve 116 / fejezet Céges feladatok Ezek a feladatok a negyedik védés választható feladatai Robocar World Championship in Debrecen Ez valójában nem céges feladat, hanem a FIRST-beli munkacsoportom aktuális témájába illeszkedő feladatcsokor. Részben mintaképpen is kerül itt kiírásra, hogy a céges feladat intézménye iránt érdeklődő cégeknek egy példát mutasson. A feladat koncepcióját egy progpater blog posztban vázoltuk. A választható részfeladatokat a koncepció "Tetris-terve" szerint vesszük számba ábra. A projekt "Tetris-terve". A projektben fejlesztendő sw-komponensek legtöbbje kapcsolatba kerül a térképpel (Map), most konkrétan az OpenStreetMap-el. A közlekedést mindig egy adott városban (City) vizsgáljuk, amelyről a priori bírunk információkkal, illetve automatikusan (ASA) vagy emberi beavatkozással segítve (HSA) gyűjtünk adatokat. Előbbire példa, amikor egy bekötőút bejövő forgalmát egy kamera alapú alkalmazás számolja adott időszakban, utóbbira, amikor ugyanezt egy emberi megfigyelő teszi. Az emulátor (Robocar City Emulator) a járművek mozgatását emulálja a vizsgált városban, miközben minden járművet ugyanazzal a vezérlő algoritmussal (The competition) látunk el. Egy-egy leemulált nap eredményei (Results) alapján hirdetjük ki a versengő vezérlő algoritmusok között a győztest. A versengés alapja például a járművek átlagos utazási idejének, azok szórásának a minimalizálása. Az emulációk mindenféle izgalmas környezetben lesznek megjeleníthetők (Monitors) például a Google Maps vagy OpenStreetMap alapú megjelenítőkben. A következő feladatok megoldását open source, lehetőleg GPLv3 engedéllyel ellátott programmal valósítsd meg. Ennek megfelelően a megoldás mellé készített dokumentációban résztelesen térj ki a felhasznált könyvtárak, API-k, források sw-komponensek licencére! A megoldásod forrásban kerüljön fel az UDPROG projekt tárolójába.

147 A Debreceni Egyetem programozói évkönyve 117 / 404 Malvin feladat. Írj C++ programot, amely kiírja az összes debreceni buszjárat megállóit, járatonként rendezve, azaz járatonként a megállókat. Nem hegylakó feladat, 40 pont. Címkék: City, Map, OSM, libosmium. Petra feladat. Írj C++ programot, amely bemenetként egy OSM térképet és két a térképen lévő GPS koordináta párt kap, majd kimenetként kinyomtat egy utat a megadott koordináta párokhoz legközelebb eső két csomópont között. Nem hegylakó feladat, 120 pont. Címkék: City, Map, OSM, routing. Helga feladat. Írj C++ programot, amely a korábbi hangya szimulációs megközelítést adaptálja OSM-re: a járművek a debreceni térképen random bolyongjanak, de használjanak olyan heurisztikát, miszerint arra mennek, amerre többen mennek (ez a hangya szimulációs megközelítés). Ha a jármű kibolyongna a Debrecen térképről, akkor egy random választott úton lépjen vissza a városba (olyan megközelítéssel, mint a sejtautomata szimulációkban a periódikus határfeltételünk volt, de ott nem volt random, ha a jobb oldalon kilépett a sejttérből, akkor a balon lépett vissza stb.). Nem hegylakó feladat, 240 pont. Címkék: City, Map, OSM, routing, Robocar City Emulator. Ferenc feladat. Írj OSM alapú megjelenítő programot a Helga feladathoz! Nem hegylakó feladat, 150 pont. Címkék: City, Map, Monitors. Aurél feladat. Írj Android Java/Google Maps alapú megjelenítő programot a Helga feladathoz! Nem hegylakó feladat, 90 pont. Címkék: City, Map, Monitors. Brúnó feladat. Írj OSM alapú megjelenítő programot a Petra feladathoz! Nem hegylakó feladat, 50 pont. Címkék: City, Map, Monitors. Amália feladat. Írj Android Java/Google Maps alapú megjelenítő programot a Petra feladathoz! Nem hegylakó feladat, 30 pont. Címkék: City, Map, Monitors. Koppány feladat. Írj OSM alapú megjelenítő programot a Malvin feladathoz! Nem hegylakó feladat, 40 pont. Címkék: City, Map, Monitors. Dénes feladat. Írj Android Java/Google Maps alapú megjelenítő programot a Malvin feladathoz! Nem hegylakó feladat, 35 pont. Címkék: City, Map, Monitors. Gedeon feladat. A Malvin feladat megoldása Java-ban! Nem hegylakó feladat, 30 pont. Címkék: City, Map. Brigitta feladat. A Petra feladat megoldása Java-ban! Nem hegylakó feladat, 90 pont. Címkék: City, Map, routing. Miksa feladat. A Helga feladat megoldása Java-ban! Nem hegylakó feladat, 190 pont. Címkék: City, Map, routing, Robocar City Emulator.

148 A Debreceni Egyetem programozói évkönyve 118 / 404 Ede feladat. A Petra feladat megoldása R-ben! Nem hegylakó feladat, 70 pont. Címkék: City, Map, routing, R. Helén feladat. Írj olyan C++ programot, amely egy adott út forgalmát mutató videófelvételről kiszámolja az adott irányú forgalmat egy olyan függvény formájában, mely megadja, hogy az addig eltelt percekben mennyi jármű haladt át. Nem hegylakó feladat, 320 pont. Két kamerát tudok kölcsönözni a feladathoz. Címkék: City, Map, videó és képfeldolgozás. Teréz feladat. Írj forgalomirányító algoritmust a Debreceni Robotautó Világbajnokságra! (Csak a robocar-emulator, Robocar World Championship - Robocar City Emulator élesítése után választható.) Nem hegylakó feladat, 100 pont. Címkék: Robocar City Emulator.

149 A Debreceni Egyetem programozói évkönyve 119 / 404 II. rész Megoldások

150 A Debreceni Egyetem programozói évkönyve 120 / 404 Ebben a részben az érdeklődő hallgatók dolgozzák ki az előadó és a laborvezetők által az aktuális félévre kiírt kidolgozható feladatokat. Ehhez természetesen felhasználhatják a kiírásnál megadott forgatókönyvet, sőt a legtöbb esetben kész forrásokat vagy akár teljes kidolgozást is. Fontos, hogy a megoldás felvitele előtt a feladatnak még kidolgozatlannak kell lennie, hiszen a hallgatók versenyben állnak és csak az első, aki itt bemutatja, könyvelheti el a pontokat! A többieknek már csak a tesztelése, hibajelentése, módosítása nyomán lehet pontokat szereznie az adott feladat kapcsán.

151 A Debreceni Egyetem programozói évkönyve 121 / fejezet A kezdő szint programjai Az első C programok Végtelen ciklus A szépség szubjektív, de számtalan esetben látjuk majd az alábbi végtelen ciklust, amelyet a../source/kezdo/elsoc/ vegetelen/v.c forrásállományba helyeztem el, s mielőtt ide bevágnám, ráengedtem az indent parancsot, ami persze csak abból a szempontból fontos, hogy Ti is elegánsan indentált forrásokat illesszetek az évkönyvbe. [nbatfai@desteny vegtelen]$ gcc -Wall v.c -o vegtelen [nbatfai@desteny vegtelen]$./vegtelen Egy másik ablakban a top -p `pgrep -u nbatfai vegtelen` parancsot futtatva látszik, hogy a program top - 14:30:05 up 4:40, 4 users, load average: 1,14, 1,08, 1,01 Tasks: 1 total, 1 running, 0 sleeping, 0 stopped, 0 zombie %Cpu0 : 7,0 us, 11,3 sy, 0,0 ni, 81,0 id, 0,0 wa, 0,0 hi, 0,7 si, 0,0 st %Cpu1 : 5,0 us, 10,3 sy, 0,0 ni, 84,1 id, 0,7 wa, 0,0 hi, 0,0 si, 0,0 st %Cpu2 : 1,3 us, 1,0 sy, 0,0 ni, 97,3 id, 0,0 wa, 0,3 hi, 0,0 si, 0,0 st %Cpu3 : 1,0 us, 0,0 sy, 0,0 ni, 99,0 id, 0,0 wa, 0,0 hi, 0,0 si, 0,0 st %Cpu4 : 0,7 us, 0,7 sy, 0,0 ni, 98,7 id, 0,0 wa, 0,0 hi, 0,0 si, 0,0 st %Cpu5 : 1,3 us, 1,7 sy, 0,0 ni, 97,0 id, 0,0 wa, 0,0 hi, 0,0 si, 0,0 st %Cpu6 : 0,0 us, 0,0 sy, 0,0 ni,100,0 id, 0,0 wa, 0,0 hi, 0,0 si, 0,0 st %Cpu7 :100,0 us, 0,0 sy, 0,0 ni, 0,0 id, 0,0 wa, 0,0 hi, 0,0 si, 0,0 st KiB Mem: total, used, free, buffers KiB Swap: total, 0 used, free, cached PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 7845 nbatfai R 99,6 0,0 20:49.98 vegtelen 100 százalékban használja a Cpu7-es magot. Ezzel a feladat fele kész, hátra van az a módosítás, amikor alig használja a program a processzort. Ezt a programot a../source/kezdo/elsoc/vegetelen/vs.c forrásállományba helyeztem el: #include <unistd.h> int main () for (;;) sleep (1); return 0;

152 A Debreceni Egyetem programozói évkönyve 122 / 404 A fordítást és a futtatást ugyanúgy végzem, mint az iménti esetben, íme az eredmény: top - 14:39:11 up 4:49, 4 users, load average: 0,03, 0,34, 0,70 Tasks: 1 total, 0 running, 1 sleeping, 0 stopped, 0 zombie %Cpu0 : 0,3 us, 0,3 sy, 0,0 ni, 99,3 id, 0,0 wa, 0,0 hi, 0,0 si, 0,0 st %Cpu1 : 0,3 us, 0,3 sy, 0,0 ni, 99,3 id, 0,0 wa, 0,0 hi, 0,0 si, 0,0 st %Cpu2 : 0,0 us, 0,0 sy, 0,0 ni,100,0 id, 0,0 wa, 0,0 hi, 0,0 si, 0,0 st %Cpu3 : 0,7 us, 0,0 sy, 0,0 ni, 99,3 id, 0,0 wa, 0,0 hi, 0,0 si, 0,0 st %Cpu4 : 0,0 us, 0,0 sy, 0,0 ni,100,0 id, 0,0 wa, 0,0 hi, 0,0 si, 0,0 st %Cpu5 : 0,0 us, 0,0 sy, 0,0 ni,100,0 id, 0,0 wa, 0,0 hi, 0,0 si, 0,0 st %Cpu6 : 0,0 us, 0,0 sy, 0,0 ni,100,0 id, 0,0 wa, 0,0 hi, 0,0 si, 0,0 st %Cpu7 : 0,0 us, 0,0 sy, 0,0 ni,100,0 id, 0,0 wa, 0,0 hi, 0,0 si, 0,0 st KiB Mem: total, used, free, buffers KiB Swap: total, 0 used, free, cached PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 8701 nbatfai S 0,0 0,0 0:00.00 vegtelen láthatóan a programunk a man 3 sleep kézikönyvlapon írtaknak megfelelően alszik Két változó értékének a cseréje A megoldást a../source/kezdo/elsoc/valtozocsere/csere.c forrásállományba helyeztem el. #include<stdio.h> int main() int a=2,b=4; printf("a=%d b=%d\n",a,b); a=a-b; b=a+b; a=b-a; printf("a=%d b=%d\n",a,b); return 0; A programunkban az "a" és "b" változó értéke megcserélődik. A forrást fordítom majd futtatom. [../udprog-code/source/kezdo/elsoc/valtozocsere]$ gcc csere.c -o csere [../udprog-code/source/kezdo/elsoc/valtozocsere]$./csere Két változó értékének a cseréje swap függvénnyel kód:../source/kezdo/elsocpp/valtozocsere/swap.cpp #include <iostream> using namespace std; int main() int a = 1; int b = 2;

153 A Debreceni Egyetem programozói évkönyve 123 / 404 a^=b; b^=a; a^=b; //csere bitenkénti kizáró vaggyal cout << "a(1): " << a << ", b(2): " << b << "\n"; swap(a,b); //csere beépített függvénnyel. cout << "a(1): " << a << ", b(2): " << b << "\n"; return 0; A program kétszer végzi el a cserét, egyszer a bitenkénti XOR-al, egyszer pedig a beépített SWAP függvénnyel, ezzel mutatjuk a két művelet ekvivalenciáját. A SWAP az std névtérben található, amit a using namespace std; parancsszóval linkeltünk Két változó értékének a cseréje swap függvénnyel C-ben. A programban az "a" és "b" változó értéke swap függvénnyel megcserélődik kód:../source/kezdo/elsoc/valtozocsere/swapp.c #include <stdio.h> #include <stdlib.h> //prototípus deklaráció void swap(int *, int *); int main() int a=5, b=6; printf("%d\t%d\n", a, b); // a két változó memóriacímét adjuk át swap(&a, &b); printf("%d\t%d\n", a, b); return 0; //a címeken található értékeket cseréljük ki void swap(int *c, int *d) *c = *c ^ *d; *d = *d ^ *c; *c = *d ^ *c; Pattogó labda A megoldást a../source/kezdo/elsoc/pattog/pattog.c forrásállományba helyeztem el. #include<stdio.h> #include<stdlib.h> gotoxy(int x, int y) int i; for(i=0; i<y; i++) printf("\n"); //kurzor pozicionálása //lefelé tolás

154 A Debreceni Egyetem programozói évkönyve 124 / 404 for(i=0; i<x; i++) printf(" "); printf("o\n"); //labda ikonja //jobbra tolás int main() int egyx=1; int egyy=-1; int j=78; int i; int x=10; //a labda kezdeti pozíciója int y=20; int ty[23];//magasság // a pálya mérete int tx[80];//szélesség //pálya széleinek meghatározás for(i=0; i<23; i++) ty[i]=1; ty[1]=-1; ty[22]=-1; for(i=0; i<79; i++) tx[i]=1; tx[1]=-1; tx[79]=-1; while(1) //címsor és pozíció kijelzése for(i=0; i<36; i++) printf("_"); printf("x=%2d", x); printf("y=%2d", y); for(i=0; i<=35; i++) printf("_"); gotoxy(x,y); //printf("o\n"); Áthelyezve a gotoxy függvényve x+=egyx; y+=egyy; egyx*=tx[x]; egyy*=ty[y]; usleep (200000); system("clear");

155 A Debreceni Egyetem programozói évkönyve 125 / 404 return 0; A forrás fordítása és futtatása. [../udprog-code/source/kezdo/elsoc/pattog]$ gcc pattog.c -o pattog [../udprog-code/source/kezdo/elsoc/pattog]$./pattog Leellenőriztem a kódot a splinttel. [../udprog-code/source/kezdo/elsoc/pattog]$ splint pattog.c Eredmény: [Splint May 2009 pattog.c: (in function gotoxy) pattog.c:11:2: Path with no return in function declared to return int There is a path through a function declared to return a value on which there is no return statement. This means the execution may fall through without returning a meaningful result to the caller. (Use -noret to inhibit warning) pattog.c: (in function main) pattog.c:41:9: Test expression for while not boolean, type int: 1 Test expression type is not boolean or int. (Use -predboolint to inhibit warning) pattog.c:57:5: Return value (type int) ignored: gotoxy(x, y) Result returned by function call is not used. If this is intended, can cast result to (void) to eliminate message. (Use -retvalint to inhibit warning) pattog.c:66:5: Unrecognized identifier: usleep Identifier used in code has not been declared. (Use -unrecog to inhibit warning) pattog.c:67:5: Return value (type int) ignored: system("clear") pattog.c:70:10: Unreachable code: return 0 This code will never be reached on any possible execution. (Use -unreachable to inhibit warning) pattog.c:18:7: Variable j declared but not used A variable is declared but never used. Use /*@unused@*/ in front of declaration to suppress message. (Use -varuse to inhibit warning) pattog.c:4:1: Function exported but not used outside pattog: gotoxy A declaration is exported, but not used outside this module. Declaration can use static qualifier. (Use -exportlocal to inhibit warning) pattog.c:11:1: Definition of gotoxy Finished checking code warnings Az első hibát amit észlelt a splint egyszerűen ki lehet küszöbölni, mert a kódban levő függvénynek egyszerűen adunk egy void típúst mivel nincs visszatérési érték. Ezen kis módosítás után már csak 6 warningunk lesz. A j változó feleslegesen van megadva, mivel a kódben sehol sem használjuk.hibák száma: 5. A while(1) helyett ha for(;;) használunk végetelen ciklusnak akkor a hibák száma: 4. A programnak nem kell visszatérési érték ezért, main(void) és nem kell return 0; sem. Hibák száma: 3. Végeredményem a kód ilyen módosításaival: [pattog.c: (in function main) pattog.c:67:5: Unrecognized identifier: usleep Identifier used in code has not been declared. (Use -unrecog to inhibit warning) pattog.c:68:5: Return value (type int) ignored: system("clear") Result returned by function call is not used. If this is intended, can cast result to (void) to eliminate message. (Use -retvalint to inhibit warning) pattog.c:5:6: Function exported but not used outside pattog: gotoxy

156 A Debreceni Egyetem programozói évkönyve 126 / 404 A declaration is exported, but not used outside this module. Declaration can use static qualifier. (Use -exportlocal to inhibit warning) pattog.c:12:1: Definition of gotoxy Finished checking code warnings Pattogó labda Készítette: Szentpéteri Annamária. Tutor: Bereczki László. Ezt a programot Bátfai Norbert már korábban elkészítette, Ács Raymund pedig szintén feltöltött egy változatot. Ez a program C++-ban valósítja meg a feladatot Linux környezetben. Update : if-ek helyett signbit() függvény használata a visszapattanás megoldásához. (Virtuális környezetben nem működik.) Update : "unistd.h" állomány csatolása, "x","y" iteratorok helyett egy "i" iterator (optimizálás). A../source/kezdo/elsocpp/patt_labda/patt_labda.c++ forrásállományban helyeztem el a kódot. #include <iostream> #include <cstdlib> #include <sys/ioctl.h> #include <math.h> #include <unistd.h> using namespace std; void put(int ex,int ey,int mx, int my, int speed) //Ablak méretének beolvasása (dinamikus) struct winsize w; ioctl(0, TIOCGWINSZ, &w); int MAX_Y = w.ws_row-1; int MAX_X = w.ws_col-1; //Képernyőtörlés és mozgatás: system("clear"); int o = mx-ex; //hány sort lépjen int s = my-ey; //hány oszlopot lépjen /* //Képernyő szélét ha eléri if ( ((mx+o)>max_x) ((mx+o)<0)) o*=(-1); if ( ((my+s)>max_y) ((my+s)<0)) s*=(-1); * * Helyettesítve if-ek nélküli megoldással! * */ //Képernyő szélét, ha eléri o=o*(((signbit(max_x-mx-o)/8) * 2) - 1 ) * (((signbit(mx+o)/8) * 2) - 1 ); s= s*(((signbit(max_y-my-s)/8) * 2) - 1 ) * (((signbit(my+s)/8) * 2) - 1 ); /* * A signbit 0 vagy 1 értékkel tér vissza, ezért kell 2-vel felszorozni, * majd 1-et kivonni, hogy -1 vagy 1 értéket kapjak negatív vagy pozitív * számok esetén

157 A Debreceni Egyetem programozói évkönyve 127 / 404 */ int ux=mx+o; //új x tengely pozíció int uy=my+s; //új y tengely pozíció int i; //a kiiratáshoz pozíció számoló for (i=0; i < uy ; i++) //megfelelő sorba állítás cout << "\n"; cout.flush(); for (i=0; i < ux ; i++) //megfelelő oszlopba állítás cout << " "; cout.flush(); cout << "O"; //labda kiírása cout.flush(); usleep(speed); //egy másodpercnyi késleltetés, hogy látható legyen put(mx,my,ux,uy,speed); //új érték megadása a put-nak int main() system("clear"); //Két előző labda pozíció és sebesség bekérése int x1,y1,x2,y2, speed; cout << "x1: "; cin >> x1; cout << "y1: "; cin >> y1; cout << "x2: "; cin >> x2; cout << "y2: "; cin >> y2; cout << "speed(1-10): "; cin >> speed; //Fv meghívása put(x1,y1,x2,y2,speed*25000); return 0; A program jellemzői: futás közbeni ablakátméretezést érzékeli és helyesen kezeli; állítható kezdő pozíció, irány és sebesség; a mozgást vektorosan modelleztük; valós végtelen ciklus Pattogó labda Készítette: Ács Raymund. Tutor: Gálffy Tamás. A../source/kezdo/elsoc/labda/pattog.c forrásállományban helyeztem el a kódot. /*

158 A Debreceni Egyetem programozói évkönyve 128 / 404 * Program: Pattogó labda (abszolútérték nélkül) * Dátum: * Tutor: Gálffy Tamás * Tutoriált: Ács Raymund */ #include <stdio.h> #include <stdlib.h> char bitzero(char x) int i; char bitt = x&0x1; for (i=0; i<8; i++) bitt = (x>>i)&1; return 1-bitt; //ez mutatja meg mikor kell pattanni void rajzol(char width, char height) int i; /*magasság*/ for (i=1; i<=height; i++) printf("\n"); /*szélesség*/ for (i=1; i<=width; i++) printf(" "); printf("o\n"); int main() char x=1, y=1, vx=1, vy=1; while(1) system("clear"); vx-=2*bitzero(79-x); //balra pattanjon vx+=2*bitzero(x); // vy-=2*bitzero(24-y); //lefele vy+=2*bitzero(y); // x+=vx; y+=vy; //printf("x: %d Y: %d \n", x, y); return 0; //printf("vx: %d Vy: %d", vx, vy); rajzol(x,y); usleep(100000); //Koordináták //Velocity A forrás fordítása és futtatása. [../udprog-code/source/kezdo/elsoc/labda]$ gcc pattog.c -o pattog [../udprog-code/source/kezdo/elsoc/labda]$./pattog Pattogó labda Készítette: Készítette: Hegyes Tibor. A../source/kezdo/elsoc/ptlabda/pattanablakhuz.c forrásállományban helyeztem el a kódot.

159 A Debreceni Egyetem programozói évkönyve 129 / 404 #include<stdio.h> #include<stdlib.h> #include <sys/ioctl.h> gotoxy(int x, int y) int i; for(i=0; i<y; i++) printf("\n"); for(i=0; i<x; i++) printf(" "); printf("o\n"); //labda ikonja //kurzor pozicionálása //lefelé tolás //jobbra tolás int main() while (1) struct winsize w; ioctl(0, TIOCGWINSZ, &w); int egyx=1; int egyy=-1; int j=78; int i; int x=2; //a labda kezdeti pozíciója int y=2; int magas=w.ws_row; int szel=w.ws_col; int ty[magas];//magasság // a pálya mérete int tx[szel];//szélesség //pálya széleinek meghatározás for(i=0; i<magas-1; i++) ty[i]=1; ty[1]=-1; ty[magas-2]=-1; for(i=0; i<szel-1; i++) tx[i]=1; tx[1]=-1; tx[szel-1]=-1; while(1) //címsor és pozíció kijelzése for(i=0; i<szel/2-4; i++) printf("_"); printf("x=%2d", x); printf("y=%2d", y); for(i=0; i<=szel/2-5; i++) printf("_");

160 A Debreceni Egyetem programozói évkönyve 130 / 404 gotoxy(x,y); //printf("o\n"); Áthelyezve a gotoxy függvényve x+=egyx; y+=egyy; egyx*=tx[x]; egyy*=ty[y]; usleep (50000); system("clear"); struct winsize w; ioctl(0, TIOCGWINSZ, &w); int magasha=w.ws_row; int szelesha=w.ws_col; if (magas!=magasha szel!=szelesha) break; return 0; A program jellemzői: Ezt a programot már előttem elkészítették én csak képessé tettem arra hogy a terminál ablakot futás közben módosítani lehessen Helló, Világ a sztenderd hibára A megoldást a../source/kezdo/elsoc/hello/hello.c forrásállományba helyeztem el. #include<stdio.h> int main () fprintf (stdout, "Helló világ\n"); fprintf (stderr, "Helló világ\n"); return 0; A programunkban az fprintf segítségével tudjuk eldönteni hova szeretnénk kiírni. Az stderr segítségével a sztenderd hibakimenetre írunk. Ellenőrzés splint-el (Kis Dávid) [../udprog-code/source/kezdo/elsoc/hello]$ splint hello.c Nem taltált hibát. Eredménye: [Splint May 2009 Finished checking --- no warnings

161 A Debreceni Egyetem programozói évkönyve 131 / 404 public class hello public static void main(string[] args) System.out.println("Hello Vilag"); System.err.println("Hello Vilag"); Átlag A megoldást a../source/kezdo/elsoc/atlag/atlag.c forrásállományba helyeztem el. #include<stdio.h> #include<stdlib.h> #include<ctype.h> int main() int ch,osszeg=0,db=0; double atlag; while((scanf("%d",&ch))>0) osszeg+=ch; db++; atlag=(double)osszeg/db; printf("az atlag:%0.2f\n",atlag); return 0; A programunk beolvas a scanf segítségével számokat amíg crtl + d-t nem ütünk le majd azokat össze adja és a végén átlagot számol belőle. A program splint ellenőrzésnél ezt a hibát dobta. /usr/include/ctype.h:47:5: Parse Error: Non-function declaration: BEGIN_DECLS : int Véletlen számok A megoldást a../source/kezdo/elsoc/veletlenszamok/veletlensz.c forrásállományba helyeztem el. #include<stdio.h> #include<stdlib.h> #include<time.h> int main (void) //printf("add meg, hogy hany veletlen szamot szeretnel generaltatni!\n"); int db,i,szam; scanf("%d",&db); srand(time(null)); for(i=0;i<db;i++)

162 A Debreceni Egyetem programozói évkönyve 132 / 404 szam=rand()%10; printf("%d\n",szam); return 0; Ha az srand függvényt nem használjuk, akkor többszöri futtatás esetén a generált számok nem lesznek véletlenek, mindig ismétlődnek. Ez akkor nem okoz problémát, ha nincs szükségünk valódi véletlen számokra. Az srand függvény a rendszeridőt felhasználva már véletlen számokat produkál. A csővezeték (pipe) segítségével a program kimenetét át tudjuk irányítani egy másik programunk bemenetére. Jelen esetben a generált számokat átirányítjuk az átlagszámító programunkra. Először mindkét programot fordítjuk, melyek legyenek veletlen és atlag. Majd kiadjuk az alábbi parancsot: [../udprog-code/source/kezdo/elsoc/veletlenszamok]$./veletlen./../atlag/atlag Ellenőrzés splint-el: [../udprog-code/source/kezdo/elsoc/veletlenszamok]$ splint veletlensz.c Eredmény: [Splint May 2009 veletlensz.c: (in function main) veletlensz.c:8:1: Return value (type int) ignored: scanf("%d", &db) Result returned by function call is not used. If this is intended, can cast result to (void) to eliminate message. (Use -retvalint to inhibit warning) veletlensz.c:9:8: Function srand expects arg 1 to be unsigned int gets time_t: time(null) To allow arbitrary integral types to match any integral type, use +matchanyintegral. Finished checking code warnings A szóhossz a gépeden A szóhossz a gépeden, sizeof operátorral A megoldást a../source/kezdo/elsoc/szohossz/szohossz_sizeof.c forrásállományba helyeztem el. #include <stdio.h> int main() printf("%d\n", sizeof(int)*8); return 0; A program meghatázozza a számítógép szóhosszát, sizeof() segítségével. A lelkes manuál olvasó a *8 helyett *CHAR_BITet ír: $ man limits.h Forditjuk és futtatjuk a programot a következőképpen: [../udprog-code/source/kezdo/elsoc/szohossz]$ gcc -o szohossz_sizeof.c szohossz_sizeof [../udprog-code/source/kezdo/elsoc/szohossz]$./szohossz_sizeof Futtatás után én a következő eredményt kapom:

163 A Debreceni Egyetem programozói évkönyve 133 / Ellenőrzés splint-el: [../udprog-code/source/kezdo/elsoc/szohossz]$ splint szohossz.c Eredmény: [Splint May 2009 szohossz.c: (in function main) szohossz.c:9:10: Left operand of <<= may be negative (int): n <<= 1 The left operand to a shift operator may be negative (behavior is implementation-defined). (Use -shiftimplementation to inhibit warning) szohossz.c:9:10: Test expression for while not boolean, type int: n <<= 1 Test expression type is not boolean or int. (Use -predboolint to inhibit warning) Finished checking code warnings A szóhossz a gépeden, bitműveletes módszerrel A megoldást a../source/kezdo/elsoc/szohossz/szohossz.c forrásállományba helyeztem el. #include <stdio.h> int main(void) int h = 0; int n = 0x01; do ++h; while(n<<=1); printf("a szohossz ezen a gepen: %d bites\n", h); return 0; A program meghatázozza a számítógép szóhosszát, amint látható, bittolásos módszerrel. Forditjuk és futtatjuk a programot a következőképpen: [../udprog-code/source/kezdo/elsoc/szohossz]$ gcc -o szohossz_sizeof.c szohossz [../udprog-code/source/kezdo/elsoc/szohossz]$./szohossz Futtatás után én a következő eredményt kapom: A szohossz ezen a gepen: 32 bites Ellenőrzés splint-el: [../udprog-code/source/kezdo/elsoc/szohossz]$ splint szohossz_sizeof.c Eredmény: [Splint May 2009 szohossz_sizeof.c: (in function main) szohossz_sizeof.c:4:28: Format argument 1 to printf (%d) expects int gets arbitrary unsigned integral type: sizeof(int) * 8

164 A Debreceni Egyetem programozói évkönyve 134 / 404 To allow arbitrary integral types to match any integral type, use +matchanyintegral. szohossz_sizeof.c:4:10: Corresponding format code Finished checking code warning BogoMIPS Készítette: Szentpéteri Annamária. A megoldást a fájlban leírtak alapján készítettem el és a../source/kezdo/elsoc/- BogoMIPS/bogoMIPS.c nevű fájlban található. Ez a függvény arra szolgál, hogy segítsen lemérni az időt, ami az elvégzéséhez szükséges, mint ahogy az lentebb látható is lesz. #include <stdio.h> #include <time.h> void delay (unsigned long long int loops) unsigned long long int i; for ( i=0; i<loops; i++) ; Miután megtörtént a loops_per_sec és a ticks változók létrehozása a while ciklusban a ticks előbb az aktuális órajelet kapja meg értékül, aztán pedig meghívódik a delay függvény, ami addig fut, míg a loops_per_sec-nél nagyobb értékű nem lesz a ciklusváltozó. Az eltelt időt a tricks fogja tárolni, miután a régebbi értékét kivontuk a clock() függvény visszatérési értékéből. Fontos, hogy a loops_per_sec értéke mindig egy bittel balra el lesz tolva minden ciklus kezdetekor, ergo a ciklus csak akkor áll le, ha túlcsordulás miatt csupa nulla van a loops_per_sec változóban, vagy a belső if függvény feltétele igaz lesz. int main(void) unsigned long long int loops_per_sec = 1; unsigned long long int ticks; printf ("Calibrating delay loop.."); fflush(stdout); while ((loops_per_sec <<= 1 )) ticks = clock(); delay (loops_per_sec); ticks = clock() - ticks; Ezután kiíratja a ticks és a loops_per_sec aktuális értékeit, majd egy feltétel vizsgálat jön. Ha a ticks nagyobb vagy egyenlő, mint a CLOCKS_PER_SEC beépített konstans akkor a következő történik: A loops_per_sec értékét megváltoztatja, majd kiírja a végeredményt a képernyőre. printf ("%llu %llu\n", ticks, loops_per_sec); if (ticks >= CLOCKS_PER_SEC) loops_per_sec = (loops_per_sec / ticks) * CLOCKS_PER_SEC;

165 A Debreceni Egyetem programozói évkönyve 135 / 404 printf ("ok - %llu.%02llu BogoMIPS\n", loops_per_sec/500000, (loops_per_sec/5000) % 100); return 0; printf ("failed\n"); return -1; A programo végén az utolsó két sor csak akkor hajtódik meg, ha az if feltétele sohasem teljesül, tehát a loops_per_sec változóban túlcsordulás lép fel és csupa nulla lesz benne tárolva. Ekkor egyértelműen hibás az eredmény Környezeti változók A megoldást a../source/kezdo/elsoc/korny_valt/korny_valt.c forrásállományba helyeztem el. #include <stdio.h> int main( int argc, char **argv, char **envp ) int i; for ( i = 0; ; ++i ) if ( envp[i][0] ) printf( "A %d. kornyezeti valtozo: %s\n", i+1, envp[i] ); else break; return 0; A korny_valt.c program kiírja a környezeti változókat a getenv függvény segítsége nélkül. A forrást fordítjuk, majd futtatjuk. [../udprog-code/source/kezdo/elsoc/korny_valt]$ gcc korny_valt.c -o korny_valt [../udprog-code/source/kezdo/elsoc/korny_valt]$./korny_valt Splintel történő ellenőrzés során ezekre panaszkodott. Main függvénynek 3 argumentum lett megadva, de 2 ajánlott. If feltételnél nem boolean típus van megadva. A paraméterként megadott argc nincs felhasználva. korny_valt.c:3:5: Function main declared with 3 args, should have 2 (int argc, char *argv[]) korny_valt.c:8:14: Test expression for if not boolean, type char: envp[i - ][0] Test expression type is not boolean. korny_valt.c:3:15: Parameter argc not used A lexikális elemzéssel kapcsolatos első programjaid Betűk számolása A feladat megoldását Akai József Zsolt készítette (Busák Zoltán Tutor segítségével)

166 A Debreceni Egyetem programozói évkönyve 136 / 404 A megoldást a../source/kezdo/elsoc/betukszama/betukszama.l forrásállományba helyeztem el. %#include <string.h> int betuk_szama=0,egyeb=0; % %%. egyeb++; \n egyeb++; [0-9]+ egyeb++; [a-za-z]+ betuk_szama+=strlen(yytext); %% int main() yylex(); printf("%d betu\n",betuk_szama); return 0; A programunk a betuk_szama változóba számolja a betűket, az egyéb változóba a többi karaktert. A Ctrl-D leütése után kiírja a betűk számát. A forrást fordítjuk majd futtatjuk. [../udprog-code/source/kezdo/elsoc/betukszama]$ lex -o betukszama.c betukszama.l [../udprog-code/source/kezdo/elsoc/betukszama]$ gcc betukszama.c -o betukszama -lfl [../udprog-code/source/kezdo/elsoc/betukszama]$./betukszama Számok számolása A megoldást a../source/kezdo/elsoc/szamokszama/szamokszama.l forrásállományba helyeztem el. % #include <string.h> int szamok_szama = 0; % %% [0-9]+ ++szamok_szama; [a-za-z][a-za-z0-9]* ; %% int main() yylex(); printf("%d szam\n", szamok_szama); return 0; A programunk a szamok_szama változóba számolja a szamokat. A Ctrl-D leütése után kiírja a szamok számát. A forrást fordítjuk majd futtatjuk. A Lex-ről: A lex egy program, amely segítségével lexikális szabályokból lexikális elemző programkódot lehet generálni. A lex egy szövegfájlból olvassa be a lexikális szabályokat, s kimenetként C nyelvű kódot állít elő. [../udprog-code/source/kezdo/elsoc/szamokszama]$ lex -o szamokszama.c szamokszama.l

167 A Debreceni Egyetem programozói évkönyve 137 / 404 Elkesziti a szamokszama.c file-t Forditjuk, és futtatjuk a szamokszama.c forráskódot, a következőképpen: [../udprog-code/source/kezdo/elsoc/betukszama]$ gcc szamokszama.c -o szamokszama -lfl [../udprog-code/source/kezdo/elsoc/betukszama]$./szamokszama Teszt példa: Mai datum: Ctrl-D lenyomása után kiírja az eredményt: 3 szam Szavak számolása A megoldást a../source/kezdo/elsoc/sorokszama/szavakszamolasa.l forrásállományba helyeztem el. % #include <string.h> int szavak_szama = 0; % %% [a-za-z]* ++szavak_szama; %% int main() yylex(); printf("%d szó\n",szavak_szama); return 0; A szavak_szama valtozóban tárolja a szavak számát. A crtl-d leütése után kiírja a szavak számát. A forrást fordítjuk, majd futtatuk: [../udprog-code/source/kezdo/elsoc/szavakszama]$ lex -o szavakszamolasa.c szavakszamolasa -.l [../udprog-code/source/kezdo/elsoc/szavakszama]$ gcc szavakszamolasa.c -o szavakszamolasa - -lfl [../udprog-code/source/kezdo/elsoc/szavakszama]$./szavakszamolasa Sorok számolása A megoldást a../source/kezdo/elsoc/sorokszama/sorokszama.l forrásállományba helyeztem el. % #include <string.h> int sorok_szama = 0; % %% \n ++sorok_szama; %%

168 A Debreceni Egyetem programozói évkönyve 138 / 404 int main() yylex(); printf("%d sor\n", sorok_szama); return 0; A programunk a sorok_szama változóba számolja a sorokat. A Ctrl-D leütése után kiírja a sorok számát. A forrást fordítjuk majd futtatjuk. [../udprog-code/source/kezdo/elsoc/betukszama]$ lex -o sorokszama.c sorokszama.l [../udprog-code/source/kezdo/elsoc/betukszama]$ gcc sorokszama.c -o sorokszama -lfl [../udprog-code/source/kezdo/elsoc/betukszama]$./sorokszama Rendszerprogramozással kapcsolatos első programjaid Villa A leírást a feladathoz Kis Dávid készítette. A megoldást a../source/kezdo/elsoc/arva/arva.c forrásállományba helyeztem el. /*Závaczki Roland*/ #include<stdio.h> #include<unistd.h> int main() pid_t p; /* Gyermekfolyamat */ p=fork(); if(p==0) /* fork() 0 visszatérési értékkel */ sleep(10); printf("the child process pid is %d parent pid %d\n", getpid(), getppid()); /*parent/child 20sec-et vár,majd kilép*/ sleep(20); printf("\nprocess %d vége,parent pid %d...\n", getpid(), getppid()); return 0; Árva folyamat amikor a szülő-folyamat hal meg előbb. Ekkor a gyermekhez tárolt szülo-folyamat azonosító mező érvénytelen folyamat-azonosítót tartalmaz! Ezt úgy oldották meg, hogy bevezettek egy speciális (1-es azonosítójú) folyamatot, az init folyamatot (ez indítja el a terminálokon a login: folyamatokat). Az "árva" gyermek-folyamatoknak ez lesz szülo-folyamatukként tárolva. Ez majd idonként figyeli, és megtisztítja a "halott árva zombie" folyamatok által lefoglalt processztábala-bejegyzésektol a processz-táblát. (Az init folyamat sosem hajt végre exit() rendszerhívást.) Fordítjuk a forrást, majd futtatjuk:

169 A Debreceni Egyetem programozói évkönyve 139 / 404 [../udprog-code/source/kezdo/elsoc/arva]$ gcc arva.c -o arva [../udprog-code/source/kezdo/elsoc/arva]$./arva Futtatás eredménye: [Jelenlegi folyamat ID-je : 4636 [ Gyermek folyamat forkolasa... ] Szulo folyamat befejezodott... Gyerek folyamat alszik......~/udprog-code/source/kezdo/elsoc/arva$ Arva gyerek szulo ID-je: 1 Láthatjuk, hogy a gyerek-folyamat szülő ID-je 1 lett, azaz "meghalt" a szülőfolyamat előbb mint a gyerek, igy a gyerefolyamat árvaként hal meg később. Ellenőrzés splint-el: [../udprog-code/source/kezdo/elsoc/arva$ splint arva.c A splint eredmény : [Splint May 2009 arva.c: (in function main) arva.c:6:9: Unrecognized identifier: getpid Identifier used in code has not been declared. (Use -unrecog to inhibit warning) arva.c:11:9: Unrecognized identifier: fork arva.c:16:14: Argument to exit has implementation defined behavior: -1 The argument to exit should be 0, EXIT_SUCCESS or EXIT_FAILURE (Use -exitarg to inhibit warning) arva.c:23:9: Unrecognized identifier: sleep arva.c:29:48: Unrecognized identifier: getppid Finished checking code warnings A figyelmeztetés oka hogy nem lettek deklarálva a getpid fork és getppid. A getpid és fork manuállapja szerint a következő include filok kellenek a megfelelő működéshaz : #include <sys/types.h> #include <unistd.h> Azonban nálam a függvények prototípusának leírása, a main függvény előtt, oldotta meg a figyelmeztetéseket : int getpid(); void sleep(int); int getppid(); int fork(); Ezután a splint-et futtatva : [Splint May 2009 arva.c: (in function main) arva.c:22:14: Argument to exit has implementation defined behavior: -1 The argument to exit should be 0, EXIT_SUCCESS or EXIT_FAILURE (Use -exitarg to inhibit warning)

170 A Debreceni Egyetem programozói évkönyve 140 / 404 Finished checking code warning Zombi A leírást a feladathoz Kis Dávid készítette. A megoldást a../source/kezdo/elsoc/zombi/zombi.c forrásállományba helyeztem el. /*Závaczki Roland*/ #include <sys/types.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> int main(void) pid_t pid;//gyermekfolyamat létrehozása// if ((pid = fork()) == -1)//Ha a visszatérési értéke -1 akkor sikertelen// printf("fork hiba"); else if (pid == 0) exit(0);//a szülő nem add ki várási parancsot ezért ZOMBI lesz// sleep(3); system("ps"); exit(0); A Unix felfogása szerint, azt a folyamatot, amely befejeződött, de a szülő nem adott ki wait parancsot, zombie folyamatnak nevezzük. Ebben az állapotban a folyamatnak nincs semmilyen lefoglalt memóriaterülete, csak egy bemenete a folyamattáblában. A rendszer felhasználhatja a lefoglalt memóriazónákat, illetve bezárhatja az általa megnyitott fájlokat. A zombie folyamatokat a ps parancs segítségével követhetjük nyomon. A fork() rendszerhívás C nyelvben egy int típusú értékkel tér vissza. Ez alapján lehet megkülönböztetni, hogy melyik a gyerek, s melyik a szülő folyamat. Fordítjuk a forrást, majd futtatjuk: [../udprog-code/source/kezdo/elsoc/zombi]$ gcc zombi_id.c -o zombi_id [../udprog-code/source/kezdo/elsoc/zombi]$./zombi_id Láthatjuk a zombi folyamatot, valahogy így: [PID TTY TIME CMD 3101 pts/1 00:00:00 bash 3999 pts/1 00:00:00 zombi 4000 pts/1 00:00:00 zombi <defunct> 4001 pts/1 00:00:00 sh 4002 pts/1 00:00:00 ps

171 A Debreceni Egyetem programozói évkönyve 141 / 404 A szülő nem addott ki várási (wait) parancsot, ezért ZOMBI lett! Ellenőrzés splint-el: [/udprog-code/source# splint kezdo/elsoc/zombi/zombi_id.c Eredmény: [Splint Feb 2009 kezdo/elsoc/zombi/zombi_id.c:1: Include file <sys/types.h> matches the name of a POSIX library, but the POSIX library is not being used. Consider using +posixlib or +posixstrictlib to select the POSIX library, or -warnposix to suppress this message. Header name matches a POSIX header, but the POSIX library is not selected. (Use -warnposixheaders to inhibit warning) kezdo/elsoc/zombi/zombi_id.c:2:23: Cannot find include file sys/types.h on search path: /usr/include;/usr/include Preprocessing error. (Use -preproc to inhibit warning) kezdo/elsoc/zombi/zombi_id.c:5: Include file <unistd.h> matches the name of a POSIX library, but the POSIX library is not being used. Consider using +posixlib or +posixstrictlib to select the POSIX library, or -warnposix to suppress this message. Preprocessing error for file: /home/ranieth/prog/udprog-code/source/kezdo/elsoc/ Zombi/zombi_id.c *** Cannot continue Riasztás A megoldást a../source/kezdo/elsoc/riasztas/risztas.c forrásállományba helyeztem el. #include <stdio.h> #include <stdlib.h> #include <signal.h> #include <sys/types.h> #include <sys/wait.h> #include <unistd.h> int gyermekem_pid; void riasztas_kezelo() printf("gyermekfolyamat kilovese\n"); kill(gyermekem_pid, SIGKILL); int main(void) int statusz; printf("fork() elott PID: %d\n", getpid()); if((gyermekem_pid = fork())!= -1) if(gyermekem_pid) printf("szulo folyamat PID: %d, gyermekem: %d szulom %d\n", getpid(), gyermekem_pid, getppid()); signal(sigalrm, riasztas_kezelo); alarm(5); printf("pid: %d gyermekfolyamat vege\n", wait(&statusz)); else

172 A Debreceni Egyetem programozói évkönyve 142 / 404 printf("gyermek folyamat PID: %d, szulom: %d\n", getpid(), getppid()); for(;;) sleep(1); else printf("sikertelen a gyermek folyamat letrehozasa\n"); exit(-1); printf("fork() utan PID: %d\n", getpid()); return 0; A fork() rendszerhívás C nyelvben egy int típusú értékkel tér vissza, és ez az, ami alapján meg lehet különböztetni,hogy melyik a szülo- ill. melyik a gyermek-folyamat. A gyermek-folyamatban a visszatérési érték: 0, míg a szülo-folyamatban a visszatérési érték egyenlo a gyermek-folyamat pid-jével. Negatív visszatérési érték a rendszerhívás sikertelenségét jelzi (a hiba oka lehet például az, hogy nem volt elég memória a gyermek-folyamat létrehozásához). A gyermekfolyamatot az 5 másodperces késleltetés után kilövi a program. A forrást fordítom, majd futtatom. [../udprog-code/source/kezdo/elsoc/riasztas]$ gcc riasztas.c -o riasztas [../udprog-code/source/kezdo/elsoc/riasztas]$./riasztas Futtatas eredménye: fork() elott PID: 7531 Szulo folyamat PID: 7531, gyermekem: 7532 szulom 2807 Gyermek folyamat PID: 7532, szulom: másodperc elteltével: Ellenőrzés splint-el: Gyermekfolyamat kilovese PID: 7548 gyermekfolyamat vege fork() utan PID: 7547 [../udprog-code/source/kezdo/elsoc/riasztas]$ splint riasztas.c A következő eredményt kaptam: [Splint May 2009 arva.c: (in function main) arva.c:6:9: Unrecognized identifier: getpid Identifier used in code has not been declared. (Use -unrecog to inhibit warning) arva.c:11:9: Unrecognized identifier: fork arva.c:16:14: Argument to exit has implementation defined behavior: -1 The argument to exit should be 0, EXIT_SUCCESS or EXIT_FAILURE (Use -exitarg to inhibit warning) arva.c:23:9: Unrecognized identifier: sleep arva.c:29:48: Unrecognized identifier: getppid Finished checking code warnings Miszerint: 6:9: ismeretlen azonosító: getpid. Ami azt akarja mondani, hogy a getpid nem deklarált. (Miközben ugyebár az stdlib.h tartalmazza). Ugyan így van a fork-al, getppid-el is. Ezektől a program még megfelelően fog működni.

173 A Debreceni Egyetem programozói évkönyve 143 / Utolsó tennivaló A megoldást a../source/kezdo/elsoc/utolso/utolso.c forrásállományba helyeztem el. #include <signal.h> #include<stdio.h> void sigint_handler (int sig) printf ("Szeretnél megszakítani?? Ha igen nyomj CTRL+C-t"); signal (SIGINT, SIG_DFL); int main () char c; signal (SIGINT, sigint_handler); while (1) c = getchar (); return 0; A signal függvény meghatározza, hogy a rendszer a soron következő jelzést hogyan fogja kezelni. Ha handler-nek a SIG_DFL lett megadva, akkor a gépi megvalósításban meghatározott alapfeltételezés szerinti kezelést végez, ha pedig a SIG_IGN lett megadva, akkor a jelzést figyelmen kívül hagyja. Minden más esetben a handler-ben megadott, a jelzés típusának megfelelő argumentummal hívott függvény végzi a jelzés kezelését. Jelen esetben ha SIGINT jelzés keletkezik az irányítás átadódik a sigint_handler függvénynek, mely egy újabb megszakításra vár. Ellenőrzés splint-el: [../source/kezdo/elsoc/utolso$ splint utolso.c A következő eredményt kaptam: [Splint May 2009 utolso.c: (in function sigint_handler) utolso.c:8:3: Return value (type [function (int) returns void]) ignored: signal(sigint, S... Result returned by function call is not used. If this is intended, can cast result to (void) to eliminate message. (Use -retvalother to inhibit warning) utolso.c:5:21: Parameter sig not used A function parameter is not used in the body of the function. If the argument is needed for type compatibility or future plans, use /*@unused@*/ in the argument declaration. (Use -paramuse to inhibit warning) utolso.c: (in function main) utolso.c:16:3: Return value (type [function (int) returns void]) ignored: signal(sigint, s... utolso.c:17:10: Test expression for while not boolean, type int: 1 Test expression type is not boolean or int. (Use -predboolint to inhibit warning) utolso.c:19:7: Assignment of int to char: c = getchar() To make char and int types equivalent, use +charint. utolso.c:22:10: Unreachable code: return 0

174 A Debreceni Egyetem programozói évkönyve 144 / 404 This code will never be reached on any possible execution. (Use -unreachable to inhibit warning) utolso.c:5:1: Function exported but not used outside utolso: sigint_handler A declaration is exported, but not used outside this module. Declaration can use static qualifier. (Use -exportlocal to inhibit warning) utolso.c:9:1: Definition of sigint_handler Finished checking code warnings Nem lokális ugrások A megoldást a../source/kezdo/elsoc/nemlokalis/ugras.c forrásállományba helyeztem el. /* * Nem lokális ugrások * Tutor: Gálffy Tamás * Tutoriált: Ács Raymund */ #include <stdio.h> #include <stdlib.h> //#include <unistd.h> #include <signal.h> void sigint_handler(int); int main(void) char szoveg[1024]; signal(sigint, sigint_handler); IdeGyereNeYoda: scanf("%s", szoveg); while (1) printf("%s \n", szoveg); scanf("%s", szoveg); //pause(); goto IdeGyereNeYoda; printf("mégse mentem Yoda\n"); return 0; void sigint_handler(int sig) /*do something*/ printf("ctrl+c. Hiperűrugrásra felkészülni!\n"); Leellenőriztem a kódot a splinttel. [../udprog-code/source/kezdo/elsoc/nemlokalis$ splint ugras.c Eredmény: [Splint May 2009 ugras.c: (in function main)

175 A Debreceni Egyetem programozói évkönyve 145 / 404 ugras.c:17:5: Return value (type [function (int) returns void]) ignored: signal(sigint, s... Result returned by function call is not used. If this is intended, can cast result to (void) to eliminate message. (Use -retvalother to inhibit warning) ugras.c:19:5: Return value (type int) ignored: scanf("%s", szoveg) Result returned by function call is not used. If this is intended, can cast result to (void) to eliminate message. (Use -retvalint to inhibit warning) ugras.c:20:12: Test expression for while not boolean, type int: 1 Test expression type is not boolean or int. (Use -predboolint to inhibit warning) ugras.c:22:9: Return value (type int) ignored: scanf("%s", szoveg) ugras.c:25:25: Unreachable code: goto IdeGyereNeYoda This code will never be reached on any possible execution. (Use -unreachable to inhibit warning) ugras.c: (in function sigint_handler) ugras.c:30:26: Parameter sig not used A function parameter is not used in the body of the function. If the argument is needed for type compatibility or future plans, use /*@unused@*/ in the argument declaration. (Use -paramuse to inhibit warning) ugras.c:12:6: Function exported but not used outside ugras: sigint_handler A declaration is exported, but not used outside this module. Declaration can use static qualifier. (Use -exportlocal to inhibit warning) ugras.c:34:1: Definition of sigint_handler Finished checking code warnings A megoldást a../source/kezdo/elsoc/nemlokalis/ugrasmashogy.c forrásállományba helyeztem el. /*Készítette: Bertalan Ádám*/ #include <stdio.h> #include <stdlib.h> #include <signal.h> #include <setjmp.h> void sighandler(int); static jmp_buf buf; int main() char c; signal(sigint, sighandler); printf("ez a ciklus előtti rész\n"); while (1) c=getchar(); printf("%c",c); longjmp(buf,1); return 0; void sighandler(int sig) char c; printf("\nhoppá! Ctrl + c lenyomva!\n"); printf("exit? (y/n)\n"); c=getchar(); if (c == y c == Y ) exit(0);

176 A Debreceni Egyetem programozói évkönyve 146 / 404 if (! setjmp(buf)) main(); Az elso párhuzamos programjaid Elromlik a változó A megoldáast a../source/kezdo/elsoc/elromlik_a_valtozo/zar_nelkul.c forrásállományba helyeztem el. A következő program azt mutatja be, hogy a (mutex által) nem védett számláló értéke "elromlik". #include <stdio.h> #include <stdlib.h> #include <pthread.h> #define SZALAK 50 int szamlalo = 0; void var(void) int i, r = 1+(int) ( * rand() / (RAND_MAX + 1.0)); for (i=0; i<r; ++i); void * novel_szal(void *id) int i; for(i=0; i<50; ++i) printf("szal: %d, %d\n", *(int *)id, pthread_self()); fflush(stdout); var(); szamlalo = szamlalo + 1; return id; csokkent_szal(void *id) int i; for(i=0; i<50; ++i) printf("szal: %d, %d\n", *(int *)id, pthread_self()); fflush(stdout); var(); szamlalo = szamlalo - 1; return id; int main (void) pthread_t sz[szalak]; int s[szalak], *r, i;

177 A Debreceni Egyetem programozói évkönyve 147 / 404 for(i=0; i<szalak; ++i) s[i]=i; if(pthread_create(&sz[i], NULL, (i<szalak/2)? novel_szal : csokkent_szal, (void *)&s[i - ])) perror("hiba"); exit(-1); for(i=0; i<szalak; ++i) pthread_join(sz[i], (void *) &r); printf("a szamlalo vegul: %d\n", szamlalo); return 0; A forrás fordítása és futtatása. $ man pthread_create Compile and link with -pthread. Azaz -pthread segítségével fordíthatjuk. [../udprog-code/source/kezdo/elsoc/elromlik_a_valtozo]$ gcc zar_nelkul.c -o - zar_nelkul -pthread [../udprog-code/source/kezdo/elsoc/elromlik_a_valtozo]$./zar_nelkul Futtatás után a következő eredményt kapjuk:... Szal: 45, Szal: 34, Szal: 11, Szal: 34, Szal: 11, A szamlalo vegul: 2 Láthatóan a globális számláló értéke elromlott. Eredetileg 0 volt, értéke 2-re változott. Ellenőrzés splint-el: [../udprog-code/source/kezdo/elsoc/elromlik_a_valtozo$ splint zar_nelkul.c Az az eset, amikor NEM romlik el a számláló: A megoldáast a../source/kezdo/elsoc/elromlik_a_valtozo/zarral.c forrásállományba helyeztem el. A következő program azt mutatja be, hogy a mutexel védett számláló nem romlik el. #include <stdio.h> #include <stdlib.h>

178 A Debreceni Egyetem programozói évkönyve 148 / 404 #include <pthread.h> #define SZALAK 50 int szamlalo = 0; pthread_mutex_t szamlalo_zar; // Mutex változó inicializálása void var(void) int i, r = 1+(int) ( *rand()/(RAND_MAX+1.0)); for(i=0; i<r; ++i) ; void * novel_szal(void *id) int i; for(i=0; i<50; ++i) printf("szal: %d, %d\n", *(int *)id, pthread_self()); fflush(stdout); var(); pthread_mutex_lock(&szamlalo_zar); //Blokkoljuk más programszálak hozzáférését. szamlalo = szamlalo + 1; //változó növelése pthread_mutex_unlock(&szamlalo_zar); //Mutex változó felszabadítása return id; void * csokkent_szal(void *id) int i; for(i=0; i<50; ++i) printf("szal: %d, %d\n", *(int *)id, pthread_self()); fflush(stdout); var(); pthread_mutex_lock(&szamlalo_zar); //Blokkoljuk más programszálak hozzáférését. szamlalo = szamlalo - 1; //változó csökkentése pthread_mutex_unlock(&szamlalo_zar); ////Mutex változó felszabadítása return id; int main(void) pthread_t sz[szalak]; int s[szalak], *r, i; for(i=0; i<szalak; ++i) s[i] = i; if(pthread_create(&sz[i], NULL, (i<szalak/2)?novel_szal:csokkent_szal, (void *)&s[i])) - //A pthread_creat rendszerfüggvény létrehoz egy új - végrehajtási szálat az éppen futó folyamatnak. //(attr=null, mert az alapértelmezett thread tulajdonságokat használjuk) perror("hiba"); exit(-1); for(i=0; i<szalak; ++i)

179 A Debreceni Egyetem programozói évkönyve 149 / 404 pthread_join(sz[i], (void *) &r); //addig vár, amíg a paraméterként adott - programszál véget nem ér. printf("a szamlalo vegul: %d\n", szamlalo); return 0; A mutex-ről: Programozástechnológiában Párhuzamos folyamatok használatakor előfordulhat, hogy két folyamat ugyanazt az Erőforrást (resource) egyszerre akarja használni. Ekkor jellemzően felléphet Versengés. Ennek kiküszöbölésére a gyorsabb folyamat egy, az erőforráshoz tartozó mutexet zárol (ún. lock-ol). Amíg a mutex zárolva van (ezt csak a zároló folyamat tudja feloldani - kivéve speciális eseteket), addig más folyamat nem férhet hozzá a zárolt erőforráshoz. Tehát: A mutex lehetővé teszi annak biztosítását, hogy egy védett erőforrással egyszerre mindig csak egyetlen feladat dolgozhasson, és így elkerülhetők legyenek a párhuzamos - egymást zavaró - hozzáférések, módosítások által okozott problémák. A forrás fordítása és futtatása ugyan úgy zajlik, mint az előző példánál: [../udprog-code/source/kezdo/elsoc/elromlik_a_valtozo]$ gcc zarral.c -o zarral - - pthread [../udprog-code/source/kezdo/elsoc/elromlik_a_valtozo]$./zarral Futtatás után a következő eredményt kapjuk:... Szal: 48, Szal: 48, Szal: 48, Szal: 48, A szamlalo vegul: 0 Láthatóan a globális számláló értéke nem változott. Ellenőrzés splint-el: [../udprog-code/source/kezdo/elsoc/elromlik_a_valtozo$ splint zarral.c Az első algoritmizálási programjaid Mandelbrot halmaz A feladatot készítette: Tuza József, tutor: Szabó Attila. A megoldás a../source/kezdo/elsocpp/mandelbrot/mandelbrot.cpp forrásállományban van. #include <png++/png.hpp> #define N 500 #define M 500 #define MAXX 0.7 #define MINX -2.0 #define MAXY 1.35 #define MINY void GeneratePNG( int tomb[n][m]) png::image< png::rgb_pixel > image(n, M);

180 A Debreceni Egyetem programozói évkönyve 150 / 404 for (int x = 0; x < N; x++) for (int y = 0; y < M; y++) image[x][y] = png::rgb_pixel(tomb[x][y], tomb[x][y], tomb[x][y]); image.write("kimenet.png"); struct Komplex double re, im; ; int main() int tomb[n][m]; int i, j, k; double dx = (MAXX - MINX) / N; double dy = (MAXY - MINY) / M; struct Komplex C, Z, Zuj; int iteracio; for (i = 0; i < M; i++) for (j = 0; j < N; j++) C.re = MINX + j * dx; C.im = MAXY - i * dy; Z.re = 0; Z.im = 0; iteracio = 0; while(z.re * Z.re + Z.im * Z.im < 4 && iteracio++ < 255) Zuj.re = Z.re * Z.re - Z.im * Z.im + C.re; Zuj.im = 2 * Z.re * Z.im + C.im; Z.re = Zuj.re; Z.im = Zuj.im; tomb[i][j] = iteracio; GeneratePNG(tomb); return 0; A program futtatásához szükséges van a png++ csomagra, ugyanis az eredmény PNG fájlban fog tárolódni. A forrás fordítása és futtatása. [../source/kezdo/elsocpp/mandelbrot]$ g++ -c mandelbrot.cpp libpng-config --cflags [../source/kezdo/elsocpp/mandelbrot]$ g++ -o mandelbrot mandelbrot.o libpng-config -- - ldflags

181 A Debreceni Egyetem programozói évkönyve 151 / 404 [../source/kezdo/elsocpp/mandelbrot]$./mandelbrot ábra. A Mandelbrot halmaz feladat kimenete (kimenet.png) Elfolyik a PageRank A feladatot megoldotta: Szentpéteri Annamária. Tutor: Bereczki László. ( ) Megoldás: /source/kezdo/elsoc/- pagerank/pagerank_ c [...] int main (void) double L[4][4] = 0.0, 0.0, 1.0/3.0, 0.0, 1.0, 1.0/2.0, 1.0/3.0, 1.0, 0.0, 1.0/2.0, 0.0, 0.0, 0.0, 0.0, 1.0/3.0, 0.0 ; [...] double L1[4][4] = 0.0, 0.0, 1.0/3.0, 0.0, 1.0, 1.0/2.0, 1.0/3.0, 0.0, 0.0, 1.0/2.0, 0.0, 0.0, 0.0, 0.0, 1.0/3.0, 0.0 ; printf("\naz eredeti mátrix értékeivel történő futás:\n"); pagerank(l); printf("\namikor az egyik oldal semmire sem mutat:\n"); pagerank(l1); [...] printf("\n");

182 A Debreceni Egyetem programozói évkönyve 152 / 404 return 0; gcc pagerank_ c -lm./a.out Az eredeti, tanár által megadott értékkekel történő futás: Amikor az egyik oldal semmire sem mutat: Ellenőrzés splint-el: [/udprog-code/source# splint kezdo/elsoc/pagerank/pagerank_ c Eredmény: [Splint Feb 2009 kezdo/elsoc/pagerank/pagerank_ c:28:17: Function parameter T declared as manifest array (size constant is meaningless) A formal parameter is declared as an array with size. The size of the array is ignored in this context, since the array formal parameter is treated as a pointer. (Use -fixedformalarray to inhibit warning) kezdo/elsoc/pagerank/pagerank_ c:6:1: Function exported but not used outside pagerank_ : kiir A declaration is exported, but not used outside this module. Declaration can use static qualifier. (Use -exportlocal to inhibit warning) kezdo/elsoc/pagerank/pagerank_ c:13:1: Definition of kiir kezdo/elsoc/pagerank/pagerank_ c:16:1: Function exported but not used outside pagerank_ : tavolsag kezdo/elsoc/pagerank/pagerank_ c:25:1: Definition of tavolsag kezdo/elsoc/pagerank/pagerank_ c:28:1: Function exported but not used outside pagerank_ : pagerank kezdo/elsoc/pagerank/pagerank_ c:56:1: Definition of pagerank Finished checking code warnings Ellopni a PageRank értéket A feladatot megoldotta: Szentpéteri Annamária. Tutor: Bereczki László. ( ) Megoldás: /source/kezdo/elsoc/- pagerank/pagerank_ c [...] int main (void)

183 A Debreceni Egyetem programozói évkönyve 153 / 404 double L[4][4] = 0.0, 0.0, 1.0/3.0, 0.0, 1.0, 1.0/2.0, 1.0/3.0, 1.0, 0.0, 1.0/2.0, 0.0, 0.0, 0.0, 0.0, 1.0/3.0, 0.0 ; [...] double L2[4][4] = 0.0, 0.0, 1.0/3.0, 0.0, 1.0, 1.0/2.0, 1.0/3.0, 0.0, 0.0, 1.0/2.0, 0.0, 0.0, 0.0, 0.0, 1.0/3.0, 1.0 ; printf("\naz eredeti mátrix értékeivel történő futás:\n"); pagerank(l); [...] printf("\namikor az egyik oldal csak magára mutat:\n"); pagerank(l2); printf("\n"); return 0; gcc pagerank_ c -lm./a.out Az eredeti, tanár által megadott értékkekel történő futás: Amikor az egyik oldal csak magára mutat: Ellenőrzés splint-el: [/udprog-code/source# splint kezdo/elsoc/pagerank/pagerank_ c Eredmény: [Splint Feb 2009 kezdo/elsoc/pagerank/pagerank_ c:28:17: Function parameter T declared as manifest array (size constant is meaningless) A formal parameter is declared as an array with size. The size of the array is ignored in this context, since the array formal parameter is treated as a pointer. (Use -fixedformalarray to inhibit warning) kezdo/elsoc/pagerank/pagerank_ c:6:1:

184 A Debreceni Egyetem programozói évkönyve 154 / 404 Function exported but not used outside pagerank_ : kiir A declaration is exported, but not used outside this module. Declaration can use static qualifier. (Use -exportlocal to inhibit warning) kezdo/elsoc/pagerank/pagerank_ c:13:1: Definition of kiir kezdo/elsoc/pagerank/pagerank_ c:16:1: Function exported but not used outside pagerank_ : tavolsag kezdo/elsoc/pagerank/pagerank_ c:25:1: Definition of tavolsag kezdo/elsoc/pagerank/pagerank_ c:28:1: Function exported but not used outside pagerank_ : pagerank kezdo/elsoc/pagerank/pagerank_ c:56:1: Definition of pagerank Finished checking code warnings Alternatív tabella A feladatot megoldotta: Szentpéteri Annamária. Tutor: Bereczki László. ( ) Megoldás: /source/kezdo/elsocpp/- alt_tab/pr.cpp A feladatot a feladat az alternatív tabella és az alternatív tabellára vonatkozó progpater bejegyzés alapján készült a megadott java program átírásával, és a pagerank algoritmus implementálásával, megfelelő átalakításával. #include <iostream> #include <string> //a csapat neveknek #include <math.h> //gyök függvény const int NoT = 16; //Number of Teams const int cross[not][not] = //lejátszott meccsek "kódtáblája" 0, 3, 2, 1, 2, 3, 2, 3, 3, 2, 3, 2, 2, 2, 2, 3, 3, 0, 2, 1, 3, 2, 1, 3, 3, 3, 1, 2, 1, 3, 2, 1, 1, 1, 0, 3, 3, 1, 3, 2, 2, 2, 3, 1, 1, 1, 2, 1, 3, 2, 1, 0, 1, 2, 1, 1, 1, 1, 1, 1, 3, 2, 1, 1, 3, 3, 3, 2, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 1, 1, 3, 1, 1, 0, 1, 1, 3, 2, 2, 1, 2, 1, 2, 3, 1, 2, 3, 2, 1, 1, 0, 1, 1, 1, 3, 3, 1, 3, 3, 1, 3, 1, 1, 1, 3, 2, 1, 0, 3, 1, 3, 1, 1, 1, 3, 1, 3, 3, 1, 2, 3, 1, 2, 1, 0, 3, 3, 2, 1, 1, 3, 1, 3, 1, 1, 2, 3, 2, 3, 1, 1, 0, 3, 1, 3, 1, 3, 3, 2, 3, 1, 2, 1, 1, 3, 1, 1, 2, 0, 1, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, 3, 1, 2, 1, 1, 0, 2, 1, 2, 3, 1, 2, 1, 1, 2, 2, 1, 1, 1, 1, 3, 1, 0, 3, 1, 2, 2, 1, 2, 2, 1, 2, 1, 1, 1, 1, 3, 1, 1, 0, 1, 1, 1, 3, 1, 1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 2, 1, 2, 3, 1, 1, 1, 1, 1, 2, 1, 3, 0 ; const std::string teams[not] = "BFC Siófok", "Budapest Honvéd", "Vasas", "Debreceni VSC", "Ferencváros", "Győri ETO", "Kaposvári Rákóczi", "Kecskeméti TE", "Lombard Pápa", "MTK Budapest", "Paksi FC", //csapat nevek

185 A Debreceni Egyetem programozói évkönyve 155 / 404 "Szolnoki MÁV FC", "Szombathelyi Haladás", "Újpest", "Videoton", "Zalaegerszegi TE" ; void // pagerank kiir függvénye, módosítva a csapat nevek miatt kiir (double tomb[], const std::string names[], int db) int i; for (i=0; i<db; ++i) std::cout<<names[i]<<": "<<tomb[i]<<std::endl; double // pagerank tavolsag függvénye tavolsag (double PR[], double PRv[], int n) int i; double osszeg=0; for (i = 0; i < n; ++i) osszeg += (PRv[i] - PR[i]) * (PRv[i] - PR[i]); return sqrt(osszeg); void // eredetihez képesti módosítás: ciklus változókban 4-es helyett NoT pagerank(double T[NoT][NoT]) double PR[NoT]; //ebbe megy az eredmény double PRv[NoT]; //ezzel szorzok for(int i=0;i<not;i++) PR[i] = 0.0; PRv[i] = 1.0 / (NoT * 1.0); for(;;) // ide jön a mátrix művelet for (int i=0; i<not; i++) PR[i]=0.0; for (int j=0; j<not; j++) PR[i] = PR[i] + T[i][j]*PRv[j]; if (tavolsag(pr,prv,not) < ) break; // ide meg az átpakolás PR-ből PRv-be for (int i=0;i<not; i++) PRv[i]=PR[i]; kiir (PR, teams, NoT);

186 A Debreceni Egyetem programozói évkönyve 156 / 404 void null_matrix(int matrix[not][not]) for (int i = 0; i < NoT; ++i) for (int j = 0; j < NoT; ++j) matrix[i][j] = 0; void load_data(int matrix[not][not]) for (int i = 0; i < NoT; ++i) for (int j = 0; j < NoT; ++j) matrix[i][j] = cross[i][j]; void load_points(const int matrix[not][not], int points[not][not]) null_matrix(points); for (int i = 0; i < NoT; ++i) for (int j = 0; j < NoT; ++j) if (matrix[i][j] == 1) // hazai nyert - zöld ++points[i][j]; else if (matrix[i][j] == 2) // döntetlen - sárga ++points[i][j]; ++points[j][i]; else if (matrix[i][j] == 3) // vendégként nyert - piros ++points[j][i]; else if (matrix[i][j] == 0) // nem játszott - üres ; else std::cout<<"i feel a disturbance in the force.."; void col_summing(const int points[not][not],int col_sum[not]) for (int i = 0; i < NoT; ++i) int c = 0; for (int j = 0; j < NoT; ++j) c += points[j][i]; col_sum[i] = c;

187 A Debreceni Egyetem programozói évkönyve 157 / 404 void init_pr(const int points[not][not],const int col_sum[not],double alt_pr[not][not]) for (int i = 0; i < NoT; ++i) for (int j = 0; j < NoT; ++j) if (col_sum[j]!= 0.0) alt_pr[i][j]=points[i][j] * (1.0 / col_sum[j]); else alt_pr[i][j]=0.0; int main() int matrix[not][not]; //eredeti eredmények betöltése load_data(matrix); int points[not][not]; //pontok átkonvertálása load_points(matrix,points); int col_sum[not]; //oszlop összeg számolás col_summing(points,col_sum); double alt_pr[not][not]; //pontok eloszlatása - "vízvezeték szerűen" init_pr(points, col_sum, alt_pr); std::cout<<std::endl<<"rank: "<<std::endl<<"-----"<<std::endl; pagerank(alt_pr); //pagerank alkalmazása std::cout<<std::endl; return 0; Az első GNU/Linux kernellel kapcsolatos programjaid Helló, Világ! a kernelből A feladatot elkészítette: Gyügyei Tamás A fájlokat nem részletezem, azok a mappában megtalálhatóak. A következőkben a telepités menetét fogom leirni. A következőket szükséges elvégezni, mielőtt a fájlokat használnád: $ sudo -i # apt-get install module-assistant

188 A Debreceni Egyetem programozói évkönyve 158 / 404 # m-a prepare $ sudo apt-get install build-essential linux-headers-$(uname -r) A 2 forrásállományt a../source/kezdo/elsoc/hello_kernel/hello.c és a../source/kezdo/elsoc/hello_ kernel/makefile forrásállományban lett elhelyezve. Következő lépésként tegyük meg a következőket: # make $ sudo insmod hello.ko Kimenetet pedig a következőképp nézhetjük meg. (tail vagy dmesg) $ tail /var/log/syslog # dmesg A PCB mérete A PCB mérete modulból Az első MINIX kernellel kapcsolatos programjaid Helló, Világ! a kernelből A feladat kidolgozását Kis Dávid készítette. A feladat megoldásának bemutatása végett ide a teljes kódnak csak a lényeges csipetét irom. A teljes forráskód itt található:../source/kezdo/minix_kernel/hellovilag/main.c MINIX3-at telepitettem, VitualBox-ban. Egész egyszerűen megoldható, és a célunknak tökéletesen megfelel. A "VM Lens" nevű programmal oldottam meg, linkeltem is: MINIX3 Virtuálisan CD meghajtóként majd magát az iso-t is felcsatolhatjuk. Az iso képfájl: OS típusként majd ne az elegáns Other/Other opciókat adjuk meg, mert azokkal értelmezhetetlen hibák jönnének például a kernel fordításkor, viszont a Linux választással ezek elmaradtak. (Operatung_System: Linux). Számos értelemszerű lépés után indithatjuk is MINIX-ünket... Részletes leírás a feladat kiírásánál linkelt oldalon. ([PROP]) A kernel/main.c forrásállomány nyitása a vi-al: # cd /usr/src/kernel/ # vi main.c A main.c forrás announce() fuggvényét a következőképpen szerkesztettem: /*===========================================================================* * announce * *===========================================================================*/ static void announce(void) /* Display the MINIX startup banner. */ printf("\nminix %s.%s. " #ifdef _VCS_REVISION

189 A Debreceni Egyetem programozói évkönyve 159 / 404 "(" _VCS_REVISION ")\n" #endif "Copyright 2012, Vrije Universiteit, Amsterdam, The Netherlands\n", OS_RELEASE, OS_VERSION); printf("minix is open source software, see printf("helló, Világ!"); Tehát egyszerűen csak kibővitettem egy printf("helló, Világ!"); -al! A forrás mentése (vi = Shift+ZZ) után a make install paranccsal fordítjuk le a kernelt, majd a shutdown -r paranccsal indíthatjuk újra a rendszert: # make install # shutdown -r A most fordított kernelt bootolva látható az üzenet a kernelből, valahogy így: MINIX (116fcea) Copyright 2012, Vrije Universiteit, Amsterdam, The Netherlands MINIX is open source software, see Helló, Világ!... Helló, Világ! A processztábla mérete A feladatot készítette: Gyügyei Tamás A megoldások részhez, csak a programnak azon részét tüntetem fel, mely változtatásra került. A feladat sikeres teljesitéséhez, a sys_config.h átirása szükséges. A forrásállomány../source/kezdo/elsoc/minix_processztabla/sys_config.h forrásállományban lett elhelyezve. A sysconfig.h fájl tartalma következik: #define _MACHINE_SUN_4_60 40 /* Sun-4/60 (aka SparcStation 1 or Campus) */ #define _MACHINE_ATARI 60 /* ATARI ST/STe/TT (68000/68030) */ #define _MACHINE_MACINTOSH 62 /* Apple Macintosh (68000) */ /* Word size in bytes (a constant equal to sizeof(int)). */ #if ACK GNUC #define _WORD_SIZE _EM_WSIZE #define _PTR_SIZE _EM_WSIZE #endif #define _NR_PROCS 150 #define _NR_SYS_PROCS 32 #define _NR_HOLES (2*_NR_PROCS+4) /* No. of memory holes maintained by PM */ /* Set the CHIP type based on the machine selected. The symbol CHIP is actually * indicative of more than just the CPU. For example, machines for which * CHIP == INTEL are expected to have 8259A interrrupt controllers and the * other properties of IBM PC/XT/AT/386 types machines in general. */ #define _CHIP_INTEL 1 /* CHIP type for PC, XT, AT, 386 and clones */ #define _CHIP_M /* CHIP type for Atari, Amiga, Macintosh */

190 A Debreceni Egyetem programozói évkönyve 160 / Ütemezési sorok A feladatot készítette: Gyügyei Tamás A megoldások részhez, csak a programnak azon részét tüntetem fel, mely változtatásra került. A../source/kezdo/elsocpp/minix_utemezesi_sorok/proc.h forrásállományban helyeztem el a kódot. A proc.h fájl tartalma következik: /* Misc flags */ #define REPLY_PENDING 0x01 /* reply to IPC_REQUEST is pending */ #define MF_VM 0x08 /* process uses VM */ /* Scheduling priorities for p_priority. Values must start at zero (highest * priority) and increment. Priorities of the processes in the boot image * can be set in table.c. IDLE must have a queue for itself, to prevent low * priority user processes to run round-robin with IDLE. */ #define NR_SCHED_QUEUES 32 /* MUST equal minimum priority + 1 */ #define TASK_Q 0 /* highest, used for kernel tasks */ #define MAX_USER_Q 0 /* highest priority for user processes */ #define USER_Q 7 /* default (should correspond to nice 0) */ #define MIN_USER_Q 14 /* minimum priority for user processes */ #define IDLE_Q 31 /* lowest, only IDLE process goes here */ #define RT_Q 7 /* Queue for real-time processes */ /* Magic process table addresses. */ #define BEG_PROC_ADDR (&proc[0]) #define BEG_USER_ADDR (&proc[nr_tasks]) #define END_PROC_ADDR (&proc[nr_tasks + NR_PROCS]) És kimenetként láthatjuk a változást: # Dumping scheduling queues. 0: -2 31: A PCB mérete A feladatot készítette: Gyügyei Tamás A megoldások részhez, csak a programnak azon részét tüntetem fel, mely változtatásra került. A futtatáshoz, a kernel újraforditása szükséges. A../source/kezdo/elsoc/minix_pcb_merete/main.c forrásállományban helyeztem el a módosított kódot. A main.c fájl tartalma következik: PRIVATE void announce(void) /* Display the MINIX startup banner. */ kprintf("\nminix %s.%s. " #ifdef _SVN_REVISION "(" _SVN_REVISION ")\n" #endif "Copyright 2009, Vrije Universiteit, Amsterdam, The Netherlands\n", OS_RELEASE, OS_VERSION);

191 A Debreceni Egyetem programozói évkönyve 161 / 404 kprintf("minix is open source software, see kprintf("%d %d %d\n", sizeof(struct proc), sizeof(proc), sizeof(struct proc)*(nr_tasks+nr_procs)); Az első C++ programok Módosított polártranszformációs véletlenszám generátor, ez legyen az első C++ progid! Készítette: Szentpéteri Annamária. Tutor: Bereczki László. Dátum: Ez a program a Bátfai Norbert által megadott polártranszformációs algoritmust használja fel véletlenszámok generálására. Ahogy a feladatban meg volt adva, külön osztályt hoztunk létre a randomgeneráláshoz. A../source/kezdo/elsocpp/random/random.cpp forrásállományban helyeztem el a kódot. #include <iostream> #include <cstdlib> #include <cmath> #include <ctime> //Random osztály class Random ; public: Random(); //konstruktor ~Random() //destruktor double get(); //random lekérés private: bool exist; //van-e korábbi érték double value; //random értéke Random::Random() //a konstruktor kifejtése exist = false; std::srand (std::time(null)); //random inicializálás ; double Random::get() //random lekérő függvény kifejtése if (!exist) double u1, u2, v1, v2, w; do u1 = std::rand () / (RAND_MAX + 1.0); //innentől jön az algoritmus u2 = std::rand () / (RAND_MAX + 1.0); v1 = 2 * u1-1; v2 = 2 * u2-1;

192 A Debreceni Egyetem programozói évkönyve 162 / 404 w = v1 * v1 + v2 * v2; while (w > 1); double r = std::sqrt ((-2 * std::log (w)) / w); value = r * v2; exist =!exist; return r * v1; //idáig tart az algoritmus else exist =!exist; //ha van korábbi random érték, akkor azt adja vissza return value; ; int main() Random rnd; for(int i=0;i<10;i++) std::cout << rnd.get() << std::endl; //10 random szám generálása Másolt Vektor Készítette: Takács Miklós A program szemlélteti, hogy mély másolás történik. A../source/kezdo/elsocpp/masolt_vektor/masolt_vektor.cpp forrásállományban helyeztem el a kódot. #include <iostream> #include <vector> int main() std::vector<int> a; std::vector<int> b; for (int i = 0; i!= 10; i++) a.push_back(i); b = a; // Masolas std::cout << "Masolas utan: " << std::endl; std::cout << "\na: " << std::endl; for (int i = 0 ; i!= a.size(); i++) std::cout << a[i] << " "; std::cout << "\nb: " << std::endl; for (int i = 0 ; i!= b.size(); i++) std::cout << b[i] << " ";

193 A Debreceni Egyetem programozói évkönyve 163 / 404 a[0] = 1; std::cout << "\nlassuk a medvet: " << std::endl; std::cout << "\na: " << std::endl; for (int i = 0 ; i!= a.size(); i++) std::cout << a[i] << " "; // Ha sekelyen masolna akkor a b[0] is 1 lenne std::cout << "\nb: " << std::endl; for (int i = 0 ; i!= b.size(); i++) std::cout << b[i] << " "; std::cout << std::endl; Másolt Verem A program szemlélteti, hogy mély másolás történik, mivel a "b" verem tetején marad a 9, viszont az "a" verem tetején 8 lesz. A../source/kezdo/elsocpp/masolt_verem/stack.cpp forrásállományban helyeztem el a kódot. #include<iostream> #include<stack> using namespace std; int main() stack<int> a; stack<int> b; for(int i=0;i<10;i++) a.push(i); b=a; a.pop(); cout<<"a: "<<a.top()<<endl; cout<<"b: "<<b.top()<<endl; return 0; Másolt Lista A feladatot Akai József Zsolt készítette.(busák Zoltán Tutor segítségével) A program szemlélteti, hogy mély másolás történik. A../source/kezdo/elsocpp/masolt_lista/list.cpp forrásállományban helyeztem el a kódot.

194 A Debreceni Egyetem programozói évkönyve 164 / 404 #include<iostream> #include<list> using namespace std; int main() list<int> a; list<int> b; for(int i=0;i<5;i++) a.push_back(i); for(list<int>::iterator it=a.begin();it!=a.end();++it) std::cout<<"a: "<<*it<<endl; b=a; cout<<"\n b -be betöltve az a értéke, és a elejére beszúrva egy elem:\n"; a.push_front(10); for(list<int>::iterator it=a.begin();it!=a.end();++it) std::cout<<"a: "<<*it<<endl; cout<<"\n"; for(list<int>::iterator it=b.begin();it!=b.end();++it) std::cout<<"b: "<<*it<<endl; return 0; Másolt map A../source/kezdo/elsocpp/masolt_map/map.cpp #include<iostream> #include<map> using namespace std; int main() map<char,int> a; map<char,int> b; a.insert(pair<char,int>( a,100)); a.insert(pair<char,int>( z,200)); cout<<"a mérete: "<<a.size()<<endl; // b -be átrakom a értékeit b=a; a.clear(); cout<<"a mérete:(a kitakarítva)"<<a.size()<<endl;

195 A Debreceni Egyetem programozói évkönyve 165 / 404 //mély másolás történt mivel a címéről mindent töröltem de b //nem változott. Akkor lenne sekély másolás ha b elemei is nullák lennének cout<<"b mérete:"<<b.size()<<endl; return 0; Másolt map A../source/kezdo/elsocpp/masolt_set/set.cpp //Závaczki Roland #include<iostream> #include<set> using namespace std; int main() set<int> a; set<int> b; a.insert(1); cout<<"a size: "<<a.size()<<endl;//"a" változó mérete b=a; //"a" érték átadása "b"nek a.clear(); //"a" megtisztítása cout<<"a mérete:(tisztitva)"<<a.size()<<endl; /*Mély másolás történt mivel a címéről minden törölve lett de b értéke nem változott.*/ cout<<"b mérete:"<<b.size()<<endl;//"b" Méretének kiiratása return 0; Komplex osztályos Mandelbrot Módosító: Dalmadi Zoltán A programot Szabó Attila és Tuza József alapfeladata szerint módosítottam. A forráskód a../source/kezdo/elsocpp/mandelbrot_komplex/mandelbrot_komplex.cpp helyen érhető el. #include <png++/png.hpp> #include <complex> const int N = 500; const int M = 500; const double MAXX = 0.7; const double MINX = -2.0; const double MAXY = 1.35;

196 A Debreceni Egyetem programozói évkönyve 166 / 404 const double MINY = -1.35; void GeneratePNG(const int tomb[n][m]) png::image< png::rgb_pixel > image(n, M); for (int x = 0; x < N; x++) for (int y = 0; y < M; y++) image[x][y] = png::rgb_pixel(tomb[x][y], tomb[x][y], tomb[x][y]); image.write("kimenet.png"); int main() int tomb[n][m]; double dx = (MAXX - MINX) / N; double dy = (MAXY - MINY) / M; std::complex<double> C, Z, Zuj; int iteracio; for (int i = 0; i < M; i++) for (int j = 0; j < N; j++) real(c) = MINX + j * dx; imag(c) = MAXY - i * dy; Z = 0; iteracio = 0; while(abs(z) < 2 && iteracio++ < 255) Zuj = Z*Z+C; Z = Zuj; tomb[i][j] = iteracio; GeneratePNG(tomb); return 0; Az első Qt programjaid A Mandelbrot RGB színezése A feladatot Tuza József készítette Akai József Zsolt és Busák Zoltán megoldása alapján. A feladat megoldása itt található:../source/kezdo/elsoqt/mandelbrot_rgb/main.cpp

197 A Debreceni Egyetem programozói évkönyve 167 / 404 Az éppen kiszámolt sor rajzolását a frakablak osztály végzi. Ezen történt a módosítás is. // frakablak.cpp #include "frakablak.h" FrakAblak::FrakAblak(double a, double b, double c, double d, int szelesseg, int iteracioshatar, QWidget *parent) : QMainWindow(parent) setwindowtitle("mandelbrot halmaz"); int magassag = (int)(szelesseg * ((d-c)/(b-a))); setfixedsize(qsize(szelesseg, magassag)); fraktal= new QImage(szelesseg, magassag, QImage::Format_RGB32); mandelbrot = new FrakSzal(a, b, c, d, szelesseg, magassag, iteracioshatar, this); mandelbrot->start(); FrakAblak::~FrakAblak() delete fraktal; delete mandelbrot; void FrakAblak::paintEvent(QPaintEvent*) QPainter qpainter(this); qpainter.drawimage(0, 0, *fraktal); qpainter.end(); void FrakAblak::vissza(int magassag, int *sor, int meret) for(int i=0; i<meret; ++i) QRgb szin = qrgb(0, 0, 255-sor[i]); fraktal->setpixel(i, magassag, szin); update(); A genetikai kód-szőnyeg parancssori bemenete A feladatot Szabó Bence készítette Akai József Zsolt megoldása alapján. A feladat megoldása itt található:../source/kezdo/elsoqt/genetikai_bemenet/main.cpp #include <QApplication> #include <iostream> #include "genablak.h" void hasznalat(void) std::cout<<"használat:./genetikai bemeneti_fájl"<<std::endl;

198 A Debreceni Egyetem programozói évkönyve 168 / 404 int main(int argc, char *argv[]) char *infile = *++argv; if (argc!= 2) hasznalat (); return -1; QApplication a(argc, argv); GenAblak w(infile, 600, 300); w.show(); return a.exec(); További élőlények a sejttérben Az első képfeldolgozással kapcsolatos programjaid Az első png++ és pngwriter könyvtárakkal kapcsolatos programjaid Kockásítás a png++ könyvtárral Készítette: Dalmadi Zoltán, Bátfai Norbert jegyzetét alapul véve. A forráskód a../source/kezdo/elsocpp/kockasitas/kockasitas.cpp helyen található meg. // "Kockásító" // Készítette: Dalmadi Zoltán, Bátfai Norbert jegyzetét alapul véve // // Fordítás: // g++ kockasitas.cpp libpng-config --ldflags -o kockasitas // Használat: //./kockasitas alapkep.png kockasitandokep.png // Csak PNG formátumú képekkel működik! #include <png++/png.hpp> void makeblocky(png::image <png::rgb_pixel> &picture, int R, int G, int B, int row, int - column, int horizontal_blocks, int vertical_blocks) // színek beállítása png::rgb_pixel rgb(r/vertical_blocks * horizontal_blocks, G/vertical_blocks * - horizontal_blocks, B/vertical_blocks * horizontal_blocks); // lepakoljuk egymás mellé és alá a "kockáinkat" for (int j = 0; j < horizontal_blocks; j++) for (int i = 0; i < vertical_blocks; i++) picture.set_pixel(row + j, column + i, rgb); int main (int argc, char *argv[]) // inicializáljuk képünket a programindításkor megadott első paraméterben megadott - névvel png::image <png::rgb_pixel> picture (argv[1]);

199 A Debreceni Egyetem programozói évkönyve 169 / 404 // változók int avgr = 0, avgg = 0, avgb = 0, block_size = 4, vertblocks, horizblocks; // piros átlag // zöld átlag // kék átlag // "kockák" mérete (pixel) // függőleges "kockák" száma // vízszintes "kockák" száma // Végigmegyünk minden oszlopon for (int column = 0; column < picture.get_height(); column += block_size) // és minden oszlopon for (int row = 0; row < picture.get_width(); row += block_size) // színcsatornák átlagának nullázása avgr = avgg = avgb = 0; // ha a blokkméreten belül vagyunk és nem lógunk ki a kép aljáról, - végigzongorázzuk for (int i = 0; i < block_size && column + i < picture.get_height(); i++) // ha a blokkméreten belül vagyunk és nem lógunk ki a kép jobb széléről, - végigzongorázzuk for (int j = 0; j < block_size && row + j < picture.get_width(); j++) // aktuális pixel beolvasása png::rgb_pixel rgb = picture.get_pixel(row + j, column + i); // aktuális pixel színcsatornáinak értékével növeljük a megfelelő - átlagunkat avgr += rgb.red; avgg += rgb.green; avgb += rgb.blue; // blokkszámok növelése vertblocks = i; horizblocks = j; // "kockásítő függvény hívása" makeblocky(picture, avgr, avgg, avgb, row, column, horizblocks, vertblocks); // "kockásított kép mentése a programindításkor megadott második paraméterben megadott - névvel" picture.write(argv[2]); return 0; Kockásítás a pngwriter könyvtárral Készítette: Csopa Tamás, Dalmadi Zoltán png++ feladatát és Bátfai Norbert jegyzetét alapul véve. A forráskód a../source/kezdo/elsocpp/kockasitas_pngwriter/kockasitas_pngwriter.cpp helyen található meg. // "Kockásító"

200 A Debreceni Egyetem programozói évkönyve 170 / 404 // Készítette: Csopa Tamás, Dalmadi Zoltán png++ feladatát és Bátfai Norbert jegyzetét - alapul véve // // Fordítás: // g++ kockasitas_pngwriter.cpp freetype-config --cflags -lpng -lpngwriter -lz - - lfreetype -o kockasitas_pngwriter // Használat: //./kockasitas_pngwriter alapkep.png kockasitandokep.png // A program csak png képekkel működőképes. #include <pngwriter.h> void kockasit(pngwriter &picture, int R, int G, int B, int row, int column, int - horizontal_blocks, int vertical_blocks) // színek beállítása R = R/vertical_blocks * horizontal_blocks; G = G/vertical_blocks * horizontal_blocks; B = B/vertical_blocks * horizontal_blocks; // lepakoljuk egymás mellé és alá a "kockáinkat" for (int j = 1; j <= horizontal_blocks; j++) for (int i = 1; i <= vertical_blocks; i++) picture.plot(row + j, column + i, R, G, B); int main (int argc, char *argv[]) // inicializáljuk képünket a programindításkor megadott második paraméterben megadott - névvel pngwriter picture(1,1,65535,argv[2]); // beállítjuk az előbbi képet az első argumentumban megadott képre picture.readfromfile(argv[1]); // változók int average_colors[] = 0, 0, 0, 0; // a színek átlagai R,G,B (az első elem egy - eltoló-elem, hogy a read-nél szinkronban legyenek a színek indexei int block_size = 4, // "kockák" mérete (pixel) vertical_blocks, // függőleges "kockák" száma horizontal_blocks; // vízszintes "kockák" száma // Végigmegyünk minden oszlopon for (int column = 1; column < picture.getheight(); column += block_size) // és minden soron for (int row = 1; row < picture.getwidth(); row += block_size) // színcsatornák átlagának nullázása average_colors[1] = 0; average_colors[2] = 0; average_colors[3] = 0; // ha a blokkméreten belül vagyunk és nem lógunk ki a kép aljáról, - végigzongorázzuk for (int i = 1; i < block_size && column + i < picture.getheight(); i++) // ha a blokkméreten belül vagyunk és nem lógunk ki a kép jobb széléről, - végigzongorázzuk for (int j = 1; j < block_size && row + j < picture.getwidth(); j++)

201 A Debreceni Egyetem programozói évkönyve 171 / 404 // aktuális pixel beolvasása // aktuális pixel színcsatornáinak értékével növeljük a megfelelő - átlagunkat average_colors[1] += picture.read(row + j, column + i,1); average_colors[2] += picture.read(row + j, column + i,2); average_colors[3] += picture.read(row + j, column + i,3); // blokkszámok növelése vertical_blocks = i; horizontal_blocks = j; // "kockásítő függvény hívása" kockasit(picture, average_colors[1], average_colors[2], average_colors[3], row, - column, horizontal_blocks, vertical_blocks); // "kockásított kép mentése a programindításkor megadott második paraméterben megadott - névvel" picture.close(); return 0; Az első Open CV-vel kapcsolatos programjaid Az első Java programok Módosított polártranszformációs véletlenszám generátor, ez legyen az első Java progid! A forráskód a../source/kezdo/elsoc/polaris/polaris.java helyen található meg. Ez a program a Bátfai Norbert által megadott cpp polártranszformációs algoritmust használja fel véletlenszámok generálására,csak mind ezt Javaban. A programban külön osztály van a randomgeneráláshoz. public class PolárGenerátor boolean nincstárolt = true; double tárolt; public PolárGenerátor() nincstárolt = true; public double következõ() if(nincstárolt) double u1, u2, v1, v2, w; do u1 = Math.random(); u2 = Math.random(); v1 = 2*u1-1;

202 A Debreceni Egyetem programozói évkönyve 172 / 404 v2 = 2*u2-1; w = v1*v1 + v2*v2; while(w > 1); double r = Math.sqrt((-2*Math.log(w))/w); tárolt = r*v2; nincstárolt =!nincstárolt; return r*v1; else nincstárolt =!nincstárolt; return tárolt; public static void main(string[] args) PolárGenerátor g = new PolárGenerátor(); for(int i=0; i<10; ++i) System.out.println(g.következõ()); Labor és szorgalmi laborfeladatok Aminosav-hisztogram Készítette: Szentpéteri Annamária (Szerda 10-12) A magyarázatot a../source/labor/ziv/ga.c fájl alapján készítettem. Magyarázat a programkódba írt kommentekben. Első két tömbben mit tárolunk: //Aminosavak egy tömbben felsorolva char *amino_sav[] = "Stop", "Phe", "Leu", "Ile", "Met", "Val", "Ser", // 6. "Pro", "Thr", "Ala", "Tyr", // 10. "His", "Gln", "Asn", "Lys", "Asp", "Glu",

203 A Debreceni Egyetem programozói évkönyve 173 / 404 "Cys", "Trp", // 18. "Arg", // 19. "Gly" // 20. ; //A fenti tömbbel megegyezik az indexelés, azonos index esetén a fenti aminosavhoz tartozó - előfordulások számát adja vissza. int amino_sav_hiszt[] = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ; A main()-ben számolt betűhármas által meghatározott érték alapján, melyik aminosavhoz tartozik a feldolgozott betűhármas. (A switch-nek csak egy részét hagytam itt, a teljesért lásd a fentebb linkelt fáljt.) // a 3 betű melyik aminosavat kódolja? // SÉMA: a triplet több értéke is vonatkozik egy aminosavra; // mindig lemegy a legutolsó rá vonatkozó értékig és csak ott // történik meg az index állítása és a break parancs kiadása // továbbá egy kupacba vannak szedve az egy aminosavra vonatkozó számok // pl: 2,3,16,17,18,19 a Leu-t jelenti // hogy jön ez? az 5 indexű a "Val" GTT-től GTG-ig van ez, jegyekben: // 300-tól 303-ig 4-es számrendszerben // ez van átváltva, pl.: // 303(4) -> 3*16+ 0*4+ 3*1 = 51(10) int genetikai_kod (int triplet) int index = 0; switch (triplet) // Phe case 0: case 1: index = 1; break; // Leu case 2: case 3: case 16: case 17: case 18: case 19: index = 2; break; // Ile case 32: case 33: case 34: index = 3; break; // (...) ITT MÉG VAN EGY CSOMÓ KÓD! LÁSD: ga.c // Arg case 46: case 47: index = 19; break;

204 A Debreceni Egyetem programozói évkönyve 174 / 404 // Gly case 60: case 61: case 62: case 63: index = 20; break; default: // csak tesztelesre a printf printf ("Zavar az eroben %d-nel", triplet); index = 0; break; return index; A main() függvény magyarázata: int main (void) // hányadik betűn állok? // Fontos! (-1)-ről indulunk, különben nem tudnánk rendesen hármasával szedni a betűket. int hanyadik_betu = -1; // azon a helyen mit olvastam? int elso = 0, masodik = 0, harmadik = 0, i = 0, jegy = -1; // vezető komment (első sor) áltépése while ((i = getchar ())!= EOF) if (i == \n ) break; while ((i = getchar ())!= EOF) // jelzem, hogy ha a jegy nem érvényes (nem T, C, A vagy G) jegy = -1; //Az érvényes betűkhöz 0-3 között értéket rendelek az alábbiak szerint: switch (i) case T : jegy = 0; break; case C : jegy = 1; break; case A : jegy = 2; break; case G : jegy = 3; break; if (jegy >= 0) //3-mal való maradékos osztás, hogy eldöntsük, hanyadik betűnél tartunk hanyadik_betu = (hanyadik_betu + 1) % 3;

205 A Debreceni Egyetem programozói évkönyve 175 / 404 if (!hanyadik_betu) //ha nem nulla, akkor elso = jegy; else if (!(hanyadik_betu - 1)) //ha nem 1, akkor masodik = jegy; else //ha nem nulla és nem 1, akkor ért el a 3. betűhöz harmadik = jegy; //Az index kiszámolása int index = genetikai_kod (elso * 16 + masodik * 4 + harmadik); //Az előfordulásokat számoló tömb megfelelő elemének növelése ++amino_sav_hiszt[index]; //A betűk által alkotott aminosav kiírása printf ("%s", amino_sav[index]); //Kiírja az összes aminosavat és a hozzájuk tartozó előfordulást for (int i = 0; i < 21; ++i) printf ("\n%s %i", amino_sav[i], amino_sav_hiszt[i]); printf ("\n"); Filogenetikai fa az LZW-s fa ághosszainak szórása alapján A feladat megoldása a../source/labor/szorgalmi/lzw_szoras mappában található meg. Az elsőként elkészített filogenetikai fa az eredeti állományokból épül fel.

206 A Debreceni Egyetem programozói évkönyve 176 / ábra. Mammals A második képhez előbb kiszámoljuk a fájlok által felépített LZW fák ághosszainak szórását, ezeket külön fájlban tároljuk, majd erre futtatjuk a CompLearn programot. Az eredmény a következő:

207 A Debreceni Egyetem programozói évkönyve 177 / ábra. LZW szórás alapján

208 A Debreceni Egyetem programozói évkönyve 178 / fejezet A közepes szint programjai A kezdő szintű feladatokra épített példák Normálisok Mivel Veress Balázs megoldása nem zérus közeli értéket generált, így feltöltöttem egy saját verziót. A programot c++ nyelven írtam, és mivel használ c++11 featuret, így fordítani a -std=c++11 kapcsolóval kell. Bereczki László. Kód:../source/ kozepes/kezdore_epulo/normalisok/normalisok2.cpp /*Készítette: Bereczki László * Neptun-kód: SR9LLD * * Dátum: :30 * * Note: A program a polártranszformációs algoritmust használva előállít random - értéket, * majd ezek átlagát veszi. * * */ #include <iostream> //#include <cstdlib> #include <cmath> #include <ctime> #include <vector> #define SIZE //környezet függő //Random osztály class Random public: Random(); //konstruktor ~Random() //destruktor double get(); //random lekérés private: bool exist; //van-e korábbi érték double value; //random értéke

209 A Debreceni Egyetem programozói évkönyve 179 / 404 ; Random::Random() //a konstruktor kifejtése exist = false; std::srand (std::time(null)); //random inicializálás ; double Random::get() //random lekérő függvény kifejtése if (!exist) double u1, u2, v1, v2, w; do u1 = std::rand () / (RAND_MAX + 1.0); //innentől jön az algoritmus u2 = std::rand () / (RAND_MAX + 1.0); v1 = 2 * u1-1; v2 = 2 * u2-1; w = v1 * v1 + v2 * v2; while (w > 1); double r = std::sqrt ((-2 * std::log (w)) / w); value = r * v2; exist =!exist; return r * v1; //idáig tart az algoritmus else exist =!exist; //ha van korábbi random érték, akkor azt adja vissza return value; ; int main() Random rnd; std::vector<double> vektor; double sum=0.0; for(int i=0;i<size;i++) vektor.push_back(rnd.get()); // random érték elhelyezése - a vektorban for (int n : vektor) sum += n; // összeg kiszámítása - c++11 szabvány sum /= SIZE; //átlag std::cout << std::endl << "Átlag: " << sum << std::endl; return 0; Futtatás: g++ normalisok2.cpp -std=c++11

210 A Debreceni Egyetem programozói évkönyve 180 / Normális-harang A megoldást az előző feladat és a [PP] jegyzet alapján készítettem(veress Balázs). Egy lehetséges kimenetet elhelyeztem a forráskód mellett. A nagy elemszám miatt fájlba érdemes a kimenetet irányítani.../source/kozepes/kezdore_epulo/ hisztogram/karakteres/hisztogram.c #include <stdio.h> #include <stdlib.h> #include <time.h> #include <sys/types.h> #include <unistd.h> #define MERET // A program kimenetét fájlba érdemek irányítani mivel a terminál //nem tudja megjeleníteni a hossza miadt. main() int t[meret]; int db[10]; int i,j; srand(time(null)+getpid()); for(i = 0;i < 10;++i) db[i] = 0; for (i = 0; i < MERET;++i) t[i] = (int) (10.0*rand()/(RAND_MAX+1.0)); printf("\n\n"); for(i = 0;i < MERET;++i) db[t[i]]++; for(i = 0;i < ;i += 25) //a lépésköz kicsi hogy printf("\n"); //látszódjon a hisztogram printf("%6d ", -i ); // gorbéje for(j = 0;j < 10;++j) if(db[j] >= -i ) printf("* "); else printf(" "); printf("\n"); printf(" "); for(i=0;i<10;++i) printf("%d ",i); printf("\n\n"); return 0; Futtatás: gcc hisztogram.c Ellenőrzés splint-el: [/udprog-code/source# splint kozepes/kezdore_epulo/hisztogram/karakteres/hisztogram.c Eredmény:

211 A Debreceni Egyetem programozói évkönyve 181 / 404 [Splint Feb 2009 kozepes/kezdore_epulo/hisztogram/karakteres/hisztogram.c:3: Include file <sys/types.h> matches the name of a POSIX library, but the POSIX library is not being used. Consider using +posixlib or +posixstrictlib to select the POSIX library, or -warnposix to suppress this message. Header name matches a POSIX header, but the POSIX library is not selected. (Use -warnposixheaders to inhibit warning) kozepes/kezdore_epulo/hisztogram/karakteres/hisztogram.c:4:23: Cannot find include file sys/types.h on search path: /usr/include;/usr/inclu de Preprocessing error. (Use -preproc to inhibit warning) kozepes/kezdore_epulo/hisztogram/karakteres/hisztogram.c:4: Include file <unistd.h> matches the name of a POSIX library, but the POSIX library is not being used. Consider using +posixlib or +posixstrictlib to select the POSIX library, or -warnposix to suppress this message. Preprocessing error for file: /home/ranieth/prog/udprog-code/source/kozepes/kezd ore_epulo/hisztogram/karakteres/hisztogram.c *** Cannot continue Normális-harang grafikusan A feladat kidolgozását az előző programok alapján készítettük. (Szabó Attila, Haraszti Péter Brúnó tutoriálásával.) A feladat megoldása a következő állományokban található:../source/kozepes/kezdore_epulo/hisztogram_qt/main.cpp../source/kozepes/kezdore_epulo/hisztogram_qt/normharaggraf.cpp../source/kozepes/kezdore_epulo/hisztogram_qt/normharaggraf.h../source/kozepes/kezdore_epulo/hisztogram_qt/ui_mainwindow.h A normharaggraf.cpp tartalma: #include "normharaggraf.h" #include "ui_mainwindow.h" #include <QPainter> #include <ctime> void MainWindow::Generalas() int i; for(i = 0; i < OSZLOP; i++) db[i] = 0; for(i = 0; i < MERET; i++) db[rand() % OSZLOP]++; void MainWindow::Rajzol() float oszlop_szel = (float) ui->label->width() / OSZLOP; float oszlop_magas; int i;

212 A Debreceni Egyetem programozói évkönyve 182 / 404 QPainter p(&img); int max = db[0]; for (i = 1; i < OSZLOP; i++) if (max < db[i]) max = db[i]; oszlop_magas = (float) ui->label->height() / (max * 2); for (i = 0; i < OSZLOP; i++) p.fillrect(oszlop_szel * i, ui->label->height(), oszlop_szel, -oszlop_magas * db[i - ], QColor::fromRgb(90, 100, 180)); p.drawrect(oszlop_szel * i, ui->label->height(), oszlop_szel, -oszlop_magas * db[i - ]); MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) ui->setupui(this); srand(time(null)); img = QImage(ui->label->width(), ui->label->height(), QImage::Format_RGB888); img.fill(qcolor(qt::white).rgb()); Generalas(); Rajzol(); ui->label->setpixmap(qpixmap::fromimage(img)); MainWindow::~MainWindow() delete ui; void MainWindow::on_pushButton_clicked() img.fill(qcolor(qt::white).rgb()); Generalas(); Rajzol(); ui->label->setpixmap(qpixmap::fromimage(img)); Ide csak a fő részt illesztettem be, a további forráskód megtalálható a source könyvtárban Pattogó labda A feladatot készítette Szentpéteri Annamária. Tutor: Bereczki László. A forrást a -lncurses kapcsolóval lehet lefordítani. Mivel a kezdő szintű pattogó labda feladat megoldásának forráskódja megegyezik nagy részben ennek a feladatnak a megoldásával, ezért csak a lényegi részt illesztem ide be. A futtatáshoz telepíteni kell a curses.h könyvtárát a következő paranccsal: "sudo apt-get install libncurses5-dev". Továbbá használni kell a -lncurses kapcsolót a fordításnál.

213 A Debreceni Egyetem programozói évkönyve 183 / 404 [...itt van még promgramkód...] initscr(); noecho(); curs_set(0); timeout(0); [...itt van még promgramkód...] int x, y; //a kiiratáshoz pozíció számoló for ( x=0 ; x<=max_x ; x++ ) for ( y=0 ; y<=max_y ; y++ ) mvprintw(y,x," "); mvprintw(uy,ux,"o"); refresh(); [...itt van még promgramkód...] curs_set(1); endwin(); [...itt van még promgramkód...] Az első négy sor az mvprintw parancs helyes működéséhez kell. A for ciklusban látottak azért kellenek, hogy "szimuláljuk" a képernyőfrissítést. Az mvprintw(uy,ux,"0") pedig a labda tényleges kirajzolásához kell. A maradék három sor szintén az mvprintw helyes használatához kell több szálon futó kockásítás png++ könyvtárral A megoldást készítette: Kakócz Erik, Dalmádi Zoltán kódja alapján A megoldás megtalálható az alábbi forrásállományban:../source/kozepes/pthreadkockasit/kockasitas_pthread.cpp #include <png++/png.hpp> #include <pthread.h> #include <unistd.h> #include <stdint.h> #define numthread 2 //globális png mutató és egy a már végzet szálakat számláló változó png::image <png::rgb_pixel> * pic; int Thread_kesz=0; void makeblocky(int R, int G, int B, int row, int column, int horizontal_blocks, int - vertical_blocks) // színek beállítása png::rgb_pixel rgb(r/vertical_blocks * horizontal_blocks, G/vertical_blocks * - horizontal_blocks, B/vertical_blocks * horizontal_blocks); // lepakoljuk egymás mellé és alá a "kockáinkat" for (int j = 0; j < horizontal_blocks; j++) for (int i = 0; i < vertical_blocks; i++)

214 A Debreceni Egyetem programozói évkönyve 184 / 404 pic->set_pixel(row + j, column + i, rgb); //A szál által végrehajtandó eljárás melyet az alábbi módon kell definiálni, a szál által - kapott paraméter minden eseten void* kell hogy legyen //melyet majd a törzsben kasztolunk át a nekünk kellő adattipusra void * sor(void * dc) // változók int avgr = 0, // piros átlag avgg = 0, // zöld átlag avgb = 0, // kék átlag block_size = 4, // "kockák" mérete (pixel) vertblocks, // függőleges "kockák" száma horizblocks; // vízszintes "kockák" száma //void* mutató átkasztolása egész mutatóvá majd a mutató által mutatott értéket átadjuk - a "z" változónak int z=*((int*)dc); // Végigmegyünk minden oszlopon for (int column = 0; column < pic->get_height(); column += block_size) // és minden soron, az eredeti kódhoz képest annyi változást eszközölünk hogy a - végrehajtás minden szálban abban a blokksorban // kezdődik ahanyadik az adott szál, és a szálak számával lép előre. for (int row = 0+(z*block_size); row < pic->get_width(); row += block_size* - numthread) // színcsatornák átlagának nullázása avgr = avgg = avgb = 0; // ha a blokkméreten belül vagyunk és nem lógunk ki a kép aljáról, - végigzongorázzuk for (int i = 0; i < block_size && column + i < pic->get_height(); i++) // ha a blokkméreten belül vagyunk és nem lógunk ki a kép jobb széléről, - végigzongorázzuk for (int j = 0; j < block_size && row + j < pic->get_width(); j++) // aktuális pixel beolvasása png::rgb_pixel rgb = pic->get_pixel(row + j, column + i); // aktuális pixel színcsatornáinak értékével növeljük a megfelelő - átlagunkat avgr += rgb.red; avgg += rgb.green; avgb += rgb.blue; // blokkszámok növelése vertblocks = i; horizblocks = j; // "kockásítő függvény hívása" makeblocky( avgr, avgg, avgb, row, column, horizblocks, vertblocks); //dolgunk végeztével növeljük a kész szálak számát és kiléptetjük a szálat

215 A Debreceni Egyetem programozói évkönyve 185 / 404 Thread_kesz++; pthread_exit(null); int main (int argc, char *argv[]) // inicializáljuk képünket a programindításkor megadott első paraméterben megadott - névvel png::image <png::rgb_pixel> picture (argv[1]); //ráálítunk egy globális mutatót amelynek a segítségével bármely függvény hozzáférhet pic=&picture; int block_size = 4; //ez a tömb fogja tartalmazni a szálakra mutató pthread_t t[numthread]; //két mutató amelyek egyfajta threadid ként fognak szolgálni a szálak megkapják ezeket - és ez alapján tudják hol kell dolgozniuk int i=0; int j=1; //az iménti változókra mutató mutatok amelyeket a szálak paraméterként fognak megkapni int * ptr=&i; int * ptr2=&j; //a szálak létrehozása a szálak paraméterként megkapják a címet ahol a mutatójuk - tárolásra kerül,valamely a szálra vonatkozó tulajdonság // (esetünkben NULL tehát nincs ilyen),az eljárást amely majd végrehajtásra kerül, és - az imént létrehozott egész mutatókat pthread_create(&t[0],null,sor,(void*)ptr); pthread_create(&t[1],null,sor,(void*)ptr2); //amíg a szálak nem végeznek várakozunk. while(thread_kesz<numthread) sleep(1); // "kockásított kép mentése a programindításkor megadott második paraméterben megadott - névvel" pic->write(argv[2]); return 0; Ez a program a kezdő szintű png++-os kockásító feladat továbbfejlesztése.a fenti program két szálon futva végzi el a feladatot, a magyarázat komment gyanánt szerepel a kódban több szálon futó kockásítás pngwriter könyvtárral A megoldást készítette: Csopa Tamás, Dalmádi Zoltán és Kakócz Erik kódja alapján A megoldás megtalálható az alábbi forrásállományban:../source/kozepes/pthreadkockasitpngwriter/kockasitas_pngwriter_pthread.cpp // "Kockásító pthreaddel" // Készítette: Csopa Tamás, a következőket alapul véve: // - Dalmadi Zoltán png++ feladata // - Kakócz Erik png++ pthread-es megoldása // - Bátfai Norbert jegyzete //

216 A Debreceni Egyetem programozói évkönyve 186 / 404 // Fordítás: // g++ kockasitas_pngwriter_pthread.cpp -pthread freetype-config --cflags -lpng - - lpngwriter -lz -lfreetype -o kockasitas_pngwriter_pthread // Használat: //./kockasitas_pngwriter alapkep.png kockasitandokep.png // A program csak png képekkel működőképes. #include <pngwriter.h> #include <pthread.h> #include <unistd.h> #include <stdint.h> #define numthread 2 pngwriter * picture; int thread_done = 0; void kockasit(int R, int G, int B, int row, int column, int horizontal_blocks, int - vertical_blocks) // színek beállítása R = R/vertical_blocks * horizontal_blocks; G = G/vertical_blocks * horizontal_blocks; B = B/vertical_blocks * horizontal_blocks; // lepakoljuk egymás mellé és alá a "kockáinkat" for (int j = 0; j <= horizontal_blocks; j++) for (int i = 0; i <= vertical_blocks; i++) picture->plot(row + j, column + i, R, G, B); void * thread_row(void * thread_argument) // változók int average_colors[] = 0, 0, 0, 0; // a színek átlagai R,G,B (az első elem egy - eltoló-elem, hogy a read-nél szinkronban legyenek a színek indexei int block_size = 4, // "kockák" mérete (pixel) vertical_blocks, // függőleges "kockák" száma horizontal_blocks; // vízszintes "kockák" száma int thread=*((int*)thread_argument); // Végigmegyünk minden oszlopon for (int column = 0; column < picture->getheight(); column += block_size) // és minden soron for (int row = 0+(thread*block_size); row < picture->getwidth(); row += block_size* - numthread) // színcsatornák átlagának nullázása average_colors[1] = 0; average_colors[2] = 0; average_colors[3] = 0; // ha a blokkméreten belül vagyunk és nem lógunk ki a kép aljáról, - végigzongorázzuk for (int i = 1; i < block_size && column + i < picture->getheight(); i++) // ha a blokkméreten belül vagyunk és nem lógunk ki a kép jobb széléről, - végigzongorázzuk for (int j = 1; j < block_size && row + j < picture->getwidth(); j++)

217 A Debreceni Egyetem programozói évkönyve 187 / 404 // aktuális pixel beolvasása // aktuális pixel színcsatornáinak értékével növeljük a megfelelő - átlagunkat average_colors[1] += picture->read(row + j, column + i,1); average_colors[2] += picture->read(row + j, column + i,2); average_colors[3] += picture->read(row + j, column + i,3); // blokkszámok növelése vertical_blocks = i; horizontal_blocks = j; // "kockásítő függvény hívása" std::cout << "row: " << row << "\n"; std::cout << "column: " << column << "\n"; std::cout << "horizontal_blocks: " << horizontal_blocks << "\n"; std::cout << "vertical_blocks: " << vertical_blocks << "\n"; kockasit(average_colors[1], average_colors[2], average_colors[3], row, column, - horizontal_blocks, vertical_blocks); thread_done++; pthread_exit(null); int main (int argc, char *argv[]) // inicializáljuk képünket a programindításkor megadott második paraméterben megadott - névvel pngwriter pic(1,1,65535,argv[2]); picture = &pic; // beállítjuk az előbbi képet az első argumentumban megadott képre picture->readfromfile(argv[1]); pthread_t thread_array[numthread]; int i = 0; int j = 1; int * pthread_1 = &i; int * pthread_2 = &j; pthread_create(&thread_array[0],null,thread_row,(void*)pthread_1); pthread_create(&thread_array[1],null,thread_row,(void*)pthread_2); while(thread_done < numthread) sleep(1); // "kockásított kép mentése a programindításkor megadott második paraméterben megadott - névvel" picture->close(); return 0;

218 A Debreceni Egyetem programozói évkönyve 188 / Rendszerprogramozással kapcsolatos programjaid Glibc függvény felüldefiniálása /*A program sárga hátteren pirossal ír a terminal ablakban. */ #include <errno.h> #include <stdarg.h> int printf (char *fmt,...) va_list ap; errno = 1; va_start (ap, fmt); putchar (0x1B); putchar ( [ ); putchar ( 4 ); putchar ( 3 ); putchar ( ; ); putchar ( 3 ); putchar ( 1 ); putchar ( m ); vprintf (fmt, ap); putchar (0x1B); putchar ( [ ); putchar ( 0 ); putchar ( m ); va_end (ap); return 0; A feldat helye:../source/kozepes/glibc/libsajat.c Futtatás gcc -fpic -shared -Wl,-soname,libsajat.so.1 -o libsajat.so.1.0 libsajat.c ln -s libsajat.so.1.0 libsajat.so.1 ln -s libsajat.so.1 libsajat.so export LD_PRELOAD=libsajat.so export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH Ellenőrzés splint-el: [/udprog-code/source# splint kozepes/glibc/libsajat.c Eredmény: [Splint Feb 2009 kozepes/glibc/libsajat.c: (in function printf) kozepes/glibc/libsajat.c:11:3: Return value (type int) ignored: putchar(0x1b) Result returned by function call is not used. If this is intended, can cast result to (void) to eliminate message. (Use -retvalint to inhibit warning) kozepes/glibc/libsajat.c:12:3: Return value (type int) ignored: putchar( [ )

219 A Debreceni Egyetem programozói évkönyve 189 / 404 kozepes/glibc/libsajat.c:13:3: Return value (type int) ignored: putchar( 4 ) kozepes/glibc/libsajat.c:14:3: Return value (type int) ignored: putchar( 3 ) kozepes/glibc/libsajat.c:15:3: Return value (type int) ignored: putchar( ; ) kozepes/glibc/libsajat.c:16:3: Return value (type int) ignored: putchar( 3 ) kozepes/glibc/libsajat.c:17:3: Return value (type int) ignored: putchar( 1 ) kozepes/glibc/libsajat.c:18:3: Return value (type int) ignored: putchar( m ) kozepes/glibc/libsajat.c:19:3: Return value (type int) ignored: vprintf(fmt, ap) kozepes/glibc/libsajat.c:20:3: Return value (type int) ignored: putchar(0x1b) kozepes/glibc/libsajat.c:21:3: Return value (type int) ignored: putchar( [ ) kozepes/glibc/libsajat.c:22:3: Return value (type int) ignored: putchar( 0 ) kozepes/glibc/libsajat.c:23:3: Return value (type int) ignored: putchar( m ) Finished checking code warnings Saját top parancs A feladatot Szimeonov Nikolett készítette. A feladat megoldása a következő állományokban található:../source/kozepes/top/proci.c #include <stdio.h> #include <unistd.h> #include <curses.h> int main () FILE *procstat; unsigned long usermode, nice, systemmode, idle, iowait, irq, softirq; unsigned long usermode1, nice1, systemmode1, idle1, iowait1, irq1, softirq1; unsigned osszes; WINDOW *ablak; ablak = initscr (); noecho (); cbreak (); nodelay (ablak, true); //egy vegtelen ciklusban olvassuk es feldolgozzuk a /proc/stat file tartalmat for (;;) //megnyitjuk a fajlt olvasasi joggal procstat = fopen ("/proc/stat", "r"); //feldolgozzuk a fajl tartalmat fscanf (procstat, "cpu %lu %lu %lu %lu %lu %lu %lu", &usermode, &nice, &systemmode, &idle, &iowait, &irq, &softirq); //fajl bezarasa fclose (procstat); //1 masodperc altatas sleep (1); //fajl ismetelt megnyitasa (tovabbi informaciok kinyerese) procstat = fopen ("/proc/stat", "r"); fscanf (procstat, "cpu %lu %lu %lu %lu %lu %lu %lu", &usermode1, &nice1, &systemmode1, &idle1, &iowait1, &irq1, &softirq1); fclose (procstat); usermode1 -= usermode; nice1 -= nice; systemmode1 -= systemmode;

220 A Debreceni Egyetem programozói évkönyve 190 / 404 idle1 -= idle; iowait1 -= iowait; irq1 -= irq; softirq1 -= softirq; osszes = usermode1 + nice1 + systemmode1 + idle1 + iowait1 + irq1 + softirq1; //console torlese clear (); //kiiratas printw ("user mode: %.2f%% nice: %.2f%% system mode: %.2f%% idle: %.2f%% IO wait: %.2f%% irq: - %.2f%% soft irq: %.2f%%\n", (double) usermode1 / osszes * 100, (double) nice1 / osszes * 100, (double) systemmode1 / osszes * 100, (double) idle1 / osszes * 100, (double) iowait1 / osszes * 100, (double) irq1 / osszes * 100, (double) softirq1 / osszes * 100); refresh (); if (getch () == q ) break; endwin (); return 0; A program fordításához a gcc proci.c -o proci -l curses és a./proci parancsokat használtam.ehhez telepítsd: sudo apt-get install libncurses5-dev ábra. Futtatás Ellenőrzés splint-el: [/udprog-code/source# splint kozepes/top/proci.c Eredmény: [Splint Feb 2009 kozepes/top/proci.c:1: Include file <unistd.h> matches the name of a POSIX library, but the POSIX library is not being used. Consider using +posixlib or +posixstrictlib to select the POSIX library, or -warnposix to suppress this message. Header name matches a POSIX header, but the POSIX library is not selected. (Use -warnposixheaders to inhibit warning) kozepes/top/proci.c:3:20: Cannot find include file curses.h on search path: /usr/include;/usr/include Preprocessing error. (Use -preproc to inhibit warning) Preprocessing error for file: /home/ranieth/prog/udprog-code/source/kozepes/top/ proci.c *** Cannot continue.

221 A Debreceni Egyetem programozói évkönyve 191 / Az első Qt programjaid Arecibói üzenet A feladatot Akai József Zsolt készítette.(busák Zoltán Tutor segítségével)../source/kozepes/qt/areciboi_uzenet/main.cpp A megoldás az arecibói rádióüzenetet készíti el amelyet 1974-ben sugároztak a Földről az űrbe. Az areciboiablak a kép méretéért felel, és ez rajzolja ki az üzenetet amelynek a hossza 23*73. //arecioablak.cpp #include "areciboiablak.h" AreciboAblak::AreciboAblak(int szelesseg, int magassag, std::string uzenet, QWidget *parent - ) : QMainWindow(parent) setwindowtitle("arecibo"); this->magassag = magassag; this->szelesseg = szelesseg; this->uzenet = uzenet; cellaszelesseg = 6; cellamagassag = 6; setfixedsize(qsize(szelesseg*cellaszelesseg, magassag*cellamagassag)); void AreciboAblak::paintEvent(QPaintEvent*) QPainter qpainter(this); for(int i=0; i<magassag; ++i) for(int j=0; j<szelesseg; ++j) if(uzenet.at(i*szelesseg+j) == 1 ) qpainter.fillrect(j*cellaszelesseg, i*cellamagassag, cellaszelesseg, cellamagassag, Qt::black); else qpainter.fillrect(j*cellaszelesseg, i*cellamagassag, cellaszelesseg, cellamagassag, Qt::white); qpainter.setpen(qpen(qt::gray, 1)); qpainter.drawrect(j*cellaszelesseg, i*cellamagassag, cellaszelesseg, cellamagassag); qpainter.end(); AreciboAblak::~AreciboAblak() //arecioablak.h #ifndef ARECIBOABLAK_H #define ARECIBOABLAK_H

222 A Debreceni Egyetem programozói évkönyve 192 / 404 #include <QMainWindow> #include <QPainter> class AreciboAblak : public QMainWindow Q_OBJECT public: AreciboAblak(int szelesseg = 23, int magassag = 73, std::string uzenet = " ", QWidget *parent = 0); ~AreciboAblak(); protected: std::string uzenet; int cellaszelesseg; int cellamagassag; int szelesseg; int magassag; void paintevent(qpaintevent*); ; #endif // ARECIBOABLAK_H //main #include <QApplication> #include "areciboiablak.h" int main(int argc, char *argv[]) QApplication a(argc, argv); AreciboAblak w(23, 73, "000..."); w.show(); return a.exec(); Mandelbrot rajzoló A feladatot Akai József Zsolt készítette.(busák Zoltán Tutor segítségével) A feladat megoldását a következő mappában található:../source/kozepes/qt/mandelbrot/ A mandelbrot halmaz számolását a frakszál végzi, viszont a rajzolást átadja frakablak osztálynak, mindig az éppen kiszámolt sort. A main függvényben példányosítunk, majd a w.show() segítségével kirajzoljuk a halmazt. // frakablak.cpp #include "frakablak.h" FrakAblak::FrakAblak(double a, double b, double c, double d, int szelesseg, int iteracioshatar, QWidget *parent) : QMainWindow(parent) setwindowtitle("mandelbrot halmaz");

223 A Debreceni Egyetem programozói évkönyve 193 / 404 int magassag = (int)(szelesseg * ((d-c)/(b-a))); setfixedsize(qsize(szelesseg, magassag)); fraktal= new QImage(szelesseg, magassag, QImage::Format_RGB32); mandelbrot = new FrakSzal(a, b, c, d, szelesseg, magassag, iteracioshatar, this); mandelbrot->start(); FrakAblak::~FrakAblak() delete fraktal; delete mandelbrot; void FrakAblak::paintEvent(QPaintEvent*) QPainter qpainter(this); qpainter.drawimage(0, 0, *fraktal); qpainter.end(); void FrakAblak::vissza(int magassag, int *sor, int meret) for(int i=0; i<meret; ++i) QRgb szin = qrgb(255-sor[i],0, 0); fraktal->setpixel(i, magassag, szin); update(); // frakszal.cpp #include "frakszal.h" FrakSzal::FrakSzal(double a, double b, double c, double d, int szelesseg, int magassag, int iteracioshatar, FrakAblak *frakablak) this->a = a; this->b = b; this->c = c; this->d = d; this->szelesseg = szelesseg; this->iteracioshatar = iteracioshatar; this->frakablak = frakablak; this->magassag = magassag; egysor = new int[szelesseg]; FrakSzal::~FrakSzal() delete[] egysor; void FrakSzal::run() double dx = (b-a)/szelesseg; double dy = (d-c)/magassag; double rec, imc, rez, imz, ujrez, ujimz; int iteracio = 0;

224 A Debreceni Egyetem programozói évkönyve 194 / 404 for(int j=0; j<magassag; ++j) //sor = j; for(int k=0; k<szelesseg; ++k) // c = (rec, imc) a háló rácspontjainak // megfelelõ komplex szám rec = a+k*dx; imc = d-j*dy; // z_0 = 0 = (rez, imz) rez = 0; imz = 0; iteracio = 0; while(rez*rez + imz*imz < 4 && iteracio < iteracioshatar) // z_n+1 = z_n * z_n + c ujrez = rez*rez - imz*imz + rec; ujimz = 2*reZ*imZ + imc; rez = ujrez; imz = ujimz; ++iteracio; iteracio %= 256; egysor[k] = iteracio; frakablak->vissza(j, egysor, szelesseg); //main #include <QApplication> #include "frakablak.h" int main(int argc, char *argv[]) QApplication a(argc, argv); FrakAblak w1, w2( , , , , 600, 3000), w3( , , , , 600, 4000), w4( , , , , 600, 38655); w1.show(); w2.show(); w3.show(); w4.show(); return a.exec(); Mandelbrot nagyító A feladatot Akai József Zsolt készítette.(busák Zoltán Tutor segítségével) A feladat megoldása a következő mappában található:../source/kozepes/qt/mandel_nagyito/

225 A Debreceni Egyetem programozói évkönyve 195 / 404 Az előző feladathoz képest csak a frakablak.cpp-ben történt változás: mousepressevent a nagyítandó terület bal felső sarkát határozza meg. mousemoveevent a nagyítandó terület szélességét és magasságát határozza meg. mousereleaseevent végzi el a nagyítást. // frakablak.cpp // // Mandelbrot halmaz nagyító #include "frakablak.h" FrakAblak::FrakAblak(double a, double b, double c, double d, int szelesseg, int iteracioshatar, QWidget *parent) : QMainWindow(parent) setwindowtitle("mandelbrot halmaz"); szamitasfut = true; x = y = mx = my = 0; this->a = a; this->b = b; this->c = c; this->d = d; this->szelesseg = szelesseg; this->iteracioshatar = iteracioshatar; magassag = (int)(szelesseg * ((d-c)/(b-a))); setfixedsize(qsize(szelesseg, magassag)); fraktal= new QImage(szelesseg, magassag, QImage::Format_RGB32); mandelbrot = new FrakSzal(a, b, c, d, szelesseg, magassag, iteracioshatar, this); mandelbrot->start(); FrakAblak::~FrakAblak() delete fraktal; delete mandelbrot; void FrakAblak::paintEvent(QPaintEvent*) QPainter qpainter(this); qpainter.drawimage(0, 0, *fraktal); if(!szamitasfut) qpainter.setpen(qpen(qt::white, 1)); qpainter.drawrect(x, y, mx, my); qpainter.end(); void FrakAblak::mousePressEvent(QMouseEvent* event) x = event->x(); y = event->y(); mx = 0; my = 0; update(); void FrakAblak::mouseMoveEvent(QMouseEvent* event)

226 A Debreceni Egyetem programozói évkönyve 196 / 404 mx = event->x() - x; my = mx; // négyzet alakú update(); void FrakAblak::mouseReleaseEvent(QMouseEvent* event) if(szamitasfut) return; szamitasfut = true; double dx = (b-a)/szelesseg; double dy = (d-c)/magassag; double a = this->a+x*dx; double b = this->a+x*dx+mx*dx; double c = this->d-y*dy-my*dy; double d = this->d-y*dy; this->a = a; this->b = b; this->c = c; this->d = d; delete mandelbrot; mandelbrot = new FrakSzal(a, b, c, d, szelesseg, magassag, iteracioshatar, this); mandelbrot->start(); update(); void FrakAblak::keyPressEvent(QKeyEvent *event) if(szamitasfut) return; if (event->key() == Qt::Key_N) iteracioshatar *= 2; szamitasfut = true; delete mandelbrot; mandelbrot = new FrakSzal(a, b, c, d, szelesseg, magassag, iteracioshatar, this); mandelbrot->start(); void FrakAblak::vissza(int magassag, int *sor, int meret) for(int i=0; i<meret; ++i) QRgb szin = qrgb(0, 255-sor[i], 0); fraktal->setpixel(i, magassag, szin); update(); void FrakAblak::vissza(void)

227 A Debreceni Egyetem programozói évkönyve 197 / 404 szamitasfut = false; x = y = mx = my = 0; Mandelbrot mentő A feladatot Deregi Diána készítette el. A feladat megoldása a következő mappában található:../source/kozepes/qt/mandel_mento/ Az előző feladat megoldását annyiban módosítottam, hogy bővítettem a keypressevent függvényt. A kényelmes használathoz a program sorszámozza az elkészített képeket. void FrakAblak::keyPressEvent(QKeyEvent *event) if(szamitasfut) return; if (event->key() == Qt::Key_N) iteracioshatar *= 2; szamitasfut = true; delete mandelbrot; mandelbrot = new FrakSzal(a, b, c, d, szelesseg, magassag, iteracioshatar, this); mandelbrot->start(); if (event->key() == Qt::Key_S) fraktal->save("mandel_"+qstring::number(kepszam++)+".png"); A genetikai kód-szőnyeg A feladatot Akai József Zsolt készítette.(busák Zoltán Tutor segítségével) A feladat megoldása a következő mappában található:../source/kozepes/qt/genetikai/ Beolvas egy adott mennyiséget a kromoszóma genetikai kódjából és a T, C, A, G betűknek egy színt megfeleltetve rajzolja ki a kapott képet. // genablak.cpp // Genomikus szőnyeg #include "genablak.h" GenAblak::GenAblak(const char *fajlnev, int szelesseg, int magassag, QWidget *parent) : QMainWindow(parent) setwindowtitle("tcag szonyeg"); this->magassag = magassag; this->szelesseg = szelesseg;

228 A Debreceni Egyetem programozói évkönyve 198 / 404 setfixedsize(qsize(szelesseg, magassag)); minta = new int*[magassag]; for(int i=0; i<magassag; ++i) minta[i] = new int [szelesseg]; for(int i=0; i<magassag; ++i) for(int j=0; j<szelesseg; ++j) minta[i][j] = qrgb (i%255, 255, 0); szonyeg = new GenSzal(fajlNev, szelesseg, this); szonyeg->start(); void GenAblak::paintEvent(QPaintEvent*) QPainter qpainter(this); for(int i=0; i<magassag; ++i) for(int j=0; j<szelesseg; ++j) qpainter.setpen(qpen(qcolor(minta[i][j]), 1)); qpainter.drawpoint(j, i); qpainter.end(); void GenAblak::vissza(int *sor, int meret) for(int i=1; i<magassag; ++i) for(int j=0; j<szelesseg; ++j) minta[i-1][j] = minta[i][j]; for(int i=0; i<meret; ++i) minta[magassag-1][i] = sor[i]; update(); GenAblak::~GenAblak() for(int i=0; i<magassag; ++i) delete[] minta[i]; delete[] minta; // genszal.cpp // // Genomikus szőnyeg #include "genszal.h" GenSzal::GenSzal(const char *fajlnev, int szelesseg, GenAblak *genablak) this->szelesseg = szelesseg;

229 A Debreceni Egyetem programozói évkönyve 199 / 404 this->genablak = genablak; egysor = new int[szelesseg]; fajl = new QFile(fajlNev); fajl->open(qiodevice::readonly); void GenSzal::run() while(true) QThread::msleep(80); char c; for(int i=0; i < szelesseg && (fajl->getchar(&c)!= -1); ++i) if(c==0x0a) continue; switch(c) case T : egysor[i] = qrgb (255, 0, 0); break; case C : egysor[i] = qrgb (0, 255, 0); break; case A : egysor[i] = qrgb (0, 0, 255); break; case G : egysor[i] = qrgb (100, 0, 50); break; default: egysor[i] = qrgb (255, 255, 255); break; genablak->vissza(egysor, szelesseg); GenSzal::~GenSzal() fajl->close(); delete fajl; delete[] egysor; #include <QApplication> #include "genablak.h" int main(int argc, char *argv[]) QApplication a(argc, argv); GenAblak w("/home/norbi/c/tcag/hs_alt_hs_celera_chr2.fa", 600, 300); w.show();

230 A Debreceni Egyetem programozói évkönyve 200 / 404 return a.exec(); A kód vizualizációjának mentése A megoldást elkészítette: Szentpéteri Annamária. Dátum: Forrás megtalálható: source/binom/d.diana-sz.annamaria/- Frak2 mappában. (Konkrétan a frakablak.cpp sorában.)... void FrakAblak::keyPressEvent(QKeyEvent *event) if(szamitasfut) return; if (event->key() == Qt::Key_N) iteracioshatar *= 2; szamitasfut = true; delete mandelbrot; mandelbrot = new FrakSzal(a, b, c, d, szelesseg, magassag, iteracioshatar, this); mandelbrot->start(); /* * Ha a lenyomott gomb az [S], akkor a fraktal - mely QImage típusú * objektum - save() fuggvényét hívja meg. * Referencia: * */ if (event->key() == Qt::Key_S) fraktal->save ( "prtscr.png", "png", 100 ); Sejtautomata szimulációk A feladatot Akai József Zsolt készítette.(busák Zoltán Tutor segítségével) A feladat megoldása a következő mappában található:../source/kozepes/qt/sejtautomata/ A sejttérbe élőlényeket helyezünk, ez a "sikló ágyú".adott irányban siklókat lõ ki. // sejtablak.cpp // // Életjáték rajzoló #include "sejtablak.h" SejtAblak::SejtAblak(int szelesseg, int magassag, QWidget *parent) : QMainWindow(parent) setwindowtitle("a John Horton Conway-féle életjáték"); this->magassag = magassag; this->szelesseg = szelesseg;

231 A Debreceni Egyetem programozói évkönyve 201 / 404 cellaszelesseg = 6; cellamagassag = 6; setfixedsize(qsize(szelesseg*cellaszelesseg, magassag*cellamagassag)); racsok = new bool**[2]; racsok[0] = new bool*[magassag]; for(int i=0; i<magassag; ++i) racsok[0][i] = new bool [szelesseg]; racsok[1] = new bool*[magassag]; for(int i=0; i<magassag; ++i) racsok[1][i] = new bool [szelesseg]; racsindex = 0; racs = racsok[racsindex]; // A kiinduló racs minden cellája HALOTT for(int i=0; i<magassag; ++i) for(int j=0; j<szelesseg; ++j) racs[i][j] = HALOTT; // A kiinduló racsra "ELOlényeket" helyezünk //siklo(racs, 2, 2); siklokilovo(racs, 5, 60); eletjatek = new SejtSzal(racsok, szelesseg, magassag, 120, this); eletjatek->start(); void SejtAblak::paintEvent(QPaintEvent*) QPainter qpainter(this); // Az aktuális bool **racs = racsok[racsindex]; // racsot rajzoljuk ki: for(int i=0; i<magassag; ++i) // végig lépked a sorokon for(int j=0; j<szelesseg; ++j) // s az oszlopok // Sejt cella kirajzolása if(racs[i][j] == ELO) qpainter.fillrect(j*cellaszelesseg, i*cellamagassag, cellaszelesseg, cellamagassag, Qt::black); else qpainter.fillrect(j*cellaszelesseg, i*cellamagassag, cellaszelesseg, cellamagassag, Qt::white); qpainter.setpen(qpen(qt::gray, 1)); qpainter.drawrect(j*cellaszelesseg, i*cellamagassag, cellaszelesseg, cellamagassag); qpainter.end(); SejtAblak::~SejtAblak() delete eletjatek; for(int i=0; i<magassag; ++i) delete[] racsok[0][i]; delete[] racsok[1][i]; delete[] racsok[0];

232 A Debreceni Egyetem programozói évkönyve 202 / 404 delete[] racsok[1]; delete[] racsok; void SejtAblak::vissza(int racsindex) this->racsindex = racsindex; update(); void SejtAblak::siklo(bool **racs, int x, int y) racs[y+ 0][x+ 2] = ELO; racs[y+ 1][x+ 1] = ELO; racs[y+ 2][x+ 1] = ELO; racs[y+ 2][x+ 2] = ELO; racs[y+ 2][x+ 3] = ELO; void SejtAblak::sikloKilovo(bool **racs, int x, int y) racs[y+ 6][x+ 0] = ELO; racs[y+ 6][x+ 1] = ELO; racs[y+ 7][x+ 0] = ELO; racs[y+ 7][x+ 1] = ELO; racs[y+ 3][x+ 13] = ELO; racs[y+ 4][x+ 12] = ELO; racs[y+ 4][x+ 14] = ELO; racs[y+ 5][x+ 11] = ELO; racs[y+ 5][x+ 15] = ELO; racs[y+ 5][x+ 16] = ELO; racs[y+ 5][x+ 25] = ELO; racs[y+ 6][x+ 11] = ELO; racs[y+ 6][x+ 15] = ELO; racs[y+ 6][x+ 16] = ELO; racs[y+ 6][x+ 22] = ELO; racs[y+ 6][x+ 23] = ELO; racs[y+ 6][x+ 24] = ELO; racs[y+ 6][x+ 25] = ELO; racs[y+ 7][x+ 11] = ELO; racs[y+ 7][x+ 15] = ELO; racs[y+ 7][x+ 16] = ELO; racs[y+ 7][x+ 21] = ELO; racs[y+ 7][x+ 22] = ELO; racs[y+ 7][x+ 23] = ELO; racs[y+ 7][x+ 24] = ELO; racs[y+ 8][x+ 12] = ELO; racs[y+ 8][x+ 14] = ELO; racs[y+ 8][x+ 21] = ELO; racs[y+ 8][x+ 24] = ELO; racs[y+ 8][x+ 34] = ELO; racs[y+ 8][x+ 35] = ELO; racs[y+ 9][x+ 13] = ELO; racs[y+ 9][x+ 21] = ELO;

233 A Debreceni Egyetem programozói évkönyve 203 / 404 racs[y+ 9][x+ 22] = ELO; racs[y+ 9][x+ 23] = ELO; racs[y+ 9][x+ 24] = ELO; racs[y+ 9][x+ 34] = ELO; racs[y+ 9][x+ 35] = ELO; racs[y+ 10][x+ 22] = ELO; racs[y+ 10][x+ 23] = ELO; racs[y+ 10][x+ 24] = ELO; racs[y+ 10][x+ 25] = ELO; racs[y+ 11][x+ 25] = ELO; // sejtszal.cpp // // Életjáték rajzoló #include "sejtszal.h" SejtSzal::SejtSzal(bool ***racsok, int szelesseg, int magassag, int varakozas, SejtAblak * - sejtablak) this->racsok = racsok; this->szelesseg = szelesseg; this->magassag = magassag; this->varakozas = varakozas; this->sejtablak = sejtablak; racsindex = 0; int SejtSzal::szomszedokSzama(bool **racs, int sor, int oszlop, bool allapot) int allapotuszomszed = 0; // A nyolcszomszédok végigzongorázása: for(int i=-1; i<2; ++i) for(int j=-1; j<2; ++j) // A vizsgált sejtet magát kihagyva: if(!((i==0) && (j==0))) // A sejttérbõl szélének szomszédai // a szembe oldalakon ("periódikus határfeltétel") int o = oszlop + j; if(o < 0) o = szelesseg-1; else if(o >= szelesseg) o = 0; int s = sor + i; if(s < 0) s = magassag-1; else if(s >= magassag) s = 0; if(racs[s][o] == allapot) ++allapotuszomszed; return allapotuszomszed; void SejtSzal::idoFejlodes()

234 A Debreceni Egyetem programozói évkönyve 204 / 404 bool **racselotte = racsok[racsindex]; bool **racsutana = racsok[(racsindex+1)%2]; for(int i=0; i<magassag; ++i) // sorok for(int j=0; j<szelesseg; ++j) // oszlopok int elok = szomszedokszama(racselotte, i, j, SejtAblak::ELO); if(racselotte[i][j] == SejtAblak::ELO) if(elok==2 elok==3) racsutana[i][j] = SejtAblak::ELO; else racsutana[i][j] = SejtAblak::HALOTT; else if(elok==3) racsutana[i][j] = SejtAblak::ELO; else racsutana[i][j] = SejtAblak::HALOTT; racsindex = (racsindex+1)%2; /** A sejttér idõbeli fejlõdése. */ void SejtSzal::run() while(true) QThread::msleep(varakozas); idofejlodes(); sejtablak->vissza(racsindex); SejtSzal::~SejtSzal() #include <QApplication> #include "sejtablak.h" int main(int argc, char *argv[]) QApplication a(argc, argv); SejtAblak w(100, 75); w.show(); return a.exec(); Fájlleíró modul A feladatot Akai József Zsolt készítette.(busák Zoltán Tutor segítségével) A feladat megoldása a következő állományokban található:../source/kozepes/fájlleiro/fájleiro.c../source/kozepes/fajlleiro/makefile Fordítás: make -j (magok száma )

235 A Debreceni Egyetem programozói évkönyve 205 / 404 #include <linux/init.h> #include <linux/module.h> #include <linux/kernel.h> #include <linux/sched.h> #include <linux/list.h> #include <linux/fdtable.h> MODULE_AUTHOR("Akai Zsolt <(zsolt2013_2013@hotmail.hu)> Tutor:Busák Zoltán"); MODULE_LICENSE("GPL"); static int elso_init_module(void) struct task_struct *task; struct list_head *p; int i=0; printk(kern_notice "Elso modul belep\n"); list_for_each(p,current->tasks.next) task=list_entry(p,struct task_struct,tasks); i=(task->files)->next_fd; printk(kern_notice "%s %i %i\n",task->comm,task->pid,i); return 0; static void elso_exit_module(void) printk(kern_notice "Elso modul kilep\n"); module_init(elso_init_module); module_exit(elso_exit_module); BBP megvalósítás A feladatot Ozsváth Jonathán készítette.(busák Zoltán Tutor segítségével) A feladat megoldása a következő állományokban található:../source/kozepes/algoritmizalasi/bbp.c #include <stdio.h> #include <math.h> #include <stdlib.h> long long int binhatmod(long long int n, long long int k) long long int r=1; long long int t=1; while(t<=n) t*=2; for(;;)

236 A Debreceni Egyetem programozói évkönyve 206 / 404 if(n>=t) r=(16*r)%k; n=n-t; t=t/2; if(t<1) break; r=(r*r)%k; return r; long double Sj(long long int d, int j) long double sj =0.0; long long int k; for(k=0;k<=d;++k) sj+=(long double) binhatmod(d-k,8*k+j)/(long double) (8*k+j); for (k=d+1;k<=2*d;++k) sj+=pow(16.0,d-k)/(long double)(8*k+j); return sj - floor(sj); int main(int argc,char **argv) long double pi_hkif=0.0; long double s1=0.0; long double s4=0.0; long double s5=0.0; long double s6=0.0; long long int d,d_kezdo,d_befejezo; int jegy,jegyh,jegysz=2; if(argc!=4) return -1; d_kezdo=atoll(argv[1]); d_befejezo=atoll(argv[2]); jegysz=atoi(argv[3]); for(d=d_kezdo;d<d_befejezo;d+=jegysz) pi_hkif=0.0; s1=sj(d,1); s4=sj(d,4); s5=sj(d,5); s6=sj(d,6); pi_hkif=4.0*s1-2.0*s4-s5-s6;

237 A Debreceni Egyetem programozói évkönyve 207 / 404 pi_hkif=pi_hkif-floor(pi_hkif); for(jegyh=0;jegyh<jegysz&&pi_hkif!=0.0;+jegyh) jegy=(int) floor(16.0*pi_hkif); pi_hkif=16.0*pi_hkif-floor(16.0*pi_hkif); if(jegy<10) printf("%d",jegy); else printf("%c", A +jegy -10); fflush(stdout); return 0; Ellenőrzés splint-el: [/udprog-code/source# splint kozepes/algoritmizalasi/bbp.c Eredmény: [Splint Feb 2009 kozepes/algoritmizalasi/bbp.c: (in function Sj) kozepes/algoritmizalasi/bbp.c:40:16: Function pow expects arg 2 to be double gets long long: d - k To allow all numeric types to match, use +relaxtypes. kozepes/algoritmizalasi/bbp.c:42:20: Function floor expects arg 1 to be double gets long double: sj To ignore type qualifiers in type comparisons use +ignorequals. kozepes/algoritmizalasi/bbp.c: (in function main) kozepes/algoritmizalasi/bbp.c:61:10: Unrecognized identifier: atoll Identifier used in code has not been declared. (Use -unrecog to inhibit warning) kozepes/algoritmizalasi/bbp.c:76:25: Function floor expects arg 1 to be double gets long double: pi_hkif kozepes/algoritmizalasi/bbp.c:78:29: Dangerous equality comparison involving long double types: pi_hkif!= 0.0 Two real (float, double, or long double) values are compared directly using == or!= primitive. This may produce unexpected results since floating point representations are inexact. Instead, compare the difference to FLT_EPSILON or DBL_EPSILON. (Use -realcompare to inhibit warning) kozepes/algoritmizalasi/bbp.c:80:21: Function floor expects arg 1 to be double gets long double: 16.0 * pi_hkif kozepes/algoritmizalasi/bbp.c:81:31: Function floor expects arg 1 to be double gets long double: 16.0 * pi_hkif kozepes/algoritmizalasi/bbp.c:86:17: Incompatible types for + (char, int): A + jegy A character constant is used as an int. Use +charintliteral to allow character constants to be used as ints. (This is safe since the actual type of a char constant is int.) kozepes/algoritmizalasi/bbp.c:88:4: Return value (type int) ignored: fflush(stdout) Result returned by function call is not used. If this is intended, can cast result to (void) to eliminate message. (Use -retvalint to inhibit warning) kozepes/algoritmizalasi/bbp.c:92:2: *** Internal Bug at constraintgeneration.c:1 441: Unsupported preop in +jegyh [errno: 25] *** Please report bug to submit@bugs.debian.org (via reportbug) ***

238 A Debreceni Egyetem programozói évkönyve 208 / 404 (attempting to continue, results may be incorrect) kozepes/algoritmizalasi/bbp.c:92:2: *** Internal Bug at constraintgeneration.c:1 442: constraintgeneration.c:1442: llassert failed: FALSE: Reached dead code! [errno: 25] *** Please report bug to submit@bugs.debian.org (via reportbug) *** (attempting to continue, results may be incorrect) Saját int veremosztály A megoldást készítette: Kakócz Erik A megoldás megtalálható az alábbi forrásállományban:../source/kozepes/int_verem/verem.cpp #include <iostream> //készítette Kakócz Erik //int verem osztály class Verem private: int* stack; int elemek; int meret; Verem(int i) stack=new int [i]; elemek=0; meret=i; ~Verem() delete[] stack; Verem(const Verem& forras) stack=new int[forras.meret]; int i=0; elemek=forras.elemek; meret=forras.meret; while(i<elemek) stack[i]=forras.stack[i]; i++; Verem& operator=(const Verem& forras) int i=0,no=0;

239 A Debreceni Egyetem programozói évkönyve 209 / 404 if (meret==forras.meret) if (elemek==forras.elemek) while(i<elemek) if (stack[i]!=forras.stack[i]) no++;; i++; if (!no) return *this; elemek=forras.elemek; meret=forras.meret; while(i<elemek) stack[i]=forras.stack[i]; i++; void push(int a) stack[elemek++]=a; int pop() return stack[--elemek]; ; int main() Verem v(10); v.push(10); v.push(3); v.push(8); Verem c=v; //használható a "Verem c(v);" alak is ahogy eddig szerepelt std::cout<<v.pop()<<std::endl; std::cout<<v.pop()<<std::endl; std::cout<<v.pop()<<std::endl; std::cout<<c.pop()<<std::endl; std::cout<<c.pop()<<std::endl; std::cout<<c.pop()<<std::endl; v.push(10); v.push(3); v.push(8); c.push(9); c.push(4); c.push(7); std::cout<<v.pop()<<std::endl; std::cout<<v.pop()<<std::endl; std::cout<<v.pop()<<std::endl; std::cout<<c.pop()<<std::endl; std::cout<<c.pop()<<std::endl; std::cout<<c.pop()<<std::endl; return 0;

240 A Debreceni Egyetem programozói évkönyve 210 / 404 Bár a feladat csak a verem osztályt követelte meg a kód végén megtalálható egy a működést szemléltető main függvény is. Az osztályunk áll egy adatrészből mely tartalmazza a veremként használt tömbre mutatóját,az elemek számát (melyet egyben a tömb indexelésére is fogunk használni), és a verem méretét. A következő a verem konstruktora melyben a new operátor segítségével helyet foglalunk a memóriában i számú elem számára (ahol i a konstruktor int argumentuma) az elemszámot és a verem méretét értelemszerűen beállítjuk. az osztály destruktorában (~Verem()) a delete operátorral felszabadítjuk a verem mutató által mutatott memóriaterületet így elkerülendő a memóriaszivárgást. A feladat része volt a mély másolás biztosítása. Mivel a Struktúra alapértelmezett másoló-konstruktora sekély másolással másol ezért ezt kell felülírnunk. Kezdésként ismét lefoglaljuk a tömb helyét a memóriában (lásd a konstruktornál) a méretnek és elemszámnak pedig a másolandó verem méretét, illetve elemszámát adjuk meg. Ezután pedig egy while ciklus segítségével másoljuk át a forrás verem tartalmát az új verembe. A másoló Konstruktor felülírása után túlterheljük az "=" értékadó operátort is, hogy a verem másolásakor ezt is használhassuk. Először ellenőrizzük hogy a másolandó verem és a veremobjektum amibe másolunk megegyeznek-e, ehhez ellenőrizzük a méretet majd az elemszámot, ha ezek egyeznek egy while ciklus segítségével egyenként hasonlítjuk össze az elemeiket. amennyiben nincs különbség a konstruktor azt a veremobjektumot adja vissza amelybe másolnánk. Ellenkező esetben az elemszámát és méretét egyenlővé tesszük a másolandóéval majd pedig egy while ciklus segítségével egyesével átmásoljuk bele a másolandó elemeit. Már csak a verem kezeléséhez elengedhetetlen két utasítás van hátra név szerint a push és a pop. Ezek szolgálnak arra hogy egy elemet behelyezzünk a verembe illetve a legutóbb behelyezett elemet visszakapjuk Saját int dinamikus tömb osztály A megoldást készítette: Balogh István Dávid, Dalmadi Zoltán tutor segítségével. A program a mély másolást mutatja be egy int dinamikus tömb osztályon keresztül. Fordítás: make Tömb osztály definíció source/kozepes/int_dintomb/int.h #ifndef INT_H #define INT_H // int dinamikus tömb osztály class Int public: Int(); Int(int); ~Int(); Int(const Int&); Int& operator=(const Int&); int& operator[](int); int getmeret() const; private: int meret; int* ertek;

241 A Debreceni Egyetem programozói évkönyve 211 / 404 ; #endif Tömb osztály implementáció source/kozepes/int_dintomb/int.cpp #include "int.h" // Paraméter nélküli konstruktor: // Inicializációs listában a két privát adattag, a tömb méretének és mutatójának nullára - állítása. Int::Int(): meret(0), ertek(0) // Paraméterül int-et kapó konstruktor: // Dinamikusan foglal n*sizeof(int) méretű helyet a tömbnek. Int::Int(int n) meret = n; ertek = new int[n]; // Destruktor: // Felszabadítja a dinamikus tárban létrehozott tömböt. Int::~Int() delete [] ertek; // Másoló konstruktor: // Konstans Int osztályt kap referenciaként, amelyet mély másolással másol. Int::Int(const Int& ref) meret = ref.getmeret(); ertek = new int[meret]; for(int i=0; i<meret; ++i) // mély másolás ertek[i] = ref.ertek[i]; // Az = operátor túlterhelése, azaz másoló értékadás. Int& Int::operator=(const Int& ref) // Ha a paraméterül kapott objektum egyezik az aktuálissal, akkor nincs mit másolni. if(&ref == this) return *this; //...Ellenkező esetben viszont másolat keletkezik, az = operátor a másolattal tér vissza -. meret = ref.getmeret(); ertek = new int[meret]; for(int i=0; i<meret; ++i) ertek[i] = ref.ertek[i]; return *this; // A [] operátor túlterhelése, hogy az Int osztályunk valóban hasonlítson tömbökre. int& Int::operator[](int n) if(n < 0) return ertek[0]; if(n >= getmeret()) return ertek[n-1]; return ertek[n];

242 A Debreceni Egyetem programozói évkönyve 212 / 404 // A tömb méretét lekérő getter függvény. // A const kulcsszó jelzi, hogy nem változtatjuk, csak olvassuk a méretet. int Int::getmeret() const return meret; Tömb osztály teszt source/kozepes/int_dintomb/main.cpp #include <iostream> #include "int.h" // A tömb elemeit és azok memóriacímeit kiírató eljárás: void kiir(int& tomb) for (int i=0; i<tomb.getmeret(); ++i) std::cout << "ertek: " << tomb[i] << ", cim: " << &tomb[i] << std::endl; // Main: int main(int argc, const char **argv) // Int osztálybeli 5 elemű tömb példányosítása: Int tomb(5); // Tömb feltöltése (50, 51, 52, 53, 54, de lehetne teljesen más is): for(int i=0; i<tomb.getmeret(); ++i) tomb[i] = (i + 50); // Első példatömb elemeinek és az elemek címeinek kiíratása: std::cout << std::endl << "Eredeti:" << std::endl << std::endl; kiir(tomb); // Második (tomb2) Int osztálybeli tömb példányosítása, mely értékül kapja az első - példatömböt. // Meghívódik a másoló értékadás, a tomb1 elemei átmásolódnak egy új din. területre. Int tomb2 = tomb; // Reményeink szerint a másolat elemei meg fognak egyezni az eredeti elemeivel, // azonban a memóriacímek különbözni fognak, azaz sikeres volt a mély másolás. std::cout << std::endl << "Masolat:" << std::endl << std::endl; kiir(tomb2); return 0;

243 A Debreceni Egyetem programozói évkönyve 213 / fejezet A Haladó szint programjai Párhuzamos programjaid Mandelbrot több szálon P-szálakkal A megoldást../source/halado/parhuzamositas/mandel.cpp forrásállományba helyeztem el. A megoldásban a párhuzamosítást a pthread_create végzi, a mandel_resz_szamitas függvényt hajtja végre párhuzamosan. A magok számát argumentumként várja. Fordítás: [../udprog-code/source/halado/parhuzamositas]$ g++ mandel.cpp libpng-config -- - ldflags -lpthread -o mandel #include <iostream> #include "png++/png.hpp" #include <pthread.h> #include <time.h> #include <sys/times.h> double a = -2.0, b =.7, c = -1.35, d = 1.35; int szelesseg = 600, magassag = 600, iteracioshatar = 32000; int SZALAK_SZAMA; png::image < png::rgb_pixel > kep(szelesseg, magassag); void * mandel_resz_szamitas(void *id) int mettol = *(int *) id * (magassag / (SZALAK_SZAMA)); int meddig = mettol + (magassag / SZALAK_SZAMA); double dx = (b - a) / szelesseg; double dy = (d - c) / magassag; double rec, imc, rez, imz, ujrez, ujimz; int iteracio = 0; std::cout << *(int *) id << ". szal szamitas indul"; for (int j = mettol; j < meddig; ++j) for (int k = 0; k < szelesseg; ++k)

244 A Debreceni Egyetem programozói évkönyve 214 / 404 rec = a + k * dx; imc = d - j * dy; rez = 0; imz = 0; iteracio = 0; while (rez * rez + imz * imz < 4 && iteracio < iteracioshatar) ujrez = rez * rez - imz * imz + rec; ujimz = 2 * rez * imz + imc; rez = ujrez; imz = ujimz; ++iteracio; kep.set_pixel(k, j, png::rgb_pixel(255 - (255 * iteracio) / iteracioshatar, (255 * iteracio) / iteracioshatar, (255 * iteracio) / iteracioshatar)); std::cout << "." << std::flush; return id; int main(int argc, char *argv[]) clock_t delta = clock(); struct tms tmsbuf1, tmsbuf2; times(&tmsbuf1); SZALAK_SZAMA=atoi(argv[2]); if (argc!= 3) std::cout << "Hasznalat:./mandel fajlnev magokszama"; return -1; pthread_t szal[szalak_szama]; int szal_arg[szalak_szama]; int i, *r; for (i = 0; i < SZALAK_SZAMA; ++i) szal_arg[i] = i; if (pthread_create(szal + i, NULL, mandel_resz_szamitas, (void *) (szal_arg + i))) exit(-1); for (i = 0; i < SZALAK_SZAMA; ++i) pthread_join(szal[i], (void **) &r); std::cout << *r << ". szal kesz."; kep.write(argv[1]); std::cout << argv[1] << " mentve" << std::endl;

245 A Debreceni Egyetem programozói évkönyve 215 / 404 times(&tmsbuf2); std::cout << tmsbuf2.tms_utime - tmsbuf1.tms_utime + tmsbuf2.tms_stime - tmsbuf1.tms_stime << std::endl; delta = clock() - delta; std::cout << (double) delta / CLOCKS_PER_SEC << " sec" << std::endl; Mandelbrot több szálon Open MP-vel A megoldást../source/halado/parhuzamositas/openmpmandel.cpp forrásállományba helyeztem el. A megoldásban a párhuzamosítást #pragma omp parallel for-al végezzük. Az omp_set_num_threads-be adjuk át azt, hogy hány szálon szeretnénk dolgozni azaz a magok számát, amit argumentumként vár. Fordítás: [../udprog-code/source/halado/parhuzamositas]$ g++ openmpmandel.cpp libpng-config -- - ldflags -fopenmp -O3 -o ompmandel #include <iostream> #include "png++/png.hpp" #include <sys/times.h> #include <omp.h> int main (int argc, char *argv[]) clock_t delta = clock (); struct tms tmsbuf1, tmsbuf2; times (&tmsbuf1); std::cout << omp_get_num_procs () << std::endl; std::cout << omp_get_max_threads () << std::endl; omp_set_num_threads (atoi(argv[2])); if (argc!= 3) std::cout << "Hasznalat:./mandel fajlnev magokszáma"; return -1; double a = -2.0, b =.7, c = -1.35, d = 1.35; int szelesseg = 600, magassag = 600, iteracioshatar = 32000; png::image < png::rgb_pixel > kep (szelesseg, magassag); double dx = (b - a) / szelesseg; double dy = (d - c) / magassag; double rec, imc, rez, imz, ujrez, ujimz; int iteracio = 0; std::cout << "Szamitas"; #pragma omp parallel for for (int j = 0; j < magassag; ++j) for (int k = 0; k < szelesseg; ++k) rec = a + k * dx;

246 A Debreceni Egyetem programozói évkönyve 216 / 404 imc = d - j * dy; // z_0 = 0 = (rez, imz) rez = 0; imz = 0; iteracio = 0; while (rez * rez + imz * imz < 4 && iteracio < iteracioshatar) // z_n+1 = z_n * z_n + c ujrez = rez * rez - imz * imz + rec; ujimz = 2 * rez * imz + imc; rez = ujrez; imz = ujimz; ++iteracio; kep.set_pixel (k, j, png::rgb_pixel (255 - (255 * iteracio) / iteracioshatar, (255 * iteracio) / iteracioshatar, (255 * iteracio) / iteracioshatar)); std::cout << "." << std::flush; kep.write (argv[1]); std::cout << argv[1] << " mentve" << std::endl; times (&tmsbuf2); std::cout << tmsbuf2.tms_utime - tmsbuf1.tms_utime + tmsbuf2.tms_stime - tmsbuf1.tms_stime << std::endl; delta = clock () - delta; std::cout << (double) delta / CLOCKS_PER_SEC << " sec" << std::endl; Mandelbrot Intel TBB-vel A megoldást../source/halado/parhuzamositas/mandeltbb.cpp forrásállományba helyeztem el. A kódból jól látszik, hogy a TBB az OpenMP-vel közeli rokonságban van. A magok számát argumentumként várja a program. Fordítás: [../udprog-code/source/halado/parhuzamositas]$ g++ mandeltbb.cpp -ltbb -lpng12 -O3 -o - mandeltbb #include <iostream> #include "tbb/tbb.h" #include "png++/png.hpp" #include <pthread.h> #include <time.h> #include <sys/times.h> int SZALAK_SZAMA;

247 A Debreceni Egyetem programozói évkönyve 217 / 404 class mandelbrot_reszszamitas public: mandelbrot_reszszamitas (int reszi, png::image < png::rgb_pixel > & kep, double a=-2.0, double b =.7, double c = -1.35, double d = 1.35, int szelesseg = 600, int magassag = 600, int iteracioshatar = ):reszi (reszi), kep (kep), a (a), b (b), c (c), d (d), szelesseg (szelesseg), magassag (magassag), iteracioshatar (iteracioshatar) void operator () () const int mettol = reszi * (magassag / SZALAK_SZAMA); int meddig = mettol + (magassag / SZALAK_SZAMA); double dx = (b - a) / szelesseg; double dy = (d - c) / magassag; double rec, imc, rez, imz, ujrez, ujimz; int iteracio = 0; for (int j = mettol; j < meddig; ++j) for (int k = 0; k < szelesseg; ++k) rec = a + k * dx; imc = d - j * dy; rez = 0; imz = 0; iteracio = 0; while (rez * rez + imz * imz < 4 && iteracio < iteracioshatar) ujrez = rez * rez - imz * imz + rec; ujimz = 2 * rez * imz + imc; rez = ujrez; imz = ujimz; ++iteracio; kep.set_pixel(k, j, png::rgb_pixel(255 - (255 * iteracio) / iteracioshatar, (255 * iteracio) / iteracioshatar, (255 * iteracio) / iteracioshatar)); private: int reszi; png::image < png::rgb_pixel > & kep; double a,b,c,d; int szelesseg, magassag, iteracioshatar;

248 A Debreceni Egyetem programozói évkönyve 218 / 404 ; int main(int argc, char *argv[]) SZALAK_SZAMA=atoi(argv[2]); if (argc!= 3) std::cout << "Hasznalat:./mandeltbb fajlnev magokszama"; return -1; tbb::task_group reszszamitasok; png::image < png::rgb_pixel > kep(600, 600); clock_t delta = clock(); struct tms tmsbuf1, tmsbuf2; times(&tmsbuf1); reszszamitasok.run (mandelbrot_reszszamitas (0, kep)); reszszamitasok.run (mandelbrot_reszszamitas (1, kep)); reszszamitasok.wait (); kep.write(argv[1]); std::cout << argv[1] << " mentve" << std::endl; times(&tmsbuf2); std::cout << tmsbuf2.tms_utime - tmsbuf1.tms_utime + tmsbuf2.tms_stime - tmsbuf1.tms_stime << std::endl; delta = clock() - delta; std::cout << (double) delta / CLOCKS_PER_SEC << " sec" << std::endl; Exor-törés párhuzamosítása A megoldást../source/halado/exor/exor.c forrásállományba helyeztem el. double atlagos_szohossz (const char *titkos, int titkos_meret) int sz = 0; for (int i = 0; i < titkos_meret; ++i) if (titkos[i] == ) ++sz; return (double) titkos_meret / sz; int tiszta_lehet (const char *titkos, int titkos_meret) double szohossz = atlagos_szohossz (titkos, titkos_meret); return szohossz > 6.0 && szohossz < 9.0 && strcasestr (titkos, "hogy") && strcasestr (titkos, "nem") && strcasestr (titkos, "az") && strcasestr (titkos, "ha");

249 A Debreceni Egyetem programozói évkönyve 219 / 404 void exor (const char kulcs[], int kulcs_meret, char titkos[], int titkos_meret, char *buffer) int kulcs_index = 0; for (int i = 0; i < titkos_meret; ++i) buffer[i] = titkos[i] ^ kulcs[kulcs_index]; kulcs_index = (kulcs_index + 1) % kulcs_meret; void exor_tores (const char kulcs[], int kulcs_meret, char titkos[], int titkos_meret) char *buffer; if ((buffer = (char *)malloc(sizeof(char)*titkos_meret)) == NULL) printf("memoria (buffer) faliora\n"); exit(-1); exor (kulcs, kulcs_meret, titkos, titkos_meret, buffer); if (tiszta_lehet (buffer, titkos_meret)) printf("kulcs: [%c%c%c%c%c%c%c%c]\ntiszta szoveg: [%s]\n", kulcs[0],kulcs[1],kulcs[2],kulcs[3],kulcs[4],kulcs[5],kulcs[6],kulcs[7], - buffer); free(buffer); int main (void) char kulcs[kulcs_meret]; char titkos[max_titkos]; char *p = titkos; int olvasott_bajtok; while ((olvasott_bajtok = read (0, (void *) p, (p - titkos + OLVASAS_BUFFER < MAX_TITKOS)? OLVASAS_BUFFER : titkos + MAX_TITKOS - p))) p += olvasott_bajtok; for (int i = 0; i < MAX_TITKOS - (p - titkos); ++i) titkos[p - titkos + i] = \0 ;

250 A Debreceni Egyetem programozói évkönyve 220 / 404 #pragma omp parallel for private(kulcs) for (int ii = 0 ; ii <= 9 ; ++ii) for (int ji = 0 ; ji <= 9 ; ++ji) for (int ki = 0 ; ki <= 9 ; ++ki) for (int li = 0 ; li <= 9 ; ++li) for (int mi = 0 ; mi <= 9 ; ++mi) for (int ni = 0 ; ni <= 9 ; ++ni) for (int oi = 0 ; oi <= 9 ; ++oi) for (int pi = 0 ; pi <= 9 ; ++pi) kulcs[0] = ii; kulcs[1] = ji; kulcs[2] = ki; kulcs[3] = li; kulcs[4] = mi; kulcs[5] = ni; kulcs[6] = oi; kulcs[7] = pi; exor_tores (kulcs, KULCS_MERET, titkos, p - titkos); return 0; A programot így fordítottam: [../udprog-code/source/halado/exor]$ gcc exor.c -fopenmp -O3 -o exor -std=c99 Párhuzamosításra az openmp-t használtam, amit a for ciklusok előtti sor jól mutat. Így a törés a magok számával megegyező szálon fut. Ellenőrzés splint-el: [/udprog-code# splint source/halado/exor/exor.c Eredmény: [Splint Feb 2009 source/halado/exor/exor.c:6: Include file <unistd.h> matches the name of a POSIX library, but the POSIX library is not being used. Consider using +posixlib or +posixstrictlib to select the POSIX library, or -warnposix to suppress this message. Header name matches a POSIX header, but the POSIX library is not selected. (Use -warnposixheaders to inhibit warning) /usr/include/unistd.h:221:8: Parse Error: Non-function declaration: BEGIN_DECLS : int. (For help on parse errors, see splint -help parseerrors.) *** Cannot continue.

251 A Debreceni Egyetem programozói évkönyve 221 / Minix kernellel kapcsolatos programok Processzek üzenetmátrixa, PCB módosítással Készítette: Takác Ján. Dr. Bártfai Norbert jegyzete alapján és Andrew S. Tanenbaum-Albert S. Woodhull: Operációs rendszerek c. könyv 2.kiadása segítségével. A minix kernel módosítást a verzió számú MINIXen végeztem el ezért nem biztos hogy a kód kompatibilis más verziókkal. Első lépésként a PCB-t kell módosítani amely a proc.h állományban található. Itt a struct proc struktúrába be kell illeszteni a processus általküldött üzenetek számát tartalmazó tömböt. //proc.h állomány változtatása struct proc //minix kód int message_number_to[nr_tasks + NR_PROCS]; //Kuldott uzenetek szamat tartalmazo tomb //minix kód ; Következő lépésként módosítani kell a minix mini_send nevű üzenetküldő függvényét, amely a proc.c állományban található. Fontos megjegyezni, hogy itt be kell tartani a sorrendet és a kódunk csak a dst_otr = proc_addr(dst_p) pointer értékadás után következhet, mivel különben nem az elvárt helyre fog mutatni a pointer! //proc.c állomány változtatásai int mini_send( register struct proc *caller_ptr, /* who is trying to send a message? */ endpoint_t dst_e, /* to whom is message being sent? */ message *m_ptr, /* pointer to message buffer */ const int flags ) /* Send a message from caller_ptr to dst. If dst is blocked waiting * for this message, copy the message to it and unblock dst. If dst is * not waiting at all, or is waiting for another source, queue caller_ptr. */ register struct proc *dst_ptr; register struct proc **xpp; int dst_p; dst_p = _ENDPOINT_P(dst_e); dst_ptr = proc_addr(dst_p); caller_ptr->message_number_to[dst_ptr->p_nr+nr_tasks]++;//uzenet kuldesnel hozza ad egyet - a PCB-ben levo tomb megfelelo elemehez Ezután meg kell írnunk a függvényt mely kiírja az üzenet mátrixot ezt a függvényt pedig a dmp_kernel.c állomány végére szúrtam be az is szerver kódjába. //dmp_kernel.c állomány változtatásai /*==========================================================================* * msg_num_matrix_dmp * *==========================================================================*/ void msg_num_matrix_dmp(void) //Uzenet matrix kovetkezo oldalanak kiirasa register struct proc *proc_t;//processzus tabla

252 A Debreceni Egyetem programozói évkönyve 222 / 404 /*Bejarashoz szukseges valtozok*/ int r, row =0, column= 0; /*Lapozashoz szukseges valtozok*/ int last_row, last_column; static int first_row=0,first_column=0; last_row=first_row; last_column=first_column; /*Friss processzus tabla lekerese*/ if ((r = sys_getproctab(proc))!= OK) printf("is","warning: couldn t get copy of process table",r); /*Kiiratas cime*/ printf("\nkuldott uzenetek szama J processtol I processnek\n"); printf("%9s ","J/I"); /*Uzeneteket kapo processzusok neveinek kiiratasa*/ for(proc_t =BEG_USER_ADDR+first_column; (proc_t<end_proc_addr)&&(column<7);++proc_t) ++last_column; if(isemptyp(proc_t)) continue; ++column; printf("%9s ",proc_t->p_name); printf("\n"); /*Matrix soronkenti kiiratas */ for(proc_t =BEG_USER_ADDR+first_row; (proc_t < END_PROC_ADDR)&&(row<22); proc_t++) /*Az uzenet kuldo processzus nevenek kiiratasa*/ last_row++; if(isemptyp(proc_t)) continue; row++; printf("%9s ",proc_t->p_name); int i; column=0; /*Az uzenetek szama J processzustol I processushoz*/ for(i=nr_tasks+first_column;(i<(nr_tasks + NR_PROCS))&&(column<7);i++) if(isemptyp(&proc[i])) continue; column++; printf("%9d ",proc_t->message_number_to[i]); printf("\n"); /*Lapozas eloszor fuggolegesen lapoz. Ha fuggolegesen vegig er akkor lapoz egyet. vizszintesen majd itt is vegig megy fuggolegesen. Ha eler a matrix legvegere kezdi elolrol.*/ if(row<22) first_row=0; first_column=column<7?0:last_column; else

253 A Debreceni Egyetem programozói évkönyve 223 / 404 first_row=last_row; Majd utolsó lépésként módosítani kell a dmp.c állományt hogy az F4 funkció billentyű lenyomásakor a msg_num_matrix_dmp függvényt futtassa. De ehhez szükséges az eredetileg F4-es billentyűhöz rendelt függvény megjegyzésbe helyezése, hogy ne legyen ütközés. //dmp.c állomány módosítása struct hook_entry int key; void (*function)(void); char *name; hooks[] = F1, proctab_dmp, "Kernel process table", F3, image_dmp, "System image", // F4, privileges_dmp, "Process privileges", F4, msg_num_matrix_dmp, "Message number matrix", //Matrix kiiras F4-es billenty - űhözkötése F5, monparams_dmp, "Boot monitor parameters", F6, irqtab_dmp, "IRQ hooks and policies", F7, kmessages_dmp, "Kernel messages", F8, vm_dmp, "VM status and process maps", F10, kenv_dmp, "Kernel parameters", SF1, mproc_dmp, "Process manager process table", SF2, sigaction_dmp, "Signals", SF3, fproc_dmp, "Filesystem process table", SF4, dtab_dmp, "Device/Driver mapping", SF5, mapping_dmp, "Print key mappings", SF6, rproc_dmp, "Reincarnation server process table", SF8, data_store_dmp, "Data store contents", SF9, procstack_dmp, "Processes with stack traces", ; //well played minix Ezek után a make -C /usr/src/releasetools hdboot && reboot shell paranccsal fordíthatjuk le a kernelt és sikeres fordításkor a rendszert is újraindítja. A forráskód a../source/halado/minixkernel/process_tabla_pcb/ mappában található aki szeretné kipróbálni a működését olvassa el az olvass_el.txt nevű fájl az egyszerű telepítéséhez Képfeldolgozási programjaid Az első Open CV-vel kapcsolatos programjaid Labda követése Készítette: Fábián Kristóf, Kolozsvári Dávid segítségével. A megoldás../source/halado/labda_kovetese_opencv/balltracking/balltracking.pro Qt projektben található. Ha ki szeretnétek próbálni saját videón, akkor a build mappába másoljátok a videót. A következő függvénnyel inicializálódik az ablak, amiben a videó fog lejátszódni, illetve maga a "player" is, amely egy megadott fájlnév alapján megnyitja a bizonyos videófájlt.

254 A Debreceni Egyetem programozói évkönyve 224 / 404 cv::videocapture VideoCamera::InitVideo(std::string const _Caption, std::pair < unsigned - int const, unsigned int const > _WindowSize, std::string const _FileName) mwindow.init(_caption, _WindowSize ); cv::videocapture VideoFromFile; VideoFromFile.open( _FileName ); if (!VideoFromFile.isOpened()) std::cout << "File not opened!" << "\n"; return -1; this->mvidsizes= VideoFromFile.get(CV_CAP_PROP_FRAME_WIDTH), VideoFromFile.get( - CV_CAP_PROP_FRAME_HEIGHT); this->mframecount = VideoFromFile.get(CV_CAP_PROP_FRAME_COUNT); this->mframecounter = 0; InitValues(); Infos(VideoFromFile); std::cout << "File Opened!"<< "\n"; return VideoFromFile; Itt hajtódik végre maga a keresés, képernyőre írások, illetve a video loop. int VideoCamera::VideoFromFileBallSearch(cv::VideoCapture _VideoLooper, std::string - _Caption, unsigned int _Debugnr, std::string _Color) do _VideoLooper.read(mVideoFromFileImage); if (!mvideofromfileimage.empty()) if (mframecounter!= (_VideoLooper.get(CV_CAP_PROP_FRAME_COUNT) -1)) mframecounter++; mfps.start(); switch(_debugnr) case 1: cv::cvtcolor(mvideofromfileimage, mhsvimage, cv::color_bgr2hsv); //CreateTrackbars(); // uncomment this and the next line for self - calibration //cv::inrange(mhsvimage, cv::scalar(mtrackbarvalues["h_values"][0], - mtrackbarvalues["s_values"][0], mtrackbarvalues["v_values"][0]), cv - ::Scalar(mTrackbarValues["H_values"][1],mTrackbarValues["S_values - "][1], mtrackbarvalues["v_values"][1]), mthresholdimage); cv::inrange(mhsvimage, mhsvvalues[_color][0], mhsvvalues[_color][1], - mthresholdimage); merodeelement = cv::getstructuringelement(cv::morph_rect, cv::size - (4,4)); mdilateelement = cv::getstructuringelement(cv::morph_rect, cv::size(8, - 8)); cv::erode(mthresholdimage, mthresholdimage, merodeelement); cv::dilate(mthresholdimage, mthresholdimage, mdilateelement); SearchForObject(mThresholdImage, mvideofromfileimage); ShowFrame(_Caption, mvideofromfileimage);

255 A Debreceni Egyetem programozói évkönyve 225 / 404 break; case 2: HoughDetector(mVideoFromFileImage); break; mfps.calculate(); WriteOnFrame(mVideoFromFileImage,mFps.WriteFPS(), 10, 15, r ); ShowFrame(_Caption, mvideofromfileimage); else mframecounter = 0; _VideoLooper.set(CV_CAP_PROP_POS_AVI_RATIO, 0); else std::cout << "Empty image! " <<"\n"; break; while (mframecounter == ( _VideoLooper.get(CV_CAP_PROP_FRAME_COUNT)-1)); return 0; Maga a "labda" követés a HoughDetector függvényben valósul meg. int VideoCamera::HoughDetector(cv::Mat &_CamImage) std::stringstream textonimage; cv::cvtcolor(_camimage, mfirstgrayimage, cv::color_bgr2gray); cv::gaussianblur(mfirstgrayimage, mfirstgrayimage, cv::size(5, 5), 3, 3); cv::houghcircles(mfirstgrayimage, mcircles, CV_HOUGH_GRADIENT, 1, 50, 180, 70, 15, ); if (!mcircles.size()) WriteOnFrame(_CamImage, "Object at: Not detected! ", 10, 70, r ); for (size_t i = 0; i< mcircles.size() ; i++) mcirclecenter = cv::point( cvround( mcircles[i][0]), cvround(mcircles[i][1]) ); mobjectpos[ x ] = mcircles[i][0]; mobjectpos[ y ] = mcircles[i][1]; mcircleradius = cvround( mcircles[i][2]); cv::circle(_camimage, mcirclecenter, mcircleradius + 4, cv::scalar(0, 0, 255), 2) - ; textonimage << "Object[" << i+1 << "] at: " <<mobjectpos[ x ] << ", " << - mobjectpos[ y ]; WriteOnFrame(_CamImage, textonimage.str(),10, i * 15+70, r ); return 0;

256 A Debreceni Egyetem programozói évkönyve 226 / 404 Extraként megírtam még két függvényt, az elsővel webkamerán keresztül tudok egy bizonyos (beállított, bekalibrált) színt keresni, követni. A _Debugnr paraméternek ha 1 - est adunk meg, akkor saját kezileg tudunk bármilyen színt kiszűrni és követni. Ha 2 - est adunk a _Debugnr paraméternek, akkor az előre beállított színek közül a _Color paramaméterrel adjuk meg a kívánt színt (egyelőre csak a kék színt kalibráltam be nagyjából) Ha 3 - ast adunk a _Debugnr paraméternek, és "none" -t a _Color paraméternek, akkor a webkamerán keresztül tudunk követni "labdákat". int VideoCamera::LiveStreamColorSearch(cv::VideoCapture _Camera, std::string _Caption -, std::string _Color, int _Debugnr) if (!_Camera.read(mVidCamFirstImage)) std::cout << "Cannot read a frame from video stream of camera: " << _Caption << " - \n"; return -1; _Camera.read(mVidCamFirstImage); WriteOnFrame(mVidCamFirstImage, _Caption, 5, 5, r ); mfps.start(); switch(_debugnr) case 1: cv::cvtcolor(mvidcamfirstimage, mhsvimage, cv::color_bgr2hsv); CreateTrackbars(); // calibrating cv::inrange(mhsvimage, cv::scalar(mtrackbarvalues["h_values"][0], - mtrackbarvalues["s_values"][0], mtrackbarvalues["v_values"][0]), cv::scalar( - mtrackbarvalues["h_values"][1],mtrackbarvalues["s_values"][1], - mtrackbarvalues["v_values"][1]), mthresholdimage); merodeelement = cv::getstructuringelement(cv::morph_rect, cv::size(4,4)); mdilateelement = cv::getstructuringelement(cv::morph_rect, cv::size(8, 8)); cv::erode(mthresholdimage, mthresholdimage, merodeelement); cv::dilate(mthresholdimage, mthresholdimage, mdilateelement); SearchForObject(mThresholdImage, mvidcamfirstimage); ShowFrame(_Caption, mvidcamfirstimage); break; case 2: if (_Color!= "none") cv::cvtcolor(mvidcamfirstimage, mhsvimage, cv::color_bgr2hsv); cv::inrange(mhsvimage, mhsvvalues[_color][0], mhsvvalues[_color][1], - mthresholdimage); merodeelement = cv::getstructuringelement(cv::morph_rect, cv::size(4,4)); mdilateelement = cv::getstructuringelement(cv::morph_rect, cv::size(8, 8)); cv::erode(mthresholdimage, mthresholdimage, merodeelement); cv::dilate(mthresholdimage, mthresholdimage, mdilateelement); SearchForObject(mThresholdImage, mvidcamfirstimage); mfps.calculate(); WriteOnFrame(mVidCamFirstImage,mFps.WriteFPS(), 10, 45, r ); ShowFrame(_Caption, mvidcamfirstimage); break; case 3: if (_Color == "none")

257 A Debreceni Egyetem programozói évkönyve 227 / 404 HoughDetector(mVidCamFirstImage); // circle detector mfps.calculate(); WriteOnFrame(mVidCamFirstImage, mfps.writefps(), 10, 45, g ); ShowFrame(_Caption, mvidcamfirstimage); break; default: break; return 0; Illetve egy másik függvényben mozgást tudunk követni. Két képet beolvasok egymás után, és különbségeket keresek, szűrök a képeken. int VideoCamera::LiveStreamMovementSearch(cv::VideoCapture _Camera, std::string - _Caption) if (!_Camera.read(mVidCamFirstImage)) std::cout << "Cannot read a frame from video stream of camera: " << _Caption << " - \n"; return -1; _Camera.read(mVidCamFirstImage); WriteOnFrame(mVidCamFirstImage, _Caption, 5, 0, r ); mfps.start(); _Camera.read(mVidCamSecondImage); WriteOnFrame(mVidCamSecondImage, _Caption, 5, 0, r ); cv::cvtcolor(mvidcamfirstimage, mfirstgrayimage, cv::color_bgr2gray); cv::cvtcolor(mvidcamsecondimage, msecondgrayimage, cv::color_bgr2gray); cv::absdiff(mfirstgrayimage, msecondgrayimage, mdifferenceofimages); cv::threshold(mdifferenceofimages, mthresholdimage, 25, 255, cv::thresh_binary); cv::blur(mthresholdimage, mthresholdimage, cv::size(10, 10)); cv::threshold(mdifferenceofimages, mthresholdimage, 25, 255, cv::thresh_binary); SearchForObject(mThresholdImage, mvidcamfirstimage); mfps.calculate(); WriteOnFrame(mVidCamFirstImage, mfps.writefps(), 10, 45, r ); ShowFrame(_Caption,mVidCamFirstImage); return 0;

258 A Debreceni Egyetem programozói évkönyve 228 / fejezet A Labor-mérés prograjaid A 2014/15 tanév őszi szemeszterének labor-mérései Bevezető laborok A védési program Java és C# átirata A megoldást../source/labor/prog2lab/binfajava/main.java../source/labor/prog2lab/binfajava/ Node.java../source/labor/prog2lab/BinfaJava/BinTree.java forrásállományokba helyeztem el. Fordítás: Main.java [../udprog-code/source/labor/prog2lab/binfajava]$ javac Main.java import java.io.*; class Main public static void main(string[] args) try if(args.length!= 2) System.err.println("Hibás argumentumszám"); System.exit(-1); FileReader inputstream = new FileReader(args[0]); int j; boolean incomment = false; char i; BinTree bt = new BinTree(); while((j = inputstream.read())!= -1) i = (char)j; if(i == > ) incomment = true; continue; if(i == \n )

259 A Debreceni Egyetem programozói évkönyve 229 / 404 incomment = false; continue; if(incomment) continue; if(i == N ) continue; for(int k = 0;k < 8; k++) if((i & 0x80) == 0x80) bt.write( 1 ); else bt.write( 0 ); i <<= 1; inputstream.close(); PrintWriter pw = new PrintWriter(new FileWriter(args[1])); bt.writeout(bt.getroot(), pw); pw.println("mélység: "+bt.getmelyseg()); pw.println("átlag: " + bt.getatlag()); pw.println("szórás: " + bt.getszoras()); pw.close(); catch(ioexception e) Node.java class Node private char value; private Node left; private Node right; public Node(char rhs) value = rhs; left = null; right = null; public char getnode() return value;

260 A Debreceni Egyetem programozói évkönyve 230 / 404 public void setleft(node rhs) left = rhs; public void setright(node rhs) right = rhs; public Node getleft() return left; public Node getright() return right; BinTree.java import java.io.*; class BinTree private final Node root; private Node current; private int treeheight; private int melyseg, maxmelyseg, atlagosszeg, atlagdb; private double atlag,szorasosszeg, szoras; public BinTree() root = new Node( / ); current = root; treeheight = -1; public Node getroot() return root; public void setcurrent(node rhs) current = rhs; public void write(char b) if(b == 0 ) if(current.getleft() == null) current.setleft(new Node( 0 )); setcurrent(root); else setcurrent(current.getleft()); if(b == 1 ) if(current.getright() == null) current.setright(new Node( 1 )); setcurrent(root);

261 A Debreceni Egyetem programozói évkönyve 231 / 404 else setcurrent(current.getright()); public void writeout(node n, PrintWriter pw) if(n!= null) ++treeheight; writeout(n.getleft(),pw); for(int i = 0; i < treeheight; i++) pw.print( - ); pw.println(n.getnode() + " (" + treeheight + ")"); writeout(n.getright(),pw); --treeheight; public int getmelyseg() melyseg = maxmelyseg = 0; rmelyseg(getroot()); return --maxmelyseg; private void rmelyseg(node rhs) if(rhs!= null) ++melyseg; if(melyseg > maxmelyseg) maxmelyseg = melyseg; rmelyseg(rhs.getleft()); rmelyseg(rhs.getright()); --melyseg; public double getatlag() atlagdb = atlagosszeg = melyseg = 0; ratlag(getroot()); atlag = (double)atlagosszeg/atlagdb; return atlag; private void ratlag(node rhs) if(rhs!= null) melyseg++; ratlag(rhs.getleft()); ratlag(rhs.getright());

262 A Debreceni Egyetem programozói évkönyve 232 / 404 melyseg--; if(rhs.getleft() == null && rhs.getright() == null) atlagdb ++; atlagosszeg += melyseg; public double getszoras() atlag = getatlag(); szorasosszeg = 0.0; atlagdb = melyseg = 0; rszoras(getroot()); if(atlagdb-1 > 0) szoras = Math.sqrt(szorasosszeg/(atlagdb-1)); else szoras = Math.sqrt(szorasosszeg); return szoras; private void rszoras(node rhs) if(rhs!= null) ++melyseg; rszoras(rhs.getleft()); rszoras(rhs.getright()); --melyseg; if(rhs.getleft() == null && rhs.getright() == null) atlagdb ++; szorasosszeg += Math.pow((melyseg-atlag), 2); A C# megoldást../source/labor/prog2lab/binfacs/pogram.cs forrásállományokba helyeztem el. Program.cs using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.IO; namespace LZWB class Node

263 A Debreceni Egyetem programozói évkönyve 233 / 404 private char value; private Node left; private Node right; public Node(char rhs) value = rhs; left = null; right = null; public char getnode() return value; public void setleft(node rhs) left = rhs; public void setright(node rhs) right = rhs; public Node getleft() return left; public Node getright() return right; class BinTree private Node root; private Node current; private int treeheight; private int melyseg, maxmelyseg, atlagosszeg, atlagdb; private double atlag,szorasosszeg, szoras; public BinTree() root = new Node( / ); current = root; treeheight = -1; public Node getroot() return root; public void setcurrent(node rhs) current = rhs; public void write(char b) if(b == 0 )

264 A Debreceni Egyetem programozói évkönyve 234 / 404 if(current.getleft() == null) current.setleft(new Node( 0 )); setcurrent(root); else setcurrent(current.getleft()); if(b == 1 ) if(current.getright() == null) current.setright(new Node( 1 )); setcurrent(root); else setcurrent(current.getright()); public void writeout(node n, StreamWriter pw) if(n!= null) ++treeheight; writeout(n.getleft(),pw); for(int i = 0; i < treeheight; i++) pw.write( - ); pw.writeline(n.getnode() + " (" + treeheight + ")"); writeout(n.getright(),pw); --treeheight; public int getmelyseg() melyseg = maxmelyseg = 0; rmelyseg(getroot()); return --maxmelyseg; private void rmelyseg(node rhs) if(rhs!= null) ++melyseg; if(melyseg > maxmelyseg) maxmelyseg = melyseg; rmelyseg(rhs.getleft()); rmelyseg(rhs.getright()); --melyseg; public double getatlag() atlagdb = atlagosszeg = melyseg = 0;

265 A Debreceni Egyetem programozói évkönyve 235 / 404 ratlag(getroot()); atlag = (double)atlagosszeg/atlagdb; return atlag; private void ratlag(node rhs) if(rhs!= null) melyseg++; ratlag(rhs.getleft()); ratlag(rhs.getright()); melyseg--; if(rhs.getleft() == null && rhs.getright() == null) atlagdb ++; atlagosszeg += melyseg; public double getszoras() atlag = getatlag(); szorasosszeg = 0.0; atlagdb = melyseg = 0; rszoras(getroot()); if(atlagdb-1 > 0) szoras = Math.Sqrt(szorasosszeg/(atlagdb-1)); else szoras = Math.Sqrt(szorasosszeg); return szoras; private void rszoras(node rhs) if(rhs!= null) ++melyseg; rszoras(rhs.getleft()); rszoras(rhs.getright()); --melyseg; if(rhs.getleft() == null && rhs.getright() == null) atlagdb ++; szorasosszeg += Math.Pow((melyseg-atlag), 2); class Program static void Main(string[] args) try

266 A Debreceni Egyetem programozói évkönyve 236 / 404 if (args.length!= 2) Console.WriteLine("aaaa"); Environment.Exit(-1); StreamReader inputstream = new StreamReader(args[0]); int j; Boolean incomment = false; char i; BinTree bt = new BinTree(); while ((j = inputstream.read())!= -1) i = (char)j; if (i == > ) incomment = true; continue; if (i == \n ) incomment = false; continue; if (incomment) continue; if (i == N ) continue; for (int k = 0; k < 8; k++) if ((i & 0x80) == 0x80) bt.write( 1 ); else bt.write( 0 ); i <<= 1; inputstream.close(); StreamWriter pw = File.CreateText(args[1]); bt.writeout(bt.getroot(), pw); pw.writeline("mélység: " + bt.getmelyseg()); pw.writeline("átlag: " + bt.getatlag()); pw.writeline("szórás: " + bt.getszoras()); pw.close(); catch (IOException e)

267 A Debreceni Egyetem programozói évkönyve 237 / Első védési program Python átirata Tudnivalók: A futtatáshoz Python 3.x szükséges. Bitmaszkolás helyett beépített stringkezelő eljárásokat használ. A kiírásnál az eredeti példa inorder bejárásával szemben ez az átirat preorder bejárást használ, így a gyökér csomópont a file elején lesz. A szórás, átlag stb. számításokat nem tartalmazza, hiszen azok a szemléltetés szempontjából irrelevánsak. Forrásfile-ok:../source/labor/prog2lab/PyBT/BT.py../source/labor/prog2lab/PyBT/main.py Készítette: Dalmadi Zoltán BT.py class Node: def init (self, x): self.value = x self.left = None self.right = None class BT: def init (self): self.root = Node( / ) self.currentnode = self.root self.treeheight = 0 def addnode(self, x): if x == 0 : if self.currentnode.left is not None: self.currentnode = self.currentnode.left else: self.currentnode.left = Node(x) self.currentnode = self.root elif x == 1 : if self.currentnode.right is not None: self.currentnode = self.currentnode.right else: self.currentnode.right = Node(x) self.currentnode = self.root def printallnodes(self, node, out): if node is None: return self.treeheight += 1 # for i in range(1, self.treeheight): i = 1 while i < self.treeheight: out.write("-") i += 1 out.write("%s(%d)\n" % (node.value, self.treeheight - 1))

268 A Debreceni Egyetem programozói évkönyve 238 / 404 self.printallnodes(node.left, out) self.printallnodes(node.right, out) self.treeheight -= 1 main.py #!/usr/bin/env python3 # encoding: utf8 import sys import BT def usage(): print("hasznalat: bemeneti_file kimeneti_file".format(sys.argv[0]), file=sys.stderr) def main(argv): if len(argv)!= 3: if len(argv) == 2: print("nincs kimeneti file!", file=sys.stderr) usage() sys.exit(-1) else: usage() sys.exit(-2) try: with open(argv[1]) as infile, open(argv[2], "w") as outfile: if not(infile.read()): print("bemeneti file ures!", file=sys.stderr) sys.exit(-3) infile.seek(0) bintree = BT.BT() for line in infile: if line[0] == > : continue for char in line: if char == N : continue if char == \n : continue # magic happens here ch = bin(ord(char))[2:].zfill(8) for bit in ch: if bit == 1 : bintree.addnode( 1 ) else: bintree.addnode( 0 ) bintree.printallnodes(bintree.root, outfile)

269 A Debreceni Egyetem programozói évkönyve 239 / 404 except FileNotFoundError: print( File "" nem talalhato!.format(argv[1]), file=sys.stderr) sys.exit(-4) if name == " main ": main(sys.argv) Első védési program sebességteszt eredménye Tudnivalók: Mindegyik program a humán genom 2. kromoszóma utolsó sorát használja bemenetként. Eredmény: ábra. A sebességteszt eredménye Készítette: Balkus Gergő Tutor: Fülöp Sándor A BBP-s sebességteszt elvégzése A megoldás a../source/labor/prog2lab/bbpbenchmark/pi_bbp_bench.c../source/labor/prog2lab/ bbpbenchmark/pibbpbench.cs../source/labor/prog2lab/bbpbenchmark/pibbpbench.java../source/ labor/prog2lab/bbpbenchmark/pibbpbench.py../source/labor/prog2lab/bbpbenchmark/futtatas források alapján készült. Megoldotta: Balkus Gergő A futtatas script a gmcs parancsot is használja, amihez a következő csomagok szükségesek: mono-xsp2, mono-xsp2-base Futtatás: [../udprog-code/source/labor/prog2lab/bbpbenchmark]$./futtatas PiBBPBench.py

270 A Debreceni Egyetem programozói évkönyve 240 / 404 #!/usr/bin/env python # encoding: utf-8 import sys, math, time def n16modk(n, k): r = float(1) t = 1 while t <= n: t *= 2 while True: if n >= t: r = (16*r) % k n -= t t /= 2 if t < 1: break return r def d16sj(d, j): d16sj = 0.0 for k in xrange(d+1): d16sj += float(n16modk(d - k, 8 * k + j) / float(8*k + j)) return d16sj - math.floor(d16sj) def main(): d16pi = 0.0 d16s1t = 0.0 d16s4t = 0.0 d16s5t = 0.0 d16s6t = 0.0 delta = time.clock() for d in xrange( , ): d16pi = 0.0 d16s1t = d16sj(d, 1) d16s4t = d16sj(d, 4) d16s5t = d16sj(d, 5) d16s6t = d16sj(d, 6) d16pi = 4.0 * d16s1t * d16s4t - d16s5t - d16s6t d16pi -= math.floor(d16pi) jegy = int(math.floor(16.0 * d16pi))

271 A Debreceni Egyetem programozói évkönyve 241 / 404 print jegy delta = time.clock() - delta print delta ######################################################################## if name == main : main() Java Performance Tuning A PrintStream Print metódusa megnövekedett futási időt eredményez, ha az autoflush-t, mint átadott paraméteret nem állítjuk false értékre. Forráskódból olvashatjuk: public void print(string s) if (s == null) s = "null"; write(s); private void write(string s) try synchronized (this) ensureopen(); textout.write(s); textout.flushbuffer(); charout.flushbuffer(); if (autoflush && (s.indexof( \n ) >= 0)) out.flush(); catch (InterruptedIOException x) Thread.currentThread().interrupt(); catch (IOException x) trouble = true; Ahol is az if-ben vizsgáljuk, hogy az autoflush true/false és hogy újsort kezdtünk-e, ha ezek teljesülnek, akkor a kimeneti csatornát bezárja és felszabadítja az erőforrásokat Alternatív Tabella A megoldás:../source/labor/alttabella/wiki2matrix.java../source/labor/prog2lab/alttabella/ AltTabella.java Wiki2Matrix.java

272 A Debreceni Egyetem programozói évkönyve 242 / 404 import static java.lang.system.out; public class Wiki2Matrix protected static void kiir(int[][] k) for (int[] is : k) out.println(); for (int i=0; i<is.length;i++) out.print(is[i] + ", "); protected static int[] kiir2(int[][] k) int[] oszlop=new int[k.length]; for (int i : oszlop) oszlop[i]=0; for (int[] is : k) out.println(); int o=0; for (int i=0; i<is.length;i++) out.print(is[i] + ", "); oszlop[i]+=is[i]; o+=is[i]; out.print(" " + o); out.println(); out.println(); out.println(); for (int sz=0; sz<oszlop.length;sz++) out.print(oszlop[sz] + ", "); return oszlop; protected static void kiir(int[][] k, int[] t) for (int i = 0; i < k.length; i++) out.print("\n"); for (int j = 0; j < k[i].length; j++) if (t[j]!= 0.0) System.out.print(k[i][j] * (1.0 / t[j]) + ", "); else System.out.print(k[i][j] + ", "); out.print(","); public static void main(string[] args)

273 A Debreceni Egyetem programozói évkönyve 243 / 404 int[][] tablazat= 0, 0, 0, 1, 0, 3, 2, 3, 3, 2, 0, 0, 0, 2, 2, 3, 0, 0, 1, 0, 1, 0, 3, 1, 1, 0, 0, 1, 2, 1, 3, 0 ; int [][] pontszerzes= new int [tablazat.length][tablazat.length]; for (int[] is : pontszerzes) for (int i=0; i<is.length;i++) is[i]=0; for (int i=0; i<pontszerzes.length;i++) for (int j=0; j<pontszerzes[i].length;j++) switch (tablazat[i][j]) case 0: break; case 1: pontszerzes[i][j]++; break; case 2: pontszerzes[i][j]++; pontszerzes[j][i]++; break; case 3: pontszerzes[j][i]++; break; default: out.println("that s all Folks!"); break; out.println("a x pontot szerez y tol matrix!"); kiir(pontszerzes); out.println("sor es oszloposszegekkel!"); int[] oszlop=kiir2(pontszerzes); out.println("\na \"link\" mαtrix"); kiir(pontszerzes,oszlop); AltTabella.java class Csapat implements Comparable<Csapat> private String nev = "Nincs"; private double ertek = 0 ;

274 A Debreceni Egyetem programozói évkönyve 244 / 404 public Csapat(String nev, double ertek) this.setnev(nev); this.setertek(ertek); public Csapat() // TODO Auto-generated constructor stub public int compareto(csapat a) if (this.getertek() < a.getertek()) return 1; else if (this.getertek() > a.getertek()) return -1; else return 0; protected String getnev() return nev; protected void setnev(string nev) this.nev = nev; protected double getertek() return ertek; protected void setertek(double ertek) this.ertek = public String tostring() StringBuilder sb = new StringBuilder(); sb.append(this.nev); sb.append("\t"); sb.append(this.ertek); return sb.tostring(); public class AltTabella public static void main(string[] args) double[][] Lnk = 0.0, , 0.0, , , 0.0, , 0.0, 0.0, , , , 0.0, , 0.0, 0.0, ; String[] eredetinev = "Videoton", "Ferencvαros", ; int[] eredetipont = 40, 9 ; String[] ujnev = "BFC "Videoton", "Zalaegerszegi TE" ;

275 A Debreceni Egyetem programozói évkönyve 245 / 404 ArrayList<Csapat> regi = new ArrayList<Csapat>(eredetinev.length); ArrayList<Csapat> uj = new ArrayList<Csapat>(ujnev.length); for (int i = 0; i < eredetinev.length; i++) regi.add(new Csapat(eredetinev[i],eredetipont[i])); double[] hv = new double[lnk.length]; double[] h = new double[lnk.length]; for (int i = 0; i < h.length; ++i) hv[i] = 1.0 / Lnk[i].length; h[i] = 0.0; double reginorma = 0.0, regiosszeg = 0.0; boolean amig = true; while (true) for (int i = 0; i < Lnk.length; i++) for (int j = 0; j < Lnk[i].length; j++) h[i] += Lnk[i][j] * hv[j]; double osszeg = 0.0; for (int i = 0; i < h.length; i++) osszeg += Math.pow(hv[i] - h[i], 2); out.println("iteracio..."); double norma = Math.sqrt(osszeg); out.println("norma = " + norma); if (norma < ) amig = false; out.println("+++"); double osszegell = 0.0; for (int i = 0; i < h.length; i++) osszegell += h[i]; out.println(h[i]); out.println("osszeg ell. = " + osszegell); out.println("++++"); double d = 0.87; osszeg = 0.0; for (int i = 0; i < h.length; ++i) hv[i] = d * h[i] + (1.0 - d) / Lnk.length; osszeg += hv[i];

276 A Debreceni Egyetem programozói évkönyve 246 / 404 h[i] = 0.0; out.println("osszeg =" + osszeg); if (osszeg == regiosszeg && norma == reginorma) amig = false; System.out.println("***"); for (int i = 0; i < h.length; i++) System.out.println(hv[i]); System.out.println("****"); for (int i = 0; i < ujnev.length; i++) uj.add(new Csapat(ujnev[i],hv[i])); Collections.sort(uj); reginorma = norma; regiosszeg = osszeg; if (!amig) break; Iterator<Csapat> Ir = regi.iterator(); Iterator<Csapat> Iuj = uj.iterator(); for (int i=0; Iuj.hasNext();i++) Csapat csapat = (Csapat) Iuj.next(); Csapat csapat2 = (Csapat) Ir.next(); out.print(i+1+" ");out.println(csapat); out.print(i+1+" ");out.println(csapat2); Alternatív Tabella C# A megoldás:../source/labor/alttabella/wiki2matrix.cs../source/labor/prog2lab/alttabella/ AltTabella.cs Wiki2Matrix.cs namespace APPPPP class Program public static void nyom(int[][] k) for (int i = 0; i < k.length; ++i) Console.WriteLine(); for (int j = 0; j < k[i].length; ++j) Console.Write(k[i][j] + ", ");

277 A Debreceni Egyetem programozói évkönyve 247 / 404 public static void nyom2(int[][] k) for (int i = 0; i < k.length; ++i) Console.WriteLine(); int o = 0; for (int j = 0; j < k[i].length; ++j) Console.Write(k[i][j] + ", "); o += k[i][j]; Console.Write(" " + o); Console.WriteLine(); Console.WriteLine(); for (int i = 0; i < k.length; ++i) int o = 0; for (int j = 0; j < k[i].length; ++j) o += k[j][i]; Console.Write(o + " "); public static void nyom3(int[][] k, int[] oszloposszeg) for (int i = 0; i < k.length; ++i) Console.WriteLine(); Console.Write(""); for (int j = 0; j < k[i].length; ++j) if (oszloposszeg[j]!= 0.0) Console.Write(k[i][j] * (1.0 / oszloposszeg[j]) + ", "); else Console.Write(k[i][j] + ", "); Console.Write(","); static void Main(string[] args) int[][] kereszt = new int[] 0, 0, 0, 1, 0, 3, 2, 3, 3, 2, 0, 0, 0, 2, 2, 3, new int[] 0, 0, 1, 0, 1, 0, 3, 1, 1, 0, 0, 1, 2, 1, 3, 0 ; int[][] pontotszerez = new int[] 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, new int[] 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,... new int[] 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ;

278 A Debreceni Egyetem programozói évkönyve 248 / 404 for (int i = 0; i < pontotszerez.length; ++i) for (int j = 0; j < pontotszerez[i].length; ++j) pontotszerez[i][j] = 0; for (int i = 0; i < pontotszerez.length; ++i) for (int j = 0; j < pontotszerez[i].length; ++j) if (kereszt[i][j] == 1) // zϕld ++pontotszerez[i][j]; else if (kereszt[i][j] == 2) // sαrga ++pontotszerez[i][j]; ++pontotszerez[j][i]; else if (kereszt[i][j] == 3) // piros ++pontotszerez[j][i]; else if (kereszt[i][j] == 0) // óres ; else Console.WriteLine("Luke, zavart ιrzek az erυben..."); Console.WriteLine("A x ontot-szerez y-tσl mαtrix"); nyom(pontotszerez); Console.WriteLine("\nSor ιs oszlop ϕsszegekkel"); nyom2(pontotszerez); int []oszloposszeg = new int[kereszt.length]; for (int i = 0; i < pontotszerez.length; ++i) int o = 0; for (int j = 0; j < pontotszerez[i].length; ++j) o += pontotszerez[j][i]; oszloposszeg[i] = o; Console.WriteLine("\nA \"link\" mαtrix"); nyom3(pontotszerez, oszloposszeg); AltTabella.cs

279 A Debreceni Egyetem programozói évkönyve 249 / 404 namespace Lolll class Csapat : IComparable<Csapat> protected String nev; protected double ertek; public Csapat(String nev, double ertek) this.nev = nev; this.ertek = ertek; public int CompareTo(Csapat csapat) if (this.ertek < csapat.ertek) return -1; else if (this.ertek > csapat.ertek) return 1; else return 0; class Program public static void rendezcsapatok(string[] s, double[] h, String[] e, int[] ep) Console.WriteLine("\nCsapatok rendezve:\n"); int csapatnevekmeret = h.length; Csapat[] csapatok = new Csapat[csapatNevekMeret]; for (int i = 0; i < csapatnevekmeret; i++) csapatok[i] = new Csapat(s[i], h[i]); List<Csapat> rendezettcsapatok = csapatok.tolist(); rendezettcsapatok.sort(); rendezettcsapatok.reverse(); csapatok=rendezettcsapatok.toarray(); for (int i = 0; i < csapatok.length; i++) Console.WriteLine(i+1+"\t"+csapatok[i].nev + "\t\t\t" + csapatok[i].ertek); Console.WriteLine(i+1 + "\t" + e[i] + "\t\t\t" + ep[i]); Console.WriteLine(" "); static void Main(string[] args) double[][] L = new double[] 0, , 0, , , 0, , 0, 0, , , , 0, , , 0,... new double[] , 0, , 0, , , 0, 0.1, 0.1, , , , , , 0, 0 ;

280 A Debreceni Egyetem programozói évkönyve 250 / 404 String[] csapatneve = "Videoton", "Ferencvαros", "Paks", ; int[] ep = 40, 34, ; String[] csapatnevl = "BFC Siσfok", "Budapest Honvιd", "Vasas", ; double[] hv = new double[l.length]; double[] h = new double[l.length]; for (int i = 0; i < hv.length; ++i) hv[i] = 1.0 / L.Length; h[i] = 0.0; double reginorma = 0.0, regiosszeg = 0.0; Boolean amig = true; while (amig) for (int i = 0; i < L.Length; i++) for (int j = 0; j < L[i].Length; j++) h[i] += L[i][j] * hv[j]; double osszeg = 0.0; for (int i = 0; i < h.length; ++i) osszeg += (hv[i] - h[i]) * (hv[i] - h[i]); double norma = Math.Sqrt(osszeg); if (norma < ) amig = false; Console.WriteLine("+++"); double osszegell = 0.0; for (int i = 0; i < h.length; ++i) osszegell += h[i]; Console.WriteLine(h[i]); Console.WriteLine("ϕsszeg ell. = " + osszegell); Console.WriteLine("+++");

281 A Debreceni Egyetem programozói évkönyve 251 / 404 double d = 0.87; osszeg = 0.0; for (int i = 0; i < h.length; ++i) hv[i] = d * h[i] + (1.0 - d) / L.Length; osszeg += hv[i]; h[i] = 0.0; Console.WriteLine("ϕsszeg = " + osszeg); if (osszeg == regiosszeg && norma == reginorma) amig = false; Console.WriteLine("***"); for (int i = 0; i < h.length; ++i) Console.WriteLine(hv[i]); Console.WriteLine("****"); rendezcsapatok(csapatnevl, hv, csapatneve, ep); reginorma = norma; regiosszeg = osszeg; Alternatív Tabella Python A megoldás:../source/labor/alttabella/wiki2matrix.py../source/labor/prog2lab/alttabella/ AltTabella.py Wiki2Matrix.py #!/usr/bin/env python # encoding: utf-8 import sys class Wiki2Matrix: def init (self): pass def kiir(self, k): for i in xrange(len(k)): print for j in xrange(len(k[i])): print ",".format(k[i][j]),

282 A Debreceni Egyetem programozói évkönyve 252 / 404 def kiir2(self, k): for i in xrange(len(k)): print o = 0 print print for j in xrange(len(k[i])): print",".format(k[i][j]), o += k[i][j] sys.stdout.write(" ".format(o)) for i in xrange(len(k)): o = 0 for j in xrange(len(k[i])): o += k[j][i] print o, def kiir3(self, k, oszloposszeg): for i in xrange(len(k)): print sys.stdout.write("") for j in xrange(len(k[i])): if oszloposszeg[j]!= 0: print ",".format(k[i][j] * (1.0/oszlopOsszeg[j])), else: print ",".format(k[i][j]), sys.stdout.write(",") def main(): kereszt = [ [0, 0, 0, 1, 0, 3, 2, 3, 3, 2, 0, 0, 0, 2, 2, 3], [3, 0, 2, 1, 3, 2, 0, 3, 3, 3, 0, 0, 0, 0, 0, 1], [1, 1, 0, 0, 3, 1, 3, 0, 0, 0, 3, 1, 1, 0, 2, 0], [0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 2, 1, 1], [3, 3, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0], [1, 0, 3, 1, 0, 0, 0, 1, 3, 2, 0, 0, 0, 1, 2, 3], [0, 2, 0, 0, 0, 1, 0, 1, 1, 0, 3, 0, 1, 3, 3, 1], [0, 0, 1, 1, 3, 0, 0, 0, 0, 1, 3, 1, 1, 1, 3, 0], [0, 0, 1, 2, 3, 0, 0, 1, 0, 0, 0, 2, 1, 1, 3, 1], [0, 1, 1, 2, 0, 0, 3, 1, 1, 0, 0, 0, 0, 1, 3, 3], [2, 3, 0, 2, 1, 1, 0, 0, 1, 2, 0, 1, 0, 0, 0, 2], [3, 3, 0, 0, 0, 3, 3, 0, 2, 1, 1, 0, 2, 0, 0, 0], [1, 2, 0, 1, 0, 2, 1, 0, 0, 1, 3, 1, 0, 0, 0, 2], [2, 1, 2, 0, 1, 2, 1, 0, 0, 0, 3, 1, 1, 0, 0, 0], [1, 3, 1, 0, 2, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 0, 1, 0, 3, 1, 1, 0, 0, 1, 2, 1, 3, 0] ] pontotszerez = [ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],

283 A Debreceni Egyetem programozói évkönyve 253 / 404 oszt = Wiki2Matrix() [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] ] for i in xrange(len(pontotszerez)): for j in xrange(len(pontotszerez[i])): if kereszt[i][j] == 1: pontotszerez[i][j] += 1 elif kereszt[i][j] == 2: pontotszerez[i][j] += 1 pontotszerez[j][i] += 1 elif kereszt[i][j] == 3: pontotszerez[j][i] += 1 elif kereszt[i][j] == 0: pass else: print "Itt valami baj van.." print "Az x-pontot-szerez-y-tól mátrix" oszt.kiir(pontotszerez) print "\nsor és oszlopösszegekkel" oszt.kiir2(pontotszerez) osszegszamlalo = [] for i in xrange(len(pontotszerez)): o = 0 for j in xrange(len(pontotszerez[i])): o += pontotszerez[j][i] osszegszamlalo.append(o) print A "link" mátrix oszt.kiir3(pontotszerez, osszegszamlalo) ############################################################################## if name == " main ": main() AltTabella.py #!/usr/bin/env python # encoding: utf-8

284 A Debreceni Egyetem programozói évkönyve 254 / 404 import sys, math def rendez(csapat): return csapat.ertek class Csapat: def init (self, nev,ertek): self.nev = nev self.ertek = ertek def rendezcsapatok(s, h, e, ep): print "Csapatok rendezve:" csapatnevekmeret = len(h) csapatok = [] for i in xrange(csapatnevekmeret): csapatok.append(csapat(s[i], h[i])) csapatok = sorted(csapatok, key=rendez, reverse=true) for i in xrange(len(csapatok)): ki = str(i+1) + "\t" + csapatok[i].nev + "\t\t\t" + str(csapatok[i].ertek) print ki ki = str(i+1) + "\t" + e[i] + "\t\t\t" + str(ep[i]) print ki print "="*30 def main(): L = [ [0, , 0, , , 0, , 0, 0, , , , 0, , , 0 ], [0, 0, , , , , , 0, 0, 0, , , ,0, , ], [ , , 0, 0, 0, , 0, 0, 0, 0.0, , , , , 0 ], [0, 0, , 0, , 0, , 0.1, 0.2, , , , 0, , , ], [0, , , 0, 0, , , 0.2, 0.1, , , , , 0, , 0 ], [ , , 0, , 0, 0, 0, 0.1, 0, , 0, , , , , 0 ], [ , , , 0, 0, , 0, 0.1, 0.1, , 0, , , 0, 0, ], [ , , , ,0, 0, 0, 0, 0, , 0, , , , 0, 0 ], [ , , , ,0, , 0, 0.1, 0, 0, 0, 0.125, , , 0, ], [ , , , , 0, -

285 A Debreceni Egyetem programozói évkönyve 255 / , 0, 0.1, 0.1, 0, , 0, 0, , - 0, 0 ], [ , 0, , , , , , 0.1, 0.1, , 0, , , , 0, ], [0, 0, 0, 0, 0, 0, 0, 0, 0.2, , , 0, , 0, 0, 0 ], [ , , 0, , 0, , , 0, 0, , 0, 0.125, 0, 0, - 0, ], [ , , , , , , , 0, 0, 0, 0, , , 0, 0, 0 ], [ , 0, , 0, , , , 0.1, 0.1, , , , , , 0, ], [ , 0, , 0, , , 0, 0.1, 0.1, , , , , , 0, 0 ] ] CsapatNevE = [ "Videoton", "Ferencváros", "Paks", "Debreceni VSC", "Zalaegerszegi TE", - "Kaposvári Rákóczi", "Lombard Pápa", "Kecskeméti TE", "Újpest", "Győri ETO", " - Budapest Honvéd", "MTK Budapest", "Vasas", "Szombathelyi Haladás", "BFC Siófok", " - Szolnoki MAV FC"] ep = [40, 34, 31, 31, 30, 29, 27, 24, 23, 23, 22, 22, 21, 20, 18, 9] CsapatNevL = ["BFC Siófok","Budapest Honvéd","Vasas","Debreceni VSC","Ferencváros","Gy - őri ETO","Kaposvári Rákóczi","Kecskeméti TE","Lombard Pápa","MTK Budapest","Paksi FC - ","Szolnoki MAV FC","Szombathelyi Haladás","Újpest","Videoton","Zalaegerszegi TE"] hv = [] h = [] for i in xrange(len(l)): hv.append(1.0 / len(l)) h.append(0.0) reginorma = 0.0 regiosszeg = 0.0 amig = True while amig: for i in xrange(len(l)): for j in xrange(len(l[i])): h[i] += L[i][j] * hv[j] osszeg = 0.0 for i in xrange(len(h)): osszeg += (hv[i] - h[i]) * (hv[i] - h[i]) print "Iteráció..." norma = math.sqrt(osszeg) print "norma =", norma if norma < : amig = False print "+++"

286 A Debreceni Egyetem programozói évkönyve 256 / 404 osszegell = 0.0 for i in xrange(len(h)): osszegell += h[i] print h[i] print "Összeg ell. =", osszegell print "+++" d = 0.87 osszeg = 0 for i in xrange(len(h)): hv[i] = d * h[i] + (1.0 - d) / len(l) osszeg += hv[i] h[i] = 0.0 print "Összeg =", osszeg if osszeg == regiosszeg and norma == reginorma: amig = False print "***" for i in xrange(len(h)): print hv[i] print "****" rendezcsapatok(csapatnevl, hv, CsapatNevE, ep) reginorma = norma regiosszeg = osszeg ############################################################################## if name == " main ": main() Kvíz megoldások: Kérdések: 17.Feladat: Mennyi a ciklomatikus komplexitása az alábbi függvénynek? Feladat: nevezz meg egy-egy osztályt (teljes csomagnévvel minősített formában) az alábbi Java kiadásokból! Illetve egy-egy interfészt (ugyancsak teljes csomagnévvel minősített formában)! Java SE: java.applet.applet; Java ME: jdk.dio.devicemanager; Android vagy lejos: lehos.robotics.color; Java SE interfész: java.applet.appletcontext; Java ME interfész: jdk.dio.transactional 19.Feladat: mit ír ki az alábbi csipet? alma, dió ; B: alma, körte, dió B: A:System.out.println("alma"); System.out.flush(); /*// System.out.println("körte"); System.out.flush(); */// System.out.println("dió"); System.out.flush(); System.out.println("1"); System.out.flush(); ///*/*/

287 A Debreceni Egyetem programozói évkönyve 257 / 404 System.out.println("1"); System.out.flush(); //*/*/ System.out.println("1"); System.out.flush(); 20.Feladat: magyarázd meg a következő ábrán vázolt helyzetet! A bal oldal az 1.5 előtti Java nyelvről szól, a jobb oldal pedig már az 1.5 utáni Java nyelvnek megfelelően készült. 21:Feladat: Java SE bájtkódot GNU/Linux alatt elkészítve (javac), a bájtkódot Windows alá átmásolva futni (java) fog? Természetesen, ez a bájtkód hordozhatósága. 22.Feladat: csak java.lang csomag alatti SE osztályokat tartalmazó Java program (bájtkód) önmagában futni fog a Javás (MIDP) mobilokon és a webszerverben (például Tomcat) is? 6) Természetesen, sőt még LEGO robotokon is a jejos JVM-el és az Android Javás Google mobilokon is! 23:Feladat: Lefordul az alábbi program? Ha igen, akkor mit ír ki? Nem fordul le, mert nincs goto a nyelvben. 24:Feladat: mi történik, ha egy osztályodban, ami kiterjeszti a javax.microedition.midlet.midlet osztályt, nem definiálod felül annak destroyapp metódusát. 2) Fordítási hiba, mert az absztakt módszereket, akár ha üres testtel is, de felül kell definiálni a leszármazottakban. 25:Feladat: Hány almát ír ki a következő program? Négyet String s1="alma"; String s2="al"; String s3="ma"; String s4="null"; String s5="alma"; s3=s2+s3; System.out.println(s1); System.out.println(s3); if (s1==s3) System.out.println(s1); if (s1.equals(s3)) System.out.println(s1); if ("alma".equals(s3)) System.out.println(s1); if (s5.equals(s4)) System.out.println(s1); 26:Mi történik, ha az alábbi kódcsipetet egy a hosztnev= localhost hosztnévvel fordítod, futtatod, és a géped futtat webszervert? Lefordul, futtatva az banan sztringet írja ki. public static void main(string[] args) String hosztnev=""; try java.net.socket s = new java.net.socket(hosztnev,80); System.out.println("alma"); s.close(); catch (java.net.unknownhostexception e) System.out.println("korte"); catch (java.io.ioexception e2) System.out.println("banan");

288 A Debreceni Egyetem programozói évkönyve 258 / Feladat:Feladat: GPL? Kezdődhet-e így az OpenJDK-beli java.util.random osztály forráskódja? 4) Igen, GNU GPL, méghozzá v2. 28: milyen mintázattal kezdődnek a Java bájtkódok? Feladat: A: Vidi 50, Etó 51, Fradi 55, Loki 60; B: Vidi 50, Etó 51, Fradi 55, Loki Feladat: 3. Az 1.6 óta a SwingWorker része a standard Java API-nak, de az osztály megváltozott: construct() és finished() YANonymous

289 A Debreceni Egyetem programozói évkönyve 259 / PeldaServlet GlassFish Sparse Table vs. StlMap Sparse Table vs. VectorBasedSparseMap Hibásan implementált RSA törés A megoldást../source/labor/prog2lab/rsatores/rsatores.java../source/labor/prog2lab/rsatores/ KulcsPar.java forrásállományokba helyeztem el. A program futtatásához szükség van a kódolt szövegre, továbbá egy angol.txt nevü fájlra, amelyben soronként a gyakorisági abc van.

290 A Debreceni Egyetem programozói évkönyve 260 / 404 import java.io.*; class RsaTores public static void main(string[] args) try BufferedReader inputstream = new BufferedReader(new FileReader("RSAPelda.java. - out.blog.txt")); int lines = 0; String line[] = new String[10000]; while((line[lines] = inputstream.readline())!= null) lines++; inputstream.close(); KulcsPar kp[] = new KulcsPar[100]; boolean volt = false; kp[0] = new KulcsPar(line[0]); int db = 1; for(int i = 1; i < lines; i++) volt = false; for(int j = 0; j < db; j++) if(kp[j].getvalue().equals(line[i])) kp[j].incfreq(); volt = true; break; if(volt == false) kp[db] = new KulcsPar(line[i]); db++; for(int i = 0; i < db; i++) for(int j = i + 1; j < db; j++) if(kp[i].getfreq() < kp[j].getfreq() ) KulcsPar temp = kp[i]; kp[i] = kp[j]; kp[j] = temp; FileReader f = new FileReader("angol.txt"); char[] key = new char[60]; int kdb=0; int k; while((k = f.read())!= -1) if((char)k!= \n ) key[kdb] = (char)k; //System.out.println(key[kdb]);

291 A Debreceni Egyetem programozói évkönyve 261 / 404 kdb++; f.close(); for(int i = 0; i < kdb; i++) kp[i].setkey(key[i]); for(int i = 0; i < lines; i++) for(int j = 0; j < db; j++) if(line[i].equals(kp[j].getvalue())) System.out.print(kp[j].getKey()); catch(ioexception e) class KulcsPar private String values; private char key = _ ; private int freq = 0; public KulcsPar(String str, char k) this.values = str; this.key = k; public KulcsPar(String str) this.values = str; public void setvalue(string str) this.values = str; public void setkey(char k) this.key = k; public String getvalue() return this.values; public char getkey() return this.key; public void incfreq() freq += 1; public int getfreq()

292 A Debreceni Egyetem programozói évkönyve 262 / 404 return freq;

293 A Debreceni Egyetem programozói évkönyve 263 / fejezet Egyéb feladatok Operációs rendszerekkel kapcsolatos alapvető feladatok A GNU/Linux kernellel kapcsolatos feladatok Kernelfordítás Telepítéssel és virtualizációval kapcsolatos feladatok Dual-boot MINIX virtualizálás A feladat kidolgozását Kis Dávid készítette. MINIX3-at telepítettem, VitualBox-ban. Egész egyszerűen megoldható, és a célunknak tökéletesen megfelel. A "VM Lens" nevű programmal oldottam meg, linkeltem is: ábra. A virtuális MINIX nevének megadás (vm1.png). Itt OS típusként láthatóan nem az elegáns Other/Other opciókat adtam meg, mert azokkal értelmezhetetlen hibák jöttek például a kernel fordításkor, viszont az ábra mutatta Linux választással ezek elmaradtak.

294 A Debreceni Egyetem programozói évkönyve 264 / 404 Az említett OS Type elfogadása után a felkínált alapértelmezéseket elfogadva néhány kattintás után indíthatjuk is a MINIX virtuális rendszerünket ábra. Virtuális MINIX indítása (vm2.png). Az első indításkor kell megadni, hogy honnan akarunk telepíteni. Nincs más dolgunk, mint kitallózni a lementett és kicsomagolt MINIX képfájlt. Az alább linkelt esetben: minix_r d.iso. Innen tölthető le: Miután csatoltuk a iso-t, néhány lépés után válasszuk a Regular MINIX 3-at! ábra. A rendszer betöltése lemezről (vm3.png). Kövessük a megjelenő instrukciókat: root felhasználói névvel belépve, majd a setup parancsot kiadva indul a telepítés. # minix log in: root...

295 A Debreceni Egyetem programozói évkönyve 265 / 404 # setup Néhány Enter gomb-alapértelmezés elfogadása ( kulcscsomó az enterre ) után lecsatolva a Devices/CD/DVD Device menüpont alatt a bemountolt telepítő lemezt máris a virtuális gép winchesteréről fogad minket a friss virtuális MINIX rendszerünk boot menedzsere. Röpke 9 év után végre megjelent egy új, lényegesen továbbfejlesztett MINIX 3 verzió, amely félelmetesen sokat tud az elődjéhez képest, ugyanakkor mindezt igen kis méretben. Aktuális továbbfejlesztések: Nagyobb POSIX kompatibilitás, Teljes többfelhasználós rendszer (korábban egyfelhasználós volt), TCP/IP hálózatok támogatása (korábban csak pár egyedi MINIX-klón tudta ezt), C fordítók (pl.: gcc), Több mint 300 program mellékelve. 4 GB memória támogatás, A rendszer forráskódja (C-ben) OpenSolaris virtualizálás BSD virtualizálás Az információs-távolsággal kapcsolatos feladatok Az alábbi feladatok kizárják egymást Genomok összehasonlítása A feladat megoldását Deregi Diána készítette el. A megoldáshoz a poszt útmutatásait követtem. A feladatban 16 élőlény adatait használtam fel. A feladat megoldása:../source/egyeb/informacios_tavolsag/genom/hexajegyek.c illetve../source/ egyeb/informacios_tavolsag/genom/8_2_1_genom.png A program a TCAG betűkből álló bemenetet alakítja át hexadecimális számokká úgy, hogy egyszerre két betűt vizsgál meg. Minden páratlan bemenetű betűnek eltárolja az értékét (0-3), majd hozzáveszi az őt követő páros bemenetű betű értékét (0-3), majd ezt a két számot átalakítja egy 0-15 közé eső számmá, amit kiír, mint eredményt. Miután készítettünk pár mintát a programmal az élőlények adataiból és telepítettük a CompLearn csomagot, elkészíthetjük a fát. Mivel a bemenet túl nagy ahhoz, hogy kényelmesen dolgozzunk vele otthoni számítógépen, ezért egy számlalóval csökkentettem a beolvasott betűk számát. #include <stdio.h> #include <unistd.h> int main (void) char hexa_jegyek[] = A, B, C, D, E, F ; int paratlan = 0, elso=0, masodik=0, i = 0, szamlalo=0;

296 A Debreceni Egyetem programozói évkönyve 266 / 404 while(((i=getchar())!= EOF) && (szamlalo<1000)) switch(i) case T : masodik = 0; break; case C : masodik = 1; break; case A : masodik = 2; break; case G : masodik = 3; break; if(paratlan) int jegy = 4*elso + masodik; if(jegy<10) printf("%d", jegy); else printf("%c", hexa_jegyek[jegy-10]); paratlan =!paratlan; elso = masodik; szamlalo++;

297 A Debreceni Egyetem programozói évkönyve 267 / ábra. Genomok összehasonlítása SZT tisztek gráfja Design-al kapcsolatos feladatok Az UDProg évkönyv logója Egy példa megoldást a../source/logo/proud.jpg képfájlban helyeztem el. A logót GIMP 2.6 segítségével hoztam létre, saját kezűleg. A font Sans mindkét esetben.

298 A Debreceni Egyetem programozói évkönyve 268 / Az UDProg logoterv A logótervek ezeken a linkeken érhetőek el.../source/logo/logo1.png../source/logo/logo2.png.. /source/logo/logo3.png../source/logo/logo4.png../source/logo/logo5.png A terveket jogtiszta Photoshop CS6 segítségével készítettem el. Betűkészletként Arial Font Family-t és ASH betűtípust használtam Az UDProg logóterv A logóterv ezen a linken érhetőek el.../source/logo/kesz.png A tervet Apró Anikó készítette el Inkscape 0.48 program segítségével. Betűkészletként Comic Sansat használt a P betű az egyedi betűtípusú Másoló konstruktor demó A demót Dalmadi Zoltán készítette. A program jól szemlélteti a másoló konstruktorok használata során esetleg felbukkanó problémákat, és a kiküszöbölésükre alkalmazható módszereket. Fordítás: make Fő forrásfájl source/halado/copy_constructor/copy_constructor.cpp #include <iostream> #include "DefaultCopy.h" #include "DisabledCopy.h" #include "DeepCopy.h" int main() int array[] = 1, 2, 3, 4, 5, 6 ; int arraysize = sizeof(array) / sizeof(*array); // Létrehozzuk a default copy constuctor-os osztályú objektumunkat DefaultCopy defaultc(5, 7.5, array, arraysize); // Kiírjuk tagjait std::cout << "defaultc tagjai:" << std::endl; defaultc.printmembers(); // Másolunk a default copy constructorral DefaultCopy defaultc_copy(defaultc); // Ugyanez a hatás elérhető az egyenlőségjel operátorral is // DefaultCopy defaultc_copy = defaultc; std::cout << "defaultc_copy tagjai" << std::endl; defaultc_copy.printmembers(); // A kimeneten jól látható, hogy az első két tag értékei megegyeznek, és // címeik különböznek. Azonban a tömb tagok címei is megegyeznek! Vagyis // ugyanarra a memóriaterületre mutatnak! Így ha megváltoztatjuk a tömbot, // és csak az egyik objektumot módosítjuk a megváltoztatott tömbbel, a többi

299 A Debreceni Egyetem programozói évkönyve 269 / 404 // objektum tömb tagjai is meg fognak változni! //*************************************************************************** // Módosítjuk az első objektumunkat std::cout << "defaultc modositasai utan:" << std::endl << std::endl; defaultc.setim(79); defaultc.setdm(3.1415); array[2] = 49; defaultc.setam(array); // Kiírjuk tagjait std::cout << "defaultc tagjai:" << std::endl; defaultc.printmembers(); // És kiírjuk a másolat tagjait is std::cout << "defaultc_copy tagjai" << std::endl; defaultc_copy.printmembers(); // A kimeneten látszik, hogy habár csak a defaultc-t változtattuk meg, a // defaultc_copy tömb tagja is megváltozott. A szakzsargon ezt // shallow copy-nak nevezi. //*************************************************************************** // Ezt a jelenségét kétféleképpen orvosolhatjuk: // 1. ha nem akarjuk, hogy az osztályunk másolható legyen, letiltjuk a // default copy constructort // // 2. implementálunk egy ún. deep copy constructort, ami egy új // memóriaterületre az argumentumban átadott tömb minden eleméről // másolatot készít. //*************************************************************************** // Kezdjük az 1. ellenszerrel. // Létrehozzuk a letiltott copy constructor-ral rendelkező osztályú // objektumunkat. DisabledCopy disabledc(8, 2.71, array, arraysize); // Kiírjuk tagjait std::cout << "disabledc tagjai" << std::endl; disabledc.printmembers(); // Minden oké eddig. Most megpróbálunk másolni // Ha az alábbi két sor egyikét kikommenteljük, panaszkodni fog a fordító, // hogy a másoló konstuktor privát. Így effektíve nem lehet másolni ezt az // osztályt. // DisabledCopy disabledc_copy(disabledc); // DisabledCopy disabledc_copy = disabledc; //*************************************************************************** // 2. ellenszer // Létrehozzuk a deep copy-val felvértezett copy constructor-os osztályú // objektumunkat. DeepCopy deepc(2, 23.76, array, arraysize); // Kiírjuk tagjait std::cout << "deepc tagjai" << std::endl;

300 A Debreceni Egyetem programozói évkönyve 270 / 404 deepc.printmembers(); // Most pedig másoljuk! DeepCopy deepc_copy(deepc); // A túlterhelt egyenlőségjel operátort is kipróbáljuk DeepCopy deepc_copyequal = deepc; // Kiírjuk a másolatok tagjait std::cout << "deepc_copy tagjai" << std::endl; deepc_copy.printmembers(); std::cout << "deepc_copyequal tagjai" << std::endl; deepc_copyequal.printmembers(); // A kimeneten látható, hogy itt a másolatok tömb tagjainak címei már nem // egyeznek meg a eredeti objektumunk tömb tagjának címével! // ellenőrizük le, hogy az eredeti objektumunk módosításával változnak-e a // másolatok! std::cout << "deepc modositasai utan:" << std::endl << std::endl; deepc.setim(7894); deepc.setdm( ); array[1] = 8; array[2] = 78; array[3] = 63; deepc.setam(array); // Kiírjuk az eredeti objektum tagjait std::cout << "deepc tagjai" << std::endl; deepc.printmembers(); // És a másolat tagjait is std::cout << "deepc_copy tagjai" << std::endl; deepc_copy.printmembers(); std::cout << "deepc_copyequal tagjai" << std::endl; deepc_copyequal.printmembers(); // A kimeneten látjuk, hogy valóban nem változtak meg az eredeti objektum // módosításával a másolt objektumok. return 0; Alapértelmezett másoló konstruktoros osztály Osztály-definíció source/halado/copy_constructor/include/defaultcopy.h #ifndef DEFAULTCOPY_H #define DEFAULTCOPY_H class DefaultCopy public: DefaultCopy(); DefaultCopy(int, double, int*, int); // alapértelmezett konstruktor // inicializáló konstruktor

301 A Debreceni Egyetem programozói évkönyve 271 / 404 ~DefaultCopy(); int getim(); int* getimaddress(); double getdm(); double* getdmaddress(); int* getam(); void setim(int); void setdm(double); void setam(int*); void printmembers(); void printarray(int*, int); void printdoubleline(); private: int integermember; double doublemember; int *arraymember; int arraymembersize; ; // destruktor // getter az int taghoz // getter az int tag címéhez // getter a double taghoz // getter a double tag címéhez // getter a tömbhoz // setter az int taghoz // setter a double taghoz // setter a tömbhöz // tag kiíró metódus // tomb kiíró metódus // dupla vízszintes vonal metódus // int tag // double tag // int tömb tag // tömb tag mérete #endif Implementáció source/halado/copy_constructor/src/defaultcopy.cpp #include <iostream> #include "DefaultCopy.h" // default constructor DefaultCopy::DefaultCopy() // inicializáló constructor DefaultCopy::DefaultCopy(int im, double dm, int *am, int ams) integermember = im; doublemember = dm; arraymember = am; arraymembersize = ams; // destructor DefaultCopy::~DefaultCopy() // getter-ek inline int DefaultCopy::getIM() return integermember; inline int* DefaultCopy::getIMAddress()

302 A Debreceni Egyetem programozói évkönyve 272 / 404 return &integermember; inline double DefaultCopy::getDM() return doublemember; inline double* DefaultCopy::getDMAddress() return &doublemember; inline int* DefaultCopy::getAM() return arraymember; // setter-ek void DefaultCopy::setIM(int im) integermember = im; void DefaultCopy::setDM(double dm) doublemember = dm; void DefaultCopy::setAM(int *am) arraymember = am; // Tag-kiíró metódus void DefaultCopy::printMembers() printdoubleline(); std::cout << "Integer tag: " << getim() << ". Cime: " << getimaddress() \ << std::endl; std::cout << "Double tag: " << getdm() << ". Cime: " << getdmaddress() \ << std::endl; std::cout << "Tomb tag: "; printarray(getam(), arraymembersize); std::cout << ". Cime: " << getam() << std::endl; printdoubleline(); std::cout << std::endl; // Tömb-kiíró metódus void DefaultCopy::printArray(int *arr, int size) std::cout << " "; for (int i = 0; i < size; i++) if (i == size - 1) std::cout << arr[i]; else std::cout << arr[i] << ", "; std::cout << " ";

303 A Debreceni Egyetem programozói évkönyve 273 / 404 // Dupla vízszintes vonal kiíró metódus void DefaultCopy::printDoubleLine() std::cout << "======================================================" \ << std::endl; Letiltott másoló konstruktoros osztály Osztály-definíció source/halado/copy_constructor/include/disabledcopy.h #ifndef DISABLEDCOPY_H #define DISABLEDCOPY_H class DisabledCopy public: DisabledCopy(); DisabledCopy(int, double, int*, int); ~DisabledCopy(); int getim(); int* getimaddress(); double getdm(); double* getdmaddress(); int* getam(); void setim(int); void setdm(double); void setam(int*); void printmembers(); void printarray(int*, int); void printdoubleline(); // alapértelmezett konstruktor // inicializáló konstruktor // destruktor // getter az int taghoz // getter az int tag címéhez // getter a double taghoz // getter a double tag címéhez // getter a tömbhoz // setter az int taghoz // setter a double taghoz // setter a tömbhöz // tag kiíró metódus // tomb kiíró metódus // dupla vízszintes vonal // metódus private: int integermember; double doublemember; int *arraymember; int arraymembersize; DisabledCopy(const DisabledCopy&); // int tag // double tag // int tömb tag // tömb tag mérete // itt tiltjuk le a copy // constructort DisabledCopy& operator= (const DisabledCopy&); // és a = operátort is ; #endif Implementáció source/halado/copy_constructor/src/disabledcopy.cpp #include <iostream> #include "DisabledCopy.h"

304 A Debreceni Egyetem programozói évkönyve 274 / 404 // default constructor DisabledCopy::DisabledCopy() // inicializáló constructor DisabledCopy::DisabledCopy(int im, double dm, int *am, int ams) integermember = im; doublemember = dm; arraymember = am; arraymembersize = ams; // destructor DisabledCopy::~DisabledCopy() // getter-ek inline int DisabledCopy::getIM() return integermember; inline int* DisabledCopy::getIMAddress() return &integermember; inline double DisabledCopy::getDM() return doublemember; inline double* DisabledCopy::getDMAddress() return &doublemember; inline int* DisabledCopy::getAM() return arraymember; // setter-ek void DisabledCopy::setIM(int im) integermember = im; void DisabledCopy::setDM(double dm) doublemember = dm; void DisabledCopy::setAM(int *am) arraymember = am;

305 A Debreceni Egyetem programozói évkönyve 275 / 404 // Tag-kiíró metódus void DisabledCopy::printMembers() printdoubleline(); std::cout << "Integer tag: " << getim() << ". Cime: " << getimaddress() \ << std::endl; std::cout << "Double tag: " << getdm() << ". Cime: " << getdmaddress() \ << std::endl; std::cout << "Tomb tag: "; printarray(getam(), arraymembersize); std::cout << ". Cime: " << getam() << std::endl; printdoubleline(); std::cout << std::endl; // Tömb-kiíró metódus void DisabledCopy::printArray(int *arr, int size) std::cout << " "; for (int i = 0; i < size; i++) if (i == size - 1) std::cout << arr[i]; else std::cout << arr[i] << ", "; std::cout << " "; // Dupla vízszintes vonal kiíró metódus void DisabledCopy::printDoubleLine() std::cout << "======================================================" \ << std::endl; "Deep copy" konstruktoros osztály Osztály-definíció source/halado/copy_constructor/include/deepcopy.h #ifndef DEEPCOPY_H #define DEEPCOPY_H class DeepCopy public: DeepCopy(); DeepCopy(int, double, int*, int); DeepCopy(const DeepCopy&); // alapértelmezett konstruktor // inicializáló konstruktor // copy konstruktor, ahol a deep copy // lesz implementálva DeepCopy& operator= (const DeepCopy&); // = operátort is túlterheljük ~DeepCopy(); // destruktor int getim(); int* getimaddress(); double getdm(); double* getdmaddress(); int* getam(); // getter az int taghoz // getter az int tag címehez // getter a double taghoz // getter a double tag címehez // getter a tömbhöz

306 A Debreceni Egyetem programozói évkönyve 276 / 404 void setim(int); void setdm(double); void setam(int*); void printmembers(); void printarray(int*, int); void printdoubleline(); private: int integermember; double doublemember; int *arraymember; int arraymembersize; ; // setter az int taghoz // setter a double taghoz // setter a tömbhöz // tag kiíró metódus // tömb kiíró metódus // dupla vízszintes vonal metódus // int tag // double tag // int tömb tag // tömb tag mérete #endif Implementáció source/halado/copy_constructor/src/deepcopy.cpp #include <iostream> #include "DeepCopy.h" // default constructor DeepCopy::DeepCopy() // inicializáló constructor DeepCopy::DeepCopy(int im, double dm, int *am, int ams) integermember = im; doublemember = dm; arraymember = am; arraymembersize = ams; // destructor DeepCopy::~DeepCopy() // Deep copy constructor implementáció DeepCopy::DeepCopy(const DeepCopy& copied) // A nem problémás tagokat simán átmásoljuk integermember = copied.integermember; doublemember = copied.doublemember; arraymembersize = copied.arraymembersize; // memóriaterület lefoglalása az új tömbnek arraymember = new int[arraymembersize]; // majd egy egyszerű for loop-pal átmásoljuk az elemeket for (int i = 0; i < arraymembersize; i++)

307 A Debreceni Egyetem programozói évkönyve 277 / 404 arraymember[i] = copied.arraymember[i]; // Egyenlőségjel operátor túlterhelése DeepCopy& DeepCopy::operator= (const DeepCopy& copied) // ön-értékadás ellenőrzése if (this == &copied) return *this; // a tömb memóriaterületének felszabadítása delete[] arraymember; // A nem problémás tagokat simán átmásoljuk integermember = copied.integermember; doublemember = copied.doublemember; arraymembersize = copied.arraymembersize; // memóriaterület lefoglalása az új tömbnek arraymember = new int[arraymembersize]; // majd egy egyszerű for loop-pal átmásoljuk az elemeket for (int i = 0; i < arraymembersize; i++) arraymember[i] = copied.arraymember[i]; // objektum visszaadása return *this; // getter-ek inline int DeepCopy::getIM() return integermember; inline int* DeepCopy::getIMAddress() return &integermember; inline double DeepCopy::getDM() return doublemember; inline double* DeepCopy::getDMAddress() return &doublemember; inline int* DeepCopy::getAM() return arraymember; // setter-ek void DeepCopy::setIM(int im)

308 A Debreceni Egyetem programozói évkönyve 278 / 404 integermember = im; void DeepCopy::setDM(double dm) doublemember = dm; void DeepCopy::setAM(int *am) arraymember = am; // Tag-kiíró metódus void DeepCopy::printMembers() printdoubleline(); std::cout << "Integer tag: " << getim() << ". Cime: " << getimaddress() \ << std::endl; std::cout << "Double tag: " << getdm() << ". Cime: " << getdmaddress() \ << std::endl; std::cout << "Tomb tag: "; printarray(getam(), arraymembersize); std::cout << ". Cime: " << getam() << std::endl; printdoubleline(); std::cout << std::endl; // Tömb-kiíró metódus void DeepCopy::printArray(int *arr, int size) std::cout << " "; for (int i = 0; i < size; i++) if (i == size - 1) std::cout << arr[i]; else std::cout << arr[i] << ", "; std::cout << " "; // Dupla vízszintes vonal kiíró metódus void DeepCopy::printDoubleLine() std::cout << "======================================================" \ << std::endl;

309 A Debreceni Egyetem programozói évkönyve 279 / fejezet Tankönyvi feladatok kidolgozása A Stroustrup könyv példái X.2[1] feladat A megoldást../source/tankonyvi/stroustrup/x.2.1 fájlba helyeztem el. Mit jelent a (*2.5) egy feladat szövege előtt? A válasz: A (*2.5) jelzés egy feladat leírása előtt, az aktuális feladat nehézségét jelzi. A nehézség hatványozódik, tehát ha egy (*1)-gyel megjelölt feladat 10 percig tart, akkor egy (*2)-es eltarthat akár egy óráig is, míg egy (*3)-as akár egy napba is beletelhet X.2[4] feladat A megoldást../source/tankonyvi/stroustrup/x.2.4 fájlba helyeztem el. A kérdés: Mik a legfőbb programozási stílusok C++ban? A válasz: c-stílusú programozás: a C++ tulajdonképpen egy jobb C, ami a C sajátosságait magában hordja de fejlettebb annál. adat absztrakció: olyan típusokat hozhatunk létre amilyenre éppen szükségünk van. objektum-orientált programozás: osztály hierarchiák használata. általános programozás: paramétereket adunk át a függvénynek, és így általánosítjuk a kódot X.2[7] feladat A megoldást../source/tankonyvi/stroustrup/x.2.7 fájlba helyeztem el. A kérdés: A C++ Standard Library főbb komponensei. A válasz: A C++ standard library osztályok és függvények gyűjteménye. Konténereket, függvényeket amelyek a konténereknél hasznosak, függvényobjektumokat, sztringeket és csatornákat(i/o is), nyelvi támogatást, és hétköznapi függvényeket pl az sqrt(square root) függvényt. Továbbá 18 header file-t a C90 C standard library-ből amelyek.h-ra végződnek. Azok a feature-ök amelyeket innen declarálunk az std névteret használják X.3[2] feladat A megoldást../source/tankonyvi/stroustrup/x.3.2 fájlba helyeztem el. A kérdés: Mit csinál a fordító? Mit csinál a linker? A válasz: Compiler: forráskódból (.c,.cpp,.java, stb... ) kiterjesztésű fájlokból tárgykódot állít elő. Linker: több tárgykódból állít elő egy futtatható fájlt.

310 A Debreceni Egyetem programozói évkönyve 280 / X.3[3] feladat A megoldást../source/tankonyvi/stroustrup/x.3.3.cpp forrásállományba helyeztem el. #include <iostream> using namespace std; int main() cout << "Hello, World!" << endl; return 0; Ebben a programban nem a programozás a lényeg, hanem, hogy hogyan fordítjuk és futtatjuk. A forrást fordítom, majd futtatom. [../udprog-code/source/tankonyvi/stroustrup]$ g++ X.3.3.cpp -o hello [../udprog-code/source/tankonyvi/stroustrup]$./hello X.3[4] feladat A megoldást../source/tankonyvi/stroustrup/x.3.4 fájlba helyeztem el. A kérdés: Sorolj fel 3 C++ fordítót. A válasz: Cygwin (GNU C++) IBM C++ Borland C X.3[5] feladat A megoldást../source/tankonyvi/stroustrup/x.3.5.cpp forrásállományba helyeztem el. #include <iostream> using namespace std; int main() bool a = true; char b = b ; int c = 3; double d = 3.14; string e = "Programozzunk."; cout << a << endl; cout << b << endl; cout << c << endl; cout << d << endl; cout << e << endl; return 0; A program kiírja a megadott típusú változókat. A forrást fordítom, majd futtatom.

311 A Debreceni Egyetem programozói évkönyve 281 / 404 [../udprog-code/source/tankonyvi/stroustrup]$ g++ X.3.5.cpp -o kiir [../udprog-code/source/tankonyvi/stroustrup]$./kiir X.3[6] feladat A megoldást../source/tankonyvi/stroustrup/x.3.6.cpp forrásállományba helyeztem el. #include <iostream> using namespace std; int main() bool a; char b; int c; double d; string e; cin >> a; cin >> b; cin >> c; cin >> d; cin >> e; return 0; A program beolvas a megadott típusú változókba. A forrást fordítom, majd futtatom. [../udprog-code/source/tankonyvi/stroustrup]$ g++ X.3.6.cpp -o beolvas [../udprog-code/source/tankonyvi/stroustrup]$./beolvas X.3[7] feladat A megoldást../source/tankonyvi/stroustrup/x.3.7 fájlba helyeztem el. A kérdés: Mire jó az invariáns? A válasz: Invariáns: Az objektum élettartama alatt végig fennálló tulajdonság, osztályokra jellemző leginkább, de struktúrákban is létezhet. Az állapotbiztosítót (invariánst) a konstruktorban (az osztály elején) adjuk meg. Arra jó továbbá hogy leszűkíti az alaphalmazt X.5[2] feladat A megoldást../source/tankonyvi/stroustrup/x.5.2 fájlba helyeztem el. A kérdés: Sorolj fel 5 Standard Library tárolót! A válasz: 5 Standard Library tároló: tömb, vector, map, list, stack

312 A Debreceni Egyetem programozói évkönyve 282 / X.5[3] feladat A megoldást../source/tankonyvi/stroustrup/x.5.3 fájlba helyeztem el. A kérdés: Sorolj fel 5 Standard Library algoritmust! A válasz: 5 Standard Library algoritmus count, sort, remove, lower_bound, make_heap, min, max, stb X.5[4] feladat A megoldást../source/tankonyvi/stroustrup/x.5.4 fájlba helyeztem el. A kérdés: Sorolj fel 5 Standard Library header file-t! A válasz: 5 Standard Library header file (de még az is lehet hogy 6) iostream vector algorithm fstream random string X.5[5] feladat A megoldást../source/tankonyvi/stroustrup/x.5.5.cpp forrásállományba helyeztem el. #include <iostream> using namespace std; int main() string name; int age; cin >> name; cin >> age; cout << "Name is: " << name << "\t" << "Age is: " << age << endl; return 0; A program bekér egy sztringet (name), egy egész számot (age), majd kiírja őket a képernyőre. A forrást fordítom, majd futtatom. [../udprog-code/source/tankonyvi/stroustrup]$ g++ X.5.5.cpp -o simple [../udprog-code/source/tankonyvi/stroustrup]$./simple X.5[6] feladat A megoldást../source/tankonyvi/stroustrup/x.5.6.cpp forrásállományba helyeztem el. #include <iostream> using namespace std; class person public: string name; int age;

313 A Debreceni Egyetem programozói évkönyve 283 / 404 ; friend ostream& operator<<(ostream& os, person& p); friend istream& operator>>(istream& is, person& p); istream& operator>> (istream& is, person& p) is >> p.name; is >> p.age; return is; ostream& operator<< (ostream& os, person& p) os << p.name << " " << p.age; return os; int main() const int N = 5; person p[n]; for( int i = 0; i < N; i++ ) cin >> p[i]; for( int i = 0; i < N; i++ ) cout << p[i] << endl; return 0; A program bekér sztring (name) és egész (age) párokat, majd kiírja őket a képernyőre a saját függvényeimmel. A forrást fordítom, majd futtatom. [../udprog-code/source/tankonyvi/stroustrup]$ g++ X.5.6.cpp -o class [../udprog-code/source/tankonyvi/stroustrup]$./class X.5[7] feladat A megoldást../source/tankonyvi/stroustrup/x.5.7.cpp forrásállományba helyeztem el. #include <iostream> #include <vector> #include <algorithm> using namespace std; int main() std::vector<int> vec; int Number1 = 5; int Number2 = 9; int Number3 = -1; int Number4 = 200;

314 A Debreceni Egyetem programozói évkönyve 284 / 404 int Number5 = 0; vec.push_back(number1); vec.push_back(number2); vec.push_back(number3); vec.push_back(number4); vec.push_back(number5); for ( int i = 0; i < vec.size(); i++) cout << vec[i] << "\n"; std::sort(vec.rbegin(), vec.rend()); cout << "\n"; for ( int i = 0; i < vec.size(); i++) cout << vec[i] << "\n"; return 0; A program egy vectort inicializál, kiírja a vektort, csökkenő sorrendbe rendezi azt, majd ismét kiírja a rendezett elemeket. A forrást fordítom, majd futtatom. [../udprog-code/source/tankonyvi/stroustrup]$ g++ X.5.7.cpp -o vector [../udprog-code/source/tankonyvi/stroustrup]$./vector X.5[7]b feladat A megoldást../source/tankonyvi/stroustrup/x.5.7b.cpp forrásállományba helyeztem el. #include <iostream> #include <vector> #include <algorithm> using namespace std; int main() std::vector<int> vec; int Number1 = 5; int Number2 = 9; int Number3 = -1; int Number4 = 200; int Number5 = 0; vec.push_back(number1); vec.push_back(number2); vec.push_back(number3); vec.push_back(number4); vec.push_back(number5); for ( int i = 0; i < vec.size(); i++) cout << vec[i] << "\n"; std::sort(vec.begin(), vec.end());

315 A Debreceni Egyetem programozói évkönyve 285 / 404 cout << "\n"; for ( int i = 0; i < vec.size(); i++) cout << vec[i] << "\n"; return 0; A program egy vectort inicializál, kiírja a vektort, növekvő sorrendbe rendezi azt, majd ismét kiírja a rendezett elemeket. A forrást fordítom, majd futtatom. [../udprog-code/source/tankonyvi/stroustrup]$ g++ X.5.7b.cpp -o vectorb [../udprog-code/source/tankonyvi/stroustrup]$./vectorb X.5[8] feladat A megoldást../source/tankonyvi/stroustrup/x.5.8.cpp forrásállományba helyeztem el. #include <iostream> #include <vector> #include <algorithm> using namespace std; int main() std::vector<string> vec; string Item1 = "Kanto"; string Item2 = "Plato"; string Item3 = "Aristotle"; string Item4 = "Kierkegard"; string Item5 = "Hume"; vec.push_back(item1); vec.push_back(item2); vec.push_back(item3); vec.push_back(item4); vec.push_back(item5); for ( int i = 0; i < vec.size(); i++) cout << vec[i] << "\n"; std::sort(vec.begin(), vec.end()); cout << "\n"; for ( int i = 0; i < vec.size(); i++) cout << vec[i] << "\n"; return 0; A program egy vectort inicializál a megadott szavakkal, kiírja a vektort, abc szerint növekvő sorrendbe rendezi azt, majd ismét kiírja a rendezett elemeket. A forrást fordítom, majd futtatom.

316 A Debreceni Egyetem programozói évkönyve 286 / 404 [../udprog-code/source/tankonyvi/stroustrup]$ g++ X.5.8.cpp -o vectors [../udprog-code/source/tankonyvi/stroustrup]$./vectors X.5[9] feladat A megoldást../source/tankonyvi/stroustrup/x.5.9.cpp forrásállományba helyeztem el. #include <iostream> #include <fstream> using namespace std; const int N = 500; int main() std::ofstream outfile; outfile.open("szamok.txt", ios::out); for( int i = 0; i < N; i++ ) outfile << i + 1 << " "; outfile.close(); return 0; A program beolvas a szamok.txt fájlba néhány száz (jelen esetben 500) egész számot. A forrást fordítom, majd futtatom. [../udprog-code/source/tankonyvi/stroustrup]$ g++ X.5.9.cpp -o write [../udprog-code/source/tankonyvi/stroustrup]$./write X.5[10] feladat A megoldást../source/tankonyvi/stroustrup/x.5.10.cpp forrásállományba helyeztem el. #include <iostream> #include <fstream> using namespace std; const int N = 500; int main() char data[n]; ifstream infile; infile.open("szamok.txt"); if( infile.is_open() ) while(!infile.eof() ) infile >> data;

317 A Debreceni Egyetem programozói évkönyve 287 / 404 cout << data << " "; cout << "\n"; infile.close(); return 0; A program megnyit egy fájlt olvasás módban, beolvas belőle, majd bezárja a fájlt. A forrást fordítom, majd futtatom. [../udprog-code/source/tankonyvi/stroustrup]$ g++ X.5.10.cpp -o read [../udprog-code/source/tankonyvi/stroustrup]$./read X.6[2] feladat A megoldást../source/tankonyvi/stroustrup/x.6.2.cpp forrásállományba helyeztem el. #include<iostream> #include<unistd.h> int main() for(int i=0;i<30;i++) std::cout<<"hello"<<std::endl; sleep(1); std::cout<<"world"<<std::endl; sleep(1); return 0; X.7[2] feladat A megoldást../source/tankonyvi/stroustrup/x.7.2.cpp forrásállományba helyeztem el. #include <iostream> #include <limits> using namespace std; int main() if( numeric_limits<char>::is_signed == true ) cout << "signed" << endl; else cout << "unsigned" << endl; return 0;

318 A Debreceni Egyetem programozói évkönyve 288 / 404 A program kiírja a signed szót, ha a char típus az adott implementáción előjeles, és az unsigned-et ha előjel nélküli. A forrást fordítom, majd futtatom. [../udprog-code/source/tankonyvi/stroustrup]$ g++ X.7.2.cpp -o char [../udprog-code/source/tankonyvi/stroustrup]$./char X.7[8] feladat A megoldást../source/tankonyvi/stroustrup/x.7.8.cpp forrásállományba helyeztem el. #include <iostream> #include <limits> // bool, char, short, int, long, long long, float, double, long double, - unsigned and unsigned long int main() std::cout << "A BOOL típus minimális értéke a rendszeren: " << std - ::numeric_limits<bool>::min() << "\n"; std::cout << "A BOOL típus maximális értéke a rendszeren: " << std - ::numeric_limits<bool>::max() << "\n"; std::cout << "A CHAR típus minimális értéke a rendszeren: " << std - ::numeric_limits<char>::min() << "\n"; std::cout << "A CHAR típus maximális értéke a rendszeren: " << std - ::numeric_limits<char>::max() << "\n"; std::cout << "A SHORT típus minimális értéke a rendszeren: " << std - ::numeric_limits<short>::min() << "\n"; std::cout << "A SHORT típus maximális értéke a rendszeren: " << std - ::numeric_limits<short>::max() << "\n"; std::cout << "Az INT típus minimális értéke a rendszeren: " << std - ::numeric_limits<int>::min() << "\n"; std::cout << "Az INT típus maximális értéke a rendszeren: " << std - ::numeric_limits<int>::max() << "\n"; std::cout << "A LONG típus minimális értéke a rendszeren: " << std - ::numeric_limits<long>::min() << "\n"; std::cout << "A LONG típus maximális értéke a rendszeren: " << std - ::numeric_limits<long>::max() << "\n"; std::cout << "A LONG LONG típus minimális értéke a rendszeren: " << - std::numeric_limits<long long>::min() << "\n"; std::cout << "A LONG LONG típus maximális értéke a rendszeren: " << - std::numeric_limits<long long>::max() << "\n"; std::cout << "A FLOAT típus minimális értéke a rendszeren: " << std - ::numeric_limits<float>::min() << "\n"; std::cout << "A FLOAT típus maximális értéke a rendszeren: " << std - ::numeric_limits<float>::max() << "\n"; std::cout << "A DOUBLE típus minimális értéke a rendszeren: " << - std::numeric_limits<double>::min() << "\n"; std::cout << "A DOUBLE típus maximális értéke a rendszeren: " << - std::numeric_limits<double>::max() << "\n"; std::cout << "A LONG DOUBLE típus minimális értéke a rendszeren: " - << std::numeric_limits<long double>::min() << "\n"; std::cout << "A LONG DOUBLE típus maximális értéke a rendszeren: " - << std::numeric_limits<long double>::max() << "\n"; std::cout << "Az UNSIGNED típus minimális értéke a rendszeren: " << - std::numeric_limits<unsigned>::min() << "\n"; std::cout << "Az UNSIGNED típus maximális értéke a rendszeren: " << - std::numeric_limits<unsigned>::max() << "\n";

319 A Debreceni Egyetem programozói évkönyve 289 / 404 std::cout << "Az UNSIGNED LONG típus minimális értéke a rendszeren: - " << std::numeric_limits<unsigned long>::min() << "\n"; std::cout << "Az UNSIGNED LONG típus maximális értéke a rendszeren: - " << std::numeric_limits<unsigned long>::max() << "\n"; return 0; A program kiírja a különböző típusok minimális és maximális méretét a rendszeren. A forrást fordítom, majd futtatom. [../udprog-code/source/tankonyvi/stroustrup]$ g++ X.7.8.cpp -o tkiir [../udprog-code/source/tankonyvi/stroustrup]$./tkiir X.7[9] feladat A megoldást../source/tankonyvi/stroustrup/x.7.9.cpp forrásállományba helyeztem el. #include <iostream> using namespace std; // bool, char, short, int, long, long long, float, double, long double, - unsigned, unsigned long int main() cout << "A bool mérete: " << sizeof(bool) << endl; cout << "A char mérete: " << sizeof(char) << endl; cout << "A short mérete: " << sizeof(short) << endl; cout << "Az int mérete: " << sizeof(int) << endl; cout << "A long mérete: " << sizeof(long) << endl; cout << "A long long mérete: " << sizeof(long long) << endl; cout << "A float mérete: " << sizeof(float) << endl; cout << "A double mérete: " << sizeof(double) << endl; cout << "A long double mérete: " << sizeof(long double) << endl; cout << "Az unsigned mérete: " << sizeof(unsigned) << endl; cout << "Az unsigned long mérete: " << sizeof(unsigned long) << - endl; return 0; A program kiírja a különböző típusok méretét byte-ban. A forrást fordítom, majd futtatom. [../udprog-code/source/tankonyvi/stroustrup]$ g++ X.7.9.cpp -o bkiir [../udprog-code/source/tankonyvi/stroustrup]$./bkiir X.7[13] feladat A megoldást../source/tankonyvi/stroustrup/x.7.3.cpp forrásállományba helyeztem el. #include <iostream>

320 A Debreceni Egyetem programozói évkönyve 290 / 404 int main() int a=4, b=5, c=9, d=17, e=12; while (1) std::cout<<a<<" "<<b<<" "<<c<<" "<<d<<" "<<e<<"\n"; A program változókat használ, nem tömböt vagy vektort X.8[4] feladat A megoldást../source/tankonyvi/stroustrup/x.8.4.cpp forrásállományba helyeztem el. #include <iostream> using namespace std; int main() char buf[100]; char* p1 = &buf[2]; char* p2 = &buf[83]; if( p1 == p2 ) cout << "Hiba: a két pointer ugyanoda mutat." << endl; return 1; else cout << "A két pointer közötti távolság: " << p2 - p1 << endl; return 0; A program kiírja a két pointer közötti távolságot, azonban ha ugyanoda mutat a két pointer akkor kilép hibaüzenettel. A forrást fordítom, majd futtatom. [../udprog-code/source/tankonyvi/stroustrup]$ g++ X.8.4.cpp -o pointertav [../udprog-code/source/tankonyvi/stroustrup]$./pointertav X.8[5] feladat A megoldást../source/tankonyvi/stroustrup/x.8.5.cpp forrásállományba helyeztem el. #include <iostream> using namespace std; int main() int buf[100];

321 A Debreceni Egyetem programozói évkönyve 291 / 404 int* p1 = &buf[43]; int* p2 = &buf[60]; if( p1 == p2 ) cout << "Hiba: a két pointer ugyanoda mutat." << endl; return 1; else cout << "A két pointer közötti távolság: " << p2 - p1 << endl; return 0; A program kiírja a két pointer közötti távolságot, azonban ha ugyanoda mutat a két pointer akkor kilép hibaüzenettel. A forrást fordítom, majd futtatom. [../udprog-code/source/tankonyvi/stroustrup]$ g++ X.8.4.cpp -o ipointertav [../udprog-code/source/tankonyvi/stroustrup]$./ipointertav X.8[7] feladat A megoldást../source/tankonyvi/stroustrup/x.8.7.cpp forrásállományba helyeztem el. #include <iostream> #include <string> using namespace std; void swap(int* a, int* b) *a ^= *b; *b ^= *a; *a ^= *b; void swap2(int& a, int& b) a ^= b; b ^= a; a ^= b; int main() int a = 3, b = 5; cout << "a = " << a << ", b = " << b << endl; swap(&a, &b); cout << "a = " << a << ", b = " << b << endl; swap2(a, b); cout << "a = " << a << ", b = " << b << endl; return 0;

322 A Debreceni Egyetem programozói évkönyve 292 / X.8[9] feladat A megoldást../source/tankonyvi/stroustrup/x.8.9.cpp forrásállományba helyeztem el. #include <iostream> void f( char ) ; void g( char& ) ; void h( const char& ) ; int main() char c; unsigned char uc; signed char sc; f( a ); f(49); f(3300); f(c); f(uc); f(sc); g( a ); g(49); g(3300); g(c); g(uc); g(sc); h( a ); h(49); h(3300); h(c); h(uc); h(sc); return 0; A program létrehoz 3 függvényt, az f fv. karaktert vár paraméterül, a g fv. karakter referenciát vár paraméterül, a h fv. konstans karakter referenciát vár paraméterül. Átadjuk nekik az előre megadott paramétereket, majd fordításkor láthatjuk, hogy melyek nem legálisak (kommentben a forráskódnál leírtam a magyarázatot), és a 2. kérdésre a válasz, hogy melyek hoznak létre átmeneti változót fordításkor, az f és a g, mivel nincs a várt paraméterük típusa előtt a const határozó. A forrást fordítom, majd futtatnám, de nem jut el odáig, hogy miért, azt a fordító hibaüzenete és a kommentjeim a fájlban leírják. [../udprog-code/source/tankonyvi/stroustrup]$ g++ X.8.9.cpp -o fuggvenyek [../udprog-code/source/tankonyvi/stroustrup]$./fuggvenyek X.8[11] feladat A megoldást../source/tankonyvi/stroustrup/x.8.11.cpp forrásállományba helyeztem el. #include <iostream> #include <string> #include <algorithm>

323 A Debreceni Egyetem programozói évkönyve 293 / 404 #define N 100 int main() std::string szo[n]; std::string tomb[n]; int szoszamlalo = 0; for( ; ; ) std::cout << "Írj be egy szót: \n"; std::cin >> szo[szoszamlalo]; if( szo[szoszamlalo] == "quit" ) break; return 1; ++szoszamlalo; int tombszamlalo = 0; for( int i = 0; i < szoszamlalo; i++ ) bool talalat = false; for ( int j = 0; j < tombszamlalo; j++ ) if ( tomb[j] == szo[i] ) talalat = true; break; if (!talalat ) tomb[tombszamlalo] = szo[i]; ++tombszamlalo; sort( tomb, tomb + tombszamlalo ); for( int i = 0; i < tombszamlalo; i++ ) std::cout << tomb[i] << std::endl; return 0; A program beolvassa a szavakat a standard inputról, majd megvizsgálja, hogy ha kétszer (vagy többször) szerepel ugyanaz a szó, akkor csak egyszer kerüljön kiíratásra. Miután kiszűrte minden szó többszöri előfordulását, a quit szó beírásával termináljuk a programot, amely ezek után abc sorrendbe rendezi a szavakat és kiírja őket. A forrást fordítom, majd futtatom. [../udprog-code/source/tankonyvi/stroustrup]$ g++ X.8.11.cpp -o quit

324 A Debreceni Egyetem programozói évkönyve 294 / 404 [../udprog-code/source/tankonyvi/stroustrup]$./quit X.9[1] feladat A megoldást../source/tankonyvi/stroustrup/x.9.1.cpp forrásállományba helyeztem el. #include <iostream> int main() struct elso bool b; //1 bájt int i; //4 bájt char c; //1 bájt long l; //4 bájt double d; //8 bájt long double ld; //12 bájt ; struct masodik long double ld; //12 bájt double d; //8 bájt int i; //4 bájt long l; //4 bájt bool b; //1 bájt char c; //1 bájt ; std::cout<<"az első struktúra mérete: "<<sizeof(elso)<<" bájt.\n"; std::cout<<"a második struktúra mérete: "<<sizeof(masodik)<<" bájt.\n"; Az én gépemen az első 32, a második 36. A különbség azért van, mert a második elrendezésnél a két egybájtos egy négybájtos helyre kerül, az elsőnél külön-külön négybájtosakba így 4 a különbség X.9[2] feladat A megoldást../source/tankonyvi/stroustrup/x.9.2.cpp forrásállományba helyeztem el. #include <iostream> #include <string> using namespace std; int main() const char* monthnames[] = "Jan","Feb","Mar","Apr","May","Jun"," - Jul","Aug","Sep","Oct","Nov","Dec"; int days[] = 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ; for(int i = 0; i < 12; i++) cout << monthnames[i] << ": " << days[i] << " days" << endl;

325 A Debreceni Egyetem programozói évkönyve 295 / 404 struct month const char *name; int days; ; month months[] = "Jan", 31, "Feb", 28, "Mar", 31, "Apr", 30, "May", 31, "Jun", 30, "Jul", 31, "Aug", 31, "Sep", 30, "Oct", 31, "Nov", 30, "Dec", 31 ; for(int i = 0; i < 12; i++) cout << months[i].name << ": " << months[i].days << " days" << - endl; return 0; X.10[1] feladat A megoldást../source/tankonyvi/stroustrup/x.10.1.cpp forrásállományba helyeztem el. #include <iostream> #include <string> #include <vector> int main() int max_length = 100; std::vector<char> input_line(max_length); int quest_count = 0; // AZ EREDETI FOR CIKLUS // for( int i = 0; i!= max_length; i++ ) // if( input_line[i] ==? ) // quest_count++; // A FOR CIKLUSSAL EGYENÉRTÉKŰ WHILE CIKLUS // int i = 0; // while( i!= max_length ) // // if( input_line[i] ==? ) // quest_count++; // i++; // // A FOR CIKLUS MEGOLDÁSA POINTERREL

326 A Debreceni Egyetem programozói évkönyve 296 / 404 // char *p; // p = input_line; // for( ; p!= input_line + max_length; ++p ) // if( *p ==? ) // quest_count++; // RANGE-FOR CIKLUS, AMIT NEM TÁMOGAT A RÉGI C++ SZABVÁNY, ÍGY -std - =c++11 KAPCSOLÓVAL KELL FORDÍTANI for(const auto& i : input_line) if( input_line[i] ==? ) quest_count++; return 0; A program átírása megtörtént, ahol probléma lehet az az utolsó rész, mert a C++98-as szabvány nem ismeri a range-based for ciklust, így amikor fordítjuk -std=c++11 vagy -std=c++0x kapcsoló segítségével fogja csak elfogadni a fordítónk. A forrást így a -std=c++11 kapcsolóval fordítom, majd futtatom, mivel csak az jó a range-for-nak és minden másik ciklusnak is tökéletes. [../udprog-code/source/tankonyvi/stroustrup]$ g++ -std=c++11 X.10.1.cpp -o - iteracio [../udprog-code/source/tankonyvi/stroustrup]$./iteracio X.11[10] feladat A megoldást../source/tankonyvi/stroustrup/x cpp forrásállományba helyeztem el. #include <iostream> #include <cstring> using namespace std; void rev( char * ); int main() char p[100]; cout << "Adj meg egy sztringet vagy mondatot: " << endl; cin.getline( p, 99 ); cout << endl; cout << "A megadott sztring vagy mondat visszafelé: " << endl; rev( p ); cout << p << endl; return 0; void rev( char *str ) int hossz = strlen( str ); char tmp;

327 A Debreceni Egyetem programozói évkönyve 297 / 404 for( int i = 0; i < hossz / 2; i++ ) tmp = str[i]; str[i] = str[hossz-i-1]; str[hossz-i-1] = tmp; A program beolvas egy sztringet a standard inputról, ezt a paraméterül kapott sztringet megfordítja/tükrözi és kiírja az újat. A forrást fordítom majd futtatom. [../udprog-code/source/tankonyvi/stroustrup]$ g++ X cpp -o rev [../udprog-code/source/tankonyvi/stroustrup]$./rev X.13[9] feladat A megoldást../source/tankonyvi/stroustrup/x.13.9.cpp forrásállományba helyeztem el. #include <iostream> #define MERET 5 #define MERETMAX 10 using namespace std; void kiir(double w[meretmax][meretmax], int n) int i, j; for (i=0; i<n; i++) for (j=0; j<n; j++) cout<<w[i][j]<<"\t"; cout<<endl; void ald(double w[meretmax][meretmax], int n, int a, int b) int i, j; for (i=0; i<n; i++) for (j=b-1; j<=n-1; j++) if (j!=n-1) w[i][j]=w[i][j+1]; else w[i][j]=0; for (i=a-1; i<n; i++) for (j=0; j<n-1; j++) if (i!=n-1) w[i][j]=w[i+1][j]; else w[i][j]=0;

328 A Debreceni Egyetem programozói évkönyve 298 / 404 double det(double x[meretmax][meretmax], int n) int i, j, s=0, k, l; double w[meretmax][meretmax]; for (i=0; i<meretmax; i++) for (j=0; j<meretmax; j++) w[i][j]=x[i][j]; if (n==1) return w[0][0]; if (n==2) return w[0][0]*w[1][1]-w[0][1]*w[1][0]; if (n==3) return w[0][0]*w[1][1]*w[2][2] + w[1][0]*w[2][1]*w[0][2] + w[2][0]*w - [0][1]*w[1][2] - w[0][2]*w[1][1]*w[2][0] - w[0][0]*w[1][2]*w[2][1] - w[0][1]*w - [1][0]*w[2][2]; for (i=0; i<n; i++) ald(w, n, 1, i+1); if (i%2==0) s+=x[0][i]*det(w, n-1); else s+=-x[0][i]*det(w, n-1); for (k=0; k<meretmax; k++) for (l=0; l<meretmax; l++) w[k][l]=x[k][l]; return s; void invert(double x[meretmax][meretmax], int n) double d, w[meretmax][meretmax]; int i, j, k, l; d=det(x, n); if (d==0) cout<<"nincs inverz"<<endl; return; for (i=0; i<meretmax; i++) for (j=0; j<meretmax; j++) w[i][j]=x[i][j]; double trans[meretmax][meretmax]; for (i=0; i<n; i++) for (j=0; j<n; j++) if ((i+j)%2==0) ald(w, n, i+1, j+1); trans[j][i]=det(w, n-1)/(d);

329 A Debreceni Egyetem programozói évkönyve 299 / 404 else ald(w, n, i+1, j+1); trans[j][i]=det(w, n-1)/(-d); for (k=0; k<meretmax; k++) for (l=0; l<meretmax; l++) w[k][l]=x[k][l]; for (i=0; i<meretmax; i++) for (j=0; j<meretmax; j++) if (trans[i][j]==0) trans[i][j]=0; //negatív 0 miatt x[i][j]=trans[i][j]; int main() double m[meretmax][meretmax]= 1,1,1,1,2,0,0,0,0,0, 4,1,7,1,1,0,0,0,0,0, 1,3,4,1,2,0,0,0,0,0, 1,1,1,9,1,0,0,0,0,0, 2,1,2,1,2,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0; kiir(m, MERET); cout<<endl<<det(m, MERET)<<endl; invert(m, MERET); cout<<endl; kiir(m, MERET); A program egy megadott tömbnek kiszámítja a determinánsát és invertálja azt, ha lehetséges kifejtési tétel alapján. Bug reportolva Forgács Péter által linkedinen X.13[14] feladat A megoldást../source/tankonyvi/stroustrup/x cpp forrásállományba helyeztem el. /* A feladat: 1. Hogyan használjuk a nagybetűket a nevekben? A nagybetűket akkor használjuk, ha többszóval akarjuk definiálni a - változóinkat, vagy például a könnyebb átláthatóság kedvéért.

330 A Debreceni Egyetem programozói évkönyve 300 / 404 Például : shortname, variablename, floatnumber, stb Hogyan használjuk az alulvonást? "_" Az alulvonást szintén így használjuk ha szavakat akarunk - összekapcsolni vele, mivel a szóközt tartalmazó név nem - engedélyezett. Például : short_name, variable_name, float_number, stb Mikor használunk rövid neveket, mint például i vagy x? */ Rövid neveket, mint például az i vagy az x, akkor használunk, ha - nem lesz jelentős szerepe a változónak, csak például egy ciklust akarunk vele bejárni, vagy egyetlen számot fogunk - beleolvasni, stb... A feladat szövegében - mivel ez nem programozási feladat -, mindent leírtam kommentben X.13[15] feladat A megoldást../source/tankonyvi/stroustrup/x cpp forrásállományba helyeztem el. #include <iostream> using namespace std; // ez így helytelen // #define PI = ; // helyesen így kell használni #define PI // ez így helytelen // #define MAX(a,b) a>b?a:b // helyesen zárójelezve már működik #define MAX( a, b ) ( ( a > b )? a : b ) // ez így helytelen // #define fac( a ) (a) fac((a)-1) // makrót nem lehet rekurzívan meghívni, ha helyesen akarjuk el - őállítani a paraméterül kapott szám faktoriálisát, // akkor át kell írnunk egy függvénybe a makrót int main() return 0; Az első makrónál felesleges karakterek voltak a hiba okozói, a második makró nem volt megfelelően bezárójelezve, a harmadik meg egyáltalán nem működhet mivel az előfeldolgozó processzor mindig rekurzívan hívná a fac makrót és így nem az helyettesítődne be, amit mi szeretnénk, hanem a fac második hívásánál mindig a fac ismét, így az eredmény nem tükrözné azt amit szeretnénk. Ha ezt mindenáron szeretnénk, bele kell tennünk egy függvénybe. Ott már könnyedén megvalósítható. A forrást fordítom majd futtatom.

331 A Debreceni Egyetem programozói évkönyve 301 / 404 [../udprog-code/source/tankonyvi/stroustrup]$ g++ X cpp -o makro [../udprog-code/source/tankonyvi/stroustrup]$./makro X.13[21] feladat A megoldást../source/tankonyvi/stroustrup/x cpp forrásállományba helyeztem el. #include <iostream> using namespace std; struct Date int ev; int honap; int nap; ; Date datum; int szokoev() if (datum.ev%400==0) return 1; if (datum.ev%100==0) return 0; if (datum.ev%4==0) return 1; return 0; void evnov() datum.ev += 1; void honapnov() switch (datum.honap) case 1: if (datum.nap>=29 &&!szokoev()) cout<<"hiba! A hónap növelése - nem értelmezett!"<<endl; break; if (datum.nap>=30 && szokoev()) cout<<"hiba! A hónap növelése nem - értelmezett!"<<endl; break; break; case 2:; break; case 3: if (datum.nap==31) cout<<"hiba! A hónap növelése nem - értelmezett!"<<endl; break; case 4:; break; case 5:; if (datum.nap==31) cout<<"hiba! A hónap növelése nem - értelmezett!"<<endl; break; case 6:; break; case 7:; break; case 8: if (datum.nap==31) cout<<"hiba! A hónap növelése nem - értelmezett!"<<endl; break; case 9:; break; case 10: if (datum.nap==31) cout<<"hiba! A hónap növelése nem - értelmezett!"<<endl; break; case 11:; break; case 12:; break; datum.honap += 1; if (datum.honap==13) datum.honap=1;

332 A Debreceni Egyetem programozói évkönyve 302 / 404 datum.ev+=1; void napnov() switch (datum.honap) case 1: if (datum.nap==31) datum.nap=1; datum.honap=2; break; else datum.nap += 1; break; break; case 2: if (datum.nap==28 &&!szokoev()) datum.nap=1; datum.honap=3; - break; else if (datum.nap==29 && szokoev()) datum.nap=1; datum.honap=3; - break; else datum.nap += 1; break; break; case 3: if (datum.nap==31) datum.nap=1; datum.honap=4; break; else datum.nap += 1; break; break; case 4: if (datum.nap==30) datum.nap=1; datum.honap=5; break; else datum.nap += 1; break; break; case 5: if (datum.nap==31) datum.nap=1; datum.honap=6; break; else datum.nap += 1; break; break; case 6: if (datum.nap==30) datum.nap=1; datum.honap=7; break; else datum.nap += 1; break; break; case 7: if (datum.nap==31) datum.nap=1; datum.honap=8; break; else datum.nap += 1; break; break; case 8: if (datum.nap==31) datum.nap=1; datum.honap=9; break; else datum.nap += 1; break; break; case 9: if (datum.nap==30) datum.nap=1; datum.honap=10; break; else datum.nap += 1; break; break; case 10: if (datum.nap==31) datum.nap=1; datum.honap=11; break; else datum.nap += 1; break; break; case 11: if (datum.nap==30) datum.nap=1; datum.honap=12; break; else datum.nap += 1; break; break; case 12: if (datum.nap==31) datum.nap=1; datum.honap=1; datum.ev+=1; - break; else datum.nap += 1; break; break; void beolvasas() cout << "Adja meg az évet: \n"; cin >> datum.ev; cout << "Adja meg a hónapot: \n"; cin >> datum.honap; cout << "Adja meg a napot: \n"; cin >> datum.nap; int value() int a=datum.ev/400;

333 A Debreceni Egyetem programozói évkönyve 303 / 404 int b=datum.ev/100; int c=datum.ev/4; int s; s=c-b+a; s=365*(datum.ev-s)+366*s; switch (datum.honap) case 1: s+=0; break; case 2: s+=31; break; case 3: s+=59; break; case 4: s+=90; break; case 5: s+=120; break; case 6: s+=151; break; case 7: s+=181; break; case 8: s+=212; break; case 9: s+=243; break; case 10: s+=273; break; case 11: s+=304; break; case 12: s+=334; break; s+=datum.nap+5; s=s-s/7*7; return s; void next() if (value()!=0 && value()!=7) napnov(), next(); int main() beolvasas(); cout<<"a beírt dátum: "<<datum.ev<<" "<<datum.honap<<" "<<datum.nap<< - endl; switch(value()) case 0: cout<<"hétfő"<<endl; break; case 1: cout<<"kedd"<<endl; break; case 2: cout<<"szerda"<<endl; break; case 3: cout<<"csütörtök"<<endl; break; case 4: cout<<"péntek"<<endl; break; case 5: cout<<"szombat"<<endl; break; case 6: cout<<"vasárnap"<<endl; break; ; next(); cout<<"rákövetkező hétfő: "<<datum.ev<<" "<<datum.honap<<" "<<datum.nap - <<endl; beolvasas(); evnov(); cout<<"+1 év: "<<datum.ev<<" "<<datum.honap<<" "<<datum.nap<<endl; beolvasas(); honapnov(); cout<<"+1 hónap (ha lehetséges): "<<datum.ev<<" "<<datum.honap<<" "<< - datum.nap<<endl; beolvasas(); napnov(); cout<<"+1 nap: "<<datum.ev<<" "<<datum.honap<<" "<<datum.nap<<endl; A program először a beírt dátumhoz hozzárendel egy napszerű értéket amely mod 7 miatt 7 féle lehet, ez a hét napjainak felel meg. A program másodszor a következő hétfőt számítja ki (hétfő esetén nem megy tovább).

334 A Debreceni Egyetem programozói évkönyve 304 / 404 A program harmadszor megpróbálja a megadott dátum utáni hétfőt növelni 1 év 1 hónap 1 nappal X.17[4] feladat A megoldást../source/tankonyvi/stroustrup/x.17.4.cpp forrásállományba helyeztem el. #include <iostream> using namespace std; class Histogram private: float low, a, b, c, up; int t[5]=0,0,0,0,0; public: Histogram(float lower, float aa, float bb, float cc, float upper) low=lower; a=aa; b=bb; c=cc; up=upper; void writenumber(float n) if (n<low) t[4]++; goto end; if (n<=a) t[0]++; goto end; if (n<=b) t[1]++; goto end; if (n<=c) t[2]++; goto end; if (n<=up) t[3]++; goto end; t[4]++; end:; void print() cout<<low<<"-"<<a<<": "<<t[0]<<endl; cout<<a<<"-"<<b<<": "<<t[1]<<endl; cout<<b<<"-"<<c<<": "<<t[2]<<endl; cout<<c<<"-"<<up<<": "<<t[3]<<endl; cout<<"out of range: "<<t[4]<<endl; ; int main() float l, aaa, bbb, ccc, u, nn; cout<<"a számokat növekvő sorrendben adja meg!"<<endl; cout<<"intervallum alsó határa"<<endl; cin>>l; cout<<"intervallum alsó határa"<<endl; cin>>aaa; cout<<"intervallum alsó határa"<<endl; cin>>bbb; cout<<"intervallum alsó határa"<<endl; cin>>ccc; cout<<"intervallum alsó határa"<<endl; cin>>u; Histogram H(l, aaa, bbb, ccc, u); cout<<"írjon be értékeket"<<endl; while(cin>>nn)

335 A Debreceni Egyetem programozói évkönyve 305 / 404 H.writenumber(nn); H.print(); A program bekéri a hisztogram konstruktorához az intervallumok határait, aztán fájlvége jelig számokat olvas be. Ezután kiírja az egyes intervallumokba esett számok számát, illetve az intervallumokon kívűlieket is X.17[7] feladat A megoldást../source/tankonyvi/stroustrup/x.17.7.cpp forrásállományba helyeztem el. #include <iostream> #include <vector> #include <algorithm> using namespace std; struct myclass bool operator() (int i,int j) return (i<j); myobject; int a[6]=1,5,8,9,4,0; int b[5]=5,9,3,7,10; vector<int> v1 (a, a+6); vector<int> v2 (b, b+5); class Halmaz public: Halmaz() int i; sort (v1.begin(), v1.end(), myobject); sort (v2.begin(), v2.end(), myobject); cout<<" A halmaz: "; for (i=0; i<v1.size(); i++) cout<<v1[i]<<" "; cout << endl; cout<<" B halmaz: "; for (i=0; i<v2.size(); i++) cout<<v2[i]<<" "; cout << endl; vector<int> intersection (vector<int> v1, vector<int> v2 ) int i=0, j=0; vector<int> in; sort (v1.begin(), v1.end(), myobject); sort (v2.begin(), v2.end(), myobject); for (i=0; i<v1.size(); i++) for (j=0; j<v2.size(); j++)

336 A Debreceni Egyetem programozói évkönyve 306 / 404 if (v1[i]==v2[j]) in.push_back(v1[i]); goto next; next:; return in; ; vector<int> unio (vector<int> v1, vector<int> v2 ) int i=0, j=0; vector<int> un; sort (v1.begin(), v1.end(), myobject); sort (v2.begin(), v2.end(), myobject); while(i<v1.size() && j<v2.size()) if (v1[i]==v2[j]) un.push_back(v1[i]); i++; j++; continue; if (v1[i]>v2[j]) un.push_back(v2[j]); j++; continue; if (v1[i]<v2[j]) un.push_back(v1[i]); i++; continue; while(i<v1.size()) un.push_back(v1[i]); i++; while(j<v2.size()) un.push_back(v2[j]); j++; return un; ; vector<int> symdif (vector<int> v1, vector<int> v2 ) int i=0, j=0; vector<int> sd; sort (v1.begin(), v1.end(), myobject); sort (v2.begin(), v2.end(), myobject); while(i<v1.size() && j<v2.size()) if (v1[i]==v2[j])

337 A Debreceni Egyetem programozói évkönyve 307 / 404 ; i++; j++; continue; if (v1[i]>v2[j]) sd.push_back(v2[j]); j++; continue; if (v1[i]<v2[j]) sd.push_back(v1[i]); i++; continue; while(i<v1.size()) sd.push_back(v1[i]); i++; while(j<v2.size()) sd.push_back(v2[j]); j++; return sd; ; int main() int i; Halmaz x; x.intersection(v1, v2); cout<<"metszet: "; for (i=0; i<x.intersection(v1, v2).size(); i++) cout<<x.intersection(v1, v2)[i]<<" "; cout<<endl; x.unio(v1, v2); cout<<"unió: "; for (i=0; i<x.unio(v1, v2).size(); i++) cout<<x.unio(v1, v2)[i]<<" "; cout<<endl; x.symdif(v1, v2); cout<<"szimmetrikus differencia: "; for (i=0; i<x.symdif(v1, v2).size(); i++) cout<<x.symdif(v1, v2)[i]<<" "; cout<<endl; A program két előre megadott tömbnek kiírja a metszetét, unióját és szimmetrikus differenciáját.

338 A Debreceni Egyetem programozói évkönyve 308 / X.17[8] feladat A megoldást../source/tankonyvi/stroustrup/x.17.8.cpp forrásállományba helyeztem el. #include <iostream> #include <vector> #include <algorithm> using namespace std; struct myclass bool operator() (int i,int j) return (i<j); myobject; typedef struct node int val; struct node *next; NODE; NODE* head=null; void addend(int val) NODE*act=head; NODE*newl=(NODE*)malloc(sizeof(NODE)); newl->val=val; newl->next=null; if(head==null) head=newl; else while(act->next!=null) act=act->next; act->next=newl; int a[6]=1,5,8,9,4,0; int b[5]=5,9,3,7,10; vector<int> v1 (a, a+6); vector<int> v2 (b, b+5); class Halmaz public: Halmaz() int i; sort (v1.begin(), v1.end(), myobject); sort (v2.begin(), v2.end(), myobject); cout<<" A halmaz: "; for (i=0; i<v1.size(); i++) cout<<v1[i]<<" "; cout << endl; cout<<" B halmaz: "; for (i=0; i<v2.size(); i++) cout<<v2[i]<<" ";

339 A Debreceni Egyetem programozói évkönyve 309 / 404 cout << endl; void intersection (vector<int> v1, vector<int> v2 ) int i=0, j=0; sort (v1.begin(), v1.end(), myobject); sort (v2.begin(), v2.end(), myobject); for (i=0; i<v1.size(); i++) for (j=0; j<v2.size(); j++) if (v1[i]==v2[j]) addend(v1[i]); goto next; next:; ; void unio (vector<int> v1, vector<int> v2 ) int i=0, j=0; sort (v1.begin(), v1.end(), myobject); sort (v2.begin(), v2.end(), myobject); while(i<v1.size() && j<v2.size()) if (v1[i]==v2[j]) addend(v1[i]); i++; j++; continue; if (v1[i]>v2[j]) addend(v2[j]); j++; continue; if (v1[i]<v2[j]) addend(v1[i]); i++; continue; while(i<v1.size()) addend(v1[i]); i++; while(j<v2.size()) addend(v2[j]); j++; ;

340 A Debreceni Egyetem programozói évkönyve 310 / 404 ; void symdif (vector<int> v1, vector<int> v2 ) int i=0, j=0; sort (v1.begin(), v1.end(), myobject); sort (v2.begin(), v2.end(), myobject); while(i<v1.size() && j<v2.size()) if (v1[i]==v2[j]) i++; j++; continue; if (v1[i]>v2[j]) addend(v2[j]); j++; continue; if (v1[i]<v2[j]) addend(v1[i]); i++; continue; while(i<v1.size()) addend(v1[i]); i++; while(j<v2.size()) addend(v2[j]); j++; ; int main() int i; Halmaz x; x.intersection(v1, v2); cout<<"metszet: "; node*felt=head; while (felt!=null) cout<<felt->val<<" "; felt=felt->next; cout<<endl; head=null; x.unio(v1, v2); cout<<"unió: "; felt=head; while (felt!=null)

341 A Debreceni Egyetem programozói évkönyve 311 / 404 cout<<felt->val<<" "; felt=felt->next; cout<<endl; head=null; x.symdif(v1, v2); cout<<"szimmetrikus differencia: "; felt=head; while (felt!=null) cout<<felt->val<<" "; felt=felt->next; cout<<endl; A program két előre megadott tömbnek kiírja a metszetét, unióját és szimmetrikus differenciáját és ezt láncolt listával teszi meg X.17[13] feladat A megoldást../source/tankonyvi/stroustrup/x cpp forrásállományba helyeztem el. #include <iostream> class Extra public: Extra() //constructor std::cout<<"initialize\n"; ~Extra() // destructor std::cout<<"clean up\n"; ; Extra a; int main() std::cout << "Hello, world!\n"; A program egyszerűen kihasználja egy globális változó konstruktorát és destruktorát X.19[4] feladat A megoldást../source/tankonyvi/stroustrup/x.19.4.cpp forrásállományba helyeztem el. #include <iostream> using namespace std; class Int

342 A Debreceni Egyetem programozói évkönyve 312 / 404 private: short *t; int l; public: Int() t = new short[10000]; short i; for (i=0; i<10000; ++i) t[i]=0; Int(int a) //cout<<"construct from int "<<a<<endl; t = new short[10000]; short i; for (i=0; i<10000; ++i) t[i]=0; short c=0; while (a>9) t[c]=a-(a/10)*10; a=a/10; c++; t[c]=a; c++; l=c; ~Int() //cout<<"dest "; //print(); //cout<<"with "<<length()<<endl; delete[] t; int length() const return l; Int (const Int& n) //cout<<"copy const "; //n.print(); //cout<<"with "<<n.length()<<endl; t = new short[10000]; short i; l=n.l; for (i=0; i<10000; ++i) t[i]=n.t[i]; Int & operator= (const Int & other) //cout<<"copy ass "; //other.print(); if (this!= &other) // protect against invalid self-assignment

343 A Debreceni Egyetem programozói évkönyve 313 / 404 short i; for (i=0; i<10000; ++i) t[i]=other.t[i]; l=other.l; // by convention, always return *this return *this; Int& operator+=( Int const& other) //cout<<"operator +="<<endl; Int temp=other; short i; for (i=0; i<10000; ++i) //cout<<">>>"<<i<<endl; t[i]+=temp.t[i]; if (t[i]>=10) t[i]-=10; t[i+1]+=1; if (t[l]!=0) l++; return *this; Int& operator*=( Int const& other) //cout<<"operator *="<<endl; Int temp=other; temp.dec(); Int copyt=0; short i; for (i=0; i<10000; ++i) copyt.t[i]=t[i]; copyt.l=l; while (temp.length()>1 temp.t[0]>0) //cout<<temp.length()<<" "<<temp.t[0]<<endl; for (i=0; i<10000; ++i) //cout<<">>>"<<i<<endl; t[i]+=copyt.t[i]; if (t[i]>=10) t[i]-=10; t[i+1]+=1; if (t[l]!=0) l++; temp.dec();

344 A Debreceni Egyetem programozói évkönyve 314 / 404 //print(); //cout<<"length: "<<length()<<endl; //cout<<"end"<<endl; return *this; void print() const short i; for (i=(l)-1; 0<=i; --i) cout<<t[i]; cout<<endl; void dec() short x=0, i; bool b=false; again:; if (t[x]!=0) t[x]--; if(!t[x]) b=true; if (x) for (i=0; i<x; ++i) t[i]=9; if (x+1==l && b) l--; else if (x!=9999) x++; goto again; ; Int operator+(int& lhs, const Int& rhs) //cout<<"operator +"<<endl; return lhs+=rhs; Int operator*(int& lhs, const Int& rhs) //cout<<"operator *"<<endl; return lhs*=rhs; int main() int i; Int p=1; for (i=1; i<=1000; ++i) Int temp=i;

345 A Debreceni Egyetem programozói évkönyve 315 / 404 p*=temp; p.print(); cout<<"endmain"<<endl; Az osztály a számokat számjegyenként tárolja. Az összeadás számjegyenként történik átvitellel, a szorzás pedig sorozatos összeadásként történik. Körülbelül egy perc kell amíg 1000! kiszámolásra kerül X.21[1] feladat A megoldást../source/tankonyvi/stroustrup/x.21.1.cpp forrásállományba helyeztem el. #include <iostream> using namespace std; class Base public: virtual void iam() cout << "Base\n"; ; class Derivedone: public Base public: void iam() cout << "Derivedone\n"; ; class Derivedtwo: public Base public: void iam() cout << "Derivedtwo\n"; ; int main() Derivedone a; Derivedtwo b; a.iam(); b.iam(); Derivedone* c=&a; Derivedtwo* d=&b; Base* e=c; Base* f=d; e->iam(); f->iam(); A program meghívja a származtatott osztályok iam függvényét majd ugyanezt Base* segítségével X.32[1] feladat A megoldást../source/tankonyvi/stroustrup/x.32.1.cpp forrásállományba helyeztem el.

346 A Debreceni Egyetem programozói évkönyve 316 / 404 #include <iostream> #include <vector> #include <algorithm> using namespace std; int main() char alpha[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" ; std::vector<char> alphabet( alpha, alpha + sizeof( alpha ) - 1 ) ; for ( int i = 0; i < alphabet.size(); i++) cout << alphabet[i] << " "; cout << endl; sort(alphabet.rbegin(), alphabet.rend()); cout << endl; for ( int i = 0; i < alphabet.size(); i++) cout << alphabet[i] << " "; cout << endl; return 0; A program kiírja az ABC betűit sorrendben, majd kiírja őket fordított sorrendben is. A forrást fordítom majd futtatom. [../udprog-code/source/tankonyvi/stroustrup]$ g++ X.32.1.cpp -o abc [../udprog-code/source/tankonyvi/stroustrup]$./abc X.32[2] feladat A megoldást../source/tankonyvi/stroustrup/x.32.2.cpp forrásállományba helyeztem el. #include <iostream> #include <vector> #include <algorithm> #include <string> using namespace std; template <typename T> void vektor_kiir( const vector<t>& V ) cout << "\na rendezett gyümölcsök listája a vektorban: " << endl; for( int i = 0; i < V.size(); i++ ) cout << V[i] << " "; cout << "\n\n"; int main()

347 A Debreceni Egyetem programozói évkönyve 317 / 404 string input; vector<string> V; cout << "Írd be a gyümölcsöket: " << endl; while( cin >> input ) V.push_back(input); sort(v.begin(), V.end()); vektor_kiir(v); return 0; A program beolvas cin-nel standard inputról gyümölcs neveket (igazából bármilyen más szavakat is) a vektorba, majd kiírja azokat sorba rendezve. A forrást fordítom majd futtatom. [../udprog-code/source/tankonyvi/stroustrup]$ g++ X.32.2.cpp -o gyumolcs [../udprog-code/source/tankonyvi/stroustrup]$./gyumolcs X.32[3] feladat A megoldást../source/tankonyvi/stroustrup/x.32.3.cpp forrásállományba helyeztem el. #include <iostream> #include <vector> #include <algorithm> #include <string> using namespace std; template <typename T> void vektor_kiir( const vector<t>& V ) cout << "\na rendezett gyümölcsök listája a vektorban: " << endl; for( int i = 0; i < V.size(); i++ ) cout << V[i] << " "; cout << "\n\n"; int main() string input; vector<string> V; cout << "Írd be a gyümölcsöket: " << endl; while( cin >> input ) V.push_back(input);

348 A Debreceni Egyetem programozói évkönyve 318 / 404 for( int i = 0; i < V.size(); i++ ) V[i].replace( 0, 1, 1, a ); vektor_kiir(v); return 0; A program beolvas cin-nel standard inputról gyümölcs neveket (igazából bármilyen más szavakat is) a vektorba, majd helyettesíti minden szó első betűjét egy a karakterrel, majd kiírja a vektort. A forrást fordítom majd futtatom. [../udprog-code/source/tankonyvi/stroustrup]$ g++ X.32.3.cpp -o helyettesit [../udprog-code/source/tankonyvi/stroustrup]$./helyettesit X.32[4] feladat A megoldást../source/tankonyvi/stroustrup/x.32.4.cpp forrásállományba helyeztem el. #include <iostream> #include <vector> #include <algorithm> #include <string> using namespace std; template <typename T> void vektor_kiir( const vector<t>& V ) cout << "\naz új vektor tartalma: " << endl; for( int i = 0; i < V.size(); i++ ) cout << V[i] << " "; cout << "\n\n"; int main() string input; vector<string> V; cout << "Írd be a gyümölcsöket: " << endl; while( cin >> input ) V.push_back(input); for( int i = 0; i < V.size(); i++ ) string aktualisszo = V[i];

349 A Debreceni Egyetem programozói évkönyve 319 / 404 if(aktualisszo[0] == a ) V.erase( V.begin() + i ); --i; vektor_kiir(v); return 0; A program beolvas cin-nel standard inputról gyümölcs neveket (igazából bármilyen más szavakat is) a vektorba, kitöröl minden olyan szót amely "a" betűvel kezdődik, majd kiírja a vektort. A forrást fordítom majd futtatom. [../udprog-code/source/tankonyvi/stroustrup]$ g++ X.32.4.cpp -o torol [../udprog-code/source/tankonyvi/stroustrup]$./torol X.32[5] feladat A megoldást../source/tankonyvi/stroustrup/x.32.5.cpp forrásállományba helyeztem el. #include <iostream> #include <vector> #include <algorithm> #include <string> using namespace std; template <typename T> void vektor_kiir( const vector<t>& V ) cout << "\naz új vektor tartalma: " << endl; for( int i = 0; i < V.size(); i++ ) cout << V[i] << " "; cout << "\n\n"; int main() string input; string input1; vector<string> V; vector<string> citrusgyumolcs = "narancs", "mandarin", "citrom", - "grépfrút", "kumkvat", "pomeló", "papeda", "lime", "citronád" ; cout << "Írj be gyümölcsöket: " << endl; while( cin >> input ) V.push_back(input); for( int i = 0; i < V.size(); i++ )

350 A Debreceni Egyetem programozói évkönyve 320 / 404 string aktualisszo = V[i]; for( int j = 0; j < citrusgyumolcs.size(); j++ ) string aktualisszo1 = citrusgyumolcs[j]; if( aktualisszo == aktualisszo1 ) V.erase( V.begin() + i ); --i; vektor_kiir(v); return 0; A program beolvas cin-nel standard inputról gyümölcs neveket (igazából bármilyen más szavakat is) a vektorba, kitöröl minden olyan szót amely szerepel az általam megadott "citrusgyumolcs" nevű vektorban, majd kiírja a vektort. A forrást -std=c++11 kapcsolóval fordítom, mert a vektort a deklarálásával egy sorban inicializálni a régi C++ szabvány még nem volt képes, majd futtatom. [../udprog-code/source/tankonyvi/stroustrup]$ g++ -std=c++11 X.32.5.cpp -o - citrus [../udprog-code/source/tankonyvi/stroustrup]$./citrus X.32[6] feladat A megoldást../source/tankonyvi/stroustrup/x.32.6.cpp forrásállományba helyeztem el. #include <iostream> #include <vector> #include <algorithm> #include <string> using namespace std; template <typename T> void vektor_kiir( const vector<t>& V ) cout << "\naz új vektor tartalma: " << endl; for( int i = 0; i < V.size(); i++ ) cout << V[i] << " "; cout << "\n\n"; int main() string input; string input1; vector<string> V;

351 A Debreceni Egyetem programozói évkönyve 321 / 404 vector<string> nemszeretem = "ananász", "mangó", "narancs", "szől - ő" ; cout << "Írj be gyümölcsöket: " << endl; while( cin >> input ) V.push_back(input); for( int i = 0; i < V.size(); i++ ) string aktualisszo = V[i]; for( int j = 0; j < nemszeretem.size(); j++ ) string aktualisszo1 = nemszeretem[j]; if( aktualisszo == aktualisszo1 ) V.erase( V.begin() + i ); --i; vektor_kiir(v); return 0; A program beolvas cin-nel standard inputról gyümölcs neveket (igazából bármilyen más szavakat is) a vektorba, kitöröl minden olyan szót amely szerepel az általam megadott "nemszeretem" nevű vektorban, majd kiírja a vektort. A forrást -std=c++11 kapcsolóval fordítom, mert a vektort a deklarálásával egy sorban inicializálni a régi C++ szabvány még nem volt képes, majd futtatom. [../udprog-code/source/tankonyvi/stroustrup]$ g++ -std=c++11 X.32.6.cpp -o - nemszeretem [../udprog-code/source/tankonyvi/stroustrup]$./nemszeretem X.37[1] feladat A megoldást../source/tankonyvi/stroustrup/x.37.1.cpp forrásállományba helyeztem el. #include <iostream> #include <string> #include <cstdlib> #include <cstring> using namespace std; string conc(string a, string b) string res = ""; res+=a; res+="."; res+=b; return res;

352 A Debreceni Egyetem programozói évkönyve 322 / 404 char* cstyle(char* a, char* b) char*res=(char*)malloc(sizeof(a)+sizeof(b)+1); int i; for(i=0; i<strlen(a); ++i) res[i]=a[i]; string n="."; res[i]=n[0]; for(i=0; i<strlen(b); ++i) res[1+i+strlen(a)]=b[i]; res[1+i+strlen(a)]= \0 ; char* wat=&res[0]; return wat; A C++ stílusú változat sokkal egyszerűbb mivel ott a += művelet definiálva van, a C stílusúnál meg nekünk kell ezt megírni.

353 A Debreceni Egyetem programozói évkönyve 323 / 404 III. rész Laborkártyák

354 A Debreceni Egyetem programozói évkönyve 324 / fejezet Laborkártyák Minden labor a kötelező olvasmány elolvasásának ellenőrzésével kezdődik, ez a szúrópróbaszerű (vagy a laborvezető döntése alapján akár teljes) rákérdezés azt a célt szolgálja, hogy az is olvassa a szakirodalmat, aki egyébként nem tenné. Ezt követi a laborkártyák kidolgozásának ellenőrzése, ennek célja, hogy a hallgató önállóan reprodukálja a példákat, az ellenőrzés tárgya magának a reprodukciónak az ellenőrzése. A laborkártya teljesítése lehet egy konkrét program megléte a saját gépen, a program villámgyors jellemzése vagy egy feljegyzés, szakmai a kód kapcsán - feladatja válogatja és megint csak a laborvezető hatásköre, hogy mely megközelítést tartja éppen a leghatékonyabbnak Bevezető laborkártyák A parancssori interfész (CLI) alapvető használata A kézikönyv Mi a különbség a man 2 signal és man 7 signal kézikönyvlapok illetve a man passwd és man 5 passwd kézikönyvlapok között? Megoldások és megjegyzések Laborkártyát kidolgozta Kovács-Ferenc Norbert, tutor: Bereczki László A fordítóprogram Miért nem fordul le a második labor../source/labor/exor/e.c (Exor-os) példája? [nbatfai@desteny exor]$ gcc e.c -o e e.c: In function main : e.c:24:7: error: for loop initial declarations are only allowed in C99 mode for (int i = 0; i < olvasott_bajtok; ++i) ^ e.c:24:7: note: use option -std=c99 or -std=gnu99 to compile your code Megoldások és megjegyzések Laborkártyát kidolgozta Kovács-Ferenc Norbert, tutor: Bereczki László

355 A Debreceni Egyetem programozói évkönyve 325 / Vektorizálás Mi az a parancssori opció amelyet alkalmazva a../source/labor/exor/t.c (Exor-os) törő példa fordítására, az alábbi látványos sebességnövekedés tapasztalhatunk? A futási idő egyszer bő másfél óra: [nbatfai@desteny exor]$ time./t <titkos.txt >teszt.txt real 109m31.178s user 109m16.488s sys 0m0.002s a tuning után pedig csak bő negyedóra: [nbatfai@desteny exor]$ time./t <titkos.txt >teszt.txt real 16m20.972s user 16m18.721s sys 0m0.003s A kapcsolatszerkesztő program Miért nem fordul le az első labor../source/labor/pr/pr.c (Page Rank-es) példája? [nbatfai@desteny pr]$ gcc pr.c -o pr /tmp/cc5mq4r1.o: In function tavolsag : pr.c:(.text+0x119): undefined reference to sqrt collect2: error: ld returned 1 exit status Miután sikerül lefordítanod (pontosabban linkelned), mit mond az ldd pr parancs? Megoldások és megjegyzések Laborkártyát kidolgozta Kovács-Ferenc Norbert, tutor: Bereczki László Az alapvető C és C++ nyelvi konstrukciók használata Nevek bevezetése a programba Értelmezd a következő neveket! int main () int a; int *b = &a; int c[3]; int *d[5]; int e[2][2]; int *f (); void (*g) (void); int &h = a; void i (int &j); int k[] = 42, 43, 44 ; int (&l)[3] = k; int m = 42, (&n)[3] = k, &o = *k, *p = k; int &q a;

356 A Debreceni Egyetem programozói évkönyve 326 / 404 int *r = &q; using FgvPtr = int *(*)(); FgvPtr s = f; long double t =.0314e+2L; class U U(); U(const U&); U(U&&); U& operator=(const U&); U& operator=(u&&); ~U(); ; return 0; A programot így tudod fordítani: g++ -c d.cpp -std=c++11 Mi a hiba (ha van hiba) a deklarációkban a következő programban? int main () int i = nullptr; const int j = 1; int *k = &j; void& l; int m (3.14); auto n 42, 3.14; const char *o = "alma"; o[1] = x ; char *p = "korte"; const int q; char r[] = "banan"; char *s = r; r = s; const char* const t = r; t[1] = x ; t = o; int& u; int& v = 42; class U void U(); int U; enum U u1, u2; ; struct V void V(); int V; enum V v1, v2; ; return 0; A -std=c++11 kapcsolóhoz tutoriál: Linkedin / c avagy miért nem fordul a kód? :) illetve javított és kommentált forráskód:../source/labor/kartyak/labor_3.cpp - Bereczki László

357 A Debreceni Egyetem programozói évkönyve 327 / for először Mi a különbség az alábbi két ciklusszervezés között? for(i=0; i<3; ++i) printf("%d\n", i); for(i=0; i<3; i++) printf("%d\n", i); Egyszerűen próbáld ki! Megoldások és megjegyzések Laborkártyához../source/labor/kartyak/ciklus.cpp eléréssel kidolgozás feltöltve. Kovács-Ferenc Norbert, tutor: Bereczki László for másodszor Mit csinál a következő kódcsipet ciklusa? int a[] = 1,2,3,4,5,6,7,8,9,10; std::vector<int> v (a, a + sizeof(a)/sizeof(int) ); int s 0; for (auto n : v) s += n; Megoldások és megjegyzések Laborkártyához../source/labor/kartyak/ciklus2.cpp eléréssel kidolgozás feltöltve. Kovács-Ferenc Norbert, tutor: Bereczki László for harmadszor Mit csinál a következő kódcsipet ciklusa? int a[] = 1,2,3,4,5,6,7,8,9,10; std::vector<int> v (a, a + sizeof(a)/sizeof(int) ); int s 0; for_each(v.begin(), v.end(), [&](int& n)s += n;); Laborkártyához../source/labor/kartyak/ciklus3.cpp eléréssel kidolgozás feltöltve. Kovács-Ferenc Norbert, tutor: Bereczki László if először Mi a különbség az alábbi két feltételszervezés között? if(signal(sigint, utolso_tennivalo) == SIG_IGN) signal(sigint, SIG_IGN);

358 A Debreceni Egyetem programozói évkönyve 328 / 404 if(signal(sigint, SIG_IGN)!= SIG_IGN) signal(sigint, utolso_tennivalo); Erről szól ez a poszt, illetve ez a webcast, illetve aki nem ismeri a signal rendszerhívást, vagy a SIGINT jelet, annak man 2 signal és man 7 signal. Mutass egy élő példát! Mutass egy élő példát a jelkezelésre forrásban, ha egyelőre nincs más ötleted, akkor például innen indulva: if másodszor Mi a különbség az if utasítások fejében a két kifejezés között (ha van)? if(b & 0x80 == 0) if((b & 0x80) == 0) Az előbbi esetében b-t a logikai vizsgálat eredményével fogja maszkolni, míg az utóbbinál a maszkolást követően megnézi, hogy az eredmény 0-e. Lásd: [STROUSTRUP] 164. oldal. Megoldások és megjegyzések A megoldást készítette Kovács-Ferenc Norbert, Bereczki László(tutor) while Mit csinál a következő utasítás? while(*p++ = *q++); Egyszerűen próbáld ki! Megoldások és megjegyzések Laborkártyához../source/labor/kartyak/while.cpp eléréssel kidolgozás feltöltve. Kovács-Ferenc Norbert, tutor: Bereczki László const Mi a const kulcsszó jelentése man 3 strcpy szinopszisában? Megoldások és megjegyzések Laborkártyát kidolgozta Kovács-Ferenc Norbert, tutor: Bereczki László

359 A Debreceni Egyetem programozói évkönyve 329 / char * Mit mondasz erre C-ben és mit C++-ban? char *p = "Mit mondasz erre C-ben, mit C++-ban?"; Megoldások és megjegyzések Laborkártyát kidolgozta Kovács-Ferenc Norbert, tutor: Bereczki László Paraméterátadás Mit jelent az, hogy C-ben a paraméterátadás érték szerinti, sorrendi kötés van és nincs szám szerinti egyeztetés? A szabad tár kezelése char ** Magyarázd el az ábrán az alábbi char ** dinamikus_tomb alapú kifejezéseket! dinamikus_tomb + 2 *(dinamikus_tomb + 2) *(dinamikus_tomb + 2) + 1 *(*(dinamikus_tomb + 2) + 1) dinamikus_tomb[1][1] *(dinamikus_tomb[1]+1) ábra. Dinamikus tömb a tárban.

360 A Debreceni Egyetem programozói évkönyve 330 / C++ alapfogalmak Másoló konstruktor és másoló értékadás A következő../source/labor/kartyak/int1/int.h #ifndef INT H #define INT H #include <iostream> class Int public: Int (int n = 0):ertek (n) std::cout << "-- Int ctor " << ertek << " " << this << " " << &ertek << std::endl; ~Int () std::cout << "-- Int dtor " << ertek << " " << this << " " << &ertek << std::endl; ; Int (const Int & n) ertek = n.ertek; std::cout << "-- Int masolo ctor " << ertek << " " << this << " " << &ertek << std::endl; Int & operator= (const Int & n); friend std::ostream & operator<< (std::ostream & os, const Int & n); private: int ertek; ; #endif és../source/labor/kartyak/int1/int.cpp #include "int.h" Int & Int::operator= (const Int & n) std::cout << "-- Int masolo ertekadas " << ertek << " " << this << " " << &ertek << std::endl; ertek = n.ertek; return *this; std::ostream & operator<< (std::ostream & os, const Int & n) os << n.ertek; return os; mellett mik fognak lefutni a következő programokban? A nyomkövető kimenetek alapján válaszolj!

361 A Debreceni Egyetem programozói évkönyve 331 / /source/labor/kartyak/Int1/main.cpp #include "int.h" int main () Int a, b (1), c2; std::cout << a << std::endl; std::cout << b << std::endl; std::cout << c << std::endl; Int d = a; std::cout << d << std::endl; return 0; /source/labor/kartyak/Int1/main2.cpp #include "int.h" int main () Int a = 42, b, c; std::cout << a << std::endl; std::cout << b << std::endl; std::cout << c << std::endl; Int d; d = a; std::cout << d << std::endl; return 0; /source/labor/kartyak/Int1/main3.cpp #include "int.h" int kicsontoz(int n) return n.getval(); int main () Int a = 42; std::cout << kicsontoz(a) << std::endl;

362 A Debreceni Egyetem programozói évkönyve 332 / 404 return 0; Ne hívódjon a másoló ctor Mit tennél ehhez, ha csak egy karaktert írhatsz be a forrásba? Módosítsd úgy a kicsontoz függvényt, hogy Int * paramétert kapjon! /source/labor/kartyak/Int1/main5.cpp #include "int.h" #include <vector> int main () Int a = 42; std::vector<int> v; v.push_back(a); std::cout << a << std::endl; return 0; Másoló konstruktor és másoló értékadás másodszor A következő../source/labor/kartyak/int2/int.h #ifndef INT H #define INT H #include <iostream> class Int public: Int(int n = 0) : ertek(new int (n)) std::cout << "-- Int ctor " << *ertek << " " << this << " " << ertek << std::endl; ~Int() std::cout << "-- Int dtor " << *ertek << " " << this << " " << ertek << std::endl; delete ertek; ; Int(const Int &n) : ertek(new int) *ertek = * (n.ertek); std::cout << "-- Int masolo ctor " << *ertek << " " << this << " " << ertek << std::endl; Int &operator= (const Int &n);

363 A Debreceni Egyetem programozói évkönyve 333 / 404 int getval() const return *ertek; friend std::ostream &operator<< (std::ostream &os, const Int &n); private: int ; *ertek; #endif és../source/labor/kartyak/int2/int.cpp #include "int.h" Int &Int::operator= (const Int &n) int *ujertek = new int (); *ujertek = * (n.ertek); delete ertek; ertek = ujertek; std::cout << "-- Int masolo ertekadas " << *ertek << " " << this << " " << ertek << std::endl; return *this; std::ostream & operator<< (std::ostream &os, const Int &n) os << * (n.ertek); return os; mellett mik fognak lefutni a következő programokban? A nyomkövető kimenetek alapján válaszolj! /source/labor/kartyak/Int2/main.cpp #include "int.h" int main() Int a; std::cout << a << std::endl; Int d = a; std::cout << d << std::endl; d = a; std::cout << d << std::endl;

364 A Debreceni Egyetem programozói évkönyve 334 / 404 return 0; Mi történik, ha? Kikommentezed a másoló értékadást és fordítás után újra futtatod a programot, azaz magyarázd meg például ezt a kimenetet: [nbatfai@desteny Int2]$./main -- Int ctor 0 0x7fffcb7f11b0 0x Int masolo ctor 0 0x7fffcb7f11a0 0x Int dtor 0 0x7fffcb7f11a0 0x Int dtor 0 0x7fffcb7f11b0 0x *** Error in./main : double free or corruption (fasttop): 0x *** ======= Backtrace: ========= /lib64/libc.so.6[0x329807d0b8]./main[0x400cee]./main[0x400b3c] /lib64/libc.so.6( libc_start_main+0xf5)[0x b45]./main[0x4009c9] ======= Memory map: ======== r-xp fd: /home/nbatfai/ - UDPROG/udprog-code/source/labor/kartyak/Int2/main r--p fd: /home/nbatfai/ - UDPROG/udprog-code/source/labor/kartyak/Int2/main rw-p fd: /home/nbatfai/ - UDPROG/udprog-code/source/labor/kartyak/Int2/main rw-p :00 0 [heap] 3297c c21000 r-xp fd: /usr/lib64/ld so 3297e e21000 r--p fd: /usr/lib64/ld so 3297e e22000 rw-p fd: /usr/lib64/ld so 3297e e23000 rw-p : b6000 r-xp fd: /usr/lib64/libc so 32981b b p 001b6000 fd: /usr/lib64/libc so 32983b ba000 r--p 001b6000 fd: /usr/lib64/libc so 32983ba bc000 rw-p 001ba000 fd: /usr/lib64/libc so 32983bc c1000 rw-p : c d01000 r-xp fd: /usr/lib64/libm so 3298d f p fd: /usr/lib64/libm so 3298f f01000 r--p fd: /usr/lib64/libm so 3298f f02000 rw-p fd: /usr/lib64/libm so r-xp fd: /usr/lib64/ - libgcc_s so a p fd: /usr/lib64/ - libgcc_s so a a15000 r--p fd: /usr/lib64/ - libgcc_s so.1

365 A Debreceni Egyetem programozói évkönyve 335 / a a16000 rw-p fd: /usr/lib64/ - libgcc_s so.1 329c c0e6000 r-xp fd: /usr/lib64/libstdc - ++.so c0e c2e p 000e6000 fd: /usr/lib64/libstdc - ++.so c2e c2ed000 r--p 000e5000 fd: /usr/lib64/libstdc - ++.so c2ed c2ef000 rw-p 000ed000 fd: /usr/lib64/libstdc - ++.so c2ef c rw-p :00 0 7fc fc68682b000 rw-p :00 0 7fc fc rw-p :00 0 7fffcb7d2000-7fffcb7f4000 rw-p :00 0 [stack] 7fffcb7fe000-7fffcb r-xp :00 0 [vdso] ffffffffff ffffffffff r-xp :00 0 [vsyscall] Aborted (core dumped) /source/labor/kartyak/Int2/main2.cpp #include "int.h" int main() Int a(4), b(2); std::cout << a << " " << b << std::endl; std::swap(a, b); std::cout << a << " " << b << std::endl; return 0; Mozgató konstruktor és mozgató értékadás A következő../source/labor/kartyak/int4/int.h #ifndef INT H #define INT H #include <iostream> #include <utility> class Int public: Int(int n = 0) : ertek(new int (n)) std::cout << "-- Int ctor " << *ertek << " " << this << " " << ertek << std::endl; Int(const Int &n) : ertek(new int) *ertek = * (n.ertek); std::cout << "-- Int masolo ctor " << *ertek << " " << this << " " << ertek << std::endl;

366 A Debreceni Egyetem programozói évkönyve 336 / 404 Int(Int && n) : ertek(n.ertek) n.ertek = nullptr; std::cout << "-- Int mozgato ctor " << *ertek << " " << this << " " << ertek << std::endl; ~Int() std::cout << "-- Int dtor " << this << " " << ertek << std::endl; ; delete ertek; Int &operator= (const Int &n); Int &operator= (Int && n); int getval() const return *ertek; friend std::ostream &operator<< (std::ostream &os, const Int &n); private: int *ertek; ; #endif és../source/labor/kartyak/int4/int.cpp #include "int.h" Int &Int::operator= (const Int &n) int *ujertek = new int (); *ujertek = * (n.ertek); delete ertek; ertek = ujertek; std::cout << "-- Int masolo ertekadas " << *ertek << " " << this << " " << ertek << std::endl; return *this; Int &Int::operator= (Int && n) std::swap(ertek, n.ertek); std::cout << "-- Int mozgato ertekadas " << *ertek << " " << this << " " << ertek << std::endl; return *this; std::ostream & operator<< (std::ostream &os, const Int &n)

367 A Debreceni Egyetem programozói évkönyve 337 / 404 os << * (n.ertek); return os; mellett mik fognak lefutni a következő programokban? A nyomkövető kimenetek alapján válaszolj! /source/labor/kartyak/Int4/main.cpp #include "int.h" int main() Int a(4), b(2); std::cout << a << " " << b << std::endl; std::swap(a, b); std::cout << a << " " << b << std::endl; return 0; Rule of Five A következő../source/labor/kartyak/int5/int.h #ifndef INT H #define INT H #include <iostream> #include <utility> class Int public: static int bogocounter; Int ( int n = 0 ) : ertek ( new int ( n ) ) bogoc = bogocounter++; std::cout << "-- Int ctor " << bogoc << ". " << *ertek << " " << this << " " << ertek << std::endl; Int ( const Int &n ) : ertek ( new int ) bogoc = bogocounter++; *ertek = * ( n.ertek ); std::cout << "-- Int masolo ctor " << bogoc << ". " << *ertek << " " << this << " " << ertek << std::endl; Int ( Int && n ) : ertek ( n.ertek ) bogoc = bogocounter++; n.ertek = nullptr; std::cout << "-- Int mozgato ctor " << bogoc << ". " << *ertek << " " << this << " " << ertek << std::endl;

368 A Debreceni Egyetem programozói évkönyve 338 / 404 ~Int() std::cout << "-- Int dtor " << bogoc<< ". " << this << " " << ertek << std::endl; delete ertek; ; Int &operator= ( const Int &n ); Int &operator= ( Int && n ); int getval() const return *ertek; friend std::ostream &operator<< ( std::ostream &os, const Int &n ); private: int *ertek; int bogoc; ; #endif és../source/labor/kartyak/int5/int.cpp #include "int.h" int Int::bogoCounter = 0; Int &Int::operator= ( const Int &n ) int *ujertek = new int (); *ujertek = * ( n.ertek ); delete ertek; ertek = ujertek; std::cout << "-- Int masolo ertekadas "<< bogoc << ". " << *ertek << " " << this << " " << ertek << std::endl; return *this; Int &Int::operator= ( Int && n ) std::swap ( ertek, n.ertek ); std::cout << "-- Int mozgato ertekadas " << bogoc << ". " << *ertek << " " << this << " " << ertek << std::endl; return *this; std::ostream & operator<< ( std::ostream &os, const Int &n ) if ( n.ertek!= nullptr ) os << * ( n.ertek ); else

369 A Debreceni Egyetem programozói évkönyve 339 / 404 os << "n.ertek->null"; return os; mellett mik fognak lefutni a következő programokban? A nyomkövető kimenetek alapján válaszolj! Próbáld ki a kódban kommentezett két kérdést is! /source/labor/kartyak/Int5/main.cpp #include "int.h" #include <vector> Int fgv ( Int n ) std::cout << std::endl << " Int fgv ( Int n ) " << std::endl; std::cout << n << std::endl; return Int ( 3 ); int main() std::cout << std::endl << " Int a( 4 ) " << std::endl; Int a ( 24 ); std::cout << std::endl << " Int b = fgv ( a ) " << std::endl; Int b = fgv ( a ); std::cout << std::endl << " v.push_back ( c ) " << std::endl; std::vector<int> v; v.reserve ( 10 ); // Miért kell most ide? Int c ( 111 ); v.push_back ( c ); std::cout << std::endl << " v.push_back ( Int ( 222 ) ) " << std::endl; v.push_back ( Int ( 222 ) ); std::cout << std::endl << " v.push_back ( std::move ( c ) ) " << std::endl; v.push_back ( std::move ( c ) ); std::cout << std::endl << " c = a " << std::endl; c = a; std::cout << std::endl << " a = std::move( c ) " << std::endl; a = std::move ( c ); std::cout << std::endl << " Int d = std::move ( b ) " << std::endl;

370 A Debreceni Egyetem programozói évkönyve 340 / 404 Int d = std::move ( c ); std::cout << std::endl << " std::swap( a, b ) " << std::endl; std::cout << "a=" << a << " b=" << b << " c=" << c << std::endl; std::swap ( a, b ); // Mi lenne a helyzet ezzel: swap ( a, c ) std::cout << "a=" << a << " b=" << b << " c=" << c << std::endl; std::cout << std::endl << " " << b << std::endl; return 0;

371 A Debreceni Egyetem programozói évkönyve 341 / fejezet Laborkártyák kidolgozása A laborkártyák kidolgozása ugyanúgy zajlik, mint a feladatok kidolgozása, de ezeket csakis tutor rendszerben lehet kidolgozni. A pontozás tekintetében legyen 3 pont egy igényes kidolgozás (természetesen nem mennyiségre, hanem minőségre, pl. nyelvi kérdésekben belinkelve a kapcsolódó C++11-es draft megfelelő részét. (A deklarációs kártyás legyen 5 pont, mert az picit talán munkásabb). Illetve ugyanilyen pontozással lehet az előadások végéről átenni a laborkártyákat is, azaz nemcsak a kidolgozást pontoznám, hanem az átvételüket is az előadások végéről; persze ha itt van valami kétség, hogy már pl. deprecated, vagy milyen főcím alá kéne tenni az adott kártyát akkor az megér egy beszélgetést a fórumokon.

372 A Debreceni Egyetem programozói évkönyve 342 / Bevezető laborkártyák A parancssori interfész (CLI) alapvető használata A kézikönyv Megoldások és megjegyzések A man és az éppen vizsgált parancsszó között megadott szám az aktuális manual egy bizonyos szekcióját fogja csak kiprintelni. Ha nem adunk meg számot, default az összes(elérhető) szekció megjelenítésre kerül. Bővebben: man man man is the system s manual pager. Each page argument given to man is normally the name of a program, utility or function. The manual page associated with each of these arguments is then found and displayed. A section, if provided, will direct man to look only in that section of the manual. The default action is to search in all of the available sections following a pre-defined order ("1 n l posix 3pm 3perl " by default, unless overridden by the SECTION directive in /etc/manpath.config), and to show only the first page found, even if page exists in several sections. The table below shows the section numbers of the manual followed by the types of pages they contain. 1 Executable programs or shell commands 2 System calls (functions provided by the kernel) 3 Library calls (functions within program libraries) 4 Special files (usually found in /dev) 5 File formats and conventions eg /etc/passwd 6 Games 7 Miscellaneous (including macro packages and conventions), e.g. man(7), groff(7) 8 System administration commands (usually only for root) 9 Kernel routines [Non standard] Készítette: Kovács-Ferenc Norbert, tutor: Bereczki László A fordítóprogram Megoldások és megjegyzések A kód azért nem fordul, mivel a ciklus változót a ciklusmagon belül hozza létre. Ez a fajta inicializálás elfogadott az ISO/IEC 9899:1999 szabvány szerint. Ahhoz, hogy ezt a szabványt használni tudjuk, jeleznünk kell a fordítónak. Ezt a -std=c99 kapcsolóval érhetjük el. Készítette: Kovács-Ferenc Norbert, tutor: Bereczki László

373 A Debreceni Egyetem programozói évkönyve 343 / Vektorizálás A kapcsolatszerkesztő program Megoldások és megjegyzések Nem fordul, mivel linkelni kell a math librayt, a -lm kapcsolóval. Ennek oka, hogy bár a math standard librarynek minősíthető, történelmi és hardveres indokok miatt, mégsem implicit kerül linkelésre, mint pl. a libc. Miután kézileg explicit módon linkeltük, az ldd függőség megjelenítő utasítással nyomon is követhetjük a hatását. linux-vdso.so.1 => (0x00007fff981fe000) libm.so.6 => /lib/x86_64-linux-gnu/libm.so.6 (0x00007fefd5e1d000) libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fefd5a55000) /lib64/ld-linux-x86-64.so.2 (0x00007fefd613f000) Készítette: Kovács-Ferenc Norbert, tutor: Bereczki László Az alapvető C és C++ nyelvi konstrukciók használata Nevek bevezetése a programba for először Megoldások és megjegyzések Laborkártyához../source/labor/kartyak/ciklus.cpp eléréssel kidolgozás feltöltve. Kovács-Ferenc Norbert, tutor: Bereczki László Nagyon tetszik a megközelítésetek: a generált assembly kód összehasonlítása, de azt indokolatlannak tartom, hogy ezt system hívásokban intézitek, simán lehetett volna parancssorban csinálni és itt egy screen elemben bemutatni, Bátfai Norbert. Úgy gondoltam, jó ha ilyet is látnak az emberek. De elkészítettük a screen-es verziót is: xyro@oblivion:~$ echo "int main() for(int i=0;i<3;++i); return 0; " > xyro@oblivion:~$ g++ pp.c -o ppi -S xyro@oblivion:~$ echo "int main() for(int i=0;i<3;i++); return 0; " > xyro@oblivion:~$ g++ pp.c -o ipp -S xyro@oblivion:~$ diff ipp ppi -s Files ipp and ppi are identical xyro@oblivion:~$ pp.c pp.c - Bereczki László for másodszor Megoldások és megjegyzések Laborkártyához../source/labor/kartyak/ciklus2.cpp eléréssel kidolgozás feltöltve. Kovács-Ferenc Norbert, tutor: Bereczki László

374 A Debreceni Egyetem programozói évkönyve 344 / for harmadszor Megoldások és megjegyzések Laborkártyához../source/labor/kartyak/ciklus3.cpp eléréssel kidolgozás feltöltve. Kovács-Ferenc Norbert, tutor: Bereczki László if először if másodszor Az előbbi esetében b-t a logikai vizsgálat eredményével fogja maszkolni, míg az utóbbinál a maszkolást követően megnézi, hogy az eredmény 0-e. Lásd: [STROUSTRUP] 164. oldal. Megoldások és megjegyzések A megoldást készítette Kovács-Ferenc Norbert, Bereczki László(tutor) while Megoldások és megjegyzések Laborkártyához../source/labor/kartyak/while.cpp eléréssel kidolgozás feltöltve. Kovács-Ferenc Norbert, tutor: Bereczki László const A konstans kulcsszó biztosítja a felhasználót, hogy a másolandó memóriaterület nem fog megváltozni a függvény során. STRCPY(3) Linux Programmer s - Manual STRCPY(3) NAME strcpy, strncpy - copy a string SYNOPSIS #include <string.h> char *strcpy(char *dest, const char *src); char *strncpy(char *dest, const char *src, size_t n); DESCRIPTION The strcpy() function copies the string pointed to by src, including the terminating - null byte ( \0 ), to the buffer pointed to by dest. The strings may not overlap -, and the destination string dest must be large enough to receive the copy.

375 A Debreceni Egyetem programozói évkönyve 345 / 404 Megoldások és megjegyzések Laborkártyát kidolgozta Kovács-Ferenc Norbert, tutor: Bereczki László char * C-ben a működése egyértelmű. Ráállítja a p mutatót a literálra. Ekkor a p mint string átadja az egész szöveget, de hivatkozhatunk annak csak egy-egy karakterjére is. char *p = "alma"; printf("%s", p); // "alma" printf("%c",*(p+1)); // l Amennyiben viszont C++-ban akarjuk fordítani, verziótól függően hibákba futhatunk. A leggyakoribb warning message amit kaphatunk, az az értékadás "elavult" mivoltára figyelmeztet: foo.cpp: In function int main() : foo.cpp:5:12: warning: deprecated conversion from string constant to char* [-Wwrite- - strings] char *p = "alma"; Ez érthető, hiszen mi sem akarjuk, hogy az eredeti memória terület módosuljon. Bár a warning ellenére a kód lefordul, ha biztosak akarunk lenni abban, hogy nem lesz az értékadásnak semmilyen mellékhatása(és el szeretnénk tüntetni a warningot) akkor egy egyszerű const kulcsszóval megoldhatjuk. Persze a kasztolás is rendelkezésre áll, ha biztosak vagyunk a dolgunkban. const char *q = "alma"; char *p = (char*)"alma"; std::cout<<p<<" "<<q; //alma alma Megoldások és megjegyzések Laborkártyát kidolgozta Kovács-Ferenc Norbert, tutor: Bereczki László Paraméterátadás A szabad tár kezelése char **

376 A Debreceni Egyetem programozói évkönyve 346 / 404 IV. rész Évkönyv

377 A Debreceni Egyetem programozói évkönyve 347 / fejezet A 2013/14 tanév A tavaszi szemeszter, avagy a prog1 Ebben a fejezetben magunkat mutatjuk be, ismerjük meg. Első lépésként, önbevallási alapon mindenkinek be kell sorolnia magát a következő kategóriákba 1, ez szabályozza, hogy milyen feladatok megoldásai után járó pontokat számolhat el a hallgató. Ha ez megvan, egészítsd ki például az én bio-m mintájára a sajátodat: mindenképpen legyen benne, hol születtél, hol jártál középiskolába, mi az érdeklődési területed, milyen díjakat kaptál, a kurzusban voltál-e egy adott feladat kapcsán tutor vagy tutoriált, ha igen kivel, melyik feladat kapcsán, beszállsz-e a prog1 robotfoci bajnokságba, kupába; s bármit, amit csak fontosnak érzel szakmai szempontból! Miért? Mert ezek az adatok lesznek az alapjai azoknak a következő érdekes feladatoknak, amelyekben valóban magunkat vizsgáljuk. Ismertetjük a feladatokat, amelyek megoldásait majd az évfolyam bemutatkozása után szerepeltessük a Gnoti se auton pontban Az évfolyam legfontosabb hallgatói - tutor rendszer Kik az évfolyam kulcshallgatói? A következő bio-k tutor-turoriált kapcsolataiból készíts egy Google-mátrixot, ahol a linket így absztraháld: attól a hallgatótól mutat, akit tutoriál, arra, aki tutoriálja. Majd futtasd a második laboron írt PageRank programot és ezzel állítsd sorrendbe az évfolyam hallgatóit! Ez a feladat 2014 március 23-án indul és a szorgalmi időszakban 2 hetenként különböző hallgató ismételheti meg a mérést. Az eredmény listákat ennek a fejezetnek a végén ismertessük. A listák mellé készíts a Graphviz programmal egy gráfot is a mátrixból, ahol a csomópontok a személyek, az élek a megadott irányítással a tutoriálások. A csomópontok mérete függjön a PageRank értéküktől! (15 pont a készítőnek és 10, 9, 8,..., 1 pont sorrendben az első tíznek az eredménylistáról) Az évfolyam legfontosabb hallgatói - feladatok megoldása Ismételd meg az előző mérést, de most a linkeket úgy értelmezd, hogy a feldatokat dolgozd fel közben: az eredeti kidolgozóra azok mutassanak, akik érintettek még a feladatban, azaz átnézték, javították, bug reportolták, alternatívát adtak stb Az évfolyam legfontosabb hallgatói - skillek Ismételd meg az előző mérést, de most a linkeket úgy értelmezd, hogy a bio-kból azt szűrd ki. ki-mit szeretne megismerni és kinek-miben van gyakorlata. A linkeket értelmezd úgy, hogy A személyből megy át a B-hez, ha az A szeretne olyat megismerni, amelyben a B-nek van gyakorlata Az évfolyam kapcsolatai A CompLearn csomag felhasználásával készítsd el az évfolyam hasonlósági gráfját a következő bio-k alapján! (10 pont) 1 A név mellett mindig tüntessük fel a pontszámot!

378 A Debreceni Egyetem programozói évkönyve 348 / Önbevallások és rövid bio-k ábra. Pillanatkép a 10. előadásról ábra. Pillanatkép a 11. előadásról

379 A Debreceni Egyetem programozói évkönyve 349 / ábra. Pillanatkép a 12. előadásról Hallgatók Kiemelkedő Haladó 1. Busák Zoltán, 2800 pont ábra. Nyíregyházán születtem án. A nyíregyházi Vasvári Pál Gimnáziumban végeztem a tanulmányaimat. Leginkább a számítógépes játékok fejlesztése érdekel. Tutoriáltjaim: Akai József Zsolt, Ozsváth Jonathán, Kistamás Dávid, Monori Fanny, Gyügyei Tamás. 2. Fülöp Sándor, 1824 pont

380 A Debreceni Egyetem programozói évkönyve 350 / ábra. Budapesten születtem én. Egerben a Neumann János Középiskola és Kollégiumban végeztem a középiskolai tanulmányaimat. Az informatikát és programozást a játékok miatt szerettem meg, ez a szeretet tart mind a mai napig. Tutoriáltjaim: Seles Péter, Kistamás Dávid,Akai Zsolt,Tamics Ádám,Tóth Máté,Szentpéteri Annamária,Fenesi Gábor,Balkus Gergő. 3. Gálffy Tamás, 96 pont ábra. soon... Nagykanizsán született án, majd rá pár évre költözött Felvidékre. Ott tanult magyar tannyelvű iskolákban ( igen, vannak ), végül a Vámbéry Ármin Magyar Tannyelvű Nyolcosztályos Gimnáziumban érettségizett. A programozás első sorban a játékok miatt kezdett el érdekelni, majd egy idő után megtetszett az a ( több-kevesebb sikerrel ) ismétlődő pillanat, amikor hirtelen közös megértésre jutunk a géppel és az történik amit várok. Mintha minden a helyére kattanna és stabilan ott is maradna. Mint a robusztus és kompakt kódokkal. Főképp a grafikus programozás érdekelt, viszont érdekesnek találom az ehhez lazábban kapcsolódó dolgokat, pl. procedurálisan generált képek/modellek, valamint AI, hálózati programozás. Tutoráltam Ács Raymund. Egy Game Maker nevű programmal kezdtem, ami bevezetésnek jónak bizonyult. Többet dolgoztam C++-al, kacsintgattam a webfejlesztés felé ( PHP, JavaScript, SQL ), valamint kísérletezgettem pár egyéb nyelvvel ( Python, AutoIt ). 4. Kolozsvári Dávid Roland (409 pont) ábra. Születtem 1994-ben, Nagyváradon, majd itt jártam középiskolába, a nagyváradi Ady Endre elméleti líceumba, ahol matematika-informatika intenzív informatika szakon végeztem. Az iskolában Pascalt tanítottak, de 10-ik osztály végén már kevésnek éreztem, ezért autodidakta módon elkezdtem C-t majd C++-t tanulni, közben ismerkedtem a C#-pal is. Tanulás közben az OpenGL körül kezdtem érdeklődni, majd megszerettem, így a jövőben szeretném bővíteni és elmélyíteni

381 A Debreceni Egyetem programozói évkönyve 351 / 404 a grafikus motorok programozásához szükséges tudásom. Az egyetemi éveimtől azt várom, hogy ezen célom elérésében segítsen, majd a diploma megszerzése után olyan helyen foglalhassak állást, ahol tovább foglalkozhatok avval amit szeretek. Éppen ezért ezen tantárgy pontversenye különösebben nem igazán érdekel, viszont a tutor rendszerben szívesen részt veszek, szeretek segíteni másoknak, megosztani azt amit tudok és eközben tanulni új dolgokat. Tutoriáltjaim: Fábián Kristóf, Kádár Gergely. 5. Takác Ján (204 pont) ábra. Pozsonyban születtem 1990-ben, majd Fülek városában jártam általános iskolába. A salgótarjáni Madách Imre gimnáziumban érettségiztem. A Pascal nyelvel 13 éves koromba futottam először össze és 15 évesen a C++ nyelvel. Gimnáziumban nem tanítottak nekem programozást csak saját erőből tanultam. Főleg a valós idejű grafika iránt érdeklődöm és a párhuzamos rendszerek működése köti le az érdeklődésem. Tutoriáltam: Csermely Attila Közepes 6. Bereczki László, 2100 pont ábra. Egyetemi státuszomat az ELTE informatikai karának PTI szakán kezdtem meg 2008-ban. Tanulmányaimat félbe kellett szakítanom, így a debreceni egyetemen tervezem a diploma befejezését. A két egyetem között dolgoztam C++, java és HTML programozóként, valamint mobil szoftvereket is fejlesztettem. Sohasem szerettem a "gányolás" jellegű programozást, viszont mindig is kedveltem a rétegesen felépített program struktúrákat - c++, ada, funkcionális nyelvek. Különösebben nem diszkriminálok semmilyen jellegű programozási feladatot a jövőre nézve. Elsősorban valós, tényleges problémákkal szeretnék foglalkozni. Motivátor a bioinformatika, játékfejlesztés, valós mesterséges intelligencia, közösségi oldalak valamint a modern technológiák. Tutoráltam: Szentpéteri Annamária, Kovács-Ferenc Norbert, Preznyák László, Madar József, Akai Zsolt, Zelina Zsolt, Márton Ákos, Nagy János, Mucsina Dávid Csaba, Tamics Ádám, Bak Balázs, Szentmiklósi Nikolett, Deregi Diána és Pop Richárd. 7. Csermely Attila (124pont)

382 A Debreceni Egyetem programozói évkönyve 352 / ábra. Miskolcon születtem 1994-ben. Középiskolába Tiszaújvárosba, az Eötvös József Gimnáziumba jártam és itt ismerkedtem meg a pascal és a C++ programozási nyelvekkel. Általában érettségi és verseny feladatokat csináltunk de pascalban a BGI grafikával is foglalkoztam. A tutor rendszerben részt veszek tutoriáltként, a tutorom pedig Takács János. 8. Dalmadi Zoltán, 3107 pont ábra ben érettségiztem a debreceni Beregszászi Pál Szakközépiskolában, majd 2 év múlva számítástechnikai műszerész szakmával indultam neki a nagybetűs életnek. Először szabadúszó, majd alkalmazott flash fejlesztőként dolgoztam. Később az informatika sok területén autodidakta módon bővítettem tudásomat. Érdeklődési köreim: multimédia, webes technológiák, látványos grafikus és tudományos alkalmazások, user interface design. Tutoriáltjaim: Nagykéri Bence, Kunkli Attila, Balogh István Dávid, Ozsváth Jonathán, Orbán István. 9. Eszenyi Gábor (164 pont) ábra. A középiskolai tanulmányaimat a debreceni Tóth Árpád Gimnáziumban végeztem, itt emelt szinten tanultam matematikát, fizikát és informatikát. Szabadidőm egy részét mobilalkalmazások fejlesztésével töltöm, illetve az egyetem mellett ios fejlesztőként dolgozom. A tutor rendszerben részt vettem Tóth Máté és Tamics Ádám tutoriáltjaként. 10. Fábián Kristóf - Szabolcs (414 pont )

383 A Debreceni Egyetem programozói évkönyve 353 / ábra. Nagyváradon, 1994-ben születtem. Középiskolai tanulmányaimat a nagyváradi Ady Endre elméleti líceumban, matematikainformatika, intenzív informatika szakon végeztem, ahol leginkább Pascalt tanítottak, ami valahogy nem igazán keltette fel az érdeklődésem, később kis C# -ot is tanítottak, de amikor elkezdett jobban érdekelni maga a programozás, akkor beletekintettem a C nyelvbe, illetve néhány C++ feature -t is használtam. Még egyetemi tanulmányaim elkezdése előtt kicsit megismerkedtem az OpenGL-lel, ami meg is tetszett akkor, és a jövőben is szeretnék foglalkozni vele komolyabban. Most második félévben, az egyik feladat során felkeltette az érdeklődésem az OpenCV, amit szépen lehet használni a 3D programozással együttesen, ezért úgy érzem, hogy lesz mivel kísérletezgessek. Sokat kell még tanulnom, de ami érdekel, arra sok időt tudok szánni. A tutor rendszerben részt veszek, leginkább, mint tutoriált a binomom által. 11. Haraszti Péter Brúnó Attila (842 pont) ábra. Debrecenben, az Ady Endre Gimnáziumban tanultam. A programozásban és számítástechnikában még specifikus érdeklődési köröm nincs, szeretek több dologgal is foglalkozni. Tutor rendszerben részt veszek mint tutoriált, Szabó Attila tutoriálása alatt. Ezen felül Forgács Péter tutorja is vagyok. 12. Kakócz Erik, 78 pont ábra. Nyíregyházán születtem án. A Váci Mihály Gimnáziumban végeztem tanulmányaimat Tiszavasváriban, ahol középszintű informatika érettségit szereztem. Ami a leginkább érdekel: a számítógépes játékok fejlesztése, azon belül is (valamint amellett) a hálózati kommunikáció. 13. Nagy Gábor (~161 pont)

384 A Debreceni Egyetem programozói évkönyve 354 / ábra. A középiskolai tanulmányaimat a debreceni Brassai Sámuel Gimnáziumban végeztem. Szabadidőm egy részét új programozási ismeretek elsajátításával töltöm, illetve az egyetem mellett Web fejlesztőként dolgozom. 14. Nagy Sándor (178 pont) ábra. Hajdúnánáson születtem, a helyi gimnáziumban érettségiztem. Egy web-programozó felsőfokú szakképzésből a munkaerőpiacra lépve céges portálok építésével és fejlesztésével foglalkoztam, de nem találtam meg benne a kellő szakmai kihívást, ezért abban a reményben, hogy a felsőoktatási környezet izgalmasabb problémák elé állít, magasabb fokú végzettség megszerzése céljából megkezdtem egyetemi tanulmányaimat. Nem volt még tutoriáltam a kurzus során. 15. Szabó Attila, 850 pont ábra. Hajdúböszörményben születtem, Hajdúnánáson tanultam a Kőrösi Csoma Sándor Gimnáziumban. Jó algoritmizálási rutinnal rendelkezem, az egyetemi éveim alatt, a meglévő tudásomhoz szeretnék gyakorlati hátteret szerezni. Az adatbázis programozás és a játékfejlesztés érdekel. Tutor rendszerben eddig Tuza József és Haraszti Péter tutoráltal dolgoztam együtt. 16. Szilágyi István Tamás, 61 pont

385 A Debreceni Egyetem programozói évkönyve 355 / ábra. Nagyváradon születtem, január 6-án. Középiskolába Nagyváradon, az Ady Endre Elméleti líceumba jártam, matematika-informatika, intenzív informatika szakon. A négy tanév alatt foglalkoztunk Pascal és C# programozási nyelvekkel, bár utóbbival csupán az utolsó évben. Programozásomat, a Game Maker nevű programban kezdtem el, az fogott meg engem igazán, és így került el ide, az IK-ra. A célom az, hogy saját független játékfejlesztő céget vezethessek. Ha a cég valaha nagy sikerű is lenne, akkor se állna szándékomban, hogy hatalmas kiadóknál dolgozzon a cég, mert a kiadók "megmérgezik" és "megfojtják" a fejlesztők szabadságát, művészi kifejező képességüket. Tutoriáltam és tutorom még nem volt. 17. Fenesi Gábor ábra. Miskolcon születtem 1994.február 3.-án. Tutorom: Fülöp Sándor 18. Balkus Gergő ábra. Debrecenben születtem november 24-én. Középiskolába a debreceni Csokonai Vitéz Mihály Gimnáziumba jártam emelt matematika és informatika szakra, ahol emelt szintű informatika érettségit tettem. Középiskolai éveim második felében a C nyelvvel foglalkoztam. Tutorom: Fülöp Sándor 19. Tóth Máté (1400,5 pont)

386 A Debreceni Egyetem programozói évkönyve 356 / ábra. Mezőtúron születtem, informatika szakra jártam. Otthon magam tanultam C/C++. Eddig játékemulátorokkal foglalkoztam. A jövőben szeretném a C++ alaptudásom tovább bővíteni. Tutoriáltaim: Tamics Ádám, Eszenyi Gábor, Birizdó Kristóf Kezdő 20. Abai Richárd, 245 pont ábra. Debrecenben születtem, Hajdúböszörményben élek. A Veress Ferenc Szakképző Iskolában, Informatika szakon végeztem. A programozás elég alap szinten folyt - egy nagyon kicsi Pascal, majd C++ volt. Célom, hogy kompetens szoftverfejlesztő legyek. Különösképpen az Android fejlesztés érdekel. Engem tutorált: Kistamás Dávid, Szőcs Gábor. Én tutoráltam: Veress Ármin, Balogh János Csaba. 21. Akai József Zsolt, pont ábra. Debrecenben születtem, a Debreceni Református Kollégium Gimnáziumába jártam, informatika szakon végeztem. Informatikából emelt szintű érettségit tettem. Érdeklődési köreim a játékfejlesztés, a mesterséges intelligencia, robot-drón programozás és a modern informatikai technológiák. Elsősorban valós, mindennapi problémákkal szeretnék foglalkozni. Egyetemi éveim alatt szeretnék piacképes tudást szerezni. Tutor rendszerben részt vettem mint tutor és mint tutoriált is. A robotfoci kupában és a bajnokságban Hall of Fame of Programmers FC csapattal vettem részt.

387 A Debreceni Egyetem programozói évkönyve 357 / Török Antal (273 pont) ábra. Tutor rendszerben Sipos Ferenc a tutorom 23. Apró Anikó (54 pont) ábra. Hajdúböszörményben születtem, itt is élek. A hajdúböszörményi Bocskai István Gimnáziumban végeztem nyelvi előkészítő tagozaton Programozásban nem vagyok gyakorlott, azonban a célom az, hogy minél magasabb szinten megtanuljak programozni és később ezt a tudást kamatoztatni szeretném. A tutor-rendszerben még nem vettem részt 24. Ács Raymund (607 pont) ábra. Nyíregyházán születtem án. Középiskolai tanulmányaimat a kisvárdai Bessenyei György Gimnázium és Kollégium Arany János Tehetséggondozó Programjában végeztem. Hobbim a zenélés és programozás. Tudok gitározni, basszus gitározni, 3 évig volt is egy zenekarom amivel az ország több pontjára is eljutottunk. A programozás, főlek online játékok módosítása mindig is érdekelt. Már 14 évesen saját COD2 szerverem volt a saját játékmódommal. 17 évesen kezdtem belemélyülni egy MMORPG-be, olyannyira, hogy több éve van szerverem egy kisebb csapattal. Az online játékok világában tudom elképzelni a jövőmet, mint programozó/szerver adminisztrátor. Tutorjaim Gálffy Tamás és Bereczki László. 25. Badó Gergely József (142 pont)

388 A Debreceni Egyetem programozói évkönyve 358 / ábra. Kárpátalján, Ungváron születtem, a Beregszászi járás egy kis falújában Hetyenben élek. A Kaszonyi Középiskolában érettségiztem. Programozás terén kezdőnek vallom magam, célom pedig tovább fejleszteni képességeimet. Az első nyelv amit kissé komolyabban megismertem a C programozási nyelv. A tutor rendszerben ezidáig nem vettem részt, a felmerülő kérdéseket a binomommal tárgyaltuk. 26. Pajkossy Ottó (105 pont) 27. Bak Balázs (291 pont) ábra ábra. Debrecenben születtem, Balmazújvároson lakom. Középiskolába a balmazújvárosi Veres Péter Gimnáziumba jártam. Programozásból nem vagyok gyakorlott. A célom hogy míg egyetemre járok megtanuljak programozni. A tutor-rendszerben még nem vettem részt 28. Balogh István Dávid (309 pont) ábra ban születtem Debrecenben, Hajdúszoboszlón élek. A debreceni Mechwart András Gépipari és Informatikai Szakközépiskolába jártam informatika szakra, ahol egy kevéske programozási tapasztalatot szereztem, illetve középfokú angol nyelvvizsgát tettem. Az érettségi után egy évet még a középiskolában töltöttem, ahol IT biztonság technikus oklevelet szereztem, ezután kerültem a Debreceni Egyetem Informatikai Karára.

389 A Debreceni Egyetem programozói évkönyve 359 / 404 Programozási tapasztalatom csekély, de igyekszek képezni magam. Tutor-rendszerben részt vettem, tutorjaim: Dalmadi Zoltán, Madar József. 29. Balogh János Csaba (476 pont fekete ponttal) ábra. Bihardiószegen születtem, jelenleg Debrecenben élek, Debrecenben a Szent József gimnáziumban érettségiztem, iskolámban c programozás alapjait sajátítottam el továbbá középfokú Angol nyelvtudással rendelkezem. Tutorjaim: Madar József, Szentpéteri Annamária, Abai Richárd, Nagy Sándor, Veress Ármin. 30. Bertalan Ádám 55 pont ábra. Nyíregyházán születtem, itt is jártam középiskolába a Széchenyi István Közgazdasági, Informatikai Szakközépiskolába Informatika szakon. Érdeklődési köreim: android szoftverfejlesztés, egyéb programfejlesztés. Egyetemi éveim alatt szeretném tudásomat olyan szintre fejleszteni amellyel el tudok helyezkedni ebben a szakmában. 31. Bodonyi Andrea - Beatrix 451 pont ábra ben születtem Szatmárnémetiben, és ott jártam középiskolába a Kölcsey Ferenc Főgimnáziumba. Matematikainformatika szakon voltam, ahol Pascal programozási nyelvet tanultam négy éven keresztül, a C és C++ nyelvek alapjait az egyetemen ismertem meg. Egyelőre kezdő szinten állok, de célom, hogy az egyetemi éveim után tapasztalt programozónak mondhassam magam. Jövőbeli terveim még nem pontosan körvonalazottak, hiszen kevés tapasztalatom van még, de ezt szeretnék szerezni a programozás minden terén, hogy aztán magabiztosan és céltudatosan tudjak dönteni. Tutorom Kistamás Dávid.

390 A Debreceni Egyetem programozói évkönyve 360 / Bodor Dávid, 11 pont ábra. Szatmárnémetiben, Erdélyben születtem és a Református Gimnázium matematika-informatika szakán tanultam. A megyei programozás olimpiaszon 3. helyen végeztem. Game Design, Játékfejlesztés érdekel, mesterizni is Game Designban szeretnék a jövőben de minden ami programozást jelent érdekel. Egyetemi tanulmányaim során fel szeretnék készülni, hogy szakomon belül állást tudjak majd vállalni. 33. Csuzi Gergely 22 pont ábra. Nyíregyházán születtem. Középiskolai tanulmányaimat Nyíregyházán a Zay Anna Egészségügyi, Informatikai Szakközépiskola és Kollégium Informatika Szakmacsoportjában végeztem el. Programozás terén az autóipar érdekel (fedélzeti számítógépek programozása) és minden olyan dolog amivel megkönnyíthető az emberek élete(okos házak). Nem vettem még részt a tutor programban a kurzus során. 34. Deregi Diána 490 pont ábra. Kisvárdán születtem 1994-ben, itt végeztem a középiskolai tanulmányaimat a Bessenyei György Gimnázium és Kollégium matematika tagozatán, az érettségi után Debrecenbe költöztünk. Még nem találtam meg a leginkább testhezálló érdeklődési kört, így a jövőbeli terveim még csak körvonalazódnak. Jelenleg az informatikára való rálátásomat szeretném bővíteni. Robotfocis feladatokban és egyéb felmerülő kérdéseknél tutoriált Bereczki László 35. Erdei Krisztián (56 pont)

391 A Debreceni Egyetem programozói évkönyve 361 / ábra. Hajdúnánáson születtem, többnyire ott is lakom. Középiskolába a hajdúnánási Kőrösi Csoma Sándor Gimnázium Szakközépiskolába jártam. Programozásból nem vagyok penge, egyelőre. A tutor-rendszerben még nem vettem részt. A robotfoci bajnokságon részt szeretnék venni.érdekelnek a mobilalkalmazások,3d grafika. 36. Farkas Tamás 130 pont ábra. 37. Fekete Attila (110 pont) ábra. Hajdúböszörményben születtem, itt is lakom. Középiskolai tanulmányaimat a Mechwart András Gépipari és Informatikai Szakközépiskola Informatikai csoportján végeztem. A 4 éves középiskolai képzés után +1 év IT Biztonságtechnikusi képzésen is maradtam ugyanitt. A programozás terén még kezdőnek számítom, középiskolában kezdő szinten tanultam HTML-t, Pascal-t, valamint Delphit. Célom az egyetemen hogy új programozási nyelveket sajátítsak el, egyetem után pedig ezt a tudást kamatoztatni tudjam egy informatikai cégnél. Még nem vettem részt a tutor-rendszerben. 38. Fekete Sándor (3213 pont)

392 A Debreceni Egyetem programozói évkönyve 362 / ábra ben születtem Debrecenben, a püspökladányi Karacs Ferenc Gimnáziumban érettségiztem. Programozással először itt az egyetemen találkoztam először, középiskolában semmilyen nyelvet nem oktattak. Érdeklődési köröm: az Android operációs rendszer, a virtuális-kiterjesztett valóság, a történelem és a számítógép fizikai komponenseinek cserélgetése. A félév során saját robotfoci csapatot készítettem A tutor rendszerben eddig nekem segítettek mint tutorok: Veress Ármin és Kolozsvári Dávid. 39. Forgács Péter pont ábra. A debreceni Fazekas Mihály Gimnáziumba jártam hat évfolyamos matematika-informatika osztálya. Itt tanultam egyszerű C++ nyelvet. Érdeklődök a matematika iránt, a programozásban a matematikai jellegű feladatokat kedvelem. Haraszti Péter a tutorom. Robotfoci csapatom a McTipszmiksz. 40. Gégény István (200 pont) ábra. Mátészalkán születtem. Nagyecseden élek. Fehérgyarmaton érettségiztem. Programozás terén totál kezdő vagyok. Egyetemen szeretnék C-ben és C++-ban biztos tudást szerezni. De a jövőt még nem látom tisztán. A tutor rendszerben részt vettem. Tutorjaim: Bodonyi Andrea-Beatrix, Laczka Zoltán, Akai Zsolt. 41. Gyügyei Tamás (887.4 pont) ábra.

393 A Debreceni Egyetem programozói évkönyve 363 / 404 Debrecenben születtem. Középiskolába a Debreceni Beregszászi Pál Szakközépiskolába jártam. Itt szereztem egy Műszaki Informatikus OKJ-s szakképesítést. Programozási téren, PHP és MYSQL területén van gyakorlatom. Tutor rendszerben segitettek: Busák Zoltán Tutoriáltjaim: Veress Balázs, Hegyes Tibor 42. Hegyes Tibor 131 pont ábra. -Születési év: Születési helyem: Nyíregyháza -A Széchenyi István Közgazdasági és Informatikai Szakközépiskola. -Érdeklődök a grafika és a mozgás dinamika lemodellezése iránt. Kezdő programozónak tartom magam, de még fejlesztem magam. Tutor-rendszerben részt vettem, tutorjaim: Szabó Bence és Gyügyei Tamás. 43. Horváth Dániel ábra ben, Debrecenben születtem. A debreceni Péchy Mihály Építőipari Szakközépiskolában érettségiztem le, de rájöttem, hogy az informatika jobban érdekel. Körülbelül ekkor készítettem el első weboldalam, mely meglepően nagy népszerűséget ért el. Rájöttem, hogy ebből pénzt is csinálhatok. Azóta már sok mindent kipróbáltam, jelenleg egyéni vállalkozóként dolgozom. Területeim: HTML, PHP, MySql, Javascript, CSS, valamint érdekel az internetes marketing és közösségépítés. Tutor programban még nem vettem részt, binomom NagyJános. 44. Iványi-Nagy Gábor, 62 pont ábra. Karcagon születtem,ahol a Karcagi Nagykun Református Gimnáziumba jártam,emelt matek-fizika szakon végeztem. Egyetemi éveim alatt szeretnék kimagasló tudást szerezni főként az objektumorientált programozási nyelvekből.

394 A Debreceni Egyetem programozói évkönyve 364 / Jakab Ádám 184 pont ábra. Nádudvaron születtem 1993-ban. Érettségi bizonyítványomat Hajdúszoboszlón szereztem meg a Hőgyes Endre Gimnázium és Szakközépiskola informatikai szakán. Programozás terén a webes nyelvek érdekelnek igazán, de szeretnék minden téren otthon lenni. Tutorjaim: Akai Zsolt, Kistamás Dávid, Tamics Ádám. 46. Józan Csaba 1100 pont ábra. Csaba vagyok, külföldről (Ukrajna,Kárpátalja) érkeztem. A Nagyberegi Ref. Líceum után jöttem ide a Debreceni egyetemre, hogy fejleszthessem tudásom a programozás terén. A középiskolában Pascallal foglalkoztunk, C++ ban elég kezdő vagyok még, de nagyon érdekelnek az objektumorientált nyelvek, mint a C++ is. Az egyetem elvégzése után, ha van lehetőség szeretnék valamilyen cégnél elhelyezkedni programozóként. Itt vagy Ukrajnában. 47. Kádár Gergely Sándor (129 pont) ábra. Nagyváradon születtem 1994-ben, a Nagyváradi Ady Endre Elméleti Líceumban tanultam matematika-informatika, intenzív angol szakon, 2013-ban végeztem. Az iskolában várakozásaimhoz képest elég kevés programozást tanultunk, saját kedvtelésből foglalkoztam a Game Maker nevezetű, kezdőknek való, játékfejlesztő szoftverrel, főleg a hozzá tartozó programozási nyelvvel. Itt, az egyetemen, szeretnék minél több C és C++ tudást szerezni. Foglalkoztat a játékfejlesztés (ahogy látom, még sokakat itt a szakon) és az ötletes felhasználói szoftverek. De igazából sok mindenhez meg tud jönni a kedvem, például a robotfoci is érdekel, csak kell még tanuljak. Nem vettem még részt a tutor programban a kurzus során.

395 A Debreceni Egyetem programozói évkönyve 365 / Kis Dávid, ~1219 pont ábra. Ukrajnában, Kárpátalján, Gyula nevezetű községben születtem 1995-ben. Középiskolai tanulmányaim a Péterfalvi Református Líceumban töltöttem (Kárpátalján), érettségi bizonyítványt is itt szereztem. A gimiben nem foglalkoztunk programozással. Talán az oktatás fejletlensége, talán a gimi szűk látókörűsége miatt; viszont mindig is érdekelt az informatika, így érdekeltségből Pascal-ban programoztam. Pont emiatt indult nehezen a félév, de nyitott vagyok az új dolgokra így remélem minél előbb sikerül elmerülnöm C, C++-ban illetve a tantervnek megfelelő témákban. Kifejezetten hasznosnak, és érdekesnek találom a prog 1-et főképp a Git, DocBook miatt. Tettszik a közös munka, hogy fejlesztői munkahelyhez hasonló környezetet teremtünk és többen dolgozunk ugyanazon project-en. Első C programokkal, lexikális elemzéssel, rendszerprogramozással, párhuzamos programozással, MINIX kernellel kapcsolatban is oldottam meg feladatokat. A továbbiakban még robotfocival, illetve a képfeldolgozó programokkal kapcsolatos feladatokkal szeretnék foglalkozni. A Bajnokságon illetve a Kupán is részt vettem a csapatommal! (FC Kumar) A tutoriáltjaim: Józan Csaba, Balogh István Dávid. 49. Kistamás Dávid, 2126 pont ábra. Miskolcon születtem, 1992-ben. Szerencsen lakom, de az egyetemista éveim nagy részét Debrecenben töltöm.az alábbi programozási nyelvekkel foglalkoztam már korábban: C, C++, Java (csak belekóstoltam, mert hajt a kíváncsiság). A szerencsi Bocskai István Gimnáziumban végeztem angol-informatika szakon. A játékfejlesztés és a robotfoci is nagyon érdekes számomra, de a legjobban ami érdekelne, az az Android programozás, Android szoftverfejlesztés. Tutor rendszerben részt veszek, tutorként és tutoriáltként is. Tutoriáltjaim: Nagy Dávid, Madar József, Laczka Zoltán, Akai József Zsolt, Varga Gábor és Bodonyi Andrea-Beatrix. Tutoriáltak: Busák Zoltán és Fülöp Sándor. 50. Konyári László, 115 pont

396 A Debreceni Egyetem programozói évkönyve 366 / ábra. Debrecenben születtem, 1995-ben. Középiskolai tanulmányaimat a Debreceni Baross Gábor Középiskola, Szakiskola informatika szakán végeztem, itt ismerkedtem meg a Pascal nyelvvel. Tutor rendszerben még nem vettem részt. Érdeklődési köreim főleg az objektumorientált programozási nyelvek, de nem köteleztem még el magam. Célom versenyképes tudás megszerzése. 51. Kovács-Ferenc Norbert, 1226 pont ábra. Dunaújvárosban születtem, középiskolai tanulmányaimat Egerben, a Wigner Jenő Műszaki, Informatikai Középiskola és Kollégium falai között fejeztem be emelt szintű informatika érettségivel. Programozást alap szinten tanultam, terveim között szerepel ezen tudás elmélyítése. A jövőben szeretnék külföldön ebben a szakmában elhelyezkedni. Tutorjaim Bereczki László és Madar József. 52. Kovács Gergely Zoltán - 49 pont ábra ben születtem Budapesten a VIII. kerületben, Abonyban lakom. Középiskolai tanulmányaimat a szolnoki Pálfy János Műszeripari és Vegyipari Szakközépiskolában kezdtem informatika szakon, de az iskola közben kétszer nevet váltott, így a SZOLMUSZ Pálfy-Vízügyi Tagintézményben végeztem. Szakmai tapasztalatom igen csekély, mivel az iskolában csak az emelt szintű érettségire való felkészítés volt a legmagasabb szintű általános képzés. Az MSc. diploma megszerzése után játékfejlesztéssel, illetve robotok mesterséges intelligenciájának fejlesztésével szeretnék foglalkozni. Nagy álmom, hogy az én kezem munkája is benne legyen a projectben, amikor az "Én, a robot" c. filmben lévő robotokat elkezdi fejleszteni az emberiség. 53. Kovács Roland (102 pont)

397 A Debreceni Egyetem programozói évkönyve 367 / ábra ban születtem Miskolcon, Putnokon élek. Kazincbarcikán végeztem a Surányi Endre középiskolában. Az érdeklődési köröm tág műszaki téren ám konkrétan a programozást emelem ki. A binomommal beszélünk meg gyakorlatilag minden informatikához és programozáshoz kapcsolódó témát. Az első programozási nyelv amit megismertem a C, ezen nyelv keretein belül oldottam meg eddig a legtöbb problémát ami elém került. 54. Kovács Ronald, 15 pont ábra. 55. Kozma Bettina (134 pont) ábra. 56. Kósa Gergő ábra.

398 A Debreceni Egyetem programozói évkönyve 368 / Kökéndy Tímea (352 pont) 58. Kunkli Attila (30 pont) ábra ábra. Debrecenben születtem 1993-ban, Kabán élek. A debreceni Mechwart András Gépipari és Informatikai Szakközépiskolába végeztem. Az érettségit követően további egy évet töltöttem ott, ahol IT biztonság technikus oklevelet szereztem, ezután jelentkeztem a Debreceni Egyetem Informatikai Karára. Kezdő programozónak tartom magam, de fejlesztem magam. Tutor-rendszerben még nem vettem részt. 59. Laczka Zoltán 432 pont 1994-ben születtem Szatmárnémetiben. A szatmárnémeti Kölcsey Ferenc Főgimnáziumba jártam középiskolába matematikainformatika szakra, ahol Free Pascalt tanultunk 4 éven keresztül, ebből van több tapasztalatom. C-vel es C++-szal az egyetemen találkoztam először. Tanulmányaim után mindenképpen olyan munkakörben szeretnék dolgozni aminek látványos eredménye is van pld: mesterséges intelligencia, robotprogramozás, játékfejlesztés. Tutorom Kistamás Dávid 60. Lécz Ildikó ábra ábra. Hajdúböszörményben születtem, a Veress Ferenc Szakképző Iskolába jártam, informatika szakon végeztem.

399 A Debreceni Egyetem programozói évkönyve 369 / 404 Érdeklődési köreim közé tartozik a mesterséges intelligencia. 61. Löki Tamás(26 pont :( ) ábra. Debrecenben születtem. A Bethlen Gábor Szakközépiskolában tanultam és itt is érettségiztem Célom hogy jó programozó legyek az egyetem végére. 62. Lukács Miklós, 23 pont ábra. Debrecenben születtem június 21-én. Középiskolás tanulmányaimat a Tóth Árpád Gimnáziumban végeztem. 63. Madar József, 1835 pont ábra. Debrecenben, a Mechwart András Gépipari és Informatikai Szakközépiskolában végeztem, ahol Pascal-t és Turbo Delphit tanultam. A jövőben robotokkal, drónokkal szeretnék foglalkozni. Tutoriáltjaim: Szentmiklósi Nikolett, Balogh István Dávid, Nagykéri Bence, Zelina Zsolt, Kovács-Ferenc Norbert, Veress Ármin, Balogh János Csaba. 64. Márton Ákos, 203 pont ábra.

400 A Debreceni Egyetem programozói évkönyve 370 / 404 Fehérgyarmatra jártam suliba, a programozás érdekelt, így választottam ezt a szakirányt, illetve ezzel is szeretnék elhelyezkedni. Cél az IT - services céghez való bekerülés. 65. Mohácsi Ádám László 106 pont ábra. Kiskunfélegyházán születtem, középiskolai tanulmányaimat is ott végeztem a Petőfi Sándor Gépészeti és Informatikai Szakképző Iskola és Kollégium hallgatójaként. Programozás terén abszolút kezdőnek tartom magam, hosszútávú célom ezért, hogy elsőre kisebb számú nyelven, de biztosabban programozzak. A tutor rendszerben eddig tutorált engem: Kovács-Ferenc Norbert, Akai József Zsolt, Bereczki László. 66. Monori Fanny 429 pont ábra ben születtem Karcagon.Itt végeztem el a középiskolát a Karcagi Nagykun Református Gimnáziumban. A C és C++ nyelvvel az egyetemen ismerkedtem meg. Célom az egyetemi évek alatt minél több téren tapasztalatot szerezni, hogy eldönthessem, hogy az informatika mely területével szeretnék foglalkozni a jövőben, mivel egyelőre nincsen konkrét elképzelésem ezt illetően. A tutorrendszerben már részt vettem, tutorom Busák Zoltán. 67. Mucsina Dávid Csaba, (112 pont) ábra. Pásztón születtem 1994-ben, a Kisterenyei Váci Mihály Gimnáziumban szereztem meg az érettségit. Az egyetemre kerülésemig még nem ismertem a programozást. Pontosan emiatt nincsen még semmilyen program nyelv amit előtérbe helyeznék, ezért is szeretném élesíteni a tudásom. Tutorom: Kovács-Ferenc Norbert. Binomom Zelina Zsolt. 68. Nad Sabolch, 122 pont

401 A Debreceni Egyetem programozói évkönyve 371 / ábra. Születési helyem Kárpátalja, a középiskolát a Péterfalvai Református Líceumban végeztem. 69. Nagy Dávid 5 pont ábra. 70. Nagy Dávid 2 pont ábra. Kisvárdán születtem, C-t tanultam a Szent László Katolikus Szakközépiskolában. Szabadidőmben szeretek olvasni, és zenélgetni. Komolyabb programokat még nem írtam. 71. Nagy Dávid 138 pont ábra. Berettyóújfaluban születtem 1994-ben.A Debreceni Református Kollégium Gimnáziumába jártam.az egyetemen előtt nem tanultam programozást. 72. Nagy Erik

402 A Debreceni Egyetem programozói évkönyve 372 / ábra. Kisvárdán születtem, Ukrajnában éltem egy kis faluban, melynek neve Gut. A Beregszászi Magyar Gimnáziumban tanultam, ahol Pascalban programoztunk. C++ -ban még mindig elég kezdő vagyok, de remélhetőleg sikerül majd felzárkóznom. Az egyetem elvégeztével szeretnék sikeres Android programozóvá válni. A tutor részben még nem vettem részt. 73. Nagy János József, 55 pont ábra. Debrecenben születtem, a Brassai Sámuel Gimnázium és Szakközépiskola informatika profilú osztályában végeztem. Emelt informatika érettségivel rendelkezem, ez az első egyetemem. A programozáson belül mindenre nyitott vagyok, és ezen a területen szeretnék később munkát találni. 74. Nagykéri Bence (303,5 pont) ábra. Debrecenben születtem, Hajdúszoboszlón lakok. Középiskolába a debreceni Mechwart András Gépipari és Informatikai Szakközépiskolába jártam. Ezután ott maradtam ötödéven, hogy IT Biztonság technikusi oklevelet szerezzek. Programozási téren elég szegényes a gyakorlatom. Célom, hogy egyetemi éveim során megtanuljak programozni. Tutorrendszerben részt vettem. Tutorok: Dalmadi Zoltán, Madar József. 75. Nagy Sándor ábra.

403 A Debreceni Egyetem programozói évkönyve 373 / Orbán István Sándor, 2190 pont ábra. Nyíregyházán születtem. A nyíregyházi Vasvári Pál Gimnáziumba végeztem, informatika szakon. Emelt szintű informatika érettségivel rendelkezem, továbbá OKJ-s képzés keretében webfejlesztést tanultam. Leginkább az objektumorientált programozást szeretném elsajátítani az egyetemi éveim alatt. Tutor: Dalmadi Zoltán 77. Oros Tibor 144 pont ábra ban születtem Karcagon. A kisújszállási Móricz Zsigmond Közgazdasági Szakközépiskola és Kollégiumban végeztem a középiskolás tanulmányaimat. Itt ismerkedtem meg a C és a C# nyelvekkel, de csak nagyon alap szinten. Célom, hogy munkaképes tudást gyűjtsek az egyetemi tanulmányi éveim alatt. Nem vettem még részt a tutor-rendszerben. 78. Ozsváth Jonathán (777 pont) ábra. Debrecenben születtem, a Debreceni Református Kollégium Gimnáziumába jártam középiskolába. A tutor rendszerben részt veszek, mint tutoriált. A robotfoci bajnokságban szeretnék részt venni, hiszen a foci amúgy is közel áll hozzám. Szakmailag pedig szeretnék elérni egy versenyképes tudást az egyetemi évek alatt.

404 A Debreceni Egyetem programozói évkönyve 374 / Pop Richárd László (103 pont) ábra. Bio: Székelyhídi Petőfi Sándor Elméleti Líceumban tanultam középiskolában, matematika-informatika szakon, itt C++ oktatásban részesültem, de nem az objektum, hanem az eljárás orientált részében. Érdekel az emberi tudat, neurális hálózatok illetve mesterséges intelligencia. Kifejezetten szeretem az egyetemen oktatott matematikát. A mesterit majd Mesterséges Intelligencia szakirányon szeretném végezni. A jövőben ebben a témakörben szeretnék kutató lenni, illetve doktorátusit is tervezek, szívesen vállalnék oktatói szerepkört is ideiglenesen. A Tutor rendszerben egyszer vettem eddig részt, ahol Bereczki László volt a tutor, s én az ő tutoriáltja. 80. Preznyák László, 410 pont ábra. Nagyváradon születtem, Romániában. A Székelyhídi Petőfi Sándor Elméleti Líceumban végeztem matematika-informatika szakon. Középiskolai éveim során C-ben programoztam, de hamar rá kellett jönnöm, hogy a tudásom az itteni kezdő szintet sem éri el egyelőre. "A célom az, hogy jó legyek. Hű binomom oldalán. Oly sok a harc, a küzdelem, de győzelem vár rám." Egyetemi éveim során olyan programozóvá szeretnék válni, aki után kapkodnak a fejvadász cégek. Ennek érdekében a programozási nyelvekkel intim kapcsolatot létesítek napról napra, és remélem a célomat elérem. Bereczki László és Kolozsvári Dávid a tutorom, de az igazi munka még csak most kezdődik! 81. Rácz Boglárka 31 pont

405 A Debreceni Egyetem programozói évkönyve 375 / ábra. Debrecenben születtem 1992-ben. A Bethlen Gábor Közgazdasági Szakközépiskolában végeztem 2011-ben, ott ismerkedtem meg először a c++ programozási nyelvvel között a Computer School OKJ-s képzésén wep-programozást tanultam. Egyetemi éveim alatt célom jobb programozóvá válni. 82. Sabo Ferents ábra. Benében születtem, Ukrajnában. A programozási tanulmányaimat Beregszászi Magyar Gimnáziumban kezdtem. Az egyetem elvégzésével szeretnék elhelyezkedni egy sikeres játékfejlesztő cégnél. 83. Seles Péter 177 pont ábra ben születtem Egerben. Az egri Neumann János Középiskola és Kollégiumban végeztem középiskolai tanulmányaimat, matematika-informatika szakon. Itt ismerkedtem meg a Pascal, C illetve C++ programozási nyelvek alapjaival. Nem vettem még részt a tutorrendszerben.

406 A Debreceni Egyetem programozói évkönyve 376 / 404 Tutorjaim: Fülöp Sándor és Kistamás Dávid. 84. Sipos Ferenc 662,5 pont ábra. Debrecenben születtem, Hajdúböszörményben lakom. A Mechwart András Gépipari és Informatikai Szakközépiskolában érettségiztem le, majd itt IT Biztonságtechnikus képesítést is szereztem. Érdekel a programozás, a hálózatok. Programozás terén szeretnék minél több tudásra, gyakorlatra és tapasztalatra szert tenni az egyetemi éveim alatt. Tutor rendszerben még nem vettem részt, de szívesen részt vennék mint tutoriált vagy akár tutorként is. A robotfoci kupában a Kispálya csapattal vettem részt. 85. Szabó Bence ELC2LN, 371 pont ábra. Nyíregyházán születtem 1994-ben. Középiskolai tanulmányaimat a nyíregyházi Széchenyi István Közgazdasági, Informatikai Szakközépiskolában végeztem, ahol Pascal és Java nyelvet tanultunk. Érdeklődési köreim a C++, Java, Android szoftverfejlesztés Feladatokat főleg órán oldottam meg, Robotfoci-t beizzítottam. A Qt-s feladatok kifejezetten tetszenek. Tutor rendszerben részt vettem mint tutor és mint tutoriált is. 86. Szabó Bence HKI0JV 21 pont ábra ben születtem Debrecenben ban végeztem a Tóth Árpád Gimnázium reál-informatika tagozatán emelt informatika érettségivel. A gimnázium alatt Pascal, Turbo Pascal és Visual Basic nyelveket tanultunk. A tutor rendszerben eddig nem vettem részt.

407 A Debreceni Egyetem programozói évkönyve 377 / Szabó Máté 115 pont ábra. Nyíregyházán születtem 1994-ben. Középiskolai tanulmányaimat a Széchenyi István Közgazdasági, Informatikai Szakközépiskola informatika szakán végeztem, ahol Pascal és Java nyelvet tanultunk. Érdeklődök a C++ és a Java iránt, valamint kiemelt szerepet kap nálam a matematika és az oktatás. Feladatokat eddig órán oldottam meg, illetve otthon az óraiakat, illetve a gource-t használtam és elkezdtem ismerkedni a robotfocival. Tutor még nem voltam, viszont több alkalommal is segített nekem egy tutor a tanulásban. 88. Szabó Zsolt 55 pont ábra én Hajdúnánáson születtem. Középiskolás tanulmányaimig ott nevelkedtem ben az akkori Vadas Jenő iskolában kezdtem meg Mátrafüreden erdészeti pályafutásomat. Ott szereztem meg az érettségimet, illetve maradtam a 2 éves erdésztechnikus szakképzésen ben lettem erdésztechnikus. Időközben a volt középiskolám többszöri átnevezésen esett át, jelenleg FVM ASzK - Mátra Erdészeti, Mezőgazdasági és Vadgazdálkodási Szakképző Iskola és Kollégium név alatt található meg. Az utolsó technikusi évemben párhuzamosan folytattam tanulmányokat a környéken lévő Gyöngyösön a Károly Róbert Főiskolán erdőgazda FSZ képzésen májusában végeztem erdőgazda szakon, majd szeptemberben a Debreceni Egyetem Informatika Karának hallgatója lettem programtervező informatikus szakon. E rövid bemutatkozásomból szerintem eléggé egyértelmű, hogy tanulmányaim során nem sok közöm volt az informatikához, tehát az egyetemi éveim során szeretném a programozáshoz szükséges ismereteket elsajátítani, hogy aztán egy biztos, stabil életet alakíthassak magamnak és a leendő családomnak. 89. Szálku Tibor, 73 pont

408 A Debreceni Egyetem programozói évkönyve 378 / ábra ben születtem Nyíregyházán. Középiskolai tanulmányaimat a győri Jedlik Ányos Gépipari és Informatikai Középiskolában végeztem gazdasági informatikus szakon. Az utolsó 2 évben volt egy kis programozás, amin a C# nyelv alapjait tanultuk meg. Ezen kívül nincs túl nagy programozási ismeretem. Tutor rendszerben még nem vettem részt. 90. Szentmiklósi Nikolett, 173 pont ábra. Debrecenben születtem, 1993-ban. A Fazekas Mihály Gimnáziumban tanultam. Programozni c++-ban tanultam fakultáció keretein belül. Szeretnék egyetemi éveim alatt jól megtanulni programozni, hogy később jól megálljam a helyem. A tutorom Madar József. 91. Szentpéteri Annamária, 940 pont ábra. Nyíregyházán születtem. Középiskolai tanulmányaimat a Széchenyi István Közgazdasági, Informatikai Szakközépiskola és Kollégiumban végeztem kitűnő eredménnyel. Informatikából emelt szintű érettségit tettem. Konkrétan nem tudom, hogy milyen típusú programokat szeretnék megoldani. Jelenleg a pattogó labda közép és kezdő szintű feladatokat csináltam meg, ez nagyon tetszett is, ezen kívül még a polártranszformációs feladatot és a BogoMIPS programot csináltam még meg eddig. A bináris-fa generáló program megértésének feladata kifejezetten tetszett, remélem, hogy lesz még ehhez hasonló feladat.

409 A Debreceni Egyetem programozói évkönyve 379 / 404 A tutor-tutoriált rendszerben tutoriáltként veszek részt, lévén kezdő vagyok. Tutorom Bereczki László. Ezen kívül kérésre szívesen segítek bárkinek, ha tudok. Binomom Deregi Diána. A robotfoci bajnokságon a MoonMoonFC nevű csapattal indulok. 92. Széles Nikolett 3 pont ábra ban születtem Debrecenben. Ide jártam középiskolába a Balásházy János mezőgazdasági és közgazdasági szakközépbe közgazdaságtant tanultam. Programozni nem tanultam még csak néha csináltam egy-két c# feladatot hobbi szinten. 93. Szimeonov Nikolett 61 pont(commitokkal) ábra május 1-jén, Nyíregyházán születtem.ekkor még Beregszászon éltünk, majd 2000ben költöztünk át Magyarországra.A Zelk Zoltán Általános és Két Tanítási Nyelvű Általános Iskolában végeztem el a nyolc osztályt, ahol első osztálytól kezdve tanultam a német nyelvet.ezután a Vasvári Pál Gimnázium német nyelvi tagozatára nyertem felvételt, így informatikát csak 2 évig tanultam.ezalatt felkészültem a középszintű érettségire, valamint megismerkedtem a Turbo Pascal programozási nyelvvel alap szinten. Szerettem volna olyan pályát választani az életemben, aminek van jövője hiszen az informatika már mindenütt jelen van.nem könnyű szakma de ez adja a szépségét, hogy van benne kihívás. 94. Szőcs Gábor 319 pont ábra. Karcagon születtem, Kisújszálláson lakom, és itt is végeztem a Móricz Zsigmond Gimnáziumban. Célom, hogy jó programozóként el tudjak helyezkedni a szakmában. Programozási tapasztalatom nem túl nagy, de a tutor rendszerben, mint tutor akinek tudok segítek.engem tutoriált: Kistamás Dávid. Én tutoriáltam: Abai Richárd, Oros Tibor, Seles Péter, Varga Attila.

410 A Debreceni Egyetem programozói évkönyve 380 / Takács Miklós, 80 pont ábra. Debrecenben születtem 1992 január 3.-án. Nyíregyházán élek és ott is végeztem a Kossuth Lajos Gimnáziumban. 1 évig a Pannon egyetemre jártam mérnök-informatikus szakon, utána OKJ-ra jártam, majd ezek után kezdtem el Debrecenbe járni. A játékfejlesztés érdekel és majd ilyen területen szeretnék elhelyezkedni. 96. Tamics Ádám 1460 pont ábra. Berettyóújfaluban születtem, Arany János Gimnáziumba jártam, matematika-informatika szakon végeztem. Érdeklődési köreim a játékfejlesztés, android programozás. Egyetemi éveim alatt szeretném teljesen elsajátítani a C++, illetve Java programozási nyelveket.tutor rendszerben részt veszek mint tutoriált illetve tutor.tutoriáltaim: Bereczki László,Tóth Máté,Bertalan Ádám,Akai Zsolt,Bak Balázs,Erdei Krisztián,Eszenyi Gábor. Tutorjaim : Tóth Máté,Bereczki László 97. Tarján Zsolt, 79 pont ábra. Kistarcsán születtem. Pascal nyelvet tanultam, Nyíregyházán a Vasvári Pál Gimnáziumban. Célom az, hogy egyszer majd programozó legyek. Remélem, hogy egyszer majd elérem ezt a célt. 98. Torma Antal ábra.

411 A Debreceni Egyetem programozói évkönyve 381 / 404 Hajdúnánáson a Kőrösi Csoma Sándor Gimnázium, Szakközépiskolában végeztem. Programozás téren még nem alakult ki a teljes kép hogy milyen programokat szeretnék csinálni. A tutor rendszerben még nem vettem részt. 99. Tóth Dávid ábra. Debrecenben születtem. Programozással középiskolában kezdtem először foglalkozni, főképpen a C nyelvvel. Érdekel az android programozás Tuza József, 184 pont ábra. Debrecenben születtem és Hajdúnánáson a Kőrösi Csoma Sándor Gimnáziumban tanultam. Emelt informatika érettségivel rendelkezem. Legfőképp a játékfejlesztés érdekel, de mindenre nyitott vagyok. Egyetemi tanulmányaim során aktuális, valós problémák megoldásával szeretnék foglalkozni. Szabó Attila tutorja és tutoráltja is voltam Varga Attila 204 pont ábra.

412 A Debreceni Egyetem programozói évkönyve 382 / 404 Debrecenben születtem és a debreceni Csokonai Vitéz Mihály Gimnáziumban tanultam. Az egyetem előtt nem találkoztam még programozási nyelvekkel, de érdekesnek találtam a programozást és azért jelentkeztem az egyetemre, hogy itt megtanuljak programozni. A tutorrendszerben nem vettem részt Varga Gábor (66 pont) ábra. Kazincbarcikán születtem és itt az Irinyi János Szakközépiskolába jártam infromatikai szakra. A mobilprogramozás érdekel, bár még semmilyen tapasztalatom nincs ezzel kapcsolatban, tehát ez még változhat. A tutor-rendszerben még nem vettem részt Veress Ármin 473 pont ábra. Hajdúnánáson születtem, a Makláry Lajos gimnáziumban érettségiztem. Programozással még csak nemrég kezdtem el foglalkozni. Szeretnék grafikus irányba menni, de igazából sok minden érdekel. A tutor rendszerben tutorként és tutoriáltként is részt vettem. Tutorjaim: Madar József, Szentpéteri Annamária, Abai Richárd, Nagy Sándor, Balogh János Csaba és Kökéndy Tímea Veress Balázs 343 pont ábra. Debrecenben születtem, később Ebesre költöztünk. Középiskolai tanulmányaimat a debreceni Szent József Gimnáziumban végeztem. Itt kezdtem ismerkedni a c programozás alapjaival, de komolyabban csak az egyetemen kezdtem el. Szeretnék Debrecen környékén elhelyezkedni, az egyetem elvégzése után. Tutorként segített : Gyügyei Tamás.

413 A Debreceni Egyetem programozói évkönyve 383 / Vona Márton (208 pont) ábra. Miskolcon születtem, középiskolai tanulmányaimat az Eötvös József Gimnáziumban Tiszaújvárosban végeztem. A programozással itt az egyetemen találkoztam először, így komolyabb előképzettséggel nem rendelkezem. A legtöbb időt C programozással töltöttem, de ismerkedés szintjén találkoztam már PHP, C++ és JavaScrip forrásokkal is Winke Róbert ábra Závaczki Roland (82 pont) ábra. Nyíregyházán születtem 1994-ben. Középiskolai tanulmányaimat a Nyíregyházi Zay Anna Egészségügyi, Informatikai Szakközépiskola és Kollégiumban végeztem, ahol Pascal-t tanultam. Az egyetem elvégzése után szeretnék elhelyezkedni egy cégnél Zelina Zsolt, 315 pont

414 A Debreceni Egyetem programozói évkönyve 384 / ábra. Születési helyem Marghita (ROMANIA). Debrecenben végeztem az eddigi tanulmányaimat, de az Informatikától elég távol állnak. Sajnos semmiféle programozási tapasztalatom nincs, ezért segítséget bárkitől elfogadok, de ha valamit tudok, szívesen átadom. Tutorjaim Madar József és Bereczki László. Binomom pedig Mucsina Dávid Csaba Németh Antal (7 pont) ábra. Hajdúböszörményben születtem és lakom. Középiskolai tanulmányaimat a Hajdúböszörményi Bocskai István Gimnázium Angol előkészítős szakán végeztem. Ennek a speciális osztálynak, illetve az egésznek a célja az volt hogy mindenkit felkészítsen egy 0. évben Angol nyelvvizsgára és egy év múlva Informatika érettségire. Célom ezen az Egyetemen, hogy megtanuljak programozni és egy biztos állást tudjak keresni amivel megtudom alapozni a családom, illetve akár pénzügyileg is tudjam segíteni szüleimet. Leginkább a C és C++ programozási nyelv felé hajlom, illetve még a Java programozási nyelv is érdekel Csopa Tamás (58 pont) ábra ben születtem Kazincbarcikán, a miskolci Bláthy Ottó Villamosipari Szakközépiskolába jártam, két OKJ-s szakmával rendelkezem: Informatikai Hálózattelepítő Üzemeltető, Internetes Alkalmazásfejlesztő, ez utóbbival közel 1 évet dolgoztam diákmunkában, PHP, CSS, MySql, JavaScript / Jquery-vel foglalkoztam. Programozás terén egyelőre minden érdekel, nem tartom magam olyan tapasztaltnak, hogy irányt választhassak egyelőre. Tutor programban még nem vettem részt Oktatók Előadó 1. Dr. Bátfai Norbert

415 A Debreceni Egyetem programozói évkönyve 385 / ábra. Dr. Bátfai Norbert Bátfai Norbert Salgótarjánban született. Gimnáziumi éveit a Magyar Honvédség szervezésében Balassagyarmaton töltötte, tanulmányait a Bólyai János Katonai Műszaki Főiskolán folytatta, ahonnan őrmesterként szerelt le, majd 1996-ban szerzett programozó matematikusi, illetve 1998-ban kitüntetéses programtervező matematikusi oklevelet a Debreceni Egyetemen ban megnyerte a Java Szövetség Java Programozási Versenyét. Mobil információtechnológiai cége, az Eurosmobil, második helyezést ért el 2004-ben a Motorola JavaJáték Versenyén, ugyancsak az Eurosmobil 2004-ben a Sun és a Nokia közös Mobil Java Fejlesztői Versenyén a Ha hívsz, támadok! (H.A.H) hálózati ( Java EE szerver, Java ME kliens) játéksorozattal első díjat nyert. A mobil játékfejlesztés elmélete és gyakorlata és a kék (JSR 82) játékok címmel előadott az Eurosmobillal a Sun Java Fejlesztői Konferencián 2005-ben. A VISZ (Vezető Informatikusok Szövetsége) a 2008-as évben az Év Informatikai Oktatójának választotta ben szerzett PhD doktori fokozatot informatikából. Jelen pillanatban a Debreceni Egyetem Információtechnológiai Tanszékének adjunktusa. Érdeklődése most a gépi tudatosságra irányul ben Pollák-Virág díjat kapott a Hírközlési és Informatikai Tudományos Egyesülettől. Gyakorlata van az alábbi platformokon és technológiákkal: Java ME, Java SE, Java EE, CORBA, Android Java, C, C++, Boost, Qt, Python, OpenGL, OpenCV, OGRE, CUDA, OpenMP, HPC, GNU/Linux rendszerprogramozás, DocBook XML Gyakorlatvezető 1. Besenczi Renátó ábra. Besenczi Renátó 1986-ban született Kecskeméten, ahol a Kocsis Pál Mezőgazdasági Szakközépiskolában érettségizett környezetvédelmi szakon és 2009 között a Debreceni Egyetem Mezőgazdaságtudományi Karán szerzett diplomát természetvédelmi mérnök valamint geodéziai és térinformatikai szakmérnök szakokon. Jelenleg a Debreceni Egyetem Informatikai Karán mérnökinformatikus MSc képzésen vesz részt, (BSc végzés éve 2014.) valamint a egyetemen futó FIRST projektben kutató-fejlesztőként tevékenykedik. Kedvenc platformok: Java, C, C++, Android Kutatási terület: közösségi alkalmazások, közösségi adatgyűjtés, crowd-sensing 2. Smajda Máté

416 A Debreceni Egyetem programozói évkönyve 386 / ábra. Smajda Máté 1993-ban született Debrecenben. Az Ady Endre Gimnázium hatosztályos tagozatán szerezte meg az érettségit. Jelenleg a Debreceni Egyetem Informatikai Karán programtervező informatikus BSc képzésen vesz részt, és a Informatikai Kar FIRST projektben végez kutató-fejlesztő munkát. Kedvenc platformok: C++, OpenGL, Java, Android, Python. 3. Mamenyák András ábra. Mamenyák András 1992-ben született Nagyváradon (Románia). A nagyváradi Ady Endre Elméleti Líceumban tanult matematika-informatika + intenzív angol szakon ( ). Jelenleg harmadéves MIs hallgató, fohálózatok szakirányon, 4,62-es kumm. átlaggal ban megnyerte a Sony és az XDA-Developers által rendezett XDA Tablet Z Development Competition versenyt. Kedvenc platformok: C, C++, Qt, CUDA Gnoti se auton Az évfolyam legfontosabb hallgatói - tutor rendszer március 24-i hét április 7-i hét Az évfolyam legfontosabb hallgatói - feladatok megoldása Az évfolyam legfontosabb hallgatói - skillek