Recapitulare pentru bacalaureat

1. ALGORITMI....................................................................................................................................3
1.1. Noiunea de algoritm. Caracteristici :............................................................................................3
1.2. Date, variabile, expresii, operaii:.............................................................................................3
1.3. Structuri de baz (liniar, alternativ si repetitiv):..................................................................5
1.4. Descrierea algoritmilor (programe pseudocod):........................................................................8
2. Elementele de baz ale unui limbaj de programare (Pascal)..........................................................12
2.1 Vocabularul limbajului.............................................................................................................12
2.2 Constante. Identificatori...........................................................................................................12
2.3 Noiunea de tip de dat. Operatori aritmetici, logici, relaionali..............................................13
2.4 Definirea tipurilor de date........................................................................................................13
2.5 Variabile. Declararea variabilelor.............................................................................................13
2.6 Definirea constantelor..............................................................................................................14
2.7 Structura programelor. Comentarii...........................................................................................14
2.8 Expresii. Instruciunea de atribuire..........................................................................................14
2.9 Citirea/scrierea datelor.............................................................................................................14
2.10 Structuri de control (instruciunea compus, structuri alternative i repetitive)....................15
3.Subprograme...................................................................................................................................15
3.1. Subprograme. Mecanisme de transfer prin intermediul parametrilor.....................................15
3.2. Proceduri si functii predefinite................................................................................................17
4. Tipuri structurate de date................................................................................................................18
4.1
Tipul tablou.........................................................................................................18
4.2. Tipul sir de caractere...............................................................................................................23
4.3. Tipul nregistrare (articol).......................................................................................................25
5. Fisiere text......................................................................................................................................26
5.1. Fisiere text. Tipuri de acces.....................................................................................................26
5.2. Proceduri si functii predefinite pentru fisiere text...................................................................26
Sintaxa de declarare:......................................................................................................................26
Efect................................................................................................................................................27
Observatie importanta....................................................................................................................27
Probleme:........................................................................................................................................27
6. Algoritmi elementari.......................................................................................................................28
6.1. Probleme care opereaz asupra cifrelor unui numr...............................................................29
6.2. Divizibilitate. Numere prime. Algoritmul lui Euclid..............................................................30
6.3. Sirul lui Fibonacci. Calculul unor sume cu termenul general dat...........................................33
6.4. Determinare minim/maxim.....................................................................................................35
6.5. Metode de ordonare (metoda bulelor, inseriei, selectiei, numrrii)....................................36
Metoda de sortare prin numrare....................................................................................................39
6.6. Interclasare..............................................................................................................................40
6.7. Metode de cutare (secvential, binar)..................................................................................41
1/67

6.8 Analiza complexitii (considernd criteriile de eficien durata de executare i spaiu de

memorie utilizat)............................................................................................................................43
7. Subprograme definite de utilizator.................................................................................................43
7.1 Proceduri i funcii...................................................................................................................43
7.2 Proiectarea modular a rezolvrii unei probleme.....................................................................46
8. Recursivitate...................................................................................................................................47
8.1 Prezentare general...................................................................................................................48
8.2 Funcii i proceduri recursive...................................................................................................48
9. Metoda backtracking......................................................................................................................49
9.1. Prezentare general..................................................................................................................49
9.2. Probleme de generare. Oportunitatea utilizrii metodei backtracking....................................52
10. Generarea elementelor combinatoriale.........................................................................................55
10.1
10.2

Permutari, aranjamente, combinari...............................................................................55

Produsul cartezian .Submultimi..........................................................................................59

11.Grafuri...........................................................................................................................................60
11.1Grafuri neorientate...................................................................................................................60
11.2Grafuri orientate......................................................................................................................62
11.3Arbori......................................................................................................................................65

2/67

1. ALGORITMI

1.1. Noiunea de algoritm. Caracteristici

Prin algoritm se nelege o mulime ordonat i finit de reguli ce descriu o succesiune finit de
operaii necesare rezolvrii unei probleme.Paii algoritmului trebuie s-i fie indicai calculatorului
sub forma unor comenzi numite instruciuni. Mulimea tuturor instruciunilor ce descriu algoritmul
de rezolvare a unei probleme formeaz programul. Pentru a dialoga cu un calculator, este necesar
cunoaterea unui limbaj comun omului i calculatorului.
Atenie! Care sunt deosebirile dintre un calculator de buzunar i unul programabil?
Exemple de algoritmi:
-calcularea ariei unui triunghi(se cunosc a,b,c);
-calcularea nlimilor unui triunghi (se cunosc a,b,c);
-calcularea mediei unui elev;
-rezolvarea ecuaiei de gradul I etc.
Caracteristici ale algoritmilor:
-generalitatea = proprietatea de a fi valabil pentru o clas ( un gen) de probleme; (ex nu aduna 3+4
ci a+b)
-finitudinea = proprietatea de a permite obinerea soluiei problemei dup parcurgerea unui numr
finit de operaii (contraexemplu: ciclu infinit ex repeat write(*) ;until 3=4 ;).
-unicitatea= proprietatea conform creia ori de cte ori se pornete de la acelai set de valori ale
variabilelor de intrare se obin aceleai soluii.
Atenie!Fiecare proprietate trebuie exemplificat prin cte un exemplu i un contraexemplu.
Atenie! Dac un algoritm are aceste 3 proprieti nu nseamn c el este i corect.

1.2. Date, variabile, expresii, operaii:

1. Date :
-

Numerice

Alfanumerice

Logice

2. Operatii :
-

aritmetice

relationale (<,>,<>,<=,>=)
3/67

logice (booleene true, false)

3. Expresii
-

Aritmetice

relationale

logice (si, sau, not)

Tabela de adevr a operatorului si:

X si Y

False

False

False

False

True

False

True

False

False

True

True

True

Observatie: si are valoarea true doar daca ambii operanzi sunt true si falsa daca unul dintre ei este false.
Tabela de adevar a operatorului sau:

X sau Y

False

False

False

False

True

True

True

False

True

True

True

True

Observatie: sau are valoarea false doar daca ambii operanzi sunt falsi si true daca unul dintre ei este true.

Tabela de adevar a operatorului not

X
False
True

not X
True
False

Operatorul XOR (sau exclusiv):

X
False

Y
False

X xor Y
False
4/67

False

True

True

True

False

True

True

True

False

Aplicatii :
Legile lui De Morgan
Not(p sau q)= not p si not q
Not (p si q)= not p sau not q

1.3. Structuri de baz (liniar, alternativ si repetitiv):

1.1. Structuri liniare
1.1.1. Citirea datelor
Citire
Sintaxa :
Citeste(v1,v2,,vn) ;
Unde v1, vn= variabile
Efect : calculatorul asteapta introducerea de la tastatura a valorii variabilelor v1,, vn si da aceasta
valoare (in memorie) variabilelor precizate

Exemplu : Citeste(a,b) =>

Memorie | Ecran
a2

b3

1.1.2. Scrierea expresiilor

Sintaxa : Scrie(e1,e2,,en);
Unde e1,,en=expresii
Efect: Se evalueaza(calculeaza) valoarea expresiilor din lista si rezultatul se afiseaza pe ecran.
Exemplu : Scrie(a,b); => Ecran : 23
5/67

scrie( este , a); =>Ecran: A este 2

OBS importanta: in sintaxa lui citestein lista nu pot sa apara expresii. De ce ?
Atenie la formatul de afiare(a:2, a:n1:n2)!
1.1.3. Atribuirea
Sintaxa :
V := expresie
Se citeste : v ia valoarea expresie
Efect : Se evalueaza expresia v si rezultatul ii este dat (in memorie) lui v.
Exemple:
A :=a+b
B :=b+2*a
=> Memorie:.
1.2. Structuri alternative :
1.2.1. Instructiunea IF
daca c atunci X

altfel Y

unde c=conditie (expresie logica) , X,Y= cate o singura instructiune ;

Efect - se evalueaza c si daca este true se executa X ; daca este false se executa Y ;

- Probleme:
* Intr-o sala de clasa sunt mese si scaune. Se cunoaste numarul lor. Care dintre acestea sunt mai
multe ? Cunoscand si numarul elevilor clasei si faptul ca la o masa pot sta 3 persoane afisati daca :
a)

sunt destule mese ;

b)

sunt destule scaune.

* Se cunosc 5 numere<10000. Afisati numarul de cifre al acestora.

Scrie( ntrodu primul numar) ;
Citeste(a) ;
Daca a<10 atunci scrie (numarul are o cifra)
Altfel daca a<100 atunci scrie(numarul are 2 cifre)
Altfel daca a<1000 atunci scrie(numarul are 3 cifre)
6/67

Altfel scrie (numarul are 4 cifre);

Scrie( ntrodu un numar) ;
Citeste(b) ;
Daca b<10 atunci scrie (numarul are o cifra)
Altfel daca b<100 atunci scrie(numarul are 2 cifre)
Altfel daca b<1000 atunci scrie(numarul are 3 cifre)
Altfel scrie (numarul are 4 cifre);
Scrie( ntrodu un numar) ;
Citeste(c) ;
Daca c<10 atunci scrie (numarul are o cifra)
Altfel daca c<100 atunci scrie(numarul are 2 cifre)
Altfel daca c<1000 atunci scrie(numarul are 3 cifre)
Altfel scrie (numarul are 4 cifre);
Scrie( ntrodu un numar) ;
Citeste(d) ;
Daca d<10 atunci scrie (numarul are o cifra)
Altfel daca d<100 atunci scrie(numarul are 2 cifre)
Altfel daca d<1000 atunci scrie(numarul are 3 cifre)
Altfel scrie (numarul are 4 cifre);
Scrie( ntrodu un numar) ;
Citeste(e) ;
Daca e<10 atunci scrie (numarul are o cifra)
Altfel daca e<100 atunci scrie(numarul are 2 cifre)
Altfel daca e<1000 atunci scrie(numarul are 3 cifre)
Altfel scrie (numarul are 4 cifre);
Dupa rezolvarea acestei probleme se simte nevoia unei noi instructiuni: repeta.
1.2.2. Instructiunea Case
7/67

Sintaxa:
CASE e OF
L1:I1;
L2:I2;
L3 :I3 ;
.
[else In+1]
end ;
e= expresie cu rezultat de tip ordinal ;
L1,L2,Ln= liste de valori posibile ale expresiei e (contin valori sau/si intervalle delimitate de ,) ;
I2, I2,= cate o singura instructiune;
Efect: se evalueaza expresia e si se cauta lista careia ii apartine valoarea rezultata; se va executa
instructiunea corespunzatoare listei. Daca nu e gasita o astfel de lista, se executa In+1, daca aceasta
exitsta, altfel se trece la urmatoarea instructiune.

Structuri repetitive
1.3.1. Instructiunea REPEAT
1.3.2. Instructiunea WHILE
1.3.3. Instructiunea FOR
1.3.4. Verificari.

1.4. Descrierea algoritmilor (programe pseudocod):

Programarea structurata a inceput la inceputul anilor 70. Este un concept cu o importanta
fundamentala in scrierea algoritmilor. In general, algoritmii se eleboreaza prin utilizarea exclusiva a
anumitor structuri (liniar, alternativa, repetitiva). Prin structura se intelege o anumita forma de
imbinare a operatiilor cu care lucreaza algoritmii.
Structuri de baz:
structurile liniar
alternativ
repetitiv
Descrierea algoritmilor cu ajutorul schemelor logice i n pseudocod;
Schema logic este reprezentarea grafic a unui algoritm.

Blocurile necesare ntocmirii unei scheme logice:

8/67

Blocul terminal pune n eviden nceputul i sfritul unei scheme logice; spre deosebire de
celelalte, blocul terminal START, respectiv STOP pot s apar numai o singur dat ntr-o schem
logic.
Blocul de intrare/ieire - pune n eviden informaiile de intrare, respectiv ieire, precum i
momentul i locul n care acestea se execut; prin intermediul acestor blocuri are loc schimbul de
informaii dintre algoritmul propriu-zis i exterior.
Blocul de calcul - pune n eviden operaiile aritmetice, precum i transferul de valori ntre
diferitele variabile utilizate n algoritm.
Blocul de decizie - pune n eviden punctele de ramificare ale algoritmului (n funcie de anumite
condiii).
Blocul de procedur (funcie) permite scrierea prescurtat a unei secvene care execut o anumit
funciune;
Blocul conector - pune n eviden nodurile (punctele de intersecie) unui algoritm
Modul de parcurgere al algoritmului (de trecere de la un bloc la altul) este indicat prin sgei avnd
un singur vrf.
Descrierea modular-structurat a algoritmilor :
Pentru ca un algoritm s fie simplu, eficient, intuitiv, uor de verificat i dezvoltat sau
corectat el trebuie realizat ca o succesiune liniar de module formate din una sau mai multe
instruciuni, cu proprietatea c au o singur intrare i o singur ieire. Pentru ca un modul s aib o
singur intrare i o singur ieire dispunem de trei structuri fundamentale
-structuri liniare;
-structuri alternative;
-structuri repetitive ;
Structurile liniare= succesiuni de operaii ce se execut necondiionat n ordinea dat.
Structurile alternative constau dintr-un bloc de decizie (c) i dou blocuri (a1) i (a2) care se
execut alternativ, dup cum contractul este adevrat sau fals (DA/NU) i un bloc conector.
Observaie: a1 sau a2 pot s fie vide.
Structurile repetitive permit efectuarea uneia sau mai multor operaii de un numr de ori
pn o condiie este ndeplinit. Structurile repetitive poart i denumirea de structuri ciclice
sau cicluri.
Avantaj: scrierea programului poate fi fcut de mai multe persoane, modificrile se fac uor.
Pseudocod:
Structuri liniare: citirea, scrierea, atribuirea, instruciunea compus, instruciunea vid.
Structuri alternative: dac (if), case (case)
Structuri repetitive: repet (repeat), ct_timp (while), pentru (for).
9/67

