Está en la página 1de 62

Jonas Blonskis Vytautas Buknaitis Renata Burbait , ,

Informacini technologij pasirenkamasis kursas


IXX klasms
i uolaiki kas vilgsnis
programavimo
pagrindus
VI LNI US 2010
C++
VADAS 5
1. PAGRINDINS STRUKTRINIO PROGRAMAVIMO SVOKOS 6
2. PRAKTIKOS DARBAI 12
2.1. Paintis su CodeBlocks aplinka 12
2.2. Kambario remonto ilaidos 21
2.3. Gros atidavimas 26
2.4. Kvadratins lygties sprendini skaiiavimas 32
2.5. Elektros laidinink varos skaiiavimas 36
2.6. Siena 41
2.7. Funkcijos apibrimo srities tyrimas 50
2.8. Trys lazdos 54
2.9. Vampyro skaiiai 61
2.10. Taikinys 69
2.11. Elektros grandins varos skaiiavimas 76
3. C++ KALBOS INYNAS 83
3.1. Kintamasis, kintamojo reikm 83
3.2. Priskyrimo sakinys 84
3.3. vedimo ir ivedimo srauto samprata 86
3.4. Duomen vedimas klaviatra 86
3.5. Rezultat (duomen) ivedimas ekran 86
3.6. Ciklo sakinys while 88
3.7. Ciklo sakinys for 89
3.8. Slyginis sakinys if 91
3.9. Knygoje naudojam ir / ar rekomenduojam matematini funkcij sraas 93
3.10. Duomen vedimas i failo 94
3.11. Rezultat (duomen) ivedimas fail 95
3.12. Funkcijos 96
3.13. Knygoje naudojam terpiam fail sraas 98
4. ALGORITM INYNAS 99
4.1. Tiesiniai algoritmai 99
4.2. Cikliniai algoritmai 100
4.3. akotieji skaiiavimai 100
4.4. Sumos skaiiavimo algoritmas 102
4.5. Sandaugos skaiiavimo algoritmas 103
4.6. Kiekio skaiiavimo algoritmas 104
4.7. Aritmetinio vidurkio skaiiavimas 105
4.8. Didiausios (maiausios) reikms paieka 105
5. APLINKA CodeBlocks 107
5.1. Pagrindiniai CodeBlocks bruoai 107
5.2. CodeBlocks diegimas 108
5.3. CodeBlocks konfgravimas 111
5.4. Programos ablono parengimas 113
5.5. Numatytojo kompiliatoriaus pasirinkimas ir diegimas 113
6. SAVARANKIKO DARBO UDUOTYS 118
Rekomenduojama literatra 123
TURINYS
5
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, kurioms
sprsti naudotojas turi atrasti sprendimo bd ir parayti program. iuolaikins taikomosios programos (pvz.,
skaiiuokl, raykl ir kt.) turi savo programavimo priemones, kurios leidia iplsti j galimybes, pritaikyti ias
programas konkreiai veiklos sriiai ar uduoiai sprsti. Bet kuriam kompiuterio naudotojui yra labai svarbios
programavimo inios, gdiai ir gebjimas kurti nesudtingas programas.
Imokti programuoti galima tik paiam kuriant programas. Todl mokymsi silome pradti nuo praktikos
darb. Knygos skyriuje Praktikos darbai rasite vienuolika praktikos darb. Jie visi pateikiami naudojantis
C++ programavimo kalba. Kiekviename darbe apraoma, kaip ingsnis po ingsnio kuriama programa. Pa-
raius nors ir kelet programos eilui, labai svarbu patikrinti programos darb. Tik sitikinus, kad programa
dirba gerai, galima j rayti toliau. Vartojamos svokos ir terminai glaustai paaikinti knygos skyriuje Pagrindi-
ns struktrinio programavimo svokos. J mokytis atmintinai nereikia, taiau, norint skmingai dirbti, btina
suvokti svok prasm.
Kiekvieno praktikos darbo pradioje rasite sra ini ir gebjim, kuriuos gysite atlikdami praktikos darb.
ia pateikiamos ir nuorodos skyrius C++ kalbos inynas bei Algoritm inynas. C++ kalbos inyne pristato-
mos C++ programavimo kalbos pagrindins priemons ir konstrukcijos. Algoritm inyne apraomi klasikiniai
algoritmai, naudojami vairaus tipo praktikos uduotims sprsti. i skyri informacija bus naudinga tiems,
kurie nors pasitikslinti ar pagilinti inias atlikdami konkret praktikos darb.
Kiekvienas praktikos darbo ingsnis tai tam tikra veikianios programos versija. Todl mokiniai gali dirbti
individualiai, prireikus pasikonsultuoti su mokytoju. Kiekvieno atlikto ingsnio rezultatas veikianti, bet dar
nebaigta programa. Darb galima tsti kit pamok arba namuose.
Praktikos darb pabaigoje gausu klausim ir uduoi, kurios pads kiekvienam sivertinti inias ir gdius. Tai
neprivaloma, taiau silome jas pasinagrinti ir atlikti. Jei kurios nors uduotys yra per sunkios, nepraleiskite
j, pasistenkite jas veikti inagrinj teorin mediag, konsultuodamiesi su mokytoju ar klass draugais.
Pirmieji ei praktikos darbai apraomi gana detaliai. Jie skirti programavimo pradmen mokymui, todl yra
privalomi. Kit praktikos darb tikslas susisteminti gytas inias ir patobulinti programavimo gdius. i
praktikos darb apraymai nra tokie isams, paliekama daugiau laisvs saviraikai, todl nebtina j vis
atlikti.
Mokiniams, jau turintiems pradini programavimo gdi, alia praktikos darb silome individualiai atlikti
uduotis, pateiktas skyriuje Savarankiko darbo uduotys. iems mokiniams taip pat bus naudingi darb apra-
ym papildymai, paymti odiu Smalsiems.
Tikims, kad autori silomas programavimo pagrind mokymosi bdas bus jums domus, suprantamas ir
naudingas.
Skms!
Knygos autoriai

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
6

