PAPRASTOS PROGRAMOS, CIKLAI
1. PAPRASTOS PROGRAMOS, CIKLAI
1. Parasyti programa, kuri apskaiciuotu funkcijos reiksme:kai x>0, tai y=1, jei x kita reiksme, tai y=2.
program Funkcija_I;
var x,y:integer;
begin
WriteLn (‘Ivesk x reiksme’);
ReadLn (x);
if x>0 then y:= 1
else y:= 2;
WriteLn (‘y=’, y);
ReadLn;
end.
2. Jei 5>x>0, tai y=1, kai 10>x>=5, tai y=2, kai x>=10, tai y=4.
program Funkcija_II;
var x,y:integer;
begin
WriteLn (‘Ivesk x reiksme:’);
ReadLn (x);
if (x>=10) then
begin
y:=4;
WriteLn (‘y=’,y);
end
else if (10>x) and (x>=5)
then
begin
y:=2;
WriteLn (‘y=’,y);
end
else if (5>x) and (x>0)
then
begin
y:=1;
WriteLn (‘y=’,y);
end
else WriteLn (‘y neturi sprendiniu’);
ReadLn;
end.
3. Parasyti programa, kuri apskaiciuotu staciakampio zemes sklypo plota. Ilgis ir plotis ivadami is klaviaturos.
program Sklypo_plotas;
var S, x, y:longint;
begin
WriteLn (‘Ivesk sklypo ilgi ir plota’);
ReadLn (x,y);
{tikrinam, ar krastine(s) nera neigiamos arba lygios nuliui}
if (x<=0) or (y<=0)
then WriteLn (‘Sklypo krastine(s) negali buti maziau arba lygi 0!’)
else
begin
S:= x*y;
WriteLn (‘Sklypo plotas yra ‘,S,’ kvadr. vnt.’);
end;
ReadLn;
end.
4. Parasyti programa, kuri tikrintu, ar galima is triju is klaviatūros ivestu krastiniu ilgiu sudaryti ttrikampi. Trecioji krastine negali buti didesne uz kitu dveiju suma.
program Trikampio_sudarymas;
var a,b,c:real;
begin
WriteLn (‘Ivesk trikampio krastiniu ilgius:’);
ReadLn (a,b,c);
{tikrina, ar ilgiai nera lygus ar mazesni uz nuli}
if (a<=0) or (b<=0) or (c<=0)
then WriteLn (‘a, b, c negali bbuti maziau arba lygus nuliui!’)
else
if ((a+b)>c) and ((b+c)>a) and ((a+c)>b)
then WriteLn (‘Trikampi galima sudaryti!’)
else WriteLn (‘Trikampio sudaryti negalima!’);
ReadLn;
end.
Ciklas FOR
5. Programa apskaiciuoja dvizenkliu, t.y. nuo 10 iki 99 skaiciu suma.
Program Dvizenkliu_suma;
var x:integer;
n:longint;
begin
n:=0;
x:=0;
{kol x yra nuo 10 iki 99, vykdyk sia uzduoti n=n+x
ciklo sakinys FOR pats padidina x vienu vnt iki nurodytos ribos (99)}
for x:=10 to 99 do
n:=n+x;
WriteLn (‘Visu teigiamu dvizenkliu (10-99) skaiciu suma yra ‘,n,’.’);
ReadLn;
end.
6. Programa skaicuoja is klaviaturos ivesto sveiko teigiamo nelygaus nuliui ir mazesnio uz 17 skaiciaus faktoriala.
Program Faktorialo_skaiciavimas;
var n,i:integer;
f:longint;
begin
WriteLn (‘Ivesk sveika teigiama nelygu nuliui ir mazesni uz 17 skaiciu:’);
ReadLn (n);
f:=1;
if n<=0
then WriteLn (‘Negalima ivesti lygaus arba mazesnio uz 00 skaiciaus!’)
else begin
for i:=1 to n do
f:= f*i;
WriteLn (‘Skaiciaus ‘,n,’ faktorialas yra ‘,f,’.’);
end;
ReadLn;
end.
7. Programa simta kartu atspausdina zodi „Labas!“.
program Labas;
var i:integer;
begin
i:=0;
for i:=1 to 100 do {kol i= nuo 1 iki 100, spausdink „Labas!“.}
WriteLn (‘Labas!’);
ReadLn;
end.
8. Programa apskaiciuoja visu teigiamu trizenkliu skaiciu (100-999) suma.
program Trizenkliu_suma;
var suma,x:longint;
begin
suma:=0; x:=0;
for x:=100 to 999 do
suma:=suma+x;
WriteLn (‘Visu teigiamu trizenkliu skaiciu suma yra ‘,suma,’.’);
ReadLn;
end.
9. Programa suskaiciuoja visu vienzenkliu skaiciu (0-9) suma.
Program Vienzenkliu_suma;
var x:integer;
n:longint;
begin
n:=0;
x:=0;
for x:=1 to 9 do
n:=n+x;
WriteLn (‘Vienzenkliu skaitmenu suma yra ‘,n,’.’);
ReadLn;
end.
Ciklas WHILE
10. Programa skaiciuoja visu teigiamu lyginiu dvizenkliu skaiciu suma.
Program Dvizenkliu_lyginiu_suma;
var i:integer;
n:longint;
begin
i:=8;
n:=0;
While i<=97 do
begin
i:=i+2;
n:=n+i;
end;
WriteLn (‘Visu teigiamu lyginiu dvizenkliu skaiciu suma yra ‘,n,’.’);
ReadLn;
end.
11. Programa skaiciuoja visu teigiamu nelyginiu dvizenkliu skaiciu suma.
Program Dvizenkliu_nelyginiu_suma;
var i:integer;
n:longint;
begin
i:=9;
n:=0;
While i<=98 do {paskutinis bus 98+1=99}
begin
i:=i+2; {pirmas skaicius bus 9+2=11}
n:=n+i;
end;
WriteLn (‘Visu teigiamu nelyginiu dvizenkliu skaiciu suma yra ‘,n,’.’);
ReadLn;
end.
12. Programa skaiciuoja visu teigiamų dvizenkliu teigiamu skaiciu (10-99) suma.
Program Dvizenkliu_suma;
var i:integer;
n:longint;
begin
i:=10;
n:=10;
While i<=98 do
begin
i:=i+1;
n:=n+i;
end;
WriteLn (‘Visu dvizenkliu teigiamu skaiciu (10-99) suma yra ‘,n,’.’);
ReadLn;
end.
13. Programa skaicuoja is klaviaturos ivesto sveiko teigiamo nelygaus 0 ir mazesnio uz 17 skaiciaus faktoriala.
Program Faktorialo_skaiciavimas;
var x,n:integer;
fk:longint;
begin
WriteLn (‘Ivesk teigiama, nelygu nuliui ir mazesni uz 17 skaiciu:’);
ReadLn (x);
n:=1;
fk:=1;
if (x<=0) or (x>16)
then WriteLn (‘Skaicius turi buti 00 then
begin
y:=(3*x-3)/v;
WriteLn (‘Kai x=’,x:2:2,’, tai y=’,y:2:2,’.’);
end
else WriteLn (‘Kai x=’,x,’, tai y yra nezinomas.’);
x:=x+0.2;
end;
ReadLn;
end.
15. Parasyti programa, kuri suskaiciuotu, kiek is klaviaturos ivedamas sveikas teigiamas skaicius turi skaitmenu.
Program Skaitmenu_skaicius;
var i,n,r:longint;
begin
WriteLn (‘Ivesk sveika teigiama skaiciu:’);
ReadLn (n);
r:=n; {kintamasis reikalingas issaugoti ppradinei reiksmei}
i:=0;
if n<0 {tikrina, ar ivestas skaicius nera neigiamas}
then WriteLn (‘Neigiamo skaiciaus ivesti negalima!’)
else
begin
While n div 10>0 do
begin
i:=i+1;
n:=n div 10;
end;
i:= i+1;
WriteLn (‘Skaicius ‘,r,’ turi ‘,i,’ skaitmeni/is.’);
end;
ReadLn;
end.
16. Programa skaiciuoja visu dvizenkliu teigiamu skaiciu (0-99) suma.
Program Dvizenkliu_suma;
var i:integer;
n:longint;
begin
i:=0;
n:=0;
While i<=98 do
begin
i:=i+1;
n:=n+i;
end;
WriteLn (‘Visu dvizenkliu teigiamu skaiciu (10-99) suma yra ‘,n,’.’);
ReadLn;
end.
17. Programa skaiciuoja visu vienzenkliu teigiamu skaiciu (0-9) suma.
Program Vienzenkliu_suma;
var i:integer;
n:longint;
begin
i:=0;
n:=0;
While i<=8 do
begin
i:=i+1;
n:=n+i;
end;
WriteLn (‘Visu vienzenkliu teigiamu skaiciu (10-99) suma yra ‘,n,’.’);
ReadLn;
end.
Ciklas REPEAT
18. Programa apskaiciuoja is klaviaturos ivesto sveiko skaiciaus (0>x>17) faktoriala.
program Faktorialo_skaiciavimas;
var i,n:integer;
f:longint;
begin
WriteLn (‘Ivesk teigiama didesni uz nuli ir mazesni uz 17 skaiciu:’);
ReadLn (n); {skaicius, kurio faktoriala reikia apskaiciuoti}
i:=0; f:=1;
Repeat
i:=i+1;
f:=f*i;
until i=n;
WriteLn (‘Skaiciaus ‘,n,’ faktorialas yra ‘,f,’.’);
Readln;
end.
19. Programa apskaiciuoja is klaviaturos ivesto sveiko teigiamo skaiciaus skaitmenu kieki.
Program Skaitmenu_skaicius;
var i:integer;
n,r:longint;
begin
WriteLn (‘Ivesk sveika teigiama skaiciu:’);
ReadLn (n);
r:=n; {pradinio skaiciaus issaugojimas}
i:=0;
if n<0 {tikrina, ar ivestas skaicius nera neigimas}
then WriteLn (‘Negalima ivesti neigiamo skaiciaus!’)
else
begin
Repeat
n:=n div 10;
i:=i+1;
until n<1;
WriteLn (‘Skaicius ‘,r, ‘ turi ‘,i,’ skaitmeni/is.’);
end;
ReadLn;
end.
20. Programa aapskaiciuoja visu teigiamu vienzenkliu skaiciu suma.
program Vienzenkliu_suma;
var i,n:integer;
begin
i:=0; n:=0;
Repeat
i:=i+1;
n:=n+i;
until i>=9;
WriteLn (‘Visu vienzenkliu teigiamu skaiciu suma yra ‘,n,’.’);
ReadLn;
end.
21. Programa is klaviaturos ivesta sveika 5-zenkli skaiciu paraso is kitos puses.
program Atbulas_penkiazenklis;
var s1,s2,s3,s4,s5,x,pr,gl:longint; {pr – pradinis, gl – galutinis}
begin
WriteLn (‘Ivesk sveika keliazenkli skaiciu:’);
ReadLn (pr);
x:=pr; {pradines reiksmes issaugojimui}
s1:= x div 10000; {pirmas skaiciu}
s2:= (x div 1000) mod 10; {antras skaiciu}
s3:= (x div 100) mod 10; {trecias skaiciu}
s4:= (x div 10) mod 10; {ketvirtas skaiciu}
s5:= (x div 1) mod 10; {penktas skaicius}
gl:= ((s5 * 10000)+(s4*1000)+(s3*100)+(s2*10)+s1);
WriteLn (‘Skaiciaus ‘,pr,’ is kitos puses parasytas skaicius ‘,gl,’.’);
ReadLn;
end.
22. Programa apskaiciuoja funkcija y=e pakeltas laipsniu (2x-2). Kintamasis x kinta nuo 0 iki 3. Kitimo zingsnis 0.3.
program Kelimas_laipsniu;
var x,y:real; {argumento tipas butinai turi buti realus}
begin
x:=0;
Repeat
y:=exp(2*x-2);
WriteLn (‘Kai x= ‘,x:2:2,’, tai y= ‘,y:2:2,’.’); {rezultatas – real}
x:=x+0.3;
until x>3;
ReadLn;
end.
Sudėtingesni uždaviniai
23. Programa is klaviaturos ivesta sveika penkiazenkli skaiciu paraso is kitos puses.
program Atbulas_penkiazenklis;
var s1,s2,s3,s4,s5,x,pr,gl:longint; {pr – pradinis, gl – galutinis}
begin
WriteLn (‘Ivesk sveika penkiazenkli skaiciu:’);
ReadLn (pr);
x:=pr; {pradines reiksmes issaugojimui}
s1:= x div 10000; {pirmas skaicius}
s2:= (x div 1000) mod 10; {antras skaicius}
s3:= (x div 100) mod 10; {trecias skaicius}
s4:= (x div 10) mod 10; {ketvirtas skaicius}
s5:= (x div 1) mod 10; {penktas
skaicius}
gl:= ((s5 * 10000)+(s4*1000)+(s3*100)+(s2*10)+s1);
WriteLn (‘Skaiciaus ‘,pr,’ is kitos puses parasytas skaicius ‘,gl,’.’);
ReadLn;
end.
24. Apskaiciuoti s = 1 + ½ +1/4 +.+1/2n +.
program funkc_naud;
var sum,eps,narys:real;
n:integer;
function vard(n:integer):longint;
var snd:integer;
f:longint;
begin
f:=1; snd:=1;
for snd:=1 to n do
f:=f*2;
vard:=f;
end;
begin
Readln (eps);
sum:=0;
narys:=1; n:=0;
while narys>eps do
begin
sum:=sum+narys;
n:=n+1;
narys:=1/vard(n);
end;
writeln (‘suma=’,sum:5:2);
readln;
end.
25. Kasininkas gauna pinigų sumą, kurią reikia išmokėti. Kokiais pinigais reikia išmokėti tą sumą, kad kupiūrų kiekis būtų minimalus?
program Min_kupiuros;
var sum:longint;
s1,s2,s3,s4,s5,s6,s7,s8,s9:longint;
begin
WriteLn (‘Iveski suma, kuria reikia ismoketi’);
ReadLn (sum);
s1:= sum div 500;
s2:= (sum-(s1*500)) div 200;
s3:= (sum-(s1*500)-(s2*200)) div 100;
s4:= (sum-(s1*500)-(s2*200)-(s3*100)) div 50;
s5:= (sum-(s1*500)-(s2*200)-(s3*100)-(s4*50)) div 20;
s6:= (sum-(s1*500)-(s2*200)-(s3*100)-(s4*50)-(s5*20)) div 10;
s7:= (sum-(s1*500)-(s2*200)-(s3*100)-(s4*50)-(s5*20)-(s6*10)) div 5;
s8:= (sum-(s1*500)-(s2*200)-(s3*100)-(s4*50)-(s5*20)-(s6*10)-(s7*5)) div 2;
s9:= (sum-(s1*500)-(s2*200)-(s3*100)-(s4*50)-(s5*20)-(s6*10)-(s7*5)-(s8*2)) div 1;
WriteLn (sum,’ Lt suma patogiausia ismoketi tokio nominalo pinigais:’);
WriteLn (‘—————–‘);
WriteLn (‘—‘,s1,’ po 500 Lt—‘);
WriteLn (‘—‘,s2,’ po 200 Lt—‘);
WriteLn (‘—‘,s3,’ po 100 Lt—‘);
WriteLn (‘—‘,s4,’ po 50 Lt —‘);
WriteLn (‘—‘,s5,’ po 220 Lt —‘);
WriteLn (‘—‘,s6,’ po 10 Lt —‘);
WriteLn (‘—‘,s7,’ po 5 Lt —‘);
WriteLn (‘—‘,s8,’ po 2 Lt —‘);
WriteLn (‘—‘,s9,’ po 1 Lt —‘);
WriteLn (‘—————–‘);
ReadLn;
end.
26. Programa suskaiciuoja bet kokio skaiciaus, ivesto is klaviaturos, skaitemnu skaiciu.
program llabas;
var x,ks,sk:longint;
begin
writeln (‘iveskite sveika skaiciu nesibaigianti nuliu’); {nesibaigianti nuliu nes apvertus ji jis bus neteisingas}
readln (sk);
x:=sk; {nes sk nuolat kinta o mums gale jo reikia pradinio}
ks:=0; {sumos kaupimo uzdavinys}
while sk >=10 do
begin
ks:=(ks+sk mod 10)*10;
{sk mod 10 atpjauna paskutini skaitmeni,daugina is desimt, kad po to pridejus antra nuo gal skaitmeni skaicius graziai rikiuotusi}
sk:=sk div 10; {palieka skaiciu be paskutinio skaitmens}
end;
ks:=ks+sk; {prijungti paskutiniam skaitmeniui, ks visa laika kito ir cia jis yra galutinis be paskutinio skaitmens}
writeln (x,’atbulai’,ks);
readln;
end.
27. Programa skaicuoka įvestos skaičių sekos narių sumą ir daro tai tol, kol bus įvestas skaičius 777.
program Skaiciu_seka;
var s, x:integer;
begin
s:=0;
Repeat
WriteLn (‘Ivesk skaiciu’);
ReadLn (x);
begin
if x=777
then Writeln (‘Ciklas baigtasm suma’,s)
else s:=s+x;
end;
WriteLn (‘Skaiciu sekos suma: &‘,s);
until x=777;
ReadLn;
end.
28. Programa sukeicia penkiazenkio skaiciaus I-aja pozicija su 4-aja
program penkiazenklio_keitinys;
var x,sk1,sk2,sk3,sk4,sk5,Pr,Ap:integer;
begin
{Ivesto 5-zenklio skaiciaus pirma skaitmeni sukeicia su ketvirtuoju}
WriteLn (‘Ivesk sveika penkiazenkli skaiciu: ‘);
ReadLn (x);
Pr:=x;
sk1:= x mod 10;
sk2:= (x div 10) mod 10;
sk3:= (x div 100) mod 10;
sk4:= (x div 1000) mod 10;
sk5:= x div 10000;
Ap:= ((sk2*10000)+(sk3*1000)+(sk4*100)+(sk5*10)+sk1);
WriteLn (‘Pradinis skaicius ‘,Pr,’ apverstas bus: ‘,Ap);
ReadLn;
end.
29. Programa parodo, kiek laiko rodys laikrodis po vienos minutes. Pradinis laikas ivedamas is kklaviaturos.
program Laikas;
var val, min:integer;
begin
WriteLn (‘Ivesk valandas:’);
ReadLn (val);
WriteLn (‘Ivesk minutes:’);
ReadLn (min);
if (val<0) or (val>24) or (min<0) or (min>60) {tikrina, ar ivestas laikas egzistuoja}
then WriteLn (‘Valandos turi buti 25>val>0, minutes – 60>min>0!’)
else
begin
if val=24 {nustato 24 valandu ir ne daugiau riba}
then
begin
val:=00; {kai val=24, tai po 1 min laikas pradedamas skaiciuoti is naujo}
min:=01;
end
else
begin
if min<>60 {jei laikrodis rodo 60 min, tai po 1 min prasideda nauja val ir minutes lygios 0 }
then min:=min+1
else
begin
val:=val+1;
min:=00;
end;
end;
if (val<10) and (min<10) {nuliu rodymui}
then WriteLn (‘Po minutes laikrodis rodys 0′,val,’:0′,min,’.’)
else WriteLn (‘Po minutes laikrodis rodys ‘,val,’:’,min,’.’);
end;
ReadLn;
end.
2. MASYVAI: rasymas, skaitymas is keliu masyvu, rusiavimas
1. Programa suformuoja studentų sesijos pažymių masyvą ir apskaičiuoja bendrą vidurkį. Masyvo duomenys, t.y. 5 pažymiai (studentų sesijos pažymių vidurkiai) įvedami is klaviatūros.
program Masyvo_sudarymas;
var i:byte;
vid:real;
Paz:array [1..5] of byte;
begin
vid:=0; {kintamojo isvalymas}
for i:=1 to 5 do
begin
ReadLn (Paz[i]);
vid:= vid + Paz[i];
end;
vid:= vid/i;
WriteLn (‘Vidurkis yra ‘,vid:5:2,’.’);
ReadLn;
end.
2. Programa suformuoja studentų pavardžių masyvą ir jį atspausdina. Pavardės (iš viso 5) įvedamos iš klaviatūros.
program Masyvo_sudarymas;
var i:byte;
Pav:array [1..5] of string [10];
begin
{——-Ivedinimas——–}
for i:=1 to 5 ddo
ReadLn (Pav[i]);
{——Isvedimas———–}
for i:=1 to 5 do
WriteLn (pav[i]);
ReadLn;
end.
3. Programa suformuoja skaičių matricą: iš eilės įvestus skaičius išdėsto 6-iomis eilutėmis ir 5 stulpeliais.
program Matricos_formavimas;
var i,j:byte;
Paz:array [1..6,1..5] of byte;
begin
for i:=1 to 6 do {kol i I-aja eilute nesurasomi 5 nariai, tol nepersokama i II-aja}
for j:=1 to 5 do
ReadLn (Paz[i,j]);
{———spausdinimas———–}
for i:=1 to 6 do
begin
for j:=1 to 5 do
Write(Paz[i,j],’ ‘);
WriteLn;
end;
ReadLn;
end.
4. Programa paprašo suvesti 20-ies studentų pažymius, kuriuos išsaugoja faile pazymiai.txt.
program tekst;
type pazymys=array [1..20] of byte;
var paz:pazymys;
i:integer;
failas:text;
begin
Assign (failas,’pazymiai.txt’); {susieja logini faila su fiziniu failu diske}
Rewrite (failas);
for i:= 1 to 20 do
begin
WriteLn (i,’ studento pazymys’);
ReadLn (paz[i]);
WriteLn (failas,paz[i]); {Ishsaugoja ivestus duomenis faile pazymiai.txt}
end;
Close (failas); {uzdaro faila}
end.
5. Nuskaito duomenis (pažymius) iš failo pazymiai.txt ir juos atspausdina.
program tekst;
type pazymys=array [1..20] of byte;
var paz:pazymys;
i:integer;
failas:text;
begin
Assign (failas,’pazymiai.txt’); {susieja logini faila su fiziniu failu diske}
Reset (failas); {nuskaito duomenis ish failo pazymiai.txt}
for i:= 1 to 20 do
begin
ReadLn (failas,paz[i]);
WriteLn (i,’-ojo studento pazymys ‘,paz[i],’.’); {duomenis, nuskaitytus ish failo pazymiai.txt, isveda i ekrana}
end;
Close (failas); {uzdaro faila pazymiai.txt}
ReadLn;
end.
6. Nuskaito duomenis (pažymius) iš failo pazymiai.txt ir randa mažiausia pažymį. Jį atspausdina.
program minimumo_paieska;
type pazymys=array [1..20] of bbyte;
var paz:pazymys; i,min:integer;
failas:text;
begin
Assign (failas,’pazymiai.txt’); {susieja logini faila su fiziniu failu diske}
Reset (failas); {nuskaito duomenis ish failo pazymiai.txt}
min:=100; {pradine minimumo reiksme}
for i:= 1 to 20 do
begin
ReadLn (failas,paz[i]);
if paz[i]max {iesko minimalios reiksmes faile pazymiai.txt}
then max:=paz[i];
end;
WriteLn (‘Maksimali reikshme faile Pazym.txt yra ‘,max,’.’);
Close (failas); {uzdaro faila pazymiai.txt}
ReadLn;
end.
8. Programa nuskaito iš trijų failų (Dalykai.txt, Pazymiai.txt ir Vardai.txt) duomenis, atspausdina juos ir randa, iš kokio dalyko studentė Jovita turi didžiausią pažymį.
program max_pazymys;
type pazymys=array[1..20,1..5] of byte; {pazymiai.txt masyvas}
vardai=array[1..20]of string; {vardai.txt masyvas}
dalykai=array[1..5]of string; {dalykai.txt masyvas}
var paz:pazymys;
i,j,max:integer; ijov,imax:byte; vard:vardai; dalyk:dalykai; failas:text;
begin
{————- Veiksmai su pazymiu masyvu —————————–}
assign(failas,’pazymiai.txt’); {kint. failas susiejimas su failu pazymiai.txt}
reset(failas); {procedura, paruosianti faila pazymiai.txt skaitymui}
for i:=1 to 20 do
begin
writeln; {iterpia tuscia eilute}
for j:=1 to 5 do
begin
read(failas,paz[i,j]);
write(paz[i,j],’ ‘);
end;
end;
close(failas); {uzdaro faila pazymiai.txt}
readln;
{————-Veiksmai su vardu masyvu——————————-}
assign(failas,’vardai.txt ‘); {kint. failas susiejamas su failu vardai.txt}
reset(failas); {paruosia faila vardai.txt skaitymui}
for i:=1 to 20 do
begin
readln(failas,vard[i]);
writeln(i,’ ‘,vard[i]);
end;
close(failas); {uzdaro faila vardai.txt}
readln;
{———–Veiksmai su dalyku masyvu———————————-}
assign(failas,’dalykai.txt ‘); {kint.failas susieja su failu dalykai.txt}
reset(failas); {paruosia faila dalykai.txt skaitymui}
for i:=1 to 5 do
begin
readln(failas,dalyk[i]);
writeln(i,’ ‘,dalyk[i]);
end;
close(failas); {uzdaro faila dalykai.txt}
{————Maksimalaus Jovitos pazymio paieska———————}
for
i:=1 to 20 do
if vard[i]=’Jovita’ then ijov:=i; {isimena Jovitos vardo elemento numeri vardu masyve}
max:=0;
for i:=1 to 5 do
if paz[ijov,i]>max then {iesko maksimalaus pazymio Jovitos pazymiu masyvo eiluteje}
begin
max:=paz[ijov,i];
imax:=i; {isimena maksimalaus pazymio vieta eiluteje, tai ir bus dalyko numeris}
end;
WriteLn;
WriteLn(‘Dalykas, is kurio Jovita turi diziausia pazymi: ‘,dalyk[imax]);
readln;
end.
Failų pavyzdžiai
Dalykai.txt
1. Matematika
2. Informatika
3. Ekonomika
4. Filosofija
5. Logika
Pažymiai.txt
1. 4 5 6 7 8
2. 9 8 7 9 8
3. 6 7 5 7 6
4. 10 9 10 10 9
5. 8 7 8 6 8
6. 8 7 99 7 8
7. 5 6 5 4 6
8. 5 5 6 5 6
9. 7 6 7 7 8
10. 6 9 8 9 8
11. 9 7 8 6 9
12. 10 10 10 10 9
13. 9 9 9 8 8
14. 9 7 9 6 8
15. 4 5 6 4 4
16. 6 5 7 6 7
17. 8 9 9 8 9
18. 7 6 8 7 6
19. 5 6 4 5 6
20. 10 9 10 8 9
Vardai.txt
1. Onute
2. Joniukas
3. Maryte
4. Petriukas
5. Ingute
6. Danas
7. Danute
8. Vytautas
9. Rosita
10. Rimas
11. Daiva
12. Saulius
13. Jovita
14. Gintaras
15. Milda
16. Osvaldas
17. Deimante
18. Kestas
19. Reda
20. Jurate
9. Programa nuskaito is triju failu (Dalykai.txt, PPazymiai.txt ir Vardai.txt) duomenis, atspausdina juos ir suskaiciuoja kiekvieno studento pazymiu vidurki.
program max_pazymys;
type pazymys=array[1..20,1..5] of byte; {pazymiai.txt masyvas}
vardai=array[1..20]of string; {vardai.txt masyvas}
dalykai=array[1..5]of string; {dalykai.txt masyvas}
var paz:pazymys; vard:vardai; dalyk:dalykai;
i,j,max:integer; vid:real; failas:text;
begin
{————- Veiksmai su pazymiu masyvu —————————–}
assign (failas,’pazymiai.txt’); {kint. failas susiejimas su ffailu pazymiai.txt}
reset (failas); {procedura, paruosianti faila pazymiai.txt skaitymui}
for i:=1 to 20 do
begin
WriteLn; {iterpia tuscia eilute}
for j:=1 to 5 do
begin
read (failas,paz[i,j]);
write (paz[i,j],’ ‘);
end;
end;
close (failas); {uzdaro faila pazymiai.txt}
readln;
WriteLn;
{————-Veiksmai su vardu masyvu——————————-}
assign (failas,’vardai.txt ‘);
reset (failas);
for i:=1 to 20 do
begin
readln (failas,vard[i]);
writeln (i,’ ‘,vard[i]);
end;
close(failas);
readln;
{———–Veiksmai su dalyku masyvu———————————-}
assign (failas,’dalykai.txt ‘);
reset (failas);
for i:=1 to 5 do
begin
readln(failas,dalyk[i]);
writeln(i,’ ‘,dalyk[i]);
end;
close(failas);
WriteLn;
{————–Vidurkio skaiciavimas——————-}
assign (failas,’pazymiai.txt’);
reset (failas);
vid:=0;
for j:=1 to 20 do
begin
for i:=1 to 5 do
begin
Read (failas,Paz[i,j]);
vid:= vid + Paz[i,j];
end;
vid:= vid/i;
WriteLn (j,’-ojo studento vidurkis yyra ‘,vid:5:2);
vid:=0;
end;
close (failas);
readln;
end.
3. MASYVAI: rasymas ir skaitymas is dvimacio masyvo, rusiavimas
1. Stomatologinė klinika teikia 4 rūšių paslaugas, kurių pavadinimai pateikti tekstiniame faile Paslaugos.dat. Klinikoje dirba 4 stomatologai, kurių vardai pateikti faile Dantistai.txt. Faile Sumos.ttt pateikti kiekvieno dantisto uždirbti pinigai (patalpinti stulpelyje), teikiant faile išvardintas paslaugas. Parašyti programą, kuri iš tekstinių failų apskaičiuotų ir atspausdintų kiekvienoje paslaugoje uždirbtų pinigų vidurkį. Perrašykite failą Sumos.ttt, papildydami jį vidurkių stulpeliu, o naujas failas turi būti pavadintas Jūsų vardu.
program kontrolinis_2F;
var sum:array[1..4,1..5]of real;
ssum:array[1..4] of real;
i,j:integer;
f1,f2:text;
begin
for i:=1 to 4 do {masyvo valymas}
ssum[i]:=0;
assign(f1,’sumos.ttt’);
reset(f1);
for i:=1 to 4 do
begin
for j:=1 to 4 do
read(f1,sum[i,j]);
readln(f1);
end;
for i:=1 to 4 do
for j:=1 to 4 do
ssum[i]:=ssum[i]+sum[i,j];
for i:=1 to 4 do
begin
sum[i,5]:=ssum[i]/4;
writeln(sum[i,5]);
end;
assign(f2,’kontras.ttt’);
rewrite(f2);
for i:=1 to 4 do
begin
for j:=1 to 5 do
write(f2,sum[i,j]:6:2,’ ‘);
writeln(f2);
end;
Close(f1);
Close(f2);
ReadLn;
end.
2. Programa nuskaito duomenis (siuo atveju 6 skaicius)is failo Rus_File.txt ir surikiuoja juos nuo maziausio iki didziausio.
program rusiavimas;
uses crt;
type skaiciai=array[1..6] of integer;
var skait:skaiciai;
i,j,k,a:integer;
failas:text;
begin
clrscr; {isvalo ekrana}
{————–Nuskaitymas is failo——————-}
Assign (failas,’Rus_File.txt’);
Reset (failas);
WriteLn (‘=====================’);
for i:=1 to 6 do
begin
ReadLn (failas,skait[i]);
WriteLn (skait[i]);
end;
WriteLn (‘——————‘);
WriteLn (‘Isrusiuoti:’);
{—————–Rusiavimas—————————}
for i:=1 to 5 do
begin
k:=i;
for j:=i+1 to 6 do
if skait[j] < skait[k]
then
begin
a:=skait[j];
skait[j]:=skait[k];
skait[k]:=a;
end;
end;
{——————-Atspausdinimas——————-}
for i:=1 to 6 do
WriteLn (skait[i]);
WriteLn (‘======================’);
Close (failas);
ReadLn;
end.
3. Programa nuskaito duomenis (siuo atveju 6 skaicius)is failo Rus_File.txt ir surikiuoja juos nuo maziausio iki didziausio.
program rusiavimas;
uses crt;
type skaiciai=array[1..6] of integer;
var skait:skaiciai;
i,j,k,a:integer;
failas:text;
begin
clrscr; {isvalo ekrana}
{————–Nuskaitymas is failo——————-}
Assign (failas,’Rus_File.txt’);
Reset (failas);
WriteLn (‘= = = = = = = = = = = = = = = = =’);
for i:=1 tto 6 do
begin
ReadLn (failas,skait[i]);
WriteLn (skait[i]);
end;
WriteLn (‘——————‘);
{—————–Rusiavimas—————————}
WriteLn (‘Isrusiuoti:’);
for i:=1 to 5 do
begin
k:=i;
for j:=i+1 to 6 do
if skait[j] < skait[k]
then
begin
a:=skait[j];
skait[j]:=skait[k];
kait[k]:=a;
end;
end;
{——————-Atspausdinimas——————-}
for i:=1 to 6 do
WriteLn (skait[i]);
WriteLn (‘======================’);
{——-Krypties nustatymo procedura——-}
for i:=2 to 6 do
for j:=i downto 2 do
if skait[j] < skait[j-1]
then
begin
a:=skait[j];
skait[j]:=skait[j-1];
skait[j-1]:=a;
end;
Close (failas);
ReadLn;
end.
4. Programa nuskaito duomenis is dvimacio masyvo, apskaiciuoja kiekvieno vaiko vidurki, suformuodama nauja stulpeli, ir pagal ta vidurki surikiuoja visus vaikus nuo turincio didziausia vidurki iki turincio maziausia. Taip pat programa nustato eiluciu ir stulpeliu masyve skaiciu.
Program r_mat_f;
var i,j,k,n,m :integer;
s, av:real;
ap:string[12];
pz:string[3];
x:array[1..30,1..10] of real;
v:array[1..30] of real;
p:array[1..30] of string[12];
d:array[1..30] of string[12];
a:array[1..10] of real;
f,fn:text;
begin
assign(f,’Rnd1r.txt’);
assign(fn,’Rnd1rf.txt’);
reset(f);
rewrite(fn);
i:=1;
while not Eoln(f) do {end of line – eilutes pabaiga}
begin
read (f,d[i]);
i:=i+1;
end;
readln(f);
i:=1;
while not Eof(f) do {end of file – failo pabaiga}
begin
read(f,p[i]);
s:=0;
j:=1;
while not Eoln(f) do
begin
read (f,x[i,j]);
read(f,pz);
s:=s+x[i,j];
j:=j+1;
end;
readln(f);
n:=j-1;
v[i]:=s/n;
i:=i+1;
end;
m:=i-1; {nuskaityta ir apskaiciuotas vidurkis}
Close(f);
writeln(‘eiluciu=’,m,’ stulpeliu=’,n);
for i:=2 to m do
for j:=i downto 2 do {perraso mazejancia tvarka}
if v[j]>v[j-1]
then
begin
av:=v[j];
v[j]:=v[j-1];
v[j-1]:=av; {jei netenkina rusiavimo tvarkos tai sukeiciami vietomis}
for k:=1 to n do
begin
a[k]:=x[j,k];
x[j,k]:=x[j-1,k];
x[j-1,k]:=a[k];
end;
ap:=p[j];
p[j]:=p[j-1];
p[j-1]:=ap;
end; {masyvai surusiuoti, lieka surasyti i faila}
for i:=1 to n do
write(fn,d[i]);
write(fn,’Vidurkis ‘);
writeln(fn);
for i:=1 to m do
begin
write(fn,p[i]);
for j:= 1 to n do
write(fn,x[i,j]:6:3);
write(fn,v[i]:6:3);
writeln(fn);
end;
writeln(fn, ‘matrica surusiuota pagal vidurki mazejimo tvarka’);
Close(fn);
ReadLn;
End.
5. Programa nuskaito duomenis is dvimacio masyvo, apskaiciuoja kiekvieno vaiko vidurki, suformuodama nauja stulpeli, ir pagal ta vidurki surikiuoja visus vaikus nuo turincio didziausia vidurki iki turincio maziausia. Taip pat programa nustato eiluciu ir stulpeliu masyve skaiciu.
Program r_mat_f;
var i,j,k,n,m:integer;
s, av:real;
ap:string[12];
pz:string[3];
x:array[1..30,1..10] of real;
v:array[1..30] of real;
p:array[1..30] of string[12];
d:array[1..30] of string[12];
a:array[1..10] of real;
f,fn:text;
begin
assign(f,’Rnd1r.txt’);
assign(fn,’Rnd1rff.txt’);
reset(f);
rewrite(fn);
for i:=1 to 6 do
read (f,d[i]);
readln(f);
for i:=1 to 20 do
begin
read(f,p[i]);
s:=0;
j:=1;
for j:=1 to 6 do
begin
read (f,x[i,j]);
{read(f,pz);}
s:=s+x[i,j];
end;
readln(f);
v[i]:=s/6;
end; {nuskaityta ir apskaiciuotas vidurkis}
Close(f);
{rusiavimas}
for i:=2 to 20 do
for j:=i downto 2 do
if v[j]>v[j-1] then
begin
av:=v[j];
v[j]:=v[j-1];
v[j-1]:=av; {jei netenkina rusiavimo tvarkos tai sukeiciami vietomis}
for k:=1 to 6 do
begin
a[k]:=x[j,k];
x[j,k]:=x[j-1,k];
x[j-1,k]:=a[k];
end;
ap:=p[j];
p[j]:=p[j-1];
p[j-1]:=ap;
end; {masyvai surusiuoti, lieka surasyti i faila}
for i:=1 to 6 do
write(fn,d[i]);
write(fn,’Vidurkis ‘);
writeln(fn);
for i:=1 to 20 do
begin
write(fn,p[i]);
for j:= 1 to 6 do
write(fn,x[i,j]:6:3);
write(fn,v[i]:6:3);
writeln(fn);
end;
writeln(fn, ‘matrica surusiuota pagal vidurki mazejimo tvarka’);
Close(fn);
ReadLn;
End.
6. Programa nuskaito dvimati masyva, atspausdina ji ekrane ir surusiuota visus mokinius pagal pirmojo dalyko pazymius nuo maziausio iki blogiausio, naujaji dvimati masyva atspausdina ekrane.
program SUPRATIMAS_01;
uses crt;
type vardai=array[1..15] of string [13]; {vardu eilutes aprasas}
rezultatai=array[1..15,1..7] of real; {skaiciu aprasas}
dalykai=array[1..7] of string [12]; {dalyku aprasas}
var vard:vardai;
rez:rezultatai;
dal:dalykai;
f1:text;
i,j,m,a:integer;
temp1:string;
temp2:real;
begin
ClrScr;
Assign (f1,’bendras.txt’);
Reset (f1);
{skaitymas}
j:=1;
while not Eoln(f1) do
begin
Read (f1,dal[j]);
j:=j+1;
end;
ReadLn (f1);
for i:=1 to 15 do
begin
Read (f1,vard[i]);
for j:=1 to 6 do
Read (f1,rez[i,j]);
ReadLn (f1);
end;
{spausdinimas}
for j:=1 to 6 do
Write (dal[j]);
WriteLn;
for i:=1 to 15 do
begin
Write (vard[i]);
for j:=1 to 6 do
Write (rez[i,j]:5:3,’ ‘);
WriteLn;
end;
{NEVEIKIA 
rusiavimas pagal stulpelio pavadinima}
{WriteLn (‘Ivesk dalyko, pagal kuri nori atlikti rikiavima, pavadinima:’);
ReadLn (subject);
m:=0;
for j:=1 to 6 do
if dal[j]=subject then m:=j;
WriteLn (m);}
{rusiavimas paagal 1 stulpeli}
ReadLn;
for a:=1 to 15 do
for i:=1 to 14 do
if rez[i,1] > rez [i+1,1]
then
begin
temp1:=vard[i];
vard[i]:=vard[i+1];
vard[i+1]:=temp1;
for j:=1 to 6 do
begin
temp2:=rez[i,j];
rez[i,j]:=rez[i+1,j];
rez[i+1,j]:=temp2;
end;
end;
{modifikuoto masyvo spausdinimas}
for i:=1 to 6 do
Write (dal[i]);
WriteLn;
for i:=1 to 15 do
begin
Write (vard[i]);
for j:=1 to 6 do
Write (rez[i,j]:5:3,’ ‘);
WriteLn;
end;
Close (f1);
ReadLn;
end.
7. Duoti du failai: 1kiek.txt ir 2sum.dat. Faile 1kiek.txt stulpeliu surasyti vaistu pavadinimai, o salia kiekvieno vaisto yra nurodytas kiekis. Faile 2sum.dat duoti tu paciu vaistu pavadinimai, isrikiuoti kita tvarka, o salia kiekvieno vaisto nurodyta suma. Programa turi atspausdinti pradinius failus ekrane, o taip pat sudauginti to paties vaisto suma ir kieki. Gauta kiekvieno vaaisto sandauga atspausdinti ekrane.
program egzam_A1;
uses crt;
type vaistai=array [1..31] of string [14];
sumos=array [1..31] of longint;
kiekiai=array [1..31] of integer;
var vai_s:vaistai;
vai_k:vaistai;
sum:sumos;
kiek:kiekiai;
i,j:integer;
san:longint;
f1,f2:text;
begin
ClrScr;
Assign (f1,’1kiek.txt’);
Reset (f1);
Assign (f2,’2sum.dat’);
Reset (f2);
{failo 2sum.dat skaitymas}
for i:=1 to 31 do
begin
Read (f2,vai_s[i]);
Read (f2,sum[i]);
ReadLn (f2);
end;
{failo 1kiek.txt skaitymas}
for j:=1 to 31 do
begin
Read (f1,vai_k[j]);
Read (f1,kiek[j]);
ReadLn (f1);
end;
{failo 2sum.dat spausdinimas}
WriteLn (‘*** Failo 2sum.dat spausdinimas ***’);
for i:=1 to 311 do
begin
Write (vai_s[i]);
Write (sum[i]);
WriteLn;
end;
ReadLn;
{failo 1kiek.txt spausdinimas}
WriteLn (‘*** Failo 1kiek.txt spausdinimas ***’);
for j:=1 to 31 do
begin
Write (vai_k[j]);
Write (kiek[j]);
WriteLn;
end;
ReadLn;
{dauginimas}
for i:=1 to 31 do
for j:=1 to 31 do
if vai_s[i]=vai_k[j]
then
begin
san:=(sum[i])*(kiek[j]);
WriteLn (vai_s[i],’ suma * ‘,vai_k[j],’ kiekis: ‘,san);
ReadLn;
end;
Close (f1); Close (f2);
ReadLn;
end.
4. KONTROLINIO DARBO NR.1 UŽDUOTYS
1. Parašyti programą funkcijos reikšmių lentelei apskaičiuoti ir atspausdinti, kai x kinta nuo –5 iki +5 su žingsneliu 0,29
nežinoma, kai x>4 arba x<0;
Y= 6-1,5x, kai 2< x 4;
3x, kai 0 x <2;
0, kai x = 2.
program A2;
uses crt;
var x,y:real;
begin
ClrScr;
WriteLn (‘=======================================’);
x:=-5; y:=0;
While x<0 do
begin
WriteLn (‘> kai x=’,x:2:2,’, tai y reiksme nezinoma <‘);
x:=x+0.29;
end;
WriteLn (‘=======================================’);
While x<2 do
begin
y:=3*x;
WriteLn (‘> kai x=’,x:2:2,’, tai y=’,y:2:2,’ <‘);
x:=x+0.29;
end;
if x=2 then
begin
y:=0;
WriteLn (‘> kai x=’,x:2:2,’, tai y=’,y:2:2,’ <‘);
end;
WriteLn (‘=======================================’);
While x<=4 do
begin
y:=6-(1.5*x);
WriteLn (‘> kai x=’,x:2:2,’, tai y=’,y:2:2,’ <‘);
x:=x+0.29;
end;
WriteLn (‘=======================================’);
While x<5 do
begin
WriteLn (‘> kai x=’,x:2:2,’, tai y reiskme nezinoma <‘);
x:=x+0.29;
end;
WriteLn (‘=======================================’);
ReadLn;
end.
2. Parašyti programą įvesto šešiaženklio skaičiaus transformacijai: antrą skkaitmenį sukeičiant su . penktuoju pvz:.284579 turėtų būti transformuotas taip 274589.
program A3_E3;
uses crt;
var s1,s2,s3,s4,s5,s6:longint; {tarpiniai skaiciai}
trans,prad:longint; {pradinis ir transformuotas skaiciai}
begin
ClrScr;
WriteLn (‘Iveskite sesiazenkli skaiciu:’);
ReadLn (prad);
s1:= prad div 100000; {pirmas skaicius}
s2:= (prad mod 100000) div 10000; {antras skaicius}
s3:= (prad mod 10000) div 1000; {trecias skaicius}
s4:= (prad mod 1000) div 100; {ketvirtas skaicius}
s5:= (prad mod 100) div 10; {penktas skaicius}
s6:= prad mod 10; {sestas skaicius}
trans:=((s1*100000)+(s2*10)+(s3*1000)+(s4*100)+(s5*10000)+(s6*1));
WriteLn (‘Transformuotas sesiazenklis skaicius: ‘,trans,’.’);
ReadLn;
end.
3. Parašyti programą funkcijos reikšmių lentelei apskaičiuoti, kai x kinta nuo –5 iki +10 su žingsneliu 0,35
nežinoma, kai 2>x>0 arba 6>x>4;
Y= 2-x, kai -2< x 0;
8-x, kai 6 x <8;
2, kai 2 x 4;
0 kai x 2 arba x 8.
program B2;
uses crt;
var x,y:real;
begin
ClrScr;
WriteLn (‘=======================================’);
x:=-5; y:=0;
While x<=-2 do
begin
y:=0;
WriteLn (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
x:=x+0.35;
end;
WriteLn (‘=======================================’);
While x<=0 do
begin
y:=2-x;
WriteLn (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
x:=x+0.35;
end;
WriteLn (‘=======================================’);
While x<1.99 do {?????????????}
begin
WriteLn (‘kai x=’,x:2:2,’,tai y nezinomas’);
x:=x+0.35;
end;
WriteLn (‘=======================================’);
While x<=4 do
begin
y:=2;
WriteLn (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
x:=x+0.35;
end;
WriteLn (‘=======================================’);
While x<6 do
begin
WriteLn (&‘kai x=’,x:2:2,’, tai y nezinomas’);
x:=x+0.35;
end;
WriteLn (‘=======================================’);
While x<8 do
begin
y:=8-x;
WriteLn (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
x:=x+0.35;
end;
WriteLn (‘=======================================’);
While x<=10 do
begin
y:=0;
WriteLn (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
x:=x+0.35;
end;
WriteLn (‘=======================================’);
ReadLn;
end.
4. Parašyti programą įvesto septynženklio skaičiaus transformacijai sukeičiant trečią skaimenį su ketvirtu.
program B3_D3_F3;
uses crt;
var s1,s2,s3,s4,s5,s6,s7:longint; {tarpiniai skaiciai}
trans,prad:longint; {pradinis ir transformuotas skaiciai}
begin
ClrScr;
WriteLn (‘Iveskite septynzenklis skaiciu:’);
ReadLn (prad);
s1:= prad div 1000000; {pirmas skaicius}
s2:= (prad mod 1000000) div 100000; {antras skaicius}
s3:= (prad mod 100000) div 10000; {trecias skaicius}
s4:= (prad mod 10000) div 1000; {ketvirtas skaicius}
s5:= (prad mod 1000) div 100; {penktas skaicius}
s6:= (prad mod 100) div 10; {sestas skaicius}
s7:= prad mod 10; {septintas skaicius}
trans:=((s1*1000000)+(s2*100000)+(s3*1000)+(s4*10000)+(s5*100)+(s6*10)+(s7*1));
WriteLn (‘Transformuotas septynzenklis skaicius: ‘,trans,’.’);
ReadLn;
end.
5. Parašyti programą funkcijos reikšmių lentelei apskaičiuoti, kai x kinta nuo –1 iki +12 su žingsneliu 0,37
0, kai x11 arba x<0;
Z= 2x, kai 0 x 3;
6-x, kai 3< x 4;
1, kai 4< x 8;
x-7, kai 8< x 9;
20-2x, kai 9< x <11;
program C2;
uses crt;
var x,y:real;
begin
ClrScr;
WriteLn (‘=======================================’);
x:=-1; y:=0;
While x<0.0001 do
begin
y:=0;
WriteLn (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
x:=x+0.37;
end;
WriteLn (‘=======================================’);
While x<3 do
begin
y:=2*x;
WriteLn (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
x:=x+0.37;
end;
WriteLn (‘=======================================’);
While x<4 do
begin
y:=6-x;
WriteLn (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
x:=x+0.37;
end;
WriteLn (‘=======================================’);
While x<7.999 do
begin
y:=1;
WriteLn (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
x:=x+0.37;
end;
WriteLn (‘=======================================’);
While x<9 do
begin
y:=x-7;
WriteLn (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
x:=x+0.37;
end;
WriteLn (‘=======================================’);
While x<11 do
begin
y:=20-(2*x);
Writeln (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
x:=x+0.37;
end;
WriteLn (‘=======================================’);
While x<12 do
begin
y:=0;
WriteLn (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
x:=x+0.37;
end;
WriteLn (‘=======================================’);
ReadLn;
end.
6. Parašyti programą įvesto penkiaženklio skaičiaus ttransformacijai sukeičiant trečią skaimenį su pirmu.
program C3;
uses crt;
var s1,s2,s3,s4,s5:longint; {tarpiniai skaiciai}
trans,prad:longint; {pradinis ir transformuotas skaiciai}
begin
ClrScr;
WriteLn (‘Iveskite penkiazenkli skaiciu:’);
ReadLn (prad);
s1:= prad div 10000; {1-as skaicius}
s2:= (prad mod 10000) div 1000; {2-as skaicius}
s3:= (prad mod 1000) div 100; {3-as skaicius}
s4:= (prad mod 100) div 10; {4-as skaicius}
s5:= prad mod 10; {5-as skaicius}
trans:=((s1*100)+(s2*1000)+(s3*10000)+(s4*10)+(s5*1));
WriteLn (‘Transformuotas sesiazenklis skaicius: ‘,trans,’.’);
ReadLn;
end.
7. Parašyti programą funkcijos reikšmių lentelei apskaičiuoti ir atspausdinti, kai x kinta nuo –5 iiki +10 su žingsneliu 0,45
nežinoma, kai 2>x>0 arba 6>x>4;
Y= 2-x, kai -2< x 0;
8-x, kai 6 x <8;
2, kai 2 x 4;
0, kai x <- 2 arba x 8.
program D2;
uses crt;
var x,y:real;
begin
ClrScr;
WriteLn (‘=======================================’);
x:=-5; yy:=0;
While x<-2 do
begin
y:=0;
WriteLn (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
x:=x+0.45;
end;
WriteLn (‘=======================================’);
While x<=0 do
begin
y:=2-x;
WriteLn (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
x:=x+0.45;
end;
WriteLn (‘=======================================’);
While x<1.99 do {?????????????}
begin
WriteLn (‘kai x=’,x:2:2,’,tai y nezinomas’);
x:=x+0.45;
end;
WriteLn (‘=======================================’);
While x<=4 do
begin
y:=2;
WriteLn (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
x:=x+0.45;
end;
WriteLn (‘=======================================’);
While x<6 do
begin
WriteLn (‘kai x=’,x:2:2,’, tai y nezinomas’);
x:=x+0.45;
end;
WriteLn (‘=======================================’);
While x<8 do
begin
y:=8-x;
WriteLn (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
x:=x+0.45;
end;
WriteLn (‘=======================================’);
While x<=10 do
begin
y:=0;
WriteLn (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
x:=x+0.45;
end;
WriteLn (‘=======================================’);
ReadLn;
end.
8. Parašyti programą konstantai C apskaičiuoti tikslumu , įvedamu iš klaviatūros, pagal eilutę
program E1;
uses crt;
var e,C,narys:real;
n:integer;
begin
ClrScr;
WriteLn (‘Ivesk eepsilion reiksme:’);
ReadLn (e);
narys:=2/7; {imame n=1 ir apskaiciuojam, kam bus lygus narys}
C:=0; n:=1;
while narys>=e do
begin
C:=C+narys;
n:=n+1;
narys:=(sqr(n)+1)/(3*((sqr(n))*(sqr(n)))+4);
end;
WriteLn (‘C=’,C:2:2);
ReadLn;
end.
9. Parašyti programą funkcijos reikšmių lentelei apskaičiuoti ir atspausdinti, kai x kinta nuo –5 iki +5 su žingsneliu 0,2
nežinoma, kai x>4 arba x<0;
Y= 6-1,5x, kai 2< x 4;
3x, kai 0 x <2;
0, kai x = 2.
program E2;
uses crt;
var x,y:real;
begin
ClrScr;
WriteLn (‘=======================================’);
x:=-5; y:=0;
While x<-0.01 do
begin
WriteLn (‘kai x=’,x:2:2,’, tai y reiksme nnezinoma’);
x:=x+0.2;
end;
WriteLn (‘=======================================’);
While x<1.99 do
begin
y:=3*x;
WriteLn (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
x:=x+0.2;
end;
WriteLn (‘=======================================’);
x:=2;
if x=2 then
begin
y:=1;
WriteLn (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
end;
WriteLn (‘=======================================’);
While x<4.01 do
begin
y:=6-(1.5*x);
WriteLn (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
x:=x+0.2;
end;
WriteLn (‘=======================================’);
While x<5 do
begin
WriteLn (‘kai x=’,x:2:2,’, tai y reiskme nezinoma’);
x:=x+0.2;
end;
WriteLn (‘=======================================’);
ReadLn;
end.
10. Parašyti procedūrą konstantai B apskaičiuoti tikslumu pagal eilutę
program F1_mok;
uses crt;
var e,c,narys:real;
n:integer;
function vard(n:integer):longint;
var i:integer; f:longint; {f-sandaugos kaupimas}
begin
f:=n;
for i:=1 to n do
f:=f*5;
vard:=f;
end;
begin
ClrScr;
narys:=3/5; {imame n=1 ir apskaiciuojame, kad bus lygus narys}
ReadLn (e);
n:=1;
c:=0;
while narys>=e do
begin
c:=c+narys;
n:=n+1;
narys:=(2*n+1)/vard(n);
end;
WriteLn (‘C=’,C:8:5,’.’);
ReadLn;
end.
11. Parašyti programą funkcijos reikšmių lentelei apskaičiuoti, kai x kinta nuo –5 iki +10 su žingsneliu 0,5
nežinoma, kai 2>x>0 arba 6>x>4;
Y= 2-x, kai -2< x 0;
8-x, kai 6 x <8;
2, kai 2 x 4;
0, kai x 2 arba x 8.
program F2;
uses crt;
var x,y:real;
begin
ClrScr;
WriteLn (‘=======================================’);
x:=-5; y:=0;
While x<-2 do
begin
y:=0;
WriteLn (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
x:=x+0.5;
end;
WriteLn (‘=======================================’);
While x<=0 do
begin
y:=2-x;
WriteLn (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
x:=x+0.5;
end;
WriteLn (‘=======================================’);
While x<1.99 do {?????????????}
begin
WriteLn (‘kai x=’,x:2:2,’,tai y nezinomas’);
x:=x+0.5;
end;
WriteLn (‘=======================================’);
While x<=4 do
begin
y:=2;
WriteLn (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
x:=x+0.5;
end;
WriteLn (‘=======================================’);
While x<6 do
begin
WriteLn (‘kai x=’,x:2:2,’, tai y nezinomas’);
x:=x+0.5;
end;
WriteLn (‘=======================================’);
While x<8 do
begin
y:=8-x;
WriteLn (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
x:=x+0.5;
end;
WriteLn (‘=======================================’);
While x<=10 do
begin
y:=0;
WriteLn (‘kai x=’,x:2:2,’, tai y=’,y:2:2);
x:=x+0.5;
end;
WriteLn (‘=======================================’);
ReadLn;
end.
ARBA
program F2_MOK;
uses crt;
var x,y:real;
poz:boolean; {pozymis}
begin
x:=-5;
while x<=10 do
begin
poz:=true;
Write (‘x= ‘,x:5:3,’ ‘);
if (x<=-2) or (x>=8)
then y:=0
else
if x<0
then y:=2-x
else
if (x>=2) and (x<=4)
then y:=2
else
if x>=6
then y:=8-x
else
begin
poz:=not(poz);
WriteLn (‘y nezinomas’);
end;
if poz then WriteLn (‘y=’,y:5:3);
WriteLn;
x:=x+0.5;
end;
ReadLn;
end.
5. KONTROLINIO DARBO NR.2 UŽDUOTYS
1. Kauno urėdija turi 7 girininkijas, kurių vardai pateikti tekstiniame faile Girinik.dat. Urėdijoje medieną ruošia 5 brigados, kurių brigadininkų vardai pateikti faile Brigados.dat. Faile Kietmet.dat pateikti kiekvienos brigados paruoštos medienos kiekiai kietmetriais kiekvienoje girininkijoje. Parašyti programą, kuri iš tekstinių failų apskaičiuotų kiekvienos brigados paruoštą medienos kiekį (sudedant vienos brigados parengtus medienos kiekius visose girininkijose). Gauta sumarinių paruoštos medienos kiekių eilute papildyti failą Kietmet.dat.
program k2A;
uses crt;
var sum:array[1..5,1..4] of real;
ssum:array[1..4] of real;
i,j:integer;
f1,f2:text;
begin
ClrScr;
for i:=1 to 4 do {masyvo valymas}
ssum[i]:=0;
assign(f1,’sumos.ttt’);
reset(f1);
for i:=1 to 4 do {masyvo skaitymas}
begin
for j:=1 to 4 do
read(f1,sum[i,j]);
readln(f1);
end;
for i:=1 to 4 do {sumavimas}
for j:=1 to 4 do
ssum[j]:=ssum[j]+sum[i,j];
for j:=1 to 4 do {vidurkio suskaiciavimas, patalpinimas i stulpeli}
begin
sum[5,j]:=ssum[j];
write (sum[5,j]:2:2,’ ‘);
end;
assign(f2,’k2A.ttt’); {irasymas i faila}
rewrite(f2);
for i:=1 to 5 do
begin
for j:=1 to 4 do
write(f2,sum[i,j]:2:2,’ ‘);
writeLn(f2);
end;
close(f1);
close(f2);
ReadLn;
end.
2. Kauno urėdija turi 7 girininkijas, kurių vardai pateikti tekstiniame faile Girinik.dat. Urėdijoje medieną ruošia 5 brigados, kurių brigadininkų vardai pateikti faile Brigados.dat. Faile Kietmet.dat pateikti kiekvienos brigados paruoštos medienos kiekiai kietmetriais kiekvienoje girininkijoje. Parašykite programą, kuri iš tekstinių failų apskaičiuotų kiekvienoje girinikijoje paruoštą medienos kiekį (sudedant visų brigadų parengtus medienos kiekius vienoje girininkijoje). Gautu sumarinių paruoštos medienos kiekių stulpeliu papildykite failą Kietmet.dat.
program k2B;
uses crt;
var sum:array[1..4,1..5] of real;
ssum:array[1..4] of real;
i,j:integer;
f1,f2:text;
begin
ClrScr;
for i:=1 to 4 do {masyvo valymas}
ssum[i]:=0;
assign(f1,’sumos.ttt’);
reset(f1);
for i:=1 to 4 do {masyvo skaitymas}
begin
for j:=1 to 4 do {skaitome tik 4 stulpelius, kadangi 5-ojo dar nera}
read(f1,sum[i,j]);
readln(f1);
end;
for i:=1 to 4 do {sumavimas}
for j:=1 to 4 do
ssum[i]:=ssum[i]+sum[i,j];
for i:=1
to 4 do {vidurkio suskaiciavimas, patalpinimas i stulpeli}
begin
sum[i,5]:=ssum[i];
writeLn (sum[i,5]:2:2,’ ‘);
end;
assign(f2,’k2B.ttt’); {irasymas i faila}
rewrite(f2);
for i:=1 to 4 do
begin
for j:=1 to 5 do
write(f2,sum[i,j]:2:2,’ ‘);
writeLn(f2);
end;
close(f1);
close(f2);
ReadLn;
end.
3. Transporto kontora turi 8 automobilius, kurių markės pateiktos tekstiniame faile Auto.txt. Automobilius vairuoja 4 vairuotojai, kurių vardai pateikti faile Vairuot.txt. Faile Km.txt pateikti kiekvieno vairuotojo nuvažiuoti atstumai kilometrais su kiekvienos markės automobiliu. Parašyti programą, kuri iš tekstinių failų apskaičiuotų ir atspausdintų vairuotojo vardą, kuris nnuvažiavo didžiausią sumarinį atstumą su visų markių automobiliais. Perrašykite failą Vairuot.txt, vietoje daugiausiai nuvažiavusio vairuotojo įrašydami savo vardą.
program k2C;
uses crt;
type paslaug=array [1..20] of string;
var sum:array[1..4,1..5] of real;
ssum:array[1..4] of real;
pasl:paslaug;
i,j,imax:integer;
max:real;
f1,f2,f3:text;
begin
ClrScr;
for i:=1 to 4 do {masyvo valymas}
ssum[i]:=0;
assign(f1,’sumos.ttt’);
reset(f1);
assign (f3,’paslaug.txt’);
reset(f3);
for i:=1 to 4 do {sumu masyvo skaitymas}
begin
for j:=1 to 4 do {skaitome tik 4 stulpelius, kadangi 5-ojo dar nera}
read(f1,sum[i,j]);
readln(f1);
end;
for i:=1 tto 4 do {paslaugu masyvo skaitymas}
begin
ReadLn (f3,pasl[i]);
WriteLn (pasl[i]);
end;
WriteLn;
for i:=1 to 4 do {sumavimas}
for j:=1 to 4 do
ssum[i]:=ssum[i]+sum[i,j];
for i:=1 to 4 do {vidurkio suskaiciavimas, patalpinimas i stulpeli}
begin
sum[i,5]:=ssum[i];
writeLn (sum[i,5]:2:2,’ ‘);
end;
assign(f2,’k2C.ttt’); {irasymas i faila}
rewrite(f2);
for i:=1 to 4 do
begin
for j:=1 to 5 do
write(f2,sum[i,j]:2:2,’ ‘);
writeLn(f2);
end;
{maksimalios sumos paieska}
max:=0;
for i:=1 to 4 do
if sum[i,5]>max
then
begin
max:=sum[i,5];
imax:=i;
end;
WriteLn (‘Max reiksme yra ‘,max:6:2);
WriteLn (‘Paslauga, kurioje uzdirbta daugiausia, yra ‘,pasl[imax],’.’);
pasl[imax]:=’dalia’;
Writeln (pasl[imax]);
close (f1);
close (f2);
close (f3);
ReadLn;
end.
4. Stomatologinė klinika teikia 4 rūšių paslaugas, kurių pavadinimai pateikti tekstiniame faile Paslaugos.dat. Klinikoje dirba 4 stomatologai, kurių vardai pateikti faile Dantistai.txt. Faile Sumos.ttt pateikti kiekvieno dantisto uždirbti pinigai (patalpinti stulpelyje), teikiant faile išvardintas paslaugas. Parašyti programą, kuri iš tekstinių failų apskaičiuotų ir atspausdintų kiekvienoje paslaugoje uždirbtų pinigų vidurkį. Perrašykite failą Sumos.ttt, papildydami jį vidurkių stulpeliu, o naujas failas turi būti ppavadintas Jūsų vardu.
program k2f;
var sum:array[1..4,1..5]of real;
ssum:array[1..4] of real;
i,j:integer;
f1,f2:text;
begin
for i:=1 to 4 do {masyvo valymas}
ssum[i]:=0;
assign(f1,’sumos.ttt’);
reset(f1);
for i:=1 to 4 do {masyvo skaitymas}
begin
for j:=1 to 4 do
read(f1,sum[i,j]);
readln(f1);
end;
for i:=1 to 4 do {sumavimas}
for j:=1 to 4 do
ssum[i]:=ssum[i]+sum[i,j];
for i:=1 to 4 do {vidurkio suskaiciavimas, patalpinimas i stulpeli}
begin
sum[i,5]:=ssum[i]/4;
writeln(sum[i,5]:2:2);
end;
assign(f2,’kontras.ttt’); {irasymas i faila}
rewrite(f2);
for i:=1 to 4 do
begin
for j:=1 to 55 do
write(f2,sum[i,j]:2:2,’ ‘);
writeln(f2);
end;
close(f1);
close(f2);
ReadLn;
end.
6. EGZAMINO UŽDUOTYS, A variantas
1. Parašyti programą funkcijos reikšmių lentelei apskaičiuoti ir atspausdinti, kai x kinta nuo –7 su žingsneliu 0,37 iki 0 ir su žingsneliu 0,21 iki +7:
0, kai x<-6, arba x>6 ir x=2 bei x=-2
Y= nežinomas kai x<-4, bet x>-6 arba x<4, bet x<6
7,5×2-1,3x kai x<0, bet x>-4 arba x>0, bet x<4
program dalia1;
uses crt;
var x,y:real;
begin
ClrScr;
y:=0; x:=-7;
WriteLn (‘—————————————–‘);
while x<-6 do
begin
y:=0;
WriteLn (‘Kai x=’,x:5:2,’, tai y=’,y:5:2,’.’);
x:=x+0.37;
end;
WriteLn (‘—————————————–‘);
while x<-4 do
begin
WriteLn (‘Kai x=’,x:5:2,’, tai y reiksme nezinoma.’);
x:=x+0.37;
end;
WriteLn (‘—————————————–‘);
while x<-1.99 do
begin
y:=(7.5*sqr(x))-(1.3*x);
WriteLn (‘Kai x=’,x:5:2,’, tai y=’,y:5:2,’.’);
x:=x+0.37;
end;
if x=-2 then WriteLn (‘Kai x=’,x:5:2,’, tai y=’,y:5:2,’.’);
WriteLn (‘—————————————–‘);
while x<0 do
begin
y:=(7.5*sqr(x))-(1.3*x);
WriteLn (‘Kai x=’,x:5:2,’, tai y=’,y:5:2,’.’);
x:=x+0.37;
end;
{nuo 0 zingsnelis keiciasi}
x:=0;
WriteLn (‘—————————————–‘);
while x<1.99 do
begin
y:=(7.5*sqr(x))-(1.3*x);
WriteLn (‘Kai x=’,x:5:2,’, tai y=’,y:5:2,’.’);
x:=x+0.21;
end;
if x=2 then WriteLn (‘Kai x=’,x:5:2,’, tai y=’,y:5:2,’.’);
WriteLn (‘—————————————–‘);
while x<4 do
begin
y:=(7.5*sqr(x))-(1.3*x);
WriteLn (‘Kai x=’,x:5:2,’, tai y=’,y:5:2,’.’);
x:=x+0.21;
end;
ReadLn;
WriteLn (‘—————————————–‘);
while x<6 do
begin
WriteLn (‘Kai x=’,x:5:2,’, tai y reiksme nezinoma.’);
x:=x+0.21;
end;
WriteLn (‘—————————————–‘);
while x<7 do
begin
y:=0;
WriteLn ((‘Kai x=’,x:5:2,’, tai y=’,y:5:2,’.’);
x:=x+0.21;
end;
WriteLn (‘—————————————-‘);
ReadLn;
end.
2. Parašyti programą įvesto penkiaženklio skaičiaus transformacijai: antrą skaitmenį sukeičiant su ketvirtu. Pvz:.28457 turėtų būti transformuotas taip 25487.
program dalia2;
uses crt;
var s1,s2,s3,s4,s5:longint; {tarpiniai skaiciai}
trans,prad:longint; {pradinis ir transformuotas skaiciai}
begin
ClrScr;
WriteLn (‘Iveskite sveika penkiazenkli skaiciu:’);
ReadLn (prad);
s1:= prad div 10000; {1-asis skaicius}
s2:= (prad mod 10000) div 1000; {2-asis skaicius}
s3:= (prad mod 1000) div 100; {3-asis skaicius}
s4:= (prad mod 100) div 10; {4-asis skaicius}
s5:= prad mod 10; {5-asis skaicius}
{Skaiciaus formavimas – antro skaiciaus keitimas su ketvirtu}
trans:=((s1*10000)+(s2*10)+(s3*100)+(s4*1000)+(s5*1));
WriteLn (‘Transformuotas penkiazenklis skaicius: ‘,trans,’.’);
ReadLn;
end.
3. Duoti failai Prekes.dat, kuriame pateikiami parduotuvėje esančių prekių pavadinimai jų kiekiai, ir Kainos.txt., kuriame pateikiama kiekvienos prekės kaina. Parašyti programą, kuri suskaičiuotų, už kokią sumą parduotuvėje yra kiekvienos prekės, sudaugindama kiekvienos prekės kiekį ir kainą. Naujai gautus duomenis įrašyti į failą, pavadintą pirmom 7 jūsų pavardės raidėm ir skaičiumi 3. Failo pradžioje turi būti padarytas įrašas, susidedantis iš tikslaus jūsų grupės šifro, pavardės, vardo ir gimimo datos.
program dalia3;
uses crt;
type preke=array[1..21] of string [10]; {prekiu masyve}
kiekis=array[1..21] of longint; {prekiu masyve}
kaina=array[1..21] of real; {kainu masyve}
var prek:preke;
kiek:kiekis;
kain:kaina;
i:integer;
f1,f2,f3:text;
m:real;
begin
ClrScr;
Assign (f1,’Prekes.dat’);
Reset (f1);
Assign (f2,’Kainos.txt’);
Reset (f2);
Assign (f3,’Bielsky3.txt’);
Rewrite (f3);
{failu skaitymas}
for i:=1 tto 21 do
ReadLn (f2,kain[i]);
for i:=1 to 21 do
begin
Read (f1,prek[i]);
Read (f1,kiek[i]);
ReadLn (f1);
end;
{spausdinimas}
for i:=1 to 21 do
WriteLn (kain[i]:5:2);
for i:=1 to 21 do
begin
Write (prek[i]);
Write (kiek[i]);
WriteLn;
end;
ReadLn;
{Irasas naujai sukurtame faile}
WriteLn (f3,’VI32, BIELSKYTE DALIA, 1983 m. liepos 30 d.’);
WriteLn (f3);
{Skaiciavimas}
WriteLn (‘Parduotuveje yra prekiu uz tokias pinigu sumas:’);
WriteLn (f3,’Parduotuveje yra prekiu uz tokias pinigu sumas:’);
m:=0;
for i:=1 to 21 do
begin
m:=((kiek[i])*(kain[i]));
WriteLn (prek[i],’ ‘,m:7:2);
WriteLn (f3,prek[i],’ ‘,m:7:2);
end;
Close (f1);
Close (f2);
Close (f3);
ReadLn;
end.
4. Duotas failas Masyvas.dat, kuriame duoti vaistų pavadinimai ir kiekvieno jų kiekiai. Parašyto programą, kuri atspausdintų pradinius duomenis ekrane, surūšiuotų vaistus pagal jų kiekį mažėjimo tvarka ir naujus duomenis atspausdintų ekrane bei faile, pavadintame 7 pirmom jūsų pavardės raidėm ir skaičiumi 4. Failo paskutiniu įrašu turi būti jūsų gimimo data, vardas, pavardė ir grupės šifras.
program dalia4;
uses crt;
type vaistas=array[1..35] of string [14];
kiekis=array[1..35] of real;
var vaist:vaistas;
kiek:kiekis;
f1,f2:text;
i,j,a:integer;
tmp1:string [14];
tmp2:real;
begin
ClrScr;
Assign (f1,’Masyvas.dat’);
Reset (f1);
Assign (f2,’Bielsky4.txt’);
Rewrite (f2);
{failu skaitymas}
for i:=1 to 35 do
begin
Read (f1,vaist[i]);
Read (f1,kiek[i]);
ReadLn (f1);
end;
{spausdinimas ekrane}
for i:=1 to 35 do
begin
Write (vaist[i]);
Write (kiek[i]:5:2);
WriteLn;
end;
ReadLn;
{rusiavimas}
WriteLn (‘————-SURUSIUOTAS MASYVAS—————‘);
WriteLn;
WriteLn (f2,’————-SURUSIUOTAS MASYVAS—————‘);
WriteLn (f2);
for a:=1 to 35 do
for i:=1 to 34 do
if kiek[i]
