Programavimas

19 Apr 07 20:09:53 GMT

1. Masyvas ir eilutë

Spræsdami uþdavinius iki ðiol vartojome tik paprastuosius duomenis, turinèius atskiras, pavienes reikðmes. Programose daþnai prireikia ne vien pavieniø duomenø reikðmiø, o vienaip ar kitaip susietø duomenø rinkiniø. Tokie duomenø rinkiniai vadinami duomenø struktûromis arba struktûriniais duomenimis. Viena daþniausiai vartojamø duomenø struktûrø yra masyvas, kurá ir panagrinësime ðiame skyriuje. Taip pat supaþindinsime ir su eilutëmis - jas galima laikyti atskiru masyvo atveju, kurio elementai - simboliai.

1.1. Masyvo sàvoka

Masyvais vadinami vienodo tipo duomenø rinkiniai, kuriuose svarbi elementø iðdëstymo tvarka. Masyvà paprasèiausiu atveju galime ásivaizduoti kaip dydþiø eilæ, kurioje jie suþymëti ið eilës. Paprasèiausias þymëjimas yra numeracija eilës tvarka. Daþniausiai numeracija pradedama vienetu. Tie numeriai vadinami indeksais. Matematikoje indeksai raðomi vardo apaèioje. Programavimo kalbose taip raðyti negalima, todël indeksai raðomi ðalia vardo lauþtiniuose skliaustuose.

Skaièiø masyvas A (reikðmës):	15 -3 18 45 2.5 -45.24 -7.5
Elementø indeksai (numeriai):	1 2 3 4 5 6 7
Elementø uþraðymas:	a₁ a₂a₃a₄a₅a₆a₇
Uþraðymas Turbo Paskaliu:	A[1] A[2] A[3] A[4] A[5] A[6] A[7]

Kadangi masyvo elementø iðdëstymas nurodomas indeksais, tai patys masyvø elementai vadinami indeksuotaisiais kintamaisiais. Elemento indeksas gali bûti sveikasis skaièius arba sveikojo tipo kintamasis, arba net reiðkinys, kurio rezultatas yra sveikasis skaièius. Elementus galima numeruoti ir raidëmis. Tuomet indekso kintamasis turi bûti simbolinio (char) tipo.

Masyvo elementais gali bûti bet kuris anksèiau apraðytas duomenø tipas. Svarbu tik, kad visi vienà masyvà sudarantys elementai bûtø to paties tipo.

Paskalio kalboje masyvas apraðomas nurodant jo elementø tipà ir jo indeksø tipà (21 pav.)

21 pav. Masyvo apraðo sintaksës diagrama

Daþniausiai indekso tipas nurodomas sveikuoju tipu. Kadangi ðis tipas pakankamai didelis (turi daug reikðmiø), tai bûtina nurodyti ne patá tipo vardà (kaip galima daryti esant loginiam ar simboliniam tipams), o jo atkarpà - maþiausià ir didþiausià leistinà reikðmæ.

Masyvo duomenø tipo Turbo Paskalyje nëra. Programuotojas turi pats susikurti reikalingà masyvo tipà pagal nurodytas taisykles (21 pav.). Po to galima apraðyti sukurto masyvo tipo kintamuosius. Masyvo tipø ir kintamøjø apraðø pavyzdþiai:

const Max = 100;
type Masyvas1 = array [1..50] of real;
Masyvas2 = array [1..Max] of boolean;
Masyvas3 = array [char] of integer;
Masyvas4 = array [1..200] of char;
var A, B : Masyvas1;
X : Masyvas2;
Z : Masyvas3;
R : Masyvas4;

Èia pavartota dar viena apraðø rûðis - duomenø tipø, kuris pradedamas nurodþius þodá type. Tipo apraðo kairëje lygybës pusëje nurodomas naujasis tipo vardas, deðinëje - tipo vardas.

Jeigu masyvo elemento tipu bus pavartotas masyvas, susidarys struktûra, kuri vadinama daugiamaèiu masyvu. Paprasèiausia masyvo matavimà atskirti pagal vienam elementui nurodyti reikalingà indeksø skaièiø: jei elementai nurodomi vienu indeksu, toks masyvas vadinamas vienmaèiu, jeigu dviem - dvimaèiu ir t. t. Daþniausiai vartojami dvimaèiai masyvai, kurie dar kartais vadinami lentelëmis (jø elementø iðdëstymà patogu pavaizduoti lentele). Dvimaèiø masyvø pavyzdþiai:

type Eil = array [1..10] of integer;
Lent = array [1..5] of Eil;

Galimi ir kitokie uþraðø variantai. Mes á tai nesigilinsime, visuomet galima paþvelgti á Paskalio kalbà apraðanèius þinynus.

Masyvø elementai vartojami reiðkiniuose bei kitose konstrukcijose taip, kaip ir paprasti kintamieji. Visam masyvui ið karto galima taikyti tiktai priskyrimo operacijà, taèiau tokiu atveju bûtina, kad abu operacijoje nurodomi masyvai bûtø apraðyti vienodai (tuo paèiu masyvo tipu):

type Mas = array [1..20] of char;
var A, B : Mas;
...
A := B;

Programose masyvai yra patogi vardø sisteminimo ir duomenø grupavimo priemonë. Jie ypaè efektyvûs tada, kai programoje tenka keletà kartø perþiûrëti tà patá duomenø rinkiná arba kai formuojami ir apdorojami susijusiø dydþiø rinkiniai.

Masyve galima laikyti ne daugiau reikðmiø negu nurodyta jo apraðe. Sakydami, kad masyve, pavyzdþiui, yra 10 skaièiø, suprasime, kad pirmasis ið jø yra pirmoje vietoje, antrasis - antroje ir t. t. Programose labai svarbu stebëti, kad indekso reikðmë visuomet bûtø ið apraðyto intervalo.

Jeigu pirmojo elemento indeksas yra vienetas (patogiausias atvejis, nes taip priimta ir matematikoje), tuomet elementø skaièius ir paskutinës áraðytos reikðmës indeksas sutampa. Sakydami, kad masyve yra 10 skaièiø, suprasime, kad paskutinis 10-asis skaièius yra deðimtoje vietoje.

Ávedant duomenis tikslinga patikrinti, ar tiek elementø tilps masyve. Jeigu ne, tuomet reikëtø numatyti galimus tolesnius veiksmus: nutraukti programos darbà, priimti maksimaliai leistinà reikðmiø skaièiø, pasiûlyti vartotojui naujai nurodyti masyvo reikðmiø skaièiø ir pan.
= 5.1 pratimas. Tarkime, kad turime daug apskritimø. Þinomi jø spinduliø ilgiai. Reikia surasti didþiausià apskritimà ir nustatyti, kiek ið viso yra tokiø didþiausiø apskritimø. Duomenys ávedami klaviatûra ir ið karto suraðomi á masyvà.