a) Structuri liniare:
a1) citirea;
a2) scrierea;
a3) atribuirea;
a4) instruciunea compus;
a5) instruciunea vid.
b) Structuri alternative:
b1) dac;
c) Structuri repetitive:
c1) repet;
c2) cat timp;
c3) pentru.

Aplicaii:
Ce vor tipri urmtoarele secvene de program :
1. readln(a,b,c) ;
if a=1 then if b=2 then if c=3 then writeln(3) else writeln(2) else writeln(1) else
writeln(0) daca se citesc valorile 1 3 3?
2. readln(a,b,c);
if a=1 then else if b=2 then else if c=3 then else writeln(0)
dac se citesc valorile 1 2 3?
3. readln(a,b,c) ;
if (c<a) and not(a>=b) then c:=a+b
else if not(a>=c) and (c<b) then a:=c+b
else if (a<b) and (b<c) then a:=b+c;
writeln(a,b,c);
daca se citesc valorile 4 8 6 ?
4) readln(a,b) ;
10/67

if a>=b then if b>0 then begin a:=a+2; b:=b-a; end else b:=b-4
else if a+2 >=b then b:=2-b else a:=a+b;
writeln(a,b);
dac se citesc valorile 0 1 ?
5) b :=-1 ;
repeat readln(a) ; if b<a then b:=a; until a=0;
writeln(b);
dac se vor citi valorile: 4,-300009,33000 si 0.
6) x :=7; for i :=1 to 5 do x :=x+1 ;writeln(x);
7) x:=1; while x<=10 do x:=x+1; writeln(x);
8) x:=1; for I:=1 to 2 do write(x); writeln;
9) x:=1;I:=2; while I>=0 do begin write(x); I:=I-1; end;
10) x:=1; for I:=1 to n do x:=x*n; pt n=5;
11) x:=1; for I:=1 to n do x:=x*10;
12) x:=10; for I:=1 to n do x:=x*I;
13) x:=1; I:=0;
14) while I<n do x:=x*10;I:=I+1;
15) a:=0;b:=1; if a=0 then if b=0 then write('b=0')
16)

a:=1;b:=0; if a=0 then if b=0 then write('b=0')

else c:=-a/b;
else c:=-a/b;

17) a:=0;b:=0; if a=0 then if b=0 then write('b=0')

else c:=-a/b;

18) a:=7;b:=14; if a=0 then if b=0 then write('b=0')

else c:=-a/b;

19)

p:=1;i:=1;while i<7 do i:=i+1;p:=p*i;

20)

p:=1;i:=6;while i>1 do begin p:=p*i;i:=i-1; end;

21) p:=1;i:=1;repeat p:=p*i;i:=i+1; until i<6;

22) p:=1;n:=2;for i:=2 to n do p:=p*i;
23) var i,n:integer; begin n:=8; for i:=1 to n do n:=n-1; end.
24)

var x,y:char; begin x:='x';y:=x;writeln(x,y);writeln('x','y'); x:=y;y:='x';

writeln(x,y); end.
11/67

25) var x,y:char; begin x:='x';y:='y';writeln(x,y);writeln('x','y'); x:=y;y:='x';

writeln(x,y); end.
26) var i,j,k:integer; begin for i:=1 to 2 do begin writeln; for j:=1 to i*i
do begin for k:=1 to i+j do write('*');
writeln;
end; end; end.
27)

var i,j,k:integer; begin for i:=1 to 2 do begin writeln; for j:=1 to i+i
do
begin for k:=1 to j-i do write('*');
writeln;
end;
end; end.

28) Verificai: var x:integer; begin for x:=1 to 10 do case x of

1,3,5,7,9:writeln('Impar ',x); 2,4,10:writeln('Par ',x); end end.

2. Elementele de baz ale unui limbaj de programare (Pascal)

2.1 Vocabularul limbajului
Setul de caractere (alfabetul) :
- litere mari i mici ale alfabetului latin (caractere alfabetice) :a, b, c etc.
- cifrele sistemului de numeraie zecimal (caractere numerice ) 0,1,2,3,9
- simbolurile +,-,*,/,=,<.>,(,),&, etc numite caractere speciale
Separatori de simboluri: spaiul i enter.
Comentariul :{ } sau (* *), caracterul de sfrit de linie (eol), caracterul ; separ
instruciunile i declaraiile. Poate s lipseasc naintea lui end.

2.2 Constante. Identificatori

Identificatorii desemneaz nume de programe, constante, tipuri, variabile, funcii, proceduri,
parametri. Printr-un identificator nelegem un nume asociat unei constante, variabile, proceduri sau
funcii. Un identificator poate conine numai litere, cifre, caracterul special _ i trebuie s nceap
obligatoriu cu o liter. Exemplu: A2, B, val_medie etc.
O categorie special de identificatori este reprezentat de cuvintele cheie al limbajului: program,
begin, until, to, downto etc.
Constante ntregi -cele cuprinse n [-32768, 32767] .Ex :13,-25,678,etc.
Constante reale sunt numere reale cuprinse ntre 3.4*10 la puterea -4352 i 1.1*10 la puterea
4932.
Constantele caracter: orice limbaj de programare conine un set de caractere propriu. Setul de
caractere folosit de limbajul Pascal se numete setul ASCII i conine litere, cifre i caractere
speciale.
Constante simbolice (desemnate prin identificatori) :
- identificatori introdui prin definiii de constante;
- identificatorii constantelor unui tip enumerare;
- identificatorii standard true i false;
- identificatorii nil i maxint;
12/67

2.3 Noiunea de tip de dat. Operatori aritmetici, logici, relaionali

Tipul unei date definete mulimea valorilor pe care le poate lua variabila, precum i mulimea
de operaii care pot fi efectuate cu elementele mulimii respective. Ex: integer, boolean, real etc.
Operatori aritmetici: +, -, *, /, div, mod.
Operatori logici: and, or, xor, not.
Operatori relaionali: <, >, =, <=, >=, <>.

2.4 Definirea tipurilor de date

Type nume_tip=tip ;
Tipurile ordinale reprezint mulimi finite i ordonate de valori. Putem s ne referim la numarul de
ordine al unei valori (cu funcia ord), putem specifica elementul succesor ( cu funcia succ) sau cel
predecesor (cu funcia pred) al unui element dat.
- Tipuri simple standard: tipuri ntregi, real, boolean (logic), char (255 caractere).
Tipurile ntregi pot fi: integer(-32678...32767), word(0...65535), shortint(-128...127), byte(0...255),
longint(-2.147.486.348...2.147.483.647).
-Tipuri ordinale definite de utilizator: enumerat i subdomeniu.
Tipul enumerare definete o mulime ordonat de valori: se enumer un ir de identificatori care
desemneaz valorile posibile. Primul identificator desemneaz cea mai mic valoare, cu numrul de
ordine zero.
Poate fi definit astfel: Type nume_tip=(idebtif1,identif2,.,identifn);
Variabilele de tip enumerare sunt declarate n seciunea var. Ele pot lua una din valorile enumerate
n list. Operaiile ce se pot face sunt : atribuirea, determinarea numrului de ordine (ord),
determinarea succesorului sau predecesorului(deter. succ. ultimului element sau pred. primului
elem. va genera eroare), comparaia (<,<=,>,>=,)
-Tipul interval. Fiind dat un tip ordinal, din acesta se poate genera un nou tip, numit tipul
interval. Definiia lui indic valoarea constant cea mai mic i cea mai mare din interval (n sensul
numrului de ordine) i cuprinde toate valorile dintre ele. Exemple : 2..7 sau c..f.
Type nume_tip=valoarea_minima..valoarea_maxim
Obs : valoarea_minimvaloarea maxim. Nu este permis definirea unui interval al tipului real,
deoarece acesta nu este un tip ordinal.
-Tipul fiier(f:text;);
-Tipuri structurate: tablouri unidimensionale(vectori- ex: var v:array[1..100];), tablouri
bidimensionale (matrici ex:var m:array[1..100,1..100];), sir de caractere (ex: v:string;), articol (ex:
a:record
n:integer; end;).

2.5 Variabile. Declararea variabilelor

Spre deosebire de constante, o variabil este o dat ale crei valori se pot modifica la fiecare
nou execuie a programului sau chiar n timpul unei execuii. Orice variabil are asociat un anumit
tip.
O declaraie de variabil asociaz un nume i un tip unei locaii de memorie. Fiecare variabil
ce apare ntr-un program Pascal trebuie s fie declarat n seciunea var n felul urmtor :
Var list_de _identificatori1:tip1;
.
list_de _identificatorin:tipn;
Identificatorii din list sunt desprii prin virgul.

2.6 Definirea constantelor

13/67

ntr-un program Pascal, constantele pot fi utilizate direct prin valoare sau printr-un
identificator. Acest identificator se definete n partea de definire a constantelor. Astfel, constanta
este utilizat n locul valorii sale, prin identificatorul su.
Exemplu: const pi=3.1415.
Odat stabilit valoarea identificatorului de constant, aceasta nu se mai poate modifica prin
instruciuni ale programului.
Avantaje ale utilizrii constantelor: economie de memorie, modificarea simpl a programelor,
claritate sporit a programului.

2.7 Structura programelor. Comentarii

[program nume;] {numele programului}
[uses ;] {=biblioteci de programe}
[const max=20;] { max=20 e un exemplu}
[type nume_tip=tip ;] {tip e un tip de date}
[var list_de _identificatori1:tip1;]
[subprograme]
begin
programul propriu-zis;{corpul programului}
end.
[]-poate s lipseasc.

2.8 Expresii. Instruciunea de atribuire

n timpul execuiei unui program, la ntlnirea unei expresii, calculatorul evalueaz expresia
respectiv, adic n acel moment variabilele din componenta expresiei au nite valori, calculatorul
va nlocui n expresie variabilele cu valorile lor i se va obine valoarea expresiei.
n cadrul expresiilor aritmetice, logice i relaionale pot fi utilizate funciile standard (funcii
declarate n unitul SYSTEM) urmtoare:
- funcii de transformare: chr, ord, trunc, round;
- funcii matematice: int, frac, sin, cos, arctan, pi,sqrt,ln,exp,abs,sqr;
- proceduri i funcii referitoare la valori ordinale: succ, inc, pred, dec, odd;
Exista 4 grupe de prioritate:
-Grupa 1 (prioritate maxima) : not, + (operator unar), - (operator unar);
-Grupa 2( se mai numesc si operatori multiplicativi): and, *, /, div, mod ;
-Grupa 3(se mai numesc si operatori aditivi): or, xor, +, - ;
-Grupa 4 (cea mai mica prioritate si cuprinde operatorii relationali) : <,<=,>,>=,=,<>.
Instruciunea de atribuire se face in felul urmator : v :=expresie ;{v este o variabil}

2.9 Citirea/scrierea datelor

Citirea datelor se realizeaz cu ajutorul instruciunii read. Exemplu: read(n);.Se pot citi date
de la tastatur sau dintr-un fiier.
Scrierea datelor se realizeaz cu ajutorul instruciunii write. Exemplu:write(6);. i datele pot
fi scrise ntr-un fiier.
{unde n este o variabil}

2.10 Structuri de control (instruciunea compus, structuri alternative i

repetitive)
14/67

Liniare:
- citirea (read, ex: read(n););
- scrierea (write, ex: write(n););
- atribuirea (v:=expresie);
- instruciunea vid;
- instruciunea compus(begin {read(n); write(n);}end.);
Alternative:
- dac (if, ex: if n=1 then n:=2;);
Repetitive:
- repet (repeat, ex: n:=1
repeat n:=n+1;
until n=4; );
- ct timp (while, n:=1;
while n<5 do n:=n+1; );
- pentru (for, for n:=1 to 4 do write(n);).
{unde n este o varialil}

3.Subprograme
3.1. Subprograme. Mecanisme de transfer prin intermediul parametrilor
Definitie:
Subprogramul reprezinta parti identificabile prin nume care se pot activa la cerere prin
intermediul acestui nume.
O parte din subprogram se contruieste ca subprogram daca un algoritm cuprinde in mai multe
locuri aceiasi secventa de operatii executabila pentru aceleasi date sau pentru date diferite.
In loc ca subprogramul sa cuprinda in acelasi loc, acelasi grup de instructiuni, concepand grupul
de intructiuni ca subprogram, el va aparea in program o singura data si se va activa de mai multe
ori. Partea respectiva de program rezolva o subproblema din cele in care se descompune problema
complexa.
In limbajul Pascal, avem doua tipuri de subprograme : procedurile si functiile. Deosebirea intre
ele consta in numarul de valori calculate si returnate programului apelat. Procedurile calculeaza mai
multe valori sau nici una, iar functiile returneaza o singura valoare asociata numelui functiei. Atat
procedurile cat si functiile pot fi standard(predefinite in unitul sistem), cat si nestandard(definite de
utilizator). Procedurile si functiile nestandard trebuie declarate obligatoriu inainte de a fi apelate.
O declarare de subprograme:
-un antet de supbrogram care precizeaza interfata subprogramului cu mediul
-blocul subprogramului care descrie functionarea lui interna
Domeniul de vizibilitate(valabilitate) al identificatorilor:
Prin domeniul de vizibilitate (valabilitate) se intelege zona de program in care e valabila
declararea sau definirea unui identificator.
Toti indentificatorii definiti sau declarati intr-un bloc sunt cunoscuti in blocul respectiv si se
numesc variabile locale.
Daca blocul cuprinde blocuri incluse in care identificatorii (variabile locale ale acestora) nu se
definesc sau redenumesc, atunci acestea sunt cunoscute in blocurile incluse si se numesc variabile
globale pentru acesta.
15/67