PAGRINDINS STRUKTRINIO
PROGRAMAVIMO SVOKOS
Algoritmas, jo vykdymas, savybs
Kasdienje veikloje kiekvienas susiduriame su vairiomis taisyklmis, nurodymais, pavyzdiui: naudojimosi
vairiais renginiais ar bald surinkimo instrukcijomis, patiekal receptais ir pan.
Yra ir kitoki nurodym. Pavyzdiui, 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.
Panaiai taisykls sudaromos ir matematikos, fzikos, chemijos udaviniams sprsti. Naudodamiesi jomis, ne-
sunkiai isprendiame vienokio ar kitokio tipo udavinius. Mokydamiesi gimtj ir usienio kalbas, imoksta-
me pagrindines taisykles ir jas taikydami skmingai veikiame gramatikos subtilybes.
I pateikt pavyzdi matyti, kad taisykls yra skirtingo pobdio, taiau turi ir bendr bruo:
jas galima aprayti atskirais aikiais nurodymais, k reikia daryti;
yra pradiniai duomenys (pavyzdiui: patiekalui pagaminti reikalingi pro-
duktai, spintos sudedamosios dalys ir kt.);
gaunamas tam tikras rezultatas (pagaminamas patiekalas, sukonstruojama
spinta ir kt.).
Ivardyti bruoai apibdina algoritmo (lot. algorithmus pagal Vidurins Azijos ma-
tematiko al-Chwarizmi pavards lotynikj form Algorithmi) svok. iuo atveju,
vadovaudamasis algoritmu, veiksmus atlieka mogus.
Algoritm vadinami aiks vienareikmiai nurodymai (sakiniai), kaip turint tam
tikrus pradinius duomenis galima gauti reikiamus rezultatus.
Algoritmo svoka yra viena i pagrindini matematikos ir informatikos svok. Pir-
mieji algoritmai apibdino veiksmus, atliekamus su deimtains skaiiavimo siste-
mos skaiiais. Vliau algoritmo svoka pradta vartoti apibdinant veiksm sek,
kuri reikia atlikti norint isprsti udavin. ioje knygoje nagrinjami matematinio
pobdio algoritmai. Pateikiame pagrindines j svokas.
Pradi`niai domenys tai i anksto inomos reikms (paprasiausiu atveju skaiiai), btinos veiksmams
atlikti. Pavyzdiui, norint apskaiiuoti staiakampio plot, btina inoti jo ilg ir plot.
Rezulttai tai reikms, gautos atlikus visus skaiiavimus.
Trpiniai rezulttai tai apskaiiuotos reikms, kurios naudojamos tolesniems veiksmams atlikti. Tarpiniai
rezultatai padeda programuotojui pasitikrinti, ar parayta visa programa, ar tik jos dalis, ar programos dalys
veikia gerai.
Algoritmu apraomi veiksmai yra skirti vkdytojui.
Kiekvienam algoritmui bdingos tokios savybs:
Diskretmas. Algoritmas suskaidomas baigtin ingsni sek. Tik atlikus vieno ingsnio veiksmus
galima pereiti prie kito ingsnio.
Aikmas. Visus algoritmu apraomus veiksmus bet kuris vykdytojas turi suprasti vienareikmikai. ioje
knygoje pateikiami algoritmai skirti kompiuteriui nemstaniam vykdytojui. Kad suprastume, k rei-
kia 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

Ebu Abdullah Muhammed


bin Musa al-Chwarizmi
(apie 780850 m.)
7
iekoti ir prijs krykel pamat ilg pagriovy stovint ir garsiai liumbiant. Tvo paklaustas, kas atsiti-
ko, 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 dien tvas sn pats per krykel
perved ir paleido: irk man, eik ir nesidairyk! Sieksnis, tiesiai eidamas, pirmiausia maln prijo ir
vis dien malnininkui talkino. Trei dien tvas pats sn mokykl nutemp.
iame epizode Sieksn galime laikyti nemstaniu algoritmo vykdytoju, kuris tiesiogiai, t. y. nemsty-
damas ir neanalizuodamas, vykd tvo nurodymus.
Rezultatyvmas. Atlikus baigtin skaii algoritmo veiksm, gaunamas rezultatas. Vienas i galim
rezultat udavinys sprendini neturi.
Baigtmas. Rezultatas gaunamas vykdius baigtin skaii algoritmo veiksm.
Universalmas. Naudojant t pat algoritm, sprendiami visi to tipo udaviniai, t. y. kiekvienam pra-
dini duomen rinkiniui gaunamas teisingas rezultatas.
Yra daug udavini, kuriems sprsti nra tiksli algoritm. Pavyzdiui, reikia mainomis gabenti daug vai-
raus dydio tui di, kurias galima dti vienas kitas. Main su kroviniu skaiius turi bti kuo maesnis.
Net mogus, galintis intuityviai sprsti tok udavin, ne i karto gaus geriausi rezultat. Jeigu di daug, o
mainas telpa nevienodas j skaiius, tuomet nemanoma perrinkti vis galim sprendimo variant ir ten-
ka pasirinkti vien kur nors geresn rezultat. Tokio tipo udaviniams sprsti kuriami algoritmai vadinami
euristiniais.
Algoritmai gali bti pateikiami skirtingais bdais:
Uraomi diais. is bdas naudojamas, kai norima labai aikiai nurodyti atliekamus veiksmus. U-
raomos komandos gali bti numeruojamos arba veiksmai apraomi kaip pasakojimas.
Vaizduojami grfkai daniausiai simblinmis (blkinmis) schmomis arba struktrogrmomis.
Vartojami grafniai simboliai apibria tam tikro tipo veiksm. Simbolinse schemose grafnius sim-
bolius jungianios linijos rodo, kokia tvarka tie veiksmai atliekami. Sutarta, kad linijos eina i viraus
apai ir i kairs dein. Visais kitais atvejais linijos gale braioma rodykl, nurodanti tolesni veiks-
m krypt. Struktrogramoje veiksm vykdymo tvarka nusakoma grafniais simboliais.
Uraomi pseudokod. Vartojami odiai, artimi natraliai kalbai. Pseudokodu patogu urayti algo-
ritmus, kai norima trumpiau ir suprantamiau atskleisti j esm vadovliuose, straipsniuose.
Pavyzdys
Kompiuteryje skaii a keliant n-uoju laipsniu skaiiuojama sandauga (tarkime, 2
3
= 2 * 2 * 2).
Skaiiaus a klimo n-uoju laipsniu algoritmas gali bti uraytas:
odiu:
1. Suinoti a ir n reikmes.
2. Skaiiuoti kartai = 1.
3. Skaiiuoti laipsnis = 1.
4. Jeigu kartai <= n, tuomet vykdyti 5 ingsn, prieingu atveju pereiti prie 8 ingsnio.
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.

8
Grafkai (simboline schema ir struktrograma):

Programa, programavimo kalba, struktrinis programavimas
Algoritmas, uraytas kuria nors programavimo kalba, yra vadinamas program.
Programvimo kalb, kaip ir nekamoji, turi savo sintaks ir semantik. Programavimo kalbos kiekvienos
konstrukcijos, kiekvieno odio, kiekvieno sakinio prasm vienareikm. Programavimo kalb yra labai daug.
Nuo 1954 m., kai buvo sukurta pirmoji programavimo kalba, iki dabar yra suskaiiuojama per 2500 kalb.
Schemoje pateikta iuo metu populiari mokymuisi skirt Pascal ir C++ programavimo kalb trumpa atsi-
radimo istorijos schema. Daugiau informacijos apie programavimo kalbas ir j istorij galite rasti internete
(www.levenez.com/lang).
Fortran 1954.11 Fortran I 1956.10 IAL 1958 Algol 58 1958 Algol 60 1960
C 1971 Simula I 1964
C++ 1983
Pascal 1970 CLU 1974
Modula 1975
Mesa 1977
Delphi 1995
Pascal AFNOR 1983
Object Pascal 1985 Borland Turbo Pascal 1988
ioje knygoje programoms kurti vartosime C++ programavimo kalb. Taiau norime pabrti, kad pati progra-
mavimo kalba yra tik priemon programavimo gdiams gyti, bet ne mokymosi tikslas. Stengiams naudoti
tas kalbos konstrukcijas, kurios yra bendros ar analogikos kit programavimo kalb konstrukcijoms.
Programvimas tai procesas, kuris apima iuos etapus:
uduoties analizs;
uduoties skaidymo dalis;
sprendimo metod parinkimo ir sukrimo;
kintamj parinkimo;
algoritm sudarymo;
programos teksto raymo, derinimo ir testavimo.

9
Yra keletas programavimo technologij. Viena j struktrinis programvimas (kartais vadinamas proce-
driniu programvimu). Struktrinio programavimo pradia yra laikoma XX a. atuntojo deimtmeio pa-
baiga. 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.
Programvimo aplink tai aparatins ir programins rangos priemoni visuma, skirta naujoms programi-
nms priemonms kurti. Paprasiausios programavimo aplinkos, pavyzdiui, CodeBlocks, turi raykl progra-
m tekstams kurti ir taisyti, kompiliatori, priemones programai derinti ir vykdyti.
Kompilitorius tai programa, kuri veria parayt programos tekst kompiuteriui suprantam kalb. Jeigu
randa raybos (sintakss) klaid, tai vertim nutraukia ir nurodo rastas klaidas.
Programos struktra
Progrmos struktr (sandar) lemia programavimo kalba. Vienos kalbos yra grietos struktros, kitose yra
leistinos alternatyvos. Programos struktrai turi takos ir programavimo technologija.
Vadovlyje pateiktos programos paraytos C++ programavimo kalba, laikantis
struktrinio programavimo technologijos reikalavim. Programos tekstas suside-
da i dviej arba trij dali:
naudojam priemoni (bibliotek, funkcij prototip, konstant, kinta-
mj, nauj tip) apraymo;
pagrindins funkcijos main() kintamj ir veiksm sakini;
naudojam funkcij, jeigu jos yra, tekst.
Programavimo stilius ir kultra
Kaip ir raytojams, program autoriams bdingas individualus programvimo stilius. Kiekvieno programuotojo
ar programuotoj grups poiris programavim ir programavimo kalbas yra savitas. Visi jie skirtingai naudoja
programavimo priemones. ios knygos autoriai laikosi toki esmini programavimo stiliaus princip:
kintamj apraai grupuojami pagal paskirt ir apraomi pagrindins funkcijos main() pradioje;
paprast kintamj (skirt skaiiams, simboliams ar loginms reikmms atmintyje laikyti) vardai
pradedami maja raide;
jei programoje yra kuriama funkcija, ji skirta vienam grietai apibrtam veiksmui atlikti (pavyzdiui:
duomenims vesti, vidurkiui apskaiiuoti, rezultatui ivesti).
Programuojant sudting uduot, labai danai jos sprendimas padalijamas atskiras dalis, kurias realizuoja
skirtingi programuotojai. Kiekvienas i j turi parayti savo dal taip, kad j lengvai suprast kiti. Svarbu, kad vi-
sas uduoties dalis bt galima susieti, pataisyti arba panaudoti kitiems udaviniams sprsti. Todl programos
tekstas turi bti aikus, vaizdus, lengvai skaitomas ir suprantamas bet kuriam naudotojui: su traukomis, tarpais
ir komentarais. Be to, programos tekstas turi atitikti login algoritmo struktr ir veiksm hierarchij.
Toliau aptarsime pagrindines programos krimo ir jos teksto pateikimo taisykles.
Raant program, reikt laikytis toki programvimo kultros taisykli:
algoritmas turi geriausiai tikti udaviniui sprsti, bti aikus, trumpas ir logikai pagrstas;
kintamj, konstant, tip, funkcij vardai turi atitikti apraom objekt prasm, taiau neturi bti
ilgi;
programa turi bti raoma su komentarais.

priemoni
apraymas
funkcij prototipai
funkcij tekstai
int main()
{
kintamieji
veiksmai
return 0;
}
10
Esmins programos teksto dstymo taisykls:
programos dalims iskirti paliekamos tuios eiluts arba raomi komentarai, sudaryti tik i minuso ar
kitoki enkl;
pavaldumui irykinti daromos traukos (pradedama rayti toliau nuo krato) ciklo ir slyginiuose
sakiniuose;
skaitomumui pagerinti slyginiuose ir sudtiniuose sakiniuose vertikaliai lygiuojami ie odiai: if,
else ir {, }.
programos tekstas raomas i abiej pusi tarpais atskiriant iuos enklus:
>, <, !=, >=, <=, =, +, -, *, /, +=, -=, *=, /=, >>, <<.
Tekst reikt rayti taip, kad atskiros dalys pagal prasm bt nesunkiai atpastamos ir suvokiamos. Jas rei-
kt idstyti lape lyg kok piein.
Pavyzdiui, tekst
...
double pirmas,antras,trecias;
cin>>pirmas>>antras>>trecias;
cout<<pirmas<<antras<<trecias;
...
sunku skaityti, todl patartume j rayti taip:
...
double pirmas, antras, trecias;
cin >> pirmas >> antras >> trecias;
cout << pirmas << antras << trecias;
...
Programos tekst padeda suprasti komentarai. Jie skirti programuotojui ir visai neturi takos programos vyk-
dytojui (kompiuteriui). Komentarai turi bti trumpi, taikliai papildyti program ir jos neugoti. Raant ko-
mentarus, siloma:
programos pradioje po antrate (arba prie j) nurodyti programos autori, paskirt, paskutinio
taisymo dat, versijos numer, uduoties sprendimo bd, programos apribojimus;
kintamj aprauose nurodyti j paskirt;
prie slyginius sakinius, ciklus, funkcijas, sakini blokus { ir } nurodyti j paskirt;
lygiuoti juos vertikaliai.
Pavyzdiui, programos fragment
double ugis1, ugis2; // mokini gis
int metai1, metai2; // mokini gimimo metai
int amzius1, amzius2; // mokini amius
double svoris1, svoris2; // mokini svoris
sunku skaityti. Silome kintamuosius grupuoti pagal prasm, juos ir komentarus vienodai lygiuoti:
// Pirmo mokinio duomenys:
double ugis1; // gis
int metai1; // gimimo metai
int amzius1; // amius
double svoris1; // svoris
// Antro mokinio duomenys:
double ugis2; // gis
int metai2; // gimimo metai
int amzius2; // amius
double svoris2; // svoris
Taisyklingai raydami, prarasime iek tiek laiko, taiau laimsime kur kas daugiau padarysime maiau klaid,
greiiau jas pastebsime.

11
Programos ir jos naudotojo dialogas
Tarp naudotojo ir kompiuterio danai vykdomas dialgas. vedant duomenis klaviatra, btina ivesti ekran
praneim, k naudotojas turi vesti, ir, jeigu reikia, nurodyti vedimo form bei eils tvark. Pavyzdiui, pro-
gramos fragmentas
...
cout << "Apskritimo spindulys: ";
cin >> R;
...
pareigoja kompiuter laukti, kol vesime vien skaii. Praneime dar vertt nurodyti, kok skaii vesti
(realj ar sveikj).
Dialogo tekstas, praneimai, nurodymai turi bti trumpi, informatyvs ir vienareikmikai suprantami. Prane-
imai neturi bti susij su programos kintamj vardais, jeigu jie nra informatyvs, pavyzdiui:
...
cout << "a = ";
cin >> a;
...
...
cout << "Knygos kaina: ";
cin >> a;
...
I pirmojo dialogo neaiku, kas yra a, i antrojo aiku, kad reikia vesti preks kain, nebtina inoti, kad
kaina programoje turi vard a.
Pavyzdinis programos krimo planas
1. Pradini duomen ir bsim rezultt anliz. Isiaikinama, kiek yra pradini duomen, kiek bus rezul-
tat, kokie j tipai, kokia tvarka juos pateikti.
2. davinio sprendimo idja tai mintis (sumanymas), kaip sprsti udavin. Idjos teisingumu galima si-
tikinti modeliuojant programos veiksmus su vairiais duomenimis. Program reikt pradti rayti tik si-
tikinus, kad sugalvotas sprendimo bdas yra teisingas.
3. Kintamj parinkimas pradi `niams duomenims ir rezulttams laikti. Nuo j parinkimo priklauso pro-
gramos apimtis, struktra, algoritmas ir jo gyvendinimas.
4. Algoritmo sukri `mas tai udavinio sprendimo idjos gyvendinimas. Daniausiai taikomi inom mate-
matini udavini sprendimo bdai naudojant pasirinktus kintamuosius.
5. Progrmos rymas tai sukurto algoritmo pateikimas pasirinkta programavimo kalba. Programa raoma
laikantis struktrinio programavimo princip (nedidelmis dalimis). Patariama sitikinti, kad kiekviena
programos dalis dirba teisingai. Tai leidia program rayti ingsnis po ingsnio. Kai derinamo teksto dalys
nedidels, galutin programa gaunama lengviau ir greiiau.
6. Testvimas. Parayta programa testuojama. Taip sitikinama, kad norimas rezultatas pasiekiamas esant vi-
siems galimiems teisingiems pradini duomen rinkiniams. Programuotojas turt sukurti kuo vairesni
pradini duomen rinkini, kad bt galima patikrinti prastas situacijas ir ribinius atvejus, sprendimo
efektyvum naudojamos atminties ir vykdymo laiko poiriu.
12

2.1. Paintis su CodeBlocks aplinka
Atlikdami darb, susipainsite su CodeBlocks aplinka:
sukursite darbo katalog ir programos fail;
pakeisite programos pavadinim, program raysite darbo katalog;
sukompiliuosite ir vykdysite paprasiausi program;
imoksite program taisyti;
imoksite ivesti duomenis ekran naudodami ivesties sraut wcout.
Nuorodos C++ kalbos inyn Nuorodos algoritm inyn
3.5. Rezultat (duomen) ivedimas ekran
3.13. Knygoje naudojam terpiam fail sra-
as
4.1. Tiesiniai algoritmai
Atliekant praktikos darb, svarbu ne apskaiiuoti kok nors konkret rezultat ar sukurti nurodyt program,
o tiesiog pajusti darbo CodeBlocks aplinkoje ypatumus, gyti patirties, kurios prireiks atliekant kitus darbus.
Dirbdami galite atlikti ir daugiau veiksm, negu ia parayta.
Kiekviena CodeBlocks programa sukuria kelet fail. Todl, prie praddami darb, sukurkite atskir katalog
kiekvieno praktikos darbo failams laikyti.
1
Darbo katalogo krimas
Kurioje nors laikmenoje, naudodamiesi prastomis Windows sistemos priemonmis, sukurkite bendr
katalog, kuriame laikysite visus savo CodeBlocks darbus. Katalog galite pavadinti savo pavarde, pa-
vyzdiui, Pavardenis.
iame kataloge sukurkite pakatalog Darbas1, skirt pirmajam darbui.
2
CodeBlocks paleidimas
Norint pradti dirbti, reikia, kad kompiuteryje bt diegta kuri nors CodeBlocks versija. Visi ios knygos pa-
vyzdiai sukurti naudojantis CodeBlocks 10.05 versija. J galima rasti internete (http://prdownload.berlios.de/
codeblocks/codeblocks-10.05mingw-setup.exe). Detaliau, kaip diegti ir paruoti aplink darbui, aprayta 5 sky-
riuje Aplinka CodeBlocks.
CodeBlocks galima paleisti:
pasirinkus pradios meniu komandas: Visos programos CodeBlocks:
dukart spragteljus darbalaukyje aukin .

13
Skmingai vykd nurodymus, pateksite CodeBlocks lang, kuris valdomas (padidinamas, sumainamas, per-
neamas ar uveriamas) prastomis operacins sistemos Windows priemonmis.

3
Programos failo krimas
Pagrindiniame meniu pasirinkite komandas File New File... ir atsivrusiame dialogo lange pay-
mkite C/C++ source. Patvirtinkite pasirinkim spragteldami mygtuk Go.

14
Atsivrusiame dialogo lange pasirinkite programavimo kalb C++ ir spragtelkite mygtuk Next.
Pasirinkite, kur rayti fail: spragtelj mygtuk , atsivrusiame dialogo lange nurodykite katalog
Darbas1, o laukelyje File name raykite failo, kuriame bus sukurta programa, vard Darbas1. Spragte-
lkite mygtuk Save.

15
Dialogo lange matysite vis programos failo adres.

Spragteljus mygtuk Finish, aplinkoje CodeBlocks atsivers kuriamos programos ablonas, kur galsite
redaguoti CodeBlocks rengykle.
Nauj programos fail taip pat galima sukurti pasirinkus priemoni juostos mygtuk arba spariaisiais kla-
viais Ctrl + Shif + N.
4
Programos ablonas
Panaiems tam tikro tipo dokumentams (pvz., C++ programoms) rengti yra patogu naudotis ablonu (pavyz-
diu). Jame raoma informacija, kuri to tipo dokumentuose visada yra tokia pati. Be to, jame gali bti nuro-
doma, kokia informacija dokumente turi bti keiiama. Skyriuje Aplinka CodeBlocks paaikinta, kaip galima
sukurti C++ program ablon.
Ms sukurtame C++ program ablone rayti sakiniai, reikalingi paprasiausiai veikianiai programai. Pana-
grinkime ablon.

Pirmoje eilutje raytas komentaras, kuris neturi jokios takos programos darbui.
// Vieta programos vardui rayti
Komentaro tekst programuotojas gali keisti, uraydamas jo vietoje programos vard, trumpai apibdindamas
kuriamos programos paskirt. Jeigu reikalinga, komentar galima praplsti iki keleto eilui.
Programos pradioje suraytos instrukcijos parengiamajai doroklei (angl. preprocessor), kurios ymimos sim-
boliu #. terpimo instrukcijomis include nurodoma, koki fail tekstai turi bti terpti instrukcij paymtose

16
vietose pirminio apdorojimo metu. terpiam fail vardai raomi tarp simboli < >. ablone rayti pirmajame
darbe naudojami failai.
terpiamas failas Paaikinimas
iostream
fcntl.h
io.h
Duomen vedimo klaviatra ir ivedimo ekran priemons
Priemons lietuvikiems ramenims ivesti ekran
Priemons lietuvikiems ramenims ivesti ekran
Sakinys
using namespace std;
raomas visada, jei programoje terpiamas bent vienas antratinis failas (pvz., iostream).
Toliau raoma programos pagrindins funkcijos antrat
int main ()
Pagrindins funkcijos kamienas (veiksm sritis) pradedamas enklu {, baigiamas enklu }.
Sakinys
_setmode (_fleno(stdout), _O_U16TEXT);
reikalingas tam, kad ekrane bt teisingai rodomi lietuviki ramenys su diakritiniais enklais.
Sakinys
wcout << L"Labas" << endl;
ekran iveda od Labas.
Tekstui su lietuvikais ramenimis ivesti ekran reikia naudoti ivedimo srauto modifkacij wcout.
Prie simboli eilutes, kuriose yra lietuvik ramen, reikia parayti didij raid L. Kitais atvejais
raids L rayti nebtina.
Sakinys
return 0;
nurodo programai baigti funkcijos main() darb.
5
Programos vardo pakeitimas. Programos failo raymas katalog Darbas1
Pirmojoje eilutje raykite programos vard Darbas1.

// Darbas1
#include <fcntl.h>
#include <io.h>
\
Toliau pasirinkite vien i ivardyt pagrindinio meniu komand:
File Save File;
File Save File As...;
File Save all Files;
File Save everything.
Program rayti taip pat galima priemoni juostos mygtukais arba spariaisiais klaviais Ctrl + S,
Ctrl + Shif + S arba Alt + Shif + S.
Kurdami program, kartkartmis raykite j laikmen. Tai galite atlikti vienu i i bd:
pagrindinio meniu komandomis: File Save File;
programos priemoni juostos mygtuku ;
spariaisiais klaviais Ctrl + S.

17
6
Programos kompiliavimas
Tai galima atlikti vienu i trij bd:
pagrindinio meniu komandomis Build Build arba Build Compile current fle;
programos priemoni juostos mygtuku ;
spariaisiais klaviais Ctrl + F9 arba Ctrl + Shif + F9.
Jeigu programoje nebuvo sintakss klaid, apatinje darbo lango dalyje bus rodomas praneimas apie skmin-
gai sukompiliuot program.

Ibandykite visus tris programos kompiliavimo bdus ir pasirinkite tinkamiausi.
Taiau, norint pamatyti programos darbo rezultatus, j dar reikia vykdyti.
7
Programos vykdymas
Tai galima atlikti vienu i trij bd:
pagrindinio meniu komandomis Build Run;
programos priemoni juostos mygtuku ;
funkciniu klaviu Ctrl + F10.
Jeigu programoje nebuvo kompiliavimo klaid, ekrane atsivers juodos spalvos programos rezultat langas, ku-
riame ivysite od Labas ir informacin praneim.
Norint taisyti program, pirmiausia reikia uverti rezultat lang. Tai galima padaryti spusteljus klaviatros
klavi Enter arba spragteljus lango uvrimo mygtuk .
gijus patirties ir norint paspartinti darb CodeBlocks aplinkoje, penkt ingsn Programos kompiliavimas ga-
lima praleisti. Prie vykdant program, kuri buvo taisyta, ji i naujo sukompiliuojama. Tam patogu naudotis
pagrindinio meniu komandomis Build Build and Run arba funkciniu klaviu F9.
Iskleiskite darbo pradioje sukurt katalog Darbas1 ir pairkite, kiek ir koki fail sukurta. Svarbiausias
failas yra Darbas1.cpp (C++ source fle), nes jame yra programos tekstas. fail reikia saugoti. I io failo su-
kuriami kiti to paties pavadinimo failai Darbas1 su skirtingais prievardiais bei kiti pagalbiniai failai.

8
Teksto ivedimas ekran
Nordami, kad ekrane alia odio Labas bt uraytas ir js vardas, programos teksto eilut
wcout << L"Labas" << endl;
pakeiskite tokia:
wcout << L"Labas. Mano vardas uolas!" << endl;

18
Atlikus pakeitim, programa bus tokia:

// Darbas1
#include <fcntl.h>
#include <io.h>
#include <iostream>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
wcout << L"Labas. Mano vardas uolas!" << endl;
return 0;
}
vykdykite program, t. y. pakartokite penkt ir et ingsnius arba tik et ingsn. Ekrane turtu-
mte matyti:

Labas. Mano vardas uolas!
9
Teksto ir ornamento ivedimas ekran
Pakeiskite ankstesn program taip:

// Darbas1
#include <fcntl.h>
#include <io.h>
#include <iostream>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
wcout << L"*******************************" << endl;
wcout << L"* Labas. Mano vardas uolas! *" << endl;
wcout << L"*******************************" << endl;
return 0;
}
vykdykite program. Ekrane turtumte matyti:

*******************************
* Labas. Mano vardas uolas! *
*******************************
Kaip pastebite, vykdant program, kiekvienu wcout sakiniu, kuris baigiasi manipuliatoriumi endl, ekrane
atskirose eilutse ivedamas tekstas, nurodytas tarp paprastj kabui. Manipuliatorius endl perkelia ymekl
nauj eilut.
Programoje paalinkite << endl.

wcout << L"*******************************";
wcout << L"* Labas. Mano vardas uolas! *";
wcout << L"*******************************";
vykdykite program. Ekrane matysite:

********************************* Labas. Mano vardas uolas! *****************
****************

19
Pastebjote, kad be manipuliatoriaus endl, upildoma pirma eilut (eilutje telpa 80 enkl), po to pradedama
pildyti antroji.
Pakeiskite program taip, kad gautumte tok vaizd:

* * * * * * * *
*** *** *** *** *** *** *** ***
* * * * * * * *
* Labas. Mano vardas uolas! *
* * * * * * * *
*** *** *** *** *** *** *** ***
* * * * * * * *
10
Darbo su CodeBlocks pabaiga
Darb galima baigti pagrindinio meniu komandomis File Quit, spariaisiais klaviais Ctrl + Q arba spragte-
ljus CodeBlocks lango uvrimo mygtuk .
raykite program ir baikite darb su CodeBlocks.
Klausimai
1. K pirmiausia patartina susikurti prie pradedant rayti program?
2. Kaip paleidiama CodeBlocks?
3. Kaip sukuriama nauja programa?
4. Kurioje vietoje raomas programos vardas?
5. Kokius veiksmus reikia atlikti norint rayti program laikmen?
6. Kokiais bdais program galima sukompiliuoti?
7. Kokiais bdais program galima vykdyti?
8. Kok veiksm atlieka manipuliatorius endl?
Uduotys
1. Paraykite program, kuri ekrane i vaigdui nupiet js inicialus.
2. Paraykite program, kuri ekrane nupiet js sugalvot ornament.
SMALSIEMS
Nordami darbo rezultatus matyti ne kompiuterio ekrane, o tekstiniame faile, tursite:
parengti fail raymui;
rayti fail norim tekst;
uverti tekstin fail.
Nuorodos C++ kalbos inyn
3.1. Kintamasis, kintamojo reikm
3.11. Rezultat (duomen) ivedimas fail
3.13. Knygoje naudojam terpiam fail sraas
Inagrinkite ir paraykite program, kuri tekstin fail rao lietuvi kalbos abcls didisias ir
masias raides su diakritiniais enklais.

20
Programos pradioje terpkite fail fstream, kuriame yra duomen skaitymo i failo ir ivedimo
fail priemons.

// Darbas1
#include <fcntl.h>
#include <io.h>
#include <iostream>
#include <fstream>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
ofstream fr ("Darbas1.txt"); // failas parengiamas duomenims rayti
fr << "" << endl;
fr << "" << endl;
fr.close(); // failas uveriamas
return 0;
}
vykdykite program. Matysite juod ekran, nes rezultatai rayti tekstin fail Darbas1.txt. Jis su-
kurtas tame paiame kataloge, kuriame yra ir programos failas Darbas1.cpp. Fail Darbas1.txt galima
atverti meniu komandomis File Open arba spariaisiais klaviais Ctrl + O.

Failas Darbas1.txt

Savo sukurt program papildykite, kad tekstas ir ornamentas, kurie buvo ivedami ekran, bt
ivedami tekstin fail.

Failas Darbas1.txt
* * * * * * * *
*** *** *** *** *** *** *** ***
* * * * * * * *
* Labas. Mano vardas uolas! *
* * * * * * * *
*** *** *** *** *** *** *** ***
* * * * * * * *

21
2.2. Kambario remonto ilaidos
Atlikdami darb, isiaikinsite, kaip kuriama paprastus skaiiavimus atliekanti programa:
imoksite aprayti sveikojo ir realiojo tipo kintamuosius;
isiaikinsite, kaip i vedimo srauto cin perskaitomos ir simenamos kintamj reikms;
suprasite, kaip uraomi ir atliekami vairs skaiiavimai;
pritaikysite ivedimo sraut wcout rezultatams ivesti ekran.
Nuorodos C++ kalbos inyn Nuorodos algoritm inyn
3.1. Kintamasis, kintamojo reikm
3.2. Priskyrimo sakinys
3.4. Duomen vedimas klaviatra
3.5. Rezultat (duomen) ivedimas ekran
3.13. Knygoje naudojam terpiam fail sra-
as
4.1. Tiesiniai algoritmai
Uduotis
inomi kambario matmenys (metrais) ilgis ir plotis. Abu dydiai yra
sveikieji skaiiai. Reikia apskaiiuoti, koki pinig sum psuma reiks
mokti u plyteles, skirtas kambario grindims ikloti, jei plyteli vieno
kvadratinio metro kaina yra m2kaina lit. Plyteli reikia pirkti 5 proc.
daugiau galimiems nuostoliams padengti.
Algoritmas
Uduotis sprendiama taip:
apskaiiuojamas kambario plotas;
apskaiiuojama pinig suma, kuri reiks mokti u plyteles.
1
Pasiruoimas
Kaip ir pirmajame darbe, atlikite tokius veiksmus:
sukurkite katalog Darbas2 programos fai-
lams laikyti;
paleiskite CodeBlocks;
sukurkite programos fail;
suteikite programai vard Darbas2;
raykite fail sukurt katalog Darbas2
vardu Darbas2.cpp.
2
Bandomasis programos kompiliavimas ir vykdymas
Sukompiliuokite ir vykdykite program.
Kaip ir pirmajame darbe, programa tik pasisveikins, t. y. ives ekran od Labas, taiau joki skaiiavim
neatliks.


22
3
Kintamj, skirt pradiniams duomenims atmintyje laikyti, apraymas ir
j reikmi vedimas
Programos pradioje apraykite sveikojo tipo int kintamuosius ilgis ir plotis kambario
matmenims atmintyje laikyti.
Pakeiskite sakin
wcout << L"Labas" << endl;
nauju sakiniu
wcout << L"Programa darb pradjo." << endl;
Paraykite kintamojo ilgis reikms vedimo klaviatra sakinius: praneimo, koki reikm vesti,
sakin (wcout) ir reikms skaitymo sakin (cin).
// Darbas 2
#include <fcntl.h>
#include <io.h>
#include <iostream>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int ilgis, plotis; // kambario matmenys
wcout << L"Programa darb pradjo." << endl;
wcout << L"veskite kambario ilg: "; cin >> ilgis;
return 0;
}
raykite ir vykdykite program. Klaviatra veskite skaii 5 ir spustelkite klavi Enter. Ekrane ma-
tysite:
Programa darb pradjo.
veskite kambario ilg: 5
Paraykite kintamojo plotis reikms vedimo klaviatra sakinius: praneimo, koki reikm vesti,
sakin (wcout) ir reikms skaitymo sakin (cin). Galite kopijuoti kintamojo ilgis reikms vedimo
sakinius ir vietoj kintamojo vardo ilgis parayti plotis.
// Darbas 2
#include <fcntl.h>
#include <io.h>
#include <iostream>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int ilgis, plotis; // kambario matmenys
wcout << L"Programa darb pradjo." << endl;
wcout << L"veskite kambario ilg: "; cin >> ilgis;
wcout << L"veskite kambario plot: "; cin >> plotis;
return 0;
}
raykite ir vykdykite program. Klaviatra veskite skaii 5 ir skaii 4 bei spustelkite po kiekvieno
i j klavi Enter. Ekrane matysite:
Programa darb pradjo.
veskite kambario ilg: 5
veskite kambario plot: 4

23
4 Kintamj, skirt rezultatui atmintyje laikyti, apraymas.
Rezultat skaiiavimas ir ivedimas ekran
Papildykite program nauju sveikojo tipo kintamuoju plotas.
Uraykite ploto skaiiavimo sakin:
plotas = ilgis * plotis;
Iveskite ekran apskaiiuot ploto reikm.
Programos pabaigoje prie sakin
return 0;
uraykite sakin
wcout << L"Programa darb baig.";
// Darbas 2
#include <fcntl.h>
#include <io.h>
#include <iostream>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int ilgis, plotis; // kambario matmenys
int plotas; // kambario grind plotas
wcout << L"Programa darb pradjo." << endl;
wcout << L"veskite kambario ilg: "; cin >> ilgis;
wcout << L"veskite kambario plot: "; cin >> plotis;
plotas = ilgis * plotis;
wcout << L"Kambario grind plotas: " << plotas << endl;
wcout << L"Programa darb baig.";
return 0;
}
raykite ir vykdykite program. Klaviatra veskite skaii 5 ir spustelkite klavi Enter. Po to klaviatra ves-
kite skaii 4 ir spustelkite klavi Enter. Ekrane matysite:
Programa darb pradjo.
veskite kambario ilg: 5
veskite kambario plot: 4
Kambario grind plotas: 20
Programa darb baig.
5
Kambario remonto ilaid skaiiavimas
Dabar reikia apskaiiuoti, kiek kainuos plytels, kai inoma vieno m
2
kaina m2kaina. inome, kad plyteli rei-
kia pirkti 5 proc. daugiau galimiems nuostoliams padengti. Pinig sum psuma, reikaling kambario remontui,
galima apskaiiuoti priskyrimo sakiniais:
psuma = (plotas * m2kaina) + (0.05 * plotas * m2kaina);
arba
psuma = 1.05 * plotas * m2kaina;
Papildykite program tokiais sakiniais:
realiojo tipo (double) kintamj m2kaina ir psuma apraymo:
double m2kaina; // plyteli 1 kvadratinio metro kaina
double psuma; // pinig suma

24
plyteli vieno kvadratinio metro kainos vedimo klaviatra:
wcout << L"veskite plyteli 1 kvadratinio metro kain: ";
cin >> m2kaina;
plyteli kainos skaiiavimo:
psuma = 1.05 * plotas * m2kaina;
rezultat ivedimo ekran:
wcout << L"Pinig suma, kuri reikia sumokti: " << psuma << endl;
Kaip pastebjote, kintamasis psuma turi bti realiojo tipo (double), nes plyteli kain sudaro dvi da-
lys: sveikoji (litai) ir trupmenin (centai).
raykite ir vykdykite program su pateiktais pradiniais duomenimis. Ekrane matysite:
Programa darb pradjo.
veskite kambario ilg: 5
veskite kambario plot: 4
Kambario grind plotas: 20
veskite plyteli 1 kvadratinio metro kain: 45.50
Pinig suma, kuri reikia sumokti: 955.5
Programa darb baig.
Klausimai
1. Koks bazinis C++ programavimo kalbos odis yra vartojamas sveikojo tipo kintamiesiems aprayti?
2. Koks bazinis C++ programavimo kalbos odis yra vartojamas realiojo tipo kintamiesiems aprayti?
3. Apraykite du sveikojo tipo kintamuosius, kurie nurodo mokinio ami (metai) ir mas (kilogramai).
4. Kokie du sakiniai vartojami kintamojo reikmei vesti? Uraykite pavyzd kintamojo greitis reikmei
vesti.
Uduotys
1. Paraykite program, kuri apskaiiuot, kiek popieriaus lap k reiks norint nukopijuoti konspekt visos
klass mokiniams. inoma, kad klasje yra n mokini ir konspekt sudaro m lap.
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.
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 gyvena iame pasaulyje. Tarkime, kad metai turi
365 dienas.
Pasitikrinkite. ved a = 16, turtumte gauti: men = 192, d = 5840, v = 140160.
4. Paraykite program, kuri apskaiiuot, kiek knyg k vidutinikai per metus perskaito vienas mokyklos
bibliotekos lankytojas. inomas vidutinikai per vien mnes perskaityt knyg skaiius v ir vidutinikai
per metus apsilankiusij bibliotekoje skaiius n.
Pasitikrinkite. ved v = 120, n = 800, turtumte gauti k = 2.

25
5. Paraykite program, kuri apskaiiuot, kiek vidutinikai keleivi k vaiuoja Vilni viename traukinio
vagone, jei inomas traukinio keleivi skaiius n, keleivi, vykstani ne Vilni, skaiius m ir vagon
skaiius v.
Pasitikrinkite. ved n = 100, m = 20 ir v = 4, turtumte gauti k = 20.
6. Paraykite program, kuri apskaiiuot staiakampio, kurio virutinio kairiojo tako (x1; y1) ir apatinio
deiniojo tako (x2; y2) koordinats yra sveikieji skaiiai, plot s ir perimetr p. Nurodyt tak koordinats
vedamos klaviatra. Staiakampio kratins lygiagreios su koordinai aimis.
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. Tarakonas yra vienas greiiausi gyvn. Jo greitis yra g kilometr per valand. Apskaiiuokite, kiek centi-
metr c tarakonas nubga per sekund.
Pasitikrinkite. Kai g = 1.08, turi bti spausdinama:
c = 30 cm
8. Vienas garsus Lietuvos pramog pasaulio atstovas per kito garsaus pramog atstovo vestuves klaidingai
informavo policij apie uminuot pokylio viet. Teismas paskyr sumokti k tkstani lit baud. Kal-
tininkas baud sumokjo 1 cento monetomis. Kiek kilogram m monet buvo nuveta bank, jei viena
1 cento moneta sveria 0,83 gramo?
Pasitikrinkite. Kai k = 15000, turi bti spausdinama:
m = 1245 kg

26
2.3. Gros atidavimas
Atlikdami darb, isiaikinsite, kaip skaiiuojama sveikj skaii dalmes sveikji dalis ir dalmes
liekana:
imoksite tinkamai urayti sveikj skaii dalybos operacijas;
tvirtinsite kintamj apraymo, tinkamo pradini duomen vedimo ir rezultat pateikimo gdius.
Nuorodos C++ kalbos inyn Nuorodos algoritm inyn
3.1. Kintamasis, kintamojo reikm
3.2. Priskyrimo sakinys
3.4. Duomen vedimas klaviatra
3.5. Rezultat (duomen) ivedimas ekran
3.9. Knygoje naudojam ir / ar rekomenduo-
jam matematini funkcij sraas
4.1. Tiesiniai algoritmai
Uduotis
Parduotuvje pardavja gr g Lt (g sveikasis skaiius) pirkjui nori atiduoti 100, 50, 20, 10 Lt nominalo
banknotais ir 5, 2, 1 Lt nominalo monetomis j nominal majimo tvarka. Reikia apskaiiuoti, kiek kokio
nominalo banknot ir monet pardavja turs atiduoti pirkjui. Pavyzdiui, jei pardavja pirkjui turi atiduoti
g = 75 Lt gr, tai jai reiks vieno 50 Lt, vieno 20 Lt banknot ir 5 Lt monetos.
Algoritmas
Uduotis sprendiama taip:
Pirmiausia imamas didiausio nominalo banknotas (100 Lt), gra g dalijama i 100 ir imama sveikoji
dalmens dalis. Gautas rezultatas yra 100 Lt nominalo banknot skaiius k100.
Apskaiiuojama, kokia pinig suma liko neatiduota. Gra g dalijama i 100 ir imama dalmens liekana.
Tai yra nauja neatiduota gra g. Ji gali bti skaiiuojama ir kitaip: g = g k100 * 100.
Veiksmai kartojami su vis nominal banknotais ir monetomis.
1
Pasiruoimas
Atlikite veiksmus:
sukurkite katalog Darbas3 programos failams laikyti;
paleiskite CodeBlocks;
sukurkite programos fail;
suteikite programai vard Darbas3;
raykite fail katalog Darbas3 vardu Darbas3.cpp.
2
Kintamojo, skirto pradiniam duomeniui atmintyje laikyti, apraymas ir
jo reikms vedimas
Apraykite sveikojo tipo kintamj g, kuris reikia pirkjo gr litais.
Paraykite kintamojo g reikms vedimo klaviatra sakinius: praneimo, koki reikm vesti, sakin
(wcout) ir reikms skaitymo sakin (cin).

27
// Darbas3
#include <fcntl.h>
#include <io.h>
#include <iostream>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int g;
wcout << L"veskite pirkjo gr: "; cin >> g;
return 0;
}
raykite ir vykdykite program. Klaviatra veskite skaii 75 ir spustelkite klavi Enter. Ekrane
matysite:
veskite pirkjo gr: 75
3 Kintamj, skirt rezultatams, t. y. kiekvieno nominalo banknot ar monet
skaiiui, atmintyje laikyti, apraymas. Rezultat skaiiavimas ir ivedimas ekran
Papildykite program sveikojo tipo kintamaisiais k100, k50, k20, k10, k5, k2 ir k1, skirtais kiekvieno
nominalo banknot ar monet skaiiui atmintyje laikyti.
Uraykite priskyrimo sakin, skaiiuojant, kiek reiks 100 Lt nominalo banknot k100 grai ati-
duoti:
k100 = g / 100;
Uraykite priskyrimo sakin, skaiiuojant, kokia pinig suma g liks, atidavus k100 100 Lt banknot:
g = g % 100;
arba
g = g - k100 * 100;
Uraykite priskyrimo sakinius, skaiiuojanius 50, 20, 10, 5, 2 ir 1 Lt nominalo banknot ar monet
skaii.
// Darbas3
#include <fcntl.h>
#include <io.h>
#include <iostream>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int g;
int k100, k50, k20, k10, k5, k2, k1;
wcout << L"veskite pirkjo gr: "; cin >> g;
k100 = g / 100; g = g % 100;
k50 = g / 50; g = g % 50;
k20 = g / 20; g = g % 20;
k10 = g / 10; g = g % 10;
k5 = g / 5; g = g % 5;
k2 = g / 2; g = g % 2;
k1 = g;
return 0;
}

28
Programos pabaigoje prie sakin return 0; paraykite rezultat ivedimo ekran sakinius:
wcout << L"Pardavja gr atiduos taip:" << endl;
wcout << L"-----------------------------" << endl;
wcout << L"100 Lt ------> " << k100 << endl;
wcout << L" 50 Lt ------> " << k50 << endl;
wcout << L" 20 Lt ------> " << k20 << endl;
wcout << L" 10 Lt ------> " << k10 << endl;
wcout << L" 5 Lt ------> " << k5 << endl;
wcout << L" 2 Lt ------> " << k2 << endl;
wcout << L" 1 Lt ------> " << k1 << endl;
wcout << L"-----------------------------" << endl;
raykite ir vykdykite program. Klaviatra veskite skaii 75 ir spustelkite klavi Enter. Ekrane
turtumte matyti:
veskite pirkjo gr: 75
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. Nuo met pradios prajo d dien. Paraykite program, kuri apskaiiuot, kiek savaii s prajo nuo met
pradios.
Pasitikrinkite. Kai d = 15, turi bti spausdinama: Nuo met pradios prajo s = 2 savaits.
2. Miesto informatikos olimpiadoje dalyvavo n devintok. Mokytoja nupirko m saldaini Nomeda (m n)
ir idalijo mokiniams po lygiai. 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.
3. Andrius septintojo gimtadienio proga gavo n balion. Su draugais nusprend balionus paleisti dang. Da-
lis puiam balion k sprogo. Likusius balionus Andrius pasidalijo su d draugais po lygiai. Jeigu po dalyb
dar liko balion, tai juos pasim Andrius. Po kiek balion m gavo kiekvienas draugas ir kiek balion a teko
Andriui? Paraykite program iam udaviniui sprsti.
Pasitikrinkite. Kai n = 77, d = 7 ir k = 3, tai kiekvienas draugas gavo po m = 9 balionus, o Andriui teko
a = 11 balion.
4. Lktuvas pakilo i oro uosto, 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. Jei a = 23, b = 55, c = 14, tai lktuvas leisis, kai bus v = 0 valand ir m = 9 minuts.
5. Nubrauktas trienklio skaiiaus x antrasis skaitmuo. Prie likusio dvienklio skaiiaus i kairs priraius
nubrauktj skaitmen, 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.

29
SMALSIEMS
Nuorodos C++ kalbos inyn
3.5. Rezultat (duomen) ivedimas ekran
3.12. Funkcijos
3.13. Knygoje naudojam terpiam fail sraas
Norint sutrumpinti sukurt gros skaiiavimo program, reikt:
kartojamus veiksmus (banknot, monet kiekio ir neatiduotos gros likuio skaiiavimo, kiekvieno no-
minalo banknot ir monet kiekio spausdinimo) kelti savarankik programos dal, t. y. funkcij;
i funkcijos main() funkcij kreiptis esant skirtingiems pinig nominalams;
programos pradioje parayti funkcijos prototip;
funkcijos tekst parayti programos gale. Labai patogu funkcij nuo pagrindins funkcijos main()
atskirti komentaru, pavyzdiui, brkneli ar vaigdui eilute.
Paraykite funkcij Graza. Jos antratje skliaustuose nurodykite du sveikojo tipo kintamuosius: k
kokio nominalo banknot ar monet skaiius skaiiuojamas, g kokia gra dar liko neatiduota.
Apraant kintamuosius funkcijos antratje, btina nurodyti j tip. Kintamasis g raomas su enklu &,
nes funkcij main() turi bti grinama apskaiiuota jo reikm. Kintamasis k apraomas be enklo &,
nes jo reikms i funkcijos funkcij main() grinti nereikia.
Funkcijos viduje paraykite priskyrimo sakinius kx ir g reikmms skaiiuoti ir sakin, skirt k nomi-
nalo banknot ar monet skaiiui ivesti.
// Funkcija, skaiiuojanti pirkjo gr g, kai nominalas k
// ekran ivedama nominalo reikm ir to nominalo banknot skaiius
void Graza(int k, int & g)
{
int kx;
kx = g / k; g = g % k;
wcout << setw(3) << k << L" Lt ------>" << kx << endl;
};
Programos pradioje terpkite fail iomanip, kuriame yra duomen ivedimo fail srautus (ekranas,
failas) priemons.
Programos pradioje paraykite funkcijos prototip:
// Darbas3
#include <fcntl.h>
#include <io.h>
#include <iostream>
#include <iomanip>
using namespace std;
//--------------------------------------------
void Graza(int k, int & g); // funkcijos prototipas
//--------------------------------------------
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
Apraykite funkcijos main () kintamuosius:

int g;
int k100, k50, k20, k10, k5, k2, k1;

30
Funkcijoje main() paraykite pradini duomen vedimo sakinius ir du pirmuosius rezultat ivedi-
mo sakinius:

wcout << L"veskite pirkjo gr: "; cin >> g;
wcout << L"Pardavja gr atiduos taip:" << endl;
wcout << L"-----------------------------" << endl;
Nurodykite kreipin funkcij Graza:
Graza(100, g);
Toliau nurodykite likusius kreipinius funkcij Graza:
Graza(50, g);
Graza(20, g);
Graza(10, g);
Graza(5, g);
Graza(2, g);
Graza(1, g);
Lentelje parodyta, kaip keiiasi kintamj reikms.
Kreipinys funkcij Banknot ar monet
nominalo reikm
funkcij perduodama
neatiduotos gros g
reikm
funkcij main() grinama
nauja neatiduotos gros g
reikm
Graza(100, g); 100 g = 75 g = 75
Graza(50, g); 50 g = 75 g = 25
Graza(20, g); 20 g = 25 g = 5
Graza(10, g); 10 g = 5 g = 5
Graza(5, g); 5 g = 5 g = 0
Graza(2, g); 2 g = 0 g = 0
Graza(1, g); 1 g = 0 g = 0
Paraykite paskutin raymo sakin:

wcout << L"-----------------------------" << endl;

31
Pasitikrinkite, ar teisingai sukrte program:
// Darbas3
#include <fcntl.h>
#include <io.h>
#include <iostream>
#include <iomanip>
using namespace std;
//--------------------------------------------
void Graza(int k, int & g); // funkcijos prototipas
//--------------------------------------------
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int g;
int k100, k50, k20, k10, k5, k2, k1;
wcout << L"veskite pirkjo gr: "; cin >> g;
wcout << L"Pardavja gr atiduos taip:" << endl;
wcout << L"-----------------------------" << endl;
Graza(100, g);
Graza(50, g);
Graza(20, g);
Graza(10, g);
Graza(5, g);
Graza(2, g);
Graza(1, g);
wcout << L"-----------------------------" << endl;
return 0;
}
//--------------------------------------------
// Funkcija, skaiiuojanti pirkjo gr g, kai nominalas k
// ekran ivedama nominalo reikm ir to nominalo banknot skaiius
void Graza(int k, int & g)
{
int kx;
kx = g / k; g = g % k;
wcout << setw(3) << k << L" Lt ------>" << kx << endl;
}
//--------------------------------------------
raykite ir vykdykite program. veskite skaii 75. Ekrane matysite:
veskite pirkjo gr: 75
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
-----------------------------
Tikriausiai pastebjote, kad naudojant funkcij programa tapo paprastesn: nebereikia kartoti t pai sakini
po kelis kartus, daug lengviau galima rasti ir itaisyti klaidas.
Savarankikos programos dalys palengvina udavini sprendim, leidia iskaidyti udavin dalimis. Be to,
atskiras dalis gali kurti ne vienas mogus.

32
2.4. Kvadratins lygties sprendini skaiiavimas
Atlikdami darb, imoksite tinkamai urayti slygin sakin.
Nuorodos C++ kalbos inyn Nuorodos algoritm inyn
3.4. Duomen vedimas klaviatra
3.5. Rezultat (duomen) ivedimas ekran
3.8. Slyginis sakinys if
3.9. Knygoje naudojam ir / ar rekomenduo-
jam matematini funkcij sraas
4.1. Tiesiniai algoritmai
4.3. akotieji skaiiavimai
Uduotis
Reikia rasti kvadratins lygties ax
2
+ bx + c = 0 sprendinius; ia a, b, c sveikieji skaiiai, nelygs nuliui.
Algoritmas
Kvadratins lygtys sprendiamos taip:
Skaiiuojamas diskriminantas d = b
2
4ac.
Tikrinama, ar lygtis turi sprendini:
jei d < 0, kvadratin lygtis neturi reali sprendini;
jei d = 0, tuomet kvadratin lygtis turi vien sprendin
a
b
x
2

= ;
jei d > 0, tuomet kvadratin lygtis turi du sprendinius:
a
d b
x
2
1

= ir
a
d b
x
2
2
+
= .
1
Pasiruoimas
Sukurkite katalog Darbas4, skirt programos failams laikyti. Paleiskite CodeBlocks. Sukurkite progra-
mos fail Darbas4.cpp, raykite j katalog Darbas4. Suteikite programai vard Darbas4.
2
Pradini duomen vedimas klaviatra
Pradiniai duomenys: a, b, c kvadratins lygties koefcientai.
Programos pradioje terpkite fail iomanip, kuriame yra duomen ivedimo fail srautus (ekranas,
failas) priemons ir fail cmath, kuriame yra matematini funkcij rinkinys.
Paraykite sakinius pradinms kintamj a, b, c reikmms vesti klaviatra:

// Darbas4
#include <fcntl.h>
#include <io.h>
#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int a, b, c; // lygties koefcientai
double d; // diskriminantas
double x1, x2; // lygties aknys
wcout << L"veskite kvadratins lygties koefcientus a, b ir c: ";
cin >> a >> b >> c;
wcout << L"a = " << a << L" b = " << b << L" c = " << c << endl;
return 0;
}

33
raykite program. J vykdykite, pasirink tokias koefcient reikmes: a = 2, b = 4, c = 1. Ekrane
turtumte matyti:
veskite kvadratins lygties koefcientus a, b ir c: 2 4 1
a = 2 b = 4 c = 1
Kvadratins lygties sprendimas ir sprendini pateikimas ekrane
Papildykite program sakiniais, kurie skirti diskriminantui skaiiuoti, kvadratins lygties sprendiniams
rasti ir jiems ivesti ekran.

// Skaiiavimai ir rezultat ivedimas
d = b * b - 4 * a * c;
if (d < 0) wcout << L"Lygtis neturi reali sprendini" << endl;
else if (d == 0) {
x1 = -b / (2 * a);
wcout << L"Lygtis turi vien sprendin: x = " << x1 << endl;
}
else {
x1 = (-b - sqrt(d)) / (2 * a);
x2 = (-b + sqrt(d)) / (2 * a);
wcout << L"Lygtis turi du sprendinius: x1 = "
<< setw(6) << fxed << setprecision(2) << x1 << L" ir x2 = "
<< setw(6) << fxed << setprecision(2) << x2 << endl;
}
raykite ir vykdykite program, kai koefcient reikms yra tokios: a = 2, b = 4, c = 1. Ekrane
turtumte matyti:

veskite kvadratins lygties koefcientus a, b ir c: 2 4 1
a = 2 b = 4 c = 1
Lygtis turi du sprendinius: x1 = 1.71 ir x2 = -0.29
4
Programos darbo tikrinimas, esant vairiems pradini duomen rinkiniams
Isprskite kvadratines lygtis:
x
2
+ 14x + 49 = 0;
x
2
+ 12x + 36 = 0;
x
2
8x 9 = 0;
x
2
6x + 8 = 0;
x
2
3x + 2 = 0;
x
2
5x + 6 = 0;
x
2
x + 2 = 0;
x
2
+ 4x + 1 = 0;
5x
2
+ 9x 2 = 0.

3
34
Klausimai
1. Kokios bus sveikojo tipo kintamj x ir y reikms atlikus sakini sek?

a) x = 5;
if (x > 4) y = x + 3;
else y = x - 3;
b) x = 3;
if (x != 3) y = x + 3;
x = x + 2;
y = x + 2;
c) x = 6;
if (x <= 8) {
x = x + 2;
y = x + 3;
}
else y = x - 3;
d) x = 2;
if (x < 0) y = x - 3;
else {
x = x + 2;
y = x + 3;
}
e) x = 1;
if (x > 0) {
y = x - 3;
x = x + 2;
}
else {
x = x + 2;
y = x + 3;
}
f) x = 1;
if (x == 0) {
y = x - 3;
x = x + 2;
}
else {
x = x + 2;
y = x + 3;
}
2. Funkcijos reikmms skaiiuoti uraytas slyginis sakinys:
a) if (x < 5) y = x + 3;
else y = x - 2;
b) y = 9;
if (x != 5);
else y = 5 * x + 3;
wcout << y << endl;

Kokia bus y reikm, kai x reikm lygi: a) 2? b) 5? c) 7?
Uduotys
1. Pakeiskite program Darbas4, kad ji sprst kvadratines lygtis su realiojo tipo koefcientais.
Pasitikrinkite. Kai a = 3.05, b = 2.15 ir c = 7.5, tai lygties sprendiniai yra: x1 = 1.25, x2 = 1.96.
2. Pirmosios olimpins aidyns vyko 1896 metais ir toliau organizuojamos kas ketveri metai. Jei aidyns
nevyksta, tie metai vis tiek laikomi olimpiniais, o aidynms skiriamas eils numeris. Paraykite progra-
m, kuri surast m-j met olimpini aidyni numer n. Jei metai neolimpiniai, turi bti spausdinama
Metai neolimpiniai.
Pasitikrinkite. Kai m = 1904, turi bti spausdinama: n = 3. Kai m = 2005, turi bti spausdinama:
Metai neolimpiniai.
3. kininkas nusprend virve paymti staiakamp plot, kuriame sodins ankstyvsias bulves. Virvs ilgis
lygus m metr (sveikasis skaiius). Kok didiausi plot s gals paymti kininkas? Rezultat pateikite
sveikuoju skaiiumi (gali likti nepanaudotas virvs galas).
Pasitikrinkite. Kai m = 22, turi bti spausdinama: s = 30. Kai m = 21, turi bti spausdinama: s = 25.
4. viesoforas veikia pagal tok algoritm: kiekvienos valandos pirmsias 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 viesa dega.
Pasitikrinkite. Kai t = 12, turi bti spausdinama: Dega alia viesa. Kai t = 13, turi bti spausdi-
nama: Dega alia viesa, tuoj usidegs raudona. Kai t = 5, turi bti spausdinama:
Dega raudona viesa, tuoj usidegs alia.
35
5. Geleinkelio stotys A, B ir C yra n-ajame, m-ajame ir p-ajame geleinkelio ruoo kilometruose. Paraykite
program, kuri surast, tarp kuri stoi atstumas yra maiausias. Stotys nebtinai vardytos abcls tvar-
ka, 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 A ir B bei B ir C stoi.
Kai n = 3, m = 15, p = 9, turi bti spausdinama:
Atstumai maiausi tarp A ir C bei B ir C stoi.
6. 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 115 dienomis ia vyksta varybos. Kurorte
C slidininkai laukiami nuo lapkriio pradios iki gegus pabaigos. Poilsio kaina kiekviename kurorte,
traukus 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. 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 kurorte C. Jam reiks 499 Lt.
7. Remdamiesi funkcij grafkais, uraykite, kaip skaiiuojamos tiesini funkcij reikms (1 langelis
atitinka 1 vienet).
y
x
b) y
x
a)

36
2.5. Elektros laidinink 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;
isiaikinsite, kaip skaiiuojama suma;
imoksite tinkamai pateikti apskaiiuot realiojo tipo rezultat.

Nuorodos C++ kalbos inyn Nuorodos algoritm inyn
3.1. Kintamasis, kintamojo reikm
3.2. Priskyrimo sakinys
3.4. Duomen vedimas klaviatra
3.5. Rezultat (duomen) ivedimas ekran
3.7. Ciklo sakinys for
4.1. Tiesiniai algoritmai
4.2. Cikliniai algoritmai
4.4. Sumos skaiiavimo algoritmas
Uduotis
Elektros grandin sudaro n nuosekliai sujungt laidinink, kuri varos yra r1, r2, ..., rn om. Reikia apskai-
iuoti grandins var r.
Algoritmas
Tarkime, kad elektros grandin sudaro n = 4 nuosekliai sujungti laidininkai, kuri varos yra r1 = 2, r2 = 4,
r3 = 1,5, r4 = 4. Bendroji grandins vara skaiiuojama sumuojant vis laidinink varas.
inant laidinink skaii n ir kiekvieno laidininko var rlaid, grandins var r galima rasti pagal algoritm,
kurio veiksmai kartojami n kart:
vedama laidininko vara rlaid;
skaiiuojama grandins vara r = r + rlaid.
Prie pradedant vykdyti veiksmus, btina inoti n reikm, o kintamojo r pradin reikm turi bti lygi nuliui.
Lentelje pavaizduota, kaip atliekami veiksmai.
Ciklas
vykdomas
i-j kart
vedama i-ojo
laidininko
vara
Skaiiuojama grandins
vara r = r + rlaid
Iliustracija
1 2 r = 0 + 2 = 2
2 4 r = 2 + 4 = 6
3 1,5 r = 6 + 1,5 = 7,5
4 4 r = 7,5 + 4 = 11,5
Skaiiavim rezultatas: r = 11,5.

37
1
Pasiruoimas
Sukurkite katalog Darbas5, skirt programos failams laikyti. Paleiskite CodeBlocks. Sukurkite progra-
mos fail ir, suteik programai vard Darbas5, raykite fail vardu Darbas5.cpp katalog Darbas5.
2
Programos pradini duomen apraymas ir vedimas
Programos pradioje apraykite naudojamus kintamuosius (laidinink skaii n, laidininko var
rlaid, grandins var r, inomo kartojim skaiiaus ciklo kintamj i).
Paraykite kintamojo n reikms vedimo klaviatra sakinius: praneimo, koki reikm vesti, sakin
(wcout) ir reikms skaitymo sakin (cin).

// Darbas5
#include <fcntl.h>
#include <io.h>
#include <iostream>
#include <iomanip>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int n; // laidinink skaiius
double rlaid; // laidininko vara
double r; // elektros grandins vara
int i; // inomo kartojim skaiiaus ciklo kintamasis
wcout << L"Kiek laidinink yra elektros grandinje? "; cin >> n;
return 0;
}
3
Pradins kintamojo r reikms apraymas ir rezultato ivedimas ekran
Papildykite program priskyrimo sakiniu, skirtu kintamojo r pradinei reikmei aprayti.
Papildykite program sakiniu, skirtu r reikmei ivesti.

// Darbas5
#include <fcntl.h>
#include <io.h>
#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int n; // laidinink skaiius
double rlaid; // laidininko vara
double r; // elektros grandins vara
int i; // inomo kartojim skaiiaus ciklo kintamasis
wcout << L"Kiek laidinink yra elektros grandinje? "; cin >> n;
r = 0;
wcout << L"Elektros grandins vara: "
<< setw(6) << fxed << setprecision(2) << r << endl;
return 0;
}
Sakinyje
wcout << L"Elektros grandins vara: "
<< setw(6) << fxed << setprecision(2) << r << endl;

38
nurodoma, kad apskaiiuotai elektros grandins varos reikmei r ivesti ekran skiriamos 6 pozici-
jos, i kuri 2 trupmeninei daliai. Manipuliatorius fxed rodo, kad trupmenin dalis visuomet turi
bti i dviej skaitmen. Takui, kuris atskiria trupmenin dal nuo sveikosios, taip pat skiriama viena
pozicija.
raykite ir vykdykite program. Klaviatra veskite skaii 4 ir spustelkite klavi Enter. Ekrane ma-
tysite:

Kiek laidinink yra elektros grandinje? 4
Elektros grandins vara: 0.00

4
Ciklo sakinio antrat. Veiksmai cikle
Ciklo sakinyje atliekami keli veiksmai, todl jie turi bti raomi tarp skliaust { ir }.
Po kintamojo r pradins reikms apraymo uraykite ciklo sakin:

for (i = 1; i <= n; i = i + 1) {
wcout << L"veskite laidininko var: "; cin >> rlaid;
r = r + rlaid;
}
Papildyta programa bus tokia:

// Darbas5
#include <fcntl.h>
#include <io.h>
#include <iostream>
#include <iomanip>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int n; // laidinink skaiius
double rlaid; // laidininko vara
double r; // elektros grandins vara
int i; // inomo kartojim skaiiaus ciklo kintamasis
wcout << L"Kiek laidinink yra elektros grandinje? "; cin >> n;
r = 0;
for (i = 1; i <= n; i = i + 1) {
wcout << L"veskite laidininko var: "; cin >> rlaid;
r = r + rlaid;
}
wcout << L"Elektros grandins vara: "
<< setw(6) << fxed << setprecision(2) << r << endl;
return 0;
}
raykite ir vykdykite program. Klaviatra veskite skaii 4 ir spustelkite klavi Enter. Ekrane ma-
tysite:

Kiek laidinink yra elektros grandinje? 4
veskite laidininko var
I eils veskite laidinink varas: 2, 4, 1.5, 4. Po kiekvienos j spustelkite klavi Enter. Ekrane ma-
tysite:

39

Kiek laidinink yra elektros grandinje? 4
veskite laidininko var 2
veskite laidininko var 4
veskite laidininko var 1.5
veskite laidininko var 4
Elektros grandins vara: 11.50
Uduotys
1. Elektros grandin sudaro n lygiagreiai sujungt laidinink, kuri varos yra r1, r2, ..., rn om. Paraykite
program, kuri apskaiiuot 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. J giai atitinkamai yra u1, u2, ..., un centimetr. Paraykite program, kuri
apskaiiuot 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 mokini gis uvid = 178.20 cm.
3. Keliamieji metai turi 366 dienas, paprastieji 365. Keliamaisiais vadinami metai, kurie be liekanos dalijasi
i 4. imtmei metai keliamaisiais laikomi tuomet, kai jie be liekanos dalijasi i 400. Paraykite program,
kuri ekrane parodyt keliamuosius metus laikotarpio, kuris prasideda m-aisiais, o baigiasi n-aisiais metais.
Pasitikrinkite. Kai m = 1898, o n = 1910, turi bti spausdinama:
Keliamieji metai yra 1904, 1908.
4. achmat iradjas i valdovo papra tokio atlygio: ant pirmo achmat lentos langelio padti vien grd,
ant antrojo du, ant treiojo keturis ir t. t., vis dvigubinant, 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. Rezultato reikmei atmintyje laikyti panaudokite double duomen
tip.
Pasitikrinkite. Ekrane turi bti spausdinama:
achmat iradjas gaus 18446744073709550000 grd.
5. Autobus parko administracija nusprend keleiviams, kuri biliet numeriai laimingi, dovanoti kelion u
pus kainos. Autobuso bilietas laikomas laimingu, jei jo pirmj trij skaitmen trejetas sutampa su pasku-
tini trij skaitmen trejetu (pvz., laimingas bilietas, kurio numeris yra 234234). Autobus parko adminis-
tracija nutar bilietus sunumeruoti nuo m-ojo iki n-ojo eiaenklio skaiiaus. Paraykite program, kuri
apskaiiuot, kiek keleivi k sigis laimingus bilietus.
Pasitikrinkite. Kai m = 170849, o n = 189965, turi bti spausdinama:
Laimingus bilietus sigijo k = 19 keleivi.
6. Architektas suprojektavo sal, kurioje bus n eili. Pirmoje eilje stovs k kdi, o kiekvienoje kitoje eil-
je 2 kdmis daugiau, negu prie tai buvusioje. Paraykite program, kuri apskaiiuot, kiek i viso kdi
(s) reikia usakyti, kad architekto sumanymas bt gyvendintas.
Pasitikrinkite. Kai n = 3, o k = 8, turi bti spausdinama: s = 30 kdi.
SMALSIEMS
Nuorodos C++ kalbos inyn
3.10. Duomen vedimas i failo
Jei pradini duomen yra labai daug, tai j vedimas klaviatra reikalauja nemaai laiko, juolab kad padarius
klaid tenka duomenis vesti i naujo. Daug patogiau pradinius duomenis vesti i tekstinio failo. Papildysime
elektros grandins varos skaiiavimo program duomenis vesime i tekstinio failo.
40
Tekstinis failas sukuriamas komandomis: File New Empty fle. 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.5 4. Ekrane turtumte matyti:

4
2 4 1.5 4
Sukurt fail pavadinkite Darbas5.txt ir raykite katalog Darbas5.
Pakeiskite sukurt program Darbas5.cpp:

// Darbas5
#include <fcntl.h>
#include <io.h>
#include <iostream>
#include <iomanip>
#include <fstream>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int n; // laidinink skaiius
double rlaid; // laidininko vara
double r; // elektros grandins vara
int i; // inomo kartojim skaiiaus ciklo kintamasis
ifstream fd("Darbas5.txt"); // paruoiamas failas duomen skaitymui
fd >> n; // vedama pirmoje failo eilutje esanti skaiiaus n reikm
r = 0;
// vedami kiti skaiiai. Skaityti baigiama, kai vedama n reikmi
for (i = 1; i <= n; i = i + 1) {
fd >> rlaid;
r = r + rlaid;
}
fd.close(); // duomen failas uveriamas
wcout << L"Elektros grandins vara: "
<< setw(6) << fxed << setprecision(2) <<r << endl;
return 0;
}
raykite ir vykdykite program. Ekrane matysite:

Elektros grandins vara: 11.50
Kaip pastebjote, duomenys i failo vedami panaiai kaip ir klaviatra. Tik 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.5
4

41
2.6. Siena
Atlikdami darb, isiaikinsite, kaip kuriama ciklinius skaiiavimus atliekanti programa, i anksto neinant,
kiek kart reiks kartoti veiksmus:
imoksite urayti neinomo kartojim skaiiaus ciklo antrat;
isiaikinsite, kaip uraomi cikle atliekami veiksmai;
prisiminsite, kaip skaiiuojama suma;
suprasite, kaip skaiiuojamas kiekis;
imoksite skaiiavim rezultatus pateikti lentele.
Nuorodos C++ kalbos inyn Nuorodos algoritm inyn
3.1. Kintamasis, kintamojo reikm
3.2. Priskyrimo sakinys
3.4. Duomen vedimas klaviatra
3.5. Rezultat (duomen) ivedimas ekran
3.6. Ciklo sakinys while
4.1. Tiesiniai algoritmai
4.2. Cikliniai algoritmai
4.4. Sumos skaiiavimo algoritmas
4.6. Kiekio skaiiavimo algoritmas
Uduotis
I plyt galima pastatyti vienos plytos storio taisykling sien, kurios virnje yra viena plyta, o onuose pu-
ss plytos ilgio laipteliai. Reikia parayti program, kuri apskaiiuot, keli plyt a bus sienos pagrindas ir keli
plyt aukio k bus siena, jei inomas sienos statybai skirt plyt skaiius p.
Algoritmas
Paveiksle pavaizduotos sienos pagrind a sudaro 4 plytos, sienos auktis k = 4 plytos, sienai pastatyti reikjo
p = 10 plyt.
k
p = 10
a
inome bendr plyt skaii p, o a ir k reikmes turime apskaiiuoti. Sienai pastatyti panaudot plyt skaii
paprasiau skaiiuoti i viraus apai.
Skaiiavimai kartojami, kol statyboms panaudot plyt skaiius s maesnis u statyboms skirt plyt skai-
i p:
Plyt skaiius eilje a gaunamas didinant buvusi a reikm vienetu, nes kiekvienoje naujoje eilje yra
viena plyta daugiau negu prie tai buvusioje.
Sienos aukio k reikm gaunama didinant buvusi k reikm vienetu, nes pradedamas skaiiuoti
plyt skaiius naujoje eilje.
Sienos statybai panaudot plyt skaiius s gaunamas prie jau buvusios s reikms pridedant naujos
eils plyt skaii a.

42
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.
Eil Ar statyboms
panaudot plyt
skaiius maesnis
u sienai skirt
plyt skaii
Plyt skaiius
eilje a
Sienos auktis k Statyboms panaudot plyt skaiius s
Ciklo
ingsniai
Slyga: s < p a = a + 1 k = k + 1 s = s + a Paveikslas
1 0 < 10 TAIP a = 0 + 1 = 1 k = 0 + 1 = 1 s = 0 + 1 = 1
2 1 < 10 TAIP a = 1 + 1 = 2 k = 1 + 1 = 2 s = 1 + 2 = 3
3 3 < 10 TAIP a = 2 + 1 = 3 k = 2 + 1 = 3 s = 3 + 3 = 6
4 6 < 10 TAIP a = 3 + 1 = 4 k = 3 + 1 = 4 s = 6 + 4 = 10
5 10 < 10 NE Veiksmai neatliekami, nes netenkinama slyga s < p
1
Pasiruoimas
Sukurkite katalog Darbas6, skirt programos failams laikyti, paleiskite CodeBlocks, sukurkite progra-
mos fail ir, suteik programai vard Darbas6, raykite fail vardu Darbas6.cpp katalog Darbas6.
2
Programos pradini duomen apraymas ir vedimas
Programos pradioje apraykite naudojamus kintamuosius (sienai statyti skirt plyt skaii p,
sienos pagrindo ilg a, sienos aukt k, sienos statybai panaudot plyt skaii s).
Paraykite kintamojo p reikms vedimo klaviatra sakinius: praneimo, koki reikm vesti, sakin
(wcout) ir reikms skaitymo sakin (cin).

// Darbas6
#include <fcntl.h>
#include <io.h>
#include <iostream>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int p, // sienos statybai skirt plyt skaiius
s, // sienos statybai panaudot plyt skaiius
a, // sienos pagrindo ilgis
k; // sienos auktis
wcout << L"Kiek plyt skirta sienos statybai? "; cin >> p;
return 0;
}
raykite ir vykdykite program. Klaviatra veskite skaii 10 ir spustelkite klavi Enter. Ekrane
matysite:

Kiek plyt skirta sienos statybai? 10

43
3
Pradini reikmi kintamiesiems a, k ir s priskyrimas ir j ivedimas ekran
Papildykite program trimis priskyrimo sakiniais:
a = 0; k = 0; s = 0;
ir sakiniais, skirtais kintamj a, k ir s reikmms ivesti ekran:

// Darbas6
#include <fcntl.h>
#include <io.h>
#include <iostream>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int p, // sienos statybai skirt plyt skaiius
s, // sienos statybai panaudot plyt skaiius
a, // sienos pagrindo ilgis
k; // sienos auktis
wcout << L"Kiek plyt skirta sienos statybai? "; cin >> p;
a = 0; k = 0; s = 0;
wcout << L"Sienos pagrindo ilgis: " << a << endl;
wcout << L"Sienos auktis: " << k << endl;
wcout << L"Sienos statybai panaudot plyt skaiius: " << s << endl;
return 0;
}
raykite ir vykdykite program. Klaviatra veskite skaii 10 ir spustelkite klavi Enter. Ekrane
matysite:

Kiek plyt skirta sienos statybai? 10
Sienos pagrindo ilgis: 0
Sienos auktis: 0
Sienos statybai panaudot plyt skaiius: 0
4
Ciklo sakinio antrat. Veiksmai cikle
Cikle atliekami keli veiksmai, todl ciklo sakinyje jie turi bti raomi tarp skliaust { ir }.
Priskyr kintamiesiems a, k ir s pradines reikmes, uraykite ciklo sakin:

while (s < p) {
a = a + 1;
k = k + 1;
s = s + a;
}

44
Papildyta programa bus tokia:

// Darbas6
#include <fcntl.h>
#include <io.h>
#include <iostream>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int p, // sienos statybai skirt plyt skaiius
s, // sienos statybai panaudot plyt skaiius
a, // sienos pagrindo ilgis
k; // sienos auktis
wcout << L"Kiek plyt skirta sienos statybai? "; cin >> p;
a = 0; k = 0; s = 0;
while (s < p) {
a = a + 1;
k = k + 1;
s = s + a;
}
wcout << L"Sienos pagrindo ilgis: " << a << endl;
wcout << L"Sienos auktis: " << k << endl;
wcout << L"Sienos statybai panaudot plyt skaiius: " << s << endl;
return 0;
}
raykite ir vykdykite program. Klaviatra veskite skaii 10 ir spustelkite klavi Enter. Ekrane
matysite:

Kiek plyt skirta sienos statybai? 10
Sienos pagrindo ilgis: 4
Sienos auktis: 4
Sienos statybai panaudot plyt skaiius: 10
5
Skaiiavim tarpini rezultat ivedimas
Nordami sitikinti, kad programa skaiiuoja teisingai, galite ivesti ne tik galutinius, bet ir tarpinius rezulta-
tus.
Sudtin sakin, nurodant, kokie veiksmai bus atliekami ciklo viduje, papildykite kintamj a, k ir s
reikmi ivedimo sakiniais ir sakiniu, atskirianiu vien skaiiavim nuo kito vaigdutmis.

while (s < p) {
a = a + 1;
k = k + 1;
s = s + a;
wcout << L"a = " << a << endl;
wcout << L"k = " << k << endl;
wcout << L"s = " << s << endl;
wcout << L"**********" << endl;
}

45
raykite ir vykdykite program. Klaviatra veskite skaii 10 ir spustelkite klavi Enter. Ekrane
matysite:

Kiek plyt skirta sienos statybai? 10
a = 1
k = 1
s = 1
**********
a = 2
k = 2
s = 3
**********
a = 3
k = 3
s = 6
**********
a = 4
k = 4
s = 10
**********
Sienos pagrindo ilgis: 4
Sienos auktis: 4
Sienos statybai panaudot plyt skaiius: 10
6
Skaiiavim rezultat pateikimas lentele
Nordami programos skaiiavim rezultatus pateikti lentele, program papildykite:
Sakiniais, apibrianiais programos paskirt:

wcout << L"Programa, skaiiuojanti sienos pagrindo ilg, aukt" << endl;
wcout << L" ir statybai panaudot plyt skaii" << endl;
wcout << L" " << endl;
Sakiniais, formuojaniais antratin lentels eilut:

wcout << L"--------------------------------------------------" << endl;
wcout << L"Pagrindo ilgis Auktis Panaudot plyt skaiius" << endl;
wcout << L"--------------------------------------------------" << endl;
Sakiniu, ivedaniu ciklo viduje apskaiiuotas kintamj a, k ir s reikmes:

wcout << L" " << a << L" " << k << L" " << s << endl;
Sakiniu, formuojaniu paskutin lentels eilut:
wcout << L"--------------------------------------------------" << endl;

46
Papildyta programa bus tokia:

// Darbas6
#include <fcntl.h>
#include <io.h>
#include <iostream>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int p, // sienos statybai skirt plyt skaiius
s, // sienos statybai panaudot plyt skaiius
a, // sienos pagrindo ilgis
k; // sienos auktis
wcout << L"Programa, skaiiuojanti sienos pagrindo ilg, aukt" << endl;
wcout << L" ir statybai panaudot plyt skaii" << endl;
wcout << L" " << endl;
wcout << L"Kiek plyt skirta sienos statybai? "; cin >> p;
a = 0; k = 0; s = 0;
wcout << L"--------------------------------------------------" << endl;
wcout << L"Pagrindo ilgis Auktis Panaudot plyt skaiius" << endl;
wcout << L"--------------------------------------------------" << endl;
while (s < p) {
a = a + 1;
k = k + 1;
s = s + a;
wcout << L" " << a << L" " << k << L" " << s
<< endl;
}
wcout << L"--------------------------------------------------" << endl;
wcout << L"Sienos pagrindo ilgis: " << a << endl;
wcout << L"Sienos auktis: " << k << endl;
wcout << L"Sienos statybai panaudot plyt skaiius: " << s << endl;
return 0;
}
raykite ir vykdykite program. Klaviatra veskite skaii 10 ir spustelkite klavi Enter. Ekrane
matysite:

Programa, skaiiuojanti sienos pagrindo ilg, aukt
ir statybai panaudot plyt skaii
Kiek plyt skirta sienos statybai? 10
--------------------------------------------------
Pagrindo ilgis Auktis Panaudot plyt skaiius
--------------------------------------------------
1 1 1
2 2 3
3 3 6
4 4 10
--------------------------------------------------
Sienos pagrindo ilgis: 4
Sienos auktis: 4
Sienos statybai panaudot plyt skaiius: 10
7
Tikrinimas, ar programa visada pateikia teisingus rezultatus
Vykdydami program, veskite p reikm, lygi 8. vykd program, gausite t pat rezultat, kaip ir
ved p reikm, lygi 10. Rezultatas yra neteisingas, nes sienos statybai panaudota daugiau plyt, negu
skirta.
Ivada. Reikia tikrinti, ar likusi plyt uteks naujai eilei.

47
Ciklo antratje slyg s < p pakeiskite slyga a + 1 <= p - s ir vykdykite program esant p
reikmei, lygiai 8. Ekrane turtumte matyti:

Programa, skaiiuojanti sienos pagrindo ilg, aukt
ir statybai panaudot plyt skaii
Kiek plyt skirta sienos statybai? 8
--------------------------------------------------
Pagrindo ilgis Auktis Panaudot plyt skaiius
--------------------------------------------------
1 1 1
2 2 3
3 3 6
--------------------------------------------------
Sienos pagrindo ilgis: 3
Sienos auktis: 3
Sienos statybai panaudot plyt skaiius: 6
Patikslinus ciklo antrats slyg, programa pateikia teisingus rezultatus esant visoms kintamojo p reikmms.
Papildykite program skaiiavimais, kiek liko nepanaudot plyt.
raykite ir vykdykite program. Klaviatra veskite skaii 8 ir spustelkite klavi Enter. Ekrane tu-
rtumte matyti:

Nepanaudot plyt skaiius: 2
Klausimai
Kaip vykdomas ciklo sakinys while?
Kaip urayti ciklo sakin, kai norima atlikti daugiau veiksm?
K daryti, kad ciklas nebt begalinis?
Kurie i nurodyt ciklo sakini, kai a = -3, yra begaliniai ir kodl?
a) while (a < 0){
wcout << L"argumentas neigiamas" << endl;
a = a + 1;
}
b) while (a < 0);{
wcout << L"argumentas neigiamas" << endl;
a = a + 1;
}
c) while (a < 0)
wcout << L"argumentas neigiamas" << endl;
a = a + 1;
d) while (a >= 0)
wcout << L"argumentas neigiamas" << endl;
a = a + 1;

1.
2.
3.
4.
48
Uduotys
Martynas labai mgsta saldainius. Mamos slptuvje berniukas rado m saldaini. Pirm dien jis suval-
g 1 saldain, antrj 2, treij 3. Kiekvien kit dien jis suvalgydavo vienu saldainiu daugiau negu
prie tai buvusi dien. Per kelias dienas d Martynas suvalgys visus saldainius? Paskutinei dienai gali likti
maiau saldaini.
Pasitikrinkite. Kai m = 11, turtumte gauti d = 5.
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, turtumte gauti t = 4.
Turime kompiuter, kuris nemoka apskaiiuoti natralij skaii dalmens sveikosios dalies ir liekanos
(nra / ir % dalybos operacij). Paraykite program, kuri apskaiiuot skaii n ir m dalmens sveikj
dal dalmuo ir liekan liekana.
Pasitikrinkite. Kai n = 14, m = 3, turtumte gauti: dalmuo = 4, liekana = 2.
Pristigo mogus pinig ir nujo pasiskolinti j i kaimyno. Tas sutiko paskolinti, bet papra gr-
inti juos kit mnes tokia tvarka: pirm mnesio dien 1 lit, antrj 2 litus, treij 4 litus,
t. y. kiekvien dien du kartus daugiau negu prie tai buvusi. T dien, kai skola gals bti padeng-
ta, reiks atiduoti ir vis tos dienos norm. Tai, kas bus atiduota daugiau, ir bus kaimyno palkanos.
Paraykite program, kuri apskaiiuot, kiek palkan litais gaus kaimynas u paskolintus n lit.
Pasitikrinkite. Kai n = 11, turtumte gauti palkanos = 4. (XIII olimpiada, 2002)
5. I n kvadratini plyteli reikia sudlioti vienos plytels storio kvadratus: pirmiausia sudti didiausi ga-
lim kvadrat, i likusi plyteli vl didiausi ir t. t. Paraykite program, kuri iskaidyt nurodyt
plyteli skaii dalis, reikalingas kiekvieno kvadrato statybai.
Pasitikrinkite. Kai n = 75, turtumte gauti: 64, 9, 1, 1.
(XI olimpiada, 2000)
1.
2.
3.
4.
49
SMALSIEMS
Nuorodos C++ kalbos inyn
3.11. Rezultat (duomen) ivedimas fail
Nordami, kad sienos statybos rezultatai bt ivedami tekstin fail, atlikite programos Darbas6.cpp
pakeitimus:
// Darbas6
#include <fcntl.h>
#include <io.h>
#include <iostream>
#include <fstream>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int p, // sienos statybai skirt plyt skaiius
s, // sienos statybai panaudot plyt skaiius
a, // sienos pagrindo ilgis
k; // sienos auktis
ofstream fr("Darbas6.txt");
fr << "Programa, skaiiuojanti sienos pagrindo ilg, aukt" << endl;
fr << " ir statybai panaudot plyt skaii" << endl;
fr << endl;
wcout << L"Kiek plyt skirta sienos statybai? "; cin >> p;
a = 0; k = 0; s = 0;
fr << "--------------------------------------------------" << endl;
fr << "Pagrindo ilgis Auktis Panaudot plyt skaiius" << endl;
fr << "--------------------------------------------------" << endl;
while (a + 1 <= p s) {
a = a + 1;
k = k + 1;
s = s + a;
fr << " " << a <<" " << k << " " << s << endl;
}
fr << "--------------------------------------------------" << endl;
fr << "Sienos pagrindo ilgis: " << a << endl;
fr << "Sienos auktis: " << k << endl;
fr << "Sienos statybai panaudot plyt skaiius: " << s << endl;
fr.close();
return 0;
}
raykite ir vykdykite program. Atverkite rezultat fail ir perirkite rezultatus. Jie turt bti tokie
patys, kaip ir rezultatai, ivesti ekran.

50
2.7. Funkcijos apibrimo srities tyrimas
Atlikdami darb, tvirtinsite slyginio ir neinomo kartojim skaiiaus ciklo sakini uraymo gdius.
Nuorodos C++ kalbos inyn Nuorodos algoritm inyn
3.1. Kintamasis, kintamojo reikm
3.2. Priskyrimo sakinys
3.4. Duomen vedimas klaviatra
3.5. Rezultat (duomen) ivedimas ekran
3.6. Ciklo sakinys while
3.8. Slyginis sakinys if
3.9. Knygoje naudojam ir / ar rekomenduo-
jam matematini funkcij sraas
4.1. Tiesiniai algoritmai
4.2. Cikliniai algoritmai
4.3. akotieji skaiiavimai
Uduotis
Reikia apskaiiuoti funkcijos y =
100
3
2

+
=
m
m
y reikm, kai mp m mg ir kinta ingsniu mz; ia mp, mg,
mz realieji skaiiai.
Atkreipkite dmes, kad trupmenos vardiklis negali bti lygus nuliui, o poaknis neigiamas.
1
Pasiruoimas
Sukurkite katalog Darbas7 programos failams laikyti. Paleiskite CodeBlocks. Sukurkite programos fai-
l Darbas7.cpp, raykite j katalog Darbas7. Programai suteikite vard Darbas7.
2
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 reikmms vesti klaviatra.

// Darbas7
#include <fcntl.h>
#include <io.h>
#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
double mp, mg, mz, m, y;
wcout << L"veskite argumento pradin reikm: "; cin >> mp;
wcout << L"veskite argumento galin reikm: "; cin >> mg;
wcout << L"veskite argumento kitimo ingsnio reikm: "; cin >> mz;
return 0;
}
raykite ir vykdykite program, kai pradiniai duomenys yra tokie: mp = -50, mg = 50, mz = 10.
Ekrane matysite:

51

veskite argumento pradin reikm: -50
veskite argumento galin reikm: 50
veskite argumento kitimo ingsnio reikm: 10
3
Funkcijos reikmi skaiiavimas ir ivedimas ekran
Papildykite program tokiais sakiniais:

wcout << L"Funkcijos reikmi skaiiavimas" << endl;
wcout << L" mp = " << setw(5) << fxed << setprecision(2) << mp
<< L" mg = " << setw(5) << fxed << setprecision(2) << mg
<< L" mz = " << setw(5) << fxed << setprecision(2) << mz << endl;
m = mp;
while (m <= mg){
if (m * m - 100 > 0) // tikrinama slyga, ar m priklauso apibrimo sriiai
// jei slyga tenkinama, skaiiuojama funkcijos reikm
y = (m + 3) / (sqrt(m * m - 100));
wcout << setw(7) << fxed << setprecision(2) << m
<< setw(12) << fxed << setprecision(5) << y << endl;
m = m + mz;
}
return 0;
}
raykite ir vykdykite program, kai pradiniai duomenys yra tokie: mp = -50, mg = 50, mz = 10.
Ekrane turtumte matyti:

veskite argumento pradin reikm: -50
veskite argumento galin reikm: 50
veskite argumento kitimo ingsnio reikm: 10
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
4
Rezultat analiz
Inagrinkite gautus rezultatus.
Kai m = -40.00 ir m = -30.00, funkcijos y reikms yra lygios -0.955. Esant toms paioms
argumento reikmms funkcijos reikmes apskaiiuokite skaiiuotuvu. Turtumte gauti atitinkamai
y = 0.95534 ir y = 0.95459. Palyginkite programos pateiktus rezultatus su apskaiiuotais skai-
iuotuvu.
Ivada. Raydami rezultat ivedimo ekran sakinius, pasirinkome trupmeninje dalyje rodyti tris
skaitmenis, todl ir gavome sutampanius rezultatus.
Pakeiskite raymo sakin taip, kad ivedamo ekran rezultato trupmeninje dalyje bt 5 skait-
menys.

52
vykdykite program. Ekrane turtumte matyti:

veskite argumento pradin reikm: -50
veskite argumento galin reikm: 50
veskite argumento kitimo ingsnio reikm: 10
Funkcijos reikmi skaiiavimas
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 ta pati ir lygi -0.98150. Tokius rezultatus gavome todl, kad argumento reikms -
10.00, 0.00 ir 10.00 netenkina slygos m * m - 100 > 0 ir ekran ivedama paskutin apskai-
iuota y reikm.
Ivada. Reikia taisyti program.
5
Teising rezultat visoms argumento m reikmms pateikimas
Funkcijos reikmi ivedimo sakin kelkite slygin sakin. Jei argumento m reikm nepriklauso
funkcijos apibrimo sriiai, tuomet vietoj funkcijos reikms iveskite septynias vaigdutes (*).

if (m * m - 100 > 0) { // tikrinama slyga, ar m priklauso apibrimo sriiai
// jei slyga tenkinama, skaiiuojama funkcijos reikm
y = (m + 3) / (sqrt(m * m - 100));
wcout << setw(7) << fxed << setprecision(2) << m
<< setw(12) << fxed << setprecision(5) << y << endl;
}
else wcout << setw(7) << fxed << setprecision(2) << m
<< setw(12) << fxed << setprecision(0) << L"*******" << endl;
raykite ir vykdykite program. Jei visk atlikote teisingai, ekrane turtumte matyti:

veskite argumento pradin reikm: -50
veskite argumento galin reikm: 50
veskite argumento kitimo ingsnio reikm: 10
Funkcijos reikmi skaiiavimas
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

53
6
Skaiiavimo rezultat pateikimas lentele
Papildykite program taip, kad argumento ir funkcijos reikms bt spausdinamos lentele:

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
-----------------------
Uduotys
1. Klasje yra n mokini. J informacini technologij savarankiko darbo paymiai yra p1, p2, ..., pn.
Paraykite program, kuri apskaiiuot, keli mokini k darbai buvo vertinti 9 ir 10.
Pasitikrinkite. Kai n = 7, p1 = 8, p2 = 9, p3 = 8, p4 = 9, p5 = 10, p6 = 9, p7 = 10, turi bti spausdinama:
Devintukus ir deimtukus gavo k = 5 mokiniai.
2. Parduotuvje mogus pirko n ri preki. J kainos yra k1, k2, ..., kn lit. Paraykite program, kuri apskai-
iuot, kiek yra preki k, kuri kaina ne didesn kaip m lit, ir koki pinig sum s reiks mokti u ias prekes.
Pasitikrinkite. Kai n = 5, m = 14, k1 = 12, k2 = 6, k3 = 19, k4 = 16, k5 = 2, turi bti spausdinama:
Preki, kuri kaina ne didesn kaip 14 lit, yra k = 3.
U jas reiks mokti s = 20 lit.
3. Klasje mokosi n mokini. J giai yra u1, u2, ..., un centimetr. Mergin gis ymimas sveikaisiais teigia-
mais, vaikin sveikaisiais neigiamais skaiiais. Paraykite program, kuri apskaiiuot, koks yra vidutinis
klass vaikin vidvaikinu ir vidutinis klass mergin vidmerginu gis.
Pasitikrinkite. Kai n = 7, u1 = 168, u2 = 179, u3 = 178, u4 = 189, u5 = 170, u6 = 169, u7 = 180, turi bti
spausdinama: vidvaikinu = 181.5, vidmerginu = 169.0.
4. Varybose dalyvavo n daugiakovinink. Sportininkai surinko t1, t2, ..., tn tak (sveikieji skaiiai). Paray-
kite program, kuri apskaiiuot didiausi tmax ir maiausi tmin sportinink surinkt tak skaii.
Pasitikrinkite. Kai n = 5, t1 = 1682, u2 = 1794, u3 = 1787, u4 = 1891, u5 = 1710, turi bti spausdinama:
tmax = 1891, tmin = 1682.
5. Pateikiamas dviej natralij skaii a ir b didiausiojo bendrojo daliklio (DBD) paiekos, vadinamojo
Euklido, algoritmo 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 nuo 2-ojo ingsnio.
Pasitikrinkite. Kai a = 14, b = 4, turi bti spausdinama: DBD = 2.

54
2.8. Trys lazdos
Atlikdami darb, susipainsite su loginiais kintamaisiais ir loginiais reikiniais, loginmis operacijomis
ARBA (||), IR (&&). Imoksite loginius reikinius naudoti ciklo ir slyginiuose sakiniuose.
Nuorodos C++ kalbos inyn Nuorodos algoritm inyn
3.7. Ciklo sakinys for
3.8. Slyginis sakinys if
4.2. Cikliniai algoritmai
4.3. akotieji skaiiavimai
Uduotis
Yra n tam tikro ilgio lazd rinkini. Kiekvien rinkin sudaro 3 lazdos. Lazd ilgiai a, b ir c matuojami decime-
trais (sveikaisiais skaiiais). Ar galima i i lazd sudaryti trikamp? Jeigu galima, tai kok: lygiakrat, lygiaon
ar vairiakrat? Jeigu negalima, reikia ivesti praneim, kad trikampio sudaryti negalima.
Algoritmas
Sprendiant i uduot, galima sivaizduoti, kad trys lazdos geometrijoje atitinka tris atitinkamo ilgio atkarpas
a, b ir c. Prisiminkite, kad ne visuomet i trij atkarp galima sudaryti trikamp. I trij atkarp trikamp galima
sudlioti tuomet, kai bet kuri atkarp por ilgi suma yra didesn u treiosios atkarpos ilg, t. y. (a + b > c)
ir (a + c > b) ir (c + b > a) .
1
Pasiruoimas
Sukurkite katalog programos failams laikyti. Paleiskite CodeBlocks. Sukurkite programos fail
Darbas8.cpp, raykite j katalog Darbas8. Programai suteikite vard Darbas8.
Pastaba. I pradi raysime program, skirt tik vienam lazd rinkiniui. Vien rinkin sudaro trys lazdos, todl
lazd ilgius vesime vienu cin sakiniu ir nustatysime, ar galima i lazd sudaryti trikamp, ar ne.
2
Kintamj apraymas ir pradini duomen vedimas
Programos pradioje apraykite trij lazd ilgius nusakanius sveikojo tipo kintamuosius a, b, ir c.
Paraykite kintamj a, b, ir c reikmi vedimo klaviatra sakinius: praneimo, kokias reikmes ir
kokia eils tvarka vesti, sakin (wcout) ir reikmi skaitymo sakin (cin).
// Darbas8
#include <fcntl.h>
#include <io.h>
#include <iostream>
#include <iomanip>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int a, b, c; // trij lazd ilgiai
wcout << L"veskite trij lazd ilgius: ";
cin >> a >> b >> c;
return 0;
}
raykite ir vykdykite program. Klaviatra veskite skaiius 30 50 40 ir spustelkite klavi Enter.
Ekrane matysite:

veskite trij lazd ilgius: 30 50 40

55
3
Tikrinimas, ar i trij lazd rinkinio galima sudaryti trikamp.
Rezultato ivedimas ekran
Papildykite program sakiniu wcout, kuris ekran ivest pradinius duomenis a, b, c.
Papildykite program slyginiu sakiniu if, skirtu patikrinti, ar i nurodyt lazd galima sudaryti tri-
kamp.

// Darbas8
#include <fcntl.h>
#include <io.h>
#include <iostream>
#include <iomanip>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int a, b, c; // trij lazd ilgiai
wcout << L"veskite trij lazd ilgius: ";
cin >> a >> b >> c;
wcout << L"Lazdos: " << setw(2) << fxed << a << L" "
<< setw(2) << fxed << b << L" " << setw(2) << fxed << c;
if ((a + b > c) && (a + c > b) && (b + c > a)) // ar trikampis?
wcout << L" trikamp sudaryti galima" << endl;
else wcout << L" - trikampio sudaryti negalima" << endl;
return 0;
}
raykite ir vykdykite program. Klaviatra veskite skaiius 30 50 40 ir spustelkite klavi Enter.
Ekrane matysite:

veskite trij lazd ilgius: 30 50 40
Lazdos: 30 50 40 trikamp sudaryti galima
Dar kart vykdykite program. Klaviatra veskite skaiius 10 50 40 ir spustelkite klavi Enter.
Ekrane matysite:

veskite trij lazd ilgius: 10 50 40
Lazdos: 10 50 40 trikampio sudaryti negalima
4
Tikrinimas, koks yra trikampis, kai j galima sudaryti
Lygiakrat trikamp galima sudaryti, jeigu dydiai a, b ir c tenkina slyg
(a = b) ir (b = c).
Lygiaon trikamp galima sudaryti, jeigu dydiai a, b ir c tenkina slyg
(a = b) arba (b = c) arba (a = c).
Jeigu n viena urayta slyga netenkinama, tai trikampis yra vairiakratis.
Pakeiskite slyginio sakinio ivedimo ekran sakin
wcout << L" trikamp sudaryti galima";
kitu sudtiniu slyginiu sakiniu, kuris analizuot, kokio tipo trikamp galima sudaryti i trij lazd
rinkinio.

56
// Darbas8
#include <fcntl.h>
#include <io.h>
#include <iostream>
#include <iomanip>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int a, b, c; // trij lazd ilgiai
wcout << L"veskite trij lazd ilgius: ";
cin >> a >> b >> c;
wcout << L"Lazdos: " << setw(2) << fxed << a << L" "
<< setw(2) << fxed << b << L" " << setw(2) << fxed << c;
if ((a + b > c) && (a + c > b) && (b + c > a)) // ar trikampis?
if ((a == b) && (b == c))
wcout << L" - galima sudaryti lygiakrat trikamp" << endl;
else if ((a == b) || (b == c) || (a == c))
wcout << L" - galima sudaryti lygiaon trikamp" << endl;
else wcout << L" - galima sudaryti vairiakrat trikamp" << endl;
else wcout << L" - trikampio sudaryti negalima" << endl;
return 0;
}
Patikrinkite program, esant iems duomen rinkiniams:
50 50 50 (Lygiakratis trikampis)
40 50 40 (Lygiaonis trikampis)
40 50 60 (vairiakratis trikampis)
10 50 40 (Trikampio sudaryti negalima)
Pirmuoju atveju, ved duomenis ir spustelj klavi Enter, ekrane matysite:

veskite trij lazd ilgius: 50 50 50
Lazdos: 50 50 50 galima sudaryti lygiakrat trikamp
5
Gautos programos pritaikymas dideliam skaiiui duomen rinkini
inome, kad pradini duomen rinkini yra n. Jiems analizuoti panaudokime cikl for.
Papildykite program dviem sveikojo tipo kintamaisiais n ir i. Pirmasis bus skirtas rinkini skaiiui
atmintyje laikyti, o antrasis rodys, su kuriuo rinkiniu atliekami skaiiavimai.
Paraykite dialogo sakinius n reikmei vesti.
kelkite duomen vedimo ir slygin sakinius cikl for. Cikle bus vykdomi keli sakiniai, todl juos
apgaubkite { ir }.
terpkite duomen vedimo dialogo sakin wcout ciklo kintamj i.

57

// Darbas8
#include <fcntl.h>
#include <io.h>
#include <iostream>
#include <iomanip>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int a, b, c; // trij lazd ilgiai
int n, // lazd rinkini skaiius
i; // ciklo kintamasis
wcout << L"veskite, kiek lazd rinkini bus: "; cin >> n;
for (i = 1; i <= n; i = i + 1){
wcout << L"veskite trij lazd " << i << L"-j rinkin: ";
cin >> a >> b >> c;
wcout << L"Lazdos: " << setw(2) << fxed << a << L" "
<< setw(2) << fxed << b << L" " << setw(2) << fxed << c;
if ((a + b > c) && (a + c > b) && (b + c > a)) // ar trikampis?
if ((a == b) && (b == c))
wcout << L" - galima sudaryti lygiakrat trikamp" << endl;
else if ((a == b) || (b == c) || (a == c))
wcout << L" - galima sudaryti lygiaon trikamp" << endl;
else wcout << L" - galima sudaryti vairiakrat trikamp" << endl;
else wcout << L" - trikampio sudaryti negalima" << endl;
}
return 0;
}
raykite ir vykdykite program su ankstesniais pradiniais duomenimis, n reikm nurodykite 4. Ekra-
ne turtumte matyti:

veskite, kiek lazd rinkini bus: 4
veskite trij lazd 1-j rinkin: 50 50 50
Lazdos: 50 50 50 galima sudaryti lygiakrat trikamp
veskite trij lazd 2-j rinkin: 40 50 40
Lazdos: 40 50 40 galima sudaryti lygiaon trikamp
veskite trij lazd 3-j rinkin: 40 50 60
Lazdos: 40 50 60 galima sudaryti vairiakrat trikamp
veskite trij lazd 4-j rinkin: 10 50 40
Lazdos: 10 50 40 trikampio sudaryti negalima
Klausimai
Kokias inote logines operacijas ir kaip jos uraomos C++ programavimo kalba?
Kaip suprantate login reikin? Paaikinkite.
Kokios operacijos daniausiai naudojamos apraant login reikin?
Kokias reikmes gali gyti loginis reikinys?
Uduotys
1 Trikampis vienu metu gali bti dviej tip: statusis ir lygiaonis, lygiaonis ir lygiakratis. Pakeiskite progra-
m taip, kad ji tai nustatyt.
Pasitikrinkite.
Kai a = 50, b = 40, c = 30, turi bti spausdinama: Trikampis statusis ir vairiakratis.
Kai a = 50, b = 50, c = 50, turi bti spausdinama: Trikampis lygiakratis ir lygiaonis.

1.
2.
3.
4.
58
2. Papildykite program taip, kad ji apskaiiuot ir ekran ivest gaut trikampi plotus. Naudokits Hero-
no formule trikampio plotui apskaiiuoti.
Pasitikrinkite.
Kai a = 50, b = 50, c = 50, turi bti spausdinama: s = 1083.
Kai a = 40, b = 50, c = 40, turi bti spausdinama: s = 781.
Kai a = 40, b = 50, c = 60, turi bti spausdinama: s = 992.
Kai a = 10, b = 50, c = 40, turi bti spausdinama: Trikampio sudaryti negalima.
3. Yra inomos staiakampio, kurio kratins lygiagreios su koordinai aimis, prieing kamp (kairiojo
virutinio ir deiniojo apatinio) koordinats (x1; y1) ir (x2; y2). Paraykite program, kuri nustatyt, ar
takas (xt; yt) yra:
viduje;
iorje;
apatinje kratinje;
virutinje kratinje;
kairiojoje kratinje;
deiniojoje kratinje.
Pasitikrinkite.
Kai x1 = 1, y1 = 5, x2 = 10, y2 = 1, xt = 4, yt = 3, turi bti spausdinama:
Takas yra staiakampio viduje.
Kai x1 = 1, y1 = 5, x2 = 10, y2 = 1, xt = 0, yt =0, turi bti spausdinama:
Takas yra staiakampio iorje.
Kai x1 = 1, y1 = 5, x2 = 10, y2 = 1, xt = 3, yt = 1, turi bti spausdinama:
Takas yra apatinje kratinje.
Kai x1 = 1, y1 = 5, x2 = 10, y2 = 1, xt = 5, yt = 5, turi bti spausdinama:
Takas yra virutinje kratinje.
Kai x1 = 1, y1 = 5, x2 = 10, y2 = 1, xt = 1, yt = 3, turi bti spausdinama:
Takas yra kairiojoje kratinje.
Kai x1 = 1, y1 = 5, x2 = 10, y2 = 1, xt = 10, yt = 4, turi bti spausdinama:
Takas yra deiniojoje kratinje.
SMALSIEMS
Nuorodos C++ kalbos inyn
3.10. Duomen vedimas i failo
3.11. Rezultat (duomen) ivedimas fail
3.12. Funkcijos
1
Duomen vedimas i failo ir rezultat ivedimas fail
Susikurkite pradini duomen fail, pavyzdiui, Lazdos.txt:

4
50 50 50
40 50 40
40 50 60
10 50 40
ia pirmoje eilutje raytas lazd rinkini skaiius n, kitose eilutse po tris skaiius surayti lazd rinkiniai.

59
Atlikite tokius programos pakeitimus:
programos pradioje terpkite fail fstream.
parenkite fail Lazdos.txt duomenims skaityti;
veskite kintamojo n reikm i failo;
veskite kintamj a, b, c reikmes i failo;
paalinkite nereikalingus sakinius:
#include <fcntl.h>
#include <io.h>
#include <iostream>
wcout << L"veskite, kiek lazd rinkini bus: ";
wcout << L"veskite trij lazd " << i << L"-j rinkin: ";
uverkite fail Lazdos.txt.
raykite ir vykdykite program.
Palyginkite gautus rezultatus su ankstesniais. Jeigu visk atlikote teisingai, tai rezultatai turt sutapti.
Panaius veiksmus atlikite rezultatams ivesti ne ekran, o rezultat fail:
sugalvokite rezultat failo vard, pavyzdiui, Rezultatai.txt;
parenkite fail Rezultatai.txt duomenims rayti;
paraykite ivedimo fail sakinius.
uverkite fail Rezultatai.txt.
raykite ir vykdykite program.
Apskaiiuoti rezultatai bus rezultat faile Rezultatai.txt. J galima atverti meniu komandomis: File Open.
2
Programos struktrizavimas naudojant funkcijas
Paraykite funkcijas, kurios patikrint, ar i 3 lazd rinkinio galima sudaryti trikamp, ir koks jis yra.
// Darbas8
#include <iomanip>
#include <fstream>
using namespace std;
//-----------------------------------------------------------------------------
bool ArTrikampis(int a, int b, int c);
bool ArLygiakrastis(int a, int b, int c);
bool ArLygiasonis(int a, int b, int c);
bool ArIvairiakrastis(int a, int b, int c);
//-----------------------------------------------------------------------------
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int a, b, c, // trij lazd ilgiai
n, // lazd rinkini skaiius
i; // ciklo kintamasis
ifstream fd("Lazdos.txt");
ofstream fr("Rezultatai.txt");
fd >> n;
for (i = 1 ; i <= n; i = i + 1){
fd >> a >> b >> c;
fr << "Lazda: " << setw(2) << fxed << a << setw(2) << fxed
<< " " << b << setw(2) << fxed << " " << c << endl;
if (ArTrikampis(a, b, c)){ // ar trikampis?
if (ArLygiakrastis(a, b, c))
fr << " - galima sudaryti lygiakrat trikamp" << endl;
if (ArLygiasonis(a, b, c))
fr << " - galima sudaryti lygiaon trikamp" << endl;
if (ArIvairiakrastis(a, b, c))
fr << " - galima sudaryti vairikrat trikamp" << endl;
}
else fr << " - trikampio sudaryti negalima" << endl;
}

60
fd.close();
fr.close();
return 0;
}
//-----------------------------------------------------------------------------
bool ArTrikampis(int a, int b, int c)
{
bool t;
t = (a + b > c) && (a + c > b) && (b + c > a);
return t;
}
//-----------------------------------------------------------------------------
bool ArLygiakrastis(int a, int b, int c)
{
bool t;
t = ((a == b) && (b == c));
return t;
}//-----------------------------------------------------------------------------
bool ArLygiasonis(int a, int b, int c)
{
bool t;
t = (a == b) || (b == c) || (a == c);
return t;
}
//-----------------------------------------------------------------------------
bool ArIvairiakrastis(int a, int b, int c)
{
bool t;
t = (a != b) && (a != c) && (b != c);
return t;
}
//-----------------------------------------------------------------------------
raykite ir vykdykite program. Rezultat faile turtumte matyti:
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

61
2.9. Vampyro skaiiai
Atlikdami darb, imoksite natraliuosius skaiius skaidyti skaitmenimis, naudodamiesi dalybos operatoriais
/ ir %. Suinosite, kokie skaiiai vadinami vampyro skaiiais, imoksite juos rasti.
Nuorodos C++ kalbos inyn Nuorodos algoritm inyn
3.4. Duomen vedimas klaviatra
3.5. Rezultat (duomen) ivedimas ekran
3.7. Ciklo sakinys for
3.8. Slyginis sakinys if
4.2. Cikliniai algoritmai
4.3. akotieji skaiiavimai
Uduotis
Tarkime, kad turime sveikj skaii sk, sudaryt i n (n lyginis skaiius) skaitmen. Jeigu skaiius sk turi 2
daugiklius, i kuri kiekvienas yra sudarytas i n/2 skaitmen ir skaiiaus sk skaitmen (visi skaitmenys naudo-
jami tik po 1 kart), tai jis yra vadinamas vampro skaiiumi, o i jo skaitmen sudaryti daugikliai vampro
skai iaus iiltimis. Reikia parayti program, kuri surast ir ivest ekran visus keturenklius vampyro skaiius
bei j iltis.
Algoritmas
Prie praddami nagrinti i uduot, pateiksime kelet keturenkli vampyro skaii ir jo ili pavyzdi:
1260 = 21 * 60
1395 = 15 * 93
1827 = 21 * 87
Kaip pastebite, ie keturenkliai skaiiai yra lygs dviej dvienkli skaii sandaugai. Be to, kiekvieno skai-
iaus abu dauginamieji turi visus pradinio skaiiaus skaitmenis.
Norint pradti sprsti i uduot, pirmiausia reikia mokti atskirti skaiiaus skaitmenis. Tai padaryti galima
naudojant sveikj skaii dalybos operacijas / ir %. Primename, kad / nurodo dalybos sveikj dal, o % da-
lybos sveikj liekan. Pavyzdiui, turime keturenkl skaii sk = 1234. Pirmj skaiiaus skaitmen pavadinki-
me a, antrj b, treij c, ketvirtj d, t. y. sk = a * 1000 + b * 100 + c * 10 + d. Dabar paraykime formules,
pagal kurias galima rasti iuos skaitmenis:
a = sk / 1000
b = (sk / 100) % 10
c = (sk / 10) % 10
d = sk % 10
Atskyrus keturenklio skaiiaus sk skaitmenis a, b, c, d, juos reikia sujungti po du, t. y. paversti dvienkliais
skaiiais sk1 ir sk2. Toliau iuos dvienklius skaiius reikia sudauginti ir gaut rezultat lyginti su pradiniu
keturenkliu skaiiumi. Jeigu gauta dvienkli skaii sk1 ir sk2 sandauga lygi keturenkliam skaiiui sk, vadi-
nasi, keturenklis skaiius sk yra vampyras, o dvienkliai skaiiai sk1 ir sk2 jo iltys. iuos veiksmus detaliau
panagrinsime ir pritaikysime programoje.

1
Pasiruoimas
Sukurkite katalog programos failams laikyti. Paleiskite CodeBlocks. Sukurkite programos fail
Darbas9.cpp, raykite j katalog Darbas9. Programai suteikite vard Darbas9.
Pastaba. I pradi paraysime program, kuri iskaidyt skaitmenimis tik vien keturenkl skaii.

62
2
Keturenklio skaiiaus iskaidymas skaitmenimis
Pagal nurodytas formules paraykite keturis priskyrimo sakinius:

// Darbas9
#include <fcntl.h>
#include <io.h>
#include <iostream>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int sk, // keturenklis skaiius
a, b, c, d; // skaiiaus sk skaitmenys
sk = 1234;
a = sk / 1000;
b = (sk / 100) % 10;
c = (sk / 10) % 10;
d = sk % 10;
wcout << L"Skaiiaus " << sk << L"skaitmenys: "
<< a << L" " << b << L" " << c << L" " << d << endl;
return 0;
}
raykite ir vykdykite program. Ekrane matysite:

Skaiiaus 1234 skaitmenys: 1 2 3 4
3 Pirmojo keturenkli skaii deimtuko skaidymas atskirais skaitmenimis ir
ivedimas ekran
Pakeiskite priskyrimo sakin
sk = 1234;
ciklo sakiniu, kuriame skaiiai nuo 1000 iki 1009 iskaidomi skaitmenimis.

// Darbas9
#include <fcntl.h>
#include <io.h>
#include <iostream>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int sk, // keturenklis skaiius
a, b, c, d; // skaiiaus sk skaitmenys
for (sk = 1000; sk <= 1009; sk = sk + 1) {
a = sk / 1000;
b = (sk / 100) % 10;
c = (sk / 10) % 10;
d = sk % 10;
wcout << L"Skaiiaus " << sk << L"skaitmenys: "
<< a << L" " << b << L" " << c << L" " << d << endl;
}
return 0;
}

63
raykite ir vykdykite program. Ekrane matysite:

Skaiiaus 1000 skaitmenys: 1 0 0 0
Skaiiaus 1001 skaitmenys: 1 0 0 1
Skaiiaus 1002 skaitmenys: 1 0 0 2
Skaiiaus 1003 skaitmenys: 1 0 0 3
Skaiiaus 1004 skaitmenys: 1 0 0 4
Skaiiaus 1005 skaitmenys: 1 0 0 5
Skaiiaus 1006 skaitmenys: 1 0 0 6
Skaiiaus 1007 skaitmenys: 1 0 0 7
Skaiiaus 1008 skaitmenys: 1 0 0 8
Skaiiaus 1009 skaitmenys: 1 0 0 9
Ibandykite program su visais 4-enkliais skaiiais: 1000..9999.
4
Iskaidyt skaitmen jungimas po du
Iskaidius keturenkl skaii sk skaitmenimis a, b, c, d, juos reikia sujungti po du. Galimi ei keturi skait-
men jungimo po du variantai (junginiai):
ab,
ac,
ad,
bc,
bd,
cd.
Pastaba. Skaitmen tvarka junginyje ir jungini eilikumas yra visikai nesvarbs.
Pagal uduoties slyg gautus junginius reikia grupuoti po du taip, kad visi skaitmenys bt naudojami po vie-
n kart. Yra trys toki jungini poros:
ab ir cd
ac ir bd
ad ir bc
Pakeiskite programos sakin
wcout << L"Skaiiaus " << sk << L"skaitmenys: "
<< a << L" " << b << L" " << c << L" " << d << endl;
iais sakiniais:

wcout << L"Skaiiaus " << sk << L"jungini poros: " << endl;
wcout << a << b << L" " << c << d << endl;
wcout << a << c << L" " << b << d << endl;
wcout << a << d << L" " << b << c << endl;
raykite ir vykdykite program. J patikrinkite ciklo for pradios ir pabaigos reikmes pasirink,
pavyzdiui, 1234. Ekrane matysite:

Skaiiaus 1234 jungini poros:
12 34
13 24
14 23
Ibandykite program su visais keturenkliais skaiiais: 1000..9999.

64
5
Derini sudarymas
Jungin sudaro du skaitmenys, todl kiekvienai jungini porai galima sudaryti po 4 (2 * 2) derinius. Deriniai
sudaromi sukeiiant junginyje skaitmenis vietomis. Lentelje pateikiami vis trij anksiau sudaryt jungini
por deriniai:

Pirmos jungini poros
ab ir cd deriniai
Antros jungini poros
ac ir bd deriniai
Treios jungini poros
ad ir bc deriniai
ab cd
ba cd
ab dc
ba dc
ac bd
ca bd
ac db
ca db
ad bc
da bc
ad cb
da cb
Pertvarkykite ankstesn program, kiekvien jungini poros ivedimo sakin pakeisdami keturiais de-
rini ivedimo sakiniais. Taigi programoje vietoj trij atsiras dvylika ivedimo sakini.

// Darbas9
#include <fcntl.h>
#include <io.h>
#include <iostream>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int sk, // keturenklis skaiius
a, b, c, d; // skaiiaus sk skaitmenys
for (sk = 1000; sk <= 1009; sk = sk + 1) {
a = sk / 1000;
b = (sk / 100) % 10;
c = (sk / 10) % 10;
d = sk % 10;
wcout << L"Skaiiaus " << sk << L"jungini poros: " << endl;
wcout << a << b << L" " << c << d << endl;
wcout << b << a << L" " << c << d << endl;
wcout << a << b << L" " << d << c << endl;
wcout << b << a << L" " << d << c << endl;
wcout << endl;
wcout << a << c << L" " << b << d << endl;
wcout << c << a << L" " << b << d << endl;
wcout << a << c << L" " << d << b << endl;
wcout << c << a << L" " << d << b << endl;
wcout << endl;
wcout << a << d << L" " << b << c << endl;
wcout << d << a << L" " << b << c << endl;
wcout << a << d << L" " << c << b << endl;
wcout << d << a << L" " << c << b << endl;
}
return 0;
}

65
raykite ir vykdykite program. Ekrane turtumte matyti:

Skaiiaus 1234 jungini poros:
12 34
21 34
12 43
21 43
13 24
31 24
13 42
31 42
14 23
41 23
14 32
41 32
6
Tikrinimas, ar skaiius yra vampyro skaiius
Visus gautus jungini derinius pavertus dvienkliais skaiiais (pavyzdiui, a * 10 + b ir c * 10 + d), juos
sudauginus ir palyginus su pradiniu skaiiumi sk, galima nustatyti, ar sk yra vampyro skaiius. Jeigu taip, tai
ekran ivedamas skaiius ir jo iltys.
Paalinkite i programos sakin:

wcout << L"Skaiiaus " << sk << L"jungini poros: " << endl;
Pakeiskite ankstesnje programoje 12 ivedimo sakini. Pavyzdiui, pirmj ivedimo sakin

wcout << a << b << L" " << c << d << endl;
pakeiskite tokiu:

if (sk == (a * 10 + b) * (c * 10 + d))
wcout << sk << L" = " << a << b << L" * " << c << d << endl;
Nurodykite ciklo for pradin reikm 1000, o galutin reikm 9999.

// Darbas9
#include <fcntl.h>
#include <io.h>
#include <iostream>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int sk, // keturenklis skaiius
a, b, c, d; // skaiiaus sk skaitmenys
wcout << L"Vampyro skaiiai: " << endl;
for (sk = 1000; sk <= 9999; sk = sk + 1) {
a = sk / 1000;
b = (sk / 100) % 10;
c = (sk / 10) % 10;
d = sk % 10;
if (sk == (a * 10 + b) * (c * 10 + d))
wcout << sk << L" = " << a << b << L" * " << c << d << endl;
if (sk == (b * 10 + a) * (c * 10 + d))
wcout << sk << L" = " << b << a << L" * " << c << d << endl;
if (sk == (a * 10 + b) * (d * 10 + c))
wcout << sk << L" = " << a << b << L" * " << d << c << endl;

66

if (sk == (b * 10 + a) * (d * 10 + c))
wcout << sk << L" = " << b << a << L" * " << d << c << endl;
if (sk == (a * 10 + c) * (b * 10 + d))
wcout << sk << L" = " << a << c << L" * " << b << d << endl;
if (sk == (c * 10 + a) * (b * 10 + d))
wcout << sk << L" = " << c << a << L" * " << b << d << endl;
if (sk == (a * 10 + c) * (d * 10 + b))
wcout << sk << L" = " << a << c << L" * " << d << b << endl;
if (sk == (c * 10 + a) * (d * 10 + b))
wcout << sk << L" = " << c << a << L" * " << d << b << endl;
if (sk == (a * 10 + d) * (b * 10 + c))
wcout << sk << L" = " << a << d << L" * " << b << c << endl;
if (sk == (d * 10 + a) * (b * 10 + c))
wcout << sk << L" = " << d << a << L" * " << b << c << endl;
if (sk == (a * 10 + d) * (c * 10 + b))
wcout << sk << L" = " << a << d << L" * " << c << b << endl;
if (sk == (d * 10 + a) * (c * 10 + b))
wcout << sk << L" = " << d << a << L" * " << c << b << endl;
}
return 0;
}
raykite ir vykdykite program. Ekrane matysite:

Vampyro skaiiai:
1260 = 21 * 60
1395 = 15 * 93
1435 = 41 * 35
1530 = 51 * 30
1827 = 21 * 87
2187 = 27 * 81
6880 = 86 * 80
6880 = 86 * 80
Klausimai
1. Tarkime, kad sk yra keturenklis sveikasis skaiius. Kokie yra nurodyt priskyrimo sakini rezultatai?
a) a := sk / 1000;
b) b := (sk / 100) % 10;
c) c := (sk / 10) % 10;
d) d := sk % 10;
2. K gausite bet kok sveikj skaii padalij i 10 ir pam dalybos sveikj dal?
3. K gausite bet kok sveikj skaii padalij i 10 ir pam dalybos liekan?
Uduotys
1. Paraykite program, kuri nustatyt, i keli skaitmen k sudarytas sveikasis skaiius sk.
Pasitikrinkite. Kai sk = 12345, tai k = 5. Kai sk = 4, tai k = 1.
2. Paraykite program, kuri nustatyt, ar sveikasis skaiius sk lyginis, ar nelyginis.
Pasitikrinkite. Kai sk = 123, turi bti spausdinama: Skaiius nelyginis.
3. Paraykite program, kuri nustatyt, ar sveikasis skaiius sk yra palindrmas (vienodai skaitomas i abiej
pusi).
Pasitikrinkite. Kai sk = 1221, turi bti spausdinama: Skaiius yra palindromas.
4. Paraykite program, kuri nustatyt, ar sveikasis skaiius sk sudarytas vien i lygini, ar vien i nelygini
skaitmen, ar i lygini ir nelygini.
Pasitikrinkite. Kai sk = 1234, turi bti spausdinama:
Skaiiuje yra ir lygini, ir nelygini skaitmen.

67
5. Paraykite program, kuri apskaiiuot sveikojo skaiiaus sk faktoril f.
Pasitikrinkite. Kai sk = 5, tai f = 120.
SMALSIEMS
Nuorodos C++ kalbos inyn
3.11. Rezultat (duomen) ivedimas fail
3.12. Funkcijos
1
Programos struktrizavimas naudojant funkcij
Sudarykite funkcij, kuri nustatyt, ar skaiius yra vampyro skaiius. Funkcij pavadinkite vardu
Vampyras. Funkcija turs penkis parametrus: keturenkl skaii sk ir keturis jo skaitmenis a, b,
c, d. Jeigu sk bus vampyro skaiius, tai funkcija ives skaii ir jo iltis. Programoje funkcij reiks
kreiptis 12 kart nurodant tinkamus argumentus. Todl programoje kiekvien if sakin pakeiskite
kreipiniu funkcij Vampyras.

// Darbas9
#include <fcntl.h>
#include <io.h>
#include <iostream>
using namespace std;
//----------------------------------------------------------------------------
void Vampyras(int sk, int a, int b, int c, int d);
//----------------------------------------------------------------------------
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int sk, // keturenklis skaiius
a, b, c, d; // skaiiaus sk skaitmenys
wcout << L"Vampyro skaiiai: ";
for (sk = 1000; sk <= 9999; sk = sk + 1) {
a = sk / 1000;
b = (sk / 100) % 10;
c = (sk / 10) % 10;
d = sk % 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, a, c, b, d);
Vampyras(sk, c, a, b, d);
Vampyras(sk, a, c, d, b);
Vampyras(sk, c, a, d, b);
Vampyras(sk, a, d, b, c);
Vampyras(sk, d, a, b, c);
Vampyras(sk, a, d, c, b);
Vampyras(sk, d, a, c, b);
}
return 0;
}
//----------------------------------------------------------------------------
void Vampyras(int sk, int a, int b, int c, int d)
{
if (sk == (a * 10 + b) * ( c * 10 + d))
wcout << sk << L" = " << a << b << L" * " << c << d << endl;
}
//----------------------------------------------------------------------------

68
raykite ir vykdykite program. Ekrane matysite tok pat rezultat, kaip ir ankstesns programos ver-
sijos.
2
Programos rezultat ivedimas rezultat fail
Atlikite tokius programos pakeitimus:
perkelkite program antratin fail fstream;
sugalvokite rezultat failo vard, pavyzdiui, Vampyrai.txt;
parenkite fail raymui;
papildykite funkcijos Vampyras parametr sra dar vienu kintamuoju (pavyzdiui,
ofstream & fr,), uraydami j pirmiausia;
ivedimo sakin wcout << L"Vampyro skaiiai: "; pakeiskite sakiniu
fr << "Vampyro skaiiai: ";
funkcijoje Vampyras ivedimo sakin wcout pakeiskite sakiniu
fr << sk << " = " << a << b << " * " << c << d << endl;
uverkite tekstin fail;
paraykite sakin
wcout << L"Rezultatai yra faile Vampyrai.txt" << endl;.
raykite ir vykdykite program. Ekrane turt bti tik tokia eilut:

Rezultatai yra faile Vampyrai.txt
Apskaiiuoti rezultatai bus rezultat faile. J atverti galima naudojantis meniu komandomis: File Open...

69
2.10. Taikinys
Atlikdami darb, tvirtinsite slyginio sakinio uraymo gdius. Suinosite, kaip nustatyti, ar du realieji
skaiiai lygs.
Nuorodos C++ kalbos inyn Nuorodos algoritm inyn
3.4. Duomen vedimas klaviatra
3.5. Rezultat (duomen) ivedimas ekran
3.8. Slyginis sakinys if
3.9. Knygoje naudojam ir / ar rekomenduo-
jam matematini funkcij sraas
4.3. akotieji skaiiavimai
Uduotis
Vyksta audymo i lanko varybos. Taikinys pritvirtintas prie lentos, turinios elektroninius
daviklius. Lentos apatinio kairiojo kampo koordinats yra (0; 0). Taikinio centras paym-
tas juodu skrituliu. Aplink j yra nubrti dar trys apskritimai. Strlei pataikius skirtingas
taikinio vietas, yra skiriamas skirtingas skaiius tak. Reikia parayti program, kuri, at-
sivelgdama strls pataikymo viet, skirt sportininkui takus. Yra inomi taikinio duo-
menys: taikinio centro koordinats (xc; yc), apskritim spinduliai, strls pataikymo tako
koordinats (x; y) ir tak verts. Jeigu strl pataik apskritimo linij, tuomet sportininkas
gauna pus tak, kurie bt skiriami, jeigu strl pataikyt apskritimo vid.
Algoritmas
Jei strls pataikymo takas nuo apskritimo centro nutols atstumu ats < r (ia r apskritimo spindulys), tuomet
pataikymo takas yra apskritimo viduje, jei ats = r pataikymo takas yra ant apskritimo, jei ats > r pataikymo
takas yra apskritimo iorje.
Pavaizduokime situacij grafkai:


y
x
ats
xc, yc
r
x, y
2 2
y yc x xc ats + =
Atstumas ats tarp dviej tak
skaiiuojamas pagal formul
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. kompiuterio atmintin realieji skaiiai raomi
tam tikru tikslumu, todl skaiiai laikomi lygiais tuomet, kai skirtumas tarp j yra nedidelis. Pavyzdiui, du
realieji skaiiai yra lygs, jeigu pirmieji penki skaitmenys po kablelio yra vienodi. Daugeliu atvej atliekant
skaiiavimus su realiaisiais skaiiais btina inoti, kokiu tikslumu reikia skaiiuoti.
1
Pasiruoimas
Sukurkite katalog programos failams laikyti, paleiskite CodeBlocks ir sukurkite programos fail
Darbas10.cpp.
Pastaba. Udavin suskaidysime dalis:
pradini duomen skaitymas;
atstumo ats skaiiavimas;
tikrinimas, kur pataik strl.

70
2
Pradini duomen skaitymas
Apraykite kintamuosius pradiniams duomenims atmintyje laikyti ir uraykite pradini duomen
skaitymo sakinius.

// Darbas10
#include <fcntl.h>
#include <io.h>
#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
double xc, yc, // taikinio centro koordinats
r1, r2, r3, r4; // taikinio apskritim spinduliai didjimo tvarka
int t1, t2, t3, t4; // skiriami takai atsivelgiant apskritimus
double x, y; // strls pataikymo tako koordinats
// Duomen skaitymas
wcout << L"Taikinio centro koordinat xc = "; cin >> xc;
wcout << L"Taikinio centro koordinat yc = "; cin >> yc;
wcout << L"Pirmojo apskritimo spindulys r1 = "; cin >> r1;
wcout << L"Pirmojo apskritimo takai t1 = "; cin >> t1;
wcout << L"Antrojo apskritimo spindulys r2 = "; cin >> r2;
wcout << L"Antrojo apskritimo takai t2 = "; cin >> t2;
wcout << L"Treiojo apskritimo spindulys r3 = "; cin >> r3;
wcout << L"Treiojo apskritimo takai t3 = "; cin >> t3;
wcout << L"Ketvirtojo apskritimo spindulys r4 = "; cin >> r4;
wcout << L"Ketvirtojo apskritimo takai t4 = "; cin >> t4;
wcout << L"Strls koordinat x = "; cin >> x;
wcout << L"Strls koordinat y = "; cin >> y;
return 0;
}
raykite ir vykdykite program.
3
Atstumo nuo pataikymo tako iki apskritimo centro skaiiavimas
Norint nagrinti strls padt, reikia inoti jos pataikymo tako atstum iki apskritimo centro.
Papildykite programos kintamj sra nauju realiojo tipo kintamuoju ats.
Paraykite priskyrimo sakin atstumui skaiiuoti:

ats = sqrt((xc - x) * (xc - x) + (yc - y) * (yc - y));
Paraykite sakin, kuris ekran ivest apskaiiuot atstumo ats reikm penki skaitmen po kab-
lelio tikslumu.

71
raykite ir vykdykite program. Patikrinkite, kaip veikia programa:

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
4
Skaiiavim tikslumo vedimas
Nordami suinoti, kur pataik strl nurodyto apskritimo atvilgiu, turime palyginti pataikymo tako atstum
iki apskritimo centro su nagrinjamo apskritimo spinduliu. Tam reikia pasirinkti skaiiavim tikslum.
Apraykite realiojo tipo kintamj tiks, skirt skaiiavim tikslumo reikmei laikyti. Papildykite pro-
gram kintamojo tiks reikms vedimo sakiniais.
raykite ir vykdykite program. Patikrinkite, kaip veikia programa:

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
Skaiiavim tikslumas: 0.00001
5
Pataikymo tako padties nustatymas
Papildykite program nauju sveikojo tipo kintamuoju tsk, skirtu sportininko gautiems takams si-
minti. Paraykite slygin sakin, kuris nustatyt pataikymo tako padt apskritim atvilgiu ir skai-
iuot takus.
Pirmiausia reikia patikrinti, ar pataikymo takas yra ant apskritimo. Jeigu nurodytu tikslumu gauname atsaky-
m, kad jis yra ne ant apskritimo, tuomet galima tikrinti, ar jis viduje, ar iorje. Tokia seka reikalinga tam, kad
isiaikintume, ar skaiiai lygs. Tikrinti pradedame nuo vidinio apskritimo:

72

if (fabs(ats - r1) < tiks) // ar skirtumas maesnis u tikslumo reikm
tsk = t1 / 2; // ant apskritimo linijos
else if (ats < r1) // apskritimo viduje
tsk = t1;
else if (fabs(ats - r2) < tiks)
tsk = t2 / 2;
else if (ats < r2)
tsk = t2;
else if (fabs(ats - r3) < tiks)
tsk = t3 / 2;
else if (ats < r3)
tsk = t3;
else if (fabs(ats - r4) < tiks)
tsk = t4 / 2;
else if (ats < r4)
tsk = t4;
else tsk = 0;
Papildykite program Darbas10 sakiniais, skirtais apskaiiuot tak reikmei ivesti ekran.
raykite ir vykdykite program. Patikrinkite, ar ji veikia teisingai. Paruokite tiek testini duomen
variant, kiek yra sportininko surinkt tak skaiiavimo variant: kiekvienam apskritimui, kai patai-
kymo takas yra jo viduje, ant apskritimo ir jo iorje. Jeigu programos pateikiami rezultatai sutampa
su test rezultatais, tuomet galime teigti, kad programa skaiiuoja teisingai. Tikslinga patikrinti, ar pro-
grama gerai skaiiuoja, kai apskritimas ir pataikymo takas yra skirtingose staiakamps koordinai
ploktumos vietose.
Pasitikrinkite. Kai xc = 60, yc = 80, r1 = 10, t1 = 10, r2 = 15, t2 = 8, r3 = 20, t3 = 6, r4 = 30, t4 = 2,
tiks = 0.00001, x = 75, y = 65, turi bti spausdinama: tsk = 2.
Klausimai
Kodl du realiuosius skaiius reikia lyginti tam tikru tikslumu?
Kodl lyginant du realiuosius skaiius i pradi reikia patikrinti, ar jie lygs, o po to nustatyti, ar pirmasis
didesnis u antrj, ar maesnis?
Uduotis
1. Papildykite program, kad ji skaiiuot takus, kai sportininkas ov i lanko kelis kartus. Tam reikia strls
pataikymo tako koordinai, atstumo ir tak skaiiavimus atlikti cikle. Be to, reikia aprayti papildom
kintamj sportininko vi skaiiui atmintyje laikyti.
Pasitikrinkite. Tarkime, kad xc = 60, yc = 80, r1 = 10, t1 = 10, r2 = 15, t2 = 8, r3 = 20, t3 = 6, r4 = 30, t4 = 2,
tiks = 0.00001, n = 4. Tuomet, kai:
x = 75, y = 65, tai tsk = 2;
x = 65, y = 75, tai tsk = 10;
x = 70, y = 85, tai tsk = 8.
SMALSIEMS
Nuorodos C++ kalbos inyn
3.10. Duomen vedimas i failo
3.12. Funkcijos

1.
2.
73
1
Pradini duomen skaitymas i failo
Pradinius duomenis suraykite tekstin fail, pavyzdiui, TaikinysDuom.txt, taip:

Failas TaikinysDuom.txt Paaikinimai
60 80
10 10
15 8
20 6
30 2
0.00001
Taikinio centro koordinats yra 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 ne vieno vio takai, tai reiks vesti tik strls pataikymo tako koordinates. Jeigu bus kitas tai-
kinys, teks fail duomenis surayti i naujo.
Programos pradioje terpkite fail fstream.
Apraykite pradini duomen globaliuosius kintamuosius.

// Darbas10
#include <fcntl.h>
#include <io.h>
#include <iostream>
#include <iomanip>
#include <cmath>
#include <fstream>
using namespace std;
//---------------------------------------------------------------------
// Globalieji kintamieji
double xc, yc, // taikinio centro koordinats
r1, r2, r3, r4; // taikinio apskritim spinduliai didjimo tvarka
int t1, t2, t3, t4; // skiriami takai atsivelgiant apskritimus
double x, y, // strls pataikymo tako koordinats
tiks; // skaiiavim tikslumas
Papildykite program funkcija duomenims i failo skaityti, funkcijos prototipu ir kreipiniu j. Funk-
cijos tekstas turi bti po funkcija main().

void SkaitytiDuomenis(); // funkcijos prototipas
//----------------------------------------------------------------------------
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
SkaitytiDuomenis(); // duomen skaitymas
return 0;
}
//----------------------------------------------------------------------------
void SkaitytiDuomenis()
{
ifstream fd("TaikinysDuom.txt");
fd >> xc >> yc;
fd >> r1 >> t1;
fd >> r2 >> t2;
fd >> r3 >> t3;
fd >> r4 >> t4;
fd >> tiks;
fd.close();
}
//----------------------------------------------------------------------------

74
raykite ir vykdykite program. Patikrinkite, kaip ji veikia. Jeigu joki klaid nra, tuomet galite siti-
kinti, ar duomenys i failo nuskaityti teisingai. Tam galite parayti kit funkcij:

void RodytiDuomenis()
{
wcout << L"xc = " << setw(5) << fxed << setprecision(2) << xc
<< L"yc = " << setw(5) << fxed << setprecision(2) << yc << endl;
wcout << L"r1 = " << setw(5) << fxed << setprecision(2) << r1
<< L"t1 = " << setw(5) << fxed << setprecision(2) << t1 << endl;
wcout << L"r2 = " << setw(5) << fxed << setprecision(2) << r2
<< L"t2 = " << setw(5) << fxed << setprecision(2) << t2 << endl;
wcout << L"r3 = " << setw(5) << fxed << setprecision(2) << r3
<< L"t3 = " << setw(5) << fxed << setprecision(2) << t3 << endl;
wcout << L"r4 = " << setw(5) << fxed << setprecision(2) << r4
<< L"t4 = " << setw(5) << fxed << setprecision(2) << t4 << endl;
wcout << L"Tikslumas: " << setw(8) << fxed << setprecision(5) << tiks << endl;
}
//----------------------------------------------------------------------------
Funkcija RodytiDuomenis raoma po duomen skaitymo funkcijos.
Funkcijoje main () paraykite kreipin funkcij RodytiDuomenis();.
raykite ir vykdykite program. Patikrinkite, kaip ji veikia. Jeigu joki klaid nra, tuomet ekrane
matysite i failo nuskaitytus 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.00001
2
Atstumo nuo strls pataikymo tako iki apskritimo centro skaiiavimas
Papildykite programos kintamj sra nauju realiojo tipo globaliuoju kintamuoju ats.
Paraykite funkcijoje main() priskyrimo sakin atstumui skaiiuoti:

ats = sqrt((xc - x) * (xc - x) + (yc - y) * (yc - y));
Paraykite sakin, kuris ekran ivest apskaiiuot atstumo ats reikm.
Papildykite program dialogo sakiniais, skirtais strls pataikymo taikin koordinai reikmms
vesti klaviatra.
raykite ir vykdykite program. Patikrinkite, kaip ji veikia. ved pasirinktus duomenis, ekrane ma-
tysime, pavyzdiui, tokias eilutes:

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.00001
Strls koordinat x = 75
Strls koordinat y = 65
Pataikymo tako atstumas iki taikinio centro: 21.21320

75
3
Sportininko surinkt tak skaiiavimas
Papildykite program nauju sveikojo tipo kintamuoju tsk, skirtu takams siminti. Paraykite funkci-
j, kurioje slyginis sakinys patikrint tako padt apskritim atvilgiu ir skaiiuot takus:

//----------------------------------------------------------------------------
void Taskai()
{
if (fabs(ats - r1) < tiks) // ar skirtumas maesnis u tikslumo reikm
tsk = t1 / 2; // ant apskritimo linijos
else if (ats < r1) // apskritimo viduje
tsk = t1;
else if (fabs(ats - r2) < tiks)
tsk = t2 / 2;
else if (ats < r2)
tsk = t2;
else if (fabs(ats - r3) < tiks)
tsk = t3 / 2;
else if (ats < r3)
tsk = t3;
else if (fabs(ats - r4) < tiks)
tsk = t4 / 2;
else if (ats < r4)
tsk = t4;
else tsk = 0;
}
//----------------------------------------------------------------------------
Papildykite program kreipiniu funkcij apskaiiuot tak reikmei ivesti. Funkcija main()bus tokia:

int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
SkaitytiDuomenis(); // duomen skaitymas
RodytiDuomenis(); // duomen rodymas
wcout << L"Strls koordinat x = "; cin >> x;
wcout << L"Strls koordinat y = "; cin >> y;
ats = sqrt ((xc - x) * (xc - x) + (yc - y) * (yc - y));
wcout << L"Pataikymo tako atstumas iki taikinio centro: "
<< setw(10) << fxed << setprecision(5) << ats << endl;
Taskai();
wcout << L"Gauti takai: " << tsk << endl;
return 0;
}
raykite ir vykdykite program. Patikrinkite, kaip ji veikia. Programos skaiiavim rezultat ekrane
pavyzdys:

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.00001
Strls koordinat x = 75
Strls koordinat y = 65
Pataikymo tako atstumas iki taikinio centro: 21.21320
Gauti takai: 2
Uduotis
Tak skaiiavimo slyginis sakinys yra sudtinis. Jeigu taikinyje bt daugiau apskritim, slyginiame sakinyje
reikt nurodyti dar daugiau slyg. Pagalvokite, kaip galima bt supaprastinti tak skaiiavim.

76
2.11. Elektros grandins varos skaiiavimas
Atlikdami darb, susipainsite su ciklo cikle struktra, prisiminsite sumavimo algoritm.
Nuorodos C++ kalbos inyn Nuorodos algoritm inyn
3.7. Ciklo sakinys for 4.2. Cikliniai algoritmai
4.4. Sumos skaiiavimo algoritmas
Uduotis
Reikia parayti program, kuri apskaiiuot bendrj grandins var, kai grandin sudaro viena ar dau-
giau nuosekliai sujungt grandins dali. Kiekviena grandins dalis sudaryta i dviej ar daugiau lygiagreiai
sujungt inomos varos laidinink. inomas nuosekliai sujungt grandins dali skaiius n, kiekvienos dalies
lygiagreiai sujungt laidinink skaiius k ir laidinink var reikms rj.
Programa turi apskaiiuoti bendrj grandins var R ir j ivesti ekran dviej enkl po kablelio tikslumu.
Algoritmas
Tarkime, turime trij nuosekliai sujungt dali (n = 3) grandin:

13
41
1
2
3
4
22
11
24
1
2
9

3
4

6
7
8
Pirmoji grandines dalis
Antroji grandines dalis
Trecioji grandines dalis
Pirmos grandins dalies var skaiius k = 2, var reikms yra 15 ir 41 . Antros grandins dalies var
skaiius k = 4, var reikms yra 1 , 2 , 3 ir 4 . Treios grandins dalies var skaiius k = 3, var
reikms yra 22 , 11 ir 24 .
Skaiiavimams naudojamos formuls:

9 8 7
3
6 5 4 3
2
2 1
1
1 1 1
,
1 1 1 1
,
1 1
R R R
L
R R R R
L
R R
L + + = + + + = + = grandins dali laidumai.
3 2 1
1 1 1
L L L
R + + = bendroji grandins vara.
I fzikos kurso inome, kad lygiagreiai sujungt laidinink bendroji vara R skaiiuojama pagal formul
n
R R R R R
1
...
1 1 1 1
3 2 1
+ + + + = , ia R
1
, R
2
, , R
n
atskir laidinink varos.
Nuosekliai sujungt laidinink bendroji vara skaiiuojama pagal formul R = R
1
+ R
2
+ + R
n
, ia R
1
, R
2
,
R
3
, , R
n
atskir laidinink varos.
Pirmiausia reikia apskaiiuoti atskir grandins dali, kuriose laidininkai sujungti lygiagreiai, varas. Jas su-
sumavus, gaunama bendroji grandins vara.
I pradi apskaiiuokime vienos dalies, sudarytos i k lygiagreiai sujungt laidinink, var. Duomenys ve-
dami klaviatra. Pirmiausia nurodomas laidinink skaiius k, toliau vedamos laidinink varos. Duomenims
nuskaityti reikia naudoti cikl for. Cikle reikia sumuoti atskir laidinink varas. Nepamirkime prie cikl
var sumai priskirti reikm, lygi 0.
77
1
Pasiruoimas
Sukurkite katalog programos failams laikyti. Paleiskite CodeBlocks. Sukurkite programos fail
Darbas11.cpp.
2
Vienos dalies laidinink varos skaiiavimas
Atlikite nurodytus veiksmus:
programos pradioje apraykite naudojamus kintamuosius;
sumos kaupimo kintamajam L priskirkite reikm, lygi 0;
veskite laidinink skaii k;
naudodami cikl for, veskite ir sumuokite laidinink varas;
gaut rezultat iveskite ekran.

// Darbas11
#include <fcntl.h>
#include <io.h>
#include <iostream>
#include <iomanip>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int k, // vienos grandins dalies var skaiius
j; // ciklo kintamasis
double L, // vienos grandins dalies laidumas
rj; // vieno laidininko vara
L = 0;
wcout << L"Laidinink skaiius grandins dalyje "; cin >> k;
for (j = 1; j <= k; j = j + 1){
wcout << L"Laidininko vara "; cin >> rj;
L = L + 1 / rj; // laidum sumavimas
}
wcout << L"Laidinink vara "
<< setw(6) << fxed << setprecision(2) << 1/L << endl;
return 0;
}
raykite ir vykdykite program. Ekrane matysite:

Laidinink skaiius grandins dalyje 2
Laidininko vara 15
Laidininko vara 41
Laidinink vara 10.98
vykdykite i program dar du kartus: apskaiiuokite antros ir treios grandins dali varas.
Antros grandins dalies var turtumte gauti lygi 0.48, treiosios 5.62.
3
Vis grandins dali varos skaiiavimas
Norint apskaiiuoti vis nuosekliai sujungt grandins dali bendrj var, programoje reikia dar vieno ciklo
for. Jis turi apgaubti ankstesnj cikl for.
Atlikite paruoiamuosius veiksmus:
papildykite programos kintamj apraus ciklo kintamuoju i, nuosekliai sujungt grandins dali
skaiiumi n ir visos grandins bendrosios varos kintamuoju R;

78
visos grandins bendrosios varos kintamajam R priskirkite reikm, lygi 0;
veskite grandins dali skaii n;
uraykite cikl for kartu su sakini bloku { ir }, kuris apgaubs ankstesnj (vidin) cikl for;
vidiniam ciklui priklausanius sakinius pastumkite dein programa taps vaizdesn ir supran-
tamesn;
prie baigdami iorin cikl uraykite sakin R = R + 1/L;, kuris susumuos atskir lygiagreiai
sujungt grandins dali varas, apskaiiuotas vidiniame cikle;
rezultato ivedimo sakinyje nurodykite kintamojo R ivedimo format.

// Darbas11
#include <fcntl.h>
#include <io.h>
#include <iostream>
#include <iomanip>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int n, // grandins dali skaiius
k, // vienos grandins dalies var skaiius
j, i; // ciklo kintamieji
double L, // vienos grandins dalies laidumas
rj, // vieno laidininko vara
R; // bendroji grandins vara
R = 0;
wcout << L"Kelios dalys sudaro elektros grandin? "; cin >> n;
for (i = 1; i <= n; i = i + 1) {
L = 0;
wcout << L"Laidinink skaiius grandins dalyje "; cin >> k;
for (j = 1; j <= k; j = j + 1){
wcout << L"Laidininko vara "; cin >> rj;
L = L + 1 / rj; // laidum sumavimas
}
R = R + 1 / L;
}
wcout << L"Bendroji grandins vara "
<< setw(6) << fxed << setprecision(2) << R << endl;
return 0;
}
raykite ir vykdykite program. veskite pradinius duomenis ir pasitikrinkite, ar gavote teising re-
zultat:

Kelios dalys sudaro elektros grandin? 3
Laidinink skaiius grandins dalyje 2
Laidininko vara 15
Laidininko vara 41
Laidinink skaiius grandins dalyje 4
Laidininko vara 1
Laidininko vara 2
Laidininko vara 3
Laidininko vara 4
Laidinink skaiius grandins dalyje 3
Laidininko vara 22
Laidininko vara 11
Laidininko vara 24
Bendroji grandins vara 17.08

79
Klausimai
Kokius paruoiamuosius darbus reikia atlikti prie skaiiuojant sum?
Kokio tipo kintamieji naudojami sumos reikmei laikyti atmintinje?
Kur programoje reikt rayti sumos reikms ivedimo sakin?
Kada naudojama ciklo cikle struktra?
SMALSIEMS
Nuorodos C++ kalbos inyn
3.10. Duomen vedimas i failo
3.11. Rezultat (duomen) ivedimas fail
3.12. Funkcijos
1
Pradini duomen vedimas i failo Duomenys.txt
Sukurkite tekstin fail Duomenys.txt ir j raykite pradinius duomenis:

Failas Duomenys.txt Paaikinimai
3
2 15 41
4 1 2 3 4
3 22 11 24
Nuosekliai sujungt grandins dali skaiius
Pirmos grandins dalies var skaiius ir R
1
bei R
2
reikms
Antros grandins dalies var skaiius ir R
3
, R
4
, R
5
, R
6
reikms
Treios grandins dalies var skaiius ir R
7
, R
8
, R
9
reikms
Papildykite program pradini duomen failo kintamuoju fd.
Paruokite fail duomenims skaityti.
Itrinkite dialogo sakinius:

wcout << L"Kelios dalys sudaro elektros grandin? ";
wcout << L"Laidinink skaiius grandins dalyje ";
wcout << L"Laidininko vara ";
Pakeiskite raymo sakinius.
Baig skaityti, uverkite pradini duomen fail.

// Darbas11
#include <fcntl.h>
#include <io.h>
#include <iostream>
#include <iomanip>
#include <fstream>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int n, // grandins dali skaiius
k, // vienos grandins dalies var skaiius
j, i; // ciklo kintamieji
double L, // vienos grandins dalies laidumas
rj, // vieno laidininko vara
R; // bendroji grandins vara
R = 0;
ifstream fd("Duomenys.txt");
fd >> n;
1.
2.
3.
4.

80

for (i = 1; i <= n; i = i + 1) {
L = 0;
fd >> k;
for (j = 1; j <= k; j = j + 1) {
fd >> rj;
L = L + 1 / rj; // laidum sumavimas
}
R = R + 1 / L;
}
fd.close();
wcout << L"Bendroji grandins vara "
<< setw(6) << fxed << setprecision(2) << R << endl;
return 0;
}
raykite ir vykdykite program. Jei visk atlikote teisingai, ekrane turtumte matyti:

Bendroji grandins vara 17.08
2
Rezultato raymas fail Rezultatai.txt
Pakeiskite rezultato ivedimo sakin
wcout << L"Bendroji grandins vara "
<< setw(6) << fxed << setprecision(2) << R << endl;
tokiais sakiniais:

ofstream fr("Rezultatai.txt");
fr << setw(6) << fxed << setprecision(2) << R <<endl;
fr.close();
raykite ir vykdykite program.
Atvr rezultat fail komanda Open..., pamatysite skaii 17.08. Vadinasi, pagal uduot parayta programa
atlieka visus skaiiavimus teisingai ir rezultatus pateikia ten, kur ir reikia, t. y. rezultat faile.
3
Programos struktrizavimas naudojant funkcij su parametraisnuorodomis
Sudarykite funkcij, kuri apskaiiuot vienos grandins dalies lygiagreiai sujungt laidinink var,
t. y. vidin ciklo cikle dal apraykite funkcija. J pavadinkite RastiRGrandies(). Funkcijai reikia
pateikti atverto duomen srauto kintamj fd. Prie j btina parayti &. Nepamirkite likusiame pa-
grindins funkcijos main() cikle parayti kreipin i funkcij.

// Darbas11
#include <fcntl.h>
#include <io.h>
#include <iostream>
#include <iomanip>
#include <fstream>
using namespace std;
//----------------------------------------------------------------------------
void RastiRGrandies(ifstream & fd, double & R);
//----------------------------------------------------------------------------
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
int n, // grandins dali skaiius
i; // ciklo kintamasis
double gr, // vienos grandies vara
R; // bendroji grandins vara

81

ifstream fd("Duomenys.txt");
fd >> n;
R = 0;
for (i = 1; i <= n; i++){
RastiRGrandies(fd, gr);
R = R + gr;
}
fd.close();
wcout << L"Bendroji grandins vara "
<< setw(6) << fxed << setprecision(2) << R << endl;
return 0;
}
//----------------------------------------------------------------------------
// Apskaiiuoja lygiagreiai sujungt laidinink var
// fd duomen srauto vardas
// R apskaiiuota vara
void RastiRGrandies(ifstream & fd, double & R)
{
int
k, // vienos grandins dalies var skaiius
j; // ciklo kintamasis
double L, // vienos grandins dalies laidumas
rj; // vieno laidininko vara
L = 0;
fd >> k;
for (j = 1; j <= k; j = j + 1){
fd >> rj;
L = L + 1 / rj; // laidum sumavimas
}
R = 1 / L;
}
raykite ir vykdykite program. Ekrane matysite tok pat rezultat, kaip ir ankstesns programos ver-
sijos.
4 Programos struktrizavimas naudojant funkcij, grinani reikm
per funkcijos vard
Pabandykite sukurt funkcij RastiRGrandies() pakeisti funkcija RGrandies():
double RGrandies(ifstream & fd)
{
int
k, // vienos grandins dalies var skaiius
j; // ciklo kintamasis
double L, // vienos grandins dalies laidumas
rj, // vieno laidininko vara
R;
L = 0;
fd >> k;
for (j = 1; j <= k; j = j + 1){
fd >> rj;
L = L + 1 / rj; // laidum sumavimas
}
R = 1 / L;
return R;
}
pagrindins funkcijos main() cikle for raykite sakin
R = R + RGrandies(fd);
raykite ir vykdykite program. Ekrane matysite tok pat rezultat, kaip ir ankstesns programos ver-
sijos.

82
Uduotys
1. Tekstinio failo Mokiniai.txt pirmoje eilutje raytas klass mokini skaiius n. Tolesnse eilutse surayti
kiekvieno mokinio metiniai paymiai (po 5 paymius). Vieno mokinio paymiai pateikti vienoje eilutje ir
vienas nuo kito atskirti tarpais. Paraykite program, kuri apskaiiuot kiekvieno mokinio paymi arit-
metin vidurk dviej enkl po kablelio tikslumu ir rezultat fail Vidurkiai.txt rayt mokini numerius
bei paymi vidurkius.
Pasitikrinkite. Pradini duomen ir rezultat tekstiniuose failuose turt bti rayta:
Mokiniai.txt Vidurkiai.txt
3
7 8 9 7 8
5 7 9 5 7
6 8 7 9 7
1 7.80
2 6.60
3 7.40
2. Tekstinio failo Troleibusai.txt pirmoje eilutje raytas miesto troleibus skaiius n. Kitose eilutse rayta
informacija apie kiekvien troleibus: pirmasis skaiius rodo, keliose stotelse troleibusas sustoja, o toles-
ni atstumus (metrais) tarp gretim troleibuso marruto stoteli. Paraykite program, kuri apskaiiuot
ir rezultat fail Marsrutai.txt rayt kiekvieno troleibuso marruto ilg.
Pasitikrinkite. Pradini duomen ir rezultat tekstiniuose failuose turt bti rayta:
Troleibusai.txt Marsrutai.txt
3
3 200 500
5 200 200 150 300
4 150 200 150
700
850
500

83
C++ KALBOS INYNAS
Programavimo kalbos C++ pirmtakas buvo programavimo kalba C, kuri
1972 m. sukr Kenas Tompsonas (Ken Tompson) ir Denis Riis (Dennis
M. Ritchie). I pradi C kalba buvo tik sisteminio programavimo darbinis
instrumentas ir nepretendavo platj pritaikym. Vliau dl ios kalbos vi-
sapusikumo, ji tapo populiaria taikomojo ir sisteminio programavimo kal-
ba. C kalba tai procedrinio programavimo kalba. Ji yra nepriklausoma nuo
kompiuterio technini charakteristik ir operacins sistemos, patogi, raiki,
lanksti, turinti paprast sintaks.
1983 m. Bjornas Stroustrupas (Bjarne Stroustrup) sukr C++ programavimo
kalb, skirt objektinio programavimo technologijai. C++ kalba sudaryta taip,
kad C kalba ilikt jos poaibiu. Todl daugelis program, parayt C kalba, yra
ir C++ kalbos programomis. Nuo 1990 m. C++ kalba yra viena populiariausi
programavimo kalb.
C++ kalba neturi versij. 1998 m. patvirtintas C++ kalbos ANSI/ISO standartas. Jis apibria kalbos pagrindus ir jos stan-
dartines bibliotekas. 2003 m. patvirtintas kitas kalbos standartas Standard C++.
3.1. Kintamasis, kintamojo reikm
Programos atlieka veiksmus su duomenimis (pvz.: sveikaisiais, realiaisiais skaiiais; simboliais; simboli eilu-
tmis). Duomenys gali bti pastovs (pvz., gimimo data) ir kintami (pvz., amius). Duomenys, kurie atliekant
program nekinta, vadinami konstntomis.
Kintamieji skirti duomenims, kuri reikms keiiasi atliekant program, atmintyje laikyti. J varda sudaromi
i raidi ir skaitmen, taiau pirmas enklas turi bti raid. Parenkant kintamj vardus reikia stengtis, kad jie
paymt duomen paskirt. Pavyzdiui, jei skaiiuojame trij skaii sum, tai juos atitinkanius kintamuosius
patogu ymti a, b, c, o sum vardu suma. Kintamieji gali bti apraomi bet kurioje programos vietoje, bet prie
juos panaudojant veiksmuose. Daniausiai jie apraomi funkcijos main() pradioje. Kiekvienam kintamajam
reikia nurodyti, kokio tipo duomenis jis turi laikyti atmintyje. Duomen tipas apibria tam tikr aib reikmi ir
veiksm, kuriuos galima atlikti su tomis reikmmis.
Lentelje pateikiami daniausiai naudojami duomen tipai:

Tipo pavadinimas Galim reikmi intervalas
int 2147483648 .. 2147483647
double 2.2310
308
.. 1.7910
308

char Vienas simbolis, pavyzdiui: 'A', '8', '+' arba skaiius 128 .. 127
bool true (1), false (0)
Kintamieji apraomi taip:
duomenTipas kintamojoVardas;
Kintamojo duomenTip nustato programuotojas. Jeigu yra keletas to paties tipo kintamj, tuomet juos ga-
lima ivardyti viename sakinyje, atskiriant vardus kableliu.
Kintamj apraymo pavyzdys:
double a, b, c, y; // realiojo tipo kintamieji
int i, k, a2; // sveikojo tipo kintamieji
char simb; // simbolinio tipo kintamasis
Dan mokslininkas Bjornas Stroustrupas
(Bjarne Stroustrup), sukrs struktrinio
programavimo kalb C++.
Gim 1950 m.
84
Vykdant program, kiekvienam kintamajam kompiuterio atmintyje skiriama tiek vietos, kiek reikia nurody-
to tipo duomenims laikyti. Kintamieji atmintyje gali laikyti tik nurodyto tipo duomen rikmes. Kintamieji
reikmes (duomenis) gauna duomen vedimo (skaitymo) sakinias, kai kintamiesiems reikms suteikiamos
imant jas i iorini rengini (klaviatros, diskini ir kit ilgalaiks atminties rengini), arba priskyrimo
sakinias, kai kintamiesiems reikms suteikiamos programos tekste. Pavyzdiui, kintamiesiems reikmes gali-
ma priskirti j apraymo sakiniuose taip:
duomenTipas kintamojoVardas = pradinReikm;
Pavyzdiui:
double pi = 3.1415;
char a = 'A';
int k = 5 / 3;
bool status = false;
int k = 5, b = 15;
Kintamojo galiojimo pradia jo apraymo vieta. Kintamasis galioja tame programos bloke, kuriame jis yra ap-
raytas. Blok sudaro programavimo kalbos sakini seka, parayta tarp riestini skliaust {}. Jis skiriasi nuo
sudtinio sakinio tuo, kad jame yra ir sakiniai, ir kintamj apraai. Daniausiai blokas naudojamas funkcijoms
urayti.
Sudtinis sakinys tai tarp riestini skliaust { } parayta sakini seka.
Sudtinio sakinio pavyzdys:

{
n = n + 1;
suma = suma + n;
}
Apraant kintamuosius, reikia prisiminti:
Kintamieji, aprayti prie pagrindin funkcij main(), vadinami globaliaisiais. Jie galioja visoje pro-
gramoje.
Kintamieji, aprayti funkcijoje, vadinami lokaliaisiais. Jie galioja tik toje funkcijoje, ijus u funkcijos
rib, i kintamj reikms neisaugomos.
Jei kintamasis tokiu paiu vardu apraytas prie pagrindin funkcij main() ir funkcijoje, pirmenyb
suteikiama lokaliajam, t. y. funkcijoje globalusis kintamasis negalioja.
3.2. Priskyrimo sakinys
Priskyrimo sakinys naudojamas, kai kintamajam reikia suteikti reikm programos tekste. Priskyrimo sakinio
struktra tokia:
kintamojoVardas = Reikinys;
ia simbolis = ymi priskyrimo operacij, o Reikinys nurodo, kokius veiksmus, kokia tvarka ir su kokiais
argumentais reikia atlikti. Kairiojoje priskyrimo operacijos pusje raytas kintamojo vardas nurodo, kam at-
mintyje suteikiama apskaiiuota reikinio reikm. Pavyzdiui, priskyrimo sakinys y = x * x; reikia, kad
argumento x reikm keliama kvadratu ir rezultatas priskiriamas kintamajam y.
Btina, kad priskyrimo operacijos kairje pusje nurodyto kintamojo tipas atitikt reikinio, esanio deinio-
joje pusje, reikms tip.
Reikiniuose galima naudoti tik tokius kintamuosius, kuri reikms apibrtos anksiau raytuose programos
sakiniuose.
Skiriami trys reikini tipai:
Aritmtinis. Tai reikinys, kuriame kintamieji ir konstantos jungiamos aritmetini operacij enklais
(+, , *, /, sveikj skaii dalmens liekana %). Tokio reikinio skaiiavimo rezultatas yra skaiius.
Pavyzdiui:
a = 5; b = 7; c = 9;
s = a * b c;

85
Rezultato tipas priklauso nuo j sudarani argument tip ir operacij, atliekam su argumentais. Jei
visi argumentai yra sveikojo tipo, tai vis operacij, atliekam su iais argumentais, rezultatas yra svei-
kojo tipo. Tuomet dalybos operacijos (ji ymima /) rezultatas visada yra sveikoji gautos dalybos dalis.
Schemoje pavaizduoti dviej tip argumentai, su jais atliekamos operacijos ir rezultatas (I ymi sveikj
duomen tip, R realj).

I I
+
-
*
/
%
=
I
I R
+
-
*
/
=
R
Sntykio. Tai du aritmetiniai reikiniai, tarp kuri raomas santykio operacijos enklas (>, <, <=, >=,
!=, ==). Tokio reikinio rezultatas yra login reikm true (tiesa) arba false (netiesa). Pavyzdiui,
k = 5 != 7 2;
Atlikus priskyrimo sakin kintamojo k reikm lygi false, nes reikinys 5 5 yra neteisingas.
Lginis. Tai reikinys, kuriame naudojami logini operacij enklai. C++ jie ymimi enkl grupmis
&& (IR), || (ARBA), ! (NE). Tokio reikinio rezultatas yra login reikm true arba false.
Pavyzdiui:
a = true; b = false;
a = !a || b;
Pateikiame logini reikini teisingumo lentel.

Kintamj reikms Logini reikini rezultatai
a b a && b a || b ! a
true true true true false
true false false true false
false true false true true
false false false false true
Priskyrimo sakinio raymo forma tokia pati, kaip ir lygybs iraikos, taiau ios struktros prasm i esms
skiriasi. Lygybmis patvirtinamas tam tikras faktas. Tuo tarpu priskyrimo sakiniai aprao procesus, kuriems
bdinga reikmi kaita, 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
a
(nauja)
= a
(sena)
+ 1.
Pavyzdiui, atlikus sakini sek
a = 5;
a = a + 1;
kintamojo a reikm lygi 6.

86
3.3. vedimo ir ivedimo srauto samprata
Kalboje C++ vedimo / ivedimo sistema yra susijusi su srauto svoka. vedimo / ivedimo srautas tai loginis
renginys, kuris iveda ir priima naudotojo informacij. vedimo / ivedimo sistema susieja sraut su fziniu
renginiu (klaviatra, ekranu, disk taisais). Visi vedimo / ivedimo srautai veikia vienodai nepriklausomai
nuo fzini rengini charakteristik.
Paleidus C++ program, automatikai atidaromi keturi srautai:
cin vedimas (klaviatra);
cout ivedimas (ekranas);
cerr praneimai apie klaidas (ekranas);
clog buferizuota cerr versija (ekranas).
Paprastai ie srautai yra naudojami darbui su klaviatra ir ekranu.
Darbo priemons su vedimo / ivedimo srautais yra saugomos faile iostream. iame faile apibrti klasi
rinkiniai, kurie leidia atlikti vedimo / ivedimo operacijas.
Klas tai darinys, kuriame saugomi kintamieji ir metodai funkcijos, taikomos darbui su klass kintamj
reikmmis.
Antratinio failo iostream priemons perkeliamos program sakiniu:
#include <iostream>
Duomenims nuskaityti i srauto naudojamas operatorius >>, ivesti sraut operatorius <<.
3.4. Duomen vedimas klaviatra
Duomenims vesti i standartinio vedimo srauto cin, paprastai susieto su klaviatra, ir / arba i srauto, susieto
su failu, daniausiai naudojamas operatorius >>. Asmeniniuose kompiuteriuose standartinis vedimo taisas
yra klaviatra.
Duomen vedimo procesas vykdomas dviem etapais: pirmiausia duomenys vedami klaviatra, po to jie pri-
skiriami kintamiesiems. I pradi vedimo operatorius >> stabdo programos darb ir laukia, kol klaviatra
vedami duomenys. Duomenys kaupiami specialioje atmintyje (buferyje) ir vaizduojami ekrane. vedimo metu
jie gali bti taisomi prastinmis teksto redagavimo priemonmis. Spusteljus vedimo klavi Enter (), bufe-
ryje laikomi duomenys paskirstomi vedimo srauto cin srae ivardytiems kintamiesiems, kurie nurodo, kiek
kokio tipo duomen reikia vesti ir kokia tvarka juos paskirstyti programos kintamiesiems.
Pavyzdiui, jei buvo sakinys cin >> a >> b;, taiau vestas tik vienas skaiius 25, kintamajam a bus suteikta
reikm 25 ir kompiuteris lauks, kol bus vesta kintamojo b reikm. Jei, vykdant sakin cin >> a >> b;,
vestos trys reikms 25 -5 10, tai kintamiesiems a ir b bus paskirstytos pirmosios dvi reikms, o treioji liks
buferyje ir lauks naujo skaitymo veiksmo. vedant duomenis viena eilute, reikms atskiriamos tarpais.
Prie kreipiantis vedimo sraut cin, patariama rayti ivedimo sakin, kuris paaikint, koki duomen reikia
programai. Tokia ivedimo ir vedimo sakini pora danai dar vadinama duomen uklausa (arba dialogu). Pa-
vyzdiui, norint vesti mokinio svor (kintamasis sv) reikt programoje rayti toki uklaus:
cout << "veskite mokinio svor: "; cin >> sv;

veskite mokinio svor: 40
i uklausa rodo, kad kompiuteris ekrane turi suformuoti praneim veskite mokinio svor ir laukti, kol
klaviatra bus vestas skaiius (svoris).
3.5. Rezultat (duomen) ivedimas ekran
Duomenims ivesti standartin ivedimo sraut cout, paprastai susiet su ekranu, ir / arba sraut, susiet su
failu, daniausiai naudojamas operatorius <<.
Ivedam duomen srauose galima nurodyti kintamuosius, konstantas, reikinius ir tekstinius duomenis.
87
Paaikinimus btina rayti tarp kabui. Pavyzdiui, uraius sakin
cout << "Sveiki! Js programa pradeda darb!" << endl;
ekran ivedamas toks tekstas:

Sveiki! Js programa pradeda darb!
Antrasis argumentas endl yra konstanta, kurios reikm yra simbolis '\n' perjimas nauj eilut. sim-
bol galima terpti ivedam tekst. Pavyzdiui, sakinys

cout << "Sveiki! Js programa pradeda darb!\n";
ekrane pateiks t pat rezultat:

Sveiki! Js programa pradeda darb!
Ivedant duomenis, galima nurodyti j ivedimo format. Tam naudojami manipuliatoriai specials nu-
rodymai, kurie terpiami ivedimo sraut. Manipuliatoriai yra dviej tip su argumentais ir be j. Norint
pasinaudoti manipuliatoriais su argumentais, btina perkelti program priemones, kurios yra antratiniame
faile iomanip, tokiu sakiniu:
#include <iomanip>
Lentelje pateiktas daniausiai naudojam manipuliatori sraas.
Manipuliatorius Paskirtis
left Ivedant duomenis, jie lygiuojami pagal kairj krat
right Ivedant duomenis, jie lygiuojami pagal deinj krat
endl sraut nusiunia eilui skyriklio simbol '\n' ir ivalo bufer
setw(int n) Nustato ivedam duomen lauko plot n
setprecision(int n) Nustato realiojo skaiiaus ivedam skaitmen skaii n.
Jeigu skaiius sveikojoje dalyje turi daugiau skaitmen, tuomet jis vaizduo-
jamas standartine iraika, kurioje yra daugiklis 10
n
. Laipsnio pagrindas
ymimas simboliu e ir po jo raomas laipsnio rodiklis. Pavyzdiui, uraas
3.1416e+006 atitinka skaii 3.1410
6
.
Jeigu prie manipuliatori setprecision raomas manipuliatorius fxed,
tuomet n nustato, kiek realiojo skaiiaus trupmenins dalies skaitmen reikia
ivesti, skaitant ir nulius skaiiaus gale, pavyzdiui, 3141592653.400
Ivedimo sraute galima nurodyti, kiek pozicij ekrane skirti atskiriems duomenims. Nurodymai raomi prie
ivedamus duomenis. Pavyzdiui:

int a = 45;
double b = 123.258;
cout << a;
cout << setw(5) << a << " "
<< fxed << setprecision(2) << b;
Ekrane matysime:

Realaus skaiiaus trupmeninei daliai ivesti nurodyt pozicij skaiius per maas, todl buvo ivesti tik du
skaitmenys po kablelio, paskutinis suapvalintas.
88
3.6. Ciklo sakinys while
Ci `klas yra naudojamas pasikartojantiems veiksmams atlikti. Labai danai veiksmai kartojami tol, kol tenkina-
ma nurodyta slyga. Tokiais atvejais naudojamas ciklo sakinys while. Jeigu reikia kartoti kelis sakinius, tai jie
raomi tarp { ir }:

