A Debreceni Egyetem programozói évkönyve

A Debreceni Egyetem programozói évkönyve


˝ A 2013/14 tanév tavaszi és a 2014/15 tanév oszi szemesztere

Ed. Egyetemi jegyzet, verzió 0.1.3312

i


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 http://www.gnu.org/licenses/. Ez a program szabad szoftver; terjeszthet˝o 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˝oleges) kés˝obbi 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 http://www.gnu.org/licenses/ oldalon. http://gnu.hu/gplv3.html

ii


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

2014. december 24.

REVISION HISTORY NUMBER

DATE

DESCRIPTION

NAME


iv

Tartalomjegyzék

I.

Feladatok

2

1. A kezd˝o szint programjai

4

1.1. Az els˝o C programok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

4

1.1.1. Végtelen ciklus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

4

1.1.2. Két változó értékének cseréje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

4

1.1.3. Pattogó labda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5

1.1.4. „Helló, Világ” a sztenderd hibára . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5

1.1.5. Átlag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5

1.1.5.1.

Véletlen számok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

6

1.1.6. A szóhossz a gépeden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

6

1.1.7. BogoMIPS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

6

1.2. Környezeti változók . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

7

1.3. A lexikális elemzéssel kapcsolatos els˝o programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

7

1.3.1. Bet˝uk számolása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

7

1.3.2. Számok számolása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

7

1.3.3. Szavak számolása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

7

1.3.4. Sorok számolása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

8

1.4. Rendszerprogramozással kapcsolatos els˝o programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

8

1.4.1. Villa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

8

1.4.1.1.

Zombi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

8

1.4.1.2.

Riasztás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

8

1.4.2. Utolsó tennivaló . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

9

1.4.3. Nem lokális ugrások . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

9

1.5. Az els˝o algoritmizálási programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

9

1.5.1. Mandelbrot halmaz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

9

1.5.2. Elfolyik a PageRank . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

9

1.5.3. Ellopni a PageRank értéket . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 1.5.4. Alternatív tabella . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10


v

1.6. Az els˝o párhuzamos programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 1.6.1. Elromlik a változó . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 1.7. Az els˝o GNU/Linux kernellel kapcsolatos programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 1.7.1. „Helló, Világ!” a kernelb˝ol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 1.7.2. A PCB mérete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 1.7.3. A PCB mérete modulból . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 1.8. Az els˝o MINIX kernellel kapcsolatos programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 1.8.1. „Helló, Világ!” a kernelb˝ol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 1.8.2. A PCB mérete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 1.8.3. A processztábla méretének módosítása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 1.8.4. Ütemezési sorok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 1.9. Az els˝o C++ programok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 1.9.1. Módosított polártranszformációs véletlen szám generátor, ez legyen az els˝o C++ progid! . . . . . . . . . 12 1.9.2. Csere mutatók nélkül . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 1.9.3. Komplex osztályos Mandelbrot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 1.9.4. Az els˝o „nyelvi” programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 1.9.4.1.

Másoló és mozgató konstruktor és értékadás . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

1.9.4.2.

Mély és sekély másolás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 1.9.4.2.1.

Másolt vektor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

1.9.4.2.2.

Másolt verem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

1.9.4.2.3.

Másolt lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

1.9.4.2.4.

Másolt map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

1.9.4.2.5.

Másolt map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

1.9.5. Az els˝o Qt programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 1.9.5.1.

A Mandelbrot RGB színezése . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

1.9.5.2.

Szavazás feladat: Mandelbrot szépségverseny . . . . . . . . . . . . . . . . . . . . . . . . . . 15 1.9.5.2.1.

1.9.5.3.

A számítás adatai a képre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

Szavazás feladat: biomorf szépségverseny . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 1.9.5.3.1.

A számítás adatai a képre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

1.9.5.4.

A genetikai kód-sz˝onyeg parancssori bemenete . . . . . . . . . . . . . . . . . . . . . . . . . . 15

1.9.5.5.

További él˝olények a sejttérben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

1.9.6. Az els˝o képfeldolgozással kapcsolatos programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 1.9.6.1.

1.9.6.2.

Az els˝o png++ és pngwriter könyvtárakkal kapcsolatos programjaid . . . . . . . . . . . . . . . 16 1.9.6.1.1.

Kockásítás a png++ könyvtárral . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

1.9.6.1.2.

Kockásítás a pngwriter könyvtárral . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

Az els˝o Open CV-vel kapcsolatos programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . 17 1.9.6.2.1.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

1.9.7. Az els˝o STL-el és Boost-al kapcsolatos programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 1.9.7.1.

Poszt feladat: lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

1.10. Az els˝o Java programok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 1.10.1. Módosított polártranszformációs véletlen szám generátor, ez legyen az els˝o Java progid! . . . . . . . . . 17


2. A közepes szint programjai

vi

18

2.1. A kezd˝o szint˝u feladatokra épített példák . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 2.1.1. Normálisok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 2.1.1.1.

Normális-harang . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

2.1.1.2.

Normális-harang grafikusan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

2.1.2. Mérk˝ozés eredmények . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 2.1.3. Pattogó labda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 2.2. Rendszerprogramozással kapcsolatos programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 2.2.1. Glibc függvény felüldefiniálása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 2.2.2. Rendszerstatisztika . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 2.3. Képfeldolgozó programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 2.3.1. P-szálas kockásítás a png++ könyvtárral . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 2.3.2. Open MP-s kockásítás a png++ könyvtárral . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 2.3.3. P-szálas kockásítás a pngwriter könyvtárral . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 2.3.4. Open MP-s kockásítás a pngwriter könyvtárral . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 2.4. Az els˝o Qt programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 2.4.1. Arecibói Üzenet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 2.4.2. Mandelbrot rajzoló . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 2.4.2.1.

Mandelbrot nagyító . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 2.4.2.1.1.

Mandelbrot halmaz ment˝o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

2.4.3. A genetikai kód-sz˝onyeg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 2.4.3.1.

A kód vizualizációjának mentése . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

2.4.4. Sejtautomata szimulációk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 2.4.4.1.

Sejttér mérete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

2.4.4.2.

Sejttér mentése . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

2.4.5. Slot-signal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 2.5. A GNU/Linux kernellel kapcsolatos programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 2.5.1. Folyamatokat számláló modul . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 2.5.2. Folyamatokat kiíró modul . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 2.5.3. Fájlleíró modul . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 2.6. A MINIX kernellel kapcsolatos programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 2.6.1. Nyomkövetés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 2.6.2. Ütemezés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 2.7. Algoritmizálási programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 2.7.1. BBP megvalósítás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 2.8. Nyelvi programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 2.8.1. Saját int verem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 2.8.2. Saját int dinamikus tömb . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24


vii

3. A haladó szint programjai

25

3.1. Párhuzamos programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 3.1.1. Mandelbrot több szálon P-szálakkal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 3.1.2. Mandelbrot több szálon Open MP-vel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 3.1.3. Mandelbrot Intel TBB-vel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 3.1.4. Exor-törés párhuzamosítása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 3.2. A GNU/Linux kernellel kapcsolatos programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 3.2.1. A /proc virtuális fájlrendszer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 3.2.2. Melyik az éppen futó processz? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 3.3. A MINIX kernellel kapcsolatos programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 3.3.1. Processzek üzenetmátrixa, PCB módosítással . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 3.3.2. Processzek üzenetmátrixa, saját rendszerhívással . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 3.4. Rendszerprogramozással kapcsolatos programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 3.4.1. Rendszerstatisztika folytatása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 3.5. Algoritmizálási programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 3.5.1. Pi-számítása a kernel üzenetsoraival . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 3.6. Képfeldolgozási programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 3.6.1. Az els˝o Open CV-vel kapcsolatos programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 3.6.1.1.

Labda követése . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

4. A kiemelked˝o szint programjai

29

4.1. CUDA programok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 4.1.1. Az EXOR-kódtörés CUDA párhuzamosítása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 4.2. QCSS programok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 4.2.1. QCSS 2D megjelenít˝o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 4.2.2. QCSS szurkolói ágens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 4.3. RCSS programok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 4.3.1. Saját 2D RCSS csapat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 4.4. MINIX kernellel kapcsolatos programok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 4.4.1. MINIX 3 ütemez˝o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 4.5. Algoritmizálási programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 4.5.1. Pi-számítása több gépen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 5. A védések programjai

31

5.1. A 2013/14 tanév tavaszi szemeszterének védései . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 5.1.1. Az els˝o védés: a humán genom LZW-bináris fa alapú feldolgozása . . . . . . . . . . . . . . . . . . . . . 31 5.1.2. A második védés: egy saját RCSS multiágens C++ implementáció . . . . . . . . . . . . . . . . . . . . . 31 5.2. A 2014/15 tanév o˝ szi szemeszterének védései . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 5.2.1. A harmadik védés: lépés a projektek felé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 5.2.2. A negyedik védés: egy céges feladat kidolgozásában részvétel . . . . . . . . . . . . . . . . . . . . . . . 31


viii

6. A labor-mérés programjaid

32

6.1. A 2013/14 tanév tavaszi szemeszterének labor-mérései . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 6.1.1. Ismerked˝o labor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 6.1.1.1.

1. labor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

6.1.2. Bevezet˝o laborok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 6.1.2.1.

A második labor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 6.1.2.1.1.

6.1.2.2.

A harmadik labor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 6.1.2.2.1.

6.1.2.3.

Exor-törés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

6.1.2.2.1.1.

A kapcsolódó laborfeladatok . . . . . . . . . . . . . . . . . . . . . . . . . . 34

6.1.2.2.1.2.

e.c

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

6.1.2.2.1.3.

t.c

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

6.1.2.2.1.4.

A t.c kiegészítése . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

A negyedik labor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 6.1.2.3.1.

6.1.2.4.

Egy saját Google PageRank implementáció . . . . . . . . . . . . . . . . . . . . . . 33

Liv-Zempel fa építése a humán genom emberi 2. kromoszómájából . . . . . . . . . . 36

6.1.2.3.1.1.

A kapcsolódó laborfeladatok . . . . . . . . . . . . . . . . . . . . . . . . . . 36

6.1.2.3.1.2.

LZW fák . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

6.1.2.3.1.3.

z.c

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

6.1.2.3.1.4.

d.c

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

6.1.2.3.1.5.

A h.c és a g.c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

6.1.2.3.1.6.

Labor és szorgalmi laborfeladatok . . . . . . . . . . . . . . . . . . . . . . . 48

6.1.2.3.1.7.

Aminosav-hisztogram . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

6.1.2.3.1.8.

Még drágább aminosav-hisztogram . . . . . . . . . . . . . . . . . . . . . . . 48

6.1.2.3.1.9.

Az aminosav-hisztogram mindig drága . . . . . . . . . . . . . . . . . . . . . 48

6.1.2.3.1.10.

C-b˝ol C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

6.1.2.3.1.11.

PyTCAG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

6.1.2.3.1.12.

PySzavak . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

6.1.2.3.1.13.

A nukleobázisok számolása a humán genom második kromoszómáján C++ban a Map-Reduce platformon . . . . . . . . . . . . . . . . . . . . . . . . . 49

6.1.2.3.1.14.

Az aminosavak számolása a humán genom második kromoszómáján C++ban a Map-Reduce platformon . . . . . . . . . . . . . . . . . . . . . . . . . 49

6.1.2.3.1.15.

Filogenetikai fa az LZW-s fa ághosszainak szórása alapján . . . . . . . . . . 49

Az ötödikt˝ol a hetedik laborig . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 6.1.2.4.1.

A védési program megalapozása . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

6.1.2.4.1.1.

Bináris fa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

6.1.2.4.1.2.

mains.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

6.1.2.4.1.3.

maini.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

6.1.2.4.1.4.

binfa.h

6.1.2.4.1.5.

int.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51


6.1.2.4.1.6. 6.1.2.4.2.

int.cpp

ix

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

Qt programok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

6.1.2.4.2.1.

Arecibói üzenet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

6.1.2.4.2.2.

Mandelbrot halmaz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

6.1.2.4.2.3.

Sejtautomata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

6.1.2.4.2.4.

Portoljuk Androidra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

6.1.2.4.3.

Programok párhuzamosítása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

6.1.2.4.3.1.

A Mandelbrot-számoló párhuzamosítása . . . . . . . . . . . . . . . . . . . . 53

6.1.2.4.3.2.

Az exor-törés Open MP párhuzamosítása . . . . . . . . . . . . . . . . . . . . 53

6.1.3. Robotfocis laborok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 6.1.3.1.

A nyolcadik labor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 6.1.3.1.1.

Kick-off . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

6.1.3.1.1.1. 6.1.3.2.

A kilencedik labor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 6.1.3.2.1.

A második védés megalapozása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

6.1.3.2.1.1. 6.1.3.3.

Bemelegítés - legyen kapus a kapus . . . . . . . . . . . . . . . . . . . . . . 54

Saját viselkedés szögletnél . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

A tizedik és tizenegyedik labor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 6.1.3.3.1.

Laborfeladatok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

6.1.4. Kvantum-tudatos laborok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 6.1.4.1.

A tizenkettedik labor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

6.1.5. A céges feladatok bevezetése . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 6.1.5.1.

Az utolsó labor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

6.1.5.2.

Lespecifikált feladatok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

6.2. A 2014/15 tanév o˝ szi szemeszterének labor-mérései . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 6.2.1. Beszokató labor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 6.2.1.1.

Az els˝o labor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

6.2.2. Bevezet˝o laborok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 6.2.2.1.

6.2.2.2.

A második labor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 6.2.2.1.1.

A védési program Java és C# átirata . . . . . . . . . . . . . . . . . . . . . . . . . . 58

6.2.2.1.2.

Java performance tuning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

6.2.2.1.3.

További pontgy˝ujt˝o feladatok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

A harmadik labor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 6.2.2.2.1.

YANonymous = YANA (You Are Not Alone) + Anonymous = You Are Not Anonymous . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

6.2.2.2.2.


6.2.3. YANO laborok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 6.2.3.1.

A negyedik labor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 6.2.3.1.1.

YANO hack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

6.2.3.1.2.



6.2.3.2.

x

Az ötödik labor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 6.2.3.2.1.

YANO hack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

6.2.3.2.2.


6.2.4. Haladó laborok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 6.2.4.1.

A hatodik labor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 6.2.4.1.1.

Robocar City Emulator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

6.2.4.1.2.


6.2.4.2.

A hetedik labor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 6.2.4.2.1.

Labormérés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

6.2.4.2.2.


6.2.4.3.

A nyolcadik labor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 6.2.4.3.1.

Labormérés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

6.2.4.3.2.


6.2.4.4.

A kilencedik labor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 6.2.4.4.1.

Labormérés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

6.2.4.4.2.


6.2.4.5.

A tizedik labor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 6.2.4.5.1.

Labormérés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

6.2.4.5.2.

További labormérés feladatok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

6.2.4.5.3.


6.2.4.6.

A tizenegyedik labor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 6.2.4.6.1.

Labormérés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

6.2.4.6.2.


6.2.4.7.

A tizenkettedik és az utolsó labor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 6.2.4.7.1.

Labormérés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

6.2.4.7.2.


7. Robotfocis programok

71

7.1. Bemelegítés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 7.1.1. Legyen kapus a kapus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 7.1.2. 2D RCSS ágensek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 7.1.3. 2D RCSS multiágensek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 7.2. Versenynaptár . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 7.3. Robotfoci logó . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 7.3.1. Szavazás feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 7.3.2. Logó-forráskód generátor feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 8. Szuperszámítógépes programok

73

8.1. „Tízb˝ol kilencszer mi nyertünk volna” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73


9. A „só” programok

xi

75

9.1. Genesis Patch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 10. Egyéb feladatok

76

10.1. Operációs rendszerekkel kapcsolatos alapvet˝o feladatok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 10.1.1. A GNU/Linux kernellel kapcsolatos feladatok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 10.1.1.1. Kernelfordítás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 10.1.2. Telepítéssel és virtualizációval kapcsolatos feladatok . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 10.1.2.1. Dual-boot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 10.1.2.2. MINIX virtualizálás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 10.1.2.3. OpenSolaris virtualizálás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 10.1.2.4. BSD virtualizálás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 10.2. Az információs-távolsággal kapcsolatos feladatok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 10.2.1. Genomok összehasonlítása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 10.2.2. SZT tisztek gráfja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 10.3. Design-al kapcsolatos feladatok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 10.3.1. Az UDProg évkönyv logója . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 10.3.1.1. Szavazás feladat: az UDProg évkönyv logójának szavazása . . . . . . . . . . . . . . . . . . . 78 10.4. Egyéb segít˝o feladatok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 10.4.1. Másoló konstruktor demó . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 10.4.1.1. Mozgató konstruktor demó . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 10.5. Promóciós feladatok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 10.5.1. Promóciós robotfoci-videó . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 10.5.1.1. Szavazás feladat: promóciós robotfoci-videó . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 10.5.2. Promóciós kurzus-videó . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 10.5.2.1. Szavazás feladat: promóciós kurzus-videó . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 10.5.3. Promóciós kurzus-prezi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 10.5.3.1. Szavazás feladat: promóciós kurzus-prezi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 10.6. Dokumentálással kapcsolatos feladatok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 10.6.1. UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 10.6.2. Doxygen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 10.7. Tesztelési feladatok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 11. Tankönyvi feladatok

81

11.1. A [STROUSTRUP] könyv feladatai . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 11.1.1. X.2[1] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 11.1.2. X.2[4] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 11.1.3. X.2[7] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 11.1.4. X.2[9] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82


xii

11.1.5. X.2[10] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 11.1.6. X.3[2] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 11.1.7. X.3[3] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 11.1.8. X.3[4] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 11.1.9. X.3[5] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 11.1.10.X.3[6] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 11.1.11.X.3[7] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 11.1.12.X.5[2] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 11.1.13.X.5[3] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 11.1.14.X.5[4] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 11.1.15.X.5[5] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 11.1.16.X.5[6] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 11.1.17.X.5[7] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 11.1.18.X.5[8] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 11.1.19.X.5[9] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 11.1.20.X.5[10] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 11.1.21.X.6[2] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 11.1.22.X.7[1] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 11.1.23.X.7[2] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 11.1.24.X.7[6] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 11.1.25.X.7[7] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 11.1.26.X.7[8] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 11.1.27.X.7[9] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 11.1.28.X.7[12] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 11.1.29.X.7[13] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 11.1.30.X.8[1] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 11.1.31.X.8[3] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 11.1.32.X.8[4] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 11.1.33.X.8[5] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 11.1.34.X.8[7] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 11.1.35.X.8[8] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 11.1.36.X.8[9] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 11.1.37.X.8[10] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 11.1.38.X.8[11] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 11.1.39.X.8[12] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 11.1.40.X.9[1] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 11.1.41.X.9[2] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 11.1.42.X.9[4] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 11.1.43.X.10[1] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90


xiii

11.1.44.X.11[1] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 11.1.45.X.11[2] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 11.1.46.X.11[3] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 11.1.47.X.11[6] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 11.1.48.X.11[10] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 11.1.49.X.13[1] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 11.1.50.X.13[2] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 11.1.51.X.13[3] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 11.1.52.X.13[4] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 11.1.53.X.13[9] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 11.1.54.X.13[14] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 11.1.55.X.13[15] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 11.1.56.X.13[20] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 11.1.57.X.13[21] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 11.1.58.X.17[4] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 11.1.59.X.17[7] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 11.1.60.X.17[8] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 11.1.61.X.17[13] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 11.1.62.X.19[4] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 11.1.63.X.21[1] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 11.1.64.X.32[1] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 11.1.65.X.32[2] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 11.1.66.X.32[3] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 11.1.67.X.32[4] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 11.1.68.X.32[5] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 11.1.69.X.32[6] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 11.1.70.X.37[1] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 11.2. A [KR] könyv feladatai . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 11.2.1. 1.1.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 11.2.2. 1.2.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 11.2.3. 1.3.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 11.2.4. 1.4.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 11.2.5. 1.5. gyakorlat. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 11.2.6. 1.6.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 11.2.7. 1.7.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 11.2.8. 1.8.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 11.2.9. 1.9.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 11.2.10.1.10.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 11.2.11.1.12.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98


xiv

11.2.12.1.12.1 gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 11.2.13.1.13.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 11.2.14.1.14.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 11.2.15.1.15.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 11.2.16.1.16.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 11.2.17.1.17.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 11.2.18.1.20.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 11.2.19.2.1.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 11.2.20.2.4.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 11.2.21.2.5.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 11.2.22.2.6.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 11.2.23.2.7.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 11.2.24.2.8.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 11.2.25.2.9.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 11.2.26.2.10.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 11.2.27.3.3.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 11.2.28.3.4.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 11.2.29.3.5.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 11.2.30.3.6.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 11.2.31.4.4. gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 11.2.32.4.7. gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 11.2.33.4.8. gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 11.2.34.4.9. gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 11.2.35.5.1. gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 11.2.36.5.3.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 11.2.37.5.4.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 11.2.38.5.5.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 11.2.39.5.7. gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 11.2.40.7.1.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 11.2.41.7.6.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 11.2.42.8.1.gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 11.3. Az [SZFCPP] könyv feladatai . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 11.3.1. 3.5.feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 11.3.2. 6.3.feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 11.3.3. 6.6.feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 11.3.4. 7.1.feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 11.3.5. 7.2.feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 11.3.6. 7.4.feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 11.3.7. 8.2.1. feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106


xv

11.3.8. 10.1.2.feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107 11.3.9. 11.2.feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107 11.3.10.12.1.1 bet˝u számoló . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107 11.3.11.12.1.1 szám számoló . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107 11.3.12.12.1.2 filozófusok oda-vissza . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107 11.3.13.12.1.2 filozófusok másolása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 11.3.14.12.2.feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 11.3.15.12.4.3 bitbeszúrás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 11.4. Az [EZUST] könyv feladatai . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 11.4.1. 1.7.2 gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 11.4.2. 1.8.1 gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 11.4.3. 1.8.2 gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 11.4.4. 1.8.3 gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 11.4.5. 1.8.4 gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 11.4.6. 1.12.2 gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 11.4.7. 2.13.4 gyakorlat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 12. Vizsgarendszer

111

12.1. A 2013/14 tanév tavaszi szemeszterének vizsgái . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 12.1.1. Szóbeli vizsgák . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 12.2. A 2014/15 tanév o˝ szi szemeszterének vizsgái . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 12.2.1. Szóbeli vizsgák . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 12.2.2. Királyi út a szóbeli vizsgán . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 13. Nincs 13. fejezet

115

14. Céges feladatok

116

14.1. Robocar World Championship in Debrecen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

II.

Megoldások

15. A kezd˝o szint programjai

119 121

15.1. Az els˝o C programok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 15.1.1. Végtelen ciklus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 15.1.2. Két változó értékének a cseréje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122 15.1.3. Két változó értékének a cseréje swap függvénnyel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122 15.1.4. Két változó értékének a cseréje swap függvénnyel C-ben. . . . . . . . . . . . . . . . . . . . . . . . . . 123 15.1.5. Pattogó labda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123 15.1.6. Pattogó labda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126 15.1.7. Pattogó labda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127


xvi

15.1.8. Pattogó labda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128 15.1.9. „Helló, Világ” a sztenderd hibára . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130 15.1.10.Átlag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131 15.1.10.1. Véletlen számok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131 15.1.11.A szóhossz a gépeden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132 15.1.11.1. A szóhossz a gépeden, sizeof operátorral . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132 15.1.11.2. A szóhossz a gépeden, bitm˝uveletes módszerrel . . . . . . . . . . . . . . . . . . . . . . . . . 133 15.1.12.BogoMIPS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134 15.1.13.Környezeti változók . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 15.1.14.A lexikális elemzéssel kapcsolatos els˝o programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 15.1.14.1. Bet˝uk számolása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 15.1.15.Számok számolása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136 15.2. Szavak számolása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137 15.3. Sorok számolása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137 15.4. Rendszerprogramozással kapcsolatos els˝o programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138 15.4.1. Villa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138 15.4.1.1. Zombi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 15.4.1.2. Riasztás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 15.4.2. Utolsó tennivaló . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 15.4.3. Nem lokális ugrások . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144 15.5. Az elso párhuzamos programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146 15.5.1. Elromlik a változó . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146 15.6. Az els˝o algoritmizálási programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149 15.6.1. Mandelbrot halmaz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149 15.6.2. Elfolyik a PageRank . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 15.6.3. Ellopni a PageRank értéket . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152 15.6.4. Alternatív tabella . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154 15.7. Az els˝o GNU/Linux kernellel kapcsolatos programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157 15.7.1. „Helló, Világ!” a kernelb˝ol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157 15.7.2. A PCB mérete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158 15.7.3. A PCB mérete modulból . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158 15.8. Az els˝o MINIX kernellel kapcsolatos programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158 15.8.1. „Helló, Világ!” a kernelb˝ol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158 15.8.2. A processztábla mérete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159 15.8.3. Ütemezési sorok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160 15.8.4. A PCB mérete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160 15.9. Az els˝o C++ programok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161 15.9.1. Módosított polártranszformációs véletlenszám generátor, ez legyen az els˝o C++ progid! . . . . . . . . . 161 15.9.2. Másolt Vektor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162


xvii

15.9.3. Másolt Verem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 15.9.4. Másolt Lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 15.9.5. Másolt map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164 15.9.6. Másolt map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 15.9.7. Komplex osztályos Mandelbrot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 15.9.8. Az els˝o Qt programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166 15.9.8.1. A Mandelbrot RGB színezése . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166 15.9.8.2. A genetikai kód-sz˝onyeg parancssori bemenete . . . . . . . . . . . . . . . . . . . . . . . . . . 167 15.9.8.3. További él˝olények a sejttérben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168 15.9.9. Az els˝o képfeldolgozással kapcsolatos programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168 15.9.9.1. Az els˝o png++ és pngwriter könyvtárakkal kapcsolatos programjaid . . . . . . . . . . . . . . . 168 15.9.9.1.1. Kockásítás a png++ könyvtárral . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168 15.9.9.1.2. Kockásítás a pngwriter könyvtárral . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 15.9.10.Az els˝o Open CV-vel kapcsolatos programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171 15.9.10.1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171 15.10.Az els˝o Java programok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171 15.10.1.Módosított polártranszformációs véletlenszám generátor, ez legyen az els˝o Java progid! . . . . . . . . . 171 15.11.Labor és szorgalmi laborfeladatok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172 15.11.1.Aminosav-hisztogram . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172 15.11.2.Filogenetikai fa az LZW-s fa ághosszainak szórása alapján . . . . . . . . . . . . . . . . . . . . . . . . . 175 16. A közepes szint programjai

178

16.1. A kezd˝o szint˝u feladatokra épített példák . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178 16.1.1. Normálisok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178 16.1.2. Normális-harang . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180 16.1.3. Normális-harang grafikusan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181 16.1.4. Pattogó labda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 16.1.5. több szálon futó kockásítás png++ könyvtárral . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183 16.1.6. több szálon futó kockásítás pngwriter könyvtárral . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185 16.1.7. Rendszerprogramozással kapcsolatos programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188 16.1.7.1. Glibc függvény felüldefiniálása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188 16.1.8. Saját top parancs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189 16.1.9. Az els˝o Qt programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191 16.1.9.1. Arecibói üzenet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191 16.1.9.2. Mandelbrot rajzoló . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192 16.1.9.3. Mandelbrot nagyító . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 16.1.9.4. Mandelbrot ment˝o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197 16.1.9.5. A genetikai kód-sz˝onyeg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197 16.1.9.6. A kód vizualizációjának mentése . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200


xviii

16.1.9.7. Sejtautomata szimulációk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200 16.1.10.Fájlleíró modul . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204 16.1.11.BBP megvalósítás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205 16.2. Saját int veremosztály . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208 16.3. Saját int dinamikus tömb osztály . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210 16.3.1. Tömb osztály definíció . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210 16.3.2. Tömb osztály implementáció . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211 16.3.3. Tömb osztály teszt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212 17. A Haladó szint programjai

213

17.1. Párhuzamos programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213 17.1.1. Mandelbrot több szálon P-szálakkal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213 17.1.2. Mandelbrot több szálon Open MP-vel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215 17.1.3. Mandelbrot Intel TBB-vel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216 17.1.4. Exor-törés párhuzamosítása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218 17.2. Minix kernellel kapcsolatos programok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221 17.2.1. Processzek üzenetmátrixa, PCB módosítással . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221 17.3. Képfeldolgozási programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223 17.3.1. Az els˝o Open CV-vel kapcsolatos programjaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223 17.3.1.1. Labda követése . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223 18. A Labor-mérés prograjaid

228

18.1. A 2014/15 tanév o˝ szi szemeszterének labor-mérései . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228 18.1.1. Bevezet˝o laborok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228 18.1.1.1. A védési program Java és C# átirata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228 18.1.1.2. Els˝o védési program Python átirata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237 18.1.1.3. Els˝o védési program sebességteszt eredménye . . . . . . . . . . . . . . . . . . . . . . . . . . 239 18.1.1.4. A BBP-s sebességteszt elvégzése . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239 18.1.1.5. Java Performance Tuning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241 18.1.1.6. Alternatív Tabella . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241 18.1.1.7. Alternatív Tabella C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246 18.1.1.8. Alternatív Tabella Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251 18.1.1.9. Kvíz megoldások: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256 18.1.1.10. YANonymous . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258 18.1.1.11. PeldaServlet GlassFish . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259 18.1.1.12. Sparse Table vs. StlMap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259 18.1.1.13. Sparse Table vs. VectorBasedSparseMap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259 18.1.1.14. Hibásan implementált RSA törés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259


19. Egyéb feladatok

xix

263

19.1. Operációs rendszerekkel kapcsolatos alapvet˝o feladatok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263 19.1.1. A GNU/Linux kernellel kapcsolatos feladatok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263 19.1.1.1. Kernelfordítás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263 19.1.2. Telepítéssel és virtualizációval kapcsolatos feladatok . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263 19.1.2.1. Dual-boot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263 19.1.2.2. MINIX virtualizálás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263 19.1.2.3. OpenSolaris virtualizálás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265 19.1.2.4. BSD virtualizálás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265 19.2. Az információs-távolsággal kapcsolatos feladatok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265 19.2.1. Genomok összehasonlítása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265 19.2.2. SZT tisztek gráfja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267 19.3. Design-al kapcsolatos feladatok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267 19.3.1. Az UDProg évkönyv logója . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267 19.3.2. Az UDProg logoterv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268 19.4. Az UDProg logóterv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268 19.5. Másoló konstruktor demó . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268 19.5.1. F˝o forrásfájl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268 19.5.2. Alapértelmezett másoló konstruktoros osztály . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270 19.5.2.1. Osztály-definíció . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270 19.5.2.2. Implementáció . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271 19.5.3. Letiltott másoló konstruktoros osztály . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273 19.5.3.1. Osztály-definíció . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273 19.5.3.2. Implementáció . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273 19.5.4. "Deep copy" konstruktoros osztály . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275 19.5.4.1. Osztály-definíció . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275 19.5.4.2. Implementáció . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276 20. Tankönyvi feladatok kidolgozása

279

20.1. A Stroustrup könyv példái . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279 20.1.1. X.2[1] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279 20.1.2. X.2[4] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279 20.1.3. X.2[7] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279 20.1.4. X.3[2] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279 20.1.5. X.3[3] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280 20.1.6. X.3[4] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280 20.1.7. X.3[5] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280 20.1.8. X.3[6] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281 20.1.9. X.3[7] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281


xx

20.1.10.X.5[2] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281 20.1.11.X.5[3] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282 20.1.12.X.5[4] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282 20.1.13.X.5[5] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282 20.1.14.X.5[6] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282 20.1.15.X.5[7] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283 20.1.16.X.5[7]b feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284 20.1.17.X.5[8] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285 20.1.18.X.5[9] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286 20.1.19.X.5[10] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286 20.1.20.X.6[2] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287 20.1.21.X.7[2] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287 20.1.22.X.7[8] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288 20.1.23.X.7[9] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289 20.1.24.X.7[13] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289 20.1.25.X.8[4] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290 20.1.26.X.8[5] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290 20.1.27.X.8[7] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291 20.1.28.X.8[9] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292 20.1.29.X.8[11] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292 20.1.30.X.9[1] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294 20.1.31.X.9[2] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294 20.1.32.X.10[1] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295 20.1.33.X.11[10] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296 20.1.34.X.13[9] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297 20.1.35.X.13[14] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299 20.1.36.X.13[15] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300 20.1.37.X.13[21] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301 20.1.38.X.17[4] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304 20.1.39.X.17[7] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305 20.1.40.X.17[8] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308 20.1.41.X.17[13] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311 20.1.42.X.19[4] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311 20.1.43.X.21[1] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315 20.1.44.X.32[1] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315 20.1.45.X.32[2] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316 20.1.46.X.32[3] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317 20.1.47.X.32[4] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318 20.1.48.X.32[5] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319 20.1.49.X.32[6] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320 20.1.50.X.37[1] feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321


III.

xxi

Laborkártyák

323

21. Laborkártyák

324

21.1. Bevezet˝o laborkártyák . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324 21.1.1. A parancssori interfész (CLI) alapvet˝o használata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324 21.1.1.1. A kézikönyv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324 21.1.1.2. A fordítóprogram . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324 21.1.1.3. Vektorizálás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325 21.1.1.4. A kapcsolatszerkeszt˝o program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325 21.1.2. Az alapvet˝o C és C++ nyelvi konstrukciók használata . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325 21.1.2.1. Nevek bevezetése a programba . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325 21.1.2.2. for el˝oször . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327 21.1.2.3. for másodszor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327 21.1.2.4. for harmadszor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327 21.1.2.5. if el˝oször . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327 21.1.2.6. if másodszor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328 21.1.2.7. while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328 21.1.2.8. const . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328 21.1.2.9. char * . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329 21.1.2.10. Paraméterátadás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329 21.1.3. A szabad tár kezelése . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329 21.1.3.1. char **

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329

21.1.4. C++ alapfogalmak . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330 21.1.4.1. Másoló konstruktor és másoló értékadás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330 21.1.4.1.1.

../source/labor/kartyak/Int1/main.cpp . . . . . . . . . . . . . . . . . . . . . . . . . 331

21.1.4.1.2.

../source/labor/kartyak/Int1/main2.cpp

. . . . . . . . . . . . . . . . . . . . . . . . 331

21.1.4.1.3.


. . . . . . . . . . . . . . . . . . . . . . . . 331

21.1.4.1.3.1. 21.1.4.1.4.

Ne hívódjon a másoló ctor . . . . . . . . . . . . . . . . . . . . . . . . . . . 332


. . . . . . . . . . . . . . . . . . . . . . . . 332

21.1.4.2. Másoló konstruktor és másoló értékadás másodszor . . . . . . . . . . . . . . . . . . . . . . . 332 21.1.4.2.1.


21.1.4.2.1.1. 21.1.4.2.2.

Mi történik, ha? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334


. . . . . . . . . . . . . . . . . . . . . . . . 335

21.1.4.3. Mozgató konstruktor és mozgató értékadás . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335 21.1.4.3.1.


21.1.5. Rule of Five . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337 21.1.5.1. ../source/labor/kartyak/Int5/main.cpp

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339


xxii

22. Laborkártyák kidolgozása

341

22.1. Bevezet˝o laborkártyák . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342 22.1.1. A parancssori interfész (CLI) alapvet˝o használata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342 22.1.1.1. A kézikönyv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342 22.1.1.2. A fordítóprogram . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342 22.1.1.3. Vektorizálás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343 22.1.1.4. A kapcsolatszerkeszt˝o program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343 22.1.2. Az alapvet˝o C és C++ nyelvi konstrukciók használata . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343 22.1.2.1. Nevek bevezetése a programba . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343 22.1.2.2. for el˝oször . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343 22.1.2.3. for másodszor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343 22.1.2.4. for harmadszor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344 22.1.2.5. if el˝oször . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344 22.1.2.6. if másodszor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344 22.1.2.7. while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344 22.1.2.8. const . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344 22.1.2.9. char * . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345 22.1.2.10. Paraméterátadás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345 22.1.3. A szabad tár kezelése . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345 22.1.3.1. char **

IV.

Évkönyv

23. A 2013/14 tanév

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345

346 347

23.1. A tavaszi szemeszter, avagy a prog1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347 23.1.1. Az évfolyam legfontosabb hallgatói - tutor rendszer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347 23.1.1.1. Az évfolyam legfontosabb hallgatói - feladatok megoldása . . . . . . . . . . . . . . . . . . . 347 23.1.1.2. Az évfolyam legfontosabb hallgatói - skillek . . . . . . . . . . . . . . . . . . . . . . . . . . . 347 23.1.1.3. Az évfolyam kapcsolatai . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347 23.1.2. Önbevallások és rövid bio-k . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348 23.1.2.1. Hallgatók . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349 23.1.2.1.1. Kiemelked˝o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349 23.1.2.1.2. Haladó . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349 23.1.2.1.3. Közepes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351 23.1.2.1.4. Kezd˝o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356 23.1.2.2. Oktatók . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384 23.1.2.2.1. El˝oadó . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384 23.1.2.2.2. Gyakorlatvezet˝o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385 23.1.3. Gnoti se auton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386


xxiii

23.1.3.1. Az évfolyam legfontosabb hallgatói - tutor rendszer . . . . . . . . . . . . . . . . . . . . . . . 386 23.1.3.1.1. 2014. március 24-i hét . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386 23.1.3.1.2. 2014. április 7-i hét . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386 23.1.3.2. Az évfolyam legfontosabb hallgatói - feladatok megoldása . . . . . . . . . . . . . . . . . . . 386 23.1.3.3. Az évfolyam legfontosabb hallgatói - skillek . . . . . . . . . . . . . . . . . . . . . . . . . . . 386

V.

Mellékletek

387

A. Mellékletek

388

A.1. A DocBook dokumentum kezelése . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388 A.1.1. Hogyan kezdjem el? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388 A.1.1.1. Parancssori gyorstalpaló . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388 A.1.1.1.1.

Fájlok módosítása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388

A.1.1.1.2.

Fájlok hozzáadása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389

A.1.1.2. A dokumentum érvényességének ellen˝orzése . . . . . . . . . . . . . . . . . . . . . . . . . . . 390 A.1.1.3. A dokumentum olvashatóvá konvertálása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390 A.1.2. Pánikgomb . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390 A.1.3. Pontozási politika . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391 A.2. Házi-versenyek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391 A.2.1. Kolmogorovi bitfaragás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391 A.2.1.1. Szimmetrikusság vizsgálata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391 A.2.1.1.1.

Bátfai Norbert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391

A.2.1.1.2.

Nagy Sándor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392

A.2.1.1.3.

Nagy Sándor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392

A.2.1.1.4.

Mamenyák András . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393

A.2.1.1.5.

Bátfai Norbert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393

A.2.1.1.6.

Mamenyák András . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394

A.2.1.1.7.

Nagy Sándor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394

A.2.1.1.8.

Nagy Sándor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394

A.2.2. Prog1 Robotfoci Labdarúgó Bajnokság (PLB) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395 A.2.2.1. Versenynaptár . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395 A.2.2.2. A PLB lebonyolítása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398 A.2.3. Prog1 Robotfoci Labdarúgó Kupa (PLK) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398 A.2.4. Prog1 Robotfoci PLBPLK-Szuperkupa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399 A.2.5. Prog1 Kvantumfoci Labdarúgó Bajnokság . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399 A.2.6. Prog1 Kvantumfoci Labdarúgó Kupa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399 A.3. Céges feladatok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399 A.3.1. A „céges feladatok” intézménye . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399


xxiv

VI.

401

Irodalomjegyzék

23.4. Algoritmusok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402 23.5. DocBook . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402 23.6. Programozás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402

24. Tárgymutató

403


xxv

Ábrák jegyzéke

1.1. A „kockásítás” feladat bemen˝o képe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 1.2. A „kockásítás” feladat eredménye. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 6.1. Az LZW szófa-építése a 01111001001001000111 bemenetre. . . . . . . . . . . . . . . . . . . . . . . . . . 37 6.2. A sejtautomata programunk egy Nexus 7-en és egy Nexus 4-en. . . . . . . . . . . . . . . . . . . . . . . . . . . 53 6.3. A feladat egy megoldása a Justine protóval, annak Justine Window tagjával. . . . . . . . . . . . . . . . . . . . . 68 6.4. Az A* algoritmus és a Dijkstra algoritmus eredménye ugyanarra az inputra Budapest és Debrecen között. . . . . 69 14.1. A projekt "Tetris-terve". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 15.1. A Mandelbrot halmaz feladat kimenete (kimenet.png). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 15.2. Mammals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176 15.3. LZW szórás alapján . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177 16.1. Futtatás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190 18.1. A sebességteszt eredménye . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239 19.1. A virtuális MINIX nevének megadás (vm1.png). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263 19.2. Virtuális MINIX indítása (vm2.png). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264 19.3. A rendszer betöltése lemezr˝ol (vm3.png). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264 19.4. Genomok összehasonlítása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267 21.1. Dinamikus tömb a tárban. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329 23.1. Pillanatkép a 10. el˝oadásról . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348 23.2. Pillanatkép a 11. el˝oadásról . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348 23.3. Pillanatkép a 12. el˝oadásról . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349 23.4.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349

23.5.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350

23.6. soon... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350 23.7.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350

23.8.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351


23.9.

xxvi

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351

23.10. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352 23.11. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352 23.12. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352 23.13. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353 23.14. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353 23.15. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353 23.16. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354 23.17. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354 23.18. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354 23.19. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355 23.20. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355 23.21. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355 23.22. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356 23.23. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356 23.24. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356 23.25. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357 23.26. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357 23.27. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357 23.28. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358 23.29. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358 23.30. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358 23.31. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358 23.32. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359 23.33. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359 23.34. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359 23.35. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360 23.36. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360 23.37. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360 23.38. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361 23.39. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361 23.40. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361 23.41. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362 23.42. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362 23.43. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362 23.44. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362 23.45. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363 23.46. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363 23.47. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363


xxvii

23.48. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364 23.49. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364 23.50. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364 23.51. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365 23.52. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365 23.53. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366 23.54. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366 23.55. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366 23.56. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367 23.57. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367 23.58. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367 23.59. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367 23.60. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368 23.61. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368 23.62. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368 23.63. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368 23.64. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369 23.65. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369 23.66. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369 23.67. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369 23.68. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370 23.69. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370 23.70. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370 23.71. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371 23.72. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371 23.73. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371 23.74. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371 23.75. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372 23.76. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372 23.77. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372 23.78. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372 23.79. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373 23.80. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373 23.81. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373 23.82. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374 23.83. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374 23.84. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375 23.85. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375 23.86. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375


xxviii

23.87. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376 23.88. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376 23.89. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376 23.90. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377 23.91. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377 23.92. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378 23.93. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378 23.94. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378 23.95. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379 23.96. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379 23.97. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379 23.98. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380 23.99. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380 23.100. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380 23.101. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380 23.102. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381 23.103. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381 23.104. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381 23.105. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382 23.106. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382 23.107. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382 23.108. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383 23.109. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383 23.110. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383 23.111. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384 23.112. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384 23.113. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384 23.114. Dr. Bátfai Norbert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385 23.115. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385 23.116. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386 23.117. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386


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.


xxx

El˝oszó Az évkönyv feladatai képezik a kurzus pontgy˝ujtésének alapját, s így végs˝o soron a megajánlott jegy megszerzését. Ennek megfelel˝oen az évkönyvben való szereplés nem kötelez˝o, csak egy lehet˝oség a kurzus hallgatói számára. Magam az összes szerepl˝o programot megírtam1 , ezek tipikusan elérhet˝oek kurzus blogjáról és részleteikben ki vannak dolgozva a kurzus környezetében, a • Bátfai Norbert: Programozó Páternoszter http://www.inf.unideb.hu/~nbatfai/ProgramozoPaternoszter.pdf, [PP].

• Bátfai Norbert, Juhász István: Javát tanítok, Bevezetés a programozásba a Turing gépekt˝ol a CORBA technológiáig http://www.tankony hu/tartalom/tkt/javat-tanitok-javat, [JAVATTANITOK]. • Bátfai Norbert: Mobil programozás, Nehogy már megint a mobilod nyomkodjon Téged! http://www.inf.unideb.hu/~nbatfai/konyvek/MOBP/mobp.book.xml.pdf, [MOBP]. • Bátfai Norbert: Mesterséges intelligencia a gyakorlatban: bevezetés a robotfoci programozásba http://www.inf.unideb.hu/~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 http://www.inf.unideb.hu/~nbatfai/konyvek/PARP/parp.book.xml.pdf, [PARP]. • Bátfai Norbert: Programozó Páternoszter újratöltve: C, C++, Java, Python és AspectJ esettanulmányok http://www.inf.unideb.hu/~nbatfai/konyvek/PROP/prop.book.xml.pdf [PROP]. • Bátfai Norbert: Paternoster of Programmers Reloaded: C, C++, Java, Python and AspectJ Case Studies http://www.inf.unideb.hu/~nbatfai/konyvek/POPR/popr.book.xml.pdf, [POPR]. könyvek valamelyikében, s˝ot 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˝ol.

A könyv szerkezete Az évkönyv négy nagyobb tartalmi részb˝ol épül fel. Az els˝o a feladatokat kiíró rész, ezt követi a megoldásokat tartalmazó, majd a laborkártyákat bemutató rész. A f˝obb tartalmi elemek lezárásaként ezek után találjuk az évkönyv jelleg˝u részt. A könyvet a használatot segít˝o melléklet, majd az irodalomjegyzék zárja. Szakmai fórum A www.linkedin.com-en létrehoztunk egy szakmai fórumot, konkrétan a The Yearbook of the Programmers of University of Debrecen csoportot, amellyel a http://progpater.blog.hu blog oktatás-szervezo˝ é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 ˝ o˝ tagjai. követni az ipar esetleges felénk érdeklod

1 El˝ ofordulhat, hogy adott feladat kidolgozása nagyobb er˝ofeszí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˝o 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.


A 2013/14 tanév tavaszi és a 2014/15 tanév o˝ szi szemesztere

1 / 404


2 / 404

I. rész

Feladatok


3 / 404

Ebben a részben az el˝oadó és a laborvezet˝ok 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˝od˝o hallgatók végzik. Ehhez természetesen kapnak egy forgatókönyvet, s˝ot 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˝ol. 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 ˝ közepes, haladó és kiemelkedo˝ kategóriák egyikébe a vélt vagy valós progformálisan is sorolják be magukat a kezdo, ramozá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 http://progpater.blog.hu/2013/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 elso˝ számolhatja el, azaz aki kidolgozza és ezt a kidolgozást bemutatja ebben a könyvben.


4 / 404

1. fejezet

A kezd˝o szint programjai A következ˝o feladatok a kurzus kezd˝o szintjére vannak kiírva, egészen pontosan az önmagukat kezd˝onek önbevalló hallgatók számára vagy a magukat magasabb szintre önbevalló tutorok és az önmagukat kezd˝onek ö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˝u kapcsolat, azaz egy tutornak lehet több tutoriáltja, de egy tutoriáltnak nem lehet több tutora. Különböz˝o feladatokban lehet különböz˝o a tutor, de ezeknek a kapcsolatoknak ki kell derülniük az évkönyv részben.

1.1. Az elso˝ 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˝onek van lehet˝osé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.

1.1.1. Végtelen ciklus Ki írja a legszebb végtelen ciklust? Ha megvan a ciklus, két változatot készíts bel˝ole! Az egyik közel 100 százalékban terheljen egy magot, a másik éppen ellenkez˝oleg, 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! Megoldás és megjegyzések A feladat kidolgozását a [PP] jegyzet alapján Bátfai Norbert (oktatói szintu˝ önbesorolás) készítette. ˝ Átnézte, ellenorizte: 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 ˝ mert abból készítünk majd ChangeLog-ot). megoldás részben (csak röviden, hiszen a git komment legyen majd bo,

1.1.2. 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: http://progpater.blog.hu/2011/02/11/elsore_neo_is_az_aszfalt_ala_esett_avagy_emlekek_az_elso_basic_programokr


5 / 404

Megoldás és megjegyzések A feladat kidolgozását Kistamás Dávid készítette. ˝ A megoldás splinttel ellenorizve, nincs hiba. (Busák Zoltán ) ˝ A megoldás átnézve, ellenorizve. (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

1.1.3. Pattogó labda Írj programot, amely egy labdát pattogtat vissza TV játék szer˝uen! (15 pont.)

Íme a feladat kiírása http://progpater.blog.hu/2011/02/11/elsore_neo_is_az_aszfalt_ala_esett_avagy_emlekek_az_elso_basic_programok és egy megoldás: http://progpater.blog.hu/2011/02/13/megtalaltam_neo_t, bár a megjelenítés itt nem téma, csak a koordináták. Az enyémt˝ol teljesen eltér˝o további megoldások +20 pontot érnek! (Eddig két ilyen volt az el˝oz˝o kurzusok során.) Megoldások és megjegyzések Egy eltéro˝ 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éro˝ 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 leellenoriztem splinttel, pattog.c nevu˝ kódot. (Józan csaba)

1.1.4. „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˝o példáját! Megoldás és megjegyzések 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 ellenoriztem splinttel, nem talált hibát. (Busák Zoltán) ˝ A megoldás átnézve, ellenorizve. (Nad Sabolch) ˝ a feladat kidolgozásánál. (Kis Dávid) Leírást készítettem a splint eredményérol

1.1.5. Á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˝o példáját!


6 / 404

Megoldás és megjegyzések A feladat kidolgozását a [PP] jegyzet alapján Kistamás Dávid készítette. ˝ A megoldást splinttel leellenoriztem. (Busák Zoltán) ˝ A megoldás átnézve, ellenorizve. (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 elso˝ verzióhoz hasonló while-t (Ács Raymund)

1.1.5.1. 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˝o ki? A megoldásban szerepeljenek a man 3 rand kézikönyvlapon leírt könyvtári függvények! Kapcsold össze egy cs˝ovezetékkel ezt és az el˝oz˝o átlagszámító programot!

Megoldás és megjegyzések A feladat kidolgozását a [PP] jegyzet alapján Sipos Ferenc készítette. ˝ A megoldást átnéztem, ellenoriztem. (Nad Sabolch) ˝ ˝ Splint-tel ellenoriztem a kódot. Az ellenorzés menetét, és eredményét a feladat kidolgozásában kifejtettem. (Kis Dávid)

1.1.6. A szóhossz a gépeden Írj egy programot, amely megmondja az o˝ 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˝uveleteket használj, a másikban akár a sizeof operátort, lásd a [PP] jegyzet ugyanezen bevezet˝o példáját is! Megoldás és megjegyzések A feladat kidolgozását a Programozó Páternoszter alapján készítettem, a feladatban kiírt 2 különbözo˝ 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 ellenoriztem. Az ellenorzés menetét, és az eredményt a feladat kidolgozásánál kifejtettem. (Kis Dávid) ˝ A megoldást átnéztem, ellenoriztem. (Nad Sabolch)

1.1.7. BogoMIPS Fejleszd tovább az iménti progit egy egyszer˝u BogoMIPS programmá! (15 pont.) Tanulmányozd a m˝ukö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: http://www.inf.unideb.hu/~nbatfai/Prog1_5.pdf.

megjegyzés ˝ A megoldást az eloadás jegyzete alapján készítette: Szentpéteri Annamária. Dátum: 2014.03.17. A megoldást a ../source/kezdo/elsoc/BogoMIPS/bogoMIPS.c nevu˝ fájlban helyeztem el.


7 / 404

1.2. 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!

Megoldás és megjegyzések 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 ellenoriztem. (Busák Zoltán)

1.3. A lexikális elemzéssel kapcsolatos elso˝ programjaid A következ˝o feladatok kizárják egymást! Nem fogadható el olyan megoldás, amely maga olvassa bet˝unké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!

1.3.1. Betuk ˝ számolása Írj olyan programot, ami számolja a bemenetén a bet˝uket, használd a lex-et! (11 pont.) Indulj ki az els˝o http://www.inf.unideb.hu/~nbatfai/Prog1_1.pdf el˝oadás megfelel˝o fóliájából!

Megoldás és megjegyzések A feladat megoldását Akai József Zsolt készítette (Busák Zoltán Tutor segítségével)

1.3.2. 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˝o http://www.inf.unideb.hu/~nbatfai/Prog1_1.pdf el˝oadás megfelel˝o fóliájából!

Megoldás és megjegyzések ˝ A feladat kidolgozását az elso˝ eloadás alapján készítettem. (Kis Dávid) Forrás: ../source/kezdo/elsoc/

szamokszama/szamokszama.l

1.3.3. 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˝o http://www.inf.unideb.hu/~nbatfai/Prog1_1.pdf el˝oadás megfelel˝o fóliájából!

Megoldás és megjegyzések ˝ A feladat kidolgozását a http://www.inf.unideb.hu/~nbatfai/Prog1_1.pdf eloadás alapján készítettem. (Orbán István)


8 / 404

1.3.4. 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˝o http://www.inf.unideb.hu/~nbatfai/Prog1_1.pdf el˝oadás megfelel˝o fóliájából!

Megoldás és megjegyzések ˝ A feladat kidolgozását az elso˝ eloadás alapján készítettem. (Józan Csaba)

1.4. Rendszerprogramozással kapcsolatos elso˝ programjaid A következ˝o példák részletes kidolgozását, szinte ugyanebben a sorrendben megtalálod a [PP] jegyzetben.

1.4.1. Villa Írj egy programot, amely létrehoz egy gyerekfolyamatot, amely árvaként hal meg! (10 pont.)

Megoldás és megjegyzések 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)

1.4.1.1. Zombi

Írj egy programot, amely létrehoz egy gyerekfolyamatot, amely zombi lesz! (10 pont.)

Megoldás és megjegyzések 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 ellenoriztem. Az ellenorzés menetét, és az eredményt a feladat kidolgozásánál kifejtettem. (Csopa Tamás)

1.4.1.2. Riasztás

Írj egy programot, amely létrehoz egy gyerekfolyamatot, majd 5 másodperc múlva kilövi! (15 pont.) Megoldás és megjegyzések 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 ellenoriztem. Az ellenorzés menete és eredménye a feladat kidolgozásánál található! (Kis Dávid)


9 / 404

1.4.2. Utolsó tennivaló Írj egy programot, amely a Ctrl+c-vel való kilövése el˝ott még végrehajt valamit ! (5 pont.)

Megoldás és megjegyzések A feladat megoldását a [KR] könyv függelékje alapján készítettem el (Sipos Ferenc)

1.4.3. Nem lokális ugrások Írj egy programot, amely végtelen ciklusban másolja a sztenderd bemenetét a kimenetére, de egy billenty˝uzetr˝ol jöv˝o Ctrl+c hatására visszaugrik a végrehajtás ez elé a ciklus elé! (15 pont.) Megoldás és megjegyzések 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 ellenoriztem. Az ellenorzés menete és eredménye a feladat kidolgozásánál található! (Bak Balázs)

1.5. Az elso˝ algoritmizálási programjaid 1.5.1. 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˝ol a megvalósításból: http://www.inf.unideb.hu/~nbatfai/konyvek/PARP/parp.book.xml.html#pngpp. Megoldás és megjegyzések 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örlodnek. Illetve ha a png++ headert nem találja a fordító, akkor ez megoldja: sudo apt-get install libpng++-dev - Bereczki László

1.5.2. Elfolyik a PageRank Mi történik a 2. labor PageRank programjában, ha egy lapnak nincs kimen˝o linkje? (A program felhasználásával válaszoljunk!) Töröljük például a JP-re M-b˝ol mutató linket! (5 pont)

Lásd még a feladat kapcsán a http://www.inf.unideb.hu/~nbatfai/kp2/Kozos_Prog2_feladatok_BN_2012osz.pdf és a http://www.slideshar adorepump/ranking-web-pages-presentation linkeket. Megoldások és megjegyzések A feladatot megoldotta: Szentpéteri Annamária. Tutor: Bereczki László. (2014.03.26.) Megoldás: /source/kezdo/elsoc/pagerank/pagerank_1.5.2-3.c ˝ ˝ A kódot splint-tel ellenoriztem. Az ellenorzés menetét, és az eredményt a feladat kidolgozásánál kifejtettem. (Csopa Tamás)


10 / 404

1.5.3. 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˝ol mutató linket módosítsuk M-b˝ol M-be mutatóval! (5 pont)

Lásd még a feladat kapcsán a http://www.inf.unideb.hu/~nbatfai/kp2/Kozos_Prog2_feladatok_BN_2012osz.pdf és a http://www.slideshar adorepump/ranking-web-pages-presentation linkeket.

Megoldások és megjegyzések A feladatot megoldotta: Szentpéteri Annamária. Tutor: Bereczki László. (2014.03.26.) Megoldás: /source/kezdo/elsoc/pagerank/pagerank_1.5.2-3.c ˝ ˝ A kódot splint-tel ellenoriztem. Az ellenorzés menetét, és az eredményt a feladat kidolgozásánál kifejtettem. (Csopa Tamás)

1.5.4. 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: http://progpater.blog.hu/2011/03/11/alternativ_tabella! De természetesen C++-ban dolgozz, ne Java-ban. További 5 pontot számolhatsz el (a feladat kidolgozója) a szorgalmi id˝oszakban 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ó. (2014.03.26.) Megoldás: /source/kezdo/elsocpp/alt_tab/pr.cpp

1.6. Az elso˝ párhuzamos programjaid 1.6.1. 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!

Megoldás és megjegyzések A feladat kidolgozását a Programozó Páternoszter [PP] alapján készítettem.(Kis Dávid) Forrás: ../source/

kezdo/elsoc/elromlik_a_valtozo/zar_nelkul.c ˝ A mindkét forrást splint-el ellenoriztem!(Kis Dávid)


11 / 404

1.7. Az elso˝ GNU/Linux kernellel kapcsolatos programjaid ˝ 1.7.1. „Helló, Világ!” a kernelbol 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.

Megoldás és megjegyzések A feladat kidolgozását a [PP] alapján készítettem. (Gyügyei Tamás)

1.7.2. A PCB mérete Írasd ki a kernelb˝ol! (15 pont.) Az el˝oz˝o 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.

Megoldás és megjegyzések 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.

1.7.3. A PCB mérete modulból Írasd ki a egy kernel modulból! (15 pont.)

1.8. Az elso˝ MINIX kernellel kapcsolatos programjaid A következ˝o feladatok a bemutatás és elszámolás tekintetében kizárják egymást.

˝ 1.8.1. „Helló, Világ!” a kernelbol 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 http://www.inf.unideb.hu/~nbatfai/konyvek/PROP/prop.book.xml.html#elsominixha 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!

Megoldás és megjegyzések A feladat kidolgozását a [PROP] könyv alapján készítettem. (Kis Dávid)


12 / 404

1.8.2. A PCB mérete Írasd ki a kernelb˝ol! (10 pont.) Követheted a részletes kidolgozást a [PROP] könyv http://www.inf.unideb.hu/~nbatfai/konyvek/PROP/prop.book.xml.html#id483616 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!

Megoldás és megjegyzések A feladat kidolgozását a [PROP] könyv alapján készítettem. (Gyügyei Tamás)

1.8.3. 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 http://www.inf.unideb.hu/~nbatfai/os/DEIK_MIPPOS2_BN_2.pdf prezentációban, a megoldások alatti bemutatásnál viszont kerüld kérlek a kép alapú-pillanatképek használatát!


1.8.4. Ü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 http://www.inf.unideb.hu/~nbatfai/os/DEIK_MIPPOS2_BN_2.pdf prezentációban, a megoldások alatti bemutatásnál viszont kerüld kérlek a kép alapú-pillanatképek használatát!


1.9. Az elso˝ C++ programok 1.9.1. Módosított polártranszformációs véletlen szám generátor, ez legyen az elso˝ 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˝opontos 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˝ol a forrásból: http://www.inf.unideb.hu/~nbatfai/p1/forrasok-SVN/bevezetes/elsoC++/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


13 / 404

1.9.2. 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˝oadás egyik fóliájának megoldását: http://www.inf.unideb.hu/~nbatfai/Prog1_5.pdf!

Megoldás és megjegyzések ˝ A feladat kidolgozását az eloadás fóliák alapján Kökéndy Tímea készítette.

1.9.3. 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: http://progpater.blog.hu/2011/03/12/hey_mikey_he_likes_it_ready_for_more_3!

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.

1.9.4. Az elso˝ „nyelvi” programjaid 1.9.4.1. Másoló és mozgató konstruktor és értékadás 1.9.4.2. Mély és sekély másolás

A következ˝o feladatok kizárják egymást! 1.9.4.2.1. 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˝oadás.

Megoldás és megjegyzések A feladatot elkészítettem, megoldás és forrás fájl hamarosan feltöltésre kerül (Takács Miklós)

1.9.4.2.2. 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˝oadás.


14 / 404

Megoldás és megjegyzések A feladat megoldását Kistamás Dávid készítette, Fülöp Sándor tutoriálásával.

1.9.4.2.3. 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˝oadás.


1.9.4.2.4. 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˝oadás.

Megoldás és megjegyzések A feladat megoldását Ozsváth Jonathán készítette (Busák Zoltán Tutor segítségével)

1.9.4.2.5. 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˝oadás.

Megoldás és megjegyzések A feladat megoldását Závaczki Roland készítette.

1.9.5. Az elso˝ Qt programjaid A következ˝o 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.


15 / 404

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

Megoldás és megjegyzések A feladatot Tuza József készítette el Akai József Zsolt és Busák Zoltán megoldása alapján.

1.9.5.2. Szavazás feladat: Mandelbrot szépségverseny

https://www.facebook.com/frak2mandelbrot 1.9.5.2.1. A számítás adatai a képre

Módosíts úgy a Mandelbrot nagyító és ment˝o 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). 1.9.5.3. Szavazás feladat: biomorf szépségverseny

https://www.facebook.com/pages/Csak-a-legszebb-maradhat-II/1456458931256329 1.9.5.3.1. A számítás adatai a képre

Módosíts úgy a Biomorf nagyító és ment˝o 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). ˝ 1.9.5.4. A genetikai kód-szonyeg 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ó http://progpater.blog.hu/2011/03/05/szonyegen_a_human_genom.

Megoldás és megjegyzések 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

˝ 1.9.5.5. További élolények a sejttérben

Módosítsd úgy a közepes szintre kiírt alapfeladatot, melyben további él˝olényeket (például lightweight spaceship) próbálsz ki a sejttérben! (15 pont.)


16 / 404

1.9.6. Az elso˝ képfeldolgozással kapcsolatos programjaid 1.9.6.1. Az elso˝ png++ és pngwriter könyvtárakkal kapcsolatos programjaid 1.9.6.1.1. 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˝o képe.

1.2. ábra. A „kockásítás” feladat eredménye. Ez és a következ˝o feladat kizárja egymást! Forráskóddal is segít a http://progpater.blog.hu/2011/03/26/kepes_egypercesek poszt.

Megoldás és megjegyzés A feladatot elkészítette: Dalmadi Zoltán


17 / 404

1.9.6.1.2. Kockásítás a pngwriter könyvtárral

Végezd el az iménti feladatot, de most a másik png kezel˝o könyvtár felhasználásával! (10 pont.) Ez és az el˝oz˝o feladat kizárja egymást! Forráskóddal is segít a http://progpater.blog.hu/2011/03/26/kepes_egypercesek poszt.

Megoldás és megjegyzés ˝ o˝ feladatát pngwriterrel) A feladatot elkészítette: Csopa Tamás (átdolgoztam Dalmadi Zoltán eloz

1.9.6.2. Az elso˝ Open CV-vel kapcsolatos programjaid 1.9.6.2.1.

1.9.7. Az elso˝ STL-el és Boost-al kapcsolatos programjaid 1.9.7.1. 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 o˝ ket egy mesél˝os posztban a linkedin-en. (A forrásokat ne tedd be, csak jelezd, hogy melyikr˝ol 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˝o 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˝oztes további 15 pontot számolhat el.

1.10. Az elso˝ Java programok 1.10.1. Módosított polártranszformációs véletlen szám generátor, ez legyen az elso˝ Java progid! Ugyanaz, mint az el˝oz˝o, 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˝oi á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



18 / 404

2. fejezet

A közepes szint programjai A következ˝o feladatok a kurzus közepes szintjére vannak kiírva, egészen pontosan az önmagukat közepesnek (vagy kezd˝onek) önbevalló hallgatók számára vagy a magukat magasabb szintre önbevalló tutorok és az önmagukat közepesnek (vagy kezd˝onek) ö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.

2.1. A kezdo˝ szintu˝ feladatokra épített példák 2.1.1. Normálisok A kezd˝o szint˝u normális-generátorral készíts 1.000.000 normálist, s az ugyancsak kezd˝o szint˝u á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. Megoldás és megjegyzések 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 3.11. 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

2.1.1.1. Normális-harang

Az el˝oz˝o 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.

Megoldás és megjegyzések A feladat kidolgozását a [PP] jegyzet alapján Veress Balázs készítette. ˝ ˝ A kódot splint-tel ellenoriztem. Az ellenorzés menetét, és az eredményt a feladat kidolgozásánál kifejtettem. (Csopa Tamás)


19 / 404

2.1.1.2. Normális-harang grafikusan

Írj Qt-s programot: az el˝oz˝o hisztogramot rajzold ki! (25 pont.) Ha az eredmény nem a harang-görbe, akkor nem vagy nyomon.

Megoldás és megjegyzések ˝ o˝ programok alapján készítettük. (Szabó Attila tutor, Haraszti Péter Brúnó tutorált.) A feladat kidolgozását az eloz

˝ 2.1.2. Mérkozés eredmények Írj programot, amely a bemenetér˝ol 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!

Megoldás és megjegyzések A feladat kidolgozását Gálffy Tamás készítette.

2.1.3. Pattogó labda Fejleszd tovább az el˝oz˝o szint kapcsolódó feladatát, hogy a curses könyvtárral mutassa is a labda mozgását! (10 pont.) Íme egy megoldás: http://progpater.blog.hu/2011/02/13/megtalaltam_neo_t.

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

2.2. Rendszerprogramozással kapcsolatos programjaid 2.2.1. 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˝oadás megfelel˝o fóliái alapján!

Megoldás és megjegyzések ˝ A feladat kidolgozását a 3. eloadás megfelelo˝ fóliái alapján készítettem.(Nad Sabolch) ˝ ˝ A kódot splint-tel ellenoriztem. Az ellenorzés menetét, és az eredményt a feladat kidolgozásánál kifejtettem. (Csopa Tamás)


20 / 404

2.2.2. Rendszerstatisztika Írj egy egyszer˝usí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˝oriztem. Az ellen˝orzés menetét, és az eredményt a feladat kidolgozásánál kifejtettem. (Csopa Tamás) Ez Linux alatt egy egyszer˝u á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.

2.3. Képfeldolgozó programjaid A következ˝o párhuzamosítási feladatok kizárják egymást!

2.3.1. P-szálas kockásítás a png++ könyvtárral Fejleszd tovább az el˝oz˝o szint kapcsolódó programját, hogy párhuzamosan dolgozzon P-szálakkal! (15 pont.)

Megoldás és megjegyzések 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

2.3.2. Open MP-s kockásítás a png++ könyvtárral Fejleszd tovább az el˝oz˝o szint kapcsolódó programját, hogy párhuzamosan dolgozzon Open MP-vel! (15 pont.)

Megoldás és megjegyzések A feladatot Tóth Máté készítette. Kód: ../source/kozepes/openmpkockasit/kockapng.cpp ˝ o˝ verzióhoz képest gyorsabb és a színeket is helyesen számolja Készítette:Csermely Attila Tutor:Takács János Az eloz Kód: ../source/kozepes/openmpkockasit/kockasitas_OpenMP.cpp

2.3.3. P-szálas kockásítás a pngwriter könyvtárral Fejleszd tovább az el˝oz˝o 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

2.3.4. Open MP-s kockásítás a pngwriter könyvtárral Fejleszd tovább az el˝oz˝o szint kapcsolódó programját, hogy párhuzamosan dolgozzon Open MP-vel! (15 pont.)

2.4. Az elso˝ Qt programjaid A feladatok iniciális forrásait megtalálod a http://www.inf.unideb.hu/~nbatfai/p1/forrasok-SVN/bevezetes/elsoQt/ lapon.


21 / 404

2.4.1. Arecibói Üzenet Rajzold ki Qt-vel az Arecibói üzenetet! (5 pont.) Lásd még a korábbi posztot is: http://progpater.blog.hu/2011/ 03/05/figyelem_ez_nem_gyakorlat!

Megoldás és megjegyzések 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

2.4.2. Mandelbrot rajzoló Rajzold ki Qt-vel a Mandelbrot halmazt! (5 pont.) Lásd még a korábbi posztot is!

Megoldás és megjegyzések A feladatot Akai József Zsolt készítette.(Busák Zoltán Tutor segítségével) ../source/kozepes/Qt/

mandelbrot/main.cpp

2.4.2.1. Mandelbrot nagyító

Írj Qt-s programot, hogy a Mandelbrot halmaz egérrel kijelölt részét nagyítsa! (7 pont.)

Megoldás és megjegyzések 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

2.4.2.1.1. Mandelbrot halmaz mento˝

Fejleszd tovább az el˝oz˝o kódot, hogy billenty˝u nyomására mentse is a képet! Lásd még a posztot is! Ez a feladat kizárja az els˝o kett˝ot.

Megoldás és megjegyzések A feladatot Deregi Diána készítette el. ../source/kozepes/Qt/mandel_mento/main.cpp

˝ 2.4.3. A genetikai kód-szonyeg Írj Qt-vel a Humán genomot vizualizáló programot! (5 pont.) Lásd még a korábbi posztot is! Az enyémt˝ol eltér˝o megoldás nem esik a hegylakó-szabály hatálya alá, abb˝ol további 2 megoldás elszámolható (különböz˝o hallgatóknak 10-10 pontért).

Megoldás és megjegyzések A feladatot Akai József Zsolt készítette.(Busák Zoltán Tutor segítségével) ../source/kozepes/Qt/

genetikai/main.cpp


22 / 404

2.4.3.1. A kód vizualizációjának mentése

Módosítsd az iménti programot(okat), hogy billenty˝ukkel 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˝o 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: 2014.05.01. Forrás megtalálható: source/binom/D.DianaSz.Annamaria/Frak2 mappában. (Konkrétan a frakablak.cpp 150-160. sorában.)

2.4.4. 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!

Megoldás és megjegyzések 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

2.4.4.1. Sejttér mérete

Módosítsd az iménti programot, hogy billenty˝ukkel lehessen nagyítani, csökkenteni a sejtméretet, illetve a szimuláció sebességét! (5 pont.) A feladat az el˝oz˝ovel kizáró. 2.4.4.2. Sejttér mentése

Módosítsd az iménti programot, hogy billenty˝ukkel lehessen az adott pillanat képét fájlba lementeni! (5 pont.) A feladat az el˝oz˝o kett˝ovel kizáró.

2.4.5. 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˝o 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˝uködhet, a szabályozás célja, hogy egy hallgató megoldja az összes, eléggé hasonló példát).

2.5.1. Folyamatokat számláló modul Írj olyan kernelmodult, ami megmondja, hány folyamat van! (15 pont.)

Megoldás és megjegyzések A feladatot Eszenyi Gábor készítette, Tóth Máté (tutor) segítségével.

folyamatszamlalo/folyszamlalo.c

Kód:

../source/kozepes/


23 / 404

2.5.2. Folyamatokat kiíró modul Írj olyan kernelmodult, amely kiírja az összes folyamatot! (15 pont.)

Megoldás és megjegyzések A feladatot Tóth Máté készítette. Kód: ../source/kozepes/folyamatkiiro/folyamatki.c

2.5.3. Fájlleíró modul Írj olyan kernelmodult, amely minden folyamatra megmondja, hogy melyik a következ˝o szabad állományleíró! (15 pont.) http://progpater.blog.hu/2011/02/19/a_fajlleirok_kicsi_egesz_szamok_nem_mondod

Megoldás és megjegyzések 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 2.6.1. 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˝ oszelet tikk-takkban alakban! (20 pont.) Követheted a részletes kidolgozást a http://www.inf.unideb.hu/~nbatfai/os/DEIK_MIPPOS2_BN_2.pdf prezentációban, a megoldások alatti bemutatásnál viszont kerüld kérlek a kép alapú-pillanatképek használatát!

Megoldás és megjegyzések 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/

2.6.2. Ütemezés Módosítsd úgy a MINIX 3 kernelt, hogy az F3 billenty˝u lenyomására listázza ki az ütemezési sorok futásra kész processzeinek nevét! (25 pont.) Lásd még a http://www.inf.unideb.hu/~nbatfai/os/DEIK_MIPPOS2_BN_4.pdf prezentációt.

2.7. Algoritmizálási programjaid 2.7.1. 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.


24 / 404

Megoldás és megjegyzések 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 ellenoriztem. Az ellenorzés menetét, és az eredményt a feladat kidolgozásánál kifejtettem. (Csopa Tamás)

2.8. Nyelvi programjaid A következ˝o feladatok kizárják egymást!

2.8.1. 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˝oadás.

Megoldás és megjegyzések A feladat megoldását készítette Kakócz Erik.

2.8.2. 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˝oadás.

Megoldás és megjegyzések A feladat megoldását készítette Balogh István Dávid, Dalmadi Zoltán tutor segítségével.


25 / 404

3. fejezet

A haladó szint programjai A következ˝o 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˝u kapcsolat, azaz egy tutornak lehet több tutoriáltja, de egy tutoriáltnak nem lehet több tutora. Különböz˝o feladatokban lehet különböz˝o a tutor, de ezeknek a kapcsolatoknak ki kell derülniük az évkönyv részben.

3.1. Párhuzamos programjaid A kurzusban ezek a példák lesznek az els˝o Pthread, Open MP és Intel TBB programjaid. A feladatok iniciális forrásait megtalálod a http://www.inf.unideb.hu/~nbatfai/konyvek/PARP/ lapon.

3.1.1. Mandelbrot több szálon P-szálakkal Fejleszd tovább a kezd˝o 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˝ol a megvalósításból: http://www.inf.unideb.hu/~nbatfai/konyvek/PARP/parp.book.xml.html#mandelbrotp.

Megoldás és megjegyzések 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

3.1.2. Mandelbrot több szálon Open MP-vel Fejleszd tovább a kezd˝o 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˝ol a megvalósításból: http://www.inf.unideb.hu/~nbatfai/konyvek/PARP/parp.book.xml.html#mandelomp.

Megoldás és megjegyzések 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


26 / 404

3.1.3. Mandelbrot Intel TBB-vel Fejleszd tovább a kezd˝o 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˝ol a megvalósításból: http://www.inf.unideb.hu/~nbatfai/konyvek/PARP/parp.book.xml.html#idp432080.

Megoldás és megjegyzések A feladat kidolgozását Ozsváth Jonathán készítette Busák Zoltán Tutor segítségével.

../source/halado/

parhuzamositas/mandeltbb.cpp

3.1.4. Exor-törés párhuzamosítása Párhuzamosítsd a laborfeladatok exor-törését! (20 pont.) Kiindulhatsz ebb˝ol a megvalósításból: http://www.inf.unideb.hu/~nbatfai/konyvek/PARP/parp.book.xml.html#idp432080.

Megoldás és megjegyzések 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 leellenoriztem. Az eredményt a feladat kidolgozásánál megadtam. (Csopa Tamás)

3.2. A GNU/Linux kernellel kapcsolatos programjaid 3.2.1. A /proc virtuális fájlrendszer Készíts olyan kernelmodult, amely nyomkövet˝o információkat jegyez be a rendszer állományairól a /proc virtuális fájlrendszer alá! (35 pont.) Kiindulhatsz ebb˝ol a megoldásból: http://www.inf.unideb.hu/~nbatfai/konyvek/PROP/prop.book.xml.html#id485799.

Megoldás és megjegyzések 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 rendelkezo˝ kernelhez lett elkészítve. ../source/halado/perprocbejegy/proc.c

3.2.2. 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˝ol a megoldásból: http://www.inf.unideb.hu/~nbatfai/konyvek/PROP/prop.book.xml.html#id486519.

Megoldás és megjegyzések A feladat kidolgozását Tóth Máté készítette, PROP alapján. 3.13.6 kernelen tesztelve. ../source/halado/

kernel_current_proc/current.c


27 / 404

3.3. A MINIX kernellel kapcsolatos programjaid A következ˝o feladatoknál követheted a részletes kidolgozást a http://www.inf.unideb.hu/~nbatfai/os/DEIK_MIPPOS2_BN_3.pdf prezentációban, a megoldások alatti bemutatásnál viszont kerüld kérlek a kép alapú-pillanatképek használatát!

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

Megoldás és megjegyzések A feladat kidolgozását dr. Bátfai Norbert http://www.inf.unideb.hu/~nbatfai/os/DEIK_MIPPOS2_BN_3.pdf jegyzete alapján készítette Takác Ján.

3.3.2. Processzek üzenetmátrixa, saját rendszerhívással Az el˝oz˝o 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.)

Megoldás és megjegyzések A feladat kidolgozását dr. Bátfai Norbert http://www.inf.unideb.hu/~nbatfai/os/DEIK_MIPPOS2_BN_3.pdf jegyzete alapján készítette Takác Ján.

3.4. Rendszerprogramozással kapcsolatos programjaid 3.4.1. Rendszerstatisztika folytatása Fejleszd tovább az el˝oz˝o szint feladatát, legyen karakteres felület˝u, de curses alapú! (35 pont.) Lásd például a [PP] 101. oldalán látható progit!

Megoldás és megjegyzések A feladat kidolgozását Tamics Ádám, tutor Tóth Máté készítette. Megj:Éppen futó processzeket megjeleníto˝ statisztikai adatok. ../source/halado/top/top.cpp

3.5. Algoritmizálási programjaid 3.5.1. 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.


28 / 404

3.6. Képfeldolgozási programjaid 3.6.1. Az elso˝ Open CV-vel kapcsolatos programjaid 3.6.1.1. Labda követése

írj programot „házi videón” a labda követésére! Ilyen videók lehetnek például ezek: http://youtu.be/yf6ijCE5MIE, http://youtu.be/KMziO2TBwls.

Megoldás és megjegyzések A feladat kidolgozását Fábián Kristóf készítette, Kolozsvári Dávid segítségével. Videók: http://youtu.be/LLKNGkE-yTg, http://youtu.be/-ew3aXJqChI, Kód : ../source/halado/labda_kovetese_opencv/BallTracking/Main.cpp


29 / 404

4. fejezet

A kiemelked˝o szint programjai A következ˝o feladatok a kurzus kiemelked˝o szintjére vannak kiírva.

4.1. CUDA programok A feladatok iniciális forrásait megtalálod a http://www.inf.unideb.hu/~nbatfai/konyvek/PARP/ lapon.

4.1.1. Az EXOR-kódtörés CUDA párhuzamosítása

Kiemelkedo˝ implementáció ˝ o˝ félévek munkái közül Mamenyák András munkáját emelhetjük ki, amelyet bátran tekinthetsz kiindulási A megeloz alapnak is akár: https://github.com/mamenyaka/CUDA-Exor.

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

4.2.1. QCSS 2D megjeleníto˝ 2D grafikus megjelenít˝o írása a Quantum Consciousness Soccer Simulator - kvantum-tudatos foci szimulátorhoz C++ nyelven, Qt-vel. (40 pont.) Kiindulási alap: http://sourceforge.net/projects/qcss/files/qcssp/.

Kiemelkedo˝ implementáció ˝ o˝ 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 A megeloz akár: http://sourceforge.net/projects/qcssp/.

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


30 / 404

4.3. RCSS programok 4.3.1. 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.)

Megoldás és megjegyzések 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 4.4.1. MINIX 3 ütemezo˝ Készítsd el a Tanenbaum könyv 237. oldali 45. feladatát, azaz „módosítsa a MINIX 3 ütemez˝ot úgy, hogy az tartsa nyilván, melyik felhasználói processzus mennyi CPU id˝ot kapott legutóbb. Amikor nincs futtatható taszk vagy szerver, válassza azt a felhasználói processzust, amely legutóbb a legkevesebb id˝ot kapta!”. (80 pont.)

Megoldás és megjegyzések 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.

4.5. Algoritmizálási programjaid 4.5.1. 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.


31 / 404

5. fejezet

A védések programjai A következ˝o feladatok, vagy azok saját klónjai minden hallgató számára kötelez˝oek.

5.1. A 2013/14 tanév tavaszi szemeszterének védései 5.1.1. Az elso˝ 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˝o forrásokat. A feladatok iniciális forrásait megtalálod a ../source/vedes/elso/z3a7.cpp lapon.

5.1.2. 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 http://www.inf.unideb.hu/~nbatfai/konyvek/PROP/ lapon.

˝ 5.2. A 2014/15 tanév oszi szemeszterének védései 5.2.1. 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˝oá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˝oen lett volna felhasználói közössége. Ám a politika senkit nem fog érdekelni a következ˝o 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˝oágba. A YANO git repóját itt találod: https://sourceforge.net/projects/yanonymous/.

5.2.2. 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˝ott megvédeni.


32 / 404

6. fejezet

A labor-mérés programjaid 6.1. A 2013/14 tanév tavaszi szemeszterének labor-mérései A következ˝o feladatok, vagy azok saját klónjai minden hallgató számára kötelez˝oek. 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˝o laborközösség is pontokat szerezhet ezekkel: egyrészt él˝oben é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˝ol a pontszerzésr˝ol melegében tudósítani kell!

6.1.1. Ismerkedo˝ labor 6.1.1.1. 1. labor

Minden hallgató egyénileg és a laborvezet˝o 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˝ot stb. Ezen a laboron még nem osztunk laborkártyákat, viszont lehet˝oség szerint egy szekvenciális végigolvasással, a nehezebb résznek érzetteken esetleg akár ugorva, gy˝urjük le a [STROUSTRUP] tankönyv bevezetését, azaz az els˝o 85 oldalt és beszéljünk ennek élményeir˝ol a laboron!

6.1.2. Bevezeto˝ laborok Minden bevezet˝o labor a laborkártyák és a kötelez˝o olvasmány gyors ellen˝orzésével kezd˝odik! (A bevezet˝o laborokon a megoldásokban egyaránt használható C, C++, legalábbis ahol a C egyáltalán értelmezhet˝o.) 6.1.2.1. A második labor

A parancssori interfész (CLI) alapvet˝o használata cím˝u pontok laborkártyáinak feldolgozását ellen˝orizzük! Minden kezdet nehéz ˝ ha a hallgató még A második csokor laborkártyában vannak nem triviális nevek is... a második laboron elegendo, 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˝o olvasmány erre a laborra a [STROUSTRUP] tankönyv els˝o 85 oldala.


33 / 404

6.1.2.1.1. Egy saját Google PageRank implementáció

Ez tk. egy burkolt „for ciklus” feladat, hiszen, ha valóban érted a PR algoritmust, akkor egyszer˝uen egy „mátrix szorozgatása vektorral” feladat ez csupán! Az algoritmust az el˝oadá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 / {1.0, 1.0 / 2.0, {0.0, 1.0 / 2.0, {0.0, 0.0, 1.0 / };

3.0, 0.0}, 1.0 / 3.0, 1.0}, 0.0, 0.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) < 0.00000001) break; /* Itt készítjük újra el˝ o a vektort a következ˝ o szorzáshoz.*/ } kiir (PR, 4); return 0; }


34 / 404

S ugye csak végs˝o elkeseredésedben nyúlsz a tárolóban lév˝o futó ../source/labor/pr/pr.c kódhoz, ezzel persze a feladat kapcsán automatikusan kivonod magad a pontversenyb˝ol! A laboron szület˝o els˝o 3 megoldás 5 pontot ér, ett˝ol természetesen független a feladat aszinkron kidolgozása a megoldásokat bemutató részben. Illetve azt a szokást tartjuk, hogy aki el˝ore 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˝o legyen. 6.1.2.2. A harmadik labor

Az alapvet˝o C és C++ nyelvi konstrukciók használata cím˝u pont laborkártyáinak feldolgozását ellen˝orizzük! A kötelez˝o olvasmány erre a laborra a [STROUSTRUP] tankönyv 87-113 oldala és a [KR] könyvb˝ol durván az els˝o 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˝o feladata után az Exor-töréssel foglalkozik. A munka menetét részletesen kidolgoztuk például a posztban. 6.1.2.2.1. Exor-törés

A f˝o 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˝ol a megvalósításból: http://www.inf.unideb.hu/~nbatfai/konyvek/PARP/parp.book.xml.html#idp1066240. 6.1.2.2.1.1. A kapcsolódó laborfeladatok

Az alábbi szimplább feladatok vezetik be a f˝o feladatot. 6.1.2.2.1.2. e.c

Önállóan írjuk meg a saját EXOR titkosítónkat, a szokásos módon a laborokon csak végs˝o elkeseredésben forduljunk a kész ../source/labor/exor/e.c kódhoz! Az els˝o három 5 pontot kaszálhat. 6.1.2.2.1.3. t.c 6.1.2.2.1.4. A t.c kiegészítése

Az el˝oz˝o labor mintájára pótold az alábbi kód hiányzó részeit! Ezt mutatja be poszt. #define #define #define #define

MAX_TITKOS 4096 OLVASAS_BUFFER 256 KULCS_MERET 8 _GNU_SOURCE

#include <stdio.h> #include #include <string.h> 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) { // 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˝ o "f˝ uré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)))

35 / 404


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! 6.1.2.3. A negyedik labor

A kötelez˝o olvasmány erre a laborra a [STROUSTRUP] tankönyv 114-140 oldala. A szabad tár kezelése cím˝u pont laborkártyáinak feldolgozását ellen˝orizzük! S természetesen visszafelé az eddigi összes laborkártya éles! 6.1.2.3.1. Liv-Zempel fa építése a humán genom emberi 2. kromoszómájából

A f˝o feladat (és egyben az els˝o 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˝ol a megvalósításból: www.inf.unideb.hu/~nbatfai/z3a7.cpp. Aki nem ír sajátot, annak ez a forrás lesz a védend˝oje az els˝o védésén! De ma még csak felvezetjük ezt a programot az alábbi kapcsolódó pontokkal. 6.1.2.3.1.1. A kapcsolódó laborfeladatok

Az alábbi szimplább feladatok vezetik be a f˝o (s egyben védési) feladatot.


37 / 404

6.1.2.3.1.2. 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 4464650, 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 4558302, 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˝u könyv alapján: jön a 0-1 sorozat, bet˝unként olvassuk, ha olyan rész jön, ami még „nincs a zsákban”, akkor „letörjük és be a zsákba”: 00011101110 -> 0 00 1 11 01 110, ennek a bekezdésnek a gondolatmenetét a korábbi posztunkban olvashatod. Bevezetésképpen végezd el az algoritmust a 01111001001001000111 sorozaton a z.c forrás felhasználásával, amelynek üzemér˝ol szól a következ˝o, még a poszthoz készített ábra.

6.1. ábra. Az LZW szófa-építése a 01111001001001000111 bemenetre. [nbatfai@desteny ziv]$ gcc z.c -o z -std=c99 -lm [nbatfai@desteny ziv]$ echo 01111001001001000111|./z ------------1(3) ---------1(2) ------1(1) ---------0(2) ------------0(3) ---------------0(4) ---/(0) ---------1(2) ------0(1) ---------0(2) melyseg=4


altag=2.750000 szoras=0.957427

6.1.2.3.1.3. z.c

// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // //

z.c LZW fa épít˝ o Programozó Páternoszter Copyright (C) 2011, Bátfai Norbert, [email protected], [email protected] 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, http://progpater.blog.hu/2011/02/19/gyonyor_a_tomor 0.0.2, csomópontok mutatóinak NULLázása (nem fejtette meg senki :) 0.0.3, http://progpater.blog.hu/2011/03/05/ labormeres_otthon_avagy_hogyan_dolgozok_fel_egy_pedat

// #include #include #include #include

<stdio.h> <stdlib.h> <math.h>

typedef struct binfa { int ertek; struct binfa *bal_nulla; struct binfa *jobb_egy; } BINFA, *BINFA_PTR;

38 / 404


BINFA_PTR uj_elem () { BINFA_PTR p; if ((p = (BINFA_PTR) malloc (sizeof (BINFA))) == NULL) { perror ("memoria"); exit (EXIT_FAILURE); } return p; } extern extern extern extern

void void void void

kiir (BINFA_PTR elem); ratlag (BINFA_PTR elem); rszoras (BINFA_PTR elem); 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; } } }

39 / 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); }

// // // // int

a Javacska ONE projekt Hetedik Szem/TudatSzamitas.java mintajara http://sourceforge.net/projects/javacska/ az atlag() hivasakor is inicializalni kell oket, a a rekurziv bejaras hasznalja 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;

40 / 404


} } } // a Javacska ONE projekt Hetedik Szem/TudatSzamitas.java mintajara // http://sourceforge.net/projects/javacska/ // 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)

41 / 404


42 / 404

{ szabadit (elem->jobb_egy); szabadit (elem->bal_nulla); free (elem); } }

A forráskód itt található: ../source/labor/ziv/z.c 6.1.2.3.1.4. d.c

A z.c programmal a humán genom 2. kromoszómáját 0, 1 sorozatként szeretnénk feldolgozni, egyel˝ore 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˝ol. #include <stdio.h> #include 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.LZWtree

-

real 9m29.787s user 3m17.285s sys 6m8.516s

Nagy a program id˝obonyolultsága, ezért vágjunk le a humán genomi bemenet (tehát nem a dump) elejéb˝ol 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˝ol a kivágást egy szimpla számlálótól függ˝o kiugratással érjük el, ha a számláló eléri a kell˝o 10 * 1024 * 1024 értéket.


43 / 404

6.1.2.3.1.5. A h.c és a g.c

A humán genomos adatállományokban a T, C, A és G bet˝uk hármasával egy fehérjét kódolnak a genetikai kódnak megfelel˝oen. A ../source/labor/ziv/h.c két nukleotid bázisból egy hexadecimális bet˝ut készít, lásd még ezt a posztot is! #include <stdio.h> #include 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 break; case ’C’: masodik break; case ’A’: masodik break; case ’G’: masodik break; }

= 0;

= 1;

= 2;

= 3;

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˝oen a kódolt aminosavakat adja meg. // // // // // // // // //

g.c genetikai kód nyomtató Programozó Páternoszter Copyright (C) 2011, Bátfai Norbert, [email protected], [email protected] 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: szösszenet A http://progpater.blog.hu/2011/02/27/a_human_genom_projekt poszt bevezet˝ o 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: http://progpater.blog.hu/2011/03/05/szonyegen_a_human_genom

#include <stdio.h> #include // Egyszer˝ uen felsorolom, pl. az alábbi alapján: // http://en.wikipedia.org/wiki/DNA_codon_table 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. };

44 / 404


// a 3 bet˝ u 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˝ u a "Val" // GTT-t˝ ol 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:

45 / 404


index = break; case 8: case 9: index = break; case 10: case 11: index = break; case 24: case 25: index = break; case 26: case 27: index = break; case 40: case 41: index = break; case 42: case 43: index = break; case 56: case 57: index = break; case 58: case 59: index = break; case 12: case 13: index = break; case 14: index = break; case 15: index = break; case 28: case 29: case 30: case 31: index = break; case 44: case 45: index = break; case 46: case 47: index = break; case 60: case 61: case 62: case 63:

9;

10; // Stop 0;

11;

12;

13;

14;

15;

16; // Cys 17; // Stop 0; // Trp 18; // Arg

19; // Ser 6; // Arg 19; // Gly

46 / 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˝ uket 3-asával "olvasom": nem kell cifrázni! egy ciklus // elvégzi, amiben megjegyzem, hogy melyik hányadik bet˝ u volt // aki ciklusban ciklusolgat, az már bénázik :) int main (void) { // hányadik bet˝ un á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)); } } }

47 / 404


48 / 404

6.1.2.3.1.6. Labor és szorgalmi laborfeladatok 6.1.2.3.1.7. Aminosav-hisztogram

Ez csak a kezd˝o 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 kezdo˝ szintu˝ programok megoldásainak legvégére beillesztve a rövid magyarázat. Szentpéteri Annamária (Szerda 10-12)

6.1.2.3.1.8. Még drágább aminosav-hisztogram

Ez csak a kezd˝o szinten választható feladat, adj az én megoldásomtól: ../source/labor/ziv/ga.c különböz˝ot 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_003280.fna [nbatfai@desteny ziv]$ gcc -O3 ga.c -o ga -std=c99 [nbatfai@desteny ziv]$ ./ga
-

Lásd még ezt a posztot is! 6.1.2.3.1.9. Az aminosav-hisztogram mindig drága

Ez csak a kezd˝o szinten és tutoriált formában választható feladat, az el˝oz˝o két pont programját írd át szép tiszta C++-ba! (5-5 pont.) ˝ C++ 6.1.2.3.1.10. C-bol

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


49 / 404

6.1.2.3.1.11. PyTCAG

Írd át Python-ba az LZW-s z.c-nket olyanra, hogy nem 0, 1 bet˝ure, hanem a T, C, A, G bet˝ukre megy! (15 pont.) 6.1.2.3.1.12. PySzavak

Írd át Python-ba az LZW-s z.c-nket olyanra, hogy nem 0, 1 bet˝ure, s nem is a T, C, A, G bet˝ukre, hanem tetsz˝oleges szavakra menjen a fa építése. (20 pont.) 6.1.2.3.1.13. 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˝o cím˝u mérését! (30 pont.) 6.1.2.3.1.14. 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˝o cím˝u mérését! (30 pont.) 6.1.2.3.1.15. Filogenetikai fa az LZW-s fa ághosszainak szórása alapján

A http://arxiv.org/abs/cs/0111054 cikk vezeti be a hasonlósági metrikát, a cikkben az els˝o á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: http://www.complearn.org/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˝o kutatási munka, egy esetleges publikáció.

Megoldás és megjegyzések A feladat megoldását Deregi Diána készítette.

˝ a hetedik laborig 6.1.2.4. Az ötödiktol

A kötelez˝o olvasmányok ezekre a laborokra sorrendben a következ˝ok a [STROUSTRUP] tankönyv 142-187, 191-218 és 221258 oldalai. A [KR] könyvb˝ol pedig a Struktúrák cím˝u fejezetet olvassuk most ért˝o 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 142-187 oldalai. A [KR] könyvb˝ol pedig a Struktúrák cím˝u fejezetet olvassuk most ért˝o 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 191-218 és 221-258 oldalai. • A [STROUSTRUP] tankönyv 295-340 oldalai. Laborkártyák tekintetében a C++ alapfogalmak cím˝u 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˝orizzük, hogy mindenki felvitte-e a bio-ját az évkönyv részbe! A bio tartalmazza legalább a következ˝o 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˝orizzük, hogy a házi versenyek kolmogorovi bitfaragsába mindenki legalább olyan szinten bekapcsolódott, hogy az évkönyvbe bekerül˝o kódokat kipróbálta és érti.


50 / 404

Az 5., 6. és a 7. laboron történik az els˝o védés, ennek megfelel˝oen 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˝ok ismertetik a védend˝o programot, illetve az el˝ore készül˝o legjobbak máris próbálkozhatnak a védéssel. A védés tulajdonképpen az el˝oz˝o 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. 6.1.2.4.1. A védési program megalapozása

Ez az egyszer˝u 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. 6.1.2.4.1.1. Bináris fa

A bináris fánkat egyszer számokkal, máskor sztringekkel fogjuk feltölteni. Ennek megfelel˝oen két indító állományt készítünk, amelyek a sztenderd bemenetr˝ol számokat, illetve sztringeket olvasnak be és nyomják azokat a fába. 6.1.2.4.1.2. 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˝uen kishifteljük a kimenetre, azaz úgy nyomtatjuk ki, hogy elegánsan kinyomjuk a kimeneti csatorna (ostream osztálybeli) cout objektumra. Lássuk a m˝ukö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)


51 / 404

6.1.2.4.1.3. maini.cpp

../source/labor/binfa/maini.cpp #include "int.h" #include "binfa.h" int main () { BinFa 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 42 41 43 42 41 43 ------43(2, 1) ---42(2, 0) ------41(2, 1)

6.1.2.4.1.4. 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 BinFa { class Csomopont {

A kód további érdekessége, hogy a BinFa osztályon belül definiáljuk a Csomopont osztályt. 6.1.2.4.1.5. int.h

Az Int osztály egy egész értéket csomagol be, a ../source/labor/binfa/int.h forrásban definiáljuk.


52 / 404

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

6.1.2.4.2. Qt programok

Próbáld ki a korábbi Qt4-es egyszer˝u OO szerkezet˝u kis programokat. Az Arecibói üzenettel kezd, ez a legegyszer˝ubb, csak egy vásznat tartalmaz, ahová dekódolja a

00000010101010000000000001010000010100000001001000100010001001011001010101010101010100100100000000000

üzenetet, ennek a posztnak megfelel˝oen: http://progpater.blog.hu/2011/03/05/figyelem_ez_nem_gyakorlat. 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˝obb 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˝usítjük majd több lépésben, miközben majd Androidos eszközökre is poroljuk o˝ 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 [nbatfai@desteny [nbatfai@desteny [nbatfai@desteny

AreciboiUzenet]$ AreciboiUzenet]$ AreciboiUzenet]$ AreciboiUzenet]$

qmake -project qmake AreciboiUzenet.pro make ./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

6.1.2.4.2.1. Arecibói üzenet

../source/labor/Qt/AreciboiUzenet 6.1.2.4.2.2. Mandelbrot halmaz

../source/labor/Qt/Frak 6.1.2.4.2.3. Sejtautomata

../source/labor/Qt/Sejtauto 6.1.2.4.2.4. 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


53 / 404

6.2. ábra. A sejtautomata programunk egy Nexus 7-en és egy Nexus 4-en.

6.1.2.4.3. Programok párhuzamosítása 6.1.2.4.3.1. A Mandelbrot-számoló párhuzamosítása 6.1.2.4.3.2. Az exor-törés Open MP párhuzamosítása

6.1.3. Robotfocis laborok 6.1.3.1. A nyolcadik labor

A kötelez˝o olvasmány a [STROUSTRUP] tankönyv 344-391. 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˝ovel lenne egyenl˝o; illetve tehát foglalj majd helyet int **-ok, int *-ok és int-ek megfelel˝o tömbjeinek). A destruktor pedig szabadítsa a tárat.


54 / 404

Megoldás és megjegyzések A ../source/labor/kartyak/matrix.cpp laborkártyát Bereczki László elkészítette.

6.1.3.1.1. Kick-off 6.1.3.1.1.1. Bemelegítés - legyen kapus a kapus

Észreveheted, hogy a foresztes csapatok nem csatolnak kapust, vagyis csatolnak, csak sem o˝ k, sem a szoftver nem tudja róluk, hogy o˝ k a kapusok (mez˝onyjátékosra van színezve a kapusunk a monitor programban). Ne hagyd ennyiben! Közösen ne hagyjuk annyiban! Els˝o lépésként kezd el forgatni a doksit: manual-20030211.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-15.1.0.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˝oen ezt kell módosítanod. Számtalan lehet˝osé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());

6.1.3.2. A kilencedik labor

Javítandó a kötelez˝o olvasmány feldolgozásának színvonalát összekötjük azt a laborkártyákkal az alábbi formában: a következ˝o kérdést mindenkinek meg kell válaszolnia a binomjának (akinek id˝okö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˝uköd˝o példának! (Természetesen az összes eddigi laborkártya éles.) 6.1.3.2.1. A második védés megalapozása 6.1.3.2.1.1. 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: http://youtu.be/93F43ppEQ2g. 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˝ol: Véd˝o a kapufához, egy támadó el˝ore kontrához (25 pont az els˝o ötnek a laboron, megkötések nélküli tutor rendszer támogatott).


55 / 404

6.1.3.3. 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˝ol történ˝o bemutatásával kezd˝odjö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˝o használatának milyen problémája van és hogyan oldottuk meg ezt a csapatunkban? A tizedik laborra a kötelez˝o olvasmány a [STROUSTRUP] tankönyv 395-427. Laborkártyaként mutassunk példát saját egyszer˝u kódban a Liskov-elv (LSP) sérülésére (lásd még az err˝ol szóló beszélgetést is a fórumunkon). Illetve az el˝oz˝o labor laborkártyájának számológépes (tankönyvi) kódját tudjuk elmagyarázni. A tizenegyedik laborra a kötelez˝o olvasmány a [STROUSTRUP] tankönyv 431-465. Laborkártyaként mutassunk példát saját kódban másoló konstruktor mélymásoló megvalósítására az els˝o védési programunkban, továbbá dolgozzuk fel ezt a rule of five-os példát. 6.1.3.3.1. Laborfeladatok

El˝otérben védünk, a háttérben ezekb˝ol 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˝uködését (30 pont, az els˝o 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˝uködését (20 pont, az els˝o 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˝uködését (20 pont, az els˝o 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 = 78.00448175529627 var = 8.858157521688605

-

• É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˝usí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 [nbatfai@desteny [nbatfai@desteny [nbatfai@desteny ...

yanoteszt]$ wget http://www.inf.unideb.hu/~nbatfai/YANonymous/1.tar.bz2 yanoteszt]$ tar xvjf 1.tar.bz2 yanoteszt]$ cd 1/YANonymous/ YANonymous]$ mvn clean install


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-1-0.0.1-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 -1-0.0.1-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-1-0.0.1-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˝oállítását (Maven életciklusok) vezérl˝o pom.xml állományon is reszelni kell, erre a csipetre cseréld a gondot okozó (mert lesz vele gond: falióra lesz :) régit: com.jayway.maven.plugins.android.generation2 <artifactId>android-maven-plugin 3.8.0 <extensions>true

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_64-20131030/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˝oá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˝ol húzva lehessen létrehozni és ezt egy éllel is jelölje a program (ebben segít a http://www.inf.unideb.hu/~nbatfai/YANonymous/2.tar.bz2 de csak végs˝o elkeseredésben, vagy az els˝o benyomások megszerzése miatt nyisd ki és ne szolgaian csak másold!

6.1.4. Kvantum-tudatos laborok 6.1.4.1. A tizenkettedik labor

A kötelez˝o olvasmány a [STROUSTRUP] tankönyv 467-509. 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˝ojét! (10 pont, illetve 15, ha ezt egy YouTube videóban is bemutatod) Írj saját Qt-s megjelenít˝ot a QCSS szimulátorhoz! (50 pont felett választható, 35 pont) Kiindulhatsz az enyémb˝ol, vagy akár valamelyik tavalyiból, például http://sourceforge.net/projects/qcssp/.


57 / 404

6.1.5. A céges feladatok bevezetése 6.1.5.1. Az utolsó labor

A 2014-2015 tanév szeptemberi szemeszterét˝ol a Prog2 (Magasszint˝u 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˝od˝o, 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˝o neve, email címe, továbbá a feladat megoldása bekerülhet a GNU GPL v3-as engedély˝u UDPROG (The Yearbook of the Programmers of University of Debrecen, http://sourceforge.net/projects/udprog/) 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˝ojegye 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˝o 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˝ore 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˝o 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˝u diákok a régióban. Szervezz le egy ilyen feladatot! (50 pont felettieknek, 70 pont, nincs hegylakó-szabály, s˝ot egy hallgatónak is lehet több megoldása, azaz leszervezett feladata, de a cég legalább emailben er˝osí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 6.1.5.2. Lespecifikált feladatok

Itt csak a specifikáció szerepeljen, a specifikáció és implementáció majd a következ˝o szemeszter évkönyvében kap helyet.

Csak engedélyek birtokában ˝ a fent hangsúlyozott engedélyeid már megvannak írásban (legalább Csakis akkor listázd itt a feladatot, ha a kiíró cégtol emailben)!

A céges feladatok intézményének részletesebb kifejtése az appandixben található.


58 / 404

˝ 6.2. A 2014/15 tanév oszi szemeszterének labor-mérései 6.2.1. Beszokató labor 6.2.1.1. Az elso˝ 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˝ot stb. Ebben a kurzusban már nem osztunk laborkártyákat, viszont a kötelez˝o olvasmányokat majd még ellen˝orizzük.

6.2.2. Bevezeto˝ laborok Minden bevezet˝o labor a kötelez˝o olvasmány és néhány forráskód gyors ellen˝orzésével kezd˝odik! 6.2.2.1. A második labor

A kötelez˝o olvasmány erre a laborra a [JAVAKONYV] tankönyv els˝o 35 oldala. Továbbá szúrópróba szer˝uen a laborközösség magyarázza el a poszt Java kódját (a szokásos feketézés tehát van). 6.2.2.1.1. A védési program Java és C# átirata

Az el˝oz˝o féléved els˝o védési programját írd át más nyelvekre! A Java átirat minenkinek kötelez˝o, ezt már hozd magaddal a laborra. Az átíráshoz forgasd a könyvet és az API doksit! Ha leküzdhetetlennek t˝un˝o nehézségeid támadnak, ámde csakis ebben a végs˝o esetben, használd az én átiratomat: LZWBinFa.java (lásd még a posztot is). Laborközösségenként 20 pont az els˝o háromnak, de a kódnak természetesen különböznie kell az enyémt˝ol! További 20 pont üti a markát annak az els˝o 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˝o 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˝o C/C++ megoldást és átiratot hasonlítani az eredeti z3a7.cpp megoldáshoz).

Megoldás és megjegyzések Java átirata: itt Megoldotta: Orbán István

Megoldás és megjegyzések Python átirat: itt Készítette: Dalmadi Zoltán

Megoldás és megjegyzések C# átirat: itt Készítette: Fenesi Gábor, Tutor: Fülöp Sándor


59 / 404

Megoldás és megjegyzések Sebességteszt eredménye: itt Készítette: Balkus Gergo˝ Tutor: Fülöp Sándor

6.2.2.1.2. 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˝u pontjában)! Húsz pont az els˝o háromnak, aki megmagyarázza a monitor programos elemzés kapcsán a poszt beállította szituációt.

Megoldás és megjegyzések Megoldás itt Készítette: Sipos Ferenc

6.2.2.1.3. További pontgyujt ˝ o˝ 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˝o 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! Megoldás és megjegyzések Java átirat: itt C# átirat: itt Megoldotta: Fenesi Gábor Tutor: Fülöp Sándor Python átirat: itt Megoldotta: Balkus Gergo˝ Tutor: Fülöp Sándor

• A http://www.inf.unideb.hu/~nbatfai/kp2/Kozos_Prog2_feladatok_BN_2012osz.pdf poszt 17-31. feladatai kvíz kérdések, kérdésenként 5 pont üti a markát a válaszoló els˝o hallgatónak. Megoldás és megjegyzések 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). Megoldás és megjegyzések 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 Gergo˝ Tutor: Fülöp Sándor


60 / 404

• 25 pont, ha ezt a Maven alapú Helló Világ! szervletes példát feléleszted tetsz˝oleges környezetben, s további 20 pont minden más környezetért (pl. az el˝oadá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 és megjegyzések ˝ Megoldás (Eloadá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˝oadá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 és megjegyzések Megoldás itt Készítette: Orbán István

6.2.2.2. A harmadik labor

A kötelez˝o olvasmány erre a laborra a [JAVAKONYV] tankönyv a 35-75 és a 112-170 oldala. Továbbá szúrópróba szer˝uen a laborközösség magyarázza el a projektek egyikének Java kódját. 6.2.2.2.1. 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˝o 8 esetet: http://www.inf.unideb.hu/~nbatfai/YANonymous/. Laborközösségenként az els˝o 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˝o teszteléshez. Megoldás és megjegyzések Megoldás itt Megoldotta: Fenesi Gábor Tutor: Fülöp Sándor Megoldotta: Balkus Gergo˝ Tutor: Fülöp Sándor


Ezeknél a feladatoknál felfüggesztjük a hegylakó-szabályt, helyette id˝okorlátot vezettünk be a kidolgozásukra. • A Városi hangya felélesztése (40 pont, tutor rendszerben készíthet˝o, de csak szept. 30-ig). A program egyszer˝uen 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: http://progpater.blog.hu/2011/04/26/varosi_hangya_2 http://progpater.blog.hu/2011/04/22/varosi_hangya http://youtu.be/QStgBZ6JfAU . A felélesztést ez alapján érdemes csinálni: http://www.inf.unideb.hu/~nbatfai/konyvek/MOBP/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˝uködjön például így: http://javacska.lib.unideb.hu/hangyak/ vagy így: http://javacska.lib.unideb.hu/programkak/hangyak.html From sctarch dolgozz! Tehát itt nincs térkép, nincs semmi hálózati kérdés, csak hangya-szimuláció. Kiindulhatsz olyasmib˝ol, 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


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˝o algoritmusa m˝uködjön alapban az itt leírt: "a legbüdösebb irányba megy" módon: http://javacska.lib.unideb.hu/programkak/hangyak.html 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˝ol 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˝oz˝ohöz hasonlóan C++ programot, amely Debrecen összes utcájának a nevét kilistázza. (25p)

6.2.3. YANO laborok Minden YANO labor az 1-8-as YANO-k forrásai ismeretének (és természetesen a kötelez˝o olvasmány) ellen˝orzésével kezd˝odik! 6.2.3.1. A negyedik labor

A kötelez˝o olvasmány erre a laborra a [JAVAKONYV] tankönyv 75-88 és 248-266 ért˝o olvasással és legalább egy-egy tartalmazott példa kidolgozásával, a 172-240 egyszeri elolvasással. 6.2.3.1.1. YANO hack

Labormunka a YANO-kon, vagy direktben egy saját ágon a hivatalos YANonymous repóban. 6.2.3.1.2. További pontgyujt ˝ o˝ 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˝oké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˝o szakmai komment további 3 pontot ér, a like pedig további egyet. Megoldás és megjegyzések Megoldás itt,.. readme ../source/labor/prog2lab/HumanGeomHPROF/ Megoldotta: Fenesi Gábor Tutor: Balkus Gergo˝

• Írj egy saját egyszer˝u 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˝o szakmai komment további 3 pontot ér, a like pedig további egyet. Hegylakó-szabály kikapcsolva.

Megoldás és megjegyzések 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˝ol. Posztonként 10 pont, illetve minden érkez˝o szakmai komment további 3 pontot ér, a like pedig további egyet.


62 / 404

Megoldás és megjegyzések 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˝u pont alatt találsz) 20 pont, illetve minden érkez˝o szakmai komment további 3 pontot ér, a like pedig további egyet.


6.2.3.2. Az ötödik labor

A kötelez˝o olvasmány erre a laborra a [JAVAKONYV] tankönyv 303-344 és 349-357 ért˝o 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! 6.2.3.2.1. YANO hack

Labormunka egy saját ágon a hivatalos YANonymous repóban. 6.2.3.2.2. További pontgyujt ˝ o˝ 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˝o kéziratba, ennek szervezése a jelen évkönyv keretein kívül történik.

6.2.4. Haladó laborok 6.2.4.1. A hatodik labor

A kötelez˝o olvasmány erre a laborra a [JAVAKONYV] tankönyv 472-509 ért˝o olvasással és legalább egy-egy tartalmazott példa kidolgozásával, az 591-656 egyszeri elolvasással. 6.2.4.1.1. 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 30000 csomópontot tartalmaz, de vannak nagyobb városok is :) • lehet 1000000 autó is akár • mi legyen egy járm˝u 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.


63 / 404


Eredetileg ezek a feladatok az 5. el˝oadáson katalogizáltaknak voltak meghirdetve, de a nagy érdekl˝odés miatt mindenki el˝ott megnyitjuk, viszont az el˝oadá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˝o rövid jellemzése 6.2.4.2. A hetedik labor

A kötelez˝o olvasmány erre a laborra a [JAVAKONYV] tankönyv 90-111 és a 286-302 ért˝o olvasással és legalább három-három!!! tartalmazott példa kidolgozásával! 6.2.4.2.1. 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˝o 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:

Ezt kell kapnod: #Stops = 125 #Kms = 1193.94


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 és megjegyzések Megoldás a ../source/robotauto/elotanulmanyok/OpenStreetMap/GergoB/buszjarat_megallo mappában. itt Megoldotta: Balkus Gergo˝

Megoldás és megjegyzések Megoldás a ../source/robotauto/elotanulmanyok/OpenStreetMap/FGabor/java_buszmeg_trolley_tram_mvn mappában. Megoldotta: Fenesi Gábor


64 / 404

Megoldás és megjegyzések 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 és megjegyzések Megoldás a ../source/binom/D.Diana-Sz.Annamaria/malvin mappában. itt Megoldotta: Szentpéteri Annamária

6.2.4.3. A nyolcadik labor

A kötelez˝o olvasmány erre a laborra a [JAVAKONYV] tankönyv II/86-98, II/171-210 ért˝o olvasással és legalább egy-egy tartalmazott példa kidolgozásával, az II/1-13 egyszeri elolvasással. 6.2.4.3.1. 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 V2 /E értéket, hogy lássuk ritka vagy s˝ur˝u mátrixal lenne-e dolgunk? Ezt kell kapnod: E= 84024 V= 69431 V^2/E= 57372.5


Itt nem alkalmazzuk a hegylakó-szabályt. • 20 pont: a Malvin megoldásokban tipikusan szerepl˝o 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˝ot és hasonlítsd össze ezeket!


• 40 pont: az iménti, de most helyettesítsd osmium::index::map::VectorBasedSparseMap-el!

Megoldás és megjegyzések Megoldás itt Megoldotta: Sipos Ferenc

• 30 pont: írj egy Linkedin posztot, amelyben megmagyarázod a http://osmcode.org/libosmium/reference/map_2vector_8hpp_source.htm forrás következ˝o csipetét


65 / 404

template class TVector> 136 class VectorBasedSparseMap : public Map<TId, TValue> { 137 138 public: 139 140 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!

Megoldás és megjegyzések 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˝o algoritmust! • 400 pont: A https://code.google.com/p/robocar-emulator/source/browse/doc/robocaremu-SRS-hu.xml doksi angol fordítása (hegylakó, 3 f˝os csapatban is készíthet˝o).

Megoldás és megjegyzések ˝ Fenesi Gábor Megoldotta: Akai Zsolt, Balkus Gergo,

• 300 pont: az el˝oz˝o angoltól különböz˝o, tetsz˝oleges fordítása (hegylakó, 3 f˝os csapatban is készíthet˝o).

Megoldás és megjegyzések Megoldotta: Józan Csaba (ukrán nyelvre)

6.2.4.4. A kilencedik labor

A kötelez˝o olvasmány erre a laborra a [JAVAKONYV] tankönyvII/420-446 ért˝o 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˝ol a 932-974 egyszeri ért˝o olvasással! 6.2.4.4.1. Labormérés

Az el˝oz˝o 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˝o három labor-megoldó 60 pont) Els˝o 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˝urést: 10: 22.0619 km 10A: 19.5012 km 10Y: 23.4514 km 11: 49.9146 km 11A: 4.45457 km 12: 31.376 km


13: 18.0957 km 15: 46.0677 km 15Y: 41.0682 km 16: 12.4683 km 17: 20.9759 km 17A: 8.18353 km 18: 10.3255 km 18Y: 11.1428 km 19: 22.886 km 21: 16.8002 km 22: 16.172 km 22Y: 16.4279 km 23: 25.7068 km 23Y: 14.4689 km 24: 16.2726 km 24Y: 16.5288 km 25: 19.4192 km 25Y: 19.4572 km 30: 36.3083 km 30A: 17.3726 km 30I: 25.9134 km 30N: 13.4453 km 33: 32.3218 km 33E: 29.827 km 33Y: 34.5761 km 34: 28.7373 km 34A: 24.4315 km 35: 24.0866 km 351: 19.7185 km 35A: 19.7623 km 35E: 12.2161 km 35Y: 23.9761 km 36: 25.2795 km 36A: 21.0219 km 36E: 12.577 km 36Y: 15.8832 km 37: 31.4751 km 39: 18.14 km 41: 16.7574 km 41Y: 16.1534 km 42: 23.8458 km 42Y: 26.8753 km 43: 20.1533 km 44: 7.60031 km 45: 16.4438 km 45H: 37.9098 km 46: 13.4782 km 46E: 12.3227 km 46Y: 17.4891 km 47: 8.40773 km 47Y: 12.5548 km 48: 11.681 km 51E: 8.24326 km A1: 34.0167 km AU1: 16.4326 km AU2: 9.44448 km GGY: 20.7056 km Not specified: 13.6644 km 1314.48

66 / 404


67 / 404


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 és megjegyzések Megoldás a ../source/robotauto/elotanulmanyok/OpenStreetMap/FGabor/graph/ mappában Megoldotta: Fenesi Gábor Tutor: Balkus Gergo˝

6.2.4.5. A tizedik labor

A kötelez˝o olvasmány erre a laborra a [STROUSTRUP] tankönyv második kötetéb˝ol a 563-669 egyszeri ért˝o 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˝ol a könyvb˝ol a 758-762 ért˝o olvasással. 6.2.4.5.1. Labormérés

Az el˝oz˝o laborok buszmegálló útvonalait ábrázoljuk. Els˝o lépésben az els˝o három labor-megoldó 40 pont: jxmapviewer2 alapú megjelenít˝o (Maven projekt) összeállítása a jxmapviewer2 projekt valamelyik bevezet˝o példája alapján, a program a Debrecen térképet mutassa. 6.2.4.5.2. További labormérés feladatok

Itt természetesen alkalmazzuk a hegylakó-szabályt, illetve az els˝o 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 és megjegyzések Megoldás a ../source/robotauto/elotanulmanyok/OpenStreetMap/GergoB/Labor-10/22_megallok/ mappában Megoldotta: Balkus Gergo˝ Tutor: Fenesi Gábor

• Mint az el˝oz˝o, de a 22-es busz útvonalát mutassa (70 pont, az útvonal kinyer˝o is saját legyen, aminek kimenetét kapja meg a szóban forgó megjelenít˝o).

Megoldás és megjegyzések Megoldás a ../source/robotauto/elotanulmanyok/OpenStreetMap/GergoB/Labor-10/sima_utvonal/ mappában Megoldotta: Balkus Gergo˝ Tutor: Fenesi Gábor

• Mint az el˝oz˝o, de az útvonal csomópontjait egy saját ikonnal jelzi (90 pont).

Megoldás és megjegyzések Megoldás a ../source/robotauto/elotanulmanyok/OpenStreetMap/GergoB/Labor-10/custom_marker/ mappában Megoldotta: Balkus Gergo˝ Tutor: Fenesi Gábor


68 / 404

6.3. ábra. A feladat egy megoldása a Justine protóval, annak Justine Window tagjával.


Itt nem alkalmazzuk a hegylakó-szabályt (pontosabban csak az évkönyvbe való bekerülés kapcsán alkalmazzuk). • 250 pont: az el˝oz˝o 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 és megjegyzések Megoldás a ../source/robotauto/elotanulmanyok/OpenStreetMap/GergoB/routing_with_BGL/ mappában Megoldotta: Balkus Gergo˝

• Próbálj ki több algoritmust az el˝oz˝o feladatra, röviden vesd össze az eredményeket, minden az el˝oz˝o feladatban választott algoritmuson túli optimalizációs algoritmus kipróbálásáért további 70 pontot könyvelhetsz el!


69 / 404

Megoldás és megjegyzések

6.4. ábra. Az A* algoritmus és a Dijkstra algoritmus eredménye ugyanarra az inputra Budapest és Debrecen között. Megoldotta: Balkus Gergo˝

6.2.4.6. A tizenegyedik labor

A kötelez˝o olvasmány erre a laborra a [JAVAKONYV] tankönyvII/240-305 ért˝o olvasással és legalább két példa tesztelésével, illetve a 305-383 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! 6.2.4.6.1. Labormérés

Mennyi a justine-car-window-0.0.1 projekt legnagyobb ciklomatikus komplexitású függvénye és mennyi pontosan a szóban forgó érték? (az els˝o 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-0.0.1 úgy tudja átvenni a cs˝ovezetékb˝ol, hogy azt sikeresen meg is tudja jeleníteni... fix it! (az els˝o három 30 pont) 6.2.4.6.2. További pontgyujt ˝ o˝ 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˝orök elkapják a gengsztereket: ne routing-ot használjanak, hanem egyszer˝uen a térkép gráfon arra az élre lépjenek, amely közelebb visz egy gengszterhez! (nem hegylakó, 80 pont) 6.2.4.7. A tizenkettedik és az utolsó labor 6.2.4.7.1. Labormérés

• Fejleszd tovább a rend˝or ágenst, hogy ne szimpla távolság alapján válassza ki a legközelebbi gengsztert, hanem a hozzájuk vezet˝o utak alapján számoljon! (200 pont az els˝o 3 hallgatónak) • Kvalifikáld magad a Robotautó Világbajnokság - Debrecen viadalra! Ez 100-ból 1 rend˝orrel 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˝ott. • A kvalifikált hallgatók a laborokon játszhatnak egymással párban ugyanarra a forgalmi szerverre csatlakozva, a gy˝oztes 100 pont, a vesztes 50 (egy pár egyet játszhat, ez ugyanaz mint tavaly az edz˝omeccsek).


70 / 404


• Jelentkezz a Robotautó Világbajnokság - Debrecen viadalra! (max. három f˝os csapatok, egy f˝o egy csapatban lehet). (200 pont) • Jelentkezz a Robotautó Világbajnokság - Debrecen viadalra! (max. három f˝os csapatok, de a mi kurzusunk hallgatója csak tutor ebben a csapatban, a csapat többi tagja más hazai egyetemr˝ol kell kikerüljön). (400 pont) • Jelentkezz a Robotautó Világbajnokság - Debrecen viadalra! (max. három f˝os csapatok, de a mi kurzusunk hallgatója csak tutor ebben a csapatban, a csapat többi tagja külföldi egyetemr˝ol 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)


71 / 404

7. fejezet

Robotfocis programok A következ˝o feladatok a robotfocival kapcsolatosak, ha nem vagy ismer˝os a témában, de el˝ore akarsz készülni, akkor indulj el err˝ol a linkr˝ol: http://www.inf.unideb.hu/~nbatfai/konyvek/MIRC/mirc.book.xml.html#robocup. 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˝o 8 számolható el, tutorrendszer támogatott a megoldásnál és a tutor-tutoriált lehet azonos önbesorolású!

7.1.1. Legyen kapus a kapus Ez a feladat megyegyezik 8. labor hasonló nev˝u feladatával (4 pont).

7.1.2. 2D 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: http://www.inf.unideb.hu/~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˝oz˝o help mellett olvasd el a https://downloads.sourceforge.net/project/sserver/rcssmanual/9-20030211/manual-20030211.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: http://www.inf.unideb.hu/~nbatfai/konyvek/PROP/prop.book.xml.html#bolyongofcpp

7.1.3. 2D RCSS multiágensek Készíts olyan 2D RCSS ágensekb˝ol á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˝ol é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˝ol és egy rövid kis videón mutasd be ennek részletét a YouTube-on (12 pont)


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˝ol é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˝ol és egy rövid kis videón mutasd be ennek részletét a YouTube-on (12 pont) Segít: http://www.inf.unideb.hu/~nbatfai/konyvek/PROP/prop.book.xml.html#konnyebb.

7.2. 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˝ozés-beosztását. Fontos, hogy id˝opontokhoz - 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: http://progpater.blog.hu/2013/02/26/a_nyolcadik_labor_anyaga.

Megoldás és megjegyzések 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 muködésér ˝ ol.

7.3. Robotfoci logó Készítsd el robotfoci csapatod logóját! Indulj ki például megfelel˝o foresztes csapatból, de a logó legyen rendben szerz˝oi jogi szempontból (nincs a tutor-tutoriált relációra önbesorolási korlátozás és nincs hegylakó szabály, az els˝o 20 hallgató könyvelheti el, 20 pont)

7.3.1. Szavazás feladat A https://www.facebook.com/frak2mandelbrot 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˝oi jogi szempontból rendben kelle lennie! Az oldal elkészült, lehet nevezni: https://www.facebook.com/pages/Robotfoci-logó-szavazás/774480775903269 (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)

7.3.2. 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˝o forráskód, amelyet be lehet illeszteni az online-coach ágens kódjába! (30 pont)

Megoldás és megjegyzések 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.


73 / 404

8. fejezet

Szuperszámítógépes programok Ezek a feladatok nem választhatóak, hanem meghívással m˝uködnek, amely minden adott feladat esetén egyedi.

˝ kilencszer mi nyertünk volna” 8.1. „Tízbol Hangzik el sokszor a mérk˝ozések után ez a tipikus mondat az edz˝oi nyilatkozatokban. Hálás mondat, mert ellen˝orizhetetlen: az emberekb˝ol álló játékosokkal a mérk˝ozé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˝ol 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˝oen ebben a feladatban az vehet részt, aki a bajnokságba sikerrel nevez és részt vesz. Az egyszer˝usí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/5.1.1 --with-mpfr=/opt/nce/packages/global/mpfr/3.1.1 --with-mpc =/opt/nce/packages/global/mpc/1.0.1 Thread model: posix gcc version 4.7.2 (GCC) norbi@DEBRECEN[service0] ~ (0)$

-

A Debreceni szuperszámítógépet a [PARP] könyvünk http://www.inf.unideb.hu/~nbatfai/konyvek/PARP/parp.book.xml.html#gepek részéb˝ol ismerheted meg, ahonnan idézve: az el˝oté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 X5650 stepping : 2 microcode : 19 cpu MHz : 1600.000 cache size : 12288 KB

@ 2.67GHz


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 : 5333.32 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˝otét szerverr˝ol 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


9. fejezet

A „só” programok A következ˝o feladatok a félév „sóját” alkotják, bárki exponálhat bennük, aki tud.

9.1. Genesis Patch https://github.com/nbatfai/gp

75 / 404


76 / 404

10. fejezet

Egyéb feladatok A következ˝o 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˝odés.

10.1. Operációs rendszerekkel kapcsolatos alapveto˝ feladatok 10.1.1. A GNU/Linux kernellel kapcsolatos feladatok 10.1.1.1. Kernelfordítás

Fordíts kernelt a Linux rendszereden! (10 pont.) http://www.inf.unideb.hu/~nbatfai/konyvek/PROP/prop.book.xml.html#id485178 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˝oálló új, custom kerneledbe!

Megoldás és megjegyzés A feladatot elkészítette: Gyügyei Tamás ˝ ˝ közül megoldotta: Szálku Tibor, Orbán István Sándor, Tuza József, Fekete Sándor, Nad Az eloadáson résztvevok Sabolch, Nagykéri Bence, Badó Gergely József, Szabó Bence, Konyári László, Abai Richárd, Kovács-Ferenc Norbert

10.1.2. Telepítéssel és virtualizációval kapcsolatos feladatok 10.1.2.1. 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.


77 / 404

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

10.1.2.3. 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 eroforrás igényes a többi virtualizált ˝ operációs rendszerhez képest. Jelentosebb új feature-ök: UEFI boot támogatás, fejlettebb csomagkezelo˝ rendszer, ˝ hálózat virtualizáció, régebbi processzorarchitektúrák támogatásának megszüntetése. felhasználóbarátabb telepíto,

10.1.2.4. 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 10.0. A telepítésnél nem volt probléma. Néhány jelentosebb új feature: szélesebb videókártya támogatás, új, fejlettebb csomagkezelo˝ rendszer használata.

10.2. Az információs-távolsággal kapcsolatos feladatok Az alábbi feladatok kizárják egymást.

10.2.1. Genomok összehasonlítása A második el˝oadá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˝olények filogenetikai fáját! (10 pont) Lásd még a http://progpater.blog.hu/2011/03/06/szigoruan_titkos_1 posztot is!


78 / 404

Megoldás és megjegyzés A feladat megoldását Deregi Diána készítette el.

10.2.2. SZT tisztek gráfja A második el˝oadá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 http://progpater.blog.hu/2011/03/06/szigoruan_titkos_1 posztot is!

10.3. 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˝oforrások licencér˝ol is nyilatkoznod kell, ez legyen legalább olyan szabad, hogy ebben a könyvben is tudjuk szerepeltetni!

10.3.1. 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˝oi joga kapcsán is nyilatkoznia kell a készít˝onek. 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ó

10.3.1.1. Szavazás feladat: az UDProg évkönyv logójának szavazása

10 pont üti a markát, aki el˝oszö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˝u költség nélkül megtehet˝o). 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˝o, aki el˝oször megírja a Facebook szavazások cím˝u beszélgetésre kommentként az URL-t. A szavazás eredményének megfelel˝oen az aspiránsok a kevesebb lájk felé haladva 10-t˝ol kapnak további pontot, helyezésenként egyesével csökkentve. A feladatot megoldotta: Szálku Tibor, a szavazási oldal megsz˝unt 2 hónappal a szavazás után.

10.4. Egyéb segíto˝ feladatok 10.4.1. 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).


79 / 404

Megoldás és megjegyzés A demót készítette: Dalmadi Zoltán.

10.4.1.1. Mozgató konstruktor demó

Egészítsd ki az el˝oz˝o feladat megoldását, hogy demózza a másoló értékadást, mozgató ctor-t és értékadást is (az el˝oz˝o feladat után készíthet˝o és kizáró feladat, 10 pont)!

10.5. Promóciós feladatok Ezek a feladatok a nem ebb˝ol 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.

10.5.1. 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). 10.5.1.1. Szavazás feladat: promóciós robotfoci-videó

Szervezd meg a Facebook-on az el˝oz˝o feladat videóinak szavazását (ha techikailag csak úgy oldható meg, akkor nevez˝ok 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.

Megoldás és megjegyzések Elkészítettem a szavazáshoz szükséges Facebook paget, Bereczki László.

10.5.2. 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˝oadó, ki a laborvezet˝o, ha valakinek felhasználod er˝oforrásait, akkor ki a valaki (mert a kurzus példái tipikusan GPL-esek, tehát használhatod mondjuk az ilyen licenc˝u é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˝ot (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). 10.5.2.1. Szavazás feladat: promóciós kurzus-videó

Szervezd meg a Facebook-on az el˝oz˝o feladat videóinak szavazását (ha techikailag csak úgy oldható meg, akkor nevez˝ok 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.


80 / 404

Megoldás és megjegyzések Elkészítettem a szavazáshoz szükséges Facebook paget, Bereczki László.

10.5.3. 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˝oadó, ki a laborvezet˝o, ha valakinek felhasználod er˝oforrásait, akkor ki a valaki (mert a kurzus példái tipikusan GPL-esek, tehát használhatod mondjuk az ilyen licenc˝u évfolyamtársaid kódjait, mondjuk biomorfok rajzolására, hogy ilyenekkel is feldobd a videót). (30 pont). 10.5.3.1. Szavazás feladat: promóciós kurzus-prezi

Szervezd meg a Facebook-on az el˝oz˝o feladat prezijeinek szavazását (ha techikailag csak úgy oldható meg, akkor nevez˝ok egy képet küldjenek a prezib˝ol é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érheto˝ ezen a Facebook oldalon. (Deregi Diána)

10.6. Dokumentálással kapcsolatos feladatok 10.6.1. 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˝onek max. 15 pont számolható el)

10.6.2. Doxygen A kurzusbeli OO programokat kommentezd be, hogy a Doxygen-el el lehessen készíteni a jó min˝oség˝u dokumentációt. (7 pont programonként, hegylakó szabály él, egy f˝onek 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.

10.7. 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˝ol).


81 / 404

11. fejezet

Tankönyvi feladatok Ezek kezd˝o szinten (vagy kezd˝o szinten és tutor rendszerben) elszámolható feladatok.

11.1. A [STROUSTRUP] könyv feladatai A megoldások részben nem kell a feladatot leírni, csak a (fejezetszám stb. tagokkal) min˝osí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˝osített nevével egyezik meg. Fontos, hogy a feladatok számát (és magukat a feladatokat) ne a könyvb˝ol nézzétek, hanem az egységes hivatkozás miatt innen: http://www.stroustrup.com/4thExercises.pdf!

11.1.1. X.2[1] feladat Mit jelent a (*2.5) egy feladat szövege el˝ott?

Megoldás és megjegyzések A feladat megoldását Kistamás Dávid készítette.

11.1.2. X.2[4] feladat Mik a f˝obb programozási stílusok C++ban?


11.1.3. X.2[7] feladat Sorold fel, hogy miket tartalmaz a C++ Standard Library-ja.



11.1.4. X.2[9] feladat Sorolj fel három (vagy több) el˝onyt attól, hogy egy könyvtár része a standard könyvtárnak.

Megoldás és megjegyzések A feladat megoldását Gyügyei Tamás készítette.

11.1.5. X.2[10] feladat Sorolj fel 20 fontosabb dolgot amib˝ol a C++ kifejl˝odött.


11.1.6. X.3[2] feladat Mit csinál a fordító? És mit a linker?


11.1.7. X.3[3] feladat Egyszer˝u Hello world program fordítása és futtatása.


82 / 404


11.1.8. X.3[4] feladat Sorolj fel 3 C++ fordítót.


11.1.9. X.3[5] feladat Írj ki egy bool-t, egy char-t, egy int-et, egy double-t és egy stringet cout-tal.


11.1.10. X.3[6] feladat Olvass be egy bool-t, egy char-t, egy int-et, egy double-t és egy stringet cin-nel.


11.1.11. X.3[7] feladat Mi az az invariáns, mire is jó tulajdonképpen?


11.1.12. X.5[2] feladat Sorolj fel 5 Standard Library tárolót!


83 / 404


84 / 404

11.1.13. X.5[3] feladat Sorolj fel 5 Standard Library algoritmust!


11.1.14. X.5[4] feladat Sorolj fel 5 Standard Library algoritmust!


11.1.15. X.5[5] feladat Olvass be egy stringet (name), egy int-et (age), majd írd ki ezeket cout-tal egy sorba.


11.1.16. 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 o˝ ket, majd írasd ki a saját beolvasó és kiíró függvényeiddel.


11.1.17. 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!



85 / 404

11.1.18. X.5[8] feladat Írd át az el˝oz˝o feladatot string típusú vektorra, amelynek kezd˝oértékei "Kanto", "Plato", "Aristotle", "Kierkegard", és "Hume" és végezd el ugyanazt rajta.


11.1.19. X.5[9] feladat Nyiss meg egy fájlt írási joggal, majd írass bele pár száz egész számot.


11.1.20. X.5[10] feladat Az el˝oz˝oleg elkészített fájlt nyisd meg olvasási módban és olvasd be a tartalmát.


11.1.21. X.6[2] feladat Hello és World szavak váltakozása másodpercenként.

Megoldás és megjegyzések A feladat megoldását Akai József Zsolt készítette.

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



86 / 404

11.1.23. X.7[2] feladat Írjunk programot, amely a signed szót írja ki ha a sima karakterek (char) el˝ojelesek az implementációdban, egyébként ha el˝ojel nélküliek, akkor az unsigned szót írja ki.


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


11.1.25. X.7[7] feladat Írjunk programot, amely kiírja az ’a’-’z’ bet˝uket é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.


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


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



87 / 404

11.1.28. 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?


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

Megoldás és megjegyzések A feladat megoldását Forgács Péter készítette Haraszti Péter tutoriálásával.

11.1.30. X.8[1] feladat Vezessük be a következ˝oket: karakterre hivatkozó mutató, 10 egészb˝ol álló tömb, 10 egészb˝ol á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.


11.1.31. X.8[3] feladat Használjunk typedef-et a következ˝ok 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˝u, egészre hivatkozó mutatókból álló tömb; 7 elem˝u, egészre hivatkozó mutatókból álló tömbre hivatkozó mutató; egészre hivatkozó mutatókat tartalmazó 7 elem˝u tömbökb˝ol álló 8 elem˝u tömb.


11.1.32. 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!


88 / 404


11.1.33. 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!


11.1.34. X.8[7] feladat Két változó cseréje

Megoldás és megjegyzések A feladat megoldását Akai József Zsolt készítette.

11.1.35. X.8[8] feladat Mi az str tömb mérete a következ˝o példában? char str[ ] = "rövid karakterlánc"; Mi a "rövid karakterlánc" hossza?


11.1.36. 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˝oket: ’a’, 49, 3300, c, uc, sc, ahol c karakter, uc el˝ojel nélküli karakter, sc el˝ojeles karakter. Mely függvény hívások legálisak? Melyek okozzák hogy a fordító átmeneti változót hozzon létre?



89 / 404

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


11.1.38. 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˝ott kiírja a szavakat, rendezze azokat.


11.1.39. X.8[12] feladat Adott karakterek megszámolása a "xabaacbaxabb" szövegben.


11.1.40. X.9[1] feladat Definiáljunk egy struktúrát bool, char, int, long, double és long double típusokkal, mindegyikb˝ol eggyel. Rendezzük sorba a tagokat úgy, hogy a lehet˝o legnagyobb illetve legkisebb méret˝u struktúrát kapjuk.


11.1.41. X.9[2] feladat Napok kiíratása havonta



90 / 404

11.1.42. 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˝o1l, olyat, ami Date-eket ír a kimenetre, és olyat, ami egy dátummal ad kezd˝oértéket a Date-nek. Program eleje szokott módon kezd˝odik, iostream, namespace, struct megadása.


11.1.43. X.10[1] feladat Írjuk át a megadott for ciklust vele egyenérték˝u while ciklusra, olyanra, hogy pointert használjon a bejárásra, valamint vele egyenérték˝u range-for ciklusra.


11.1.44. X.11[1] feladat Zárójelezzük teljesen a következ˝o kifejezéseket


11.1.45. 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˝opontos érték. Írjuk ki az összes névre vonatkozó összeget és számtani közepet.


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



91 / 404

11.1.47. X.11[6] feladat Zárójelezzük teljesen a következ˝o kifejezéseket


11.1.48. 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˝o karaktere lesz az utolsó és így tovább.


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

Megoldás és megjegyzések A feladat megoldását Monori Fanny készítette.

11.1.50. X.13[2] feladat Mit jelent a következõ sor? Mire lehet jó? typedef int (& rifii) (int, int);

Megoldás és megjegyzések A feladat megoldását Monori Fanny készítette.

11.1.51. X.13[3] feladat Írjunk egy Helló, világ!-szer˝u 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˝oleges számú név paramétere lehessen és mondjon hellót minden egyes névvel.



92 / 404

11.1.52. X.13[4] feladat Írjunk olyan programot, amely tetsz˝oleges 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˝uzi a paramétereit, hogy megkapja a kimenetet, elnevezhetjük cat-nek.


11.1.53. X.13[9] feladat Írj egy függvényt ami invertál egy kétdimenziós tömböt (mátrixot).

Megoldás és megjegyzések 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.

11.1.54. X.13[14] feladat Nézz meg néhány programot. Ezekb˝ol sz˝urd le, hogy hogyan használjuk a nagybet˝uket és az alulvonást a nevekben, valamint mikor használunk rövid neveket, mint például i vagy x?


11.1.55. X.13[15] feladat Mi a baj az adott makrókkal? (forrásfájlban részletesen)


11.1.56. X.13[20] feladat Írjunk olyan faktoriális függvényt, amely nem hívja meg önmagát.



93 / 404

11.1.57. X.13[21] feladat Írjunk függvényeket, melyek az X.9[4]-ben lév˝o 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˝o dátumát adja vissza.


11.1.58. X.17[4] feladat Definiáljunk egy Hisztogram nev˝u 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.


11.1.59. X.17[7] feladat Hozzunk létre egy osztályt, ami int-ek csoportján tud kezelni metszetet, uniót és szimmetrikus differenciát.


11.1.60. X.17[8] feladat Módosítsuk az X.17.7-et úgy, hogy láncolt listát használjunk.


11.1.61. X.17[13] feladat Modifikáljuk a hello world programot, hogy el˝otte és utána írja ki, hogy Initialize illetve Clean up, anélkül, hogy a main függvényt módosítanánk.



94 / 404

11.1.62. X.19[4] feladat Definiáljunk egy osztályt ami kivitelez tetsz˝oleges pontosságú aritmetikát. Teszteljük 1000! kiszámításával.


11.1.63. X.21[1] feladat Definiáljuk az alábbi osztályt: class Derivedone: public Base { public: void iam() { cout << "Derivedone\n"; } }; Származtassunk bel˝ole két osztályt és módosítsuk az iam függvényt, hogy a megfelel˝o 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.


11.1.64. X.32[1] feladat Hozzunk létre karakter típusú vektort, amely az ABC bet˝uit tartalmazza sorrendben. Írjuk ki ezt a vektort, majd írjuk ki a fordítottját is.


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


11.1.66. X.32[3] feladat Az X.32[2] feladat vektorát felhasználva írassuk ki úgy a vektort, hogy minden szó els˝o bet˝ujét helyettesítjük az "a" karakterrel.



95 / 404

11.1.67. 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˝uvel kezd˝odik.


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


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


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


11.2. A [KR] könyv feladatai Ugyanúgy járjunk el, mint az el˝oz˝o tankönyv esetén, itt egységesen 3 pont számolható el példánként.


96 / 404

11.2.1. 1.1.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!

Megoldás és megjegyzések A feladat megoldását Gyügyei Tamás készítette. ˝ A megoldást ellenoriztem splint-el, nem talált hibát. (Abai Richárd) ˝ A feladatot valgrind-el ellenoriztem, 0 hibát .(Józan Csaba)

11.2.2. 1.2.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˝o escape jelsorozat)!

Megoldás és megjegyzések A feladat megoldását Gyügyei Tamás készítette. ˝ A megoldást ellenoriztem splint-el, nem talált hibát. (Abai Richárd)

11.2.3. 1.3.gyakorlat Módosítsuk a h˝omérséklet-átalakító programot úgy, hogy a táblázat fölé fejlécet is nyomtasson!

Megoldás és megjegyzések A feladat megoldását Gyügyei Tamás készítette. ˝ A megoldást ellenoriztem splint-el, a kimentet a forrás melett egy fájlba helyeztem. (Veress Balázs) ˝ A feladatot valgrind-el ellenoriztem, 0 hibát .(Józan Csaba)

11.2.4. 1.4.gyakorlat Írjunk programot, amely a Celsius-fokban adott értékeket alakítja Fahrenheit-fokká!

Megoldás és megjegyzések A feladat megoldását Ozsváth Jonathán készítette. Ezen link sorszámozása alapján készítettem: http://lidi.

uw.hu/krc/index.html ˝ A feladatot valgrind-el ellenoriztem, 0 hibát .(Józan Csaba)

11.2.5. 1.5. gyakorlat. Módosítsuk a h˝omérséklet-átalakító programot úgy, hogy a táblázatot fordított sorrendben, tehát 300 foktól 0 fokig nyomtassa ki!


97 / 404

Megoldás és megjegyzések 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 ellenoriztem, 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 ellenoriztem, 0 hibát .(Józan Csaba)

11.2.6. 1.6.gyakorlat Igazoljuk, hogy a getchar( ) != EOF kifejezés értéke valóban 0 vagy 1!

Megoldás és megjegyzések A feladat megoldását Gyügyei Tamás készítette. ˝ A feladatot splint-el ellenoriztem, 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 ellenoriztem, 0 hibát .(Józan Csaba)

11.2.7. 1.7.gyakorlat Írjunk programot, ami kiírja az EOF értékét!

Megoldás és megjegyzések A feladat megoldását Ozsváth Jonathán készítette. ˝ A feladatot splint-el ellenoriztem, 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 ellenoriztem, 0 hibát .(Józan Csaba)

11.2.8. 1.8.gyakorlat Írjunk programot, ami megszámolja a bemenetre adott szövegben lév˝o szóközöket, tabulátorokat és újsor-karaktereket!

Megoldás és megjegyzések A feladat megoldását Ozsváth Jonathán készítette. ˝ A feladatot splint-el ellenoriztem, 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 ellenoriztem, 0 hibát .(Józan Csaba)

11.2.9. 1.9.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˝ol álló karaktersorozatokat egyetlen szóközzel helyettesíti!

Megoldás és megjegyzések A feladat megoldását Ozsváth Jonathán készítette. ˝ A feladatot splint-el ellenoriztem 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 ellenoriztem, 0 hibát .(Józan Csaba)


98 / 404

11.2.10. 1.10.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.


11.2.11. 1.12.gyakorlat Írjunk programot, ami a bemenetére adott szöveg minden szavát új sorba írja ki!


11.2.12. 1.12.1 gyakorlat Írjunk olyan programot, amely kinyomtatja a bemenetén el˝oforduló szavak hosszúságának hisztogramját! (Függ˝oleges verzió)

Megoldás és megjegyzések A feladat megoldását Abai Richárd készítette. Forrás: ../source/tankonyvi/KR/1.12.h.c ˝ A feladatot splint-el ellenoriztem 0 hibát talált.(Józan Csaba) ˝ A feladatot valgrind-el ellenoriztem, 0 hibát .(Józan Csaba)

11.2.13. 1.13.gyakorlat Írjunk olyan programot, amely a beolvasott szöveget kisbet˝ussé alakítja át egy olyan lower© függvény segítségével, amely c-vel tér vissza, ha c nem bet˝u, és c kisbet˝us megfelel˝ojét adja vissza, ha c bet˝u!

Megoldás és megjegyzések A feladat megoldását Preznyák László készítette. ˝ A feladatot splint-el ellenoriztem 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 ellenoriztem, 0 hibát .(Józan Csaba)

11.2.14. 1.14.gyakorlat Írjunk programot, ami kinyomtatja a bemenetre adott különböz˝o karakterek el˝ofordulási gyakoriságának hisztogramját!


99 / 404


11.2.15. 1.15.gyakorlat Írjunk olyan programot amely minden olyan sort megjelenít, amely 80 karakternél hosszabb!

Megoldás és megjegyzések A feladat megoldását Veress Balázs készítette. ˝ A feladatot splint-el ellenoriztem 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 ellenoriztem, 0 hibát .(Józan Csaba)

11.2.16. 1.16.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! Megoldás és megjegyzések A feladat megoldását Veress Balázs készítette. ˝ A feladatot splint-el ellenoriztem 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 ellenoriztem, 0 hibát .(Józan Csaba)

11.2.17. 1.17.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!


11.2.18. 1.20.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˝o 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˝u megadni?

Megoldás és megjegyzések 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 ellenoriztem 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 ellenoriztem, 0 hibát .(Józan Csaba)


100 / 404

11.2.19. 2.1.gyakorlat Írjunk programot, ami meghatározza a signed és unsigned min˝osít˝oj˝u char, short, int és long típusú változók nagyságát a szabványos header állományokból vett megfelel˝o é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˝o, ha a lebeg˝opontos számok nagyságát is meg akarjuk határozni.

Megoldás és megjegyzések A feladat megoldását Gyügyei Tamás készítette. ˝ A feladatot splint-el ellenoriztem 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 ellenoriztem, 0 hibát .(Józan Csaba)

11.2.20. 2.4.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ó!


11.2.21. 2.5.gyakorlat Írjunk any(s1, s2) néven függvényt, amely visszatérési értékként megadja az s1 karaktersorozat azon legels˝o helyét, ahol az s2 karaktersorozat bármelyik karaktere el˝ofordul! 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˝o mutatót adja.)


11.2.22. 2.6.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˝o n bitje helyébe bemásolja y jobb széls˝o n bitjét, a többi bitet változatlanul hagyva!



101 / 404

11.2.23. 2.7.gyakorlat Írjunk olyan rightsh(n, b) függvényt, amely b számú bitpozícióval jobbra történ˝o biteltolást végez az n egész típusú mennyiségen!

Megoldás és megjegyzések A feladat megoldását Veress Balázs készítette. ˝ A feladatot splint-el ellenoriztem 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)

11.2.24. 2.8.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˝o bitek a bal szélen visszakerülnek a szóba. Megoldás és megjegyzések 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 ellenoriztem 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 muve˝ lettel muköd ˝ o˝ megoldással kiegészítettem. ˝ A feladatot valgrind-el ellenoriztem, 0 hibát .(Józan Csaba)

11.2.25. 2.9.gyakorlat A kettes komplemens kódú aritmetikában az x = (x-1) kifejezés törli x jobb széls˝o bitjét. Magyarázzuk meg, miért! Ezt kihasználva írjunk egy gyorsabb bitcount változatot!


11.2.26. 2.10.gyakorlat Írjuk át a nagybet˝uket kisbet˝ukké alakító lower függvényt úgy, hogy az if-else szerkezetet feltételes kifejezéssel helyettesítjük!


11.2.27. 3.3.gyakorlat Írjunk expand(s1, s2) néven függvényt, amely az s1 karaktersorozatban lév˝o rövidítéseket s2 karaktersorozatban feloldja (pl. az a-z helyett kiírja az abc...xyz teljes listát)! A program tegye lehet˝ové a bet˝uk é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˝u a kezd˝o vagy záró - jelet literálisként kezelni.


102 / 404


11.2.28. 3.4.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!


11.2.29. 3.5.gyakorlat Írjuk meg az itoa függvénynek azt a változatát, amely kett˝o helyett három argumentumot fogad el! A harmadik argumentum a minimális mez˝oszé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!

Megoldás és megjegyzések A feladat megoldását Veress Balázs készítette. ˝ A feladatot valgrind-el ellenoriztem, 0 hibát .(Józan Csaba)

11.2.30. 3.6.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˝u változata az UNIX uniq szolgáltatásának)


11.2.31. 4.4. gyakorlat Írjuk meg a ungets(s) nev˝u rutint, amely egy teljes karakterláncot ír vissza a bemenetre!

Megoldás és megjegyzések A feladat megoldását Abai Richárd készítette. Forrás: ../source/tankonyvi/KR/4.4.c ˝ A feladatot splint-el ellenoriztem 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 ellenoriztem, 0 hibát .(Józan Csaba)


103 / 404

11.2.32. 4.7. 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á!

Megoldás és megjegyzések A feladat megoldását Sipos Ferenc készítette. Forrás: ../source/tankonyvi/KR/4.7.c ˝ A feladatot valgrind-el ellenoriztem, 0 hibát .(Józan Csaba)

11.2.33. 4.8. gyakorlat Írjuk meg az s karakterláncot megfordító reverse(s) függvény rekurzív változatát! Megoldás és megjegyzések A feladat megoldását Sipos Ferenc készítette. Forrás: ../source/tankonyvi/KR/4.8.c ˝ A feladatot splint-el ellenoriztem 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 ellenoriztem, 0 hibát .(Józan Csaba)

11.2.34. 4.9. 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.) Megoldás és megjegyzések A feladat megoldását Sipos Ferenc készítette. Forrás: ../source/tankonyvi/KR/4.9.c ˝ A feladatot splint-el ellenoriztem 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 ellenoriztem, 0 hibát .(Józan Csaba)

11.2.35. 5.1. gyakorlat Írjuk meg a getfloat függvényt, amely a getint lebeg˝opontos megfelel˝oje! Milyen típust ad vissza getfloat függvényértékként? Megoldás és megjegyzések A feladat megoldását Sipos Ferenc készítette. Forrás: ../source/tankonyvi/KR/5.1.c ˝ A feladatot splint-el ellenoriztem 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 ellenoriztem, 0 hibát .(Józan Csaba)

11.2.36. 5.3.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. Megoldás és megjegyzések 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 ellenoriztem 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)


104 / 404

11.2.37. 5.4.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!


11.2.38. 5.5.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˝o n karakterével végeznek m˝uveletet, pl. az strncpy(s, t, n) a t karaktersorozat legfeljebb els˝o n karakterét másolja s-be.

Megoldás és megjegyzések 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 ellenoriztem 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)

11.2.39. 5.7. gyakorlat 5.7. Gyakorlat. Írjuk meg az add nev˝u programot, amely kiértékel egy, a parancssorban szerepl˝ofordított lengyel alakú kifejezést! Például add 2 3 4 + * 2 * (3+4)-et számítja ki.

Megoldás és megjegyzések A feladat megoldását Sipos Ferenc készítette. Forrás: ../source/tankonyvi/KR/5.7.c ˝ A feladatot splint-el ellenoriztem 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 ellenoriztem, 0 hibát .(Józan Csaba)

11.2.40. 7.1.gyakorlat Írjunk programot, amely a hívásakor az argv[0]-ban elhelyezett paramétert˝ol függ˝oen a nagybet˝uket kisbet˝uvé vagy a kisbet˝uket nagybet˝uvé alakítja!

Megoldás és megjegyzések 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 ellenoriztem, 0 hibát .(Józan Csaba)


105 / 404

11.2.41. 7.6.gyakorlat Írjunk programot, amely összehasonlít két állományt, és kiírja az els˝o olyan sort, ahol különböznek!


11.2.42. 8.1.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!

Megoldás és megjegyzések 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 ellenoriztem, 0 hibát .(Józan Csaba)

11.3. Az [SZFCPP] könyv feladatai Ugyanúgy járjunk el, mint az el˝oz˝o tankönyvek esetén, itt egységesen 10 pont számolható el példánként.

11.3.1. 3.5.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 o˝ ket. Mivel az el˝oször berakott alamet vehetjük ki els˝oként, ezt a struktúrát firt is sirst out (FIFO) Tárolónak nevezzük.

Megoldás és megjegyzések A megoldást Veress Balázs Készítette Gyügyei Tamás tutor segítségével.

11.3.2. 6.3.feladat Írjunk komplex számokat megvalósító osztályt! Tegyük lehet˝ové az alábbi m˝uveletcsoportokat! Statikus m˝uveletek, Imaginárius egység használata, M˝uveletek komplex számokkal, Valós és komplex m˝uveletek, I/O m˝uveletek. A könyv 69. oldala.

Megoldás és megjegyzések A megoldást Veress Ármin készítette Balog János Csaba tutor segítségével.


106 / 404

11.3.3. 6.6.feladat Írjunk egy egyszer˝u 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˝o parancsát!


11.3.4. 7.1.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˝ol a prototípustól mindössze annyit várunk el, hogy kiírja egy személy vagy egy alkalmazott adatait a szabványos kimenetre.


11.3.5. 7.2.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˝o definiáljunk egy Print függvényt, amely kiírja, hogy a téglalapról, vagy körr˝ol van szó.

Megoldás és megjegyzések A megoldást Kovács-Ferenc Norbert készítette Bereczki László tutor segítségével.

11.3.6. 7.4.feladat A tankönyv 142. oldalán a feladat bemutatja az interfészimplementáció alkalmazását.


11.3.7. 8.2.1. feladat Tervezzük meg és valósítsuk meg egy String osztály konverzióit!



107 / 404

11.3.8. 10.1.2.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.


11.3.9. 11.2.feladat Írjunk egy olyan ContainerProcessor nev˝u osztálysablont, melynek statikus tagfüggvényei különböz˝o m˝uveleteket végeznek a paraméterként megkapott tároló (container) osztályon.


11.3.10. 12.1.1 betu˝ számoló Számoljuk meg, hány ’h’ karakter található egy C stílusú sztringben!

Megoldás és megjegyzések A megoldást Nagy Dávid készítette Kistamás Dávid tutoriálásával.

11.3.11. 12.1.1 szám számoló Számoljuk meg, hányszor fordul el˝o a 42 egy egészeket tartalmazó tömbben!


11.3.12. 12.1.2 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!



108 / 404

11.3.13. 12.1.2 filozófusok másolása Másoljuk át egy vektor tartalmát listába, majd írassuk ki a lista tartalmát.


11.3.14. 12.2.feladat Tekintsünk adottnak egy vektorobjektumot, amely egész számokkal lett feltöltve! Keressük meg az els˝o olyan elemet, amely nagyobb vagy egyenl˝o, mint 3!

Megoldás és megjegyzések A megoldást Balogh János Csaba készítette Veress Ármin tutor segítségével.

11.3.15. 12.4.3 bitbeszúrás Írjunk olyan programot, amely egy bináris vektorban minden egymás után következ˝o öt egyes után beszúr egy nullát.


11.4. Az [EZUST] könyv feladatai Ugyanúgy járjunk el, mint az el˝oz˝o tankönyvek esetén, itt egységesen 7 pont számolható el példánként.

11.4.1. 1.7.2 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


../source/tankonyvi/EZUST/1.7.2.cpp


109 / 404

11.4.2. 1.8.1 gyakorlat Egy örök kedvenc: Írj egy rövid programot, ami bekéri a felhasználótól a h˝omérsékletátváltás irányát(Celsius-Fahrenheit/FahrenheitCelsius). Ezután kérj be egy alsó határt, egy fels˝o határt és egy lépésközt. Használd ezeket, hogy létrehozd a megfelel˝o 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.



11.4.3. 1.8.2 gyakorlat Ha includoljuk a 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˝uködik, hogy kiszámolj ap következ˝o számot a sorban az el˝oz˝o 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.



11.4.4. 1.8.3 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˝o 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.



11.4.5. 1.8.4 gyakorlat Írj egy programot, ami bekér két érteket a felhasználótól(vev˝ot˝ol): az egyik a fizetend˝o ö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˝o 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)




110 / 404

11.4.6. 1.12.2 gyakorlat Módosítsd a 1.19-es példát úgy, hogy csináljon valamilyen aritmetikai m˝uveletet 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˝o helyeken a programban. Figyeld meg, hogy hogy reagál a fordító és a futó rendszer a kimenetek elhelyezésére.



11.4.7. 2.13.4 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˝o üzemanyag mennyiségét. Az addFuel() függvény állítsa az üzemanyagszintet megfelel˝oen és adja vissza a tankban lév˝o üzemanyagmennyiséget. Az addFuel(0) töltse tele a tankot. Példányosítsd az egyszer˝ubb tesztelés kedvéért.




111 / 404

12. fejezet

Vizsgarendszer A szillabusznak megfelel˝oen 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.

12.1. A 2013/14 tanév tavaszi szemeszterének vizsgái 12.1.1. 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˝oen kidolgozhatóak, (hegylakó-szabály van, 50 pont felettieknek, tételenként 40 pontért igényes kidolgozás esetén, kezd˝o önbesorolásúak esetén csak tutor-rendszerben). A jól kell tudni részek kidolgozása egyértelm˝ubb, a f˝otéma kidolgozása szervez˝odjön az el˝oadás, a labor, a szakmai fórumunk vagy saját nagyon egyszer˝u 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˝ol 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˝odik, 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˝o védési program LZW binfa osztályába. F˝otéma: Típusok és deklarációk, a [STROUSTRUP] tankönyv 90-113 oldala.

Megoldás és megjegyzések A feladat megoldását Antal Török készítette . Tutor: Fülöp Sándor


112 / 404

2. 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˝o üzenetek nyomán. F˝otéma: Mutatók, tömbök és struktúrák, a [STROUSTRUP] tankönyv 115-139 oldala.

Megoldás és megjegyzések 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˝otéma: Kifejezések és utasítások, a [STROUSTRUP] tankönyv 142-187 oldala.

Megoldás és megjegyzések 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˝otéma: Függvények, a [STROUSTRUP] tankönyv 191-218 oldala.

Megoldás és megjegyzések 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˝otéma: Névterek és kivételek, a [STROUSTRUP] tankönyv 221-258 oldala.

Megoldás és megjegyzések 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˝otéma: Forrásfájlok és programok, a [STROUSTRUP] tankönyv 261-291 oldala.

Megoldás és megjegyzések 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˝otéma: Osztályok, a [STROUSTRUP] tankönyv 295-340 oldala.


113 / 404

Megoldás és megjegyzések 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˝o) Omips programod. F˝otéma: Operátorok túlterhelése, a [STROUSTRUP] tankönyv 344-391 oldala.


9. Jól kell tudni: saját (bármely a tárolóban lév˝o) fraktálnagyító vagy életjáték programod. F˝otéma: Származtatott osztályok, a [STROUSTRUP] tankönyv 395-427 oldala.

Megoldás és megjegyzések

10. Jól kell tudni: egy szabadon választott robotfocis feladatunk megoldása (vagy a P-szálak használata az ágensekben). F˝otéma: Sablonok, a [STROUSTRUP] tankönyv 431-465 oldala.

Megoldás és megjegyzések 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˝orz˝okkel, például a splint-el vagy valgrind-el. F˝otéma: Kivételkezelés, a [STROUSTRUP] tankönyv 467-509 oldala.


˝ 12.2. A 2014/15 tanév oszi szemeszterének vizsgái 12.2.1. 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˝o kedvezmények tekintetében lásd a sillabuszt!


114 / 404

• 2000 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. • 1800 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. • 1500 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. • 1200 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˝otémak kidolgozása szervez˝odjön az el˝oadás, a labor, a szakmai fórumunk vagy saját nagyon egyszer˝u 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˝ol 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˝odik, 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˝otéma: A [JAVAKONYV] tankönyv a 35-75 oldala. 2. Jól kell tudni: Boost BGL alapú routing a robotautóban. F˝otéma: A [JAVAKONYV] tankönyv 112-170 oldala. 3. Jól kell tudni: A Maven alapú Helló Világ! szervletes példa. F˝otéma: A [JAVAKONYV] tankönyv 75-88 oldala. 4. Jól kell tudni: Az els˝o védés (humán genomos) C++ kódjának Java átirata. F˝otéma: A [JAVAKONYV] tankönyv 349-357 oldala. 5. Jól kell tudni: Egy Maven projekt (YANO vagy robotautó/rcwin) riportjai (kitérve pl. a ciklomatikus komplexitásra). F˝otéma: A [JAVAKONYV] tankönyv 303-344 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˝u pont alatt). F˝otéma: A [JAVAKONYV] tankönyv 472-509 oldala. 7. Jól kell tudni: kvalifikációs szint elérése a január 28-i Robotautó Világbajnokságra. F˝otéma: A [JAVAKONYV] tankönyv 90-111 oldala. 8. Jól kell tudni: saját kliens ágens a Robotautó Világbajnokságra. F˝otéma: A [JAVAKONYV] tankönyv 286-302 oldala. 9. Jól kell tudni: OSM XML-b˝ol C++ programmal a buszok útvonalának kibányászása. F˝otéma: A [JAVAKONYV] tankönyvII/420-446 oldala. 10. Jól kell tudni: OSM XML-b˝ol kibányászott busz-útvonalak megjelenítése (Android-on, vagy xmapviewer PC-n). F˝otéma: A [STROUSTRUP] tankönyv második kötetéb˝ol a 563-669 oldal.

12.2.2. Királyi út a szóbeli vizsgán Lehet˝osége van a tételsor kiváltására annak, aki eleget tesz a következ˝o 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˝ol kaphat kérdést, amelyet el kell magyaráznia 3. részt is vesz a versenyen!


13. fejezet

Nincs 13. fejezet

115 / 404


116 / 404

14. fejezet

Céges feladatok Ezek a feladatok a negyedik védés választható feladatai.

14.1. 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˝o feladatcsokor. Részben mintaképpen is kerül itt kiírásra, hogy a céges feladat intézménye iránt érdekl˝od˝o 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.

14.1. ábra. A projekt "Tetris-terve". A projektben fejlesztend˝o 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˝ol a priori bírunk információkkal, illetve automatikusan (ASA) vagy emberi beavatkozással segítve (HSA) gy˝ujtünk adatokat. El˝obbire példa, amikor egy beköt˝oút bejöv˝o forgalmát egy kamera alapú alkalmazás számolja adott id˝oszakban, utóbbira, amikor ugyanezt egy emberi megfigyel˝o teszi. Az emulátor (Robocar City Emulator) a járm˝uvek mozgatását emulálja a vizsgált városban, miközben minden járm˝uvet ugyanazzal a vezérl˝o algoritmussal (The competition) látunk el. Egy-egy leemulált nap eredményei (Results) alapján hirdetjük ki a verseng˝o vezérl˝o algoritmusok között a gy˝oztest. A versengés alapja például a járm˝uvek á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˝ok (Monitors) például a Google Maps vagy OpenStreetMap alapú megjelenít˝okben. A következ˝o feladatok megoldását open source, lehet˝oleg GPLv3 engedéllyel ellátott programmal valósítsd meg. Ennek megfelel˝oen 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.


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˝o GPS koordináta párt kap, majd kimenetként kinyomtat egy utat a megadott koordináta párokhoz legközelebb es˝o 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˝uvek 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˝u kibolyongna a Debrecen térképr˝ol, 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˝ol, 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˝o 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˝o programot a Helga feladathoz! Nem hegylakó feladat, 90 pont. Címkék: City, Map, Monitors. • Brúnó feladat. Írj OSM alapú megjelenít˝o 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˝o programot a Petra feladathoz! Nem hegylakó feladat, 30 pont. Címkék: City, Map, Monitors. • Koppány feladat. Írj OSM alapú megjelenít˝o 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˝o 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.


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˝ol 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˝u 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.


119 / 404

II. rész

Megoldások


120 / 404

Ebben a részben az érdekl˝od˝o hallgatók dolgozzák ki az el˝oadó és a laborvezet˝ok á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˝ot a legtöbb esetben kész forrásokat vagy akár teljes kidolgozást is. Fontos, hogy a megoldás felvitele el˝ott a feladatnak még kidolgozatlannak kell lennie, hiszen a hallgatók versenyben állnak és csak az els˝o, 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.


121 / 404

15. fejezet

A kezd˝o szint programjai 15.1. Az elso˝ C programok 15.1.1. 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˝ott 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, %Cpu1 : 5,0 us, 10,3 sy, 0,0 ni, 84,1 id, 0,7 wa, 0,0 hi, 0,0 si, %Cpu2 : 1,3 us, 1,0 sy, 0,0 ni, 97,3 id, 0,0 wa, 0,3 hi, 0,0 si, %Cpu3 : 1,0 us, 0,0 sy, 0,0 ni, 99,0 id, 0,0 wa, 0,0 hi, 0,0 si, %Cpu4 : 0,7 us, 0,7 sy, 0,0 ni, 98,7 id, 0,0 wa, 0,0 hi, 0,0 si, %Cpu5 : 1,3 us, 1,7 sy, 0,0 ni, 97,0 id, 0,0 wa, 0,0 hi, 0,0 si, %Cpu6 : 0,0 us, 0,0 sy, 0,0 ni,100,0 id, 0,0 wa, 0,0 hi, 0,0 si, %Cpu7 :100,0 us, 0,0 sy, 0,0 ni, 0,0 id, 0,0 wa, 0,0 hi, 0,0 si, KiB Mem: 8126124 total, 4229920 used, 3896204 free, 280076 buffers KiB Swap: 8142844 total, 0 used, 8142844 free, 1625532 cached PID USER 7845 nbatfai

PR 20

NI 0

VIRT 4164

RES 328

SHR S 260 R

%CPU %MEM 99,6 0,0

0,0 0,0 0,0 0,0 0,0 0,0 0,0 0,0

st st st st st st st st

TIME+ COMMAND 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 int main () { for (;;) sleep (1); return 0; }


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 Tasks: 1 total, %Cpu0 : 0,3 us, %Cpu1 : 0,3 us, %Cpu2 : 0,0 us, %Cpu3 : 0,7 us, %Cpu4 : 0,0 us, %Cpu5 : 0,0 us, %Cpu6 : 0,0 us, %Cpu7 : 0,0 us, KiB Mem: 8126124 KiB Swap: 8142844 PID USER 8701 nbatfai

4:49, 4 users, load average: 0,03, 0,34, 0,70 0 running, 1 sleeping, 0 stopped, 0 zombie 0,3 sy, 0,0 ni, 99,3 id, 0,0 wa, 0,0 hi, 0,0 si, 0,3 sy, 0,0 ni, 99,3 id, 0,0 wa, 0,0 hi, 0,0 si, 0,0 sy, 0,0 ni,100,0 id, 0,0 wa, 0,0 hi, 0,0 si, 0,0 sy, 0,0 ni, 99,3 id, 0,0 wa, 0,0 hi, 0,0 si, 0,0 sy, 0,0 ni,100,0 id, 0,0 wa, 0,0 hi, 0,0 si, 0,0 sy, 0,0 ni,100,0 id, 0,0 wa, 0,0 hi, 0,0 si, 0,0 sy, 0,0 ni,100,0 id, 0,0 wa, 0,0 hi, 0,0 si, 0,0 sy, 0,0 ni,100,0 id, 0,0 wa, 0,0 hi, 0,0 si, total, 4275236 used, 3850888 free, 280824 buffers total, 0 used, 8142844 free, 1626104 cached

PR 20

NI 0

VIRT 4164

RES 332

SHR S 260 S

%CPU %MEM 0,0 0,0

0,0 0,0 0,0 0,0 0,0 0,0 0,0 0,0

st st st st st st st st

TIME+ COMMAND 0:00.00 vegtelen

láthatóan a programunk a man 3 sleep kézikönyvlapon írtaknak megfelel˝oen alszik.

15.1.2. 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˝odik. 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

15.1.3. Két változó értékének a cseréje swap függvénnyel kód: ../source/kezdo/elsocpp/valtozocsere/swap.cpp #include using namespace std; int main() { int a = 1; int b = 2;


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˝uvelet ekvivalenciáját. A SWAP az std névtérben található, amit a using namespace std; parancsszóval linkeltünk.

15.1.4. 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˝odik 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; }

15.1.5. 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
//kurzor pozicionálása

//lefelé tolás


for(i=0; i<x; i++) printf(" "); printf("o\n"); //labda ikonja

124 / 404

//jobbra tolás

} int main() { int int int int int int int int

egyx=1; egyy=-1; j=78; i; x=10; //a labda kezdeti pozíciója y=20; ty[23];//magasság // a pálya mérete 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"); }


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˝oriztem a kódot a splinttel. [../udprog-code/source/kezdo/elsoc/pattog]$ splint pattog.c

Eredmény: [Splint 3.1.2 --- 03 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 --- 8 code warnings

Az els˝o hibát amit észlelt a splint egyszer˝uen ki lehet küszöbölni, mert a kódban lev˝o függvénynek egyszer˝uen 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


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 --- 3 code warnings

15.1.6. 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 2014.02.28.: if-ek helyett signbit() függvény használata a visszapattanás megoldásához. (Virtuális környezetben nem m˝uködik.) Update 2014.03.03.: "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 #include #include #include #include

<sys/ioctl.h> <math.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˝ otö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˝ o 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˝ o 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


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˝ o sorba állítás cout << "\n"; cout.flush(); } for (i=0; i < ux ; i++){ //megfelel˝ o 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˝ oz˝ o 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˝oi: futás közbeni ablakátméretezést érzékeli és helyesen kezeli; állítható kezd˝o pozíció, irány és sebesség; a mozgást vektorosan modelleztük; valós végtelen ciklus.

15.1.7. 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. /*


128 / 404

* Program: Pattogó labda (abszolútérték nélkül) * Dátum: 2014.02.19. * 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); //printf("Vx: %d Vy: %d", vx, vy); rajzol(x,y); usleep(100000); } return 0; }

//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

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


129 / 404

#include<stdio.h> #include<stdlib.h> #include <sys/ioctl.h> gotoxy(int x, int y) { int i; for(i=0; i
//kurzor pozicionálása

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("_");

//lefelé tolás //jobbra tolás


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˝oi: Ezt a programot már el˝ottem elkészítették én csak képessé tettem arra hogy a terminál ablakot futás közben módosítani lehessen.

15.1.9. „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˝orzés splint-el (Kis Dávid) [../udprog-code/source/kezdo/elsoc/hello]$ splint hello.c

Nem taltált hibát. Eredménye: [Splint 3.1.2 --- 03 May 2009 Finished checking --- no warnings


131 / 404

public class hello { public static void main(String[] args) { System.out.println("Hello Vilag"); System.err.println("Hello Vilag"); } }

15.1.10. Átlag A megoldást a ../source/kezdo/elsoc/atlag/atlag.c forrásállományba helyeztem el. #include<stdio.h> #include<stdlib.h> #include 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˝ole. A program splint ellen˝orzésnél ezt a hibát dobta. /usr/include/ctype.h:47:5: Parse Error: Non-function declaration: __BEGIN_DECLS : int.

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

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˝odnek. 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˝ot felhasználva már véletlen számokat produkál. A cs˝ovezeté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˝oszö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˝orzés splint-el: [../udprog-code/source/kezdo/elsoc/veletlenszamok]$ splint veletlensz.c

Eredmény: [Splint 3.1.2 --- 03 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 --- 2 code warnings

15.1.11. A szóhossz a gépeden 15.1.11.1. 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˝oké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˝o eredményt kapom:


32

Ellen˝orzés splint-el: [../udprog-code/source/kezdo/elsoc/szohossz]$ splint szohossz.c

Eredmény: [Splint 3.1.2 --- 03 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 --- 2 code warnings

15.1.11.2. A szóhossz a gépeden, bitmuveletes ˝ 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˝oké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˝o eredményt kapom: A szohossz ezen a gepen: 32 bites

Ellen˝orzés splint-el: [../udprog-code/source/kezdo/elsoc/szohossz]$ splint szohossz_sizeof.c

Eredmény: [Splint 3.1.2 --- 03 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

133 / 404


134 / 404

To allow arbitrary integral types to match any integral type, use +matchanyintegral. szohossz_sizeof.c:4:10: Corresponding format code Finished checking --- 1 code warning

15.1.12. BogoMIPS Készítette: Szentpéteri Annamária. A megoldást a http://www.inf.unideb.hu/~nbatfai/Prog1_5.pdf fájlban leírtak alapján készítettem el és a ../source/kezdo/elsoc/BogoMIPS/bogoMIPS.c nev˝u fájlban található. Ez a függvény arra szolgál, hogy segítsen lemérni az id˝ot, ami az elvégzéséhez szükséges, mint ahogy az lentebb látható is lesz. #include <stdio.h> #include void delay (unsigned long long int loops) { unsigned long long int i; for ( i=0; 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˝obb 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˝u nem lesz a ciklusváltozó. Az eltelt id˝ot 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˝ol. 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˝o 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˝o, mint a CLOCKS_PER_SEC beépített konstans akkor a következ˝o történik: A loops_per_sec értékét megváltoztatja, majd kiírja a végeredményt a képerny˝ore. printf ("%llu %llu\n", ticks, loops_per_sec); if (ticks >= CLOCKS_PER_SEC) { loops_per_sec = (loops_per_sec / ticks) * CLOCKS_PER_SEC;


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˝uen hibás az eredmény.

15.1.13. 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˝o ellen˝orzé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

15.1.14. A lexikális elemzéssel kapcsolatos elso˝ programjaid 15.1.14.1. Betuk ˝ számolása

A feladat megoldását Akai József Zsolt készítette (Busák Zoltán Tutor segítségével)


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˝uket, az egyéb változóba a többi karaktert. A Ctrl-D leütése után kiírja a bet˝uk 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

15.1.15. 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˝ol: A lex egy program, amely segítségével lexikális szabályokból lexikális elemz˝o programkódot lehet generálni. A lex egy szövegfájlból olvassa be a lexikális szabályokat, s kimenetként C nyelv˝u kódot állít el˝o. [../udprog-code/source/kezdo/elsoc/szamokszama]$ lex -o szamokszama.c szamokszama.l


137 / 404

Elkesziti a szamokszama.c file-t Forditjuk, és futtatjuk a szamokszama.c forráskódot, a következ˝oké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: 2014. 02. 28.

Ctrl-D lenyomása után kiírja az eredményt: 3 szam

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

15.3. 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; %%

-

-


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

15.4. Rendszerprogramozással kapcsolatos elso˝ programjaid 15.4.1. 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 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˝o-folyamat hal meg el˝obb. Ekkor a gyermekhez tárolt szülo-folyamat azonosító mez˝o é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:


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˝o ID-je 1 lett, azaz "meghalt" a szül˝ofolyamat el˝obb mint a gyerek, igy a gyerefolyamat árvaként hal meg kés˝obb. Ellen˝orzés splint-el: [../udprog-code/source/kezdo/elsoc/arva$ splint arva.c

A splint eredmény : [Splint 3.1.2 --- 03 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 --- 5 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˝o include filok kellenek a megfelel˝o m˝uködéshaz : #include <sys/types.h> #include

Azonban nálam a függvények prototípusának leírása, a main függvény el˝ott, oldotta meg a figyelmeztetéseket : int getpid(); void sleep(int); int getppid(); int fork();

Ezután a splint-et futtatva : [Splint 3.1.2 --- 03 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)


140 / 404

Finished checking --- 1 code warning

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

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˝ o 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˝odött, de a szül˝o 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˝o 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 3101 pts/1 3999 pts/1 4000 pts/1 4001 pts/1 4002 pts/1

TIME CMD 00:00:00 bash 00:00:00 zombi 00:00:00 zombi <defunct> 00:00:00 sh 00:00:00 ps


A szül˝o nem addott ki várási (wait) parancsot, ezért ZOMBI lett! Ellen˝orzés splint-el: [/udprog-code/source# splint kezdo/elsoc/Zombi/zombi_id.c

Eredmény: [Splint 3.1.2 --- 20 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 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.

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

141 / 404


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: 7531

5 másodperc elteltével: Gyermekfolyamat kilovese PID: 7548 gyermekfolyamat vege fork() utan PID: 7547

Ellen˝orzés splint-el: [../udprog-code/source/kezdo/elsoc/riasztas]$ splint riasztas.c

A következ˝o eredményt kaptam: [Splint 3.1.2 --- 03 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 --- 5 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˝ol a program még megfelel˝oen fog m˝uködni.


143 / 404

15.4.2. 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˝o 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˝o 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˝orzés splint-el: [../source/kezdo/elsoc/utolso$ splint utolso.c

A következ˝o eredményt kaptam: [Splint 3.1.2 --- 03 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


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 --- 7 code warnings

15.4.3. 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 #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˝ urugrásra felkészülni!\n"); }

Leellen˝oriztem a kódot a splinttel. [../udprog-code/source/kezdo/elsoc/nemlokalis$ splint ugras.c

Eredmény: [Splint 3.1.2 --- 03 May 2009 ugras.c: (in function main)

144 / 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 --- 7 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 #include #include #include

<stdio.h> <stdlib.h> <signal.h> <setjmp.h>

void sighandler(int); static jmp_buf buf; int main(){ char c; signal(SIGINT, sighandler);

printf("Ez a ciklus el˝ otti 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);

145 / 404


146 / 404

if ( ! setjmp(buf)) main(); }

15.5. Az elso párhuzamos programjaid 15.5.1. 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˝o program azt mutatja be, hogy a (mutex által) nem védett számláló értéke "elromlik". #include <stdio.h> #include <stdlib.h> #include #define SZALAK 50

int szamlalo = 0; void var(void) { int i, r = 1+(int) (10000.0 * rand() / (RAND_MAX + 1.0)); for (i=0; i

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˝o eredményt kapjuk: . . . Szal: 45, 14726912 Szal: 34, 107046656 Szal: 11, 300078848 Szal: 34, 107046656 Szal: 11, 300078848 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˝orzé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˝o program azt mutatja be, hogy a mutexel védett számláló nem romlik el. #include <stdio.h> #include <stdlib.h>

-


148 / 404

#include #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) (10000.0*rand()/(RAND_MAX+1.0)); for(i=0; i
-


pthread_join(sz[i], (void *) &r); //addig programszál véget nem ér.

149 / 404

vár,

amíg

a

paraméterként

adott

-

} printf("A szamlalo vegul: %d\n", szamlalo); return 0; }

A mutex-r˝ol: Programozástechnológiában Párhuzamos folyamatok használatakor el˝ofordulhat, hogy két folyamat ugyanazt az Er˝oforrást (resource) egyszerre akarja használni. Ekkor jellemz˝oen felléphet Versengés. Ennek kiküszöbölésére a gyorsabb folyamat egy, az er˝oforrá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˝oforráshoz. Tehát: A mutex lehet˝ové teszi annak biztosítását, hogy egy védett er˝oforrással egyszerre mindig csak egyetlen feladat dolgozhasson, és így elkerülhet˝ok 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˝oz˝o 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˝o eredményt kapjuk: . . . Szal: 48, 1130182400 Szal: 48, 1130182400 Szal: 48, 1130182400 Szal: 48, 1130182400 A szamlalo vegul: 0

Láthatóan a globális számláló értéke nem változott. Ellen˝orzés splint-el: [../udprog-code/source/kezdo/elsoc/elromlik_a_valtozo$ splint zarral.c

15.6. Az elso˝ algoritmizálási programjaid 15.6.1. 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 #define #define #define #define #define #define

N 500 M 500 MAXX 0.7 MINX -2.0 MAXY 1.35 MINY -1.35

void GeneratePNG( int tomb[N][M]) { png::image< png::rgb_pixel > image(N, M);

-


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 { Zuj.re Zuj.im Z.re = Z.im = }

* Z.re + Z.im * Z.im < 4 && iteracio++ < 255) = Z.re * Z.re - Z.im * Z.im + C.re; = 2 * Z.re * Z.im + C.im; Zuj.re; Zuj.im;

tomb[i][j] = 256 - 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‘

-


151 / 404

[../source/kezdo/elsocpp/mandelbrot]$ ./mandelbrot

15.1. ábra. A Mandelbrot halmaz feladat kimenete (kimenet.png).

15.6.2. Elfolyik a PageRank A feladatot megoldotta: Szentpéteri Annamária. Tutor: Bereczki László. (2014.03.26.) Megoldás: /source/kezdo/elsoc/pagerank/pagerank_1.5.2-3.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˝ o futás:\n"); pagerank(L); printf("\nAmikor az egyik oldal semmire sem mutat:\n"); pagerank(L1); [...] printf("\n");


152 / 404

return 0; }

gcc pagerank_1.5.2-3.c -lm ./a.out Az eredeti, tanár által megadott értékkekel történ˝ o futás: 0.090909 0.545455 0.272727 0.090909 Amikor az egyik oldal semmire sem mutat: 0.000000 0.000000 0.000000 0.000000

Ellen˝orzés splint-el: [/udprog-code/source# splint kezdo/elsoc/pagerank/pagerank_1.5.2-3.c

Eredmény: [Splint 3.1.2 --- 20 Feb 2009 kezdo/elsoc/pagerank/pagerank_1.5.2-3.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_1.5.2-3.c:6:1: Function exported but not used outside pagerank_1.5.2-3: 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_1.5.2-3.c:13:1: Definition of kiir kezdo/elsoc/pagerank/pagerank_1.5.2-3.c:16:1: Function exported but not used outside pagerank_1.5.2-3: tavolsag kezdo/elsoc/pagerank/pagerank_1.5.2-3.c:25:1: Definition of tavolsag kezdo/elsoc/pagerank/pagerank_1.5.2-3.c:28:1: Function exported but not used outside pagerank_1.5.2-3: pagerank kezdo/elsoc/pagerank/pagerank_1.5.2-3.c:56:1: Definition of pagerank Finished checking --- 4 code warnings

15.6.3. Ellopni a PageRank értéket A feladatot megoldotta: Szentpéteri Annamária. Tutor: Bereczki László. (2014.03.26.) Megoldás: /source/kezdo/elsoc/pagerank/pagerank_1.5.2-3.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 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˝ o futás:\n"); pagerank(L); [...] printf("\nAmikor az egyik oldal csak magára mutat:\n"); pagerank(L2); printf("\n"); return 0; }

gcc pagerank_1.5.2-3.c -lm ./a.out Az eredeti, tanár által megadott értékkekel történ˝ o futás: 0.090909 0.545455 0.272727 0.090909 Amikor az egyik oldal csak magára mutat: 0.000000 0.000000 0.000000 1.000000

Ellen˝orzés splint-el: [/udprog-code/source# splint kezdo/elsoc/pagerank/pagerank_1.5.2-3.c

Eredmény: [Splint 3.1.2 --- 20 Feb 2009 kezdo/elsoc/pagerank/pagerank_1.5.2-3.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_1.5.2-3.c:6:1:

153 / 404


154 / 404

Function exported but not used outside pagerank_1.5.2-3: 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_1.5.2-3.c:13:1: Definition of kiir kezdo/elsoc/pagerank/pagerank_1.5.2-3.c:16:1: Function exported but not used outside pagerank_1.5.2-3: tavolsag kezdo/elsoc/pagerank/pagerank_1.5.2-3.c:25:1: Definition of tavolsag kezdo/elsoc/pagerank/pagerank_1.5.2-3.c:28:1: Function exported but not used outside pagerank_1.5.2-3: pagerank kezdo/elsoc/pagerank/pagerank_1.5.2-3.c:56:1: Definition of pagerank Finished checking --- 4 code warnings

15.6.4. Alternatív tabella A feladatot megoldotta: Szentpéteri Annamária. Tutor: Bereczki László. (2014.03.26.) 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˝o átalakításával. #include #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] {0, 3, 2, 1, 2, 3, 2, {3, 0, 2, 1, 3, 2, 1, {1, 1, 0, 3, 3, 1, 3, {3, 2, 1, 0, 1, 2, 1, {3, 3, 3, 2, 0, 1, 1, {1, 1, 3, 1, 1, 0, 1, {1, 2, 3, 2, 1, 1, 0, {3, 1, 1, 1, 3, 2, 1, {3, 3, 1, 2, 3, 1, 2, {3, 1, 1, 2, 3, 2, 3, {2, 3, 1, 2, 1, 1, 3, {3, 3, 3, 3, 3, 3, 3, {1, 2, 1, 1, 2, 2, 1, {2, 1, 2, 2, 1, 2, 1, {1, 3, 1, 1, 2, 1, 1, {1, 1, 1, 2, 1, 2, 3, };

= { 3, 3, 3, 3, 2, 2, 1, 1, 1, 1, 1, 3, 1, 1, 0, 3, 1, 0, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1,

//lejátszott meccsek "kódtáblája" 2, 3, 2, 2, 2, 2, 3}, 3, 1, 2, 1, 3, 2, 1}, 2, 3, 1, 1, 1, 2, 1}, 1, 1, 1, 3, 2, 1, 1}, 1, 1, 1, 1, 1, 3, 2}, 2, 2, 1, 2, 1, 2, 3}, 1, 3, 3, 1, 3, 3, 1}, 1, 3, 1, 1, 1, 3, 1}, 3, 3, 2, 1, 1, 3, 1}, 0, 3, 1, 3, 1, 3, 3}, 2, 0, 1, 1, 1, 1, 2}, 1, 1, 0, 2, 1, 2, 3}, 1, 3, 1, 0, 3, 1, 2}, 1, 3, 1, 1, 0, 1, 1}, 1, 1, 1, 1, 1, 0, 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˝ ori ETO", "Kaposvári Rákóczi", "Kecskeméti TE", "Lombard Pápa", "MTK Budapest", "Paksi FC",

//csapat nevek


"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
155 / 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; } }

156 / 404


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˝ uen" 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; }

15.7. Az elso˝ GNU/Linux kernellel kapcsolatos programjaid ˝ 15.7.1. „Helló, Világ!” a kernelbol 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˝okben a telepités menetét fogom leirni. A következ˝oket szükséges elvégezni, miel˝ott a fájlokat használnád: $ sudo -i # apt-get install module-assistant


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˝o lépésként tegyük meg a következ˝oket: # make $ sudo insmod hello.ko

Kimenetet pedig a következ˝oképp nézhetjük meg. (tail vagy dmesg) $ tail /var/log/syslog # dmesg

15.7.2. A PCB mérete 15.7.3. A PCB mérete modulból

15.8. Az elso˝ MINIX kernellel kapcsolatos programjaid ˝ 15.8.1. „Helló, Világ!” a kernelbol 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˝uen megoldható, és a célunknak tökéletesen megfelel. A "VM Lens" nev˝u programmal oldottam meg, linkeltem is: https://apps.ubuntu.com/cat/applications/unity-lens-vm/ MINIX3 Virtuálisan CD meghajtóként majd magát az iso-t is felcsatolhatjuk. Az iso képfájl: http://www.minix3.org/ 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˝u 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˝oképpen szerkesztettem:

/*===========================================================================* announce * * *===========================================================================*/ static void announce(void) { /* Display the MINIX startup banner. */ printf("\nMINIX %s.%s. " #ifdef _VCS_REVISION


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 http://www.minix3.org\n"); printf("Helló, Világ!"); }

Tehát egyszer˝uen csak kib˝ovitettem 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˝ol, valahogy így: MINIX 3.2.1. (116fcea) Copyright 2012, Vrije Universiteit, Amsterdam, The Netherlands MINIX is open source software, see http://www.minix3.org Helló, Világ! . . .

Helló, Világ!

15.8.2. 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 #define _MACHINE_ATARI #define _MACHINE_MACINTOSH

40 /* Sun-4/60 (aka SparcStation 1 or Campus) */ 60 /* ATARI ST/STe/TT (68000/68030) */ 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_M68000 2 /* CHIP type for Atari, Amiga, Macintosh */


160 / 404

15.8.3. Ü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: -4

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


161 / 404

kprintf("MINIX is open source software, see http://www.minix3.org\n"); kprintf("%d %d %d\n", sizeof(struct proc), sizeof(proc), sizeof(struct proc)*(NR_TASKS+NR_PROCS)); }

15.9. Az elso˝ C++ programok 15.9.1. Módosított polártranszformációs véletlenszám generátor, ez legyen az elso˝ C++ progid! Készítette: Szentpéteri Annamária. Tutor: Bereczki László. Dátum: 2014.02.28. 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 #include #include #include

//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˝ o függvény kifejtése if (!exist){ double u1, u2, v1, v2, w; do{ u1 u2 v1 v2

= = = =

std::rand () / (RAND_MAX + 1.0); //innent˝ ol jön az algoritmus std::rand () / (RAND_MAX + 1.0); 2 * u1 - 1; 2 * u2 - 1;


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 }

15.9.2. 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 #include int main() { std::vector a; std::vector 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] << " ";


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; }

15.9.3. 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 #include<stack> using namespace std; int main() { stack a; stack b; for(int i=0;i<10;i++) { a.push(i); } b=a; a.pop(); cout<<"a: "<
15.9.4. 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.


#include #include<list> using namespace std; int main() { list a; list b; for(int i=0;i<5;i++) { a.push_back(i); } for(list::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::iterator it=a.begin();it!=a.end();++it) { std::cout<<"a: "<<*it<<endl; } cout<<"\n"; for(list::iterator it=b.begin();it!=b.end();++it) { std::cout<<"b: "<<*it<<endl; } return 0; }

15.9.5. Másolt map A ../source/kezdo/elsocpp/masolt_map/map.cpp #include #include<map> using namespace std; int main() { map a; map b; a.insert(pair(’a’,100)); a.insert(pair(’z’,200)); cout<<"a mérete: "<
164 / 404


165 / 404

//mély másolás történt mivel ’a’ címér˝ ol 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:"<
15.9.6. Másolt map A ../source/kezdo/elsocpp/masolt_set/set.cpp //Závaczki Roland #include #include<set> using namespace std; int main() { set a; set b; a.insert(1); cout<<"a size: "<
15.9.7. 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˝o el. #include #include const const const const const

int N = 500; int M = 500; double MAXX = 0.7; double MINX = -2.0; double MAXY = 1.35;


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] = 256 - iteracio; } } GeneratePNG(tomb); return 0; }

15.9.8. Az elso˝ Qt programjaid 15.9.8.1. 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

166 / 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(); }

˝ 15.9.8.2. A genetikai kód-szonyeg 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 #include #include "genablak.h" void hasznalat(void) { std::cout<<"Használat: ./genetikai bemeneti_fájl"<<std::endl; }

167 / 404


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(); }

˝ 15.9.8.3. További élolények a sejttérben

15.9.9. Az elso˝ képfeldolgozással kapcsolatos programjaid 15.9.9.1. Az elso˝ png++ és pngwriter könyvtárakkal kapcsolatos programjaid 15.9.9.1.1. 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˝ uködik!

#include void makeBlocky(png::image &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˝ o paraméterben megadott névvel png::image picture (argv[1]);

-


// változók int avgR = 0, avgG = 0, avgB = 0, block_size = 4, vertBlocks, horizBlocks;

// // // // // //

169 / 404

piros átlag zöld átlag kék átlag "kockák" mérete (pixel) függ˝ oleges "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˝ ol, 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˝ o átlagunkat avgR += rgb.red; avgG += rgb.green; avgB += rgb.blue;

-

-

// blokkszámok növelése vertBlocks = i; horizBlocks = j; } // "kockásít˝ o 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;

-

}

15.9.9.1.2. 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ó"


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˝ uköd˝ oképes. #include 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˝ obbi képet az els˝ o 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˝ o 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˝ oleges "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˝ ol, végigzongorázzuk for (int j = 1; j < block_size && row + j < picture.getwidth(); j++) {

-


// aktuális pixel // aktuális pixel átlagunkat average_colors[1] average_colors[2] average_colors[3]

171 / 404

beolvasása színcsatornáinak értékével növeljük a megfelel˝ o

-

+= picture.read(row + j, column + i,1); += picture.read(row + j, column + i,2); += picture.read(row + j, column + i,3);

// blokkszámok növelése vertical_blocks = i; horizontal_blocks = j; } // "kockásít˝ o 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;

-

}

15.9.10. Az elso˝ Open CV-vel kapcsolatos programjaid 15.9.10.1.

15.10. Az elso˝ Java programok 15.10.1. Módosított polártranszformációs véletlenszám generátor, ez legyen az elso˝ 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;


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õ()); } }

15.11. Labor és szorgalmi laborfeladatok 15.11.1. 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˝o 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",


"Cys", "Trp", "Arg", "Gly"

173 / 404

// 18. // 19. // 20.

}; //A fenti tömbbel megegyezik az indexelés, azonos index esetén a fenti aminosavhoz tartozó el˝ ofordulá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˝uhármas által meghatározott érték alapján, melyik aminosavhoz tartozik a feldolgozott bet˝uhármas. (A switch-nek csak egy részét hagytam itt, a teljesért lásd a fentebb linkelt fáljt.) // a 3 bet˝ u 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˝ u a "Val" GTT-t˝ ol 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;


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˝ un állok? // Fontos! (-1)-r˝ ol indulunk, különben nem tudnánk rendesen hármasával szedni a bet˝ uket. int hanyadik_betu = -1; // azon a helyen mit olvastam? int elso = 0, masodik = 0, harmadik = 0, i = 0, jegy = -1; // vezet˝ o komment (els˝ o 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˝ ukhö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˝ unél tartunk hanyadik_betu = (hanyadik_betu + 1) % 3;


if (!hanyadik_betu) //ha nem nulla, elso = jegy; else if (!(hanyadik_betu - 1)) //ha masodik = jegy; else //ha nem nulla és nem 1, { harmadik = jegy; //Az index kiszámolása int index = genetikai_kod (elso * //Az el˝ ofordulásokat számoló tömb ++amino_sav_hiszt[index]; //A bet˝ uk által alkotott aminosav printf ("%s", amino_sav[index]); } }

175 / 404

akkor nem 1, akkor akkor ért el a 3. bet˝ uhöz

16 + masodik * 4 + harmadik); megfelel˝ o elemének növelése kiírása

} //Kiírja az összes aminosavat és a hozzájuk tartozó el˝ ofordulást for (int i = 0; i < 21; ++i) printf ("\n%s %i", amino_sav[i], amino_sav_hiszt[i]); printf ("\n"); }

15.11.2. 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˝oként elkészített filogenetikai fa az eredeti állományokból épül fel.


176 / 404

15.2. ábra. Mammals A második képhez el˝obb 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˝o:


177 / 404

15.3. ábra. LZW szórás alapján


178 / 404

16. fejezet

A közepes szint programjai 16.1. A kezdo˝ szintu˝ feladatokra épített példák 16.1.1. 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: 2014.02.28. 22:30 * oállít 1.000.000 random * Note: A program a polártranszformációs algoritmust használva el˝ értéket, * majd ezek átlagát veszi. * * */ #include //#include #include #include #include #define SIZE 1000000

//környezet függ˝ o

//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

-


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˝ o függvény kifejtése if (!exist){ double u1, u2, v1, v2, w; do{ u1 = std::rand () / (RAND_MAX + 1.0); //innent˝ ol 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()); //1.000.000 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

-


180 / 404

16.1.2. Normális-harang A megoldást az el˝oz˝o 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 #include <sys/types.h> #include #define MERET 1000000 // 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 < 110001;i += 25) { //a lépésköz kicsi hogy printf("\n"); //látszódjon a hisztogram printf("%6d ", -i + 110000); // gorbéje for(j = 0;j < 10;++j) if(db[j] >= -i +110000) 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˝orzés splint-el: [/udprog-code/source# splint kozepes/kezdore_epulo/hisztogram/karakteres/hisztogram.c

Eredmény:


[Splint 3.1.2 --- 20 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 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.

16.1.3. Normális-harang grafikusan A feladat kidolgozását az el˝oz˝o 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˝o á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 #include

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;

181 / 404


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˝o részt illesztettem be, a további forráskód megtalálható a source könyvtárban.

16.1.4. 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˝o szint˝u 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˝o paranccsal: "sudo apt-get install libncurses5-dev". Továbbá használni kell a -lncurses kapcsolót a fordításnál.


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˝o négy sor az mvprintw parancs helyes m˝uködéséhez kell. A for ciklusban látottak azért kellenek, hogy "szimuláljuk" a képerny˝ofrissí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.

16.1.5. 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 #include #include #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 * 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++)

-


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˝ o 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˝ oleges "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˝ odik ahanyadik az adott szál, és a szálak számával lép el˝ ore. 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˝ ol, 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˝ o átlagunkat avgR += rgb.red; avgG += rgb.green; avgB += rgb.blue; // blokkszámok növelése vertBlocks = i; horizBlocks = j; } // "kockásít˝ o 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

-

-


185 / 404

Thread_kesz++; pthread_exit(NULL); } int main (int argc, char *argv[]) { // inicializáljuk képünket a programindításkor megadott els˝ o paraméterben megadott névvel

-

png::image 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_keszwrite(argv[2]); return 0;

-

}

Ez a program a kezd˝o szint˝u 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.

16.1.6. 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˝ oket alapul véve: // - Dalmadi Zoltán png++ feladata // - Kakócz Erik png++ pthread-es megoldása // - Bátfai Norbert jegyzete //


// Fordítás: // g++ kockasitas_pngwriter_pthread.cpp -pthread ‘freetype-config --cflags‘ lpngwriter -lz -lfreetype -o kockasitas_pngwriter_pthread

186 / 404

-lpng -

-

// Használat: // ./kockasitas_pngwriter alapkep.png kockasitandokep.png // A program csak png képekkel m˝ uköd˝ oképes. #include #include #include #include <stdint.h> #define numThread 2 pngwriter * picture; int thread_done = 0; void kockasit(int R, int G, vertical_blocks) { // színek beállítása R = R/vertical_blocks * G = G/vertical_blocks * B = B/vertical_blocks *

int B, int row, int column, int horizontal_blocks, int

-

horizontal_blocks; horizontal_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˝ o 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˝ oleges "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˝ ol, végigzongorázzuk for (int j = 1; j < block_size && row + j < picture->getwidth(); j++) {

-


// aktuális pixel // aktuális pixel átlagunkat average_colors[1] average_colors[2] average_colors[3]

187 / 404

beolvasása színcsatornáinak értékével növeljük a megfelel˝ o

-

+= picture->read(row + j, column + i,1); += picture->read(row + j, column + i,2); += picture->read(row + j, column + i,3);

// blokkszámok növelése vertical_blocks = i; horizontal_blocks = j; } // "kockásít˝ o 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˝ obbi képet az els˝ o 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; }

-


16.1.7. Rendszerprogramozással kapcsolatos programjaid 16.1.7.1. 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˝orzés splint-el: [/udprog-code/source# splint kozepes/glibc/libsajat.c

Eredmény: [Splint 3.1.2 --- 20 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(’[’)

188 / 404


kozepes/glibc/libsajat.c:13:3: kozepes/glibc/libsajat.c:14:3: kozepes/glibc/libsajat.c:15:3: kozepes/glibc/libsajat.c:16:3: kozepes/glibc/libsajat.c:17:3: kozepes/glibc/libsajat.c:18:3: kozepes/glibc/libsajat.c:19:3: kozepes/glibc/libsajat.c:20:3: kozepes/glibc/libsajat.c:21:3: kozepes/glibc/libsajat.c:22:3: kozepes/glibc/libsajat.c:23:3:

Return value (type int) Return value (type int) Return value (type int) Return value (type int) Return value (type int) Return value (type int) Return value (type int) vprintf(fmt, ap) Return value (type int) Return value (type int) Return value (type int) Return value (type int)

189 / 404

ignored: ignored: ignored: ignored: ignored: ignored: ignored:

putchar(’4’) putchar(’3’) putchar(’;’) putchar(’3’) putchar(’1’) putchar(’m’)

ignored: ignored: ignored: ignored:

putchar(0x1B) putchar(’[’) putchar(’0’) putchar(’m’)

Finished checking --- 13 code warnings

16.1.8. Saját top parancs A feladatot Szimeonov Nikolett készítette. A feladat megoldása a következ˝o állományokban található: ../source/kozepes/top/proci.c #include <stdio.h> #include #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;


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.

16.1. ábra. Futtatás Ellen˝orzés splint-el: [/udprog-code/source# splint kozepes/top/proci.c

Eredmény: [Splint 3.1.2 --- 20 Feb 2009 kozepes/top/proci.c:1: Include file 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. ***


191 / 404

16.1.9. Az elso˝ Qt programjaid 16.1.9.1. 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˝ol az u˝ 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

-


192 / 404

#include #include class AreciboAblak : public QMainWindow { Q_OBJECT public: AreciboAblak(int szelesseg = 23, int magassag = 73, std::string uzenet = "0000....", QWidget *parent = 0); ~AreciboAblak(); protected: std::string uzenet; int cellaSzelesseg; int cellaMagassag; int szelesseg; int magassag; void paintEvent(QPaintEvent*); }; #endif // ARECIBOABLAK_H

//main #include #include "areciboiablak.h" int main(int argc, char *argv[]) { QApplication a(argc, argv); AreciboAblak w(23, 73, "000...."); w.show(); return a.exec(); }

16.1.9.2. 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˝o 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");


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;


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 #include "frakablak.h" int main(int argc, char *argv[]) { QApplication a(argc, argv); FrakAblak w1, w2(-.08292191725019529, -.082921917244591272, -.9662079988595939, -.9662079988551173, 600, 3000), w3(-.08292191724880625, -.0829219172470933, -.9662079988581493, -.9662079988563615, 600, 4000), w4(.14388310361318304, .14388310362702217, .6523089200729396, .6523089200854384, 600, 38655); w1.show(); w2.show(); w3.show(); w4.show(); return a.exec(); }

16.1.9.3. 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˝o mappában található: ../source/kozepes/Qt/mandel_nagyito/

194 / 404


195 / 404

Az el˝oz˝o feladathoz képest csak a frakablak.cpp-ben történt változás: mousePressEvent a nagyítandó terület bal fels˝o 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) {


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 double double double this->a this->b this->c this->d

a b c d

= = = = = = = =

this->a+x*dx; this->a+x*dx+mx*dx; this->d-y*dy-my*dy; this->d-y*dy; a; b; c; 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)

196 / 404


197 / 404

{ szamitasFut = false; x = y = mx = my = 0; }

16.1.9.4. Mandelbrot mento˝

A feladatot Deregi Diána készítette el. A feladat megoldása a következ˝o mappában található: ../source/kozepes/Qt/mandel_mento/ Az el˝oz˝o feladat megoldását annyiban módosítottam, hogy b˝oví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"); } }

˝ 16.1.9.5. A genetikai kód-szonyeg

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˝o 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˝uknek egy színt megfeleltetve rajzolja ki a kapott képet. // genablak.cpp // Genomikus sz˝ onyeg #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;


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˝ onyeg

#include "genszal.h" GenSzal::GenSzal(const char *fajlNev, int szelesseg, GenAblak *genAblak) { this->szelesseg = szelesseg;

198 / 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] break; case ’C’: egySor[i] break; case ’A’: egySor[i] break; case ’G’: egySor[i] break; default: egySor[i] break;

= qRgb (255, 0, 0);

= qRgb (0, 255, 0);

= qRgb (0, 0, 255);

= qRgb (100, 0, 50);

= qRgb (255, 255, 255);

} } genAblak->vissza(egySor, szelesseg); } } GenSzal::~GenSzal() { fajl->close(); delete fajl; delete[] egySor; } #include #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();

199 / 404


200 / 404

return a.exec(); }

16.1.9.6. A kód vizualizációjának mentése

A megoldást elkészítette: Szentpéteri Annamária. Dátum: 2014.05.01. Forrás megtalálható: source/binom/D.Diana-Sz.Annamaria/Frak2 mappában. (Konkrétan a frakablak.cpp 150-160. 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: http://qt-project.org/doc/qt-4.8/qimage.html#save * */ if (event->key() == Qt::Key_S) { fraktal->save ( "prtscr.png", "png", 100 ); } } ...

16.1.9.7. 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˝o mappában található: ../source/kozepes/Qt/sejtautomata/ A sejttérbe él˝olé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;


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];

201 / 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+ racs[y+ racs[y+ racs[y+ racs[y+

0][x+ 1][x+ 2][x+ 2][x+ 2][x+

2] 1] 1] 2] 3]

= = = = =

ELO; ELO; ELO; ELO; ELO;

} void SejtAblak::sikloKilovo(bool **racs, int x, int y) { racs[y+ racs[y+ racs[y+ racs[y+

6][x+ 6][x+ 7][x+ 7][x+

0] 1] 0] 1]

= = = =

ELO; ELO; ELO; ELO;

racs[y+ 3][x+ 13] = ELO; racs[y+ 4][x+ 12] = ELO; racs[y+ 4][x+ 14] = ELO; racs[y+ racs[y+ racs[y+ racs[y+

5][x+ 5][x+ 5][x+ 5][x+

11] 15] 16] 25]

= = = =

ELO; ELO; ELO; ELO;

racs[y+ racs[y+ racs[y+ racs[y+ racs[y+ racs[y+ racs[y+

6][x+ 6][x+ 6][x+ 6][x+ 6][x+ 6][x+ 6][x+

11] 15] 16] 22] 23] 24] 25]

= = = = = = =

ELO; ELO; ELO; ELO; ELO; ELO; 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;

202 / 404


racs[y+ racs[y+ racs[y+ racs[y+ racs[y+

9][x+ 9][x+ 9][x+ 9][x+ 9][x+

racs[y+ racs[y+ racs[y+ racs[y+

10][x+ 10][x+ 10][x+ 10][x+

22] 23] 24] 34] 35] 22] 23] 24] 25]

= = = = =

203 / 404

ELO; ELO; ELO; ELO; ELO; = = = =

ELO; ELO; ELO; 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() {

-


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 #include "sejtablak.h" int main(int argc, char *argv[]) { QApplication a(argc, argv); SejtAblak w(100, 75); w.show(); return a.exec(); }

16.1.10. 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˝o állományokban található: ../source/kozepes/fájlleiro/fájleiro.c ../source/kozepes/fajlleiro/Makefile Fordítás: make -j (magok száma )

204 / 404


#include #include #include #include #include #include

MODULE_AUTHOR("Akai Zsolt <([email protected])> 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);

16.1.11. 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˝o á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(;;)

205 / 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
206 / 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˝orzés splint-el: [/udprog-code/source# splint kozepes/algoritmizalasi/bbp.c

Eredmény: [Splint 3.1.2 --- 20 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 [email protected] (via reportbug) ***

207 / 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 [email protected] (via reportbug) *** (attempting to continue, results may be incorrect)

16.2. 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 //készítette Kakócz Erik 2014.03.11 //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;

208 / 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<
209 / 404


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˝uködést szemléltet˝o main függvény is. Az osztályunk áll egy adatrészb˝ol 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˝o 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˝uen 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˝o 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˝oször ellen˝orizzük hogy a másolandó verem és a veremobjektum amibe másolunk megegyeznek-e, ehhez ellen˝orizzü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˝o esetben az elemszámát és méretét egyenl˝ové 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.

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

16.3.1. 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;


211 / 404

}; #endif

16.3.2. 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˝ u 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˝ o 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]; }

-


212 / 404

// A tömb méretét lekér˝ o getter függvény. // A const kulcsszó jelzi, hogy nem változtatjuk, csak olvassuk a méretet. int Int::getmeret() const { return meret; }

16.3.3. Tömb osztály teszt source/kozepes/int_dintomb/main.cpp #include #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
{

// Int osztálybeli 5 elem˝ u 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
-


213 / 404

17. fejezet

A Haladó szint programjai 17.1. Párhuzamos programjaid 17.1.1. 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 #include #include #include #include

"png++/png.hpp" <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) {

-


reC = a + k * dx; imC = d - j * dy; reZ = 0; imZ = 0; iteracio = 0; while (reZ * reZ + imZ * imZ < 4 && iteracio < iteraciosHatar) { ujreZ ujimZ reZ = imZ =

= reZ * reZ - imZ * imZ + reC; = 2 * reZ * imZ + imC; ujreZ; ujimZ;

++iteracio; } kep.set_pixel(k, j, png::rgb_pixel(255 (255 * iteracio) / iteraciosHatar, 255 (255 * iteracio) / iteraciosHatar, 255 (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;

214 / 404


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; }

17.1.2. 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 #include #include #include

"png++/png.hpp" <sys/times.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;

-


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 (255 * iteracio) / iteraciosHatar, 255 (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; }

17.1.3. 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 #include #include #include #include #include

"tbb/tbb.h" "png++/png.hpp" <sys/times.h>

int SZALAK_SZAMA;

-


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 = 32000 ):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 ujimZ reZ = imZ =

= reZ * reZ - imZ * imZ + reC; = 2 * reZ * imZ + imC; ujreZ; ujimZ;

++iteracio; } kep.set_pixel(k, j, png::rgb_pixel(255 (255 * iteracio) / iteraciosHatar, 255 (255 * iteracio) / iteraciosHatar, 255 (255 * iteracio) / iteraciosHatar)); } } } private: int reszi; png::image < png::rgb_pixel > & kep; double a ,b ,c ,d; int szelesseg , magassag , iteraciosHatar;

217 / 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; }

17.1.4. 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");

218 / 404


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’;

-


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˝otti sor jól mutat. Így a törés a magok számával megegyez˝o szálon fut. Ellen˝orzés splint-el: [/udprog-code# splint source/halado/exor/exor.c

Eredmény: [Splint 3.1.2 --- 20 Feb 2009 source/halado/exor/exor.c:6: Include file 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.


221 / 404

17.2. Minix kernellel kapcsolatos programok 17.2.1. 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 3.2.1 verzió számú MINIXen végeztem el ezért nem biztos hogy a kód kompatibilis más verziókkal. Els˝o 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˝o lépésként módosítani kell a minix mini_send nev˝u üzenetküld˝o 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


/*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{

222 / 404


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˝u lenyomásakor a msg_num_matrix_dmp függvényt futtassa. De ehhez szükséges az eredetileg F4-es billenty˝uhö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 uhö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˝uködését olvassa el az olvass_el.txt nev˝u fájl az egyszer˝u telepítéséhez.

17.3. Képfeldolgozási programjaid 17.3.1. Az elso˝ Open CV-vel kapcsolatos programjaid 17.3.1.1. 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 5.2.1 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˝o 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.


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˝ore í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);

-

-

-


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, 1000); 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; }

-


226 / 404

Extraként megírtam még két függvényt, az els˝ovel 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˝urni és követni. Ha 2 - est adunk a _Debugnr paraméternek, akkor az el˝ore beállított színek közül a _Color paramaméterrel adjuk meg a kívánt színt (egyel˝ore 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: \n"; return -1; } _Camera.read(mVidCamFirstImage); WriteOnFrame(mVidCamFirstImage, _Caption, {5, 5},’r’); mFps.Start();

" <<

_Caption << "

-

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

-


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˝urö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: \n"; return -1; } _Camera.read(mVidCamFirstImage); WriteOnFrame(mVidCamFirstImage, _Caption, {5, 0}, ’r’); mFps.Start(); _Camera.read(mVidCamSecondImage); WriteOnFrame(mVidCamSecondImage, _Caption, {5, 0},’r’);

" <<

_Caption << "

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; }

-


228 / 404

18. fejezet

A Labor-mérés prograjaid ˝ 18.1. A 2014/15 tanév oszi szemeszterének labor-mérései 18.1.1. Bevezeto˝ laborok 18.1.1.1. 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: [../udprog-code/source/labor/prog2lab/BinfaJava]$ javac Main.java

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’){


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; }

229 / 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);

230 / 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());

231 / 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 using using using

using System; System.Collections.Generic; System.Linq; System.Text; System.IO;

namespace LZWB { class Node

232 / 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 private private private private private

BinTree{ Node root; Node current; int treeHeight; int melyseg, maxMelyseg, atlagosszeg, atlagdb; 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’){

233 / 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;

234 / 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 {

235 / 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) {

236 / 404


237 / 404

} } } }

18.1.1.2. Elso˝ védési program Python átirata

Tudnivalók: A futtatáshoz Python 3.x szükséges. Bitmaszkolás helyett beépített stringkezel˝o 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))


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)

238 / 404


239 / 404

except FileNotFoundError: print(’File "{}" nem talalhato!’.format(argv[1]), file=sys.stderr) sys.exit(-4) if __name__ == "__main__": main(sys.argv)

18.1.1.3. Elso˝ védési program sebességteszt eredménye

Tudnivalók: Mindegyik program a humán genom 2. kromoszóma utolsó 100 000 sorát használja bemenetként. Eredmény:

18.1. ábra. A sebességteszt eredménye Készítette: Balkus Gerg˝o Tutor: Fülöp Sándor 18.1.1.4. 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˝o A futtatas script a gmcs parancsot is használja, amihez a következ˝o csomagok szükségesek: mono-xsp2, mono-xsp2-base Futtatás: [../udprog-code/source/labor/prog2lab/bbpbenchmark]$ ./futtatas

PiBBPBench.py


#!/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 d16S4t d16S5t d16S6t

= = = =

0.0 0.0 0.0 0.0

delta = time.clock() for d in xrange(1000000, 1000001): d16Pi = 0.0 d16S1t d16S4t d16S5t d16S6t

= = = =

d16Sj(d, d16Sj(d, d16Sj(d, d16Sj(d,

1) 4) 5) 6)

d16Pi = 4.0 * d16S1t - 2.0 * d16S4t - d16S5t - d16S6t d16Pi -= math.floor(d16Pi) jegy = int(math.floor(16.0 * d16Pi))

240 / 404


241 / 404

print jegy delta = time.clock() - delta print delta

######################################################################## if __name__ == ’__main__’: main()

18.1.1.5. Java Performance Tuning

A PrintStream Print metódusa megnövekedett futási id˝ot 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˝oforrásokat. 18.1.1.6. Alternatív Tabella

A megoldás: ../source/labor/AltTabella/Wiki2Matrix.java ../source/labor/prog2lab/AltTabella/ AltTabella.java Wiki2Matrix.java


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
242 / 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
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 { private String nev = "Nincs"; private double ertek = ’0’;

243 / 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 = ertek; } @Override 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.08333333333333333, 0.0, 0.1111111111111111, 0.14285714285714285, 0.0, 0.1111111111111111, 0.0, 0.0, 0.08333333333333333, 0.1111111111111111, 0.0625, 0.0, 0.16666666666666666.... 0.08333333333333333, 0.0, 0.0, } }; String[] eredetinev = { "Videoton", "Ferencvαros", }; int[] eredetipont = { 40, 9 }; String[] ujnev = { "BFC "Videoton", "Zalaegerszegi TE" };

244 / 404


ArrayList regi = new ArrayList(eredetinev.length); ArrayList uj = new ArrayList(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 < .000000000001) { 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];

245 / 404


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 Ir = regi.iterator(); Iterator 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); } } }

18.1.1.7. 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] + ", ");


} } } 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[][] new int[] {0, new int[] {0, 0, 0, ..... new int[] {0, 0, 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},

247 / 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

248 / 404


249 / 404

namespace Lolll { class Csapat : IComparable { 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 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.0833333333333333, 0, 0.111111111111111, 0.142857142857143, 0, 0.111111111111111, 0, 0, 0.0833333333333333, 0.111111111111111, 0.0625, 0, 0.166666666666667, 0.166666666666667, 0 },..... new double[]{0.0714285714285714, 0, 0.0833333333333333, 0, 0.142857142857143, 0.0833333333333333, 0, 0.1, 0.1, 0.0833333333333333, 0.111111111111111, 0.0625, 0.153846153846154, 0.0833333333333333, 0, 0 }};

-

-


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 < .000000000001) { 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("+++"); }

250 / 404


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; } } } } }

18.1.1.8. 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]),


252 / 404

def kiir2(self, k): for i in xrange(len(k)): print o = 0 for j in xrange(len(k[i])): print"{},".format(k[i][j]), o += k[i][j] sys.stdout.write(" {}".format(o)) print print 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, [3, [1, [0, [3, [1, [0, [0, [0, [0, [2, [3, [1, [2, [1, [0,

0, 0, 1, 0, 3, 0, 2, 0, 0, 1, 3, 3, 2, 1, 3, 0,

0, 2, 0, 1, 0, 3, 0, 1, 1, 1, 0, 0, 0, 2, 1, 1,

pontotSzerez = [ [0, [0, [0, [0, [0, [0, [0,

1, 1, 0, 0, 0, 1, 0, 1, 2, 2, 2, 0, 1, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0,

0, 3, 3, 1, 0, 0, 0, 3, 3, 0, 1, 0, 0, 1, 2, 1,

0, 0, 0, 0, 0, 0, 0,

3, 2, 1, 0, 1, 0, 1, 0, 0, 0, 1, 3, 2, 2, 0, 0,

0, 0, 0, 0, 0, 0, 0,

2, 0, 3, 1, 1, 0, 0, 0, 0, 3, 0, 3, 1, 1, 0, 3,

0, 0, 0, 0, 0, 0, 0,

3, 3, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1,

0, 0, 0, 0, 0, 0, 0,

3, 3, 0, 1, 0, 3, 1, 0, 0, 1, 1, 2, 0, 0, 0, 1,

0, 0, 0, 0, 0, 0, 0,

2, 3, 0, 0, 1, 2, 0, 1, 0, 0, 2, 1, 1, 0, 1, 0,

0, 0, 0, 0, 0, 0, 0,

0, 0, 3, 1, 1, 0, 3, 3, 0, 0, 0, 1, 3, 3, 1, 0,

0, 0, 0, 0, 0, 0, 0,

0, 0, 1, 1, 1, 0, 0, 1, 2, 0, 1, 0, 1, 1, 1, 1,

0, 0, 0, 0, 0, 0, 0,

0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 2, 0, 1, 1, 2,

0, 0, 0, 0, 0, 0, 0,

2, 0, 0, 2, 0, 1, 3, 1, 1, 1, 0, 0, 0, 0, 1, 1,

0, 0, 0, 0, 0, 0, 0,

2, 0, 2, 1, 0, 2, 3, 3, 3, 3, 0, 0, 0, 0, 0, 3,

0, 0, 0, 0, 0, 0, 0,

3], 1], 0], 1], 0], 3], 1], 0], 1], 3], 2], 0], 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, 0, 0, 0, 0, 0,

253 / 404

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] ]

oszt = Wiki2Matrix() 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


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.0833333333333333, 0, 0.111111111111111, 0.142857142857143, 0, 0.111111111111111, 0, 0, 0.0833333333333333, 0.111111111111111, 0.0625, 0, 0.166666666666667, 0.166666666666667, 0 ], [0, 0, 0.0833333333333333, 0.111111111111111, 0.142857142857143, 0.0833333333333333, 0.111111111111111, 0, 0, 0, 0.111111111111111, 0.0625, 0.0769230769230769,0, 0.166666666666667, 0.111111111111111 ], [0.0714285714285714, 0.166666666666667, 0, 0, 0, 0.166666666666667, 0, 0, 0, 0.0, 0.0625, 0.0769230769230769, 0.0833333333333333, 0.166666666666667, 0 ], [0, 0, 0.0833333333333333, 0, 0.142857142857143, 0, 0.111111111111111, 0.1, 0.2, 0.0833333333333333, 0.222222222222222, 0.0625, 0, 0.0833333333333333, 0.166666666666667, 0.111111111111111 ], [0, 0.0833333333333333, 0.0833333333333333, 0, 0, 0.0833333333333333, 0.111111111111111, 0.2, 0.1, 0.0833333333333333, 0.111111111111111, 0.0625, 0.0769230769230769, 0, 0.166666666666667, 0 ], [0.142857142857143, 0.0833333333333333, 0, 0.111111111111111, 0, 0, 0, 0.1, 0, 0.0833333333333333, 0, 0.0625, 0.0769230769230769, 0.166666666666667, 0.166666666666667, 0 ], [0.0714285714285714, 0.0833333333333333, 0.0833333333333333, 0, 0, 0.0833333333333333, 0, 0.1, 0.1, 0.0833333333333333, 0, 0.0625, 0.0769230769230769, 0, 0, 0.222222222222222 ], [0.0714285714285714, 0.0833333333333333, 0.0833333333333333, 0.111111111111111,0, 0, 0, 0, 0, 0.0833333333333333, 0, 0.0625, 0.0769230769230769, 0.0833333333333333, 0, 0 ], [0.0714285714285714, 0.0833333333333333, 0.0833333333333333, 0.111111111111111,0, 0.0833333333333333, 0, 0.1, 0, 0, 0, 0.125, 0.0769230769230769, 0.0833333333333333, 0, 0.111111111111111 ], [0.0714285714285714, 0.166666666666667, 0.0833333333333333, 0.111111111111111, 0,

-

-

-

-

-


255 / 404

0.0833333333333333, 0, 0.1, 0.1, 0, 0.111111111111111, 0, 0, 0.0833333333333333, 0, 0 ], [0.0714285714285714, 0, 0.0833333333333333, 0.111111111111111, 0.142857142857143, 0.0833333333333333, 0.111111111111111, 0.1, 0.1, 0.0833333333333333, 0, 0.0625, 0.0769230769230769, 0.0833333333333333, 0, 0.111111111111111 ], [0, 0, 0, 0, 0, 0, 0, 0, 0.2, 0.0833333333333333, 0.111111111111111, 0, 0.0769230769230769, 0, 0, 0 ], [0.0714285714285714, 0.0833333333333333, 0, 0.111111111111111, 0, 0.0833333333333333, 0.111111111111111, 0, 0, 0.0833333333333333, 0, 0.125, 0, 0, 0, 0.222222222222222 ], [0.142857142857143, 0.0833333333333333, 0.0833333333333333, 0.111111111111111, 0.142857142857143, 0.0833333333333333, 0.222222222222222, 0, 0, 0, 0, 0.0625, 0.0769230769230769, 0, 0, 0 ], [0.142857142857143, 0, 0.166666666666667, 0, 0.142857142857143, 0.0833333333333333, 0.111111111111111, 0.1, 0.1, 0.166666666666667, 0.111111111111111, 0.0625, 0.0769230769230769, 0.0833333333333333, 0, 0.111111111111111 ], [0.0714285714285714, 0, 0.0833333333333333, 0, 0.142857142857143, 0.0833333333333333, 0, 0.1, 0.1, 0.0833333333333333, 0.111111111111111, 0.0625, 0.153846153846154, 0.0833333333333333, 0, 0 ] ] CsapatNevE = [ "Videoton", "Ferencváros", "Paks", "Debreceni VSC", "Zalaegerszegi TE", "Kaposvári Rákóczi", "Lombard Pápa", "Kecskeméti TE", "Újpest", "Gy˝ ori 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 ˝ ori 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 < 0.000000000001: amig = False print "+++"

-


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

18.1.1.9. Kvíz megoldások:

Kérdések: 17.Feladat: Mennyi a ciklomatikus komplexitása az alábbi függvénynek? 11. 18.Feladat: nevezz meg egy-egy osztályt (teljes csomagnévvel min˝osített formában) az alábbi Java kiadásokból! Illetve egy-egy interfészt (ugyancsak teljes csomagnévvel min˝osí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ó” A:System.out.println("alma"); System.out.flush(); /*// System.out.println("körte"); System.out.flush(); */// System.out.println("dió"); System.out.flush(); B: System.out.println("1"); System.out.flush(); ///*/*/


257 / 404

System.out.println("1"); System.out.flush(); //*/*/ System.out.println("1"); System.out.flush();

20.Feladat: magyarázd meg a következ˝o ábrán vázolt helyzetet! A bal oldal az 1.5 el˝otti Java nyelvr˝ol szól, a jobb oldal pedig már az 1.5 utáni Java nyelvnek megfelel˝oen 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˝ot 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˝o program? Négyet String String String String String

s1="alma"; s2="al"; s3="ma"; s4="null"; 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"); }


258 / 404

27.Feladat:Feladat: GPL? Kezd˝odhet-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˝odnek a Java bájtkódok? 11001010111111101011101010111110 29.Feladat: A: Vidi 50, Etó 51, Fradi 55, Loki 60; B: Vidi 50, Etó 51, Fradi 55, Loki 60 30.Feladat: 3. Az 1.6 óta a SwingWorker része a standard Java API-nak, de az osztály megváltozott: construct() és finished() 18.1.1.10. YANonymous


259 / 404

18.1.1.11. PeldaServlet GlassFish

18.1.1.12. Sparse Table vs. StlMap

18.1.1.13. Sparse Table vs. VectorBasedSparseMap

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


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]);

-


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(){

261 / 404


return freq; } }

262 / 404


263 / 404

19. fejezet

Egyéb feladatok 19.1. Operációs rendszerekkel kapcsolatos alapveto˝ feladatok 19.1.1. A GNU/Linux kernellel kapcsolatos feladatok 19.1.1.1. Kernelfordítás

19.1.2. Telepítéssel és virtualizációval kapcsolatos feladatok 19.1.2.1. Dual-boot 19.1.2.2. MINIX virtualizálás

A feladat kidolgozását Kis Dávid készítette. MINIX3-at telepítettem, VitualBox-ban. Egész egyszer˝uen megoldható, és a célunknak tökéletesen megfelel. A "VM Lens" nev˝u programmal oldottam meg, linkeltem is: https://apps.ubuntu.com/cat/applications/unity-lens-vm/

19.1. á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.


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.

19.2. ábra. Virtuális MINIX indítása (vm2.png). Az els˝o 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_R3.2.1-972156d.iso. Innen tölthet˝o le: http://www.minix3.org/ Miután csatoltuk a iso-t, néhány lépés után válasszuk a Regular MINIX 3-at!

19.3. ábra. A rendszer betöltése lemezr˝ol (vm3.png). Kövessük a megjelen˝o instrukciókat: root felhasználói névvel belépve, majd a setup parancsot kiadva indul a telepítés. # minix log in: root . . .


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˝o lemezt máris a virtuális gép winchesterér˝ol 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˝odjé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). 19.1.2.3. OpenSolaris virtualizálás 19.1.2.4. BSD virtualizálás

19.2. Az információs-távolsággal kapcsolatos feladatok Az alábbi feladatok kizárják egymást.

19.2.1. Genomok összehasonlítása A feladat megoldását Deregi Diána készítette el. A megoldáshoz a http://progpater.blog.hu/2011/02/27/a_human_genom_projekt poszt útmutatásait követtem. A feladatban 16 él˝olé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˝ukb˝ol álló bemenetet alakítja át hexadecimális számokká úgy, hogy egyszerre két bet˝ut vizsgál meg. Minden páratlan bemenet˝u bet˝unek eltárolja az értékét (0-3), majd hozzáveszi az o˝ t követ˝o páros bemenet˝u bet˝u értékét (0-3), majd ezt a két számot átalakítja egy 0-15 közé es˝o számmá, amit kiír, mint eredményt. Miután készítettünk pár mintát a programmal az él˝olé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˝uk számát. #include <stdio.h> #include int main (void) { char hexa_jegyek[] = {’A’, ’B’, ’C’, ’D’, ’E’, ’F’}; int paratlan = 0, elso=0, masodik=0, i = 0, szamlalo=0;


while(((i=getchar()) != EOF)

&& (szamlalo<1000)) {

switch(i) { case ’T’: masodik break; case ’C’: masodik break; case ’A’: masodik break; case ’G’: masodik break; }

= 0;

= 1;

= 2;

= 3;

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

266 / 404


19.4. ábra. Genomok összehasonlítása

19.2.2. SZT tisztek gráfja

19.3. Design-al kapcsolatos feladatok 19.3.1. 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˝uleg. A font Sans mindkét esetben.

267 / 404


268 / 404

19.3.2. Az UDProg logoterv A logótervek ezeken a linkeken érhet˝oek 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˝ukészletként Arial Font Family-t és ASH bet˝utípust használtam.

19.4. Az UDProg logóterv A logóterv ezen a linken érhet˝oek el. ../source/logo/kesz.png A tervet Apró Anikó készítette el Inkscape 0.48 program segítségével. Bet˝ukészletként Comic Sansat használt a P bet˝u az egyedi bet˝utípusú.

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

19.5.1. Fo˝ forrásfájl source/halado/copy_constructor/copy_constructor.cpp #include #include #include #include

"DefaultCopy.h" "DisabledCopy.h" "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˝ o az egyenl˝ osé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˝ o 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


// objektum tömb tagjai is meg fognak változni! //*************************************************************************** // Módosítjuk az els˝ o 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˝ ol // másolatot készít. //*************************************************************************** // Kezdjük az 1. ellenszerrel. // Létrehozzuk a letiltott copy constructor-ral rendelkez˝ o 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;

269 / 404


270 / 404

deepC.printMembers(); // Most pedig másoljuk! DeepCopy deepC_copy(deepC); // A túlterhelt egyenl˝ osé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˝ orizü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(234.5368); 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; }

19.5.2. Alapértelmezett másoló konstruktoros osztály 19.5.2.1. 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


271 / 404

~DefaultCopy();

// destruktor

int getIM(); int* getIMAddress(); double getDM(); double* getDMAddress(); int* getAM();

// // // // //

void setIM(int); void setDM(double); void setAM(int*);

// setter az int taghoz // setter a double taghoz // setter a tömbhöz

void printMembers(); void printArray(int*, int);

// tag kiíró metódus // tomb kiíró metódus

void printDoubleLine();

// dupla vízszintes vonal metódus

private: int integerMember; double doubleMember; int *arrayMember; int arrayMemberSize; };

// // // //

getter getter getter getter getter

az int taghoz az int tag címéhez a double taghoz a double tag címéhez a tömbhoz

int tag double tag int tömb tag tömb tag mérete

#endif

19.5.2.2. Implementáció

source/halado/copy_constructor/src/DefaultCopy.cpp #include #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() {


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

272 / 404


273 / 404

// Dupla vízszintes vonal kiíró metódus void DefaultCopy::printDoubleLine() { std::cout << "======================================================" \ << std::endl; }

19.5.3. Letiltott másoló konstruktoros osztály 19.5.3.1. 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();

// alapértelmezett konstruktor // inicializáló konstruktor // destruktor


// // // // //




// 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&);

// // // // // // DisabledCopy& operator= (const DisabledCopy&); //


int tag double tag int tömb tag tömb tag mérete itt tiltjuk le a copy constructort és a = operátort is

}; #endif


source/halado/copy_constructor/src/DisabledCopy.cpp #include #include "DisabledCopy.h"

az int taghoz az int tag címéhez a double taghoz a double tag címéhez a tömbhoz


// 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; }

274 / 404


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; }

19.5.4. "Deep copy" konstruktoros osztály 19.5.4.1. 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&);

// // // // DeepCopy& operator= (const DeepCopy&); // ~DeepCopy(); //

alapértelmezett konstruktor inicializáló konstruktor copy konstruktor, ahol a deep copy lesz implementálva = operátort is túlterheljük destruktor



// // // // //

az int taghoz az int tag címehez a double taghoz a double tag címehez a tömbhöz


276 / 404




// tag kiíró metódus // tömb kiíró metódus


// dupla vízszintes vonal metódus

private: int integerMember; double doubleMember; int *arrayMember; int arrayMemberSize; };

// // // //

int tag double tag int tömb tag tömb tag mérete

#endif


source/halado/copy_constructor/src/DeepCopy.cpp #include #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˝ u for loop-pal átmásoljuk az elemeket for (int i = 0; i < arrayMemberSize; i++) {


arrayMember[i] = copied.arrayMember[i]; } } // Egyenl˝ oségjel operátor túlterhelése DeepCopy& DeepCopy::operator= (const DeepCopy& copied) { // ön-értékadás ellen˝ orzé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˝ u 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)

277 / 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; }

278 / 404


279 / 404

20. fejezet

Tankönyvi feladatok kidolgozása 20.1. A Stroustrup könyv példái 20.1.1. 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˝ott? A válasz: A (*2.5) jelzés egy feladat leírása el˝ott, 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.

20.1.2. X.2[4] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.2.4 fájlba helyeztem el. A kérdés: Mik a legf˝obb 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.

20.1.3. 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˝obb komponensei. A válasz: A C++ standard library osztályok és függvények gy˝ujtemé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˝ol amelyek .h-ra végz˝odnek. Azok a feature-ök amelyeket innen declarálunk az std névteret használják.

20.1.4. 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˝u fájlokból tárgykódot állít el˝o. Linker: több tárgykódból állít el˝o egy futtatható fájlt.


280 / 404

20.1.5. X.3[3] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.3.3.cpp forrásállományba helyeztem el. #include 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

20.1.6. 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++

20.1.7. X.3[5] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.3.5.cpp forrásállományba helyeztem el. #include using namespace std; int main() { bool a = true; char b = ’b’; int c = 3; double d = 3.14; string e = "Programozzunk."; cout cout cout cout cout

<< << << << <<

a b c d e

<< << << << <<

endl; endl; endl; endl; endl;

return 0; }

A program kiírja a megadott típusú változókat. A forrást fordítom, majd futtatom.


281 / 404

[../udprog-code/source/tankonyvi/STROUSTRUP]$ g++ X.3.5.cpp -o kiir [../udprog-code/source/tankonyvi/STROUSTRUP]$ ./kiir

20.1.8. X.3[6] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.3.6.cpp forrásállományba helyeztem el. #include using namespace std; int main() { bool a; char b; int c; double d; string e; cin cin cin cin cin

>> >> >> >> >>

a; b; c; d; 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

20.1.9. 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˝o 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˝ukíti az alaphalmazt.

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


282 / 404

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

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

20.1.13. X.5[5] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.5.5.cpp forrásállományba helyeztem el. #include 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 o˝ ket a képerny˝ore. 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

20.1.14. X.5[6] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.5.6.cpp forrásállományba helyeztem el. #include using namespace std; class person { public: string name; int age;


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 o˝ ket a képerny˝ore 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

20.1.15. X.5[7] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.5.7.cpp forrásállományba helyeztem el. #include #include #include using namespace std; int main() { std::vector vec; int int int int

Number1 Number2 Number3 Number4

= = = =

5; 9; -1; 200;


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˝o 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

20.1.16. X.5[7]b feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.5.7b.cpp forrásállományba helyeztem el. #include #include #include using namespace std; int main() { std::vector vec; int int int int int

Number1 Number2 Number3 Number4 Number5

= 5; = 9; = -1; = 200; = 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());


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˝o 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

20.1.17. X.5[8] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.5.8.cpp forrásállományba helyeztem el. #include #include #include using namespace std; int main() { std::vector<string> vec; string string string string string

Item1 Item2 Item3 Item4 Item5

= = = = =

"Kanto"; "Plato"; "Aristotle"; "Kierkegard"; "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˝o sorrendbe rendezi azt, majd ismét kiírja a rendezett elemeket. A forrást fordítom, majd futtatom.


286 / 404

[../udprog-code/source/tankonyvi/STROUSTRUP]$ g++ X.5.8.cpp -o vectors [../udprog-code/source/tankonyvi/STROUSTRUP]$ ./vectors

20.1.18. X.5[9] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.5.9.cpp forrásállományba helyeztem el. #include #include 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

20.1.19. X.5[10] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.5.10.cpp forrásállományba helyeztem el. #include #include 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;


cout << data << " "; } cout << "\n"; } infile.close(); return 0; }

A program megnyit egy fájlt olvasás módban, beolvas bel˝ole, 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

20.1.20. X.6[2] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.6.2.cpp forrásállományba helyeztem el. #include #include 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; }

20.1.21. X.7[2] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.7.2.cpp forrásállományba helyeztem el. #include #include using namespace std; int main() { if( numeric_limits::is_signed == true ) cout << "signed" << endl; else cout << "unsigned" << endl; return 0; }

287 / 404


288 / 404

A program kiírja a signed szót, ha a char típus az adott implementáción el˝ojeles, és az unsigned-et ha el˝ojel 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

20.1.22. X.7[8] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.7.8.cpp forrásállományba helyeztem el. #include #include // 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::min() << "\n"; std::cout << "A BOOL típus maximális értéke a rendszeren: " << std ::numeric_limits::max() << "\n"; std::cout << "A CHAR típus minimális értéke a rendszeren: " << std ::numeric_limits::min() << "\n"; std::cout << "A CHAR típus maximális értéke a rendszeren: " << std ::numeric_limits::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::min() << "\n"; std::cout << "Az INT típus maximális értéke a rendszeren: " << std ::numeric_limits::max() << "\n"; std::cout << "A LONG típus minimális értéke a rendszeren: " << std ::numeric_limits::min() << "\n"; std::cout << "A LONG típus maximális értéke a rendszeren: " << std ::numeric_limits::max() << "\n"; std::cout << "A LONG LONG típus minimális értéke a rendszeren: " << std::numeric_limits::min() << "\n"; std::cout << "A LONG LONG típus maximális értéke a rendszeren: " << std::numeric_limits::max() << "\n"; std::cout << "A FLOAT típus minimális értéke a rendszeren: " << std ::numeric_limits::min() << "\n"; std::cout << "A FLOAT típus maximális értéke a rendszeren: " << std ::numeric_limits::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::min() << "\n"; std::cout << "A LONG DOUBLE típus maximális értéke a rendszeren: " << std::numeric_limits::max() << "\n"; std::cout << "Az UNSIGNED típus minimális értéke a rendszeren: " << std::numeric_limits::min() << "\n"; std::cout << "Az UNSIGNED típus maximális értéke a rendszeren: " << std::numeric_limits::max() << "\n";

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-


std::cout " << std::cout " <<

289 / 404

<< "Az UNSIGNED LONG típus minimális értéke a rendszeren: std::numeric_limits::min() << "\n"; << "Az UNSIGNED LONG típus maximális értéke a rendszeren: std::numeric_limits::max() << "\n";

-

-

return 0; }

A program kiírja a különböz˝o 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

20.1.23. X.7[9] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.7.9.cpp forrásállományba helyeztem el. #include 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˝o 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

20.1.24. X.7[13] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.7.3.cpp forrásállományba helyeztem el. #include

-

-


290 / 404

int main() { int a=4, b=5, c=9, d=17, e=12; while (1) { std::cout<
A program változókat használ, nem tömböt vagy vektort.

20.1.25. X.8[4] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.8.4.cpp forrásállományba helyeztem el. #include 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

20.1.26. X.8[5] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.8.5.cpp forrásállományba helyeztem el. #include using namespace std; int main() { int buf[100];


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

20.1.27. X.8[7] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.8.7.cpp forrásállományba helyeztem el. #include #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 = cout << "a = " swap(&a, &b); cout << "a = " swap2(a, b); cout << "a = " return 0; }

5; << a << ", b = " << b << endl; << a << ", b = " << b << endl; << a << ", b = " << b << endl;


292 / 404

20.1.28. X.8[9] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.8.9.cpp forrásállományba helyeztem el. #include 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˝ore 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˝ott 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

20.1.29. X.8[11] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.8.11.cpp forrásállományba helyeztem el. #include #include <string> #include


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˝urte minden szó többszöri el˝ofordulá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 o˝ ket. A forrást fordítom, majd futtatom. [../udprog-code/source/tankonyvi/STROUSTRUP]$ g++ X.8.11.cpp -o quit


294 / 404

[../udprog-code/source/tankonyvi/STROUSTRUP]$ ./quit

20.1.30. X.9[1] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.9.1.cpp forrásállományba helyeztem el. #include 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˝ o 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˝o 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˝onél külön-külön négybájtosakba így 4 a különbség.

20.1.31. X.9[2] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.9.2.cpp forrásállományba helyeztem el. #include #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; }

-


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; }

20.1.32. X.10[1] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.10.1.cpp forrásállományba helyeztem el. #include #include <string> #include int main() { int max_length = 100; std::vector 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˝ U WHILE CIKLUS int i = 0; while( i != max_length ) { if( input_line[i] == ’?’ ) quest_count++; i++; }

// A FOR CIKLUS MEGOLDÁSA POINTERREL

-


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

20.1.33. X.11[10] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.11.10.cpp forrásállományba helyeztem el. #include #include 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;

-


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.11.10.cpp -o rev [../udprog-code/source/tankonyvi/STROUSTRUP]$ ./rev

20.1.34. X.13[9] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.13.9.cpp forrásállományba helyeztem el. #include #define MERET 5 #define MERETMAX 10 using namespace std; void kiir(double w[MERETMAX][MERETMAX], int n) { int i, j; for (i=0; i

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
-


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.

20.1.35. X.13[14] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.13.14.cpp forrásállományba helyeztem el. /* A feladat: 1. Hogyan használjuk a nagybet˝ uket a nevekben? A nagybet˝ uket 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.

-


300 / 404

Például : shortName, variableName, floatNumber, stb...

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

-

3. 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˝ os 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.

20.1.36. X.13[15] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.13.15.cpp forrásállományba helyeztem el. #include using namespace std; // ez így helytelen // #define PI = 3.141593; // helyesen így kell használni #define PI 3.141593 // ez így helytelen // #define MAX(a,b) a>b?a:b // helyesen zárójelezve már m˝ ukö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 ˝ oá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˝o makrónál felesleges karakterek voltak a hiba okozói, a második makró nem volt megfelel˝oen bezárójelezve, a harmadik meg egyáltalán nem m˝uködhet mivel az el˝ofeldolgozó processzor mindig rekurzívan hívná a fac makrót és így nem az helyettesít˝odne 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.


301 / 404

[../udprog-code/source/tankonyvi/STROUSTRUP]$ g++ X.13.15.cpp -o makro [../udprog-code/source/tankonyvi/STROUSTRUP]$ ./makro

20.1.37. X.13[21] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.13.21.cpp forrásállományba helyeztem el. #include 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;

-

-

-


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;

-

-

-


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: "<
-

A program el˝oször a beírt dátumhoz hozzárendel egy napszer˝u értéket amely mod 7 miatt 7 féle lehet, ez a hét napjainak felel meg. A program másodszor a következ˝o hétf˝ot számítja ki (hétf˝o esetén nem megy tovább).


A program harmadszor megpróbálja a megadott dátum utáni hétf˝ot növelni 1 év 1 hónap 1 nappal.

20.1.38. X.17[4] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.17.4.cpp forrásállományba helyeztem el. #include 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>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)

304 / 404


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˝ulieket is.

20.1.39. X.17[7] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.17.7.cpp forrásállományba helyeztem el. #include #include #include 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 v1 (a, a+6); vector 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 intersection (vector v1, vector v2 ) { int i=0, j=0; vector in; sort (v1.begin(), v1.end(), myobject); sort (v2.begin(), v2.end(), myobject); for (i=0; i

if (v1[i]==v2[j]) { in.push_back(v1[i]); goto next; } } next:; } return in; }; vector unio (vector v1, vector v2 ) { int i=0, j=0; vector un; sort (v1.begin(), v1.end(), myobject); sort (v2.begin(), v2.end(), myobject); while(iv2[j]) { un.push_back(v2[j]); j++; continue; } if (v1[i] symdif (vector v1, vector v2 ) { int i=0, j=0; vector sd; sort (v1.begin(), v1.end(), myobject); sort (v2.begin(), v2.end(), myobject); while(i
306 / 404


i++; j++; continue; } if (v1[i]>v2[j]) { sd.push_back(v2[j]); j++; continue; } if (v1[i]
A program két el˝ore megadott tömbnek kiírja a metszetét, unióját és szimmetrikus differenciáját.

307 / 404


20.1.40. X.17[8] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.17.8.cpp forrásállományba helyeztem el. #include #include #include 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 v1 (a, a+6); vector 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
308 / 404


cout << endl; } void intersection (vector v1, vector v2 ) { int i=0, j=0; sort (v1.begin(), v1.end(), myobject); sort (v2.begin(), v2.end(), myobject); for (i=0; i v1, vector v2 ) { int i=0, j=0; sort (v1.begin(), v1.end(), myobject); sort (v2.begin(), v2.end(), myobject); while(iv2[j]) { addend(v2[j]); j++; continue; } if (v1[i]
309 / 404


void symdif (vector v1, vector v2 ) { int i=0, j=0; sort (v1.begin(), v1.end(), myobject); sort (v2.begin(), v2.end(), myobject); while(iv2[j]) { addend(v2[j]); j++; continue; } if (v1[i]val<<" "; felt=felt->next; } cout<<endl; head=NULL; x.unio(v1, v2); cout<<"Unió: "; felt=head; while (felt!=NULL) {

310 / 404


311 / 404

cout<val<<" "; felt=felt->next; } cout<<endl; head=NULL; x.symdif(v1, v2); cout<<"Szimmetrikus differencia: "; felt=head; while (felt!=NULL) { cout<val<<" "; felt=felt->next; } cout<<endl; }

A program két el˝ore megadott tömbnek kiírja a metszetét, unióját és szimmetrikus differenciáját és ezt láncolt listával teszi meg.

20.1.41. X.17[13] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.17.13.cpp forrásállományba helyeztem el. #include 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˝uen kihasználja egy globális változó konstruktorát és destruktorát.

20.1.42. X.19[4] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.19.4.cpp forrásállományba helyeztem el. #include using namespace std; class Int {


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 "<9) { t[c]=a-(a/10)*10; a=a/10; c++; } t[c]=a; c++; l=c; } ~Int() { //cout<<"Dest "; //print(); //cout<<"with "<
312 / 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<<">>>"<=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<>>"<=10) { t[i]-=10; t[i+1]+=1; } } if (t[l]!=0) l++; temp.dec(); }

313 / 404


//print(); //cout<<"Length: "<
314 / 404


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.

20.1.43. X.21[1] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.21.1.cpp forrásállományba helyeztem el. #include 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.

20.1.44. X.32[1] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.32.1.cpp forrásállományba helyeztem el.


316 / 404

#include #include #include using namespace std; int main() { char alpha[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" ; std::vector 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˝uit sorrendben, majd kiírja o˝ 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

20.1.45. X.32[2] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.32.2.cpp forrásállományba helyeztem el. #include #include #include #include

<string>

using namespace std; template void vektor_kiir( const vector& 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()


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


<string>

using namespace std; template void vektor_kiir( const vector& 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);


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˝o bet˝ujé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


<string>

using namespace std; template void vektor_kiir( const vector& 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];


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˝uvel kezd˝odik, 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


<string>

using namespace std; template void vektor_kiir( const vector& 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++ )

-


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˝u 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


<string>

using namespace std; template void vektor_kiir( const vector& 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;

-


321 / 404

vector<string> nemSzeretem = { "ananász", "mangó", "narancs", "sz˝ ol ˝ o" };

-

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˝u 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

20.1.50. X.37[1] feladat A megoldást ../source/tankonyvi/STROUSTRUP/X.37.1.cpp forrásállományba helyeztem el. #include #include <string> #include #include using namespace std; string conc(string a, string b) { string res = ""; res+=a; res+="."; res+=b; return res; }

-


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˝ubb mivel ott a += m˝uvelet definiálva van, a C stílusúnál meg nekünk kell ezt megírni.


323 / 404

III. rész

Laborkártyák


324 / 404

21. fejezet

Laborkártyák Minden labor a kötelez˝o olvasmány elolvasásának ellen˝orzésével kezd˝odik, ez a szúrópróbaszer˝u (vagy a laborvezet˝o 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˝orzése, ennek célja, hogy a hallgató önállóan reprodukálja a példákat, az ellen˝orzés tárgya magának a reprodukciónak az ellen˝orzé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 email a kód kapcsán - feladatja válogatja és megint csak a laborvezet˝o hatásköre, hogy mely megközelítést tartja éppen a leghatékonyabbnak.

21.1. Bevezeto˝ laborkártyák 21.1.1. A parancssori interfész (CLI) alapveto˝ használata 21.1.1.1. 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ó. 15.1.1.1

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



325 / 404

21.1.1.3. Vektorizálás

Mi az a parancssori opció amelyet alkalmazva a ../source/labor/exor/t.c (Exor-os) tör˝o példa fordítására, az alábbi látványos sebességnövekedés tapasztalhatunk? A futási id˝o egyszer b˝o másfél óra: [nbatfai@desteny exor]$ time ./t teszt.txt real 109m31.178s user 109m16.488s sys 0m0.002s

a „tuning” után pedig csak b˝o negyedóra: [nbatfai@desteny exor]$ time ./t teszt.txt real 16m20.972s user 16m18.721s sys 0m0.003s

21.1.1.4. A kapcsolatszerkeszto˝ program

Miért nem fordul le az els˝o 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?


21.1.2. Az alapveto˝ C és C++ nyelvi konstrukciók használata 21.1.2.1. Nevek bevezetése a programba

Értelmezd a következ˝o 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};


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˝o 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++11 - 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ó


327 / 404

˝ 21.1.2.2. for eloszö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˝uen próbáld ki!

Megoldások és megjegyzések Laborkártyához ../source/labor/kartyak/ciklus.cpp Norbert, tutor: Bereczki László

eléréssel kidolgozás feltöltve.

Kovács-Ferenc

21.1.2.3. for másodszor

Mit csinál a következ˝o kódcsipet ciklusa? int a[] = {1,2,3,4,5,6,7,8,9,10}; std::vector 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ó

21.1.2.4. for harmadszor

Mit csinál a következ˝o kódcsipet ciklusa? int a[] = {1,2,3,4,5,6,7,8,9,10}; std::vector 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ó ˝ 21.1.2.5. if eloszö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);


328 / 404

if(signal(SIGINT, SIG_IGN) != SIG_IGN) signal(SIGINT, utolso_tennivalo);

Err˝ol 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 élo˝ példát! ˝ Mutass egy élo˝ példát a jelkezelésre forrásban, ha egyelore nincs más ötleted, akkor például innen indulva: http://www.inf.unideb.hu/~nbatfai/konyvek/PROP/prop.book.xml.html#id489286.

21.1.2.6. 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˝obbi esetében b-t a logikai vizsgálat eredményével fogja maszkolni, míg az utóbbinál a maszkolást követ˝oen 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)

21.1.2.7. while

Mit csinál a következ˝o utasítás? while(*p++ = *q++);

Egyszer˝uen 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ó

21.1.2.8. const

Mi a const kulcsszó jelentése man 3 strcpy szinopszisában?



21.1.2.9. char *

Mit mondasz erre C-ben és mit C++-ban? char *p = "Mit mondasz erre C-ben, mit C++-ban?";


21.1.2.10. 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?

21.1.3. A szabad tár kezelése 21.1.3.1. 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)

21.1. ábra. Dinamikus tömb a tárban.

329 / 404


21.1.4. C++ alapfogalmak 21.1.4.1. Másoló konstruktor és másoló értékadás

A következ˝o ../source/labor/kartyak/Int1/int.h #ifndef INT__H #define INT__H #include class Int { public: Int (int n = 0):ertek (n) { std::cout << "-- Int ctor << ertek << " " << this } ~Int () { std::cout << "-- Int dtor << ertek << " " << this };

" << " " << &ertek << std::endl;

" << " " << &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˝o programokban? A nyomkövet˝o kimenetek alapján válaszolj!

330 / 404


21.1.4.1.1. ../source/labor/kartyak/Int1/main.cpp

#include "int.h" int main () { Int a, b (1), c{2}; 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; }

21.1.4.1.2. ../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; }


#include "int.h" int kicsontoz(Int n) { return n.getVal(); } int main () { Int a = 42; std::cout << kicsontoz(a) << std::endl;

331 / 404


return 0; }

21.1.4.1.3.1. 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! 21.1.4.1.4. ../source/labor/kartyak/Int1/main5.cpp

#include "int.h" #include int main () { Int a = 42; std::vector v; v.push_back(a); std::cout << a << std::endl; return 0; }

21.1.4.2. Másoló konstruktor és másoló értékadás másodszor

A következ˝o ../source/labor/kartyak/Int2/int.h #ifndef INT__H #define INT__H #include 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);

332 / 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˝o programokban? A nyomkövet˝o kimenetek alapján válaszolj! 21.1.4.2.1. ../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;

333 / 404


334 / 404

return 0; }

21.1.4.2.1.1. 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 0x1412010 0 -- Int masolo ctor 0 0x7fffcb7f11a0 0x1412030 0 0 -- Int dtor 0 0x7fffcb7f11a0 0x1412010 -- Int dtor 0 0x7fffcb7f11b0 0x1412010 *** Error in ‘./main’: double free or corruption (fasttop): 0x0000000001412010 *** ======= Backtrace: ========= /lib64/libc.so.6[0x329807d0b8] ./main[0x400cee] ./main[0x400b3c] /lib64/libc.so.6(__libc_start_main+0xf5)[0x3298021b45] ./main[0x4009c9] ======= Memory map: ======== 00400000-00402000 r-xp 00000000 fd:02 12976515 /home/nbatfai/ UDPROG/udprog-code/source/labor/kartyak/Int2/main 00601000-00602000 r--p 00001000 fd:02 12976515 /home/nbatfai/ UDPROG/udprog-code/source/labor/kartyak/Int2/main 00602000-00603000 rw-p 00002000 fd:02 12976515 /home/nbatfai/ UDPROG/udprog-code/source/labor/kartyak/Int2/main 01412000-01433000 rw-p 00000000 00:00 0 [heap] 3297c00000-3297c21000 r-xp 00000000 fd:00 3014850 /usr/lib64/ld -2.17.so 3297e20000-3297e21000 r--p 00020000 fd:00 3014850 /usr/lib64/ld -2.17.so 3297e21000-3297e22000 rw-p 00021000 fd:00 3014850 /usr/lib64/ld -2.17.so 3297e22000-3297e23000 rw-p 00000000 00:00 0 3298000000-32981b6000 r-xp 00000000 fd:00 3014917 /usr/lib64/libc -2.17.so 32981b6000-32983b6000 ---p 001b6000 fd:00 3014917 /usr/lib64/libc -2.17.so 32983b6000-32983ba000 r--p 001b6000 fd:00 3014917 /usr/lib64/libc -2.17.so 32983ba000-32983bc000 rw-p 001ba000 fd:00 3014917 /usr/lib64/libc -2.17.so 32983bc000-32983c1000 rw-p 00000000 00:00 0 3298c00000-3298d01000 r-xp 00000000 fd:00 3015288 /usr/lib64/libm -2.17.so 3298d01000-3298f00000 ---p 00101000 fd:00 3015288 /usr/lib64/libm -2.17.so 3298f00000-3298f01000 r--p 00100000 fd:00 3015288 /usr/lib64/libm -2.17.so 3298f01000-3298f02000 rw-p 00101000 fd:00 3015288 /usr/lib64/libm -2.17.so 3299800000-3299815000 r-xp 00000000 fd:00 3019673 /usr/lib64/ libgcc_s-4.8.2-20131212.so.1 3299815000-3299a14000 ---p 00015000 fd:00 3019673 /usr/lib64/ libgcc_s-4.8.2-20131212.so.1 3299a14000-3299a15000 r--p 00014000 fd:00 3019673 /usr/lib64/ libgcc_s-4.8.2-20131212.so.1

-

-

-

-

-

-

-

-

-

-

-


3299a15000-3299a16000 rw-p 00015000 fd:00 3019673 libgcc_s-4.8.2-20131212.so.1 329c000000-329c0e6000 r-xp 00000000 fd:00 3024419 ++.so.6.0.19 329c0e6000-329c2e5000 ---p 000e6000 fd:00 3024419 ++.so.6.0.19 329c2e5000-329c2ed000 r--p 000e5000 fd:00 3024419 ++.so.6.0.19 329c2ed000-329c2ef000 rw-p 000ed000 fd:00 3024419 ++.so.6.0.19 329c2ef000-329c304000 rw-p 00000000 00:00 0 7fc686826000-7fc68682b000 rw-p 00000000 00:00 0 7fc686852000-7fc686855000 rw-p 00000000 00:00 0 7fffcb7d2000-7fffcb7f4000 rw-p 00000000 00:00 0 7fffcb7fe000-7fffcb800000 r-xp 00000000 00:00 0 ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0 Aborted (core dumped)


#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; }

21.1.4.3. Mozgató konstruktor és mozgató értékadás

A következ˝o ../source/labor/kartyak/Int4/int.h #ifndef INT__H #define INT__H #include #include 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;

335 / 404

/usr/lib64/

-

/usr/lib64/libstdc

-

/usr/lib64/libstdc

-

/usr/lib64/libstdc

-

/usr/lib64/libstdc

-

[stack] [vdso] [vsyscall]


} 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) {

336 / 404


os << * (n.ertek); return os; }

mellett mik fognak lefutni a következ˝o programokban? A nyomkövet˝o kimenetek alapján válaszolj! 21.1.4.3.1. ../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; }

21.1.5. Rule of Five A következ˝o ../source/labor/kartyak/Int5/int.h #ifndef INT__H #define INT__H #include #include 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; }

337 / 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

338 / 404


339 / 404

os << "n.ertek->NULL"; return os; }

mellett mik fognak lefutni a következ˝o programokban? A nyomkövet˝o kimenetek alapján válaszolj! Próbáld ki a kódban kommentezett két kérdést is! 21.1.5.1. ../source/labor/kartyak/Int5/main.cpp

#include "int.h" #include 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 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;


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; }

340 / 404


341 / 404

22. 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˝oségre, pl. nyelvi kérdésekben belinkelve a kapcsolódó C++11-es draft megfelel˝o 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˝oadások végér˝ol átenni a laborkártyákat is, azaz nemcsak a kidolgozást pontoznám, hanem az átvételüket is az el˝oadások végér˝ol; persze ha itt van valami kétség, hogy már pl. deprecated, vagy milyen f˝ocím alá kéne tenni az adott kártyát akkor az megér egy beszélgetést a fórumokon.


342 / 404

22.1. Bevezeto˝ laborkártyák 22.1.1. A parancssori interfész (CLI) alapveto˝ használata 22.1.1.1. 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 ˝ szekció megjelenítésre kerül. Bovebben: ˝ kiprintelni. Ha nem adunk meg számot, default az összes(elérheto) 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 8 3 2 3posix 3pm 3perl 5 4 9 6 7" 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 2 3 4 5 6 7 8 9

Executable programs or shell commands System calls (functions provided by the kernel) Library calls (functions within program libraries) Special files (usually found in /dev) File formats and conventions eg /etc/passwd Games Miscellaneous (including macro packages and conventions), e.g. man(7), groff(7) System administration commands (usually only for root) Kernel routines [Non standard]

Készítette: Kovács-Ferenc Norbert, tutor: Bereczki László

22.1.1.2. 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ó


343 / 404

22.1.1.3. Vektorizálás 22.1.1.4. A kapcsolatszerkeszto˝ 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 ˝ ˝ történelmi és hardveres indokok miatt, mégsem implicit kerül linkelésre, mint pl. a libc. Miután kézileg minosíthet o, ˝ explicit módon linkeltük, az ldd függoség megjeleníto˝ 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ó

22.1.2. Az alapveto˝ C és C++ nyelvi konstrukciók használata 22.1.2.1. Nevek bevezetése a programba ˝ 22.1.2.2. for eloszö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ó

22.1.2.3. for másodszor



344 / 404

22.1.2.4. for harmadszor


˝ 22.1.2.5. if eloször 22.1.2.6. if másodszor

Az el˝obbi esetében b-t a logikai vizsgálat eredményével fogja maszkolni, míg az utóbbinál a maszkolást követ˝oen 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)

22.1.2.7. 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ó

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

Linux Programmer’s 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.

-


345 / 404

Megoldások és megjegyzések Laborkártyát kidolgozta Kovács-Ferenc Norbert, tutor: Bereczki László.

22.1.2.9. char *

C-ben a m˝uködése egyértelm˝u. 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˝oen 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*’ [-Wwritestrings] char *p = "alma";

-

Ez érthet˝o, 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˝u 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<
Megoldások és megjegyzések Laborkártyát kidolgozta Kovács-Ferenc Norbert, tutor: Bereczki László.

22.1.2.10. Paraméterátadás

22.1.3. A szabad tár kezelése 22.1.3.1. char **


346 / 404

IV. rész

Évkönyv


347 / 404

23. fejezet

A 2013/14 tanév 23.1. A tavaszi szemeszter, avagy a prog1 Ebben a fejezetben magunkat mutatjuk be, ismerjük meg. Els˝o lépésként, önbevallási alapon mindenkinek be kell sorolnia magát a következ˝o kategóriákba1 , 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˝odé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˝o é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.

23.1.1. Az évfolyam legfontosabb hallgatói - tutor rendszer Kik az évfolyam kulcshallgatói? A következ˝o 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˝oszakban 2 hetenként különböz˝o 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˝ol! (15 pont a készít˝onek és 10, 9, 8, ..., 1 pont sorrendben az els˝o tíznek az eredménylistáról) 23.1.1.1. Az évfolyam legfontosabb hallgatói - feladatok megoldása

Ismételd meg az el˝oz˝o 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. 23.1.1.2. Az évfolyam legfontosabb hallgatói - skillek

Ismételd meg az el˝oz˝o mérést, de most a linkeket úgy értelmezd, hogy a bio-kból azt sz˝urd ki. ki-mit szeretne megismerni és kinek-miben van gyakorlata. A linkeket értelmezd úgy, hogy A személyb˝ol megy át a B-hez, ha az A szeretne olyat megismerni, amelyben a B-nek van gyakorlata. 23.1.1.3. 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˝o bio-k alapján! (10 pont) 1

A név mellett mindig tüntessük fel a pontszámot!


23.1.2. Önbevallások és rövid bio-k

23.1. ábra. Pillanatkép a 10. el˝oadásról

23.2. ábra. Pillanatkép a 11. el˝oadásról

348 / 404


349 / 404

23.3. ábra. Pillanatkép a 12. el˝oadásról 23.1.2.1. Hallgatók 23.1.2.1.1. Kiemelkedo˝

23.1.2.1.2. Haladó

1. Busák Zoltán, 2800 pont

23.4. ábra. Nyíregyházán születtem 1994.02.20-á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


350 / 404

23.5. ábra. Budapesten születtem 1992.07.21-é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˝o. 3. Gálffy Tamás, 96 pont

23.6. ábra. soon... Nagykanizsán született 1995.03.03-án, majd rá pár évre költözött Felvidékre. Ott tanult magyar tannyelv˝u iskolákban ( igen, vannak ), végül a Vámbéry Ármin Magyar Tannyelv˝u Nyolcosztályos Gimnáziumban érettségizett. A programozás els˝o sorban a játékok miatt kezdett el érdekelni, majd egy id˝o után megtetszett az a ( több-kevesebb sikerrel ) ismétl˝od˝o 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˝oké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˝u 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)

23.7. á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˝odni, majd megszerettem, így a jöv˝oben szeretném b˝ovíteni és elmélyíteni


351 / 404

a grafikus motorok programozásához szükséges tudásom. Az egyetemi éveimt˝ol 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)

23.8. á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˝oször össze és 15 évesen a C++ nyelvel. Gimnáziumban nem tanítottak nekem programozást csak saját er˝ob˝ol tanultam. F˝oleg a valós idej˝u grafika iránt érdekl˝odöm és a párhuzamos rendszerek m˝uködése köti le az érdekl˝odésem. Tutoriáltam: Csermely Attila. 23.1.2.1.3. Közepes

6. Bereczki László, 2100 pont

23.9. á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˝u 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˝u programozási feladatot a jöv˝ore nézve. Els˝osorban 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)


352 / 404

23.10. á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

23.11. ábra. 2004-ben érettségiztem a debreceni Beregszászi Pál Szakközépiskolában, majd 2 év múlva számítástechnikai m˝uszerész szakmával indultam neki a nagybet˝us életnek. El˝oször szabadúszó, majd alkalmazott flash fejleszt˝oként dolgoztam. Kés˝obb az informatika sok területén autodidakta módon b˝ovítettem tudásomat. Érdekl˝odé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)

23.12. á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˝om egy részét mobilalkalmazások fejlesztésével töltöm, illetve az egyetem mellett iOS fejleszt˝oké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 )


353 / 404

23.13. á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˝odésem, kés˝obb 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˝ott kicsit megismerkedtem az OpenGL-lel, ami meg is tetszett akkor, és a jöv˝oben is szeretnék foglalkozni vele komolyabban. Most második félévben, az egyik feladat során felkeltette az érdekl˝odé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˝ot 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)

23.14. ábra. Debrecenben, az Ady Endre Gimnáziumban tanultam. A programozásban és számítástechnikában még specifikus érdekl˝odé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

23.15. ábra. Nyíregyházán születtem 1991.07.20-án. A Váci Mihály Gimnáziumban végeztem tanulmányaimat Tiszavasváriban, ahol középszint˝u 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)


354 / 404

23.16. ábra. A középiskolai tanulmányaimat a debreceni Brassai Sámuel Gimnáziumban végeztem. Szabadid˝om egy részét új programozási ismeretek elsajátításával töltöm, illetve az egyetem mellett Web fejleszt˝oként dolgozom. 14. Nagy Sándor (178 pont)

23.17. ábra. Hajdúnánáson születtem, a helyi gimnáziumban érettségiztem. Egy web-programozó fels˝ofokú szakképzésb˝ol a munkaer˝opiacra lépve céges portálok építésével és fejlesztésével foglalkoztam, de nem találtam meg benne a kell˝o szakmai kihívást, ezért abban a reményben, hogy a fels˝ooktatá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

23.18. ábra. Hajdúböszörményben születtem, Hajdúnánáson tanultam a K˝orösi Csoma Sándor Gimnáziumban. Jó algoritmizálási rutinnal rendelkezem, az egyetemi éveim alatt, a meglév˝o 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


355 / 404

23.19. ábra. Nagyváradon születtem, 1994. 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˝u 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˝o céget vezethessek. Ha a cég valaha nagy siker˝u 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˝ok szabadságát, m˝uvészi kifejez˝o képességüket. Tutoriáltam és tutorom még nem volt. 17. Fenesi Gábor

23.20. ábra. Miskolcon születtem 1994.február 3.-án. Tutorom: Fülöp Sándor 18. Balkus Gerg˝o

23.21. ábra. Debrecenben születtem 1993. 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˝u 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)


356 / 404

23.22. ábra. Mez˝otúron születtem, informatika szakra jártam. Otthon magam tanultam C/C++. Eddig játékemulátorokkal foglalkoztam. A jöv˝oben szeretném a C++ alaptudásom tovább b˝ovíteni. Tutoriáltaim: Tamics Ádám, Eszenyi Gábor, Birizdó Kristóf. 23.1.2.1.4. Kezdo˝

20. Abai Richárd, 245 pont

23.23. ábra. Debrecenben születtem, Hajdúböszörményben élek. A Veress Ferenc Szakképz˝o 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˝o legyek. Különösképpen az Android fejlesztés érdekel. Engem tutorált: Kistamás Dávid, Sz˝ocs Gábor. Én tutoráltam: Veress Ármin, Balogh János Csaba. 21. Akai József Zsolt , 1390.8 pont

23.24. ábra. Debrecenben születtem, a Debreceni Református Kollégium Gimnáziumába jártam, informatika szakon végeztem. Informatikából emelt szint˝u érettségit tettem. Érdekl˝odé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˝osorban 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.


357 / 404

22. Török Antal (273 pont)

23.25. ábra. Tutor rendszerben Sipos Ferenc a tutorom 23. Apró Anikó (54 pont)

23.26. á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˝okészít˝o tagozaton Programozásban nem vagyok gyakorlott, azonban a célom az, hogy minél magasabb szinten megtanuljak programozni és kés˝obb ezt a tudást kamatoztatni szeretném. A tutor-rendszerben még nem vettem részt 24. Ács Raymund (607 pont)

23.27. ábra. Nyíregyházán születtem 1994.01.03-á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˝olek 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˝omet, mint programozó/szerver adminisztrátor. Tutorjaim Gálffy Tamás és Bereczki László. 25. Badó Gergely József (142 pont)


358 / 404

23.28. á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˝onek vallom magam, célom pedig tovább fejleszteni képességeimet. Az els˝o nyelv amit kissé komolyabban megismertem a C programozási nyelv. A tutor rendszerben ezidáig nem vettem részt, a felmerül˝o kérdéseket a binomommal tárgyaltuk. 26. Pajkossy Ottó (105 pont)

23.29. ábra. 27. Bak Balázs (291 pont)

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

23.31. ábra. 1993-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.


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)

23.32. á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

23.33. á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˝odé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

23.34. ábra. 1994-ben születtem Szatmárnémetiben, és ott jártam középiskolába a Kölcsey Ferenc F˝ogimná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˝ore kezd˝o szinten állok, de célom, hogy az egyetemi éveim után tapasztalt programozónak mondhassam magam. Jöv˝obeli 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.


360 / 404

32. Bodor Dávid, 11 pont

23.35. á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˝oben 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

23.36. á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˝o 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

23.37. á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˝odési kört, így a jöv˝obeli terveim még csak körvonalazódnak. Jelenleg az informatikára való rálátásomat szeretném b˝ovíteni. Robotfocis feladatokban és egyéb felmerül˝o kérdéseknél tutoriált Bereczki László 35. Erdei Krisztián (56 pont)


361 / 404

23.38. ábra. Hajdúnánáson születtem, többnyire ott is lakom. Középiskolába a hajdúnánási K˝orösi Csoma Sándor Gimnázium Szakközépiskolába jártam. Programozásból nem vagyok penge, egyel˝ore. 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

23.39. ábra. 37. Fekete Attila (110 pont)

23.40. á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˝onek számítom, középiskolában kezd˝o 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)


362 / 404

23.41. ábra. 1995-ben születtem Debrecenben, a püspökladányi Karacs Ferenc Gimnáziumban érettségiztem. Programozással el˝oször itt az egyetemen találkoztam el˝oször, középiskolában semmilyen nyelvet nem oktattak. Érdekl˝odé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 485.4 pont

23.42. ábra. A debreceni Fazekas Mihály Gimnáziumba jártam hat évfolyamos matematika-informatika osztálya. Itt tanultam egyszer˝u C++ nyelvet. Érdekl˝odök a matematika iránt, a programozásban a matematikai jelleg˝u feladatokat kedvelem. Haraszti Péter a tutorom. Robotfoci csapatom a McTipszmiksz. 40. Gégény István (200 pont)

23.43. ábra. Mátészalkán születtem. Nagyecseden élek. Fehérgyarmaton érettségiztem. Programozás terén totál kezd˝o vagyok. Egyetemen szeretnék C-ben és C++-ban biztos tudást szerezni. De a jöv˝ot 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)

23.44. ábra.


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˝uszaki 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

23.45. ábra. -Születési év:1994.07.01 -Születési helyem: Nyíregyháza -A Széchenyi István Közgazdasági és Informatikai Szakközépiskola. -Érdekl˝odök a grafika és a mozgás dinamika lemodellezése iránt. Kezd˝o 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

23.46. ábra. 1995-ben, Debrecenben születtem. A debreceni Péchy Mihály Épít˝oipari 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˝o weboldalam, mely meglep˝oen nagy népszer˝uséget ért el. Rájöttem, hogy ebb˝ol 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

23.47. á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˝oként az objektumorientált programozási nyelvekb˝ol.


364 / 404

45. Jakab Ádám 184 pont

23.48. ábra. Nádudvaron születtem 1993-ban. Érettségi bizonyítványomat Hajdúszoboszlón szereztem meg a H˝ogyes 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

23.49. ábra. Csaba vagyok, külföldr˝ol (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˝o vagyok még, de nagyon érdekelnek az objektumorientált nyelvek, mint a C++ is. Az egyetem elvégzése után, ha van lehet˝oség szeretnék valamilyen cégnél elhelyezkedni programozóként. Itt vagy Ukrajnában. 47. Kádár Gergely Sándor (129 pont)

23.50. á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˝ol foglalkoztam a Game Maker nevezet˝u, kezd˝oknek való, játékfejleszt˝o szoftverrel, f˝oleg 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.


365 / 404

48. Kis Dávid, ~1219 pont

23.51. ábra. Ukrajnában, Kárpátalján, Gyula nevezet˝u 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˝uk látókör˝usége miatt; viszont mindig is érdekelt az informatika, így érdekeltségb˝ol Pascal-ban programoztam. Pont emiatt indult nehezen a félév, de nyitott vagyok az új dolgokra így remélem minél el˝obb sikerül elmerülnöm C, C++-ban illetve a tantervnek megfelel˝o témákban. Kifejezetten hasznosnak, és érdekesnek találom a prog 1-et f˝oképp a Git, DocBook miatt. Tettszik a közös munka, hogy fejleszt˝oi munkahelyhez hasonló környezetet teremtünk és többen dolgozunk ugyanazon project-en. Els˝o 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

23.52. á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


366 / 404

23.53. á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˝odési köreim f˝oleg 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

23.54. ábra. Dunaújvárosban születtem, középiskolai tanulmányaimat Egerben, a Wigner Jen˝o M˝uszaki, Informatikai Középiskola és Kollégium falai között fejeztem be emelt szint˝u informatika érettségivel. Programozást alap szinten tanultam, terveim között szerepel ezen tudás elmélyítése. A jöv˝oben 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

23.55. ábra. 1994-ben születtem Budapesten a VIII. kerületben, Abonyban lakom. Középiskolai tanulmányaimat a szolnoki Pálfy János M˝uszeripari é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˝u érettségire való felkészítés volt a legmagasabb szint˝u á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˝o robotokat elkezdi fejleszteni az emberiség. 53. Kovács Roland (102 pont)


367 / 404

23.56. ábra. 1993-ban születtem Miskolcon, Putnokon élek. Kazincbarcikán végeztem a Surányi Endre középiskolában. Az érdekl˝odési köröm tág m˝uszaki 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˝o 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

23.57. ábra. 55. Kozma Bettina (134 pont)

23.58. ábra. 56. Kósa Gerg˝o

23.59. ábra.


368 / 404

57. Kökéndy Tímea (352 pont)

23.60. ábra. 58. Kunkli Attila (30 pont)

23.61. á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˝oen 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˝o 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˝ogimnáziumba jártam középiskolába matematikainformatika szakra, ahol Free Pascalt tanultunk 4 éven keresztül, ebb˝ol van több tapasztalatom. C-vel es C++-szal az egyetemen találkoztam el˝oszö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

23.62. ábra. 60. Lécz Ildikó

23.63. ábra. Hajdúböszörményben születtem, a Veress Ferenc Szakképz˝o Iskolába jártam, informatika szakon végeztem.


369 / 404

Érdekl˝odési köreim közé tartozik a mesterséges intelligencia. 61. Löki Tamás(26 pont :( )

23.64. á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

23.65. ábra. Debrecenben születtem 1994. 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

23.66. á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˝oben 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

23.67. ábra.


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

23.68. ábra. Kiskunfélegyházán születtem, középiskolai tanulmányaimat is ott végeztem a Pet˝ofi Sándor Gépészeti és Informatikai Szakképz˝o Iskola és Kollégium hallgatójaként. Programozás terén abszolút kezd˝onek tartom magam, hosszútávú célom ezért, hogy els˝ore 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

23.69. ábra. 1994-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˝oben, mivel egyel˝ore nincsen konkrét elképzelésem ezt illet˝oen. A tutorrendszerben már részt vettem, tutorom Busák Zoltán. 67. Mucsina Dávid Csaba, (112 pont)

23.70. á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˝oté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


371 / 404

23.71. á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

23.72. ábra. 70. Nagy Dávid 2 pont

23.73. ábra. Kisvárdán születtem, C-t tanultam a Szent László Katolikus Szakközépiskolában. Szabadid˝omben szeretek olvasni, és zenélgetni. Komolyabb programokat még nem írtam. 71. Nagy Dávid 138 pont

23.74. ábra. Berettyóújfaluban születtem 1994-ben.A Debreceni Református Kollégium Gimnáziumába jártam.Az egyetemen el˝ott nem tanultam programozást. 72. Nagy Erik


372 / 404

23.75. á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˝o vagyok, de remélhet˝oleg 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

23.76. á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˝o egyetemem. A programozáson belül mindenre nyitott vagyok, és ezen a területen szeretnék kés˝obb munkát találni. 74. Nagykéri Bence (303,5 pont)

23.77. á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

23.78. ábra.


373 / 404

76. Orbán István Sándor, 2190 pont

23.79. ábra. Nyíregyházán születtem. A nyíregyházi Vasvári Pál Gimnáziumba végeztem, informatika szakon. Emelt szint˝u 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

23.80. ábra. 1993-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˝ujtsek az egyetemi tanulmányi éveim alatt. Nem vettem még részt a tutor-rendszerben. 78. Ozsváth Jonathán (777 pont)

23.81. á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.


374 / 404

79. Pop Richárd László (103 pont)

23.82. ábra. Bio: Székelyhídi Pet˝ofi 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˝oben 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 o˝ tutoriáltja. 80. Preznyák László, 410 pont

23.83. ábra. Nagyváradon születtem, Romániában. A Székelyhídi Pet˝ofi 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˝o szintet sem éri el egyel˝ore. "A célom az, hogy jó legyek. H˝u binomom oldalán. Oly sok a harc, a küzdelem, de gy˝ozelem 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˝odik! 81. Rácz Boglárka 31 pont


375 / 404

23.84. á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˝oször a c++ programozási nyelvvel. 2011-2013 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

23.85. á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˝o cégnél. 83. Seles Péter 177 pont

23.86. ábra. 1994-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.


376 / 404

Tutorjaim: Fülöp Sándor és Kistamás Dávid. 84. Sipos Ferenc 662,5 pont

23.87. á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

23.88. á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˝odési köreim a C++, Java, Android szoftverfejlesztés Feladatokat f˝oleg ó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

23.89. ábra. 1994-ben születtem Debrecenben. 2013-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.


377 / 404

87. Szabó Máté 115 pont

23.90. á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˝odö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

23.91. ábra. 1990.09.07-én Hajdúnánáson születtem. Középiskolás tanulmányaimig ott nevelkedtem. 2005-ben az akkori Vadas Jen˝o 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. 2011-ben lettem erdésztechnikus. Id˝oközben a volt középiskolám többszöri átnevezésen esett át, jelenleg FVM ASzK - Mátra Erdészeti, Mez˝ogazdasági és Vadgazdálkodási Szakképz˝o 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˝o Gyöngyösön a Károly Róbert F˝oiskolán erd˝ogazda FSZ képzésen. 2012. májusában végeztem erd˝ogazda szakon, majd szeptemberben a Debreceni Egyetem Informatika Karának hallgatója lettem programtervez˝o informatikus szakon. E rövid bemutatkozásomból szerintem eléggé egyértelm˝u, 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˝o családomnak. 89. Szálku Tibor, 73 pont


378 / 404

23.92. ábra. 1994-ben születtem Nyíregyházán. Középiskolai tanulmányaimat a gy˝ori 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

23.93. á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˝obb jól megálljam a helyem. A tutorom Madar József. 91. Szentpéteri Annamária, 940 pont

23.94. á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˝un˝o eredménnyel. Informatikából emelt szint˝u érettségit tettem. Konkrétan nem tudom, hogy milyen típusú programokat szeretnék megoldani. Jelenleg a pattogó labda közép és kezd˝o szint˝u 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.


379 / 404

A tutor-tutoriált rendszerben tutoriáltként veszek részt, lévén kezd˝o 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˝u csapattal indulok. 92. Széles Nikolett 3 pont

23.95. ábra. 1993-ban születtem Debrecenben. Ide jártam középiskolába a Balásházy János mez˝ogazdasá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)

23.96. ábra. 1995. 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˝u Általános Iskolában végeztem el a nyolc osztályt, ahol els˝o 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˝u é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˝oje hiszen az informatika már mindenütt jelen van.Nem könny˝u szakma de ez adja a szépségét, hogy van benne kihívás. 94. Sz˝ocs Gábor 319 pont

23.97. á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.


380 / 404

95. Takács Miklós, 80 pont

23.98. á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

23.99. ábra. Berettyóújfaluban születtem, Arany János Gimnáziumba jártam, matematika-informatika szakon végeztem. Érdekl˝odé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

23.100. á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

23.101. ábra.


381 / 404

Hajdúnánáson a K˝orö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

23.102. ábra. Debrecenben születtem. Programozással középiskolában kezdtem el˝oször foglalkozni, f˝oképpen a C nyelvvel. Érdekel az android programozás. 100. Tuza József, 184 pont

23.103. ábra. Debrecenben születtem és Hajdúnánáson a K˝orösi Csoma Sándor Gimnáziumban tanultam. Emelt informatika érettségivel rendelkezem. Legf˝oké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. 101. Varga Attila 204 pont

23.104. ábra.


382 / 404

Debrecenben születtem és a debreceni Csokonai Vitéz Mihály Gimnáziumban tanultam. Az egyetem el˝ott 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. 102. Varga Gábor (66 pont)

23.105. á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. 103. Veress Ármin 473 pont

23.106. á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. 104. Veress Balázs 343 pont

23.107. ábra. Debrecenben születtem, kés˝obb 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.


383 / 404

105. Vona Márton (208 pont)

23.108. á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˝oször, így komolyabb el˝oképzettséggel nem rendelkezem. A legtöbb id˝ot C programozással töltöttem, de ismerkedés szintjén találkoztam már PHP, C++ és JavaScrip forrásokkal is. 106. Winke Róbert

23.109. ábra. 107. Závaczki Roland (82 pont)

23.110. á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. 108. Zelina Zsolt, 315 pont


384 / 404

23.111. á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˝ol elfogadok, de ha valamit tudok, szívesen átadom. Tutorjaim Madar József és Bereczki László. Binomom pedig Mucsina Dávid Csaba. 109. Németh Antal (7 pont)

23.112. á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˝okészít˝os 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. 110. Csopa Tamás (58 pont)

23.113. ábra. 1989-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˝o – Üzemeltet˝o, Internetes Alkalmazásfejleszt˝o, ez utóbbival közel 1 évet dolgoztam diákmunkában, PHP, CSS, MySql, JavaScript / Jquery-vel foglalkoztam. Programozás terén egyel˝ore minden érdekel, nem tartom magam olyan tapasztaltnak, hogy irányt választhassak egyel˝ore. Tutor programban még nem vettem részt. 23.1.2.2. Oktatók ˝ 23.1.2.2.1. Eloadó

1. Dr. Bátfai Norbert


385 / 404

23.114. á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˝uszaki F˝oiskolán folytatta, ahonnan o˝ rmesterként szerelt le, majd 1996-ban szerzett programozó matematikusi, illetve 1998-ban kitüntetéses programtervez˝o matematikusi oklevelet a Debreceni Egyetemen. 1998-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˝oi Versenyén a „Ha hívsz, támadok!” (H.A.H) hálózati ( Java EE szerver, Java ME kliens) játéksorozattal els˝o 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˝oadott az Eurosmobillal a Sun Java Fejleszt˝oi Konferencián 2005-ben. A VISZ (Vezet˝o Informatikusok Szövetsége) a 2008-as évben az Év Informatikai Oktatójának választotta. 2011-ben szerzett PhD doktori fokozatot informatikából. Jelen pillanatban a Debreceni Egyetem Információtechnológiai Tanszékének adjunktusa. Érdekl˝odése most a gépi tudatosságra irányul. 2012-ben Pollák-Virág díjat kapott a Hírközlési és Informatikai Tudományos Egyesülett˝ol. 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. 23.1.2.2.2. Gyakorlatvezeto˝

1. Besenczi Renátó

23.115. ábra. Besenczi Renátó 1986-ban született Kecskeméten, ahol a Kocsis Pál Mez˝ogazdasági Szakközépiskolában érettségizett környezetvédelmi szakon. 2004 és 2009 között a Debreceni Egyetem Mez˝ogazdasá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˝oként tevékenykedik. Kedvenc platformok: Java, C, C++, Android Kutatási terület: közösségi alkalmazások, közösségi adatgy˝ujtés, crowd-sensing 2. Smajda Máté


386 / 404

23.116. á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˝o informatikus BSc képzésen vesz részt, és a Informatikai Kar FIRST projektben végez kutató-fejleszt˝o munkát. Kedvenc platformok: C++, OpenGL, Java, Android, Python. 3. Mamenyák András

23.117. á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 (2007 - 2011). Jelenleg harmadéves MIs hallgató, fohálózatok szakirányon, 4,62-es kumm. átlaggal. 2013-ban megnyerte a Sony és az XDA-Developers által rendezett XDA Tablet Z Development Competition versenyt. Kedvenc platformok: C, C++, Qt, CUDA.

23.1.3. Gnoti se auton 23.1.3.1. Az évfolyam legfontosabb hallgatói - tutor rendszer 23.1.3.1.1. 2014. március 24-i hét 23.1.3.1.2. 2014. április 7-i hét 23.1.3.2. Az évfolyam legfontosabb hallgatói - feladatok megoldása 23.1.3.3. Az évfolyam legfontosabb hallgatói - skillek


387 / 404

V. rész

Mellékletek


388 / 404

A. függelék

Mellékletek A.1. A DocBook dokumentum kezelése A.1.1. Hogyan kezdjem el? A.1.1.1. Parancssori gyorstalpaló

Leklónozol egy munkapéldányt RW módban a sourceforge.org-ról. [nbatfai@desteny UDProg]$ git clone ssh://[email protected]/p/udprog/code udprog-code

Ehhez ott regisztrálnod kell, majd a felhasználói nevedet elküldeni a [email protected] címre, hogy felvehesselek a fejleszt˝ok csoportjába. Ennek hiányában csak RO módban éred el a tárolót: [nbatfai@desteny UDProg]$ git clone git://git.code.sf.net/p/udprog/code udprog-code

Belépsz a munkakönyvtárba, ahol elkezdheted a munkát. [nbatfai@desteny UDProg]$ cd udprog-code/ [nbatfai@desteny udprog-code]$

Most még biztosan up-to-date a munkapéldányod, de javaslom, hogy gyakran, például minden munkameneted el˝ott adj ki egy git pull parancsot, hogy ez így is maradjon. [nbatfai@desteny udprog-code]$ git pull Password: Already up-to-date.

A.1.1.1.1. Fájlok módosítása

Példának okáért szeretném az évkönyv alcímben szerepeltetni az évfolyamot, ekkor böngészve a [TDG51] könyv online változatának DocBook elemei között, adódik, hogy a subtitle elemet használjam. Ennek megfelel˝oen b˝ovítem a udprog_main_ hu.xml állományt A Debreceni Egyetem programozói évkönyve <subtitle>A 2013/14 tanév els˝ o féléve UDProg

mivel a [TDG51] dokumentáció mutatja, hogy a subtitle elem lehet a book elem gyereke. A módosítás után validálok, majd miután meggy˝oz˝odtem róla, hogy a dokumentum valid, felkommitolom a tárolóba a változást.


389 / 404

[nbatfai@desteny book]$ git commit -m "Alcím hozzáadása" udprog_main_hu.xml [master cb41724] Alcím hozzáadása 1 file changed, 23 insertions(+)

Eddig semmi nem történt a távoli tárolóban, csak a saját munkapéldányomban dolgozta. Hasznos dolog gyakran kiadni a git status parancsot, hogy lássuk, mit készülünk változtatni a távoli tárolóban: [nbatfai@desteny book]$ git status # On branch master # Your branch is ahead of ’origin/master’ by 1 commit. # (use "git push" to publish your local commits) # # Changes not staged for commit: # (use "git add ..." to update what will be committed) # (use "git checkout -- ..." to discard changes in working directory) # # modified: udprog_appx_hu.xml # modified: udprog_p1ch1_hu.xml # modified: udprog_p3ch1_hu.xml # # Untracked files: # (use "git add ..." to include in what will be committed) # # udprog_main_hu.pdf no changes added to commit (use "git add" and/or "git commit -a")

Tanulságos átfutni a parancs kimenetét. Jelzi, hogy további fájlok is módosultak. S szeretném is, ha ezeket a közben módosított XML állományokat is felnyomná, ezért kiadom még az alábbi parancsot is a távoli tárolóba nyomás el˝ott. [nbatfai@desteny book]$ git commit -a -m "A másik 3 módosított XML-ben szerkezeti és apró javítások" [master 3813441] A másik 3 módosított XML-ben szerkezeti és apró javítások 3 files changed, 210 insertions(+), 7 deletions(-)

-

Végül a változtatásokat átvezetem a távoli tárolóba. Ez el˝ott a git status parancs már nem látja a commitokat, de érdemes kiadni egy git log parancsot, ahol meglesznek azok. Majd a git push parancs alkalmazásával próbáljuk meg megosztani a többiekkel a munkánkat: [nbatfai@desteny book]$ git push Password: Counting objects: 16, done. Delta compression using up to 8 threads. Compressing objects: 100% (8/8), done. Writing objects: 100% (10/10), 4.47 KiB | 0 bytes/s, done. Total 10 (delta 2), reused 0 (delta 0) remote: refresh queued. To ssh://[email protected]/p/udprog/code 8754e0b..3813441 master -> master

Generált állományokat ne! Arra viszont figyeljünk, hogy átmeneti, vagy generált állományokat ne kommitoljunk fel a tárolóba! Ilyen itt a pdf fájlt, de ˝ ilyen lehet egy fordított bináris ELF vagy Java class vagy akár egy szövegszerkesztoi ˝ backup stb. késobb

A.1.1.1.2. Fájlok hozzáadása

Hasonlóan járunk el, mint az imént, a fájlok módosítása esetén. Most példaképpen a bibliográfiát tettük át külön állományba, amelyet hozzáadunk ezért a tárolóhoz.


390 / 404

[nbatfai@desteny book]$ git add udprog_bib_hu.xml [nbatfai@desteny book]$ git commit -a -m "A bibliográfia külön fájlba." [master 259802e] A bibliográfia külön fájlba. 3 files changed, 85 insertions(+), 47 deletions(-) create mode 100644 book/udprog_bib_hu.xml [nbatfai@desteny book]$ git push

˝ A.1.1.2. A dokumentum érvényességének ellenorzése

Bár már az xmllint is tud RELAX NG séma szerint validálni, de az elemz˝ojének hibakimenete sokszor nagyon félrevezet˝o, ezért használd a jing-trang programot, amelyet innen tölthetsz le: https://code.google.com/p/jing-trang/. Kicsomagolás után a parancssorban tallózd ki a jing-20091111/bin/jing.jar Java archívumot, azaz add ki a következ˝o parancsot a validáláshoz: [nbatfai@desteny book]$ xmllint --xinclude udprog_main_hu.xml --output output.xml [nbatfai@desteny book]$ java -jar ../../jing-20091111/bin/jing.jar -c http://www.docbook. org/xml/5.1CR2/rng/docbookxi.rnc output.xml

-

Validálás az xmllint programmal Az xmllint programot könnyebb használni, amíg minden okés, ám a hibák helyének jelölésében a jing-trang sokkal jobb, ennek ellenére ezt a parancssort is bemutatjuk, mert az xmllint tipikusan ott lesz csomagból a gépeden.

[nbatfai@desteny book]$ xmllint --xinclude udprog_main_hu.xml --output output.xml [nbatfai@desteny book]$ xmllint --relaxng http://www.docbook.org/xml/5.1CR2/rng/ docbookxi.rng output.xml --noout output.xml validates Észreveheted, hogy nem a kompakt formájú sémát kell megadni.

A.1.1.3. A dokumentum olvashatóvá konvertálása

Pdf, epub és HTML kimeneteket állítunk el˝o. A pdf állomány el˝oállítására a dblatex programot használjuk, itt magam annak is a meg-patch-elt változatát, ahol némiképpen az eredménydokumentum magyarsága javul. [nbatfai@desteny book]$ ~/dblatex32book/bin/dblatex udprog_main_hu.xml -p udprog.xls

Természetesen a dblatex csomagból is feltehet˝o, ekkor elegend˝o a dblatex udprog_main_hu.xml parancs kiadása a konverzióhoz.

A.1.2. Pánikgomb Még az el˝oz˝o pont technikai értelemben ad segítséget az induláshoz addig ez azokhoz szól, akik nem vették komolyan, hogy a kurzus elejét˝ol folyamatosan készülni kell, sokat! Viszont szeretnének er˝ofeszítést tenni, hogy élvezhessék a kurzust. Ehhez az kell, hogy higgyenek magukban, ami pedig sikereket feltételez. Ha pánikban vagy és úgy érzed, agyonnyomnak a megtanulni valók, akkor ez a pár sor éppen hozzád szól. Ne feledd a kurzus lényegét: forrásokat írni és olvasni! Persze esetedben ezt már nagyon célzottan kell tennünk. Kövesd a következ˝o iránymutatást és ezen az ösvényen kijutsz majd a programozás egy napos tisztására. Azt persze nem tudjuk nem megtörténté tenni, ha nem olvastad, vagy még inkább nem értelmezted a kötelez˝oket, nem oldottad a feladatokat, ne adj isten még gy˝ujtött pontod sincs... Nem varázslatot ígérek, hanem egy ösvényt. Felejts el mindent és csak arra koncentrálj, hogy teljesen megértsd a Másoló konstruktor és másoló értékadás cím˝u laborkártya 3 forrását és az ottani futtatások m˝uködését. Ehhez els˝o lépésben keress egy tutort, aki face-to-face magyarázza neked a forrást, ezt a keresést külön is támogatom, lásd majd kés˝obb. Ha ezzel megvagytok, ugyanígy dolgozzátok fel és értsd meg a Másoló


391 / 404

konstruktor és másoló értékadás másodszor cím˝u laborkártyát. Ezután már lesz egy olyan szemléletbeli alapod, amely elég önbizalmat és valódi tudás-magot ültet el benned, hogy bátran forgasd a [STROUSTRUP] könyvet, dolgozz ki feladatokat, gy˝ujtsd a pontokat és valóban élvezd Te is a kurzust. Ha ezt a pánikkezelési rutint végrehajtjátok és a tapasztalatodról a kapcsolódó beszélgetésben kommentelsz, akkor Te magad 5 pontot, a (tetsz˝oleges önbesorolásból választott) tutorod pedig 7 pontot könyvelhet el.

A.1.3. Pontozási politika Az id˝o mindenkinek drága, ez a f˝o oka, hogy csalódni fogsz, ha azt várod, hogy akár nekem, akár a laborvezet˝odnek részletes nyilvántartása lesz arról, hogy hány pontod van. Egy elosztott, bizalmi alapú rendszert használunk. Elosztott, mert az tartja nyilván a pontjaidat, aki a leginkább érdekelt ebben és a leginkább képben van: Te magad! Bizalmi, mert ennek a nyilvántartásnak az alapja, hogy Neked valóban legyen egy naprakészen tartott mire-mikor-mennyi pontot kaptam/könyveltem el magamnak jelleg˝u nyilvántartásod. A dokumentum jelen része ebben segít eligazodni. A feladatok részben egyértelm˝u a pontozás. Ezeken túl a laborvezet˝o a labormunkát olajozandó, az ottani példák (azaz a laboron kiadott példák) tekintetében sokszor akár még alkudhat is veletek, ha így tudja jobban ösztönözni a munkát. A jelen doksi feladatai és a laborokon feldolgozott feladatok a pontszerzés f˝o pillérei. Ezeken túl általános pontozási elv, hogy minden kommit 2 pontot ér. (Kommitjaid az egész világnak nyilvánosak, ezt ne feledd.) Adott feladatot csak egy hallgató tud kidolgozni a jegyzetben. Viszont a már felvitt feladatok tekintetében a feladat átnézése 1 pont (az átnézés egyben annak jelzése is, hogy az átnéz˝o helyesnek tartja a megoldást, az átnéz˝o nevének a feladatkiíró részben ki kell derülnie), tesztelése/BUG riportolása (utóbbi a SF ticket rendszerét használva) 5 pont, ha a BUG-ot elismeri a fejleszt˝o. Ugyancsak 5 pont a feladat tetsz˝oleges nyelvre fordítása (új nyelv esetén az iniciális DocBook dokumentumok elkészítése további 15 pont, tehát az egy évkönyv - egy nyelv elvet követjük). Bármelyik aktuális könyvben egy helyesírási javítás 1 pont, de ezekb˝ol a pontokból 20 pontnál több nem számolható el (ett˝ol az értelemszer˝uen szükséges kommitok után járó pontok függetlenek). Bármelyik aktuális könyvben egy további DocBook elemmel történ˝o annotálása a szövegnek 2 pont, de ezekb˝ol a pontokból 40 pontnál több nem számolható el (ett˝ol az értelemszer˝uen szükséges kommitok után járó pontok függetlenek).

A.2. Házi-versenyek A.2.1. Kolmogorovi bitfaragás Itt kapnak helyet azok a binomi beszélgetésekb˝ol kin˝ov˝o kis versenyek, ahol minden ugyanúgy m˝uköd˝o, de az aktuális utolsónál rövidebb (ahol persze nem a fehér szóközök csökkentését értjük) megoldás 5 pontot ér! A binomi beszélgetésb˝ol az n˝o ki, ahol megjenelik a versenyben 2, a binom tagjaitól különb˝oz˝o programozó. Továbbá a versengést elkezd˝o binomok is kapnak minden itt megjelen˝o megoldás után 1 pontot. A.2.1.1. Szimmetrikusság vizsgálata

Ez a verseny a source/binom/Preznyák_László---Iványi-Nagy_Gábor/Verseny könyvtárból n˝ott ki. Az int szimmetrikus (char *str); függvény legrövidebb implementációját kell megadni, amely 1-et ad vissza, ha a paraméterként kapott szó szimmetrikus a közepére, 0-t, ha nem; A.2.1.1.1. Bátfai Norbert

../source/binom/Preznyák_László---Iványi-Nagy_Gábor/Verseny/szimmetria_norbert_batfai. c int szimmetrikus (char *str) { char *p = str, *q = str + strlen (str) - 1;


for (; { if return } return

392 / 404

*p == *q; ++p, --q) (q <= p) 1; 0;

} [nbatfai@desteny Verseny]$ wc -c BatfaiNorbertSzimm.txt 160 BatfaiNorbertSzimm.txt

Tesztelés Az általam írt program tesztesetei szerint a függvény jól muködik. ˝ (Deregi Diána)

../source/binom/Preznyák_László---Iványi-Nagy_Gábor/Verseny/Teszt/teszt_ szimmetria_norbert_batfai.c

A.2.1.1.2. Nagy Sándor

../source/binom/Preznyák_László---Iványi-Nagy_Gábor/Verseny/szimmetria_sandor_nagy.c int szimmetrikus { int s = 0, while (i < s += abs return !s; }

(char *str) i = 0, j = strlen (str); j) (str[i++] - str[--j]);

[nbatfai@desteny Verseny]$ wc -c NagySandorSzimm.txt 135 NagySandorSzimm.txt


../source/binom/Preznyák_László---Iványi-Nagy_Gábor/Verseny/Teszt/teszt_ szimmetria_sandor_nagy.c


../source/binom/Preznyák_László---Iványi-Nagy_Gábor/Verseny/szimmetria_sandor_nagy2.c int szimmetrikus (char *str) { char s, *v = str + strlen (str); while (!(s = *str++ - *--v) && str < v); return !s; } [nbatfai@desteny Verseny]$ wc -c NagySandorSzimm2.txt 123 NagySandorSzimm2.txt


393 / 404


../source/binom/Preznyák_László---Iványi-Nagy_Gábor/Verseny/Teszt/teszt_ szimmetria_sandor_nagy2.c

A.2.1.1.4. Mamenyák András

../source/binom/Preznyák_László---Iványi-Nagy_Gábor/Verseny/szimmetria_csakazertis.c int szimmetrikus(char *str) { char *p = str + strlen(str) - 1; while (*str++ == *p--); return p < str-1; } [nbatfai@desteny Verseny]$ wc -c MamenyakAndris.txt 112 MamenyakAndris.txt

figyelem ˝ Ezt és a szimmetria_Katona_Besenczi.c-t még ellenorizni kell, nincs konzenzus az elfogadására.

A.2.1.1.5. Bátfai Norbert

../source/binom/Preznyák_László---Iványi-Nagy_Gábor/Verseny/szimmetria_norbert_batfai3. c int r(char *p, char *q) { if(p>=q)return 1; if(*p==*q)return r(++p,--q); return 0; } int szimmetrikus (char *str) { return r(str,str+strlen(str)-1); } [nbatfai@desteny Verseny]$ wc -c 157 BatfaiNorbertSzimm3.txt

BatfaiNorbertSzimm3.txt

figyelem Ez a mérete miatt már versenyen kívüli, de egy másik elképzelésre épül, de lehet rajra rövidíteni, azaz forkolódhat ˝ a verseny. belole


394 / 404

A.2.1.1.6. Mamenyák András

../source/binom/Preznyák_László---Iványi-Nagy_Gábor/Verseny/szimmetria_csakazertisrek. c int r (char *p, int n) { return (*p == *(p + n)) * (n > 0 ? r (p + 1, n - 2) : 1); } int szimmetrikus (char *str) { return r (str, strlen (str) - 1); } [nagys@pc Verseny]$ wc -c 157 CsakAzertIsRek.txt

CsakAzertIsRek.txt


../source/binom/Preznyák_László---Iványi-Nagy_Gábor/Verseny/szimmetria_sandor_nagy_rek. c int r (char *p, int n) { return n <= 0 ? 1 : *p == p[--n] && r (++p, --n); } int szimmetrikus (char *str) { return r (str, strlen (str)); } [nagys@pc Verseny]$ wc -c 145 NagySandorRek.txt

NagySandorRek.txt


../source/binom/Preznyák_László---Iványi-Nagy_Gábor/Verseny/szimmetria_sandor_nagy_rek2. c int szimmetrikus (char *str) { int l = strlen (str); return l ? *str == str[--l] ? str[l] = 0, szimmetrikus (++str) : 0 : 1; } [nagys@pc Verseny]$ wc -c 131 NagySandorRek2.txt

NagySandorRek2.txt


395 / 404

A.2.2. Prog1 Robotfoci Labdarúgó Bajnokság (PLB) Korábban DEIK Prog Labor Bajnokság (PLB). Egy f˝os csapatok jelentkezhetnek egy rövid TDP jelleg˝u dokumentum elkészítésével. Például a 2012-es VB TDP-it itt találod: http://www.socsim.robocup.org/files/2D/tdp/RoboCup2012/. A saját TDP doksid a ../source/plbplk/TDP/ures könyvtárba tett minta alapján készítsd el, a generált pdf dokumentumot a levelezési listánkra küld el március 30-ig. A nevezett csapat lehet • from scratch alapon teljesen saját • az rcssserver sampleclient programján alapuló • a [PROP] könyv valamelyik (rcssserver sampleclient alapú) csapatán alapuló. A csapat TDP dokumentumában add meg, hogy a fenti három lehet˝oségb˝ol Te melyiket választod. A sikeres nevezést 10 ponttal jutalmazzuk. A bajnokságban résztvev˝ok a laborokon egymással edz˝omérk˝ozéseket játszhatnak, párosításonként és alkalmanként 9 pont a gy˝ozelem, 3 a döntetlen és 1 a vereség alapon. A bajnokság mérk˝ozéseit is ugyanígy pontozzuk. Továbbá az els˝o, második, harmadik hely rendre további 200, 150 és 100 pontot ér. A.2.2.1. Versenynaptár

A versenybizottság az alábbi nevezéseket fogadta el és az alábbi id˝obeosztással szervezte meg a 16 csapatos bajnokság lebonyolítását. 1. forduló, április 13, vasárnap BlackLongju DeadlyTeam FC KUMAR Hall of Fame of Programmers FC KTDavidFC MoonMoonFC MordOrk PSZTLTK

: : : : : : : :

BDSRSTNT ARANYMESTER Falabu Football Team Sea Pandas TeamUnicorn Tagok Random Goal Generators Debrecen Round Forest FC++

: : : : : : : :

BlackLongju BDSRSTNT ARANYMESTER Falabu Football Team Sea Pandas TeamUnicorn Tagok Random Goal Generators

: : : : : : : :

FC KUMAR DeadlyTeam BDSRSTNT ARANYMESTER Falabu Football Team Sea Pandas TeamUnicorn Tagok

2. forduló, április 15, kedd DeadlyTeam FC KUMAR Hall of Fame of Programmers FC KTDavidFC MoonMoonFC MordOrk PSZTLTK Debrecen Round Forest FC++ 3. forduló, április 18, péntek BlackLongju Hall of Fame of Programmers FC KTDavidFC MoonMoonFC MordOrk PSZTLTK Debrecen Round Forest FC++ Random Goal Generators 4. forduló, április 20, vasárnap


Hall of Fame of Programmers FC KTDavidFC MoonMoonFC MordOrk PSZTLTK Debrecen Round Forest FC++ Random Goal Generators Tagok

396 / 404

: : : : : : : :

BlackLongju FC KUMAR DeadlyTeam BDSRSTNT ARANYMESTER Falabu Football Team Sea Pandas TeamUnicorn

: : : : : : : :

KTDavidFC Hall of Fame of Programmers FC FC KUMAR DeadlyTeam BDSRSTNT ARANYMESTER Falabu Football Team Sea Pandas

: : : : : : : :

BlackLongju KTDavidFC Hall of Fame of Programmers FC FC KUMAR DeadlyTeam BDSRSTNT ARANYMESTER Falabu Football Team

: : : : : : : :

MordOrk MoonMoonFC KTDavidFC Hall of Fame of Programmers FC FC KUMAR DeadlyTeam BDSRSTNT ARANYMESTER

: : : : : : : :

BlackLongju MordOrk MoonMoonFC KTDavidFC Hall of Fame of Programmers FC FC KUMAR DeadlyTeam BDSRSTNT

: : : : : : :

Debrecen Round Forest FC++ PSZTLTK MordOrk MoonMoonFC KTDavidFC Hall of Fame of Programmers FC FC KUMAR

5. forduló, április 22, kedd BlackLongju MoonMoonFC MordOrk PSZTLTK Debrecen Round Forest FC++ Random Goal Generators Tagok TeamUnicorn 6. forduló, április 25, péntek MoonMoonFC MordOrk PSZTLTK Debrecen Round Forest FC++ Random Goal Generators Tagok TeamUnicorn Sea Pandas 7. forduló, április 27, vasárnap BlackLongju PSZTLTK Debrecen Round Forest FC++ Random Goal Generators Tagok TeamUnicorn Sea Pandas Falabu Football Team 8. forduló, április 29, kedd PSZTLTK Debrecen Round Forest FC++ Random Goal Generators Tagok TeamUnicorn Sea Pandas Falabu Football Team ARANYMESTER 9. forduló, május 2, péntek BlackLongju Random Goal Generators Tagok TeamUnicorn Sea Pandas Falabu Football Team ARANYMESTER


397 / 404

BDSRSTNT : DeadlyTeam 10. forduló, május 4, vasárnap Random Goal Generators Tagok TeamUnicorn Sea Pandas Falabu Football Team ARANYMESTER BDSRSTNT DeadlyTeam

: : : : : : : :

BlackLongju Debrecen Round Forest FC++ PSZTLTK MordOrk MoonMoonFC KTDavidFC Hall of Fame of Programmers FC FC KUMAR

: : : : : : : :

Tagok Random Goal Generators Debrecen Round Forest FC++ PSZTLTK MordOrk MoonMoonFC KTDavidFC Hall of Fame of Programmers FC

: : : : : : : :

BlackLongju Tagok Random Goal Generators Debrecen Round Forest FC++ PSZTLTK MordOrk MoonMoonFC KTDavidFC

: : : : : : : :

Sea Pandas TeamUnicorn Tagok Random Goal Generators Debrecen Round Forest FC++ PSZTLTK MordOrk MoonMoonFC

: : : : : : : :

BlackLongju Sea Pandas TeamUnicorn Tagok Random Goal Generators Debrecen Round Forest FC++ PSZTLTK MordOrk

11. forduló, május 6, kedd BlackLongju TeamUnicorn Sea Pandas Falabu Football Team ARANYMESTER BDSRSTNT DeadlyTeam FC KUMAR 12. forduló, május 9, péntek TeamUnicorn Sea Pandas Falabu Football Team ARANYMESTER BDSRSTNT DeadlyTeam FC KUMAR Hall of Fame of Programmers FC 13. forduló, május 11, vasárnap BlackLongju Falabu Football Team ARANYMESTER BDSRSTNT DeadlyTeam FC KUMAR Hall of Fame of Programmers FC KTDavidFC 14. forduló, május 13, kedd Falabu Football Team ARANYMESTER BDSRSTNT DeadlyTeam FC KUMAR Hall of Fame of Programmers FC KTDavidFC MoonMoonFC 15. forduló, május 16, péntek BlackLongju : ARANYMESTER BDSRSTNT : Falabu Football Team DeadlyTeam : Sea Pandas


FC KUMAR Hall of Fame of Programmers FC KTDavidFC MoonMoonFC MordOrk

: : : : :

398 / 404

TeamUnicorn Tagok Random Goal Generators Debrecen Round Forest FC++ PSZTLTK

A.2.2.2. A PLB lebonyolítása

Ahogy id˝od engedi, gyúrd a csapatodat, amikor úgy gondolod, hogy egy adott verziót beküldesz, akkor a make dist-bzip2 parancs kiadásával legenerált .bz2 kiterjesztés˝u állományt küld be a plbplk listára egy mail csatolmányaként. Az els˝o titkár a mérk˝ozés el˝ott (ha új csomagod érkezett be) lefordítja a csomagot, majd a mérk˝ozésre a csomagodhoz mellékelt start.sh szkripttel küldi be az ágenseidet. Ha a csapatod nem fut, akkor a mérk˝ozés gy˝oztese 3:0-s gólkülönbséggel a másik csapat, ha egyik sem fut, akkor az eredmény 0:0. Ilyen esetekben az els˝o titkár a listán tájékoztatja a résztvev˝oket. Az els˝o titkár mérk˝ozésenként 6 pontot könyvel el magának, ha az id˝opontot el˝ore bejelenti, hogy az érdekl˝od˝ok a mérk˝ozést on-line is megtekinthessék saját monitor programjaikkal, akkor 9 pont. ˝ mérk˝ozésenként A második titkár teszi elérhet˝ové a weben a lejátszott mérk˝ozések .rcg állományait és tartja karban a tabellát. O 3 pontot könyvelhet el. Az rcg állományokat az els˝o titkártól kapja meg. Ha az els˝o három helyen laborvezet˝o vagy oktató végez, akkor o˝ k az els˝o háro helyezettnek járó pontozásban természetesen nem vesznek részt, hanem a következ˝o hallgatói csapatot (csapatokat) kell a pontozásnál tekinteni. A PLB tabelláját itt találod: http://robocup.inf.unideb.hu/plbplk/2014tavasz/plb/.

A.2.3. Prog1 Robotfoci Labdarúgó Kupa (PLK) A hagyományoknak megfelel˝oen nyilvánosan történik a kupa sorsolása. A nem hivatalos tabella és az egyenes kieséses torna szervezése itt található: http://challonge.com/deikplk2014spring. A hivatalos tabellát itt találod majd: http://robocup.inf.unideb.hu/plbplk/2014tavasz/. A kupa pontozása megegyezik a bajnokságnál bevezetettel (ez természetesen a laboron lejátszott edz˝omérk˝ozésekre is vonatkozik). Az els˝o játéknap sorsolása a következ˝o: 1. BDSRSTNT vs. Debreceni Lobogo FC++ 2. Skate Connect The World vs. ChigaTempo 3. Z4QQQ vs. Debreceni Great Forest FC++ 4. Tagok vs. Own Goal FC 5. Hall of Fame of Programmers vs. Debrecen Deep Forest FC++ 6. Lambdába Rúgók vs. The Wizards 7. ffTeam vs. McTipszMiksz 8. Random Goal Generators vs. NDFC++ 9. MoonMoonFC vs. FrostWarg C++n 10. Kispályások vs. BlueBear 11. FC KUMAR vs. The Dongers 12. MordOrk vs. Myrmidons 13. PSZTLTK vs. Debreceni Egyetértés FC++ 14. DeadlyTeam vs. KTDavidFC 15. Debrecen Round Forest FC++ vs. Debreceni Hivatásos FC++ 16. Aranymester vs. TeamUnicorn


399 / 404

A.2.4. Prog1 Robotfoci PLBPLK-Szuperkupa A bajnokság és a kupa gy˝oztesének mérk˝ozése. Gy˝ozelem 200, vereség 100, döntetlen 150 pont pontozással. Ha a kupa és a bajnokság gy˝oztese megegyezik, akkor a kupa második helyezettje a játszani jogosult. (Itt nem különböztetjük meg a hallgatói és oktatói csapatokat.)

PSZTLTK:BDSRSTNT 6:7 ˝ A 2013/14 tanév tavaszi szemeszterének szuperkupa gyoztese Busák Zoltán BDSRSTNT csapata.

A.2.5. Prog1 Kvantumfoci Labdarúgó Bajnokság Kvantum-tudatos torna csak a prog2-ben kerül majd megrendezésre.

A.2.6. Prog1 Kvantumfoci Labdarúgó Kupa Kvantum-tudatos torna csak a prog2-ben kerül majd megrendezésre.

A.3. Céges feladatok Jobban fedné az elképzelést a „cégek által kiírt oktatási célú programozási feladatok”, de az kissé nehézkes. Maradjunk ezért a korábbinál és fejtsük ki, mit értünk alatta.

A.3.1. A „céges feladatok” intézménye Nem új a koncepció, hanem a 2010-ben részben és kicsiben kipróbált céges feladat koncepció felmelegítése. A 2014-2015 tanév szeptemberi szemeszterét˝ol a Magasszint˝u programozási nyelvek 2 (Prog2) 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 szoftverfejlesztésben 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˝o neve, email címe, továbbá a feladat megoldása bekerülhet a GNU GPL v3-as engedély˝u UDPROG (The Yearbook of the Programmers of University of Debrecen, http://sourceforge.net/projects/udprog/) projektbe. Fontosnak kiemelni, hogy a céges feladatok semmiképpen sem valamilyen konkrét „céges munka” elvégzésér˝ol szólnak, hanem sokkal kevesebbr˝ol. Mert azt biztosítani akarjuk, hogy egyetlen résztvev˝o se, azaz se a hallgató, se az egyetem, se a cég ne viseljen semmiféle felel˝osséget, illetve semmilyen anyagi aspektus se merülhessen fel. Ezt azzal érhetjük el, hogy a szóban forgó feladatok nem a cégek egy valódi feladatának valamilyen részét alkotják, hanem sokkal inkább direkt erre a célra kitalált fiktív feladatok legyenek, amelyek vonzóak a hallgatóknak, hiszen a cégek feladatai a beküldéssel egyértelm˝uen egy versenyhelyzetbe kerülnek, mivel a kurzus hallgatói teljesen szabadon választhatnak a feladatok közül. A kihívás és a megvalósíthatóság fontos szempont lesz a feladat-választó hallgatóknál, ezért érdemes a feladatot úgy skálázni, hogy tartalmazzon kihívás jelleg˝u és könnyebben megvalósítható részt is, hogy a hallgató egyszerre akarja és merje is választani.

GPLv3 Ezen törekvésünk ellenére van olyan cég is, akiknek belefér, hogy éles feladatot írjanak ki (mert mondjuk éppen open source a fejlesztése), ezzel elfogadva egyben, hogy a feladat és annak megoldása a GNU GPL v3 engedéllyel szerepeljen az UDPROG projektben.


400 / 404

Lássuk a „céges feladatok” intézményének három alapvet˝o használati esetét: 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˝ojegye 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˝o 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˝ore 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˝o 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˝u diákok a régióban. A céges feladatok intézménye aktuális feladatként megfogalmazva, illetve a tervezett kulcstémák az utolsó labor feladatai között található.


401 / 404

VI. rész

Irodalomjegyzék


402 / 404

23.4. Algoritmusok [BBP]

Bailey, David H., The BBP Algorithm for Pi, http://crd.lbl.gov/~dhbailey/dhbpapers/bbp-alg.pdf , 2006.

23.5. DocBook [TDG51]

Walsh, Norman, DocBook 5.1: The Definitive Guide, O’Reilly Media, http://docbook.org/tdg51/en/html/ , 2010.

23.6. Programozás [EZUST]

Ezust, Alan Ã©s Ezust, Paul, An Introduction to Design Patterns in C++ with Qt 4, Prentice Hall, http://ptgmedia.pearsoncmg.com/images/9780131879058/downloads/0131879057_Ezust_book.pdf , 2006.

[JAVAKONYV] Gaizler Judit, Nyékyné Ã©s et, al., Java 2 útikalauz programozóknak: 5.0, ELTE TTK Hallgatói Alapítvány , 2008. [JAVATTANITOK] Bátfai, Norbert Ã©s Juhász, István, Javát tanítok, Bevezetés a programozásba a Turing gépekt˝ol a CORBA technológiáig, Kempelen Farkas Digitális Fels˝ooktatási Tankönyvtár http://www.tankonyvtar.hu/site/upload/pdf/b10108.pdf http://www.tankonyvtar.hu/informatika/javat-tanitok-javat-080904 , 2007. [KR]

Kernighan, Brian W. Ã©s Rithcie, Dennis M., A C programozási nyelv, Bp., M˝uszaki, 1993.

[MIRC]

Bátfai, Norbert, Mesterséges intelligencia a gyakorlatban: bevezetés a robotfoci programozásba, Kempelen Farkas Digitális Fels˝ooktatási Tankönyvtár http://www.tankonyvtar.hu , A szerz˝o honlapján elérhet˝o a saját pdf, html és epub konverziója: http://www.inf.unideb.hu/~nbatfai/konyvek , 2011.

[MOBP]

Bátfai, Norbert, Mobil programozás - Nehogy már megint a mobilod nyomkodjon Téged!, Kempelen Farkas Digitális Fels˝ooktatási Tankönyvtár http://www.tankonyvtar.hu , A szerz˝o honlapján elérhet˝o a saját pdf, html és epub konverziója: http://www.inf.unideb.hu/~nbatfai/konyvek , 2011.

[NEHOGY]

Bátfai, Norbert, Nehogy már a mobilod nyomkodjon Téged!, ISBN 978 963 473 094 1, Debrecen, DEENK http://www.eurosmobil.hu/NehogyMar , 2008.

[PARP]

Bátfai, Norbert, Párhuzamos programozás GNU/Linux környezetben: SysV IPC, P-szálak, OpenMP, Kempelen Farkas Digitális Fels˝ooktatási Tankönyvtár http://www.tankonyvtar.hu , A szerz˝o honlapján elérhet˝o a saját pdf, html és epub konverziója: http://www.inf.unideb.hu/~nbatfai/konyvek , 2011.

[POPR]

Bátfai, Norbert, Paternoster of Programmers Reloaded: C, C++, Java, Python and AspectJ Case Studies, Kempelen Farkas Digitális Fels˝ooktatási Tankönyvtár http://www.tankonyvtar.hu , A szerz˝o honlapján elérhet˝o a saját pdf, html és epub konverziója: http://www.inf.unideb.hu/~nbatfai/konyvek , 2011.

[PP]

Bátfai, Norbert, Programozó Páternoszter, http://www.inf.unideb.hu/~nbatfai/ProgramozoPaternoszter.pdf , 2007.

[PROP]

Bátfai, Norbert, Programozó Páternoszter újratöltve: C, C++, Java, Python és AspectJ esettanulmányok, Kempelen Farkas Digitális Fels˝ooktatási Tankönyvtár http://www.tankonyvtar.hu , A szerz˝o honlapján elérhet˝o a saját pdf, html és epub konverziója: http://www.inf.unideb.hu/~nbatfai/konyvek , 2011.

[STROUSTRUP] Stroustrup, Bjarne, A C++ programozási nyelv, Kiskapu , 2001. [SZFCPP]

Benedek, Zoltán Ã©s Levendovszky, Tihamér, Szoftverfejlesztés C++ nyelven, Szak , 2007.


24. fejezet

Tárgymutató G GNU Linux, lásd Linux, 11 kernel, lásd Linux kernel L Linux rendszerhívás, xxx M Minix kernel, 11 P PCB, lásd Process Control Block Process Control Block, lásd PCB

403 / 404


Végszó Kolofon.

404 / 404

A Debreceni Egyetem programozói évkönyve

Recommend Documents