Daca o variabila declarata intr-un bloc se redefineste atunci in blocul in care a fost redeclarata
va fi variabila atribuita generata la redeclarare.
A.Procedurile
Declararea si apelul procedurilor.Parametrii formali si parametrii efectivi
Definitie:
Procedura este un subprogram care calculeaza mai multe valori accesibile sau nu programului
apelant sau efectueaza anumite operatii fara sa calculeze vreo valoare.
Valorile calculate accesibile programului apelant reprezinta parametrii de iesire ai
subprogramului. Acestia pot depinde de anumite valori pe care subprogramul le primeste din
programul apelant, valori reprezentand parametrii de intrare.
Parametrii formali sunt variabile simbolice in care lucreaza subprogramul. Ele sunt declarate in
antetul subprogramului si sunt cunoscute numai in interiorul subprogramului..
Parametrii efectivi reprezinta variabilele cu care subprogramele lucreaza efectiv in momentul
activarii.
La apelarea procedurii se specifica parametrii efectivi sau actuali prin intermediul instructiunii
procedurale
Declararea procedurii:
PROCEDURE nume_procedura(lista parametrii)
-parametrii precizati la scrierea proedurii sunt parametrii formali si se separa prin ;
-pentru fiecare parametru se precizeaza numele si tipul acestuia.
Apelarea procedurii:
Pentru a executa o procedura aceasta trebuia apelata. La apel se da numele procedurii si valorile
concrete ale parametrilor care se separa prin punct si virgula.
Ex : uses crt;
procedure citire(n :integer ; k :char) ;
begin
writeln(Introdu un numar si litera atribuita lui!);
read(n); read(k);
writeln(Pentru litera ,k, gasim cifra ,n,.);
end;
begin
clrscr;
citire(n, k);
end.

Cand se apeleaza o procedura, modulul apelant a abandonat temporar, si se executa procedura.

In timpul executiei procedurii, parametrii formali sunt inlocuiti in tot corpul procedurii cu
parametrii actuali (valori concrete). Dupa executarea procedurii se revine in modulul apelant la linia
imediat urmatoare celei care a facut apelul. Parametrii formali si parametrii efectivi nu e obligatoriu
sa aiba acelasi nume dar trebuie sa existe o concordanta de numar, tip si ordine.
B.Functiile
Declararea si apelul functiilor:
Definitie:
Functia este un subprogram care calculeaza si returneaza programului apelant o singula valoare.

16/67

Aceasta valoare este asociata numelui functiei. Iar tipul poate fi simplu, string sau reper. Valoarea
returnata de functie nu poate avea alt tip structurat decat string.
Declararea unei functii:
FUNCTION nume_functie(lista parametrii formali): identificator de tip;
-nume_functie reprezinta numele functiei, al carei tip este identificator de tip
-identificator de tip = nume de tip simplu: STRING sau REPER;
Blocul functiei trebuie sa contina obligatoriu o instructiune de atribuire prin care identificatorul
functiei primeste valoarea unei expresii.
Identificatorul functiei nu are voie sa apara in partea dreapta a unor atribuiri decat daca functia
este recursiva.
Apelarea functeii:
- se intrerupe calculul expresiei in care a aparul apelul functiei ;
- se transmit parametrii, daca exista, exact ca la proceduri ;
- se executa functia;
Ex : uses crt;
var a:integer;
b:real;
function f(var x:real);
begin
if x<0 then x:=-x;
x:=x*10;
x:=x mod 10;
end;
begin
clrscr;
a:=12;
b:=3.4567;
a:=a+f(b);
writeln(a+f(b)+f(b));
end.

3.2. Proceduri si functii predefinite

Definitie:
Procedurile si functiile predefinite sunt niste blocuri de instructiuni care au fost scrise de catre
autori ale limbajului.

Pentru a folosi o astfel de procedura trebuie sa avem executia adica sa o apelam.

Ex. proceduri: - write
-writeln

Sunt folosite pentru afisarea unor date pe ecran.

Functiile predefinite sunt similare cu procedurile, dar in plus, in cazul unor executari, o functie
intoarce o valoare adica noi apelam functia , ea se executa si la sfarsitul executiei ne da inapoi un
rezultat.
Ex: -ABC(X) returneaza mod lui z
-SQR(X) returneaza X

17/67

-SQRT(x) returneaza radical X

4. Tipuri structurate de date

4.1

Tipul tablou

Tipul tablou este tipul compus, care consta dintr-un numar fix de componente, fiecare
componenta avnd acelasi tip. La definirea tipului tablou trebuie precizat att tipul componentelor, ct
si tipul indicelui, care stabileste numarul componentelor tabloului .

1.1.1

Tipul array

Sintaxa declararii:
Nume_tip= array [l1..l2] of tip;
L1=limita inferioara a valorilor indicilor;
L2=limita superioara a valorilor indicilor;
l1,l2 de tip ordinal;
tip=tipul elementelor tabloului (tip oarecare);
Fiecare componenta a unei variabile de tip tablou poate fi specificata prin numele variabilei
urmat de indice ncadrat ntre paranteze patrate (de ex. a[4]).
Deoarece tip poate fi de orice tip, el poate fi tot un tip tablou. Astfel devine posibila definirea
tipului tablou multidimensional.
-exemple de siruri;
-exemple de matrici (tablouri bidimensionale);
-exemple de tablouri tridimensionale;
-citirea si afisarea sirurilor, a matricilor;
Sa se determine cte elemente prime se afla deasupra diagonalei secundare a unei matrice cu n x
n elemente naturale.

type matrice =array [1..100,1..100] of integer;

var f:text;

18/67

x,i,j,n,k,t:integer;
a:matrice;
begin
assign (f,'date.in'); reset(f);
readln(f,n);
t:=0;
for i:=1 to n do
for j:=1 to n do
read(f,a[i,j]);
for i:=1 to n do
begin
for j:=1 to n do
write(a[i,j]:3);
writeln
end;

for i:=1 to n do
for j:=1 to n-i+1 do
begin
x:=0;
for k:=2 to a[i,j]-1 do
if a[i,j] mod k =0 then
x:=x+1 ;
if x=0 then t:=t+1;
end;
writeln('sunt' ,t, 'numere prime');
end.

19/67

Se citeste de la tastatura o matrice de dimensiune n x n. Spuneti daca exista in matrice doua linii
sau doua coloane gemene (doua linii sunt gemene daca au aceleasi elemente, eventual in alta ordine)
Ex
N=3
121
456
211
Liniile 1 si 3 sunt gemene

Type sir=array [1..100] of integer;

matrice =array [1..100] of sir;
var f:text;
x,i,j,n,k,t:integer;
da:boolean;
a:matrice;
procedure geamana(i,j:integer;var da:boolean);
var b,c:sir;cc: integer; k:integer; sant:integer;
begin
{b:=a[i];c:=a[j];}
for k:=1 to n do b[k]:=a[i,k];
for k:=1 to n do c[k]:=a[j,k];
repeat
sant:=0;
for k:=1 to n-1 do if b[k]>b[k+1] then
begin
cc:=b[k];b[k]:=b[k+1];b[k+1]:=cc;
sant:=1;
end;

20/67

until sant=0;
repeat
sant:=0;
for k:=1 to n-1 do if c[k]>c[k+1] then
begin
cc:=c[k];c[k]:=c[k+1];c[k+1]:=cc;
sant:=1;
end;
until sant=0;
sant:=0;
for k:=1 to n do if b[k]<> c[k] then sant:=1;
if sant=0 then da:=true
else da:=false;
end;
begin
assign (f,'date.in'); reset(f);
readln(f,n);
t:=0;
for i:=1 to n do
for j:=1 to n do
read(f,a[i,j]);
for i:=1 to n do
begin
for j:=1 to n do
write(a[i,j]:3);
writeln
end;
for i:=1 to n do

21/67

for j:=i+1 to n do
begin
geamana(i,J,da);
if da then begin writeln('existsa doua gemene',i,' cu ',j);j:=n;i:=n;end;
end;
if not da then writeln('nu exista gemene');

end.
Alte probleme asemanatoare :
1. Verificati daca o valoare ntreaga X, citita de la tastatura, se gaseste printre cele n elemente ntregi ale
unui vector. Elementele vectorului se vor citi de la tastatura n ordine crescatoare.
2. Sa se afle cate elemente maxime are un sir dat cu n elemente.

3. Sa se determine cte elemente prime se afla deasupra diagonalei principale a unei matrice cu n x n
elemente naturale.

1. Se cunoaste un numar n si n numere citite de la tastatura. Calculati maximul lor.

program unu;
var f:text;
maX,n,i:integer;
a:array [1..100] of integer;
begin
write ('n='); readln(n);
for i :=1 to n do
begin
write('a[',i,']=');
readln(a[i]);
end;

22/67

max:=a[1];
for i:=1 to n do
if a[i]>max then max:=a[i];
writeln ('max este',MAX);
Readln;
end.

4.2. Tipul sir de caractere

operatori, proceduri si functii predefinite pentru: citire, afisare, concatenare,
cutare, extragere, inserare, eliminare si conversii (sir <-> valoare numeric)
declararea:
var v:string;
sau
var v:string[lmax];
lmax=numrul maxim de caractere al irului v;
Citirea unei variabile de tip string se face cu read(v), afiarea ei cu write(v). Caracterele din care
este format variabila pot fi prelucrate una cte una (v[1], v[2],,v[n]). Lungimea variabilei
(numrul de caractere poate fi aflat cu ajutorul funciei length(v).

Operatori, proceduri si functii predefinite pentru citire, afisare, concatenare,

cautare, extragere, inserare, eliminare si conversii (sir<-> valoare numerica)
Pos (function)
Caut ntr-un string un substring.
Declararea:
function Pos(Substr: String; S: String): Byte;
Exemplu:
writeln(pos(ana, ioana); => 3
writeln(pos(Ana, ioana); => 0

Delete
terge un substring dintr-un string.
Declararea:
procedure Delete(var S: String; Index: Integer; Count:Integer);
Exemplu:
s:= Ana Maria);
delete(s,3,2);
writeln(s);
=> AnMaria

Concat (function)
Concateneaz mai multe stringuri.
23/67

Declararea:
function Concat(s1 [, s2,..., sn]: String): String;
writeln(concat(ana+maria)) => afieaz anamaria

Copy (function)
Returneaz un substring dintr-un string.
Declararea:
function Copy(S: String; Index: Integer; Count: Integer): String;
ex.
s:=copy(ana maria,3,4);
writeln(s); => a ma

Insert (procedure)
Insereaz un substring ntr-un string.
Declararea:
procedure Insert(Source: String; var S: String; Index: Integer);
Exemplu: s:= ana maria;
insert(corina,s,4); =>anacorina maria

Length (function)
Returneaz numrul de caractere pe care le conine un string.
Declararea:
function Length(S: String): Integer;

UpCase (function)
Transform litera mic n majuscul.
Declararea:
function UpCase(Ch: Char): Char;
ex.
s:= ana maria;
s[1]:=upcase(s[1]);
writeln(s); => Ana maria

Probleme:
1. Se citeste o propozitie. Eliminati din ea literele a,b,c.
Rezolvare:
uses crt;
var s:string;
begin
clrscr;
writeln('Introduceti o propozitie ');
readln(s);
while pos('a',s)<>0 do delete(s,pos('a',s),1);
while pos('b',s)<>0 do delete(s,pos('b',s),1);
while pos('c',s)<>0 do delete(s,pos('c',s),1);
writeln;
write(s);
end.
24/67

2.De la tastatura se citesc un numar n si n denumiri de orase. Scrieti aceste nume sub forma: prima
litera mare, urmatoarele mici intr-un fisier cu numele rase.out.
Rezolvare:
uses crt;
var a:array[1..100] of string;
s:string;
n,i:integer;
f:text;
begin
clrscr;
write('n=?');
readln(n);
for i:=1 to n do begin writeln('Introduceti numele unui oras ');
readln(a[i]);
end;
for i:=1 to n do begin
s:=a[i];
s[1]:=upcase(s[1]);
a[i]:=s;
end;
assign(f,'orase.out');
rewrite(f) ;
for i:=1 to n do writeln(f,a[i]);
close(f);

end.

4.3. Tipul nregistrare (articol)

Tipul nregistrare fix - desemneaz o structur format dintr-un numr de component
numite cmpuri.
In cadrul unui articol campurile pot fi de diferite tipuri, spre deosebire de vectori unde
elementele au acelasi tip.
Sintaxa:
V= record
l1:tip1;
l2:tip2;
l3:tip3;

ln:tipn;
end;
l1, l2, l3, ln = liste de cmpuri;
tip1, tip2, tip3,tip n = tipurile cmpurilor din listele l1, l2, l3, ln ;
25/67

Exemplu:
a: record;
sex, nume, culoareochi: char;
h, g, v: integer;
casatorit: Boolean;
media: real;
end;
Tipul unui cmp este oarecare, deci poate fi tot articol si se pot defini tipuri imbricate.
Un nume de cmp trebuie sa fie unic numai n tipul articol n care a fost definit. Un cmp al unei
variabile de tip articol este referit prin numele variabilei i numele cmpului, separate printr-un
punct.
Exemplu:
read(a.nume);
read (a.h, a.g, a.v);
if a.v >=18 then write ( DA )
else write ( NU );

4.3.1. Instruciunea WITH

WITH c DO x
c= variabila de tip record
x= o singura instructiune
-

Efect: in instructiunea x se adauga c. inaintea campurilor variabilei c

Este utilizata pentru a usura scrierea anevoioasa a calificarilor.
Exemplu:
var a: record
nume, prenume: string[30];
nota: integer;
end;

with a do begin
readln ( nume );
readln ( prenume );
readln ( nota );
end;

5. Fisiere text
5.1. Fisiere text. Tipuri de acces
5.2. Proceduri si functii predefinite pentru fisiere text
Sintaxa de declarare:
varf:text;

unde varf=variabila de tip fisier

26/67

assign(varf,numefis); unde numefis= nume real al fisierului;

Efect: ataseaza variabilei varf fisierul cu numele numefis

reset(varf); -deschide pentru citire fisierul varf;
rewrite(varf); -deschide pentru scriere fisierul varf;
read(varf,v1,vn); -citeste din fisierul varf valorile v1,vn;
readln(varf,v1,vn); -citeste din fisierul varf valorile v1,vn si trece apoi la linie noua;
write(varf,e1,,en); -scrie in fisierul varf valorile expresiilor e1,en
writeln(varf,e1,,en); -scrie in fisierul varf valorile expresiilor e1,en si apoi trece la linie noua;
writeln(varf); -trece la linie noua in fisierul varf;
close(varf); -inchide fisierul varf.

Observatie importanta: din fisierele deschise pentru citire se poate doar citi, iar in cele
deschise pentru rescriere se poate doar scrie.

Probleme:
1. Fie programul:
Var a,b,c,d:integer;f:text;
Begin
Assign(f,date.in);reset(f);
Readln(f,a,b);read(f,c);read(f,d);
Close (f);
Write(a);writeln(b);writeln(c,d);End.
Ce se va afisa pe ecran daca:
a)

fisierul contine:

234
27/67

56
78
b)

