Programavimo Pradmenys 10 Kl.

1
Jonas Blonskis
Vytautas Buknaitis
Renata Burbait
IUOLAIKIKAS VILGSNIS
PROGRAMAVIMO PAGRINDUS
Informacini technologij vadovlis

pasirenkamajam kursui IXX klasse
2
Turinys
VADAS ............................................................................................................................................................................ 4
1.
PAGRINDINS STRUKTRINIO PROGRAMAVIMO SVOKOS.............................................................. 5
2.
PRAKTIKOS DARBAI........................................................................................................................................ 13
2.1.
VADAS FREE PASCAL TERP ............................................................................................................... 13
2.2.
ILAIDOS KAMBARIO REMONTUI ......................................................................................................... 20
2.3.
GROS ATIDAVIMAS MAIAUSIU BANKNOT IR MONET SKAIIUMI ................................ 24
2.4.
PIRAMID....................................................................................................................................................... 29
2.5.
ELEKTROS LAIDININKO VAROS SKAIIAVIMAS........................................................................... 37
2.6.
FUNKCIJOS APIBRIMO SRITIES TYRIMAS ..................................................................................... 41
2.7.
KVADRATINS LYGTIES SPRENDINI SKAIIAVIMAS................................................................... 46
2.8.
VAMPYRO SKAIIAI ................................................................................................................................... 49
2.9.
TRYS LAZDOS ............................................................................................................................................... 57
2.10.
TAIKINYS........................................................................................................................................................ 64
2.11.
ELEKTROS GRANDINS VAROS SKAIIAVIMAS ............................................................................ 71
2.12.
GRAFIKOS PRADMENYS............................................................................................................................ 77
2.13.
REKLAMINIAI URAAI GRAFINIAME EKRANE............................................................................... 81
2.14.
JUDESYS.......................................................................................................................................................... 84
2.15.
LAIKRODIS..................................................................................................................................................... 89
3.
PAGRINDINS PASKALIO KALBOS KONSTRUKCIJOS.......................................................................... 97
3.1.
KINTAMASIS, KINTAMOJO REIKM ................................................................................................... 97
3.2.
PRISKYRIMO SAKINYS .............................................................................................................................. 97
3.3.
DUOMEN VEDIMAS KLAVIATRA ..................................................................................................... 98
3.4.
REZULTAT (DUOMEN) IVEDIMAS EKRANE................................................................................. 99
3.5.
CIKLAS WHILE ............................................................................................................................................. 100
3.6.
CIKLAS FOR .................................................................................................................................................. 100
3.7.
SLYGOS SAKINYS IF............................................................................................................................... 101
3.8.
KNYGOJE NAUDOJAM IR REKOMENDUOJAM FUNKCIJ SRAAS................................... 102
3.9.
DUOMEN VEDIMAS I FAILO............................................................................................................. 102
3.10.
REZULTAT (DUOMEN) IVEDIMAS FAIL................................................................................. 103
3.11.
PROCEDROS.............................................................................................................................................. 104
3.12.
FUNKCIJOS .................................................................................................................................................. 104
3.13.
KNYGOJE NAUDOJAM IR REKOMENDUOJAM FUNKCIJ IR PROCEDR SRAAS... 105
4.
4.1.
KAI KURIE PRAKTIKOS DARBUOSE NAUDOJAMI ALGORITMAI ................................................... 107

TIESINIAI ALGORITMAI .......................................................................................................................... 107
3
4.2.
CIKLINIAI ALGORITMAI ......................................................................................................................... 107
4.3.
AKOTIEJI SKAIIAVIMAI. .................................................................................................................... 108
4.4.
SUMOS SKAIIAVIMO ALGORITMAS ................................................................................................. 110
4.5.
SANDAUGOS SKAIIAVIMO ALGORITMAS....................................................................................... 111
4.6.
KIEKIO SKAIIAVIMO ALGORITMAS................................................................................................. 112
4.7.
ARITMETINIO VIDURKIO SKAIIAVIMAS ........................................................................................ 113
4.8.
DIDIAUSIOS (MAIAUSIOS) REIKMS PAIEKA ......................................................................... 113
5.
UDUOTYS SAVARANKIKAM DARBUI .................................................................................................. 115
LITERATRA ............................................................................................................................................................. 120

NAUDINGOS NUORODOS ....................................................................................................................................... 120
4
Skaityk ne tam, kad prietarautum ir neigtum, ne tam,
kad ikart patiktum, ir ne tam, kad turtum apie k
kalbti, bet tam, kad mstytum ir svarstytum.
F. Bekonas
vadas
avdamiesi kompiuterio galimybmis daniausiai pamirtame, kad kompiuteris yra tik mogaus
sukurtos programos vykdytojas. Norint kompiuter efektyviai taikyti praktinje veikloje vien ini apie
kompiuterio darbo principus ir mokjimo dirbti taikomja programine ranga nebepakanka: pasitaiko problem,
kuri sprendimui paiam naudotojui reikia sugalvoti sprendimo keli (bd) ir parayti program. iuolaikins
taikomosios programos (pvz., skaiiuokl, tekst rengykl ir kt.) turi savo programavimo priemones, kurios
leidia iplsti j galimybes, pritaikyti jas konkreiai veiklos sriiai ar uduoiai sprsti. Programavimo inios,
gdiai ir gebjimas kurti nesudtingas programas yra labai naudingi bet kuriam kompiuterio naudotojui.
Imokti programuoti galima tik paiam kuriant programas. Todl mokymsi silome pradti nuo
praktikos darb. Knygos skyriuje Praktikos darbai rasite penkiolikos praktikos darb scenarijus. Jie visi
pateikiami FreePascal 0.6.4a versijoje. Kiekvienas scenarijus aprao, kaip ingsnis po ingsnio kuriama programa.
Labai svarbu prasti, paraius nors ir kelet programos eilui, skirt kokiam nors veiksmui atlikti, patikrinti
programos darb. Tik sitikinus, kad programa dirba ir ji dirba teisingai, galima j rayti toliau. Scenarijuose
vartojamos svokos ir terminai glaustai paaikinti knygos skyriuje Pagrindins struktrinio programavimo
svokos. J mokytis mintinai nra tikslo, taiau suvokti j prasm btina, norint skmingai dirbti su kitais
knygos skyriais, kita literatra.
Kiekvieno praktikos darbo pradioje rasite sra ini ir gebjim, kuriuos gysite atliekant t praktikos
darb. ia tai pat pateikiamos nuorodos skyri Pagrindins Paskalio kalbos konstrukcijos ir Kai kurie
praktikos darbuose naudojami algoritmai skyrelius. Skyriuje Pagrindins Paskalio kalbos konstrukcijos
pristatomos pagrindins Paskalio programavimo kalbos priemons ir konstrukcijos. Tai inyno pobdio
informacija. Skyriuje Kai kurie praktikos darbuose naudojami algoritmai apraomi klasikiniai algoritmai,
naudojami daugeliui vairaus tipo praktikos uduoi sprsti. i skyri informacija bus naudinga tiems, kas nors
pasitikslinti ar pagilinti inias ir gdius atliekant konkret praktikos darb.
Kiekvienas scenarijaus ingsnis tai tam tikra veikianios programos versija. Toks scenarij pateikimo
bdas leis kiekvienam mokiniui dirbti individualiai, mokytojui konsultuojant ar padedant, jei reikia. Atlikus
kiekvien darbo ingsn turime dirbani, bet dar nebaigt program. Darb galima tsti kit pamok arba
namuose nuo sekanio ingsnio.
Kiekvieno praktikos darbo pabaigoje gausu klausim ir uduoi, kurie pads kiekvienam sivertinti savo
inias ir gdius. Jie nra privalomi, taiau silome juos panagrinti ir atlikti. Jei kurie nors klausimai ar uduotys
yra per sunks, nepraleiskite j, pasistenkite juos veikti inagrinj teorin mediag, konsultuodamiesi su
mokytoju ar su klass draugais.
Pirmieji praktikos darb scenarijai yra pakankamai detals, vliau, programavimo gdiams ir inioms
tvirtjant, scenarijai nra tokie isams, paliekama daugiau laisvs saviraikai. Pirmieji ei praktikos darbai skirti
vadui programavim. Juos privalu atlikti. Kiti darbai skirti gautoms inioms ir gdiams tobulinti
programuojant sudtingesnes uduotis, todl nebtina j vis atlikti. Praktikos darb ciklas baigiamas paintimi
su Free Pascal grafikos priemonmis. ie darbai taip pat nra privalomi ir skirti tiems, kurie nori imokti gautus
rezultatus ekrane pateikti vaizdiai.
Mokiniams, jau turintiems pradinius programavimo gdius, alia praktikos darb silome individualiai
atlikti uduotis, pateiktas skyrelyje Uduotys savarankikam darbui. iems mokiniams taip pat bus naudingi
scenarij papildymai ir teorini skyreli mediaga, paymti odiu Smalsiems.
Besidomintiems programavimu knygos gale pateikiamas sraas nuorod, kurios leis rasti internete
daugiau informacijos rpimais klausimais.
Tikims, kad autori silomas programavimo pagrind mokymosi kelias bus jums domus, suprantamas
ir naudingas.
Skms!
Knygos autoriai
1. Pagrindins struktrinio programavimo svokos

1.1. Algoritmas, jo vykdymas, savybs
Kiekvienas i ms kasdieninje veikloje susiduriame su vairiomis taisyklmis, instrukcijomis, receptais,
nurodymais. Pavyzdiui, tai naudojimosi vairiais renginiais, bald surinkimo instrukcijos, patiekal
receptai, rali turmano legenda ir pan.
tai pavyzdys. Draugas kvieia jus sveius pasidalyti atostog spdiais. Jis
sako: ijs i nam pasuk dein, pajk iki artimiausios autobuso stotels, lipk
autobus Nr. 5, pavaiuok 3 stoteles, ilipk vaigdi stotelje. Ten tave
pasitiksiu.
Panaios apraymo taisykls sudaromos ir matematikos, fizikos, chemijos
udaviniams sprsti. Naudodamiesi jomis nesunkiai isprendiame vieno ar kito
tipo udavinius.
Mokydamiesi gimtj ir usienio kalbas imokstame pagrindines taisykles, kurias
taikydami, skmingai veikiame gramatikos subtilybes.
Ebu Abdullah Muhammed
Pateikti pavyzdiai yra skirtingo pobdio, taiau turi ir bendr bruo:
bin Musa al-Chwarizmi
(apie 780-850 m.)
juos galima aprayti atskirais aikiais nurodymais, k reikia daryti;
jie turi tam tikrus pradinius duomenis (pvz.: patiekalui pagaminti reikalingi produktai, spintos
sudedamosios dalys ir t. t.);
gaunamas tam tikras rezultatas (pagaminamas patiekalas, sukonstruojama spinta ir t. t.).
Ivardyti bruoai apibdina algoritmo (lot. algorithmus pagal Vidurins Azijos matematiko al-Chwarizmi
pavards lotynik form Algorithmi) svok. iuo atveju veiksmus, algoritmu vadovaujantis, atlieka
mogus.
Algoritmu vadinami aiks vienareikmiai nurodymai (sakiniai), kaip turint tam tikrus pradinius duomenis
gauti reikiamus rezultatus.
Algoritmo svoka yra viena i pagrindini matematikos ir informatikos svok. Pirmieji algoritmai
apibdino veiksmus, atliekamus su deimtains skaiiavimo sistemos skaiiais. Vliau algoritmo svoka
pradta vartoti apibdinant veiksm sek, kuri reikia atlikti norint isprsti udavin. ioje knygoje
nagrinjami tik matematinio pobdio algoritmai.
Pradiniai duomenys tai i anksto inomos reikms (paprasiausiu atveju skaiiai), btini veiksmams
atlikti. Pavyzdiui, norint apskaiiuoti staiakampio plot, btina inoti jo ilg ir plot.
Rezultatai tai skaiiavim metu gautos reikms.
Tarpiniai rezultatai tai skaiiavim metu gautos reikms, kurios naudojamos tolesniuose veiksmuose.
Jie taip pat reikalingi pasitikrinti, ar pilnai parayta programa, ar jos dalis, veikia gerai. Programos
naudotojui jie nra pateikiami.
Kiekvienas algoritmas skirtas tam, kad j kas nors vykdyt. Algoritme apraomi veiksmai yra skirti
vykdytojui. odio algoritmas reikm artima odi receptas, metodas, bdas reikmei.
Kiekvienam algoritmui bdingos tokios savybs:
Diskretikumas. Algoritmas suskaidomas baigtini veiksm (ingsni) sek. Tik atlikus vien
veiksm galima pereiti prie kito.
Aikumas. Visi algoritmu apraomi veiksmai turi bti suprantami vienareikmikai bet kuriuo
naudotojo. Algoritmas yra kuriamas nemstaniam vykdytojui. Kad suprasti, k reikia i svoka,
prisiminkime raytojo V. Petkeviiaus pasakos vaikams Sieksnis, Sprindio vaikas vien epizod.
Tvai, ileisdami sn mokykl, sako: Eidamas dairykis. Neskubk lkti per keli, palauk, kol
maina pravaiuos, kad po ratais nepaklitum. Vis dien Sieksnio i mokyklos nesulauks tvas
ijo jo iekoti ir prijs krykel pamat ilg pagriovy stovint ir garsiai liumbiant. Tvo
paklaustas, kas atsitiko, Sieksnis atr: Sakei, kad neskubiau, palaukiau, kol maina pravaiuos.
A vis dien laukiu, o jos kaip nr, taip nr. Ir mokykl t dien Sieksnis taip ir nenujo. Kit
6
dien tvas sn pats per krykel perved ir paleido: irk man, eik ir nesidairyk!. Sieksnis,
tiesiai eidamas, pirmiausiai maln prijo ir vis dien malnininkui talkino. Trei dien tvas pats
sn mokykl nutemp.
iame epizode Sieksn galime laikyti nemstaniu algoritmo vykdytoju, kuris tiesiogiai
(nemstydamas ir neanalizuodamas) vykd tvo nurodymus.
Rezultatyvumas. Atlikus baigtin algoritmo veiksm (ingsni) skaii turi bti gaunamas
rezultatas. Vienas i galim rezultat gali bti ir toks, kai udavinys neturi sprendini.
Baigtumas. Rezultat gauname vykd baigtin algoritmo komand skaii.
Universalumas. Naudojant algoritm galima sprsti visus to tipo udavinius, t. y. kiekvienam
pradini duomen rinkiniui gaunamas teisingas rezultatas.
Yra daug udavini, kuriems sprsti nra tiksli algoritm. Pavyzdiui, reikia perveti mainomis daug
vairaus dydio tui di, kurias galima dti vienas kitas. Main su kroviniu skaiius turi bti kuo
maesnis. Net mogus, kuris pasiymi galimybe intuityviai sprsti toki uduot, ne i karto gaus geriausi
rezultat. Jeigu di daug, o mainas telpa nevienodas di skaiius, tuomet nemanoma perrinkti vis
galim sprendini ir tenka pasitenkinti kuriuo nors geresniu rezultatu. Tokio tipo udaviniams sprsti
kuriami algoritmai, vadinami euristiniais. Taikant euristinius algoritmus tinkamu rezultatu laikomas tas,
kuris tenkina mogaus poreikius.
Kiekvienas algoritmas gali bti apraomas skirtingais bdais:
Algoritmo uraymas odiais taikomas tuomet, kai norima labai aikiai nurodyti atliekamus
veiksmus. Uraant algoritm iuo bdu komandos gali bti numeruojamos, arba veiksmai apraomi
kaip pasakojimas.
Algoritmo uraymas grafine forma yra daug vaizdesnis u odin apraym. Labiausiai paplit du
grafiniai algoritm vaizdavimo bdai: simbolins (blokins) schemos ir struktrogramos.
Simbolinse schemose ir struktrogramose naudojami grafiniai simboliai apibria tam tikro tipo
komand. Simbolinse schemose grafinius simbolius jungianios linijos rodo, kokia tvarka atliekami
veiksmai. Sutarta, kad linijos eina i viraus apai ir i kairs dein. Visais kitais atvejais linijos
gale braioma rodykl, nurodanti tolesni veiksm krypt. Struktrogramoje komand vykdymo
tvarka nusakoma paiais grafiniais simboliais.
Algoritmai gali bti uraomi pseudokodu. is bdas skirtas mogui. Pseudokode vartojami odiai,
artimi natraliai kalbai. Pseudokodas vartojamas algoritmams urayti ten, kur aikinama algoritmo
esm vadovliuose, straipsniuose, nes juo algoritm galima urayti trumpiau ir suprantamiau.
Pavyzdiui, skaiiaus a klimo n-tuoju laipsniu algoritmas uraytas:
odiu
1. Suinoti a ir n reikmes.
2. Skaiiuoti kartai = 1.
3. Skaiiuoti laipsnis = 1.
4. Jeigu kartai <= n, tuomet vykdyti 5 ingsn, kitaip 8 ingsnis.
5. Skaiiuoti laipsnis = laipsnis a.
6. Skaiiuoti kartai = kartai + 1.
7. Pereiti prie 4 ingsnio.
8. Rezultatas yra laipsnis reikm.
pseudokodu
vesti: a, n;
laipsnis := 1;
kartoti n kart
laipsnis := laipsnis a;
spausdinti: laipsnis.
grafine forma (simboline schema ir struktrograma)

Pradia
Pradia
vesti: a, n
vesti: a, n
laipsnis := 1
laipsnis := 1
k := 1
k := 1
kol k n
laipsnis := laipsnis * a
Ne
kn
k := k + 1
Taip
laipsnis := laipsnis * a
k := k +1
Spausdinti: laipsnis
Pabaiga
Spausdinti: laipsnis
Pabaiga
Daugelyje straipsni ir mokomj knyg algoritmams urayti naudojamas pseudo Paskalio programavimo
kalba, kuri nuo tikrosios skiriasi labai nedaug. Taip atsitiko, nes Paskalio programavimo kalba buvo kuriama
kaip galint panaesn nekamsias kalbas, tikintis, kad pradedantiems mokytis programuoti bus lengviau.
1.2. Programa, programavimo kalba, struktrinis programavimas
Algoritmas, uraytas kuria nors programavimo kalba, yra vadinamas programa.
Programavimo kalba skirta algoritmams urayti. Programavimo kalba artima nekamajai, nes ji skirta
programuotojui. Programavimo kalbos abcl skirta kalbos konstrukcijoms sudaryti: vardams, apraams,
sakiniams. Kalba, kaip ir nekamoji, turi savo sintaks ir semantik. Programavimo kalbos kiekvienos
konstrukcijos, kiekvieno odio, kiekvieno sakinio prasm vienareikm ir baigtin. Programavimo kalb
yra labai daug. Nuo pirmosios programavimo kalbos, sukurtos 1954 m., iki dabar yra suskaiiuojama per
2500 kalb.
ioje knygoje programoms kurti naudosime Paskalio programavimo kalb, kuri artima angl kalbai. Taiau
norime pabrti, kad pati programavimo kalba yra tik priemon programavimo gdiams susidaryti, bet ne
mokymosi tikslas. Stengiams naudoti tas konkreios kalbos konstrukcijas, kurios yra bendros ar analogikos
kitose programavimo kalbose.
Programavimas tai procesas, kuris apima iuos etapus:
uduoties parengim,
uduoties analiz,
uduoties skaidym dalis,
sprendimo metod parinkim bei sukrim,
duomen struktr parinkim bei sukrim,
algoritm sudarym,
8
programos teksto raym, derinim, testavim.
Struktrinio programavimo, dar kartais vadinamo procedriniu, pradia yra laikoma XX amiaus
atuntojo deimtmeio pabaiga. Struktrinio programavimo esm labai paprasta: skaldyk ir valdyk.
Kiekvienas udavinys iskaidomas smulkesnes dalis, kurios programuojamos kaip atskiri udaviniai.
Kiekviena t dali skirta vienai grietai apibrtai veiksm sekai atlikti.
Programavimo terp (aplinka) tai aparatini ir programini priemoni visuma, skirta nauj programini
priemoni krimui. Paprasiausios programavimo terps, pavyzdiui, Free Pascal kalbos, turi teksto rengykl
program tekst (ir duomen) fail krimui ir taisymui, kompiliatori, programos redaktori, priemones
programai derinti ir vykdyti. Program tekstus galima rayti ir kitomis priemonmis, pavyzdiui NotePad,
taiau terp turi papildom funkcij, kuri nra kitose tekst rengyklse. Kompiliatorius, tai programa, kuri
veria parayt programos tekst kompiuteriui suprantam kalb. Jeigu randa raybos (sintaksini) klaid
(angl. Error), tai vertim nutraukia nurodydamas rastas klaidas.
program Vardas;
1.3. Programos struktra
Programos struktr (sandar) nulemia programavimo kalba. Vienos kalbos
apraymai
yra grietos struktros, kitose yra leistinos alternatyvos. Programos struktrai turi
takos ir programavimo technologija.
begin
Vadovlyje pateiktos programos paraytos Paskalio programavimo kalba,
veiksmai
laikantis struktrinio programavimo technologijos reikalavim. Programos
end.
tekstas visada skirstomas dvi dalis:
naudojam priemoni (konstant, kintamj, nauj tip, naudojam bibliotek) apraymas;
veiksm sakiniai.
1.4. Programavimo stilius ir kultra

Kaip raytojams bdingas skirtingas literatrinis stilius, taip ir program autoriai turi individual
programavimo stili. Kiekvienas programuotojas ar programuotoj grup turi savit poir programavim,
mgstamas programavimo kalbas, naudoja skirtingai programavimo priemones. Programuotojo
individualyb ireikianius savitumus prasta vadinti programavimo stiliumi. ios knygos autoriai laikosi
toki esmini programavimo stiliaus princip:
kintamj apraai grupuojami pagal paskirt. Jei programoje yra procedr ar funkcij, pagrindins
programos kintamieji apraomi prie programos begin;
paprast kintamj (saugani skaii, simbol ar login reikm) vardai pradedami maja raide;
Paskalio kalbos baziniai odiai (program, var, begin, end ir pan.) visada raomi maosiomis
raidmis. ie odiai vartojami tik pagal Paskalio kalboje jiems suteikt prasm, t. y. nepervardijami;
kiekvienas odis programos, procedros ir funkcijos varde pradedamas didija raide (pvz.: ReadLn,
WriteLn);
kiekvienas programos sakinys baigiamas kabliatakiu.
jei programoje yra kuriama procedra ar funkcija, ji skirta vienam grietai apibrtam veiksmui
atlikti (pvz.: duomenims vesti, vidurkiams apskaiiuoti, rezultatui ivesti).
Programuojant sudting uduot, labai danai jos sprendimas padalijamas atskiras dalis, kurias realizuoja
skirtingi programuotojai. Todl kiekvienam i j svarbu parayti program tokiu bdu, kad j nesudtingai
suprast kiti, be to visas uduotis nesudtinga bt susieti, pataisyti arba panaudoti kitiems udaviniams
sprsti. Todl programos tekstas turi bti aikus, vaizdus, lengvai skaitomas ir suprantamas bet kuriam
naudotojui. Tekstas lengviau suprantamas, kai jis patogiai idstytas lape, eiluts neperkrautos informacija,
yra traukos, tarpai, komentarai.
Esmins programos teksto idstymo taisykls:
programos dalims iskirti paliekamos tuios eiluts arba komentar eiluts, sudarytos tik i minuso
ar kitoki simboli;
pavaldumui irykinti daromos traukos (pradedama rayti toliau nuo krato):

kartojimo sakiniuose,
sakini blokuose begin ... end;
skaitomumui pagerinti slygos sakinyje ir sakini bloke lygiuojami vertikaliai ie odiai:
then
else
begin
...
...
end
Kad programa bt aiki, lengvai ir greitai suvokiama bet kuriam naudotojui programos tekstas turi atitikti
login algoritmo struktr ir veiksm hierarchij. Raant program, reikt laikytis toki programavimo
kultros taisykli:
algoritm reikia parinkti tok, kad jis kuo geriau tikt duotam udaviniui sprsti, bt aikus,
trumpas ir logikai pagrstas;
tekst rayti laikantis bendr raybos taisykli. Tarp odi ir po skyrybos enklo palikti bent vien
tarp. Prie : ir := enklus reikt palikti tarp;
kintamj, konstant, tip, procedr, funkcij vardai turi atspindti juos atitinkani objekt
prasm, taiau neturi bti labai ilgi;
komentarai turi susieti udavinio apraym su algoritmu;
jei programoje naudojamos savarankikos algoritmo dalys, tai jos turi bti ireikiamos kuo maiau
tarpusavyje susijusiomis procedromis bei funkcijomis.
Tekst tikslinga rayti taip, kad atskiros dalys pagal prasm bt nesunkiai atpastamos ir suvokiamos. Tam
reikia j idstyti lape lyg kok piein, kur reikia paliekant didesnes traukas.
Pavyzdiui, itaip parayt tekst sunku skaityti:
var pirmas,antras,trecias:real;
begin
Read(pirmas,antras,trecias);
WriteLn(pirmas,antras,trecias);
...
end.
Patartume j rayti taip:

var
pirmas, antras, trecias : real;
begin
Read(pirmas, antras, trecias);
WriteLn(pirmas, antras, trecias);
...
end.
Danai programos tekst padeda suprasti komentarai, kurie skirti programos naudotojui (programuotojui) ir
visai neturi takos programos vykdytojui (kompiuteriu). Komentarai neturi trukdyti skaityti program, t. y. jie
turi bti trumpi, taikliai papildyti program, bet jos neugoti. Komentarai gali sudaryti apie 20 % visos
programos apimties.
Raant komentarus, rekomenduojama:
programos pradioje po antrate (arba prie j) nurodyti programos autori, paskirt, paskutinio
taisymo dat, versijos numer, taikymo sritis, uduoties sprendimo bd, programinius
apribojimus;
kintamj aprauose nurodyti j paskirt;
prie ciklus, procedras, funkcijas, sakini blokus nurodyti j paskirt;
paaikinti neaikios paskirties veiksmus, pavyzdiui, slygos sakinyje komentuoti atskirai then
ir else dalis;
10
jei komentarai uima atskir eilut, nuo programos teksto juos galima atskirti tuiomis
eilutmis.
Pavyzdiui, programos fragment sunku skaityti:
var
ugis1, ugis2: real; // mokini giai

metai1, metai2: integer; // mokini gimimo metai
amzius1, amzius2: integer;// mokini amiai
svoris1, svoris2: real; // mokini svoriai
Kad programa bt aikesn ir j bt lengviau skaityti, apraant kintamuosius reikt juos grupuoti pagal
prasm ir lyginti pagal pozicijas, o komentarus pateikti darant vienodas traukas. Anksiau pateikt
programos fragment silome rayti taip:
var
ugis1 :
metai1 :
amzius1:
svoris1:
ugis2 :
metai2 :
amzius2:
svoris2:
// Pirmojo
real;
//
integer;
//
integer;
//
real;
//
// Antrojo
real;
//
integer;
//
integer;
//
real;
//
mokinio duomenims:
giui,
gimimo metams,
amiui,
svoriui.
mokinio duomenims:
giui,
gimimo metams,
amiui,
svoriui.
Taisyklingai raydami, prarasime iek tiek laiko, taiau laimsime kur kas daugiau maiau padarysime
klaid, greiiau jas pastebsime.
1.5. Dialogas tarp programos ir naudotojo
Tarp naudotojo ir kompiuterio danai vykdomas dialogas. Pavyzdiui, vedant duomenis klaviatra, btina
ivesti ekran praneim, kad kompiuteris laukia duomen vedimo, paaikinti, k naudotojas turi vesti ir,
jeigu reikia, nurodyti vedimo form ir eils tvark. Pavyzdiui, toks programos fragmentas pareigoja laukti,
kol vesime vien skaii (taiau neaiku, realj ar sveikj):
...
WriteLn('veskite apskritimo spindul');
ReadLn(R);
...
Dialogo tekstas, praneimai, nurodymai turi bti lakoniki, informatyvs ir vienareikmikai suprantami.
Praneimai neturi bti susij su programos kintamj vardais, jeigu jie nra informatyvs, pavyzdiui:
...
WriteLn('veskite a reikm: ');
ReadLn(a);
...
...
WriteLn('veskite preks kain: ');
ReadLn(a);
...
Pirmajame dialoge neaiku, kas yra a. Antrajame dialoge aiku, jog reikia vesti preks kain, nebtina
inoti, kad kaina programoje turi vard a.
Projektuojant programos struktr, reikt atskirti dialogo ir skaiiavim dalis, nes j skirtingi tikslai.
Dialogas skirtas bendravimui su programos naudotoju, o skaiiavimai apdoroja duomenis. Dialogo tikslas
gauti tam tikr informacij. Jis gali bti danai keiiamas, pertvarkomas, papildomas. Tai gali bti susij ne
tik su kalbos tobulinimu, bet ir su technini galimybi pasikeitimu.
1.6. Bendras programos krimo planas
1. Pradini duomen ir bsim rezultat analiz. Isiaikinama, kiek yra pradini duomen, kiek bus
rezultat, kokie j tipai, kokia tvarka juos pateikti.
11
2. Udavinio sprendimo idja tai mintis (sumanymas), kaip sprsti udavin. Idjos teisingumu galima
sitikinti modeliuojant programos veiksmus su vairiais kontroliniais duomenimis. inoma, pirmiausia
reikia patikrinti idj su slygoje pateiktais duomenimis siekiant gauti rezultatus, sutampanius su
slygoje pateiktais rezultat pavyzdiais.
Jeigu modeliuojant negaunama reikiam rezultat arba paaikja, kad sprendimo kelias pernelyg
sudtingas, neracionalus, tai iekoma kito bdo udaviniui sprsti. Bt gerai, kad tik sitikinus, jog
sugalvotas sprendimo bdas teisingas, bt pradta rayti programa.
3. Duomen struktr parinkimas pradiniams duomenims ir rezultatams siminti. Nuo io ingsnio i
esms priklauso programos apimtis, struktra, algoritmas ir jo gyvendinimas.
4. Algoritmo sukrimas tai udavinio sprendimo idjos gyvendinimas. Daniausiai tam pritaikomi
inom matematini udavini sprendimo bdai naudojant konkreias duomen struktras. Algoritmo
sudtingumas paprastai priklauso nuo pasirinkt duomen struktr. Duomen struktros, tai
kompiuterio atmintins paskirstymo bdas duomenims saugoti. Jeigu iame etape paaikja, kad
algoritmas pernelyg sudtingas, tuomet reikia keisti duomen struktras arba net udavinio sprendimo
bd. Jei metodo nerandama, tuomet tenka sprsti uduot euristikai.
5. Programos raymas tai sukurto algoritmo uraymas konkreia programavimo kalba. Programa
raoma struktriniu principu (nedidelmis dalimis). Pageidautina kiekvien dal pirmiausia atskirai
suderinti, t. y. sitikinti, kad jau turima programos dalis duoda reikiamus rezultatus, dirba teisingai. Tai
leidia program rayti ingsnis po ingsnio. Kai derinamo teksto dalys nedidels lengviau ir greiiau
gaunama galutin programa.
6. Testavimas. Parayta programa testuojama, kad sitikintume, kad norimas rezultatas pasiekiamas
visiems galimiems teisingiems pradini duomen rinkiniams. Programuotojas turt sukurti kuo
vairesni pradini duomen rinkini, kurie tikrint prastas bei ribines situacijas, sprendimo efektyvum
atmintins kiekio ir vykdymo laiko poiriu. Jei pradini duomen rinkiniai turi bti dideli, gali tekti
parayti program, generuojani pradini duomen rinkinius. Atkreipiame dmes, kad tai btinas
programos raymo etapas, net ir per olimpiadas.
ie etapai nra atliekami nuosekliai. Kiekvienu momentu gali prireikti sugrti vienu ar keliais ingsniais
atgal. Nepatartina skubti, nes vliau gali tekti rayti program i naujo.
Programos naudotojui btinas apraymas, kaip naudotis programa. Aprayme paprastai pateikiama tokia
informacija:
programos paskirtis, jos panaudojimui btina aparatin ir programin ranga, diegimas (jeigu btina);
programos naudojimo instrukcija, kuri aprao programos vykdymo galimas situacijas;
pradini duomen pateikimo forma, kiek ir koki duomen reikia vesti;
rezultat paaikinimas, j susiejimas su pradiniais duomenimis.
1.7. Trumpa Paskalio ir C++ programavimo kalb atsiradimo istorija
Algoritmus galima urayti vairiomis programavimo kalbomis. Programavimo kalb sukurta labai daug ir
atsiranda vl nauj. Daugelio programavimo kalb pagrindins konstrukcijos yra panaios. Schemoje
pateikta populiari mokymuisi skirt Pascal ir C++ programavimo kalb supaprastinta trumpa atsiradimo
istorija. ia parykinti dviguba linija blokeliai rodo dabar vartojam mokymui Paskalio ir C++
programavimo kalb sukrimo datos. Nuo to laiko tos kalbos buvo modifikuojamos ir papildomos naujomis
galimybmis. Plaiau apie kalbas ir j istorija galite rasti internetiniame puslapyje, kuris pateiktas knygos
pabaigoje.
12
Fortran 1954.11
CLU 1974
Fortran I 1956.10
Pascal 1970
Modula 1975
Mesa 1977
IAL 1958
Algol 58 1958
Algol 60 1960
SimulaI 1964
C 1971
Pascal AFNOR 1983

Object Pascal 1985
Delphi 1995
Delphi2006 2005
Borland Turbo Pascal 1988
C++ 1983
13
2.
Praktikos darbai
2.1. vadas Free Pascal terp

Atlikdami darb susipainsite su terps Free Pascal darbo aplinka:
sukursite darbo katalog ir programos fail;
pakeisite programos pavadinim ir j raysite darbo kataloge;
sukompiliuosite ir vykdysite paprasiausi program;
program redaguosite ir papildysite;
imoksite ivesti informacij ekran naudodami raymo procedras Write ir WriteLn.
Nuorodos Paskalio kalbos inyn (psl.)
Nuorodos algoritm inyn (psl.)
3.1. Kintamasis, kintamojo reikm
94
4.1. Tiesinis algoritmas
103
3.2. Priskyrimo sakinys
94
3.3. Duomen vedimas klaviatra
95
3.4. Rezultat (duomen) ivedimas ekrane 96
Tai paintinis praktikos darbas. Atlikdami darb susipainsite su terps Free Pascal darbo aplinka:
meniu, program krimo principais: redagavimu, kompiliavimu, vykdymu, suinosite, kokie failai sukuriami
ir kaip juos isaugoti.
Atliekant praktikos darb svarbu ne apskaiiuoti kok nors konkret rezultat ar sukurti nurodyt
program, o tiesiog pajusti darbo Free Pascal aplinkoje ypatumus. Dirbdami galite atlikti ir daugiau
veiksm, negu ia parayta. Gal ne visi veiksmai bus skmingi, taiau gysite patirties, kuri bus reikalinga
atliekant kitus darbus.
Kiekviena Free Pascal programa sukuria kelet fail. Todl prie pradedant darb patariame sukurti
atskir katalog kiekvieno darbo failams saugoti.
Pirmas ingsnis. Darbo katalogo sukrimas.

