MASARYKOVA UNIVERZITA PEDAGOGICKÁ FAKULTA
Programování – Delphi 7 Object Pascal (Příloha diplomové práce)
Pavel Dohnal 2008/2009
OBSAH
ÚVOD...................................................................................................................................................................... 3 1.
ODDÍL I. ZÁKLADY .................................................................................................................................. 4 1.1 CO JE TO PROGRAM? .................................................................................................................................. 4 1.2 DELPHI 7 ................................................................................................................................................... 4 1.2.1 Vývojové prostředí........................................................................................................................... 4 1.2.2 Spuštění vývojového prostředí ......................................................................................................... 4 1.2.3 Ukázka a popis vývojového prostředí .............................................................................................. 5 1.3 ZÁKLADNÍ STRUKTURA PROGRAMU ........................................................................................................... 5 1.4 ZÁKLADNÍ POJMY ...................................................................................................................................... 6 1.4.1 Co je to příkaz? ............................................................................................................................... 6 1.4.2 Klíčová slova ................................................................................................................................... 6 1.4.3 Rezervovaná slova ........................................................................................................................... 6 1.4.4 Poznámky ........................................................................................................................................ 6 1.4.5 Pravidla zápisu zdrojového kódu .................................................................................................... 6 1.5 PŘÍKAZY VÝSTUPU .................................................................................................................................... 7 1.6 IDENTIFIKÁTORY ....................................................................................................................................... 8 1.7 DATOVÉ TYPY ........................................................................................................................................... 8 1.7.1 Ordinální typy ................................................................................................................................. 8 1.7.2 Datové typy reálných čísel ............................................................................................................ 10 1.7.3 Datové typy řetězců ....................................................................................................................... 10 1.8 PROMĚNNÉ, KONSTANTY A JEJICH DEKLARACE ....................................................................................... 10 1.9 VÝRAZY .................................................................................................................................................. 11 1.10 PŘIŘAZOVACÍ PŘÍKAZ ......................................................................................................................... 12 1.11 PŘÍKAZ VSTUPU .................................................................................................................................. 13 SAMOSTATNÁ PRÁCE K PRVNÍ ČÁSTI ................................................................................................................. 14
2.
ODDÍL II. ŘÍZENÍ CHODU PROGRAMU ............................................................................................ 15 2.1 VĚTVENÍ PROGRAMU ............................................................................................................................... 15 2.1.1 Neúplný podmíněný příkaz ............................................................................................................ 15 2.1.2 Úplný podmíněný příkaz................................................................................................................ 16 2.1.3 Relační operátory .......................................................................................................................... 17 2.1.4 Volba náhodných čísel .................................................................................................................. 18 2.2 CYKLY ..................................................................................................................................................... 19 2.2.1 Cyklus s příkazem While ............................................................................................................... 20 2.2.2 Cyklus s příkazem Repeat .............................................................................................................. 21 2.2.3 Cyklus s příkazem For ................................................................................................................... 23
3.
ODDÍL III – POLE A ŘETĚZEC ............................................................................................................ 26 3.1 STATICKÉ JEDNOROZMĚRNÉ POLE A PŘÍKAZ ARRAY ............................................................................... 26 3.1.1 Přístup k prvkům pole ................................................................................................................... 28 3.1.2 Plnění polí ..................................................................................................................................... 28 3.2 STRING A PRÁCE S ŘETĚZCEM .................................................................................................................. 30 3.2.1 Přehled příkazů a funkcí pro práci s řetězci ................................................................................. 31
4.
ODDÍL IV – PODPROGRAMY ............................................................................................................... 34 4.1 PROCEDURY ............................................................................................................................................ 34 4.1.1 Procedury a parametry ................................................................................................................. 35 4.2 FUNKCE ................................................................................................................................................... 37 4.2.1 Funkce a parametry ...................................................................................................................... 38
DOPORUČENÁ LITERATURA: ...................................................................................................................... 40 MOŽNÁ ŘEŠENÍ PŘÍKLADŮ NA PROCVIČENÍ: ....................................................................................... 41 MOŽNÁ ŘEŠENÍ PŘÍKLADŮ SAMOSTATNÉ PRÁCE: ............................................................................. 69
2
Úvod Programovací jazyky jsou umělé jazyky vytvořené pro zápis počítačového programu. Mají přesně definovanou syntaktickou stavbu a sémantiku a pracují s lexikálními jednotkami. Z tohoto pohledu by se dalo říci, že fungují stejně jako jazyky přirozené. Existují různé přirozené jazyky a stejně tak existují i různé jazyky umělé. Od přirozených jazyků se však tyto jazyky výrazně liší. Zatímco přirozené jazyky vznikaly svou vlastní cestou a neustále se kontinuálně vyvíjejí, umělé jazyky jsou vytvářeny cíleně a k jejich změnám dochází pouze v případě, že stávající podoba jazyka přestane vyhovovat požadavkům tvorby programů, pro jejichž vytváření je programovací jazyk určen. Změny nejsou postupné, nýbrž skokové. Programovací jazyky a jejich vývojová prostředí slouží k vývoji a realizaci nejrůznějších programů a systémů. Každý program má svůj zdrojový kód, tedy textový soubor, který obsahuje popis algoritmu v daném programovacím jazyce. Přeložený a sestavený program je uceleným souborem instrukcí zapsaných ve strojovém kódu, který je schopen spouštění na počítači. Tento text se bude věnovat strukturované formě programování v jazyce Object Pascal a ve vývojovém prostředí Delphi 7 Personal Edition. Bude možné ho využít jako materiál pro výuku základů programování na základních školách, jako referenční příručku ho zároveň budou moct využít všichni, kdo se s programováním zatím nesetkali a chtěli by do základů programování proniknout. Dokument je rozdělen do čtyř oddílů: Základy, Řízení chodu programu, Pole a řetězec a Podprogramy. Každý oddíl obsahuje teoretické informace, obecné vysvětlení problematiky a příklady na procvičení. Na konci textu jsou uvedena řešení jednotlivých úkolů. Materiál je k dispozici rovněž na CD-ROMu a na webových stránkách www.programovaninazs.wz.cz, kde je také zprovozněno fórum, ve kterém si uživatelé mohou navzájem předávat zkušenosti, diskutovat o problémech, řešit nové úlohy a komentovat studijní materiál jako takový.
3
1. Oddíl I. Základy 1.1
Co je to program?
Zjednodušeně by se dalo říct, že program je text zapsaný v některém z programovacích jazyků. Tento text (zdrojový kód) je tvořen posloupností instrukcí a příkazů, již zpravidla označujeme pojmem algoritmus. Programátor text vytváří v podobě srozumitelné člověku. Po spuštění programu je však text programu pomocí překladače programovacího jazyka přeložen do jazyka srozumitelného počítači (procesoru počítače), do tzv. strojového kódu, jinak by počítač nebyl schopný s textem programu pracovat. Program vždy pracuje s konkrétními daty s přesně stanovenými vlastnostmi. Kromě dat jsou vždy specifikovány i příkazy neboli operace, jež mají být s daty provedeny. Výsledkem programu jsou opět data, jež byla získána provedením požadovaných operací. K výsledným datům je možné se dopracovat několika různými způsoby, a není proto výjimkou, že zdrojové kódy programů se u jednotlivých programátorů do značné míry liší, a to i v případech, že programátoři řeší stejné zadání.
1.2
Delphi 7
1.2.1 Vývojové prostředí Vývojovým prostředím se rozumí software (aplikace), která programátorovi umožňuje vytvářet programy. Tyto aplikace bývají často vázány na jeden programovací jazyk a tomuto jazyku jsou rovněž přizpůsobeny, např. vývojové prostředí Delphi je založeno na jazyku Object Pascal. Téměř každé vývojové prostředí se skládá ze tří částí, a to z textového editoru, překladače a debuggeru. Textový editor slouží k samotnému zápisu zdrojového kódu, překladač daného jazyka překládá zdrojový kód zapsaný programátorem do strojového kódu, tj. do podoby, se kterou může pracovat procesor, a debugger je ladicí nástroj sloužící k ladění programů. Delphi, ale i některá jiná vývojová prostředí obsahují navíc systém pro rychlý vývoj aplikací (RAD), který umožňuje snadné vytváření vizuálních návrhů grafického uživatelského rozhraní.
1.2.2 Spuštění vývojového prostředí Spuštění vývojového prostředí: Ikona na ploše – Delphi 7 nebo Start – programy – Borland Delphi 7 – Delphi 7 Spuštění konzoly: File – New – Other... – Console Application Spuštění programu: Klávesa – F9
4
1.2.3 Ukázka a popis vývojového prostředí Na následujícím obrázku je zobrazena pracovní plocha vývojového prostředí Delphi 7. Červeně jsou zvýrazněny prvky, které budeme využívat: pracovní okno pro zápis zdrojového kódu (editor kódu) a „zelený trojúhelník“ pro spuštění programu. Nezvýrazněné ikony panelu nástrojů se zpravidla využívají při tvorbě programů v rámci objektového programování.
1.3
Základní struktura programu
program Název programu; {hlavička programu je povinná a obsahuje název programu} uses SysUtils; {V této části se deklarují globálně dostupné prvky programů, které se budou později využívat. Jsou jimi konstanty (za klíčovým slovem const); proměnné (za klíčovým slovem var); typy (za klíčovým slovem type); procedury a funkce.} begin {příkazová část – je tvořena posloupností příkazů} end.
5
1.4
Základní pojmy
1.4.1 Co je to příkaz? Příkaz v tomto smyslu přestavuje předpis pro vykonání určité operace. Příkazy se vykonávají ve stejné posloupnosti, v jaké byly zapsány, není-li řídicí strukturou určeno jinak. Příkazy se dělí na ty, které mění tok programu (cykly, větvení atd.), a na ty, které mění stav paměti (vstupní/výstupní příkazy atd.).
1.4.2 Klíčová slova Klíčová slova vyznačují jednotlivé konstrukce jazyka, podle nichž se překladač orientuje ve zdrojovém kódu. Mají jednoznačně definovaný význam, nelze je měnit a nemohou být použita v jiném významu. Klíčovými slovy v Object Pascalu jsou např. výrazy begin, end, if, else, do, div, var, while, and, array, class, for, in, or, repeat, set, type atd.
1.4.3 Rezervovaná slova Rezervovaná slova se od klíčových slov liší tím, že mají svůj význam pouze v určitém bloku. Mimo tento blok je možné tato slova použít jako identifikátory, z důvodu přehlednosti se však toto použití nedoporučuje. Rezervovanými slovy Object Pascalu jsou např. výrazy default, private, public, published apod.
1.4.4 Poznámky Poznámka ve zdrojovém kódu je část textu, kterou překladač při spouštění programu ignoruje. Slouží k vytváření vlastních záznamů a vysvětlivek, kterými programátor pro vlastní potřebu popisuje jednotlivé části kódu a zvyšuje tak jeho přehlednost. Object Pascal nabízí několik možností, jak poznámku zapsat. Chceme-li zapsat poznámku na více řádků, je vhodné použít složené závorky „{,}“ a text vepsat mezi ně. Pro krátkou poznámku, tedy pro poznámku na jeden řádek je vhodnější použít dvojité lomítko „//“. Překladač ignoruje veškerý text, který je zapsán od tohoto znaku až do konce řádku.
1.4.5 Pravidla zápisu zdrojového kódu Zdrojový text programu se formátuje tak, aby byl co nejpřehlednější. Každý programátor si může vytvořit svůj vlastní styl podle toho, co mu vyhovuje. Existuje však několik obecných pravidel, které je vhodné při psaní programu dodržovat: − každý příkaz začíná na samostatném řádku − středník oddělující dva příkazy se píše za prvním z nich − vnořené příkazy jsou od levého okraje odsazeny více než jejich obalující konstrukce − dvojice k sobě příslušejících klíčových slov jsou psány pod sebe (např. begin a end, if a else) − významnější části programu jsou odděleny prázdnými řádky a doplněny o komentáře − do záhlaví programu se vkládá komentář, který stručně rekapituluje zadání problému, jejž program řeší
6
1.5
Příkazy výstupu
Aby byl program užitečný, musí být schopný zveřejnit vypočtené výsledky. K tomu slouží příkazy výstupu. Standardní výstup (výstup na obrazovku) se zajistí příkazy Write a Writeln. Obecný tvar zápisu příkazů je:
Write (P1, P2, … , Pn);
- zobrazí na standardní výstup hodnoty parametrů P1 - Pn
Writeln (P1, P2, … , Pn);
- zobrazí na standardní výstup hodnoty parametrů P1 - Pn, a navíc provede přechod na následující řádek
nebo
Parametry P1, P2, … , Pn mohou být výrazy, proměnné nebo texty (řetězce). Výstupní text se uzavírá do apostrofů (‘) a od proměnných a výrazů se odděluje čárkami. Jednoduché výrazy jsou před vlastním výstupem vypočteny za použití příkazů Write a Writeln. ►Příklad výstupu na obrazovku Write (‘Adresa skoly:’); - na obrazovku se vypíše text „Adresa skoly:“ Write (20 + 30); - na obrazovku se vypíše výsledek výrazu, čili „50“ Write (‘Obvod ctverce je: ’ , 4*15, ‘ cm’); - na obrazovku se vypíše text „Obvod ctverce je: 60 cm“ Problematika výstupu je značně rozsáhlá. Výše uvedený přehled bude v budoucnu dále rozšiřován. * * * Procvičení:
Všechny programy opatřete poznámkou, ve které bude uvedeno jméno programu a k jakým výpočtům je určen. ■ (01) Napište program, který na obrazovku vypíše pozdrav (např. Zdravím všechny!).
■ (02) Vytvořte program, který na obrazovku vypíše název a adresu vaší školy. Jednotlivé položky adresy budou uvedeny na samostatných řádcích. ■ (03) Rozšiřte předchozí program (02) tak, aby mezi názvem školy a adresou byl jeden volný řádek. ■ (04) Napište program, který na obrazovku vypíše obvod a obsah obdélníka, jehož velikosti stran jsou: a = 5 cm, b = 7 cm. (Program vypíše informaci o tom, co bude počítat, rozměry obdélníka a na samostatných řádcích bude vypsán obsah a obvod.) 7
1.6
Identifikátory
Identifikátory (jména) se používají jako označení proměnných, konstant, typů, procedur, funkcí a mnoha dalších objektů, které jsou programem používány. Identifikátorem je posloupnost písmen a číslic, která začíná písmenem a je různá od klíčových a rezervovaných slov. V identifikátoru mohou být použita malá a velká písmena anglické abecedy spolu se znakem podtržítka „_“, a číslic 0 až 9. ►Příklady SPRÁVNĚ vytvořených identifikátorů Cislo, SoucetCisel, Pocet_znaku, X_1, ZNAK apod. ►Příklady NESPRÁVNĚ vytvořených identifikátorů Identifikátor 1pomoc Číslo X>Y B-A Pocet znaku DO POZOR! G4d8ee5_bl
1.7
Popis chyby Identifikátor musí začínat písmenem. Znaky české abecedy, které nejsou zároveň znaky abecedy anglické, nepatří mezi písmena (č, š, ř, ž, ě apod.). Speciální symboly nelze použít. Znak minus (pomlčka) nelze použít, nejedná se o znak podtržítka. Oddělovač (mezera) nesmí být součástí identifikátoru. Klíčové slovo nemůže být použito jako identifikátor. Znak vykřičníku nesmí být použit. Syntakticky správný identifikátor, ale nesrozumitelný.
Datové typy
Object Pascal je silně typizovaný programovací jazyk, a každá proměnná proto musí mít svůj datový typ. Datový typ určuje, jaké operace může kompilátor (překladač) s proměnnou provádět a jakým způsobem jsou data v proměnné uložena na harddisku. Object Pascal má k dispozici širokou škálu standardních datových typů, které lze rozšířit o typy, jež si nadefinuje sám uživatel. Datové typy se v Object Pascalu dělí na typy ordinální, číselné s pohyblivou desetinnou čárkou (reálná čísla), řetězcové, strukturované, ukazatelové a na typ Variant.
1.7.1 Ordinální typy Ordinálními typy se rozumí všechny takové typy, které mají omezený počet hodnot a které můžeme navíc snadno seřadit jeden za druhým. Na ordinálních typech potom můžeme definovat funkce Pred (z angl. Predecessor – předchůdce) a Succ (z angl. Successor – následník), které vracejí předchůdce, resp. následníka zadaného prvku. Mezi ordinální prvky patří všechny celočíselné datové typy, znakové sady, booleovské typy a typ výčtový. Celočíselné datové typy Object Pascal nabízí pro reprezentaci celých čísel hned několik datových typů. Tyto typy se liší svým rozsahem (tj. intervalem hodnot, jež mohou proměnné daného typy nabývat) a také nároky na místo v paměti.
8
Přehled celočíselných datových typů Typ ShortInt Byte SmallInt Integer
Rozsah hodnot -128 ... 127 0 ... 255 -32 768 ... 32 767
LongInt
-2 147 483 648... 2 147 483 647
Formát 8 bitů se znaménkem 8 bitů bez znaménka 16 bitů se znaménkem podle prostředí 16 nebo 32 bitů se znaménkem 32 bitů se znaménkem
Znakový datový typ Char Datový typ Char je výchozím typem pro práci se znaky. Do proměnné tohoto typu je možné uložit jeden libovolný znak, který se ve zdrojovém kódu ohraničuje apostrofy (‘). Je-li v programu napsáno 5, znamená to „konstanta s číselnou hodnotou pět“. Je-li v programu napsáno ’5’, znamená to „konstanta pro znak pětky“. Jednotlivé hodnoty typu Char jsou v počítači ukládány pomocí kódu, tj. každému znaku je přiřazeno konkrétní číslo (vychází z ASCII tabulky). Díky tomu lze mezi sebou jednotlivé hodnoty typu Char porovnávat (menší znak má menší číslo v ASCII tabulce). Ukázka uspořádání číslic a písmen anglické abecedy:
’0’ < ’1 ’< ’2’< ... < ’9’ < ’A’ < ’B’ < ... < ’Z’ < ’a’ < ’b’ < ...< ’z’
Typ Boolean Booleovský typ reprezentuje pouze dvě hodnoty – pravda (true) a nepravda (false). Pravda je reprezentovaná hodnotou jedna (1) a nepravda hodnotou nula (0). Výčtový typ Tento typ si definuje každý uživatel sám podle svých potřeb, a to buď vyjmenováním všech hodnot, jakých může proměnná nabývat, nebo pomocí intervalu. Definice může vypadat následovně: var rocniObdobi : (jaro, leto, podzim, zima); var nabytek : (zidle, skrin, postel, stul); var pocetStenat : 0..12; var cislice : 0..9; Při definici výčtového typu vyjmenováním všech hodnot nelze použít jako hodnoty číslice či znaky (např. ’A’). Musí se definovat vlastní prvky pomocí platných identifikátorů (hodnota zde vystupuje jako konstanta, tedy identifikátor). Při definici pomocí intervalu musí být tento interval ordinálního typu. Interval musí být spojitý, to znamená, že nemůže být složen např. ze dvou různých intervalů. Jednotlivým prvkům tohoto typu jsou přiřazeny hodnoty od nuly, tedy: Ord (jaro) = 0 Ord (leto) = 1 Ord (podzim) = 2 Ord (zima) = 3
// význam Ord bude vysvětlen vyučujícím
9
1.7.2 Datové typy reálných čísel Provádění nejrůznějších operací nad reálnými čísly je při programování velmi častým jevem. K tomu účelu Object Pascal nabízí hned několik datových typů reálných čísel. Tak jako celočíselné datové typy se i tyto datové typy liší svým rozsahem hodnot a nároky na místo v paměti. Přehled datových typů pro reálná čísla Typ Real Single Double Extended
Rozsah hodnot 5,0x10-324 .. 1,7x10308 1,5x10-45 .. 3,4x1038 5,0x10-324 .. 1,7x10308 3,6x10-4951 .. 1,1x104932
Počet bytů v závislosti na platformě 4 8 10
1.7.3 Datové typy řetězců Řetězcové datové typy se používají k uchovávání celých znakových řetězců, tj. řetězců, které jsou složeny z konečného počtu jednotlivých znaků (Char). Pro krátké řetězce se používá datový typ String, kde je délka řetězce omezena na 255 znaků. Více o výčtových a strukturovaných typech později.
1.8
Proměnné, konstanty a jejich deklarace
Pojem proměnná je v programování chápán jako symbolické označení (jméno) pro určitou oblast paměti, ve které jsou uložena data daného typu. Hodnoty proměnných mohou být za chodu programu měněny. Každá použitá proměnná musí být nejprve nadeklarována v bloku deklarací tak, že se za klíčové slovo var uvede jméno proměnné, dvojtečka a její datový typ. Konstanty se od proměnných liší tím, že jejich hodnotu nelze za chodu programu měnit. Konstanty se deklarují pomocí klíčového slova const.
Obecná deklarace proměnné:
var
název_proměnné(identifikátor): typ;
►Příklad deklarace proměnných:
var
Cislo, Soucet2: integer; Znak: char;
Obecná deklarace konstanty:
const název_konstanty(identifikátor) = hodnota;
►Příklad deklarace konstant:
const Dny_v_tydnu = 7; PrvniDen = ‘pondělí’;
Výpis proměnných a konstant na obrazovku (tj. na standardní výstup) se provádí pomocí příkazů výstupu write a writeln tak, že se jako parametr uvede identifikátor proměnné. V mnoha případech je třeba výstupní parametr naformátovat do požadovaného tvaru, tj. číselná hodnota se například bude vypisovat na předem daný počet znaků.
10
Formátování celého čísla writeln (parametr:N); číslo, které je formátováno
počet znaků výstupní hodnoty
►Příklad formátovaného výstupu celočíselných parametrů: writeln (’Obvod obdélníka je:’, vysledek:5); Na obrazovku se vypíše text „Obvod obdélníka je:“, za kterým bude uvedena hodnota proměnné výsledek. Tato hodnota bude zobrazena na pět míst.
Formátování reálného čísla writeln (parametr:N:D); číslo, které je formátováno
celkový počet znaků výstupní hodnoty
počet znaků na desetinných místech
►Příklad formátovaného výstupu reálných parametrů: writeln (’Obvod kruhu je:’, vysledek:7:3); Na obrazovku se vypíše text „Obvod kruhu je:“, za kterým bude uvedena hodnota proměnné výsledek. Tato hodnota bude zobrazena celkem na 7 míst, z nichž 3 místa budou vyhrazena pro desetinnou část.
1.9
Výrazy
Výraz je předpis pro získání hodnoty, který je tvořen z operandů, operátorů a okrouhlých závorek. − − − −
operandy jsou číslice, číselné proměnné, číselné konstanty operátory jsou +, -, *, / a další výraz uzavřený v závorkách bude vyhodnocován jako první násobení a dělení je vyhodnoceno dříve než sčítání a odčítání (není-li závorkami stanoveno jinak)
11
►Příklad správně vytvořeného výrazu – PI v tomto příkladě vystupuje jako konstanta. Operandy
(3 + 6) * 8 / PI Operátory * * * Procvičení:
Všechny programy opatřete poznámkou, ve které bude uvedeno jméno programu a k jakým výpočtům je určen. ■ (05) Rozšíření předchozího příkladu (04). Napište program, který na obrazovku vypíše obvod a obsah obdélníka, jehož strany mají velikost: a = 5 cm, b = 7 cm. (Program vypíše informaci o tom, co bude počítat, rozměry obdélníka a na samostatných řádcích bude vypsán obsah a obvod. Řešte s použitím konstant.) ■ (06) Vytvořte program, který na obrazovku vypíše obvod a obsah kruhu, jehož poloměr je 15 cm. (Program vypíše informaci o tom, co bude počítat, velikost poloměru a na samostatných řádcích bude vypsán obsah a obvod. Řešte s použitím konstant.) ■ (07) Rozšiřte předchozí příklad (06) o formátování výstupu. Výsledek bude vypsán na 9 míst, z nichž 3 místa budou vymezena pro desetinnou část.
1.10 Přiřazovací příkaz Jde o nejzákladnější a nejčastěji používaný příkaz, jehož prostřednictvím se mění hodnota proměnné. Přiřazovací příkaz má tvar:
proměnná := výraz
►Příklad přiřazovacího příkazu: Cislo_1 := 5; Cislo_2 := 66; SoucetCisel := Cislo_1 + Cislo_2; Postup zpracování přiřazovacího příkazu: 1. Určí se cíl přiřazení (proměnná na levé straně). 2. Vyhodnotí se výraz na pravé straně. 3. Získaná hodnota se uloží do stanovené cílové proměnné.
12
1.11 Příkaz vstupu Každý program potřebuje odněkud získávat informace, které bude zpracovávat, případně přijímat pokyny ovlivňující jeho další činnost. K tomuto účelu slouží vstup. Pro standardní vstup neboli načítání údajů z klávesnice slouží příkaz
Readln (seznam_proměnných);
Readln (p1, p2,...);
Seznam_proměnných je seznam identifikátorů proměnných, jejichž hodnoty mají být načteny, identifikátory jsou odděleny čárkami. ►Příklad vstupu z klávesnice Readln (Cislo_1); Bude-li na klávesnici jako vstup zadána např. hodnota „45“, bude mít po provedení uvedeného příkazu proměnná Cislo_1 hodnotu 45. Readln (Cislo_2, Cislo_3); Bude-li na klávesnici jako vstup zadáno např. „454 6“, bude mít po provedení uvedeného příkazu proměnná Cislo_2 hodnotu 454 a proměnná Cislo_3 hodnotu 6. Poznámka: Všimněte si zápisu vstupu, pro oddělení hodnot proměnných se využívá mezera.
* * * Procvičení:
Všechny programy opatřete poznámkou, ve které bude uvedeno jméno programu a k jakým výpočtům je určen. ■ (08) Napište program, který vyzve uživatele k zadání dvou celých čísel a vypíše na obrazovku jejich součet. ■ (09) Upravte program (05) na výpočet obvodu a obsahu obdélníka tak, aby hodnoty pro výpočet byly zadány uživatelem (datový typ proměnných si zvolte libovolně). ■ (10) Upravte program (07) na výpočet obvodu a obsahu kruhu tak, aby hodnota π vystupovala ve zdrojovém kódu jako konstanta a velikost poloměru byla zadávána uživatelem. ■ (11) Napište program, který převede zadanou hodnotu v metrech na kilometry, decimetry, centimetry a milimetry. Program vypíše všechny převody.
■ (12) Přizpůsobte předešlý program (11) na převod čtverečních jednotek. Program bude převádět čtverečné metry na decimetry čtverečné, centimetry čtverečné a milimetry čtverečné.
13
■ (13) Vytvořte program na převod české měny do zahraniční. Uživatel zadá částku v českých korunách a kurz a program na obrazovku vypíše částku v cílové měně. ■ (14) Napište program, který vypočítá váš index tělesné hmotnosti (BMI). Program vyzve uživatele k zadání vstupních hodnot – výška postavy v metrech a tělesnou hmotnost v kilogramech. BMI se vypočítá jako podíl tělesné hmotnosti a druhé mocniny výšky postavy v metrech. Program zároveň vypíše tabulku s jednotlivými kategoriemi BMI (hodnoty BMI pro podváhu, průměr a nadváhu). ■ (15) Vytvořte program, který spočítá konečný zůstatek na vašem spořicím účtu. Uživatel zadá výši vkladu, dobu spoření (v měsících) a úrok u spořicího učtu (p.a.). (Předpokládejte, že se každý měsíc připisuje úrok pouze z původního vkladu a neuvažujte daň z úroku.) * * *
Samostatná práce k první části Máte před sebou dva měsíce letních prázdnin. Doma v kasičce se objevilo nečekaně velké množství peněz, a proto jste se rozhodli, že letošní dovolená bude trochu neobvyklá. Poletíte na dovolenou se svými kamarády a vyberete si kam. 1) Prázdniny: Rozmyslete si, kam byste se v létě chtěli podívat, a napište program, který na obrazovku vypíše text: „O prázdninách poletím... [doplňte]“. 2) Cena letenky: Společnost, se kterou chcete letět, uvádí zvlášť ceny letenky a zvlášť veškeré letištní poplatky. Napište program, který spočítá celkovou cenu, již za let budete muset zaplatit (tj. uživatel do programu vždy zadá cenu letenky a cenu letištních poplatků, ceny uvažujeme pouze v celých číslech). 3) Počet cestujících: Některým vašim kamarádům je více než 24 let, a cena jejich letenky je proto odlišná. Napište program, který spočítá celkovou částku, kterou budete muset za cenu letenek zaplatit (tj. uživatel do programu vždy zadá počet studentů do 24 let, počet dospělých, cenu letenky pro studenta, cenu letenky pro dospělého a letištní poplatky). 4) Zpáteční let: V internetových vyhledávačích spojení uživatel vždy vyplňuje políčka „Odkud“ a „Kam“. Většina z nich disponuje i funkcí, která umožňuje hodnoty vyměnit. Napište program, který prohodí jednotlivé proměnné (tj. uživatel zadá proměnnou „Odkud“ a proměnnou „Kam“ a program vypíše zpáteční let tak, že prohodí obsah proměnných). 5) Vstupenky: Jedním z míst, kam se během svých prázdnin dostanete, je Paříž. Stejně jako na většinu památek je i na Eiffelovu věž rozdílné vstupné pro studenty a pro dospělé. Napište program, který spočítá celkovou cenu, již musíte za vstup zaplatit (tj. uživatel vypíše počet studentů, počet dospělých, cenu vstupenky pro studenta a cenu vstupenky pro dospělého). 6) Zmrzlina: Přímo pod Eiffelovou věží prodávají zmrzlinu. Návštěvníci si mohou vybrat, zda si koupí zmrzlinu točenou nebo kopečkovou, jejich cena není stejná. Napište program, který spočítá celkovou cenu, již zaplatíte za kopečkovou zmrzlinu, a celkovou cenu zmrzliny točené (tj. uživatel vypíše cenu točené zmrzliny, cenu kopečku a jejich celkové počty).
14
2. Oddíl II. Řízení chodu programu Tento blok se bude věnovat základním programovacím strukturám, které se používají pro řízení chodu programu. Jsou to struktury, které se běžně používají při programování i těch nejjednodušších programů a se kterými se můžete setkat téměř ve všech programovacích jazycích. Jde především o větvení programu pomocí podmínek a opakované provádění příkazů pomocí cyklů.
2.1
Větvení programu
Velmi často je zapotřebí provést některou část kódu pouze v případě, že jsou splněny určité podmínky. K těmto účelům slouží podmíněný příkaz, který je buď neúplný, nebo úplný.
2.1.1 Neúplný podmíněný příkaz
if podmínka then příkaz;
Zpracování příkazu začne vyhodnocením podmínky. Je-li podmínka splněna, provede se příkaz (skupina příkazů), v opačném případě se neprovede žádná operace a program pokračuje. ►Příklad: if Cislo<0 then Cislo := -Cislo; Uvedený příklad se vyhodnotí takto: zjistí se, je-li hodnota v proměnné Cislo menší než nula. Je-li to pravda (tj. jde o záporné číslo), provede se příkaz za klíčovým slovem then, který změní záporné číslo na kladné. Není-li to pravda (tj. jde o kladné číslo), příkaz za klíčovým slovem then se neprovede. Po průchodu programu touto podmínkou je hodnota v proměnné Cislo vždy kladné číslo. Má-li se při splnění podmínky provést více příkazů, musejí být tyto příkazy napsány mezi klíčovými slovy begin a end. if podmínka then begin příkaz_1; příkaz_2; M příkaz_n; end;
15
2.1.2 Úplný podmíněný příkaz
if podmínka then příkaz1; else příkaz2;
Úplný podmíněný příkaz definuje i to, co se má stát, je-li podmínka nesplněna. Má-li se v každé větvi provést více příkazů, musejí být tyto příkazy opět ohraničeny klíčovými slovy begin a end. Zpracování příkazu začne rovněž vyhodnocením podmínky. Je-li podmínka splněna, provede se příkaz1 (skupina příkazů), v opačném případě se provede příkaz2 (skupina příkazů). Před klíčovým slovem else se nepíše středník, tento znak patří až na konec celého podmíněného příkazu. Podmíněné příkazy lze do sebe vnořovat.
if podmínka1 then begin if podmínka2 then příkaz1 else příkaz2 end
Rozdělit program najednou do více větví je možné pomocí několika podmíněných příkazů If, kdy každý tento příkaz představuje jednu větev. Pro rozvětvení programu do více větví (tj. 3 a více) je vhodnější použít speciální druh podmíněného příkazu Case, který má obecný tvar:
case výraz of hodnoty_1: příkaz_1 hodnoty_2: příkaz_2 M hodnoty_n: příkaz_n end
16
Výraz mezi klíčovými slovy case a of může být libovolný výraz ordinálního typu. (Většinou se používá jednoduchá proměnná.) Hodnoty_1, hodnoty_2, ... , hodnoty_n v levé části jsou navzájem disjunktní hodnoty (nebo intervaly), kterých může výraz po vyhodnocení nabývat. V pravé části za dvojtečkou jsou příkazy (příkaz_1, příkaz_2, ... , příkaz_n), jež se v závislosti na hodnotě výrazu provádějí. Zpracování příkazu spočívá ve vyhodnocení výrazu. Následně se v levé části najde větev, která má stejnou hodnotu jako vyhodnocený výraz, a provede se příslušný příkaz za dvojtečkou. Vždy se provede jen jedna větev. Příkaz case lze rozšířit o nepovinnou větev else, která se provede v případě, že se vyhodnocený výraz nerovná žádné hodnotě uvedené vlevo od dvojtečky. Není-li větev else uvedena a hodnota výrazu je různá od všech „nabízených“ hodnot, je příkaz case ekvivalentní prázdnému příkazu. ►Příklad: case cislo_dne of 7,12: write('Šťastné dny v měsíci.'); 13: write('Špatné dny v měsíci.'); 1..6: write('Neutrální dny v měsíci.'); else write('N/A'); end; V uvedeném příkladu je proměnná cislo_dne ordinálního typu integer. Zpracování proběhne tak, že se porovná hodnota v proměnné cislo_dne s hodnotami uvedenými v levé části. − je-li hodnota proměnné 7 nebo 12, vypíše se na obrazovku text „Šťastné dny v měsíci.“ − je-li hodnota proměnné 13, vypíše se na obrazovku text „Špatné dny v měsíci.“ − je-li hodnota proměnné v intervalu 1 až 6 (psáno 1..6), vypíše se na obrazovku text „Neutrální dny v měsíci.“ − je-li hodnota proměnné jiná než 1..6, 7, 12, 13, vypíše se na obrazovku text „N/A“ Poznámka: − proměnná mezi klíčovými slovy case a of musí být ordinálního typu (tj. celočíselný datový typ, znakový typ Char, booleovský datový typ nebo datový typ výčtový) − hodnoty v levé části musí být disjunktní
2.1.3 Relační operátory Pomocí relačních operátorů lze porovnávat jak hodnoty číselné, tak i hodnoty jiné (podrobné vysvětlení bude uvedeno později). A=B A <> B A
A je rovno B A není rovno B A je menší než B
A<=B A>B A>=B
A je menší rovno B A je větší B A je větší rovno B
Složitější výrazy lze vytvářet pomocí pravdivostních operací, které vycházejí z matematické logiky. Negace se značí klíčovým slovem not, konjunkce neboli logický součin se značí klíčovým slovem and a pro disjunkci neboli logický součet se používá or. 17
Logické operace P True True False False
Q True False True False
not P False False True True
P and Q True False False False
P or Q True True True False
2.1.4 Volba náhodných čísel Většina programovacích jazyků umožňuje provést náhodný výběr prvku z dané množiny, čehož se často využívá například při programování her nebo při testování a ladění programů. Object Pascal náhodný výběr umožňuje také, a to pomocí spuštění generátoru náhodných čísel randomize a funkce random. Funkce random se používá k náhodnému výběru (volbě) přirozeného čísla, kdy se jako parametr do závorek uvádí horní mez, která je vždy o jedna menší než zadané číslo v závorce. Například pro náhodný výběr čísla od jedné do dvaceti se jako parametr uvede číslo 21 tj. random(21). Dále je možné funkci random použít k náhodnému výběru desetinného čísla v intervalu 0 ≤ x < 1. V takovém případě se neuvádí parametr, tj. random. Aby bylo možné s náhodně zvoleným číslem dále pracovat, je třeba je uložit do proměnné.
nahodneCislo := random(10);
Kdyby byla v programu použita pouze funkce random, generoval by program při spuštění vždy tatáž čísla. Aby byl výběr při každém spuštění programu jiný, musí se do příkazové části zdrojového kódu (tj. mezi begin a end) zápisem randomize spustit generátor náhodných čísel.
►Příklady volby náhodného čísla: begin randomize; x:= random(10); y:= 1 + random(10); z:= 100 * random; end.
// spuštění generátoru náhodných čísel // náhodný výběr čísla od 0 do 9 // náhodný výběr čísla od 1 do 10 // náhodný výběr reálného čísla v intervalu 0 ≤ x < 100 * * *
Procvičení:
Všechny programy opatřete poznámkou, ve které bude uvedeno jméno programu a k jakým výpočtům je určen. ■ (16) Napište program, který vyzve uživatele k zadání dvou celých (reálných) čísel a zadaná čísla porovná. Výsledek vypíše na obrazovku. 18
■ (17) Vytvořte program, který rozhodne, zda číslo zadané uživatelem bylo liché, nebo sudé. (Použijte operaci mod – vrací celočíselný zbytek po dělení. Syntaxi vyhledejte pomocí nápovědy F1 nebo v referenčních příručkách jazyka Object Pascal.) ■ (18) Napište program, který uživatele vyzve k zadání tří celých (reálných) čísel, zadaná čísla porovná a vypíše největší z nich. ■ (19) Vytvořte program, který převede zadanou hodnotu v metrech na jinou jednotku délky. Uživatel si sám vybere, zda chce provést převod na kilometry, decimetry, centimetry či milimetry. Jako základ můžete použít předchozí příklad (11). ■ (20) Upravte program (14) na výpočet BMI tak, aby nevypisoval celou tabulku s jednotlivými kategoriemi BMI, ale jen jednu kategorii, která odpovídá výsledné hodnotě BMI uživatele. ■ (21) Vytvořte program, do něhož uživatel zadá tři libovolná čísla, a program je poté sečtěte. Dále určí, zda je součet zároveň dělitelný šesti i devíti. ■ (22) Vytvořte program, který vyzve uživatele k zadání libovolného znaku z klávesnice. Program poté vypíše na obrazovku, zda se jedná o číslici (0-9), malé písmeno, velké písmeno nebo jiný znak. ■ (23) Naprogramujte program, který vypočítá cenu za jízdu taxíkem. Uživatel zadá vzdálenost (může být i desetinné místo), jakou taxíkem urazil, a program mu podle sazby vypočítá cenu, kterou má zaplatit. Neuvažujeme nástupní taxu. Sazba za jízdu je: 0 – 14 km 40 Kč/km 15 – 34 km 36 Kč/km 35 – 59 km 32 Kč/km 60 a více 25 Kč/km Poznámka: Je-li zadaná vzdálenost 14,8 km, sazba je stále 40 Kč/km. Řešte pomocí příkazu case a použijte funkci trunc(r), která vrací celou část reálného čísla. Použití této funkce nastudujte z nápovědy F1 nebo v referenčních příručkách jazyka Object Pascal. ■ (24) Vytvořte program, který uživatele vyzve k zadání tří libovolných čísel, tato čísla pak seřadí podle velikosti a ve správném pořadí vypíše na obrazovku.
2.2
Cykly
Opakované provádění příkazů je v programování velice častým jevem, a proto je nezbytné se s touto problematikou seznámit. Zjednodušeně by se dalo říci, že se používají dva základní druhy cyklů – cyklus řízený podmínkou a cyklus s pevně daným počtem opakování. Cykly řízené podmínkou Object Pascal nabízí dvě různé konstrukce cyklů, jež jsou řízeny podmínkou. Prvním z nich je cyklus s příkazem While, který má podmínku na začátku, druhým je cyklus s příkazem Repeat s podmínkou na konci.
19
Cyklus s podmínkou na začátku
Cyklus s podmínkou na konci
2.2.1 Cyklus s příkazem While Cyklus s příkazem while má následující tvar:
while podmínka do příkaz
(tento příkaz se nazývá tělo cyklu)
Význam cyklu s příkazem while by bylo možné zapsat následovně: „dokud platí podmínka, opakuj příkaz“. Zpracování cyklu probíhá takto: 1. vyhodnotí se podmínka 2. jestliže podmínka neplatí (není pravda), cyklus se ukončí a program pokračuje příkazem, který následuje za tělem cyklu 3. jestliže podmínka platí (je pravda), provede se tělo cyklu 4. provádění programu se vrátí k bodu 1 (opakuje se celý postup) Je-li tělo cyklu tvořeno více než jedním příkazem, musejí být tyto příkazy ohraničeny klíčovými slovy begin a end. Poznámka: Zpracování While-cyklu začíná vyhodnocením podmínky. Není-li tato podmínka splněna hned na začátku, tělo cyklu se neprovede ani jednou. Celý cyklus se ukončí a program pokračuje příkazem, který následuje za tělem cyklu. Tento příkaz používáme tehdy, neznáme-li předem přesný počet opakování potřebných k dosažení cílového stavu. Ukončení je reprezentováno splněním dané podmínky.
20
Poznámka: Dávejte pozor na to, aby vaše podmínka mohla někdy nabýt hodnoty nepravda. V opačném případě by se cyklus prováděl do nekonečna (tzv. nekonečný cyklus) a program by nikdy nemohl skončit. V takovém případě se program ukončuje násilným zásahem zvenku. ►Ukázkový příklad cyklu s příkazem While: Zadání: Program vyzve uživatele k zadání přirozeného čísla n. Poté vypíše čísla od 1 do n, každé na nový řádek. (Předpokládáme, že uživatel nezadá jiné číslo než přirozené.) program While_1; {$APPTYPE CONSOLE} uses SysUtils; var n,i:integer;
// název programu
//deklarace proměnných
begin write('Zadej pocet vypisovanych cisel: '); readln(n); i:=0;
// vyzve uživatele k zadání čísla // načtení čísla do proměnné n // proměnná i je nastavena na hodnotu nula
while i
// začátek cyklu ... podmínka zní: jestliže i je menší než n, proveď tělo cyklu. Mezi klíčovými slovy begin/end je tělo cyklu. Při jednom průchodu tělem se zvýší hodnota i o jedničku a vypíše se jeho hodnota.
readln; end.
2.2.2 Cyklus s příkazem Repeat Cyklus s příkazem Repeat má následující tvar: repeat příkaz_1 příkaz_2 M příkaz_n until podmínka
Význam tohoto cyklu by bylo možné vyjádřit takto: „opakuj příkazy, dokud nezačne platit podmínka“. Zpracování cyklu probíhá následovně: 1. provedou se příkazy v těle cyklu 2. poté se vyhodnotí podmínka 3. jestliže je podmínka neplatná (není pravda), opakuje se postup od bodu 1 4. je-li podmínka splněna (pravda), cyklus se ukončí a program pokračuje prvním příkazem za cyklem 21
Poznámka: Cyklus Repeat (s podmínkou na konci) začíná provedením příkazů, které tvoří tělo cyklu. Z toho vyplývá, že se tělo cyklu provede alespoň jednou, což u cyklu s podmínkou na začátku neplatí. Pomůcka:
while „Máš hlad?“ do „Tak jez.“
repeat „Najez se.“ until „Jsi syt?“
Jednotlivé cykly lze vzájemně zaměňovat. To znamená, že je zpravidla jedno, použije-li se cyklus While nebo Repeat. V některých případech je však výhodnější použít jeden, v jiných zase druhý. Volba cyklu záleží na charakteru úlohy i na osobním vkusu programátora. ►Ukázkový příklad cyklu s příkazem Repeat: Cykly s podmínkou na začátku a na konci je v mnoha případech možné vzájemně zaměňovat, proto je pro ukázkový příklad cyklu s příkazem Repeat použito stejné zadání jako pro cyklus s příkazem While. Zadání: Program vyzve uživatele k zadání přirozeného čísla n. Poté vypíše čísla od 1 do n, každé na nový řádek. (Předpokládáme, že uživatel nezadá jiné číslo než přirozené.) program Repeat_1; {$APPTYPE CONSOLE} uses SysUtils; var n,i:integer;
// název programu
//deklarace proměnných
begin write('Zadej pocet vypisovanych cisel: '); readln(n); i:=0; repeat i:=i+1; writeln(i); until i=n;
readln; end.
// vyzve uživatele k zadání čísla // načtení čísla do proměnné n // proměnná i je nastavena na hodnotu nula //začátek cyklu ... nejprve se provedou příkazy (tělo cyklu) mezi klíčovými slovy repeat/until, tj. zvýší se hodnota proměnné i o jedničku a její hodnota se vypíše na obrazovku. Poté se vyhodnotí podmínka. Je-li podmínka pravdivá, cyklus se ukončí, v opačném případě se tělo cyklu provede znovu.
* * * Procvičení:
Všechny programy opatřete poznámkou, ve které bude uvedeno jméno programu a k jakým výpočtům je určen.
■ (25) Program (19) má zásadní nedostatek v tom, že zadá-li uživatel jiný znak, než je požadováno, převod se neprovede. Upravte proto program tak, aby vždy došlo k požadovanému převodu jednotek, tj. v případě, že uživatel zadá špatný znak, program vyčká na zadání znaku odpovídajícího.
22
■ (26) Naprogramujte hru na hádání čísla. Program náhodně vygeneruje číslo z intervalu 1..100, úkolem hráče je toto číslo uhodnout. Vytvořte hru tak, aby hádající věděl, zda je jeho tip větší nebo menší než hádané číslo. ■ (27) Upravte předchozí hru tak, aby měl hráč na uhodnutí čísla jen osm pokusů a aby měl přehled o tom, kolik pokusů mu ještě zbývá. V případě neúspěchu se na konci vypíše hledané číslo a informace, že hráč číslo neuhodl. ■ (28) Zdramatizujte hru hádání čísla tak, že tipne-li si hráč číslo o jedničku větší nebo menší, než je číslo hledané, program automaticky vygeneruje nové číslo a bude o tom hráče informovat. Počet pokusů omezte podle vlastního uvážení. Cyklus s pevně daným počtem opakování: Object Pascal nabízí pro cyklus s předem daným počtem opakování konstrukci s příkazem For.
2.2.3 Cyklus s příkazem For Cyklus s příkazem For má následující tvar:
for počítadlo := DolníMez to HorníMez do příkaz nebo for počítadlo := HorníMez downto DolníMez do příkaz
Počítadlo je proměnná ordinálního typu, při každém průchodu programu cyklem se mění její hodnota o jedničku. Je-li použit tvar s to, počítadlo se při průchodu o jedničku zvyšuje, je-li použit tvar s downto, počítadlo se při průchodu o jedničku snižuje. Cyklus končí v okamžiku, kdy počítadlo dosáhne stejné hodnoty, jako je krajní mez cyklu. Tento cyklus se používá tehdy, známe-li předem přesný počet průchodů. Je-li tělo cyklu tvořeno více než jedním příkazem, musejí být tyto příkazy ohraničeny klíčovými slovy begin a end. ► Ukázkový příklad cyklu s příkazem For: Pro demonstraci příkladu cyklu s příkazem For bude použito stejné zadání jako pro cyklus s příkazem While a Repeat. program For_1; {$APPTYPE CONSOLE} uses SysUtils; var n,i:integer;
23
begin write('Zadej pocet vypisovanych cisel: '); readln(n); for i:=1 to n do writeln(i);
//začátek cyklu //při každém průchodu cyklem se bude //provádět příkaz writeln(i)
readln; end.
* * * Procvičení:
Všechny programy opatřete poznámkou, ve které bude uvedeno jméno programu a k jakým výpočtům je určen. ■ (29) Vytvořte program, který na obrazovku počítače vypíše všechna sudá čísla z intervalu 1 < x < 30. Pro výpis použijte cyklus s příkazem For.
■ (30) Vytvořte program, jenž na obrazovku vypíše tabulku druhých mocnin čísel od 1 do 20. ■ (31) Napište program, jehož výstup na obrazovce bude vypadat takto: 1 2 3 4 5 6
6 5 4 3 2 1
Počet čísel ve sloupcích bude zadán uživatelem.
■ (32) Vytvořte program, který na obrazovku vypíše pyramidu ze znaku „*“ tak, aby byl vrchol pyramidy přibližně šest řádků od horního okraje obrazovky a aby byl horizontálně zarovnán doprostřed okna. Počet vypisovaných řádků pyramidy si uživatel určí sám. (Předpokládejme, že uživatel zadá nejvíce 30 řádků.) Pyramida na šest řádků bude vypadat takto: * * * * * * * * * * * * * * * * * * * * * ■ (33) Upravte předchozí příklad (32) s pyramidou tak, aby se pyramida vypsala převráceně, tj. vrcholem dolů. Převrácená pyramida na šest řádků bude vypadat takto. * * * * * * * * * * * * * * * * * * * * *
24
■ (34) Představte si posloupnost přirozených čísel, ve které se každá číslice opakuje tolikrát, jaká je její hodnota, tj. 1,2,2,3,3,3,4,4,4,4, atd. (posloupnost je vzestupná). Vytvořte program, který bude umět určit číslici na libovolné pozici posloupnosti. Pozici posloupnosti bude opakovaně zadávat uživatel. Pro ukončení programu uživatel zadá nulu. ■ (35) Rozšiřte jeden z předchozích příkladů s pyramidou tak, aby si uživatel sám zvolil znak, ze kterého bude pyramida postavena. ■ (36) Vytvořte program na výpočet zůstatku na spořicím účtu. Uživatel zadá částku, kterou chce na spořicí učet vložit, úrok spořicího účtu (p.a.) a délku spoření v měsících. Úrok se bude na účet připisovat každý měsíc z aktuálního zůstatku na účtu. Program bude brát v úvahu i patnáctiprocentní daň z úroku.
25
3. Oddíl III – Pole a řetězec Tento blok se bude věnovat základnímu strukturovanému datovému typu pole, který se objevuje téměř ve všech programovacích jazycích. Datový typ pole lze rozdělit na pole statická a dynamická, případně na pole jednorozměrná a vícerozměrná. Problematika polí je značně rozsáhlá, tento blok se proto bude věnovat jen jednomu typu, a to poli statickému jednorozměrnému. Dále se tento blok bude věnovat datovému typu String, ke kterému lze přistupovat obdobně jako k datovému typu pole.
3.1
Statické jednorozměrné pole a příkaz Array
Strukturovaný datový typ pole umožňuje snadně zpracovávat skupinu souvisejících dat. Pod pojmem statické jednorozměrné pole je možné si představit konečnou skupinu prvků stejného datového typu (tj. všechny prvky pole mají stejný typ, např. integer nebo char). Počet prvků pole je dán při deklaraci a za běhu programu jej nelze měnit. Každý prvek (položka) pole je přímo přístupný a má své jedinečné označení, tzv. index. Ordinální hodnota indexu následujícího prvku je vždy o jedničku větší než ordinální hodnota prvku výchozího. Při práci s poli se velmi často využívá cyklu s příkazem For. Datový typ pole se v Object Pascalu definuje pomocí klíčového slova array:
array[typ_indexu] of typ_položky − typ_indexu je libovolný ordinální typ, který stanoví, jak budou prvky pole indexovány a kolik jich bude. Zpravidla bývá používán interval datového typu Integer − typ_položky je libovolný datový typ, který určuje, jaký typ budou mít jednotlivé prvky pole
Deklaraci pole v Object Pascalu je možné provést v zásadě dvěma způsoby. Pro účely tohoto studijního materiálu postačí, bude-li předvedena deklarace typu pole, v němž bude pomocí klíčového slova type vytvořen (nadefinován) datový typ pole a za klíčovým slovem var nadeklarován potřebný počet proměnných toho typu. Tato deklarace vypadá následovně: Obecně: type název_pole = array[typ_indexu] of typ_položky var název_proměnné_pole(identifikátor):typ_pole; − název_pole je identifikátor, který slouží k identifikaci pole a přístupu k němu
26
►Příklady deklarací polí: type poleDny = array [1..7] of string; poleMesice = array [1..12] of string; var dny : poleDny; mesice : poleMesice; Výše uvedený příklad ukazuje deklaraci strukturovaného datového typu pole. Za klíčovým slovem type jsou vytvořena dvě pole. První typ pole s názvem poleDny má sedm prvků typu String (řetězec), typ_indexu je od jedné do sedmi. Dvanáct prvků druhého typu pole poleMesic má stejný datový typ String (řetězec), prvky jsou indexovány od jedné do dvanácti. Za klíčovým slovem var jsou vytvořeny dvě proměnné těchto polí. Proměnná dny má sedm prvků, proměnná mesice má prvků dvanáct. Poznámka: Budeme-li ve zdrojovém kódu pracovat s poli, použijeme pro ně proměnné typu pole. V tomto případě proměnné – dny, mesice (práce s poli bude upřesněna níže). Další způsoby deklarace polí pomocí klíčového slova type. Příklady jsou uvedeny bez deklarace proměnných za klíčovým slovem var.
type poleCisel = array [1..20] of real;
Deklarace typu pole s názvem poleCisel, které má dvacet prvků typu Real, jež jsou indexovány od jedné do dvaceti.
const min=1; max=20; type poleCisel = array [min..max] of integer;
Typ_indexu může obsahovat i konstanty, jako je tomu v tomto příkladě. Důležité je, aby byly konstanty vytvořeny před samotnou deklarací pole.
const min=1998; max=2008; type poleCisel = array [min..max] of integer;
Typ_indexu nemusí vždy začínat (být indexován) od jedničky. Je možné použít jiné indexování, viz výše uvedený příklad.
type poleZnaku = array [1..10] of char;
Zde je uveden příklad deklarace pole znaků, které má deset prvků typu Char a typ_indexu je od jedné do deseti.
27
3.1.1 Přístup k prvkům pole K jednotlivým položkám pole lze přistupovat (číst nebo měnit jejich hodnotu) tak, že se ve zdrojovém kódu nejprve uvede identifikátor (název) proměnné daného typu pole, za který se do hranatých závorek přidá index požadované položky. Při přístupu k položkám pole nesmí index v hranatých závorkách překročit (přetéct) meze indexu pole. Jinými slovy, index nesmí odkazovat mimo pole.
3.1.2 Plnění polí Ukážeme si dva způsoby, jimiž je možné pole naplnit. První způsob je ten, že programátor hodnoty jednotlivých složek pole vyplní ve zdrojovém kódu. Tento způsob se v programátorské praxi zpravidla nepoužívá. Jeho využití je omezeno především pro účely výuky práce s poli. Druhý způsob je dynamický, tj. pole se naplní teprve při běhu programu. Hodnoty jednotlivých položek může program získat různými způsoby: jsou zadány uživatelem, program je náhodně vygeneruje nebo načte z externího souboru apod. ►Příklady plnění pole: Vytvoříme pole poleDny, které bude mít sedm prvků (složek) typu String. Prvky pole budou obsahovat jednotlivé dny v týdnu, viz obr.:
První způsob – pole naplní programátor ve zdrojovém kódu type poleDny = array [1..7] of string; var dny : poleDny; begin dny[1]:= 'Pondělí'; dny[2]:= 'Úterý'; dny[3]:= 'Středa'; dny[4]:= 'Čtvrtek'; dny[5]:= 'Pátek'; dny[6]:= 'Sobota'; dny[7]:= 'Neděle'; // v tomto okamžiku je pole naplněno a můžeme s jeho daty pracovat readln; end;
28
Druhý způsob – pole naplní uživatel poté, co jej program vyzve k zadání jednotlivých dnů type poleDny = array [1..7] of string; var dny : poleDny; i:integer; begin for i:= 1 to 7 do begin
end;
write('Zadej ',i,' den v tydnu: '); readln(dny[i]); // v tomto okamžiku je pole naplněno, následující příkaz For jednotlivé prvky pole vypíše na obrazovku
for i:= 1 to 7 do writeln(dny[i]); readln; end.
* * * Procvičení:
Všechny programy opatřete poznámkou, ve které bude uvedeno jméno programu a k jakým výpočtům je určen.
■ (37) Vytvořte jednoduchý program tak, že nadefinujete pole, které bude mít pět prvků, prvky budou mít datový typ Integer. Pole naplňte libovolnými hodnotami a poté je pomocí cyklu s příkazem For vypište na obrazovku do dvou řádků. V prvním řádku budou hodnoty jednotlivých složek pole vypsány v pořadí, v jakém jste je zadali, v druhém řádku budou tyto hodnoty vypsány v pořadí obráceném. ■ (38) Upravte předcházející program (37) tak, že hodnoty zadá uživatel. Podmínky pro výpis zůstávají nezměněny. ■ (39) Vytvořte program, který vygeneruje 15 náhodných čísel v intervalu 1 < x < 100. Tato čísla vypíše na obrazovku stejně jako v příkladu (37). ■ (40) Rozšiřte předcházející program o nalezení největšího a nejmenšího prvku. Oba prvky se vypíší na obrazovku.
29
3.2
String a práce s řetězcem
Datovému typu řetězce String byla pozornost věnována již výše. Nyní se zaměříme na jeho vlastnosti a způsob použití. Definice má tvar:
string[délka_řetězce]
Délka_řetězce udává maximální délku daného řetězce v intervalu od 1 do 255. Není-li délka_řetězce v definici za klíčovým slovem String uvedena, je délka řetězce automaticky nastavena na maximální velikost, tj. na velikost 255. Kratší řetězce se používají z důvodu úspory místa v operační paměti. ►Příklady deklarací řetězců: type
Str[50] = string [50];
// zde se zavádí typ Str[50] pro ukládání řetězců o délce max. 50 znaků var
jmeno: string [15]; prijmeni: string [20]; nadpis: string;
// zde jsou deklarovány proměnné jmeno (max. 15 znaků), prijmeni (max. 20 znaků) a nadpis (max. 255 znaků) Datový typ String má obdobné vlastnosti jako typ pole, tj. typ String[N] je reprezentován jako array [0..N] of Char. Na pozici s indexem nula je uložena informace o aktuální délce řetězce a samotný řetězec začíná na pozici s indexem jedna. K jednotlivým pozicím (položkám) je možné přistupovat obdobně, jako je tomu u pole, tj. pomocí indexu pozice uzavřeného v hranatých závorkách. Např. jmeno[1] je první znak řetězce uloženého v proměnné jmeno. Čtení a zápis řetězců Řetězce se čtou pomocí příkazů Read a Readln tak, že se přečtou všechny znaky na řádku a přiřadí se do dané proměnné typu String. Je-li počet znaků v řetězci (na řádku) delší než deklarovaná hodnota, např. 280 znaků, jsou přebývající znaky ignorovány a do proměnné se uloží jen max. nadeklarovaná délka. Je-li počet načítaných znaků menší než max. deklarovaná hodnota, načtou se jen tyto znaky. Pro výpis proměnné typu String se používají příkazy Write a Writeln, které vždy vypíší tolik znaků, jaká je aktuální délka řetězce.
30
3.2.1 Přehled příkazů a funkcí pro práci s řetězci V následující části je uveden přehled nejpoužívanějších operací, které lze s řetězci provádět. Pro více informací je možné použít nápovědu vývojového prostředí nebo dostupné referenční příručky jazyka Object Pascal.
Copy (řetězec, začátek, délka)
Funkce, která vrátí podřetězec z řetězce, jehož počet znaků je zadán hodnotou délka a začíná na pozici začátek. ►Příklad: Copy(‘ZakladniSkola’,4 ,5)
// vrátí podřetězec ‘ladni’
Length (řetězec)
Funkce, která vrací aktuální délku řetězce zadaného v závorkách. Výsledek je typu Integer. ►Příklad: delka := Length (‘ZakladniSkola’); delka := Length (jmeno);
// do proměnné délka vloží hodnotu 13 // do proměnné délka se vloží aktuální počet znaků řetězce jmeno
Delete (řetězec, odkud, delka )
Procedura, která vymaže z řetězce podřetězec s počátkem na pozici odkud, jehož počet znaků je dán hodnotou délka. ►Příklad: nadpis:= ‘Základní_škola‘; Delete (nadpis,3,6); // Výsledná hodnota se uloží do proměnné nadpis, jejíž hodnota je: nadpis =‘Zá_škola’
Concat (řetězec_1, řetězec_2, ... , řetězec_N)
Funkce spojující řetězce uvedené v závorce v jeden celek. Je-li délka zřetězeného řetězce větší než deklarovaná délka, je řetězec automaticky zakrácen na tuto délku. Výsledek má typ String.
31
►Příklad: cely_retezec := Concat(’Základní’,’_’,’Škola’) //Do proměnné cely_retezec typu String se vloží jeden řetězec, který vznikl sloučením tří menších řetězců. Výsledný řetězec je v tomto případě ’Základní_Škola’.
Pos (co, kde)
Funkce, která hledá pozici řetězce co v řetězci kde. Jako výsledek vrací odpovídající index prvního znaku hledaného řetězce v prvním výskytu v řetězci kde. ►Příklad: cislo := Pos (’Ško’,’Základní_Škola’); // Do proměnné cislo typu integer se v tomto případě uloží hodnota 10.
Insert (vkládaný_řetězec, do_řetězce, začátek)
Procedura, která vloží řetězec do jiného řetězce. Vkládaný_řetězec je řetězec, který bude přidán. Hodnota začátek udává pozici v řetězci do_řetězce, na kterou má být vkládaný_řetězec vložen. ►Příklad: nadpis := ’ZŠ_Svornosti’; Insert (’_náměstí’, nadpis, 3); // Výsledná hodnota ’ZŠ_náměstí_Svornosti’ je uložena v proměnné nadpis. Dalšími hojně používanými funkcemi jsou funkce, které převádějí znaky (Char) na jejich kódy (Ascii) a naopak. Object Pascal pro tento převod nabízí funkce: Ord(C), která převede hodnotu C typu Char na odpovídající kód typu Integer a Chr(I), jež je opakem Ord, tj. vrátí znak typu Char odpovídající hodnoty I.
* * * Procvičení:
Všechny programy opatřete poznámkou, ve které bude uvedeno jméno programu a k jakým výpočtům je určen. ■ (41) Napište program, který vyzve uživatele k zadání jeho jména. Program poté vypíše hlásky jeho jména v opačném pořadí (např. uživatel zadá Jan a na obrazovku se vypíše naJ).
32
■ (42) Vytvořte program, který bude na obrazovku vypisovat jen znaky na sudých pozicích daného řetězce, který bude zadán uživatelem (předpokládejte, že text zadaný uživatelem bude kratší než 255 znaků). Například uživatel zadá „Základní škola Brno“ a na obrazovku se vypíše „áldíšoaBn“). ■ (43) Napište program, který z textu zadaného uživatelem odstraní všechny číslice a na závěr vypíše, kolik číslic bylo z daného textu odstraněno. ■ ( 44 ) Rozšiřte předchozí program tak, že se číslice vypíší na konec zadaného textu. ■ (45) Vytvořte program, který bude zjišťovat četnost jednotlivých samohlásek v uživatelem zadaném textu (předpokládejte, že text zadaný uživatelem bude kratší než 255 znaků). Jednotlivé četnosti se budou vypisovat na obrazovku.
33
4. Oddíl IV – Podprogramy V současné době jsou vytvářené programy značně rozsáhlé, a vzhledem k tomu často i méně srozumitelné. Tento blok se proto bude věnovat problematice organizace zdrojového kódu pomocí rozčlenění do skupin spolupracujících jednotek, které se nazývají podprogramy. Toto členění je v programátorské praxi běžné a téměř každý programovací jazyk poskytuje nástroje, jimiž lze podprogramy vytvářet a pracovat s nimi. Použití podprogramů nepřináší jen zkrácení zdrojového kódu, ale také jednodušší ladění programu. Podprogramy umožňují snazší provádění změn a hlavně větší srozumitelnost zdrojového kódu. Podprogramy se používají především v případech, kdy je třeba určitou část programu provádět vícekrát. Z této části se vytvoří podprogram a v případě, že je třeba v hlavním programu provést kód podprogramu, daný podprogram se z potřebného místa jednoduše zavolá. Tento oddíl se bude věnovat dvěma základním druhům podprogramů, jimiž jsou procedury a funkce.
4.1
Procedury
Proceduru si lze zjednodušeně představit jako „samostatný“ program, který je součástí jiného programu. Struktura procedury je obdobná jako struktura programu, tj. obsahuje deklarační část a příkazovou část. V Object Pascalu se procedura definuje následovně: procedure jméno_procedury (definice_parametrů); // hlavička {deklarace – v této části se deklarují lokálně dostupné prvky procedury, které se budou později využívat. Jsou jimi konstanty (za klíčovým slovem const); proměnné (za klíčovým slovem var); typy (za klíčovým slovem type); další procedury a funkce.} begin {tělo procedury – je tvořeno posloupností příkazů} end; Definice procedury začíná hlavičkou s klíčovým slovem Procedure, za kterým následuje specifické jméno_procedury (identifikátor), pomocí kterého je možné s podprogramem dále pracovat. Následuje část definice_parametrů, která je však při zavádění procedury nepovinná. Významu parametrů bude pozornost věnována níže. Všechny prvky zavedené v části deklarace jsou dostupné pouze uvnitř dané procedury (podprogramu), a jsou proto označovány za lokální. Tyto prvky vznikají v době zavolání a poté, co procedura skončí, zanikají. Tělo procedury obsahuje stejně jako příkazová část v hlavním programu výkonné příkazy. Poznámka: Je dobrým zvykem každý podprogram okomentovat tak, aby bylo zřejmé, k jakým výpočtům je určen. Za klíčovým slovem end v definici podprogramu následuje středník „;“. Volání procedury Proceduru lze zavolat z hlavního programu nebo jiného podprogramu, a to tak, že se napíše jméno procedury a středník. (Volání procedury je ze syntaktického hlediska příkaz.)
34
►Příklad definice a volání procedury bez předání parametrů Jako praktickou ukázku definice procedury je použit příklad číslo (03), který na obrazovku vypisuje název a adresu školy. Je změněn tak, že samotný výpis provádí procedura s názvem vypis_adresu a hlavní program obsahuje jen volání této procedury. program Adresa_skoly; {$APPTYPE CONSOLE} uses SysUtils; // definice procedury s názvem vypis_adresu procedure vypis_adresu; {KOMENTÁŘ – výpis názvu a adresy školy, nepoužívají se parametry.} begin writeln('ZAKLADNI SKOLA BRNO VEDLEJSI'); writeln; writeln('adresa:'); writeln('Vedlejsi 10'); writeln('625 00 Brno'); end; // hlavní program begin vypis_adresu; readln; end.
// volání procedury
4.1.1 Procedury a parametry Procedury bez parametrů nekomunikují s okolím, tj. při zavolání vždy provádějí tutéž operaci se stejnými daty (nebereme zde v úvahu globální proměnné). Situaci si lze představit tak, že máme-li proceduru na výpočet obsahu obdélníka, jejíž zdrojový kód obsahuje rozměry tohoto rovinného útvaru jako konstanty, bude taková procedura vracet velikost obsahu jen jediného obdélníka. Takový přístup však není příliš praktický. Je třeba, aby byl podprogram schopen počítat obsah libovolného obdélníka. Toho docílíme využitím parametrů. Jejich pomocí předáme podprogramu vstupní data, v našem případě rozměry obdélníka. Parametry se definují v hlavičce podprogramu do okrouhlých závorek za jméno_procedury. Tyto parametry se nazývají „formální parametry“. Jejich cílem je stanovit, kolik bude mít daný podprogram parametrů a jakého budou typu. Jejich definice je do značné míry podobná deklaraci proměnných. Parametry nadefinujeme tak, že do okrouhlých závorek uvedeme seznam identifikátorů (tj. jmen parametrů), které jsou odděleny čárkami. Za tento seznam se uvede dvojtečka a jméno typu. ►Příklad definice hlavičky procedury s předáním parametrů jednoho typu procedure obsah_obdelnika(strA, strB: Real); Chceme-li nadefinovat parametry o více typech, provede se jejich definice tak, že se mezi seznamy jednotlivých typů napíše středník „;“.
35
►Příklad definice hlavičky procedury s předáním parametrů o více typech procedure vypocet_BMI (hmotnost: Integer ; vyska: Real);
Volání procedury s předáním parametrů Volání procedury s předáním parametrů se provádí tak, že se do programu napíše jméno_procedury a za něj se do okrouhlých závorek vepíší parametry, které se oddělují čárkami. Tyto parametry se nazývají „skutečné parametry“ a určují, s jakými hodnotami bude daný podprogram pracovat při tomto konkrétním volání. ►Příklady volání procedury s předáním parametrů (Níže uvedenými příklady lze volat procedury nadefinované v předešlé části.) obsah_obdelnika(5, 8); // parametry jsou pevně dané čísly 5 a 8 obsah_obdelnika(a, b); // a, b jsou skutečné parametry stejného typu, jako jsou formální parametry v hlavičce definice vypocet_BMI(m, v); // m je skutečný parametr typu Integer a skutečný parametr v je typu Real
►Příklad definice a volání procedury s předáním parametrů Pro praktickou ukázku definice procedury s předáním parametru je použita problematika výpočtu obsahu obdélníka. Výpočet obsahu bude proveden tělem procedury a rozměry tělesa (hodnoty), které zadá uživatel, budou předány podprogramu pomocí parametrů. program Obsah_obdélníka_podprogram; {$APPTYPE CONSOLE} uses SysUtils; procedure vypis_obsah( strA, strB: Integer); {Podprogram na výpočet obsahu obdélníka.} var obsah:integer; begin obsah:= strA * strB; writeln('Obsah obelnika o stranach ', strA,' a ',strB,' je: ',obsah); end; var a,b: integer; begin writeln('Zadej rozmery obdelnika: '); readln(a,b); vypis_obsah(a,b); readln; end.
36
Parametry (hodnoty) lze podprogramům předávat i jinými způsoby, než jaké byly popsány. Pro naše účely však nejsou stěžejní a nebude jim v této části věnována pozornost. * * * Procvičení:
Všechny programy opatřete poznámkou, ve které bude uvedeno jméno programu a k jakým výpočtům je určen. ■ (46) Upravte program (03) tak, aby výpis názvu a adresy školy provedla procedura s názvem „vypis_hlavicku“. ■ (47) Upravte program (39) tak, že výpis pole bude provádět procedura s názvem „vypis_pole“.
■ (48) Upravte program (44) tak, že se odstraněné číslice z textu vypíší na samostatný řádek a tento řádek bude graficky oddělen souvislou čárou „________“, jež bude umístěna na předchozím a následujícím řádku. ■ (49) Upravte předchozí program (48) tak, aby oddělovací čára byla vždy stejně dlouhá jako řetězec vypsaných čísel.
4.2
Funkce
Funkce jsou dalším často používaným druhem podprogramů. Od procedur se liší především tím, že se při volání funkce neprovedou jen příkazy z těla funkce, jak je tomu u procedur, ale zároveň je vrácena funkční hodnota, se kterou lze dále pracovat. V Object Pascalu se funkce definuje následovně: function jméno_funkce (definice_parametrů): typ_výsledku; // hlavička {deklarace – v této části se deklarují lokálně dostupné prvky funkce, které se budou později využívat. Jsou jimi konstanty (za klíčovým slovem const); proměnné (za klíčovým slovem var); typy (za klíčovým slovem type); další procedury a funkce.} begin {tělo funkce – je tvořeno posloupností příkazů} end; Na první pohled se definice funkce výrazně podobá definici procedury. Definice funkce začíná hlavičkou s klíčovým slovem Function, za kterým následuje jméno_funkce (identifikátor), pomocí kterého je možné s podprogramem dále pracovat. Následující část definice_parametrů je stejně jako u procedury nepovinnou částí. Hlavička definice funkce je ukončena dvojtečkou a datovým typem, kterému náleží funkční hodnota návratové hodnoty. Tento typ nesmí být žádný ze strukturovaných typů. Další rozdíl mezi funkcí a procedurou je nastavení výsledné hodnoty v těle funkce. To se provede pomocí příkazu přiřazení, na jehož levé straně je jméno_funkce.
37
►Příklad definice funkce bez předání parametrů Pro účely názorného předvedení není v této části vytvořen celý program, ale jen funkce se jménem maximumAB, která porovná dvě čísla uložená v proměnných A, B typu Integer a jako výsledek vrátí hodnotu většího z nich. function maximumAB: Integer; begin if A>B then maximumAB := A else maximumAB := B; end;
// nastavení výsledné hodnoty na hodnotu proměnné A // nastavení výsledné hodnoty na hodnotu proměnné B
Jak již bylo řečeno, zavoláním funkce se neprovedou jen příkazy v těle funkce, ale zároveň se vrátí funkční hodnota, se kterou je možné dále pracovat. Volání (použití) funkce bez parametru Volání funkce je ze syntaktického hlediska výraz, ne příkaz, jak tomu bylo u procedury. Funkce tedy v programu vystupuje jako výraz se jménem funkce, s nímž se pracuje úplně stejně jako s jakýmkoliv výrazem, tj. může se vyskytovat jako součást složitějšího výrazu, být na pravé straně přiřazovacího příkazu apod. ►Příklady použití funkce (bez parametru) V příkladech je použita výše definovaná funkce maximumAB. vysledek := maximumAB; // výsledek je proměnná stejného typu, jako je návratová hodnota funkce soucet := (maximumAB - 9) * vysledek; // soucet a vysledek jsou proměnné stejného typu, jako je návratová hodnota funkce if maximumAB = min then // použití funkce v podmíněném příkazu if
4.2.1 Funkce a parametry Význam předání parametrů u funkce je stejný jako u procedur. Parametry se taktéž definují v hlavičce podprogramu do okrouhlých závorek za jméno_funkce. Jejich definice je stejná jako u procedur, tj. parametry nadefinujeme tak, že do okrouhlých závorek uvedeme seznam identifikátorů (tj. jmen parametrů), jež jsou odděleny čárkami. Za tento seznam se uvede dvojtečka a jméno typu. ►Příklad definice hlavičky funkce s předáním parametrů jednoho typu function obsah_obdelnika(strA, strB: Real):Real;
38
Chceme-li nadefinovat parametry o více typech, provede se jejich definice tak, že se mezi seznamy jednotlivých typů napíše středník „;“. ►Příklad definice hlavičky funkce s předáním parametrů o více typech function vypocet_BMI (hmotnost: Integer; vyska: Real): Real; //výstupní hodnota bude typu Real i přesto, že do funkce vstupuje parametr typu Integer
Volání (použití) funkce s předáním parametrů I v tomto případě funkce vystupuje jako výraz. Rozdíl v použití funkce s předáním parametru je, že se za výraz se jménem funkce do okrouhlých závorek vepíší parametry, které se oddělují čárkami. ►Příklady použití funkce s předáním parametrů (Definice procedur je použita z předchozí části.) vysledek := obsah_obdelnika(5,8); // výsledek je proměnná stejného typu, jako je návratová hodnota funkce, hodnoty vstupující do funkce, tj. 5 a 8 musejí být stejného typu jako odpovídající formální parametry v hlavičce definice funkce soucet := (obsah_obdelnika(a,b) - 9) * vysledek; // soucet a vysledek jsou proměnné stejného typu, jako je návratová hodnota funkce, (a,b) jsou hodnoty vstupující do funkce if vypocet_BMI(m,v) > 25 then // použití funkce v podmíněném příkazu if, (m,v) jsou hodnoty vstupující do funkce
* * * Procvičení:
Všechny programy opatřete poznámkou, ve které bude uvedeno jméno programu a k jakým výpočtům je určen. ■ (50) Napište program, který vyzve uživatele k zadání dvou celých čísel a vypíše na obrazovku jejich součet. Pro výpočet součtu naprogramujte funkci s názvem secti_cisla.
■ (51) Upravte předchozí program (50) tak, aby si uživatel mohl vybrat, zda chce zadaná čísla sečíst, odečíst, vynásobit nebo vydělit. Pro každou aritmetickou operaci naprogramujete příslušnou funkci. ■ (52) Vytvořte program pro výpočet obvodu a obsahu obdélníka a kruhu. Pro výpočty jednotlivých obsahů naprogramujte příslušné funkce.
39
Doporučená literatura: BRÁZA, Jiří. Delphi 4: Kompletní kapesní průvodce. Praha: Grada, 1999. CANTU, Marco. Myslíme v jazyku Delphi 6. 1. díl. 1. vyd. Praha: Grada, 2002a. CANTU, Marco. Myslíme v jazyku Delphi 6. 2. díl. 1. vyd. Praha: Grada, 2002b. CANTU, Marco. Myslíme v jazyku Delphi 7. 1. vyd. Praha: Grada, 2003. KADLEC, Václav. Učíme se programovat v Delphi a jazyce Object Pascal. 1. vyd. Praha: Computer Press, 2001. MARTIŠEK, Dalibor. Algoritmizace a programování v Delphi. 1. vyd. Brno: Littera, 2007. OLEHLA, Miroslav. Počítače a programování Pascal: Studijní podklady. 3. rozš. vyd. Liberec: Technická univerzita v Liberci, 2008. SATRAPA, Pavel. Pascal pro zelenáče. 3. vyd. Praha: Neocortex, 2005.
40
Možná řešení příkladů na procvičení: ■(01) // Program, který vypíše na obrazovku pozdrav. program Pozdrav; {$APPTYPE CONSOLE} uses SysUtils; begin { <-KOMENTÁŘ-> writeln - příkaz pro výpis na obrazovku, text uvedený v apostrofech se vypíše na obrazovku jako text} writeln('Nazdar!'); readln; end.
■(02) // Program, který vypíše na obrazovku název a adresu školy. program Adresa_skoly_a; {$APPTYPE CONSOLE} uses SysUtils; begin writeln('ZÁKLADNÍ ŠKOLA BRNO VEDLEJŠÍ'); writeln('adresa:'); writeln('Vedlejší 10'); writeln('625 00 Brno'); readln; end.
■(03) // Program, který vypíše na obrazovku název a adresu školy. program Adresa_skoly_b; {$APPTYPE CONSOLE} uses SysUtils; begin writeln('ZAKLADNI SKOLA BRNO VEDLEJSI'); writeln; writeln('adresa:'); writeln('Vedlejší 10'); writeln('625 00 Brno'); readln; end.
41
■(04) {* Program, který vypočítá obvod a obsah obdélníka, velikosti stran jsou: a=5cm, b=7cm. *} program Obdelnik_a; {$APPTYPE CONSOLE} uses SysUtils; begin writeln('Výpočet obvodu a obsahu obdélníka.'); writeln('Velikosti stran: a = 5 cm, b = 7 cm.'); writeln; writeln('Obvod je: ', 2*(5 + 7),' cm'); writeln('Obsah je: ', 5*7,' cm'); readln; end.
■(05) {* Program, který vypočítá obvod a obsah obdélníka, velikosti stran jsou: a=5cm, b=7cm; řešeno pomocí konstant. *} program Obdelnik_b; {$APPTYPE CONSOLE} uses SysUtils; const a=5; b=7; begin writeln('Výpočet obvodu a obsahu obdélníka.'); writeln('Velikosti stran: a = 5 cm, b = 7 cm.'); writeln; writeln('Obvod je: ', 2*(a + b),' cm'); writeln('Obsah je: ', a*b,' cm'); readln; end.
■(06) //Program, který vypočítá obvod a obsah kruhu, velikost poloměru je 15 cm. program Kruh_a; {$APPTYPE CONSOLE} uses SysUtils; const polomer=15; pi=3.14; begin writeln('Výpočet obvodu a obsahu kruhu.'); writeln('Poloměr kruhu je 15 cm.'); writeln('Obvod je: ', 2*pi*polomer,' cm'); writeln('Obsah je: ', pi*polomer*polomer,' cm cverecnich'); readln; end.
42
■(07) {* Program, který vypočítá obvod a obsah kruhu, velikost poloměru je 15 cm, formátování výstupu na 9 míst, z nichž 3 místa jsou vymezena pro desetinnou část. *} program Kruh_b; {$APPTYPE CONSOLE} uses SysUtils; const pi=3.14; polomer=15; begin writeln('Výpočet obvodu a obsahu kruhu o poloměru 15 cm.'); writeln; writeln('Obvod je: ', 2*pi*polomer:9:3,' cm'); writeln('Obsah je: ', pi*polomer*polomer:9:3,' cm čtverečních'); readln; end.
■(08) {* Program, který vyzve uživatele k zadání dvou celých čísel. Součet vypíše na obrazovku. *} program Soucet_cisel; {$APPTYPE CONSOLE} uses SysUtils; var Cislo_1, Cislo_2: integer;
// deklarace proměnných
begin writeln ('Zadej dvě celá čísla: '); readln(Cislo_1, Cislo_2); // příkaz vstupu writeln('Součet zadaných čísel je: ', Cislo_1 + Cislo_2); readln; end.
■(09) // Program na výpočet obvodu a obsahu obdélníka. program Obdelnik_c; {$APPTYPE CONSOLE} uses SysUtils; var str_a, str_b, obsah, obvod:integer; begin writeln('Zadej strany obdélníka'); write('stranu a: '); readln(str_a); write('stranu b: '); readln(str_b); {* výpočet obvodu a obsahu, operátor přiřazení ":=" přiřadí proměnné na levé straně vyhodnocený výraz na straně pravé *} obvod:=(2*(str_a + str_b)); obsah:=(str_a * str_b);
43
//výpis na obrazovku writeln('Obsah obdélníka je ',obsah); writeln('Obvod obdélníka je ',obvod); readln; end.
■(10) {* Program, který vypočítá obvod a obsah kruhu, velikosti poloměru zadá uživatel, formátování výstupu na 9 míst, z nichž 3 místa jsou vymezena pro desetinnou část *} program Kruh_c; {$APPTYPE CONSOLE} uses SysUtils; const pi=3.14; var polomer:real; begin writeln('Výpočet obvodu a obsahu kruhu.'); write('Zadej velikost poloměru: '); readln (polomer); writeln; writeln('Obvod je: ', 2*pi*polomer:9:3,' cm'); writeln('Obsah je: ', pi*polomer*polomer:9:3,' cm čtverečních'); readln; end.
■(11) {* Program, který převede zadanou decimetry, centimetry a milimetry *}
hodnotu
v
metrech
na
kilometry,
program Prevod_a; {$APPTYPE CONSOLE} uses SysUtils; var m:real; znak:char; begin writeln('Program, který převede zadanou vzdálenost v metrech na kilometry, decimetry, centimetry a milimetry.'); writeln; write('Zadejte vzdálenost v metrech: '); readln (m); writeln; writeln(' Zadaná vzdálenost je ', m/1000:9:6,' kilometrů'); writeln(' Zadaná vzdálenost je ', m*10:9:3,' decimetrů'); writeln(' Zadaná vzdálenost je ', m*100:9:2,' centimetrů'); writeln(' Zadaná vzdálenost je ', m*1000:9:1,' milimetrů'); readln; end.
44
■(12) {* Program, který převede zadanou hodnotu v metrech čtverečních decimetry čtverečné, centimetry čtverečné a milimetry čtverečné. *}
na
program Prevod_b; {$APPTYPE CONSOLE} uses SysUtils; var m:real;
begin writeln(' Program, který převede zadanou hodnotu v metrech čtverečních na decimetry čtverečné, centimetry čtverečné a milimetry čtverečné..'); writeln; write('Zadejte plochu v readln (m); writeln; writeln(' Zadaná plocha writeln(' Zadaná plocha writeln(' Zadaná plocha readln; end.
metrech čtverečních: ');
je je je
', m*100:9:2,' decimetrů'); ', m*10000:9:1,' centimetrů'); ', m*1000000:9:0,' milimetrů');
■(13) // Program, který převede částku v českých korunách na zahraniční měnu. program Prevod_meny; {$APPTYPE CONSOLE} uses SysUtils; var a, b :real; begin writeln(' Program, který převede částku v českých korunách na zahraniční měnu.'); writeln; write('Zadejte částku (CZK), kterou chcete převést: '); readln (a); write('Zadejte kurz: '); readln (b); writeln('Cílová částka v zahraniční měně je: ',a/b:10:2); readln; end.
■(14) // Program na výpočet BMI program BMI; {$APPTYPE CONSOLE} uses SysUtils; var vyska,hmotnost,index:real; x:char;
45
begin writeln ('PROGRAM NA VYPOCET BMI'); writeln; write('Zadej svou hmotnost (kg): '); readln (hmotnost); write('Zadej svou výšku (m): '); readln(vyska); index:=hmotnost/(vyska*vyska); writeln('Tvůj idex je ',index:8:3); writeln; writeln('BMI 0..20 >> podvaha'); writeln('BMI 21..25 >> normal'); writeln('BMI 26.. >> nadvaha'); readln; end.
■(15) {* Program, který spočítá konečný zůstatek na spořicím účtu, uživatel zadá: délku vkladu v měsících, částku a úrok spořicího úctu. *} program Sporici_ucet_a; {$APPTYPE CONSOLE} uses SysUtils; var vklad, urok, delka: real; begin writeln ('Program na výpočet konečného zůstatku na spořicím účtu.'); writeln; write('Zadejte výši vkladu: '); readln(vklad); write('Zadejte délku spoření (v měsících): '); readln(delka); write('Zadejte úrok u spořicího účtu (p.a.): '); readln(urok); writeln; writeln ('Konečný zůstatek po ' ,delka:3:0,' měsících je ', vklad + ((urok/12)/100)*vklad*delka:10:3,' korun'); readln; end.
■(16) // Program na určení většího čísla. program Vetsi_mensi; {$APPTYPE CONSOLE} uses SysUtils; var a,b:real; begin write('Napiš číslo a: '); readln(a); write('Napiš číslo b: '); readln(b); //porovnávací část
46
if a
b then writeln('a je větší než b'); if a=b then writeln('Nezkoušej to na mě, jsou stejný!!'); readln; end.
■(17) // Program na určení sudého nebo lichého čísla program Sude_liche; {$APPTYPE CONSOLE} uses SysUtils; var a,b:Integer; begin write('Zadej cele cislo a: '); readln(a); //porovnávací část if (a mod 2 = 0) then writeln('Zadané číslo ',a,' je SUDÉ.') else writeln('Zadané číslo ',a,' je LICHÉ.'); readln; end.
■(18) // Program na určení největšího čísla. program Nejvetsi_cislo; {$APPTYPE CONSOLE} uses SysUtils; var a,b,c :integer; begin writeln (' Program write('Napiš číslo readln(a); write('Napiš číslo readln(b); write('Napiš číslo readln(c);
na určení největšího čísla.'); a: '); b: '); c: ');
//vyhodnocovací část if a>b then begin if a>=c then writeln('Největší číslo je:', a) else writeln('Největší číslo je:', c); end else begin if b>=c then writeln('Největší číslo je:', b)
47
else writeln('Největší číslo je:', c); end; readln; end.
■(19) {* Program, který převede zadanou decimetry, centimetry a milimetry.*}
hodnotu
v
metrech
na
kilometry,
program Prevod_c; {$APPTYPE CONSOLE} uses SysUtils; var m:real; znak:char; begin writeln(' Program, který převede zadanou hodnotu v metrech na kilometry, decimetry, centimetry a milimetry.'); writeln; write('Zadejte vzdálenost v metrech: '); readln (m); writeln; writeln('Pro writeln('Pro writeln('Pro writeln('Pro
převod převod převod převod
na na na na
kilometry stiskni klávesu '); decimetry stiskni klávesu '); centimetry stiskni klávesu '); milimetry stiskni klávesu <m>');
writeln; write('Zadej příslušný znak pro převod: '); readln (znak); if if if if
znak='k' znak='d' znak='c' znak='m'
then then then then
writeln('Zadaná writeln('Zadaná writeln('Zadaná writeln('Zadaná
vzdálenost vzdálenost vzdálenost vzdálenost
je', m/1000:9:6,'kilometrů'); je', m*10:9:3,'decimetrů'); je ',m*100:9:2,'centimetrů'); je ',m*1000:9:1,'milimetrů');
readln; end.
■(20) //Program na výpočet BMI program BMI_b; {$APPTYPE CONSOLE} uses SysUtils; var vyska,hmotnost,index:real; x:char; begin writeln('PROGRAM NA VÝPOČET BMI'); writeln;
48
write('Zadej svou hmotnost(kg): '); readln(hmotnost); write('Zadej svou výšku (m): '); readln(vyska); index:=hmotnost/(vyska*vyska); writeln('Tvůj index je ',index:8:3); writeln; if index < 20 then writeln('Tvůj BMI index je v rozmezí 0..20 >> PODVÁHA '); if index = 20 then writeln ('Tvůj BMI index je na hranici PODVÁHA a NORMÁL '); if (index > 20) and (index<25) then writeln('Tvůj BMI index je v rozmezí 20..25 >> NORMÁL '); if index = 26 then writeln ('Tvůj BMI index je na hranici NORMÁL a NADVÁHA '); if index > 26 then writeln('Tvůj BMI index je vetší než 26 >> NADVÁHA '); readln; end.
■(21) {* Program, který načte od uživatele dvě celá čísla, poté je sečte a rozhodne, zda je součet dělitelný šesti a devíti současně.*} program Znaky_delitelnosti; {$APPTYPE CONSOLE} uses SysUtils; var a, b, soucet: integer; begin writeln ('Program rozhodne, dělitelný šesti i devíti.'); writeln; write('Zadej první celé číslo: readln(a); write('Zadej druhé celé číslo: readln(b); writeln; soucet:= a+b; writeln('Součet zadaných čísel writeln;
zda
je
součet
zadaných
čísel
zároveň
'); ');
je ',soucet);
if (soucet mod 6 = 0) and (soucet mod 9 = 0) then writeln('Součet zadaných čísel je dělitelný šesti i devíti.') else writeln('Součet zadaných čísel není dělitelný šesti i devíti.'); readln; end.
■(22) // Program na procvičení příkazu case. program Procviceni_case;
49
{$APPTYPE CONSOLE} uses SysUtils; var znak:char; begin writeln('Program na procvičení práce s příkazem case.'); writeln; write('Zadej libovolný znak z klávesnice: '); readln(znak); writeln; case znak of '0'..'9': writeln('Zadaný znak je číslice.'); 'a'..'z': writeln('Zadaný znak je malé písmeno anglické abecedy.'); 'A'..'Z': writeln('Zadaný znak je velké písmeno anglické abecedy.'); '+','-','*','/':writeln('Zadaný znak je operátor.'); else writeln('Zadaný znak není písmeno, číslice ani operátor.'); end; readln; end.
■(23) // Program na výpočet jízdného v taxíku. program Taxik; {$APPTYPE CONSOLE} uses wincrt; var sazba:integer; vzdalenost:real; begin writeln ('Program na výpočet ceny jízdy taxíkem.') ; write('Zadejte ujetou vzdálenost: '); readln(vzdalenost); case trunc(vzdalenost) of 0..14 :sazba:=40; 15..34:sazba:=36; 35..59:sazba:=32; else sazba:=25; end; writeln; writeln('Za ujetou vzdálenost ',vzdalenost:0:2,' km je sazba ',sazba,' Kč/km a zaplatíte: ',(vzdalenost*sazba):0:2,' Kc'); readln; end.
■(24) //Program načte tři čísla, porovná je a vypíše je na obrazovku. program Serazeni; {$APPTYPE CONSOLE}
50
uses SysUtils; var a,b,c : real; begin writeln('Program načte tři čísla a zpětně je vypíše od největšího po nejmenší'); writeln; write('Zadej první číslo: '); readln(a); write('Zadej druhé číslo: '); readln(b); write('Zadej třetí číslo: '); readln(c); if a>b then if b>c then writeln(' Sestupné pořadí je ',a:8:2,' ',b:8:2,' ',c:8:2) else if a>c then writeln(' Sestupné pořadí je ',a:8:2,' ',c:8:2,' ',b:8:2) else writeln(' Sestupné pořadí je ',c:8:2,' ',a:8:2,' ',b:8:2) else if a>c then writeln(' Sestupné pořadí je ',b:8:2,' ',a:8:2,' ',c:8:2) else if b>c then writeln(' Sestupné pořadí je ',b:8:2,' ',c:8:2,' ',a:8:2) else writeln(' Sestupné pořadí je ',c:8:2,' ',b:8:2,' ',a:8:2); readln; end.
■(25) {* Program, který převede zadanou decimetry, centimetry a milimetry *}
hodnotu
v
metrech
na
kilometry,
program Prevod_d; {$APPTYPE CONSOLE} uses SysUtils; var m:real; znak:char; poc:integer; begin poc:=0; writeln('Program, který převede zadanou vzdálenost v metrech na kilometry, decimetry, centimetry a milimetry.'); writeln; write('Zadejte vzdálenost v metrech: '); readln (m); writeln; writeln('Pro převod na kilometry stiskni klávesu '); writeln('Pro převod na decimetry stiskni klávesu '); writeln('Pro převod na centimetry stiskni klávesu ');
51
writeln('Pro převod na milimetry stiskni klávesu <m>'); writeln; write('Zadej příslušný znak pro převod: '); repeat if poc>0 then write('Zadal jsi nesprávný znak, opakuj volbu: '); readln (znak); poc:=poc+1; until (znak='k') or (znak='d') or (znak='c')or (znak='m'); writeln; if znak='k' if znak='d' if znak='c' if znak='m'
then then then then
writeln('Zadaná writeln('Zadaná writeln('Zadaná writeln('Zadaná
vzdálenost vzdálenost vzdálenost vzdálenost
je', je', je', je',
m/1000:9:6,'kilometrů'); m*10:9:3,'decimetrů'); m*100:9:2,'centimetrů'); m*1000:9:1,'milimetrů');
readln; end.
■(26) // Hra na hádání čísla, které je vygenerováno počítačem, hráč má neomezený počet pokusů. program Hadani; {$APPTYPE CONSOLE} uses SysUtils; var cislo, pokus: integer; begin randomize; cislo:=1+random(100); writeln(cislo); Writeln('Program náhodně vygeneroval číslo z intervalu 1..100. '); writeln ('Tvým úkolem je dané číslo uhodnout.'); writeln; repeat write('Zadej typ: '); readln(pokus); if pokus>cislo then writeln('---------------Hledané číslo je MENŠÍ') if pokus
■(27) {* Hra na pokusů. *}
hádání
čísla,
které
je
vygenerováno
počítačem,
hráč
má
osm
program Hadani_a;
52
{$APPTYPE CONSOLE} uses SysUtils; const max=100; var cislo, pokus, pom: integer; begin randomize; cislo:=1+random(max); writeln(cislo); pom:=0; Writeln('Program náhodně vygeneroval číslo z intervalu 1..100. '); writeln ('Tvým úkolem je dané číslo uhodnout maximálně na 8 pokusů.'); writeln; repeat pom:= pom+1; write('Zadej ',pom,'. typ: '); readln(pokus); if pokus>cislo then writeln(' if pokus
Hledané číslo je MENŠÍ'); Hledané číslo je VĚTŠÍ');
until (pokus=cislo) or (pom=8); writeln; if (pokus<>cislo) and (pom=8)then writeln('Je mi líto, nepodařilo se ti to, hledané číslo bylo: ',cislo) else writeln('Super, podařilo se ti to..:-)'); readln; end.
■(28) // Hra na hádání čísla, které je vygenerováno počítačem, hráč má 15 pokusů. program Hadani_b; {$APPTYPE CONSOLE} uses SysUtils; const max=100; max_p=15; nul = -1; var cislo, pokus, pom: integer; begin randomize; cislo:=1+random(max); pom:=0; pokus:=nul;
// generování čísla
writeln('Program náhodně vygeneroval číslo z intervalu 1..100. '); writeln ('Tvým úkolem je dané číslo uhodnout maximálně na 15 pokusů.'); writeln; // cyklus hádání repeat
53
if (succ(pokus)=cislo)or(pred(pokus)=cislo) then begin cislo:=1+random(max); writeln; writeln('Právě bylo vygenerováno nové číslo!!!!!'); end else begin if pom>0 then begin if pokus>cislo then writeln(' Hledané číslo je MENŠÍ'); if pokuscislo) and (pom=max_p)then writeln('Je mi líto, nepodařilo se ti to, hledané číslo bylo: ',cislo) else writeln('Super, podařilo se ti to..:-)'); readln; end.
■(29) // Program vypíše sudá čísla z intervalu 1<x<30 program Suda_cisla; {$APPTYPE CONSOLE} uses SysUtils; var i:integer; begin writeln('Výpis sudých čísel.'); writeln; for i:=1 to 14 do write(i*2,' '); readln; end.
■(30) // Program vypíše tabulku druhých mocnin od 1 do 20. program Mocnina; {$APPTYPE CONSOLE} uses SysUtils; var i:integer;
54
begin writeln('Výpis druhých mocnin.'); writeln; writeln('_____________________________'); for i:=1 to 20 do writeln(i:4,' readln; end.
',i*i:4);
■(31) {*Napište program, jehož výstup na obrazovce bude vypadat takto: pro hodnotu šest 1 6 2 5 3 4 4 3 5 2 6 1 Počet řádků zadá uživatel *} program Vypis; {$APPTYPE CONSOLE} uses SysUtils; var i,n:integer; begin write('Zadej počet řádků: '); readln(n); writeln; for i:=1 to n do writeln(i:4,' readln; end.
',(n+1)-i);
■(32) // Program na procvičení cyklu s příkazem for. program Pyramida; {$APPTYPE CONSOLE} uses SysUtils; const stred = 30; var i,j,p,m,n:integer; begin write('Zadej počet řádků pyramidy <max 30>: '); readln(n); for p:=1 to 5 do writeln; for i:=1 to n do begin for m:=stred downto i do
55
write(' '); for j:=1 to i do write('* '); writeln; end; readln; end.
■(33) // Program na procvičení cyklu s příkazem for. program Pyramida_b; {$APPTYPE CONSOLE} uses SysUtils; const stred = 30; var i,ii,j,p,m,n:integer; begin write('Zadej počet řádků pyramidy <max 30>: '); readln(n); for p:=1 to 5 do writeln; for i:=1 to n do begin m:=stred+i; for ii:=m downto 1 do write(' '); for j:=n downto i do write('* '); writeln; end; readln; end.
■(34) // Program určí číslici na n-té pozici v posloupnosti program Posloupnost; {$APPTYPE CONSOLE} uses SysUtils; var pozice, pom, j, cislo: integer; begin writeln('Program na určení číslice na n-té pozici v posloupnosti 1, 2, 2 , 3, 3, 3, ...'); write('Zadej pozici: '); readln(pozice); pom:=1; cislo:=0; repeat while pom <= pozice do
56
begin cislo:=cislo+1; for i:=1 to cislo do begin pom:=pom+1; end; end; writeln; writeln('Číslice na ',pozice,'. pozici je: ',cislo); writeln; pom:=1; cislo:=0; write('Zadej pozici: '); readln(pozice); until pozice=0; end.
■(35) // Program na procvičení cyklu s příkazem for. program Pyramida_c; {$APPTYPE CONSOLE} uses SysUtils; const stred = 35; var i,ii,j,p,m,n:integer; znak:char; begin write('Zadej počet řádků pyramidy <max 30>: '); readln(n); write('Zadej znak, ze kterého má být pyramida postavena: '); readln(znak); for p:=1 to 5 do writeln; for i:=1 to n do begin m:=stred-n+i; for ii:=m downto 1 do write(' '); for j:=n downto i do write(znak,' '); writeln; end; readln; end.
■(36) {* Program na výpočet zůstatku na spořicím účtu. Uživatel zadá částku, kterou chce na spořicí učet vložit, úrok spořicího účtu (p.a.) a délku spoření v měsících. Úrok se bude na účet připisovat každý měsíc z aktuálního zůstatku na účtu. Program bude brát v úvahu i patnáctiprocentní daň z úroku. *} program Sporici_ucet; {$APPTYPE CONSOLE}
57
uses SysUtils; var vklad, urok, urok_m: real; i,delka: integer; begin writeln ('Program na výpočet konečného zůstatku na spořicím učtu.'); writeln; write('Zadejte výši vkladu: '); readln(vklad); write('Zadejte délku spoření (v měsících): '); readln(delka); write('Zadejte úrok u spořicího učtu (p.a.): '); readln(urok); writeln; urok_m:=(urok/1200)*0.85; for i:=1 to delka do begin vklad:=vklad+(vklad*urok_m); writeln('Po',i:2,'. měsíci bude zůstatek na učtu:',vklad:12:2,' Kč'); end; readln; end.
■(37) {* Vytvořte jednoduchý program tak, že nadefinujete pole, které bude mít pět prvků, prvky budou mít datový typ Integer. Pole naplňte libovolnými hodnotami a poté je pomocí cyklu s příkazem For vypište na obrazovku do dvou řádků. V prvním řádku budou hodnoty jednotlivých složek pole vypsány v pořadí, v jakém jste je zadali, v druhém řádku budou tyto hodnoty vypsány v obráceném pořadí. *} program Pole; {$APPTYPE CONSOLE} uses SysUtils; const max = 5 ; type pole_cisel=array[1..max]of integer; var i: integer; p:pole_cisel; begin writeln ('Program vypíše pole o pěti prvcích.'); writeln; // plnění pole p[1]:=12; p[2]:=1254; p[3]:=155; p[4]:=1452; p[5]:=545; // výpis pole for i:=1 to max do write(p[i]:5); writeln; writeln; // výpis pole v opačném pořadí
58
for i:=max downto 1 do write(p[i]:5); readln; end.
■(38) {* Upravte předcházející program (37) tak, že hodnoty zadá uživatel. Podmínky pro výpis zůstávají nezměněny. *} program Pole_b; {$APPTYPE CONSOLE} uses SysUtils; const max = 5 ; type pole_cisel=array[1..max]of integer; var i: integer; p: pole_cisel; begin writeln ('Program načte z klávesnice celočíselné hodnoty a uloží je do pole.'); writeln; for i:=1 to max do begin write('Zadej ',i,'. prvek pole: '); readln(p[i]); end; // výpis pole for i:=1 to max do write(p[i]:5); writeln; writeln; // výpis pole v opačném pořadí for i:=max downto 1 do write(p[i]:5); readln; end.
■(39) {* Upravte předcházející program (37) tak, že hodnoty zadá uživatel. Podmínky pro výpis zůstávají nezměněny. *} program Pole_c; {$APPTYPE CONSOLE} uses SysUtils; const max = 15 ; type pole_cisel=array[1..max]of integer; var i: integer; p:pole_cisel; begin randomize; writeln ('Program načte z klávesnice celočíselné hodnoty a uloží je do pole.'); writeln;
59
for i:=1 to max do begin p[i]:=1+random(100); end; // výpis pole for i:=1 to max do write(p[i]:5); writeln; writeln; // výpis pole v opačném pořadí for i:=max downto 1 do write(p[i]:5); readln; end.
■(40) {* Rozšiřte předcházející program o nalezení největšího a nejmenšího prvku. Oba prvky se vypíší na obrazovku. *} program Pole_nalezeni_prvku; {$APPTYPE CONSOLE} uses SysUtils; const max = 15; horni_mez = 100; type pole_cisel=array[1..max]of integer; var i, max_, min_: integer; p:pole_cisel; begin randomize; writeln ('Program načte z klávesnice celočíselné hodnoty a uloží je do pole.'); writeln; for i:=1 to max do begin p[i]:=1+random(horni_mez); end; // výpis pole for i:=1 to max do write(p[i]:5); writeln; writeln; // výpis pole v opačném pořadí for i:=max downto 1 do write(p[i]:5); min_:= horni_mez; max_:=1; // hledání nejmenšího prvku for i:=1 to max do begin if min_>p[i] then min_:=p[i]; if max_
60
writeln('Největší prvek je: ',max_); readln; end.
■(41) // Program na procvičení datového typu String program String_jmeno; {$APPTYPE CONSOLE} uses SysUtils; var jmeno:String; i, delka:integer; begin writeln ('Program na procvičení datového typu String.'); write ('Zadej své jméno: '); readln(jmeno); writeln; delka:= length(jmeno);
// funkce vrátí délku řetězce
for i:=delka downto 1 do write(jmeno[i]); readln; end.
■(42) {* Program na procvičení datového typu String. Na obrazovku se vypíší znaky na sudých pozicích zadaného řetězce. *} program String_sude_pozice; {$APPTYPE CONSOLE} uses SysUtils; var retezec:String; i, delka:integer; begin writeln ('Program na procvičení datového typu String.'); write ('Zadej nějaký text: '); readln(retezec); writeln; delka:= trunc(length(retezec)/2); // funkce vrátí délku řetězce // writeln (delka); for i:=1 to delka do write(retezec[i*2]); readln; end.
■(43) {* Program na procvičení datového typu String. Na obrazovku se vypise text bez symbolu cisel. *}
61
program String_odstraneni_cislic; {$APPTYPE CONSOLE} uses SysUtils; var retezec:String; z:char; i, delka :integer; begin writeln ('Program na procvičení datového typu String.'); write ('Zadej nějaký text: '); readln(retezec); writeln; delka:=length(retezec); // funkce vrátí délku řetězce for i:=1 to delka do begin z:=retezec[i]; if (ord(z)<=48) or ( ord(z)>=57 ) then write(retezec[i]); end; readln; end.
■(44) {* Program na procvičení datového typu String. *} program String_odstraneni_cislic_b; {$APPTYPE CONSOLE} uses SysUtils; var retezec,pom:String; z:char; i,pocet, delka:integer; begin writeln ('Program na procvičení datového typu String.'); writeln; write ('Zadej nějaký text: '); readln(retezec); writeln; pocet:=0; delka:=length(retezec); // funkce vrátí délku řetězce for i:=1 to delka do begin z:=retezec[i]; if (ord(z)>=48) and ( ord(z)<=57 ) then begin pom:=concat(pom, retezec[i]); pocet:=pocet+1; end else write(retezec[i]); end; writeln(' ',pom); writeln; writeln('Počet číslic v zadaném textu je: ', pocet); readln; end.
62
■(45) {* Program na procvièení datového typu String. Na obrazovku se vypisi cetnosti jednotlivych samohlasek zadanych v textu. *} program String_cetnost_samohlasek; {$APPTYPE CONSOLE} uses SysUtils; var retezec:String; znak:char; i,delka,p_a,p_e,p_i,p_o,p_u,p_y:integer; begin writeln ('Program na procvičení datového typu String.'); writeln; write ('Zadej nějaký text: '); readln(retezec); writeln; delka:=length(retezec); // funkce vrátí délku řetězce for i:=1 to delka do begin znak:=retezec[i]; case znak of 'a': p_a:=p_a+1; 'e': p_e:=p_e+1; 'i': p_i:=p_i+1; 'o': p_o:=p_o+1; 'u': p_u:=p_u+1; 'y': p_y:=p_y+1; end; end; writeln; writeln('V zadaném textu writeln('V zadaném textu writeln('V zadaném textu writeln('V zadaném textu writeln('V zadaném textu writeln('V zadaném textu readln; end.
je je je je je je
',p_a, ',p_e, ',p_i, ',p_o, ',p_u, ',p_y,
' ' ' ' ' '
samohlásek samohlásek samohlásek samohlásek samohlásek samohlásek
-
A'); E'); I'); O'); U'); Y');
■(46) // Program, který vypíše na obrazovku název a adresu školy pomocí procedury. program Procedura_Adresa_skoly; {$APPTYPE CONSOLE} uses SysUtils; procedure vypis_hlavicku; begin writeln('ZÁKLADNÍ ŠKOLA BRNO VEDLEJŠÍ'); writeln; writeln('adresa:'); writeln('Vedlejší 10'); writeln('625 00 Brno'); end;
63
begin vypis_hlavicku; readln; end.
■(47) // Program, který vypíše pole pomocí procedury. program Procedura_vypis_pole; {$APPTYPE CONSOLE} uses SysUtils; const max = 15; type pole_cisel=array[1..max]of integer; var i: integer; p:pole_cisel; procedure vypis_pole(pp:pole_cisel; maximum:integer); var i:integer; begin // výpis pole for i:=1 to maximum do write(p[i]:5); writeln; writeln; // výpis pole v opačném pořadí for i:=maximum downto 1 do write(p[i]:5); end; begin randomize; writeln ('Program načte z klávesnice celočíselné hodnoty a uloží je do pole.'); writeln; for i:=1 to max do p[i]:=1+random(100); // volání procedury vypis_pole(p,max); readln; end.
■(48) // Program na procvičení datového typu String. program Pole_odstraneni_cislic_b; {$APPTYPE CONSOLE} uses SysUtils; var retezec,pom:String; z:char; i,pocet,delka, delkaCary:integer; procedure cara; var i: integer; begin
64
writeln('___________'); end; begin writeln ('Program na procvičení datového typu String.'); writeln; write ('Zadej nějaký text: '); readln(retezec); writeln; pocet:=0; delka:=length(retezec); // funkce vrátí délku řetězce for i:=1 to delka do begin z:=retezec[i]; if (ord(z)>=48) and ( ord(z)<=57 ) then begin pom:=concat(pom, retezec[i]); pocet:=pocet+1; end else write(retezec[i]); end; writeln; delkaCary:=length(pom); cara; // volání procedury writeln; writeln; writeln(pom); cara; // volání procedury writeln; writeln('Počet číslic v zadaném textu je: ', pocet); readln; end.
■(49) // Program na procvičení datového typu String. program Pole_odstraneni_cislic_c; {$APPTYPE CONSOLE} uses SysUtils; var retezec,pom:String; z:char; i,pocet,delka, delkaCary:integer; procedure cara(delkaC:integer); var i: integer; begin for i:=1 to delkaC do write('_'); end; begin writeln ('Program na procvičeni datového typu String.'); writeln; write ('Zadej nějaký text: '); readln(retezec); writeln;
65
pocet:=0; delka:=length(retezec);
// funkce vrátí délku řetězce
for i:=1 to delka do begin z:=retezec[i]; if (ord(z)>=48) and ( ord(z)<=57 ) then begin pom:=concat(pom, retezec[i]); pocet:=pocet+1; end else write(retezec[i]); end; writeln; delkaCary:=length(pom); cara(delkaCary); // volání procedury writeln; writeln; writeln(pom); cara(delkaCary); // volání procedury writeln; writeln('Počet číslic v zadaném textu je: ', pocet); readln; end.
■(50) {* Program, který vyzve uživatele k zadáni dvou celých čísel. Součet vypíše na obrazovku. *} program Soucet_cisel_funkce; {$APPTYPE CONSOLE} uses SysUtils; function secti_cisla(a,b:real):real; begin secti_cisla:= a+b; end; var Cislo_1, Cislo_2:real;
// deklarace proměnných
begin writeln ('Zadej dvě celá čísla: '); readln(Cislo_1, Cislo_2); writeln('Součet zadaných čísel je: ', secti_cisla(Cislo_1,Cislo_2):8:2); readln; end.
■(51) // Program na procvičení funkcí program Funkce; {$APPTYPE CONSOLE} uses SysUtils;
66
function secti_cisla(a,b:real):real; begin secti_cisla:= a+b; end; function odecti_cisla(a,b:real):real; begin odecti_cisla:= a-b; end; function vynasob_cisla(a,b:real):real; begin vynasob_cisla:= a*b; end; function vydel_cisla(a,b:real):real; begin if b<> 0 then vydel_cisla:= a/b else begin writeln('Nelze, dělitel je roven nule!!!'); vydel_cisla:= 0; end; end; var Cislo_1, Cislo_2:real; znak:char;
// deklarace proměnných
begin writeln ('Zadej dvě celá čísla: '); readln(Cislo_1, Cislo_2); writeln('Pro součet zadaných čísel stiskni " + " '); writeln('Pro rozdíl zadaných čísel stiskni " - " '); writeln('Pro součin zadaných čísel stiskni " * " '); writeln('Pro podíl zadaných čísel stiskni " / " '); writeln('Pro ukončení programu stiskni " k "'); writeln; repeat readln(znak); until (znak='+') or (znak='-') or (znak='*') (znak='k'); case znak of '+': writeln('Součet zadaných čísel je: ', secti_cisla(Cislo_1,Cislo_2):8:2); '-': writeln('Rozdíl zadaných čísel je: ', odecti_cisla(Cislo_1,Cislo_2):8:2); '*': writeln('Součin zadaných čísel je: ', vynasob_cisla(Cislo_1,Cislo_2):8:2); '/': writeln('Podíl zadaných čísel je: ', vydel_cisla(Cislo_1,Cislo_2):8:2); end; readln; end.
or
(znak='/')
or
■(52) // Program na procvičení funkcí program Funkce_stereometrie; {$APPTYPE CONSOLE} uses SysUtils;
67
function obsah_obdelnika:real; var a,b:real; begin writeln('Zadej velikosti stran obdélníka: '); readln(a,b); obsah_obdelnika:= a*b; end; function obsah_kruhu:real; var polomer:real; const PI=3.14; begin writeln('Zadej velikost poloměru: '); readln(polomer); obsah_kruhu:= PI*polomer*polomer; end; var Cislo_1, Cislo_2:real; znak:char; spatne:boolean; // deklarace proměnných begin writeln ('Program pro výpočet obsahu obdélníka a kruhu '); writeln; writeln('Pro výpočet obsahu obdélníka stiskni "d"'); writeln('Pro výpočet obsahu kruhu stiskni "k"'); writeln('Pro ukončení programu stiskni "e"'); repeat if spatne=true then writeln('Špatně!!! Vyber znovu.'); readln(znak); spatne:=true; until (znak='d') or (znak='k') or (znak='e'); case znak of 'd': writeln('Obsah obdélníka je: ', obsah_obdelnika:8:2); 'k': writeln('Obsah kruhu je: ', obsah_kruhu:8:2); end; readln; end.
68
Možná řešení příkladů samostatné práce: ■(01) program Prazdniny; {$APPTYPE CONSOLE} uses SysUtils; begin writeln('O prázdninách poletím na Kubu.'); readln; end.
■(02) program Cena_letenky; {$APPTYPE CONSOLE} uses SysUtils; var letenka, poplatky: integer;
// deklarace proměnných
begin write ('Zadej cenu letenky: '); readln(letenka); write ('Zadej cenu poplatku: '); readln(poplatky); writeln('Celková cena letecké přepravy je: ', letenka + poplatky); readln; end.
■(03) program Pocet_cestujicich; {$APPTYPE CONSOLE} uses SysUtils; // deklarace proměnných var letenka_s, letenka_d, poplatky, stud, dos, cena: integer; begin write ('Zadej cenu studentské letenky: '); readln(letenka_s); write ('Zadej cenu zakladní letenky: '); readln(letenka_d); write ('Zadej cenu poplatku: '); readln(poplatky); write ('Zadej počet cestujících do 24 let - studentů: '); readln(stud); write ('Zadej počet cestujících nad 24 let: '); readln(dos); cena:= ((stud+dos)*poplatky) + (letenka_s*stud)+ (letenka_d*dos); writeln; writeln('Celková cena letecké přepravy je: ', cena); readln; end.
69
■(04) program Zpatecni_let; {$APPTYPE CONSOLE} uses SysUtils; var odkud, kam, pom: string;
// deklarace proměnných
begin writeln ('Odlet'); write ('Zadej místo odletu: '); readln(odkud); write ('Zadej místo příletu: '); readln(kam); // prohození hodnot proměnných pom:= odkud; odkud:=kam; kam:= pom; writeln; writeln ('Návrat z dovolené'); writeln ('Odlet: ', odkud); writeln ('Prilet: ', kam); readln; end.
■(05) program Vstupenky; {$APPTYPE CONSOLE} uses SysUtils; var vstupenka_s, vstupenka_z, stud, dos, cena: integer begin writeln('<<-- Výpočet ceny vstupného -->>'); writeln; write ('Zadej cenu studentské vstupenky: '); readln(vstupenka_s); write ('Zadej cenu zakladní vstupenky: '); readln(vstupenka_z); write ('Zadej počet navštěvníků do 24 let - studentu: '); readln(stud); write ('Zadej počet navštěvníků nad 24 let: '); readln(dos); cena:= (vstupenka_s*stud)+ (vstupenka_z*dos); writeln; writeln('Celková cena za vstupenky je: ', cena); readln; end.
■(06) program Zmrzlina; {$APPTYPE CONSOLE} uses SysUtils;
70
var kopecek, tocena, pocet_k, pocet_t : integer;
// deklarace proměnných
begin writeln('<<-- Výpočet ceny za zmrzlinu -->>'); writeln; write ('Zadej cenu jednoho kopečku zmrzliny: '); readln(kopecek); write ('Zadej počet kopečků: '); readln(pocet_k); write ('Zadej cenu jedné točené zmrzliny: '); readln(tocena); write ('Zadej počet točených zmrzlin: '); readln(pocet_t); writeln; writeln('Celková cena za kopečkovou zmrzlinu: ',kopecek * pocet_k); writeln('Celková cena za točenou zmrzlinu: ',tocena * pocet_t); readln; end.
71