fisierul contine:

2
4
6789
2. Fie programul:

Var a,b,c,d:integer;f:text;
Begin
Assign(f,a:\date.in);rewrite(f);
Readln(a,b);read(c);read(d);
Write(f,a);writeln(f,b);writeln(c);writeln(f,d); Close (f);End.
Ce va contine fisierul daca se dau numerele urmatoare? Unde va fi el salvat?
a)
234
56
78
b)
2
4
6789
28/67

6. Algoritmi elementari
6.1. Probleme care opereaz asupra cifrelor unui numr
1. De la tastatura se citete un numar natural n .Afiai ultima cifr a numrului.
Se observ c:- uc= ultima cifr a numrului;
- n div 10 =numrul fr ultima cifr
uses crt;
var n,uc:integer;
p:integer;
begin
clrscr;
read(n);
uc:=n mod 10;
n:=n div 10;
writeln('ultima cifra este',uc);
end.
2. Scriei un program pascal care calculeaz i afieaz suma cifrelor pare ale unui numr natural.
uses crt;
var n,uc,s:integer;
p:integer;
begin
clrscr;
read(n);
s:=0;
repeat
uc:=n mod 10;
if uc mod 2=0 then s:=s+uc;
n:=n div 10;
until n=0;
writeln('Suma cifrelor pare este',s);
end.
3.Scriei un pascal care calculeaz cea mai mare i cea mai mic cifr a unui numr natural dat.
uses crt;
var n,max,uc,min:integer;
begin
clrscr;
read(n);
max:=0;min:=10;
repeat
uc:=n mod 10;
if uc>max then max:=uc;
if uc<min then min:=uc;
n:=n div 10;
until n=0;
writeln('cea mai mare cifra este',max);
writeln('cea mai mica cifra este',min);
29/67

end.
4.Se cunosc dou numere.Aflai suma cifrelor lor.
uses crt;
var a ,b,uc1,uc2,s,s1,s2:integer;
p:integer;
begin
clrscr;
read(a);
read(b);
s1:=0;s2:=0;
repeat
uc1:=a mod 10;
s1:=s1+uc1;
a:=a div 10;
until a=0;
repeat
uc2:=b mod 10;
s2:=s2+uc2;
b:=b div 10;
until b=0;
s:=s1+s2;
writeln('Suma celor doua numere este',s);
end.

6.2. Divizibilitate. Numere prime. Algoritmul lui Euclid

Spunem c numrul natural a se divide cu d,dac exist un nr.c, astfel nct a=dxc.
Ex:30 se divide cu nr.5, pentru ca exist un nr.6,astfel nct 30=5x6.
Dac d/a,atunci d se numete divizor al lui a i a se numete multiplu al lui d.
Divizori proprii i improprii
Orice nr.este divizibil prin 1 i prin el nsui.Nr.1 i nr. nsui se numesc divizori improprii.Ceilali
divizori ai nr. se numesc divizori proprii.
Ex:D6={1;2;3;6}

1.Scriei un program pascal care calculeaz i afieaz produsul cifrelor divizibile cu 5 ale unui
numr natural.
uses crt;
var n,uc:integer;
p:integer;
begin
clrscr;
read(n);
p:=1;
repeat
uc:=n mod 10;
if uc mod 5=0 then p:=p*uc;
30/67

n:=n div 10;

until n=0;
writeln('produsul cifrelor divizibile cu 5 este',p);
end.
2.Verificai dac un numr dat este perfect. Un numr este perfect dac este egal cu suma divizorilor
si(exclusiv el).
Ex: 6=1+2+3;
uses crt;
var i,s,n:longint;
begin
clrscr;
read(n);
{25242}
i:=1;s:=0;
repeat
if n mod i=0 then s:=s+i;
i:=i+1;
until i=n;
if s=n then writeln('Nua=marul este perfect')
else writeln('Numarul nu este perfect');
end.
3. Calculai cel mai mare divizor a 2 numere naturale citite de la tastatur.
Metoda 1:
uses crt;
var a,b,i ,min,x:integer;
begin
clrscr;
read(a,b);
if a<=b then min:=a
else
min:=b;
for i:=1 to min do
if (a mod i=0) and (b mod i=0) then x:=i;
writeln('cel mai mare divizor comun este',x);
end.

Numim numr prim orice nr.nat.mai mare dect 1,care are numai divizori improprii.Nr.prime
sunt:2;3;5;7;11;13;17;19;23;29;31...
Obs.:Singurul nr.prim i par este 2.
Pentru a afla daca un numar este prim sau nu, l descompunem n factori primi,adica l mprim la
toate nr.prime cu care este divizibil. Dac este divizibil doar cu 1 si cu el nsui,atunci nr. este prim.
Nr. prime ntre ele
Dou numere care au cel mai mare divizor comun 1,se numesc numere prime ntre ele.
Obs.:dac a i b sunt prime ntre ele, scriem:(a;b)=1
Proprietate:Dou numere consecutive sunt prime ntre ele.
1. Se citete un numr de la tastatur. Este el prim?
31/67

uses crt;
var n,i,k:integer;
begin
clrscr;
read(n);
k:=0;
for i:=2 to n-1 do
if n mod i=0 then k:=k+1;
if k=0 then writeln('Numarul este prim')
else writeln('Numarul nu este prim');
end.
2.Descompunerea unui numar natural n dou numere naturale prime distincte ntre ele.
uses crt;
var k,n,a,d,j,b,i:integer;
begin
clrscr;
read(n);
k:=0;
for i:=2 to n div 2 do
begin
{verificam daca i este prim}
a:=0;
for j:=2 to i-1 do
if i mod j =0 then a:=1 ;
if a=0 then
begin
b:=n-i;
{verificam daca b este prim}
d:=0;
for j:=2 to b-1 do
if b mod j=0 then d:=1 ;
if d=0 then if i<>b then begin
writeln(i,' ',b);
k:=1;
end;
end;
end;
if k=0 then write('nu exista solutie');
end.

Algoritmul lui Euclid este o metod eficient de calcul al celui mai mare divizor
comun(CMMDC).
CMMDC al dou numere este cel mai mare numr care le divide pe ambele. Algoritmul lui Euclid
se bazeaz pe principiul c cel mai mare divizor comun al dou numere nu se modific dac
numrul cel mai mic este sczut din cel mai mare. De exemplu, 21 este CMMDC al numerelor 252
i 105 (252 = 21 12; 105 = 21 5); ntruct 252 105 = 147, CMMDC al lui 147 i 105 este tot
21. Cum cel mai mare dintre cele dou numere este redus, repetarea acestui proces d numere din ce
n ce mai mici, pn cnd unul dintre ele este 0. Cnd se ntmpl aceasta, CMMDC este cellalt
32/67

numr, cel nenul. Inversnd paii algoritmului lui Euclid, CMMDC se poate exprima sub form de
celor dou numere iniiale, fiecare nmulite cu un ntreg pozitiv sau negativ, de exemplu: 21 = 5
105 + (2) 252.
Algoritmul lui Euclid calculeaz eficient CMMDC a dou numere orict de mari sunt, deoarece
nu necesit niciodat mai mult dect de cinci ori numrul de cifre (n baz 10) al celui mai mic
ntreg.
Exemple:
28
28 : 49=0 rest 28
49
49 : 28=1 rest 21
28 : 21=1 rest 7
21 : 7 =3 rest 0
d.c= 7(ultimul rest 0)
a b
c
36 : 42= 0 rest 36
b c
42 : 36= 1 rest 6
36 : 6= 6 rest 0
d.c= 6
24
17

24 : 17= 1 rest 7
17 : 7=2 rest 3
7 : 3=2 rest 1
3 : 1=3 rest 0
d.c=1

1. Calculai cel mai mare divizor comun si cel mai mic multiplu comun a 2 numere naturale citite de
la tastatur.
Metoda II:
uses crt;
var a,b,i ,min,x,c,cmmmc,cmmdc,p:integer;
begin
clrscr;
read(a,b);
repeat
c:=a mod b;
a:=b;
b:=c;
until c=0;
cmmdc:=a;
p:=a*b;
cmmmc:=p div cmmdc;
writeln('cel mai mic multiplu comun este',cmmmc);
writeln('cel mai mare divizor comun este',cmmdc);
end.

6.3. Sirul lui Fibonacci. Calculul unor sume cu termenul general dat
irul lui Fibonacci este o secven de numere n care fiecare numr se obine din suma
precedentelor dou din ir. Astfel, primele 10 numere ale irului lui Fibonacci sunt:
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...
(primele 2 numere sunt predefinite, iar restul se obin n mod recursiv, din suma precedentelor dou:
3 = 2 + 1, 5 = 3 + 2 ...)
33/67

Afiai primii n termeni ai irului lui Fibonacci:

uses crt;
var a,b,c,i,n:integer;
begin clrscr;
a:=0;
b:=1;
writeln('Cate elemente din sirul lui Fibonacci doriti sa fie afisate?');
read(n);
write(a,' ',b);
for i:=3 to n do begin c:=a+b;
write(' ',c);
a:=b;
b:=c;
end;
end.

Date de intrare: n=10

Date de ieire: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34

Pentru un numr natural n dat s se calculeze expresia:

S= 1+ 4+ 7+ + (3n-2)

uses crt;
var a:array[1..100] of longint;
n,i,s:integer;
begin clrscr;
writeln('Care este valoarea lui n?');
34/67

read(n);
for i:=1 to n do a[i]:=(3*i-2)*(3*i-2);
s:=0;
for i:=1 to n do s:=s+a[i];
writeln('Valoarea expresiei s este:',s);
end.

Date de intrare: n= 10
Date de ieire: s= 2845

6.4. Determinare minim/maxim

Se d un vector cu n elemente citite de la tastatur. Calculai maximul si minimul elementelor din
vector.
program minmax;
var a:array[1..100] of integer;
n,i,min,max:integer;
begin
writeln('Cate elemente are vectorul?');
read(n);
writeln('Introduceti elementele vectorului!');
for i:=1 to n do
read(a[i]);
min:=a[1];
max:=a[1];
for i:=1 to n do
begin
if a[i]>max then max:=a[i];
if a[i]<min then min:=a[i];
35/67

end;
writeln('Maximul elementelor din vector este ',max,' iar minimul este ',min,'.');
end.

6.5. Metode de ordonare (metoda bulelor, inseriei, selectiei, numrrii)

Prin metoda bulelor se verific dou cte dou toate elementele din vector i dac nu
sunt ordonate corespunzator le interschimbm.
Ex: 4 3 3 3 2
3
4
4
2
3
5
5
2
3
3
6
2
3
4
4
2
3
5
5
5
3
6
6
6
6
7
7
7
7
7
8
8
8
8
8
Pentru a ordona cresctor un vector cu n elemente folosim programul urmator:
uses crt;
var a:array[1..100] of integer;
c,n,i:integer;
ok:boolean;
begin clrscr;
write('Cate elemente sunt in vector?');
read(n);
writeln('Introduceti elementele vectorului');
for i:=1 to n do read(a[i]);
writeln('Vectorul neordonat este:');
writeln;
for i:=1 to n do write(a[i],' ');
repeat
36/67

ok:=true;
for i:=1 to n-1 do if a[i]>a[i+1] then begin
c:=a[i];
a[i]:=a[i+1];
a[i+1]:=c;
ok:=false;
end;
until ok=true;
writeln;
writeln('Vectorul ordonat este:');
for i:=1 to n do write(a[i],' ');
end.
Sortarea prin inserie seamn oarecum cu sortarea prin selecie. Tabloul este mprit
imaginar n dou pri- o parte sortat i o parte nesortat. La nceput, partea sortat conine primul
element al tabloului i partea nesortat conine restul tabloului. La fiecare pas, algoritmul ia primul
element din partea nesortat i l insereaz n locul potrivit al prii sortate. Cnd partea nesortat nu
mai are niciun element, algoritmul se oprete.
Ex: S ordonm vectorul: 7, -5, 2, 16, 4 folosind sortarea prin inserie.
7, -5, 2, 16, 4 nesortat
7, -5, 2, 16, 4 -5 va fi inserat 7 > -5 , schimbm
-5, 7, 2, 16, 4 2 va fi inserat 7 > 2, schimbm
-5, 2, 7, 16, 4 -5 < 2 , 2 ramne pe loc
-5, 2, 7, 16, 4 16 va fi inserat, 7 < 16, 16 ramne pe loc
-5, 2, 7, 16, 4 4 va fi inserat, 4 < 16, schimbm
-5, 2, 7, 4, 16 4 < 7 , schimbm
-5, 2, 4, 7, 16 ordonat
Pentru a ordona cresctor un vector cu n elemente folosim programul urmator:
uses crt;
var a:array[1..100] of integer;
i,j,n,x,k:integer;
begin clrscr;
writeln('Cate numere sunt in vector?') ;
read(n);
37/67

