Documente Academic
Documente Profesional
Documente Cultură
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
11.Grafuri...........................................................................................................................................60
11.1Grafuri neorientate...................................................................................................................60
11.2Grafuri orientate......................................................................................................................62
11.3Arbori......................................................................................................................................65
2/67
1. ALGORITMI
Numerice
Alfanumerice
Logice
2. Operatii :
-
aritmetice
relationale (<,>,<>,<=,>=)
3/67
3. Expresii
-
Aritmetice
relationale
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.
X
False
True
not X
True
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
Memorie | Ecran
a2
b3
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
altfel 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)
b)
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.
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)
else c:=-a/b;
else c:=-a/b;
else c:=-a/b;
else c:=-a/b;
19)
20)
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.
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.
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.
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.
17/67
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.
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
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.
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.
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.
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 );
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;
26/67
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.
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
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
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
end;
writeln('Maximul elementelor din vector este ',max,' iar minimul este ',min,'.');
end.
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
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.
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.
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.
46/67
ascendent;
b)
descendent.
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).
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
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.
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.
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.
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
ncrcarea valorii 2 pe nivelul al 2-lea este posibil, deoarece aceast valoare nu mai este
ntlnit;
56/67
57/67
58/67
PERMUTARI
program permutari;
ARANJAMENTE
program aranjamente;
COMBINARI
program combinari;
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;
begin
begin
begin
st[k]:=0;
st[k]:=0;
st[k]:=0;
end;
end;
end;
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;
st:stiva; k:integer);
var i:integer;
k:integer);
var i:integer;
begin
var i:integer;
begin
ev:=true;
begin
ev:=true;
ev:=true;
end;
end;
begin
end;
solutie:=(k=p)
begin
end;
begin
solutie:=(k=n)
procedure tipar;
solutie:=(k=p)
end;
var i:integer;
end;
procedure tipar;
begin
procedure tipar;
var i:integer;
var i:integer;
begin
writeln;
begin
end;
writeln;
Begin
writeln;
end;
end;
Begin
Begin
while (k>0) do
begin
while (k>0) do
repeat
begin
while (k>0) do
repeat
succesor (as, st, k);
if as then valid (ev,st,k);
until (not as) or (asand ev);
begin
repeat
if as then
if as then
else begin
if as then
k:=k+1;
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
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.
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:
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
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.
-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:
67/67