while (Slyga)
KartojamasSakinys;
while (Slyga) {
KartojamiSakiniai;
};
Slyga tai bet koks loginis ar santykio reikinys, KartojamasSakinys bet koks sakinys (taip pat ir ciklo).
Vykdant sakin while pirmiausia patikrinama Slyga: jei jos reikm yra true, tuomet atliekamas
KartojamasSakinys, prieingu atveju jis praleidiamas ir atliekami toliau u ciklo esantys sakiniai. Jei kartoti
reikia ne vien sakin, raomas sudtinis sakinys { }.
tai keletas ciklo while pavyzdi.
1 pavyzdys

x = 10;
while (x < 15)
x = x + 1;

Ciklo ingsniai Slyga: x < 15 Kintamojo x reikm: x = x + 1
1 10 < 15 true x = 10 + 1 = 11
2 11 < 15 true x = 11 + 1 = 12
3 12 < 15 true x = 12 + 1 = 13
4 13 < 15 true x = 13 + 1 = 14
5 14 < 15 true x = 14 + 1 = 15
6 15 < 15 false Veiksmai neatliekami, nes netenkinama slyga
Ciklas atlikamas 5 kartus. Atlikus veiksmus, kintamojo x reikm lygi 15.
2 pavyzdys

x = 10; y = 14;
while (x <= y) {
x = x + 1;
y = y 1;
}