Apskritimø ilgiø skaièiuoti nereikia. Akivaizdu, kad pakanka nustatyti, kurio apskritimo spindulys ilgiausias.

program P5_1;
uses Crt;
type Masyvas = array [1..50] of real;
{----------------------------------------------------}
procedure Langas (x1, y1, x2, y2, spalva : integer);
begin
Window(x1, y1, x2, y2);
TextBackground( spalva ); ClrScr;
end;
{----------------------------------------------------}
procedure Duomenys (var A : Masyvas; var n : integer);
var i : integer;
begin
Langas(5, 5, 55, 10, Blue);
TextColor(Red);
WriteLn('Duomenø ávedimas');
Write('Kiek yra apskritimø? = '); ReadLn(n);
TextColor(Green);
for i := 1 to n do
begin
GoToXY(5, 4);
Write('Apskritimo nr. ', i:3, ' spindulys = ');
ClrEol; { Valoma eilutë: nuo þymeklio vietos iki galo }
ReadLn(A); { Apskritimo spindulio reikðmë áraðoma á masyvà }
end;
end;
{----------------------------------------------------}
procedure Didelis (var A : Masyvas; n : integer;
var nr : integer);
var i : integer;
begin
nr := 1; { Pirmasis apskritimas}
for i := 1 to n do
if A > A[nr] then nr := i;
end;
{----------------------------------------------------}
procedure Kiek (var A : masyvas; n : integer;
nr : integer; var k : integer);
var i : integer;
begin
k := 0;
for i := 1 to n do
if Abs(A - A[nr]) <= 0.01 { Realieji skaièiai lyginami }
then k := k + 1; { tam tikru tikslumu }
end;
{---------------------------------------------------------}
var A : Masyvas; { Spinduliø ilgiø sàraðas }
n,
dnr, { Didþiausio apskritimo numeris }
dk : integer; { Didþiausiø apskritimø skaièius }

begin
Langas (1, 1, 80, 25, Black);

Duomenys(A, n);
Didelis(A, n, dnr);
Kiek(A, n, dnr, dk);

Langas(1, 1, 80, 25, Black);

Langas(10, 10, 50, 14, Blue);
TextColor(Black);

WriteLn('Ilgiausias apskritimas yra: ', dnr);
WriteLn(' Jo spindulys: ', A[dnr]:5:2);
WriteLn(' Tokiø surasta: ', dk);

ReadLn;
end.

Kontrolinës uþduotys

Papildykite 5.1 pratimo programà taip, kad ji papildomai spausdintø didþiausio apskritimo ilgá.
Ði programa negali laikyti masyve daugiau kaip 50 skaièiø (þr. masyvo tipo apraðà). Kaip reikëtø pakeisti programà, kad ji tikrintø, ar ávedamas apskritimø skaièius nëra didesnis? Sugalvokite, kà daryti, kai taip atsitiktø ir papildykite programà.
Papildykite programà, kad ji turëtø antraðtiná puslapá - uþsklandà. Tai bûtø programos prisistatymas. Èia gali bûti numatyti þaismingi vaizdeliai ekrane: programa galëtø pasisveikinti su vartotoju ir paraðyti, kà ji þada daryti, kas jos autorius. Tam paprastai daromos atskiros procedûros.

5.2. Veiksmai su masyvo elementais

Su masyvo elementais galima atlikti ávairius veiksmus, tokius pat, kaip ir su paprastaisiais kintamaisiais. Pavyzdþiui, masyvo elementus (indeksuotus kintamuosius) galima vartoti reiðkiniuose, ciklø sàlygose, skaitymo ir raðymo sakiniuose ir pan.

Panagrinëkime keletà masyvams bûdingø situacijø. Pirmiausiai apraðykime reikalingus kintamuosius:

type Mas = array [1..50] of real;
var A, D : Mas;
i, n, k : integer;

Daþniausiai reikalingas veiksmas - tai masyvo uþpildymas pradinëmis reikðmëmis. Tà atliekame vartodami ciklà:

for i := 1 to 50 do A := 0;

Paskalio kalba neturi priemoniø visam masyvui ið karto perskaityti bei iðspausdinti. Ðiems veiksmams atlikti reikia vartoti ciklus:

ReadLn(n);
for i := 1 to n do ReadLn(A);

Visiðkai analogiðkai galima iðspausdinti masyvus - vartojamos procedûros Write arba WriteLn.

Neretai reikia vieno masyvo elementams priskirti kito masyvo elementus. Ðitoks veiksmas vadinamas masyvø kopijavimu. Jeigu kopijuojami masyvai apraðyti to paties tipo, tuomet galime vartoti tiesioginá priskyrimà:

A := D;

Tai vienintelis galimas veiksmas su visu masyvu.

Taèiau galima (daþnai ir bûtina, jei masyvai apraðyti ne to paties tipo) kopijuoti po vienà elementà:

for i := 1 to 10 do A := D;

Daþnai reikia surasti masyve elementus, tenkinanèius kurias nors sàlygas. Pavyzdþiui, suskaièiuosime, kiek masyve A yra lygiø nuliui elementø:

k := 0;
for i := 1 to n do { Skaièiuojami nuliniai elementai }
if A = 0 then k := k + 1;

Sudarant uþdaviniø programas labai svarbu tinkamai parinkti duomenø struktûras. Nuo to priklauso ne tik bûsimos programos sudëtingumas, bet ir apimtis, galimybës programà modifikuoti, pritaikyti kitoms reikmëms. Duomenø struktûros parinkimas ir sudarymas yra vienas svarbiausiø programavime etapø.

Jeigu skaièiavimø rezultatus reikia suraðyti á masyvà, tai daroma analogiðkai, kaip kaip ir ávesdant duomenis (kas buvo aiðkinta 5.1 pratime).

= 5.2 pratimas. Koordinaèiø plokðtumoje duota daug taðkø. Jø koordinatës suraðytos á masyvus X ir Y taip, kad pirmame masyve yra visø duotø taðkø x koordinatës, antrame - ðiø taðkø y koordinatës, pateiktos atitinkama tvarka. Reikia sudaryti programà, kuri suskaièiuotø atstumà nuo kiekvieno taðko iki koordinaèiø pradþios ir gautus rezultatus suraðytø á masyvà A (22 pav.).

Pradþia: Atstumai
Ávesti duomenis: masyvo dydá n bei paèiø masyvø X ir Y reikðmes
NUO 1 IKI n

Spausdinti masyvø X, Y, A reikðmes
Pabaiga

22 pav. Rezultatø raðymo á masyvà struktûrograma

Èia rezultatø skaièius þinomas ið anksto. Kai neþinome, kiek bus rezultatø, bûtina tikrinti, kad duomenys nebûtø bandomi raðyti á masyvà su neleistinu indeksu, t. y. iðeinanèiu uþ masyvo ribø. Tai bus parodyta tolesniame skyriuje. = 5.3 pratimas. Koordinaèiø plokðtumoje duota n taðkø. Reikia sudaryti programà, kuri nustatytø, ar yra bent vienas taðkas, kuris bûtø duoto apskritimo viduje. Apskritimo centro koordinatës a, b ir jo spindulys r þinomos.

