duminică, 4 decembrie 2011

FILE

Tipul fişier

Un fişier este o colecţie de date. El este memorat pe un suport de informaţie. Suportuul de informaţie se numeşte volum. De regulă, pe un suport există mai multe fişiere. Pentru a identifica un fişier, el trebuie să aibă un nume delimitarea fişierului pe suport se face prin marcaje logice:

1) marcaj de început de fişier (BOF - Begin Of File)
2) marcaj de sfârşit de fişier (EOF - End Of File)

Fişierul este o colecţie de înregistrări. Înregistrările sunt de două tipuri:
1) înregistrări fizice sau blocuri;
2) înregistrări logice sau articole.
Înregistrarea fizică este unitatea de transfer între dispozitivul pereferic şi procesor. Deci, pe suportul de de informaţie, fişierul este o colecţie de înregistrări fizice .
Înregistrarea logică este unitatea de informaţie pe care o tratează programul. Prin urmare, din punct de vedere al programului care manipulează fişierul, acesta este o colecţie de înregistrări logice.
Translatarea între cele două tipuri de înregistrări o face sistemul de operare.
Organizarea datelor îin fişiere este necesară, dacă:
1) volumul datelor prelucrate este foarte mare şi depăşeşte caracteristica memoriei operative disponibile;
2) datele trbuie stocate în vederea unei prelucrări ulterioare, în cadrul aceluiaşi program sau al altora.
Tipul fişier defineşte o structură care cuprinde un număr nefixat de componente de acelaşi tip.
Tipul fişier se aseamănă cu tipul tablou prin faptul că toate componentele au acelaşi tip, dar se deosebesc de acestea prin modul de acces la componente ş i prin aceea că numărul componentelor unui tip fişier nu este limitat.
Accesul la componentele unui fişier poate fi:
1) secvenţial – pentru a accesa o anumită componentă trebuie parcurse toate componentele care o preced în fişier;
2) direct – orice componentă se poate accesa imediat, dacă se precizează numărul ei de ordine în fişier, fără să fie necesară parcurgerea elementelor precedente.
Accesul direct este permis numai pentru fişierele stocate pe pe disc. Acesta este singurul suport adresabil, care permite calculul adresei unei componente, dacă i se cunoaşte lungimea şi numărul de ordine în fişier.
Fiecărui fişier i se asociază de către compilator o variabilă numită indicator de fişier care cuprinde, pe tot parcursul prelucrării fişierului, numărul de ordine al componentei curente.
În limbajele de programare există trei tipuri de fişiere:
1) fişiere cu tip – componentele au acelaşi tip şi sunt stocate pe disc;
2) fişiere text – componentele sunt caractere structurate pe linii de lungimi variabile;
3) fişiere fără tip – componentele sunt blocuri de informaţii de lungime fixă, stocate pe disc.
Într-un algoritm un fişier se identifică printr-o variabilă de tip fişier, variabila de tip fişier nu are voie să apară în atribuiri sau expresii.

Prelucrările admise asupra unui fişier
1) crearea fişierului – constă în scrierea componentelor în fişier;
2) exploatarea fişierului – constă în citirea şi prelucrarea componentelor fişierului;
3) actualizarea fişierului – constă în adăugarea, modificarea sau “ştergerea” unor componente ale fişierului, prin operaţii de citire şi scriere.
Oricare ar fi modul de prelucrare al unui fişier, accesul la componentele lui este permis numai dacă el este deschis. Orice prelucrare începe cu deschiderea fişierului şi se încheie ci închiderea sa. Deschiderea fişierului se realizează cu ajutorul procedurii
Open(numele fişierului, tipul prelucrării),
Unde, tipul prelucrării poate fi Input sau Output. Output se foloseşte atunci când are loc crearea fişierului, iar Input - la exploatarea fişierului.
Fişierele cu tip
Un fişier cu tip cuprinde mai multe componente de acelaşi tip, numit tipul de bază al fişierului. Se declară fişierul cu tip astfel:
FILE OF
Tipul componentelor este de obicei de tip articol. Componentele unui fişier cu tip pot fi accesate atât secvenţial cât şi direct.
Indicatorul de fişier indică în permanenţă numărul de ordine al componentei care urmează să fie prelucrată. Programatorul are acces la acest indicator prin intermediul funcţiei FILEPOS şi al procedurii SEEK. După deschiderea fişierului indicatorul de fişier are valoarea 0.

Operaţiile posibile
1. citirea unei componente se realozează prin apelul procedurii
READ(fişier, articol)
Execuţia procedurii constă în:
Se citeşte componenta al cărei număr de ordine este păstrat în indicatorul de fişier şi se memorează în articol. Valoarea indicatorului de fişier creşte cu 1. La prima operaţie de citire tot conţinutul înregistrării fizice se transferă în zona de tampon, asociată fişierului, iar apoi din zona de tampon prima înregistrare logică se transferă la adresa variabilei articol. Următoarele operaţii de citire preiau consecutiv înregistrările logice din zona de tampon până când tot conţinutul zonei de tampon nu va fi prelucrat. După aceasta în zona de tampon se transferă următoarea înregistrare logică.
2. scrierea componentelor în fişier
WRITE(fişier, articol)
Se scrie conţinutul articolului în fişier prin intermediul zonei de tampon, care după ce se completează se scrie automat pe disc.
3. funcţia EOF(fişier) de tip Boolean.
Se apelează prin EOF(fişier). Funcţia returnează True, dacă indicatorul de fişier indică marcaju EOF sau dacă fişierul este vid şi False în caz contrar.
4. funcţia FILEPOS(fişier) returnează numărul de ordine al componentei curente.
5. Funcţia FILESIZE(fisier) returnează numărul de componente asociat fişierului. Dacă indicatorul de fişier indică sfârşitul fişierului , atunci:
FILESIZE(fisier) = FILEPOS(fisier)
EOF(fisier) = TRUE
6. Procedura SEEK(fisier,n)
Prin execuţia procedurii se poziţionează indicatorul de fişier la valoarea n.
7. Procedura CLOSE(fisier) – realizează închiderea fişierului. Dacă fişierul este deschis cu OUTPUT, atunci operaţia de închidere este obligatorie, deoarece are loc transferarea informaţiilor din zona de tampon incomplecte în fişier pe disc.

SET

Tipul mulţime

Introducere

Tipul mulţime este un tip structurat, total diferit de celelalte tipuri structurate; el corespunde noţiunii de mulţime din matematică. Mulţimea este o totalitate de obiecte distincte. Obiectele mulţimii se numesc elemente. O mulţime se caracterizează prin următoarele proprietăţi:

- toate elementele mulţimii aparţin unui domeniu. De exemplu, mulţimea tuturor numerelor naturale reprezintă domeniu pentru orice mulţime de numere întregi;
- orice element al mulţimii are numai două alternative: aparţine sau nu mulţimii date. Un element al mulţimii se include în mulţime o singură dată. Din aceste considerente mulţimile {1,2,7} şi {1,1,2,7,7} sunt echivalente;
- nu este importantă ordinea enumerării elementelor mulţimii. De exemplu, mulţimile {1,2,7}, {7,1,2} şi {7,2,2,1,7,2} sunt echivalente.

Mulţimile pot fi finite şi infinite.

Mulţimile infinite cuprind o infinitate de elemente. De exemplu, mulţimea numerelor pare formează o mulţime infinită, deoarece nu există cel mai mare număr par.
Mulţimile finite cuprind un număr finit de elemente. De exemplu, mulţimea numerelor naturale pare din intervalul 0..10 este o mulţime finită.
În programare se folosesc numai mulţimile finite, deoarece memoria operativă, unde se reprezintă ele, este limitată.

Reprezentarea datelor ca mulţime

Deseori, informaţia despre lumea înconjurătoare se reprezintă sub formă de mulţimi. De exemplu, medicii lucrează cu mulţimi de bolnavi, elevii unei clase reprezintă o mulţime. În program mulţimile de obiecte pot fi reprezentate sub diferite forme de structuri de date: tablouri, structuri de date dinamice, fişiere, mulţimi. Datele pot fi reprezentate ca date de tip mulţime numai dacă se respectă cele trei proprietăţi ale mulţimii.

Tipul mulţime