prastomis Windows sistemos priemonmis kuriame nors savo kompiuterio diske sukurkite bendr
katalog, kuriame saugosite visus savo Free Pascal darbus. Katalog galite pavadinti savo pavarde,
pvz.: Pavardenis.
io katalogo viduje sukurkite katalog Darbas1, skirt ms pirmajam (vadiniam) darbui.
Antras ingsnis. Free Pascal terps paleidimas.

Norint pradti dirbti, reikia, kad kompiuteryje bt diegta kuri nors Free Pascal versija. Visi ios
knygos pavyzdiai sukurti naudojant Free Pascal 0.6.4a versij.
Pradios meniu pasirinkite komand Visos programos, suraskite ir pasirinkite FPS 0.6.4a.
arba nuorod
darbalaukyje.
14
Skmingai vykd komandas,
patenkate Free Pascal
terp (toliau FPS). Tai
Windows tipo langas su
pagrindiniu
meniu
ir
priemoni juostomis, kaip
tekst
rengyklje
ar
skaiiuoklje. Jei programos
langas uima ne vis ekran,
o tik jo dal, darbo lang
galima padidinti prastomis
priemonmis.
Treias ingsnis. Programos failo krimas.
Pagrindiniame
komandas:
meniu
parinkite
RinkmenaKurtiprogram.
Nauj programos fail taip pat

galima sukurti pasirinkus priemoni
juostos mygtuk
sparij
klavi
Ctrl+N.
arba
kombinacij
FPS aplinkoje atsiras kuriamos

programos rmai. FPS redaktoriaus
lange (Bevard0) bus raomas
programos tekstas.
Ketvirtas ingsnis. Programos vardo pakeitimas ir raymas kataloge Darbas1.
15
FPS redaktoriaus lange, po bazinio odio program, vietoj odio Bevard0 raykite od Darbas1.
Toks bus Js pirmosios programos vardas.
Toliau pagrindiniame meniu parinkite komandas:
Rinkmenarayti kaip...
Program rayti galima priemoni juostos

mygtukais
arba sparij
klavi deriniu Ctrl+S.
Pasirink norim bd, atsivrusiame
dialogo lange rayti kaip...
laukelyje Vardas vietoj vardo Bevard0
raykite failo, kuriame bus saugoma
sukurta programa, vard Darbas1, o
laukelyje Medis nurodykite anksiau
sukurt katalog Darbas1 ir paspauskite
mygtuk rayti. Programa bus rayta
kompiuterio standiajame diske.
Jeigu uraydami failo vard nenurodte prievardio .pas,
sistema paklausia, ar j urayti. inoma, reikia atsakyti
Taip, nes prievardis parodo, kad faile isaugota Pascal
programa.
Penktas ingsnis. Programos kompiliavimas 1.

Tai galima atlikti vienu i trij bd:
pagrindinio meniu komandomis: KompiliatoriusKompiliuoti;
programos priemoni juostos mygtuku

;
sparij klavi deriniu Ctrl+F9.

Jeigu programoje nebuvo sintakss klaid, ekrane
pasirodys
informacinis praneimas. Paspaud mygtuk Gerai patvirtiname, kad
susipainome su informacija apie skmingai sukompiliuot program.
Ibandykite visus tris programos kompiliavimo bdus ir pasirinkite
sau tinkamiausi.
Taiau norint pamatyti programos darbo rezultatus j dar reikia vykdyti.
etas ingsnis. Programos vykdymas.

Tai galima atlikti vienu i trij bd:
pagrindinio meniu komandomis DerinimasVykdyti;
;
paspaudiant klaviatros klavi F9.
Jeigu programoje nebuvo vykdymo klaid, ekrane pasirodys juodos spalvos programos naudotojo langas su
baltos spalvos tekstu: Labas.
Programavimo kalba paraytos programos vertimas kompiuterin kalb.
16
Kaip ir ankstesniame ingsnyje, kuris programos vykdymo bdas jums pasirodys geriausias, t toliau ir
naudokite.
Rezultat lang galima udaryti paspaudiant klaviatros klavi Enter arba gerai jums inom lang
. Neudar rezultat lango negalsite redaguoti programos.
valdymo mygtuk
gij pakankamai patyrimo nordami
paspartinti darb FPS aplinkoje penkt
ingsn galite ir praleisti. Prie
vykdant program, jeigu ji buvo
redaguota (keista ar papildyta), ji bus
i naujo sukompiliuota ir vykdyta, jei
ne tik vykdyta.
Iskleiskite darbo pradioje sukurt katalog Darbas1 ir pairkite, kiek ir koki fail buvo sukurta.
Svarbiausias failas yra Darbas1.pas, nes jame yra programos tekstas. fail reikia saugoti. I io failo
sukuriami kiti tokio paties pavadinimo failai Darbas1 su skirtingais prievardiais, bei kiti pagalbiniai failai.
Septintas ingsnis. Pakeiskite ankstesn program taip, kad j vykdius, alia odio Labas bt
uraytas ir Js vardas.
FPS programos tekste eilut WriteLn('Labas'); pakeiskite tokia:
WriteLn('Labas. Mano vardas Vytautas!');
Atlikus pakeitim programa bus tokia:
program Darbas1;
begin
ReadLn;
end.
ir vykdykite program, t. y. pakartokite penkt ir et ingsnius, arba tik et ingsn. vykd program
ekrane turtumte matyti:
Labas. Mano vardas Vytautas!
Atuntas ingsnis. Pakeiskite ankstesn program taip:

program Darbas1;
begin
WriteLn('********************************');
WriteLn('* Labas. Mano vardas Vytautas! *');
WriteLn('********************************');
ReadLn;
end.
vykd program ekrane turtumte matyti:

********************************
* Labas. Mano vardas Vytautas! *
********************************
Kaip pastebite, kiekvienas WriteLn sakinys, vykdant program ekrane urao po vien tarp apostrof
urayt eilut.
Programoje WriteLn pakeiskite Write.
Write('********************************');
17
Write('* Labas. Mano vardas Vytautas! *');
Write('********************************');
vykd program ekrane matote:

********************************* Labas. Mano vardas Vytautas! *****************
****************
Pastebjote, kad vietoj WriteLn paraius procedr Write, upildoma pirma eilut (eilutje telpa 80
simboli), po to pradedama pildyti antra eilut.
Papildykite program taip, kad prie vard ir po vardu bt spausdinamas i vaigdui sudarytas
ornamentas:
*
*
*
*
*
*
*
*
*** *** *** *** *** *** *** ***
*
*
*
*
*
*
*
*
* Labas. Mano vardas Vytautas! *
*
*
*
*
*
*
*
*
*** *** *** *** *** *** *** ***
*
*
*
*
*
*
*
*
Devintas ingsnis. Spalv keitimas.

Sukurkite program:
program Darbas1;
uses Crt;
begin
TextBackground (Red);
TextColor (Yellow);
ReadLn;
end.
Black = 0;
Blue = 1;
Green = 2;
Cyan = 3;
Red = 4;
Magenta = 5;
Brown = 6;
LightGray = 7;
DarkGray = 8;
LightBlue = 9;
LightGreen = 10;
LightCyan = 11;
LightRed = 12;
LightMagenta = 13;
Yellow = 14;
White = 15;
Blink = 128;
Nordami pakeisti rezultat ekrano spalvas, turjome prisijungti bibliotek Crt. Ji prijungiama sakiniu
uses Crt; Sakinys raomas antroje programos eilutje. Procedra TextBackground nurodo, kokia
bus teksto fono spalva, o TextColor kokia bus teksto spalva.
vykd program ekrane turtumte matyti geltonos spalvos tekst raudoname fone.
Pakeiskite teksto fono spalv ali (Green), o teksto spalv mlyn (blue).
Nordami, kad skirtingose eilutse uraytas tekstas ir/ar jo fonas bt skirtingos spalvos, spalvas btinai
apraykite prie WriteLn eilut. Pvz.:
program Darbas1;
uses Crt;
begin
TextBackground (Green);
TextColor(Blue);
TextBackground (Red);
TextColor(Yellow);
WriteLn('Viso gero.');
ReadLn;
end.
vykdykite i program. Tekstas 'Labas. Mano vardas Vytautas! bus mlynos spalvos aliame
fone, o tekstas Viso gero. Bus geltonos spalvos raudoname fone.
18
Deimtas ingsnis. Darbo su FPS pabaiga.
Tai galima atlikti pagrindinio meniu komandomis: RinkmenaBaigti darb (angl. FileExit)
arba paspaudiant FPS lango udarymo mygtuk
deiniajame virutiniame darbo lango kampe.
Raydami program ir baigdami darb FPS aplinkoje nepamirkite program rayti standiajame
kompiuterio diske. Tai galima atlikti vienu i trij bd:
pagrindinio meniu komandomis: Rinkmenarayti;

sparij klavi deriniu Ctrl+S.
Klausimai
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
K pirmiausiai reikia susikurti prie pradedant rayti program?

Kaip ikvieiama Free Pascal aplinka?
Kaip pradedama kurti nauja programa?
Kurioje vietoje raomas programos vardas?
Kokius veiksmus reikia atlikti norint rayti program kompiuterio standiajame diske pirm kart?
Kokiais bdais program galima sukompiliuoti?
Kokiais bdais program galima vykdyti?
Kokiais bdais program galima rayti standiajame diske?
Ar galima program vykdyti jos nesukompiliavus? Paaikinkite.
Kuo procedra WriteLn skiriasi nuo procedros Write?
Uduotys
1. Paraykite program, kuri ekrane (arba faile) i skirting spalv vaigdui nupiet Js vardo ir
pavards pirmj raidi derin.
2. Paraykite program, kuri ekrane nupiet js sugalvot ornament.
Smalsiems
Nordami darbo rezultatus matyti ne kompiuterio ekrane, o tekstiniame faile, tursite:
program papildyti failo kintamuoju,
prisijungti fail ir j susieti su failo kintamuoju,
parengti fail raymui,
rayti fail norim tekst,
udaryti tekstin fail.

Inagrinkite program ir pabandykite patys j sukurti ir paleisti vykdyti:
program Darbas1;
var Fr : text;
// Tekstinio failo kintamasis
begin
Assign(Fr, 'Darbas1.txt'); // Tekstinis failas Darbas1.txt susiejamas su failo kintamuoju
Rewrite(Fr);
// Failas parengiamas raymui
WriteLn(Fr, '********************************');
WriteLn(Fr, '* Labas. Mano vardas Vytautas! *');
WriteLn(Fr, '********************************');
Close(Fr);
// Failas udaromas
Readln;
end.
vykd program matysite tui juod ekran, nes visa informacija bus saugoma tekstiniame faile
Darbas1.txt, kuris yra sukuriamas tame paiame kataloge, kuriame saugomas ir programos failas.
19
Matome, kad raant procedr WriteLn, pirmiausiai uraomas failo kintamasis Fr, po to tarp apostrof
raomas tekstas, kur norsime matyti rayt tekstiniame faile.
Savo sukurt program papildykite, kad tekstas ir ornamentas, kurie buvo ivedami ekran, bt
spausdinami tekstin fail.
20
2.2. Ilaidos kambario remontui
Atlikdami darb isiaikinsite, kaip kuriama paprastus skaiiavimus atliekanti programa:
imoksite aprayti sveikojo ir realiojo tipo kintamuosius,
isiaikinsite, kaip perskaitomos ir simenamos kintamj reikms,
suprasite, kaip uraomi ir atliekami vairs skaiiavimai,
pritaikysite raymo procedras Write ir WriteLn rezultat ivedimui ekran.
94
103
94
95
Uduotis. inomi kambario imatavimai (metrais) ilgis ir plotis. Abu dydiai yra sveikieji skaiiai.
Reikia apskaiiuoti, koki pinig sum psuma kainuos ikloti kambario grindis plytelmis, jei plyteli vieno
kvadratinio metro kaina yra m2kaina lit. Plyteli reikia pirkti 5 % daugiau galimiems nuostoliams
padengti.
Udavinio sprendimo algoritmas:
skaiiuojamas kambario plotas;
skaiiuojama, koki pinig sum psuma kainuos plytels.

Aiku, kintamiesiems galima sugalvoti ir kitokius vardus, taiau geriausia, kai kintamj vardai atspindi j
paskirt. Tuomet j nereikia komentuoti.
Pirmas ingsnis. Pasiruoimas.

Kaip ir pirmajame darbe Darbas1 atlikite veiksmus:
sukurkite katalog programos failams saugoti: Darbas2;
ikvieskite FPS terp;
sukurkite programos fail;
suteikite programai vard Darbas2;
isaugokite fail sukurtame kataloge Darbas2 vardu
Darbas2.pas.
Antras ingsnis. Bandomasis programos kompiliavimas ir vykdymas.

Sukompiliuokite ir vykdykite program.
Kaip ir pirmajame darbe, programa tik pasisveikins, t. y. parays ekrane od Labas, taiau joki
skaiiavim neatliks.
Treias ingsnis. Programos pradini duomen apraymas ir vedimas.

Programos pradioje apraykite kambario imatavimus sauganius sveikojo tipo kintamuosius ilgis ir
plotis.
Pakeiskite sakin WriteLn('Labas'); nauju sakiniu
WriteLn('Programa darb pradjo.');
Paraykite kintamojo ilgis reikms vedimo klaviatra sakinius: praneimo, koki reikm vesti,
sakin Write ir reikms skaitymo sakin Readln.
Isaugokite ir vykdykite program.
program Darbas2;
21
var ilgis, plotis : integer;
// Kambario imatavimai
begin
Write('veskite kambario ilg: '); ReadLn(ilgis);
ReadLn;
end.
Paleid program, klaviatra surink skaii 5 ir

paspaud Enter klavi, ekrane matysite:
Programa darb pradjo.

veskite kambario ilg: 5
Paraykite kintamojo plotis reikms vedimo klaviatra sakinius: praneimo, koki reikm vesti,
sakin Write ir reikms skaitymo sakin ReadLn. Galite kopijuoti kintamojo ilgis reikms vedimo
sakinius ir vietoje kintamojo vardo ilgis parayti plotis.
program Darbas2;
begin
Write('veskite kambario plot: '); ReadLn(plotis);
Readln;
end.
Paleid vykdyti program, klaviatra surink skaii 5
ir skaii 4, bei paspaud po kiekvieno i j Enter
klavi, ekrane matysite:
veskite kambario plot: 4
Ketvirtas ingsnis. Papildomas programos kintamj,

skirt rezultatui kambario plotui saugoti, apraymas. Rezultat skaiiavimas ir rodymas ekrane.
Papildykite program nauju sveikojo tipo kintamuoju plotas.
Uraykite ploto skaiiavimo sakin: plotas := ilgis * plotis;
Ekrane spausdinkite apskaiiuot ploto reikm.
Programos pabaigoje prie sakin ReadLn; uraykite sakin
WriteLn('Programa darb baig.');

program Darbas2;
plotas : integer;
begin
Write('veskite kambario plot: '); ReadLn(plotis);
plotas := ilgis * plotis;
WriteLn('Kambario plotas: ', plotas);
ReadLn;
end.
22
Paleid program, klaviatra surink skaii 5 ir
skaii 4, bei paspaud po kiekvieno i j Enter
klavi, ekrane matysite:
Programa
veskite
veskite
Kambario
Programa
darb pradjo.
kambario ilg: 5
kambario plot: 4
plotas: 20
darb baig.
Penktas ingsnis. inodami kambario plot apskaiiuosime, kiek kainuos kambar ikloti plytelmis.
Plyteli reikia pirkti 5 % daugiau galimiems nuostoliams padengti. Dabar reikia apskaiiuoti, kiek jos
kainuos, kai inoma vieno m2 kaina. Pinig suma, skirta kambario remontui, gali bti skaiiuojama uraius
priskyrimo sakinius:
psuma := plotas * m2kaina + 0.05 * plotas * m2 kaina;
arba
psuma := 1.05 * plotas * m2kaina;
Papildykite program tokiais Paskalio kalbos sakiniais:

kintamj m2kaina ir psuma apraymu:
// Plyteli 1 kvadratinio metro kaina
// Pinig suma
Kaip pastebjote, ie kintamieji turi bti realaus tipo (real), nes plyteli kain sudaro dvi dalys: sveikoji
m2kaina : real;
psuma
: real;
(litai) ir trupmenin (centai).

plyteli kainos skaiiavimais:
Write('veskite plyteli 1 kvadr. metro kain: '); ReadLn(m2kaina);
psuma := 1.05 * plotas * m2kaina;
WriteLn('Pinig suma, kuri reikia sumokti: ', psuma:6:2);
Isaugokite ir vykdykite program su pateiktais pradiniais duomenimis:

veskite kambario plot: 4
Kambario plotas: 20
veskite plyteli 1 kvadr. metro kain: 45.50
Pinig suma, kuri reikia sumokti: 955.50
Programa darb baig.
Klausimai
1. Koks bazinis Paskalio programavimo kalbos odis yra naudojamas sveikojo tipo kintamiesiems
aprayti?
2. Koks bazinis Paskalio programavimo kalbos odis yra naudojamas realiojo tipo kintamiesiems
aprayti?
3. Apraykite du sveikojo tipo kintamuosius: mokinio amius (metai) ir mas (kilogramai).
4. Apraykite realiojo tipo kintamj: mokinio gis (metrai).
5. K reikia raktinis odis var, kam jis naudojamas ir kurioje programos vietoje jis raomas?
6. Kokie du sakiniai naudojami kintamojo reikmei vesti? Uraykite pavyzd kintamojo greitis
reikmei vesti.
7. Ar galima vienu sakiniu ReadLn vesti kelias kintamj reikmes? Jeigu galima, uraykite pavyzd.
8. Kam programos pabaigoje reikalingas sakinys ReadLn;?
23
Uduotys
1. Paraykite program, skaiiuojani, kiek lap popieriaus k reiks visos klass mokini
konspektams nukopijuoti, jei inomas klass mokini skaiius n ir kiek lap m sudaro konspekt.
Pasitikrinkite: ved n = 20 ir m = 10, turtumte gauti k = 200.
2. Laikrodis rodo x valand ir y minui. Paraykite program, kuri apskaiiuot kiek minui m ir
kiek sekundi s prabgo nuo vidurnakio. Programoje naudokite sveikj skaii tip longint
(dideliems sveikiesiems skaiiams).
Pasitikrinkite: ved x = 3 ir y = 5, turtumte gauti: m = 185, s = 11100.
3. iandien Tautvydas venia gimtadien. Jam sukanka a met. Paraykite program, kuri
apskaiiuot kiek mnesi men, dien d ir valand v Tautvydas jau pragyveno iame pasaulyje.
Programoje naudokite sveikj skaii tip longint. Sprsdami udavin laikykite, kad metai turi
365 dienas. Pasitikrinkite: ved a = 16 turtumte gauti: men = 192, d = 5840, v = 140160.
4. Paraykite program, skaiiuojani, kiek knyg k vidutinikai per metus perskaito vienas mokyklos
bibliotekos lankytojas, jei bibliotekinink pateik vidutin per vien mnes perskaityt knyg
skaii v ir vidutin bibliotekos lankytoj skaii n per metus. Sprsdami udavin naudokite
standartin Paskalio funkcij Round, kuri suapvalins knyg skaii iki sveikojo skaiiaus.
Pasitikrinkite: ved v = 120, n = 800, turtumte gauti k = 2.
5. Paraykite program, skaiiuojani, kiek keleivi k vidutinikai vaiuoja viename traukinio vagone
Vilni, jei inomas traukinio keleivi skaiius n, keleivi, vykstani ne Vilni skaiius nv ir
vagon skaiius v. Sprsdami udavin naudokite standartin Paskalio funkcij Round, kuri
suapvalins keleivi skaii iki sveikojo skaiiaus. Pasitikrinkite: ved n = 100, nv = 20 ir v = 4,
turtumte gauti k = 20.
6. Paraykite program, skaiiuojani staiakampio, kurio virutinio kairiojo tako (x1; y1) ir apatinio
deiniojo tako (x2; y2) koordinats yra sveikieji skaiiai vedami klaviatra, plot s ir perimetr p.
Staiakampio kratins lygiagreios koordinai aims. Pasitikrinkite: kai x1 = 0, y1 = 5, x2 = 4, y2
= 0, turi bti spausdinama: Staiakampio plotas s = 20 kvadr. vnt., staiakampio perimetras p = 18
vnt.
7. Takai A (x1;y1) ir B (x2; y2) yra atkarpos galai. J koordinats vedamos klaviatra. Atkarpa AB
yra skritulio skersmuo. Paraykite program, skaiiuojani skritulio plot s ir jo centro koordinates
xc ir yc. Pasitikrinkite: kai x1 = 0, y1 = 0, x2 = 0, y2 = 4, turi bti spausdinama: Skritulio plotas s
= 12.57 kvadr. vnt., skritulio centro koordinats: xc = 0, yc = 2.
8. Paraykite program, kuri sukeist kintamj x ir y reikmes vietomis. Raant program negalima
naudoti papildom kintamj. Pasitikrinkite: kai x = 0, y = 5, turi bti spausdinama: Sukeit x ir y
reikmes vietomis, gauname: x = 5, y = 0.
9. inomas laikas, ireiktas sveikaisiais skaiiais: m, s (ia m minuts ir 0 < m 59, s sekunds ir
0 < s 59, be to m s). Paraykite program, kuri kompiuterio ekrane spausdint, kok kamp ms
(skaiiuojant pagal laikrodio rodykl) sudaro minui ir sekundi rodykls ir kiek maiausiai
laiko minutmis tm ir sekundmis ts turi praeiti, kol laikrodio minui ir sekundi rodykls sutaps.
Pasitikrinkite: kai m = 12, s = 15, turi bti spausdinama: Kampas tarp minui ir sekundi
rodykli ms = 18 laipsni. Kad rodykls sutapt, turi praeiti tm = 0 minui (-s) ir ts = 58
sekundi (-s).
24
2.3. Gros atidavimas maiausiu banknot ir monet skaiiumi
Atlikdami darb isiaikinsite sveikj skaii dalmens sveikosios dalies ir liekanos skaiiavim:
imoksite tinkamai urayti sveikj skaii dalybos operacijas;
tvirtinsite kintamj apraymo, tinkamo pradini duomen vedimo ir rezultat pateikimo
gdius.
94
103
94
95
Uduotis. Parduotuvje pardavja nori pirkjui gr g Lt (g sveikasis skaiius) atiduoti maiausiu 1, 2, 5
Lt nominalo monet ir 10, 20, 50 ir 100 Lt banknot skaiiumi. Reikia apskaiiuoti, kiek kokio nominalo
monet ir banknot pardavja turs atiduoti pirkjui.
pirmiausiai imame didiausio nominalo banknot (100 Lt) ir gr g daliname i 100 ir
skaiiuojame sveikj dalmens dal. Gautas rezultatas yra 100 Lt nominalo banknot skaiius
k100;
nordami apskaiiuoti, kokia pinig suma liko nepanaudota, galime gr g dalinti i 100 ir
apskaiiuoti dalmens liekan. Tai bus nauja gra g. Likusi gros g dalis gali bti skaiiuojama ir
kitaip: g = g - k100 * 100;
pirmuosius du veiksmus kartojame su vis nominal monetomis ir banknotais.
Pavyzdiui, jei pardavja pirkjui turi atiduoti g = 75 Lt gr, tai jai reiks vieno 50 Lt, vieno 20 Lt
banknot ir 5 Lt monetos.
Pirmas ingsnis. Pasiruoimas.

Kaip ir antrajame darbe Darbas2 atlikite veiksmus:
sukurkite katalog programos failams saugoti: Darbas3;
ikvieskite FPS terp;
sukurkite programos fail;
suteikite programai vard Darbas3;
isaugokite fail sukurtame kataloge Darbas3 vardu Darbas3.pas.
Antras ingsnis. Programos kintamj pradini duomen apraymas ir vedimas.

Programos pradioje apraykite sveikojo tipo kintamj g, kuris reikia pirkjo gr.
Paraykite kintamojo g reikms vedimo klaviatra sakinius: praneimo, koki reikm vesti, sakin
Write ir reikms skaitymo sakin ReadLn.
program Darbas3;
var g : integer;
begin
Write('veskite pirkjo gr: '); ReadLn(g);
Readln;
end.
25
Paleid program, klaviatra surink skaii 75 ir paspaud klavi Enter, ekrane matysite:
veskite pirkjo gr: 75
Treias ingsnis. Papildomas programos kintamj, skirt rezultatams kiekvieno nominalo banknot ar
monet skaiiui sraas. Rezultat skaiiavimas ir rodymas ekrane.
Papildykite program naujais sveikojo tipo kintamaisiais k100, k50, k20, k10, k5, k2 ir k1,
skirtais kiekvieno nominalo banknot ar monet skaiiui saugoti.
Uraykite priskyrimo sakin, skaiiuojant, kiek reiks 100 Lt nominalo banknot k100 grai atiduoti:
k100 := g div 100;
Uraykite priskyrimo sakin, skaiiuojant, kokia pinig suma g liks, atidavus k100 100 Lt banknot:
g := g mod 100;
arba
g := g - k100 * 100;
Toliau raome priskyrimo sakinius, skaiiuojanius 50, 20, 10, 5, 2 ir 1 Lt nominalo banknot ar monet
skaii.
program Darbas3;
var g : integer;
k100, k50, k20, k10, k5, k2, k1 : integer;
begin
k100 := g div 100; g := g mod 100;
k50 := g div 50; g := g mod 50;
k20 := g div 20; g := g mod 20;
k10 := g div 10; g := g mod 10;
k5
:= g div 5;
g := g mod 5;
k2
:= g div 2;
g := g mod 2;
k1
:= g;
ReadLn;
end.
Programos pabaigoje prie sakin ReadLn paraykite rezultat spausdinimo ekrane sakinius:
WriteLn('Pardavja gr atiduos taip:');
WriteLn('-----------------------------');
WriteLn('100 Lt ------ ', k100);
WriteLn(' 50 Lt ------ ', k50);
WriteLn(' 20 Lt ------ ', k20);
WriteLn(' 10 Lt ------ ', k10);
WriteLn(' 5 Lt ------ ', k5);
WriteLn(' 2 Lt ------ ', k2);
WriteLn(' 1 Lt ------ ', k1);
WriteLn('-----------------------------');

Paleid program, klaviatra surink skaii 75, ekrane matysite:
26
Pardavja gr atiduos taip:

----------------------------100 Lt ------ 0
50 Lt ------ 1
20 Lt ------ 1
10 Lt ------ 0
5 Lt ------ 1
2 Lt ------ 0
1 Lt ------ 0
-----------------------------
Uduotys
1. Apskaiiuokite reikini reikmes:
a. 17 mod 3 + 7 div 3 * 2 =
b. 17 mod (3 + 7) div 3 * 2 =
c. 17 mod (3 + 7 div 3) *2 =
d. 1 + 49 mod 5 + 6 div 3 =
e. (1 + 49) mod 5 6 div 3 =
f.
1 + 49 mod (5 + 7) div 3 =
g. 19 mod 8 + 7 div 3 =
h. 19 mod (8 + 7 div 3) =
2. Nurodykite i reikini rezultat tipus:

a. 123 + 45 + 5678
b. 49 + (12.5 1) * 3
c. 73/2 * 2
d. 72 div 2 + 1.05
e. 100 div 5 + 700 - 25/5
3. Nuo met pradios prajo d dien. Paraykite program, skaiiuojani, kiek savaii s prajo nuo
met pradios. Pasitikrinkite: kai d = 15, turi bti spausdinama: Nuo met pradios prajo s = 2
savaii (-s).
4. Miesto informatikos olimpiadoje dalyvavo n devintok. Mokytoja nupirko m saldaini Nomeda ir
idalino mokiniams po lygiai. Padalinus saldaini neliko arba liko maiau, negu yra mokini. Po
kiek saldaini s gavo kiekvienas mokinys ir kiek saldaini k liko mokytojai? Paraykite program
iam udaviniui sprsti. Pasitikrinkite: kai n = 7 ir m = 23, tai kiekvienas mokinys gavo po s = 3
saldainius, o mokytojai liko k = 2 saldainiai.
5. vsdamas septintj gimtadien Andrius gavo n balion. Su draugais nusprend balionus paleisti
dang. Taiau juos puiant k balion sprogo. Likusius balionus Andrius pasidalino su d draugais po
lygiai. Jeigu dalinant balionus visiems po lygiai j liko, tai juos pasim Andrius. Po kiek balion m
gavo kiekvienas draugas ir kiek balion a teko Andriui? Paraykite program iam udaviniui
27
sprsti. Pasitikrinkite: kai n = 77, d = 7 ir k = 3, tai kiekvienas draugas gavo po m = 9 balionus, o
Andriui teko a = 14 balion.
6. Lktuvas pakilo i aerouosto, kai buvo A valand ir B minui. Lktuvas ore praleido C minui.
Paraykite program, kuri nustatyt, kiek bus valand V ir minui M, kai lktuvas nusileis.
Atkreipkite dmes, kad C reikm gali bti didel ir lktuvas gali leistis ne t pai par. Paraykite
program iam udaviniui sprsti. Pasitikrinkite: kai A = 23, B = 55, C =14, tai lktuvas leisis V = 0
valand ir M = 9 minuts.
7. Nubrauktas trienklio skaiiaus x antrasis skaitmuo. Kai likusiam dvienkliam skaiiui i kairs
buvo priraytas nubrauktasis skaitmuo, tuomet buvo gautas skaiius n (10 < n 999, be to skaiiaus n
deimi skaitmuo nelygus nuliui). Paraykite program, kuri apskaiiuot, kokia buvo x reikm,
kai n reikm vedama klaviatra. Pasitikrinkite: kai n = 135, turi bti spausdinama: Trienklis
skaiius x = 315.
Smalsiems
Nordami sutrumpinti sukurt gros skaiiavimo program, pasikartojanius veiksmus banknot ar
monet kiekio, neatiduotos gros likuio skaiiavim, kiekvieno nominalo banknot ar monet kiekio
spausdinim kelsime savarankik programos dal procedr.
I pagrindins programos procedr kreipsims su skirting nominal pinigais.
Procedros tekstas raomas programos pradioje po programos antrate. Labai patogu nuo pagrindins
programos procedr atskirti komentaru, pvz., brkneli ar vaigdui eilute.
Uraykite programos antrat ir komentar:
program Darbas3;
//------------------------------------------------------- Raome procedr Graza. Procedros antratje skliausteliuose apraysime tris sveikojo tipo
kintamuosius: kintamasis k kokio nominalo banknot ar monet skaiius skaiiuojamas, kx kiek k
nominalo pinig yra, g kokia gra dar liko neatiduota. Kintamieji kx ir g raomi su odeliu var, nes
pagrindin program turi bti grinamos apskaiiuotos j reikms. Apraant kintamuosius btina
nurodyti j tip. Procedros visuje paraykite priskyrimo sakinius kx ir g reikmms skaiiuoti ir raymo
sakin, skirt k nominalo pinig skaiiaus spausdinimui.
procedure Graza(k : integer; var kx : integer; var g : integer);
begin
kx := g div k; g := g mod k;
WriteLn(k : 3, ' Lt ------ ', kx);
end;
Po procedra paraykite skiriamj komentar (brkneli eil), apraykite pagrindins programos

kintamuosius:
//-------------------------------------------------------var g : integer;
k100, k50, k20, k10, k5, k2, k1 : integer;
Pagrindinje programoje paraykite pradini duomen vedimo sakinius ir du pirmuosius rezultat
spausdinimo sakinius:
begin
WriteLn('-----------------------------');
Toliau raysime kreipinius procedr Graza:
Graza(100, k100, g);
Graza(50, k50, g);
28
Graza(20, k20, g);
Graza(10, k10, g);
Graza(5, k5, g);
Graza(2, k2, g);
Graza(1, k1, g);
Paraykite paskutin raymo sakin: WriteLn ('-----------------------------');

Pasitikrinkite, ar teisingai sukrte program:
program Darbas3;
//-------------------------------------------------------procedure Graza(k : integer; var kx : integer; var g : integer);
begin
kx := g div k; g := g mod k;
WriteLn(k : 3, ' Lt ------ ', kx);
end;
//-------------------------------------------------------var g : integer;
k100, k50, k20, k10, k5, k2, k1 : integer;
begin
WriteLn('-----------------------------');
Graza(100, k100, g);
Graza(50, k50, g);
Graza(20, k20, g);
Graza(10, k10, g);
Graza(5, k5, g);
Graza(2, k2, g);
Graza(1, k1, g);
WriteLn('-----------------------------');
ReadLn;
end.
Pardavja gr atiduos taip:
vykdykite program, vesdami 75. Jei visk atlikote
----------------------------teisingai, ekrane turtumte matyti:
100 Lt ------ 0
50 Lt ------ 1
Tikriausiai pastebjote, kad naudojant procedr
20 Lt ------ 1
programa tapo paprastesn: nebereikia kartoti t pai
10 Lt ------ 0
sakini po kelis kartus, daug lengviau surasti ir itaisyti
5 Lt ------ 1
klaidas.
2 Lt ------ 0
Savarankikos programos dalys labai palengvina
1 Lt ------ 0
udavini sprendim, leidia iskaidyti udavin dalimis,
----------------------------atskiras dalis gali kurti ne vienas mogus.
29
2.4. Piramid
Atlikdami darb isiaikinsite, kaip kuriama ciklinius skaiiavimus atliekanti programa, kai i anksto
neinoma, kiek kart reiks kartoti veiksmus:
imoksite urayti neinomo kartojim skaiiaus ciklo antrat,
isiaikinsite, kaip uraomi cikle atliekami veiksmai,
suprasite, kaip skaiiuojama suma ir kiekis,
imoksite skaiiavim rezultatus spausdinti lentelje.
94
103
94
4.2. Ciklinis algoritmas
103
95
3.5. Ciklo sakinys while
96
Uduotis. I plyt galima pastatyti vienos plytos ploio taisykling piramid, kurios virnje yra viena
plyta, o onuose puss plytos ilgio laipteliai. Paraykite program, skaiiuojani, kokio ilgio a bus
piramids pagrindas ir keli plyt k aukio bus piramid, jei pradinis duomuo yra piramids statybai skirt
plyt skaiius p.