program P5_3;
uses Crt;
type Mas = array [1..20] of real;
{---------- Duomenø ávedimo procedûra -------------------------}
procedure Apskritimas( var a, b, r : real);
begin
ClrScr;
Write(‘Áveskite apskritimo centro koordinates:');
ReadLn(a, b);
Write(‘Áveskite apskritimo spindulá:');
ReadLn(r);
end;
{---------- Taðkø koordinaèiø masyvø ávedimas -------------------}
procedure Masyvas( var X, Y : Mas; var n : integer);
var i : integer;
begin
Write(‘Áveskite taðkø skaièiø:');
ReadLn(n);
for i := to n do
begin
Writeln(‘ Taðkas nr. ‘, i: 4);
Write(‘x = ‘); ReadLn(X);
Write(‘y = ‘); ReadLn(Y);
end;
WriteLn;
end;
{---------- Ar yra taðkø apskritimo viduje? ---------------------}
function Viduje (var X, Y : Mas; n : integer;
a,b, r : real): boolean;
var yra : boolean;
i : integer;
begin
yra := false;
while (i <= n) and not yra do
if Sqr(X - a) + Sqr(Y - b) < Sqr(r)
then yra := true
else i := i + 1;
Viduje : = yra;
end;
{---------------------------------------------------------}
var X, Y : Mas; { taðkø koordinaèiø masyvas }
nt : integer; { taðkø skaièius }
a, b, { apskritimo centras }
r : real; { apskritimo spindulys }
begin
TextBackground(Blue); ClrScr; TextColor(Black) ;
Apskritimas( a, b, r );
Masyvas( X, Y, nt );
if Viduje( X, Y, nt, a, b, r )
then Write(‘Apskritimo viduje yra taðkø')
else Write(‘Apskritimo viduje taðkø nëra')
ReadLn;
end.

Kontroliniø duomenø pavyzdys

Testo nr.	Tikrinamas atvejis	Duomenys					Rezultatas
Testo nr.	Tikrinamas atvejis	a	b	r	nt	Taðkø koordinatës	Rezultatas
1	Priklauso	1	0	2	3	X = (-1, 2, 3) Y = (2, 1, 2)	Apskritimo viduje yra taðkø
2	Nepriklauso	1	0	2	2	X = (-1, 3) Y = (2, 2)	Apskritimo viduje taðkø nëra

Duomenø grupavimo pagal nurodytus poþymius uþdavinio pavyzdþiu gali bûti toks pratimas.
= 5.4 pratimas. Ûkininkas parsiveþë nuimtà arbûzø derliø. Juos reikia surûðiuoti pagal svorá á dvi krûvas: tinkamus prekybai ir netinkamus.

Toks pratimas buvo treèiame skyriuje. Skirstymas vyko kompiuterio ekrane ir arbûzø svoriø reikðmës nebuvo ásimenamos. Dabar duomenis ir gautus rezultatus áraðysime á masyvus. Tai leis ne tik papildyti programà naujais veiksmais, bet reikalui esant iðsaugoti byloje, spausdinti popieriuje ir pan. Tai bus parodyta kituose skyriuose.

Èia parodysime tik arbûzø skirstymà á dvi krûvas. Programoje bus reikalingos tokios procedûros:

Langas - ekranui valdyti (atkeliama ið ankstesniø programø);
Duomenys - pradiniams duomenims ið klaviatûros á masyvà ávesti;
Skirstyti - duomenims grupuoti;
Rodyti - masyvo reikðmëms rodyti ekrane.

program P5_4;
uses Crt;
const x1 = 5; y1 = 2; { darbo lango koordinatës }
x2 = 40; y2 = 5;
Fonas = Green;
NN = 100; { Didþiausias leistinas masyve elementø skaièius }
type Mas = array [1..NN] of real;
{---------------------------------------------------------}
procedure Langas (x1, y1, x2, y2, spalva : integer);
begin
Window(x1, y1, x2, y2);
TextBackground(spalva); ClrScr;
end;
{---------- Pradiniø duomenø ávedimas ---------------------------}
procedure Duomenys (var A : Mas; var n : integer);
var i : integer;
begin
Langas(x1, y1, x2, y2, fonas);
Write('Kiek turite arbûzø? '); ReadLn(n);
for i := 1 to n do
begin
GoToXY(3, 3); ClrEol;
Write('Arbûzo nr. ', i:2, ' svoris = ');
ReadLn(A)
end
end;
{---------- Arbûzø skirstymas á krûvas ---------------------------}
procedure Skirstyti(var A : Mas; n : integer; sv : real;
var K1 : Mas; var n1 : integer;
var K2 : Mas; var n2 : integer);
var i : integer;
begin
n1 := 0; n2 := 0;
for i := 1 to n do
if A >= sv
then
begin
n1 := n1 + 1;
K1[n1] := A
end
else
begin
n2 := n2 + 1;
K2 [n2] := A
end
end;
{-------------------------------------------------}
procedure Rodyti(var A : Mas; n : integer);
var i : integer;
begin
for i := 1 to n do { Skirstoma po 7 skaièius eilutëje }
if i mod 7 = 0
then WriteLn(A:7:2)
else Write (A:7:2);
WriteLn;
end;
{-------------------------------------------------}
var A : Mas; n : integer; { Pradiniai duomenys }
k1 : Mas; n1 : integer; { Tinkami arbûzai }
k2 : Mas; n2 : integer; { Netinkami arbûzai }
sv : real; { Svoris grupavimui }
begin { Programos veiksmai }
Langas(1, 1, 80, 25, Black); TextColor(Black);
Duomenys(A, n);
Langas(x1, y1, x2, y2, Fonas);
Write('Tinkamo arbûzo svoris = '); ReadLn(sv);

Skirstyti(A, n, sv, k1, n1, k2, n2);

Langas(1, 1, 80, 25, Black);
Langas(5, 2, 78, 23, Blue);
Langas(8, 3, 75, 22, Green);

WriteLn('Pradinis arbûzø sàraðas: ');
Rodyti(A, n);

TextColor(Red);
WriteLn('Netinkamø arbûzø sàraðas: ');
Rodyti(k2, n2);

TextColor(Magenta);
WriteLn('Tinkamø arbûzø sàraðas: ');
Rodyti(k1, n1);

ReadLn;
end.
= 5.5 pratimas. Masyvo reikðmiø rikiavimas, t. y. jo reikðmiø iðdëstymas didëjanèia (nemaþëjanèia) arba maþëjanèia (nedidëjanèia) tvarka, yra klasikinis programavimo uþdavinys. Galite rasti daug rikiavimo metodø. Keli jø apraðyti ir „Programavimo uþdavinyne". Pateiksime patá paprasèiausià. Pasinaudosime didþiausios reikðmës radimo algoritmu. Algoritmà truputá pakeisime. Ieðkosime didþiausios reikðmës ne visame masyve, bet nurodytame masyvo elementø intervale. Algoritmas toks:

Surandame didþiausià elementà visame masyve, t.y. nuo 1-ojo iki n-ojo elementø. Sukeièiame vietomis surastojo elemento ir 1-ojo elemento reikðmes.
Surandame didþiausià elementà masyvo intervale nuo 2-ojo iki n-ojo elementø. Sukeièiame vietomis surastojo elemento ir 2-ojo elemento reikðmes.
Surandame didþiausià elementà masyvo intervale nuo 3-ojo iki n-ojo elementø. Sukeièiame vietomis surastojo elemento ir 3-ojo elemento reikðmes.

Taip darome tol, kol intervale lieka tik vienas elementas. Rezultatu bus masyve sudëlioti skaièiai maþëjimo tvarka.

Norint gauti didëjimo tvarka, reikia tà patá daryti, tik ieðkant maþiausios reikðmës nurodytame intervale.

program P5_5;
uses Crt;
type Mas = array [1..50] of real;
{---------------------------------------------------------}
procedure Langas (x1, y1, x2, y2, spalva : integer);
begin
Window(x1, y1, x2, y2);
TextBackground(spalva); ClrScr;
end;
{---------- Pradiniø duomenø ávedimas ---------------------------}
procedure Duomenys( var A : Mas; var n : integer);
var i : integer;
begin
Write('Áveskite N = '); ReadLn(n);
WriteLn('Áveskite masyvo elementus:');
for i := 1 to n do
begin
Write('A[‘, i, ‘] = ‘);
ReadLn(A)
end
end;
{---------- Rikiuojama didëjanèiai ------------------------------}
procedure Rikiuoti( var A : Mas; n : integer);
var elem : real; i, j : integer;
begin
for i := 1 to n - 1 do
for j := i + 1 to n do
if A > A[j]
then begin
elem := A;
A := A[j];
A[j] := elem
end
end;
{---------- Rezultatø iðspausdinimas -----------------------------}
procedure Rezultatai( var A : Mas; n : integer);
var i : integer;
begin
WriteLn('Masyvas surikiuotas:');
for i := 1 to n do
Write(A:6 :1);
WriteLn;
end;
{--------------------------------------------------------}
var A : Mas;
n : integer;
begin
Langas( 1, 1, 80, 25, Blue ); TextColor( Black );
Duomenys ( A, n );
Rikiuoti ( A, n );
Rezultatai( A, n );
ReadLn;
end.
Kontroliniø duomenø pavyzdys

Duomenys		Rezultatai
N = 4	A = (5, 2, 7, 1)	A = (1, 2, 5, 7)

Kontrolinës uþduotys

Atlikite þodþiu „Programavimo pradmenø uþdavinyno" 5.1-5.4 pratimus. Po to sudarykite programëles gautø rezultatø teisingumui patikrinti.
Sudarykite programà 5.9 pratimui ið „Programavimo pradmenø uþdavinyno" (97 psl.) atlikti - besikeièianèioms masyvo reikðmëms stebëti.
Rezultatø suraðymo á masyvà algoritmà (5.2 pratimas), pavaizduotà struktûrograma (22 pav.), uþraðykite programa. Iðbandykite jà su ávairiais duomenimis.
Arbûzø rûðiavimo programà iðbandykite su ávairiais duomenimis.
Moksleivio kiekvienos mënesio dienos iðlaidos litais áraðytos á masyvà. Sudarykite programà, kuri paskaièiuotø moksleivio iðlaidas per k dienø. Nustatykite, kiek jis vidutiniðkai iðleidþia per vienà dienà.
Sudarykite programà ligonio temperatûrai analizuoti per parà. Nustatykite didþiausià ir maþiausià temperatûros reikðmæ. Laikykite, kad temperatûra matuojama kas valandà, jos reikðmës ávedamos klaviatûra ir suraðomos á masyvà.
Kai kuriose sportinëse varþybose sportininko pasirodymà vertina keletas teisëjø. Ið gautø balø atmetamas pats aukðèiausias ir pats þemiausias ávertinimas ir tada randamas likusiø balø vidurkis. Jei aukðèiausiu balu ávertino keli teisëjai, tai atmetamas tik vienas aukðèiausias balas. Analogiðkai pasielgiama ir kai keli teisëjai ávertina þemiausiu balu. Á masyvà ávedami aðtuoniø teisëjø pateikti sportininko pasirodymo ávertinimai balais. Paraðykite programà sportininko galutiniam skelbiamam ávertinimui rasti.

Kontroliniai pratimai

Kà ir kaip programa parodys ekrane, jeigu jà vykdydami klaviatûra surinksite tokias skaièiø eilutes:

Variantas	Skaièiø eilutë
V1	5 6 3 - 2 4 5 2 8
V2	5 6 3 - 9 14 2 7 6
V3	4 5 - 4 8 - 3 12 2 1
V4	5 7 - 4 4 5 3 6 10
V5	5 - 3 4 6 - 5 9 2 11
V6	5 3 - 3 4 6 2 2 8

program M1;
const L = 100;
type Mas = array[ 1..L ] of integer;
{---------------------------------------------}
procedure Imti( var A : Mas; var n : integer);
var i : integer;
begin
Read( n );
if n > L then n := L;
for i := 1 to n do Read( A );
ReadLn;
end;
{---------------------------------------------}
procedure Rodyti( var A : Mas; n : integer);
var i : integer;
begin
for i := 1 to n do
if i mod 3 = 0 then WriteLn( A:6 )
else Write ( A:6 );
WriteLn;
end;
{---------------------------------------------}
procedure Dirbti( var A : Mas; var n : integer);
var i, r, s : integer;
begin
s := 0; r := 0;
for i := 1 to n do
begin r := A; A := s; s := s + r; end;
end;
{---------------------------------------------}
var A : Mas; n : integer;
begin
Imti ( A, n );
Dirbti( A, n );
Rodyti( A, n );
end.

Kà ir kaip matysite ekrane, jeigu procedûrà Dirbti pakeisite tokia:

Procedûros variantas	Procedûra Dirbti
I	procedure Dirbti( var A : Mas; var n : integer); var i, r : integer; begin for i := 1 to n-1 do if A > A[ i+1 ] then begin r := A; A := A[ i+1 ]; A[ i+1 ] := r; end; end;
II	procedure Dirbti( var A : Mas; var n : integer); var i, r, s : integer; begin r := 0; s := 0; for i := 1 to n-1 do begin r := A; if A > A[ i+1 ] then A[ i ] := s; s := s + r; end; end;
III	procedure Dirbti( var A : Mas; var n : integer); var i, r : integer; begin r := 0; for i := 1 to n do if A > 0 then begin r := r + 1; A[ r ] := A; end; end;
IV	procedure Dirbti( var A : Mas; var n : integer); var i, r : integer; begin r := 0; for i := 1 to n do if A > 0 then begin r := r + 1; A[r] := A; end else begin n := n + 1; A[n] := A; end; end;

Savarankiðko darbo uþduotys

Turguje ant prekystalio eilute vienas ðalia kito guli arbûzai. Kiekvieno ið jø svoris þinomas. Pirkëjas praðo vidutinio arbûzo. Kuris tai bus?
Koordinaèiø plokðtumoje yra daug taðkø, kuriø koordinatës (x, y) þinomos. Apie tolimiausià nuo koordinaèiø pradþios taðkà yra apibrëþtas apskritimas spinduliu R. Kiek taðkø yra to apskritimo viduje?
Turime daug cilindro formos statiniø, kurið aukðtis ir skersmuo þinomi. Rasti aukðèiausios statinës tûrá ir kiek tokio tûrio statiniø yra.
Kuris klasëje nurodytà mënesá pirmasis ðvæs savo gimtadiená? Jeigu tokio nëra, programa savo vartotojui pasiûlo rinktis kità mënesá.
Plokðtumoje yra nubrëþta n trikampiø. Virðûniø koordinatës (x, y) þinomos. Jos suraðomos á masyvus X1(n), Y1(n), X2(n), Y2(n), X3(n), Y3(n). Èia pirmieji skaièiai visuose masyvuose reiðkia pirmojo trikampio virðûniø koordinates, antrieji - antrojo ir t.t. Apie kiekvienà trikampá brëþiami apskritimai, kuriø centrai yra treèios virðûnës taðke, o spinduliai lygûs kraðtinës ilgiui tarp pirmos ir antros virðûniø. Atrinkti trikampius (nurodyti jø indeksus duomenø masyvuose), kurie yra pilnai savame apskritime.
Turime traukinio judëjimo grafikà. Tai atstumas nuo pradinës stoties iki stotelës ir laikas, per kurá traukinys atvaþiuoja á tà stotelæ. Rasti tarp kuriø stoteliø atstumas maþiausias ir kurià atkarpà traukinys pravaþiuos greièiausiai.
Cilindrinës statinës, kurios aukðtis H ir skersmuo D, ðone iðgræþtos labai maþos skylutës. Kiekvienos jos skersmuo d << D. Þinomas kievienos skylutës atstumas nuo statinës virðaus. Statinë pripilta iki virðaus vandens. Per kiek laiko iðbëgs vanduo iki apatinës skylutës? Skaièiuojant priimti, kad vandens bëgimo greitis per skylutæ, esanèià h gilumoje, lygus Sqrt( 2*g*h).

5.3. Simboliø masyvai

Masyve galima saugoti ne tik skaièius, bet ir simbolius. Ið simboliø sudaromas tekstas. Yra daug uþdaviniø, kuriuose reikia apdoroti tekstà. Pavyzdþiui, galima atlikti teksto statistinæ analizæ: suskaièiuoti, kiek skirtingø raidþiø pavartota, kuri raidë daþniausiai vartojama, kurios raidës ið viso nepavartotos ir t. t. Tiesa, rimtai analizei reikalingi didelës apimties tekstai. Simboliø masyvà apraðome taip pat, kaip ir skaièiø, tik elementø tipas nurodomas simbolinis - char.

= 5.6 pratimas. Klaviatûra surenkama bet kokiø simboliø eilutë. Reikia surasti, kiek toje eilutëje buvo skaitmenø ir juos parodyti ekrane.

Programa gana paprasta. Kaip ir anksèiau, reikia pagalvoti, kokia bus programos struktûra: aiðku, kad reikës ekranà apipavidalinanèios ir simbolius ávedanèios procedûrø.

Procedûrà Langas perkeliame ið ankstesniø programø. Simboliø eilutei ávesti sudarome procedûrà Simboliai. Èia buvo galima ávedimà programuoti taip pat, kaip ir esant skaièiø masyvui: pirmiausia paklausti, kiek ið viso bus simboliø, po to panaudojant ciklà for ávesti nurodytà simboliø skaièiø. Taèiau taip nëra patogu, nes reikës suskaièiuoti, kiek bus simboliø. Patogiau ávedinëti visus ið eilës renkamus simbolius iki kol bus nurodyta, kad ávedimas baigtas. Tai galima padaryti ávairiai. Patogiausia pasinaudoti Turbo Paskalio funkcija Eoln, kuri nurodo, ar aptikta eilutës pabaiga (tuomet jos reikðmë lygi True) ar dar ne (tuomet jos reikðmë bus False).

Eilutë gali bûti gana ilga ir jos visi simboliai gali netilpti á masyvà. Tai reiðkia, kad reikia tikrinti, ar skaitomas simbolis dar telpa á masyvà, ar ne. Jeigu jau netelpa, tai toliau skaityti nëra prasmës.

Skaitmenø paieðkai ávestame simboliø masyve sudarysime procedûrà Skaitmuo. Reikia paeiliui perþiûrëti visus masyve esanèius simbolius ir patikrinti, ar tai skaitmuo. Tam reikës kiekvienà masyvo simbolá palyginti su simboliais ‘0', ‘1', ‘2', ..., ‘9'. Ðitaip programuodami gautume sudëtingà sàlyginio sakinio konstrukcijà (arba deðimt paprastø sàlyginiø sakiniø if . . . then).

Siûlome trumpesná sprendimà. Prisiminkime, kad lyginant simbolius jie keièiami jø kodais pagal kodø lentelæ. Pasiremkime tuo faktu, kad skaitmenys lentelëje suraðyti eilës tvarka (þr. 6 priedà).

program P5_6;
uses Crt;
const R = 100;
Fonas = Green;
type Mas = array [1..R] of char; { Simboliø masyvo tipas }
{--------------------------------------------------------}
procedure Langas (x1, y1, x2, y2, spalva : integer);
begin
Window(x1, y1, x2, y2 );
TextBackground(spalva ); ClrScr;
end;
{-------- Simboliø eilutës ávedimas -----------------------------}
procedure Simboliai (var A : Mas; var n : integer);
begin
WriteLn('Surinkite simboliø eilutæ:');
n := 0;
while not Eoln and (n < R)do
begin
n := n + 1;
Read(A[n]);
end;
ReadLn;
end;
{--------- Skaitmenø paieðka eilutëje --------------------------}
procedure Skaitmuo (var A : Mas; n : integer);
var i : integer;
begin
Langas(10, 10, 50, 15, White);
TextColor(Black);
WriteLn('Eilutëje buvo tokie skaitmenys:');

for i := 1 to n do
if (A >= '0') and (A <= '9')
then
Write(A:3); { Tarp skaitmenø paliekami du tarpai }
WriteLn;
end;
{----------------------------------------}
var A : Mas;
n : integer;
begin
Langas(1, 1, 80, 25, Black); TextColor(Green);
Simboliai(A, n);
Skaitmuo (A, n);
ReadLn;
end.

Kontrolinës uþduotys

Procedûroje Skaitmuo sàlyginio sakinio lyginimo sàlygà pakeiskite ðitokia: A in ['0'..'9']. Ásitikinkite, kad gausite tà patá rezultatà. Ðitaip raðome, kai norime nustatyti, ar elemento A reikðmë yra ið intervalo '0'..'9'. Jeigu yra ið ðio intervalo, tai atsakymas bus true, kitaip - false. Ið tikrøjø uþraðas ['0'..'9'] reiðkia skaitmenø aibæ, o operacija in patikrina, ar kairëje pusëje paraðyta reikðmë priklauso deðinëje pusëje nurodytai aibei.
Didþiosios lotyniðkos abëcëlës raidës kodø lentelëje yra suraðytos ið eilës. Programoje skaitmenø atpaþinimo sàlygoje ‘0' pakeiskite á ‘A', o ‘9' á ‘Z'. Dabar programa turëtø ekrane parodyti visos surinktos eilutës didþiàsias raides.
Kà reikëtø pakeisti programoje, kad ji tiktø surinktos eilutës lotyniðkos abëcëlës maþosiomis raidëmis parodyti ekrane?

5.4. Simboliø eilutës

Turbo Paskalyje simboliø eilutei ásiminti yra labai patogus duomenø tipas - eilutë. Jis þymimas þodþiu string. Ðá tipà galima laikyti tokiu, lyg jis bûtø ðitaip apraðytas:

type string = array [0..255] of char;

Matome, kad eilutë - tai tam tikras simboliø masyvas. Darbui su tokio tipo duomenimis (eilutëmis) yra sudaryta nemaþai standartiniø procedûrø ir funkcijø, todël programuotojui labai patogu jomis pakeisti daugelá veiksmø, uþuot paèiam tai programavus.

Eilutës tipo duomenys turi ádomià savybæ: nulinio indekso elementas nurodo, kiek eilutëje ið viso yra simboliø. Tik tas kiekis raðomas ne skaièiumi, bet já atitinkanèiu simboliu kodø lentelëje. Pavyzdþiui:

var A : string;
. . .
A := ‘Antarktida';

Eilutëje A saugoma 10 simboliø. Nuliniu indeksu eilutëje bus uþraðytas deðimtas (10) simbolis pagal kodø lentelæ.

Patys simboliai eilutëje raðomi nuo pirmos vietos. Tikrinti, ar ne per daug simboliø, nereikia. Netelpantys simboliai bus paprasèiausiai atmenami.

Jeigu eilutës simbolius reikia nagrinëti atskirai, tai vartojame ciklus, kaip prieð buvusiame pratime. Tuomet bûtina þinoti, kiek simboliø yra toje eilutëje. Tam vartojama standartinë funkcija Length, pavyzdþiui:

var A : string;
n : integer;
. . .
A := 'Batuotas Katinas';
n := Length(A ); { n bus lygu 16 (tiek simboliø yra eilutëje A) }

Perdarykite ankstesnio skyrelio programà. Ji gerokai supaprastës.

program P5_6a;
uses Crt;
{--------- Simboliø eilutës ávedimas -----------------------------}
procedure Langas (x1, y1, x2, y2, spalva : integer);
begin
Window(x1, y1, x2, y2);
TextBackground(spalva); ClrScr;
end;
{--------- Skaitmenø paieðka eilutëje ----------------------------}
procedure Simboliai (var A : string);
begin
WriteLn('Surinkite simboliø eilutæ:');
ReadLn(A);
end;
{----------------------------------------}
procedure Skaitmuo (var A : string);
{ Skaitmenø paieðka masyve }
var i: integer;
begin
Langas(10, 10, 50, 15, White);
TextColor(Black);
WriteLn('Eilutëje buvo tokie skaitmenys:');

for i := 1 to Length(A) do
if A in ['0'..'9']
then Write(A:3); { Tarp skaitmenø paliekami du tarpai }
WriteLn;
end;
{----------------------------------------}
var A : string;
begin
Langas(1, 1, 80, 25, Black); TextColor(Green);
Simboliai(A);
Skaitmuo(A);
ReadLn;
end.

Su eilutëmis galima atlikti ávairiausius veiksmus, taèiau to èia nenagrinësime. Eilutæ vartosime þodþiams (arba þodþiø sekai, pvz., pavardei ir vardui) ásiminti.

Labai naudinga programose vartoti sutrumpintas eilutes. Jos apraðomos ðalia lauþtiniuose skliaustuose nurodant jø ilgá, pavyzdþiui:

var A : string[15];

Tokia eilutë gali turëti tik iki 15 simboliø. Jeigu ávedant klaviatûra bus surinkta ilgesnë eilutë, tai skaitymas bus uþbaigtas perskaièius 15-àjá simbolá. Jeigu ávedant bus surinkta maþiau simboliø, tuomet eilutë bus trumpesnë. Daugiau simboliø nebus reikalaujama.

Jeigu reikia keliose apraðø vietose panaudoti tà patá eilutës tipà, tai pirmiausiai apraðome tipà, pavyzdþiui:

type Eil = string [15];
var a : Eil;
b : Eil;

Daugumoje uþdaviniø tekstinë ir skaitmeninë informacija neatskiriamos. Veiksmuose lygiomis teisëmis vartojama tiek simboliniai duomenys, tiek skaièiai. Susipaþinkime su paprasèiausiu atveju.
= 5.7 pratimas. Tegul turime klasës mokiniø sàraðà, kuriame nurodyta kiekvieno moksleivio pavardë ir jo ûgis. Kurie moksleiviai gali bûti kandidatais á mokyklos krepðinio komandà? Tarkime, kad pretenduoti gali ne þemesni, kaip 170 cm. ûgio moksleiviai.

program P5_7;
uses Crt;
const L = 30;
Tinka = 170;
type Mokiniai = array [1..L] of string;
Mas = array [1..L] of real; { Mokiniø ûgiai }
{----------------------------------------------------}
procedure Duomenys( var A : Mokiniai; var B : Mas;
var n : integer);
var i : integer;
begin
Write('Kiek klasëje moksleiviø? '); ReadLn(n);
WriteLn(‘Áveskite moksleivio pavardæ ir ûgá:');
for i := 1 to n do
begin
Write(i, ‘ Pavardë: '); ReadLn( A );
Write(‘ Ûgis: ‘); ReadLn( B )
end;
Writeln;
end;
{----------------------------------------------------}
procedure Kandidatai( var A : Mokiniai; var B : Mas;
n : integer;
var C : Mokiniai; var k : integer);
var i : integer;
begin
k := 0;
for i := 1 to n do
if B > Tinka then begin
k := k + 1;
C[k] := A;
end;
end;
{----------------------------------------------------}
procedure Rezultatai( var A : Mokiniai; n : integer);
var i : integer;
begin
WriteLn( ‘Krepðinio komanda');
if n = 0 then WriteLn(‘ Kandidatø nëra');
for i := 1 to n do WriteLn( i, ‘ ‘, A );
end;
{----------------------------------------------------}
var pavarde : Mokiniai;
ilgis : Mas;
n : integer;
Kand : Mokiniai; { Kandidatø pavardës }
k : integer;
begin
ClrScr;
Duomenys ( Pavarde, Ilgis, n);
Kandidatai( Pavarde, Ilgis, n, Kand, k);
Rezultatai( Kand, k);
Readln;
end.

Kontroliniø duomenø pavyzdys

Testo nr.	Tikrinamas atvejis	Mokiniø skaièius	Pavardë	Ûgis	Rezultatas
1	Yra kandidatø	3	Jonaitis Keras Lapinas	171 165 178	1 Jonaitis 2 Lapinas
2	Nëra kandidatø	2	Petraitis Rimða	169 165	Kandidatø nëta

= 5.8 pratimas. Þinome mokinio pavardæ, vardà, mokomàjá dalykà ir to dalyko paþymius. Reikia suskaièiuoti mokinio dalyko mokymosi aritmetiná vidurká ir jo ávertinimà paþymiu (suapvalintà sveikøjø skaièiø tikslumu).

Duomenys ávedami klaviatûra. Tam programoje numatomas dialogas: programa pati papraðo, kada kà ávesti. Þodþiams ásiminti bus vartojamas eilutës tipas string. Mokinio pavardë, vardas ir dalyko pavadinimas bus ávedami klaviatûra atskiromis eilutëmis. Paþymiai bus pateikiami vienoje eilutëje, atskiriant juos bent vienu tarpo simboliu.

Skaièiuojant vidurká, reikia nepamirðti ávertinti to atvejo, kai mokinys negavo nei vieno paþymio. Tuo atveju vidurkis turi bûti nulis.

program P5_8;
uses Crt;
type Mas = array [1..25] of integer;
{---------------------------------------------------}
procedure Langas (x1, y1, x2, y2, spalva : integer);
begin
Window(x1, y1, x2, y2);
TextBackground(spalva); ClrScr;
end;
{-------- Duomenø apie mokiná ávedimas --------------------------}
procedure Duomenys (var A : Mas; var n : integer;
var pav, vard, dalykas : string);
begin
Langas(5, 3, 40, 7, Magenta);
Write('Pavardë : '); ReadLn(pav);
Write('Vardas : '); ReadLn(vard);
Write('Dalykas : '); ReadLn(dalykas);
Write('Paþymiai : ');
n := 0;
while not Eoln do
begin
n := n + 1;
Read(A[n]);
end;
ReadLn;
end;
{--------- paþymiø vidurkio skaièiavimas --------------------------}
procedure Vidurkis (var A : Mas; n : integer;
var vid : real);
var s : real;
i : integer;
begin
s := 0;
for i := 1 to n do
s := s + A;
if n > 0 { Ar sàraðe buvo bent vienas paþymys? }
then vid := s / n
else vid := 0;
end;
{---------------------------------------------------}
var A : Mas; n : integer;
pav, vard, dalykas : string;
v : real;

begin { Programos veiksmai }
TextColor(Black); Langas(1, 1, 80, 25, Black);
Duomenys(A, n, pav, vard, dalykas);
Vidurkis(A, n, v);
Langas(5, 10, 40, 13, Green);
WriteLn(pav, ' ', vard);
WriteLn(dalykas, ' ávertinta paþymiu: ', Round(v));
WriteLn('Vidurkis = ', v:8:3);
ReadLn;
end.
Kontrolinës uþduotys

Paraðykite programà, kuri papraðytø surinkti Jûsø vardà. Tada pasisveikintø. Pavyzdþiui, jeigu Jûsø vardas Julius, tai programa ekrane paraðytø:
Sveikas, Juliau!
Pabandykite 5.8 pratimo eilutæ pakeisti sutrumpinta. Iðbandykite programà surinkdami trumpesná, o po to ilgesná tekstà.
Procedûrà Vidurkis papildykite taip, kad bûtø spausdinami visi eilutëje A esantys simboliai. Taip suþinosite, kiek simboliø ið klaviatûra surinktos eilutës pateko á eilutæ A.
Programoje nëra apsaugos ávedant paþymius. Tikimasi, kad tikrai mokinys negali gauti daugiau kaip 25 paþymius per trimestrà. Papildykite paþymiø ávedimà apsauga.
5.8 pratimo programa dirba tik su vieno mokinio duomenimis. Pertvarkykite programà taip, kad ji apdorojusi vienus duomenis paklaustø vartotojo, ar dar bus dirbama su kitais duomenimis. Jeigu taip, tai reikia kartoti visus veiksmus.

Masyve laikomi n moksleiviø komandø, dalyvavusiø sportinëse estafetëse, surinkti taðkai. Nustatykite komandas, laimëjusias pirmàjà ir antràjà vietas.
Vieno masyvo elementus perraðykite á kità, iðdëstydami atvirkðèia seka.
Duotame skaièiø masyve sukeiskite didþiausià ir maþiausià elementà vietomis.
Vaikø darþelyje yra N sviediniø, kuriø kiekvieno skersmuo þinomas. Nustatykite, kiek sviediniø pralys pro tvoros plyðá, kurio aukðtis Ta, o plotis Tp. Duomenys pateikiami centimetrais. Kokio skersmens didþiausias sviedinys gali pralysti per tvoros plyðá ir kiek tokioskersmens svieniniø yra.
Turime vieno mënesio oro temperatûros duomenis kiekvienos dienos vidurdiená. Rasti, kiek dienø buvo ðalèiausiø.
Þinomi klasës mokiniø ûgiai. Nustatyti vidutiná moksleivio ûgá. Rasti, keliø moksleiviø ûgis didesnis ir keliø maþesnis uþ vidutiná ûgá.

Kà pasirinkti?

Masyvas yra labai populiari duomenø struktûra, taèiau já taikyti konkreèiuose uþdaviniuose bûtina kûrybiðkai. Programos apimtis ir sudëtingumas priklauso ne tik nuo pasirinkto masyvo tipo, bet ir duomenø interpretacijos tame masyve, duomenø atvaizdavimo bûdo masyve. Negalime rasti bendrø ir universaliø nurodymø. Kaip kiekvienas uþdavinys turi savo skirtingus spredimo bûdus (ir ne vienà), taip programuotojas randa skirtingus bûdus paraðyti programà tam uþdaviniui spræsti. Kartais net neámanoma pasakyti, kuri ið tokiø programø yra geresnë (bûtini grieþti programø vertinimo kriterijai, kuriuos universalius sukurti taip pat neámanoma).

Pateikiame vieno uþdavinio keletà sprendimø variantø. Iðvadas padarykite patys.

Pratimo programose priimta, kad duomenys bus ávesti teisingai ir kad bus ávestas bent vienas skaièius.
= 5.9 pratimas. Klaviatûra ávedami sveiki teigiami skaièiai. Reika pasakyti, kuris ið jø turi daugiausiai skirtingø skaitmenø. Skaièiø ávedimo pabaiga bus tuomet, kai ávesime nulá (0) arba neigiamà skaièiø.
Programose yra procedûra Kiek, kuri suranda, kiek duotame skaièiuje Sk yra skirtingø skaitmenø.

Pirmasis variantas. Nenaudojami masyvai. Norint rasti, kiek kokiø skaitmenø yra skaièiuje, reikia 10 kintamøjø.

program Mas1;
uses Crt;
{--------------------------------------------}
procedure Kiek( Sk : integer; var K : integer);
var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9 : integer;
b : integer;
begin
s0 := 0; s1 := 0; s2 := 0; s3 := 0; s4 := 0;
s5 := 0; s6 := 0; s7 := 0; s8 := 0; s9 := 0;
while Sk <> 0 do { Kiek kokiø skaitmenø yra skaièiuje Sk}
begin
b := Sk mod 10; Sk := Sk div 10;
case b of
0 : s0 := s0 + 1;
1 : s1 := s1 + 1;
2 : s2 := s2 + 1;
3 : s3 := s3 + 1;
4 : s4 := s4 + 1;
5 : s5 := s5 + 1;
6 : s6 := s6 + 1;
7 : s7 := s7 + 1;
8 : s8 := s8 + 1;
9 : s9 := s9 + 1;
end;
end;
K := 0; { Kiek yra skirtingø skaitmenø skaièiuje Sk}
if s0 > 0 then K := K + 1;
if s1 > 0 then K := K + 1;
if s2 > 0 then K := K + 1;
if s3 > 0 then K := K + 1;
if s4 > 0 then K := K + 1;
if s5 > 0 then K := K + 1;
if s6 > 0 then K := K + 1;
if s7 > 0 then K := K + 1;
if s8 > 0 then K := K + 1;
if s9 > 0 then K := K + 1;
end;
{--------------------------------------------}
var Daug, Sd : integer;
Sk, K : integer;
begin
ClrScr;
Daug := 0; Sd := 0;
Write( 'Iveskite skaièiø (pabaiga <= 0): '); ReadLn( Sk );
while Sk > 0 do
begin
Kiek( Sk, K );
if K > Daug then begin Daug := K; Sd := Sk end;
Write( 'Iveskite skaièiø (pabaiga <= 0): '); ReadLn( Sk );
end;
GoToXY( 5, 10 );
TextColor( Green ); Write( 'Skaièius ');
TextColor( Red ); Write( Sd:5 );
TextColor( Green ); Write( ' turi daugiausiai skirtingø skaitmenø: ');
TextColor( Red ); Write( Daug:5 );
end.

Antrasis variantas. Naudojami masyvai. Skaitmenø kiekiui skaièiuoti vartojamas masyvas. Patogu buvo priimti, kad masyve nuliniu indeksu saugotume kiek skaièiuje yra skaitmenø nulis (0), pirmu indeksu - kiek vienetukø, antru - dvejetukø ir t.t.

program Mas2;
uses Crt;
type Mas = array[ 0..9 ] of integer;
{--------------------------------------------}
procedure Kiek( Sk : integer; var K : integer);
var Skaitmuo : Mas; i : integer;
b : integer;
begin
for i := 0 to 9 do Skaitmuo[ i ] := 0;
while Sk <> 0 do
begin
b := Sk mod 10; Sk := Sk div 10;
Skaitmuo[ b ] := Skaitmuo[ b ] + 1;
end;
K := 0;
for i := 0 to 9 do
if Skaitmuo[ i ] > 0 then K := K + 1;
end;
{--------------------------------------------}
var Daug, Sd : integer;
Sk, K : integer;
begin
ClrScr;
Daug := 0; Sd := 0;
Write( 'Iveskite skaièiø (pabaiga <= 0): '); ReadLn( Sk );
while Sk > 0 do
begin
Kiek( Sk, K );
if K > Daug then begin Daug := K; Sd := Sk end;
Write( 'Iveskite skaièiø (pabaiga <= 0): '); ReadLn( Sk );
end;
GoToXY( 5, 10 );
TextColor( Green ); Write( 'Skaièius ');
TextColor( Red ); Write( Sd:5 );
TextColor( Green ); Write( ' turi daugiausiai skirtingø skaitmenø: ');
TextColor( Red ); Write( Daug:5 );
end.

Treèiasis variantas. Naudojami masyvai. Ankstesnis variantas nepatogus tuo, kad skaièius tipo integer nedidelis. Pasinaudokite tuo, kad klaviatûra ávedami duomenys yra simboliø seka. Procedûros Read ir ReadLn tà simboliø sekà, jeigu ji atitinka duomenø skaièiaus uþraðymo reikalavimus, paverèia reikalingu skaièiumi.

Akstesniuose programos variantuose gautà skaièiø skaidëme á atskirus skaitmenis. Ðiame variante surinktà klaviatûra eilutæ sugosime string tipo kintamuoju. Tai leis ávesti labai ilgà sveikà skaièiø.

Kiekvienas skaitmuo bus masyvo atskiras elementas. Tolesniems skaièiavimams simbolius galima bûtø paversti skaitmenimis, bet prgramoje atsisakyta tai padaryti. Galima skaièiuoti sakitmenis simbolinëje formoje.

program Mas3;
uses Crt;
type Mas = array[ '0'..'9' ] of integer;
{--------------------------------------------}
procedure Kiek( Sk : string; var K : integer);
var Skaitmuo : Mas; i : integer; sim : char;
begin
for sim := '0' to '9' do Skaitmuo[ sim ] := 0;
for i := 1 to Length( Sk ) do
Skaitmuo[ Sk ] := Skaitmuo[ Sk ] + 1;
K := 0;
for sim := '0' to '9' do
if Skaitmuo[ sim ] > 0 then K := K + 1;
end;
{--------------------------------------------}
var Daug, K : integer;
Sd, Sk : string;
begin
ClrScr;
Daug := 0; Sd := '';
Write( 'Iveskite skaièiø (pabaiga <= 0): '); ReadLn( Sk );
while Sk <> '' do
begin
Kiek( Sk, K );
if K > Daug then begin Daug := K; Sd := Sk end;
Write( 'Iveskite skaièiø (pabaiga <= 0): '); ReadLn( Sk );
end;
GoToXY( 5, 10 );
TextColor( Green ); Write( 'Skaièius ');
TextColor( Red ); Write( Sd:5 );
TextColor( Green ); Write( ' turi daugiausiai skirtingø skaitmenø: ');
TextColor( Red ); Write( Daug:5 );
end.

arvydasxx.mylivepage.com

Taxi 4 [Lt]

Hello

Programavimas

http://mcw.lt