Ciklo
ingsniai
Slyga:
x <= y
Kintamojo x reikm:
x = x + 1
Kintamojo y reikm:
y = y 1
1 10 <= 14 true x = 10 + 1 = 11 y = 14 1= 13
2 11 <= 13 true x = 11 + 1 = 12 y = 13 1 = 12
3 12 <= 12 true x = 12 + 1 = 13 y = 12 1 = 11
4 13 <= 11 false Veiksmai neatliekami, nes netenkinama slyga
Ciklas atliekamas 3 kartus. Atlikus veiksmus, kintamojo x reikm lygi 13, kintamojo y reikm yra 11.
89
3 pavyzdys

x = 5;
while (x > 10) // 5 > 10 (slyga netenkinama, veiksmai cikle neatliekami)
x = x + 3;
x = x * 2 + 3; // x = 5 * 2 + 3 = 13.
Ciklas neatliekamas n karto. Atliekamas u ciklo esantis sakinys, kintamojo x reikm lygi 13.
4 pavyzdys

x = 7; y = 8;
while (x <= y)
x = x - 2;

Ciklo ingsniai Slyga: x <= y Kintamojo x reikm: x = x + 1
1 7 <= 8 true x = 7 2 = 5
2 5 <= 8 true x = 5 2 = 3
3 3 <= 8 true x = 3 2 = 1
4 1 <= 8 true x = 1 2 = 1
5 Slyga visada bus teisinga
Ciklas atliekamas be galo daug kart. Tai aminsis ciklas.
Naudojant neinomo kartojim skaiiaus cikl while, reikia atkreipti dmes iuos dalykus:
jeigu ciklo viduje reikia vykdyti kelis sakinius, tai jie turi bti raomi tarp { ir };
jei prie pradedant cikl Slyga yra netenkinama (false), KartojamasSakinys (ar sakini grup) ne-
vykdomas n karto;
kintamiesiems, kurie yra slygos reikinyje, prie sakin while esanioje programos dalyje turi bti
suteiktos pradins reikms. Ciklo viduje i kintamj reikms turi bti keiiamos taip, kad kada
nors Slyga tapt false. Kitu atveju ciklas bus vykdomas be galo daug kart.
3.7. Ciklo sakinys for
Kai i anksto inoma, kiek kart reikia kartoti veiksmus, naudojamas inomo kartojim skaiiaus ciklas for.
Ciklo for antrat valdo tik vieno sakinio kartojim. Jeigu reikia kartoti kelis sakinius, tai jie raomi tarp { ir }.
Ciklo for sintaks yra tokia:

for (R1; Slyga; R2)
KartojamasSakinys;
for (R1; Slyga; R2) {
KartojamiSakiniai;
}
R1 priskyrimo sakinys, Slyga bet koks santykio arba loginis reikinys, R2 priskyrimo sakinys,
KartojamasSakinys (KartojamiSakiniai) bet koks sakinys (sakiniai).
Formaliai ciklo for veiksmus galima aprayti taip:
Vykdomas sakinys R1. Paprastai jis naudojamas ciklo kintamojo (kintamasis, kuris vartojamas ciklo pabai-
gai apibrti) pradinei reikmei priskirti. Sakinys R1 vykdomas tik pirm kart.
Patikrinama Slyga. Jei jos reikm yra true, tuomet atliekamas KartojamasSakinys (arba KartojamiSakiniai).
Prieingu atveju ciklas nutraukiamas.
Vykdomas sakinys R2. Jis nurodo, kaip turi bti apskaiiuojama ciklo kintamojo reikm. Veiksmai karto-
jami nuo 2 ingsnio.

1.
2.
3.
90
Naudojant inomo kartojim skaiiaus cikl, reikia atkreipti dmes iuos dalykus:
jeigu ciklo viduje reikia vykdyti kelis sakinius, tai jie turi bti raomi tarp { ir };
jei prie pradedant cikl Slyga yra netenkinama (false), KartojamasSakinys (ar sakini grup) ne-
vykdomas n karto;
kintamiesiems, kurie yra slygos reikinyje, prie patikrinant Slyg pirm kart turi bti suteiktos
pradins reikms. Jos gali bti nurodomos prie cikl arba sakinyje R1 priskyrimo sakiniu, kurie atski-
riami kableliu. Ciklo viduje kintamj, kurie yra slygos reikinyje, reikms turi bti keiiamos taip,
kad kada nors Slyga tapt false. Kitu atveju ciklas bus vykdomas be galo daug kart. Toks ciklas
vadinamas aminoju ciklu.
Pateikiame ciklo for naudojimo pavyzdi.
1 pavyzdys