Paveiksllyje vaizduojamos piramids pagrind a sudaro 4 plytos, piramids auktis k = 4 plytos, piramidei
pastatyti reikjo p = 10 plyt. Sprsdami udavin inosime bendr plyt skaii p, o a ir k reikmes
tursime apskaiiuoti.
Skaiiuosime piramids statybai panaudot plyt skaii s, kuris gaunamas prie jau buvusios s
reikms pridedant naujos eils plyt skaii a.
Nauja a reikm gaunama didinant esam a reikm vienetu, nes kiekvienoje naujoje eilje yra
viena plyta daugiau negu prie tai buvusioje.
Nauja k reikm gaunama senj k reikm didinant vienetu, nes pridjus nauj eil, eili skaiius
padidja viena nauja eile.
Pradin s reikm yra lygi nuliui. Skaiiuojam s reikm lyginsime su piramids statybai skirt
plyt skaiiumi p. Kai s ir p reikms susilygins, veiksmai bus baigiami.
Lentelje pavaizduota, kaip keiiasi kintamj a, k ir s reikms, atliekant veiksmus, kol s reikm maesn
u p reikm.
Pradins kintamj reikms: a = 0, k = 0, s = 0, p = 10.
a = a + 1
k = k + 1
s = s + a
Ciklo ingsniai Slyga: s < p
1
2
3
4
5
0 < 10
1 < 10
3 < 10
6 < 10
10 < 10
a
a
a
a
=
=
=
=
0
1
2
3
+
+
+
+
1
1
1
1
=
=
=
=
1
2
3
4
k
k
k
k
=
=
=
=
0
1
2
3
+
+
+
+
1
1
1
1
=
=
=
=
1
2
3
4
s
s
s
s
=
=
=
=
Veiksmai neatliekami, nes netenkinama slyga s
0
1
3
6
<
+
+
+
+
p
1
2
3
4
=
=
=
=
1
3
6
10
30
Pirmas ingsnis. Pasiruoimas. Sukurkite katalog Darbas4, skirt programos failams saugoti,
ikvieskite FPS terp, sukurkite programos fail ir suteik programai vard Darbas4 raykite fail
sukurtame kataloge Darbas4 vardu Darbas4.pas.
Antras ingsnis. Programos pradini duomen apraymas ir vedimas.

Programos pradioje apraykite programoje naudojamus kintamuosius: p - piramidei statyti skirt plyt
skaiius, a - piramids pagrindo ilgis, k - piramids auktis, s - piramids statybai panaudot plyt
skaiius:
var p
s
a
k
:
:
:
:
integer;
integer;
integer;
integer;
//
//
//
//
Piramids statybai skirt plyt skaiius

Piramids statybai panaudot plyt skaiius
Piramids pagrindo ilgis
Piramids auktis
Paraykite kintamojo p reikms vedimo klaviatra sakinius: praneimo, koki reikm vesti, sakin
Write ir reikms skaitymo sakin Readln.
program Darbas4;
var p : integer;
s : integer;
a : integer;
k : integer;
begin
Write('Kiek plyt
ReadLn;
end.
//
//
//
//
Piramids statybai skirt plyt skaiius

Piramids statybai panaudot plyt skaiius
Piramids pagrindo ilgis
Piramids auktis
skirta piramids statybai?: '); ReadLn(p);

Kiek plyt skirta piramids statybai?: 10
Treias ingsnis. Suteikiamos kintamiesiems a, k ir s pradins reikms.

Papildykite program trimis priskyrimo sakiniais:
a := 0; k := 0; s := 0;
Papildykite program sakiniais, skirtais a, k ir s reikmi spausdinimui:
program Darbas4;
var p : integer; // Piramids statybai skirt plyt skaiius
s : integer; // Piramids statybai panaudot plyt skaiius
a : integer; // Piramids pagrindo ilgis
k : integer; // Piramids auktis
begin
Write('Kiek plyt skirta piramids statybai?: '); ReadLn(p);
a := 0; k := 0; s := 0;
WriteLn('Piramids pagrindo ilgis: ', a);
WriteLn('Piramids auktis: ', k);
WriteLn('Piramids statybai panaudot plyt skaiius: ', s);
ReadLn;
end.
31
Piramids pagrindo ilgis: 0
Piramids auktis: 0
Piramids statybai panaudot plyt skaiius: 0
Ketvirtas ingsnis. Ciklo sakinio antrat. Veiksmai cikle. Kadangi ciklo sakinyje bus kartojami keli
veiksmai, jie turi bti raomi tarp bazini odi begin ir end. Toks sudtinis sakinys baigiamas
kabliatakiu.
Po kintamj a, k ir s pradini reikmi apraymu uraykite ciklo sakin:
while s <
begin
a :=
k :=
s :=
end;
p do
a + 1;
k + 1;
s + a;
Papildyta programa bus tokia:

program Darbas4;
begin
a := 0; k := 0; s := 0;
while s < p do
begin
a := a + 1;
k := k + 1;
s := s + a;
end;
ReadLn;
end.

Piramids auktis: 4
Penktas ingsnis. Skaiiavim tarpini reikmi spausdinimas. Nordami sitikinti, kad programa
skaiiuoja teisingai, galite spausdinti ne tik galutinius, bet ir tarpinius skaiiavim rezultatus.
32
Sudtin sakin, nurodant, kokie veiksmai bus atliekami ciklo viduje papildykite kintamj a, k ir s
reikmi spausdinimo sakiniais ir sakiniu, atskirianiu vien kartojim nuo kito vaigdutmis:
while s < p do
begin
a := a + 1;
k := k + 1;
s := s + a;
WriteLn('a = ', a);
WriteLn('k = ', k);
WriteLn('s = ', s);
WriteLn('**********');
end;

a = 1
k = 1
s = 1
**********
a = 2
k = 2
s = 3
**********
a = 3
k = 3
s = 6
**********
a = 4
k = 4
s = 10
**********
Piramids auktis: 4
etas ingsnis. Skaiiavim rezultat spausdinimas lentelje.

Nordami programos skaiiavim rezultatus spausdinti lentelje, papildysime program WriteLn
sakiniais:
program Darbas4;
begin
WriteLn('Programa, skaiiuojanti piramids pagrindo ilg, aukt');
WriteLn(' ir statybai panaudot plyt skaii');
WriteLn('*******************************************************');
a := 0; k := 0; s := 0;
WriteLn('--------------------------------------------------');
33
WriteLn('Pagrindo ilgis
Auktis Panaudot plyt skaiius');
WriteLn('--------------------------------------------------');
while s < p do
begin
a := a + 1;
k := k + 1;
s := s + a;
WriteLn(a : 5, k : 15, s : 20);
end;
WriteLn('--------------------------------------------------');
ReadLn;
end.
Sakiniai apibriantys programos paskirt:

WriteLn('Programa, skaiiuojanti piramids pagrindo ilg, aukt');
WriteLn(' ir statybai panaudot plyt skaii');
WriteLn('*******************************************************');
Sakiniai formuojantys lentels antratin eilut:

WriteLn('--------------------------------------------------');
WriteLn('Pagrindo ilgis
WriteLn('--------------------------------------------------');
Sakinys, spausdinantis ciklo viduje apskaiiuotas kintamj a, k ir s reikmes:
WriteLn(a : 5, k : 15, s : 20);
iame sakinyje spausdinamos formatuotos kintamj reikms: kintamajam a skirtos 5 pozicijos,

kintamajam k 15 pozicij, kintamajam s 20 pozicij. Pavyzdiui, jei kintamojo a reikm yra lygi 1, tai
i reikm spausdinama 5 pozicijoje, o keturios pozicijos i kairs paliekamos tuios. Analogikai
spausdinamos ir kit kintamj reikms.
Sakinys, formuojantis lentels paskutin eilut:
WriteLn('--------------------------------------------------');

Programa, skaiiuojanti piramids pagrindo ilg, aukt
ir statybai panaudot plyt skaii
*******************************************************
-------------------------------------------------Pagrindo ilgis
Auktis Panaudot plyt skaiius
-------------------------------------------------1
1
1
2
2
3
3
3
6
4
4
10
-------------------------------------------------Piramids pagrindo ilgis: 4
Piramids auktis: 4
34
Septintas ingsnis. Tikrinimas, ar programa visada pateikia teisingus rezultatus.
Paleid vykdyti program veskite p reikm, lygi 8. vykd program gaunate t pat rezultat, kaip ir
ved p reikm, lygi 10. Pastebime, kad rezultatas yra neteisingas, nes piramids statybai panaudota
daugiau plyt, negu skirta.
Pakeiskite ciklo antratje slyg s < p salyga p - s >= a + 1 ir vykdykite program su p
reikme, lygia 8. Ekrane turtumte matyti:
Programa, skaiiuojanti piramids pagrindo ilg, aukt
ir statybai panaudot plyt skaii
*******************************************************
-------------------------------------------------Pagrindo ilgis
Auktis Panaudot plyt skaiius
-------------------------------------------------1
1
1
2
2
3
3
3
6
-------------------------------------------------Piramids pagrindo ilgis: 3
Piramids auktis: 3
Patikslinus ciklo antrats slyg, programa pateikia teisingus rezultatus su visomis kintamojo p
reikmmis.
Klausimai
1.
2.
3.
4.
5.
Jeigu plyt liko nepanaudot, tai kiek? Papildykite program skaiaivimais, kiek liko plyt.
Kaip vykdomas kartojimas ciklo sakinyje while?
K daryti, kad ciklas nebt begalinis?
Kaip urayti ciklo sakin, kai norima kartoti daugiau sakini?
Kurie i emiau pateikt ciklo sakini, kai a = -3, yra begaliniai ir kodl?
a) while a < 0 do
begin
WriteLn ('argumentas neigiamas');
a := a + 1;
end;
b) while a < 0 do;
begin
WriteLn('argumentas neigiamas');
a := a + 1;
end;
c) while a < 0 do
a := a + 1;
d) while a >= 0 do
a := a + 1;
35
Uduotys
1. Martynas labai mgsta saldainius. Mamos slptuvje berniukas rado m saldaini. Pirm dien jis suvalg
1 saldain, antr 2, trei 3 ir kiekvien tolesn dien suvalgydavo vienu saldainiu daugiau negu prie
tai buvusi. Per kelias dienas d Martynas suvalgys visus saldainius? Paskutinei dienai gali likti maiau
saldaini. Pasitikrinkite: kai m = 11, turime gauti tok rezultat: d = 5.
2. PALKANOS. Pristigo mogus pinig ir nujo pasiskolinti j i prekybininko. Tas sutiko paskolinti,
bet papra grinti juos kit mnes itaip: pirmj mnesio dien 1 lit, antrj du litus, treij
keturis litus, t. y. kiekvien dien du kartus daugiau negu prie tai buvusi. T dien, kai skola gals bti
padengta, reiks atiduoti ir vis tos dienos norm. Tai, kas bus atiduota viraus, ir bus prekybininko
palkanos.
Uduotis. Paraykite program, kuri suskaiiuot, kiek palkan litais gaus prekybininkas u paskolintus
n lit. (13 olimpiada, 2002).
3. Bankas u indlius moka p procent palkan per metus. Met gale palkanos pridedamos prie indlio.
Jei indlininkas pinig n kiek neiima, palkanos skaiiuojamos nuo vis didesns sumos. Paraykite
program, kuri apskaiiuot, per kiek met t, pradinis indlis ind pasieks sum s. Pasitikrinkite: kai p
= 5, ind = 1000, s = 1200, rezultatas t = 4.
4. Turime kompiuter, kuris nemoka skaiiuoti natralij skaii dalmens sveikosios dalies ir liekanos
(nra DIV ir MOD dalybos operacij). Paraykite program, kuri apskaiiuot skaii n ir m dalmens
sveikj dal dalmuo ir liekan liekana. Pasitikrinkite: kai n = 14, m = 3, turime gauti tokius
rezultatus: dalmuo = 4, liekana = 2.
5. Paskalyje nra funkcijos, skirtos realiojo skaiiaus x klimui sveikuoju laipsniu k. Paraykite program
iam udaviniui sprsti. Rezultat y spausdinkite dviej enkl po kablelio tikslumu. Pasitikrinkite: kai
x = 5, k = 2, rezultatas y = 25.00.
6. PLYTELI DLIOJIMAS. I n kvadratini plyteli reikia sudlioti vienos plytels storio kvadrat
eil. Pirmiausia sudedamas didiausias galimas kvadratas. I likusi plyteli vl didiausias ir t. t.
Uduotis. Paraykite program, kuri iskaidyt duot plyteli skaii dalis, reikalingas kiekvieno kvadrato
statybai. Pavyzdiui, kai n = 75, tai rezultatas turi bti: 64, 9, 1, 1. (11 olimpiada, 2000).
Testo nr.
Pradinis duomuo
Rezultatai
1 1 1
Paaikinimai
35
25 9 1
89
81 4 4
149
144 4 1
225
225
Pradinis duomuo yra kvadratas
32767
32761 4 1 1
Maksimali pradinio duomens reikm
Kvadratai atskiros plytels

Trys atsitiktinai parinkti didjantys testai
Smalsiems
Nordami, kad piramids statybos rezultatai bt isaugoti tekstiniame faile, programoje Darbas3.pas
atlikite pakeitimus:
program Darbas4;
36
var p : integer;
// Piramids statybai skirt plyt skaiius
s : integer;
// Piramids statybai panaudot plyt skaiius
a : integer;
// Piramids pagrindo ilgis
k : integer;
// Piramids auktis
Fr : text;
// Tekstinio failo kintamasis
begin
Assign(Fr, 'Darbas3.txt'); // Failo kintamasis Fr susiejamas su failo vardu Darbas4.txt
Rewrite(Fr);
// Failas parengiamas raymui
WriteLn(Fr, 'Programa, skaiiuojanti piramids pagrindo ilg, aukt');
WriteLn(Fr, ' ir statybai panaudot plyt skaii');
WriteLn(Fr, '*******************************************************');
a := 0; k := 0; s := 0;
WriteLn(Fr, '--------------------------------------------------');
WriteLn(Fr, 'Pagrindo ilgis
WriteLn(Fr, '--------------------------------------------------');
while p - s >= a + 1 do
begin
a := a + 1;
k := k + 1;
s := s + a;
WriteLn(Fr, a : 5, k : 15, s : 20);
end;
WriteLn(Fr, '--------------------------------------------------');
WriteLn(Fr, 'Piramids pagrindo ilgis: ', a);
WriteLn(Fr, 'Piramids auktis: ', k);
WriteLn(Fr, 'Piramids statybai panaudot plyt skaiius: ', s);
Close(Fr);
// raius visus rezultatus failas udaromas
ReadLn;
end.
37
2.5. Elektros laidininko varos skaiiavimas
Atlikdami darb isiaikinsite, kaip kuriama ciklinius skaiiavimus atliekanti programa, kai inoma, kiek
kart bus kartojami veiksmai:
imoksite urayti inomo kartojim skaiiaus ciklo antrat,
isiaikinsite, kaip uraomi cikle atliekami veiksmai,
prisiminsite, kaip skaiiuojama suma,
imoksite tinkamai ivesti apskaiiuot realiojo tipo rezultat.
94
103
94
103
95
96
Uduotis. Elektros laidinink sudaro n nuosekliai sujungt laidinink, kuri varos yra r1, r2, ..., rn
om. Reikia apskaiiuoti grandins var r.

Tarkime, kad elektros grandin sudaro n = 4 nuosekliai sujungti laidininkai, kuri varos yra r1 = 2, r2
= 4, r3 = 1, r4 = 4. Grandins vara skaiiuojama sumuojant vis laidinink varas. inodami
laidinink skaii n ir kiekvieno laidininko var rlaid, grandins var r galime rasti pagal pagal
algoritm, kurio veiksmai kartojami n kart. Prie pradedant vykdyti veiksmus, btina inoti n reikm, o
kintamojo r pradin reikm yra lygi nuliui. Atliekami tokie pasikartojaantys skaiiavimai:
vedama laidininko vara rlaid;
skaiiuojama grandins vara r = r + rlaid;
Lentelje pavaizduota, kaip atliekami veiksmai:
Ciklas vykdomas
vedama i-tojo
Skaiiuojama grandins
i-tj kart
laidininko vara
vara r = r + rlaid;
1
2
3
4
2
4
1
4
Skaiiavim rezultatas: r = 11.
r = 0 + 2 = 2
r = 2 + 4 = 6
r = 6 + 1 = 7
r = 7 + 4 = 11
Pirmas ingsnis. Pasiruoimas. Sukurkite katalog Darbas5, skirt programos failams saugoti,
ikvieskite FPS terp, sukurkite programos fail ir suteik programai vard Darbas5 raykite fail
sukurtame kataloge Darbas5 vardu Darbas5.pas.
Antras ingsnis. Programos pradini duomen apraymas ir vedimas.

Programos pradioje apraykite programoje naudojamus kintamuosius: n - laidinink skaiius,
rlaid - laidininko vara, r - grandins vara, i - inomo kartojim skaiiaus ciklo parametras.
var
n
i
rlaid
r
:
:
:
:
integer;
integer;
real;
real;
//
//
//
//
Laidinink skaiius
inomo kartojim skaiiaus ciklo parametras
Laidininko vara
Elektros grandins vara
Paraykite kintamojo n reikms vedimo klaviatra sakinius: praneimo, koki reikm vesti, sakin
Write ir reikms skaitymo sakin ReadLn.
program Darbas5;
var
n : integer;
// Laidinink skaiius
38
i : integer; //
rlaid : real;
//
r : real;
//
begin
Write('Kiek laidinink
ReadLn;
end.
inomo kartojim skaiiaus ciklo parametras

Laidininko vara
Elektros grandins vara
yra elektros grandinje?: '); ReadLn(n);

Kiek laidinink yra elektros grandinje?: 4
Treias ingsnis. Apraoma pradin kintamjo r reikm.

Papildykite program priskyrimo sakiniu:
r := 0;
Papildykite program sakiniu, skirtu r reikms spausdinimui:
program Darbas5;
var
n : integer; // Laidinink skaiius
i : integer; // inomo kartojim skaiiaus ciklo parametras
rlaid : real;
// Laidininko vara
r : real;
// Elektros grandins vara
begin
Write('Kiek laidinink yra elektros grandinje?: '); ReadLn(n);
r := 0;
WriteLn('Elektros grandins vara: ', r : 6 : 2);
ReadLn;
end.

Elektros grandins vara:
0.00
Sakinyje WriteLn('Elektros grandins vara: ', r : 6 : 2); apskaiiuota elektros

grandins vara spausdinama skiriant reikmei 6 pozicijas, i kuri dvi paskutins pozicijos skiriamos
trupmeninei daliai. Pradedama spausdinti i deins kair. Takui, kuris atskiria trupmenin dal nuo
sveikosios, taip pat skiriama viena pozicija.
Ketvirtas ingsnis. Ciklo sakinio antrat. Veiksmai cikle. Kadangi ciklo sakinyje bus atliekami keli
veiksmai, jie turi bti raomi tarp bazini odi begin ir end. Toks sudtinis sakinys baigiamas
kabliatakiu.
Po kintamojo r pradins reikms apraymo uraykite ciklo sakin:
for i := 1 to n do
begin
Write('veskite laidininko var: '); ReadLn(rlaid);
r := r + rlaid;
end;
Papildyta programa bus tokia:
39
program Darbas5;
var
n : integer; // Laidinink skaiius
i : integer; // inomo kartojim skaiiaus ciklo parametras
rlaid : real;
// Laidininko vara
r : real;
begin
Write('Kiek laidinink yra elektros grandinje?: '); ReadLn(n);
r := 0;
for i := 1 to n do
begin
Write('veskite laidininko var: '); ReadLn (rlaid);
r := r + rlaid;
end;
ReadLn;
end.

veskite laidininko var:
I eils veskite kiekvieno laidininko varas: 2, 4, 1, 4. Po kiekvieno vedimo paspauskite Enter

klavi. ved varas ekrane matysite:
veskite laidininko var: 2
Elektros grandins vara: 11.00
Uduotys
1. Elektros grandin sudaro n lygiagreiai sujungt laidinink, kuri varos yra r1, r2, ..., rn om.
Paraykite program, skaiiuojani grandins var r. Pasitikrinkite, kai n = 4, o r1 = 2, r2 = 4, r3 = 1,
r4 = 4, turi bti spausdinama: Elektros grandins vara r = 0.50 om.
2. Klasje mokosi n mokini. Kiekvieno mokinio gis yra u1, u2, ..., un centimetr. Paraykite
program, skaiiuojani vidutin klass mokini g uvid. Pasitikrinkite, kai n = 5, o u1 = 179, u2 =
180, u3 = 178, u4 = 179, u5 = 175, turi bti spausdinama: Vidutinis klass mokinio gis uvid = 178.20
cm.
3. achmat iradjas i valdovo papra tokio atlygio: ant pirmojo achmat lentos langelio padk vien
grd, ant antrojo du, ant treiojo keturis ir t.t. vis dvigubink, kol pasibaigs langeliai. Valdovas tik
nusijuok ir paliep atseikti grd. Kiek grd gaus achmat iradjas? achmat lentoje yra 64
langeliai. Paraykite program iam udaviniui sprsti. Udaviniui sprsti panaudokite real duomen
tip rezultatao reikmei saugoti.
40
Smalsiems
Jei pradini duomen yra labai daug, tai j vedimas klaviatra reikalauja daug laiko, padarius klaid tenka
visk kartoti i naujo. Daug patogiau bt pradinius duomenis perskaityti i tekstinio failo. Papildysime
elektros grandins varos skaiiavimo program duomen skaitymu i tekstinio failo.
Tekstinis failas sukuriamas komandomis Rinkmena Kurti tekstin rinkmen. Atsivrusio
lango pirmoje eilutje raykite skaii 4, kuris reikia laidinink skaii, antroje eilutje raykite
keturi laidinink varas, vien nuo kitos atskirdami tarpais: 2 4 1 4. Ekrane turtumte matyti:
4
2 4 1 4
Sukurt fail raykite kataloge Darbas5 pavadindami j Darbas5.txt.

Papildykite ir pakeiskite sukurt program Darbas5.pas:
program Darbas5;
var n : integer;
// Laidinink skaiius
i : integer;
// inomo kartojim skaiiaus ciklo parametras
rlaid : real;
// Laidininko vara
r : real;
Fd : text;
// Pradini duomen failo kintamasis
begin
Assign(Fd, 'Darbas4.txt');
// Pradini duomen failo kintamasis susiejamas su failo vardu
Reset(Fd);
// Tekstinis failas parengiamas skaitymui
ReadLn(Fd, n);
// Perskaitomas pirmoje failo eilutje esantis skaiius. Tai n reikm
r := 0;
for i := 1 to n do
begin
Read(Fd, rlaid);
// Skaitomi tolesni skaiiai. Skaitymas baigiamas, kai perskaitoma n reikmi
r := r + rlaid;
end;
Close(Fd);
// Pradini duomen failas udaromas
ReadLn;
end.
vykd program ekrane matysite:
Elektros grandins vara:
11.00
Kaip pastebjote, skaitymas i failo yra labai panaus duomen vedim klaviatra. Skaitant duomenis
i failo nebereikia rayti sakini, kuriais praoma vesti pradines kintamj reikmes.
Jei pirmoje failo eilutje raytas laidinink skaiius n, o likusiose n eilui
laidinink varos po vien eilutje, tuomet pradini duomen failas bus toks:
4
2
4
1
4
Norint, kad laidinink var reikms bt perskaitytos tinkamai, sakin Read(Fd, rlaid);
utenka pakeisti sakiniu ReadLn(Fd, rlaid); Sakinys Read skaito reikmes iki eiluts pabaigos,
o ReadLn perskaito kreipinyje nurodyt reikmi kiek ir persikelia kit eilut.
41
2.6. Funkcijos apibrimo srities tyrimas
Atlikdami darb imoksite tinkamai urayti slygos tikrinimo sakin.
94
103
94
103
95
4.3. akotas skaiiavimas
104
96
3.7. Slygos sakinys if
97
3.8. Funkcij sraas
99
Uduotis. Apskaiiuoti funkcijos y =
m +3
m 2 100
reikm, kai mp m mg ir kinta ingsniu mz. ia
mp, mg, mz reals skaiiai.

Komentaras. Atkreipkite dmes, kad trupmenos vardiklis negali bti lygus nuliui, o poaknis neigiamas.
Pasiruoimas. Sukurkite katalog Darbas6 programos failams saugoti, atverkite FPS terp ir sukurkite
programos fail Darbas6.pas.
Pirmas ingsnis. Pradini duomen vedimas klaviatra.

Pradiniai duomenys:
mp funkcijos argumento m pradin reikm;
mg funkcijos argumento m galin (paskutin) reikm;
mz funkcijos argumento m kitimo ingsnis.
Paraykite dialogo sakinius, skirtus kintamj mp, mg, mz reikmi vedimui klaviatra.
program Darbas6;
var mp, mg, mz : real;
begin
Write('veskite argumento pradin reikm: '); ReadLn (mp);
Write('veskite argumento galin reikm:
'); ReadLn (mg);
Write('veskite argumento ingsnio reikm: '); ReadLn (mz);
ReadLn;
end.
Isaugokite ir vykdykite program su tokiais pradiniais duomenimis: mp = -50, mg = 50, mz =
10. Ekrane turt bti rodomi tokie rezultatai:
veskite argumento pradin reikm: -50
veskite argumento galin reikm: 50
veskite argumento ingsnio reikm: 10
Antras ingsnis. Funkcijos reikmi skaiiavimas ir spausdinimas ekrane. Papildykite program

sakiniais:
WriteLn ('Funkcijos reikmi skaiiavimas');
WriteLn ('mp = ', mp:5:2, ' mg = ', mg:5:2, ' mz = ', mz:5:2);
m := mp;
while m <= mg do
begin
if m * m - 100 > 0
// Tikrinama slyga, ar m priklauso funkcijos apibrimo sriiai
// Jei slyga tenkinama, skaiiuojama funkcijos reikm
then y := (m + 3) / (Sqrt (m * m - 100));
42
WriteLn(m:7:2, y:12:3);
m := m + mz;
end;
Isaugokite ir vykdykite program su tokiais pradiniais duomenimis: mp = -50, mg = 50, mz =

10. Ekrane turt bti rodomi tokie rezultatai:
Funkcijos reikmi skaiiavimas
mp = -50.00 mg = 50.00 mz = 10.00
-50.00
-0.959
-40.00
-0.955
-30.00
-0.955
-20.00
-0.981
-10.00
-0.981
0.00
-0.981
10.00
-0.981
20.00
1.328
30.00
1.167
40.00
1.110
50.00
1.082
Treias ingsnis. Rezultat analiz.

Inagrinkite gautus rezultatus. Kai m = -40.00 ir m = -30.00, funkcijos y reikms yra lygios
-0.955. Patikrinkite skaiiuotuvu, skaiiuodami 0,00001 tikslumu. Kai m = -40.00, turtumte gauti
y = 0.95534, kai m = -30.00, y = 0.95459. Raydami rezultat ivedim ekran pasirinkome
rodyti tris skaitmenis trupmeninje dalyje, todl ir gavome sutampanius rezultatus.
Pakeiskite spausdinimo sakin taip, kad rezultatas ekran bt ivedamas su 5 skaitmenimis
trupmeninje dalyje. Jei visk atlikote teisingai, vykd program ekrane turtumte matyti rezultatus:

mp = -50.00 mg = 50.00 mz = 10.00
-50.00
-0.95938
-40.00
-0.95534
-30.00
-0.95459
-20.00
-0.98150
-10.00
-0.98150
0.00
-0.98150
10.00
-0.98150
20.00
1.32791
30.00
1.16673
40.00
1.11026
50.00
1.08186
Patikslin rezultatus pastebime, kad esant argumento m reikmms -20.00, -10.00, 0.00 ir 10.00,
y reikm yra lygi -0.98150. Tokius rezultatus gavome todl, kad argumento reikms -10.00, 0.00
ir 10.00 netenkina slygos m * m - 100 > 0. Funkcijos reikms spausdinamos vykdius slygos
sakin. Jeigu slyga netenkinama, tuomet spausdinama paskutin apskaiiuota y reikm.
43
Ketvirtas ingsnis. Tinkamas skaiiavimo rezultat pateikimas.
Nordami gauti teisingus rezultatus visoms argumento m reikmms, funkcijos reikmi spausdinim
kelsime slygos sakinyje atliekamus veiksmus. Jei argumento m reikm nepriklauso funkcijos
apibrimo sriiai, tuomet vietoj funkcijos reikms spausdinsime septynis vaigdui (*) simbolius.
Slygos sakinio akas papildykite rezultat spausdinimo sakiniais:
if m * m - 100 > 0
then
begin
y := (m + 3) / (Sqrt (m * m - 100));
WriteLn(m:7:2, y:12:5);
end
else WriteLn(m:7:2,'*******':12);
Isaugokite ir vykdykite program. Jei

visk atlikote teisingai, vykd program
ekrane turtumte matyti rezultatus:

mp = -50.00 mg = 50.00 mz = 10.00
-50.00
-0.95938
-40.00
-0.95534
-30.00
-0.95459
-20.00
-0.98150
-10.00
*******
0.00
*******
10.00
*******
20.00
1.32791
30.00
1.16673
40.00
1.11026
50.00
1.08186
Penktas ingsnis. Skaiiavimo rezultat pateikimas lentelje.
Papildykite program taip, kad argumento

ir funkcijos reikms bt spausdinamos
lentelje.
Funkcijos reikms nuo -50.00 iki 50.00

----------------------m
y
-----------------------50.00
-0.95938
-40.00
-0.95534
-30.00
-0.95459
-20.00
-0.98150
-10.00
*******
0.00
*******
10.00
*******
20.00
1.32791
30.00
1.16673
40.00
1.11026
50.00
1.08186
-----------------------
44
Klausimai
1. Kokios bus sveikojo tipo kintamj x ir y reikms atlikus sakini sek?
a) x := 5;
b) x := 3;
c) x := 6;
if x > 4
then y := x + 3
else y := x - 3;
if x <> 3
then y := x + 3;
x := x + 2;
y := x + 2;
d) x := 2;
if x < 0
then y := x - 3
else
begin
x := x + 2;
y := x + 3;
end;
e)
x := 1;
if x > 0
then
begin
y := x
x := x
end
else
begin
x :=
y :=
end;
f)
- 3;
+ 2;
x + 2;
x + 3;
if x <= 8
then
begin
x := x + 2;
y := x + 3;
end
else y := x - 3;
x := 1;
if x = 0
then
begin
y := x - 3;
x := x + 2;
end
else
begin
x := x + 2;
y := x + 3;
end;
2. Kas bus rodoma ekrane atlikus programos fragment? Koki slyg tikrina slygos sakinys?
for x := 10 to 15 do
if x mod 2 <> 0
then WriteLn (x);
4. Funkcijos reikmi skaiiavimui uraytas slygos sakinys. Nubraiykite funkcijos grafik.

if x < 5
then y := x + 3
else y := x - 2;
7. Remdamiesi funkcij grafikais uraykite, kaip skaiiuojamos funkcij y = f (x) reikms. 1 langelis
atitinka 1 vienet.
a)
b)
Atlikdami uduot uraykite matematines funkcij iraikas.
Uduotys
1. viesoforas veikia pagal tok algoritm: kiekvienos valandos pradioje tris minutes dega alia viesa,
po to dvi minutes raudona, po to vl tris minutes alia ir t.t. inoma, kiek minui t (t sveikasis
skaiius) prajo nuo valandos pradios. Paraykite program, kuri nustatyt, kokia viesoforo spalva
dega. Pasitikrinkite: kai t = 12, tuomet spausdinama: Dega alia viesa. Kai t = 13, tuomet
45
spausdinama: Dega alia viesa, tuoj degs raudona. Kai t = 5, tuomet spausdinama: Dega raudona
viesa, tuoj degs alia.
2. Geleinkelio stotys A, B ir C yra n-tajame, m-tajame ir p-tajame geleinkelio ruoo kilometruose.
Paraykite program, kuri surast, tarp kuri stoi atstumas yra maiausias. Stotys nebtinai
vardytos abcls tvarka, pavyzdiui, po stoties A gali sekti stotis C. Pasitikrinkite: kai n = 3, m =
8, p = 15, turi bti spausdinama: Atstumas maiausias tarp A ir B stoi. Kai n = 3, m = 9, p = 15,
turi bti spausdinama: Atstumai maiausi tarp AB ir BC stoi. Kai n = 3, m = 15, p = 9, turi bti
spausdinama: Atstumai maiausi tarp AC ir BC stoi.
3. Osvaldas nori savait slidinti viename i trij kurort. Kurorte A slidinjimo sezonas prasideda
lapkriio, o baigiasi balandio mnes, bet dl lavin pavojaus vis sausio mnes slidinti negalima.
Kurorte B slidinti galima nuo gruodio pradios iki kovo pabaigos, taiau vasario 1-15 dienomis
jame vyksta varybos. Kurorte C slidininkai laukiami nuo lapkriio pradios iki gegus pabaigos.
Poilsio kaina kiekviename kurorte, vertinant ir kelions ilaidas, atitinkamai yra k1, k2, k3 lit.
inodami atostog pradios dat (mnes m ir dien d) nustatykite, ar Osvaldas gals atostogauti
bent viename kurorte ir jeigu taip, tai kur kurort jam rinktis, kad ileist maiausiai pinig.
Pasitikrinkite: kai m = 2, d = 5, k1 = 500, k2 = 520, k3 = 499, turi bti spausdinama: Osvaldas
gals slidinti C kurorte. Jam reiks 499 Lt.
4. Pateikiamas dviej natralij skaii a ir b didiausio bendrojo daliklio (DBD) paiekos algoritmo,
dar vadinamo Euklido 2 algoritmu, odinis apraymas. Paraykite program iam udaviniui sprsti.
Euklido algoritmas:
1. Pradiniai duomenys natralieji skaiiai a ir b.
2. Jei skaiiai yra lygs, tai bet kuris i j yra DBD ir veiksmai toliau neatliekami, jei ne atliekami
tolesni veiksmai.
3. Nustatoma, kuris skaiius yra didesnis.
4. Didesniojo skaiiaus reikme tampa didesniojo ir maesniojo skaii skirtumas.
5. Algoritmo veiksmai kartojami pradedant 2.
Euklidas senovs graik matematikas, dabar inomas kaip geometrijos tvas.
46
2.7. Kvadratins lygties sprendini skaiiavimas
Atlikdami darb tvirtinsite slygos sakinio uraymo gdius, imoksite sukurti patogesn naudotojo
ssaj.
103
3.4. Rezultat (duomen) ivedimas ekrane
104
97
Uduotis. Rasti kvadratins lygties ax2 + bx + c = 0 sprendinius. ia a, b, c skaiiai, nelygs
nuliui.
Algoritmas. Kvadratins lygtys sprendiamos taip:
Skaiiuojamas diskriminantas: d = b2 - 4ac.
Tikrinama, ar lygtis turi sprendini ir jei taip, tai jie skaiiuojami:
o jei d < 0, kvadratin lygtis neturi reali sprendini;
o
o
b
;
2a
b d
b+ d
ir x1 =
.
jei d > 0, tuomet kvadratin lygtis turi du sprendinius: x1 =
2a
2a
jei d = 0, tuomet kvadratin lygtis turi vien sprendin x =
Pasiruoimas. Sukurkite katalog programos failams saugoti, atverkite FPS terp ir sukurkite programos
fail Darbas7.pas.
Pirmas ingsnis. Pradini duomen vedimas klaviatra.