for i:=1 to n do read(a[i]);

j:=1;
repeat j:=j+1;
for i:=1 to j do if a[j]<a[i] then begin
x:=a[j];
for k:=j downto i+1 do a[k]:=a[k-1];
a[i]:=x;
i:=j;
end;
until j=n;
writeln('Vectorul ordonat este:');
for i:=1 to n do write(a[i]);
end.
Ordonarea prin selecie (metoda munimului). Vectorul este mprit n dou pri
imaginare- o parte sortat i o parte nesortat. La nceput, partea sortata este goal, n timp ce partea
nesortat conine ntreg tabloul. La fiecare pas, algoritmul gsete elementul minim din partea
nesortat i l adaug la finalul prii sortate. Cnd partea nesortat rmne goal, algoritmul se
oprete.
Ex: S ordonm vectorul: 5, 1, 12, -5, 16, 2, 12, 14 utiliznd sortarea prin selecie.
5, 1, 12, -5, 16, 2, 12, 14 nesortat
5, 1, 12, -5, 16, 2, 12, 14 interschimbm 5 cu -5 (partea sortata este - 5, partea nesortat este 1, 12,
5, 16, 2, 12, 14)
-5, 1, 12, 5, 16, 2, 12, 14 1 rmne pe poziie (partea sortat este -5, 1, partea nesortat este 12, 5,
16, 2, 12, 14)
-5, 1, 12, 5, 16, 2, 12, 14 interschimbm 2 cu 12 (partea sortat este -5, 1, 2, partea nesortat este 5,
16, 12, 12, 14)
-5, 1, 2, 5, 16, 12, 12, 14 5 rmne pe poziie (partea sortat este -5, 1, 2, 5, partea nesortat este 16,
12, 12, 14)
-5, 1, 2, 5, 16, 12, 12, 14 interschimbm 16 cu 12 (partea sortat -5, 1, 2, 5, 12 ,12, partea nesortat
16, 14)
-5, 1, 2, 5, 12, 12, 16, 14 interschimbm 16 cu 14 (ajungem la partea sortat -5, 1, 2, 5, 12, 12, 14,
16 i partea nesortat este goal, algoritmul se oprete)
-5, 1, 2, 5, 12, 12, 14, 16 sortat
uses crt;
var a:array[1..100] of integer;
i,n,j,c,poz,min:integer;
38/67

begin clrscr;
write('Cate elemente sunt in vector?');
read(n);
writeln('Introduceti elementele');
for i:=1 to n do read(a[i]);
for i:=1 to n do begin
min:=a[i];
poz:=i;
for j:=i to n do if min>a[j] then begin
min:=a[j];
poz:=j;
end;
if a[poz]<>a[i] then begin
c:=poz;
a[poz]:=a[i];
a[i]:=c;
end;
end;
writeln('Vectorul ordonat este:');
for i:=1 to n do write(a[i],' ');
end.

Metoda de sortare prin numrare const n construirea unui nou vector care are aceeai
dimensiune ca i vectorul iniial. Vom analiza fiecare element din primul vector i l vom
compara cu fiecare alt element din ir pentru a putea reine n al doilea vector numrul
elementelor care sunt mai mici dect elementul considerat, astfel vom afla poziia pe care trebuie
s-l punem pe acesta.
Programul Pascal de ordonare:
uses crt;
var a,b,c:array[1..100] of integer;
39/67

k,i,x,n:integer;
begin clrscr;
write('Cate elemente sunt in vector?');
read(n);
writeln('Introduceti elementele vectorului');
for i:=1 to n do read(a[i]);
k:=0;
repeat
k:=k+1;
x:=0;
for i:=1 to n do
if a[k]>a[i] then x:=x+1;
b[k]:=x;
until k=n;
for i:=1 to n do b[i]:=b[i]+1;
x:=0;
repeat
x:=x+1;
for i:=1 to n do if b[i]=x then c[x]:=a[i];
until x=n;
writeln;
writeln('Vectorul ordonat este:');
for i:=1 to n do write(c[i],' ');
end.

6.6. Interclasare
Interclasarea a 2 vectori sortati deja crescator, intr-un al treila vector astfel incat acesta sa ramana
tot sortat.
var a,b,c:array[1..20] of integer;
40/67

i,n,j,k,x,y,m:integer;
begin
write('m=');readln(m);
for i:=1 to m do
begin
write('a[',i,']=');
readln(a[i]);
end;
write('n=');readln(n);
for i:=1 to n do
begin
write('b[',i,']=');
readln(b[i]);
end;
i:=1; j:=1; k:=1;
while (i<=m) and (j<=n) do
begin
if a[i]<b[j] then
begin
c[k]:=a[i];
i:=i+1;
end
else
begin
c[k]:=b[j];
j:=j+1;
end;
k:=k+1;
end;
if i<=m then for x:=i to m do
begin
c[k]:=a[x];
k:=k+1;
end;
if j<=n then for y:=j to n do
begin
c[k]:=a[y];
k:=k+1;
end;
for i:=1 to n do write(c[i],' ');
readln;
end.

6.7. Metode de cutare (secvential, binar)

Cutarea secvenial are avantaje i dezavantaje. Unul din avantajele cautrii secveniale il
reprezinta faptul c vectorul nu trebuie ordonat cresctor pentru a putea gasi numarul cutat. Un
dezavantaj il reprezinta numrul de operaii mari care trebuie effectuate pentru cutarea numarului
in cazul in care vectorul ar avea dimensiuni mari iar numarul ar fi situat la sfarsitul acestuia.

De la tastatur se citeste un vector de n elemente i un numr m. Aflai dac numrul se gseste in

vector si afisai un mesaj corespunzator.
41/67

var a:array[1..100] of integer;

n,i,m:integer;ok:boolean;
begin
writeln('Cate elemente are vectorul?');
read(n);
writeln('Introduceti elementele vectorului!');
for i:=1 to n do
read(a[i]);
writeln('Care este numarul pe care il cautati?');
read(m);
ok:=false;
for i:=1 to n do
if a[i]=m then ok:=true;
if ok then writeln('Numarul cautat de dumneavoastra a fost gasit!')
else writeln('Numarul cautat de dumneavoastra nu a fost gasit!');
end.

Cautarea binar. Pentru a aflat dac un numr se gaseste sau nu intr-un vector folosind
metoda cautarii binare vectorul trebuie ordonat crescator.
De la tastatur se citeste un vector cu n elemente ordonate cresctor i un numar m. Aflai dac
numrul se afla in vector i afisai un mesaj corespunzator.
uses crt;
var a:array[1..100] of integer;
n,i,m,c,p:integer;ok:boolean;
function poz(i,j,m:integer):integer;
var mijl:integer;
begin
if i=j then if a[i]=m then poz:=i
else poz:=0
42/67

else begin
mijl:=(i+j) div 2;
if m<a[mijl] then poz:=poz(i,mijl,m)
else if a[mijl]=m then poz:=mijl
else poz:=poz(mijl+1,j,m);
end;
end;
begin
clrscr;
writeln('Cate elemente are vectorul?');
read(n);
writeln('Introduceti elementele vectorului!');
for i:=1 to n do
read(a[i]);
writeln('Care este numarul pe care il cautati?');
read(m);
p:=poz(1,n,m);
if p=0 then writeln('Nr. cautat nu se gaseste in vector.')
else writeln('Nr cautat se gaseste in vector.');
end.

6.8 Analiza complexitii (considernd criteriile de eficien durata de executare

i spaiu de memorie utilizat)

7. Subprograme definite de utilizator

7.1 Proceduri i funcii
Scrierea programului se face mult mai uor dac mprim problema n subprobleme relativ
independente, pentru fiecare din ele scriindu-se programe mult mai simple. De altfel, realizarea unui
program de complexitate mare impune organizarea unor date i a aciunilor la care acestea trebuie
supuse sub form de subprograme.
Subprogramele limbajului Pascal sunt de dou tipuri:
43/67

proceduri
funcii.

Diferena dintre ele const n numrul valorilor calculate i returnate programului apelant.
Att procedurile ct i funciile pot fi de dou tipuri:
standard (predefinite);
nestandard (declarate n program).
Procedurile i funciile nestandard trebuie obligatoriu declarate nainte de a fi apelate. In cazul
general, un program Pascal e format dintr-un program principal i dintr-un numr oarecare de
proceduri i funcii apelabile din programul principal sau unele din altele.
Declarare i apel
Declararea unei proceduri:
procedure nume[([var] l1:tip1[;[var] l2:tip2.])];
l1, l2,..., ln = lista parametrilor formali.
Apelul unei proceduri:
nume (la1,la2,,lan);
la1,,lan = lista parametrilor efectivi (actuali).
Declararea unei funcii:
function nume[([var] l1:tip1[;[var] l2:tip2.])]tip;
l1, l2,..., ln = lista parametrilor formali.
Apelul unei funcii:
nume(la1,la2,...,lan);
la1,,lan = lista parametrilor efectivi (actuali).
parametrii actuali i cei formali trebuie s corespund n numr, tip i ordine;
dac lista parametrilor formali este vid, atunci sau nu exist schimb de informaii cu restul
programului, sau schimbul se execut prin intermediul variabilelor globale;
spre deosebire de proceduri, funciile returneaz ele nsele un rezultat. n cadrul definirii
funciei, numele funciei poate aprea n stnga semnului egal. Ultima apariie de acest fel
returneaz rezultatul funciei. Funcia poate fi apelat n cadrul unor expresii (write,
atribuire) n cadrul programului apelant.

Clasificarea parametrilor unei proceduri:

a) Dup tipul parametrilor:
parametrii actuali;
parametrii formali.
b) Dup modul de transmitere:
parametrii transmii prin valoare :
44/67

- sublista lor nu este precedat de nici un cuvnt cheie (VAR);

- aceti parametri pot fi modificai n corpul procedurii dar valorile noi nu se
transmit ctre blocul apelant, ei sunt doar parametri de intrare;
- sunt asemanatori unor constante (si pot modifica valoarea n timpul
execuiei procedurii, dar revin la valoarea anterioar la ieirea din execuia
procedurii);
parametri transmii prin referin:
- sublista lor este precedat de cuvntul cheie VAR, iar parametri actuali sunt
variabile;
- aceti parametri pot fi modificai n corpul procedurii, ei sunt parametri de
ieire, nu sunt transmii prin valoare ci se transmite adresa lor, deci n blocul
apelant valorile parametrilor actuali vor fi modificate.

Proceduri i funcii predefinite

1. Funcii de transformare:
Function trunc(x:real):longint; - rezultatul e int(x) daca x>0 si int(x)+1 daca x<0;
trunc(-2.3)=-2;
trunc(2.7)=+2;
Function round(x:real):longint;
round(2.3)=2;
round(2.6)=3;
2. Funcii matematice:
Function int(x:real):real;
Function frac(x:real):real;
Function sin(x:real):real;
Function cos(x:real):real;
Function arctan(x:real):real;
Function pi;
Function sqrt(x:real):real;
Function ln(x:real):real;
Function exp(x:real):real;
Function abs(x);
Function sqr(x);
3. Proceduri i funcii referitoare la valori ordinale:
Function succ(x);
Procedure inc(var x[;n:longint]); incrementeaza x de n ori;
Function pred(x);
Procedure dec(var x[;n:longint]); decrementeaza x de n ori;
Function odd(x:longint):Boolean; returneaza true daca x e impar, false in caz contrar;
4. Subprograme destinate tratrii irurilor:
Delete
Insert
Str
Val
Concat
Copy
Length
Pos
5. Proceduri de interes general:
Random + Randomize + Upcase
45/67

Variabile globale si variabile locale, domeniu de vizibilitate

Varibilele globale sunt variabilele programului principal.Ele sunt rezervate intr-o zona
speciala de date, numita segment de date.
Variabilele locale sunt variabile declarate in interiorul subprogramelor.Aceste variabile sunt
memorate in segmentul de stiva dupa variabilele generate de parametri.Este sarcina programatorului
sa asigure initializarea lor cu valorile dorite.La iesirea din subprogram continutul variabilelor locale
se pierde.
Un termen des folosit in practica limbajelor de programare este acela de vizibilitate.A
preciza vizibilitatea unei variabile inseamna a spune care sunt blocurile de unde se poate adresa(ca
sa-i atribuim o valoare de exemplu).
Variabilele globale sunt vizibile la nivelul programului principal si la nivelul
subprogramelor.
Variabilele locale sunt vizibile doar la nivelul subprogramului in care au fost declarate si la
nivelul subprogramelor definite in acesta..
Atentie! Exista situatii in care o variabila globala nu poate fi adresata din cadrul
subprogramului, adica atunci cand acesta contine declaratia unei alte variabile, cu acelasi nume.In
acest caz, prin nume, se adreseaza variabila locala.Regula este urmatoarea: in cazul in care doua
variabile au acelasi nume, dar vizibilitati diferite, se adreseaza intotdeauna variabila cu vizibilitatea
mai redusa.Evident, in cazul existentei a doua variabile cu aceeasi vizibilitate si acelasi nume,
compilatorul va da eroare de sintaxa.

46/67

7.2 Proiectarea modular a rezolvrii unei probleme

