Programovanie (2) v Jave
1-INF-166, letný semester 2023/24
2012/13 Programovanie (1) v C/C++: Rozdiel medzi revíziami
(9 medziľahlých úprav od rovnakého používateľa nie je zobrazených.) | |||
Riadok 1: | Riadok 1: | ||
− | * [[Zimný semester, úvodné informácie]] | + | __NOTOC__ |
− | * [[Zimný semester, pravidlá]] | + | |
− | * [[Zimný semester, test a skúška]] | + | Táto stránka obsahuje archívnu kópiu materiálov zo školského roku 2012/13. Niektoré odkazy nemusia byť funkčné. V ďalších školských rokoch sa obsah predmetu môže mierne alebo výraznejšie meniť. |
− | * [[Netbeans]] | + | |
− | * [[SimpleDraw]] | + | * [[#Zimný semester, úvodné informácie]] |
+ | * [[#Zimný semester, pravidlá]] | ||
+ | * [[#Zimný semester, test a skúška]] | ||
+ | * [[#Netbeans]] | ||
+ | * [[#SimpleDraw]] | ||
{| | {| | ||
|- | |- | ||
Riadok 11: | Riadok 15: | ||
|- | |- | ||
|- | |- | ||
− | | [[Prednáška 1]] '''·''' [[Prednáška 2]] '''·''' [[Cvičenia 1]] '''·''' [[DÚ0]] | + | | [[#Prednáška 1]] '''·''' [[#Prednáška 2]] '''·''' [[#Cvičenia 1]] '''·''' [[#DÚ0]] |
|- | |- | ||
|style="background:#f0f0f0" |'''Týždeň 24.-30.9.''' | |style="background:#f0f0f0" |'''Týždeň 24.-30.9.''' | ||
Riadok 18: | Riadok 22: | ||
|- | |- | ||
|- | |- | ||
− | | [[Prednáška 3]] '''·''' [[Prednáška 4]] '''·''' [[Cvičenia 2]] '''·''' [[DÚ1]] '''·''' [[Pokročilá DÚ1]] | + | | [[#Prednáška 3]] '''·''' [[#Prednáška 4]] '''·''' [[#Cvičenia 2]] '''·''' [[#DÚ1]] '''·''' [[#Pokročilá DÚ1]] |
|- | |- | ||
|style="background:#f0f0f0" |'''Týždeň 1.-7.10.''' | |style="background:#f0f0f0" |'''Týždeň 1.-7.10.''' | ||
Riadok 25: | Riadok 29: | ||
|- | |- | ||
|- | |- | ||
− | | [[Prednáška 5]] '''·''' [[Prednáška 6]] '''·''' [[Cvičenia 3]] '''·''' [[DÚ2]] | + | | [[#Prednáška 5]] '''·''' [[#Prednáška 6]] '''·''' [[#Cvičenia 3]] '''·''' [[#DÚ2]] |
|- | |- | ||
|style="background:#f0f0f0" |'''Týždeň 8.-14.10.''' | |style="background:#f0f0f0" |'''Týždeň 8.-14.10.''' | ||
Riadok 32: | Riadok 36: | ||
|- | |- | ||
|- | |- | ||
− | | [[Prednáška 7]] '''·''' [[Prednáška 8]] '''·''' [[Cvičenia 4]] '''·''' [[DÚ3]] | + | | [[#Prednáška 7]] '''·''' [[#Prednáška 8]] '''·''' [[#Cvičenia 4]] '''·''' [[#DÚ3]] |
|- | |- | ||
|style="background:#f0f0f0" |'''Týždeň 15.-21.10.''' | |style="background:#f0f0f0" |'''Týždeň 15.-21.10.''' | ||
Riadok 39: | Riadok 43: | ||
|- | |- | ||
|- | |- | ||
− | | [[Prednáška 9]] '''·''' [[Prednáška 10]] '''·''' [[Cvičenia 5]] '''·''' [[DÚ4]] '''·''' [[Pokročilá DÚ2]] | + | | [[#Prednáška 9]] '''·''' [[#Prednáška 10]] '''·''' [[#Cvičenia 5]] '''·''' [[#DÚ4]] '''·''' [[#Pokročilá DÚ2]] |
|- | |- | ||
|style="background:#f0f0f0" |'''Týždeň 22.-28.10.''' | |style="background:#f0f0f0" |'''Týždeň 22.-28.10.''' | ||
Riadok 46: | Riadok 50: | ||
|- | |- | ||
|- | |- | ||
− | | [[Prednáška 11]] '''·''' [[Prednáška 12]] '''·''' [[Cvičenia 6]] '''·''' [[DÚ5]] | + | | [[#Prednáška 11]] '''·''' [[#Prednáška 12]] '''·''' [[#Cvičenia 6]] '''·''' [[#DÚ5]] |
|- | |- | ||
|style="background:#f0f0f0" |'''Týždeň 29.10.-4.11.''' | |style="background:#f0f0f0" |'''Týždeň 29.10.-4.11.''' | ||
Riadok 53: | Riadok 57: | ||
|- | |- | ||
|- | |- | ||
− | | [[Prednáška 13]] '''·''' [[Prednáška 14]] '''·''' [[Cvičenia 7]] '''·''' [[DÚ6]] '''·''' [[Pokročilá DÚ3]] | + | | [[#Prednáška 13]] '''·''' [[#Prednáška 14]] '''·''' [[#Cvičenia 7]] '''·''' [[#DÚ6]] '''·''' [[#Pokročilá DÚ3]] |
|- | |- | ||
|style="background:#f0f0f0" |'''Týždeň 5.-11.11.''' | |style="background:#f0f0f0" |'''Týždeň 5.-11.11.''' | ||
Riadok 60: | Riadok 64: | ||
|- | |- | ||
|- | |- | ||
− | | [[Prednáška 15]] '''·''' [[Prednáška 16]] '''·''' [[Cvičenia 8]] | + | | [[#Prednáška 15]] '''·''' [[#Prednáška 16]] '''·''' [[#Cvičenia 8]] |
|- | |- | ||
|style="background:#f0f0f0" |'''Týždeň 12.-18.11.''' | |style="background:#f0f0f0" |'''Týždeň 12.-18.11.''' | ||
Riadok 67: | Riadok 71: | ||
|- | |- | ||
|- | |- | ||
− | | [[Prednáška 17]] '''·''' [[Prednáška 18]] '''·''' [[Cvičenia 9]] '''·''' [[DÚ7]] | + | | [[#Prednáška 17]] '''·''' [[#Prednáška 18]] '''·''' [[#Cvičenia 9]] '''·''' [[#DÚ7]] |
|- | |- | ||
|style="background:#f0f0f0" |'''Týždeň 19.-25.11.''' | |style="background:#f0f0f0" |'''Týždeň 19.-25.11.''' | ||
Riadok 74: | Riadok 78: | ||
|- | |- | ||
|- | |- | ||
− | | [[Prednáška 19]] '''·''' [[Prednáška 20]] '''·''' [[Cvičenia 10]] '''·''' [[DÚ8]] '''·''' [[Pokročilá DÚ4]] | + | | [[#Prednáška 19]] '''·''' [[#Prednáška 20]] '''·''' [[#Cvičenia 10]] '''·''' [[#DÚ8]] '''·''' [[#Pokročilá DÚ4]] |
|- | |- | ||
|style="background:#f0f0f0" |'''Týždeň 26.11.-2.12.''' | |style="background:#f0f0f0" |'''Týždeň 26.11.-2.12.''' | ||
Riadok 81: | Riadok 85: | ||
|- | |- | ||
|- | |- | ||
− | | [[Prednáška 21]] '''·''' [[Prednáška 22]] '''·''' [[Cvičenia 11]] '''·''' [[DÚ9]] | + | | [[#Prednáška 21]] '''·''' [[#Prednáška 22]] '''·''' [[#Cvičenia 11]] '''·''' [[#DÚ9]] |
|- | |- | ||
|style="background:#f0f0f0" |'''Týždeň 3.-9.12.''' | |style="background:#f0f0f0" |'''Týždeň 3.-9.12.''' | ||
Riadok 88: | Riadok 92: | ||
|- | |- | ||
|- | |- | ||
− | | [[Prednáška 23]] '''·''' [[Prednáška 24]] '''·''' [[Cvičenia 12]] '''·''' [[DÚ10]] | + | | [[#Prednáška 23]] '''·''' [[#Prednáška 24]] '''·''' [[#Cvičenia 12]] '''·''' [[#DÚ10]] |
|- | |- | ||
|style="background:#f0f0f0" |'''Týždeň 10.-16.12.''' | |style="background:#f0f0f0" |'''Týždeň 10.-16.12.''' | ||
Riadok 95: | Riadok 99: | ||
|- | |- | ||
|- | |- | ||
− | | [[Prednáška 25]] '''·''' [[Cvičenia 13]] | + | | [[#Prednáška 25]] '''·''' [[#Cvičenia 13]] |
|- | |- | ||
|} | |} | ||
+ | =Zimný semester, úvodné informácie= | ||
+ | '''Rozvrh''' | ||
+ | * Prednášky: pondelok 9:00 F1-328 a utorok 9:50 F1-109 | ||
+ | * Cvičenia: | ||
+ | ** 1i1 (prvý krúžok) pondelok 10:40 M-217 Martin Králik | ||
+ | ** 1i2 (druhý krúžok) pondelok 12:20 M-217 Martin Králik | ||
+ | ** 1i3 (tretí krúžok) pondelok 12:20 M-218 Jaro Budiš | ||
+ | ** Rozdelenie na krúžky [http://www.fmph.uniba.sk/index.php?id=1774] | ||
+ | * Nepovinné cvičenia: pondelok 14:50 M-218 (pre tých, ktorí si potrebujú učivo lepšie precvičiť alebo majú ďalšie otázky) | ||
+ | Poznámka: cvičenia z predmetu 1-INF-126 Programovanie (1) sú v pondelok o 10:40 v M-IX | ||
+ | |||
+ | '''Vyučujúce''' | ||
+ | |||
+ | * [http://new.dcs.fmph.uniba.sk/index.php/JanaKatreniakova RNDr. Jana Katreniaková PhD.], miestnosť M-263, [[Image:e-jk.png]] | ||
+ | ::Konzultácie pondelok 13:10-14:00 alebo po dohode e-mailom | ||
+ | |||
+ | * [http://compbio.fmph.uniba.sk/~bbrejova/ Mgr. Broňa Brejová, PhD.], miestnosť M-163, [[Image:e-bb.png]] | ||
+ | ::Konzultácie pondelok 14:00-15:00 alebo po dohode e-mailom | ||
+ | |||
+ | '''Cvičiaci''' | ||
+ | |||
+ | * Mgr. Jaroslav Budiš, miestnosť M-25 (oproti akváriu X), [[Image:e-jb.png]] | ||
+ | * Mgr. Martin Králik, miestnosť M-25, [[Image:e-mk.png]] | ||
+ | |||
+ | '''Voľba verzie programovania''' | ||
+ | * Tento predmet (1-INF-127 Programovanie (1) v C/C++) je určený študentom prvého ročníka bakalárskeho študijného programu Informatika a spolu s predmetom 1-INF-166 Programovanie (2) v Jave v letnom semestri tvoria alternatívu k povinným predmetom [http://pascal.input.sk/ 1-INF-126 Programovanie (1) a 1-INF-165 Programovanie (2)]. | ||
+ | * Každý študent sa môže rozhodnúť, či absolvuje 1-INF-127 a 1-INF-166 alebo 1-INF-126 a 1-INF-165. Nie je však možné absolvovať obe verzie programovania ani sa po prvom semestri presunúť z jednej verzie do druhej. | ||
+ | * Predmety 1-INF-126 a 1-INF-165 sa vyučujú v jazyku FreePascal a majú na našej fakulte už dlhú tradíciu. Predmety 1-INF-127 a 1-INF-166 budú vyučované v jazykoch C resp. C++ a Java. Výhodou je, že tieto jazyky využijete aj v ďalších nadväzujúcich predmetoch (Systémové programovanie, Programovanie (3) a podobne) a sú to aj jazyky využívané v praxi. Nevýhodu je, že sa po prvom semestri budete musieť preorientovať na iný jazyk. | ||
+ | |||
+ | '''Ciele predmetu 1-INF-127''' | ||
+ | * Naučiť sa algoritmicky uvažovať, písať kratšie programy a hľadať v nich chyby, porozumieť existujúcemu kódu | ||
+ | * Oboznámiť sa so základnými programovými a dátovými štruktúrami jazyka C resp. C++, nie je však nutne so všetkými črtami týchto jazykov | ||
+ | ** Cykly, podmienky, premenné a ich typy, funkcie a odovzdávanie parametrov, polia, smerníky, reťazce, súbory | ||
+ | * Oboznámiť sa s niektorými základnými algoritmami a dátovými štruktúrami | ||
+ | ** Triedenia, spájané zoznamy, hašovacie tabuľky, stromy, aritmetické výrazy, rad a zásobník, rekurzia, prehľadávanie, vyfarbovanie | ||
+ | * Aj štruktúry, ktoré sú hotové v C++ knižniciach, si budeme programovať sami, aby sme videli, čo sa za nimi skrýva | ||
+ | |||
+ | '''Literatúra''' | ||
+ | * Predmet sa nebude striktne riadiť žiadnou učebnicou. Prehľad preberaných tém a stručné poznámky nájdete na stránke predmetu, doporučujeme Vám si na prednáškach a cvičeniach robiť vlastné poznámky. | ||
+ | * Pri štúdiu Vám môžu pomôcť knihy o jazykoch C a C++, o programovaní všeobecne a o algoritmoch preberaných na prednáške. Tu je výber z vhodných titulov, ktoré sú k dispozícii na prezenčné štúdium vo fakultnej knižnici: | ||
+ | ** Prokop: Algoritmy v jazyku C a C++ praktický pruvodce, Grada 2008, I-INF-P-26 | ||
+ | ** Sedgewick: Algorithms in C. Parts 1-4 I-INF-S-43/I-IV | ||
+ | ** Kochan: Programming in C, 2005 D-INF-K-7a | ||
+ | * Referenčnú príručku k jazyku C++ nájdete napríklad na tejto webstránke: http://cplusplus.com/ | ||
+ | |||
+ | '''Priebeh semestra''' | ||
+ | * Na prednáškach budeme preberať obsah predmetu. Prednášky budú štyri vyučovacie hodiny do týždňa. | ||
+ | * Cvičenia budú dve vyučovacie hodiny do týždňa v počítačovej učebni a ich cieľom je aktívne si precvičiť učivo. Na začiatku cvičenia bude krátka diskusia o prípadných nejasnostiach ohľadom materiálu z minulého cvičenia. Potom nasleduje rozcvička (krátky test) písaný na papieri. Ďalšou časťou cvičenia je precvičovanie príkladov k predchádzajúcim prednáškam (spoločne alebo individuálne). Na konci cvičenia spravidla budete môcť začať pracovať na domácej úlohe, pričom cvičiaci Vám v prípade potreby odpovie na Vaše otázky. | ||
+ | * Domáce úlohy navrhujeme tak, aby Vám ich riešenie pomohlo osvojiť si a precvičiť si učivo, čím sa okrem iného pripravujete aj na záverečnú skúšku. Okrem tohto sú za domáce úlohy body do záverečného hodnotenia. Najviac sa naučíte, ak sa Vám domácu úlohu podarí samostatne vyriešiť, ale ak sa vám to napriek vášmu usilu nedarí, neváhajte sa spýtať o pomoc prednášajúcich alebo cvičiacich. Možno s malou radou od nás sa Vám podarí úlohu spraviť. Treba však na domácej úlohe začať pracovať v predstihu, aby ste nás v prípade problémov stihli kontaktovať. | ||
+ | * Cieľom vyučujúcich tohto predmetu je vás čo najviac naučiť, ale musíte aj vy byť aktívni partneri. Ak Vám na prednáške alebo cvičení nie je niečo jasné, spýtajte sa. Môžete nám klásť tiež otázky počas našich konzultačných hodín alebo emailom. Ak sa dostanete do väčších problémov s plnením študijných povinností, poraďte sa s vyučujúcimi alebo s tútorom, ako tieto problémy riešiť. | ||
+ | * 40% známky dostávate za prácu cez semester, preto netreba nechávať štúdium učebnej látky až na skúškové obdobie. | ||
+ | =Zimný semester, pravidlá= | ||
+ | ==Známkovanie== | ||
+ | * 20% známky je na základe rozcvičiek, ktoré sa píšu na (takmer) každom cvičení | ||
+ | * 20% známky je za domáce úlohy | ||
+ | * 30% známky je za záverečný písomný test | ||
+ | * 30% známky je za praktickú skúšku pri počítači | ||
+ | Pozor, body získavané za jednotlivé príklady nezodpovedajú priamo percentám záverečnej známky. Body za každú formu známkovania sa preváhujú tak, aby maximálny získateľný počet zodpovedal váham uvedených vyššie. Úlohy označené ako bonusové sa nerátajú do maximálneho počtu získateľných bodov v danej aktivite. | ||
+ | |||
+ | ==Stupnica== | ||
+ | * Na úspešné absolvovanie predmetu je potrebné splniť nasledovné tri podmienky: | ||
+ | ** Získať aspoň 50% bodov v celkovom hodnotení | ||
+ | ** Získať aspoň 50% zo záverečného písomného testu | ||
+ | ** Získať aspoň 50% zo skúšky | ||
+ | * Ak niektorú z týchto troch podmienok nesplníte, dostávate známku Fx. | ||
+ | * V prípade úspešného absolvovania predmetu získate známku podľa bodov v celkovom hodnotení takto: | ||
+ | ::: A: 90% a viac, B:80...89%, C: 70...79%, D: 60...69%, E: 50...59% | ||
+ | |||
+ | ==Rozcvičky== | ||
+ | * Rozcvičky sú krátke testy (cca 15 minút), ktoré sa píšu na začiatku (takmer) každého cvičenia. Za každú rozcvičku môžete získať najviac 5 bodov. | ||
+ | * Pri rozcvičke môžete použiť ľubovoľné písomné materiály (poznámky, knihy,...), nie však počítače a iné elektronické pomôcky. Počas rozcvičky nie je možné zdieľať materiály so spolužiakmi. | ||
+ | * Ak bude počas semestra celkovo ''N'' rozcvičiek, do výslednej známky sa vám zaráta iba ''N-2'' najlepších, t.j. dve rozcvičky, na ktorých ste získali najmenej bodov (alebo ste sa ich ani nezúčastnili) sa vám škrtajú. | ||
+ | |||
+ | ==Domáce úlohy== | ||
+ | * Domáce úlohy budú vypisované takmer každý týždeň. Maximálny počet bodov za domácu úlohu bude uvedený v zadaní a bude sa pohybovať spravidla v rozsahu 10-20 bodov podľa náročnosti úlohy. | ||
+ | * Domáce úlohy treba odovzdať elektronicky pomocou systému Moodle do termínu určeného v zadaní. Neskoršie odovzdané úlohy nebudú akceptované. | ||
+ | * Niektoré týždne budú vypísané aj špeciálne bonusové domáce úlohy, za ktoré môžete získať body navyše alebo dohnať body stratené na iných domácich úlohách. Bonusové úlohy sú však náročnejšie. Body za bonusovú úlohu môžete dostať iba ak máte základnú časť úlohy správne. | ||
+ | * Program, ktorý odovzdáte ako domácu úlohu by mal byť skompilovateľný a spustiteľný v prostredí používanom na cvičeniach. Budeme kontrolovať správnosť celkovej myšlienky, správnosť implementácie ale body môžete stratiť aj za neprehľadný štýl. | ||
+ | |||
+ | ==Záverečný písomný test== | ||
+ | * Záverečný test bude trvať 90 minút a bude obsahovať úlohy podobné tým, ktoré sa riešili na cvičeniach. | ||
+ | * Riadny termín testu sa bude konať v prvom týždni skúškového obdobia, opravný termín neskôr počas skúškového obdobia. | ||
+ | * Pri teste nemôžete používať žiadne pomocné materiály (písomné ani elektronické) okrem povoleného ťaháku v rozsahu jedného listu formátu A4 s ľubovoľným obsahom na oboch stranách. | ||
+ | |||
+ | ==Skúška== | ||
+ | * Na skúške budete riešiť 2 úlohy pri počítači v celkovom trvaní 2-3 hodiny. | ||
+ | * Na skúške nemôžete používať žiadne pomocné materiály okrem povoleného ťaháku v rozsahu jedného listu formátu A4 s ľubovoľným obsahom na oboch stranách. Nebude k dispozícii ani internet. Budete používať rovnaké programátorské prostredie ako na cvičeniach. | ||
+ | * Po skončení skúšky sa koná krátky ústny pohovor s vyučujúcimi, počas ktorého sa prediskutujú programy, ktoré ste odovzdali a uzavrie sa vaša známka. | ||
+ | * Opakovanie skúšky sa riadi študijným poriadkom fakulty. | ||
+ | |||
+ | ==Opravné termíny== | ||
+ | * Máte nárok na dva opravné termíny (ale len v rámci termínov, ktoré sme určili). | ||
+ | * Toto sa týka písomky aj skúšky pri počítači. | ||
+ | ** Účasť na opravnom termíne písomky teda tiež vedie k zápisu známky z predmetu v opravnom termíne. | ||
+ | ** Druhý opravný termín písomky môžu písať len študenti, ktorí už majú absolvovanú skúšku na aspoň 50% bodov a majú šancu úspešne ukončiť predmet (termín určíme v prípade potreby). | ||
+ | * Ak sa zúčastníte opravného termínu, strácate body z predchádzajúceho termínu, aj keby ste na opravnom získali menej bodov. | ||
+ | * Ak po skúške pri počítači máte nárok na známu E alebo lepšiu, ale chceli by ste si známku ešte opraviť, musíte sa dohodnúť so skúšajúcimi pred zapísaním známky do indexu. | ||
+ | * Ak po skúške pri počítači ešte opravujete písomku, je potrebné prísť uzavrieť a zapísať známku v termíne určenom vyučujúcimi. | ||
+ | * Ak sa zo závažných dôvodov (napr. zdravotných, alebo konflikt s inou skúškou) nemôžete zúčastniť termínu skúšky alebo písomky, dajte o tom vyučujúcim vedieť čím skôr. | ||
+ | |||
+ | ==Opisovanie== | ||
+ | * Máte povolené sa so spolužiakmi a ďalšími osobami rozprávať o domácich úlohách a stratégiách na ich riešenie. Kód, ktorý odovzdáte, musí však byť vaša samostatná práca. Je zakázané opisovať kód z literatúry alebo z internetu a ukazovať svoj kód spolužiakom. Domáce úlohy môžu byť kontrolované softvérom na detekciu plagiarizmu. | ||
+ | * Počas rozcvičiek, testov a skúšok môžete používať iba povolené pomôcky a nesmiete komunikovať s žiadnymi osobami okrem vyučujúcich. | ||
+ | * Ak nájdeme prípady opisovania alebo nepovolených pomôcok, všetci zúčastnení študenti získajú za príslušnú domácu úlohu alebo test nula bodov (t.j. aj tí, ktorí dali spolužiakom odpísať). Opakované alebo obzvlášť závažné prípady opisovania budú podstúpené na riešenie dekanovi fakulty. | ||
+ | |||
+ | ==Neprítomnosť== | ||
+ | * Účasť na cvičeniach veľmi silne doporučujeme a v prípade neprítomnosti stratíte body za rocvičky. | ||
+ | * V prípade kratšieho ochorenia alebo iných problémov môžete využiť možnosť, že dve najhoršie rozcvičky sa škrtajú. | ||
+ | * V prípade dlhšieho ochorenia (aspoň dva týždne alebo opakovaná neprítomnosť) alebo iných závažných prekážok sa príďte poradiť s prednášajúcimi o možných riešeniach. Treba tak spraviť čím skôr, nie až spätne cez skúškové. Prineste si potvrdenku od lekára. | ||
+ | |||
+ | ==Možnosti pre pokročilých programátorov== | ||
+ | * Študenti, ktorí už ovládajú väčšiu časť učiva na tento semester, majú možnosť získať známku zmysluplnejším spôsobom, ako písaním ľahkých rozcvičiek a domácich úloh. | ||
+ | |||
+ | '''Test pre pokročilých''' | ||
+ | * V druhom týždni semestra sa bude konať nepovinný test pre pokročilých. Príklady na ňom budú podobné ako na záverečnom teste. | ||
+ | * Ak na test prídete a napíšete ho na menej ako 50%, nezískate žiadne výhody (ako keby ste na test ani neprišli). | ||
+ | * V opačnom prípade za každých celých získaných 10% získavate plný počet bodov z jednej rozcvičky. Napr. ak ste získali 59% z testu, dostanete plný počet bodov z prvých 5 rozcvičiek po opravení testu. Tieto body nie je možné presúvať na iné termíny rozcvičiek. | ||
+ | * Navyše si môžete body z testu pre pokročilých nechať uznať ako body zo záverečného testu. Máte však aj možnosť písať záverečný test so spolužiakmi. | ||
+ | |||
+ | '''Domáce úlohy pre pokročilých''' | ||
+ | * Namiesto bežných domácich úloh, ktoré budú menšie a odovzdávané skoro každý týždeň, ponúkame aj možnosť riešiť 4 väčšie a ťažšie domáce úlohy pre pokročilých. | ||
+ | * Tieto domáce úlohy môžu vyžadovať aj znalosti nepreberané na prednáškach, ktoré si budete musieť doštudovať z odbornej literatúry. | ||
+ | * Bežné a pokročilé DÚ nie je možné striedať, celý semester teda musíte odovzdávať ten istý typ úloh. Výnimkou je DÚ0, ktorú robia všetci študenti. | ||
+ | * Aby ste mohli namiesto bežných úloh robiť pokročilé, potrebujete povolenie od vyučujúcich. Všetci, čo napíšu test pre pokročilých aspoň na 50%, toto povolenie automaticky majú. Ostatní kontaktujte vyučujúce emailom a popíšte svoje programátorské skúsenosti. | ||
+ | |||
+ | ==Nepreberané črty jazykov C a C++== | ||
+ | * Z jazykov C a C++ uvidíme len malú časť. | ||
+ | * Preberané črty týchto jazykov je potrebné ovládať, pre vlastnú potrebu si však môžete v literatúre doštudovať aj ďalšie užitočné príkazy, knižnice a konštrukty. | ||
+ | * Ak je v zadaní uvedené, aké prostriedky máte použiť, držte sa týchto pokynov. | ||
+ | * V opačnom prípade môžete použiť aj nepreberané črty. Aby ste sa vyhli problémom pri opravovaní, je vhodné ich doplniť vysvetľujúcim komentárom. | ||
+ | * Vždy používajte len štandardné súčasti jazykov C a C++ , nie špeciálne knižnice. (Výnimkou sú samozrejme knižnice poskytnuté vyučujúcimi). | ||
+ | * Vaše programy by mali fungovať v prostredí používanom v učebni bez zvláštnych nastavení kompilátora a pod. | ||
+ | =Zimný semester, test a skúška= | ||
+ | Na tejto stránke sú informácie týkajúce sa záverečného písomného testu a praktickej skúšky pri počítači v zimnom semestri. Doporučujeme tiež si preštudovať | ||
+ | * '''[[#Zimný semester, pravidlá|pravidlá predmetu]]''' | ||
+ | * rady a informácie na [[#Prednáška 24|prednáške 24]] | ||
+ | |||
+ | ==Termíny== | ||
+ | Písomný test | ||
+ | * Riadny termín pondelok 17.12. o 10:00 v posluchárni B | ||
+ | * Opravný/náhradný termín utorok 8.1. o 10:00 v akváriu M-VII | ||
+ | |||
+ | Termíny skúšok vždy o 9:00: | ||
+ | * 20.12. | ||
+ | * 10.1. | ||
+ | * 23.1. | ||
+ | * 30.1. (opravný termín) | ||
+ | * 6.2. (2. opravný termín) | ||
+ | Na termín skúšky sa zapisujte v systéme AIS. Ústna časť skúšky sa koná v poobedňajších hodinách ten istý deň. | ||
+ | |||
+ | ==Ukážkové príklady na písomný test== | ||
+ | |||
+ | V texte nižšie je niekoľko príkladov, ktoré sa svojim charakterom a obtiažnosťou podobajú na príklady, aké budú na záverečnej písomke. Tieto ukážkové príklady sú prevažne vybrané z cvičení a prednášok, na skutočnej písomke však budú nové, zatiaľ nepoužité príklady. | ||
+ | |||
+ | * Svoje odpovede si môžete skontrolovať nižšie | ||
+ | |||
+ | * '''Príklad 1:''' Zistite, čo vypíše nasledujúca funkcia, ak ju spustíme ako generuj(a, pocet, 0, 2, 3), pričom polia a a pocet majú dĺžku n=3 a obe sú naplnené nulami. Funkcia vypis(a,n) vypíše prvky poľa a. | ||
+ | ** Ako musíme funkciu opraviť, aby vypisovala všetky usporiadané n-tice čísel z množiny {0,...,n-1}, v ktorých sa každé číslo opakuje najviac k krát? | ||
+ | <pre> | ||
+ | void generuj(int a[], int pocet[], int i, int k, int n) { | ||
+ | if (i == n) { | ||
+ | vypis(a, n); | ||
+ | } else { | ||
+ | for (int x = 0; x < n; x++) { | ||
+ | if (pocet[x]<k) { | ||
+ | a[i] = x; | ||
+ | pocet[x]++; | ||
+ | generuj(a, pocet, i + 1, k, n); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * '''Príklad 2:''' Prepíšte výraz 8 3 4 * + 2 3 + / z postfixovej notácie do bežnej infixovej notácie | ||
+ | |||
+ | * '''Príklad 3:''' Prepíšte výraz ((2+4)/(3*5))/(1-2) do postfixovej a prefixovej notácie | ||
+ | |||
+ | * '''Príklad 4:''' Vyhodnocujeme výraz 8 3 4 * + 2 3 - / v postfixovej notácii algoritmom z prednášky. Aký bude obsah zásobníka v čase, keď začneme spracovávať znamienko +? | ||
+ | |||
+ | * '''Príklad 5:''' Máme zásobník s a rad q, pričom obidve štruktúry uchovávajú dáta typu char. Aký bude ich obsah po nasledujúcej postupnosti príkazov? | ||
+ | <pre> | ||
+ | init(s); | ||
+ | init(q); | ||
+ | push(s, 'A'); | ||
+ | push(s, 'B'); | ||
+ | push(s, 'C'); | ||
+ | enqueue(q, pop(s)); | ||
+ | enqueue(q, pop(s)); | ||
+ | push(s, 'D'); | ||
+ | push(s, dequeue(q)); | ||
+ | </pre> | ||
+ | |||
+ | * '''Príklad 6:''' Máme binárny strom, v ktorom má každý vrchol buď dve deti a v dátovom poli uložený znak '#' alebo nemá žiadne deti a v dátovom poli má uložený znak '*'. Keď tento strom vypíšeme v preorder poradí, dostaneme postupnosť ##*#*** Nakreslite, ako vyzerá tento strom. | ||
+ | |||
+ | * '''Príklad 7:''' Nakreslite binárny vyhľadávací strom, ktorý dostaneme, ak do prázdneho slovníka postupne vkladáme záznamy s kľúčami 3, 4, 1, 2, 5, 6 (v tomto poradí). | ||
+ | |||
+ | * '''Príklad 8:''' Nakreslite lexikografický strom s abecedou {a,b}, do ktorého sme vložili reťazce aba, aaab, baa, bab, ba. Vrcholy, ktoré zodpovedajú niektorému reťazcu zo vstupu, zvýraznite dvojitým krúžkom. | ||
+ | |||
+ | * '''Príklad 9:''' Uvažujme nasledujúcu rekurzívnu funkciu na vyfarbovanie. Predpokladajme, že a je matica s troma riadkami a troma stĺpcami vyplnená nulami, pričom funkciu spustíme na stredné políčko, t.j. stlpec=riadok=1 a nová farba je tiež 1. V akom poradí vyfarbí políčka matice novou farbou? | ||
+ | <pre> | ||
+ | void vyfarbi(int **a, int n, int m, int riadok, int stlpec, int farba) { | ||
+ | /* prefarbi suvislu jednofarebnu oblast obsahujucu | ||
+ | * a[riadok][stlpec] na farbu farba */ | ||
+ | |||
+ | if (a[riadok][stlpec] != farba) { | ||
+ | int stara_farba = a[riadok][stlpec]; | ||
+ | a[riadok][stlpec] = farba; | ||
+ | if (riadok > 0 && a[riadok - 1][stlpec] == stara_farba) { | ||
+ | vyfarbi(a, n, m, riadok - 1, stlpec, farba); | ||
+ | } | ||
+ | if (riadok + 1 < n && a[riadok + 1][stlpec] == stara_farba) { | ||
+ | vyfarbi(a, n, m, riadok + 1, stlpec, farba); | ||
+ | } | ||
+ | if (stlpec > 0 && a[riadok][stlpec - 1] == stara_farba) { | ||
+ | vyfarbi(a, n, m, riadok, stlpec - 1, farba); | ||
+ | } | ||
+ | if (stlpec + 1 < m && a[riadok][stlpec + 1] == stara_farba) { | ||
+ | vyfarbi(a, n, m, riadok, stlpec + 1, farba); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * '''Príklad 10:''' Napíšte funkciu vyhod(linkedList &z), ktorá z jednosmerného spájaného zoznamu vyhodí všetky záznamy, v ktorých má položka data nulovú hodnotu. Pozor, takéto záznamy sa môžu vyskytovať aj na začiatku zoznamu. Vyhodené položky zoznamu treba odalokovať. | ||
+ | |||
+ | * '''Príklad 11:''' Napíšte funkciu dvojicky(node *root), ktorá spočíta počet všetkých vnútorných vrcholov v strome s koreňom root takých, že ich ľavé aj pravé dieťa majú v svojom dátovom poli uloženú tú istú hodnotu. | ||
+ | |||
+ | * '''Príklad 12:''' Nasledujúci program načíta od užívateľa počet kruhov, zoznam údajov pre jednotlivé kruhy (celočíselné súradnice a polomer), posunie každý kruh o 10 nižšie a zase kruhy vypíše. Doplňte do programu chýbajúce časti vyznačené čiarami (typy premenných, parametre a návratové typy funkcií). | ||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | struct kruh { | ||
+ | ________________ | ||
+ | }; | ||
+ | |||
+ | _______ posunKruh(__________) { | ||
+ | k.y-=10; | ||
+ | } | ||
+ | |||
+ | _______ nacitajKruhy(__________) { | ||
+ | _________ a; | ||
+ | a = new kruh[n]; | ||
+ | for(int i=0; i<n; i++) { | ||
+ | cin >> a[i].x >> a[i].y >> a[i].r; | ||
+ | } | ||
+ | return a; | ||
+ | } | ||
+ | |||
+ | ______ vypisKruhy(________________) { | ||
+ | for(int i=0; i<n; i++) { | ||
+ | cout << " " << a[i].x << " " << a[i].y << " " << a[i].r << endl; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | _______ n; | ||
+ | _______ a; | ||
+ | cin >> n; | ||
+ | a = nacitajKruhy(n); | ||
+ | for(int i=0; i<n; i++) { | ||
+ | posunKruh(a[i]); | ||
+ | } | ||
+ | vypisKruhy(a, n); | ||
+ | delete[] a; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * '''Príklad 13:''' Funkcia jeRastuci kontroluje, či sa hodnoty v spájanom jednosmernom zozname zvyšujú v smere od začiatku ku koncu zoznamu, t.j. či každý prvok je väčší ako jeho predchodca. Ak áno, vráti true, inak vráti false. Doplňte podmienky na podčiarknuté miesta tak, aby funkcia správne fungovala. V prípade, že zoznam je prázdny alebo obsahuje jeden prvok, odpoveď má byť true. | ||
+ | <pre> | ||
+ | struct item { | ||
+ | int data; | ||
+ | item* next; | ||
+ | }; | ||
+ | |||
+ | struct zoznam { | ||
+ | item* zaciatok; | ||
+ | }; | ||
+ | |||
+ | bool jeRastuci(zoznam &z) { | ||
+ | item *v = z.zaciatok; | ||
+ | while(____________) { | ||
+ | if(_____________) { | ||
+ | return false; | ||
+ | } | ||
+ | v = v->next; | ||
+ | } | ||
+ | return true; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * '''Príklad 14:''' Uvažujme funkciu na triedenie vkladaním uvedenú nižšie. | ||
+ | ** Koľkokrát sa vykoná riadok označený (**) na vstupnom poli (5,2,3,4,1)? | ||
+ | ** Koľkokrát sa vykoná riadok označený (**) na vstupnom poli dĺžky n, ktoré je celé utriedené okrem toho, že najmenší a najväčší prvok sú vymenené teda (n,2,3,4,...,n-2,n-1,1)? Počet vykonaní zapíšte ako funkciu od dĺžky poľa n. | ||
+ | <pre> | ||
+ | void insertionSort(int a[], int n) { | ||
+ | /* usporiadaj prvky v poli a od najmenšieho po najväčší */ | ||
+ | |||
+ | for (int i = 1; i < n; i++) { | ||
+ | int prvok = a[i]; | ||
+ | int kam = i; | ||
+ | while (kam > 0 && a[kam - 1] > prvok) { | ||
+ | a[kam] = a[kam - 1]; // (**) | ||
+ | kam--; | ||
+ | } | ||
+ | a[kam] = prvok; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Vzorové riešenia ukážkových príkladov na písomný test== | ||
+ | * '''Príklad 1:''' funkcia vypíše tri trojice: 0 0 1, 0 0 2, 0 1 2. Nevypisuje to čo má, lebo po vynorení z rekurzie nezníži od pocet[x], aj keď hodnota a[i] bude zmenená z x na x+1. Tu je funkcia po oprave: | ||
+ | <pre> | ||
+ | void generuj(int a[], int pocet[], int i, int k, int n) { | ||
+ | if (i == n) { | ||
+ | vypis(a, n); | ||
+ | } else { | ||
+ | for (int x = 0; x < n; x++) { | ||
+ | if (pocet[x]<k) { | ||
+ | a[i] = x; | ||
+ | pocet[x]++; | ||
+ | generuj(a, pocet, i + 1, k, n); | ||
+ | pocet[x]--; /* pridany prikaz */ | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | * '''Príklad 2:''' (8+3*4)/(2+3) | ||
+ | * '''Príklad 3:''' postfix 2 4 + 3 5 * / 1 2 - / prefix: / / + 2 4 * 3 5 - 1 2 | ||
+ | * '''Príklad 4:''' na zásobníku budú čísla 8 a 12 (8 je na spodku zásobníka). Číslo 12 vzniklo vynásobením 3 a 4. | ||
+ | * '''Príklad 5:''' na zásobníku budú znaky A, D, C (A na spodku zásobníka), v rade bude písmeno B | ||
+ | * '''Príklad 6:''' | ||
+ | <pre> | ||
+ | # | ||
+ | / \ | ||
+ | # * | ||
+ | /\ | ||
+ | * # | ||
+ | /\ | ||
+ | * * | ||
+ | </pre> | ||
+ | * '''Príklad 7:''' | ||
+ | <pre> | ||
+ | 3 | ||
+ | / \ | ||
+ | 1 4 | ||
+ | \ \ | ||
+ | 2 5 | ||
+ | \ | ||
+ | 6 | ||
+ | </pre> | ||
+ | * '''Príklad 8:''' (namiesto dvojiteho krúžku používame *) | ||
+ | <pre> | ||
+ | . | ||
+ | / \ | ||
+ | / \ | ||
+ | / \ | ||
+ | a b | ||
+ | / \ / | ||
+ | a b a* | ||
+ | / / / \ | ||
+ | a a* a* b* | ||
+ | / | ||
+ | b* | ||
+ | </pre> | ||
+ | * '''Príklad 9:''' do každého políčka sme vpísali poradové číslo, kedy bude vyfarbené: | ||
+ | <pre> | ||
+ | 3 2 9 | ||
+ | 4 1 8 | ||
+ | 5 6 7 | ||
+ | </pre> | ||
+ | * '''Príklad 10:''' Jedna možnosť je použiť dvojitý smerník, ktorý môže ukazovať buď na premennú zaciatok v zozname alebo na premennú next v niektorom jeho prvku. | ||
+ | <pre> | ||
+ | void vyhod(zoznam &z) { | ||
+ | /* vytvorime si smernik na miesto, | ||
+ | * kde je ulozeny smenrik na dalsi prvok*/ | ||
+ | item **smernik = &(z.zaciatok); | ||
+ | /* kym nie sme na konci zoznamu */ | ||
+ | while((*smernik)!=NULL) { | ||
+ | /* dalsi prvok je nula, zmazeme ju a prevesime zvysok zoznamu */ | ||
+ | if((*smernik)->data==0) { | ||
+ | item *remove = *smernik; | ||
+ | (*smernik) = (*smernik)->next; | ||
+ | delete remove; | ||
+ | } | ||
+ | /* dalsi prvok nie je nula, posunieme smernik */ | ||
+ | else { | ||
+ | smernik = &((*smernik)->next); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Druhá možnosť je použiť dva cykly: jedným mažeme nuly na začiaktu a druhým mažeme nuly vo zvyšku zoznamu. | ||
+ | <pre> | ||
+ | void vyhod(zoznam &z) { | ||
+ | /* vyhadzujeme nuly na zaciatku */ | ||
+ | while (z.zaciatok != NULL && z.zaciatok->data == 0) { | ||
+ | item * remove = z.zaciatok; | ||
+ | z.zaciatok = remove->next; | ||
+ | delete remove; | ||
+ | } | ||
+ | /* node bude ukazovat vzdy na nenulovy prvok, | ||
+ | * kontrolujeme prvok za nim */ | ||
+ | item * node = z.zaciatok; | ||
+ | while (node != NULL && node->next != NULL) { | ||
+ | if (node->next->data == 0) { | ||
+ | item * remove = node->next; | ||
+ | node->next = remove->next; | ||
+ | delete remove; | ||
+ | } | ||
+ | else { | ||
+ | node = node->next; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | * '''Príklad 11:''' | ||
+ | <pre> | ||
+ | int dvojicky(node *root) { | ||
+ | /* prazdny strom neobsahuje dvojicky */ | ||
+ | if(root == NULL) return 0; | ||
+ | |||
+ | int result = 0; | ||
+ | /* ak su deti korena dvojicky, pricitaj 1*/ | ||
+ | if(root->left != NULL && root->right != NULL | ||
+ | && root->left->data == root->right->data) { | ||
+ | result++; | ||
+ | } | ||
+ | /* spocitaj dvojicky v lavom a pravom podstrome */ | ||
+ | result += dvojicky(root->left); | ||
+ | result += dvojicky(root->right); | ||
+ | return result; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * '''Príklad 12:''' | ||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | struct kruh { | ||
+ | int x, y, r; | ||
+ | }; | ||
+ | |||
+ | void posunKruh(kruh &k) { | ||
+ | k.y-=10; | ||
+ | } | ||
+ | |||
+ | kruh * nacitajKruhy(int n) { | ||
+ | kruh * a; | ||
+ | a = new kruh[n]; | ||
+ | for(int i=0; i<n; i++) { | ||
+ | cin >> a[i].x >> a[i].y >> a[i].r; | ||
+ | } | ||
+ | return a; | ||
+ | } | ||
+ | |||
+ | void vypisKruhy(kruh *a, int n) { | ||
+ | for(int i=0; i<n; i++) { | ||
+ | cout << " " << a[i].x << " " << a[i].y << " " << a[i].r << endl; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | int n; | ||
+ | kruh * a; | ||
+ | cin >> n; | ||
+ | a = nacitajKruhy(n); | ||
+ | for(int i=0; i<n; i++) { | ||
+ | posunKruh(a[i]); | ||
+ | } | ||
+ | vypisKruhy(a, n); | ||
+ | delete[] a; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * '''Príklad 13:''' | ||
+ | <pre> | ||
+ | bool jeRastuci(zoznam &z) { | ||
+ | item *v = z.zaciatok; | ||
+ | while (v != NULL && v->next != NULL) { | ||
+ | if (v->data >= v->next->data) { | ||
+ | return false; | ||
+ | } | ||
+ | v = v->next; | ||
+ | } | ||
+ | return true; | ||
+ | } | ||
+ | </pre> | ||
+ | * '''Príklad 14:''' | ||
+ | ** Čísla 2,3,4 musia preskočiť číslo 5, riadok sa teda pre každé z nich vykoná raz a pre číslo 1 sa vykoná 4 krát, spolu teda 7 krát. | ||
+ | ** Čísla 2,3,4,...,n-2,n-1 musia preskočiť číslo n, riadok sa teda pre každé z nich vykoná raz a pre číslo 1 sa vykoná n-1 krát. Spolu sa teda riadok vykoná n-2+n-1=2n-3 krát. | ||
+ | |||
+ | ==Ukážkové príklady na skúšku pri počítači== | ||
+ | |||
+ | ===Prvý príklad=== | ||
+ | |||
+ | Vo vstupnom súbore matice.txt sú dve matice celých čísel. Každá matica má na prvom riadku počet riadkov ''m'' a počet stĺpcov ''n''. Nasleduje samotná matica v ''m'' riadkoch, pričom každý obsahuje ''n'' čísel oddelených medzerami. Matice sú oddelené voľným riadkom. | ||
+ | |||
+ | Úlohou je vypísať súčet týchto dvoch matíc. V algebre spravidla sčitujeme matice rovnakého rozmeru, vo výslednej matici ''C'' je každé | ||
+ | políčko súčtom zodpovedajúcich políčok vo vstupných maticiach ''A'' a ''B''. V tomto zadaní ale môžeme mať aj matice rôznych rozmerov. V tom prípade matice najskôr rozšírime na spoločný rozmer. Ak majú napríklad rôzny počet riadkov, doplníme na spodok matice s menším počtom riadkov riadky vyplnené nulami tak, aby mala rovnaký počet riadkov ako druhá matica. Podobne pri rôznom počte stĺpcov pridávame na pravý okraj jednej matice stĺpce vyplnené nulami. | ||
+ | |||
+ | Uvažujme napríklad vstup s maticami rozmerov 2x1 a 1x4: | ||
+ | <pre> | ||
+ | 2 1 | ||
+ | 5 | ||
+ | 6 | ||
+ | |||
+ | 1 4 | ||
+ | 1 2 3 4 | ||
+ | </pre> | ||
+ | Po rozšírení budú mať obidve matice dva riadky a štyri stĺpce, budú teda vyzerať nasledovne: | ||
+ | ::<math> | ||
+ | A=\left(\begin{array}{llll} | ||
+ | 5 & 0 & 0 & 0 \\ | ||
+ | 6 & 0 & 0 & 0 \\ | ||
+ | \end{array}\right) | ||
+ | \qquad | ||
+ | B=\left(\begin{array}{llll} | ||
+ | 1 & 2 & 3 & 4 \\ | ||
+ | 0 & 0 & 0 & 0 \\ | ||
+ | \end{array}\right) | ||
+ | </math> | ||
+ | a ich súčet bude | ||
+ | ::<math> | ||
+ | C=\left(\begin{array}{llll} | ||
+ | 6 & 2 & 3 & 4 \\ | ||
+ | 6 & 0 & 0 & 0 \\ | ||
+ | \end{array}\right) | ||
+ | </math> | ||
+ | |||
+ | Tento súčet matíc vypíšte do súboru sucet.txt v rovnakom formáte ako matice na vstupe, teda prvý riadok obsahuje rozmery matice a ďalej idú jednotlivé riadky matice s číslami oddelenými medzerami. Nedávajte medzeru pred prvé ani za posledné číslo v riadku. Pre uvedený príklad vstupu teda dostaneme výstup | ||
+ | <pre> | ||
+ | 2 4 | ||
+ | 6 2 3 4 | ||
+ | 6 0 0 0 | ||
+ | </pre> | ||
+ | |||
+ | V programe nepoužívajte polia konštantných veľkostí, program by mal vedieť spracovať ľubovoľné dáta, ktoré sa zmestia do pamäte (ak treba, | ||
+ | alokujte polia dynamicky alebo použite štruktúry, ktoré menia veľkosť podľa potreby). Môžete predpokladať, že vstupný súbor existuje a má | ||
+ | správny formát. | ||
+ | |||
+ | ===Druhý príklad, verzia A=== | ||
+ | |||
+ | Tento príklad je prevzatý z prednášky, na skúške budú príklady, ktoré doteraz neboli použité. | ||
+ | |||
+ | Úlohou je napísať program, ktorý bude riešiť hlavolam Sudoku. V tomto hlavolame máme danú plochu 9x9 políčok, pričom niektoré sú prázdne, iné obsahujú číslo z množiny {1..9}. Plocha je rozdelená do 9 štvorcov 3x3. Cieľom je doplniť čísla do všetkých prázdnych políčok tak, aby v každom riadku plochy, v každom stĺpci plochy a v každom štvorci 3x3 bola každá cifra {1..9} práve raz. | ||
+ | |||
+ | Tu je príklad hlavolamu aj s naznačeným rozdelením plochy na štvorce 3x3. Bodky označujú prázdne políčka. | ||
+ | <pre> | ||
+ | . 3 . | . 7 . | . . . | ||
+ | 6 . . | 1 9 5 | . . . | ||
+ | . 9 8 | . . . | . 6 . | ||
+ | --------------------- | ||
+ | 8 . . | . 6 . | . . 3 | ||
+ | 4 . . | 8 . 3 | . . 1 | ||
+ | . . . | . 2 . | . . 6 | ||
+ | --------------------- | ||
+ | . 6 . | . . . | 2 8 . | ||
+ | . . . | 4 . 9 | . . 5 | ||
+ | . . . | . 8 . | . 7 . | ||
+ | </pre> | ||
+ | |||
+ | Náš program dostane vstup ako maticu 9x9 čísel, pričom nuly označujú prázdne políčka. Cieľom je vypísať na konzolu všetky riešenia hlavolamu, pričom každé riešenie je matica 9x9 a za ňou voľný riadok. Nakoniec má program vypísať celkový počet riešení hlavolamu. Matica je zadaná v súbore sudoku.txt | ||
+ | Príklad vstupu a výstupu: | ||
+ | <pre> | ||
+ | Vstup: | ||
+ | 0 3 0 0 7 0 0 0 0 | ||
+ | 6 0 0 1 9 5 0 0 0 | ||
+ | 0 9 8 0 0 0 0 6 0 | ||
+ | 8 0 0 0 6 0 0 0 3 | ||
+ | 4 0 0 8 0 3 0 0 1 | ||
+ | 0 0 0 0 2 0 0 0 6 | ||
+ | 0 6 0 0 0 0 2 8 0 | ||
+ | 0 0 0 4 0 9 0 0 5 | ||
+ | 0 0 0 0 8 0 0 7 0 | ||
+ | |||
+ | Vystup: | ||
+ | 5 3 4 6 7 8 9 1 2 | ||
+ | 6 7 2 1 9 5 3 4 8 | ||
+ | 1 9 8 3 4 2 5 6 7 | ||
+ | 8 5 9 7 6 1 4 2 3 | ||
+ | 4 2 6 8 5 3 7 9 1 | ||
+ | 7 1 3 9 2 4 8 5 6 | ||
+ | 9 6 1 5 3 7 2 8 4 | ||
+ | 2 8 7 4 1 9 6 3 5 | ||
+ | 3 4 5 2 8 6 1 7 9 | ||
+ | |||
+ | Pocet rieseni: 1 | ||
+ | </pre> | ||
+ | |||
+ | Program nižšie načíta maticu a obsahuje aj funkciu na výpis riešenia. Doprogramujte rekurzívnu funkciu generuj a ďalšie pomocné funkcie (najdiVolne a moze). Vaša rekurzívna funkcia by mala postupovať nasledovne: | ||
+ | * Pomocou funkcie najdiVolne nájde na ploche prázdne políčko, ak také nie je, vypíše riešenie a skončí. | ||
+ | * Do prázdneho políčka skúša vložiť čísla 1...9 a testuje, či nenastane konflikt v riadku, stĺpci alebo štvorci. Túto kontrolu robí pomocou funkcie moze. | ||
+ | * Vždy, keď niektoré číslo sedí, zavolá sa rekurzívne na vyplnenie zvyšných bielych miest. | ||
+ | V prípade potreby navrhnite a naprogramujte aj ďalšie pomocné funkcie. | ||
+ | |||
+ | <pre> | ||
+ | #include <cstdio> | ||
+ | |||
+ | void vypis(int **a) { | ||
+ | /* vypis riesenia sudoku */ | ||
+ | for (int i = 0; i < 9; i++) { | ||
+ | for (int j = 0; j < 9; j++) { | ||
+ | printf(" %d", a[i][j]); | ||
+ | } | ||
+ | printf("\n"); | ||
+ | } | ||
+ | printf("\n"); | ||
+ | } | ||
+ | |||
+ | void najdiVolne(int **a, int &riadok, int &stlpec) { | ||
+ | /* najdi volne policko na ploche a uloz jeho suradnice | ||
+ | * do premennych riadpk a stlpec. Ak nie je, uloz do oboch | ||
+ | * premennych hodnotu -1. */ | ||
+ | |||
+ | |||
+ | } | ||
+ | |||
+ | bool moze(int **a, int riadok, int stlpec, int hodnota) { | ||
+ | /* Mozeme ulozit danu hodnotu na dane policko? | ||
+ | * Da sa to, ak riadok, stlpec, ani stvorec nema | ||
+ | * tuto hodnotu este pouzitu. */ | ||
+ | } | ||
+ | |||
+ | int generuj(int **a) { | ||
+ | /* mame ciastocne vyplnenu plochu sudoku, | ||
+ | * chceme najst vsetky moznosti, ako ho dovyplnat | ||
+ | * a vratit ich pocet. */ | ||
+ | |||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | FILE *f = fopen("sudoku.txt", "r"); | ||
+ | |||
+ | /* alokujeme a nacitame 2D maticu so vstupom */ | ||
+ | int **a = new int *[9]; | ||
+ | for (int i = 0; i < 9; i++) { | ||
+ | a[i] = new int[9]; | ||
+ | } | ||
+ | for (int i = 0; i < 9; i++) { | ||
+ | for (int j = 0; j < 9; j++) { | ||
+ | fscanf(f, "%d", &(a[i][j])); | ||
+ | } | ||
+ | } | ||
+ | fclose(f); | ||
+ | |||
+ | /* rekurzivne prehladavanie s navratom */ | ||
+ | int pocet = generuj(a); | ||
+ | |||
+ | /* vypis riesenia */ | ||
+ | printf("Pocet rieseni: %d\n", pocet); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Druhý príklad, verzia B=== | ||
+ | |||
+ | Tento príklad je prevzatý z cvičení, na skúške budú príklady, ktoré doteraz neboli použité. | ||
+ | |||
+ | Napíšte program, ktorý udržuje množinu celých čísel, pričom od užívateľa jeden po druhom načítava príkazy, ktoré aj hneď aj vykonáva. Každý príkaz pozostáva z jednopísmenového kódu a z celočísleného parametra, ktoré užívateľ zadá na jednom riadku. Príkazy sú štyroch typov: | ||
+ | * Príkaz s kódom 'I' vloží zadané číslo do množiny (na začiatku programu je množina prázdna). Vypíše buď reťazec OK, ak sa podarilo číslo vložiť, alebo reťazec ERR, ak už číslo v množine bolo. | ||
+ | * Príkaz s kódom 'R' dostane ako parameter prvok x a zistí, koľký v utriedenom poradí tento prvok je v rámci množiny. Ak zadané číslo nie je z množiny, vypíše reťazec ERR, v opačnom prípade vypíše výsledok, ktorý by mal byť číslo od 1 po počet prvkov množiny. | ||
+ | * Príkaz s kódom 'S' nájde k-te najmenšie číslo v množine, pričom k je zadaný parameter, ktorý by mal byť v rozsahu od 1 po počet prvkov množiny. Ak k nie je v tomto rozsahu, program vypíše reťazec ERR, v opačnom prípade vypíše nájdený prvok. | ||
+ | * Príkaz s kódom 'E' ukončí program, parameter ignoruje. | ||
+ | |||
+ | Príklad: | ||
+ | <pre> | ||
+ | I 20 | ||
+ | OK | ||
+ | I 20 | ||
+ | ERR | ||
+ | I 10 | ||
+ | OK | ||
+ | R 20 | ||
+ | 2 | ||
+ | S 2 | ||
+ | 20 | ||
+ | R 30 | ||
+ | ERR | ||
+ | E 0 | ||
+ | </pre> | ||
+ | |||
+ | Tento problém budeme riešiť modifikáciou binárnych vyhľadávacích stromov. Každý vrchol bude obsahovať kľúč typu int, smerník na ľavého a pravého syna, smerník na otca a počet vrcholov v celom podstrome zakorenenom v danom vrchole (položka count). Napríklad pre list by mal byť count 1, pre vrchol s dvoma synmi, ktorí sú obaja listami, by hodnota count mala byť 3. | ||
+ | |||
+ | V programe uvedenom nižšie máte funkcie z prednášky na vkladanie prvku do vyhľadávacieho stromu a jeho vyhľadávanie ako aj základ funkcie main. Vašou úlohou je doprogramovať nasledovné časti kódu: | ||
+ | * Funkcie createLeaf a insert zmeňte tak, aby správne inicalizovali a udržiavali položku count pre všetky vrcholy v strome. | ||
+ | * Funkcie rank a select (pozri nižšie) | ||
+ | * Dopísať spracovanie príkazov R a S do hlavného programu. | ||
+ | Čiastočné body môžete dostať aj ak sa vám podarí spraviť správne iba niektoré z týchto podúloh, nemeňte však celkovú kostru programu. V prípade potreby si napíšte aj ďalšie funkcie, ktoré budete z uvedených funkcií volať. | ||
+ | |||
+ | * Funkcia <tt>int rank(dictionary &d, int key)</tt> má nájsť prvok key v strome a vrátiť, koľký v utriedenom poradí spomedzi iných prvkov v strome je. V tejto funkcii predpokladajte, že hľadaný kľúč sa v strome určite nachádza (prípad, že sa nenachádza doriešte v hlavnom programe). V tejto funkcii využite položku count. Ak totiž pokračujeme v hľadaní v pravom podstrome určitého vrcholu v, tak vrchol v aj všetky vrcholy v jeho ľavom podstrome sú pred hľadaným prvkom. A aj bez toho, aby sme ľavý podstrom celý prechádzali, vieme koľko prvkov v ňom je. | ||
+ | |||
+ | * Funkcia <tt>int select(dictionary &d, int k)</tt> má vrátiť k-ty najmenší prvok vo vyhľadávacom strome. Aj v tejto funkcii využite položku count. Ak je totiž k najviac rovné počtu vrcholov v ľavom podstrome, k-ty najmenší prvok musí byť niekde v tomto podstrome. Ak je naopak k veľké, hľadaný prvok musí byť v pravom podstrome a vieme spočítať aj to, koľký najmenší v rámci tohto podstromu je. | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | #include <cassert> | ||
+ | using namespace std; | ||
+ | |||
+ | struct node { | ||
+ | /* vrchol binarneho vyhladavacieho stromu */ | ||
+ | int key; /* kluc podla ktoreho vyhladavame */ | ||
+ | int count; /* pocet vrcholov v podstrome */ | ||
+ | node * parent; /* otec vrchola */ | ||
+ | node * left; /* lavy syn */ | ||
+ | node * right; /* pravy syn */ | ||
+ | }; | ||
+ | |||
+ | struct dictionary { | ||
+ | node *root; | ||
+ | }; | ||
+ | |||
+ | void init(dictionary &d) { | ||
+ | /* inicializuje prazdny slovnik */ | ||
+ | d.root = NULL; | ||
+ | } | ||
+ | |||
+ | node * createLeaf(int key, node * parent) { | ||
+ | /* vytvor novy vrchol s danymi hodnotami, obe deti nastav na NULL */ | ||
+ | node *v = new node; | ||
+ | v->key = key; | ||
+ | v->left = NULL; | ||
+ | v->right = NULL; | ||
+ | v->parent = parent; | ||
+ | return v; | ||
+ | } | ||
+ | |||
+ | node * findNode(node *root, int key) { | ||
+ | /* V binarnom vyhladavacom strom s korenom root najdi a vrat | ||
+ | * vrchol s klucom a ak neexistuje, vrat NULL. */ | ||
+ | node * v = root; | ||
+ | while (v != NULL && v->key != key) { | ||
+ | if (key < v->key) { | ||
+ | v = v->left; | ||
+ | } else { | ||
+ | v = v->right; | ||
+ | } | ||
+ | } | ||
+ | return v; | ||
+ | } | ||
+ | |||
+ | void findNode(node *root, int key, node *&v, node *&parent) { | ||
+ | /* Do v uloz smernik na vrchol s klucom key alebo NULL ak neexistuje. | ||
+ | * Do parent uloz otca v, NULL ak neexistuje a ak key nie je v strome | ||
+ | * tak smernik na vrchol, ktory by mal byt otcom pre vrchol | ||
+ | * s hodnotou key.*/ | ||
+ | parent = NULL; | ||
+ | v = root; | ||
+ | while (v != NULL && v->key != key) { | ||
+ | parent = v; | ||
+ | if (key < v->key) { | ||
+ | v = v->left; | ||
+ | } else { | ||
+ | v = v->right; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | bool find(dictionary &d, int key) { | ||
+ | /* Zisti, ci sa v slovniku d nachadza kluc key. */ | ||
+ | node *v = findNode(d.root, key); | ||
+ | if (v != NULL) { | ||
+ | assert(v->key == key); | ||
+ | return true; | ||
+ | } else { | ||
+ | return false; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void insert(dictionary &d, int key) { | ||
+ | /* Do slovnika d vlozi kluc key. | ||
+ | * Predpokladame, ze takyto kluc este v slovniku nie je. */ | ||
+ | if (d.root == NULL) { | ||
+ | /* prazdny strom - treba vytvorit koren */ | ||
+ | d.root = createLeaf(key, NULL); | ||
+ | } else { | ||
+ | node *v; | ||
+ | node *parent; | ||
+ | findNode(d.root, key, v, parent); | ||
+ | /* parent je teraz vrchol, ktoreho syn ma byt novy vrchol */ | ||
+ | assert(v == NULL && parent != NULL); | ||
+ | /* zisti, ci mame byt lave alebo prave dieta otca */ | ||
+ | if (key < parent->key) { | ||
+ | assert(parent->left == NULL); | ||
+ | parent->left = createLeaf(key, parent); | ||
+ | } else { | ||
+ | assert(parent->right == NULL); | ||
+ | parent->right = createLeaf(key, parent); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int rank(dictionary &d, int key) { | ||
+ | /* vrati kolky je key v utriedenom poradi prvkov v strome. | ||
+ | * Predpoklada, ze key sa v strome nachadza. */ | ||
+ | } | ||
+ | |||
+ | int select(dictionary &d, int k) { | ||
+ | /* vrati k-ty najmensi prvok v strome. | ||
+ | * Predpoklada, ze 1 <= k <= celkovy pocet prvkov v strome. */ | ||
+ | } | ||
+ | |||
+ | int main() { | ||
+ | dictionary d; | ||
+ | init(d); | ||
+ | |||
+ | while (true) { | ||
+ | char command; | ||
+ | int param; | ||
+ | cin >> command >> param; | ||
+ | switch (command) { | ||
+ | case 'I': | ||
+ | if (find(d, param)) { | ||
+ | cout << "ERR" << endl; | ||
+ | } else { | ||
+ | insert(d, param); | ||
+ | cout << "OK" << endl; | ||
+ | } | ||
+ | case 'S': | ||
+ | break; | ||
+ | case 'R': | ||
+ | break; | ||
+ | case 'E': return 0; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | =Netbeans= | ||
+ | ==Ako spustiť Netbeans v učebni== | ||
+ | * Po spustení počítača zvoľte Linux a prihláste sa pomocou toho istého mena a hesla, ako používate v systéme AIS | ||
+ | * V ľavom dolnom rohu obrazovky je menu s ponukou programov, v oddelení Development nájdete Netbeans | ||
+ | |||
+ | ==Základy práce v Netbeans== | ||
+ | |||
+ | '''Vytvorenie nového projektu''' | ||
+ | * Každý program v Netbeans potrebuje svoj "projekt", čo je adresár so všetkými potrebnými súbormi. | ||
+ | * V menu zvoľte File, potom New project | ||
+ | * V Categories zvoľte '''C/C++''', v Project: '''C/C++ Application''' | ||
+ | * Na ďalšej obrazovke projekt nejako nazvite a zvoľte do akého adresára sa má uložiť. Doproučujeme cestu na svieťovom disku net, ku ktorému máte prístup zo všetkých počítačov v učebniach, napríklad v adresári /home/x/vasemeno/net/NetBeansProjects | ||
+ | * Stlačte Finish | ||
+ | |||
+ | '''Editovanie programu''' | ||
+ | * V ľavej časti okna máte panel Project, v ktorom nájdite projekt, ktorý ste práve vytvorili. | ||
+ | * V projekte rozbaľte Source Files a nájdete tam main.cpp, ktorý si dvojitým kliknutím otvoríte v editore. Jeho obsah môžete modifikovať alebo celý zmazať a nahradiť programom z prednášky. | ||
+ | * Súbor main.cpp nezabudnite uložiť (menu File, Save, alebo Ctrl-S) | ||
+ | |||
+ | '''Kompilovanie a spúšťanie''' | ||
+ | * V menu Run zvoľte Build main project (F11), program sa skompiluje. Prípadné chyby sa objavia v dolnej časti okna. | ||
+ | * V menu Run zvoľte Run main project (F6), program sa spustí. | ||
+ | * Ak máte naraz otvorených viac projektov, jeden z nich je hlavný, vyznačený hrubým písmom. Kompilovanie a spúšťanie sa aplikuje na hlavný projekt. | ||
+ | ** Ak chcete nastaviť nejaký projekt ako hlavný, kliknite na jeho meno v paneli Project pravým tlačidlom a zvoľte Set as main project | ||
+ | |||
+ | '''Prenášanie programov a odovzdávanie domácich úloh''' | ||
+ | * Pri odovzdávaní domácich úloh odovzdávajte súbor main.cpp s vašim programom (prípadne ďalšie súbory ak to vyžaduje zadanie). Tento súbor nájdete v adresári net/NetBeansProjects/menoprojektu | ||
+ | * Ak pracujete na rôznych počítačoch v rámci FMFI učební, svoje projekty si ukladajte na sieťovom disku net | ||
+ | * Dáta zo sieťového disku si môžete stiahnuť v učebni na USB kľúčik, alebo aj cez sieť z domu prihlásením sa na študentský Linuxový klaster [http://www.st.fmph.uniba.sk/ daVinci] (davinci.fmph.uniba.sk). Na prenos dát môžete použiť napríklad windowsovský program [http://winscp.net/eng/docs/introduction winscp] | ||
+ | * Ak chcete prenášať projekt medzi rôznymi počítačmi, doporučujeme skopírovať iba main.cpp, prípadne ďalšie potrebné súbory. | ||
+ | ** Na druhom počítači vytvoríte nový projekt, nakopírujete main.cpp do jeho adresára. | ||
+ | ** Potom pridáte main.cpp do projektu takto: kliknite pravým tlačidlom na Source Files v paneli Projects, zvoľte Add Existing Item | ||
+ | |||
+ | ==Práca v Netbeans s grafickou knižnicou== | ||
+ | |||
+ | * Stiahnite si [http://compbio.fmph.uniba.sk/vyuka/prog/data knižnicu] vo verzii určenej pre učebňu | ||
+ | ** Stiahnuté súbory libsimpleDraw.a a SimpleDraw.h uložte do adresára NetBeansProjects, v ktorom podadresáre obsahujú jednotlivé projekty | ||
+ | * Pri vytváraní nového projektu je potrebné zvoliť '''C/C++ Qt Application''' namiesto C/C++ Application | ||
+ | * Po vytvorení kliknite pravým tlačidlom na meno projektu v paneli Projects a zvoľte Properties | ||
+ | ** V paneli Categories zvoľte Linker v časti Build, v pravom paneli stlačte tri bodky pri Libraries, potom Add Library File, potom zvoľte súbor libsimpleDraw.a | ||
+ | * Teraz môžete editovať, kompilovať a spúšťať program rovnako ako bez použitie knižnice | ||
+ | |||
+ | '''Kopírovanie projektov''' | ||
+ | * Keď už máte jeden grafický program hotový a chcete si vytvoriť ďalší, môžete vynechať niektoré z krokov uvedených vyššie tým, že si otvoríte starý projekt, v paneli Project kliknete na jeho meno pravým tlačidlom, v menu zvolíte Copy a zadáte nové meno projektu. | ||
+ | * Teraz môžete editovať, kompilovať a spúšťať program bez zadávania ďalších nastavení. | ||
+ | |||
+ | ==Práca s Netbeans na vlastnom počítači== | ||
+ | * Ak máte na počítači nainštalovaný '''Linux''', podľa návodu nižšie si ľahko [[#Inštalácia v Linuxe|nainštalujete Netbeans a ďalšie potrebné súčasti]] (pozri nižšie) | ||
+ | * Ak máte na počítači operačný systém '''Windows''', je možné tiež si nainštalovať Netbeans, o niečo ťažšie je však rozchodiť knižnicu Qt, ktorá je potrebná na použitie našej grafickej knižnice používanej na predmete. | ||
+ | ** Informácia o inštalovaní Netbeans http://netbeans.org/community/releases/69/cpp-setup-instructions.html | ||
+ | ** Odskúšaný návod [[#SimpleDraw vo Windows]]. | ||
+ | * Namiesto toho môžete vo Windows spustiť '''[[#Netbeans vo virtuálnom počítači|virtuálny počítač]]''' so systémom Linux | ||
+ | |||
+ | ===Inštalácia v Linuxe=== | ||
+ | Ak máte na počítači operačný systém '''Linux''', budete potrebovať nainštalovať nasledujúce softvérové balíčky: | ||
+ | * Prostredie netbeans (v učebni máme verziu 6.9.1, mala by však postačovať aj iná verzia) | ||
+ | * Komplilátor g++ | ||
+ | * Debuger gdb | ||
+ | * Knižnicu qt4 (balíček libqt4-dev) | ||
+ | Všetky tieto balíčky existujú napríklad v distribúcii Ubuntu. Ak vo vašej distribúcii nie je k dispozícii balíček pre Netbeans, stiahnite si ho zo stránky http://netbeans.org/downloads/ | ||
+ | |||
+ | Po nainštalovaní týchto balíčkov spustite Netbeans, v menu Tools zvoľte Plugins a pridajte si plugin C/C++. | ||
+ | |||
+ | ====Používanie grafickej knižnice==== | ||
+ | * Stiahnite si verziu [http://compbio.fmph.uniba.sk/vyuka/prog/data knižnice] určenú na kompilovanie. | ||
+ | * Vytvorte si v Netbeans nový projekt typu C/C++ Qt Static Library, nazvite ho simpleDraw | ||
+ | * Do adresára NetBeansProjects/simpleDraw/ rozzipujte stiahnuté súbory | ||
+ | * V projekte simpleDraw kliknite na Source files pravým tlačidlom a zvoľte Add Existing Item, potom medzi súbormi vyberte SimpleDraw.cpp a SimpleDraw.h (viac súborov naraz môžete pridať ak súčasne stlačíte Ctrl a kliknete na meno ďalšieho súboru) | ||
+ | * V projekte simpleDraw kliknite na Resource files pravým tlačidlom a zvoľte Add Existing Item, potom medzi súbormi zvoľte SimpleDrawWindow.cpp, SimpleDrawWindow.h a SimpleDrawWindow.ui | ||
+ | * Spustite Build Main Project | ||
+ | * Niekde v podadresároch adresára NetBeansProjects/simpleDraw/dist by vám mal vzniknúť súbor libsimpleDraw.a. Tento potom môžete použiť na vašom počítači rovnako ako používate jeho verziu pre učebne stiahnutú zo stránky. | ||
+ | |||
+ | ===Netbeans vo virtuálnom počítači=== | ||
+ | * Jedna z možností, ako sa vysporiadať s problémami okolo inštalovania Netbeans a grafickej knižnice na Windowsovom počítači je bežať ho vo virtuálnom serveri s nainštalovaným Linuxom | ||
+ | * Doporučujeme túto možnosť, len ak Váš počítač má aspoň 2G pamäte | ||
+ | * Na cvičeniach môžete získať dva súbory <tt>prog.ovf</tt> a <tt>prog-disk1.vmdk</tt> celkovej veľkosti cca 2G (doneste si veľký USB kľúčik) obsahujúce nainštalovaný virtuálny počítač aj s prostredím Netbeans. | ||
+ | * Potrebujete si stiahnuť aj softvér na spúšťanie virtuálneho počítača, ten získate na stránke https://www.virtualbox.org/ | ||
+ | * Po nainštalovaní softvéru Virtualbox pridáte do neho pridáte virtuálny počítač pomocou možnosti Import appliance, zvolíte prog.ovf (vmkd súbor musí byť v tom istom priečinku) | ||
+ | * Virtuálnemu počítaču môžete nastaviť veľkosť pamäte, alebo zdieľanie priečinkov s vašim počítačom. | ||
+ | * Heslo na prihlasovanie a administrátorské úkony je také isté, aké ste použili pri prihlasovaní sa na predmet v prostredí Moodle (dve slová) | ||
+ | * Na pravom okraji obrazovky je lišta s často používanými programami, vrátane Netbeans a Firefoxu. | ||
+ | |||
+ | =SimpleDraw vo Windows= | ||
+ | == Inštalácia softvéru == | ||
+ | |||
+ | |||
+ | '''Ak nemáme Netbeans''', | ||
+ | stiahneme si ho tu: | ||
+ | http://netbeans.org/downloads/index.html | ||
+ | ([http://download.netbeans.org/netbeans/7.0.1/final/bundles/netbeans-7.0.1-ml-cpp-windows.exe priamy link na inštalátor pre lenivých]) | ||
+ | |||
+ | Mala by stačiť verzia pre C/C++. | ||
+ | |||
+ | |||
+ | |||
+ | '''Ak už Netbeans máme''', tak si skontrolujeme, či v ňom máme plugin pre C++. | ||
+ | To sa dá spraviť skontrolovaním dostupných pluginov tu: | ||
+ | |||
+ | [[Súbor:PROG-WIN-01-menu-plugins.png]] | ||
+ | |||
+ | [[Súbor:PROG-WIN-02-available-plugins.png]] | ||
+ | |||
+ | Ak medzi nimi je, to znamená, že ho nemáme a treba si ho v danom okne doinštalovať. | ||
+ | |||
+ | |||
+ | Po inštalácii Netbeans je ďalším krokom je nainštalovanie '''Qt SDK''' z http://qt.nokia.com/downloads/ | ||
+ | ([http://get.qt.nokia.com/qtsdk/Qt_SDK_Win_online_v1_1_3_en.exe priamy link na inštalátor pre lenivých]). | ||
+ | |||
+ | V prípade inštalácie na počítači s internetom postačí online verzia inštalátora. | ||
+ | |||
+ | |||
+ | Pri inštalácii je dôležité zvoliť správne komponenty. | ||
+ | Budeme potrebovať nasledovné: | ||
+ | |||
+ | [[Súbor:PROG-WIN-03-Qt-SDK-Setup.png]] | ||
+ | |||
+ | |||
+ | Nakoniec je ešte potrebné nainštalovať '''MSYS'''. | ||
+ | |||
+ | ''"MSYS is a collection of GNU utilities such as bash, make, gawk and grep to allow building of applications and programs which depend on traditionally UNIX tools to be present. It is intended to supplement MinGW and the deficiencies of the cmd shell."'' | ||
+ | |||
+ | Sťahujeme odtiaľto: http://downloads.sourceforge.net/mingw/MSYS-1.0.11.exe | ||
+ | |||
+ | Ku koncu inštalácie je nutné odpovedať na dve otázky "yes" a následne vpísať cestu k nainštalovanému MinGW. | ||
+ | |||
+ | Pri použití predvolenej cesty pri inštalácii Qt to má vyzerať takto: | ||
+ | |||
+ | [[Súbor:PROG-WIN-04-MSYS-Installer.png]] | ||
+ | |||
+ | Dôležité je v ceste použiť presne tie lomítka, ktoré sú na obrázku. | ||
+ | |||
+ | == Nastavenie Windows == | ||
+ | Aby nám v Netbeans šlo spúštať konzolové (negrafické programy), | ||
+ | potrebujeme do premennej prostredia PATH pridať cestu k MinGW: | ||
+ | C:\QtSDK\mingw\bin | ||
+ | |||
+ | Objavili sa prípady, kedy bolo do PATH potrebné pridať aj cestuku Qt knižniciam: | ||
+ | C:\QtSDK\Desktop\Qt\4.7.4\mingw\bin | ||
+ | |||
+ | Premenná PATH sa dá nastaviť v pravý klik na tento počítač > properties > | ||
+ | advanced system settings > environment variables > system variables > | ||
+ | variable path > edit. | ||
+ | Na jej konci treba pridať bodkočiarku a danú cestu. | ||
+ | |||
+ | Po úprave PATH je nutné Windows reštartovať. | ||
+ | |||
+ | == Nastavenie Netbeans == | ||
+ | V Netbeans treba nastaviť správne cesty k jednotlivým súčastiam. | ||
+ | Prejdeme preto cez menu do Tools -> Options -> C/C++ a klikneme na "Add...". | ||
+ | |||
+ | Objaví sa dialóg, do ktorého je treba vyplniť cestu k mingw, ktorá pri použití predvolených ciest vyzerá takto: | ||
+ | |||
+ | [[Súbor:PROG-WIN-05-Add-New-Tool-Collection.png]] | ||
+ | |||
+ | |||
+ | Následne ostanú nevyplnené dve cesty - k príkazom make a qmake. | ||
+ | Tie vyplníme nasledovne (za predpokladu predvolených ciest): | ||
+ | |||
+ | [[Súbor:PROG-WIN-06-Tool-Collection-Paths.png]] | ||
+ | |||
+ | |||
+ | |||
+ | == Vytvorenie knižnice == | ||
+ | V Netbeans si vytvoríme nový projekt - Qt Static Library: | ||
+ | |||
+ | [[Súbor:PROG-WIN-07-New-Project.png]] | ||
+ | |||
+ | Po kliknutí na "Next >" nastavíme "Tool Collection" na MinGW. | ||
+ | |||
+ | |||
+ | Zdrojové súbory knižnice si stiahneme tu: http://compbio.fmph.uniba.sk/vyuka/prog/data/simpleDraw.zip | ||
+ | a rozbalíme do priečinku s novovytvoreným projektom. | ||
+ | Následne tieto súbory musíme pridať do projektu tak, aby o tom Netbeans vedel. | ||
+ | Najprv pridáme hlavičkové (.h) súbory: | ||
+ | |||
+ | [[Súbor:PROG-WIN-08-Add-Existing-Item.png]] | ||
+ | |||
+ | [[Súbor:PROG-WIN-09-Select-Item.png]] | ||
+ | |||
+ | |||
+ | Rovnakým spôsobom pridáme zdrojové súbory (.cpp) do Source Files. | ||
+ | |||
+ | Konfiguráciu projektu prepneme z "Debug" na "Release" a celé to skompilujeme stlačením tlačidla s obrázkom kladiva. | ||
+ | |||
+ | [[Súbor:PROG-WIN-10-Build-Main-Project.png]] | ||
+ | |||
+ | O úspechu nás bude informovať konzola v spodnej časti Netbeans hláškou "BUILD SUCCESSFUL (total time: XYs)". | ||
+ | |||
+ | Vytvorenú knižnicu nájdeme v adresári projektu v podadresári "dist\Release\MinGW-Windows", v závislosti od mena nášho projektu sa môže volať napríklad "libsimpleDraw.a" | ||
+ | |||
+ | |||
+ | == Použitie knižnice == | ||
+ | Tak ako na cvikách (Qt Application, pridať library file) | ||
+ | ale miesto "main(void)" treba dať "main(int argc, char** argv)". | ||
+ | |||
+ | =SimpleDraw= | ||
+ | Knižnica SimpleDraw umožňuje zobraziť grafické okno a vykresľovať do neho rôzne geometrické útvary. | ||
+ | * [[#Netbeans|Návod na použitie knižnice v prostredí Netbeans]] | ||
+ | * [http://compbio.fmph.uniba.sk/vyuka/prog/data/ Stiahnutie knižnice] | ||
+ | * Príklady programov na [[#Prednáška 1|prvej prednáške]] | ||
+ | * [http://compbio.fmph.uniba.sk/vyuka/prog/data/SimpleDraw.pdf Manuál ku knižnici] | ||
+ | |||
+ | ==Príkazy na prácu s grafickou plochou== | ||
+ | |||
+ | * Ako prvé musíme vytvoriť grafické okno s určitou veľkosťou plochy príkazom typu <tt>SimpleDraw window(300, 400);</tt> | ||
+ | * V každom programe vytvárajte iba jedno okno. | ||
+ | * Do okna môžeme kresliť príkazmi drawRectangle, drawEllipse, drawLine, drawText. Presný zoznam parametrov každého príkazu nájdete v [http://compbio.fmph.uniba.sk/vyuka/prog/data/SimpleDraw.pdf manuáli]. Príklad: <tt>window.drawRectangle(100, 200, 100, 100);</tt> | ||
+ | * Môžeme vykresľovať aj celé bitmapy načítané napr z .jpg alebo .png súboru, a to príkazom drawPixmap | ||
+ | * Ak chceme vykresľovať mnohouholníky alebo lomené čiary, použijeme skupinu príkazov startPath, lineTo a drawPath alebo drawClosedPath. Pomocou startPath a lineTo postupne vymenujeme vrcholy a pomocou drawPath alebo drawClosedPath čiaru uzavrieme a vykreslíme. | ||
+ | * Pomocou príkazov setPenColor, setBrushColor, unsetBrush, setFontColor vieme nastavovať farbu čiar, písma a vyfarbovania. Farby zadávame buď troma číslami od 0 do 255 určujúcimi intenzitu červenej, zelenej a modrej, alebo názvom, napr. "red" ([http://www.w3.org/TR/SVG/types.html#ColorKeywords zoznam mien farieb]). Príkazom setFontSize nastavujeme veľkosť písma. | ||
+ | * Príkaz showAndClose vykreslí okno a čaká, kým užívateľ stlačí Exit, potom zavrie okno. Príkaz show čaká kým užívateľ stlačí Next, potom môžeme pokračovať vo vykresľovaní. Príkaz wait čaká zadaný počet sekúnd, čo sa dá využiť na spomalenie animácie. | ||
+ | * Príkaz clear vymaže obsah okna. Príkaz removeItem zmaže objekt (napr. čiaru) so zadaným číslom. Každý kresliaci príkaz vráti číslo práve vykresleného objektu, takže si ho stačí uložiť v nejakej premennej pre neskoršie mazanie. | ||
+ | * Príkaz savePng uloží zobrazený obrázok do png súboru. | ||
+ | * Príkazy startDebugging a stopDebugging zapínajú a vypínajú ladiaci mód, v ktorom program čaká na stlačenie Next po vykreslení každej čiary alebo iného objektu. | ||
+ | |||
+ | ==Príkazy na korytnačiu grafiku== | ||
+ | |||
+ | * Pred vytvorením korytnačky musíme vytvoriť grafickú plochu. | ||
+ | * Korytnačka si pamätá svoju polohu a natočenie na ploche. Príkaz forward posunie korytnačku dopredu, príkaz turnLeft ju otočí. | ||
+ | * Ak má korytnačka spustené pero, kreslí pri pohybe čiaru. Toto sa mení príkazmi penUp a penDown. | ||
+ | * Príkazmi show a hide vieme nastaviť, či sa má nasmerovanie korytnačky zobrazovať ako šípka. | ||
+ | * Príkaz setWait umožňuje zapnúť čakanie po každom pohybe, aby sme lepšie videli, ako sa postupne hýbe. | ||
+ | =Prednáška 1= | ||
+ | |||
+ | Pozrite si [[#Zimný semester, úvodné informácie|úvod k predmetu]] a [[#Zimný semester, pravidlá|pravidlá]] | ||
+ | |||
+ | == Čo je programovanie == | ||
+ | |||
+ | ==== Algoritmus ==== | ||
+ | |||
+ | Algoritmus: Postupnosť konečného počtu elementárnych krokov vedúca k vyriešeniu daného typu úlohy | ||
+ | |||
+ | Príklady: | ||
+ | # Ako sčítať dve celé čísla v desiatkovej sústave | ||
+ | # Ako nájsť najväčšieho spoločného deliteľa dvoch čísel | ||
+ | # Ako riešiť Sudoku | ||
+ | |||
+ | ==== Správnosť algoritmu ==== | ||
+ | |||
+ | * Keď vždy dáva správne výsledky. | ||
+ | * Keď vždy skončí. | ||
+ | |||
+ | ==== Program ==== | ||
+ | * Predpis, pomocou ktorého počítač môže vykonávať algoritmus | ||
+ | * Zapísaný v programovacom jazyku | ||
+ | |||
+ | == Programátorské prostredie == | ||
+ | |||
+ | * Na tomto predmete budeme programovať v jazyku '''C++''', budeme však z neho používať len malú časť. | ||
+ | * Budeme používať programátorské prostredie '''NetBeans''', ktoré vám spríjemňuje a zjednodušuje prácu. | ||
+ | * Cvičenia a skúšky budú v operačnom systéme '''Linux''' | ||
+ | |||
+ | * V princípe môžete používať aj iné programátorské prostredia, ale | ||
+ | ** odovzdané programy (DÚ, skúška) musia správne pracovať v prostredí ako na cvičeniach | ||
+ | ** počas skúšky budete mať k dispozícii len to, čo beží v učebniach v Linuxe | ||
+ | |||
+ | * Netbeans a ďalšie potrebné nástroje si môžete nainštalovať zadarmo aj na vašom počítači | ||
+ | ** Pre Windows je inštalácia obtiažnejšia, môžete však spúšťať virtuálny linuxový stroj, ktorý vám poskytneme | ||
+ | ** [[#Netbeans|Návod k práci v prostredí Netbeans]] | ||
+ | |||
+ | ==Prvý program== | ||
+ | |||
+ | * Tradične sa v učebniciach programovania ako prvý uvádza program, ktorý iba vypíše na obrazovku text "Hello world!". Tu je v jazyku C++: | ||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | cout << "Hello world!" << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Samotný text je vypísaný príkazom <tt>cout << "Hello world!" << endl;</tt> | ||
+ | * Všimnite si, že text <tt>Hello world!</tt> sme dali do úvodzoviek, čím poukazujeme na to, že to nie sú príkazy programovacieho jazyka, ale text, s ktorým treba niečo robiť. | ||
+ | * Za príkazom sme dali bodkočiarku, ktorá ho ukončuje. | ||
+ | * O vypisovaní si povieme viac neskôr, ale už teraz môžete vypisovať rôzne texty tým, že zmeníte text medzi úvodzovkami. | ||
+ | |||
+ | * Riadok <tt>int main(void) {</tt> označuje začiatok programu, program ide až po ukončovaciu zloženú zátvorku <tt>}</tt> | ||
+ | * Jazyk C++ sám o sebe neobsahuje príkazy na vypisovanie (<tt>cout <<...</tt>). Na to potrebujeme použiť '''knižnicu''': súbor príkazov, ktoré niekto už naprogramoval a my ich len používame. Prvé dva riadky programu nám umožnia používať štandardnú knižnicu iostream, ktorá je súčasťou C++ a ktorá obsahuje príkazy na vypisovanie. | ||
+ | |||
+ | ===Spúšťanie programu=== | ||
+ | * Na to, aby sme náš program mohli spustiť na počítači, potrebujeme ho najskôr '''skompilovať''', t.j. preložiť do spustiteľného strojového kódu. | ||
+ | * Ako na to, nájdete v [[#Netbeans|návode k práci v prostredí Netbeans]] | ||
+ | * V prostredí Netbeans vieme program aj spustiť, môžeme si ho však aj skopírovať a spúšťať na iných počítačoch nezávisle od Netbeans. | ||
+ | |||
+ | ==Prvý grafický program== | ||
+ | * Občas budeme vykresľovať obrázky pomocou knižnice <tt>SimpleDraw</tt> vytvorenej špeciálne pre tento predmet. (Tu je [[#SimpleDraw|návod na jej používanie]]) | ||
+ | * Nasledujúci program vypíše text <tt>Hello world!</tt> pomocou tejto knižnice. | ||
+ | |||
+ | <pre> | ||
+ | #include "../SimpleDraw.h" | ||
+ | |||
+ | int main(void) { | ||
+ | /* Vytvor obrázok s rozmermi 100x100 pixelov */ | ||
+ | SimpleDraw window(100, 100); | ||
+ | |||
+ | /* Nastav farbu písma na červenú. */ | ||
+ | window.setFontColor("red"); | ||
+ | |||
+ | /* Vypíš text vystredený na súradniciach 50,50. */ | ||
+ | window.drawText(50, 50, "Hello world!"); | ||
+ | |||
+ | /* Ulož obrázok do súboru hello s príponou png. */ | ||
+ | window.savePng("hello.png"); | ||
+ | |||
+ | /* Zobraz na obrazovke a čakaj, kým užívateľ stlačí Exit, | ||
+ | potom zavri okno. */ | ||
+ | window.showAndClose(); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | [[Image:PROG-P1-hello.png|frame|Obsah súboru <tt>hello.png</tt>]] | ||
+ | * Po spustení program vypíše text červenou farbou, uloží ho vo forme obrázku do súboru <tt>hello.png</tt> a zobrazí ho v grafickom okne s tlačidlom "Exit". Keď užívateľ stlačí tlačidlo, okno sa zavrie. | ||
+ | * Prvý riadok programu teraz obsahuje inú knižnicu (SimpleDraw). Nie je súčasťou jazyka, preto si ju musíme skopírovať na náš počítač a umiestniť do vhodného adresára. Viac v [[#Netbeans|návode]]. | ||
+ | |||
+ | * Medzi <tt>int main(void) {</tt> a koncovou zátvorkou <tt>}</tt> máme teraz viacero príkazov, každý ukončený bodkočiarkou. Vykonávajú sa v tom poradí, v ako sú napísané. | ||
+ | * Text medzi <tt>/*</tt> a <tt>*/</tt> bude počítač ignorovať, ide o '''komentár''' určený pre čitateľa. V tomto prípade vždy popisuje, čo bude robiť nasledujúci riadok. | ||
+ | |||
+ | ===Cvičenia=== | ||
+ | Aj keď sme si nepovedali toho veľa o jednotlivých príkazoch v tomto programe, mali by ste z komentárov vedieť uhádnuť, ako meniť program aby napríklad: | ||
+ | * mal inú veľkosť obrázku | ||
+ | * použil na vypisovanie inú farbu | ||
+ | * vypísal text na iné miesto v rámci obrázku | ||
+ | * vypísal dva rôzne texty na rôzne miesta obrazovky rôznou farbou (napr. červeným <tt>Hello world!</tt> a pod to modrým <tt>Good morning, starshine!</tt>) | ||
+ | * uložil obrázok do súboru s iným menom | ||
+ | * vôbec neukladal nič do súboru | ||
+ | |||
+ | ==Vykreslenie domčeka== | ||
+ | [[Image:PROG-P1-domcek1.png|thumb|200px|Tradičný preškrtnutý domček]] | ||
+ | [[Image:PROG-P1-domcek1-popis.png|thumb|200px|Domček so súradnicami]] | ||
+ | * Ukážeme si ešte program, ktorý vykreslí tradičný prečiarknutý domček, ako je na obrázku vpravo. | ||
+ | * Pozor, grafická obrazovka má súradnicu 0,0 v ľavom hornom rohu a smerom nadol y-ová súradnica stúpa, čo je naopak, než je zvykom v matematike. | ||
+ | |||
+ | <pre> | ||
+ | #include "../SimpleDraw.h" | ||
+ | |||
+ | int main(void) { | ||
+ | /* Vytvor obrázok s rozmermi 300x400 pixelov */ | ||
+ | SimpleDraw window(300, 400); | ||
+ | |||
+ | /* Nakresli obdĺžnik (štvorec) s ľavým horným rohom v 100, 200 | ||
+ | * a šírkou aj dĺžkou 100. */ | ||
+ | window.drawRectangle(100, 200, 100, 100); | ||
+ | |||
+ | /* Prečiarkni štvorec dvomi čiarami po uhlopriečke. */ | ||
+ | window.drawLine(100, 300, 200, 200); | ||
+ | window.drawLine(100, 200, 200, 300); | ||
+ | |||
+ | /* Nakresli strechu ako dve čiary. */ | ||
+ | window.drawLine(100, 200, 150, 100); | ||
+ | window.drawLine(200, 200, 150, 100); | ||
+ | |||
+ | /* Ulož obrázok do súboru domcek1 s príponou png. */ | ||
+ | window.savePng("domcek1.png"); | ||
+ | |||
+ | /* Zobraz na obrazovke a čakaj, kým užívateľ stlačí Exit, | ||
+ | potom zavri okno. */ | ||
+ | window.showAndClose(); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Obmenou týchto dvoch programov by ste mali vedieť vykresliť hocijaký obrazec z rovných čiar a pridať k nim text. | ||
+ | * Knižnica SimpleDraw umožnuje vykresľovať aj kružnice a elipsy, lomené čiary, obrázky načítané zo súboru, meniť farbu čiary, vyfarbovať útvary a podobne. Viac sa dočítate v [[#SimpleDraw|návode]]. | ||
+ | |||
+ | ==Domček korytnačou grafikou== | ||
+ | * Pointa preškrtnutého domčeka je, že sa má kresliť jedným ťahom. To náš program vyššie nerobil. | ||
+ | * Knižnica SimpleDraw obsahuje aj príkazy na korytnačiu grafiku, ktorou môžeme domček nakresliť jedným ťahom. | ||
+ | ** Na obrazovke si vytvoríme virtuálnu korytnačku, ktorá má určitú polohu a natočenie. | ||
+ | ** Môžeme jej povedať, aby sa otočila doľava o určitý počet stupňov (<tt>turtle.turnLeft(uhol)</tt>). | ||
+ | ** Môžeme jej povedať, aby išla o určitú dĺžku dopredu (<tt>turtle.forward(dlzka)</tt>) | ||
+ | ** Keď ide korytnačka dopredu, zanecháva v piesku chvostom čiarku (vykreslí teda čiaru do nášho obrázku). | ||
+ | |||
+ | <pre> | ||
+ | #include "../SimpleDraw.h" | ||
+ | #include <cmath> | ||
+ | |||
+ | int main(void) { | ||
+ | /* Vytvor obrázok s rozmermi 300x400 pixelov. */ | ||
+ | SimpleDraw window(300, 400); | ||
+ | |||
+ | /* Vytvor korytnačku v ľavom dolnom rohu domu | ||
+ | * otočenú doprava. */ | ||
+ | Turtle turtle(window, 100, 300, 0); | ||
+ | |||
+ | /* Zobraz korytnačku ako šípku. */ | ||
+ | turtle.show(); | ||
+ | |||
+ | /* Korytnačka bude čakať 1 sekundu po každom ťahu. */ | ||
+ | turtle.setWait(1); | ||
+ | |||
+ | /* Nakresli dolnú čiaru a otoč sa smerom hore. */ | ||
+ | turtle.forward(100); | ||
+ | turtle.turnLeft(90); | ||
+ | |||
+ | /* Nakresli pravú zvislú čiaru, hornú vodorovnú a ľavú zvislú. */ | ||
+ | turtle.forward(100); | ||
+ | turtle.turnLeft(90); | ||
+ | turtle.forward(100); | ||
+ | turtle.turnLeft(90); | ||
+ | turtle.forward(100); | ||
+ | |||
+ | /* Otoč sa smerom na uhlopriečku. | ||
+ | Dĺžku uhlopriečky vyrátame Pytagorovou vetou. */ | ||
+ | turtle.turnLeft(135); | ||
+ | turtle.forward(sqrt(100 * 100 + 100 * 100)); | ||
+ | |||
+ | /* Otoč sa smerom na pravú časť strechy. | ||
+ | * Strecha bude rovnostranný trojuholník so stranou | ||
+ | * dĺžky 100. */ | ||
+ | turtle.turnLeft(75); | ||
+ | turtle.forward(100); | ||
+ | turtle.turnLeft(120); | ||
+ | turtle.forward(100); | ||
+ | |||
+ | /* A posledná čiara - uhlopriečne prečiarknutie. */ | ||
+ | turtle.turnLeft(75); | ||
+ | turtle.forward(sqrt(100 * 100 + 100 * 100)); | ||
+ | |||
+ | /* Schovaj korytnačku. */ | ||
+ | turtle.hide(); | ||
+ | |||
+ | /* Zobraz na obrazovke. */ | ||
+ | window.showAndClose(); | ||
+ | } | ||
+ | </pre> | ||
+ | * Pre jednoduchosť tento domček má trochu nižšiu strechu v tvare rovnostranného trojuholníka s každou stranou dĺžky 100 (a vnútornými uhlami 60 stupňov) | ||
+ | * Keďže domček je štvorec, uhlupriečka ide pod uhlom 45 stupňov. Jej dĺžku však musíme spočítať. Na sčítavanie používame znamieko +, na násobenie *, a na odmocninu funkciu sqrt (skratka z anglického square root), ktorá je v knižnici cmath | ||
+ | * Po každom príkaze forward korytnačka na sekundu zastane, aby sme videli, čo robí. | ||
+ | |||
+ | ==Zhrnutie== | ||
+ | * Programy, ktoré sme doteraz videli, vyzerali takto: | ||
+ | ** Najprv sme zapli používanie niekoľkých knižníc | ||
+ | ** Samotný program začínal <tt>int main(void) {</tt> a končil zloženou zátvorkou <tt>}</tt> | ||
+ | ** Program mohol mať niekoľko príkazov ukončených bodkočiarkami, ktoré sa vykonávajú jeden po druhom. | ||
+ | ** Okrem toho môžu byť v programe komentáre medzi /* a */, ktoré počítač ignoruje. | ||
+ | |||
+ | * Logiku za tým, prečo jednotlivé príkazy píšu tak, ako sa píšu, sme zatiaľ ešte nevysvetľovali, mali by ste však byť schopní modifikovať príklady uvedené v prednáške menením čísel, textov v úvodzovkách, pridávaním ďalších príkazov a podobne. | ||
+ | |||
+ | * Upozornenia: | ||
+ | ** Je rozdiel medzi malými a veľkými písmenami | ||
+ | ** Všetky čiarky, bodkočiarky, zátvorky a podobne sú dôležité | ||
+ | ** Na väčšine miest v programe môžeme voľne pridávať medzery a konce riadku, snažíme sa tým program spraviť prehľadný | ||
+ | |||
+ | * Programy, ktoré sme videli doteraz nie sú veľmi zaujímavé, lebo vždy robia to isté a robia pevný počet krokov, ktoré sme museli ručne všetky vypísať. Ďalej uvidíme | ||
+ | ** príkazy na načítanie vstupu od užívateľa | ||
+ | ** premenné, v ktorých si môžeme uchovávať vstupy a iné hodnoty | ||
+ | ** podmienky, ktoré nám umožnia vykonávať príkazy podľa okolností | ||
+ | ** cykly, ktoré nám umožnia opakovať tie isté príkazy veľa krát | ||
+ | |||
+ | ==Organizačné poznámky== | ||
+ | * Dnes prvé cvičenia | ||
+ | ** Skúste odovzdat DÚ0 v moodli (treba heslo) | ||
+ | * Zajtra ďalšia prednáška | ||
+ | * Štvrtok zverejnenie DÚ1 a PDÚ1 | ||
+ | * V piatok termín odovzdania DÚ0 | ||
+ | * Budúci pondelok zverejníme prípadné zmeny v rozdelení do skupín na cvičenia | ||
+ | * Budúci pondelok prvá rozcvička | ||
+ | |||
+ | =Prednáška 2= | ||
+ | == Premenné == | ||
+ | |||
+ | [[Image:PROG-P1-domcek1.png|thumb|200px|Tradičný preškrtnutý domček]] | ||
+ | Spomeňme si na program na vykresľovanie domčeka z minulej prednášky: | ||
+ | <pre> | ||
+ | #include "../SimpleDraw.h" | ||
+ | |||
+ | int main(void) { | ||
+ | /* Vytvor obrázok s rozmermi 300x400 pixelov */ | ||
+ | SimpleDraw window(300, 400); | ||
+ | |||
+ | /* Nakresli obdĺžnik (štvorec) s ľavým horným rohom v 100, 200 | ||
+ | * a šírkou aj dĺžkou 100. */ | ||
+ | window.drawRectangle(100, 200, 100, 100); | ||
+ | |||
+ | /* Prečiarkni štvorec dvomi čiarami po uhlopriečke. */ | ||
+ | window.drawLine(100, 300, 200, 200); | ||
+ | window.drawLine(100, 200, 200, 300); | ||
+ | |||
+ | /* Nakresli strechu ako dve čiary. */ | ||
+ | window.drawLine(100, 200, 150, 100); | ||
+ | window.drawLine(200, 200, 150, 100); | ||
+ | |||
+ | /* Zobraz na obrazovke a čakaj, kým užívateľ stlačí Exit, | ||
+ | potom zavri okno. */ | ||
+ | window.showAndClose(); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Ak by sme v ňom chceli zmeniť napríklad výšku domčeka, museli by sme pomeniť veľa súradníc v celom programe. Navyše keď vidíme v programe nejaké číslo, napr. 200, nevieme, ako sme k nemu prišli. | ||
+ | |||
+ | Program na kreslenie domčeka teraz prepíšeme tak, aby sme polohu a veľkosť domčeka mali zapísané symbolicky a mohli ich meniť na jednom mieste. | ||
+ | <pre> | ||
+ | #include "../SimpleDraw.h" | ||
+ | |||
+ | int main(void) { | ||
+ | /* x a y sú súradnice ľavého dolného rohu domčeka, | ||
+ | * width a height sú jeho šírka a dĺžka, | ||
+ | * roof je výška strechy. */ | ||
+ | int x = 100; | ||
+ | int y = 300; | ||
+ | int width = 100; | ||
+ | int height = 100; | ||
+ | int roof = 100; | ||
+ | |||
+ | /* Vytvor obrázok s rozmermi 300x400 pixelov */ | ||
+ | SimpleDraw window(300, 400); | ||
+ | |||
+ | /* Nakresli obdĺžnik */ | ||
+ | window.drawRectangle(x, y - height, width, height); | ||
+ | |||
+ | /* Prečiarkni štvorec dvomi čiarami po uhlopriečke. */ | ||
+ | window.drawLine(x, y, x + width, y - height); | ||
+ | window.drawLine(x, y - height, x + width, y); | ||
+ | |||
+ | /* Nakresli strechu ako dve čiary. */ | ||
+ | window.drawLine(x, y - height, x + width / 2, y - height - roof); | ||
+ | window.drawLine(x + width, y - height, x + width / 2, y - height - roof); | ||
+ | |||
+ | /* Zobraz na obrazovke a čakaj, kým užívateľ stlačí Exit, | ||
+ | potom zavri okno. */ | ||
+ | window.showAndClose(); | ||
+ | } | ||
+ | </pre> | ||
+ | Symbolickým hodnotám '''x,y,width,height,roof''' sa hovorí '''premenné'''. | ||
+ | |||
+ | * Premmená je určité vyhradené miesto v pamäti počítača, ku ktorému v programe pristupujeme pod určitým názvom. | ||
+ | * Do tejto pamäti si môžeme zapísať hodnotu a neskôr ju použiť. | ||
+ | |||
+ | * Príkaz <tt>int x=100;</tt> vytvorí novú premennú a uloží do nej hodnotu 100. | ||
+ | * Každá premenná má určitý typ, ktorý určuje, aké hodnoty do nej môžeme ukladať. | ||
+ | * Tieto premenné majú typ <tt>int</tt>, čo je skratka zo slova ''integer'', celé číslo. | ||
+ | |||
+ | [[Image:PROG-P2-domcek3.png|thumb|150px|Domček s height=200, roof=50]] | ||
+ | Ak v programe premenným priradíme iné čísla, môžeme vytvárať domčeky, ktorú budú vyššie alebo širšie, alebo budú mať strechu inej výšky, napr: | ||
+ | <pre> | ||
+ | int x = 100; | ||
+ | int y = 300; | ||
+ | int width = 100; | ||
+ | int height = 200; | ||
+ | int roof = 50; | ||
+ | </pre> | ||
+ | |||
+ | Príkaz <tt>int x=100;</tt> vieme rozpísať aj na dva príkazy <tt>int x; x=100;</tt>. Prvý z nich vytvorí premennú x, ktorá teraz bude mať nejakú ľubovoľnú hodnotu a druhý túto počiatočnú hodnotu zmení na 100. | ||
+ | |||
+ | '''Cvičenie''': v programe sa opakuje vzorec na výpočet x-ovej súradnice vrcholu strechy. Spočítajte ho iba raz a uložte do premennej middle | ||
+ | |||
+ | == Textový výpis a načítanie == | ||
+ | |||
+ | Vieme už vypísať niečo na obrazovku (výstup - output) a podobne môžeme aj čítať, čo nám používateľ napíše na klávesnici (vstup - input). Takéto zadané hodnoty s tiež uložíme v premenných, aby sme s nimi mohli ďalej pracovať. | ||
+ | |||
+ | Nasledujúci program od užívateľa vypýta dve čísla a vypíše ich súčet. | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | int x, y; | ||
+ | |||
+ | cout << "Please enter the first number: "; | ||
+ | cin >> x; | ||
+ | cout << "Please enter the second number: "; | ||
+ | cin >> y; | ||
+ | |||
+ | int result = x + y; | ||
+ | cout << x << "+" << y << "=" << result << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Tu je príklad behu programu, keď užívateľ zadal čísla 10 a 3: | ||
+ | |||
+ | <pre> | ||
+ | Please enter the first number: 10 | ||
+ | Please enter the second number: 3 | ||
+ | 10+3=13 | ||
+ | </pre> | ||
+ | |||
+ | * Tento program používa na vstup a výstup príkazy z knižnice iostream a teda do hlavičky programu dáme <tt>#include <iostream></tt> a <tt>using namespace std;</tt> | ||
+ | * Program najskôr vytvorí dve premenné ''x'' a ''y'' typu <tt>int</tt> (a nepriradzuje im zatiaľ žiadne hodnoty) | ||
+ | * Potom príkazom <tt>cout</tt> vypíše text <tt>"Please enter the first number: "</tt> aby užívateľ vedel, čo má robiť. | ||
+ | * Potom pomocou príkazu cin načíta číslo od používateľa do premennej ''x'' | ||
+ | * To isté opakuje pre premennú ''y'' | ||
+ | * Potom vytvorí novú premennú ''result'' a uloží do nej súčet ''x'' a ''y''. | ||
+ | * Nakoniec vypíše výsledok aj s výrazom, ktorý sme počítali, pomocou príkazu <tt>cout</tt>. | ||
+ | |||
+ | === Viac o príkaze cout === | ||
+ | |||
+ | * Pomocou <tt>cout</tt> vypisujeme na konzolu, t.j. textovú obrazovku | ||
+ | * To, čo chceme vypísať pošleme na <tt>cout</tt> pomocou šípky <tt><<</tt> | ||
+ | * <tt>cout << endl;</tt> vypíše koniec riadku | ||
+ | * Môžeme naraz vypísať aj viac vecí oddelených šípkami <tt><<</tt> | ||
+ | ** Napr. <tt>cout << x << "+" << y << "=" << result << endl;</tt> vypíše najskôr obsah premennej ''x'' (napr. hodnotu 10), potom znamieko plus (ktoré máme v úvodzovkách), potom obsah premennej ''y'', potom znamienko rovnosti, potom obsah premennej ''result'' a nakoniec koniec riadku. | ||
+ | |||
+ | === Viac o príkaze cin === | ||
+ | |||
+ | * Pomocu <tt>cin</tt> načítavame z konzoly údaje od užívateľa | ||
+ | * Tieto údaje pošleme do premenných pomocou šípky <tt>>></tt> | ||
+ | * Opäť môžeme načítať aj viac vecí naraz, napr. nasledovný úryvok si vypýta obe čísla naraz a uloží ich do premenných ''x'' a ''y'' | ||
+ | |||
+ | cout << "Please enter two numbers separated by space: "; | ||
+ | cin >> x >> y; | ||
+ | |||
+ | * Pozor, cin nekontroluje, že užívateľ zadáva rozumné hodnoty. Čo sa stane, ak namiesto čísla zadá nejaké písmená a podobne? | ||
+ | |||
+ | == Výrazy == | ||
+ | |||
+ | Pri využívaní premenných by sme si mali niečo povedať aj o výrazoch a ich vyhodnocovaní. | ||
+ | Na vytváranie výrazov v programe môžeme používať aritmetické a logické výrazy, zátvorky, čísla, konštanty a premenné. | ||
+ | |||
+ | === Premenné === | ||
+ | * Pre začiatok budeme pracovať s premennými typu <tt>int</tt> a <tt>double</tt>. | ||
+ | * Premenná typu <tt>int</tt> reprezentuje celé číslo. | ||
+ | * Premenná typu <tt>double</tt> reprezentuje reálne číslo. | ||
+ | * Ich rozsah je však obmedzený. | ||
+ | ** Typ int väčšinou zaberá 4 bajty (32 bitov) pamäte a vie ukladať čísla z intervalu <-2 147 483 648, +2 147 483 647> | ||
+ | ** Typ double väčšinou zaberá 8 bajtov a je uložený vo formáte s pohyblivou rádovou čiarkou, t.j. vo forme <math>z\cdot a\cdot 2^b</math>, kde ''z'' je znamienko, ''a'' je reálne číslo z intervalu <1,2) (mantisa) a ''b'' je celé číslo (exponent). Na uloženie mantisy sa používa 52 bitov a na uloženie exponentu 11 bitov. Vieme teda spracovávať zhruba čísla v rozsahu od <math>10^{-300}</math> po <math>10^{300}</math> s presnosťou na 15 až 16 platných cifier. | ||
+ | * Keď priradíme hodnotu typu double do hodnoty typu int, dôjde k jej zaokrúhleniu (nadol pri kladných číslach, nahor pri záporných). | ||
+ | |||
+ | === Aritmetické výrazy === | ||
+ | * +, -, * (násobenie), / (delenie) | ||
+ | ** delenie celočíselných premenných vráti dolnú celú časť podielu, napr. 5/3 je 1 (pre záporné čísla to môže byť horná celá časť) | ||
+ | * % je modulo, napr. 5%3 bude 2, lebo 5 má zvyšok 2 po delení 3 | ||
+ | * ďalšie matematické funkcie vyžadujú <tt>#include <cmath></tt> v hlavičke programu | ||
+ | ** napríklad cos(x), sin(x), tan(x) (tangens), acos(x) (arkus kosínus), exp(x) (<math>e^x</math>), log(x) (prirodzený logaritmus), pow(x,y) (<math>x^y</math>), sqrt(x) (odmocnina), abs(x) (absolútna hodnota), floor(x) (dolná celá časť) | ||
+ | ** pozri tiež [http://www.cplusplus.com/reference/clibrary/cmath/ zoznam tu] | ||
+ | |||
+ | Skratky: | ||
+ | Ak chceme zvýšiť hodnotu premennej x o 1, môžeme použiť niektorý z nasledujúcich spôsobov: | ||
+ | * x = x+1; | ||
+ | * x++; | ||
+ | * x += 1; | ||
+ | Podobne ako ++ existuje aj --, podobne ako += existuje aj -=, *= atď | ||
+ | |||
+ | === Konštanty === | ||
+ | * Celočíselné konštanty, ako napríklad 0, 1, 100, -5, majú typ int | ||
+ | * Konštanty s desatinnou bodkou, ako napríklad 1.5, 1.0, 3.13, -0.5 majú typ double. Môžeme tiež používať semilogaritmický zápis typu 1.5e3, čo znamená <math>1.5\cdot 10^3</math>, t.j. 1500. | ||
+ | |||
+ | === Logické konštanty a výrazy === | ||
+ | |||
+ | * Logické konštanty: true (1) a false (0) | ||
+ | * Logické výrazy dávajú ako výsledok pravdivostnú hodnotu -- logickú konštantu | ||
+ | ** == (rovnosť), != (nerovnosť), <, <= | ||
+ | ** && (logický AND), || (logický OR), ! (logický NOT) | ||
+ | |||
+ | === Vyhodnocovanie výrazov === | ||
+ | |||
+ | Výrazy sa vyhodnocujú s preferenciou podľa nasledovnej tabuľky. Výrazy v jednom riadku tabuľky majú rovnakú prednosť a vyhodnocujú sa väčšinou zľava doprava, okrem !,++,-- a priradenia. | ||
+ | * ++, --, logický NOT | ||
+ | * *, /, % | ||
+ | * +, - | ||
+ | * <, >, <=, >= | ||
+ | * ==, != | ||
+ | * && (logický AND) | ||
+ | * || (logický OR) | ||
+ | * priradenie | ||
+ | |||
+ | Poradie vyhodnocovania môžeme meniť zátvorkami, napr. 4*(5-3) | ||
+ | |||
+ | Viac o operátoroch v C++ nájdete napríklad [http://cplusplus.com/doc/tutorial/operators/ tu]. | ||
+ | |||
+ | == Podmienka (if) == | ||
+ | |||
+ | Niekedy chceme vykonať určité príkazy len ak sú splnené nejaké podmienky. To nám umožňuje príkaz podmienky '''if'''. | ||
+ | |||
+ | * Nasledujúci program si vypýta od užívateľa číslo a vypíše, či je toto číslo párne (even) alebo nepárne (odd). | ||
+ | |||
+ | <pre> #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | int x; | ||
+ | cout << "Please enter some number: "; | ||
+ | cin >> x; | ||
+ | |||
+ | if (x % 2 == 0) { | ||
+ | cout << "Number " << x << " is even." << endl; | ||
+ | } else { | ||
+ | cout << "Number " << x << " is odd." << endl; | ||
+ | } | ||
+ | |||
+ | }</pre> | ||
+ | |||
+ | * Tu je príklad dvoch behov programu: | ||
+ | |||
+ | <pre> | ||
+ | Please enter some number: 10 | ||
+ | Number 10 is even. | ||
+ | </pre> | ||
+ | |||
+ | <pre> | ||
+ | Please enter some number: 3 | ||
+ | Number 3 is odd. | ||
+ | </pre> | ||
+ | |||
+ | * Ako vidíme, za príkazom if je zátvorka s podmienkou. V našom príklade podmienka je <tt>x % 2 == 0</tt>. Zoberieme teda hodnotu x, pomocou operátora % zistíme zvyšok po delení 0 a pomocou dvoch rovnítok == testujeme, či je tento zvyšok rovný nule. | ||
+ | * Ak je podmienka v zátvorke splnená (t.j. ak je zvyšok rovný nule), vykonáme príkazy v zloženej zátvorke za príkazom if. | ||
+ | * Ak podmienka nie je splnená (t.j. ak zvyšok nie je rovný nule), vykonáme príkazy v zloženej zátvorke za slovom else | ||
+ | * Časť else {...} je možné vynechať, ak nechceme vykonávať žiadne príkazy. | ||
+ | * Nateraz píšeme zátvorky { a } za if aj za else. Ak za nimi nasleduje iba jeden príkaz, môžeme ich vynechať, ľahko to však vedie k chybám, preto je lepšie ich vždy použiť. | ||
+ | |||
+ | === Vnorené podmienky === | ||
+ | |||
+ | Pritom príkazy if môžeme navzájom vnárať, čím vzniknú vcelku komplikované výrazy. | ||
+ | |||
+ | * Načítaj čislo a zisti, či je kladné, záporné alebo nula. | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | int x; | ||
+ | cout << "Please enter some number: "; | ||
+ | cin >> x; | ||
+ | |||
+ | if (x == 0) { | ||
+ | cout << "Null" << endl; | ||
+ | } else { | ||
+ | if (x > 0) { | ||
+ | cout << "Positive" << endl; | ||
+ | } else { | ||
+ | cout << "Negative" << endl; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | '''Cvičenie:''' vypíšte, koľko z čísel 2,3,5 delí zadané číslo x. Napr. | ||
+ | <pre> | ||
+ | Zadajte cislo: 6 | ||
+ | Pocet delitelov z mnoziny {2,3,5}: 2 | ||
+ | |||
+ | Zadajte cislo: 60 | ||
+ | Pocet delitelov z mnoziny {2,3,5}: 3 | ||
+ | |||
+ | Zadajte cislo: 7 | ||
+ | Pocet delitelov z mnoziny {2,3,5}: 0 | ||
+ | </pre> | ||
+ | |||
+ | === Upozornenie=== | ||
+ | Častá chyba, ktorá sa vyskytuje pri podmienke je použitie priradenia namiesto porovnania. Keby sme napísali | ||
+ | <pre>if (x=0) cout << “Null” << endl; </pre> | ||
+ | tak program do premennej x priradí nulu, ktorá sa premení na logické false pre účely vyhodnotenia podmienky. | ||
+ | |||
+ | Ďalšia bežná chyba je zabudnutie zložených zátvoriek | ||
+ | <pre> | ||
+ | if (x==0) cout << “Null”; cout << endl; | ||
+ | </pre> | ||
+ | Tento program vykoná <tt>cout << endl</tt> vždy, nezávisle od podmienky. V prípade, že chceme vykonať v podmienke viacero príkazov, nesmieme zabudnúť ich uzátvorkovať: | ||
+ | <pre> | ||
+ | if (x==0) { cout << “Null”; cout << endl; } | ||
+ | </pre> | ||
+ | |||
+ | == Cyklus (for) == | ||
+ | |||
+ | Teraz si ukážeme príkaz for, ktorý nám umožňuje opakovať viackrát nejakú skupinu príkazov. | ||
+ | |||
+ | Na úvod trochu motivácie. Ako by ste napísali nasledovné jednoduché programy? | ||
+ | * Vypíšte čísla od 0 do 9. A následne od 0 do 24. (pre vytrvalých od 0 do 99) | ||
+ | * Vykreslite pravidelný štvoruholník. Šesťuholník? Devätnásťuholník? | ||
+ | |||
+ | === Vypisovanie čísiel === | ||
+ | |||
+ | Nasledujúci program vypíše čísla 0 až 9 oddelené medzerami bez toho, aby sme ich niekde v programe explicitne vymenovali. | ||
+ | |||
+ | <pre>#include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | for (int i = 0; i < 10; i++) { | ||
+ | cout << " " << i; | ||
+ | } | ||
+ | cout << endl; | ||
+ | }</pre> | ||
+ | |||
+ | Tu je výstup programu. | ||
+ | |||
+ | <pre>0 1 2 3 4 5 6 7 8 9</pre> | ||
+ | |||
+ | Ak by sme v programe číslo 10 zmenili napr. na 25, vypíše čísla 0 do 24. | ||
+ | |||
+ | * Novou črtou tohto programu je príkaz for pre cyklus: <tt>for (int i = 0; i < 10; i++)</tt> | ||
+ | * Cyklus nám umožňuje opakovať určitú časť programu viackrát. | ||
+ | * V zátvorke za for sú tri časti oddelené bodkočiarkami. | ||
+ | ** Príkaz <tt>int i = 0</tt> vytvorí novú celočíselnú premenú i a priradí jej hodnotu 0. | ||
+ | ** Podmienka <tt>i < 10</tt> určuje dokedy sa má cyklus opakovať, t.j. kým hodnota i je menšia ako 10. | ||
+ | ** Príkaz <tt>i++</tt> hovorí, že v každom kroku sa má premenná i zvýšiť o jedna. | ||
+ | * Medzi zložené zátvorky { a } môžeme dať jeden alebo viac príkazov, ktoré sa budú opakovať pre rôzne hodnoty premennej i. | ||
+ | ** V našom príklade máme vo vnútri cyklu iba príkaz <tt>cout << " " << i;</tt>, ktorý vypíše medzeru a hodnotu premennej i. | ||
+ | * Po skončení cyklu sa pokračuje príkazmi za končiacou zloženou zátvorkou, v našom prípade vypíšeme ešte koniec riadku. | ||
+ | * Všimnite si, že náš program obsahuje dve sady zložených zátvoriek vnorených v sebe: jedna ohraničuje celý program, jedna ohraničuje príkazy, ktorá sa robia vo vnútri cyklu. | ||
+ | |||
+ | * O presnom fungovaní príkazu for si povieme viac neskôr, ale teraz sa pozrime, čo spraví jednoduchá zmena v tomto príkaze: | ||
+ | |||
+ | <pre> | ||
+ | for (int i = 1; i <= 10; i++) { | ||
+ | </pre> | ||
+ | |||
+ | * Počiatočnú príkaz sme zmenili z int i = 0 na int i = 1, premenná i teda začne s hodnotou 1, nie 0. Cyklus môže začať od ľubovoľnej hodnoty (napríklad aj zápornej) | ||
+ | * Podmienku ukončenia sme zmenili z i < 10 na i <= 10, t.j. cyklus sa opakuje kým je hodnota premennej i menšia alebo rovná 10 (to isté by sme dosiahli aj pomocou i < 11) | ||
+ | * Program teda vypíše čísla od 1 po 10: | ||
+ | |||
+ | <pre> 1 2 3 4 5 6 7 8 9 10</pre> | ||
+ | |||
+ | === Vykreslenie náhodných kruhov === | ||
+ | |||
+ | Nasledujúci program vykreslí na obrazovku náhodne rozmiestnené kruhy. | ||
+ | |||
+ | <pre> | ||
+ | #include "../SimpleDraw.h" | ||
+ | #include <cstdlib> | ||
+ | #include <ctime> | ||
+ | |||
+ | int main(void) { | ||
+ | int size = 300; /* veľkosť obrázku */ | ||
+ | int count = 30; /* počet kruhov */ | ||
+ | int diameter = 10; /* priemer kruhu */ | ||
+ | |||
+ | /* inicializácia generátora pseudonáhodných čísel */ | ||
+ | srand(time(NULL)); | ||
+ | |||
+ | SimpleDraw window(size, size); | ||
+ | |||
+ | for (int i = 0; i < count; i++) { | ||
+ | /* vykresli kruh s priemerom diameter na náhodné miesto */ | ||
+ | window.drawEllipse(rand() % size, rand() % size, diameter, diameter); | ||
+ | } | ||
+ | |||
+ | window.showAndClose(); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Program využíva príkaz <tt>rand()</tt>, ktorý generuje pseudonáhodné celé čísla. (Nie sú v skutočnosti náhodné, lebo ide o pevne definovanú matematickú postupnosť, ktorá však má mnohé vlastnosti náhodných čísel). | ||
+ | ** Výsledkom <tt>rand()</tt> je celé nezáporné číslo medzi 0 a nejakou veľkou konštantou. | ||
+ | ** <tt>rand() % size</tt> je číslo medzi 0 a size-1 | ||
+ | ** vygenerujeme dve také čísla a použijeme ich ako súradnice kruhu (presnejšie ľavého horného rohu štvorca opísaného kruhu) | ||
+ | * Príkaz <tt>srand</tt> inicializuje generátor pseudonáhodných čísel na určitú hodnotu, my použijeme aktuálny čas. | ||
+ | * Potrebujeme knižnice <tt>cstdlib</tt> a <tt>ctime</tt>. | ||
+ | |||
+ | Skúsme pred príkaz window.drawEllipse dať ešte príkaz window.setBrushColor, ktorý nastaví farbu výplne kruhu. Túto farbu chceme tiež nastaviť na náhodnú hodnotu, t.j. vygenerujeme tri náhodné čísla pre červenú, zelenú a modrú zložku tejto farby. Tieto čísla majú byť medzi 0 a 255. | ||
+ | |||
+ | <pre> | ||
+ | /* nastav náhodnú farbu */ | ||
+ | window.setBrushColor(rand() % 256, rand() % 256, rand() % 256); | ||
+ | </pre> | ||
+ | |||
+ | Cvičenie: nastavme aj priemer kruhu ako náhodné číslo od 0 do 19. Čo ak chceme priemer od 10 do 19? | ||
+ | |||
+ | ==Organizačné poznámky== | ||
+ | * Štvrtok zverejnenie DÚ1 a PDÚ1 | ||
+ | * V piatok termín odovzdania DÚ0 | ||
+ | * Budúci pondelok zverejníme prípadné zmeny v rozdelení do skupín na cvičenia | ||
+ | * Budúci pondelok na cvičeniach prvá rozcvička - kreslenie so simpleDraw | ||
+ | * Budúci pondelok poobede nepovinný test pre pokročilých | ||
+ | =Cvičenia 1= | ||
+ | Cieľom prvých cvičení je vyskúšať si prostredie Netbeans a jednoduché úpravy textových aj grafických programov z prednášky. Podobné programy budete písať budúci týždeň na rozcvičke, takže doporučujeme si priniesť papier s poznámkami z prvej prednášky. | ||
+ | |||
+ | ==Príklad 1== | ||
+ | * Prihláste sa na počítač a spustite Netbeans podľa návodu [[#Netbeans|tu]] | ||
+ | * Vytvorte nový projekt a skopírujte si tam [[#Prednáška_1|Hello world program z prvej prednášky]] | ||
+ | * Skúste ho skompilovať a spustiť. | ||
+ | * Zmodifikujte ho tak, aby vypisoval slovenskú hlášku Ahoj svet! a opäť ho skompilujte a spustite. | ||
+ | |||
+ | ==Príklad 2== | ||
+ | * Vytvorte nový projekt s programom na [[#Prednáška_1|vykreslenie domčeka z prvej prednášky]] | ||
+ | ** Postupujte podľa návodu [[#Netbeans|tu]] | ||
+ | ** Stiahnite si grafickú knižnicu [http://compbio.fmph.uniba.sk/vyuka/prog/data/ SimpleDraw] a správne ju umiestnite | ||
+ | ** Nezabudnite nastaviť novému projektu typ C/C++ Qt Application a nastaviť použitie knižnice | ||
+ | * Program skompilujte a spustite | ||
+ | * Zmodifikujte ho tak, aby nad domčekom v hornej časti obrázku bol zelený nápis Domcek | ||
+ | |||
+ | ==Príklad 3== | ||
+ | [[Image:PROG-CV1-trojuholniky.png|thumb|200px|right]] | ||
+ | Nakreslite korytnačou grafikou jedným ťahom obrázok napravo. Všetky malé trojuholníky na obrázku sú rovnostranné s dĺžkou hrany 100, veľký trojuholník má teda dĺžku hrany 200. Pripomíname, že v rovnostrannom trojuholníku majú vnútorné uhly 60 stupňov. | ||
+ | |||
+ | ==Príklad 4== | ||
+ | Prihláste sa do prostredia Moodle a odovzdajte [[#DÚ0|nultú domácu úlohu]]. | ||
+ | =DÚ0= | ||
+ | {{MDU|0|3827}} max. 2 body, termín odovzdania piatok 21.9.2012 o 22:00 | ||
+ | |||
+ | Cieľom tejto domácej úlohy je oboznámiť sa so systémom Moodle, ktorý budete používať na odovzdávanie úloh aj neskôr a potvrdiť svoj záujem o tento predmet, aby sme s Vami rátali pri rozdelovaní do skupín na cvičenia. | ||
+ | |||
+ | Postup: | ||
+ | * Vytvorte textový súbor (napríklad v textovom editore alebo v prostredí Netbeans) | ||
+ | * Napíšte do neho odpovede na otázky uvedené nižšie | ||
+ | * Prihláste sa do systému Moodle {{MDU|0|3827}} pomocou AIS prihlasovacieho mena a hesla | ||
+ | * Zapíšte sa na predmet Programovanie (1) v C/C++ s použitím kľúča, ktorý dostanete na prednáške resp. cvičení | ||
+ | * Odovzdajte vytvorený textový súbor | ||
+ | |||
+ | Otázky | ||
+ | # Meno a priezvisko | ||
+ | # Emailová adresa | ||
+ | # Učili ste sa už programovať? Ak áno, v akom jazyku (jazykoch)? | ||
+ | =Prednáška 3= | ||
+ | Doteraz sme videli: | ||
+ | * Vypisovanie a načítavanie v textovom režime | ||
+ | * Vykresľovanie pomocou grafickej knižnice SimpleDraw | ||
+ | * Aritmetické a logické výrazy, premenné typu int a double | ||
+ | * Podmienku if | ||
+ | * Cyklus for | ||
+ | |||
+ | Dnes: | ||
+ | * Ďalšie príklady na cykly a podmienky, zopár menších noviniek. | ||
+ | |||
+ | |||
+ | ==Viac príkladov na cyklus for== | ||
+ | |||
+ | === Výpočet faktoriálu === | ||
+ | |||
+ | Tento program si od užívateľa vypýta číslo n a spočíta n!, t.j. súčin celých čísel od 1 po n. | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | int n; | ||
+ | |||
+ | cout << "Please enter n: "; | ||
+ | cin >> n; | ||
+ | |||
+ | int result = 1; | ||
+ | for (int i = 1; i <= n; i++) { | ||
+ | result = result * i; | ||
+ | } | ||
+ | cout << n << "!=" << result << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Tu je príklad behu programu pre n=4 (1*2*3*4=24) | ||
+ | |||
+ | <pre> | ||
+ | Please enter n: 4 | ||
+ | 4!=24 | ||
+ | </pre> | ||
+ | |||
+ | * Program používa premennú result, v ktorej sa ukladá dočasný výsledok. Na začiatok ju nastavíme na 1 a postupne ju násobíme číslami 1, 2, ..., n. | ||
+ | * Riadok result = result * i; zoberie pôvodnú hodnotu premennej result, vynásobí ju hodnotou premennej i (t.j. jedným z čísel 1, 2, ..., n) a výsledok uloží naspäť do premennej result (prepíše pôvodnú hodnotu). To isté sa dá napísať ako result *= i; | ||
+ | |||
+ | ====Krokovanie programu==== | ||
+ | * Skúsme si odkrokovať, ako sa budú postupne meniť hodnoty premenných počas behu programu | ||
+ | * Krokovanie programu a vypisovanie hodnôt premenných je možné robiť v prostredí Netbeans, mali by ste však byť schopní to robiť aj ručne, lebo tým lepšie pochopíte, ako program pracuje. | ||
+ | * Krokovanie v prostredí Netbeans: | ||
+ | ** Klikneme pravým na meno projeku v záložke Projects, zvolíme Step into | ||
+ | ** Tým sa naštaruje a hneď aj zastaví náš program, ďalej sa môžeme púšťať program riadok po riadku ikonkou Step Over (F8) | ||
+ | ** V dolnej časti okna v záložke Variables vidíme hodnoty vybraných premenných, ďalšie si môžeme ručne pridať | ||
+ | |||
+ | ====Int má obmedzený rozsah==== | ||
+ | Funkcia n! veľmi rýchlo rastie a už pre n=13 sa výsledok nezmestí do premennej typu int. Dostávame nezmyselné hodnoty: | ||
+ | |||
+ | <pre> | ||
+ | 12!=479001600 | ||
+ | 13!=1932053504 | ||
+ | 14!=1278945280 | ||
+ | 15!=2004310016 | ||
+ | 16!=2004189184 | ||
+ | 17!=-288522240 | ||
+ | </pre> | ||
+ | |||
+ | Správne hodnoty sú: | ||
+ | |||
+ | <pre> | ||
+ | 12!=479001600 | ||
+ | 13!=6227020800 | ||
+ | 14!=87178291200 | ||
+ | 15!=1307674368000 | ||
+ | 16!=20922789888000 | ||
+ | 17!=355687428096000 | ||
+ | </pre> | ||
+ | |||
+ | Cvičenie: Prepíšme program na počítanie faktoriálu tak, aby vypísal aj faktoriál ako súčin čísel, napríklad | ||
+ | <pre>Please enter n: 4 | ||
+ | 4! = 1*2*3*4 = 24</pre> | ||
+ | |||
+ | ===Vypisovanie deliteľov: podmienka v cykle=== | ||
+ | Nasledujúci program načíta číslo od užívateľa a vypíše zoznam jeho deliteľov. | ||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | int n; | ||
+ | cout << "Please enter some number: "; | ||
+ | cin >> n; | ||
+ | |||
+ | cout << "Divisors of " << n << ":"; | ||
+ | for (int i = 1; i <= n; i++) { | ||
+ | if (n % i == 0) { | ||
+ | cout << " " << i; | ||
+ | } | ||
+ | } | ||
+ | cout << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Beh programu: | ||
+ | <pre> | ||
+ | Please enter some number: 12 | ||
+ | Divisors of 12: 1 2 3 4 6 12 | ||
+ | </pre> | ||
+ | |||
+ | ==Malá odbočka: úprava a čitateľnosť programov== | ||
+ | |||
+ | Okrem počítača budú váš program čítať aj ľudia: vy sami, keď v ňom potrebujete nájsť chybu alebo ho v budúcnosti rozširovať, vaši kolegovia vo firme, učitelia v škole. Preto treba programy písať tak, aby boli nielen správne, ale aj prehľadné a ľahko pochopiteľné. Tu sú zásady, ktoré takejto čitateľnosti pomáhajú: | ||
+ | * '''Odsadzovanie:''' príkazy vykonávané v cykle alebo podmienke (medzi { a }) odsaďte o niekoľko pozícií doprava. Pri vnorených cykloch a podmienkach odsaďte každú ďalšiu úroveň viac. | ||
+ | ** V Netbeans sa dá odsadzovanie napraviť na vybranom texte pomocou položky menu Source->Format | ||
+ | * '''Medzery a voľné riadky:''' prehľadnosť zvýšite, ak oddelíte ucelené časti programu voľným riadkom. V zložitejších výrazoch doporučujeme vkladať medzery okolo operátorov: | ||
+ | ** <tt>for(int i=0;i<count;i++){</tt> | ||
+ | ** <tt>for (int i = 0; i < count; i++) {</tt> | ||
+ | * '''Dĺžka riadku:''' doporučujeme sa vyhýbať sa dlhým riadkom nad 80 znakov. Sú problémy s ich tlačením alebo zobrazovaním v menších oknách, aj na veľkom monitore namáhajú čitateľa. V prípade potreby je možné dlhšiu podmenku alebo iný výraz rozdeliť na viac riadkov. | ||
+ | * '''Názvy premenných:''' je vhodné používať názvy premenných, ktoré vyjadrujú ich obsah (po anglicky príp. slovensky). Pri premenných v kratších programoch, alebo ktoré sa používajú len lokálne v kratšom kúsku programu môžete použiť aj krátke zaužívané názvy, napr. i a j pre premenné v cykloch, n pre počet, a pre pole. | ||
+ | * '''Komentáre:''' význam jednotlivých úsekov kódu je dobré popísať v komentároch. | ||
+ | Pri známkovaní budeme brať do úvahy aj prehľadnosť vašich programov. | ||
+ | |||
+ | ==Cyklus while== | ||
+ | |||
+ | Okrem cyklu <tt>for</tt> môžeme použiť aj cyklus <tt>while</tt>, ktorý vyzerá nasledovne: | ||
+ | <pre> | ||
+ | while (podmienka) { | ||
+ | príkaz; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Čítame: kým je splnená podmienka vykonávaj príkaz. Podrobnejšie: | ||
+ | * podmienka je výraz, ktorý sa najskôr vyhodnotí: | ||
+ | ** ak je jeho hodnota logická nepravda, cyklus je ukončený a program pokračuje ďalším príkazom za while{...} | ||
+ | ** ak je jeho hodnota logická pravda, vykoná sa príkaz a celý cyklus sa opäť opakuje. | ||
+ | |||
+ | === Úroky v banke === | ||
+ | |||
+ | Na začiatku každého roku uložíme 1000 EUR na úrokovú vkladnú knižku s ročným úrokom 5%. Zistite, za koľko rokov naše úspory dosiahnu sumu aspoň 20 000 EUR. | ||
+ | |||
+ | Vieme určite, že budeme musieť peniaze vkladať niekoľko rokov. Problém je v tom, že dopredu nevieme povedať koľko, pretože počet rokov je vlastne výstupom programu. Neformálne by sme algoritmus na vyriešenie mohli popísať takto: | ||
+ | |||
+ | * Založ si účet v banke (zatiaľ šetríš nula rokov) | ||
+ | * Kým nemáš na začiatku roka našetrené 20 000 EUR opakuj: | ||
+ | ** Vlož čiastku a čakaj na nový rok, kým sa zúročia | ||
+ | |||
+ | Potrebujeme cyklus, ktorý sa bude vykonávať, kým platí nejaká podmienka - práve na to je vhodný while cyklus. Pomocou neho zapíšeme algoritmus nasledovne: | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | double ucet = 0; | ||
+ | int rok = 0; | ||
+ | |||
+ | while (ucet < 20000) { | ||
+ | ucet = (ucet + 1000) * 1.05; | ||
+ | rok++; /* to isté ako rok = rok + 1 */ | ||
+ | cout << "Na konci roku " << rok << " máme na účte " << ucet << " EUR" << endl; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | <pre> | ||
+ | Na konci roku 1 máme na účte 1050 EUR | ||
+ | Na konci roku 2 máme na účte 2152.5 EUR | ||
+ | Na konci roku 3 máme na účte 3310.12 EUR | ||
+ | Na konci roku 4 máme na účte 4525.63 EUR | ||
+ | Na konci roku 5 máme na účte 5801.91 EUR | ||
+ | Na konci roku 6 máme na účte 7142.01 EUR | ||
+ | Na konci roku 7 máme na účte 8549.11 EUR | ||
+ | Na konci roku 8 máme na účte 10026.6 EUR | ||
+ | Na konci roku 9 máme na účte 11577.9 EUR | ||
+ | Na konci roku 10 máme na účte 13206.8 EUR | ||
+ | Na konci roku 11 máme na účte 14917.1 EUR | ||
+ | Na konci roku 12 máme na účte 16713 EUR | ||
+ | Na konci roku 13 máme na účte 18598.6 EUR | ||
+ | Na konci roku 14 máme na účte 20578.6 EUR | ||
+ | </pre> | ||
+ | |||
+ | ===Euklidov algoritmus na nájdenie najväčšieho spoločného deliteľa=== | ||
+ | * Jeden z najstarších dodnes používaných algoritmov, Euklides ho popísal v svom diele Základy, cca 300 pred Kr. | ||
+ | * Máme dané dve kladné celé čísla ''a'' a ''b'' a chceme nájsť najväčšie číslo ''d'', ktoré delí ''a'' aj ''b''. | ||
+ | * Skratka nsd(a,b), po anglicky gcd(a,b) (greatest common divisor) | ||
+ | |||
+ | * Príklad: | ||
+ | ** Delitele 12: 1, 2, 3, 4, 6, 12 | ||
+ | ** Delitele 8: 1, 2, 4, 8 | ||
+ | ** Spoločné delitele 8 a 12: 1, 2, 4 | ||
+ | ** gcd(8,12)=4 | ||
+ | |||
+ | * Lema: pre všetky kladné celé čísla ''a'' a ''b'' platí: gcd(''a'',''b'') = gcd(''b'', ''a'' mod ''b'') | ||
+ | ** nech <math>x = a \bmod b, y = \lfloor a/b\rfloor</math> | ||
+ | ** nech ''A'' je množina spoločných deliteľov ''a'' a ''b'', ''B'' je množina spoločných deliteľov ''b'' a ''x'' | ||
+ | ** ukážeme, že ''A=B'' (a teda aj <math>\max A = \max B</math>) | ||
+ | ** ''x'' = ''a'' - ''yb'' a preto každý deliteľ ''a'' aj ''b'' delí aj ''x'', t.j. <math>A\subseteq B</math> | ||
+ | ** taktiež ''a'' = ''yb'' + ''x'' a preto každý deliteľ ''b'' a ''x'' delí aj ''a'', t.j. <math>B\subseteq A</math> | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | int a, b; | ||
+ | cout << "Enter two positive integers a and b: "; | ||
+ | cin >> a >> b; | ||
+ | while(b != 0) { | ||
+ | int x = a % b; | ||
+ | a = b; | ||
+ | b = x; | ||
+ | } | ||
+ | cout << "Their gcd: " << a << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Príklad behu programu: | ||
+ | <pre> | ||
+ | Enter two positive integers a and b: 30 8 | ||
+ | Their gcd: 2 | ||
+ | </pre> | ||
+ | |||
+ | Tento výpočet prešiel cez dvojice: | ||
+ | <pre> | ||
+ | 30 8 | ||
+ | 8 6 | ||
+ | 6 2 | ||
+ | 2 0 | ||
+ | </pre> | ||
+ | |||
+ | ===Nekonečný cyklus=== | ||
+ | <pre> | ||
+ | while (true) { | ||
+ | prikaz; | ||
+ | } | ||
+ | </pre> | ||
+ | Opakuje príkaz donekonečna (kým program nezastavíme). | ||
+ | |||
+ | Napríklad môžeme donekonečna vykresľovať náhodné kruhy, ale pozor, každý kruh berie trochu miesta v pamäti, po čase zaplníte pamäť a počítač môže dramaticky spomaliť, alebo program skončí s chybovou hláškou. | ||
+ | |||
+ | <pre> | ||
+ | #include "../SimpleDraw.h" | ||
+ | #include <cstdlib> | ||
+ | #include <ctime> | ||
+ | |||
+ | int main(void) { | ||
+ | int size = 300; /* veľkosť obrázku */ | ||
+ | int diameter = 10; /* priemer kruhu */ | ||
+ | |||
+ | /* inicializácia generátora pseudonáhodných čísel */ | ||
+ | srand(time(NULL)); | ||
+ | |||
+ | SimpleDraw window(size, size); | ||
+ | |||
+ | while (true) { | ||
+ | /* vykresli kruh s priemerom diameter na náhodné miesto */ | ||
+ | window.drawEllipse(rand() % size, rand() % size, diameter, diameter); | ||
+ | } | ||
+ | |||
+ | window.showAndClose(); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Hra hádaj číslo=== | ||
+ | V nasledujúcom programe si počítač "myslí číslo" od 1 do 100 a užívateľ háda, o ktoré číslo ide. | ||
+ | |||
+ | Program používa premennú typu '''bool''', do ktorej môžeme priraďovať logické hodnoty true alebo false. | ||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | #include <cstdlib> | ||
+ | #include <ctime> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | /* vygenerujeme náhodné číslo medzi 1 a 100 */ | ||
+ | srand(time(NULL)); | ||
+ | int number = rand() % 100 + 1; | ||
+ | |||
+ | /* Pamätáme si, či sme už uhádli alebo nie. */ | ||
+ | bool guessed = false; | ||
+ | cout << "Guess a number between 1 and 100: "; | ||
+ | /* Kým užívateľ neuhádne, spýtame sa ho na ďalšiu | ||
+ | odpoveď. */ | ||
+ | while (!guessed) { | ||
+ | int guess; | ||
+ | cin >> guess; | ||
+ | /* Vyhodnotíme odpoveď. */ | ||
+ | if (guess < number) { | ||
+ | cout << "Too low, try again: "; | ||
+ | } else if (guess > number) { | ||
+ | cout << "Too high, try again: "; | ||
+ | } else if (guess == number) { | ||
+ | guessed = true; | ||
+ | cout << "Correct guess" << endl; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Príklad priebehu programu: | ||
+ | <pre> | ||
+ | Guess a number between 1 and 100: 50 | ||
+ | Too low, try again: 75 | ||
+ | Too high, try again: 63 | ||
+ | Too low, try again: 69 | ||
+ | Too high, try again: 66 | ||
+ | Too low, try again: 67 | ||
+ | Correct guess | ||
+ | </pre> | ||
+ | |||
+ | ===Príkazy break a continue (používať s mierou)=== | ||
+ | |||
+ | * Príkaz break: skončí sa cyklus, v ktorom práve sme, pokračuje sa prvým príkazom za cyklom. | ||
+ | * Príkaz continue: ide na ďalšiu iteráciu cyklu, nevykoná zvyšok tela cyklu. | ||
+ | Používať s mierou, robia program menej prehľadný, ľahko zavlečú chyby. | ||
+ | |||
+ | Program uvedený vyššie môžeme prepísať bez boolovskej premennej s použitím nekonečného cyklu, z ktorého ale vyskočíme príkazom break, keď užívateľ uhádne. | ||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | #include <cstdlib> | ||
+ | #include <ctime> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | /* vygenerujeme náhodné číslo medzi 1 a 100 */ | ||
+ | srand(time(NULL)); | ||
+ | int number = rand() % 100 + 1; | ||
+ | |||
+ | cout << "Guess a number between 1 and 100: "; | ||
+ | /* Kým užívateľ neuhádne, spýtame sa ho na ďalšiu | ||
+ | odpoveď. */ | ||
+ | while (true) { | ||
+ | int guess; | ||
+ | cin >> guess; | ||
+ | /* Vyhodnotíme odpoveď. */ | ||
+ | if (guess < number) { | ||
+ | cout << "Too low, try again: "; | ||
+ | } else if (guess > number) { | ||
+ | cout << "Too high, try again: "; | ||
+ | } else if (guess == number) { | ||
+ | cout << "Correct guess" << endl; | ||
+ | break; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Späť k cyklu for== | ||
+ | |||
+ | Cyklus for má tvar | ||
+ | <pre> | ||
+ | for(prikaz1; podmienka; prikaz2) { | ||
+ | prikaz3; | ||
+ | } | ||
+ | </pre> | ||
+ | Je ekvivalentný nasledujúcemu príkazu while: | ||
+ | <pre> | ||
+ | prikaz1; | ||
+ | while(podmienka) { | ||
+ | prikaz3; | ||
+ | prikaz2; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Napríklad, nasledujúce kúsky kódu oba vypisujú čísla 0 až 9: | ||
+ | <pre> | ||
+ | for (int i = 0; i < 10; i++) { | ||
+ | cout << " " << i; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | <pre> | ||
+ | int i = 0; | ||
+ | while(i < 10) { | ||
+ | cout << " " << i; | ||
+ | i++; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Cyklus for spravidla používame, ak má náš cyklus krátky a jednoduchý iterátor (prikaz2) a jednoduchú podmienku. V opačnom prípade väčšinou používame cyklus while. | ||
+ | |||
+ | |||
+ | ===Ešte vypisovanie deliteľov=== | ||
+ | |||
+ | Ak chceme vypísať deliteľov od najväčších, stačí prepísať for cyklus: | ||
+ | * od najmenších: <tt>for (int i = 1; i <= n; i++) {</tt> | ||
+ | * od najväčších: <tt>for (int i = n; i > 0; i--) {</tt> | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | int n; | ||
+ | cout << "Please enter some number: "; | ||
+ | cin >> n; | ||
+ | |||
+ | cout << "Divisors of " << n << ":"; | ||
+ | for (int i = n; i > 0; i--) { | ||
+ | if (n % i == 0) { | ||
+ | cout << " " << i; | ||
+ | } | ||
+ | } | ||
+ | cout << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | |||
+ | Príklad behu programu: | ||
+ | <pre> | ||
+ | Please enter some number: 30 | ||
+ | Divisors of 30: 30 15 10 6 5 3 2 1 | ||
+ | </pre> | ||
+ | |||
+ | Zrýchlime program na vypisovanie deliteľov: ak i je deliteľ n, aj n/i je deliteľ, môžeme ho rovno vypísať. Aspoň jeden z tejto dvojice je najviac odmocnina z n. | ||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | int n; | ||
+ | cout << "Please enter some number: "; | ||
+ | cin >> n; | ||
+ | |||
+ | cout << "Divisors of " << n << ":"; | ||
+ | |||
+ | for(int i=1; i*i<=n; i++) { | ||
+ | if (n % i == 0) { | ||
+ | int j = n / i; | ||
+ | cout << " " << i << " " << j; | ||
+ | } | ||
+ | } | ||
+ | cout << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | Cvičenie: Tento program nefunguje celkom správne, občas vypíše nejaké číslo dvakrát. Kedy? Ako ho vieme opraviť? | ||
+ | |||
+ | Pomalší program, ktorý skúša všetky čísla po n trvá pre n=1234567890 na mojom počítači 4.5s. Program, ktorý ide iba po odmocninu trvá 0.0002s. | ||
+ | |||
+ | ==Vnorené cykly== | ||
+ | |||
+ | Vykreslime šachovnicu s n x n štvorčekmi, ktoré sú striedavo čierne a žlté. | ||
+ | * Potrebujeme na to dva vnorené cykly, jeden pôjde cez riadky šachovnice, druhý pre stĺpce. | ||
+ | * Ak row + column je párne, kreslíme čierny štvorec, inak kreslíme žltý. | ||
+ | <pre> | ||
+ | #include "../SimpleDraw.h" | ||
+ | |||
+ | int main(void) { | ||
+ | int n = 8; /* počet štvorcov v riadku a stĺpci*/ | ||
+ | int square = 20; /* veľkosť jedného štvorca */ | ||
+ | int size = n * square; /* veľkosť obrázku */ | ||
+ | |||
+ | SimpleDraw window(size, size); | ||
+ | |||
+ | for (int row = 0; row < n; row++) { | ||
+ | for (int column = 0; column < n; column++) { | ||
+ | if ((row + column) % 2 == 0) { | ||
+ | window.setBrushColor("black"); | ||
+ | } else { | ||
+ | window.setBrushColor("yellow"); | ||
+ | } | ||
+ | window.drawRectangle(column * square, row * square, | ||
+ | square, square); | ||
+ | } | ||
+ | } | ||
+ | window.showAndClose(); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | To isté, ale najskôr vykreslíme veľký žltý štvorec, potom do neho vkresľujeme malé čierne štvorčeky. | ||
+ | * V cykle pre stĺpce preskakujeme každý druhý štvorec, pričom ak row je párny, začíname od 0, ak je nepárny, začíname od 1 | ||
+ | ** <tt>for (int column = row % 2; column < n; column += 2) {</tt> | ||
+ | ** príkaz <tt>column += 2</tt> je to isté ako <tt>column = column + 2</tt> | ||
+ | |||
+ | <pre> | ||
+ | #include "../SimpleDraw.h" | ||
+ | |||
+ | int main(void) { | ||
+ | int n = 8; /* počet štvorcov v riadku a stĺpci*/ | ||
+ | int square = 20; /* veľkosť jedného štvorca */ | ||
+ | int size = n * square; /* veľkosť obrázku */ | ||
+ | |||
+ | SimpleDraw window(size, size); | ||
+ | |||
+ | /* veľký žltý štvorec */ | ||
+ | window.setBrushColor("yellow"); | ||
+ | window.drawRectangle(0,0,size,size); | ||
+ | |||
+ | /* nastavíme farbu na čiernu */ | ||
+ | window.setBrushColor("black"); | ||
+ | |||
+ | for (int row = 0; row < n; row++) { | ||
+ | for (int column = row % 2; column < n; column += 2) { | ||
+ | window.drawRectangle(column * square, row * square, | ||
+ | square, square); | ||
+ | } | ||
+ | } | ||
+ | window.showAndClose(); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Zhrnutie== | ||
+ | * Videli sme niekoľko príkladov využitia cyklov for a while. | ||
+ | * Cyklus for je možné zapísať ako while (a naopak). | ||
+ | * Logické hodnoty true a false vieme ukladať do premenných typu bool. | ||
+ | * Z cyklu vieme vyskočiť príkazom break, prejsť na ďalšiu iteráciu príkazom continue. Používať s mierou. | ||
+ | * Euklidov algoritmus rýchlo nájde najväčšieho spoločného deliteľa dvoch čísel. | ||
+ | * Dôležitá je prehľadná úprava programov a názvy premenných súvisiace s ich obsahom. | ||
+ | * Netbeans umožňuje krokovať program, mali by ste to však vedieť robiť aj ručne. | ||
+ | |||
+ | ==Organizačné poznámky== | ||
+ | * Dnes cvičenia podľa pôvodného rozvrhu, prvá rozcvička | ||
+ | * O 14:50 v F-108 test pre pokročilých | ||
+ | * Zajtra prednáška, téma podprogramy | ||
+ | * Na stránke zadania DÚ1, riešte do pondelka 1.10.2012 (koncom tohto týždňa pribudnú zadania DÚ2) | ||
+ | =Prednáška 4= | ||
+ | |||
+ | * ''Funkcia'' je skupina príkazov s určitým menom, ktorú môžeme spustiť a vykonať tak určitú akciu alebo vypočítať určitú hodnotu | ||
+ | ** Možno ste stretli iné termíny s podobným významom, ako ''procedúra'', ''metóda'', ''podprogram'' | ||
+ | * V našich programoch sme už používali hotové funkcie | ||
+ | ** Napríklad <tt>sqrt(x)</tt> je funkcia, ktorá nám povie druhú odmocninu čísla ''x''. | ||
+ | ** V grafických programoch sme napríklad používali funkciu <tt>window.drawRectangle(x, y, s, v)</tt> z knižnice SimpleDraw, ktorá na grafickej obrazovke vykreslí obdĺždnik. | ||
+ | |||
+ | Teraz sa pozrieme na to, ako vytvoriť v programe vlastnú funkciu. Doteraz sme vytvorili jedinú funkciu - funkciu main. | ||
+ | |||
+ | ==Motivačný príklad: Obvod trojuholníka == | ||
+ | Chceme napísať program, ktorý načíta súradnice vrcholov trojuholníka a spočíta jeho obvod, tu je príklad jeho behu: | ||
+ | <pre> | ||
+ | Zadaj suradnice vrcholu A oddelene medzerou: 0 0 | ||
+ | Zadaj suradnice vrcholu B oddelene medzerou: 3 0 | ||
+ | Zadaj suradnice vrcholu C oddelene medzerou: 0 4 | ||
+ | Obvod trojuholnika ABC: 12 | ||
+ | </pre> | ||
+ | |||
+ | Obvod spočítame ako súčet dĺžok jednotlivých strán, v programe teda trikrát opakujeme výpočet dĺžky strany. Pri opakovaní dlhšieho vzorca ľahko spravíme chybu. | ||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | #include <cmath> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | double xa, ya, xb, yb, xc, yc; | ||
+ | cout << "Zadaj suradnice vrcholu A oddelene medzerou: "; | ||
+ | cin >> xa >> ya; | ||
+ | cout << "Zadaj suradnice vrcholu B oddelene medzerou: "; | ||
+ | cin >> xb >> yb; | ||
+ | cout << "Zadaj suradnice vrcholu C oddelene medzerou: "; | ||
+ | cin >> xc >> yc; | ||
+ | /* spocitaj dlzky stran */ | ||
+ | double da = sqrt((xb - xc) * (xb - xc) + (yb - yc) * (yb - yc)); | ||
+ | double db = sqrt((xa - xc) * (xa - xc) + (ya - yc) * (ya - yc)); | ||
+ | double dc = sqrt((xa - xb) * (xa - xb) + (ya - yb) * (ya - yb)); | ||
+ | cout << "Obvod trojuholnika ABC: " << da + db + dc << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Definícia funkcie=== | ||
+ | Vzorec na výpočet môžeme zapísať ako funkciu: | ||
+ | <pre> | ||
+ | double dlzka(double x1, double y1, double x2, double y2) { | ||
+ | return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Definícia funkcie má nasledovné časti: | ||
+ | * '''Návratová hodnotu funkcie:''' Naša funkcia vracia dĺžku, teda hodnotu typu <tt>double</tt> (desatinné číslo). V prípade, že by funkcia nemala vrátiť nič, jej návratová hodnota je typu '''void'''. Také sú napríklad funkcie, ktoré niečo vypisujú alebo vykresľujú. | ||
+ | * '''Názov funkcie:''' zvolíme si ako chceme, podobne ako pri premenných. Vhodné je použiť názov, ktorý vystihuje, čo funkcia počíta, napríklad <tt>dlzka</tt> | ||
+ | * '''Zoznam parametrov funkcie:''' V zátvorkách za názvom funkcie je zoznam typov a názvov premenných, ktoré funkcia očakáva. V našom príklade funkcia očakáva súradnice dvoch vrcholov, teda štyri hodnoty typu double. Funkcie môžu mať zoznam parametrov aj prázdny. | ||
+ | * '''Telo funkcie:''' V zložených zátvorkách za definíciou funkcie je jej vlastný obsah, teda zoznam príkazov, ktoré má funkcia vykonať. | ||
+ | * '''Príkaz return:''' Vracia hodnotu funkcie. | ||
+ | |||
+ | ===Program s využitím funkcie=== | ||
+ | Celý program s funkciou dlzka | ||
+ | * vzorec na výpočet dĺžky je teraz iba na jednom mieste | ||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | #include <cmath> | ||
+ | using namespace std; | ||
+ | |||
+ | double dlzka(double x1, double y1, double x2, double y2) { | ||
+ | return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)); | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | double xa, ya, xb, yb, xc, yc; | ||
+ | cout << "Zadaj suradnice vrcholu A oddelene medzerou: "; | ||
+ | cin >> xa >> ya; | ||
+ | cout << "Zadaj suradnice vrcholu B oddelene medzerou: "; | ||
+ | cin >> xb >> yb; | ||
+ | cout << "Zadaj suradnice vrcholu C oddelene medzerou: "; | ||
+ | cin >> xc >> yc; | ||
+ | /* spocitaj dlzky stran */ | ||
+ | double da = dlzka(xb, yb, xc, yc); | ||
+ | double db = dlzka(xa, ya, xc, yc); | ||
+ | double dc = dlzka(xa, ya, xb, yb); | ||
+ | cout << "Obvod trojuholnika ABC: " << da + db + dc << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Funkcia môže obsahovať aj viacero príkazov. V našom príklade môžeme napríklad výpočet rozložiť na tri kroky: | ||
+ | <pre> | ||
+ | double dlzka(double x1, double y1, double x2, double y2) { | ||
+ | double dx = x1 - x2; | ||
+ | double dy = y1 - y2; | ||
+ | return sqrt(dx * dx + dy * dy); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | '''Cvičenie:''' v Pascale je funkcia sqr(x), ktorá vráti x na druhú. Naprogramujte túto funkciu v jazyku C a použite ju na zjednodušenie funkcie dlzka. | ||
+ | * V jazyku C by sme mohli použiť pow(x,2), ale môže byť jednoduchšie zrátať x*x. | ||
+ | |||
+ | |||
+ | |||
+ | == Príkaz return == | ||
+ | |||
+ | * Pri vykonaní príkazu <tt>return</tt> je funkcia okamžite zastavená a jej výstupná hodnota je výraz za slovom <tt>return</tt>. | ||
+ | * Ak funkcia má niečo vrátiť (jej návratový typ nie je <tt>void</tt>), musí obsahovať <tt>return</tt>. | ||
+ | ** Príkazov return môže obsahovať viac, ale tak, aby každé možné prejdenie funkciou bolo ukončené príkazom return. | ||
+ | |||
+ | Dva spôsoby, ako napísať funkciu <tt>min</tt>, ktorá vráti menšie z dvoch zadaných čísel ''a'' a ''b'': | ||
+ | <pre> | ||
+ | int min(int a, int b) { | ||
+ | int minval; | ||
+ | if (a < b) { | ||
+ | minval = a; | ||
+ | } else { | ||
+ | minval = b; | ||
+ | } | ||
+ | return minval; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | <pre> | ||
+ | int min(int a, int b) { | ||
+ | if (a < b) { | ||
+ | return a; | ||
+ | } else { | ||
+ | return b; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Vo funkciách, ktoré vracajú void, môže ale nemusí byť return. To znamená, že oba nasledovné programy sú v poriadku. | ||
+ | <pre> | ||
+ | void printmessage () | ||
+ | { | ||
+ | cout << "I'm a function!"; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | <pre> | ||
+ | void printmessage () | ||
+ | { | ||
+ | cout << "I'm a function!"; | ||
+ | return; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | '''Cvičenie:''' čo vráti nasledujúca funkcia pre n=6? Čo vráti pre n=7? Viete stručne popísať, čo robí pre všeobecné n? | ||
+ | <pre> | ||
+ | int zahada(int n) { | ||
+ | for (int i = 2; i * i <= n; i++) { | ||
+ | if (n % i == 0) { return i; } | ||
+ | } | ||
+ | return n; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | == Lokálne a globálne premenné == | ||
+ | |||
+ | * '''Globálne premenné''' sú definované mimo akejkoľvek funkcie | ||
+ | ** môžu ich používať všetky funkcie definované pod nimi | ||
+ | * '''Lokálne premenné''' sú definované vo vnútri funkcie | ||
+ | ** môže ich používať iba táto funkcia | ||
+ | |||
+ | Príklad: program s globálnou premennou x a dvomi lokálnymi premennými v rôznych funkciách | ||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | int x = 0; // globálna premenná | ||
+ | |||
+ | void vypis() { | ||
+ | int y = 1; // lokálna premenná vo funkcii vypis | ||
+ | cout << x << " " << y << endl; | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | int z = 2; // lokálna premenná vo funkcii main | ||
+ | cout << x << " " << z << endl; | ||
+ | vypis(); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Viaceré funkcie môžu mať lokálne premenné s tým istým menom, každá používa tú svoju | ||
+ | * Ak má lokálna a globálna premenná to isté meno, lokálna premenná prekryje globálnu, funkcia teda používa svoju lokálnu premennú (bližšia košeľa ako kabát) | ||
+ | |||
+ | Príklad: | ||
+ | <pre> | ||
+ | void Fnc () { | ||
+ | // i=13; – nemôžeme používať premennú i – žiadna premenná i nie je viditeľná | ||
+ | } | ||
+ | |||
+ | int i; | ||
+ | |||
+ | void Fnc2 () { | ||
+ | i=50; // priradí sa do globálne premennej i! | ||
+ | Fnc (); | ||
+ | } | ||
+ | |||
+ | void Fnc1 () { | ||
+ | int i; | ||
+ | i=2; // priradí sa do lokálnej premennej i, ktorá vznikla v tejto funkcii | ||
+ | // uvedomte si, že v tomto okamihu existujú 3 premenné s menom i : | ||
+ | // i – globálna premenná, | ||
+ | // lokálna premenná i, ktorá vznikla vo funkcii main, | ||
+ | // a lokálna premenná i, ktorá vznikla v tejto funkcii. | ||
+ | } | ||
+ | |||
+ | void main () { | ||
+ | int i; | ||
+ | i=1; | ||
+ | // priraďuje sa do lokálnej premennej i a nie do globálnej premennej i, | ||
+ | // globálna premenná i je prekrytá – identifikátor i označuje lokálnu premennú i. | ||
+ | Fnc1 (); | ||
+ | // lokálna premenná i má stále hodnotu 1 | ||
+ | Fnc2 (); | ||
+ | // lokálna premenná i má stále hodnotu 1, globálna premenná i má hodnotu 50, | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | == Parametre funkcií == | ||
+ | |||
+ | === Odovzdávanie parametrov hodnotou=== | ||
+ | |||
+ | Funkcie majú často parametre. | ||
+ | * Tieto parametre sa správajú ako lokálne premenné danej funkcie | ||
+ | * Pri volaní funkcie sa im priradí hodnota, ktorú zadal používateľ funkcie (tento mechanizmus voláme '''odovzdávanie parametrov hodnotou''') | ||
+ | * Túto hodnotu síce môžeme meniť, ale táto zmena sa neprejaví na mieste, odkiaľ funkciu voláme | ||
+ | |||
+ | Príklad: | ||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | void vypis(int x) { | ||
+ | cout << "Predtym: " << x; /* vypiseme povodnu hodnotu x */ | ||
+ | x++; /* zvysime hodnotu x o 1 */ | ||
+ | cout << ", potom: " << x << endl; /* vypiseme nove x */ | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | int x = 0; | ||
+ | int y = 3; | ||
+ | vypis(x); /* vypise Predtym: 0, potom: 1 */ | ||
+ | vypis(x); /* vypise Predtym: 0, potom: 1 */ | ||
+ | vypis(y); /* vypise Predtym: 3, potom: 4 */ | ||
+ | vypis(y); /* vypise Predtym: 3, potom: 4 */ | ||
+ | vypis(y + 7); /* vypise Predtym: 10, potom: 11 */ | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Odovzdávanie parametrov referenciou=== | ||
+ | * Ak pred meno parametra v hlavičke funkcie dáme '''&''', parameter sa bude '''odovzdávať referenciou''' | ||
+ | * Pri použití takejto funkcie môžeme ako parameter zadať iba premennú, nie iný výraz | ||
+ | * Namiesto samotnej hodnoty sa funkcii pošle adresa premennej v pamäti (referencia) | ||
+ | * Táto sa bude vo funkcii používať pod novým menom, prípadné zmeny sa prejavia aj na mieste, odkiaľ sme funkciu volali | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | void vypis(int & x) { | ||
+ | cout << "Predtym: " << x; /* vypiseme povodnu hodnotu x */ | ||
+ | x++; /* zvysime hodnotu x o 1 */ | ||
+ | cout << ", potom: " << x << endl; /* vypiseme nove x */ | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | int x = 0; | ||
+ | int y = 3; | ||
+ | vypis(x); /* vypise Predtym: 0, potom: 1 */ | ||
+ | vypis(x); /* vypise Predtym: 1, potom: 2 */ | ||
+ | vypis(y); /* vypise Predtym: 3, potom: 4 */ | ||
+ | vypis(y); /* vypise Predtym: 4, potom: 5 */ | ||
+ | /* vypis(y + 7); toto teraz nemozeme pouzit, y+7 nie je premenna */ | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Odovzdávanie referenciou: viac ako jedna návratová hodnota === | ||
+ | |||
+ | Odovzdávanie parametra referenciou používame napríklad vtedy, ak máme vrátiť viac ako jednu hodnotu. | ||
+ | |||
+ | Funkcia stred dostane hodnotou súradnice dvoch bodov (x1,y1) a (x2,y2) a do parametrov xs, ys, ktoré sú odovzdané referenciou, uloží súradnice stredu úsečky. | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | void stred(double x1, double y1, double x2, double y2, double &xs, double &ys) { | ||
+ | xs = (x1 + x2) / 2; | ||
+ | ys = (y1 + y2) / 2; | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | |||
+ | double x1, y1, x2, y2; | ||
+ | double x, y; | ||
+ | |||
+ | cout << "Napiste suradnice jedneho konca usecky (oddelene medzerou): "; | ||
+ | cin >> x1 >> y1; | ||
+ | |||
+ | cout << "Napiste suradnice druheho konca usecky (oddelene medzerou): "; | ||
+ | cin >> x2 >> y2; | ||
+ | |||
+ | stred(x1, y1, x2, y2, x, y); | ||
+ | cout << "Stred usecky je [" << x << "," << y << "]." << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Odovzdávanie referenciou: Funkcia, ktorej úlohou je zmeniť svoj parameter === | ||
+ | Ďalší dôvod pre odovzdávanie parametrov referenciou je, keď chceme vo funkcii priamo parameter meniť s trvalými následkami. | ||
+ | * Typickým príkladom je funkcia <tt>swap</tt>, ktorá vymení hodnoty dvoch premenných, ktoré dostane ako parametre | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | void swap(int &a, int &b) { | ||
+ | int tmp = a; | ||
+ | a = b; | ||
+ | b = tmp; | ||
+ | } | ||
+ | |||
+ | int main() { | ||
+ | int x = 1, y = 3; | ||
+ | swap(x, y); | ||
+ | cout << "x=" << x << ", y=" << y << endl; | ||
+ | return 0; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Keby sme funkcii odovzdali parameter hodnotou tj, <tt>void swap(int a, int b)</tt>, vo funkcii main by sa premenné nevymenili. | ||
+ | |||
+ | === Odovzdávanie indikátoru chyby === | ||
+ | |||
+ | Niektoré funkcie potrebujú, aby parameter spĺňal určité podmienky. Napríklad odmocninu vieme spočítať iba z nezáporného čísla. Čo vlastne môžeme urobiť, keď dostaneme zlý parameter? | ||
+ | |||
+ | * Môžeme okamžite ukončiť celý program. V knižnici <tt>cstdlib</tt> je funkcia <tt>exit</tt>, ktorá robí presne to. Má ako parameter návratovú hodnotu celého programu | ||
+ | <pre> | ||
+ | double mySqrt(double x) { | ||
+ | if (x < 0) { exit(1); } // zlý vstup: ukončíme program | ||
+ | else { return sqrt(x); } // dobrý vstup: spočítame odmocninu | ||
+ | } | ||
+ | </pre> | ||
+ | * Pohodlnejší spôsob ukončenia programu pri zlom vstupe je funkcia <tt>assert</tt> z knižnice <tt>cassert</tt>, ktorá ako parameter dostane logickú hodnotu, a ak je tá hodnota nepravda, ukončí program s chybovou hláškou. | ||
+ | ** Pri dôležitých programoch ale nechceme, aby len tak skončili pri každej chybe | ||
+ | <pre> | ||
+ | double mySqrt(double x) { | ||
+ | assert(x >= 0); // tvrdime, ze x>=0, inak program skonci | ||
+ | return sqrt(x); // teraz mozeme veselo odmocnovat | ||
+ | } | ||
+ | </pre> | ||
+ | * Bežný spôsob, o ktorom sa budeme učiť v druhom semestri, sú takzvané ''výnimky'' (exceptions) | ||
+ | * Môžeme vrátiť nejakú špeciálnu hodnotu, ktorá odzrkadľuje, že vstup bol zlý. Používateľ funkcie by mal túto hodnotu rozoznať od správneho výstupu funkcie. Ale dôvera v používateľa sa všeobecne v softvérovom inžinierstve neodporúča. | ||
+ | ** Knižničná funkcia sqrt vráti pre záporné čísla špeciálnu hodnotu NaN (not a number), my vrátime napr. -1 | ||
+ | <pre> | ||
+ | double mySqrt(double x) { | ||
+ | if (x < 0) { return -1; } // zlý vstup: vrátime -1 | ||
+ | else { return sqrt(x); } // dobrý vstup: spočítame odmocninu | ||
+ | } | ||
+ | </pre> | ||
+ | * Môžeme ako výstup funkcie vrátiť, či sa podarilo alebo nepodarilo správne vypočítať hodnotu. Výstupom funkcie bude logická hodnota typu bool a samotnú hodnotu vrátime v parametri odovzdanom referenciou | ||
+ | <pre> | ||
+ | bool mySqrt(double x, double & result) { | ||
+ | if (x < 0) { return false; } // zlý vstup: vrátime false | ||
+ | else { | ||
+ | result = sqrt(x); // dobrý vstup: spočítame odmocninu a vrátime true | ||
+ | return true; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | == Ešte jeden príklad: Fibonacciho čísla == | ||
+ | |||
+ | [http://sk.wikipedia.org/wiki/Fibonacciho_postupnos%C5%A5 Fibonacciho postupnosť] je postupnosť čísel, v ktorej každý ďalší člen je súčtom dvoch predchádzajúcich. Jednotlivé členy postupnosti sa nazývajú Fibonacciho čísla. | ||
+ | |||
+ | 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393… | ||
+ | |||
+ | Na výpočet Fibonacciho čísel používame nasledovný vzťah: | ||
+ | * F(0) = 0 | ||
+ | * F(1) = 1 | ||
+ | * F(n)=F(n-1)+F(n-2) | ||
+ | |||
+ | Napíšeme funkciu, ktorá bude počítať Fibonacciho čísla. Na otázku "Aké je ôsme Fibonacciho číslo?" teda odpovie "21". | ||
+ | * '''Cvičenie:''' Pozor, nefunguje správne pre nulu, skúste opraviť | ||
+ | <pre> | ||
+ | int fibonacci(int n) { | ||
+ | |||
+ | int f = 1; // Cislo F(i) | ||
+ | int oldF = 0; // Cislo F(i-1) | ||
+ | |||
+ | for (int i = 2; i <= n; i++) { | ||
+ | int newF = f + oldF; // spocitaj nove F(i) pre vyssie i | ||
+ | oldF = f; // poposuvaj hodnoty | ||
+ | f = newF; | ||
+ | } | ||
+ | |||
+ | return f; | ||
+ | }</pre> | ||
+ | '''Cvičenie:''' napíšte funkciu printFibonacci, ktorá vypíše prvých n Fibonacciho čísel. | ||
+ | * Akú by mala mať hlavičku? | ||
+ | * Skúste dva spôsoby implementácie: | ||
+ | ** volaním funkcie fibonacci pre rôzne hodnoty n | ||
+ | ** prepísaním tejto funkcie, aby sa hodnoty vypisovali priamo ako sa počítajú | ||
+ | * Ktorý spôsob bude rýchlejší pre veľké n a prečo? | ||
+ | |||
+ | == Ďalšie poznámky o funkciách == | ||
+ | |||
+ | === Kde definovať funkciu? === | ||
+ | Funkcia musí byť definovaná pred tým, ako ju v programe použijeme, aby kompilátor vedel skontrolovať korektnosť jej použitia (počet parametrov, ich typ..). | ||
+ | |||
+ | V prípade, že to nie je možné urobiť, potrebujeme aspoň dopredu oznámiť, že takéto funkcie budú. Urobíme to pomocou '''prototypu funkcie''' | ||
+ | <tt>type name ( argument_type1, argument_type2, ...);</tt> | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | void odd (int a); // prototypy | ||
+ | void even (int a); | ||
+ | |||
+ | int main () | ||
+ | { | ||
+ | int i; | ||
+ | do { | ||
+ | cout << "Type a number (0 to exit): "; | ||
+ | cin >> i; | ||
+ | odd (i); | ||
+ | } while (i!=0); | ||
+ | return 0; | ||
+ | } | ||
+ | |||
+ | void odd (int a) | ||
+ | { | ||
+ | if ((a%2)!=0) cout << "Number is odd.\n"; | ||
+ | else even (a); | ||
+ | } | ||
+ | |||
+ | void even (int a) | ||
+ | { | ||
+ | if ((a%2)==0) cout << "Number is even.\n"; | ||
+ | else odd (a); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Funkcia main === | ||
+ | |||
+ | Má od ostatných funkcií niekoľko odlišností | ||
+ | |||
+ | * Síce má návratový typ (int), ale nemusí nič vracať. | ||
+ | * V programe sa nemôže volať - jediné jej volanie je automatické (začína sa ním beh programu) | ||
+ | * Má predpísané argumenty, ktoré sa dajú vynechať (viac o nich neskôr) | ||
+ | |||
+ | == Príklad: obmena problému z cvičení == | ||
+ | |||
+ | Máme dané dva intervaly [a,b] a [c,d] a chceme buď vypísať ich prienik, alebo správu, že sú disjunktné. Podobný príklad sme riešili na cvičeniach pomocou vnorených podmienok. | ||
+ | * Vzniká viacero možností, podľa toho, či prvý interval začína naľavo alebo napravo od druhého | ||
+ | * Prácu si teda zjednodušíme tým, že ak je prvý interval napravo, prehodíme intervaly. | ||
+ | * Potom máme isté, že prvý interval začína skôr ako druhý, a teda intervaly sú disjunktné práve vtedy, ak prvý aj skončí skôr ako druhý začne. | ||
+ | * V opačnom prípade je prienik od začiatku druhého intervalu po prvý koniec, teda menšie z čísel b,d. | ||
+ | * V programe môžeme využiť funkcie <tt>min</tt> a <tt>swap</tt>, ktoré sme videli vyššie. | ||
+ | ** Dobre navrhnuté funkcie sa často dajú použiť vo viacerých programoch. | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | void swap(int &x, int &y) { | ||
+ | int tmp = x; | ||
+ | x = y; | ||
+ | y = tmp; | ||
+ | } | ||
+ | |||
+ | int min(int x, int y) { | ||
+ | if (x < y) { | ||
+ | return x; | ||
+ | } else { | ||
+ | return y; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | int a, b, c, d; | ||
+ | cout << "Zadajte zaciatok a koniec prveho intervalu: "; | ||
+ | cin >> a >> b; | ||
+ | cout << "Zadajte zaciatok a koniec druheho intervalu: "; | ||
+ | cin >> c >> d; | ||
+ | |||
+ | /* Chceme, aby zaciatok prveho intervalu bol <= zaciatku druheho. */ | ||
+ | if (c < a) { | ||
+ | swap(a, c); | ||
+ | swap(b, d); | ||
+ | } | ||
+ | |||
+ | if (b < c) { | ||
+ | cout << "Intervaly su disjunktne." << endl; | ||
+ | } else { | ||
+ | cout << "Ich prienik je interval [" << c << "," << min(b, d) << "]" << endl; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Zhrnutie== | ||
+ | * Funkcie nám umožňujú rozbiť väčší program na menšie logické časti a tým ho sprehľadniť. Tiež nám umožňujú vyhnúť sa opakovaniu podobných kusov kódu. | ||
+ | * Hlavička funkcie obsahuje návratový typ (môže byť void), meno funkcie, typy a mená parametrov. | ||
+ | * V tele funkcie sú samotné príkazy. Vypočítanú hodnotu vrátime príkazom return. | ||
+ | * Lokálne premenné sú viditeľné len vo funkcii, ktoré ich definuje, globálne vo všetkých funkciách. | ||
+ | * Parametre odovzdávané hodnotou sú lokálne premenné inicializované určitou hodnotou, ktorú zadá užívateľ funkcie. | ||
+ | * Parametre odovzdávané referenciou (&) sú len novým menom pre inú premennú. | ||
+ | |||
+ | ==Organizačné poznámky== | ||
+ | * Na stránke zadania DÚ1, riešte do pondelka 1.10.2012 | ||
+ | ** Ak chcete namiesto toho robiť DÚ pre pokročilých, hláste sa vyučujúcim | ||
+ | * Vo štvrtok na stránke pribudnú zadania DÚ2 | ||
+ | * Výsledky testu pre pokročilých pravdepodobne dnes v Moodli | ||
+ | * Budúci týždeň opäť prednášky, cvičenia a rozcvička (z tohtotýždenných cvičení) | ||
+ | * Nezabudnite si v AISe spraviť prípadné zmeny v zápise (do nedele 30.9.) a dať si ich potvrdiť na študijnom (do piatku 5.10.). Pred koncom tejto doby bývajú na študijnom dlhé rady, choďte čím skôr. | ||
+ | =Cvičenia 2= | ||
+ | Úlohou dnešného cvičenia je precvičiť si logické a aritmetické výrazy, podmienky a jednoduché použitie cyklu for. | ||
+ | |||
+ | * Nasledujúce dva úryvky programu robia to isté, pričom prvý používa logický operátor && (and) a druhý používa dva príkazy if: | ||
+ | <pre> | ||
+ | //Verzia 1: | ||
+ | if(x>0 && y>0) { cout << "Yes!"; } | ||
+ | |||
+ | //Verzia 2: | ||
+ | if(x>0) { | ||
+ | if(y>0) { cout << "Yes!"; } | ||
+ | } | ||
+ | </pre> | ||
+ | * Podobne nahraďte logické operátory && a || aj v nasledujúcich príkazoch: | ||
+ | <pre> | ||
+ | if(x>0 || y>0) { cout << "Yes!"; } | ||
+ | if (x>0 || (x<0 && y<0)) { cout << "Yes!"; } | ||
+ | if (x<0 && (y<0 || z<0)) { cout << "Yes!"; } | ||
+ | </pre> | ||
+ | |||
+ | * Nech x je nejaký logický výraz. Čomu sa rovnajú nasledovné výrazy? | ||
+ | <pre> | ||
+ | x && true | ||
+ | x && false | ||
+ | x || true | ||
+ | x || false | ||
+ | x && x | ||
+ | x || x | ||
+ | x && !x | ||
+ | x || !x | ||
+ | x == true | ||
+ | x == false | ||
+ | </pre> | ||
+ | |||
+ | * Napíšte program, ktorý načíta dve čísla a vypíše to väčšie z nich. | ||
+ | |||
+ | * Napíšte program, ktorý korytnačou grafikou vykreslí pravidelný n-uholník. V programe si zadefinujte a použite nasledujúce premenné | ||
+ | <pre> | ||
+ | int size = 300; /* veľkosť obrázku */ | ||
+ | int length = 200; /* dĺžka strany */ | ||
+ | int n = 4; /* počet strán */ | ||
+ | </pre> | ||
+ | Vyskúšajte meniť hodnoty premenných a pozrite si výsledok. | ||
+ | |||
+ | * Napíšte program, ktorý načíta tri celé čísla a vypíše, či môžu byť stranami jedného trojuholníka. | ||
+ | |||
+ | * Napíšte program, ktorý vypíše tabuľku druhých mocnín čísel 1,2,...,n. Výstup bude mať takúto formu: | ||
+ | <pre> | ||
+ | 1 squared is 1 | ||
+ | 2 squared is 4 | ||
+ | 3 squared is 9 | ||
+ | ... | ||
+ | </pre> | ||
+ | |||
+ | * Napíšte program, ktorý načíta štyri celé čísla a,b,c,d, ktoré predstavujú dva uzavreté intervaly [a,b] a [c,d]. Program vypíše tú z nasledujúcich viet, ktorá pre ne platí: | ||
+ | |||
+ | Intervaly su disjunktne (maju prazdny prienik). | ||
+ | Jeden z intervalov je podmnozinou druheho. | ||
+ | Intervaly sa pretinaju, ale ziaden nie je podmnozinou druheho. | ||
+ | |||
+ | * Napíšte program, ktorý načíta dĺžku základne a výšku rovnoramenného trojuholníka a vykreslí ho pomocou drawLine. Veľkosť obrázku môžete zvoliť pevne 300x300 a horný vrchol trojuholníka (150,20). | ||
+ | ** Prepíšte predchádzajúci program, aby používal korytnačiu grafiku. Potrebné dĺžky spočítajte Pytagorovou vetou a uhly spočítajte napr. funkciou atan (arkus tangens). Pozor, atan vracia radiány, treba prepočítať na stupne. Zadefinujte si a použite premennú double pi = 3.1415926536; Ak budete kresliť obrázok obidvoma spôsobmi do tej iste plochy, môžete si overiť, či dostanete to isté. | ||
+ | |||
+ | [[Image:PROG-P2-spirala.png|frame|150px|Špirála pre n=10]] | ||
+ | * Napíšte program, ktorý vykreslí špirálu korytnačou grafikou ako na obrázku vpravo. Špirála pozostáva z n úsečiek, pričom prvá má dĺžku d a každá ďalšia je o d dlhšia od predchádzajúcej. Čísla n a d sú uložené v premenných. Veľkosť obrázku uložte do ďalšej premennej size. Korytnačka nech začína v strede plochy. | ||
+ | =DÚ1= | ||
+ | {{MDU||3989}} max. 10 bodov, termín odovzdania pondelok 1.10. o 22:00 | ||
+ | |||
+ | Ak narazíte pri riešení úlohy na problémy, s ktorými si neviete poradiť, neváhajte sa poradiť s vyučujúcimi. Neopisujte od spolužiakov ani z iných zdrojov. | ||
+ | |||
+ | Cieľom tejto domácej úlohy je precvičiť si prácu s grafickou knižnicou, textovým vstupom a výstupom, jednoduchými premennými a aritmetickými výrazmi, ako aj použitie podmienok. | ||
+ | |||
+ | Napíšte program, ktorý na základe vstupu od užívateľa vykreslí pomocou knižnice simpleDraw obrazec ako na obrázkoch nižšie. Tento obrazec pozostáva z dvoch farebných štvorcov rovnakej veľkosti, pričom žltý štvorec je umiestnený vyššie a viac vľavo a modrý štvorec nižšie a viac vpravo. Prienik týchto štvorcov tvorí tiež štvorec, ktorý má byť na obrázku vyfarbený zelenou farbou (kreslíte teda tri štvorce s farbami yellow, blue a green). Štvorce sú umiestnené v obrázku štvorcovej veľkosti tak, aby na všetkých stranách bola rovnaká medzera medzi okrajom obrázku a najkrajnejšou stranou štvorca (táto medzera sa v skutočnosti môže mierne líšiť kvôli zaokrúhľovaniu). | ||
+ | |||
+ | Váš program si najskôr od užívateľa vypýta tri hodnoty, ktoré uloží do premenných: | ||
+ | * Celková veľkosť obrázku '''o''' | ||
+ | * Veľkosť dvoch väčších štvorcov '''s''' | ||
+ | * Veľkosť prieniku štvorcov '''p''' | ||
+ | Potom váš program spraví kontrolu správnosti vstupov. Predpokladajte, že užívateľ skutočne zadal celé čísla, to nemusíte kontrolovať. Spravte však nasledujúce kontroly: | ||
+ | * Každé zo vstupných čísel by malo byť v rozsahu od 10 po 1000 vrátane. Ak to tak nie je, program by mal vypísať chybovú hlášku <tt>"Zla hodnota"</tt> | ||
+ | * Prienik štvorcov nemôže byť väčší ako samotné štvorce. Ak táto chyba nastane, program by mal vypísať chybovú hlášku <tt>"Prilis velky prienik"</tt> | ||
+ | * Veľkost obrázku musí byť dostatočná na to, aby sa do neho zmestili oba štvorce príslušnej veľkosti so zadaným prienikom. Ak tomu tak nie je, program by mal vypísať chybovú hlášku <tt>"Prilis maly obrazok"</tt> | ||
+ | Ak váš program vypíše niektorú z týchto chybových hlásení, nemal by už nič ďalšie vypisovať ani vykresľovať. Ak program nenájde v zadaných číslach žiadnu chybu, vytvorí grafické okno s požadovaným obrázkom, zapíše obrázok do súboru <tt>stvorce.png</tt> a čaká kým užívateľ stlačí Exit. | ||
+ | |||
+ | Váš program by mal byť skompilovateľný a spustiteľný v prostredí používanom na cvičeniach. V prostredí moodle odovzdajte súbor <tt>main.cpp</tt> obsahujúci váš program. | ||
+ | |||
+ | '''Poznámka:''' To či máte štvorce správne umiestnené v rámci obrázku doporučujeme skontrolovať vo vytvorenom png súbore, lebo veľkosť grafického okna môže byť iná ako veľkosť obrázku. | ||
+ | |||
+ | |||
+ | '''Príklady:''' | ||
+ | {| | ||
+ | |- | ||
+ | | Príklad pre o=300,s=200,p=150 || Príklad pre o=300,s=100,p=20 | ||
+ | |- | ||
+ | | [[Image:PROG-DU1-squares1.png|frameless|border|300px]] || [[Image:PROG-DU1-squares2.png|frameless|border|300px]] | ||
+ | |- | ||
+ | |} | ||
+ | =Pokročilá DÚ1= | ||
+ | {{MDU||3990}} max. 20 bodov + 4 body bonus, termín odovzdania pondelok 8.10. o 22:00 | ||
+ | |||
+ | Odovzdávať pokročilé domáce úlohy môžete iba po predchádzajúcom schválení vyučujúcimi, alebo ak ste napísali test pre pokročilých aspoň na 50%. Nie je možné striedať pokročilé a bežné domáce úlohy, s výnimkou DÚ0. Ak narazíte pri riešení úlohy na problémy, s ktorými si neviete poradiť, neváhajte sa poradiť s vyučujúcimi. Neopisujte od spolužiakov ani z iných zdrojov. Dbajte na prehľadný štýl programu (vhodné pomenovanie premenných, komentáre, formátovanie...). | ||
+ | |||
+ | Cieľom tejto domácej úlohy je precvičiť si prácu s cyklami, poliami a súbormi. Vašou úlohou je implementovať mierne zjednodušenú verzou algoritmu '''k-means clustering''', ktorý je popísaný nižšie. Viac o tomto algoritme sa dozviete napríklad na [http://en.wikipedia.org/wiki/K-means_clustering#Standard_algorithm Wikipédii]. Algoritmus k-means clustering sa používa pri analýze dát. Jeho cieľom je zadeliť vstupné dáta do ''k'' skupín, nazývaných zhluky (clusters) tak, aby dáta v rámci jedného zhluku boli na seba podobné a dáta z rôznych zhlukov aby sa podobali menej. | ||
+ | |||
+ | == Algoritmus k-means clustering== | ||
+ | |||
+ | Vstupné dáta sú body vo viacrozmernom priestore, teda každý bod je vektor reálnych čísel rozmeru DIM. Každý zhluk je reprezentovaný svojim stredom, ktorý je tiež bod z priestoru rozmeru DIM. Na počítanie vzdialenosti medzi bodmi budeme používať bežnú Euklidovskú vzdialenosť dvoch bodov v priestore (vzorec na jej výpočet nájdete [http://mathworld.wolfram.com/Distance.html napríklad tu]). Pre každý bod môžeme teda spočítať jeho vzdialenosť od stredu zhluku, do ktorého bol priradený. K-means clustering sa snaží nájsť také zhlukovanie, aby súčet druhých mocnín týchto vzdialeností pre všetky vstupné body bol čo najmenší (nie vždy však nájde najlepšie možné také zhlukovanie). | ||
+ | |||
+ | Postupujte nasledovne: Na začiatku zvoľte ako stredy zhlukov prvých K vstupných bodov. Potom opakujte nasledujúce dva kroky: | ||
+ | * Pre každý vstupný bod spočítame jeho vzdialenosť od stredov všetkých zhlukov a priradíme do toho zhluku, ku ktorého stredu je najbližšie. | ||
+ | * Pre každý zhluk vypočítame nový stred na základe bodov do neho patriacich. Každú súradnicu nového stredu vyrátame ako aritmetický priemer danej súradnice cez všetky body patriace do tohto zhluku.<br/> | ||
+ | V praxi sa tieto kroky opakujú, kým dochádza k nejakému zlepšeniu, my si však situáciu uľahčíme a budeme ich opakovať pevný počet krát. | ||
+ | |||
+ | ==Vstup a výstup== | ||
+ | |||
+ | Poskytujeme Vám dva vstupné súbory. V prvom je malý hračkársky prípad s dvojrozmernými bodmi, ktorý môžete použiť na ladenie programu. Druhý, väčší vstup, obsahuje údaje o zložení rôznych jedál. Každý vstupný bod reprezentuje jeden typ jedla ako 18-rozmerný vektor s nasledujúcimi položkami: zrno, celé zrno, zelenina, oranžová zelenina, tmavozelená zelenina, škrobová zelenina, iná zelenina, ovocie, mlieko, mäso, sója, fazuľa a hrach, olej, tuhý tuk, pridaný cukor, alkohol, kalórie, nasýtené tuky. Dáta boli získané zo stránky https://explore.data.gov/Health-and-Nutrition/MyPyramid-Food-Raw-Data/b978-7txq | ||
+ | |||
+ | V oboch súboroch sú údaje pre každý vstupný bod na jednom riadku, pričom prvý stĺpec obsahuje textový identifikátor bodu (reťazec bez medzier a iných bielych znakov) a ďalšie stĺpce obsahujú desatinné čísla tvoriace príslušný vektor. Stĺpce sú oddelené medzerami. | ||
+ | |||
+ | Vo výstupnom súbore by mali byť tie isté dáta ako vo vstupnom súbore aj v tom istom poradí, ale na začiatok každého riadku pridajte nový stĺpec obsahujúci číslo zhluku, do ktorého daný vstupný bod patrí. Zhluky čísľujte 0,1,...,K-1. Navyše ako prvých K riadkov súboru vypíšte stredy nájdených zhlukov v tom istom formáte, t.j. najprv číslo zhluku, potom názov riadku vo formáte <tt>cluster_1</tt> kde 1 je nahradená príslušným číslom zhluku a potom hodnoty jednotlivých súradníc. Všetky súradnice vo výstupnom súbore vypisujte na 5 desatinných miest. | ||
+ | |||
+ | Potrebné súbory: | ||
+ | * [http://compbio.fmph.uniba.sk/vyuka/prog/data/pdu1-kmeans/small.txt Malý vstup] | ||
+ | * [http://compbio.fmph.uniba.sk/vyuka/prog/data/pdu1-kmeans/small_out.txt Príklad výstupu pre malý vstup a K=3] | ||
+ | * [http://compbio.fmph.uniba.sk/vyuka/prog/data/pdu1-kmeans/food.txt Zloženie jedál] | ||
+ | |||
+ | ==Implementačné detaily== | ||
+ | |||
+ | Na začiatku programu si zadefinujte nasledujúce konštanty a používajte ich v programe: | ||
+ | |||
+ | <pre> | ||
+ | const char * INPUT = "food.txt"; /* meno vstupného súboru */ | ||
+ | const char * OUTPUT = "clusters.txt"; /* meno výstupného súboru */ | ||
+ | const int ROWS = 579; /* počet vstupných bodov, resp. počet riadkov vo vstupnom súbore */ | ||
+ | const int DIM = 18; /* rozmer vstupných bodov */ | ||
+ | const int MAX_NAME_LENGTH = 50; /* najväčšia možná dĺžka mena riadku vo vstupnom súbore */ | ||
+ | const int K = 4; /* počet hľadaných zhlukov */ | ||
+ | const int STEPS = 20; /* počet krokov algoritmu */ | ||
+ | </pre> | ||
+ | |||
+ | Pri testovaní meňte tieto konštanty podľa potreby (ROWS a DIM prispôsobte vstupnému súboru), ale v odovzdanom súbore nastavte konštanty na hodnoty uvedené vyššie. | ||
+ | |||
+ | Vstupné dáta načítavajte zo súboru s menom v konštante INPUT a vypisujte do súboru s menom v konštante OUTPUT, pričom dodržujte formát súboru uvedený vyššie. Nemusíte kontrolovať správnosť vstupných dát. | ||
+ | |||
+ | Pri písaní programu budete potrebovať niektoré črty jazyka C, ktoré ešte neboli preberané na prednáškach. Prečítajte si o nich v príručkách jazyka C resp. C++ alebo na prednáškach z minulého roku: | ||
+ | |||
+ | * Práca so súbormi (použite C-čkovú knižnicu [http://www.cplusplus.com/reference/clibrary/cstdio/ stdio] alebo C++ knižnicu [http://www.cplusplus.com/reference/iostream/ fstream]) | ||
+ | ** Prednášky [http://compbio.fmph.uniba.sk/vyuka/prog/index.php/2011/12_Programovanie_%281%29_v_C/C%2B%2B#Predn.C3.A1.C5.A1ka_9], [http://compbio.fmph.uniba.sk/vyuka/prog/index.php/2011/12_Programovanie_%281%29_v_C/C%2B%2B#Predn.C3.A1.C5.A1ka_10] | ||
+ | |||
+ | * Dvojrozmerné polia na uchovávanie vstupných vektorov a stredov zhlukov. Na prednáške minulý rok sme viacrozmerné polia robili pomocou smerníkov, oveľa jednoduchšie je však zadefinovať dvojrozmerné pole s pevnými veľkosťami, napr. <tt>double data[ROWS][DIM];</tt> K prvkom tohto poľa potom pristupujeme napr. <tt>data[riadok][stlpec]</tt> | ||
+ | ** Prednáška o dvojrozmerných poliach cez smerníky: [http://compbio.fmph.uniba.sk/vyuka/prog/index.php/2011/12_Programovanie_%281%29_v_C/C%2B%2B#Predn.C3.A1.C5.A1ka_12] | ||
+ | |||
+ | * Reťazce na uchovávanie mien riadkov (použite buď C++ typ [http://www.cplusplus.com/reference/string/ string], alebo pole znakov pevnej veľkosti; všetky mená riadkov môžete dať napr. do poľa typu <tt>char mena[ROWS][MAX_NAME_LENGTH+1]</tt>) | ||
+ | ** Prednáška o reťazcoch: [http://compbio.fmph.uniba.sk/vyuka/prog/index.php/2011/12_Programovanie_%281%29_v_C/C%2B%2B#Predn.C3.A1.C5.A1ka_8] | ||
+ | |||
+ | == Bonus == | ||
+ | Dôležitým aspektom spracovania dát je aj vizualizácia výsledkov. V tejto časti je vašou úlohou zobraziť výsledky vášho zhlukovania dát v súbore <tt>food.txt</tt>. Vyberte si dva zaujímavé stĺpce z tohto súboru a použite jeden z nich ako x-ovú a jeden ako y-ovú súradnicu. Každý bod zo súboru potom nakreslite na jeho pozíciu (x,y), pričom farbu značky zvoľte podľa čísla zhluku (použijete teda 4 farby, každú pre jeden zhluk). K bodu malým písmom pripíšte jeho meno (nevadí ak sa tieto popisky budú na niektorých miestach prekrývať). Skúste trochu experimetnovať s tým, ktoré dva stĺpce vybrať aby obrázok vyzeral rozumne. | ||
+ | |||
+ | Tento graf vytvorte v systéme gnuplot alebo v systéme R, čo sú dva často používané systémy na vizualizáciu dát. Sú to pomerne zložité systémy s textovým ovládaním, na vytvorenie grafu si teda o nich budete musieť niečo prečítať. Tieto zručnosti sa vám však môžu zísť v budúcnosti, keď budete napríklad vytvárať grafy do vašej bakalárskej práce. Výhodou takýchto textových nástrojov oproti napr. Excelu je možnosť spúšťať vytvorené vizualizačné príkazy automaticky na nových dátach bez ručného klikania. | ||
+ | |||
+ | * [http://www.gnuplot.info/ Oficiálna stránka programu gnuplot] | ||
+ | * [http://kzr.blog.matfyz.sk/p15995-ako-na-fakt-pekne-grafy Návod na použitie od Petra Kováča z blog.matfyz.sk] | ||
+ | * [http://www.r-project.org/ Oficiálna stránka programu R] | ||
+ | * [http://compbio.fmph.uniba.sk/vyuka/ppb/index.php/%C5%A0tatistick%C3%BD_syst%C3%A9m_R Návody k systému R] | ||
+ | |||
+ | == Odovzdávanie == | ||
+ | Domácu úlohu odovzdávajte elektronicky v systéme Moodle do uvedeného termínu. | ||
+ | * V hlavnej časti úlohy odovzdajte súbor <tt>main.cpp</tt>, ktorý by mal obsahovať celý zdrojový kód vášho programu. Váš program by mal byť skompilovateľný a spustiteľný v prostredí používanom na cvičeniach. | ||
+ | * V bonusovej časti odovzdajte výsledný graf vo formáte png a krátky textový súbor popisujúci, ako ste obrázok vytvorili (uveďte použité príkazy v systéme gnuplot prípadne R) | ||
+ | =Prednáška 5= | ||
+ | == Organizačné poznámky == | ||
+ | |||
+ | * Dnes cvičenia podľa rozvrhu | ||
+ | * Odovzdávanie DU1 do 22:00 | ||
+ | * Už by ste mali mať zapísané správne predmety (ak nie bežte na štúdijné) a v prípade zmien do 5.10. potvrdiť finálnu verziu na študijnom oddelení | ||
+ | |||
+ | == Štatistika z N čísel == | ||
+ | |||
+ | Úlohou je zistiť o N prečítaných číslach nejaké štatistické údaje. | ||
+ | |||
+ | === Maximum a minimum === | ||
+ | |||
+ | Zrejme stačí čítať čísla postupne a pamätať si zatiaľ najväčšie a zatiaľ najmenšie číslo. | ||
+ | |||
+ | * Ako ale začať? Ako nastaviť maximum a minumum na začiatok? | ||
+ | ** Jedna možnosť je nastaviť ich tak, aby to boli nezmyselné hodnoty a iste sa zmenili - napriklad maximum veľmi malé a minumum veľké. Kto nám ale zaručí, že používateľ nedá všetky čísla ešte menšie? Riešením je použiť najväčšie resp. najmenšie možné číslo - ale je to škaredé. | ||
+ | ** Druhá možnosť je si pamätať, že ešte nemáme správne nastavené minimum a maximum a pri prvej príležitosti ich nastaviť. | ||
+ | ** A prvá príležitosť je pri prvom čísle. Môžeme to teda urobiť priamo. Minimum iste nebude väčšie ako toto prvé číslo a maximum iste nebude menšie. | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | #include <cstdlib> | ||
+ | |||
+ | using namespace std; | ||
+ | |||
+ | int main(void){ | ||
+ | int max, min, x, N; | ||
+ | |||
+ | cout << "Zadaj pocet cisel: "; | ||
+ | cin >> N; | ||
+ | |||
+ | cout << "Zadavajte cisla: "; | ||
+ | cin >> x; | ||
+ | |||
+ | min=x; max=x; | ||
+ | for (int i=1; i<N; i++){ | ||
+ | cin >> x; | ||
+ | if (x<min) {min=x;} | ||
+ | if (x>max) {max=x;} | ||
+ | } | ||
+ | |||
+ | cout << endl << "Maximum je " << max << " a minumum je " << min << endl; | ||
+ | }</pre> | ||
+ | |||
+ | === Výskyty čísel 0..9 === | ||
+ | |||
+ | Ak vieme, že na vstupe sú iba čísla od 0 do 9, tak by sme chceli vedieť, koľko jednotlivých čísel je. Mohli by sme to riesiť takto: | ||
+ | |||
+ | * Pre každú možnú hodnotu si vytvoríme jednu premennú (dokopy ich bude teda 10 - napríklad p0, p1 .. p9) na začiatku nastavenú na 0. | ||
+ | * V prípade, že prečítané číslo bolo 0 zväčšíme hodnotu p0, ak bolo 1 zväčšíme p1 ... | ||
+ | |||
+ | Je to však pomerne komplikovaný spôsob - a to máme iba 10 rôznych premenných. Problém je v tom, že štvrtá premenná je p4 vieme iba my ako programátori a počítač o tom nevie - nemá žiaden súvis medzi jednotlivými premennými. | ||
+ | |||
+ | Teraz ukážeme riešenie tohoto príkladu pomocou poľa. | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | int p[10]; | ||
+ | int c,N; | ||
+ | |||
+ | for (int i=0; i<10; i++) p[i]=0; // inicializácia pola p[0]=0; p[1]=0; ... p[9]=0; | ||
+ | |||
+ | cout << "Zadajte pocet cisel: "; | ||
+ | cin >> N; | ||
+ | cout << "Zadavajte " << N << "cisel z intervalu 0-9: "; | ||
+ | for (int i=0; i<N; i++){ | ||
+ | cin >> c; | ||
+ | if (c>=0 && c<10) p[c]++; // test, či je číslo z požadovaného rozsahu | ||
+ | } | ||
+ | |||
+ | cout << endl; | ||
+ | for (int i=0; i<10; i++) cout << i << ": " << p [i] << endl; // výpis | ||
+ | }</pre> | ||
+ | |||
+ | === Priemer === | ||
+ | |||
+ | Podobne ako pri maxime a minime si aj priemer vieme počítať postupne. | ||
+ | |||
+ | * Budeme si počítať súčet doterajších čísel a na záver ho vydelíme ich počtom. | ||
+ | * Dá sa robiť aj postupne - aby sme nemali zapamätané príliš veľké číslo (súčet)? | ||
+ | |||
+ | Ak by sme chceli o každom čísle vedieť, či je nadpriemerné alebo podpriemerné zjavne by sme si museli čísla zapamätať. | ||
+ | |||
+ | * Keby sme vedeli dopredu, koľko ich bude vedeli by sme to urobiť podobne ako v predchádzajúcom príklade. | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | |||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | int N=20; | ||
+ | int p[20]; | ||
+ | double sucet=0; | ||
+ | double priemer; | ||
+ | |||
+ | cout << "Zadavajte " << N << " cisel: "; | ||
+ | for (int i=0; i<N; i++){ | ||
+ | cin >> p[i]; | ||
+ | sucet=sucet+p[i]; | ||
+ | } | ||
+ | |||
+ | priemer=sucet/N; | ||
+ | cout << "Priemer je " << priemer << "." << endl; | ||
+ | for (int i=0; i<N; i++) | ||
+ | if (p[i]>priemer) cout << p[i] << ": vacsie ako priemer." << endl; | ||
+ | else if (p[i]<priemer) cout << p[i] << ": mensie ako priemer." << endl; | ||
+ | else cout << p[i] << ": priemer." << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Ak by sme nevedeli počet čísel, môžeme aspoň odhadnúť, že ich nebude viac ako NMax, ktoré definujeme ako konštantu v programe. | ||
+ | * A prečo vlastne nemôžeme dať ako veľkosť poľa N, ktoré si prečítame od používateľa? | ||
+ | |||
+ | == Polia == | ||
+ | |||
+ | * Rozsah poľa je konštantný výraz väčší ako 0. Prvky sa indexujú od 0 po počet - 1 | ||
+ | * Občas sa dá ako rozsah použiť aj dopredu zadefinovaná premenná, ale napr. nasledovný program v C++ skompilujete ale v C nie. Takže opatrne! | ||
+ | |||
+ | <pre> | ||
+ | int i=100; | ||
+ | int p [i]; // i je premenná, ktorá vznikne až počas behu programu, a teda jej hodnota nie je počas kompilácie známa. | ||
+ | </pre> | ||
+ | |||
+ | * Radšej použijeme konštantu <tt>const int N=100</tt> | ||
+ | * Veľkosť poľa môže byť ohraničená v závislosti od kompilátora. | ||
+ | |||
+ | === Vytvorenie a inicializácia poľa === | ||
+ | |||
+ | V C++ je niekoľko pravidiel, ktoré určujú kedy ich môže používať a čo sa stane, ak počet prvok neodpovedá počtu hodnôt v inicializácii. Pole je možné inicializovať iba v definícii. | ||
+ | |||
+ | <pre> | ||
+ | int A[4]={3, 6, 8, 10}; //spravne | ||
+ | int B[4]; //spravne | ||
+ | B[4]={3, 6, 8, 10}; //nespravne | ||
+ | B[0]=3; B[1]=6; B[2]=8; B[3]=10; | ||
+ | </pre> | ||
+ | |||
+ | Pri inicializácii sa dá dodať aj menej hodnôt ako má pole. Napr. inicializácia iba dvoch prvých hodnôt. Pri čiastočnej inicializácii nastaví prekladač ostatné prvky na nulu. | ||
+ | |||
+ | <pre> | ||
+ | double C[5]={5.0, 13.9}; // inicializuje C[0]=5.0, C[1]=13.9 a C[2]..C[4]=0 | ||
+ | double C[5]={0}; // jednoduchá inicializácia všetkých prvkov na 0 | ||
+ | </pre> | ||
+ | |||
+ | Ak pri inicializácii poľa necháme hranaté zátvorky prázdne prekladač si sám spočíta prvky poľa. Nie je to však odporúčaný postup. | ||
+ | |||
+ | <pre> | ||
+ | int A[]={1, 5, 3, 8}; // zistí rozsah poľa 0..3 | ||
+ | </pre> | ||
+ | |||
+ | === Indexovanie hodnotou mimo intervalu === | ||
+ | |||
+ | <pre> | ||
+ | int a [10], b [10]; | ||
+ | int i; | ||
+ | for (i=0; i<10; i++) a [i]=random (100); // náhodné hodnoty | ||
+ | </pre> | ||
+ | |||
+ | Pozor, kompilátor nekontroluje indexy prvkov | ||
+ | |||
+ | a [11]=1234; | ||
+ | |||
+ | * Skompilujete, ale hodnota 1234 sa zapíše do pamäte na zlé miesto, | ||
+ | * Môže to mať nepredvídateľné následky: prepísanie obsahu iných premenných (chybný výpočet alebo „nevysvetliteľné“ správanie sa programu) alebo prepísane časti kódu vášho programu (čo vo väčšine prípadov spôsobí „zamrznutie“ alebo reset počítača), | ||
+ | |||
+ | === Kopírovanie a testovanie rovnosti === | ||
+ | |||
+ | V prípade, že chceme vytvoriť pole, ktoré je kópiou už existujúceho poľa, ponúka sa možnosť príkazu priradenia <tt>b=a;</tt>. | ||
+ | Takýto príkaz však neskompilujete – nedá sa takto priraďovať, treba kopírovať prvok po prvku. | ||
+ | |||
+ | <pre> | ||
+ | for (i=0; i<10; i++) b[i]=a[i]; | ||
+ | </pre> | ||
+ | |||
+ | Podobne sa nedá porovnávať polia pomocou podmienky <tt>if (a==b) cout << "Ok";</tt>. | ||
+ | Takúto podmienku síce skompilujete, ale nikdy to nebude pravda – neporovná sa obsah poľa, ale niečo úplne iné (adresy polí v pamäti). | ||
+ | Treba to riešiť opäť prvok po prvku. | ||
+ | |||
+ | <pre> | ||
+ | bool r=true; | ||
+ | for (i=0; i<10; i++) { r=r && (a [i]==b [i]); } | ||
+ | if (r) cout << "Ok\n"; | ||
+ | </pre> | ||
+ | |||
+ | == Príklady na prácu s poľom == | ||
+ | |||
+ | * Načítajte pole čísel a vypíšte ho v opačnom poradí. | ||
+ | * Skúste poradie povymienať priamo v poli a nie iba pri výpise. | ||
+ | |||
+ | * Načítajte pole čísel a vypíšte ho v náhodnom poradí. | ||
+ | * Ako by ste pole náhodne povymieňali priamo v pamäti? | ||
+ | |||
+ | == Kreslíme padajúce kruhy == | ||
+ | |||
+ | * Vytvoríme si polia pre x-ovú a y-ovú súradnicu kruhu. | ||
+ | * Potrebujeme aj pole, do ktorého si budeme dávať celočíselné identifikátory nakreslených kruhov, aby sme ich neskôr mohli zmazať. | ||
+ | |||
+ | <pre> | ||
+ | #include "../SimpleDraw.h" | ||
+ | #include <cstdlib> | ||
+ | #include <ctime> | ||
+ | |||
+ | int main(void) { | ||
+ | const int count = 30; /* počet kruhov */ | ||
+ | int size = 300; /* veľkosť obrázku */ | ||
+ | int diameter = 15; /* polomer kruhu */ | ||
+ | int step = 4; /* o kolko padne dolu v jednom kroku */ | ||
+ | int repeat = 50; /* pocet iteracii */ | ||
+ | double wait = 0.1; /* cakaj po kazdej iteracii */ | ||
+ | |||
+ | /* inicializácia generátora pseudonáhodných čísel */ | ||
+ | srand(time(NULL)); | ||
+ | |||
+ | SimpleDraw window(size, size); | ||
+ | window.setBrushColor("lightblue"); | ||
+ | |||
+ | int x[count]; /* x-ova poloha kruzku */ | ||
+ | int y[count]; /* y-ove poloha kruzku */ | ||
+ | int id[count]; /* id objektu na obrazovke */ | ||
+ | |||
+ | /* kazdemu kruzku vygeneruj nahodnu polohu */ | ||
+ | for (int i = 0; i < count; i++) { | ||
+ | x[i] = rand() % (size - diameter); | ||
+ | y[i] = rand() % (size - diameter); | ||
+ | } | ||
+ | |||
+ | /* opakuj repeat iteracii */ | ||
+ | for (int r = 0; r < repeat; r++) { | ||
+ | /* chod cez vsetky kruhy */ | ||
+ | for (int i = 0; i < count; i++) { | ||
+ | /* ak nie sme v prvej iteracii, treba zmazat kruh */ | ||
+ | if (r > 0) { | ||
+ | window.removeItem(id[i]); | ||
+ | } | ||
+ | /* zvys y-ovu suradnicu o step */ | ||
+ | y[i] += step; | ||
+ | /* ak sme prilis nizko, zacni na vrchu na nahodnom x */ | ||
+ | if (y[i] >= size - diameter) { | ||
+ | y[i] = 0; | ||
+ | x[i] = rand() % (size - diameter); | ||
+ | } | ||
+ | /* vykresli kruzok na novom mieste */ | ||
+ | id[i] = window.drawEllipse(x[i], y[i], diameter, diameter); | ||
+ | } | ||
+ | /* na konci iteracie chvilu pockaj */ | ||
+ | window.wait(wait); | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Takéto polia nie sú ideálne, lebo údaje o jednom kruhu sú v troch rôznych poliach a bolo by logickejšie ich mať pokope. | ||
+ | * Situácia by bola ešte horšia, ak by každý kruh mal napr. aj náhodnú farbu s troma zložkami R,G,B. To by sme potrebovali päť polí. | ||
+ | * Na spojenie údajov k jednému kruhu použijeme dátovú štruktúru struct | ||
+ | |||
+ | === Padajúce kruhy so struct === | ||
+ | <pre> | ||
+ | #include "../SimpleDraw.h" | ||
+ | #include <cstdlib> | ||
+ | #include <ctime> | ||
+ | |||
+ | struct kruh { | ||
+ | int x, y; /* suradnice */ | ||
+ | int id; /* id na mazanie */ | ||
+ | int r, g, b; /* zlozky farby: red, green, blue */ | ||
+ | }; | ||
+ | |||
+ | void generujKruh(kruh &k, int max) { | ||
+ | k.x = rand() % max; | ||
+ | k.y = rand() % max; | ||
+ | k.r = rand() % 256; | ||
+ | k.g = rand() % 256; | ||
+ | k.b = rand() % 256; | ||
+ | k.id = -1; | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | const int count = 30; /* počet kruhov */ | ||
+ | int size = 300; /* veľkosť obrázku */ | ||
+ | int diameter = 15; /* polomer kruhu */ | ||
+ | int step = 4; /* o kolko padne dolu v jednom kroku */ | ||
+ | int repeat = 50; /* pocet iteracii */ | ||
+ | double wait = 0.1; /* cakaj po kazdej iteracii */ | ||
+ | |||
+ | int max = size - diameter; /* maximalna mozna suradnica */ | ||
+ | |||
+ | /* inicializácia generátora pseudonáhodných čísel */ | ||
+ | srand(time(NULL)); | ||
+ | |||
+ | SimpleDraw window(size, size); | ||
+ | window.setBrushColor("lightblue"); | ||
+ | |||
+ | /* pole kruhov */ | ||
+ | kruh kruhy[count]; | ||
+ | |||
+ | /* kazdemu kruzku vygeneruj nahodnu polohu */ | ||
+ | for (int i = 0; i < count; i++) { | ||
+ | generujKruh(kruhy[i], max); | ||
+ | } | ||
+ | |||
+ | /* opakuj repeat iteracii */ | ||
+ | for (int r = 0; r < repeat; r++) { | ||
+ | /* chod cez vsetky kruhy */ | ||
+ | for (int i = 0; i < count; i++) { | ||
+ | /* ak nie sme v prvej iteracii, treba zmazat kruh */ | ||
+ | if (r > 0) { | ||
+ | window.removeItem(kruhy[i].id); | ||
+ | } | ||
+ | /* zvys y-ovu suradnicu o step */ | ||
+ | kruhy[i].y += step; | ||
+ | /* ak sme prilis nizko, zacni na vrchu na nahodnom x */ | ||
+ | if (kruhy[i].y >= max) { | ||
+ | generujKruh(kruhy[i], max); | ||
+ | kruhy[i].y = 0; | ||
+ | } | ||
+ | /* vykresli kruzok na novom mieste */ | ||
+ | window.setBrushColor(kruhy[i].r, kruhy[i].g, kruhy[i].b); | ||
+ | kruhy[i].id = window.drawEllipse(kruhy[i].x, kruhy[i].y, | ||
+ | diameter, diameter); | ||
+ | } | ||
+ | /* na konci iteracie chvilu pockaj */ | ||
+ | window.wait(wait); | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | == Eratostenovo sito == | ||
+ | |||
+ | Chceme vypísať všetky prvočísla medzi 2 a N. Mohli by sme ísť cez všetky čísla a pre každé testovať, koľko má deliteľov (deliteľov sme už hľadali predtým), ale vieme to spraviť aj rýchlejšie. Použijeme algoritmus zvaný Eratostenovo sito. | ||
+ | |||
+ | * Vytvoríme pole ''A'' pravdivostných hodnôt, kde ''A[i]'' nám hovorí, či je ''i'' ešte potenciálne prvočíslo. | ||
+ | * Na začiatku budú všetky hodnoty true, lebo sme ešte žiadne číslo nevylúčili. | ||
+ | * Začneme číslom 2 - toto je iste prvočíslo (tak ho vypíšeme). O jeho násobkoch však vieme, že iste nemôžu byť prvočísla - nastavíme preto pre každý násobok j=2*k pravdivostnú hodnotu A[j] na false. | ||
+ | * Potom prechádzame v poli, kým nenájdeme najbližšiu ďalšiu hodnotu true. Toto číslo je prvočíslo (vypíšeme ho) a vyškrtáme jeho násobky. | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | const int N = 25; | ||
+ | bool A[N + 1]; | ||
+ | |||
+ | for (int i = 2; i <= N; i++) { | ||
+ | A[i] = true; | ||
+ | } | ||
+ | for (int i = 2; i <= N; i++) { | ||
+ | if (A[i]) { | ||
+ | cout << i << " "; | ||
+ | for (int j = 2 * i; j <= N; j = j + i) { | ||
+ | A[j] = false; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | cout << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Výstup programu | ||
+ | <pre> | ||
+ | 2 3 5 7 11 13 17 19 23 | ||
+ | </pre> | ||
+ | |||
+ | Priebeh programu: | ||
+ | <pre> | ||
+ | 0 1 2 3 4 5 6 7 8 9 10 11 12 ... | ||
+ | ? ? T T T T T T T T T T T ... na zaciatku | ||
+ | ? ? T T F T F T F T F T F ... po vyskrtani i=2 | ||
+ | ? ? T T F T F T F F F T F ... po vyskrtani i=3 | ||
+ | ? ? T T F T F T F F F T F ... dalej sa uz skrtaju len vacsie cisla | ||
+ | </pre> | ||
+ | |||
+ | '''Cvičenie:''' Napíšte funkciu, ktorá uloží prvočísla medzi 2 a N do poľa (ak by sme ich chceli použiť na ďalšie výpočty). | ||
+ | |||
+ | == Zhrnutie == | ||
+ | |||
+ | * V prípade využívania viacerých premenných, ktoré sú vlastne jednotlivé prvky nejakej postupnosti (načítávané čísla, ..) môžeme využívať polia | ||
+ | * Jednotlivé spolu súvisiace informácie (vlastnosti) o nejakom prvku spojíme do štruktúry pomocou struct | ||
+ | =Prednáška 6= | ||
+ | ==Organizačné poznámky== | ||
+ | * V moodli si vždy skontrolujte, či ste súbor správne odovzdali, priebežne si pozerajte známky a komentáre, upozornite nás na prípadné problémy | ||
+ | * DÚ2 a PDÚ1 do pondelka, DÚ3 zverejnená koncom týždňa, PDÚ2 začiatkom budúceho týždňa. | ||
+ | * Poriadne čítať a dodržiavať zadania úloh, spýtajte sa, ak niečo nie je jasné, alebo ak máte problémy úlohu riešiť | ||
+ | |||
+ | |||
+ | * Prebrali sme premenné, polia, podmienky, cykly a funkcie. | ||
+ | ** Z týchto stavebných prvkov sa dajú vystavať pomerne komplikované programy. Menej skúsení programátori si potrebujú prácu s týmito pojmami čo najviac precvičiť. Skúste si vyriešiť všetky príklady z cvičení. Kontaktujte nás, ak Vám niečo nie je jasné. | ||
+ | ** Predbežný plán: tento a budúci týždeň algoritmy s poliami, znaky a reťazce. O dva týždňe rekurzia (veľa študentom robila problém na skúške). | ||
+ | |||
+ | ==Parametre funkcií - prehľad, opakovanie== | ||
+ | * Jednoduché typy, napr. int, double, bool | ||
+ | ** Bez & sa skopíruje hodnota | ||
+ | ** S & premenná dostane vo funkcii nové meno | ||
+ | <pre> | ||
+ | void f1(int x) { | ||
+ | x++; // zmena x sa nepresenie do main (y zostane rovnaká) | ||
+ | cout << x << endl; | ||
+ | } | ||
+ | |||
+ | void f2(int &x) { | ||
+ | x++; // zmena x sa prenesie ako zmena y v main | ||
+ | cout << x << endl; | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | int y = 0; | ||
+ | f1(y); | ||
+ | f2(y); | ||
+ | f1(y + 1); | ||
+ | //zle: f2(y+1); | ||
+ | } | ||
+ | </pre> | ||
+ | * Polia odovzdávame bez & | ||
+ | ** väčšinou potrebujeme poslať aj veľkosť poľa, ak nie je globálne známa | ||
+ | ** zmeny v poli zostanú aj po skončení funkcie | ||
+ | <pre> | ||
+ | void f(int a[], int n) { | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | cout << a[i] << endl; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | int b[3] = {1, 2, 3}; | ||
+ | f(b, 3); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Korytnačky, grafické okná a pod. sú v skutočnosti objekty, väčšinou ich chcete posielať s & | ||
+ | ** všetky zmeny na nich spravené pretrvávajú aj po skončení funkcie | ||
+ | <pre> | ||
+ | void kresli(Turtle &t, int n) { | ||
+ | for(int i=0; i<n; i++) { | ||
+ | t.turnLeft(rand() % 360); | ||
+ | t.forward(10); | ||
+ | } | ||
+ | } | ||
+ | int main(void) { | ||
+ | int n=10; | ||
+ | SimpleDraw window(500,500); | ||
+ | Turtle turtle(window, 250, 450, 0); | ||
+ | kresli(turtle, n); | ||
+ | window.showAndClose(); | ||
+ | } | ||
+ | </pre> | ||
+ | * Štruktúry (struct) väčšinou tiež posielame pomocou & | ||
+ | * Návratové hodnoty: | ||
+ | ** ak je výsledkom funkcie jedno číslo alebo pravdivostná hodnota, vrátime ju príkazom return | ||
+ | ** ak je výsledkom viac hodnôt, alebo niečo zložitejšie (pole, struct,...), odovzdáme ho ako parameter pomocou &, návratová hodnota môže zostať void | ||
+ | * Tieto pravidlá súvisia so smerníkmi a správou pamäti, povieme si viac o pár týždňov | ||
+ | |||
+ | ==Polynómy== | ||
+ | |||
+ | * Príklad polynómu: <math>2x^3 + 3x -1</math>. | ||
+ | * Polynóm si môžeme uložiť do poľa, pričom koeficient pri <math>x^i</math> dáme do a[i] | ||
+ | * Pre náš príklad vytvoríme pole napríklad príkazom <tt>double a[4] = {-1, 3, 0, 2};</tt> | ||
+ | * Teraz si ukážeme niekoľko funkcií, ktoré s polynómami pracujú. | ||
+ | |||
+ | ===Vyhodnocovanie polynómu=== | ||
+ | |||
+ | * Chceme spočítať hodnotu polynómu pre nejaké konkrétne ''x'' | ||
+ | * Príklad: pre <math>2x^3 + 3x -1</math> a pre x=2 dostaneme <math>21 = (2\cdot 2^3 + 3\cdot 2 -1)</math> | ||
+ | |||
+ | '''Pokus 1:''' | ||
+ | <pre> | ||
+ | double evaluatePolynomial(double a[], int n, double x) { | ||
+ | /* a je pole koeficientov s n hodnotami. | ||
+ | * Funkcia vráti hodnotu tohto polynómu v bode x. | ||
+ | * | ||
+ | * Táto implementácia na výpočet x na i používa funkciu | ||
+ | * pow, čo ale pomalé a potenciálne nie úplne presné. | ||
+ | */ | ||
+ | double value = 0; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | value += a[i] * pow(x, i); | ||
+ | } | ||
+ | return value; | ||
+ | } | ||
+ | </pre> | ||
+ | * Pripomíname: <tt>value += x</tt> je to isté ako <tt>value = value + x</tt> | ||
+ | * Všimnite si, že v komentári na začiatku funkcie popisujeme, čo tá funkcia robí, to je väčšinou dobrý nápad spraviť. | ||
+ | * Aký najvyšší stupeň môže mať polynóm ''a'' (ako funkcia ''n'')? | ||
+ | |||
+ | '''Pokus 2:''' | ||
+ | * Vyhneme sa volaniu pow tým, že budeme nejakú premennú opakovanie násobiť hodnotou x | ||
+ | * V cykle uvádzame ako komentár invariant, podmienku, ktorá na tom mieste vždy platí. Takýto invariant nám pomôže si uvedomiť, že je náš program správny. | ||
+ | * Čo by sa stalo, ak by sme prehodili dva príkazy vo vnútri cyklu? | ||
+ | <pre> | ||
+ | double evaluatePolynomial(double a[], int n, double x) { | ||
+ | /* a je pole koeficientov s n hodnotami. | ||
+ | * Funkcia vráti hodnotu tohto polynómu v bode x. | ||
+ | * | ||
+ | * Táto implementácia počíta x na i v cykle spolu | ||
+ | * s vyhodnocovaním polynómu. | ||
+ | */ | ||
+ | double value = 0; | ||
+ | double xpow = 1; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | /* Invariant: xpow sa rovna x na i */ | ||
+ | value += a[i] * xpow; | ||
+ | xpow *= x; | ||
+ | } | ||
+ | return value; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | '''Pokus 3: Hornerova schéma''' | ||
+ | * O kúsoček lepšia ako pokus 2 - nepotrebuje pomocnú premennú a v každej iterácii cyklu robí iba jedno násobenie, nie dve | ||
+ | * Idea je začať od najvyšších mocnín ''x'': | ||
+ | ** <math>2x^3 + 0x^2 + 3x -1 = ((2\cdot x+0)x+3)x-1</math> | ||
+ | |||
+ | <pre> | ||
+ | double evaluatePolynomial(double a[], int n, double x) { | ||
+ | /* a je pole koeficientov s n hodnotami. | ||
+ | * Funkcia vráti hodnotu tohto polynómu v bode x. | ||
+ | * | ||
+ | * Táto implementácia používa tzv. Hornerovu schému, | ||
+ | * ktorá začína od najvyšších koeficentov a | ||
+ | * a pre každé i robí iba jedno sčítanie a jedno násobenie. | ||
+ | */ | ||
+ | double value = 0; | ||
+ | for (int i = n - 1; i >= 0; i--) { | ||
+ | value = value * x + a[i]; | ||
+ | } | ||
+ | return value; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Cvičenie: aký je invariant po vykonaní príkazu v cykle? | ||
+ | |||
+ | |||
+ | Hlavný program: | ||
+ | <pre> | ||
+ | #include <cstdlib> | ||
+ | #include <cmath> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | double evaluatePolynomial(double a[], int n, double x) { | ||
+ | // jedna z funkcií vyššie | ||
+ | } | ||
+ | |||
+ | void enterPolynomial(double a[], int &n, int maxN) { | ||
+ | /* Od užívateľa načíta koeficienty polynómu do a, | ||
+ | * ich počet uloží do n, maxN je veľkosť poľa, | ||
+ | * ktorú nemožno prekročiť. */ | ||
+ | cout << "Zadaj pocet koeficientov n: "; | ||
+ | cin >> n; | ||
+ | if (n > maxN) { | ||
+ | cout << "Prilis velke n!" << endl; | ||
+ | exit(1); | ||
+ | } | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | cout << "Zadaj koeficient pri x na " << i << ": "; | ||
+ | cin >> a[i]; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | const int maxN = 100; | ||
+ | int n; | ||
+ | double a[maxN]; | ||
+ | |||
+ | enterPolynomial(a, n, maxN); | ||
+ | double x; | ||
+ | cout << "Zadaj x: "; | ||
+ | cin >> x; | ||
+ | cout << "Hodnota pre x=" << x << " je " << evaluatePolynomial(a, n, x) << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | <pre> | ||
+ | Zadaj pocet koeficientov n: 4 | ||
+ | Zadaj koeficient pri x na 0: -1 | ||
+ | Zadaj koeficient pri x na 1: 3 | ||
+ | Zadaj koeficient pri x na 2: 0 | ||
+ | Zadaj koeficient pri x na 3: 2 | ||
+ | Zadaj x: 2 | ||
+ | Hodnota pre x=2 je 21 | ||
+ | </pre> | ||
+ | |||
+ | === Sčítanie polynómov=== | ||
+ | * Pri sčítaní polynómov len sčítame koeficienty pri zodpovedajúcich mocninách ''x'' | ||
+ | * Napr. <math>(2x^3 + 3x -1) + (-4x^2+2x+7) = (2+0)x^3 + (0-4)x^2 +(3+2)x^1 + (-1+7)x^0 = 2x^3-4x^2+5x+6</math> | ||
+ | * Musíme dávať pozor na to, že dĺžky polynómov môžu byť rôzne a hodnoty v poli za ''n'' ďalej sú nedefinované. | ||
+ | <pre> | ||
+ | void addPolynomials(double a[], int na, double b[], int nb, double c[], int &nc) { | ||
+ | /* a je pole koeficientov polynomu s na hodnotami, | ||
+ | * b je pole koeficientov s nb hodnotami | ||
+ | * do c zratame ich sucet, do nc pocet hodnot, ktory bude vacsie z | ||
+ | * na, nb. Predpokladame, ze c je dost velke, aby sa do neho nc | ||
+ | * prvkov zmestilo. */ | ||
+ | if (na > nb) { | ||
+ | nc = na; | ||
+ | } else { | ||
+ | nc = nb; | ||
+ | } | ||
+ | |||
+ | for (int i = 0; i < nc; i++) { | ||
+ | c[i] = 0; | ||
+ | if (i < na) { | ||
+ | c[i] += a[i]; | ||
+ | } | ||
+ | if (i < nb) { | ||
+ | c[i] += b[i]; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Hlavný program: (teraz vidíme, načo nám je funkcia enterPolynomial, bez nej by sme cyklus na načítavanie museli písať dvakrát) | ||
+ | <pre> | ||
+ | #include <cstdlib> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | void enterPolynomial(double a[], int &n, int maxN) { | ||
+ | // pozri vyššie | ||
+ | } | ||
+ | |||
+ | void writePolynomial(double a[], int n) { | ||
+ | /* a je pole koeficientov polynómu s n hodnotami */ | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | cout << "Koeficient polynomu pri x na " << i << " je " << a[i] << endl; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | const int maxN = 100; | ||
+ | int na, nb; | ||
+ | double a[maxN], b[maxN]; | ||
+ | |||
+ | cout << "Prvy polynom:" << endl; | ||
+ | enterPolynomial(a, na, maxN); | ||
+ | cout << endl << "Druhy polynom:" << endl; | ||
+ | enterPolynomial(b, nb, maxN); | ||
+ | |||
+ | double c[maxN]; | ||
+ | int nc; | ||
+ | addPolynomials(a, na, b, nb, c, nc); | ||
+ | cout << endl << "Ich sucet:" << endl; | ||
+ | writePolynomial(c, nc); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Príklad behu: | ||
+ | <pre> | ||
+ | Prvy polynom: | ||
+ | Zadaj pocet koeficientov n: 4 | ||
+ | Zadaj koeficient pri x na 0: -1 | ||
+ | Zadaj koeficient pri x na 1: 3 | ||
+ | Zadaj koeficient pri x na 2: 0 | ||
+ | Zadaj koeficient pri x na 3: 2 | ||
+ | |||
+ | Druhy polynom: | ||
+ | Zadaj pocet koeficientov n: 3 | ||
+ | Zadaj koeficient pri x na 0: 7 | ||
+ | Zadaj koeficient pri x na 1: 2 | ||
+ | Zadaj koeficient pri x na 2: -4 | ||
+ | |||
+ | Ich sucet: | ||
+ | Koeficient polynomu pri x na 0 je 6 | ||
+ | Koeficient polynomu pri x na 1 je 5 | ||
+ | Koeficient polynomu pri x na 2 je -4 | ||
+ | Koeficient polynomu pri x na 3 je 2 | ||
+ | </pre> | ||
+ | |||
+ | ===Ďalšie príklady s polynómami=== | ||
+ | Vieme napísať aj ďalšie funkcie alebo programy na prácu s polynómami: | ||
+ | * Vykresľovanie grafu (rátame hodnotu polynómu v husto rozmiestnených bodoch) | ||
+ | * Násobenie polynómov | ||
+ | * Delenie so zvyškom a Euklidov algoritmus | ||
+ | * Derivácia | ||
+ | * A mnohé ďalšie | ||
+ | |||
+ | ===Zdrojový kód celého programu=== | ||
+ | * [http://compbio.fmph.uniba.sk/vyuka/prog/data/programy/P6-polynomy.cpp Zdrojový kód programu s polynómami] | ||
+ | |||
+ | ===Načo sú v programovaní dobré funkcie=== | ||
+ | * Rozbijeme veľký problém na menšie dobre definované časti (napr. načítaj polynóm, spočítaj jeho hodnotu), každou časťou sa môžeme zaoberať zvlášť. Výsledný program je ľahšie pochopiteľný, najmä ak u každej funkcie napíšeme, čo robí. | ||
+ | * Vyhneme sa opakovaniu kusov kódu (napr. načítanie polynómu A a B). Pri kopírovaní kusov kódu ľahko narobíme chyby, a ak chceme niečo meniť, musíme meniť na veľa miestach. | ||
+ | * Hotové funkcie môžeme použiť aj v ďalších programoch, prípadne z nich zostavovať nové knižnice, napríklad knižnicu na prácu s polynómami. | ||
+ | |||
+ | ==Triedenia== | ||
+ | |||
+ | Máme pole čísel, chceme ich usporiadať od najmenšieho po najväčšie. | ||
+ | * Napr. pre pole 9 3 7 4 5 2 chceme dostať 2 3 4 5 7 9 | ||
+ | * Jeden z najštudovanejších problémov v informatike. | ||
+ | * Súčasť mnohých zložitejších algoritmov. | ||
+ | * Veľa spôsobov, ako triediť, dnes si ukážeme zopár najjednoduchších. | ||
+ | |||
+ | ===Bublinkové triedenie (Bubble Sort)=== | ||
+ | |||
+ | Idea: Kontrolujeme všetky dvojice susedných prvkov a keď vidíme menšie číslo za väčším, vymeníme ich | ||
+ | <pre> | ||
+ | for (int i = 1; i < n; i++) { | ||
+ | if (a[i] < a[i - 1]) { | ||
+ | swap(a[i - 1], a[i]); | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | * Ak sme nenašli v poli žiadnu dvojicu, ktorú treba vymeniť, skončili sme. | ||
+ | * Inak celý proces opakujeme znova. | ||
+ | |||
+ | Celé triedenie: | ||
+ | <pre> | ||
+ | void swap(int &x, int &y) { | ||
+ | /* Vymeň hodnoty premenných x a y. */ | ||
+ | int tmp = x; | ||
+ | x = y; | ||
+ | y = tmp; | ||
+ | } | ||
+ | |||
+ | void sort(int a[], int n) { | ||
+ | /* usporiadaj prvky v poli a od najmenšieho po najväčší */ | ||
+ | |||
+ | bool hotovo = false; | ||
+ | while (!hotovo) { | ||
+ | bool vymenil = false; | ||
+ | /* porovnávaj všetky dvojice susedov, vymeň ak menší za väčším */ | ||
+ | for (int i = 1; i < n; i++) { | ||
+ | if (a[i] < a[i - 1]) { | ||
+ | swap(a[i - 1], a[i]); | ||
+ | vymenil = true; | ||
+ | } | ||
+ | } | ||
+ | /* ak sme žiadnu dvojicu nevymenili, môžeme skončiť. */ | ||
+ | if (!vymenil) { | ||
+ | hotovo = true; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | * Čo ak vo for cykle dám <tt>for (int i = 0; i < n; i++) {</tt> | ||
+ | * Ako nahradím premennú <tt>hotovo</tt> príkazom <tt>break</tt>? | ||
+ | |||
+ | Príklad behu: | ||
+ | <pre> | ||
+ | prvá iterácia while cyklu | ||
+ | 9 3 7 4 5 2 | ||
+ | 3 9 7 4 5 2 | ||
+ | 3 7 9 4 5 2 | ||
+ | 3 7 4 9 5 2 | ||
+ | 3 7 4 5 9 2 | ||
+ | 3 7 4 5 2 9 | ||
+ | |||
+ | druhá iterácia while cyklu | ||
+ | 3 7 4 5 2 9 | ||
+ | 3 4 7 5 2 9 | ||
+ | 3 4 5 7 2 9 | ||
+ | 3 4 5 2 7 9 | ||
+ | |||
+ | tretia iterácia while cyklu | ||
+ | 3 4 5 2 7 9 | ||
+ | 3 4 2 5 7 9 | ||
+ | |||
+ | štvrtá iterácia while cyklu | ||
+ | 3 4 2 5 7 9 | ||
+ | 3 2 4 5 7 9 | ||
+ | |||
+ | piata iterácia while cyklu | ||
+ | 3 2 4 5 7 9 | ||
+ | 2 3 4 5 7 9 | ||
+ | </pre> | ||
+ | |||
+ | Cvičenie: | ||
+ | Ako sa bude správať algoritmus na nasledujúcich vstupoch, koľkokrát zopakuje vonkajší while cyklus? | ||
+ | * Utriedené pole 1,2,...,n | ||
+ | * Pole n,1,2,...,n-1 | ||
+ | * Pole 2,3,...,n,1 | ||
+ | * Pole n,n-1,...,1 | ||
+ | |||
+ | ===Triedenie výberom (selection sort, max sort)=== | ||
+ | |||
+ | Idea: nájdime najväčší prvok a uložme ho na koniec. Potom nájdime najväčší medzi zvyšnými a uložme ho na druhé miesto odzadu atď. | ||
+ | |||
+ | <pre> | ||
+ | int maxIndex(int a[], int n) { | ||
+ | /* vráť index, na ktorom je najväčší prvok z prvkov a[0]...a[n-1] */ | ||
+ | int index = 0; | ||
+ | for(int i=1; i<n; i++) { | ||
+ | if(a[i]>a[index]) { | ||
+ | index = i; | ||
+ | } | ||
+ | /* invariant: a[j]<=a[index] pre vsetky j=0,...,i*/ | ||
+ | } | ||
+ | return index; | ||
+ | } | ||
+ | |||
+ | void sort(int a[], int n) { | ||
+ | /* usporiadaj prvky v poli a od najmenšieho po najväčší */ | ||
+ | |||
+ | for(int kam=n-1; kam>=1; kam--) { | ||
+ | /* invariant: a[kam+1]...a[n-1] sú utriedené | ||
+ | * a pre každé i,j také že 0<=i<=kam, kam<j<n platí a[i]<=a[j] */ | ||
+ | int index = maxIndex(a, kam+1); | ||
+ | swap(a[index], a[kam]); | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Príklad behu programu | ||
+ | <pre> | ||
+ | Vstup 9 3 7 4 5 2 | ||
+ | Po výmene (9,2) 2 3 7 4 5 9 | ||
+ | Po výmene (7,5) 2 3 5 4 7 9 | ||
+ | Po výmene (5,4) 2 3 4 5 7 9 | ||
+ | Po výmene (4,4) 2 3 4 5 7 9 | ||
+ | Po výmene (3,3) 2 3 4 5 7 9 | ||
+ | </pre> | ||
+ | |||
+ | Cvičenie: Bude čas behu algoritmu výrazne odlišný pre pole utriedené správne a pole utriedené v opačnom poradí? | ||
+ | |||
+ | ===Triedenie vkladaním (Insertion Sort)=== | ||
+ | |||
+ | Idea: | ||
+ | * v prvej časti poľa prvky v utriedenom poradí | ||
+ | * zober prvý prvok z druhej časti a vlož ho na správne miesto v utriedenom poradí | ||
+ | |||
+ | Príklad behu algoritmu: | ||
+ | <pre> | ||
+ | 9 3 7 4 5 2 | ||
+ | 3 9 7 4 5 2 | ||
+ | 3 7 9 4 5 2 | ||
+ | 3 4 7 9 5 2 | ||
+ | 3 4 5 7 9 2 | ||
+ | 2 3 4 5 7 9 | ||
+ | </pre> | ||
+ | |||
+ | Ako spraviť vkladanie: | ||
+ | * Vkladaný prvok si zamätáme v pomocnej premennej | ||
+ | * Utriedené prvky posúvame o jedno doprava, kým nenájdeme správne miesto pre odložený prvok | ||
+ | |||
+ | <pre> | ||
+ | void sort(int a[], int n) { | ||
+ | /* usporiadaj prvky v poli a od najmenšieho po najväčší */ | ||
+ | |||
+ | for (int i = 1; i < n; i++) { | ||
+ | int prvok = a[i]; | ||
+ | int kam = i; | ||
+ | while (kam > 0 && a[kam - 1] > prvok) { | ||
+ | a[kam] = a[kam - 1]; | ||
+ | kam--; | ||
+ | } | ||
+ | a[kam] = prvok; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Všimnime si podmienku <tt>(kam > 0 && a[kam - 1] > prvok)</tt> | ||
+ | ** Ak kam==0, prvá časť je false, druhá časť sa už nevyhodnocuje | ||
+ | ** Ak by sme prehodili časti, program by mohol spadnúť <tt>(a[kam - 1] > prvok && kam > 0)</tt> | ||
+ | |||
+ | Cvičenie: | ||
+ | Ako sa bude správať algoritmus na nasledujúcich vstupoch, koľkokrát zopakuje priradenie a[kam]=a[kam-1]? | ||
+ | * Utriedené pole 1,2,...,n | ||
+ | * Pole n,1,2,...,n-1 | ||
+ | * Pole 2,3,...,n,1 | ||
+ | * Pole n,n-1,...,1 | ||
+ | |||
+ | ===Zdrojový kód programu s triedeniami=== | ||
+ | * [http://compbio.fmph.uniba.sk/vyuka/prog/data/programy/P6-polynomy.cpp Zdrojový kód programu s triedeniami] | ||
+ | |||
+ | ==Zhrnutie== | ||
+ | * Videli sme niekoľko nových algoritmov: | ||
+ | ** Vyhodnocovanie a sčítavanie polynómov | ||
+ | ** Tri jednoduché algoritmy na triedenie | ||
+ | *** Neskôr sa ešte naučíme rýchlejšie algoritmy na triedenie, ktoré používajú rekurziu | ||
+ | |||
+ | * Precvičili sme si funkcie, parametre a polia | ||
+ | * K funkciám je dobré napísať, čo robia | ||
+ | * Do cyklov si môžeme písať invarianty | ||
+ | ** Používajú sa pri formálnom dokazovaní správnosti | ||
+ | ** Pomáhajú pochopeniu kódu | ||
+ | ** Môžeme ich použiť na ručnú alebo automatickú kontrolu správnosti hodnôt premenných | ||
+ | ** Príkaz <tt>assert</tt> v knižnici <tt>cassert</tt> kontroluje podmienku, napr. <tt>assert(i>=0 && i<n);</tt> ukončí program s chybovou hláškou ak podmienka neplatí | ||
+ | =Cvičenia 3= | ||
+ | == Vypisovanie čísel == | ||
+ | |||
+ | Napíšte program, ktorý vypíše štvorec veľkosti NxN obsahujúci čísla nasledovne (vyskúšajte všetky tri spôsoby): | ||
+ | |||
+ | * V prvom riadku budú samé 1, v druhom samé 2, .. v poslednom samé N | ||
+ | * V každom riadku budú čísla od 1 po N | ||
+ | * Rovnaké čísla budú uhlopriečne | ||
+ | <pre> | ||
+ | 1 1 1 1 1 2 3 4 1 2 3 4 | ||
+ | 2 2 2 2 1 2 3 4 2 3 4 5 | ||
+ | 3 3 3 3 1 2 3 4 3 4 5 6 | ||
+ | 4 4 4 4 1 2 3 4 4 5 6 7 | ||
+ | </pre> | ||
+ | Hodnotu N si na začiatku programu uložte do premennej. | ||
+ | |||
+ | == Číselné sústavy == | ||
+ | |||
+ | * Napíšte funkciu <tt>cifernySucet</tt>, ktorá dostane ako parameter číslo N a vráti jeho ciferný súčet (napr. pre N=124 vráti 7). Funkcia main načíta číslo od užívateľa, zavolá túto funkciu a vypíše výsledok. | ||
+ | |||
+ | * Napíšte funkciu <tt>pocetCifier</tt>, ktorá dostane ako parameter číslo N a vráti počet cifier, ktoré má (napr. pre N=124 vráti 3). Funkcia main načíta dve čísla ''a'' a ''b'' a vypíše ich pod seba zarovnané doprava (zistí pre obe počet cifier a pred kratšie vypíše potrebný počet medier. Napríklad pre a=3 a b=100 vypíše: | ||
+ | <pre> | ||
+ | 3 | ||
+ | 100 | ||
+ | </pre> | ||
+ | |||
+ | == Hádaj číslo == | ||
+ | |||
+ | Na prednáške bola naprogramovaná hra [[#Prednáška_3#Hra_h.C3.A1daj_.C4.8D.C3.ADslo|Hádaj číslo]], kde si počítač "myslí číslo" od 1 do 100 a používateľ háda, o ktoré číslo ide. Upravte program nasledovne: | ||
+ | |||
+ | * Program umožní používateľovi sa vzdať, napríklad keď používateľ zadá 0. V tom prípade program vypíše hľadané číslo a skončí. | ||
+ | * Program bude počítať počet kôl, ktoré používateľ potreboval k uhádnutiu čísla a na konci ho vypíše. | ||
+ | |||
+ | == Kombinačné čísla == | ||
+ | |||
+ | Iste poznáte kombinačné číslo <math>{n\choose k}=\frac{n!}{k!(n-k)!}</math>, ktoré vyjadruje, koľkými možnosťami je možné vybrať k prvkov z n-prvkovej množiny. | ||
+ | |||
+ | * Vypočítajte kombinačné číslo <math>{n\choose k}</math> priamo z definície, t.j. pomocou funkcie, ktorá počíta faktoriál čísla. | ||
+ | * Kombinačné čísla sa dajú počítať aj efektívnejšie. Napríklad <math>{5 \choose 2} = \frac{5!}{2!3!} = \frac{5\cdot4\cdot 3\cdot 2\cdot 1}{2\cdot 1\cdot3\cdot2\cdot1}</math> sa zjavne dá zjednodušiť na <math>{5 \choose 2} = \frac{5\cdot4}{2\cdot 1}</math>. Vytvorte funkciu, ktorá počíta kombinačné číslo týmto spôsobom. Vieme túto funkciu upraviť tak, aby nepočítala najskôr čitateľa a potom menovateľa a pritom ostal jej výsledok stále typu int? | ||
+ | * Pomocou predchádzajúcej funkcie vypíšte do jedného riadku hodnoty <math>{n\choose i}</math> pre používateľom zadané n a všetky i od 0 po n. | ||
+ | * Funkciu pre vypísanie celého riadku vieme optimalizovať nasledovne: Na základe čísla <math>{n\choose i}</math> budeme počítať <math>{n\choose i+1}</math>. Vypíšte riadok Pascalovho trojuholníka takýmto spôsobom. | ||
+ | |||
+ | == Grafická funkcia == | ||
+ | |||
+ | * Napíšte funkciu, ktorá do grafického okna vykreslí [[#Prednáška_2#Premenn.C3.A9|domček z prvej resp. druhej prednášky]]. Ako parameter dostane súradnice ľavého dolného rohu domčeka, jeho výšku, šírku a výšku strechy, ale aj okno, do ktorého vykresľujeme (prenesieme ho ako referenciu - pomocou <tt>SimpleDraw & window</tt>). | ||
+ | ** V hlavnom okne použite túto funkciu na vykreslenie domčekov rôznej farby na nieľkokých miestach na obrazovke. | ||
+ | =DÚ2= | ||
+ | {{MDU|2|4085}} a {{MDU|2 bonus|4086}} max. 10 bodov + 4 body bonus, termín odovzdania pondelok 8.10. o 22:00 | ||
+ | |||
+ | Cieľom tejto domácej úlohy je precvičiť prácu s cyklami a funkciami. Nepoužívajte polia a iné dátové štruktúry, iba premenné typu int, prípadne aj double a bool. | ||
+ | |||
+ | Iste poznáte kombinačné čísla <math>{n\choose k}=\frac{n!}{k!(n-k)!}</math>, ktoré vyjadrujú, koľkými možnosťami je možné vybrať ''k'' prvkov z ''n''-prvkovej množiny. Keď kombinačné čísla usporiadame do tvaru trojuholníka, dostaneme [http://sk.wikipedia.org/wiki/Pascalov_trojuholn%C3%ADk Pascalov trojuholník]. V každom riadku Pascalovho trojuholníka sú kombinačné čísla pre jednu hodnotu ''n'', pričom uvažujeme všetky hodnoty ''k'' od 0 po ''n''. | ||
+ | |||
+ | V tejto úlohe chceme zrátať zvyšok po delení dvoma pre jednotlivé čísla v Pascalovom trojuholníku a vykresliť ich graficky tak, že nepárne čísla zobrazíme ako čierny štvorček a párne ako biely štvorček. Ak tak urobíme pre veľa riadkov Pascalovho trojuholníka, dostaneme fraktálny útvar zvaný Sierpinského trojuholník. Problém však je, že keby sme priamočiaro rátali kombinačné čísla pre veľké hodnoty ''n'' a zisťovali či sú párne, nestačil by nám rozsah premennej int. Budeme teda postupovať prefíkanejšie: nebudeme rátať presnú hodnotu kombinačného čísla, zrátame iba najväčšiu mocninu dvojky, ktorá ho delí. Kombinačné číslo je podiel súčinov malých celých čísel. Ak zistíme pre každé z týchto čísel, aká najväčšia mocnina dvojky ho delí, sčitovaním a odčitovaním môžeme získať najväčšiu mocninu dvojky, ktorá delí výsledné kombinačné číslo. Napríklad <math>{5 \choose 2} = \frac{5!}{2!3!} = \frac{5\cdot4\cdot 3\cdot 2\cdot 1}{2\cdot 1\cdot3\cdot2\cdot1}</math> V čitateli 5,3 a 1 sú deliteľné iba <math>2^0 </math>, 4 je deliteľné <math>2^2</math> a 2 je deliteľné <math>2^1</math>. Spolu je teda čitateľ deliteľný <math>2^3</math>. Podobne menovateľ je deliteľný <math>2^2</math>, najvyššia mocnina dvojky, ktorá delí výsledné kombinačné číslo je teda <math>2^3/2^2 = 2^{3-2}=2^1</math>. Toto kombinačné číslo je 10, takže vidíme, že odpoveď je správna. | ||
+ | |||
+ | * Časť a) Napíšte funkciu s hlavičkou <tt>int powerTwo(int n)</tt> ktorá spočíta pre dané kladné celé číslo ''n'' najvyššie ''k'' také, že <math>2^k</math> delí ''n''. Napríklad powerTwo(12) je 2, lebo <math>4=2^2</math> je najvyššia mocnina dvojky, ktorá delí 12. | ||
+ | |||
+ | [[Image:PROG-DU3-triangle.png|thumb|200px|right|Výsledok pre maxN=4]] [[Image:PROG-DU3-triangle2.png|thumb|200px|right|Výsledok pre maxN=4 s naznačenými hranicami jednotlivých políčok Pascalovho trojuholníka. Červené čiary vo vašom programe nekreslite.]] | ||
+ | * Časť b) Napíšte program, ktorý bude riadok po riadku počítať paritu kombinačných čísel v Pascalovom trojuholníku a keď nájde nepárne číslo, vykreslí na príslušné miesto grafickej plochy čierny štvorček. | ||
+ | ** Pri výpočte môžete použiť vzťah medzi susednými hodnotami v riadku: <math>{n\choose k} = {n\choose k-1} \cdot \frac{n-k+1}{k}</math> pre <math>1\le k \le n</math>. | ||
+ | ** Vyhnite sa problémom s veľmi veľkými číslami použitím funkcie powerTwo | ||
+ | ** V programe si uložte do premenných nasledujúce parametre obrázku (nenačítavajte ich od užívateľa, stačí ich nastaviť priamo v programe): | ||
+ | *** maxN - posledný riadok, ktorý vypisujeme | ||
+ | *** square - veľkosť jedného štvrčeka | ||
+ | ** Potrebnú veľkosť obrázku aj rozmiestnenie štvorcov spočítajte z týchto premenných. | ||
+ | ** Výsledok by mal vyzerať ako obrázok napravo (použili sme maxN=4, square=50). Pre veľké maxN program potrebuje veľa pamäte na uloženie jednotlivých štvorčekov, skúste však napríklad hodnotu square=2 a maxN=63 a maxN=255. | ||
+ | |||
+ | * Časť c) bonus: Napíšte vylepšený program taký, že ak ide v riadku za sebou niekoľko čiernych štvorčekov, vykreslíte ich ako jeden obdĺžnik. To by malo program zrýchliť a zmenšiť jeho pamäť. Program by mal tiež spočítať, koľko čiernych štvorčekov by vykreslil v základnej verzii, koľko vykreslil obdĺžnikov a aká je teda úspora v počte vykreslených útvarov. Hodnoty, ktoré dostanete pre maxN=63 uveďte v komentári programu. | ||
+ | |||
+ | Domácu úlohu odovzdávajte v systéme Moodle, pričom odovzdajte program main.cpp pre časť a) a b) a ak robíte aj časť c), odovzdajte ju v zvláštnom súbore bonus.cpp. | ||
+ | =Prednáška 7= | ||
+ | == Organizačné poznámky == | ||
+ | |||
+ | * DÚ2 a pokročilú DÚ1 odovzdávajte do dnes (8.10.2012) do 22:00 | ||
+ | * Nepovinné cvičenia z programovania v H3 od 14:50. V prípade, že by to veľa ľuďom nevyhovovalo, dá sa presunúť na 14:00 | ||
+ | |||
+ | == Vyhľadávanie prvkov poľa == | ||
+ | |||
+ | Úlohou je zistiť, či pole obsahuje prvok zadanej hodnoty. | ||
+ | |||
+ | * Zrejme budeme musieť prejsť celé pole, lebo nevieme, kde sa prvok môže nachádzať. | ||
+ | |||
+ | <pre> | ||
+ | int Member(int A[], int N, int x){ | ||
+ | for (int i=0; i<N; i++){ | ||
+ | if (a[i]==x) return i; | ||
+ | } | ||
+ | return -1; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Toto môžeme urobiť aj v prípade, že máme pole usporiadané. Prejdením celého poľa prvok iste nájdeme alebo zistíme, že sa tam taký prvok nenachádza. | ||
+ | * Ale neexistuje lepšie riešenie? | ||
+ | |||
+ | === Binárne vyhľadávanie === | ||
+ | |||
+ | Lepšie riešenie samozrejme existuje a je založené na nasledovnej myšlienke: | ||
+ | |||
+ | * Ak pozriem v utriedenom poli na nejaký prvok A[i], tak v intervale <tt>0..(i-1)</tt> sú čísla veľkosti nanajvýš A[i] a v intervale <tt>(i+1)..(N-1)</tt> sú čísla veľkosti aspoň A[i]. | ||
+ | * Keď teda hľadám nejaký prvok x, tak po jednom nahliadnutí do poľa viem | ||
+ | ** buď priamo povedať, že ten prvok sa tam nachádza - ak som trafila priamo pozíciu i taku, že x=A[i] | ||
+ | ** vyhodiť (t.j. ďalej nepoužívať) časť poľa v intervale <tt>(i+1)..(N-1)</tt> - ak som trafila priamo pozíciu i taku, že x<A[i] | ||
+ | ** vyhodiť (t.j. ďalej nepoužívať) časť poľa v intervale <tt>0..(i-1)</tt> - ak som trafila priamo pozíciu i taku, že x>A[i] | ||
+ | * V utriedenom poli teda môžem vyhľadávať nasledovne: | ||
+ | ** budem si pamätať ľavý a pravý kraj, kde ešte môže byť hľadaný prvok | ||
+ | ** vyberiem nejaký prvok z tohoto intervalu a patrične interval skrátim | ||
+ | ** ak už je interval zlý (t.j. pravý a ľavý kraj sú naopak) tak skončí | ||
+ | * Jediná nezodpovedaná otázka je, ako vyberám prvok, na ktorý sa pýtam | ||
+ | |||
+ | <pre> | ||
+ | int Member(int A[], int N, int x){ | ||
+ | int left=0, right=N-1, index; | ||
+ | while (left<=right){ | ||
+ | index=??; | ||
+ | if (A[index]==x) {return index;} | ||
+ | else if (A[index]<x) {left=index+1;} | ||
+ | else {right=index-1;} | ||
+ | } | ||
+ | return =-1; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Pozrime sa na jednotlivé možnosti ako prvok vyberať (aj keď vám je už asi jasné, aký bude výsledok): | ||
+ | * Budeme vyberať vždy prvý prvok - tým vlastne máme skoro pôvodné hľadanie. Jediný rozdiel je, že v prípade, že už dojdeme na prvok poľa, ktorý je väčší ako hľadané x, tak zastavíme a odpovieme, že prvok tam nie je. | ||
+ | ** Beh programu si ukážeme na príklade | ||
+ | <pre> | ||
+ | A[7]={2,5,41,68,72,100,156} | ||
+ | N=7 x=41 | ||
+ | left=0 right=6: index=0; A[index]<x | ||
+ | left=1 right=6; index=1; A[index]<x | ||
+ | left=2 right=6; index=2; A[index]=x -> return 2 | ||
+ | N=7 x=31 | ||
+ | left=0 right=6: index=0; A[index]<x | ||
+ | left=1 right=6; index=1; A[index]<x | ||
+ | left=2 right=6; index=2; A[index]>x | ||
+ | left=2 right=1; left>right -> koniec while cyklu -> return -1 | ||
+ | </pre> | ||
+ | * Budeme vyberať vždy stredný prvok teda <tt>index=(left+right)/2</tt>, čím dosiahneme, že v každom ktorku zahodíme polovicu poľa. | ||
+ | ** Beh programu si ukážeme na príklade | ||
+ | <pre> | ||
+ | A[7]={2,5,41,68,72,100,156} | ||
+ | N=7 x=41 | ||
+ | left=0 right=6: index=3; A[index]>x (68>41) | ||
+ | left=0 right=2; index=2; A[index]<x (5<41) | ||
+ | left=2 right=2; index=1; A[index]=x -> return 2 | ||
+ | N=7 x=31 | ||
+ | left=0 right=6: index=3; A[index]>x (68>31) | ||
+ | left=1 right=2; index=1; A[index]<x (5<31) | ||
+ | left=2 right=2; index=2; A[index]>x (41>31) | ||
+ | left=2 right=1; left>right -> koniec while cyklu -> return -1 | ||
+ | </pre> | ||
+ | |||
+ | Tak nejako prirodzene máme pocit, že to druhé riešenie je lepšie. Že by malo byť asi rýchlejšie... | ||
+ | |||
+ | == Zložitosť algoritmu == | ||
+ | |||
+ | Ako sme viedli už napríklad na triedení a vyhľadávaní, jednu úlohu môžeme často riešiť viacerými spôsobmi. Tak intuitívne máme o niektorých pocit, že sú lepšie ako iné. Prečo a v čom sú niektoré riešenia lepšie a ako môžeme niečo také vlastne odhadovať (ináč ako intuitívne). | ||
+ | |||
+ | === Čas === | ||
+ | |||
+ | Často nás zaujíma, ako rýchlo nám program bude bežať. Vo väčšine prípadov táto rýchlosť nejakým spôsobom závisí od vstupných dát. Iste bude kratšie trvať utriedenie 3 prvkového poľa ako poľa s 100000 prvkami. Časovú zložitosť teda budeme odhadovať v závislosti od veľkosti vstupu. | ||
+ | |||
+ | Pre niektoré programy sa môže čas vypočítať jednoducho ako počet operácií, ktoré program vykoná. Avšak už pri použití podmienky dojdeme k situácii, kedy začneme uvažovať, čo započítať a co nie. | ||
+ | |||
+ | <pre> | ||
+ | int main(void){ | ||
+ | int x,max,N; | ||
+ | |||
+ | cout << "Zadajte N>0: "; | ||
+ | cin >> N; | ||
+ | cout << "Zadavajte cisla: "; | ||
+ | |||
+ | cin >> max; | ||
+ | for (int i=1; i<N; i++){ | ||
+ | cin >> x; | ||
+ | if (x>max) {max=x;} | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Na začiatku máme 3 príkazy (cout a cin). | ||
+ | * Pre prvý prvok následne potrebujeme jeho načítanie (priamo do premennej max v ktorej si pamätáme aktuálne maximum). | ||
+ | * Je jasné, že pre každý ďalší z N prvkov, potrebujeme prvok načítať a opýtať sa na podmienku. | ||
+ | * Avšak už nie pre každý prvok musíme následne použiť priradenie (tých priradení nemusíme potrebovať žiadne ale môžeme ho potrebovať v každom z N-1 prvkov) | ||
+ | * Celkový súčet bude teda niečo medzi 3+1+(N-1)+0 a 3+1+(N-1)+(N-1) | ||
+ | |||
+ | Vo väčších programoch však to rozmedzie nie je také jednoduché vypočítať a preto sa bavíme často o najhoršom prípade, ktorý môže nastať. Okrem toho nás nezaujímajú presné čísla ale iba akýsi odhad (približná funkcia) závislá od vstupu. Ukážeme si odhad zložitosti na niektorých príkladoch. | ||
+ | |||
+ | * Už spomínané hľadanie maxima. Pre každý z N prvkov potrebujeme urobiť niekoľko (aspoň jednu ale nie viac ako konštantu) operácií. Preto zložitosť bude lineárna. | ||
+ | * Pozrime sa, ako na tom bude binárne vyhľadávanie. Pozrieme sa na najhorší možný scénár a to, že prvok nájdeme až v poslednom kroku alebo v poli nebude vôbec, teda ho neobjavíme skôr. | ||
+ | ** V prvom kroku máme celé pole a v ňom sa pozrieme na stredný prvok a podľa jeho hodnoty zoberieme buď ľavú alebo pravú (zhruba) polovicu poľa. | ||
+ | ** Tým pádom v druhom kroku máme pole polovičnej veľkosti a robíme na ňom zase to isté. | ||
+ | ** V každom kroku teda máme pole o poloicu menšie až kým nemáme pole veľkosti 1 - potom buď už prbvok nájdeme alebo v ďalšom krku povieme, že tam nie je. | ||
+ | ** Akú zložitosť bude mať tento program? Zapíšeme si číslo N (počet prvkov) v dvojkovej sústave. Pri delení poľa na polovicu bude ďalšia veľkosť poľa vlastne toto číslo bez poslednej cifry. Počet krokov, ktoré potrebujeme je teda zhruba počet cifier takto zapísaného čísla, čo je <math>log_2 N</math>. | ||
+ | ** Iba tak pre úplnosť dodávam, že log N je menej ako N, čiže binárne vyhľadávanie beží rýchlejšie ako lineárne (v najhoršom prípade). | ||
+ | |||
+ | Na minulej prednáške boli niektoré triedenia. Pozrime, akú zložitosť majú. Odhad zložitosti urobím na jednom príklade, zvyšné si môžete skúsiť doma alebo na cvičeniach. | ||
+ | * Selection sort (max sort). Najprv pripomeniem hlavnú ideu: nájdeme najväčší prvok a uložme ho na koniec. Potom nájdime najväčší medzi zvyšnými a uložme ho na druhé miesto odzadu atď. | ||
+ | |||
+ | <pre> | ||
+ | int maxIndex(int a[], int n) { | ||
+ | /* vráť index, na ktorom je najväčší prvok z prvkov a[0]...a[n-1] */ | ||
+ | int index = 0; | ||
+ | for(int i=1; i<n; i++) { | ||
+ | if(a[i]>a[index]) { | ||
+ | index = i; | ||
+ | } | ||
+ | /* invariant: a[j]<=a[index] pre vsetky j=0,...,i*/ | ||
+ | } | ||
+ | return index; | ||
+ | } | ||
+ | |||
+ | void sort(int a[], int n) { | ||
+ | /* usporiadaj prvky v poli a od najmenšieho po najväčší */ | ||
+ | |||
+ | for(int kam=n-1; kam>=1; kam--) { | ||
+ | /* invariant: a[kam+1]...a[n-1] sú utriedené | ||
+ | * a pre každé i,j také že 0<=i<=kam, kam<j<n platí a[i]<=a[j] */ | ||
+ | int index = maxIndex(a, kam+1); | ||
+ | swap(a[index], a[kam]); | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Opäť máme program, v ktorom postupujeme v nejakých krokoch - v tomto prípade máme for-cyklus. V každom kroku musíme nájsť maximum z poľa a veľkosti kam+1. Potom už iba vymeníme takto nájdené maximum a posledný provok poľa. Pričom premenná kam je riadiaca premenná for-cyklu a v každom kroku klesá. | ||
+ | * Otázka je, aký čas potrebujeme na hľadanie maxima z x prvkov. Odpoveď je jednoduchá - prvky musíme prejsť všetky a teda zložitosť bude lineárna, t.j. <tt>x</tt>. | ||
+ | * Teraz si už iba spočítame: V prvom kroku hľadáme maximum z n prvkov, v druhom z n-1 ... | ||
+ | * Teda čas, ktorý na to potrebujeme je <math>n+(n-1)+...+1=\frac{n(n+1)}{2}=\frac{n^2}{2}+\frac{n}{2}</math>. Zložitosť tohoto triedenia bude teda kvadratická. | ||
+ | |||
+ | * Bude sa však správať rovnako (kvadraticky) na všetkých vstupoch? Ak by sme ako mieru zložitosti brali výmeny prvkov, koľkokrát zopakuje priradenie a[kam]=a[kam-1]? | ||
+ | |||
+ | Utriedené pole 1,2,...,n | ||
+ | Pole n,1,2,...,n-1 | ||
+ | Pole 2,3,...,n,1 | ||
+ | Pole n,n-1,...,1 | ||
+ | |||
+ | === Pamäť === | ||
+ | |||
+ | Ďalší bežný dôdov prečo povedať, že nejaký algoritmus je lepší ako druhý je, keď si toho musí menej pamätať. Majme napríklad klasickú úlohu - hľadanie najväčšieho prvku. To môžeme riešiť dvomi spôsobmi. | ||
+ | |||
+ | * Všetky čísla si zapamätáme do poľa a následne nájdeme maximum z poľa. | ||
+ | * Budeme zisťovať maximum priebežne a pamätať si ho v jednej premennej. | ||
+ | |||
+ | Na prvý spôsob si potrebujeme zapamätať pole čísel - teda pre N čísel potrebujeme N prvkov poľa a ešte nejaké pomocné premenné k tomu. Na rozdiel od toho, pre druhý spôsob (priebežné počítanie) si potrebujeme pamätať iba to priebežné maximum a nejakú pomocnú premennú. Zjavne teda pre nejaké väčšie N bude druhý spôsob výrazne vhodnejší. | ||
+ | |||
+ | == Znaky == | ||
+ | |||
+ | Znakové konštanty sa zapisujú v jednoduchých apostrofoch: 'A'. Špeciálne znaky sa dajú zapísať | ||
+ | pomocou ich kódu v osmičkovej alebo šestnástkovej sústave: '\101' a '\x41' reprezentujú znak s | ||
+ | kódom 65, t.j. 'A'. | ||
+ | |||
+ | Znaky majú teda svoje kódy. Najbežnejšie sa budeme stretávať s týmito: | ||
+ | * 32: medzera | ||
+ | * 27: escape | ||
+ | * 48...57: 0...9 | ||
+ | * 65...90: A...Z | ||
+ | * 97...122: a...z | ||
+ | * -1 ... -128: (aby ste si nemysleli, že kódy sú iba kladné) rôzne symboly | ||
+ | |||
+ | Znakové premenné sú typu char. Ich veľkosť je vždy 1, teda sizeof(char) == 1 | ||
+ | |||
+ | Do premennej môžem priraďovať, jej obsah zapísať alebo prečítať: | ||
+ | |||
+ | <pre> | ||
+ | char c='A'; | ||
+ | char z; | ||
+ | z=c; | ||
+ | cout << c; | ||
+ | cin >> z; // prečíta jeden znak (pozor, preskakujú sa biele znaky) | ||
+ | </pre> | ||
+ | |||
+ | Znaky môžem porovnávať. Na konci programu vyššie platí nasledovné: | ||
+ | |||
+ | * c=='A' ... je pravda, | ||
+ | * c=='a' ... nie je pravda – rozlišujú sa malé a veľké písmená, | ||
+ | * c<='Z' ... je pravda – písmená sú usporiadané: A<B< ... <Z, a<b< ... <z, aj cifry sú usporiadané: 0<1< ... <9. | ||
+ | |||
+ | Ako už bolo spomínané, pri čítaní zo streamu sa preskakujú tzv. biele znaky. Toto nie je vždy žiadúce a preto môžeme streamu nastaviť modifikátor <tt>noskipws</tt>, ktorý zruší preskakovanie takýchto znakov. Do premennej teda budeme vedieť prečítať aj medzeru. | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | char a,b,c; | ||
+ | |||
+ | cin >> noskipws >> a >> b >> c; | ||
+ | cout << a << b << c; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | |||
+ | === Pretypovavanie === | ||
+ | |||
+ | Znakové premenné, ako už bolo spomínané majú svoje kódy. Tieto kódy sú celé čísla a preto medzi znakmi a celými číslami môžeme prechádzať úplne jednoducho. | ||
+ | |||
+ | <pre> | ||
+ | #include<iostream> | ||
+ | |||
+ | using namespace std; | ||
+ | |||
+ | int main(void){ | ||
+ | |||
+ | int N; | ||
+ | char c; | ||
+ | |||
+ | cout << "Napiste cislo: "; | ||
+ | cin >> N; // prečíta číslo | ||
+ | c=N; // do znakovej premennej môžeme číslo priradiť bez problémov | ||
+ | cout << c << endl; // vieme vypísať znak | ||
+ | cout << (c+1) << endl; // ale keď už použijeme aritm. operáciu, je to ako číslo | ||
+ | |||
+ | cout << "Napiste znak: "; | ||
+ | cin >> c; // prečíta znak | ||
+ | N=c; // do celočíselnej premennej ho priamo vieme priradiť | ||
+ | cout << N << endl; | ||
+ | }</pre> | ||
+ | |||
+ | Okrem toho však vieme urobiť aj tzv. pretypovávanie, keď chceme aby výsledok bol konkrétneho typu. | ||
+ | Napríklad, aby nám v prvej časti vypísalo nie ďalší kód ale ďalší znak, mohli sme výsledok pretypovať. | ||
+ | |||
+ | <pre> | ||
+ | cout << (char)(c+1) << endl; // vďaka pretypovaniu dostávame na výpise zase znak | ||
+ | </pre> | ||
+ | |||
+ | Všeobecne môžeme takýmto spôsobom môžeme meniť typ - napr. výsledku nejakej operácie. | ||
+ | |||
+ | <pre> | ||
+ | double x=8.344; | ||
+ | int N=x; | ||
+ | cout << N/3 << " " << (double)(N/3) << " " << (double)N/3 << " " << x/3 << " " << (int)x/3<< endl; | ||
+ | </pre> | ||
+ | |||
+ | Tento program vypíše nasledovný výstup: | ||
+ | <pre> | ||
+ | 2 2 2.66667 2.78133 2 | ||
+ | </pre> | ||
+ | |||
+ | == Hádaj číslo (kým to niekoho baví) == | ||
+ | |||
+ | Viacero programov čo sme tu mali sa mohlo vykonávať viac ráz. My si ukážeme, ako upraviť program "Hádaj číslo", aby po uhádnutí ponúkol možnosť hrať znovu, pokiaľ to niekoho baví. | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | #include <cstdlib> | ||
+ | #include <ctime> | ||
+ | using namespace std; | ||
+ | |||
+ | void HadajCislo(int number) { | ||
+ | /* Pamätáme si, či sme už uhádli alebo nie. */ | ||
+ | bool guessed = false; | ||
+ | cout << "Guess a number between 1 and 10: "; | ||
+ | /* Kým užívateľ neuhádne, spýtame sa ho na ďalšiu odpoveď. */ | ||
+ | while (!guessed) { | ||
+ | int guess; | ||
+ | cin >> guess; | ||
+ | /* Vyhodnotíme odpoveď. */ | ||
+ | if (guess < number) { | ||
+ | cout << "Too low, try again: "; | ||
+ | } else if (guess > number) { | ||
+ | cout << "Too high, try again: "; | ||
+ | } else if (guess == number) { | ||
+ | guessed = true; | ||
+ | cout << "Correct guess" << endl; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | /* vygenerujeme náhodné číslo medzi 1 a 10 */ | ||
+ | srand(time(NULL)); | ||
+ | int number; | ||
+ | char c; | ||
+ | bool pokracovat = true; | ||
+ | |||
+ | while (pokracovat) { | ||
+ | |||
+ | number = rand() % 10 + 1; | ||
+ | HadajCislo(number); | ||
+ | |||
+ | cout << "Do you want to play again? (Y/N) "; | ||
+ | cin >> c; | ||
+ | if (c=='Y') { | ||
+ | cout << "OK. Play once more." << endl; | ||
+ | } | ||
+ | else if (c=='N') { | ||
+ | pokracovat=false; | ||
+ | } | ||
+ | |||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Switch === | ||
+ | |||
+ | V prípade, že by možností bolo viac a napríklad by sme chceli ináč reagovať v prípade iných odpovedí tak sa podmienka stane príliš komplikovanou. Preto často používame príkaz na switch, ktorý podľa hodnoty výrazu pokračuje jednou vetvou. | ||
+ | |||
+ | V našom jednoduchom príklade, by mohol switch vyzerať nasledovne: | ||
+ | |||
+ | <pre> | ||
+ | switch (c) { | ||
+ | case 'Y': cout << "OK. Play once more." << endl; break; | ||
+ | case 'N': pokracovat = false; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Vo všeobecnosti má príkaz switch viacero rôznych prípadov vyhodnotenia výrazu v podmienke. | ||
+ | |||
+ | <pre> | ||
+ | switch (výraz) | ||
+ | { | ||
+ | case k1: príkazy1 | ||
+ | case k2: príkazy2 | ||
+ | default: príkazyd | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Takýto príkaz funguje nasledovne: | ||
+ | * Vyhodnotí výraz. | ||
+ | ** Ak sa hodnota zhoduje s konštantným výrazom ki v niektorom case, pokračuje prvým príkazom v príkazyi | ||
+ | ** Ak sa nezhoduje, pokračuje prvým príkazom v prikazyd, ak existuje default, alebo pokračuje za koncom switch bloku. | ||
+ | * Narozdiel od pascalovského case vykonávanie nekončí vykonaním posledného príkazu v prikazyi, ale pokračuje ďalej, ak nie je prerušené príkazom break. | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream.h> | ||
+ | |||
+ | void main () { | ||
+ | int n; | ||
+ | cout << "\n" << "Zadaj n (1,2,3,4): "; | ||
+ | cin >> n; | ||
+ | switch (n) { | ||
+ | case 1: cout << "Jeden\n"; | ||
+ | case 2: cout << "Dva\n"; | ||
+ | case 3: | ||
+ | case 4: cout << "Tri alebo styri\n"; | ||
+ | default: cout << "Chyba!\n"; | ||
+ | } | ||
+ | cout << "Koniec.\n"; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Pre n=2 sa začnú vykonávať príkazy uvedené za vetvou case 2:. Vypíše sa: | ||
+ | |||
+ | <pre> | ||
+ | Dva | ||
+ | Tri alebo styri | ||
+ | Chyba! | ||
+ | Koniec. | ||
+ | </pre> | ||
+ | |||
+ | Výhodou je, že môžeme zlúčiť viacero prípadov do jednej vetvy tým, ze príkazy napíšeme až za posledný prípad (tu vidíme napr. v situácii n=3 a n=4). | ||
+ | |||
+ | === Dôležité upozornenie: break switch while === | ||
+ | |||
+ | Možno ste si všimli, že v príklade Hádaj číslo som použila na ukončenie cyklu premennú pokračuj. V prípade použitia podmienky if som mohla namiesto toho urobiť cyklus nekonečný a v prípade odpovede 'N' cyklus prerušiť príkazom <tt>break</tt>. | ||
+ | Keby som podobnú vec skúsila urobiť v prípade použitia <tt>switch</tt> program by sa neskončil nikdy. Dôvod je, že príkaz break nevyskočí zo všetkých cyklov, ale iba z najvnútornejšieho - a tým je v tomto prípade switch. | ||
+ | |||
+ | == Kontrola čísla == | ||
+ | |||
+ | Vďaka znakom môžeme skúsiť urobiť prvú jednoduchú kontrolu toho, čo nám vlastne používateľ napísal na vstup. Napríklad, či zadal správne celé číslo a nenamiešal medzi cifry nejaký iný znak. | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | int N = 0; | ||
+ | char c; | ||
+ | |||
+ | cout << "Zadajte cele kladne cislo: "; | ||
+ | |||
+ | cin >> noskipws >> c; | ||
+ | while ((c >= '0') && (c <= '9')) { // kym je nacitany znak cislo (t.j. jedna cifra) | ||
+ | /* vsimnite si ze nepripocitavame priamo c ale c-'0': ide totiz o kod znaku a '0' ma kod 48 */ | ||
+ | N = N * 10 + (c - '0'); // upravime cislo N | ||
+ | cin >> noskipws >> c; // a nacitame dalsi znak | ||
+ | } | ||
+ | |||
+ | if ((c == ' ') || (c == '\n')) { // ak sme skoncili medzerou alebo koncom riadku, tak je to pekne cislo | ||
+ | cout << "Zadali ste " << N << endl; | ||
+ | } else { | ||
+ | cout << "Toto je cele cislo?" << endl; // ak sme skoncili niecim divnym, tak to asi nebude ok | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Vďaka načítaniu znakov a ich kontroly vieme zistiť, či doteraz zadané číslo alebo čokoľvek iné zodpovedá tomu, čo program očakáva. | ||
+ | =Prednáška 8= | ||
+ | == Organizačné poznámky== | ||
+ | * DÚ3 do pondelka, zadania DÚ4 sa objavia koncom týždňa | ||
+ | * Zadania PDÚ2 dnes večer | ||
+ | * V piatok 12.10. od 11:35 v H6 školské kolo programátorskej súťaže ACM, viac na http://people.ksp.sk/~acm/news.php | ||
+ | * Pondelok poobede v H3 budú bývať nepovinné cvičenia z programovania | ||
+ | * Budúci týždeň preberáme rekurziu, dôležité učivo | ||
+ | |||
+ | == Z minulej prednášky== | ||
+ | |||
+ | Vďaka znakom môžeme skúsiť urobiť prvú jednoduchú kontrolu toho, čo nám vlastne používateľ napísal na vstup. Napríklad, či zadal správne celé číslo a nenamiešal medzi cifry nejaký iný znak. | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | int N = 0; | ||
+ | char c; | ||
+ | |||
+ | cout << "Zadajte cele kladne cislo: "; | ||
+ | |||
+ | cin >> noskipws >> c; | ||
+ | while ((c >= '0') && (c <= '9')) { // kym je nacitany znak cislo (t.j. jedna cifra) | ||
+ | /* vsimnite si ze nepripocitavame priamo c ale c-'0': ide totiz o kod znaku a '0' ma kod 48 */ | ||
+ | N = N * 10 + (c - '0'); // upravime cislo N | ||
+ | cin >> noskipws >> c; // a nacitame dalsi znak | ||
+ | } | ||
+ | |||
+ | if ((c == ' ') || (c == '\n')) { // ak sme skoncili medzerou alebo koncom riadku, tak je to pekne cislo | ||
+ | cout << "Zadali ste " << N << endl; | ||
+ | } else { | ||
+ | cout << "Toto je cele cislo?" << endl; // ak sme skoncili niecim divnym, tak to asi nebude ok | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | == Reťazec ako postupnosť znakov == | ||
+ | * Reťazec je nejaký text, postupnosť znakov | ||
+ | * Vedeli by sme si naprogramovať vlastné funkcie na prácu s reťazcami, ukladať ich ako pole znakov | ||
+ | * Napríklad funkcia nacitajRiadok, ktorá znak po znaku načíta text z konzoly a uloží ich do poľa, dĺžku text uloží do premennej n. | ||
+ | * Naopak funkcia vypisRetazec dostane pole znakov a jeho dĺžku a vypisuje znak po znaku. | ||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | void nacitajRiadok(char a[], int &n, int maxN) { | ||
+ | /* Z konzoly nacita riadok a ulozi ho do pola a, | ||
+ | * jeho dlzku do premennej n. Premenna maxN | ||
+ | * obsahuje dlzku pola, ktoru nesmieme prekrocit. | ||
+ | * Ak je riadok dlhsi ako maxN, nacita sa z neho iba cast. */ | ||
+ | n = 0; | ||
+ | while(n<maxN) { | ||
+ | cin >> noskipws >> a[n]; | ||
+ | n++; | ||
+ | if(a[n-1]=='\n') { break; } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void vypisRetazec(char a[], int n) { | ||
+ | /* Na konzolu vypise prvych n znakov z pola a */ | ||
+ | for(int i=0; i<n; i++) { | ||
+ | cout << a[i]; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | const int maxN = 100; | ||
+ | char a[maxN]; | ||
+ | int n; | ||
+ | |||
+ | cout << "Zadajte text: "; | ||
+ | nacitajRiadok(a, n, maxN); | ||
+ | cout << "Zadali ste: "; | ||
+ | vypisRetazec(a, n); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Nevýhoda tohto riešenia: reťazec musíme posielať všade ako dve premenné (pole a dĺžku) | ||
+ | * Preto v Cčku reťazce štandardne fungujú trochu inak. | ||
+ | |||
+ | == Reťazce v jazyku C == | ||
+ | |||
+ | Textový reťazec je v jazyku C štandardne uložený ako postupnosť znakov char v poli ukončená znakom s kódom 0. | ||
+ | * Nemusíme teda ukladať zvlášť dĺžku, reťazec ide po prvú nulu | ||
+ | * Pozor, rozdiel medzi znakom s kódom 0 a znakom '0' s kódom 48 | ||
+ | * Reťazce teda nemôžu obsahovať vo vnútri znak s kódom 0, ten je rezervovaný na ukončovanie | ||
+ | * Na reťazec s n znakmi potrebujeme pole dĺžky aspoň n+1, lebo jeden znak sa minie na ukončovací symbol | ||
+ | |||
+ | Teraz by sme vedeli prepísať nacitajRiadok a vypisRetazec, ale netreba, lebo existujú v knižniciach | ||
+ | |||
+ | ===Inicializácia reťazcov=== | ||
+ | |||
+ | * Chceme vytvoriť premennú str obsahujúce reťazec <tt>Ahoj</tt> spolu s koncom riadku | ||
+ | * Prvý spôsob je zdĺhavý: | ||
+ | <pre> | ||
+ | char str[10]; | ||
+ | str[0] = 'A'; | ||
+ | str[1] = 'h'; | ||
+ | str[2] = 'o'; | ||
+ | str[3] = 'j'; | ||
+ | str[4] = '\n'; // znak pre koniec riadku | ||
+ | str[5] = 0; | ||
+ | </pre> | ||
+ | * Alebo ako inicializácia poľa: <tt>char str[10]={'A','h','o','j','\n',0};</tt> | ||
+ | * Špeciálna skratka: <tt>char str[10]="Ahoj\n";</tt> | ||
+ | |||
+ | * Ako vytvoríme prázdny reťazec? | ||
+ | |||
+ | ===Reťazec je naozaj pole=== | ||
+ | |||
+ | '''Znaky reťazca môžeme meniť''' | ||
+ | <pre> | ||
+ | char a[100] = "vlk"; | ||
+ | char ch = a[0]; // ch obsahuje hodnotu 'v' | ||
+ | char b[100] = "pes"; | ||
+ | |||
+ | b[0] = ch; // priradíme do jedného prvku reťazca premmennú typu char. Výsledkom je 'ves'. | ||
+ | b[0] = 'd'; // priradíme do jedného prvku reťazca konštantný znak. Výsledkom je 'des'. | ||
+ | b[0] = a[1]; // priradíme do jedného prvku reťazca prvok iného reťazca. Výsledkom je 'les'. | ||
+ | </pre> | ||
+ | |||
+ | '''Reťazec sa nedá kopírovať jendoduchým priradením''', nemôžeme teda spraviť | ||
+ | <pre> | ||
+ | char a[100]; | ||
+ | a = "Ahoj"; // chyba | ||
+ | char b[100] = "Ahoj"; // ok - inicializacia | ||
+ | a = b; // chyba | ||
+ | </pre> | ||
+ | |||
+ | '''Reťazce sa nedajú ani porovnávať pomocou ==, !=, < atď''' | ||
+ | |||
+ | Kopírovanie a porovnávanie si musíme naprogramovať cez cykly, alebo použiť hotové funkcie z knižníc. | ||
+ | |||
+ | == Knižnica cstring== | ||
+ | |||
+ | Obsahuje mnohé funkcie na prácu s reťazcami, napríklad tieto: | ||
+ | * <tt>strlen(retazec)</tt>: vráti dĺžku reťazca | ||
+ | * <tt>strcpy(kam, co)</tt>: skopíruje reťazec <tt>co</tt> do reťazca <tt>kam</tt> (pole <tt>kam</tt> musí byť dosť dlhé) | ||
+ | * <tt>strcat(kam, co)</tt>: za koniec reťazca <tt>kam</tt> pridá reťazec <tt>co</tt> (pole <tt>kam</tt> musí byť dosť dlhé) | ||
+ | * <tt>strcmp(retazec1, retazec2)</tt>: vráti nulu ak sa reťazce rovnajú, kladné číslo keď je prvý neskôr v abecednom poradí, záporné číslo ak je skôr. Pozor, to či je skôr alebo neskôr sa berie podľa kódov znakov, takže napr "Z" je skôr ako "a". | ||
+ | |||
+ | Všetky tieto funkcie by sme si však vedeli naprogramovať aj sami. Tu je napríklad výpočet dĺžky: | ||
+ | <pre> | ||
+ | int myStrLen(char a[]) { | ||
+ | int n=0; | ||
+ | while(a[n]!=0) { n++; } | ||
+ | return n; | ||
+ | } | ||
+ | </pre> | ||
+ | * čo bude funkcia robiť ak reťazcu chýba na konci 0? | ||
+ | |||
+ | Dve verzie kopírovania: | ||
+ | <pre> | ||
+ | void myStrCpy(char a[], char b[]) { | ||
+ | /* Skopiruj obsah retazca b do retazca a. | ||
+ | * Pole a musi mat dost miesta. */ | ||
+ | int n = 0; | ||
+ | while (b[n] != 0) { | ||
+ | a[n] = b[n]; | ||
+ | n++; | ||
+ | } | ||
+ | a[n] = 0; // reťazec musí končiť 0 | ||
+ | } | ||
+ | |||
+ | void myStrCpy2(char a[], char b[]) { | ||
+ | /* Skopiruj obsah retazca b do retazca a. | ||
+ | * Pole a musi mat dost miesta. */ | ||
+ | for (int i = 0; i <= strlen(b); i++) { | ||
+ | a[i] = b[i]; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | * Ktorá je rýchlejšia pre dlhé reťazce? | ||
+ | * Aká je ich zložitosť ako funkcia dĺžky reťazca n? | ||
+ | |||
+ | Namiesto <tt>strcmp</tt> naprogramujeme len test na rovnosť: | ||
+ | <pre> | ||
+ | bool rovnostRetazcov(char a[], char b[]) { | ||
+ | /* vrati true ak su retazce a, b rovnake, inak vrati false */ | ||
+ | |||
+ | for (int i = 0; a[i] != 0 || b[i] != 0; i++) { | ||
+ | if (a[i] != b[i]) return false; | ||
+ | } | ||
+ | return true; | ||
+ | } | ||
+ | </pre> | ||
+ | * Ako bude prebiehať funkcia, ak jeden reťazec je začiatkom druhého? | ||
+ | |||
+ | ==Načítavanie a vypisovanie reťazcov== | ||
+ | * Bežné načítanie z konzoly do reťazca (<tt>cin >> str</tt>) načíta jedno slovo | ||
+ | ** Preskočí biele znaky (medzery, konce riadkov, tabulátory), potom prečíta všetko po ďalší biely znak (alebo koniec vstupu) a uloží do premennej. | ||
+ | ** Pri čítaní je vhodné nastaviť maximálny počet znakov na načítanie, aby sme nevyšli z poľa | ||
+ | |||
+ | * Na načítanie jedného riadku je možné použiť funkciu <tt>getline</tt>. Načíta až po koniec riadku, ten zahodí. | ||
+ | * Vypisovanie funguje normálne pomocou <tt>cout << str</tt> | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | const int maxN = 100; | ||
+ | char str[maxN], str2[maxN], str3[maxN]; | ||
+ | |||
+ | cin.getline(str, maxN); // cely riadok, ale najviac maxN-1 znakov | ||
+ | |||
+ | cin.width(maxN); // najviac maxN-1 znakov pri najbližšom načítaní | ||
+ | cin >> str2; // nacita jedno slovo | ||
+ | cin.width(maxN); // najviac maxN-1 znakov pri najbližšom načítaní | ||
+ | cin >> str3; // nacita dalsie slovo | ||
+ | |||
+ | cout << "str: \"" << str << "\"" << endl; | ||
+ | cout << "str2: \"" << str2 << "\"" << endl; | ||
+ | cout << "str3: \"" << str3 << "\"" << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Príklad behu programu (prvé dva riadky zadal užívateľ, na začiatku a konci každého je medzera) | ||
+ | <pre> | ||
+ | a b c | ||
+ | g h i | ||
+ | str: " a b c " | ||
+ | str2: "g" | ||
+ | str3: "h" | ||
+ | </pre> | ||
+ | |||
+ | ==Algoritmy s textovými reťazcami== | ||
+ | |||
+ | Prácu s reťazcami si precvičíme na niekoľkých menších príkladoch. | ||
+ | |||
+ | ===Vyhľadávanie podreťazca=== | ||
+ | |||
+ | Chceme zistiť, či a kde sa v reťazci nachádza určité slovo alebo iná vzorka. | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | #include <cstring> | ||
+ | using namespace std; | ||
+ | |||
+ | int find(char text[], char pattern[]) { | ||
+ | /* Vráti -1 ak sa retazec pattern nevyskytuje v retazce text, | ||
+ | * inak vráti polohu jeho prvého výskytu. */ | ||
+ | |||
+ | int n = strlen(text); | ||
+ | int m = strlen(pattern); | ||
+ | for (int i = 0; i < n - m + 1; i++) { | ||
+ | int j = 0; | ||
+ | while (j < m && text[i + j] == pattern[j]) { | ||
+ | j++; | ||
+ | } | ||
+ | if (j == m) { | ||
+ | return i; | ||
+ | } | ||
+ | } | ||
+ | return -1; | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | const int maxN = 2000; | ||
+ | char A[maxN], B[maxN]; | ||
+ | |||
+ | cout << "Zadaj text: "; | ||
+ | cin.getline(A,maxN); | ||
+ | cout << "Zadaj vzorku: "; | ||
+ | cin.getline(B,maxN); | ||
+ | cout << find(A,B) << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Predpočítame si dĺžky a uložíme do premenných, aby sa zbytočne nerátali znova a znova | ||
+ | * Vedeli by sme do poľa uložiť polohy všetkých výskytov? | ||
+ | |||
+ | ===Prevod čísla na reťazec=== | ||
+ | |||
+ | Máme danú premennú x typu int, chceme ju uložiť v desiatkovej sústave do reťazca. | ||
+ | * Zvyšok po delení 10 je posledná cifra, uložíme si ju do reťazca, vydelíme x desiatimi | ||
+ | * Opakujeme, kým nespracujeme celé číslo. | ||
+ | * Prevod z čísla c (0..9) na cifru: '0'+c | ||
+ | * Nezabudneme na ukončovací znak 0 | ||
+ | * Dostaneme číslo v opačnom poradí, napr pre x=12 budeme mať reťazec {'2', '1', 0} | ||
+ | * Preto ešte celé číslo otočíme naopak. | ||
+ | |||
+ | <pre> | ||
+ | void reverse(char a[]) { | ||
+ | int n = strlen(a); | ||
+ | int i = 0; | ||
+ | int j = n - 1; | ||
+ | while (i < j) { | ||
+ | char tmp = a[i]; | ||
+ | a[i] = a[j]; | ||
+ | a[j] = tmp; | ||
+ | i++; j--; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void int2str(int x, char a[]) { | ||
+ | /* prevedie kladne cele cislo x na retazec, | ||
+ | * vysledok ulozi do retazca a, ktory musi mat dost miesta. */ | ||
+ | assert(x > 0); | ||
+ | |||
+ | int n = 0; | ||
+ | while(x > 0) { | ||
+ | a[n] = '0' + x % 10; | ||
+ | x /= 10; | ||
+ | n++; | ||
+ | } | ||
+ | a[n] = 0; | ||
+ | |||
+ | /* teraz je cislo naopak, treba otocit */ | ||
+ | reverse(a); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Ako upravíme funkciu, aby fungovala aj pre x=0, prípadne záporné x? | ||
+ | * Pozor na rozdiel medzi znakom 0 a '0' (a medzi reťazcom "0") | ||
+ | |||
+ | ===Formátovanie čísla=== | ||
+ | * Chceme číslo zapísať do reťazca a doplniť naľavo medzerami na šírku width. | ||
+ | |||
+ | <pre> | ||
+ | const int maxN = 100; | ||
+ | |||
+ | void formatInt(int x, char A[], int width) { | ||
+ | /* číslo x konvertujeme na reťazec | ||
+ | * a uložíme do poľa A zarované doprava na šírku width */ | ||
+ | |||
+ | /* najprv x uložíme do pomocného reťazca B a zrátame jeho dĺžku n */ | ||
+ | char B[maxN]; | ||
+ | int2str(x, B); | ||
+ | int n = strlen(B); | ||
+ | |||
+ | /* do A dáme n-width medzier a ukončovaciu 0 */ | ||
+ | assert(n <= width); | ||
+ | int i; | ||
+ | for (i = 0; i < width - n; i++) { | ||
+ | A[i] = ' '; | ||
+ | } | ||
+ | A[i] = 0; | ||
+ | |||
+ | /* za A prikopírujeme B */ | ||
+ | strcat(A, B); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Čo by sa stalo, ak by sme nedali do A ukončovaciu 0? | ||
+ | * Vedeli by sme prepísať program, aby pracoval priamo v poli A (bez poľa B)? | ||
+ | |||
+ | |||
+ | Využijeme na vypísanie pekne zarovnanej tabuľky faktoriálov: | ||
+ | <pre> | ||
+ | int factorial(int n) { | ||
+ | int result = 1; | ||
+ | for (int i = 1; i <= n; i++) { | ||
+ | result *= i; | ||
+ | } | ||
+ | return result; | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | char A[maxN]; | ||
+ | int n = 12; | ||
+ | for (int i = 1; i <= n; i++) { | ||
+ | int x = factorial(i); | ||
+ | formatInt(i, A, 2); | ||
+ | cout << A << "! = "; | ||
+ | formatInt(x, A, 10); | ||
+ | cout << A << endl; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | <pre> | ||
+ | 1! = 1 | ||
+ | 2! = 2 | ||
+ | 3! = 6 | ||
+ | 4! = 24 | ||
+ | 5! = 120 | ||
+ | 6! = 720 | ||
+ | 7! = 5040 | ||
+ | 8! = 40320 | ||
+ | 9! = 362880 | ||
+ | 10! = 3628800 | ||
+ | 11! = 39916800 | ||
+ | 12! = 479001600 | ||
+ | </pre> | ||
+ | |||
+ | Dalo by sa aj jednoduchšie pomocou nastavenia width v cin: | ||
+ | <pre> | ||
+ | int main(void) { | ||
+ | int n = 12; | ||
+ | for (int i = 1; i <= n; i++) { | ||
+ | int x = factorial(i); | ||
+ | cout.width(2); | ||
+ | cout << i << "! = "; | ||
+ | cout.width(10); | ||
+ | cout << x << endl; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Zalamovanie riadkov=== | ||
+ | |||
+ | * Máme reťazec s nejakým textom, v ktorom sa vyskytujú rôzne biele znaky, napríklad medzery a konce riadkov. Máme danú šírku riadku W, napr. 80 znakov. Úlohou je ho upraviť tak: | ||
+ | ** aby na každom riadku bolo najviac napr. W znakov, pričom nový riadok začína tam, kde by už ďalšie slovo presahovalo cez W | ||
+ | ** medzi dvoma slovami má byť vždy buď jedna medzera alebo jeden koniec riadku | ||
+ | ** predpokladáme, že žiadne slovo nemá viac ako W znakov | ||
+ | |||
+ | <pre> | ||
+ | Zadavaj text ukonceny prazdnym riadkom. | ||
+ | A AA A AAA | ||
+ | A A AA AAA | ||
+ | AAA A AA AA A | ||
+ | |||
+ | Zadaj sirku riadku: | ||
+ | 5 | ||
+ | Sformatovany odstavec: | ||
+ | A AA | ||
+ | A AAA | ||
+ | A A | ||
+ | AA | ||
+ | AAA | ||
+ | AAA A | ||
+ | AA AA | ||
+ | A | ||
+ | </pre> | ||
+ | |||
+ | <pre> | ||
+ | Zadavaj text ukonceny prazdnym riadkom. | ||
+ | Martin Kukucin: Do skoly. Vakacie sa koncia. Ondrej Rybar sa vse zamysli nad marnostou sveta i vsetkeho, co je v nom. | ||
+ | Predstupuje mu tu i tu pred oci profesor, ako stoji pred ciernou tabulou, drziac kruzidlo v ruke a demonstruje pamatnu poucku Pytagorovu. | ||
+ | A zimomriavky naskakuju na chrbat, lebo s geometriou stoji od pociatku na nohe valecnej. | ||
+ | Ani matematika nenie lepsia, menovite odvtedy, co sa do nej vplichtili miesto cisel vsakove litery. | ||
+ | Neraz hutal, naco ich ucenci vpustili do matematiky - ved i bez nich je dost strapata: ci sa im malilo cisel a tak preto vsantrocili medzi ne a a b a ci fantazia sa im tak rozihrala, | ||
+ | ze prekrocila hranice cisel celych, zlomkov obycajnych i desatinnych i bohvieakych, a zabludila na nivy, kde rastu nestastne litery? | ||
+ | ,Uz akokolvek,' huta Ondro, ,litery tam nemaju co hladat. Tazko je uverit, ze a/b = c, lebo nevies, co je a, alebo b.' | ||
+ | |||
+ | Zadaj sirku riadku: | ||
+ | 50 | ||
+ | Sformatovany odstavec: | ||
+ | Martin Kukucin: Do skoly. Vakacie sa koncia. | ||
+ | Ondrej Rybar sa vse zamysli nad marnostou sveta i | ||
+ | vsetkeho, co je v nom. Predstupuje mu tu i tu pred | ||
+ | oci profesor, ako stoji pred ciernou tabulou, | ||
+ | drziac kruzidlo v ruke a demonstruje pamatnu | ||
+ | poucku Pytagorovu. A zimomriavky naskakuju na | ||
+ | chrbat, lebo s geometriou stoji od pociatku na | ||
+ | nohe valecnej. Ani matematika nenie lepsia, | ||
+ | menovite odvtedy, co sa do nej vplichtili miesto | ||
+ | cisel vsakove litery. Neraz hutal, naco ich ucenci | ||
+ | vpustili do matematiky - ved i bez nich je dost | ||
+ | strapata: ci sa im malilo cisel a tak preto | ||
+ | vsantrocili medzi ne a a b a ci fantazia sa im tak | ||
+ | rozihrala, ze prekrocila hranice cisel celych, | ||
+ | zlomkov obycajnych i desatinnych i bohvieakych, a | ||
+ | zabludila na nivy, kde rastu nestastne litery? ,Uz | ||
+ | akokolvek,' huta Ondro, ,litery tam nemaju co | ||
+ | hladat. Tazko je uverit, ze a/b = c, lebo nevies, | ||
+ | co je a, alebo b.' | ||
+ | </pre> | ||
+ | |||
+ | Plán: úlohu si rozdelíme na viac častí | ||
+ | * Prerobíme reťazec tak, aby sme všetky biele znaky nahradili medzerami. Na rozpoznanie bielych znakov použijeme funkciu isspace z knižnice cctype. | ||
+ | * Každý súvislý úsek medzier nahradíme práve jednou medzerou, zmažeme medzery na začiatku a konci. | ||
+ | ** Podobá sa na príklad s vyhadzovaním núl z poľa z cvičení | ||
+ | ** Viac možnostá na riešenie, napríklad znaky presýpame do nového poľa. my ale použijeme len jedno pole | ||
+ | * Niektoré medzery nahradíme koncom riadku, aby každý riadok mal šírku najviac W | ||
+ | * Spravíme načítanie a vypísanie. | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | #include <cstring> | ||
+ | #include <cctype> | ||
+ | #include <cassert> | ||
+ | using namespace std; | ||
+ | |||
+ | void simplify(char A[]) { | ||
+ | /* V retazci A nahradi kazdy suvisly usek bielych znakov prave jednou medzerou. | ||
+ | * Na zaciatku a konci retazca nebudu medzery. */ | ||
+ | |||
+ | int i; | ||
+ | |||
+ | /* prepis hocijake biele znaky na medzeru */ | ||
+ | for (int i = 0; A[i] != 0; i++) { | ||
+ | if (isspace(A[i])) { | ||
+ | A[i] = ' '; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int kam = 0; /* prve este neobsadene miesto */ | ||
+ | char prev = ' '; /* predchadzajuci znak */ | ||
+ | |||
+ | for (int i = 0; A[i] != 0; i++) { | ||
+ | /* ak nemame viac medzier po sebe, skopirujeme znak */ | ||
+ | if (A[i] != ' ' || prev != ' ') { | ||
+ | A[kam] = A[i]; | ||
+ | kam++; | ||
+ | } | ||
+ | /* zapamatame si posledny znak */ | ||
+ | prev = A[i]; | ||
+ | } | ||
+ | |||
+ | /* zrusime pripadnu medzeru na konci */ | ||
+ | if (kam > 0 && A[kam - 1] == ' ') { | ||
+ | |||
+ | kam--; | ||
+ | } | ||
+ | |||
+ | /* retazec ukoncime nulou */ | ||
+ | A[kam] = 0; | ||
+ | } | ||
+ | |||
+ | bool breakLines(char A[], int width) { | ||
+ | /* Preformatuje odstavec na sirku riadku width, vyhodi zbytocne medzery. | ||
+ | * Dlzka kazdeho slova musi byt najviac width, inak funkcia vrati false */ | ||
+ | |||
+ | simplify(A); | ||
+ | int n = strlen(A); | ||
+ | |||
+ | int zac = 0; /* prve pismeno v riadku */ | ||
+ | while (zac < n) { | ||
+ | int kon = zac + width; /* potencialny koniec riadku */ | ||
+ | /* ak uz nemame dost pismen na cely riadok */ | ||
+ | if (kon > n) { | ||
+ | kon = n; | ||
+ | } | ||
+ | /* ak sme na konci, pridame koniec riadku za koniec retazca */ | ||
+ | if (kon == n) { | ||
+ | A[kon] = '\n'; | ||
+ | A[kon + 1] = 0; | ||
+ | n++; | ||
+ | } else { | ||
+ | /* ideme späť, kým nenájdeme medzeru */ | ||
+ | while (kon > zac && A[kon] != ' ') { | ||
+ | kon--; | ||
+ | } | ||
+ | /* nenašli sme medzeru: slovo bolo príliš dlhé. */ | ||
+ | if (kon == zac) { | ||
+ | return false; | ||
+ | } | ||
+ | /* medzeru prepíšeme na koniec riadku */ | ||
+ | assert(A[kon]==' '); | ||
+ | A[kon] = '\n'; | ||
+ | } | ||
+ | /* za koncom riadku bude novy zaciatok */ | ||
+ | zac = kon + 1; | ||
+ | } | ||
+ | return true; | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | const int maxN = 2000; | ||
+ | char A[maxN]; | ||
+ | |||
+ | cout << "Zadavaj text ukonceny prazdnym riadkom." << endl; | ||
+ | while (true) { | ||
+ | /* nacitame jeden riadok */ | ||
+ | char tmp[maxN]; | ||
+ | cin.getline(tmp, maxN); | ||
+ | /* ak je prazdny, koncime nacitavanie */ | ||
+ | if (strcmp(tmp, "") == 0) { | ||
+ | break; | ||
+ | } | ||
+ | /* ak je miesto v poli A, pridame do neho novy riadok */ | ||
+ | if (strlen(A) + strlen(tmp) + 2 < maxN) { | ||
+ | strcat(A, tmp); | ||
+ | strcat(A, "\n"); | ||
+ | } else { | ||
+ | cout << "Text je prilis dlhy." << endl; | ||
+ | return 1; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | cout << "Zadaj sirku riadku:" << endl; | ||
+ | int width; | ||
+ | cin >> width; | ||
+ | |||
+ | breakLines(A, width); | ||
+ | cout << "Sformatovany odstavec:" << endl; | ||
+ | cout << A; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Akú zložitosť má načítanie vzhľadom na celkový počet načítaných písmen? Dalo by sa zlepšiť? | ||
+ | |||
+ | ==Zhrnutie== | ||
+ | * Reťazec je pole znakov, za posledným znakom reťazca dáme špeciálny znak s kódom 0 | ||
+ | * V knižnici cstring sú funkcie na porovnávanie a kopírovanie reťazcov atď | ||
+ | * Ďalšie funkcie si vieme naprogramovať aj sami, zvyčajne jednoduchá práca s poľom | ||
+ | =Cvičenia 4= | ||
+ | == Manipulácia s poľom == | ||
+ | |||
+ | Napíšte funkciu, ktorá dostane pole intov ''a'' a jeho veľkosť ''n''. Funkcia v poli nájde všetky nuly a vyhodí ich, pričom po skončení je v premennej ''n'' nový počet prvkov. | ||
+ | * Viete spraviť funkciu tak, aby poradie nenulových prvkov zostalo to isté? T.j. z poľa {1,0,4,0,0,7} dostaneme {1,4,7} | ||
+ | |||
+ | == Triedenia == | ||
+ | * Bublinkové triedenie z [[#Prednáška_6|prednášky 6]] v prvej iterácii dostane najväčší prvok na svoje miesto, po druhej už sú dva najväčšie na svojom mieste atď. | ||
+ | ** Využite tento fakt na zrýchlenie: porovnávajte dvojice len po n-k kde k je číslo aktuálnej iterácie (program s triedeniami je [http://compbio.fmph.uniba.sk/vyuka/prog/data/programy/P6-triedenia.cpp tu]). | ||
+ | * Bublinkové triedenie sa dá zrýchliť ešte viac v prípade, ak si budeme pamätať posledné miesto, kde sa uskutočnila výmena. Od tohoto miesta ďalej už je pole usporiadané. | ||
+ | |||
+ | == Ladenie programu (debugovanie) == | ||
+ | Šejkrové triedenie je veľmi podobné bublinkovému. Na rozdiel od neho šejkrové po prejdení poľom jedným smerom až do konca nezačína znovu od začiatku, ale pokračuje opačným smerom od konca späť. Taktiež používa zrýchlenie spomenuté v predchádzajúcej úlohe k bublinkovému triedeniu. Šejkrové triedenie teda prechádza poľom stále tam a späť, pokiaľ sa usporiadaný začiatok nespojí s usporiadným koncom. | ||
+ | |||
+ | Nájdite všetky chyby v nasledujúcom programe. Doporučujeme najprv spraviť program skompilovateľný, potom si ho pozorne prečítať a odstrániť nezmysly a zvyšné chyby odladiť pomocou krokovania programu. | ||
+ | * [[#Shakersort pre cvičenia 4]] | ||
+ | |||
+ | == Triky s otáčaním poľa== | ||
+ | Máme dané pole intov a a počet jeho prvkov n. | ||
+ | * Otočte poradie prvkov v úseku poľa zadanom začiatkom a koncom. | ||
+ | * Posuňte pole cyklicky o 1 doprava, pričom posledný prvok sa dostane na prvé miesto. | ||
+ | * Posuňte pole cyklicky o k doprava. | ||
+ | ** Viete to spraviť tak, aby čas výpočtu nezávisel od k? Pomôcka: skúste využiť otáčanie. | ||
+ | |||
+ | |||
+ | |||
+ | == Polynómy == | ||
+ | |||
+ | * Na [[#Prednáška_6|prednáške 6]] sme mali [http://compbio.fmph.uniba.sk/vyuka/prog/data/programy/P6-polynomy.cpp program]], v ktorom polynóm reprezentujeme ako pole jeho koeficientov. Napíšte funkciu, ktorá vynásobí takéto polynómy. | ||
+ | * Vykreslite graf polynómu. | ||
+ | |||
+ | == Prvočísla == | ||
+ | * Použite Eratostenovo sito na nájdenie prvočísel z [[#Prednáška_5|prednášky 5]]. S pomocou týchto prvočísel napíšte program na rozklad čísla na súčin prvočíselných deliteľov. | ||
+ | |||
+ | ==Shakersort pre cvičenia 4== | ||
+ | <pre> | ||
+ | #include <ioscream> | ||
+ | #using namespace std; | ||
+ | |||
+ | void swap(int x, int y) { | ||
+ | /* Vymeň hodnoty premenných x a y. */ | ||
+ | int tmp = x; | ||
+ | x = y; | ||
+ | y = tmp; | ||
+ | } | ||
+ | |||
+ | void printArray(int a[], int n) { | ||
+ | /* Vypíš celé pole. */ | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | cout << " " << a[n]; | ||
+ | } | ||
+ | cout << endl; | ||
+ | } | ||
+ | |||
+ | void shakerSort(int a[], int n) { | ||
+ | /* Usporiadaj prvky v poli a od najmenšieho po najväčší. */ | ||
+ | /* Chodíme tam a späť, pričom vždy menej, | ||
+ | * lebo na koniec v každom prechode presunieme číslo, | ||
+ | * ktoré tam patrí. */ | ||
+ | |||
+ | int begin = 0; | ||
+ | int end = n; | ||
+ | int i; | ||
+ | while (begin<end) | ||
+ | { | ||
+ | /* spravíme prechod zľava doprava */ | ||
+ | for (i==begin; i<end; i++); | ||
+ | { | ||
+ | if (a[i]>=a[i+1]) swap(a[i], a[i+1]); | ||
+ | } | ||
+ | end--; | ||
+ | /* spravíme prechod sprava doľava */ | ||
+ | for (i==end; i>begin; i++); | ||
+ | { | ||
+ | if (a[i]>=a[i-1]) swap(a[i], a[i+1]); | ||
+ | } | ||
+ | begin--; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | int n = 6; | ||
+ | int a[6] = {9, 3, 7, 4, 5, 6}; | ||
+ | |||
+ | printArray(a, n); | ||
+ | sharkSort(a, n); | ||
+ | printArray(a, n); | ||
+ | } | ||
+ | </pre> | ||
+ | =DÚ3= | ||
+ | {{MDU|3|4210}} max. 15 bodov, termín odovzdania pondelok 15.10. o 22:00 | ||
+ | |||
+ | Cieľom tejto domácej úlohy je precvičiť si prácu s poliami a funkciami pri písaní o niečo dlhšieho programu. Budeme programovať hru [http://en.wikipedia.org/wiki/Mastermind_%28board_game%29 Logik]. V tejto hre máme hracie kamene ''F'' rôznych farieb. Prvý hráč (v našom prípade počítač) si zvolí ''N'' hracích kameňov a uloží ich do radu. Druhý hráč sa snaží túto postupnosť farieb uhádnuť. V každom kole si druhý hráč tiež zvolí ''N'' kameňov a zoradí ich. Prvý hráč mu povie, ako blízko je k správnej odpovedi pomocou bielych a čiernych bodov nasledujúcim spôsobom: | ||
+ | |||
+ | * Za každú pozíciu, na ktorej sa správna opoveď a najnovší pokus nelíšia, dostane čierny bod. | ||
+ | |||
+ | * Celkový počet bodov (bielych a čiernych spolu) zodpovedá tomu, koľko najviac čiernych bodov by sa dalo získať preusporiadaním kameňov v pokuse. | ||
+ | |||
+ | Ak sa teda v pokuse žiadna farba neopakuje, biele body zodpovedajú farbám, ktoré sú aj v správnej odpovedi, ale na inom mieste ako v pokuse. Ak sa farby v pokuse opakujú, musíme vziať do úvahy aj ich počty. Napríklad ak pokus obsahuje tri červené kamene a správna odpoveď iba dva červené kamene, hráč dostane iba dva biele (príp. čierne) body. | ||
+ | |||
+ | Hra sa končí, keď druhý hráč dostane ''N'' čiernych bodov, teda správne uhádol poradie farieb v správnej odpovedi. | ||
+ | |||
+ | V našej verzii budeme farby reprezentovať číslami 0,1,...,''F''-1. Biele body sa budú zapisovať ako malé x a veľké body ako veľké X. Vždy sa vypíšu najskôr všetky biele a potom všetky čierne body. Tu je príklad priebehu hry pre ''N''=3, ''F''=5 a správnu odpoveď 2,4,4. | ||
+ | |||
+ | <pre> | ||
+ | Zadaj 3 cisel(cisla) od 0 po 4: 0 1 2 | ||
+ | Hodnotenie: x | ||
+ | |||
+ | Zadaj 3 cisel(cisla) od 0 po 4: 0 3 4 | ||
+ | Hodnotenie: X | ||
+ | |||
+ | Zadaj 3 cisel(cisla) od 0 po 4: 1 4 3 | ||
+ | Hodnotenie: X | ||
+ | |||
+ | Zadaj 3 cisel(cisla) od 0 po 4: 3 2 4 | ||
+ | Hodnotenie: xX | ||
+ | |||
+ | Zadaj 3 cisel(cisla) od 0 po 4: 3 2 2 | ||
+ | Hodnotenie: x | ||
+ | |||
+ | Zadaj 3 cisel(cisla) od 0 po 4: 2 4 4 | ||
+ | Hodnotenie: XXX | ||
+ | |||
+ | Uhadli ste! | ||
+ | </pre> | ||
+ | |||
+ | Napíšte program, ktorý vygeneruje správnu odpoveď generátorom pseudonáhodných čísel a potom si opakovane od hráča vypýta jeho tip a spočíta mu body. Hra sa končí, keď hráč uhádne správnu odpoveď. Môžete predpokladať, že hráč zadáva korektné hodnoty (čísla od 0 do ''F''-1). | ||
+ | |||
+ | Najzložitejšou časťou je spočítanie počtu bielych bodov. Ten môžete získať z celkového počtu bodov odčítaním čiernych bodov. Na spočítanie celkového počtu bodov doporučujeme vytvoriť pomocné pole dĺžky ''F'', ktoré v políčku ''i'' bude mať počet výskytov čísla ''i'' v správnej odpovedi a druhé pole takého istého tvaru pre aktuálny pokus. Potom viete ľahko spracovať prípad typu, že v pokuse sú dva červené a v správnej odpovedi tri červené kamene. | ||
+ | |||
+ | Nižšie prikladáme kostru programu, ktorá celý problém rozkladá na menšie časti implementované v jednotlivých funkciách. Doporučujeme Vám postupovať podľa tohto návodu, nie je to však nevyhnutné. Vaše riešenie by však malo spĺňať nasledovné požiadavky: | ||
+ | |||
+ | * Váš program správne funguje a správa sa analogicky k vyššie uvedenému priebehu hry. | ||
+ | * Hodnoty ''N'' a ''F'' máte zadefinované ako konštanty, ktoré stačí zmeniť na jednom mieste v programe. | ||
+ | * Používate len príkazy, ktoré sme preberali na prednáške. | ||
+ | * Program je rozdelený na niekoľko funkcií s dobre logicky definovanými úlohami. Mená funkcií zodpovedajú tomu, čo tie funkcie robia a na začiatku každej funkcie v komentári podrobnejšie vysvetlíte jej účel. | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | #include <cstdlib> | ||
+ | #include <ctime> | ||
+ | using namespace std; | ||
+ | |||
+ | /* globalne konstanty: | ||
+ | * F je pocet vsetkych moznych farieb | ||
+ | * (farby budu od 0 po F-1 vratane) | ||
+ | * N je pocet hadanych farieb | ||
+ | */ | ||
+ | const int F = 5; | ||
+ | const int N = 3; | ||
+ | |||
+ | void nacitaj(int a[]) { | ||
+ | /* Do pola a od uzivatela nacita N cisel od 0 po F-1 */ | ||
+ | |||
+ | } | ||
+ | |||
+ | void generuj(int a[]) { | ||
+ | /* Do pola a vygeneruje N nahodnych cisel od 0 po F-1 */ | ||
+ | |||
+ | } | ||
+ | |||
+ | int cierne(int a[], int b[]) { | ||
+ | /* V poli a je spravne riesenie, v poli b je pokus. | ||
+ | * Obidve polia obsahuju N cisel od 0 po F-1. | ||
+ | * Funkcia vrati pocet ciernych bodov, | ||
+ | * ktore ma uzivatel dostat. */ | ||
+ | |||
+ | } | ||
+ | |||
+ | void pocty(int a[], int p[]) { | ||
+ | /* V poli a je riesenie (N cisel od 0 po F-1). | ||
+ | * Do pola p spocitame pocty vyskytov | ||
+ | * jednotlivych cisel, t.j. pre 0<=i<F | ||
+ | * p[i] bude pocet vskytov cisla i v poli a | ||
+ | */ | ||
+ | |||
+ | } | ||
+ | |||
+ | int vsetky(int a[], int b[]) { | ||
+ | /* V poli a je spravne riesenie, v poli b je pokus. | ||
+ | * Obidve polia obsahuju N cisel od 0 po F-1. | ||
+ | * Funkcia vrati pocet vsetkych bodov, | ||
+ | * ktore ma uzivatel dostat. */ | ||
+ | |||
+ | } | ||
+ | |||
+ | void vypis(int vsetky, int cierne) { | ||
+ | /* Dany je pocet vsetkych bodov a kolko | ||
+ | * z nich maju byt cierne (zvysne su biele). | ||
+ | * Pre kazdy biely bod vypise x | ||
+ | * a pre kazdy cierny X. */ | ||
+ | |||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | /* pole so spravnou odpovedou a pokusom */ | ||
+ | int spravne[N]; | ||
+ | int pokus[N]; | ||
+ | |||
+ | /* generovanie spravnej odpovede */ | ||
+ | srand(time(NULL)); | ||
+ | generuj(spravne); | ||
+ | |||
+ | /* samotna hra */ | ||
+ | while(true) { | ||
+ | nacitaj(pokus); | ||
+ | int v = vsetky(spravne, pokus); | ||
+ | int c = cierne(spravne, pokus); | ||
+ | vypis(v, c); | ||
+ | if(c==N) { | ||
+ | cout << "Uhadli ste!" << endl; | ||
+ | break; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | =Prednáška 9= | ||
+ | == Bežné úvodné príklady na rekurziu == | ||
+ | |||
+ | Vysvetlenie pojmu rekurzia sa dá zhrnúť do jednej vety: Rekurzia je metóda, pri ktorej definujeme objekt (funkciu, pojem, . . . ) pomocou jeho samého. | ||
+ | |||
+ | Na začiatok sa skúsme pozrieť na „klasické“ príklady algoritmov využívajúcich rekurziu. Prvým, azda najklasickejším príkladom je faktoriál. Ten pre prirodzené (0, 1, 2, . . .) číslo n vráti 1 | ||
+ | pokiaľ n = 0 a súčin všetkých čísel od 1 po n inak. | ||
+ | |||
+ | <pre> | ||
+ | int factorial(int n){ | ||
+ | if (n<2) return 1; | ||
+ | else return n*factorial(n-1); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Výpočet faktorilu je založený na jeho rekurzívnej definícii. Pri prepisovaní rekurzívnych definícii (a všeobecne pri používaní rekurzie) je potrebné dodržiavať nasledujúce zásady, aby sme sa vyhli chybám: | ||
+ | * Príkazová časť rekurzívnej procedúry (funkcie) musí obsahovať vetvu pre triviálny prípad niektorého základného parametra alebo vstupnej hodnoty. Táto vetva nebude obsahovať (rekurzívne) volanie procedúry (funkcie), ktorú práve definujeme. | ||
+ | * Ľubovoľné volanie procedúry (funkcie) vo vnútri jej príkazovej časti musí mať vhodne redukovaný argument (alebo globálnu hodnotu). Pri tejto redukcii sa očakáva, že raz dosiahne triviálny prípad po konečnom počte opakovaní. | ||
+ | |||
+ | Ďalším tradičným príkladom na rekurziu s ktorým ste sa už stretli je počítanie najväčšieho spoločného deliteľa. Opäť dostvame jednoduchú rekurzívnu funkciu. Budeme si jej parametre udržovať usporiadané, tj. prvý parameter je vždy väčší ako druhý (ak by to tak nebolo, vieme jednuduchým testom na začiatku upraviť). | ||
+ | |||
+ | * Triviálny prípad nastáva, keď druhý parameter je 0. Potom je výsledkom prvý parameter. | ||
+ | * V opačnom prípade je NSD(a,b) = NSD(a mod b, b) - tu však vidíme, že <math>a mod b < b</math> a preto zavoláme NSD(b,a mod b) | ||
+ | |||
+ | <pre> | ||
+ | int nsd(int a, int b){ | ||
+ | if (b == 0) return a; | ||
+ | else return nsd(b,a%b); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | A nemôžeme vynechať obľúbený rekurzívny príklad - Fibonacciho čísla. Tam sa rekurzia priam pýta, keďže Fibonacciho čísla sú samé o sebe definované rekurzívne. | ||
+ | |||
+ | * F(0)=F(1)=1 | ||
+ | * F(n)=F(n-1)+F(n-2) pre n>2 | ||
+ | |||
+ | Z tejto definície vieme opäť urobiť rekurzívny príklad jednoducho: | ||
+ | |||
+ | <pre> | ||
+ | int fib(int n){ | ||
+ | if (n<2) return 1; | ||
+ | else return fib(n-1)+fib(n-2); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Nepriama rekurzia === | ||
+ | |||
+ | Všetky doteraz uvedené funkcie sú príkladom priamej rekurzie – definovaná funkcia používa | ||
+ | seba samú priamo. Druhým možným prípadom je nepriama rekurzia (alebo tiež vzájomná), kedy | ||
+ | funkcia neodkazuje vo svojej definícii priamo na seba, ale využíva inú funkciu, ktorá sa odkazuje | ||
+ | naspäť na prvú (všeobecnejšie sa kruh môže uzavrieť na krokov viac). | ||
+ | Ako príklad uveďme rekurzívne definície predikátov párnosti a nepárnosti | ||
+ | |||
+ | <pre> | ||
+ | bool even(int n) { | ||
+ | if (n == 0) return true; | ||
+ | else return odd(n - 1); | ||
+ | } | ||
+ | |||
+ | bool odd(int n) { | ||
+ | if (n == 0) return false; | ||
+ | else return even(n - 1); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Binárne vyhľadávanie === | ||
+ | |||
+ | Binárne vyhľadávanie sme už mali skôr, avšak rekurzia značne zjednoduší a zprehľadní túto funkciu. | ||
+ | Na rozdiel od pôvodnej verzie si nepotrebujeme pamätať okraje aktuálneho miesta - pamätá si ich za nás rekurzia (ako svoj parameter). | ||
+ | |||
+ | Ako funguje: | ||
+ | * V prípade, že už máme jednoprvkové pole dostávame triviálny prípad. | ||
+ | * Ak máme viac prvkov, tak sa rekurzívne zavoláme na pravú alebo ľavú stranu podľa vzťahu hodnoty x a stredného prvku. | ||
+ | |||
+ | <pre> | ||
+ | bool binSearch(int x, int l, int r, int A[]){ | ||
+ | if (l==r) return (A[l]==x); | ||
+ | if (x<=A[(l+r)/2]) return binSearch(x,l,(l+r)/2,A); | ||
+ | else return binSearch(x,(l+r)/2+1,r,A); | ||
+ | } | ||
+ | |||
+ | int main(void){ | ||
+ | int A[9]={1,5,7,12,45,79,100,123,467}; | ||
+ | cout << binSearch(7,0,8,A); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | == Rekurzia == | ||
+ | |||
+ | Predchádzajúce príklady boli príkladmi použitia rekurzie pri definícii jednoduchých funkcií. Samozrejme, funkcie, ktoré by počítali to isté, by sa dali naprogramovať aj bez pomoci rekurzie. Ale pravdepodobne vidíte, že rekurzívny spôsob je prehľadnejší, zrozumiteľnejší, kratší a krajší (teda aspoň v prvých príkladoch určite). | ||
+ | |||
+ | Načo to vôbec robíme, veď všetko toto sme už robili aj pred tým a nebolo to nič náročné (prečo vôbec riešiť niečo ako rekurzia)? | ||
+ | Asi hlavný dôvod je, že nie všetko vieme prepísať bez rekurzie. Príklady, ktoré sme ukázali boli teda istým spôsobom ľahké - pomocou rekurzie vieme urobiť oveľa viac. | ||
+ | |||
+ | === Vyhodnocovanie výrazu === | ||
+ | |||
+ | Máme zadaný reťazec, v ktorom je výraz obsahujúci celé čísla, znamienka '+', '-' a zátvorky. | ||
+ | Pre jednoduchosť predpokladajme, že zátvorky sú všade (t.j. každý výraz je tvaru <tt>(Výraz Operátor Výraz)</tt> alebo <tt>Číslo</tt>)a celý výraz je správne uzátvorkovaný. | ||
+ | |||
+ | Príklady výrazov: | ||
+ | * 99 | ||
+ | * (12+13) | ||
+ | * (((12-5)+7)-(6+8)) | ||
+ | |||
+ | Na vyhodnotenie výrazu môžeme použiť nasledovný postup: | ||
+ | * Nájdeme si znamienko Z také, že výraz je tvaru ((Výraz1)Z(Výraz2)) | ||
+ | * Zistíme, akú hodnotu majú Výraz1 a Výraz2 | ||
+ | * Hodnota celého výrazu sa dá vypočítať pomocou týchto hodnôt a znamienka Z | ||
+ | |||
+ | Čo nutne ešte potrebujeme je nájsť správne znamienko Z. | ||
+ | |||
+ | <pre> | ||
+ | int najdiZnamienko(char str[]){ | ||
+ | /*Vieme, ze vyraz je tvaru (Vyraz1 Z Vyraz2)*/ | ||
+ | int poc=0; | ||
+ | for (int i=1; i<strlen(str)-1; i++){ | ||
+ | if (str[i]=='(') poc++; | ||
+ | else if (str[i]==')') poc--; | ||
+ | else if (((str[i]=='+')||(str[i]=='-'))&&(poc==0)) return i; | ||
+ | } | ||
+ | return -1; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Ďalej je dobre sa zamyslieť, kedy s vyhodnocovaním skončíme. Bude to v prípade, že už očakvame, že máme výraz iba celé číslo - na začiatku nie je zátvorka. | ||
+ | |||
+ | Potom vyhodnocovanie výrazu može pracovať nasledovne: | ||
+ | <pre> | ||
+ | int vyhodnotVyraz(char str[]){ | ||
+ | if (str[0]!='(') return vyhodnotCislo(str); | ||
+ | else { | ||
+ | char s[100]; | ||
+ | int poz, hodnota1, hodnota2; | ||
+ | |||
+ | poz=najdiZnamienko(str); | ||
+ | |||
+ | strCopy(str,s,1,poz-1); // od 1 po pozíciu pred znamienkom (pozícia 0 je '(' ) | ||
+ | hodnota1=vyhodnotVyraz(s); | ||
+ | strCopy(str,s,poz+1,strlen(str)-2); // od pozície po znamienku po predposledný znak stringu (posledný znak - strlen()-1 je ')' ) | ||
+ | hodnota2=vyhodnotVyraz(s); | ||
+ | |||
+ | switch (str[poz]){ | ||
+ | case '+': return hodnota1+hodnota2; | ||
+ | case '-': return hodnota1-hodnota2; | ||
+ | } | ||
+ | |||
+ | return 0; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Fraktály === | ||
+ | |||
+ | [[Image:PROG-P14-koch.png|thumb|right|Kochova krivka stupňa 3]] | ||
+ | Príkladom fraktálu je Kochova krivka. Ako vzniká? | ||
+ | * Predstavme si úsečku, ktorá meria d centimetrov. | ||
+ | * Ďalej potrebujeme transformáciu, teda konkrétne presne definovaný súbor opakovateľných pravidiel: Úsečka sa rozdelí na tretiny a nad strednou tretinou sa zostrojí rovnostranný trojuholník. Základňa trojuholníka v krivke nebude. Opakovaní môžeme robiť nekonečno. | ||
+ | * Druhá možnosť je popísať krivku pomocou systému, ktorého vykonávanie sa podobá príkazom korytnačky. | ||
+ | ** Základným krokom je F (forward) vytvorenie rovnej čiary určitej dĺžky | ||
+ | ** Okrem toho poznáme príkazy + a - (turn left a turn right o určitý uhol - v našom prípade 60 stupňov) | ||
+ | ** Krivku môžeme popísať pomocou nasledovného pravidla <tt> F → F+F--F+F </tt>, ktoré kreslí z pôvodnej krivky komplikovanejšiu krivku. | ||
+ | ** Takže namiesto F (rovnej čiary určitej dĺžky) môžeme nakresliť rovnú čiaru, otočiť sa doľava, nakresliť rovnú čiaru, dva krát sa otočiť doprava, nakresliť čiaru, otočiť sa doľava a nakresliť čiaru. | ||
+ | ** Následne s '''každou''' čiarou môžeme opäť urobiť transformáciu a dostať zložitejšiu krivku. | ||
+ | ** Drobný problém, ktorý musíme vyriešiť je, že týmto spôsobom (ak by sme robili vždy čiary veľkosti d) by nám obrázok príliš rástol. My však chceme ostať v pôvodnej veľkosti preto pri každej transformácii zmenšíme dĺžku čiary na 1/3. | ||
+ | |||
+ | |||
+ | Z toho potom dostávame nasledovný program: | ||
+ | <pre> | ||
+ | #include "../SimpleDraw.h" | ||
+ | |||
+ | void drawKoch(double d, int n, Turtle& turtle){ | ||
+ | if (n==0) turtle.forward(d); | ||
+ | else { | ||
+ | drawKoch(d/3, n-1, turtle); | ||
+ | turtle.turnLeft(60); | ||
+ | drawKoch(d/3, n-1, turtle); | ||
+ | turtle.turnLeft(-120); | ||
+ | drawKoch(d/3, n-1, turtle); | ||
+ | turtle.turnLeft(60); | ||
+ | drawKoch(d/3, n-1, turtle); | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | int width = 310; /* rozmery obrazku */ | ||
+ | int height = 150; | ||
+ | |||
+ | double d = 300; /* velkost krivky */ | ||
+ | int n = 3; /* stupen krivky */ | ||
+ | double wait = 0.2; /* kolko korytnacka caka */ | ||
+ | |||
+ | /* Vytvor obrázok */ | ||
+ | SimpleDraw window(width, height); | ||
+ | |||
+ | /* Vytvor korytnačku otočenú doprava. */ | ||
+ | Turtle turtle(window, 1, height - 10, 0); | ||
+ | /* Zobraz korytnačku ako šípku. */ | ||
+ | turtle.show(); | ||
+ | /* Korytnačka bude čakať po každom ťahu. */ | ||
+ | turtle.setWait(wait); | ||
+ | |||
+ | /* nakresli Kochovu krivku rekurzívne */ | ||
+ | drawKoch(d, n, turtle); | ||
+ | |||
+ | /* Schovaj korytnačku. */ | ||
+ | turtle.hide(); | ||
+ | /* Zobraz na obrazovke a čakaj, kým užívateľ stlačí Exit, | ||
+ | potom zavri okno. */ | ||
+ | window.showAndClose(); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Hanojské veže === | ||
+ | |||
+ | * Problém hanojských veží pozostáva z troch stĺpcov (tyčiek) a niekoľkých kruhov rôznej veľkosti. Začína sa postavením pyramídy z kruhov (kameňov) na prvú tyčku. | ||
+ | * Úlohou je potom presunúť celú pyramídu na inú tyčku, avšak pri dodržaní nasledovných pravidiel: | ||
+ | ** v jednom ťahu (na jedenkrát) je možné premiestniť iba jeden hrací kameň | ||
+ | ** väčší kameň nesmie byť nikdy položený na menší | ||
+ | |||
+ | |||
+ | Ako budeme úlohu riešiť? Asi rekurzívne, nie? | ||
+ | * V prípade, že máme iba jeden kameň je úloha veľmi jednoduchá - preložíme ho z pôvodného stĺpika na cieľový stĺpik. | ||
+ | * Ak chceme preložiť viac kameňov (nech ich je N), tak | ||
+ | ** Všetky okrem posledného preložíme na pomocný stĺpik (na to použijeme taký istý postup len s N-1 kameňmi) | ||
+ | ** Premiestnime jeden kameň kam potrebujeme | ||
+ | ** Zatiaľ odložené kamene (na pomocnom stĺpiku) preložíme z pomocného na cieľový stĺpik (na to použijeme opäť taký istý postup s N-1 kameňmi) | ||
+ | |||
+ | Aby sme to popísali konkrétnejšie - preloženie N kameňov z A na C (s pomocným stĺpikom B) urobíme takto: | ||
+ | * Preložíme N-1 kameňov z A na B (s použitím C) | ||
+ | * Preložíme 1 kameň z A na C (s použitím B - ale reálne to potrebovať nebudeme) | ||
+ | * Preložíme N-1 kameňov z B na C (s použitím A) | ||
+ | |||
+ | Dôležité je si uvedomiť, že nasledovný postup dodržuje pravidlá. | ||
+ | |||
+ | <pre> | ||
+ | void presunHanoi(int odkial, int cez, int kam, int n){ | ||
+ | if (n == 1) { | ||
+ | cout << "Prelozim kamen z " << odkial <<" na " << kam << endl; | ||
+ | } else { | ||
+ | presunHanoi(odkial, kam, cez, n-1); // odlozime si n-1 na pomocny-cez | ||
+ | presunHanoi(odkial, cez, kam, 1); // prelozime najvacsi na finalne miesto | ||
+ | presunHanoi(cez, odkial, kam, n-1); // zvysnych n-1 prelozime z docasneho odkladiska na finalne | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int main (void){ | ||
+ | presunHanoi(1, 2, 3, 3); // z veze 1 na vezu 3 (pomocou veze 2) | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | == Rekurzia pomocou stacku - ako to funguje == | ||
+ | |||
+ | O rekurzívne volania sa stará zásobník. Ako funguje? | ||
+ | * Pri vnáraní sa do rekruzívnej funkcie (keď volá funkcia sama seba) si potrebuje zapamätať stav v akom sa nachádza, aby sa pri vynorení vedel dostať do pôvodného stavu. Všetky informácie popisujúce stav si zapíše do zásobníka a až potom sa rekurzívne zavolá. | ||
+ | * Pri vynorení musí zo zásobníka vybrať v prvom rade miesto, kde v rekurzívnej funkcii pokračovať a ďalej všetky premenné. | ||
+ | |||
+ | Čo si teda musel zásobník pamätať? | ||
+ | * adresu návratu - teda miesto kde v rekurzívnej funkcii sa nachádza: dôležité je to hlavne v situácii, keď máme viacero rekurzívnych volaní (či už podľa podmienky alebo sa voláme vždy viac krát) | ||
+ | * lokálne premenné - hodnoty (a spôsob ako sa k nim dostať - v realite totiž zásobník funguje kúsok komplikovanejšie) | ||
+ | |||
+ | Keď už vieme, že o rekurzívne volania sa stará zásobník, možeme si taký jednoduchý zásobník osimulovať napríklad na výpočte faktoriálu. | ||
+ | |||
+ | <pre> | ||
+ | int fact(int n){ | ||
+ | if (n<2) return 1; | ||
+ | else return n*fact(n-1); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | == Chvostová rekurzia == | ||
+ | |||
+ | Dôvod, prečo sme tieto príklady vedeli napísať už pred tým, ako sme sa dozvedeli niečo o rekurzii je to, že voláme rekurziu z každého volania iba raz. Napríklad na výpočet faktoriálu daného čísla potrebujeme jedenkrát rekurzívne zavolať faktoriál predchádzajúceho čísla. | ||
+ | Navyše sa rekurzívne volanie nachádza iba ako posledný krok (niektorých vetiev) výpočtu funkcie. Dobrý kompilátor dokáže z takejto rekurzívnej funkcie vytvoriť nerekurzívnu. | ||
+ | |||
+ | A Fibonacci, ten sa predsa volá dve krát? Áno, ale iba ak je program napísaný neefektívne. Ak napíšeme program podľa uvedeného predpisu a pokúsime sa funkciu volať s rôznymi parametrami, tak čoskoro zistíme, že takto definovaná funkcia počíta celkom pomaly. Prečo? Jednotlivé hodnoty Fibonacciho čísel počítame totiž viackrát (čím menšie číslo, tým viackrát je spočítané). | ||
+ | To sa dá napraviť celkom jednoducho použitím takzvaného akumulátora. Akumulátor je dodatočný parameter, v ktorom si predávame stav výpočtu. Konkrétne pri efektívnejšom počítaní Fibonacciho čísel zdola nahor si v akumulátore budeme odkladať posledné dve napočítané čísla. V podstate takto budeme napodobňovať to, ako by ste si napočítali konkrétne Fibonacciho číslo v hlave. Začnete od dvoch jednotiek a postupne si dopočítate ďalšie až po číslo, ktoré ste potrebovali. | ||
+ | |||
+ | <pre> | ||
+ | int fib1(int a, int b, int n) { | ||
+ | if (n == 0) return a; | ||
+ | else return fib1(b,a+b,n-1); | ||
+ | } | ||
+ | |||
+ | int fib(int n){ | ||
+ | fib1(1,1,n); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | V parametroch a a b si pamätáme dve susedné čísla a v parametri n si pamätáme, koľko rekurzívnych volaní ešte chceme urobiť. Takže takto naprogramovaná Fibonacciho funkcia je nielen rýchla, ale aj kopíruje spôsob nášho uvažovania, a preto je zrozumiteľnejšia. Navyše používa iba jedno rekurzívne volanie. | ||
+ | =Prednáška 10= | ||
+ | ==Opakovanie rekurzie== | ||
+ | [[Image:PROG-P14-koch.png|thumb|right|Kochova krivka stupňa 3]] | ||
+ | * '''Rekurentná definícia''': určitý objekt definujeme pomocou menších objektov toho istého typu | ||
+ | ** Napr. Fibonacciho čísla ''F(n) = F(n-1) + F(n-2)'' | ||
+ | ** Napr. fraktál stupňa ''n'' ako kompozícia fraktálov stupňa ''n-1'' | ||
+ | ** Nezabudnime na triviálne prípady, napr. ''F(0)=F(1)=1'', fraktál stupňa 0 | ||
+ | |||
+ | * Rekurentné definície vieme často priamočiaro zapísať do '''rekurzívnych funkcií''' (aj keď môžu byť pomalé) | ||
+ | <pre> | ||
+ | int fib(int n) { | ||
+ | if (n<2) return 1; | ||
+ | else return fib(n-1) + fib(n-2); | ||
+ | } | ||
+ | </pre> | ||
+ | * V rekurzívnej funkcii riešime problém pomocou menších podproblémov toho istého typu | ||
+ | ** Napríklad aby sme našli číslo ''x'' v utriedenom poli medzi indexami ''l'' a ''r'', potrebujeme ho porovnať so stredným prvkom tohoto intervalu a potom riešiť tú istú úlohu pre menší interval | ||
+ | ** Aj keď sme pôvodne chceli hľadať prvok v celom poli, úlohu rozšírime o parametre ''l'' a ''r'', aby sa dala spraviť rekurzia | ||
+ | <pre> | ||
+ | bool binSearch(int x, int l, int r, int A[]){ | ||
+ | if (l==r) return (A[l]==x); | ||
+ | if (x<=A[(l+r)/2]) return binSearch(x,l,(l+r)/2,A); | ||
+ | else return binSearch(x,(l+r)/2+1,r,A); | ||
+ | } | ||
+ | </pre> | ||
+ | * Druhý pohľad na rekurziu je dynamický: môžeme simulovať, čo sa v programe deje so '''zásobníkom''' | ||
+ | ** Na zásobníku ukladáme parametre, lokálne premenné, kde v kóde sme skončili | ||
+ | ** Skúsme napríklad odsimulovať, čo sa deje ak vo funkcii <tt>main</tt> zavoláme <tt>fib(3)</tt> | ||
+ | ** Kvôli prehľadnosti si <tt>fib</tt> rozpíšeme na viac riadkov: | ||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | int fib(int n) { | ||
+ | if (n < 2) return 1; | ||
+ | else { | ||
+ | int a = fib(n - 1); // riadok (A) | ||
+ | int b = fib(n - 2); // riadok (B) | ||
+ | return a+b; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | int x = fib(3); // riadok (C) | ||
+ | cout << x << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Tu je priebeh programu (obsah zásobníka) | ||
+ | <pre> | ||
+ | (1) (2) (3) | ||
+ | |||
+ | fib n=2 | ||
+ | fib n=3 fib n=3, a=?, b=?, riadok A | ||
+ | main, x=? main, x=?, riadok C main, x=?, riadok C | ||
+ | |||
+ | (4) (5) | ||
+ | |||
+ | fib n=1 | ||
+ | fib n=2, a=?, b=?, riadok A fib n=2, a=1, b=?, riadok A | ||
+ | fib n=3, a=?, b=?, riadok A fib n=3, a=?, b=?, riadok A | ||
+ | main, x=?, riadok C main, x=?, riadok C | ||
+ | |||
+ | |||
+ | (6) (7) | ||
+ | |||
+ | fib n=0 | ||
+ | fib n=2, a=1, b=?, riadok B fib n=2, a=1, b=1, riadok B | ||
+ | fib n=3, a=?, b=?, riadok A fib n=3, a=?, b=?, riadok A | ||
+ | main, x=?, riadok C main, x=?, riadok C | ||
+ | |||
+ | |||
+ | (8) (9) | ||
+ | |||
+ | fib n=1 | ||
+ | fib n=3, a=2, b=?, riadok A fib n=3, a=2, b=?, riadok B | ||
+ | main, x=?, riadok C main, x=?, riadok C | ||
+ | |||
+ | |||
+ | (10) (11) | ||
+ | |||
+ | fib n=3, a=2, b=1, riadok B | ||
+ | main, x=?, riadok C main, x=3, riadok C | ||
+ | </pre> | ||
+ | |||
+ | ===Efektívnejší výpočet Fibonacciho čísel=== | ||
+ | Priamočiary rekurzívny zápis výpočtu Fibonacciho čísel je neefektívny, lebo výpočet Fibonacciho čísel sa opakuje | ||
+ | * Napr. pre ''n=4'' počítame <tt>fib(2)</tt> dvakrát, pre ''n=6'' päťkrát a pre ''n=20'' až 4181-krát | ||
+ | |||
+ | Spomeňme si na zápis výpočtu bez rekurzie, s dvomi premennými: | ||
+ | * F(n) spočíta v čase O(n) | ||
+ | <pre> | ||
+ | int fibonacci(int n) { | ||
+ | |||
+ | int f = 1; // Cislo F(i) | ||
+ | int oldF = 0; // Cislo F(i-1) | ||
+ | |||
+ | for (int i = 2; i <= n; i++) { | ||
+ | int newF = f + oldF; // spocitaj nove F(i) pre vyssie i | ||
+ | oldF = f; // poposuvaj hodnoty | ||
+ | f = newF; | ||
+ | } | ||
+ | |||
+ | return f; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Prepíšeme ho na rekurziu: | ||
+ | <pre> | ||
+ | int fib1(int a, int b, int i, int n) { | ||
+ | /* a je F(i-1), b je F(i), spočítaj F(n), kde n>=i */ | ||
+ | if (n == i) return b; | ||
+ | else return fib1(b, a+b, i+1, n); | ||
+ | } | ||
+ | |||
+ | int fib(int n){ | ||
+ | return fib1(1, 1, 1, n); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Namiesto dvoch premenných ''i'' a ''n'' si môžeme pamätať len ich rozdiel ''k=n-i'' | ||
+ | * hodnota ''k'' nám vraví, koľkokrát máme ešte sčitovať dve posledné čísla | ||
+ | <pre> | ||
+ | int fib1(int a, int b, int k) { | ||
+ | /* a je F(i-1), b je F(i), spočítaj F(i+k) */ | ||
+ | if (k == 0) return b; | ||
+ | else return fib1(b,a+b,k-1); | ||
+ | } | ||
+ | |||
+ | int fib(int n){ | ||
+ | fib1(1,1,n-1); | ||
+ | } | ||
+ | </pre> | ||
+ | Táto rekurzívna funkcia pracuje v čase ''O(n)'', rovnako ako verzia s cyklom. | ||
+ | |||
+ | ==Vypisovanie variácií s opakovaním== | ||
+ | Vypíšte všetky trojice cifier, pričom každá cifra je z množiny {0..n-1} a cifry sa môžu opakovať (variácie 3-tej triedy z n prvkov). Napr. pre n=2: | ||
+ | <pre> | ||
+ | 000 | ||
+ | 001 | ||
+ | 010 | ||
+ | 011 | ||
+ | 100 | ||
+ | 101 | ||
+ | 110 | ||
+ | 111 | ||
+ | </pre> | ||
+ | |||
+ | Veľmi jednoduchý program s troma cyklami: | ||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | int n; | ||
+ | cin >> n; | ||
+ | for(int i=0; i<n; i++) { | ||
+ | for(int j=0; j<n; j++) { | ||
+ | for(int k=0; k<n; k++) { | ||
+ | cout << i << j << k << endl; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Rekurzívne riešenie pre všeobecné k=== | ||
+ | Čo ak chceme k-tice pre všeobecné k? Využijeme rekurziu. | ||
+ | * Variácie k-tej triedy vieme rozdeliť na n skupín podľa prvého prvku: | ||
+ | ** tie čo začínajú na 0, tie čo začínajú na 1, ..., tie čo začínajú na ''n-1''. | ||
+ | * V každej skupine ak odoberieme prvý prvok, dostaneme variácie triedy ''k-1'' | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | void vypis(int a[], int k) { | ||
+ | for (int i = 0; i < k; i++) { | ||
+ | cout << a[i]; | ||
+ | } | ||
+ | cout << endl; | ||
+ | } | ||
+ | |||
+ | void generuj(int a[], int i, int k, int n) { | ||
+ | /* v poli a dlzky k mame prvych i cifier, | ||
+ | * chceme vygenerovat vsetky moznosti | ||
+ | * poslednych k-i cifier */ | ||
+ | if (i == k) { | ||
+ | vypis(a, k); | ||
+ | } else { | ||
+ | for (int x = 0; x < n; x++) { | ||
+ | a[i] = x; | ||
+ | generuj(a, i + 1, k, n); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | const int maxK = 100; | ||
+ | int a[maxK]; | ||
+ | int k, n; | ||
+ | cin >> k >> n; | ||
+ | cout << "Zadajte k a n: "; | ||
+ | generuj(a, 0, k, n); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Ďalšie rozšírenia=== | ||
+ | * Čo ak chceme všetky k-tice písmen A-Z? | ||
+ | * Čo ak chceme všetky DNA reťazce dĺžky k (DNA pozostáva z "písmen" A,C,G,T)? | ||
+ | |||
+ | <pre> | ||
+ | // pouzi n=26 | ||
+ | void vypis(int a[], int k) { | ||
+ | for (int i = 0; i < k; i++) { | ||
+ | char c = 'A'+a[i]; | ||
+ | cout << c; | ||
+ | } | ||
+ | cout << endl; | ||
+ | } | ||
+ | |||
+ | // pouzi n=4 | ||
+ | void vypis(int a[], int k) { | ||
+ | char abeceda[5] = "ACGT"; | ||
+ | for (int i = 0; i < k; i++) { | ||
+ | cout << abeceda[a[i]]; | ||
+ | } | ||
+ | cout << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | '''Cvičenia''' | ||
+ | * Ako by sme vypisovali všetky k-ciferné hexadecimálne čísla (šestnástková sústava), kde používame cifry 0-9 a písmená A-F? | ||
+ | * Ako by sme vypisovali všetky k-tice písmen v opačnom poradí, od ZZZ po AAA? | ||
+ | |||
+ | ==Variácie bez opakovania== | ||
+ | Teraz chceme vypísať všetky k-tice cifier z množiny {0,..,n-1}, v ktorých sa žiaden prvok neopakuje (pre k=n dostávame permutácie) | ||
+ | |||
+ | Príklad pre k=3, n=3 | ||
+ | <pre> | ||
+ | 012 | ||
+ | 021 | ||
+ | 102 | ||
+ | 120 | ||
+ | 201 | ||
+ | 210 | ||
+ | </pre> | ||
+ | |||
+ | ===Skúšanie všetkých možností=== | ||
+ | * Jednoduchá možnosť: použijeme predchádzajúci program a pred výpisom skontrolujeme, či je riešenie správne | ||
+ | |||
+ | Prvý pokus: | ||
+ | <pre> | ||
+ | bool spravne(int a[], int k, int n) { | ||
+ | /* je v poli a dlzky k kazde cislo od 0 po n-1 najviac raz? */ | ||
+ | bool bolo[maxN]; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | bolo[i] = false; | ||
+ | } | ||
+ | for (int i = 0; i < k; i++) { | ||
+ | if (bolo[a[i]]) return false; | ||
+ | bolo[a[i]] = true; | ||
+ | } | ||
+ | return true; | ||
+ | } | ||
+ | |||
+ | void generuj(int a[], int i, int k, int n) { | ||
+ | /* v poli a dlzky k mame prvych i cifier, | ||
+ | * chceme vygenerovat vsetky moznosti | ||
+ | * poslednych k-i cifier */ | ||
+ | if (i == k) { | ||
+ | if (spravne(a, k, n)) { | ||
+ | vypis(a, k); | ||
+ | } | ||
+ | } else { | ||
+ | for (int x = 0; x < n; x++) { | ||
+ | a[i] = x; | ||
+ | generuj(a, i + 1, k, n); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | '''Cvičenie:''' ako by sme napísali kontrolu, ak by sme nepoznali n? | ||
+ | |||
+ | ===Prehľadávanie s návratom, backtracking=== | ||
+ | * Predchádzajúce riešenie je neefektívne, lebo prechádza cez všetky variácie s opakovaním a veľa z nich zahodí. | ||
+ | ** Napríklad pre k=7 a n=10 pozeráme <math>10^7</math> variácií s opakovaním, ale iba 604800 z nich je správnych, čo je asi 6% | ||
+ | * Len čo sa v poli a vyskytne opakujúca sa cifra, chceme túto vetvu prehľadávania ukončiť, lebo doplnením ďalších cifier problém neodstránime | ||
+ | * Spravíme funkciu <tt>moze(a,i,x)</tt>, ktorá určí, či je možné na miesto ''i'' v poli ''a'' dať cifru ''x'' | ||
+ | * Testovanie správnosti vo funkcii generuj sa dá vynechať | ||
+ | |||
+ | <pre> | ||
+ | bool moze(int a[], int i, int x) { | ||
+ | /* Mozeme dat hodnotu x na poziciu i v poli a? | ||
+ | * Mozeme, ak sa nevyskytuje v a[0..i-1] */ | ||
+ | for (int j = 0; j < i; j++) { | ||
+ | if (a[j] == x) return false; | ||
+ | } | ||
+ | return true; | ||
+ | } | ||
+ | |||
+ | void generuj(int a[], int i, int k, int n) { | ||
+ | /* v poli a dlzky k mame prvych i cifier, | ||
+ | * chceme vygenerovat vsetky moznosti | ||
+ | * poslednych k-i cifier */ | ||
+ | if (i == k) { | ||
+ | vypis(a, k); | ||
+ | } else { | ||
+ | for (int x = 0; x < n; x++) { | ||
+ | if (moze(a, i, x)) { | ||
+ | a[i] = x; | ||
+ | generuj(a, i + 1, k, n); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Možné zrýchlenie: vytvoríme si trvalé pole <tt>bolo</tt>, v ktorom bude zaznamené, ktoré cifry sa už vyskytli a to použijeme vo funkcii <tt>moze</tt>. | ||
+ | * Po návrate z rekurzie nesmieme zabudúť príslušnú hodnotu odznačiť! | ||
+ | <pre> | ||
+ | void generuj(int a[], bool bolo[], int i, int k, int n) { | ||
+ | /* v poli a dlzky k mame prvych i cifier, | ||
+ | * v poli bolo mame zaznamenane, ktore cifry su uz pouzite, | ||
+ | * chceme vygenerovat vsetky moznosti | ||
+ | * poslednych k-i cifier */ | ||
+ | if (i == k) { | ||
+ | vypis(a, k); | ||
+ | } else { | ||
+ | for (int x = 0; x < n; x++) { | ||
+ | if (!bolo[x]) { | ||
+ | a[i] = x; | ||
+ | bolo[x] = true; | ||
+ | generuj(a, bolo, i + 1, k, n); | ||
+ | bolo[x] = false; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | const int maxK = 100; | ||
+ | const int maxN = 100; | ||
+ | int a[maxK]; | ||
+ | bool bolo[maxN]; | ||
+ | int k, n; | ||
+ | cout << "Zadajte k a n (k<=n): "; | ||
+ | cin >> k >> n; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | bolo[i] = false; | ||
+ | } | ||
+ | generuj(a, bolo, 0, k, n); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Cvičenia: ako potrebujeme zmeniť program, aby sme generovali všetky postupnosti k cifier z množiny {0,..,n-1}, také, že: | ||
+ | * z každej cifry sú v postupnosti najviac 2 výskyty? | ||
+ | * žiadne dve po sebe idúce cifry nie sú rovnaké? | ||
+ | * súčet cifier je aspoň S? | ||
+ | |||
+ | Technika rekurzívneho prehľadávania všetkých možností s orezávaním beznádejných vetiev sa nazýva '''prehľadávanie s návratom''' alebo '''backtracking'''. | ||
+ | * Hľadáme všetky postupnosti, ktoré spĺňajú nejaké podmienky | ||
+ | ** Vo všeobecnosti nemusia byť rovnako dlhé | ||
+ | * Ak máme celú postupnosť, vieme otestovať, či spĺňa podmienku (funkcia <tt>spravne</tt>) | ||
+ | * Ak máme časť postupnosti a nový prvok, vieme otestovať, či po pridaní tohto prvku má ešte šancu tvoriť časť riešenia (funkcia <tt>moze</tt>) | ||
+ | ** Funkcia <tt>moze</tt> nesmie vrátiť false, ak ešte je možné riešenie | ||
+ | ** Môže vrátiť true, ak už nie je možné riešenie, ale nevie to ešte odhaliť | ||
+ | ** Snažíme sa však odhaliť problém čím skôr | ||
+ | |||
+ | Všeobecná schéma | ||
+ | <pre> | ||
+ | void generuj(int a[], int i) { | ||
+ | /* v poli a dlzky k mame prvych i cisel z riesenia */ | ||
+ | if (spravne(a, i)) { /* ak uz mame cele riesenie, vypisme ho */ | ||
+ | vypis(a, i); | ||
+ | } else { | ||
+ | pre vsetky hodnoty x { | ||
+ | if (moze(a,i,x) { | ||
+ | a[i] = x; | ||
+ | generuj(a, i + 1); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Prehľadávanie s návratom môže byť vo všeobecnosti veľmi pomalé, čas výpočtu exponenciálne rastie. | ||
+ | |||
+ | ==Problém 8 dám== | ||
+ | |||
+ | Cieľom je rozmiestniť n dám na šachovnici nxn tak, aby sa žiadne dve navzájom neohrozovali, tj. aby žiadne dve neboli v rovnakom riadku, stĺpci, ani na rovnakej uhlopriečke. | ||
+ | |||
+ | Príklad pre n=4: | ||
+ | <pre> | ||
+ | . * . . | ||
+ | . . . * | ||
+ | * . . . | ||
+ | . . * . | ||
+ | </pre> | ||
+ | |||
+ | * V každom riadku bude práve jedna dáma, teda môžeme si riešenie reprezetovať ako pole <tt>damy</tt> dĺžky ''n'', kde <tt>damy[i]</tt> je stĺpec, v ktorom je dáma na riadku ''i'' | ||
+ | * Podobne ako v predchádzajúcom príklade chceme do poľa dať čísla od 1 po ''n'', aby spĺňali ďalšie podmienky (v každom stĺpci a na každej uhlopriečke najviac 1 dáma) | ||
+ | * Vytvoríme si polia, kde si budeme pamätať pre každý stĺpec a uhlopriečku, či už je obsadený | ||
+ | * Uhlopriečky v oboch smeroch očísľujeme číslami od 0 po ''2n-2'' | ||
+ | ** V jednom smere majú miesta na uhlopriečke rovnaký súčet, ten teda bude číslom uhlopriečky | ||
+ | ** V druhom smere majú rovnaký rozdiel, ten však môže byť aj záporný, pričítame ''n-1'' | ||
+ | * Pre jednoduchosť použijeme globálne premenné, lebo potrebujeme veľa polí | ||
+ | ** Globálne premenné spôsobujú problémy vo väčších programoch: mená premenných sa môžu "biť", môžeme si omylom prepísať číslo dôležité v inej časti programu | ||
+ | ** Mohli by sme si tiež spraviť struct obsahujúci všetky premenné potrebné premenné v rekurzii a odovzdávať si ten | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | /* globalne premenne */ | ||
+ | const int maxN = 100; | ||
+ | int n; | ||
+ | int damy[maxN]; /* pole ktore obsahuje stlpec s damou v riadku i*/ | ||
+ | bool bolStlpec[maxN]; /* pole ktore obsahuje true ak stlpec obsadeny damou */ | ||
+ | bool bolaUhl1[2 * maxN - 1]; /* polia ktore obsahuju true ak uhlopriecky obsadene */ | ||
+ | bool bolaUhl2[2 * maxN - 1]; | ||
+ | int pocet; /* pocet najdenych rieseni */ | ||
+ | |||
+ | int uhl1(int i, int j) { | ||
+ | /* na ktorej uhlopriecke je riadok i, stlpec j v smere 1? */ | ||
+ | return i + j; | ||
+ | } | ||
+ | |||
+ | int uhl2(int i, int j) { | ||
+ | /* na ktorej uhlopriecke je riadok i, stlpec j v smere 2? */ | ||
+ | return n - 1 + i - j; | ||
+ | } | ||
+ | |||
+ | void vypis() { | ||
+ | /* vypis sachovnicu textovo a zvys pocitadlo rieseni */ | ||
+ | pocet++; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | for (int j = 0; j < n; j++) { | ||
+ | if (damy[i] == j) cout << " *"; | ||
+ | else cout << " ."; | ||
+ | } | ||
+ | cout << endl; | ||
+ | } | ||
+ | cout << endl; | ||
+ | } | ||
+ | |||
+ | void generuj(int i) { | ||
+ | /* v poli damy mame prvych i dam, dopln dalsie */ | ||
+ | if (i == n) { | ||
+ | vypis(); | ||
+ | } else { | ||
+ | for (int j = 0; j < n; j++) { | ||
+ | /* skus dat damu na riadok i, stlpec j */ | ||
+ | if (!bolStlpec[j] | ||
+ | && !bolaUhl1[uhl1(i, j)] && !bolaUhl2[uhl2(i, j)]) { | ||
+ | damy[i] = j; | ||
+ | bolStlpec[j] = true; | ||
+ | bolaUhl1[uhl1(i, j)] = true; | ||
+ | bolaUhl2[uhl2(i, j)] = true; | ||
+ | generuj(i + 1); | ||
+ | bolStlpec[j] = false; | ||
+ | bolaUhl1[uhl1(i, j)] = false; | ||
+ | bolaUhl2[uhl2(i, j)] = false; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | cout << "Zadajte velkost sachovnice: "; | ||
+ | cin >> n; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | bolStlpec[i] = false; | ||
+ | } | ||
+ | for (int i = 0; i < 2 * n + 1; i++) { | ||
+ | bolaUhl1[i] = false; | ||
+ | bolaUhl2[i] = false; | ||
+ | } | ||
+ | |||
+ | /* rekuzia */ | ||
+ | pocet=0; | ||
+ | generuj(0); | ||
+ | cout << "Pocet rieseni: " << pocet << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Generovanie všetkých podmnožín== | ||
+ | Chceme vypísať všetky podmnožiny množiny {0,..,m-1}. Na rozdiel od variácií nám v podmnožine nezáleží na poradí (napr. {0,1} = {1,0}), prvky teda budeme vždy vypisovať od najmenšieho po najväčší. Napr. pre m=2 máme podmnožiny | ||
+ | <pre> | ||
+ | {} | ||
+ | {0} | ||
+ | {0,1} | ||
+ | {1} | ||
+ | </pre> | ||
+ | Podmnožinu vieme vyjadriť ako binárne pole dĺžky m, kde a[i]=0 znamená, že i nepatrí do množiny a a[i]=1 znamená, že patrí. Teda môžeme použiť predchádzajúci program pre n=2,k=m a zmeniť iba výpis: | ||
+ | |||
+ | <pre> | ||
+ | void vypis(int a[], int m) { | ||
+ | cout << "{"; | ||
+ | char oddelovac[2] = ""; | ||
+ | for (int i = 0; i < m; i++) { | ||
+ | if (a[i] == 1) { | ||
+ | cout << oddelovac; | ||
+ | strcpy(oddelovac, ","); | ||
+ | cout << i; | ||
+ | } | ||
+ | } | ||
+ | cout << "}" << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | * V premennej oddeľovač si pamätáme, akým reťazcom máme oddeliť ďalšie vypisované číslo od predchádzajúceho. | ||
+ | ** Ak ešte žiadne nebolo, oddeľovač je prázdny reťazec. | ||
+ | ** Ak už sme niečo vypísali, oddeľovač je čiarka. | ||
+ | |||
+ | Namiesto poľa intov môžeme použiť pole boolovských hodnôt a celý program trochu prispôsobiť tomu, že generujeme podmnožiny: | ||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | #include <cstring> | ||
+ | using namespace std; | ||
+ | |||
+ | void vypis(bool a[], int m) { | ||
+ | cout << "{"; | ||
+ | char oddelovac[2] = ""; | ||
+ | for (int i = 0; i < m; i++) { | ||
+ | if (a[i]) { | ||
+ | cout << oddelovac; | ||
+ | strcpy(oddelovac, ","); | ||
+ | cout << i; | ||
+ | } | ||
+ | } | ||
+ | cout << "}" << endl; | ||
+ | } | ||
+ | |||
+ | void generuj(bool a[], int i, int m) { | ||
+ | /* v poli a dlzky k mame rozhodnutie o prvych i | ||
+ | * prvkoch, chceme vygenerovat vsetky podmnoziny | ||
+ | * prvkov {i..m-1} */ | ||
+ | if (i == m) { | ||
+ | vypis(a, m); | ||
+ | } else { | ||
+ | a[i] = true; | ||
+ | generuj(a, i + 1, m); | ||
+ | a[i] = false; | ||
+ | generuj(a, i + 1, m); | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | const int maxM = 100; | ||
+ | int m; | ||
+ | cin >> m; | ||
+ | bool a[maxM]; | ||
+ | generuj(a, 0, m); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Pre n=3 program vypíše: | ||
+ | <pre> | ||
+ | {0,1,2} | ||
+ | {0,1} | ||
+ | {0,2} | ||
+ | {0} | ||
+ | {1,2} | ||
+ | {1} | ||
+ | {2} | ||
+ | {} | ||
+ | </pre> | ||
+ | |||
+ | Cvičenie: Čo by vypísal, ak by sme prehodili true a false v rekurzii? | ||
+ | |||
+ | ==Problém batoha, Knapsack problem== | ||
+ | Zlodej sa vlúpal do obchodu a vidí ''n'' vecí, pričom pre každú z nich vie odhadnúť jej hmostnosť a cenu, za ktorú by ju vedel predať. V svojom batohu však vie odniesť len veci s celkovou hmotnosťou najviac ''W'' kilogramov. Ako má vybrať veci, aby mali čo najväčšiu cenu a aby ich celková hmostnosť neprekročila ''W''? | ||
+ | |||
+ | Príklad: majme ''n=3'' veci, pričom vec 0 má hmostnoť 10 a cenu 6, vec 1 má hmotnosť 8 a cenu 4 a vec 2 má hmotnosť 6 a cenu 3. Zlodej unesie najviac 15. Na vstupe to zapíšeme takto: | ||
+ | <pre> | ||
+ | Zadaj pocet predmetov: 3 | ||
+ | Zadaj hmotnost a cenu 0-teho predmetu: 10 6 | ||
+ | Zadaj hmotnost a cenu 1-teho predmetu: 8 4 | ||
+ | Zadaj hmotnost a cenu 2-teho predmetu: 6 3 | ||
+ | Zadaj nosnost batoha: 15 | ||
+ | Zober predmety 1, 2. Ich cena je 7. | ||
+ | </pre> | ||
+ | Najlepšie je zobrať veci 1 a 2. Ich cena je 7 a súčet hmotností 14. | ||
+ | |||
+ | Tento problém ešte stretnete v ďalších ročníkoch štúdia, teraz si ukážeme jednoduchý program, ktorý prehľadáva všetky možnosti. | ||
+ | |||
+ | ===Jednoduché riešenie: pozeráme všetky podmnožiny=== | ||
+ | |||
+ | Ako predtým, generujeme všetky podmnožiny a pre každú spočítame, či jej hmotnosť nepresahuje nosnosť batoha. Podmnožiny však nevypisujeme, ale porovnávame s najlepšou nájdenou doteraz. | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | #include <cstring> | ||
+ | using namespace std; | ||
+ | |||
+ | /* struktura na ukladanie udajov o jednej veci */ | ||
+ | struct vec { | ||
+ | int hmotnost; | ||
+ | int cena; | ||
+ | }; | ||
+ | |||
+ | const int maxN = 100; /* maximalny pocet veci */ | ||
+ | |||
+ | /* globalne premenne pouzivane v rekurzii */ | ||
+ | int n; /* celkovy pocet veci v obchode */ | ||
+ | vec a[maxN]; /* pole veci */ | ||
+ | int maxCena; /* najlepsie doteraz najdene riesenie */ | ||
+ | bool maxZober[maxN]; /* ktore veci su v najlepsom rieseni */ | ||
+ | int nosnost; /* kolko unesie batoh */ | ||
+ | |||
+ | /* spocitaj sucet hmotnosti vybranych predmetov */ | ||
+ | int sucetHmotnosti(bool zober[]) { | ||
+ | int sucet = 0; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | if(zober[i]) sucet += a[i].hmotnost; | ||
+ | } | ||
+ | return sucet; | ||
+ | } | ||
+ | |||
+ | /* spocitaj sucet cien vybranych predmetov */ | ||
+ | int sucetCien(bool zober[]) { | ||
+ | int sucet = 0; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | if(zober[i]) sucet += a[i].cena; | ||
+ | } | ||
+ | return sucet; | ||
+ | } | ||
+ | |||
+ | /* vypis zoznam vybranych predmetov */ | ||
+ | void vypis(bool zober[]) { | ||
+ | cout << "Zober predmety "; | ||
+ | char oddelovac[2] = ""; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | if (zober[i]) { | ||
+ | cout << oddelovac; | ||
+ | strcpy(oddelovac, ","); | ||
+ | cout << i; | ||
+ | } | ||
+ | } | ||
+ | cout << ". Ich cena je " << sucetCien(zober) << "." << endl; | ||
+ | } | ||
+ | |||
+ | void generuj(bool zober[], int i) { | ||
+ | /* v poli a dlzky k mame rozhodnutie o prvych i | ||
+ | * prvkoch, chceme vygenerovat vsetky podmnoziny | ||
+ | * prvkov {i..n-1} a kazdu skontrolovat a porovnat s maximom */ | ||
+ | if (i == n) { | ||
+ | /* uz sme sa rozhodli o kazdom prvku. Zistime, ci mame hmostnost | ||
+ | * vybranych predmetov <= nosnost */ | ||
+ | if(sucetHmotnosti(zober)<=nosnost) { | ||
+ | /* ak ano, zistime, ci cena vybranych predmetov | ||
+ | * je viac ako doteraz najlepsie maximum */ | ||
+ | int cena = sucetCien(zober); | ||
+ | if(cena>maxCena) { | ||
+ | /* prekopiruj sucasny vyber do najlepsieho */ | ||
+ | maxCena = cena; | ||
+ | for(int i=0; i<n; i++) { | ||
+ | maxZober[i] = zober[i]; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | } else { | ||
+ | /* dosad true aj false na miesto i | ||
+ | * a skusaj vsetky moznosti pre zvysok pola */ | ||
+ | zober[i] = true; | ||
+ | generuj(zober, i+1); | ||
+ | zober[i] = false; | ||
+ | generuj(zober, i+1); | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | cout << "Zadaj pocet predmetov: "; | ||
+ | cin >> n; | ||
+ | /* nacitame hmotnost a cenu predmetov */ | ||
+ | for(int i=0; i<n; i++) { | ||
+ | cout << "Zadaj hmotnost a cenu " << i << "-teho predmetu: "; | ||
+ | cin >> a[i].hmotnost >> a[i].cena; | ||
+ | } | ||
+ | /* nacitame nostnost */ | ||
+ | cout << "Zadaj nosnost batoha: "; | ||
+ | cin >> nosnost; | ||
+ | |||
+ | bool zober[maxN]; | ||
+ | maxCena = -1; /* doteraz najlepsie riesenie ma cenu -1 */ | ||
+ | generuj(zober, 0); /* prehladavaj vsetky moznosti */ | ||
+ | |||
+ | vypis(maxZober); /* vypis najlepsie najdene riesenie */ | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Trochu rýchlejší program: skončíme vždy keď prekročíme nosnosť=== | ||
+ | |||
+ | Keď už sme sa rozhodli o prvých ''i'' veciach, sčítame hmotnosť tých, čo sme vybrali, a ak prekračuje nosnosť, túto vetvu hľadania ukončíme - nemá zmysel dopĺňať ďalšie hodnoty do zvyšku poľa, ak už zvolené veci sú príliš ťažké. | ||
+ | |||
+ | <pre> | ||
+ | /* spocitaj sucet hmotnosti vybranych predmetov, | ||
+ | * ale uvazujme iba prvych k predmetov */ | ||
+ | int sucetHmotnosti(bool zober[], int k) { | ||
+ | int sucet = 0; | ||
+ | for (int i = 0; i < k; i++) { | ||
+ | if(zober[i]) sucet += a[i].hmotnost; | ||
+ | } | ||
+ | return sucet; | ||
+ | } | ||
+ | |||
+ | void generuj(bool zober[], int i) { | ||
+ | /* v poli a dlzky k mame rozhodnutie o prvych i | ||
+ | * prvkoch, chceme vygenerovat vsetky podmnoziny | ||
+ | * prvkov {i..n-1} a kazdu skontrolovat a porovnat s maximom */ | ||
+ | |||
+ | /* ak uz sme prekrocili nosnost, nemusime pokracovat v hladani */ | ||
+ | if(sucetHmotnosti(zober, i) > nosnost) return; | ||
+ | if (i == n) { | ||
+ | /* uz sme sa rozhodli o kazdom prvku. | ||
+ | * Sucasne vieme, ze hmostnost | ||
+ | * vybranych predmetov <= nosnost. | ||
+ | * Zistime teda, ci cena vybranych predmetov | ||
+ | * je viac ako doteraz najlepsie maximum */ | ||
+ | int cena = sucetCien(zober); | ||
+ | if (cena > maxCena) { | ||
+ | /* prekopiruj sucasny vyber do najlepsieho */ | ||
+ | maxCena = cena; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | maxZober[i] = zober[i]; | ||
+ | } | ||
+ | } | ||
+ | } else { | ||
+ | /* dosad true aj false na miesto i | ||
+ | * a skusaj vsetky moznosti pre zvysok pola */ | ||
+ | zober[i] = true; | ||
+ | generuj(zober, i + 1); | ||
+ | zober[i] = false; | ||
+ | generuj(zober, i + 1); | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Ešte rýchlejší program: neprepočítavame nosnosť a cenu vždy znovu a znovu=== | ||
+ | Predchádzajúci program vždy znovu a znovu prepočítava hmotnosť a cenu, aj keď sa zoznam vybraných predmetov zmení iba trochu. Namiesto toho si môžeme v rekurzii udržiavať aktuálnu hmotnosť aj cenu doteraz vybraných predmetov. | ||
+ | <pre> | ||
+ | void generuj(bool zober[], int i, int hmotnost, int cena) { | ||
+ | /* v poli a dlzky k mame rozhodnutie o prvych i | ||
+ | * prvkoch, hmotnost je sucet hmotnosti uz vybranych predmetov | ||
+ | * a cena je sucet ich cien. | ||
+ | * Chceme vygenerovat vsetky podmnoziny | ||
+ | * prvkov {i..n-1} a kazdu skontrolovat a porovnat s maximom */ | ||
+ | |||
+ | /* ak uz sme prekrocili nosnost, nemusime pokracovat v hladani */ | ||
+ | if(hmotnost > nosnost) return; | ||
+ | if (i == n) { | ||
+ | /* uz sme sa rozhodli o kazdom prvku. | ||
+ | * Sucasne vieme, ze hmostnost | ||
+ | * vybranych predmetov <= nosnost. | ||
+ | * Zistime teda, ci cena vybranych predmetov | ||
+ | * je viac ako doteraz najlepsie maximum */ | ||
+ | if (cena > maxCena) { | ||
+ | /* prekopiruj sucasny vyber do najlepsieho */ | ||
+ | maxCena = cena; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | maxZober[i] = zober[i]; | ||
+ | } | ||
+ | } | ||
+ | } else { | ||
+ | /* dosad true aj false na miesto i | ||
+ | * a skusaj vsetky moznosti pre zvysok pola */ | ||
+ | zober[i] = true; | ||
+ | generuj(zober, i + 1, hmotnost + a[i].hmotnost, cena + a[i].cena); | ||
+ | zober[i] = false; | ||
+ | generuj(zober, i + 1, hmotnost, cena); | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | * V <tt>main</tt> zavoláme <tt>generuj(zober, 0, 0, 0);</tt> | ||
+ | ** Prečo sme nastavili cenu aj hmotnost na 0? | ||
+ | =Cvičenia 5= | ||
+ | == Funkcie zo string.h == | ||
+ | |||
+ | Naprogramujte si vlastné verzie funkcií z knižnice cstring: | ||
+ | * <tt>myStrCat(kam, co)</tt>: za koniec reťazca <tt>kam</tt> pridá reťazec <tt>co</tt> (pole <tt>kam</tt> musí byť dosť dlhé) | ||
+ | * <tt>myStrCmp(retazec1, retazec2)</tt>: vráti nulu ak sa reťazce rovnajú, kladné číslo keď je prvý neskôr v abecednom poradí, záporné číslo ak je skôr. Pozor, to či je skôr alebo neskôr sa berie podľa kódov znakov, takže napr "Z" je skôr ako "a". | ||
+ | |||
+ | Použitie strcmp: | ||
+ | * Načítajte od užívateľa postupne 5 slov a vypíšte z nich to, ktoré je prvé v abecednom poradí. Na porovnávajte reťazcov použite <tt>strcmp</tt> (alebo <tt>myStrCmp</tt>). Použite iba dve polia char-ov, v jednom budete mať práve načítané slovo, v druhom doteraz najmenšie nájdené. | ||
+ | |||
+ | == Práca s reťazcami == | ||
+ | |||
+ | * Upravte reťazec tak, aby začiatočné písmeno každého slova bolo veľké (môžete použiť funkciu toupper z knižnice cctype). | ||
+ | * Upravte načítané slovo nasledovne: Prvý a posledný znak slova necháme, ostatné náhodne poprehadzujeme. | ||
+ | ** Vypíšte používateľovi takto upravené slovo a dajte mu hádať aké slovo ste pôvodne mali. | ||
+ | |||
+ | == Jednoduchá kalkulačka == | ||
+ | |||
+ | * Napíšte program, ktorý načíta dve čísla a ponúkne "Menu" operácií, ktoré s nimi môže vykonať (plus, mínus, krát, deleno). Na základe znaku, ktorý používateľ zadal, vypíše výsledok. | ||
+ | * Rozšírte program tak, aby sa vždy po skončení pýtal, či ešte chce používateľ ďalej pokračovať. | ||
+ | |||
+ | == Veľké čísla == | ||
+ | |||
+ | Vytvorte program pre prácu s dlhými číslami. Čísla si reprezentujte v poli celých čísel, ktoré zodpovedá desiatkovému zápisu veľkého čísla. | ||
+ | |||
+ | * Vytvorte funkciu pre načítanie takéhoto čísla. Funkcia prečíta reťazec znakov a uloží ho do poľa reprezentujúceho toto číslo. | ||
+ | * Vytvorte funkciu pre vypísanie takéhoto čísla. Funkcia vypíše reťazec znakov na základe obsahu poľa. | ||
+ | * Vytvorte funkciu pre sčítanie dvoch takto reprezentovaných čísel. Výsledkom je tretie pole, ktoré reprezentuje výsledok sčítania. | ||
+ | |||
+ | == Zmeny programov z prednášky== | ||
+ | |||
+ | V programoch z [[#Prednáška_8|prednášky 8]] spravte nasledujúce zmeny: | ||
+ | |||
+ | * Funkciu [[#Prednáška_8#Vyh.C4.BEad.C3.A1vanie_podre.C5.A5azca|find]] na hľadanie vzorky v texte prerobte tak, aby našla všetky výskyty, vrátila ich pozície v poli a vrátila ich počet ako návratovú hodnotu | ||
+ | * Funkciu [[#Prednáška_8#Form.C3.A1tovanie_.C4.8D.C3.ADsla|formatInt]] na formátovanie čísla na určitú šírku stĺpca prerobte tak, aby nepoužívala pomocné pole B, ale všetko robila priamo v poli A | ||
+ | =DÚ4= | ||
+ | {{MDU|4|4366}} max. 10 bodov plus 5 bodov bonus, termín odovzdania pondelok 22.10. o 22:00 | ||
+ | |||
+ | Napíšte program, ktorý animuje bublinkové triedenie, ktoré sme preberali na [[#Prednáška_6|prednáške 6]] pomocou grafickej knižnice SimpleDraw. Vaša animácia by mala vyzerať ako príklad na obrázku vpravo. Na začiatku každého prechodu poľom zobrazte všetky prvky v poli ako čierne paličky. Keď algoritmus porovnáva dve susedné hodnoty v poli, zobrazte pole tak, aby porovnávané prvky boli vyznačené červenou. | ||
+ | [[Image:PROG-bubble.gif|frame|right|Aminácia pre počiatočnú hodnotu poľa {9, 3, 7, 5, 2}]] | ||
+ | |||
+ | '''Základná verzia programu:''' | ||
+ | * Pred každým vykreslením poľa môžete zmazať obrazovkou príkazom window.clear() a vykresľovať pole odznovu. | ||
+ | * Po každom vykreslení poľa čakajte určitý počet sekúnd príkazom window.wait(time); | ||
+ | * V programe si definujte nasledujúce konštanty, ktorými určíte parametre obrázku: | ||
+ | <pre> | ||
+ | /* veľkosť medzery medzi paličkami a | ||
+ | * veľkosť okraja okolo obrázku */ | ||
+ | const int gap = 10; | ||
+ | |||
+ | /* šírka paličky */ | ||
+ | const int width = 10; | ||
+ | |||
+ | /* výška jedného dieliku paličky, t.j. napr. palička pre hodnotu 8 | ||
+ | * bude výšky 8*height */ | ||
+ | const int height = 10; | ||
+ | |||
+ | /* maximálna povolená hodnota v triedenom poli */ | ||
+ | const int maxValue = 10; | ||
+ | |||
+ | /* dĺžka čakania po každom zobrazení poľa */ | ||
+ | const double wait = 1; | ||
+ | |||
+ | /* maximálny povolený počet hodnôt v poli resp. počet paličiek */ | ||
+ | const int maxN = 5; | ||
+ | </pre> | ||
+ | ::Konštanty môžete mať zadefinované globálne na vrchu programu, aby ste ich mohli používať vo všetkých funkciách. Potrebné rozmery obrázku a súradnice paličiek spočítajte z týchto hodnôt. | ||
+ | * Pole nenačítavajte od užívateľa, inicializujte ho n hodnotami priamo v programe. | ||
+ | * V poli budú iba kladné celé čísla medzi 1 a maxValue a ich počet bude najviac maxN. | ||
+ | * Dbajte na prehľadný štýl programu (členenie na funkcie, pomenovanie funkcií a premenných, komentáre, formátovanie) | ||
+ | |||
+ | '''Bonusové úlohy''' | ||
+ | * Prepíšte program tak, aby nevolal funkciu window.clear(), ale aby podľa potreby zmazal iba tie paličky, ktorým treba zmeniť farbu alebo výšku (zoznam id jednotlivých vykreslených paličiek si musíte pamätať v nejakom poli) | ||
+ | * Ak sa budú dve porovnávané paličky vymieňať, naznačte to v obrázku obojstrannou šípkou v medzere medzi nimi. | ||
+ | Odovzdávajte len jeden súbor, ktorý môže obsahovať základnú verziu, alebo verziu rozšírenú aj o bonusy. | ||
+ | =Pokročilá DÚ2= | ||
+ | {{MDU||4283}} max. 20 bodov + 6 bodov bonus, termín odovzdania pondelok 29.10. o 22:00 | ||
+ | |||
+ | Cieľom tejto domácej úlohy pre pokročilých je precvičiť si prácu s rekurziou a prehľadávanie s návratom (backtracking). Tieto témy budeme preberať v týždni od 15.10., ale môžete si o nich prečítať v prednáškach z minulého roku: [http://compbio.fmph.uniba.sk/vyuka/prog/index.php/2011/12_Programovanie_%281%29_v_C/C%2B%2B#Predn.C3.A1.C5.A1ka_14], [http://compbio.fmph.uniba.sk/vyuka/prog/index.php/2011/12_Programovanie_%281%29_v_C/C%2B%2B#Predn.C3.A1.C5.A1ka_15], [http://compbio.fmph.uniba.sk/vyuka/prog/index.php/2011/12_Programovanie_%281%29_v_C/C%2B%2B#Predn.C3.A1.C5.A1ka_16] (najmä programy na riešenie Sudoku). Nezabudnite na pekný štýl programu a vyvarujte sa opisovania. V komentároch vysvetlite hlavné dátové štruktúry a funkcie programu. Dodržte formát vstupu a výstupu popísaný nižšie. Odovzdávajte jeden program, ktorý bude obsahovať hlavnú časť úlohy, prípadne aj rozšírenú o bonusovú časť. | ||
+ | |||
+ | Vašou úlohou bude napísať program, ktorý rieši hlavolam [http://en.wikipedia.org/wiki/Kakuro Kakuro]. V tomto hlavolame máme danú hraciu plochu s ''n'' riadkami a ''m'' stĺpcami, pozostávajúcu z bielych a čiernych políčiek. Čierne políčka sú oddeľovače, podobne ako v klasických krížovkách. Rozdeľujú plochu na "slová": súvislé úseky bielych políčok v jednotlivých riadkoch a stĺpcoch. Do bielych políčok sa v tomto hlavolame ale namiesto písmen vpisujú cifry 1..9. Pre každé "slovo" máme v legende krížovky určené, aký majú mať cifry v tomto slove súčet. Navyše musí platiť, že v jedom slove sa žiadna cifra nesmie opakovať. Napríklad ak máme slovo dĺžky 3, ktoré má mať súčet 9, môžeme ho rozpísať napríklad ako 1+2+6, alebo 2+1+6, alebo 2+3+4 atď, ale nemôžeme použiť 1+7+1, lebo cifra 1 sa nesmie opakovať. | ||
+ | |||
+ | Napíšte program, ktorý načíta popis hlavolamu vo formáte popísanom nižšie a nájde a vypíše všetky riešenia. Hlavolam už môže mať niektoré políčka predvyplnené, ich hodnoty nemeňte. Hlavolam riešte jednoduchým prehľadávaním s návratom nasledovne: v každom kroku rekurzie nájdite prvé nevyplnené políčko na hracej ploche a skúste do neho postupne dosadiť všetky možné cifry 1..9. Potom rekurzívne prehľadajte možné dosadenia do zvyšných prázdnych políčok. Cifru však na aktuálne políčko dosaďte iba vtedy, ak nespôsobuje očividný konflikt s už vyplnenými políčkami, t.j. ak spĺňa nasledujúce pravidlá pre vodorovné aj zvislé slovo križujúce aktuálne políčko: | ||
+ | * práve dosadená cifra sa neopakuje medzi už vyplnenými hodnotami v slove | ||
+ | * ak by sme na zvyšné voľné miesta v slove dosadili najmenšie možné hodnoty 1,2,..., tak spolu s už dosadenými ciframi a aktuálnou cifrou dostaneme súčet neprevyšujúci cieľový súčet | ||
+ | * ak by sme na zvyšné voľné miesta v slove dosadili najväčšie možné hodnoty 9,8,..., tak spolu s už dosadenými ciframi a aktuálnou cifrou dostaneme súčet ktorý nie je menší ako cieľový súčet | ||
+ | Napríklad predpokladajte, že máme slovo dĺžky 6 s cieľovým súčtom 35, máme v ňom už dosadené čísla 1, 7 a skúšame všetky možnosti pre ďalšie políčko. Cifry 1 a 7 budú odmietnuté, lebo už boli v slove použité. Zvyšné tri cifry slova majú súčet aspoň 6 (1+2+3) a najviac 24 (9+8+7), teda aktuálne políčko musí byť medzi 35-1-7-24=3 a 35-1-7-6=21. Cifry 1 a 2 budú teda tiež odmietnuté kvôli tomu, že by sme už nemali šancu dosiahnuť cieľovú sumu. Skúšame teda dosadiť cifry 3,4,5,6,8 a 9. Všimnite si, že pre jednoduchosť predpokladáme, že zvyšné tri políčka môžu obsahovať najmenšie možné cifry 1,2,3 aj najväčšie možné cifry 9,8,7 bez ohľadu na to, či tieto cifry už boli v tomto alebo nejakom križujúcom slove použité. | ||
+ | |||
+ | Všimnite si, že ak dosadzujeme do nejakého slova poslednú cifru, tieto podmienky zabezpečia, že dostaneme správny súčet, lebo zvyšných políčok je 0 a teda ich najmenší aj najväčší súčet je 0. | ||
+ | |||
+ | '''Bonusová úloha:''' Pred začatím prehľadávania s návratom sa pokúste vylúčiť čo najviac možností. Pre každé políčko si pamätajte, ktoré cifry sa na ňom môžu nachádzať. Na začiatku sú to všetky cifry 1..9. Ak sú nejaké cifry predvyplnené, vylúčte ich zo všetkých políčok v pretínajúcich slovách. Potom prechádzajte jednotlivé slová, skúste pre dané slovo vygenerovať všetky možnosti ako ho doplniť pomocou zatiaľ povolených cifier a sledujte, ktoré cifry na ktorých pozíciách boli použité v aspoň jednom riešení pre toto slovo. Ostatné cifry vylúčte zo zoznamu možností. Ak zostane iba jedna cifra, dosaďte ju na políčko a vyškrtajte zo zoznamov pre ostatné políčka križujúcich slov. Tento proces opakujte, kým sa darí vylučovať ďalšie možnosti, lebo vylúčením nejakých cifier v jednom smere sa môže neskôr podariť vylúčiť ďalšie cifry v križujúcom smere. Na vygenerovanie všetkých možností pre jedno slovo použite jednoduchšiu verziu prehľadávania s návratom z hlavnej časti domácej úlohy. | ||
+ | |||
+ | Majme napríklad vodorovné slovo dĺžky 2 so súčtom 12 a zvislé slovo dĺžky 2 so súčtom 7, ktoré sa pretínajú svojimi prvými ciframi. | ||
+ | * Pre vodorovné slovo máme možnosti 3+9, 4+8, 5+7, 7+5, 8+4, 9+3. Zo zoznamov pre obidve políčka tohto slova teda môžeme vylúčiť cifry 1, 2 a 6. | ||
+ | * Pre zvislé slovo nám teraz zostávajú tieto možnosti: 3+4, 4+3, 5+2. Na prvom políčku teda zostávajú možné cifry 3,4,5, na druhom políčku máme možné cifry 2,3,4. | ||
+ | * Teraz sa môžeme napríklad vrátiť späť k vodorovnému slovu, kde už máme len možnosti 3+9, 4+8, 5+7. Na druhom políčku tohto slova nám teda zostávajú iba možné cifry 7,8,9, ale prvé políčko zostáva 3,4,5. | ||
+ | |||
+ | Keď už nie je možné vylúčiť žiadnu ďalšiu cifru zo žiadneho políčka, spustite prehľadávanie s návratom na celej ploche ako predtým, ale na každom políčku uvažujte len cifry, ktoré neboli vylúčené počas predspracovania. | ||
+ | |||
+ | ==Formát vstupu a výstupu== | ||
+ | |||
+ | Popis hlavolamu načítajte zo súboru <tt>hlavolam.txt</tt>. Na prvom riadku tohto súboru sú čísla ''n'' a ''m'' oddelené medzerou, udávajúce počet riadkov a stĺpcov hracej plochy. Potom nasleduje hracia plocha, v ktorej je každé políčko reprezentované jedným znakom. Znak <tt>#</tt> znamená čierne políčko, znak <tt>.</tt> znamené biele políčko a cifra 1..9 znamená biele políčko predvyplnené s danou cifrou. V poslednej časti vstupného súboru je legenda. Každý riadok legendy pozostáva zo štyroch údajov oddelených medzerami: číslo riadku, číslo stĺpca, písmeno h alebo v a požadovaný súčet. Prvé dve čísla udávajú súradnice ľavého resp. horného konca slova, pričom riadky aj stĺpce plochy číslujeme od 0. Písmeno h zodpovedá vodorovnému (horizontálnemu) smeru slova a písmeno v zvislému (vertikálnemu) smeru. Jednotlivé slová hracej plochy sa v legende môžu vyskytovať v ľubovoľnom poradí, ale žiadne nie je vynechané, ani sa neopakuje. Môžete predpokladať, že súbor je v správnom formáte, hlavolam má aspoň jedno riešenie a n aj m sú naviac 50. | ||
+ | |||
+ | Výsledok vypíšte do súboru <tt>riesenia.txt</tt>. Vypíšte všetky riešenia hlavolamu, v ľubovoľnom poradí, každé práve raz. Použite formát ako v príklade (cifry v jednom riadku neoddeľujte medzerami, čierne políčka vypíšte ako #). Za každé riešenie vypíšte prázdny riadok. | ||
+ | |||
+ | Príklad vstupu: | ||
+ | <pre> | ||
+ | 3 5 | ||
+ | ..#.. | ||
+ | ...#. | ||
+ | ..... | ||
+ | 0 0 h 5 | ||
+ | 0 3 h 8 | ||
+ | 1 0 h 9 | ||
+ | 1 4 h 4 | ||
+ | 2 0 h 17 | ||
+ | 0 0 v 6 | ||
+ | 0 1 v 10 | ||
+ | 1 2 v 10 | ||
+ | 0 3 v 1 | ||
+ | 2 3 v 2 | ||
+ | 0 4 v 14 | ||
+ | </pre> | ||
+ | Príklad výstupu: | ||
+ | <pre> | ||
+ | 23#17 | ||
+ | 324#4 | ||
+ | 15623 | ||
+ | |||
+ | 32#17 | ||
+ | 216#4 | ||
+ | 17423 | ||
+ | |||
+ | 32#17 | ||
+ | 234#4 | ||
+ | 15623 | ||
+ | |||
+ | </pre> | ||
+ | Ak na vstupe predvyplníme vhodnú cifru, zostane nám iba jedno riešenie: | ||
+ | <pre> | ||
+ | 3 5 | ||
+ | ..#.. | ||
+ | ..6#. | ||
+ | ..... | ||
+ | 0 0 h 5 | ||
+ | 0 3 h 8 | ||
+ | 1 0 h 9 | ||
+ | 1 4 h 4 | ||
+ | 2 0 h 17 | ||
+ | 0 0 v 6 | ||
+ | 0 1 v 10 | ||
+ | 1 2 v 10 | ||
+ | 0 3 v 1 | ||
+ | 2 3 v 2 | ||
+ | 0 4 v 14 | ||
+ | </pre> | ||
+ | výstup: | ||
+ | <pre> | ||
+ | 32#17 | ||
+ | 216#4 | ||
+ | 17423 | ||
+ | |||
+ | </pre> | ||
+ | =Prednáška 11= | ||
+ | ==Opakovanie backtrackingu== | ||
+ | |||
+ | * Na minulej prednáške sme používali backtracking (prehľadávanie s návratom). Metóda, ktorú sme videli sa dá zhrnúť nasledovne: | ||
+ | ** V poli si budeme postupne generovať možnosti pre jednotlivé pozície (keď potrebujeme vygenerovať ''k'' prvkov a každý môže byť z ''n'' možností) | ||
+ | ** Keď už budeme mať pole vyplnené (máme hodnotu pre každý prvok) skontrolujeme, či je možnosť korektná | ||
+ | ** Ak si niekde pamätáme už použité prvky, nezabudneme ich pri vynáraní z rekurzie odznačiť | ||
+ | |||
+ | <pre> | ||
+ | void generuj(int a[], int i, int k, int n) { | ||
+ | /* v poli a dlzky k mame prvych i pozicii, | ||
+ | * chceme vygenerovat vsetky moznosti | ||
+ | * poslednych k-i pozicii */ | ||
+ | if (i == k) { | ||
+ | if (spravne(a, k, n)) { | ||
+ | vypis(a, k); | ||
+ | } | ||
+ | } else { | ||
+ | for (vsetky moznosti na dalsom mieste) { | ||
+ | // pridaj moznost na i-tom mieste | ||
+ | generuj(a, i + 1, k, n); | ||
+ | // tu ak treba vráť všetko do pôvodného stavu | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Problém batoha, Knapsack problem== | ||
+ | Zlodej sa vlúpal do obchodu a vidí ''n'' vecí, pričom pre každú z nich vie odhadnúť jej hmostnosť a cenu, za ktorú by ju vedel predať. V svojom batohu však vie odniesť len veci s celkovou hmotnosťou najviac ''W'' kilogramov. Ako má vybrať veci, aby mali čo najväčšiu cenu a aby ich celková hmostnosť neprekročila ''W''? | ||
+ | |||
+ | Príklad: majme ''n=3'' veci, pričom vec 0 má hmostnoť 10 a cenu 6, vec 1 má hmotnosť 8 a cenu 4 a vec 2 má hmotnosť 6 a cenu 3. Zlodej unesie najviac 15. Na vstupe to zapíšeme takto: | ||
+ | <pre> | ||
+ | Zadaj pocet predmetov: 3 | ||
+ | Zadaj hmotnost a cenu 0-teho predmetu: 10 6 | ||
+ | Zadaj hmotnost a cenu 1-teho predmetu: 8 4 | ||
+ | Zadaj hmotnost a cenu 2-teho predmetu: 6 3 | ||
+ | Zadaj nosnost batoha: 15 | ||
+ | Zober predmety 1, 2. Ich cena je 7. | ||
+ | </pre> | ||
+ | Najlepšie je zobrať veci 1 a 2. Ich cena je 7 a súčet hmotností 14. | ||
+ | |||
+ | Tento problém ešte stretnete v ďalších ročníkoch štúdia, teraz si ukážeme jednoduchý program, ktorý prehľadáva všetky možnosti. | ||
+ | |||
+ | ===Jednoduché riešenie: pozeráme všetky podmnožiny=== | ||
+ | |||
+ | Ako predtým, generujeme všetky podmnožiny a pre každú spočítame, či jej hmotnosť nepresahuje nosnosť batoha. Podmnožiny však nevypisujeme, ale porovnávame s najlepšou nájdenou doteraz. | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | #include <cstring> | ||
+ | using namespace std; | ||
+ | |||
+ | /* struktura na ukladanie udajov o jednej veci */ | ||
+ | struct vec { | ||
+ | int hmotnost; | ||
+ | int cena; | ||
+ | }; | ||
+ | |||
+ | const int maxN = 100; /* maximalny pocet veci */ | ||
+ | |||
+ | /* globalne premenne pouzivane v rekurzii */ | ||
+ | int n; /* celkovy pocet veci v obchode */ | ||
+ | vec a[maxN]; /* pole veci */ | ||
+ | int maxCena; /* najlepsie doteraz najdene riesenie */ | ||
+ | bool maxZober[maxN]; /* ktore veci su v najlepsom rieseni */ | ||
+ | int nosnost; /* kolko unesie batoh */ | ||
+ | |||
+ | /* spocitaj sucet hmotnosti vybranych predmetov */ | ||
+ | int sucetHmotnosti(bool zober[]) { | ||
+ | int sucet = 0; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | if(zober[i]) sucet += a[i].hmotnost; | ||
+ | } | ||
+ | return sucet; | ||
+ | } | ||
+ | |||
+ | /* spocitaj sucet cien vybranych predmetov */ | ||
+ | int sucetCien(bool zober[]) { | ||
+ | int sucet = 0; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | if(zober[i]) sucet += a[i].cena; | ||
+ | } | ||
+ | return sucet; | ||
+ | } | ||
+ | |||
+ | /* vypis zoznam vybranych predmetov */ | ||
+ | void vypis(bool zober[]) { | ||
+ | cout << "Zober predmety "; | ||
+ | char oddelovac[2] = ""; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | if (zober[i]) { | ||
+ | cout << oddelovac; | ||
+ | strcpy(oddelovac, ","); | ||
+ | cout << i; | ||
+ | } | ||
+ | } | ||
+ | cout << ". Ich cena je " << sucetCien(zober) << "." << endl; | ||
+ | } | ||
+ | |||
+ | void generuj(bool zober[], int i) { | ||
+ | /* v poli a dlzky k mame rozhodnutie o prvych i | ||
+ | * prvkoch, chceme vygenerovat vsetky podmnoziny | ||
+ | * prvkov {i..n-1} a kazdu skontrolovat a porovnat s maximom */ | ||
+ | if (i == n) { | ||
+ | /* uz sme sa rozhodli o kazdom prvku. Zistime, ci mame hmostnost | ||
+ | * vybranych predmetov <= nosnost */ | ||
+ | if(sucetHmotnosti(zober)<=nosnost) { | ||
+ | /* ak ano, zistime, ci cena vybranych predmetov | ||
+ | * je viac ako doteraz najlepsie maximum */ | ||
+ | int cena = sucetCien(zober); | ||
+ | if(cena>maxCena) { | ||
+ | /* prekopiruj sucasny vyber do najlepsieho */ | ||
+ | maxCena = cena; | ||
+ | for(int i=0; i<n; i++) { | ||
+ | maxZober[i] = zober[i]; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | } else { | ||
+ | /* dosad true aj false na miesto i | ||
+ | * a skusaj vsetky moznosti pre zvysok pola */ | ||
+ | zober[i] = true; | ||
+ | generuj(zober, i+1); | ||
+ | zober[i] = false; | ||
+ | generuj(zober, i+1); | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | cout << "Zadaj pocet predmetov: "; | ||
+ | cin >> n; | ||
+ | /* nacitame hmotnost a cenu predmetov */ | ||
+ | for(int i=0; i<n; i++) { | ||
+ | cout << "Zadaj hmotnost a cenu " << i << "-teho predmetu: "; | ||
+ | cin >> a[i].hmotnost >> a[i].cena; | ||
+ | } | ||
+ | /* nacitame nostnost */ | ||
+ | cout << "Zadaj nosnost batoha: "; | ||
+ | cin >> nosnost; | ||
+ | |||
+ | bool zober[maxN]; | ||
+ | maxCena = -1; /* doteraz najlepsie riesenie ma cenu -1 */ | ||
+ | generuj(zober, 0); /* prehladavaj vsetky moznosti */ | ||
+ | |||
+ | vypis(maxZober); /* vypis najlepsie najdene riesenie */ | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Trochu rýchlejší program: skončíme vždy keď prekročíme nosnosť=== | ||
+ | |||
+ | Keď už sme sa rozhodli o prvých ''i'' veciach, sčítame hmotnosť tých, čo sme vybrali, a ak prekračuje nosnosť, túto vetvu hľadania ukončíme - nemá zmysel dopĺňať ďalšie hodnoty do zvyšku poľa, ak už zvolené veci sú príliš ťažké. | ||
+ | |||
+ | <pre> | ||
+ | /* spocitaj sucet hmotnosti vybranych predmetov, | ||
+ | * ale uvazujme iba prvych k predmetov */ | ||
+ | int sucetHmotnosti(bool zober[], int k) { | ||
+ | int sucet = 0; | ||
+ | for (int i = 0; i < k; i++) { | ||
+ | if(zober[i]) sucet += a[i].hmotnost; | ||
+ | } | ||
+ | return sucet; | ||
+ | } | ||
+ | |||
+ | void generuj(bool zober[], int i) { | ||
+ | /* v poli a dlzky k mame rozhodnutie o prvych i | ||
+ | * prvkoch, chceme vygenerovat vsetky podmnoziny | ||
+ | * prvkov {i..n-1} a kazdu skontrolovat a porovnat s maximom */ | ||
+ | |||
+ | /* ak uz sme prekrocili nosnost, nemusime pokracovat v hladani */ | ||
+ | if(sucetHmotnosti(zober, i) > nosnost) return; | ||
+ | if (i == n) { | ||
+ | /* uz sme sa rozhodli o kazdom prvku. | ||
+ | * Sucasne vieme, ze hmostnost | ||
+ | * vybranych predmetov <= nosnost. | ||
+ | * Zistime teda, ci cena vybranych predmetov | ||
+ | * je viac ako doteraz najlepsie maximum */ | ||
+ | int cena = sucetCien(zober); | ||
+ | if (cena > maxCena) { | ||
+ | /* prekopiruj sucasny vyber do najlepsieho */ | ||
+ | maxCena = cena; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | maxZober[i] = zober[i]; | ||
+ | } | ||
+ | } | ||
+ | } else { | ||
+ | /* dosad true aj false na miesto i | ||
+ | * a skusaj vsetky moznosti pre zvysok pola */ | ||
+ | zober[i] = true; | ||
+ | generuj(zober, i + 1); | ||
+ | zober[i] = false; | ||
+ | generuj(zober, i + 1); | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Ešte rýchlejší program: neprepočítavame nosnosť a cenu vždy znovu a znovu=== | ||
+ | Predchádzajúci program vždy znovu a znovu prepočítava hmotnosť a cenu, aj keď sa zoznam vybraných predmetov zmení iba trochu. Namiesto toho si môžeme v rekurzii udržiavať aktuálnu hmotnosť aj cenu doteraz vybraných predmetov. | ||
+ | <pre> | ||
+ | void generuj(bool zober[], int i, int hmotnost, int cena) { | ||
+ | /* v poli a dlzky k mame rozhodnutie o prvych i | ||
+ | * prvkoch, hmotnost je sucet hmotnosti uz vybranych predmetov | ||
+ | * a cena je sucet ich cien. | ||
+ | * Chceme vygenerovat vsetky podmnoziny | ||
+ | * prvkov {i..n-1} a kazdu skontrolovat a porovnat s maximom */ | ||
+ | |||
+ | /* ak uz sme prekrocili nosnost, nemusime pokracovat v hladani */ | ||
+ | if(hmotnost > nosnost) return; | ||
+ | if (i == n) { | ||
+ | /* uz sme sa rozhodli o kazdom prvku. | ||
+ | * Sucasne vieme, ze hmostnost | ||
+ | * vybranych predmetov <= nosnost. | ||
+ | * Zistime teda, ci cena vybranych predmetov | ||
+ | * je viac ako doteraz najlepsie maximum */ | ||
+ | if (cena > maxCena) { | ||
+ | /* prekopiruj sucasny vyber do najlepsieho */ | ||
+ | maxCena = cena; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | maxZober[i] = zober[i]; | ||
+ | } | ||
+ | } | ||
+ | } else { | ||
+ | /* dosad true aj false na miesto i | ||
+ | * a skusaj vsetky moznosti pre zvysok pola */ | ||
+ | zober[i] = true; | ||
+ | generuj(zober, i + 1, hmotnost + a[i].hmotnost, cena + a[i].cena); | ||
+ | zober[i] = false; | ||
+ | generuj(zober, i + 1, hmotnost, cena); | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | * V <tt>main</tt> zavoláme <tt>generuj(zober, 0, 0, 0);</tt> | ||
+ | ** Prečo sme nastavili cenu aj hmotnost na 0? | ||
+ | |||
+ | |||
+ | == Rozdeľuj a panuj == | ||
+ | |||
+ | Metóda '''Rozdeľuj a panuj''' je rekurzívna metóda, kde podproblémy rozdelíme, aby ich urobil niekto iný a my to iba spracujeme. | ||
+ | Rekurzívne triedenia sú založené na tomto princípe. Tento spôsob všeobecne funguje nasledovne | ||
+ | |||
+ | * Rozdeľuj: Prvá fáza algoritmu je rozdelenie problému na nejaké menšie časti, ktoré sa dajú riešiť ďalej samostatne (teda by nemali mať prienik). | ||
+ | * Vyrieš podproblémy: Rekurzívne sa zavolám na podproblémy a keď dostanem ich výsledky, tak .. | ||
+ | * Panuj: Poslednou časťou je spojenie výsledkov do výsledku celkového problému. | ||
+ | |||
+ | == MergeSort == | ||
+ | |||
+ | V triedení zlučovaním sa pole veľkosti N rozdelí na polovicu najjednoduchším spôsobom - na prvú a druhú polovicu. Tieto rekurzívne utriedime, čím dostávame 2 utriedené postupnosti. Preto vo fáze panuj potrebujeme tieto dve polia zlúčiť (merge) do výsledného poľa. | ||
+ | |||
+ | <pre> | ||
+ | int mergesort(int a[], int low, int high){ | ||
+ | if (low>=high) return 0; | ||
+ | |||
+ | // rozdeluj | ||
+ | int mid=(low+high)/2; | ||
+ | |||
+ | //rekurzivne volanie na dva podpripady | ||
+ | mergesort(a,low,mid); | ||
+ | mergesort(a,mid+1,high); | ||
+ | |||
+ | //panuj | ||
+ | return merge(a,low,high,mid); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Zlučovanie utriedených podpolí === | ||
+ | |||
+ | Zaujímavým problémom je zlúčenie dvoch utriedených postupností. Máme dve utriedené postupnosti A[0..N-1] a B[0..M-1]. | ||
+ | |||
+ | * Je úplne jasné, že prvým prvkom výslednej postupnosti bude menší z prvkov A[0] a B[0]. | ||
+ | Potom ostávajú postupnosti A[1..N-1] a B[0..M-1] alebo A[0..N-1] a B[1..M-1]. | ||
+ | * Vo všeobecnosti máme teraz postupnosti A[i..N-1] a B[j..M-1]. Ďalším prvkom postupnosti bude buď A[i] alebo B[j] a ostanú nám postupnosti A[i+1..N-1] a B[j..M-1] alebo A[i..N-1] a B[j-1..M-1]. | ||
+ | * Toto robíme dovtedy, kým s jedným poľom neskončíme. Vtedy na koniec dokopírujeme zyvšok druhého poľa. | ||
+ | |||
+ | Z toho dostávame nasledovný program. | ||
+ | <pre> | ||
+ | void merge(int A[],int B[],int N, int M){ | ||
+ | int i=0,j=0; | ||
+ | int C[MAX]; | ||
+ | |||
+ | while((i<N)&&(j<M)){ | ||
+ | if(A[i]<=B[j]){ | ||
+ | C[i+j]=A[i++]; // vysledok ukladame na (i+j)-te miesto | ||
+ | } | ||
+ | else{ | ||
+ | C[i+j]=B[j++]; // vysledok ukladame na (i+j)-te miesto | ||
+ | } | ||
+ | } | ||
+ | |||
+ | if (i<N){ // skoncilo pole B | ||
+ | for(;i<N;i++){ | ||
+ | C[i+j]=A[i]; | ||
+ | } | ||
+ | } | ||
+ | else { // skoncilo pole A | ||
+ | for(;j<M;j++){ | ||
+ | C[i+j]=B[j]; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Tento postup sa dá mierne upraviť, ak si uvedomíme, že vlastne vieme, ako dlho zapisujeme z jednej postupnosti (napríklad A). Je to do chvíle, kým jej prvý prvok nebude väčší, ako prvý prvok z postupnosti druhej (B). | ||
+ | |||
+ | <pre> | ||
+ | void merge(int A[],int B[],int N, int M){ | ||
+ | int i=0,j=0; | ||
+ | int C[MAX]; | ||
+ | |||
+ | while((i<N)&&(j<M)){ | ||
+ | while ((A[i]<=B[j])&&(i<N)){ | ||
+ | C[i+j]=A[i++]; | ||
+ | } | ||
+ | |||
+ | while (B[j]<=A[i]&&(j<M)){ | ||
+ | C[i+j]=B[j++]; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | for(;i<N;i++){ // ktore pole skoncilo testovat netreba, lebo cyklus prinajhorsom neprebehne | ||
+ | C[i+j]=A[i]; | ||
+ | } | ||
+ | for(;j<M;j++){ | ||
+ | C[i+j]=B[j]; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Výsledný MergeSort === | ||
+ | |||
+ | Ostáva už iba drobnosť. My nezlučujeme dve nezávislé polia ale prvky jedného poľa a navyše by sme radi, aby tie prvky v tomto poli aj skončili. | ||
+ | * Prvá časť sa bude riešiť jednoducho. Nepotrebujeme teda ako parameter dve polia ale iba jedno (A[]) ale zato potrebujeme miesta odkiaľ a pokiaľ sú jednotlivé úseky. | ||
+ | ** Pre začiatok by sme teda mali parametre int A[], int zaciatok1, int koniec1, int zaciatok2, int koniec2. | ||
+ | ** Avšak jediné úseky, ktoré zlučujeme sú úseky idúce za sebou, ktoré sme iba rozdelili na nejakom mieste - pôvodne sme mali interval (low, high) a my sme ho rozdelili na intervaly (low, mid) a (mid+1,high). Na identifikáciu takýchto úsekov potom stačia parametre low a high. | ||
+ | * Druhý problém vieme vyriešiť jednoducho - pomocné pole na konci nakopírujeme naspäť. | ||
+ | ** A nič oveľa inteligentnejšie nebudeme robiť - zbytočne by sme si niečo prepísali - toto nie je rekurzívna fáza, tu sa to pole vždy umaže hned po využití. | ||
+ | |||
+ | <pre> | ||
+ | #include<iostream> | ||
+ | |||
+ | using namespace std; | ||
+ | |||
+ | void merge(int A[],int low, int high){ | ||
+ | int i=low, j=(high+low)/2+1; // indexy v poli A | ||
+ | int k=0; // index v poli C | ||
+ | int N=j, M=high+1; // zarazky indexov i a j | ||
+ | int C[MAX]; | ||
+ | |||
+ | while((i<N)&&(j<M)){ | ||
+ | while ((A[i]<=A[j])&&(i<N)){ | ||
+ | C[k++]=A[i++]; | ||
+ | } | ||
+ | |||
+ | while (A[j]<=A[i]&&(j<M)){ | ||
+ | C[k++]=A[j++]; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | for(;i<N;i++){ // ktore pole skoncilo testovat netreba, lebo cyklus prinajhorsom neprebehne | ||
+ | C[k++]=A[i]; | ||
+ | } | ||
+ | for(;j<M;j++){ | ||
+ | C[k++]=A[j]; | ||
+ | } | ||
+ | |||
+ | for (int kk=low; kk<=high; kk++) A[kk]=C[kk-low]; | ||
+ | |||
+ | } | ||
+ | |||
+ | |||
+ | void mergesort(int A[], int low, int high){ | ||
+ | if (low>=high) return; | ||
+ | |||
+ | // rozdeluj | ||
+ | int mid=(low+high)/2; | ||
+ | |||
+ | //rekurzivne volanie na dva podpripady | ||
+ | mergesort(A,low,mid); | ||
+ | mergesort(A,mid+1,high); | ||
+ | |||
+ | //panuj | ||
+ | merge(A,low,high); | ||
+ | } | ||
+ | |||
+ | int main(void){ | ||
+ | int A[]={135,1,58,75,12,45,7,100,23,467}; | ||
+ | mergesort(A,0,9); | ||
+ | for (int i=0; i<10; i++) cout<< A[i]<< " "; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Ukážka na príklade === | ||
+ | Pole A[]={135,1,58,75,12,45,7,100,23,467} | ||
+ | |||
+ | <pre> | ||
+ | Merge (0,0,1): 135 1 -> 1 135 | ||
+ | Merge (0,1,2): 1 135 58 -> 1 58 135 | ||
+ | Merge (3,3,4): 75 12 -> 12 75 | ||
+ | Merge (0,2,4): 1 58 135 12 75 -> 1 12 58 75 135 | ||
+ | Merge (5,5,6): 45 7 -> 7 45 | ||
+ | Merge (5,6,7): 7 45 100 -> 7 45 100 | ||
+ | Merge (8,8,9): 23 467 -> 23 467 | ||
+ | Merge (5,7,9): 7 45 100 23 467 -> 7 23 45 100 467 | ||
+ | Merge (0,4,9): 1 12 58 75 135 7 23 45 100 467 -> 1 7 12 23 45 58 75 100 135 467 | ||
+ | </pre> | ||
+ | |||
+ | |||
+ | |||
+ | == Quicksort == | ||
+ | |||
+ | Quicksort je tiež založený na metóde rozdeľuj a panuj. Aby utriedil pole N prvkov, rozdelí si ich na menšie a väčšie prvky, ktoré potom utriedi. Štruktúra programu je nasledovná: | ||
+ | * Rozdeľuj: prvky rozdelí na dve skupiny (menšie a väčšie prvky). Ako uvidíme neskôr, čo sú väčšie a menšie prvky závisí na spracovávaných prvkoch. Celkovo môžeme povedať, že menšie prvky sú menšie ako väčšie prvky (logické, nie?) | ||
+ | * Rekurzívne sa zavolá na každú skupinu prvkov a dostáva dve utriedené postupnosti - utriedenú postupnosť menších prvkov a utriedenú postupnosť väčších prvkov. | ||
+ | * Panuj: Keďže menšie prvky sú všetky menšie ako prvky väčšie pole N prvkov je utriedené, ak dáme tieto dve postupnosti proste za seba, najskôr utriedené menšie prvky, potom utriedené väčšie prvky. | ||
+ | |||
+ | <pre> | ||
+ | void quicksort(int A[], int l, int r){ | ||
+ | if (l>=r) return; | ||
+ | |||
+ | // rozdelenie | ||
+ | pivot=divide(A, l, r); | ||
+ | |||
+ | // rekurzivne volanie na mensie a vacsie prvky | ||
+ | quicksort(A,l,pivot); | ||
+ | quicksort(A,pivot+1,r); | ||
+ | |||
+ | //zlucenie nebude treba - su spravne za sebou | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Jednoduché rozdelenie prvkov === | ||
+ | |||
+ | Najprv si ukážeme jednoduchý spôsob, ako pole správne rozdeliť. Budeme si naozaj vytvárať 2 polia (Cmensie a Cvacsie), do ktorého prvky z poľa A (teda z jeho podpoľa A[l..r]) budeme rozdeľovať. Každé z týchto polí bude mať veľkosť najviac r-l. | ||
+ | |||
+ | Špeciálne si oddelíme pivot, aby sme si ho niekde neprepísali (mohli sme si vytvárať polia 3 - väčšie, menšie a rovné). | ||
+ | |||
+ | Následne do poľa A[l..r] nakopírujeme najskôr pole Cmensie, potom pivot (jeho pozíciu si zapamatáme) a nakoniec pole Cvacsie. Takto upravené pole a hodnotu na ktorej sa nachádza pivot môžeme vrátiť. | ||
+ | |||
+ | <pre> | ||
+ | int divide(int A[], int l, int r){ | ||
+ | int pivot=l; //alebo lubovolny iny prvok z intervalu | ||
+ | int pivothodnota=A[pivot]; | ||
+ | int Cmensie[MAX]; | ||
+ | int Cvacsie[MAX]; | ||
+ | |||
+ | int i1=0,i2=0; | ||
+ | for (int i=l; i<=r; i++){ | ||
+ | if (i==pivot) continue; | ||
+ | else if (A[i]<=A[pivot]) Cmensie[i1++]=A[i]; | ||
+ | else Cvacsie[i2++]=A[i]; | ||
+ | } | ||
+ | for (int i=0; i<i1; i++){ | ||
+ | A[l+i]=Cmensie[i]; | ||
+ | } | ||
+ | |||
+ | pivot=l+i1; | ||
+ | A[pivot]=pivothodnota; | ||
+ | |||
+ | for (int i=0; i<i2; i++){ | ||
+ | A[pivot+1+i]=Cvacsie[i]; | ||
+ | } | ||
+ | |||
+ | return pivot; // hodnota na ktorej je teraz realne pivot | ||
+ | } | ||
+ | |||
+ | </pre> | ||
+ | |||
+ | Pri takomto rozdeľovaní poľa by sme sa mohli rekurzívne volať iba na časti A[l..pivot-1] a A[pivot+1..r] resp. na ešte kratšie úseky ak by sme si pamätali aj prvky rovné pivotu. | ||
+ | |||
+ | === Rozdelenie prvkov priamo v poli (inplace quicksort) === | ||
+ | |||
+ | Rozdelenie prvkov na menšie a väčšie sa dá vykonávať aj priamo v poli - bez pomocných polí. Myšlienka je nasledovná: | ||
+ | * Zvolíme si hodnotu, na základe ktorej budeme prvky deliť. | ||
+ | * Zľava pozeráme na prvky v poli - ktoré môžu byť v tejto polovici (sú menšie ako pivot), tak tam necháme a keď narazíme na väčší (alebo rovný), zastavíme. | ||
+ | * Podobne sprava - ktoré môžu byť v tejto polovici (sú väčšie ako pivot), tak tam necháme a keď narazíme na menší (alebo rovný), zastavíme. | ||
+ | * V jednej chvíli sme zastavili z oboch krajov a máme dva prvky - jeden je menší a druhý väčší ako pivot. V prípade, že sú v tých nesprávnych poloviciach (teda ak ten väčší je naľavo od menšieho) tak ich vymeníme. | ||
+ | * V prípade, že sme našli prvky, ktoré však už sú v správnych poloviciach znamená to, že sa nám už naše dva indexy niekedy stretli. V tom pripade viem, že naľavo od j máme iste iba čísla menšie od pivota (lebo touto časťou už index i prechádzal) - podobne to platí aj napravo od i. | ||
+ | |||
+ | <pre> | ||
+ | int divide(int A[], int l, int r){ | ||
+ | int i=l, j=r; | ||
+ | int pivothodnota=A[1]; | ||
+ | |||
+ | while (i<j){ | ||
+ | while (A[i]<pivothodnota) i++; | ||
+ | while (A[j]>pivothodnota) j--; | ||
+ | if (i<j) { | ||
+ | int temp=A[i]; A[i]=A[j]; A[j]=temp; | ||
+ | } | ||
+ | } | ||
+ | return j; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Takto napísaná funkcia funguje iba pre rôzne čísla. Uvedomte si, že pri výmene dvoch rovnakých čísel (môže sa stať, ak sú vybraným pivotom) sa zacyklíme. | ||
+ | Preto vo finálnej verzii upravíme rozdelenie tak, aby fungovalo aj pre opakované čísla. | ||
+ | |||
+ | === Výsledný quicksort === | ||
+ | |||
+ | <pre> | ||
+ | int divide(int A[], int l, int r){ | ||
+ | int v=A[r]; // zvolim si pivot a odlozim si ho na kraj (alebo rovno zvolim krajny prvok) | ||
+ | int i=l-1, j=r; | ||
+ | int temp; | ||
+ | while (i<j){ | ||
+ | while (A[++i]<v); | ||
+ | while (A[--j]>v); | ||
+ | if (i>=j) break; | ||
+ | temp=A[i]; A[i]=A[j]; A[j]=temp; | ||
+ | } | ||
+ | temp=A[i]; A[i]=A[r]; A[r]=temp; // vratim pivot kam patri | ||
+ | return i; | ||
+ | } | ||
+ | |||
+ | void quicksort(int A[], int l, int r){ | ||
+ | if (l>=r) return; | ||
+ | |||
+ | // rozdelenie | ||
+ | int pivot=divide(A, l, r); | ||
+ | |||
+ | // rekurzivne volanie na mensie a vacsie prvky | ||
+ | quicksort(A,l,pivot-1); | ||
+ | quicksort(A,pivot+1,r); | ||
+ | |||
+ | //zlucenie nebude treba - su spravne za sebou | ||
+ | } | ||
+ | |||
+ | </pre> | ||
+ | |||
+ | Občas sa môžete stretnúť aj s takto napísaným quicksortom. Skúste si premyslieť, prečo funguje a prečo si môžem dovoliť niektoré prvky vynechať. | ||
+ | |||
+ | <pre> | ||
+ | void quickSort(int A[], int left, int right) { | ||
+ | if (left>=right) return; | ||
+ | int i = left, j = right; | ||
+ | int pivot = A[(left + right) / 2]; | ||
+ | |||
+ | /* partition */ | ||
+ | while (i <= j) { | ||
+ | while (A[i] < pivot) i++; | ||
+ | while (A[j] > pivot) j--; | ||
+ | if (i <= j) { | ||
+ | int tmp = A[i]; A[i] = A[j]; A[j] = tmp; | ||
+ | i++; j--; | ||
+ | } | ||
+ | }; | ||
+ | |||
+ | /* recursion */ | ||
+ | quickSort(A, left, j); | ||
+ | quickSort(A, i, right); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Príklad === | ||
+ | |||
+ | <pre> | ||
+ | Divide (0,8): 1 2 5 7 3 14 7 26 12 | ||
+ | Divide (0,4): 1 2 3 7 5 | ||
+ | Divide (0,2): 1 2 3 | ||
+ | Divide (3,4): 5 7 | ||
+ | Divide (5,8): 7 14 26 12 | ||
+ | Divide (6,8): 14 12 26 | ||
+ | Divide (6,7): 12 14 | ||
+ | </pre> | ||
+ | |||
+ | === Odhad zložitosti === | ||
+ | |||
+ | Zjavne sa vyskytujú dobré a zlé prípady. Ideálne je, keď sa nám podarí rozdeliť pole na dve rovnaké časti. Vtedy má quicksort zložitosť O(N.log N), čiže lepšiu, ako triedenia, ktoré sme ukázali na prednáške 6. | ||
+ | |||
+ | Nepríjemné je, keď sa nám podarí pole vždy rozdeliť na dve podpolia, z ktorých jedno má iba jeden prvok. Toto spôsobí, že v takýchto prípadoch potrebujeme až <math>O(N^2)</math>. Dobrá správa je, že takýchto prípadov nie je príliš veľa. | ||
+ | |||
+ | * Vymyslite príklad, kde by nastalo nevhodné rozdelenie. Závisí to samozrejme od toho, ako vyberáme pivota. Zamyslite sa nad prípadmi pivot=A[1] a pivot=A[(l+r)/2]. | ||
+ | =Prednáška 12= | ||
+ | == Organizačné poznámky== | ||
+ | * DÚ6 bude na stránke koncom týždňa, termín odovzdania až 12.11. | ||
+ | * DÚ5, PDÚ2 termín budúci týždeň | ||
+ | * Budúci týždeň štvrtok sviatok, piatok rektorské voľno, inak všetko beží normálne | ||
+ | * Konzultačné hodiny každý pondelok J.K. 13:10-14:00, B.B. 14:00-14:50 | ||
+ | |||
+ | == Opakovanie: triedenia == | ||
+ | |||
+ | Jednoduché triedenia: bubblesort, insertsort, maxsort | ||
+ | * Jednoduché, ale pomalé, zložitosť <math>O(n^2)</math> | ||
+ | |||
+ | Rekurzívne triedenia, rozdeľuj a panuj | ||
+ | * Rýchlejšie, zložitejšie | ||
+ | * Mergesort, zložitosť <math>O(n\log n)</math> | ||
+ | * Quicksort, zložitosť <math>O(n^2)</math> v najhoršom prípade, pre väčšinu stupov <math>O(n\log n)</math>, väčšinou rýchlejší ako Mergesort | ||
+ | |||
+ | ===Quicksort=== | ||
+ | |||
+ | <pre> | ||
+ | int divide(int A[], int l, int r) { | ||
+ | /* Preusporiada prvky A[l..r] tak, že | ||
+ | * - všetky prvky v A[l..k-1] su <= A[k], | ||
+ | * - vsetky prvky v A[k+1..r] su >= A[k] | ||
+ | * a funkcia vrati hodnotu k */ | ||
+ | |||
+ | int v = A[r]; // zvolim si pivot a odlozim si ho na kraj (alebo rovno zvolim krajny prvok) | ||
+ | int i = l - 1, j = r; | ||
+ | int temp; | ||
+ | while (i < j) { | ||
+ | while (A[++i] < v); | ||
+ | while (A[--j] > v); | ||
+ | if (i >= j) break; | ||
+ | temp = A[i]; | ||
+ | A[i] = A[j]; | ||
+ | A[j] = temp; | ||
+ | } | ||
+ | temp = A[i]; | ||
+ | A[i] = A[r]; | ||
+ | A[r] = temp; // vratim pivot kam patri | ||
+ | return i; | ||
+ | } | ||
+ | |||
+ | void quicksort(int A[], int l, int r) { | ||
+ | if (l >= r) return; | ||
+ | |||
+ | // rozdelenie | ||
+ | int pivot = divide(A, l, r); | ||
+ | |||
+ | // rekurzivne volanie na mensie a vacsie prvky | ||
+ | quicksort(A, l, pivot - 1); | ||
+ | quicksort(A, pivot + 1, r); | ||
+ | |||
+ | //zlucenie nebude treba - su spravne za sebou | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | == Medián == | ||
+ | |||
+ | Medián prvkov v poli je prvok, ktorý by po utriedení bol v strede poľa. | ||
+ | * Pre N prvkové pole je teda (N/2)-ty najmenší prvok. | ||
+ | |||
+ | Jednoduchý algoritmus: utriedime pole, vypíšeme A[n/2]. | ||
+ | * Zložitosť <math>O(n^2)</math> alebo <math>O(n\log n)</math> podľa použitého triedenia | ||
+ | |||
+ | Ukážeme si rýchlejší algoritmus, <math>O(n^2)</math> v najhoršom prípade, väčšina vstupov <math>O(n)</math> | ||
+ | * Zovšeobecníme problém: hľadáme prvok, ktorý by bbol v utriedenom pole na mieste ''k'' (''0<=k<n'') | ||
+ | * Podobný na Quicksort, ale niektoré časti nebudeme triediť | ||
+ | |||
+ | Postup: | ||
+ | * Pole si rozdelíme ako pri quicksorte. Nech prvá časť má ''x'' prvkov. Potom | ||
+ | ** ak ''k<x'', stačí nám hľadať ''k''-ty najmenší prvok v prvej časti | ||
+ | ** ak ''k>x'', potrebujeme nájsť ''(k-x)''-tý prvok v druhej časti | ||
+ | |||
+ | <pre> | ||
+ | int select(int A[], int l, int r, int k) { | ||
+ | /* vrati prvok, ktory by bol na pozicii l+k, keby sme A[l..r] utriedili */ | ||
+ | assert(0 <= k && k <= r - l); | ||
+ | if (l == r) return A[l]; | ||
+ | |||
+ | int pivot = divide(A, l, r); | ||
+ | if (k < pivot - l) select(A, l, pivot - 1, k); | ||
+ | else if (k > pivot - l) select(A, pivot + 1, r, k - pivot + l - 1); | ||
+ | else return A[pivot]; | ||
+ | }</pre> | ||
+ | |||
+ | == Ukazovateľ, smerník, pointer== | ||
+ | |||
+ | * Pamäť v počítači je rozdelená na dieliky, do ktorých sa zapisujú hodnoty premenných | ||
+ | * Väčšinou k týmto dielikom pristupujeme pomocou mien premenných | ||
+ | * Každý dielik má adresu (niečo ako poradové číslo) | ||
+ | * Ukazovateľ (resp. smerník alebo pointer) je premenná, ktorej hodnota je adresa iného dieliku pamäte | ||
+ | |||
+ | ===Definovanie premennej typu ukazovateľ=== | ||
+ | * Nový ukazovateľ je definovaný pomocou typu s pridanou <tt>*</tt> | ||
+ | <pre> | ||
+ | int i; // klasická celočíselná premenná | ||
+ | int *pi; // ukazovateľ na celočíselnú premennú | ||
+ | </pre> | ||
+ | * Typ ukazovateľa je teda rôzny pre rôzne typy premenných | ||
+ | ** nedá sa priraďovať navzájom napr. ukazovateľ na int a ukazovateľ na char | ||
+ | <pre> | ||
+ | int *pi; | ||
+ | char *pc; | ||
+ | pc = pi; // chyba | ||
+ | </pre> | ||
+ | |||
+ | === Operátor & (adresa) === | ||
+ | |||
+ | * Adresu nejakej premennej vieme zistiť operátorom & | ||
+ | * Tú potom môžeme priradiť do premennej typu ukazovateľ | ||
+ | * Ak do premennej typu ukazovateľ nič nepriradíme, má nedefinovanú hodnotu, ukazuje na náhodné miesto v pamäti, alebo niekde mimo | ||
+ | |||
+ | <pre> | ||
+ | int i; | ||
+ | int *pi = &i; | ||
+ | </pre> | ||
+ | |||
+ | Premenná ''pi'' teraz ukazuje na miesto, kde je uložené ''i'' | ||
+ | |||
+ | === Smerník, ktorý nikam neukazuje === | ||
+ | |||
+ | * Nulový ukazovateľ <tt>NULL</tt> - konštanta definovaná v knižnici <tt>cstdlib</tt> | ||
+ | * Je možné priradiť ho ukazovateľom na ľubovoľný typ | ||
+ | * Testovanie: <tt>if (pi == NULL) {...} </tt> | ||
+ | * V C++ môžeme používať namiesto NULL aj 0. | ||
+ | |||
+ | === Operátor * (dereferencovanie, údaje na adrese) === | ||
+ | |||
+ | * Ak máme ukazovateľ <tt>x</tt>, dáta z adresy, na ktorú ukazuje, získame ako <tt>*x</tt> | ||
+ | ** Môžeme ich aj meniť | ||
+ | <pre> | ||
+ | int i = 1; | ||
+ | int j = 2; | ||
+ | int *p = &i; // p ukazuje na i | ||
+ | cout << *p << endl; // vypise 1 | ||
+ | p = &j; // p ukazuje na j | ||
+ | cout << *p << endl; // vypise 2 | ||
+ | (*p)++; // zvysime j o 1 | ||
+ | cout << *p << endl; // vypise 3 | ||
+ | cout << j << endl; // vypise 3 | ||
+ | </pre> | ||
+ | |||
+ | === Príklady === | ||
+ | * Do premennej typu smerník na niečo môžeme priradiť iba adresu premennej typu niečo (alebo NULL). | ||
+ | <pre> | ||
+ | int i, *p_i; | ||
+ | |||
+ | p_i = &i; // spravne | ||
+ | p_i = &(i + 3); // zle, i+3 nie je premenna | ||
+ | p_i = &15; // zle, konstanta nema adresu | ||
+ | p_i = 15; // zle, priradovanie intu do adresy | ||
+ | i = p_i; // zle, priradovanie adresy do intu | ||
+ | i = &p_i; // zle, priradovanie adresy do intu | ||
+ | i = *p_i; // spravne ak p_i bol inicializovany | ||
+ | *p_i = 4; // spravne ak p_i bol inicializovany | ||
+ | </pre> | ||
+ | |||
+ | ===Smerníky na struct=== | ||
+ | |||
+ | Smerník môže ukazovať aj na structy | ||
+ | <pre> | ||
+ | struct kruh { | ||
+ | int x, y, r; | ||
+ | }; | ||
+ | kruh k; | ||
+ | k.x = 0; k.y = 0; k.r = 10; // kruh na suradnicicach (0,0) s polomerom 10 | ||
+ | kruh *p = &k; // smernik na strukturu typu kruh | ||
+ | (*p).x = 20; // dve formy priradovania do sucasti structu | ||
+ | p->y = 10; | ||
+ | // k je teraz na suradniciach (20,10) | ||
+ | </pre> | ||
+ | |||
+ | Pozor, bodka má vyššiu prioritu ako hviezdička | ||
+ | * preto <tt>*p.x</tt> znamená <tt>*(p.x)</tt>, teda vezmeme hodnotu v <tt>p.x</tt>, interpetujeme ju ako adresu a pozrieme sa, čo je na tejto adrese | ||
+ | ** aký typ by muselo mať <tt>p</tt> aby toto fungovalo? | ||
+ | * väčšinou chceme skôr <tt>(*p).x</tt>, čo znamená, že interpretujeme <tt>p</tt> ako adresu na struct, v ktorom je položka <tt>x</tt> | ||
+ | * keďže sa to často používa, existuje skratka <tt>p->x</tt> | ||
+ | |||
+ | == Parametre funkcií == | ||
+ | |||
+ | * '''Odovzdávanie hodnotou:''' nakopíruje hodnotu do novej lokálnej premennej | ||
+ | <pre> | ||
+ | void nasob(int x) { | ||
+ | x = 2*x; | ||
+ | cout << x; | ||
+ | } | ||
+ | int main(void){ | ||
+ | int x = 1; | ||
+ | nasob(x); // vypise 2 | ||
+ | cout << x; // vypise 1 | ||
+ | }</pre> | ||
+ | |||
+ | * '''Odovzdávanie referenciou:''' vytvorí nové meno pre existujúcu premennú, zmeny zostávajú aj po skončení | ||
+ | <pre> | ||
+ | void nasob(int &x) { | ||
+ | x = 2*x; | ||
+ | cout << x; | ||
+ | } | ||
+ | int main(void){ | ||
+ | int x = 1; | ||
+ | nasob(x); // vypise 2 | ||
+ | cout << x; // vypise 2 | ||
+ | }</pre> | ||
+ | |||
+ | * Nové: '''parameter je smerník''' | ||
+ | ** Volajúca funkcia pošle smerník, ten sa hodnotou skopíruje do lokálnej premennej | ||
+ | ** Ak ale robíme zmeny na adrese uloženej v parametri, majú dosah aj mimo funkcie | ||
+ | <pre> | ||
+ | void nasob(int *p_x) { | ||
+ | *p_x = *p_x * 2; | ||
+ | cout << *p_x; | ||
+ | } | ||
+ | int main(void){ | ||
+ | int x = 1; | ||
+ | nasob(&x); // vypise 2 | ||
+ | cout << x; // vypise 2 | ||
+ | }</pre> | ||
+ | * V čistom C neboli referencie, týmto spôsobom sa odovzdávajú premenné, ktoré sa majú meniť | ||
+ | ** Stále používané v C-čkových štandardných knižniciach | ||
+ | |||
+ | ===Funkcia swap s použitím ukazovateľov=== | ||
+ | <pre> | ||
+ | void swapP(int *p_x, int *p_y){ // ako parameter má dve adresy ukazujúce na celé čísla | ||
+ | int pom = *p_x; // do premennej pom nastavi hodnotu, ktorá je na adrese p_x | ||
+ | *p_x = *p_y; // hodnotu, ktorá je na adrese p_x zmení na hodnotu, ktorá je na adrese p_y | ||
+ | *p_y = pom; // hodnotu, ktorá je na adrese p_y nastaví na hodnotu premennej pom | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Ako budeme túto funkciu volať, ak chceme vymeniť hodnoty premenných i=5 a j=7? | ||
+ | * <tt>swapP(i, j);</tt> Zle. Vymieňame obsahy adries 5 a 7. Neskompiluje, lebo int sa nedá priradiť do int * | ||
+ | * <tt>swapP(*i, *j);</tt> Zle. Vymieňame obsahy adries uložených na adresách 5 a 7. Neskompiluje lebo operátor * sa nedá použiť na premenné typu int. | ||
+ | * <tt>swapP(&i, &j);</tt> '''Správne.''' Pošle adresy premenných i a j a funkcia swapP vymení hodnoty na týchto adresách. | ||
+ | |||
+ | == Dynamická alokácia a dealokácia pamäte: new, delete == | ||
+ | |||
+ | Doteraz sme videli | ||
+ | * '''globálne premenné''': majú vopred známu veľkosť a vyhradenú pamäť | ||
+ | * '''lokálne premenné''': majú vopred známu veľkosť, ale nevieme, ktoré funkcie sa použijú (a v prípade rekurzie koľkokrát), preto sa im pamäť priraďuje až pri volaní funkcie na '''zásobníku funkčných volaní (call stack)''' | ||
+ | |||
+ | Teraz si ukážeme, ako môže si program vyhradiť počas behu ďalšiu pamäť podľa potreby | ||
+ | * Používa sa na to príkaz '''new''' | ||
+ | * Pamäť sa vyhradí v oblasti zvanej '''heap (halda, hromada)''' | ||
+ | * Keď už pamäť nepotrebujeme, uvoľníme ju príkazom '''delete''' | ||
+ | * Uvoľnená pamäť môže byť znovu použitá pri ďalších volaniach new | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void){ | ||
+ | int * p; // p je lokalna premenna, zatial neinicializovana | ||
+ | p = new int; // vypytam si novy kus pamate dost velky na 1 int | ||
+ | // a adresu ulozim do p | ||
+ | |||
+ | *p = 50; // do alokovanej pamati ulozim hodnotu 50 | ||
+ | cout << *p << endl; // vypisem 50 | ||
+ | delete p; // alokovanu pamat uvolnim | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Príklad využitia new a delete === | ||
+ | * Máme štruktúru <tt>kruh</tt>, chceme od užívateľa načítať niekoľko kruhov | ||
+ | * Nevieme, koľko ich bude, tak si spravíme pole smerníkov a naalokujeme len potrebné kruhy | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | #include <cstdlib> | ||
+ | using namespace std; | ||
+ | |||
+ | struct kruh { | ||
+ | int x, y, r; | ||
+ | }; | ||
+ | |||
+ | const int maxN = 100; | ||
+ | const double pi = 3.1415926536; | ||
+ | |||
+ | int main(void) { | ||
+ | kruh * kruhy[maxN]; | ||
+ | int n; | ||
+ | cout << "Zadajte pocet kruhov: "; | ||
+ | cin >> n; | ||
+ | |||
+ | for (int i = 0; i < n; i++) { | ||
+ | cout << "Zadajte suradnice stredu a polomer kruhu " << i << ": "; | ||
+ | |||
+ | /* vytvorime novy kruh */ | ||
+ | kruh * novy = new kruh; | ||
+ | cin >> novy->x >> novy->y >> novy->r; | ||
+ | |||
+ | /* ulozime adresu noveho kruhu do pola */ | ||
+ | kruhy[i] = novy; | ||
+ | } | ||
+ | |||
+ | /* spracovavame zoznam kruhov, napr. spocitame sucet ich obsahov */ | ||
+ | double sucet = 0; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | sucet += kruhy[i]->r * kruhy[i]->r * pi; | ||
+ | } | ||
+ | cout << "Sucet obsahov kruhov: " << sucet << endl; | ||
+ | |||
+ | /* na konci zmazeme kruhy */ | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | delete kruhy[i]; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | Všimnite si: | ||
+ | * <tt>kruh * kruhy[maxN];</tt> vytvorí pole smerníkov na <tt>kruh</tt> s <tt>maxN</tt> prvkami | ||
+ | * Prístup k polomeru ''i''-teho kruhu: <tt>kruhy[i]->r</tt> | ||
+ | |||
+ | '''Problém:''' pole <tt>kruhy</tt> má aj tak vopred stanovenú veľkosť, je však možné alokovať aj polia dynamickej veľkosti. | ||
+ | |||
+ | '''Cvičenie:''' Prečo nemôžeme v programe zmeniť načítanie takto? | ||
+ | <pre> | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | cout << "Zadajte suradnice stredu a polomer kruhu " << i << ": "; | ||
+ | |||
+ | /* nacitame kruh */ | ||
+ | kruh novy; | ||
+ | cin >> novy.x >> novy.y >> novy.r; | ||
+ | |||
+ | /* ulozime adresu noveho kruhu do pola */ | ||
+ | kruhy[i] = &novy; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | == Polia a smerníky == | ||
+ | |||
+ | * Polia a smerníky v jazyku C spolu veľmi úzko súvisia. | ||
+ | * Pole sa správa (väčšinou) ako ukazovateľ na jeho prvý prvok. | ||
+ | |||
+ | Vezmime tento jednoduchý program s funkciou, ktorá vypíše obsah poľa | ||
+ | <pre> | ||
+ | void vypisPole(int a[], int n) { | ||
+ | for(int i=0; i<n; i++) { | ||
+ | cout << a[i]; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | int a[3] = {0,1,2}; | ||
+ | vypisPole(a, 3); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Hlavičku funkcie môžeme zmeniť takto a všetko bude ďalej fungovať: | ||
+ | <pre> | ||
+ | void vypisPole(int *a, int n) { | ||
+ | </pre> | ||
+ | |||
+ | Tiež do premennej typu int * môžeme priradiť pole. Premenná bude potom fungovať ako smerník na prvý (presnejšie nultý) prvok poľa. | ||
+ | <pre> | ||
+ | int a[3] = {0,1,2}; | ||
+ | int *b = a; | ||
+ | vypisPole(b, 3); | ||
+ | </pre> | ||
+ | |||
+ | === Alokovanie jednorozmerného poľa === | ||
+ | |||
+ | * Operátor <tt>new</tt> má verziu, ktorá alokuje pole zadanej dĺžky | ||
+ | * Napr. <tt>int *a = new int[10];</tt> | ||
+ | * Výsledok priradíme do ukazovateľa, odvtedy používame ako pole | ||
+ | * Uvoľníme operátorom <tt>delete[]</tt>. | ||
+ | * Veľkosť poľa v <tt>new</tt> nemusí byť konštantná, môžeme si naalokovať také veľké pole, ako potrebujeme | ||
+ | |||
+ | Napríklad od užívateľa načítame počet čísel, vytvoríme pole príslušnej veľkosti a načítame do neho čísla: | ||
+ | * Podobne by sa dal zmeniť aj program s kruhmi vyššie | ||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | cout << "Zadaj pocet cisel: "; | ||
+ | int n; | ||
+ | cin >> n; | ||
+ | int *a = new int[n]; // vytvorime pole | ||
+ | |||
+ | for (int i = 0; i < n; i++) { // nacitame data | ||
+ | cout << "Zadaj cislo " << i << ": "; | ||
+ | cin >> a[i]; | ||
+ | } | ||
+ | for (int i = n-1; i >=0; i--) { // spracujeme, napr. vypiseme odzadu | ||
+ | cout << a[i] << endl; | ||
+ | } | ||
+ | delete[] a; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | == Kontrola programov nástrojom valgrind== | ||
+ | * C-čko pri použití polí a smerníkov nekontroluje, či ich používame správne | ||
+ | * Chybou v programe sa nám teda ľahko môže stať, že čítame alebo píšeme mimo alokovanej pamäte | ||
+ | * Takéto chyby sa niekedy ťažko hľadajú | ||
+ | * V Linuxe nám na hľadanie takýchto chýb pomôže nástroj [http://valgrind.org/ valgrind] | ||
+ | |||
+ | * Keď v Netbeans spustíme nástroj Build (ikonka kladivka; spúšťa sa tiež automaticky pred spustením programu), Netbeans zavolá kompilátor a vytvorí spustiteľný súbor | ||
+ | * Tento spustiteľný súbor nájdeme v adresári typu <tt>NetBeansProjects/meno_projektu/dist/Debug/GNU-Linux-x86/</tt>, volá sa rovnako ako projekt | ||
+ | * V Linuxe si ho môžeme na príkazovom riadku spustiť aj mimo prostredia Netbeans, stačí napísať <tt>NetBeansProjects/meno_projektu/dist/Debug/GNU-Linux-x86/meno_projektu</tt> | ||
+ | * Namiesto toho ho môžeme spustiť <tt>valgrind NetBeansProjects/meno_projektu/dist/Debug/GNU-Linux-x86/meno_projektu</tt> | ||
+ | * Nástroj valgrind bude náš program pozorne sledovať a keď robí divné veci v pamäti, vypíše nám o tom správu | ||
+ | |||
+ | Nasledujúci program vypisuje neinicializovanú premennú i (knižnice pre krátkosť vynechávame): | ||
+ | <pre> | ||
+ | int main(void) { | ||
+ | int i; cout << i << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | Valgrind vypíše okrem iného | ||
+ | <pre> | ||
+ | ==6021== Conditional jump or move depends on uninitialised value(s) | ||
+ | ==6021== at 0x4EBAD23: std::ostreambuf_iterator<char, std::char_traits<char> > std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::_M_insert_int<long>(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.16) | ||
+ | ==6021== by 0x4EBB065: std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::do_put(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.16) | ||
+ | ==6021== by 0x4EC64DC: std::ostream& std::ostream::_M_insert<long>(long) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.16) | ||
+ | ==6021== by 0x40079A: main (main.cpp:7) | ||
+ | ==6021== | ||
+ | ==6021== Use of uninitialised value of size 8 | ||
+ | ==6021== at 0x4EBA823: ??? (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.16) | ||
+ | ==6021== by 0x4EBAD47: std::ostreambuf_iterator<char, std::char_traits<char> > std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::_M_insert_int<long>(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.16) | ||
+ | ==6021== by 0x4EBB065: std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::do_put(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.16) | ||
+ | ==6021== by 0x4EC64DC: std::ostream& std::ostream::_M_insert<long>(long) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.16) | ||
+ | ==6021== by 0x40079A: main (main.cpp:7) | ||
+ | </pre> | ||
+ | |||
+ | Nasledujúci program zapisuje do pamäte, na ktorú ukazuje smerník s neinicializovnaou hodnotou | ||
+ | <pre> | ||
+ | int main(void) { | ||
+ | int *p; | ||
+ | *p = 7; | ||
+ | cout << *p << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | <pre> | ||
+ | ==6125== Use of uninitialised value of size 8 | ||
+ | ==6125== at 0x400790: main (main.cpp:7) | ||
+ | ==6125== | ||
+ | ==6125== Invalid write of size 4 | ||
+ | ==6125== at 0x400790: main (main.cpp:7) | ||
+ | ==6125== Address 0x0 is not stack'd, malloc'd or (recently) free'd | ||
+ | ==6125== | ||
+ | ==6125== | ||
+ | ==6125== Process terminating with default action of signal 11 (SIGSEGV) | ||
+ | ==6125== Access not within mapped region at address 0x0 | ||
+ | ==6125== at 0x400790: main (main.cpp:6) | ||
+ | </pre> | ||
+ | |||
+ | Tento program sa pokúša odalokovať pamäť, ktorá nebola alokovaná | ||
+ | <pre> | ||
+ | int main(void) { | ||
+ | int i = 7; | ||
+ | int *p = &i; | ||
+ | delete p; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | <pre> | ||
+ | ==6579== Invalid free() / delete / delete[] / realloc() | ||
+ | ==6579== at 0x4C2A4BC: operator delete(void*) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so) | ||
+ | ==6579== by 0x400696: main (main.cpp:8) | ||
+ | ==6579== Address 0x7ff00097c is on thread 1's stack | ||
+ | </pre> | ||
+ | |||
+ | Ani valgrind nemusí nájsť všetky chyby, napr. tu sa k premennej správame ako ku poľu a píšeme mimo, ale valgrind si to nevšimne: | ||
+ | <pre> | ||
+ | int main(void) { | ||
+ | int i; | ||
+ | int *p = &i; | ||
+ | p[2] = 7; | ||
+ | cout << p[2] << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | Ak index 2 nahradíme 2000, valgrind už vypíše chybu... | ||
+ | |||
+ | ==Zhrnutie== | ||
+ | * Smerník, ukazovateľ, pointer je premenná, v ktorej je uložená adresa nejakého pamäťového miesta | ||
+ | * Typ smerníku určuje, na aký typ premennej by mal ukazovať, napr. <tt>int *p</tt> | ||
+ | * Do smerníku môžeme priradiť <tt>NULL</tt>, adresu nejakej premennej (<tt>&i</tt>), novoalokovanú pamäť pomocou <tt>new</tt>, iný smerník toho istého typu | ||
+ | * Ku políčku, na ktoré ukazuje smerník ''p'', pristupujeme pomocou (<tt>*p</tt>) | ||
+ | * Pole je vlastne smerník na svoj prvý (nultý) prvok | ||
+ | * Pole určitej dĺžky (ktorá je známa až počas behu) alokujeme pomocou <tt>new typ[pocet]</tt> | ||
+ | * Pamäť alokovanú cez <tt>new</tt> by sme mali odalokovať pomocou <tt>delete</tt> alebo <tt>delete[]</tt> (podľa toho, či to bolo pole) | ||
+ | * Pri práci so smerníkmi ľahko spravíme chybu, pomôcť nám môže valgrind | ||
+ | =Cvičenia 6= | ||
+ | ==Backtracking, prehľadávanie s návratom== | ||
+ | * Napíšte rekurzívny program, ktorý pre dané čísla ''n'' a ''k'' (''1<=k<=n'') vypíše všetky podmnožiny veľkosti ''k'' množiny ''{0..n-1}''. Na rozdiel od variácií nám v podmnožine nezáleží na poradí (napr. ''{0,1} = {1,0}''), prvky teda budeme vždy vypisovať od najmenšieho po najväčší. Napr. pre ''n=3'' a ''k=2'' vypíšte | ||
+ | <pre> | ||
+ | 0 1 | ||
+ | 0 2 | ||
+ | 1 2 | ||
+ | </pre> | ||
+ | |||
+ | * Napíšte program, ktorý pre dané čísla ''n'', ''k'' a ''S'' vypíše všetky ''k''-tice čísel z množiny ''{0..n-1}'', ktorých súčet je aspoň ''S''. Prehľadávanie zastavte vždy, keď nie je možné súčet ''S'' dosiahnuť, ani keby všetky zvyšné čísla mali hodnotu ''n-1''. Napríklad pre ''k=3'', ''n=3'', ''S=5'' vypíšte | ||
+ | <pre> | ||
+ | 1 2 2 | ||
+ | 2 1 2 | ||
+ | 2 2 1 | ||
+ | 2 2 2 | ||
+ | </pre> | ||
+ | |||
+ | ==Rekurzívne vykresľovanie korytnačou grafikou== | ||
+ | |||
+ | Napíšte rekurzívny program, ktorý bude vykresľovať strom korytnačou grafikou. Strom má dva parametre: veľkosť ''d'' a stupeň ''n''. Strom stupňa 0 je prázdna množina. Strom stupňa ''n'' pozostáva z kmeňa, ktorý tvorí úsečka dĺžky ''n'' a z dvoch podstromov, ktoré sú stromy stupňa ''n-1'', veľkosti ''d/2'' a otočené o 30 stupnov doľava a doprava od hlavnej osi stromu (pozri obrázky nižšie). Pri vykresľovaní stromu sa s korytnačkou vráťte na miesto a otočenie, v ktorom ste začali (bez toho by sa len ťažko písala rekuzívna funkcia). Korytnačka teda prejde po každej vetve dvakrát, raz smerom dopredu a raz naspäť. | ||
+ | |||
+ | <gallery widths=155 heights=115> | ||
+ | Image:PROG-C8-strom1.png|Strom stupňa 1 | ||
+ | Image:PROG-C8-strom2.png|Strom stupňa 2 | ||
+ | Image:PROG-C8-strom3.png|Strom stupňa 3 | ||
+ | Image:PROG-C8-strom5.png|Strom stupňa 5 | ||
+ | </gallery> | ||
+ | |||
+ | ==Grayov kód== | ||
+ | * Vypíšte všetky ''k''-tice binárnych hodnôt 0 a 1 tak, aby sa každé dve po sebe idúce ''k''-tice sa líšili na najviac jednom mieste a tiež posledná ''k''-tica s prvou, ako v tomto príklade: | ||
+ | <pre> | ||
+ | 000 | ||
+ | 001 | ||
+ | 011 | ||
+ | 010 | ||
+ | 110 | ||
+ | 111 | ||
+ | 101 | ||
+ | 100 | ||
+ | </pre> | ||
+ | Takáto postupnosť sa nazýva Grayov kód. Ako vidno v tomto príklade, Grayov kód stupňa ''k'' sa dá zostaviť rekurzívne: horná polovica kódu stupňa ''k'' je Grayov kód stupňa ''k''-1 s cifrou 0 pridanou na najľavejšiu pozíciu a druhá polovica kódu stupňa ''k'' je kód stupňa ''k''-1 vypísaný odzadu s cifrou 1 pridanou na najľavejšiu pozíciu. Môžete použiť nasledovnú hlavičku rekurzívnej funkcie: | ||
+ | <pre> | ||
+ | void gray(int a[], int k, int i, bool reverse) { | ||
+ | /* Prvych i pozicii v poli a obsahuje hodnoty 0 a 1, | ||
+ | * Do zvysnych k-i postupne dosadte Grayov kod stupna k-i | ||
+ | * a zakazdym vypiste cele pole. | ||
+ | * Ak reverse = true, Grayov kod generujte odzadu. */ | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Čo vypíše program?== | ||
+ | Bez použitia počíta skúste zistiť, čo vypíše nasledujúci program. Pomôcka: vybudujte si tabuľku hodnôt funkcie ''f'' pre rôzne ''n'' a vypĺňajte ju od najmenších hodnôt ''n'' k väčším. Delenie dvomi v programe je celočíselné, vráti teda dolnú celú časť. | ||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | int f(int n) { | ||
+ | if(n<=5) return n; | ||
+ | else { | ||
+ | return (f(n-1) + f(n-3))/2; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | |||
+ | int main(void) { | ||
+ | for(int i=1; i<=10; i++) { | ||
+ | cout << i << ": " << f(i) << endl; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | =DÚ5= | ||
+ | {{MDU|5|4465}} max. 10 bodov, termín odovzdania pondelok 29.10. o 22:00 | ||
+ | |||
+ | Cieľom tejto domácej úlohy je precvičiť si prácu s rekurziou. | ||
+ | |||
+ | Napíšte program, ktorý pomocou korytnačej grafiky a rekurzie vykreslí fraktálnu krivku, ktorá je pre stupne 1,2 a 5 zobrazená na obrázkoch nižšie. Pre stupeň 1 má táto krivka tvar T-čka, pričom vodorovná aj zvislá úsečka majú dĺžku ''d''. Pre stupeň ''n'' z každého konca vodorovnej časti T-čka zavesíme fraktály stupňa ''n-1'' a veľkosti ''d/2'', pričom jeden je otočený nahor a jeden nadol. (Fraktál stupňa 0 môžeme pre úplnosť zadefinovať ako prázdnu množinu.) | ||
+ | |||
+ | V programe si zadefinujte nasledujúce konštanty, ktorých zmenou môžete ovplyvniť správanie sa programu: | ||
+ | <pre> | ||
+ | const int width = 400; /* rozmery obrázku */ | ||
+ | const int height = 400; | ||
+ | |||
+ | const double d = 200; /* dĺžka úsečiek T-čka na najvyššej úrovni rekurzie */ | ||
+ | const int n = 5; /* stupeň fraktálu */ | ||
+ | const double wait = 0.2; /* koľko korytnačka čaká po každom ťahu */ | ||
+ | </pre> | ||
+ | Korytnačka by mala začať v strede spodnej strany obrázku natočená nahor. Po nakreslení celého fraktálu by mala skončiť na tom istom mieste a s tým istým natočením (po každej čiare prejde dvakrát -- tam aj späť). Táto podmienka vám pomôže správne pospájať fraktály stupňa ''n-1'' do fraktálu stupňa ''n''. | ||
+ | |||
+ | Pomôcky: | ||
+ | * Doporučujeme program najskôr odladiť pre stupeň ''n=1'' a ''2'' a dlhšie čakanie (napr. <tt>wait=2</tt>), až potom skúšať vyššie hodnoty ''n'' a kratší <tt>wait</tt>. | ||
+ | * Inšpirovať sa môžete programom na Kochovu krivku z [[#Prednáška 9|prednášky 9]]. | ||
+ | * Ak dáme korytnačke ako argument do <tt>turnLeft</tt> záporné číslo, bude sa otáčať o toľko stupňov doprava. Ak jej do <tt>forward</tt> dáme záporné číslo, pôjde o toľko dozadu. | ||
+ | |||
+ | <gallery widths=200 heights=200> | ||
+ | Image:PROG-DU8-1.png|Krivka stupňa 1 | ||
+ | Image:PROG-DU8-2.png|Krivka stupňa 2 | ||
+ | Image:PROG-DU8-5.png|Krivka stupňa 5 | ||
+ | </gallery> | ||
+ | =Prednáška 13= | ||
+ | == Práca so súbormi == | ||
+ | |||
+ | * Doteraz sme na načítavanie a vypisovanie dát používali výhradne konzolu (obrazovku/klávesnicu). | ||
+ | * V praxi často chceme spracovávať dáta uložené v súboroch. | ||
+ | * Zameriame sa na súbory v textovom formáte, pracuje sa s nimi podobne ako s konzolou. | ||
+ | * V C++ existujú ekvivalenty <tt>cin >></tt> a <tt>cout << </tt> aj pre súbory, nájdete ich v knižnici fstream. | ||
+ | |||
+ | == Práca s konzolou v Cčku: printf a scanf== | ||
+ | |||
+ | * Teraz sa naučíme, ako sa so súbormi (a s konzolou) pracuje v klasickom Cčku. | ||
+ | * Príkazy printf a scanf sú v knižnici <tt>cstdio</tt> | ||
+ | |||
+ | === printf=== | ||
+ | * Funkcia printf vypisuje formátovaný text na konzolu. | ||
+ | * Použitie: printf(format, hodnota1, hodnota2,...) | ||
+ | * Formátovací reťazec obsahuje bežné znaky, ktoré sa priamo vytlačia a špeciálne formátovacie príkazy začínajúce %, ktoré určujú, ako formátovať jednotlivé hodnoty | ||
+ | * Napr. predpokladajme, že x a y sú celočíslené premenné s hodnotami 10 a 20. Príkaz printf("bod (%d,%d)\n", x, y) vypíše "bod (10,20)" a koniec riadku. | ||
+ | |||
+ | Príklady formátovacích reťazcov: | ||
+ | * %c - znak (character) | ||
+ | * %s - reťazec (string) | ||
+ | * %d - celé číslo (integer) | ||
+ | * %f - reálne číslo (double) | ||
+ | * %e - reálne čislo vo vedeckej notácii napr. 5.4e7 | ||
+ | * %% - vypíše znak % | ||
+ | Pozor, typy výrazov v zozname hodnôt musia sedieť s formátovacím reťazcom | ||
+ | |||
+ | === Formátovanie=== | ||
+ | |||
+ | Nastavovanie šírky a počtu desatinných miest | ||
+ | * %.2f - vypíše na 2 desatinné miesta | ||
+ | * %4d - ak má číslo menej ako 4 znaky, doplní vľavo medzery | ||
+ | * %04d - podobne, ale dopĺňa nuly | ||
+ | |||
+ | Na predáške o stringoch sme videli formatovanie vysledku (zarovnanie doľava) pomocou vlastnej funkcie, ktorá číslo pripravila do pomocného poľa znakov (stringu). | ||
+ | |||
+ | <pre> | ||
+ | int main(void) { | ||
+ | char A[maxN]; | ||
+ | int n = 12; | ||
+ | for (int i = 1; i <= n; i++) { | ||
+ | int x = factorial(i); | ||
+ | formatInt(i, A, 2); | ||
+ | cout << A << "! = "; | ||
+ | formatInt(x, A, 10); | ||
+ | cout << A << endl; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Vďaka formátovacím reťazcom v printf vieme tento program prepísať jednoduchšie. | ||
+ | |||
+ | <pre> | ||
+ | int main(void) { | ||
+ | int n = 12; | ||
+ | for (int i = 1; i <= n; i++) { | ||
+ | printf("%2d",i); | ||
+ | printf("! = "); | ||
+ | printf("%10d\n",factorial(i)); | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Dokonca by nám v cykle stačil jediný príkaz <tt>printf("%2d! = %10d\n",i,factorial(i));</tt> | ||
+ | * Podobne vieme doplniť aj úvodné nuly - napríklad, keď by sme radi v dátume doplnili deň a mesiac na dvojciferné čísla a rok na štvorciferné. | ||
+ | <pre> | ||
+ | void showDate(int d, int m, int y){ | ||
+ | printf("%02d.%02d.%04d",d,m,y); | ||
+ | } | ||
+ | |||
+ | int main(void){ | ||
+ | showDate(1,1,1990); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === scanf=== | ||
+ | * Funkcia scanf(format, premenna1, premenna2,...) načítava dáta z konzoly | ||
+ | ** Napr. scanf("%d", &x) načíta celočíselnú hodnotu do premennej x. | ||
+ | ** Všimnite si, že zatiaľ čo do printf sa vkladajú priamo hodnoty (premenné), scanf potrebuje smerníky na premenné, pretože ich modifikuje. | ||
+ | |||
+ | Jednoduché načítanie mena a veku. | ||
+ | <pre> | ||
+ | char str [80]; | ||
+ | int i; | ||
+ | |||
+ | printf ("Enter your family name: "); | ||
+ | scanf ("%s",str); | ||
+ | printf ("Enter your age: "); | ||
+ | scanf ("%d",&i); | ||
+ | printf ("Mr. %s , %d years old.\n",str,i); | ||
+ | </pre> | ||
+ | |||
+ | * Formátovací reťazec obsahuje: | ||
+ | ** Špecifikáciu formátov načítávaných premenných (začínajú znakom %) - podobne ako u printf | ||
+ | ** Biele znaky ("whitespace" - medzery, konce riadkov, tabulátory) - funkcia číta a ignoruje všetky biele znaky pred ďalším nebielym znakom (jeden biely znak umožní ľubovoľný počet bielych znakov na vstupe) | ||
+ | ** Ostatné znaky formátovacieho reťazca musia presne zodpovedať vstupu | ||
+ | |||
+ | Načítávanie dátumu. | ||
+ | <pre> | ||
+ | int d,m,y; | ||
+ | |||
+ | printf("Enter the date: "); | ||
+ | scanf("%d.%d.%d",&d,&m,&y); | ||
+ | printf("Year: %d\n",y); | ||
+ | </pre> | ||
+ | |||
+ | * Funkcia vracia počet úspešne priradených hodnôt (načítáva kým nedôjde k chybe vstupu alebo chybe konverzie na príslušný typ premennej). V prípade chyby hneď na začiatku vracia hodnotu EOF (napríklad hneď na začiatku končí vstup). | ||
+ | |||
+ | Postupné sčítávanie čísel zo vstupu. | ||
+ | <pre> | ||
+ | double sum, v; | ||
+ | |||
+ | sum = 0; | ||
+ | while (scanf("%lf", &v) == 1) | ||
+ | printf("%.2f\n", sum += v); | ||
+ | </pre> | ||
+ | |||
+ | === Kontrola správneho vstupu === | ||
+ | |||
+ | * Určenie, či máme na vstupe potrebný počet čísel na nejakú operáciu | ||
+ | |||
+ | Program načíta zo súboru tri double čísla a vypíše ich na obrazovku - testuje, či sú v súbore 3 čísla | ||
+ | |||
+ | <pre> | ||
+ | int main() { | ||
+ | double x, y, z; | ||
+ | |||
+ | if(scanf("%lf %lf %lf", &x, &y, &z) == 3) | ||
+ | printf("%lf \n", x + y + z); | ||
+ | else | ||
+ | printf("Neboli nacitane 3 realne cisla\n."); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Kontrola celého čísla, záporného čísla, desatinného čísla, pre vhodné číselné sústavy kontrola čísla | ||
+ | * Pomocou scanf, však vieme robiť iba jednoduché kontroly chýb. Môže byť preto lepšie najprv načítať zo vstupu reťazec pomocou gets a prečítaný string následne spracovať. Ale o tom až na ďalšej prednáške. | ||
+ | |||
+ | == Práca so súborom: FILE *, fopen, fclose, fprintf, fscanf== | ||
+ | |||
+ | Základný dátový typ: FILE * | ||
+ | * ukazovateľ (pointer - *) na objekt typu FILE | ||
+ | * dodržať veľké písmená (FILE *, nie file *) | ||
+ | * obsahuje údaje o otvorenom súbore, s ktorým práve pracujeme | ||
+ | * definícia premennej f pre prácu so súborom <tt>FILE *f;</tt> (pre viac premenných <tt>FILE *fr, *fw;</tt>) | ||
+ | |||
+ | Otvorenie súboru pre čítanie | ||
+ | * <tt>fr = fopen("vstup.txt", "r");</tt> | ||
+ | * Otvorí súbor s menom vstup.txt (môžeme samozrejme použiť aj iné meno, prípadne pridať cestu) | ||
+ | * Ak taký súbor neexistuje alebo sa nedá otvoriť, do fr priradí NULL | ||
+ | * Z takto otvoreného súboru môžeme čítať napr. pomocou fscanf, ktorá je analógom scanf | ||
+ | * Napr. <tt>fscanf(fr, "%d", &x);</tt> | ||
+ | |||
+ | Otvorenie súboru pre zápis | ||
+ | * <tt>fw = fopen("vystup.txt", "w");</tt> | ||
+ | * Vytvorí súbor s menom vystup.txt. Ak už existoval, zmaže jeho obsah. | ||
+ | * Ak sa nepodarí súbor otvoriť, do fw priradí NULL. | ||
+ | * Do takto otvoreného súboru môžeme zapisovať napr. pomocou fprintf, ktorá je analógom printf | ||
+ | * Napr. <tt>fprintf(fw, "%d", x);</tt> | ||
+ | |||
+ | Zatvorenie súboru | ||
+ | * Keď už nebudeme zo súboru čítať ani doňho zapisovať, uzatvoríme ho pomocou <tt>fclose(f);</tt> | ||
+ | * Nespoliehať sa, že po skončení programu sa súbor automaticky zavrie súbor | ||
+ | * Počet súčasne otvorených súborov je obmedzený | ||
+ | * Pri zavretí sa zapíše buffer do súboru, predídeme tým strate dát pri páde programu | ||
+ | * Ak sa nepodarí otvoriť súbor - vracia fclose() konštantu EOF | ||
+ | |||
+ | V súbore <tt>vstup.txt</tt> máme niekoľko riadkov, prvý obsahuje názov výstupného súboru a každý ďalší obsahuje názov súboru (označme f) a číslo (označme x). Do výstupného súboru chceme pre každý riadok zo vstupu vypísať zo súboru f prvých x čísel. | ||
+ | |||
+ | Príklad: Súbor <tt>a.txt</tt> obsahuje čísla 1..9, súbor <tt>b.txt</tt> obsahuje čísla 10,20..90 a súbor <tt>c.txt</tt> obsahuje čísla 100,200..900. | ||
+ | |||
+ | Pre vstupný súbor <tt>vstup.txt</tt> | ||
+ | <pre> | ||
+ | vystup.txt | ||
+ | a.txt 2 | ||
+ | b.txt 1 | ||
+ | a.txt 3 | ||
+ | </pre> | ||
+ | |||
+ | Očakávame výstup v súbore <tt>vystup.txt</tt> | ||
+ | <pre> | ||
+ | 1 2 10 1 2 3 | ||
+ | </pre> | ||
+ | |||
+ | * Otvoríme vstupný súbor a prečítame z neho názov výstupného súboru | ||
+ | * Otvoríme aj výstupný súbor a postupne budeme zo vstupu čítať dvojice <tt>subor cislo</tt>. | ||
+ | ** Každý načítaný súbor si otvoríme, vypíšeme z neho čísla a zatvoríme. | ||
+ | * Na konci zavrieme vstup aj výstup. | ||
+ | * Kontrolujeme existenciu súborov aj čísel v nich. | ||
+ | |||
+ | <pre> | ||
+ | int main() { | ||
+ | FILE *fr1, *fr2, *fw; | ||
+ | char str[20]; | ||
+ | int kolko,cislo; | ||
+ | |||
+ | fr1=fopen("vstup.txt","r"); | ||
+ | if (!fr1) return -1; | ||
+ | if (fscanf(fr1,"%s",str)!=1) return -1; | ||
+ | fw=fopen(str,"w"); | ||
+ | if (!fw) return -1; | ||
+ | while (!feof(fr1)){ | ||
+ | fscanf(fr1,"%s %d",str,&kolko); | ||
+ | fr2=fopen(str,"r"); | ||
+ | if (!fr2) return -1; | ||
+ | for (int i=0; i<kolko; i++){ | ||
+ | if (fscanf(fr2,"%d ",&cislo)!=1) return -1; | ||
+ | fprintf(fw,"%d ",cislo); | ||
+ | } | ||
+ | fclose(fr2); | ||
+ | } | ||
+ | fclose(fr1); | ||
+ | fclose(fw); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Štandardný vstup a výstup ako súbor === | ||
+ | |||
+ | C pracuje s klávesnicou a obrazovkou ako so súborom - v stdio.h sú definované dva konštantné ukazovatele stdin a stdout. | ||
+ | <pre> | ||
+ | FILE *stdin, *stdout; | ||
+ | </pre> | ||
+ | |||
+ | * označujú štandardný vstupný/výstupný prúd (standard intput-output stream) | ||
+ | * stdin a stdout môžu byť použité v programe ako argumenty operácií so súbormi <tt>fscanf(stdin,"%d",&x)</tt> | ||
+ | |||
+ | Vďaka tomu, že aj štandardný vstup a výstup sa dajú používať v takým istým spôsobom ako súbory je, že si používateľ môže vybrať, s čím chce pracovať. | ||
+ | |||
+ | V prípade, že by sme v predchádzajúcom príklade chceli na základe prvého riadku vstupu umožniť aj umožniť zapisovanie na štandardný výstup (napríklad ak je na vstupe "-"), stačilo by pred otvorením výstupu overiť túto alternatívu a ďalej pracovať rovnako. | ||
+ | |||
+ | <pre> | ||
+ | ... | ||
+ | if (fscanf(fr1,"%s",str)!=1) return -1; | ||
+ | if (strcmp(str,"-")==0) fw=stdout; | ||
+ | else fw=fopen(str,"w"); | ||
+ | if (!fw) return -1; | ||
+ | ... | ||
+ | </pre> | ||
+ | |||
+ | === Testovanie konca súboru === | ||
+ | |||
+ | * Pomocou symbolickej konštanty EOF | ||
+ | ** definovaná v stdio.h, väčšinou má hodnotu -1 | ||
+ | * Pomocou makra feof() | ||
+ | |||
+ | == Binárne súbory == | ||
+ | |||
+ | Ako ukladať desatinné čísla? | ||
+ | * Strata presnosti | ||
+ | A čo väčšie štruktúry? | ||
+ | * Nanútime pre všetkých spôsob načítávania | ||
+ | |||
+ | Alternatívne riešenie je použitie binárnych súborov, kde sa neukladáme textovú reprezentáciu ale reprezentáciu, ktorá zodpovedá uloženiu v pamäti. | ||
+ | |||
+ | === fwrite === | ||
+ | |||
+ | * Funkcia <tt>fwrite( const void * ptr, size_t size, size_t count, FILE * f );</tt> do súboru <tt>f</tt> zapíše <tt>count</tt> položiek veľkosti <tt>size</tt> ležiacich v pamäti od adresy <tt>ptr</tt>. | ||
+ | ** Funkcia vráti počet reálne zapísaných položiek. | ||
+ | ** Súbor f musí byť otvorený na zápis. | ||
+ | * Typickým príkladom je, že mám určité položky uložené v poli. Potom začiatok pamäte je určený smerníkom. | ||
+ | |||
+ | Príklad: Chceme uložiť pole reálnych čísel (napríklad odmocniny z čísel 0..100). | ||
+ | |||
+ | <pre> | ||
+ | int main() { | ||
+ | |||
+ | double a[100]; | ||
+ | FILE *f; | ||
+ | double b[5]; | ||
+ | |||
+ | |||
+ | for (int i=0; i<100; i++) a[i]=sqrt(i); | ||
+ | |||
+ | f=fopen("binarny.dat","w"); | ||
+ | fwrite(a,sizeof(double),100,f); | ||
+ | fclose(f); | ||
+ | |||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === fread === | ||
+ | |||
+ | * fread funguje podobne ako fwrite. | ||
+ | * Funkcia <tt>fread (void * ptr, size_t size, size_t count, FILE * f );</tt> zo súboru <tt>f</tt> prečíta <tt>count</tt> položiek veľkosti <tt>size</tt> a uloží ich do pamäti od adresy <tt>ptr</tt>. | ||
+ | |||
+ | Ak by sme si chceli napríklad overiť, že súbor z predchádzajúceho príkladu naozaj obsahuje na 4. mieste číslo 2, stačí si do poľa <tt>b</tt> uložiť prvých 5 položiek zo súboru <tt>binarny.dat</tt> a skontrolovať prvok <tt>b[4]</tt>. | ||
+ | |||
+ | <pre> | ||
+ | int main() { | ||
+ | |||
+ | FILE *f; | ||
+ | double b[5]; | ||
+ | |||
+ | f=fopen("binarny.dat","r"); | ||
+ | fread(b,sizeof(double),5,f); | ||
+ | printf("%f\n",b[4]); | ||
+ | fclose(f); | ||
+ | } | ||
+ | |||
+ | </pre> | ||
+ | |||
+ | == Spracovávanie vstupu == | ||
+ | |||
+ | V prípade, že máme v súbore zaručené čísla, bežne bývajú v niektorom z nasledujúcich formátov: | ||
+ | * N (počet čísel) a za tým N čísel | ||
+ | <pre> | ||
+ | FILE *f; | ||
+ | int a[100],N,i,x; | ||
+ | int sum=0; | ||
+ | |||
+ | f=fopen("vstup.txt","r"); | ||
+ | if (!f) return -1; | ||
+ | |||
+ | if (fscanf(f,"%d ",&N)!=1) return -1; | ||
+ | |||
+ | for (int i=0; i<N; i++){ | ||
+ | if (fscanf(f,"%d ",&a[i])!=1) return -2; | ||
+ | sum+=a[i]; | ||
+ | } | ||
+ | |||
+ | printf("%d\n",sum); | ||
+ | fclose(f); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * postupnosť čísel ukončená -1 alebo inou špeciálnou hodnotu | ||
+ | <pre> | ||
+ | int main() { | ||
+ | |||
+ | FILE *f; | ||
+ | int a[100],N,i,x; | ||
+ | int sum=0; | ||
+ | |||
+ | f=fopen("vstup.txt","r"); | ||
+ | if (!f) return -1; | ||
+ | |||
+ | i=0; | ||
+ | if (fscanf(f,"%d ",&x)!=1) return -2; | ||
+ | while (x!=-1){ | ||
+ | a[i++]=x; | ||
+ | sum+=x; | ||
+ | if (fscanf(f,"%d ",&x)!=1) return -2; | ||
+ | } | ||
+ | |||
+ | printf("%d\n",sum); | ||
+ | fclose(f); | ||
+ | } | ||
+ | |||
+ | </pre> | ||
+ | |||
+ | * čísla až kým neskončí súbor | ||
+ | ** teoreticky by sme mohli kontrolovať či sa správne načítalo, teda <tt>while (fscanf(f,"%d ",&x)==1)){...}</tt>, ale nerozoznali by sme správny koniec od chyby | ||
+ | <pre> | ||
+ | int main() { | ||
+ | |||
+ | FILE *f; | ||
+ | int a[100],N,i,x; | ||
+ | int sum=0; | ||
+ | |||
+ | f=fopen("vstup.txt","r"); | ||
+ | if (!f) return -1; | ||
+ | |||
+ | i=0; | ||
+ | while (!feof(f)){ | ||
+ | if (fscanf(f,"%d ",&a[i])!=1) return -1; | ||
+ | sum+=a[i++]; | ||
+ | } | ||
+ | |||
+ | printf("%d\n",sum); | ||
+ | fclose(f); | ||
+ | } | ||
+ | |||
+ | </pre> | ||
+ | |||
+ | * niekoľko sád z predchádzajúcich vecí | ||
+ | =Prednáška 14= | ||
+ | == Organizačné poznámky== | ||
+ | * Včera časový posun na Moodli, chvíľu sa nedali odovzdávať DÚ. Ak Vás to postihlo, dajte nám čím skôr vedieť a úlohu ešte dnes pošlite emailom cvičiacemu. | ||
+ | ** Nabudúce nám hláste prípadné poruchy čím skôr, aby sme ich mohli riešiť. | ||
+ | ** Ak kvôli technickým problémom neviete úlohu odovzdať, pošlite ju ešte pred termínom cvičiacemu. | ||
+ | * Neopisovať domáce úlohy od spolužiakov, z internetu ani od starších kolegov | ||
+ | ** Pripravíte sa o možnosť precvičiť si učivo, hrozia vám postihy | ||
+ | ** Ak neviete úlohu riešiť, pýtajte sa nás | ||
+ | * DÚ6 do pondelka 12.11., budúci pondelok normálne prednáška aj cvičenia (vrátane rozcvičky) | ||
+ | * PDÚ3 bude zverejnená dnes | ||
+ | |||
+ | ==Súbory, zhrnutie== | ||
+ | |||
+ | * Príkazy <tt>fopen</tt>, <tt>fclose</tt> na otváranie a zatváranie súboru, typ <tt>FILE *</tt> | ||
+ | * Príkazy <tt>fscanf</tt> a <tt>fprintf</tt> na načítavanie a vypisovanie formátovaných dát (čísla, slová) | ||
+ | |||
+ | Príklad: načítame číslo ''n'' a ''n'' celých čísel zo súboru <tt>vstup.txt</tt>. Do súboru <tt>vystup.txt</tt> vypíšeme ''n'' a vstupné čísla v opačnom poradí. | ||
+ | <pre> | ||
+ | #include <cstdio> | ||
+ | #include <cassert> | ||
+ | |||
+ | int main(void) { | ||
+ | FILE *fr = fopen("vstup.txt", "r"); // otvorime vstupny a vystupny subor | ||
+ | FILE *fw = fopen("vystup.txt", "w"); | ||
+ | assert(fr != NULL && fw != NULL); // skontrolujeme, ze sa podarilo | ||
+ | |||
+ | int n, r; | ||
+ | r = fscanf(fr, "%d ", &n); // nacitame pocet prvkov n | ||
+ | assert(r == 1 && n >= 0); // overime, ze s apodarilo a ze pocet nezaporny | ||
+ | int *a = new int[n]; // alokujeme pole dlzky n | ||
+ | |||
+ | for (int i = 0; i < n; i++) { // citame jednotlive prvky pola | ||
+ | r = fscanf(fr, "%d ", &a[i]); | ||
+ | assert(r == 1); | ||
+ | } | ||
+ | fclose(fr); // zavrieme vstupny subor | ||
+ | |||
+ | fprintf(fw, "%d", n); // vypiseme pocet prvkov do vystupu | ||
+ | for (int i = n - 1; i >= 0; i--) { // vypiseme vstupne prvky naopak | ||
+ | fprintf(fw, " %d", a[i]); | ||
+ | } | ||
+ | fclose(fw); // zavrieme vystupny subor | ||
+ | delete[] a; // uvolnime pamat | ||
+ | } | ||
+ | </pre> | ||
+ | * <tt>printf</tt> a <tt>scanf</tt> sú podobné, ale pracujú s konzolou (<tt>stdin</tt>, <tt>stdout</tt>) | ||
+ | * existujú aj funkcie <tt>sscanf</tt>, <tt>sprintf</tt>, ktoré načítavajú resp. vypisujú do reťazca | ||
+ | |||
+ | == Práca so súbormi po znakoch== | ||
+ | |||
+ | '''Čítanie po znakoch:''' funkcia <tt>getc(subor)</tt> načíta zo súboru jeden znak. | ||
+ | * Vracia <tt>int</tt> (nie <tt>char</tt>). | ||
+ | * Ak sa podarilo načítať, je to kód načítaného znaku. | ||
+ | * Ak sa nepodarilo načítať znak (koniec súboru, alebo nejaká chyba), vráti špeciálnu hodnotu <tt>EOF</tt> | ||
+ | ** Pozor, neukladať výsledok do premennej typu char, nevedeli by sme rozpoznať koniec súboru, bol by konvertovaný na iný znak | ||
+ | * Funkcia <tt>getchar()</tt> je skratka za <tt>getc(stdin)</tt>, číta teda jeden znak z konzoly | ||
+ | ** Spracovanie vstupu z klávesnice začne až potom, ako užívateľ stlačí Enter, nevieme takto reagovať priamo na stlačenie nejakej klávesy | ||
+ | |||
+ | '''Písanie po znakoch:''' funkcia <tt>putc(znak, subor)</tt> zapíše do súboru jeden znak | ||
+ | * Vracia int: zapísaný znak alebo EOF ak nastala chyba | ||
+ | * Funkcia <tt>putchar(znak)</tt> je skratka za <tt>putc(znak, stdout)</tt>, píše teda na konzolu | ||
+ | |||
+ | === Príklad: kopírovanie súboru === | ||
+ | |||
+ | <pre> | ||
+ | #include <cstdio> | ||
+ | int main(void) { | ||
+ | FILE *fr = fopen("list.txt", "r"); | ||
+ | FILE *fw = fopen("kopia.txt", "w"); | ||
+ | |||
+ | int c = getc(fr); | ||
+ | while (c != EOF) { | ||
+ | putc(c, fw); | ||
+ | c = getc(fr); | ||
+ | } | ||
+ | |||
+ | fclose(fr); | ||
+ | fclose(fw); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Načítavať môžeme aj priamo v podmienke <tt>while</tt> cyklu: | ||
+ | * výsledkom priradenia je nová hodnota, túto porovnáme s <tt>EOF</tt> | ||
+ | * kratšie ale trochu menej čitateľné | ||
+ | <pre> | ||
+ | int c; | ||
+ | while ((c = getc(fr)) != EOF) { | ||
+ | putc(c, fw); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Konce riadkov === | ||
+ | |||
+ | Znak pre koniec riadku je <tt>'\n'</tt> | ||
+ | * pri čítaní alebo zápise sa môže prekladať na jeden alebo dva znaky podľa typu operačného systému (<CR>, <LF>, alebo <CR><LF>) | ||
+ | |||
+ | Čo robí nasledujúci program? | ||
+ | <pre> | ||
+ | #include <cstdio> | ||
+ | |||
+ | int main(void) { | ||
+ | FILE *fr; | ||
+ | int c; | ||
+ | |||
+ | fr = fopen("VSTUP.TXT", "r"); | ||
+ | while ((c = getc(fr)) != '\n') { | ||
+ | putchar(c); | ||
+ | } | ||
+ | putchar(c); /* vypis \n */ | ||
+ | fclose(fr); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Ungetc === | ||
+ | |||
+ | Často zistíme, že máme prestať čítať znak až potom, čo prečítame o znak naviac | ||
+ | * funkcia <tt>ungetc(znak, subor)</tt> vráti znak späť (ako keby sme ho neprečítali) | ||
+ | * ak je vrátenie úspešné, <tt>ungetc()</tt> vracia vrátený znak | ||
+ | * ak je vrátenie neúspešné, vráti <tt>EOF</tt> | ||
+ | * vrátiť môžeme aj iný ako práve prečítaný znak | ||
+ | ** použije sa pri ďalšom načítaní, ale nezmení obsah súboru | ||
+ | * nemali by sme volať viackrát za sebou | ||
+ | |||
+ | Program konvertuje znakový reťazec na zodpovedajúcu číselnú hodnotu. Keď narazí na prvé číslo, ktoré nie je cifra, vráti znak, aby sa dal použiť pri ďalšom spracovávaní. | ||
+ | <pre> | ||
+ | int hodnota = 0; | ||
+ | int c = getchar(); | ||
+ | while (c >= '0' && c <= '9') { | ||
+ | hodnota = hodnota * 10 + (c - '0'); | ||
+ | c = getchar(); | ||
+ | } | ||
+ | ungetc(c, stdin); | ||
+ | </pre> | ||
+ | |||
+ | Program prečíta číslo pomocou fscanf, predtým však musí prečítať neznámy počet znakov '$'. | ||
+ | <pre> | ||
+ | #include <cstdio> | ||
+ | int main(void) { | ||
+ | FILE *fr = fopen("vstup.txt", "r"); | ||
+ | int c = getc(fr); | ||
+ | while (c == '$') { | ||
+ | c = getc(fr); | ||
+ | } | ||
+ | ungetc(c, fr); | ||
+ | |||
+ | int hodnota; | ||
+ | fscanf(fr, "%d", &hodnota); | ||
+ | printf("%d\n", hodnota); | ||
+ | fclose(fr); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Čítanie a písanie po riadkoch== | ||
+ | |||
+ | Funkcia <tt>fgets(str, n, subor)</tt> načíta riadok zo súboru | ||
+ | * str je pole char-ov (premenná typu char *) | ||
+ | * n je veľkosť tohto poľa (aby funkcia neprepísala miesto mimo poľa) | ||
+ | * Funkcia načíta do str jeden riadok súboru, ale ak by bol príliš dlhý, skončí po prvých n-1 znakoch | ||
+ | * Znak '\n' nechá na konci poľa, za neho dá ukončovaciu 0 | ||
+ | * Skončí aj ak príde na koniec súboru | ||
+ | * Vráti str, alebo NULL ak sa nepodarilo načítať ani jeden znak (vracia teda char *) | ||
+ | |||
+ | Nasledujúci program spočíta počet riadkov v súbore | ||
+ | * Čo spraví, ak posledný znak súboru nie je koniec riadku? | ||
+ | * Čo vypíše pre súbor, ktorý obsahuje jeden riadok s 200 znakmi? | ||
+ | <pre> | ||
+ | #include <cstdio> | ||
+ | int main(void) { | ||
+ | const int maxN = 100; | ||
+ | char str[maxN]; | ||
+ | FILE *fr = fopen("vstup.txt", "r"); | ||
+ | int num = 0; | ||
+ | while (fgets(str, maxN, fr) != NULL) { | ||
+ | num++; | ||
+ | } | ||
+ | cout << num << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Funkcia <tt>fputs(str, subor)</tt> vypíše reťazec str do súboru | ||
+ | * str môže obsahovať hocikoľko koncov riadkov (aj nula) | ||
+ | * pri chybe vráti EOF | ||
+ | |||
+ | == Spracovávanie vstupu == | ||
+ | |||
+ | Časté schémy spracovania textového súboru: | ||
+ | * Pomocou fscanf načítavame jednotlivé čísla, slová a pod. (väčšinou všetky biele znaky považujeme za ekvivalentné oddeľovače) | ||
+ | * Čítanie po znakoch pomocou getc | ||
+ | * Čítanie po riadkoch pomocou fgets do reťazca, potom reťazec spracovávame | ||
+ | |||
+ | Príklad: chceme nájsť dĺžku najdlhšieho riadku v súbore | ||
+ | * Prvá možnosť je čítanie riadkov do reťazca a ich spracovanie (problém ak je riadok príliš dlhý) | ||
+ | * Druhá možnosť je čítať súbor po znakoch, pričom si potrebujeme udržiavať "stav": koľko písmen sme už videli v tomto riadku | ||
+ | |||
+ | <pre> | ||
+ | #include <cstdio> | ||
+ | #include <cstring> | ||
+ | int main(void) { | ||
+ | FILE *fr = fopen("vstup.txt", "r"); | ||
+ | int maxDlzka = 0; // dlzka najdlhsieho riadku doteraz | ||
+ | const int maxN = 100; | ||
+ | char str[maxN]; | ||
+ | while (fgets(str, maxN, fr) != NULL) { | ||
+ | int dlzka = strlen(str); | ||
+ | if (dlzka > maxDlzka) { | ||
+ | maxDlzka = dlzka; | ||
+ | } | ||
+ | } | ||
+ | printf("Najdlhsi riadok ma dlzku %d\n", maxDlzka); | ||
+ | fclose(fr); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | <pre> | ||
+ | #include <cstdio> | ||
+ | |||
+ | int main(void) { | ||
+ | FILE *fr = fopen("vstup.txt", "r"); | ||
+ | int maxDlzka = 0; // dlzka najdlhsieho riadku doteraz | ||
+ | int dlzka = 0; // dlzka aktualneho riadku | ||
+ | int c = getc(fr); | ||
+ | while (c != EOF) { // nacitavame po znaku | ||
+ | dlzka++; // zvysime dlzku riadku | ||
+ | if (c == '\n') { // koniec riadku: spracujeme ho | ||
+ | if (dlzka > maxDlzka) { | ||
+ | maxDlzka = dlzka; | ||
+ | } | ||
+ | dlzka = 0; | ||
+ | } | ||
+ | c = getc(fr); | ||
+ | } | ||
+ | if (dlzka > maxDlzka) { // nezabudneme na posledny riadok (moze chybat \n) | ||
+ | maxDlzka = dlzka; | ||
+ | } | ||
+ | printf("Najdlhsi riadok ma dlzku %d\n", maxDlzka); | ||
+ | fclose(fr); | ||
+ | } | ||
+ | </pre> | ||
+ | Cvičenie: čo ak chceme zistiť, koľký riadok v súbore bol ten najdlhší? | ||
+ | |||
+ | Ešte jeden príklad: máme súbor s číslami oddelenými bielymi znakmi (medzery, tabulátory, konce riadkov,...), pričom medzi dvoma číslami mlže byť aj viac ako jeden oddeľovač. Chceme spočítať súčet čísel na každom riadku. | ||
+ | * nepríjemná kombinácia rozlišovania koncov riadku od iných bielych znakov a čítania formátovaných hodnôt (čísel) | ||
+ | * môžeme biele znaky spracovávať cez getc, potom použiť ungetc a fscanf | ||
+ | * alebo prečítať riadok do reťazca a rozložiť na čísla | ||
+ | |||
+ | <pre> | ||
+ | #include <cstdio> | ||
+ | #include <cctype> | ||
+ | int main(void) { | ||
+ | FILE *fr = fopen("vstup.txt", "r"); | ||
+ | int sucet = 0; | ||
+ | while(!feof(fr)) { | ||
+ | int c = getc(fr); | ||
+ | while(c!=EOF && isspace(c)) { | ||
+ | if (c == '\n') { | ||
+ | printf("Sucet %d\n", sucet); | ||
+ | sucet = 0; | ||
+ | } | ||
+ | c= getc(fr); | ||
+ | } | ||
+ | if(c==EOF) { break; } | ||
+ | ungetc(c, fr); | ||
+ | int hodnota; | ||
+ | fscanf(fr, "%d", &hodnota); | ||
+ | sucet += hodnota; | ||
+ | } | ||
+ | fclose(fr); | ||
+ | } | ||
+ | </pre> | ||
+ | Cvičenia: | ||
+ | * upravte program, aby fungoval aj ak posledný riadok nie je ukončený '\n' | ||
+ | * upravte program, aby na výstupe vypisoval aj čísla na riadkoch oddelené medzerami | ||
+ | |||
+ | == Jednoduché šifrovanie == | ||
+ | Prácu so súbormi si precvičíme na jednoduchých šifrách. | ||
+ | |||
+ | === Cézarova šifra === | ||
+ | |||
+ | [http://sk.wikipedia.org/wiki/C%C3%A9zarova_%C5%A1ifra Cézarova šifra] je šifra, kde každé písmeno vstupného reťazca posunieme v abecede cyklicky o K miest. | ||
+ | * Napr. ak K=2, tak namiesto A budeme budeme písať C, namiesto B píšeme D, namiesto Z píšeme B. | ||
+ | * Ukážeme si použitie pre anglickú abecedu (t.j. znaky 'A'-'Z' bez diakritiky), ale je možné ju použiť napríklad aj na ASCI kódy. | ||
+ | |||
+ | <pre> | ||
+ | void encryptCezar(FILE *fr, int K) { | ||
+ | assert(0 <= K && K < 26); | ||
+ | |||
+ | int c = getc(fr); | ||
+ | while (c != EOF) { | ||
+ | if ((c <= 'Z') && (c >= 'A')) { // prekodujeme pismeno | ||
+ | c = c + K; | ||
+ | if (c > 'Z') { | ||
+ | c = c - 26; | ||
+ | } | ||
+ | putc(c, stdout); | ||
+ | } | ||
+ | else if (isspace(c)) { // medzery kopirujeme na vystup | ||
+ | putc(c, stdout); | ||
+ | } | ||
+ | c = getc(fr); | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Text, ktorý chceme zašifrovať načítavame zo súboru fr a posúvame znaky 'A'-'Z' o nejakú konštantu K. | ||
+ | * Biele znaky kopírujeme. | ||
+ | * Zašifrovaný text vypisujeme na obrazovku, nebol pri problém to zmeniť do súboru. | ||
+ | * Cvičenie: upravte program tak, aby správne šifroval aj malé písmená a aby na obrazovku kopíroval aj iné znaky, napr. čísla a interpunkciu. | ||
+ | |||
+ | Pri dešifrovaní postupujeme podobne, len číslo K od prečítaného znaku odrátame (pozor na prechod cez A). | ||
+ | |||
+ | === Vigenerova šifra === | ||
+ | |||
+ | [http://cs.wikipedia.org/wiki/Vigen%C3%A8rova_%C5%A1ifra Vigenerova šifra] je veľmi podobná Cézarovej, ale posun nie je konštantný, ale podľa kľúča. | ||
+ | * Kľúč je nejaké slovo z písmen A-Z, pričom tieto sa písmená predstavujú posuny o 0..25 | ||
+ | * Pri šifrovaní aj dešifrovaní cyklicky používame posuny z kľúča | ||
+ | * Kľúč samozrejme musí byť známy obidvom stranám. | ||
+ | |||
+ | <pre> | ||
+ | void encryptVigenere(FILE *fr, char kluc[]) { | ||
+ | int c = getc(fr); | ||
+ | int i = 0; | ||
+ | while (c != EOF) { | ||
+ | if ((c <= 'Z') && (c >= 'A')) { | ||
+ | c = c + kluc[i] - 'A'; | ||
+ | if (c > 'Z') { | ||
+ | c = c - 26; | ||
+ | } | ||
+ | putc(c, stdout); | ||
+ | i++; | ||
+ | if (kluc[i] == 0) i = 0; | ||
+ | } else if (isspace(c)) { | ||
+ | putc(c, stdout); | ||
+ | } | ||
+ | c = getc(fr); | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Rastúce pole== | ||
+ | |||
+ | Vráťme sa k programu, ktorý má zo súboru načítať postupnosť čísel a uložiť ich do poľa na ďalši spracovanie | ||
+ | * Ak je na za začiatku súboru počet čísel N, môžeme alokovať akurátne veľké pole | ||
+ | * Ak ale počet čísel nie je vopred známy, môžeme pole nafukovať podľa veľkosti | ||
+ | ** Začneme s malým poľom (veľkosti 2) | ||
+ | ** Vždy keď sa pole zaplní, alokujeme nové pole dvojnásobnej veľkosti, prvky do neho skopírujeme a staré pole odalokujeme | ||
+ | ** Presúvanie prvkov dlho trvá, preto pole vždy zdvojnásobíme, aby sme nemuseli presúvať často | ||
+ | ** Spolu pri načítaní n prvkov robíme najviac 2n presunov jednotlivých prvkov | ||
+ | <pre> | ||
+ | #include <cstdio> | ||
+ | |||
+ | int *nacitajDoPola(FILE *f, int &n) { | ||
+ | /* Cita cele cisla zo suboru f az kym nepride na koniec. | ||
+ | * Uklada ich do dynamicky alokovaneho pola, ktore vrati, | ||
+ | * pocet nacitanych cisel ulozi do n */ | ||
+ | |||
+ | int velkost = 2; // zacneme s polom s 2 prvkami | ||
+ | int *pole = new int[velkost]; | ||
+ | n = 0; // 0 cisel je zatial ulozenych | ||
+ | while (!feof(f)) { | ||
+ | if (n == velkost) { // ak sme naplnili pole, presunime do vacsieho | ||
+ | velkost *= 2; | ||
+ | int *nove = new int[velkost]; | ||
+ | /* prekopirujeme zo stareho do noveho */ | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | nove[i] = pole[i]; | ||
+ | } | ||
+ | /* zmazeme stare */ | ||
+ | delete[] pole; | ||
+ | pole = nove; | ||
+ | } | ||
+ | |||
+ | fscanf(f, "%d ", &pole[n]); // v poli je miesto, ulozime novu hodnotu | ||
+ | n++; | ||
+ | } | ||
+ | return pole; | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | int n; | ||
+ | int *a; | ||
+ | a = nacitajDoPola(stdin, n); // nacitame pole a a pocet n | ||
+ | for (int i = 0; i < n; i++) { // spracovavame, ako sme zvyknuti | ||
+ | printf(" %d", a[i]); | ||
+ | } | ||
+ | printf("\n"); | ||
+ | delete[] a; // nakoniec zmazeme pole a | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Vector== | ||
+ | |||
+ | Rastúce pole z predchádzajúceho programu by sa nám mohlo zísť aj na iné účely | ||
+ | * V C++ knižniciach je štruktúra vector, ktorá podobne rastie podľa potreby | ||
+ | * My si jednoduchšiu verziu vektora naprogramujeme. | ||
+ | * Na začiatku programu si zadefinujeme, akého typu prvky budeme do vektora dávať (napr. int, doble, char a pod.) | ||
+ | :: <tt>typedef int dataType;</tt> | ||
+ | * Náš vektor bude struct s potrebnými údajmi a bude poskytovať nasledujúce funkcie | ||
+ | ** <tt>double init(vector &a)</tt> vytvorí prázdny vektor | ||
+ | ** <tt>void add(vector &a, dataType x)</tt> pridá na koniec vektoru prvok x | ||
+ | ** <tt>dataType get(vector &a, int i)</tt> vráti prvok na pozícii i v poli, pričom kontroluje, či je index platný (od 0 po najväčší vložený prvok) a ak nie, ukončí program príkazom assert | ||
+ | ** <tt>void set(vector &a, int i, dataType x)</tt> na pozíciu i v poli uloží prvok x (s kontrolou indexu i) | ||
+ | ** <tt>int length(vector &a)</tt> | ||
+ | ** <tt>void destroy(vector &a)</tt> zmaže pamäť alokovanú pre vektor a | ||
+ | * Štruktúra vector teda v sebe združuje pole aj jeho dĺžku, stačí posielať jeden parameter | ||
+ | * Vector posielame do funkcií referenciou, aby sa zbytočne veľa nekopírovalo (a tiež aby sme ho mohli v prípade potreby meniť) | ||
+ | * Vector by sme teraz vedeli použiť bez toho, aby sme vedeli, ako sú funkcie naprogramované vo vnútri | ||
+ | ** Môžeme teda implementáciu vectora meniť bez zmeny programu, ktorý ho používa | ||
+ | <pre> | ||
+ | typedef double dataType; | ||
+ | // sem pride definicia tyzpu vector + funkcie uvedene vyssie | ||
+ | |||
+ | int main(void) { | ||
+ | vector a; | ||
+ | init(a); | ||
+ | add(a, 0.5); // mame 1-prvkove pole {0.5} | ||
+ | add(a, 1.0); // mame 2-prvkove pole {0.5, 1.0} | ||
+ | set(a, 1, 1.5); // mame 2-prvkove pole {0.5, 1.5} | ||
+ | printf("%f\n", get(a,0) + get(a,1)); // vypise 2.0000 | ||
+ | destroy(a); | ||
+ | } | ||
+ | </pre> | ||
+ | * V objektovo-orientovanom programovaní (budúci semester) sa namiesto napr. <tt>get(a,0)</tt> píše niečo ako <tt>a.get(0)</tt> | ||
+ | |||
+ | ===Implementácia vectora=== | ||
+ | <pre> | ||
+ | struct vector { | ||
+ | dataType *a; /* pole prvkov typu dataType */ | ||
+ | int size; /* velkost alokovaneho pola */ | ||
+ | int n; /* pocet prvkov pridanych do pola */ | ||
+ | }; | ||
+ | |||
+ | dataType init(vector &a) { | ||
+ | /* inicializuj vektor s kratkym polom */ | ||
+ | a.size = 2; | ||
+ | a.a = new dataType[a.size]; | ||
+ | a.n = 0; | ||
+ | } | ||
+ | |||
+ | void add(vector &a, dataType x) { | ||
+ | /* na koniec pola pridaj prvok x, zvacsi pole ak treba */ | ||
+ | |||
+ | if (a.n == a.size) { | ||
+ | /* treba zvacsovat */ | ||
+ | dataType *nove = new dataType[a.size * 2]; | ||
+ | /* prekopirujeme zo stareho do noveho */ | ||
+ | for (int i = 0; i < a.n; i++) { | ||
+ | nove[i] = a.a[i]; | ||
+ | } | ||
+ | /* zmazeme stare */ | ||
+ | delete [] a.a; | ||
+ | /* upravujeme premenne */ | ||
+ | a.a = nove; | ||
+ | a.size *= 2; | ||
+ | } | ||
+ | /* teraz uz je pole dost velke, staci ulozit x */ | ||
+ | a.a[a.n] = x; | ||
+ | a.n++; | ||
+ | } | ||
+ | |||
+ | dataType get(vector &a, int i) { | ||
+ | /* vrat prvok v poli na pozicii i (s kontrolou i) */ | ||
+ | assert(i >= 0 && i < a.n); | ||
+ | return a.a[i]; | ||
+ | } | ||
+ | |||
+ | void set(vector &a, int i, dataType x) { | ||
+ | /* na poziciu i uloz hodnotu x (s kontrolou i) */ | ||
+ | assert(i >= 0 && i < a.n); | ||
+ | a.a[i] = x; | ||
+ | } | ||
+ | |||
+ | void destroy(vector &a) { | ||
+ | delete[] a.a; | ||
+ | } | ||
+ | |||
+ | int length(vector &a) { | ||
+ | return a.n; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Použitie vektora pri načítaní dát=== | ||
+ | |||
+ | * Vráťme sa k príkladu, kde sme načítavali desatinné čísla zo súboru až do konca súboru | ||
+ | * Vtedy sme priamo pri načítaní čísel menili veľkosť poľa | ||
+ | * Teraz vieme zapísať pomocou operácie add, oddelili sme prácu s alokovaním poľa a prácu so súborom | ||
+ | |||
+ | <pre> | ||
+ | int main(void) { | ||
+ | FILE *fr = fopen("vstup.txt", "r"); // otvorime vstupny subor | ||
+ | |||
+ | vector a; // vytvorime a inicializujeme vektor a | ||
+ | init(a); | ||
+ | |||
+ | while (!feof(fr)) { // nacitavame prvky do vektora | ||
+ | double hodnota; | ||
+ | fscanf(fr, "%lf ", &hodnota); | ||
+ | add(a, hodnota); | ||
+ | } | ||
+ | fclose(fr); // zavrieme vstupny subor | ||
+ | |||
+ | double sucet = 0; // teraz pracujeme s a, napr. spocitame sucet prvkov vo vektore | ||
+ | for (int i = 0; i < length(a); i++) { | ||
+ | sucet += get(a, i); | ||
+ | } | ||
+ | |||
+ | printf("pocet: %d, sucet: %f\n", length(a), sucet); // vypise pocet prvkov a ich sucet na konzolu | ||
+ | destroy(a); // uvolnime pamat vektora a | ||
+ | } | ||
+ | </pre> | ||
+ | =Cvičenia 7= | ||
+ | ==Čítanie programov== | ||
+ | |||
+ | * Skúste zistiť bez použitia počítača, čo vypíše nasledujúca funkcia, ak ju spustíme ako <tt>generuj(a, pocet, 0, 2, 3)</tt>, pričom polia <tt>a</tt> a <tt>pocet</tt> majú dĺžku n=3 a obe sú naplnené nulami. Funkcia <tt>vypis(a,n)</tt> vypíše prvky poľa <tt>a</tt>. | ||
+ | * Ako musíme funkciu opraviť, aby vypisovala všetky usporiadané n-tice čísel z množiny {0,...,n-1}, v ktorých sa každé číslo opakuje najviac k krát? | ||
+ | <pre> | ||
+ | void generuj(int a[], int pocet[], int i, int k, int n) { | ||
+ | if (i == n) { | ||
+ | vypis(a, n); | ||
+ | } else { | ||
+ | for (int x = 0; x < n; x++) { | ||
+ | if (pocet[x]<k) { | ||
+ | a[i] = x; | ||
+ | pocet[x]++; | ||
+ | generuj(a, pocet, i + 1, k, n); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | == Valgrind== | ||
+ | Nasledujúci program nesprávne odalokováva pamäť. Spustite ho v programe valgrind, mal by vám oznámiť dva problémy: | ||
+ | * <tt>Invalid free() / delete / delete[] / realloc()</tt> Čo to asi znamená? Na ktorom riadku programu je chyba? | ||
+ | * <tt>LEAK SUMMARY: definitely lost: 4 bytes in 1 blocks</tt> Čo to asi znamená? (memory leak je pamäť, ktorú sme neodalokovali a ku ktorej sa už nevieme dostať cez žiadnu premennú). | ||
+ | ** Tento problém môžete bližšie preskúmať, ak spustíme valgrind takto: <tt>valgrind --leak-check=full cesta/meno_programu</tt> | ||
+ | ** Mali by ste potom dostať hlášku typu <tt>4 bytes in 1 blocks are definitely lost in loss record 1 of 1</tt> s bližším určením, na ktorom mieste programu bola táto stratená pamäť alokovaná | ||
+ | |||
+ | <pre> | ||
+ | int main(void) { | ||
+ | int i; | ||
+ | int *p = new int; | ||
+ | int *q = new int; | ||
+ | int *r = p; | ||
+ | delete p; | ||
+ | delete r; | ||
+ | } | ||
+ | |||
+ | </pre> | ||
+ | |||
+ | ==Triedenie kruhov== | ||
+ | Na prednáške 12 sme mali [[#Prednáška_12#Pr.C3.ADklad_vyu.C5.BEitia_new_a_delete|program]], ktorý od užívateľa načítal počet kruhov a potom pre každý kruh jeho súradnice a polomer. Jednotlivé kruhy alokuje dynamicky a smerníky na ne ukladá do poľa. | ||
+ | * Zmeňte tento program tak, aby poľe smerníkov bolo tiež alokované dynamicky, pričom bude mať dĺžku n, ktorú sme načítali od užívateľa | ||
+ | * Program ďalej zmeňte tak, aby kruhy utriedil podľa polomeru od najmenších po najväčšie a vypísal v tomto poradí na obrazovku. | ||
+ | ** Môžete použiť niektoré rekurzívne triedenie z [[#Prednáška_11|prednášky 11]] alebo niektoré jednoduché triedenie z [[#Prednáška_6|prednášky 6]]. | ||
+ | ** Triediaca funkcia dostane pole smerníkov na kruhy a preusporiada tieto smerníky tak, aby kruhy, na ktoré ukazujú, išli v správnom poradí | ||
+ | ** Vždy keď sa v triedení porovnávajú dva prvky poľa, porovná príslušné polomery kruhov, na ktoré tieto smerníky ukazujú. | ||
+ | |||
+ | == Smerníky a typy == | ||
+ | Majme nasledujúce definície premenných: | ||
+ | <pre> | ||
+ | struct volaco { | ||
+ | int x; | ||
+ | int *y; | ||
+ | }; | ||
+ | volaco * a[3]; // pole 3 smernikov na volaco | ||
+ | volaco v; | ||
+ | volaco *p; | ||
+ | </pre> | ||
+ | |||
+ | Akých typov sú nasledovné výrazy? (t.j. napr. do premennej akého typu by sme ich mohli priradiť?) | ||
+ | * <tt>*(p->y)</tt> | ||
+ | * <tt>&(v.x)</tt> | ||
+ | * <tt>&(a[2])</tt> | ||
+ | * <tt>p->y[p->x]</tt> | ||
+ | Skúste inicializovať premenné a, v a p (a príslušné časti structov volaco) tak, aby všetky tieto výrazy pracovali len s platnými miestami v pamäti. | ||
+ | |||
+ | ==Ešte valgrind a hľadanie chýb== | ||
+ | Nasledujúci program by mal správne vypísať text "AhojAhojAhojAhoj", ale je v ňom zopár chýb. Skúste nájsť a opraviť chyby čítaním programu, použitím debugera, programu valgrind, prípadne si pridajte nejaké pomocné výpisy premenných. | ||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | void opakuj(char kam[], char co[], char kolko) { | ||
+ | /* Funkcia dostane na vstupe retazec co a cislo kolko a nakopiruje ho tolkokrat | ||
+ | * za sebou do retazca kam. */ | ||
+ | |||
+ | int i=0; // pozicia v kam | ||
+ | for(int opakovanie=0; opakovanie<kolko; opakovanie++) { // opakuj kopirovanie | ||
+ | for(int j=0; co[j]!=0; j++) { // prechod cez znaky retazca co | ||
+ | kam[i] = co[j]; | ||
+ | i++; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | char ahoj[4] = {'A', 'h', 'o', 'j'}; | ||
+ | char vysledok[16]; | ||
+ | opakuj(vysledok, ahoj, 4); | ||
+ | cout << vysledok << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | =DÚ6= | ||
+ | {{MDU|6|4558}} a {{MDU|6 bonus|4559}} max. 10 bodov + 5 bodov bonus, termín odovzdania pondelok 12.11. o 22:00 | ||
+ | |||
+ | Napíšte program, ktorý od užívateľa načíta celé kladné čísla ''n'' a ''k'' a vypíše všetky spôsoby, ako zapísať číslo ''n'' ako súčin ''k'' kladných celých čísel. Napríklad ak ''n=100'' a ''k=3'', môžeme ''n'' zapísať napríklad ako ''1 * 1 * 100'' alebo ''2 * 5 * 10'' atď. Dodržujte formát výstupu z nasledujúceho príkladu: | ||
+ | <pre> | ||
+ | Zadajte n a k: 100 3 | ||
+ | 100 = 1 * 1 * 100 | ||
+ | 100 = 1 * 2 * 50 | ||
+ | 100 = 1 * 4 * 25 | ||
+ | 100 = 1 * 5 * 20 | ||
+ | 100 = 1 * 10 * 10 | ||
+ | 100 = 2 * 2 * 25 | ||
+ | 100 = 2 * 5 * 10 | ||
+ | 100 = 4 * 5 * 5 | ||
+ | Pocet vypisov: 8 | ||
+ | Pocet volani: 38 | ||
+ | </pre> | ||
+ | Každá možnosť zápisu čísla ''n'' je teda na zvláštnom riadku, ktorý sa začína textom <tt>"n = "</tt> a pokračuje jednotlivými deliteľmi od najmenšieho po najväčší oddelenými reťazcom <tt>" * "</tt>. Jednotlivé možnosti môžete vypisovať v ľubovoľnom poradí, nemali by sa však opakovať ani by žiadna nemala chýbať. Za poslednou možnosťou vypíšte ešte počet vypísaných možností a počet rekurzívnych volaní funkcie <tt>generuj</tt> (počet rekurzívnych volaní sa môže líšiť v závislosti podľa presných detailov vašej implementácie). | ||
+ | |||
+ | Vaše riešenie dopíšte do kostry uvedenej nižšie na miesta označené <tt>VAS KOD TU</tt>. Pokiaľ možno sa držte tejto kostry, ak ju však potrebujte nutne meniť, vysvetlite svoje zmeny v komentároch. Ak chcete, môžete si naprogramovať a použiť ďalšie pomocné funkcie. Dodržte formát výstupu podľa príkladu vyššie. | ||
+ | |||
+ | '''Algoritmus:''' Rekurzívna funkcia <tt>generuj</tt> dostane v poli ''a'' vyplnených prvých ''i'' deliteľov čísla ''n'' a snaží sa vyplniť zvyšných ''k-i''. V premennej <tt>zostava</tt> má číslo ''n'' vydelené prvými ''i'' deliteľmi. Napríklad v priebehu výpočtu pre náš príklad môžeme mať v ''a[0]'' vyplnené číslo ''2'' a zavolá sa <tt>generuj</tt> pre <tt>zostava</tt>''=50, i=1''. Pri skúšaní všetkých možností hodnôt pre aktuálne políčko ''a[i]'' dbajte na tieto tri podmienky: | ||
+ | * Do ''a[i]'' dosaďte len čísla, ktoré delia číslo <tt>zostava</tt>. | ||
+ | * Čísla vypĺňajte tak, aby boli v poli usporiadané od najmenšieho po najväčšie. Teda ak ''a[0]=2'', do ''a[1]'' nebudeme skúšať dať ''1''. | ||
+ | * Do ''a[i]'' nedosadzujte príliš veľké čísla. Všetky zvyšné prvky v poli budú aspoň také veľké ako ''a[i]'', takže ak by sme do celého zvyšku poľa dosadili nejaké ''x'' a dostaneme príliš veľký súčin, nemá zmysel ''x'' a väčšie čísla do ''a[i]'' dosadzovať. Ak napr. ak v našom príklade ''a[0]=2'' (a teda <tt>zostava=50</tt>), nebudeme do ''a[1]'' skúšať dosadiť hodnoty 8 a viac, lebo napr. ''a[1]=8'' a ''a[2]=8'' dáva súčin 64, čo už je viac ako naša momentálna hodnota <tt>zostava=50</tt>. | ||
+ | |||
+ | '''Poznámky:''' | ||
+ | * V programe sú dve globálne premenné <tt>pocetVypisov</tt> a <tt>pocetVolani</tt>. Dajte pozor, aby ste ich na správnych miestach menili. | ||
+ | * Pole ''a'' alokujte tak, aby malo potrebný počet prvkov v závislosti od vstupu a nezabudnite ho na konci uvoľniť. | ||
+ | |||
+ | '''Bonus:''' Upravte program tak, že ešte pred začiatkom rekurzívneho prehľadávania spočíta do nejakého poľa všetkých deliteľov čísla ''n'' od najmenšieho po najväčšie. Napríklad pre ''n=100'' uloží do tohto poľa čísla ''1,2,4,5,10,20,25,50,100''. V rekurzii potom pri dosadzovaní do ''a[i]'' skúša len vhodnú podmnožinu prvkov z tohto poľa deliteľov (pozor, sú to delitele ''n'', nemusia teda nutne deliť aj <tt>zostava</tt>, to treba otestovať). Dbajte na to, aby hodnoty dosadzované do ''a[i]'' spĺňali všetky tri podmienky uvedené v časti Algoritmus. Cieľom tejto zmeny je dosiahnuť určité zrýchlenie, lebo pri prehľadávaní zbytočne netestujeme čísla, ktoré nedelia číslo ''n'' a tým pádom nedelia ani <tt>zostava</tt>. Ak riešite bonus, odovzdajte zvlášť základnú verziu programu držiacu sa kostry a zvlášť bonus, kde kostru podľa potreby pomeňte. Bonus sa bude uznávať len tým, ktorí majú správne hlavnú časť úlohy. | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | #include <cassert> | ||
+ | #include <cmath> | ||
+ | #include <cstring> | ||
+ | using namespace std; | ||
+ | |||
+ | /* Premenna pocetVypisov pocita, kolkokrat sa volala | ||
+ | * funkcia vypis. */ | ||
+ | int pocetVypisov = 0; | ||
+ | /* Premenna pocetVolani pocita, kolkokrat sa volala | ||
+ | * funkcia generuj. */ | ||
+ | int pocetVolani = 0; | ||
+ | |||
+ | void vypis(int a[], int k, int n) { | ||
+ | /* Funkcia vypise cislo n ako sucin k cisel v poli a, pricom | ||
+ | * dodrzi format zo zadania. | ||
+ | */ | ||
+ | |||
+ | // VAS KOD TU | ||
+ | } | ||
+ | |||
+ | void generuj(int n, int k, int zostava, int i, int a[]) { | ||
+ | /* Funkcia do pola a rekurzivne generuje rozklad | ||
+ | * cisla n na k delitelov, pricom tito su v poli | ||
+ | * od najmensieho po najvacsi. Kazdy takyto rozklad vypise. | ||
+ | * V poli je uz je prvych i delitelov (v neklesajucom poradi) | ||
+ | * a hodnota zostava je n vydelene vsetkymi tymito delitelmi z pola. | ||
+ | * Cielom je teda vsetkymi moznostami doplnit do pola a k-i delitelov | ||
+ | * cisla zostava tak, aby cele pole bolo v neklesajucom poradi. | ||
+ | */ | ||
+ | |||
+ | assert(zostava>0 && zostava<=n && i>=0 && k>=i); | ||
+ | // VAS KOD TU | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | int n, k; /* vstupne hodnoty */ | ||
+ | int *a; /* pole s delitelmi */ | ||
+ | |||
+ | /* nacitame n a k */ | ||
+ | cout << "Zadajte n a k: "; | ||
+ | cin >> n >> k; | ||
+ | |||
+ | /* alokujeme pole a vhodnej velkosti */ | ||
+ | // VAS KOD TU | ||
+ | |||
+ | /* zavolame rekurzivne generovanie moznosti */ | ||
+ | generuj(n, k, n, 0, a); | ||
+ | |||
+ | /* vypiseme vysledok */ | ||
+ | cout << "Pocet vypisov: " << pocetVypisov << endl; | ||
+ | cout << "Pocet volani: " << pocetVolani << endl; | ||
+ | |||
+ | /* uvolnime alokovanu pamat */ | ||
+ | // VAS KOD TU | ||
+ | } | ||
+ | </pre> | ||
+ | =Pokročilá DÚ3= | ||
+ | {{MDU||4618}} max. 20 bodov + 4 body bonus, termín odovzdania pondelok 19.10. o 22:00 | ||
+ | |||
+ | Cieľom tejto domácej úlohy je precvičiť si prácu so smerníkmi a spájanými zoznamami. Vašou úlohou bude implementovať dátovú štruktúru, ktorá spája hašovanie, spájané zoznamy a techniku move-to-front na dynamické presúvanie prvkov v spájanom zozname. Túto dátovú štruktúru potom použijeme na počítanie výskytov slov v súbore. Našim cieľom je implementovať asociatívne pole (slovník, map), v ktorom si pre každé slovo zo vstupného súboru pamätáme, koľkokrát sme ho už v súbore videli. V tejto úlohe potrebujete ovládať dátové štruktúry '''hašovacia tabuľka''' a '''spájaný zoznam'''. Budeme sa o nich učiť na prednáškach v týždni po 5.11. Viac si môžete prečítať v niektorej štandardnej učebnici algoritmov a dátových štruktúr (napr. kniha Sedgewick: Algorithms in C. Parts 1-4 v knižnici pod signatúrou I-INF-S-43/I-IV) prípadne v prednáškach [[#2011/12_Programovanie_(1)_v_C/C%2B%2B#Predn.C3.A1.C5.A1ka_13|13]] a [[#2011/12_Programovanie_(1)_v_C/C%2B%2B#Predn.C3.A1.C5.A1ka_18|18]] z minulého školského roku. Všetky dátové štruktúry si skúste naprogramovať sami, nekopírujte celé kusy kódu z internetu, prednášok, kníh alebo iných zdrojov (t.j. prečítajte si ako tieto štruktúry fungujú, ale potom si sadnite a skúste napísať príslušné časti programu sami, bez opisovania). | ||
+ | |||
+ | ==Dátová štruktúra== | ||
+ | Naša dátová štruktúra má nasledovné zložky: | ||
+ | * Hašovaciu tabuľku veľkosti N. Každé políčko tabuľky obsahuje smerník na spájaný zoznam slov, ktoré hašovacia funkcia zobrazí do tohto políčka. | ||
+ | * Tento spájaný zoznam má v každom uzle uložené jedno slovo a počítadlo výskytov. Doporučujeme použiť obojsmerne spájaný zoznam, aby sa v ňom ľahšie menilo poradie prvkov. | ||
+ | |||
+ | Program teda vždy načíta jedno slovo zo vstupu a spracuje ho nasledovným postupom: | ||
+ | * hašovacou funkciou uvedenou nižšie spočíta jeho index h v hašovacej tabuľke | ||
+ | * prehľadáva spájaný zoznam uložený v políčku h, až kým nenájde záznam pre toto slovo alebo neprejde celý zoznam | ||
+ | * ak slovo nebolo nájdené v zozname, pridá pre neho uzol na začiatok zoznamu | ||
+ | * ak slovo bolo nájdené v zozname, zvýši mu počítadlo a presunie ho na začiatok zoznamu | ||
+ | ** tento presun sa volá '''move-to-front''' a spôsobí to, že ak sa niektoré slovo v zozname vyskytuje v súbore často, bude sa nachádzať blízko pri začiatku zoznamu a teda ho pri ďalšom hľadaní rýchlejšie nájdeme | ||
+ | ** napríklad ak máme v zozname pre nejaké políčko slová <tt>wandered, zigzag, was, field</tt> a hľadáme slovo <tt>was</tt>, zastavíme sa na treťom uzle zoznamu a tento uzol presunieme na začiatok, takže budeme mať zoznam <tt>was, wandered, zigzag, field</tt> | ||
+ | |||
+ | Použite túto hašovaciu funkciu (nemeňte počítanú hodnotu, ale ak chcete, môžete si ju prerobiť tak, aby namiesto C-čkového reťazca pracovala s typom string z C++): | ||
+ | <pre>int hashFunction(char str[], int N) { | ||
+ | // Funkcia dostane vstupny retazec str a velkost hashovacej tabulky N. | ||
+ | // Vrati cislo medzi 0 a N-1 | ||
+ | const int seed = 2012; | ||
+ | const int L = 5; | ||
+ | const int R = 2; | ||
+ | unsigned int h = seed; | ||
+ | char *c = str; | ||
+ | while (*c) { | ||
+ | h = h ^ ((h << L) + (h >> R) + *c); | ||
+ | c++; | ||
+ | } | ||
+ | h = h % N; | ||
+ | return h; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Vstup a výstup== | ||
+ | |||
+ | Váš program by mal načítavať vstup zo súboru <tt>vstup.txt</tt> a vypisovať výstup do súboru <tt>vystup.txt</tt>, pričom dodržujte mená a formát súborov. Ak potrebujete, na obrazovku si môžete vypísať pomocné výpisy v ľubovoľnom formáte. Vo '''vstupnom súbore''' budeme za '''slovo''' považovať neprázdnu postupnosť písmen anglickej abecedy oddelenú od iných slov jedným alebo viacerými oddeľovacími znakmi. Všetky znaky okrem písmen (biele znaky, interpunkcia, čísla, špeciálne znaky, znaky s diakritikou...) považujte sa oddeľovače slov. Pri čítaní vstupného súboru preveďte všetky veľké písmená na malé (funkciou <tt>tolower</tt>). Do '''výstupného súboru''' vypíšte všetky slová zo vstupného súboru, každé na jednom riadku a za ním medzeru a počet jeho výskytov. Slová môžete vypisovať v ľubovoľnom poradí. | ||
+ | |||
+ | Príklad: vstup.txt: | ||
+ | <pre> | ||
+ | ahoj svet! | ||
+ | Ahoj123svet, HELLO world. | ||
+ | </pre> | ||
+ | |||
+ | vystup.txt: | ||
+ | <pre> | ||
+ | ahoj 2 | ||
+ | world 1 | ||
+ | hello 1 | ||
+ | svet 2 | ||
+ | </pre> | ||
+ | |||
+ | ==Meranie času výpočtu, nastavenia programu, odovzdávanie== | ||
+ | |||
+ | Výsledný program spustite na vstupnom súbore, ktorý nájdete [http://compbio.fmph.uniba.sk/vyuka/prog/data/pdu3-mtf/vstup.txt tu] (obsahuje text knihy Alice's Adventures in Wonderland od Lewisa Carrolla). Chceli by sme porovnať čas výpočtu programu pre rôzne nastavenia veľkosti hašovacej tabuľky N. Ak pracujete v Linuxe, čas programu môžete merať príkazom time -p, napr. <tt>time -p NetBeansProjects/pdu3/dist/Debug/GNU-Linux-x86/pdu3</tt> vypíše | ||
+ | <pre> | ||
+ | real 0.03 | ||
+ | user 0.01 | ||
+ | sys 0.01 | ||
+ | </pre> | ||
+ | My budeme uvažovať druhé z vypísaných čísel (user), čo je čas výpočtu v sekundách okrem systémových volaní súvisiacich napríklad s čítaním súboru. Ako vidíme, tento čas je veľmi malý a môže byť problém ho zmerať presne. Preto celý výpočet (načítavanie súboru a ukladanie do tabuľky aj vypisovanie výsledku) opakujte K krát pre vhodne zvolené K tak, aby program bežal aspoň rádovo niekoľko sekúnd. Aby sa Vám experimenty dobre robili, váš program by mal hodnoty K a N dostať ako argumenty z príkazového riadku, pomocou parametrov argc a argv vo funkcii main (o týchto parametroch si môžete prečítať v [[#2011/12_Programovanie_(1)_v_C/C%2B%2B#Vstupy_do_funkcie_main|prednáške z minulého roku]]). Presnejšie, váš program dostane tri parametre: číslo K, číslo N a reťazec určujúci štruktúru na asociatívne pole. Ak neriešite bonus, môžete tento parameter ignorovať. Váš program budete teda spúšťať napríklad takto: <tt>time -p NetBeansProjects/pdu3/dist/Debug/GNU-Linux-x86/pdu3 100 1000 mtf</tt>, čo znamená K=100, N=1000 a implementácia mtf. V programe budete potrebovať previesť parametre K a N na číslo, na čo môžete použiť napr funkciou sscanf z knižnice cstdio. | ||
+ | |||
+ | Takto upravený program spustite na súbore uvedenom vyššie pre vhodné K a hodnoty N=10,100,1000 a 10000. Pre každé N spustite program 5 krát, zapíšte si namerané časy a spočítajte ich priemer. Snažte sa robiť všetky experimenty za porovnateľných podmienok (ten istý počítač, približne rovnaká záťaž z iných programov, to isté K). | ||
+ | |||
+ | V Moodli odovzdajte | ||
+ | * zdrojový kód programu (.cpp). Ak robíte bonus, odovzdajte hlavnú aj bonusovú časť v jednom programe. | ||
+ | * súbor opisujúci výsledky vašich meraní vo formáte .pdf alebo .txt. V tomto súbore uveďte prehľadne namerané časy a ich priemery. Krátko skomentujte, čo z vašich meraní usudzujete (ktorá hodnota N je najlepšia, či vôbec záleží na N, v prípade bonusu aj ako sa porovnajú rôzne metódy). | ||
+ | |||
+ | ==Bonus== | ||
+ | |||
+ | Okrem vyššie uvedenej dátovej štruktúry riešte úlohu aj nasledujúcimi spôsobmi: | ||
+ | * použite takú istú hašovaciu tabuľku so spájanými zoznamami, ale po nájdení prvku ho nechajte na tom istom mieste, nepresúvajte ho na začiatok zoznamu | ||
+ | * namiesto hašovacej tabuľky použite dátovú štruktúru map <string, int> z knižnice map, kde si pre každé slovo uložené v C++ type string ukladáte počet jeho výskytov. Viac o použití štruktúry map nájdete [http://www.sgi.com/tech/stl/Map.html tu] alebo [http://www.cplusplus.com/reference/stl/map/ tu]. | ||
+ | |||
+ | Tretí argument vášho programu určuje, ktorá z týchto metód sa použije. Pre základnú verziu úlohy je to reťazec mtf, pre hašovanie bez presúvania prvkov je to hash a pre štandardný map je to reťazec map. Pre map ignorujte parameter N. Spustite program aj s týmito novými nastaveniami a uveďte namerané časy, porovnajte s pôvodnými výsledkymi zo základnej časti úlohy. | ||
+ | =Prednáška 15= | ||
+ | ==Opakovanie smerníkov== | ||
+ | Smerníky na jednoduché premenné: | ||
+ | <pre> | ||
+ | int a = 7; /* premenna typu int */ | ||
+ | int *b = NULL; /* smernik na premennu typu int */ | ||
+ | b = &a; /* b ukazuje na a */ | ||
+ | *b = 8; /* v premennej a je teraz 8 */ | ||
+ | a = (*b)+1; /* v premennej a je teraz 9 */ | ||
+ | </pre> | ||
+ | |||
+ | Smerníky na structy: | ||
+ | <pre> | ||
+ | struct bod { | ||
+ | int x,y; | ||
+ | }; | ||
+ | bod *p; /* smernik na structuru typu bod */ | ||
+ | p = new bod; /* alokovanie noveho bodu */ | ||
+ | p->x = 10; /* dve formy priradovania do sucasti structu */ | ||
+ | (*p).y = 20; | ||
+ | delete p; /* uvoľníme alokovanú pamäť */ | ||
+ | </pre> | ||
+ | |||
+ | Smerníky a polia, alokovanie poľa: | ||
+ | <pre> | ||
+ | int a[3]; | ||
+ | int *b = a; /* a,b su teraz takmer rovnocenne premenne */ | ||
+ | *b = 3; | ||
+ | b[1] = 4; | ||
+ | a[2] = 5; /* v poli sú teraz čísla 3,4,5 */ | ||
+ | b = new int[a[1]]; /* b teraz ukazuje na nove pole dlzky 4 */ | ||
+ | delete[] b; /* uvoľníme pamäť alokovanú pre nové pole */ | ||
+ | </pre> | ||
+ | |||
+ | == Smerníková aritmetika == | ||
+ | |||
+ | * Pole je vlastne smerník na svoj prvý prvok | ||
+ | * Majme napr. pole <tt>int a[4] = {4, 3, 2, 1};</tt> | ||
+ | * K ''i''-temu prvku sa vieme dostať pomocou <tt>a[i]</tt> | ||
+ | * Dá sa to však napísať aj ako <tt>*(a+i)</tt> | ||
+ | * Konkrétne ''a+i'' je smerník na ''i''-ty prvok poľa ''a'' | ||
+ | * Kompilátor spočíta veľkosť jedného políčka poľa, takže vie, ako ďaleko sa posunúť, aby sa dostal na ''i''-te políčko | ||
+ | * <tt>int *b = a+2</tt> vytvorí smerník na ''a[2]'', ale k ''b'' sa môžeme správať ako ku dvojprvkovému poľu <tt>{2, 1}</tt> | ||
+ | |||
+ | '''Smerníková aritmetika:''' | ||
+ | * <tt>smerník + n</tt>: Posun smerníka o ''n''. Ak napríklad smerník ukazuje na 0. prvok poľa, smerník + n bude ukazovať na ''n''-tý prvok poľa. | ||
+ | ** Ak chceme zvýšiť smerník o 1 môžeme použiť <tt>smerník++</tt>. | ||
+ | * <tt>smerník - n</tt>: Posun smerníka o ''n'' prvkov smerom k začiatku. | ||
+ | * <tt>smerník1 - smerník2</tt>: Výsledkom rozdielu smerníkov je vzdialenosť miest na ktoré ukazujú. Ak napríklad prvý smerník ukazuje na 5. prvok poľa a druhý smerník na 3. prvok poľa ich rozdiel je 2. Smerníky musia patriť do toho istého poľa, inak bude výsledok nedefinovaný. | ||
+ | |||
+ | '''Porovnávanie ukazovateľov:''' | ||
+ | * operátory: <tt>< <= > >= == !=</tt> | ||
+ | * porovnávanie má zmysel len keď ukazovatele: | ||
+ | ** sú rovnakého typu | ||
+ | ** ukazujú do toho istého poľa | ||
+ | |||
+ | Tu je napr. zvláštny spôsob ako vypísať pole ''a'' definované vyššie: | ||
+ | <pre> | ||
+ | for (int *smernik = a; smernik < a + 4; smernik++) { | ||
+ | cout << "Prvok " << smernik - a << " je " << *smernik << endl; | ||
+ | }</pre> | ||
+ | |||
+ | Podobný kód sa ale občas používa na prechádzanie reťazcov, napr. ak chceme zrátať počet medzier v reťazci: | ||
+ | <pre> | ||
+ | int zratajMedzery(char str[]) { // mohli by sme dat aj char *str | ||
+ | int pocet = 0; | ||
+ | while(*str != 0) { // kym nenajdeme ukoncovaciu nulu v retazci | ||
+ | if(*str==' ') { pocet++; } // skontroluj znak, na ktory ukazuje smernik | ||
+ | str++; // posun smernik na dalsi znak | ||
+ | } | ||
+ | return pocet; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Funkcie z knižnice cstring s reťazcovou aritmetikou=== | ||
+ | |||
+ | * strstr(text, vzorka) vracia smerník na char | ||
+ | ** NULL ak sa vzorka nenachádza v texte, smerník na začiatok prvého výskytu inak | ||
+ | ** pozíciu výskytu zistíme smerníkovou aritmetikou: | ||
+ | <pre> | ||
+ | char *text, *vzorka; | ||
+ | char *where = strstr(text, vzorka); | ||
+ | if(where != NULL) { | ||
+ | int position = where - text; | ||
+ | } | ||
+ | </pre> | ||
+ | * Ako by ste spočítali počet výskytov vzorky v texte? | ||
+ | * Podobne strchr hľadá prvý výskyt znaku v texte | ||
+ | |||
+ | === Sizeof() === | ||
+ | Operátor <tt>sizeof()</tt> zistí "veľkosť" dátového typu v bajtoch | ||
+ | * napr. pri struct sa nemusí jednať o súčet veľkostí | ||
+ | * presnejšie ide o vzdialenosť medzi nasledujúcimi prvkami poľa -- teda o koľko sa posunieme pri posune +1 v smerníkovej aritmetike | ||
+ | |||
+ | <pre> | ||
+ | int i, *pi; | ||
+ | sizeof(*pi); //počet bajtov potrebných na uloženie typu int | ||
+ | sizeof(i); // da sa napisat aj takto | ||
+ | sizeof(int); // alebo takto | ||
+ | |||
+ | sizeof(pi); // pocet bajtov na ulozenie smernika na int | ||
+ | sizeof(int *); // to iste | ||
+ | </pre> | ||
+ | |||
+ | ==Dvojrozmerné polia== | ||
+ | * Doteraz sme stále pracovali s jednorozmerným poľom, čo však ak potrebujeme dvojrozmerné pole, maticu? | ||
+ | * Spravme teraz maticu s n=10 riadkami a m=20 stĺpcami | ||
+ | * Spravíme si pole n jednorozmerných polí, t.j. pole smerníkov na int: <tt>int *a[n];</tt> | ||
+ | * Naalokujeme si n jednorozmerných polí veľkosti m a smerník na každé uložíme do jedného prvku poľa a | ||
+ | <pre> | ||
+ | const int n = 10; | ||
+ | const int m = 20; | ||
+ | int *a[n]; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | a[i] = new int[m]; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Prvok v i-tom riadku a j-tom stĺpci dostaneme jedným z týchto spôsobov: | ||
+ | * <tt>a[i][j]</tt> | ||
+ | * <tt>*(*(a+i)+j)</tt> | ||
+ | Tu je kód, ktorý vynuluje pole: | ||
+ | <pre> | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | for (int j = 0; j < m; j++) { | ||
+ | a[i][j] = 0; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Na konci sa patrí pamäť uvoľniť: | ||
+ | <pre> | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | delete[] a[i]; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Dynamicky alokovaná matica=== | ||
+ | Ak chceme n a m určiť dynamicky, napr. načítať ich zo súboru, musíme aj pole a alokovať pomocou new a nakoniec uvoľniť pomocou delete[]: | ||
+ | <pre> | ||
+ | #include <cstdio> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | int n, m; | ||
+ | scanf("%d %d,&n,&m); // nacitame n a m | ||
+ | int **a; // alokujeme maticu nxm | ||
+ | a = new int *[n]; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | a[i] = new int[m]; | ||
+ | } | ||
+ | |||
+ | for (int i = 0; i < n; i++) { // pracujeme s maticou, napr. vynulujeme ju | ||
+ | for (int j = 0; j < m; j++) { | ||
+ | a[i][j] = 0; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | for (int i = 0; i < n; i++) { // na konci uvolnime pamat | ||
+ | delete[] a[i]; | ||
+ | } | ||
+ | delete[] a; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Funkcie pre alokáciu matice=== | ||
+ | Na alokáciu a dealokáciu matice si napíšeme funkcie, môžu sa nám hodiť: | ||
+ | <pre> | ||
+ | int ** vytvorMaticu(int n, int m) { | ||
+ | /* vytvor maticu s n riadkami a m stlpcami */ | ||
+ | int **a; | ||
+ | a = new int *[n]; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | a[i] = new int[m]; | ||
+ | } | ||
+ | return a; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | <pre> | ||
+ | void zmazMaticu(int n, int m, int **a) { | ||
+ | /* uvolni pamat matice s n riadkami a m stlpcami */ | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | delete[] a[i]; | ||
+ | } | ||
+ | delete[] a; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | <pre> | ||
+ | void nacitajMaticu(FILE *f, int n, int m, int **a) { | ||
+ | /* matica je vytvorena, velkosti n, m, vyplnime ju cislami zo vstupu */ | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | for (int j = 0; j < m; j++) { | ||
+ | fscanf(f, "%d", &a[i][j]); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Všimnite si, že všetkým funkciám dávame aj rozmery matice. Namiesto toho by sme si mohli spraviť štruktúru podobne ako pri vektore: | ||
+ | <pre> | ||
+ | struct matica { | ||
+ | int n, m; | ||
+ | int **a; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Výšková mapa== | ||
+ | V matici môžeme mať danú napr. mapu: | ||
+ | * 0 znamené more | ||
+ | * kladné číslo znamená pevninu a udáva nadmorskú výšku (napr. v metroch) | ||
+ | Táto reprezentácia neumožňuje zapísať pevninu pod úrovňou mora. | ||
+ | |||
+ | Pomocou funkcií vyššie môžeme takúto mapu načítať zo súboru a môžeme spraviť napr. program, ktorý zobrazí more modrou a pevninou odtieňami zelenej a hnedej podľa nadmorskej výšky. Príklad matice a obrázku: | ||
+ | |||
+ | [[Image:PROG-P12-mapa.png|right]] | ||
+ | <pre> | ||
+ | 22 11 | ||
+ | 0 0 0 0 0 0 0 0 0 0 0 | ||
+ | 0 20 40 60 80 100 120 140 120 0 0 | ||
+ | 0 40 80 120 160 200 240 280 190 100 0 | ||
+ | 0 60 120 180 240 300 360 420 260 100 0 | ||
+ | 0 80 160 240 320 400 480 560 260 100 0 | ||
+ | 0 100 200 300 400 500 600 700 330 100 0 | ||
+ | 0 120 240 360 480 600 720 840 400 100 0 | ||
+ | 0 140 280 420 560 700 840 980 470 100 0 | ||
+ | 0 160 320 480 640 800 960 700 200 0 0 | ||
+ | 0 180 360 540 720 900 700 500 0 0 0 | ||
+ | 0 200 400 600 800 1000 1200 1400 680 100 0 | ||
+ | 0 220 440 660 880 1100 1320 1540 750 100 0 | ||
+ | 0 240 480 720 960 1200 1440 1680 820 100 0 | ||
+ | 0 260 520 780 1040 1300 1560 1820 1200 400 0 | ||
+ | 0 280 560 840 1120 1400 1680 1960 1500 600 0 | ||
+ | 0 240 480 720 960 1200 1440 1680 1000 400 0 | ||
+ | 0 200 400 600 800 1000 1200 1400 680 100 0 | ||
+ | 0 160 320 480 640 800 960 1120 540 100 0 | ||
+ | 0 120 240 360 480 600 720 840 400 100 0 | ||
+ | 0 80 160 240 320 400 480 560 260 100 0 | ||
+ | 0 40 80 120 160 200 240 280 120 0 0 | ||
+ | 0 0 0 0 0 0 0 0 0 0 0 | ||
+ | </pre> | ||
+ | |||
+ | Okrem zobrazovania môžeme chcieť napríklad nájsť polohu najvyššieho vrchu a zobraziť ho v čiernom rámčeku, ako na obrázku vyššie. | ||
+ | * Čo spraví funkcia, ak je celá mapa pokrytá morom? | ||
+ | <pre> | ||
+ | void najvyssiVrch(int n, int m, int **a, int &riadok, int &stlpec) { | ||
+ | /* najdi polohu najvyssej hodnoty v matici */ | ||
+ | riadok = 0; | ||
+ | stlpec = 0; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | for (int j = 0; j < m; j++) { | ||
+ | if(a[i][j]>a[riadok][stlpec]) { | ||
+ | riadok = i; | ||
+ | stlpec = j; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Príklad hlavného programu, ktorý hľadá najvyšší vrch. | ||
+ | <pre> | ||
+ | int main(void) { | ||
+ | /* nacitaj rozmery matice */ | ||
+ | int n, m; | ||
+ | scanf("%d %d", &n, &m); | ||
+ | |||
+ | /* vytvor a nacitaj maticu */ | ||
+ | int **a = vytvorMaticu(n, m); | ||
+ | nacitajMaticu(cin, n, m, a); | ||
+ | |||
+ | /* najdi najvyssi vrch */ | ||
+ | int riadok, stlpec; | ||
+ | najvyssiVrch(n, m, a, riadok, stlpec); | ||
+ | |||
+ | /* uvolni pamat matice */ | ||
+ | zmazMaticu(n, m, a); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Zdrojový kód celého programu=== | ||
+ | * Tento program načíta maticu, nájde najvyšší vrch a vykreslí obrázok: [[#Program mapa pre prednášku 15]] | ||
+ | |||
+ | ==Hra life== | ||
+ | |||
+ | [http://en.wikipedia.org/wiki/Conway%27s_Game_of_Life Hra life] je jednoduchá simulácia kolónie buniek, ktorá má zaujímavé teoretické vlastnosti. | ||
+ | * Máme mriežku m x n štvorčekov, v každom žije najviac 1 bunka | ||
+ | * Bunky sa rodia a umierajú podľa toho, koľko majú susedov v ôsmych okolitých políčkach | ||
+ | ** Ak v čase t má bunka 2 alebo 3 susedov, zostane žiť aj v čase t+1, inak zomiera | ||
+ | ** Ak v čase t má prázden políčko presne 3 susedov, narodí sa tam v čase t+1 nová bunka | ||
+ | |||
+ | Stav hry si môžeme pamätať v matici boolovských hodnôt. | ||
+ | |||
+ | ===Rátanie zmeny v matici=== | ||
+ | * Stav v čase t máme v matici a, do matice b chceme dať stav v čase t+1 | ||
+ | <pre> | ||
+ | int zratajOkolie(int n, int m, bool **a, int riadok, int stlpec) { | ||
+ | /* pocet zivych prvkov v okoli */ | ||
+ | int sucet = 0; | ||
+ | for (int i = riadok - 1; i <= riadok + 1; i++) { | ||
+ | for (int j = stlpec - 1; j <= stlpec + 1; j++) { | ||
+ | /* treba osetrit okraje matice */ | ||
+ | if (i >= 0 && i < n && j >= 0 && j < m && a[i][j]) { | ||
+ | sucet++; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | /* samotny stvorcek nechceme zaratat */ | ||
+ | if (a[riadok][stlpec]) { | ||
+ | sucet--; | ||
+ | } | ||
+ | return sucet; | ||
+ | } | ||
+ | |||
+ | void prepocitajMaticu(int n, int m, bool **a, bool **b) { | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | for (int j = 0; j < m; j++) { | ||
+ | int pocet = zratajOkolie(n, m, a, i, j); | ||
+ | /* prirad do b[i][j] hodnotu podla okolia a[i][j] */ | ||
+ | b[i][j] = (pocet == 3 || (pocet == 2 && a[i][j])); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Hlavný program=== | ||
+ | * Prepočítavanie chceme opakovať v cykle pre viacero časových intervalov | ||
+ | * Môžeme prekopírovať celú maticu z b späť do a, ale rýchlejšie je len vymeniť smerníky | ||
+ | <pre> | ||
+ | for (int i = 0; i < 10; i++) { | ||
+ | /* podla a spocitaj maticu do b */ | ||
+ | prepocitajMaticu(n, m, a, b); | ||
+ | /* vymen smerniky, aby v a bola nova matica */ | ||
+ | bool **tmp = b; | ||
+ | b = a; | ||
+ | a = tmp; | ||
+ | } | ||
+ | </pre> | ||
+ | * vytvorMaticu, zmazMaticu a pod. prepíšeme tak, aby robili s maticou boolovských hodnôt namiesto intov | ||
+ | <pre> | ||
+ | int main(void) { | ||
+ | /* nacitaj rozmery matice */ | ||
+ | int n, m; | ||
+ | scanf("%d %d", &n, &m); | ||
+ | |||
+ | /* vytvor a nacitaj maticu */ | ||
+ | bool **a = vytvorMaticu(n, m); | ||
+ | nacitajMaticu(stdin, n, m, a); | ||
+ | |||
+ | /* zobraz maticu */ | ||
+ | SimpleDraw window(m*stvorcek, n * stvorcek); | ||
+ | zobrazMaticu(n, m, a, window); | ||
+ | window.wait(2); | ||
+ | |||
+ | /* pomocna matica na vypocty */ | ||
+ | bool **b = vytvorMaticu(n, m); | ||
+ | |||
+ | /* simuluj 10 krokov hry life */ | ||
+ | for (int i = 0; i < 10; i++) { | ||
+ | /* podla a spocitaj maticu do b */ | ||
+ | prepocitajMaticu(n, m, a, b); | ||
+ | /* prekresli, co sa zmenilo */ | ||
+ | zobrazZmeny(n, m, a, b, window); | ||
+ | window.wait(2); | ||
+ | /* vymen smerniky, aby v a bola nova matica */ | ||
+ | bool **tmp = b; | ||
+ | b = a; | ||
+ | a = tmp; | ||
+ | } | ||
+ | |||
+ | /* uvolni pamat matic */ | ||
+ | zmazMaticu(n, m, a); | ||
+ | zmazMaticu(n, m, b); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Detaily vykresľovania=== | ||
+ | * Na začiatku vykreslíme celú maticu, potom prekreslíme vždy len tie bunky, ktoré sa zmenili | ||
+ | <pre> | ||
+ | void zobrazStvorcek(int i, int j, bool hodnota, SimpleDraw &window) { | ||
+ | /* zobraz stvorcek v riadku i a stlpci j */ | ||
+ | window.setPenColor("white"); | ||
+ | if (hodnota) { | ||
+ | window.setBrushColor("black"); | ||
+ | } else { | ||
+ | window.setBrushColor("white"); | ||
+ | } | ||
+ | window.drawRectangle(j*stvorcek, i*stvorcek, stvorcek, stvorcek); | ||
+ | } | ||
+ | |||
+ | void zobrazMaticu(int n, int m, bool **a, SimpleDraw &window) { | ||
+ | /* zobraz prvky true ciernymi stvorcekmi */ | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | for (int j = 0; j < m; j++) { | ||
+ | /* nastavenie farby podla hodnoty */ | ||
+ | if (a[i][j]) { | ||
+ | zobrazStvorcek(i, j, true, window); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void zobrazZmeny(int n, int m, bool **a, bool **b, SimpleDraw &window) { | ||
+ | /* zobraz nove stvorceky na miestach, kde bola zmena */ | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | for (int j = 0; j < m; j++) { | ||
+ | if (a[i][j] != b[i][j]) zobrazStvorcek(i, j, b[i][j], window); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Príklad vstupu=== | ||
+ | * Pre jednoduchosť vstup uvádzame ako nuly a jednotky bez medzier (1=živá bunka) | ||
+ | <pre> | ||
+ | 20 20 | ||
+ | 00000000000000000000 | ||
+ | 00000000000000000000 | ||
+ | 00000000000000000000 | ||
+ | 00000000000000000000 | ||
+ | 00000000000000000000 | ||
+ | 00000000000000000000 | ||
+ | 00000000000000000000 | ||
+ | 00000000000000000000 | ||
+ | 00000000000000000000 | ||
+ | 00000111111111100000 | ||
+ | 00000000000000000000 | ||
+ | 00000000000000000000 | ||
+ | 00000000000000000000 | ||
+ | 00000000000000000000 | ||
+ | 00000000000000000000 | ||
+ | 00000000000000000000 | ||
+ | 00000000000000000000 | ||
+ | 00000000000000000000 | ||
+ | 00000000000000000000 | ||
+ | 00000000000000000000 | ||
+ | </pre> | ||
+ | |||
+ | ===Zdrojový kód celého programu=== | ||
+ | * Tento program načíta vstup a simuluje 10 krokov hry Life: [[#Program life pre prednášku 15]] | ||
+ | |||
+ | |||
+ | ==Pole reťazcov== | ||
+ | Dvojrozmerné polia v C/C++ nemusia mať všetky riadky rovnako dlhé. | ||
+ | * Spomeňte si, že v C je reťazec jednoducho pole char-ov, kde za posledným znakom ide špeciálny znak 0 | ||
+ | * Pole reťazcov bude teda dvojrozmerné pole char-ov | ||
+ | * Môžeme načítavať napr. súbor po riadkoch, pričom každý riadok načítame do dlhého poľa, ktoré by malo stačiť a potom do prekopírujeme do akurát veľkého riadku v poli | ||
+ | * Nakoniec program riadky vypíše odzadu | ||
+ | * Ak by sme vopred alokovali maxN riadkov, každý veľkosti maxRiadok, vyšlo by potenciálne na zmar oveľa viac pamäte. | ||
+ | <pre> | ||
+ | #include <cstdio> | ||
+ | #include <string.h> | ||
+ | using namespace std; | ||
+ | |||
+ | const int maxRiadok = 1000; | ||
+ | const int maxN = 1000; | ||
+ | |||
+ | int main(void) { | ||
+ | char *a[maxN]; | ||
+ | char riadok[maxRiadok]; | ||
+ | int n = 0; | ||
+ | while (true) { | ||
+ | if (!fgets(riadok, maxRiadok,stdin)) break; | ||
+ | a[n] = new char[strlen(riadok)+1]; | ||
+ | strcpy(a[n], riadok); | ||
+ | n++; | ||
+ | if (feof(stdin)) break; | ||
+ | } | ||
+ | |||
+ | for(int i=n-1; i>=0; i--) { | ||
+ | printf("%s", a[i]); | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Program mapa pre prednášku 15== | ||
+ | <pre> | ||
+ | /* Program Mapa z prednášky 15. | ||
+ | http://compbio.fmph.uniba.sk/vyuka/prog/index.php/Predn%C3%A1%C5%A1ka_15 */ | ||
+ | |||
+ | #include "../SimpleDraw.h" | ||
+ | #include <cstdio> | ||
+ | |||
+ | /* velkost stvorceka mapy v pixeloch */ | ||
+ | const int stvorcek = 15; | ||
+ | |||
+ | int ** vytvorMaticu(int n, int m) { | ||
+ | /* vytvor maticu s n riadkami a m stlpcami */ | ||
+ | int **a; | ||
+ | a = new int *[n]; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | a[i] = new int[m]; | ||
+ | } | ||
+ | return a; | ||
+ | } | ||
+ | |||
+ | void zmazMaticu(int n, int m, int **a) { | ||
+ | /* uvolni pamat matice s n riadkami a m stlpcami */ | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | delete[] a[i]; | ||
+ | } | ||
+ | delete[] a; | ||
+ | } | ||
+ | |||
+ | void nacitajMaticu(FILE *f, int n, int m, int **a) { | ||
+ | /* matica je vytvorena, velkosti n, m, vyplnime ju cislami zo vstupu */ | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | for (int j = 0; j < m; j++) { | ||
+ | fscanf(f, "%d", &a[i][j]); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void farba(SimpleDraw &window, int r, int g, int b) { | ||
+ | /* nastav farbu ciary aj vyplne na dane hodnoty */ | ||
+ | window.setBrushColor(r, g, b); | ||
+ | window.setPenColor(r, g, b); | ||
+ | } | ||
+ | |||
+ | void zobrazMaticu(int n, int m, int **a, SimpleDraw &window) { | ||
+ | /* zobraz maticu farebnymi stvorcekmi : | ||
+ | * modra: more (hodnota 0) | ||
+ | * zelena: niziny 1..200, | ||
+ | * hneda: pohoria 200..2000 */ | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | for (int j = 0; j < m; j++) { | ||
+ | /* nastavenie farby podla hodnoty */ | ||
+ | if (a[i][j] == 0) { | ||
+ | farba(window, 0, 0, 255); | ||
+ | } else if (a[i][j] <= 200) { | ||
+ | double x = a[i][j] / 200.0; | ||
+ | farba(window, x * 255, 127 + x * 127, 0); | ||
+ | } else { | ||
+ | double x = (a[i][j] - 200) / 2000.0; | ||
+ | farba(window, 255 - x * 150, 255 - x * 200, 0); | ||
+ | } | ||
+ | /* vykresleni stvorceka, pozor: vymena suradnic */ | ||
+ | window.drawRectangle(j*stvorcek, i*stvorcek, stvorcek, stvorcek); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void najvyssiVrch(int n, int m, int **a, int &riadok, int &stlpec) { | ||
+ | /* najdi polohu najvyssej hodnoty v matici */ | ||
+ | riadok = 0; | ||
+ | stlpec = 0; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | for (int j = 0; j < m; j++) { | ||
+ | if(a[i][j]>a[riadok][stlpec]) { | ||
+ | riadok = i; | ||
+ | stlpec = j; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | /* nacitaj rozmery matice */ | ||
+ | int n, m; | ||
+ | scanf("%d %d", &n, &m); //22 11 | ||
+ | |||
+ | /* vytvor a nacitaj maticu */ | ||
+ | int **a = vytvorMaticu(n, m); | ||
+ | |||
+ | nacitajMaticu(stdin, n, m, a); | ||
+ | |||
+ | /* zobraz maticu */ | ||
+ | SimpleDraw window(m*stvorcek, n * stvorcek); | ||
+ | zobrazMaticu(n, m, a, window); | ||
+ | |||
+ | /* najdi najvyssi vrch a zobraz ho stvorcekom */ | ||
+ | int riadok, stlpec; | ||
+ | najvyssiVrch(n, m, a, riadok, stlpec); | ||
+ | window.unsetBrush(); | ||
+ | window.setPenColor("black"); | ||
+ | window.drawRectangle(stlpec*stvorcek, riadok*stvorcek, stvorcek, stvorcek); | ||
+ | |||
+ | /* zobraz okno */ | ||
+ | window.showAndClose(); | ||
+ | |||
+ | /* uvolni pamat matice */ | ||
+ | zmazMaticu(n, m, a); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Program life pre prednášku 15== | ||
+ | <pre> | ||
+ | /* Program Hra Life z prednášky 15. | ||
+ | http://compbio.fmph.uniba.sk/vyuka/prog/index.php/Predn%C3%A1%C5%A1ka_15 */ | ||
+ | |||
+ | #include "../SimpleDraw.h" | ||
+ | #include <string> | ||
+ | #include<cstdio> | ||
+ | #include <cassert> | ||
+ | using namespace std; | ||
+ | |||
+ | /* velkost stvorceka */ | ||
+ | const int stvorcek = 15; | ||
+ | |||
+ | bool ** vytvorMaticu(int n, int m) { | ||
+ | /* vytvor maticu s n riadkami a m stlpcami */ | ||
+ | bool **a; | ||
+ | a = new bool *[n]; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | a[i] = new bool[m]; | ||
+ | } | ||
+ | return a; | ||
+ | } | ||
+ | |||
+ | void zmazMaticu(int n, int m, bool **a) { | ||
+ | /* uvolni pamat matice s n riadkami a m stlpcami */ | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | delete[] a[i]; | ||
+ | } | ||
+ | delete[] a; | ||
+ | } | ||
+ | |||
+ | void nacitajMaticu(FILE *f, int n, int m, bool **a) { | ||
+ | /* matica je vytvorena, velkosti n, m, vyplnime ju cislami zo vstupu */ | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | char riadok[100]; | ||
+ | fscanf(f,"%s",riadok); | ||
+ | assert(strlen(riadok) == m); | ||
+ | for (int j = 0; j < m; j++) { | ||
+ | a[i][j] = (riadok[j] == '1'); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void zobrazStvorcek(int i, int j, bool hodnota, SimpleDraw &window) { | ||
+ | /* zobraz stvorcek v riadku i a stlpci j */ | ||
+ | window.setPenColor("white"); | ||
+ | if (hodnota) { | ||
+ | window.setBrushColor("black"); | ||
+ | } else { | ||
+ | window.setBrushColor("white"); | ||
+ | } | ||
+ | window.drawRectangle(j*stvorcek, i*stvorcek, stvorcek, stvorcek); | ||
+ | } | ||
+ | void zobrazMaticu(int n, int m, bool **a, SimpleDraw &window) { | ||
+ | /* zobraz prvky true ciernymi stvorcekmi */ | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | for (int j = 0; j < m; j++) { | ||
+ | /* nastavenie farby podla hodnoty */ | ||
+ | if (a[i][j]) { | ||
+ | zobrazStvorcek(i, j, true, window); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | =Prednáška 16= | ||
+ | ==Dynamická alokácia poľa a matice, opakovanie== | ||
+ | * 1D pole: <tt>int *a = new int[n]; cin >> a[0];</tt> | ||
+ | * 2D pole: <tt>int **a = new int * [n]; for(int i=0; i<n; i++) a[i] = new int[m]; cin >> a[0][1];</tt> | ||
+ | ** Riadky 2D poľa nemusia byť rovnako dlhé | ||
+ | * 3D pole: <tt>int ***a = new int ** [n]; ... </tt> | ||
+ | |||
+ | ==Vstupy do funkcie main== | ||
+ | * Netbeans vám vyrobí main funkciu s nasledujúcou hlavičkou: | ||
+ | <pre> | ||
+ | int main(int argc, char** argv) { | ||
+ | </pre> | ||
+ | * char **argv je pole C-čkových reťazcov a argc je počet reťazcov v tomto poli | ||
+ | * Prvý z nich, argv[0], je meno samotného programu a ostatné sú argumenty programu | ||
+ | * Užitočné, ak spúšťame program z príkazového riadku | ||
+ | * Dá sa nastaviť v Netbeans, Properties, Run | ||
+ | * Tento program jednoducho argumenty vypíše | ||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(int argc, char** argv) { | ||
+ | for (int i = 0; i < argc; i++) { | ||
+ | cout << argv[i] << endl; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Smerníkové kuriozity== | ||
+ | <pre> | ||
+ | int *a[3]; /* pole 3 smerníkov na int */ | ||
+ | int (*b)[3]; /* jeden smerník na pole troch intov, neinicializovaný */ | ||
+ | int c[3] = {0,1,2}; /* pole troch intov */ | ||
+ | b = &c; /* teraz b ukazuje na pole c */ | ||
+ | cout << (*b)[2] << endl; /* pristup k prvku 2 pola c */ | ||
+ | cout << *b[2] << endl; /* zle: tvarime sa, ze b je pole, pristupime k jeho prvku 2 a interpretujeme ho ako smernik */ | ||
+ | </pre> | ||
+ | |||
+ | == Spájaný zoznam == | ||
+ | |||
+ | Ak niekde chceme uložiť ''N'' prvkov, doteraz sme videli nasledujúce možnosti: | ||
+ | * Vytvoriť pole pevnej veľkosti ''N'', ak je ''N'' vopred známa konštanta: <tt>const int N = 100; int A[N];</tt> | ||
+ | * Vytvoriť veľké pole, ktoré dúfame bude stačiť, časť z neho môže nepoužitá: <tt>const int maxN = 100; int A[maxN];</tt> | ||
+ | * Dynamicky alokovať pole ''N'' prvkov, ak ''N'' je číslo spočítané niekde v programe alebo načítané zo súboru: <tt>int *A = new int[N];</tt> | ||
+ | * Pomocou new vieme naprogramovať aj štruktúru vector, do ktorej môžeme postupne pridávať prvky, aj keď vopred nevieme ''N'' | ||
+ | |||
+ | Teraz si ukážeme ďalší spôsob, ako si prvky ukladať, keď vopred nevieme ich počet | ||
+ | |||
+ | === Štruktúra jednoduchého spájaného zoznamu === | ||
+ | |||
+ | '''Spájaný zoznam''' (linked list) je postupnosť uzlov rovnakého typu usporiadaných za sebou. | ||
+ | |||
+ | Každý uzol pozostáva z dvoch častí: | ||
+ | * smerník, ktorý ukazuje na nasledovníka a pomáha nám sa pohybovať po zozname | ||
+ | * samotné dáta, v našom prípade pre jednoduchosť int | ||
+ | |||
+ | Uzol spájaného zoznamu je teda pre naše účely nasledovného typu: | ||
+ | <pre> | ||
+ | struct item { | ||
+ | int data; | ||
+ | item* next; | ||
+ | }; | ||
+ | </pre> | ||
+ | Všimnite si, že vo vnútri definície typu item používame smerník na item. | ||
+ | |||
+ | Na rozdiel od poľa, v ktorom je poradie stanovené indexmi, je teda poradie v spájanom zozname určované ukazovateľmi next. | ||
+ | Ak <tt>x</tt> je prvok zoznamu, tak <tt>x.next</tt> je | ||
+ | * nasledujúci prvok zoznamu | ||
+ | * NULL (ak x je posledným prvkom zoznamu) | ||
+ | |||
+ | [[Image:PROG-list.png|200px]] | ||
+ | |||
+ | Samotný typ linkedList reprezentujúci celý zoznam si potrebuje pamätať smerník na úvodný prvok: | ||
+ | <pre> | ||
+ | struct linkedList { | ||
+ | item* first; | ||
+ | }; | ||
+ | </pre> | ||
+ | Pre prázdny zoznam <tt>z</tt> bude <tt>z.first</tt> rovné NULL. | ||
+ | |||
+ | Inicializácia zoznamu je teda veľmi jednoduchá: | ||
+ | |||
+ | <pre> | ||
+ | void init(linkedList &z){ | ||
+ | z.first = NULL; | ||
+ | } | ||
+ | |||
+ | int main(void){ | ||
+ | linkedList z; | ||
+ | init(z); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Tiež vieme veľmi jednoducho určiť, či je zoznam prázdny: | ||
+ | <pre> | ||
+ | bool empty(const linkedList &z){ | ||
+ | if (!z.first) return true; // resp. (z.first == NULL) | ||
+ | else return false; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Vkladanie a vymazanie na začiatku === | ||
+ | |||
+ | Na to, aby sme zoznam nejakým spôsobom naplnili, potrebujeme vedieť vôbec vytvoriť prvok zoznamu. To robíme dynamicky nasledovne: | ||
+ | <pre> | ||
+ | item* p=new item; | ||
+ | p->data=NEJAKE_DATA; | ||
+ | p->next=NEJAKY_SMERNIK_NIEKAM; | ||
+ | </pre> | ||
+ | |||
+ | Teda vytvoríme si smerník na uzol zoznamu, vyhradíme mu patričný kus pamäte a naplníme ho vhodnými dátami. | ||
+ | |||
+ | Môžeme si teda skúsiť vytvoriť zoznam z, ktorý bude mať 3 prvky 1,2 a 3. | ||
+ | |||
+ | <pre> | ||
+ | linkedList z; | ||
+ | item* p=new item; | ||
+ | item* q=new item; | ||
+ | item* r=new item; | ||
+ | p->data = 1; | ||
+ | q->data = 2; | ||
+ | r->data = 3; | ||
+ | p->next = q; | ||
+ | q->next = r; | ||
+ | r->next = NULL; | ||
+ | z.first = p; | ||
+ | </pre> | ||
+ | |||
+ | Pravdepodobne nechceme vytvárať zoznam ako v príklade a potrebujeme teda funkciu na vloženie prvku. Najjednoduchšia možnosť je vkladanie na začiatok zoznamu. Samozrejme prvku budeme musieť vhodne nastaviť jeho smerník next a asi aj nejaké smerníky v zozname. | ||
+ | |||
+ | <pre> | ||
+ | void insertFirst(linkedList &z, int d){ | ||
+ | /* do zoznamu z vlozi na zaciatok novy prvok s datami d */ | ||
+ | item* p = new item; // vytvoríme nový prvok | ||
+ | p->data = d; // naplníme dáta | ||
+ | p->next = z.first; // prvok bude prvým prvkom zoznamu (ukazuje na doterajší začiatok) | ||
+ | z.first = p; // tento prvok je novým začiatkom | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Pre vymazanie prvého prvku postupujeme podobne, len nesmieme zabudnúť okrem presmerovania začiatku aj uvoľniť pamäť pôvodne prvého prvku. | ||
+ | Funkcia deleteFirst vráti hodnotu prvého prvku a tento prvok vymaže. | ||
+ | |||
+ | <pre> | ||
+ | int deleteFirst(linkedList &z){ | ||
+ | /* zo zoznamu z vymaze prvy prvok a vrati jeho data */ | ||
+ | assert(z.first != NULL); // nemozeme mazat, ak je zoznam prazdny | ||
+ | |||
+ | item* p = z.first; // prvok, ktorý ideme vymazat | ||
+ | int d = z.first->data; // to čo máme vrátiť | ||
+ | z.first = z.first->next; // presmerujeme zoznam na novy zaciatok | ||
+ | delete p; // uvoľnenie pamäte | ||
+ | return d; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Prechádzanie zoznamu === | ||
+ | |||
+ | Veľmi dôležité je vedieť zoznamom prechádzať a postupne pracovať s jeho prvkami. Prechádzanie zoznamom je potrebné napríklad pre hľadanie konkrétneho prvku, hľadanie najväčšieho prvku, vypisovanie všetkých prvkov zoznamu atď | ||
+ | |||
+ | Ako budeme postupovať? | ||
+ | * Vytvoríme si smerník na prvky zoznamu x. | ||
+ | * Začneme prvým prvkom zoznamu. Na ten nám ukazuje smerník z.first. | ||
+ | * Kým x nebude na konci zoznamu (t.j. nebude NULL), vypíšeme patričné dáta (x->data) a presunieme sa na ďalší prvok (x->next) | ||
+ | * Vo chvíli keď je x NULL znamená to, že ďalší prvok už nie je (a je jedno, či sa to stalo hneď na začiatku - t.j. že z.first je NULL - alebo neskôr) | ||
+ | |||
+ | <pre> | ||
+ | void print(linkedList &z){ | ||
+ | item* x = z.first; | ||
+ | while (x != NULL){ | ||
+ | printf(" %d", x->data); | ||
+ | x = x->next; | ||
+ | } | ||
+ | printf("\n"); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Prejsť celý zoznam potrebujeme aj v prípade, že chcem uvoľniť pamäť (na konci programu). | ||
+ | <pre> | ||
+ | void destroy(linkedList &z){ | ||
+ | while (z.first != NULL){ | ||
+ | item* p = z.first; | ||
+ | z.first = z.first->next; | ||
+ | delete p; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | Dá sa to aj funkciami, ktoré sme si už napísali: | ||
+ | <pre> | ||
+ | void destroy(linkedList &z){ | ||
+ | while (!empty(z)){ | ||
+ | deleteFirst(z); | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | Alebo rekurzívne: | ||
+ | <pre> | ||
+ | void destroy(item *p) { | ||
+ | if(p!=NULL) { | ||
+ | destroy(p->next); | ||
+ | delete p; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void destroy(linkedList &z){ | ||
+ | destroy(z.first); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | == Utriedený zoznam == | ||
+ | |||
+ | Občas sa nám hodí, aby sme si zoznam udržiavali utriedený. Vkladanie doprostred zoznamu (pred nejaký prvok) ale môže spôsobiť niekoľko špeciálnych prípadov, ktoré potrebujeme ošetriť. | ||
+ | |||
+ | Keď chceme vkladať pred prvok x, potrebujeme totiž meniť jeho predchodcu, teda prvok, ktorý pôvodne ukazoval na x. Po vložení už nemá ukazovať na x, ale na novo vložený prvok. Preto potrebujeme celú dobu hľadania vhodného miesta pamätať na to, že predchodca je potrebný a niekde si ho pamätať. | ||
+ | |||
+ | Rozlišujeme teda 3 prípady: | ||
+ | * Zoznam je prázdny - vytvoríme prvok, naplníme dátami, nemá nasledovníka a je novým začiatkom | ||
+ | * Chceme vložiť na začiatok zoznamu - vytvoríme prvok, naplníme dátami, nasledovník je pôvodný začiatok a on je nový začiatok | ||
+ | * Ostatné prípady - nájdeme miesto, s tým, že sme o krok pozadu (teda všetko riešime z pozície predchodcu), vytvoríme prvok a upravíme | ||
+ | |||
+ | <pre> | ||
+ | void insert(linkedList& z, int data) { | ||
+ | item* p = new item; | ||
+ | p->data=data; | ||
+ | |||
+ | // máme prázdny zoznam alebo vkladáme pred prvý prvok | ||
+ | if (z.first==NULL || data < z.first->data) { | ||
+ | p->next= z.first; | ||
+ | z.first = p; | ||
+ | return; | ||
+ | } | ||
+ | |||
+ | //prvok nepatrí na začiatok | ||
+ | item* prev = z.first; | ||
+ | while ((prev->next != NULL) && (prev->next->data < data)){ | ||
+ | prev = prev->next; | ||
+ | } | ||
+ | p->next = prev->next; | ||
+ | prev->next = p; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Riešenie ako je popísané je správne, avšak je náročné na napísanie, aby sme vyriešili špeciálne prípady. Tu sú dve možné riešenia, ako sa takýmto prípadom vyhnúť: | ||
+ | |||
+ | '''Použitie zarážky (sentinel node)''': pridáme špeciálny uzol na začiatok (v niektorých prípadoch aj na koniec) zoznamu, pričom hodnotu jeho kľúča nepoužívame. | ||
+ | * prázdny zoznam teda obsahuje iba zarážku | ||
+ | * každý uzol má predchodcu a každý zoznam má prvý uzol | ||
+ | * vkladanie na začiatok znamená vložiť za zarážku | ||
+ | * nikdy nemažeme úplne prvý prvok, lebo to je zarážka | ||
+ | Zarážky sa niekedy používajú aj pri práci v poli - do poľa si umelo vložím špeciálny prvý alebo posledný prvok, čo mi uľahčí program. | ||
+ | |||
+ | '''Smerník na smerník:''' | ||
+ | * dva prípady v kóde vyššie oba nastavujú p->next a ešte nejaký iný smerník | ||
+ | * z.first aj prev->next majú typ item * | ||
+ | * vyrobíme si premennú typu item **, ktorá ukazuje na smerník, ktorý chceme potenciálne meniť | ||
+ | * touto premennou sa pohybujeme po zozname, až kým nenájdeme správne miesto | ||
+ | |||
+ | <pre> | ||
+ | void insert2(linkedList &z, int data){ | ||
+ | item* p = new item; | ||
+ | p->data = data; | ||
+ | |||
+ | item** it = &z.first; | ||
+ | while (*it && (*it)->data < data) { | ||
+ | it = &((*it)->next); | ||
+ | } | ||
+ | p->next = *it; | ||
+ | *it = p; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Podobne vymazávame prvky zo zoznamu. Vo funkcii remove nájdeme a vymažeme prvok s určitou hodnotou so zoznamu s utriedenými prvkami. Potrebné je si opäť pamätať jeho predchodcu, nakoľko tomuto prvku meníme nasledovníka. | ||
+ | |||
+ | <pre> | ||
+ | void remove(linkedList &z, int data) { | ||
+ | // prvok sa v zozname nenachádza resp. je zoznam prázdny | ||
+ | if (!z.first || z.first->data > data) return; | ||
+ | |||
+ | // vymazávam prvý prvok | ||
+ | if (data == z.first->data) { | ||
+ | item* to_del = z.first; | ||
+ | z.first = z.first->next; | ||
+ | delete to_del; | ||
+ | return; | ||
+ | } | ||
+ | |||
+ | // ostatné prípady | ||
+ | item* prev = z.first; | ||
+ | while (prev->next && prev->next->data < data) { | ||
+ | prev = prev->next; | ||
+ | } | ||
+ | if (prev->next && prev->next->data == data) { | ||
+ | item* to_del = prev->next; | ||
+ | prev->next = prev->next->next; | ||
+ | delete to_del; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | == Dvojsmerne spájaný zoznam == | ||
+ | |||
+ | Je to typ spájaného zoznamu, ktorý má smerník na svojho nasledovníka a aj smerník na svojho predchodcu. Ak je uzol prvý, hodnota smerníka na predchodcu má hodnotu NULL a obdobne, ak je uzol posledný, tak hodnota smerníka na nasledovníka je NULL. | ||
+ | |||
+ | Prvok zoznamu teda vyzerá takto: | ||
+ | <pre> | ||
+ | struct item { | ||
+ | int data; | ||
+ | item* next; | ||
+ | item* prev; | ||
+ | }; | ||
+ | </pre> | ||
+ | |||
+ | Obvykle sa potom okrem začiatku zoznamu udržuje aj smerník na koniec (teda posledný prvok zoznamu). Teda zoznam vyzerá nasledovne: | ||
+ | <pre> | ||
+ | struct linkedList { | ||
+ | item* first; | ||
+ | item* last; | ||
+ | }; | ||
+ | </pre> | ||
+ | |||
+ | Pre inicializáciu je potrebné okrem začiatku nastaviť aj koniec. Uvoľňovanie pamäti funguje úplne rovnako ako v jednosmerne spájanom. | ||
+ | |||
+ | === Vkladanie a vymazávanie na začiatku === | ||
+ | |||
+ | Vkladanie na začiatok podobne ako pri jednosmernom zozname, ale upravujeme viac smerníkov. | ||
+ | * Podobne sa dá pracovať aj na konci zoznamu, keďže smerník na koniec si tiež udržujeme. | ||
+ | |||
+ | <pre> | ||
+ | void insertFirst(linkedList &z, int d){ | ||
+ | item* p = new item; | ||
+ | p->next = z.first; | ||
+ | p->prev = NULL; | ||
+ | p->data = d; | ||
+ | if (z.first != NULL){ | ||
+ | z.first->prev = p; | ||
+ | } | ||
+ | else { | ||
+ | z.last = p; | ||
+ | } | ||
+ | z.first = p; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Rozdiely oproti jednosmerne spájanému zoznamu: | ||
+ | * Ak je zoznam prázdny, po vložení treba nastaviť smerník na koniec zoznamu. | ||
+ | * Ak zoznam nie je prázdny, treba nastaviť predchádzajúci prvok pôvodnému začiatku, teda smerník (z.first)->prev. | ||
+ | |||
+ | Pri vymazávaní potrebujeme ošetriť, či sme nevymazali posledný prvok. V tom prípade potrebujeme nastaviť správne aj koniec zoznamu. | ||
+ | |||
+ | <pre> | ||
+ | int deleteFirst(linkedList &z){ | ||
+ | /* zo zoznamu z vymaze prvy prvok a vrati jeho data */ | ||
+ | assert(z.first != NULL); // nemozeme mazat, ak je zoznam prazdny | ||
+ | |||
+ | item* p = z.first; // prvok, ktorý ideme vymazat | ||
+ | int d = z.first->data; // to čo máme vrátiť | ||
+ | z.first = z.first->next; // presmerujeme zoznam na novy zaciatok | ||
+ | if(z.first==NULL) z.last = NULL; | ||
+ | else z.first->prev = NULL; | ||
+ | delete p; // uvoľnenie pamäte | ||
+ | return d; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Prechádzanie zoznamu odpredu/odzadu === | ||
+ | |||
+ | Na prechádzanie dvojsmerne spájaného zoznamu je možné použiť rovnaký postup ako pri prechádzaní jednosmerného. | ||
+ | Okrem toho máme možnosť urobiť aj prechádzanie/výpis zoznamu odzadu. | ||
+ | <pre> | ||
+ | void vypisOdzadu(linkedList &z){ | ||
+ | item* x = z.last; | ||
+ | while (x != NULL){ | ||
+ | printf("%d ", x->data); | ||
+ | x=x->prev; | ||
+ | } | ||
+ | printf("\n"); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Vďaka tejto možnosti teda vieme jednoducho nájsť k-ty prvok odzadu zoznamu. | ||
+ | <pre> | ||
+ | int kOdzadu(linkedList &z, int k){ | ||
+ | item* x = z.last; | ||
+ | int data; | ||
+ | for (int i = 0; i < k; i++){ | ||
+ | if (x == NULL) return -1; | ||
+ | data = x->data; | ||
+ | x = x->prev; | ||
+ | } | ||
+ | return data; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Zhrnutie== | ||
+ | * V spájanom zozname máme uzly pospájané smerníkmi | ||
+ | * Môžeme si do neho uložiť postupnosť prvkov aj keď nevieme vopred, aká bude dlhá | ||
+ | * Cez zoznam môžeme ľahko prejsť, ale nevieme rýchlo skočiť niekam do stredu (toto zase vieme v poli) | ||
+ | * Existuje veľa variantov: jednosmerne / obojsmerne spájané, kruhové, so sentinelmi, môžeme si pamätať začiatok alebo začiatok aj koniec... | ||
+ | * Pozor na smerníky, aby všetky správne ukazovali a aby sa nám zoznam nepomotal | ||
+ | * Príklady využitia zoznamov na ďalších prednáškach, napr. hašovanie, zásobník a rad. | ||
+ | =Cvičenia 8= | ||
+ | == Vstup== | ||
+ | * Napíšte program, ktorý vypíše súbor vstup.txt na obrazovku tak, že všetky riadky dlhšie ako 80 znakov ureže na 80-tom stĺpci. | ||
+ | ** Váš program by mal fungovať aj pre súbory s veľmi dlhými riadkami | ||
+ | * Napíšte program, ktorý od užívateľa načíta názvy dvoch súborov a potom zistí, či tieto dva súbory majú rovnaký obsah. | ||
+ | * V súbore máme na každom riadku tri údaje oddelené medzerami: desatinné číslo, znamienko (jedno z +, -, *, /) a druhé desatinné číslo. Postupne načítavajte tento súbor a na konzolu vypisujte výrazy aj s výslednou hodnotu. Na vypisovanie čísel typu double skúste použiť formát %g v príkaze printf. Príklad: | ||
+ | |||
+ | Vstup: | ||
+ | <pre> | ||
+ | 1.5 + 3 | ||
+ | -7 - -8.1 | ||
+ | 3 / 2 | ||
+ | </pre> | ||
+ | Výstup: | ||
+ | <pre> | ||
+ | 1.5 + 3 = 4.5 | ||
+ | -7 - -8.1 = 1.1 | ||
+ | 3 / 2 = 1.5 | ||
+ | </pre> | ||
+ | |||
+ | ==Výstup== | ||
+ | * Do súboru vypíšte tabuľku hodnôt funkcie sin(x) pre x od -1 po 1 s krokom 0.2, pričom ich bude vypisovať na 5 desatinných miest a x aj sin(x) budú zarovnané doprava: | ||
+ | <pre> | ||
+ | -1.0 -0.84147 | ||
+ | -0.8 -0.71736 | ||
+ | -0.6 -0.56464 | ||
+ | -0.4 -0.38942 | ||
+ | -0.2 -0.19867 | ||
+ | -0.0 -0.00000 | ||
+ | 0.2 0.19867 | ||
+ | 0.4 0.38942 | ||
+ | 0.6 0.56464 | ||
+ | 0.8 0.71736 | ||
+ | 1.0 0.84147 | ||
+ | </pre> | ||
+ | |||
+ | ==Štatistika== | ||
+ | * Stiahnite si textový súbor [http://compbio.fmph.uniba.sk/vyuka/prog/data/icecream.txt], ktorý obsahuje frekvenciu, s akou užívatelia vyhľadávali výraz <tt>ice cream</tt> v Googli v jednotlivých týždňoch rokov 2004 až 2010. Každý riadok obsahuje údaje o jednom týždni: prvé tri slová sú dátum, štvrté relatívna frekvencia. | ||
+ | * Načítajte tento súbor do poľa záznamov so štruktúrou | ||
+ | <pre> | ||
+ | struct tyzden { | ||
+ | char[4] mesiac; | ||
+ | int den; | ||
+ | int rok; | ||
+ | double frekvencia; | ||
+ | }; | ||
+ | </pre> | ||
+ | * Vypíšte na konzolu, v ktorom týždni bola frekvencia vyhľadávania najvyššia. | ||
+ | * Pre každý rok od 2004 po 2010 spočítajte súčet frekvencií a vypíšte na konzolu v prehľadnom tvare, na dve desatinné miesta: | ||
+ | <pre> | ||
+ | 2004 63.14 | ||
+ | 2005 62.14 | ||
+ | ... | ||
+ | 2010 72.02 | ||
+ | </pre> | ||
+ | |||
+ | == Šifrovanie permutačnou šifrou== | ||
+ | |||
+ | * Napíšte funkciu, ktorá zašifruje vstupný súbor tak, že v každom bloku dĺžky ''n'' povymieňa polohu znakov podľa zadaného kľúča. Kľúč je pole ''A'' dĺžky ''n'', kde ''A[i]'' uvádza, ktoré písmeno z pôvodného bloku má ísť na ''i''-te miesto v zašifrovanom bloku. Napr. pre ''n=4'' a ''A={3,2,0,1}'' dostaneme pre blok "ABCD" výsledok "DCAB", lebo na pozíciu 0 vo výsledku sme dali písmeno na pozícii ''A[0] = 3'', t.j. D, atď. Ak v poslednom bloku nemáme dosť písmen, doplníme ich medzerami. Hlavička funkcie: <tt>void encryptPermutation(FILE *f, int n, int A[]);</tt> | ||
+ | |||
+ | * Pre dešifrovanie môžeme použiť tú istú funkciu, akurát kľúč musíme zmeniť z pôvodnej permutácie A na novú permutáciu B tak, že B[A[i]]=i pre každé i. Napr. pre príklad vyššie to bude B={2,3,1,0} | ||
+ | |||
+ | * Vyskúšajte touto šifrou zašifrovať a potom spätne odšifrovať krátky text. | ||
+ | =Prednáška 17= | ||
+ | ==Abstraktný dátový typ, ADT== | ||
+ | * Určíme, aké operácie by mala dátová štruktúra spĺňať (hlavičky funkcií), nestaráme sa o implementáciu | ||
+ | * Napríklad ADT vektor poskytuje operácie init, add, get, set, length a destroy | ||
+ | * Pre jeden ADT môže byť viacero implementácií, napr. vector by sme mohli implementovať aj pomocou spájaného zoznamu | ||
+ | * Program, ktorý vektor používa, netreba meniť kvôli zmene implementácie vektora | ||
+ | |||
+ | == Problém slovníka == | ||
+ | |||
+ | ADT '''slovník''' (dictionary), nazýva sa aj asociatívne pole (associative array), map | ||
+ | * Klasický papierový slovník umožňuje rýchlo nájsť nejaké slovo a prečítať si k nemu jeho význam alebo preklad do iného jazyka | ||
+ | * ADT slovník obsahuje záznamy, pričom každý záznam má '''kľúč''' (key), podľa ktorého vyhľadávame | ||
+ | * Podporuje operácie | ||
+ | ** insert: vloženie nového záznamu | ||
+ | ** find: hľadanie záznamu podľa kľúča | ||
+ | ** delete: mazania záznamu s daným kľúčom | ||
+ | * Okrem toho potrebujeme init, destroy na celý slovník ale tiež na jednotlivé položky | ||
+ | * V niektorých aplikáciách potrebujeme aj možnosť prejsť cez všetky záznamy (napr. vypísať ich na obrazovku alebo do súboru) | ||
+ | ** na toto si spravíme funkciu items, ktorá nakopíruje všetky záznamy do novo alokovaného poľa | ||
+ | ** to však nie je veľmi elegantné, väčšinou sa používajú skôr iterátory - uvidíme v Jave | ||
+ | |||
+ | ===Príklady použitia=== | ||
+ | * Mená a rodné čísla | ||
+ | * Telefónnny zoznam (mená a telefónne čísla) | ||
+ | * Mapovanie host name na IP adresy | ||
+ | |||
+ | ===Hlavičky funkcií=== | ||
+ | |||
+ | V danej aplikácii si musíme najskôr zadefinovať typy itemType a keyType, ktoré určujú, aké záznamy a aké kľúče budeme do slovníka ukladať. | ||
+ | <pre> | ||
+ | struct person { | ||
+ | char * name; | ||
+ | char * phone; | ||
+ | char * address; | ||
+ | }; | ||
+ | typedef person itemType; | ||
+ | typedef char * keyType; | ||
+ | </pre> | ||
+ | |||
+ | Ďalej potrebujeme funkciu, ktorá nám pre záznam dá kľúč a funkciu, ktorá zistí, či sú dva kľúče rovnaké. Niektoré implementácie slovníka budú potrebovať aj ďalšie podobné funkcie, napr. zistiť, či je jeden kľúč menší ako druhý. | ||
+ | <pre> | ||
+ | keyType key(itemType *x) { | ||
+ | return x->name; | ||
+ | } | ||
+ | bool equal(keyType x, keyType y) { | ||
+ | return strcmp(x, y)==0; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Ak chceme s itemType pracovať bez využívania toho, ako vyzerá potrebujeme si jednotlivé položky aj alokovať a uvoľňovať pomocou vlastných funkcií, ktoré vedia, ako itemType vyzerá. | ||
+ | <pre> | ||
+ | itemType * createItem(const char* name, const char* phone, const char* address){ | ||
+ | char* name_=new char[strlen(name)+1]; | ||
+ | strcpy(name_,name); | ||
+ | char* phone_=new char[strlen(phone)+1]; | ||
+ | strcpy(phone_,phone); | ||
+ | char* address_=new char[strlen(address)+1]; | ||
+ | strcpy(address_,address); | ||
+ | itemType* res=new itemType; | ||
+ | res->name=name_; | ||
+ | res->phone=phone_; | ||
+ | res->address=address_; | ||
+ | return res; | ||
+ | } | ||
+ | |||
+ | void destroyItem(itemType *x){ | ||
+ | delete[] x->name; | ||
+ | delete[] x->phone; | ||
+ | delete[] x->address; | ||
+ | delete x; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | A tu sú hlavičky základných slovníkových funkcií: | ||
+ | * <tt>void insert(dictionary &d, itemType *x); </tt> | ||
+ | ** do dátovej štruktúry d vloží záznam *x | ||
+ | ** predpokladá, že v štruktúre je dosť miesta a nie je tam záznam s rovnakým kľúčom | ||
+ | * <tt>itemType *find(dictionary &d, keyType k);</tt> | ||
+ | ** nájde záznam s kľúčom k a vráti smerník na neho ho. Ak taký kľúč v slovníku nie je, vráti NULL | ||
+ | * <tt>void remove(dictionary &d, keyType k);</tt> | ||
+ | ** vymaže záznam s kľúčom k z d | ||
+ | |||
+ | A pomocné funkcie: | ||
+ | * <tt>void init(dictionary &d, int maxN);</tt> | ||
+ | ** vytvorí slovník, do ktorého sa zmestí maxN záznamov (niektoré implementácie maxN nepotrebujú, rastú podľa potreby) | ||
+ | * <tt>void destroy(dictionary &d);</tt> | ||
+ | ** uvoľní pamäť, ktorú zaberá slovník, využíva pritom funkciu destroyItem | ||
+ | * <tt>itemType ** items(dictionary &d, int &n);</tt> | ||
+ | ** vráti novo alokované pole so smerníkmi na jednotlivé záznamy, ich počet dá do n | ||
+ | * <tt>void printItem(itemType *x);</tt> | ||
+ | ** vypíše prvok, alebo "NULL", ak dostane prázdny smerník | ||
+ | |||
+ | ===Príklad použitia=== | ||
+ | V súbore z cvičení máme frekvencie, s akou užívatelia vyhľadávali výraz <tt>ice cream</tt> v Googli v jednotlivých týždňoch rokov 2004 až 2010. | ||
+ | * Každý riadok obsahuje údaje o jednom týždni: prvé tri slová sú dátum, štvrté relatívna frekvencia. | ||
+ | <pre> | ||
+ | Jan 4 2004 0.94 | ||
+ | Jan 11 2004 0.96 | ||
+ | ... | ||
+ | </pre> | ||
+ | Chceme spočítať, aký je súčet frekvencií pre jednotlivé mesiace v roku, t.j. koľko dokopy vyhľadávali v januári za všetky roky atď. | ||
+ | |||
+ | Spravíme si záznam a definujeme potrebné typy a funkcie ako predtým | ||
+ | <pre> | ||
+ | struct month { | ||
+ | char * name; // kľúč - skratka mesiaca, napr "Jan" | ||
+ | double sum; // data - súčet frekvencií pre daný mesiac | ||
+ | }; | ||
+ | typedef month itemType; | ||
+ | typedef char * keyType; | ||
+ | |||
+ | keyType key(itemType *x) { | ||
+ | return x->name; | ||
+ | } | ||
+ | bool equal(keyType x, keyType y) { | ||
+ | return strcmp(x, y)==0; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Samotný program používajúci slovník | ||
+ | <pre> | ||
+ | int main(void) { | ||
+ | dictionary d; // vytvorime slovnik pre 12 prvkov | ||
+ | init(d, 12); | ||
+ | |||
+ | FILE *f = fopen("icecream.txt", "r"); // otvorime subor na citanie | ||
+ | assert(f != NULL); | ||
+ | |||
+ | while (!feof(f)) { | ||
+ | char month[4]; // nacitame 1 riadok suboru | ||
+ | int day, year; | ||
+ | double freq; | ||
+ | fscanf(f, "%3s %d %d %lf ", month, &day, &year, &freq); | ||
+ | |||
+ | monthSum *m = find(d, month); // najdeme mesiac v slovniku | ||
+ | |||
+ | if (m == NULL) { // mesiac este nie je v slovniku, vyrobime novy | ||
+ | itemType* it = createItem(month,freq); | ||
+ | insert(d, it); | ||
+ | } else { // mesiac uz je v slovniku, zvysime mu frekvenciu | ||
+ | m->sum += freq; | ||
+ | } | ||
+ | } | ||
+ | fclose(f); | ||
+ | |||
+ | int n; // statistiky mame spocitane, staci ich vypisat | ||
+ | monthSum **sums = items(d, n); // vypytame si vsetky zaznamy a ich pocet n | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | printf("%s %f\n", sums[i]->name, sums[i]->sum); | ||
+ | } | ||
+ | |||
+ | delete[] sums; // odalokujeme sums | ||
+ | |||
+ | destroy(d); // odalokujeme pamat, ktore alokoval slovnik, vratane jeho zaznamov | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | == Implementácia slovníka pomocou poľa == | ||
+ | |||
+ | Asi najjednoduchšia implementácia je pomocou poľa: Majme pole a dĺžky maxN, v ktorom je n záznamov. | ||
+ | <pre> | ||
+ | struct dictionary { | ||
+ | itemType **a; // pole smernikov na zaznamy | ||
+ | int maxN; // dlzka pola | ||
+ | int n; // pocet zaznamov v poli | ||
+ | }; | ||
+ | </pre> | ||
+ | |||
+ | Inicializácia | ||
+ | <pre> | ||
+ | void init(dictionary &d, int maxN) { | ||
+ | // vytvorí slovník, do ktorého sa zmestí maxN záznamov (niektoré implementácie maxN nepotrebujú, rastú podľa potreby) | ||
+ | d.maxN = maxN; | ||
+ | d.n = 0; | ||
+ | d.a = new itemType *[maxN]; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Vkladanie === | ||
+ | |||
+ | Nový prvok vložíme jednoducho na koniec: | ||
+ | |||
+ | <pre> | ||
+ | void insert(dictionary &d, itemType *x) { | ||
+ | assert(d.n < d.maxN); | ||
+ | d.a[d.n] = x; | ||
+ | d.n++; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | V prípade, že n=maxN, program skončí s chybou | ||
+ | * Mohli by sme tiež podľa potreby alokovať dvakrát väčšie pole a prvky tam presypať, ako v štruktúre vector. | ||
+ | * Ak neskôr počet prvkov klesne pod štvrtinu (n < maxN/4), môžeme pole realokovať späť na polovičnú veľkosť. | ||
+ | |||
+ | === Vymazávanie === | ||
+ | |||
+ | Vymazávanie je tiež jednoduché, daný prvok nahradíme prvkom na konci: | ||
+ | |||
+ | <pre> | ||
+ | void remove(dictionary &d, keyType k) { | ||
+ | int i = findIndex(d, k); // zisti, kde ten prvok v poli je, vrati -1 ak tam nie je | ||
+ | if (i >= 0) { | ||
+ | d.a[i] = d.a[d.n - 1]; | ||
+ | d.n--; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Vyhľadávanie === | ||
+ | |||
+ | Pri vyhľadávaní nám neostáva nič iné ako prezerať postupne všetky záznamy, kým daný kľúč nenájdeme, alebo | ||
+ | nedôjdeme na koniec poľa (v tom prípade vieme, že záznam s daným kľúčom sa v poli nenachádza): | ||
+ | |||
+ | <pre> | ||
+ | int findIndex(dictionary &d, keyType k) { | ||
+ | // pomocna funkcia pouzivana vo find a delete | ||
+ | // vrati poziciu zaznamu s klucom k v poli, alebo -1 ak tam nie je | ||
+ | for (int i = 0; i < d.n; i++) { | ||
+ | if (equal(key(d.a[i]), k)) { | ||
+ | return i; | ||
+ | } | ||
+ | } | ||
+ | return -1; | ||
+ | } | ||
+ | |||
+ | itemType *find(dictionary &d, keyType k) { | ||
+ | int i = findIndex(d, k); | ||
+ | if (i < 0) return NULL; | ||
+ | return d.a[i]; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | == Implementácia slovníka pomocou utriedeného poľa == | ||
+ | |||
+ | Ak potrebujeme rýchlo vyhľadávať, lepšia možnosť je udržiavať pole utriedené. Rýchle vyhľadávanie však bude na úkor väčšej zložitosti ostatných operácií. | ||
+ | |||
+ | === Vkladanie === | ||
+ | |||
+ | <pre> | ||
+ | void insert(dictionary &d, itemType *x) { | ||
+ | assert(d.n < d.maxN); | ||
+ | int i=d.n-1; | ||
+ | keyType k=key(x); | ||
+ | |||
+ | while ((i>=0)&&(greater(key(d.a[i]),k))) {i--; d.a[i+1]=d.a[i];} | ||
+ | d.a[i+1]=x; | ||
+ | d.n++; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Pri vkladaní musíme novému záznamu „spraviť miesto" – nájdeme miesto, kam nový záznam | ||
+ | vložiť (while-cyklus) pričom prvky za daným miestom posúvame všetky záznamy o 1 doprava. | ||
+ | |||
+ | === Vymazávanie === | ||
+ | |||
+ | Vymazávanie existujúceho prvku, ktorý je na i-tom mieste nemôžeme tak jednoducho ako pri neutriedenom poli. Keďže musíme zachovať poradie (a zároveň nevytvárať diery), posunieme všetky prvky počnúc (i+1)-vým doľava. | ||
+ | |||
+ | <pre> | ||
+ | void remove(dictionary &d, const keyType k) { | ||
+ | // vymaže záznam s kľúčom k z d | ||
+ | int i = findIndex(d, k); | ||
+ | if (i >= 0) { | ||
+ | while (i<d.n-1) {d.a[i] = d.a[i+1]; i++;} | ||
+ | d.n--; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Vyhľadávanie === | ||
+ | |||
+ | Funkciu findIndex, môžeme urobiť podobne ako pri neutriedenom poli prechodom poľa. Vieme však, že od istého momentu nemá význam pokračovať ďalej. | ||
+ | |||
+ | <pre> | ||
+ | int findIndex(dictionary &d, const keyType k) { | ||
+ | // pomocna funkcia pouzivana vo find a delete | ||
+ | // vrati poziciu zaznamu s klucom k v poli, alebo -1 ak tam nie je | ||
+ | int i=0; | ||
+ | while ((i<d.n)&&(greater(k,key(d.a[i])))) i++; | ||
+ | if ((i<d.n)&&(equal(k,key(d.a[i])))) return i; | ||
+ | else return -1; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Druhá možnosť je použiť binárne vyhľadávanie. Zjavne pri utriedenom poli máme komplikovanejšie (a časovo zložitejšie) vkladanie a vymazávanie. Vieme však rýchlejšie výhľadávať. | ||
+ | |||
+ | Pripomenieme myšlienku: začíname hľadať v intervale <l,r> a pozrieme sa na stredný prvok A[m], kde m = (l+ r )/2. | ||
+ | * ak A[m] = k , našli sme hľadaný záznam a sme hotoví. | ||
+ | * ak k < A[m], potom zjavne hľadaný kľúč patrí do prvej polovice intervalu <l,r>, t.j. do intervalu <l,m-1>. | ||
+ | * ak A[m] < k , zjavne patrí do druhej polovice intervalu <l,r>, t.j. do intervalu <m+1,r>. | ||
+ | Takto sa nám každým krokom zmenší hľadaný interval na polovicu | ||
+ | |||
+ | <pre> | ||
+ | int findIndex(dictionary &d, const keyType k) { | ||
+ | // pomocna funkcia pouzivana vo find a delete | ||
+ | // vrati poziciu zaznamu s klucom k v poli, alebo -1 ak tam nie je | ||
+ | int l=0; int r=d.n-1; | ||
+ | while (l<=r){ | ||
+ | int m=(l+r)/2; | ||
+ | if (equal(key(d.a[m]),k)) return m; | ||
+ | else if (greater(key(d.a[m]),k)) r=m-1; | ||
+ | else l=m+1; | ||
+ | } | ||
+ | return -1; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Slovník s použitím utriedeného poľa === | ||
+ | *[[#Zdrojový kód slovníka s použitím utriedeného poľa]] | ||
+ | |||
+ | ==Implementácia slovníka pomocou spájaných zoznamov== | ||
+ | |||
+ | Slovník môžeme implementovať aj pomocou spájaných zoznamov. Čo si však musíme uvedomiť je, že ak máme prvok typu itemType, tak v spájanom zozname musíme pracovať s týmto prvkom a zároveň so smerníkom na ďalší prvok. A teda prvky v spájanom zozname sú typu | ||
+ | |||
+ | <pre> | ||
+ | struct item{ | ||
+ | itemType* it; | ||
+ | item* next; | ||
+ | }; | ||
+ | </pre> | ||
+ | |||
+ | Zvyšok je rovnaký ako pri vkladaní, vyhľadávaní a mazaní zo spáajaného zoznamu s tým rozdielom, že by sme mali používať funkcie key, equal a podobne, ktoré máme k dispozícii ku konkrétnemu typu itemType. | ||
+ | |||
+ | Podrobnejšie prácu so spájanými zoznamami uvidíme neskôr na tejto prednáške. | ||
+ | |||
+ | == Hashovacie tabuľky == | ||
+ | |||
+ | Hashovanie je metóda vyhľadávania, ktorá je založená na trochu inom princípe ako predchádzajúce možnosti. Tabuľka, do ktorej budeme ukladať záznamy, je výrazne väčšia, ako očakávaný počet záznamov. Do tabuľky budeme pristupovať pomocou funkcie, ktorá vypočíta, kam uložíme prvok, resp. kde ho máme hľadať. | ||
+ | |||
+ | <pre> | ||
+ | struct itemType{ | ||
+ | keyType key; | ||
+ | valueType value; | ||
+ | }; | ||
+ | |||
+ | struct hashMap{ | ||
+ | itemType** data; | ||
+ | int n; | ||
+ | }; | ||
+ | </pre> | ||
+ | |||
+ | Konkrétne, nech K je množina všetkých kľúčov a hashovacia tabuľka je veľkosti n (teda používa indexy 0..n-1). | ||
+ | * Hashovacia funkcia bude transformovať kľúče na indexy poľa, teda pôjde o funkciu h:K -> {0 , 1 , . . . , n −1}. | ||
+ | * Snažíme sa, aby funkcia bola jadnoduchá ale pritom neprideľovala často rovnaké indexy (bude kľúče do tabuľky distribuovať rovnomerne). | ||
+ | * V triviálnom prípade, ak K = {0, 1, . . . , n −1}, stačí za h zvoliť identitu. Keďže v praxi však býva množina K príliš veľká, takúto funkciu nemôžeme použiť. | ||
+ | * Často sa používa funkcia h(k) = k mod n (je dobré, ak v tomto prípade n je prvočíslo nie blízko mocniny 2). | ||
+ | |||
+ | <pre> | ||
+ | int hash(keyType k, int n){ | ||
+ | return k%n; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Jednoduché riešenie === | ||
+ | |||
+ | Ak máme teda vhodnú funkciu hash a hashovaciu tabuľku, môžeme navrhnúť prvé funkcie na prácu s ňou. | ||
+ | |||
+ | * Vyhľadávanie je jednoduché - v prípade, že tam prvok s kľúčom k je, musí byť na mieste hash(k). Skontrolujeme teda, či na tomto mieste je prvok s kľúčom k - ak áno, je to hľadaný prvok a ak nie, tak hľadaný prvok neexistuje. | ||
+ | <pre> | ||
+ | itemType* find(hashMap& h,keyType k){ | ||
+ | int hashed=hash(k,h.n); | ||
+ | itemType* lookup=h.data[hashed]; | ||
+ | if (equal(key(lookup),k)) return lookup; | ||
+ | else return NULL; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Vymazanie takéhoto prvku je tiež jednoduché. Ak sme prvok našli, tak ho vymažeme. | ||
+ | <pre> | ||
+ | void remove(hashMap& h, keyType key){ | ||
+ | int hashed=hash(key,h.n); | ||
+ | itemType* lookup=h.data[hashed]; | ||
+ | if (equal(key(lookup),k)) delete lookup; | ||
+ | h.data[hashed]=NULL; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Nakoniec si ukážeme vkladanie. Myšlienka je podobne jednoduchá - vypočítame si, kam prvok chceme vložiť a ak je tam miesto, tak ho tam vložíme. | ||
+ | <pre> | ||
+ | void insert(hashMap& h, keyType key, valueType value){ | ||
+ | int hashed=hash(key,h.n); | ||
+ | itemType* it=createItem(key,value); | ||
+ | h.data[hashed]=it; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Ostáva nám otázka - Čo so situáciou, keď chceme vložiť na miesto, kde už niečo uložené máme? | ||
+ | |||
+ | === Kolízia === | ||
+ | |||
+ | Pri vkladaní prvku sme narazili na problém, že na už obsadané miesto sme chceli vložiť iný prvok. Môže sa stať, že dva prvky x a y sa zahashujú na rovnakú pozíciu h(x) = h(y). Takémuto javu hovoríme kolízia. Existuje viacero spôsobov, ako ju riešiť. | ||
+ | |||
+ | * Budeme aj tak vkladať na toto miesto, len tam potenciálne nebude iba jeden prvok, ale viac v spájanom zozname | ||
+ | * Budeme nejako hľadať prvú voľnú pozíciu v tabuľke, buď postupným prezeraním nasledovných prvkov, alebo s pozeraním nie tesne nasledovných prvkov ale s nejakým krokom - o tomto sa dozviete o rok na ADŠ | ||
+ | |||
+ | === Riešenie kolízii pomocou spájaných zoznamov === | ||
+ | |||
+ | Namiesto smerníkov priamo na prvok typu itemType budeme mať v každom políčku hashovacej tabuľky spájaný zoznam s prvkami, ktorých kľúče sa priradili na toto políčko. Preto pochopiteľne potrebujeme k itemType pridať aj smerník na nasledujúci prvok. Takto vzniknutú dvojicu budeme označovať item a v tabuľke budeme ukladať smerník na item. | ||
+ | |||
+ | <pre> | ||
+ | struct item{ | ||
+ | itemType* it; | ||
+ | item* next; | ||
+ | }; | ||
+ | |||
+ | struct hashMap{ | ||
+ | item** data; | ||
+ | int n; | ||
+ | }; | ||
+ | </pre> | ||
+ | |||
+ | Potom pre ľubovoľný smerník na prvok typu item (teda pre premennú p typu item*) sa k samotným dátam dostaneme pomocou p->it, ktorý je typu itemType*. | ||
+ | Kľúč potom získame ako key(p->it) a s takto získaným kľúčom typu keyType vieme robiť porovnávanie pomocou equal(). | ||
+ | |||
+ | * Vyhľadávanie pracuje na spájanom zozname, ktorý sa nachádza na správnom mieste hashovacej tabuľky. Správny index dostaneme pomocou hash(k,h.n), kde | ||
+ | k je hľadaný kľúč a h.n je veľkosť tabuľky h. | ||
+ | |||
+ | <pre> | ||
+ | itemType* find(hashMap& h,keyType k){ | ||
+ | int hashed=hash(k,h.n); | ||
+ | item* lookup=h.data[hashed]; | ||
+ | while(lookup){ | ||
+ | if (equal(key(lookup->it),k)) return lookup->it; | ||
+ | lookup=lookup->next; | ||
+ | } | ||
+ | return NULL; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Vkladanie môžeme umožniť rôzne alternatívy podľa toho, aké správanie očakávame. V predchádzajúcom prípade nám nevadilo umiestniť do slovníka aj viacero prvkov s rovnakým kľúčom (nekontrolovali sme existenciu prvku s rovnakým kľúčom). Tým pádom nám stačí nový prvok (ktorý si vytvoríme) vložiť na začiatok spájaného zoznamu na vhodnom mieste tabuľky. | ||
+ | |||
+ | <pre> | ||
+ | void insert(hashMap& h, keyType k, valueType value){ | ||
+ | int hashed=hash(k,h.n); | ||
+ | item* it=new item; | ||
+ | it->it=createItem(k,value); | ||
+ | it->next=h.data[hashed]; | ||
+ | h.data[hashed]=it; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * V prípade, že by sme chceli iným spôsobom ošetriť existenciu prvku s rovnakým kľúčom (či už tomu zabrániť, alebo pri vložení takého prvku urobiť update), musíme patričný spájaný zoznam prejsť aby sme skontrolovali potenciálnu duplicitu kľúčov. | ||
+ | |||
+ | <pre> | ||
+ | void insert(hashMap& h, keyType k, valueType value){ | ||
+ | int hashed=hash(k,h.n); | ||
+ | item* lookup=h.data[hashed]; | ||
+ | while(lookup){ | ||
+ | if (equal(key(lookup->it),k)){ | ||
+ | lookup->it->value=value; // v prípade duplicity robíme update hodnoty | ||
+ | return; | ||
+ | } | ||
+ | lookup=lookup->next; | ||
+ | } | ||
+ | item* it=new item; | ||
+ | it->it=createItem(k,value); | ||
+ | it->next=h.data[hashed]; | ||
+ | h.data[hashed]=it; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Vymazávanie prebieha podobne ako všetky ostatné operácie na spájanom zozname, ktorý je na mieste tabuľky, kam nás nasmeroval zahashovaný kľúč. | ||
+ | ** Vymazávanie je možné urobiť buď klasicky ako v predchádzajúcej prednáške alebo elegantnejšie pomocou dvojitých smerníkov (smerník na smerník môžeme využiť vďaka tomu, že h.data[hashed] aj item->next sú rovnakého typu - item*). | ||
+ | |||
+ | <pre> | ||
+ | void remove(hashMap& h, keyType k){ | ||
+ | int hashed=hash(k,h.n); | ||
+ | item** lookup=&h.data[hashed]; | ||
+ | while(*lookup){ | ||
+ | item* it=*lookup; | ||
+ | if (equal(key(it->it),k)){ | ||
+ | *lookup=it->next; | ||
+ | delete it; | ||
+ | return; | ||
+ | } | ||
+ | lookup=&it->next; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * [[#Zdrojový kód programu s Hashovacou tabuľkou]] | ||
+ | |||
+ | ==Zdrojový kód programu s netriedeným poľom== | ||
+ | <pre> | ||
+ | #include <cstring> | ||
+ | #include <cassert> | ||
+ | #include <cstdio> | ||
+ | |||
+ | struct monthSum { | ||
+ | char * name; // kľúč - skratka mesiaca, napr "Jan" | ||
+ | double sum; // data - sucet frekvencií pre daný mesiac | ||
+ | }; | ||
+ | typedef monthSum itemType; | ||
+ | typedef char * keyType; | ||
+ | |||
+ | keyType key(itemType *x) { | ||
+ | return x->name; | ||
+ | } | ||
+ | |||
+ | bool equal(keyType x, keyType y) { | ||
+ | return strcmp(x, y) == 0; | ||
+ | } | ||
+ | |||
+ | void printItem(itemType *x){ | ||
+ | if (x==NULL) printf("NULL\n"); | ||
+ | else printf("%s: %f\n",x->name,x->sum); | ||
+ | } | ||
+ | |||
+ | itemType * createItem(const char* name, double sum){ | ||
+ | char* name_=new char[strlen(name)+1]; | ||
+ | strcpy(name_,name); | ||
+ | itemType* res=new itemType; | ||
+ | res->name=name_; | ||
+ | res->sum=sum; | ||
+ | return res; | ||
+ | } | ||
+ | |||
+ | void destroyItem(itemType *x){ | ||
+ | delete[] x->name; | ||
+ | delete x; | ||
+ | } | ||
+ | |||
+ | struct dictionary { | ||
+ | itemType **a; // pole smernikov na zaznamy | ||
+ | int maxN; // dlzka pola | ||
+ | int n; // pocet zaznamov v poli | ||
+ | }; | ||
+ | |||
+ | void insert(dictionary &d, itemType *x) { | ||
+ | // do dátovej štruktúry d vloží záznam *x | ||
+ | // predpokladá, že v štruktúre je dosť miesta a nie je tam záznam s rovnakým kľúčom | ||
+ | assert(d.n < d.maxN); | ||
+ | d.a[d.n] = x; | ||
+ | d.n++; | ||
+ | } | ||
+ | |||
+ | int findIndex(dictionary &d, keyType k) { | ||
+ | for (int i = 0; i < d.n; i++) { | ||
+ | if (equal(key(d.a[i]), k)) { | ||
+ | return i; | ||
+ | } | ||
+ | } | ||
+ | return -1; | ||
+ | } | ||
+ | |||
+ | itemType *find(dictionary &d, keyType k) { | ||
+ | // nájde záznam s kľúčom k a vráti smerník na neho ho. | ||
+ | // Ak taký kľúč v slovníku nie je, vráti NULL | ||
+ | int i = findIndex(d, k); | ||
+ | if (i < 0) return NULL; | ||
+ | return d.a[i]; | ||
+ | } | ||
+ | |||
+ | void remove(dictionary &d, keyType k) { | ||
+ | // vymaže záznam s kľúčom k z d | ||
+ | int i = findIndex(d, k); | ||
+ | if (i >= 0) { | ||
+ | d.a[i] = d.a[d.n - 1]; | ||
+ | d.n--; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void init(dictionary &d, int maxN) { | ||
+ | // vytvorí slovník, do ktorého sa zmestí maxN záznamov (niektoré implementácie maxN nepotrebujú, rastú podľa potreby) | ||
+ | d.maxN = maxN; | ||
+ | d.n = 0; | ||
+ | d.a = new itemType *[maxN]; | ||
+ | } | ||
+ | |||
+ | void destroy(dictionary &d) { | ||
+ | // uvoľní jednotlivé záznamy | ||
+ | for (int i=0; i<d.n; i++) destroyItem(d.a[i]); | ||
+ | // uvoľní pamäť, ktorú zaberá slovník | ||
+ | delete[] d.a; | ||
+ | } | ||
+ | |||
+ | itemType ** items(dictionary &d, int &n) { | ||
+ | // vráti novo alokované pole so smerníkmi na jednotlivé záznamy, ich počet dá do n | ||
+ | itemType **a = new itemType*[d.n]; | ||
+ | n = d.n; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | a[i] = d.a[i]; | ||
+ | } | ||
+ | return a; | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | dictionary d; // vytvorime slovnik pre 12 prvkov | ||
+ | init(d, 12); | ||
+ | |||
+ | FILE *f = fopen("icecream.txt", "r"); // otvorime subor na citanie | ||
+ | assert(f != NULL); | ||
+ | |||
+ | while (!feof(f)) { | ||
+ | char month[4]; // nacitame 1 riadok suboru | ||
+ | int day, year; | ||
+ | double freq; | ||
+ | fscanf(f, "%3s %d %d %lf ", month, &day, &year, &freq); | ||
+ | |||
+ | monthSum *m = find(d, month); // najdeme mesiac v slovniku | ||
+ | |||
+ | if (m == NULL) { // mesiac este nie je v slovniku, vyrobime novy | ||
+ | itemType it = createItem(month,freq); | ||
+ | insert(d, it); | ||
+ | } else { // mesiac uz je v slovniku, zvysime mu frekvenciu | ||
+ | m->sum += freq; | ||
+ | } | ||
+ | } | ||
+ | fclose(f); | ||
+ | |||
+ | int n; // statistiky mame spocitane, staci ich vypisat | ||
+ | monthSum **sums = items(d, n); // vypytame si vsetky zaznamy a ich pocet n | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | printf("%s %f\n", sums[i]->name, sums[i]->sum); | ||
+ | } | ||
+ | |||
+ | delete[] sums; // odalokujeme sums | ||
+ | |||
+ | destroy(d); // odalokujeme pamat, ktore alokoval slovnik | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Zdrojový kód slovníka s použitím utriedeného poľa == | ||
+ | <pre> | ||
+ | #include <cstdlib> | ||
+ | #include <cstdio> | ||
+ | #include <cassert> | ||
+ | #include <cstring> | ||
+ | |||
+ | using namespace std; | ||
+ | |||
+ | struct monthSum { | ||
+ | char * name; // kľúč - skratka mesiaca, napr "Jan" | ||
+ | double sum; // data - sucet frekvencií pre daný mesiac | ||
+ | }; | ||
+ | typedef monthSum itemType; | ||
+ | typedef char * keyType; | ||
+ | |||
+ | keyType key(itemType *x) { | ||
+ | return x->name; | ||
+ | } | ||
+ | |||
+ | bool equal(keyType x, keyType y) { | ||
+ | return strcmp(x, y) == 0; | ||
+ | } | ||
+ | |||
+ | bool greater(keyType x, keyType y) { | ||
+ | // x>y | ||
+ | return strcmp(x, y) > 0; | ||
+ | } | ||
+ | |||
+ | void printItem(itemType *x){ | ||
+ | if (x==NULL) printf("NULL\n"); | ||
+ | else printf("%s: %f\n",x->name,x->sum); | ||
+ | } | ||
+ | |||
+ | itemType * createItem(const char* name, double sum){ | ||
+ | char* name_=new char[strlen(name)+1]; | ||
+ | strcpy(name_,name); | ||
+ | itemType* res=new itemType; | ||
+ | res->name=name_; | ||
+ | res->sum=sum; | ||
+ | return res; | ||
+ | } | ||
+ | |||
+ | void destroyItem(itemType *x){ | ||
+ | delete[] x->name; | ||
+ | delete x; | ||
+ | } | ||
+ | |||
+ | struct dictionary { | ||
+ | itemType **a; // pole smernikov na zaznamy | ||
+ | int maxN; // dlzka pola | ||
+ | int n; // pocet zaznamov v poli | ||
+ | }; | ||
+ | |||
+ | void init(dictionary &d, int maxN) { | ||
+ | // vytvorí slovník, do ktorého sa zmestí maxN záznamov (niektoré implementácie maxN nepotrebujú, rastú podľa potreby) | ||
+ | d.maxN = maxN; | ||
+ | d.n = 0; | ||
+ | d.a = new itemType *[maxN]; | ||
+ | } | ||
+ | |||
+ | int findIndex1(dictionary &d, const keyType k) { | ||
+ | // pomocna funkcia pouzivana vo find a delete | ||
+ | // vrati poziciu zaznamu s klucom k v poli, alebo -1 ak tam nie je | ||
+ | int i=0; | ||
+ | while ((i<d.n)&&(greater(k,key(d.a[i])))) i++; | ||
+ | if ((i<d.n)&&(equal(k,key(d.a[i])))) return i; | ||
+ | else return -1; | ||
+ | } | ||
+ | |||
+ | int findIndex2(dictionary &d, const keyType k) { | ||
+ | // pomocna funkcia pouzivana vo find a delete | ||
+ | // vrati poziciu zaznamu s klucom k v poli, alebo -1 ak tam nie je | ||
+ | int l=0; int r=d.n-1; | ||
+ | while (l<=r){ | ||
+ | int m=(l+r)/2; | ||
+ | if (equal(key(d.a[m]),k)) return m; | ||
+ | else if (greater(key(d.a[m]),k)) r=m-1; | ||
+ | else l=m+1; | ||
+ | } | ||
+ | return -1; | ||
+ | } | ||
+ | |||
+ | itemType *find(dictionary &d, const keyType k) { | ||
+ | // nájde záznam s kľúčom k a vráti smerník na neho ho. | ||
+ | // Ak taký kľúč v slovníku nie je, vráti NULL | ||
+ | int i = findIndex1(d, k); | ||
+ | if (i < 0) return NULL; | ||
+ | return d.a[i]; | ||
+ | } | ||
+ | |||
+ | void remove(dictionary &d, const keyType k) { | ||
+ | // vymaže záznam s kľúčom k z d | ||
+ | int i = findIndex1(d, k); | ||
+ | if (i >= 0) { | ||
+ | while (i<d.n-1) {d.a[i] = d.a[i+1]; i++;} | ||
+ | d.n--; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void insert(dictionary &d, itemType *x) { | ||
+ | assert(d.n < d.maxN); | ||
+ | int i=d.n-1; | ||
+ | keyType k=key(x); | ||
+ | |||
+ | while ((i>=0)&&(greater(key(d.a[i]),k))) {i--; d.a[i+1]=d.a[i];} | ||
+ | d.a[i+1]=x; | ||
+ | d.n++; | ||
+ | } | ||
+ | |||
+ | void destroy(dictionary &d) { | ||
+ | for (int i=0; i<d.n; i++) destroyItem(d.a[i]); | ||
+ | // uvoľní pamäť, ktorú zaberá slovník (neuvoľňuje pamäť jednotlivých záznamov) | ||
+ | delete[] d.a; | ||
+ | } | ||
+ | |||
+ | void printDictionary(dictionary &d){ | ||
+ | printf("Dictionary (n=%d)\n",d.n); | ||
+ | for (int i=0; i<d.n; i++){ | ||
+ | printItem(d.a[i]); | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int main() { | ||
+ | dictionary d; | ||
+ | |||
+ | init(d,12); | ||
+ | insert(d,createItem("Jan",0.9)); | ||
+ | insert(d,createItem("Mar",0.8)); | ||
+ | printDictionary(d); | ||
+ | printItem(find(d,"Jan")); | ||
+ | printItem(find(d,"Feb")); | ||
+ | remove(d,"Mar"); | ||
+ | printDictionary(d); | ||
+ | printItem(find(d,"Mar")); | ||
+ | destroy(d); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Zdrojový kód programu s Hashovacou tabuľkou== | ||
+ | <pre> | ||
+ | #include <cstring> | ||
+ | #include <cstdio> | ||
+ | #include <cassert> | ||
+ | |||
+ | using namespace std; | ||
+ | |||
+ | typedef int keyType; | ||
+ | typedef double valueType; | ||
+ | |||
+ | struct itemType{ | ||
+ | keyType key; | ||
+ | valueType value; | ||
+ | }; | ||
+ | |||
+ | struct item{ | ||
+ | itemType* it; | ||
+ | item* next; | ||
+ | }; | ||
+ | |||
+ | keyType key(itemType *x) { | ||
+ | return x->key; | ||
+ | } | ||
+ | |||
+ | valueType value(itemType *x) { | ||
+ | return x->value; | ||
+ | } | ||
+ | |||
+ | bool equal(keyType x, keyType y) { | ||
+ | return (x == y); | ||
+ | } | ||
+ | |||
+ | itemType * createItem(keyType key, valueType value){ | ||
+ | itemType* res=new itemType; | ||
+ | res->key=key; | ||
+ | res->value=value; | ||
+ | return res; | ||
+ | } | ||
+ | |||
+ | struct hashMap{ | ||
+ | item** data; | ||
+ | int n; | ||
+ | }; | ||
+ | |||
+ | int hash(keyType k, int n){ | ||
+ | return k%n; | ||
+ | } | ||
+ | |||
+ | void printValue(valueType* x){ | ||
+ | if (x==0) printf("NULL\n"); | ||
+ | else printf("%f\n",*x); | ||
+ | } | ||
+ | |||
+ | void printItem(itemType* x){ | ||
+ | if (x==0) printf("NULL\n"); | ||
+ | else printf("(%d, %f)\n",x->key,x->value); | ||
+ | } | ||
+ | |||
+ | void createHashMap(hashMap& h, int n){ | ||
+ | h.n=n; | ||
+ | h.data=new item*[n]; | ||
+ | for(int i=0;i<n;++i) h.data[i]=NULL; | ||
+ | } | ||
+ | |||
+ | void printHashMap(hashMap& h){ | ||
+ | for(int i=0;i<h.n;++i){ | ||
+ | printf("%d: ",i); | ||
+ | item* it=h.data[i]; | ||
+ | while(it){ | ||
+ | printf("(%d,%f) ",key(it->it),value(it->it)); | ||
+ | it=it->next; | ||
+ | } | ||
+ | printf("\n"); | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void destroyHashMap(hashMap& h){ | ||
+ | for(int i=0;i<h.n;++i){ | ||
+ | item* it=h.data[i]; | ||
+ | while(it){ | ||
+ | item* next=it->next; | ||
+ | delete it; | ||
+ | it=next; | ||
+ | } | ||
+ | } | ||
+ | delete[] h.data; | ||
+ | } | ||
+ | |||
+ | void insert(hashMap& h, keyType k, valueType value){ | ||
+ | int hashed=hash(k,h.n); | ||
+ | item* lookup=h.data[hashed]; | ||
+ | while(lookup){ | ||
+ | if (equal(key(lookup->it),k)){ | ||
+ | lookup->it->value=value; | ||
+ | return; | ||
+ | } | ||
+ | lookup=lookup->next; | ||
+ | } | ||
+ | item* it=new item; | ||
+ | it->it=createItem(k,value); | ||
+ | it->next=h.data[hashed]; | ||
+ | h.data[hashed]=it; | ||
+ | } | ||
+ | |||
+ | itemType* find(hashMap& h,keyType k){ | ||
+ | int hashed=hash(k,h.n); | ||
+ | item* lookup=h.data[hashed]; | ||
+ | while(lookup){ | ||
+ | if (equal(key(lookup->it),k)) return lookup->it; | ||
+ | lookup=lookup->next; | ||
+ | } | ||
+ | return NULL; | ||
+ | } | ||
+ | |||
+ | void remove(hashMap& h, keyType k){ | ||
+ | int hashed=hash(k,h.n); | ||
+ | item** lookup=&h.data[hashed]; | ||
+ | while(*lookup){ | ||
+ | item* it=*lookup; | ||
+ | if (equal(key(it->it),k)){ | ||
+ | *lookup=it->next; | ||
+ | delete it; | ||
+ | return; | ||
+ | } | ||
+ | lookup=&it->next; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int main(){ | ||
+ | hashMap h; | ||
+ | createHashMap(h,10); | ||
+ | insert(h,2,2.0); | ||
+ | insert(h,2,1.0); | ||
+ | printHashMap(h); | ||
+ | printItem(find(h,1)); | ||
+ | printItem(find(h,2)); | ||
+ | insert(h,12,12.0); | ||
+ | insert(h,1,1.0); | ||
+ | printHashMap(h); | ||
+ | printItem(find(h,1)); | ||
+ | printItem(find(h,2)); | ||
+ | |||
+ | remove(h,12); | ||
+ | printHashMap(h); | ||
+ | remove(h,12); | ||
+ | printHashMap(h); | ||
+ | remove(h,2); | ||
+ | printHashMap(h); | ||
+ | |||
+ | destroyHashMap(h); | ||
+ | } | ||
+ | </pre> | ||
+ | =Prednáška 18= | ||
+ | ==Organizačné poznámky== | ||
+ | * DÚ7 a PDÚ3 odovzdávať do budúceho pondelka, DÚ8 zverejnená koncom týždňa | ||
+ | * Pondelok 17.12. o 10:00 bude záverečný test (nejaké konflikty?) | ||
+ | |||
+ | ==Opakovanie: Abstraktný dátový typ (ADT)== | ||
+ | |||
+ | * Určíme, aké operácie by mala dátová štruktúra spĺňať (hlavičky funkcií) | ||
+ | * Oddelíme tak samotnú implementáciu dátovej štruktúry a program, ktorý ju používa | ||
+ | * Implementáciu štruktúry môžeme zmeniť bez zmeny zvyšku programu | ||
+ | |||
+ | Doteraz sme videli: | ||
+ | * ADT '''vektor''' poskytuje operácie init, add, get, set, length a destroy | ||
+ | ** Implementácia poľom, ktorá podľa potreby realokujeme na väčšie | ||
+ | * ADT '''slovník''' poskytuje operácie insert, remove, find, init, destroy | ||
+ | ** Implementácie napr. utriedeným poľom, neutriedeným poľom, hashovacou tabuľkou, ale aj spájaným zoznamom a ďalšími zložitejšími štruktúrami | ||
+ | |||
+ | Dnes dve nové ADT: zásobník a rad | ||
+ | * Obidve implementujeme pomocou polí aj spájaných zoznamov | ||
+ | |||
+ | ==Zásobník (stack) a rad (queue)== | ||
+ | * Jednoduché dátové štruktúry, ktoré udržujú zoznam nejakých prvkov | ||
+ | * Tieto prvky sú dosť často úlohy, resp. dáta čakajúce na spracovanie | ||
+ | * Vieme do nich vkladať a vyberať | ||
+ | * Líšia sa tým, v akom poradí vyberáme | ||
+ | |||
+ | '''Rad, fronta (queue)''' | ||
+ | * Vyberáme prvok, ktorý je v rade najdlhšie (first in, first out, FIFO) | ||
+ | * Podobá sa na státie v rade pri pokladni: ten, kto tam stojí najdlhšie, bude prvý obslúžený | ||
+ | * Základné operácie | ||
+ | <pre> | ||
+ | /* inicializuje prázdny rad */ | ||
+ | void init(queue &q); | ||
+ | |||
+ | /* zisti, ci je rad prazdny */ | ||
+ | bool isEmpty(queue &q); | ||
+ | |||
+ | /* prida prvok item na koniec radu */ | ||
+ | void enqueue(queue &q, dataType item); | ||
+ | |||
+ | /* odoberie prvok zo začiatku radu a vráti jeho hodnotu */ | ||
+ | dataType dequeue(queue &q); | ||
+ | |||
+ | /* vrati prvok zo zaciatku radu, ale necha ho v rade */ | ||
+ | dataType peek(queue &q); | ||
+ | </pre> | ||
+ | |||
+ | |||
+ | '''Zásobník (stack)''' | ||
+ | * Vyberáme prvok, ktorý je v rade najkratšie (last in, first out, LIFO) | ||
+ | * Podobá sa na umývača tanierov v reštaurácii, vždy vezme horný tanier z kopy | ||
+ | <pre> | ||
+ | /* inicializuje prázdny zásobník */ | ||
+ | void init(stack &s); | ||
+ | |||
+ | /* zisti, ci je zasobnik prazdny */ | ||
+ | bool isEmpty(stack &s); | ||
+ | |||
+ | /* prida prvok item na vrch zasobnika */ | ||
+ | void push(stack &s, dataType item); | ||
+ | |||
+ | /* odoberie prvok z vrchu zásobníka a vráti jeho hodnotu */ | ||
+ | dataType pop(stack &q); | ||
+ | </pre> | ||
+ | Ešte potenciálne potrebujeme uvoľniť pamäť nejakou ďalšou funkciou, napr. destroy. | ||
+ | |||
+ | |||
+ | '''Príklad:''' | ||
+ | <pre> | ||
+ | typedef int dataType; | ||
+ | /* sem pride definicia typov stack a queue a vsetky potrebne funkcie */ | ||
+ | |||
+ | int main() { | ||
+ | cout << "Stack:" << endl; | ||
+ | stack s; | ||
+ | init(s); | ||
+ | push(s, 1); | ||
+ | push(s, 2); | ||
+ | push(s, 3); | ||
+ | cout << pop(s) << endl; | ||
+ | cout << pop(s) << endl; | ||
+ | cout << pop(s) << endl; | ||
+ | |||
+ | cout << "Queue:" << endl; | ||
+ | queue q; | ||
+ | init(q); | ||
+ | enqueue(q, 1); | ||
+ | enqueue(q, 2); | ||
+ | enqueue(q, 3); | ||
+ | cout << dequeue(q) << endl; | ||
+ | cout << dequeue(q) << endl; | ||
+ | cout << dequeue(q) << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Zásobník prevracia poradie prvkov, rad zachováva. | ||
+ | <pre> | ||
+ | Stack: | ||
+ | 3 | ||
+ | 2 | ||
+ | 1 | ||
+ | Queue: | ||
+ | 1 | ||
+ | 2 | ||
+ | 3 | ||
+ | </pre> | ||
+ | |||
+ | ==Zásobník implementovaný pomocou poľa== | ||
+ | Dve prirodzené možnosti: | ||
+ | * vrch zásobníka v prvku 0 | ||
+ | * spodok zásobníka v prvku 0 | ||
+ | |||
+ | Prvá možnosť by bola pomalá, na operácie push aj pop by sme museli posúvať všetky prvky v zásobníku. Použijeme teda druhú možnosť, v prvku 0 bude spodok zásobníka, v premennej top si pamätáme pozíciu vrchného prvku. | ||
+ | |||
+ | <pre> | ||
+ | struct stack { | ||
+ | int top; /* pozicia vrchného prvku zásobníka */ | ||
+ | dataType *items; /* pole prvkov */ | ||
+ | }; | ||
+ | |||
+ | /* inicializuje prázdny zásobník */ | ||
+ | void init(stack &s) { | ||
+ | s.top = -1; | ||
+ | s.items = new dataType[maxN]; | ||
+ | } | ||
+ | |||
+ | /* zisti, ci je zasobnik prazdny */ | ||
+ | bool isEmpty(stack &s) { | ||
+ | return s.top == -1; | ||
+ | } | ||
+ | |||
+ | /* prida prvok s hodnotou item na vrch zasobnika */ | ||
+ | void push(stack &s, dataType item) { | ||
+ | s.top++; | ||
+ | assert(s.top < maxN); | ||
+ | s.items[s.top] = item; | ||
+ | } | ||
+ | |||
+ | /* odoberie prvok z vrchu zásobníka a vráti jeho hodnotu */ | ||
+ | dataType pop(stack &s) { | ||
+ | assert(s.top >= 0); | ||
+ | s.top--; | ||
+ | return s.items[s.top + 1]; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Rad implementovaný pomocou poľa== | ||
+ | * Rad sa nedá implementovať tak jednoducho ako zásobník, lebo na jednej strane potrebujeme vkladať a na druhej vyberať. | ||
+ | * Takže ak by sme chceli mať napr. prvý prvok v rade vždy na pozícii 0, museli by sme pri vyberaní posúvať všetky prvky, čo je pomalé. | ||
+ | * Namiesto toho si budeme pamätať pozíciu prvého prvku (premenná first) a keď vyberieme prvok, len zvýšime first | ||
+ | * Tým sa zaplnený úsek postupne posúva doprava | ||
+ | * Keď dôjdeme na koniec poľa, zatočíme sa, ako keby za prvkom maxN-1 nasledoval prvok 0 | ||
+ | |||
+ | <pre> | ||
+ | struct queue { | ||
+ | int first; /* prvý prvok v rade */ | ||
+ | int count; /* počet prvkov v rade */ | ||
+ | dataType *items; /* pole prvkov */ | ||
+ | }; | ||
+ | |||
+ | /* inicializuje prázdny rad */ | ||
+ | void init(queue &q) { | ||
+ | q.first = 0; | ||
+ | q.count = 0; | ||
+ | q.items = new dataType[maxN]; | ||
+ | } | ||
+ | |||
+ | /* zisti, ci je rad prazdny */ | ||
+ | bool isEmpty(queue &q) { | ||
+ | return q.count == 0; | ||
+ | } | ||
+ | |||
+ | /* prida prvok s hodnotou item na koniec radu */ | ||
+ | void enqueue(queue &q, dataType item) { | ||
+ | assert(q.count < maxN); | ||
+ | int last = (q.first + q.count) % maxN; | ||
+ | q.items[last] = item; | ||
+ | q.count++; | ||
+ | } | ||
+ | |||
+ | /* odoberie prvok zo začiatku radu a vráti jeho hodnotu */ | ||
+ | dataType dequeue(queue &q) { | ||
+ | assert(q.count > 0); | ||
+ | int index = q.first; /* kde je prvok, ktory chceme vratit */ | ||
+ | q.first = (q.first + 1) % maxN; | ||
+ | q.count--; | ||
+ | return q.items[index]; | ||
+ | } | ||
+ | |||
+ | /* vrati prvok zo zaciatku radu, ale necha ho v rade */ | ||
+ | dataType peek(queue &q) { | ||
+ | assert(q.count > 0); | ||
+ | return q.items[q.first]; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Zásobník implementovaný pomocou spájaného zoznamu== | ||
+ | * V zásobníku v poli sme na začiatku poľa mali spodok zásobníka | ||
+ | * V zozname budeme mať na začiatku zoznamu vrchol zásobníka, lebo na začiatok zoznamu sa dobre vkladá a vyberá. | ||
+ | * Použijeme kód na vkladanie a vyberanie zo zoznamu z prednášky 16 (prvok zoznamu sme premenovali na node, začiatok zoznamu na top) | ||
+ | * Nepotrebujeme vopred stanovavať maximálny počet prvkov, zásobník podľa potreby rastie alebo sa zmenšuje (kým je voľná pamäť) | ||
+ | <pre> | ||
+ | struct node { | ||
+ | dataType data; | ||
+ | node* next; | ||
+ | }; | ||
+ | |||
+ | struct stack { | ||
+ | node *top; /* vrchný prvok zásobníka */ | ||
+ | }; | ||
+ | |||
+ | /* inicializuje prázdny zásobník */ | ||
+ | void init(stack &s) { | ||
+ | s.top = NULL; | ||
+ | } | ||
+ | |||
+ | /* zisti, ci je zasobnik prazdny */ | ||
+ | bool isEmpty(stack &s) { | ||
+ | return s.top == NULL; | ||
+ | } | ||
+ | |||
+ | /* prida prvok s hodnotou item na vrch zasobnika */ | ||
+ | void push(stack &s, dataType item) { | ||
+ | node *temp = new node; | ||
+ | temp->data = item; | ||
+ | temp->next = s.top; | ||
+ | s.top = temp; | ||
+ | } | ||
+ | |||
+ | /* odoberie prvok z vrchu zásobníka a vráti jeho hodnotu */ | ||
+ | dataType pop(stack &s) { | ||
+ | assert(s.top != NULL); | ||
+ | node *temp = s.top->next; // prvok, ktorý bude ďalej top | ||
+ | dataType val = s.top->data; // to čo máme vrátiť | ||
+ | delete s.top; | ||
+ | s.top = temp; | ||
+ | return val; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Rad implementovaný pomocou spájaného zoznamu== | ||
+ | * Potrebujeme na jednom konci zoznamu vkladať, na opačnom vyberať. | ||
+ | * Použijeme kruhový zoznam, v ktorom posledný prvok ukazuje pomocou next na prvý prvok v zozname. | ||
+ | * Prvý prvok radu bude prvý v zozname, bude ukazovať na druhý prvok atď. | ||
+ | * V štruktúre queue si pamätáme iba smerník na posledný prvok radu. | ||
+ | ** Ak je rad prázdny, tento smerník je NULL. | ||
+ | ** Z posledného prvku sa jedným krokom vieme dostať k prvému prvku. | ||
+ | |||
+ | <pre> | ||
+ | struct queue { | ||
+ | node *last; /* posledný prvok v rade */ | ||
+ | }; | ||
+ | |||
+ | /* inicializuje prázdny rad */ | ||
+ | void init(queue &q) { | ||
+ | q.last = NULL; | ||
+ | } | ||
+ | |||
+ | /* zisti, ci je rad prazdny */ | ||
+ | bool isEmpty(queue &q) { | ||
+ | return q.last == NULL; | ||
+ | } | ||
+ | |||
+ | /* prida prvok s hodnotou item na koniec radu */ | ||
+ | void enqueue(queue &q, dataType item) { | ||
+ | node *temp = new node; | ||
+ | temp->data = item; | ||
+ | if (q.last == NULL) { | ||
+ | q.last = temp; | ||
+ | temp->next = temp; | ||
+ | } else { | ||
+ | temp->next = q.last->next; | ||
+ | q.last->next = temp; | ||
+ | q.last = temp; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | /* odoberie prvok zo začiatku radu a vráti jeho hodnotu */ | ||
+ | dataType dequeue(queue &q) { | ||
+ | assert(q.last != NULL); | ||
+ | node *first = q.last->next; | ||
+ | if (first->next == first) { /* ak v zozname iba jeden prvok */ | ||
+ | q.last = NULL; | ||
+ | } else { /* v zozname viac prvkov, preskocime first */ | ||
+ | q.last->next = first->next; | ||
+ | } | ||
+ | dataType val = first->data; | ||
+ | delete first; /* zmazeme node pre first */ | ||
+ | return val; | ||
+ | } | ||
+ | |||
+ | /* vrati prvok zo zaciatku radu, ale necha ho v rade */ | ||
+ | dataType peek(queue &q) { | ||
+ | assert(q.last != NULL); | ||
+ | return q.last->next->data; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Použitie rady a zásobníka== | ||
+ | Zvyčajne uchovávajú dáta, ktoré ešte treba spracovať, resp. zoznam úloh. | ||
+ | |||
+ | Rad použijeme, ak chceme zachovať poradie. | ||
+ | * Jeden proces pridáva úlohy, druhý ich rieši (prípadne aj viac procesov môže vkladať alebo vyberať) | ||
+ | * Príklady: | ||
+ | ** Textový procesor pripravuje strany na tlač, vkladá ich do radu, tlačiareň ich tlačí | ||
+ | ** Výpočtové úlohy čakajú na veľkom serveri v rade na spustenie | ||
+ | ** Zákazníci čakajú na zákazníckej linke na voľného operátora | ||
+ | ** Pasažieri na stand-by čakajú na voľné miesto v lietadle | ||
+ | |||
+ | Zásobník je jednoduchší, používame ho, ak nám nezáleží na poradí, alebo ak chceme poradie prevracať | ||
+ | * Hlavný príklad je zásobník, ktorý kompilátor vytvorí na ukladanie lokálnych premenných funkcií, čo nám umožňuje použiť rekurziu (call stack) | ||
+ | * Pri nekonečnej rekurzii nám zásobník "pretečie" a program spadne, napr. s chybou Segmentation fault | ||
+ | <pre> | ||
+ | void pokus() { | ||
+ | int i; | ||
+ | pokus(); | ||
+ | } | ||
+ | |||
+ | int main() { | ||
+ | pokus(); | ||
+ | } | ||
+ | </pre> | ||
+ | * Rekurzívne programy vieme prepísať na nerekurzívne, napríklad pomocou ručne vytvoreného zásobníka | ||
+ | ** Mohli by sme mechanicky simulovať to, ako zásobník používa kompilátor, to by však bolo veľmi neprehľadné | ||
+ | ** Väčšinou trochu zmeníme ako presne program funguje | ||
+ | ** Ukážeme si niekoľko príkladov | ||
+ | |||
+ | ==Nerekurzívny QuickSort== | ||
+ | * Quicksort zvolí nejakú hodnotu, prvky menšie ako táto hodnota dá do ľavej časti poľa, väčšie prvky do pravej časti poľa | ||
+ | * Potom rekurzívne volá Quicksort na obe časti poľa | ||
+ | <pre> | ||
+ | void quicksort(int A[], int l, int r) { | ||
+ | if (l >= r) return; | ||
+ | |||
+ | // rozdelenie | ||
+ | int pivot = divide(A, l, r); | ||
+ | |||
+ | // reukrzivne volanie na mensie a vacsie prvky | ||
+ | quicksort(A, l, pivot - 1); | ||
+ | quicksort(A, pivot + 1, r); | ||
+ | } | ||
+ | int main() { | ||
+ | ... | ||
+ | quicksort(A, 0, n-1); | ||
+ | ... | ||
+ | } | ||
+ | </pre> | ||
+ | Namiesto rekurzie si spravíme zásobník dvojíc l,r, ktoré ešte treba dotriediť | ||
+ | <pre> | ||
+ | struct usek { | ||
+ | int l, r; | ||
+ | }; | ||
+ | |||
+ | typedef usek dataType; | ||
+ | |||
+ | void quicksort(int A[], int n) { | ||
+ | stack s; | ||
+ | init(s); | ||
+ | |||
+ | /* do stacku vlozime usek pre cele pole */ | ||
+ | usek u; | ||
+ | u.l = 0; | ||
+ | u.r = n - 1; | ||
+ | push(s, u); | ||
+ | |||
+ | while (!isEmpty(s)) { | ||
+ | u = pop(s); | ||
+ | /* spracovavame usek od u.l po u.r */ | ||
+ | if (u.l >= u.r) continue; | ||
+ | |||
+ | /* rozdelenie */ | ||
+ | int pivot = divide(A, u.l, u.r); | ||
+ | |||
+ | /* ľavý a pravý úsek vložíme do stacku na neskoršie dotriedenie */ | ||
+ | usek u1; | ||
+ | u1.l = u.l; | ||
+ | u1.r = pivot - 1; | ||
+ | usek u2; | ||
+ | u2.l = pivot + 1; | ||
+ | u2.r = u.r; | ||
+ | push(s, u2); | ||
+ | push(s, u1); | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | * Tento program triedi úseky v rovnakom poradí, ako rekurzívny Quicksort, lebo po rozdelení intervalu [0..n-1] na dve časti dá na vrchol zásobníka ľavú časť. Až keď sa táto ľavá časť a všetky podúlohy, ktoré z nej vzniknú, spracuje, vytiahne sa zo zásobníka pravá časť. | ||
+ | * V Quicksorte však na poradí nezáleží, takže by sme mohli vložiť úseky aj naopak push(s, u1); push(s, u2); (potom by najprv dotriedil pravú časť až potom ľavú) | ||
+ | * Alebo by sme namiesto zásobníka mohli použiť rad. Potom by najskôr rozdelil ľavú aj pravú časť na ďalšie podčasti a potom by delil každú z týchto podčastí atď | ||
+ | |||
+ | '''Na zamyslenie''': ako by sme spravili nerekurzívny MergeSort? Prečo to nejde tak isto ako Quicksort? | ||
+ | |||
+ | ==Kontrola uzátvorkovania== | ||
+ | * Jednoduchý príklad na použitie zásobníka | ||
+ | * Máme daný reťazec obsahujúci zátvorky rôznych typov (,),[,],{,} a chceme zistiť, či je dobre uzátvorkovaný | ||
+ | * Ak zoberieme prvých i znakov reťazca, počet uzátvaracích zátvoriek nesmie prevýšiť počet otváracích | ||
+ | * Ku každej otváracej zátvorke musí byť zatváracia toho istého typu | ||
+ | <pre> | ||
+ | +2 | ||
+ | Vyraz je dobre uzatvorkovany | ||
+ | |||
+ | (x+2) | ||
+ | Vyraz je dobre uzatvorkovany | ||
+ | |||
+ | [((({}[])[]))] | ||
+ | Vyraz je dobre uzatvorkovany | ||
+ | |||
+ | [[#)) | ||
+ | Vyraz nie je dobre uzatvorkovany | ||
+ | |||
+ | ())( | ||
+ | Vyraz nie je dobre uzatvorkovany | ||
+ | |||
+ | (( | ||
+ | Vyraz nie je dobre uzatvorkovany | ||
+ | </pre> | ||
+ | |||
+ | Do zásobníka si budeme ukladať pre každú začínajúcu zátvorku jej zodpovedajúcu končiacu. Keď príde končiaca zátvorka, skontrolujeme, či na vrchu zásobníka je to isté (a vyberieme to zo zásobníka). | ||
+ | <pre> | ||
+ | typedef char dataType; | ||
+ | |||
+ | char vyraz[100]; | ||
+ | fgets(vyraz, 100, stdin); // nacitame retazec do pola vyraz | ||
+ | stack s; | ||
+ | init(s); | ||
+ | bool spravny = true; | ||
+ | for (int i = 0; vyraz[i] != 0; i++) { | ||
+ | switch (vyraz[i]) { | ||
+ | case '(': | ||
+ | push(s, ')'); | ||
+ | break; | ||
+ | case '[': | ||
+ | push(s, ']'); | ||
+ | break; | ||
+ | case '{': | ||
+ | push(s, '}'); | ||
+ | break; | ||
+ | case ')': | ||
+ | case ']': | ||
+ | case '}': | ||
+ | if (isEmpty(s)) { | ||
+ | spravny = false; | ||
+ | } else { | ||
+ | char c = pop(s); | ||
+ | if (c != vyraz[i]) { | ||
+ | spravny = false; | ||
+ | } | ||
+ | } | ||
+ | break; | ||
+ | } | ||
+ | } | ||
+ | if (spravny) { | ||
+ | cout << "Vyraz je dobre uzatvorkovany" << endl; | ||
+ | } else { | ||
+ | cout << "Vyraz nie je dobre uzatvorkovany" << endl; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | '''Cvičenie:''' | ||
+ | * Čo spraví program, ak na vstupe je ((? Opravte ho, aby fungoval správne. | ||
+ | * Pridajte do programu výpis pozície, kde bola detekovaná chyba a výpis typu chyby. | ||
+ | * Prepíšte program na kontrolu zátvoriek do rekurzívnej podoby, pričom použijete iba premenné typu char (žiadne polia a pod.). Reťazec načítavajte pomocou getc a ungetc, ukončený je koncom riadku. | ||
+ | =Cvičenia 9= | ||
+ | == Matice == | ||
+ | Napíšte funkcie, ktoré dostanú na vstupe dvojrozmernú maticu celých čísel s n riadkami a m stĺpcami a spravia s ňou jednu z týchto operácií: | ||
+ | * Otočte poradie riadkov matice (stačí vymeniť smerníky) | ||
+ | * Otočte poradie stĺpcov matice (treba vymienať čísla v riadkoch) | ||
+ | * Zostavte transponovanú maticu, t.j. s m riadkami a n stĺcami | ||
+ | Na testovanie vášho programu môžete použiť funkcie na prácu s maticami z [[#Prednáška_15#Funkcie_pre_alok.C3.A1ciu_matice|prednášky 15]]. | ||
+ | |||
+ | == 2D polia == | ||
+ | * Vytvorte Pascalov trojuholník ako 2D pole, ktoré má v prvom riadku jedno číslo <math>{0 \choose 0}</math>, v druhom dve <math>{1 \choose 0}</math> a <math>{1 \choose 1}</math> atď. Môžete využiť vzťah, že <math>{n \choose 0} = {n \choose 0} = 1</math> a pre 0<k<n platí <math>{n \choose k} = {n-1 \choose k-1} + {n-1 \choose k}</math>, t.j. n-tý riadok vieme ľahko spočítať z n-1-vého. | ||
+ | * Do [[#Prednáška_15#Program_mapa_pre_predn.C3.A1.C5.A1ku_15|programu s výškovou mapou z prednášky 15]] doprogramujte hľadanie všetkých ostrovčekov veľkosti 1, t.j. políčka s pevninou, ktoré sa hranou nedotýkajú inej pevniny (môžu sa dotýkať rohom). Každý taký ostrovček zarámikujte. Spravte si vstup, v ktorom takéto ostrovčeky budú, aby ste mohli program vyskúšať. | ||
+ | |||
+ | == Vektor == | ||
+ | * Do programu na prácu s vektorom z [[#Prednáška_14#Vector|prednášky 14]] doprogramujte funkciu void removeLast(vector &a), ktorá z poľa vyhodí posledný prvok (zmenší sa teda n) a ak bude n menší ako tretina veľkosti, vytvorí nové pole polovičnej veľkosti, zvyšné prvky do neho premiestni, a staré pole uvoľní. Pole by malo mať vždy veľkosť aspoň 1. | ||
+ | |||
+ | == 2D vektor== | ||
+ | * Vytvorte dvojrozmerný vektor, ktorý bude podporovať nasledovné operácie: | ||
+ | ** Inicializuj: Nastaví počiatočnú použiteľnú veľkosť na 2x2, N(počet riadkov)=0 a M(počet stĺpcov)=0. | ||
+ | ** Pridaj riadok: Ak sa do súčasnej veľkosti zmestí, pridá riadok (zväčší N) obsahujúci M núl. Ak sa nezmestí, zdvojnásobí počet riadkov. | ||
+ | ** Pridaj stĺpec: Ak sa do súčasnej veľkosti zmestí, pridá stĺpec (zväčší M) obsahujúci N núl. Ak sa nezmestí, zdvojnásobí počet stĺpcov. | ||
+ | ** Prístup k prvku na riadku i a stĺpci j (funkcie get a set) | ||
+ | ** Uvoľni: Uvoľní pamäť. | ||
+ | |||
+ | ==Hra Life== | ||
+ | Na konci [[#Prednáška_15#Hra_life|prednášky 15]] je program na simulovanie hry Life. | ||
+ | * Prečítajte si popis tejto hry a skúste si spustiť [[#Program life pre prednášku 12|príslušný program]] | ||
+ | * Zobrazovanie hry Life zmeňte tak, aby sa bunky, ktoré práve umreli, zobrazili ako sivé políčka a až v ďalšom kroku zmizli úplne. (T.j. v čase t bunka žije, teda je čierne, v čase t+1 umrela teda je sivá a v čase t+2 bude bielou, ak sa znova nenarodila). Pre jednoduchosť môžete v každom kole zmazať obrazovku a vykresľovať všetky políčka odzova. | ||
+ | =DÚ7= | ||
+ | {{MDU|7|4762}} max. 10 bodov plus 3 body bonus, termín odovzdania 19.11.2012 o 22:00 | ||
+ | |||
+ | Cieľom tejto domácej úlohy je precvičiť si prácu so súbormi. | ||
+ | |||
+ | Váš program na vstupe načíta zo súboru zoznam mailových kontaktov a vypíše ho v prehľadnejšom tvare do iného súboru. Podrobne si prečítajte celé zadanie a dodržte všetky pokyny. | ||
+ | |||
+ | '''Popis vstupného súboru''' | ||
+ | * Súbor pozostáva zo slov oddelených bielymi znakmi, pričom pod slovom rozumieme postupnosť nebielych znakov ohraničenú bielymi znakmi, prípadne začiatkom a koncom súboru. Medzi dvoma slovami môže byť aj viac ako jeden biely znak. Na začiatku a konci súboru môžu a nemusia byť biele znaky. | ||
+ | * V súbore sú údaje o niekoľkých osobách a ich e-mailových adresách, pričom záznam o jednej osobe začína jedným alebo viacerými slovami tvoriacimi meno a za nimi nasleduje jedno slovo tvoriace e-mailovú adresu. | ||
+ | ** Slová tvoriace meno rozpoznáme podľa toho, že obsahujú iba písmená anglickej abecedy (malé alebo veľké, bez diakritiky). | ||
+ | ** E-mailové adresy obsahujú podslová oddelené znakmi '.' alebo '@', pričom znak '@' sa v e-mailovej adrese vyskytuje práve raz. Jednotlivé podslová môžu byť tvorené ľubovoľnými nebielymi znakmi okrem '.' a '@', ale musia obsahovať aspoň jedno písmeno anglickej abecedy (malé alebo veľké, bez diakritiky). | ||
+ | |||
+ | '''Popis výstupného súboru''' | ||
+ | * Záznam o každej osobe je na zvláštnom riadku, pričom jednotlivé slová v mene sú oddelené práve jednou medzerou. | ||
+ | * Medzi koncom mena a začiatkom e-mailovej adresy je tiež práve jedna medzera. | ||
+ | * Mená zarovnávajte doprava tak, aby najdlhšie meno v súbore začínalo na začiatku riadku a pred kratšie mená vložte na začiatok riadku medzery tak, aby všetky mená končili v tom istom stĺpci. | ||
+ | * Záznamy vo výstupnom súbore budú v rovnakom poradí ako na vstupe. | ||
+ | |||
+ | '''Príklad vstupu a výstupu''' | ||
+ | <pre> | ||
+ | Janko | ||
+ | Hrasko jano1@hrasok.com | ||
+ | Jozko F Mrkvicka | ||
+ | jozko.f.mrkv$icka@mrkvicka.v.mrkvickovej.hriadke6.xy? | ||
+ | </pre> | ||
+ | |||
+ | <pre> | ||
+ | Janko Hrasko jano1@hrasok.com | ||
+ | Jozko F Mrkvicka jozko.f.mrkv$icka@mrkvicka.v.mrkvickovej.hriadke6.xy? | ||
+ | </pre> | ||
+ | |||
+ | '''Ďalšie pokyny''' | ||
+ | * Ako názov vstupného súboru zadajte <tt>zoznam.txt</tt> a výstupného súboru <tt>prehlad.txt</tt>. Pri otváraní súborov zadajte iba meno bez cesty, súbor sa vám podľa nastavení Netbeans vytvorí buď v domovskom adresári alebo v adresári s projektom. | ||
+ | * Pri alokovaní pamäte môžete predpokladať, že počet osôb v súbore je najviac 100 a dĺžka každého slova vo vstupnom súbore je tiež najviac 100. | ||
+ | * Pozor, počet súčastí jedného mena nie je ohraničený, teda pamäť na ukladanie celého mena alebo jednotlivých slov mena alokujte dynamicky podľa potreby a nespoliehajte sa, že sa zmestia do dopredu danej dĺžky. | ||
+ | * Pri načítavaní súboru kontrolujte, či: | ||
+ | ** súbor obsahuje najviac 100 záznamov | ||
+ | ** súbor nezačína e-mailovou adresou (prvé musí ísť vždy meno) | ||
+ | ** súbor nekončí menom (za každým menom musí e-mailová adresa) | ||
+ | ** v súbore nejdú dve emailové adresy za sebou (medzi každými dvomi musí byť aspoň jedno slovo mena) | ||
+ | ** neobsahuje reťazce, ktoré nie sú ani meno ani e-mailová adresa | ||
+ | Ak niektorá z týchto podmienok nie je splnená, vypíšte na konzolu vhodnú chybovú hlášku a ukončite program príkazom exit(1) z knižnice cstdlib, prípadne príkazom return 1, ak ste vo funkcii main. | ||
+ | * Dbajte na čitateľnosť programu, rozdeľte ho na vhodne definované funkcie. | ||
+ | |||
+ | '''Dobré rady''' (ktoré nie je nutné dodržať, ak si myslíte, že to viete spraviť lepšie) | ||
+ | * Pri načítavaní ukladajte údaje do poľa struct-ov, napr. | ||
+ | <pre> | ||
+ | struct osoba { | ||
+ | char *meno; | ||
+ | char *email; | ||
+ | }; | ||
+ | </pre> | ||
+ | * Ak <tt>zoznam</tt> je pole typu <tt>osoba</tt>, tak dĺžku mena i-tej osoby zistíme príkazom <tt>strlen(zoznam[i].meno)</tt> | ||
+ | * Na načítavanie použite fscanf do premennej typu char[100]. Táto funkcia sa postará o rozdelenie súboru na slová. | ||
+ | * Dajte pozor na správnu detekciu konca súboru. Pre FILE *f vráti feof(f) true, iba ak pri predchádzajúcom načítaní program narazil na koniec súboru. Vyskúšajte teda, či Váš program funguje aj v prípade, že súbor končí bielym znakom, aj v prípade, že končí napr. nejakým písmenom. | ||
+ | * To, či je znak písmeno, môžete overiť funkciou isalpha z knižnice cctype. | ||
+ | |||
+ | '''Bonusová úloha''' | ||
+ | * V zozname nájdite záznamy s tým istým menom (meno je také isté, ak sa skladá z tých istých slov v tom istom poradí). Každú takúto skupinu e-mailových adries pre rovnaké meno vypíšte na jednom riadku, pričom najprv ide meno zarovnané doprava a potom jednotlivé adresy oddelené čiarkou a medzerou. | ||
+ | * Tieto dáta vypíšte do súboru <tt>skupiny.txt</tt> | ||
+ | * Nemusíte dbať na rýchlosť, môžete porovnávať každé meno s každým. | ||
+ | * Poradie záznamov nemusíte zachovať. | ||
+ | * Bonusovú a hlavnú časť úlohy odovzdajte v tom istom programe, ktorý bude vypisovať obidva súbory. | ||
+ | |||
+ | Príklad | ||
+ | <pre> | ||
+ | Janko M. jano@mail.com | ||
+ | Misko misko@pieskovisko.sk | ||
+ | Janko | ||
+ | M. janicko@nieco.divne.xy | ||
+ | </pre> | ||
+ | |||
+ | <pre> | ||
+ | Janko M. jano@mail.com, janicko@nieco.divne.xy | ||
+ | Misko misko@pieskovisko.sk | ||
+ | </pre> | ||
+ | =Prednáška 19= | ||
+ | ==Vyfarbovanie súvislých oblastí== | ||
+ | Máme daný obrázok pozostávajúci z m riadkov a n stĺpcov pixelov, každý pixel určitej farby. V našom jednoduchom príklade budeme uvažovať iba 4 farby, ktoré budeme zapisvať číslami 0,..,3 a ktorých význam bude daný týmto poľom, takže napr. farba 0 je biela: | ||
+ | <pre> | ||
+ | const string farby[4] = {"white", "green", "black", "brown"}; | ||
+ | </pre> | ||
+ | |||
+ | Užívateľ si zvolí určitý pixel obrázku a chce vyfarbiť celú súvislú jednofarebnú oblasť obsahujúcu tento pixel novou farbou. Ak napríklad začneme vyfarbovať v obrázku vľavo farbou 3 (hnedou) od pixelu (0,0), dostaneme obrázok napravo: | ||
+ | <gallery> | ||
+ | Image:PROG-P17-vyfarbi1.png | ||
+ | Image:PROG-P17-vyfarbi2.png | ||
+ | </gallery> | ||
+ | |||
+ | Tu je pôvodný obrázok v textovej forme, ako matica čísel. | ||
+ | <pre> | ||
+ | 11 17 | ||
+ | 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 | ||
+ | 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0 | ||
+ | 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 | ||
+ | 0 0 0 1 0 0 0 0 0 2 2 1 2 2 2 2 0 | ||
+ | 0 0 0 1 0 0 0 0 0 2 0 1 0 0 0 2 0 | ||
+ | 0 2 2 2 2 2 2 2 0 2 2 1 2 2 2 2 0 | ||
+ | 0 2 0 1 0 0 0 2 0 0 0 1 0 0 0 0 0 | ||
+ | 0 2 0 1 0 0 0 2 0 0 0 1 0 1 1 1 1 | ||
+ | 0 2 0 1 1 1 1 2 1 1 1 1 0 1 0 0 1 | ||
+ | 0 2 0 0 0 0 0 2 0 0 0 0 0 1 1 1 1 | ||
+ | 0 2 2 2 2 2 2 2 0 0 0 0 0 0 0 0 0 | ||
+ | </pre> | ||
+ | |||
+ | Túto úlohu vieme vyriešiť nasledujúcou rekurzívnou funkciou, ktorá prefarbí zadané políčko a potom rekurzívne pokračuje vo vyfarbovaní vo všetkých susedoch, ktorí majú rovnakú farbu, ako pôvodne malo toto políčko. | ||
+ | <pre> | ||
+ | void vyfarbi(int **a, int n, int m, int riadok, int stlpec, int farba) { | ||
+ | /* prefarbi suvislu jednofarebnu oblast obsahujucu | ||
+ | * a[riadok][stlpec] na farbu farba */ | ||
+ | |||
+ | if (a[riadok][stlpec] != farba) { | ||
+ | int stara_farba = a[riadok][stlpec]; | ||
+ | a[riadok][stlpec] = farba; | ||
+ | if (riadok > 0 && a[riadok - 1][stlpec] == stara_farba) { | ||
+ | vyfarbi(a, n, m, riadok - 1, stlpec, farba); | ||
+ | } | ||
+ | if (riadok + 1 < n && a[riadok + 1][stlpec] == stara_farba) { | ||
+ | vyfarbi(a, n, m, riadok + 1, stlpec, farba); | ||
+ | } | ||
+ | if (stlpec > 0 && a[riadok][stlpec - 1] == stara_farba) { | ||
+ | vyfarbi(a, n, m, riadok, stlpec - 1, farba); | ||
+ | } | ||
+ | if (stlpec + 1 < m && a[riadok][stlpec + 1] == stara_farba) { | ||
+ | vyfarbi(a, n, m, riadok, stlpec + 1, farba); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Susedov náš program pozerá v poradí hore, dole, doľava, doprava. | ||
+ | * V akom poradí vyfarbí políčka nulovej matice 2x2 ak začne v ľavom hornom rohu? | ||
+ | * V akom poradí vyfarbuje jednoriadkovú maticu, ak začneme niekde v strede? | ||
+ | |||
+ | ===Zdrojový kód celého programu=== | ||
+ | * Tento program vytvorí maticu a vyfarbí v ňom jednu oblasť aj s animáciou: [[#Program rekurzívne vyfarbovanie]] | ||
+ | |||
+ | ==Použitie vyfarbovania na mape== | ||
+ | Spomeňme si na program na prácu s výškovou mapu z [[#Prednáška_15|prednášky 15]]. Máme zadanú mapu ako maticu celých čísel, v ktorej 0 znamená more a kladné čísla nadmorskú výšku pevniny. Budeme predpokladať, že na mape je niekoľko ostrovov, ktoré sú plne obkolesené morom a nemajú žiadne vnútorné moria ani jazerá. Chceme spočítať, koľko tam tých ostrovov je. | ||
+ | |||
+ | Použijeme na to vyfarbovanie z predchádzajúceho programu. | ||
+ | * Prejdeme maticu a všetky kladné čísla prepíšeme na 1. Máme teda 0 vyznačené more a 1 ostrovy. | ||
+ | * Prechádzame maticu a vždy, keď nájdeme 1 (ešte nepreskúmaný ostrov), vyfarbíme ho farbou 2 a zvýšime počet ostrovov. | ||
+ | * Nakoniec máme more ako 0 a všetky ostrovy ako 2. | ||
+ | |||
+ | Príklad mapy a jej zobrazenie po prepísaní kladných čísel na 1 (zelená), po vyfarbení prvého ostrova číslom 2 (čiernou) a po vyfarbení všetkých ostrovov. | ||
+ | <pre> | ||
+ | 11 17 | ||
+ | 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 | ||
+ | 0 0 0 1 9 1 1 1 0 0 1 1 0 0 0 0 0 | ||
+ | 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 | ||
+ | 0 0 0 1 0 0 0 0 0 1 1 1 0 0 1 1 0 | ||
+ | 0 0 0 1 0 0 0 0 0 2 0 0 0 0 0 1 0 | ||
+ | 0 1 0 0 2 2 2 2 0 2 2 1 7 1 1 1 0 | ||
+ | 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 | ||
+ | 0 7 0 1 0 0 0 2 0 0 0 1 0 1 1 1 0 | ||
+ | 0 0 0 1 5 1 1 2 1 1 3 1 0 1 2 2 0 | ||
+ | 0 1 0 0 0 1 1 2 2 0 0 0 0 1 1 1 0 | ||
+ | 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 | ||
+ | </pre> | ||
+ | <gallery> | ||
+ | Image:PROG-P17-ostrovy1.png | ||
+ | Image:PROG-P17-ostrovy3.png | ||
+ | Image:PROG-P17-ostrovy2.png | ||
+ | </gallery> | ||
+ | |||
+ | Takto to naprogramujeme: | ||
+ | <pre> | ||
+ | for(int i=0; i<n; i++) { | ||
+ | for(int j=0; j<m; j++) { | ||
+ | if(a[i][j]>0) a[i][j] = 1; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int ostrovov = 0; | ||
+ | for(int i=0; i<n; i++) { | ||
+ | for(int j=0; j<m; j++) { | ||
+ | if(a[i][j]==1) { | ||
+ | ostrovov++; | ||
+ | vyfarbi(a, n, m, i, j, 2); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | cout << "Pocet ostrovov: " << ostrovov << endl; | ||
+ | </pre> | ||
+ | |||
+ | ===Zdrojový kód celého programu=== | ||
+ | * Tento program načíta maticu a zobrazuje vyfarbovanie ostrovov: [[#Ukážkový program ostrovy]] | ||
+ | |||
+ | ==Nerekurzívne vyfarbovanie== | ||
+ | |||
+ | Prepíšme si štyri volania rekurzívne do jedného cyklu pomocou polí delta_riadok a delta_stlpec. | ||
+ | <pre> | ||
+ | const int delta_stlpec[4] = {1, 0, -1, 0}; | ||
+ | const int delta_riadok[4] = {0, -1, 0, 1}; | ||
+ | |||
+ | void vyfarbi(int **a, int n, int m, int riadok, int stlpec, int farba) { | ||
+ | /* prefarbi suvislu jednofarebnu oblast obsahujucu | ||
+ | * a[riadok][stlpec] na farbu farba */ | ||
+ | |||
+ | if (a[riadok][stlpec] != farba) { | ||
+ | int stara_farba = a[riadok][stlpec]; | ||
+ | a[riadok][stlpec] = farba; | ||
+ | for (int smer = 0; smer < 4; smer++) { | ||
+ | /* skus susedne policko so suradnicami r,s */ | ||
+ | int r = riadok + delta_riadok[smer]; | ||
+ | int s = stlpec + delta_stlpec[smer]; | ||
+ | if (r >= 0 && r < n && s >= 0 && s < m && a[r][s] == stara_farba) { | ||
+ | vyfarbi(a, n, m, r, s, farba); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Namiesto rekurzie budeme používať zásobník. Do zásobníka si môžeme uložiť štyroch susedov aktuálneho políčka, pretože z nich ešte treba vyfarbovať ďalej. Ale spravíme malú zmenu: pred uložením do stacku ich už prefarbíme novou farbou, aby sme vedeli, že ich už viackrát do zásobníka nemáme dať. | ||
+ | <pre> | ||
+ | struct policko { | ||
+ | int r, s; | ||
+ | }; | ||
+ | |||
+ | typedef policko dataType; | ||
+ | |||
+ | void vyfarbi(int **a, int n, int m, int riadok, int stlpec, int farba) { | ||
+ | /* prefarbi suvislu jednofarebnu oblast obsahujucu | ||
+ | * a[riadok][stlpec] na farbu farba */ | ||
+ | |||
+ | stack s; | ||
+ | init(s); | ||
+ | |||
+ | /* vyfarbi startovacie policko a daj ho do stacku */ | ||
+ | int stara_farba = a[riadok][stlpec]; | ||
+ | if (stara_farba == farba) return; | ||
+ | a[riadok][stlpec] = farba; | ||
+ | policko p; | ||
+ | p.r = riadok; | ||
+ | p.s = stlpec; | ||
+ | push(s, p); | ||
+ | |||
+ | while (!isEmpty(s)) { | ||
+ | /* vytiahni policko zo stacku */ | ||
+ | p = pop(s); | ||
+ | /* skontroluj jeho susedov, vyfarbi ich a uloz to stacku */ | ||
+ | for (int smer = 0; smer < 4; smer++) { | ||
+ | policko p2; | ||
+ | p2.r = p.r + delta_riadok[smer]; | ||
+ | p2.s = p.s + delta_stlpec[smer]; | ||
+ | if (p2.r >= 0 && p2.r < n && p2.s >= 0 && p2.s < m | ||
+ | && a[p2.r][p2.s] == stara_farba) { | ||
+ | a[p2.r][p2.s] = farba; | ||
+ | push(s, p2); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Namiesto zásobníka môžeme použiť aj rad, potom bude vyfarbovať v poradí podľa vzdialenosti od štartovacieho políčka (prehľadávanie do šírky) | ||
+ | <pre> | ||
+ | void vyfarbi(int **a, int n, int m, int riadok, int stlpec, int farba) { | ||
+ | /* prefarbi suvislu jednofarebnu oblast obsahujucu | ||
+ | * a[riadok][stlpec] na farbu farba */ | ||
+ | |||
+ | queue q; | ||
+ | init(q); | ||
+ | |||
+ | /* vyfarbi startovacie policko a daj ho do radu */ | ||
+ | int stara_farba = a[riadok][stlpec]; | ||
+ | if (stara_farba == farba) return; | ||
+ | a[riadok][stlpec] = farba; | ||
+ | policko p; | ||
+ | p.r = riadok; | ||
+ | p.s = stlpec; | ||
+ | enqueue(q, p); | ||
+ | |||
+ | while (!isEmpty(q)) { | ||
+ | /* vytiahni policko z radu */ | ||
+ | p = dequeue(q); | ||
+ | zobrazStvorcek(p.r, p.s, a[p.r][p.s], "lightgray", window); | ||
+ | window.wait(waitTime); | ||
+ | /* skontroluj jeho susedov, vyfarbi ich a uloz to radu */ | ||
+ | for (int smer = 0; smer < 4; smer++) { | ||
+ | policko p2; | ||
+ | p2.r = p.r + delta_riadok[smer]; | ||
+ | p2.s = p.s + delta_stlpec[smer]; | ||
+ | if (p2.r >= 0 && p2.r < n && p2.s >= 0 && p2.s < m | ||
+ | && a[p2.r][p2.s] == stara_farba) { | ||
+ | a[p2.r][p2.s] = farba; | ||
+ | enqueue(q, p2); | ||
+ | zobrazStvorcek(p2.r, p2.s, a[p2.r][p2.s], "red", window); | ||
+ | window.wait(waitTime); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Sudoku== | ||
+ | Chceme riešiť hlavolam Sudoku. Máme danú plochu 9x9 políčok, pričom niektoré sú prázdne, iné obsahujú číslo z množiny {1..9}. Plocha je rozdelená do 9 štvorcov 3x3. Cieľom je doplniť čísla do prázdnych štvorčekov tak, aby v každom riadku plochy, v každom stĺpci plochy a v každom štvorci 3x3 bola každá cifra {1..9} práve raz. | ||
+ | |||
+ | <pre> | ||
+ | . 3 . | . 7 . | . . . | ||
+ | 6 . . | 1 9 5 | . . . | ||
+ | . 9 8 | . . . | . 6 . | ||
+ | --------------------- | ||
+ | 8 . . | . 6 . | . . 3 | ||
+ | 4 . . | 8 . 3 | . . 1 | ||
+ | . . . | . 2 . | . . 6 | ||
+ | --------------------- | ||
+ | . 6 . | . . . | 2 8 . | ||
+ | . . . | 4 . 9 | . . 5 | ||
+ | . . . | . 8 . | . 7 . | ||
+ | </pre> | ||
+ | |||
+ | Príklad vstupu a výstupu: | ||
+ | <pre> | ||
+ | Vstup: Vystup: | ||
+ | 0 3 0 0 7 0 0 0 0 5 3 4 6 7 8 9 1 2 | ||
+ | 6 0 0 1 9 5 0 0 0 6 7 2 1 9 5 3 4 8 | ||
+ | 0 9 8 0 0 0 0 6 0 1 9 8 3 4 2 5 6 7 | ||
+ | 8 0 0 0 6 0 0 0 3 8 5 9 7 6 1 4 2 3 | ||
+ | 4 0 0 8 0 3 0 0 1 4 2 6 8 5 3 7 9 1 | ||
+ | 0 0 0 0 2 0 0 0 6 7 1 3 9 2 4 8 5 6 | ||
+ | 0 6 0 0 0 0 2 8 0 9 6 1 5 3 7 2 8 4 | ||
+ | 0 0 0 4 0 9 0 0 5 2 8 7 4 1 9 6 3 5 | ||
+ | 0 0 0 0 8 0 0 7 0 3 4 5 2 8 6 1 7 9 | ||
+ | |||
+ | Pocet rieseni: 1 | ||
+ | </pre> | ||
+ | |||
+ | Naša rekurzívna procedúra bude postupovať nasledovne: | ||
+ | * nájde na ploche prázdne políčko, ak také nie je, vypíše riešenie a skončí | ||
+ | * do prázdneho políčka skúša vložiť čísla 1...9 a testuje, či nenastane konflikt v riadku, stĺpci alebo štvorci | ||
+ | * ak niektoré číslo sedí, zavolá sa rekurzívne na vyplnenie zvyšných bielych miest | ||
+ | |||
+ | <pre> | ||
+ | void generuj(int **a) { | ||
+ | najdiVolne(a,r,s); | ||
+ | if ((r < 0)||(s < 0)) { | ||
+ | vypis(a); | ||
+ | } else { | ||
+ | for (int x = 1; x <= 9; x++) { | ||
+ | if (moze(a, r, s, x)) { | ||
+ | a[r][s]=x; | ||
+ | generuj(a); | ||
+ | a[r][s]=0; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Nájdenie voľného miesta v tabuľke urobíme jednoduchým prechodom matice a hľadaním miesta, ktoré má hodnotu 0. Jeho súradnice uložíme do premenných r,s ak také existuje. V opačnom prípade nastavíme r=s=-1. | ||
+ | |||
+ | Funkcia môže prechádza riadok, stĺpec a štvorec do ktorého patrí miesto, ktoré práve obsadzujeme. Zisťuje, či sa poteniálny kandidát nenachádza uz niekde inde. | ||
+ | <pre> | ||
+ | bool moze(int **a, int riadok, int stlpec, int hodnota) { | ||
+ | /* Mozeme ulozit danu hodnotu na dane policko? | ||
+ | * Da sa to, ak riadok, stlpec, ani stvorec nema | ||
+ | * tuto hodnotu este pouzitu. */ | ||
+ | for (int i = 0; i < 9; i++) { | ||
+ | if (a[riadok][i] == hodnota) return false; | ||
+ | if (a[i][stlpec] == hodnota) return false; | ||
+ | } | ||
+ | /* lavy horny roh stvorca */ | ||
+ | int riadok1 = riadok - riadok % 3; | ||
+ | int stlpec1 = stlpec - stlpec % 3; | ||
+ | for (int i = 0; i < 3; i++) { | ||
+ | for (int j = 0; j < 3; j++) { | ||
+ | if (a[riadok1 + i][stlpec1 + j] == hodnota) return false; | ||
+ | } | ||
+ | } | ||
+ | return true; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Úpravy v sudoku=== | ||
+ | |||
+ | * Plochu zodpovedajúcu sudoku si nemusíme ukaldať ako dvojrozmerné pole veľkosti 9x9. V podstate nám stačí jednorozmerné veľkosti 9*9=81, kde miesto plocha[i] bude zodpovedať pôvodnému a[i/3][i%3] | ||
+ | * Tiež si môžeme pamätať, ktoré čísla sú už obsadené v riadku, stĺpci a štvorci. | ||
+ | |||
+ | Namiesto globálnych premenných si vytvoríme si struct sudoku, do ktorého uložíme všetky potrebné údaje pre rekurzívne vyhľadávanie. | ||
+ | <pre> | ||
+ | struct policko { | ||
+ | int riadok, stlpec, stvorec; | ||
+ | int hodnota; | ||
+ | }; | ||
+ | |||
+ | struct sudoku { | ||
+ | policko *plocha; /* pole vsetkych policok plochy */ | ||
+ | bool *obsadeneRiadok; /* pre kazdy riadok ci je dana cifra uz pouzita */ | ||
+ | bool *obsadeneStlpec; /* pre kazdy stlpec ci je dana cifra uz pouzita */ | ||
+ | bool *obsadeneStvorec; /* pre kazdy stvorec ci je dana cifra uz pouzita */ | ||
+ | int pocetPolicok; /* celkovy pocet policok (9*9) */ | ||
+ | int pocet; /* celkovy pocet riadkov,stlpcov a stvorcov (9) */ | ||
+ | int rieseni; /* pocet najdenych rieseni */ | ||
+ | }; | ||
+ | </pre> | ||
+ | |||
+ | Hneď pri inicializácii si musíme pre každé políčko povedať, kam vlastne patrí. Predpokladajme, že zadanie máme v dvojrozmernom poli a. | ||
+ | <pre> | ||
+ | void inicializuj(sudoku &s, int **a) { | ||
+ | /* inicializuj strukturu sudoku na zaklade | ||
+ | * vstupnej matice s cislami 0..9*/ | ||
+ | s.pocetPolicok = 9 * 9; | ||
+ | s.pocet = 9; | ||
+ | /* alokujeme polia a oznacime cifry ako neobsadene */ | ||
+ | s.plocha = new policko[s.pocetPolicok]; | ||
+ | s.obsadeneRiadok = new bool*[s.pocet]; | ||
+ | s.obsadeneStlpec = new bool*[s.pocet]; | ||
+ | s.obsadeneStvorec = new bool*[s.pocet]; | ||
+ | for (int i = 0; i < s.pocet; i++) { | ||
+ | s.obsadeneRiadok[i] = new bool[10]; | ||
+ | s.obsadeneStlpec[i] = new bool[10]; | ||
+ | s.obsadeneStvorec[i] = new bool[10]; | ||
+ | for (int j = 1; j <= 9; j++) { | ||
+ | s.obsadeneRiadok[i][j] = false; | ||
+ | s.obsadeneStlpec[i][j] = false; | ||
+ | s.obsadeneStvorec[i][j] = false; | ||
+ | } | ||
+ | } | ||
+ | /* pre kazde policko naplnime jeho strukturu | ||
+ | * a vyplnime obsadene cifry */ | ||
+ | int pozicia = 0; | ||
+ | for (int i = 0; i < 9; i++) { | ||
+ | for (int j = 0; j < 9; j++) { | ||
+ | s.plocha[pozicia].riadok = i; | ||
+ | s.plocha[pozicia].stlpec = j; | ||
+ | s.plocha[pozicia].stvorec = (i / 3)*3 + (j / 3); | ||
+ | uloz(s, pozicia, a[i][j]); | ||
+ | pozicia++; | ||
+ | } | ||
+ | } | ||
+ | /* este sme nenasli ziadne riesenie */ | ||
+ | s.rieseni = 0; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Rekurzia už potom musí okrem priradenia hodnoty na políčko obhospodáriť aj obsadenosť daného čísla v riadku, stĺpci a štvorci. Bude teda vyzera takto: | ||
+ | <pre> | ||
+ | void generuj(sudoku &s) { | ||
+ | int i = najdiVolne(s); | ||
+ | if (i < 0) { | ||
+ | vypis(s); | ||
+ | } else { | ||
+ | for (int x = 1; x <= 9; x++) { | ||
+ | if (moze(s, i, x)) { | ||
+ | uloz(s, i, x); | ||
+ | generuj(s); | ||
+ | zmaz(s, i, x); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Nájdenie voľného miesta ostáva podobné, ako v predchádzajúcom prípade. | ||
+ | * Uloženie alebo zmazanie hodnoty musí okrem priradenia hodnoty upraviť aj hodnoty v obsadeneRiadok, obsadeneStlpec a obsadeneStvorec. Funckcia uloz teda vyzerá nasledovne (funckiu zmaz analogicky): | ||
+ | |||
+ | <pre> | ||
+ | void uloz(sudoku &s, int pozicia, int hodnota) { | ||
+ | s.plocha[pozicia].hodnota = hodnota; | ||
+ | if (hodnota > 0) { | ||
+ | int riadok= s.plocha[pozicia].riadok; | ||
+ | int stlpec= s.plocha[pozicia].stlpec; | ||
+ | int stvorec= s.plocha[pozicia].stvorec; | ||
+ | s.obsadeneRiadok[riadok][hodnota] = true; | ||
+ | s.obsadeneStlpec[stlpec][hodnota] = true; | ||
+ | s.obsadeneStvorec[stvorec][hodnota] = true; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Funkcia moze() sa nám naopak zjednoduší. Na určenie, či hodnotu x môžeme priradiť na políčko p nám stačí skontrolovať či s.obsadeneRiadok[p.riadok], s.obsadeneStlpec[p.stlpec] aj s.obsadeneStvorec[p.stvorec] sú false. | ||
+ | |||
+ | === Ešte si to zoptimalizujeme === | ||
+ | |||
+ | Vidíme, že obsadeneRiadok, obsadeneStlpec aj obsadeneStvorec sú veľmi podobné polia. Môžeme si teda vytvoriť pole, ktoré celkovo popisuje obsadené prvky v ľubovoľnej skupine. Každý prvok potom má určené svoje skupiny do ktorých patrí (už nie tromi premennými riadok, stlpec, stvorec ale v poli, ktoré obsahuje indexy skupín v poli obsadene, kam políčko patrí). | ||
+ | |||
+ | * Výsledný program je tu: [[#Program Sudoku]] | ||
+ | |||
+ | * Takýmto spôsobom si vieme pridávať ďalšie požiadavky na naše riešenie sudoku. | ||
+ | * Čo by bolo treba zmeniť v programe, aby zakazoval opakujúce sa cifry aj na hlavnej diagonále celej plochy? | ||
+ | |||
+ | === Dalšie možné úpravy === | ||
+ | |||
+ | * Zlepšite algoritmus tak, aby nezačínal vždy s prvým prázdnym políčkom, ale s takým, ktoré má najmenej neobsadených možností (v ideálnom prípade 1). Ak má niektoré nevyplnené políčko 0 možností, môžeme túto vetvu hľadania tiež ukončiť. | ||
+ | |||
+ | ==Program rekurzívne vyfarbovanie== | ||
+ | <pre> | ||
+ | #include "../SimpleDraw.h" | ||
+ | #include <cstdio> | ||
+ | |||
+ | const string farby[4] = {"white", "green", "black", "brown"}; | ||
+ | /* velkost stvorceka mapy v pixeloch */ | ||
+ | const int stvorcek = 15; | ||
+ | /* cakanie po kazdom kroku vysvetlovania */ | ||
+ | double waitTime = 0.3; | ||
+ | |||
+ | int ** vytvorMaticu(int n, int m) { | ||
+ | /* vytvor maticu s n riadkami a m stlpcami */ | ||
+ | int **a; | ||
+ | a = new int *[n]; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | a[i] = new int[m]; | ||
+ | } | ||
+ | return a; | ||
+ | } | ||
+ | |||
+ | void zmazMaticu(int n, int m, int **a) { | ||
+ | /* uvolni pamat matice s n riadkami a m stlpcami */ | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | delete[] a[i]; | ||
+ | } | ||
+ | delete[] a; | ||
+ | } | ||
+ | |||
+ | void zobrazStvorcek(int i, int j, int farba, string farbaCiary, SimpleDraw &window) { | ||
+ | /* zobraz stvorcek v riadku i a stlpci j */ | ||
+ | window.setPenColor(farbaCiary); | ||
+ | window.setBrushColor(farby[farba]); | ||
+ | window.drawRectangle(j*stvorcek, i*stvorcek, stvorcek, stvorcek); | ||
+ | } | ||
+ | |||
+ | void zobrazMaticu(int **a, int n, int m, SimpleDraw &window) { | ||
+ | /* zobraz vsetky stvorceky matice */ | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | for (int j = 0; j < m; j++) { | ||
+ | zobrazStvorcek(i, j, a[i][j], "lightgray", window); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void obdlznik(int **a, int riadok, int stlpec, int vyska, int sirka, int farba) { | ||
+ | /* do matice vykresli ram obdlznika urcitej farby */ | ||
+ | for (int i = 0; i < sirka; i++) { | ||
+ | a[riadok][stlpec + i] = farba; | ||
+ | a[riadok + vyska - 1][stlpec + i] = farba; | ||
+ | } | ||
+ | for (int i = 0; i < vyska; i++) { | ||
+ | a[riadok + i][stlpec] = farba; | ||
+ | a[riadok + i][stlpec + sirka - 1] = farba; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void naplnMaticu(int **a, int n, int m) { | ||
+ | /* do matice vykrelsi tri obdlzniky. Rozmery musia byt aspon | ||
+ | * 11 riadkov a 17 stlpcov */ | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | for (int j = 0; j < m; j++) { | ||
+ | a[i][j] = 0; | ||
+ | } | ||
+ | } | ||
+ | obdlznik(a, 3, 9, 3, 7, 2); | ||
+ | obdlznik(a, 1, 3, 8, 9, 1); | ||
+ | obdlznik(a, 5, 1, 6, 7, 2); | ||
+ | obdlznik(a, 7, 13, 3, 4, 1); | ||
+ | } | ||
+ | |||
+ | void vyfarbi(int **a, int n, int m, int riadok, int stlpec, | ||
+ | int farba, SimpleDraw &window) { | ||
+ | /* prefarbi suvislu jednofarebnu oblast obsahujucu | ||
+ | * a[riadok][stlpec] na farbu farba */ | ||
+ | |||
+ | if (a[riadok][stlpec] != farba) { | ||
+ | int stara_farba = a[riadok][stlpec]; | ||
+ | a[riadok][stlpec] = farba; | ||
+ | zobrazStvorcek(riadok, stlpec, a[riadok][stlpec], "red", window); | ||
+ | window.wait(waitTime); | ||
+ | if (riadok > 0 && a[riadok - 1][stlpec] == stara_farba) { | ||
+ | vyfarbi(a, n, m, riadok - 1, stlpec, farba, window); | ||
+ | } | ||
+ | if (riadok + 1 < n && a[riadok + 1][stlpec] == stara_farba) { | ||
+ | vyfarbi(a, n, m, riadok + 1, stlpec, farba, window); | ||
+ | } | ||
+ | if (stlpec > 0 && a[riadok][stlpec - 1] == stara_farba) { | ||
+ | vyfarbi(a, n, m, riadok, stlpec - 1, farba, window); | ||
+ | } | ||
+ | if (stlpec + 1 < m && a[riadok][stlpec + 1] == stara_farba) { | ||
+ | vyfarbi(a, n, m, riadok, stlpec + 1, farba, window); | ||
+ | } | ||
+ | zobrazStvorcek(riadok, stlpec, a[riadok][stlpec], "lightgray", window); | ||
+ | window.wait(waitTime); | ||
+ | } | ||
+ | } | ||
+ | |||
+ | |||
+ | int main(void) { | ||
+ | int n = 11; | ||
+ | int m = 17; | ||
+ | int **a = vytvorMaticu(n, m); | ||
+ | naplnMaticu(a, n, m); | ||
+ | |||
+ | SimpleDraw window(m*stvorcek, n * stvorcek); | ||
+ | zobrazMaticu(a, n, m, window); | ||
+ | |||
+ | //vyfarbi(a, n, m, 1, 6, 3, window); | ||
+ | vyfarbi(a, n, m, 0, 0, 3, window); | ||
+ | |||
+ | window.showAndClose(); | ||
+ | |||
+ | zmazMaticu(n, m, a); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Ukážkový program ostrovy== | ||
+ | <pre> | ||
+ | #include "../SimpleDraw.h" | ||
+ | #include <cstdio> | ||
+ | |||
+ | const string farby[3] = {"white", "green", "black"}; | ||
+ | /* velkost stvorceka mapy v pixeloch */ | ||
+ | const int stvorcek = 15; | ||
+ | |||
+ | int ** vytvorMaticu(int n, int m) { | ||
+ | /* vytvor maticu s n riadkami a m stlpcami */ | ||
+ | int **a; | ||
+ | a = new int *[n]; | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | a[i] = new int[m]; | ||
+ | } | ||
+ | return a; | ||
+ | } | ||
+ | |||
+ | void zmazMaticu(int n, int m, int **a) { | ||
+ | /* uvolni pamat matice s n riadkami a m stlpcami */ | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | delete[] a[i]; | ||
+ | } | ||
+ | delete[] a; | ||
+ | } | ||
+ | |||
+ | |||
+ | void nacitajMaticu(FILE *f, int n, int m, int **a) { | ||
+ | /* matica je vytvorena, velkosti n, m, vyplnime ju cislami zo vstupu */ | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | for (int j = 0; j < m; j++) { | ||
+ | fscanf(f,"%d ",&a[i][j]); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void zobrazStvorcek(int i, int j, int farba, string farbaCiary, SimpleDraw &window) { | ||
+ | /* zobraz stvorcek v riadku i a stlpci j */ | ||
+ | window.setPenColor(farbaCiary); | ||
+ | window.setBrushColor(farby[farba]); | ||
+ | window.drawRectangle(j*stvorcek, i*stvorcek, stvorcek, stvorcek); | ||
+ | } | ||
+ | |||
+ | void zobrazMaticu(int **a, int n, int m, SimpleDraw &window) { | ||
+ | /* zobraz vsetky stvorceky matice */ | ||
+ | for (int i = 0; i < n; i++) { | ||
+ | for (int j = 0; j < m; j++) { | ||
+ | zobrazStvorcek(i, j, a[i][j], "lightgray", window); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void vyfarbi(int **a, int n, int m, int riadok, int stlpec, int farba) { | ||
+ | /* prefarbi suvislu jednofarebnu oblast obsahujucu | ||
+ | * a[riadok][stlpec] na farbu farba */ | ||
+ | |||
+ | if (a[riadok][stlpec] != farba) { | ||
+ | int stara_farba = a[riadok][stlpec]; | ||
+ | a[riadok][stlpec] = farba; | ||
+ | if (riadok > 0 && a[riadok - 1][stlpec] == stara_farba) { | ||
+ | vyfarbi(a, n, m, riadok - 1, stlpec, farba); | ||
+ | } | ||
+ | if (riadok + 1 < n && a[riadok + 1][stlpec] == stara_farba) { | ||
+ | vyfarbi(a, n, m, riadok + 1, stlpec, farba); | ||
+ | } | ||
+ | if (stlpec > 0 && a[riadok][stlpec - 1] == stara_farba) { | ||
+ | vyfarbi(a, n, m, riadok, stlpec - 1, farba); | ||
+ | } | ||
+ | if (stlpec + 1 < m && a[riadok][stlpec + 1] == stara_farba) { | ||
+ | vyfarbi(a, n, m, riadok, stlpec + 1, farba); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | |||
+ | int main(void) { | ||
+ | /* nacitaj rozmery matice */ | ||
+ | int n, m; | ||
+ | FILE *f; | ||
+ | f=fopen("vstup.txt","r"); | ||
+ | if (!f) return -1; | ||
+ | |||
+ | fscanf(f,"%d %d ",&n,&m); | ||
+ | |||
+ | /* vytvor a nacitaj maticu */ | ||
+ | int **a = vytvorMaticu(n, m); | ||
+ | nacitajMaticu(f, n, m, a); | ||
+ | |||
+ | fclose(f); | ||
+ | |||
+ | for(int i=0; i<n; i++) { | ||
+ | for(int j=0; j<m; j++) { | ||
+ | if(a[i][j]>0) a[i][j] = 1; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | |||
+ | SimpleDraw window(m*stvorcek, n * stvorcek); | ||
+ | zobrazMaticu(a, n, m, window); | ||
+ | |||
+ | int ostrovov = 0; | ||
+ | for(int i=0; i<n; i++) { | ||
+ | for(int j=0; j<m; j++) { | ||
+ | if(a[i][j]==1) { | ||
+ | ostrovov++; | ||
+ | vyfarbi(a, n, m, i, j, 2); | ||
+ | window.clear(); | ||
+ | zobrazMaticu(a, n, m, window); | ||
+ | window.show(); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | printf("Pocet ostrovov: %d\n",ostrovov); | ||
+ | |||
+ | window.showAndClose(); | ||
+ | zmazMaticu(n, m, a); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | |||
+ | |||
+ | ==Program Sudoku== | ||
+ | <pre> | ||
+ | #include <cstdio> | ||
+ | using namespace std; | ||
+ | |||
+ | /* kazde policko patri do 3 skupin: riadok, stlpec a stvorec */ | ||
+ | const int SKUPIN = 3; | ||
+ | |||
+ | /* udaje o jednom policku plochy: suradnice, | ||
+ | * hodnota (0 ak prazdne, alebo 1..9, | ||
+ | * a zoznam skupin, do ktorych patri. */ | ||
+ | struct policko { | ||
+ | int riadok, stlpec; | ||
+ | int hodnota; | ||
+ | int skupiny[SKUPIN]; | ||
+ | }; | ||
+ | |||
+ | struct sudoku { | ||
+ | policko *plocha; /* pole vsetkych policok plochy */ | ||
+ | bool **obsadene; /* pre kazdy skupiny ci je dana cifra uz pouzita */ | ||
+ | int pocetPolicok; /* clekovy pocet policok (9*9) */ | ||
+ | int pocetSkupin; /* clekovy pocet skupin (3*9) */ | ||
+ | int rieseni; /* pocet najdenych rieseni */ | ||
+ | }; | ||
+ | |||
+ | void vypis(FILE *f, sudoku &s) { | ||
+ | /* vypis riesenie sudoku a zvys pocitadlo rieseni */ | ||
+ | s.rieseni++; | ||
+ | int pozicia = 0; | ||
+ | for (int i = 0; i < 9; i++) { | ||
+ | for (int j = 0; j < 9; j++) { | ||
+ | fprintf(f," %d",s.plocha[pozicia].hodnota); | ||
+ | pozicia++; | ||
+ | } | ||
+ | fprintf(f,"\n"); | ||
+ | } | ||
+ | fprintf(f,"\n"); | ||
+ | } | ||
+ | |||
+ | int najdiVolne(sudoku &s) { | ||
+ | /* najdi volne policko na ploche */ | ||
+ | for (int i = 0; i < s.pocetPolicok; i++) { | ||
+ | if (s.plocha[i].hodnota == 0) return i; | ||
+ | } | ||
+ | return -1; | ||
+ | } | ||
+ | |||
+ | bool moze(sudoku &s, int pozicia, int hodnota) { | ||
+ | /* Mozeme ulozit danu hodnotu na policko s poradovym cislom pozicia? | ||
+ | * Da sa to, ak ziadna so skupin tohto policka nema | ||
+ | * tuto hodnotu uz pouzitu. */ | ||
+ | for (int i = 0; i < SKUPIN; i++) { | ||
+ | /* cislo i-tej skupiny pre policko */ | ||
+ | int skupina = s.plocha[pozicia].skupiny[i]; | ||
+ | /* ak je uz hodnota obsadena, neda sa pouzit */ | ||
+ | if (s.obsadene[skupina][hodnota]) return false; | ||
+ | } | ||
+ | /* vo vsetkych skupinach je hdonota neobsadena */ | ||
+ | return true; | ||
+ | } | ||
+ | |||
+ | void uloz(sudoku &s, int pozicia, int hodnota) { | ||
+ | /* na policko s poradovym cislom pozicia uloz danu | ||
+ | * hodnotu. Ak je hodnota > 0, zaregistruj ju | ||
+ | * tiez ako obsadenu vo vsetkych skupinach, | ||
+ | * kam policko patri. */ | ||
+ | s.plocha[pozicia].hodnota = hodnota; | ||
+ | if (hodnota > 0) { | ||
+ | for (int i = 0; i < SKUPIN; i++) { | ||
+ | int skupina = s.plocha[pozicia].skupiny[i]; | ||
+ | s.obsadene[skupina][hodnota] = true; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void zmaz(sudoku &s, int pozicia) { | ||
+ | /* hodnotu v policku s pozicia zmen na nulu | ||
+ | * a povodnu hodnotu odznac v poliach obsadene pre vsetky | ||
+ | * skupiny tohto policka */ | ||
+ | int hodnota = s.plocha[pozicia].hodnota; | ||
+ | s.plocha[pozicia].hodnota = 0; | ||
+ | for (int i = 0; i < SKUPIN; i++) { | ||
+ | int skupina = s.plocha[pozicia].skupiny[i]; | ||
+ | s.obsadene[skupina][hodnota] = false; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void generuj(FILE *f,sudoku &s) { | ||
+ | /* mame ciastocne vyplnenu plochu sudoku, | ||
+ | * chceme najst vsetky moznosti, ako ho dovyplnat. */ | ||
+ | int i = najdiVolne(s); | ||
+ | if (i < 0) { | ||
+ | vypis(f,s); | ||
+ | } else { | ||
+ | for (int x = 1; x <= 9; x++) { | ||
+ | if (moze(s, i, x)) { | ||
+ | uloz(s, i, x); | ||
+ | generuj(f,s); | ||
+ | zmaz(s, i); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void inicializuj(sudoku &s, int **a) { | ||
+ | /* inicializuj strukturu sudoku na zaklade | ||
+ | * vstupnej matice s cislami 0..9*/ | ||
+ | s.pocetPolicok = 9 * 9; | ||
+ | s.pocetSkupin = 3 * 9; | ||
+ | /* alokujeme polia a oznacime cifry ako neobsadene */ | ||
+ | s.plocha = new policko[s.pocetPolicok]; | ||
+ | s.obsadene = new bool*[s.pocetSkupin]; | ||
+ | for (int i = 0; i < s.pocetSkupin; i++) { | ||
+ | s.obsadene[i] = new bool[10]; | ||
+ | for (int j = 1; j <= 9; j++) { | ||
+ | s.obsadene[i][j] = false; | ||
+ | } | ||
+ | } | ||
+ | /* pre kazde policko naplnime jeho strukturu | ||
+ | * a vyplnime obsadene cifry */ | ||
+ | int pozicia = 0; | ||
+ | for (int i = 0; i < 9; i++) { | ||
+ | for (int j = 0; j < 9; j++) { | ||
+ | s.plocha[pozicia].riadok = i; | ||
+ | s.plocha[pozicia].stlpec = j; | ||
+ | s.plocha[pozicia].skupiny[0] = i; | ||
+ | s.plocha[pozicia].skupiny[1] = 9 + j; | ||
+ | s.plocha[pozicia].skupiny[2] = (i / 3)*3 + (j / 3) + 18; | ||
+ | uloz(s, pozicia, a[i][j]); | ||
+ | pozicia++; | ||
+ | } | ||
+ | } | ||
+ | /* este sme nenasli ziadne riesenie */ | ||
+ | s.rieseni = 0; | ||
+ | } | ||
+ | |||
+ | void uvolni(sudoku &s) { | ||
+ | /* alokujeme polia a oznacime cifry ako neobsadene */ | ||
+ | for (int i = 0; i < s.pocetSkupin; i++) { | ||
+ | delete[] s.obsadene[i]; | ||
+ | } | ||
+ | delete[] s.obsadene; | ||
+ | |||
+ | delete[] s.plocha; | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | /* alokujeme a nacitame 2D maticu so vstupom */ | ||
+ | int **a = new int *[9]; | ||
+ | for (int i = 0; i < 9; i++) { | ||
+ | a[i] = new int[9]; | ||
+ | } | ||
+ | |||
+ | FILE *f; | ||
+ | f=fopen("vstup.txt","r"); | ||
+ | if (!f) return -1; | ||
+ | |||
+ | for (int i = 0; i < 9; i++) { | ||
+ | for (int j = 0; j < 9; j++) { | ||
+ | fscanf(f,"%d ",&a[i][j]); | ||
+ | } | ||
+ | } | ||
+ | fclose(f); | ||
+ | |||
+ | /* vytvorime struktury pre sudoku */ | ||
+ | sudoku s; | ||
+ | inicializuj(s, a); | ||
+ | |||
+ | f=fopen("vystup.txt","w"); | ||
+ | if (!f) return -1; | ||
+ | |||
+ | /* rekurzivne prehladavanie s navratom */ | ||
+ | generuj(f,s); | ||
+ | |||
+ | fclose(f); | ||
+ | /* vypis riesenia */ | ||
+ | printf("Pocet rieseni: %d\n",s.rieseni); | ||
+ | |||
+ | /* este by sme mali odalokovat polia v sudoku */ | ||
+ | for (int i = 0; i < 9; i++) { | ||
+ | delete[] a[i]; | ||
+ | } | ||
+ | delete[] a; | ||
+ | uvolni(s); | ||
+ | |||
+ | } | ||
+ | </pre> | ||
+ | =Prednáška 20= | ||
+ | ==Aritmetické výrazy== | ||
+ | |||
+ | '''Infixový zápis''' (infixová forma alebo notácia) aritmetického výrazu | ||
+ | * bežný zápis používaný v matematike | ||
+ | * každý binárny operátor medzi dvoma operandami, s ktorými sa bude vykonávať príslušná operácia | ||
+ | * poradie, v akom sa jednotlivé operácie vykonávajú, sa riadi umiestnením zátvoriek a prioritou operácií | ||
+ | |||
+ | Napríklad: (65 – 3*5)/(2 + 3) | ||
+ | |||
+ | Vyhodnocovanie výrazov v infixovej notácii sme ukázali na [[#Prednáška_9|prednáške 9]]. | ||
+ | * Pre jednoduchosť: úplne uzátvorkovaný výraz, znamienka + a -, čísla, bez medzier, napr. (((12-5)+7)-(6+8)) | ||
+ | Pripomeňme si kostru programu: | ||
+ | <pre> | ||
+ | int vyhodnotVyraz(char str[]){ | ||
+ | if (str[0] != '(') return vyhodnotCislo(str); | ||
+ | else { | ||
+ | char s[100]; | ||
+ | int poz, hodnota1, hodnota2; | ||
+ | |||
+ | poz = najdiZnamienko(str); | ||
+ | |||
+ | strCopy(str, s, 1, poz-1); // kopíruj od 1 po pozíciu pred znamienkom (pozícia 0 je '(' ) | ||
+ | hodnota1 = vyhodnotVyraz(s); | ||
+ | strCopy(str, s, poz+1, strlen(str)-2); // od pozície po znamienku po predposledný znak stringu (posledný znak - strlen()-1 je ')' ) | ||
+ | hodnota2 = vyhodnotVyraz(s); | ||
+ | |||
+ | switch (str[poz]){ | ||
+ | case '+': return hodnota1+hodnota2; | ||
+ | case '-': return hodnota1-hodnota2; | ||
+ | } | ||
+ | |||
+ | return 0; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | |||
+ | <pre> | ||
+ | int najdiZnamienko(char str[]){ | ||
+ | /*Vieme, ze vyraz je tvaru (Vyraz1 Z Vyraz2)*/ | ||
+ | int poc=0; | ||
+ | for (int i=1; i<strlen(str)-1; i++){ | ||
+ | if (str[i]=='(') poc++; | ||
+ | else if (str[i]==')') poc--; | ||
+ | else if (((str[i]=='+')||(str[i]=='-'))&&(poc==0)) return i; | ||
+ | } | ||
+ | return -1; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | V prípade, že by sme chceli výraz vyhodnocovať bez úplného uzátvorkovania, zmenila by sa hlavne funkcia, ktorá hľadá operand, ktorý potrebujeme vykonať. | ||
+ | |||
+ | === Postfixová a prefixovová notácia === | ||
+ | |||
+ | Okrem infixovej notácie se môžeme stretnúť s ďalšími formami zápisu aritmetických výrazov. | ||
+ | |||
+ | '''Postfixová notácia''' (obrátená poľská notácia) má v zápise výrazu operátor až po oboch operandoch. | ||
+ | |||
+ | Výraz <tt>(65 – 3*5)/(2 + 3)</tt> by teda v postfixovej forme mal notáciu <tt>65 3 5 * - 2 3 + /</tt> | ||
+ | |||
+ | V '''prefixovej notácii''' je situácia opačná ako pri postfixovej notácii. Každý operátor stojí pred dvoma operandami, ku ktorým prislúcha. | ||
+ | |||
+ | Výraz <tt>(65 – 3*5)/(2 + 3)</tt> by v prefixovej forme bol <tt>/ - 65 * 3 5 + 2 3</tt> | ||
+ | |||
+ | Postfixová a prefixová notácia sú na prvý pohľad pre človeka neprehľadné, ale ako uvidíme, dajú sa oveľa jednoduchšie vyhodnocovať. Okrem toho vidíme ešte jednu výhodu - nepotrebujú zátvorky. | ||
+ | |||
+ | === Vyhodnocovanie postfixovej formy === | ||
+ | |||
+ | Na vyhodnocovanie výrazov v postfixovej forme budeme používať zásobník. Budeme do neho vkladať operandy - teda hodnoty podvýrazov. | ||
+ | * Využijeme vlastnosť, že operátor má oba operandy pred sebou. Teda vo chvíli, keď narazíme na operátor, jeho operandy už máme niekde prečítané. | ||
+ | * Navyše sú to posledné dve prečítané alebo vypočítané hodnoty. | ||
+ | |||
+ | Pri vyhodnocovaní výrazu prechádzame výraz zľava doprava | ||
+ | * Keď narazíme na operand, uložíme ho do zásobníku. | ||
+ | * Keď narazíme na operátor, tak vyberieme dva operandy zo zásobníku. | ||
+ | ** Ale pozor! Keďže máme zásobník (LIFO), musíme prehodiť poradie operandov oproti tomu, ako sme ich vybrali zo zásobníku | ||
+ | ** Napríklad delenie <tt>a/b</tt> je v postfixovej notácii <tt>a b /</tt>, teda zo zásobníku najskôr vyberieme deliteľa (b) a ako druhého vyberieme delenca (a), a preto pri vykonávaní operácie musíme prehodiť ich poradie. | ||
+ | * Vykonáme operáciu s vybranými operandami a výsledok tejto operácie umiestnime späť do zásobníku. | ||
+ | Tento postup opakujeme, kým nedojdeme na koniec výrazu. V tom okamžiku by sme mali mať na zásobníku jeden prvok a to je výsledok výrazu. | ||
+ | |||
+ | <pre> | ||
+ | int main(void) { | ||
+ | stack s; // vytvor prazdny zasobnik | ||
+ | init(s); | ||
+ | char postfix[maxN]; // nacitaj vyraz do retazca | ||
+ | fgets(postfix, maxN, stdin); | ||
+ | |||
+ | int i = 0; | ||
+ | while (postfix[i] != '\0') { | ||
+ | if (isspace(postfix[i])) { // preskakuj biele znaky | ||
+ | i++; | ||
+ | } else if (isdigit(postfix[i]) || postfix[i]=='.') { // spracuj jedno cislo zo vstupu | ||
+ | push(s, evaluateNumber(postfix, i)); | ||
+ | } else { // binarny operator | ||
+ | double elem1 = pop(s); | ||
+ | double elem2 = pop(s); | ||
+ | switch (postfix[i]) { | ||
+ | case '+': push(s, elem2 + elem1); | ||
+ | break; | ||
+ | case '-': push(s, elem2 - elem1); | ||
+ | break; | ||
+ | case '*': push(s, elem2 * elem1); | ||
+ | break; | ||
+ | case '/': push(s, elem2 / elem1); | ||
+ | break; | ||
+ | } | ||
+ | i++; | ||
+ | } | ||
+ | } | ||
+ | printf("%f\n", pop(s)); // na zasobniku mame vysledok | ||
+ | assert(isEmpty(s)); // teraz uz je zasobnik prazdny | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Funkcia evaluateNumber môže vyzerať napríklad takto: | ||
+ | <pre> | ||
+ | double evaluateNumber(char str[], int &i) { | ||
+ | /* Z retazca od pozicie i precitaj cislo az po prvy | ||
+ | * iny znak (medzera, koniec retazca, operator). | ||
+ | * Cislo i sa nastavi na prvu poziciu, ktora sa neda precitat. */ | ||
+ | double val = 0; | ||
+ | while (isdigit(str[i])) { | ||
+ | val = val * 10 + (str[i] - '0'); | ||
+ | i++; | ||
+ | } | ||
+ | /* desatinna cast */ | ||
+ | if (str[i] == '.') { | ||
+ | i++; | ||
+ | double power = 0.1; | ||
+ | while (isdigit(str[i])) { | ||
+ | val += (str[i] - '0') * power; | ||
+ | power /= 10; | ||
+ | i++; | ||
+ | } | ||
+ | } | ||
+ | return val; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Konverzia infixovej formy na postfixovú === | ||
+ | |||
+ | Vidíme, že vyhodnocovanie postfixového výrazu je jednoduché. Väčšinou však pracujeme s infixovou formou zápisu a preto ju potrebujeme nejakým spôsobom prepísať do postfixovej. | ||
+ | |||
+ | Pre jednoduchosť si najskôr ukážeme iba výrazy bez zátvoriek (* a - majú vyššiu prioritu ako + a -). Použijeme zásobník, do ktorého si budeme ukladať zatiaľ nevypísané časti infixovej formuly (teda operátory, ktoré ešte nemajú oba operandy). | ||
+ | |||
+ | Pri vyhodnocovaní prechádzame výrazom zľava doprava: | ||
+ | * Ak objavíme operand, prepíšeme ho do postfixového reťazca a ďalej nás už nezaujíma. | ||
+ | * Ak narazíme na operátor, pozrieme sa na vrch zásobníka: | ||
+ | ** Kým operátor zo zásobníka má väčšiu alebo rovnakú prioritu, tak vyberáme zo zásobníka (a vybrané operátory prepíšeme do postfixového reťazca). Vypisujeme až dokiaľ nenarazíme na operátor s nižšou prioritou (alebo dno). | ||
+ | * Po tomto kroku umiestnime aktuálny operátor do zásobníka. | ||
+ | * Tento postup opakujeme pokiaľ nenarazíme na koniec výrazu. | ||
+ | ** Potom vyberieme operátory zo zásobníka a umiestnime ich na výstup. | ||
+ | |||
+ | Pridanie zátvoriek: | ||
+ | * Ľavú zátvorku iba ju vložíme do zásobníka | ||
+ | * Keď narazíme na pravú zátvorku, znamená to, že všetky operátory, ktoré boli v zátvorke, by mali byť už vypísané na výstup. Preto ich vypisujeme, až kým nenarazíme na ľavú zátvorku. | ||
+ | |||
+ | <pre> | ||
+ | int precedence(char op) { | ||
+ | if (op == '#' || op == '(') return 0; // specialne pripady, ktore bezne nevyhadzujeme | ||
+ | if (op == '-' || op == '+') return 1; | ||
+ | if (op == '*' || op == '/') return 2; | ||
+ | assert(false); // sem by sme sa nemali dostat | ||
+ | } | ||
+ | |||
+ | int main(void) { | ||
+ | char infix[maxN], postfix[maxN]; | ||
+ | fgets(infix, 100, stdin); // nacita aritmeticky vyraz v infixovej forme | ||
+ | |||
+ | stack s; // vytvor prazdny zasobnik | ||
+ | init(s); | ||
+ | push(s, '#'); // specialne dno zasobnika | ||
+ | |||
+ | int j = 0; /* index do vystupneho retazca */ | ||
+ | for (int i = 0; infix[i] != 0; i++) { | ||
+ | if (isdigit(infix[i]) || infix[i]=='.') { /* cisla skopirujeme na vystup */ | ||
+ | postfix[j++] = infix[i]; | ||
+ | } | ||
+ | else if (isspace(infix[i])) { /* biele znaky preskakujeme */ | ||
+ | } else if (infix[i] == '(') { /* zaciatok zatvorky dame na zasobnik */ | ||
+ | push(s, infix[i]); | ||
+ | } else if (infix[i] == ')') { | ||
+ | /* koniec zatvorky znamena, ze vypiseme vsetky operatory, | ||
+ | * co boli v tej zatvorke (a este nie su vypisane)*/ | ||
+ | char popped = pop(s); | ||
+ | postfix[j++] = ' '; | ||
+ | while (popped != '(') { | ||
+ | postfix[j++] = popped; | ||
+ | postfix[j++] = ' '; | ||
+ | popped = pop(s); | ||
+ | } | ||
+ | } | ||
+ | else { /* spracovanie operatora */ | ||
+ | postfix[j++] = ' '; // pridame medzeru | ||
+ | int p = precedence(infix[i]); // dolezitost prichadzajuceho operatora | ||
+ | while (precedence(peek(s)) >= p) { | ||
+ | postfix[j++] = pop(s); | ||
+ | postfix[j++] = ' '; | ||
+ | } | ||
+ | push(s, infix[i]); | ||
+ | } | ||
+ | } | ||
+ | |||
+ | /* vsetko, co na zasobniku ostalo, vypiseme */ | ||
+ | char popped = pop(s); | ||
+ | postfix[j++] = ' '; | ||
+ | while (popped != '#') { | ||
+ | postfix[j++] = popped; | ||
+ | postfix[j++] = ' '; | ||
+ | popped = pop(s); | ||
+ | } | ||
+ | |||
+ | postfix[j] = '\0'; | ||
+ | printf("Postfix: %s\n", postfix); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Program na niekoľkých miestach pridáva medzery (občas zbytočné), aby sa nám operandy nezliali do jedného čísla a vedeli sme ich následne vyhodnocovať. | ||
+ | * Nefunguje pre unárne mínus (napr. 2*-3), ktoré treba detekovať a kopírovať na výstup spolu s číslom (a správne spracovávať aj v postfixovej notácii) | ||
+ | |||
+ | Cvičenia: | ||
+ | * Ako by ste rozšírili o operáciu umocnenia ^ s ešte vyššou prioritou ako *? | ||
+ | * Niektoré časti programu (cykly while) sa trochu opakujú, ako by sa to dalo vyriešiť pomocnou funkciou? | ||
+ | * Ako by sme program upravili, aby nikde nedal dve medzery za sebou? | ||
+ | |||
+ | ===Zhrnutie=== | ||
+ | Aritmetické výrazy | ||
+ | * Bežná infixová notácia, napr. (65 – 3*5)/(2 + 3) | ||
+ | * Úplne uzátvorkovaná, napr. ((65 – (3*5))/(2 + 3)) | ||
+ | * Postfixová notácia 65 3 5 * - 2 3 + / | ||
+ | * Prefixová notácia / - 65 * 3 5 + 2 3 | ||
+ | * Prefixová a postfixová notácia nepotrebujú zátvorky | ||
+ | * Prevod z infixovej notácie na postfixovú pomocou zásobníka | ||
+ | ** Čo si ukladáme do zásobníka? | ||
+ | * Vyhodnocovanie postfixovej notácie pomocou zásobníka | ||
+ | ** Čo si ukladáme do zásobníka? | ||
+ | |||
+ | ==Aritmetický výraz ako strom== | ||
+ | |||
+ | Ďalšia téma: | ||
+ | * uloženie aritmetického výrazu vo forme stromu a práca so stromami všeobecne | ||
+ | |||
+ | Budúci týždeň: | ||
+ | * ďalšie príklady stromov v informatike | ||
+ | |||
+ | [[Image:PROG-P21-aritm.png|thumb|right|Strom pre výraz (65 – 3*5)/(2 + 3)]] | ||
+ | Reprezentácia aritmetického výrazu vo forme stromu | ||
+ | * Každý operátor a každé číslo tvorí vrchol stromu | ||
+ | * Vrchol pre operátor má pod sebou zavesené menšie stromy pre podvýrazy, ktoré spája | ||
+ | * Informatici stromy väčšinou kreslia hore nohami, s koreňom na vrchu | ||
+ | ** V našom príklade je koreň vrchol s operátorom / | ||
+ | |||
+ | ===Dátová štruktúra pre vrcholy stromu=== | ||
+ | |||
+ | <pre> | ||
+ | struct node { | ||
+ | /* vrchol stromu */ | ||
+ | double val; /* ciselna hodnota */ | ||
+ | char op; /* operator '+', '-', *', '/', alebo ' ' ak ide o hodnotu */ | ||
+ | node * left; /* lavy podvyraz */ | ||
+ | node * right; /* pravy podvyraz */ | ||
+ | }; | ||
+ | </pre> | ||
+ | |||
+ | Ak máme vrchol pre operátor: | ||
+ | * left a right sú smerníky na ľavý a pravý podvýraz | ||
+ | * znak op je znamienko operátora, napr. '+' | ||
+ | * hodnota val je nevyužitá | ||
+ | |||
+ | Ak máme vrchol pre číslo vo výraze: | ||
+ | * left a right majú hodnotu NULL (žiadne podvýrazy) | ||
+ | * znak op má hodnotu medzera ' ' | ||
+ | * val obsahuje hodnotu čísla | ||
+ | |||
+ | Jednoduchá ale nie veľmi elegantná reprezentácia | ||
+ | * niektoré položky sú nevyužité (val v operátoroch, left a right pri číslach) | ||
+ | * budúci semester uvidíme krajšie riešenie pomocou objektov | ||
+ | |||
+ | ===Vytváranie vrcholov stromu=== | ||
+ | |||
+ | Nasledujúce dve funkcie vytvoria nový vrchol. | ||
+ | * Pre vrchol typu operátor už funkcia dostane smerníky na vrcholy pre podvýrazy | ||
+ | |||
+ | <pre> | ||
+ | node * createOp(char op, node *left, node *right) { | ||
+ | /* vytvori novy vrchol stromu s operatorom op | ||
+ | * a do jeho laveho a praveho podvyrazu ulozi | ||
+ | * smerniky left a right. */ | ||
+ | node *v = new node; | ||
+ | v->left = left; | ||
+ | v->right = right; | ||
+ | v->op = op; | ||
+ | return v; | ||
+ | } | ||
+ | |||
+ | node * createNum(double val) { | ||
+ | /* Vytvori novy vrchol stromu s danou hodnotou, | ||
+ | * lavy a pravy podvyraz bude prazdny, op bude medzera */ | ||
+ | node *v = new node; | ||
+ | v->left = NULL; | ||
+ | v->right = NULL; | ||
+ | v->op = ' '; | ||
+ | v->val = val; | ||
+ | return v; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Vytvorme teraz ručne strom pre náš výraz (65 – 3*5)/(2 + 3): | ||
+ | <pre> | ||
+ | node *v = createOp('/', | ||
+ | createOp('-', createNum(65), | ||
+ | createOp('*', createNum(3), createNum(5))), | ||
+ | createOp('+', createNum(2), createNum(3))); | ||
+ | </pre> | ||
+ | Alebo to môžeme rozpísať po krokoch: | ||
+ | <pre> | ||
+ | node *v65 = createNum(65); | ||
+ | node *v3 = createNum(3); | ||
+ | node *v5 = createNum(5); | ||
+ | node *v2 = createNum(2); | ||
+ | node *v3b = createNum(3); | ||
+ | node *vKrat = createOp('*', v3, v5); | ||
+ | node *vMinus = createOp('-', v65, vKrat); | ||
+ | node *vPlus = createOp('+', v2, v3b); | ||
+ | node *vDeleno = createOp('/', vMinus, vPlus); | ||
+ | </pre> | ||
+ | |||
+ | ===Vyhodnocovanie výrazu=== | ||
+ | <pre> | ||
+ | double evaluate(node *v) { | ||
+ | /* vyhodnoti vyraz dany stromom s korenom vo vrchole v */ | ||
+ | assert(v != NULL); | ||
+ | |||
+ | /* ak je operator medzera, vratime jednoducho hodnotu */ | ||
+ | if (v->op == ' ') { | ||
+ | return v->val; | ||
+ | } | ||
+ | |||
+ | /* rekurzivne vyhodnotime lavy a pravy podvyraz */ | ||
+ | double valLeft = evaluate(v->left); | ||
+ | double valRight = evaluate(v->right); | ||
+ | |||
+ | /* Hodnotu laveho a praveho podvyrazu spojime podla typu operatora | ||
+ | * a vratime. Prikaz break netreba, pouzivame return. */ | ||
+ | switch (v->op) { | ||
+ | case '+': return valLeft + valRight; | ||
+ | case '-': return valLeft - valRight; | ||
+ | case '*': return valLeft * valRight; | ||
+ | case '/': return valLeft / valRight; | ||
+ | default: assert(false); | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Zhrnutie=== | ||
+ | * Aritmetický výraz vieme reprezentovať aj ako strom. | ||
+ | * Rekurzívnou funkciou môžeme potom ľahko spočítať jeho hodnotu. | ||
+ | * Nabudúce si ukážeme, ako prerobiť postfixovú formu na strom (a tým pádom vieme prerobiť aj infixovú, lebo tú vieme prerobiť na postfixovú). | ||
+ | * Ukážeme si tiež, ako výraz reprezentovaný stromom vypísať vo všetkých troch formách. | ||
+ | |||
+ | ==Terminológia stromov== | ||
+ | * ''Strom'' má ''vrcholy'' (nodes, vertices) a tie sú pospájané ''hranami'' (edges) | ||
+ | * Nás zaujímajú ''zakorenené'' stromy, ktoré majú jeden vrchol zvolený ako ''koreň'' (root) | ||
+ | * Každý iný vrchol okrem koreňa je spojený hranou s jedným ''otcom'' (parent) a s niekoľkými (nula alebo viac) ''synmi'' (children) | ||
+ | * ''Listy'' sú vrcholy, ktoré nemajú deti, ostatné vrcholy voláme ''vnútorné'' | ||
+ | * V ''binárnom'' strome má každý vrchol najviac dve deti | ||
+ | * ''Predkovia'' vrchola sú všetky vrcholy na ceste od neho smerom ku koreňu, teda on sám, jeho otec, otec jeho otca atď, až kým nenarazíme na koreň | ||
+ | * Ak x predkom y, tak y je ''potomkom'' x | ||
+ | * ''Podstrom'' s koreňom vo vrchole x tvorí vrchol x a všetci jeho potomkovia | ||
+ | * Strom je teda buď prázdny, alebo je tvorený koreňom a dvoma podstromami: ľavým a pravým. | ||
+ | |||
+ | Náš aritmetický strom | ||
+ | * Je binárny | ||
+ | * V listoch sú čísla, vo vnútorných vrcholoch operácie | ||
+ | * Každý vnútorný vrchol má dve deti | ||
+ | =Cvičenia 10= | ||
+ | ==Spájané zoznamy== | ||
+ | * Napíšte funkciu vyhod(linkedList &z), ktorá z jednosmerného spájaného zoznamu vyhodí všetky záznamy, v ktorých má položka data nulovú hodnotu. Pozor, takéto záznamy sa môžu vyskytovať aj na začiatku zoznamu. Vyhodené položky zoznamu treba odalokovať. V [[#Prednáška_16|prednáške 16]] nájdete funkcie na vytvorenie a vypísanie zoznamu, ktoré môžete použiť na testovanie vašej funkcie. | ||
+ | |||
+ | * Napíšte funkciu kopiruj(linkedList &kam, linkedList &odkial), ktorá vytvorí kópiu zoznamu odkial a uloží ju do zoznamu kam. | ||
+ | |||
+ | ==Slovník== | ||
+ | |||
+ | * V knižnici má každý čitateľ pridelené identifikačné číslo, ktoré je možné uložiť do premenej typu int. V jednom súbore má knižnica uvedený zoznam ID čitateľov, ktorým treba poslať upomienku (je to súbor, v ktorom sú len celé čísla oddelené bielymi znakmi). V druhom súbore má knižnica emailové adresy všetkých čitateľov, pričom na každom riadku je najskôr ID čitateľa, potom medzera a potom emailová adresa (ktorá neobsahuje biele znaky) a za ňou koniec riadku. Môžete predpokladať, že dĺžka emailovej adresy je najviac 100 a počet čitateľov je najviac 1000. S využitím slovníka napíšte program, ktorý vypíše adresy čitateľov, ktorým treba poslať upomienku. | ||
+ | ** jedna možnosť je do slovníka načítať zoznam čitateľov s upomienkou (kľúč bude ID) a potom čítate adresy jednu po druhej a pre každú zistíte, či ju máte vypísať alebo nie | ||
+ | ** druhá možnosť je do slovníka uložiť všetky adresy (kľúč opäť ID) a potom čítať zoznam upomienok a pri každej zo slovníka získať adresu. | ||
+ | ** Pri ladení programu použite niektorú implementáciu slovníka z [[#Prednáška_17|prednášky 17]] | ||
+ | Príklad. Adresy: | ||
+ | <pre> | ||
+ | 123 janko.hrasko@email.com | ||
+ | 17 ferko.mrkvicka@inymail.sk | ||
+ | 26 baba.jaga@chalupka.na.stracej.nozke.eu | ||
+ | </pre> | ||
+ | Upomienky: | ||
+ | <pre> | ||
+ | 26 | ||
+ | 123 | ||
+ | </pre> | ||
+ | Výstup: | ||
+ | <pre> | ||
+ | baba.jaga@chalupka.na.stracej.nozke.eu | ||
+ | janko.hrasko@email.com | ||
+ | </pre> | ||
+ | |||
+ | ==Ešte spájané zoznamy== | ||
+ | * Napíšte funkciu zip(linkedList &z1, linkedList &z2, linkedList &z3), ktorá vyvorí z dvoch zoznamov ich "zips" - vo výslednom zozname sa budú postupne striedať prvky z prvého a druhého zoznamu. Pokiaľ má jeden zoznam viac prvkov ako ten druhý, tak jeho zvyšné prvky budú na konci zoznamu. | ||
+ | zip({1,2,3}, {10,11,12,13,14}) = {1,10,2,11,3,12,13,14} | ||
+ | |||
+ | * Napíšte funkciu reverse(linkedList &z), ktorá otočí poradie prvkov v zozname (jednosmernom spájanom). | ||
+ | |||
+ | ==Ešte slovník== | ||
+ | |||
+ | * [[#Prednáška_17#Zdrojov.C3.BD_k.C3.B3d_programu_s_Hashovacou_tabu.C4.BEkou|Implementáciu slovníka pomocou hashovania]] prerobte tak, aby si slovník pamätal, koľko celkovo obsahuje prvkov a vždy, keď počet prvkov prekročí polovicu dĺžky tabuľky, zvolí väčšiu veľkosť tabuľky, alokuje väčšie pole, pre všetky prvky spočíta ich novú hodnotu hashovacej funkcie (s novým n) a umiestni ich do príslušného políčka nového poľa. Staré pole odalokuje. Ideálne by sme ako n mali vhodné prvočísla, ale pre jednoduchosť môžete staré n jednoducho vynásobiť 2. Všimnite si, že tabuľku chceme zväčšiť už keď počet prvkov dosiahne polovicu jej veľkosti, lebo hashovanie pracuje rýchlejšie pri riedšie zaplnených tabuľkách, kde je menej kolízií. | ||
+ | =DÚ8= | ||
+ | {{MDU|8|4888}} max. 10 bodov, termín odovzdania pondelok 26.11. o 22:00 | ||
+ | |||
+ | Cieľom tejto domácej úlohy je precvičiť si prácu so spájanými zoznamami a s rekurziou. | ||
+ | |||
+ | Napíšte verziu triedenia QuickSort, ktorá bude triediť dáta v spájanom zozname. Vo vašom programe použite jednosmerný spájaný zoznam, ktorý si udržuje smerník na prvý aj posledný prvok zoznamu. V kostre uvedenej nižšie najskôr naprogramujte podporné funkcie insertLast, length, moveItem a concatenate, ktoré pracujú s takýmito zoznamami. Potom naprogramujte funkciu divide, ktorá podľa pivota rozdelí zoznam na tri podzoznamy a rekurzívnu funkciu quickSort, ktorá s pomocou divide zoznam rozdelí na menšie, tie rekurzívne utriedi a pomocou concatenate spojí. Zoznamy dĺžky 1 a 0 už netreba triediť. Presnejšie popisy jednotlivých funkcií nájdete v kostre programu, pokúste sa ich držať. | ||
+ | |||
+ | Celý program načítava od užívateľa čísla až kým užívateľ nezadá číslo -1, potom ich utriedi a vypíše výsledok. | ||
+ | |||
+ | Pokiaľ možno počas samotného triedenia nepoužívajte new a delete, zoznamy modifikujte iba menením smerníkov next v jednotlivých item-och a smerníkov first a last v zoznamoch (môžete používať lokálne premenné typu linkedList). V programe sa teda new sa použije iba pri načítavaní vo funkcii insertLast a delete sa použije na konci programu vo funkcii destroy. Doporučujeme skontrolovať programom valgrind, či váš program správne alokuje a odalokuje všetku pamäť. | ||
+ | |||
+ | <pre> | ||
+ | #include <iostream> | ||
+ | #include <cassert> | ||
+ | using namespace std; | ||
+ | |||
+ | struct item { | ||
+ | /* prvok spajaneho zoznamu so smernikom na dalsi */ | ||
+ | int data; | ||
+ | item* next; | ||
+ | }; | ||
+ | |||
+ | struct linkedList { | ||
+ | /* spajany zoznam so smernikom na prvy a posledny prvok, | ||
+ | * smerniky budu NULL ak je zoznam prazdny */ | ||
+ | item *first; | ||
+ | item *last; | ||
+ | }; | ||
+ | |||
+ | void init(linkedList &z) { | ||
+ | /* inicializuje prazdny zoznam */ | ||
+ | z.first = NULL; | ||
+ | z.last = NULL; | ||
+ | } | ||
+ | |||
+ | bool isEmpty(const linkedList &z) { | ||
+ | /* testuje, ci je zoznam prazdny */ | ||
+ | return z.first == NULL; | ||
+ | } | ||
+ | |||
+ | void print(linkedList &z) { | ||
+ | /* vypise vsetky prvky zoznamu oddelene medzerami */ | ||
+ | item* x = z.first; | ||
+ | while (x != NULL) { | ||
+ | cout << x->data << " "; | ||
+ | x = x->next; | ||
+ | } | ||
+ | cout << endl; | ||
+ | } | ||
+ | |||
+ | void destroy(linkedList &z) { | ||
+ | /* uvolni pamat vsetkych buniek zoznamu */ | ||
+ | while (z.first != NULL) { | ||
+ | item* p = z.first; | ||
+ | z.first = z.first->next; | ||
+ | delete p; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int length(linkedList &z) { | ||
+ | /* vrati dlzku zoznamu */ | ||
+ | |||
+ | // VAS KOD TU | ||
+ | } | ||
+ | |||
+ | void insertLast(linkedList &z, int d) { | ||
+ | /* Vlozi prvok na posledne miesto v zozname. | ||
+ | * Pozor na pripad, ked je zoznam prazdny */ | ||
+ | |||
+ | // VAS KOD TU | ||
+ | } | ||
+ | |||
+ | void moveItem(linkedList &from, linkedList &to) { | ||
+ | /* Dostane dva zoznamy from a to, pricom from je neprazdny. | ||
+ | * Presunie prvy prvok zo zoznamu from na zaciatok zoznamu to. */ | ||
+ | assert(!isEmpty(from)); | ||
+ | |||
+ | // VAS KOD TU | ||
+ | } | ||
+ | |||
+ | void concatenate(linkedList &z1, linkedList &z2) { | ||
+ | /* Zoznam z1 zmeni tak, ze za jeho posledny prvok pripoji zoznam z2. | ||
+ | * Zoznam z2 uz nebude dalej pouzivany, takze je jedno, | ||
+ | * kam jeho first a last ukazuje. Pozor na pripady, | ||
+ | * ked je jeden alebo druhy zoznam prazdny. */ | ||
+ | |||
+ | // VAS KOD TU | ||
+ | } | ||
+ | |||
+ | void divide(linkedList &z, linkedList &smaller, linkedList &equal, linkedList &greater) { | ||
+ | /* Dostane neprazdny zoznam z a prazdne zoznamy smaller, equal a greater. | ||
+ | * Prvy prvok zo z pouzije ako pivot a popremiestnuje prvky zo z do dalsich | ||
+ | * troch zoznamov tak, aby vsetky prvky mensie ako pivot boli v smaller, | ||
+ | * vsetky prvky rovne pivotu boli v equal a vsetky vacsie ako pivot boli v greater. | ||
+ | * Pouzite funkciu moveItem. | ||
+ | */ | ||
+ | |||
+ | assert(!isEmpty(z) && isEmpty(smaller) && isEmpty(equal) && isEmpty(greater)); | ||
+ | // VAS KOD TU | ||
+ | |||
+ | } | ||
+ | |||
+ | |||
+ | void quickSort(linkedList &z) { | ||
+ | /* utriedi zoznam z */ | ||
+ | |||
+ | // VAS KOD TU | ||
+ | } | ||
+ | |||
+ | int main() { | ||
+ | linkedList z; | ||
+ | init(z); | ||
+ | |||
+ | /* nacitaj data zo vstupu */ | ||
+ | while (1) { | ||
+ | int data; | ||
+ | cin >> data; | ||
+ | if (data == -1) break; | ||
+ | insertLast(z, data); | ||
+ | } | ||
+ | |||
+ | /* utried */ | ||
+ | quickSort(z); | ||
+ | |||
+ | /* vypis vysledok */ | ||
+ | print(z); | ||
+ | |||
+ | /* uvolni pamat */ | ||
+ | destroy(z); | ||
+ | } | ||
+ | </pre> | ||
+ | =Pokročilá DÚ4= | ||
+ | {{MDU||5002}} max. 20 bodov, termín odovzdania pondelok 10.12. o 22:00 | ||
+ | |||
+ | Cieľom tejto domácej úlohy je precvičiť si prácu so smerníkmi a binárnymi stromami. Vašou úlohou bude implementovať dátovú štruktúru podobnú binárnemu vyhľadávaciemu stromu. Oproti binárnemu vyhľadávaciemu stromu je však každý vrchol rozšírený o dva smerníky - smerník na predchodcu a smerník na nasledovníka. Binárne vyhľadávacie stromy budeme preberať na prednáškach v týždni od 26.11., predtým si môžete pozrieť [[#2011/12_Programovanie_(1)_v_C/C%2B%2B#Predn.C3.A1.C5.A1ka_22|prednášku z minulého semestra]]. | ||
+ | |||
+ | ==Dátová štruktúra== | ||
+ | |||
+ | Binárny vyhľadávací strom rozšírený o nasledovníka a predchodcu bude pracovať s kľúčmi typu integer. Bude podporovať operácie insert, delete, find, predecessor a successor. | ||
+ | |||
+ | Vrchol binárneho stromu obsahuje | ||
+ | * Kľúč - typu integer (číslo uložené v strome) | ||
+ | * Smerníky na pravého a ľavého syna (podobne ako binárny vyhľadávací strom). Zároveň (ako v binárnom vyhľadávacom strome) pre každý vrchol v stromu platí, že | ||
+ | ** Každý vrchol u v ľavom podstrome v má kľúč menší ako vrchol v | ||
+ | ** Každý vrchol u v pravom podstrome v má kľúč väčší ako vrchol v | ||
+ | * Smerníky na predchodcu a nasledovníka v strome. Predchodca vrcholu s kľúčom k je vrchol s najväčším kľúčom menším ako k. Analogicky nasledovník vrcholu s kľúčom k je vrchol s najmenším kľúčom väčším ako k (na obrázku vidíme príklad nasledovníkov v binárnom strome) | ||
+ | |||
+ | [[Image:PROG-PDU4-1.jpg]] | ||
+ | |||
+ | Dátová štruktúra podporuje nasledovné operácie | ||
+ | * Insert vrchola s kľúčom k. Vrchol sa vloží do binárneho vyhľadávacieho stromu a upraví príslušné smerníky na predchodcov a nasledovníkov. V prípade, že vrchol s daným kľúčom sa už v strome nachádza, vypíše o tom patričnú chybovú hlášku. | ||
+ | * Delete vrchola s kľúčom k. Vymaže z binárneho vyhľadávacieho stromu vrchol s kľúčom k a upraví príslušné smerníky na predchodcov a nasledovníkov. V prípade, že sa vrchol s daným kľúčom nenachádza, vypíše o tom patričnú chybovú hlášku. | ||
+ | * Find vrchola s kľúčom k. Zistí, či sa v strome nachádza vrchol s daným kľúčom. V prípade, že áno vypíše <tt>true</tt> a v prípade, že sa vrchol s hľadaným kľúčom v strome nenachádza, vypíše <tt>false</tt> a dva najbližšie menšie a dva najbližšie väčšie kľúče zo stromu. | ||
+ | * Predecessor vrchola s kľúčom k. Nájde a vypíše predchodcu vrchola s kľúčom k alebo vypíše, že vrchol predchodcu nemá. V prípade, že sa vrchol s daným kľúčom nenachádza, vypíše o tom patričnú chybovú hlášku. | ||
+ | * Successor vrchola s kľúčom k. Nájde a vypíše nasledovníka vrchola s kľúčom k alebo vypíše, že vrchol nasledovníka nemá. V prípade, že sa vrchol s daným kľúčom nenachádza, vypíše o tom patričnú chybovú hlášku. | ||
+ | |||
+ | ==Vstup a výstup na testovanie== | ||
+ | |||
+ | Na testovanie funkčnosti použijeme textový súbor (<tt>vstup.txt</tt>), ktorý bude obsahovať postupnosť operácií, ktoré na strome treba vykonať. | ||
+ | |||
+ | Vstupný súbor obsahuje na každom riadku písmenko reprezentujúce operáciu a následne jej parametre. Riadok teda obsahuje jednu z nasledovných možností: | ||
+ | * i nasledované celým číslom k. Vloží do stromu vrchol s kľúčom k. | ||
+ | * d nasledované celým číslom k. Vymaže zo stromu vrchol s kľúčom k. | ||
+ | * f nasledované celým číslom k. Vyhľadá v strome vrchol s kľúčom k a vypíše true alebo false. V prípade, že sa taký vrchol v strome nenachádza vypíše najbližšie dva menšie a najbližšie dva väčšie kľúče, ktoré v strome sú (ak tam také sú). | ||
+ | * p nasledované celým číslom k. Vypíše vrchol, ktorý je predchodcom vrchola s kľúčom k alebo informáciu, že vrchol nemá predchodcu. | ||
+ | * s nasledované celým číslom k. Vypíše vrchol, ktorý je nasledovníkom vrchola s kľúčom k alebo informáciu, že vrchol nemá nasledovníka. | ||
+ | * o vypíše v utriedenom poradí (podľa kľúča) vrcholy stromu. | ||
+ | |||
+ | Operácie postupne vykonajte začínajúc prázdnym binárnym vyhľadávacím stromom a výsledky vypisuje do súboru <tt>vystup.txt</tt>. Dodržte formát ako v príklade nižšie. | ||
+ | |||
+ | Príklad vstup.txt | ||
+ | <pre> | ||
+ | i 5 | ||
+ | i 3 | ||
+ | i 10 | ||
+ | o | ||
+ | f 5 | ||
+ | f 7 | ||
+ | d 1 | ||
+ | i 1 | ||
+ | o | ||
+ | p 1 | ||
+ | p 2 | ||
+ | p 5 | ||
+ | d 5 | ||
+ | o | ||
+ | f 11 | ||
+ | </pre> | ||
+ | |||
+ | vystup.txt | ||
+ | <pre> | ||
+ | 3 5 10 | ||
+ | true | ||
+ | false mensie:3 5 vacsie:10 | ||
+ | err: vrchol 1 v strome nie je | ||
+ | 1 3 5 10 | ||
+ | vrchol 1 nema predchodcu | ||
+ | err: vrchol 2 v strome nie je | ||
+ | 3 | ||
+ | 1 3 10 | ||
+ | false mensie:3 10 vacsie: | ||
+ | </pre> | ||
+ | =Prednáška 21= | ||
+ | ==Opakovanie== | ||
+ | Aritmetické výrazy | ||
+ | * Bežná infixová notácia, napr. (65 – 3*5)/(2 + 3) | ||
+ | * Úplne uzátvorkovaná, napr. ((65 – (3*5))/(2 + 3)) | ||
+ | * Postfixová notácia 65 3 5 * - 2 3 + / | ||
+ | * Prefixová notácia / - 65 * 3 5 + 2 3 | ||
+ | * Prefixová a postfixová notácia nepotrebujú zátvorky | ||
+ | * Prevod z infixovej notácie na postfixovú pomocou zásobníka | ||
+ | * Vyhodnocovanie postfixovej notácie pomocou zásobníka | ||
+ | |||
+ | [[Image:PROG-P21-aritm.png|thumb|right|Strom pre výraz (65 – 3*5)/(2 + 3)]] | ||
+ | Aritmetické výrazy ako stromy | ||
+ | * Každý operátor a každé číslo tvorí vrchol stromu | ||
+ | * Vrchol pre operátor má pod sebou zavesené podstromy pre podvýrazy, ktoré spája | ||
+ | |||
+ | <pre> | ||
+ | struct node { /* vrchol stromu */ | ||
+ | double val; /* ciselna hodnota */ | ||
+ | char op; /* operator '+', '-', '*', '/', | ||
+ | * alebo ' ' ak ide o hodnotu */ | ||
+ | node * left; /* lavy podvyraz alebo NULL */ | ||
+ | node * right; /* pravy podvyraz alebo NULL */ | ||
+ | }; | ||
+ | |||
+ | node * createOp(char op, node *left, node *right) { | ||
+ | /* vytvori novy vrchol stromu s operatorom op | ||
+ | * a do jeho laveho a praveho podvyrazu ulozi | ||
+ | * smerniky left a right. */ | ||
+ | node *v = new node; | ||
+ | v->left = left; | ||
+ | v->right = right; | ||
+ | v->op = op; | ||
+ | return v; | ||
+ | } | ||
+ | |||
+ | node * createNum(double val) { | ||
+ | /* Vytvori novy vrchol stromu s danou hodnotou, | ||
+ | * lavy a pravy podvyraz bude prazdny, op bude medzera */ | ||
+ | node *v = new node; | ||
+ | v->left = NULL; | ||
+ | v->right = NULL; | ||
+ | v->op = ' '; | ||
+ | v->val = val; | ||
+ | return v; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Vytvorenie stromu z postfixového výrazu== | ||
+ | Pripomeňme si kód na vyhodnocovanie postfixového výrazu: | ||
+ | <pre> | ||
+ | typedef double dataType; | ||
+ | |||
+ | double evaluatePostfix(char postfix[]) { | ||
+ | stack s; | ||
+ | init(s); | ||
+ | int i = 0; | ||
+ | while (postfix[i] != '\0') { | ||
+ | if (isspace(postfix[i])) { // preskakuj biele znaky | ||
+ | i++; | ||
+ | } else if (isdigit(postfix[i]) || postfix[i]=='.') { // spracuj jedno cislo zo vstupu | ||
+ | push(s, evaluateNumber(postfix, i)); | ||
+ | } else { // binarny operator | ||
+ | double elem1 = pop(s); | ||
+ | double elem2 = pop(s); | ||
+ | switch (postfix[i]) { | ||
+ | case '+': push(s, elem2 + elem1); | ||
+ | break; | ||
+ | case '-': push(s, elem2 - elem1); | ||
+ | break; | ||
+ | case '*': push(s, elem2 * elem1); | ||
+ | break; | ||
+ | case '/': push(s, elem2 / elem1); | ||
+ | break; | ||
+ | } | ||
+ | i++; | ||
+ | } | ||
+ | } | ||
+ | return pop(s); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Do zásobníka si ukladáme čísla - medzivýsledky už vyhodnotených podvýrazov. | ||
+ | * Pri tvorbe stromu si tam namiesto toho budeme ukladať už vytvorené podstromy. | ||
+ | |||
+ | <pre> | ||
+ | typedef node * dataType; | ||
+ | |||
+ | node *parsePostfix(char *postfix) { | ||
+ | stack s; | ||
+ | init(s); | ||
+ | |||
+ | int i = 0; | ||
+ | while (postfix[i] != '\0') { | ||
+ | if (isspace(postfix[i])) { // preskakuj biele znaky | ||
+ | i++; | ||
+ | } else if (isdigit(postfix[i]) || postfix[i]=='.') { // spracuj jedno cislo zo vstupu | ||
+ | double val = evaluateNumber(postfix, i); | ||
+ | push(s, createNum(val)); | ||
+ | } else { // binarny operator | ||
+ | node * elem1 = pop(s); | ||
+ | node * elem2 = pop(s); | ||
+ | node * v = createOp(postfix[i], elem2, elem1); | ||
+ | push(s, v); | ||
+ | i++; | ||
+ | } | ||
+ | } | ||
+ | return pop(s); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Dátová štruktúra pre binárne stromy== | ||
+ | |||
+ | Dátovú štruktúru pre vrcholy binárnych stromov môžeme zovšeobecniť a použiť v nej nejaký všeobecný typ dataType, podobne ako pri zásobníku. Spravíme si tiež všeobecnú funkciu na vytvorenie nového vrcholu, ktorá dostane smerníky na podstromy. | ||
+ | |||
+ | <pre> | ||
+ | struct node { | ||
+ | /* vrchol stromu */ | ||
+ | dataType data; | ||
+ | node * left; /* lavy podstrom */ | ||
+ | node * right; /* pravy podstrom */ | ||
+ | }; | ||
+ | |||
+ | node * createNode(dataType data, node *left, node *right) { | ||
+ | node *v = new node; | ||
+ | v->data = data; | ||
+ | v->left = left; | ||
+ | v->right = right; | ||
+ | return v; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Uvažujme strom, v ktorom každý vrchol obsahuje jeden znak. Ako bude vyzerať tento strom? | ||
+ | |||
+ | <pre> | ||
+ | node *v = createNode('A', | ||
+ | createNode('B', createNode('C', NULL, NULL), | ||
+ | createNode('D', NULL, NULL)), | ||
+ | createNode('E', NULL, createNode('F', NULL, NULL))); | ||
+ | </pre> | ||
+ | |||
+ | ===Použitie pre aritmetické výrazy=== | ||
+ | |||
+ | Ak by sme takýto všeobecný strom chceli použiť na aritmetické výrazy, definujeme si dataType ako štruktúru s dvoma položkami op a val, ktoré vo vrcholoch potrebujeme. Funkcie createOp a createNum vieme napísať pomocou createNode. | ||
+ | |||
+ | <pre> | ||
+ | struct dataType { | ||
+ | double val; /* ciselna hodnota */ | ||
+ | char op; /* operator '+', '-', *', '/', alebo ' ' ak ide o hodnotu */ | ||
+ | }; | ||
+ | |||
+ | node * createOp(char op, node *left, node *right) { | ||
+ | dataType d; | ||
+ | d.op = op; | ||
+ | return createNode(d, left, right); | ||
+ | } | ||
+ | |||
+ | node * createNum(double val) { | ||
+ | dataType d; | ||
+ | d.op = ' '; | ||
+ | d.val = val; | ||
+ | return createNode(d, NULL, NULL); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Ak teraz máme premennú ''v'' ako smerník na nejaký vrchol stromu, namiesto <tt>v->op</tt> budeme písať <tt>v->data.op</tt>. | ||
+ | |||
+ | ==Prehľadávanie stromov== | ||
+ | |||
+ | * Často potrebujeme prejsť celý strom a spracovať dáta vo všetkých vrcholoch. | ||
+ | * Napríklad chceme vypísať hodnotu v každom vrchole | ||
+ | * Opäť použijeme rekurziu, voláme na ľavý a pravý podstrom. | ||
+ | |||
+ | <pre> | ||
+ | void print(dataType &d) { | ||
+ | cout << d; | ||
+ | } | ||
+ | |||
+ | void preorder(node *v) { | ||
+ | if (v == NULL) return; | ||
+ | print(v->data); | ||
+ | preorder(v->left); | ||
+ | preorder(v->right); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Pre príklad stromu uvedeného vyššie vypíše ABCDEF | ||
+ | * Takéto poradie sa volá preorder, lebo najprv vypíšeme (spracujeme) dáta vo vrchole, až potom v jeho podstromoch. | ||
+ | * Dáta vo vrchole môžeme vypísať aj po navštívení oboch podstromov, takéto poradie nazývame postorder. | ||
+ | ** Pre náš strom CDBFEA | ||
+ | * Alebo ich môžeme vypísať medzi navštívením ľavého a pravého vrcholu, takéto poradie nazývame inorder. | ||
+ | ** Pre náš strom CBDAEF | ||
+ | |||
+ | <pre> | ||
+ | void postorder(node *v) { | ||
+ | if (v == NULL) return; | ||
+ | postorder(v->left); | ||
+ | postorder(v->right); | ||
+ | print(v->data); | ||
+ | } | ||
+ | |||
+ | void inorder(node *v) { | ||
+ | if (v == NULL) return; | ||
+ | inorder(v->left); | ||
+ | print(v->data); | ||
+ | inorder(v->right); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Vypisovanie aritmetických výrazov=== | ||
+ | * Preorder vypisovanie vypíše výraz v prefixovej notácii / - 65 * 3 5 + 2 3 | ||
+ | * Postdorder vypisovanie vypíše výraz v postfixovej notácii 65 3 5 * - 2 3 + / | ||
+ | <pre> | ||
+ | void print(dataType &d) { | ||
+ | /* funkcia na tlac jedneho vrcholu pouzita v preorder a postorder */ | ||
+ | if(d.op == ' ') { | ||
+ | cout << ' ' << d.val; | ||
+ | } | ||
+ | else { | ||
+ | cout << ' ' << d.op; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Inorder vypisovanie nevypíše výraz v infixovej notácii, chýbajú zátvorky 65 - 3 * 5 / 2 + 3 | ||
+ | ** Chceme úplne uzátvorkovaný výraz, napr. ( ( 65 - ( 3 * 5 ) ) / ( 2 + 3 ) ) | ||
+ | <pre> | ||
+ | void infix(node *v) { | ||
+ | /* funkcia na tlac vyrazu v infixovej notacii */ | ||
+ | if(v->data.op == ' ') { | ||
+ | cout << ' ' << v->data.val; | ||
+ | } | ||
+ | else { | ||
+ | cout << " ("; | ||
+ | infix(v->left); | ||
+ | cout << " " << v->data.op; | ||
+ | infix(v->right); | ||
+ | cout << " )"; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Jednoduchá práca so stromami== | ||
+ | |||
+ | ===Výška (hĺbka) stromu=== | ||
+ | * Hĺbka vrcholu v strome je jeho vzdialenosť od koreňa. T.j. koreň má hĺbku 0, jeho synovia hĺbku 1 atď. | ||
+ | * Výška stromu (niekedy nazývaná hĺbka stromu) je maximum z hĺbok jeho vrcholov | ||
+ | ** Ak máme strom s jedným vrcholom, výška je 0 | ||
+ | ** Inak spočítame výšku ľavého a pravého podstromu | ||
+ | ** Ku každej pripočítame 1, lebo pridávame hranu k otcovi | ||
+ | ** Aby to fungovalo aj pre prázdne podstromy, dodefinujeme výšku prázdneho podstromu na -1 | ||
+ | |||
+ | <pre> | ||
+ | int height(node *v) { | ||
+ | /* Vrat vysku stromu s korenom v. | ||
+ | * Ak v je NULL, vrati -1. */ | ||
+ | if (v == NULL) return -1; | ||
+ | int left = height(v->left); | ||
+ | int right = height(v->right); | ||
+ | /* vrat max(left, right)+1 */ | ||
+ | if (left >= right) return left + 1; | ||
+ | else return right + 1; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Ak máme binárny strom s n vrcholmi, aká môže byť jeho minimálna a maximálna výška? | ||
+ | * Výška stromu s n vrcholmi je najviac n-1, ak sú všetky navešané jeden pod druhý, t.j. každý okrem posledného má jedného syna | ||
+ | * Strom s výškou h má najviac <math>2^{h+1}-1</math> vrcholov | ||
+ | ** Dá sa dokázať indukciou vzhľadom na h | ||
+ | * Takže vieme, že <math>n\le 2^{h+1}-1</math>. | ||
+ | * Vyjadríme h: <math>h\ge \log_2(n+1)-1</math> | ||
+ | * Takže dostávame <math>\log_2(n+1)-1 \le h \le n-1</math> | ||
+ | |||
+ | ===Úplný binárny strom=== | ||
+ | |||
+ | * Strom, ktorý má pri určitej hĺbke h maximálny počet vrcholov, t.j. <math>2^{h+1}-1</math> sa nazýva úplny binárny strom. | ||
+ | * Chceli by sme taký strom vytvoriť. | ||
+ | |||
+ | * Použijeme funkciu createNode na vytvorenie jedného vrcholu: | ||
+ | |||
+ | <pre> | ||
+ | node * createNode(dataType data, node *left, node *right) { | ||
+ | node *v = new node; | ||
+ | v->data = data; | ||
+ | v->left = left; | ||
+ | v->right = right; | ||
+ | return v; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Rekurzívne tvoríme väčšie stromy z menších. | ||
+ | * Globálna premenná count priradí vrcholom do dátovej položky poradové číslo. | ||
+ | <pre> | ||
+ | node* createTree(int height) { | ||
+ | if (height == -1) return NULL; | ||
+ | node* u = createNode(count++, NULL, NULL); | ||
+ | u->left = createTree(height - 1); | ||
+ | u->right = createTree(height - 1); | ||
+ | return u; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Uvoľňovanie stromu === | ||
+ | |||
+ | Pri ukončení práce by sme mali pamäť, ktorú sme potrebovali na strom uvoľniť. | ||
+ | |||
+ | <pre> | ||
+ | void destroyTree(node* v){ | ||
+ | if(v!=NULL){ | ||
+ | destroyTree(v->left); | ||
+ | destroyTree(v->right); | ||
+ | delete v; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ==Cvičenia== | ||
+ | * Napíšte funkciu, ktorá každému uzlu prirobí smerník na rodiča do položky parent typu node * | ||
+ | * Vo výrazoch by sme mohli mať aj premenné, potom za ne dosadzovať hodnoty alebo celé podvýrazy | ||
+ | ** Ako by sme premenné reprezentovali v štruktúre dataType? | ||
+ | * Predstavme si, že v preorder poradí namiesto dát vypíšeme počet detí daného vrcholu. Napríklad pre náš strom so znakmi to bude 2 2 0 0 1 0 (preorder poradie je A B C D E F, vrcholy A a B majú po dve deti, vrcholy C a D majú 0 detí, vrchol E má jedno dieťa a vrchol F 0 detí). Ako z takejto postupnosti zostavíme strom? Je jednoznačne daný? Skúste si nakresliť strom pre postupnosť 2 0 2 1 2 0 0 2 0 0. | ||
+ | =Prednáška 22= | ||
+ | == Organizačné poznámky == | ||
+ | Dobeh semestra: | ||
+ | * DÚ9 do 3.12., DÚ10 do 10.12., PDÚ4 do 10.12. | ||
+ | * Cvičenia + rozcvičky (3.12. a 10.12.) | ||
+ | * Prednášky: | ||
+ | ** dnes binárne vyhľadávacie stromy | ||
+ | ** budúci pondelok lexikografické stromy | ||
+ | ** budúci utorok opakovanie, príprava na písomku a skúšku | ||
+ | ** pondelok 10.12. nepreberané črty jazykov C a C++ | ||
+ | * Na stránke tento týždeň zverejníme ukážkové príklady na písomku a skúšku | ||
+ | * Termíny písomky: 17.12. o 10:00 riadny termín, 8.1. opravný termín | ||
+ | * Termíny skúšok: 20.12., 10.1., 23.1., opravný termín 30.1., druhý opravný termín 6.2. | ||
+ | * Skontrolujte si v Moodli známky z DÚ aj rozcvičiek, problémy nám hláste čím skôr | ||
+ | ** Jednotlivé body podľa Moodla, percentá podľa pravidiel predmetu (Moodle nezobrazuje správne) | ||
+ | |||
+ | == Opakovanie: binárne stromy == | ||
+ | * V každom vrchole máme uložené nejaké dáta a smerník na ľavého a pravého syna. | ||
+ | <pre> | ||
+ | struct node { | ||
+ | /* vrchol stromu */ | ||
+ | dataType data; | ||
+ | node * left; /* lavy syn */ | ||
+ | node * right; /* pravy syn */ | ||
+ | }; | ||
+ | </pre> | ||
+ | |||
+ | * Príklad využitia: reprezentácia aritmetických výrazov | ||
+ | * Na prechádzanie všetkých vrcholov sa hodí rekurzia | ||
+ | ** videli sme preorder, inorder, postorder poradie vypisovania | ||
+ | |||
+ | <pre> | ||
+ | void inorder(node *v) { | ||
+ | if (v == NULL) return; | ||
+ | inorder(v->left); | ||
+ | print(v->data); | ||
+ | inorder(v->right); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Hľadanie prvku v strome === | ||
+ | * Chceme zistiť, či sa v strome nachádza určitá hodnota, alebo spočítať, koľkokrát sa tam nachádza. | ||
+ | * Môže byť hocikde, preto musíme prejsť rekurzívne všetky vrcholy stromu | ||
+ | |||
+ | <pre> | ||
+ | int count(node *v, dataType x) { | ||
+ | /* Vrat pocet vyskytov hodnoty x v strome s korenom v. */ | ||
+ | if (v == NULL) return 0; | ||
+ | int add = 0; | ||
+ | if (v->data == x) add = 1; | ||
+ | return count(v->left, x) + count(v->right, x) + add; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | == Binárne vyhľadávacie stromy == | ||
+ | |||
+ | [[Image:P22-BST.png|200px|right]] | ||
+ | * Binárne vyhľadávacie stromy sú usporiadané tak, aby sme vedli pomerne rýchlo vyhľadať prvok s určitou hodnotou | ||
+ | * V každom vrchole máme položku kľúč (key) | ||
+ | * Pre každý vrchol v stromu platí: | ||
+ | ** Každý vrchol u v ľavom podstrome v má kľúč menší ako vrchol v | ||
+ | ** Každý vrchol u v pravom podstrome v má kľúč väčší ako vrchol v | ||
+ | * Z toho vyplýva, že ak vypíšeme strom v inorder poradí, dostaneme prvky usporiadané | ||
+ | * Pre danú množinu kľúčov existuje veľa vyhľadávacích stromov | ||
+ | |||
+ | Cvičenie: nájdite všetky binárne vyhľadávacie stromy pre množinu kľúčov {1,2,3} | ||
+ | |||
+ | ===Definícia dátových štruktúr=== | ||
+ | * V každom vrchole kľúč typu keyType, kľúče vieme porovnávať znamienkom < (napr. int, double, ...) | ||
+ | * V každom vrchole si pamätáme aj smerník na otca (ten má hodnotu NULL v koreni) | ||
+ | * Strom je potom jednoducho smerník na koreň a inicializujeme ho na NULL. | ||
+ | <pre> | ||
+ | struct node { | ||
+ | /* vrchol binarneho vyhladavacieho stromu */ | ||
+ | keyType key; /* hodnota kluca */ | ||
+ | node * parent; /* otec vrchola */ | ||
+ | node * left; /* lavy syn */ | ||
+ | node * right; /* pravy syn */ | ||
+ | }; | ||
+ | |||
+ | struct binarySearchTree { | ||
+ | node *root; /* koren stromu, NULL pre prazdny strom */ | ||
+ | }; | ||
+ | |||
+ | void init(binarySearchTree &t) { | ||
+ | /* inicializuje prazdny binarny vyhladavaci strom */ | ||
+ | t.root = NULL; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Pre binárne vyhľadávacie stromy si ukážeme hľadanie, pridávanie a uberanie vrcholov | ||
+ | * Ktorý abstraktný dátový typ vám tieto operácie pripomínajú? | ||
+ | |||
+ | ===Hľadanie vo vyhľadávacom strome=== | ||
+ | * Porovnáme hľadaný kľúč s kľúčom v koreni | ||
+ | ** Ak sa rovnajú, končíme (našli sme, čo hľadáme) | ||
+ | ** Ak je hľadaná hodnota menšia ako kľúč v koreni, musí byť v ľavom podstrome, ak je väčšia v pravom | ||
+ | * V príslušnom podstrome sa rozhodujeme podľa tých istých pravidiel | ||
+ | * Keď narazíme na prázdny podstrom, kľúč sa v strome nenachádza | ||
+ | * Dá sa zapísať rekurzívne alebo cyklom, lebo vždy ideme iba do jedného podstromu | ||
+ | |||
+ | <pre> | ||
+ | node * findNode(node *root, keyType key) { | ||
+ | /* V binarnom vyhladavacom strom s korenom root najdi a vrat | ||
+ | * vrchol s klucom a ak neexistuje, vrat NULL. */ | ||
+ | node * v = root; | ||
+ | while (v != NULL && v->key != key) { | ||
+ | if (key < v->key) { | ||
+ | v = v->left; | ||
+ | } else { | ||
+ | v = v->right; | ||
+ | } | ||
+ | } | ||
+ | return v; | ||
+ | } | ||
+ | |||
+ | /* rekurzivna verzia */ | ||
+ | node * findNodeR(node *root, keyType key) { | ||
+ | /* V binarnom vyhladavacom strom s korenom root najdi a vrat | ||
+ | * vrchol s klucom a ak neexistuje, vrat NULL. */ | ||
+ | if (root == NULL || root->key == key) { | ||
+ | return root; | ||
+ | } else if (key < root->key) { | ||
+ | return findNodeR(root->left, key); | ||
+ | } else { | ||
+ | return findNodeR(root->right, key); | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Čas výpočtu je v najhoršom prípade úmerný výške stromu | ||
+ | |||
+ | Pre užívateľa rekuziu obalíme do pomocnej funkcie, ktorá vráti true ak sa daný kľúč v strome vyskytuje a false inak | ||
+ | <pre> | ||
+ | bool find(binarySearchTree &t, keyType key) { | ||
+ | return findNode(t.root, key) != NULL; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Vkladanie prvku do vyhľadávacieho stromu=== | ||
+ | |||
+ | * Predpokladáme, že prvok v strome nie je. | ||
+ | * Putujeme po strome podobne ako po vyhľadávaní prvku, až kým nenarazíme na nulový smerník. | ||
+ | ** Na tomto mieste by mal byť nový prvok, takže ho tam pridáme ako nový list | ||
+ | * Použijeme rozšírenú verziu findNode, ktorá vráti miesto, kam by mal prvok patriť, aj jeho otca. | ||
+ | |||
+ | <pre> | ||
+ | node * createLeaf(keyType key, node * parent) { | ||
+ | /* vytvor novy vrchol s danym kľúčom, obe deti nastav na NULL */ | ||
+ | node *v = new node; | ||
+ | v->key = key; | ||
+ | v->left = NULL; | ||
+ | v->right = NULL; | ||
+ | v->parent = parent; | ||
+ | return v; | ||
+ | } | ||
+ | |||
+ | void findNode(node *root, keyType key, node *&v, node *&parent) { | ||
+ | /* Do v uloz smernik na vrchol s klucom key alebo NULL ak neexistuje. | ||
+ | * Do parent uloz otca v, NULL ak neexistuje a ak key nie je v strome | ||
+ | * tak smernik na vrchol, ktory by mal byt otcom pre vrchol | ||
+ | * s hodnotou key. */ | ||
+ | parent = NULL; | ||
+ | v = root; | ||
+ | while (v != NULL && v->key != key) { | ||
+ | parent = v; | ||
+ | if (key < v->key) { | ||
+ | v = v->left; | ||
+ | } else { | ||
+ | v = v->right; | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void insert(binarySearchTree &t, keyType key) { | ||
+ | /* Do stromu t vlozi kluc key na spravne miesto. | ||
+ | * Predpokladame, ze takyto kluc este v strome nie je. */ | ||
+ | if (t.root == NULL) { | ||
+ | /* prazdny strom - treba vytvorit koren */ | ||
+ | t.root = createLeaf(key, NULL); | ||
+ | } else { | ||
+ | node *v; | ||
+ | node *parent; | ||
+ | findNode(t.root, key, v, parent); | ||
+ | /* parent je teraz vrchol, ktoreho syn ma byt novy vrchol */ | ||
+ | assert(v == NULL && parent != NULL); | ||
+ | /* zisti, ci mame byt lave alebo prave dieta otca */ | ||
+ | if (key < parent->key) { | ||
+ | assert(parent->left == NULL); | ||
+ | parent->left = createLeaf(key, parent); | ||
+ | } else { | ||
+ | assert(parent->right == NULL); | ||
+ | parent->right = createLeaf(key, parent); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | * Čas vkladania je tiež v najhoršom prípade úmerný hĺbke stromu. | ||
+ | |||
+ | '''Príklad:''' ako bude vyzerať strom po nasledujúcej postupnosti operácií? | ||
+ | <pre> | ||
+ | binarySearchTree t; | ||
+ | init(t); | ||
+ | insert(t, 2); | ||
+ | insert(t, 5); | ||
+ | insert(t, 3); | ||
+ | insert(t, 10); | ||
+ | insert(t, 7); | ||
+ | </pre> | ||
+ | |||
+ | ===Odbočka: minimum a nasledovník=== | ||
+ | * Spravíme si dve funkcie, ktoré sa nám zídu pri mazaní prvku, ale môžu sa zísť aj inokedy. | ||
+ | |||
+ | * Prvá funkcia nájde vo vyhľadávacom strome minimum. | ||
+ | ** Všetky prvky menšie ako koreň sú v ľavom podstrome, bude tam zrejme aj minimum. | ||
+ | ** Tá istá úvaha platí pre koreň ľavého podstromu. | ||
+ | ** Ideme teda doľava kým sa dá, posledný vrchol vrátime (list alebo vrchol s pravým synom). | ||
+ | ** Dá sa tiež pekne napísať rekurzívne. | ||
+ | <pre> | ||
+ | node *minimumNode(node *v) { | ||
+ | /* vrati vrchol s minimalnym klucom vo vyhladavacom strome | ||
+ | * s korenom v */ | ||
+ | assert(v != NULL); | ||
+ | while (v->left != NULL) { | ||
+ | v = v->left; | ||
+ | } | ||
+ | return v; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Druhá funkcia nájde vrchol, ktorý v utriedenom poradí nasleduje za daným vrcholom v. | ||
+ | * Ak má v pravého syna, nasledovník bude v pravom podstrome, konkrétne vrchol s minimálnym kľúčom v tomto podstrome | ||
+ | * V opačnom prípade to môže byť rodič, ak v je jeho ľavý syn | ||
+ | * Ak je pravý syn, môže to byť prarodič, ak je rodiť jeho ľavý syn, atď | ||
+ | * Nájdeme teda prvého predka, do ktorého ľavého podstromu patrí v a ten je hľadaný nasledovník | ||
+ | <pre> | ||
+ | node *successorNode(node *v) { | ||
+ | /* vrati vrchol, ktorý v utriedenom poradi nasleduje za vrcholom v, | ||
+ | * alebo NULL ak taky vrchol nie je */ | ||
+ | assert(v != NULL); | ||
+ | if (v->right != NULL) { | ||
+ | return minimumNode(v->right); | ||
+ | } | ||
+ | while (v->parent != NULL && v == v->parent->right) { | ||
+ | v = v->parent; | ||
+ | } | ||
+ | return v->parent; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Mazanie prvkov z vyhľadávacieho stromu=== | ||
+ | |||
+ | * Nájdeme mazaný vrchol ''v'' podľa kľúča obvyklým spôsobom | ||
+ | * Ak je ''v'' list, jednoducho ho zmažeme | ||
+ | * Ak má ''v'' jedno dieťa, toto dieťa prevesíme priamo pod otca ''v'' a ''v'' zmažeme | ||
+ | * Ak má ''v'' dve deti, nájdeme nasledovníka v, t.j. minimum v pravom podstrome ''v''. | ||
+ | * Tento nasledovník nemá ľavé dieťa, vieme ho teda zmazať. | ||
+ | * Jeho údaje presunieme do vrcholu ''v''. | ||
+ | * Tiež treba dať pozor na mazanie koreňa. | ||
+ | |||
+ | <pre> | ||
+ | void remove(binarySearchTree &t, keyType key) { | ||
+ | /* Zmaze kluc key zo stromu t. | ||
+ | * Predpokladame, ze tam taky kluc je. */ | ||
+ | |||
+ | /* Najdi vrchol s klucom */ | ||
+ | node *v = findNode(t.root, key); | ||
+ | assert(v != NULL && v->key == key); | ||
+ | /* najdi vrchol rm s jednym synom child, | ||
+ | * ktory vyhodime. */ | ||
+ | node *rm, *child; | ||
+ | if (v->left == NULL || v->right == NULL) rm = v; | ||
+ | else rm = successorNode(v); | ||
+ | assert(rm->left == NULL || rm->right == NULL); | ||
+ | if (rm->left != NULL) child = rm->left; | ||
+ | else child = rm->right; | ||
+ | |||
+ | /* preves syna priamo pod otca rm */ | ||
+ | if (child != NULL) child->parent = rm->parent; | ||
+ | if (rm->parent == NULL) t.root = child; | ||
+ | else { | ||
+ | /* ak rm nie je koren, jeho otcovi zaves child */ | ||
+ | node *parent = rm->parent; | ||
+ | assert(rm == parent->left || rm == parent->right); | ||
+ | if (rm == parent->left) parent->left = child; | ||
+ | else parent->right = child; | ||
+ | } | ||
+ | /* ak rm nema mazany kluc, prekopiruj data z rm do v*/ | ||
+ | if (rm != v) { | ||
+ | v->key = rm->key; | ||
+ | } | ||
+ | delete rm; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Zdrojový kód programu s binárnymi vyhľadávacími stromami=== | ||
+ | * [http://compbio.fmph.uniba.sk/vyuka/prog/data/programy/P22-binarySearchTree.cpp Zdrojový kód programu s binárnymi vyhľadávacími stromami] | ||
+ | |||
+ | ==Vyhľadávací strom ako implementácia slovníka== | ||
+ | |||
+ | Spomeňte si na abstraktný dátový typ slovník: | ||
+ | * Pre každý kľúč máme v slovníku uložené nejaké dáta, napr. pre každé meno máme telefónne číslo. | ||
+ | * Toto sú hlavné funkcie, ktoré slovník podporuje: | ||
+ | <pre> | ||
+ | void init(dictionary &d); | ||
+ | /* inicializuje prazdny slovnik */ | ||
+ | |||
+ | itemType *find(dictionary &d, keyType k); | ||
+ | /* nájde záznam s kľúčom k a vráti smerník na neho ho. | ||
+ | * Ak taký kľúč v slovníku nie je, vráti NULL */ | ||
+ | |||
+ | void insert(dictionary &d, itemType *x); | ||
+ | /* Do slovnika vloží záznam *x. | ||
+ | * Predpokladame, ze takyto kluc este v slovniku nie je. */ | ||
+ | |||
+ | void remove(dictionary &d, keyType k); | ||
+ | /* Zmaze zaznam s kucom k zo slovnika d. | ||
+ | * Predpokladame, ze tam taky kluc je. */ | ||
+ | </pre> | ||
+ | |||
+ | * Videli sme už slovník v neutriedenom poli, utriedenom poli, hashovacej tabuľke, dal by sa spraviť aj spájanom zozname... | ||
+ | * Slovník sa ale dá spraviť aj v binárnom vyhľadávacom strome | ||
+ | ** už vieme ako robiť všetky potrebné operácie: find, insert, remove | ||
+ | ** stačí mierne prerobiť, aby sedelo s typmi zo slovníka | ||
+ | |||
+ | Vo vrchole si namiesto kľúča dáme smerník na item | ||
+ | <pre> | ||
+ | struct node { | ||
+ | /* vrchol binarneho vyhladavacieho stromu */ | ||
+ | itemType *item; /* smernik na zaznam */ | ||
+ | node * parent; /* otec vrchola */ | ||
+ | node * left; /* lavy syn */ | ||
+ | node * right; /* pravy syn */ | ||
+ | }; | ||
+ | |||
+ | struct dictionary { | ||
+ | node *root; | ||
+ | }; | ||
+ | </pre> | ||
+ | |||
+ | Používateľ definuje itemType a funkcie key, equal, greater a pod., napr. | ||
+ | <pre> | ||
+ | struct monthSum { | ||
+ | char * name; // kľúč - skratka mesiaca, napr "Jan" | ||
+ | double sum; // data - sucet frekvencií pre daný mesiac | ||
+ | }; | ||
+ | typedef monthSum itemType; | ||
+ | typedef const char * keyType; | ||
+ | |||
+ | keyType key(itemType *x) { | ||
+ | return x->name; | ||
+ | } | ||
+ | |||
+ | bool equal(keyType x, keyType y) { | ||
+ | return strcmp(x, y) == 0; | ||
+ | } | ||
+ | |||
+ | bool greater(keyType x, keyType y) { | ||
+ | // x>y | ||
+ | return strcmp(x, y) > 0; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Všade, kde funkcie uvedené vyššie porovnávajú kľúče pomocou ==, >, <, použijeme príslušné funkcie, napr findNode a find: | ||
+ | <pre> | ||
+ | node * findNode(node *root, keyType k) { | ||
+ | /* V binarnom vyhladavacom strom s korenom root najdi a vrat | ||
+ | * vrchol s klucom k, alebo vrat NULL ak taky neexistuje. */ | ||
+ | node *v = root; | ||
+ | while (v != NULL && !equal(key(v->item), k)) { | ||
+ | if (greater(key(v->item), k)) { | ||
+ | v = v->left; | ||
+ | } else { | ||
+ | v = v->right; | ||
+ | } | ||
+ | } | ||
+ | return v; | ||
+ | } | ||
+ | |||
+ | itemType *find(dictionary &d, keyType k) { | ||
+ | // nájde záznam s kľúčom k a vráti smerník na neho ho. | ||
+ | // Ak taký kľúč v slovníku nie je, vráti NULL | ||
+ | node *v = findNode(d.root, k); | ||
+ | if (v == NULL) return NULL; | ||
+ | return v->item; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Zdrojový kód programu so slovníkom pomocou binárnych vyhľadávacích stromov=== | ||
+ | * [http://compbio.fmph.uniba.sk/vyuka/prog/data/programy/P22-dictionary.cpp Zdrojový kód programu so slovníkom pomocou binárnych vyhľadávacích stromov] | ||
+ | |||
+ | ==Zhrnutie== | ||
+ | Binárny vyhladávací strom je binárny strom v ktorom platí: | ||
+ | * Hodnota v koreni je väčšia ako všetky hodnoty v ľavom podstrome. | ||
+ | * Hodnota v koreni je menšia ako všetky hodnoty v pravom podstrome. | ||
+ | * Ľavý aj pravý podstrom sú binárne vyhľadávacie stromy. | ||
+ | Hodí sa na implementáciu slovníkových operácií find, remove, insert | ||
+ | |||
+ | Pri hľadaní putujeme od koreňa dole a vždy vieme, či máme pokračovať vľavo alebo vpravo | ||
+ | * podobá sa to teda na binárne vyhľadávanie | ||
+ | |||
+ | Zložitosť operácií závisí od výšky stromu. Tá je | ||
+ | * V najhoršom prípade O(n) | ||
+ | * V priemernom prípade O(log n) | ||
+ | |||
+ | Find, Insert, Delete: | ||
+ | * Najlepší prípad O(1) | ||
+ | * Najhorší prípad O(height(T))=O(n) | ||
+ | * Priemerný prípad O(height(T))=O(log n) | ||
+ | |||
+ | Na druháckom predmete Algoritmy a dátové štruktúry si ukážete obmeny vyhľadávacích stromov, ktoré majú zložisť O(log n) aj v priemernom prípade | ||
+ | |||
+ | Pre porovnanie jednoduché implementácie slovníka, najhoršie aj priemerné prípady: | ||
+ | * Usporiadané pole: Find - O(log n), Insert - O(n), Delete - O(n) | ||
+ | * Neusporiadané pole: Find - O(n), Insert - O(1), Delete - O(n) | ||
+ | =Cvičenia 11= | ||
+ | ==Zásobník a rad== | ||
+ | * Majme zásobník, do ktorého ukladáme dáta typu char. Do nasledujúceho úryvku kódu vložte na tri miesta príkaz <tt>cout << pop(s)</tt> tak, aby program vypísal text BAC | ||
+ | <pre> | ||
+ | stack s; | ||
+ | init(s); | ||
+ | push(s, 'A'); | ||
+ | push(s, 'B'); | ||
+ | push(s, 'C'); | ||
+ | </pre> | ||
+ | |||
+ | * Majme dva rady, do ktorých ukladáme dáta typu char. Do nasledujúce úryvku kódu vložte na vhodné miesta príkazy tak, aby program vypísal text BAC. Môžete použiť len tri typy príkazov, každý aj viackrát: | ||
+ | ** cout << dequeue(q1); | ||
+ | ** enqueue(q1, dequeue(q2)); | ||
+ | ** enqueue(q2, dequeue(q1)); | ||
+ | |||
+ | <pre> | ||
+ | queue q1, q2; | ||
+ | init(q1); | ||
+ | init(q2); | ||
+ | enqueue(q1, 'A'); | ||
+ | enqueue(q1, 'B'); | ||
+ | enqueue(q1, 'C'); | ||
+ | </pre> | ||
+ | |||
+ | ==Vyfarbovanie== | ||
+ | |||
+ | * Na prednáške 19 sme mali [[#Prednáška_19#Uk.C3.A1.C5.BEkov.C3.BD_program_ostrovy|program]], ktorý počítal počet ostrovov na mape. Upravte ho tak, aby našiel ostrov s najväčšou plochou a vyfarbil ho inou farbou ako ostatné ostrovy. | ||
+ | ** Upravte funkciu vyfarbi tak, aby vracala celé číslo udávajúce počet políčok, ktoré prefarbila. Tým zistíte plochu jednotlivých ostrovov. | ||
+ | |||
+ | * Na prednáške [[#Prednáška_19#Nerekurz.C3.ADvne_vyfarbovanie|prednáške 19]] sú tri funkcie na vyfarbovanie súvislej plochy, ktoré používajú polia delta_x a delta_y. Vďaka týmto poliam skúma každé políčko svojich susedov v poradí vpravo, hore, vľavo, dole. Jedna z týchto funkcií je však rekurzívna, jedna používa zásobník a jedna rad. Každú funkciu spustíme na matici s troma riadkami a troma stĺpcami, ktorá je vyplnená nulami, pričom funkciu spustíme na stredné políčko, t.j. stlpec=riadok=1 a nová farba je tiež 1. V akom poradí budú tieto funkcie vyfarbovať jednotlivé štvorčeky matice? Skúste túto úlohu riešiť bez použitia počítača. | ||
+ | |||
+ | ==Zátvorky== | ||
+ | * Do programu na kontrolu správne uzátvorkovaných výrazov z [[#Prednáška_18#Kontrola_uz.C3.A1tvorkovania|prednášky 18]] dopíšte informatívne oznamy pre užívateľa, ktoré mu povedia, zátvorka na ktorom mieste v reťazci nemá ľavý pár alebo na ktorom mieste má ľavý pár iného typu ako pravý alebo koľko ľavých zátvoriek zostalo na konci neuzavretých. Po prvej takejto chybe už ďalšie nevypisujte. | ||
+ | |||
+ | ==Deque== | ||
+ | * Uvažujme abstraktný dátový typ deque, ktorý je kombináciou radu a zásobníka. Dovoľuje | ||
+ | ** pridávať na jeden aj druhý koniec postupnosti (funkcie addFirst, addLast) | ||
+ | ** mazať na jednom aj druhom konci postupnosti (funkcie removeFirst a removeLast), pričom zmazaný prvok vráti | ||
+ | ** pozrieť sa na prvý a posledný prvok bez toho aby sa zmazal (funkcie getFirst a getLast) | ||
+ | ** pomocné operácie isEmpty, init a destroy | ||
+ | * Ako by ste pomocou deque implementovali zásobník a ako rad? (t.j. ktoré operácie sú ekvivalentné push, pop, resp. enqueue a dequeue)? | ||
+ | * Prepíšte [[#Prednáška_18#Rad_implementovan.C3.BD_pomocou_po.C4.BEa|implementáciu radu pomocou poľa]] tak, aby poskytovala všetky operácie pre deque. Nezabudnite pomocou príkazu assert skontrolovať, že dátová štruktúra nie je preplnená pri pridávaní, ale ani prázdna pri vyberaní a vracaní prvku. | ||
+ | =DÚ9= | ||
+ | {{MDU|9|5001}} max. 10 bodov, termín odovzdania pondelok 3.12. o 22:00 | ||
+ | |||
+ | Cieľom tejto domácej úlohy je precvičiť si prácu s maticami, súbormi a vyfarbovanie. | ||
+ | |||
+ | Napíšte program, ktorý načíta maticu predstavujúcu mapu ostrovov v oceáne, nájde jednotlivé ostrovy a pre každý spočíta jeho plochu a dĺžku pobrežia. | ||
+ | |||
+ | '''Vstupný súbor''' <tt>ostrovy.txt</tt> obsahuje každý riadok vstupnej mapy ako reťazec, v ktorom bodka znamená políčko s oceánom a písmeno X znamená políčko s ostrovom. Tu je príklad: | ||
+ | <pre> | ||
+ | .......X.. | ||
+ | .XX....XX. | ||
+ | ..X.X..... | ||
+ | X...XXXX.. | ||
+ | .X...XXX.. | ||
+ | .....XXX.. | ||
+ | </pre> | ||
+ | ''Ostrov'' je súvislá oblasť políčok označených písmenom X, pričom dve políčka dotýkajúce sa rohom nepovažujeme za susedné a nemusia teda byť súčasťou jedného ostrova, ak nie sú prepojené cez iné políčka. ''Plocha ostrova'' je jednoducho počet políčok označených X v rámci tohto ostrova. ''Dĺžka pobrežia'' je počet hraníc medzi políčkom ostrova a susedným políčkom oceánu. Teda napríklad ostrov pozostávajúci iba z jedného políčka má dĺžku pobrežia 4. Predpokladajte, že okolo celej vstupnej matice je oceán a teda ostrovy, ktoré sa dotýkajú okraja matice, majú na tomto okraji pobrežie. Môžete predpokladať, každý rozmer mapy je najviac 100. | ||
+ | |||
+ | '''Výstupný súbor''' <tt>vystup.txt</tt> obsahuje najprv kópiu vstupnej mapy, ktorá je ale zmenená tak, že prvý ostrov je označený písmenami A, druhý ostrov písmenami B atď. Môžete predpokladať, že ostrovov je najviac 26 a teda vám budú stačiť písmená A..Z. Pod mapou by mal byť voľný riadok a pod ním zoznam ostrovov s údajmi o ploche a dĺžke pobrežia vo formáte ako v príklade nižšie. Ostrovy by mali byť zoradené podľa toho, v akom poradí narazíme na ich prvé políčko, keď ideme po mape po riadkoch zhora nadol a v každom riadku zľava doprava (a v tomto poradí sú aj označené písmenami A,B,...). Výstup pre príklad vstupu uvedený vyššie: | ||
+ | <pre> | ||
+ | .......A.. | ||
+ | .BB....AA. | ||
+ | ..B.C..... | ||
+ | D...CCCC.. | ||
+ | .E...CCC.. | ||
+ | .....CCC.. | ||
+ | |||
+ | Ostrov A: plocha 3, pobrezie 8 | ||
+ | Ostrov B: plocha 3, pobrezie 8 | ||
+ | Ostrov C: plocha 11, pobrezie 16 | ||
+ | Ostrov D: plocha 1, pobrezie 4 | ||
+ | Ostrov E: plocha 1, pobrezie 4 | ||
+ | </pre> | ||
+ | |||
+ | Dodržujte mená súborov a ich formát podľa príkladu v zadaní. Dbajte na úpravu a čitateľnosť vášho programu. | ||
+ | |||
+ | '''Pomôcky:''' | ||
+ | * Doporučujeme použiť niektorú funkciu na vyfarbovanie z [[#Prednáška 19|prednášky 19]]. | ||
+ | * Doporučujeme si v programe uložiť mapu ako dvojrozmernú maticu int-ov, pričom napr. more máte ako 0, ešte nepreskúmané ostrovy ako -1 a preskúmané ostrovy označené číslami 1,2,... | ||
+ | * Ak máte už každý ostrov označený iným číslom, dĺžku pobrežia všetkých ostrovov ľahko spočítate jedným prechodom matice, pričom si budete všímať susedné políčka s rôznymi hodnotami. | ||
+ | =Prednáška 23= | ||
+ | == Slovník == | ||
+ | |||
+ | Na [[#Prednáška_17|prednáške 17]] sme pracovali s abstraktnou dátovou štruktúrou slovník. Na implementáciu sme využívali hashovacie tabuľky, ktoré pracovali vcelku optimálne, avšak potrebovali veľký pamäťový priestor. Pripomeňme si, aké operácie od slovníka požadujeme. | ||
+ | |||
+ | * Vloženie prvku | ||
+ | * Vymazanie prvku | ||
+ | * Hľadanie prvku | ||
+ | |||
+ | Budeme sa snažiť vytvoriť takú implementáciu slovníka, kde si nebudeme musieť pamätať nič zbytočné a pritom v ňom budeme vedieť vyhľadávať lepšie ako čisto v zozname slov. | ||
+ | |||
+ | == Opakovanie binárne vyhľadávacie stromy == | ||
+ | |||
+ | Aj binárne vyhľadávacie stromy môžeme chápať ako implementáciu slovníka a jeho operácií. Najvhodnejší je v prípade, ak sú kľúče (celé) čísla. Samozrejme vo všeobecnosti postačí, ak vieme na kľúčoch urobiť porovnanie (>,<,=). | ||
+ | |||
+ | Binárny vyhladávací strom je binárny strom v ktorom platí: | ||
+ | * Hodnota v koreni je väčšia ako všetky hodnoty v ľavom podstrome. | ||
+ | * Hodnota v koreni je menšia ako všetky hodnoty v pravom podstrome. | ||
+ | * Ľavý aj pravý podstrom sú binárne vyhľadávacie stromy. | ||
+ | |||
+ | [[Image:bvs.jpg]] | ||
+ | |||
+ | Pre tie isté čísla existuje viacero binárnych vyhľadávacích stromov (skúste napríklad čísla 1..4). Čo však majú spoločné je inorder výpis. | ||
+ | * Prečo? | ||
+ | |||
+ | Zopakujeme si, ako boli implementované jednotlivé operácie. | ||
+ | |||
+ | === Hľadanie v binárnom strome === | ||
+ | |||
+ | Porovnáme hľadaný kľúč s kľúčom v koreni | ||
+ | * Ak sa rovnajú, našli sme čo hľadáme a končíme | ||
+ | * Ak je hľadaná hodnota menšia ako kľúč v koreni, musí byť v ľavom podstrome, ak je väčšia v pravom | ||
+ | |||
+ | <pre> | ||
+ | node* findNode(node* root, keyType key) { | ||
+ | node* v = root; | ||
+ | while (v != NULL && v->key != key) { | ||
+ | if (key < v->key) { | ||
+ | v = v->left; | ||
+ | } else { | ||
+ | v = v->right; | ||
+ | } | ||
+ | } | ||
+ | return v; | ||
+ | } | ||
+ | |||
+ | node* findNode(node* root, keyType key) { | ||
+ | if ((root==NULL)||(root->key==key)) return root; | ||
+ | |||
+ | if (key < root->key) return findNode(root->left); | ||
+ | else return findNode(root->left); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Vkladanie do binárneho vyhľadávacieho stromu === | ||
+ | |||
+ | * Putujeme po strome podobne ako po vyhľadávaní prvku, až kým nenarazíme na nulový smerník. | ||
+ | * Na tomto mieste by mal byť nový prvok, takže ho tam pridáme ako nový list. | ||
+ | * Na to, aby sme vedeli pridať nový list potrebujeme vedieť predchodcu toho listu (takže si musíme pri hľadaní ťahať za sebou). | ||
+ | |||
+ | === Vymazávanie z binárneho vyhľadávacieho stromu === | ||
+ | |||
+ | * Putujeme po strome podobne ako po vyhľadávaní prvku, až kým nenarazíme na hľadaný prvok. | ||
+ | * Tento prvok chceme vymazať: | ||
+ | ** Ak je prvok listom, triviálne vymažeme. | ||
+ | ** Ak má iba jedného potomka, prevesíme. | ||
+ | ** Ináč nájdeme nasledovníka (minimum v pravom podstrome) a prekopírujeme ho na miesto hľadaného prvku a ten list zmažeme. | ||
+ | |||
+ | === Zložitosť slovníkových operácií v BVS === | ||
+ | |||
+ | Zložitosť operácií závisí od výšky stromu. Tá je | ||
+ | * V najhoršom prípade O(n) | ||
+ | * V priemernom prípade O(log n) | ||
+ | |||
+ | Find, Insert, Delete: | ||
+ | * Najlepší prípad O(1) | ||
+ | * Najhorší prípad O(height(T))=O(n) | ||
+ | * Priemerný prípad O(height(T))=O(log n) | ||
+ | |||
+ | Pre porovnanie si pripomeňme implementáciu slovníka pomocou | ||
+ | * Usporiadaného poľa Find - O(log n), Insert - O(n), Delete - O(n) (najhoršie prípady) | ||
+ | * Neusporiadaného poľa: Find - O(n), Insert - O(1), Delete - O(n) (najhoršie prípady) | ||
+ | |||
+ | == Lexikografické stromy (trie) == | ||
+ | |||
+ | Myšlienka je relatívne jednoduchá. Slová budem ukladať do stromu, kde sa budem rozhodovať na základe písmen. Každé slovo začína niektorým písmenom abecedy. Podľa neho sa v koreni stromu rozhodnem, do ktorého z jeho podstromov pokračujem. Podstromov je <math>|Abeceda|</math>. | ||
+ | |||
+ | [[Image:trie.jpg]] | ||
+ | |||
+ | Vrchol lexikografického stromu obsahuje: | ||
+ | * dáta - môže byť čisto písmenko, na ktoré som sa do vrcholu dostala (alebo celé slovo, ktoré v tomto vrchole končí) | ||
+ | * smerníky na ďalšie podstromy (teda na ďalšie vrcholy stromu) | ||
+ | * určenie, či vo vrchole končí nejaké slovo | ||
+ | |||
+ | Vrchol je teda nasledovného tvaru: | ||
+ | |||
+ | <pre> | ||
+ | struct node { | ||
+ | /* vrchol lexikografickeho stromu */ | ||
+ | char data; // pismeno ulozene v tomto vrchole | ||
+ | bool isWord; // je tento vrchol koncom slova? | ||
+ | node* next[Abeceda]; // pole smernikov na deti | ||
+ | }; | ||
+ | </pre> | ||
+ | |||
+ | alebo môžeme pole smerníkov alokovať vždy keď vznikne vrchol - nebude definícia závislá od veľkosti abecedy: | ||
+ | |||
+ | <pre> | ||
+ | struct node { | ||
+ | /* vrchol lexikografickeho stromu */ | ||
+ | char data; // pismeno ulozene v tomto vrchole | ||
+ | bool isWord; // je tento vrchol koncom slova? | ||
+ | node** next; // pole smernikov na deti | ||
+ | }; | ||
+ | </pre> | ||
+ | |||
+ | Samotný strom je potom iba smerník na koreňový vrchol | ||
+ | <pre> | ||
+ | struct trie { | ||
+ | /* samotny lexikograficky storm si pamata smernik na koren */ | ||
+ | node* root; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Inicializácia a uvoľňovanie stromu === | ||
+ | |||
+ | Pri práci s lexikografickým stromom začíname s jedným prázdnym vrcholom - koreňom, ktorý má v pole nasledovníkov iba smerníky s hodnotou NULL. Koreň je vlastne špeciálny vrchol, ktorý neobsahuje žiadne dáta (jeho dáta nastavíme na 0). | ||
+ | |||
+ | <pre> | ||
+ | void init(trie &t) { | ||
+ | /* inicializuj prazdny lexikograficky strom, ktory bude mat iba koren */ | ||
+ | t.root = createNode('\0'); // koren si oznacime specialnym znakom 0 | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Pričom funkcia createNode pracuje nasledovne: | ||
+ | * Vytvorí si smerník na nový vrchol (alokuje mu priestor) | ||
+ | * Ak máme pole nasledovníkov cez smerníky (teda nie pole konkrétnej veľkosti, ktoré by sa vytvorilo spolu s vrcholom), vytvoríme si takéto pole. | ||
+ | * Inicializujeme nasledovníkov na NULL. | ||
+ | * Nastavíme hodnoty data a isWord | ||
+ | |||
+ | <pre> | ||
+ | node* createNode(char data) { | ||
+ | /* vytvor vrchol stromu s danymi datami */ | ||
+ | node* v = new node; // novy vrchol | ||
+ | v->next = new node*[Abeceda]; // alokuj pole deti | ||
+ | for (int i = 0; i < Abeceda; i++) v->next[i] = NULL; // inicializacia deti | ||
+ | v->isWord = false; | ||
+ | v->data = data; | ||
+ | return v; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Uvoľňovanie pamäti stromu je pomocou jednoduchej rekurzívnej funkcie destroySubtree(node*), pričom na uvoľnenie celého stromu ju potrebujeme zavolať pre koreň | ||
+ | |||
+ | <pre> | ||
+ | void destroySubtree(node* v) { | ||
+ | /* rekurzivne uvolni pamat pre podstrom lexikografickleho stromu | ||
+ | * s korenom vo vrchole v */ | ||
+ | if (v == NULL) return; | ||
+ | for (int i = 0; i < Abeceda; i++) destroySubtree(v->next[i]); | ||
+ | delete[] v->next; // táto časť by nebola potrebná, ak by sme mali next statické | ||
+ | delete v; | ||
+ | } | ||
+ | |||
+ | void destroy(trie &t) { | ||
+ | /* uvolni pamat alokovanu pre lexikograficky strom t */ | ||
+ | destroySubtree(t.root); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Vkladanie do stromu === | ||
+ | |||
+ | Do lexikografického stromu vkladáme reťazec zložený iba z písmen abecedy (pre jednoduchosť pracujeme s abecedou 'A'..'Z' resp. s jej začiatkom veľkosti Abeceda). | ||
+ | |||
+ | Postupujeme v cykle (po jednotlivých písmenách vkladaného slova) nasledovne: | ||
+ | * Začínam od koreňa stromu | ||
+ | * Ak nemám patričný smerník - tj. smerník na ďalšie potrebné písmkenko, tak si takýto vrchol (obsahujúci patričné písmenko) vytvoríme. | ||
+ | ** Všimnite si, že v úplne prvom otočení cyklu nemáme žiadne zmysluplné písmenko, ktoré by sme dali ako hodnotu koreňu. | ||
+ | * Pozrieme si znak slova a ak je to koniec slova, tak skončíme cyklus. | ||
+ | * V opačnom prípade sa posunieme vhodnou hranou - máme už zaručené, že tam nebude NULL a tiež na ďalší znak slova. | ||
+ | * Keď nájdeme koniec slova, poznačíme si, že daný vrchol zodpovedá slovu | ||
+ | |||
+ | <pre> | ||
+ | void insert(trie &t, const char* key) { | ||
+ | /* do lexikografixkeho stromu t pridaj slovo key */ | ||
+ | node *v = t.root; | ||
+ | for (int i = 0; key[i] != 0; i++) { // posuvame sa od korena na spravne miesto | ||
+ | int c = key[i] - 'A'; | ||
+ | if (v->next[c] == NULL) { // ak vrchol chyba, spravime novy | ||
+ | v->next[c] = createNode(key[i]); | ||
+ | } | ||
+ | v = v->next[c]; | ||
+ | } | ||
+ | |||
+ | /* Aktualny vrchol v je koncom slova */ | ||
+ | v->isWord = true; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Hľadanie v lexikografickom strome === | ||
+ | |||
+ | Vyhľadávanie v strome opäť postupuje po písmenkách vyhľadávaného slova. Kým nedojde na koniec slova snaží sa ísť po hranách, ktoré zodpovedajú písmenkám. | ||
+ | V prípade, že na niektorom mieste chýba patričná hrana, znamená to, že takéto slovo sa v strome nenachádza. | ||
+ | |||
+ | <pre> | ||
+ | bool find(trie& t, const char* key) { | ||
+ | /* zisti, ci v lexikografickom strome t je kluc key */ | ||
+ | node *v = t.root; | ||
+ | for (int i = 0; key[i] != 0; i++) { | ||
+ | int c = key[i] - 'A'; | ||
+ | if (v->next[c] == NULL) return false; | ||
+ | v = v->next[c]; | ||
+ | } | ||
+ | return true; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Teraz sa nad tým kúsok zamyslíme. Vo chvíli, keď uložím slovo "ahoj", mám vlaste vytvorené aj slová "a", "ah" a "aho", pričom tieto vôbec v slovníku nemusia byť. Po prečítaní slova sa teda potrebujem opýtať, či tam nejaké slovo naozaj končilo a na základe toho odpovedať. | ||
+ | |||
+ | <pre> | ||
+ | bool find(trie& t, const char* key) { | ||
+ | /* zisti, ci v lexikografickom strome t je kluc key */ | ||
+ | node *v = t.root; | ||
+ | for (int i = 0; key[i] != 0; i++) { | ||
+ | int c = key[i] - 'A'; | ||
+ | if (v->next[c] == NULL) return false; | ||
+ | v = v->next[c]; | ||
+ | } | ||
+ | return v->isWord; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Vymazávanie z lexikografického stromu === | ||
+ | |||
+ | Pri vymazávaní slova potrebujeme spraviť nasledujúce veci: | ||
+ | * nájsť vrchol pre dané slovo a nastaviť mu isWord na false (predpokladáme, že slovo v strome bolo) | ||
+ | * prípadne uvoľniť nepotrebné vrcholy | ||
+ | |||
+ | Prvá možnosť je uvoľňovanie vrcholov ignorovať. | ||
+ | <pre> | ||
+ | void deleteTrie(trie* t, const char* key){ | ||
+ | /* zisti, ci v lexikografickom strome t je kluc key */ | ||
+ | node *v = t.root; | ||
+ | for (int i = 0; key[i] != 0; i++) { | ||
+ | int c = key[i] - 'A'; | ||
+ | assert(v->next[c] != NULL); | ||
+ | v = v->next[c]; | ||
+ | } | ||
+ | assert(v->isWord); | ||
+ | v->isWord=false; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Ak by sme chceli byť dôkladní potrebujeme spraviť nasledujúce veci: | ||
+ | * nájsť vrchol pre dané slovo a nastaviť mu isWord na false (predpokladáme, že slovo v strome bolo) | ||
+ | * môže sa však stať, že tento vrchol je už nepotrebný, lebo nemá žiadne deti, takže ho treba zmazať | ||
+ | * tým sa môže stať nepotrebný aj jeho rodič a ďalší predkovia | ||
+ | |||
+ | Použijeme rekurziu, kde najskôr vymažeme slovo z určitého podstromu a ak sa tým stal jeho rodič zbytočný, zmažeme aj jeho. | ||
+ | |||
+ | <pre> | ||
+ | void remove(trie& t, const char* key) { | ||
+ | /* z lexikografickeho stromu t zmaze slovo key */ | ||
+ | removeFromSubtree(t.root, key, 0); | ||
+ | } | ||
+ | |||
+ | bool removeFromSubtree(node *v, const char *key, int depth) { | ||
+ | /* Z podstromu s korenom v zmaz slovo key, pricom aktualna hlbka je depth. | ||
+ | * Vrati true, ak sme zmazali vrchol v, false inak. */ | ||
+ | if (key[depth] == '\0') { // ak sme na konci slova, odznacime vrchol | ||
+ | assert(v->isWord); | ||
+ | v->isWord = false; | ||
+ | } else { // ak nie sme na konci slova, zmazeme ho z prislusneho podstromu | ||
+ | int c = key[depth] - 'A'; | ||
+ | assert(v->next[c] != NULL); | ||
+ | bool deleted = removeFromSubtree(v->next[c], key, depth + 1); | ||
+ | if (deleted) { // ak sme zmazali dieta, poznacime v poli next | ||
+ | v->next[c] = NULL; | ||
+ | } | ||
+ | } | ||
+ | // zistime, kolko deti ma v | ||
+ | int numChildren = 0; | ||
+ | for (int i = 0; i < Abeceda; i++) { | ||
+ | if (v->next[i] != NULL) numChildren++; | ||
+ | } | ||
+ | // ak v nema deti, nie je oznaceny ako slovo a nie je koren, zmazeme ho | ||
+ | if (numChildren == 0 && !v->isWord && v->data != '\0') { | ||
+ | delete[] v->next; | ||
+ | delete v; | ||
+ | return true; | ||
+ | } | ||
+ | return false; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Čo sa stane, ak takto napísanú spustíme na strome v ktorom máme iba slovo "AHOJ" a skúsime z neho vymazať slovo "A"? | ||
+ | |||
+ | === Vypisovanie stromu === | ||
+ | |||
+ | Podobne ako pri binárnych stromoch aj lexikografický strom môžeme vypisovať napríklad funkciou <tt>preorder</tt> | ||
+ | Aby sa aspoň kúsok dalo sledovať, ako to so stromom vyzerá, pridali sme nejaké zátvorky (nie že by veľmi pomohli). | ||
+ | |||
+ | <pre> | ||
+ | void preorder(node* v){ | ||
+ | if (v==NULL) {cout << "0 "; return;} | ||
+ | else cout << "("<< v->data<<","<< v->use_count<<") "; | ||
+ | |||
+ | cout << "["; | ||
+ | for (int i=0; i<Abeceda; i++){ | ||
+ | preorder(v->next[i]); | ||
+ | } | ||
+ | cout <<"] "; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Napr. pre strom so slovami A, ARE, AS, DO, DOT dostávame: | ||
+ | <pre> | ||
+ | [A* [R [E* [] ] S* [] ] D [O* [T* [] ] ] ] | ||
+ | </pre> | ||
+ | |||
+ | Oveľa viac by nám pomohlo vypísať všetky slová, ktoré sú v slovníku. | ||
+ | |||
+ | Funkcia na vypisovanie všetkých slov bude pracovať rekurzívne a do pomocného poľa prefox si bude zapisovať aktuálny prefix stav slova, ktoré vypisuje. | ||
+ | Pracuje nasledovne: vo vrchole v mám aktuálny prefix | ||
+ | * Špeciálne ak je vo vrchole v koniec nejakého slova, tak ho vypíše. | ||
+ | * Rekurzívne sa zavolá na všetky podstromy, pričom k prefixu pridá postupne všetky potenciálne znaky abecedy. | ||
+ | |||
+ | <pre> | ||
+ | void printSubtree(int depth, node *v, char* prefix) { | ||
+ | /* rekurzivne vypise vsetky slova v podstrome s korenom v, | ||
+ | * pricom v ma hlbku depth | ||
+ | * a spolocny prefix jeho slov je v retazci prefix */ | ||
+ | if (v->isWord) { | ||
+ | prefix[depth] = '\0'; | ||
+ | printf("%s\n", prefix); | ||
+ | } | ||
+ | for (int i = 0; i < Abeceda; i++) { | ||
+ | if (v->next[i] != NULL) { | ||
+ | prefix[depth] = (v->next[i])->data; // pridám si ďalšie písmeno | ||
+ | printSubtree(depth + 1, v->next[i], prefix); // zavolám sa rekurzívne | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Volanie tejto rekurzívnej funkcie je s použitím pomocného poľa, ktorého dĺžku by sme mohli nastaviť ako dĺžku najdlhšieho slova v strome. | ||
+ | |||
+ | <pre> | ||
+ | void printTrie(trie &t) { | ||
+ | /* vypise vsetky slova v lexikografickom strome t */ | ||
+ | char *prefix = new char[maxLen+1]; | ||
+ | printSubtree(0, t.root, prefix); | ||
+ | delete[] prefix; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | === Ďalšie použitie lexikografického stromu === | ||
+ | |||
+ | Videli sme, že pri vymazávaní zo stromu sma narazili na problém ako zistiť, či je vrchol stromu ešte využívaný. Ďalšia možnosť, ako to zistiť je si pre každý vrchol pamätať, koľko krát bol pre nejaké slovo v strome používaný. | ||
+ | |||
+ | <pre> | ||
+ | struct node { | ||
+ | /* vrchol stromu */ | ||
+ | char data; | ||
+ | int use_count; //počet použití vrcholu | ||
+ | bool isWord; | ||
+ | node** next; | ||
+ | }; | ||
+ | </pre> | ||
+ | |||
+ | Takto definovaný vrchol stromu bude vhodný aj pre nasledovnú úlohu: na vstupe je daná množina slov z abecedy {a, b}. Takýchto slov môže byť aj niekoľko stotisíc a my potrebujeme vedieť, koľkokrát sa nachádza každé slovo v tejto množine. | ||
+ | |||
+ | Môžeme použiť lexikografický strom a jeho pripravené funkcie, ale v každom vrchole si budeme ešte udržovať počítadlo výskytov príslušného slova. Pochopiteľne musíme novú vlastnosť vrcholu upravovať priebežne pri pridávaní. Pri inicializácii vrcholu ho nastavíme na nulu. Pri každom prechádzaní cez tento vrchol potom budeme hodnotu <tt>use_count</tt> zvyšovať. | ||
+ | |||
+ | <pre> | ||
+ | void insert(trie &t, const char* key) { | ||
+ | /* do lexikografickeho stromu t pridaj slovo key */ | ||
+ | node *v = t.root; | ||
+ | for (int i = 0; key[i] != 0; i++) { // posuvame sa od korena na spravne miesto | ||
+ | int c = key[i] - 'A'; | ||
+ | if (v->next[c] == NULL) { // ak vrchol chyba, spravime novy | ||
+ | v->next[c] = createNode(key[i]); | ||
+ | } | ||
+ | v->use_count++; | ||
+ | v = v->next[c]; | ||
+ | } | ||
+ | |||
+ | /* Aktualny vrchol v je koncom slova */ | ||
+ | v->isWord = true; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Pri vyhľadávaní sa hodnota <tt>use_count</tt> nepoužíva, takže vyhľadávanie nepotrebuje žiadnu úpravu. | ||
+ | Pri vymazávaní však vieme jednoducho zistiť, ktoré vrcholy máme uvoľniť. | ||
+ | |||
+ | * Akonáhle narazíme na vrchol, ktorý má iba jediné použitie vieme, že celý jeho podstrom môžeme zmazať. | ||
+ | |||
+ | <pre> | ||
+ | void remove(trie &t, const char* key){ | ||
+ | /* zisti, ci v lexikografickom strome t je kluc key */ | ||
+ | node *v = t.root; | ||
+ | for (int i = 0; key[i] != 0; i++) { | ||
+ | int c = key[i] - 'A'; | ||
+ | assert(v->next[c] != NULL); | ||
+ | if ((v->next[c])->use_count==1){ | ||
+ | destoySubtree(v->next[c]); | ||
+ | v->next[c] = NULL; | ||
+ | } | ||
+ | else { | ||
+ | v=v->next[c]; | ||
+ | v->use_count--; | ||
+ | } | ||
+ | } | ||
+ | (t.root)->use_count--; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | Teraz si vyskúšajme takto napísanú funkciu na strome v ktorom máme iba slovo "ahoj" a skúsime z neho vymazať slovo "a". Takéto slovo v slovníku nemáme, napriek tomu nám ho dovolí vymazať a vymaže tým vlastne slovo "ahoj". | ||
+ | |||
+ | Aby sme tomu zabránili môžeme urobiť jednu z nasledujúcich vecí: | ||
+ | |||
+ | * Uvoľnovať vrcholy iba v prípade, že je tam niekde isWord() -- napríklad napísať funkciu condDestroySubtree(node* v, const char* key) | ||
+ | * Na začiatku sa opýtať, či sa také slovo vyskytuje a potom mazať v kľude. Tým vyriešime aj problém, že čo z rozpracovaným stromom vo chvíli, keď zistím, že som vlastne vymazávať nemala. | ||
+ | |||
+ | ==Zdrojový k programu s lexikografickým stromom== | ||
+ | <pre> | ||
+ | #include <cstdio> | ||
+ | #include <cassert> | ||
+ | |||
+ | const int Abeceda = 26; /* velkost abecedy, znaky cislujeme 0..Abeceda-1 */ | ||
+ | const int maxLen = 100; /* maximalna dlzka slova v strome */ | ||
+ | |||
+ | struct node { | ||
+ | /* vrchol lexikografickeho stromu */ | ||
+ | char data; // pismeno ulozene v tomto vrchole | ||
+ | bool isWord; // je tento vrchol koncom slova? | ||
+ | node** next; // pole smernikov na deti | ||
+ | }; | ||
+ | |||
+ | struct trie { | ||
+ | /* samotny lexikograficky storm si pamata smernik na koren */ | ||
+ | node* root; | ||
+ | }; | ||
+ | |||
+ | node* createNode(char data) { | ||
+ | /* vytvor vrchol stromu s danymi datami */ | ||
+ | node* v = new node; // novy vrchol | ||
+ | v->next = new node*[Abeceda]; // alokuj pole deti | ||
+ | for (int i = 0; i < Abeceda; i++) v->next[i] = NULL; // inicializacia deti | ||
+ | v->isWord = false; | ||
+ | v->data = data; | ||
+ | return v; | ||
+ | } | ||
+ | |||
+ | void init(trie &t) { | ||
+ | /* inicializuj prazdny lexikograficky strom, ktory bude mat iba koren */ | ||
+ | t.root = createNode('\0'); // koren si oznacime specialnym znakom 0 | ||
+ | } | ||
+ | |||
+ | void destroySubtree(node* v) { | ||
+ | /* rekurzivne uvolni pamat pre podstrom lexikografickleho stromu | ||
+ | * s korenom vo vrchole v */ | ||
+ | if (v == NULL) return; | ||
+ | for (int i = 0; i < Abeceda; i++) destroySubtree(v->next[i]); | ||
+ | delete[] v->next; // táto časť by nebola potrebná, ak by sme mali next statické | ||
+ | delete v; | ||
+ | } | ||
+ | |||
+ | void destroy(trie &t) { | ||
+ | /* uvolni pamat alokovanu pre lexikograficky strom t */ | ||
+ | destroySubtree(t.root); | ||
+ | } | ||
+ | |||
+ | void insert(trie &t, const char* key) { | ||
+ | /* do lexikografixkeho stromu t pridaj slovo key */ | ||
+ | node *v = t.root; | ||
+ | for (int i = 0; key[i] != 0; i++) { // posuvame sa od korena na spravne miesto | ||
+ | int c = key[i] - 'A'; | ||
+ | if (v->next[c] == NULL) { // ak vrchol chyba, spravime novy | ||
+ | v->next[c] = createNode(key[i]); | ||
+ | } | ||
+ | v = v->next[c]; | ||
+ | } | ||
+ | |||
+ | /* Aktualny vrchol v je koncom slova */ | ||
+ | v->isWord = true; | ||
+ | } | ||
+ | |||
+ | bool find(trie& t, const char* key) { | ||
+ | /* zisti, ci v lexikografickom strome t je kluc key */ | ||
+ | node *v = t.root; | ||
+ | for (int i = 0; key[i] != 0; i++) { | ||
+ | int c = key[i] - 'A'; | ||
+ | if (v->next[c] == NULL) return false; | ||
+ | v = v->next[c]; | ||
+ | } | ||
+ | return v->isWord; | ||
+ | } | ||
+ | |||
+ | bool removeFromSubtree(node *v, const char *key, int depth) { | ||
+ | /* Z podstromu s korenom v zmaz slovo key, pricom aktualna hlbka je depth. | ||
+ | * Vrati true, ak sme zmazali vrchol v, false inak. */ | ||
+ | if (key[depth] == '\0') { // ak sme na konci slova, odznacime vrchol | ||
+ | assert(v->isWord); | ||
+ | v->isWord = false; | ||
+ | } else { // ak nie sme na konci slova, zmazeme ho z prislusneho podstromu | ||
+ | int c = key[depth] - 'A'; | ||
+ | assert(v->next[c] != NULL); | ||
+ | bool deleted = removeFromSubtree(v->next[c], key, depth + 1); | ||
+ | if (deleted) { // ak sme zmazali dieta, poznacime v poli next | ||
+ | v->next[c] = NULL; | ||
+ | } | ||
+ | } | ||
+ | // zistime, kolko deti ma v | ||
+ | int numChildren = 0; | ||
+ | for (int i = 0; i < Abeceda; i++) { | ||
+ | if (v->next[i] != NULL) numChildren++; | ||
+ | } | ||
+ | // ak v nema deti, nie je oznaceny ako slovo a nie je koren, zmazeme ho | ||
+ | if (numChildren == 0 && !v->isWord && v->data != '\0') { | ||
+ | delete[] v->next; | ||
+ | delete v; | ||
+ | return true; | ||
+ | } | ||
+ | return false; | ||
+ | } | ||
+ | |||
+ | void remove(trie& t, const char* key) { | ||
+ | /* z lexikografickeho stromu t zmaze slovo key */ | ||
+ | removeFromSubtree(t.root, key, 0); | ||
+ | } | ||
+ | |||
+ | void printSubtree(int depth, node *v, char* prefix) { | ||
+ | /* rekurzivne vypise vsetky slova v podstrome s korenom v, | ||
+ | * pricom v ma hlbku depth | ||
+ | * a spolocny prefix jeho slov je v retazci prefix */ | ||
+ | if (v->isWord) { | ||
+ | prefix[depth] = '\0'; | ||
+ | printf("%s\n", prefix); | ||
+ | } | ||
+ | for (int i = 0; i < Abeceda; i++) { | ||
+ | if (v->next[i] != NULL) { | ||
+ | prefix[depth] = (v->next[i])->data; // pridám si ďalšie písmeno | ||
+ | printSubtree(depth + 1, v->next[i], prefix); // zavolám sa rekurzívne | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void printTrie(trie &t) { | ||
+ | /* vypise vsetky slova v lexikografickom strome t */ | ||
+ | char *prefix = new char[maxLen+1]; | ||
+ | printSubtree(0, t.root, prefix); | ||
+ | delete[] prefix; | ||
+ | } | ||
+ | |||
+ | void preorder(node* v){ | ||
+ | if (v==NULL) return; | ||
+ | char *isWord = ""; | ||
+ | if(v->isWord) isWord = "*"; | ||
+ | printf("%c%s ", v->data, isWord); | ||
+ | |||
+ | printf("["); | ||
+ | for (int i=0; i<Abeceda; i++){ | ||
+ | preorder(v->next[i]); | ||
+ | } | ||
+ | printf("] "); | ||
+ | } | ||
+ | |||
+ | |||
+ | int main(void) { | ||
+ | trie t; | ||
+ | init(t); | ||
+ | insert(t, "ARE"); | ||
+ | insert(t, "AS"); | ||
+ | insert(t, "A"); | ||
+ | insert(t, "DO"); | ||
+ | insert(t, "DOT"); | ||
+ | if (find(t, "ARE")) { | ||
+ | printf("Nasiel ARE\n"); | ||
+ | } | ||
+ | if (find(t, "AR")) { | ||
+ | printf("Nasiel AR\n"); | ||
+ | } | ||
+ | if (find(t, "AREA")) { | ||
+ | printf("Nasiel AREA\n"); | ||
+ | } | ||
+ | preorder(t.root); printf("\n"); | ||
+ | printTrie(t); | ||
+ | remove(t, "AHO"); | ||
+ | remove(t, "ABC"); | ||
+ | destroy(t); | ||
+ | } | ||
+ | </pre> | ||
+ | =Prednáška 24= | ||
+ | == Organizačné poznámky == | ||
+ | |||
+ | Dobeh semestra: | ||
+ | * DÚ10 a PDÚ4 do 10.12. | ||
+ | * Cvičenia + rozcvičky 10.12. | ||
+ | * Prednášky: | ||
+ | ** dnes opakovanie, príprava na písomku a skúšku | ||
+ | ** pondelok 10.12. nepreberané črty jazykov C a C++ | ||
+ | ** utorok 11.12. prednáška nebude | ||
+ | * Na stránke zverejnené ukážkové príklady na písomku a skúšku | ||
+ | * Skontrolujte si v Moodli známky z DÚ aj rozcvičiek, problémy nám hláste čím skôr | ||
+ | ** Jednotlivé body podľa Moodla, súčty/percentá podľa pravidiel predmetu (Moodle nezobrazuje správne) | ||
+ | * V stredu 12.12. na Matematickej propedeutike (14:50, M-VII) dobré rady k skúškovému obdobiu s vašim tútorom Tomášom Kulichom | ||
+ | |||
+ | == Sylaby predmetu == | ||
+ | === Základy === | ||
+ | |||
+ | '''Konštrukcie jazyka C''' | ||
+ | * premenné typov int, double, char, bool (vzťah int a char) | ||
+ | * podmienky (if, else, switch), cykly (for, while) | ||
+ | * funkcie (a parametre funkcií - odovzdávanie hodnotou, referenciou, smerníkom) | ||
+ | <pre> | ||
+ | void f1(int x){} //hodnotou | ||
+ | void f2(int &x){} //referenciou | ||
+ | void f3(int* x){} //smerníkom | ||
+ | void f(int a[], int n){} //polia bez & (ostanú zmeny) | ||
+ | void kresli(Turtle &t){} //korytnačky, okná a pod. s & | ||
+ | </pre> | ||
+ | |||
+ | '''Polia, reťazce''' (char[]) | ||
+ | <pre> | ||
+ | int A[4]={3, 6, 8, 10}; //spravne | ||
+ | int B[4]; //spravne | ||
+ | B={3, 6, 8, 10}; //nespravne | ||
+ | B[0]=3; B[1]=6; B[2]=8; B[3]=10; | ||
+ | |||
+ | char C[100] = "pes"; | ||
+ | char D[100] = {'p', 'e', 's', 0}; | ||
+ | </pre> | ||
+ | * funkcie strlen, strcpy, strcmp, strcat | ||
+ | |||
+ | '''Súbory, spracovanie vstupu''' | ||
+ | * cin, cout alebo printf, scanf | ||
+ | * fopen, fclose, feof | ||
+ | * fprintf, fscanf | ||
+ | * getc, putc, ungetc, fgets, fputs | ||
+ | * spracovanie súboru po znakoch, po riadkoch, po číslach alebo slovách | ||
+ | |||
+ | '''Smerníky, dynamicky alokovaná pamäť, dvojrozmerné polia''' | ||
+ | <pre> | ||
+ | int i; // „klasická“ celočíselná premenná | ||
+ | int *p; // ukazovateľ na celočíselnú premennú | ||
+ | |||
+ | p = &i; // spravne | ||
+ | p = &(i + 3); // zle i+3 nie je premenna | ||
+ | p = &15; // zle konstanta nema adresu | ||
+ | i = *p; // spravne ak p bol inicializovany | ||
+ | |||
+ | int * cislo = new int; // alokovanie jednej premennej | ||
+ | *cislo = 50; | ||
+ | .. | ||
+ | delete cislo; | ||
+ | |||
+ | int a[4]; | ||
+ | int *b = a; // a,b su teraz takmer rovnocenne premenne | ||
+ | |||
+ | int *A = new int[n]; // alokovanie 1D pola danej dlzky | ||
+ | .. | ||
+ | delete[] A; | ||
+ | |||
+ | int **a; // alokovanie 2D pola | ||
+ | a = new int *[n]; | ||
+ | for (int i = 0; i < n; i++) a[i] = new int[m]; | ||
+ | .. | ||
+ | for (int i = 0; i < n; i++) delete[] a[i]; | ||
+ | delete[] a; | ||
+ | </pre> | ||
+ | |||
+ | === Dátové štruktúry === | ||
+ | |||
+ | Abstraktný dátový typ '''vektor''' (rastúce pole) | ||
+ | * operácie add, get, set, length | ||
+ | |||
+ | Abstraktný dátový typ '''slovník''' (asociatívne pole, map) | ||
+ | * operácie insert, find, remove | ||
+ | * implementácie | ||
+ | ** utriedené, neutriedené pole | ||
+ | ** hashovacia tabuľka | ||
+ | ** spájaný zoznam | ||
+ | ** binárny vyhľadávací strom | ||
+ | ** lexikografický strom (ak kľúč je reťazec) | ||
+ | |||
+ | Abstraktné dátové typy '''rad a zásobník''' | ||
+ | * operácie pre rad (frontu, queue): init, isEmpty, enqueue, dequeue, peek | ||
+ | * operácie pre zásobník (stack): init, isEmpty, push, pop, top | ||
+ | * implementácie: v poli alebo v spájanom zozname | ||
+ | * využitie: ukladanie dát na spracovanie, odstránenie rekurzie | ||
+ | * kontrola zátvoriek a vyhodnocovanie výrazov pomocou zásobníka | ||
+ | |||
+ | [[Image:PROG-list.png|right|200px]]'''Spájané zoznamy''' | ||
+ | <pre> | ||
+ | struct node { | ||
+ | int data; | ||
+ | item* next; | ||
+ | }; | ||
+ | struct linkedList { | ||
+ | item* first; | ||
+ | }; | ||
+ | void insertFirst(linkedList &z, int d){ | ||
+ | /* do zoznamu z vlozi na zaciatok novy prvok s datami d */ | ||
+ | item* p = new item; // vytvoríme nový prvok | ||
+ | p->data = d; // naplníme dáta | ||
+ | p->next = z.first; // prvok bude prvým prvkom zoznamu (ukazuje na doterajší začiatok) | ||
+ | z.first = p; // tento prvok je novým začiatkom | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | [[Image:PROG-P21-aritm.png|thumb|right|Strom pre výraz (65 – 3*5)/(2 + 3)]]'''Binárne stromy''' | ||
+ | <pre> | ||
+ | struct node { | ||
+ | /* vrchol stromu */ | ||
+ | dataType data; | ||
+ | node * left; /* lavy syn */ | ||
+ | node * right; /* pravy syn */ | ||
+ | }; | ||
+ | |||
+ | node * createNode(dataType data, node *left, node *right) { | ||
+ | node *v = new node; | ||
+ | v->data = data; | ||
+ | v->left = left; | ||
+ | v->right = right; | ||
+ | return v; | ||
+ | } | ||
+ | </pre> | ||
+ | * prehľadávanie inorder, preorder, postorder | ||
+ | * použitie na uloženie aritmetických výrazov | ||
+ | |||
+ | [[Image:P22-BST.png|200px|right]]'''Binárne vyhľadávacie stromy''' | ||
+ | * vrcholy vľavo od koreňa menší kľúč, vpravo od koreňa väčší | ||
+ | * insert, find, remove v čase závisiacom od hĺbky stromu | ||
+ | |||
+ | [[Image:trie.jpg|right]]'''Lexikografické stromy''' | ||
+ | * ukladajú množinu reťazcov | ||
+ | * nie sú binárne: vrchol môže mať veľa synov | ||
+ | * insert, find, remove v čase závisiacom od dĺžky kľúča, ale nie od počtu kľúčov, ktoré už sú v strome | ||
+ | <pre> | ||
+ | struct node { | ||
+ | /* vrchol lexikografickeho stromu */ | ||
+ | char data; // pismeno ulozene v tomto vrchole | ||
+ | bool isWord; // je tento vrchol koncom slova? | ||
+ | node* next[Abeceda]; // pole smernikov na deti | ||
+ | }; | ||
+ | </pre> | ||
+ | |||
+ | === Algoritmy === | ||
+ | |||
+ | '''Rekurzia''' | ||
+ | * Rekurzívné funkcie | ||
+ | * Vykresľovanie fraktálov | ||
+ | * Prehľadávanie s návratom (backtracking) | ||
+ | * Vyfarbovanie | ||
+ | * Prehľadávanie stromov | ||
+ | |||
+ | '''Triedenia''' | ||
+ | * nerekurzívne: Bubblesort, Selectionsort, Insertsort | ||
+ | * rekurzívne: Mergesort, Quicksort | ||
+ | * súvisiace algoritmy: binárne vyhľadávanie, hľadanie mediána | ||
+ | |||
+ | '''Matematické úlohy''' | ||
+ | * Euklidov algoritmus, Eratostenovo sito | ||
+ | * Práca s polynómami (vyhodnocovanie, sčítanie) | ||
+ | * Práca s aritmetickými výrazmi: rekurzívne vyhodnocovanie, vyhodnocovanie postfixovej formy, prevod z infixovej do postfixovej, reprezentácia vo forme stromu | ||
+ | |||
+ | == Záverečná písomka == | ||
+ | |||
+ | * Termín: pondelok 17.12.2011 o 10:00 v posluchárni B | ||
+ | * Opravný/náhradný termín: 8.1. o 10:00 v M-VII | ||
+ | * 90 minút | ||
+ | * Aby ste mali šancu úspešne ukončiť predmet, musíte získať aspoň polovicu bodov. | ||
+ | |||
+ | === Čo musíte, môžete a nemôžete === | ||
+ | |||
+ | * Musíte | ||
+ | ** Index/ISIC | ||
+ | ** Perá (pre istotu aj viac) | ||
+ | * Môžete | ||
+ | ** Ťahák veľkosti A4 | ||
+ | * Nemôžete | ||
+ | ** Žiadne elektronické pomôcky (vypnúť mobily) | ||
+ | ** Opisovať | ||
+ | ** Iné materiály na stole (čisté papiere dostanete od nás) | ||
+ | |||
+ | === Príklady === | ||
+ | |||
+ | * Bude zhruba 5 príkladov | ||
+ | ** Príklad môže mať niekoľko podpríkladov, ktoré sú zároveň odporúčaným postupom krokov | ||
+ | * Náročnosť zhruba ako rozcvičky | ||
+ | * Dobre si rozvrhnite čas, niektoré úlohy sú ťažšie, iné ľahšie. | ||
+ | |||
+ | == Skúška pri počítači == | ||
+ | |||
+ | * Termíny vypísané v AIS | ||
+ | * Prineste si ISIC a index, písacie potreby na písanie pracovných poznámok, ťahák v rozsahu jedného listu A4. Žiadne ďalšie pomôcky nie sú povolené, nebude k dispozícii ani internet. | ||
+ | * Stretávame sa vždy o 8:50 pred počítačovou halou (H3 alebo M217), kde sa dozviete pokyny a rozsadenie do miestností | ||
+ | * Doobeda: 2 hodiny práca pri počítačoch. | ||
+ | ** Prostredie ako na cvičeniach (Linux, Netbeans, ale môžete používať aj iné nainštalované editory, valgrind a pod.) | ||
+ | ** Budete používať špeciálne skúškové konto, takže nebudete mať k dispozícii žiadne svoje súbory alebo nastavenia. | ||
+ | ** Odovzdávanie prostredníctvom špeciálnej webstránky, slúži súčasne ako záloha. | ||
+ | * Poobede: vyhodnotenie u prednášajúcich, zapisovanie známok. | ||
+ | * Prihlasovanie/odhlasovanie na skúšku do 14:00 deň pred skúškou. | ||
+ | * Aby ste mali šancu úspešne ukončiť predmet, musíte získať aspoň polovicu bodov. | ||
+ | |||
+ | === Príklady === | ||
+ | * Na skúške budete riešiť dva príklady. | ||
+ | * V prvom príklade budete mať za úlohu samostatne napísať celý program, ktorý rieši zadanú úlohu. Typicky bude treba načítať dáta zo súboru, spracovať ich a vypísať výsledok. | ||
+ | ** V tomto príklade môžete použiť ľubovoľný postup. | ||
+ | * V druhom príklade dostanete kostru programu, pričom vašou úlohou bude doprogramovať niektoré funkcie. | ||
+ | ** V tomto príklade môžete mať v zadaní predpísaný spôsob, ako máte niektoré časti naprogramovať. | ||
+ | ** Budú sa vyžadovať aj zložitejšie časti učiva, ako napríklad zoznamy, stromy a rekurzia. | ||
+ | * Nebudeme používať SimpleDraw. | ||
+ | * Môžete používať aj črty C/C++, ktoré sme nebrali. Používajte len štandardné súčasti jazyka. Vaše programy by mali fungovať v prostredí používanom v učebni bez zvláštnych nastavení kompilátora a pod. | ||
+ | |||
+ | ===Hodnotenie=== | ||
+ | * V prvom rade budeme hodnotiť správnosť myšlienky vášho programu. Predtým, ako začnete programovať, si dobre rozmyslite, ako budete úlohu riešiť. | ||
+ | * Ďalej je dôležité, aby sa program dal skompilovať (v štandardnom prostredí Netbeans) a aby správne fungoval na všetkých vstupoch spĺňajúcich podmienky v zadaní. Za nefunkčné programy môžete získať najviac polovicu bodov, aj keď ich myšlienka je správna. | ||
+ | * V druhej úlohe budeme jednotlivé funkcie hodnotiť zvlášť, takže môžete získať čiastočné body, ak ste niekoľko funkcií správne napísali. | ||
+ | * Hodnotiť budeme aj úpravu a štýl programu (komentáre, mená premenných, odsadzovanie, členenie dlhšieho programu na funkcie,...) | ||
+ | * Na tejto skúške nezáleží na rýchlosti vášho programu. Radšej napíšte jednoduchý, prehľadný a hlavne správny pomalší program, než rýchlejší, ale zbytočne zložitý, či nesprávny. | ||
+ | |||
+ | ==Opravné termíny== | ||
+ | * Máte nárok na dva opravné termíny (ale len v rámci termínov, ktoré sme určili). | ||
+ | * Toto sa týka písomky aj skúšky pri počítači. | ||
+ | ** Účasť na opravnom termíne písomky teda tiež vedie k zápisu známky z predmetu v opravnom termíne. | ||
+ | ** Druhý opravný termín písomky môžu písať len študenti, ktorí už majú absolvovanú skúšku na aspoň 50% bodov a majú šancu úspešne ukončiť predmet (termín určíme v prípade potreby). | ||
+ | * Ak sa zúčastníte opravného termínu, strácate body z predchádzajúceho termínu, aj keby ste na opravnom získali menej bodov. | ||
+ | * Ak po skúške pri počítači máte nárok na známu E alebo lepšiu, ale chceli by ste si známku ešte opraviť, musíte sa dohodnúť so skúšajúcimi pred zapísaním známky do indexu. | ||
+ | * Ak po skúške pri počítači ešte opravujete písomku, je potrebné prísť uzavrieť a zapísať známku v termíne určenom vyučujúcimi. | ||
+ | * Ak sa zo závažných dôvodov (napr. zdravotných, alebo konflikt s inou skúškou) nemôžete zúčastniť termínu skúšky alebo písomky, dajte o tom vyučujúcim vedieť čím skôr. | ||
+ | =Cvičenia 12= | ||
+ | * Máme binárny strom, v ktorom má každý vrchol buď dve deti a v dátovom poli uložený znak '#' alebo nemá žiadne deti a v dátovom poli má uložený znak '*'. Keď tento strom vypíšeme v preorder poradí, dostaneme postupnosť ##*#*** Nakreslite, ako vyzerá tento strom. | ||
+ | |||
+ | * Nakreslite binárny vyhľadávací strom, ktorý dostaneme, ak do prázdneho slovníka postupne vkladáme záznamy s kľúčami 3, 4, 1, 2, 5, 6 (v tomto poradí). | ||
+ | |||
+ | * Napíšte funkciu dvojicky(node *root), ktorá spočíta počet všetkých vnútorných vrcholov v binárnom strome s koreňom root takých, že ich ľavé aj pravé dieťa majú v svojom dátovom poli uloženú tú istú hodnotu. | ||
+ | |||
+ | * Napíšte rekurzívnu funkciu, ktorá každému uzlu binárneho stromu prirobí smerník na otca do položky parent typu node *. Funkcia bude mať hlavičku <tt>void assignParent(node *v, node *parent)</tt> kde vrchol parent je otcom vrchola v, alebo NULL ak v je koreň a teda nemá otca. Funkcia doplní otca vrcholu v aj všetkým jeho potomkom, t.j. napr. synom vrchola v nastaví ako otca smerník na v. Použite nasledujúcu štruktúru pre vrchol stromu: | ||
+ | <pre> | ||
+ | struct node { | ||
+ | /* vrchol stromu */ | ||
+ | dataType data; | ||
+ | node * left; /* lavy podstrom */ | ||
+ | node * right; /* pravy podstrom */ | ||
+ | node * parent; /* otec vrcholu */ | ||
+ | }; | ||
+ | </pre> | ||
+ | |||
+ | * Uvažujte binárne stromy pre aritmetické výrazy, v ktorých máme aj premennú x. Tá sa spozná podľa toho, že v položke op je uložený znak 'x' (položka val sa v takýchto vrcholoch nepoužíva). | ||
+ | ** Napíšte funkciu, ktorá dostane nezáporné celé číslo n a zostaví strom, ktorý reprezentuje <math>x^n</math>, pričom použije len vrcholy pre premennú x a pre násobenie. | ||
+ | ** Modifikujte funkciu [[#Prednáška_20#Vyhodnocovanie_v.C3.BDrazu|evaluate z prednášky 20]] tak, aby pracovala aj pre výrazy s premennou x, pričom hodnotu tejto premennej dostane ako parameter, t.j. hlavička bude <tt>double evaluate(node *v, double x) {</tt>. Overte, že ak tútu funkciu spustíte pre váš strom zodpovedajúci <math>x^n</math>, dostanete správny výsledok. | ||
+ | |||
+ | * Napíšte funkciu, ktorá dostane utriedené pole čísel a vytvorí z nich binárny vyhľadávací strom (priamo, bez použitia funkcie insert). Pokúste sa strom vytvoriť tak, aby ľavý a pravý podstrom každého vrcholu obsahovali približne rovnako veľa prvkov. | ||
+ | ** Doporučujeme postupovať rekurzívne, pričom napíšte funkciu s hlavičkou napr. node * vytvorStrom(int a[], int l, int r), ktorá vytvorí strom pre časť poľa a od pozície l po pozíciu r. | ||
+ | =DÚ10= | ||
+ | {{MDU|10|5132}} max. 10 bodov plus 4 body bonus, termín odovzdania pondelok 10.12. o 22:00 | ||
+ | |||
+ | Cieľom tejto úlohy je precvičiť si prácu so stromami. | ||
+ | |||
+ | Vašou úlohou je napísať program, ktorý odkóduje text zapísaný Morseovou abecedou, pričom túto abecedu budete mať uloženú v binárnom strome. Samotnú Morseovu abecedu načítajte zo súboru s názvom morse.txt, ktorý si stiahnite [http://compbio.fmph.uniba.sk/vyuka/prog/data/morse.txt tu]. Na každom riadku súboru je jedno písmeno a za medzerou zápis tohto písmena v Morseovej abecede pomocou znakov bodka a pomlčka. Budeme pracovať len s kódmi pre písmená A až Z. Text na dekódovanie zadá užívateľ ako jeden riadok na konzole, pričom kódy pre jednotlivé písmená sú oddelené medzerou a dve medzery znamenajú medzeru medzi slovami. Napríklad ak užívateľ zadá text <tt>".... . .-.. .-.. --- .-- --- .-. .-.. -.."</tt>, váš program by mal vypísať "HELLO WORLD". Ak text obsahuje neexistujúci kód, program vypíše namiesto takéhoto písmena otáznik, napríklad pre zadaný text "... ------ ..." vypíše "S?S". | ||
+ | |||
+ | Morseovu abecedu si uložte vo forme binárneho stromu, kde každý vrchol môže mať dve deti, jedno nazvané dot (bodka) a druhé dash (čiarka). Určitému kódu zodpovedá vrchol, do ktorého sa dostaneme z koreňa, pričom budeme vždy na bodku pokračovať do dieťaťa nazvaného dot a na pomlčku do dieťaťa nazvaného dash. V tomto vrchole máme ako dáta uložené písmeno, ktoré tomuto kódu zodpovedá. Príklad prvých troch vrstiev stromu je na obrázku nižšie. Písmeno A má kód .- a teda sa k jeho vrcholu dostaneme tak, že z koreňa pôjdeme do dieťaťa označeného dot a odtiaľ do dieťaťa označeného dash. Niektoré vrcholy, napríklad koreň, nezodpovedajú žiadnemu písmenu v Morseovej abecedy a teda v nich namiesto písmena máme uložený otáznik, t.j. znak '?'. Na uloženie stromu použite nasledovnú dátovú štruktúru: | ||
+ | <pre> | ||
+ | struct node { | ||
+ | /* vrchol stromu */ | ||
+ | char letter; /* pismeno vo vrchole alebo '?' */ | ||
+ | node * dot; /* kod predlzeny o bodku */ | ||
+ | node * dash; /* kod predlzeny o ciarku */ | ||
+ | }; | ||
+ | </pre> | ||
+ | |||
+ | [[Image:PROG-DU11-morse.png]] | ||
+ | |||
+ | V svojom programe naprogramujte nasledujúce dve funkcie na základnú prácu s Morseovým kódom, ktoré potom použite vo vašom programe, ktorý načíta Morseovu abecedu zo súboru, zakódovaný text od užívateľa a vypíše výsledok. | ||
+ | |||
+ | <pre> | ||
+ | void addCode(char letter, char code[], node *root) { | ||
+ | /* Do stromu s koreňom root pridá kód uložený v reťazci code | ||
+ | * ktorý zodpovedá písmenu letter. */ | ||
+ | } | ||
+ | </pre> | ||
+ | V tejto funkcii postupujte z koreňa hlbšie podľa zadaného kódu, kým nenanarazíte na nulový smerník. Ďalej vytvárajte nové vrcholy podľa potreby. Keď prídete do vrcholu zodpovedajúcemu celému kódu, uložte do neho dané písmeno. Môže sa stať, že nebudete musieť vytvárať žiadne nové vrcholy, lebo vrchol pre daný kód už bol vytvorený počas spracovávania nejakého dlhšieho kódu. | ||
+ | |||
+ | <pre> | ||
+ | char findLetter(char message[], int &pos, node *root) { | ||
+ | /* V strome s koreňom root nájde písmeno zodpovedajúce kódu, | ||
+ | * ktorý v texte message začína na pozícii pos. | ||
+ | * Toto písmeno vráti ako výsledok funkcie. | ||
+ | * Ak takéto písmeno neexistuje, vráti znak '?'. | ||
+ | * Pozíciu pos posunie na najbližšiu medzeru za kódom alebo za | ||
+ | * posledné písmeno textu, ak za kódom je už koniec textu. */ | ||
+ | </pre> | ||
+ | V tejto funkcii nezabudnite na možnosť, že príslušný kód nie je v strome a vtedy treba vrátiť otáznik, ale aj správne posunúť pos za koniec kódu. | ||
+ | |||
+ | |||
+ | '''Bonusová úloha:''' Na vstupe dostanete od užívateľa text v Morseovej abecede, v ktorom ale chýbajú medzery oddeľujúce kódy pre jednotlivé znaky. Dostanete tiež počet písmen, ktorý je v texte zakódovaný. Napíšte rekurzívne prehľadávanie, ktoré nájde všetky texty danej dĺžky, ktoré majú takýto kód. Napríklad pre text "..." a počet znakov 2 by ste mali dostať možnosti EI a IE. Pre text "......-...-..---" a počet znakov 5, by ste mali dostať 62 možností, z ktorých jedna je HELLO. Bonusovú úlohu odovzdajte v tom istom programe ako základ domácej úlohy, pričom program si najskôr vypýta text s medzerami, odkóduje ho a potom si ešte vypýta text bez medzier a počet hľadaných znakov a vypisuje všetky možnosti. | ||
+ | =Prednáška 25= | ||
+ | Na tejto prednáške si stručne ukážeme niektoré črty jazykov C a C++, ktoré sme počas semestra nepreberali. Nebudeme preberať väčšie detaily; cieľom je, aby ste neboli príliš prekvapení pri štúdiu existujúcich programov, resp. poskytnúť inšpiráciu pre ďalšie samoštúdium. | ||
+ | |||
+ | Tento materiál nebude vyžadovaný na skúške a ani Vám neodporúčame tieto črty jazyka používať, ak ste sa s nimi dostatočne pred skúškou neoboznámili. Z dnešného prehľadu vynecháme objektovo-orientované programovanie v jazyku C++. Objektovo-orientovanému programovaniu (v jazyku Java) sa budeme venovať budúci semester. | ||
+ | |||
+ | ==Organizačné poznámky== | ||
+ | * Konzultačné hodiny | ||
+ | ** 11.12.2012 9:50-11:00 v M263 | ||
+ | ** 14.12.2012 13:00-14:00 v M163 | ||
+ | ** 7.1.2013 13:00-14:00 v M163 | ||
+ | |||
+ | ==Jazyk C== | ||
+ | * Jazyk C existuje v rôznych verziách. | ||
+ | * V starších verziách nefungujú mnohé veci z jazya C++, ktoré sme bežne používali, napr. komentáre vo forme //, všetky deklarácie premenných musia byť na začiatku funkcie a pod. | ||
+ | |||
+ | ===Ďalšie typy premenných=== | ||
+ | * Celé čísla: short int, long int, unsigned int, ... | ||
+ | ** Veľkosť jednotlivých typov závisí od kompilátora platformy | ||
+ | * Desatinné čísla: float (menej presný ako double) | ||
+ | * V staršom C-čku nie je bool, používa sa int, ktorý ma hodnotu 0 pre false a nenulovú (napr. 1) pre true. | ||
+ | * Zložený typ union: v tom istom mieste v pamäti môže byť jedna z alternívnych premenných, napr. pri artimetickom strome by sme mohli uložiť buď smerníky na deti, alebo hodnotu v liste a ušetriť tak trochu pamäti | ||
+ | * Typ enum: vymenujeme možné hodnoty, tie sa stanú celočíselnými konštantami: enum farby {biela, cierna, cervena}; | ||
+ | |||
+ | ===Operátory=== | ||
+ | Okrem operátorov, ktoré sme bežne používali, existuje niekoľko ďalších, napríklad: | ||
+ | * Bitové operátory pracujú s celým číslom ako s poľom bitov (vhodnejšie sú unsigned typy): | ||
+ | ** << a >> cyklicky posúvajú bity doľava a doprava, zodpovedajú násobeniu a deleniu mocninami dvojky | ||
+ | ** & (and po bitoch), | (or po bitoch), ^ (xor po bitoch), ~ (negácia po bitoch) | ||
+ | * Ternárny operátor ?: má tvar (podmienka)?(hodnota pre true):(hodnota pre false), napr. | ||
+ | cout << x << " je " << ((x%2==0) ? "parne" : "neparne") << endl; | ||
+ | * Pozor na rozdiel medzi a[i++]=0 a a[++i]=0, prehľadnejšie použiť dva príkazy: a[i]=0; i++ alebo i++; a[i] = 0; | ||
+ | |||
+ | ===Príkaz do-while=== | ||
+ | |||
+ | Nasledujúce dva spôsoby písania cyklu sú viac-menej ekvivalentné: | ||
+ | <pre> | ||
+ | do { | ||
+ | prikazy; | ||
+ | } while(podmienka) | ||
+ | |||
+ | while(true) { | ||
+ | prikazy; | ||
+ | if(!podmienka) break; | ||
+ | } | ||
+ | </pre> | ||
+ | ===Makrá a konštanty=== | ||
+ | * V C-čku nie sú klasické konštanty, robia sa pomocou makier. Nasledujúce dva riadky majú podobný význam: | ||
+ | <pre> | ||
+ | #define MAXN 100 | ||
+ | const int MAXN=100; | ||
+ | </pre> | ||
+ | * Okrem konštánt môžeme definovať aj zložitejšie makrá s parametrami: | ||
+ | <pre> | ||
+ | /* definicia makra: */ | ||
+ | #define MIN(X,Y) ((X) < (Y) ? (X) : (Y)) | ||
+ | |||
+ | /* priklad pouzitia: */ | ||
+ | cout << MIN(a*a, b+5); | ||
+ | /* preprocesor dosadi, dostane: */ | ||
+ | cout << ((a*a) < (b+5) ? (a*a) : (b+5)); | ||
+ | </pre> | ||
+ | * Treba dať kopu zátvoriek, aby nedošlo k interakcii s okolím použitia príkazu max | ||
+ | |||
+ | ===Delenie programu na súbory=== | ||
+ | * Väčší program chceme rozdeliť na viac súborov | ||
+ | * Chceme vytvárať a používať vlastné knižnice - skupiny funkcií s podobným účelom | ||
+ | ** Napríklad knižnica implementujúca funkcie pracujúce so zásobníkom | ||
+ | * Knižnicu rozdelíme na dva súbory, napr. stack.h a stack.c resp. stack.cpp | ||
+ | * V hlavičkovom súbore (header file) zadeklarujeme funkcie, ale neuvádzame ich kód, napr.: | ||
+ | <pre> | ||
+ | typedef int dataType; | ||
+ | struct stack { | ||
+ | int top; /* pozicia vrchného prvku zásobníka */ | ||
+ | dataType *items; /* pole prvkov */ | ||
+ | }; | ||
+ | void init(stack &s); | ||
+ | bool isEmpty(stack &s); | ||
+ | void push(stack &s, dataType data); | ||
+ | dataType pop(stack &q); | ||
+ | </pre> | ||
+ | * Programy, ktoré chcú použiť stack, použijú include na tento súbor | ||
+ | <pre> | ||
+ | #include "stack.h" | ||
+ | </pre> | ||
+ | * V súbore stack.cpp uvedieme kód funkcií, napr. | ||
+ | <pre> | ||
+ | #include "stack.h" | ||
+ | const int maxN = 100; | ||
+ | void init(stack &s) { | ||
+ | s.top = -1; | ||
+ | s.items = new dataType[maxN]; | ||
+ | } | ||
+ | ... | ||
+ | </pre> | ||
+ | * Všimnite si, že v include dávame meno štandardných knižníc v <>, našich vlastných v "" | ||
+ | * Pri štandardných knižniciach sa v C-čku používa prípona h, v C++ sa namiesto toho väčšinou pridá c na začiatok (že je to knižnica z čistého C) | ||
+ | ** Napr. <cmath> vs. <math.h> | ||
+ | * Ako zabrániť, aby sa vložilo include viackrát? | ||
+ | ** <tt>#ifndef IDENTIFIKATOR #define IDENTIFIKATOR ... #endif</tt> | ||
+ | ** Preprocesor umožňuje okrem toho aj ďalšie podmienené príkazy <tt>#if VYRAZ ... #else ... #endif</tt> alebo <tt>#ifdef IDENTIFIKATOR ... #else ... #endif</tt> | ||
+ | |||
+ | ===C nemá posielanie parametrov referenciou=== | ||
+ | * ... používame teda smerníky | ||
+ | <pre> | ||
+ | void swap(int &a, int &b) { | ||
+ | int tmp = a; | ||
+ | a = b; | ||
+ | b = tmp; | ||
+ | } | ||
+ | |||
+ | void swap(int *a, int *b) { | ||
+ | int tmp; | ||
+ | tmp = *a; | ||
+ | *a = *b; | ||
+ | *b = tmp; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Zopár užitočných funkcií=== | ||
+ | |||
+ | '''Hľadanie v reťazcoch''' | ||
+ | * strstr(text, vzorka) vracia smerník na char | ||
+ | ** NULL ak sa vzorka nenachádza v texte, smerník na začiatok prvého výskytu inak | ||
+ | ** pozíciu výskytu zistíme smerníkovou aritmetikou: | ||
+ | <pre> | ||
+ | char *text, *vzorka; | ||
+ | char *where = strstr(text, vzorka); | ||
+ | if(where != NULL) { | ||
+ | int position = where - text; | ||
+ | } | ||
+ | </pre> | ||
+ | * Ako by ste spočítali počet výskytov vzorky v texte? | ||
+ | * Podobne strchr hľadá prvý výskyt znaku v texte | ||
+ | |||
+ | '''Alokácia pamäte''' | ||
+ | * V C-čku sa nepoužíva new a delete, resp. new[] a delete[] | ||
+ | * Pamäť sa alokuje funkciou malloc, ktorá alokuje kus pamäte s daným počtom bajtov | ||
+ | ** Ak sa nepodarilo, vráti NULL | ||
+ | ** Inak vrati pointer na void, treba pretypovať | ||
+ | ** Veľkosť spočítame operátorom sizeof | ||
+ | <pre> | ||
+ | #include <stdlib.h> | ||
+ | |||
+ | /* vytvorime pole 100 int-ov */ | ||
+ | int *a = (int *)malloc(sizeof(int) * 100); | ||
+ | /* odalokujeme pole a */ | ||
+ | free(a); | ||
+ | </pre> | ||
+ | |||
+ | '''Triedenie''' | ||
+ | * Funkcia qsort z knižnice stdlib.h | ||
+ | * Dostane pole, počet jeho prvkov, veľkosť každého prvku a funkciu, ktorá porovná dva prvky | ||
+ | ** Funkciu teda posielame ako parameter | ||
+ | ** Táto porovnávacia funkcia dostane smerníky na dva prvky v type void * | ||
+ | ** Vráti záporné číslo, ak prvý prvok je menší, nulu, ak sú rovnaké a kladné číslo, ak prvý je väčší | ||
+ | * Ak si napíšeme porovnávaciu funkciu, môžeme triediť prvky hocijakého typu | ||
+ | <pre> | ||
+ | int compare (const void * a, const void * b) { | ||
+ | return (*(int*)a - *(int*)b); | ||
+ | } | ||
+ | int a[] = {5, 3, 2, 4, 1}; | ||
+ | qsort (a, 5, sizeof(int), compare); | ||
+ | </pre> | ||
+ | * Podobne je aj funkcia bsearch na binárne vyhľadávanie v striedenom poli | ||
+ | |||
+ | ==Jazyk C++== | ||
+ | ===Generické funkcie=== | ||
+ | * Často chceme napísať algoritmus, ktorý by mohol fungovať veľa rôznych typoch | ||
+ | * Napr. triediť môžeme celé alebo desatinné čísla, reťazce, zložitejšie štruktúry s určitým kľúčom a pod. | ||
+ | * Funkcia qsort nám to umožňuje, ale musíme sa zapodievať veľkosťami a pretypovaním, kde sa dajú ľahko narobiť chyby. | ||
+ | * V C++ sa dajú písať funkcie, ktoré majú typ ako parameter: | ||
+ | <pre> | ||
+ | template <class T> | ||
+ | T max (T a, T b) { | ||
+ | return (a>b)? a : b; | ||
+ | } | ||
+ | |||
+ | int i=3; | ||
+ | int j=5; | ||
+ | int k=max<int>(i,j); | ||
+ | </pre> | ||
+ | |||
+ | ===Preťaženie operátorov=== | ||
+ | * Pre naše typy si vieme zadefinovať nové operátory | ||
+ | * Napr. dve mená porovnávame najskôr podľa priezviska, pri zhode podľa krstného mena | ||
+ | <pre> | ||
+ | struct meno { | ||
+ | char *krstne, *priezvisko; | ||
+ | }; | ||
+ | |||
+ | bool operator < (meno x, meno y) { | ||
+ | return strcmp(x.priezvisko, y.priezvisko)<0 | ||
+ | || strcmp(x.priezvisko, y.priezvisko)==0 | ||
+ | && strcmp(x.krstne, y.krstne)<0; | ||
+ | } | ||
+ | </pre> | ||
+ | * Podobne môžeme zadefinovať napr. operátor + a * pre náš struct reprezentujúci trebárs polynómy alebo komplexné čísla... | ||
+ | * cin << "Hello" používa preťažený operátor << ak na ľavej strane je stream a na pravej reťazec | ||
+ | |||
+ | ===Stringy=== | ||
+ | |||
+ | * Okrem klasických C-čkových reťazcov môžeme použiť aj C++ typ string. | ||
+ | * Majú elegantnejšie používanie, sami si určujú potrebnú veľkosť pamäte | ||
+ | * Sú to objekty, do funkcií odovzdávame cez & | ||
+ | * Jednotlivým znakom pristupujeme pomocou [] (ako u polí) alebo pomocou metódy <tt>at</tt> | ||
+ | |||
+ | <pre> | ||
+ | #include <string> | ||
+ | using namespace std; | ||
+ | |||
+ | int main(void) { | ||
+ | |||
+ | char cstr[100] = "Ahoj\n"; | ||
+ | string str = "Ako sa mas?\n"; | ||
+ | string str2; | ||
+ | |||
+ | /* mozeme priradovat konstantne retazce, C-ckove retazce (polia znamkov) | ||
+ | aj C++ stringy. */ | ||
+ | str2 = "Ahoj\n"; | ||
+ | str2 = cstr; | ||
+ | str2 = str; | ||
+ | /* meranie dlzky */ | ||
+ | cout << "Dlzka je: " << str.length() << endl; | ||
+ | |||
+ | /* Funguje porovnanie pomocou ==, !=, <,... | ||
+ | * (bud dvoch C++ stringov, alebo C++ stringu a C stringu) | ||
+ | * Znamienko + znamená zreťazenie. */ | ||
+ | str2 = cstr + str; | ||
+ | str2.push_back('X'); | ||
+ | str2.push_back('\n'); | ||
+ | cout << str2; | ||
+ | |||
+ | if (str < str2) { | ||
+ | cout << "Prvy je skor" << endl; | ||
+ | } else if (str == str2) { | ||
+ | cout << "Rovnaju sa" << endl; | ||
+ | } else { | ||
+ | cout << "Druhy je skor" << endl; | ||
+ | } | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Pomocou funkcie <tt>c_str()</tt> vieme získať zo stringu premennú typu <tt>const char*</tt> | ||
+ | |||
+ | ===Streamy=== | ||
+ | |||
+ | * Každý textový súbor môžeme chápať ako postupnosť znakov (podobne ako vstup/výstup z konzoly). Teda aj textový súbor je vlastne stream, ktorý môžeme postupne (zľava doprava) čítať alebo do neho zapisovať. | ||
+ | * Textové súbory teda môžeme načítávať alebo zapisovať pomocou analógie k <tt>cin</tt> a <tt>cout</tt> | ||
+ | * Budeme využívať typy a funkcie zadefinované v knižnici fstream. | ||
+ | |||
+ | <pre> | ||
+ | #include <fstream> | ||
+ | |||
+ | using namespace std; | ||
+ | |||
+ | int main (void) { | ||
+ | ofstream o; | ||
+ | o.open ("Test.txt"); // otvorenie súboru | ||
+ | o << 'z'; // zapíše 1 znak | ||
+ | o << "Toto je retazec"; // zapíše reťazec znakov (= postupnosť znakov) | ||
+ | o << endl; // 1 znak = nový riadok – znak \ má špeciálny význam | ||
+ | o << "Text"; // v súbore bude toto na začiatku nového riadka | ||
+ | o << endl; | ||
+ | o << 10*32 ; // môžeme zapísať hodnotu výrazu ako reťazec znakov | ||
+ | o << endl; | ||
+ | o << "10*32=" << 10*32 << endl; // zapíše sa zľava doprava | ||
+ | o << "1 rovna sa 4? " << (1==4) << endl; // pozor na priority operátorov ... 1==4 musí byť v zátvorkách !!! | ||
+ | o.close (); // zatvorenie súboru | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * ofstream tiež umožňuje formátovanie výstupu napríklad pomocou modifikátorov <tt>fixed,setprecision(),setfill(),setw()</tt> | ||
+ | |||
+ | * Podobne môžeme otvoriť aj súbor, z ktorého budeme čítať vstup. V príklade načítame pole celých čísel. | ||
+ | |||
+ | <pre> | ||
+ | #include <fstream> | ||
+ | #include <iostream> | ||
+ | |||
+ | using namespace std; | ||
+ | const int MAX=100; | ||
+ | |||
+ | int main (void) { | ||
+ | ifstream f; | ||
+ | int pocet, A[MAX]; | ||
+ | |||
+ | f.open ("VSTUP.txt"); | ||
+ | if (f.fail ()) return 1; // return = návrat z funkcie – koniec programu | ||
+ | f >> pocet; | ||
+ | for (int i=0; i<pocet; i++) { | ||
+ | f >> A[i]; | ||
+ | } | ||
+ | |||
+ | for (int i=0; i<pocet; i++) { | ||
+ | cout<< A[i] << " "; | ||
+ | } | ||
+ | f.close(); | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Pri načítaní sme sa už stretli s funkciou f.fail(), ktorá vrátila logickú hodnotu pravda ak vznikla chyba (väčšinou pri otovrení neexistujúceho súboru). Druhou možnosťou je testovať správne otvorenie pomocou testovania premennej typu ofstream alebo ifstream. Je to ekvivalentné (snáď skoro vždy) funkcii fail. | ||
+ | |||
+ | <pre> | ||
+ | ifstream fin("VSTUP.txt"); // input | ||
+ | if(!fin) { | ||
+ | cout << "Cannot open VSTUP.txt file.\n"; | ||
+ | return 1; | ||
+ | } | ||
+ | |||
+ | ofstream fout("VYSTUP.txt"); // output, normal file | ||
+ | if(!fout) { | ||
+ | cout << "Cannot open VYSTUP.txt file.\n"; | ||
+ | return 1; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Testovanie konca súboru môžeme robiť pomocou funkcie eof | ||
+ | |||
+ | <pre> | ||
+ | ifstream fin("VSTUP.txt"); // input | ||
+ | char c; | ||
+ | |||
+ | while(!fin.eof()) { | ||
+ | fin>>c; | ||
+ | cout<<c; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Pre streamy je praktická funkcia getline, ktorá načíta zo streamu celý riadok. Nasledovný príklad spočíta v jednotlivých riadkoch počet bodiek. | ||
+ | |||
+ | <pre> | ||
+ | int main(void){ | ||
+ | ifstream f("VSTUP.txt");; | ||
+ | string line; | ||
+ | int poc; | ||
+ | |||
+ | while (getline(f,line)){ | ||
+ | poc=0; | ||
+ | for (int i=0; i<line.length(); i++){ | ||
+ | if (line[i]=='.') poc++; | ||
+ | } | ||
+ | cout << poc <<endl; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | ===Niektoré užitočné štruktúry=== | ||
+ | STL (standard template library) | ||
+ | * Veľká knižnica rôznych dátových štruktúr | ||
+ | * Manuál napr. tu: http://www.sgi.com/tech/stl/ | ||
+ | |||
+ | * Vector - pole s dynamickou alokáciou pamäte, čo znamená, že ak by priestor, ktorý si vyhradil nestačil vyrieši si to sám. | ||
+ | ** Deklarovať vector môžeme jedným z nasledujúcich spôsobov | ||
+ | <pre> | ||
+ | vector<int> A; //vytvorí pole celých čísel | ||
+ | vector<int> A(10); //vytvorí pole 10 celých čísel, ktoré všetky nastaví na default hodnotu | ||
+ | vector<int> A(5,1); //vytvorí pole 5 celých čísel, ktoré nastaví na 1 | ||
+ | </pre> | ||
+ | ** Prístup k prvkom vectora je možný dvoma spôsobmi | ||
+ | *** klasicky pomocou A[index] - má podobné problémy ako polia | ||
+ | *** A.at(index) je bezpečnejší spôsob, kedy v prípade indexu mimo rozsahu nebude robiť neplechu | ||
+ | |||
+ | ** Vkladanie do poľa je možné tiež dvomi spôsobmi - ale pozor na miešanie | ||
+ | *** do už vytvoreného miesta (ak sme tak deklarovali vector) pomocou priradenia (ďalší priestor získam pomocou A.resize(nova hodnota)) | ||
+ | *** pomocou A.push_back(x), kedy ako ďalší prvok nastaví x s tým, že o pamäť sa stará sám (veľkosť si potom môžeme zistiť pomocou A.size()) | ||
+ | |||
+ | ** Ako generická dátová štruktúra: | ||
+ | <pre> | ||
+ | vector<int> A; | ||
+ | for (int i=0; i<10; i++){ | ||
+ | A.push_back(i); | ||
+ | } | ||
+ | for (int i=0; i<A.size(); i++){ | ||
+ | cout << A[i] << endl; // alebo A.at(i) | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Štruktúra map implementuje slovník | ||
+ | <pre> | ||
+ | map <string, string> zoznam; | ||
+ | zoznam["Jozko Mrkvicka"] = "02/12345678"; | ||
+ | if(zoznam.count("Jozko Mrkvicka") > 0) { | ||
+ | cout << zoznam["Jozko Mrkvicka"] << endl; | ||
+ | } | ||
+ | </pre> | ||
+ | |||
+ | * Štruktúra deque implementuje zásobník aj rad naraz (double-ended queue) | ||
+ | <pre> | ||
+ | deque <int> a; | ||
+ | a.push_back(0); | ||
+ | a.push_front(1); | ||
+ | cout << a.back() << endl; | ||
+ | cout << a.front() << endl; | ||
+ | a.pop_back(); | ||
+ | a.pop_front(); | ||
+ | </pre> | ||
+ | |||
+ | * Triedenie v knižnici <algorithm> | ||
+ | <pre> | ||
+ | //triedime normalne pole | ||
+ | int A[6] = {1, 4, 2, 8, 5, 7}; | ||
+ | sort(A, A + 6); | ||
+ | |||
+ | //triedime vektor | ||
+ | vector <int> A; | ||
+ | sort(A.begin(), A.end()); | ||
+ | |||
+ | //triedime podla nasej porovnavacej funkcie, napr. podla absolutnej hodnoty | ||
+ | struct cmp { | ||
+ | bool operator()(int x, int y) { return abs(x) < abs(y); } | ||
+ | }; | ||
+ | cmp c; | ||
+ | sort(A.begin(), A.end(), c); | ||
+ | </pre> | ||
+ | =Cvičenia 13= | ||
+ | * Nakreslite lexikografický strom s abecedou {a,b}, do ktorého sme vložili reťazce aba, aaab, baa, bab, ba. Vrcholy, ktoré zodpovedajú niektorému reťazcu zo vstupu zvýraznite dvojitým krúžkom. | ||
+ | |||
+ | * Na [[#Prednáška_23#Zdrojov.C3.BD_k_programu_s_lexikografick.C3.BDm_stromom|prednáške 23]] nájdete ukážkový program pre lexikografický strom. Zmeňte ho tak, aby najskôr načítal zo súboru [http://compbio.fmph.uniba.sk/vyuka/prog/data/dict.txt dict.txt] zoznam anglických slov a uložil ich do stromu. Potom načíta od užívateľa nejaký reťazec a vypíše všetky slová, ktoré na tento reťazec začínajú. Napríklad pre reťazec all vypíše <tt>all allah allegiance allen alley alliance allied allow allowance allowed allowing allude allusion ally</tt>. Skúste pozmeniť alebo využiť funkcie printSubtree a find. Pozor, program predpokladá, že reťazce obsahujú iba veľké písmená anglickej abecedy. Malé písmena zo vstupu zmeníte na veľké funkciou toupper z knižnice cctype. | ||
+ | |||
+ | * Naprogramujte funkciu, ktorá uprace lexikografický strom, t.j. uvoľní všetky vrcholy, ktoré nemajú žiaden vrchol, kde isWord je pravdivé, svojom podstrome. | ||
+ | |||
+ | * Vyskúšajte si vyriešiť [[#Zimný_semester,_test_a_skúška|ukážkový prvý príklad na skúšku]], prípadne niektoré ukážkové príklady na písomku. |
Aktuálna revízia z 09:32, 7. október 2013
Táto stránka obsahuje archívnu kópiu materiálov zo školského roku 2012/13. Niektoré odkazy nemusia byť funkčné. V ďalších školských rokoch sa obsah predmetu môže mierne alebo výraznejšie meniť.
- #Zimný semester, úvodné informácie
- #Zimný semester, pravidlá
- #Zimný semester, test a skúška
- #Netbeans
- #SimpleDraw
Týždeň 17.-23.9. |
Úvod, použitie grafickej knižnice, premenné, podmienky, cyklus for |
#Prednáška 1 · #Prednáška 2 · #Cvičenia 1 · #DÚ0 |
Týždeň 24.-30.9. |
Cykly (for, while), Euklidov algoritmus, funkcie |
#Prednáška 3 · #Prednáška 4 · #Cvičenia 2 · #DÚ1 · #Pokročilá DÚ1 |
Týždeň 1.-7.10. |
Polia, struct, Eratostenovo sito, polynómy, jednoduché triedenia |
#Prednáška 5 · #Prednáška 6 · #Cvičenia 3 · #DÚ2 |
Týždeň 8.-14.10. |
Binárne vyhľadávanie, zložitosť, znaky, reťazce |
#Prednáška 7 · #Prednáška 8 · #Cvičenia 4 · #DÚ3 |
Týždeň 15.-21.10. |
Rekurzia, prehľadávanie s návratom |
#Prednáška 9 · #Prednáška 10 · #Cvičenia 5 · #DÚ4 · #Pokročilá DÚ2 |
Týždeň 22.-28.10. |
Mergesort, quicksort, medián, smerníky |
#Prednáška 11 · #Prednáška 12 · #Cvičenia 6 · #DÚ5 |
Týždeň 29.10.-4.11. |
Súbory, vektor |
#Prednáška 13 · #Prednáška 14 · #Cvičenia 7 · #DÚ6 · #Pokročilá DÚ3 |
Týždeň 5.-11.11. |
Matica, spájaný zoznam |
#Prednáška 15 · #Prednáška 16 · #Cvičenia 8 |
Týždeň 12.-18.11. |
Slovník, zásobník, rad |
#Prednáška 17 · #Prednáška 18 · #Cvičenia 9 · #DÚ7 |
Týždeň 19.-25.11. |
Vyfarbovanie, aritmetické výrazy |
#Prednáška 19 · #Prednáška 20 · #Cvičenia 10 · #DÚ8 · #Pokročilá DÚ4 |
Týždeň 26.11.-2.12. |
Aritmetický výraz ako strom, binárne stromy, binárne vyhľadávacie stromy |
#Prednáška 21 · #Prednáška 22 · #Cvičenia 11 · #DÚ9 |
Týždeň 3.-9.12. |
Lexikografické stromy, opakovanie, zhrnutie, príprava na skúšku a písomku |
#Prednáška 23 · #Prednáška 24 · #Cvičenia 12 · #DÚ10 |
Týždeň 10.-16.12. |
Nepreberané črty jazykov C a C++ |
#Prednáška 25 · #Cvičenia 13 |
Zimný semester, úvodné informácie
Rozvrh
- Prednášky: pondelok 9:00 F1-328 a utorok 9:50 F1-109
- Cvičenia:
- 1i1 (prvý krúžok) pondelok 10:40 M-217 Martin Králik
- 1i2 (druhý krúžok) pondelok 12:20 M-217 Martin Králik
- 1i3 (tretí krúžok) pondelok 12:20 M-218 Jaro Budiš
- Rozdelenie na krúžky [1]
- Nepovinné cvičenia: pondelok 14:50 M-218 (pre tých, ktorí si potrebujú učivo lepšie precvičiť alebo majú ďalšie otázky)
Poznámka: cvičenia z predmetu 1-INF-126 Programovanie (1) sú v pondelok o 10:40 v M-IX
Vyučujúce
- RNDr. Jana Katreniaková PhD., miestnosť M-263,
- Konzultácie pondelok 13:10-14:00 alebo po dohode e-mailom
- Mgr. Broňa Brejová, PhD., miestnosť M-163,
- Konzultácie pondelok 14:00-15:00 alebo po dohode e-mailom
Cvičiaci
Voľba verzie programovania
- Tento predmet (1-INF-127 Programovanie (1) v C/C++) je určený študentom prvého ročníka bakalárskeho študijného programu Informatika a spolu s predmetom 1-INF-166 Programovanie (2) v Jave v letnom semestri tvoria alternatívu k povinným predmetom 1-INF-126 Programovanie (1) a 1-INF-165 Programovanie (2).
- Každý študent sa môže rozhodnúť, či absolvuje 1-INF-127 a 1-INF-166 alebo 1-INF-126 a 1-INF-165. Nie je však možné absolvovať obe verzie programovania ani sa po prvom semestri presunúť z jednej verzie do druhej.
- Predmety 1-INF-126 a 1-INF-165 sa vyučujú v jazyku FreePascal a majú na našej fakulte už dlhú tradíciu. Predmety 1-INF-127 a 1-INF-166 budú vyučované v jazykoch C resp. C++ a Java. Výhodou je, že tieto jazyky využijete aj v ďalších nadväzujúcich predmetoch (Systémové programovanie, Programovanie (3) a podobne) a sú to aj jazyky využívané v praxi. Nevýhodu je, že sa po prvom semestri budete musieť preorientovať na iný jazyk.
Ciele predmetu 1-INF-127
- Naučiť sa algoritmicky uvažovať, písať kratšie programy a hľadať v nich chyby, porozumieť existujúcemu kódu
- Oboznámiť sa so základnými programovými a dátovými štruktúrami jazyka C resp. C++, nie je však nutne so všetkými črtami týchto jazykov
- Cykly, podmienky, premenné a ich typy, funkcie a odovzdávanie parametrov, polia, smerníky, reťazce, súbory
- Oboznámiť sa s niektorými základnými algoritmami a dátovými štruktúrami
- Triedenia, spájané zoznamy, hašovacie tabuľky, stromy, aritmetické výrazy, rad a zásobník, rekurzia, prehľadávanie, vyfarbovanie
- Aj štruktúry, ktoré sú hotové v C++ knižniciach, si budeme programovať sami, aby sme videli, čo sa za nimi skrýva
Literatúra
- Predmet sa nebude striktne riadiť žiadnou učebnicou. Prehľad preberaných tém a stručné poznámky nájdete na stránke predmetu, doporučujeme Vám si na prednáškach a cvičeniach robiť vlastné poznámky.
- Pri štúdiu Vám môžu pomôcť knihy o jazykoch C a C++, o programovaní všeobecne a o algoritmoch preberaných na prednáške. Tu je výber z vhodných titulov, ktoré sú k dispozícii na prezenčné štúdium vo fakultnej knižnici:
- Prokop: Algoritmy v jazyku C a C++ praktický pruvodce, Grada 2008, I-INF-P-26
- Sedgewick: Algorithms in C. Parts 1-4 I-INF-S-43/I-IV
- Kochan: Programming in C, 2005 D-INF-K-7a
- Referenčnú príručku k jazyku C++ nájdete napríklad na tejto webstránke: http://cplusplus.com/
Priebeh semestra
- Na prednáškach budeme preberať obsah predmetu. Prednášky budú štyri vyučovacie hodiny do týždňa.
- Cvičenia budú dve vyučovacie hodiny do týždňa v počítačovej učebni a ich cieľom je aktívne si precvičiť učivo. Na začiatku cvičenia bude krátka diskusia o prípadných nejasnostiach ohľadom materiálu z minulého cvičenia. Potom nasleduje rozcvička (krátky test) písaný na papieri. Ďalšou časťou cvičenia je precvičovanie príkladov k predchádzajúcim prednáškam (spoločne alebo individuálne). Na konci cvičenia spravidla budete môcť začať pracovať na domácej úlohe, pričom cvičiaci Vám v prípade potreby odpovie na Vaše otázky.
- Domáce úlohy navrhujeme tak, aby Vám ich riešenie pomohlo osvojiť si a precvičiť si učivo, čím sa okrem iného pripravujete aj na záverečnú skúšku. Okrem tohto sú za domáce úlohy body do záverečného hodnotenia. Najviac sa naučíte, ak sa Vám domácu úlohu podarí samostatne vyriešiť, ale ak sa vám to napriek vášmu usilu nedarí, neváhajte sa spýtať o pomoc prednášajúcich alebo cvičiacich. Možno s malou radou od nás sa Vám podarí úlohu spraviť. Treba však na domácej úlohe začať pracovať v predstihu, aby ste nás v prípade problémov stihli kontaktovať.
- Cieľom vyučujúcich tohto predmetu je vás čo najviac naučiť, ale musíte aj vy byť aktívni partneri. Ak Vám na prednáške alebo cvičení nie je niečo jasné, spýtajte sa. Môžete nám klásť tiež otázky počas našich konzultačných hodín alebo emailom. Ak sa dostanete do väčších problémov s plnením študijných povinností, poraďte sa s vyučujúcimi alebo s tútorom, ako tieto problémy riešiť.
- 40% známky dostávate za prácu cez semester, preto netreba nechávať štúdium učebnej látky až na skúškové obdobie.
Zimný semester, pravidlá
Známkovanie
- 20% známky je na základe rozcvičiek, ktoré sa píšu na (takmer) každom cvičení
- 20% známky je za domáce úlohy
- 30% známky je za záverečný písomný test
- 30% známky je za praktickú skúšku pri počítači
Pozor, body získavané za jednotlivé príklady nezodpovedajú priamo percentám záverečnej známky. Body za každú formu známkovania sa preváhujú tak, aby maximálny získateľný počet zodpovedal váham uvedených vyššie. Úlohy označené ako bonusové sa nerátajú do maximálneho počtu získateľných bodov v danej aktivite.
Stupnica
- Na úspešné absolvovanie predmetu je potrebné splniť nasledovné tri podmienky:
- Získať aspoň 50% bodov v celkovom hodnotení
- Získať aspoň 50% zo záverečného písomného testu
- Získať aspoň 50% zo skúšky
- Ak niektorú z týchto troch podmienok nesplníte, dostávate známku Fx.
- V prípade úspešného absolvovania predmetu získate známku podľa bodov v celkovom hodnotení takto:
- A: 90% a viac, B:80...89%, C: 70...79%, D: 60...69%, E: 50...59%
Rozcvičky
- Rozcvičky sú krátke testy (cca 15 minút), ktoré sa píšu na začiatku (takmer) každého cvičenia. Za každú rozcvičku môžete získať najviac 5 bodov.
- Pri rozcvičke môžete použiť ľubovoľné písomné materiály (poznámky, knihy,...), nie však počítače a iné elektronické pomôcky. Počas rozcvičky nie je možné zdieľať materiály so spolužiakmi.
- Ak bude počas semestra celkovo N rozcvičiek, do výslednej známky sa vám zaráta iba N-2 najlepších, t.j. dve rozcvičky, na ktorých ste získali najmenej bodov (alebo ste sa ich ani nezúčastnili) sa vám škrtajú.
Domáce úlohy
- Domáce úlohy budú vypisované takmer každý týždeň. Maximálny počet bodov za domácu úlohu bude uvedený v zadaní a bude sa pohybovať spravidla v rozsahu 10-20 bodov podľa náročnosti úlohy.
- Domáce úlohy treba odovzdať elektronicky pomocou systému Moodle do termínu určeného v zadaní. Neskoršie odovzdané úlohy nebudú akceptované.
- Niektoré týždne budú vypísané aj špeciálne bonusové domáce úlohy, za ktoré môžete získať body navyše alebo dohnať body stratené na iných domácich úlohách. Bonusové úlohy sú však náročnejšie. Body za bonusovú úlohu môžete dostať iba ak máte základnú časť úlohy správne.
- Program, ktorý odovzdáte ako domácu úlohu by mal byť skompilovateľný a spustiteľný v prostredí používanom na cvičeniach. Budeme kontrolovať správnosť celkovej myšlienky, správnosť implementácie ale body môžete stratiť aj za neprehľadný štýl.
Záverečný písomný test
- Záverečný test bude trvať 90 minút a bude obsahovať úlohy podobné tým, ktoré sa riešili na cvičeniach.
- Riadny termín testu sa bude konať v prvom týždni skúškového obdobia, opravný termín neskôr počas skúškového obdobia.
- Pri teste nemôžete používať žiadne pomocné materiály (písomné ani elektronické) okrem povoleného ťaháku v rozsahu jedného listu formátu A4 s ľubovoľným obsahom na oboch stranách.
Skúška
- Na skúške budete riešiť 2 úlohy pri počítači v celkovom trvaní 2-3 hodiny.
- Na skúške nemôžete používať žiadne pomocné materiály okrem povoleného ťaháku v rozsahu jedného listu formátu A4 s ľubovoľným obsahom na oboch stranách. Nebude k dispozícii ani internet. Budete používať rovnaké programátorské prostredie ako na cvičeniach.
- Po skončení skúšky sa koná krátky ústny pohovor s vyučujúcimi, počas ktorého sa prediskutujú programy, ktoré ste odovzdali a uzavrie sa vaša známka.
- Opakovanie skúšky sa riadi študijným poriadkom fakulty.
Opravné termíny
- Máte nárok na dva opravné termíny (ale len v rámci termínov, ktoré sme určili).
- Toto sa týka písomky aj skúšky pri počítači.
- Účasť na opravnom termíne písomky teda tiež vedie k zápisu známky z predmetu v opravnom termíne.
- Druhý opravný termín písomky môžu písať len študenti, ktorí už majú absolvovanú skúšku na aspoň 50% bodov a majú šancu úspešne ukončiť predmet (termín určíme v prípade potreby).
- Ak sa zúčastníte opravného termínu, strácate body z predchádzajúceho termínu, aj keby ste na opravnom získali menej bodov.
- Ak po skúške pri počítači máte nárok na známu E alebo lepšiu, ale chceli by ste si známku ešte opraviť, musíte sa dohodnúť so skúšajúcimi pred zapísaním známky do indexu.
- Ak po skúške pri počítači ešte opravujete písomku, je potrebné prísť uzavrieť a zapísať známku v termíne určenom vyučujúcimi.
- Ak sa zo závažných dôvodov (napr. zdravotných, alebo konflikt s inou skúškou) nemôžete zúčastniť termínu skúšky alebo písomky, dajte o tom vyučujúcim vedieť čím skôr.
Opisovanie
- Máte povolené sa so spolužiakmi a ďalšími osobami rozprávať o domácich úlohách a stratégiách na ich riešenie. Kód, ktorý odovzdáte, musí však byť vaša samostatná práca. Je zakázané opisovať kód z literatúry alebo z internetu a ukazovať svoj kód spolužiakom. Domáce úlohy môžu byť kontrolované softvérom na detekciu plagiarizmu.
- Počas rozcvičiek, testov a skúšok môžete používať iba povolené pomôcky a nesmiete komunikovať s žiadnymi osobami okrem vyučujúcich.
- Ak nájdeme prípady opisovania alebo nepovolených pomôcok, všetci zúčastnení študenti získajú za príslušnú domácu úlohu alebo test nula bodov (t.j. aj tí, ktorí dali spolužiakom odpísať). Opakované alebo obzvlášť závažné prípady opisovania budú podstúpené na riešenie dekanovi fakulty.
Neprítomnosť
- Účasť na cvičeniach veľmi silne doporučujeme a v prípade neprítomnosti stratíte body za rocvičky.
- V prípade kratšieho ochorenia alebo iných problémov môžete využiť možnosť, že dve najhoršie rozcvičky sa škrtajú.
- V prípade dlhšieho ochorenia (aspoň dva týždne alebo opakovaná neprítomnosť) alebo iných závažných prekážok sa príďte poradiť s prednášajúcimi o možných riešeniach. Treba tak spraviť čím skôr, nie až spätne cez skúškové. Prineste si potvrdenku od lekára.
Možnosti pre pokročilých programátorov
- Študenti, ktorí už ovládajú väčšiu časť učiva na tento semester, majú možnosť získať známku zmysluplnejším spôsobom, ako písaním ľahkých rozcvičiek a domácich úloh.
Test pre pokročilých
- V druhom týždni semestra sa bude konať nepovinný test pre pokročilých. Príklady na ňom budú podobné ako na záverečnom teste.
- Ak na test prídete a napíšete ho na menej ako 50%, nezískate žiadne výhody (ako keby ste na test ani neprišli).
- V opačnom prípade za každých celých získaných 10% získavate plný počet bodov z jednej rozcvičky. Napr. ak ste získali 59% z testu, dostanete plný počet bodov z prvých 5 rozcvičiek po opravení testu. Tieto body nie je možné presúvať na iné termíny rozcvičiek.
- Navyše si môžete body z testu pre pokročilých nechať uznať ako body zo záverečného testu. Máte však aj možnosť písať záverečný test so spolužiakmi.
Domáce úlohy pre pokročilých
- Namiesto bežných domácich úloh, ktoré budú menšie a odovzdávané skoro každý týždeň, ponúkame aj možnosť riešiť 4 väčšie a ťažšie domáce úlohy pre pokročilých.
- Tieto domáce úlohy môžu vyžadovať aj znalosti nepreberané na prednáškach, ktoré si budete musieť doštudovať z odbornej literatúry.
- Bežné a pokročilé DÚ nie je možné striedať, celý semester teda musíte odovzdávať ten istý typ úloh. Výnimkou je DÚ0, ktorú robia všetci študenti.
- Aby ste mohli namiesto bežných úloh robiť pokročilé, potrebujete povolenie od vyučujúcich. Všetci, čo napíšu test pre pokročilých aspoň na 50%, toto povolenie automaticky majú. Ostatní kontaktujte vyučujúce emailom a popíšte svoje programátorské skúsenosti.
Nepreberané črty jazykov C a C++
- Z jazykov C a C++ uvidíme len malú časť.
- Preberané črty týchto jazykov je potrebné ovládať, pre vlastnú potrebu si však môžete v literatúre doštudovať aj ďalšie užitočné príkazy, knižnice a konštrukty.
- Ak je v zadaní uvedené, aké prostriedky máte použiť, držte sa týchto pokynov.
- V opačnom prípade môžete použiť aj nepreberané črty. Aby ste sa vyhli problémom pri opravovaní, je vhodné ich doplniť vysvetľujúcim komentárom.
- Vždy používajte len štandardné súčasti jazykov C a C++ , nie špeciálne knižnice. (Výnimkou sú samozrejme knižnice poskytnuté vyučujúcimi).
- Vaše programy by mali fungovať v prostredí používanom v učebni bez zvláštnych nastavení kompilátora a pod.
Zimný semester, test a skúška
Na tejto stránke sú informácie týkajúce sa záverečného písomného testu a praktickej skúšky pri počítači v zimnom semestri. Doporučujeme tiež si preštudovať
- pravidlá predmetu
- rady a informácie na prednáške 24
Termíny
Písomný test
- Riadny termín pondelok 17.12. o 10:00 v posluchárni B
- Opravný/náhradný termín utorok 8.1. o 10:00 v akváriu M-VII
Termíny skúšok vždy o 9:00:
- 20.12.
- 10.1.
- 23.1.
- 30.1. (opravný termín)
- 6.2. (2. opravný termín)
Na termín skúšky sa zapisujte v systéme AIS. Ústna časť skúšky sa koná v poobedňajších hodinách ten istý deň.
Ukážkové príklady na písomný test
V texte nižšie je niekoľko príkladov, ktoré sa svojim charakterom a obtiažnosťou podobajú na príklady, aké budú na záverečnej písomke. Tieto ukážkové príklady sú prevažne vybrané z cvičení a prednášok, na skutočnej písomke však budú nové, zatiaľ nepoužité príklady.
- Svoje odpovede si môžete skontrolovať nižšie
- Príklad 1: Zistite, čo vypíše nasledujúca funkcia, ak ju spustíme ako generuj(a, pocet, 0, 2, 3), pričom polia a a pocet majú dĺžku n=3 a obe sú naplnené nulami. Funkcia vypis(a,n) vypíše prvky poľa a.
- Ako musíme funkciu opraviť, aby vypisovala všetky usporiadané n-tice čísel z množiny {0,...,n-1}, v ktorých sa každé číslo opakuje najviac k krát?
void generuj(int a[], int pocet[], int i, int k, int n) { if (i == n) { vypis(a, n); } else { for (int x = 0; x < n; x++) { if (pocet[x]<k) { a[i] = x; pocet[x]++; generuj(a, pocet, i + 1, k, n); } } } }
- Príklad 2: Prepíšte výraz 8 3 4 * + 2 3 + / z postfixovej notácie do bežnej infixovej notácie
- Príklad 3: Prepíšte výraz ((2+4)/(3*5))/(1-2) do postfixovej a prefixovej notácie
- Príklad 4: Vyhodnocujeme výraz 8 3 4 * + 2 3 - / v postfixovej notácii algoritmom z prednášky. Aký bude obsah zásobníka v čase, keď začneme spracovávať znamienko +?
- Príklad 5: Máme zásobník s a rad q, pričom obidve štruktúry uchovávajú dáta typu char. Aký bude ich obsah po nasledujúcej postupnosti príkazov?
init(s); init(q); push(s, 'A'); push(s, 'B'); push(s, 'C'); enqueue(q, pop(s)); enqueue(q, pop(s)); push(s, 'D'); push(s, dequeue(q));
- Príklad 6: Máme binárny strom, v ktorom má každý vrchol buď dve deti a v dátovom poli uložený znak '#' alebo nemá žiadne deti a v dátovom poli má uložený znak '*'. Keď tento strom vypíšeme v preorder poradí, dostaneme postupnosť ##*#*** Nakreslite, ako vyzerá tento strom.
- Príklad 7: Nakreslite binárny vyhľadávací strom, ktorý dostaneme, ak do prázdneho slovníka postupne vkladáme záznamy s kľúčami 3, 4, 1, 2, 5, 6 (v tomto poradí).
- Príklad 8: Nakreslite lexikografický strom s abecedou {a,b}, do ktorého sme vložili reťazce aba, aaab, baa, bab, ba. Vrcholy, ktoré zodpovedajú niektorému reťazcu zo vstupu, zvýraznite dvojitým krúžkom.
- Príklad 9: Uvažujme nasledujúcu rekurzívnu funkciu na vyfarbovanie. Predpokladajme, že a je matica s troma riadkami a troma stĺpcami vyplnená nulami, pričom funkciu spustíme na stredné políčko, t.j. stlpec=riadok=1 a nová farba je tiež 1. V akom poradí vyfarbí políčka matice novou farbou?
void vyfarbi(int **a, int n, int m, int riadok, int stlpec, int farba) { /* prefarbi suvislu jednofarebnu oblast obsahujucu * a[riadok][stlpec] na farbu farba */ if (a[riadok][stlpec] != farba) { int stara_farba = a[riadok][stlpec]; a[riadok][stlpec] = farba; if (riadok > 0 && a[riadok - 1][stlpec] == stara_farba) { vyfarbi(a, n, m, riadok - 1, stlpec, farba); } if (riadok + 1 < n && a[riadok + 1][stlpec] == stara_farba) { vyfarbi(a, n, m, riadok + 1, stlpec, farba); } if (stlpec > 0 && a[riadok][stlpec - 1] == stara_farba) { vyfarbi(a, n, m, riadok, stlpec - 1, farba); } if (stlpec + 1 < m && a[riadok][stlpec + 1] == stara_farba) { vyfarbi(a, n, m, riadok, stlpec + 1, farba); } } }
- Príklad 10: Napíšte funkciu vyhod(linkedList &z), ktorá z jednosmerného spájaného zoznamu vyhodí všetky záznamy, v ktorých má položka data nulovú hodnotu. Pozor, takéto záznamy sa môžu vyskytovať aj na začiatku zoznamu. Vyhodené položky zoznamu treba odalokovať.
- Príklad 11: Napíšte funkciu dvojicky(node *root), ktorá spočíta počet všetkých vnútorných vrcholov v strome s koreňom root takých, že ich ľavé aj pravé dieťa majú v svojom dátovom poli uloženú tú istú hodnotu.
- Príklad 12: Nasledujúci program načíta od užívateľa počet kruhov, zoznam údajov pre jednotlivé kruhy (celočíselné súradnice a polomer), posunie každý kruh o 10 nižšie a zase kruhy vypíše. Doplňte do programu chýbajúce časti vyznačené čiarami (typy premenných, parametre a návratové typy funkcií).
#include <iostream> using namespace std; struct kruh { ________________ }; _______ posunKruh(__________) { k.y-=10; } _______ nacitajKruhy(__________) { _________ a; a = new kruh[n]; for(int i=0; i<n; i++) { cin >> a[i].x >> a[i].y >> a[i].r; } return a; } ______ vypisKruhy(________________) { for(int i=0; i<n; i++) { cout << " " << a[i].x << " " << a[i].y << " " << a[i].r << endl; } } int main(void) { _______ n; _______ a; cin >> n; a = nacitajKruhy(n); for(int i=0; i<n; i++) { posunKruh(a[i]); } vypisKruhy(a, n); delete[] a; }
- Príklad 13: Funkcia jeRastuci kontroluje, či sa hodnoty v spájanom jednosmernom zozname zvyšujú v smere od začiatku ku koncu zoznamu, t.j. či každý prvok je väčší ako jeho predchodca. Ak áno, vráti true, inak vráti false. Doplňte podmienky na podčiarknuté miesta tak, aby funkcia správne fungovala. V prípade, že zoznam je prázdny alebo obsahuje jeden prvok, odpoveď má byť true.
struct item { int data; item* next; }; struct zoznam { item* zaciatok; }; bool jeRastuci(zoznam &z) { item *v = z.zaciatok; while(____________) { if(_____________) { return false; } v = v->next; } return true; }
- Príklad 14: Uvažujme funkciu na triedenie vkladaním uvedenú nižšie.
- Koľkokrát sa vykoná riadok označený (**) na vstupnom poli (5,2,3,4,1)?
- Koľkokrát sa vykoná riadok označený (**) na vstupnom poli dĺžky n, ktoré je celé utriedené okrem toho, že najmenší a najväčší prvok sú vymenené teda (n,2,3,4,...,n-2,n-1,1)? Počet vykonaní zapíšte ako funkciu od dĺžky poľa n.
void insertionSort(int a[], int n) { /* usporiadaj prvky v poli a od najmenšieho po najväčší */ for (int i = 1; i < n; i++) { int prvok = a[i]; int kam = i; while (kam > 0 && a[kam - 1] > prvok) { a[kam] = a[kam - 1]; // (**) kam--; } a[kam] = prvok; } }
Vzorové riešenia ukážkových príkladov na písomný test
- Príklad 1: funkcia vypíše tri trojice: 0 0 1, 0 0 2, 0 1 2. Nevypisuje to čo má, lebo po vynorení z rekurzie nezníži od pocet[x], aj keď hodnota a[i] bude zmenená z x na x+1. Tu je funkcia po oprave:
void generuj(int a[], int pocet[], int i, int k, int n) { if (i == n) { vypis(a, n); } else { for (int x = 0; x < n; x++) { if (pocet[x]<k) { a[i] = x; pocet[x]++; generuj(a, pocet, i + 1, k, n); pocet[x]--; /* pridany prikaz */ } } } }
- Príklad 2: (8+3*4)/(2+3)
- Príklad 3: postfix 2 4 + 3 5 * / 1 2 - / prefix: / / + 2 4 * 3 5 - 1 2
- Príklad 4: na zásobníku budú čísla 8 a 12 (8 je na spodku zásobníka). Číslo 12 vzniklo vynásobením 3 a 4.
- Príklad 5: na zásobníku budú znaky A, D, C (A na spodku zásobníka), v rade bude písmeno B
- Príklad 6:
# / \ # * /\ * # /\ * *
- Príklad 7:
3 / \ 1 4 \ \ 2 5 \ 6
- Príklad 8: (namiesto dvojiteho krúžku používame *)
. / \ / \ / \ a b / \ / a b a* / / / \ a a* a* b* / b*
- Príklad 9: do každého políčka sme vpísali poradové číslo, kedy bude vyfarbené:
3 2 9 4 1 8 5 6 7
- Príklad 10: Jedna možnosť je použiť dvojitý smerník, ktorý môže ukazovať buď na premennú zaciatok v zozname alebo na premennú next v niektorom jeho prvku.
void vyhod(zoznam &z) { /* vytvorime si smernik na miesto, * kde je ulozeny smenrik na dalsi prvok*/ item **smernik = &(z.zaciatok); /* kym nie sme na konci zoznamu */ while((*smernik)!=NULL) { /* dalsi prvok je nula, zmazeme ju a prevesime zvysok zoznamu */ if((*smernik)->data==0) { item *remove = *smernik; (*smernik) = (*smernik)->next; delete remove; } /* dalsi prvok nie je nula, posunieme smernik */ else { smernik = &((*smernik)->next); } } }
Druhá možnosť je použiť dva cykly: jedným mažeme nuly na začiaktu a druhým mažeme nuly vo zvyšku zoznamu.
void vyhod(zoznam &z) { /* vyhadzujeme nuly na zaciatku */ while (z.zaciatok != NULL && z.zaciatok->data == 0) { item * remove = z.zaciatok; z.zaciatok = remove->next; delete remove; } /* node bude ukazovat vzdy na nenulovy prvok, * kontrolujeme prvok za nim */ item * node = z.zaciatok; while (node != NULL && node->next != NULL) { if (node->next->data == 0) { item * remove = node->next; node->next = remove->next; delete remove; } else { node = node->next; } } }
- Príklad 11:
int dvojicky(node *root) { /* prazdny strom neobsahuje dvojicky */ if(root == NULL) return 0; int result = 0; /* ak su deti korena dvojicky, pricitaj 1*/ if(root->left != NULL && root->right != NULL && root->left->data == root->right->data) { result++; } /* spocitaj dvojicky v lavom a pravom podstrome */ result += dvojicky(root->left); result += dvojicky(root->right); return result; }
- Príklad 12:
#include <iostream> using namespace std; struct kruh { int x, y, r; }; void posunKruh(kruh &k) { k.y-=10; } kruh * nacitajKruhy(int n) { kruh * a; a = new kruh[n]; for(int i=0; i<n; i++) { cin >> a[i].x >> a[i].y >> a[i].r; } return a; } void vypisKruhy(kruh *a, int n) { for(int i=0; i<n; i++) { cout << " " << a[i].x << " " << a[i].y << " " << a[i].r << endl; } } int main(void) { int n; kruh * a; cin >> n; a = nacitajKruhy(n); for(int i=0; i<n; i++) { posunKruh(a[i]); } vypisKruhy(a, n); delete[] a; }
- Príklad 13:
bool jeRastuci(zoznam &z) { item *v = z.zaciatok; while (v != NULL && v->next != NULL) { if (v->data >= v->next->data) { return false; } v = v->next; } return true; }
- Príklad 14:
- Čísla 2,3,4 musia preskočiť číslo 5, riadok sa teda pre každé z nich vykoná raz a pre číslo 1 sa vykoná 4 krát, spolu teda 7 krát.
- Čísla 2,3,4,...,n-2,n-1 musia preskočiť číslo n, riadok sa teda pre každé z nich vykoná raz a pre číslo 1 sa vykoná n-1 krát. Spolu sa teda riadok vykoná n-2+n-1=2n-3 krát.
Ukážkové príklady na skúšku pri počítači
Prvý príklad
Vo vstupnom súbore matice.txt sú dve matice celých čísel. Každá matica má na prvom riadku počet riadkov m a počet stĺpcov n. Nasleduje samotná matica v m riadkoch, pričom každý obsahuje n čísel oddelených medzerami. Matice sú oddelené voľným riadkom.
Úlohou je vypísať súčet týchto dvoch matíc. V algebre spravidla sčitujeme matice rovnakého rozmeru, vo výslednej matici C je každé políčko súčtom zodpovedajúcich políčok vo vstupných maticiach A a B. V tomto zadaní ale môžeme mať aj matice rôznych rozmerov. V tom prípade matice najskôr rozšírime na spoločný rozmer. Ak majú napríklad rôzny počet riadkov, doplníme na spodok matice s menším počtom riadkov riadky vyplnené nulami tak, aby mala rovnaký počet riadkov ako druhá matica. Podobne pri rôznom počte stĺpcov pridávame na pravý okraj jednej matice stĺpce vyplnené nulami.
Uvažujme napríklad vstup s maticami rozmerov 2x1 a 1x4:
2 1 5 6 1 4 1 2 3 4
Po rozšírení budú mať obidve matice dva riadky a štyri stĺpce, budú teda vyzerať nasledovne:
- Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle A=\left(\begin{array}{llll} 5 & 0 & 0 & 0 \\ 6 & 0 & 0 & 0 \\ \end{array}\right) \qquad B=\left(\begin{array}{llll} 1 & 2 & 3 & 4 \\ 0 & 0 & 0 & 0 \\ \end{array}\right) }
a ich súčet bude
- Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle C=\left(\begin{array}{llll} 6 & 2 & 3 & 4 \\ 6 & 0 & 0 & 0 \\ \end{array}\right) }
Tento súčet matíc vypíšte do súboru sucet.txt v rovnakom formáte ako matice na vstupe, teda prvý riadok obsahuje rozmery matice a ďalej idú jednotlivé riadky matice s číslami oddelenými medzerami. Nedávajte medzeru pred prvé ani za posledné číslo v riadku. Pre uvedený príklad vstupu teda dostaneme výstup
2 4 6 2 3 4 6 0 0 0
V programe nepoužívajte polia konštantných veľkostí, program by mal vedieť spracovať ľubovoľné dáta, ktoré sa zmestia do pamäte (ak treba, alokujte polia dynamicky alebo použite štruktúry, ktoré menia veľkosť podľa potreby). Môžete predpokladať, že vstupný súbor existuje a má správny formát.
Druhý príklad, verzia A
Tento príklad je prevzatý z prednášky, na skúške budú príklady, ktoré doteraz neboli použité.
Úlohou je napísať program, ktorý bude riešiť hlavolam Sudoku. V tomto hlavolame máme danú plochu 9x9 políčok, pričom niektoré sú prázdne, iné obsahujú číslo z množiny {1..9}. Plocha je rozdelená do 9 štvorcov 3x3. Cieľom je doplniť čísla do všetkých prázdnych políčok tak, aby v každom riadku plochy, v každom stĺpci plochy a v každom štvorci 3x3 bola každá cifra {1..9} práve raz.
Tu je príklad hlavolamu aj s naznačeným rozdelením plochy na štvorce 3x3. Bodky označujú prázdne políčka.
. 3 . | . 7 . | . . . 6 . . | 1 9 5 | . . . . 9 8 | . . . | . 6 . --------------------- 8 . . | . 6 . | . . 3 4 . . | 8 . 3 | . . 1 . . . | . 2 . | . . 6 --------------------- . 6 . | . . . | 2 8 . . . . | 4 . 9 | . . 5 . . . | . 8 . | . 7 .
Náš program dostane vstup ako maticu 9x9 čísel, pričom nuly označujú prázdne políčka. Cieľom je vypísať na konzolu všetky riešenia hlavolamu, pričom každé riešenie je matica 9x9 a za ňou voľný riadok. Nakoniec má program vypísať celkový počet riešení hlavolamu. Matica je zadaná v súbore sudoku.txt Príklad vstupu a výstupu:
Vstup: 0 3 0 0 7 0 0 0 0 6 0 0 1 9 5 0 0 0 0 9 8 0 0 0 0 6 0 8 0 0 0 6 0 0 0 3 4 0 0 8 0 3 0 0 1 0 0 0 0 2 0 0 0 6 0 6 0 0 0 0 2 8 0 0 0 0 4 0 9 0 0 5 0 0 0 0 8 0 0 7 0 Vystup: 5 3 4 6 7 8 9 1 2 6 7 2 1 9 5 3 4 8 1 9 8 3 4 2 5 6 7 8 5 9 7 6 1 4 2 3 4 2 6 8 5 3 7 9 1 7 1 3 9 2 4 8 5 6 9 6 1 5 3 7 2 8 4 2 8 7 4 1 9 6 3 5 3 4 5 2 8 6 1 7 9 Pocet rieseni: 1
Program nižšie načíta maticu a obsahuje aj funkciu na výpis riešenia. Doprogramujte rekurzívnu funkciu generuj a ďalšie pomocné funkcie (najdiVolne a moze). Vaša rekurzívna funkcia by mala postupovať nasledovne:
- Pomocou funkcie najdiVolne nájde na ploche prázdne políčko, ak také nie je, vypíše riešenie a skončí.
- Do prázdneho políčka skúša vložiť čísla 1...9 a testuje, či nenastane konflikt v riadku, stĺpci alebo štvorci. Túto kontrolu robí pomocou funkcie moze.
- Vždy, keď niektoré číslo sedí, zavolá sa rekurzívne na vyplnenie zvyšných bielych miest.
V prípade potreby navrhnite a naprogramujte aj ďalšie pomocné funkcie.
#include <cstdio> void vypis(int **a) { /* vypis riesenia sudoku */ for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { printf(" %d", a[i][j]); } printf("\n"); } printf("\n"); } void najdiVolne(int **a, int &riadok, int &stlpec) { /* najdi volne policko na ploche a uloz jeho suradnice * do premennych riadpk a stlpec. Ak nie je, uloz do oboch * premennych hodnotu -1. */ } bool moze(int **a, int riadok, int stlpec, int hodnota) { /* Mozeme ulozit danu hodnotu na dane policko? * Da sa to, ak riadok, stlpec, ani stvorec nema * tuto hodnotu este pouzitu. */ } int generuj(int **a) { /* mame ciastocne vyplnenu plochu sudoku, * chceme najst vsetky moznosti, ako ho dovyplnat * a vratit ich pocet. */ } int main(void) { FILE *f = fopen("sudoku.txt", "r"); /* alokujeme a nacitame 2D maticu so vstupom */ int **a = new int *[9]; for (int i = 0; i < 9; i++) { a[i] = new int[9]; } for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { fscanf(f, "%d", &(a[i][j])); } } fclose(f); /* rekurzivne prehladavanie s navratom */ int pocet = generuj(a); /* vypis riesenia */ printf("Pocet rieseni: %d\n", pocet); }
Druhý príklad, verzia B
Tento príklad je prevzatý z cvičení, na skúške budú príklady, ktoré doteraz neboli použité.
Napíšte program, ktorý udržuje množinu celých čísel, pričom od užívateľa jeden po druhom načítava príkazy, ktoré aj hneď aj vykonáva. Každý príkaz pozostáva z jednopísmenového kódu a z celočísleného parametra, ktoré užívateľ zadá na jednom riadku. Príkazy sú štyroch typov:
- Príkaz s kódom 'I' vloží zadané číslo do množiny (na začiatku programu je množina prázdna). Vypíše buď reťazec OK, ak sa podarilo číslo vložiť, alebo reťazec ERR, ak už číslo v množine bolo.
- Príkaz s kódom 'R' dostane ako parameter prvok x a zistí, koľký v utriedenom poradí tento prvok je v rámci množiny. Ak zadané číslo nie je z množiny, vypíše reťazec ERR, v opačnom prípade vypíše výsledok, ktorý by mal byť číslo od 1 po počet prvkov množiny.
- Príkaz s kódom 'S' nájde k-te najmenšie číslo v množine, pričom k je zadaný parameter, ktorý by mal byť v rozsahu od 1 po počet prvkov množiny. Ak k nie je v tomto rozsahu, program vypíše reťazec ERR, v opačnom prípade vypíše nájdený prvok.
- Príkaz s kódom 'E' ukončí program, parameter ignoruje.
Príklad:
I 20 OK I 20 ERR I 10 OK R 20 2 S 2 20 R 30 ERR E 0
Tento problém budeme riešiť modifikáciou binárnych vyhľadávacích stromov. Každý vrchol bude obsahovať kľúč typu int, smerník na ľavého a pravého syna, smerník na otca a počet vrcholov v celom podstrome zakorenenom v danom vrchole (položka count). Napríklad pre list by mal byť count 1, pre vrchol s dvoma synmi, ktorí sú obaja listami, by hodnota count mala byť 3.
V programe uvedenom nižšie máte funkcie z prednášky na vkladanie prvku do vyhľadávacieho stromu a jeho vyhľadávanie ako aj základ funkcie main. Vašou úlohou je doprogramovať nasledovné časti kódu:
- Funkcie createLeaf a insert zmeňte tak, aby správne inicalizovali a udržiavali položku count pre všetky vrcholy v strome.
- Funkcie rank a select (pozri nižšie)
- Dopísať spracovanie príkazov R a S do hlavného programu.
Čiastočné body môžete dostať aj ak sa vám podarí spraviť správne iba niektoré z týchto podúloh, nemeňte však celkovú kostru programu. V prípade potreby si napíšte aj ďalšie funkcie, ktoré budete z uvedených funkcií volať.
- Funkcia int rank(dictionary &d, int key) má nájsť prvok key v strome a vrátiť, koľký v utriedenom poradí spomedzi iných prvkov v strome je. V tejto funkcii predpokladajte, že hľadaný kľúč sa v strome určite nachádza (prípad, že sa nenachádza doriešte v hlavnom programe). V tejto funkcii využite položku count. Ak totiž pokračujeme v hľadaní v pravom podstrome určitého vrcholu v, tak vrchol v aj všetky vrcholy v jeho ľavom podstrome sú pred hľadaným prvkom. A aj bez toho, aby sme ľavý podstrom celý prechádzali, vieme koľko prvkov v ňom je.
- Funkcia int select(dictionary &d, int k) má vrátiť k-ty najmenší prvok vo vyhľadávacom strome. Aj v tejto funkcii využite položku count. Ak je totiž k najviac rovné počtu vrcholov v ľavom podstrome, k-ty najmenší prvok musí byť niekde v tomto podstrome. Ak je naopak k veľké, hľadaný prvok musí byť v pravom podstrome a vieme spočítať aj to, koľký najmenší v rámci tohto podstromu je.
#include <iostream> #include <cassert> using namespace std; struct node { /* vrchol binarneho vyhladavacieho stromu */ int key; /* kluc podla ktoreho vyhladavame */ int count; /* pocet vrcholov v podstrome */ node * parent; /* otec vrchola */ node * left; /* lavy syn */ node * right; /* pravy syn */ }; struct dictionary { node *root; }; void init(dictionary &d) { /* inicializuje prazdny slovnik */ d.root = NULL; } node * createLeaf(int key, node * parent) { /* vytvor novy vrchol s danymi hodnotami, obe deti nastav na NULL */ node *v = new node; v->key = key; v->left = NULL; v->right = NULL; v->parent = parent; return v; } node * findNode(node *root, int key) { /* V binarnom vyhladavacom strom s korenom root najdi a vrat * vrchol s klucom a ak neexistuje, vrat NULL. */ node * v = root; while (v != NULL && v->key != key) { if (key < v->key) { v = v->left; } else { v = v->right; } } return v; } void findNode(node *root, int key, node *&v, node *&parent) { /* Do v uloz smernik na vrchol s klucom key alebo NULL ak neexistuje. * Do parent uloz otca v, NULL ak neexistuje a ak key nie je v strome * tak smernik na vrchol, ktory by mal byt otcom pre vrchol * s hodnotou key.*/ parent = NULL; v = root; while (v != NULL && v->key != key) { parent = v; if (key < v->key) { v = v->left; } else { v = v->right; } } } bool find(dictionary &d, int key) { /* Zisti, ci sa v slovniku d nachadza kluc key. */ node *v = findNode(d.root, key); if (v != NULL) { assert(v->key == key); return true; } else { return false; } } void insert(dictionary &d, int key) { /* Do slovnika d vlozi kluc key. * Predpokladame, ze takyto kluc este v slovniku nie je. */ if (d.root == NULL) { /* prazdny strom - treba vytvorit koren */ d.root = createLeaf(key, NULL); } else { node *v; node *parent; findNode(d.root, key, v, parent); /* parent je teraz vrchol, ktoreho syn ma byt novy vrchol */ assert(v == NULL && parent != NULL); /* zisti, ci mame byt lave alebo prave dieta otca */ if (key < parent->key) { assert(parent->left == NULL); parent->left = createLeaf(key, parent); } else { assert(parent->right == NULL); parent->right = createLeaf(key, parent); } } } int rank(dictionary &d, int key) { /* vrati kolky je key v utriedenom poradi prvkov v strome. * Predpoklada, ze key sa v strome nachadza. */ } int select(dictionary &d, int k) { /* vrati k-ty najmensi prvok v strome. * Predpoklada, ze 1 <= k <= celkovy pocet prvkov v strome. */ } int main() { dictionary d; init(d); while (true) { char command; int param; cin >> command >> param; switch (command) { case 'I': if (find(d, param)) { cout << "ERR" << endl; } else { insert(d, param); cout << "OK" << endl; } case 'S': break; case 'R': break; case 'E': return 0; } } }
Netbeans
Ako spustiť Netbeans v učebni
- Po spustení počítača zvoľte Linux a prihláste sa pomocou toho istého mena a hesla, ako používate v systéme AIS
- V ľavom dolnom rohu obrazovky je menu s ponukou programov, v oddelení Development nájdete Netbeans
Základy práce v Netbeans
Vytvorenie nového projektu
- Každý program v Netbeans potrebuje svoj "projekt", čo je adresár so všetkými potrebnými súbormi.
- V menu zvoľte File, potom New project
- V Categories zvoľte C/C++, v Project: C/C++ Application
- Na ďalšej obrazovke projekt nejako nazvite a zvoľte do akého adresára sa má uložiť. Doproučujeme cestu na svieťovom disku net, ku ktorému máte prístup zo všetkých počítačov v učebniach, napríklad v adresári /home/x/vasemeno/net/NetBeansProjects
- Stlačte Finish
Editovanie programu
- V ľavej časti okna máte panel Project, v ktorom nájdite projekt, ktorý ste práve vytvorili.
- V projekte rozbaľte Source Files a nájdete tam main.cpp, ktorý si dvojitým kliknutím otvoríte v editore. Jeho obsah môžete modifikovať alebo celý zmazať a nahradiť programom z prednášky.
- Súbor main.cpp nezabudnite uložiť (menu File, Save, alebo Ctrl-S)
Kompilovanie a spúšťanie
- V menu Run zvoľte Build main project (F11), program sa skompiluje. Prípadné chyby sa objavia v dolnej časti okna.
- V menu Run zvoľte Run main project (F6), program sa spustí.
- Ak máte naraz otvorených viac projektov, jeden z nich je hlavný, vyznačený hrubým písmom. Kompilovanie a spúšťanie sa aplikuje na hlavný projekt.
- Ak chcete nastaviť nejaký projekt ako hlavný, kliknite na jeho meno v paneli Project pravým tlačidlom a zvoľte Set as main project
Prenášanie programov a odovzdávanie domácich úloh
- Pri odovzdávaní domácich úloh odovzdávajte súbor main.cpp s vašim programom (prípadne ďalšie súbory ak to vyžaduje zadanie). Tento súbor nájdete v adresári net/NetBeansProjects/menoprojektu
- Ak pracujete na rôznych počítačoch v rámci FMFI učební, svoje projekty si ukladajte na sieťovom disku net
- Dáta zo sieťového disku si môžete stiahnuť v učebni na USB kľúčik, alebo aj cez sieť z domu prihlásením sa na študentský Linuxový klaster daVinci (davinci.fmph.uniba.sk). Na prenos dát môžete použiť napríklad windowsovský program winscp
- Ak chcete prenášať projekt medzi rôznymi počítačmi, doporučujeme skopírovať iba main.cpp, prípadne ďalšie potrebné súbory.
- Na druhom počítači vytvoríte nový projekt, nakopírujete main.cpp do jeho adresára.
- Potom pridáte main.cpp do projektu takto: kliknite pravým tlačidlom na Source Files v paneli Projects, zvoľte Add Existing Item
Práca v Netbeans s grafickou knižnicou
- Stiahnite si knižnicu vo verzii určenej pre učebňu
- Stiahnuté súbory libsimpleDraw.a a SimpleDraw.h uložte do adresára NetBeansProjects, v ktorom podadresáre obsahujú jednotlivé projekty
- Pri vytváraní nového projektu je potrebné zvoliť C/C++ Qt Application namiesto C/C++ Application
- Po vytvorení kliknite pravým tlačidlom na meno projektu v paneli Projects a zvoľte Properties
- V paneli Categories zvoľte Linker v časti Build, v pravom paneli stlačte tri bodky pri Libraries, potom Add Library File, potom zvoľte súbor libsimpleDraw.a
- Teraz môžete editovať, kompilovať a spúšťať program rovnako ako bez použitie knižnice
Kopírovanie projektov
- Keď už máte jeden grafický program hotový a chcete si vytvoriť ďalší, môžete vynechať niektoré z krokov uvedených vyššie tým, že si otvoríte starý projekt, v paneli Project kliknete na jeho meno pravým tlačidlom, v menu zvolíte Copy a zadáte nové meno projektu.
- Teraz môžete editovať, kompilovať a spúšťať program bez zadávania ďalších nastavení.
Práca s Netbeans na vlastnom počítači
- Ak máte na počítači nainštalovaný Linux, podľa návodu nižšie si ľahko nainštalujete Netbeans a ďalšie potrebné súčasti (pozri nižšie)
- Ak máte na počítači operačný systém Windows, je možné tiež si nainštalovať Netbeans, o niečo ťažšie je však rozchodiť knižnicu Qt, ktorá je potrebná na použitie našej grafickej knižnice používanej na predmete.
- Informácia o inštalovaní Netbeans http://netbeans.org/community/releases/69/cpp-setup-instructions.html
- Odskúšaný návod #SimpleDraw vo Windows.
- Namiesto toho môžete vo Windows spustiť virtuálny počítač so systémom Linux
Inštalácia v Linuxe
Ak máte na počítači operačný systém Linux, budete potrebovať nainštalovať nasledujúce softvérové balíčky:
- Prostredie netbeans (v učebni máme verziu 6.9.1, mala by však postačovať aj iná verzia)
- Komplilátor g++
- Debuger gdb
- Knižnicu qt4 (balíček libqt4-dev)
Všetky tieto balíčky existujú napríklad v distribúcii Ubuntu. Ak vo vašej distribúcii nie je k dispozícii balíček pre Netbeans, stiahnite si ho zo stránky http://netbeans.org/downloads/
Po nainštalovaní týchto balíčkov spustite Netbeans, v menu Tools zvoľte Plugins a pridajte si plugin C/C++.
Používanie grafickej knižnice
- Stiahnite si verziu knižnice určenú na kompilovanie.
- Vytvorte si v Netbeans nový projekt typu C/C++ Qt Static Library, nazvite ho simpleDraw
- Do adresára NetBeansProjects/simpleDraw/ rozzipujte stiahnuté súbory
- V projekte simpleDraw kliknite na Source files pravým tlačidlom a zvoľte Add Existing Item, potom medzi súbormi vyberte SimpleDraw.cpp a SimpleDraw.h (viac súborov naraz môžete pridať ak súčasne stlačíte Ctrl a kliknete na meno ďalšieho súboru)
- V projekte simpleDraw kliknite na Resource files pravým tlačidlom a zvoľte Add Existing Item, potom medzi súbormi zvoľte SimpleDrawWindow.cpp, SimpleDrawWindow.h a SimpleDrawWindow.ui
- Spustite Build Main Project
- Niekde v podadresároch adresára NetBeansProjects/simpleDraw/dist by vám mal vzniknúť súbor libsimpleDraw.a. Tento potom môžete použiť na vašom počítači rovnako ako používate jeho verziu pre učebne stiahnutú zo stránky.
Netbeans vo virtuálnom počítači
- Jedna z možností, ako sa vysporiadať s problémami okolo inštalovania Netbeans a grafickej knižnice na Windowsovom počítači je bežať ho vo virtuálnom serveri s nainštalovaným Linuxom
- Doporučujeme túto možnosť, len ak Váš počítač má aspoň 2G pamäte
- Na cvičeniach môžete získať dva súbory prog.ovf a prog-disk1.vmdk celkovej veľkosti cca 2G (doneste si veľký USB kľúčik) obsahujúce nainštalovaný virtuálny počítač aj s prostredím Netbeans.
- Potrebujete si stiahnuť aj softvér na spúšťanie virtuálneho počítača, ten získate na stránke https://www.virtualbox.org/
- Po nainštalovaní softvéru Virtualbox pridáte do neho pridáte virtuálny počítač pomocou možnosti Import appliance, zvolíte prog.ovf (vmkd súbor musí byť v tom istom priečinku)
- Virtuálnemu počítaču môžete nastaviť veľkosť pamäte, alebo zdieľanie priečinkov s vašim počítačom.
- Heslo na prihlasovanie a administrátorské úkony je také isté, aké ste použili pri prihlasovaní sa na predmet v prostredí Moodle (dve slová)
- Na pravom okraji obrazovky je lišta s často používanými programami, vrátane Netbeans a Firefoxu.
SimpleDraw vo Windows
Inštalácia softvéru
Ak nemáme Netbeans, stiahneme si ho tu: http://netbeans.org/downloads/index.html (priamy link na inštalátor pre lenivých)
Mala by stačiť verzia pre C/C++.
Ak už Netbeans máme, tak si skontrolujeme, či v ňom máme plugin pre C++. To sa dá spraviť skontrolovaním dostupných pluginov tu:
Ak medzi nimi je, to znamená, že ho nemáme a treba si ho v danom okne doinštalovať.
Po inštalácii Netbeans je ďalším krokom je nainštalovanie Qt SDK z http://qt.nokia.com/downloads/
(priamy link na inštalátor pre lenivých).
V prípade inštalácie na počítači s internetom postačí online verzia inštalátora.
Pri inštalácii je dôležité zvoliť správne komponenty.
Budeme potrebovať nasledovné:
Nakoniec je ešte potrebné nainštalovať MSYS.
"MSYS is a collection of GNU utilities such as bash, make, gawk and grep to allow building of applications and programs which depend on traditionally UNIX tools to be present. It is intended to supplement MinGW and the deficiencies of the cmd shell."
Sťahujeme odtiaľto: http://downloads.sourceforge.net/mingw/MSYS-1.0.11.exe
Ku koncu inštalácie je nutné odpovedať na dve otázky "yes" a následne vpísať cestu k nainštalovanému MinGW.
Pri použití predvolenej cesty pri inštalácii Qt to má vyzerať takto:
Dôležité je v ceste použiť presne tie lomítka, ktoré sú na obrázku.
Nastavenie Windows
Aby nám v Netbeans šlo spúštať konzolové (negrafické programy), potrebujeme do premennej prostredia PATH pridať cestu k MinGW: C:\QtSDK\mingw\bin
Objavili sa prípady, kedy bolo do PATH potrebné pridať aj cestuku Qt knižniciam: C:\QtSDK\Desktop\Qt\4.7.4\mingw\bin
Premenná PATH sa dá nastaviť v pravý klik na tento počítač > properties > advanced system settings > environment variables > system variables > variable path > edit. Na jej konci treba pridať bodkočiarku a danú cestu.
Po úprave PATH je nutné Windows reštartovať.
Nastavenie Netbeans
V Netbeans treba nastaviť správne cesty k jednotlivým súčastiam. Prejdeme preto cez menu do Tools -> Options -> C/C++ a klikneme na "Add...".
Objaví sa dialóg, do ktorého je treba vyplniť cestu k mingw, ktorá pri použití predvolených ciest vyzerá takto:
Následne ostanú nevyplnené dve cesty - k príkazom make a qmake.
Tie vyplníme nasledovne (za predpokladu predvolených ciest):
Vytvorenie knižnice
V Netbeans si vytvoríme nový projekt - Qt Static Library:
Po kliknutí na "Next >" nastavíme "Tool Collection" na MinGW.
Zdrojové súbory knižnice si stiahneme tu: http://compbio.fmph.uniba.sk/vyuka/prog/data/simpleDraw.zip
a rozbalíme do priečinku s novovytvoreným projektom.
Následne tieto súbory musíme pridať do projektu tak, aby o tom Netbeans vedel.
Najprv pridáme hlavičkové (.h) súbory:
Rovnakým spôsobom pridáme zdrojové súbory (.cpp) do Source Files.
Konfiguráciu projektu prepneme z "Debug" na "Release" a celé to skompilujeme stlačením tlačidla s obrázkom kladiva.
O úspechu nás bude informovať konzola v spodnej časti Netbeans hláškou "BUILD SUCCESSFUL (total time: XYs)".
Vytvorenú knižnicu nájdeme v adresári projektu v podadresári "dist\Release\MinGW-Windows", v závislosti od mena nášho projektu sa môže volať napríklad "libsimpleDraw.a"
Použitie knižnice
Tak ako na cvikách (Qt Application, pridať library file) ale miesto "main(void)" treba dať "main(int argc, char** argv)".
SimpleDraw
Knižnica SimpleDraw umožňuje zobraziť grafické okno a vykresľovať do neho rôzne geometrické útvary.
- Návod na použitie knižnice v prostredí Netbeans
- Stiahnutie knižnice
- Príklady programov na prvej prednáške
- Manuál ku knižnici
Príkazy na prácu s grafickou plochou
- Ako prvé musíme vytvoriť grafické okno s určitou veľkosťou plochy príkazom typu SimpleDraw window(300, 400);
- V každom programe vytvárajte iba jedno okno.
- Do okna môžeme kresliť príkazmi drawRectangle, drawEllipse, drawLine, drawText. Presný zoznam parametrov každého príkazu nájdete v manuáli. Príklad: window.drawRectangle(100, 200, 100, 100);
- Môžeme vykresľovať aj celé bitmapy načítané napr z .jpg alebo .png súboru, a to príkazom drawPixmap
- Ak chceme vykresľovať mnohouholníky alebo lomené čiary, použijeme skupinu príkazov startPath, lineTo a drawPath alebo drawClosedPath. Pomocou startPath a lineTo postupne vymenujeme vrcholy a pomocou drawPath alebo drawClosedPath čiaru uzavrieme a vykreslíme.
- Pomocou príkazov setPenColor, setBrushColor, unsetBrush, setFontColor vieme nastavovať farbu čiar, písma a vyfarbovania. Farby zadávame buď troma číslami od 0 do 255 určujúcimi intenzitu červenej, zelenej a modrej, alebo názvom, napr. "red" (zoznam mien farieb). Príkazom setFontSize nastavujeme veľkosť písma.
- Príkaz showAndClose vykreslí okno a čaká, kým užívateľ stlačí Exit, potom zavrie okno. Príkaz show čaká kým užívateľ stlačí Next, potom môžeme pokračovať vo vykresľovaní. Príkaz wait čaká zadaný počet sekúnd, čo sa dá využiť na spomalenie animácie.
- Príkaz clear vymaže obsah okna. Príkaz removeItem zmaže objekt (napr. čiaru) so zadaným číslom. Každý kresliaci príkaz vráti číslo práve vykresleného objektu, takže si ho stačí uložiť v nejakej premennej pre neskoršie mazanie.
- Príkaz savePng uloží zobrazený obrázok do png súboru.
- Príkazy startDebugging a stopDebugging zapínajú a vypínajú ladiaci mód, v ktorom program čaká na stlačenie Next po vykreslení každej čiary alebo iného objektu.
Príkazy na korytnačiu grafiku
- Pred vytvorením korytnačky musíme vytvoriť grafickú plochu.
- Korytnačka si pamätá svoju polohu a natočenie na ploche. Príkaz forward posunie korytnačku dopredu, príkaz turnLeft ju otočí.
- Ak má korytnačka spustené pero, kreslí pri pohybe čiaru. Toto sa mení príkazmi penUp a penDown.
- Príkazmi show a hide vieme nastaviť, či sa má nasmerovanie korytnačky zobrazovať ako šípka.
- Príkaz setWait umožňuje zapnúť čakanie po každom pohybe, aby sme lepšie videli, ako sa postupne hýbe.
Prednáška 1
Pozrite si úvod k predmetu a pravidlá
Čo je programovanie
Algoritmus
Algoritmus: Postupnosť konečného počtu elementárnych krokov vedúca k vyriešeniu daného typu úlohy
Príklady:
- Ako sčítať dve celé čísla v desiatkovej sústave
- Ako nájsť najväčšieho spoločného deliteľa dvoch čísel
- Ako riešiť Sudoku
Správnosť algoritmu
- Keď vždy dáva správne výsledky.
- Keď vždy skončí.
Program
- Predpis, pomocou ktorého počítač môže vykonávať algoritmus
- Zapísaný v programovacom jazyku
Programátorské prostredie
- Na tomto predmete budeme programovať v jazyku C++, budeme však z neho používať len malú časť.
- Budeme používať programátorské prostredie NetBeans, ktoré vám spríjemňuje a zjednodušuje prácu.
- Cvičenia a skúšky budú v operačnom systéme Linux
- V princípe môžete používať aj iné programátorské prostredia, ale
- odovzdané programy (DÚ, skúška) musia správne pracovať v prostredí ako na cvičeniach
- počas skúšky budete mať k dispozícii len to, čo beží v učebniach v Linuxe
- Netbeans a ďalšie potrebné nástroje si môžete nainštalovať zadarmo aj na vašom počítači
- Pre Windows je inštalácia obtiažnejšia, môžete však spúšťať virtuálny linuxový stroj, ktorý vám poskytneme
- Návod k práci v prostredí Netbeans
Prvý program
- Tradične sa v učebniciach programovania ako prvý uvádza program, ktorý iba vypíše na obrazovku text "Hello world!". Tu je v jazyku C++:
#include <iostream> using namespace std; int main(void) { cout << "Hello world!" << endl; }
- Samotný text je vypísaný príkazom cout << "Hello world!" << endl;
- Všimnite si, že text Hello world! sme dali do úvodzoviek, čím poukazujeme na to, že to nie sú príkazy programovacieho jazyka, ale text, s ktorým treba niečo robiť.
- Za príkazom sme dali bodkočiarku, ktorá ho ukončuje.
- O vypisovaní si povieme viac neskôr, ale už teraz môžete vypisovať rôzne texty tým, že zmeníte text medzi úvodzovkami.
- Riadok int main(void) { označuje začiatok programu, program ide až po ukončovaciu zloženú zátvorku }
- Jazyk C++ sám o sebe neobsahuje príkazy na vypisovanie (cout <<...). Na to potrebujeme použiť knižnicu: súbor príkazov, ktoré niekto už naprogramoval a my ich len používame. Prvé dva riadky programu nám umožnia používať štandardnú knižnicu iostream, ktorá je súčasťou C++ a ktorá obsahuje príkazy na vypisovanie.
Spúšťanie programu
- Na to, aby sme náš program mohli spustiť na počítači, potrebujeme ho najskôr skompilovať, t.j. preložiť do spustiteľného strojového kódu.
- Ako na to, nájdete v návode k práci v prostredí Netbeans
- V prostredí Netbeans vieme program aj spustiť, môžeme si ho však aj skopírovať a spúšťať na iných počítačoch nezávisle od Netbeans.
Prvý grafický program
- Občas budeme vykresľovať obrázky pomocou knižnice SimpleDraw vytvorenej špeciálne pre tento predmet. (Tu je návod na jej používanie)
- Nasledujúci program vypíše text Hello world! pomocou tejto knižnice.
#include "../SimpleDraw.h" int main(void) { /* Vytvor obrázok s rozmermi 100x100 pixelov */ SimpleDraw window(100, 100); /* Nastav farbu písma na červenú. */ window.setFontColor("red"); /* Vypíš text vystredený na súradniciach 50,50. */ window.drawText(50, 50, "Hello world!"); /* Ulož obrázok do súboru hello s príponou png. */ window.savePng("hello.png"); /* Zobraz na obrazovke a čakaj, kým užívateľ stlačí Exit, potom zavri okno. */ window.showAndClose(); }
- Po spustení program vypíše text červenou farbou, uloží ho vo forme obrázku do súboru hello.png a zobrazí ho v grafickom okne s tlačidlom "Exit". Keď užívateľ stlačí tlačidlo, okno sa zavrie.
- Prvý riadok programu teraz obsahuje inú knižnicu (SimpleDraw). Nie je súčasťou jazyka, preto si ju musíme skopírovať na náš počítač a umiestniť do vhodného adresára. Viac v návode.
- Medzi int main(void) { a koncovou zátvorkou } máme teraz viacero príkazov, každý ukončený bodkočiarkou. Vykonávajú sa v tom poradí, v ako sú napísané.
- Text medzi /* a */ bude počítač ignorovať, ide o komentár určený pre čitateľa. V tomto prípade vždy popisuje, čo bude robiť nasledujúci riadok.
Cvičenia
Aj keď sme si nepovedali toho veľa o jednotlivých príkazoch v tomto programe, mali by ste z komentárov vedieť uhádnuť, ako meniť program aby napríklad:
- mal inú veľkosť obrázku
- použil na vypisovanie inú farbu
- vypísal text na iné miesto v rámci obrázku
- vypísal dva rôzne texty na rôzne miesta obrazovky rôznou farbou (napr. červeným Hello world! a pod to modrým Good morning, starshine!)
- uložil obrázok do súboru s iným menom
- vôbec neukladal nič do súboru
Vykreslenie domčeka
- Ukážeme si ešte program, ktorý vykreslí tradičný prečiarknutý domček, ako je na obrázku vpravo.
- Pozor, grafická obrazovka má súradnicu 0,0 v ľavom hornom rohu a smerom nadol y-ová súradnica stúpa, čo je naopak, než je zvykom v matematike.
#include "../SimpleDraw.h" int main(void) { /* Vytvor obrázok s rozmermi 300x400 pixelov */ SimpleDraw window(300, 400); /* Nakresli obdĺžnik (štvorec) s ľavým horným rohom v 100, 200 * a šírkou aj dĺžkou 100. */ window.drawRectangle(100, 200, 100, 100); /* Prečiarkni štvorec dvomi čiarami po uhlopriečke. */ window.drawLine(100, 300, 200, 200); window.drawLine(100, 200, 200, 300); /* Nakresli strechu ako dve čiary. */ window.drawLine(100, 200, 150, 100); window.drawLine(200, 200, 150, 100); /* Ulož obrázok do súboru domcek1 s príponou png. */ window.savePng("domcek1.png"); /* Zobraz na obrazovke a čakaj, kým užívateľ stlačí Exit, potom zavri okno. */ window.showAndClose(); }
- Obmenou týchto dvoch programov by ste mali vedieť vykresliť hocijaký obrazec z rovných čiar a pridať k nim text.
- Knižnica SimpleDraw umožnuje vykresľovať aj kružnice a elipsy, lomené čiary, obrázky načítané zo súboru, meniť farbu čiary, vyfarbovať útvary a podobne. Viac sa dočítate v návode.
Domček korytnačou grafikou
- Pointa preškrtnutého domčeka je, že sa má kresliť jedným ťahom. To náš program vyššie nerobil.
- Knižnica SimpleDraw obsahuje aj príkazy na korytnačiu grafiku, ktorou môžeme domček nakresliť jedným ťahom.
- Na obrazovke si vytvoríme virtuálnu korytnačku, ktorá má určitú polohu a natočenie.
- Môžeme jej povedať, aby sa otočila doľava o určitý počet stupňov (turtle.turnLeft(uhol)).
- Môžeme jej povedať, aby išla o určitú dĺžku dopredu (turtle.forward(dlzka))
- Keď ide korytnačka dopredu, zanecháva v piesku chvostom čiarku (vykreslí teda čiaru do nášho obrázku).
#include "../SimpleDraw.h" #include <cmath> int main(void) { /* Vytvor obrázok s rozmermi 300x400 pixelov. */ SimpleDraw window(300, 400); /* Vytvor korytnačku v ľavom dolnom rohu domu * otočenú doprava. */ Turtle turtle(window, 100, 300, 0); /* Zobraz korytnačku ako šípku. */ turtle.show(); /* Korytnačka bude čakať 1 sekundu po každom ťahu. */ turtle.setWait(1); /* Nakresli dolnú čiaru a otoč sa smerom hore. */ turtle.forward(100); turtle.turnLeft(90); /* Nakresli pravú zvislú čiaru, hornú vodorovnú a ľavú zvislú. */ turtle.forward(100); turtle.turnLeft(90); turtle.forward(100); turtle.turnLeft(90); turtle.forward(100); /* Otoč sa smerom na uhlopriečku. Dĺžku uhlopriečky vyrátame Pytagorovou vetou. */ turtle.turnLeft(135); turtle.forward(sqrt(100 * 100 + 100 * 100)); /* Otoč sa smerom na pravú časť strechy. * Strecha bude rovnostranný trojuholník so stranou * dĺžky 100. */ turtle.turnLeft(75); turtle.forward(100); turtle.turnLeft(120); turtle.forward(100); /* A posledná čiara - uhlopriečne prečiarknutie. */ turtle.turnLeft(75); turtle.forward(sqrt(100 * 100 + 100 * 100)); /* Schovaj korytnačku. */ turtle.hide(); /* Zobraz na obrazovke. */ window.showAndClose(); }
- Pre jednoduchosť tento domček má trochu nižšiu strechu v tvare rovnostranného trojuholníka s každou stranou dĺžky 100 (a vnútornými uhlami 60 stupňov)
- Keďže domček je štvorec, uhlupriečka ide pod uhlom 45 stupňov. Jej dĺžku však musíme spočítať. Na sčítavanie používame znamieko +, na násobenie *, a na odmocninu funkciu sqrt (skratka z anglického square root), ktorá je v knižnici cmath
- Po každom príkaze forward korytnačka na sekundu zastane, aby sme videli, čo robí.
Zhrnutie
- Programy, ktoré sme doteraz videli, vyzerali takto:
- Najprv sme zapli používanie niekoľkých knižníc
- Samotný program začínal int main(void) { a končil zloženou zátvorkou }
- Program mohol mať niekoľko príkazov ukončených bodkočiarkami, ktoré sa vykonávajú jeden po druhom.
- Okrem toho môžu byť v programe komentáre medzi /* a */, ktoré počítač ignoruje.
- Logiku za tým, prečo jednotlivé príkazy píšu tak, ako sa píšu, sme zatiaľ ešte nevysvetľovali, mali by ste však byť schopní modifikovať príklady uvedené v prednáške menením čísel, textov v úvodzovkách, pridávaním ďalších príkazov a podobne.
- Upozornenia:
- Je rozdiel medzi malými a veľkými písmenami
- Všetky čiarky, bodkočiarky, zátvorky a podobne sú dôležité
- Na väčšine miest v programe môžeme voľne pridávať medzery a konce riadku, snažíme sa tým program spraviť prehľadný
- Programy, ktoré sme videli doteraz nie sú veľmi zaujímavé, lebo vždy robia to isté a robia pevný počet krokov, ktoré sme museli ručne všetky vypísať. Ďalej uvidíme
- príkazy na načítanie vstupu od užívateľa
- premenné, v ktorých si môžeme uchovávať vstupy a iné hodnoty
- podmienky, ktoré nám umožnia vykonávať príkazy podľa okolností
- cykly, ktoré nám umožnia opakovať tie isté príkazy veľa krát
Organizačné poznámky
- Dnes prvé cvičenia
- Skúste odovzdat DÚ0 v moodli (treba heslo)
- Zajtra ďalšia prednáška
- Štvrtok zverejnenie DÚ1 a PDÚ1
- V piatok termín odovzdania DÚ0
- Budúci pondelok zverejníme prípadné zmeny v rozdelení do skupín na cvičenia
- Budúci pondelok prvá rozcvička
Prednáška 2
Premenné
Spomeňme si na program na vykresľovanie domčeka z minulej prednášky:
#include "../SimpleDraw.h" int main(void) { /* Vytvor obrázok s rozmermi 300x400 pixelov */ SimpleDraw window(300, 400); /* Nakresli obdĺžnik (štvorec) s ľavým horným rohom v 100, 200 * a šírkou aj dĺžkou 100. */ window.drawRectangle(100, 200, 100, 100); /* Prečiarkni štvorec dvomi čiarami po uhlopriečke. */ window.drawLine(100, 300, 200, 200); window.drawLine(100, 200, 200, 300); /* Nakresli strechu ako dve čiary. */ window.drawLine(100, 200, 150, 100); window.drawLine(200, 200, 150, 100); /* Zobraz na obrazovke a čakaj, kým užívateľ stlačí Exit, potom zavri okno. */ window.showAndClose(); }
Ak by sme v ňom chceli zmeniť napríklad výšku domčeka, museli by sme pomeniť veľa súradníc v celom programe. Navyše keď vidíme v programe nejaké číslo, napr. 200, nevieme, ako sme k nemu prišli.
Program na kreslenie domčeka teraz prepíšeme tak, aby sme polohu a veľkosť domčeka mali zapísané symbolicky a mohli ich meniť na jednom mieste.
#include "../SimpleDraw.h" int main(void) { /* x a y sú súradnice ľavého dolného rohu domčeka, * width a height sú jeho šírka a dĺžka, * roof je výška strechy. */ int x = 100; int y = 300; int width = 100; int height = 100; int roof = 100; /* Vytvor obrázok s rozmermi 300x400 pixelov */ SimpleDraw window(300, 400); /* Nakresli obdĺžnik */ window.drawRectangle(x, y - height, width, height); /* Prečiarkni štvorec dvomi čiarami po uhlopriečke. */ window.drawLine(x, y, x + width, y - height); window.drawLine(x, y - height, x + width, y); /* Nakresli strechu ako dve čiary. */ window.drawLine(x, y - height, x + width / 2, y - height - roof); window.drawLine(x + width, y - height, x + width / 2, y - height - roof); /* Zobraz na obrazovke a čakaj, kým užívateľ stlačí Exit, potom zavri okno. */ window.showAndClose(); }
Symbolickým hodnotám x,y,width,height,roof sa hovorí premenné.
- Premmená je určité vyhradené miesto v pamäti počítača, ku ktorému v programe pristupujeme pod určitým názvom.
- Do tejto pamäti si môžeme zapísať hodnotu a neskôr ju použiť.
- Príkaz int x=100; vytvorí novú premennú a uloží do nej hodnotu 100.
- Každá premenná má určitý typ, ktorý určuje, aké hodnoty do nej môžeme ukladať.
- Tieto premenné majú typ int, čo je skratka zo slova integer, celé číslo.
Ak v programe premenným priradíme iné čísla, môžeme vytvárať domčeky, ktorú budú vyššie alebo širšie, alebo budú mať strechu inej výšky, napr:
int x = 100; int y = 300; int width = 100; int height = 200; int roof = 50;
Príkaz int x=100; vieme rozpísať aj na dva príkazy int x; x=100;. Prvý z nich vytvorí premennú x, ktorá teraz bude mať nejakú ľubovoľnú hodnotu a druhý túto počiatočnú hodnotu zmení na 100.
Cvičenie: v programe sa opakuje vzorec na výpočet x-ovej súradnice vrcholu strechy. Spočítajte ho iba raz a uložte do premennej middle
Textový výpis a načítanie
Vieme už vypísať niečo na obrazovku (výstup - output) a podobne môžeme aj čítať, čo nám používateľ napíše na klávesnici (vstup - input). Takéto zadané hodnoty s tiež uložíme v premenných, aby sme s nimi mohli ďalej pracovať.
Nasledujúci program od užívateľa vypýta dve čísla a vypíše ich súčet.
#include <iostream> using namespace std; int main(void) { int x, y; cout << "Please enter the first number: "; cin >> x; cout << "Please enter the second number: "; cin >> y; int result = x + y; cout << x << "+" << y << "=" << result << endl; }
Tu je príklad behu programu, keď užívateľ zadal čísla 10 a 3:
Please enter the first number: 10 Please enter the second number: 3 10+3=13
- Tento program používa na vstup a výstup príkazy z knižnice iostream a teda do hlavičky programu dáme #include <iostream> a using namespace std;
- Program najskôr vytvorí dve premenné x a y typu int (a nepriradzuje im zatiaľ žiadne hodnoty)
- Potom príkazom cout vypíše text "Please enter the first number: " aby užívateľ vedel, čo má robiť.
- Potom pomocou príkazu cin načíta číslo od používateľa do premennej x
- To isté opakuje pre premennú y
- Potom vytvorí novú premennú result a uloží do nej súčet x a y.
- Nakoniec vypíše výsledok aj s výrazom, ktorý sme počítali, pomocou príkazu cout.
Viac o príkaze cout
- Pomocou cout vypisujeme na konzolu, t.j. textovú obrazovku
- To, čo chceme vypísať pošleme na cout pomocou šípky <<
- cout << endl; vypíše koniec riadku
- Môžeme naraz vypísať aj viac vecí oddelených šípkami <<
- Napr. cout << x << "+" << y << "=" << result << endl; vypíše najskôr obsah premennej x (napr. hodnotu 10), potom znamieko plus (ktoré máme v úvodzovkách), potom obsah premennej y, potom znamienko rovnosti, potom obsah premennej result a nakoniec koniec riadku.
Viac o príkaze cin
- Pomocu cin načítavame z konzoly údaje od užívateľa
- Tieto údaje pošleme do premenných pomocou šípky >>
- Opäť môžeme načítať aj viac vecí naraz, napr. nasledovný úryvok si vypýta obe čísla naraz a uloží ich do premenných x a y
cout << "Please enter two numbers separated by space: "; cin >> x >> y;
- Pozor, cin nekontroluje, že užívateľ zadáva rozumné hodnoty. Čo sa stane, ak namiesto čísla zadá nejaké písmená a podobne?
Výrazy
Pri využívaní premenných by sme si mali niečo povedať aj o výrazoch a ich vyhodnocovaní. Na vytváranie výrazov v programe môžeme používať aritmetické a logické výrazy, zátvorky, čísla, konštanty a premenné.
Premenné
- Pre začiatok budeme pracovať s premennými typu int a double.
- Premenná typu int reprezentuje celé číslo.
- Premenná typu double reprezentuje reálne číslo.
- Ich rozsah je však obmedzený.
- Typ int väčšinou zaberá 4 bajty (32 bitov) pamäte a vie ukladať čísla z intervalu <-2 147 483 648, +2 147 483 647>
- Typ double väčšinou zaberá 8 bajtov a je uložený vo formáte s pohyblivou rádovou čiarkou, t.j. vo forme Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle z\cdot a\cdot 2^b} , kde z je znamienko, a je reálne číslo z intervalu <1,2) (mantisa) a b je celé číslo (exponent). Na uloženie mantisy sa používa 52 bitov a na uloženie exponentu 11 bitov. Vieme teda spracovávať zhruba čísla v rozsahu od Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 10^{-300}} po Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 10^{300}} s presnosťou na 15 až 16 platných cifier.
- Keď priradíme hodnotu typu double do hodnoty typu int, dôjde k jej zaokrúhleniu (nadol pri kladných číslach, nahor pri záporných).
Aritmetické výrazy
- +, -, * (násobenie), / (delenie)
- delenie celočíselných premenných vráti dolnú celú časť podielu, napr. 5/3 je 1 (pre záporné čísla to môže byť horná celá časť)
- % je modulo, napr. 5%3 bude 2, lebo 5 má zvyšok 2 po delení 3
- ďalšie matematické funkcie vyžadujú #include <cmath> v hlavičke programu
- napríklad cos(x), sin(x), tan(x) (tangens), acos(x) (arkus kosínus), exp(x) (Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle e^x} ), log(x) (prirodzený logaritmus), pow(x,y) (Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle x^y} ), sqrt(x) (odmocnina), abs(x) (absolútna hodnota), floor(x) (dolná celá časť)
- pozri tiež zoznam tu
Skratky: Ak chceme zvýšiť hodnotu premennej x o 1, môžeme použiť niektorý z nasledujúcich spôsobov:
- x = x+1;
- x++;
- x += 1;
Podobne ako ++ existuje aj --, podobne ako += existuje aj -=, *= atď
Konštanty
- Celočíselné konštanty, ako napríklad 0, 1, 100, -5, majú typ int
- Konštanty s desatinnou bodkou, ako napríklad 1.5, 1.0, 3.13, -0.5 majú typ double. Môžeme tiež používať semilogaritmický zápis typu 1.5e3, čo znamená Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 1.5\cdot 10^3} , t.j. 1500.
Logické konštanty a výrazy
- Logické konštanty: true (1) a false (0)
- Logické výrazy dávajú ako výsledok pravdivostnú hodnotu -- logickú konštantu
- == (rovnosť), != (nerovnosť), <, <=
- && (logický AND), || (logický OR), ! (logický NOT)
Vyhodnocovanie výrazov
Výrazy sa vyhodnocujú s preferenciou podľa nasledovnej tabuľky. Výrazy v jednom riadku tabuľky majú rovnakú prednosť a vyhodnocujú sa väčšinou zľava doprava, okrem !,++,-- a priradenia.
- ++, --, logický NOT
- *, /, %
- +, -
- <, >, <=, >=
- ==, !=
- && (logický AND)
- || (logický OR)
- priradenie
Poradie vyhodnocovania môžeme meniť zátvorkami, napr. 4*(5-3)
Viac o operátoroch v C++ nájdete napríklad tu.
Podmienka (if)
Niekedy chceme vykonať určité príkazy len ak sú splnené nejaké podmienky. To nám umožňuje príkaz podmienky if.
- Nasledujúci program si vypýta od užívateľa číslo a vypíše, či je toto číslo párne (even) alebo nepárne (odd).
#include <iostream> using namespace std; int main(void) { int x; cout << "Please enter some number: "; cin >> x; if (x % 2 == 0) { cout << "Number " << x << " is even." << endl; } else { cout << "Number " << x << " is odd." << endl; } }
- Tu je príklad dvoch behov programu:
Please enter some number: 10 Number 10 is even.
Please enter some number: 3 Number 3 is odd.
- Ako vidíme, za príkazom if je zátvorka s podmienkou. V našom príklade podmienka je x % 2 == 0. Zoberieme teda hodnotu x, pomocou operátora % zistíme zvyšok po delení 0 a pomocou dvoch rovnítok == testujeme, či je tento zvyšok rovný nule.
- Ak je podmienka v zátvorke splnená (t.j. ak je zvyšok rovný nule), vykonáme príkazy v zloženej zátvorke za príkazom if.
- Ak podmienka nie je splnená (t.j. ak zvyšok nie je rovný nule), vykonáme príkazy v zloženej zátvorke za slovom else
- Časť else {...} je možné vynechať, ak nechceme vykonávať žiadne príkazy.
- Nateraz píšeme zátvorky { a } za if aj za else. Ak za nimi nasleduje iba jeden príkaz, môžeme ich vynechať, ľahko to však vedie k chybám, preto je lepšie ich vždy použiť.
Vnorené podmienky
Pritom príkazy if môžeme navzájom vnárať, čím vzniknú vcelku komplikované výrazy.
- Načítaj čislo a zisti, či je kladné, záporné alebo nula.
#include <iostream> using namespace std; int main(void) { int x; cout << "Please enter some number: "; cin >> x; if (x == 0) { cout << "Null" << endl; } else { if (x > 0) { cout << "Positive" << endl; } else { cout << "Negative" << endl; } } }
Cvičenie: vypíšte, koľko z čísel 2,3,5 delí zadané číslo x. Napr.
Zadajte cislo: 6 Pocet delitelov z mnoziny {2,3,5}: 2 Zadajte cislo: 60 Pocet delitelov z mnoziny {2,3,5}: 3 Zadajte cislo: 7 Pocet delitelov z mnoziny {2,3,5}: 0
Upozornenie
Častá chyba, ktorá sa vyskytuje pri podmienke je použitie priradenia namiesto porovnania. Keby sme napísali
if (x=0) cout << “Null” << endl;
tak program do premennej x priradí nulu, ktorá sa premení na logické false pre účely vyhodnotenia podmienky.
Ďalšia bežná chyba je zabudnutie zložených zátvoriek
if (x==0) cout << “Null”; cout << endl;
Tento program vykoná cout << endl vždy, nezávisle od podmienky. V prípade, že chceme vykonať v podmienke viacero príkazov, nesmieme zabudnúť ich uzátvorkovať:
if (x==0) { cout << “Null”; cout << endl; }
Cyklus (for)
Teraz si ukážeme príkaz for, ktorý nám umožňuje opakovať viackrát nejakú skupinu príkazov.
Na úvod trochu motivácie. Ako by ste napísali nasledovné jednoduché programy?
- Vypíšte čísla od 0 do 9. A následne od 0 do 24. (pre vytrvalých od 0 do 99)
- Vykreslite pravidelný štvoruholník. Šesťuholník? Devätnásťuholník?
Vypisovanie čísiel
Nasledujúci program vypíše čísla 0 až 9 oddelené medzerami bez toho, aby sme ich niekde v programe explicitne vymenovali.
#include <iostream> using namespace std; int main(void) { for (int i = 0; i < 10; i++) { cout << " " << i; } cout << endl; }
Tu je výstup programu.
0 1 2 3 4 5 6 7 8 9
Ak by sme v programe číslo 10 zmenili napr. na 25, vypíše čísla 0 do 24.
- Novou črtou tohto programu je príkaz for pre cyklus: for (int i = 0; i < 10; i++)
- Cyklus nám umožňuje opakovať určitú časť programu viackrát.
- V zátvorke za for sú tri časti oddelené bodkočiarkami.
- Príkaz int i = 0 vytvorí novú celočíselnú premenú i a priradí jej hodnotu 0.
- Podmienka i < 10 určuje dokedy sa má cyklus opakovať, t.j. kým hodnota i je menšia ako 10.
- Príkaz i++ hovorí, že v každom kroku sa má premenná i zvýšiť o jedna.
- Medzi zložené zátvorky { a } môžeme dať jeden alebo viac príkazov, ktoré sa budú opakovať pre rôzne hodnoty premennej i.
- V našom príklade máme vo vnútri cyklu iba príkaz cout << " " << i;, ktorý vypíše medzeru a hodnotu premennej i.
- Po skončení cyklu sa pokračuje príkazmi za končiacou zloženou zátvorkou, v našom prípade vypíšeme ešte koniec riadku.
- Všimnite si, že náš program obsahuje dve sady zložených zátvoriek vnorených v sebe: jedna ohraničuje celý program, jedna ohraničuje príkazy, ktorá sa robia vo vnútri cyklu.
- O presnom fungovaní príkazu for si povieme viac neskôr, ale teraz sa pozrime, čo spraví jednoduchá zmena v tomto príkaze:
for (int i = 1; i <= 10; i++) {
- Počiatočnú príkaz sme zmenili z int i = 0 na int i = 1, premenná i teda začne s hodnotou 1, nie 0. Cyklus môže začať od ľubovoľnej hodnoty (napríklad aj zápornej)
- Podmienku ukončenia sme zmenili z i < 10 na i <= 10, t.j. cyklus sa opakuje kým je hodnota premennej i menšia alebo rovná 10 (to isté by sme dosiahli aj pomocou i < 11)
- Program teda vypíše čísla od 1 po 10:
1 2 3 4 5 6 7 8 9 10
Vykreslenie náhodných kruhov
Nasledujúci program vykreslí na obrazovku náhodne rozmiestnené kruhy.
#include "../SimpleDraw.h" #include <cstdlib> #include <ctime> int main(void) { int size = 300; /* veľkosť obrázku */ int count = 30; /* počet kruhov */ int diameter = 10; /* priemer kruhu */ /* inicializácia generátora pseudonáhodných čísel */ srand(time(NULL)); SimpleDraw window(size, size); for (int i = 0; i < count; i++) { /* vykresli kruh s priemerom diameter na náhodné miesto */ window.drawEllipse(rand() % size, rand() % size, diameter, diameter); } window.showAndClose(); }
- Program využíva príkaz rand(), ktorý generuje pseudonáhodné celé čísla. (Nie sú v skutočnosti náhodné, lebo ide o pevne definovanú matematickú postupnosť, ktorá však má mnohé vlastnosti náhodných čísel).
- Výsledkom rand() je celé nezáporné číslo medzi 0 a nejakou veľkou konštantou.
- rand() % size je číslo medzi 0 a size-1
- vygenerujeme dve také čísla a použijeme ich ako súradnice kruhu (presnejšie ľavého horného rohu štvorca opísaného kruhu)
- Príkaz srand inicializuje generátor pseudonáhodných čísel na určitú hodnotu, my použijeme aktuálny čas.
- Potrebujeme knižnice cstdlib a ctime.
Skúsme pred príkaz window.drawEllipse dať ešte príkaz window.setBrushColor, ktorý nastaví farbu výplne kruhu. Túto farbu chceme tiež nastaviť na náhodnú hodnotu, t.j. vygenerujeme tri náhodné čísla pre červenú, zelenú a modrú zložku tejto farby. Tieto čísla majú byť medzi 0 a 255.
/* nastav náhodnú farbu */ window.setBrushColor(rand() % 256, rand() % 256, rand() % 256);
Cvičenie: nastavme aj priemer kruhu ako náhodné číslo od 0 do 19. Čo ak chceme priemer od 10 do 19?
Organizačné poznámky
- Štvrtok zverejnenie DÚ1 a PDÚ1
- V piatok termín odovzdania DÚ0
- Budúci pondelok zverejníme prípadné zmeny v rozdelení do skupín na cvičenia
- Budúci pondelok na cvičeniach prvá rozcvička - kreslenie so simpleDraw
- Budúci pondelok poobede nepovinný test pre pokročilých
Cvičenia 1
Cieľom prvých cvičení je vyskúšať si prostredie Netbeans a jednoduché úpravy textových aj grafických programov z prednášky. Podobné programy budete písať budúci týždeň na rozcvičke, takže doporučujeme si priniesť papier s poznámkami z prvej prednášky.
Príklad 1
- Prihláste sa na počítač a spustite Netbeans podľa návodu tu
- Vytvorte nový projekt a skopírujte si tam Hello world program z prvej prednášky
- Skúste ho skompilovať a spustiť.
- Zmodifikujte ho tak, aby vypisoval slovenskú hlášku Ahoj svet! a opäť ho skompilujte a spustite.
Príklad 2
- Vytvorte nový projekt s programom na vykreslenie domčeka z prvej prednášky
- Postupujte podľa návodu tu
- Stiahnite si grafickú knižnicu SimpleDraw a správne ju umiestnite
- Nezabudnite nastaviť novému projektu typ C/C++ Qt Application a nastaviť použitie knižnice
- Program skompilujte a spustite
- Zmodifikujte ho tak, aby nad domčekom v hornej časti obrázku bol zelený nápis Domcek
Príklad 3
Nakreslite korytnačou grafikou jedným ťahom obrázok napravo. Všetky malé trojuholníky na obrázku sú rovnostranné s dĺžkou hrany 100, veľký trojuholník má teda dĺžku hrany 200. Pripomíname, že v rovnostrannom trojuholníku majú vnútorné uhly 60 stupňov.
Príklad 4
Prihláste sa do prostredia Moodle a odovzdajte nultú domácu úlohu.
DÚ0
Odovzdávanie DÚ0 max. 2 body, termín odovzdania piatok 21.9.2012 o 22:00
Cieľom tejto domácej úlohy je oboznámiť sa so systémom Moodle, ktorý budete používať na odovzdávanie úloh aj neskôr a potvrdiť svoj záujem o tento predmet, aby sme s Vami rátali pri rozdelovaní do skupín na cvičenia.
Postup:
- Vytvorte textový súbor (napríklad v textovom editore alebo v prostredí Netbeans)
- Napíšte do neho odpovede na otázky uvedené nižšie
- Prihláste sa do systému Moodle Odovzdávanie DÚ0 pomocou AIS prihlasovacieho mena a hesla
- Zapíšte sa na predmet Programovanie (1) v C/C++ s použitím kľúča, ktorý dostanete na prednáške resp. cvičení
- Odovzdajte vytvorený textový súbor
Otázky
- Meno a priezvisko
- Emailová adresa
- Učili ste sa už programovať? Ak áno, v akom jazyku (jazykoch)?
Prednáška 3
Doteraz sme videli:
- Vypisovanie a načítavanie v textovom režime
- Vykresľovanie pomocou grafickej knižnice SimpleDraw
- Aritmetické a logické výrazy, premenné typu int a double
- Podmienku if
- Cyklus for
Dnes:
- Ďalšie príklady na cykly a podmienky, zopár menších noviniek.
Viac príkladov na cyklus for
Výpočet faktoriálu
Tento program si od užívateľa vypýta číslo n a spočíta n!, t.j. súčin celých čísel od 1 po n.
#include <iostream> using namespace std; int main(void) { int n; cout << "Please enter n: "; cin >> n; int result = 1; for (int i = 1; i <= n; i++) { result = result * i; } cout << n << "!=" << result << endl; }
Tu je príklad behu programu pre n=4 (1*2*3*4=24)
Please enter n: 4 4!=24
- Program používa premennú result, v ktorej sa ukladá dočasný výsledok. Na začiatok ju nastavíme na 1 a postupne ju násobíme číslami 1, 2, ..., n.
- Riadok result = result * i; zoberie pôvodnú hodnotu premennej result, vynásobí ju hodnotou premennej i (t.j. jedným z čísel 1, 2, ..., n) a výsledok uloží naspäť do premennej result (prepíše pôvodnú hodnotu). To isté sa dá napísať ako result *= i;
Krokovanie programu
- Skúsme si odkrokovať, ako sa budú postupne meniť hodnoty premenných počas behu programu
- Krokovanie programu a vypisovanie hodnôt premenných je možné robiť v prostredí Netbeans, mali by ste však byť schopní to robiť aj ručne, lebo tým lepšie pochopíte, ako program pracuje.
- Krokovanie v prostredí Netbeans:
- Klikneme pravým na meno projeku v záložke Projects, zvolíme Step into
- Tým sa naštaruje a hneď aj zastaví náš program, ďalej sa môžeme púšťať program riadok po riadku ikonkou Step Over (F8)
- V dolnej časti okna v záložke Variables vidíme hodnoty vybraných premenných, ďalšie si môžeme ručne pridať
Int má obmedzený rozsah
Funkcia n! veľmi rýchlo rastie a už pre n=13 sa výsledok nezmestí do premennej typu int. Dostávame nezmyselné hodnoty:
12!=479001600 13!=1932053504 14!=1278945280 15!=2004310016 16!=2004189184 17!=-288522240
Správne hodnoty sú:
12!=479001600 13!=6227020800 14!=87178291200 15!=1307674368000 16!=20922789888000 17!=355687428096000
Cvičenie: Prepíšme program na počítanie faktoriálu tak, aby vypísal aj faktoriál ako súčin čísel, napríklad
Please enter n: 4 4! = 1*2*3*4 = 24
Vypisovanie deliteľov: podmienka v cykle
Nasledujúci program načíta číslo od užívateľa a vypíše zoznam jeho deliteľov.
#include <iostream> using namespace std; int main(void) { int n; cout << "Please enter some number: "; cin >> n; cout << "Divisors of " << n << ":"; for (int i = 1; i <= n; i++) { if (n % i == 0) { cout << " " << i; } } cout << endl; }
Beh programu:
Please enter some number: 12 Divisors of 12: 1 2 3 4 6 12
Malá odbočka: úprava a čitateľnosť programov
Okrem počítača budú váš program čítať aj ľudia: vy sami, keď v ňom potrebujete nájsť chybu alebo ho v budúcnosti rozširovať, vaši kolegovia vo firme, učitelia v škole. Preto treba programy písať tak, aby boli nielen správne, ale aj prehľadné a ľahko pochopiteľné. Tu sú zásady, ktoré takejto čitateľnosti pomáhajú:
- Odsadzovanie: príkazy vykonávané v cykle alebo podmienke (medzi { a }) odsaďte o niekoľko pozícií doprava. Pri vnorených cykloch a podmienkach odsaďte každú ďalšiu úroveň viac.
- V Netbeans sa dá odsadzovanie napraviť na vybranom texte pomocou položky menu Source->Format
- Medzery a voľné riadky: prehľadnosť zvýšite, ak oddelíte ucelené časti programu voľným riadkom. V zložitejších výrazoch doporučujeme vkladať medzery okolo operátorov:
- for(int i=0;i<count;i++){
- for (int i = 0; i < count; i++) {
- Dĺžka riadku: doporučujeme sa vyhýbať sa dlhým riadkom nad 80 znakov. Sú problémy s ich tlačením alebo zobrazovaním v menších oknách, aj na veľkom monitore namáhajú čitateľa. V prípade potreby je možné dlhšiu podmenku alebo iný výraz rozdeliť na viac riadkov.
- Názvy premenných: je vhodné používať názvy premenných, ktoré vyjadrujú ich obsah (po anglicky príp. slovensky). Pri premenných v kratších programoch, alebo ktoré sa používajú len lokálne v kratšom kúsku programu môžete použiť aj krátke zaužívané názvy, napr. i a j pre premenné v cykloch, n pre počet, a pre pole.
- Komentáre: význam jednotlivých úsekov kódu je dobré popísať v komentároch.
Pri známkovaní budeme brať do úvahy aj prehľadnosť vašich programov.
Cyklus while
Okrem cyklu for môžeme použiť aj cyklus while, ktorý vyzerá nasledovne:
while (podmienka) { príkaz; }
Čítame: kým je splnená podmienka vykonávaj príkaz. Podrobnejšie:
- podmienka je výraz, ktorý sa najskôr vyhodnotí:
- ak je jeho hodnota logická nepravda, cyklus je ukončený a program pokračuje ďalším príkazom za while{...}
- ak je jeho hodnota logická pravda, vykoná sa príkaz a celý cyklus sa opäť opakuje.
Úroky v banke
Na začiatku každého roku uložíme 1000 EUR na úrokovú vkladnú knižku s ročným úrokom 5%. Zistite, za koľko rokov naše úspory dosiahnu sumu aspoň 20 000 EUR.
Vieme určite, že budeme musieť peniaze vkladať niekoľko rokov. Problém je v tom, že dopredu nevieme povedať koľko, pretože počet rokov je vlastne výstupom programu. Neformálne by sme algoritmus na vyriešenie mohli popísať takto:
- Založ si účet v banke (zatiaľ šetríš nula rokov)
- Kým nemáš na začiatku roka našetrené 20 000 EUR opakuj:
- Vlož čiastku a čakaj na nový rok, kým sa zúročia
Potrebujeme cyklus, ktorý sa bude vykonávať, kým platí nejaká podmienka - práve na to je vhodný while cyklus. Pomocou neho zapíšeme algoritmus nasledovne:
#include <iostream> using namespace std; int main(void) { double ucet = 0; int rok = 0; while (ucet < 20000) { ucet = (ucet + 1000) * 1.05; rok++; /* to isté ako rok = rok + 1 */ cout << "Na konci roku " << rok << " máme na účte " << ucet << " EUR" << endl; } }
Na konci roku 1 máme na účte 1050 EUR Na konci roku 2 máme na účte 2152.5 EUR Na konci roku 3 máme na účte 3310.12 EUR Na konci roku 4 máme na účte 4525.63 EUR Na konci roku 5 máme na účte 5801.91 EUR Na konci roku 6 máme na účte 7142.01 EUR Na konci roku 7 máme na účte 8549.11 EUR Na konci roku 8 máme na účte 10026.6 EUR Na konci roku 9 máme na účte 11577.9 EUR Na konci roku 10 máme na účte 13206.8 EUR Na konci roku 11 máme na účte 14917.1 EUR Na konci roku 12 máme na účte 16713 EUR Na konci roku 13 máme na účte 18598.6 EUR Na konci roku 14 máme na účte 20578.6 EUR
Euklidov algoritmus na nájdenie najväčšieho spoločného deliteľa
- Jeden z najstarších dodnes používaných algoritmov, Euklides ho popísal v svom diele Základy, cca 300 pred Kr.
- Máme dané dve kladné celé čísla a a b a chceme nájsť najväčšie číslo d, ktoré delí a aj b.
- Skratka nsd(a,b), po anglicky gcd(a,b) (greatest common divisor)
- Príklad:
- Delitele 12: 1, 2, 3, 4, 6, 12
- Delitele 8: 1, 2, 4, 8
- Spoločné delitele 8 a 12: 1, 2, 4
- gcd(8,12)=4
- Lema: pre všetky kladné celé čísla a a b platí: gcd(a,b) = gcd(b, a mod b)
- nech Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle x = a \bmod b, y = \lfloor a/b\rfloor}
- nech A je množina spoločných deliteľov a a b, B je množina spoločných deliteľov b a x
- ukážeme, že A=B (a teda aj Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle \max A = \max B} )
- x = a - yb a preto každý deliteľ a aj b delí aj x, t.j. Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle A\subseteq B}
- taktiež a = yb + x a preto každý deliteľ b a x delí aj a, t.j. Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle B\subseteq A}
#include <iostream> using namespace std; int main(void) { int a, b; cout << "Enter two positive integers a and b: "; cin >> a >> b; while(b != 0) { int x = a % b; a = b; b = x; } cout << "Their gcd: " << a << endl; }
Príklad behu programu:
Enter two positive integers a and b: 30 8 Their gcd: 2
Tento výpočet prešiel cez dvojice:
30 8 8 6 6 2 2 0
Nekonečný cyklus
while (true) { prikaz; }
Opakuje príkaz donekonečna (kým program nezastavíme).
Napríklad môžeme donekonečna vykresľovať náhodné kruhy, ale pozor, každý kruh berie trochu miesta v pamäti, po čase zaplníte pamäť a počítač môže dramaticky spomaliť, alebo program skončí s chybovou hláškou.
#include "../SimpleDraw.h" #include <cstdlib> #include <ctime> int main(void) { int size = 300; /* veľkosť obrázku */ int diameter = 10; /* priemer kruhu */ /* inicializácia generátora pseudonáhodných čísel */ srand(time(NULL)); SimpleDraw window(size, size); while (true) { /* vykresli kruh s priemerom diameter na náhodné miesto */ window.drawEllipse(rand() % size, rand() % size, diameter, diameter); } window.showAndClose(); }
Hra hádaj číslo
V nasledujúcom programe si počítač "myslí číslo" od 1 do 100 a užívateľ háda, o ktoré číslo ide.
Program používa premennú typu bool, do ktorej môžeme priraďovať logické hodnoty true alebo false.
#include <iostream> #include <cstdlib> #include <ctime> using namespace std; int main(void) { /* vygenerujeme náhodné číslo medzi 1 a 100 */ srand(time(NULL)); int number = rand() % 100 + 1; /* Pamätáme si, či sme už uhádli alebo nie. */ bool guessed = false; cout << "Guess a number between 1 and 100: "; /* Kým užívateľ neuhádne, spýtame sa ho na ďalšiu odpoveď. */ while (!guessed) { int guess; cin >> guess; /* Vyhodnotíme odpoveď. */ if (guess < number) { cout << "Too low, try again: "; } else if (guess > number) { cout << "Too high, try again: "; } else if (guess == number) { guessed = true; cout << "Correct guess" << endl; } } }
Príklad priebehu programu:
Guess a number between 1 and 100: 50 Too low, try again: 75 Too high, try again: 63 Too low, try again: 69 Too high, try again: 66 Too low, try again: 67 Correct guess
Príkazy break a continue (používať s mierou)
- Príkaz break: skončí sa cyklus, v ktorom práve sme, pokračuje sa prvým príkazom za cyklom.
- Príkaz continue: ide na ďalšiu iteráciu cyklu, nevykoná zvyšok tela cyklu.
Používať s mierou, robia program menej prehľadný, ľahko zavlečú chyby.
Program uvedený vyššie môžeme prepísať bez boolovskej premennej s použitím nekonečného cyklu, z ktorého ale vyskočíme príkazom break, keď užívateľ uhádne.
#include <iostream> #include <cstdlib> #include <ctime> using namespace std; int main(void) { /* vygenerujeme náhodné číslo medzi 1 a 100 */ srand(time(NULL)); int number = rand() % 100 + 1; cout << "Guess a number between 1 and 100: "; /* Kým užívateľ neuhádne, spýtame sa ho na ďalšiu odpoveď. */ while (true) { int guess; cin >> guess; /* Vyhodnotíme odpoveď. */ if (guess < number) { cout << "Too low, try again: "; } else if (guess > number) { cout << "Too high, try again: "; } else if (guess == number) { cout << "Correct guess" << endl; break; } } }
Späť k cyklu for
Cyklus for má tvar
for(prikaz1; podmienka; prikaz2) { prikaz3; }
Je ekvivalentný nasledujúcemu príkazu while:
prikaz1; while(podmienka) { prikaz3; prikaz2; }
Napríklad, nasledujúce kúsky kódu oba vypisujú čísla 0 až 9:
for (int i = 0; i < 10; i++) { cout << " " << i; }
int i = 0; while(i < 10) { cout << " " << i; i++; }
Cyklus for spravidla používame, ak má náš cyklus krátky a jednoduchý iterátor (prikaz2) a jednoduchú podmienku. V opačnom prípade väčšinou používame cyklus while.
Ešte vypisovanie deliteľov
Ak chceme vypísať deliteľov od najväčších, stačí prepísať for cyklus:
- od najmenších: for (int i = 1; i <= n; i++) {
- od najväčších: for (int i = n; i > 0; i--) {
#include <iostream> using namespace std; int main(void) { int n; cout << "Please enter some number: "; cin >> n; cout << "Divisors of " << n << ":"; for (int i = n; i > 0; i--) { if (n % i == 0) { cout << " " << i; } } cout << endl; }
Príklad behu programu:
Please enter some number: 30 Divisors of 30: 30 15 10 6 5 3 2 1
Zrýchlime program na vypisovanie deliteľov: ak i je deliteľ n, aj n/i je deliteľ, môžeme ho rovno vypísať. Aspoň jeden z tejto dvojice je najviac odmocnina z n.
#include <iostream> using namespace std; int main(void) { int n; cout << "Please enter some number: "; cin >> n; cout << "Divisors of " << n << ":"; for(int i=1; i*i<=n; i++) { if (n % i == 0) { int j = n / i; cout << " " << i << " " << j; } } cout << endl; }
Cvičenie: Tento program nefunguje celkom správne, občas vypíše nejaké číslo dvakrát. Kedy? Ako ho vieme opraviť?
Pomalší program, ktorý skúša všetky čísla po n trvá pre n=1234567890 na mojom počítači 4.5s. Program, ktorý ide iba po odmocninu trvá 0.0002s.
Vnorené cykly
Vykreslime šachovnicu s n x n štvorčekmi, ktoré sú striedavo čierne a žlté.
- Potrebujeme na to dva vnorené cykly, jeden pôjde cez riadky šachovnice, druhý pre stĺpce.
- Ak row + column je párne, kreslíme čierny štvorec, inak kreslíme žltý.
#include "../SimpleDraw.h" int main(void) { int n = 8; /* počet štvorcov v riadku a stĺpci*/ int square = 20; /* veľkosť jedného štvorca */ int size = n * square; /* veľkosť obrázku */ SimpleDraw window(size, size); for (int row = 0; row < n; row++) { for (int column = 0; column < n; column++) { if ((row + column) % 2 == 0) { window.setBrushColor("black"); } else { window.setBrushColor("yellow"); } window.drawRectangle(column * square, row * square, square, square); } } window.showAndClose(); }
To isté, ale najskôr vykreslíme veľký žltý štvorec, potom do neho vkresľujeme malé čierne štvorčeky.
- V cykle pre stĺpce preskakujeme každý druhý štvorec, pričom ak row je párny, začíname od 0, ak je nepárny, začíname od 1
- for (int column = row % 2; column < n; column += 2) {
- príkaz column += 2 je to isté ako column = column + 2
#include "../SimpleDraw.h" int main(void) { int n = 8; /* počet štvorcov v riadku a stĺpci*/ int square = 20; /* veľkosť jedného štvorca */ int size = n * square; /* veľkosť obrázku */ SimpleDraw window(size, size); /* veľký žltý štvorec */ window.setBrushColor("yellow"); window.drawRectangle(0,0,size,size); /* nastavíme farbu na čiernu */ window.setBrushColor("black"); for (int row = 0; row < n; row++) { for (int column = row % 2; column < n; column += 2) { window.drawRectangle(column * square, row * square, square, square); } } window.showAndClose(); }
Zhrnutie
- Videli sme niekoľko príkladov využitia cyklov for a while.
- Cyklus for je možné zapísať ako while (a naopak).
- Logické hodnoty true a false vieme ukladať do premenných typu bool.
- Z cyklu vieme vyskočiť príkazom break, prejsť na ďalšiu iteráciu príkazom continue. Používať s mierou.
- Euklidov algoritmus rýchlo nájde najväčšieho spoločného deliteľa dvoch čísel.
- Dôležitá je prehľadná úprava programov a názvy premenných súvisiace s ich obsahom.
- Netbeans umožňuje krokovať program, mali by ste to však vedieť robiť aj ručne.
Organizačné poznámky
- Dnes cvičenia podľa pôvodného rozvrhu, prvá rozcvička
- O 14:50 v F-108 test pre pokročilých
- Zajtra prednáška, téma podprogramy
- Na stránke zadania DÚ1, riešte do pondelka 1.10.2012 (koncom tohto týždňa pribudnú zadania DÚ2)
Prednáška 4
- Funkcia je skupina príkazov s určitým menom, ktorú môžeme spustiť a vykonať tak určitú akciu alebo vypočítať určitú hodnotu
- Možno ste stretli iné termíny s podobným významom, ako procedúra, metóda, podprogram
- V našich programoch sme už používali hotové funkcie
- Napríklad sqrt(x) je funkcia, ktorá nám povie druhú odmocninu čísla x.
- V grafických programoch sme napríklad používali funkciu window.drawRectangle(x, y, s, v) z knižnice SimpleDraw, ktorá na grafickej obrazovke vykreslí obdĺždnik.
Teraz sa pozrieme na to, ako vytvoriť v programe vlastnú funkciu. Doteraz sme vytvorili jedinú funkciu - funkciu main.
Motivačný príklad: Obvod trojuholníka
Chceme napísať program, ktorý načíta súradnice vrcholov trojuholníka a spočíta jeho obvod, tu je príklad jeho behu:
Zadaj suradnice vrcholu A oddelene medzerou: 0 0 Zadaj suradnice vrcholu B oddelene medzerou: 3 0 Zadaj suradnice vrcholu C oddelene medzerou: 0 4 Obvod trojuholnika ABC: 12
Obvod spočítame ako súčet dĺžok jednotlivých strán, v programe teda trikrát opakujeme výpočet dĺžky strany. Pri opakovaní dlhšieho vzorca ľahko spravíme chybu.
#include <iostream> #include <cmath> using namespace std; int main(void) { double xa, ya, xb, yb, xc, yc; cout << "Zadaj suradnice vrcholu A oddelene medzerou: "; cin >> xa >> ya; cout << "Zadaj suradnice vrcholu B oddelene medzerou: "; cin >> xb >> yb; cout << "Zadaj suradnice vrcholu C oddelene medzerou: "; cin >> xc >> yc; /* spocitaj dlzky stran */ double da = sqrt((xb - xc) * (xb - xc) + (yb - yc) * (yb - yc)); double db = sqrt((xa - xc) * (xa - xc) + (ya - yc) * (ya - yc)); double dc = sqrt((xa - xb) * (xa - xb) + (ya - yb) * (ya - yb)); cout << "Obvod trojuholnika ABC: " << da + db + dc << endl; }
Definícia funkcie
Vzorec na výpočet môžeme zapísať ako funkciu:
double dlzka(double x1, double y1, double x2, double y2) { return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)); }
Definícia funkcie má nasledovné časti:
- Návratová hodnotu funkcie: Naša funkcia vracia dĺžku, teda hodnotu typu double (desatinné číslo). V prípade, že by funkcia nemala vrátiť nič, jej návratová hodnota je typu void. Také sú napríklad funkcie, ktoré niečo vypisujú alebo vykresľujú.
- Názov funkcie: zvolíme si ako chceme, podobne ako pri premenných. Vhodné je použiť názov, ktorý vystihuje, čo funkcia počíta, napríklad dlzka
- Zoznam parametrov funkcie: V zátvorkách za názvom funkcie je zoznam typov a názvov premenných, ktoré funkcia očakáva. V našom príklade funkcia očakáva súradnice dvoch vrcholov, teda štyri hodnoty typu double. Funkcie môžu mať zoznam parametrov aj prázdny.
- Telo funkcie: V zložených zátvorkách za definíciou funkcie je jej vlastný obsah, teda zoznam príkazov, ktoré má funkcia vykonať.
- Príkaz return: Vracia hodnotu funkcie.
Program s využitím funkcie
Celý program s funkciou dlzka
- vzorec na výpočet dĺžky je teraz iba na jednom mieste
#include <iostream> #include <cmath> using namespace std; double dlzka(double x1, double y1, double x2, double y2) { return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)); } int main(void) { double xa, ya, xb, yb, xc, yc; cout << "Zadaj suradnice vrcholu A oddelene medzerou: "; cin >> xa >> ya; cout << "Zadaj suradnice vrcholu B oddelene medzerou: "; cin >> xb >> yb; cout << "Zadaj suradnice vrcholu C oddelene medzerou: "; cin >> xc >> yc; /* spocitaj dlzky stran */ double da = dlzka(xb, yb, xc, yc); double db = dlzka(xa, ya, xc, yc); double dc = dlzka(xa, ya, xb, yb); cout << "Obvod trojuholnika ABC: " << da + db + dc << endl; }
Funkcia môže obsahovať aj viacero príkazov. V našom príklade môžeme napríklad výpočet rozložiť na tri kroky:
double dlzka(double x1, double y1, double x2, double y2) { double dx = x1 - x2; double dy = y1 - y2; return sqrt(dx * dx + dy * dy); }
Cvičenie: v Pascale je funkcia sqr(x), ktorá vráti x na druhú. Naprogramujte túto funkciu v jazyku C a použite ju na zjednodušenie funkcie dlzka.
- V jazyku C by sme mohli použiť pow(x,2), ale môže byť jednoduchšie zrátať x*x.
Príkaz return
- Pri vykonaní príkazu return je funkcia okamžite zastavená a jej výstupná hodnota je výraz za slovom return.
- Ak funkcia má niečo vrátiť (jej návratový typ nie je void), musí obsahovať return.
- Príkazov return môže obsahovať viac, ale tak, aby každé možné prejdenie funkciou bolo ukončené príkazom return.
Dva spôsoby, ako napísať funkciu min, ktorá vráti menšie z dvoch zadaných čísel a a b:
int min(int a, int b) { int minval; if (a < b) { minval = a; } else { minval = b; } return minval; }
int min(int a, int b) { if (a < b) { return a; } else { return b; } }
Vo funkciách, ktoré vracajú void, môže ale nemusí byť return. To znamená, že oba nasledovné programy sú v poriadku.
void printmessage () { cout << "I'm a function!"; }
void printmessage () { cout << "I'm a function!"; return; }
Cvičenie: čo vráti nasledujúca funkcia pre n=6? Čo vráti pre n=7? Viete stručne popísať, čo robí pre všeobecné n?
int zahada(int n) { for (int i = 2; i * i <= n; i++) { if (n % i == 0) { return i; } } return n; }
Lokálne a globálne premenné
- Globálne premenné sú definované mimo akejkoľvek funkcie
- môžu ich používať všetky funkcie definované pod nimi
- Lokálne premenné sú definované vo vnútri funkcie
- môže ich používať iba táto funkcia
Príklad: program s globálnou premennou x a dvomi lokálnymi premennými v rôznych funkciách
#include <iostream> using namespace std; int x = 0; // globálna premenná void vypis() { int y = 1; // lokálna premenná vo funkcii vypis cout << x << " " << y << endl; } int main(void) { int z = 2; // lokálna premenná vo funkcii main cout << x << " " << z << endl; vypis(); }
- Viaceré funkcie môžu mať lokálne premenné s tým istým menom, každá používa tú svoju
- Ak má lokálna a globálna premenná to isté meno, lokálna premenná prekryje globálnu, funkcia teda používa svoju lokálnu premennú (bližšia košeľa ako kabát)
Príklad:
void Fnc () { // i=13; – nemôžeme používať premennú i – žiadna premenná i nie je viditeľná } int i; void Fnc2 () { i=50; // priradí sa do globálne premennej i! Fnc (); } void Fnc1 () { int i; i=2; // priradí sa do lokálnej premennej i, ktorá vznikla v tejto funkcii // uvedomte si, že v tomto okamihu existujú 3 premenné s menom i : // i – globálna premenná, // lokálna premenná i, ktorá vznikla vo funkcii main, // a lokálna premenná i, ktorá vznikla v tejto funkcii. } void main () { int i; i=1; // priraďuje sa do lokálnej premennej i a nie do globálnej premennej i, // globálna premenná i je prekrytá – identifikátor i označuje lokálnu premennú i. Fnc1 (); // lokálna premenná i má stále hodnotu 1 Fnc2 (); // lokálna premenná i má stále hodnotu 1, globálna premenná i má hodnotu 50, }
Parametre funkcií
Odovzdávanie parametrov hodnotou
Funkcie majú často parametre.
- Tieto parametre sa správajú ako lokálne premenné danej funkcie
- Pri volaní funkcie sa im priradí hodnota, ktorú zadal používateľ funkcie (tento mechanizmus voláme odovzdávanie parametrov hodnotou)
- Túto hodnotu síce môžeme meniť, ale táto zmena sa neprejaví na mieste, odkiaľ funkciu voláme
Príklad:
#include <iostream> using namespace std; void vypis(int x) { cout << "Predtym: " << x; /* vypiseme povodnu hodnotu x */ x++; /* zvysime hodnotu x o 1 */ cout << ", potom: " << x << endl; /* vypiseme nove x */ } int main(void) { int x = 0; int y = 3; vypis(x); /* vypise Predtym: 0, potom: 1 */ vypis(x); /* vypise Predtym: 0, potom: 1 */ vypis(y); /* vypise Predtym: 3, potom: 4 */ vypis(y); /* vypise Predtym: 3, potom: 4 */ vypis(y + 7); /* vypise Predtym: 10, potom: 11 */ }
Odovzdávanie parametrov referenciou
- Ak pred meno parametra v hlavičke funkcie dáme &, parameter sa bude odovzdávať referenciou
- Pri použití takejto funkcie môžeme ako parameter zadať iba premennú, nie iný výraz
- Namiesto samotnej hodnoty sa funkcii pošle adresa premennej v pamäti (referencia)
- Táto sa bude vo funkcii používať pod novým menom, prípadné zmeny sa prejavia aj na mieste, odkiaľ sme funkciu volali
#include <iostream> using namespace std; void vypis(int & x) { cout << "Predtym: " << x; /* vypiseme povodnu hodnotu x */ x++; /* zvysime hodnotu x o 1 */ cout << ", potom: " << x << endl; /* vypiseme nove x */ } int main(void) { int x = 0; int y = 3; vypis(x); /* vypise Predtym: 0, potom: 1 */ vypis(x); /* vypise Predtym: 1, potom: 2 */ vypis(y); /* vypise Predtym: 3, potom: 4 */ vypis(y); /* vypise Predtym: 4, potom: 5 */ /* vypis(y + 7); toto teraz nemozeme pouzit, y+7 nie je premenna */ }
Odovzdávanie referenciou: viac ako jedna návratová hodnota
Odovzdávanie parametra referenciou používame napríklad vtedy, ak máme vrátiť viac ako jednu hodnotu.
Funkcia stred dostane hodnotou súradnice dvoch bodov (x1,y1) a (x2,y2) a do parametrov xs, ys, ktoré sú odovzdané referenciou, uloží súradnice stredu úsečky.
#include <iostream> using namespace std; void stred(double x1, double y1, double x2, double y2, double &xs, double &ys) { xs = (x1 + x2) / 2; ys = (y1 + y2) / 2; } int main(void) { double x1, y1, x2, y2; double x, y; cout << "Napiste suradnice jedneho konca usecky (oddelene medzerou): "; cin >> x1 >> y1; cout << "Napiste suradnice druheho konca usecky (oddelene medzerou): "; cin >> x2 >> y2; stred(x1, y1, x2, y2, x, y); cout << "Stred usecky je [" << x << "," << y << "]." << endl; }
Odovzdávanie referenciou: Funkcia, ktorej úlohou je zmeniť svoj parameter
Ďalší dôvod pre odovzdávanie parametrov referenciou je, keď chceme vo funkcii priamo parameter meniť s trvalými následkami.
- Typickým príkladom je funkcia swap, ktorá vymení hodnoty dvoch premenných, ktoré dostane ako parametre
#include <iostream> using namespace std; void swap(int &a, int &b) { int tmp = a; a = b; b = tmp; } int main() { int x = 1, y = 3; swap(x, y); cout << "x=" << x << ", y=" << y << endl; return 0; }
Keby sme funkcii odovzdali parameter hodnotou tj, void swap(int a, int b), vo funkcii main by sa premenné nevymenili.
Odovzdávanie indikátoru chyby
Niektoré funkcie potrebujú, aby parameter spĺňal určité podmienky. Napríklad odmocninu vieme spočítať iba z nezáporného čísla. Čo vlastne môžeme urobiť, keď dostaneme zlý parameter?
- Môžeme okamžite ukončiť celý program. V knižnici cstdlib je funkcia exit, ktorá robí presne to. Má ako parameter návratovú hodnotu celého programu
double mySqrt(double x) { if (x < 0) { exit(1); } // zlý vstup: ukončíme program else { return sqrt(x); } // dobrý vstup: spočítame odmocninu }
- Pohodlnejší spôsob ukončenia programu pri zlom vstupe je funkcia assert z knižnice cassert, ktorá ako parameter dostane logickú hodnotu, a ak je tá hodnota nepravda, ukončí program s chybovou hláškou.
- Pri dôležitých programoch ale nechceme, aby len tak skončili pri každej chybe
double mySqrt(double x) { assert(x >= 0); // tvrdime, ze x>=0, inak program skonci return sqrt(x); // teraz mozeme veselo odmocnovat }
- Bežný spôsob, o ktorom sa budeme učiť v druhom semestri, sú takzvané výnimky (exceptions)
- Môžeme vrátiť nejakú špeciálnu hodnotu, ktorá odzrkadľuje, že vstup bol zlý. Používateľ funkcie by mal túto hodnotu rozoznať od správneho výstupu funkcie. Ale dôvera v používateľa sa všeobecne v softvérovom inžinierstve neodporúča.
- Knižničná funkcia sqrt vráti pre záporné čísla špeciálnu hodnotu NaN (not a number), my vrátime napr. -1
double mySqrt(double x) { if (x < 0) { return -1; } // zlý vstup: vrátime -1 else { return sqrt(x); } // dobrý vstup: spočítame odmocninu }
- Môžeme ako výstup funkcie vrátiť, či sa podarilo alebo nepodarilo správne vypočítať hodnotu. Výstupom funkcie bude logická hodnota typu bool a samotnú hodnotu vrátime v parametri odovzdanom referenciou
bool mySqrt(double x, double & result) { if (x < 0) { return false; } // zlý vstup: vrátime false else { result = sqrt(x); // dobrý vstup: spočítame odmocninu a vrátime true return true; } }
Ešte jeden príklad: Fibonacciho čísla
Fibonacciho postupnosť je postupnosť čísel, v ktorej každý ďalší člen je súčtom dvoch predchádzajúcich. Jednotlivé členy postupnosti sa nazývajú Fibonacciho čísla.
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393…
Na výpočet Fibonacciho čísel používame nasledovný vzťah:
- F(0) = 0
- F(1) = 1
- F(n)=F(n-1)+F(n-2)
Napíšeme funkciu, ktorá bude počítať Fibonacciho čísla. Na otázku "Aké je ôsme Fibonacciho číslo?" teda odpovie "21".
- Cvičenie: Pozor, nefunguje správne pre nulu, skúste opraviť
int fibonacci(int n) { int f = 1; // Cislo F(i) int oldF = 0; // Cislo F(i-1) for (int i = 2; i <= n; i++) { int newF = f + oldF; // spocitaj nove F(i) pre vyssie i oldF = f; // poposuvaj hodnoty f = newF; } return f; }
Cvičenie: napíšte funkciu printFibonacci, ktorá vypíše prvých n Fibonacciho čísel.
- Akú by mala mať hlavičku?
- Skúste dva spôsoby implementácie:
- volaním funkcie fibonacci pre rôzne hodnoty n
- prepísaním tejto funkcie, aby sa hodnoty vypisovali priamo ako sa počítajú
- Ktorý spôsob bude rýchlejší pre veľké n a prečo?
Ďalšie poznámky o funkciách
Kde definovať funkciu?
Funkcia musí byť definovaná pred tým, ako ju v programe použijeme, aby kompilátor vedel skontrolovať korektnosť jej použitia (počet parametrov, ich typ..).
V prípade, že to nie je možné urobiť, potrebujeme aspoň dopredu oznámiť, že takéto funkcie budú. Urobíme to pomocou prototypu funkcie type name ( argument_type1, argument_type2, ...);
#include <iostream> using namespace std; void odd (int a); // prototypy void even (int a); int main () { int i; do { cout << "Type a number (0 to exit): "; cin >> i; odd (i); } while (i!=0); return 0; } void odd (int a) { if ((a%2)!=0) cout << "Number is odd.\n"; else even (a); } void even (int a) { if ((a%2)==0) cout << "Number is even.\n"; else odd (a); }
Funkcia main
Má od ostatných funkcií niekoľko odlišností
- Síce má návratový typ (int), ale nemusí nič vracať.
- V programe sa nemôže volať - jediné jej volanie je automatické (začína sa ním beh programu)
- Má predpísané argumenty, ktoré sa dajú vynechať (viac o nich neskôr)
Príklad: obmena problému z cvičení
Máme dané dva intervaly [a,b] a [c,d] a chceme buď vypísať ich prienik, alebo správu, že sú disjunktné. Podobný príklad sme riešili na cvičeniach pomocou vnorených podmienok.
- Vzniká viacero možností, podľa toho, či prvý interval začína naľavo alebo napravo od druhého
- Prácu si teda zjednodušíme tým, že ak je prvý interval napravo, prehodíme intervaly.
- Potom máme isté, že prvý interval začína skôr ako druhý, a teda intervaly sú disjunktné práve vtedy, ak prvý aj skončí skôr ako druhý začne.
- V opačnom prípade je prienik od začiatku druhého intervalu po prvý koniec, teda menšie z čísel b,d.
- V programe môžeme využiť funkcie min a swap, ktoré sme videli vyššie.
- Dobre navrhnuté funkcie sa často dajú použiť vo viacerých programoch.
#include <iostream> using namespace std; void swap(int &x, int &y) { int tmp = x; x = y; y = tmp; } int min(int x, int y) { if (x < y) { return x; } else { return y; } } int main(void) { int a, b, c, d; cout << "Zadajte zaciatok a koniec prveho intervalu: "; cin >> a >> b; cout << "Zadajte zaciatok a koniec druheho intervalu: "; cin >> c >> d; /* Chceme, aby zaciatok prveho intervalu bol <= zaciatku druheho. */ if (c < a) { swap(a, c); swap(b, d); } if (b < c) { cout << "Intervaly su disjunktne." << endl; } else { cout << "Ich prienik je interval [" << c << "," << min(b, d) << "]" << endl; } }
Zhrnutie
- Funkcie nám umožňujú rozbiť väčší program na menšie logické časti a tým ho sprehľadniť. Tiež nám umožňujú vyhnúť sa opakovaniu podobných kusov kódu.
- Hlavička funkcie obsahuje návratový typ (môže byť void), meno funkcie, typy a mená parametrov.
- V tele funkcie sú samotné príkazy. Vypočítanú hodnotu vrátime príkazom return.
- Lokálne premenné sú viditeľné len vo funkcii, ktoré ich definuje, globálne vo všetkých funkciách.
- Parametre odovzdávané hodnotou sú lokálne premenné inicializované určitou hodnotou, ktorú zadá užívateľ funkcie.
- Parametre odovzdávané referenciou (&) sú len novým menom pre inú premennú.
Organizačné poznámky
- Na stránke zadania DÚ1, riešte do pondelka 1.10.2012
- Ak chcete namiesto toho robiť DÚ pre pokročilých, hláste sa vyučujúcim
- Vo štvrtok na stránke pribudnú zadania DÚ2
- Výsledky testu pre pokročilých pravdepodobne dnes v Moodli
- Budúci týždeň opäť prednášky, cvičenia a rozcvička (z tohtotýždenných cvičení)
- Nezabudnite si v AISe spraviť prípadné zmeny v zápise (do nedele 30.9.) a dať si ich potvrdiť na študijnom (do piatku 5.10.). Pred koncom tejto doby bývajú na študijnom dlhé rady, choďte čím skôr.
Cvičenia 2
Úlohou dnešného cvičenia je precvičiť si logické a aritmetické výrazy, podmienky a jednoduché použitie cyklu for.
- Nasledujúce dva úryvky programu robia to isté, pričom prvý používa logický operátor && (and) a druhý používa dva príkazy if:
//Verzia 1: if(x>0 && y>0) { cout << "Yes!"; } //Verzia 2: if(x>0) { if(y>0) { cout << "Yes!"; } }
- Podobne nahraďte logické operátory && a || aj v nasledujúcich príkazoch:
if(x>0 || y>0) { cout << "Yes!"; } if (x>0 || (x<0 && y<0)) { cout << "Yes!"; } if (x<0 && (y<0 || z<0)) { cout << "Yes!"; }
- Nech x je nejaký logický výraz. Čomu sa rovnajú nasledovné výrazy?
x && true x && false x || true x || false x && x x || x x && !x x || !x x == true x == false
- Napíšte program, ktorý načíta dve čísla a vypíše to väčšie z nich.
- Napíšte program, ktorý korytnačou grafikou vykreslí pravidelný n-uholník. V programe si zadefinujte a použite nasledujúce premenné
int size = 300; /* veľkosť obrázku */ int length = 200; /* dĺžka strany */ int n = 4; /* počet strán */
Vyskúšajte meniť hodnoty premenných a pozrite si výsledok.
- Napíšte program, ktorý načíta tri celé čísla a vypíše, či môžu byť stranami jedného trojuholníka.
- Napíšte program, ktorý vypíše tabuľku druhých mocnín čísel 1,2,...,n. Výstup bude mať takúto formu:
1 squared is 1 2 squared is 4 3 squared is 9 ...
- Napíšte program, ktorý načíta štyri celé čísla a,b,c,d, ktoré predstavujú dva uzavreté intervaly [a,b] a [c,d]. Program vypíše tú z nasledujúcich viet, ktorá pre ne platí:
Intervaly su disjunktne (maju prazdny prienik). Jeden z intervalov je podmnozinou druheho. Intervaly sa pretinaju, ale ziaden nie je podmnozinou druheho.
- Napíšte program, ktorý načíta dĺžku základne a výšku rovnoramenného trojuholníka a vykreslí ho pomocou drawLine. Veľkosť obrázku môžete zvoliť pevne 300x300 a horný vrchol trojuholníka (150,20).
- Prepíšte predchádzajúci program, aby používal korytnačiu grafiku. Potrebné dĺžky spočítajte Pytagorovou vetou a uhly spočítajte napr. funkciou atan (arkus tangens). Pozor, atan vracia radiány, treba prepočítať na stupne. Zadefinujte si a použite premennú double pi = 3.1415926536; Ak budete kresliť obrázok obidvoma spôsobmi do tej iste plochy, môžete si overiť, či dostanete to isté.
- Napíšte program, ktorý vykreslí špirálu korytnačou grafikou ako na obrázku vpravo. Špirála pozostáva z n úsečiek, pričom prvá má dĺžku d a každá ďalšia je o d dlhšia od predchádzajúcej. Čísla n a d sú uložené v premenných. Veľkosť obrázku uložte do ďalšej premennej size. Korytnačka nech začína v strede plochy.
DÚ1
Odovzdávanie DÚ max. 10 bodov, termín odovzdania pondelok 1.10. o 22:00
Ak narazíte pri riešení úlohy na problémy, s ktorými si neviete poradiť, neváhajte sa poradiť s vyučujúcimi. Neopisujte od spolužiakov ani z iných zdrojov.
Cieľom tejto domácej úlohy je precvičiť si prácu s grafickou knižnicou, textovým vstupom a výstupom, jednoduchými premennými a aritmetickými výrazmi, ako aj použitie podmienok.
Napíšte program, ktorý na základe vstupu od užívateľa vykreslí pomocou knižnice simpleDraw obrazec ako na obrázkoch nižšie. Tento obrazec pozostáva z dvoch farebných štvorcov rovnakej veľkosti, pričom žltý štvorec je umiestnený vyššie a viac vľavo a modrý štvorec nižšie a viac vpravo. Prienik týchto štvorcov tvorí tiež štvorec, ktorý má byť na obrázku vyfarbený zelenou farbou (kreslíte teda tri štvorce s farbami yellow, blue a green). Štvorce sú umiestnené v obrázku štvorcovej veľkosti tak, aby na všetkých stranách bola rovnaká medzera medzi okrajom obrázku a najkrajnejšou stranou štvorca (táto medzera sa v skutočnosti môže mierne líšiť kvôli zaokrúhľovaniu).
Váš program si najskôr od užívateľa vypýta tri hodnoty, ktoré uloží do premenných:
- Celková veľkosť obrázku o
- Veľkosť dvoch väčších štvorcov s
- Veľkosť prieniku štvorcov p
Potom váš program spraví kontrolu správnosti vstupov. Predpokladajte, že užívateľ skutočne zadal celé čísla, to nemusíte kontrolovať. Spravte však nasledujúce kontroly:
- Každé zo vstupných čísel by malo byť v rozsahu od 10 po 1000 vrátane. Ak to tak nie je, program by mal vypísať chybovú hlášku "Zla hodnota"
- Prienik štvorcov nemôže byť väčší ako samotné štvorce. Ak táto chyba nastane, program by mal vypísať chybovú hlášku "Prilis velky prienik"
- Veľkost obrázku musí byť dostatočná na to, aby sa do neho zmestili oba štvorce príslušnej veľkosti so zadaným prienikom. Ak tomu tak nie je, program by mal vypísať chybovú hlášku "Prilis maly obrazok"
Ak váš program vypíše niektorú z týchto chybových hlásení, nemal by už nič ďalšie vypisovať ani vykresľovať. Ak program nenájde v zadaných číslach žiadnu chybu, vytvorí grafické okno s požadovaným obrázkom, zapíše obrázok do súboru stvorce.png a čaká kým užívateľ stlačí Exit.
Váš program by mal byť skompilovateľný a spustiteľný v prostredí používanom na cvičeniach. V prostredí moodle odovzdajte súbor main.cpp obsahujúci váš program.
Poznámka: To či máte štvorce správne umiestnené v rámci obrázku doporučujeme skontrolovať vo vytvorenom png súbore, lebo veľkosť grafického okna môže byť iná ako veľkosť obrázku.
Príklady:
Príklad pre o=300,s=200,p=150 | Príklad pre o=300,s=100,p=20 |
![]() |
![]() |
Pokročilá DÚ1
Odovzdávanie DÚ max. 20 bodov + 4 body bonus, termín odovzdania pondelok 8.10. o 22:00
Odovzdávať pokročilé domáce úlohy môžete iba po predchádzajúcom schválení vyučujúcimi, alebo ak ste napísali test pre pokročilých aspoň na 50%. Nie je možné striedať pokročilé a bežné domáce úlohy, s výnimkou DÚ0. Ak narazíte pri riešení úlohy na problémy, s ktorými si neviete poradiť, neváhajte sa poradiť s vyučujúcimi. Neopisujte od spolužiakov ani z iných zdrojov. Dbajte na prehľadný štýl programu (vhodné pomenovanie premenných, komentáre, formátovanie...).
Cieľom tejto domácej úlohy je precvičiť si prácu s cyklami, poliami a súbormi. Vašou úlohou je implementovať mierne zjednodušenú verzou algoritmu k-means clustering, ktorý je popísaný nižšie. Viac o tomto algoritme sa dozviete napríklad na Wikipédii. Algoritmus k-means clustering sa používa pri analýze dát. Jeho cieľom je zadeliť vstupné dáta do k skupín, nazývaných zhluky (clusters) tak, aby dáta v rámci jedného zhluku boli na seba podobné a dáta z rôznych zhlukov aby sa podobali menej.
Algoritmus k-means clustering
Vstupné dáta sú body vo viacrozmernom priestore, teda každý bod je vektor reálnych čísel rozmeru DIM. Každý zhluk je reprezentovaný svojim stredom, ktorý je tiež bod z priestoru rozmeru DIM. Na počítanie vzdialenosti medzi bodmi budeme používať bežnú Euklidovskú vzdialenosť dvoch bodov v priestore (vzorec na jej výpočet nájdete napríklad tu). Pre každý bod môžeme teda spočítať jeho vzdialenosť od stredu zhluku, do ktorého bol priradený. K-means clustering sa snaží nájsť také zhlukovanie, aby súčet druhých mocnín týchto vzdialeností pre všetky vstupné body bol čo najmenší (nie vždy však nájde najlepšie možné také zhlukovanie).
Postupujte nasledovne: Na začiatku zvoľte ako stredy zhlukov prvých K vstupných bodov. Potom opakujte nasledujúce dva kroky:
- Pre každý vstupný bod spočítame jeho vzdialenosť od stredov všetkých zhlukov a priradíme do toho zhluku, ku ktorého stredu je najbližšie.
- Pre každý zhluk vypočítame nový stred na základe bodov do neho patriacich. Každú súradnicu nového stredu vyrátame ako aritmetický priemer danej súradnice cez všetky body patriace do tohto zhluku.
V praxi sa tieto kroky opakujú, kým dochádza k nejakému zlepšeniu, my si však situáciu uľahčíme a budeme ich opakovať pevný počet krát.
Vstup a výstup
Poskytujeme Vám dva vstupné súbory. V prvom je malý hračkársky prípad s dvojrozmernými bodmi, ktorý môžete použiť na ladenie programu. Druhý, väčší vstup, obsahuje údaje o zložení rôznych jedál. Každý vstupný bod reprezentuje jeden typ jedla ako 18-rozmerný vektor s nasledujúcimi položkami: zrno, celé zrno, zelenina, oranžová zelenina, tmavozelená zelenina, škrobová zelenina, iná zelenina, ovocie, mlieko, mäso, sója, fazuľa a hrach, olej, tuhý tuk, pridaný cukor, alkohol, kalórie, nasýtené tuky. Dáta boli získané zo stránky https://explore.data.gov/Health-and-Nutrition/MyPyramid-Food-Raw-Data/b978-7txq
V oboch súboroch sú údaje pre každý vstupný bod na jednom riadku, pričom prvý stĺpec obsahuje textový identifikátor bodu (reťazec bez medzier a iných bielych znakov) a ďalšie stĺpce obsahujú desatinné čísla tvoriace príslušný vektor. Stĺpce sú oddelené medzerami.
Vo výstupnom súbore by mali byť tie isté dáta ako vo vstupnom súbore aj v tom istom poradí, ale na začiatok každého riadku pridajte nový stĺpec obsahujúci číslo zhluku, do ktorého daný vstupný bod patrí. Zhluky čísľujte 0,1,...,K-1. Navyše ako prvých K riadkov súboru vypíšte stredy nájdených zhlukov v tom istom formáte, t.j. najprv číslo zhluku, potom názov riadku vo formáte cluster_1 kde 1 je nahradená príslušným číslom zhluku a potom hodnoty jednotlivých súradníc. Všetky súradnice vo výstupnom súbore vypisujte na 5 desatinných miest.
Potrebné súbory:
Implementačné detaily
Na začiatku programu si zadefinujte nasledujúce konštanty a používajte ich v programe:
const char * INPUT = "food.txt"; /* meno vstupného súboru */ const char * OUTPUT = "clusters.txt"; /* meno výstupného súboru */ const int ROWS = 579; /* počet vstupných bodov, resp. počet riadkov vo vstupnom súbore */ const int DIM = 18; /* rozmer vstupných bodov */ const int MAX_NAME_LENGTH = 50; /* najväčšia možná dĺžka mena riadku vo vstupnom súbore */ const int K = 4; /* počet hľadaných zhlukov */ const int STEPS = 20; /* počet krokov algoritmu */
Pri testovaní meňte tieto konštanty podľa potreby (ROWS a DIM prispôsobte vstupnému súboru), ale v odovzdanom súbore nastavte konštanty na hodnoty uvedené vyššie.
Vstupné dáta načítavajte zo súboru s menom v konštante INPUT a vypisujte do súboru s menom v konštante OUTPUT, pričom dodržujte formát súboru uvedený vyššie. Nemusíte kontrolovať správnosť vstupných dát.
Pri písaní programu budete potrebovať niektoré črty jazyka C, ktoré ešte neboli preberané na prednáškach. Prečítajte si o nich v príručkách jazyka C resp. C++ alebo na prednáškach z minulého roku:
- Dvojrozmerné polia na uchovávanie vstupných vektorov a stredov zhlukov. Na prednáške minulý rok sme viacrozmerné polia robili pomocou smerníkov, oveľa jednoduchšie je však zadefinovať dvojrozmerné pole s pevnými veľkosťami, napr. double data[ROWS][DIM]; K prvkom tohto poľa potom pristupujeme napr. data[riadok][stlpec]
- Prednáška o dvojrozmerných poliach cez smerníky: [4]
- Reťazce na uchovávanie mien riadkov (použite buď C++ typ string, alebo pole znakov pevnej veľkosti; všetky mená riadkov môžete dať napr. do poľa typu char mena[ROWS][MAX_NAME_LENGTH+1])
- Prednáška o reťazcoch: [5]
Bonus
Dôležitým aspektom spracovania dát je aj vizualizácia výsledkov. V tejto časti je vašou úlohou zobraziť výsledky vášho zhlukovania dát v súbore food.txt. Vyberte si dva zaujímavé stĺpce z tohto súboru a použite jeden z nich ako x-ovú a jeden ako y-ovú súradnicu. Každý bod zo súboru potom nakreslite na jeho pozíciu (x,y), pričom farbu značky zvoľte podľa čísla zhluku (použijete teda 4 farby, každú pre jeden zhluk). K bodu malým písmom pripíšte jeho meno (nevadí ak sa tieto popisky budú na niektorých miestach prekrývať). Skúste trochu experimetnovať s tým, ktoré dva stĺpce vybrať aby obrázok vyzeral rozumne.
Tento graf vytvorte v systéme gnuplot alebo v systéme R, čo sú dva často používané systémy na vizualizáciu dát. Sú to pomerne zložité systémy s textovým ovládaním, na vytvorenie grafu si teda o nich budete musieť niečo prečítať. Tieto zručnosti sa vám však môžu zísť v budúcnosti, keď budete napríklad vytvárať grafy do vašej bakalárskej práce. Výhodou takýchto textových nástrojov oproti napr. Excelu je možnosť spúšťať vytvorené vizualizačné príkazy automaticky na nových dátach bez ručného klikania.
- Oficiálna stránka programu gnuplot
- Návod na použitie od Petra Kováča z blog.matfyz.sk
- Oficiálna stránka programu R
- Návody k systému R
Odovzdávanie
Domácu úlohu odovzdávajte elektronicky v systéme Moodle do uvedeného termínu.
- V hlavnej časti úlohy odovzdajte súbor main.cpp, ktorý by mal obsahovať celý zdrojový kód vášho programu. Váš program by mal byť skompilovateľný a spustiteľný v prostredí používanom na cvičeniach.
- V bonusovej časti odovzdajte výsledný graf vo formáte png a krátky textový súbor popisujúci, ako ste obrázok vytvorili (uveďte použité príkazy v systéme gnuplot prípadne R)
Prednáška 5
Organizačné poznámky
- Dnes cvičenia podľa rozvrhu
- Odovzdávanie DU1 do 22:00
- Už by ste mali mať zapísané správne predmety (ak nie bežte na štúdijné) a v prípade zmien do 5.10. potvrdiť finálnu verziu na študijnom oddelení
Štatistika z N čísel
Úlohou je zistiť o N prečítaných číslach nejaké štatistické údaje.
Maximum a minimum
Zrejme stačí čítať čísla postupne a pamätať si zatiaľ najväčšie a zatiaľ najmenšie číslo.
- Ako ale začať? Ako nastaviť maximum a minumum na začiatok?
- Jedna možnosť je nastaviť ich tak, aby to boli nezmyselné hodnoty a iste sa zmenili - napriklad maximum veľmi malé a minumum veľké. Kto nám ale zaručí, že používateľ nedá všetky čísla ešte menšie? Riešením je použiť najväčšie resp. najmenšie možné číslo - ale je to škaredé.
- Druhá možnosť je si pamätať, že ešte nemáme správne nastavené minimum a maximum a pri prvej príležitosti ich nastaviť.
- A prvá príležitosť je pri prvom čísle. Môžeme to teda urobiť priamo. Minimum iste nebude väčšie ako toto prvé číslo a maximum iste nebude menšie.
#include <iostream> #include <cstdlib> using namespace std; int main(void){ int max, min, x, N; cout << "Zadaj pocet cisel: "; cin >> N; cout << "Zadavajte cisla: "; cin >> x; min=x; max=x; for (int i=1; i<N; i++){ cin >> x; if (x<min) {min=x;} if (x>max) {max=x;} } cout << endl << "Maximum je " << max << " a minumum je " << min << endl; }
Výskyty čísel 0..9
Ak vieme, že na vstupe sú iba čísla od 0 do 9, tak by sme chceli vedieť, koľko jednotlivých čísel je. Mohli by sme to riesiť takto:
- Pre každú možnú hodnotu si vytvoríme jednu premennú (dokopy ich bude teda 10 - napríklad p0, p1 .. p9) na začiatku nastavenú na 0.
- V prípade, že prečítané číslo bolo 0 zväčšíme hodnotu p0, ak bolo 1 zväčšíme p1 ...
Je to však pomerne komplikovaný spôsob - a to máme iba 10 rôznych premenných. Problém je v tom, že štvrtá premenná je p4 vieme iba my ako programátori a počítač o tom nevie - nemá žiaden súvis medzi jednotlivými premennými.
Teraz ukážeme riešenie tohoto príkladu pomocou poľa.
#include <iostream> using namespace std; int main(void) { int p[10]; int c,N; for (int i=0; i<10; i++) p[i]=0; // inicializácia pola p[0]=0; p[1]=0; ... p[9]=0; cout << "Zadajte pocet cisel: "; cin >> N; cout << "Zadavajte " << N << "cisel z intervalu 0-9: "; for (int i=0; i<N; i++){ cin >> c; if (c>=0 && c<10) p[c]++; // test, či je číslo z požadovaného rozsahu } cout << endl; for (int i=0; i<10; i++) cout << i << ": " << p [i] << endl; // výpis }
Priemer
Podobne ako pri maxime a minime si aj priemer vieme počítať postupne.
- Budeme si počítať súčet doterajších čísel a na záver ho vydelíme ich počtom.
- Dá sa robiť aj postupne - aby sme nemali zapamätané príliš veľké číslo (súčet)?
Ak by sme chceli o každom čísle vedieť, či je nadpriemerné alebo podpriemerné zjavne by sme si museli čísla zapamätať.
- Keby sme vedeli dopredu, koľko ich bude vedeli by sme to urobiť podobne ako v predchádzajúcom príklade.
#include <iostream> using namespace std; int main(void) { int N=20; int p[20]; double sucet=0; double priemer; cout << "Zadavajte " << N << " cisel: "; for (int i=0; i<N; i++){ cin >> p[i]; sucet=sucet+p[i]; } priemer=sucet/N; cout << "Priemer je " << priemer << "." << endl; for (int i=0; i<N; i++) if (p[i]>priemer) cout << p[i] << ": vacsie ako priemer." << endl; else if (p[i]<priemer) cout << p[i] << ": mensie ako priemer." << endl; else cout << p[i] << ": priemer." << endl; }
- Ak by sme nevedeli počet čísel, môžeme aspoň odhadnúť, že ich nebude viac ako NMax, ktoré definujeme ako konštantu v programe.
- A prečo vlastne nemôžeme dať ako veľkosť poľa N, ktoré si prečítame od používateľa?
Polia
- Rozsah poľa je konštantný výraz väčší ako 0. Prvky sa indexujú od 0 po počet - 1
- Občas sa dá ako rozsah použiť aj dopredu zadefinovaná premenná, ale napr. nasledovný program v C++ skompilujete ale v C nie. Takže opatrne!
int i=100; int p [i]; // i je premenná, ktorá vznikne až počas behu programu, a teda jej hodnota nie je počas kompilácie známa.
- Radšej použijeme konštantu const int N=100
- Veľkosť poľa môže byť ohraničená v závislosti od kompilátora.
Vytvorenie a inicializácia poľa
V C++ je niekoľko pravidiel, ktoré určujú kedy ich môže používať a čo sa stane, ak počet prvok neodpovedá počtu hodnôt v inicializácii. Pole je možné inicializovať iba v definícii.
int A[4]={3, 6, 8, 10}; //spravne int B[4]; //spravne B[4]={3, 6, 8, 10}; //nespravne B[0]=3; B[1]=6; B[2]=8; B[3]=10;
Pri inicializácii sa dá dodať aj menej hodnôt ako má pole. Napr. inicializácia iba dvoch prvých hodnôt. Pri čiastočnej inicializácii nastaví prekladač ostatné prvky na nulu.
double C[5]={5.0, 13.9}; // inicializuje C[0]=5.0, C[1]=13.9 a C[2]..C[4]=0 double C[5]={0}; // jednoduchá inicializácia všetkých prvkov na 0
Ak pri inicializácii poľa necháme hranaté zátvorky prázdne prekladač si sám spočíta prvky poľa. Nie je to však odporúčaný postup.
int A[]={1, 5, 3, 8}; // zistí rozsah poľa 0..3
Indexovanie hodnotou mimo intervalu
int a [10], b [10]; int i; for (i=0; i<10; i++) a [i]=random (100); // náhodné hodnoty
Pozor, kompilátor nekontroluje indexy prvkov
a [11]=1234;
- Skompilujete, ale hodnota 1234 sa zapíše do pamäte na zlé miesto,
- Môže to mať nepredvídateľné následky: prepísanie obsahu iných premenných (chybný výpočet alebo „nevysvetliteľné“ správanie sa programu) alebo prepísane časti kódu vášho programu (čo vo väčšine prípadov spôsobí „zamrznutie“ alebo reset počítača),
Kopírovanie a testovanie rovnosti
V prípade, že chceme vytvoriť pole, ktoré je kópiou už existujúceho poľa, ponúka sa možnosť príkazu priradenia b=a;. Takýto príkaz však neskompilujete – nedá sa takto priraďovať, treba kopírovať prvok po prvku.
for (i=0; i<10; i++) b[i]=a[i];
Podobne sa nedá porovnávať polia pomocou podmienky if (a==b) cout << "Ok";. Takúto podmienku síce skompilujete, ale nikdy to nebude pravda – neporovná sa obsah poľa, ale niečo úplne iné (adresy polí v pamäti). Treba to riešiť opäť prvok po prvku.
bool r=true; for (i=0; i<10; i++) { r=r && (a [i]==b [i]); } if (r) cout << "Ok\n";
Príklady na prácu s poľom
- Načítajte pole čísel a vypíšte ho v opačnom poradí.
- Skúste poradie povymienať priamo v poli a nie iba pri výpise.
- Načítajte pole čísel a vypíšte ho v náhodnom poradí.
- Ako by ste pole náhodne povymieňali priamo v pamäti?
Kreslíme padajúce kruhy
- Vytvoríme si polia pre x-ovú a y-ovú súradnicu kruhu.
- Potrebujeme aj pole, do ktorého si budeme dávať celočíselné identifikátory nakreslených kruhov, aby sme ich neskôr mohli zmazať.
#include "../SimpleDraw.h" #include <cstdlib> #include <ctime> int main(void) { const int count = 30; /* počet kruhov */ int size = 300; /* veľkosť obrázku */ int diameter = 15; /* polomer kruhu */ int step = 4; /* o kolko padne dolu v jednom kroku */ int repeat = 50; /* pocet iteracii */ double wait = 0.1; /* cakaj po kazdej iteracii */ /* inicializácia generátora pseudonáhodných čísel */ srand(time(NULL)); SimpleDraw window(size, size); window.setBrushColor("lightblue"); int x[count]; /* x-ova poloha kruzku */ int y[count]; /* y-ove poloha kruzku */ int id[count]; /* id objektu na obrazovke */ /* kazdemu kruzku vygeneruj nahodnu polohu */ for (int i = 0; i < count; i++) { x[i] = rand() % (size - diameter); y[i] = rand() % (size - diameter); } /* opakuj repeat iteracii */ for (int r = 0; r < repeat; r++) { /* chod cez vsetky kruhy */ for (int i = 0; i < count; i++) { /* ak nie sme v prvej iteracii, treba zmazat kruh */ if (r > 0) { window.removeItem(id[i]); } /* zvys y-ovu suradnicu o step */ y[i] += step; /* ak sme prilis nizko, zacni na vrchu na nahodnom x */ if (y[i] >= size - diameter) { y[i] = 0; x[i] = rand() % (size - diameter); } /* vykresli kruzok na novom mieste */ id[i] = window.drawEllipse(x[i], y[i], diameter, diameter); } /* na konci iteracie chvilu pockaj */ window.wait(wait); } }
- Takéto polia nie sú ideálne, lebo údaje o jednom kruhu sú v troch rôznych poliach a bolo by logickejšie ich mať pokope.
- Situácia by bola ešte horšia, ak by každý kruh mal napr. aj náhodnú farbu s troma zložkami R,G,B. To by sme potrebovali päť polí.
- Na spojenie údajov k jednému kruhu použijeme dátovú štruktúru struct
Padajúce kruhy so struct
#include "../SimpleDraw.h" #include <cstdlib> #include <ctime> struct kruh { int x, y; /* suradnice */ int id; /* id na mazanie */ int r, g, b; /* zlozky farby: red, green, blue */ }; void generujKruh(kruh &k, int max) { k.x = rand() % max; k.y = rand() % max; k.r = rand() % 256; k.g = rand() % 256; k.b = rand() % 256; k.id = -1; } int main(void) { const int count = 30; /* počet kruhov */ int size = 300; /* veľkosť obrázku */ int diameter = 15; /* polomer kruhu */ int step = 4; /* o kolko padne dolu v jednom kroku */ int repeat = 50; /* pocet iteracii */ double wait = 0.1; /* cakaj po kazdej iteracii */ int max = size - diameter; /* maximalna mozna suradnica */ /* inicializácia generátora pseudonáhodných čísel */ srand(time(NULL)); SimpleDraw window(size, size); window.setBrushColor("lightblue"); /* pole kruhov */ kruh kruhy[count]; /* kazdemu kruzku vygeneruj nahodnu polohu */ for (int i = 0; i < count; i++) { generujKruh(kruhy[i], max); } /* opakuj repeat iteracii */ for (int r = 0; r < repeat; r++) { /* chod cez vsetky kruhy */ for (int i = 0; i < count; i++) { /* ak nie sme v prvej iteracii, treba zmazat kruh */ if (r > 0) { window.removeItem(kruhy[i].id); } /* zvys y-ovu suradnicu o step */ kruhy[i].y += step; /* ak sme prilis nizko, zacni na vrchu na nahodnom x */ if (kruhy[i].y >= max) { generujKruh(kruhy[i], max); kruhy[i].y = 0; } /* vykresli kruzok na novom mieste */ window.setBrushColor(kruhy[i].r, kruhy[i].g, kruhy[i].b); kruhy[i].id = window.drawEllipse(kruhy[i].x, kruhy[i].y, diameter, diameter); } /* na konci iteracie chvilu pockaj */ window.wait(wait); } }
Eratostenovo sito
Chceme vypísať všetky prvočísla medzi 2 a N. Mohli by sme ísť cez všetky čísla a pre každé testovať, koľko má deliteľov (deliteľov sme už hľadali predtým), ale vieme to spraviť aj rýchlejšie. Použijeme algoritmus zvaný Eratostenovo sito.
- Vytvoríme pole A pravdivostných hodnôt, kde A[i] nám hovorí, či je i ešte potenciálne prvočíslo.
- Na začiatku budú všetky hodnoty true, lebo sme ešte žiadne číslo nevylúčili.
- Začneme číslom 2 - toto je iste prvočíslo (tak ho vypíšeme). O jeho násobkoch však vieme, že iste nemôžu byť prvočísla - nastavíme preto pre každý násobok j=2*k pravdivostnú hodnotu A[j] na false.
- Potom prechádzame v poli, kým nenájdeme najbližšiu ďalšiu hodnotu true. Toto číslo je prvočíslo (vypíšeme ho) a vyškrtáme jeho násobky.
#include <iostream> using namespace std; int main(void) { const int N = 25; bool A[N + 1]; for (int i = 2; i <= N; i++) { A[i] = true; } for (int i = 2; i <= N; i++) { if (A[i]) { cout << i << " "; for (int j = 2 * i; j <= N; j = j + i) { A[j] = false; } } } cout << endl; }
Výstup programu
2 3 5 7 11 13 17 19 23
Priebeh programu:
0 1 2 3 4 5 6 7 8 9 10 11 12 ... ? ? T T T T T T T T T T T ... na zaciatku ? ? T T F T F T F T F T F ... po vyskrtani i=2 ? ? T T F T F T F F F T F ... po vyskrtani i=3 ? ? T T F T F T F F F T F ... dalej sa uz skrtaju len vacsie cisla
Cvičenie: Napíšte funkciu, ktorá uloží prvočísla medzi 2 a N do poľa (ak by sme ich chceli použiť na ďalšie výpočty).
Zhrnutie
- V prípade využívania viacerých premenných, ktoré sú vlastne jednotlivé prvky nejakej postupnosti (načítávané čísla, ..) môžeme využívať polia
- Jednotlivé spolu súvisiace informácie (vlastnosti) o nejakom prvku spojíme do štruktúry pomocou struct
Prednáška 6
Organizačné poznámky
- V moodli si vždy skontrolujte, či ste súbor správne odovzdali, priebežne si pozerajte známky a komentáre, upozornite nás na prípadné problémy
- DÚ2 a PDÚ1 do pondelka, DÚ3 zverejnená koncom týždňa, PDÚ2 začiatkom budúceho týždňa.
- Poriadne čítať a dodržiavať zadania úloh, spýtajte sa, ak niečo nie je jasné, alebo ak máte problémy úlohu riešiť
- Prebrali sme premenné, polia, podmienky, cykly a funkcie.
- Z týchto stavebných prvkov sa dajú vystavať pomerne komplikované programy. Menej skúsení programátori si potrebujú prácu s týmito pojmami čo najviac precvičiť. Skúste si vyriešiť všetky príklady z cvičení. Kontaktujte nás, ak Vám niečo nie je jasné.
- Predbežný plán: tento a budúci týždeň algoritmy s poliami, znaky a reťazce. O dva týždňe rekurzia (veľa študentom robila problém na skúške).
Parametre funkcií - prehľad, opakovanie
- Jednoduché typy, napr. int, double, bool
- Bez & sa skopíruje hodnota
- S & premenná dostane vo funkcii nové meno
void f1(int x) { x++; // zmena x sa nepresenie do main (y zostane rovnaká) cout << x << endl; } void f2(int &x) { x++; // zmena x sa prenesie ako zmena y v main cout << x << endl; } int main(void) { int y = 0; f1(y); f2(y); f1(y + 1); //zle: f2(y+1); }
- Polia odovzdávame bez &
- väčšinou potrebujeme poslať aj veľkosť poľa, ak nie je globálne známa
- zmeny v poli zostanú aj po skončení funkcie
void f(int a[], int n) { for (int i = 0; i < n; i++) { cout << a[i] << endl; } } int main(void) { int b[3] = {1, 2, 3}; f(b, 3); }
- Korytnačky, grafické okná a pod. sú v skutočnosti objekty, väčšinou ich chcete posielať s &
- všetky zmeny na nich spravené pretrvávajú aj po skončení funkcie
void kresli(Turtle &t, int n) { for(int i=0; i<n; i++) { t.turnLeft(rand() % 360); t.forward(10); } } int main(void) { int n=10; SimpleDraw window(500,500); Turtle turtle(window, 250, 450, 0); kresli(turtle, n); window.showAndClose(); }
- Štruktúry (struct) väčšinou tiež posielame pomocou &
- Návratové hodnoty:
- ak je výsledkom funkcie jedno číslo alebo pravdivostná hodnota, vrátime ju príkazom return
- ak je výsledkom viac hodnôt, alebo niečo zložitejšie (pole, struct,...), odovzdáme ho ako parameter pomocou &, návratová hodnota môže zostať void
- Tieto pravidlá súvisia so smerníkmi a správou pamäti, povieme si viac o pár týždňov
Polynómy
- Príklad polynómu: Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 2x^3 + 3x -1} .
- Polynóm si môžeme uložiť do poľa, pričom koeficient pri Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle x^i} dáme do a[i]
- Pre náš príklad vytvoríme pole napríklad príkazom double a[4] = {-1, 3, 0, 2};
- Teraz si ukážeme niekoľko funkcií, ktoré s polynómami pracujú.
Vyhodnocovanie polynómu
- Chceme spočítať hodnotu polynómu pre nejaké konkrétne x
- Príklad: pre Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 2x^3 + 3x -1} a pre x=2 dostaneme Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 21 = (2\cdot 2^3 + 3\cdot 2 -1)}
Pokus 1:
double evaluatePolynomial(double a[], int n, double x) { /* a je pole koeficientov s n hodnotami. * Funkcia vráti hodnotu tohto polynómu v bode x. * * Táto implementácia na výpočet x na i používa funkciu * pow, čo ale pomalé a potenciálne nie úplne presné. */ double value = 0; for (int i = 0; i < n; i++) { value += a[i] * pow(x, i); } return value; }
- Pripomíname: value += x je to isté ako value = value + x
- Všimnite si, že v komentári na začiatku funkcie popisujeme, čo tá funkcia robí, to je väčšinou dobrý nápad spraviť.
- Aký najvyšší stupeň môže mať polynóm a (ako funkcia n)?
Pokus 2:
- Vyhneme sa volaniu pow tým, že budeme nejakú premennú opakovanie násobiť hodnotou x
- V cykle uvádzame ako komentár invariant, podmienku, ktorá na tom mieste vždy platí. Takýto invariant nám pomôže si uvedomiť, že je náš program správny.
- Čo by sa stalo, ak by sme prehodili dva príkazy vo vnútri cyklu?
double evaluatePolynomial(double a[], int n, double x) { /* a je pole koeficientov s n hodnotami. * Funkcia vráti hodnotu tohto polynómu v bode x. * * Táto implementácia počíta x na i v cykle spolu * s vyhodnocovaním polynómu. */ double value = 0; double xpow = 1; for (int i = 0; i < n; i++) { /* Invariant: xpow sa rovna x na i */ value += a[i] * xpow; xpow *= x; } return value; }
Pokus 3: Hornerova schéma
- O kúsoček lepšia ako pokus 2 - nepotrebuje pomocnú premennú a v každej iterácii cyklu robí iba jedno násobenie, nie dve
- Idea je začať od najvyšších mocnín x:
- Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 2x^3 + 0x^2 + 3x -1 = ((2\cdot x+0)x+3)x-1}
double evaluatePolynomial(double a[], int n, double x) { /* a je pole koeficientov s n hodnotami. * Funkcia vráti hodnotu tohto polynómu v bode x. * * Táto implementácia používa tzv. Hornerovu schému, * ktorá začína od najvyšších koeficentov a * a pre každé i robí iba jedno sčítanie a jedno násobenie. */ double value = 0; for (int i = n - 1; i >= 0; i--) { value = value * x + a[i]; } return value; }
Cvičenie: aký je invariant po vykonaní príkazu v cykle?
Hlavný program:
#include <cstdlib> #include <cmath> #include <iostream> using namespace std; double evaluatePolynomial(double a[], int n, double x) { // jedna z funkcií vyššie } void enterPolynomial(double a[], int &n, int maxN) { /* Od užívateľa načíta koeficienty polynómu do a, * ich počet uloží do n, maxN je veľkosť poľa, * ktorú nemožno prekročiť. */ cout << "Zadaj pocet koeficientov n: "; cin >> n; if (n > maxN) { cout << "Prilis velke n!" << endl; exit(1); } for (int i = 0; i < n; i++) { cout << "Zadaj koeficient pri x na " << i << ": "; cin >> a[i]; } } int main(void) { const int maxN = 100; int n; double a[maxN]; enterPolynomial(a, n, maxN); double x; cout << "Zadaj x: "; cin >> x; cout << "Hodnota pre x=" << x << " je " << evaluatePolynomial(a, n, x) << endl; }
Zadaj pocet koeficientov n: 4 Zadaj koeficient pri x na 0: -1 Zadaj koeficient pri x na 1: 3 Zadaj koeficient pri x na 2: 0 Zadaj koeficient pri x na 3: 2 Zadaj x: 2 Hodnota pre x=2 je 21
Sčítanie polynómov
- Pri sčítaní polynómov len sčítame koeficienty pri zodpovedajúcich mocninách x
- Napr. Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle (2x^3 + 3x -1) + (-4x^2+2x+7) = (2+0)x^3 + (0-4)x^2 +(3+2)x^1 + (-1+7)x^0 = 2x^3-4x^2+5x+6}
- Musíme dávať pozor na to, že dĺžky polynómov môžu byť rôzne a hodnoty v poli za n ďalej sú nedefinované.
void addPolynomials(double a[], int na, double b[], int nb, double c[], int &nc) { /* a je pole koeficientov polynomu s na hodnotami, * b je pole koeficientov s nb hodnotami * do c zratame ich sucet, do nc pocet hodnot, ktory bude vacsie z * na, nb. Predpokladame, ze c je dost velke, aby sa do neho nc * prvkov zmestilo. */ if (na > nb) { nc = na; } else { nc = nb; } for (int i = 0; i < nc; i++) { c[i] = 0; if (i < na) { c[i] += a[i]; } if (i < nb) { c[i] += b[i]; } } }
Hlavný program: (teraz vidíme, načo nám je funkcia enterPolynomial, bez nej by sme cyklus na načítavanie museli písať dvakrát)
#include <cstdlib> #include <iostream> using namespace std; void enterPolynomial(double a[], int &n, int maxN) { // pozri vyššie } void writePolynomial(double a[], int n) { /* a je pole koeficientov polynómu s n hodnotami */ for (int i = 0; i < n; i++) { cout << "Koeficient polynomu pri x na " << i << " je " << a[i] << endl; } } int main(void) { const int maxN = 100; int na, nb; double a[maxN], b[maxN]; cout << "Prvy polynom:" << endl; enterPolynomial(a, na, maxN); cout << endl << "Druhy polynom:" << endl; enterPolynomial(b, nb, maxN); double c[maxN]; int nc; addPolynomials(a, na, b, nb, c, nc); cout << endl << "Ich sucet:" << endl; writePolynomial(c, nc); }
Príklad behu:
Prvy polynom: Zadaj pocet koeficientov n: 4 Zadaj koeficient pri x na 0: -1 Zadaj koeficient pri x na 1: 3 Zadaj koeficient pri x na 2: 0 Zadaj koeficient pri x na 3: 2 Druhy polynom: Zadaj pocet koeficientov n: 3 Zadaj koeficient pri x na 0: 7 Zadaj koeficient pri x na 1: 2 Zadaj koeficient pri x na 2: -4 Ich sucet: Koeficient polynomu pri x na 0 je 6 Koeficient polynomu pri x na 1 je 5 Koeficient polynomu pri x na 2 je -4 Koeficient polynomu pri x na 3 je 2
Ďalšie príklady s polynómami
Vieme napísať aj ďalšie funkcie alebo programy na prácu s polynómami:
- Vykresľovanie grafu (rátame hodnotu polynómu v husto rozmiestnených bodoch)
- Násobenie polynómov
- Delenie so zvyškom a Euklidov algoritmus
- Derivácia
- A mnohé ďalšie
Zdrojový kód celého programu
Načo sú v programovaní dobré funkcie
- Rozbijeme veľký problém na menšie dobre definované časti (napr. načítaj polynóm, spočítaj jeho hodnotu), každou časťou sa môžeme zaoberať zvlášť. Výsledný program je ľahšie pochopiteľný, najmä ak u každej funkcie napíšeme, čo robí.
- Vyhneme sa opakovaniu kusov kódu (napr. načítanie polynómu A a B). Pri kopírovaní kusov kódu ľahko narobíme chyby, a ak chceme niečo meniť, musíme meniť na veľa miestach.
- Hotové funkcie môžeme použiť aj v ďalších programoch, prípadne z nich zostavovať nové knižnice, napríklad knižnicu na prácu s polynómami.
Triedenia
Máme pole čísel, chceme ich usporiadať od najmenšieho po najväčšie.
- Napr. pre pole 9 3 7 4 5 2 chceme dostať 2 3 4 5 7 9
- Jeden z najštudovanejších problémov v informatike.
- Súčasť mnohých zložitejších algoritmov.
- Veľa spôsobov, ako triediť, dnes si ukážeme zopár najjednoduchších.
Bublinkové triedenie (Bubble Sort)
Idea: Kontrolujeme všetky dvojice susedných prvkov a keď vidíme menšie číslo za väčším, vymeníme ich
for (int i = 1; i < n; i++) { if (a[i] < a[i - 1]) { swap(a[i - 1], a[i]); } }
- Ak sme nenašli v poli žiadnu dvojicu, ktorú treba vymeniť, skončili sme.
- Inak celý proces opakujeme znova.
Celé triedenie:
void swap(int &x, int &y) { /* Vymeň hodnoty premenných x a y. */ int tmp = x; x = y; y = tmp; } void sort(int a[], int n) { /* usporiadaj prvky v poli a od najmenšieho po najväčší */ bool hotovo = false; while (!hotovo) { bool vymenil = false; /* porovnávaj všetky dvojice susedov, vymeň ak menší za väčším */ for (int i = 1; i < n; i++) { if (a[i] < a[i - 1]) { swap(a[i - 1], a[i]); vymenil = true; } } /* ak sme žiadnu dvojicu nevymenili, môžeme skončiť. */ if (!vymenil) { hotovo = true; } } }
- Čo ak vo for cykle dám for (int i = 0; i < n; i++) {
- Ako nahradím premennú hotovo príkazom break?
Príklad behu:
prvá iterácia while cyklu 9 3 7 4 5 2 3 9 7 4 5 2 3 7 9 4 5 2 3 7 4 9 5 2 3 7 4 5 9 2 3 7 4 5 2 9 druhá iterácia while cyklu 3 7 4 5 2 9 3 4 7 5 2 9 3 4 5 7 2 9 3 4 5 2 7 9 tretia iterácia while cyklu 3 4 5 2 7 9 3 4 2 5 7 9 štvrtá iterácia while cyklu 3 4 2 5 7 9 3 2 4 5 7 9 piata iterácia while cyklu 3 2 4 5 7 9 2 3 4 5 7 9
Cvičenie: Ako sa bude správať algoritmus na nasledujúcich vstupoch, koľkokrát zopakuje vonkajší while cyklus?
- Utriedené pole 1,2,...,n
- Pole n,1,2,...,n-1
- Pole 2,3,...,n,1
- Pole n,n-1,...,1
Triedenie výberom (selection sort, max sort)
Idea: nájdime najväčší prvok a uložme ho na koniec. Potom nájdime najväčší medzi zvyšnými a uložme ho na druhé miesto odzadu atď.
int maxIndex(int a[], int n) { /* vráť index, na ktorom je najväčší prvok z prvkov a[0]...a[n-1] */ int index = 0; for(int i=1; i<n; i++) { if(a[i]>a[index]) { index = i; } /* invariant: a[j]<=a[index] pre vsetky j=0,...,i*/ } return index; } void sort(int a[], int n) { /* usporiadaj prvky v poli a od najmenšieho po najväčší */ for(int kam=n-1; kam>=1; kam--) { /* invariant: a[kam+1]...a[n-1] sú utriedené * a pre každé i,j také že 0<=i<=kam, kam<j<n platí a[i]<=a[j] */ int index = maxIndex(a, kam+1); swap(a[index], a[kam]); } }
Príklad behu programu
Vstup 9 3 7 4 5 2 Po výmene (9,2) 2 3 7 4 5 9 Po výmene (7,5) 2 3 5 4 7 9 Po výmene (5,4) 2 3 4 5 7 9 Po výmene (4,4) 2 3 4 5 7 9 Po výmene (3,3) 2 3 4 5 7 9
Cvičenie: Bude čas behu algoritmu výrazne odlišný pre pole utriedené správne a pole utriedené v opačnom poradí?
Triedenie vkladaním (Insertion Sort)
Idea:
- v prvej časti poľa prvky v utriedenom poradí
- zober prvý prvok z druhej časti a vlož ho na správne miesto v utriedenom poradí
Príklad behu algoritmu:
9 3 7 4 5 2 3 9 7 4 5 2 3 7 9 4 5 2 3 4 7 9 5 2 3 4 5 7 9 2 2 3 4 5 7 9
Ako spraviť vkladanie:
- Vkladaný prvok si zamätáme v pomocnej premennej
- Utriedené prvky posúvame o jedno doprava, kým nenájdeme správne miesto pre odložený prvok
void sort(int a[], int n) { /* usporiadaj prvky v poli a od najmenšieho po najväčší */ for (int i = 1; i < n; i++) { int prvok = a[i]; int kam = i; while (kam > 0 && a[kam - 1] > prvok) { a[kam] = a[kam - 1]; kam--; } a[kam] = prvok; } }
- Všimnime si podmienku (kam > 0 && a[kam - 1] > prvok)
- Ak kam==0, prvá časť je false, druhá časť sa už nevyhodnocuje
- Ak by sme prehodili časti, program by mohol spadnúť (a[kam - 1] > prvok && kam > 0)
Cvičenie: Ako sa bude správať algoritmus na nasledujúcich vstupoch, koľkokrát zopakuje priradenie a[kam]=a[kam-1]?
- Utriedené pole 1,2,...,n
- Pole n,1,2,...,n-1
- Pole 2,3,...,n,1
- Pole n,n-1,...,1
Zdrojový kód programu s triedeniami
Zhrnutie
- Videli sme niekoľko nových algoritmov:
- Vyhodnocovanie a sčítavanie polynómov
- Tri jednoduché algoritmy na triedenie
- Neskôr sa ešte naučíme rýchlejšie algoritmy na triedenie, ktoré používajú rekurziu
- Precvičili sme si funkcie, parametre a polia
- K funkciám je dobré napísať, čo robia
- Do cyklov si môžeme písať invarianty
- Používajú sa pri formálnom dokazovaní správnosti
- Pomáhajú pochopeniu kódu
- Môžeme ich použiť na ručnú alebo automatickú kontrolu správnosti hodnôt premenných
- Príkaz assert v knižnici cassert kontroluje podmienku, napr. assert(i>=0 && i<n); ukončí program s chybovou hláškou ak podmienka neplatí
Cvičenia 3
Vypisovanie čísel
Napíšte program, ktorý vypíše štvorec veľkosti NxN obsahujúci čísla nasledovne (vyskúšajte všetky tri spôsoby):
- V prvom riadku budú samé 1, v druhom samé 2, .. v poslednom samé N
- V každom riadku budú čísla od 1 po N
- Rovnaké čísla budú uhlopriečne
1 1 1 1 1 2 3 4 1 2 3 4 2 2 2 2 1 2 3 4 2 3 4 5 3 3 3 3 1 2 3 4 3 4 5 6 4 4 4 4 1 2 3 4 4 5 6 7
Hodnotu N si na začiatku programu uložte do premennej.
Číselné sústavy
- Napíšte funkciu cifernySucet, ktorá dostane ako parameter číslo N a vráti jeho ciferný súčet (napr. pre N=124 vráti 7). Funkcia main načíta číslo od užívateľa, zavolá túto funkciu a vypíše výsledok.
- Napíšte funkciu pocetCifier, ktorá dostane ako parameter číslo N a vráti počet cifier, ktoré má (napr. pre N=124 vráti 3). Funkcia main načíta dve čísla a a b a vypíše ich pod seba zarovnané doprava (zistí pre obe počet cifier a pred kratšie vypíše potrebný počet medier. Napríklad pre a=3 a b=100 vypíše:
3 100
Hádaj číslo
Na prednáške bola naprogramovaná hra Hádaj číslo, kde si počítač "myslí číslo" od 1 do 100 a používateľ háda, o ktoré číslo ide. Upravte program nasledovne:
- Program umožní používateľovi sa vzdať, napríklad keď používateľ zadá 0. V tom prípade program vypíše hľadané číslo a skončí.
- Program bude počítať počet kôl, ktoré používateľ potreboval k uhádnutiu čísla a na konci ho vypíše.
Kombinačné čísla
Iste poznáte kombinačné číslo Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {n\choose k}=\frac{n!}{k!(n-k)!}} , ktoré vyjadruje, koľkými možnosťami je možné vybrať k prvkov z n-prvkovej množiny.
- Vypočítajte kombinačné číslo Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {n\choose k}} priamo z definície, t.j. pomocou funkcie, ktorá počíta faktoriál čísla.
- Kombinačné čísla sa dajú počítať aj efektívnejšie. Napríklad Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {5 \choose 2} = \frac{5!}{2!3!} = \frac{5\cdot4\cdot 3\cdot 2\cdot 1}{2\cdot 1\cdot3\cdot2\cdot1}} sa zjavne dá zjednodušiť na Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {5 \choose 2} = \frac{5\cdot4}{2\cdot 1}} . Vytvorte funkciu, ktorá počíta kombinačné číslo týmto spôsobom. Vieme túto funkciu upraviť tak, aby nepočítala najskôr čitateľa a potom menovateľa a pritom ostal jej výsledok stále typu int?
- Pomocou predchádzajúcej funkcie vypíšte do jedného riadku hodnoty Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {n\choose i}} pre používateľom zadané n a všetky i od 0 po n.
- Funkciu pre vypísanie celého riadku vieme optimalizovať nasledovne: Na základe čísla Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {n\choose i}} budeme počítať Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {n\choose i+1}} . Vypíšte riadok Pascalovho trojuholníka takýmto spôsobom.
Grafická funkcia
- Napíšte funkciu, ktorá do grafického okna vykreslí domček z prvej resp. druhej prednášky. Ako parameter dostane súradnice ľavého dolného rohu domčeka, jeho výšku, šírku a výšku strechy, ale aj okno, do ktorého vykresľujeme (prenesieme ho ako referenciu - pomocou SimpleDraw & window).
- V hlavnom okne použite túto funkciu na vykreslenie domčekov rôznej farby na nieľkokých miestach na obrazovke.
DÚ2
Odovzdávanie DÚ2 a Odovzdávanie DÚ2 bonus max. 10 bodov + 4 body bonus, termín odovzdania pondelok 8.10. o 22:00
Cieľom tejto domácej úlohy je precvičiť prácu s cyklami a funkciami. Nepoužívajte polia a iné dátové štruktúry, iba premenné typu int, prípadne aj double a bool.
Iste poznáte kombinačné čísla Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {n\choose k}=\frac{n!}{k!(n-k)!}} , ktoré vyjadrujú, koľkými možnosťami je možné vybrať k prvkov z n-prvkovej množiny. Keď kombinačné čísla usporiadame do tvaru trojuholníka, dostaneme Pascalov trojuholník. V každom riadku Pascalovho trojuholníka sú kombinačné čísla pre jednu hodnotu n, pričom uvažujeme všetky hodnoty k od 0 po n.
V tejto úlohe chceme zrátať zvyšok po delení dvoma pre jednotlivé čísla v Pascalovom trojuholníku a vykresliť ich graficky tak, že nepárne čísla zobrazíme ako čierny štvorček a párne ako biely štvorček. Ak tak urobíme pre veľa riadkov Pascalovho trojuholníka, dostaneme fraktálny útvar zvaný Sierpinského trojuholník. Problém však je, že keby sme priamočiaro rátali kombinačné čísla pre veľké hodnoty n a zisťovali či sú párne, nestačil by nám rozsah premennej int. Budeme teda postupovať prefíkanejšie: nebudeme rátať presnú hodnotu kombinačného čísla, zrátame iba najväčšiu mocninu dvojky, ktorá ho delí. Kombinačné číslo je podiel súčinov malých celých čísel. Ak zistíme pre každé z týchto čísel, aká najväčšia mocnina dvojky ho delí, sčitovaním a odčitovaním môžeme získať najväčšiu mocninu dvojky, ktorá delí výsledné kombinačné číslo. Napríklad Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {5 \choose 2} = \frac{5!}{2!3!} = \frac{5\cdot4\cdot 3\cdot 2\cdot 1}{2\cdot 1\cdot3\cdot2\cdot1}} V čitateli 5,3 a 1 sú deliteľné iba Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 2^0 } , 4 je deliteľné Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 2^2} a 2 je deliteľné Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 2^1} . Spolu je teda čitateľ deliteľný Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 2^3} . Podobne menovateľ je deliteľný Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 2^2} , najvyššia mocnina dvojky, ktorá delí výsledné kombinačné číslo je teda Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 2^3/2^2 = 2^{3-2}=2^1} . Toto kombinačné číslo je 10, takže vidíme, že odpoveď je správna.
- Časť a) Napíšte funkciu s hlavičkou int powerTwo(int n) ktorá spočíta pre dané kladné celé číslo n najvyššie k také, že Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 2^k} delí n. Napríklad powerTwo(12) je 2, lebo Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 4=2^2} je najvyššia mocnina dvojky, ktorá delí 12.
- Časť b) Napíšte program, ktorý bude riadok po riadku počítať paritu kombinačných čísel v Pascalovom trojuholníku a keď nájde nepárne číslo, vykreslí na príslušné miesto grafickej plochy čierny štvorček.
- Pri výpočte môžete použiť vzťah medzi susednými hodnotami v riadku: Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {n\choose k} = {n\choose k-1} \cdot \frac{n-k+1}{k}} pre Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 1\le k \le n} .
- Vyhnite sa problémom s veľmi veľkými číslami použitím funkcie powerTwo
- V programe si uložte do premenných nasledujúce parametre obrázku (nenačítavajte ich od užívateľa, stačí ich nastaviť priamo v programe):
- maxN - posledný riadok, ktorý vypisujeme
- square - veľkosť jedného štvrčeka
- Potrebnú veľkosť obrázku aj rozmiestnenie štvorcov spočítajte z týchto premenných.
- Výsledok by mal vyzerať ako obrázok napravo (použili sme maxN=4, square=50). Pre veľké maxN program potrebuje veľa pamäte na uloženie jednotlivých štvorčekov, skúste však napríklad hodnotu square=2 a maxN=63 a maxN=255.
- Časť c) bonus: Napíšte vylepšený program taký, že ak ide v riadku za sebou niekoľko čiernych štvorčekov, vykreslíte ich ako jeden obdĺžnik. To by malo program zrýchliť a zmenšiť jeho pamäť. Program by mal tiež spočítať, koľko čiernych štvorčekov by vykreslil v základnej verzii, koľko vykreslil obdĺžnikov a aká je teda úspora v počte vykreslených útvarov. Hodnoty, ktoré dostanete pre maxN=63 uveďte v komentári programu.
Domácu úlohu odovzdávajte v systéme Moodle, pričom odovzdajte program main.cpp pre časť a) a b) a ak robíte aj časť c), odovzdajte ju v zvláštnom súbore bonus.cpp.
Prednáška 7
Organizačné poznámky
- DÚ2 a pokročilú DÚ1 odovzdávajte do dnes (8.10.2012) do 22:00
- Nepovinné cvičenia z programovania v H3 od 14:50. V prípade, že by to veľa ľuďom nevyhovovalo, dá sa presunúť na 14:00
Vyhľadávanie prvkov poľa
Úlohou je zistiť, či pole obsahuje prvok zadanej hodnoty.
- Zrejme budeme musieť prejsť celé pole, lebo nevieme, kde sa prvok môže nachádzať.
int Member(int A[], int N, int x){ for (int i=0; i<N; i++){ if (a[i]==x) return i; } return -1; }
- Toto môžeme urobiť aj v prípade, že máme pole usporiadané. Prejdením celého poľa prvok iste nájdeme alebo zistíme, že sa tam taký prvok nenachádza.
- Ale neexistuje lepšie riešenie?
Binárne vyhľadávanie
Lepšie riešenie samozrejme existuje a je založené na nasledovnej myšlienke:
- Ak pozriem v utriedenom poli na nejaký prvok A[i], tak v intervale 0..(i-1) sú čísla veľkosti nanajvýš A[i] a v intervale (i+1)..(N-1) sú čísla veľkosti aspoň A[i].
- Keď teda hľadám nejaký prvok x, tak po jednom nahliadnutí do poľa viem
- buď priamo povedať, že ten prvok sa tam nachádza - ak som trafila priamo pozíciu i taku, že x=A[i]
- vyhodiť (t.j. ďalej nepoužívať) časť poľa v intervale (i+1)..(N-1) - ak som trafila priamo pozíciu i taku, že x<A[i]
- vyhodiť (t.j. ďalej nepoužívať) časť poľa v intervale 0..(i-1) - ak som trafila priamo pozíciu i taku, že x>A[i]
- V utriedenom poli teda môžem vyhľadávať nasledovne:
- budem si pamätať ľavý a pravý kraj, kde ešte môže byť hľadaný prvok
- vyberiem nejaký prvok z tohoto intervalu a patrične interval skrátim
- ak už je interval zlý (t.j. pravý a ľavý kraj sú naopak) tak skončí
- Jediná nezodpovedaná otázka je, ako vyberám prvok, na ktorý sa pýtam
int Member(int A[], int N, int x){ int left=0, right=N-1, index; while (left<=right){ index=??; if (A[index]==x) {return index;} else if (A[index]<x) {left=index+1;} else {right=index-1;} } return =-1; }
Pozrime sa na jednotlivé možnosti ako prvok vyberať (aj keď vám je už asi jasné, aký bude výsledok):
- Budeme vyberať vždy prvý prvok - tým vlastne máme skoro pôvodné hľadanie. Jediný rozdiel je, že v prípade, že už dojdeme na prvok poľa, ktorý je väčší ako hľadané x, tak zastavíme a odpovieme, že prvok tam nie je.
- Beh programu si ukážeme na príklade
A[7]={2,5,41,68,72,100,156} N=7 x=41 left=0 right=6: index=0; A[index]<x left=1 right=6; index=1; A[index]<x left=2 right=6; index=2; A[index]=x -> return 2 N=7 x=31 left=0 right=6: index=0; A[index]<x left=1 right=6; index=1; A[index]<x left=2 right=6; index=2; A[index]>x left=2 right=1; left>right -> koniec while cyklu -> return -1
- Budeme vyberať vždy stredný prvok teda index=(left+right)/2, čím dosiahneme, že v každom ktorku zahodíme polovicu poľa.
- Beh programu si ukážeme na príklade
A[7]={2,5,41,68,72,100,156} N=7 x=41 left=0 right=6: index=3; A[index]>x (68>41) left=0 right=2; index=2; A[index]<x (5<41) left=2 right=2; index=1; A[index]=x -> return 2 N=7 x=31 left=0 right=6: index=3; A[index]>x (68>31) left=1 right=2; index=1; A[index]<x (5<31) left=2 right=2; index=2; A[index]>x (41>31) left=2 right=1; left>right -> koniec while cyklu -> return -1
Tak nejako prirodzene máme pocit, že to druhé riešenie je lepšie. Že by malo byť asi rýchlejšie...
Zložitosť algoritmu
Ako sme viedli už napríklad na triedení a vyhľadávaní, jednu úlohu môžeme často riešiť viacerými spôsobmi. Tak intuitívne máme o niektorých pocit, že sú lepšie ako iné. Prečo a v čom sú niektoré riešenia lepšie a ako môžeme niečo také vlastne odhadovať (ináč ako intuitívne).
Čas
Často nás zaujíma, ako rýchlo nám program bude bežať. Vo väčšine prípadov táto rýchlosť nejakým spôsobom závisí od vstupných dát. Iste bude kratšie trvať utriedenie 3 prvkového poľa ako poľa s 100000 prvkami. Časovú zložitosť teda budeme odhadovať v závislosti od veľkosti vstupu.
Pre niektoré programy sa môže čas vypočítať jednoducho ako počet operácií, ktoré program vykoná. Avšak už pri použití podmienky dojdeme k situácii, kedy začneme uvažovať, čo započítať a co nie.
int main(void){ int x,max,N; cout << "Zadajte N>0: "; cin >> N; cout << "Zadavajte cisla: "; cin >> max; for (int i=1; i<N; i++){ cin >> x; if (x>max) {max=x;} } }
- Na začiatku máme 3 príkazy (cout a cin).
- Pre prvý prvok následne potrebujeme jeho načítanie (priamo do premennej max v ktorej si pamätáme aktuálne maximum).
- Je jasné, že pre každý ďalší z N prvkov, potrebujeme prvok načítať a opýtať sa na podmienku.
- Avšak už nie pre každý prvok musíme následne použiť priradenie (tých priradení nemusíme potrebovať žiadne ale môžeme ho potrebovať v každom z N-1 prvkov)
- Celkový súčet bude teda niečo medzi 3+1+(N-1)+0 a 3+1+(N-1)+(N-1)
Vo väčších programoch však to rozmedzie nie je také jednoduché vypočítať a preto sa bavíme často o najhoršom prípade, ktorý môže nastať. Okrem toho nás nezaujímajú presné čísla ale iba akýsi odhad (približná funkcia) závislá od vstupu. Ukážeme si odhad zložitosti na niektorých príkladoch.
- Už spomínané hľadanie maxima. Pre každý z N prvkov potrebujeme urobiť niekoľko (aspoň jednu ale nie viac ako konštantu) operácií. Preto zložitosť bude lineárna.
- Pozrime sa, ako na tom bude binárne vyhľadávanie. Pozrieme sa na najhorší možný scénár a to, že prvok nájdeme až v poslednom kroku alebo v poli nebude vôbec, teda ho neobjavíme skôr.
- V prvom kroku máme celé pole a v ňom sa pozrieme na stredný prvok a podľa jeho hodnoty zoberieme buď ľavú alebo pravú (zhruba) polovicu poľa.
- Tým pádom v druhom kroku máme pole polovičnej veľkosti a robíme na ňom zase to isté.
- V každom kroku teda máme pole o poloicu menšie až kým nemáme pole veľkosti 1 - potom buď už prbvok nájdeme alebo v ďalšom krku povieme, že tam nie je.
- Akú zložitosť bude mať tento program? Zapíšeme si číslo N (počet prvkov) v dvojkovej sústave. Pri delení poľa na polovicu bude ďalšia veľkosť poľa vlastne toto číslo bez poslednej cifry. Počet krokov, ktoré potrebujeme je teda zhruba počet cifier takto zapísaného čísla, čo je Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle log_2 N} .
- Iba tak pre úplnosť dodávam, že log N je menej ako N, čiže binárne vyhľadávanie beží rýchlejšie ako lineárne (v najhoršom prípade).
Na minulej prednáške boli niektoré triedenia. Pozrime, akú zložitosť majú. Odhad zložitosti urobím na jednom príklade, zvyšné si môžete skúsiť doma alebo na cvičeniach.
- Selection sort (max sort). Najprv pripomeniem hlavnú ideu: nájdeme najväčší prvok a uložme ho na koniec. Potom nájdime najväčší medzi zvyšnými a uložme ho na druhé miesto odzadu atď.
int maxIndex(int a[], int n) { /* vráť index, na ktorom je najväčší prvok z prvkov a[0]...a[n-1] */ int index = 0; for(int i=1; i<n; i++) { if(a[i]>a[index]) { index = i; } /* invariant: a[j]<=a[index] pre vsetky j=0,...,i*/ } return index; } void sort(int a[], int n) { /* usporiadaj prvky v poli a od najmenšieho po najväčší */ for(int kam=n-1; kam>=1; kam--) { /* invariant: a[kam+1]...a[n-1] sú utriedené * a pre každé i,j také že 0<=i<=kam, kam<j<n platí a[i]<=a[j] */ int index = maxIndex(a, kam+1); swap(a[index], a[kam]); } }
- Opäť máme program, v ktorom postupujeme v nejakých krokoch - v tomto prípade máme for-cyklus. V každom kroku musíme nájsť maximum z poľa a veľkosti kam+1. Potom už iba vymeníme takto nájdené maximum a posledný provok poľa. Pričom premenná kam je riadiaca premenná for-cyklu a v každom kroku klesá.
- Otázka je, aký čas potrebujeme na hľadanie maxima z x prvkov. Odpoveď je jednoduchá - prvky musíme prejsť všetky a teda zložitosť bude lineárna, t.j. x.
- Teraz si už iba spočítame: V prvom kroku hľadáme maximum z n prvkov, v druhom z n-1 ...
- Teda čas, ktorý na to potrebujeme je Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle n+(n-1)+...+1=\frac{n(n+1)}{2}=\frac{n^2}{2}+\frac{n}{2}} . Zložitosť tohoto triedenia bude teda kvadratická.
- Bude sa však správať rovnako (kvadraticky) na všetkých vstupoch? Ak by sme ako mieru zložitosti brali výmeny prvkov, koľkokrát zopakuje priradenie a[kam]=a[kam-1]?
Utriedené pole 1,2,...,n Pole n,1,2,...,n-1 Pole 2,3,...,n,1 Pole n,n-1,...,1
Pamäť
Ďalší bežný dôdov prečo povedať, že nejaký algoritmus je lepší ako druhý je, keď si toho musí menej pamätať. Majme napríklad klasickú úlohu - hľadanie najväčšieho prvku. To môžeme riešiť dvomi spôsobmi.
- Všetky čísla si zapamätáme do poľa a následne nájdeme maximum z poľa.
- Budeme zisťovať maximum priebežne a pamätať si ho v jednej premennej.
Na prvý spôsob si potrebujeme zapamätať pole čísel - teda pre N čísel potrebujeme N prvkov poľa a ešte nejaké pomocné premenné k tomu. Na rozdiel od toho, pre druhý spôsob (priebežné počítanie) si potrebujeme pamätať iba to priebežné maximum a nejakú pomocnú premennú. Zjavne teda pre nejaké väčšie N bude druhý spôsob výrazne vhodnejší.
Znaky
Znakové konštanty sa zapisujú v jednoduchých apostrofoch: 'A'. Špeciálne znaky sa dajú zapísať pomocou ich kódu v osmičkovej alebo šestnástkovej sústave: '\101' a '\x41' reprezentujú znak s kódom 65, t.j. 'A'.
Znaky majú teda svoje kódy. Najbežnejšie sa budeme stretávať s týmito:
- 32: medzera
- 27: escape
- 48...57: 0...9
- 65...90: A...Z
- 97...122: a...z
- -1 ... -128: (aby ste si nemysleli, že kódy sú iba kladné) rôzne symboly
Znakové premenné sú typu char. Ich veľkosť je vždy 1, teda sizeof(char) == 1
Do premennej môžem priraďovať, jej obsah zapísať alebo prečítať:
char c='A'; char z; z=c; cout << c; cin >> z; // prečíta jeden znak (pozor, preskakujú sa biele znaky)
Znaky môžem porovnávať. Na konci programu vyššie platí nasledovné:
- c=='A' ... je pravda,
- c=='a' ... nie je pravda – rozlišujú sa malé a veľké písmená,
- c<='Z' ... je pravda – písmená sú usporiadané: A<B< ... <Z, a<b< ... <z, aj cifry sú usporiadané: 0<1< ... <9.
Ako už bolo spomínané, pri čítaní zo streamu sa preskakujú tzv. biele znaky. Toto nie je vždy žiadúce a preto môžeme streamu nastaviť modifikátor noskipws, ktorý zruší preskakovanie takýchto znakov. Do premennej teda budeme vedieť prečítať aj medzeru.
#include <iostream> using namespace std; int main(void) { char a,b,c; cin >> noskipws >> a >> b >> c; cout << a << b << c; }
Pretypovavanie
Znakové premenné, ako už bolo spomínané majú svoje kódy. Tieto kódy sú celé čísla a preto medzi znakmi a celými číslami môžeme prechádzať úplne jednoducho.
#include<iostream> using namespace std; int main(void){ int N; char c; cout << "Napiste cislo: "; cin >> N; // prečíta číslo c=N; // do znakovej premennej môžeme číslo priradiť bez problémov cout << c << endl; // vieme vypísať znak cout << (c+1) << endl; // ale keď už použijeme aritm. operáciu, je to ako číslo cout << "Napiste znak: "; cin >> c; // prečíta znak N=c; // do celočíselnej premennej ho priamo vieme priradiť cout << N << endl; }
Okrem toho však vieme urobiť aj tzv. pretypovávanie, keď chceme aby výsledok bol konkrétneho typu. Napríklad, aby nám v prvej časti vypísalo nie ďalší kód ale ďalší znak, mohli sme výsledok pretypovať.
cout << (char)(c+1) << endl; // vďaka pretypovaniu dostávame na výpise zase znak
Všeobecne môžeme takýmto spôsobom môžeme meniť typ - napr. výsledku nejakej operácie.
double x=8.344; int N=x; cout << N/3 << " " << (double)(N/3) << " " << (double)N/3 << " " << x/3 << " " << (int)x/3<< endl;
Tento program vypíše nasledovný výstup:
2 2 2.66667 2.78133 2
Hádaj číslo (kým to niekoho baví)
Viacero programov čo sme tu mali sa mohlo vykonávať viac ráz. My si ukážeme, ako upraviť program "Hádaj číslo", aby po uhádnutí ponúkol možnosť hrať znovu, pokiaľ to niekoho baví.
#include <iostream> #include <cstdlib> #include <ctime> using namespace std; void HadajCislo(int number) { /* Pamätáme si, či sme už uhádli alebo nie. */ bool guessed = false; cout << "Guess a number between 1 and 10: "; /* Kým užívateľ neuhádne, spýtame sa ho na ďalšiu odpoveď. */ while (!guessed) { int guess; cin >> guess; /* Vyhodnotíme odpoveď. */ if (guess < number) { cout << "Too low, try again: "; } else if (guess > number) { cout << "Too high, try again: "; } else if (guess == number) { guessed = true; cout << "Correct guess" << endl; } } } int main(void) { /* vygenerujeme náhodné číslo medzi 1 a 10 */ srand(time(NULL)); int number; char c; bool pokracovat = true; while (pokracovat) { number = rand() % 10 + 1; HadajCislo(number); cout << "Do you want to play again? (Y/N) "; cin >> c; if (c=='Y') { cout << "OK. Play once more." << endl; } else if (c=='N') { pokracovat=false; } } }
Switch
V prípade, že by možností bolo viac a napríklad by sme chceli ináč reagovať v prípade iných odpovedí tak sa podmienka stane príliš komplikovanou. Preto často používame príkaz na switch, ktorý podľa hodnoty výrazu pokračuje jednou vetvou.
V našom jednoduchom príklade, by mohol switch vyzerať nasledovne:
switch (c) { case 'Y': cout << "OK. Play once more." << endl; break; case 'N': pokracovat = false; }
Vo všeobecnosti má príkaz switch viacero rôznych prípadov vyhodnotenia výrazu v podmienke.
switch (výraz) { case k1: príkazy1 case k2: príkazy2 default: príkazyd }
Takýto príkaz funguje nasledovne:
- Vyhodnotí výraz.
- Ak sa hodnota zhoduje s konštantným výrazom ki v niektorom case, pokračuje prvým príkazom v príkazyi
- Ak sa nezhoduje, pokračuje prvým príkazom v prikazyd, ak existuje default, alebo pokračuje za koncom switch bloku.
- Narozdiel od pascalovského case vykonávanie nekončí vykonaním posledného príkazu v prikazyi, ale pokračuje ďalej, ak nie je prerušené príkazom break.
#include <iostream.h> void main () { int n; cout << "\n" << "Zadaj n (1,2,3,4): "; cin >> n; switch (n) { case 1: cout << "Jeden\n"; case 2: cout << "Dva\n"; case 3: case 4: cout << "Tri alebo styri\n"; default: cout << "Chyba!\n"; } cout << "Koniec.\n"; }
Pre n=2 sa začnú vykonávať príkazy uvedené za vetvou case 2:. Vypíše sa:
Dva Tri alebo styri Chyba! Koniec.
Výhodou je, že môžeme zlúčiť viacero prípadov do jednej vetvy tým, ze príkazy napíšeme až za posledný prípad (tu vidíme napr. v situácii n=3 a n=4).
Dôležité upozornenie: break switch while
Možno ste si všimli, že v príklade Hádaj číslo som použila na ukončenie cyklu premennú pokračuj. V prípade použitia podmienky if som mohla namiesto toho urobiť cyklus nekonečný a v prípade odpovede 'N' cyklus prerušiť príkazom break. Keby som podobnú vec skúsila urobiť v prípade použitia switch program by sa neskončil nikdy. Dôvod je, že príkaz break nevyskočí zo všetkých cyklov, ale iba z najvnútornejšieho - a tým je v tomto prípade switch.
Kontrola čísla
Vďaka znakom môžeme skúsiť urobiť prvú jednoduchú kontrolu toho, čo nám vlastne používateľ napísal na vstup. Napríklad, či zadal správne celé číslo a nenamiešal medzi cifry nejaký iný znak.
#include <iostream> using namespace std; int main(void) { int N = 0; char c; cout << "Zadajte cele kladne cislo: "; cin >> noskipws >> c; while ((c >= '0') && (c <= '9')) { // kym je nacitany znak cislo (t.j. jedna cifra) /* vsimnite si ze nepripocitavame priamo c ale c-'0': ide totiz o kod znaku a '0' ma kod 48 */ N = N * 10 + (c - '0'); // upravime cislo N cin >> noskipws >> c; // a nacitame dalsi znak } if ((c == ' ') || (c == '\n')) { // ak sme skoncili medzerou alebo koncom riadku, tak je to pekne cislo cout << "Zadali ste " << N << endl; } else { cout << "Toto je cele cislo?" << endl; // ak sme skoncili niecim divnym, tak to asi nebude ok } }
Vďaka načítaniu znakov a ich kontroly vieme zistiť, či doteraz zadané číslo alebo čokoľvek iné zodpovedá tomu, čo program očakáva.
Prednáška 8
Organizačné poznámky
- DÚ3 do pondelka, zadania DÚ4 sa objavia koncom týždňa
- Zadania PDÚ2 dnes večer
- V piatok 12.10. od 11:35 v H6 školské kolo programátorskej súťaže ACM, viac na http://people.ksp.sk/~acm/news.php
- Pondelok poobede v H3 budú bývať nepovinné cvičenia z programovania
- Budúci týždeň preberáme rekurziu, dôležité učivo
Z minulej prednášky
Vďaka znakom môžeme skúsiť urobiť prvú jednoduchú kontrolu toho, čo nám vlastne používateľ napísal na vstup. Napríklad, či zadal správne celé číslo a nenamiešal medzi cifry nejaký iný znak.
#include <iostream> using namespace std; int main(void) { int N = 0; char c; cout << "Zadajte cele kladne cislo: "; cin >> noskipws >> c; while ((c >= '0') && (c <= '9')) { // kym je nacitany znak cislo (t.j. jedna cifra) /* vsimnite si ze nepripocitavame priamo c ale c-'0': ide totiz o kod znaku a '0' ma kod 48 */ N = N * 10 + (c - '0'); // upravime cislo N cin >> noskipws >> c; // a nacitame dalsi znak } if ((c == ' ') || (c == '\n')) { // ak sme skoncili medzerou alebo koncom riadku, tak je to pekne cislo cout << "Zadali ste " << N << endl; } else { cout << "Toto je cele cislo?" << endl; // ak sme skoncili niecim divnym, tak to asi nebude ok } }
Reťazec ako postupnosť znakov
- Reťazec je nejaký text, postupnosť znakov
- Vedeli by sme si naprogramovať vlastné funkcie na prácu s reťazcami, ukladať ich ako pole znakov
- Napríklad funkcia nacitajRiadok, ktorá znak po znaku načíta text z konzoly a uloží ich do poľa, dĺžku text uloží do premennej n.
- Naopak funkcia vypisRetazec dostane pole znakov a jeho dĺžku a vypisuje znak po znaku.
#include <iostream> using namespace std; void nacitajRiadok(char a[], int &n, int maxN) { /* Z konzoly nacita riadok a ulozi ho do pola a, * jeho dlzku do premennej n. Premenna maxN * obsahuje dlzku pola, ktoru nesmieme prekrocit. * Ak je riadok dlhsi ako maxN, nacita sa z neho iba cast. */ n = 0; while(n<maxN) { cin >> noskipws >> a[n]; n++; if(a[n-1]=='\n') { break; } } } void vypisRetazec(char a[], int n) { /* Na konzolu vypise prvych n znakov z pola a */ for(int i=0; i<n; i++) { cout << a[i]; } } int main(void) { const int maxN = 100; char a[maxN]; int n; cout << "Zadajte text: "; nacitajRiadok(a, n, maxN); cout << "Zadali ste: "; vypisRetazec(a, n); }
- Nevýhoda tohto riešenia: reťazec musíme posielať všade ako dve premenné (pole a dĺžku)
- Preto v Cčku reťazce štandardne fungujú trochu inak.
Reťazce v jazyku C
Textový reťazec je v jazyku C štandardne uložený ako postupnosť znakov char v poli ukončená znakom s kódom 0.
- Nemusíme teda ukladať zvlášť dĺžku, reťazec ide po prvú nulu
- Pozor, rozdiel medzi znakom s kódom 0 a znakom '0' s kódom 48
- Reťazce teda nemôžu obsahovať vo vnútri znak s kódom 0, ten je rezervovaný na ukončovanie
- Na reťazec s n znakmi potrebujeme pole dĺžky aspoň n+1, lebo jeden znak sa minie na ukončovací symbol
Teraz by sme vedeli prepísať nacitajRiadok a vypisRetazec, ale netreba, lebo existujú v knižniciach
Inicializácia reťazcov
- Chceme vytvoriť premennú str obsahujúce reťazec Ahoj spolu s koncom riadku
- Prvý spôsob je zdĺhavý:
char str[10]; str[0] = 'A'; str[1] = 'h'; str[2] = 'o'; str[3] = 'j'; str[4] = '\n'; // znak pre koniec riadku str[5] = 0;
- Alebo ako inicializácia poľa: char str[10]={'A','h','o','j','\n',0};
- Špeciálna skratka: char str[10]="Ahoj\n";
- Ako vytvoríme prázdny reťazec?
Reťazec je naozaj pole
Znaky reťazca môžeme meniť
char a[100] = "vlk"; char ch = a[0]; // ch obsahuje hodnotu 'v' char b[100] = "pes"; b[0] = ch; // priradíme do jedného prvku reťazca premmennú typu char. Výsledkom je 'ves'. b[0] = 'd'; // priradíme do jedného prvku reťazca konštantný znak. Výsledkom je 'des'. b[0] = a[1]; // priradíme do jedného prvku reťazca prvok iného reťazca. Výsledkom je 'les'.
Reťazec sa nedá kopírovať jendoduchým priradením, nemôžeme teda spraviť
char a[100]; a = "Ahoj"; // chyba char b[100] = "Ahoj"; // ok - inicializacia a = b; // chyba
Reťazce sa nedajú ani porovnávať pomocou ==, !=, < atď
Kopírovanie a porovnávanie si musíme naprogramovať cez cykly, alebo použiť hotové funkcie z knižníc.
Knižnica cstring
Obsahuje mnohé funkcie na prácu s reťazcami, napríklad tieto:
- strlen(retazec): vráti dĺžku reťazca
- strcpy(kam, co): skopíruje reťazec co do reťazca kam (pole kam musí byť dosť dlhé)
- strcat(kam, co): za koniec reťazca kam pridá reťazec co (pole kam musí byť dosť dlhé)
- strcmp(retazec1, retazec2): vráti nulu ak sa reťazce rovnajú, kladné číslo keď je prvý neskôr v abecednom poradí, záporné číslo ak je skôr. Pozor, to či je skôr alebo neskôr sa berie podľa kódov znakov, takže napr "Z" je skôr ako "a".
Všetky tieto funkcie by sme si však vedeli naprogramovať aj sami. Tu je napríklad výpočet dĺžky:
int myStrLen(char a[]) { int n=0; while(a[n]!=0) { n++; } return n; }
- čo bude funkcia robiť ak reťazcu chýba na konci 0?
Dve verzie kopírovania:
void myStrCpy(char a[], char b[]) { /* Skopiruj obsah retazca b do retazca a. * Pole a musi mat dost miesta. */ int n = 0; while (b[n] != 0) { a[n] = b[n]; n++; } a[n] = 0; // reťazec musí končiť 0 } void myStrCpy2(char a[], char b[]) { /* Skopiruj obsah retazca b do retazca a. * Pole a musi mat dost miesta. */ for (int i = 0; i <= strlen(b); i++) { a[i] = b[i]; } }
- Ktorá je rýchlejšia pre dlhé reťazce?
- Aká je ich zložitosť ako funkcia dĺžky reťazca n?
Namiesto strcmp naprogramujeme len test na rovnosť:
bool rovnostRetazcov(char a[], char b[]) { /* vrati true ak su retazce a, b rovnake, inak vrati false */ for (int i = 0; a[i] != 0 || b[i] != 0; i++) { if (a[i] != b[i]) return false; } return true; }
- Ako bude prebiehať funkcia, ak jeden reťazec je začiatkom druhého?
Načítavanie a vypisovanie reťazcov
- Bežné načítanie z konzoly do reťazca (cin >> str) načíta jedno slovo
- Preskočí biele znaky (medzery, konce riadkov, tabulátory), potom prečíta všetko po ďalší biely znak (alebo koniec vstupu) a uloží do premennej.
- Pri čítaní je vhodné nastaviť maximálny počet znakov na načítanie, aby sme nevyšli z poľa
- Na načítanie jedného riadku je možné použiť funkciu getline. Načíta až po koniec riadku, ten zahodí.
- Vypisovanie funguje normálne pomocou cout << str
#include <iostream> using namespace std; int main(void) { const int maxN = 100; char str[maxN], str2[maxN], str3[maxN]; cin.getline(str, maxN); // cely riadok, ale najviac maxN-1 znakov cin.width(maxN); // najviac maxN-1 znakov pri najbližšom načítaní cin >> str2; // nacita jedno slovo cin.width(maxN); // najviac maxN-1 znakov pri najbližšom načítaní cin >> str3; // nacita dalsie slovo cout << "str: \"" << str << "\"" << endl; cout << "str2: \"" << str2 << "\"" << endl; cout << "str3: \"" << str3 << "\"" << endl; }
Príklad behu programu (prvé dva riadky zadal užívateľ, na začiatku a konci každého je medzera)
a b c g h i str: " a b c " str2: "g" str3: "h"
Algoritmy s textovými reťazcami
Prácu s reťazcami si precvičíme na niekoľkých menších príkladoch.
Vyhľadávanie podreťazca
Chceme zistiť, či a kde sa v reťazci nachádza určité slovo alebo iná vzorka.
#include <iostream> #include <cstring> using namespace std; int find(char text[], char pattern[]) { /* Vráti -1 ak sa retazec pattern nevyskytuje v retazce text, * inak vráti polohu jeho prvého výskytu. */ int n = strlen(text); int m = strlen(pattern); for (int i = 0; i < n - m + 1; i++) { int j = 0; while (j < m && text[i + j] == pattern[j]) { j++; } if (j == m) { return i; } } return -1; } int main(void) { const int maxN = 2000; char A[maxN], B[maxN]; cout << "Zadaj text: "; cin.getline(A,maxN); cout << "Zadaj vzorku: "; cin.getline(B,maxN); cout << find(A,B) << endl; }
- Predpočítame si dĺžky a uložíme do premenných, aby sa zbytočne nerátali znova a znova
- Vedeli by sme do poľa uložiť polohy všetkých výskytov?
Prevod čísla na reťazec
Máme danú premennú x typu int, chceme ju uložiť v desiatkovej sústave do reťazca.
- Zvyšok po delení 10 je posledná cifra, uložíme si ju do reťazca, vydelíme x desiatimi
- Opakujeme, kým nespracujeme celé číslo.
- Prevod z čísla c (0..9) na cifru: '0'+c
- Nezabudneme na ukončovací znak 0
- Dostaneme číslo v opačnom poradí, napr pre x=12 budeme mať reťazec {'2', '1', 0}
- Preto ešte celé číslo otočíme naopak.
void reverse(char a[]) { int n = strlen(a); int i = 0; int j = n - 1; while (i < j) { char tmp = a[i]; a[i] = a[j]; a[j] = tmp; i++; j--; } } void int2str(int x, char a[]) { /* prevedie kladne cele cislo x na retazec, * vysledok ulozi do retazca a, ktory musi mat dost miesta. */ assert(x > 0); int n = 0; while(x > 0) { a[n] = '0' + x % 10; x /= 10; n++; } a[n] = 0; /* teraz je cislo naopak, treba otocit */ reverse(a); }
- Ako upravíme funkciu, aby fungovala aj pre x=0, prípadne záporné x?
- Pozor na rozdiel medzi znakom 0 a '0' (a medzi reťazcom "0")
Formátovanie čísla
- Chceme číslo zapísať do reťazca a doplniť naľavo medzerami na šírku width.
const int maxN = 100; void formatInt(int x, char A[], int width) { /* číslo x konvertujeme na reťazec * a uložíme do poľa A zarované doprava na šírku width */ /* najprv x uložíme do pomocného reťazca B a zrátame jeho dĺžku n */ char B[maxN]; int2str(x, B); int n = strlen(B); /* do A dáme n-width medzier a ukončovaciu 0 */ assert(n <= width); int i; for (i = 0; i < width - n; i++) { A[i] = ' '; } A[i] = 0; /* za A prikopírujeme B */ strcat(A, B); }
- Čo by sa stalo, ak by sme nedali do A ukončovaciu 0?
- Vedeli by sme prepísať program, aby pracoval priamo v poli A (bez poľa B)?
Využijeme na vypísanie pekne zarovnanej tabuľky faktoriálov:
int factorial(int n) { int result = 1; for (int i = 1; i <= n; i++) { result *= i; } return result; } int main(void) { char A[maxN]; int n = 12; for (int i = 1; i <= n; i++) { int x = factorial(i); formatInt(i, A, 2); cout << A << "! = "; formatInt(x, A, 10); cout << A << endl; } }
1! = 1 2! = 2 3! = 6 4! = 24 5! = 120 6! = 720 7! = 5040 8! = 40320 9! = 362880 10! = 3628800 11! = 39916800 12! = 479001600
Dalo by sa aj jednoduchšie pomocou nastavenia width v cin:
int main(void) { int n = 12; for (int i = 1; i <= n; i++) { int x = factorial(i); cout.width(2); cout << i << "! = "; cout.width(10); cout << x << endl; } }
Zalamovanie riadkov
- Máme reťazec s nejakým textom, v ktorom sa vyskytujú rôzne biele znaky, napríklad medzery a konce riadkov. Máme danú šírku riadku W, napr. 80 znakov. Úlohou je ho upraviť tak:
- aby na každom riadku bolo najviac napr. W znakov, pričom nový riadok začína tam, kde by už ďalšie slovo presahovalo cez W
- medzi dvoma slovami má byť vždy buď jedna medzera alebo jeden koniec riadku
- predpokladáme, že žiadne slovo nemá viac ako W znakov
Zadavaj text ukonceny prazdnym riadkom. A AA A AAA A A AA AAA AAA A AA AA A Zadaj sirku riadku: 5 Sformatovany odstavec: A AA A AAA A A AA AAA AAA A AA AA A
Zadavaj text ukonceny prazdnym riadkom. Martin Kukucin: Do skoly. Vakacie sa koncia. Ondrej Rybar sa vse zamysli nad marnostou sveta i vsetkeho, co je v nom. Predstupuje mu tu i tu pred oci profesor, ako stoji pred ciernou tabulou, drziac kruzidlo v ruke a demonstruje pamatnu poucku Pytagorovu. A zimomriavky naskakuju na chrbat, lebo s geometriou stoji od pociatku na nohe valecnej. Ani matematika nenie lepsia, menovite odvtedy, co sa do nej vplichtili miesto cisel vsakove litery. Neraz hutal, naco ich ucenci vpustili do matematiky - ved i bez nich je dost strapata: ci sa im malilo cisel a tak preto vsantrocili medzi ne a a b a ci fantazia sa im tak rozihrala, ze prekrocila hranice cisel celych, zlomkov obycajnych i desatinnych i bohvieakych, a zabludila na nivy, kde rastu nestastne litery? ,Uz akokolvek,' huta Ondro, ,litery tam nemaju co hladat. Tazko je uverit, ze a/b = c, lebo nevies, co je a, alebo b.' Zadaj sirku riadku: 50 Sformatovany odstavec: Martin Kukucin: Do skoly. Vakacie sa koncia. Ondrej Rybar sa vse zamysli nad marnostou sveta i vsetkeho, co je v nom. Predstupuje mu tu i tu pred oci profesor, ako stoji pred ciernou tabulou, drziac kruzidlo v ruke a demonstruje pamatnu poucku Pytagorovu. A zimomriavky naskakuju na chrbat, lebo s geometriou stoji od pociatku na nohe valecnej. Ani matematika nenie lepsia, menovite odvtedy, co sa do nej vplichtili miesto cisel vsakove litery. Neraz hutal, naco ich ucenci vpustili do matematiky - ved i bez nich je dost strapata: ci sa im malilo cisel a tak preto vsantrocili medzi ne a a b a ci fantazia sa im tak rozihrala, ze prekrocila hranice cisel celych, zlomkov obycajnych i desatinnych i bohvieakych, a zabludila na nivy, kde rastu nestastne litery? ,Uz akokolvek,' huta Ondro, ,litery tam nemaju co hladat. Tazko je uverit, ze a/b = c, lebo nevies, co je a, alebo b.'
Plán: úlohu si rozdelíme na viac častí
- Prerobíme reťazec tak, aby sme všetky biele znaky nahradili medzerami. Na rozpoznanie bielych znakov použijeme funkciu isspace z knižnice cctype.
- Každý súvislý úsek medzier nahradíme práve jednou medzerou, zmažeme medzery na začiatku a konci.
- Podobá sa na príklad s vyhadzovaním núl z poľa z cvičení
- Viac možnostá na riešenie, napríklad znaky presýpame do nového poľa. my ale použijeme len jedno pole
- Niektoré medzery nahradíme koncom riadku, aby každý riadok mal šírku najviac W
- Spravíme načítanie a vypísanie.
#include <iostream> #include <cstring> #include <cctype> #include <cassert> using namespace std; void simplify(char A[]) { /* V retazci A nahradi kazdy suvisly usek bielych znakov prave jednou medzerou. * Na zaciatku a konci retazca nebudu medzery. */ int i; /* prepis hocijake biele znaky na medzeru */ for (int i = 0; A[i] != 0; i++) { if (isspace(A[i])) { A[i] = ' '; } } int kam = 0; /* prve este neobsadene miesto */ char prev = ' '; /* predchadzajuci znak */ for (int i = 0; A[i] != 0; i++) { /* ak nemame viac medzier po sebe, skopirujeme znak */ if (A[i] != ' ' || prev != ' ') { A[kam] = A[i]; kam++; } /* zapamatame si posledny znak */ prev = A[i]; } /* zrusime pripadnu medzeru na konci */ if (kam > 0 && A[kam - 1] == ' ') { kam--; } /* retazec ukoncime nulou */ A[kam] = 0; } bool breakLines(char A[], int width) { /* Preformatuje odstavec na sirku riadku width, vyhodi zbytocne medzery. * Dlzka kazdeho slova musi byt najviac width, inak funkcia vrati false */ simplify(A); int n = strlen(A); int zac = 0; /* prve pismeno v riadku */ while (zac < n) { int kon = zac + width; /* potencialny koniec riadku */ /* ak uz nemame dost pismen na cely riadok */ if (kon > n) { kon = n; } /* ak sme na konci, pridame koniec riadku za koniec retazca */ if (kon == n) { A[kon] = '\n'; A[kon + 1] = 0; n++; } else { /* ideme späť, kým nenájdeme medzeru */ while (kon > zac && A[kon] != ' ') { kon--; } /* nenašli sme medzeru: slovo bolo príliš dlhé. */ if (kon == zac) { return false; } /* medzeru prepíšeme na koniec riadku */ assert(A[kon]==' '); A[kon] = '\n'; } /* za koncom riadku bude novy zaciatok */ zac = kon + 1; } return true; } int main(void) { const int maxN = 2000; char A[maxN]; cout << "Zadavaj text ukonceny prazdnym riadkom." << endl; while (true) { /* nacitame jeden riadok */ char tmp[maxN]; cin.getline(tmp, maxN); /* ak je prazdny, koncime nacitavanie */ if (strcmp(tmp, "") == 0) { break; } /* ak je miesto v poli A, pridame do neho novy riadok */ if (strlen(A) + strlen(tmp) + 2 < maxN) { strcat(A, tmp); strcat(A, "\n"); } else { cout << "Text je prilis dlhy." << endl; return 1; } } cout << "Zadaj sirku riadku:" << endl; int width; cin >> width; breakLines(A, width); cout << "Sformatovany odstavec:" << endl; cout << A; }
- Akú zložitosť má načítanie vzhľadom na celkový počet načítaných písmen? Dalo by sa zlepšiť?
Zhrnutie
- Reťazec je pole znakov, za posledným znakom reťazca dáme špeciálny znak s kódom 0
- V knižnici cstring sú funkcie na porovnávanie a kopírovanie reťazcov atď
- Ďalšie funkcie si vieme naprogramovať aj sami, zvyčajne jednoduchá práca s poľom
Cvičenia 4
Manipulácia s poľom
Napíšte funkciu, ktorá dostane pole intov a a jeho veľkosť n. Funkcia v poli nájde všetky nuly a vyhodí ich, pričom po skončení je v premennej n nový počet prvkov.
- Viete spraviť funkciu tak, aby poradie nenulových prvkov zostalo to isté? T.j. z poľa {1,0,4,0,0,7} dostaneme {1,4,7}
Triedenia
- Bublinkové triedenie z prednášky 6 v prvej iterácii dostane najväčší prvok na svoje miesto, po druhej už sú dva najväčšie na svojom mieste atď.
- Využite tento fakt na zrýchlenie: porovnávajte dvojice len po n-k kde k je číslo aktuálnej iterácie (program s triedeniami je tu).
- Bublinkové triedenie sa dá zrýchliť ešte viac v prípade, ak si budeme pamätať posledné miesto, kde sa uskutočnila výmena. Od tohoto miesta ďalej už je pole usporiadané.
Ladenie programu (debugovanie)
Šejkrové triedenie je veľmi podobné bublinkovému. Na rozdiel od neho šejkrové po prejdení poľom jedným smerom až do konca nezačína znovu od začiatku, ale pokračuje opačným smerom od konca späť. Taktiež používa zrýchlenie spomenuté v predchádzajúcej úlohe k bublinkovému triedeniu. Šejkrové triedenie teda prechádza poľom stále tam a späť, pokiaľ sa usporiadaný začiatok nespojí s usporiadným koncom.
Nájdite všetky chyby v nasledujúcom programe. Doporučujeme najprv spraviť program skompilovateľný, potom si ho pozorne prečítať a odstrániť nezmysly a zvyšné chyby odladiť pomocou krokovania programu.
Triky s otáčaním poľa
Máme dané pole intov a a počet jeho prvkov n.
- Otočte poradie prvkov v úseku poľa zadanom začiatkom a koncom.
- Posuňte pole cyklicky o 1 doprava, pričom posledný prvok sa dostane na prvé miesto.
- Posuňte pole cyklicky o k doprava.
- Viete to spraviť tak, aby čas výpočtu nezávisel od k? Pomôcka: skúste využiť otáčanie.
Polynómy
- Na prednáške 6 sme mali program], v ktorom polynóm reprezentujeme ako pole jeho koeficientov. Napíšte funkciu, ktorá vynásobí takéto polynómy.
- Vykreslite graf polynómu.
Prvočísla
- Použite Eratostenovo sito na nájdenie prvočísel z prednášky 5. S pomocou týchto prvočísel napíšte program na rozklad čísla na súčin prvočíselných deliteľov.
Shakersort pre cvičenia 4
#include <ioscream> #using namespace std; void swap(int x, int y) { /* Vymeň hodnoty premenných x a y. */ int tmp = x; x = y; y = tmp; } void printArray(int a[], int n) { /* Vypíš celé pole. */ for (int i = 0; i < n; i++) { cout << " " << a[n]; } cout << endl; } void shakerSort(int a[], int n) { /* Usporiadaj prvky v poli a od najmenšieho po najväčší. */ /* Chodíme tam a späť, pričom vždy menej, * lebo na koniec v každom prechode presunieme číslo, * ktoré tam patrí. */ int begin = 0; int end = n; int i; while (begin<end) { /* spravíme prechod zľava doprava */ for (i==begin; i<end; i++); { if (a[i]>=a[i+1]) swap(a[i], a[i+1]); } end--; /* spravíme prechod sprava doľava */ for (i==end; i>begin; i++); { if (a[i]>=a[i-1]) swap(a[i], a[i+1]); } begin--; } } int main(void) { int n = 6; int a[6] = {9, 3, 7, 4, 5, 6}; printArray(a, n); sharkSort(a, n); printArray(a, n); }
DÚ3
Odovzdávanie DÚ3 max. 15 bodov, termín odovzdania pondelok 15.10. o 22:00
Cieľom tejto domácej úlohy je precvičiť si prácu s poliami a funkciami pri písaní o niečo dlhšieho programu. Budeme programovať hru Logik. V tejto hre máme hracie kamene F rôznych farieb. Prvý hráč (v našom prípade počítač) si zvolí N hracích kameňov a uloží ich do radu. Druhý hráč sa snaží túto postupnosť farieb uhádnuť. V každom kole si druhý hráč tiež zvolí N kameňov a zoradí ich. Prvý hráč mu povie, ako blízko je k správnej odpovedi pomocou bielych a čiernych bodov nasledujúcim spôsobom:
- Za každú pozíciu, na ktorej sa správna opoveď a najnovší pokus nelíšia, dostane čierny bod.
- Celkový počet bodov (bielych a čiernych spolu) zodpovedá tomu, koľko najviac čiernych bodov by sa dalo získať preusporiadaním kameňov v pokuse.
Ak sa teda v pokuse žiadna farba neopakuje, biele body zodpovedajú farbám, ktoré sú aj v správnej odpovedi, ale na inom mieste ako v pokuse. Ak sa farby v pokuse opakujú, musíme vziať do úvahy aj ich počty. Napríklad ak pokus obsahuje tri červené kamene a správna odpoveď iba dva červené kamene, hráč dostane iba dva biele (príp. čierne) body.
Hra sa končí, keď druhý hráč dostane N čiernych bodov, teda správne uhádol poradie farieb v správnej odpovedi.
V našej verzii budeme farby reprezentovať číslami 0,1,...,F-1. Biele body sa budú zapisovať ako malé x a veľké body ako veľké X. Vždy sa vypíšu najskôr všetky biele a potom všetky čierne body. Tu je príklad priebehu hry pre N=3, F=5 a správnu odpoveď 2,4,4.
Zadaj 3 cisel(cisla) od 0 po 4: 0 1 2 Hodnotenie: x Zadaj 3 cisel(cisla) od 0 po 4: 0 3 4 Hodnotenie: X Zadaj 3 cisel(cisla) od 0 po 4: 1 4 3 Hodnotenie: X Zadaj 3 cisel(cisla) od 0 po 4: 3 2 4 Hodnotenie: xX Zadaj 3 cisel(cisla) od 0 po 4: 3 2 2 Hodnotenie: x Zadaj 3 cisel(cisla) od 0 po 4: 2 4 4 Hodnotenie: XXX Uhadli ste!
Napíšte program, ktorý vygeneruje správnu odpoveď generátorom pseudonáhodných čísel a potom si opakovane od hráča vypýta jeho tip a spočíta mu body. Hra sa končí, keď hráč uhádne správnu odpoveď. Môžete predpokladať, že hráč zadáva korektné hodnoty (čísla od 0 do F-1).
Najzložitejšou časťou je spočítanie počtu bielych bodov. Ten môžete získať z celkového počtu bodov odčítaním čiernych bodov. Na spočítanie celkového počtu bodov doporučujeme vytvoriť pomocné pole dĺžky F, ktoré v políčku i bude mať počet výskytov čísla i v správnej odpovedi a druhé pole takého istého tvaru pre aktuálny pokus. Potom viete ľahko spracovať prípad typu, že v pokuse sú dva červené a v správnej odpovedi tri červené kamene.
Nižšie prikladáme kostru programu, ktorá celý problém rozkladá na menšie časti implementované v jednotlivých funkciách. Doporučujeme Vám postupovať podľa tohto návodu, nie je to však nevyhnutné. Vaše riešenie by však malo spĺňať nasledovné požiadavky:
- Váš program správne funguje a správa sa analogicky k vyššie uvedenému priebehu hry.
- Hodnoty N a F máte zadefinované ako konštanty, ktoré stačí zmeniť na jednom mieste v programe.
- Používate len príkazy, ktoré sme preberali na prednáške.
- Program je rozdelený na niekoľko funkcií s dobre logicky definovanými úlohami. Mená funkcií zodpovedajú tomu, čo tie funkcie robia a na začiatku každej funkcie v komentári podrobnejšie vysvetlíte jej účel.
#include <iostream> #include <cstdlib> #include <ctime> using namespace std; /* globalne konstanty: * F je pocet vsetkych moznych farieb * (farby budu od 0 po F-1 vratane) * N je pocet hadanych farieb */ const int F = 5; const int N = 3; void nacitaj(int a[]) { /* Do pola a od uzivatela nacita N cisel od 0 po F-1 */ } void generuj(int a[]) { /* Do pola a vygeneruje N nahodnych cisel od 0 po F-1 */ } int cierne(int a[], int b[]) { /* V poli a je spravne riesenie, v poli b je pokus. * Obidve polia obsahuju N cisel od 0 po F-1. * Funkcia vrati pocet ciernych bodov, * ktore ma uzivatel dostat. */ } void pocty(int a[], int p[]) { /* V poli a je riesenie (N cisel od 0 po F-1). * Do pola p spocitame pocty vyskytov * jednotlivych cisel, t.j. pre 0<=i<F * p[i] bude pocet vskytov cisla i v poli a */ } int vsetky(int a[], int b[]) { /* V poli a je spravne riesenie, v poli b je pokus. * Obidve polia obsahuju N cisel od 0 po F-1. * Funkcia vrati pocet vsetkych bodov, * ktore ma uzivatel dostat. */ } void vypis(int vsetky, int cierne) { /* Dany je pocet vsetkych bodov a kolko * z nich maju byt cierne (zvysne su biele). * Pre kazdy biely bod vypise x * a pre kazdy cierny X. */ } int main(void) { /* pole so spravnou odpovedou a pokusom */ int spravne[N]; int pokus[N]; /* generovanie spravnej odpovede */ srand(time(NULL)); generuj(spravne); /* samotna hra */ while(true) { nacitaj(pokus); int v = vsetky(spravne, pokus); int c = cierne(spravne, pokus); vypis(v, c); if(c==N) { cout << "Uhadli ste!" << endl; break; } } }
Prednáška 9
Bežné úvodné príklady na rekurziu
Vysvetlenie pojmu rekurzia sa dá zhrnúť do jednej vety: Rekurzia je metóda, pri ktorej definujeme objekt (funkciu, pojem, . . . ) pomocou jeho samého.
Na začiatok sa skúsme pozrieť na „klasické“ príklady algoritmov využívajúcich rekurziu. Prvým, azda najklasickejším príkladom je faktoriál. Ten pre prirodzené (0, 1, 2, . . .) číslo n vráti 1 pokiaľ n = 0 a súčin všetkých čísel od 1 po n inak.
int factorial(int n){ if (n<2) return 1; else return n*factorial(n-1); }
Výpočet faktorilu je založený na jeho rekurzívnej definícii. Pri prepisovaní rekurzívnych definícii (a všeobecne pri používaní rekurzie) je potrebné dodržiavať nasledujúce zásady, aby sme sa vyhli chybám:
- Príkazová časť rekurzívnej procedúry (funkcie) musí obsahovať vetvu pre triviálny prípad niektorého základného parametra alebo vstupnej hodnoty. Táto vetva nebude obsahovať (rekurzívne) volanie procedúry (funkcie), ktorú práve definujeme.
- Ľubovoľné volanie procedúry (funkcie) vo vnútri jej príkazovej časti musí mať vhodne redukovaný argument (alebo globálnu hodnotu). Pri tejto redukcii sa očakáva, že raz dosiahne triviálny prípad po konečnom počte opakovaní.
Ďalším tradičným príkladom na rekurziu s ktorým ste sa už stretli je počítanie najväčšieho spoločného deliteľa. Opäť dostvame jednoduchú rekurzívnu funkciu. Budeme si jej parametre udržovať usporiadané, tj. prvý parameter je vždy väčší ako druhý (ak by to tak nebolo, vieme jednuduchým testom na začiatku upraviť).
- Triviálny prípad nastáva, keď druhý parameter je 0. Potom je výsledkom prvý parameter.
- V opačnom prípade je NSD(a,b) = NSD(a mod b, b) - tu však vidíme, že Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle a mod b < b} a preto zavoláme NSD(b,a mod b)
int nsd(int a, int b){ if (b == 0) return a; else return nsd(b,a%b); }
A nemôžeme vynechať obľúbený rekurzívny príklad - Fibonacciho čísla. Tam sa rekurzia priam pýta, keďže Fibonacciho čísla sú samé o sebe definované rekurzívne.
- F(0)=F(1)=1
- F(n)=F(n-1)+F(n-2) pre n>2
Z tejto definície vieme opäť urobiť rekurzívny príklad jednoducho:
int fib(int n){ if (n<2) return 1; else return fib(n-1)+fib(n-2); }
Nepriama rekurzia
Všetky doteraz uvedené funkcie sú príkladom priamej rekurzie – definovaná funkcia používa seba samú priamo. Druhým možným prípadom je nepriama rekurzia (alebo tiež vzájomná), kedy funkcia neodkazuje vo svojej definícii priamo na seba, ale využíva inú funkciu, ktorá sa odkazuje naspäť na prvú (všeobecnejšie sa kruh môže uzavrieť na krokov viac). Ako príklad uveďme rekurzívne definície predikátov párnosti a nepárnosti
bool even(int n) { if (n == 0) return true; else return odd(n - 1); } bool odd(int n) { if (n == 0) return false; else return even(n - 1); }
Binárne vyhľadávanie
Binárne vyhľadávanie sme už mali skôr, avšak rekurzia značne zjednoduší a zprehľadní túto funkciu. Na rozdiel od pôvodnej verzie si nepotrebujeme pamätať okraje aktuálneho miesta - pamätá si ich za nás rekurzia (ako svoj parameter).
Ako funguje:
- V prípade, že už máme jednoprvkové pole dostávame triviálny prípad.
- Ak máme viac prvkov, tak sa rekurzívne zavoláme na pravú alebo ľavú stranu podľa vzťahu hodnoty x a stredného prvku.
bool binSearch(int x, int l, int r, int A[]){ if (l==r) return (A[l]==x); if (x<=A[(l+r)/2]) return binSearch(x,l,(l+r)/2,A); else return binSearch(x,(l+r)/2+1,r,A); } int main(void){ int A[9]={1,5,7,12,45,79,100,123,467}; cout << binSearch(7,0,8,A); }
Rekurzia
Predchádzajúce príklady boli príkladmi použitia rekurzie pri definícii jednoduchých funkcií. Samozrejme, funkcie, ktoré by počítali to isté, by sa dali naprogramovať aj bez pomoci rekurzie. Ale pravdepodobne vidíte, že rekurzívny spôsob je prehľadnejší, zrozumiteľnejší, kratší a krajší (teda aspoň v prvých príkladoch určite).
Načo to vôbec robíme, veď všetko toto sme už robili aj pred tým a nebolo to nič náročné (prečo vôbec riešiť niečo ako rekurzia)? Asi hlavný dôvod je, že nie všetko vieme prepísať bez rekurzie. Príklady, ktoré sme ukázali boli teda istým spôsobom ľahké - pomocou rekurzie vieme urobiť oveľa viac.
Vyhodnocovanie výrazu
Máme zadaný reťazec, v ktorom je výraz obsahujúci celé čísla, znamienka '+', '-' a zátvorky. Pre jednoduchosť predpokladajme, že zátvorky sú všade (t.j. každý výraz je tvaru (Výraz Operátor Výraz) alebo Číslo)a celý výraz je správne uzátvorkovaný.
Príklady výrazov:
- 99
- (12+13)
- (((12-5)+7)-(6+8))
Na vyhodnotenie výrazu môžeme použiť nasledovný postup:
- Nájdeme si znamienko Z také, že výraz je tvaru ((Výraz1)Z(Výraz2))
- Zistíme, akú hodnotu majú Výraz1 a Výraz2
- Hodnota celého výrazu sa dá vypočítať pomocou týchto hodnôt a znamienka Z
Čo nutne ešte potrebujeme je nájsť správne znamienko Z.
int najdiZnamienko(char str[]){ /*Vieme, ze vyraz je tvaru (Vyraz1 Z Vyraz2)*/ int poc=0; for (int i=1; i<strlen(str)-1; i++){ if (str[i]=='(') poc++; else if (str[i]==')') poc--; else if (((str[i]=='+')||(str[i]=='-'))&&(poc==0)) return i; } return -1; }
Ďalej je dobre sa zamyslieť, kedy s vyhodnocovaním skončíme. Bude to v prípade, že už očakvame, že máme výraz iba celé číslo - na začiatku nie je zátvorka.
Potom vyhodnocovanie výrazu može pracovať nasledovne:
int vyhodnotVyraz(char str[]){ if (str[0]!='(') return vyhodnotCislo(str); else { char s[100]; int poz, hodnota1, hodnota2; poz=najdiZnamienko(str); strCopy(str,s,1,poz-1); // od 1 po pozíciu pred znamienkom (pozícia 0 je '(' ) hodnota1=vyhodnotVyraz(s); strCopy(str,s,poz+1,strlen(str)-2); // od pozície po znamienku po predposledný znak stringu (posledný znak - strlen()-1 je ')' ) hodnota2=vyhodnotVyraz(s); switch (str[poz]){ case '+': return hodnota1+hodnota2; case '-': return hodnota1-hodnota2; } return 0; } }
Fraktály
Príkladom fraktálu je Kochova krivka. Ako vzniká?
- Predstavme si úsečku, ktorá meria d centimetrov.
- Ďalej potrebujeme transformáciu, teda konkrétne presne definovaný súbor opakovateľných pravidiel: Úsečka sa rozdelí na tretiny a nad strednou tretinou sa zostrojí rovnostranný trojuholník. Základňa trojuholníka v krivke nebude. Opakovaní môžeme robiť nekonečno.
- Druhá možnosť je popísať krivku pomocou systému, ktorého vykonávanie sa podobá príkazom korytnačky.
- Základným krokom je F (forward) vytvorenie rovnej čiary určitej dĺžky
- Okrem toho poznáme príkazy + a - (turn left a turn right o určitý uhol - v našom prípade 60 stupňov)
- Krivku môžeme popísať pomocou nasledovného pravidla F → F+F--F+F , ktoré kreslí z pôvodnej krivky komplikovanejšiu krivku.
- Takže namiesto F (rovnej čiary určitej dĺžky) môžeme nakresliť rovnú čiaru, otočiť sa doľava, nakresliť rovnú čiaru, dva krát sa otočiť doprava, nakresliť čiaru, otočiť sa doľava a nakresliť čiaru.
- Následne s každou čiarou môžeme opäť urobiť transformáciu a dostať zložitejšiu krivku.
- Drobný problém, ktorý musíme vyriešiť je, že týmto spôsobom (ak by sme robili vždy čiary veľkosti d) by nám obrázok príliš rástol. My však chceme ostať v pôvodnej veľkosti preto pri každej transformácii zmenšíme dĺžku čiary na 1/3.
Z toho potom dostávame nasledovný program:
#include "../SimpleDraw.h" void drawKoch(double d, int n, Turtle& turtle){ if (n==0) turtle.forward(d); else { drawKoch(d/3, n-1, turtle); turtle.turnLeft(60); drawKoch(d/3, n-1, turtle); turtle.turnLeft(-120); drawKoch(d/3, n-1, turtle); turtle.turnLeft(60); drawKoch(d/3, n-1, turtle); } } int main(void) { int width = 310; /* rozmery obrazku */ int height = 150; double d = 300; /* velkost krivky */ int n = 3; /* stupen krivky */ double wait = 0.2; /* kolko korytnacka caka */ /* Vytvor obrázok */ SimpleDraw window(width, height); /* Vytvor korytnačku otočenú doprava. */ Turtle turtle(window, 1, height - 10, 0); /* Zobraz korytnačku ako šípku. */ turtle.show(); /* Korytnačka bude čakať po každom ťahu. */ turtle.setWait(wait); /* nakresli Kochovu krivku rekurzívne */ drawKoch(d, n, turtle); /* Schovaj korytnačku. */ turtle.hide(); /* Zobraz na obrazovke a čakaj, kým užívateľ stlačí Exit, potom zavri okno. */ window.showAndClose(); }
Hanojské veže
- Problém hanojských veží pozostáva z troch stĺpcov (tyčiek) a niekoľkých kruhov rôznej veľkosti. Začína sa postavením pyramídy z kruhov (kameňov) na prvú tyčku.
- Úlohou je potom presunúť celú pyramídu na inú tyčku, avšak pri dodržaní nasledovných pravidiel:
- v jednom ťahu (na jedenkrát) je možné premiestniť iba jeden hrací kameň
- väčší kameň nesmie byť nikdy položený na menší
Ako budeme úlohu riešiť? Asi rekurzívne, nie?
- V prípade, že máme iba jeden kameň je úloha veľmi jednoduchá - preložíme ho z pôvodného stĺpika na cieľový stĺpik.
- Ak chceme preložiť viac kameňov (nech ich je N), tak
- Všetky okrem posledného preložíme na pomocný stĺpik (na to použijeme taký istý postup len s N-1 kameňmi)
- Premiestnime jeden kameň kam potrebujeme
- Zatiaľ odložené kamene (na pomocnom stĺpiku) preložíme z pomocného na cieľový stĺpik (na to použijeme opäť taký istý postup s N-1 kameňmi)
Aby sme to popísali konkrétnejšie - preloženie N kameňov z A na C (s pomocným stĺpikom B) urobíme takto:
- Preložíme N-1 kameňov z A na B (s použitím C)
- Preložíme 1 kameň z A na C (s použitím B - ale reálne to potrebovať nebudeme)
- Preložíme N-1 kameňov z B na C (s použitím A)
Dôležité je si uvedomiť, že nasledovný postup dodržuje pravidlá.
void presunHanoi(int odkial, int cez, int kam, int n){ if (n == 1) { cout << "Prelozim kamen z " << odkial <<" na " << kam << endl; } else { presunHanoi(odkial, kam, cez, n-1); // odlozime si n-1 na pomocny-cez presunHanoi(odkial, cez, kam, 1); // prelozime najvacsi na finalne miesto presunHanoi(cez, odkial, kam, n-1); // zvysnych n-1 prelozime z docasneho odkladiska na finalne } } int main (void){ presunHanoi(1, 2, 3, 3); // z veze 1 na vezu 3 (pomocou veze 2) }
Rekurzia pomocou stacku - ako to funguje
O rekurzívne volania sa stará zásobník. Ako funguje?
- Pri vnáraní sa do rekruzívnej funkcie (keď volá funkcia sama seba) si potrebuje zapamätať stav v akom sa nachádza, aby sa pri vynorení vedel dostať do pôvodného stavu. Všetky informácie popisujúce stav si zapíše do zásobníka a až potom sa rekurzívne zavolá.
- Pri vynorení musí zo zásobníka vybrať v prvom rade miesto, kde v rekurzívnej funkcii pokračovať a ďalej všetky premenné.
Čo si teda musel zásobník pamätať?
- adresu návratu - teda miesto kde v rekurzívnej funkcii sa nachádza: dôležité je to hlavne v situácii, keď máme viacero rekurzívnych volaní (či už podľa podmienky alebo sa voláme vždy viac krát)
- lokálne premenné - hodnoty (a spôsob ako sa k nim dostať - v realite totiž zásobník funguje kúsok komplikovanejšie)
Keď už vieme, že o rekurzívne volania sa stará zásobník, možeme si taký jednoduchý zásobník osimulovať napríklad na výpočte faktoriálu.
int fact(int n){ if (n<2) return 1; else return n*fact(n-1); }
Chvostová rekurzia
Dôvod, prečo sme tieto príklady vedeli napísať už pred tým, ako sme sa dozvedeli niečo o rekurzii je to, že voláme rekurziu z každého volania iba raz. Napríklad na výpočet faktoriálu daného čísla potrebujeme jedenkrát rekurzívne zavolať faktoriál predchádzajúceho čísla. Navyše sa rekurzívne volanie nachádza iba ako posledný krok (niektorých vetiev) výpočtu funkcie. Dobrý kompilátor dokáže z takejto rekurzívnej funkcie vytvoriť nerekurzívnu.
A Fibonacci, ten sa predsa volá dve krát? Áno, ale iba ak je program napísaný neefektívne. Ak napíšeme program podľa uvedeného predpisu a pokúsime sa funkciu volať s rôznymi parametrami, tak čoskoro zistíme, že takto definovaná funkcia počíta celkom pomaly. Prečo? Jednotlivé hodnoty Fibonacciho čísel počítame totiž viackrát (čím menšie číslo, tým viackrát je spočítané). To sa dá napraviť celkom jednoducho použitím takzvaného akumulátora. Akumulátor je dodatočný parameter, v ktorom si predávame stav výpočtu. Konkrétne pri efektívnejšom počítaní Fibonacciho čísel zdola nahor si v akumulátore budeme odkladať posledné dve napočítané čísla. V podstate takto budeme napodobňovať to, ako by ste si napočítali konkrétne Fibonacciho číslo v hlave. Začnete od dvoch jednotiek a postupne si dopočítate ďalšie až po číslo, ktoré ste potrebovali.
int fib1(int a, int b, int n) { if (n == 0) return a; else return fib1(b,a+b,n-1); } int fib(int n){ fib1(1,1,n); }
V parametroch a a b si pamätáme dve susedné čísla a v parametri n si pamätáme, koľko rekurzívnych volaní ešte chceme urobiť. Takže takto naprogramovaná Fibonacciho funkcia je nielen rýchla, ale aj kopíruje spôsob nášho uvažovania, a preto je zrozumiteľnejšia. Navyše používa iba jedno rekurzívne volanie.
Prednáška 10
Opakovanie rekurzie
- Rekurentná definícia: určitý objekt definujeme pomocou menších objektov toho istého typu
- Napr. Fibonacciho čísla F(n) = F(n-1) + F(n-2)
- Napr. fraktál stupňa n ako kompozícia fraktálov stupňa n-1
- Nezabudnime na triviálne prípady, napr. F(0)=F(1)=1, fraktál stupňa 0
- Rekurentné definície vieme často priamočiaro zapísať do rekurzívnych funkcií (aj keď môžu byť pomalé)
int fib(int n) { if (n<2) return 1; else return fib(n-1) + fib(n-2); }
- V rekurzívnej funkcii riešime problém pomocou menších podproblémov toho istého typu
- Napríklad aby sme našli číslo x v utriedenom poli medzi indexami l a r, potrebujeme ho porovnať so stredným prvkom tohoto intervalu a potom riešiť tú istú úlohu pre menší interval
- Aj keď sme pôvodne chceli hľadať prvok v celom poli, úlohu rozšírime o parametre l a r, aby sa dala spraviť rekurzia
bool binSearch(int x, int l, int r, int A[]){ if (l==r) return (A[l]==x); if (x<=A[(l+r)/2]) return binSearch(x,l,(l+r)/2,A); else return binSearch(x,(l+r)/2+1,r,A); }
- Druhý pohľad na rekurziu je dynamický: môžeme simulovať, čo sa v programe deje so zásobníkom
- Na zásobníku ukladáme parametre, lokálne premenné, kde v kóde sme skončili
- Skúsme napríklad odsimulovať, čo sa deje ak vo funkcii main zavoláme fib(3)
- Kvôli prehľadnosti si fib rozpíšeme na viac riadkov:
#include <iostream> using namespace std; int fib(int n) { if (n < 2) return 1; else { int a = fib(n - 1); // riadok (A) int b = fib(n - 2); // riadok (B) return a+b; } } int main(void) { int x = fib(3); // riadok (C) cout << x << endl; }
Tu je priebeh programu (obsah zásobníka)
(1) (2) (3) fib n=2 fib n=3 fib n=3, a=?, b=?, riadok A main, x=? main, x=?, riadok C main, x=?, riadok C (4) (5) fib n=1 fib n=2, a=?, b=?, riadok A fib n=2, a=1, b=?, riadok A fib n=3, a=?, b=?, riadok A fib n=3, a=?, b=?, riadok A main, x=?, riadok C main, x=?, riadok C (6) (7) fib n=0 fib n=2, a=1, b=?, riadok B fib n=2, a=1, b=1, riadok B fib n=3, a=?, b=?, riadok A fib n=3, a=?, b=?, riadok A main, x=?, riadok C main, x=?, riadok C (8) (9) fib n=1 fib n=3, a=2, b=?, riadok A fib n=3, a=2, b=?, riadok B main, x=?, riadok C main, x=?, riadok C (10) (11) fib n=3, a=2, b=1, riadok B main, x=?, riadok C main, x=3, riadok C
Efektívnejší výpočet Fibonacciho čísel
Priamočiary rekurzívny zápis výpočtu Fibonacciho čísel je neefektívny, lebo výpočet Fibonacciho čísel sa opakuje
- Napr. pre n=4 počítame fib(2) dvakrát, pre n=6 päťkrát a pre n=20 až 4181-krát
Spomeňme si na zápis výpočtu bez rekurzie, s dvomi premennými:
- F(n) spočíta v čase O(n)
int fibonacci(int n) { int f = 1; // Cislo F(i) int oldF = 0; // Cislo F(i-1) for (int i = 2; i <= n; i++) { int newF = f + oldF; // spocitaj nove F(i) pre vyssie i oldF = f; // poposuvaj hodnoty f = newF; } return f; }
Prepíšeme ho na rekurziu:
int fib1(int a, int b, int i, int n) { /* a je F(i-1), b je F(i), spočítaj F(n), kde n>=i */ if (n == i) return b; else return fib1(b, a+b, i+1, n); } int fib(int n){ return fib1(1, 1, 1, n); }
Namiesto dvoch premenných i a n si môžeme pamätať len ich rozdiel k=n-i
- hodnota k nám vraví, koľkokrát máme ešte sčitovať dve posledné čísla
int fib1(int a, int b, int k) { /* a je F(i-1), b je F(i), spočítaj F(i+k) */ if (k == 0) return b; else return fib1(b,a+b,k-1); } int fib(int n){ fib1(1,1,n-1); }
Táto rekurzívna funkcia pracuje v čase O(n), rovnako ako verzia s cyklom.
Vypisovanie variácií s opakovaním
Vypíšte všetky trojice cifier, pričom každá cifra je z množiny {0..n-1} a cifry sa môžu opakovať (variácie 3-tej triedy z n prvkov). Napr. pre n=2:
000 001 010 011 100 101 110 111
Veľmi jednoduchý program s troma cyklami:
#include <iostream> using namespace std; int main(void) { int n; cin >> n; for(int i=0; i<n; i++) { for(int j=0; j<n; j++) { for(int k=0; k<n; k++) { cout << i << j << k << endl; } } } }
Rekurzívne riešenie pre všeobecné k
Čo ak chceme k-tice pre všeobecné k? Využijeme rekurziu.
- Variácie k-tej triedy vieme rozdeliť na n skupín podľa prvého prvku:
- tie čo začínajú na 0, tie čo začínajú na 1, ..., tie čo začínajú na n-1.
- V každej skupine ak odoberieme prvý prvok, dostaneme variácie triedy k-1
#include <iostream> using namespace std; void vypis(int a[], int k) { for (int i = 0; i < k; i++) { cout << a[i]; } cout << endl; } void generuj(int a[], int i, int k, int n) { /* v poli a dlzky k mame prvych i cifier, * chceme vygenerovat vsetky moznosti * poslednych k-i cifier */ if (i == k) { vypis(a, k); } else { for (int x = 0; x < n; x++) { a[i] = x; generuj(a, i + 1, k, n); } } } int main(void) { const int maxK = 100; int a[maxK]; int k, n; cin >> k >> n; cout << "Zadajte k a n: "; generuj(a, 0, k, n); }
Ďalšie rozšírenia
- Čo ak chceme všetky k-tice písmen A-Z?
- Čo ak chceme všetky DNA reťazce dĺžky k (DNA pozostáva z "písmen" A,C,G,T)?
// pouzi n=26 void vypis(int a[], int k) { for (int i = 0; i < k; i++) { char c = 'A'+a[i]; cout << c; } cout << endl; } // pouzi n=4 void vypis(int a[], int k) { char abeceda[5] = "ACGT"; for (int i = 0; i < k; i++) { cout << abeceda[a[i]]; } cout << endl; }
Cvičenia
- Ako by sme vypisovali všetky k-ciferné hexadecimálne čísla (šestnástková sústava), kde používame cifry 0-9 a písmená A-F?
- Ako by sme vypisovali všetky k-tice písmen v opačnom poradí, od ZZZ po AAA?
Variácie bez opakovania
Teraz chceme vypísať všetky k-tice cifier z množiny {0,..,n-1}, v ktorých sa žiaden prvok neopakuje (pre k=n dostávame permutácie)
Príklad pre k=3, n=3
012 021 102 120 201 210
Skúšanie všetkých možností
- Jednoduchá možnosť: použijeme predchádzajúci program a pred výpisom skontrolujeme, či je riešenie správne
Prvý pokus:
bool spravne(int a[], int k, int n) { /* je v poli a dlzky k kazde cislo od 0 po n-1 najviac raz? */ bool bolo[maxN]; for (int i = 0; i < n; i++) { bolo[i] = false; } for (int i = 0; i < k; i++) { if (bolo[a[i]]) return false; bolo[a[i]] = true; } return true; } void generuj(int a[], int i, int k, int n) { /* v poli a dlzky k mame prvych i cifier, * chceme vygenerovat vsetky moznosti * poslednych k-i cifier */ if (i == k) { if (spravne(a, k, n)) { vypis(a, k); } } else { for (int x = 0; x < n; x++) { a[i] = x; generuj(a, i + 1, k, n); } } }
Cvičenie: ako by sme napísali kontrolu, ak by sme nepoznali n?
Prehľadávanie s návratom, backtracking
- Predchádzajúce riešenie je neefektívne, lebo prechádza cez všetky variácie s opakovaním a veľa z nich zahodí.
- Napríklad pre k=7 a n=10 pozeráme Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 10^7} variácií s opakovaním, ale iba 604800 z nich je správnych, čo je asi 6%
- Len čo sa v poli a vyskytne opakujúca sa cifra, chceme túto vetvu prehľadávania ukončiť, lebo doplnením ďalších cifier problém neodstránime
- Spravíme funkciu moze(a,i,x), ktorá určí, či je možné na miesto i v poli a dať cifru x
- Testovanie správnosti vo funkcii generuj sa dá vynechať
bool moze(int a[], int i, int x) { /* Mozeme dat hodnotu x na poziciu i v poli a? * Mozeme, ak sa nevyskytuje v a[0..i-1] */ for (int j = 0; j < i; j++) { if (a[j] == x) return false; } return true; } void generuj(int a[], int i, int k, int n) { /* v poli a dlzky k mame prvych i cifier, * chceme vygenerovat vsetky moznosti * poslednych k-i cifier */ if (i == k) { vypis(a, k); } else { for (int x = 0; x < n; x++) { if (moze(a, i, x)) { a[i] = x; generuj(a, i + 1, k, n); } } } }
Možné zrýchlenie: vytvoríme si trvalé pole bolo, v ktorom bude zaznamené, ktoré cifry sa už vyskytli a to použijeme vo funkcii moze.
- Po návrate z rekurzie nesmieme zabudúť príslušnú hodnotu odznačiť!
void generuj(int a[], bool bolo[], int i, int k, int n) { /* v poli a dlzky k mame prvych i cifier, * v poli bolo mame zaznamenane, ktore cifry su uz pouzite, * chceme vygenerovat vsetky moznosti * poslednych k-i cifier */ if (i == k) { vypis(a, k); } else { for (int x = 0; x < n; x++) { if (!bolo[x]) { a[i] = x; bolo[x] = true; generuj(a, bolo, i + 1, k, n); bolo[x] = false; } } } } int main(void) { const int maxK = 100; const int maxN = 100; int a[maxK]; bool bolo[maxN]; int k, n; cout << "Zadajte k a n (k<=n): "; cin >> k >> n; for (int i = 0; i < n; i++) { bolo[i] = false; } generuj(a, bolo, 0, k, n); }
Cvičenia: ako potrebujeme zmeniť program, aby sme generovali všetky postupnosti k cifier z množiny {0,..,n-1}, také, že:
- z každej cifry sú v postupnosti najviac 2 výskyty?
- žiadne dve po sebe idúce cifry nie sú rovnaké?
- súčet cifier je aspoň S?
Technika rekurzívneho prehľadávania všetkých možností s orezávaním beznádejných vetiev sa nazýva prehľadávanie s návratom alebo backtracking.
- Hľadáme všetky postupnosti, ktoré spĺňajú nejaké podmienky
- Vo všeobecnosti nemusia byť rovnako dlhé
- Ak máme celú postupnosť, vieme otestovať, či spĺňa podmienku (funkcia spravne)
- Ak máme časť postupnosti a nový prvok, vieme otestovať, či po pridaní tohto prvku má ešte šancu tvoriť časť riešenia (funkcia moze)
- Funkcia moze nesmie vrátiť false, ak ešte je možné riešenie
- Môže vrátiť true, ak už nie je možné riešenie, ale nevie to ešte odhaliť
- Snažíme sa však odhaliť problém čím skôr
Všeobecná schéma
void generuj(int a[], int i) { /* v poli a dlzky k mame prvych i cisel z riesenia */ if (spravne(a, i)) { /* ak uz mame cele riesenie, vypisme ho */ vypis(a, i); } else { pre vsetky hodnoty x { if (moze(a,i,x) { a[i] = x; generuj(a, i + 1); } } } }
Prehľadávanie s návratom môže byť vo všeobecnosti veľmi pomalé, čas výpočtu exponenciálne rastie.
Problém 8 dám
Cieľom je rozmiestniť n dám na šachovnici nxn tak, aby sa žiadne dve navzájom neohrozovali, tj. aby žiadne dve neboli v rovnakom riadku, stĺpci, ani na rovnakej uhlopriečke.
Príklad pre n=4:
. * . . . . . * * . . . . . * .
- V každom riadku bude práve jedna dáma, teda môžeme si riešenie reprezetovať ako pole damy dĺžky n, kde damy[i] je stĺpec, v ktorom je dáma na riadku i
- Podobne ako v predchádzajúcom príklade chceme do poľa dať čísla od 1 po n, aby spĺňali ďalšie podmienky (v každom stĺpci a na každej uhlopriečke najviac 1 dáma)
- Vytvoríme si polia, kde si budeme pamätať pre každý stĺpec a uhlopriečku, či už je obsadený
- Uhlopriečky v oboch smeroch očísľujeme číslami od 0 po 2n-2
- V jednom smere majú miesta na uhlopriečke rovnaký súčet, ten teda bude číslom uhlopriečky
- V druhom smere majú rovnaký rozdiel, ten však môže byť aj záporný, pričítame n-1
- Pre jednoduchosť použijeme globálne premenné, lebo potrebujeme veľa polí
- Globálne premenné spôsobujú problémy vo väčších programoch: mená premenných sa môžu "biť", môžeme si omylom prepísať číslo dôležité v inej časti programu
- Mohli by sme si tiež spraviť struct obsahujúci všetky premenné potrebné premenné v rekurzii a odovzdávať si ten
#include <iostream> using namespace std; /* globalne premenne */ const int maxN = 100; int n; int damy[maxN]; /* pole ktore obsahuje stlpec s damou v riadku i*/ bool bolStlpec[maxN]; /* pole ktore obsahuje true ak stlpec obsadeny damou */ bool bolaUhl1[2 * maxN - 1]; /* polia ktore obsahuju true ak uhlopriecky obsadene */ bool bolaUhl2[2 * maxN - 1]; int pocet; /* pocet najdenych rieseni */ int uhl1(int i, int j) { /* na ktorej uhlopriecke je riadok i, stlpec j v smere 1? */ return i + j; } int uhl2(int i, int j) { /* na ktorej uhlopriecke je riadok i, stlpec j v smere 2? */ return n - 1 + i - j; } void vypis() { /* vypis sachovnicu textovo a zvys pocitadlo rieseni */ pocet++; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { if (damy[i] == j) cout << " *"; else cout << " ."; } cout << endl; } cout << endl; } void generuj(int i) { /* v poli damy mame prvych i dam, dopln dalsie */ if (i == n) { vypis(); } else { for (int j = 0; j < n; j++) { /* skus dat damu na riadok i, stlpec j */ if (!bolStlpec[j] && !bolaUhl1[uhl1(i, j)] && !bolaUhl2[uhl2(i, j)]) { damy[i] = j; bolStlpec[j] = true; bolaUhl1[uhl1(i, j)] = true; bolaUhl2[uhl2(i, j)] = true; generuj(i + 1); bolStlpec[j] = false; bolaUhl1[uhl1(i, j)] = false; bolaUhl2[uhl2(i, j)] = false; } } } } int main(void) { cout << "Zadajte velkost sachovnice: "; cin >> n; for (int i = 0; i < n; i++) { bolStlpec[i] = false; } for (int i = 0; i < 2 * n + 1; i++) { bolaUhl1[i] = false; bolaUhl2[i] = false; } /* rekuzia */ pocet=0; generuj(0); cout << "Pocet rieseni: " << pocet << endl; }
Generovanie všetkých podmnožín
Chceme vypísať všetky podmnožiny množiny {0,..,m-1}. Na rozdiel od variácií nám v podmnožine nezáleží na poradí (napr. {0,1} = {1,0}), prvky teda budeme vždy vypisovať od najmenšieho po najväčší. Napr. pre m=2 máme podmnožiny
{} {0} {0,1} {1}
Podmnožinu vieme vyjadriť ako binárne pole dĺžky m, kde a[i]=0 znamená, že i nepatrí do množiny a a[i]=1 znamená, že patrí. Teda môžeme použiť predchádzajúci program pre n=2,k=m a zmeniť iba výpis:
void vypis(int a[], int m) { cout << "{"; char oddelovac[2] = ""; for (int i = 0; i < m; i++) { if (a[i] == 1) { cout << oddelovac; strcpy(oddelovac, ","); cout << i; } } cout << "}" << endl; }
- V premennej oddeľovač si pamätáme, akým reťazcom máme oddeliť ďalšie vypisované číslo od predchádzajúceho.
- Ak ešte žiadne nebolo, oddeľovač je prázdny reťazec.
- Ak už sme niečo vypísali, oddeľovač je čiarka.
Namiesto poľa intov môžeme použiť pole boolovských hodnôt a celý program trochu prispôsobiť tomu, že generujeme podmnožiny:
#include <iostream> #include <cstring> using namespace std; void vypis(bool a[], int m) { cout << "{"; char oddelovac[2] = ""; for (int i = 0; i < m; i++) { if (a[i]) { cout << oddelovac; strcpy(oddelovac, ","); cout << i; } } cout << "}" << endl; } void generuj(bool a[], int i, int m) { /* v poli a dlzky k mame rozhodnutie o prvych i * prvkoch, chceme vygenerovat vsetky podmnoziny * prvkov {i..m-1} */ if (i == m) { vypis(a, m); } else { a[i] = true; generuj(a, i + 1, m); a[i] = false; generuj(a, i + 1, m); } } int main(void) { const int maxM = 100; int m; cin >> m; bool a[maxM]; generuj(a, 0, m); }
Pre n=3 program vypíše:
{0,1,2} {0,1} {0,2} {0} {1,2} {1} {2} {}
Cvičenie: Čo by vypísal, ak by sme prehodili true a false v rekurzii?
Problém batoha, Knapsack problem
Zlodej sa vlúpal do obchodu a vidí n vecí, pričom pre každú z nich vie odhadnúť jej hmostnosť a cenu, za ktorú by ju vedel predať. V svojom batohu však vie odniesť len veci s celkovou hmotnosťou najviac W kilogramov. Ako má vybrať veci, aby mali čo najväčšiu cenu a aby ich celková hmostnosť neprekročila W?
Príklad: majme n=3 veci, pričom vec 0 má hmostnoť 10 a cenu 6, vec 1 má hmotnosť 8 a cenu 4 a vec 2 má hmotnosť 6 a cenu 3. Zlodej unesie najviac 15. Na vstupe to zapíšeme takto:
Zadaj pocet predmetov: 3 Zadaj hmotnost a cenu 0-teho predmetu: 10 6 Zadaj hmotnost a cenu 1-teho predmetu: 8 4 Zadaj hmotnost a cenu 2-teho predmetu: 6 3 Zadaj nosnost batoha: 15 Zober predmety 1, 2. Ich cena je 7.
Najlepšie je zobrať veci 1 a 2. Ich cena je 7 a súčet hmotností 14.
Tento problém ešte stretnete v ďalších ročníkoch štúdia, teraz si ukážeme jednoduchý program, ktorý prehľadáva všetky možnosti.
Jednoduché riešenie: pozeráme všetky podmnožiny
Ako predtým, generujeme všetky podmnožiny a pre každú spočítame, či jej hmotnosť nepresahuje nosnosť batoha. Podmnožiny však nevypisujeme, ale porovnávame s najlepšou nájdenou doteraz.
#include <iostream> #include <cstring> using namespace std; /* struktura na ukladanie udajov o jednej veci */ struct vec { int hmotnost; int cena; }; const int maxN = 100; /* maximalny pocet veci */ /* globalne premenne pouzivane v rekurzii */ int n; /* celkovy pocet veci v obchode */ vec a[maxN]; /* pole veci */ int maxCena; /* najlepsie doteraz najdene riesenie */ bool maxZober[maxN]; /* ktore veci su v najlepsom rieseni */ int nosnost; /* kolko unesie batoh */ /* spocitaj sucet hmotnosti vybranych predmetov */ int sucetHmotnosti(bool zober[]) { int sucet = 0; for (int i = 0; i < n; i++) { if(zober[i]) sucet += a[i].hmotnost; } return sucet; } /* spocitaj sucet cien vybranych predmetov */ int sucetCien(bool zober[]) { int sucet = 0; for (int i = 0; i < n; i++) { if(zober[i]) sucet += a[i].cena; } return sucet; } /* vypis zoznam vybranych predmetov */ void vypis(bool zober[]) { cout << "Zober predmety "; char oddelovac[2] = ""; for (int i = 0; i < n; i++) { if (zober[i]) { cout << oddelovac; strcpy(oddelovac, ","); cout << i; } } cout << ". Ich cena je " << sucetCien(zober) << "." << endl; } void generuj(bool zober[], int i) { /* v poli a dlzky k mame rozhodnutie o prvych i * prvkoch, chceme vygenerovat vsetky podmnoziny * prvkov {i..n-1} a kazdu skontrolovat a porovnat s maximom */ if (i == n) { /* uz sme sa rozhodli o kazdom prvku. Zistime, ci mame hmostnost * vybranych predmetov <= nosnost */ if(sucetHmotnosti(zober)<=nosnost) { /* ak ano, zistime, ci cena vybranych predmetov * je viac ako doteraz najlepsie maximum */ int cena = sucetCien(zober); if(cena>maxCena) { /* prekopiruj sucasny vyber do najlepsieho */ maxCena = cena; for(int i=0; i<n; i++) { maxZober[i] = zober[i]; } } } } else { /* dosad true aj false na miesto i * a skusaj vsetky moznosti pre zvysok pola */ zober[i] = true; generuj(zober, i+1); zober[i] = false; generuj(zober, i+1); } } int main(void) { cout << "Zadaj pocet predmetov: "; cin >> n; /* nacitame hmotnost a cenu predmetov */ for(int i=0; i<n; i++) { cout << "Zadaj hmotnost a cenu " << i << "-teho predmetu: "; cin >> a[i].hmotnost >> a[i].cena; } /* nacitame nostnost */ cout << "Zadaj nosnost batoha: "; cin >> nosnost; bool zober[maxN]; maxCena = -1; /* doteraz najlepsie riesenie ma cenu -1 */ generuj(zober, 0); /* prehladavaj vsetky moznosti */ vypis(maxZober); /* vypis najlepsie najdene riesenie */ }
Trochu rýchlejší program: skončíme vždy keď prekročíme nosnosť
Keď už sme sa rozhodli o prvých i veciach, sčítame hmotnosť tých, čo sme vybrali, a ak prekračuje nosnosť, túto vetvu hľadania ukončíme - nemá zmysel dopĺňať ďalšie hodnoty do zvyšku poľa, ak už zvolené veci sú príliš ťažké.
/* spocitaj sucet hmotnosti vybranych predmetov, * ale uvazujme iba prvych k predmetov */ int sucetHmotnosti(bool zober[], int k) { int sucet = 0; for (int i = 0; i < k; i++) { if(zober[i]) sucet += a[i].hmotnost; } return sucet; } void generuj(bool zober[], int i) { /* v poli a dlzky k mame rozhodnutie o prvych i * prvkoch, chceme vygenerovat vsetky podmnoziny * prvkov {i..n-1} a kazdu skontrolovat a porovnat s maximom */ /* ak uz sme prekrocili nosnost, nemusime pokracovat v hladani */ if(sucetHmotnosti(zober, i) > nosnost) return; if (i == n) { /* uz sme sa rozhodli o kazdom prvku. * Sucasne vieme, ze hmostnost * vybranych predmetov <= nosnost. * Zistime teda, ci cena vybranych predmetov * je viac ako doteraz najlepsie maximum */ int cena = sucetCien(zober); if (cena > maxCena) { /* prekopiruj sucasny vyber do najlepsieho */ maxCena = cena; for (int i = 0; i < n; i++) { maxZober[i] = zober[i]; } } } else { /* dosad true aj false na miesto i * a skusaj vsetky moznosti pre zvysok pola */ zober[i] = true; generuj(zober, i + 1); zober[i] = false; generuj(zober, i + 1); } }
Ešte rýchlejší program: neprepočítavame nosnosť a cenu vždy znovu a znovu
Predchádzajúci program vždy znovu a znovu prepočítava hmotnosť a cenu, aj keď sa zoznam vybraných predmetov zmení iba trochu. Namiesto toho si môžeme v rekurzii udržiavať aktuálnu hmotnosť aj cenu doteraz vybraných predmetov.
void generuj(bool zober[], int i, int hmotnost, int cena) { /* v poli a dlzky k mame rozhodnutie o prvych i * prvkoch, hmotnost je sucet hmotnosti uz vybranych predmetov * a cena je sucet ich cien. * Chceme vygenerovat vsetky podmnoziny * prvkov {i..n-1} a kazdu skontrolovat a porovnat s maximom */ /* ak uz sme prekrocili nosnost, nemusime pokracovat v hladani */ if(hmotnost > nosnost) return; if (i == n) { /* uz sme sa rozhodli o kazdom prvku. * Sucasne vieme, ze hmostnost * vybranych predmetov <= nosnost. * Zistime teda, ci cena vybranych predmetov * je viac ako doteraz najlepsie maximum */ if (cena > maxCena) { /* prekopiruj sucasny vyber do najlepsieho */ maxCena = cena; for (int i = 0; i < n; i++) { maxZober[i] = zober[i]; } } } else { /* dosad true aj false na miesto i * a skusaj vsetky moznosti pre zvysok pola */ zober[i] = true; generuj(zober, i + 1, hmotnost + a[i].hmotnost, cena + a[i].cena); zober[i] = false; generuj(zober, i + 1, hmotnost, cena); } }
- V main zavoláme generuj(zober, 0, 0, 0);
- Prečo sme nastavili cenu aj hmotnost na 0?
Cvičenia 5
Funkcie zo string.h
Naprogramujte si vlastné verzie funkcií z knižnice cstring:
- myStrCat(kam, co): za koniec reťazca kam pridá reťazec co (pole kam musí byť dosť dlhé)
- myStrCmp(retazec1, retazec2): vráti nulu ak sa reťazce rovnajú, kladné číslo keď je prvý neskôr v abecednom poradí, záporné číslo ak je skôr. Pozor, to či je skôr alebo neskôr sa berie podľa kódov znakov, takže napr "Z" je skôr ako "a".
Použitie strcmp:
- Načítajte od užívateľa postupne 5 slov a vypíšte z nich to, ktoré je prvé v abecednom poradí. Na porovnávajte reťazcov použite strcmp (alebo myStrCmp). Použite iba dve polia char-ov, v jednom budete mať práve načítané slovo, v druhom doteraz najmenšie nájdené.
Práca s reťazcami
- Upravte reťazec tak, aby začiatočné písmeno každého slova bolo veľké (môžete použiť funkciu toupper z knižnice cctype).
- Upravte načítané slovo nasledovne: Prvý a posledný znak slova necháme, ostatné náhodne poprehadzujeme.
- Vypíšte používateľovi takto upravené slovo a dajte mu hádať aké slovo ste pôvodne mali.
Jednoduchá kalkulačka
- Napíšte program, ktorý načíta dve čísla a ponúkne "Menu" operácií, ktoré s nimi môže vykonať (plus, mínus, krát, deleno). Na základe znaku, ktorý používateľ zadal, vypíše výsledok.
- Rozšírte program tak, aby sa vždy po skončení pýtal, či ešte chce používateľ ďalej pokračovať.
Veľké čísla
Vytvorte program pre prácu s dlhými číslami. Čísla si reprezentujte v poli celých čísel, ktoré zodpovedá desiatkovému zápisu veľkého čísla.
- Vytvorte funkciu pre načítanie takéhoto čísla. Funkcia prečíta reťazec znakov a uloží ho do poľa reprezentujúceho toto číslo.
- Vytvorte funkciu pre vypísanie takéhoto čísla. Funkcia vypíše reťazec znakov na základe obsahu poľa.
- Vytvorte funkciu pre sčítanie dvoch takto reprezentovaných čísel. Výsledkom je tretie pole, ktoré reprezentuje výsledok sčítania.
Zmeny programov z prednášky
V programoch z prednášky 8 spravte nasledujúce zmeny:
- Funkciu find na hľadanie vzorky v texte prerobte tak, aby našla všetky výskyty, vrátila ich pozície v poli a vrátila ich počet ako návratovú hodnotu
- Funkciu formatInt na formátovanie čísla na určitú šírku stĺpca prerobte tak, aby nepoužívala pomocné pole B, ale všetko robila priamo v poli A
DÚ4
Odovzdávanie DÚ4 max. 10 bodov plus 5 bodov bonus, termín odovzdania pondelok 22.10. o 22:00
Napíšte program, ktorý animuje bublinkové triedenie, ktoré sme preberali na prednáške 6 pomocou grafickej knižnice SimpleDraw. Vaša animácia by mala vyzerať ako príklad na obrázku vpravo. Na začiatku každého prechodu poľom zobrazte všetky prvky v poli ako čierne paličky. Keď algoritmus porovnáva dve susedné hodnoty v poli, zobrazte pole tak, aby porovnávané prvky boli vyznačené červenou.
Základná verzia programu:
- Pred každým vykreslením poľa môžete zmazať obrazovkou príkazom window.clear() a vykresľovať pole odznovu.
- Po každom vykreslení poľa čakajte určitý počet sekúnd príkazom window.wait(time);
- V programe si definujte nasledujúce konštanty, ktorými určíte parametre obrázku:
/* veľkosť medzery medzi paličkami a * veľkosť okraja okolo obrázku */ const int gap = 10; /* šírka paličky */ const int width = 10; /* výška jedného dieliku paličky, t.j. napr. palička pre hodnotu 8 * bude výšky 8*height */ const int height = 10; /* maximálna povolená hodnota v triedenom poli */ const int maxValue = 10; /* dĺžka čakania po každom zobrazení poľa */ const double wait = 1; /* maximálny povolený počet hodnôt v poli resp. počet paličiek */ const int maxN = 5;
- Konštanty môžete mať zadefinované globálne na vrchu programu, aby ste ich mohli používať vo všetkých funkciách. Potrebné rozmery obrázku a súradnice paličiek spočítajte z týchto hodnôt.
- Pole nenačítavajte od užívateľa, inicializujte ho n hodnotami priamo v programe.
- V poli budú iba kladné celé čísla medzi 1 a maxValue a ich počet bude najviac maxN.
- Dbajte na prehľadný štýl programu (členenie na funkcie, pomenovanie funkcií a premenných, komentáre, formátovanie)
Bonusové úlohy
- Prepíšte program tak, aby nevolal funkciu window.clear(), ale aby podľa potreby zmazal iba tie paličky, ktorým treba zmeniť farbu alebo výšku (zoznam id jednotlivých vykreslených paličiek si musíte pamätať v nejakom poli)
- Ak sa budú dve porovnávané paličky vymieňať, naznačte to v obrázku obojstrannou šípkou v medzere medzi nimi.
Odovzdávajte len jeden súbor, ktorý môže obsahovať základnú verziu, alebo verziu rozšírenú aj o bonusy.
Pokročilá DÚ2
Odovzdávanie DÚ max. 20 bodov + 6 bodov bonus, termín odovzdania pondelok 29.10. o 22:00
Cieľom tejto domácej úlohy pre pokročilých je precvičiť si prácu s rekurziou a prehľadávanie s návratom (backtracking). Tieto témy budeme preberať v týždni od 15.10., ale môžete si o nich prečítať v prednáškach z minulého roku: [6], [7], [8] (najmä programy na riešenie Sudoku). Nezabudnite na pekný štýl programu a vyvarujte sa opisovania. V komentároch vysvetlite hlavné dátové štruktúry a funkcie programu. Dodržte formát vstupu a výstupu popísaný nižšie. Odovzdávajte jeden program, ktorý bude obsahovať hlavnú časť úlohy, prípadne aj rozšírenú o bonusovú časť.
Vašou úlohou bude napísať program, ktorý rieši hlavolam Kakuro. V tomto hlavolame máme danú hraciu plochu s n riadkami a m stĺpcami, pozostávajúcu z bielych a čiernych políčiek. Čierne políčka sú oddeľovače, podobne ako v klasických krížovkách. Rozdeľujú plochu na "slová": súvislé úseky bielych políčok v jednotlivých riadkoch a stĺpcoch. Do bielych políčok sa v tomto hlavolame ale namiesto písmen vpisujú cifry 1..9. Pre každé "slovo" máme v legende krížovky určené, aký majú mať cifry v tomto slove súčet. Navyše musí platiť, že v jedom slove sa žiadna cifra nesmie opakovať. Napríklad ak máme slovo dĺžky 3, ktoré má mať súčet 9, môžeme ho rozpísať napríklad ako 1+2+6, alebo 2+1+6, alebo 2+3+4 atď, ale nemôžeme použiť 1+7+1, lebo cifra 1 sa nesmie opakovať.
Napíšte program, ktorý načíta popis hlavolamu vo formáte popísanom nižšie a nájde a vypíše všetky riešenia. Hlavolam už môže mať niektoré políčka predvyplnené, ich hodnoty nemeňte. Hlavolam riešte jednoduchým prehľadávaním s návratom nasledovne: v každom kroku rekurzie nájdite prvé nevyplnené políčko na hracej ploche a skúste do neho postupne dosadiť všetky možné cifry 1..9. Potom rekurzívne prehľadajte možné dosadenia do zvyšných prázdnych políčok. Cifru však na aktuálne políčko dosaďte iba vtedy, ak nespôsobuje očividný konflikt s už vyplnenými políčkami, t.j. ak spĺňa nasledujúce pravidlá pre vodorovné aj zvislé slovo križujúce aktuálne políčko:
- práve dosadená cifra sa neopakuje medzi už vyplnenými hodnotami v slove
- ak by sme na zvyšné voľné miesta v slove dosadili najmenšie možné hodnoty 1,2,..., tak spolu s už dosadenými ciframi a aktuálnou cifrou dostaneme súčet neprevyšujúci cieľový súčet
- ak by sme na zvyšné voľné miesta v slove dosadili najväčšie možné hodnoty 9,8,..., tak spolu s už dosadenými ciframi a aktuálnou cifrou dostaneme súčet ktorý nie je menší ako cieľový súčet
Napríklad predpokladajte, že máme slovo dĺžky 6 s cieľovým súčtom 35, máme v ňom už dosadené čísla 1, 7 a skúšame všetky možnosti pre ďalšie políčko. Cifry 1 a 7 budú odmietnuté, lebo už boli v slove použité. Zvyšné tri cifry slova majú súčet aspoň 6 (1+2+3) a najviac 24 (9+8+7), teda aktuálne políčko musí byť medzi 35-1-7-24=3 a 35-1-7-6=21. Cifry 1 a 2 budú teda tiež odmietnuté kvôli tomu, že by sme už nemali šancu dosiahnuť cieľovú sumu. Skúšame teda dosadiť cifry 3,4,5,6,8 a 9. Všimnite si, že pre jednoduchosť predpokladáme, že zvyšné tri políčka môžu obsahovať najmenšie možné cifry 1,2,3 aj najväčšie možné cifry 9,8,7 bez ohľadu na to, či tieto cifry už boli v tomto alebo nejakom križujúcom slove použité.
Všimnite si, že ak dosadzujeme do nejakého slova poslednú cifru, tieto podmienky zabezpečia, že dostaneme správny súčet, lebo zvyšných políčok je 0 a teda ich najmenší aj najväčší súčet je 0.
Bonusová úloha: Pred začatím prehľadávania s návratom sa pokúste vylúčiť čo najviac možností. Pre každé políčko si pamätajte, ktoré cifry sa na ňom môžu nachádzať. Na začiatku sú to všetky cifry 1..9. Ak sú nejaké cifry predvyplnené, vylúčte ich zo všetkých políčok v pretínajúcich slovách. Potom prechádzajte jednotlivé slová, skúste pre dané slovo vygenerovať všetky možnosti ako ho doplniť pomocou zatiaľ povolených cifier a sledujte, ktoré cifry na ktorých pozíciách boli použité v aspoň jednom riešení pre toto slovo. Ostatné cifry vylúčte zo zoznamu možností. Ak zostane iba jedna cifra, dosaďte ju na políčko a vyškrtajte zo zoznamov pre ostatné políčka križujúcich slov. Tento proces opakujte, kým sa darí vylučovať ďalšie možnosti, lebo vylúčením nejakých cifier v jednom smere sa môže neskôr podariť vylúčiť ďalšie cifry v križujúcom smere. Na vygenerovanie všetkých možností pre jedno slovo použite jednoduchšiu verziu prehľadávania s návratom z hlavnej časti domácej úlohy.
Majme napríklad vodorovné slovo dĺžky 2 so súčtom 12 a zvislé slovo dĺžky 2 so súčtom 7, ktoré sa pretínajú svojimi prvými ciframi.
- Pre vodorovné slovo máme možnosti 3+9, 4+8, 5+7, 7+5, 8+4, 9+3. Zo zoznamov pre obidve políčka tohto slova teda môžeme vylúčiť cifry 1, 2 a 6.
- Pre zvislé slovo nám teraz zostávajú tieto možnosti: 3+4, 4+3, 5+2. Na prvom políčku teda zostávajú možné cifry 3,4,5, na druhom políčku máme možné cifry 2,3,4.
- Teraz sa môžeme napríklad vrátiť späť k vodorovnému slovu, kde už máme len možnosti 3+9, 4+8, 5+7. Na druhom políčku tohto slova nám teda zostávajú iba možné cifry 7,8,9, ale prvé políčko zostáva 3,4,5.
Keď už nie je možné vylúčiť žiadnu ďalšiu cifru zo žiadneho políčka, spustite prehľadávanie s návratom na celej ploche ako predtým, ale na každom políčku uvažujte len cifry, ktoré neboli vylúčené počas predspracovania.
Formát vstupu a výstupu
Popis hlavolamu načítajte zo súboru hlavolam.txt. Na prvom riadku tohto súboru sú čísla n a m oddelené medzerou, udávajúce počet riadkov a stĺpcov hracej plochy. Potom nasleduje hracia plocha, v ktorej je každé políčko reprezentované jedným znakom. Znak # znamená čierne políčko, znak . znamené biele políčko a cifra 1..9 znamená biele políčko predvyplnené s danou cifrou. V poslednej časti vstupného súboru je legenda. Každý riadok legendy pozostáva zo štyroch údajov oddelených medzerami: číslo riadku, číslo stĺpca, písmeno h alebo v a požadovaný súčet. Prvé dve čísla udávajú súradnice ľavého resp. horného konca slova, pričom riadky aj stĺpce plochy číslujeme od 0. Písmeno h zodpovedá vodorovnému (horizontálnemu) smeru slova a písmeno v zvislému (vertikálnemu) smeru. Jednotlivé slová hracej plochy sa v legende môžu vyskytovať v ľubovoľnom poradí, ale žiadne nie je vynechané, ani sa neopakuje. Môžete predpokladať, že súbor je v správnom formáte, hlavolam má aspoň jedno riešenie a n aj m sú naviac 50.
Výsledok vypíšte do súboru riesenia.txt. Vypíšte všetky riešenia hlavolamu, v ľubovoľnom poradí, každé práve raz. Použite formát ako v príklade (cifry v jednom riadku neoddeľujte medzerami, čierne políčka vypíšte ako #). Za každé riešenie vypíšte prázdny riadok.
Príklad vstupu:
3 5 ..#.. ...#. ..... 0 0 h 5 0 3 h 8 1 0 h 9 1 4 h 4 2 0 h 17 0 0 v 6 0 1 v 10 1 2 v 10 0 3 v 1 2 3 v 2 0 4 v 14
Príklad výstupu:
23#17 324#4 15623 32#17 216#4 17423 32#17 234#4 15623
Ak na vstupe predvyplníme vhodnú cifru, zostane nám iba jedno riešenie:
3 5 ..#.. ..6#. ..... 0 0 h 5 0 3 h 8 1 0 h 9 1 4 h 4 2 0 h 17 0 0 v 6 0 1 v 10 1 2 v 10 0 3 v 1 2 3 v 2 0 4 v 14
výstup:
32#17 216#4 17423
Prednáška 11
Opakovanie backtrackingu
- Na minulej prednáške sme používali backtracking (prehľadávanie s návratom). Metóda, ktorú sme videli sa dá zhrnúť nasledovne:
- V poli si budeme postupne generovať možnosti pre jednotlivé pozície (keď potrebujeme vygenerovať k prvkov a každý môže byť z n možností)
- Keď už budeme mať pole vyplnené (máme hodnotu pre každý prvok) skontrolujeme, či je možnosť korektná
- Ak si niekde pamätáme už použité prvky, nezabudneme ich pri vynáraní z rekurzie odznačiť
void generuj(int a[], int i, int k, int n) { /* v poli a dlzky k mame prvych i pozicii, * chceme vygenerovat vsetky moznosti * poslednych k-i pozicii */ if (i == k) { if (spravne(a, k, n)) { vypis(a, k); } } else { for (vsetky moznosti na dalsom mieste) { // pridaj moznost na i-tom mieste generuj(a, i + 1, k, n); // tu ak treba vráť všetko do pôvodného stavu } } }
Problém batoha, Knapsack problem
Zlodej sa vlúpal do obchodu a vidí n vecí, pričom pre každú z nich vie odhadnúť jej hmostnosť a cenu, za ktorú by ju vedel predať. V svojom batohu však vie odniesť len veci s celkovou hmotnosťou najviac W kilogramov. Ako má vybrať veci, aby mali čo najväčšiu cenu a aby ich celková hmostnosť neprekročila W?
Príklad: majme n=3 veci, pričom vec 0 má hmostnoť 10 a cenu 6, vec 1 má hmotnosť 8 a cenu 4 a vec 2 má hmotnosť 6 a cenu 3. Zlodej unesie najviac 15. Na vstupe to zapíšeme takto:
Zadaj pocet predmetov: 3 Zadaj hmotnost a cenu 0-teho predmetu: 10 6 Zadaj hmotnost a cenu 1-teho predmetu: 8 4 Zadaj hmotnost a cenu 2-teho predmetu: 6 3 Zadaj nosnost batoha: 15 Zober predmety 1, 2. Ich cena je 7.
Najlepšie je zobrať veci 1 a 2. Ich cena je 7 a súčet hmotností 14.
Tento problém ešte stretnete v ďalších ročníkoch štúdia, teraz si ukážeme jednoduchý program, ktorý prehľadáva všetky možnosti.
Jednoduché riešenie: pozeráme všetky podmnožiny
Ako predtým, generujeme všetky podmnožiny a pre každú spočítame, či jej hmotnosť nepresahuje nosnosť batoha. Podmnožiny však nevypisujeme, ale porovnávame s najlepšou nájdenou doteraz.
#include <iostream> #include <cstring> using namespace std; /* struktura na ukladanie udajov o jednej veci */ struct vec { int hmotnost; int cena; }; const int maxN = 100; /* maximalny pocet veci */ /* globalne premenne pouzivane v rekurzii */ int n; /* celkovy pocet veci v obchode */ vec a[maxN]; /* pole veci */ int maxCena; /* najlepsie doteraz najdene riesenie */ bool maxZober[maxN]; /* ktore veci su v najlepsom rieseni */ int nosnost; /* kolko unesie batoh */ /* spocitaj sucet hmotnosti vybranych predmetov */ int sucetHmotnosti(bool zober[]) { int sucet = 0; for (int i = 0; i < n; i++) { if(zober[i]) sucet += a[i].hmotnost; } return sucet; } /* spocitaj sucet cien vybranych predmetov */ int sucetCien(bool zober[]) { int sucet = 0; for (int i = 0; i < n; i++) { if(zober[i]) sucet += a[i].cena; } return sucet; } /* vypis zoznam vybranych predmetov */ void vypis(bool zober[]) { cout << "Zober predmety "; char oddelovac[2] = ""; for (int i = 0; i < n; i++) { if (zober[i]) { cout << oddelovac; strcpy(oddelovac, ","); cout << i; } } cout << ". Ich cena je " << sucetCien(zober) << "." << endl; } void generuj(bool zober[], int i) { /* v poli a dlzky k mame rozhodnutie o prvych i * prvkoch, chceme vygenerovat vsetky podmnoziny * prvkov {i..n-1} a kazdu skontrolovat a porovnat s maximom */ if (i == n) { /* uz sme sa rozhodli o kazdom prvku. Zistime, ci mame hmostnost * vybranych predmetov <= nosnost */ if(sucetHmotnosti(zober)<=nosnost) { /* ak ano, zistime, ci cena vybranych predmetov * je viac ako doteraz najlepsie maximum */ int cena = sucetCien(zober); if(cena>maxCena) { /* prekopiruj sucasny vyber do najlepsieho */ maxCena = cena; for(int i=0; i<n; i++) { maxZober[i] = zober[i]; } } } } else { /* dosad true aj false na miesto i * a skusaj vsetky moznosti pre zvysok pola */ zober[i] = true; generuj(zober, i+1); zober[i] = false; generuj(zober, i+1); } } int main(void) { cout << "Zadaj pocet predmetov: "; cin >> n; /* nacitame hmotnost a cenu predmetov */ for(int i=0; i<n; i++) { cout << "Zadaj hmotnost a cenu " << i << "-teho predmetu: "; cin >> a[i].hmotnost >> a[i].cena; } /* nacitame nostnost */ cout << "Zadaj nosnost batoha: "; cin >> nosnost; bool zober[maxN]; maxCena = -1; /* doteraz najlepsie riesenie ma cenu -1 */ generuj(zober, 0); /* prehladavaj vsetky moznosti */ vypis(maxZober); /* vypis najlepsie najdene riesenie */ }
Trochu rýchlejší program: skončíme vždy keď prekročíme nosnosť
Keď už sme sa rozhodli o prvých i veciach, sčítame hmotnosť tých, čo sme vybrali, a ak prekračuje nosnosť, túto vetvu hľadania ukončíme - nemá zmysel dopĺňať ďalšie hodnoty do zvyšku poľa, ak už zvolené veci sú príliš ťažké.
/* spocitaj sucet hmotnosti vybranych predmetov, * ale uvazujme iba prvych k predmetov */ int sucetHmotnosti(bool zober[], int k) { int sucet = 0; for (int i = 0; i < k; i++) { if(zober[i]) sucet += a[i].hmotnost; } return sucet; } void generuj(bool zober[], int i) { /* v poli a dlzky k mame rozhodnutie o prvych i * prvkoch, chceme vygenerovat vsetky podmnoziny * prvkov {i..n-1} a kazdu skontrolovat a porovnat s maximom */ /* ak uz sme prekrocili nosnost, nemusime pokracovat v hladani */ if(sucetHmotnosti(zober, i) > nosnost) return; if (i == n) { /* uz sme sa rozhodli o kazdom prvku. * Sucasne vieme, ze hmostnost * vybranych predmetov <= nosnost. * Zistime teda, ci cena vybranych predmetov * je viac ako doteraz najlepsie maximum */ int cena = sucetCien(zober); if (cena > maxCena) { /* prekopiruj sucasny vyber do najlepsieho */ maxCena = cena; for (int i = 0; i < n; i++) { maxZober[i] = zober[i]; } } } else { /* dosad true aj false na miesto i * a skusaj vsetky moznosti pre zvysok pola */ zober[i] = true; generuj(zober, i + 1); zober[i] = false; generuj(zober, i + 1); } }
Ešte rýchlejší program: neprepočítavame nosnosť a cenu vždy znovu a znovu
Predchádzajúci program vždy znovu a znovu prepočítava hmotnosť a cenu, aj keď sa zoznam vybraných predmetov zmení iba trochu. Namiesto toho si môžeme v rekurzii udržiavať aktuálnu hmotnosť aj cenu doteraz vybraných predmetov.
void generuj(bool zober[], int i, int hmotnost, int cena) { /* v poli a dlzky k mame rozhodnutie o prvych i * prvkoch, hmotnost je sucet hmotnosti uz vybranych predmetov * a cena je sucet ich cien. * Chceme vygenerovat vsetky podmnoziny * prvkov {i..n-1} a kazdu skontrolovat a porovnat s maximom */ /* ak uz sme prekrocili nosnost, nemusime pokracovat v hladani */ if(hmotnost > nosnost) return; if (i == n) { /* uz sme sa rozhodli o kazdom prvku. * Sucasne vieme, ze hmostnost * vybranych predmetov <= nosnost. * Zistime teda, ci cena vybranych predmetov * je viac ako doteraz najlepsie maximum */ if (cena > maxCena) { /* prekopiruj sucasny vyber do najlepsieho */ maxCena = cena; for (int i = 0; i < n; i++) { maxZober[i] = zober[i]; } } } else { /* dosad true aj false na miesto i * a skusaj vsetky moznosti pre zvysok pola */ zober[i] = true; generuj(zober, i + 1, hmotnost + a[i].hmotnost, cena + a[i].cena); zober[i] = false; generuj(zober, i + 1, hmotnost, cena); } }
- V main zavoláme generuj(zober, 0, 0, 0);
- Prečo sme nastavili cenu aj hmotnost na 0?
Rozdeľuj a panuj
Metóda Rozdeľuj a panuj je rekurzívna metóda, kde podproblémy rozdelíme, aby ich urobil niekto iný a my to iba spracujeme. Rekurzívne triedenia sú založené na tomto princípe. Tento spôsob všeobecne funguje nasledovne
- Rozdeľuj: Prvá fáza algoritmu je rozdelenie problému na nejaké menšie časti, ktoré sa dajú riešiť ďalej samostatne (teda by nemali mať prienik).
- Vyrieš podproblémy: Rekurzívne sa zavolám na podproblémy a keď dostanem ich výsledky, tak ..
- Panuj: Poslednou časťou je spojenie výsledkov do výsledku celkového problému.
MergeSort
V triedení zlučovaním sa pole veľkosti N rozdelí na polovicu najjednoduchším spôsobom - na prvú a druhú polovicu. Tieto rekurzívne utriedime, čím dostávame 2 utriedené postupnosti. Preto vo fáze panuj potrebujeme tieto dve polia zlúčiť (merge) do výsledného poľa.
int mergesort(int a[], int low, int high){ if (low>=high) return 0; // rozdeluj int mid=(low+high)/2; //rekurzivne volanie na dva podpripady mergesort(a,low,mid); mergesort(a,mid+1,high); //panuj return merge(a,low,high,mid); }
Zlučovanie utriedených podpolí
Zaujímavým problémom je zlúčenie dvoch utriedených postupností. Máme dve utriedené postupnosti A[0..N-1] a B[0..M-1].
- Je úplne jasné, že prvým prvkom výslednej postupnosti bude menší z prvkov A[0] a B[0].
Potom ostávajú postupnosti A[1..N-1] a B[0..M-1] alebo A[0..N-1] a B[1..M-1].
- Vo všeobecnosti máme teraz postupnosti A[i..N-1] a B[j..M-1]. Ďalším prvkom postupnosti bude buď A[i] alebo B[j] a ostanú nám postupnosti A[i+1..N-1] a B[j..M-1] alebo A[i..N-1] a B[j-1..M-1].
- Toto robíme dovtedy, kým s jedným poľom neskončíme. Vtedy na koniec dokopírujeme zyvšok druhého poľa.
Z toho dostávame nasledovný program.
void merge(int A[],int B[],int N, int M){ int i=0,j=0; int C[MAX]; while((i<N)&&(j<M)){ if(A[i]<=B[j]){ C[i+j]=A[i++]; // vysledok ukladame na (i+j)-te miesto } else{ C[i+j]=B[j++]; // vysledok ukladame na (i+j)-te miesto } } if (i<N){ // skoncilo pole B for(;i<N;i++){ C[i+j]=A[i]; } } else { // skoncilo pole A for(;j<M;j++){ C[i+j]=B[j]; } } }
Tento postup sa dá mierne upraviť, ak si uvedomíme, že vlastne vieme, ako dlho zapisujeme z jednej postupnosti (napríklad A). Je to do chvíle, kým jej prvý prvok nebude väčší, ako prvý prvok z postupnosti druhej (B).
void merge(int A[],int B[],int N, int M){ int i=0,j=0; int C[MAX]; while((i<N)&&(j<M)){ while ((A[i]<=B[j])&&(i<N)){ C[i+j]=A[i++]; } while (B[j]<=A[i]&&(j<M)){ C[i+j]=B[j++]; } } for(;i<N;i++){ // ktore pole skoncilo testovat netreba, lebo cyklus prinajhorsom neprebehne C[i+j]=A[i]; } for(;j<M;j++){ C[i+j]=B[j]; } }
Výsledný MergeSort
Ostáva už iba drobnosť. My nezlučujeme dve nezávislé polia ale prvky jedného poľa a navyše by sme radi, aby tie prvky v tomto poli aj skončili.
- Prvá časť sa bude riešiť jednoducho. Nepotrebujeme teda ako parameter dve polia ale iba jedno (A[]) ale zato potrebujeme miesta odkiaľ a pokiaľ sú jednotlivé úseky.
- Pre začiatok by sme teda mali parametre int A[], int zaciatok1, int koniec1, int zaciatok2, int koniec2.
- Avšak jediné úseky, ktoré zlučujeme sú úseky idúce za sebou, ktoré sme iba rozdelili na nejakom mieste - pôvodne sme mali interval (low, high) a my sme ho rozdelili na intervaly (low, mid) a (mid+1,high). Na identifikáciu takýchto úsekov potom stačia parametre low a high.
- Druhý problém vieme vyriešiť jednoducho - pomocné pole na konci nakopírujeme naspäť.
- A nič oveľa inteligentnejšie nebudeme robiť - zbytočne by sme si niečo prepísali - toto nie je rekurzívna fáza, tu sa to pole vždy umaže hned po využití.
#include<iostream> using namespace std; void merge(int A[],int low, int high){ int i=low, j=(high+low)/2+1; // indexy v poli A int k=0; // index v poli C int N=j, M=high+1; // zarazky indexov i a j int C[MAX]; while((i<N)&&(j<M)){ while ((A[i]<=A[j])&&(i<N)){ C[k++]=A[i++]; } while (A[j]<=A[i]&&(j<M)){ C[k++]=A[j++]; } } for(;i<N;i++){ // ktore pole skoncilo testovat netreba, lebo cyklus prinajhorsom neprebehne C[k++]=A[i]; } for(;j<M;j++){ C[k++]=A[j]; } for (int kk=low; kk<=high; kk++) A[kk]=C[kk-low]; } void mergesort(int A[], int low, int high){ if (low>=high) return; // rozdeluj int mid=(low+high)/2; //rekurzivne volanie na dva podpripady mergesort(A,low,mid); mergesort(A,mid+1,high); //panuj merge(A,low,high); } int main(void){ int A[]={135,1,58,75,12,45,7,100,23,467}; mergesort(A,0,9); for (int i=0; i<10; i++) cout<< A[i]<< " "; }
Ukážka na príklade
Pole A[]={135,1,58,75,12,45,7,100,23,467}
Merge (0,0,1): 135 1 -> 1 135 Merge (0,1,2): 1 135 58 -> 1 58 135 Merge (3,3,4): 75 12 -> 12 75 Merge (0,2,4): 1 58 135 12 75 -> 1 12 58 75 135 Merge (5,5,6): 45 7 -> 7 45 Merge (5,6,7): 7 45 100 -> 7 45 100 Merge (8,8,9): 23 467 -> 23 467 Merge (5,7,9): 7 45 100 23 467 -> 7 23 45 100 467 Merge (0,4,9): 1 12 58 75 135 7 23 45 100 467 -> 1 7 12 23 45 58 75 100 135 467
Quicksort
Quicksort je tiež založený na metóde rozdeľuj a panuj. Aby utriedil pole N prvkov, rozdelí si ich na menšie a väčšie prvky, ktoré potom utriedi. Štruktúra programu je nasledovná:
- Rozdeľuj: prvky rozdelí na dve skupiny (menšie a väčšie prvky). Ako uvidíme neskôr, čo sú väčšie a menšie prvky závisí na spracovávaných prvkoch. Celkovo môžeme povedať, že menšie prvky sú menšie ako väčšie prvky (logické, nie?)
- Rekurzívne sa zavolá na každú skupinu prvkov a dostáva dve utriedené postupnosti - utriedenú postupnosť menších prvkov a utriedenú postupnosť väčších prvkov.
- Panuj: Keďže menšie prvky sú všetky menšie ako prvky väčšie pole N prvkov je utriedené, ak dáme tieto dve postupnosti proste za seba, najskôr utriedené menšie prvky, potom utriedené väčšie prvky.
void quicksort(int A[], int l, int r){ if (l>=r) return; // rozdelenie pivot=divide(A, l, r); // rekurzivne volanie na mensie a vacsie prvky quicksort(A,l,pivot); quicksort(A,pivot+1,r); //zlucenie nebude treba - su spravne za sebou }
Jednoduché rozdelenie prvkov
Najprv si ukážeme jednoduchý spôsob, ako pole správne rozdeliť. Budeme si naozaj vytvárať 2 polia (Cmensie a Cvacsie), do ktorého prvky z poľa A (teda z jeho podpoľa A[l..r]) budeme rozdeľovať. Každé z týchto polí bude mať veľkosť najviac r-l.
Špeciálne si oddelíme pivot, aby sme si ho niekde neprepísali (mohli sme si vytvárať polia 3 - väčšie, menšie a rovné).
Následne do poľa A[l..r] nakopírujeme najskôr pole Cmensie, potom pivot (jeho pozíciu si zapamatáme) a nakoniec pole Cvacsie. Takto upravené pole a hodnotu na ktorej sa nachádza pivot môžeme vrátiť.
int divide(int A[], int l, int r){ int pivot=l; //alebo lubovolny iny prvok z intervalu int pivothodnota=A[pivot]; int Cmensie[MAX]; int Cvacsie[MAX]; int i1=0,i2=0; for (int i=l; i<=r; i++){ if (i==pivot) continue; else if (A[i]<=A[pivot]) Cmensie[i1++]=A[i]; else Cvacsie[i2++]=A[i]; } for (int i=0; i<i1; i++){ A[l+i]=Cmensie[i]; } pivot=l+i1; A[pivot]=pivothodnota; for (int i=0; i<i2; i++){ A[pivot+1+i]=Cvacsie[i]; } return pivot; // hodnota na ktorej je teraz realne pivot }
Pri takomto rozdeľovaní poľa by sme sa mohli rekurzívne volať iba na časti A[l..pivot-1] a A[pivot+1..r] resp. na ešte kratšie úseky ak by sme si pamätali aj prvky rovné pivotu.
Rozdelenie prvkov priamo v poli (inplace quicksort)
Rozdelenie prvkov na menšie a väčšie sa dá vykonávať aj priamo v poli - bez pomocných polí. Myšlienka je nasledovná:
- Zvolíme si hodnotu, na základe ktorej budeme prvky deliť.
- Zľava pozeráme na prvky v poli - ktoré môžu byť v tejto polovici (sú menšie ako pivot), tak tam necháme a keď narazíme na väčší (alebo rovný), zastavíme.
- Podobne sprava - ktoré môžu byť v tejto polovici (sú väčšie ako pivot), tak tam necháme a keď narazíme na menší (alebo rovný), zastavíme.
- V jednej chvíli sme zastavili z oboch krajov a máme dva prvky - jeden je menší a druhý väčší ako pivot. V prípade, že sú v tých nesprávnych poloviciach (teda ak ten väčší je naľavo od menšieho) tak ich vymeníme.
- V prípade, že sme našli prvky, ktoré však už sú v správnych poloviciach znamená to, že sa nám už naše dva indexy niekedy stretli. V tom pripade viem, že naľavo od j máme iste iba čísla menšie od pivota (lebo touto časťou už index i prechádzal) - podobne to platí aj napravo od i.
int divide(int A[], int l, int r){ int i=l, j=r; int pivothodnota=A[1]; while (i<j){ while (A[i]<pivothodnota) i++; while (A[j]>pivothodnota) j--; if (i<j) { int temp=A[i]; A[i]=A[j]; A[j]=temp; } } return j; }
Takto napísaná funkcia funguje iba pre rôzne čísla. Uvedomte si, že pri výmene dvoch rovnakých čísel (môže sa stať, ak sú vybraným pivotom) sa zacyklíme. Preto vo finálnej verzii upravíme rozdelenie tak, aby fungovalo aj pre opakované čísla.
Výsledný quicksort
int divide(int A[], int l, int r){ int v=A[r]; // zvolim si pivot a odlozim si ho na kraj (alebo rovno zvolim krajny prvok) int i=l-1, j=r; int temp; while (i<j){ while (A[++i]<v); while (A[--j]>v); if (i>=j) break; temp=A[i]; A[i]=A[j]; A[j]=temp; } temp=A[i]; A[i]=A[r]; A[r]=temp; // vratim pivot kam patri return i; } void quicksort(int A[], int l, int r){ if (l>=r) return; // rozdelenie int pivot=divide(A, l, r); // rekurzivne volanie na mensie a vacsie prvky quicksort(A,l,pivot-1); quicksort(A,pivot+1,r); //zlucenie nebude treba - su spravne za sebou }
Občas sa môžete stretnúť aj s takto napísaným quicksortom. Skúste si premyslieť, prečo funguje a prečo si môžem dovoliť niektoré prvky vynechať.
void quickSort(int A[], int left, int right) { if (left>=right) return; int i = left, j = right; int pivot = A[(left + right) / 2]; /* partition */ while (i <= j) { while (A[i] < pivot) i++; while (A[j] > pivot) j--; if (i <= j) { int tmp = A[i]; A[i] = A[j]; A[j] = tmp; i++; j--; } }; /* recursion */ quickSort(A, left, j); quickSort(A, i, right); }
Príklad
Divide (0,8): 1 2 5 7 3 14 7 26 12 Divide (0,4): 1 2 3 7 5 Divide (0,2): 1 2 3 Divide (3,4): 5 7 Divide (5,8): 7 14 26 12 Divide (6,8): 14 12 26 Divide (6,7): 12 14
Odhad zložitosti
Zjavne sa vyskytujú dobré a zlé prípady. Ideálne je, keď sa nám podarí rozdeliť pole na dve rovnaké časti. Vtedy má quicksort zložitosť O(N.log N), čiže lepšiu, ako triedenia, ktoré sme ukázali na prednáške 6.
Nepríjemné je, keď sa nám podarí pole vždy rozdeliť na dve podpolia, z ktorých jedno má iba jeden prvok. Toto spôsobí, že v takýchto prípadoch potrebujeme až Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle O(N^2)} . Dobrá správa je, že takýchto prípadov nie je príliš veľa.
- Vymyslite príklad, kde by nastalo nevhodné rozdelenie. Závisí to samozrejme od toho, ako vyberáme pivota. Zamyslite sa nad prípadmi pivot=A[1] a pivot=A[(l+r)/2].
Prednáška 12
Organizačné poznámky
- DÚ6 bude na stránke koncom týždňa, termín odovzdania až 12.11.
- DÚ5, PDÚ2 termín budúci týždeň
- Budúci týždeň štvrtok sviatok, piatok rektorské voľno, inak všetko beží normálne
- Konzultačné hodiny každý pondelok J.K. 13:10-14:00, B.B. 14:00-14:50
Opakovanie: triedenia
Jednoduché triedenia: bubblesort, insertsort, maxsort
- Jednoduché, ale pomalé, zložitosť Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle O(n^2)}
Rekurzívne triedenia, rozdeľuj a panuj
- Rýchlejšie, zložitejšie
- Mergesort, zložitosť Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle O(n\log n)}
- Quicksort, zložitosť Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle O(n^2)} v najhoršom prípade, pre väčšinu stupov Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle O(n\log n)} , väčšinou rýchlejší ako Mergesort
Quicksort
int divide(int A[], int l, int r) { /* Preusporiada prvky A[l..r] tak, že * - všetky prvky v A[l..k-1] su <= A[k], * - vsetky prvky v A[k+1..r] su >= A[k] * a funkcia vrati hodnotu k */ int v = A[r]; // zvolim si pivot a odlozim si ho na kraj (alebo rovno zvolim krajny prvok) int i = l - 1, j = r; int temp; while (i < j) { while (A[++i] < v); while (A[--j] > v); if (i >= j) break; temp = A[i]; A[i] = A[j]; A[j] = temp; } temp = A[i]; A[i] = A[r]; A[r] = temp; // vratim pivot kam patri return i; } void quicksort(int A[], int l, int r) { if (l >= r) return; // rozdelenie int pivot = divide(A, l, r); // rekurzivne volanie na mensie a vacsie prvky quicksort(A, l, pivot - 1); quicksort(A, pivot + 1, r); //zlucenie nebude treba - su spravne za sebou }
Medián
Medián prvkov v poli je prvok, ktorý by po utriedení bol v strede poľa.
- Pre N prvkové pole je teda (N/2)-ty najmenší prvok.
Jednoduchý algoritmus: utriedime pole, vypíšeme A[n/2].
- Zložitosť Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle O(n^2)} alebo Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle O(n\log n)} podľa použitého triedenia
Ukážeme si rýchlejší algoritmus, Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle O(n^2)} v najhoršom prípade, väčšina vstupov Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle O(n)}
- Zovšeobecníme problém: hľadáme prvok, ktorý by bbol v utriedenom pole na mieste k (0<=k<n)
- Podobný na Quicksort, ale niektoré časti nebudeme triediť
Postup:
- Pole si rozdelíme ako pri quicksorte. Nech prvá časť má x prvkov. Potom
- ak k<x, stačí nám hľadať k-ty najmenší prvok v prvej časti
- ak k>x, potrebujeme nájsť (k-x)-tý prvok v druhej časti
int select(int A[], int l, int r, int k) { /* vrati prvok, ktory by bol na pozicii l+k, keby sme A[l..r] utriedili */ assert(0 <= k && k <= r - l); if (l == r) return A[l]; int pivot = divide(A, l, r); if (k < pivot - l) select(A, l, pivot - 1, k); else if (k > pivot - l) select(A, pivot + 1, r, k - pivot + l - 1); else return A[pivot]; }
Ukazovateľ, smerník, pointer
- Pamäť v počítači je rozdelená na dieliky, do ktorých sa zapisujú hodnoty premenných
- Väčšinou k týmto dielikom pristupujeme pomocou mien premenných
- Každý dielik má adresu (niečo ako poradové číslo)
- Ukazovateľ (resp. smerník alebo pointer) je premenná, ktorej hodnota je adresa iného dieliku pamäte
Definovanie premennej typu ukazovateľ
- Nový ukazovateľ je definovaný pomocou typu s pridanou *
int i; // klasická celočíselná premenná int *pi; // ukazovateľ na celočíselnú premennú
- Typ ukazovateľa je teda rôzny pre rôzne typy premenných
- nedá sa priraďovať navzájom napr. ukazovateľ na int a ukazovateľ na char
int *pi; char *pc; pc = pi; // chyba
Operátor & (adresa)
- Adresu nejakej premennej vieme zistiť operátorom &
- Tú potom môžeme priradiť do premennej typu ukazovateľ
- Ak do premennej typu ukazovateľ nič nepriradíme, má nedefinovanú hodnotu, ukazuje na náhodné miesto v pamäti, alebo niekde mimo
int i; int *pi = &i;
Premenná pi teraz ukazuje na miesto, kde je uložené i
Smerník, ktorý nikam neukazuje
- Nulový ukazovateľ NULL - konštanta definovaná v knižnici cstdlib
- Je možné priradiť ho ukazovateľom na ľubovoľný typ
- Testovanie: if (pi == NULL) {...}
- V C++ môžeme používať namiesto NULL aj 0.
Operátor * (dereferencovanie, údaje na adrese)
- Ak máme ukazovateľ x, dáta z adresy, na ktorú ukazuje, získame ako *x
- Môžeme ich aj meniť
int i = 1; int j = 2; int *p = &i; // p ukazuje na i cout << *p << endl; // vypise 1 p = &j; // p ukazuje na j cout << *p << endl; // vypise 2 (*p)++; // zvysime j o 1 cout << *p << endl; // vypise 3 cout << j << endl; // vypise 3
Príklady
- Do premennej typu smerník na niečo môžeme priradiť iba adresu premennej typu niečo (alebo NULL).
int i, *p_i; p_i = &i; // spravne p_i = &(i + 3); // zle, i+3 nie je premenna p_i = &15; // zle, konstanta nema adresu p_i = 15; // zle, priradovanie intu do adresy i = p_i; // zle, priradovanie adresy do intu i = &p_i; // zle, priradovanie adresy do intu i = *p_i; // spravne ak p_i bol inicializovany *p_i = 4; // spravne ak p_i bol inicializovany
Smerníky na struct
Smerník môže ukazovať aj na structy
struct kruh { int x, y, r; }; kruh k; k.x = 0; k.y = 0; k.r = 10; // kruh na suradnicicach (0,0) s polomerom 10 kruh *p = &k; // smernik na strukturu typu kruh (*p).x = 20; // dve formy priradovania do sucasti structu p->y = 10; // k je teraz na suradniciach (20,10)
Pozor, bodka má vyššiu prioritu ako hviezdička
- preto *p.x znamená *(p.x), teda vezmeme hodnotu v p.x, interpetujeme ju ako adresu a pozrieme sa, čo je na tejto adrese
- aký typ by muselo mať p aby toto fungovalo?
- väčšinou chceme skôr (*p).x, čo znamená, že interpretujeme p ako adresu na struct, v ktorom je položka x
- keďže sa to často používa, existuje skratka p->x
Parametre funkcií
- Odovzdávanie hodnotou: nakopíruje hodnotu do novej lokálnej premennej
void nasob(int x) { x = 2*x; cout << x; } int main(void){ int x = 1; nasob(x); // vypise 2 cout << x; // vypise 1 }
- Odovzdávanie referenciou: vytvorí nové meno pre existujúcu premennú, zmeny zostávajú aj po skončení
void nasob(int &x) { x = 2*x; cout << x; } int main(void){ int x = 1; nasob(x); // vypise 2 cout << x; // vypise 2 }
- Nové: parameter je smerník
- Volajúca funkcia pošle smerník, ten sa hodnotou skopíruje do lokálnej premennej
- Ak ale robíme zmeny na adrese uloženej v parametri, majú dosah aj mimo funkcie
void nasob(int *p_x) { *p_x = *p_x * 2; cout << *p_x; } int main(void){ int x = 1; nasob(&x); // vypise 2 cout << x; // vypise 2 }
- V čistom C neboli referencie, týmto spôsobom sa odovzdávajú premenné, ktoré sa majú meniť
- Stále používané v C-čkových štandardných knižniciach
Funkcia swap s použitím ukazovateľov
void swapP(int *p_x, int *p_y){ // ako parameter má dve adresy ukazujúce na celé čísla int pom = *p_x; // do premennej pom nastavi hodnotu, ktorá je na adrese p_x *p_x = *p_y; // hodnotu, ktorá je na adrese p_x zmení na hodnotu, ktorá je na adrese p_y *p_y = pom; // hodnotu, ktorá je na adrese p_y nastaví na hodnotu premennej pom }
Ako budeme túto funkciu volať, ak chceme vymeniť hodnoty premenných i=5 a j=7?
- swapP(i, j); Zle. Vymieňame obsahy adries 5 a 7. Neskompiluje, lebo int sa nedá priradiť do int *
- swapP(*i, *j); Zle. Vymieňame obsahy adries uložených na adresách 5 a 7. Neskompiluje lebo operátor * sa nedá použiť na premenné typu int.
- swapP(&i, &j); Správne. Pošle adresy premenných i a j a funkcia swapP vymení hodnoty na týchto adresách.
Dynamická alokácia a dealokácia pamäte: new, delete
Doteraz sme videli
- globálne premenné: majú vopred známu veľkosť a vyhradenú pamäť
- lokálne premenné: majú vopred známu veľkosť, ale nevieme, ktoré funkcie sa použijú (a v prípade rekurzie koľkokrát), preto sa im pamäť priraďuje až pri volaní funkcie na zásobníku funkčných volaní (call stack)
Teraz si ukážeme, ako môže si program vyhradiť počas behu ďalšiu pamäť podľa potreby
- Používa sa na to príkaz new
- Pamäť sa vyhradí v oblasti zvanej heap (halda, hromada)
- Keď už pamäť nepotrebujeme, uvoľníme ju príkazom delete
- Uvoľnená pamäť môže byť znovu použitá pri ďalších volaniach new
#include <iostream> using namespace std; int main(void){ int * p; // p je lokalna premenna, zatial neinicializovana p = new int; // vypytam si novy kus pamate dost velky na 1 int // a adresu ulozim do p *p = 50; // do alokovanej pamati ulozim hodnotu 50 cout << *p << endl; // vypisem 50 delete p; // alokovanu pamat uvolnim }
Príklad využitia new a delete
- Máme štruktúru kruh, chceme od užívateľa načítať niekoľko kruhov
- Nevieme, koľko ich bude, tak si spravíme pole smerníkov a naalokujeme len potrebné kruhy
#include <iostream> #include <cstdlib> using namespace std; struct kruh { int x, y, r; }; const int maxN = 100; const double pi = 3.1415926536; int main(void) { kruh * kruhy[maxN]; int n; cout << "Zadajte pocet kruhov: "; cin >> n; for (int i = 0; i < n; i++) { cout << "Zadajte suradnice stredu a polomer kruhu " << i << ": "; /* vytvorime novy kruh */ kruh * novy = new kruh; cin >> novy->x >> novy->y >> novy->r; /* ulozime adresu noveho kruhu do pola */ kruhy[i] = novy; } /* spracovavame zoznam kruhov, napr. spocitame sucet ich obsahov */ double sucet = 0; for (int i = 0; i < n; i++) { sucet += kruhy[i]->r * kruhy[i]->r * pi; } cout << "Sucet obsahov kruhov: " << sucet << endl; /* na konci zmazeme kruhy */ for (int i = 0; i < n; i++) { delete kruhy[i]; } }
Všimnite si:
- kruh * kruhy[maxN]; vytvorí pole smerníkov na kruh s maxN prvkami
- Prístup k polomeru i-teho kruhu: kruhy[i]->r
Problém: pole kruhy má aj tak vopred stanovenú veľkosť, je však možné alokovať aj polia dynamickej veľkosti.
Cvičenie: Prečo nemôžeme v programe zmeniť načítanie takto?
for (int i = 0; i < n; i++) { cout << "Zadajte suradnice stredu a polomer kruhu " << i << ": "; /* nacitame kruh */ kruh novy; cin >> novy.x >> novy.y >> novy.r; /* ulozime adresu noveho kruhu do pola */ kruhy[i] = &novy; }
Polia a smerníky
- Polia a smerníky v jazyku C spolu veľmi úzko súvisia.
- Pole sa správa (väčšinou) ako ukazovateľ na jeho prvý prvok.
Vezmime tento jednoduchý program s funkciou, ktorá vypíše obsah poľa
void vypisPole(int a[], int n) { for(int i=0; i<n; i++) { cout << a[i]; } } int main(void) { int a[3] = {0,1,2}; vypisPole(a, 3); }
Hlavičku funkcie môžeme zmeniť takto a všetko bude ďalej fungovať:
void vypisPole(int *a, int n) {
Tiež do premennej typu int * môžeme priradiť pole. Premenná bude potom fungovať ako smerník na prvý (presnejšie nultý) prvok poľa.
int a[3] = {0,1,2}; int *b = a; vypisPole(b, 3);
Alokovanie jednorozmerného poľa
- Operátor new má verziu, ktorá alokuje pole zadanej dĺžky
- Napr. int *a = new int[10];
- Výsledok priradíme do ukazovateľa, odvtedy používame ako pole
- Uvoľníme operátorom delete[].
- Veľkosť poľa v new nemusí byť konštantná, môžeme si naalokovať také veľké pole, ako potrebujeme
Napríklad od užívateľa načítame počet čísel, vytvoríme pole príslušnej veľkosti a načítame do neho čísla:
- Podobne by sa dal zmeniť aj program s kruhmi vyššie
#include <iostream> using namespace std; int main(void) { cout << "Zadaj pocet cisel: "; int n; cin >> n; int *a = new int[n]; // vytvorime pole for (int i = 0; i < n; i++) { // nacitame data cout << "Zadaj cislo " << i << ": "; cin >> a[i]; } for (int i = n-1; i >=0; i--) { // spracujeme, napr. vypiseme odzadu cout << a[i] << endl; } delete[] a; }
Kontrola programov nástrojom valgrind
- C-čko pri použití polí a smerníkov nekontroluje, či ich používame správne
- Chybou v programe sa nám teda ľahko môže stať, že čítame alebo píšeme mimo alokovanej pamäte
- Takéto chyby sa niekedy ťažko hľadajú
- V Linuxe nám na hľadanie takýchto chýb pomôže nástroj valgrind
- Keď v Netbeans spustíme nástroj Build (ikonka kladivka; spúšťa sa tiež automaticky pred spustením programu), Netbeans zavolá kompilátor a vytvorí spustiteľný súbor
- Tento spustiteľný súbor nájdeme v adresári typu NetBeansProjects/meno_projektu/dist/Debug/GNU-Linux-x86/, volá sa rovnako ako projekt
- V Linuxe si ho môžeme na príkazovom riadku spustiť aj mimo prostredia Netbeans, stačí napísať NetBeansProjects/meno_projektu/dist/Debug/GNU-Linux-x86/meno_projektu
- Namiesto toho ho môžeme spustiť valgrind NetBeansProjects/meno_projektu/dist/Debug/GNU-Linux-x86/meno_projektu
- Nástroj valgrind bude náš program pozorne sledovať a keď robí divné veci v pamäti, vypíše nám o tom správu
Nasledujúci program vypisuje neinicializovanú premennú i (knižnice pre krátkosť vynechávame):
int main(void) { int i; cout << i << endl; }
Valgrind vypíše okrem iného
==6021== Conditional jump or move depends on uninitialised value(s) ==6021== at 0x4EBAD23: std::ostreambuf_iterator<char, std::char_traits<char> > std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::_M_insert_int<long>(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.16) ==6021== by 0x4EBB065: std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::do_put(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.16) ==6021== by 0x4EC64DC: std::ostream& std::ostream::_M_insert<long>(long) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.16) ==6021== by 0x40079A: main (main.cpp:7) ==6021== ==6021== Use of uninitialised value of size 8 ==6021== at 0x4EBA823: ??? (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.16) ==6021== by 0x4EBAD47: std::ostreambuf_iterator<char, std::char_traits<char> > std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::_M_insert_int<long>(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.16) ==6021== by 0x4EBB065: std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::do_put(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.16) ==6021== by 0x4EC64DC: std::ostream& std::ostream::_M_insert<long>(long) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.16) ==6021== by 0x40079A: main (main.cpp:7)
Nasledujúci program zapisuje do pamäte, na ktorú ukazuje smerník s neinicializovnaou hodnotou
int main(void) { int *p; *p = 7; cout << *p << endl; }
==6125== Use of uninitialised value of size 8 ==6125== at 0x400790: main (main.cpp:7) ==6125== ==6125== Invalid write of size 4 ==6125== at 0x400790: main (main.cpp:7) ==6125== Address 0x0 is not stack'd, malloc'd or (recently) free'd ==6125== ==6125== ==6125== Process terminating with default action of signal 11 (SIGSEGV) ==6125== Access not within mapped region at address 0x0 ==6125== at 0x400790: main (main.cpp:6)
Tento program sa pokúša odalokovať pamäť, ktorá nebola alokovaná
int main(void) { int i = 7; int *p = &i; delete p; }
==6579== Invalid free() / delete / delete[] / realloc() ==6579== at 0x4C2A4BC: operator delete(void*) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so) ==6579== by 0x400696: main (main.cpp:8) ==6579== Address 0x7ff00097c is on thread 1's stack
Ani valgrind nemusí nájsť všetky chyby, napr. tu sa k premennej správame ako ku poľu a píšeme mimo, ale valgrind si to nevšimne:
int main(void) { int i; int *p = &i; p[2] = 7; cout << p[2] << endl; }
Ak index 2 nahradíme 2000, valgrind už vypíše chybu...
Zhrnutie
- Smerník, ukazovateľ, pointer je premenná, v ktorej je uložená adresa nejakého pamäťového miesta
- Typ smerníku určuje, na aký typ premennej by mal ukazovať, napr. int *p
- Do smerníku môžeme priradiť NULL, adresu nejakej premennej (&i), novoalokovanú pamäť pomocou new, iný smerník toho istého typu
- Ku políčku, na ktoré ukazuje smerník p, pristupujeme pomocou (*p)
- Pole je vlastne smerník na svoj prvý (nultý) prvok
- Pole určitej dĺžky (ktorá je známa až počas behu) alokujeme pomocou new typ[pocet]
- Pamäť alokovanú cez new by sme mali odalokovať pomocou delete alebo delete[] (podľa toho, či to bolo pole)
- Pri práci so smerníkmi ľahko spravíme chybu, pomôcť nám môže valgrind
Cvičenia 6
Backtracking, prehľadávanie s návratom
- Napíšte rekurzívny program, ktorý pre dané čísla n a k (1<=k<=n) vypíše všetky podmnožiny veľkosti k množiny {0..n-1}. Na rozdiel od variácií nám v podmnožine nezáleží na poradí (napr. {0,1} = {1,0}), prvky teda budeme vždy vypisovať od najmenšieho po najväčší. Napr. pre n=3 a k=2 vypíšte
0 1 0 2 1 2
- Napíšte program, ktorý pre dané čísla n, k a S vypíše všetky k-tice čísel z množiny {0..n-1}, ktorých súčet je aspoň S. Prehľadávanie zastavte vždy, keď nie je možné súčet S dosiahnuť, ani keby všetky zvyšné čísla mali hodnotu n-1. Napríklad pre k=3, n=3, S=5 vypíšte
1 2 2 2 1 2 2 2 1 2 2 2
Rekurzívne vykresľovanie korytnačou grafikou
Napíšte rekurzívny program, ktorý bude vykresľovať strom korytnačou grafikou. Strom má dva parametre: veľkosť d a stupeň n. Strom stupňa 0 je prázdna množina. Strom stupňa n pozostáva z kmeňa, ktorý tvorí úsečka dĺžky n a z dvoch podstromov, ktoré sú stromy stupňa n-1, veľkosti d/2 a otočené o 30 stupnov doľava a doprava od hlavnej osi stromu (pozri obrázky nižšie). Pri vykresľovaní stromu sa s korytnačkou vráťte na miesto a otočenie, v ktorom ste začali (bez toho by sa len ťažko písala rekuzívna funkcia). Korytnačka teda prejde po každej vetve dvakrát, raz smerom dopredu a raz naspäť.
Grayov kód
- Vypíšte všetky k-tice binárnych hodnôt 0 a 1 tak, aby sa každé dve po sebe idúce k-tice sa líšili na najviac jednom mieste a tiež posledná k-tica s prvou, ako v tomto príklade:
000 001 011 010 110 111 101 100
Takáto postupnosť sa nazýva Grayov kód. Ako vidno v tomto príklade, Grayov kód stupňa k sa dá zostaviť rekurzívne: horná polovica kódu stupňa k je Grayov kód stupňa k-1 s cifrou 0 pridanou na najľavejšiu pozíciu a druhá polovica kódu stupňa k je kód stupňa k-1 vypísaný odzadu s cifrou 1 pridanou na najľavejšiu pozíciu. Môžete použiť nasledovnú hlavičku rekurzívnej funkcie:
void gray(int a[], int k, int i, bool reverse) { /* Prvych i pozicii v poli a obsahuje hodnoty 0 a 1, * Do zvysnych k-i postupne dosadte Grayov kod stupna k-i * a zakazdym vypiste cele pole. * Ak reverse = true, Grayov kod generujte odzadu. */ }
Čo vypíše program?
Bez použitia počíta skúste zistiť, čo vypíše nasledujúci program. Pomôcka: vybudujte si tabuľku hodnôt funkcie f pre rôzne n a vypĺňajte ju od najmenších hodnôt n k väčším. Delenie dvomi v programe je celočíselné, vráti teda dolnú celú časť.
#include <iostream> using namespace std; int f(int n) { if(n<=5) return n; else { return (f(n-1) + f(n-3))/2; } } int main(void) { for(int i=1; i<=10; i++) { cout << i << ": " << f(i) << endl; } }
DÚ5
Odovzdávanie DÚ5 max. 10 bodov, termín odovzdania pondelok 29.10. o 22:00
Cieľom tejto domácej úlohy je precvičiť si prácu s rekurziou.
Napíšte program, ktorý pomocou korytnačej grafiky a rekurzie vykreslí fraktálnu krivku, ktorá je pre stupne 1,2 a 5 zobrazená na obrázkoch nižšie. Pre stupeň 1 má táto krivka tvar T-čka, pričom vodorovná aj zvislá úsečka majú dĺžku d. Pre stupeň n z každého konca vodorovnej časti T-čka zavesíme fraktály stupňa n-1 a veľkosti d/2, pričom jeden je otočený nahor a jeden nadol. (Fraktál stupňa 0 môžeme pre úplnosť zadefinovať ako prázdnu množinu.)
V programe si zadefinujte nasledujúce konštanty, ktorých zmenou môžete ovplyvniť správanie sa programu:
const int width = 400; /* rozmery obrázku */ const int height = 400; const double d = 200; /* dĺžka úsečiek T-čka na najvyššej úrovni rekurzie */ const int n = 5; /* stupeň fraktálu */ const double wait = 0.2; /* koľko korytnačka čaká po každom ťahu */
Korytnačka by mala začať v strede spodnej strany obrázku natočená nahor. Po nakreslení celého fraktálu by mala skončiť na tom istom mieste a s tým istým natočením (po každej čiare prejde dvakrát -- tam aj späť). Táto podmienka vám pomôže správne pospájať fraktály stupňa n-1 do fraktálu stupňa n.
Pomôcky:
- Doporučujeme program najskôr odladiť pre stupeň n=1 a 2 a dlhšie čakanie (napr. wait=2), až potom skúšať vyššie hodnoty n a kratší wait.
- Inšpirovať sa môžete programom na Kochovu krivku z prednášky 9.
- Ak dáme korytnačke ako argument do turnLeft záporné číslo, bude sa otáčať o toľko stupňov doprava. Ak jej do forward dáme záporné číslo, pôjde o toľko dozadu.
Prednáška 13
Práca so súbormi
- Doteraz sme na načítavanie a vypisovanie dát používali výhradne konzolu (obrazovku/klávesnicu).
- V praxi často chceme spracovávať dáta uložené v súboroch.
- Zameriame sa na súbory v textovom formáte, pracuje sa s nimi podobne ako s konzolou.
- V C++ existujú ekvivalenty cin >> a cout << aj pre súbory, nájdete ich v knižnici fstream.
Práca s konzolou v Cčku: printf a scanf
- Teraz sa naučíme, ako sa so súbormi (a s konzolou) pracuje v klasickom Cčku.
- Príkazy printf a scanf sú v knižnici cstdio
printf
- Funkcia printf vypisuje formátovaný text na konzolu.
- Použitie: printf(format, hodnota1, hodnota2,...)
- Formátovací reťazec obsahuje bežné znaky, ktoré sa priamo vytlačia a špeciálne formátovacie príkazy začínajúce %, ktoré určujú, ako formátovať jednotlivé hodnoty
- Napr. predpokladajme, že x a y sú celočíslené premenné s hodnotami 10 a 20. Príkaz printf("bod (%d,%d)\n", x, y) vypíše "bod (10,20)" a koniec riadku.
Príklady formátovacích reťazcov:
- %c - znak (character)
- %s - reťazec (string)
- %d - celé číslo (integer)
- %f - reálne číslo (double)
- %e - reálne čislo vo vedeckej notácii napr. 5.4e7
- %% - vypíše znak %
Pozor, typy výrazov v zozname hodnôt musia sedieť s formátovacím reťazcom
Formátovanie
Nastavovanie šírky a počtu desatinných miest
- %.2f - vypíše na 2 desatinné miesta
- %4d - ak má číslo menej ako 4 znaky, doplní vľavo medzery
- %04d - podobne, ale dopĺňa nuly
Na predáške o stringoch sme videli formatovanie vysledku (zarovnanie doľava) pomocou vlastnej funkcie, ktorá číslo pripravila do pomocného poľa znakov (stringu).
int main(void) { char A[maxN]; int n = 12; for (int i = 1; i <= n; i++) { int x = factorial(i); formatInt(i, A, 2); cout << A << "! = "; formatInt(x, A, 10); cout << A << endl; } }
Vďaka formátovacím reťazcom v printf vieme tento program prepísať jednoduchšie.
int main(void) { int n = 12; for (int i = 1; i <= n; i++) { printf("%2d",i); printf("! = "); printf("%10d\n",factorial(i)); } }
- Dokonca by nám v cykle stačil jediný príkaz printf("%2d! = %10d\n",i,factorial(i));
- Podobne vieme doplniť aj úvodné nuly - napríklad, keď by sme radi v dátume doplnili deň a mesiac na dvojciferné čísla a rok na štvorciferné.
void showDate(int d, int m, int y){ printf("%02d.%02d.%04d",d,m,y); } int main(void){ showDate(1,1,1990); }
scanf
- Funkcia scanf(format, premenna1, premenna2,...) načítava dáta z konzoly
- Napr. scanf("%d", &x) načíta celočíselnú hodnotu do premennej x.
- Všimnite si, že zatiaľ čo do printf sa vkladajú priamo hodnoty (premenné), scanf potrebuje smerníky na premenné, pretože ich modifikuje.
Jednoduché načítanie mena a veku.
char str [80]; int i; printf ("Enter your family name: "); scanf ("%s",str); printf ("Enter your age: "); scanf ("%d",&i); printf ("Mr. %s , %d years old.\n",str,i);
- Formátovací reťazec obsahuje:
- Špecifikáciu formátov načítávaných premenných (začínajú znakom %) - podobne ako u printf
- Biele znaky ("whitespace" - medzery, konce riadkov, tabulátory) - funkcia číta a ignoruje všetky biele znaky pred ďalším nebielym znakom (jeden biely znak umožní ľubovoľný počet bielych znakov na vstupe)
- Ostatné znaky formátovacieho reťazca musia presne zodpovedať vstupu
Načítávanie dátumu.
int d,m,y; printf("Enter the date: "); scanf("%d.%d.%d",&d,&m,&y); printf("Year: %d\n",y);
- Funkcia vracia počet úspešne priradených hodnôt (načítáva kým nedôjde k chybe vstupu alebo chybe konverzie na príslušný typ premennej). V prípade chyby hneď na začiatku vracia hodnotu EOF (napríklad hneď na začiatku končí vstup).
Postupné sčítávanie čísel zo vstupu.
double sum, v; sum = 0; while (scanf("%lf", &v) == 1) printf("%.2f\n", sum += v);
Kontrola správneho vstupu
- Určenie, či máme na vstupe potrebný počet čísel na nejakú operáciu
Program načíta zo súboru tri double čísla a vypíše ich na obrazovku - testuje, či sú v súbore 3 čísla
int main() { double x, y, z; if(scanf("%lf %lf %lf", &x, &y, &z) == 3) printf("%lf \n", x + y + z); else printf("Neboli nacitane 3 realne cisla\n."); }
- Kontrola celého čísla, záporného čísla, desatinného čísla, pre vhodné číselné sústavy kontrola čísla
- Pomocou scanf, však vieme robiť iba jednoduché kontroly chýb. Môže byť preto lepšie najprv načítať zo vstupu reťazec pomocou gets a prečítaný string následne spracovať. Ale o tom až na ďalšej prednáške.
Práca so súborom: FILE *, fopen, fclose, fprintf, fscanf
Základný dátový typ: FILE *
- ukazovateľ (pointer - *) na objekt typu FILE
- dodržať veľké písmená (FILE *, nie file *)
- obsahuje údaje o otvorenom súbore, s ktorým práve pracujeme
- definícia premennej f pre prácu so súborom FILE *f; (pre viac premenných FILE *fr, *fw;)
Otvorenie súboru pre čítanie
- fr = fopen("vstup.txt", "r");
- Otvorí súbor s menom vstup.txt (môžeme samozrejme použiť aj iné meno, prípadne pridať cestu)
- Ak taký súbor neexistuje alebo sa nedá otvoriť, do fr priradí NULL
- Z takto otvoreného súboru môžeme čítať napr. pomocou fscanf, ktorá je analógom scanf
- Napr. fscanf(fr, "%d", &x);
Otvorenie súboru pre zápis
- fw = fopen("vystup.txt", "w");
- Vytvorí súbor s menom vystup.txt. Ak už existoval, zmaže jeho obsah.
- Ak sa nepodarí súbor otvoriť, do fw priradí NULL.
- Do takto otvoreného súboru môžeme zapisovať napr. pomocou fprintf, ktorá je analógom printf
- Napr. fprintf(fw, "%d", x);
Zatvorenie súboru
- Keď už nebudeme zo súboru čítať ani doňho zapisovať, uzatvoríme ho pomocou fclose(f);
- Nespoliehať sa, že po skončení programu sa súbor automaticky zavrie súbor
- Počet súčasne otvorených súborov je obmedzený
- Pri zavretí sa zapíše buffer do súboru, predídeme tým strate dát pri páde programu
- Ak sa nepodarí otvoriť súbor - vracia fclose() konštantu EOF
V súbore vstup.txt máme niekoľko riadkov, prvý obsahuje názov výstupného súboru a každý ďalší obsahuje názov súboru (označme f) a číslo (označme x). Do výstupného súboru chceme pre každý riadok zo vstupu vypísať zo súboru f prvých x čísel.
Príklad: Súbor a.txt obsahuje čísla 1..9, súbor b.txt obsahuje čísla 10,20..90 a súbor c.txt obsahuje čísla 100,200..900.
Pre vstupný súbor vstup.txt
vystup.txt a.txt 2 b.txt 1 a.txt 3
Očakávame výstup v súbore vystup.txt
1 2 10 1 2 3
- Otvoríme vstupný súbor a prečítame z neho názov výstupného súboru
- Otvoríme aj výstupný súbor a postupne budeme zo vstupu čítať dvojice subor cislo.
- Každý načítaný súbor si otvoríme, vypíšeme z neho čísla a zatvoríme.
- Na konci zavrieme vstup aj výstup.
- Kontrolujeme existenciu súborov aj čísel v nich.
int main() { FILE *fr1, *fr2, *fw; char str[20]; int kolko,cislo; fr1=fopen("vstup.txt","r"); if (!fr1) return -1; if (fscanf(fr1,"%s",str)!=1) return -1; fw=fopen(str,"w"); if (!fw) return -1; while (!feof(fr1)){ fscanf(fr1,"%s %d",str,&kolko); fr2=fopen(str,"r"); if (!fr2) return -1; for (int i=0; i<kolko; i++){ if (fscanf(fr2,"%d ",&cislo)!=1) return -1; fprintf(fw,"%d ",cislo); } fclose(fr2); } fclose(fr1); fclose(fw); }
Štandardný vstup a výstup ako súbor
C pracuje s klávesnicou a obrazovkou ako so súborom - v stdio.h sú definované dva konštantné ukazovatele stdin a stdout.
FILE *stdin, *stdout;
- označujú štandardný vstupný/výstupný prúd (standard intput-output stream)
- stdin a stdout môžu byť použité v programe ako argumenty operácií so súbormi fscanf(stdin,"%d",&x)
Vďaka tomu, že aj štandardný vstup a výstup sa dajú používať v takým istým spôsobom ako súbory je, že si používateľ môže vybrať, s čím chce pracovať.
V prípade, že by sme v predchádzajúcom príklade chceli na základe prvého riadku vstupu umožniť aj umožniť zapisovanie na štandardný výstup (napríklad ak je na vstupe "-"), stačilo by pred otvorením výstupu overiť túto alternatívu a ďalej pracovať rovnako.
... if (fscanf(fr1,"%s",str)!=1) return -1; if (strcmp(str,"-")==0) fw=stdout; else fw=fopen(str,"w"); if (!fw) return -1; ...
Testovanie konca súboru
- Pomocou symbolickej konštanty EOF
- definovaná v stdio.h, väčšinou má hodnotu -1
- Pomocou makra feof()
Binárne súbory
Ako ukladať desatinné čísla?
- Strata presnosti
A čo väčšie štruktúry?
- Nanútime pre všetkých spôsob načítávania
Alternatívne riešenie je použitie binárnych súborov, kde sa neukladáme textovú reprezentáciu ale reprezentáciu, ktorá zodpovedá uloženiu v pamäti.
fwrite
- Funkcia fwrite( const void * ptr, size_t size, size_t count, FILE * f ); do súboru f zapíše count položiek veľkosti size ležiacich v pamäti od adresy ptr.
- Funkcia vráti počet reálne zapísaných položiek.
- Súbor f musí byť otvorený na zápis.
- Typickým príkladom je, že mám určité položky uložené v poli. Potom začiatok pamäte je určený smerníkom.
Príklad: Chceme uložiť pole reálnych čísel (napríklad odmocniny z čísel 0..100).
int main() { double a[100]; FILE *f; double b[5]; for (int i=0; i<100; i++) a[i]=sqrt(i); f=fopen("binarny.dat","w"); fwrite(a,sizeof(double),100,f); fclose(f); }
fread
- fread funguje podobne ako fwrite.
- Funkcia fread (void * ptr, size_t size, size_t count, FILE * f ); zo súboru f prečíta count položiek veľkosti size a uloží ich do pamäti od adresy ptr.
Ak by sme si chceli napríklad overiť, že súbor z predchádzajúceho príkladu naozaj obsahuje na 4. mieste číslo 2, stačí si do poľa b uložiť prvých 5 položiek zo súboru binarny.dat a skontrolovať prvok b[4].
int main() { FILE *f; double b[5]; f=fopen("binarny.dat","r"); fread(b,sizeof(double),5,f); printf("%f\n",b[4]); fclose(f); }
Spracovávanie vstupu
V prípade, že máme v súbore zaručené čísla, bežne bývajú v niektorom z nasledujúcich formátov:
- N (počet čísel) a za tým N čísel
FILE *f; int a[100],N,i,x; int sum=0; f=fopen("vstup.txt","r"); if (!f) return -1; if (fscanf(f,"%d ",&N)!=1) return -1; for (int i=0; i<N; i++){ if (fscanf(f,"%d ",&a[i])!=1) return -2; sum+=a[i]; } printf("%d\n",sum); fclose(f); }
- postupnosť čísel ukončená -1 alebo inou špeciálnou hodnotu
int main() { FILE *f; int a[100],N,i,x; int sum=0; f=fopen("vstup.txt","r"); if (!f) return -1; i=0; if (fscanf(f,"%d ",&x)!=1) return -2; while (x!=-1){ a[i++]=x; sum+=x; if (fscanf(f,"%d ",&x)!=1) return -2; } printf("%d\n",sum); fclose(f); }
- čísla až kým neskončí súbor
- teoreticky by sme mohli kontrolovať či sa správne načítalo, teda while (fscanf(f,"%d ",&x)==1)){...}, ale nerozoznali by sme správny koniec od chyby
int main() { FILE *f; int a[100],N,i,x; int sum=0; f=fopen("vstup.txt","r"); if (!f) return -1; i=0; while (!feof(f)){ if (fscanf(f,"%d ",&a[i])!=1) return -1; sum+=a[i++]; } printf("%d\n",sum); fclose(f); }
- niekoľko sád z predchádzajúcich vecí
Prednáška 14
Organizačné poznámky
- Včera časový posun na Moodli, chvíľu sa nedali odovzdávať DÚ. Ak Vás to postihlo, dajte nám čím skôr vedieť a úlohu ešte dnes pošlite emailom cvičiacemu.
- Nabudúce nám hláste prípadné poruchy čím skôr, aby sme ich mohli riešiť.
- Ak kvôli technickým problémom neviete úlohu odovzdať, pošlite ju ešte pred termínom cvičiacemu.
- Neopisovať domáce úlohy od spolužiakov, z internetu ani od starších kolegov
- Pripravíte sa o možnosť precvičiť si učivo, hrozia vám postihy
- Ak neviete úlohu riešiť, pýtajte sa nás
- DÚ6 do pondelka 12.11., budúci pondelok normálne prednáška aj cvičenia (vrátane rozcvičky)
- PDÚ3 bude zverejnená dnes
Súbory, zhrnutie
- Príkazy fopen, fclose na otváranie a zatváranie súboru, typ FILE *
- Príkazy fscanf a fprintf na načítavanie a vypisovanie formátovaných dát (čísla, slová)
Príklad: načítame číslo n a n celých čísel zo súboru vstup.txt. Do súboru vystup.txt vypíšeme n a vstupné čísla v opačnom poradí.
#include <cstdio> #include <cassert> int main(void) { FILE *fr = fopen("vstup.txt", "r"); // otvorime vstupny a vystupny subor FILE *fw = fopen("vystup.txt", "w"); assert(fr != NULL && fw != NULL); // skontrolujeme, ze sa podarilo int n, r; r = fscanf(fr, "%d ", &n); // nacitame pocet prvkov n assert(r == 1 && n >= 0); // overime, ze s apodarilo a ze pocet nezaporny int *a = new int[n]; // alokujeme pole dlzky n for (int i = 0; i < n; i++) { // citame jednotlive prvky pola r = fscanf(fr, "%d ", &a[i]); assert(r == 1); } fclose(fr); // zavrieme vstupny subor fprintf(fw, "%d", n); // vypiseme pocet prvkov do vystupu for (int i = n - 1; i >= 0; i--) { // vypiseme vstupne prvky naopak fprintf(fw, " %d", a[i]); } fclose(fw); // zavrieme vystupny subor delete[] a; // uvolnime pamat }
- printf a scanf sú podobné, ale pracujú s konzolou (stdin, stdout)
- existujú aj funkcie sscanf, sprintf, ktoré načítavajú resp. vypisujú do reťazca
Práca so súbormi po znakoch
Čítanie po znakoch: funkcia getc(subor) načíta zo súboru jeden znak.
- Vracia int (nie char).
- Ak sa podarilo načítať, je to kód načítaného znaku.
- Ak sa nepodarilo načítať znak (koniec súboru, alebo nejaká chyba), vráti špeciálnu hodnotu EOF
- Pozor, neukladať výsledok do premennej typu char, nevedeli by sme rozpoznať koniec súboru, bol by konvertovaný na iný znak
- Funkcia getchar() je skratka za getc(stdin), číta teda jeden znak z konzoly
- Spracovanie vstupu z klávesnice začne až potom, ako užívateľ stlačí Enter, nevieme takto reagovať priamo na stlačenie nejakej klávesy
Písanie po znakoch: funkcia putc(znak, subor) zapíše do súboru jeden znak
- Vracia int: zapísaný znak alebo EOF ak nastala chyba
- Funkcia putchar(znak) je skratka za putc(znak, stdout), píše teda na konzolu
Príklad: kopírovanie súboru
#include <cstdio> int main(void) { FILE *fr = fopen("list.txt", "r"); FILE *fw = fopen("kopia.txt", "w"); int c = getc(fr); while (c != EOF) { putc(c, fw); c = getc(fr); } fclose(fr); fclose(fw); }
Načítavať môžeme aj priamo v podmienke while cyklu:
- výsledkom priradenia je nová hodnota, túto porovnáme s EOF
- kratšie ale trochu menej čitateľné
int c; while ((c = getc(fr)) != EOF) { putc(c, fw); }
Konce riadkov
Znak pre koniec riadku je '\n'
- pri čítaní alebo zápise sa môže prekladať na jeden alebo dva znaky podľa typu operačného systému (<CR>, <LF>, alebo <CR><LF>)
Čo robí nasledujúci program?
#include <cstdio> int main(void) { FILE *fr; int c; fr = fopen("VSTUP.TXT", "r"); while ((c = getc(fr)) != '\n') { putchar(c); } putchar(c); /* vypis \n */ fclose(fr); }
Ungetc
Často zistíme, že máme prestať čítať znak až potom, čo prečítame o znak naviac
- funkcia ungetc(znak, subor) vráti znak späť (ako keby sme ho neprečítali)
- ak je vrátenie úspešné, ungetc() vracia vrátený znak
- ak je vrátenie neúspešné, vráti EOF
- vrátiť môžeme aj iný ako práve prečítaný znak
- použije sa pri ďalšom načítaní, ale nezmení obsah súboru
- nemali by sme volať viackrát za sebou
Program konvertuje znakový reťazec na zodpovedajúcu číselnú hodnotu. Keď narazí na prvé číslo, ktoré nie je cifra, vráti znak, aby sa dal použiť pri ďalšom spracovávaní.
int hodnota = 0; int c = getchar(); while (c >= '0' && c <= '9') { hodnota = hodnota * 10 + (c - '0'); c = getchar(); } ungetc(c, stdin);
Program prečíta číslo pomocou fscanf, predtým však musí prečítať neznámy počet znakov '$'.
#include <cstdio> int main(void) { FILE *fr = fopen("vstup.txt", "r"); int c = getc(fr); while (c == '$') { c = getc(fr); } ungetc(c, fr); int hodnota; fscanf(fr, "%d", &hodnota); printf("%d\n", hodnota); fclose(fr); }
Čítanie a písanie po riadkoch
Funkcia fgets(str, n, subor) načíta riadok zo súboru
- str je pole char-ov (premenná typu char *)
- n je veľkosť tohto poľa (aby funkcia neprepísala miesto mimo poľa)
- Funkcia načíta do str jeden riadok súboru, ale ak by bol príliš dlhý, skončí po prvých n-1 znakoch
- Znak '\n' nechá na konci poľa, za neho dá ukončovaciu 0
- Skončí aj ak príde na koniec súboru
- Vráti str, alebo NULL ak sa nepodarilo načítať ani jeden znak (vracia teda char *)
Nasledujúci program spočíta počet riadkov v súbore
- Čo spraví, ak posledný znak súboru nie je koniec riadku?
- Čo vypíše pre súbor, ktorý obsahuje jeden riadok s 200 znakmi?
#include <cstdio> int main(void) { const int maxN = 100; char str[maxN]; FILE *fr = fopen("vstup.txt", "r"); int num = 0; while (fgets(str, maxN, fr) != NULL) { num++; } cout << num << endl; }
Funkcia fputs(str, subor) vypíše reťazec str do súboru
- str môže obsahovať hocikoľko koncov riadkov (aj nula)
- pri chybe vráti EOF
Spracovávanie vstupu
Časté schémy spracovania textového súboru:
- Pomocou fscanf načítavame jednotlivé čísla, slová a pod. (väčšinou všetky biele znaky považujeme za ekvivalentné oddeľovače)
- Čítanie po znakoch pomocou getc
- Čítanie po riadkoch pomocou fgets do reťazca, potom reťazec spracovávame
Príklad: chceme nájsť dĺžku najdlhšieho riadku v súbore
- Prvá možnosť je čítanie riadkov do reťazca a ich spracovanie (problém ak je riadok príliš dlhý)
- Druhá možnosť je čítať súbor po znakoch, pričom si potrebujeme udržiavať "stav": koľko písmen sme už videli v tomto riadku
#include <cstdio> #include <cstring> int main(void) { FILE *fr = fopen("vstup.txt", "r"); int maxDlzka = 0; // dlzka najdlhsieho riadku doteraz const int maxN = 100; char str[maxN]; while (fgets(str, maxN, fr) != NULL) { int dlzka = strlen(str); if (dlzka > maxDlzka) { maxDlzka = dlzka; } } printf("Najdlhsi riadok ma dlzku %d\n", maxDlzka); fclose(fr); }
#include <cstdio> int main(void) { FILE *fr = fopen("vstup.txt", "r"); int maxDlzka = 0; // dlzka najdlhsieho riadku doteraz int dlzka = 0; // dlzka aktualneho riadku int c = getc(fr); while (c != EOF) { // nacitavame po znaku dlzka++; // zvysime dlzku riadku if (c == '\n') { // koniec riadku: spracujeme ho if (dlzka > maxDlzka) { maxDlzka = dlzka; } dlzka = 0; } c = getc(fr); } if (dlzka > maxDlzka) { // nezabudneme na posledny riadok (moze chybat \n) maxDlzka = dlzka; } printf("Najdlhsi riadok ma dlzku %d\n", maxDlzka); fclose(fr); }
Cvičenie: čo ak chceme zistiť, koľký riadok v súbore bol ten najdlhší?
Ešte jeden príklad: máme súbor s číslami oddelenými bielymi znakmi (medzery, tabulátory, konce riadkov,...), pričom medzi dvoma číslami mlže byť aj viac ako jeden oddeľovač. Chceme spočítať súčet čísel na každom riadku.
- nepríjemná kombinácia rozlišovania koncov riadku od iných bielych znakov a čítania formátovaných hodnôt (čísel)
- môžeme biele znaky spracovávať cez getc, potom použiť ungetc a fscanf
- alebo prečítať riadok do reťazca a rozložiť na čísla
#include <cstdio> #include <cctype> int main(void) { FILE *fr = fopen("vstup.txt", "r"); int sucet = 0; while(!feof(fr)) { int c = getc(fr); while(c!=EOF && isspace(c)) { if (c == '\n') { printf("Sucet %d\n", sucet); sucet = 0; } c= getc(fr); } if(c==EOF) { break; } ungetc(c, fr); int hodnota; fscanf(fr, "%d", &hodnota); sucet += hodnota; } fclose(fr); }
Cvičenia:
- upravte program, aby fungoval aj ak posledný riadok nie je ukončený '\n'
- upravte program, aby na výstupe vypisoval aj čísla na riadkoch oddelené medzerami
Jednoduché šifrovanie
Prácu so súbormi si precvičíme na jednoduchých šifrách.
Cézarova šifra
Cézarova šifra je šifra, kde každé písmeno vstupného reťazca posunieme v abecede cyklicky o K miest.
- Napr. ak K=2, tak namiesto A budeme budeme písať C, namiesto B píšeme D, namiesto Z píšeme B.
- Ukážeme si použitie pre anglickú abecedu (t.j. znaky 'A'-'Z' bez diakritiky), ale je možné ju použiť napríklad aj na ASCI kódy.
void encryptCezar(FILE *fr, int K) { assert(0 <= K && K < 26); int c = getc(fr); while (c != EOF) { if ((c <= 'Z') && (c >= 'A')) { // prekodujeme pismeno c = c + K; if (c > 'Z') { c = c - 26; } putc(c, stdout); } else if (isspace(c)) { // medzery kopirujeme na vystup putc(c, stdout); } c = getc(fr); } }
- Text, ktorý chceme zašifrovať načítavame zo súboru fr a posúvame znaky 'A'-'Z' o nejakú konštantu K.
- Biele znaky kopírujeme.
- Zašifrovaný text vypisujeme na obrazovku, nebol pri problém to zmeniť do súboru.
- Cvičenie: upravte program tak, aby správne šifroval aj malé písmená a aby na obrazovku kopíroval aj iné znaky, napr. čísla a interpunkciu.
Pri dešifrovaní postupujeme podobne, len číslo K od prečítaného znaku odrátame (pozor na prechod cez A).
Vigenerova šifra
Vigenerova šifra je veľmi podobná Cézarovej, ale posun nie je konštantný, ale podľa kľúča.
- Kľúč je nejaké slovo z písmen A-Z, pričom tieto sa písmená predstavujú posuny o 0..25
- Pri šifrovaní aj dešifrovaní cyklicky používame posuny z kľúča
- Kľúč samozrejme musí byť známy obidvom stranám.
void encryptVigenere(FILE *fr, char kluc[]) { int c = getc(fr); int i = 0; while (c != EOF) { if ((c <= 'Z') && (c >= 'A')) { c = c + kluc[i] - 'A'; if (c > 'Z') { c = c - 26; } putc(c, stdout); i++; if (kluc[i] == 0) i = 0; } else if (isspace(c)) { putc(c, stdout); } c = getc(fr); } }
Rastúce pole
Vráťme sa k programu, ktorý má zo súboru načítať postupnosť čísel a uložiť ich do poľa na ďalši spracovanie
- Ak je na za začiatku súboru počet čísel N, môžeme alokovať akurátne veľké pole
- Ak ale počet čísel nie je vopred známy, môžeme pole nafukovať podľa veľkosti
- Začneme s malým poľom (veľkosti 2)
- Vždy keď sa pole zaplní, alokujeme nové pole dvojnásobnej veľkosti, prvky do neho skopírujeme a staré pole odalokujeme
- Presúvanie prvkov dlho trvá, preto pole vždy zdvojnásobíme, aby sme nemuseli presúvať často
- Spolu pri načítaní n prvkov robíme najviac 2n presunov jednotlivých prvkov
#include <cstdio> int *nacitajDoPola(FILE *f, int &n) { /* Cita cele cisla zo suboru f az kym nepride na koniec. * Uklada ich do dynamicky alokovaneho pola, ktore vrati, * pocet nacitanych cisel ulozi do n */ int velkost = 2; // zacneme s polom s 2 prvkami int *pole = new int[velkost]; n = 0; // 0 cisel je zatial ulozenych while (!feof(f)) { if (n == velkost) { // ak sme naplnili pole, presunime do vacsieho velkost *= 2; int *nove = new int[velkost]; /* prekopirujeme zo stareho do noveho */ for (int i = 0; i < n; i++) { nove[i] = pole[i]; } /* zmazeme stare */ delete[] pole; pole = nove; } fscanf(f, "%d ", &pole[n]); // v poli je miesto, ulozime novu hodnotu n++; } return pole; } int main(void) { int n; int *a; a = nacitajDoPola(stdin, n); // nacitame pole a a pocet n for (int i = 0; i < n; i++) { // spracovavame, ako sme zvyknuti printf(" %d", a[i]); } printf("\n"); delete[] a; // nakoniec zmazeme pole a }
Vector
Rastúce pole z predchádzajúceho programu by sa nám mohlo zísť aj na iné účely
- V C++ knižniciach je štruktúra vector, ktorá podobne rastie podľa potreby
- My si jednoduchšiu verziu vektora naprogramujeme.
- Na začiatku programu si zadefinujeme, akého typu prvky budeme do vektora dávať (napr. int, doble, char a pod.)
- typedef int dataType;
- Náš vektor bude struct s potrebnými údajmi a bude poskytovať nasledujúce funkcie
- double init(vector &a) vytvorí prázdny vektor
- void add(vector &a, dataType x) pridá na koniec vektoru prvok x
- dataType get(vector &a, int i) vráti prvok na pozícii i v poli, pričom kontroluje, či je index platný (od 0 po najväčší vložený prvok) a ak nie, ukončí program príkazom assert
- void set(vector &a, int i, dataType x) na pozíciu i v poli uloží prvok x (s kontrolou indexu i)
- int length(vector &a)
- void destroy(vector &a) zmaže pamäť alokovanú pre vektor a
- Štruktúra vector teda v sebe združuje pole aj jeho dĺžku, stačí posielať jeden parameter
- Vector posielame do funkcií referenciou, aby sa zbytočne veľa nekopírovalo (a tiež aby sme ho mohli v prípade potreby meniť)
- Vector by sme teraz vedeli použiť bez toho, aby sme vedeli, ako sú funkcie naprogramované vo vnútri
- Môžeme teda implementáciu vectora meniť bez zmeny programu, ktorý ho používa
typedef double dataType; // sem pride definicia tyzpu vector + funkcie uvedene vyssie int main(void) { vector a; init(a); add(a, 0.5); // mame 1-prvkove pole {0.5} add(a, 1.0); // mame 2-prvkove pole {0.5, 1.0} set(a, 1, 1.5); // mame 2-prvkove pole {0.5, 1.5} printf("%f\n", get(a,0) + get(a,1)); // vypise 2.0000 destroy(a); }
- V objektovo-orientovanom programovaní (budúci semester) sa namiesto napr. get(a,0) píše niečo ako a.get(0)
Implementácia vectora
struct vector { dataType *a; /* pole prvkov typu dataType */ int size; /* velkost alokovaneho pola */ int n; /* pocet prvkov pridanych do pola */ }; dataType init(vector &a) { /* inicializuj vektor s kratkym polom */ a.size = 2; a.a = new dataType[a.size]; a.n = 0; } void add(vector &a, dataType x) { /* na koniec pola pridaj prvok x, zvacsi pole ak treba */ if (a.n == a.size) { /* treba zvacsovat */ dataType *nove = new dataType[a.size * 2]; /* prekopirujeme zo stareho do noveho */ for (int i = 0; i < a.n; i++) { nove[i] = a.a[i]; } /* zmazeme stare */ delete [] a.a; /* upravujeme premenne */ a.a = nove; a.size *= 2; } /* teraz uz je pole dost velke, staci ulozit x */ a.a[a.n] = x; a.n++; } dataType get(vector &a, int i) { /* vrat prvok v poli na pozicii i (s kontrolou i) */ assert(i >= 0 && i < a.n); return a.a[i]; } void set(vector &a, int i, dataType x) { /* na poziciu i uloz hodnotu x (s kontrolou i) */ assert(i >= 0 && i < a.n); a.a[i] = x; } void destroy(vector &a) { delete[] a.a; } int length(vector &a) { return a.n; }
Použitie vektora pri načítaní dát
- Vráťme sa k príkladu, kde sme načítavali desatinné čísla zo súboru až do konca súboru
- Vtedy sme priamo pri načítaní čísel menili veľkosť poľa
- Teraz vieme zapísať pomocou operácie add, oddelili sme prácu s alokovaním poľa a prácu so súborom
int main(void) { FILE *fr = fopen("vstup.txt", "r"); // otvorime vstupny subor vector a; // vytvorime a inicializujeme vektor a init(a); while (!feof(fr)) { // nacitavame prvky do vektora double hodnota; fscanf(fr, "%lf ", &hodnota); add(a, hodnota); } fclose(fr); // zavrieme vstupny subor double sucet = 0; // teraz pracujeme s a, napr. spocitame sucet prvkov vo vektore for (int i = 0; i < length(a); i++) { sucet += get(a, i); } printf("pocet: %d, sucet: %f\n", length(a), sucet); // vypise pocet prvkov a ich sucet na konzolu destroy(a); // uvolnime pamat vektora a }
Cvičenia 7
Čítanie programov
- Skúste zistiť bez použitia počítača, čo vypíše nasledujúca funkcia, ak ju spustíme ako generuj(a, pocet, 0, 2, 3), pričom polia a a pocet majú dĺžku n=3 a obe sú naplnené nulami. Funkcia vypis(a,n) vypíše prvky poľa a.
- Ako musíme funkciu opraviť, aby vypisovala všetky usporiadané n-tice čísel z množiny {0,...,n-1}, v ktorých sa každé číslo opakuje najviac k krát?
void generuj(int a[], int pocet[], int i, int k, int n) { if (i == n) { vypis(a, n); } else { for (int x = 0; x < n; x++) { if (pocet[x]<k) { a[i] = x; pocet[x]++; generuj(a, pocet, i + 1, k, n); } } } }
Valgrind
Nasledujúci program nesprávne odalokováva pamäť. Spustite ho v programe valgrind, mal by vám oznámiť dva problémy:
- Invalid free() / delete / delete[] / realloc() Čo to asi znamená? Na ktorom riadku programu je chyba?
- LEAK SUMMARY: definitely lost: 4 bytes in 1 blocks Čo to asi znamená? (memory leak je pamäť, ktorú sme neodalokovali a ku ktorej sa už nevieme dostať cez žiadnu premennú).
- Tento problém môžete bližšie preskúmať, ak spustíme valgrind takto: valgrind --leak-check=full cesta/meno_programu
- Mali by ste potom dostať hlášku typu 4 bytes in 1 blocks are definitely lost in loss record 1 of 1 s bližším určením, na ktorom mieste programu bola táto stratená pamäť alokovaná
int main(void) { int i; int *p = new int; int *q = new int; int *r = p; delete p; delete r; }
Triedenie kruhov
Na prednáške 12 sme mali program, ktorý od užívateľa načítal počet kruhov a potom pre každý kruh jeho súradnice a polomer. Jednotlivé kruhy alokuje dynamicky a smerníky na ne ukladá do poľa.
- Zmeňte tento program tak, aby poľe smerníkov bolo tiež alokované dynamicky, pričom bude mať dĺžku n, ktorú sme načítali od užívateľa
- Program ďalej zmeňte tak, aby kruhy utriedil podľa polomeru od najmenších po najväčšie a vypísal v tomto poradí na obrazovku.
- Môžete použiť niektoré rekurzívne triedenie z prednášky 11 alebo niektoré jednoduché triedenie z prednášky 6.
- Triediaca funkcia dostane pole smerníkov na kruhy a preusporiada tieto smerníky tak, aby kruhy, na ktoré ukazujú, išli v správnom poradí
- Vždy keď sa v triedení porovnávajú dva prvky poľa, porovná príslušné polomery kruhov, na ktoré tieto smerníky ukazujú.
Smerníky a typy
Majme nasledujúce definície premenných:
struct volaco { int x; int *y; }; volaco * a[3]; // pole 3 smernikov na volaco volaco v; volaco *p;
Akých typov sú nasledovné výrazy? (t.j. napr. do premennej akého typu by sme ich mohli priradiť?)
- *(p->y)
- &(v.x)
- &(a[2])
- p->y[p->x]
Skúste inicializovať premenné a, v a p (a príslušné časti structov volaco) tak, aby všetky tieto výrazy pracovali len s platnými miestami v pamäti.
Ešte valgrind a hľadanie chýb
Nasledujúci program by mal správne vypísať text "AhojAhojAhojAhoj", ale je v ňom zopár chýb. Skúste nájsť a opraviť chyby čítaním programu, použitím debugera, programu valgrind, prípadne si pridajte nejaké pomocné výpisy premenných.
#include <iostream> using namespace std; void opakuj(char kam[], char co[], char kolko) { /* Funkcia dostane na vstupe retazec co a cislo kolko a nakopiruje ho tolkokrat * za sebou do retazca kam. */ int i=0; // pozicia v kam for(int opakovanie=0; opakovanie<kolko; opakovanie++) { // opakuj kopirovanie for(int j=0; co[j]!=0; j++) { // prechod cez znaky retazca co kam[i] = co[j]; i++; } } } int main(void) { char ahoj[4] = {'A', 'h', 'o', 'j'}; char vysledok[16]; opakuj(vysledok, ahoj, 4); cout << vysledok << endl; }
DÚ6
Odovzdávanie DÚ6 a Odovzdávanie DÚ6 bonus max. 10 bodov + 5 bodov bonus, termín odovzdania pondelok 12.11. o 22:00
Napíšte program, ktorý od užívateľa načíta celé kladné čísla n a k a vypíše všetky spôsoby, ako zapísať číslo n ako súčin k kladných celých čísel. Napríklad ak n=100 a k=3, môžeme n zapísať napríklad ako 1 * 1 * 100 alebo 2 * 5 * 10 atď. Dodržujte formát výstupu z nasledujúceho príkladu:
Zadajte n a k: 100 3 100 = 1 * 1 * 100 100 = 1 * 2 * 50 100 = 1 * 4 * 25 100 = 1 * 5 * 20 100 = 1 * 10 * 10 100 = 2 * 2 * 25 100 = 2 * 5 * 10 100 = 4 * 5 * 5 Pocet vypisov: 8 Pocet volani: 38
Každá možnosť zápisu čísla n je teda na zvláštnom riadku, ktorý sa začína textom "n = " a pokračuje jednotlivými deliteľmi od najmenšieho po najväčší oddelenými reťazcom " * ". Jednotlivé možnosti môžete vypisovať v ľubovoľnom poradí, nemali by sa však opakovať ani by žiadna nemala chýbať. Za poslednou možnosťou vypíšte ešte počet vypísaných možností a počet rekurzívnych volaní funkcie generuj (počet rekurzívnych volaní sa môže líšiť v závislosti podľa presných detailov vašej implementácie).
Vaše riešenie dopíšte do kostry uvedenej nižšie na miesta označené VAS KOD TU. Pokiaľ možno sa držte tejto kostry, ak ju však potrebujte nutne meniť, vysvetlite svoje zmeny v komentároch. Ak chcete, môžete si naprogramovať a použiť ďalšie pomocné funkcie. Dodržte formát výstupu podľa príkladu vyššie.
Algoritmus: Rekurzívna funkcia generuj dostane v poli a vyplnených prvých i deliteľov čísla n a snaží sa vyplniť zvyšných k-i. V premennej zostava má číslo n vydelené prvými i deliteľmi. Napríklad v priebehu výpočtu pre náš príklad môžeme mať v a[0] vyplnené číslo 2 a zavolá sa generuj pre zostava=50, i=1. Pri skúšaní všetkých možností hodnôt pre aktuálne políčko a[i] dbajte na tieto tri podmienky:
- Do a[i] dosaďte len čísla, ktoré delia číslo zostava.
- Čísla vypĺňajte tak, aby boli v poli usporiadané od najmenšieho po najväčšie. Teda ak a[0]=2, do a[1] nebudeme skúšať dať 1.
- Do a[i] nedosadzujte príliš veľké čísla. Všetky zvyšné prvky v poli budú aspoň také veľké ako a[i], takže ak by sme do celého zvyšku poľa dosadili nejaké x a dostaneme príliš veľký súčin, nemá zmysel x a väčšie čísla do a[i] dosadzovať. Ak napr. ak v našom príklade a[0]=2 (a teda zostava=50), nebudeme do a[1] skúšať dosadiť hodnoty 8 a viac, lebo napr. a[1]=8 a a[2]=8 dáva súčin 64, čo už je viac ako naša momentálna hodnota zostava=50.
Poznámky:
- V programe sú dve globálne premenné pocetVypisov a pocetVolani. Dajte pozor, aby ste ich na správnych miestach menili.
- Pole a alokujte tak, aby malo potrebný počet prvkov v závislosti od vstupu a nezabudnite ho na konci uvoľniť.
Bonus: Upravte program tak, že ešte pred začiatkom rekurzívneho prehľadávania spočíta do nejakého poľa všetkých deliteľov čísla n od najmenšieho po najväčšie. Napríklad pre n=100 uloží do tohto poľa čísla 1,2,4,5,10,20,25,50,100. V rekurzii potom pri dosadzovaní do a[i] skúša len vhodnú podmnožinu prvkov z tohto poľa deliteľov (pozor, sú to delitele n, nemusia teda nutne deliť aj zostava, to treba otestovať). Dbajte na to, aby hodnoty dosadzované do a[i] spĺňali všetky tri podmienky uvedené v časti Algoritmus. Cieľom tejto zmeny je dosiahnuť určité zrýchlenie, lebo pri prehľadávaní zbytočne netestujeme čísla, ktoré nedelia číslo n a tým pádom nedelia ani zostava. Ak riešite bonus, odovzdajte zvlášť základnú verziu programu držiacu sa kostry a zvlášť bonus, kde kostru podľa potreby pomeňte. Bonus sa bude uznávať len tým, ktorí majú správne hlavnú časť úlohy.
#include <iostream> #include <cassert> #include <cmath> #include <cstring> using namespace std; /* Premenna pocetVypisov pocita, kolkokrat sa volala * funkcia vypis. */ int pocetVypisov = 0; /* Premenna pocetVolani pocita, kolkokrat sa volala * funkcia generuj. */ int pocetVolani = 0; void vypis(int a[], int k, int n) { /* Funkcia vypise cislo n ako sucin k cisel v poli a, pricom * dodrzi format zo zadania. */ // VAS KOD TU } void generuj(int n, int k, int zostava, int i, int a[]) { /* Funkcia do pola a rekurzivne generuje rozklad * cisla n na k delitelov, pricom tito su v poli * od najmensieho po najvacsi. Kazdy takyto rozklad vypise. * V poli je uz je prvych i delitelov (v neklesajucom poradi) * a hodnota zostava je n vydelene vsetkymi tymito delitelmi z pola. * Cielom je teda vsetkymi moznostami doplnit do pola a k-i delitelov * cisla zostava tak, aby cele pole bolo v neklesajucom poradi. */ assert(zostava>0 && zostava<=n && i>=0 && k>=i); // VAS KOD TU } int main(void) { int n, k; /* vstupne hodnoty */ int *a; /* pole s delitelmi */ /* nacitame n a k */ cout << "Zadajte n a k: "; cin >> n >> k; /* alokujeme pole a vhodnej velkosti */ // VAS KOD TU /* zavolame rekurzivne generovanie moznosti */ generuj(n, k, n, 0, a); /* vypiseme vysledok */ cout << "Pocet vypisov: " << pocetVypisov << endl; cout << "Pocet volani: " << pocetVolani << endl; /* uvolnime alokovanu pamat */ // VAS KOD TU }
Pokročilá DÚ3
Odovzdávanie DÚ max. 20 bodov + 4 body bonus, termín odovzdania pondelok 19.10. o 22:00
Cieľom tejto domácej úlohy je precvičiť si prácu so smerníkmi a spájanými zoznamami. Vašou úlohou bude implementovať dátovú štruktúru, ktorá spája hašovanie, spájané zoznamy a techniku move-to-front na dynamické presúvanie prvkov v spájanom zozname. Túto dátovú štruktúru potom použijeme na počítanie výskytov slov v súbore. Našim cieľom je implementovať asociatívne pole (slovník, map), v ktorom si pre každé slovo zo vstupného súboru pamätáme, koľkokrát sme ho už v súbore videli. V tejto úlohe potrebujete ovládať dátové štruktúry hašovacia tabuľka a spájaný zoznam. Budeme sa o nich učiť na prednáškach v týždni po 5.11. Viac si môžete prečítať v niektorej štandardnej učebnici algoritmov a dátových štruktúr (napr. kniha Sedgewick: Algorithms in C. Parts 1-4 v knižnici pod signatúrou I-INF-S-43/I-IV) prípadne v prednáškach 13 a 18 z minulého školského roku. Všetky dátové štruktúry si skúste naprogramovať sami, nekopírujte celé kusy kódu z internetu, prednášok, kníh alebo iných zdrojov (t.j. prečítajte si ako tieto štruktúry fungujú, ale potom si sadnite a skúste napísať príslušné časti programu sami, bez opisovania).
Dátová štruktúra
Naša dátová štruktúra má nasledovné zložky:
- Hašovaciu tabuľku veľkosti N. Každé políčko tabuľky obsahuje smerník na spájaný zoznam slov, ktoré hašovacia funkcia zobrazí do tohto políčka.
- Tento spájaný zoznam má v každom uzle uložené jedno slovo a počítadlo výskytov. Doporučujeme použiť obojsmerne spájaný zoznam, aby sa v ňom ľahšie menilo poradie prvkov.
Program teda vždy načíta jedno slovo zo vstupu a spracuje ho nasledovným postupom:
- hašovacou funkciou uvedenou nižšie spočíta jeho index h v hašovacej tabuľke
- prehľadáva spájaný zoznam uložený v políčku h, až kým nenájde záznam pre toto slovo alebo neprejde celý zoznam
- ak slovo nebolo nájdené v zozname, pridá pre neho uzol na začiatok zoznamu
- ak slovo bolo nájdené v zozname, zvýši mu počítadlo a presunie ho na začiatok zoznamu
- tento presun sa volá move-to-front a spôsobí to, že ak sa niektoré slovo v zozname vyskytuje v súbore často, bude sa nachádzať blízko pri začiatku zoznamu a teda ho pri ďalšom hľadaní rýchlejšie nájdeme
- napríklad ak máme v zozname pre nejaké políčko slová wandered, zigzag, was, field a hľadáme slovo was, zastavíme sa na treťom uzle zoznamu a tento uzol presunieme na začiatok, takže budeme mať zoznam was, wandered, zigzag, field
Použite túto hašovaciu funkciu (nemeňte počítanú hodnotu, ale ak chcete, môžete si ju prerobiť tak, aby namiesto C-čkového reťazca pracovala s typom string z C++):
int hashFunction(char str[], int N) { // Funkcia dostane vstupny retazec str a velkost hashovacej tabulky N. // Vrati cislo medzi 0 a N-1 const int seed = 2012; const int L = 5; const int R = 2; unsigned int h = seed; char *c = str; while (*c) { h = h ^ ((h << L) + (h >> R) + *c); c++; } h = h % N; return h; }
Vstup a výstup
Váš program by mal načítavať vstup zo súboru vstup.txt a vypisovať výstup do súboru vystup.txt, pričom dodržujte mená a formát súborov. Ak potrebujete, na obrazovku si môžete vypísať pomocné výpisy v ľubovoľnom formáte. Vo vstupnom súbore budeme za slovo považovať neprázdnu postupnosť písmen anglickej abecedy oddelenú od iných slov jedným alebo viacerými oddeľovacími znakmi. Všetky znaky okrem písmen (biele znaky, interpunkcia, čísla, špeciálne znaky, znaky s diakritikou...) považujte sa oddeľovače slov. Pri čítaní vstupného súboru preveďte všetky veľké písmená na malé (funkciou tolower). Do výstupného súboru vypíšte všetky slová zo vstupného súboru, každé na jednom riadku a za ním medzeru a počet jeho výskytov. Slová môžete vypisovať v ľubovoľnom poradí.
Príklad: vstup.txt:
ahoj svet! Ahoj123svet, HELLO world.
vystup.txt:
ahoj 2 world 1 hello 1 svet 2
Meranie času výpočtu, nastavenia programu, odovzdávanie
Výsledný program spustite na vstupnom súbore, ktorý nájdete tu (obsahuje text knihy Alice's Adventures in Wonderland od Lewisa Carrolla). Chceli by sme porovnať čas výpočtu programu pre rôzne nastavenia veľkosti hašovacej tabuľky N. Ak pracujete v Linuxe, čas programu môžete merať príkazom time -p, napr. time -p NetBeansProjects/pdu3/dist/Debug/GNU-Linux-x86/pdu3 vypíše
real 0.03 user 0.01 sys 0.01
My budeme uvažovať druhé z vypísaných čísel (user), čo je čas výpočtu v sekundách okrem systémových volaní súvisiacich napríklad s čítaním súboru. Ako vidíme, tento čas je veľmi malý a môže byť problém ho zmerať presne. Preto celý výpočet (načítavanie súboru a ukladanie do tabuľky aj vypisovanie výsledku) opakujte K krát pre vhodne zvolené K tak, aby program bežal aspoň rádovo niekoľko sekúnd. Aby sa Vám experimenty dobre robili, váš program by mal hodnoty K a N dostať ako argumenty z príkazového riadku, pomocou parametrov argc a argv vo funkcii main (o týchto parametroch si môžete prečítať v prednáške z minulého roku). Presnejšie, váš program dostane tri parametre: číslo K, číslo N a reťazec určujúci štruktúru na asociatívne pole. Ak neriešite bonus, môžete tento parameter ignorovať. Váš program budete teda spúšťať napríklad takto: time -p NetBeansProjects/pdu3/dist/Debug/GNU-Linux-x86/pdu3 100 1000 mtf, čo znamená K=100, N=1000 a implementácia mtf. V programe budete potrebovať previesť parametre K a N na číslo, na čo môžete použiť napr funkciou sscanf z knižnice cstdio.
Takto upravený program spustite na súbore uvedenom vyššie pre vhodné K a hodnoty N=10,100,1000 a 10000. Pre každé N spustite program 5 krát, zapíšte si namerané časy a spočítajte ich priemer. Snažte sa robiť všetky experimenty za porovnateľných podmienok (ten istý počítač, približne rovnaká záťaž z iných programov, to isté K).
V Moodli odovzdajte
- zdrojový kód programu (.cpp). Ak robíte bonus, odovzdajte hlavnú aj bonusovú časť v jednom programe.
- súbor opisujúci výsledky vašich meraní vo formáte .pdf alebo .txt. V tomto súbore uveďte prehľadne namerané časy a ich priemery. Krátko skomentujte, čo z vašich meraní usudzujete (ktorá hodnota N je najlepšia, či vôbec záleží na N, v prípade bonusu aj ako sa porovnajú rôzne metódy).
Bonus
Okrem vyššie uvedenej dátovej štruktúry riešte úlohu aj nasledujúcimi spôsobmi:
- použite takú istú hašovaciu tabuľku so spájanými zoznamami, ale po nájdení prvku ho nechajte na tom istom mieste, nepresúvajte ho na začiatok zoznamu
- namiesto hašovacej tabuľky použite dátovú štruktúru map <string, int> z knižnice map, kde si pre každé slovo uložené v C++ type string ukladáte počet jeho výskytov. Viac o použití štruktúry map nájdete tu alebo tu.
Tretí argument vášho programu určuje, ktorá z týchto metód sa použije. Pre základnú verziu úlohy je to reťazec mtf, pre hašovanie bez presúvania prvkov je to hash a pre štandardný map je to reťazec map. Pre map ignorujte parameter N. Spustite program aj s týmito novými nastaveniami a uveďte namerané časy, porovnajte s pôvodnými výsledkymi zo základnej časti úlohy.
Prednáška 15
Opakovanie smerníkov
Smerníky na jednoduché premenné:
int a = 7; /* premenna typu int */ int *b = NULL; /* smernik na premennu typu int */ b = &a; /* b ukazuje na a */ *b = 8; /* v premennej a je teraz 8 */ a = (*b)+1; /* v premennej a je teraz 9 */
Smerníky na structy:
struct bod { int x,y; }; bod *p; /* smernik na structuru typu bod */ p = new bod; /* alokovanie noveho bodu */ p->x = 10; /* dve formy priradovania do sucasti structu */ (*p).y = 20; delete p; /* uvoľníme alokovanú pamäť */
Smerníky a polia, alokovanie poľa:
int a[3]; int *b = a; /* a,b su teraz takmer rovnocenne premenne */ *b = 3; b[1] = 4; a[2] = 5; /* v poli sú teraz čísla 3,4,5 */ b = new int[a[1]]; /* b teraz ukazuje na nove pole dlzky 4 */ delete[] b; /* uvoľníme pamäť alokovanú pre nové pole */
Smerníková aritmetika
- Pole je vlastne smerník na svoj prvý prvok
- Majme napr. pole int a[4] = {4, 3, 2, 1};
- K i-temu prvku sa vieme dostať pomocou a[i]
- Dá sa to však napísať aj ako *(a+i)
- Konkrétne a+i je smerník na i-ty prvok poľa a
- Kompilátor spočíta veľkosť jedného políčka poľa, takže vie, ako ďaleko sa posunúť, aby sa dostal na i-te políčko
- int *b = a+2 vytvorí smerník na a[2], ale k b sa môžeme správať ako ku dvojprvkovému poľu {2, 1}
Smerníková aritmetika:
- smerník + n: Posun smerníka o n. Ak napríklad smerník ukazuje na 0. prvok poľa, smerník + n bude ukazovať na n-tý prvok poľa.
- Ak chceme zvýšiť smerník o 1 môžeme použiť smerník++.
- smerník - n: Posun smerníka o n prvkov smerom k začiatku.
- smerník1 - smerník2: Výsledkom rozdielu smerníkov je vzdialenosť miest na ktoré ukazujú. Ak napríklad prvý smerník ukazuje na 5. prvok poľa a druhý smerník na 3. prvok poľa ich rozdiel je 2. Smerníky musia patriť do toho istého poľa, inak bude výsledok nedefinovaný.
Porovnávanie ukazovateľov:
- operátory: < <= > >= == !=
- porovnávanie má zmysel len keď ukazovatele:
- sú rovnakého typu
- ukazujú do toho istého poľa
Tu je napr. zvláštny spôsob ako vypísať pole a definované vyššie:
for (int *smernik = a; smernik < a + 4; smernik++) { cout << "Prvok " << smernik - a << " je " << *smernik << endl; }
Podobný kód sa ale občas používa na prechádzanie reťazcov, napr. ak chceme zrátať počet medzier v reťazci:
int zratajMedzery(char str[]) { // mohli by sme dat aj char *str int pocet = 0; while(*str != 0) { // kym nenajdeme ukoncovaciu nulu v retazci if(*str==' ') { pocet++; } // skontroluj znak, na ktory ukazuje smernik str++; // posun smernik na dalsi znak } return pocet; }
Funkcie z knižnice cstring s reťazcovou aritmetikou
- strstr(text, vzorka) vracia smerník na char
- NULL ak sa vzorka nenachádza v texte, smerník na začiatok prvého výskytu inak
- pozíciu výskytu zistíme smerníkovou aritmetikou:
char *text, *vzorka; char *where = strstr(text, vzorka); if(where != NULL) { int position = where - text; }
- Ako by ste spočítali počet výskytov vzorky v texte?
- Podobne strchr hľadá prvý výskyt znaku v texte
Sizeof()
Operátor sizeof() zistí "veľkosť" dátového typu v bajtoch
- napr. pri struct sa nemusí jednať o súčet veľkostí
- presnejšie ide o vzdialenosť medzi nasledujúcimi prvkami poľa -- teda o koľko sa posunieme pri posune +1 v smerníkovej aritmetike
int i, *pi; sizeof(*pi); //počet bajtov potrebných na uloženie typu int sizeof(i); // da sa napisat aj takto sizeof(int); // alebo takto sizeof(pi); // pocet bajtov na ulozenie smernika na int sizeof(int *); // to iste
Dvojrozmerné polia
- Doteraz sme stále pracovali s jednorozmerným poľom, čo však ak potrebujeme dvojrozmerné pole, maticu?
- Spravme teraz maticu s n=10 riadkami a m=20 stĺpcami
- Spravíme si pole n jednorozmerných polí, t.j. pole smerníkov na int: int *a[n];
- Naalokujeme si n jednorozmerných polí veľkosti m a smerník na každé uložíme do jedného prvku poľa a
const int n = 10; const int m = 20; int *a[n]; for (int i = 0; i < n; i++) { a[i] = new int[m]; }
Prvok v i-tom riadku a j-tom stĺpci dostaneme jedným z týchto spôsobov:
- a[i][j]
- *(*(a+i)+j)
Tu je kód, ktorý vynuluje pole:
for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { a[i][j] = 0; } }
Na konci sa patrí pamäť uvoľniť:
for (int i = 0; i < n; i++) { delete[] a[i]; }
Dynamicky alokovaná matica
Ak chceme n a m určiť dynamicky, napr. načítať ich zo súboru, musíme aj pole a alokovať pomocou new a nakoniec uvoľniť pomocou delete[]:
#include <cstdio> using namespace std; int main(void) { int n, m; scanf("%d %d,&n,&m); // nacitame n a m int **a; // alokujeme maticu nxm a = new int *[n]; for (int i = 0; i < n; i++) { a[i] = new int[m]; } for (int i = 0; i < n; i++) { // pracujeme s maticou, napr. vynulujeme ju for (int j = 0; j < m; j++) { a[i][j] = 0; } } for (int i = 0; i < n; i++) { // na konci uvolnime pamat delete[] a[i]; } delete[] a; }
Funkcie pre alokáciu matice
Na alokáciu a dealokáciu matice si napíšeme funkcie, môžu sa nám hodiť:
int ** vytvorMaticu(int n, int m) { /* vytvor maticu s n riadkami a m stlpcami */ int **a; a = new int *[n]; for (int i = 0; i < n; i++) { a[i] = new int[m]; } return a; }
void zmazMaticu(int n, int m, int **a) { /* uvolni pamat matice s n riadkami a m stlpcami */ for (int i = 0; i < n; i++) { delete[] a[i]; } delete[] a; }
void nacitajMaticu(FILE *f, int n, int m, int **a) { /* matica je vytvorena, velkosti n, m, vyplnime ju cislami zo vstupu */ for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { fscanf(f, "%d", &a[i][j]); } } }
Všimnite si, že všetkým funkciám dávame aj rozmery matice. Namiesto toho by sme si mohli spraviť štruktúru podobne ako pri vektore:
struct matica { int n, m; int **a; }
Výšková mapa
V matici môžeme mať danú napr. mapu:
- 0 znamené more
- kladné číslo znamená pevninu a udáva nadmorskú výšku (napr. v metroch)
Táto reprezentácia neumožňuje zapísať pevninu pod úrovňou mora.
Pomocou funkcií vyššie môžeme takúto mapu načítať zo súboru a môžeme spraviť napr. program, ktorý zobrazí more modrou a pevninou odtieňami zelenej a hnedej podľa nadmorskej výšky. Príklad matice a obrázku:
22 11 0 0 0 0 0 0 0 0 0 0 0 0 20 40 60 80 100 120 140 120 0 0 0 40 80 120 160 200 240 280 190 100 0 0 60 120 180 240 300 360 420 260 100 0 0 80 160 240 320 400 480 560 260 100 0 0 100 200 300 400 500 600 700 330 100 0 0 120 240 360 480 600 720 840 400 100 0 0 140 280 420 560 700 840 980 470 100 0 0 160 320 480 640 800 960 700 200 0 0 0 180 360 540 720 900 700 500 0 0 0 0 200 400 600 800 1000 1200 1400 680 100 0 0 220 440 660 880 1100 1320 1540 750 100 0 0 240 480 720 960 1200 1440 1680 820 100 0 0 260 520 780 1040 1300 1560 1820 1200 400 0 0 280 560 840 1120 1400 1680 1960 1500 600 0 0 240 480 720 960 1200 1440 1680 1000 400 0 0 200 400 600 800 1000 1200 1400 680 100 0 0 160 320 480 640 800 960 1120 540 100 0 0 120 240 360 480 600 720 840 400 100 0 0 80 160 240 320 400 480 560 260 100 0 0 40 80 120 160 200 240 280 120 0 0 0 0 0 0 0 0 0 0 0 0 0
Okrem zobrazovania môžeme chcieť napríklad nájsť polohu najvyššieho vrchu a zobraziť ho v čiernom rámčeku, ako na obrázku vyššie.
- Čo spraví funkcia, ak je celá mapa pokrytá morom?
void najvyssiVrch(int n, int m, int **a, int &riadok, int &stlpec) { /* najdi polohu najvyssej hodnoty v matici */ riadok = 0; stlpec = 0; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if(a[i][j]>a[riadok][stlpec]) { riadok = i; stlpec = j; } } } }
Príklad hlavného programu, ktorý hľadá najvyšší vrch.
int main(void) { /* nacitaj rozmery matice */ int n, m; scanf("%d %d", &n, &m); /* vytvor a nacitaj maticu */ int **a = vytvorMaticu(n, m); nacitajMaticu(cin, n, m, a); /* najdi najvyssi vrch */ int riadok, stlpec; najvyssiVrch(n, m, a, riadok, stlpec); /* uvolni pamat matice */ zmazMaticu(n, m, a); }
Zdrojový kód celého programu
- Tento program načíta maticu, nájde najvyšší vrch a vykreslí obrázok: #Program mapa pre prednášku 15
Hra life
Hra life je jednoduchá simulácia kolónie buniek, ktorá má zaujímavé teoretické vlastnosti.
- Máme mriežku m x n štvorčekov, v každom žije najviac 1 bunka
- Bunky sa rodia a umierajú podľa toho, koľko majú susedov v ôsmych okolitých políčkach
- Ak v čase t má bunka 2 alebo 3 susedov, zostane žiť aj v čase t+1, inak zomiera
- Ak v čase t má prázden políčko presne 3 susedov, narodí sa tam v čase t+1 nová bunka
Stav hry si môžeme pamätať v matici boolovských hodnôt.
Rátanie zmeny v matici
- Stav v čase t máme v matici a, do matice b chceme dať stav v čase t+1
int zratajOkolie(int n, int m, bool **a, int riadok, int stlpec) { /* pocet zivych prvkov v okoli */ int sucet = 0; for (int i = riadok - 1; i <= riadok + 1; i++) { for (int j = stlpec - 1; j <= stlpec + 1; j++) { /* treba osetrit okraje matice */ if (i >= 0 && i < n && j >= 0 && j < m && a[i][j]) { sucet++; } } } /* samotny stvorcek nechceme zaratat */ if (a[riadok][stlpec]) { sucet--; } return sucet; } void prepocitajMaticu(int n, int m, bool **a, bool **b) { for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { int pocet = zratajOkolie(n, m, a, i, j); /* prirad do b[i][j] hodnotu podla okolia a[i][j] */ b[i][j] = (pocet == 3 || (pocet == 2 && a[i][j])); } } }
Hlavný program
- Prepočítavanie chceme opakovať v cykle pre viacero časových intervalov
- Môžeme prekopírovať celú maticu z b späť do a, ale rýchlejšie je len vymeniť smerníky
for (int i = 0; i < 10; i++) { /* podla a spocitaj maticu do b */ prepocitajMaticu(n, m, a, b); /* vymen smerniky, aby v a bola nova matica */ bool **tmp = b; b = a; a = tmp; }
- vytvorMaticu, zmazMaticu a pod. prepíšeme tak, aby robili s maticou boolovských hodnôt namiesto intov
int main(void) { /* nacitaj rozmery matice */ int n, m; scanf("%d %d", &n, &m); /* vytvor a nacitaj maticu */ bool **a = vytvorMaticu(n, m); nacitajMaticu(stdin, n, m, a); /* zobraz maticu */ SimpleDraw window(m*stvorcek, n * stvorcek); zobrazMaticu(n, m, a, window); window.wait(2); /* pomocna matica na vypocty */ bool **b = vytvorMaticu(n, m); /* simuluj 10 krokov hry life */ for (int i = 0; i < 10; i++) { /* podla a spocitaj maticu do b */ prepocitajMaticu(n, m, a, b); /* prekresli, co sa zmenilo */ zobrazZmeny(n, m, a, b, window); window.wait(2); /* vymen smerniky, aby v a bola nova matica */ bool **tmp = b; b = a; a = tmp; } /* uvolni pamat matic */ zmazMaticu(n, m, a); zmazMaticu(n, m, b); }
Detaily vykresľovania
- Na začiatku vykreslíme celú maticu, potom prekreslíme vždy len tie bunky, ktoré sa zmenili
void zobrazStvorcek(int i, int j, bool hodnota, SimpleDraw &window) { /* zobraz stvorcek v riadku i a stlpci j */ window.setPenColor("white"); if (hodnota) { window.setBrushColor("black"); } else { window.setBrushColor("white"); } window.drawRectangle(j*stvorcek, i*stvorcek, stvorcek, stvorcek); } void zobrazMaticu(int n, int m, bool **a, SimpleDraw &window) { /* zobraz prvky true ciernymi stvorcekmi */ for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { /* nastavenie farby podla hodnoty */ if (a[i][j]) { zobrazStvorcek(i, j, true, window); } } } } void zobrazZmeny(int n, int m, bool **a, bool **b, SimpleDraw &window) { /* zobraz nove stvorceky na miestach, kde bola zmena */ for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (a[i][j] != b[i][j]) zobrazStvorcek(i, j, b[i][j], window); } } }
Príklad vstupu
- Pre jednoduchosť vstup uvádzame ako nuly a jednotky bez medzier (1=živá bunka)
20 20 00000000000000000000 00000000000000000000 00000000000000000000 00000000000000000000 00000000000000000000 00000000000000000000 00000000000000000000 00000000000000000000 00000000000000000000 00000111111111100000 00000000000000000000 00000000000000000000 00000000000000000000 00000000000000000000 00000000000000000000 00000000000000000000 00000000000000000000 00000000000000000000 00000000000000000000 00000000000000000000
Zdrojový kód celého programu
- Tento program načíta vstup a simuluje 10 krokov hry Life: #Program life pre prednášku 15
Pole reťazcov
Dvojrozmerné polia v C/C++ nemusia mať všetky riadky rovnako dlhé.
- Spomeňte si, že v C je reťazec jednoducho pole char-ov, kde za posledným znakom ide špeciálny znak 0
- Pole reťazcov bude teda dvojrozmerné pole char-ov
- Môžeme načítavať napr. súbor po riadkoch, pričom každý riadok načítame do dlhého poľa, ktoré by malo stačiť a potom do prekopírujeme do akurát veľkého riadku v poli
- Nakoniec program riadky vypíše odzadu
- Ak by sme vopred alokovali maxN riadkov, každý veľkosti maxRiadok, vyšlo by potenciálne na zmar oveľa viac pamäte.
#include <cstdio> #include <string.h> using namespace std; const int maxRiadok = 1000; const int maxN = 1000; int main(void) { char *a[maxN]; char riadok[maxRiadok]; int n = 0; while (true) { if (!fgets(riadok, maxRiadok,stdin)) break; a[n] = new char[strlen(riadok)+1]; strcpy(a[n], riadok); n++; if (feof(stdin)) break; } for(int i=n-1; i>=0; i--) { printf("%s", a[i]); } }
Program mapa pre prednášku 15
/* Program Mapa z prednášky 15. http://compbio.fmph.uniba.sk/vyuka/prog/index.php/Predn%C3%A1%C5%A1ka_15 */ #include "../SimpleDraw.h" #include <cstdio> /* velkost stvorceka mapy v pixeloch */ const int stvorcek = 15; int ** vytvorMaticu(int n, int m) { /* vytvor maticu s n riadkami a m stlpcami */ int **a; a = new int *[n]; for (int i = 0; i < n; i++) { a[i] = new int[m]; } return a; } void zmazMaticu(int n, int m, int **a) { /* uvolni pamat matice s n riadkami a m stlpcami */ for (int i = 0; i < n; i++) { delete[] a[i]; } delete[] a; } void nacitajMaticu(FILE *f, int n, int m, int **a) { /* matica je vytvorena, velkosti n, m, vyplnime ju cislami zo vstupu */ for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { fscanf(f, "%d", &a[i][j]); } } } void farba(SimpleDraw &window, int r, int g, int b) { /* nastav farbu ciary aj vyplne na dane hodnoty */ window.setBrushColor(r, g, b); window.setPenColor(r, g, b); } void zobrazMaticu(int n, int m, int **a, SimpleDraw &window) { /* zobraz maticu farebnymi stvorcekmi : * modra: more (hodnota 0) * zelena: niziny 1..200, * hneda: pohoria 200..2000 */ for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { /* nastavenie farby podla hodnoty */ if (a[i][j] == 0) { farba(window, 0, 0, 255); } else if (a[i][j] <= 200) { double x = a[i][j] / 200.0; farba(window, x * 255, 127 + x * 127, 0); } else { double x = (a[i][j] - 200) / 2000.0; farba(window, 255 - x * 150, 255 - x * 200, 0); } /* vykresleni stvorceka, pozor: vymena suradnic */ window.drawRectangle(j*stvorcek, i*stvorcek, stvorcek, stvorcek); } } } void najvyssiVrch(int n, int m, int **a, int &riadok, int &stlpec) { /* najdi polohu najvyssej hodnoty v matici */ riadok = 0; stlpec = 0; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if(a[i][j]>a[riadok][stlpec]) { riadok = i; stlpec = j; } } } } int main(void) { /* nacitaj rozmery matice */ int n, m; scanf("%d %d", &n, &m); //22 11 /* vytvor a nacitaj maticu */ int **a = vytvorMaticu(n, m); nacitajMaticu(stdin, n, m, a); /* zobraz maticu */ SimpleDraw window(m*stvorcek, n * stvorcek); zobrazMaticu(n, m, a, window); /* najdi najvyssi vrch a zobraz ho stvorcekom */ int riadok, stlpec; najvyssiVrch(n, m, a, riadok, stlpec); window.unsetBrush(); window.setPenColor("black"); window.drawRectangle(stlpec*stvorcek, riadok*stvorcek, stvorcek, stvorcek); /* zobraz okno */ window.showAndClose(); /* uvolni pamat matice */ zmazMaticu(n, m, a); }
Program life pre prednášku 15
/* Program Hra Life z prednášky 15. http://compbio.fmph.uniba.sk/vyuka/prog/index.php/Predn%C3%A1%C5%A1ka_15 */ #include "../SimpleDraw.h" #include <string> #include<cstdio> #include <cassert> using namespace std; /* velkost stvorceka */ const int stvorcek = 15; bool ** vytvorMaticu(int n, int m) { /* vytvor maticu s n riadkami a m stlpcami */ bool **a; a = new bool *[n]; for (int i = 0; i < n; i++) { a[i] = new bool[m]; } return a; } void zmazMaticu(int n, int m, bool **a) { /* uvolni pamat matice s n riadkami a m stlpcami */ for (int i = 0; i < n; i++) { delete[] a[i]; } delete[] a; } void nacitajMaticu(FILE *f, int n, int m, bool **a) { /* matica je vytvorena, velkosti n, m, vyplnime ju cislami zo vstupu */ for (int i = 0; i < n; i++) { char riadok[100]; fscanf(f,"%s",riadok); assert(strlen(riadok) == m); for (int j = 0; j < m; j++) { a[i][j] = (riadok[j] == '1'); } } } void zobrazStvorcek(int i, int j, bool hodnota, SimpleDraw &window) { /* zobraz stvorcek v riadku i a stlpci j */ window.setPenColor("white"); if (hodnota) { window.setBrushColor("black"); } else { window.setBrushColor("white"); } window.drawRectangle(j*stvorcek, i*stvorcek, stvorcek, stvorcek); } void zobrazMaticu(int n, int m, bool **a, SimpleDraw &window) { /* zobraz prvky true ciernymi stvorcekmi */ for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { /* nastavenie farby podla hodnoty */ if (a[i][j]) { zobrazStvorcek(i, j, true, window); } } } }
Prednáška 16
Dynamická alokácia poľa a matice, opakovanie
- 1D pole: int *a = new int[n]; cin >> a[0];
- 2D pole: int **a = new int * [n]; for(int i=0; i<n; i++) a[i] = new int[m]; cin >> a[0][1];
- Riadky 2D poľa nemusia byť rovnako dlhé
- 3D pole: int ***a = new int ** [n]; ...
Vstupy do funkcie main
- Netbeans vám vyrobí main funkciu s nasledujúcou hlavičkou:
int main(int argc, char** argv) {
- char **argv je pole C-čkových reťazcov a argc je počet reťazcov v tomto poli
- Prvý z nich, argv[0], je meno samotného programu a ostatné sú argumenty programu
- Užitočné, ak spúšťame program z príkazového riadku
- Dá sa nastaviť v Netbeans, Properties, Run
- Tento program jednoducho argumenty vypíše
#include <iostream> using namespace std; int main(int argc, char** argv) { for (int i = 0; i < argc; i++) { cout << argv[i] << endl; } }
Smerníkové kuriozity
int *a[3]; /* pole 3 smerníkov na int */ int (*b)[3]; /* jeden smerník na pole troch intov, neinicializovaný */ int c[3] = {0,1,2}; /* pole troch intov */ b = &c; /* teraz b ukazuje na pole c */ cout << (*b)[2] << endl; /* pristup k prvku 2 pola c */ cout << *b[2] << endl; /* zle: tvarime sa, ze b je pole, pristupime k jeho prvku 2 a interpretujeme ho ako smernik */
Spájaný zoznam
Ak niekde chceme uložiť N prvkov, doteraz sme videli nasledujúce možnosti:
- Vytvoriť pole pevnej veľkosti N, ak je N vopred známa konštanta: const int N = 100; int A[N];
- Vytvoriť veľké pole, ktoré dúfame bude stačiť, časť z neho môže nepoužitá: const int maxN = 100; int A[maxN];
- Dynamicky alokovať pole N prvkov, ak N je číslo spočítané niekde v programe alebo načítané zo súboru: int *A = new int[N];
- Pomocou new vieme naprogramovať aj štruktúru vector, do ktorej môžeme postupne pridávať prvky, aj keď vopred nevieme N
Teraz si ukážeme ďalší spôsob, ako si prvky ukladať, keď vopred nevieme ich počet
Štruktúra jednoduchého spájaného zoznamu
Spájaný zoznam (linked list) je postupnosť uzlov rovnakého typu usporiadaných za sebou.
Každý uzol pozostáva z dvoch častí:
- smerník, ktorý ukazuje na nasledovníka a pomáha nám sa pohybovať po zozname
- samotné dáta, v našom prípade pre jednoduchosť int
Uzol spájaného zoznamu je teda pre naše účely nasledovného typu:
struct item { int data; item* next; };
Všimnite si, že vo vnútri definície typu item používame smerník na item.
Na rozdiel od poľa, v ktorom je poradie stanovené indexmi, je teda poradie v spájanom zozname určované ukazovateľmi next. Ak x je prvok zoznamu, tak x.next je
- nasledujúci prvok zoznamu
- NULL (ak x je posledným prvkom zoznamu)
Samotný typ linkedList reprezentujúci celý zoznam si potrebuje pamätať smerník na úvodný prvok:
struct linkedList { item* first; };
Pre prázdny zoznam z bude z.first rovné NULL.
Inicializácia zoznamu je teda veľmi jednoduchá:
void init(linkedList &z){ z.first = NULL; } int main(void){ linkedList z; init(z); }
Tiež vieme veľmi jednoducho určiť, či je zoznam prázdny:
bool empty(const linkedList &z){ if (!z.first) return true; // resp. (z.first == NULL) else return false; }
Vkladanie a vymazanie na začiatku
Na to, aby sme zoznam nejakým spôsobom naplnili, potrebujeme vedieť vôbec vytvoriť prvok zoznamu. To robíme dynamicky nasledovne:
item* p=new item; p->data=NEJAKE_DATA; p->next=NEJAKY_SMERNIK_NIEKAM;
Teda vytvoríme si smerník na uzol zoznamu, vyhradíme mu patričný kus pamäte a naplníme ho vhodnými dátami.
Môžeme si teda skúsiť vytvoriť zoznam z, ktorý bude mať 3 prvky 1,2 a 3.
linkedList z; item* p=new item; item* q=new item; item* r=new item; p->data = 1; q->data = 2; r->data = 3; p->next = q; q->next = r; r->next = NULL; z.first = p;
Pravdepodobne nechceme vytvárať zoznam ako v príklade a potrebujeme teda funkciu na vloženie prvku. Najjednoduchšia možnosť je vkladanie na začiatok zoznamu. Samozrejme prvku budeme musieť vhodne nastaviť jeho smerník next a asi aj nejaké smerníky v zozname.
void insertFirst(linkedList &z, int d){ /* do zoznamu z vlozi na zaciatok novy prvok s datami d */ item* p = new item; // vytvoríme nový prvok p->data = d; // naplníme dáta p->next = z.first; // prvok bude prvým prvkom zoznamu (ukazuje na doterajší začiatok) z.first = p; // tento prvok je novým začiatkom }
Pre vymazanie prvého prvku postupujeme podobne, len nesmieme zabudnúť okrem presmerovania začiatku aj uvoľniť pamäť pôvodne prvého prvku. Funkcia deleteFirst vráti hodnotu prvého prvku a tento prvok vymaže.
int deleteFirst(linkedList &z){ /* zo zoznamu z vymaze prvy prvok a vrati jeho data */ assert(z.first != NULL); // nemozeme mazat, ak je zoznam prazdny item* p = z.first; // prvok, ktorý ideme vymazat int d = z.first->data; // to čo máme vrátiť z.first = z.first->next; // presmerujeme zoznam na novy zaciatok delete p; // uvoľnenie pamäte return d; }
Prechádzanie zoznamu
Veľmi dôležité je vedieť zoznamom prechádzať a postupne pracovať s jeho prvkami. Prechádzanie zoznamom je potrebné napríklad pre hľadanie konkrétneho prvku, hľadanie najväčšieho prvku, vypisovanie všetkých prvkov zoznamu atď
Ako budeme postupovať?
- Vytvoríme si smerník na prvky zoznamu x.
- Začneme prvým prvkom zoznamu. Na ten nám ukazuje smerník z.first.
- Kým x nebude na konci zoznamu (t.j. nebude NULL), vypíšeme patričné dáta (x->data) a presunieme sa na ďalší prvok (x->next)
- Vo chvíli keď je x NULL znamená to, že ďalší prvok už nie je (a je jedno, či sa to stalo hneď na začiatku - t.j. že z.first je NULL - alebo neskôr)
void print(linkedList &z){ item* x = z.first; while (x != NULL){ printf(" %d", x->data); x = x->next; } printf("\n"); }
Prejsť celý zoznam potrebujeme aj v prípade, že chcem uvoľniť pamäť (na konci programu).
void destroy(linkedList &z){ while (z.first != NULL){ item* p = z.first; z.first = z.first->next; delete p; } }
Dá sa to aj funkciami, ktoré sme si už napísali:
void destroy(linkedList &z){ while (!empty(z)){ deleteFirst(z); } }
Alebo rekurzívne:
void destroy(item *p) { if(p!=NULL) { destroy(p->next); delete p; } } void destroy(linkedList &z){ destroy(z.first); }
Utriedený zoznam
Občas sa nám hodí, aby sme si zoznam udržiavali utriedený. Vkladanie doprostred zoznamu (pred nejaký prvok) ale môže spôsobiť niekoľko špeciálnych prípadov, ktoré potrebujeme ošetriť.
Keď chceme vkladať pred prvok x, potrebujeme totiž meniť jeho predchodcu, teda prvok, ktorý pôvodne ukazoval na x. Po vložení už nemá ukazovať na x, ale na novo vložený prvok. Preto potrebujeme celú dobu hľadania vhodného miesta pamätať na to, že predchodca je potrebný a niekde si ho pamätať.
Rozlišujeme teda 3 prípady:
- Zoznam je prázdny - vytvoríme prvok, naplníme dátami, nemá nasledovníka a je novým začiatkom
- Chceme vložiť na začiatok zoznamu - vytvoríme prvok, naplníme dátami, nasledovník je pôvodný začiatok a on je nový začiatok
- Ostatné prípady - nájdeme miesto, s tým, že sme o krok pozadu (teda všetko riešime z pozície predchodcu), vytvoríme prvok a upravíme
void insert(linkedList& z, int data) { item* p = new item; p->data=data; // máme prázdny zoznam alebo vkladáme pred prvý prvok if (z.first==NULL || data < z.first->data) { p->next= z.first; z.first = p; return; } //prvok nepatrí na začiatok item* prev = z.first; while ((prev->next != NULL) && (prev->next->data < data)){ prev = prev->next; } p->next = prev->next; prev->next = p; }
Riešenie ako je popísané je správne, avšak je náročné na napísanie, aby sme vyriešili špeciálne prípady. Tu sú dve možné riešenia, ako sa takýmto prípadom vyhnúť:
Použitie zarážky (sentinel node): pridáme špeciálny uzol na začiatok (v niektorých prípadoch aj na koniec) zoznamu, pričom hodnotu jeho kľúča nepoužívame.
- prázdny zoznam teda obsahuje iba zarážku
- každý uzol má predchodcu a každý zoznam má prvý uzol
- vkladanie na začiatok znamená vložiť za zarážku
- nikdy nemažeme úplne prvý prvok, lebo to je zarážka
Zarážky sa niekedy používajú aj pri práci v poli - do poľa si umelo vložím špeciálny prvý alebo posledný prvok, čo mi uľahčí program.
Smerník na smerník:
- dva prípady v kóde vyššie oba nastavujú p->next a ešte nejaký iný smerník
- z.first aj prev->next majú typ item *
- vyrobíme si premennú typu item **, ktorá ukazuje na smerník, ktorý chceme potenciálne meniť
- touto premennou sa pohybujeme po zozname, až kým nenájdeme správne miesto
void insert2(linkedList &z, int data){ item* p = new item; p->data = data; item** it = &z.first; while (*it && (*it)->data < data) { it = &((*it)->next); } p->next = *it; *it = p; }
Podobne vymazávame prvky zo zoznamu. Vo funkcii remove nájdeme a vymažeme prvok s určitou hodnotou so zoznamu s utriedenými prvkami. Potrebné je si opäť pamätať jeho predchodcu, nakoľko tomuto prvku meníme nasledovníka.
void remove(linkedList &z, int data) { // prvok sa v zozname nenachádza resp. je zoznam prázdny if (!z.first || z.first->data > data) return; // vymazávam prvý prvok if (data == z.first->data) { item* to_del = z.first; z.first = z.first->next; delete to_del; return; } // ostatné prípady item* prev = z.first; while (prev->next && prev->next->data < data) { prev = prev->next; } if (prev->next && prev->next->data == data) { item* to_del = prev->next; prev->next = prev->next->next; delete to_del; } }
Dvojsmerne spájaný zoznam
Je to typ spájaného zoznamu, ktorý má smerník na svojho nasledovníka a aj smerník na svojho predchodcu. Ak je uzol prvý, hodnota smerníka na predchodcu má hodnotu NULL a obdobne, ak je uzol posledný, tak hodnota smerníka na nasledovníka je NULL.
Prvok zoznamu teda vyzerá takto:
struct item { int data; item* next; item* prev; };
Obvykle sa potom okrem začiatku zoznamu udržuje aj smerník na koniec (teda posledný prvok zoznamu). Teda zoznam vyzerá nasledovne:
struct linkedList { item* first; item* last; };
Pre inicializáciu je potrebné okrem začiatku nastaviť aj koniec. Uvoľňovanie pamäti funguje úplne rovnako ako v jednosmerne spájanom.
Vkladanie a vymazávanie na začiatku
Vkladanie na začiatok podobne ako pri jednosmernom zozname, ale upravujeme viac smerníkov.
- Podobne sa dá pracovať aj na konci zoznamu, keďže smerník na koniec si tiež udržujeme.
void insertFirst(linkedList &z, int d){ item* p = new item; p->next = z.first; p->prev = NULL; p->data = d; if (z.first != NULL){ z.first->prev = p; } else { z.last = p; } z.first = p; }
Rozdiely oproti jednosmerne spájanému zoznamu:
- Ak je zoznam prázdny, po vložení treba nastaviť smerník na koniec zoznamu.
- Ak zoznam nie je prázdny, treba nastaviť predchádzajúci prvok pôvodnému začiatku, teda smerník (z.first)->prev.
Pri vymazávaní potrebujeme ošetriť, či sme nevymazali posledný prvok. V tom prípade potrebujeme nastaviť správne aj koniec zoznamu.
int deleteFirst(linkedList &z){ /* zo zoznamu z vymaze prvy prvok a vrati jeho data */ assert(z.first != NULL); // nemozeme mazat, ak je zoznam prazdny item* p = z.first; // prvok, ktorý ideme vymazat int d = z.first->data; // to čo máme vrátiť z.first = z.first->next; // presmerujeme zoznam na novy zaciatok if(z.first==NULL) z.last = NULL; else z.first->prev = NULL; delete p; // uvoľnenie pamäte return d; }
Prechádzanie zoznamu odpredu/odzadu
Na prechádzanie dvojsmerne spájaného zoznamu je možné použiť rovnaký postup ako pri prechádzaní jednosmerného. Okrem toho máme možnosť urobiť aj prechádzanie/výpis zoznamu odzadu.
void vypisOdzadu(linkedList &z){ item* x = z.last; while (x != NULL){ printf("%d ", x->data); x=x->prev; } printf("\n"); }
Vďaka tejto možnosti teda vieme jednoducho nájsť k-ty prvok odzadu zoznamu.
int kOdzadu(linkedList &z, int k){ item* x = z.last; int data; for (int i = 0; i < k; i++){ if (x == NULL) return -1; data = x->data; x = x->prev; } return data; }
Zhrnutie
- V spájanom zozname máme uzly pospájané smerníkmi
- Môžeme si do neho uložiť postupnosť prvkov aj keď nevieme vopred, aká bude dlhá
- Cez zoznam môžeme ľahko prejsť, ale nevieme rýchlo skočiť niekam do stredu (toto zase vieme v poli)
- Existuje veľa variantov: jednosmerne / obojsmerne spájané, kruhové, so sentinelmi, môžeme si pamätať začiatok alebo začiatok aj koniec...
- Pozor na smerníky, aby všetky správne ukazovali a aby sa nám zoznam nepomotal
- Príklady využitia zoznamov na ďalších prednáškach, napr. hašovanie, zásobník a rad.
Cvičenia 8
Vstup
- Napíšte program, ktorý vypíše súbor vstup.txt na obrazovku tak, že všetky riadky dlhšie ako 80 znakov ureže na 80-tom stĺpci.
- Váš program by mal fungovať aj pre súbory s veľmi dlhými riadkami
- Napíšte program, ktorý od užívateľa načíta názvy dvoch súborov a potom zistí, či tieto dva súbory majú rovnaký obsah.
- V súbore máme na každom riadku tri údaje oddelené medzerami: desatinné číslo, znamienko (jedno z +, -, *, /) a druhé desatinné číslo. Postupne načítavajte tento súbor a na konzolu vypisujte výrazy aj s výslednou hodnotu. Na vypisovanie čísel typu double skúste použiť formát %g v príkaze printf. Príklad:
Vstup:
1.5 + 3 -7 - -8.1 3 / 2
Výstup:
1.5 + 3 = 4.5 -7 - -8.1 = 1.1 3 / 2 = 1.5
Výstup
- Do súboru vypíšte tabuľku hodnôt funkcie sin(x) pre x od -1 po 1 s krokom 0.2, pričom ich bude vypisovať na 5 desatinných miest a x aj sin(x) budú zarovnané doprava:
-1.0 -0.84147 -0.8 -0.71736 -0.6 -0.56464 -0.4 -0.38942 -0.2 -0.19867 -0.0 -0.00000 0.2 0.19867 0.4 0.38942 0.6 0.56464 0.8 0.71736 1.0 0.84147
Štatistika
- Stiahnite si textový súbor [9], ktorý obsahuje frekvenciu, s akou užívatelia vyhľadávali výraz ice cream v Googli v jednotlivých týždňoch rokov 2004 až 2010. Každý riadok obsahuje údaje o jednom týždni: prvé tri slová sú dátum, štvrté relatívna frekvencia.
- Načítajte tento súbor do poľa záznamov so štruktúrou
struct tyzden { char[4] mesiac; int den; int rok; double frekvencia; };
- Vypíšte na konzolu, v ktorom týždni bola frekvencia vyhľadávania najvyššia.
- Pre každý rok od 2004 po 2010 spočítajte súčet frekvencií a vypíšte na konzolu v prehľadnom tvare, na dve desatinné miesta:
2004 63.14 2005 62.14 ... 2010 72.02
Šifrovanie permutačnou šifrou
- Napíšte funkciu, ktorá zašifruje vstupný súbor tak, že v každom bloku dĺžky n povymieňa polohu znakov podľa zadaného kľúča. Kľúč je pole A dĺžky n, kde A[i] uvádza, ktoré písmeno z pôvodného bloku má ísť na i-te miesto v zašifrovanom bloku. Napr. pre n=4 a A={3,2,0,1} dostaneme pre blok "ABCD" výsledok "DCAB", lebo na pozíciu 0 vo výsledku sme dali písmeno na pozícii A[0] = 3, t.j. D, atď. Ak v poslednom bloku nemáme dosť písmen, doplníme ich medzerami. Hlavička funkcie: void encryptPermutation(FILE *f, int n, int A[]);
- Pre dešifrovanie môžeme použiť tú istú funkciu, akurát kľúč musíme zmeniť z pôvodnej permutácie A na novú permutáciu B tak, že B[A[i]]=i pre každé i. Napr. pre príklad vyššie to bude B={2,3,1,0}
- Vyskúšajte touto šifrou zašifrovať a potom spätne odšifrovať krátky text.
Prednáška 17
Abstraktný dátový typ, ADT
- Určíme, aké operácie by mala dátová štruktúra spĺňať (hlavičky funkcií), nestaráme sa o implementáciu
- Napríklad ADT vektor poskytuje operácie init, add, get, set, length a destroy
- Pre jeden ADT môže byť viacero implementácií, napr. vector by sme mohli implementovať aj pomocou spájaného zoznamu
- Program, ktorý vektor používa, netreba meniť kvôli zmene implementácie vektora
Problém slovníka
ADT slovník (dictionary), nazýva sa aj asociatívne pole (associative array), map
- Klasický papierový slovník umožňuje rýchlo nájsť nejaké slovo a prečítať si k nemu jeho význam alebo preklad do iného jazyka
- ADT slovník obsahuje záznamy, pričom každý záznam má kľúč (key), podľa ktorého vyhľadávame
- Podporuje operácie
- insert: vloženie nového záznamu
- find: hľadanie záznamu podľa kľúča
- delete: mazania záznamu s daným kľúčom
- Okrem toho potrebujeme init, destroy na celý slovník ale tiež na jednotlivé položky
- V niektorých aplikáciách potrebujeme aj možnosť prejsť cez všetky záznamy (napr. vypísať ich na obrazovku alebo do súboru)
- na toto si spravíme funkciu items, ktorá nakopíruje všetky záznamy do novo alokovaného poľa
- to však nie je veľmi elegantné, väčšinou sa používajú skôr iterátory - uvidíme v Jave
Príklady použitia
- Mená a rodné čísla
- Telefónnny zoznam (mená a telefónne čísla)
- Mapovanie host name na IP adresy
Hlavičky funkcií
V danej aplikácii si musíme najskôr zadefinovať typy itemType a keyType, ktoré určujú, aké záznamy a aké kľúče budeme do slovníka ukladať.
struct person { char * name; char * phone; char * address; }; typedef person itemType; typedef char * keyType;
Ďalej potrebujeme funkciu, ktorá nám pre záznam dá kľúč a funkciu, ktorá zistí, či sú dva kľúče rovnaké. Niektoré implementácie slovníka budú potrebovať aj ďalšie podobné funkcie, napr. zistiť, či je jeden kľúč menší ako druhý.
keyType key(itemType *x) { return x->name; } bool equal(keyType x, keyType y) { return strcmp(x, y)==0; }
Ak chceme s itemType pracovať bez využívania toho, ako vyzerá potrebujeme si jednotlivé položky aj alokovať a uvoľňovať pomocou vlastných funkcií, ktoré vedia, ako itemType vyzerá.
itemType * createItem(const char* name, const char* phone, const char* address){ char* name_=new char[strlen(name)+1]; strcpy(name_,name); char* phone_=new char[strlen(phone)+1]; strcpy(phone_,phone); char* address_=new char[strlen(address)+1]; strcpy(address_,address); itemType* res=new itemType; res->name=name_; res->phone=phone_; res->address=address_; return res; } void destroyItem(itemType *x){ delete[] x->name; delete[] x->phone; delete[] x->address; delete x; }
A tu sú hlavičky základných slovníkových funkcií:
- void insert(dictionary &d, itemType *x);
- do dátovej štruktúry d vloží záznam *x
- predpokladá, že v štruktúre je dosť miesta a nie je tam záznam s rovnakým kľúčom
- itemType *find(dictionary &d, keyType k);
- nájde záznam s kľúčom k a vráti smerník na neho ho. Ak taký kľúč v slovníku nie je, vráti NULL
- void remove(dictionary &d, keyType k);
- vymaže záznam s kľúčom k z d
A pomocné funkcie:
- void init(dictionary &d, int maxN);
- vytvorí slovník, do ktorého sa zmestí maxN záznamov (niektoré implementácie maxN nepotrebujú, rastú podľa potreby)
- void destroy(dictionary &d);
- uvoľní pamäť, ktorú zaberá slovník, využíva pritom funkciu destroyItem
- itemType ** items(dictionary &d, int &n);
- vráti novo alokované pole so smerníkmi na jednotlivé záznamy, ich počet dá do n
- void printItem(itemType *x);
- vypíše prvok, alebo "NULL", ak dostane prázdny smerník
Príklad použitia
V súbore z cvičení máme frekvencie, s akou užívatelia vyhľadávali výraz ice cream v Googli v jednotlivých týždňoch rokov 2004 až 2010.
- Každý riadok obsahuje údaje o jednom týždni: prvé tri slová sú dátum, štvrté relatívna frekvencia.
Jan 4 2004 0.94 Jan 11 2004 0.96 ...
Chceme spočítať, aký je súčet frekvencií pre jednotlivé mesiace v roku, t.j. koľko dokopy vyhľadávali v januári za všetky roky atď.
Spravíme si záznam a definujeme potrebné typy a funkcie ako predtým
struct month { char * name; // kľúč - skratka mesiaca, napr "Jan" double sum; // data - súčet frekvencií pre daný mesiac }; typedef month itemType; typedef char * keyType; keyType key(itemType *x) { return x->name; } bool equal(keyType x, keyType y) { return strcmp(x, y)==0; }
Samotný program používajúci slovník
int main(void) { dictionary d; // vytvorime slovnik pre 12 prvkov init(d, 12); FILE *f = fopen("icecream.txt", "r"); // otvorime subor na citanie assert(f != NULL); while (!feof(f)) { char month[4]; // nacitame 1 riadok suboru int day, year; double freq; fscanf(f, "%3s %d %d %lf ", month, &day, &year, &freq); monthSum *m = find(d, month); // najdeme mesiac v slovniku if (m == NULL) { // mesiac este nie je v slovniku, vyrobime novy itemType* it = createItem(month,freq); insert(d, it); } else { // mesiac uz je v slovniku, zvysime mu frekvenciu m->sum += freq; } } fclose(f); int n; // statistiky mame spocitane, staci ich vypisat monthSum **sums = items(d, n); // vypytame si vsetky zaznamy a ich pocet n for (int i = 0; i < n; i++) { printf("%s %f\n", sums[i]->name, sums[i]->sum); } delete[] sums; // odalokujeme sums destroy(d); // odalokujeme pamat, ktore alokoval slovnik, vratane jeho zaznamov }
Implementácia slovníka pomocou poľa
Asi najjednoduchšia implementácia je pomocou poľa: Majme pole a dĺžky maxN, v ktorom je n záznamov.
struct dictionary { itemType **a; // pole smernikov na zaznamy int maxN; // dlzka pola int n; // pocet zaznamov v poli };
Inicializácia
void init(dictionary &d, int maxN) { // vytvorí slovník, do ktorého sa zmestí maxN záznamov (niektoré implementácie maxN nepotrebujú, rastú podľa potreby) d.maxN = maxN; d.n = 0; d.a = new itemType *[maxN]; }
Vkladanie
Nový prvok vložíme jednoducho na koniec:
void insert(dictionary &d, itemType *x) { assert(d.n < d.maxN); d.a[d.n] = x; d.n++; }
V prípade, že n=maxN, program skončí s chybou
- Mohli by sme tiež podľa potreby alokovať dvakrát väčšie pole a prvky tam presypať, ako v štruktúre vector.
- Ak neskôr počet prvkov klesne pod štvrtinu (n < maxN/4), môžeme pole realokovať späť na polovičnú veľkosť.
Vymazávanie
Vymazávanie je tiež jednoduché, daný prvok nahradíme prvkom na konci:
void remove(dictionary &d, keyType k) { int i = findIndex(d, k); // zisti, kde ten prvok v poli je, vrati -1 ak tam nie je if (i >= 0) { d.a[i] = d.a[d.n - 1]; d.n--; } }
Vyhľadávanie
Pri vyhľadávaní nám neostáva nič iné ako prezerať postupne všetky záznamy, kým daný kľúč nenájdeme, alebo nedôjdeme na koniec poľa (v tom prípade vieme, že záznam s daným kľúčom sa v poli nenachádza):
int findIndex(dictionary &d, keyType k) { // pomocna funkcia pouzivana vo find a delete // vrati poziciu zaznamu s klucom k v poli, alebo -1 ak tam nie je for (int i = 0; i < d.n; i++) { if (equal(key(d.a[i]), k)) { return i; } } return -1; } itemType *find(dictionary &d, keyType k) { int i = findIndex(d, k); if (i < 0) return NULL; return d.a[i]; }
Implementácia slovníka pomocou utriedeného poľa
Ak potrebujeme rýchlo vyhľadávať, lepšia možnosť je udržiavať pole utriedené. Rýchle vyhľadávanie však bude na úkor väčšej zložitosti ostatných operácií.
Vkladanie
void insert(dictionary &d, itemType *x) { assert(d.n < d.maxN); int i=d.n-1; keyType k=key(x); while ((i>=0)&&(greater(key(d.a[i]),k))) {i--; d.a[i+1]=d.a[i];} d.a[i+1]=x; d.n++; }
Pri vkladaní musíme novému záznamu „spraviť miesto" – nájdeme miesto, kam nový záznam vložiť (while-cyklus) pričom prvky za daným miestom posúvame všetky záznamy o 1 doprava.
Vymazávanie
Vymazávanie existujúceho prvku, ktorý je na i-tom mieste nemôžeme tak jednoducho ako pri neutriedenom poli. Keďže musíme zachovať poradie (a zároveň nevytvárať diery), posunieme všetky prvky počnúc (i+1)-vým doľava.
void remove(dictionary &d, const keyType k) { // vymaže záznam s kľúčom k z d int i = findIndex(d, k); if (i >= 0) { while (i<d.n-1) {d.a[i] = d.a[i+1]; i++;} d.n--; } }
Vyhľadávanie
Funkciu findIndex, môžeme urobiť podobne ako pri neutriedenom poli prechodom poľa. Vieme však, že od istého momentu nemá význam pokračovať ďalej.
int findIndex(dictionary &d, const keyType k) { // pomocna funkcia pouzivana vo find a delete // vrati poziciu zaznamu s klucom k v poli, alebo -1 ak tam nie je int i=0; while ((i<d.n)&&(greater(k,key(d.a[i])))) i++; if ((i<d.n)&&(equal(k,key(d.a[i])))) return i; else return -1; }
Druhá možnosť je použiť binárne vyhľadávanie. Zjavne pri utriedenom poli máme komplikovanejšie (a časovo zložitejšie) vkladanie a vymazávanie. Vieme však rýchlejšie výhľadávať.
Pripomenieme myšlienku: začíname hľadať v intervale <l,r> a pozrieme sa na stredný prvok A[m], kde m = (l+ r )/2.
- ak A[m] = k , našli sme hľadaný záznam a sme hotoví.
- ak k < A[m], potom zjavne hľadaný kľúč patrí do prvej polovice intervalu <l,r>, t.j. do intervalu <l,m-1>.
- ak A[m] < k , zjavne patrí do druhej polovice intervalu <l,r>, t.j. do intervalu <m+1,r>.
Takto sa nám každým krokom zmenší hľadaný interval na polovicu
int findIndex(dictionary &d, const keyType k) { // pomocna funkcia pouzivana vo find a delete // vrati poziciu zaznamu s klucom k v poli, alebo -1 ak tam nie je int l=0; int r=d.n-1; while (l<=r){ int m=(l+r)/2; if (equal(key(d.a[m]),k)) return m; else if (greater(key(d.a[m]),k)) r=m-1; else l=m+1; } return -1; }
Slovník s použitím utriedeného poľa
Implementácia slovníka pomocou spájaných zoznamov
Slovník môžeme implementovať aj pomocou spájaných zoznamov. Čo si však musíme uvedomiť je, že ak máme prvok typu itemType, tak v spájanom zozname musíme pracovať s týmto prvkom a zároveň so smerníkom na ďalší prvok. A teda prvky v spájanom zozname sú typu
struct item{ itemType* it; item* next; };
Zvyšok je rovnaký ako pri vkladaní, vyhľadávaní a mazaní zo spáajaného zoznamu s tým rozdielom, že by sme mali používať funkcie key, equal a podobne, ktoré máme k dispozícii ku konkrétnemu typu itemType.
Podrobnejšie prácu so spájanými zoznamami uvidíme neskôr na tejto prednáške.
Hashovacie tabuľky
Hashovanie je metóda vyhľadávania, ktorá je založená na trochu inom princípe ako predchádzajúce možnosti. Tabuľka, do ktorej budeme ukladať záznamy, je výrazne väčšia, ako očakávaný počet záznamov. Do tabuľky budeme pristupovať pomocou funkcie, ktorá vypočíta, kam uložíme prvok, resp. kde ho máme hľadať.
struct itemType{ keyType key; valueType value; }; struct hashMap{ itemType** data; int n; };
Konkrétne, nech K je množina všetkých kľúčov a hashovacia tabuľka je veľkosti n (teda používa indexy 0..n-1).
- Hashovacia funkcia bude transformovať kľúče na indexy poľa, teda pôjde o funkciu h:K -> {0 , 1 , . . . , n −1}.
- Snažíme sa, aby funkcia bola jadnoduchá ale pritom neprideľovala často rovnaké indexy (bude kľúče do tabuľky distribuovať rovnomerne).
- V triviálnom prípade, ak K = {0, 1, . . . , n −1}, stačí za h zvoliť identitu. Keďže v praxi však býva množina K príliš veľká, takúto funkciu nemôžeme použiť.
- Často sa používa funkcia h(k) = k mod n (je dobré, ak v tomto prípade n je prvočíslo nie blízko mocniny 2).
int hash(keyType k, int n){ return k%n; }
Jednoduché riešenie
Ak máme teda vhodnú funkciu hash a hashovaciu tabuľku, môžeme navrhnúť prvé funkcie na prácu s ňou.
- Vyhľadávanie je jednoduché - v prípade, že tam prvok s kľúčom k je, musí byť na mieste hash(k). Skontrolujeme teda, či na tomto mieste je prvok s kľúčom k - ak áno, je to hľadaný prvok a ak nie, tak hľadaný prvok neexistuje.
itemType* find(hashMap& h,keyType k){ int hashed=hash(k,h.n); itemType* lookup=h.data[hashed]; if (equal(key(lookup),k)) return lookup; else return NULL; }
- Vymazanie takéhoto prvku je tiež jednoduché. Ak sme prvok našli, tak ho vymažeme.
void remove(hashMap& h, keyType key){ int hashed=hash(key,h.n); itemType* lookup=h.data[hashed]; if (equal(key(lookup),k)) delete lookup; h.data[hashed]=NULL; }
- Nakoniec si ukážeme vkladanie. Myšlienka je podobne jednoduchá - vypočítame si, kam prvok chceme vložiť a ak je tam miesto, tak ho tam vložíme.
void insert(hashMap& h, keyType key, valueType value){ int hashed=hash(key,h.n); itemType* it=createItem(key,value); h.data[hashed]=it; }
- Ostáva nám otázka - Čo so situáciou, keď chceme vložiť na miesto, kde už niečo uložené máme?
Kolízia
Pri vkladaní prvku sme narazili na problém, že na už obsadané miesto sme chceli vložiť iný prvok. Môže sa stať, že dva prvky x a y sa zahashujú na rovnakú pozíciu h(x) = h(y). Takémuto javu hovoríme kolízia. Existuje viacero spôsobov, ako ju riešiť.
- Budeme aj tak vkladať na toto miesto, len tam potenciálne nebude iba jeden prvok, ale viac v spájanom zozname
- Budeme nejako hľadať prvú voľnú pozíciu v tabuľke, buď postupným prezeraním nasledovných prvkov, alebo s pozeraním nie tesne nasledovných prvkov ale s nejakým krokom - o tomto sa dozviete o rok na ADŠ
Riešenie kolízii pomocou spájaných zoznamov
Namiesto smerníkov priamo na prvok typu itemType budeme mať v každom políčku hashovacej tabuľky spájaný zoznam s prvkami, ktorých kľúče sa priradili na toto políčko. Preto pochopiteľne potrebujeme k itemType pridať aj smerník na nasledujúci prvok. Takto vzniknutú dvojicu budeme označovať item a v tabuľke budeme ukladať smerník na item.
struct item{ itemType* it; item* next; }; struct hashMap{ item** data; int n; };
Potom pre ľubovoľný smerník na prvok typu item (teda pre premennú p typu item*) sa k samotným dátam dostaneme pomocou p->it, ktorý je typu itemType*. Kľúč potom získame ako key(p->it) a s takto získaným kľúčom typu keyType vieme robiť porovnávanie pomocou equal().
- Vyhľadávanie pracuje na spájanom zozname, ktorý sa nachádza na správnom mieste hashovacej tabuľky. Správny index dostaneme pomocou hash(k,h.n), kde
k je hľadaný kľúč a h.n je veľkosť tabuľky h.
itemType* find(hashMap& h,keyType k){ int hashed=hash(k,h.n); item* lookup=h.data[hashed]; while(lookup){ if (equal(key(lookup->it),k)) return lookup->it; lookup=lookup->next; } return NULL; }
- Vkladanie môžeme umožniť rôzne alternatívy podľa toho, aké správanie očakávame. V predchádzajúcom prípade nám nevadilo umiestniť do slovníka aj viacero prvkov s rovnakým kľúčom (nekontrolovali sme existenciu prvku s rovnakým kľúčom). Tým pádom nám stačí nový prvok (ktorý si vytvoríme) vložiť na začiatok spájaného zoznamu na vhodnom mieste tabuľky.
void insert(hashMap& h, keyType k, valueType value){ int hashed=hash(k,h.n); item* it=new item; it->it=createItem(k,value); it->next=h.data[hashed]; h.data[hashed]=it; }
- V prípade, že by sme chceli iným spôsobom ošetriť existenciu prvku s rovnakým kľúčom (či už tomu zabrániť, alebo pri vložení takého prvku urobiť update), musíme patričný spájaný zoznam prejsť aby sme skontrolovali potenciálnu duplicitu kľúčov.
void insert(hashMap& h, keyType k, valueType value){ int hashed=hash(k,h.n); item* lookup=h.data[hashed]; while(lookup){ if (equal(key(lookup->it),k)){ lookup->it->value=value; // v prípade duplicity robíme update hodnoty return; } lookup=lookup->next; } item* it=new item; it->it=createItem(k,value); it->next=h.data[hashed]; h.data[hashed]=it; }
- Vymazávanie prebieha podobne ako všetky ostatné operácie na spájanom zozname, ktorý je na mieste tabuľky, kam nás nasmeroval zahashovaný kľúč.
- Vymazávanie je možné urobiť buď klasicky ako v predchádzajúcej prednáške alebo elegantnejšie pomocou dvojitých smerníkov (smerník na smerník môžeme využiť vďaka tomu, že h.data[hashed] aj item->next sú rovnakého typu - item*).
void remove(hashMap& h, keyType k){ int hashed=hash(k,h.n); item** lookup=&h.data[hashed]; while(*lookup){ item* it=*lookup; if (equal(key(it->it),k)){ *lookup=it->next; delete it; return; } lookup=&it->next; } }
Zdrojový kód programu s netriedeným poľom
#include <cstring> #include <cassert> #include <cstdio> struct monthSum { char * name; // kľúč - skratka mesiaca, napr "Jan" double sum; // data - sucet frekvencií pre daný mesiac }; typedef monthSum itemType; typedef char * keyType; keyType key(itemType *x) { return x->name; } bool equal(keyType x, keyType y) { return strcmp(x, y) == 0; } void printItem(itemType *x){ if (x==NULL) printf("NULL\n"); else printf("%s: %f\n",x->name,x->sum); } itemType * createItem(const char* name, double sum){ char* name_=new char[strlen(name)+1]; strcpy(name_,name); itemType* res=new itemType; res->name=name_; res->sum=sum; return res; } void destroyItem(itemType *x){ delete[] x->name; delete x; } struct dictionary { itemType **a; // pole smernikov na zaznamy int maxN; // dlzka pola int n; // pocet zaznamov v poli }; void insert(dictionary &d, itemType *x) { // do dátovej štruktúry d vloží záznam *x // predpokladá, že v štruktúre je dosť miesta a nie je tam záznam s rovnakým kľúčom assert(d.n < d.maxN); d.a[d.n] = x; d.n++; } int findIndex(dictionary &d, keyType k) { for (int i = 0; i < d.n; i++) { if (equal(key(d.a[i]), k)) { return i; } } return -1; } itemType *find(dictionary &d, keyType k) { // nájde záznam s kľúčom k a vráti smerník na neho ho. // Ak taký kľúč v slovníku nie je, vráti NULL int i = findIndex(d, k); if (i < 0) return NULL; return d.a[i]; } void remove(dictionary &d, keyType k) { // vymaže záznam s kľúčom k z d int i = findIndex(d, k); if (i >= 0) { d.a[i] = d.a[d.n - 1]; d.n--; } } void init(dictionary &d, int maxN) { // vytvorí slovník, do ktorého sa zmestí maxN záznamov (niektoré implementácie maxN nepotrebujú, rastú podľa potreby) d.maxN = maxN; d.n = 0; d.a = new itemType *[maxN]; } void destroy(dictionary &d) { // uvoľní jednotlivé záznamy for (int i=0; i<d.n; i++) destroyItem(d.a[i]); // uvoľní pamäť, ktorú zaberá slovník delete[] d.a; } itemType ** items(dictionary &d, int &n) { // vráti novo alokované pole so smerníkmi na jednotlivé záznamy, ich počet dá do n itemType **a = new itemType*[d.n]; n = d.n; for (int i = 0; i < n; i++) { a[i] = d.a[i]; } return a; } int main(void) { dictionary d; // vytvorime slovnik pre 12 prvkov init(d, 12); FILE *f = fopen("icecream.txt", "r"); // otvorime subor na citanie assert(f != NULL); while (!feof(f)) { char month[4]; // nacitame 1 riadok suboru int day, year; double freq; fscanf(f, "%3s %d %d %lf ", month, &day, &year, &freq); monthSum *m = find(d, month); // najdeme mesiac v slovniku if (m == NULL) { // mesiac este nie je v slovniku, vyrobime novy itemType it = createItem(month,freq); insert(d, it); } else { // mesiac uz je v slovniku, zvysime mu frekvenciu m->sum += freq; } } fclose(f); int n; // statistiky mame spocitane, staci ich vypisat monthSum **sums = items(d, n); // vypytame si vsetky zaznamy a ich pocet n for (int i = 0; i < n; i++) { printf("%s %f\n", sums[i]->name, sums[i]->sum); } delete[] sums; // odalokujeme sums destroy(d); // odalokujeme pamat, ktore alokoval slovnik }
Zdrojový kód slovníka s použitím utriedeného poľa
#include <cstdlib> #include <cstdio> #include <cassert> #include <cstring> using namespace std; struct monthSum { char * name; // kľúč - skratka mesiaca, napr "Jan" double sum; // data - sucet frekvencií pre daný mesiac }; typedef monthSum itemType; typedef char * keyType; keyType key(itemType *x) { return x->name; } bool equal(keyType x, keyType y) { return strcmp(x, y) == 0; } bool greater(keyType x, keyType y) { // x>y return strcmp(x, y) > 0; } void printItem(itemType *x){ if (x==NULL) printf("NULL\n"); else printf("%s: %f\n",x->name,x->sum); } itemType * createItem(const char* name, double sum){ char* name_=new char[strlen(name)+1]; strcpy(name_,name); itemType* res=new itemType; res->name=name_; res->sum=sum; return res; } void destroyItem(itemType *x){ delete[] x->name; delete x; } struct dictionary { itemType **a; // pole smernikov na zaznamy int maxN; // dlzka pola int n; // pocet zaznamov v poli }; void init(dictionary &d, int maxN) { // vytvorí slovník, do ktorého sa zmestí maxN záznamov (niektoré implementácie maxN nepotrebujú, rastú podľa potreby) d.maxN = maxN; d.n = 0; d.a = new itemType *[maxN]; } int findIndex1(dictionary &d, const keyType k) { // pomocna funkcia pouzivana vo find a delete // vrati poziciu zaznamu s klucom k v poli, alebo -1 ak tam nie je int i=0; while ((i<d.n)&&(greater(k,key(d.a[i])))) i++; if ((i<d.n)&&(equal(k,key(d.a[i])))) return i; else return -1; } int findIndex2(dictionary &d, const keyType k) { // pomocna funkcia pouzivana vo find a delete // vrati poziciu zaznamu s klucom k v poli, alebo -1 ak tam nie je int l=0; int r=d.n-1; while (l<=r){ int m=(l+r)/2; if (equal(key(d.a[m]),k)) return m; else if (greater(key(d.a[m]),k)) r=m-1; else l=m+1; } return -1; } itemType *find(dictionary &d, const keyType k) { // nájde záznam s kľúčom k a vráti smerník na neho ho. // Ak taký kľúč v slovníku nie je, vráti NULL int i = findIndex1(d, k); if (i < 0) return NULL; return d.a[i]; } void remove(dictionary &d, const keyType k) { // vymaže záznam s kľúčom k z d int i = findIndex1(d, k); if (i >= 0) { while (i<d.n-1) {d.a[i] = d.a[i+1]; i++;} d.n--; } } void insert(dictionary &d, itemType *x) { assert(d.n < d.maxN); int i=d.n-1; keyType k=key(x); while ((i>=0)&&(greater(key(d.a[i]),k))) {i--; d.a[i+1]=d.a[i];} d.a[i+1]=x; d.n++; } void destroy(dictionary &d) { for (int i=0; i<d.n; i++) destroyItem(d.a[i]); // uvoľní pamäť, ktorú zaberá slovník (neuvoľňuje pamäť jednotlivých záznamov) delete[] d.a; } void printDictionary(dictionary &d){ printf("Dictionary (n=%d)\n",d.n); for (int i=0; i<d.n; i++){ printItem(d.a[i]); } } int main() { dictionary d; init(d,12); insert(d,createItem("Jan",0.9)); insert(d,createItem("Mar",0.8)); printDictionary(d); printItem(find(d,"Jan")); printItem(find(d,"Feb")); remove(d,"Mar"); printDictionary(d); printItem(find(d,"Mar")); destroy(d); }
Zdrojový kód programu s Hashovacou tabuľkou
#include <cstring> #include <cstdio> #include <cassert> using namespace std; typedef int keyType; typedef double valueType; struct itemType{ keyType key; valueType value; }; struct item{ itemType* it; item* next; }; keyType key(itemType *x) { return x->key; } valueType value(itemType *x) { return x->value; } bool equal(keyType x, keyType y) { return (x == y); } itemType * createItem(keyType key, valueType value){ itemType* res=new itemType; res->key=key; res->value=value; return res; } struct hashMap{ item** data; int n; }; int hash(keyType k, int n){ return k%n; } void printValue(valueType* x){ if (x==0) printf("NULL\n"); else printf("%f\n",*x); } void printItem(itemType* x){ if (x==0) printf("NULL\n"); else printf("(%d, %f)\n",x->key,x->value); } void createHashMap(hashMap& h, int n){ h.n=n; h.data=new item*[n]; for(int i=0;i<n;++i) h.data[i]=NULL; } void printHashMap(hashMap& h){ for(int i=0;i<h.n;++i){ printf("%d: ",i); item* it=h.data[i]; while(it){ printf("(%d,%f) ",key(it->it),value(it->it)); it=it->next; } printf("\n"); } } void destroyHashMap(hashMap& h){ for(int i=0;i<h.n;++i){ item* it=h.data[i]; while(it){ item* next=it->next; delete it; it=next; } } delete[] h.data; } void insert(hashMap& h, keyType k, valueType value){ int hashed=hash(k,h.n); item* lookup=h.data[hashed]; while(lookup){ if (equal(key(lookup->it),k)){ lookup->it->value=value; return; } lookup=lookup->next; } item* it=new item; it->it=createItem(k,value); it->next=h.data[hashed]; h.data[hashed]=it; } itemType* find(hashMap& h,keyType k){ int hashed=hash(k,h.n); item* lookup=h.data[hashed]; while(lookup){ if (equal(key(lookup->it),k)) return lookup->it; lookup=lookup->next; } return NULL; } void remove(hashMap& h, keyType k){ int hashed=hash(k,h.n); item** lookup=&h.data[hashed]; while(*lookup){ item* it=*lookup; if (equal(key(it->it),k)){ *lookup=it->next; delete it; return; } lookup=&it->next; } } int main(){ hashMap h; createHashMap(h,10); insert(h,2,2.0); insert(h,2,1.0); printHashMap(h); printItem(find(h,1)); printItem(find(h,2)); insert(h,12,12.0); insert(h,1,1.0); printHashMap(h); printItem(find(h,1)); printItem(find(h,2)); remove(h,12); printHashMap(h); remove(h,12); printHashMap(h); remove(h,2); printHashMap(h); destroyHashMap(h); }
Prednáška 18
Organizačné poznámky
- DÚ7 a PDÚ3 odovzdávať do budúceho pondelka, DÚ8 zverejnená koncom týždňa
- Pondelok 17.12. o 10:00 bude záverečný test (nejaké konflikty?)
Opakovanie: Abstraktný dátový typ (ADT)
- Určíme, aké operácie by mala dátová štruktúra spĺňať (hlavičky funkcií)
- Oddelíme tak samotnú implementáciu dátovej štruktúry a program, ktorý ju používa
- Implementáciu štruktúry môžeme zmeniť bez zmeny zvyšku programu
Doteraz sme videli:
- ADT vektor poskytuje operácie init, add, get, set, length a destroy
- Implementácia poľom, ktorá podľa potreby realokujeme na väčšie
- ADT slovník poskytuje operácie insert, remove, find, init, destroy
- Implementácie napr. utriedeným poľom, neutriedeným poľom, hashovacou tabuľkou, ale aj spájaným zoznamom a ďalšími zložitejšími štruktúrami
Dnes dve nové ADT: zásobník a rad
- Obidve implementujeme pomocou polí aj spájaných zoznamov
Zásobník (stack) a rad (queue)
- Jednoduché dátové štruktúry, ktoré udržujú zoznam nejakých prvkov
- Tieto prvky sú dosť často úlohy, resp. dáta čakajúce na spracovanie
- Vieme do nich vkladať a vyberať
- Líšia sa tým, v akom poradí vyberáme
Rad, fronta (queue)
- Vyberáme prvok, ktorý je v rade najdlhšie (first in, first out, FIFO)
- Podobá sa na státie v rade pri pokladni: ten, kto tam stojí najdlhšie, bude prvý obslúžený
- Základné operácie
/* inicializuje prázdny rad */ void init(queue &q); /* zisti, ci je rad prazdny */ bool isEmpty(queue &q); /* prida prvok item na koniec radu */ void enqueue(queue &q, dataType item); /* odoberie prvok zo začiatku radu a vráti jeho hodnotu */ dataType dequeue(queue &q); /* vrati prvok zo zaciatku radu, ale necha ho v rade */ dataType peek(queue &q);
Zásobník (stack)
- Vyberáme prvok, ktorý je v rade najkratšie (last in, first out, LIFO)
- Podobá sa na umývača tanierov v reštaurácii, vždy vezme horný tanier z kopy
/* inicializuje prázdny zásobník */ void init(stack &s); /* zisti, ci je zasobnik prazdny */ bool isEmpty(stack &s); /* prida prvok item na vrch zasobnika */ void push(stack &s, dataType item); /* odoberie prvok z vrchu zásobníka a vráti jeho hodnotu */ dataType pop(stack &q);
Ešte potenciálne potrebujeme uvoľniť pamäť nejakou ďalšou funkciou, napr. destroy.
Príklad:
typedef int dataType; /* sem pride definicia typov stack a queue a vsetky potrebne funkcie */ int main() { cout << "Stack:" << endl; stack s; init(s); push(s, 1); push(s, 2); push(s, 3); cout << pop(s) << endl; cout << pop(s) << endl; cout << pop(s) << endl; cout << "Queue:" << endl; queue q; init(q); enqueue(q, 1); enqueue(q, 2); enqueue(q, 3); cout << dequeue(q) << endl; cout << dequeue(q) << endl; cout << dequeue(q) << endl; }
Zásobník prevracia poradie prvkov, rad zachováva.
Stack: 3 2 1 Queue: 1 2 3
Zásobník implementovaný pomocou poľa
Dve prirodzené možnosti:
- vrch zásobníka v prvku 0
- spodok zásobníka v prvku 0
Prvá možnosť by bola pomalá, na operácie push aj pop by sme museli posúvať všetky prvky v zásobníku. Použijeme teda druhú možnosť, v prvku 0 bude spodok zásobníka, v premennej top si pamätáme pozíciu vrchného prvku.
struct stack { int top; /* pozicia vrchného prvku zásobníka */ dataType *items; /* pole prvkov */ }; /* inicializuje prázdny zásobník */ void init(stack &s) { s.top = -1; s.items = new dataType[maxN]; } /* zisti, ci je zasobnik prazdny */ bool isEmpty(stack &s) { return s.top == -1; } /* prida prvok s hodnotou item na vrch zasobnika */ void push(stack &s, dataType item) { s.top++; assert(s.top < maxN); s.items[s.top] = item; } /* odoberie prvok z vrchu zásobníka a vráti jeho hodnotu */ dataType pop(stack &s) { assert(s.top >= 0); s.top--; return s.items[s.top + 1]; }
Rad implementovaný pomocou poľa
- Rad sa nedá implementovať tak jednoducho ako zásobník, lebo na jednej strane potrebujeme vkladať a na druhej vyberať.
- Takže ak by sme chceli mať napr. prvý prvok v rade vždy na pozícii 0, museli by sme pri vyberaní posúvať všetky prvky, čo je pomalé.
- Namiesto toho si budeme pamätať pozíciu prvého prvku (premenná first) a keď vyberieme prvok, len zvýšime first
- Tým sa zaplnený úsek postupne posúva doprava
- Keď dôjdeme na koniec poľa, zatočíme sa, ako keby za prvkom maxN-1 nasledoval prvok 0
struct queue { int first; /* prvý prvok v rade */ int count; /* počet prvkov v rade */ dataType *items; /* pole prvkov */ }; /* inicializuje prázdny rad */ void init(queue &q) { q.first = 0; q.count = 0; q.items = new dataType[maxN]; } /* zisti, ci je rad prazdny */ bool isEmpty(queue &q) { return q.count == 0; } /* prida prvok s hodnotou item na koniec radu */ void enqueue(queue &q, dataType item) { assert(q.count < maxN); int last = (q.first + q.count) % maxN; q.items[last] = item; q.count++; } /* odoberie prvok zo začiatku radu a vráti jeho hodnotu */ dataType dequeue(queue &q) { assert(q.count > 0); int index = q.first; /* kde je prvok, ktory chceme vratit */ q.first = (q.first + 1) % maxN; q.count--; return q.items[index]; } /* vrati prvok zo zaciatku radu, ale necha ho v rade */ dataType peek(queue &q) { assert(q.count > 0); return q.items[q.first]; }
Zásobník implementovaný pomocou spájaného zoznamu
- V zásobníku v poli sme na začiatku poľa mali spodok zásobníka
- V zozname budeme mať na začiatku zoznamu vrchol zásobníka, lebo na začiatok zoznamu sa dobre vkladá a vyberá.
- Použijeme kód na vkladanie a vyberanie zo zoznamu z prednášky 16 (prvok zoznamu sme premenovali na node, začiatok zoznamu na top)
- Nepotrebujeme vopred stanovavať maximálny počet prvkov, zásobník podľa potreby rastie alebo sa zmenšuje (kým je voľná pamäť)
struct node { dataType data; node* next; }; struct stack { node *top; /* vrchný prvok zásobníka */ }; /* inicializuje prázdny zásobník */ void init(stack &s) { s.top = NULL; } /* zisti, ci je zasobnik prazdny */ bool isEmpty(stack &s) { return s.top == NULL; } /* prida prvok s hodnotou item na vrch zasobnika */ void push(stack &s, dataType item) { node *temp = new node; temp->data = item; temp->next = s.top; s.top = temp; } /* odoberie prvok z vrchu zásobníka a vráti jeho hodnotu */ dataType pop(stack &s) { assert(s.top != NULL); node *temp = s.top->next; // prvok, ktorý bude ďalej top dataType val = s.top->data; // to čo máme vrátiť delete s.top; s.top = temp; return val; }
Rad implementovaný pomocou spájaného zoznamu
- Potrebujeme na jednom konci zoznamu vkladať, na opačnom vyberať.
- Použijeme kruhový zoznam, v ktorom posledný prvok ukazuje pomocou next na prvý prvok v zozname.
- Prvý prvok radu bude prvý v zozname, bude ukazovať na druhý prvok atď.
- V štruktúre queue si pamätáme iba smerník na posledný prvok radu.
- Ak je rad prázdny, tento smerník je NULL.
- Z posledného prvku sa jedným krokom vieme dostať k prvému prvku.
struct queue { node *last; /* posledný prvok v rade */ }; /* inicializuje prázdny rad */ void init(queue &q) { q.last = NULL; } /* zisti, ci je rad prazdny */ bool isEmpty(queue &q) { return q.last == NULL; } /* prida prvok s hodnotou item na koniec radu */ void enqueue(queue &q, dataType item) { node *temp = new node; temp->data = item; if (q.last == NULL) { q.last = temp; temp->next = temp; } else { temp->next = q.last->next; q.last->next = temp; q.last = temp; } } /* odoberie prvok zo začiatku radu a vráti jeho hodnotu */ dataType dequeue(queue &q) { assert(q.last != NULL); node *first = q.last->next; if (first->next == first) { /* ak v zozname iba jeden prvok */ q.last = NULL; } else { /* v zozname viac prvkov, preskocime first */ q.last->next = first->next; } dataType val = first->data; delete first; /* zmazeme node pre first */ return val; } /* vrati prvok zo zaciatku radu, ale necha ho v rade */ dataType peek(queue &q) { assert(q.last != NULL); return q.last->next->data; }
Použitie rady a zásobníka
Zvyčajne uchovávajú dáta, ktoré ešte treba spracovať, resp. zoznam úloh.
Rad použijeme, ak chceme zachovať poradie.
- Jeden proces pridáva úlohy, druhý ich rieši (prípadne aj viac procesov môže vkladať alebo vyberať)
- Príklady:
- Textový procesor pripravuje strany na tlač, vkladá ich do radu, tlačiareň ich tlačí
- Výpočtové úlohy čakajú na veľkom serveri v rade na spustenie
- Zákazníci čakajú na zákazníckej linke na voľného operátora
- Pasažieri na stand-by čakajú na voľné miesto v lietadle
Zásobník je jednoduchší, používame ho, ak nám nezáleží na poradí, alebo ak chceme poradie prevracať
- Hlavný príklad je zásobník, ktorý kompilátor vytvorí na ukladanie lokálnych premenných funkcií, čo nám umožňuje použiť rekurziu (call stack)
- Pri nekonečnej rekurzii nám zásobník "pretečie" a program spadne, napr. s chybou Segmentation fault
void pokus() { int i; pokus(); } int main() { pokus(); }
- Rekurzívne programy vieme prepísať na nerekurzívne, napríklad pomocou ručne vytvoreného zásobníka
- Mohli by sme mechanicky simulovať to, ako zásobník používa kompilátor, to by však bolo veľmi neprehľadné
- Väčšinou trochu zmeníme ako presne program funguje
- Ukážeme si niekoľko príkladov
Nerekurzívny QuickSort
- Quicksort zvolí nejakú hodnotu, prvky menšie ako táto hodnota dá do ľavej časti poľa, väčšie prvky do pravej časti poľa
- Potom rekurzívne volá Quicksort na obe časti poľa
void quicksort(int A[], int l, int r) { if (l >= r) return; // rozdelenie int pivot = divide(A, l, r); // reukrzivne volanie na mensie a vacsie prvky quicksort(A, l, pivot - 1); quicksort(A, pivot + 1, r); } int main() { ... quicksort(A, 0, n-1); ... }
Namiesto rekurzie si spravíme zásobník dvojíc l,r, ktoré ešte treba dotriediť
struct usek { int l, r; }; typedef usek dataType; void quicksort(int A[], int n) { stack s; init(s); /* do stacku vlozime usek pre cele pole */ usek u; u.l = 0; u.r = n - 1; push(s, u); while (!isEmpty(s)) { u = pop(s); /* spracovavame usek od u.l po u.r */ if (u.l >= u.r) continue; /* rozdelenie */ int pivot = divide(A, u.l, u.r); /* ľavý a pravý úsek vložíme do stacku na neskoršie dotriedenie */ usek u1; u1.l = u.l; u1.r = pivot - 1; usek u2; u2.l = pivot + 1; u2.r = u.r; push(s, u2); push(s, u1); } }
- Tento program triedi úseky v rovnakom poradí, ako rekurzívny Quicksort, lebo po rozdelení intervalu [0..n-1] na dve časti dá na vrchol zásobníka ľavú časť. Až keď sa táto ľavá časť a všetky podúlohy, ktoré z nej vzniknú, spracuje, vytiahne sa zo zásobníka pravá časť.
- V Quicksorte však na poradí nezáleží, takže by sme mohli vložiť úseky aj naopak push(s, u1); push(s, u2); (potom by najprv dotriedil pravú časť až potom ľavú)
- Alebo by sme namiesto zásobníka mohli použiť rad. Potom by najskôr rozdelil ľavú aj pravú časť na ďalšie podčasti a potom by delil každú z týchto podčastí atď
Na zamyslenie: ako by sme spravili nerekurzívny MergeSort? Prečo to nejde tak isto ako Quicksort?
Kontrola uzátvorkovania
- Jednoduchý príklad na použitie zásobníka
- Máme daný reťazec obsahujúci zátvorky rôznych typov (,),[,],{,} a chceme zistiť, či je dobre uzátvorkovaný
- Ak zoberieme prvých i znakov reťazca, počet uzátvaracích zátvoriek nesmie prevýšiť počet otváracích
- Ku každej otváracej zátvorke musí byť zatváracia toho istého typu
+2 Vyraz je dobre uzatvorkovany (x+2) Vyraz je dobre uzatvorkovany [((({}[])[]))] Vyraz je dobre uzatvorkovany [[#)) Vyraz nie je dobre uzatvorkovany ())( Vyraz nie je dobre uzatvorkovany (( Vyraz nie je dobre uzatvorkovany
Do zásobníka si budeme ukladať pre každú začínajúcu zátvorku jej zodpovedajúcu končiacu. Keď príde končiaca zátvorka, skontrolujeme, či na vrchu zásobníka je to isté (a vyberieme to zo zásobníka).
typedef char dataType; char vyraz[100]; fgets(vyraz, 100, stdin); // nacitame retazec do pola vyraz stack s; init(s); bool spravny = true; for (int i = 0; vyraz[i] != 0; i++) { switch (vyraz[i]) { case '(': push(s, ')'); break; case '[': push(s, ']'); break; case '{': push(s, '}'); break; case ')': case ']': case '}': if (isEmpty(s)) { spravny = false; } else { char c = pop(s); if (c != vyraz[i]) { spravny = false; } } break; } } if (spravny) { cout << "Vyraz je dobre uzatvorkovany" << endl; } else { cout << "Vyraz nie je dobre uzatvorkovany" << endl; } }
Cvičenie:
- Čo spraví program, ak na vstupe je ((? Opravte ho, aby fungoval správne.
- Pridajte do programu výpis pozície, kde bola detekovaná chyba a výpis typu chyby.
- Prepíšte program na kontrolu zátvoriek do rekurzívnej podoby, pričom použijete iba premenné typu char (žiadne polia a pod.). Reťazec načítavajte pomocou getc a ungetc, ukončený je koncom riadku.
Cvičenia 9
Matice
Napíšte funkcie, ktoré dostanú na vstupe dvojrozmernú maticu celých čísel s n riadkami a m stĺpcami a spravia s ňou jednu z týchto operácií:
- Otočte poradie riadkov matice (stačí vymeniť smerníky)
- Otočte poradie stĺpcov matice (treba vymienať čísla v riadkoch)
- Zostavte transponovanú maticu, t.j. s m riadkami a n stĺcami
Na testovanie vášho programu môžete použiť funkcie na prácu s maticami z prednášky 15.
2D polia
- Vytvorte Pascalov trojuholník ako 2D pole, ktoré má v prvom riadku jedno číslo Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {0 \choose 0}} , v druhom dve Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {1 \choose 0}} a Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {1 \choose 1}} atď. Môžete využiť vzťah, že Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {n \choose 0} = {n \choose 0} = 1} a pre 0<k<n platí Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {n \choose k} = {n-1 \choose k-1} + {n-1 \choose k}} , t.j. n-tý riadok vieme ľahko spočítať z n-1-vého.
- Do programu s výškovou mapou z prednášky 15 doprogramujte hľadanie všetkých ostrovčekov veľkosti 1, t.j. políčka s pevninou, ktoré sa hranou nedotýkajú inej pevniny (môžu sa dotýkať rohom). Každý taký ostrovček zarámikujte. Spravte si vstup, v ktorom takéto ostrovčeky budú, aby ste mohli program vyskúšať.
Vektor
- Do programu na prácu s vektorom z prednášky 14 doprogramujte funkciu void removeLast(vector &a), ktorá z poľa vyhodí posledný prvok (zmenší sa teda n) a ak bude n menší ako tretina veľkosti, vytvorí nové pole polovičnej veľkosti, zvyšné prvky do neho premiestni, a staré pole uvoľní. Pole by malo mať vždy veľkosť aspoň 1.
2D vektor
- Vytvorte dvojrozmerný vektor, ktorý bude podporovať nasledovné operácie:
- Inicializuj: Nastaví počiatočnú použiteľnú veľkosť na 2x2, N(počet riadkov)=0 a M(počet stĺpcov)=0.
- Pridaj riadok: Ak sa do súčasnej veľkosti zmestí, pridá riadok (zväčší N) obsahujúci M núl. Ak sa nezmestí, zdvojnásobí počet riadkov.
- Pridaj stĺpec: Ak sa do súčasnej veľkosti zmestí, pridá stĺpec (zväčší M) obsahujúci N núl. Ak sa nezmestí, zdvojnásobí počet stĺpcov.
- Prístup k prvku na riadku i a stĺpci j (funkcie get a set)
- Uvoľni: Uvoľní pamäť.
Hra Life
Na konci prednášky 15 je program na simulovanie hry Life.
- Prečítajte si popis tejto hry a skúste si spustiť príslušný program
- Zobrazovanie hry Life zmeňte tak, aby sa bunky, ktoré práve umreli, zobrazili ako sivé políčka a až v ďalšom kroku zmizli úplne. (T.j. v čase t bunka žije, teda je čierne, v čase t+1 umrela teda je sivá a v čase t+2 bude bielou, ak sa znova nenarodila). Pre jednoduchosť môžete v každom kole zmazať obrazovku a vykresľovať všetky políčka odzova.
DÚ7
Odovzdávanie DÚ7 max. 10 bodov plus 3 body bonus, termín odovzdania 19.11.2012 o 22:00
Cieľom tejto domácej úlohy je precvičiť si prácu so súbormi.
Váš program na vstupe načíta zo súboru zoznam mailových kontaktov a vypíše ho v prehľadnejšom tvare do iného súboru. Podrobne si prečítajte celé zadanie a dodržte všetky pokyny.
Popis vstupného súboru
- Súbor pozostáva zo slov oddelených bielymi znakmi, pričom pod slovom rozumieme postupnosť nebielych znakov ohraničenú bielymi znakmi, prípadne začiatkom a koncom súboru. Medzi dvoma slovami môže byť aj viac ako jeden biely znak. Na začiatku a konci súboru môžu a nemusia byť biele znaky.
- V súbore sú údaje o niekoľkých osobách a ich e-mailových adresách, pričom záznam o jednej osobe začína jedným alebo viacerými slovami tvoriacimi meno a za nimi nasleduje jedno slovo tvoriace e-mailovú adresu.
- Slová tvoriace meno rozpoznáme podľa toho, že obsahujú iba písmená anglickej abecedy (malé alebo veľké, bez diakritiky).
- E-mailové adresy obsahujú podslová oddelené znakmi '.' alebo '@', pričom znak '@' sa v e-mailovej adrese vyskytuje práve raz. Jednotlivé podslová môžu byť tvorené ľubovoľnými nebielymi znakmi okrem '.' a '@', ale musia obsahovať aspoň jedno písmeno anglickej abecedy (malé alebo veľké, bez diakritiky).
Popis výstupného súboru
- Záznam o každej osobe je na zvláštnom riadku, pričom jednotlivé slová v mene sú oddelené práve jednou medzerou.
- Medzi koncom mena a začiatkom e-mailovej adresy je tiež práve jedna medzera.
- Mená zarovnávajte doprava tak, aby najdlhšie meno v súbore začínalo na začiatku riadku a pred kratšie mená vložte na začiatok riadku medzery tak, aby všetky mená končili v tom istom stĺpci.
- Záznamy vo výstupnom súbore budú v rovnakom poradí ako na vstupe.
Príklad vstupu a výstupu
Janko Hrasko jano1@hrasok.com Jozko F Mrkvicka jozko.f.mrkv$icka@mrkvicka.v.mrkvickovej.hriadke6.xy?
Janko Hrasko jano1@hrasok.com Jozko F Mrkvicka jozko.f.mrkv$icka@mrkvicka.v.mrkvickovej.hriadke6.xy?
Ďalšie pokyny
- Ako názov vstupného súboru zadajte zoznam.txt a výstupného súboru prehlad.txt. Pri otváraní súborov zadajte iba meno bez cesty, súbor sa vám podľa nastavení Netbeans vytvorí buď v domovskom adresári alebo v adresári s projektom.
- Pri alokovaní pamäte môžete predpokladať, že počet osôb v súbore je najviac 100 a dĺžka každého slova vo vstupnom súbore je tiež najviac 100.
- Pozor, počet súčastí jedného mena nie je ohraničený, teda pamäť na ukladanie celého mena alebo jednotlivých slov mena alokujte dynamicky podľa potreby a nespoliehajte sa, že sa zmestia do dopredu danej dĺžky.
- Pri načítavaní súboru kontrolujte, či:
- súbor obsahuje najviac 100 záznamov
- súbor nezačína e-mailovou adresou (prvé musí ísť vždy meno)
- súbor nekončí menom (za každým menom musí e-mailová adresa)
- v súbore nejdú dve emailové adresy za sebou (medzi každými dvomi musí byť aspoň jedno slovo mena)
- neobsahuje reťazce, ktoré nie sú ani meno ani e-mailová adresa
Ak niektorá z týchto podmienok nie je splnená, vypíšte na konzolu vhodnú chybovú hlášku a ukončite program príkazom exit(1) z knižnice cstdlib, prípadne príkazom return 1, ak ste vo funkcii main.
- Dbajte na čitateľnosť programu, rozdeľte ho na vhodne definované funkcie.
Dobré rady (ktoré nie je nutné dodržať, ak si myslíte, že to viete spraviť lepšie)
- Pri načítavaní ukladajte údaje do poľa struct-ov, napr.
struct osoba { char *meno; char *email; };
- Ak zoznam je pole typu osoba, tak dĺžku mena i-tej osoby zistíme príkazom strlen(zoznam[i].meno)
- Na načítavanie použite fscanf do premennej typu char[100]. Táto funkcia sa postará o rozdelenie súboru na slová.
- Dajte pozor na správnu detekciu konca súboru. Pre FILE *f vráti feof(f) true, iba ak pri predchádzajúcom načítaní program narazil na koniec súboru. Vyskúšajte teda, či Váš program funguje aj v prípade, že súbor končí bielym znakom, aj v prípade, že končí napr. nejakým písmenom.
- To, či je znak písmeno, môžete overiť funkciou isalpha z knižnice cctype.
Bonusová úloha
- V zozname nájdite záznamy s tým istým menom (meno je také isté, ak sa skladá z tých istých slov v tom istom poradí). Každú takúto skupinu e-mailových adries pre rovnaké meno vypíšte na jednom riadku, pričom najprv ide meno zarovnané doprava a potom jednotlivé adresy oddelené čiarkou a medzerou.
- Tieto dáta vypíšte do súboru skupiny.txt
- Nemusíte dbať na rýchlosť, môžete porovnávať každé meno s každým.
- Poradie záznamov nemusíte zachovať.
- Bonusovú a hlavnú časť úlohy odovzdajte v tom istom programe, ktorý bude vypisovať obidva súbory.
Príklad
Janko M. jano@mail.com Misko misko@pieskovisko.sk Janko M. janicko@nieco.divne.xy
Janko M. jano@mail.com, janicko@nieco.divne.xy Misko misko@pieskovisko.sk
Prednáška 19
Vyfarbovanie súvislých oblastí
Máme daný obrázok pozostávajúci z m riadkov a n stĺpcov pixelov, každý pixel určitej farby. V našom jednoduchom príklade budeme uvažovať iba 4 farby, ktoré budeme zapisvať číslami 0,..,3 a ktorých význam bude daný týmto poľom, takže napr. farba 0 je biela:
const string farby[4] = {"white", "green", "black", "brown"};
Užívateľ si zvolí určitý pixel obrázku a chce vyfarbiť celú súvislú jednofarebnú oblasť obsahujúcu tento pixel novou farbou. Ak napríklad začneme vyfarbovať v obrázku vľavo farbou 3 (hnedou) od pixelu (0,0), dostaneme obrázok napravo:
Tu je pôvodný obrázok v textovej forme, ako matica čísel.
11 17 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 2 2 1 2 2 2 2 0 0 0 0 1 0 0 0 0 0 2 0 1 0 0 0 2 0 0 2 2 2 2 2 2 2 0 2 2 1 2 2 2 2 0 0 2 0 1 0 0 0 2 0 0 0 1 0 0 0 0 0 0 2 0 1 0 0 0 2 0 0 0 1 0 1 1 1 1 0 2 0 1 1 1 1 2 1 1 1 1 0 1 0 0 1 0 2 0 0 0 0 0 2 0 0 0 0 0 1 1 1 1 0 2 2 2 2 2 2 2 0 0 0 0 0 0 0 0 0
Túto úlohu vieme vyriešiť nasledujúcou rekurzívnou funkciou, ktorá prefarbí zadané políčko a potom rekurzívne pokračuje vo vyfarbovaní vo všetkých susedoch, ktorí majú rovnakú farbu, ako pôvodne malo toto políčko.
void vyfarbi(int **a, int n, int m, int riadok, int stlpec, int farba) { /* prefarbi suvislu jednofarebnu oblast obsahujucu * a[riadok][stlpec] na farbu farba */ if (a[riadok][stlpec] != farba) { int stara_farba = a[riadok][stlpec]; a[riadok][stlpec] = farba; if (riadok > 0 && a[riadok - 1][stlpec] == stara_farba) { vyfarbi(a, n, m, riadok - 1, stlpec, farba); } if (riadok + 1 < n && a[riadok + 1][stlpec] == stara_farba) { vyfarbi(a, n, m, riadok + 1, stlpec, farba); } if (stlpec > 0 && a[riadok][stlpec - 1] == stara_farba) { vyfarbi(a, n, m, riadok, stlpec - 1, farba); } if (stlpec + 1 < m && a[riadok][stlpec + 1] == stara_farba) { vyfarbi(a, n, m, riadok, stlpec + 1, farba); } } }
Susedov náš program pozerá v poradí hore, dole, doľava, doprava.
- V akom poradí vyfarbí políčka nulovej matice 2x2 ak začne v ľavom hornom rohu?
- V akom poradí vyfarbuje jednoriadkovú maticu, ak začneme niekde v strede?
Zdrojový kód celého programu
- Tento program vytvorí maticu a vyfarbí v ňom jednu oblasť aj s animáciou: #Program rekurzívne vyfarbovanie
Použitie vyfarbovania na mape
Spomeňme si na program na prácu s výškovou mapu z prednášky 15. Máme zadanú mapu ako maticu celých čísel, v ktorej 0 znamená more a kladné čísla nadmorskú výšku pevniny. Budeme predpokladať, že na mape je niekoľko ostrovov, ktoré sú plne obkolesené morom a nemajú žiadne vnútorné moria ani jazerá. Chceme spočítať, koľko tam tých ostrovov je.
Použijeme na to vyfarbovanie z predchádzajúceho programu.
- Prejdeme maticu a všetky kladné čísla prepíšeme na 1. Máme teda 0 vyznačené more a 1 ostrovy.
- Prechádzame maticu a vždy, keď nájdeme 1 (ešte nepreskúmaný ostrov), vyfarbíme ho farbou 2 a zvýšime počet ostrovov.
- Nakoniec máme more ako 0 a všetky ostrovy ako 2.
Príklad mapy a jej zobrazenie po prepísaní kladných čísel na 1 (zelená), po vyfarbení prvého ostrova číslom 2 (čiernou) a po vyfarbení všetkých ostrovov.
11 17 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 9 1 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 1 0 0 1 1 0 0 0 0 1 0 0 0 0 0 2 0 0 0 0 0 1 0 0 1 0 0 2 2 2 2 0 2 2 1 7 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 7 0 1 0 0 0 2 0 0 0 1 0 1 1 1 0 0 0 0 1 5 1 1 2 1 1 3 1 0 1 2 2 0 0 1 0 0 0 1 1 2 2 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Takto to naprogramujeme:
for(int i=0; i<n; i++) { for(int j=0; j<m; j++) { if(a[i][j]>0) a[i][j] = 1; } } int ostrovov = 0; for(int i=0; i<n; i++) { for(int j=0; j<m; j++) { if(a[i][j]==1) { ostrovov++; vyfarbi(a, n, m, i, j, 2); } } } cout << "Pocet ostrovov: " << ostrovov << endl;
Zdrojový kód celého programu
- Tento program načíta maticu a zobrazuje vyfarbovanie ostrovov: #Ukážkový program ostrovy
Nerekurzívne vyfarbovanie
Prepíšme si štyri volania rekurzívne do jedného cyklu pomocou polí delta_riadok a delta_stlpec.
const int delta_stlpec[4] = {1, 0, -1, 0}; const int delta_riadok[4] = {0, -1, 0, 1}; void vyfarbi(int **a, int n, int m, int riadok, int stlpec, int farba) { /* prefarbi suvislu jednofarebnu oblast obsahujucu * a[riadok][stlpec] na farbu farba */ if (a[riadok][stlpec] != farba) { int stara_farba = a[riadok][stlpec]; a[riadok][stlpec] = farba; for (int smer = 0; smer < 4; smer++) { /* skus susedne policko so suradnicami r,s */ int r = riadok + delta_riadok[smer]; int s = stlpec + delta_stlpec[smer]; if (r >= 0 && r < n && s >= 0 && s < m && a[r][s] == stara_farba) { vyfarbi(a, n, m, r, s, farba); } } } }
Namiesto rekurzie budeme používať zásobník. Do zásobníka si môžeme uložiť štyroch susedov aktuálneho políčka, pretože z nich ešte treba vyfarbovať ďalej. Ale spravíme malú zmenu: pred uložením do stacku ich už prefarbíme novou farbou, aby sme vedeli, že ich už viackrát do zásobníka nemáme dať.
struct policko { int r, s; }; typedef policko dataType; void vyfarbi(int **a, int n, int m, int riadok, int stlpec, int farba) { /* prefarbi suvislu jednofarebnu oblast obsahujucu * a[riadok][stlpec] na farbu farba */ stack s; init(s); /* vyfarbi startovacie policko a daj ho do stacku */ int stara_farba = a[riadok][stlpec]; if (stara_farba == farba) return; a[riadok][stlpec] = farba; policko p; p.r = riadok; p.s = stlpec; push(s, p); while (!isEmpty(s)) { /* vytiahni policko zo stacku */ p = pop(s); /* skontroluj jeho susedov, vyfarbi ich a uloz to stacku */ for (int smer = 0; smer < 4; smer++) { policko p2; p2.r = p.r + delta_riadok[smer]; p2.s = p.s + delta_stlpec[smer]; if (p2.r >= 0 && p2.r < n && p2.s >= 0 && p2.s < m && a[p2.r][p2.s] == stara_farba) { a[p2.r][p2.s] = farba; push(s, p2); } } } }
Namiesto zásobníka môžeme použiť aj rad, potom bude vyfarbovať v poradí podľa vzdialenosti od štartovacieho políčka (prehľadávanie do šírky)
void vyfarbi(int **a, int n, int m, int riadok, int stlpec, int farba) { /* prefarbi suvislu jednofarebnu oblast obsahujucu * a[riadok][stlpec] na farbu farba */ queue q; init(q); /* vyfarbi startovacie policko a daj ho do radu */ int stara_farba = a[riadok][stlpec]; if (stara_farba == farba) return; a[riadok][stlpec] = farba; policko p; p.r = riadok; p.s = stlpec; enqueue(q, p); while (!isEmpty(q)) { /* vytiahni policko z radu */ p = dequeue(q); zobrazStvorcek(p.r, p.s, a[p.r][p.s], "lightgray", window); window.wait(waitTime); /* skontroluj jeho susedov, vyfarbi ich a uloz to radu */ for (int smer = 0; smer < 4; smer++) { policko p2; p2.r = p.r + delta_riadok[smer]; p2.s = p.s + delta_stlpec[smer]; if (p2.r >= 0 && p2.r < n && p2.s >= 0 && p2.s < m && a[p2.r][p2.s] == stara_farba) { a[p2.r][p2.s] = farba; enqueue(q, p2); zobrazStvorcek(p2.r, p2.s, a[p2.r][p2.s], "red", window); window.wait(waitTime); } } } }
Sudoku
Chceme riešiť hlavolam Sudoku. Máme danú plochu 9x9 políčok, pričom niektoré sú prázdne, iné obsahujú číslo z množiny {1..9}. Plocha je rozdelená do 9 štvorcov 3x3. Cieľom je doplniť čísla do prázdnych štvorčekov tak, aby v každom riadku plochy, v každom stĺpci plochy a v každom štvorci 3x3 bola každá cifra {1..9} práve raz.
. 3 . | . 7 . | . . . 6 . . | 1 9 5 | . . . . 9 8 | . . . | . 6 . --------------------- 8 . . | . 6 . | . . 3 4 . . | 8 . 3 | . . 1 . . . | . 2 . | . . 6 --------------------- . 6 . | . . . | 2 8 . . . . | 4 . 9 | . . 5 . . . | . 8 . | . 7 .
Príklad vstupu a výstupu:
Vstup: Vystup: 0 3 0 0 7 0 0 0 0 5 3 4 6 7 8 9 1 2 6 0 0 1 9 5 0 0 0 6 7 2 1 9 5 3 4 8 0 9 8 0 0 0 0 6 0 1 9 8 3 4 2 5 6 7 8 0 0 0 6 0 0 0 3 8 5 9 7 6 1 4 2 3 4 0 0 8 0 3 0 0 1 4 2 6 8 5 3 7 9 1 0 0 0 0 2 0 0 0 6 7 1 3 9 2 4 8 5 6 0 6 0 0 0 0 2 8 0 9 6 1 5 3 7 2 8 4 0 0 0 4 0 9 0 0 5 2 8 7 4 1 9 6 3 5 0 0 0 0 8 0 0 7 0 3 4 5 2 8 6 1 7 9 Pocet rieseni: 1
Naša rekurzívna procedúra bude postupovať nasledovne:
- nájde na ploche prázdne políčko, ak také nie je, vypíše riešenie a skončí
- do prázdneho políčka skúša vložiť čísla 1...9 a testuje, či nenastane konflikt v riadku, stĺpci alebo štvorci
- ak niektoré číslo sedí, zavolá sa rekurzívne na vyplnenie zvyšných bielych miest
void generuj(int **a) { najdiVolne(a,r,s); if ((r < 0)||(s < 0)) { vypis(a); } else { for (int x = 1; x <= 9; x++) { if (moze(a, r, s, x)) { a[r][s]=x; generuj(a); a[r][s]=0; } } } }
Nájdenie voľného miesta v tabuľke urobíme jednoduchým prechodom matice a hľadaním miesta, ktoré má hodnotu 0. Jeho súradnice uložíme do premenných r,s ak také existuje. V opačnom prípade nastavíme r=s=-1.
Funkcia môže prechádza riadok, stĺpec a štvorec do ktorého patrí miesto, ktoré práve obsadzujeme. Zisťuje, či sa poteniálny kandidát nenachádza uz niekde inde.
bool moze(int **a, int riadok, int stlpec, int hodnota) { /* Mozeme ulozit danu hodnotu na dane policko? * Da sa to, ak riadok, stlpec, ani stvorec nema * tuto hodnotu este pouzitu. */ for (int i = 0; i < 9; i++) { if (a[riadok][i] == hodnota) return false; if (a[i][stlpec] == hodnota) return false; } /* lavy horny roh stvorca */ int riadok1 = riadok - riadok % 3; int stlpec1 = stlpec - stlpec % 3; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { if (a[riadok1 + i][stlpec1 + j] == hodnota) return false; } } return true; }
Úpravy v sudoku
- Plochu zodpovedajúcu sudoku si nemusíme ukaldať ako dvojrozmerné pole veľkosti 9x9. V podstate nám stačí jednorozmerné veľkosti 9*9=81, kde miesto plocha[i] bude zodpovedať pôvodnému a[i/3][i%3]
- Tiež si môžeme pamätať, ktoré čísla sú už obsadené v riadku, stĺpci a štvorci.
Namiesto globálnych premenných si vytvoríme si struct sudoku, do ktorého uložíme všetky potrebné údaje pre rekurzívne vyhľadávanie.
struct policko { int riadok, stlpec, stvorec; int hodnota; }; struct sudoku { policko *plocha; /* pole vsetkych policok plochy */ bool *obsadeneRiadok; /* pre kazdy riadok ci je dana cifra uz pouzita */ bool *obsadeneStlpec; /* pre kazdy stlpec ci je dana cifra uz pouzita */ bool *obsadeneStvorec; /* pre kazdy stvorec ci je dana cifra uz pouzita */ int pocetPolicok; /* celkovy pocet policok (9*9) */ int pocet; /* celkovy pocet riadkov,stlpcov a stvorcov (9) */ int rieseni; /* pocet najdenych rieseni */ };
Hneď pri inicializácii si musíme pre každé políčko povedať, kam vlastne patrí. Predpokladajme, že zadanie máme v dvojrozmernom poli a.
void inicializuj(sudoku &s, int **a) { /* inicializuj strukturu sudoku na zaklade * vstupnej matice s cislami 0..9*/ s.pocetPolicok = 9 * 9; s.pocet = 9; /* alokujeme polia a oznacime cifry ako neobsadene */ s.plocha = new policko[s.pocetPolicok]; s.obsadeneRiadok = new bool*[s.pocet]; s.obsadeneStlpec = new bool*[s.pocet]; s.obsadeneStvorec = new bool*[s.pocet]; for (int i = 0; i < s.pocet; i++) { s.obsadeneRiadok[i] = new bool[10]; s.obsadeneStlpec[i] = new bool[10]; s.obsadeneStvorec[i] = new bool[10]; for (int j = 1; j <= 9; j++) { s.obsadeneRiadok[i][j] = false; s.obsadeneStlpec[i][j] = false; s.obsadeneStvorec[i][j] = false; } } /* pre kazde policko naplnime jeho strukturu * a vyplnime obsadene cifry */ int pozicia = 0; for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { s.plocha[pozicia].riadok = i; s.plocha[pozicia].stlpec = j; s.plocha[pozicia].stvorec = (i / 3)*3 + (j / 3); uloz(s, pozicia, a[i][j]); pozicia++; } } /* este sme nenasli ziadne riesenie */ s.rieseni = 0; }
Rekurzia už potom musí okrem priradenia hodnoty na políčko obhospodáriť aj obsadenosť daného čísla v riadku, stĺpci a štvorci. Bude teda vyzera takto:
void generuj(sudoku &s) { int i = najdiVolne(s); if (i < 0) { vypis(s); } else { for (int x = 1; x <= 9; x++) { if (moze(s, i, x)) { uloz(s, i, x); generuj(s); zmaz(s, i, x); } } } }
- Nájdenie voľného miesta ostáva podobné, ako v predchádzajúcom prípade.
- Uloženie alebo zmazanie hodnoty musí okrem priradenia hodnoty upraviť aj hodnoty v obsadeneRiadok, obsadeneStlpec a obsadeneStvorec. Funckcia uloz teda vyzerá nasledovne (funckiu zmaz analogicky):
void uloz(sudoku &s, int pozicia, int hodnota) { s.plocha[pozicia].hodnota = hodnota; if (hodnota > 0) { int riadok= s.plocha[pozicia].riadok; int stlpec= s.plocha[pozicia].stlpec; int stvorec= s.plocha[pozicia].stvorec; s.obsadeneRiadok[riadok][hodnota] = true; s.obsadeneStlpec[stlpec][hodnota] = true; s.obsadeneStvorec[stvorec][hodnota] = true; } }
- Funkcia moze() sa nám naopak zjednoduší. Na určenie, či hodnotu x môžeme priradiť na políčko p nám stačí skontrolovať či s.obsadeneRiadok[p.riadok], s.obsadeneStlpec[p.stlpec] aj s.obsadeneStvorec[p.stvorec] sú false.
Ešte si to zoptimalizujeme
Vidíme, že obsadeneRiadok, obsadeneStlpec aj obsadeneStvorec sú veľmi podobné polia. Môžeme si teda vytvoriť pole, ktoré celkovo popisuje obsadené prvky v ľubovoľnej skupine. Každý prvok potom má určené svoje skupiny do ktorých patrí (už nie tromi premennými riadok, stlpec, stvorec ale v poli, ktoré obsahuje indexy skupín v poli obsadene, kam políčko patrí).
- Výsledný program je tu: #Program Sudoku
- Takýmto spôsobom si vieme pridávať ďalšie požiadavky na naše riešenie sudoku.
- Čo by bolo treba zmeniť v programe, aby zakazoval opakujúce sa cifry aj na hlavnej diagonále celej plochy?
Dalšie možné úpravy
- Zlepšite algoritmus tak, aby nezačínal vždy s prvým prázdnym políčkom, ale s takým, ktoré má najmenej neobsadených možností (v ideálnom prípade 1). Ak má niektoré nevyplnené políčko 0 možností, môžeme túto vetvu hľadania tiež ukončiť.
Program rekurzívne vyfarbovanie
#include "../SimpleDraw.h" #include <cstdio> const string farby[4] = {"white", "green", "black", "brown"}; /* velkost stvorceka mapy v pixeloch */ const int stvorcek = 15; /* cakanie po kazdom kroku vysvetlovania */ double waitTime = 0.3; int ** vytvorMaticu(int n, int m) { /* vytvor maticu s n riadkami a m stlpcami */ int **a; a = new int *[n]; for (int i = 0; i < n; i++) { a[i] = new int[m]; } return a; } void zmazMaticu(int n, int m, int **a) { /* uvolni pamat matice s n riadkami a m stlpcami */ for (int i = 0; i < n; i++) { delete[] a[i]; } delete[] a; } void zobrazStvorcek(int i, int j, int farba, string farbaCiary, SimpleDraw &window) { /* zobraz stvorcek v riadku i a stlpci j */ window.setPenColor(farbaCiary); window.setBrushColor(farby[farba]); window.drawRectangle(j*stvorcek, i*stvorcek, stvorcek, stvorcek); } void zobrazMaticu(int **a, int n, int m, SimpleDraw &window) { /* zobraz vsetky stvorceky matice */ for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { zobrazStvorcek(i, j, a[i][j], "lightgray", window); } } } void obdlznik(int **a, int riadok, int stlpec, int vyska, int sirka, int farba) { /* do matice vykresli ram obdlznika urcitej farby */ for (int i = 0; i < sirka; i++) { a[riadok][stlpec + i] = farba; a[riadok + vyska - 1][stlpec + i] = farba; } for (int i = 0; i < vyska; i++) { a[riadok + i][stlpec] = farba; a[riadok + i][stlpec + sirka - 1] = farba; } } void naplnMaticu(int **a, int n, int m) { /* do matice vykrelsi tri obdlzniky. Rozmery musia byt aspon * 11 riadkov a 17 stlpcov */ for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { a[i][j] = 0; } } obdlznik(a, 3, 9, 3, 7, 2); obdlznik(a, 1, 3, 8, 9, 1); obdlznik(a, 5, 1, 6, 7, 2); obdlznik(a, 7, 13, 3, 4, 1); } void vyfarbi(int **a, int n, int m, int riadok, int stlpec, int farba, SimpleDraw &window) { /* prefarbi suvislu jednofarebnu oblast obsahujucu * a[riadok][stlpec] na farbu farba */ if (a[riadok][stlpec] != farba) { int stara_farba = a[riadok][stlpec]; a[riadok][stlpec] = farba; zobrazStvorcek(riadok, stlpec, a[riadok][stlpec], "red", window); window.wait(waitTime); if (riadok > 0 && a[riadok - 1][stlpec] == stara_farba) { vyfarbi(a, n, m, riadok - 1, stlpec, farba, window); } if (riadok + 1 < n && a[riadok + 1][stlpec] == stara_farba) { vyfarbi(a, n, m, riadok + 1, stlpec, farba, window); } if (stlpec > 0 && a[riadok][stlpec - 1] == stara_farba) { vyfarbi(a, n, m, riadok, stlpec - 1, farba, window); } if (stlpec + 1 < m && a[riadok][stlpec + 1] == stara_farba) { vyfarbi(a, n, m, riadok, stlpec + 1, farba, window); } zobrazStvorcek(riadok, stlpec, a[riadok][stlpec], "lightgray", window); window.wait(waitTime); } } int main(void) { int n = 11; int m = 17; int **a = vytvorMaticu(n, m); naplnMaticu(a, n, m); SimpleDraw window(m*stvorcek, n * stvorcek); zobrazMaticu(a, n, m, window); //vyfarbi(a, n, m, 1, 6, 3, window); vyfarbi(a, n, m, 0, 0, 3, window); window.showAndClose(); zmazMaticu(n, m, a); }
Ukážkový program ostrovy
#include "../SimpleDraw.h" #include <cstdio> const string farby[3] = {"white", "green", "black"}; /* velkost stvorceka mapy v pixeloch */ const int stvorcek = 15; int ** vytvorMaticu(int n, int m) { /* vytvor maticu s n riadkami a m stlpcami */ int **a; a = new int *[n]; for (int i = 0; i < n; i++) { a[i] = new int[m]; } return a; } void zmazMaticu(int n, int m, int **a) { /* uvolni pamat matice s n riadkami a m stlpcami */ for (int i = 0; i < n; i++) { delete[] a[i]; } delete[] a; } void nacitajMaticu(FILE *f, int n, int m, int **a) { /* matica je vytvorena, velkosti n, m, vyplnime ju cislami zo vstupu */ for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { fscanf(f,"%d ",&a[i][j]); } } } void zobrazStvorcek(int i, int j, int farba, string farbaCiary, SimpleDraw &window) { /* zobraz stvorcek v riadku i a stlpci j */ window.setPenColor(farbaCiary); window.setBrushColor(farby[farba]); window.drawRectangle(j*stvorcek, i*stvorcek, stvorcek, stvorcek); } void zobrazMaticu(int **a, int n, int m, SimpleDraw &window) { /* zobraz vsetky stvorceky matice */ for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { zobrazStvorcek(i, j, a[i][j], "lightgray", window); } } } void vyfarbi(int **a, int n, int m, int riadok, int stlpec, int farba) { /* prefarbi suvislu jednofarebnu oblast obsahujucu * a[riadok][stlpec] na farbu farba */ if (a[riadok][stlpec] != farba) { int stara_farba = a[riadok][stlpec]; a[riadok][stlpec] = farba; if (riadok > 0 && a[riadok - 1][stlpec] == stara_farba) { vyfarbi(a, n, m, riadok - 1, stlpec, farba); } if (riadok + 1 < n && a[riadok + 1][stlpec] == stara_farba) { vyfarbi(a, n, m, riadok + 1, stlpec, farba); } if (stlpec > 0 && a[riadok][stlpec - 1] == stara_farba) { vyfarbi(a, n, m, riadok, stlpec - 1, farba); } if (stlpec + 1 < m && a[riadok][stlpec + 1] == stara_farba) { vyfarbi(a, n, m, riadok, stlpec + 1, farba); } } } int main(void) { /* nacitaj rozmery matice */ int n, m; FILE *f; f=fopen("vstup.txt","r"); if (!f) return -1; fscanf(f,"%d %d ",&n,&m); /* vytvor a nacitaj maticu */ int **a = vytvorMaticu(n, m); nacitajMaticu(f, n, m, a); fclose(f); for(int i=0; i<n; i++) { for(int j=0; j<m; j++) { if(a[i][j]>0) a[i][j] = 1; } } SimpleDraw window(m*stvorcek, n * stvorcek); zobrazMaticu(a, n, m, window); int ostrovov = 0; for(int i=0; i<n; i++) { for(int j=0; j<m; j++) { if(a[i][j]==1) { ostrovov++; vyfarbi(a, n, m, i, j, 2); window.clear(); zobrazMaticu(a, n, m, window); window.show(); } } } printf("Pocet ostrovov: %d\n",ostrovov); window.showAndClose(); zmazMaticu(n, m, a); }
Program Sudoku
#include <cstdio> using namespace std; /* kazde policko patri do 3 skupin: riadok, stlpec a stvorec */ const int SKUPIN = 3; /* udaje o jednom policku plochy: suradnice, * hodnota (0 ak prazdne, alebo 1..9, * a zoznam skupin, do ktorych patri. */ struct policko { int riadok, stlpec; int hodnota; int skupiny[SKUPIN]; }; struct sudoku { policko *plocha; /* pole vsetkych policok plochy */ bool **obsadene; /* pre kazdy skupiny ci je dana cifra uz pouzita */ int pocetPolicok; /* clekovy pocet policok (9*9) */ int pocetSkupin; /* clekovy pocet skupin (3*9) */ int rieseni; /* pocet najdenych rieseni */ }; void vypis(FILE *f, sudoku &s) { /* vypis riesenie sudoku a zvys pocitadlo rieseni */ s.rieseni++; int pozicia = 0; for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { fprintf(f," %d",s.plocha[pozicia].hodnota); pozicia++; } fprintf(f,"\n"); } fprintf(f,"\n"); } int najdiVolne(sudoku &s) { /* najdi volne policko na ploche */ for (int i = 0; i < s.pocetPolicok; i++) { if (s.plocha[i].hodnota == 0) return i; } return -1; } bool moze(sudoku &s, int pozicia, int hodnota) { /* Mozeme ulozit danu hodnotu na policko s poradovym cislom pozicia? * Da sa to, ak ziadna so skupin tohto policka nema * tuto hodnotu uz pouzitu. */ for (int i = 0; i < SKUPIN; i++) { /* cislo i-tej skupiny pre policko */ int skupina = s.plocha[pozicia].skupiny[i]; /* ak je uz hodnota obsadena, neda sa pouzit */ if (s.obsadene[skupina][hodnota]) return false; } /* vo vsetkych skupinach je hdonota neobsadena */ return true; } void uloz(sudoku &s, int pozicia, int hodnota) { /* na policko s poradovym cislom pozicia uloz danu * hodnotu. Ak je hodnota > 0, zaregistruj ju * tiez ako obsadenu vo vsetkych skupinach, * kam policko patri. */ s.plocha[pozicia].hodnota = hodnota; if (hodnota > 0) { for (int i = 0; i < SKUPIN; i++) { int skupina = s.plocha[pozicia].skupiny[i]; s.obsadene[skupina][hodnota] = true; } } } void zmaz(sudoku &s, int pozicia) { /* hodnotu v policku s pozicia zmen na nulu * a povodnu hodnotu odznac v poliach obsadene pre vsetky * skupiny tohto policka */ int hodnota = s.plocha[pozicia].hodnota; s.plocha[pozicia].hodnota = 0; for (int i = 0; i < SKUPIN; i++) { int skupina = s.plocha[pozicia].skupiny[i]; s.obsadene[skupina][hodnota] = false; } } void generuj(FILE *f,sudoku &s) { /* mame ciastocne vyplnenu plochu sudoku, * chceme najst vsetky moznosti, ako ho dovyplnat. */ int i = najdiVolne(s); if (i < 0) { vypis(f,s); } else { for (int x = 1; x <= 9; x++) { if (moze(s, i, x)) { uloz(s, i, x); generuj(f,s); zmaz(s, i); } } } } void inicializuj(sudoku &s, int **a) { /* inicializuj strukturu sudoku na zaklade * vstupnej matice s cislami 0..9*/ s.pocetPolicok = 9 * 9; s.pocetSkupin = 3 * 9; /* alokujeme polia a oznacime cifry ako neobsadene */ s.plocha = new policko[s.pocetPolicok]; s.obsadene = new bool*[s.pocetSkupin]; for (int i = 0; i < s.pocetSkupin; i++) { s.obsadene[i] = new bool[10]; for (int j = 1; j <= 9; j++) { s.obsadene[i][j] = false; } } /* pre kazde policko naplnime jeho strukturu * a vyplnime obsadene cifry */ int pozicia = 0; for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { s.plocha[pozicia].riadok = i; s.plocha[pozicia].stlpec = j; s.plocha[pozicia].skupiny[0] = i; s.plocha[pozicia].skupiny[1] = 9 + j; s.plocha[pozicia].skupiny[2] = (i / 3)*3 + (j / 3) + 18; uloz(s, pozicia, a[i][j]); pozicia++; } } /* este sme nenasli ziadne riesenie */ s.rieseni = 0; } void uvolni(sudoku &s) { /* alokujeme polia a oznacime cifry ako neobsadene */ for (int i = 0; i < s.pocetSkupin; i++) { delete[] s.obsadene[i]; } delete[] s.obsadene; delete[] s.plocha; } int main(void) { /* alokujeme a nacitame 2D maticu so vstupom */ int **a = new int *[9]; for (int i = 0; i < 9; i++) { a[i] = new int[9]; } FILE *f; f=fopen("vstup.txt","r"); if (!f) return -1; for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { fscanf(f,"%d ",&a[i][j]); } } fclose(f); /* vytvorime struktury pre sudoku */ sudoku s; inicializuj(s, a); f=fopen("vystup.txt","w"); if (!f) return -1; /* rekurzivne prehladavanie s navratom */ generuj(f,s); fclose(f); /* vypis riesenia */ printf("Pocet rieseni: %d\n",s.rieseni); /* este by sme mali odalokovat polia v sudoku */ for (int i = 0; i < 9; i++) { delete[] a[i]; } delete[] a; uvolni(s); }
Prednáška 20
Aritmetické výrazy
Infixový zápis (infixová forma alebo notácia) aritmetického výrazu
- bežný zápis používaný v matematike
- každý binárny operátor medzi dvoma operandami, s ktorými sa bude vykonávať príslušná operácia
- poradie, v akom sa jednotlivé operácie vykonávajú, sa riadi umiestnením zátvoriek a prioritou operácií
Napríklad: (65 – 3*5)/(2 + 3)
Vyhodnocovanie výrazov v infixovej notácii sme ukázali na prednáške 9.
- Pre jednoduchosť: úplne uzátvorkovaný výraz, znamienka + a -, čísla, bez medzier, napr. (((12-5)+7)-(6+8))
Pripomeňme si kostru programu:
int vyhodnotVyraz(char str[]){ if (str[0] != '(') return vyhodnotCislo(str); else { char s[100]; int poz, hodnota1, hodnota2; poz = najdiZnamienko(str); strCopy(str, s, 1, poz-1); // kopíruj od 1 po pozíciu pred znamienkom (pozícia 0 je '(' ) hodnota1 = vyhodnotVyraz(s); strCopy(str, s, poz+1, strlen(str)-2); // od pozície po znamienku po predposledný znak stringu (posledný znak - strlen()-1 je ')' ) hodnota2 = vyhodnotVyraz(s); switch (str[poz]){ case '+': return hodnota1+hodnota2; case '-': return hodnota1-hodnota2; } return 0; } }
int najdiZnamienko(char str[]){ /*Vieme, ze vyraz je tvaru (Vyraz1 Z Vyraz2)*/ int poc=0; for (int i=1; i<strlen(str)-1; i++){ if (str[i]=='(') poc++; else if (str[i]==')') poc--; else if (((str[i]=='+')||(str[i]=='-'))&&(poc==0)) return i; } return -1; }
V prípade, že by sme chceli výraz vyhodnocovať bez úplného uzátvorkovania, zmenila by sa hlavne funkcia, ktorá hľadá operand, ktorý potrebujeme vykonať.
Postfixová a prefixovová notácia
Okrem infixovej notácie se môžeme stretnúť s ďalšími formami zápisu aritmetických výrazov.
Postfixová notácia (obrátená poľská notácia) má v zápise výrazu operátor až po oboch operandoch.
Výraz (65 – 3*5)/(2 + 3) by teda v postfixovej forme mal notáciu 65 3 5 * - 2 3 + /
V prefixovej notácii je situácia opačná ako pri postfixovej notácii. Každý operátor stojí pred dvoma operandami, ku ktorým prislúcha.
Výraz (65 – 3*5)/(2 + 3) by v prefixovej forme bol / - 65 * 3 5 + 2 3
Postfixová a prefixová notácia sú na prvý pohľad pre človeka neprehľadné, ale ako uvidíme, dajú sa oveľa jednoduchšie vyhodnocovať. Okrem toho vidíme ešte jednu výhodu - nepotrebujú zátvorky.
Vyhodnocovanie postfixovej formy
Na vyhodnocovanie výrazov v postfixovej forme budeme používať zásobník. Budeme do neho vkladať operandy - teda hodnoty podvýrazov.
- Využijeme vlastnosť, že operátor má oba operandy pred sebou. Teda vo chvíli, keď narazíme na operátor, jeho operandy už máme niekde prečítané.
- Navyše sú to posledné dve prečítané alebo vypočítané hodnoty.
Pri vyhodnocovaní výrazu prechádzame výraz zľava doprava
- Keď narazíme na operand, uložíme ho do zásobníku.
- Keď narazíme na operátor, tak vyberieme dva operandy zo zásobníku.
- Ale pozor! Keďže máme zásobník (LIFO), musíme prehodiť poradie operandov oproti tomu, ako sme ich vybrali zo zásobníku
- Napríklad delenie a/b je v postfixovej notácii a b /, teda zo zásobníku najskôr vyberieme deliteľa (b) a ako druhého vyberieme delenca (a), a preto pri vykonávaní operácie musíme prehodiť ich poradie.
- Vykonáme operáciu s vybranými operandami a výsledok tejto operácie umiestnime späť do zásobníku.
Tento postup opakujeme, kým nedojdeme na koniec výrazu. V tom okamžiku by sme mali mať na zásobníku jeden prvok a to je výsledok výrazu.
int main(void) { stack s; // vytvor prazdny zasobnik init(s); char postfix[maxN]; // nacitaj vyraz do retazca fgets(postfix, maxN, stdin); int i = 0; while (postfix[i] != '\0') { if (isspace(postfix[i])) { // preskakuj biele znaky i++; } else if (isdigit(postfix[i]) || postfix[i]=='.') { // spracuj jedno cislo zo vstupu push(s, evaluateNumber(postfix, i)); } else { // binarny operator double elem1 = pop(s); double elem2 = pop(s); switch (postfix[i]) { case '+': push(s, elem2 + elem1); break; case '-': push(s, elem2 - elem1); break; case '*': push(s, elem2 * elem1); break; case '/': push(s, elem2 / elem1); break; } i++; } } printf("%f\n", pop(s)); // na zasobniku mame vysledok assert(isEmpty(s)); // teraz uz je zasobnik prazdny }
Funkcia evaluateNumber môže vyzerať napríklad takto:
double evaluateNumber(char str[], int &i) { /* Z retazca od pozicie i precitaj cislo az po prvy * iny znak (medzera, koniec retazca, operator). * Cislo i sa nastavi na prvu poziciu, ktora sa neda precitat. */ double val = 0; while (isdigit(str[i])) { val = val * 10 + (str[i] - '0'); i++; } /* desatinna cast */ if (str[i] == '.') { i++; double power = 0.1; while (isdigit(str[i])) { val += (str[i] - '0') * power; power /= 10; i++; } } return val; }
Konverzia infixovej formy na postfixovú
Vidíme, že vyhodnocovanie postfixového výrazu je jednoduché. Väčšinou však pracujeme s infixovou formou zápisu a preto ju potrebujeme nejakým spôsobom prepísať do postfixovej.
Pre jednoduchosť si najskôr ukážeme iba výrazy bez zátvoriek (* a - majú vyššiu prioritu ako + a -). Použijeme zásobník, do ktorého si budeme ukladať zatiaľ nevypísané časti infixovej formuly (teda operátory, ktoré ešte nemajú oba operandy).
Pri vyhodnocovaní prechádzame výrazom zľava doprava:
- Ak objavíme operand, prepíšeme ho do postfixového reťazca a ďalej nás už nezaujíma.
- Ak narazíme na operátor, pozrieme sa na vrch zásobníka:
- Kým operátor zo zásobníka má väčšiu alebo rovnakú prioritu, tak vyberáme zo zásobníka (a vybrané operátory prepíšeme do postfixového reťazca). Vypisujeme až dokiaľ nenarazíme na operátor s nižšou prioritou (alebo dno).
- Po tomto kroku umiestnime aktuálny operátor do zásobníka.
- Tento postup opakujeme pokiaľ nenarazíme na koniec výrazu.
- Potom vyberieme operátory zo zásobníka a umiestnime ich na výstup.
Pridanie zátvoriek:
- Ľavú zátvorku iba ju vložíme do zásobníka
- Keď narazíme na pravú zátvorku, znamená to, že všetky operátory, ktoré boli v zátvorke, by mali byť už vypísané na výstup. Preto ich vypisujeme, až kým nenarazíme na ľavú zátvorku.
int precedence(char op) { if (op == '#' || op == '(') return 0; // specialne pripady, ktore bezne nevyhadzujeme if (op == '-' || op == '+') return 1; if (op == '*' || op == '/') return 2; assert(false); // sem by sme sa nemali dostat } int main(void) { char infix[maxN], postfix[maxN]; fgets(infix, 100, stdin); // nacita aritmeticky vyraz v infixovej forme stack s; // vytvor prazdny zasobnik init(s); push(s, '#'); // specialne dno zasobnika int j = 0; /* index do vystupneho retazca */ for (int i = 0; infix[i] != 0; i++) { if (isdigit(infix[i]) || infix[i]=='.') { /* cisla skopirujeme na vystup */ postfix[j++] = infix[i]; } else if (isspace(infix[i])) { /* biele znaky preskakujeme */ } else if (infix[i] == '(') { /* zaciatok zatvorky dame na zasobnik */ push(s, infix[i]); } else if (infix[i] == ')') { /* koniec zatvorky znamena, ze vypiseme vsetky operatory, * co boli v tej zatvorke (a este nie su vypisane)*/ char popped = pop(s); postfix[j++] = ' '; while (popped != '(') { postfix[j++] = popped; postfix[j++] = ' '; popped = pop(s); } } else { /* spracovanie operatora */ postfix[j++] = ' '; // pridame medzeru int p = precedence(infix[i]); // dolezitost prichadzajuceho operatora while (precedence(peek(s)) >= p) { postfix[j++] = pop(s); postfix[j++] = ' '; } push(s, infix[i]); } } /* vsetko, co na zasobniku ostalo, vypiseme */ char popped = pop(s); postfix[j++] = ' '; while (popped != '#') { postfix[j++] = popped; postfix[j++] = ' '; popped = pop(s); } postfix[j] = '\0'; printf("Postfix: %s\n", postfix); }
- Program na niekoľkých miestach pridáva medzery (občas zbytočné), aby sa nám operandy nezliali do jedného čísla a vedeli sme ich následne vyhodnocovať.
- Nefunguje pre unárne mínus (napr. 2*-3), ktoré treba detekovať a kopírovať na výstup spolu s číslom (a správne spracovávať aj v postfixovej notácii)
Cvičenia:
- Ako by ste rozšírili o operáciu umocnenia ^ s ešte vyššou prioritou ako *?
- Niektoré časti programu (cykly while) sa trochu opakujú, ako by sa to dalo vyriešiť pomocnou funkciou?
- Ako by sme program upravili, aby nikde nedal dve medzery za sebou?
Zhrnutie
Aritmetické výrazy
- Bežná infixová notácia, napr. (65 – 3*5)/(2 + 3)
- Úplne uzátvorkovaná, napr. ((65 – (3*5))/(2 + 3))
- Postfixová notácia 65 3 5 * - 2 3 + /
- Prefixová notácia / - 65 * 3 5 + 2 3
- Prefixová a postfixová notácia nepotrebujú zátvorky
- Prevod z infixovej notácie na postfixovú pomocou zásobníka
- Čo si ukladáme do zásobníka?
- Vyhodnocovanie postfixovej notácie pomocou zásobníka
- Čo si ukladáme do zásobníka?
Aritmetický výraz ako strom
Ďalšia téma:
- uloženie aritmetického výrazu vo forme stromu a práca so stromami všeobecne
Budúci týždeň:
- ďalšie príklady stromov v informatike
Reprezentácia aritmetického výrazu vo forme stromu
- Každý operátor a každé číslo tvorí vrchol stromu
- Vrchol pre operátor má pod sebou zavesené menšie stromy pre podvýrazy, ktoré spája
- Informatici stromy väčšinou kreslia hore nohami, s koreňom na vrchu
- V našom príklade je koreň vrchol s operátorom /
Dátová štruktúra pre vrcholy stromu
struct node { /* vrchol stromu */ double val; /* ciselna hodnota */ char op; /* operator '+', '-', *', '/', alebo ' ' ak ide o hodnotu */ node * left; /* lavy podvyraz */ node * right; /* pravy podvyraz */ };
Ak máme vrchol pre operátor:
- left a right sú smerníky na ľavý a pravý podvýraz
- znak op je znamienko operátora, napr. '+'
- hodnota val je nevyužitá
Ak máme vrchol pre číslo vo výraze:
- left a right majú hodnotu NULL (žiadne podvýrazy)
- znak op má hodnotu medzera ' '
- val obsahuje hodnotu čísla
Jednoduchá ale nie veľmi elegantná reprezentácia
- niektoré položky sú nevyužité (val v operátoroch, left a right pri číslach)
- budúci semester uvidíme krajšie riešenie pomocou objektov
Vytváranie vrcholov stromu
Nasledujúce dve funkcie vytvoria nový vrchol.
- Pre vrchol typu operátor už funkcia dostane smerníky na vrcholy pre podvýrazy
node * createOp(char op, node *left, node *right) { /* vytvori novy vrchol stromu s operatorom op * a do jeho laveho a praveho podvyrazu ulozi * smerniky left a right. */ node *v = new node; v->left = left; v->right = right; v->op = op; return v; } node * createNum(double val) { /* Vytvori novy vrchol stromu s danou hodnotou, * lavy a pravy podvyraz bude prazdny, op bude medzera */ node *v = new node; v->left = NULL; v->right = NULL; v->op = ' '; v->val = val; return v; }
Vytvorme teraz ručne strom pre náš výraz (65 – 3*5)/(2 + 3):
node *v = createOp('/', createOp('-', createNum(65), createOp('*', createNum(3), createNum(5))), createOp('+', createNum(2), createNum(3)));
Alebo to môžeme rozpísať po krokoch:
node *v65 = createNum(65); node *v3 = createNum(3); node *v5 = createNum(5); node *v2 = createNum(2); node *v3b = createNum(3); node *vKrat = createOp('*', v3, v5); node *vMinus = createOp('-', v65, vKrat); node *vPlus = createOp('+', v2, v3b); node *vDeleno = createOp('/', vMinus, vPlus);
Vyhodnocovanie výrazu
double evaluate(node *v) { /* vyhodnoti vyraz dany stromom s korenom vo vrchole v */ assert(v != NULL); /* ak je operator medzera, vratime jednoducho hodnotu */ if (v->op == ' ') { return v->val; } /* rekurzivne vyhodnotime lavy a pravy podvyraz */ double valLeft = evaluate(v->left); double valRight = evaluate(v->right); /* Hodnotu laveho a praveho podvyrazu spojime podla typu operatora * a vratime. Prikaz break netreba, pouzivame return. */ switch (v->op) { case '+': return valLeft + valRight; case '-': return valLeft - valRight; case '*': return valLeft * valRight; case '/': return valLeft / valRight; default: assert(false); } }
Zhrnutie
- Aritmetický výraz vieme reprezentovať aj ako strom.
- Rekurzívnou funkciou môžeme potom ľahko spočítať jeho hodnotu.
- Nabudúce si ukážeme, ako prerobiť postfixovú formu na strom (a tým pádom vieme prerobiť aj infixovú, lebo tú vieme prerobiť na postfixovú).
- Ukážeme si tiež, ako výraz reprezentovaný stromom vypísať vo všetkých troch formách.
Terminológia stromov
- Strom má vrcholy (nodes, vertices) a tie sú pospájané hranami (edges)
- Nás zaujímajú zakorenené stromy, ktoré majú jeden vrchol zvolený ako koreň (root)
- Každý iný vrchol okrem koreňa je spojený hranou s jedným otcom (parent) a s niekoľkými (nula alebo viac) synmi (children)
- Listy sú vrcholy, ktoré nemajú deti, ostatné vrcholy voláme vnútorné
- V binárnom strome má každý vrchol najviac dve deti
- Predkovia vrchola sú všetky vrcholy na ceste od neho smerom ku koreňu, teda on sám, jeho otec, otec jeho otca atď, až kým nenarazíme na koreň
- Ak x predkom y, tak y je potomkom x
- Podstrom s koreňom vo vrchole x tvorí vrchol x a všetci jeho potomkovia
- Strom je teda buď prázdny, alebo je tvorený koreňom a dvoma podstromami: ľavým a pravým.
Náš aritmetický strom
- Je binárny
- V listoch sú čísla, vo vnútorných vrcholoch operácie
- Každý vnútorný vrchol má dve deti
Cvičenia 10
Spájané zoznamy
- Napíšte funkciu vyhod(linkedList &z), ktorá z jednosmerného spájaného zoznamu vyhodí všetky záznamy, v ktorých má položka data nulovú hodnotu. Pozor, takéto záznamy sa môžu vyskytovať aj na začiatku zoznamu. Vyhodené položky zoznamu treba odalokovať. V prednáške 16 nájdete funkcie na vytvorenie a vypísanie zoznamu, ktoré môžete použiť na testovanie vašej funkcie.
- Napíšte funkciu kopiruj(linkedList &kam, linkedList &odkial), ktorá vytvorí kópiu zoznamu odkial a uloží ju do zoznamu kam.
Slovník
- V knižnici má každý čitateľ pridelené identifikačné číslo, ktoré je možné uložiť do premenej typu int. V jednom súbore má knižnica uvedený zoznam ID čitateľov, ktorým treba poslať upomienku (je to súbor, v ktorom sú len celé čísla oddelené bielymi znakmi). V druhom súbore má knižnica emailové adresy všetkých čitateľov, pričom na každom riadku je najskôr ID čitateľa, potom medzera a potom emailová adresa (ktorá neobsahuje biele znaky) a za ňou koniec riadku. Môžete predpokladať, že dĺžka emailovej adresy je najviac 100 a počet čitateľov je najviac 1000. S využitím slovníka napíšte program, ktorý vypíše adresy čitateľov, ktorým treba poslať upomienku.
- jedna možnosť je do slovníka načítať zoznam čitateľov s upomienkou (kľúč bude ID) a potom čítate adresy jednu po druhej a pre každú zistíte, či ju máte vypísať alebo nie
- druhá možnosť je do slovníka uložiť všetky adresy (kľúč opäť ID) a potom čítať zoznam upomienok a pri každej zo slovníka získať adresu.
- Pri ladení programu použite niektorú implementáciu slovníka z prednášky 17
Príklad. Adresy:
123 janko.hrasko@email.com 17 ferko.mrkvicka@inymail.sk 26 baba.jaga@chalupka.na.stracej.nozke.eu
Upomienky:
26 123
Výstup:
baba.jaga@chalupka.na.stracej.nozke.eu janko.hrasko@email.com
Ešte spájané zoznamy
- Napíšte funkciu zip(linkedList &z1, linkedList &z2, linkedList &z3), ktorá vyvorí z dvoch zoznamov ich "zips" - vo výslednom zozname sa budú postupne striedať prvky z prvého a druhého zoznamu. Pokiaľ má jeden zoznam viac prvkov ako ten druhý, tak jeho zvyšné prvky budú na konci zoznamu.
zip({1,2,3}, {10,11,12,13,14}) = {1,10,2,11,3,12,13,14}
- Napíšte funkciu reverse(linkedList &z), ktorá otočí poradie prvkov v zozname (jednosmernom spájanom).
Ešte slovník
- Implementáciu slovníka pomocou hashovania prerobte tak, aby si slovník pamätal, koľko celkovo obsahuje prvkov a vždy, keď počet prvkov prekročí polovicu dĺžky tabuľky, zvolí väčšiu veľkosť tabuľky, alokuje väčšie pole, pre všetky prvky spočíta ich novú hodnotu hashovacej funkcie (s novým n) a umiestni ich do príslušného políčka nového poľa. Staré pole odalokuje. Ideálne by sme ako n mali vhodné prvočísla, ale pre jednoduchosť môžete staré n jednoducho vynásobiť 2. Všimnite si, že tabuľku chceme zväčšiť už keď počet prvkov dosiahne polovicu jej veľkosti, lebo hashovanie pracuje rýchlejšie pri riedšie zaplnených tabuľkách, kde je menej kolízií.
DÚ8
Odovzdávanie DÚ8 max. 10 bodov, termín odovzdania pondelok 26.11. o 22:00
Cieľom tejto domácej úlohy je precvičiť si prácu so spájanými zoznamami a s rekurziou.
Napíšte verziu triedenia QuickSort, ktorá bude triediť dáta v spájanom zozname. Vo vašom programe použite jednosmerný spájaný zoznam, ktorý si udržuje smerník na prvý aj posledný prvok zoznamu. V kostre uvedenej nižšie najskôr naprogramujte podporné funkcie insertLast, length, moveItem a concatenate, ktoré pracujú s takýmito zoznamami. Potom naprogramujte funkciu divide, ktorá podľa pivota rozdelí zoznam na tri podzoznamy a rekurzívnu funkciu quickSort, ktorá s pomocou divide zoznam rozdelí na menšie, tie rekurzívne utriedi a pomocou concatenate spojí. Zoznamy dĺžky 1 a 0 už netreba triediť. Presnejšie popisy jednotlivých funkcií nájdete v kostre programu, pokúste sa ich držať.
Celý program načítava od užívateľa čísla až kým užívateľ nezadá číslo -1, potom ich utriedi a vypíše výsledok.
Pokiaľ možno počas samotného triedenia nepoužívajte new a delete, zoznamy modifikujte iba menením smerníkov next v jednotlivých item-och a smerníkov first a last v zoznamoch (môžete používať lokálne premenné typu linkedList). V programe sa teda new sa použije iba pri načítavaní vo funkcii insertLast a delete sa použije na konci programu vo funkcii destroy. Doporučujeme skontrolovať programom valgrind, či váš program správne alokuje a odalokuje všetku pamäť.
#include <iostream> #include <cassert> using namespace std; struct item { /* prvok spajaneho zoznamu so smernikom na dalsi */ int data; item* next; }; struct linkedList { /* spajany zoznam so smernikom na prvy a posledny prvok, * smerniky budu NULL ak je zoznam prazdny */ item *first; item *last; }; void init(linkedList &z) { /* inicializuje prazdny zoznam */ z.first = NULL; z.last = NULL; } bool isEmpty(const linkedList &z) { /* testuje, ci je zoznam prazdny */ return z.first == NULL; } void print(linkedList &z) { /* vypise vsetky prvky zoznamu oddelene medzerami */ item* x = z.first; while (x != NULL) { cout << x->data << " "; x = x->next; } cout << endl; } void destroy(linkedList &z) { /* uvolni pamat vsetkych buniek zoznamu */ while (z.first != NULL) { item* p = z.first; z.first = z.first->next; delete p; } } int length(linkedList &z) { /* vrati dlzku zoznamu */ // VAS KOD TU } void insertLast(linkedList &z, int d) { /* Vlozi prvok na posledne miesto v zozname. * Pozor na pripad, ked je zoznam prazdny */ // VAS KOD TU } void moveItem(linkedList &from, linkedList &to) { /* Dostane dva zoznamy from a to, pricom from je neprazdny. * Presunie prvy prvok zo zoznamu from na zaciatok zoznamu to. */ assert(!isEmpty(from)); // VAS KOD TU } void concatenate(linkedList &z1, linkedList &z2) { /* Zoznam z1 zmeni tak, ze za jeho posledny prvok pripoji zoznam z2. * Zoznam z2 uz nebude dalej pouzivany, takze je jedno, * kam jeho first a last ukazuje. Pozor na pripady, * ked je jeden alebo druhy zoznam prazdny. */ // VAS KOD TU } void divide(linkedList &z, linkedList &smaller, linkedList &equal, linkedList &greater) { /* Dostane neprazdny zoznam z a prazdne zoznamy smaller, equal a greater. * Prvy prvok zo z pouzije ako pivot a popremiestnuje prvky zo z do dalsich * troch zoznamov tak, aby vsetky prvky mensie ako pivot boli v smaller, * vsetky prvky rovne pivotu boli v equal a vsetky vacsie ako pivot boli v greater. * Pouzite funkciu moveItem. */ assert(!isEmpty(z) && isEmpty(smaller) && isEmpty(equal) && isEmpty(greater)); // VAS KOD TU } void quickSort(linkedList &z) { /* utriedi zoznam z */ // VAS KOD TU } int main() { linkedList z; init(z); /* nacitaj data zo vstupu */ while (1) { int data; cin >> data; if (data == -1) break; insertLast(z, data); } /* utried */ quickSort(z); /* vypis vysledok */ print(z); /* uvolni pamat */ destroy(z); }
Pokročilá DÚ4
Odovzdávanie DÚ max. 20 bodov, termín odovzdania pondelok 10.12. o 22:00
Cieľom tejto domácej úlohy je precvičiť si prácu so smerníkmi a binárnymi stromami. Vašou úlohou bude implementovať dátovú štruktúru podobnú binárnemu vyhľadávaciemu stromu. Oproti binárnemu vyhľadávaciemu stromu je však každý vrchol rozšírený o dva smerníky - smerník na predchodcu a smerník na nasledovníka. Binárne vyhľadávacie stromy budeme preberať na prednáškach v týždni od 26.11., predtým si môžete pozrieť prednášku z minulého semestra.
Dátová štruktúra
Binárny vyhľadávací strom rozšírený o nasledovníka a predchodcu bude pracovať s kľúčmi typu integer. Bude podporovať operácie insert, delete, find, predecessor a successor.
Vrchol binárneho stromu obsahuje
- Kľúč - typu integer (číslo uložené v strome)
- Smerníky na pravého a ľavého syna (podobne ako binárny vyhľadávací strom). Zároveň (ako v binárnom vyhľadávacom strome) pre každý vrchol v stromu platí, že
- Každý vrchol u v ľavom podstrome v má kľúč menší ako vrchol v
- Každý vrchol u v pravom podstrome v má kľúč väčší ako vrchol v
- Smerníky na predchodcu a nasledovníka v strome. Predchodca vrcholu s kľúčom k je vrchol s najväčším kľúčom menším ako k. Analogicky nasledovník vrcholu s kľúčom k je vrchol s najmenším kľúčom väčším ako k (na obrázku vidíme príklad nasledovníkov v binárnom strome)
Dátová štruktúra podporuje nasledovné operácie
- Insert vrchola s kľúčom k. Vrchol sa vloží do binárneho vyhľadávacieho stromu a upraví príslušné smerníky na predchodcov a nasledovníkov. V prípade, že vrchol s daným kľúčom sa už v strome nachádza, vypíše o tom patričnú chybovú hlášku.
- Delete vrchola s kľúčom k. Vymaže z binárneho vyhľadávacieho stromu vrchol s kľúčom k a upraví príslušné smerníky na predchodcov a nasledovníkov. V prípade, že sa vrchol s daným kľúčom nenachádza, vypíše o tom patričnú chybovú hlášku.
- Find vrchola s kľúčom k. Zistí, či sa v strome nachádza vrchol s daným kľúčom. V prípade, že áno vypíše true a v prípade, že sa vrchol s hľadaným kľúčom v strome nenachádza, vypíše false a dva najbližšie menšie a dva najbližšie väčšie kľúče zo stromu.
- Predecessor vrchola s kľúčom k. Nájde a vypíše predchodcu vrchola s kľúčom k alebo vypíše, že vrchol predchodcu nemá. V prípade, že sa vrchol s daným kľúčom nenachádza, vypíše o tom patričnú chybovú hlášku.
- Successor vrchola s kľúčom k. Nájde a vypíše nasledovníka vrchola s kľúčom k alebo vypíše, že vrchol nasledovníka nemá. V prípade, že sa vrchol s daným kľúčom nenachádza, vypíše o tom patričnú chybovú hlášku.
Vstup a výstup na testovanie
Na testovanie funkčnosti použijeme textový súbor (vstup.txt), ktorý bude obsahovať postupnosť operácií, ktoré na strome treba vykonať.
Vstupný súbor obsahuje na každom riadku písmenko reprezentujúce operáciu a následne jej parametre. Riadok teda obsahuje jednu z nasledovných možností:
- i nasledované celým číslom k. Vloží do stromu vrchol s kľúčom k.
- d nasledované celým číslom k. Vymaže zo stromu vrchol s kľúčom k.
- f nasledované celým číslom k. Vyhľadá v strome vrchol s kľúčom k a vypíše true alebo false. V prípade, že sa taký vrchol v strome nenachádza vypíše najbližšie dva menšie a najbližšie dva väčšie kľúče, ktoré v strome sú (ak tam také sú).
- p nasledované celým číslom k. Vypíše vrchol, ktorý je predchodcom vrchola s kľúčom k alebo informáciu, že vrchol nemá predchodcu.
- s nasledované celým číslom k. Vypíše vrchol, ktorý je nasledovníkom vrchola s kľúčom k alebo informáciu, že vrchol nemá nasledovníka.
- o vypíše v utriedenom poradí (podľa kľúča) vrcholy stromu.
Operácie postupne vykonajte začínajúc prázdnym binárnym vyhľadávacím stromom a výsledky vypisuje do súboru vystup.txt. Dodržte formát ako v príklade nižšie.
Príklad vstup.txt
i 5 i 3 i 10 o f 5 f 7 d 1 i 1 o p 1 p 2 p 5 d 5 o f 11
vystup.txt
3 5 10 true false mensie:3 5 vacsie:10 err: vrchol 1 v strome nie je 1 3 5 10 vrchol 1 nema predchodcu err: vrchol 2 v strome nie je 3 1 3 10 false mensie:3 10 vacsie:
Prednáška 21
Opakovanie
Aritmetické výrazy
- Bežná infixová notácia, napr. (65 – 3*5)/(2 + 3)
- Úplne uzátvorkovaná, napr. ((65 – (3*5))/(2 + 3))
- Postfixová notácia 65 3 5 * - 2 3 + /
- Prefixová notácia / - 65 * 3 5 + 2 3
- Prefixová a postfixová notácia nepotrebujú zátvorky
- Prevod z infixovej notácie na postfixovú pomocou zásobníka
- Vyhodnocovanie postfixovej notácie pomocou zásobníka
Aritmetické výrazy ako stromy
- Každý operátor a každé číslo tvorí vrchol stromu
- Vrchol pre operátor má pod sebou zavesené podstromy pre podvýrazy, ktoré spája
struct node { /* vrchol stromu */ double val; /* ciselna hodnota */ char op; /* operator '+', '-', '*', '/', * alebo ' ' ak ide o hodnotu */ node * left; /* lavy podvyraz alebo NULL */ node * right; /* pravy podvyraz alebo NULL */ }; node * createOp(char op, node *left, node *right) { /* vytvori novy vrchol stromu s operatorom op * a do jeho laveho a praveho podvyrazu ulozi * smerniky left a right. */ node *v = new node; v->left = left; v->right = right; v->op = op; return v; } node * createNum(double val) { /* Vytvori novy vrchol stromu s danou hodnotou, * lavy a pravy podvyraz bude prazdny, op bude medzera */ node *v = new node; v->left = NULL; v->right = NULL; v->op = ' '; v->val = val; return v; }
Vytvorenie stromu z postfixového výrazu
Pripomeňme si kód na vyhodnocovanie postfixového výrazu:
typedef double dataType; double evaluatePostfix(char postfix[]) { stack s; init(s); int i = 0; while (postfix[i] != '\0') { if (isspace(postfix[i])) { // preskakuj biele znaky i++; } else if (isdigit(postfix[i]) || postfix[i]=='.') { // spracuj jedno cislo zo vstupu push(s, evaluateNumber(postfix, i)); } else { // binarny operator double elem1 = pop(s); double elem2 = pop(s); switch (postfix[i]) { case '+': push(s, elem2 + elem1); break; case '-': push(s, elem2 - elem1); break; case '*': push(s, elem2 * elem1); break; case '/': push(s, elem2 / elem1); break; } i++; } } return pop(s); }
- Do zásobníka si ukladáme čísla - medzivýsledky už vyhodnotených podvýrazov.
- Pri tvorbe stromu si tam namiesto toho budeme ukladať už vytvorené podstromy.
typedef node * dataType; node *parsePostfix(char *postfix) { stack s; init(s); int i = 0; while (postfix[i] != '\0') { if (isspace(postfix[i])) { // preskakuj biele znaky i++; } else if (isdigit(postfix[i]) || postfix[i]=='.') { // spracuj jedno cislo zo vstupu double val = evaluateNumber(postfix, i); push(s, createNum(val)); } else { // binarny operator node * elem1 = pop(s); node * elem2 = pop(s); node * v = createOp(postfix[i], elem2, elem1); push(s, v); i++; } } return pop(s); }
Dátová štruktúra pre binárne stromy
Dátovú štruktúru pre vrcholy binárnych stromov môžeme zovšeobecniť a použiť v nej nejaký všeobecný typ dataType, podobne ako pri zásobníku. Spravíme si tiež všeobecnú funkciu na vytvorenie nového vrcholu, ktorá dostane smerníky na podstromy.
struct node { /* vrchol stromu */ dataType data; node * left; /* lavy podstrom */ node * right; /* pravy podstrom */ }; node * createNode(dataType data, node *left, node *right) { node *v = new node; v->data = data; v->left = left; v->right = right; return v; }
Uvažujme strom, v ktorom každý vrchol obsahuje jeden znak. Ako bude vyzerať tento strom?
node *v = createNode('A', createNode('B', createNode('C', NULL, NULL), createNode('D', NULL, NULL)), createNode('E', NULL, createNode('F', NULL, NULL)));
Použitie pre aritmetické výrazy
Ak by sme takýto všeobecný strom chceli použiť na aritmetické výrazy, definujeme si dataType ako štruktúru s dvoma položkami op a val, ktoré vo vrcholoch potrebujeme. Funkcie createOp a createNum vieme napísať pomocou createNode.
struct dataType { double val; /* ciselna hodnota */ char op; /* operator '+', '-', *', '/', alebo ' ' ak ide o hodnotu */ }; node * createOp(char op, node *left, node *right) { dataType d; d.op = op; return createNode(d, left, right); } node * createNum(double val) { dataType d; d.op = ' '; d.val = val; return createNode(d, NULL, NULL); }
Ak teraz máme premennú v ako smerník na nejaký vrchol stromu, namiesto v->op budeme písať v->data.op.
Prehľadávanie stromov
- Často potrebujeme prejsť celý strom a spracovať dáta vo všetkých vrcholoch.
- Napríklad chceme vypísať hodnotu v každom vrchole
- Opäť použijeme rekurziu, voláme na ľavý a pravý podstrom.
void print(dataType &d) { cout << d; } void preorder(node *v) { if (v == NULL) return; print(v->data); preorder(v->left); preorder(v->right); }
- Pre príklad stromu uvedeného vyššie vypíše ABCDEF
- Takéto poradie sa volá preorder, lebo najprv vypíšeme (spracujeme) dáta vo vrchole, až potom v jeho podstromoch.
- Dáta vo vrchole môžeme vypísať aj po navštívení oboch podstromov, takéto poradie nazývame postorder.
- Pre náš strom CDBFEA
- Alebo ich môžeme vypísať medzi navštívením ľavého a pravého vrcholu, takéto poradie nazývame inorder.
- Pre náš strom CBDAEF
void postorder(node *v) { if (v == NULL) return; postorder(v->left); postorder(v->right); print(v->data); } void inorder(node *v) { if (v == NULL) return; inorder(v->left); print(v->data); inorder(v->right); }
Vypisovanie aritmetických výrazov
- Preorder vypisovanie vypíše výraz v prefixovej notácii / - 65 * 3 5 + 2 3
- Postdorder vypisovanie vypíše výraz v postfixovej notácii 65 3 5 * - 2 3 + /
void print(dataType &d) { /* funkcia na tlac jedneho vrcholu pouzita v preorder a postorder */ if(d.op == ' ') { cout << ' ' << d.val; } else { cout << ' ' << d.op; } }
- Inorder vypisovanie nevypíše výraz v infixovej notácii, chýbajú zátvorky 65 - 3 * 5 / 2 + 3
- Chceme úplne uzátvorkovaný výraz, napr. ( ( 65 - ( 3 * 5 ) ) / ( 2 + 3 ) )
void infix(node *v) { /* funkcia na tlac vyrazu v infixovej notacii */ if(v->data.op == ' ') { cout << ' ' << v->data.val; } else { cout << " ("; infix(v->left); cout << " " << v->data.op; infix(v->right); cout << " )"; } }
Jednoduchá práca so stromami
Výška (hĺbka) stromu
- Hĺbka vrcholu v strome je jeho vzdialenosť od koreňa. T.j. koreň má hĺbku 0, jeho synovia hĺbku 1 atď.
- Výška stromu (niekedy nazývaná hĺbka stromu) je maximum z hĺbok jeho vrcholov
- Ak máme strom s jedným vrcholom, výška je 0
- Inak spočítame výšku ľavého a pravého podstromu
- Ku každej pripočítame 1, lebo pridávame hranu k otcovi
- Aby to fungovalo aj pre prázdne podstromy, dodefinujeme výšku prázdneho podstromu na -1
int height(node *v) { /* Vrat vysku stromu s korenom v. * Ak v je NULL, vrati -1. */ if (v == NULL) return -1; int left = height(v->left); int right = height(v->right); /* vrat max(left, right)+1 */ if (left >= right) return left + 1; else return right + 1; }
Ak máme binárny strom s n vrcholmi, aká môže byť jeho minimálna a maximálna výška?
- Výška stromu s n vrcholmi je najviac n-1, ak sú všetky navešané jeden pod druhý, t.j. každý okrem posledného má jedného syna
- Strom s výškou h má najviac Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 2^{h+1}-1}
vrcholov
- Dá sa dokázať indukciou vzhľadom na h
- Takže vieme, že Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle n\le 2^{h+1}-1} .
- Vyjadríme h: Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle h\ge \log_2(n+1)-1}
- Takže dostávame Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle \log_2(n+1)-1 \le h \le n-1}
Úplný binárny strom
- Strom, ktorý má pri určitej hĺbke h maximálny počet vrcholov, t.j. Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 2^{h+1}-1} sa nazýva úplny binárny strom.
- Chceli by sme taký strom vytvoriť.
- Použijeme funkciu createNode na vytvorenie jedného vrcholu:
node * createNode(dataType data, node *left, node *right) { node *v = new node; v->data = data; v->left = left; v->right = right; return v; }
- Rekurzívne tvoríme väčšie stromy z menších.
- Globálna premenná count priradí vrcholom do dátovej položky poradové číslo.
node* createTree(int height) { if (height == -1) return NULL; node* u = createNode(count++, NULL, NULL); u->left = createTree(height - 1); u->right = createTree(height - 1); return u; }
Uvoľňovanie stromu
Pri ukončení práce by sme mali pamäť, ktorú sme potrebovali na strom uvoľniť.
void destroyTree(node* v){ if(v!=NULL){ destroyTree(v->left); destroyTree(v->right); delete v; } }
Cvičenia
- Napíšte funkciu, ktorá každému uzlu prirobí smerník na rodiča do položky parent typu node *
- Vo výrazoch by sme mohli mať aj premenné, potom za ne dosadzovať hodnoty alebo celé podvýrazy
- Ako by sme premenné reprezentovali v štruktúre dataType?
- Predstavme si, že v preorder poradí namiesto dát vypíšeme počet detí daného vrcholu. Napríklad pre náš strom so znakmi to bude 2 2 0 0 1 0 (preorder poradie je A B C D E F, vrcholy A a B majú po dve deti, vrcholy C a D majú 0 detí, vrchol E má jedno dieťa a vrchol F 0 detí). Ako z takejto postupnosti zostavíme strom? Je jednoznačne daný? Skúste si nakresliť strom pre postupnosť 2 0 2 1 2 0 0 2 0 0.
Prednáška 22
Organizačné poznámky
Dobeh semestra:
- DÚ9 do 3.12., DÚ10 do 10.12., PDÚ4 do 10.12.
- Cvičenia + rozcvičky (3.12. a 10.12.)
- Prednášky:
- dnes binárne vyhľadávacie stromy
- budúci pondelok lexikografické stromy
- budúci utorok opakovanie, príprava na písomku a skúšku
- pondelok 10.12. nepreberané črty jazykov C a C++
- Na stránke tento týždeň zverejníme ukážkové príklady na písomku a skúšku
- Termíny písomky: 17.12. o 10:00 riadny termín, 8.1. opravný termín
- Termíny skúšok: 20.12., 10.1., 23.1., opravný termín 30.1., druhý opravný termín 6.2.
- Skontrolujte si v Moodli známky z DÚ aj rozcvičiek, problémy nám hláste čím skôr
- Jednotlivé body podľa Moodla, percentá podľa pravidiel predmetu (Moodle nezobrazuje správne)
Opakovanie: binárne stromy
- V každom vrchole máme uložené nejaké dáta a smerník na ľavého a pravého syna.
struct node { /* vrchol stromu */ dataType data; node * left; /* lavy syn */ node * right; /* pravy syn */ };
- Príklad využitia: reprezentácia aritmetických výrazov
- Na prechádzanie všetkých vrcholov sa hodí rekurzia
- videli sme preorder, inorder, postorder poradie vypisovania
void inorder(node *v) { if (v == NULL) return; inorder(v->left); print(v->data); inorder(v->right); }
Hľadanie prvku v strome
- Chceme zistiť, či sa v strome nachádza určitá hodnota, alebo spočítať, koľkokrát sa tam nachádza.
- Môže byť hocikde, preto musíme prejsť rekurzívne všetky vrcholy stromu
int count(node *v, dataType x) { /* Vrat pocet vyskytov hodnoty x v strome s korenom v. */ if (v == NULL) return 0; int add = 0; if (v->data == x) add = 1; return count(v->left, x) + count(v->right, x) + add; }
Binárne vyhľadávacie stromy
- Binárne vyhľadávacie stromy sú usporiadané tak, aby sme vedli pomerne rýchlo vyhľadať prvok s určitou hodnotou
- V každom vrchole máme položku kľúč (key)
- Pre každý vrchol v stromu platí:
- Každý vrchol u v ľavom podstrome v má kľúč menší ako vrchol v
- Každý vrchol u v pravom podstrome v má kľúč väčší ako vrchol v
- Z toho vyplýva, že ak vypíšeme strom v inorder poradí, dostaneme prvky usporiadané
- Pre danú množinu kľúčov existuje veľa vyhľadávacích stromov
Cvičenie: nájdite všetky binárne vyhľadávacie stromy pre množinu kľúčov {1,2,3}
Definícia dátových štruktúr
- V každom vrchole kľúč typu keyType, kľúče vieme porovnávať znamienkom < (napr. int, double, ...)
- V každom vrchole si pamätáme aj smerník na otca (ten má hodnotu NULL v koreni)
- Strom je potom jednoducho smerník na koreň a inicializujeme ho na NULL.
struct node { /* vrchol binarneho vyhladavacieho stromu */ keyType key; /* hodnota kluca */ node * parent; /* otec vrchola */ node * left; /* lavy syn */ node * right; /* pravy syn */ }; struct binarySearchTree { node *root; /* koren stromu, NULL pre prazdny strom */ }; void init(binarySearchTree &t) { /* inicializuje prazdny binarny vyhladavaci strom */ t.root = NULL; }
- Pre binárne vyhľadávacie stromy si ukážeme hľadanie, pridávanie a uberanie vrcholov
- Ktorý abstraktný dátový typ vám tieto operácie pripomínajú?
Hľadanie vo vyhľadávacom strome
- Porovnáme hľadaný kľúč s kľúčom v koreni
- Ak sa rovnajú, končíme (našli sme, čo hľadáme)
- Ak je hľadaná hodnota menšia ako kľúč v koreni, musí byť v ľavom podstrome, ak je väčšia v pravom
- V príslušnom podstrome sa rozhodujeme podľa tých istých pravidiel
- Keď narazíme na prázdny podstrom, kľúč sa v strome nenachádza
- Dá sa zapísať rekurzívne alebo cyklom, lebo vždy ideme iba do jedného podstromu
node * findNode(node *root, keyType key) { /* V binarnom vyhladavacom strom s korenom root najdi a vrat * vrchol s klucom a ak neexistuje, vrat NULL. */ node * v = root; while (v != NULL && v->key != key) { if (key < v->key) { v = v->left; } else { v = v->right; } } return v; } /* rekurzivna verzia */ node * findNodeR(node *root, keyType key) { /* V binarnom vyhladavacom strom s korenom root najdi a vrat * vrchol s klucom a ak neexistuje, vrat NULL. */ if (root == NULL || root->key == key) { return root; } else if (key < root->key) { return findNodeR(root->left, key); } else { return findNodeR(root->right, key); } }
- Čas výpočtu je v najhoršom prípade úmerný výške stromu
Pre užívateľa rekuziu obalíme do pomocnej funkcie, ktorá vráti true ak sa daný kľúč v strome vyskytuje a false inak
bool find(binarySearchTree &t, keyType key) { return findNode(t.root, key) != NULL; }
Vkladanie prvku do vyhľadávacieho stromu
- Predpokladáme, že prvok v strome nie je.
- Putujeme po strome podobne ako po vyhľadávaní prvku, až kým nenarazíme na nulový smerník.
- Na tomto mieste by mal byť nový prvok, takže ho tam pridáme ako nový list
- Použijeme rozšírenú verziu findNode, ktorá vráti miesto, kam by mal prvok patriť, aj jeho otca.
node * createLeaf(keyType key, node * parent) { /* vytvor novy vrchol s danym kľúčom, obe deti nastav na NULL */ node *v = new node; v->key = key; v->left = NULL; v->right = NULL; v->parent = parent; return v; } void findNode(node *root, keyType key, node *&v, node *&parent) { /* Do v uloz smernik na vrchol s klucom key alebo NULL ak neexistuje. * Do parent uloz otca v, NULL ak neexistuje a ak key nie je v strome * tak smernik na vrchol, ktory by mal byt otcom pre vrchol * s hodnotou key. */ parent = NULL; v = root; while (v != NULL && v->key != key) { parent = v; if (key < v->key) { v = v->left; } else { v = v->right; } } } void insert(binarySearchTree &t, keyType key) { /* Do stromu t vlozi kluc key na spravne miesto. * Predpokladame, ze takyto kluc este v strome nie je. */ if (t.root == NULL) { /* prazdny strom - treba vytvorit koren */ t.root = createLeaf(key, NULL); } else { node *v; node *parent; findNode(t.root, key, v, parent); /* parent je teraz vrchol, ktoreho syn ma byt novy vrchol */ assert(v == NULL && parent != NULL); /* zisti, ci mame byt lave alebo prave dieta otca */ if (key < parent->key) { assert(parent->left == NULL); parent->left = createLeaf(key, parent); } else { assert(parent->right == NULL); parent->right = createLeaf(key, parent); } } }
- Čas vkladania je tiež v najhoršom prípade úmerný hĺbke stromu.
Príklad: ako bude vyzerať strom po nasledujúcej postupnosti operácií?
binarySearchTree t; init(t); insert(t, 2); insert(t, 5); insert(t, 3); insert(t, 10); insert(t, 7);
Odbočka: minimum a nasledovník
- Spravíme si dve funkcie, ktoré sa nám zídu pri mazaní prvku, ale môžu sa zísť aj inokedy.
- Prvá funkcia nájde vo vyhľadávacom strome minimum.
- Všetky prvky menšie ako koreň sú v ľavom podstrome, bude tam zrejme aj minimum.
- Tá istá úvaha platí pre koreň ľavého podstromu.
- Ideme teda doľava kým sa dá, posledný vrchol vrátime (list alebo vrchol s pravým synom).
- Dá sa tiež pekne napísať rekurzívne.
node *minimumNode(node *v) { /* vrati vrchol s minimalnym klucom vo vyhladavacom strome * s korenom v */ assert(v != NULL); while (v->left != NULL) { v = v->left; } return v; }
Druhá funkcia nájde vrchol, ktorý v utriedenom poradí nasleduje za daným vrcholom v.
- Ak má v pravého syna, nasledovník bude v pravom podstrome, konkrétne vrchol s minimálnym kľúčom v tomto podstrome
- V opačnom prípade to môže byť rodič, ak v je jeho ľavý syn
- Ak je pravý syn, môže to byť prarodič, ak je rodiť jeho ľavý syn, atď
- Nájdeme teda prvého predka, do ktorého ľavého podstromu patrí v a ten je hľadaný nasledovník
node *successorNode(node *v) { /* vrati vrchol, ktorý v utriedenom poradi nasleduje za vrcholom v, * alebo NULL ak taky vrchol nie je */ assert(v != NULL); if (v->right != NULL) { return minimumNode(v->right); } while (v->parent != NULL && v == v->parent->right) { v = v->parent; } return v->parent; }
Mazanie prvkov z vyhľadávacieho stromu
- Nájdeme mazaný vrchol v podľa kľúča obvyklým spôsobom
- Ak je v list, jednoducho ho zmažeme
- Ak má v jedno dieťa, toto dieťa prevesíme priamo pod otca v a v zmažeme
- Ak má v dve deti, nájdeme nasledovníka v, t.j. minimum v pravom podstrome v.
- Tento nasledovník nemá ľavé dieťa, vieme ho teda zmazať.
- Jeho údaje presunieme do vrcholu v.
- Tiež treba dať pozor na mazanie koreňa.
void remove(binarySearchTree &t, keyType key) { /* Zmaze kluc key zo stromu t. * Predpokladame, ze tam taky kluc je. */ /* Najdi vrchol s klucom */ node *v = findNode(t.root, key); assert(v != NULL && v->key == key); /* najdi vrchol rm s jednym synom child, * ktory vyhodime. */ node *rm, *child; if (v->left == NULL || v->right == NULL) rm = v; else rm = successorNode(v); assert(rm->left == NULL || rm->right == NULL); if (rm->left != NULL) child = rm->left; else child = rm->right; /* preves syna priamo pod otca rm */ if (child != NULL) child->parent = rm->parent; if (rm->parent == NULL) t.root = child; else { /* ak rm nie je koren, jeho otcovi zaves child */ node *parent = rm->parent; assert(rm == parent->left || rm == parent->right); if (rm == parent->left) parent->left = child; else parent->right = child; } /* ak rm nema mazany kluc, prekopiruj data z rm do v*/ if (rm != v) { v->key = rm->key; } delete rm; }
Zdrojový kód programu s binárnymi vyhľadávacími stromami
Vyhľadávací strom ako implementácia slovníka
Spomeňte si na abstraktný dátový typ slovník:
- Pre každý kľúč máme v slovníku uložené nejaké dáta, napr. pre každé meno máme telefónne číslo.
- Toto sú hlavné funkcie, ktoré slovník podporuje:
void init(dictionary &d); /* inicializuje prazdny slovnik */ itemType *find(dictionary &d, keyType k); /* nájde záznam s kľúčom k a vráti smerník na neho ho. * Ak taký kľúč v slovníku nie je, vráti NULL */ void insert(dictionary &d, itemType *x); /* Do slovnika vloží záznam *x. * Predpokladame, ze takyto kluc este v slovniku nie je. */ void remove(dictionary &d, keyType k); /* Zmaze zaznam s kucom k zo slovnika d. * Predpokladame, ze tam taky kluc je. */
- Videli sme už slovník v neutriedenom poli, utriedenom poli, hashovacej tabuľke, dal by sa spraviť aj spájanom zozname...
- Slovník sa ale dá spraviť aj v binárnom vyhľadávacom strome
- už vieme ako robiť všetky potrebné operácie: find, insert, remove
- stačí mierne prerobiť, aby sedelo s typmi zo slovníka
Vo vrchole si namiesto kľúča dáme smerník na item
struct node { /* vrchol binarneho vyhladavacieho stromu */ itemType *item; /* smernik na zaznam */ node * parent; /* otec vrchola */ node * left; /* lavy syn */ node * right; /* pravy syn */ }; struct dictionary { node *root; };
Používateľ definuje itemType a funkcie key, equal, greater a pod., napr.
struct monthSum { char * name; // kľúč - skratka mesiaca, napr "Jan" double sum; // data - sucet frekvencií pre daný mesiac }; typedef monthSum itemType; typedef const char * keyType; keyType key(itemType *x) { return x->name; } bool equal(keyType x, keyType y) { return strcmp(x, y) == 0; } bool greater(keyType x, keyType y) { // x>y return strcmp(x, y) > 0; }
Všade, kde funkcie uvedené vyššie porovnávajú kľúče pomocou ==, >, <, použijeme príslušné funkcie, napr findNode a find:
node * findNode(node *root, keyType k) { /* V binarnom vyhladavacom strom s korenom root najdi a vrat * vrchol s klucom k, alebo vrat NULL ak taky neexistuje. */ node *v = root; while (v != NULL && !equal(key(v->item), k)) { if (greater(key(v->item), k)) { v = v->left; } else { v = v->right; } } return v; } itemType *find(dictionary &d, keyType k) { // nájde záznam s kľúčom k a vráti smerník na neho ho. // Ak taký kľúč v slovníku nie je, vráti NULL node *v = findNode(d.root, k); if (v == NULL) return NULL; return v->item; }
Zdrojový kód programu so slovníkom pomocou binárnych vyhľadávacích stromov
Zhrnutie
Binárny vyhladávací strom je binárny strom v ktorom platí:
- Hodnota v koreni je väčšia ako všetky hodnoty v ľavom podstrome.
- Hodnota v koreni je menšia ako všetky hodnoty v pravom podstrome.
- Ľavý aj pravý podstrom sú binárne vyhľadávacie stromy.
Hodí sa na implementáciu slovníkových operácií find, remove, insert
Pri hľadaní putujeme od koreňa dole a vždy vieme, či máme pokračovať vľavo alebo vpravo
- podobá sa to teda na binárne vyhľadávanie
Zložitosť operácií závisí od výšky stromu. Tá je
- V najhoršom prípade O(n)
- V priemernom prípade O(log n)
Find, Insert, Delete:
- Najlepší prípad O(1)
- Najhorší prípad O(height(T))=O(n)
- Priemerný prípad O(height(T))=O(log n)
Na druháckom predmete Algoritmy a dátové štruktúry si ukážete obmeny vyhľadávacích stromov, ktoré majú zložisť O(log n) aj v priemernom prípade
Pre porovnanie jednoduché implementácie slovníka, najhoršie aj priemerné prípady:
- Usporiadané pole: Find - O(log n), Insert - O(n), Delete - O(n)
- Neusporiadané pole: Find - O(n), Insert - O(1), Delete - O(n)
Cvičenia 11
Zásobník a rad
- Majme zásobník, do ktorého ukladáme dáta typu char. Do nasledujúceho úryvku kódu vložte na tri miesta príkaz cout << pop(s) tak, aby program vypísal text BAC
stack s; init(s); push(s, 'A'); push(s, 'B'); push(s, 'C');
- Majme dva rady, do ktorých ukladáme dáta typu char. Do nasledujúce úryvku kódu vložte na vhodné miesta príkazy tak, aby program vypísal text BAC. Môžete použiť len tri typy príkazov, každý aj viackrát:
- cout << dequeue(q1);
- enqueue(q1, dequeue(q2));
- enqueue(q2, dequeue(q1));
queue q1, q2; init(q1); init(q2); enqueue(q1, 'A'); enqueue(q1, 'B'); enqueue(q1, 'C');
Vyfarbovanie
- Na prednáške 19 sme mali program, ktorý počítal počet ostrovov na mape. Upravte ho tak, aby našiel ostrov s najväčšou plochou a vyfarbil ho inou farbou ako ostatné ostrovy.
- Upravte funkciu vyfarbi tak, aby vracala celé číslo udávajúce počet políčok, ktoré prefarbila. Tým zistíte plochu jednotlivých ostrovov.
- Na prednáške prednáške 19 sú tri funkcie na vyfarbovanie súvislej plochy, ktoré používajú polia delta_x a delta_y. Vďaka týmto poliam skúma každé políčko svojich susedov v poradí vpravo, hore, vľavo, dole. Jedna z týchto funkcií je však rekurzívna, jedna používa zásobník a jedna rad. Každú funkciu spustíme na matici s troma riadkami a troma stĺpcami, ktorá je vyplnená nulami, pričom funkciu spustíme na stredné políčko, t.j. stlpec=riadok=1 a nová farba je tiež 1. V akom poradí budú tieto funkcie vyfarbovať jednotlivé štvorčeky matice? Skúste túto úlohu riešiť bez použitia počítača.
Zátvorky
- Do programu na kontrolu správne uzátvorkovaných výrazov z prednášky 18 dopíšte informatívne oznamy pre užívateľa, ktoré mu povedia, zátvorka na ktorom mieste v reťazci nemá ľavý pár alebo na ktorom mieste má ľavý pár iného typu ako pravý alebo koľko ľavých zátvoriek zostalo na konci neuzavretých. Po prvej takejto chybe už ďalšie nevypisujte.
Deque
- Uvažujme abstraktný dátový typ deque, ktorý je kombináciou radu a zásobníka. Dovoľuje
- pridávať na jeden aj druhý koniec postupnosti (funkcie addFirst, addLast)
- mazať na jednom aj druhom konci postupnosti (funkcie removeFirst a removeLast), pričom zmazaný prvok vráti
- pozrieť sa na prvý a posledný prvok bez toho aby sa zmazal (funkcie getFirst a getLast)
- pomocné operácie isEmpty, init a destroy
- Ako by ste pomocou deque implementovali zásobník a ako rad? (t.j. ktoré operácie sú ekvivalentné push, pop, resp. enqueue a dequeue)?
- Prepíšte implementáciu radu pomocou poľa tak, aby poskytovala všetky operácie pre deque. Nezabudnite pomocou príkazu assert skontrolovať, že dátová štruktúra nie je preplnená pri pridávaní, ale ani prázdna pri vyberaní a vracaní prvku.
DÚ9
Odovzdávanie DÚ9 max. 10 bodov, termín odovzdania pondelok 3.12. o 22:00
Cieľom tejto domácej úlohy je precvičiť si prácu s maticami, súbormi a vyfarbovanie.
Napíšte program, ktorý načíta maticu predstavujúcu mapu ostrovov v oceáne, nájde jednotlivé ostrovy a pre každý spočíta jeho plochu a dĺžku pobrežia.
Vstupný súbor ostrovy.txt obsahuje každý riadok vstupnej mapy ako reťazec, v ktorom bodka znamená políčko s oceánom a písmeno X znamená políčko s ostrovom. Tu je príklad:
.......X.. .XX....XX. ..X.X..... X...XXXX.. .X...XXX.. .....XXX..
Ostrov je súvislá oblasť políčok označených písmenom X, pričom dve políčka dotýkajúce sa rohom nepovažujeme za susedné a nemusia teda byť súčasťou jedného ostrova, ak nie sú prepojené cez iné políčka. Plocha ostrova je jednoducho počet políčok označených X v rámci tohto ostrova. Dĺžka pobrežia je počet hraníc medzi políčkom ostrova a susedným políčkom oceánu. Teda napríklad ostrov pozostávajúci iba z jedného políčka má dĺžku pobrežia 4. Predpokladajte, že okolo celej vstupnej matice je oceán a teda ostrovy, ktoré sa dotýkajú okraja matice, majú na tomto okraji pobrežie. Môžete predpokladať, každý rozmer mapy je najviac 100.
Výstupný súbor vystup.txt obsahuje najprv kópiu vstupnej mapy, ktorá je ale zmenená tak, že prvý ostrov je označený písmenami A, druhý ostrov písmenami B atď. Môžete predpokladať, že ostrovov je najviac 26 a teda vám budú stačiť písmená A..Z. Pod mapou by mal byť voľný riadok a pod ním zoznam ostrovov s údajmi o ploche a dĺžke pobrežia vo formáte ako v príklade nižšie. Ostrovy by mali byť zoradené podľa toho, v akom poradí narazíme na ich prvé políčko, keď ideme po mape po riadkoch zhora nadol a v každom riadku zľava doprava (a v tomto poradí sú aj označené písmenami A,B,...). Výstup pre príklad vstupu uvedený vyššie:
.......A.. .BB....AA. ..B.C..... D...CCCC.. .E...CCC.. .....CCC.. Ostrov A: plocha 3, pobrezie 8 Ostrov B: plocha 3, pobrezie 8 Ostrov C: plocha 11, pobrezie 16 Ostrov D: plocha 1, pobrezie 4 Ostrov E: plocha 1, pobrezie 4
Dodržujte mená súborov a ich formát podľa príkladu v zadaní. Dbajte na úpravu a čitateľnosť vášho programu.
Pomôcky:
- Doporučujeme použiť niektorú funkciu na vyfarbovanie z prednášky 19.
- Doporučujeme si v programe uložiť mapu ako dvojrozmernú maticu int-ov, pričom napr. more máte ako 0, ešte nepreskúmané ostrovy ako -1 a preskúmané ostrovy označené číslami 1,2,...
- Ak máte už každý ostrov označený iným číslom, dĺžku pobrežia všetkých ostrovov ľahko spočítate jedným prechodom matice, pričom si budete všímať susedné políčka s rôznymi hodnotami.
Prednáška 23
Slovník
Na prednáške 17 sme pracovali s abstraktnou dátovou štruktúrou slovník. Na implementáciu sme využívali hashovacie tabuľky, ktoré pracovali vcelku optimálne, avšak potrebovali veľký pamäťový priestor. Pripomeňme si, aké operácie od slovníka požadujeme.
- Vloženie prvku
- Vymazanie prvku
- Hľadanie prvku
Budeme sa snažiť vytvoriť takú implementáciu slovníka, kde si nebudeme musieť pamätať nič zbytočné a pritom v ňom budeme vedieť vyhľadávať lepšie ako čisto v zozname slov.
Opakovanie binárne vyhľadávacie stromy
Aj binárne vyhľadávacie stromy môžeme chápať ako implementáciu slovníka a jeho operácií. Najvhodnejší je v prípade, ak sú kľúče (celé) čísla. Samozrejme vo všeobecnosti postačí, ak vieme na kľúčoch urobiť porovnanie (>,<,=).
Binárny vyhladávací strom je binárny strom v ktorom platí:
- Hodnota v koreni je väčšia ako všetky hodnoty v ľavom podstrome.
- Hodnota v koreni je menšia ako všetky hodnoty v pravom podstrome.
- Ľavý aj pravý podstrom sú binárne vyhľadávacie stromy.
Pre tie isté čísla existuje viacero binárnych vyhľadávacích stromov (skúste napríklad čísla 1..4). Čo však majú spoločné je inorder výpis.
- Prečo?
Zopakujeme si, ako boli implementované jednotlivé operácie.
Hľadanie v binárnom strome
Porovnáme hľadaný kľúč s kľúčom v koreni
- Ak sa rovnajú, našli sme čo hľadáme a končíme
- Ak je hľadaná hodnota menšia ako kľúč v koreni, musí byť v ľavom podstrome, ak je väčšia v pravom
node* findNode(node* root, keyType key) { node* v = root; while (v != NULL && v->key != key) { if (key < v->key) { v = v->left; } else { v = v->right; } } return v; } node* findNode(node* root, keyType key) { if ((root==NULL)||(root->key==key)) return root; if (key < root->key) return findNode(root->left); else return findNode(root->left); }
Vkladanie do binárneho vyhľadávacieho stromu
- Putujeme po strome podobne ako po vyhľadávaní prvku, až kým nenarazíme na nulový smerník.
- Na tomto mieste by mal byť nový prvok, takže ho tam pridáme ako nový list.
- Na to, aby sme vedeli pridať nový list potrebujeme vedieť predchodcu toho listu (takže si musíme pri hľadaní ťahať za sebou).
Vymazávanie z binárneho vyhľadávacieho stromu
- Putujeme po strome podobne ako po vyhľadávaní prvku, až kým nenarazíme na hľadaný prvok.
- Tento prvok chceme vymazať:
- Ak je prvok listom, triviálne vymažeme.
- Ak má iba jedného potomka, prevesíme.
- Ináč nájdeme nasledovníka (minimum v pravom podstrome) a prekopírujeme ho na miesto hľadaného prvku a ten list zmažeme.
Zložitosť slovníkových operácií v BVS
Zložitosť operácií závisí od výšky stromu. Tá je
- V najhoršom prípade O(n)
- V priemernom prípade O(log n)
Find, Insert, Delete:
- Najlepší prípad O(1)
- Najhorší prípad O(height(T))=O(n)
- Priemerný prípad O(height(T))=O(log n)
Pre porovnanie si pripomeňme implementáciu slovníka pomocou
- Usporiadaného poľa Find - O(log n), Insert - O(n), Delete - O(n) (najhoršie prípady)
- Neusporiadaného poľa: Find - O(n), Insert - O(1), Delete - O(n) (najhoršie prípady)
Lexikografické stromy (trie)
Myšlienka je relatívne jednoduchá. Slová budem ukladať do stromu, kde sa budem rozhodovať na základe písmen. Každé slovo začína niektorým písmenom abecedy. Podľa neho sa v koreni stromu rozhodnem, do ktorého z jeho podstromov pokračujem. Podstromov je Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle |Abeceda|} .
Vrchol lexikografického stromu obsahuje:
- dáta - môže byť čisto písmenko, na ktoré som sa do vrcholu dostala (alebo celé slovo, ktoré v tomto vrchole končí)
- smerníky na ďalšie podstromy (teda na ďalšie vrcholy stromu)
- určenie, či vo vrchole končí nejaké slovo
Vrchol je teda nasledovného tvaru:
struct node { /* vrchol lexikografickeho stromu */ char data; // pismeno ulozene v tomto vrchole bool isWord; // je tento vrchol koncom slova? node* next[Abeceda]; // pole smernikov na deti };
alebo môžeme pole smerníkov alokovať vždy keď vznikne vrchol - nebude definícia závislá od veľkosti abecedy:
struct node { /* vrchol lexikografickeho stromu */ char data; // pismeno ulozene v tomto vrchole bool isWord; // je tento vrchol koncom slova? node** next; // pole smernikov na deti };
Samotný strom je potom iba smerník na koreňový vrchol
struct trie { /* samotny lexikograficky storm si pamata smernik na koren */ node* root; }
Inicializácia a uvoľňovanie stromu
Pri práci s lexikografickým stromom začíname s jedným prázdnym vrcholom - koreňom, ktorý má v pole nasledovníkov iba smerníky s hodnotou NULL. Koreň je vlastne špeciálny vrchol, ktorý neobsahuje žiadne dáta (jeho dáta nastavíme na 0).
void init(trie &t) { /* inicializuj prazdny lexikograficky strom, ktory bude mat iba koren */ t.root = createNode('\0'); // koren si oznacime specialnym znakom 0 }
Pričom funkcia createNode pracuje nasledovne:
- Vytvorí si smerník na nový vrchol (alokuje mu priestor)
- Ak máme pole nasledovníkov cez smerníky (teda nie pole konkrétnej veľkosti, ktoré by sa vytvorilo spolu s vrcholom), vytvoríme si takéto pole.
- Inicializujeme nasledovníkov na NULL.
- Nastavíme hodnoty data a isWord
node* createNode(char data) { /* vytvor vrchol stromu s danymi datami */ node* v = new node; // novy vrchol v->next = new node*[Abeceda]; // alokuj pole deti for (int i = 0; i < Abeceda; i++) v->next[i] = NULL; // inicializacia deti v->isWord = false; v->data = data; return v; }
Uvoľňovanie pamäti stromu je pomocou jednoduchej rekurzívnej funkcie destroySubtree(node*), pričom na uvoľnenie celého stromu ju potrebujeme zavolať pre koreň
void destroySubtree(node* v) { /* rekurzivne uvolni pamat pre podstrom lexikografickleho stromu * s korenom vo vrchole v */ if (v == NULL) return; for (int i = 0; i < Abeceda; i++) destroySubtree(v->next[i]); delete[] v->next; // táto časť by nebola potrebná, ak by sme mali next statické delete v; } void destroy(trie &t) { /* uvolni pamat alokovanu pre lexikograficky strom t */ destroySubtree(t.root); }
Vkladanie do stromu
Do lexikografického stromu vkladáme reťazec zložený iba z písmen abecedy (pre jednoduchosť pracujeme s abecedou 'A'..'Z' resp. s jej začiatkom veľkosti Abeceda).
Postupujeme v cykle (po jednotlivých písmenách vkladaného slova) nasledovne:
- Začínam od koreňa stromu
- Ak nemám patričný smerník - tj. smerník na ďalšie potrebné písmkenko, tak si takýto vrchol (obsahujúci patričné písmenko) vytvoríme.
- Všimnite si, že v úplne prvom otočení cyklu nemáme žiadne zmysluplné písmenko, ktoré by sme dali ako hodnotu koreňu.
- Pozrieme si znak slova a ak je to koniec slova, tak skončíme cyklus.
- V opačnom prípade sa posunieme vhodnou hranou - máme už zaručené, že tam nebude NULL a tiež na ďalší znak slova.
- Keď nájdeme koniec slova, poznačíme si, že daný vrchol zodpovedá slovu
void insert(trie &t, const char* key) { /* do lexikografixkeho stromu t pridaj slovo key */ node *v = t.root; for (int i = 0; key[i] != 0; i++) { // posuvame sa od korena na spravne miesto int c = key[i] - 'A'; if (v->next[c] == NULL) { // ak vrchol chyba, spravime novy v->next[c] = createNode(key[i]); } v = v->next[c]; } /* Aktualny vrchol v je koncom slova */ v->isWord = true; }
Hľadanie v lexikografickom strome
Vyhľadávanie v strome opäť postupuje po písmenkách vyhľadávaného slova. Kým nedojde na koniec slova snaží sa ísť po hranách, ktoré zodpovedajú písmenkám. V prípade, že na niektorom mieste chýba patričná hrana, znamená to, že takéto slovo sa v strome nenachádza.
bool find(trie& t, const char* key) { /* zisti, ci v lexikografickom strome t je kluc key */ node *v = t.root; for (int i = 0; key[i] != 0; i++) { int c = key[i] - 'A'; if (v->next[c] == NULL) return false; v = v->next[c]; } return true; }
Teraz sa nad tým kúsok zamyslíme. Vo chvíli, keď uložím slovo "ahoj", mám vlaste vytvorené aj slová "a", "ah" a "aho", pričom tieto vôbec v slovníku nemusia byť. Po prečítaní slova sa teda potrebujem opýtať, či tam nejaké slovo naozaj končilo a na základe toho odpovedať.
bool find(trie& t, const char* key) { /* zisti, ci v lexikografickom strome t je kluc key */ node *v = t.root; for (int i = 0; key[i] != 0; i++) { int c = key[i] - 'A'; if (v->next[c] == NULL) return false; v = v->next[c]; } return v->isWord; }
Vymazávanie z lexikografického stromu
Pri vymazávaní slova potrebujeme spraviť nasledujúce veci:
- nájsť vrchol pre dané slovo a nastaviť mu isWord na false (predpokladáme, že slovo v strome bolo)
- prípadne uvoľniť nepotrebné vrcholy
Prvá možnosť je uvoľňovanie vrcholov ignorovať.
void deleteTrie(trie* t, const char* key){ /* zisti, ci v lexikografickom strome t je kluc key */ node *v = t.root; for (int i = 0; key[i] != 0; i++) { int c = key[i] - 'A'; assert(v->next[c] != NULL); v = v->next[c]; } assert(v->isWord); v->isWord=false; }
Ak by sme chceli byť dôkladní potrebujeme spraviť nasledujúce veci:
- nájsť vrchol pre dané slovo a nastaviť mu isWord na false (predpokladáme, že slovo v strome bolo)
- môže sa však stať, že tento vrchol je už nepotrebný, lebo nemá žiadne deti, takže ho treba zmazať
- tým sa môže stať nepotrebný aj jeho rodič a ďalší predkovia
Použijeme rekurziu, kde najskôr vymažeme slovo z určitého podstromu a ak sa tým stal jeho rodič zbytočný, zmažeme aj jeho.
void remove(trie& t, const char* key) { /* z lexikografickeho stromu t zmaze slovo key */ removeFromSubtree(t.root, key, 0); } bool removeFromSubtree(node *v, const char *key, int depth) { /* Z podstromu s korenom v zmaz slovo key, pricom aktualna hlbka je depth. * Vrati true, ak sme zmazali vrchol v, false inak. */ if (key[depth] == '\0') { // ak sme na konci slova, odznacime vrchol assert(v->isWord); v->isWord = false; } else { // ak nie sme na konci slova, zmazeme ho z prislusneho podstromu int c = key[depth] - 'A'; assert(v->next[c] != NULL); bool deleted = removeFromSubtree(v->next[c], key, depth + 1); if (deleted) { // ak sme zmazali dieta, poznacime v poli next v->next[c] = NULL; } } // zistime, kolko deti ma v int numChildren = 0; for (int i = 0; i < Abeceda; i++) { if (v->next[i] != NULL) numChildren++; } // ak v nema deti, nie je oznaceny ako slovo a nie je koren, zmazeme ho if (numChildren == 0 && !v->isWord && v->data != '\0') { delete[] v->next; delete v; return true; } return false; }
Čo sa stane, ak takto napísanú spustíme na strome v ktorom máme iba slovo "AHOJ" a skúsime z neho vymazať slovo "A"?
Vypisovanie stromu
Podobne ako pri binárnych stromoch aj lexikografický strom môžeme vypisovať napríklad funkciou preorder Aby sa aspoň kúsok dalo sledovať, ako to so stromom vyzerá, pridali sme nejaké zátvorky (nie že by veľmi pomohli).
void preorder(node* v){ if (v==NULL) {cout << "0 "; return;} else cout << "("<< v->data<<","<< v->use_count<<") "; cout << "["; for (int i=0; i<Abeceda; i++){ preorder(v->next[i]); } cout <<"] "; }
Napr. pre strom so slovami A, ARE, AS, DO, DOT dostávame:
[A* [R [E* [] ] S* [] ] D [O* [T* [] ] ] ]
Oveľa viac by nám pomohlo vypísať všetky slová, ktoré sú v slovníku.
Funkcia na vypisovanie všetkých slov bude pracovať rekurzívne a do pomocného poľa prefox si bude zapisovať aktuálny prefix stav slova, ktoré vypisuje. Pracuje nasledovne: vo vrchole v mám aktuálny prefix
- Špeciálne ak je vo vrchole v koniec nejakého slova, tak ho vypíše.
- Rekurzívne sa zavolá na všetky podstromy, pričom k prefixu pridá postupne všetky potenciálne znaky abecedy.
void printSubtree(int depth, node *v, char* prefix) { /* rekurzivne vypise vsetky slova v podstrome s korenom v, * pricom v ma hlbku depth * a spolocny prefix jeho slov je v retazci prefix */ if (v->isWord) { prefix[depth] = '\0'; printf("%s\n", prefix); } for (int i = 0; i < Abeceda; i++) { if (v->next[i] != NULL) { prefix[depth] = (v->next[i])->data; // pridám si ďalšie písmeno printSubtree(depth + 1, v->next[i], prefix); // zavolám sa rekurzívne } } }
Volanie tejto rekurzívnej funkcie je s použitím pomocného poľa, ktorého dĺžku by sme mohli nastaviť ako dĺžku najdlhšieho slova v strome.
void printTrie(trie &t) { /* vypise vsetky slova v lexikografickom strome t */ char *prefix = new char[maxLen+1]; printSubtree(0, t.root, prefix); delete[] prefix; }
Ďalšie použitie lexikografického stromu
Videli sme, že pri vymazávaní zo stromu sma narazili na problém ako zistiť, či je vrchol stromu ešte využívaný. Ďalšia možnosť, ako to zistiť je si pre každý vrchol pamätať, koľko krát bol pre nejaké slovo v strome používaný.
struct node { /* vrchol stromu */ char data; int use_count; //počet použití vrcholu bool isWord; node** next; };
Takto definovaný vrchol stromu bude vhodný aj pre nasledovnú úlohu: na vstupe je daná množina slov z abecedy {a, b}. Takýchto slov môže byť aj niekoľko stotisíc a my potrebujeme vedieť, koľkokrát sa nachádza každé slovo v tejto množine.
Môžeme použiť lexikografický strom a jeho pripravené funkcie, ale v každom vrchole si budeme ešte udržovať počítadlo výskytov príslušného slova. Pochopiteľne musíme novú vlastnosť vrcholu upravovať priebežne pri pridávaní. Pri inicializácii vrcholu ho nastavíme na nulu. Pri každom prechádzaní cez tento vrchol potom budeme hodnotu use_count zvyšovať.
void insert(trie &t, const char* key) { /* do lexikografickeho stromu t pridaj slovo key */ node *v = t.root; for (int i = 0; key[i] != 0; i++) { // posuvame sa od korena na spravne miesto int c = key[i] - 'A'; if (v->next[c] == NULL) { // ak vrchol chyba, spravime novy v->next[c] = createNode(key[i]); } v->use_count++; v = v->next[c]; } /* Aktualny vrchol v je koncom slova */ v->isWord = true; }
Pri vyhľadávaní sa hodnota use_count nepoužíva, takže vyhľadávanie nepotrebuje žiadnu úpravu. Pri vymazávaní však vieme jednoducho zistiť, ktoré vrcholy máme uvoľniť.
- Akonáhle narazíme na vrchol, ktorý má iba jediné použitie vieme, že celý jeho podstrom môžeme zmazať.
void remove(trie &t, const char* key){ /* zisti, ci v lexikografickom strome t je kluc key */ node *v = t.root; for (int i = 0; key[i] != 0; i++) { int c = key[i] - 'A'; assert(v->next[c] != NULL); if ((v->next[c])->use_count==1){ destoySubtree(v->next[c]); v->next[c] = NULL; } else { v=v->next[c]; v->use_count--; } } (t.root)->use_count--; }
Teraz si vyskúšajme takto napísanú funkciu na strome v ktorom máme iba slovo "ahoj" a skúsime z neho vymazať slovo "a". Takéto slovo v slovníku nemáme, napriek tomu nám ho dovolí vymazať a vymaže tým vlastne slovo "ahoj".
Aby sme tomu zabránili môžeme urobiť jednu z nasledujúcich vecí:
- Uvoľnovať vrcholy iba v prípade, že je tam niekde isWord() -- napríklad napísať funkciu condDestroySubtree(node* v, const char* key)
- Na začiatku sa opýtať, či sa také slovo vyskytuje a potom mazať v kľude. Tým vyriešime aj problém, že čo z rozpracovaným stromom vo chvíli, keď zistím, že som vlastne vymazávať nemala.
Zdrojový k programu s lexikografickým stromom
#include <cstdio> #include <cassert> const int Abeceda = 26; /* velkost abecedy, znaky cislujeme 0..Abeceda-1 */ const int maxLen = 100; /* maximalna dlzka slova v strome */ struct node { /* vrchol lexikografickeho stromu */ char data; // pismeno ulozene v tomto vrchole bool isWord; // je tento vrchol koncom slova? node** next; // pole smernikov na deti }; struct trie { /* samotny lexikograficky storm si pamata smernik na koren */ node* root; }; node* createNode(char data) { /* vytvor vrchol stromu s danymi datami */ node* v = new node; // novy vrchol v->next = new node*[Abeceda]; // alokuj pole deti for (int i = 0; i < Abeceda; i++) v->next[i] = NULL; // inicializacia deti v->isWord = false; v->data = data; return v; } void init(trie &t) { /* inicializuj prazdny lexikograficky strom, ktory bude mat iba koren */ t.root = createNode('\0'); // koren si oznacime specialnym znakom 0 } void destroySubtree(node* v) { /* rekurzivne uvolni pamat pre podstrom lexikografickleho stromu * s korenom vo vrchole v */ if (v == NULL) return; for (int i = 0; i < Abeceda; i++) destroySubtree(v->next[i]); delete[] v->next; // táto časť by nebola potrebná, ak by sme mali next statické delete v; } void destroy(trie &t) { /* uvolni pamat alokovanu pre lexikograficky strom t */ destroySubtree(t.root); } void insert(trie &t, const char* key) { /* do lexikografixkeho stromu t pridaj slovo key */ node *v = t.root; for (int i = 0; key[i] != 0; i++) { // posuvame sa od korena na spravne miesto int c = key[i] - 'A'; if (v->next[c] == NULL) { // ak vrchol chyba, spravime novy v->next[c] = createNode(key[i]); } v = v->next[c]; } /* Aktualny vrchol v je koncom slova */ v->isWord = true; } bool find(trie& t, const char* key) { /* zisti, ci v lexikografickom strome t je kluc key */ node *v = t.root; for (int i = 0; key[i] != 0; i++) { int c = key[i] - 'A'; if (v->next[c] == NULL) return false; v = v->next[c]; } return v->isWord; } bool removeFromSubtree(node *v, const char *key, int depth) { /* Z podstromu s korenom v zmaz slovo key, pricom aktualna hlbka je depth. * Vrati true, ak sme zmazali vrchol v, false inak. */ if (key[depth] == '\0') { // ak sme na konci slova, odznacime vrchol assert(v->isWord); v->isWord = false; } else { // ak nie sme na konci slova, zmazeme ho z prislusneho podstromu int c = key[depth] - 'A'; assert(v->next[c] != NULL); bool deleted = removeFromSubtree(v->next[c], key, depth + 1); if (deleted) { // ak sme zmazali dieta, poznacime v poli next v->next[c] = NULL; } } // zistime, kolko deti ma v int numChildren = 0; for (int i = 0; i < Abeceda; i++) { if (v->next[i] != NULL) numChildren++; } // ak v nema deti, nie je oznaceny ako slovo a nie je koren, zmazeme ho if (numChildren == 0 && !v->isWord && v->data != '\0') { delete[] v->next; delete v; return true; } return false; } void remove(trie& t, const char* key) { /* z lexikografickeho stromu t zmaze slovo key */ removeFromSubtree(t.root, key, 0); } void printSubtree(int depth, node *v, char* prefix) { /* rekurzivne vypise vsetky slova v podstrome s korenom v, * pricom v ma hlbku depth * a spolocny prefix jeho slov je v retazci prefix */ if (v->isWord) { prefix[depth] = '\0'; printf("%s\n", prefix); } for (int i = 0; i < Abeceda; i++) { if (v->next[i] != NULL) { prefix[depth] = (v->next[i])->data; // pridám si ďalšie písmeno printSubtree(depth + 1, v->next[i], prefix); // zavolám sa rekurzívne } } } void printTrie(trie &t) { /* vypise vsetky slova v lexikografickom strome t */ char *prefix = new char[maxLen+1]; printSubtree(0, t.root, prefix); delete[] prefix; } void preorder(node* v){ if (v==NULL) return; char *isWord = ""; if(v->isWord) isWord = "*"; printf("%c%s ", v->data, isWord); printf("["); for (int i=0; i<Abeceda; i++){ preorder(v->next[i]); } printf("] "); } int main(void) { trie t; init(t); insert(t, "ARE"); insert(t, "AS"); insert(t, "A"); insert(t, "DO"); insert(t, "DOT"); if (find(t, "ARE")) { printf("Nasiel ARE\n"); } if (find(t, "AR")) { printf("Nasiel AR\n"); } if (find(t, "AREA")) { printf("Nasiel AREA\n"); } preorder(t.root); printf("\n"); printTrie(t); remove(t, "AHO"); remove(t, "ABC"); destroy(t); }
Prednáška 24
Organizačné poznámky
Dobeh semestra:
- DÚ10 a PDÚ4 do 10.12.
- Cvičenia + rozcvičky 10.12.
- Prednášky:
- dnes opakovanie, príprava na písomku a skúšku
- pondelok 10.12. nepreberané črty jazykov C a C++
- utorok 11.12. prednáška nebude
- Na stránke zverejnené ukážkové príklady na písomku a skúšku
- Skontrolujte si v Moodli známky z DÚ aj rozcvičiek, problémy nám hláste čím skôr
- Jednotlivé body podľa Moodla, súčty/percentá podľa pravidiel predmetu (Moodle nezobrazuje správne)
- V stredu 12.12. na Matematickej propedeutike (14:50, M-VII) dobré rady k skúškovému obdobiu s vašim tútorom Tomášom Kulichom
Sylaby predmetu
Základy
Konštrukcie jazyka C
- premenné typov int, double, char, bool (vzťah int a char)
- podmienky (if, else, switch), cykly (for, while)
- funkcie (a parametre funkcií - odovzdávanie hodnotou, referenciou, smerníkom)
void f1(int x){} //hodnotou void f2(int &x){} //referenciou void f3(int* x){} //smerníkom void f(int a[], int n){} //polia bez & (ostanú zmeny) void kresli(Turtle &t){} //korytnačky, okná a pod. s &
Polia, reťazce (char[])
int A[4]={3, 6, 8, 10}; //spravne int B[4]; //spravne B={3, 6, 8, 10}; //nespravne B[0]=3; B[1]=6; B[2]=8; B[3]=10; char C[100] = "pes"; char D[100] = {'p', 'e', 's', 0};
- funkcie strlen, strcpy, strcmp, strcat
Súbory, spracovanie vstupu
- cin, cout alebo printf, scanf
- fopen, fclose, feof
- fprintf, fscanf
- getc, putc, ungetc, fgets, fputs
- spracovanie súboru po znakoch, po riadkoch, po číslach alebo slovách
Smerníky, dynamicky alokovaná pamäť, dvojrozmerné polia
int i; // „klasická“ celočíselná premenná int *p; // ukazovateľ na celočíselnú premennú p = &i; // spravne p = &(i + 3); // zle i+3 nie je premenna p = &15; // zle konstanta nema adresu i = *p; // spravne ak p bol inicializovany int * cislo = new int; // alokovanie jednej premennej *cislo = 50; .. delete cislo; int a[4]; int *b = a; // a,b su teraz takmer rovnocenne premenne int *A = new int[n]; // alokovanie 1D pola danej dlzky .. delete[] A; int **a; // alokovanie 2D pola a = new int *[n]; for (int i = 0; i < n; i++) a[i] = new int[m]; .. for (int i = 0; i < n; i++) delete[] a[i]; delete[] a;
Dátové štruktúry
Abstraktný dátový typ vektor (rastúce pole)
- operácie add, get, set, length
Abstraktný dátový typ slovník (asociatívne pole, map)
- operácie insert, find, remove
- implementácie
- utriedené, neutriedené pole
- hashovacia tabuľka
- spájaný zoznam
- binárny vyhľadávací strom
- lexikografický strom (ak kľúč je reťazec)
Abstraktné dátové typy rad a zásobník
- operácie pre rad (frontu, queue): init, isEmpty, enqueue, dequeue, peek
- operácie pre zásobník (stack): init, isEmpty, push, pop, top
- implementácie: v poli alebo v spájanom zozname
- využitie: ukladanie dát na spracovanie, odstránenie rekurzie
- kontrola zátvoriek a vyhodnocovanie výrazov pomocou zásobníka
Spájané zoznamy
struct node { int data; item* next; }; struct linkedList { item* first; }; void insertFirst(linkedList &z, int d){ /* do zoznamu z vlozi na zaciatok novy prvok s datami d */ item* p = new item; // vytvoríme nový prvok p->data = d; // naplníme dáta p->next = z.first; // prvok bude prvým prvkom zoznamu (ukazuje na doterajší začiatok) z.first = p; // tento prvok je novým začiatkom }
Binárne stromy
struct node { /* vrchol stromu */ dataType data; node * left; /* lavy syn */ node * right; /* pravy syn */ }; node * createNode(dataType data, node *left, node *right) { node *v = new node; v->data = data; v->left = left; v->right = right; return v; }
- prehľadávanie inorder, preorder, postorder
- použitie na uloženie aritmetických výrazov
Binárne vyhľadávacie stromy
- vrcholy vľavo od koreňa menší kľúč, vpravo od koreňa väčší
- insert, find, remove v čase závisiacom od hĺbky stromu
Lexikografické stromy
- ukladajú množinu reťazcov
- nie sú binárne: vrchol môže mať veľa synov
- insert, find, remove v čase závisiacom od dĺžky kľúča, ale nie od počtu kľúčov, ktoré už sú v strome
struct node { /* vrchol lexikografickeho stromu */ char data; // pismeno ulozene v tomto vrchole bool isWord; // je tento vrchol koncom slova? node* next[Abeceda]; // pole smernikov na deti };
Algoritmy
Rekurzia
- Rekurzívné funkcie
- Vykresľovanie fraktálov
- Prehľadávanie s návratom (backtracking)
- Vyfarbovanie
- Prehľadávanie stromov
Triedenia
- nerekurzívne: Bubblesort, Selectionsort, Insertsort
- rekurzívne: Mergesort, Quicksort
- súvisiace algoritmy: binárne vyhľadávanie, hľadanie mediána
Matematické úlohy
- Euklidov algoritmus, Eratostenovo sito
- Práca s polynómami (vyhodnocovanie, sčítanie)
- Práca s aritmetickými výrazmi: rekurzívne vyhodnocovanie, vyhodnocovanie postfixovej formy, prevod z infixovej do postfixovej, reprezentácia vo forme stromu
Záverečná písomka
- Termín: pondelok 17.12.2011 o 10:00 v posluchárni B
- Opravný/náhradný termín: 8.1. o 10:00 v M-VII
- 90 minút
- Aby ste mali šancu úspešne ukončiť predmet, musíte získať aspoň polovicu bodov.
Čo musíte, môžete a nemôžete
- Musíte
- Index/ISIC
- Perá (pre istotu aj viac)
- Môžete
- Ťahák veľkosti A4
- Nemôžete
- Žiadne elektronické pomôcky (vypnúť mobily)
- Opisovať
- Iné materiály na stole (čisté papiere dostanete od nás)
Príklady
- Bude zhruba 5 príkladov
- Príklad môže mať niekoľko podpríkladov, ktoré sú zároveň odporúčaným postupom krokov
- Náročnosť zhruba ako rozcvičky
- Dobre si rozvrhnite čas, niektoré úlohy sú ťažšie, iné ľahšie.
Skúška pri počítači
- Termíny vypísané v AIS
- Prineste si ISIC a index, písacie potreby na písanie pracovných poznámok, ťahák v rozsahu jedného listu A4. Žiadne ďalšie pomôcky nie sú povolené, nebude k dispozícii ani internet.
- Stretávame sa vždy o 8:50 pred počítačovou halou (H3 alebo M217), kde sa dozviete pokyny a rozsadenie do miestností
- Doobeda: 2 hodiny práca pri počítačoch.
- Prostredie ako na cvičeniach (Linux, Netbeans, ale môžete používať aj iné nainštalované editory, valgrind a pod.)
- Budete používať špeciálne skúškové konto, takže nebudete mať k dispozícii žiadne svoje súbory alebo nastavenia.
- Odovzdávanie prostredníctvom špeciálnej webstránky, slúži súčasne ako záloha.
- Poobede: vyhodnotenie u prednášajúcich, zapisovanie známok.
- Prihlasovanie/odhlasovanie na skúšku do 14:00 deň pred skúškou.
- Aby ste mali šancu úspešne ukončiť predmet, musíte získať aspoň polovicu bodov.
Príklady
- Na skúške budete riešiť dva príklady.
- V prvom príklade budete mať za úlohu samostatne napísať celý program, ktorý rieši zadanú úlohu. Typicky bude treba načítať dáta zo súboru, spracovať ich a vypísať výsledok.
- V tomto príklade môžete použiť ľubovoľný postup.
- V druhom príklade dostanete kostru programu, pričom vašou úlohou bude doprogramovať niektoré funkcie.
- V tomto príklade môžete mať v zadaní predpísaný spôsob, ako máte niektoré časti naprogramovať.
- Budú sa vyžadovať aj zložitejšie časti učiva, ako napríklad zoznamy, stromy a rekurzia.
- Nebudeme používať SimpleDraw.
- Môžete používať aj črty C/C++, ktoré sme nebrali. Používajte len štandardné súčasti jazyka. Vaše programy by mali fungovať v prostredí používanom v učebni bez zvláštnych nastavení kompilátora a pod.
Hodnotenie
- V prvom rade budeme hodnotiť správnosť myšlienky vášho programu. Predtým, ako začnete programovať, si dobre rozmyslite, ako budete úlohu riešiť.
- Ďalej je dôležité, aby sa program dal skompilovať (v štandardnom prostredí Netbeans) a aby správne fungoval na všetkých vstupoch spĺňajúcich podmienky v zadaní. Za nefunkčné programy môžete získať najviac polovicu bodov, aj keď ich myšlienka je správna.
- V druhej úlohe budeme jednotlivé funkcie hodnotiť zvlášť, takže môžete získať čiastočné body, ak ste niekoľko funkcií správne napísali.
- Hodnotiť budeme aj úpravu a štýl programu (komentáre, mená premenných, odsadzovanie, členenie dlhšieho programu na funkcie,...)
- Na tejto skúške nezáleží na rýchlosti vášho programu. Radšej napíšte jednoduchý, prehľadný a hlavne správny pomalší program, než rýchlejší, ale zbytočne zložitý, či nesprávny.
Opravné termíny
- Máte nárok na dva opravné termíny (ale len v rámci termínov, ktoré sme určili).
- Toto sa týka písomky aj skúšky pri počítači.
- Účasť na opravnom termíne písomky teda tiež vedie k zápisu známky z predmetu v opravnom termíne.
- Druhý opravný termín písomky môžu písať len študenti, ktorí už majú absolvovanú skúšku na aspoň 50% bodov a majú šancu úspešne ukončiť predmet (termín určíme v prípade potreby).
- Ak sa zúčastníte opravného termínu, strácate body z predchádzajúceho termínu, aj keby ste na opravnom získali menej bodov.
- Ak po skúške pri počítači máte nárok na známu E alebo lepšiu, ale chceli by ste si známku ešte opraviť, musíte sa dohodnúť so skúšajúcimi pred zapísaním známky do indexu.
- Ak po skúške pri počítači ešte opravujete písomku, je potrebné prísť uzavrieť a zapísať známku v termíne určenom vyučujúcimi.
- Ak sa zo závažných dôvodov (napr. zdravotných, alebo konflikt s inou skúškou) nemôžete zúčastniť termínu skúšky alebo písomky, dajte o tom vyučujúcim vedieť čím skôr.
Cvičenia 12
- Máme binárny strom, v ktorom má každý vrchol buď dve deti a v dátovom poli uložený znak '#' alebo nemá žiadne deti a v dátovom poli má uložený znak '*'. Keď tento strom vypíšeme v preorder poradí, dostaneme postupnosť ##*#*** Nakreslite, ako vyzerá tento strom.
- Nakreslite binárny vyhľadávací strom, ktorý dostaneme, ak do prázdneho slovníka postupne vkladáme záznamy s kľúčami 3, 4, 1, 2, 5, 6 (v tomto poradí).
- Napíšte funkciu dvojicky(node *root), ktorá spočíta počet všetkých vnútorných vrcholov v binárnom strome s koreňom root takých, že ich ľavé aj pravé dieťa majú v svojom dátovom poli uloženú tú istú hodnotu.
- Napíšte rekurzívnu funkciu, ktorá každému uzlu binárneho stromu prirobí smerník na otca do položky parent typu node *. Funkcia bude mať hlavičku void assignParent(node *v, node *parent) kde vrchol parent je otcom vrchola v, alebo NULL ak v je koreň a teda nemá otca. Funkcia doplní otca vrcholu v aj všetkým jeho potomkom, t.j. napr. synom vrchola v nastaví ako otca smerník na v. Použite nasledujúcu štruktúru pre vrchol stromu:
struct node { /* vrchol stromu */ dataType data; node * left; /* lavy podstrom */ node * right; /* pravy podstrom */ node * parent; /* otec vrcholu */ };
- Uvažujte binárne stromy pre aritmetické výrazy, v ktorých máme aj premennú x. Tá sa spozná podľa toho, že v položke op je uložený znak 'x' (položka val sa v takýchto vrcholoch nepoužíva).
- Napíšte funkciu, ktorá dostane nezáporné celé číslo n a zostaví strom, ktorý reprezentuje Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle x^n} , pričom použije len vrcholy pre premennú x a pre násobenie.
- Modifikujte funkciu evaluate z prednášky 20 tak, aby pracovala aj pre výrazy s premennou x, pričom hodnotu tejto premennej dostane ako parameter, t.j. hlavička bude double evaluate(node *v, double x) {. Overte, že ak tútu funkciu spustíte pre váš strom zodpovedajúci Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle x^n} , dostanete správny výsledok.
- Napíšte funkciu, ktorá dostane utriedené pole čísel a vytvorí z nich binárny vyhľadávací strom (priamo, bez použitia funkcie insert). Pokúste sa strom vytvoriť tak, aby ľavý a pravý podstrom každého vrcholu obsahovali približne rovnako veľa prvkov.
- Doporučujeme postupovať rekurzívne, pričom napíšte funkciu s hlavičkou napr. node * vytvorStrom(int a[], int l, int r), ktorá vytvorí strom pre časť poľa a od pozície l po pozíciu r.
DÚ10
Odovzdávanie DÚ10 max. 10 bodov plus 4 body bonus, termín odovzdania pondelok 10.12. o 22:00
Cieľom tejto úlohy je precvičiť si prácu so stromami.
Vašou úlohou je napísať program, ktorý odkóduje text zapísaný Morseovou abecedou, pričom túto abecedu budete mať uloženú v binárnom strome. Samotnú Morseovu abecedu načítajte zo súboru s názvom morse.txt, ktorý si stiahnite tu. Na každom riadku súboru je jedno písmeno a za medzerou zápis tohto písmena v Morseovej abecede pomocou znakov bodka a pomlčka. Budeme pracovať len s kódmi pre písmená A až Z. Text na dekódovanie zadá užívateľ ako jeden riadok na konzole, pričom kódy pre jednotlivé písmená sú oddelené medzerou a dve medzery znamenajú medzeru medzi slovami. Napríklad ak užívateľ zadá text ".... . .-.. .-.. --- .-- --- .-. .-.. -..", váš program by mal vypísať "HELLO WORLD". Ak text obsahuje neexistujúci kód, program vypíše namiesto takéhoto písmena otáznik, napríklad pre zadaný text "... ------ ..." vypíše "S?S".
Morseovu abecedu si uložte vo forme binárneho stromu, kde každý vrchol môže mať dve deti, jedno nazvané dot (bodka) a druhé dash (čiarka). Určitému kódu zodpovedá vrchol, do ktorého sa dostaneme z koreňa, pričom budeme vždy na bodku pokračovať do dieťaťa nazvaného dot a na pomlčku do dieťaťa nazvaného dash. V tomto vrchole máme ako dáta uložené písmeno, ktoré tomuto kódu zodpovedá. Príklad prvých troch vrstiev stromu je na obrázku nižšie. Písmeno A má kód .- a teda sa k jeho vrcholu dostaneme tak, že z koreňa pôjdeme do dieťaťa označeného dot a odtiaľ do dieťaťa označeného dash. Niektoré vrcholy, napríklad koreň, nezodpovedajú žiadnemu písmenu v Morseovej abecedy a teda v nich namiesto písmena máme uložený otáznik, t.j. znak '?'. Na uloženie stromu použite nasledovnú dátovú štruktúru:
struct node { /* vrchol stromu */ char letter; /* pismeno vo vrchole alebo '?' */ node * dot; /* kod predlzeny o bodku */ node * dash; /* kod predlzeny o ciarku */ };
V svojom programe naprogramujte nasledujúce dve funkcie na základnú prácu s Morseovým kódom, ktoré potom použite vo vašom programe, ktorý načíta Morseovu abecedu zo súboru, zakódovaný text od užívateľa a vypíše výsledok.
void addCode(char letter, char code[], node *root) { /* Do stromu s koreňom root pridá kód uložený v reťazci code * ktorý zodpovedá písmenu letter. */ }
V tejto funkcii postupujte z koreňa hlbšie podľa zadaného kódu, kým nenanarazíte na nulový smerník. Ďalej vytvárajte nové vrcholy podľa potreby. Keď prídete do vrcholu zodpovedajúcemu celému kódu, uložte do neho dané písmeno. Môže sa stať, že nebudete musieť vytvárať žiadne nové vrcholy, lebo vrchol pre daný kód už bol vytvorený počas spracovávania nejakého dlhšieho kódu.
char findLetter(char message[], int &pos, node *root) { /* V strome s koreňom root nájde písmeno zodpovedajúce kódu, * ktorý v texte message začína na pozícii pos. * Toto písmeno vráti ako výsledok funkcie. * Ak takéto písmeno neexistuje, vráti znak '?'. * Pozíciu pos posunie na najbližšiu medzeru za kódom alebo za * posledné písmeno textu, ak za kódom je už koniec textu. */
V tejto funkcii nezabudnite na možnosť, že príslušný kód nie je v strome a vtedy treba vrátiť otáznik, ale aj správne posunúť pos za koniec kódu.
Bonusová úloha: Na vstupe dostanete od užívateľa text v Morseovej abecede, v ktorom ale chýbajú medzery oddeľujúce kódy pre jednotlivé znaky. Dostanete tiež počet písmen, ktorý je v texte zakódovaný. Napíšte rekurzívne prehľadávanie, ktoré nájde všetky texty danej dĺžky, ktoré majú takýto kód. Napríklad pre text "..." a počet znakov 2 by ste mali dostať možnosti EI a IE. Pre text "......-...-..---" a počet znakov 5, by ste mali dostať 62 možností, z ktorých jedna je HELLO. Bonusovú úlohu odovzdajte v tom istom programe ako základ domácej úlohy, pričom program si najskôr vypýta text s medzerami, odkóduje ho a potom si ešte vypýta text bez medzier a počet hľadaných znakov a vypisuje všetky možnosti.
Prednáška 25
Na tejto prednáške si stručne ukážeme niektoré črty jazykov C a C++, ktoré sme počas semestra nepreberali. Nebudeme preberať väčšie detaily; cieľom je, aby ste neboli príliš prekvapení pri štúdiu existujúcich programov, resp. poskytnúť inšpiráciu pre ďalšie samoštúdium.
Tento materiál nebude vyžadovaný na skúške a ani Vám neodporúčame tieto črty jazyka používať, ak ste sa s nimi dostatočne pred skúškou neoboznámili. Z dnešného prehľadu vynecháme objektovo-orientované programovanie v jazyku C++. Objektovo-orientovanému programovaniu (v jazyku Java) sa budeme venovať budúci semester.
Organizačné poznámky
- Konzultačné hodiny
- 11.12.2012 9:50-11:00 v M263
- 14.12.2012 13:00-14:00 v M163
- 7.1.2013 13:00-14:00 v M163
Jazyk C
- Jazyk C existuje v rôznych verziách.
- V starších verziách nefungujú mnohé veci z jazya C++, ktoré sme bežne používali, napr. komentáre vo forme //, všetky deklarácie premenných musia byť na začiatku funkcie a pod.
Ďalšie typy premenných
- Celé čísla: short int, long int, unsigned int, ...
- Veľkosť jednotlivých typov závisí od kompilátora platformy
- Desatinné čísla: float (menej presný ako double)
- V staršom C-čku nie je bool, používa sa int, ktorý ma hodnotu 0 pre false a nenulovú (napr. 1) pre true.
- Zložený typ union: v tom istom mieste v pamäti môže byť jedna z alternívnych premenných, napr. pri artimetickom strome by sme mohli uložiť buď smerníky na deti, alebo hodnotu v liste a ušetriť tak trochu pamäti
- Typ enum: vymenujeme možné hodnoty, tie sa stanú celočíselnými konštantami: enum farby {biela, cierna, cervena};
Operátory
Okrem operátorov, ktoré sme bežne používali, existuje niekoľko ďalších, napríklad:
- Bitové operátory pracujú s celým číslom ako s poľom bitov (vhodnejšie sú unsigned typy):
- << a >> cyklicky posúvajú bity doľava a doprava, zodpovedajú násobeniu a deleniu mocninami dvojky
- & (and po bitoch), | (or po bitoch), ^ (xor po bitoch), ~ (negácia po bitoch)
- Ternárny operátor ?: má tvar (podmienka)?(hodnota pre true):(hodnota pre false), napr.
cout << x << " je " << ((x%2==0) ? "parne" : "neparne") << endl;
- Pozor na rozdiel medzi a[i++]=0 a a[++i]=0, prehľadnejšie použiť dva príkazy: a[i]=0; i++ alebo i++; a[i] = 0;
Príkaz do-while
Nasledujúce dva spôsoby písania cyklu sú viac-menej ekvivalentné:
do { prikazy; } while(podmienka) while(true) { prikazy; if(!podmienka) break; }
Makrá a konštanty
- V C-čku nie sú klasické konštanty, robia sa pomocou makier. Nasledujúce dva riadky majú podobný význam:
#define MAXN 100 const int MAXN=100;
- Okrem konštánt môžeme definovať aj zložitejšie makrá s parametrami:
/* definicia makra: */ #define MIN(X,Y) ((X) < (Y) ? (X) : (Y)) /* priklad pouzitia: */ cout << MIN(a*a, b+5); /* preprocesor dosadi, dostane: */ cout << ((a*a) < (b+5) ? (a*a) : (b+5));
- Treba dať kopu zátvoriek, aby nedošlo k interakcii s okolím použitia príkazu max
Delenie programu na súbory
- Väčší program chceme rozdeliť na viac súborov
- Chceme vytvárať a používať vlastné knižnice - skupiny funkcií s podobným účelom
- Napríklad knižnica implementujúca funkcie pracujúce so zásobníkom
- Knižnicu rozdelíme na dva súbory, napr. stack.h a stack.c resp. stack.cpp
- V hlavičkovom súbore (header file) zadeklarujeme funkcie, ale neuvádzame ich kód, napr.:
typedef int dataType; struct stack { int top; /* pozicia vrchného prvku zásobníka */ dataType *items; /* pole prvkov */ }; void init(stack &s); bool isEmpty(stack &s); void push(stack &s, dataType data); dataType pop(stack &q);
- Programy, ktoré chcú použiť stack, použijú include na tento súbor
#include "stack.h"
- V súbore stack.cpp uvedieme kód funkcií, napr.
#include "stack.h" const int maxN = 100; void init(stack &s) { s.top = -1; s.items = new dataType[maxN]; } ...
- Všimnite si, že v include dávame meno štandardných knižníc v <>, našich vlastných v ""
- Pri štandardných knižniciach sa v C-čku používa prípona h, v C++ sa namiesto toho väčšinou pridá c na začiatok (že je to knižnica z čistého C)
- Napr. <cmath> vs. <math.h>
- Ako zabrániť, aby sa vložilo include viackrát?
- #ifndef IDENTIFIKATOR #define IDENTIFIKATOR ... #endif
- Preprocesor umožňuje okrem toho aj ďalšie podmienené príkazy #if VYRAZ ... #else ... #endif alebo #ifdef IDENTIFIKATOR ... #else ... #endif
C nemá posielanie parametrov referenciou
- ... používame teda smerníky
void swap(int &a, int &b) { int tmp = a; a = b; b = tmp; } void swap(int *a, int *b) { int tmp; tmp = *a; *a = *b; *b = tmp; }
Zopár užitočných funkcií
Hľadanie v reťazcoch
- strstr(text, vzorka) vracia smerník na char
- NULL ak sa vzorka nenachádza v texte, smerník na začiatok prvého výskytu inak
- pozíciu výskytu zistíme smerníkovou aritmetikou:
char *text, *vzorka; char *where = strstr(text, vzorka); if(where != NULL) { int position = where - text; }
- Ako by ste spočítali počet výskytov vzorky v texte?
- Podobne strchr hľadá prvý výskyt znaku v texte
Alokácia pamäte
- V C-čku sa nepoužíva new a delete, resp. new[] a delete[]
- Pamäť sa alokuje funkciou malloc, ktorá alokuje kus pamäte s daným počtom bajtov
- Ak sa nepodarilo, vráti NULL
- Inak vrati pointer na void, treba pretypovať
- Veľkosť spočítame operátorom sizeof
#include <stdlib.h> /* vytvorime pole 100 int-ov */ int *a = (int *)malloc(sizeof(int) * 100); /* odalokujeme pole a */ free(a);
Triedenie
- Funkcia qsort z knižnice stdlib.h
- Dostane pole, počet jeho prvkov, veľkosť každého prvku a funkciu, ktorá porovná dva prvky
- Funkciu teda posielame ako parameter
- Táto porovnávacia funkcia dostane smerníky na dva prvky v type void *
- Vráti záporné číslo, ak prvý prvok je menší, nulu, ak sú rovnaké a kladné číslo, ak prvý je väčší
- Ak si napíšeme porovnávaciu funkciu, môžeme triediť prvky hocijakého typu
int compare (const void * a, const void * b) { return (*(int*)a - *(int*)b); } int a[] = {5, 3, 2, 4, 1}; qsort (a, 5, sizeof(int), compare);
- Podobne je aj funkcia bsearch na binárne vyhľadávanie v striedenom poli
Jazyk C++
Generické funkcie
- Často chceme napísať algoritmus, ktorý by mohol fungovať veľa rôznych typoch
- Napr. triediť môžeme celé alebo desatinné čísla, reťazce, zložitejšie štruktúry s určitým kľúčom a pod.
- Funkcia qsort nám to umožňuje, ale musíme sa zapodievať veľkosťami a pretypovaním, kde sa dajú ľahko narobiť chyby.
- V C++ sa dajú písať funkcie, ktoré majú typ ako parameter:
template <class T> T max (T a, T b) { return (a>b)? a : b; } int i=3; int j=5; int k=max<int>(i,j);
Preťaženie operátorov
- Pre naše typy si vieme zadefinovať nové operátory
- Napr. dve mená porovnávame najskôr podľa priezviska, pri zhode podľa krstného mena
struct meno { char *krstne, *priezvisko; }; bool operator < (meno x, meno y) { return strcmp(x.priezvisko, y.priezvisko)<0 || strcmp(x.priezvisko, y.priezvisko)==0 && strcmp(x.krstne, y.krstne)<0; }
- Podobne môžeme zadefinovať napr. operátor + a * pre náš struct reprezentujúci trebárs polynómy alebo komplexné čísla...
- cin << "Hello" používa preťažený operátor << ak na ľavej strane je stream a na pravej reťazec
Stringy
- Okrem klasických C-čkových reťazcov môžeme použiť aj C++ typ string.
- Majú elegantnejšie používanie, sami si určujú potrebnú veľkosť pamäte
- Sú to objekty, do funkcií odovzdávame cez &
- Jednotlivým znakom pristupujeme pomocou [] (ako u polí) alebo pomocou metódy at
#include <string> using namespace std; int main(void) { char cstr[100] = "Ahoj\n"; string str = "Ako sa mas?\n"; string str2; /* mozeme priradovat konstantne retazce, C-ckove retazce (polia znamkov) aj C++ stringy. */ str2 = "Ahoj\n"; str2 = cstr; str2 = str; /* meranie dlzky */ cout << "Dlzka je: " << str.length() << endl; /* Funguje porovnanie pomocou ==, !=, <,... * (bud dvoch C++ stringov, alebo C++ stringu a C stringu) * Znamienko + znamená zreťazenie. */ str2 = cstr + str; str2.push_back('X'); str2.push_back('\n'); cout << str2; if (str < str2) { cout << "Prvy je skor" << endl; } else if (str == str2) { cout << "Rovnaju sa" << endl; } else { cout << "Druhy je skor" << endl; } }
- Pomocou funkcie c_str() vieme získať zo stringu premennú typu const char*
Streamy
- Každý textový súbor môžeme chápať ako postupnosť znakov (podobne ako vstup/výstup z konzoly). Teda aj textový súbor je vlastne stream, ktorý môžeme postupne (zľava doprava) čítať alebo do neho zapisovať.
- Textové súbory teda môžeme načítávať alebo zapisovať pomocou analógie k cin a cout
- Budeme využívať typy a funkcie zadefinované v knižnici fstream.
#include <fstream> using namespace std; int main (void) { ofstream o; o.open ("Test.txt"); // otvorenie súboru o << 'z'; // zapíše 1 znak o << "Toto je retazec"; // zapíše reťazec znakov (= postupnosť znakov) o << endl; // 1 znak = nový riadok – znak \ má špeciálny význam o << "Text"; // v súbore bude toto na začiatku nového riadka o << endl; o << 10*32 ; // môžeme zapísať hodnotu výrazu ako reťazec znakov o << endl; o << "10*32=" << 10*32 << endl; // zapíše sa zľava doprava o << "1 rovna sa 4? " << (1==4) << endl; // pozor na priority operátorov ... 1==4 musí byť v zátvorkách !!! o.close (); // zatvorenie súboru }
- ofstream tiež umožňuje formátovanie výstupu napríklad pomocou modifikátorov fixed,setprecision(),setfill(),setw()
- Podobne môžeme otvoriť aj súbor, z ktorého budeme čítať vstup. V príklade načítame pole celých čísel.
#include <fstream> #include <iostream> using namespace std; const int MAX=100; int main (void) { ifstream f; int pocet, A[MAX]; f.open ("VSTUP.txt"); if (f.fail ()) return 1; // return = návrat z funkcie – koniec programu f >> pocet; for (int i=0; i<pocet; i++) { f >> A[i]; } for (int i=0; i<pocet; i++) { cout<< A[i] << " "; } f.close(); }
- Pri načítaní sme sa už stretli s funkciou f.fail(), ktorá vrátila logickú hodnotu pravda ak vznikla chyba (väčšinou pri otovrení neexistujúceho súboru). Druhou možnosťou je testovať správne otvorenie pomocou testovania premennej typu ofstream alebo ifstream. Je to ekvivalentné (snáď skoro vždy) funkcii fail.
ifstream fin("VSTUP.txt"); // input if(!fin) { cout << "Cannot open VSTUP.txt file.\n"; return 1; } ofstream fout("VYSTUP.txt"); // output, normal file if(!fout) { cout << "Cannot open VYSTUP.txt file.\n"; return 1; }
- Testovanie konca súboru môžeme robiť pomocou funkcie eof
ifstream fin("VSTUP.txt"); // input char c; while(!fin.eof()) { fin>>c; cout<<c; }
- Pre streamy je praktická funkcia getline, ktorá načíta zo streamu celý riadok. Nasledovný príklad spočíta v jednotlivých riadkoch počet bodiek.
int main(void){ ifstream f("VSTUP.txt");; string line; int poc; while (getline(f,line)){ poc=0; for (int i=0; i<line.length(); i++){ if (line[i]=='.') poc++; } cout << poc <<endl; }
Niektoré užitočné štruktúry
STL (standard template library)
- Veľká knižnica rôznych dátových štruktúr
- Manuál napr. tu: http://www.sgi.com/tech/stl/
- Vector - pole s dynamickou alokáciou pamäte, čo znamená, že ak by priestor, ktorý si vyhradil nestačil vyrieši si to sám.
- Deklarovať vector môžeme jedným z nasledujúcich spôsobov
vector<int> A; //vytvorí pole celých čísel vector<int> A(10); //vytvorí pole 10 celých čísel, ktoré všetky nastaví na default hodnotu vector<int> A(5,1); //vytvorí pole 5 celých čísel, ktoré nastaví na 1
- Prístup k prvkom vectora je možný dvoma spôsobmi
- klasicky pomocou A[index] - má podobné problémy ako polia
- A.at(index) je bezpečnejší spôsob, kedy v prípade indexu mimo rozsahu nebude robiť neplechu
- Prístup k prvkom vectora je možný dvoma spôsobmi
- Vkladanie do poľa je možné tiež dvomi spôsobmi - ale pozor na miešanie
- do už vytvoreného miesta (ak sme tak deklarovali vector) pomocou priradenia (ďalší priestor získam pomocou A.resize(nova hodnota))
- pomocou A.push_back(x), kedy ako ďalší prvok nastaví x s tým, že o pamäť sa stará sám (veľkosť si potom môžeme zistiť pomocou A.size())
- Vkladanie do poľa je možné tiež dvomi spôsobmi - ale pozor na miešanie
- Ako generická dátová štruktúra:
vector<int> A; for (int i=0; i<10; i++){ A.push_back(i); } for (int i=0; i<A.size(); i++){ cout << A[i] << endl; // alebo A.at(i) }
- Štruktúra map implementuje slovník
map <string, string> zoznam; zoznam["Jozko Mrkvicka"] = "02/12345678"; if(zoznam.count("Jozko Mrkvicka") > 0) { cout << zoznam["Jozko Mrkvicka"] << endl; }
- Štruktúra deque implementuje zásobník aj rad naraz (double-ended queue)
deque <int> a; a.push_back(0); a.push_front(1); cout << a.back() << endl; cout << a.front() << endl; a.pop_back(); a.pop_front();
- Triedenie v knižnici <algorithm>
//triedime normalne pole int A[6] = {1, 4, 2, 8, 5, 7}; sort(A, A + 6); //triedime vektor vector <int> A; sort(A.begin(), A.end()); //triedime podla nasej porovnavacej funkcie, napr. podla absolutnej hodnoty struct cmp { bool operator()(int x, int y) { return abs(x) < abs(y); } }; cmp c; sort(A.begin(), A.end(), c);
Cvičenia 13
- Nakreslite lexikografický strom s abecedou {a,b}, do ktorého sme vložili reťazce aba, aaab, baa, bab, ba. Vrcholy, ktoré zodpovedajú niektorému reťazcu zo vstupu zvýraznite dvojitým krúžkom.
- Na prednáške 23 nájdete ukážkový program pre lexikografický strom. Zmeňte ho tak, aby najskôr načítal zo súboru dict.txt zoznam anglických slov a uložil ich do stromu. Potom načíta od užívateľa nejaký reťazec a vypíše všetky slová, ktoré na tento reťazec začínajú. Napríklad pre reťazec all vypíše all allah allegiance allen alley alliance allied allow allowance allowed allowing allude allusion ally. Skúste pozmeniť alebo využiť funkcie printSubtree a find. Pozor, program predpokladá, že reťazce obsahujú iba veľké písmená anglickej abecedy. Malé písmena zo vstupu zmeníte na veľké funkciou toupper z knižnice cctype.
- Naprogramujte funkciu, ktorá uprace lexikografický strom, t.j. uvoľní všetky vrcholy, ktoré nemajú žiaden vrchol, kde isWord je pravdivé, svojom podstrome.
- Vyskúšajte si vyriešiť ukážkový prvý príklad na skúšku, prípadne niektoré ukážkové príklady na písomku.