Pradiniai duomenys:
a, b, c kvadratins lygties koeficientai.
Raydami program, skirt kvadratini lygi sprendini skaiiavimui, sukursime patogesn naudotojo
ssaj. Prisijungsime bibliotek Crt ir pasinaudosime jos procedromis:
GotoXY (x, y) ymeklio padtis ekrane fiksuojama take, kurio koordinats yra (x; y). i
procedr naudosime ekrane vesdami pradinius duomenis, uraydami sprendiam kvadratin
lygt, ivesdami lygties sprendinius.
TextBackground (spalva) pasirenkama norima teksto fono spalva. i procedr naudosime
vesdami kvadratins lygties koeficientus jie bus vedami kitos spalvos fone.
Paraykite sakinius pradini reikmi vedimui klaviatra.
program Darbas7;
uses Crt;
var a, b, c, d : integer; // Lygties koeficientai ir diskriminantas
x1, x2 : real;
// Lygties aknys
begin
GotoXY(10, 2);
// Fiksuojama ymeklio padtis
Write('Kvadratins lygties ax');
GotoXY(32, 1);
Write('2');
GotoXY(33, 2);
WriteLn(' + bx + c = 0 sprendimas');
GotoXY(5, 4);
WriteLn('Klaustuk vietoje raykite kvadratins lygties koeficientus');
GotoXY(15, 7);
Write('?x');
GotoXY(17, 6);
Write('2');
GotoXY(19, 7);
WriteLn(' + ?x + ? = 0');
TextBackground (Red); // Lygties koeficient vietoje teksto fonas raudonos spalvos
GotoXy(15, 7);
Read(a);
GotoXY(22, 7);
Read(b);
47
GotoXY(27, 7);
ReadLn(c);
TextBackground (Black); // Atstatomas pradinis teksto fonas
GotoXY(5, 9);
WriteLn('Sprendiama kvadratin lygtis:');
GotoXY(15, 11);
Write(a, 'x');
GotoXY(17, 10);
Write('2');
GotoXY(19, 11);
WriteLn(' + ', b,'x + ', c, ' = 0');
ReadLn;
end.
Isaugokite ir vykdykite program su koeficient reikmmis: a = 2, b = 4, c = 1. Ekrane
turtumte matyti:
Antras ingsnis. Kvadratins lygties sprendimas ir sprendini spausdinimas ekrane.

d := b * b - 4 * a * c;
if d < 0
then WriteLn('Lygtis neturi reali sprendini')
else if d = 0
then
begin
x1 := -b / (2 * a);
WriteLn('Lygtis turi vien sprendin: x = ', x1:0:2);
end
else
begin
x1 := (-b - Sqrt (d)) / (2 * a);
x2 := (-b + Sqrt (d)) / (2 * a);
WriteLn('Lygtis turi du sprendinius: x1 = ', x1:0:2,
' ir x2 = ', x2:0:2);
end;
Isaugokite ir vykdykite program su koeficient reikmmis: a = 2, b = 4, c = 1. Ekrane
turtumte matyti:
Treias ingsnis. Programos darbo tikrinimas su vairiais pradini duomen rinkiniais.
48
Isprskite kvadratines lygtis:
x2 + 14x + 49 = 0;
x2 + 12x + 36 = 0;
x2 - 8x - 9 = 0;
x2 - 6x + 8 = 0;
x2 - 3x + 2 = 0;
x2 - 5x + 6 = 0;
x2 - x + 2 = 0;
-x2 + 4x + 1 = 0;
-5x2 + 9x - 2 = 0.
Uduotis.
Pakeiskite program, kad ji sprst kvadratines lygtis su realiojo tipo koeficientais. Atkreipkite dmes tai,
kad reiks pataisyti ymeklio padt ekrane vedant pradinius duomenis ir spausdinant sprendiam
kvadratin lygt. Laikykite, kad koeficientui vesti skiriamos 7 pozicijos.
49
2.8. Vampyro skaiiai
Atlikdami darb susipainsite su sveikj skaii skaidymu skaitmenimis, naudojant operatorius div ir
mod. Suinosite kaip kombinatorikos (matematikos aka) elementus galima taikyti skaii teorijoje raant
programas. Suinosite kas yra skaiiaus faktorialas.
94
103
95
104
3.6. Ciklo sakinys for
97
97
Uduotis. Tarkime, kad turime sveikj skaii sk sudaryt i n (n - lyginis skaiius) skaitmen. Jeigu
skaiius sk turi 2 daugiklius, kiekvienas i kuri yra sudarytas i n/2 skaitmen, sukonstruotus i skaiiaus
sk skaitmen (visi skaitmenys panaudojami tik po 1 kart), jis yra vadinamas vampyro skaiiumi, o i jo
skaitmen sukonstruoti daugikliai vampyro iltimis. Paraykite program, kuri surast ir ekrane
atspausdint visus 4-enklius vampyro skaiius ir j iltis.
Algoritmas. Prie pradedant nagrinti i uduot pateiksime kelet 4-enkli vampyro skaii ir j ili
pavyzdi:
1260 = 21 * 60
1395 = 15 * 93
1827 = 21 * 87
Kaip pastebite ie 4-enkliai skaiiai yra iskaidyti dviej dvienkli skaii skaii sandaug. Be to ie
abu skaiiai turi visus pradinio skaiiaus skaitmenis.
Norint pradti sprsti i uduot pirmiausia reikia mokti atskirti skaiiaus skaitmenis. Tai padaryti galima
naudojant sveik skaii dalybos operatorius div ir mod. Primename, kad pirmasis i j leidia gauti
sveikj dal, o antrasis dalybos liekan. Pavyzdiui, turime keturenkl skaii sk = 1234. Pirmj
skaiiaus skaitmen paymkime a, antrj b, treij c, ketvirtj d simboliais, t. y. sk = abcd. Dabar
paraykime formules, pagal kurias galima rasti iuos skaitmenis:
a
b
c
d
= sk div 1000
= (sk div 100) mod 10
= (sk div 10) mod 10
= sk mod 10
Perkelkime tai kas buvo urayta program.

fail Darbas8.pas.
Pradioje program raysime tik vienam 4-enklio skaiiaus skaidymui atskirais skaitmenimis.
Pirmas ingsnis. Apraomi kintamieji, skirti pradini duomen reikmms saugoti. Uraomi keturi
priskyrimo sakiniai pagal aukiau uraytas formules. Ekrane spausdinamas gautas rezultatas.
program Darbas8;
var
sk,
// Keturenklis skaiius
a, b, c, d : integer;
// Skaiiaus sk (abcd) skaitmenys
begin
WriteLn('Programa pradjo darb');
sk := 1234;
a := sk div 1000;
50
b := (sk div 100) mod 10;
c := (sk div 10) mod 10;
d := sk mod 10;
WriteLn(sk , ' skaitmenys: ', a, ' ', b, ' ', c, ' ', d);
WriteLn('Programa darb baig');
ReadLn;
end.
Programa pradjo darb
Paleid program, ekrane matysite:
1234 skaitmenys: 1 2 3 4
Programa darb baig
Antras ingsnis. Pirmojo 4-enkli skaii deimtuko skaidymas atskirais skaitmenimis ir rodymas
ekrane.
Pakeiskite priskyrimo sakin sk := 1234; ciklo sakiniu
Uraykite operatorinius skliaustus begin .. end.
for sk := 1000 to 1009 do
program Darbas8;
var
sk,
begin
for sk := 1000 to 1009 do
begin
a := sk div 1000;
b := (sk div 100) mod 10;
c := (sk div 10) mod 10;
d := sk mod 10;
end;
ReadLn;
end.

1000 skaitmenys: 1 0 0
Programa darb baig
0
1
2
3
4
5
6
7
8
9
Ibandykite program su visais 4-enkliais skaiiais: 1000..9999.
51
Treias ingsnis. Grkime prie uduoties vampyro skaii ir j ili. Iskaidius 4-enkl skaii sk
skaitmenimis a, b, c, d, reikia skaitmenis sujungti po du. Galimi ei keturi skaitmen sujungimo po du
variantai (junginiai):
ab, ac, ad, bc, bd, cd.
ia galima atpainti vien i kombinatorikos udavini derini sudarym. Deriniai kombinatorikoje
baigtins objekt aibs, turinios n element, junginiai i k (1 k n) element. Derini skaiius ymimas
C nk ir randamas pagal formul:
C nk =
n(n 1) ... (n (k 1))

. Uraas k! reikia skaiiaus faktorial ir yra lygus skaii
k!
k, k-1, k-2,..., 1 sandaugai, t. y. k! = k(k-1)(k-2)...1.

Ms atveju derini skaiius C 42 =
43 43
=
= 6 . ia 4-enklio skaiiaus sk skaitmen kiekis n = 4, o
2! 2 1
skaitmen kiekis junginyje k = 2. Kaip pastebite apskaiiuotas derini skaiius 6 atitinka aukiau
uraytiems 6 junginiams. Kadangi, pagal uduoties slyg, gautus junginius reikia grupuoti po du, todl
gaunasi trys poros jungini:
ab ir cd
ac ir bd
ad ir bc
Programoje pakeiskite sakin
sekaniais sakiniais:
WriteLn(sk , ' junginiu poros:');
WriteLn(' ':20, a, b, ' ', c, d);
WriteLn(' ':20, a, c, ' ', b, d);
WriteLn(' ':20, a, d, ' ', b, c);
program Darbas7;
var
sk,
begin
for sk := 1000 to 1009 do
begin
a := sk div 1000;
b := (sk div 100) mod 10;
c := (sk div 10) mod 10;
d := sk mod 10;
WriteLn(' ':20, a, b, ' ', c, d);
WriteLn(' ':20, a, c, ' ', b, d);
WriteLn(' ':20, a, d, ' ', b, c);
end;
Readln;
end.
Program galima patikrinti, pavyzdiui, su tokiomis ciklo for pradios ir pabaigos reikmmis: 1234.
52
1234 jungini poros:
12 34
13 24
14 23
Programa darb baig
Ibandykite program su visais 4-enkliais skaiiais: 1000..9999.
Ketvirtas ingsnis. Kiekvienai jungini porai (viso 3 poros), sudarykime visas galimas skaitmen
sukeitimo kombinacijas. Kadangi kiekvien pora sudaro po du skaitmenis, tai kiekvienai porai sudarysime po
4 (2*2) kombinacijas (ir. lentel).
Pirma jungini pora
ab
ba
ab
ba
cd
cd
dc
dc
Antra jungini pora

ac
ca
ac
ca
bd
bd
db
db
Treia jungini pora

ad
da
ad
da
bc
bc
cb
cb
Pertvarkykite ankstesn program, kiekvien jungini poros spausdinimo sakin, pakeisdami keturiais
kombinacij spausdinimo sakiniais. Taigi, programoje vietoje 3-j spausdinimo sakini atsiras 12-ka
spausdinimo sakini.
program Darbas8;
var
sk,
begin
for sk := 1234 to 1234 do
begin
a := sk div 1000;
b := (sk div 100) mod 10;
c := (sk div 10) mod 10;
d := sk mod 10;
WriteLn(' ':20, a, b, ' ', c, d);
WriteLn(' ':20, b, a, ' ', c, d);
WriteLn(' ':20, a, b, ' ', d, c);
WriteLn(' ':20, b, a, ' ', d, c);
WriteLn;
WriteLn(' ':20, a, c, ' ', b, d);
WriteLn(' ':20, c, a, ' ', b, d);
WriteLn(' ':20, a, c, ' ', d, b);
WriteLn(' ':20, c, a, ' ', d, b);
WriteLn;
WriteLn(' ':20, a, d, ' ', b, c);
WriteLn(' ':20, d, a, ' ', b, c);
WriteLn(' ':20, a, d, ' ', c, b);
53
WriteLn(' ':20, d, a, ' ', c, b);
end;
ReadLn;
end.
Isaugokite ir vykdykite program. Rezultatas turt bti toks:

1234 jungini poros:
12
21
12
21
34
34
43
43
13
31
13
31
24
24
42
42
14
41
14
41
Programa darb baig
23
23
32
32
Penktas ingsnis. Visas aukiau gautas jungini kombinacijas pavert dvienkliais skaiiais (pvz.:
a*10+b), jas sudaugin ir palygin su pradiniu skaiiumi sk galime nustatyti ar skaiius sk yra vampyras.
Jeigu skaiius yra vampyras bus spausdinamas skaiius ir jo iltys.

Pertvarkykite ankstesn program, kiekvien spausdinimo sakin (viso 12 sakini), atitinkamai
pakeisdami, Pavyzdiui, pirmj spausdinimo sakin
WriteLn(' ':20, a, b, ' ', c, d);
pakeiskite tokiu sakiniu

if sk = (a*10+b)*(c*10+d) then
WriteLn('Vampyras ', sk, ' = ', a, b, ' * ', c, d);
Atinkamai pakeiskite ir likusius vienuolika sakini.