Procedurile i funciile nestandard trebuie obligatoriu declarate nainte de a fi apelate. In cazul
general, un program Pascal e format dintr-un program principal i dintr-un numr oarecare de
proceduri i funcii apelabile din programul principal sau unele din altele.
Domeniul de vizibilitate al identificatorilor (elemente locale i globale)
Declararea procedurilor n cadrul altor proceduri, fiecare din acestea cu propriile declaraii
i definiii ridic o problem deosebit: domeniul de vizibilitate al identificatorilor.
Prin domeniul de vizibilitate (de valabilitate) nelegem zona de program n care este
cunoscut declaraia sau definiia unui identificator.
Cnd fluxul de control intr ntr-un bloc, toate entitile declarate n blocul respectiv
sunt alocate pe stiva de execuie; la prsirea unui bloc zona de pe stiv alocat blocului
este eliberat astfel nct valorile aflate acolo nu mai pot fi referite.
Subprogramele pot fi recursive, adic se pot apela ele nsele, fie direct, fie indirect
printr-un lan de apeluri. Fiecare apelare a unui subprogram determin alocarea de spaiu
pe stiv pentru entitile sale locale care sunt astfel distincte de entitile corespunztoare
alocate n timpul altor apeluri ale aceleiai proceduri. Acest spaiu este eliberat la
terminarea apelrii respective.
Concluzie: domeniul de vizibilitate al unui identificator este tot blocul n care acesta a fost
definit, inclusiv blocurile subprogramelor decarate n bloc, cu excepia celor care
redefinesc identificatorul.
Dezvoltarea ascendent i dezvoltarea descendent a programelor
In Pascal exist dou posibiliti de dezvoltare a programelor:
a)

ascendent;

b)

descendent.

a)In programarea ascendent subprogramele se declar n seciunea de declaraii a programului.

Regul general: referirea identificatorilor numai dup declararea lor. Blocurile sunt n acest caz
independente. Apeluri posibile:
-

din programul principal se poate apela orice subprogram, n orice ordine;

dip subprogramul_i se pot apela subprogramele anterioare, n orice ordine;

b)In programarea descendent subprogramele se declar imbricate unul n cellalt.

Apeluri posibile:
-

din programul principal se poate apela subprogramul_1;

din subprogramul_i se poate apela subprogramul_i+1;

In practic programarea ascendent i cea descendent sunt combinate.

47/67

8. Recursivitate
8.1 Prezentare general
Un program este recursiv atunci cnd se autoapeleaz. Pentru ca autoapelul sa nu aib loc la
infinit un program recursiv trebuie s conin o condiie de oprire (de sfrit).

8.2 Funcii i proceduri recursive

Exemple de funcii i proceduri recursive:
procedure P( x: integer);
begin
If x< >0 then
if x mod 2=0 then begin
write (x) ; P (x div 2 ) end
else begin
P (x-1) ; write (x) end
end;

procedure f(i, k: integer) ;

begin
if k<=4 then begin
write (i*k) ;
f (i-1 , k+1)
end;
end;

function f (a, b:integer):byte;

begin
if b<1 then f : = -1;
else
if a mod b =0 then
f:=1+f(a div b,b);
else f:= 0;
end;

procedure f (n:longint);
begin
write(n mod 10);
if n<>0 then begin
f(n div 100); write(n mod 10);
end
end;
48/67

Mai jos este verificarea procedurii anterioare :

9. Metoda backtracking
9.1. Prezentare general
Metoda backtracking este o metod de rezolvare a problemelor prin ncercri. Soluia
problemelor const n determinarea unor valori ce ndeplnesc anumite condiii.
Aceast metod ncearc la fiecare pas alegerea unei valori dintre cele posibile. Dac
valoarea ncercat ndeplinete condiiile problemei, atunci vom trece la pasul urmtor. Dac
valoarea nu ndeplinete condiiile, vom rmne la acelai pas i vom ncerca altceva ntr-o ordine
stabilit la nceputul rezolvrii problemei. Dac nu mai avem de unde alege valori, ne vom ntoarce
la pasul anterior.
Dac ncercnd s rezolvm problema ne vom ntoarce la pasul 0, va nsemna c am
determinat toate soluiile sau c problema nu are rezolvare.
De multe ori, n aplicaii apar probleme n care se cere gsirea unor soluii de forma
x=x1x2... xn unde xi A, i = 1,,n n care x1xn trebuie s ndeplineasc anumite condiii.
Am putea s generm toate combinaiile posibile de valori i apoi s le alegem doar pe cele
convenabile. Considernd mulimile A = {ai,1,ai,2,,ai,n(i)}, aceste combinaii s-ar putea construi
astfel: pentru fiecare valoare posibil fixat pentru componenta xi, vom alege toate valorile posibile
pentru componenta xi+1 i pentru fiecare astfel de valoare fixat pentru xi+1 vom alege toate valorile
posibile pentru componenta xi+2, etc.
Rezolvnd problema n acest mod, deci genernd tote elementele produsului cartezian i
verificnd abia apoi dac fiecare combinaie este o soluie, eficient este sczut.
49/67

Astfel, dac de exemplu ne propunem s generm toate cuvintele formate cu litere a,b,c, aa
nct fiecare liter s apar o singur dat, combinaiile posibile sunt n numr de 27, dintre care
convin doar 6.
Tehnica Backtracking propune generarea soluiei prin completarea vectorului x n ordine
x1x2... xn i are la baz un principiu de bun sim: dac se constat c avnd o combinaie parial de
form v1v2...v k-1 (unde vi,,vk-1 sunt valori deja fixate), dac alegem pentru xk o valoare vk i
combinaia rezultat nu ne permite s ajungem la o soluie, se renun la aceast valoare i se
ncearc o alta (dintre cele netestate n aceast etap). ntr-adevr, oricum am alega celelalte valori,
dac una nu corespunde nu putem avea o soluie.
Pentru exemplu ales anterior se observ c dac notm cuvntul cu x1x2x3, combinaia aax3
nu ne poate conduce la o soluie (literele trebuie s fie distincte) i deci nu are sens s mai ncercm
s stabilim valori pentru x3.
Algoritmul general al metodei Backtracking
Pentru evitarea generrii combinaiilor neconvenabile se procedeaz astfel:
Presupunem c s-au gsit valorile v1v2vk-1 pentru componentele x1x2... xk-1 (au rmas de
determinat valorile pentru xkxn). Ne ocupm n continuare de componenta xk. Paii urmai sunt:
1) Pentru nceput, pentru xk nu s-a testat nc nici o valoare.
2) Se verific dac exist valori netestate pentru xk .
a) n caz afirmativ, se trece la pasul 3.
b) Altfel, se revine la componenta anterioar, xk-1; se reia pasul 2 pentru k=k-1.
3) Se alege prima valoare v dintre cele netestate nc pentru xk.
4) Se verific dac acest combinaie parial v1v2vk-1v ne poate conduce la un rezultat (dac sunt
ndeplinite anumite condiii de continuare).
a) Dac valoarea aleas este bun se trece la pasul 5.
b) Altfel, se rmne pe aceeai poziie k i se reia cazul 2.
5) Se verific dac s-a obinut o soluie .
a) n caz afirmativ, se tiprete aceast soluie i se rmne la aceeai component xk, relunduse pasul 2.
b) Altfel se reia altgoritmul pentru urmtoarea component (se trece la pasul 1 pentru k=k+1).
Altgoritmul ncepe prin stabilirea unei valori pentru componenta x1(k=1) i se ncheie cnd
pentru aceasta am testat toate valorile posibile i conform pasului 2b) ar trebui s revenim la
componenta anterioar, care n aceast caz nu exist.
Rezumnd, metoda Backtracking se folosete n rezolvarea problemelor care ndeplinesc condiiile:
soluia poate fi pus sub forma unui vector S=x1x2xn, unde xi
mulimile Ai sunt finite i ordonate (pentru a lua n considerare toate valorile posibile).
nainte de a scrie programul care ne va obine soluiile, trebuie s stabilim unele detalii cu
privire la:
vectorul soluie cte componente are, ce menine fiecare component.
mulimea de valori posibile pentru fiecare component (sunt foarte importante limitele
acestei mulimi).
condiiile de continuare (condiiile ca o valoare x[k]s fie acceptat).
condiia ca ansamblul de valori generat s fie soluie.
Pe baza acestor date vom scrie apoi procedurile i funciile pe care le vom apela n
altgoritmul general al metodei, dat mai jos, care se poate aplica tuturor problemelor ce respect
condiiile menionate anterior. Aceste proceduri i funcii au o semnificaie comun, prezentnd ns
particulariti n funcie de fiecare problem n parte.
Astfel, se va nota cu x vectorul care conine soluia; x[k] = v va avea ca semnificaie faptul
c elementul al-v-lea din mulimea de valori ppsibile Ak a fost selectat pentru componenta xk. dac
mulimea Ak are m elemente, a1a2am,pentru uurin ne vom referii la indicii lor 1,2,,m. Deci
valorile posibile pentru o component vor fi 1,2,,m n aceast ordine.

50/67

Iniial, cnd pentru o component nu am testat nc nimic, aceasta va avea valoarea 0 (un
indice care nu exist). Aceast operaie se va realiza n procedura INIT care va avea ce parametru
poziia k.
Funcia SUCCESOR(k) verific dac ultima valoare aleas pentru componenta xk nu a atins
limita maxim admis (indicele de valoare maxim). ntruct elementele sunt testate n ordine, acest
lucru este echivalent cu a verifica dac mai avem valori netestate nc pentru aceast component.
Funcia VALIDARE(k) verific dac valoarea aleas pentru x[k] ndeplinete condiiile de
continuare, deci dac aceast combinaie parial v1v2vk poate s conduc la o soluie.
Funcia SOLUTIE(k) verific dac s-a ajuns la o soluie final.
Procedura TIPAR(k) tiprete o soluie.
ablonul metodei backtracking:
uses crt;
type stiva=array[1..100] of integer;
var st:stiva;
k,n:integer;
as,ev:boolean;
procedure init(k:integer;var st:stiva);
begin
...
end;
procedure succesor(k:integer;var st:stiva;var as:boolean);
begin
....
end;
procedure validare(k:integer;st:stiva;var ev:boolean);
begin
...
end;
function solutie(k:integer):boolean;
begin
...
end;
procedure tipar;
begin
...
end;
begin
...
{citirea datelor}
k:=1;
init(k,st);
while k>0 do
begin
repeat
succesor(k,st,as);
if as then
51/67

validare(k,st,ev);
until (not as) or (as and ev);
if as then
if solutie(k) then
tipar
else
begin
k:=k+1;
init(k,st);
end
else
k:=k-1;
end;
end.

9.2. Probleme de generare. Oportunitatea utilizrii metodei backtracking

Problemele care se rezolv prin metoda backtracking pot fi mprite n mai multe grupuri de
probleme cu rezolvri asemntoare, in funcie de modificrile pe care le vom face n algoritm.
Principalele grupuri de probleme sunt:
a) probleme n care vectorul soluie are lungime fix i fiecare element apare o singur dat n
soluie;
b) probleme n care vectorul soluie are lungime variabil i fiecare element poate s apar de mai
multe ori n soluie;
c) probleme n plan, atunci cnd spaiul n care ne deplasm este un tablou bidimensional.
Vom prezenta n cele ce urmeaz cteva probleme care pac parte din primul grup. Cele mai
cunoscute sunt:
generarea permutrilor, aranjamentelor, combinrilor
generarea submulimilor unei mulimi
generarea produsului cartezian
problema damelor pe tabla de ah
colorarea rilor de pe o hart astfel nct oricare dou ri vecine s aib culori diferite
problema labirintului
problema calului pe tabla de ah
problema plii unei sume de bani (bancomatul)
problema grafului hamiltonian (problema comis-voiajorului)
Toate problemele din acest grup au particularitatea c soluia se obine atunci cnd vectorul
soluie ajunge s conin un anumit numr de elemente.
Probleme:
Considernd c avem o tabl de ah cu n linii i n coloane, scriei programul care afiez
Modurile n care pot fi aezate n dame pe tabl astfel nct s nu existe dou dame care s se atace
reciproc (dou dame se atac n cazul n care sunt situate pe aceeai linie, coloan sau diagonal).
uses crt;
type stiva=array[1..100] of integer;
var st:stiva;
k,n,l:integer;
as,ev:boolean;
procedure init(k:integer;var st:stiva);
begin
52/67

st[k]:=0;
end;
procedure succesor(k:integer;var st:stiva;var as:boolean);
begin
if st[k]<n then begin
as:=true;
st[k]:=st[k]+1;
end
else as:=false;
end;
procedure validare(k:integer;st:stiva;var ev:boolean);
var i:integer;
begin
ev:=true;
for i:=1 to k-1 do
begin
if st[k]=st[i] then ev:=false;
if abs(k-i)=abs(st[k]-st[i]) then ev :=false;
end;
end;
function solutie(k:integer):boolean;
begin
if k=n then solutie:=true else solutie:=false;
end;
procedure tipar;
var i:integer;
begin
for i:=1 to n do write(i,'-',st[i],' ; ');
writeln;
end;
begin
read(n);
k:=1;
init(k,st);
l:=0;
while k>0 do
begin
repeat
succesor(k,st,as);
if as then
validare(k,st,ev);
until (not as) or (as and ev);
if as then
if solutie(k) then
begin
tipar;
inc(l);
end
else
begin
53/67

k:=k+1;
init(k,st);
end
else
k:=k-1;
end;
if l=0 then write('Damele nu pot fi aranjate.')
else write('Damele pot fi aranjate in ',l,' moduri.');
end.

Pentru generarea numerelor cu n cifre formate cu elementele mulPentru generarea