m = 10; n = 12;
for (i = m; i <= n; i = i + 1)
cout << i << endl;

Ciklo ingsniai Kintamojo i reikm Slyga: i <= 12 Ekrane matysite
1 10 10 <= 12 true 10
2 11 11 <= 12 true 11
3 12 12 <= 12 true 12
4 13 13 <= 12 false
Ciklas atliekamas 3 kartus.
2 pavyzdys

m = 10; n = 12; k = 5;
for (i = m; i <= n; i = i + 1) {
k = k + 2;
cout << i << " " << k << endl;
}

Ciklo
ingsniai
Kintamojo i
reikm
Slyga: i <= 12 Kintamojo k
reikm
Ekrane matysite
1 10 10 <= 12 true 7 10 7
2 11 11 <= 12 true 9 11 9
3 12 12 <= 12 true 11 12 11
13 <= 12 false
Ciklas atliekamas 3 kartus.
3 pavyzdys

m = 12; n = 10;
for (i = m; i <= n; i = i + 1)
cout << i << endl;
cout << i << endl;

Ciklo ingsniai Kintamojo i reikm Slyga: i <= 10 Ekrane matysite
12 12 <= 10 false 12
Ciklas neatliekamas, nes pradin ciklo kintamojo reikm yra didesn u galutin. Atliekamas sakinys, esantis
u ciklo.