Paalinkite i programos sakin WriteLn(sk , ' junginiu poros:');
Uraykite ciklo for pradin reikm 1000, o galin reikm 9999.
program Darbas8;
var
sk,
begin
for sk := 1000 to 9999 do
begin
a := sk div 1000;
54
b := (sk div 100) mod 10;
c := (sk div 10) mod 10;
d := sk mod 10;
WriteLn(' Vampyras ', sk, '
if sk = (b*10+a)*(c*10+d) then
if sk = (a*10+b)*(d*10+c) then
if sk = (b*10+a)*(d*10+c) then
if sk = (a*10+c)*(b*10+d) then
if sk = (c*10+a)*(b*10+d) then
if sk = (a*10+c)*(d*10+b) then
if sk = (c*10+a)*(d*10+b) then
if sk = (a*10+d)*(b*10+c) then
if sk = (d*10+a)*(b*10+c) then
if sk = (a*10+d)*(c*10+b) then
if sk = (d*10+a)*(c*10+b) then
end;
ReadLn;
end.
= ', a, b, ' * ', c, d);

= ', b, a, ' * ', c, d);
= ', a, b, ' * ', d, c);
= ', b, a, ' * ', d, c);
= ', a, c, ' * ', b, d);
= ', c, a, ' * ', b, d);
= ', a, c, ' * ', d, b);
= ', c, a, ' * ', d, b);
= ', a, d, ' * ', b, c);
= ', d, a, ' * ', b, c);
= ', a, d, ' * ', c, b);
= ', d, a, ' * ', c, b);
vykd program, ekrane matysite:

Vampyras 1260 = 21 *
Programa darb baig
60
93
35
30
87
81
80
80
Klausimai
1.
2.
3.
4.
5.
Ivardinkite kokius inote sveikj skaii dalybos operatorius Paskalio kalboje.

Koks bus rezultatas a := sk div 1000;, kur sk 4-enklis sveikas skaiius?
Koks bus rezultatas b := (sk div 100) mod 10;, kur sk 4-enklis sveikas skaiius?
Koks bus rezultatas c := (sk div 10) mod 10;, kur sk 4-enklis sveikas skaiius?
Koks bus rezultatas d := sk mod 10;, kur sk 4-enklis sveikas skaiius?
55
6. K gauname bet kok sveik skaii padalin i 10 (div 10)?
7. K gauname bet kok sveik skaii padalin i 10 (mod 10)?
Uduotys
1. Paraykite program, kuri rast i keli skaitmen sudarytas duotas sveikasis skaiius sk.
2. Paraykite program, kuri nustatyt, ar duotas sveikasis skaiius sk lyginis, ar nelyginis.
3. Paraykite program, kuri nustatyt, ar duotas sveikasis skaiius sk yra palidromas (vienodai
skaitomas i abiej gal).
4. Paraykite program, kuri nustatyt, ar duotas sveikasis skaiius sk sudarytas vien i lygini, vien
nelygini skaitmen, ar ir i toki ir toki.
5. Paraykite program, kuri apskaiiuot sveikojo skaiiaus sk faktorial.
6. Paraykite program, kuri apskaiiuot, kiek skirting penketuk galima sudaryti i 10 krepinink.
Raydami program pasinaudokite derini formule.
Smalsiems
Pirmas papildomas ingsnis. Programa bus aikesn ir suprantamesn, jeigu j struktrizuosime,
panaudojant procedr.
Sudarykite procedr, kuri nustatyt, ar skaiius yra vampyras. Procedr pavadinkite tuo paiu vardu
Vampyras. Procedra turs penkis parametrus: 4-enkl skaii sk ir keturis jo skaitmenis a, b, c, d.
Jeigu skaiius sk bus vampyras, tai procedra atspausdins skaii ir jo iltis. Programoje procedr
Vampyras reiks kreiptis 12 kart su atitinkamais argumentais, t. y. kiekvienas programos if sakinys
bus pakeistas kreipiniu i procedr.
program Darbas8;
procedure Vampyras(sk, a, b, c, d : integer);
begin
WriteLn(' Vampyras ', sk, ' = ', a, b, ' * ', c, d);
end;
var
sk,
begin
for sk := 1000 to 9999 do
begin
a := sk div 1000;
b := (sk div 100) mod 10;
c := (sk div 10) mod 10;
d := sk mod 10;
Vampyras(sk, a, b, c, d);
Vampyras(sk, b, a, c, d);
Vampyras(sk, a, b, d, c);
Vampyras(sk, b, a, d, c);
Vampyras(sk,
Vampyras(sk,
Vampyras(sk,
Vampyras(sk,
a,
c,
a,
c,
c,
a,
c,
a,
b,
b,
d,
d,
d);
d);
b);
b);
56
Vampyras(sk, a, d, b, c);
Vampyras(sk, d, a, b, c);
Vampyras(sk, a, d, c, b);
Vampyras(sk, d, a, c, b);
end;
Readln;
end.
Isaugokite ir vykdykite program. Ekrane matysite tok pat rezultat, kaip ir ankstesnje programos
versijoje
Antras papildomas ingsnis. Norint aukiau parayt program padaryti dar universalesn, reikt rezultatus
pateikti ne ekrane, o rezultat faile.
Norint rezultatus pateikti ne ekrane, o rezultat faile reikia:
program papildyti failo kintamuoju F,
sugalvoti rezultat failo vard, pvz.: Vampyrai.txt,
papildyti procedros Vampyras parametr sra dar vienu kintamuoju (pvz.: var F : text;),
uraant j pirmoje vietoje,
procedroje Vampyras, spausdinimo sakin WriteLn, papildykite failo kintamuoju F,
visuose 12-oje kreipini procedr Vampyras pradioje urayti argument F,
vykdius program ekrane turt matytis tik dvi eiluts:
Programa darb baig
Apskaiiuoti rezultatai bus rezultat faile. Atverkite j pasinaudodami meniu komanda Open....
57
2.9. Trys lazdos
Atlikdami darb susipainsite su loginiais kintamaisiais ir loginiais reikiniais, loginmis operacijomis IR,
ARBA. Imoksite loginius reikinius panaudoti ciklo ir slygos sakiniuose.
94
103
3.8. Funkcij sraas
94
104
Uduotis. Duota n rinkini tam tikro ilgio lazd. Kiekvien rinkin sudaro 3 lazdos. Lazd ilgiai a, b ir c
matuojami decimetrais (sveikieji skaiiai). Nustatyti, ar galima i i lazd sudti trikamp. Jeigu galima, tai
kok: statj, lygiakrat, lygiaon ar vairiakrat. Jeigu negalima, tai urayti atitinkam tekst.
Algoritmas. Sprendiant i uduot galime sivaizduoti, kad trys lazdos geometrijoje atitinka tris atitinkamo
ilgio atkarpas a, b ir c. Prisiminkite, kad ne visuomet i trij atkarp galima sudti trikamp. Btent,
trikampio sudti negalima, jeigu yra bent viena pora atkarp, kurios ilgi suma yra maesn arba lygi u
likusij treij atkarp. Arba, galima pasakyti ir taip, kad i trij atkarp trikamp galima sudti tuomet, kai
vis galim (arba bet kuri) atkarp por ilgi suma yra didesn u treij atkarp, t. y.
(a + b > c) ir (a + c > b) ir (c + b > a).

fail Darbas9.pas.
Pradioje program raysime tik vienam lazd rinkiniui. Kadangi vien rinkin sudaro trys
lazdos, tai lazd ilgius vesime vienu ReadLn sakiniu ir nustatysime, ar galime sudaryti trikamp, ar ne.
Pirmas ingsnis. Apraomi kintamieji, skirti pradini duomen reikmms saugoti, vedami duomenys.
Programos pradioje apraykite trij lazd ilgius sauganius sveikojo tipo kintamuosius a, b, ir c.
Pakeiskite sakin WriteLn('Labas'); nauju sakiniu
Paraykite kintamj a, b, ir c reikmi vedimo klaviatra sakinius: praneimo, kokias reikmes ir

kokia eils tvarka vesti, sakin Write ir reikmi skaitymo sakin Readln.
Programos pabaigoje, prie sakin ReadLn; uraykite tok sakin:

program Darbas9;
var
a, b, c : integer;
// Trij lazd ilgiai
begin
Write('veskite trij lazd ilgius: '); ReadLn(a, b, c);
ReadLn;
end.
Paleid program, klaviatra surink skaiius 30 50 40 ir paspaud klavi Enter, ekrane matysite:
veskite trij lazd ilgius: 30 50 40
Programa darb baig
58
Antras ingsnis. Pirmojo rezultato ar i trij lazd rinkinio galima sudti trikamp skaiiavimas ir
rodymas ekrane.
Papildykite program sakiniu WriteLn, kuris ekrane spausdint pradinius duomenis a, b, c.
Papildykite program slygos sakiniu if su darbo apraymo pradioje pateikto loginio reikinio
skaiiavimu odius ir pakeiiant AND.
program Darbas9;
var
a, b, c : integer;
// Trij lazd ilgiai
begin
Write('Lazdos: ', a:2, ' ', b:2, ' ', c:2);
if (a + b > c) AND (a + c > b) AND (b + c > a) // Ar trikampis?
then WriteLn(' - galima sudaryti trikamp')
else WriteLn(' - trikampio sudaryti negalima');
ReadLn;
end.
Paleid program, klaviatra surink skaiius 30 50 40, bei gale paspaud klavi Enter , ekrane matysite:
Lazdos: 30 50 40 galima sudaryti trikamp
Programa darb baig
Dar kart paleid program ir klaviatra surink skaiius 10 50 40, bei gale paspaud klavi Enter, ekrane
matysite:
Lazdos: 10 50 40 trikampio sudaryti negalima
Programa darb baig
Treias ingsnis. Jeigu trikamp galima sudaryti, tai reikia nustatyti, kokio tipo trikamp galima sudaryti.
Statj trikamp galima sudaryti, jeigu duotiems dydiams a, b ir c galioja reikinys
(a2 + b2 = c2) arba (a2 + c2 = b2) arba (c2 + b2 = a2).
Lygiakrat trikamp galima sudaryti, jeigu duotiems dydiams a, b ir c galioja reikinys

(a = b) ir (b = c).
Lygiaon trikamp galima sudaryti, jeigu duotiems dydiams a, b ir c galioja reikinys

(a = b) arba (b = c) arba (a = c).
Jeigu nei vienas aukiau uraytas reikinys negalioja, tai trikampis yra vairiakratis.
Programoje reikia pakeisti slygos sakinio akoje then esant sakin
WriteLn(' - galima sudaryti trikamp')
59
kitu sudtiniu salygos sakiniu, kuris analizuos, kokio tipo trikamp galima sudaryti i trij duot lazd
rinkinio.
program Darbas9;
var
a, b, c : integer;
// Trij lazd ilgiai
begin
Write('Lazdos: ', a:2, ' ', b:2, ' ', c:2);
then if (a*a + b*b = c*c) OR (a*a + c*c = b*b) OR (b*b + c*c = a*a)
then WriteLn(' - galima sudaryti statj trikamp')
else if (a = b) AND (b = c)
then WriteLn(' - galima sudaryti lygiakrat trikamp')
else if (a = b) OR (b = c) OR (a = c)
then WriteLn(' - galima sudaryti lygiaon trikamp')
ReadLn;
end.
Program reikia patikrinti su penkiais duomen rinkiniais, pavyzdiui su tokiais:

30 50 40 (Statusis trikampis)
50 50 50 (Lygiakratis trikampis)
40 50 40 (Lygiaonis trikampis)
40 50 60 (vairiakratis trikampis)
10 50 40 (Trikampis nesusidaro)
Pirmuoju atveju, surink duomenis ir paspaud klavi Enter, ekrane matysite:
Lazdos: 30 50 40 galima sudaryti statj trikamp
Programa darb baig
Analogiki rezultatai turt gautis ir likusiais atvejais.
Ketvirtas ingsnis. Pritaikykime gaut program keliems duomen trij lazd rinkiniams.
Panaudokime for cikl. Slygoje nurodyta, kad skaiiavimus reikia atlikti su n duomen rinkini.
Papildykite program dviem sveikojo tipo kintamaisiais n ir i. Pirmasis bus skirtas rinkini skaiiui
saugoti, o antrasis rodys, su kuriuo rinkiniu atliekami skaiiavimai.
raykite dialogo sakinius n reikms vedimui.
Apgaubkite duomen vedimo ir salygos sakinius ciklu for. Tam reikia naudoti operatorinius skliaustus
begin .. end, nes cikle bus atliekamas ne vienas , o keli sakiniai.
Pastumkite cikle for tarp begin ir end esant tekst dein. Tai atlikus programos tekstas taps
vaizdesnis, o tuo paiu ir suprantamesnis.
terpkite duomen vedimo dialogo sakin WriteLn ciklo kintamj i.
program Darbas9;
var
a, b, c : integer;
n,
i : integer;
// Trij lazd ilgiai

// Lazd rinkini skaiius
// Ciklo kintamasis
60
begin
Write('Iveskite kiek lazd rinkiniu bus: '); ReadLn(n);
for i := 1 to n do
begin
Write('Iveskite trij lazd ', i, '-j rinkin: '); ReadLn(a, b, c);
Write('Lazdos: ', a:2, ' ', b:2, ' ', c:2);
then if (a*a + b*b = c*c) OR (a*a + c*c = b*b) OR (b*b + c*c = a*a)
then WriteLn(' - galima sudaryti statj trikamp')
else if (a = b) AND (b = c)
then WriteLn(' - galima sudaryti lygiakrat trikamp')
else if (a = b) OR (b = c) OR (a = c)
then WriteLn(' - galima sudaryti lygiaon trikamp')
end;
ReadLn;
end.
Isaugokite ir vykdykite program su ankstesniais pradiniais duomenimis. n reikm nurodykite 5.

Rezultatas turt bti toks:
veskite kiek rinkini lazd bus: 5
veskite trij lazd 1-j rinkin: 30 50 40
Lazdos: 30 50 40 galima sudaryti statj trikamp
Lazdos: 50 50 50 galima sudaryti lygiakrat trikamp
Lazdos: 40 50 40 galima sudaryti lygiaon trikamp
Lazdos: 40 50 60 galima sudaryti vairiakrat trikamp
Lazdos: 10 50 40 trikampio sudaryti negalima
Programa darb baig
Klausimai
1.
2.
3.
4.
5.
Ivardinkite kokius inote loginius operatorius ir kaip jie uraomi Paskalio kalboje.
Kaip suprantate login reikin? Paaikinkite.
Kokias reikmes gali gauti loginis reikinys?
Kokie operatoriai daniausiai naudojami apraant login reikin?
Kokias reikmes gali gauti loginis reikinys?
Uduotys
1.
2.
3.
4.
Nubraiykite ir upildykite loginio operatoriaus IR veiksm lentel.

Nubraiykite ir upildykite oginio operatoriaus ARBA veiksm lentel.
Nubraiykite ir upildykite loginio operatoriaus NE veiksm lentel.
Uraykite dialogo sakinius tako (xt, yt) koordinatms vesti.
61
5. Duotos staiakampio prieing kamp koordinats: kairiojo virutinio kampo (x1, y1) ir deinio
apatinio kampo (x3, y3). Uraykite loginius reikinius:
Tako priklausomybei staiakampio viduje nustatyti,
Tako priklausomybei staiakampio iorje nustatyti,
Tako priklausomybei staiakampio apatinje kratinje nustatyti,
Tako priklausomybei staiakampio virutinje kratinje nustatyti,
Tako priklausomybei staiakampio kairje kratinje nustatyti,
Tako priklausomybei staiakampio deinje kratinje nustatyti.

6. Papildykite program taip, kad ji rast ir ekrane parodyt gaut trikampi plotus. Naudokite Herono
formul trikampio plotui apskaiiuoti.
7. Trikampis vienu metu gali bti ir dviej tip: statusis ir lygiaonis, lygiaonis ir lygiakratis.
Pakeiskite program taip, kad ji tai vertint.
8. Panaudokite programoje skirtingas spalvas, skirtingiems trikampi tipams ekrane paymti.
Smalsiems
Pirmas papildomas ingsnis. Norint aukiau parayt program padaryti universalesn, reikt
duomenis programai vesti ne klaviatra, bet imti i i anksto paruoto duomen failo. Lygiai taip pat
rezultatus reikt pateikti ne ekrane, o rezultat faile.
Nordami duomenis imti i failo pirmiausia reikt susikurti duomen fail, pvz.: Lazdos.txt:
5
30
50
40
40
10
50
50
50
50
50
40
50
40
60
40
Pirmoje failo eilutje uraytas lazd rinkini skaiius n, kitose eilutse po tris skaiius surayti lazd
rinkiniai.
K reikia padaryti:
program papildyti failo kintamuoju,
parengti fail skaitymui,
papildyti n ir a, b, c ivedimo sakinius failo kintamuoju,
paalinti sekanius sakinius kaip nereikalingus
Write('Iveskite kiek lazd rinkiniu bus: ');
Write('Iveskite trij lazd ', i, '-j rinkin: ');

Palyginkite gautus rezultatus su ankstesniais rezultatais. Jeigu visk teisingai atlikote, tai jie turt
sutapti.
Panaius veiksmus reikt atlikti, norint rezultatus pateikti ne ekrane, o rezultat faile:
program papildyti dar vienu failo kintamuoju,
sugalvoti rezultat failo vard, pvz.: Rezultatai.txt,
papildyti ivedimo sakinius failo kintamuoju,
62
vykdius program ekrane turt matytis tik dvi eiluts:
Programa darb baig
Apskaiiuoti rezultatai bus rezultat faile. Atverkite j pasinaudodami meniu komanda Open....
Antras papildomas ingsnis. Programa bus aikesn ir suprantamesn, jeigu j struktrizuosime,

panaudojant funkcijas. Be to inome, kad trikampis gali turti kelias savybes, pavyzdiui bti status ir
lygiaonis. Todl reikt patikrinti kiekvienam trikampiui atskirai, kokias savybes jis tenkina.
program Darbas9;
var
a, b, c : integer;
// Trij lazd ilgiai
n,
// Lazd rinkini skaiius
i : integer;
// Ciklo kintamasis
//---------------------------------------------function ArTrikampis: boolean;
begin
ArTrikampis := (a + b > c) AND (a + c > b) AND (b + c > a);
end;
//---------------------------------------------function ArStatus: boolean;
begin
ArStatus := (a*a + b*b = c*c) OR (a*a + c*c = b*b) OR (b*b + c*c = a*a)
end;
//---------------------------------------------function ArLygiakrastis: boolean;
begin
ArLygiakrastis := (a = b) AND (b = c)
end;
//---------------------------------------------function ArLygiasonis: boolean;
begin
ArLygiasonis := (a = b) OR (b = c) or (a = c)
end;
//---------------------------------------------function ArIvairiakrastis: boolean;
begin
ArIvairiakrastis := (a <> b) AND (a <> c) AND (b <> c);
end;
//---------------------------------------------var fd, fr : text;
begin
Assign(fr, 'Rezultatai.txt'); Rewrite(fr);
Assign( fd, 'Lazdos.txt'); Reset(fd);
ReadLn(fd, n);
for i := 1 to n do
begin
ReadLn(fd, a, b, c);
WriteLn(fr, 'Lazda: ', a:2, ' ', b:2, ' ', c:2);
if ArTrikampis // Ar trikampis?
then begin
63
if ArStatus then
WriteLn(fr, ' - galima sudaryti statj trikamp');
if ArLygiakrastis then
WriteLn(fr, ' - galima sudaryti lygiakrat trikamp');
if ArLygiasonis then
WriteLn(fr, ' - galima sudaryti lygiaon trikamp');
if ArIvairiakrastis then
WriteLn(fr, ' - galima sudaryti vairiakrat trikamp');
end
else WriteLn(fr, ' - trikampio sudaryti negalima');
end;
Close(fr);
Readln;
end.
Isaugokite ir vykdykite program. Rezultat faile matysite:

Lazda: 30 50 40
- galima sudaryti statj trikamp
- galima sudaryti vairiakrat trikamp
Lazda: 50 50 50
- galima sudaryti lygiakrat trikamp
- galima sudaryti lygiaon trikamp
Lazda: 40 50 40
- galima sudaryti lygiaon trikamp
Lazda: 40 50 60
- galima sudaryti vairiakrat trikamp
Lazda: 10 50 40
- trikampio sudaryti negalima
64
2.10. Taikinys
Atlikdami darb tvirtinsite slygos sakinio uraymo gdius. Suinosite, kaip
nustatyti, ar du reals skaiiai lygs.
Smalsiems silomas kitas programos variantas. ia taikinio duomenys skaitomi i tekstinio
failo, todl pakartotinai vykdant program, nereikia klaviatra suvedinti daug pradini
duomen. Jie suraomi tekstiniame faile ir saugomi tol, kol nepakeiiami naujais. Taip pat
ia js susipainsite, kaip, panaudojant procedras, galima supaprastinti programos
struktr. Atskirus veiksmus uraius procedromis, kiekviena j tampa lengviau skaitoma, pagrindin
programa tampa veiksm nuoseklumo valdymo priemone.
Uduotis. Vyksta audymo i lanko varybos. Taikinys pritvirtintas prie lentos, turinios elektroninius
daviklius. Lentos apatinio kairiojo kampo koordinats yra (0; 0). Taikinio centras paymtas juodu skrituliu.
Aplink skritul yra nubrti dar trys apskritimai. Strlei pataikius skirtingas taikinio vietas yra skiriamas
skirtingas tak skaiius. Reikia parayti program, kuri, priklausomai nuo strls pataikymo vietos, skirt
sportininkui takus. Yra inomi taikinio duomenys: taikinio centro koordinats (xc; yc), apskritim
spinduliai, strls pataikymo vietos koordinats (x; y) ir tak verts. Jeigu strl pataik ant apskritimo
linijos, tuomet sportininkas gauna pus tak, kurie bt skiriami, jeigu takas bt apskritimo viduje.
Algoritmas. Jei takas nuo apskritimo centro yra atstumu a < r, tuomet takas bus apskritimo viduje, jei a =
r takas bus ant apskritimo, jei a > r takas bus apskritimo iorje. Bet kurio tako koordinats (x, y) yra
realieji skaiiai. Nustatyti, ar du realieji skaiiai yra lygs, nemanoma, nes kiekvienas j bendru atveju po
kablelio turi daug skaitmen. Kompiuteryje realieji skaiiai saugomi tam tikru tikslumu, todl skaiiai
laikomi lygiais tuomet, kai skirtumas tarp j yra nedidelis. Yra laikoma, pavyzdiui, kad du realieji skaiiai
yra lygs, jeigu pirmi penki skaitmenys po kablelio yra vienodi. Daugeliu atvej atliekant skaiiavimus su
realiaisiais skaiiais btina inoti, kokiu tikslumu reikia skaiiuoti.
Pavaizduokime situacij grafikai:
y
xt; yt
Atstumas ats tarp dviej

skaiiuojamas pagal formul:
tak
ats = ( xc xt ) 2 + ( yc yt ) 2
xc; yc
x
r
---------------------------------------------------------------------------
fail Darbas10.pas. Udavin suskaidysime dalis:
pradini duomen skaitymas;

atstumo a skaiiavimas;
65
tikrinimas, kur yra takas;
Pirmas ingsnis. Pradini duomen skaitymas. Apraomi kintamieji pradiniams duomenims skaityti ir
uraomi duomen skaitymo sakiniai.
program Darbas10;
var
xc, yc : real;
r1, r2, r3, r4 : real;
t1, t2, t3, t4 : integer;
x, y : real;
begin
//
//
//
//
Taikinio centro koordinats

Apskritim spinduliai didjimo tvarka
Skiriami takai atitinkamai pagal apskritimus
Strls koordinats
// Duomen skaitymas
Write ('Taikinio centro koordinat xc = ');
ReadLn
Write ('Taikinio centro koordinat yc = ');
ReadLn
Write ('Pirmojo apskritimo spindulys r1 = ');
ReadLn
Write ('Pirmojo apskritimo takai
t1 = ');
ReadLn
Write ('Antrojo apskritimo spindulys r2 = ');
ReadLn
Write ('Antrojo apskritimo takai
t2 = ');
ReadLn
Write ('Treiojo apskritimo spindulys r3 = '); ReadLn
Write ('Treiojo apskritimo takai
t3 = '); ReadLn
Write ('Ketvirtojo apskritimo spindulys r4 = '); ReadLn
Write ('Ketvirtojo apskritimo takai
t4 = '); ReadLn
Write ('Strls koordinat x = '); ReadLn (x);
Write ('Strls koordinat y = '); ReadLn (y);
ReadLn;
end.
Isaugokite program ir patikrinkite kaip veikia.
(xc);
(yc);
(r1);
(t1);
(r2);
(t2);
(r3);
(t3);
(r4);
(t4);
Antras ingsnis. Strls padiai nagrinti reikalingas jos pataikymo taikin tako atstumas iki
apskritimo centro. Jam skaiiuoti paraykite priskyrimo sakin
ats := Sqrt (Sqr (xc - x) + Sqr (yc - y));
Papildykite programos kintamj sra nauju realiojo tipo kintamuoju ats.

Paraykite sakin, kuris ekran iveda apskaiiuot atstumo ats reikm.
Isaugokite program ir patikrinkite, kaip ji veikia. ved pasirinktus duomenis ekrane matysime,
pavyzdiui, tokias eilutes:
Taikinio centro koordinat xc = 60
Taikinio centro koordinat yc = 80
Pirmojo apskritimo spindulys r1 = 10
Pirmojo apskritimo takai
t1 = 10
Antrojo apskritimo spindulys r2 = 15
Antrojo apskritimo takai
t2 = 8
Treiojo apskritimo spindulys r3 = 20
Treiojo apskritimo takai
t3 = 6
Ketvirtojo apskritimo spindulys r4 = 30
Ketvirtojo apskritimo takai
t4 = 2
Strls koordinat x = 55
Strls koordinat y = 45
Pataikymo tako atstumas iki taikinio centro: 35.35534
66
Treias ingsnis. Ivados, kur yra takas nurodyto apskritimo atvilgiu, formulavimui reikia inoti, kokiu
tikslumu atlikti apskritimo spindulio ir tako atstumo iki apskritimo centro palyginim. Tam reikia ivesti
skaiiavim tikslumo reikm, kuriai saugoti reikia aprayti realaus tipo kintamj, kur galime pavadinti
tiks.
Papildykite program skaiiavim tikslumo reikms vedimo sakiniais.
Isaugokite program ir patikrinkite, kaip ji dirba. vedus pasirinktus duomenis ekrane matysime,
Taikinio centro koordinat xc = 60
Taikinio centro koordinat yc = 80
Pirmojo apskritimo spindulys r1 = 10
Pirmojo apskritimo takai
t1 = 10
Antrojo apskritimo spindulys r2 = 15
Antrojo apskritimo takai
t2 = 8
Treiojo apskritimo spindulys r3 = 20
Treiojo apskritimo takai
t3 = 6
Ketvirtojo apskritimo spindulys r4 = 30
Ketvirtojo apskritimo takai
t4 = 2
Pataikymo tako atstumas iki taikinio centro: 35.35534
Skaiiavim tikslumas: 0.01
Ketvirtas ingsnis. Papildykite program nauju sveikojo tipo kintamuoju tsk, skirtu takams siminti.
Programoje paraykite slygos sakin, kuris patikrina tako padt apskritim atvilgiu ir skaiiuoja takus:
if Abs(ats - r1) < tiks then tsk := t1 div 2
else if ats < r1 then tsk := t1
else if Abs(ats - r2) < tiks then tsk := t2 div 2
else tsk := 0;
Slygos sakinyje pirmiausiai reikia patikrinti, ar takas yra ant apskritimo. Jeigu duotu tikslumu gauname
atsakym, kad jis yra ne ant apskritimo, tuomet galima tikrinti, ar viduje, ar iorje. Tokia seka reikalinga
tam, kad iskirtume atvej, ar skaiiai lygs. Tikrinti pradedame nuo vidinio apskritimo.
Papildykite program apskaiiuot tak reikmei spausdinti.
Patikrinkite, ar programa veikia teisingai. Tam reikia paruoti tiek duomen testini variant, kiek
yra tak skaiiavimo variant: kiekvienam apskritimui, kai takas yra jo viduje, kai ant apskritimo ir kai
jo iorje. Jeigu programos pateikiami rezultatai sutampa su test rezultatais, tuomet galime teigti, kad
programa skaiiuoja teisingai. Norint sitikinti, ar gerai skaiiuojamas atstumas, testiniuose duomen
variantuose reikia apskaiiuoti tako atstumus iki apskritimo centro. Tikslinga patikrinti, ar programa
gerai skaiiuoja, kai apskritimas ir takas yra skirtingose staiakamps koordinai ploktumos vietose.
Klausimai
1. Kodl du realiuosius skaiius reikia lyginti tam tikru tikslumu?
2. Kodl lyginant du realiuosius skaiius i pradi reikia patikrinti, ar jie lygs, o po to nustatyti
pirmas didesnis u antr, ar maesnis?
67
3. Jeigu vietoje apskritimo bt staiakampis, kurio kratins yra lygiagreios koordinai aims, tai
kaip reikt parayti patikrinim, ar takas yra viduje, ar iorje, ar ant kurios nors kratins?
Uduotys
1. Papildykite program, kuri skaiiuot takus, kai sportininkas ov i lanko kelis kartus. Tam reikia
strls pataikymo koordinates, atstumo skaiiavim ir tak skaiiavim atlikti cikle. Papildomu
kintamuoju reikia saugoti, kiek kart sportininkas ov.
2. Ne visuomet taikiniuose yra apskritimai. Pakeiskite program, kai vietoje apskritim turime
staiakampius, kuri kratins lygiagreios koordinai aims.
3. Paraykite program, kuri nustatyt, ar du apskritimai kertasi, jeigu yra inomi j spinduliai ir centr
koordinats.
Smalsiems
Pirmas ingsnis. Pradini duomen skaitymas.

Pradiniai duomenys suraomi tekstiniame faile. Pavyzdiui faile TaikinysDuom.txt taip:
TaikinysDuom.txt
60 80
10 10
15 8
20 6
30 2
0.01
Paaikinimai
Taikinio centro koordinats xc ir yc
Pirmojo apskritimo spindulys ir skiriami takai
Antrojo apskritimo spindulys ir skiriami takai
Treiojo apskritimo spindulys ir skiriami takai
Ketvirtojo apskritimo spindulys ir skiriami takai
Skaiiavim tikslumas
Tai pastovs duomenys. Derinant program nereiks kiekvien kart suvedinti taikinio duomen. Jeigu bus
skaiiuojami takai ne vienam viui, tai tereiks tik strls pataikymo koordinates vesti. Jeigu bus kitas
taikinys, tuomet duomen faile tursite duomenis surayti i naujo.
Apraomi pradini duomen kintamieji.
program Darbas10;
var
xc, yc : real;
r1, r2, r3, r4 : real;
t1, t2, t3, t4 : integer;
tiks : real;
//
//
//
//
Taikinio centro koordinats

Apskritim spinduliai didjimo tvarka
Skiriami takai atitinkamai pagal apskritimus
Skaiiavim tikslumas
Paraoma procedra duomenims i failo skaityti ir kreipinys skaitymo procedr pagrindinje

programoje. Procedros tekstas programoje turi bti prie pagrindins programos pradi, kuri ymi
odis begin.
//-----------------------------------------------procedure SkaitytiDuomenis;
var Fd : text;
begin
Assign(Fd, 'TaikinysDuom.txt'); Reset(Fd);
ReadLn(Fd, xc, yc);
ReadLn(Fd, r1, t1);
ReadLn(Fd, r2, t2);
ReadLn(Fd, r3, t3);
ReadLn(Fd, r4, t4);
ReadLn(Fd, tiks);
Close(Fd);
68
end;
//--------- Pagrindin programa (manau, kad reikt akcentuoti)
begin
SkaitytiDuomenis;
// Duomen skaitymas
ReadLn;
end.
Isaugokite program ir patikrinkite kaip veikia. Jeigu joki klaid nra, tuomet galite sitikinti, ar
duomenys i failo perskaityti teisingai. Tam galite parayti kit procedr:
//------------------------------------------------procedure RodytiDuomenis;
begin
WriteLn('xc = ', xc:5:2, ' yc = ', yc:5:2);
WriteLn('r1 = ', r1:5:2, ' t1 = ', t2:5);
WriteLn('r2 = ', r1:5:2, ' t2 = ', t2:5);
WriteLn('r3 = ', r1:5:2, ' t3 = ', t2:5);
WriteLn('r4 = ', r1:5:2, ' t4 = ', t2:5);
WriteLn('Tikslumas: ', tiks:8:5);
end;
//------------------------------------------------Procedra RodytiDuomenis raoma toliau po duomen skaitymo procedros, taiau prie pagrindin
program.
Pagrindinje programoje paraykite kreipin procedr: RodytiDuomenis;
Isaugokite program ir patikrinkite kaip veikia. Jeigu joki klaid nra, tuomet ekrane matysite
pradinius duomenis
xc= 60.00 yc = 80.00
r1= 10.00 t1 =
10
r2= 15.00 t2
8
r3= 20.00 t3=
6
r4= 30.00 t4=
2
Tikslumas: 0.01000
Antras ingsnis. Strls padiai nagrinti reikalingas jos pataikymo taikin tako atstumas iki
apskritimo centro. Jam skaiiuoti toliau pagrindinje programoje paraykite priskyrimo sakin:
ats := Sqrt (Sqr (xc - x) + Sqr (yc - y));
Papildykite programos kintamj sra nauju realiojo tipo kintamuoju ats.

Paraykite sakin, kuris ekran iveda apskaiiuot atstumo ats reikm.
Isaugokite program ir patikrinkite, kaip ji veikia. ved pasirinktus duomenis ekrane matysime,
xc= 60.00 yc = 80.00
r1= 10.00 t1 =
10
r2= 15.00 t2
8
r3= 20.00 t3=
6
r4= 30.00 t4=
2
Tikslumas: 0.01000
Pataikymo tako atstumas iki taikinio centro:
21.21320
69
Treias ingsnis. Tak skaiiavimas.
Papildykite program nauju sveikojo tipo kintamuoju tsk, skirtu takams siminti. Paraykite
procedr, kurioje paraykite slygos sakin, kuris patikrina tako padt apskritim atvilgiu ir
skaiiuoja takus:
//-------------------------------------------------------------------procedure Taskai;
begin
if Abs(ats - r1) < tiks then tsk := t1 div 2
else tsk := 0;
end;
//--------------------------------------------------------------------
Slygos sakinyje pirmiausia reikia patikrinti, ar takas yra ant apskritimo. Jeigu duotu tikslumu gauname
atsakym, kad jis yra ne ant apskritimo, tuomet galima patikrinti, ar viduje, ar iorje. Tokia seka reikalinga
tam, kad iskirtume atvej, ar skaiiai lygs. Tikrinti pradedame nuo vidinio apskritimo.
Papildykite program kintamaisiais x ir y, skirtais strls pataikymo taikin koordinatms saugoti.
Papildykite program sakiniais, skirtais strls pataikymo taikin koordinai reikmi vedimui
klaviatra:
Papildykite program kreipiniu procedr suskaiiuot tak reikmei spausdinti. Pagrindin
programa bus tokia:

begin
SkaitytiDuomenis;
// Duomen skaitymas
RodytiDuomenis;
// Duomenys rodomi ekrane
ats := Sqrt (Sqr (xc - x) + Sqr (yc - y)); // Atstumo skaiiavimas
WriteLn('Pataikymo tako atstumas iki taikinio centro: ', ats:10:5);
Taskai;
// Tak skaiiavimas
WriteLn('Gauti takai: ', tsk);
ReadLn;
end.
Isaugokite program ir patikrinkite kaip ji veikia.
Patikrinkite, ar programa veikia teisingai. Tam reikia paruoti tiek duomen testini variant, kiek
yra tak skaiiavimo variant: kiekvienam apskritimui, kai takas yra jo viduje, kai ant apskritimo ir kai
jo iorje. Jeigu programos pateikiami rezultatai sutampa su test rezultatais, tuomet galime teigti, kad
programa skaiiuoja teisingai. Norint sitikinti, ar gerai skaiiuojamas atstumas, testiniuose duomen
variantuose reikia apskaiiuoti tako atstumus iki apskritimo centro. Tikslinga patikrinti, ar programa
gerai skaiiuoja, kai apskritimas ir takas yra skirtingose staiakamps koordinai ploktumos vietose.
Programos skaiiavim rezultat ekrane pavyzdys:
70
xc= 60.00 yc = 80.00

r1= 10.00 t1 =
10
r2= 15.00 t2
8
r3= 20.00 t3=
6
r4= 30.00 t4=
2
Tikslumas: 0.01000
Pataikymo tako atstumas iki taikinio centro:
Gauti takai: 2
21.21320
Uduotys.
1. Inagrinkite pirmojo programos varianto klausimus ir atlikite pateiktas uduotis.
2. Tak skaiiavimo slygos sakinys sudtingas. Jeigu taikinyje bt daugiau apskritim, jis tapt dar
sudtingesnis). Pagalvokite, kaip galima bt supaprastinti tak skaiiavim.
71
2.11. Elektros grandins varos skaiiavimas
i uduotis yra paimta i 2006 m. informacini technologij valstybinio egzamino. Atlikdami darb
susipainsite su ciklas cikle struktra. Ibandysite skaitymo i failo ir raymo fail veiksmus. Prisiminsite
sumavimo algoritm.
I fizikos kurso inome, kad lygiagreiai sujungt laidinink bendra vara skaiiuojama pagal formul
1 1
1
1
1
=
+
+
+ ... +
, ia R lygiagreiai sujungt laidinink vara, R1, R2, , Rn atskir
R R1 R2 R3
Rn
laidinink varos.
Nuosekliai sujungt laidinink bendra vara skaiiuojama pagal formul R = R1 + R2 + + Rn, ia R
nuosekliai sujungt laidinink bendra vara, R1, R2, , Rn atskir laidinink varos.
Uduotis. Paraykite program, kuri apskaiiuot grandins bendr var, kai grandin sudaro viena ar
daugiau nuosekliai sujungt grandins dali; kiekviena grandins dalis sudaryta i dviej ar daugiau
lygiagreiai sujungt inomos varos laidinink.
Programa turi skaityti duomenis i tekstinio Duomenys.txt failo. Pirmoje failo eilutje raytas nuosekliai
sujungt grandins dali skaiius (ne daugiau kaip 100). Po to atskirose eilutse surayti grandin sudarani
dali duomenys: lygiagreiai sujungt laidinink skaiius (ne daugiau kaip 50) ir j var reikms.
Rezultat apskaiiuot grandins bendr var programa turi rayti Rezultatai.txt fail dviej
enkl po kablelio tikslumu.
Pavyzdys
Duomen failas
3
2 15 41
4 1 2 3 4
3 22 11 24
Duomen paaikinimas
Rezultat failas
Nuosekliai sujungt grandins dali skaiius:

pirmoji grandins dalis (dvi var R1 ir R2 reikms),
antroji grandins dalis (keturios var R3, R4, R5 ir R6 reikms),
treioji grandins dalis (trys var R7, R8 ir R9 reikms)
R3
R1 15
R4
R2 41
R5
Pirmoji grandins dalis
R6
R7 22
R8 11
3
4
17.08
R9 24
Traioji grandins dalis
Antroji grandins dalis
Skaiiavimas:
L1 =
1
1
1
1
1
1
1
1
1
+ ; L2 =
+
+
+ ; L3 =
+
+
R1 R2
R3 R4 R5 R6
R7 R8 R9
skaiiavimas,
R=
1
1
1
+
+
grandins bendra vara.
L1 L2 L3
grandins
dali
laidum
72
Algoritmas. Kaip pastebite, pirmiausia reikia apskaiiuoti atskir grandins dali varas, pagal aukiau
duot formul ir po to jas susumuoti. iose dalyse laidininkai sujungti lygiagreiai. Pavyzdyje pavaizduotos
trys tokios dalys. Yra inoma kiek kiekvienoje dalyje yra laidinink. Pradioje sivaizduokite, kad grandin
sudaro tik viena dalis, sudaryta i k lygiagreiai sujungt laidinink. Tegul i laidinink varos suraytos
tekstiniame faile Duomenys.txt vienoje eilutje tokia seka: pirmasis skaiius k eilutje nurodo laidinink
skaii, o toliau surayta k laidinink varos. Duomen failo Duomenys.txt pavyzdys:
2 15 41
Duomenims i failo nuskaityti reikia naudoti cikl for. Cikle reikia atlikti atskir laidinink var
sumavim. Nepamirkite prie cikl var sumai priskirti reikm lygi 0.
fail Darbas11.pas.
Pirmas ingsnis. Vienos dalies laidinink varos skaiiavimas. Tai nesudtingas ciklinis sumos kaupimo
algoritmas. Toliau atlikite sekanius veiksmus.
Sukurkite tekstin duomen fail Duomenys.txt ir j raykite aukiau pateikto pavyzdio vien
eilut.
Programos pradioje apraykite programoje naudojamus kintamuosius.
Paruokite duomen fail vedimui.
Sumos kaupimo kintamajam L priskirkite reikm lygi 0.
veskite duomenis: pirmiausia veskite laidinink skaii k, o po to naudodami cikl for veskte ir kartu
sumuokite laidinink varas.
Udarykite duomen fail.
Atspausdinkite gaut rezultat.
program Darbas11;
const CDuom = 'Duomenys.txt';
//-----------------------------------------------------------------------------var k,
// Vienos dalies var skaiius
j : integer;
// Ciklo kintamasis
L,
// Vienos dalies laidumas
rj : real;
// Vieno laidininko vara
F : text;
// Failo kintamasis
begin
Assign(F, CDuom); Reset(F);
L := 0;
Read(F, k);
for j := 1 to k do
begin
Read(F, rj);
// Skaitoma vara
L := L + 1 / rj; // Laidum sumavimas
end;
ReadLn(F);
// Vienos dalies var srao pabaiga
Close(F);
WriteLn('Laidinink vara: ', 1/L:8:2);
ReadLn;
end.
73
Laidinink vara
10.98
Ibandykite i program dar du kartus. Pirmj kart duomen fail Duomenys.txt raykite
4 1 2 3 4
o antrj kart
3 22 11 24
Pirmuoju atveju rezultatas laidinink vara turt bti 0.48, o antruoju 5.62.
Susumavus visus programos bandymus su pradiniais duomenimis (ir. schem) rezultatas turt bti toks:
10.98 + 0.48 + 5.62 = 17.08.
Kaip pastebjote is rezultatas pilnai sutampa su pavyzdio rezultatu. Taiau akivaizdu, kad toks darbas su
programa neteikia malonumo, nes atliekant skaiiavimus kiekvienai grandins daliai reikia keisti.duomen
failo turin ir vl i naujo paleidinti program. O be to dar gali prisireikti kalkuliatoriaus susumuojant visos
grandins dali varas. Reikia iekoti ieities i ios situacijos.
Antras ingsnis. Vis nuosekliai sujungt grandins dali bendrai varai rasti programoje reikalingas dar
vienas ciklas for, kuris turi apgaubti ankstesnj cikl for. iam ciklui atlikti, kaip ir ankstesnio ciklo
atveju, reikalingi analogiki paruoiamieji veiksmai.
Pakeiskite duomen failo Duomenys.txt turin tokiu, koks buvo nurodytas darbo pradioje
Papildykite programos kintamj apraus.
Visos grandins sumos kaupimo kintamajam R priskirkite reikm lygi 0.
veskite grandins dali skaii n.
Uraykite cikl for kartu su operatoriniais skliaustais begin..end, kurie apgaubs ankstenj (vidin)
cikl for.
Vidiniam ciklui priklausanius sakinius pastumkite dein. Tai atlikus programa tampa vaizdesn ir tuo
paiu suprantamesn.
Prie pasibaigiant iam ciklui uraykite sumavimo veiksm R := R + 1/L, kuris sumuos atskir
grandins dali (sujungt lygiareiai) varas, suskaiiuotas vidiniame cikle.
Pakeiskite rezultato spausdinimo sakin tokiu
WriteLn('Visos grandins laidinink vara: ', R:8:2);

program Darbas11;
//-----------------------------------------------------------------------------var n,
// Grandin sudarani dali skaiius
k,
i, j : integer;
// Cikl kintamieji
L,
R,
// Visos grandin vara
rj : real;
F : text;
// Failo kintamasis
begin
R := 0;
74
ReadLn(F, n);
for i := 1 to n do
begin
L := 0;
Read(F, k);
for j := 1 to k do
begin
Read(F, rj);
// Skaitoma vara
L := L + 1 / rj; // Laidum sumavimas
end;
ReadLn(F);
R := R + 1 / L;
end;
Close(F);
ReadLn;
end.

Visos grandins laidinink vara
17.08
Kaip matote rezultatas sutapo su tuo rezultatu, kuris buvo gautas ankstesn program leidiant tris kartus. Be
to iuo atveju nereikjo kaitalioti duomen failo turinio. Na ir galiausiai nereikjo atlikti atskir grandins
var sumavimo rankomis. Dar kart pavelkite program. Netiktina, j sudaro tik 30 eilui!
Treias ingsnis. Grkime prie uduoties programa gaut rezultat (tik skaii 17.08) turi rayti
rezultat fail Rezultatai.txt.
Pakeiskite rezultato spausdinimo sakin
tokiais sakiniais
Assign(F, 'Rezultatai.txt'); Rewrite(F);
WriteLn(F, R:8:2);
Close(F);

Atvr rezultat fail su komanda Atverti... pamatysite skaii 17.08. O tai reikia, kad pagal uduot
parayta programa atlieka visus skaiiavimus teisingai ir rezultatus pateikia ten kur ir reikia, t. y. rezultat
faile. Aiku, rezultatas nra vaizdus, trksta paaikinamojo teksto, taiau informacini technologij
valstybinio egzamino programos testuojamos automatikai, todl ia svarbus yra tik pats programos
skaiiavim rezultatas.
Klausimai
1.
2.
3.
4.
Kokius paruoiamuosius veiksmus reikia atlikti sumavimo algoritme?

Kokio tipo kintamieji naudojami uraant Paskalio kalba sumavimo algoritm?
Kada galima naudoti apskaiiuot sumos reikm programoje?
Paaikinkite, kuomet reikia naudoti ciklas cikle struktr.
75
Uduotys
1. Tekstiniame faile atskirose eilutse yra surayta Js klass mokini metiniai vertinim paymiai
(viso 10 paymi). Paraykite program, kuri apskaiiuot kiekvieno mokinio paymi vidurk ir j
atspausdint rezultat faile tokiu pavidalu: mokinio numeris, vidurkis.
2. Tekstiniame faile atskirose eilutse yra surayta miesto troleibus marrut atstumai (metrais) tarp
vis marruto stoteli. Eilui pradioje uraytas atitinkamo marruto stoteli skaiius. Paraykite
program, kuri apskaiiuot kiekvieno troleibus marruto ilg.
Smalsiems
Pirmas papildomas ingsnis. Programa bus aikesn ir suprantamesn, jeigu j struktrizuosime,

panaudojant procedr.
Sudarykite procedr, kuri apskaiiuot vienos grandins dalies laidinink, sujungt lygiareiai var, t.
y. vidin ciko cikle dal apiforminkite procedra. Procedr pavadinkite RastiRGrandies. Procedrai
reikia perduoti atidaryto duomen failo kintamj F, btinai nurodant prie j raktin odel var.
Nepamirkite pagrindinje programoje, likusiame cikle dti kreipin i procedr.
program Darbas11;
//-----------------------------------------------------------------------------// Vienos grandies vara
procedure RastiRGrandies (var F : text; var R : real);
var k,
j : integer;
// Ciklo kintamasis
rj,
L : real;
begin
L := 0;
Read(F, k);
for j := 1 to k do
begin
Read(F, rj);
// Skaitoma vara
L := L + 1 / rj;
// Laidum sumavimas
end;
ReadLn(F);
R := 1 / L;
end;
//-----------------------------------------------------------------------------var n,
// Grandin sudarani dali skaiius
i : integer;
// Ciklo kintamasis
GR,
// Vienos dalies vara
R : real;
// Visos grandin vara
F : text;
// Failo kintamasis
begin
R := 0;
ReadLn(F, n);
for i := 1 to n do
begin
RastiRGrandies (F, GR);
R := R + Gr;
end;
Close(F);
76
ReadLn;
end.
versijoje
Antras papildomas ingsnis. Pabandykite aukiau sukurt procedr pertvarkyti funkcij. Tam
reikia atlikti labai nedidelius pakeitimus aukiau uraytoje programoje.
Kaip procedr pertvarkyti funkcij:
procedros antrat pakeisti tokia
function RGrandies(var F : text) : real;
procedroje vietoj sakinio R := 1 / L; uraykite sakin RGrandies := 1 / L;
pagrindinje programoje vietoje cikle for esani operatorini skliaust (4 eiluts) uraykite sakin
R := R + RGrandies(F);
versijoje
77
2.12. Grafikos pradmenys
Atlikdami darb susipainsite su Paskalio kalbos struktromis, skirtomis grafiniam ekrano reimui valdyti
ir imoksite kurti paprastus grafinius objektus.
Free Pascal terpje grafiniam ekrano reimui valdyti skirtos struktros yra saugomos bibliotekoje Graph.
Prijungus ir aktyvizavus bibliotek Graph, sukuriamas grafinis langas, kuriame koordinai pradia (0; 0)
yra kairysis virutinis ekrano takas. x ais nukreipta dein, y emyn. Be to, koordinats yra tik sveikos ir
teigiamos.
Atlikdami darb ibandysite bibliotek Graph ir Crt galimybes.
Pirmas ingsnis. Bibliotekos Graph, kurioje yra visos reikalingos standartins procedros, prijungimas,
apskritimo braiymas.
Po programos antrate terpkite sakin uses Graph; iuo sakiniu prijungiama grafikos biblioteka.
Biblioteka Graph aktyvizuojama pagrindinje programoje, uraant sakin:
Initgraph (gd, gm, ''); ia gd ir gm sveikojo tipo kintamieji, kurie apraomi prie pagrindin
program. Kreiptis bibliotekos standartines procedras galima i bet kurios programos vietos ar
programoje esanios procedros.
Programoje paraykite kreipin standartin procedr Circle, kad bt braiomas apskritimas, kurio
centras yra take (100; 100), o spindulys 50:
program Darbas12;
uses Graph;
var gd, gm : integer;
begin
Initgraph (gd, gm,'');
Circle (100, 100, 50);
ReadLn;
end.
Isaugokite ir vykdykite sukurt program. Jei visk atlikote

teisingai, ekrane turtumte matyti vaizd:
Apskritimo braiymui panaudota bibliotekos Graph procedra
Circle (x, y, r) braiomas r spindulio apskritimas, kurio
centras yra take (x; y). ia x, y ir r yra sveikieji teigiami skaiiai.
. Tuomet
Grafinis langas udaromas paspaudus pele lango viruje deinje esant paskutin mygtuk
sugrtama tekstin programos darbo lang.
Antras ingsnis. Daugybs skirting spalv ir spinduli apskritim braiymas.
Nordami grafiniame ekrane matyti daug skirting apskritim, panaudosime standartin Paskalio
funkcij Random (n), kuri generuoja sveikuosius atsitiktinius skaiius, priklausanius intervalui [0;
n-1]. Prie panaudojant i funkcij rekomenduojama ikviesti procedr Randomize, kuri susieja
funkcijos Random generuojamos sekos pradi su kompiuterio laikrodio parodymu.
Sukurt program papildykite naujais kintamaisiais ir kreipiniais procedras ir funkcijas:
program Darbas12;
uses Graph;
x, y, r : integer;
s : integer;
i : integer;
begin
Randomize;
// Apskritimo centro (x; y) ir spindulio dydiai

// Apskritimo spalva
// Ciklo kintamasis
// Kreipinys procedr Randomize, susiejani funkcijos Random
78
for i := 1 to 100 do
begin
x := Random (1000);
y := Random (800);
r := Random (100);
s := Random (256);
SetColor (s);
Circle (x, y, r);
end;
ReadLn;
end.
// Generuojam sek su kompiuterio laikrodio parodymu

// Ciklas bus vykdomas 100 kart (bus braiomas 100 apskritim)
// Atsitiktinai generuojama apskritimo centro x koordinat
// Atsitiktinai generuojama apskritimo centro y koordinat
// Atsitiktinai generuojamas apskritimo spindulio ilgis
// Atsitiktinai generuojama apskritimo spalva
// Nurodoma apskritimo linijos spalva
// Braiomas r spindulio apskritimas, kurio centras yra take (x; y)
Isaugokite ir vykdykite
sukurt program. Jei visk
atlikote teisingai, ekrane
turtumte matyti pana
vaizd:
Ibandykite, kaip veikia
programa su atsitiktinai
sugeneruotomis reikmmis
i kito intervalo.
Treias ingsnis. Apskritimo linijos storio ir upildo spalvos bei rato keitimas.
Sukurt program papildykite naujais kintamaisiais ir kreipiniais procedras ir funkcijas:
program Darbas12;
uses Graph;
x, y, r : integer;
s, sr : integer;
// sr - upildo rato spalva
i : integer;
storis : integer;
// Kontro linijos storis
tipas : integer;
// Kontro linijos tipas
rastas : integer;
// Upildo ratas
begin
Randomize;
begin
x := Random (1000);
y := Random (800);
r := Random (100);
s := Random (256);
sr := Random (256);
SetColor (s);
storis := Random (4);
// Atsitiktinai generuojamas kontro linijos storis
79
tipas := Random (5);
// Atsitiktinai generuojamas kontro linijos tipas
SetLineStyle (tipas, tipas, storis); // Nurodomos linij charakteristikos
SetColor (sr);
// Atsitiktinai generuojama rato spalva
rastas := Random (13);
// Atsitiktinai generuojamas rato tipas
SetFillStyle (rastas, sr);// Nurodomas ratas ir spalva, kurie bus naudojami upildymui
FillEllipse (x, y, r, r); // Braioma upildyta elips, kurios centro koordinats yra (x; y), o
// abu spinduliai vienodi ir lygs r (taip gaunamas apskritimas,
// kuris yra atskiras elipss atvejis).
end;
ReadLn;
end.
Isaugokite ir vykdykite sukurt program. Jei visk atlikote teisingai, ekrane turtumte matyti pana
vaizd:
Ibandykite, kaip veikia programa parinkus kitas elipss spinduli reikmes. Pavyzdiui, pakeit kreipin
procedr FillEllipse tokiu:
FillEllipse (x, y, r, 2 * r);
ekrane matysite vaizd, pana pateikt:
80
Ketvirtas ingsnis. Judesio programavimas.
Nordami suprogramuoti judes pasinaudosime galimybe apgauti mogaus ak: rodant kelet ar
keliolika paveikslli, tam tikru laiko intervalu. Laiko tarpas apraomas milisekundmis t. Norim laiko
tarp aprao procedra Delay (t). i procedra yra bibliotekoje Crt.
Treiame ingsnyje sukurt program papildykite prijungdami bibliotek Crt: uses Graph, Crt;
Program cikle papildykite kreipiniu procedr Delay: Delay (500);
Isaugokite ir vykdykite sukurt program. Kreipinyje procedr Delay pakeiskite laiko tarpo
reikm ir stebkite situacij. Pastebjote, kad tarpas tarp apskritim pasirodymo keiiasi.
Penktas ingsnis. Garsai.
Nordami papildyti sukurt program garsais, pasinaudosime bibliotekos Crt procedra Sound (garso
danis).
Prie kreipin procedr Delay raykite kreipin procedr Sound: Sound (500);
Isaugokite ir vykdykite sukurt program. Pastebjote, kad parodant kiekvien nauj apskritim,
pasigirsta garsas. Kreipinyje procedr Sound pakeiskite danio reikm ir stebkite situacij. Itirkite,
kokio danio garsai erzina klaus, kokio danio gars jau nebegirdite.
Isamiai visos bibliotek Graph ir Crt procedros ir funkcijos yra apraytos FPS terps inyne, daug
pavyzdi atrasite internete.
Uduotys
1. Pakeiskite antrame ingsnyje sukurt program taip, kad grafiniame ekrane bt rodomi ne apskritimai,
o staiakampiai. Staiakampis pieiamas naudojant bibliotekos Graph procedr
Rectangle (x1, y1, x2, y2).
ia x1, y1 staiakampio kairiojo virutinio kampo koordinats, x2, y2 staiakampio deiniojo
apatinio kampo koordinats. Staiakampio koordinats turi bti generuojamos atsitiktinai.
2. Pakeiskite treiame ingsnyje sukurt program taip, kad grafiniame ekrane bt rodomi vairiais ratais
upildyti vairaus dydio staiakampiai. Upildytas staiakampis pieiamas naudojant bibliotekos Graph
procedr
Bar (x1, y1, x2, y2).
ia x1, y1 staiakampio kairiojo virutinio kampo koordinats, x2, y2 staiakampio deiniojo
apatinio kampo koordinats. Staiakampio koordinats turi bti generuojamos atsitiktinai. Program
papildykite kreipiniais procedras Delay ir Sound.
81
2.13. Reklaminiai uraai grafiniame ekrane
Atlikdami darb imoksite panaudoti grafikos galimybes reklamini ura ekrane krimui.
Pirmas ingsnis. Bibliotek Graph ir Crt prijungimas, ekrano fono upildymas atsitiktinai
generuojamais skirting spalv takais.
Sukurkite program:
program Darbas13;
uses Graph, Crt;
x, y : integer;
// Tako koordinatms
s : integer;
// Tako spalvai
i : integer;
begin
Randomize;
for i := 1 to 10000 do
begin
x := Random (1000);
y := Random (800);
s := Random (256);
PutPixel (x, y, s);
end;
ReadLn;
end.
ioje programoje naudojama bibliotekos Graph procedra PutPixel(x, y, spalva), kuri ekrane
vaizduoja atsitiktinai sugeneruotos spalvos tak, kurio koordinats (x; y) yra sveikieji skaiiai,
sugeneruoti panaudojant standartin Paskalio funkcij Random.
Isaugokite ir vykdykite sukurt program. Jei visk atlikote teisingai, ekrane turtumte matyti daug
vairiaspalvi tak.
Antras ingsnis. Programos papildymas reklaminiu urau.
Nordami program papildyti reklaminiu urau, panaudosime bibliotekos Graph procedr
OutTextXY (x, y, tekstas), ia x ir y tako, nuo kurio pradedamas rayti tekstas, koordinats,
tekstas viengubose kabutse raomas tekstas. Jei procedr uraysime OutText (tekstas),
tuomet tekstas bus raomas nuo nuo grafinio ymeklio.
Programoje prie ciklo sakin terpkite kreipin procedr OutText:
OutTextXY (20, 20, 'Programuojame Paskaliu');
Isaugokite ir vykdykite sukurt program. Jei visk atlikote teisingai, ekrane turtumte matyti daug
vairiaspalvi tak ir ura Programuojame Paskaliu.
Treias ingsnis. Reklaminio urao teksto rifto, krypties, dydio keitimas.
Nordami programoje nustatyti reklaminio urao teksto parametrus, eilute panaudosime bibliotekos
Graph procedr SetTextStyle (sriftas, kryptis, dydis). Parametras sriftas leidia
pasirinkti vien i 5 rift. parametras gyja reikmes nuo 0 iki 4. Parametras kryptis nurodo raymo
krypt: jei parametras kryptis lygus nuliui, tekstas raomas horizontaliai, jei 1 vertikaliai. Parametras
dydis gali bti skaiius nuo 1 iki 10.
Programoje prie reklamins eiluts raymo sakin terpkite kreipin procedr SetTextStyle:
SetTextStyle (4, 0, 5);
vaizd:
82
Kreipinyje procedr SetTextStyle pakeiskite parametr reikmes ir stebkite situacij. Itirkite,

kaip keiiasi reklaminio urao tekstas keiiant parametr reikmes.
Ketvirtas ingsnis. Reklaminio urao teksto spalvos, dydio, krypties, vietos ekrane keitimas.
Nordami pakeisti reklaminio urao viet ekrane vietoj procedros OutTextXY paraykite procedr
OutText, kuri dkite cikl:
program Darbas13;
uses Graph;
x, y : integer;
// Tako koordinatms
s : integer;
// Tako spalvai
i : integer;
xe, ye : integer;
// Teksto koordinats
sr, kr, d : integer;
// Teksto formatai
sp : integer;
// Teksto spalva
begin
Randomize;
for i := 1 to 10000 do
begin
x := Random (1000);
y := Random (800);
s := Random (256);
PutPixel (x, y, s);
end;
begin
xe := Random (1000);
ye := Random (800);
sr := Random (5);
kr := Random (2);
d := Random (11);
sp := Random (256);
SetColor (sp);
SetTextStyle (sr, kr, d);
OutTextXY (xe, ye, 'Programuojame Paskaliu');
Delay (1000);
end;
ReadLn;
end.
83
vaizd. Skirtingais laiko tarpais skirtingose ekrano vietose atsiranda skirtingos spalvos, dydio ir krypties
uraai.
Uduotis
Sukurkite ura ekrane, kuris reklamuot domi knyg. Kurdami ura panaudokite vairias bibliotek
Graph ir Crt procedras ir funkcijas, suteikite judes, papildykite garsais.
84
2.14. Judesys.
Paprasiausio judesio imitacija gaunama t pat paveiksl perpieiant kitoje ekrano vietoje. Vien judesio
ingsn sudaro trys veiksmai: paveikslo pieimas, pauz ir paveikslo valymas. Nepertraukiamo judesio
vaizdas priklauso nuo paveikslo dydio, pieimo bdo ir pauzs ilgio. Sudtingesnius paveikslus tikslinga
vien kart nupieti ir isaugoti atmintinje santykinmis koordinatmis. Vliau toks paveikslas rodomas
skirtingose ekrano vietose. ia demonstruojamas paprasiausias perpieimo bdas. Sudtingesnius bdus ir
daugiau informacijos galite rasti literatroje. Norint jais pasinaudoti, reikia inoti sudtingesnes duomen
struktras ir algoritmus.
Pirmas ingsnis. Grafinio ekrano aktyvizacija.

Po programos antrate terpkite sakin uses Graph; iuo sakiniu prijungiama grafikos biblioteka.
Paraykite grafinio ekrano aktyvizacijos procedr ir j ibandykite.
program Darbas14;
uses Crt, Graph;
//--------------------------------------------------------------------------// Aktyvizuojamas grafinis ekranas. Grina ekrano plot dx ir aukt dy
procedure Ekranas( var dx, dy : integer);
begin
gd := D8bit;
// Grafin tvarkykl
gm := m640x480;
// Tvarkykls modifikacija
InitGraph(gd,gm,'');
// Grafinio lango aktyvizavimas
if GraphResult <> grOk then
// Aktyvizacijos patikra
begin
WriteLn('640x480x256 ekranas nedirba!');
Halt(1)
end;
dx := GetMaxX;
dy := GetMaxY; // Tak skaiius (ekrano plotis ir auktis)
end;
//--------------------------------------------------------------------------var
dx, dy : integer;
begin
Ekranas(dx, dy);
// Grafinio ekrano aktyvizacija
WriteLn(dx, ' ', dy); // Tekstiniame ekrane spausdinamas grafinio ekrano plotis ir auktis
ReadLn;
CloseGraph;
end.
Ankstesniuose darbuose grafinio ekrano dydis buvo parenkamas pagal nutyljim ir sutapo su kompiuterio
ekranu. Buvo parenkama standartin grafinio ekrano tvarkykl. Norint sumainti ekran, reikjo pele
paspausti vidurin ekrano viruje deinje esant mygtuk:
Sumainus lang, po juo rasime tekstin programos lang. J galima aktyvizuoti pele. Taip pat galime
padaryti pele perjungus kompiuterio ekrano apaioje paspaudus langus perjungianius mygtukus:
Sumainus grafin ekran, galite parinkti jo dyd taip, kad bt matomi abu langai, pavyzdiui programoje
Darbas12, galime gauti tok lang idstym ekrane:
85
Aktyvizuojant grafin lang, galima parinkti grafinio

lango tvarkykl ir jos modifikacij. Grafinio ekrano
tvarkykls priklauso nuo kompiuterio konstrukcini
savybi, todl skirtinguose kompiuteriuose gali bti
skirtingos tvarkykls. Galim tvarkykli sra galima
surasti Free Pascal inyne arba tam skirtoje
literatroje. io darbo grafinis ekranas gaunamas i
karto maesnis.
Antras ingsnis. Skrituli pieimas.
Paraome procedr, kuri ekrane atsitiktinai pieia nurodyt skaii spalvot skrituli ir j
ibandome. Gauname vaizd, pana gautam Darbas12 programoje.
program Darbas14;
uses Crt, Graph;
//--------------------------------------------------------------------------// Ekrane pieiami n skrituli. Ekrano plotis dx ir aukitis dy
procedure Skrituliai( n : byte; dx, dy : integer);
var x, y, r : integer; // Skritulio koordinats ir spindulys
i : integer;
begin
Randomize;
for i := 1 to n do begin
SetFillStyle( Random(11), Random(15) );
// Parenkama upildymo ratas
SetColor(Random(11) ); SetLineStyle( 0, 0, 1 ); // Kontro spalva ir linija
x := Random( dx - 30 ) + 20;
y := Random( dy - 30 ) + 20;
r := Random( 30 ) + 5;
FillEllipse( x, y, r, r );
end;
end;
//====================================================================
var
dx, dy : integer;
begin
Ekranas(dx, dy);
WriteLn(dx, ' ', dy);
// Tekstiniame ekrane spausinamas grafinio ekrano plotis ir auktis
Skrituliai( 25, dx, dy ); // Ekrane pieiami 25 skrituliai
ReadLn;
CloseGraph;
end.
Treias ingsnis. Sauluts pieimas.

Nupieiame saulut. Tam sukuriama tokia procedra.
86
program Darbas14;
uses Crt, Graph;
//--------------------------------------------------------------------------procedure Skrituliai( n : byte; dx, dy : integer);
//--------------------------------------------------------------------------// Pieiama saulut, kurios koordinats ekrane (x, y), o spindulys r
procedure Saulute(
x, y, r : integer);
var t, t1, t2, t3, t4, t5 : word;
begin
// Skaiiuojamos sauluts element santykins reikms, priklausomai nuo pateikt per parametrus dyi
t := r div 4; t1 := r div 5; t2 := r div 7;
t3 := r div 8; t4 := r div 2; t5 := Trunc( r / Sqrt( 2));
SetColor( Black );
SetFillStyle( 1, Yellow );
FillEllipse( x, y, r, r );
// Geltonas skritulys
SetFillStyle( 1, White );
FillEllipse( x-t, y-t4, t2, t1 );
SetFillStyle( 1, Black );
FillEllipse( x-t, y-t4+3, t3, t3 );
Arc( x, y+t-2, 180, 360, r-t );
Arc( x, y-t,
210, 340, r-2 );
SetFillStyle( 1, Red );
// Akys
FillEllipse( x+t, y-t4, t2, t1 );
FillEllipse( x+t, y-t4+3, t3, t3 );
// ypsena
FloodFill( x, y-t+r, Black );
SetColor( red );
// Nosyt
SetLineStyle( 0, 0, 1 );
Arc( x, y+2, 30, 150, t-2 );
end;
//====================================================================
var
dx, dy : integer;
x, y : integer;
begin
Ekranas(dx, dy);
// Tekstiniame ekrane spausinamas grafinio ekrano plotis ir auktis
Skrituliai( 25, dx, dy );
// Ekrane pieiami 15 skrituli
x := dx div 2;
y := dy div 2; // Saulut bus pieiama ekrano centre
Saulute( x, y, r );
// Saulut ekrano centre
ReadLn;
CloseGraph;
end.
Ibandykite program, nupiedami saulut ekrano centre. Sauluts spindulys nurodomas konstanta, kuri
paraoma programos pradioje const r = 40;
Ketvirtas ingsnis. Sauluts judesys.

Saulut juds ekrane. Kai pasieks ekrano rib, bus ekrane nupieiami papildomi nauji skrituliai ir saulut
pakeis savo judjimo krypt. Kryptis parenkama atsitiktin.
Kadangi saulut sudaro daug element, tai j kiekvien kart naujai perpieti kitoje vietoje netikslinga. Labai
sults judesys. Nupiet sauluts paveiksl uraysime atmintinje. Nereiks kiekvien kart kitoje ekrano
naujai pieti. Pakaks i atminties turim vaizd padti kitoje ekrano vietoje. Aiku, ankstesns vietos sauluts
vaizd reikia valyti.
87
program Darbas14;
uses Crt, Graph;
//--------------------------------------------------------------------------procedure Skrituliai( n : byte; dx, dy : integer);
//--------------------------------------------------------------------------procedure Saulute(
x, y, r : integer);
//--------------------------------------------------------------------------// Generuojama nauja judesio kryptis: koordinai pokyio reikms x ir y
procedure Eiti( var x, y : integer );
var al : integer;
begin
repeat
al := Random( 360 );
x := Trunc( Cos( al / 180 * Pi )*20);
y := Trunc( Sin( al / 180 * Pi )*20);
until ( x <> 0 ) or ( y <> 0 );
end;
//--------------------------------------------------------------------// Sauluts judesys ekrane
procedure Judesys(k, x, y, dx, dy : integer; S : pointer);
var zx, zy : integer;
// Sauluts koordinai pokytis
begin
PutImage( x-k, y-k, S^, 1 );
// Saulut perkeliama ekran
repeat
Eiti( zx, zy );
// Saulutes judesio zingsniai
Skrituliai( 25, dx, dy );
while ( x < dx-k ) AND ( x > k ) AND // Judesys iki ekrano krato
( y < dy-k ) AND ( y > k ) AND
NOT KeyPressed
do begin
// Saulut perkelima ekran
Delay( 10 );
// Sauluts valymas senoje vietoje
x := x + zx; y := y + zy;
// Naujo vietos koordinats
end;
x := x - zx;
y := y - zy;
// Sugrtama ekran
until KeyPressed;
end;
//====================================================================
var
dx, dy : integer;
x, y : integer;
k : integer;
S : pointer;
// Rodykl atmintins viet, kurioje bus saugomas paveikslas
begin
Ekranas(dx, dy);
// Tekstiniame ekrane spausdinamas grafinio ekrano plotis ir auktis
k := 2*r;
// Sauluts skersmuo
x := dx div 2;
y := dy div 2; // Ekrano centras
GetMem( S, ImageSize( 0, 0, 2*k, 2*k )); // Atminties iskyrimas saulutei saugoti
Saulute( x, y, r );
// Pieiama saulut
GetImage( x-k, y-k, x+k, y+k, S^ );
// Saulut uraoma atmintinje
Judesys(k, x, y, dx, dy, S);
// Sauluts judesio ekrane imitacija
88
ReadLn;
CloseGraph;
end.
Judesio valdymo ciklas begalinis. Darbas nutraukiamas, kai

paspaudiamas bet koks klavias klaviatroje. Taiau funkcija
KeyPressed dirba tik tekstiniame ekrane. Taigi, reikia pele pereiti
tekstin ekran. Perjus, darbas grafiniame ekrane nenutrksta.
89
2.15. Laikrodis.
Uduotis. Reikia sukurti laikrod, veikiant grafiniame reime. Laikrodio fone idstyti valand skaiius
nuo 1 iki 12. Laikrodis privalo turti tris rodykles: valandoms, minutms ir sekundms rodyti. Rodykls turi
judti.
Sprendiant udavin bus reikalingi du dalykai: trigonometrijos inios ir ekrano grafinis reimas.
Pirmiausia prisiminkime trigonometrij ir j susiekime su laikrodiu. Paprasiausio laikrodio paviriuje
(daniausiai apskritimu) yra suraytos valand reikms nuo 1 iki 12. Kaip inote apskritimas turi 360
laipsni. Taigi, valandos yra idstytos kas 30 laipsni (360/12), minuts ir sekunds kas 6 laipsniai.
Paprasiausias laikrodis turi tris rodykles valandoms, minutms ir sekundms rodyti. Kiekviena rodykl yra
tam tikro ilgio, storio ir spalvos. ios rodykls sukasi ratu ir rodo laik (1 pav.).
t
y
k
x
1 pav. Grafinis laikrodio vaizdas

inant apskritimo spindul c bei kamp k (radianais) tako (laiko) t koordinates x ir y galima apskaiiuoti
taikant formules:
sin(k) = y / c ir
cos(k) = x / c;
I i formuli ireikiame x = c cos(k) ir y = c sin(k).
Jeigu inome kamp k laipsniais, tai j galima ireikti radianais: krad = klaips ( / 180).
Paskutines tris formules pritaikysime savo uduoiai vykdyti, t. y. laikrodio rodykli pozicijai keisti.
Laiko reikmes galima gauti panaudojant procedr GetTime, kuri grina kompiuterio sistemin laik:
valandas, minutes, sekundes ir imtsias sekunds dalis. i procedra imama i bibliotekos Dos.
Kompiuterio ekrane visi vaizduojami elementai sudaromi i tak. Tekstiniame ekrano darbo reime visos
ivedimo ekran priemons dirba fiksuoto dydio simboliais, kuri forma yra saugoma Free Paskalio kalbos
failuose. iuo atveju ekrane galima formuoti praneimus, naudojant tik simbolius, esanius konkreiame
simboli rinkinyje. Free Paskalio bibliotekoje Graph yra priemoni rinkinys darbui su kompiuterio ekranu
grafiniame reime. Programuotojas gali pats formuoti vaizdus i tak. Norint dirbti grafiniame reime,
reikia kompiuterio ekran paruoti. Tam naudojamos specialios priemons.
procedure InitGraph(var graphDriver : integer;
var
graphMode : integer;
driverPath : string);
90
i procedra paruoia kompiuterio ekran darbui grafiniu reimu, t. y. sukuria grafin lang Graph window
application.
graphDriver kintamasis, kurio reikm paprogramei nurodo, kokia bus ekrano grafikos tvarkykl.
graphMode konstanta, kuri nusako ekrano format: tak skaii, spalvas ir j kiek, grafini puslapi kiek.
Nenurodius reikms, parenkama standartin pagal nutyljim.
driverPath kelias katalog, kur saugomas grafikos tvarkykls failas.
grOK standartin konstanta, kurios reikm ymi, kad grafikos reimas jungtas teisingai.
function GraphResult : integer funkcija, kurios rezultatas yra reikm, rodanti, ar skmingai buvo
jungtas grafikos reimas. Galim neskmi prieast rodo funkcijos grinama reikm.
procedure CloseGraph; ijungia grafikos reim. Grtama tekstin darbo reim.
function GetMaxX : integer;
function GetMaxY : integer;
ios funkcijos grina grafinio ekrano tak kiek horizontalia ir vertikalia kryptimis. Tai galimos
didiausios X ir Y koordinai reikms. Atskaitos takas yra kairysis virutinis ekrano kampas, kurio
koordinats (0, 0).
Dabar galima praktikai palaipsniui pereiti grafin ekrano darbo reim.
Pasiruoimas darbui. Sukurkite katalog programos failams saugoti, atverkite FPS terp ir sukurkite
programos fail Darbas15.pas.
Pirmas ingsnis. Grafinio programos darbo reimo patikrinimas.

Uraykite programos tekst ir j vykdykite.
program Darbas15;
uses Crt, Dos, Graph;
var graphdriver, graphmode, klaida : integer;
// Program perveda grafin darbo reim. Jeigu vyksta klaida, programa stabdoma
procedure GrafinisEkranas;
begin
graphdriver := vga;
InitGraph ( graphdriver, graphmode, '' );
klaida := GraphResult;
if klaida <> grOk then
begin
WriteLn ( 'Klaidos kodas: ', klaida );
WriteLn ( 'Programa nutraukta' );
ReadLn;
Halt (1);
end
end;
// --------------------------------- Pagrindin programa -------------------------------------------var
mx, my : integer;
// Grafinio lango imatavimai
cx, cy : integer;
// Grafinio lango centro koordinats
begin
GrafinisEkranas;
// Pereinama grafin darbo reim
mx := GetmaxX;
my := GetmaxY;
cx := mx div 2;
cy := my div 2;
Circle(cx, cy, 100); // Lango centre pieiamas apskritimas
91
repeat
until KeyPressed;
CloseGraph;
ReadLn;
end.
vykd program, ekrane matysite grafin lang Graph window application su apskritimu lango centre:
Darome ivad, kad perjimas grafin programos darbo reim buvo skmingas. Darb galima tsti toliau.
Antras ingsnis. Laikrodio valand skaii, nuo 1 iki 12 suraymas grafiniame ekrane
Papildykite ankstesn program sekaniomis trimis paprogrammis ir j vykdykite.
// Grina laikrodio rodykls koordinat x; laikas - laiko reikm; ilgis - rodykls ilgis
function X_Koord( laikas : word; ilgis : integer ) : integer;
// Grina laikrodio rodykls koordinat y; laikas - laiko reikm; ilgis - rodykls ilgis
function Y_Koord( laikas : word; ilgis : integer ) : integer;
// Nubraiomas laikrodio fonas, t. y. aplink idstoma 12 skaii (valand)
// mx, my - grafinio lango dydis; cx, cy - grafinio lango centro koordinates
procedure Fonas ( mx, my, cx, cy : integer );
Pagrindinje programoje vietoj eiluts

Circle(cx, cy, 100);
// Lango centre pieiamas apskritimas
dkite kreipin procedr Fonas
Fonas ( mx, my, cx, cy ); // Nubraiomas laikrodio fonas
program Darbas15;
begin
graphdriver := vga;
92
begin
WriteLn ( 'Programa nutraukta.' );
ReadLn;
Halt (1);
end
end;
var k : real;
x : integer;
begin
if laikas > 360 then
laikas := laikas - 360;
k := laikas * Pi / 180;
x := - Round ( ilgis * cos( k ) * 639 / 250 );
X_Koord := x;
end;
var k : real;
y : integer;
begin
k := laikas * Pi / 180;
y := - Round ( ilgis * sin( k ) );
Y_Koord := y;
end;
var x, y : integer;
i : integer;
sk : string;
begin
Bar ( 40, 10, mx - 40, my - 10 );
for i := 1 to 12 do
begin
Str ( i, sk );
SetTextStyle ( 0, 0, 2 );
x := X_Koord ( i * 30 + 90, 70 );
y := Y_Koord ( i * 30 + 90, 70 );
MoveTo ( cx + x, cy + y );
SetTextJustify ( 1, 1 );
SetColor ( Green );
OutText ( sk );
end
end;
mx, my : integer;
cx, cy : integer;
93
begin
GrafinisEkranas;
mx := GetmaxX;
my := GetmaxY;
cx := mx div 2;
cy := my div 2;
// Circle(cx, cy, 100); // Lango centre pieiamas apskritimas
repeat
until KeyPressed;
CloseGraph;
ReadLn;
end.
vykd program ekrane matysite grafin lang Graph window application su laikrodio fonu:
---------------------------------------------------------------------------
Treias ingsnis. Trys laikrodio rodykls ir j judjimas ratu.

Papildykite ankstesn program dar viena procedra
// Bria linij nukreipt i centro (taskas (cx, cy)) atitinkam tak, kuri nusako laikas ir ilgis
// spalva - linijos spalva; storis - linijos storis
procedure Rodykle( cx, cy : integer; spalva : integer;
laikas : word; ilgis, storis : integer );
Pagrindinje programoje cikl repeat until papildykite reikalingais skaiiavimais, t. y. sisteminio

kompiuterio laiko skaitymo procedra GetTime bei trimis kreipiniais procedr Rodykle
Ibandykite program.
program Darbas15;
begin
graphdriver := vga;
94
begin
WriteLn ( 'Programa nutraukta' );
ReadLn;
Halt (1);
end
end;
var k : real;
x : integer;
begin
k := laikas * Pi / 180;
x := - Round ( ilgis * cos( k ) * 639 / 250 );
X_Koord := x;
end;
var k : real;
y : integer;
begin
k := laikas * Pi / 180;
y := - Round ( ilgis * sin( k ) );
Y_Koord := y;
end;
var x, y : integer;
i : integer;
sk : string;
begin
Bar ( 40, 10, mx - 40, my - 10 );
for i := 1 to 12 do
begin
Str ( i, sk );
SetTextStyle ( 0, 0, 2 );
x := X_Koord ( i * 30 + 90, 70 );
y := Y_Koord ( i * 30 + 90, 70 );
MoveTo ( cx + x, cy + y );
SetTextJustify ( 1, 1 );
SetColor ( Green );
OutText ( sk );
end
end;
// Bria linij nukreipt i centro (taskas (cx, cy)) atitinkam tak, kuri nusako laikas ir ilgis
// spalva - linijos spalva; storis - linijos storis
procedure Rodykle( cx, cy : integer; spalva : integer;
95
laikas : word; ilgis, storis : integer );
begin
MoveTo ( cx, cy );
SetLineStyle ( 0, 0, storis );
SetColor ( spalva );
LineRel ( X_Koord ( laikas, ilgis ), Y_Koord ( laikas, ilgis ) )
end;
mx, my : integer;
cx, cy : integer;
val, min, sek, sek1, ss : word;
begin
GrafinisEkranas;
mx := GetmaxX;
my := GetmaxY;
cx := mx div 2;
cy := my div 2;
// Circle(cx, cy, 100); // Lango centre pieiamas apskritimas
sek := 0;
sek1 := 0;
repeat
while sek = sek1 do
GetTime ( val, min, sek1, ss );
sek := sek1;
SetColor ( Yellow );
FillEllipse ( cx, cy, Round ( 50 * 639 /
Rodykle ( cx, cy, red, sek * 6 + 90, 50,
Rodykle ( cx, cy, 8, min * 6 + 90, 45, 3
Rodykle ( cx, cy, Black, val * 30 + 90 +
Sound ( 100 );
Delay ( 50 );
NoSound;
until KeyPressed;
CloseGraph;
ReadLn;
end.
250 ), 52 );
1 );
);
Round((min * 6 + 90) / 60), 25, 5);
96
vykd program ekrane matysite grafin lang Graph window application su laikrodio fonu ir
rodyklmis:
---------------------------------------------------------------------------
Ketvirtas ingsnis. Papildomi programos pertvarkymai.

Pakeiskite laikrodio fono ir skaii spalvas kitomis.
Pakeiskite laikrodio skleidiamo garso dan ir jo ilgum.
Laikrodio fone padarykite sekundi ir minui atymas.
97
3.
Pagrindins Paskalio kalbos konstrukcijos
Vadovavo kuriant programavimo kalbas: Euler, Algo W, Pascal, Modula,

Modula-2, Oberon. Sukr paprast programavimo kalb PL/0, skirt
kompiuterio projektavimui iliustruoti.
Daug dmesio skyr programavimo mokymo metodikai. Jo 1975 m. parayta
knyga Algoritmai + Duomen struktros = Programos buvo plaiai pripainta
visame pasaulyje ir labai vertinga dar iuo metu.
Paskalio programavimo kalba buvo sukurta iskirtinai programavimo mokymui,
taiau ji ir po iai dienai skmingai naudojama net programuotoj profesonal.
Modula serijos programavimo kalbos buvo sukurtos Paskalio kalbos pagrindu ir
skirtos mokymui, taiau jos nepasiymjo populiarumu.
veicar mokslininkas
Niklausas Virtas (Niklaus Emil Wirth),
sukrs programavimo kalb Pascal
Gim 1934 m.

Kintamieji skirti duomenims saugoti. J vardai sudaromi naudojant raides ir skaitmenis, taiau pirmu
simboliu turi bti raid. Kintamieji apraomi apraym srityje, ymint odiu var (angliko odio
variable santrumpa). Kiekvienam kintamajam reikia nurodyti, kokio tipo duomenis jis saugos. Kintamojo
apraymo struktra: kintamojoVardas : duomenTipas; Jeigu yra keletas to paties tipo kintamj,
tuomet galima juos ivardyti viename sakinyje, skiriant vardus kableliu. Pagrindiniai duomen tipai
nurodomi tokiais odiais:
real realiesiems skaiiamas,
integer sveikiesiems skaiiams,
boolean lognms reikmms,
char simbliams.
Pavyzdiui:
var a, b, c, y: real;
// Realaus tipo kintamieji
i, k, a2 : integer; // Sveikojo tipo kintamieji
simb
: char;
// Simbolinio tipo kintamasis
Kompiliatorius kiekvienam kintamajam kompiuterio atmintinje skiria tiek vietos, kiek reikia nurodyto tipo
duomenis saugoti. Kintamieji reikmes (duomenis) gauna duomen vedimo (skaitymo) sakiniais arba
priskyrimo sakiniais. Kintamieji negali saugoti kito duomen tipo reikmi.

Duomen apdorojimo veiksmai apraomi priskyrimo sakiniais, kuri struktra:
kintamojoVardas := Reikinys;
ia simbolis := ymi priskyrimo operatori, o Reikinys aprao, kokius veiksmus, kokia tvarka ir su
kokiais argumentais reikia atlikti. Kairiojoje operatoriaus := pusje raytas kintamojo vardas nurodo, kam
suteikiama apskaiiuota reikinio reikm. Daniausiai vartojami aritmetiniai reikiniai, apraantys
aritmetinius skaiiavimus ir atitinkantys mums prast algebrini reikini svok.
Pavyzdiui, priskyrimo sakinys y := x * x; reikia, kad argumento x reikm keliama kvadratu ir
rezultatas priskiriamas kintamajam y. Priskyrimo sakinio raymo forma artima lygybs iraikai, taiau tarp
i struktr yra esminis skirtumas. Lygybmis nurodoma egzistuojanti priklausomyb, patvirtinamas tam
tikras faktas. Tuo tarpu priskyrimo sakiniai aprao procesus, kuriems bdinga reikmi kaita laikui bgant,
todl taisyklingas ir toks sakinys:
a := a + 1;
Jis nurodo, kad senoji kintamojo a reikm turi bti padidinta vienetu, o rezultatas vl pavadintas a.
veiksm galima aprayti lygtimi:
98
a(nauja) = a(sena) + 1.
Priskyrimo sakiniuose, deinje priskyrimo operatoriaus pusje, gali bti nurodyti vairi tip reikiniai.
Todl btina sekti, kad priskyrimo operatoriaus kairiojoje pusje nurodyto kintamojo tipas atitikt reikinio,
esanio deiniojoje pusje, reikms tip.
Reikiniuose galima naudoti tik tokius kintamuosius, kuri reikms apibrtos anksiau raytuose
programos sakiniuose.
Skiriami trys reikini tipai:
Aritmetinis reikinys, kuriame yra kintamieji ir konstantos jungiami aritmetini operacij enklais ir
kuri skaiiavimo rezultatas yra skaiius; reikinius uraant naudojami paprastieji skliaustai, gali
bti kreipiniai funkcijas, kuri darbo rezultatas yra skaiius (pvz, Sin funkcija).
Santykio reikinys. Tai du aritmetiniai reikiniai, tarp kuri raomas santykio operacijos enklas (>,
<, <=, >=, <>, =). Tokio reikinio rezultatas yra login reikm TRUE (tiesa) arba FALSE (netiesa).
Loginis reikinys. Tai reikinys, kuriame santykio reikiniai jungiami logini operacij enklais.
Paskalyje jie ymimi odiais AND (ir), OR (arba), NOT (ne). Reikinio rezultatas yra login reikm
TRUE arba FALSE.
Santykio ir loginiai reikiniai daniausiai naudojami ciklo ir slygos sakiniuose. Kadangi santykio reikiniai
yra logini reikini dalis, todl apbendrintai jie vadinami loginiais reikiniais.

Duomenys kompiuteriuose gali bti vedami i vairi rengini ir j valdymas yra gana sudtingas dalykas.
ia reikia nurodyti ne tik perduodamus duomenis, bet ir vairias rengini parengimo bei duomen tvarkymo
operacijas. Asmeniniuose kompiuteriuose standartinis vesties renginys yra klaviatra.
Duomen vedamo klaviatra procedros:
Read (kintamjSraas);
ReadLn(kintamjSraas);
Duomen vedimo procesas programos darbo metu vykdomas dviem etapais: duomen surinkimu klaviatra
ir duomen perdavimu kintamiesiems. I pradi vedimo procedra stabdo kompiuter ir laukia, kol
klaviatra renkami duomenys. Jie kaupiami specialiame buferins atmintins taise ir vaizduojami ekrane.
Tuo metu jie gali bti taisomi vaizdinmis redagavimo priemonmis. Nuspaudus vedimo klavi, kuris
ymimas simboliu arba odiu Enter, buferyje saugomi duomenys paskirstomi procedros Read arba
ReadLn argument srae ivardintiems kintamiesiems, kurie nurodo, kiek ir kokio tipo duomen turi bti
vesta, bei kaip jie turi bti paskirstyti programos kintamiesiems.
Procedros Read ir ReadLn skiriasi duomen atrinkimo i pagalbins atmintins (buferio) bdais. Procedra
Read visuomet ima tiek duomen, kiek jos srae yra parametr, o procedra ReadLn ima visus buferyje
esanius duomenis, kurie vesti prie paspaudiant klavi Enter. Toki pastarosios procedros savyb
nurodo ir jos vardas ReadLn, kuris sudarytas i dviej angl kalbos odi: Read (skaityti) ir Line (eilut).
Pavyzdiui, jei atliekama komanda Read(a, b);, taiau vesime tik vien skaii 25, kintamajam a bus
suteikta reikm 25 ir kompiuteris lauks kol vesime b reikm. Jei, vykdant Read(a, b);, vesime tris
reikmes: 25 -5 10, kintamiesiems a ir b bus paskirstytos pirmosios dvi reikms, o treioji liks buferyje ir
lauks naujo skaitymo veiksmo.
Jeigu tokia pati situacija susidaryt vykdant procedr ReadLn, treioji reikm 10 bt prarasta, nes i
procedra atmeta perteklinius duomenis, kurie lieka paskirsius perskaitytos eiluts duomenis.
Duomen grupes vedant vienoje eilutje, reikms atskiriamos tarpo arba tabuliacijos klaviais.
Procedr ReadLn galima naudoti ir be parametr. Programa laukia, kol, paspaudus klavi Enter, bus
vykdyta i procedra. Tai patogu derinant programas, ivedant ekran didelius duomen kiekius ir kitais
atvejais.
99
Apraant duomen vedim, prie kreipiantis procedr ReadLn (arba Read) patariama rayti ivedimo
sakin, kuris paaikint, koki duomen programai reikia. Tokia ivedimo ir vedimo sakini pora danai dar
vadinama duomen uklausa (arba dialogu). Pavyzdiui, norint vesti mokinio svor (kintamasis sv) reikt
programoje rayti toki uklaus:
Write('veskite mokinio svor: ');
ReadLn(sv);
WriteLn('veskite mokinio svor');
ReadLn(sv);
arba
Ji nurodo, kad kompiuteriui ekrane reikia suformuoti praneim veskite mokinio svor ir laukti, kol
klaviatra bus surinktas skaiius (svoris).
3.4. Rezultat (duomen) ivedimas ekrane

Standartinis asmenini kompiuteri ivesties renginys, kur duomenys nukreipiami procedromis Write ir
WriteLn, yra ekranas. Kreipini ias procedras sintaks:
Write(duomenSraas);
WriteLn(duomenSraas);
Ivedam duomen srauose galima nurodyti kintamuosius, konstantas ir reikinius. Be to, gali bti aprayti
ir atskiriems duomenims skirti laukai. Duomen srao elemento struktra:
Duomuo[:s1[:s2]]
ia lautinai skliaustai rodo, kad tos dalies gali nebti. Sveikojo skaiiaus tipo konstanta s1 elemento aprae
nurodo jam skiriamo lauko dyd, o konstanta s2 raoma tik realiesiems skaiiams, turintiems sveikj ir
trupmenin dalis. Tai trupmeninei daliai skirt simboli skaiius. Pavyzdiai:
Write(a);
WriteLn(a:5, ' ', b:6:2);
Jei ivedant realiuosius skaiius trupmeninei daliai skiriamo lauko dydis nenurodomas, skaiiai vaizduojami,
standartine iraika, kurioje vartojamas daugiklis 10n. Laipsnio pagrindas ymimas simboliu E ir po jo
raomas sveikuoju skaiiumi ireiktas laipsnio rodiklis n. Pavyzdiui, 1.254E-05 atitinka 1.25410-5.
Ekrane ivedami duomenys pradedami rayti nuo ymeklio pozicijos, vadinamos aktyvija ekrano pozicija.
Jei atliekama procedra Write, ekrane suraius duomenis, aktyvioji ekrano pozicija lieka ties paskutiniojo
lauko riba. Procedra WriteLn aktyvij ekrano pozicij visuomet perkelia naujos eiluts pradi. i
savyb galima panaudoti apraant tuias ekrano eilutes:
WriteLn;
Procedr Write ir WriteLn argumentai gali bti ne tik skaiiai ir kintamieji, bet ir bet kokie tekstiniai
duomenys, kuriuos pageidaujama matyti ekrane. Tokius duomenis argument srae btina rayti tarp
kabui (apostrof). Pavyzdiui, sakinys
WriteLn('Sveiki! Js programa pradeda darb!');
iveda ekrane jo argumento nurodom tekst:

Sveiki! Js programa pradeda darb!
Apraant programos darbo rezultat ivedim, labai patogu procedros WriteLn duomen srae nurodyti
tiek duomen reikmes, tiek juos paaikinanias simboli eilutes. Pavyzdiui, sakinys
WriteLn ('Staiakampio plotas: ', plotas:10:2);
nurodo, kad prie kintamojo plotas reikm bus raomas paaikinimas Staiakampio plotas:
100
3.5. Ciklas while
Ciklas yra naudojamas pasikartojantiems skaiiavimams atlikti. Ciklo while antrat valdo tik vieno sakinio
kartojim. Jeigu reikia kartoti kelis sakinius, tai jie jungiami sudtin sakin ir raomi tarp begin ir end:
while Slyga do
KartojamasSakinys;
while Slyga do
begin
KartojamiSakiniai;
end;
Slyga tai bet koks loginis reikinys, KartojamasSakinys bet koks sakinys (taip pat ir ciklo).
Ciklo while vykdymo tvarka: Patikrinama Slyga. Jei jos reikm yra TRUE (tiesa), tuomet atliekamas
KartojamasSakinys, prieingu atveju jis praleidiamas ir atliekami toliau u ciklo esantys sakiniai.
Organizuojant cikl reikia atkreipti dmes :
Ciklas bus vykdomas be galo daug kart (toks ciklas vadinamas aminuoju ciklu), jeigu
nepasirpinsite, kad atliekant cikl (KartojamasSakinys viduje) Slyga kada nors gaut reikm FALSE.
Jeigu ciklo viduje reikia vykdyti ne vien sakin, o sakini grup, i grup turi bti raoma tarp begin
ir end.
Jei prie pradedant cikl Slyga yra FALSE, KartojamasSakinys ar sakini grup nevykdomas n karto.
Kintamiesiems, sudarantiems Slyga login iraik, prie while sakin esanioje programos dalyje turi
bti suteiktos pradins reikms, o KartojamasSakinys viduje i kintamj reikms turi bti keiiamos
taip, kad kada nors Slyga tapt FALSE.
3.6. Ciklas for

Ciklo for antrat valdo tik vieno sakinio kartojim. Jeigu reikia kartoti kelis sakinius, tai jie jungiami
sudtin sakin, kuris apjungiamas begin end skliaustais. Ciklo parametro reikm turi bti diskretinio tipo.
Paprasiausiu atveju sveikasis skaiius.
Kitimo ingsnis: +1
for cp := R1 to R2 do
KartojamasSakinys;
for cp := R1 to R2 do
begin
KartojamiSakiniai;
end;
Kitimo ingsnis: 1
for cp := R1 downto R2 do
KartojamasSakinys;
for cp := R1 downto R2 do
begin
KartojamiSakiniai;
end;
Vykdymo tvarka. Formaliai for ciklo veiksmus galima aprayti taip:

1. Ciklo parametro cp reikmei priskiriama reikinio R1 reikm. R1 reikm apskaiiuojama
pradedant cikl ir naujai neperskaiiuojama.
2. Skaiiuojama reikinio R2 reikm. Tai bus ciklo parametro paskutin reikm, kuriai esant
ciklas dar bus vykdomas. Ji apskaiiuojama pradedant cikl ir neperskaiiuojama.
3. Jeigu ciklo parametro cp reikm ne didesn u apskaiiuot paskutin reikm, tuomet
atliekami ciklo sakiniai. Prieingu atveju ciklas nutraukiamas.
4. Atlikus ciklo sakinius, cp reikm didinama vienetu ir veiksmai kartojami nuo treiojo ingsnio.
Jeigu cikle yra downto nuoroda, tuomet paskutiniai du ingsniai tokie:
3. Jeigu ciklo parametro cp reikm ne maesn u apskaiiuot paskutin reikm, tuomet
atliekami ciklo sakiniai. Prieingu atveju ciklas nutraukiamas.
4. Atlikus ciklo sakinius, cp reikm mainama vienetu ir veiksmai kartojami nuo treiojo
ingsnio.
101
Slygos sakiniu keiiama nuosekli sakini atlikimo tvarka. Atliekami veiksmai priklauso nuo Slygos: jei
Slyga tenkinama, atliekamas po then esantis PirmasSakinys, jei ne po else esantis AntrasSakinys. Jeigu
reikia atlikti kelis sakinius, kai Slyga tenkinama arba netenkinama, tai jie jungiami sudtin sakin ir
raomi begin end skliaustuose.
if Slyga
then PirmasSakinys
else AntrasSakinys;
if Slyga
then
begin
Sakiniai, atliekami kai slyga tenkinama
end
else
begin
Sakiniai, atliekami kai slyga netenkinama
end;
Galima vartoti sutrumpint slygos sakin, kuriame yra tik aka then ir veiksmai atliekami tik tuomet, kai
Slyga tenkinama.
if Slyga
then PirmasSakinys;
if Slyga
then
begin
Sakiniai, atliekami kai slyga tenkinama
end;
Slygos sakinio then ir else akose galima urayti bet kokius Paskalio kalbos sakinius. Bet kurioje
slygos sakinio akoje galima urayti dar vien slygos sakin, pastarojo akose dar vien ir t.t. Toks
sakinys vadinamas sudtingu slygos sakiniu. Sudting slygos sakini pavyzdiai:
if Slyga1
then if Slyga2
then PirmasSakinys
else AntrasSakinys
else TreiasSakinys;
if Slyga1
then if Slyga2
then if Slyga3
then PirmasSakinys
else if Slyga4
then AntrasSakinys;
Paprasiausios slygos apraomos palyginimo reikiniais, kuri sintaks:

R1 PalyginimoOperatorius R2
ia R1 ir R2 - aritmetiniai reikiniai, o PalyginimoOperatorius gali bti ymimas tokiais operatoriais:

= lygu
< maiau
<= maiau arba lygu
<> nelygu
> daugiau
>= daugiau arba lygu
Jei reikini reikms tenkina palyginimo slygas, tai palyginimo operacijos rezultatui suteikiama login
reikm TRUE (tiesa), o jei ne FALSE (melas).
Pirmas pavyzdys:
if a > 0
then WriteLn('Teigiamas')
else WriteLn('Neigiamas arba nulis');
Antras pavyzdys:
if a > 0
102
then WriteLn('Teigiamas')
else if a = 0
then WriteLn('Nulis')
else WriteLn('Neigiamas');
Danai tenka tikrinti, ar kintamj reikms priklauso leistinai reikmi atkarpai. Pavyzdiui, gali bti
skaiiuojama tik teigiam arba lygi nuliui argument kvadratins aknys. Todl tokioje programoje reikt
tikrinti, ar argument reikms yra leistinos, t. y., ar poaknyje nra neigiamas:
if x >= 0
then WriteLn('aknis: ', Sqrt(x):8:3)
else WriteLn('Neigiamas poaknis');
Sudtingos slygos apraomos loginiais reikiniais. Tai reikiniai, kuriuose naudojami loginiai operatoriai
NOT, AND, OR. Jais jungiami palyginimo reikiniai sudtingesnius, kurie vadinami loginiais reikiniais.
Logini operatori teisingumo lentels:
Kintamj reikms
a
b
TRUE
TRUE
FALSE
FALSE
TRUE
FALSE
TRUE
FALSE
Operacij su loginmis reikmmis rezultatai

a AND b
a OR b
NOT a
TRUE
FALSE
FALSE
FALSE
TRUE
TRUE
TRUE
FALSE
FALSE
FALSE
TRUE
TRUE
3.8. Knygoje naudojam ir rekomenduojam funkcij sraas

function
function
function
function
function
function
function
function
function
function
function
Abs(X): argumentoTipas;
ArcTan(X: real): real;
Cos(X: real): real;
Exp(X: real): real;
Ln(X: real): real;
Pi: real;
Sin(X: real): real;
Sqr(X): argumentoTipas
Sqrt(X: real): real;
Round(X: real): longint;
Trunc(X: real): longint;
Rezultatas yra argumento X absoliutin reikm.

Skaiiuoja duoto argumento X arktanget.
Skaiiuoja duoto argumento X kosinus.
Skaiiuoja duoto argumento X eksponent.
Skaiiuoja duoto argumento X natrin logaritm.
Grina reikm 3.1415926535897932385.
Skaiiuoja duoto argumento X sinus.
Skaiiuoja duoto argumento X kvadrat.
Skaiiuoja duoto argumento X kvadratin akn.
Real skaii veria sveikuoju (integer) apvalinant.
Real skaii veria sveikuoju (integer). Trupmenin
dalis atmetama
Smalsiems
3.9. Duomen vedimas i failo
Duomen vedimas klaviatra visuomet organizuojamas dialogo principu: ekrane spausdinami praneimai,
nusakantys kada ir kokius duomenis reikia surinkti klaviatra. Kai duomen skaiius didelis, tai labai
nepatogus ir ilgai trunkantis procesas, nes norint pakartoti skaiiavimus, reikia duomenis suvedinti i naujo.
Nepatogum galima ivengti, jeigu duomenys i anksto suraomi tekstiniame faile. Taiau faile neraomi
praneimai ir paaikinimai, kokie duomenys ir kokia seka surayti. Raant duomen skaitymo i failo
sakinius reikia i anksto inoti, kokia seka surayti duomenys. Nuo to priklauso, kiek bus kintamj ir kokia
seka bus skaitomos j reikms i failo
Norint duomenis perskaityti i failo, reikia:
103
Aprayti failo kintamj, kurio tipas text, pavyzdiui, Fd : text;

Susieti diskin fail su failo kintamuoju programoje. Tam naudojama procedra Assign.
Pavyzdiui: Assign(Fd, Duom.txt); Failo vard galima nurodyti tekstine konstanta,
simboli eiluts tipo kintamuoju, kuris saugo failo vard.
Atidaryti fail duomen skaitymui. Tam panaudojama procedra Reset, pavyzdiui: Reset(Fd);
Baigus darb su failu btina j udaryti. Tam panaudojama procedra Close. Pavyzdiui,
Close(Fd);
Vis failo kintamj vardus siloma pradti didiaja raide F. Tai leis programos tekste juos atpainti be
papildom paaikinim. Antruoju simboliu siloma rayti rad d (duomenys) arba r (rezultatai). Tolesni
simboliai, jeigu reikia, gali bti parenkami programuotojo nuoira.
Duomenims i failo skaityti naudojamos tos paios procedros, kaip ir vedamiems klaviatra, tik pirmuoju
argumentu raomas failo kintamasis:
Read(Fd, kintamjSraas);
ReadLn(Fd, kintamjSraas);
Procedr darbas niekuo nesiskiria nuo jau nagrinto duomen vedimo klaviatra. inant, kad klaviatra
yra taip pat tekstinis failas, kuris pagal nutyljim yra susiejamas su failo kintamuoju Input, kurio nebtina
(bet galima) rayti procedroje pirmuoju argumentu, panaudojimo skirtum nelieka.
3.10. Rezultat (duomen) ivedimas fail

Akivaizdu, kad spausdinti skaiiavim rezultatus ekrane galima, jeigu j yra nedaug. Juos bus nesunku
perirti ir/arba nusirayti. Taiau jeigu rezultat yra daug, tai ymiai patogiau juos surayti tekstin fail.
Taip suformuotus rezultatus lengva panaudoti dokumentuose, kaip duomenis kitose programose, apdoroti
kitomis taikomosiomis programomis (pvz., skaiiuokle).
Norint duomenis rayti fail, reikia:
Apayti failo kintamj, kurio tipas text, pavyzdiui, Fr : text;
Susieti fail su failo kintamuoju. Tam naudojama procedra Assign.
Pavyzdiui: Assign(Fr, Rez.txt); Failo vard galima nurodyti tekstine konstanta arba
simboli eiluts tipo kintamuoju, kuris saugo failo vard
Atidaryti fail duomen raymui. Tam skirta procedra Rewrite. Jeigu failo nurodytu vardu
kataloge nra, tuomet jis sukuriamas. Svarbu inoti tai, kad jeigu failas tokiu vardu jau yra, tuomet
jame esantys duomenys naikinami (failas ivalomas). Pavyzdiui: Rewrite(Fr);
Baigus darb su failu, btina j udaryti. Tam panaudojama procedra Close. Pavyzdiui,
Close(Fr); Tai padaryti btina, nes raymas fail vyksta netiesiogiai. Pradioje raoma
speciali atmintins viet (bufer), o j upildius, informacija siuniama fail. Po to buferis
valomas ir duomenys raomi toliau. Procedra Close siunia fail buferyje likusi dar nerayt
informacij.
Duomenims fail spausdinti naudojamos tos paios procedros, kaip ir spausdinant rezultatus ekrane, tik
pirmuoju argumentu raomas failo kintamasis:
Write(Fr, duomenSraas);
WriteLn(Fr, duomenSraas);
Procedr darbas niekuo nesiskiria nuo jau nagrinto spausdinimo ekrane. inant, kad ekranas yra taip pat
tekstinis failas, kuris pagal nutyljim yra susiejamas su failo kintamuoju Output, kurio nebtina (bet
galima) rayti procedroje pirmuoju argumentu, panaudojimo skirtum nelieka.
Papildymui failas atidaromas procedra Assign. Tuomet esami duomenys nebus naikinami, o failas bus
paruoiamas nauj duomen raymui failo pabaigoje.
104
3.11. Procedros
Procedromis yra vadinami programos struktriniai elementai, kuriuos galima kreiptis daugel kart. Jos
padeda geriau struktrizuoti programas, padaro jas lengviau skaitomas ir analizuojamas. Procedroms yra
skiriamos dviej tip sintaksins struktros: apraymai ir kreipiniai. Apraymai nurodo, k procedra turi
atlikti. Vykdant program jie praleidiami. Procedrose aprayti veiksmai yra vykdomi tiktai tada, kai jas
kreipiamasi. Procedr apraymai gali bti bet kurioje apra vietoje. Procedr aprao sintaks:
procedure Vardas(FormalijParametrSraas);
LokaliejiApraai
begin
ProcedrosKamienas
// Veiksmai, kuriuos atlieka procedra
end;
Vardas parenkamas pagal tas paias taisykles, kaip kintamj vardai.
FormalijParametrSraas, tai kintamj apraymas, kurie skirti ryiui su programa, kuri kvieia
procedr. Kintamieji, prie kuri apraym nra odelio var, skirti tik duomen perdavimui procedr. Jie
vadinami parametrai-reikms Kintamieji, prie kuri apraym yra odelis var, skirti ne tik duomen
perdavimui procedr, bet ir rezultat grinimui i procedros. Jie vadinami parametraiskintamaisiais.

Parametrai skirti informaciniams ryiams su programa palaikyti. J apraymai galioja tik procedroje.
LokaliejiApraai, tai kintamj, kurie reikalingi procedros kamiene suraomiems veiksmams, sraas.
ia gali bti ir sudtingesni apraai. Galioja tik procedroje.
ProcedrosKamienas aprao procedros vykdomus veiksmus.
procedras kreipiamasi j vardais, u kuri lenktiniuose skliaustuose suraomi faktiniai parametrai
(argumentai):
Vardas (FaktiniParametrSraas);
Faktiniai parametrai nurodo, kokiais pagrindins programos duomenimis turi bti keiiami formals
parametrai. Parametr keitimo bdas priklauso nuo j tipo. Formals parametraikintamieji keiiami
kreipinyje nurodytais pagrindins programos kintamaisiais. Tokie parametrai yra naudingi tada, kai
pageidaujama, kad procedra pakeist pagrindins programos kintamj reikmes.
Kai norime apsaugoti pagrindins programos kintamuosius nuo pakeitim procedr darbo metu, yra
vartojami parametrai-reikms, kuri aprauose odelis var nenurodomas. Tada duomenys perduodami tik
viena kryptimi i besikreipianios programos vietos procedr. vykdius procedr, tokiais faktiniais
parametrais nurodomos kintamj reikms nepakinta. Be to, faktiniais parametrais-reikmmis gali bti ne
tik kintamieji, bet ir konstantos bei iraikos.
Btina inoti, kad failo kintamieji gali bti tik parametrais-kintamaisiais, pavyzdiui
procedure Spausdinti(var Fr : text);
3.12. Funkcijos
Funkcijomis yra vadinami programos struktriniai elementai, kuriuos galima kreiptis daugel kart. Jos
padeda geriau struktrizuoti programas, padaro jas lengviau skaitomas ir analizuojamas. Funkcijoms yra
skiriamos dviej tip sintaksins struktros: apraymai ir kreipiniai. Apraymai nurodo, k funkcija turi
atlikti. Vykdant program jie praleidiami. Funkcijose aprayti veiksmai yra vykdomi tiktai tada, kai jas
kreipiamasi. Funkcij apraymai gali bti bet kurioje apra vietoje. Funkcij aprao sintaks:
function Vardas(FormalijParametrSraas): RezultatoTipas;
LokaliejiApraai
begin
FunkcijosKamienas
// Veiksmai, kuriuos atlieka funkcija
end;
Vardas parenkamas pagal tas paias taisykles, kaip kintamj vardai.
105
FormalijParametrSraas, tai kintamj apraymas, kurie skirti ryiui su programa, kuri kvieia
funkcij ir sudaromas pagal tas paias taisykles, kaip ir procedrose. Parametruskintamuosius

nerekomenduojama naudoti.
RezultatoTipas, tai funkcijoje suskaiiuotos reikms, kuri grinama funkcijos vardu, tipas. Funkcija
skiriasi nuo procedros tuo, kas jos vardas yra kartu ir skaiiavim rezultato kintamasis. Funkcijos
naudojamos, kai skaiiavim rezultatas yra viena reikm ir j reikia panaudoti tiesiogiai reikiniuose
(analogikai, kaip standartines funkcijas Abs, Sin, Sqrt ir pan.).
LokaliejiApraai, tai kintamj, kurie reikalingi procedros kamiene suraytiems veiksmams atlikti,
sraas. ia gali bti ir sudtingesni apraai. Galioja tik funkcijoje.
FunkcijosKamienas aprao funkcijos vykdomus veiksmus. J tarpe turi bti bent vienas sakinys, kuriuo
suskaiiuota reikm priskiriama funkcijos vardui.
funkcijas kreipiamasi reikiniuose j vardais, u kuri lenktiniuose skliaustuose suraomi faktiniai
parametrai (argumentai), pvz., y := Vardas(FaktiniParametrSraas)* c;
Faktiniams parametrams galioja tos paios taisykls, kaip ir procedrose.
3.13. Knygoje naudojam ir rekomenduojam funkcij ir procedr sraas

Darbas su failu
procedure Assign(var FailoKintamasis;
FailoVardas);
procedure Close(var FailoKintamasis);
procedure Reset(var FailoKintamasis: text);
procedure Rewrite(var FailoKintamasis: text);
procedure Append(var FailoKintamasis: text);
function Eof (var FailoKintamasis: text):boolean;
function Eoln (var FailoKintamasis: text):
boolean;
Prijungia iorin fail.

Udaro atidaryt fail.
Atidaro fail skaitymui.
Atidaro fail raymui.
Atidaro egzistuojant fail papildymui.
Analizuoja tekstinio failo pabaig.
Analizuoja failo eiluts pabaig.
vairios
function Random[(Riba: word)]:
SutampaSuKintamojo tipu;
procedure Randomize;
function Chr(X: byte): char;
function Ord(X): longint;
function Round(X: real): longint;
function Trunc(X: real): longint;
procedure
procedure
procedure
procedure
ClrScr;
TextColor(spalva : byte);
TextBackground(spalva : byte)
Window(x1, y1,
x2, y2 : integer);
procedure GoToXY (x, y : byte);

function WhereX: byte;
function WhereY: byte;
Grina atsitiktin skaii, ne didesn u nurodyt rib.

Jei riba nenurodoma, tai reikm bus intervale [0,1].
Paruoia darbui atsitiktini skaii generatori su
pradine atsitiktine reikme.
Grina nurodyt kodu simbol.
Grina nurodytos sekos elemento kod.
Real skaii veria sveikuoju (integer)
apvalinant.
Real skaii veria sveikuoju (integer).
Trupmenin dalis atmetama.
Valo ekran.
Teksto spalva: spalvos kodas arba konstanta.
Fono spalva: spalvos kodas arba konstanta
Aktyvaus lango apraymas: (x1,y1) kairiojo
virutinio ir (x2,y2) deinio apatinio lango kamp
koordinats.
Perkelia ymekl nauj ekrano viet (x, y).
Grina ymeklio vietos koordinat x.
Grina ymeklio vietos koordinat y.
Data ir laikas.
procedure GetDate(metai, mnuo, diena, savaitsDiena : word);
106
Savaits dienos reikm nulis nurodo sekmadien. Duomen tipas word nurodo sveik teigiam skaii.
procedure GetTime(valanda, minut, sekund, sekundsimtojiDalis : word);
107
4.
Kai kurie praktikos darbuose naudojami algoritmai
Vienas i struktrinio
programavimo pradinink
olandas E. W. Dijkstra
(19302002 m.)
1969 m. E. W. Dijkstra straipsnyje Duomen struktros ir algoritmai rod,

kad kiekvien algoritm galima aprayti trimis pagrindinmis konstrukcijomis:
1. Nuosekliai atliekamais veiksmais. Tokie algoritmai vadinami tiesiniais.
2. Cikliniais veiksmais, kai tas pats veiksmas kartojamas daug kart. Tokie
algoritmai vadinami cikliniais.
3. Veiksm pasirinkimo veiksmais. Tokie algoritmai vadinami akotaisiais.
Dijkstros teigimu, jei udavin galima isprsti uraant algoritm, tai galima
sugalvoti daugyb algoritm, i kuri po to irenkamas pats efektyviausias.
4.1. Tiesiniai algoritmai

Jais vadinami veiksmai, kurie atliekami j suraymo eils tvarka.
Pavyzdys 1. Trienklio natraliojo skaiiaus x skaitmen sumos s skaiiavimas. Norint isprsti udavin,
reikia skaii x iskaidyti skaitmenimis, skaitmenis sudti ir pateikti skaiiavim rezultat.
Algoritmo uraymas odiais:
1. Pradinis duomuo trienklis natralusis skaiius x.
2. Atskiriamas pirmasis trienklio skaiiaus skaitmuo a.
3. Atskiriamas antrasis trienklio skaiiaus skaitmuo b.
4. Atskiriamas treiasis trienklio skaiiaus skaitmuo c.
5. Skaiiuojama trienklio skaiiaus skaitmen suma s = a + b + c.
6. Pateikiamas gautas skaiiavim rezultatas.
Algoritmas, uraytas Paskalio programavimo kalba:
program Suma1;
var x, a, b, c, s: integer;
begin
WriteLn('veskite trienkl natralj skaii');
ReadLn (x);
a := x div 100;
b := x div 10 mod 10;
c := x mod 10;
s := a + b + c;
WriteLn ('Skaiiaus skaitmen suma lygi ', s);
end.
4.2. Cikliniai algoritmai

Tai veiksmai, kuriuos reikia daug kart atlikti. Veiksm kartojim skaiius nusakomas santykio bei loginiais
reikiniais.
Pavyzdys 2. Skaiiuoti vis natralij trienkli skaii skaitmen sumas. Norint isprsti udavin,
reikia kiekvien trienkl skaii iskaidyti skaitmenimis, skaitmenis sudti ir pateikti gaut rezultat.
Algoritmas odiais.
1. Pradinis duomuo pirmas trienklis natralusis skaiius x = 100.
108
7. x reikm padidinama vienetu.
8. 2-7 veiksmai kartojami tol, kol x < 1000.
Udavinio sprendimas, uraytas Paskalio programavimo kalba:
program Suma2;
begin
x := 100;
while x < 1000 do
begin
a := x div 100;
b := x div 10 mod 10;
c := x mod 10;
s := a + b + c;
WriteLn ('Skaiiaus ',x,' skaitmen suma lygi ', s);
x := x + 1;
end;
end.
4.3. akotieji skaiiavimai.

Tai veiksmai, kai, priklausomai nuo gaut ankstesni skaiiavimo rezultat, reikia vykdyti vienokius arba
kitokius veiksmus. Tokie skaiiavimai apraomi slygos sakiniais, kuriuose naudojami santykio bei loginiai
reikiniai.
Pavyzdys 3. Ciklinis algoritmas papildomas akojimu: turi bti skaiiuojama kiekvieno natraliojo trienklio
nelyginio skaiiaus skaitmen suma. Norint isprsti udavin, reikia kiekvien trienkl skaii patikrinti,
ar jis nelyginis, jei taip, tuomet iskaidyti skaitmenimis, skaitmenis sudti ir pateikti gaut rezultat.
Udavinio sprendimo algoritmas uraytas odiais:
2. Tikrinama slyga, ar trienklis skaiius yra nelyginis.
2.1. Jei slyga tenkinama, tuomet atliekami veiksmai:
6. x reikm padidinama vienetu.
2.2. Jei slyga netenkinama, x reikm padidinama vienetu.
3. 2 veiksmas kartojamas tol, kol x < 1000.
Udavinio sprendimas Paskalio programavimo kalba:
program Suma3;
begin
x := 100;
while x < 1000 do
109
end.
begin
if x mod 2 <> 0
then
begin
a := x div 100;
b := x div 10 mod 10;
c := x mod 10;
s := a + b + c;
x := x + 1;
end
else x := x + 1;
end;
Veiksmus galima supaprastinti, iklus x reikms didinim i slygos tikrinimo:

while x < 1000 do
begin
if x mod 2 <> 0
then
begin
a := x div 100;
b := x div 10 mod 10;
c := x mod 10;
s := a + b + c;
end;
x := x + 1;
end;
Sprendiant 3 pavyzdio udavin, slygos if x mod 2 <> 0 galima ir netikrinti:

7. x reikm padidinama 2.
8. 2-7 veiksmai kartojami tol, kol x < 1000.
Udavinio sprendimas Paskalio programavimo kalba:
program Suma5;
begin
x := 101;
while x < 1000 do
begin
a := x div 100;
b := x div 10 mod 10;
c := x mod 10;
s := a + b + c;
110
end.

x := x + 2;
end;
Mokydamiesi programuoti daug dmesio skirsime programavimo kultrai taisyklms, kuri turi bti
laikomasi raant teisingas ir lengvai skaitomas programas. Programavimo kultros pagrindiniai poymiai:
tvarkingai idstytas programos tekstas;
prasmingi programos objekt (kintamj, paprogrami, duomen tip vardai);
suprantami ir reikiamose programos vietose parayti komentarai.
Raydami programas stenkits laikytis i taisykli:
Vieno sintaksinio lygmens sakiniai turi bti vienodai atitraukti nuo eiluts pradios. emesnio lygmens
sakiniai yra deiniau negu auktesnio.
Jei programoje yra kelios logikai nepriklausomos dalys, jos viena nuo kitos skiriamos tuia eilute arba
linija, sudaryta i brkneli, vaigdui arba kitoki enkl.
Programoje begin-end, then-else turi bti lygiuojami, jei jie priklauso tai paiai struktrai.
I abiej pusi tarpais turi bti skiriami enklai >, <, <>, >=, <=, =, :=, +, -, *, /. Po
enkl : ir , paliekamas tarpas.
Smalsiems
4.4. Sumos skaiiavimo algoritmas
Keli skaii sum galime urayti taip: suma = sk1 + sk2 + + skn.
ia sk1, sk2, skn yra skaiiai, kuriuos sudj gauname sum suma.
Atlikdami veiksmus skaiiuokliu (ar pietuku popieriuje), visuomet sumuojame du skaiius. Veiksmus
galime iskleisti taip:
suma2 = sk1 + sk2;
suma3 = suma2 + sk3;
suma4 = suma3 + sk4;
. . .
suma = suman-1 + skn ;
// Pirmj dviej skaii suma

// Ankstesnio rezultato ir treio skaiiaus suma
// Ankstesnio rezultato ir ketvirto skaiiaus suma
// Vis n skaii suma
Skaiiuoklio ekrane visuomet matome tik paskutinio veiksmo rezultat (dalin sum). Kiekviena nauja suma
gaunama prie jau apskaiiuotos sumos pridedant po vien dmen. Todl uraytoje veiksm sekoje visose
eilutse galima parayti:
suma =
suma =
suma =
. . .
suma =
sk1 + sk2;
suma + sk3;
suma + sk4;
// Pirmj dviej skaii suma

// Trij skaii suma
// Keturi skaii suma
suma + skn;
// Vis n skaii suma
Sumos skaiiavim galima urayti: suma = suma + skaiius. Tokiu atveju pradin suma reikm turi
bti lygi nuliui, nes:
suma =
suma =
suma =
suma =
. . .
suma =
0;
//
suma + sk1; //
suma + sk2; //
suma + sk3; //
Pradin rezultato reikm

Pirmojo skaiiaus ir nulio suma
Dviej skaii suma
Trij skaii suma
suma + skn; // Vis n skaii suma
111
Bendru atveju veiksmus galime ireikti tokiu algoritmu:
Pradia Skaii suma
suma = 0;
kol yra skaii
ciklo pradia
vesti skaii sk;
suma = suma + sk;
ciklo pabaiga
Spausdinti (rodyti) rezultat suma
Pabaiga
Ciklo slyg kol yra skaii galime nurodyti labai vairiai. Paprasiausias atvejis, kai prie cikl yra tiksliai
apibriama, kiek bus skaii, kuriuos reikia sudti.
Galimas toks programos tekstas:
// Skaii suma
program SkaiciuSuma;
var suma, sk : integer; // Sumos ir dmens kintamieji
n : integer; // Skaii kiekis
i : integer; // Ciklo parametras
begin
Write('Kiek bus skaii?'); ReadLn(n);
suma := 0;
for i := 1 to n do
begin
Write('Koks bus ', i, ' skaiius?'); ReadLn(sk);
suma := suma + sk;
end;
WriteLn('Sudta skaii: ', n, ' Rezultatas = ', suma);
WriteLn('Pabaiga');
ReadLn;
end.
Kaip matote, sumos skaiiavimo veiksmai panas kasininks veiksmus parduotuvje:

1. Pradedant skaiiuoti, kasos aparato ekrane turi bti rodoma reikm nulis.
2. Skenuojant prekes, j kaina pridedama prie ekrane matomo skaiiaus. Pinig suma, kuri reiks mokti,
didja.
3. Nuskenavus paskutins preks kain, ekrane matomas rezultatas.
Proces galime pavaizduoti tokia schema
suma := 0
Kol yra preki
suma := suma + prekesKaina
Rezultatas: suma
4.5. Sandaugos skaiiavimo algoritmas

Keli skaii sandaug galime urayti taip: sand = sk1 * sk2 * * skn.
ia sk1, sk2, skn yra skaiiai, kuriuos sudauginus gauname sandaug sand.
Atliekant veiksmus skaiiuokliu (ar pietuku popieriuje), visuomet dauginame du skaiius. Veiksmus galime
iskleisti taip pat, kaip ir skaii sumavimo atveju. Kiekviena nauja sandauga gaunama jau apskaiiuot
112
sandaug dauginant i naujo dauginamojo: sand = sand * skaiius. Pradin sandaugos reikm turi
bti lygi vienetui.
Sandaugos skaiiavim seka bus tokia:
sand =
sand =
sand =
sand =
. . .
sand =
1;
//
sand * sk1; //
sand * sk2; //
sand * sk3; //
Pradin rezultato reikm

Pirmojo skaiiaus ir vieneto sandauga
Dviej skaii sandauga
Trij skaii sandauga
sand * skn; // Vis n skaii sandauga
Bendru atveju veiksmus galime ireikti tokiu paiu algoritmu, kaip ir sumavimo, tik pradin sandaugos
reikm turi bti vienetas, o sudties operatorius (+) pakeistas daugybos (*).
Klimas laipsniu. Sandaugos skaiiavimo algoritmas panaudojamas skaiiaus klimui sveikuoju laipsniu:
R = xn.
// Skaiiaus klimas laipsniu. Panaudojamas sandaugos skaiiavimo algoritmas.
program Laipsnis;
var i : integer; // Ciklo parametras
R,
// Sandaugos kintamasis
x,
// Laipsnio pagrindas
n : integer; // Laipsnio rodiklis
begin
Write('Skaiius, kur kelsite laipsniu: '); ReadLn(x);
Write('Laipsnio rodiklio reikm: '); ReadLn(n);
R := 1;
for i := 1 to n do
R := R * x;
WriteLn('Rezultatas: ', R);
WriteLn('Pabaiga');
Readln;
end.
4.6. Kiekio skaiiavimo algoritmas

Kiek yra dvienkli natralij skaii, kurie dalinasi i penki?
program KiekSkaiciu;
var x : integer; // Pirmasis dvienklis skaiius, kuris dalinasi i penki
k : integer; // Dvienkli skaii, dali i 5, kiekis
begin
x := 10; k := 0;
while x < 100 do
begin
k := k + 1;
x := x + 5;
end;
WriteLn ('Dvienkli skaii, dali i 5, yra ', k);
ReadLn;
end.
113
Udavinio sprendimo algoritmas. Pirmasis dvienklis skaiius, kuris dalinasi i penki, yra 10. Kiekio
pradin reikm yra lygi nuliui. Ciklo antratje raome slyg, kad ciklo vykdymas bt nutrauktas,
perirjus visus dvienklius skaiius. Kadangi cikl ateiname su pirmuoju dvienkliu skaiiumi, kuris
dalinasi i 5, tai toki skaii kiekis padidja vienu nauju skaiiumi. Po to x reikm didinama 5, tikrinama
ciklo slyga ir atliekamai veiksmai ciklo viduje.
Veiksm algoritmas analogikas sumos skaiiavimui, tik ia bus sumuojamos ne reikms, o vienetukai.
Dar vienas pavyzdys: rasti, kiek natralusis skaiius x turi dalikli k.
Udavinio sprendimo algoritmas yra klasikinis: sukamas ciklas nuo 1 iki x ir cikle tikrinama, ar natralusis
skaiius x be liekanos dalinasi i ciklo kintamojo i. Jei taip, tai i yra x daliklis ir dalikli skaiius didinamas
vienu nauju dalikliu.
program Dalikliai;
var x, i, k : integer;
begin
WriteLn ('veskite natralj skaii x');
ReadLn (x);
k := 0;
for i := 1 to x do
if x mod i = 0
then k := k + 1;
WriteLn ('Natralusis skaiius ', x, ' turi ', k,' dalikli (-ius)');
ReadLn;
end.
4.7. Aritmetinio vidurkio skaiiavimas

Skaiiavimus sudaro dvi atskiros dalys:
1. Skaii sumos skaiiavimas;
2. Gautos sumos padalinimas i skaii kiekio.
Pirmoji dalis jau nagrinta. Reikia atkreipti dmes, kad jeigu i anksto neinomas sumuojam skaii kiekis,
tai reikia sumuojant skaiius kartu skaiiuoti ir kiek toki skaii buvo.
Antr veiksm dal sudaro dviej skaii dalybos veiksmas: vidurkis = suma / skaiiKiekis.
Ne visuomet toks veiksmas bus teisingas. Tarkime, kad reikia suskaiiuoti teigiam skaii
aritmetin vidurk. O jeigu nei vieno teigiamo skaiiaus nebuvo? Visi skaiiai buvo tik neigiami ir nuliai.
inome, kad dalyba i nulio negalima. Taigi, prie atliekant dalybos veiksm, btina sitikinti, kad galima
dalinti.
4.8. Didiausios (maiausios) reikms paieka

Tai tradiciniai programavimo udaviniai. Populiariausias j sprendimo bdas yra toks. Apraomi du
kintamieji vedamai (x) ir didiausiai (d) reikmi saugoti. vedant pirmj reikm, daroma prielaida, kad i
yra didiausia (kai iekoma didiausios reikms):
d := x;
Po to, paeiliui skaitomos kitos reikms ir lyginamos su d. Jei randama didesn, kintamojo d reikm
keiiama nauja:
if
x > d
then
d := x;
Taip patikrinus vis vedam duomen sraut, kintamojo d reikm bus didiausia vesta reikm.
Analogikai iekoma maiausia reikm. Skirtumas tik palyginimo slygoje:
if
x < d
then
d := x;
Pateikiame vien tokio algoritmo apraymo Paskalio kalba variant:

program Didelis;
var n, x, d, i : integer;
114
begin
Write(Kiek bus skaii: ); ReadLn(n);
Write(veskite pirm skaii: ); ReadLn(d);
for i := 2 to n do begin
Write(veskite , i,- skaii: ); ReadLn(x);
if x > d then d := x;
end;
WriteLn( Didiausias skaiius: , d);
end;
Pirmj reikm laikyti pradine didiausia (arba maiausia) reikme ne visuomet patogu. Ypa tuomet, kai ta
reikm turi bti apskaiiuojama (pavyzdiui, iekant maiausio teigiamo skaiiaus, kai srauto pradioje gali
bti daug neigiam skaii). Tokiu atveju galima pradinei didiausiai reikmei priskirti pakankamai ma
reikm: toki, kuri tikrai bt maesn u visas galimas reikmes, tarp kuri iekome didiausios reikms.
Cikle analizuojamos visos reikms. Iekant maiausios reikms, pradinei reikmei reikia priskirti
pakankamai didel skaii, geriausia j laikyti lygiu standartinei Paskalio konstantai maxint (arba
maxlongint, jei sveikasis tipas longint).
Pavyzdys. Turguje ant prekystalio yra n arbz, kuri mass inomos. Reikia sudaryti program
sunkiausiam arbzui rasti.
program Turgus;
var n : integer;
// Arbz skaiius
m : real;
// Arbzo mas
i : integer;
// Arbzo numeris
s : real;
// Sunkiausio arbzo mas
ns : integer;
// Sunkiausio arbzo numeris
//----------------------------------------------------begin
Write('Kiek yra arbz? '); Read(n);
// Sunkiausio arbzo paieka
WriteLn('Arbz masi vedimas');
s := 0; ns := 0;
for i := 1 to n do
begin
Write('veskite', i:2, '-ojo arbzo mas: '); ReadLn(m);
if m > s then
begin
s := m; ns := i;
end;
end;
// Rezultatai
WriteLn('Sunkiausias arbzas Nr', ns:4);
WriteLn('Jo mas:', s:6:2);
WriteLn('Spauskite ENTER'); ReadLn;
end.
115
5.
Uduotys savarankikam darbui
TRYS SODININKAI. Trys draugai apsigyven kaime nusprend mokytis sodininkauti. Kaime buvo
didiulis sodas, jame augo po vien vaismed kiekviename kvadratiniame ploto vienete.
Kiekvienas i trij draug pasirinko staiakamp sklyp ir nusprend priirti jame esanius
medius. Susirinkus draugn paaikjo, kad j pasirinkti sklypai persidengia, t. y. kai kuriuos
vaismedius priirs ne vienas, o keletas sodinink.
Uduotis. Paraykite algoritm, kuris suskaiiuot, kiek vaismedi panorjo
y
priirti visi trys draugai.
Pradiniai duomenys pateikiami trijose tekstins bylos SODAS.DAT eilutse.
kiekvien eilut rayta po keturis skaiius, apibdinanius kiekvieno draugo
x pasirinkt sklyp: sklypo apatinio kairiojo ir virutinio deiniojo kamp
koordinats (pirma koordinat x, po to y.). Visos koordinats sveikieji
skaiiai. (10 olimpiada, 1999).
Testo nr.
1
2 3 6 7
Pradiniai
4 1 8 5
duomenys 6 0 10 3
0
Rezultatas
2
1 5 9 9
5 6 13 12
6 1 9 11
9
3
0 4 6 8
0 4 6 8
0 0 6 4
0
4
10 8 13 12
2 3 9 7
6 0 13 2
0
5
30 30 80 70
10 20 70 90
50 20 100 90
800
6
10 30 100 80
60 10 120 60
70 30 100 50
600
JAPON KALENDORIUS. Senovs japon kalendori sudar 60 met ciklas. Visi metai cikle buvo
sunumeruoti nuo 1 iki 60 ir suskirstyti poromis, kuri kiekviena turjo savo spalv (ali, raudon, gelton,
balt ar juod). Ciklo met spalvos buvo paskirstytos itaip:
1, 2, 11, 12, 21, 22, , 51, 52 metai alia spalva;
3, 4, 13, 14, 23, 24, , 53, 54 metai raudona spalva;
5, 6, 15, 16, 25, 26, , 55, 56 metai geltona spalva;
7, 8, 17, 18, 27, 28, , 57, 58 metai balta spalva;
9, 10, 19, 20, 29, 30, , 59, 60 metai juoda spalva;
inoma, kad naujasis 60 met ciklas prasidjo 1984aisiais ir baigsis 2043iaisiais metais; 1984ieji
ir 1985ieji buvo alios spalvos metai, 1986-ieji ir 1987ieji buvo raudonos spalvos metai, 2043ieji
bus juodos spalvos metai.
Uduotis. Duoti metai m (1800m2200). Paraykite program, kuri nustatyt ir ispausdint, kokia
duotj met spalva.
Testo nr. Pradinis duomuo Rezultatas
Paaikinimai
1984
ALIA
1
Paprasiausias atvejis 1984-ieji metai
2001
BALTA
2
Einamieji metai
3
1804
ALIA
Pirmieji ciklo metai
2103
JUODA
Paskutinieji ciklo metai
1945
ALIA
alios spalvos metai
2137
1859
RAUDONA Raudonos spalvos metai

GELTONA Geltonos spalvos metai
1970
BALTA
Baltos spalvos metai
116
9
1942
JUODA
Juodos spalvos metai (baigiasi skaitmeniu 9)
10
1943
JUODA
Juodos spalvos metai (baigiasi nuliu)
11
2200
BALTA
Ribinis atvejis
SKAITMENYS. Laura mokosi rayti skaiius. Mokytoja jai liep parayti visus natraliuosius skaiius nuo
1 iki N. domu, kiek skaitmen Laura i viso parays savo ssiuvinyje?
Uduotis. Paraykite program, kuri rast Lauros parayt bendr skaitmen skaii.
Pradiniai duomenys. Pirmoje ir vienintelje pradini duomen failo skait.in eilutje pateiktas
paskutinysis Lauros paraytas natralusis skaiius N (1 N < 10 000).
Rezultatas. Rezultat faile skait.out turi bti raytas vienas skaiius bendras Lauros parayt
skaitmen skaiius.
(19 olimpiada, 2008)
Pavyzdiai
Pradiniai duomenys
Rezultatas
Paaikinimai
10
11
1 2 3 4 5 6 7 8 9 10 i viso 11 skaitmen
1 2 3 4 5 i viso 5 skaitmenys.
IOGAS. iogas tupi ant horizontaliai itemptos virvuts, prie pat kairiojo krato. Virvuts ilgis s sprindi.
iogas moka okti priek a sprindi ir atgal b sprindi. Jam reikia patekti ant virvutje umegzto mazgo,
kuris nutols nuo iogo pradins padties per c sprindi (visi sprindiai vienodo ilgio).
Pradiniai duomenys s, a, b ir c natralieji skaiiai, be to, s > c > a > b > 0.
Paraykite algoritm, kuris apskaiiuot, kiek maiausiai uoli turi padaryti iogas, kad pasiekt mazg.
(8 olimpiada, 1997).
Testo
nr.
1
Pradiniai
duomenys
10 3 2 6
iogas turi okti du kartus priek
20 3 1 5
iogas oks du kartus priek ir kart atgal
20 4 2 5
Negalima Mazgo pasiekti negalima
9 7 4 8
Negalima
Mazg galima bt pasiekti tik tada, jei virvut bt begalinio ilgio (tada
reikt 9 uoli)
100 13 1 27
15
iogas oka dideliais ingsniais priek ir maais atgal
Rezultatas
Paaikinimai
SULTIS GERTI SVEIKA. Kiekvienos savaits pirmadienio ryt Jonas gauna k cent kienpinigiams.
Vienas butelis suli kainuoja s cent, o tuti buteliai superkami po b cent. Kart (tai buvo i-oji savaits
diena), i viso turdamas n cent, Jonas nusprend kasdien (pradedant i-ja diena) pirkti suli u visus
turimus pinigus. Pinigai, gauti pardavus butelius, bus panaudojami kit dien sultims pirkti. itaip Jonas
darys tol, kol jis stengs nusipirkti bent vien suli butel.
Kiek buteli suli igers Jonas?
Paraykite program iam udaviniui sprsti. Pradiniai duomenys natralieji skaiiai k, s, b, n, i (1 <= i <=
7). Jei nusprendiama sultis pirkti pirmadien, tai i karto gaunami kienpinigiai (pasipildo turima pinig
suma). U pirmadien gautus kienpinigius sultys perkamos pirmadien. (9 olimpiada, 1998).
Testo
nr.
Pradiniai duomenys
Rezultatas
Paaikinimai
117
k = 25, s = 10, b = 3, i = 2, n = 15
Pirmj dien nusiperkamas tik vienas butelis
k = 24, s = 10, b = 2, i = 1, n = 1
Prie perkant sultis pirmj dien, btina pasiimti kienpinigius
k = 25, s = 9, b = 2, i = 4, n = 23
Pinig treiajam buteliui uteks tik tuomet, jei bus parduoti abu
buteliai
k = 100, s = 10, b = 2, i = 5, n = 500
74
Didesnis testas, kai buteliai perkami kelias dienas, o tarp dien

yra pirmadienis
DIDMENINIS PIRKIMAS. inoma, kad perkant daugiau preki j vienetas kainuoja pigiau. Pundelyje yra
12 por kojini, dje 12 pundeli. Pavyzdiui, kojini d kainuoja 247 litus, pundelis 21 lt, pora 2
lt. domu tai, kad jei mums reikt 11 por kojini, tai geriau pirkti pundel ir vienerias kojines kam nors
atiduoti.
Uduotis. Pirkjas nori sigyti n por kojini. Sudarykite algoritm, vadovaudamiesi kuriuo pigiausiai
nupirktume kojines. Jei u t pai kain galima nupirkti didesn ir maesn kiek kojini, tai perkamas
didesnis kiekis. Raskite perkam di, pundeli ir por skaii.
Pradinius duomenis sudaro keturi skaiiai: kojini por skaiius n, vienos ds, vieno pundelio bei
vienos poros kaina litais. (10 olimpiada, 1999).
Testo
nr.
Pradiniai
duomenys
Rezultatai
Paaikinimai
Di skaiius: 5
720 303 32 3 Pundeli skaiius: 0 n dalus i 144 (por skaiiaus dje)
Por skaiius: 0
84 210 20 2
Di skaiius: 0
Pundeli skaiius: 7 n dalus i 12 (por skaiiaus pundelyje)
Por skaiius: 0
Di skaiius: 2
Perkame tik des; jei pirktume kitais dviem bdais (1, 4, 4
196 100 20 5 Pundeli skaiius: 0 arba 1, 5, 0), kaina bt ta pati, taiau kojini kiekis
Por skaiius: 0
maesnis
Di skaiius: 2
355 292 41 6 Pundeli skaiius: 6 Perkame tik des ir pundelius
Por skaiius: 0
Di skaiius: 3
355 291 50 6 Pundeli skaiius: 0 Perkame tik des
Por skaiius: 0
Di skaiius: 2
355 292 49 6 Pundeli skaiius: 5 Perkame ir des, ir pundelius, ir poras
Por skaiius: 7
VAIZDO RAAI. 240 minui trukms vaizdajuost kainuoja 10 lit 90 cent, 180 minui trukms
vaizdajuost kainuoja 9 litus 15 cent. Tomas perirjo Baltijos televizijos savaits program ir panorjo
sirayti n laid. inoma kiek valand ir kiek minui trunka kiekviena laida. Reikalui esant, bet kuri laida
gali bti suskaidyta dalis ir rayta dvi ar daugiau vaizdajuosi, o vien vaizdajuost gali bti raomos
kelios laidos. Deja, Tomas neturi nei vienos tuios vaizdajuosts.
Uduotis. Paraykite algoritm, kuris suskaiiuot, kiek maiausiai pinig (lit bei cent) reiks ileisti
Tomui, norint nusipirkti tiek vaizdajuosi, kad j utekt norimoms laidoms rayti. (11 olimpiada,
2000).
118
Pirmoje kiekvieno duomen rinkinio eilutje nurodytas laid skaiius n, o likusiose n eilui
kiekvienos laidos trukm. Pirma nurodomas valand, paskui minui skaiius.
Testo nr.
Pradiniai duomenys
1
3
1 10 2 00
2 00
0 30
3
4
0
0
3
1
3
30 2 30
20 2 30
40 1 01
30
5
5
1
1
1
4
1
10
05
00
45
00
6
5
1
1
1
4
1
10
05
00
45
05
3
3
5 30 5 00
3 20 5 00
2 00 3 00
10
3
6
5 00 3 00
5 00 3 00
3 05 3 00
3 00
3 00
0 55
11
6
8
8
8
8
8
2
30
30
30
30
30
00
Bendra laid trukm
1:10
4:30
6:00
6:01
9:00
9:05
10:50
13:00
13:05
15:55
44:30
Valand skaiius
10
11
13
14
16
45
Ilg ir trump
vaizdajuosi skaiius
01
02
02
11
03
12
21
13
22
40
93
Rezultatas
9,15 18,30 18,30 20,05 27,45 29,20 30,95 38,35 40,10 43,60 125,55
VARLI KONCERTAS. Varli koncertas. Kart vienoje kdroje gyveno daug varli, ir ne bet koki, o
dresiruot. Kiekviena varl sugebdavo iokti i vandens ir sukvarksti kas tiksliai jai bding laiko
period. Pavyzdiui, varls kvarkimo periodas lygus 5. Tai reikia, kad jei varl sukvarksjo pirm minut,
antr kart ji kvarkss po penki minui, t. y. et minut, trei kart vienuolikt minut ir t. t.
Uduotis. Patekjus saulei visos varls ioko i vandens ir sukvarksjo. Sudarykite algoritm, kuris
nustatyt, po kiek valand ir minui (<60) vyks antrasis varli koncertas, t. y. vienu metu ioks i
vandens ir sukvarkss visos kdroje esanios varls.
Pradiniai duomenys vedami tokia tvarka. Pirma vedamas varli skaiius, po to kiekvienos varls
kvarkimo periodas. Varli pasirodymo periodai surayti i eils: p1, p2, p3, p4, p5 ir t. t., ia p1 pirmosios
varls pasirodymo periodas, p2 antrosios ir t. t. (0 < pi <= 20 minui). Varli skaiius kdroje
nevirijo 10.
Atkreipiame dmes, kad valand skaiius, po kurio vyks antrasis koncertas, nevirija maxlongint. (11
olimpiada, 2000).
Testo
Pradiniai duomenys
Rezultatai
nr.
2
Koncertas vyks po 0 val. ir 8 min.
1
8 8
Paaikinimai
Paprasiausias atvejis: abu
periodai sutampa
3
2 3 5
Periodai neturi bendr dalikli:

kartotinis lygus period sandaugai
6
12 15 20 10 6
30
Periodai turi bendr dalikli
5
18 7 3 2 4
Tikrinama, ar laikas teisingai

Koncertas vyks po 4 val. ir 12 min. perskaiiuojamas valandas ir
minutes
10
Koncertas vyks po 3879876 val. ir 0 iuo testu tikrinamas sprendimo
11 12 13 14 15
min.
efektyvumas
16 17 18 19 20
119
SENAS KALENDORIUS. Metai yra keliamieji, jeigu jie dals i 4 ir nesidalija i 100, arba jeigu jie dals
i 400. Pavyzdiui:
2000 metai buvo keliamieji, nes jie dals i 400;
2004 metai keliamieji, nes jie dals i 4 ir nra dals i 100;
1900 metai nra keliamieji, nes jie dals i 100, bet ne i 400.
Uduotis. Turime sen kalendori, kuris buvo ileistas tarp 1900 ir 2004 met. Paraykite program, kuri
rast artimiausius bsimus metus (t. y. pradedant 2005-aisiais), kuriems tinka turimas kalendorius.
Pradiniai duomenys du sveikieji skaiiai skaitomi i ekrano. Pirmasis skaiius tai metai, kuriems buvo
ileistas senasis kalendorius. Antrasis skaiius yra i intervalo [1..7] ir nusako, kuria savaits diena prasidjo
tie metai.
Rezultatas raomas ekrane.
Pavyzdiui, jeigu pradinis duomuo yra 1979 1, tai rezultatas turt bti 2007. (16 olimpiada, 2005)
DEGTUKAI. Duota n degtuk. Paraykite algoritm, kuris nustatyt, ar i duot degtuk galima sudlioti
bent vien i i figr: lygiakrat trikamp, kvadrat ar staiakamp. Dliojamai figrai turi bti panaudoti
visi degtukai; be to, degtuk lauyti negalima. (8 olimpiada, 1997).
Pradinis
Rezultatas
duomuo
1
Negalima
Testo nr.
1
Paaikinimai
Per maai degtuk;
Negalima
Per maai degtuk;
Galima
Paprastas atvejis, kai galima sudti lygiakrat trikamp;
12
Galima
Galima sudti visas figras;
15
Galima
Galima sudti tik trikamp;
16
Galima
Galima sudti kvadrat ir staiakamp;
35
Negalima
Negalima sudti nei vienos figros;
NUTRINTI SKAIIAI. Ant popieriaus lapo buvo urayti keturi natralieji skaiiai: a, b, s, d. Po to du i j
buvo nutrinti (juos ymsime nuliais). Reikia atstatyti nutrintuosius skaiius, jeigu inoma, kad yra liks bent
vienas i skaii a ir b ir kad skaiiai tenkino itokias lygybes:
s = a + b;
d = a x b.
(8 olimpiada, 1997).
Testo nr.
1
Pradiniai duomenys
0 12
0
48
39
15
0 105
25 13
0 32766
Rezultatas
12
16
Paaikinimai
48
Nutrinti skaiiai a ir s
20
Nutrinti skaiiai a ir d
13
16
39
Nutrinti skaiiai b ir s
15
90
105
1350
Nutrinti skaiiai b ir d
25
13
38
325
Nutrinti skaiiai s ir d
1 32766 32766 32766
Rezultatai skaiiai, artimi

maxint;
120
Literatra
1.
Jonas Blonskis, Kazys Baniulis, Vacius Jusas, Romas Marcinkeviius, Jonas Smolinskas. Programavimas.
Vadovlis, II leidimas. Kaunas: Technologija, 2000, 378 psl. ISBN 9986 13 673 3.
2.
Jonas Blonskis, Vytautas Buknaitis, Jonas Smolinskas, Antanas Vidinas. Programavimo praktikumas.
Programavimas su Turbo Paskaliu. Kaunas: Smaltija, 2000, 251 psl. ISBN 9986-965-18-7.
3.
Bronislovas Burgis, Antanas Kulikauskas. Kompiuterija.Mokymosi knyga studentams, moksleiviams,

entuziastams. Kaunas: Naujasis lankas, 2000, ISBN 9955 03 026 7
4.
Dagien V., Grigas G. Programavimo pradmen udavinynas / Realinio profilio vidurinms mokykloms.
Vilnius: TEV, 2000, 208 p.
5.
Jonas Blonskis, Valentina Dagien. Programavimo pradmenys. Vadovlis XI-XII klasms. Vilnius: TEV, 2001,
270 psl. ISBN 9955-491-01-9.
6.
Dagien V. Informatikos pradmenys, IXX kl., II d.: Algoritmai. Vilnius: TEV, 1998, 104 p.; Pataisytas ir
papildytas leidimas, Vilnius: TEV, 2001, 112 p.
7.
Valentina Dagien. Informacins technologijos IX-X klasms. 2 dalis. Vilnius, TEV, 2003, 256 p. ISBN:
9955-491-39-6
8.
Valentina Dagien, Alvida Lozdien. Informacins technologijos. Algoritmai: Paskalis. Pratyb ssiuvinis IX-X
klasms. Vilnius: TEV, 2004, 64 p. ISBN: 9955-491-83-3
9.
Dagien V., Lozdien A. Programavimas Paskaliu, Vilnius: TEV, 2005, 64 p.
10. Valentina Dagien, Gintautas Grigas, Tatjana Jevsikova. Enciklopedinis kompiuterijos odynas. Vilnius: TEV,
2005, 388 p. ISBN 9955-680-19-9. Internetinis odyno variantas svetainje www.likit.lt
Naudingos nuorodos
1) http://ims.mii.lt/asmen/rimga/vu/didaktika/free_pascal/fpc_ir_tp_duomtipiu_skirtumai.htm
R. Laucius. Free Pascal ir Turbo Pascal duomen tip skirtumai
2) http://62.80.232.136/informatika/kurybiniai_darbai/vad9_10/
Kompiuterinis "Informatikos pradmen vadovlis" sukurtas Alytaus Vidzgirio vidurinje mokykloje ir
vliau modifikuotas Alytaus Likikli vidurinje mokykloje. Autorius - informatikos vyr. mokytojas Vidas
emaitis. Idja kurti vadovl kilo tada, kai tapo aiku, kad mokykloje truks INFORMATIKOS
PRADMEN vadovli 9 - 10 klasi mokiniams. Vadovlyje mokomoji mediaga pateikta pagal Valentinos
Dagiens vadovlius INFORMATIKOS PRADMENYS (I ir II dalis). Kiekvien skyri sudaro teorija bei
pratimai ir uduotys. Kai kuri skyri pratimuose ir uduotyse galima rasti testus pagal ieit tem. Test
uduoi skaiius nuo 10 iki 14, o mokiniui pateikiamos tik 8 atsitiktinai parinktos uduotys.
3) http://vmc.ppf.ktu.lt/saulius/v2/?puslapis=327
Autorius: Sinkeviius Saulius; 2001 m. ileista Turbo Pascal 7.0 trumpai. inynas knyga.
i knyga gavo grif, t. y. ji yra rekomenduojama Lietuvos Respublikos vietimo ir mokslo ministerijos.
Recenzavo dr. Jonas Blonskis, dr. Valentina Dagien, mok. metodininkas Arvydas Verseckas
2000 m. padarytas informatikos puslapis, kuris buvo pastoviai pildomas iki 2002 met. Vliau tik po
didels pertraukos vl atnaujintas. Puslapis pirm kart publikuotas 2000-06-25. is darbas 2002-03-17
laimjo pirmj viet KTU Informatikos forume, moksleivi sukurt program konkurse. Puslapis
susilaukt ymiai didesnio mano darbo, jei bt ioks toks finansavimas.
121
Darbe panaudotos technologijos: FrontPage, Java Script, Flash, GIF animacija, Java Apletai. 2002 m.
atnaujinant panaudota: PHP, MySQL, CSS.)
4) http://www.ivinskis.kursenai.lm.lt/gimnaz/dalykai/files/ppp10/
A. Verseckas. Programavimo pradmenys
5) http://www.ipc.lt/21z/mokymas/mokymopr/el/ek/knyga1.htm
G.Grigas. Programavimas Paskaliu. Elektronin knyga
i knyga yra programavimo pradiamokslis. Apraomos pagrindins Paskalio kalbos konstrukcijas bei j bei
j panaudojimas algoritmams ir programoms urayti. Mediaga pateikiama taip, kad skaitytojas galt j
sisavinti sprsdamas udavinius. Pateikiami udaviniai ir praktikos darbai. Udaviniai skirti savikontrolei.
Knygos pabaigoje pateikiami j sprendimai (atsakymai). Praktikos darbai tai nedideli programavimo
darbai, skirti programavimo gdiams pagilinti bei darbo su kompiuteriu praktikai.
Knyga turt bti naudinga vyresnij klasi moksleiviams, informatikos mokytojams ir pirmj kurs
pedagogins krypties studentams.
6) http://ims.mii.lt/fps/download/0.6.4/
I ia galima parsisisti Free Pascal.
7) http://62.80.232.136/informatika/uzduotys/vadoveliai/fps.pdf
Lokalizuota Free Pascal programavimo sistema
8) http://www.taoyue.com/tutorials/pascal/contents.html
Paskalis. Mokomoji mediaga. Angl kalba
9) http://www.geocities.com/SiliconValley/Bay/5707/pascal.html
Paskalis. Mokomoji mediaga. Angl kalba
10) http://freepascal.org/download.var
I ia galima parsisisti naujausi Free Pascal versija (Nelokalizuot)
11) Uklausa internete:
Informacini technologij valstybinis brandos egzaminas praktins uduotys 2006 m.
Pateiktis, kur gerai pristatyti Free Pascal diegimas ir aplinka
12) http://www.levenez.com/lang/
Isami informacija apie vairias programavimo kalbas