numerelor
cu n cifre formate cu elementele muimii {0,2,8} se utilizeaz un algoritm backtrackingcare, pentru
n=2 generaz n ordine numerele 20, 22,28,80,82,88.
uses crt;
type stiva = array [1..100] of integer;
var a, st : stiva;
n, k : integer;
as, ev : boolean;
procedure init (k : integer; var st : stiva);
begin
st[k]:=0;
end;
procedure succesor (k : integer; var st : stiva; var as : boolean);
begin
if st[k]<3 then
begin
as:=true;
st[k]:=st[k]+1;
end
else as:=false;
end;
procedure validare (k : integer; st : stiva; var ev : boolean);
begin
ev:=true;
if (k=1) and (a[st[k]]=0) then ev:=false;
end;
function solutie (k : integer) : boolean;
begin
if k=n then solutie:=true
else solutie:=false;
end;
procedure tipar;
var i:integer;
begin
for i:=1 to n do write (a[st[i]]);
writeln;
end;
54/67

begin
k:=1;
read (n);
a[1]:=0;
a[2]:=2;
a[3]:=8;
init (k, st);
while k<>0 do begin
repeat
succesor (k, st, as);
if as then validare (k, st, ev);
until (not as) or (as and ev);
if as then if solutie (k) then tipar
else begin
k:=k+1;
init (k, st);
end
else k:=k-1;
end;
end.

10. Generarea elementelor combinatoriale

10.1

Permutari, aranjamente, combinari

Metoda Backtracking se aplic problemelor n care soluia poate fi reprezentat sub forma

unui vector x = (x1, x2, x3, xk, xn) S, unde S este mulimea soluiilor problemei i S = S1 x
S2 x x Sn, i Si sunt mulimi finite avnd s elemente si xi si , ()i = 1..n.
Pentru fiecare problem se dau relaii ntre componentele vectorului x, care sunt numite
condiii interne; soluiile posibile care satisfac condiiile interne se numesc soluii rezultat. Metoda
de generare a tuturor soluiilor posibile si apoi de determinare a soluiilor rezultat prin verificarea
ndeplinirii condiiilor interne necesit foarte mult timp.
Metoda backtracking evit aceast generare i este mai eficient. Elementele vectorului x,
primesc pe rnd valori n ordinea cresctoare a indicilor, x[k] va primi o valoare numai daca au fost
atribuite valori elementelor x1.. x[k-1]. La atribuirea valorii lui x[k] se verifica ndeplinirea unor
condiii de continuare referitoare la x1x[k-1]. Daca aceste condiii nu sunt ndeplinite, la pasul k,
acest lucru nseamn ca orice valori i-am atribui lui x[k+1], x[k+1], .. x[n] nu se va ajunge la o
soluie rezultat.
APLICAII REZOLVATE
Exemple:
Generarea permutrilor. Se citete un numr natural n. S se genereze toate permutrile
mulimii {1, 2, 3, ,n}.

55/67

Generarea permutrilor se va face innd cont c orice permutare va fi alctuit din elemente
distincte ale mulimii A. Din acest motiv, la generarea unei permutri, vom urmri ca numerele s
fie distincte.
Prezentm algoritmul corespunztor cazului n=3:

1
1

2
1

1
2
1

3
1

1
3
1

2
3
1

3
3
1

1
1
2

2
1
2

3
1
2

2
2

2
2
1

3
2
1

1
2

3
2

1
3
2

se ncarc n stiv pe nivelul 1 valoarea 1;

ncrcarea valorii 1 pe nivelul al 2-lea nu este posibil, ntruct aceast valoare se

gsete i pe nivelul 1 al stivei;

ncrcarea valorii 2 pe nivelul al 2-lea este posibil, deoarece aceast valoare nu mai este
ntlnit;

valoarea 1 din nivelul al 3-lea se regsete pe nivelul 1;

valoarea 2 din nivelul al 3-lea se regsete pe nivelul al 2-lea;

valoarea 3 pe nivelul al 3-lea nu e ntlnit pe nivelurile anterioare; ntruct nivelul 3

este completat corect. Tiprim: 1 2 3

Algoritmul continu pn cnd stiva devine vid.

Metoda backtracking construiete un vector soluie n mod progresiv ncepnd cu
prima component a vectorului i mergnd spre ultima cu eventuale reveniri asupra
atribuirilor anterioare.
Metoda se aplica astfel :
1) se alege prima valoare sin S1 si I se atribuie lui x1 ;
2) se presupun generate elementele x1x[k-1], cu valori din S1..S[k-1]; pentru generarea lui
x[k] se alege primul element din S[k] disponibil si pentru valoarea aleasa se testeaz
ndeplinirea condiiilor de continuare.
Pot aprea urmtoarele situaii :

56/67

a) x[k] ndeplinete condiiile de continuare. Daca s-a ajuns la soluia final (k = n)

atunci se afieaz soluia obinut. Daca nu s-a ajuns la soluia final se trece la
generarea elementului urmtor x [k-1];
b) x[k] nu ndeplinete condiiile de continuare. Se ncearc urmtoarea valoare
disponibila din S[k]. Daca nu se gsete nici o valoare n S[k] care s ndeplineasc
condiiile de continuare, se revine la elementul x[k-1] i se reia algoritmul pentru o
nou valoare a acestuia. Algoritmul se ncheie cnd au fost luate in considerare toate
elementele lui S1.
Problemele rezolvate prin aceast metod necesit timp mare de execuie, de aceea
este indicat sa se foloseasc metoda numai daca nu avem alt algoritm de rezolvare.

Dac mulimile S1,S2,Sn au acelai numr k de elemente, timpul necesar de execuie al

algoritmului este k la n. Dac mulimile S1, S2.. Sn nu au acelai numr de elemente, atunci se
noteaz cu m minimul cardinalelor mulimilor S1Sn si cu M, maximul. Timpul de execuie
este situat n intervalul [m la n .. M la n]. Metoda backtracking are complexitatea exponenial, in
cele mai multe cazuri fiind ineficient. Ea insa nu poate fi nlocuit cu alte variante de rezolvare mai
rapide n situaia n care se cere determinarea tuturor soluiilor unei probleme.
Generarea aranjamentelor. Se citesc n i p. S se genereze toate aranjamentele de n luate
cte p.
Din analiza problemei rezult urmtoarele:
stiva are nlimea p;
fiecare nivel ia valori ntre 1 i n;
elementele plasate pe diverse niveluri trebuie s fie distincte.
Algoritmul este asemntor cu cel de la permutri, cu deosebirea c aici stipa are nlimea
p.
Generarea combinrilor. Se citesc n i p numere naturale, np. Se cere s se genereze toate
submulimile cu p elemente ale mulimii {1, 2, 3, , n}.
Pentru rezolvarea problemei trebuie inut cont de urmtoarele:
stiva are nlimea p;
elementele aflate pe niveluri diferite ale stivei trebuie s fie distincte;
pentru a evita repetiia elementele se aeaz n ordine cresctoare: pe nivelul k se va afla o
valoare mai mare dect pe nivelul k-1 i mai mic sau egal cu n-p+k.

57/67

58/67

PERMUTARI
program permutari;

ARANJAMENTE
program aranjamente;

COMBINARI
program combinari;

type stiva=array[1..20] ofinteger;

type stiva=array[1..20] ofinteger;

type stiva=array[1..20] ofinteger;

var st:stiva;

var st:stiva;

var st:stiva;

n,k:integer;

n,k:integer;

n,k:integer;

as,ev:boolean;

as,ev:boolean;

as,ev:boolean;

procedure init(k:integer;var st:stiva);

procedure init (k:integer;var st:stiva);

procedure init(k:integer;var st:stiva);

begin

begin

begin

st[k]:=0;

st[k]:=0;

st[k]:=0;

end;

end;

end;

procedure succesor (var as: boolean; var

procedure succesor (var as: boolean; var st: stiva;

procedure succesor (var as: boolean; var st: stiva;

st: stiva; k:integer);

k:integer);

k:integer);

begin

begin

begin

if st[k]<n then

if st[k]<n then

if st[k]<n-p+k then

begin

begin

begin

st[k]:=st[k]+1;

st[k]:=st[k]+1;

st[k]:=st[k]+1;

as:=true;

as:=true;

as:=true;

end

end

end

else as:=false

else as:=false

else as:=false

end;

end;

end;

procedure valid (var ev:boolean;

procedure valid (var ev:boolean; st:stiva; k:integer);

procedure valid (var ev:boolean; st:stiva;

st:stiva; k:integer);

var i:integer;

k:integer);

var i:integer;

begin

var i:integer;

begin

ev:=true;

begin

ev:=true;

for i:=1 to k-1 do if st[k]=st[i]then ev:=false

ev:=true;

for i:=1 to k-1

end;

for i:=1 to k-1 do ifst[k]=st[i] then ev:=false

do ifst[k]=st[i] then ev:=false

function solutie (k:integer): boolean;

if k>1 then st[k]<st[k-1]then ev:=false

end;

begin

end;

function solutie(k:integer): boolean;

solutie:=(k=p)

function solutie(k:integer): boolean;

begin

end;

begin

solutie:=(k=n)

procedure tipar;

solutie:=(k=p)

end;

var i:integer;

end;

procedure tipar;

begin

procedure tipar;

var i:integer;

for i:=1 to p do write (st[i]);

var i:integer;

begin

writeln;

begin

for i:=1 to n do write (st[i]);

end;

for i:=1 to p do write (st[i]);

writeln;

Begin

writeln;

end;

write (n=); readln(n);write(p=);readln(p);

end;

Begin

k:=1; init (k,st);

Begin

write (n=); readln(n);

while (k>0) do

write (n=); readln(n);write(p=); readln(p);

k:=1; init (k,st);

begin

while (k>0) do

k:=1; init (k,st);

repeat

begin

while (k>0) do

succesor (as, st, k);

repeat
succesor (as, st, k);
if as then valid (ev,st,k);
until (not as) or (asand ev);

begin

if as then valid (ev,st,k);

repeat

until (not as) or (as andev);

succesor (as, st, k);

if as then

if as then valid (ev,st,k);

if solutie (k) then tipar

until (not as) or (as andev);

if as then

else begin

if as then

if solutie (k) then tipar

k:=k+1;

if solutie (k) then tipar

else begin

init (k,st)

else begin

k:=k+1;

end

k:=k+1;

init (k,st)

else k:=k-1

init (k,st)

end

end

end

else k:=k-1

readln;

else k:=k-1

end

End.

end

readln;

readln;

End.

End.

59/67

10.2

Produsul cartezian .Submultimi.

Se dau mulimile de mai jos i se cere produsul cartezian al lor.

A1 = {1, 2, 3, , k1}
A2 = {1, 2, 3, , k2}

An = {1, 2, 3, , kn}
Exemplu:

A1 = {1, 2}
A2 = {1, 2, 3}
A3 = {1, 2, 3}

A1 A2 A3 = {(1, 1, 1), (1, 1, 2), (1, 1, 3), (1, 2, 1), (1, 2, 2), (1, 2, 3), (1, 3, 1), (1, 3, 2), (1,
3, 3), (2, 1, 1), (2, 1, 2), (2, 1, 3), (2, 2, 1), (2, 2, 2), (2, 2, 3), (2, 3, 1), (2, 3, 2), (2, 3, 3)}.
Pentru rezolvare, se folosesc stiva ST i un vector A ce reine numerele k1, k2, kn. Utilizm
metoda backtracking, uor modificat din urmtoarele motive:
a) Orice element aflat la nivelul k al stivei este valid, motiv pentru care procedura valid nu
face altceva dect s atribuie variabilei ev valoarea TRUE.
b) 9
Modul de concepere a algoritmului rezult din cele ce urmeaz:
1

Observaii:

Algoritmul prezentat aici este de tip backtracking? ntrebarea are sens pentru c este
absent mecanismul de ntoarcere. Vom admite c i aceasta este backtracking, dar
degenerat.

Generarea submulimilor unei mulimi

60/67

Generarea submulimilor unei mulimi A cu n elemente se poate face cu ajutorul algoritmului de

generare a combinrilor, apelndu-l repetat cu valorile 1, 2, ..., n pentru a genera submulimile cu
un element, apoi cele cu dou elemente, apoi cu 3 elemente etc.
Aceast modalitate de rezolvare este i mai complicat i mai puin eficient dect urmtoarea, care
se bazeaz pe generarea produsului cartezian {0,1}n. Aceast a doua metod este eficient deoarece
genereaz 2n soluii, adic exact attea cte submulimi are o mulime cu n elemente.
Aadar, generm toate combinaiile de lungime n cu valorile 0 i 1. Pentru fiecare combinaie
parcurgem soluia X i afim elementele din mulimea A crora le corespund valori 1 n X. Astfel,
pentru combinaia 001011 vom afia elementele de pe poziiile 3, 5 i 6 din mulimea iniial.
Generarea partiiilor unei mulimi
Generm partiiilor unei mulimi presupune mprirea mulimii n mulimi nevide i disjuncte care
reunite s dea ntreaga mulime. Putem, ca i n cazurile anterioare, s considerm mulimea {1,2,
,n}. Construim un vector soluie n care pentru fiecare element vom trece submulimea n care l
vom include. Aceast submulime mai este numit i clas.
Algoritmul genereaz pe rnd toate modalitile de a mpri elementele mulimii {1,2,,n}
folosind mai nti o singur clas, apoi dou, .a.m.d. pn la n clase.