Un tip mulţime se defineşte în raport cu un tip de bază care trebuie să fie un tip ordinal (deci poate fi char, boolean, enumerare, interval de cardinal, interval de integer, interval de char şi nu poate fi real sau string sau vre-un tip structurat (array sau record). Fiind dat un asemenea tip de bază, tipul mulţime reprezintă mulţimea tuturor submulţimilor tipului de bază, inclusiv şi mulţimea vidă. Dacă tipul de bază are n valori, atunci tipul mulţime reprezintă 2n valori.
În limbajele de programare tipul de bază este limitat. De exemplu, în limbajul Pascal tipul de bază al mulţimii nu are voie să aibă mai mult de 256 valori.El se reprezintă în memoria operativă pe un octet.

Reprezentarea în memorie a variabilelor de tip mulţime

Variabilele de tip mulţime sunt reprezentate în memorie pe n biţi, ocupând
(n div 8 + 1) octeţi. Fiecărei valori admise de tipul de bază îi corespunde bitul al cărui număr de ordine coincide cu cel al valorii. Dacă elementul aparţine mulţimii, atunci bitul care î-l reprezintă va fi poziţionat în 1, în caz contrar – pe 0.
De exemplu, fie mulţimea M={10,13,18,22,23,24}, care reprezintă numere naturale din intervalul 10 .. 30. Pentru reprezentarea acestei mulţimi în memoria operativă sunt necesari 22 biţi. Reprezentarea internă a mulţimii va fi următoare:
1000100001000111000000.
Datorită acestui mod de reprezentare, operaţiile cu datele de tip mulţime se execută extrem de rapid. Este avantajoasă şi alocarea lor în memoria operativă.

Definirea tipului mulţime

Un tip mulţime se defineşte astfel:

Type
= set of

De exemplu,

Type
Oras = (Balti,Floresti,Soroca)
M_oras = set of oras
Var
X: m_oras;

Variabila X este o variabilă de tip mulţime a tipului de bază Oras, care este un tip enumerare cu trei valori. Deci, variabila X poate primi 23 = 8 valori. Valorile posibile sunt:

X = []
X = [Balti]
X = [Floresti]
X = [Soroca]
X = [Balti,Floresti]
X = [Balti, Soroca]
X = [Floresti,Soroca]
X = [Balti,Floresti,Soroca]

Putem defini mulţimi pentru cifrele di baza zece:
Type
Cifre1 = set of 0 ..9
Sau
Cifre2 = set of ‘0’ ..’9’
Putem defini mulţimea cifrelor binare:
Type
Cifre_bin = set of 0..1
Vom defini
Type
Semne = set of char
Fie:
Var
Par: cifre1
Impar: cifre1
Cifre: cifre1
Cifra : cifre2
Litere: semne

Operaţiile posibile cu datele de tip mulţime

1. Atribuirea

Variabilele de tip mulţime pot fi iniţializate doar prin atribuire. Operaţia de citire a acestor variabile este interzisă. O mulţime poate fi specificată enumerându-i-se elementele.
Par := []
Par := [0,2,4,6,8]
Impar :=[1,3,5,7,9]
Cifra := [‘0’,’1’ ..’5’,’9’]
Liter :=[‘a’..’z’]

2. reuniunea a două mulţimi

Este mulţimea formată din elementele comune şi necomune ale celor două mulţimi.
Cifre:= par+impar
Mulţimea Cifre va conţine elementele [0,1,2,3,4,5,6,7,8,9]

3. intersecţia a două mulţimi

Este mulţimea formată din elementele comune a două mulţimi.

Cifre:= [2,5,8,9] * [4,2,9]. Rezultatul va fi mulţimea [2,9]
Cifre:= [2,5,7] * [4,6,9]. Rezultatul va fi mulţimea [], deoarece în mulţimile opreand nu sunt elemente comune.

4. diferenţa a două mulţimi

Este mulţimea formată dim elementele primei mulţimi, care nu aparţin celei de-a doua mulţimi
Cifre_impare:=[‘1’ ..’9’] – cifre_pare

5. datele de tip mulţime pot să apară în expresii relaţionale

Două mulţimi sunt egale numai atunci când sunt formate din aceleaşi elemente (de obicei se foloseşte smnul =). Dacă cele două mulţimi diferă măcar cu un element, ele sunt diferite (#). Se permite verificarea dacă o mulţime este inclusă în altă mulţime(<=) sau dacă o mulţime include pe altă mulţime (>=)

6. selectarea unei componente prin testul de apartenenţă.

Elementele unei date de tip mulţime nu pot fi accesatwe direct, dar se permite verificarea apartenenţei unui element la data respectivă folosind operatorul relaţionmal in
E in A,
Unde A este o mulţime, iar e este o expresie de acelaşi tip ordinal cu tipul de bază al mulţimii A. Această expresie are valoarea TRUE dacă valoarea expresiei reprezintă un element din A şi valoarea FALSE în caz contrar. Folosirea testului de apartenenţă permite transcrierea eficientă a unor teste complicate. De exemplu, construcţia

If (c=’A’) or (c=’B’) or (c=’C’) or (c=’D’) or (c=’E’) or (c=’F’) then …

Se poate scrie mai simplu

If c in [‘A’ …’F’] then …

Întroducera mulţimilor

Datele de tip mulţime nu pot fi nici citite, nici scrise.
Pentru a întroduce o mulţime concretă se citesc elementele care formeză mulţmea şi reunind aceste elemente, se construeşte mulţimea dorită.

Fie,
Var
A: set of [1..100]
X: [1..100]
Begin
A:=[]
Readcard(x)
A:=a+[x]
End.

Sau

Var
b: set of [‘a’ ..’f’]
y: char
Begin
b:=[]
Readchar(y)
b:=b+[y]
End.

Afişarea mulţimilor
Pentru a afişa o mulţime e necesar să se determine elementele care aparţin mulţimii. Pentru a determina care elemente aparţin mulţimii se organizează un ciclu care verifică dacă fiecare element posibil aparţine cu siguranţă mulţimii.

For i:=’a’ to ‘f’ step 1
If y in B then
Write(i)
Endif
Endfor

Exemple

1. Se citesc n cuvinte. Se cere să se afişeze literele distincte din fiecare cuvînt citit şi literele distincte întîlnite în toate cele n cuvinte.

Rezolvare:
Se vor declara două variabile de tip mulţime cu tipul de bază litere: cuvint şi total. Iniţial aceste mulţimi vor fi vide.

Type
Litere=set of ‘a’.. ‘z’
Var
Cuvint: litere
Total: litere
N: cardinal
I: integer
X: ‘a’ .. ‘z’
Begin
Total:=[]
For i:=1 to n step 1
Cuvint:=[]
While not eoln do
Readchar(x)
Cuvint:=cuvint + [litera]
Enddo
Writecard(n)
Total:=total+cuvint
For x:=’a’ to z’ step 1
If litera in cuvint then
Writechar(x)
Endif
Endfor
Endfor
For x:=’a’ to z’ step 1
If litera in total then
Writechar(x)
Endif
Endfor


2. Se dau numerele a şi b. Să se determine divizorii comuni ai celor două numere date folosind tipul mulţime.

Rezolvare:
Dacă numerele sunt de tip interval cu cel mult 256 elemente problema se rezolvă în felul următor:

Type
Interval = 1..255
M=set of interval
var
Da: m
Db: m
Dc: m
A: interval
B: interval
I: cardinal
Begin
Writestring(‘A-?’)
Readcard(a)
Writeln
;
Writestring(‘B-?’)
Readcard(b)
Writeln
;
Da:=[]
For i:=1 to a step 1
If a mod i = 0 then
Da:=da+[i]
Endif
Endfor
;
Db:=[]
For i:=1 to b step 1
If b mod i = 0 then
Db:=db+[i]
Endif
Endfor
;
dc:=da * db
;
For i:=1 to a step 1
If i in dc then
Writecard(i)
Endif
Endfor
var x1,x2,x3:array[0..255] of set of byte; i,j:word; a,b:word; n1,n2:byte; begin for i:=0 to 255 do x1[i]:=[]; endfor
readln(a); i:=1; while i<=a do if a mod i =0 then
n1:=i div 255;
n2:=i mod 255;
x1[n1]:=x1[n1]+[n2];
endif
i:=i+1
enddo
for i:=0 to 255 do
x2[i]:=[];
endfor
read(b);
i:=1;
while i<=b do
if b mod i =0 then
n1:=i div 255;
n2:=i mod 255;
x2[n1]:=x2[n1]+[n2];
endif
i:=i+1;
enddo
for i:=0 to 255 do
x3[i]:=x1[i]*x2[i];
writeln('tyy');
for i:=0 to 255 do
for j:=1 to 255 do
if j in x3[i] then
writeln(j+(i)*255);
end.

RECORD

Tipul înregistrare (articol)

Spre deosebire de tipul tablou, tipul articol este o structură neomogenă, care cuprinde un număr fix sau variabil de componente, care pot fi de tipuri diferite. Componentele articolului se numesc câmpuri. Un câmp al articolului este specificat printr-un identificator, numit selector şi prin tipul câmpului, care poate fi simplu sau structurat.
Tipul articol poate fi de două feluri:
- tipul articol fix care conţine numai o parte fixă, adică numărul componentelor este fix;
- tipul articol cu variante, care conţine o structură variabilă în ceea ce priveştye numărul componentelor sau tipul lor.
Tipul articol fix se defineşte în felul următor:

Type
Nume =Record
Selector1: tipul selectorului 1
Selector2: tipul selectorului 2
……………..
selectorn: tipul selectorului n
end

Selectorul este un identificator al câmpului. Câmpuri diferite vor avea selectori diferiţi. Un selector dintr-un articol poate avea acelaşi nume cu o variabilă din program sau cu un alt selector din altă înregistrare. Tipul selectorului este un tip simplu sau structurat.
Exemplu:
Type
data = record
zi: 1..31
luna: 1..12
an: cardinal
end
Type
persoana=record
nume: string[30]
data_nast: record
zi: 1..31
luna: 1..12
an: cardinal
end
sau
Type
persoana=record
nume: string[30]
data_nast: data
end
var
d1:data
d2:data
a,b:persoana;

Selectarea unei componente se realizează prin procedeul de calificare în felul următor:

Variabila_articol.selector

Exemple:
1. Variabilei d1 să i se atribuie valoarea 11 martie 1999
d1.zi:=11
d1.luna:=3
d1.an:=1999
2. Variabilei d2 să i se atribuie 9 mai 1945
D2.zi:=9
D2.luna:=5
D2.an:=1945
3.
a.nume:=’Ivanov’
a.data_nast.zi:=18
a.data_nast.luna:=5
a.data_nast.an:=1979

Vectori de articole
Var
Grupa: array[1..25] of persoana

Aritcole cu variante
Tipul articol cu variante reprezintă o structură care cuprinde o parte variantă, adică o parte care a cărei structură diferă de la un caz la altul. Astfel, două variabile, având acelaşi tip articol cu variante, vor putea avea structuri diferite, determinate de numărul componentelor şi/sau de tipul acestora. În general, valorile pe care le poate lua un anumit câmp din tipul articolului, numit câmp selector, vor determina variantele.

Type
Nume = record
Descrierea partea fixa
Descrierea partea variabila
End

Exemple
Type
Fel=(punct,triunghi,dreptunghi,cerc)
Figura=record
Nume: string[15]
Case f:fel of
Punct: (x:real,y:real)
Treunghi: (a,b,c:cardinal)
Dreptunghi:(a,b:cardinal)
Cerc(x,y:integer,r:cardinal)
End

operatii cu matrici

Determinarea elementului maxim al matricei

Să se determine elementul maxim al unui tabel bidimensional.

La început considerăm maxim primul element A[1,1]. Apoi parcurgând restul elementelor matricei , ori de câte ori gâsim un element A[i,j] mai mare, actualizăm maximul la valoarea acelui element.

Max:=A[1,1]
For i:=1 to n step 1 do
For j:=1 to m step 1 do
If A[i,j] >max then
Max:=A[i,j]
Endif
Endfor
Endfor

Însumarea elementelor fiecărui rând

Să se calculeze suma elementelor fiecărui rând al tabelului bidimensional. Rezultatele sâ se înscrie într-un vector.

Se va organiza un ciclu care se va repeta de n ori ( se calculează suma a n rânduri). O iteraţie a acestui ciclu va însuma cele m elemente a rândului. Însumarea elementelor rândului se va face în variabila S. La începutul prelucrării fiecărui rând S se iniţializează la valoarea 0. La sfârşitul prelucrării unui rând suma elementelor rândului ,păstrată în variabila S se va înscrie în elementul corespunzător al vectorului D[i] (i – indicele rândului).

For i:=1 to n step 1 do
S:=0
For j:=1 to m step 1 to
S:=S+A[i,j]
Endfor
D[i]:=s
Endfor

Transpunerea matricei

Să se transpună o matrice patrată.
Operaţia de transpunere se reduce la înlocuirea rândurile matricei cu coloanele ei. Se va forma o nouă matrice B, unde B[i,j]=A[j,i]

For i:=1 to n step 1 do
For j:=1 to m step 1 do
B[i,j]:=A[j,i]
Endfor
Endfor

Transpunerea se poate face în matricea iniţială. Elementele fiecărui rând situate deasupra diagonalei principale se interschimbă cu elementele coloanei corespunzătoare, situate sub diagonala principală.
For i:=1 to n –1 step 1 do
For j:=i+1 to n step 1 do
P:=A[i,j]
A[i,j]:=A[j,i]
A[j,i]:=p
Endfor
Endfor
Înmulţirea matricei cu un vector

Înmulţirea matricei A de dimensiune [n,m] la vectorul B de dimensiune [m]. Se va forma tabloul C, unde elementul C[i]=j=1ma[i,j]*b[j]

For i:=1 to n step 1 do
S:=0
For j:=1 to m step 1 do
S:=S+A[i,j]*B[j]
Endfor
C[i]:=S
Endfor


Înmulţirea a două matrici.

Pentru înmulţirea matricei A de dimensiune n*k la matricea B de dimensiune k*m se va forma matricea C, unde elementul
C[i,j]= j=1ka[i,j]*b[i,j]

For i:=1 to n step 1 do
For j:=1 to m step 1 do
S:=0
For l:=1 to k step 1 do
S:=S+A[i,l]*B[l,j]
Endfor
C[i,j]:=S
Endfor
Endfor

Eliminarea unui rând din matrice.

Se va elimina rândul k. Toate rândurile de la rândul cu numărul k+1 şi până la n vor fi deplasate cu un rând în sus.

For i:=k to n step 1 do
For j:=1 to m step 1 do
A[i,j]:=A[i+1,j]
Endfor
Endfor
N:=N-1

Inserarea unui rând în matrice.

Rândul se reprezintă cu ajutorul vectorului C.
Primele (k –1) rânduri nu se modifică. Iar celelelalte rânduri (k..n) se deplasează cu un rând în jos. Deplasarea acestor rânduri se realizează de jos în sus (ciclul după i). Apoi în rîndul k se scriu elementele vectorului C. În acest caz tabloul trebuie declarat cu (n+1) rânduri.

For i:=n to k step –1 do
For j:=1 to m step 1 do
A[i+1,j]:=A[i,j]
Endfor
Endfor
For j:=1 to m step 1 do
A[k,j]:=C[j]
Endfor
N:=N+1

Interschimbarea rândurilor matricei.

Se vor interschimba toate elementele rândului i cu elementele corespunzătoare ale rândului j.

For k:=1 to m step 1 do
P:=A[i,k]
A[i,k]:=A[j,k]
A[j,k]:=p
Endfor

Calcularea sumei elementelor diagonalei principale

Elementul e pe diagonala principală dacă i=j

S:=0
For i:=1 to n step 1 do
For j:=1 to n step 1 do
If i=j then
S:=s+A[i,j]
Endif
Endfor
Endfor

O variantă mai optimală ar fi următoarea:

S:=0
For i:=1 to n step 1 do
S:=S+A[i,i]
Endfor

Calcularea sumei elementelor diagonale secundare

Elementul e pe diagonala secundară dacă i+j=n+1

S:=0
For i:=1 to n step 1 do
For j:=1 to n step 1 do
If i+j=n+1 then
S:=S+A[i,j]
Endif
Endfor
Endfor

Sau
S:=0
For i:=1 to n step 1 do
S:=S+A[i,n+1-i]
Endfor


Probleme rezolvate cu matrice

1. Relaţii între persoane

Se dau n persoane şi matricea A, unde
A[i,j]=1, dacă persoanele i şi j se cunosc
A[i,j]=0, în caz contrar
Să se găsească persoanele care nu au nici o cunoştinţă.
Rezolvare:
Fie n – numărul persoanelor
A – matricea
K – numărul persoanelor care nu au nici o cunoştinţă
P - vector cu k componente; el reţine cele k persoane fără cunoştinţe.
Pentru rezolvarea problemei, în matricea dată se caută liniile care au numai zerouri. Ciclul For organizează prelucrarea a celor n rânduri. O iteraţie a ciclului determionă dacă rândul este format numai din zerouri. Prelucrare elementelor rândului se realizează folosind ciclul While. Ieşirea din acest ciclul se face sau când au fost examinate toate elementele rândului (j>n) sau când elementul rândului este diferit de 0 (A[i,j] #0). Dacă ieşirea din ciclu s-a realizat atunci când prima subcondiţie e falsă ((j<=n) = false) rezultă că tot rândul matrcei conţine elemente nule şi contorul k se incrementează cu o unitate.
K:=0
For i:=1 to n step 1 do
J:=1
While (j<=n) and (A[i,j]=0 do
J:=j+1
Enddo
If j>n then
K:=k+1
P[k]:=i
Endif
Endfor
If k>0 then
For i:=1 to k step 1 do
Writecard(p[i])
Endfor
Else
Writestring(‘nu există persoane fără cunoştinţe)
Endif


2. Cel mai bun dintre toţi

Într-o şcoală sunt m clase, fiecare având câte n elevi. Se cere să se determine care elev are media la învăţătură cea mai mare.


Rezolvare:

Vom memora într-o matrice toate mediile tuturor elevilor. Asctfel vom considera:

Var
Medie: array[1..m,1..n] of real

Elementul Medie[i,j] reprezintă media elevului de pe poziţia j din clasa i din şcoala respectivă.
Problema se reduce la determinarea celui mai mare element din întrega matrice. De aceea se pleacă de la ipoteza că cel mai mare element este primul – Medie[1,1]. Parcurgându-se matricea Medie, acest element maxim se poate modifica, actualizându-se la valoarea unui element găsit mai mare. Se păstrează, de fiecare dată, în variabilele i_max şi j_max poziţia pe linie, respectiv pe coloană, a elementului maxim.

Algoritm Cel_mai_bun
Var
Medie: array[1..m,1..n] of real
Clasa: cardinal
Elev: cardinal
Max: real
I_max: cardinal
J_max: cardinal
Begin
Max:=medie[1,1]
I_max:=1
J_max:=1
For clasa:=1 to m step do
For elev:=1 to n step do
If medie[clas,elev]>max then
Max:=medie[clas,elev]
I_max:=clasa
J_clasa:=elev
Endif
Endfor
Endfor

3. Generarea unei matrice dintr-un şir

Se cere să se construiască o matrice A cu m linii şi n coloane astfel încât elementele matricei să fie elementele şirului X în următoarea ordine: (cosiderăm m=3 şi n=4)
X1 X6 X7 X12
X2 X5 X8 X11
X3 X4 X9 X10
În cazul în care nu există suficiente elemente în vectorul X, deci matricea nu se poate construi, se va da un mesaj de eroare.

Rezolvare:
Var
M,n: cardinal ; dau dimensiunile matricei
K : cardinal ; numărul componentelor şirului
X : array [1..k] of real
A : array [1..m,1..n] of real

Se observă că elementele şirului sunt puse în ordine pe coloane şi anume pe o coloană de sus în jos, iar pe următoarea coloană de jos în jos. Pentru a deosebi cele două cazuri vom folosi o variabil de control notată kod care ia două valori posibile 0 şi 1. Dacă valoarea lui kod este 0 atunci pe acea coloană elementele din şir se pun începând cu prima linie şi până la linia m, iar dacă valoarea lui kod este 1 atunci pe acea coloană elementele şirului se pun începând cu linia a m-1 şi până la prima linie. Vom folosi şi variabilele :

L: cardinal ; indice în şir
Kod: 0..1 ; variabilă de control.
Algoritm
Begin
If m*n>k then
Writestring(‘Prea puţine elemente în şir’)
Else
J:=1
L:=1
Kod:=0
Repeat
If kod=0 then
Kod:=1
For i:=1 to m step 1 do
A[i,j]:=x[i]
L:=l+1
Endfor
Else
Kod:=0
For i:=m to 1 step -1 do
A[i,j]:=x[i]
L:=l+1
Endfor
Endif
Until j>n
End.

Tabele bidimensionale

Tabele bidimensionale
Fie că e necesar de determinat în ce zi şi la care oră a fost cea mai înaltă temperatură a anului. Cu aceast scop se poate declara un tablou cu 8760 (24*365) elemente , câte un element pentru fiecare oră a anului.
Type
Ore_an = array [1..8760] of integer
Var
Temp: Ore_an
Dacă există un tablou pentru toate orele anului, atunci temperatura maximă poate fi determinată aplicând algoritmul de căutare a elementului maxim în tablou. Şi dacă temperatura maximă a fost înregistrată în ora 4568, atunci apare problema cum să determinăm luna şi ziua. Evident , sunt necesare anumite calcule. Dar există şi altă rezolvare. În limbajele de programare se folosesc tabele multidimensionale.
Tabelul multidimensional este un tablou elementele căruia sunt de tip tablou.
De exemplu tabloul LunaTemp poate fi declarat ca tablou cu 31 elemene care conţin temperaturile fiecărei ore a zilei:
LunaTemp :array [1..31] of array [0..23] of integer

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
1
2
.
.
30
31
În mod analog poate fi declarat tabloul AnTemp:
AnTemp :array[1..12] of array [1..31] of array[0..23] of integer
Sau
AnTemp: array[1..12], [1.31], [0..23] of integer
Pentru a identifica un element a acestui tablou e necesar de indicat indecele fiecărei dimensiuni.
Pentru identificarea unui element a tabloului Temp se indică un indice (valoarea orei) Temp[100];
Pentru identificarea unui erlement a tabloului LunaTemp se arată doi indici (ziua,ora) LunaTemp[2,14] (temperatura la orele 14 în ziua 2 a lunii).
Pentru identificarea unui element a tabloului AnTemp se arată trei indici (luna, ziua,ora) AnTemp[5,18,10] (temperatura la 18 mai ora 10)
Declaraţia generală a unui tablou bidimensional este:
Type
Nume_tip = array [tip_indice1,tip_indice2] of tip_element
Var
Variabila_tablou : nume_tip
Un tablou bidimensional se mai numeşte şi matrice, conform noţiunii din matematică.
Un element al tabloului bidimensional se specifică prin intermediul numelui variabilei şi a valorilor indicelor elementului respectiv, sub forma:
Variabila_tablou[indice1,indice2],
unde indice1,indice2 conţin câte o expresie pentru fiecare indice, având tipuri compatibile cu cele ale tipului declarat. Corectitudinea valorilor indicilor este verificată pe parcursul executării programului. Dacă valoarile indice1,indice2 nu corespund tipurilor declarate, atunci se cauzează eroare de depăşire a domeniului de valori (eroare run_time).
Exemple:
1. Type
luna=(martie,apr,mai)
tablou=array[1..5,luna] of integer
Var
X: tablou
În acest exemplu primul indice este de tip interval [1..5], iar al doilea de tip enumerare. Tabelul va avea 5 rânduri, numerotate de la 1 până la 5 şi 3 coloane (deoarece tipul celui de-al doilea indice are numai trei valori).
Expresia X[2,martie] - specifică primul element din rândul dou;
X[5,mai] - specifică ultimul element din ultimul rând
X[3,dec] - specifică eroare, deoarece valoare celui de-al doilea indice nu aparţine tipului luna. .
Tablou[2,martie] – specifică eroare sintactică, deoarece tablou nu este nume de variabilă ci nume de tip;
X[2,apr]:=13 - atribuie elementului din rândul doi, coloana a doua valoarea 13;
X[2,apr]:=false - cauzează eroare sintactică, deoarece tipul elementului ( este integer) nu corespunde cu tipul expresiei (este boolean].
2. Type
Tablou = array[boulean,boulean] of boulean
Var
Y: tablou
În acest caz se declară un tablou bidimensional cu două rânduri (deoarece primul indice este de tip boolean ,care are numai două valori: false,true) şi două colane.
Expresia Y[false,false]:=false atribuie valoarea false elementului din primul rând şi din prima coloană.
3. Să presupunem că vrem să elaborăm programul orarului de activităţi pentru elevii din clasa 1. Cu acest scop vom defini o matrice în care, pe coloane vom avea zilele săptămânii, iar pe linii orele de lucru. În celula care se formează la intersecţia liniei cu coloana va fi un şir de caractere care reprezintă disciplina de învăţământ.
Type
Orar=array[1..4,1..5] of string
Var
Orarul_meu: orar
Putem, de asemenea să declarăm direct:
Var
Orarul_meu: array[1..4,1..5] of string.
Elementul Orarul_meu[2,3] reprezinta ziua de miercuri, lecţia 2.
Dar, pentru a fi mai sugestivi, am putea face declaraţii de genul:
Type
Zi_de_scoala=(luni,marti,miercuri,joi,vineri)
Orar: array[1..4,zi_de scoala] of string
Var
Orarul_meu:orar
Elementul Orarul_meu[2,miercuri] reprezinta ziua de miercuri, lecţia 2.
4. Să definim o matrice pentru o tablă de şah; piesele vor fi codificate: -1 pion negru, 1- pion alb, -2- cal negru, 2 – cal alb, ş.a.m.d., iar 0 pentru poziţiile neocupate.
Type
Tabla_de_sah=array[‘a’..’h’, 1..8’] of integer

5. Să presupunem că avem un grup de n băieţi şi n fete care sunt prietene cu cei n băieţi.
Vom memora aceasta sub forma unei matrice patratice (are numărul de coloane egal cu cel de linii):
Type
Matrice=array[1..n, 1..n] of boolean
Var
X:matrice
Vom avea X[i,j]=true dacă băiatul i este prieten cu fata j, respectiv false, dacă nu.
Noţiunea de prietenie este simetrică: dacă băiatul j este prieten cu fata i, atunci şi fata i este prietenă cu băiatul j. Matricea X va fi simetrică: X[i,j]=X[j,i].
Parcurgerea matricei
Considerăm declaraţia:
A :array[1..n,1..m] of integer;
Se declară un tablou cu două dimensiuni - un tablou bidimensional, care declară o matrice, formată din n linii şi m coloane:
A11 A12 … A1m
A21 A22 … A2m

An1 An2 … Anm
În memoria operativă elementele matriciei se alocă în felul următor:
A11, A12, … A1m, A21, A22, … A2n, … An1 , An2 … An
Elementele unui tablou bidimensional pot fi accesate secvenţial prin două metode:
1) pe rânduri;
2) pe coloane.
Pentru a parcurge toate elementele unei matrice este necesar ca cei doi indici care selectează un element din matrice să primească toate combinaţiile posibile. În acest scop trebuie să se efectuieze două cicluri incluse unul în altul.
Prelucrarea secvenţială pe rânduri se organizează cu ajutorul următorului algoritm:
Var
I:integer ;indicele rândului
J:integer ;indicele coloanei
Begin
For i:=1 to n step 1 do
For j:=1 to m step 1 do
{prelucrarea elementului A[i,j]}
endfor
endfor
Primul ciclu (după i) organizează prelucrarea a n rânduri a matricei. Corpul ciclului realizează prelucrarea unui rând. Deoarece rândul este compus din m elemente, se organizează un ciclu (după j), care prelucrează toate elementele rândului.
Pentru o valoare a variabilei i variabila j parcurge toate elementele posibile. Adică se va parcurge tot rândul respectiv.

Prelucrarea secvenţială pe coloane se organizează cu ajutorul următorului algoritm:
Var
I:integer ;indicele rândului
J:integer ;indicele coloanei
Begin
For j:=1 to m step 1 do
For i:=1 to n step 1 do
{prelucrarea elementului A[i,j]}
endfor
endfor

Citirea unei matrice


1. Să se citească de la tastatură un tabel bidimensional pe rânduri:
For i:=1 to n step 1 do
WriteString(‘Introdu rândul’
WriteInt(i)
For j:=1 to m step 1 do
ReadInt A[i,j]
Endfor
Writeln
Endfor
2. Să se citească de la tastatură un tabel bidimensional pe coloane:
For j:=1 to m step 1 do
WriteString(‘Introdu coloana’)
WriteInt(j)
For i:=1 to n step 1 do
ReadInt A[i,j]
Endfor
Endfor

Afişarea unei matrice

Să se afişeze un tabel bidimensional pe rânduri:

For i:=1 to n step 1 do
For j:=1 to m step 1 do
WriteInt A[i,j]
Endfor
Writeln
endfor

Însumarea componentelor unei matrice

1. Să se calculeze suma elementelor unui tabel bidimensional.

Se pleacă de la suma nulă. Apoi, folosind algoritmul de parcurgere secvenţială a elementelor maticei, suma creşte cu elementul curent, care este A[i,j],
unde i – indecele rândului, iar j – indecele coloanei.

S:=0
For i:=1 to n step 1 do
For j:=1 to m step 1 do
S:=S+ A[i,j]
Endfor
Endfor

3. Să se determine suma elementelor rândului k a unui tabel bidimensional
Elementele rândului k au primul indice constant, iar cel de-al doilea indice se schimbă de la 1.. m. Se va folosi un ciclu care se repetă de m ori care va accesa pe rând toate elementele rândului k.
S:=0
For j:=1 to m step 1 do
S:=S+A[k,j]
Endfor

Numărarea elementelor matricei, care verifică o anumită condiţie

Să se calculeze câte elemente impare conţine un tabel bidimensional.

Să notăm prin N_impar numărul elementelor impare. Iniţial ea se comportă caun contor nul. Parcurgând secvenţial elementele matricei, de fiecare dată când găsim în matrice un element impar (A[i,j] mod 2 #0) se incrementează contorul N_impar.
N_impar:=0
For i:=1 to n step 1 do
For j:=1 to m step 1 do
If A[i,j] mod 2 # 0 then
N_impar:=N_impar+1
endif
Endfor
Endfor


Determinarea existenţei în matrice a elementelor care au o anumită proprietate

Să se determine dacă matricea A conţine vre-un element nul.

Trebuie să se determine primul element nul. În cel mai nefavorabil caz ( când elementul din ultimul rând şi ultima coloană este nul sau nu există nici un element nul) se vor examina toate elementele matricei. Se va folosi o variabilă logică, de exemplu conţine. Iniţial acestei variabile i se atribuie valoarea false. Dacă elementul analizat va fi egal cu zero, atunci această variabilă va primi valoarea true şi se va termina parcurgerea matricei. Deci parcurgerea matricei va avea loc până când mai sunt elemente în matrice (i<=n şi j<=m) şi nu s-a găsit un element nul (not contine). Cu acest scop vom folosi ciclul While.

I:=1 se începe cu primul rând;
Contine := false;
While (i <=n) and not contine do
; prelucrarea unui rând
j:=1 se începe cu primul element al rândului;
while (j<=m) and not contine do
if a[i,j]=0 then
contine=true
endif
j:=j+1
enddo
i:=i+1
enddo

Obiective

Obiective
După ce veţi studia aceast capitol, veţi fi în măsură să:
- definiţi corect un tip de date tabel bidimensional;
- definiţi corect o variabilă de tip tabel bidimensional;
- accesaţi corect elementele tabelului bidimensional;
- modificaţi elementele unui tabel bidimensional;
- prelucraţi tabelul pe rânduri;
- prelucraţi tabelul pe coloane;
- construiţi un tabel bidimensional;
- afişaţi elementele unui tabel bidimensional;
- calculaţi suma elementelor unui tabel bidimensional;
- calculaţi suma elementelor unui rând;
- calculaţi suma elementelor unei coloane;
- număraţi elementele unui tabel bidimensional, care verifică o oarecare condiţie;
- determinaţi cel mai mare (cele mai mic) element al unui tabel bidimensional;
- determinaţi poziţia celui mai mare (celui mai mic) element al unui tabel bidimensional;
- dereminaţi existenţa într-un tabel bidimensional a vre-unui element care posedă o anumită proprietate;
- includeţi un rând într-un tabel bidimensional;
- includeţi o coloană într-un tabel bidimensional;
- eliminaţi un rând dintr-un tabel bidimensional;
- eliminaţi o coloană dintr-un tabel bidimensional;
- formaţi un vector dintr-un tabel bidimensional;
- selectaţi diferite regiuni dintr-un tabel bidimensional;
- proiectaţi algoritmi, folosind tabele bidimensionale.









Noţiuni primare
În lucrare se folosesc următoarele noţiuni primare:
- tip de date;
- tip de date elementar;
- tip de date structurat;
- tip de date utilizator;
- tip de date enumerare;
- tip de date interval;
- tip de date boolean;
- tip de date char;
- tip de date cardinal;
- tip de date integer;
- variabilă;
- operaţia de atribuire;
- operaţia de introducere;
- operaţia de afişare;
- operaţia de selectare;
- ciclul cu contor, realizat cu For;
- ciclul cu contor realizat cu While.
Algoritmi elementari
În lucrare se folosesc următorii algoritmi elementari:
- introducerea de la tastatură a n elemente;
- calcularea sumei a n elemente;
- numărarea elementelor dintr-un şir de n elemente care posedă o proprietate;
- determinarea elementului maxim (minim) din n elemente;
- determinarea poziţiei elementului maxim (minim) din n elemente;
- determinarea existenţei într-un şir de n elemente a unui element care posedă o anumită proprietate.

Tipul de date STRING

Tipul de date STRING
Printre tipurile standard se numără şi tipul char. Valorile de tip char reprezintă caractere (litere mari şi mici,cifre,semne de punctuaţie …). Un şir de caractere poate fi definit ca un vector, elementele căruia sunt caractere.
Type
Sir =array[1..10] of char
Var
A:sir;
Pentru variabila A în memoria operativă se alocă consecutiv 10 elemente de tip char:

[1] [2] [3] [4] [5] [6] [7] [8] [9] [10]
Pentru a facilita prelucrarea şirurilor de caractere majoritatea limbajelor de programarepermit definirea unor tipuri de date specifice – tipurile string.
Tipul string este definit ca un tip special de vector cu elemente de tip char, dar care memorează pe lângă caracterele din şir şi lungimea reală a respectivului vector de caractere. Lungimea acestui şir de caractere este limitată superior de o valoare declarată, numită dimensiunea şirului. Ea se declară odată cu declararea şirului, sub forma:
String[dimensiune]
De exemplu,
Type
Sir1=string[5]
Sir2=string[20]
Un şir de acest tip nu poate avea o dimensiune mai mare decât cea declarată. Dimensiunea unui şir poate varia între 0.. 255 caractere, deoarece această valoare se păstrează într-un octet.
Astfel, din punct de vedere al spaţiului de memorie ocupat, declaraţiile:
Type
Sir1 = string[5]
Sir2 = array [0..5] of char
Sunt echivalente. Variabila de tip sir1 va ocupa în memorie 6 octeţi (5 octeţi – pentru caracterele şirului şi un octet pentru dimensiunea lui) şi variabila de tip sir2 va ocupa în memoria operativă 6 octeţi (cîte un octet pentru fiecare element al vectorului: A[0], A[1], A[2], A[3], A[4], A[5]).
Prima poziţie (indicele 0) din string memorează un caracteravând codul egal ci dimensiunea reală a şirului ( o valoare întreagă între 0 ..255)

[0] [1] [2] [3] [4] [5]
6.2.1. Prelucrare şirurilor de caractere
Citirea de la tastatură a unui şir de caractere
Se realizează cu ajutorul unei proceduri standard
Readstring(sir), unde sir – variabilă de tip string.
La citirea valorii unei variabile de tip string este posibil ca lungimea şirului întrodus să depăşească dimensiunea declarată în definiţia tipului variabilei. În astfel de cazuri şirul întrodus este trunchiat, caracterele în exces ffind ignorate.
De exemplu:
Type
Sir = string[10]
Var
S:sir
În memoria operativă variabila S se alocă astfel:
0
[0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10]
Dacă în algoritm urmează Readstring (S) şi de la tastatură se întroduce ‘ABC’, atunci variabila S va avea următorul conţinut:
3 A B C ? ? ? ? ? ? ?
[0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10]
Iar dacă de la tastatură se întroduce ‘ABCDEF123456789’, atunci variabila S va avea următorul conţinut:
10 A B C D E F 1 2 3 4
[0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10]
Afişarea unui şir de caractere
Se realizează cu ajutorul procedurii standard Writestring(sir), unde sir – variabilă de tip string.
Atribuirea
Spre deosebire de vectori, unei variabile de tip string i se poate atribui valoarea unei expresii de tip string în componenţa căreia pot să apară constante şiruri de caractere, variabile de tip string, apeluri de funcţii care returnează şiruri de caractere şi operatorul ‘+’, care realizează concatenarea şirurilor.
Exemple:
Type
Sir =string[5]
Var
X: sir ;  0  ?  ?  ?  ?  ? 
Y: sir ;  0  ?  ?  ?  ?  ? 
Z: sir ;  0  ?  ?  ?  ?  ? 
Begin
X:= ‘ABC’ ;  3  A  B  C  ?  ? 
Y:= ‘D’+’E’+’F’  3  D  E  F  ?  ? 
Z:=X+Y  5  A B  C  D E
Dacă valoarea expresiei cuprinde mai multe caractere decât lungimea maximă a variabilei căreia i se atribuie, caracterele care sunt în plus se negligează.
Selectarea de componente.
Componentele unei variabile de tip string au tipul char şi se specifică prin identificatorul variabilei, urmat între paranteze drepte de o expresie – indice întregă cu valori cuprinse între 0 şi lungimea efectivă. Octetul care cuprinde lungimea efectivă a şirului are indeicele 0, iar tipul său este tot char.
De exemplu, X[1] din exemplul anterior are valoarea ‘A’.
Aplicarea operaţiilor relaţionale
Spre deosebire de vectori, variabilele de tip string pot să apară în expresii relaţionale. Operatorii relaţionali: =, # ,<, >, >=, <=, aplicaţi unor date de tip string, furnizează o valoare booleană.
Comparaţia a două date de tip string constă în compararea caracter cu caracter, de la stânga la dreapta, a codurilor ASCII ale caracterilor, până când se ajunge la 2 caractere diferite sau se epuizează caracterele unuia dintre şiruri. Expresia relaţională primeşte valoarea booleană, în conformitate cu relaţia dintre cele două caractere pe care s-a oprit comparaţia şi operatorul din expresia relaţională. Dacă şirurile coincid pe lungimea celui mai scurt, atunci acest şir este considerat “mai mic” decât celălalt. Şirurile sunt egale numai dacă atât lungimile cât şi conţinutul lor sunt identice. De exemplu:
a) ‘abc’ <’abcd’ =true
b) ‘axy’ < ‘abcd’ =false.
În alte limbaje de programare stringul se reprezintă în memoria operativă în felul următor:
Memorarea caracterelor în structură începe de pe prima poziţie şi informaţia efectivă va fi mărginită în dreapta de caracterul Null, caracter ASCII cu codul numeric egal cu zero.
Să revenim la reprezentarea stringului prin prima metoda. În acest caz lungimea efectivă a şirului se păstrează în octetul cu indicele 0, a variabilei, care este de tip char. Pentru a determina valoarea numerică a acestui octet se foloseşte funcţia ord:
Ord(X[0]).
În limbajele de programare se utilizează funcţii standard, care returnează lungimea efectivă a şirului. De exemplu în Pascal swe foloseşte funcţia Length(Sir)
Prelucrarea şirului de caractere caracter cu caracter
Deoarece valoarea unei variabile X de tip string este un şir de caractere, acestea pot fi referite individual, prin intermediul unui indice, la fel ca elementele unui vector, sub forma X[i]. Bineînţeles, că valoara indicelui i trebuie să se încadreze în intervalul 1.. length(x). Cu acest scop se va folosi ciclul cu contor, care se va repeta de length(x) ori.
De exemplu: Să se determine numărul de cifre din şirul citit de la tastatură.
Rezolvare:
Algoritmul va citi şirul în variabila S, pe care îl va analiza caracter cu caracter, incrementând contorul Nrcifre, dacă caracterul analizat este cifră. Caracterul analizat este cifră, dacă se respectă condiţia:
S[i]>=’0’ and S[i]<=’9’. Lungimea efectivă a şirului va fi determinatăcu ajutorul funcţiei standard Length(S). La începutul prelucrării şirului contorul Nrcifre se iniţializează cu valoarea zero.
Algoritm numarul_de_cifre;
Type
Sir=string[20]
Var
S:sir
Nrcifre:=cardinal;
I: cardinal;
Begin
Writestring(‘Întrodu şirul: ‘)
Readstring(s)
Nrcifre:=0
For i:=1 to length(s) do step 1
If s[i]>=’0’ and s[i]<=’9’ then
Nrcifre:=nrcifre+1
End
End
Writecard(nrcifre)
End.
Compararea şirurilor
Se citesc două şiruri, dacă acestea nu sunt identice, atunci se afişează în ordine lexicografică.
Algoritm comparare;
Type
Sir = string[20]
Var
Sir1: sir
Sir2: sir
Begin
Writestring(‘Introdu sirul 1:’)
Readstring(sir1)
Writeln
Writestring(‘Introdu sirul 2:’)
Readstring(sir2)
Writeln
If sir1 < sir2 then
Writestring(sir1)
Writeln
Writstring(sir2)
Else
If sir1>sir2 then
Writestring(sir2)
Writeln
Writstring(sir1)
end
End
End.

Ordonarea alfabetică a unei liste de cuvinte
Să se realizeze citirea a n cuvinte şi afişarea lor în ordine alfabetică.
Rezolvare:
Cele n cuvinte se vor memora într-un vector componentele căruia sunt de tip string. Apoi se va aplica un algoritm de sortare a vectorilor. Vom folosi ordonarea prin metoda bulelor.
Algoritm ordonare_alfabetica_cuvinte;
Type
Sir:string[20]
Vector:array[1..n] of sir
Var
X:vector
I:cardinal
Aux:sir
Ordonat:boolean
Begin
For i:=1 to n step 1
Writstring(‘introdu cuvîntul: ‘)
Readstring(x[i])
Endfor
Repeat
Ordonat:=true
For i:=1 to n-1 step 1
If x[i] >x[i+1] then
Aux:= x[i]
X[i]:=x[i+1]
X[i+1]:=aux
Ordonat:=false
Endif
Until ordonat
Writestring(‘Cuvintele în ordine alfabetică’)
For i:=1 to n step 1
Writestring(x[i])
Writeln
Endfor
End.