91
4 pavyzdys

m = 12; n = 10;
for (i = m; i >= n; i = i - 1)
cout << i << endl;

Ciklo ingsniai Kintamojo i reikm Slyga: i >= 10 Ekrane matysite
1 12 12 >= 10 true 12
2 11 11 >= 10 true 11
3 10 10 >= 10 true 10
9 9 >= 10 false
Ciklas atliekamas 3 kartus.
5 pavyzdys

for (i = 0; ; i = i + 1)
cout << i;
Ciklas yra aminasis (begalinis), nes nra Slygos.
3.8. Slyginis sakinys if
Slygini skiniu programoje keiiama nuosekli sakini atlikimo tvarka: jei Slyga tenkinama, atliekamas
PirmasSakinys, jei ne po else esantis AntrasSakinys. Jeigu reikia atlikti kelis sakinius, kai Slyga tenkinama
arba netenkinama, tai jie raomi tarp { ir }. Slyga bet koks santykio arba loginis reikinys.

if (Slyga) PirmasSakinys;
else AntrasSakinys;
if (Slyga) {
Sakiniai, kurie atliekami, kai Slyga tenkinama;
}
else {
Sakiniai, kurie atliekami, kai Slyga netenkinama;
}
Slyga tai bet koks loginis ar santykio reikinys, PirmasSakinys, AntrasSakinys bet koks sakinys.
Pateikiame kelet slyginio sakinio pavyzdi.

Pavyzdiai Slyga Ekrane matysite
x = 4;
if (x < 9) y = x + 3;
else y = x + 5;
cout << y;

4 < 9

true
7
x = 14;
if (x < 9) y = x + 3;
else y = x + 5;
cout << y;

14 < 9

false
19
x = 4;
if (x < 9) {
x = x + 2;
y = x * 3;
}
else {
x = x 5;
y = x * 5;
}
cout << x << " " << y;

4 < 9

true
6 18
92

Pavyzdiai Slyga Ekrane matysite
x = 14;
if (x < 9) {
x = x + 2;
y = x * 3;
}
else {
x = x 5;
y = x * 5;
}
cout << x << " " << y;

14 < 9

false
9 45
Galima rayti sutrumpint slygin sakin, kuriame yra tik PirmasSakinys ir veiksmai atliekami tik tuomet, kai
Slyga tenkinama.

if (Slyga) PirmasSakinys; if (Slyga) {
Sakiniai, kurie atliekami, kai Slyga tenkinama;
}
tai keletas toki slygini sakini pavyzdi.

Pavyzdiai Slyga Ekrane matysite
x = 4; y = 14;
if (x < 9) y = x + 3;
cout << y;

4 < 9

true
7
x = 14; y = 14;
if (x < 9) y = x + 3;
cout << y;

14 < 9

false
14
Slyginio sakinio akose galima urayti bet kokius C++ kalbos sakinius. Bet kurioje slyginio sakinio ako-
je galima urayti dar vien slygin sakin, pastarojo akose dar po vien ir t. t. Toks sakinys vadinamas
sudtingu slygini sakiniu.

if (Slyga1)
if (Slyga2)
PirmasSakinys;
else AntrasSakinys;
else TreiasSakinys;
if (Slyga1)
if (Slyga2)
if (Slyga3)
PirmasSakinys;
else if (Slyga4) AntrasSakinys;
Pavyzdiui, nordami patikrinti, kuriame koordinai ploktumos ketvirtyje (arba koordinai ayje) yra ta-
kas (x; y), galime urayti tok slygin sakin:
if ((x > 0) && (y > 0)) cout << "I ketvirtis " << endl;
else if ((x < 0) && (y > 0)) cout << "II ketvirtis " << endl;
else if ((x < 0) && (y < 0)) cout << "III ketvirtis " << endl;
else if ((x > 0) && (y < 0)) cout << "IV ketvirtis " << endl;
else if ((x == 0) && (y != 0)) cout << "Y ais " << endl;
else if ((x != 0) && (y == 0)) cout << "X ais " << endl;
else cout << "Koordinai pradia " << endl

93
3.9. Knygoje naudojam ir / ar rekomenduojam
matematini funkcij sraas
Funkcija Paskirtis
int abs(int x); Grina sveikojo skaiiaus x absoliutj didum. Esant teigiamam ar
neigiamam funkcijos parametrui, rezultatas yra teigiamas.
Pavyzdys:
int x = -10;
cout << "Sveikojo skaiiaus " << x
<< " modulis yra " << abs(x) << endl;
Ekrane matysite:
Sveikojo skaiiaus -10 modulis yra 10
double fabs(double x); Grina realiojo skaiiaus x absoliutj didum.
Pavyzdys:
double x = -15.5;
cout << "Realiojo skaiiaus " << x
<< " modulis yra " << fabs(x) << endl;
Ekrane matysite:
Realiojo skaiiaus -15.5 modulis yra 15.5
double pow(double x, double y); Skaii x kelia laipsniu y. (Jei y yra 0.5, tai funkcija skaiiuoja
neneigiamo argumento x kvadratin akn.)
Pavyzdys:
int x = 15, y = 3;
cout << "Skaiius " << x
<< " pakeltas laipsniu " << y
<< ": " << pow(x, y) << endl;
Ekrane matysite:
Skaiius 15 pakeltas laipsniu 3: 3325
double sqrt(double x); Skaiiuoja neneigiamo argumento x kvadratin akn.
Pavyzdys:
double x = 15.5;
cout << "Kvadratin aknis i realiojo skaiiaus "
<< x << " yra "
<< sqrt(x) << endl;
Ekrane matysite:
Kvadratin aknis i realiojo skaiiaus 15.5 yra
3.937
int random(int Riba); Grina atsitiktin sveikj skaii i intervalo [0; Riba).
Pavyzdys:
cout << "Atsitiktinis skaiius intervale 0-99: "
<< random(100) << endl;
Ekrane matysite:
Atsitiktinis skaiius intervale 0-99: 84
int rand(void); Grina atsitiktin sveikj skaii i intervalo [0; RAND_MAX].
Konstanta RAND_MAX daniausiai lygi 32767. Norint pasinaudoti kon-
stanta RAND_MAX, reikia prie programos prijungti fail stdlib.h
sakiniu #include <stdlib.h>
Pavyzdys:
cout << "Atsitiktinis skaiius: " <<
<< rand() << endl;
Ekrane matysite:
Atsitiktinis skaiius: 130
94
void randomize(void); Priskiria pradin reikm atsitiktini skaii generatoriui.
Funkcijos random() ir rand() visada generavim pradeda nuo tos
paios reikms ir skaiius generuoja tokia paia seka. Taiau, jei prie
kreipimsi ias funkcijas, kreipiamasi funkcij randomize(), tuomet
funkcijos random() ir rand() kiekvien kart generuos skirting
skaii sekas.
(Jei atsitiktiniai skaiiai generuojami atliekame cikle, tuomet kreiptis
funkcij randomize() reikia prie cikl.)
Pavyzdys:
randomize();
cout << "Funkcijos random() pateiktas skaiius: "
<< random(1000) << endl;
<< "Funkcijos rand() pateiktas skaiius: "
<< rand() << endl;
Ekrane matysite:
Funkcijos random() pateiktas skaiius: 540
Funkcijos rand() pateiktas skaiius: 2599
double cos(double x); Skaiiuoja argumento x, pateikiamo radianais, kosinus.
Pavyzdys:
double x = 0;
cout << "Kosinusas " << x << " yra "
<< cos(x) << endl;
Ekrane matysite:
Kosinusas 0 yra 1
double sin(double x); Skaiiuoja argumento x, pateikiamo radianais, sinus.
Pavyzdys:
double x = 0;
cout << "Sinusas " << x << " yra "
<< sin(x) << endl;
Ekrane matysite:
Sinusas 0 yra 0
double tan(double x); Skaiiuoja argumento x, pateikiamo radianais, tangent.
Pavyzdys:
double x = 0;
cout << "Tangentas " << x << " yra "
<< tan(x) << endl;
Ekrane matysite:
Tangentas 0 yra 0
3.10. Duomen vedimas i failo
Kai pradini duomen daug, juos vedinti klaviatra nra patogu. Be to, norint skaiiavimus pakartoti, reikia
duomenis vesti i naujo. Nepatogum galima ivengti, duomenis i anksto raant tekstin fail. Taiau fail
neraomi praneimai ir paaikinimai, kokie duomenys ir kokia eils tvarka pateikiami. Raant duomen skai-
tymo i failo sakinius, reikia i anksto inoti, kokia eils tvarka faile surayti duomenys. Nuo to priklauso, kiek
bus kintamj ir kokia eils tvarka j reikms bus skaitomos i failo.
Norint duomenis nuskaityti i failo, reikia:
Aprayti vedimo i srauto ifstream kintamj, pavyzdiui, ifstream fd;.
Programoje susieti kintamj su tekstiniu failu, pavyzdiui, fd.open("Duom.txt").
Galima aprayti vedimo i srauto ifstream kintamj ir susieti j su tekstiniu failu vienu sakiniu,
pavyzdiui, ifstream fd("Duom.txt");
Baigus darb, fail btina uverti, pavyzdiui, fd.close();.
Vis vedimo i srauto duomen fail kintamj vardus rekomenduojame pradti raidmis fd (raid f reikia
fail, d duomenis). Tuomet programos tekste juos galima atpainti be papildom paaikinim.

95
Duomenims i failo skaityti naudojamas tas pats operatorius >>, kaip ir vedamiems klaviatra, tik srauto var-
das cin yra keiiamas vedimo i srauto, susijusio su duomen failu, kintamojo vardu, pavyzdiui,
fd >> x;
vedimo ir ivedimo sraut, susijusi su duomen ir rezultat failais, priemons apraytos antratiniame faile
fstream. Jis perkeliamas program tokiu sakiniu:
#include <fstream>
Pavyzdys. I tekstinio failo Duomenys.txt nuskaitomi du sveikieji skaiiai ir ekran ivedama nuskaityt skai-
i suma.

Duomenys.txt
15 134

#include <fstream>
#include <iostream>
using namespace std;
int main()
{
int a, b, s;
ifstream fd("Duomenys.txt");
fd >> a >> b;
s = a + b;
fd.close();
cout << s << endl;
return 0;
}
3.11. Rezultat (duomen) ivedimas fail
Akivaizdu, kad skaiiavim rezultatus ekran galima ivesti, jeigu j yra nedaug. Tuomet nesunku juos per-
irti ir / arba nusirayti. Taiau jeigu rezultat yra daug, tai kur kas patogiau juos ivesti tekstin fail. Tada
duomenis lengva panaudoti dokumentuose, apdoroti kitomis taikomosiomis programomis (pvz., skaiiuokle).
Norint duomenis rayti fail, reikia:
Aprayti ivedimo sraut ofstream kintamj, pavyzdiui, ofstream fd;.
Programoje susieti failo kintamj su tekstiniu failu, pavyzdiui, fr.open("Duom.txt").
Galima aprayti vedimo sraut ifstream kintamj ir susieti j su tekstiniu failu vienu sakiniu, pavyz-
diui, ofstream fr("Rezultatas.txt");
Vykdant program, tuo atveju, jeigu darbiniame kataloge yra tekstinis failas nurodytu vardu, tai jame
esantys duomenys paalinami. Prieingu atveju sukuriamas naujas failas.
Norint jau egzistuojant rezultat fail papildyti, jis atveriamas, pavyzdiui, taip:
ofstream fr("Rezultatas.txt", ios::app);
Tuomet esami duomenys ilieka, o failas paruoiamas naujiems duomenims rayti failo pabaigoje.
Baigus darb, fail btina uverti, pavyzdiui, fr.close();.
Vis ivedimo fail srautus kintamj vardus rekomenduojame pradti raidmis fr (raid f reikia fail,
r rezultat). Tuomet programos tekste juos galima atpainti be papildom paaikinim.
Duomenims fail rayti naudojamas tas pats operatorius <<, kaip ir vedamiems klaviatra, tik srauto vardas
cout yra keiiamas ivedimo srauto, susijusio su duomen failu, kintamojo vardu, pavyzdiui,
fr << x;
vedimo ir ivedimo sraut, susijusi su duomen ir rezultat failais, priemons apraytos antratiniame faile
fstream. Jis perkeliamas program tokiu sakiniu:
#include <fstream>

96
Pavyzdys. tekstin fail Rezultatas.txt ivedama dviej sveikj skaii, vest klaviatra, suma.

#include <fstream>
#include <iostream>
using namespace std;
int main ()
{
int a, b, s;
cin >> a >> b;
s = a + b;
ofstream fr("Rezultatas.txt");
fr << s << endl;
fr.close();
return 0;
}
Klaviatra ved skaiius 49 ir 100, rezultat faile Rezultatai.txt matysite:

Rezultatas.txt
149
3.12. Funkcijos
Fnkcijomis yra vadinamos programos konstrukcijos, kurios atlieka savarankikus veiksmus. Vykdant progra-
m, funkcijas galima kreiptis daug kart. Funkcijos padeda struktrizuoti programas. Programas su funkci-
jomis lengviau skaityti ir analizuoti.
Naujai kuriam funkcij apraym galima skaidyti dvi dalis: prototip (iankstin apra) ir realizavimo apra-
ym.
Funkcijos prototipas nurodo naudotojui, kokia tvarka duomenys perduodami funkcijai ir kaip gaunami rezul-
tatai. Funkcijos prototipas raomas prie funkcij main() ir baigiamas kabliatakiu. Prototipo struktra tokia:
rezultatoTipas funkcijosVardas(formaliiejiParametrai);
Funkcijos prototipo pavyzdys: int Suma(int a, int b);
Paprastai funkcijos realizavimo apraas (funkcijos antrat ir veiksmai, kuriuos ji turi atlikti) raomas u
main() funkcijos. Jei funkcijos realizavimo apraas pateikiamas vir main(), tuomet nereikia rayti funkcijos
prototipo.
Funkcijos apraas atrodo taip:
rezultatoTipas funkcijosVardas(formaliejiParametrai)
{
funkcijosKamienas
}
Funkcijos antratje pirmiausiai nurodomas grinamos reikms tipas. Jei funkcija jokios reikms negrina,
vietoj rezultatoTipas nurodomas bazinis odis void. Toliau raomas funkcijosVardas, kuris parenka-
mas pagal tas paias taisykles, kaip ir kintamj vardai. Po to skliaustuose ivardijami parametrai. Jei funkcija
neturi parametr, tuomet raomi tuti skliaustai.
FormaliejiParametrai skirti funkcijos duomenims susieti su programos duomenimis. Parametrai apibr-
iami pagal tas paias taisykles, kaip ir kintamieji: nurodant j tip ir vard. Vienas nuo kito parametrai atski-
riami kableliais.
FunkcijosKamiene apraomi veiksmai, kuriuos turi atlikti funkcija. Jei funkcija skirta kokiai nors reikmei gr-
inti, tai tarp funkcijos veiksm turi bti bent vienas sakinys, kuriuo apskaiiuota reikm grinama program.
Funkcijos kamiene gali bti apraomi kintamieji, reikalingi funkcijos veiksmams atlikti. Jie galioja tik funkcijoje.
Reikmei grinti per funkcijos vard naudojamas sakinys return. Sakinio return sintaks:
return Reikinys;
97
Reikinys tai bet koks reikinys, kurio reikm grinama atlikus funkcij. Grinamos reikms tipas ir
funkcijos antratje nurodytas rezultato tipas turi bti tarpusavyje suderinami. Sakinys return ne tik grina
nurodyt reikm, bet ir nutraukia funkcijos darb. Sakinys return; tiesiog nutraukia funkcijos darb.
funkcijas kreipiamasi j vardais, u kuri skliaustuose pateikiami faktiniai parametrai (argumentai). Jei funk-
cija grina reikm, j kreipiamasi reikiniuose, pavyzdiui,
y = funkcijosVardas(faktiniaiParametrai) * c;.
Jei funkcija jokios reikms negrina, j kreipiamasi taip:
funkcijosVardas(faktiniaiParametrai);
FaktiniaiParametrai nurodo tuos duomenis, su kuriais bus atliekami funkcijos veiksmai.
Kreipinyje funkcij faktini parametr paprastai bna tiek pat ir tokio pat tipo, kaip nurodyta funkcijos ant-
ratje. Parametrai raomi tokia pat eils tvarka, kaip nurodyta funkcijos antratje, ir tarpusavyje atskiriami
kableliais. Jei funkcija parametr neturi, kreipinyje nurodomi tuti skliaustai.
Pavyzdys
// Staiakampio plotas
#include <iostream>
using namespace std;
//----------------------------------------------------
int Plotas(int a, int b); // funkcijos Plotas prototipas
//----------------------------------------------------
int main ()
{
int x = 5, y = 4, s;
s = Plotas(x, y); // kreipinys funkcij Plotas
cout << "Plotas = " << s << endl;
return 0;
}
//----------------------------------------------------
// Skaiiuoja staiakampio, kurio kratins a ir b, plot
int Plotas(int a, int b) // funkcijos antrat
{
return a * b; // grinamas apskaiiuotas staiakampio plotas
}
vykd program, ekrane matysite:
Staiakampio plotas 20
Jei funkcija turi grinti kelet reikmi, tuomet naudojami parametrainuorodos. Prie juos funkcijos antra-
tje raomas enklas &:
rezultatoTipas funkcijosVardas(tipas & vardas1, tipas & vardas2);
Tuo atveju, kai funkcij kreipiamasi, perduodant jai parametrusreikmes, funkcija sukuria naujus toki pai
tip kintamuosius, kaip ir perduodami parametrai, ir iems kintamiesiems priskiria parametr reikmes. Va-
dinasi, funkcija dirba su parametr reikmi kopijomis, bet ne su paiais parametrais. Toks mechanizmas yra
patogus, kai funkcijai nereikia keisti parametr reikmi.
Tuo atveju, kai funkcij kreipiamasi, perduodant jai parametrusnuorodas, ji gauna ne kintamj reikmes,
o nuorodas kintamuosius (kintamj adresai). Vadinasi, funkcija tiesiogiai naudoja perduodamus kintamuo-
sius. tai pavyzdys, kuriame funkcija Sukeisti(), naudodama parametr vardus pirmas ir antras, fakti-
kai naudojasi kintamaisiais x ir y.
98
// Dviej kintamj reikmi sukeitimas
#include <iostream>
using namespace std;
//--------------------------------------------------
void Sukeisti(int & pirmas, int & antras);
//--------------------------------------------------
int main ()
{
int x = 11, y = 25;
Sukeisti(x, y);
cout << " Kintamasis x po keitimo " << x << endl;
cout << " Kintamasis y po keitimo " << y << endl;
return 0;
}
//--------------------------------------------------
void Sukeisti(int & pirmas, int & antras)
{
int papildomas = pirmas;
pirmas = antras;
antras = papildomas;
}
vykd program ekrane matysite:
Kintamasis x po keitimo 25
Kintamasis y po keitimo 11
3.13. Knygoje naudojam terpiam fail sraas
Programos pradioje raomos instrukcijos parengiamajai doroklei (angl. preprocessor), koki fail tekstai turi
bti terpiami program pirminio apdorojimo metu. terpimo instrukcijos pradioje raoma #include, to-
liau tarp simboli < > nurodomi terpiam fail vardai. Pavyzdiui, antratinio failo iostream priemons
perkeliamos program sakiniu: #include <iostream>.
Lentelje pateikiami tik praktikos darbuose naudojami antratiniai failai.
terpiamas failas Paaikinimas
iostream
fstream
iomanip
cmath
fcntl.h
io.h
Duomen vedimo klaviatra ir ivedimo ekran priemons
Duomen skaitymo i failo ir ivedimo fail priemons
Duomen ivedimo fail srautus (ekranas, failas) priemons
Matematini funkcij rinkinys
Priemons lietuvikiems ramenims ekrane ivesti ekran
Priemons lietuvikiems ramenims ekrane ivesti ekran
99
ALGORITM INYNAS
E. W. Dijkstra 1969 m. straipsnyje Duomen struktros ir algoritmai rod, kad
kiekvien algoritm galima aprayti trimis pagrindiniais bdais:
Nuosekliai atliekamais veiksmais. Tokie algoritmai vadinami tiesiniais.
Cikliniais veiksmais, kai tas pats veiksmas kartojamas daug kart. Tokie algorit-
mai vadinami cikliniais.
Pasirinkimo veiksmais. Tokie algoritmai vadinami aktaisiais.
E. W. Dijkstros teigimu, jei udaviniui sprsti galima parayti algoritm, tai galima
sugalvoti daugyb algoritm ir po to i j isirinkti pat efektyviausi.
Toliau aptarsime tik kai kuriuos praktikos darbuose naudojamus algoritmus ir j C++ programavimo kalba
uraytus tekstus (kodus, fragmentus). Visus pateiktus kodus galima ibandyti, keliant juos main() arba
savo sukurt funkcij.
Norint ivesti ekran tekst su lietuvikais ramenimis, reikia parayti sakin:
_setmode (_fleno(stdout), _O_U16TEXT);
Tekstui ivesti ekran naudojama ivedimo srauto modifkacija wcout. Prie simboli eilutes, kuriose yra
lietuvik ramen, reikia parayti didij raid L. Pavyzdiui:
wcout << L"Skaii suma yra ";.
ios priemons tinka naudojant aplink Microsof Visual C++ arba aplink CodeBlocks, kuri diegiant buvo su-
sieta su aplinka Microsof Visual C++.
inyne visoms simboli eilutms ivesti ekran naudojamas srautas cout.
4.1. Tiesiniai algoritmai
Tai algoritmai, kai veiksmai atliekami j suraymo eils tvarka.
1 pavyzdys. Trienklio natraliojo skaiiaus x skaitmen sumos s skaiiavimas.
Norint isprsti udavin, reikia skaii x iskaidyti skaitmenimis, skaitmenis sudti ir pateikti skaiiavim
rezultat.
Algoritmas, uraytas odiais:
Pradinis duomuo trienklis natralusis skaiius x.
Atskiriamas pirmasis trienklio skaiiaus skaitmuo a.
Atskiriamas antrasis trienklio skaiiaus skaitmuo b.
Atskiriamas treiasis trienklio skaiiaus skaitmuo c.
Skaiiuojama trienklio skaiiaus skaitmen suma s = a + b + c.
Pateikiamas gautas skaiiavim rezultatas.
Algoritmas, uraytas C++ programavimo kalba:
1.
2.
3.
1.
2.
3.
4.
5.
6.
Vienas i struktrinio
programavimo pradinink
olandas E. W. Dijkstra
(19302002)
100

...
int x, a, b, c, s;
cout << "veskite trienkl natralj skaii ";
cin >> x;
a = x / 100;
b = x / 10 % 10;
c = x % 10;
s = a + b + c;
cout << "Skaiiaus " << x << " skaitmen suma lygi " << s;
...

Skaiiaus 158 skaitmen suma lygi 14
4.2. Cikliniai algoritmai
Tai algoritmai, kai veiksmus programoje reikia atlikti daug kart. Veiksm kartojim skaiius nusakomas san-
tykio ir loginiais reikiniais arba konkreiu skaiiumi.
2 pavyzdys. Vis natralij trienkli skaii skaitmen sum skaiiavimas.
Norint isprsti udavin, reikia kiekvien trienkl skaii iskaidyti skaitmenimis, skaitmenis sudti ir pa-
teikti gaut rezultat (skaii, jo skaitmenis ir j sum).
Algoritmas, uraytas odiais:
Pradinis duomuo pirmas trienklis natralusis skaiius x = 100.
Kartojami 38 veiksmai tol, kol x < 1000.
Atskiriamas pirmasis trienklio skaiiaus skaitmuo a.
Atskiriamas antrasis trienklio skaiiaus skaitmuo b.
Atskiriamas treiasis trienklio skaiiaus skaitmuo c.
Skaiiuojama trienklio skaiiaus skaitmen suma s = a + b + c.
Pateikiamas gautas skaiiavim rezultatas.
Reikm x padidinama vienetu.
Algoritmas, uraytas C++ programavimo kalba:

...
int x, a, b, c, s;
x = 100;
while (x < 1000) {
a = x / 100;
b = x / 10 % 10;
c = x % 10;
s = a + b + c;
cout << "Skaiiaus " << x << " skaitmen suma lygi " << s << endl;
x = x + 1;
}
...
4.3. akotieji skaiiavimai
Tai algoritmai, kai veiksmus reikia vykdyti atsivelgiant gautus ankstesni skaiiavim rezultatus. Tokie skai-
iavimai apraomi slyginiais sakiniais, kuriuose naudojami santykio ir loginiai reikiniai.
3 pavyzdys. Kiekvieno natraliojo trienklio nelyginio skaiiaus skaitmen sumos skaiiavimas.
Norint isprsti udavin, reikia kiekvien trienkl skaii patikrinti, ar jis nelyginis. Jei taip, tuomet reikia
j iskaidyti skaitmenimis, juos sudti ir pateikti gaut rezultat.
1.
2.
3.
4.
5.
6.
7.
8.
101
Algoritmas, uraytas odiais:
Pradinis duomuo pirmas trienklis natralusis skaiius x = 100.
Treias veiksmas kartojamas tol, kol x < 1000.
Tikrinama slyga, ar trienklis skaiius yra nelyginis.
3.1. Jei slyga tenkinama, tuomet atliekami veiksmai:
3.1.1. Atskiriamas pirmasis trienklio skaiiaus skaitmuo a.
3.1.2. Atskiriamas antrasis trienklio skaiiaus skaitmuo b.
3.1.3. Atskiriamas treiasis trienklio skaiiaus skaitmuo c.
3.1.4. Skaiiuojama trienklio skaiiaus skaitmen suma s = a + b + c.
3.1.5. Pateikiamas gautas skaiiavim rezultatas.
3.1.6. Reikm x padidinama vienetu.
3.2. Jei slyga netenkinama, reikm x padidinama vienetu.
Algoritmas, uraytas C++ programavimo kalba:

...
int x, a, b, c, s;
x = 100;
while (x < 1000) {
if (x % 2 != 0) {
a = x / 100;
b = x / 10 % 10;
c = x % 10;
s = a + b + c;
cout << "Skaiiaus " << x << " skaitmen suma lygi " << s << endl;
x = x + 1;
}
else x = x + 1;
}
...
Veiksmus galima supaprastinti, iklus priskyrimo sakin x = x + 1; i slygos tikrinimo:

...
while (x < 1000) {
if (x % 2 != 0) {
a = x / 100;
b = x / 10 % 10;
c = x % 10;
s = a + b + c;
cout << "Skaiiaus " << x << " skaitmen suma lygi " << s << endl;
}
x = x + 1;
}
...
Sprendiant 3 pavyzdio udavin, slygos if (x % 2 != 0) galima ir netikrinti (nelieka akojimo veiksmo).
Algoritmas, uraytas odiais:
Pradinis duomuo pirmas trienklis natralusis skaiius x = 101.
Veiksmai 38 kartojami tol, kol x < 1000.
Atskiriamas pirmasis trienklio skaiiaus skaitmuo a.
Atskiriamas antrasis trienklio skaiiaus skaitmuo b.
Atskiriamas treiasis trienklio skaiiaus skaitmuo c.
Skaiiuojama trienklio skaiiaus skaitmen suma s = a + b + c.
Pateikiamas gautas skaiiavim rezultatas.
Reikm x padidinama 2.
1.
2.
3.
1.
2.
3.
4.
5.
6.
7.
8.
102
Algoritmas, uraytas C++ programavimo kalba:

...
int x, a, b, c, s;
x = 101;
while (x < 1000) {
a = x / 100;
b = x / 10 % 10;
c = x % 10;
s = a + b + c;
cout << "Skaiiaus " << x << " skaitmen suma lygi " << s << endl;
x = x + 2;
}
...
4.4. Sumos skaiiavimo algoritmas
Keli skaii sum galima urayti taip: suma = sk1 + sk2 + + skn.
ia sk1, sk2, , skn yra skaiiai, kuriuos sudjus gaunama suma suma.
Atliekant veiksmus skaiiuotuvu (ar pietuku popieriuje), visuomet sumuojami du skaiiai. Veiksmus galima
iskleisti taip:

suma
2
= sk1 + sk2; // pirmj dviej skaii suma
suma
3
= suma
2
+ sk3; // ankstesnio rezultato ir treio skaiiaus suma
suma
4
= suma
3
+ sk4; // ankstesnio rezultato ir ketvirto skaiiaus suma
. . .
suma = suma
n-1
+ skn ; // vis n skaii suma
Skaiiuotuvo ekrane visuomet matyti tik paskutinio veiksmo rezultatas (dalin suma). Kiekviena nauja suma
gaunama prie jau apskaiiuotos sumos pridedant po vien dmen. Todl nagrinjam veiksm sek galima
urayti taip:

suma = sk1 + sk2; // pirmj dviej skaii suma
suma = suma + sk3; // trij skaii suma
suma = suma + sk4; // keturi skaii suma
. . .
suma = suma + skn; // vis n skaii suma
Sumos skaiiavimo formul galima urayti ir taip: suma = suma + skaiius. iuo atveju pradin suma
reikm turi bti lygi nuliui:

suma = 0; // pradin rezultato reikm
suma = suma + sk1; // pirmojo skaiiaus ir nulio suma
suma = suma + sk2; // dviej skaii suma
suma = suma + sk3; // trij skaii suma
. . .
suma = suma + skn; // vis n skaii suma
Bendru atveju algoritm galima urayti pseudokodu taip:
Pradia Skaii suma
suma = 0;
kol yra skaii
ciklo pradia
vesti skaii sk;
suma = suma + sk;
ciklo pabaiga
Ivesti rezultat suma
Pabaiga
103
Ciklo slyg kol yra skaii galima nurodyti labai vairiai. Paprasiausiu atveju prie cikl tiksliai apibriama,
kiek bus skaii, kuriuos reikia sudti.
Galimas toks algoritmo uraymas C++ programavimo kalba:

// Skaii suma
...
int suma, sk; // suma ir dmuo
int n; // skaii kiekis
int i; // ciklo kintamasis
cout << "Kiek bus skaii? ";
cin >> n;
suma = 0;
for (i = 1; i <= n; i = i + 1) {
cout << "Koks bus " << i << " skaiius? ";
cin >> sk;
suma = suma + sk;
}
cout << "vest skaii suma = " << suma << endl;
...

Kiek bus skaii? 3
Koks bus 1 skaiius? 12
Koks bus 2 skaiius? 5
Koks bus 3 skaiius? 10
vest skaii suma = 27
Kaip matote, sumos skaiiavimo veiksmai panas tuos, kurie atliekami atsiskaitant u prekes parduotuvje:
Pradedant skaiiuoti, kasos aparato ekrane rodoma reikm lygi nuliui.
Nuskaitant brkninio kodo skaitytuvu preki kodus, j kaina pridedama prie ekrane matomo skai-
iaus. Pinig suma, kuri reiks mokti, didja.
Nuskaiius paskutins preks kod, ekrane parodomas rezultatas.
4.5. Sandaugos skaiiavimo algoritmas
Keli skaii sandaug galima urayti taip: sand = sk1 * sk2 * * skn.
ia sk1, sk2, , skn yra skaiiai, kuriuos sudauginus, gaunama sandauga sand.
Atliekant veiksmus skaiiuotuvu (ar pietuku popieriuje), visuomet dauginami du skaiiai. Veiksmus galima
iskleisti taip pat, kaip ir sumuojant skaiius. Kiekviena nauja sandauga gaunama jau apskaiiuot sandaug
dauginant i naujo dauginamojo: sand = sand * skaiius. Pradin sandaugos reikm turi bti lygi
vienetui.
Sandaugos skaiiavim seka yra tokia:

sand = 1; // pradin rezultato reikm
sand = sand * sk1; // pirmojo skaiiaus ir vieneto sandauga
sand = sand * sk2; // dviej skaii sandauga
sand = sand * sk3; // trij skaii sandauga
. . .
sand = sand * skn; // vis n skaii sandauga
Bendru atveju veiksmus galima aprayti tokiu pat algoritmu, kaip ir skaiiuojant sum, tik pradin sandaugos
reikm turi bti lygi vienetui, o sudties operacijas (+) reikia pakeisti daugybos operacijomis (*).

104
4 pavyzdys. Skaiiaus klimas sveikuoju laipsniu (r = x
n
).
Algoritmas, uraytas C++ programavimo kalba:

// Skaiiaus klimas laipsniu. Taikomas sandaugos skaiiavimo algoritmas
...
int r, // sandauga
x, // laipsnio pagrindas
n; // laipsnio rodiklis
int i; // ciklo kintamasis
cout << "Skaiius, kur kelsite laipsniu: ";
cin >> x;
cout << "Laipsnio rodiklio reikm: ";
cin >> n;
r = 1;
for (i = 1; i <= n; i = i + 1)
r = r * x;
cout << "Rezultatas: " << r << endl;
...

Skaiius, kur kelsite laipsniu: 2
Laipsnio rodiklio reikm: 3
Rezultatas: 8
4.6. Kiekio skaiiavimo algoritmas
5 pavyzdys. Dvienkli natralij skaii, kurie dalijasi i penki, kiekio skaiiavimas.
Pirmasis dvienklis skaiius, kuris dalijasi i penki, yra 10. Kiekio pradin reikm yra lygi nuliui. Ciklo ant-
ratje raoma slyga, kad ciklas bt nutrauktas, perirjus visus dvienklius skaiius. Ciklas pradedamas
pirmuoju dvienkliu skaiiumi, kuris dalijasi i 5, todl toki skaii kiekis padidja vienetu. Po to x reikm
didinama 5, tikrinama ciklo slyga ir atliekami veiksmai ciklo viduje.
Veiksm algoritmas analogikas sumos skaiiavimo algoritmui, tik ia sumuojamos ne reikms, o vienetukai.
Algoritmas, uraytas C++ programavimo kalba:

...
int x, // pirmasis dvienklis skaiius, kuris dalijasi i penki
k; // dvienkli skaii, dali i 5, kiekis
x = 10;
k = 0;
while (x < 100) {
k = k + 1;
x = x + 5;
}
cout << "Dvienkli skaii, dali i 5, yra " << k << endl;
...

Dvienkli skaii, dali i 5, yra 18
105
6 pavyzdys. Natraliojo skaiiaus x dalikli kiekio k skaiiavimas.
Udavinio sprendimo algoritmas yra klasikinis: ciklas vykdomas nuo 1 iki x. Tikrinama, ar natralusis skai-
ius x be liekanos dalijasi i ciklo kintamojo i. Jei taip, tai i yra x daliklis ir dalikli kiekis k didinamas vienetu.
Algoritmas, uraytas C++ programavimo kalba:

...
int x, i, k;
cout << "Skaiius x = ";
cin >> x;
k = 0;
for (i = 1; i <= x; i = i + 1)
if (x % i == 0)
k = k + 1;
cout << " turi " << k << " dalikli(-ius) " << endl;
...

Skaiius x = 6 turi 4 dalikli(-ius)
4.7. Aritmetinio vidurkio skaiiavimas
Aritmetinis vidurkis skaiiuojamas dviem etapais:
1) apskaiiuojama skaii suma;
2) gauta suma padalijama i skaii kiekio.
Sumos skaiiavimo algoritm jau inagrinjome. Reikia atkreipti dmes, kad jeigu i anksto neinoma, kiek
skaii sumuojama, tai sumuojant reikia kartu skaiiuoti, kiek toki skaii buvo.
Antrasis etapas tai dviej skaii (gautos sumos ir skaii kiekio) dalyba:
vidurkis = suma / skaiiKiekis.
inome, kad dalyba i nulio negalima. Todl, prie atliekant dalybos veiksm (pvz., kai reikia apskaiiuoti teigia-
m skaii aritmetin vidurk), btina sitikinti, kad galima dalyti (kad vesti ne vien neigiami skaiiai ir nuliai).
4.8. Didiausios (maiausios) reikms paieka
Tai tradiciniai programavimo udaviniai. Populiariausias j sprendimo bdas yra toks. Iekant didiausios
reikms apraomi du kintamieji: vedamai x ir didiausiai d reikmms atmintyje laikyti. vedant pirmj
reikm, daroma prielaida, kad i yra didiausia:
d = x;
Po to paeiliui skaitomos kitos reikms ir lyginamos su d. Jei randama didesn, kintamojo d reikm keiiama nauja:
if (x > d) d = x;
Taip patikrinus vis vedam duomen sraut, kintamojo d reikm bus didiausia vesta reikm.
Analogikai iekoma maiausios reikms. Skiriasi tik palyginimo slyga:
if (x < d) d = x;
Algoritmas, uraytas C++ programavimo kalba:

...
int n, x, d, i;
cout << "Kiek bus skaii: ";
cin >> n;
cout << "Koks 1 skaiius: ";
cin >> d;
for (i = 2; i <= n; i = i + 1) {
cout << "Koks " << i << " skaiius: ";
cin >> x;
if (x > d) d = x;
}
cout << "Didiausias skaiius: " << d;
...
106

Kiek bus skaii: 5
Koks 1 skaiius: 7
Koks 2 skaiius: 9
Koks 3 skaiius: 12
Koks 4 skaiius: 8
Koks 5 skaiius: 6
Didiausias skaiius: 12
Pirmj reikm laikyti pradine didiausia (arba maiausia) reikme ne visuomet patogu. Ypa tada, kai ta
reikm turi bti apskaiiuojama (pavyzdiui, iekant maiausio teigiamo skaiiaus, kai sekos pradioje gali
bti daug neigiam skaii). Tokiu atveju pradinei didiausiai reikmei galima priskirti toki, kuri tikrai bt
maesn u visas galimas reikmes, tarp kuri iekome didiausios reikms. Cikle analizuojamos visos reik-
ms. Iekant maiausios reikms, pradinei reikmei reikia priskirti toki, kuri tikrai bt didesn u visas
galimas reikmes, tarp kuri iekome maiausios reikms. Geriausiai tam tinka standartin C++ konstanta
RAND_MAX, kuri yra faile stdlib.h.
7 pavyzdys. Sunkiausio arbzo paieka.
Tarkime, ant prekystalio yra n arbz, kuri mass inomos.
Algoritmas, uraytas C++ programavimo kalba:

...
int n; // arbz skaiius
double m; // arbzo mas
int i; // arbzo numeris
double s; // sunkiausio arbzo mas
int ns; // sunkiausio arbzo numeris
cout << "Kiek yra arbz? ";
cin >> n;
// Sunkiausio arbzo paieka
cout << "Arbz masi vedimas";
s = 0; ns = 0;
for (i = 1; i <= n; i = i + 1) {
cout << "veskite" << i << " arbzo mas: ";
cin >> m;
if (m > s) {
s = m; ns = i;
}
}
// Rezultatai
cout << "Sunkiausias arbzas Nr. " << ns << endl;
cout << "Jo mas: " << s << endl;
...

Kiek yra arbz? 5
Arbz masi vedimas
veskite 1 arbzo mas: 3.9
veskite 2 arbzo mas: 3.5
veskite 3 arbzo mas: 4.7
veskite 4 arbzo mas: 3.9
veskite 5 arbzo mas: 4.2
Sunkiausias arbzas Nr. 3
Jo mas: 4.7
107

APLINKA CodeBlocks
5.1. Pagrindiniai CodeBlocks bruoai
CodeBlocks populiari, patogi, nemokama, atvirojo kodo, nuolat atnaujinama ir tobulinama programavimo
aplinka, skirta programuoti C / C++ kalbomis operacinse sistemose Windows, Linux, Mac OS X.
CodeBlocks turi patogi rengykl, kuri iskiria programos fragmentus, automatikai pildo programos kod
(pvz., uraius vien skliaust, automatikai raomas kitas skliaustas).
Naudojantis ia aplinka galima kurti vairius projektus:


108

5.2. CodeBlocks diegimas
Paleiskite diegimo fail. Pasirodius informacinio praneimo langui spragtelkite mygtuk Next.

Spragtelkite mygtuk I Agree patvirtinti, kad sutinkame su licencijos reikalavimais.

109

Pasirinkite diegimo tip ir spragtelkite mygtuk Next:

Pasirinkite, kur diegti aplink CodeBlocks ir spragtelkite mygtuk Install.

110
diegus program, siloma j paleisti. Spragtelkite mygtuk Yes.

Pateikiamas aplinkos CodeBlocks palaikom kompiliatori sraas. Numatytasis yra GNU GCC kom-
piliatorius. Spragtelkite mygtuk OK.

Praneama, kad diegimas skmingai baigtas. Spragtelkite mygtuk Finish.

111
Atsiveria CodeBlocks aplinka. Pasirenkame, kad daugiau nebt rodomas informacinis praneimas.
Dialogo lange Tip of the Day panaikinamas parinkties Show tips on startup ymjimas ir spragtelimas
mygtukas Close.
Pasirenkama, kad aplinka CodeBlocks bt numatytoji atveriant C / C++ failus.

Spragtelimas Scripting Console lango uvrimo mygtukas .

5.3. CodeBlocks konfgravimas
Nurodykite pagrindinius aplinkos CodeBlocks nustatymus. Pasirinkite komandas: Settings
Environment... Srityje On Project load paymkite parinkt Do not open any fles, kitas parinktis pata-
riama pasilikti numatytsias.

112

Pasirinkite rengykls nustatymus. Pasirinkite komandas: Settings Editor... Pasirinkite tokias rengy-
kls parinktis:

113
5.4. Programos ablono parengimas
Programuojant labai patogu naudotis programos ablonu. Norint sukurti ablon reikia pasirinkti komandas:
Settings Editor Default Code. Default Code dialogo lang raykite pateikiam kod ir spragtelkite mygtuk
OK.

// Vieta programos vardui rayti
#include <fcntl.h>
#include <io.h>
#include <iostream>
using namespace std;
int main ()
{
_setmode (_fleno(stdout), _O_U16TEXT);
wcout << L"Labas." << endl;
return 0;
}
Pasirinkus nauj programos fail, jame jau tursite i programos kodo fragment.
5.5. Numatytojo kompiliatoriaus pasirinkimas ir diegimas
CodeBlocks aplink sukonfgruokite taip, kad numatytasis kompiliatorius bt Microsof Visual C++ 2005/2008.
is kompiliatorius pasirinktas dl to, kad juo naudojantis ekran galima paprasiau ivesti lietuvikus rame-
nis.
Parsisiskite Microsof Visual C++ 2008 Express Edition. J galima rasti adresu http://www.brothersof.
com/visual-c++-download-65282.html ir naudoti mokymui nemokamai.
diekite Microsof Visual C++ 2008 Express Edition.
Paleiskite vykdomj fail vcsetup.exe. Atsivrusiame lange spragtelkite mygtuk Next.

114
Pasirinkite parinkt I have read and accept the license terms patvirtinti, kad sutinkate su licencijos
reikalavimais, ir spragtelkite mygtuk Next.

Pasirinkite, kuriuos komponentus norsite diegti, ir spragtelkite mygtuk Next:

115
Pasirinkite, kur norsite diegti, ir spragtelkite mygtuk Install:

I interneto automatikai parsiuniami ir pasirinkt katalog diegiami reikalingi failai:

Baigus diegti program, reikia perkrauti kompiuter tam, kad programa veikt tinkamai.

116
dieg Microsof Visual C++ 2008 Express Edition, aplinkoje CodeBlocks pasirinkite numatytuoju kom-
piliatori Microsof Visual C++ 2005/2008. Pasirinkite komandas: Settings Compiler and debugger.
Atsivrusiame lange pasirinkite kompiliatori Microsof Visual C++ 2005/2008 ir spragtelkite mygtu-
k Set as default.

Nurodykite keli iki kompiliatoriaus Microsof Visual C++ 2005/2008 katalogo ir fail vardus. Tam
spragtelkite kortel Toolchain executables ir spragtelkite Auto-detect. Reikalingi programos failai su-
randami ir kortels laukai upildomi automatikai.

117
Spragteljus kortel Search directories, reikia kelti nuorodas Compiler, Linker ir Resource compiler
laukus. Laukeliai upildomi spragteljus mygtuk Add, esant lango apaioje, ir pasirinkus norim ka-
talog mygtuku Browse:


118
SAVARANKIKO DARBO UDUOTYS
1. Nutrinti skaiiai. Ant popieriaus lapo urayti keturi natralieji skaiiai: a, b, s, d. Po to du i j buvo nu-
trinti (juos ymsime nuliais). Reikia atkurti 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 * b.
Pavyzdiai:
Testo Nr. Pradiniai duomenys Rezultatai Paaikinimai
1 0 12 0 48 4 12 16 48 Nutrinti skaiiai a ir s
2 0 5 9 0 4 5 9 20 Nutrinti skaiiai a ir d
3 3 0 0 39 3 13 16 39 Nutrinti skaiiai b ir s
4 15 0 105 0 15 90 105 1350 Nutrinti skaiiai b ir d
5 25 13 0 0 25 13 38 325 Nutrinti skaiiai s ir d
6 1 0 0 32766 1 32766 32766 32766 Rezultatai skaiiai, artimi maxint
(VIII olimpiada, 1997)
2. Degtukai. Yra n degtuk. Paraykite program, kuri nustatyt, ar i t degtuk galima sudti bent vien i
i fgr: lygiakrat trikamp, kvadrat ar staiakamp. Dliojamai fgrai turi bti panaudoti visi degtukai;
be to, degtuk lauyti negalima.
Pavyzdiai:
Testo Nr. Pradinis duomuo Rezultatas Paaikinimai
1 1 Negalima Per maai degtuk
2 2 Negalima Per maai degtuk
3 3 Galima Paprastas atvejis, kai galima sudti lygiakrat trikamp
4 12 Galima Galima sudti visas fgras
5 15 Galima Galima sudti tik trikamp
6 16 Galima Galima sudti kvadrat ir staiakamp
7 35 Negalima Negalima sudti n vienos fgros
(VIII olimpiada, 1997)
3. 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 taip:
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 1984-aisiais ir baigsis 2043-iaisiais metais; 1984-ieji ir 1985-ieji
buvo alios spalvos metai, 1986-ieji ir 1987-ieji buvo raudonos spalvos metai, 2043-ieji bus juodos spalvos
metai.
Uduotis. inomi metai m (1800 m 2200). Paraykite program, kuri nustatyt ir ispausdint, kokia t
met spalva.

119
Pavyzdiai:
Testo Nr. Pradinis duomuo Rezultatas Paaikinimai
1 1984 ALIA Paprasiausias atvejis 1984-ieji metai
2 2001 BALTA Einamieji metai
3 1804 ALIA Pirmieji ciklo metai
4 2103 JUODA Paskutiniai ciklo metai
5 1945 ALIA alios spalvos metai
6 2137 RAUDONA Raudonos spalvos metai
7 1859 GELTONA Geltonos spalvos metai
8 1970 BALTA Baltos spalvos metai
9 1942 JUODA Juodos spalvos metai (baigiasi skaitmeniu 9)
10 1943 JUODA Juodos spalvos metai (baigiasi nuliu)
11 2200 BALTA Ribinis atvejis
(XIII olimpiada, 2002)
4. 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 apskaiiuot bendr Lauros parayt skaitmen skaii.
Pradiniai duomenys. Pirmoje ir vienintelje pradini duomen failo skait.in eilutje pateiktas paskutinis Lauros
paraytas natralusis skaiius n (1 n < 10 000).
Rezultatas. Rezultat faile skait.out turi bti raytas vienas skaiius bendras Lauros parayt skaitmen skai-
ius.
Pavyzdiai:
Pradinis duomuo Rezultatas Paaikinimai
10 11 1 2 3 4 5 6 7 8 9 10 i viso 11 skaitmen
5 5 1 2 3 4 5 i viso 5 skaitmenys
(XIX olimpiada, 2008)
5. iogas. iogas tupi ant horizontaliai itemptos virvuts, kairiajame gale. Virvuts ilgis yra s sprindi. io-
gas 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).
Uduotis. Paraykite program, kuri apskaiiuot, kiek maiausiai uoli turi padaryti iogas, kad pasiekt
mazg.
Pradiniai duomenys natralieji skaiiai s, a, b, c (s > c > a > b > 0).
Pavyzdiai:
Testo Nr. Pradiniai duomenys Rezultatas Paaikinimai
1 10 3 2 6 2 iogas turi okti du kartus priek
2 20 3 1 5 3 iogas oks du kartus priek ir kart atgal
3 20 4 2 5 Negalima Mazgo pasiekti negalima
4 9 7 4 8 Negalima Mazg galima bt pasiekti tik tada, jei virvut bt begalinio
ilgio (tada reikt 9 uoli)
5 100 13 1 27 15 iogas oka dideliais ingsniais priek ir maais atgal
(VIII olimpiada, 1997)
6. Sultis gerti sveika. Kiekvienos savaits pirmadienio ryt Jonas gauna k cent kienpinigi. Vienas butelis
suli kainuoja s cent, o tuti buteliai superkami po b cent. Kart (tai buvo i-oji savaits diena), i viso tur-
damas n cent, Jonas nusprend kasdien (pradedant i-ja diena) pirkti suli u visus turimus pinigus. Pinigai,
120
gauti pardavus butelius, bus panaudojami kit dien sultims pirkti. itaip Jonas darys tol, kol jis stengs nusi-
pirkti bent vien suli butel. Kiek buteli suli igers Jonas?
Uduotis. 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.
Pavyzdiai:
Testo Nr. Pradiniai duomenys Rezultatas Paaikinimai
1 k = 25, s = 10, b = 3, i = 2, n = 15 1 Pirmj dien nusiperkamas tik vienas butelis
2 k = 24, s = 10, b = 2, i = 1, n = 1 2
Prie perkant sultis pirmadien, btina pasiimti kien-
pinigius
3 k = 25, s = 9, b = 2, i = 4, n = 23 3
Pinig treiajam buteliui uteks tik tuomet, jei bus par-
duoti abu buteliai
4 k = 100, s = 10, b = 2, i = 5, n = 500 74
Didesnis testas, kai buteliai perkami kelias dienas ir
viena diena yra pirmadienis
(IX olimpiada, 1998)
7. Vaizdo raai. 240 minui trukms vaizdajuost kainuoja 10 Lt ir 90 ct, 180 minui trukms vaizdajuost
kainuoja 9 Lt ir 15 ct. 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 galima rayti kelias laidas. Deja, Tomas
neturi n vienos tuios vaizdajuosts.
Uduotis. Paraykite program, kuri apskaiiuot, kiek maiausiai pinig (lit ir cent) Tomui reiks ileisti
vaizdajuostms nusipirkti, kad j utekt norimoms laidoms rayti.
Pradiniai duomenys. Pirmoje kiekvieno duomen rinkinio eilutje nurodytas laid skaiius n, o likusiose
n eilui kiekvienos laidos trukm. Pirma nurodomas valand, paskui minui skaiius.
Pavyzdiai:
Testo Nr. 1 2 3 4 5 6 7 8 9 10 11
Pradiniai duomenys
1
1 10
3
2 00
2 00
0 30
4
0 30
0 20
3 40
1 30
3
2 30
2 30
1 01
5
1 10
1 05
1 00
4 45
1 00
5
1 10
1 05
1 00
4 45
1 05
3
5 30
3 20
2 00
3
5 00
5 00
3 00
3
5 00
5 00
3 05
6
3 00
3 00
3 00
3 00
3 00
0 55
6
8 30
8 30
8 30
8 30
8 30
2 00
Rezultatas 9,15 18,30 18,30 20,05 27,45 29,20 30,95 38,35 40,10 43,60 125,55
Paaikinimai
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 2 5 6 7 9 10 11 13 14 16 45
Ilg ir trump
vaizdajuosi skaiius
0 1 0 2 0 2 1 1 0 3 1 2 2 1 1 3 2 2 4 0 9 3
(XI olimpiada, 2000)
8. Didmeninis pirkimas. inoma, kad, perkant daugiau preki, j vienetas kainuoja pigiau. Ryulyje yra
12 por kojini, dje 12 ryuli. Pavyzdiui, kojini d kainuoja 247 Lt, ryulys 21 Lt, pora 2 Lt.
domu tai, kad jei mums reikt 11 por kojini, tai geriau pirkti ryul ir vienas kojines kam nors atiduoti.
Uduotis. Pirkjas nori sigyti n por kojini. Paraykite program, kuria vadovaudamiesi pigiausiai nupirktu-
me kojines. Jei u t pai kain galima nupirkti didesn ir maesn kiek kojini, tai perkamas didesnis kiekis.
Apskaiiuokite perkam di, ryuli ir por skaii.
121
Pradinius duomenis sudaro keturi skaiiai: kojini por skaiius n, vienos ds, vieno ryulio ir vienos poros
kaina litais.
Pavyzdiai:
Testo Nr. Pradiniai duomenys Rezultatai Paaikinimai
1 720 303 32 3
Di skaiius: 5
Ryuli skaiius: 0
Por skaiius: 0
n dalus i 144 (por skaiiaus dje)
2 84 210 20 2
Di skaiius: 0
Ryuli skaiius: 7
Por skaiius: 0
n dalus i 12 (por skaiiaus ryulyje)
3 196 100 20 5
Di skaiius: 2
Ryuli skaiius: 0
Por skaiius: 0
Perkamos tik ds; perkant di, ryuli ir por ati-
tinkamai 1, 4, 4 arba 1, 5, 0, kaina bt ta pati, taiau
kojini kiekis bt maesnis
4 355 292 41 6
Di skaiius: 2
Ryuli skaiius: 6
Por skaiius: 0
Perkamos tik ds ir ryuliai
5 355 291 50 6
Di skaiius: 3
Ryuli skaiius: 0
Por skaiius: 0
Perkamos tik ds
6 355 292 49 6
Di skaiius: 2
Ryuli skaiius: 5
Por skaiius: 7
Perkamos ir ds, ir ryuliai, ir poros
(X olimpiada, 1999)
9. Varli koncertas. Kart vienoje kdroje gyveno daug varli, ir ne bet koki, o dresuot. Kiekviena varl su-
gebdavo iokti i vandens ir sukvarksti jai bdingais tiksliai pasikartojaniais laiko momentais. Pavyzdiui,
tarkime, kad varls kvarksjimo periodas lygus 5. Vadinasi, 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. Pirma vedamas varli skaiius, po to kiekvienos varls kvarkimo periodas. Varli pasi-
rodymo periodai surayti i eils: p
1
, p
2
, p
3
, p
4
, p
5
ir t. t., ia p
1
pirmos varls pasirodymo periodas, p
2
antros
ir t. t. (0 < p
i
20 minui). Varli skaiius kdroje nevirijo 10.
Atkreipiame dmes, kad skaiius valand, po kuri vyks antrasis koncertas, nevirija long long.
Pavyzdiai:
Testo Nr. Pradiniai duomenys Rezultatai Paaikinimai
1 2
8 8
Koncertas vyks po
0 val. ir 8 min.
Paprasiausias atvejis: abu periodai
sutampa
2 3
2 3 5
Koncertas vyks po
0 val. ir 30 min.
Periodai neturi bendr dalikli:
kartotinis lygus period sandaugai
3 6
12 15 20 10 6 30
Koncertas vyks po
1 val. ir 0 min.
Periodai turi bendr dalikli
4 5
18 7 3 2 4
Koncertas vyks po
4 val. ir 12 min.
Tikrinama, ar laikas teisingai
perskaiiuojamas valandas ir minutes
5 10
11 12 13 14 15 16 17 18 19 20
Koncertas vyks po
3879876 val. ir 0 min.
iuo testu tikrinamas sprendimo
efektyvumas
(XI olimpiada, 2000)
122
10. Senas kalendorius. Metai yra keliamieji, jeigu jie dals i 4 ir nesidalija i 100 arba jeigu jie dals i 400.
Pavyzdiui:
2000-ieji metai keliamieji, nes jie dals i 400;
2004-ieji metai keliamieji, nes jie dals i 4 ir nra dals i 100;
1900-ieji metai nra keliamieji, nes jie dals i 100, bet nra dals 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, vedami klaviatra. Pirmas skaiius tai metai, kuriems buvo i-
leistas senasis kalendorius. Antrasis skaiius yra i intervalo [1..7] ir nusako, kuria savaits diena prasidjo tie
metai.
Rezultatas ivedamas ekran.
Pavyzdiai:
Testo Nr. Pradiniai duomenys Rezultatas
1 1979 1 2007
2 1941 3 2014
3 1964 3 2020
4 1993 5 2010
5 2002 2 2013
(XVI olimpiada, 2005)
11. Trys sodininkai. Trys draugai, apsigyven kaime, nusprend mokytis sodininkauti. Kaime buvo didiulis
sodas, kurio kiekviename vienetiniame plotelyje augo po vien vaismed.
Kiekvienas i trij draug pasirinko staiakamp sklyp ir nusprend priirti jame esanius medius. Susi-
rinkus draugn paaikjo, kad j pasirinkti sklypai siterpia vienas kit, t. y. kai kuriuos vaismedius priirs
ne vienas, o keletas sodinink.
Uduotis. Paraykite program, kuri apskaiiuot, kiek vaismedi panorjo
priirti visi trys draugai.
Pradiniai duomenys pateikiami trijose tekstinio failo sodas.dat eilutse. kiekvien
eilut rayta po keturis skaiius, apibdinanius kiekvieno draugo pasirinkt
sklyp: sklypo apatinio kairiojo ir virutinio deiniojo kamp koordinats (pir-
ma koordinat x, po to y). Visos koordinats sveikieji skaiiai.
Pavyzdiai:
Testo Nr. Pradiniai duomenys Rezultatas
1 2 3 6 7
4 1 8 5
6 0 10 3
0
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 30 30 80 70
10 20 70 90
50 20 100 90
800
(X olimpiada, 1999)

Rekomenduojama literatra
1. J. Blonskis, V. Buknaitis, V. Jusas, R. Marcinkeviius, D. Rubliauskas. Programavimas C++. Vadovlis.
KTU leidykla Technologija, Kaunas, 2005.
2. J. Blonskis, V. Buknaitis, V. Jusas, R. Marcinkeviius, A. Miseviius, S. Turskien. Programavimo kalba
C++. Mokomoji knyga. Smaltijos leidykla, Kaunas, 2008.
3. J. Blonskis, V. Buknaitis, J. Konien, D. Rubliauskas. C++ praktikumas. KTU leidykla Technologija,
Kaunas, 2001.
4. J. Blonskis, V. Buknaitis, V. Jusas, R. Marcinkeviius, A. Miseviius. C++ Builder. Mokomoji knyga.
Smaltijos leidykla, Kaunas, 2005.
5. A. Vidinas. C++ ir objektinis programavimas. Programuotojo vadovas. Smaltijos leidykla, Kaunas, 2008.
6. H. M. Deitel, P. J. Deitel. C++ How to Program. Prentice Hall, 2001.
7. V. Dagien, G. Grigas, T. Jevsikova, Enciklopedinis kompiuterijos odynas. II papildytas leidimas. TEV,
Vilnius, 2008. odyno svetain: www.likit.lt/term/enciklo.html.