Programavimo Pradmenys 10 Kl.

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Programavimo Pradmenys 10 Kl.

Uploaded by

Copyright:

Available Formats

1

Informacini technologij vadovlis

PAGRINDINS STRUKTRINIO PROGRAMAVIMO SVOKOS.............................................................. 5

VADAS FREE PASCAL TERP ............................................................................................................... 13

ILAIDOS KAMBARIO REMONTUI ......................................................................................................... 20

GROS ATIDAVIMAS MAIAUSIU BANKNOT IR MONET SKAIIUMI ................................ 24

ELEKTROS LAIDININKO VAROS SKAIIAVIMAS........................................................................... 37

FUNKCIJOS APIBRIMO SRITIES TYRIMAS ..................................................................................... 41

KVADRATINS LYGTIES SPRENDINI SKAIIAVIMAS................................................................... 46

VAMPYRO SKAIIAI ................................................................................................................................... 49

TRYS LAZDOS ............................................................................................................................................... 57

ELEKTROS GRANDINS VAROS SKAIIAVIMAS ............................................................................ 71

REKLAMINIAI URAAI GRAFINIAME EKRANE............................................................................... 81

PAGRINDINS PASKALIO KALBOS KONSTRUKCIJOS.......................................................................... 97

KINTAMASIS, KINTAMOJO REIKM ................................................................................................... 97