11.Grafuri
11.1Grafuri neorientate
Graf neorientat, adiacenta, incidenta, grad
Definitie:
Se numeste graf neorientat, o pereche ordonata de multimi (X,U), unde:
-X este o multime finita, nevida, de elemente numite varfuri sau noduri;
-U este o multime de perechi neordonate de cate doua elemente din X, numite muchii
sau arce.
Asadar un graf neorientat poate fi reprezentat sub forma unei figuri geometrice alcatuita din
puncte (muchii, arce) si linii drepte sau curbe care unesc aceste puncte (muchii, arce). Respectand o
anumita traditie pe care o gasim in literatura de specialitate, vom folosi:
- pentru grafuri neorientate termenii de varf si muchie
- pentru grafuri orientate termenii de nod si arc
Pentru o muchie uk=(a,b), vom spune ca:
- varfurile a si b sunt adiacente si se numesc extremitatile muchiei uk;
- muchia uk si varful a sunt incidente in graf. La fel, muchia uk si varful b;
- muchia (a,b) este totuna cu (b,a) (nu exista o orientare a muchiei).
Definitie:
Gradul unui varf x, notat d(x) reprezinta numarul muchiilor care trec prin nodul x (incidente
cu nodul x)
Un varf care are gradul 0 se numeste varf izolat
Un varf care are gradul 1 se numeste varf terminal
61/67

Teorema:
Intr-un graf G=(X,U) cu n varfuri si m muchii, suma gradelor tuturor varfurilor este egala
cu 2*numarul muchiilor.
n

d (x ) d (x ) d (x
i 1

) ... d ( x n ) 2 * m

Lan
Definitie :
Se numeste lant in graful G, o succesiune de varfuri L=(z1, z 2,...,zk), unde z1, z 2,...,zk X, cu
proprietatea ca oricare doua varfuri consecutive sunt adiacente, adica exista muchiile [Z 1, Z 2], [Z2,
Z 3],..., [Zk-1, Z k] U.
Varfurile zi si z k se numesc extremitatile lantului, iar numarul de muchii care intra in
componenta lantului reprezinta lungimea lantului.
Un lant poate fi interpretat ca un traseu care pleaca din varful z1 si ajunge in varful zk,
trecand prin mai multe varfuri si parcurgand mai multe muchii.
Daca varfurile z1, z2, ..., zk sunt distincte doua cate doua, lantul se numeste elementar. In caz
contrar, lantul este ne-elementar.
Ciclu
Se numeste ciclu intr-un graf, un lant L=(z1, z2, ... , zk) cu proprietatea ca z1=zk si muchiile
[z1, z2], [z2, z3], ... , [zk-1, zk] sunt distincte doua cate doua.
Daca intr-un ciclu, toate varfurile cu exceptia primului si ultimului sunt distincte doua cate
doua, atunci ciclul se numeste elementar. In caz contrar, el este ne-elementar.
Graf parial
Un graf parial al grafului G=(X,U) este un graf G1=(X,V) astfel nct VU, adic G1 are
aceeai mulime de vrfuri ca G iar mulimea de muchii V este chiar U sau o submulime a acesteia.
Cu alte cuvinte, un graf parial al unui graf se obine pstrnd aceeai mulime de vrfuri i
eliminnd o parte din muchii.
Subgraf
Un subgraf al unui graf G=(X,U) este un graf H=(Y,V) astfel nct Y X iar V conine
toate muchiile din U care au ambele extremiti n Y. Vom spune c subgraful H este indus sau
generat de mulimea de vrfuri Y.
Graf conex
Un graf G se numete conex dac pentru orice dou vrfuri x i y diferite ale sale exist un
lan care le leag.
Component conex
Se numete component conex a grafului G=(X, U) un subgraf C=(X1, U1), conex, a lui G
care are proprietatea c nu exist nici un lan n G care s lege un vrf din X1 cu un vrf din X-X1.
Ciclu hamiltonian
Se numete ciclu hamiltonian intr-un graf neorientat un ciclu elementar care trece prin toate
nodurile grafului.
Un graf neorientat este hamiltonian dac el conine un ciclu hamiltonian.
62/67

Ciclu eulerian
Se numete ciclu eulerian un ciclu care contine toate muchiile unui graf (o singur dat
fiecare).
Un graf neorientat este eulerian dac el conine un ciclu eulerian.
Metode de reprezentare a grafurilor orientate:
1)Matricea de adiacen
-o matrice de n linii si n coloane,unde n= nr nodurilor grafului
a[i,j]=1,dac (i,j) U
=0,in caz contrar
Cu ajutorul acestei matrici putem extrage informaii cum ar fi:
-gradele nodurilor ;
-putem determina nodurile izolate,terminale,adiacente;
-putem determina nodurile de grad maxim sau minim;
-cate muchii are graful.
Exemplu:

Pentru graful din figura matricea de adiacenta este:

01100
10100
11000
00001
00010
2)Prin liste de vecini
123
213
312
45
54

3)Prin lista muchiilor

12
13
23
45

11.2Grafuri orientate
Definitie:
Numim graf orientat, o pereche ordonat de mulimi G=(X,U), unde:
X este o mulime finit i nevid numit mulimea nodurilor (vrfurilor);
U este o mulime format din perechi ordonate de elemente ale lui X, numit mulimea
arcelor (muchiilor)
Observaii:
Prin noiunea de perechi ordonate nu trebuie s nelegem c o muchie este mai mare dect
alta, ci pur i simplu c facem deosebire ntre o muchie de forma (x,z) i o alta de forma (y,x). Cu
alte cuvinte muchiile sunt difereniate prin ordinea de scriere a simbolurilor.
Arcul (x,y) nu este tot una cu arcul (y,x).
63/67

Un arc va fi de forma u= (x,y), unde x se numete extremitate iniial, iar y se numete

extremitate final a arcului. Cu alte cuvinte, arcul iese din nodul x i intr n nodul y.
La fel ca la grafurile neorientate, vom spune c nodurile x i y sunt adiacente, iar arcul u i
nodul x sunt incidente (la fel arcul x i nodul y).
Graful unui vrf. Mulimile i
Gradul exterior al unui vrf x, notat d*(x), reprezint numrul arcelor care ies din nodul x,
adic numrul arcelor de forma (x,z) U.
Analog, se definete gradul interior al unui vrf x, notat d-(x), ca fiind numrul arcelor care
intr n nodul x (de forma (y,x) U).
Drum, circuit
Se numete drum n graful G, un ir de noduri D={z1, z2, z3, , zk}, unde z1, z2, z3, ,
zk aparin lui x, cu proprietatea c oricare dou noduri consecutive sunt adiacente, adic exist
arcele [z1, z2], [z2, z3], , [zk-1,zk] aparin lui U.
Practic, un drum poate fi privit ca un traseu n care toate arcele au aceeai orientare, dat de
sensul de deplasare de la z1 la zk.
Dac nodurile z1, z2, z3, , zk sunt distincte dou cte dou, drumul se numete elementar.
n caz contrar, drumul este ne-elementar.
Lungimea unui drum = numrul de muchii din care este format.
Se numete circuit ntr-un graf, un lan L={z1, z2, z3, , zk} cu proprietatea c z1=zk i
arcele [z1, z2], [z2, z3], , [zk-1,zk] sunt distincte dou cte dou.
Graf parial i subgraf
Definiie: Fie graful G=(X,U). Un graf parial al lui G, este un graf G1=(X,V), cu V U.
Altfel spus , un graf parial G1 al lui G, este chiar G, sau se obine din G pstrnd toate vrfurile i
suprimnd nite muchii.
Definiie: Fie graful G=(X,U). Un subgraf al lui G, este un graf G 1=(Y,T), unde Y X i T
U, iar T va conine numai muchiile care au ambele extremiti n Y. Altfel spus, un graf parial G 1
al lui G, se obine din G eliminnd nite vrfuri i pstrnd doar acele muchii care au ambele
extremiti n mulimea vrfurilor rmase.
Conexitate in grafuri orientate
Graf conex: Definitie:
Un graf G este conex, daca oricare ar fi doua varfuri ale sale, exista un lant care le leaga.
Un graf G=(X,U) se numeste tare conex daca pentru oricare doua noduri distincte exista x,y
apartinand lui X, exista in G un drum de la x la y si un drum de la y la x.
Se numeste componenta tare conexa a unui graf orientat G=(X,U) un subgraf tare conex
G1=(X1,U1) al sau, maximal in raport cu acel propus.
Grafuri hamiltoniene si euleriene
Definitie:
Se numeste ciclu hamiltonian intr-un graf, un ciclu elementar care contine toate varfurile
grafului.
Se numeste graf hamiltonian, un graf care contine un ciclu hamiltonian.
Definitie:
Se numeste lant hamiltonian, intr-un graf, un lant elementar care contine toate varfurile
grafului.
Teorema:
64/67

Daca intr-un graf G=(X,U) cu n>=3 varfuri, gradul fiecarui varf x verifica conditia
d(x)>=n/2,atunci graful este hamiltonian.
Definitie:
Se numeste ciclu eulerian, intr-un graf, un ciclu care contine toate muchiile grafului.
Se numeste graf eulerian, un graf care contine un ciclu eulerian.
Teorema:
Un graf fara varfuri izolate este eulerian, daca si numai daca este conex, si gradele tuturor
varfurilor sunt numere pare.
Metode de reprezentare a grafurilor ne-orientate:
Matricea de adiacen
Are aceeai semnificaie ca n cazul grafurilor neorientate, fiecare element a[i,j], cu i,j
{ 1,2,..,n} este: 1 dac exis arcul (i,j), respectiv 0 n cay contrar.
Listele vecinilor
Pentru fiecare nod x se construiesc dou liste ale vecinilor si:
- L+(x) lista vecinilor succesori; conine nodurile ce sunt extremiti finale ale arcelor care
ies din nodul x.
- L- (x) lista vecinilor predecesori; conine nodurile ce sunt extremiti iniiale ale arcelor
care intr n nodul x.

Exemplu:
n graful din figura 6 de mai sus, pentru nodul x=4 avem:
arcele care ies din nodul 4 sunt (4,2) i (4,3). n consecin, lista vecinilor succesori L*(4)
conine nodurile 2 i 3;
n nodul 4 intr un singur arc, i anume (3,4), motiv pentru care lista vecinilor predecesori L(4) conine doar nodul 3.
Prezentm n continuare aceste liste ale vecinilor pentru graful din figura 6.
Nodul x
L*(x)
L-(x)
1
2
Vida
2
Vida
1,3,4
3
2,4
4
4
2,3
3

11.3Arbori
Definitie: Un graf conex si fara cicluri se numeste arbore.
Teorema:
Fie un graf G=(x, u). urmatoarele afirmatii sunt echivalente:
65/67

- G este arbore.
- G este un graf conex, minimal in raport cu aceasta proprietate (eliminand o muchie
oarecare, se obtine un graf ne-conex).
- G este un graf fara cicluri, maximal in raport cu aceasta proprietate (adaugand o
muchie oarecare, se obtine un graf care are cel putin un ciclu).
In cazul arborilor, in loc de varfuri si muchii, se folosesc cu precadere termenii
sinonimi noduri respectiv arce.
Rdcin = Nod special care genereaz aezarea unui arbore pe niveluri; Aceast operaie
se efectueaz n funcie de lungimea lanurilor prin care celelalte noduri sunt legate de rdcin.
Descendent = ntr-un arbore cu rdcin nodul y este descendentul nodului x dac este
situat pe un nivel mai mare dect nivelul lui x i exist un lan care le unete i nu trece prin
rdcin.
Descendent direct / fiu = ntr-un arbore cu rdcin nodul y este fiul (descendentul direct)
nodului x dac este situat pe nivelul imediat urmtor nivelului lui x i exist muchie ntre x i y.
Ascendent = ntr-un arbore cu rdcin nodul x este ascendentul nodului y dac este situat
pe un nivel mai mic dect nivelul lui y i exist un lan care le unete i nu trece prin rdcin.
Ascendent direct / printe = ntr-un arbore cu rdcin nodul x este printele (ascendentul
direct) nodului y dac este situat pe nivelul imediat superior (cu numr de ordine mai mic) nivelului
lui y i exist muchie ntre x i y.
Frai = ntr-un arbore cu rdcin nodul x este fratele nodului y dac au acelai printe.
Frunz = ntr-un arbore cu rdcin nodul x este frunz dac nu are nici un descendent
direct
Teorema: Un arbore cu n varfuri are n-1 muchii.
Proprietatile care caracterizeaza un arbore:
- exista un nod in care nu intra nici un arc, numit radacina arborelui.
- cu exceptia radacinii, fiecare nod are proprietatea ca in el intra un singur arc.
Aceasta leaga nodul respectiv de un alt nod numit predecesor sau parinte.
- dintr-un nod pot iesi unul sau mai multe arce. Fiecare astfel de arc, leaga nodul
respectiv de un alt nod numit succesor sau fiu al nodului, iar arcele care ies din acelasi nod se
numesc frati.
- nodurile sunt organizate pe nivele, primul nivel fiind ocupat de nodurile-radacina.
Nodurile de pe ultimul nivel se caracterizeaza prin faptul ca din ele nu mai iese nici un arc, si se
numesc noduri terminale sau frunze.
- nodurile pot contine o asa-numita informatie utila, care poate fi de orice tip. De
obicei aceste informatii se mai numesc si chei ale arborelui.
Arbori binari
Definitie: Un arbore cu proprietatea ca fiecare nod, cu exceptia frunzelor are cel mult doi
descendenti (succesori) se numeste arbore binar.Succesorii se vor numi, in cazul in care exista, fiul
stang si fiul drept.
Metode de reprezentare a arborilor :
1.
Metode specifice grafurilor:
-matricea de adiacenta
-liste de adiacente
2.

Metode specifice arborilor:

66/67

-prin legaturi de tip TATA. Arborele se reprezinta sub forma unui vector t cu n componente (n
reprezinta numarul de noduri). Daca t[i]=k atunci nodul I este descendent al nodului k. Daca nodul I
este varf atunci t[i]=0.
Fie arborele din figura:

Nodul 1 este radacina. Atunci vectorul de tip tata este: t=0 1 1 1 3 3 3 4 7 7.

67/67