PRISKYRIMO SAKINYS .............................................................................................................................. 97

DUOMEN VEDIMAS KLAVIATRA ..................................................................................................... 98

REZULTAT (DUOMEN) IVEDIMAS EKRANE................................................................................. 99

CIKLAS WHILE ............................................................................................................................................. 100

CIKLAS FOR .................................................................................................................................................. 100

SLYGOS SAKINYS IF............................................................................................................................... 101

KNYGOJE NAUDOJAM IR REKOMENDUOJAM FUNKCIJ SRAAS................................... 102

DUOMEN VEDIMAS I FAILO............................................................................................................. 102

REZULTAT (DUOMEN) IVEDIMAS FAIL................................................................................. 103

FUNKCIJOS .................................................................................................................................................. 104

KNYGOJE NAUDOJAM IR REKOMENDUOJAM FUNKCIJ IR PROCEDR SRAAS... 105

KAI KURIE PRAKTIKOS DARBUOSE NAUDOJAMI ALGORITMAI ................................................... 107

CIKLINIAI ALGORITMAI ......................................................................................................................... 107

AKOTIEJI SKAIIAVIMAI. .................................................................................................................... 108

SUMOS SKAIIAVIMO ALGORITMAS ................................................................................................. 110

SANDAUGOS SKAIIAVIMO ALGORITMAS....................................................................................... 111

KIEKIO SKAIIAVIMO ALGORITMAS................................................................................................. 112

ARITMETINIO VIDURKIO SKAIIAVIMAS ........................................................................................ 113

DIDIAUSIOS (MAIAUSIOS) REIKMS PAIEKA ......................................................................... 113

UDUOTYS SAVARANKIKAM DARBUI .................................................................................................. 115

LITERATRA ............................................................................................................................................................. 120

1. Pagrindins struktrinio programavimo svokos

grafine forma (simboline schema ir struktrograma)

1.4. Programavimo stilius ir kultra

pavaldumui irykinti daromos traukos (pradedama rayti toliau nuo krato):

Patartume j rayti taip:

ugis1, ugis2: real; // mokini giai

Pascal AFNOR 1983

Borland Turbo Pascal 1988

2.1. vadas Free Pascal terp

Pirmas ingsnis. Darbo katalogo sukrimas.

Antras ingsnis. Free Pascal terps paleidimas.

Treias ingsnis. Programos failo krimas.

Nauj programos fail taip pat

FPS aplinkoje atsiras kuriamos

Ketvirtas ingsnis. Programos vardo pakeitimas ir raymas kataloge Darbas1.

Program rayti galima priemoni juostos

Penktas ingsnis. Programos kompiliavimas 1.

pagrindinio meniu komandomis: KompiliatoriusKompiliuoti;

programos priemoni juostos mygtuku

sparij klavi deriniu Ctrl+F9.

etas ingsnis. Programos vykdymas.

Programavimo kalba paraytos programos vertimas kompiuterin kalb.

Atuntas ingsnis. Pakeiskite ankstesn program taip:

vykd program ekrane turtumte matyti:

vykd program ekrane matote:

Devintas ingsnis. Spalv keitimas.

programos priemoni juostos mygtuku