Sunteți pe pagina 1din 68

MINISTERUL EDUCAȚIEI, CULTURII ȘI CERCETĂRII AL

REPUBLICII MOLDOVA UNIVERSITATEA DE STAT DIN TIRASPOL


CATEDRA DE INFORMATICĂ ȘI TEHNOLOGII INFORMAȚIONALE

LUCRU INDIVIDUAL

TEORIA RECURSIILOR

A elaborat: Andrian Dascal, masterand anul 2


A verificat: Liubomir Chiriac, dr. prof. univ

Chișinău, 2017
CUPRINS:

1. Factorialul unui număr.........................................................................................................................................2


2. Suma numerelor pare............................................................................................................................................4
3. Suma numerelor impare.......................................................................................................................................6
4. Șirul Fibonacci........................................................................................................................................................8
5. Șirul Fibonacci modificat...................................................................................................................................10
6. Suma numerelor 4k-3...........................................................................................................................12
7. Progresia -1/8, 2an-1..............................................................................................................................14
8. Suma șirului 1, 5n-4..............................................................................................................................16
9. Algoritmul lui Euclid pentru 2 numere...............................................................................................18
10. Algoritmul lui Euclid pentru 3 numere.............................................................................................20
11. Recursivitate indirectă (fx_gx)...........................................................................................................22
12. Recursivitate indirectă (ax_bx)..........................................................................................................23
13. Recursivitate indirectă (ax_bx_cx).................................................................................................... 24
14. Recursivitate indirectă (an_bn).........................................................................................................26
15. Recursivitate indirectă (an_bn_cn)...................................................................................................27
16. Ackerman............................................................................................................................................ 29
17. Hermite................................................................................................................................................30
18. Cebâșev................................................................................................................................................31
19 Manna Pnueli.......................................................................................................................................32
20. Turnurile Hanoi.................................................................................................................................. 33
21. Compoziția a două funcții.................................................................................................................. 34
22. Algoritmul lui Euclid pentru n numere............................................................................................. 36
23. Generarea părților unui număr.........................................................................................................38
24. Curba Hilbert.....................................................................................................................................40
25. Curba Sierpinski.................................................................................................................................42
26. Covorul Sierpinski..............................................................................................................................44
27. Curba lui Koch pentru un triunghi echilateral................................................................................ 46
28. Arborele............................................................................................................................................... 48
29. Generarea permutărilor.....................................................................................................................50
30. Generarea aranjamentelor.................................................................................................................52
31. Generarea combinărilor.....................................................................................................................54
32. Problema celor n dame.......................................................................................................................56
33. Problema colorării hărţilor................................................................................................................58
34. Problema imaginii (FILL)..................................................................................................................63
35. Problema labirintului.........................................................................................................................65

1
Problema 1
Factorial
Să se determine factorialul unui numar. Să se alcătuiască variant nerecursivă şi recursivă ȋn Pascal şi
C care va afisa rezultatul pentru factorial.

Program Pascal nerecursiv Program Pascal recursiv


uses crt; uses crt;
var factorial: longint; function fact(n: integer): longint;
n, i: byte; begin
begin if (n = 0) then fact := 1
write('n = '); readln(n); else
factorial := 1; fact := n * fact(n - 1);
for i:=2 to n do end;
factorial := factorial * i; var n: integer;
writeln('n! = ', factorial); begin
readln; for n := 0 to 16 do
end. writeln(n, '! = ', fact(n));
end.

Program C nerecursiv Program C recursiv


#include<stdio.h> #include<stdio.h>
long int factorial (int n) long int factorial (int n)
{ {
long int f=1; if (n==1) return 1;
for (int i=1; i<=n;i++) else return n*factorial(n-1);
f=f*i; }
return f; void main()
} {
void main() int n;
{ printf("Introduceti n= ");
int n; scanf("%d", &n);
printf("Introduceti n= "); if(!n)
scanf("%d", &n); printf("0!=1\n");
if(!n) else
printf("0!=1\n"); printf("%d!=%ld\n",n,factorial(n));
else getchar();
printf("%d!=%ld\n",n,factorial(n)); int var;
getchar(); scanf("%d", var);
int var; }
scanf("%d", var);
}

2
Rezultat program Pascal nerecursiv Rezultat program Pascal recursiv

Rezultat program C nerecursiv Rezultat program C recursiv

1, n  0,1
Fact(n)= 
Fact ( n  1) * n, n  2

3
Problema 2
Suma numerelor pare.
Să se elaboreze un program care calculează suma numerelor pare pozitive până la n. În pascal și c+
+, metoda recursivă și nerecursivă.

Program Pascal nerecursiv Program Pascal recursiv


program SumaParNeRecursiv; program SumaParRecursiv;
uses crt; uses crt;
var n, i, s :integer; var n:integer;
begin function suma_p(n: integer): longint;
clrscr; begin
writeln('Calcularea sumei numerelor if (n=0) then
pare.'); suma_p:=0
writeln('Rezolvare prin metoda else
nerecursiva.'); suma_p:=suma_p(n-1)+2*n;
write('Introdu n= '); end;
readln(n); begin
writeln('Calculare'); clrscr;
s:=-1; writeln('Calcularea sumei numerelor
for i:=0 to n do pare.');
if (i=0) then s:=0 else s:=s+2*i; writeln('Rezolvare prin metoda
writeln('Suma a primilor ',n,' recursiei.');
termeni pari = ',s:10); write('Introdu n= ');
end. readln(n);
writeln('Calculare');
writeln('Suma a primilor ',n,'
termeni pari = ',suma_p(n):10);
end.

Program C nerecursiv Program C recursiv


#include <iostream.h> #include <iostream.h>
#include <conio.h> #include <conio.h>
#include <iomanip.h> #include <iomanip.h>
unsigned long int suma_p(unsigned int unsigned long int suma_p(unsigned int
n) n)
{ {
unsigned long int i, s=-1; if(n==0)
for(i=0; i<=n;i++) return 0;
if(i==0) else
s=0; return suma_p(n-1)+2*n;
else
s+=2*i; }
return s; void main()
} {
void main() clrscr();
{ unsigned int n, i;
clrscr(); cout<<"Calcularea sumei numerelor
unsigned int n, i; pare.\n";
cout<<"Calcularea sumei numerelor cout<<"Rezolvare prin metoda

4
pare.\n"; recursiei.\n";
cout<<"Rezolvare prin metoda cout<<"Introdu n= ";cin>>n;
nerecursiva.\n"; for(i=1; i<=n;i++)
cout<<"Introdu n= ";cin>>n; cout<<setw(4)<<i<<". t=
for(i=1; i<=n;i++) "<<setw(4)<<2*i<<";
cout<<setw(4)<<i<<". t= S("<<setw(4)<<i<<")=
"<<setw(4)<<2*i<<"; "<<setw(10)<<suma_p(i)<<";"<<endl;
S("<<setw(4)<<i<<")= }
"<<setw(10)<<suma_p(i)<<";"<<endl;
}

Rezultat program Pascal nerecursiv Rezultat program Pascal recursiv


Calcularea sumei numerelor pare. Calcularea sumei numerelor pare.
Introdu n= 20 Introdu n= 20
Calculare Calculare
Suma a primilor 20 termeni pari = 420 Suma a primilor 20 termeni pari = 420

Rezultat program C nerecursiv Rezultat program C recursiv


Calcularea sumei numerelor pare. Calcularea sumei numerelor pare.
Introdu n= 20 Introdu n= 20
Calculare Calculare
Suma a primilor 20 termeni pari = 420 Suma a primilor 20 termeni pari = 420

0, ă =0
={

−1

+2∗ ă >0

5
Problema 3
Suma numerelor impare.
Să se elaboreze un program care calculează suma numerelor impare pozitive până la n. În pascal și
c++, metoda recursivă și nerecursivă.

Program Pascal nerecursiv Program Pascal recursiv


program SumaIparNeRecursiv; program SumaIparRecursiv;
uses crt; uses crt;
var n, i, s :integer; var n:integer;
begin function suma_i(n: integer): longint;
clrscr; begin
writeln('Calcularea sumei numerelor if (n=0) then
impare.'); suma_i:=0
writeln('Rezolvare prin metoda else
nerecursiva.'); suma_i:=suma_i(n-1)+(2*n-1);
write('Introdu n= '); end;
readln(n); begin
writeln('Calculare'); clrscr;
s:=-1; writeln('Calcularea sumei numerelor
for i:=0 to n do impare.');
if (i=0) then s:=0 else writeln('Rezolvare prin metoda
s:=s+(2*i-1); recursiei.');
writeln('Suma a primilor ',n,' write('Introdu n= ');
termeni impari = ',s:10); readln(n);
end. writeln('Calculare');
writeln('Suma a primilor ',n,'
termeni impari = ',suma_i(n):10);
end.

Program C nerecursiv Program C recursiv


#include <iostream.h> #include <iostream.h>
#include <conio.h> #include <conio.h>
#include <iomanip.h> #include <iomanip.h>
unsigned long int suma_p(unsigned int unsigned long int suma_p(unsigned int
n) n)
{ {
unsigned long int i, s=-1; if(n==0)
for(i=0; i<=n;i++) return 0;
if(i==0) else
s=0; return suma_p(n-1)+(2*n-1);
else
s+=(2*i-1); }
return s; void main()
} {
void main() clrscr();
{ unsigned int n, i;
clrscr(); cout<<"Calcularea sumei numerelor
unsigned int n, i; impare.\n";
cout<<"Calcularea sumei numerelor cout<<"Rezolvare prin metoda
impare.\n"; recursiei.\n";
cout<<"Rezolvare prin metoda cout<<"Introdu n= ";cin>>n;
nerecursiva.\n"; for(i=1; i<=n;i++)
cout<<"Introdu n= ";cin>>n; cout<<setw(4)<<i<<". t=
for(i=1; i<=n;i++) "<<setw(4)<<(2*i-1)<<";
cout<<setw(4)<<i<<". t= S("<<setw(4)<<i<<")=
6
"<<setw(4)<<(2*i-1)<<"; "<<setw(10)<<suma_p(i)<<";"<<endl;
S("<<setw(4)<<i<<")= }
"<<setw(10)<<suma_p(i)<<";"<<endl; }

Rezultat program Pascal nerecursiv Rezultat program Pascal recursiv


Calcularea sumei numerelor impare. Calcularea sumei numerelor impare.
Introdu n= 20 Introdu n= 20
Calculare Calculare
Suma a primilor 20 termeni pari = 400 Suma a primilor 20 termeni pari = 400

Rezultat program C nerecursiv Rezultat program C recursiv


Calcularea sumei numerelor impare. Calcularea sumei numerelor impare.
Introdu n= 20 Introdu n= 20
Calculare Calculare
Suma a primilor 20 termeni pari = 400 Suma a primilor 20 termeni pari = 400

0, ă =0
={

−1

+2∗ −1 ă >0

7
Problema 4
Șirul Fibonacci
Se cere de scris un program ȋn Pascal şi C varianta recursivă şi nerecursivă a şirului de numere
Fibonacci:1,1,2,3,5,8,...21.

Program Pascal nerecursiv Program Pascal recursiv


uses crt; uses crt;
var n,k:integer; var k,n:integer;
f:array[1..25] of integer; function Fib(k:integer):integer;
begin begin
clrscr; if (k=1) or (k=2) then Fib:=1
write('introdu n:'); else Fib:=Fib(k-1)+Fib(k-2);
readln(n); end;
f[1]:=1; f[2]:=1; begin
for k:=3 to n do clrscr;
begin write('introduceti n:');
f[k]:=f[k-1]+f[k-2]; readln(n);
end; writeln('Numerele Fibonacci sunt:');
writeln('Numerele Fibonacci sunt:'); for k:=1 to n do
for k:=1 to n do write(' ',Fib(k):3);
write(f[k],' '); readkey;
readkey; end.
end.

Program C nerecursiv Program C recursiv


#include<stdio.h> #include<stdio.h>
#include<conio.h> #include<conio.h>
void main(){ int Fib(int k){
int f[25],n,k; if (k<2) return 1;
printf("introdu n:"); else return (Fib(k-1)+Fib(k-2));
scanf("%d",&n); }
f[0]=1; f[1]=1; void main(){
for (k=2;k<n;k++) intn,k;
f[k]=f[k-1]+f[k-2]; clrscr();
printf("primele %d elemente printf("introdu n:");
sunt:\n",n); scanf("%d",&n);
for(k=0; k<n; k++) printf("primele %d elementesunt:",n);
printf(" %d",f[k]); for (k=0;k<n;k++)
printf(" \n"); printf("\n %d",Fib(k));
return 0; getch();
getch(); }
}

8
Rezultat program Pascal nerecursiv Rezultat program Pascal recursiv

Rezultat program C nerecursiv Rezultat program C recursiv

Fibn  1, n 1, 2

Fib ( n  1)  Fib ( n  2), n  2

9
Problema 5
Șirul Fibonacci modificat
Se cere de scris un program ȋn Pascal şi C,varianta recursivă şi nerecursivă, care afişează la ecran
şirul de numere: 1,1,1,2,3,7,23,164....

Program Pascal nerecursiv Program Pascal recursiv


uses crt; uses crt;
var k,n:integer; var k,n:integer;
f:array[1..25] of integer; function rec(k:integer):integer;
begin begin
clrscr; if (k=1) or (k=2) or (k=3) then rec:=1
write('introdu n:'); else rec:=rec(k-1)*rec(k-2)+rec(k-3);
readln(n); end;
f[1]:=1; f[2]:=1; f[3]:=1; begin
for k:=4 to n do clrscr;
f[k]:=f[k-1]*f[k-2]+f[k-3]; write('Introdu n:'); readln(n);
writeln('primele ',n,' writeln('primele ',n,' numere :');
numere:');writeln; writeln;
for k:=1 to n do for k:=1 to n do
writeln('Numarul ',k,' este: ',f[k]:3); writeln('Numarul ',k,' este:
readkey; ',rec(k):3); readkey;
end. end.

Program C nerecursiv Program C recursiv


#include<stdio.h> #include<stdio.h>
#include<conio.h> #include<conio.h>
void main(){ int rec(int k){
int f[25],n,k; if (k<3)
clrscr(); return 1;
printf("introdu n:"); else return (rec(k-1)*rec(k-2)+rec(k-
scanf("%d",&n); 3));
f[0]=1; f[1]=1; f[2]=1; }
for (k=3;k<n;k++) void main(){
f[k]=f[k-1]*f[k-2]+f[k-3]; intn,k;
printf("primele %d elemente sunt:",n); printf("introdu n :");
for(k=0;k<n;k++) scanf("%d",&n);
printf("\n %d",f[k]); printf("primele %d numere:",n);
getch(); for (k=0; k<n; k++)
} printf("\n %d",rec(k));
getch();
}

10
Rezultat program Pascal nerecursiv Rezultat program Pascal recursiv

Rezultat program C nerecursiv Rezultat program C recursiv

Fibn  1, n 1, 2, 3

Fib ( n  1) * Fib ( n  2)  Fib ( n  3), n  3

11
Problema 6
Suma sirului de numere
Să se calculeze suma primilor n termini ai şirului de numere : 1, 5, 9, 13, 17, … ,4n-3, …

Program Pascal nerecursiv Program Pascal recursiv


uses crt; usescrt;
var i,n,s:integer; varn,k:integer;
begin function suma(k:integer):integer;
clrscr; begin
write('introdu n:'); if k=0 then suma:=0
readln(n); else suma:=suma(k-1)+4*k-3;
s:=0; end;
for i:=1 to n do begin
s:=s+4*i-3; clrscr;
writeln('suma este:',s); write('introdu n:');
readkey; readln(n);
end. writeln('suma este:',suma(n));
readkey;
end.

Program C nerecursiv Program C recursiv


#include<stdio.h> #include<stdio.h>
#include<conio.h> #include<conio.h>
void main(){ int s(int k){
int n,s,k,t; if (k==0) return 0;
clrscr(); else return s(k-1)+4*k-3;
printf("introdu n:"); }
scanf("%d",&n); voidmain(){
s=0; k=1; t=4*n-3; int n;
while(k<=t) clrscr();
{ printf("introdu n:");
s=s+k; scanf("%d",&n);
k=k+4; printf("suma sirului este=%d",s(n));
} getch();
printf("suma este=%d",s); }
getch();
}

12
Rezultat program Pascal nerecursiv Rezultat program Pascal recursiv

Rezultat program C nerecursiv Rezultat program C recursiv

0, n  0
S(n)= 
S (n 1)  4 * n  3

13
Problema 7
Suma numerelor
Este dat şirulde numere 1,6,11,16,21,….Să se determine suma primelor n numere a şiruluidat.Să se
alcătuiască variant nerecursiv şi recursiv ȋn Pascal şi C.

Program Pascal nerecursiv Program Pascal recursiv


uses crt; uses crt;
var i,n,s:integer; varn,k:integer;
begin functionsuma(k:integer):integer;
clrscr; begin
write('introdu n:'); if k=0 then suma:=0
readln(n); elsesuma:=suma(k-1)+5*k-4;
s:=0; end;
for i:=1 to n do begin
s:=s+5*i-4; clrscr;
writeln('suma este:',s); write('introdu n:');
readkey; readln(n);
end. writeln('suma este:',suma(n));
readkey;
end.

Program C nerecursiv Program C recursiv


#include<stdio.h> #include<stdio.h>
#include<conio.h> #include<conio.h>
void main(){ int s(int k){
int n,s,k,t; if (k==0) return 0;
clrscr(); else return s(k-1)+5*k-4;
printf("introdu n:"); }
scanf("%d",&n); Void main(){
s=0; k=1; t=5*n-4; int n;
while(k<=t){ clrscr();
s=s+k; printf("introdu n:");
k=k+5; scanf("%d",&n);
} printf("suma primelor %d numere
printf("suma primelor %d numere este=%d",n,s(n));
este=%d",n,s); getch();
getch(); }
}

14
Rezultat program Pascal nerecursiv Rezultat program Pascal recursiv

Rezultat program C nerecursiv Rezultat program C recursiv

1, n  0
S(n)= 
S ( n  1)  5* n  4, n 1

15
Problema 8
Suma numerelor
Este datşirulde numere 1,6,11,16,21,….Să se determine suma primelor n numere a şirului dat. Să se
alcătuiască variant nerecursivă şi recursive ȋn Pascal şi C.

Program Pascal nerecursiv Program Pascal recursiv


uses crt; uses crt;
var i,n,s:integer; varn,k:integer;
begin function suma(k:integer):integer;
clrscr; begin
write('introdu n:'); if k=0 then suma:=0
readln(n); else suma:=suma(k-1)+5*k-4;
s:=0; end;
for i:=1 to n do begin
s:=s+5*i-4; clrscr;
writeln('suma este:',s); write('introdu n:');
readkey; readln(n);
end. writeln('suma este:',suma(n));
readkey;
end.

Program C nerecursiv Program C recursiv


#include<stdio.h> #include<stdio.h>
#include<conio.h> #include<conio.h>
void main(){ int s(int k){
int n,s,k,t; if (k==0) return 0;
clrscr(); else return s(k-1)+5*k-4;
printf("introdu n:"); }
scanf("%d",&n); voidmain(){
s=0; k=1; t=5*n-4; int n;
while(k<=t) clrscr();
{ printf("introdu n:");
s=s+k; scanf("%d",&n);
k=k+5; printf("suma primelor %d numere
} este=%d",n,s(n));
printf("suma primelor %d numere getch();
este=%d",n,s); }
getch();
}

16
Rezultat program Pascal nerecursiv Rezultat program Pascal recursiv

Rezultat program C nerecursiv Rezultat program C recursiv

 1, n  0
S(n)= 
S ( n  1)  5* n  4

17
Problema 9
Algoritmul lui Euclid
Să se determine cel mai mare divizor comun a două numere naturale. Să se scrie varianta recursivă
si nerecursivă in Pascal şi C.

Program Pascal nerecursiv Program Pascal recursiv


usescrt; usescrt;
var a,b,cmmdc:integer; var a1,b1:integer;
begin function cmmdc(a,b:integer):integer;
clrscr; begin
write('introdu a='); readln(a); if a=b then cmmdc:=a
write('introdu b='); readln(b); else
while(a<>b) do if a>b then cmmdc:=cmmdc(a-b,b)
if a>b then a:=a-b else cmmdc:=cmmdc(a,b-a);
else b:=b-a; end;
writeln('cmmdc=',a); begin
readkey; clrscr;
end. write('introdu a1:');
readln(a1);
write('introdu b1:');
readln(b1);
writeln('cmmdc= ',cmmdc(a1,b1));
readln;
end.

Program C nerecursiv Program C recursiv


#include<stdio.h> #include<conio.h>
#include<conio.h> #include<stdio.h>
void main(){ Int cmmdc(int a,int b){
int a,b,cmmdc; if (a==b) return a;
clrscr(); if (a>b) return cmmdc(a-b,b);
printf("introdu a:"); else return cmmdc(a,b-a);
scanf("%d",&a); }
printf("introdu b:"); void main(){
scanf("%d",&b); inta,b;
while (a!=b){ clrscr();
if (a>b) a=a-b ; printf("introdu a:");
else b=b-a ; scanf("%d",&a);
} printf("introdu b:");
printf("cmmdc=%d",a); scanf("%d",&b);
getch(); printf("cmmdc(%d,%d)=%d",a,b,
} cmmdc(a,b));
getch();
}

18
Rezultat program Pascal nerecursiv Rezultat program Pascal recursiv

Rezultat program C nerecursiv Rezultat program C recursiv

a,

ab
CMMDC(a,b)= cmmdc(a  b, b), a  b

cmmdc(a, b  a), b  a

19
Problema 10
Algoritmul lui Euclid
Să se determine cel mai mare divizor comun a trei numere naturale. Să se scrie varianta recursivă si
nerecursivă in Pascal şi C.

Program Pascal nerecursiv Program Pascal recursiv


usescrt; usescrt;
var a,b,c,cmmdc:integer; var a1,b1,c1:integer;
begin function cmmdc(a,b:integer):integer;
clrscr; begin
write('introdu a='); readln(a); if a=b then cmmdc:=a
write('introdu b='); readln(b); else
write('introdu c='); readln(c); if a>b then cmmdc:=cmmdc(a-b,b)
while(a<>b) do else cmmdc:=cmmdc(a,b-a);
if a>b then a:=a-b end;
else b:=b-a; begin
while(a<>c) do clrscr;
if a>c then a:=a-c write('introdu a1:'); readln(a1);
else c:=c-a; write('introdu b1:');
writeln('cmmdc=',a); readln(b1);
readkey; write('introdu c1:');
end. readln(c1);
writeln('cmmdc= ',
cmmdc(cmmdc(a1,b1),c1));
readln;
end.

Program C nerecursiv Program C recursiv


#include<stdio.h> #include<stdio.h>
#include<conio.h> #include<math.h>
void main(){ int main(){
int a,b,c,cmmdc; int a,b,c;
clrscr(); int cmmdc(int a, int b){
printf("introdu a:"); if (a==b) return a;
scanf("%d",&a); else
printf("introdu b:"); if (a>b) return(cmmdc(a-b,b));
scanf("%d",&b); else return(cmmdc(a,b-a));
printf("introdu c:"); }
scanf("%d",&c); printf("introdu a:\n ");
while (a!=b){ scanf("%d",&a);
if (a>b) a=a-b ; printf("introdu b:\n ");
else b=b-a ; scanf("%d",&b);
} printf("introdu c:\n ");
while (a!=c){ scanf("%d",&c);
if (a>c) a=a-c ; printf("cmmdc(%d,%d,%d) este: %d
else c=c-a ; ",a,b,c,cmmdc(cmmdc(a,b),c));
} return 0;
printf("cmmdc=%d",a); }
getch();
}

20
Rezultat program Pascal nerecursiv Rezultat program Pascal recursiv

Rezultat program C nerecursiv Rezultat program C recursiv

 a,abc
CMMDC(a,b,c)= 
cmmdc (cmmdc (a , b ), b ) , a , b , c 

21
Problema 11
Recursivitatea indirectă.
Calcularea valorilor a 2 funcţii F(x) şi G(x). Să se alcătuiască un program Pascal şi C utilizȋnd
recursia indirectă pentru a calcula valorile funcţiilor:
 x  2, x 1   x ,x  0
f ( x)   și g ( x)
g (x  1), x 1   f (x )  1,  0
x
Program Pascal recursiv-indirect Program C recursiv-indirect
uses crt; # include<stdio.h>
var x:integer; # include<conio.h>
Function F(x:integer):integer; int G(int);
Forward; int F(int x){
Function G(x:integer):integer; if (x>1) return G(x-1);
begin else return x+2;}
if (x>=0) then G:=F(x)+1 int G(int x){
else G:=-x; if(x>=0) return F(x)+1;
end; else return -x;}
Function F(x:integer):integer;
begin void main (){
if (x>1) then F:=G(x-1) int x;
else F:=x+2;end; clrscr();
Begin printf ("Introdu x=");
Write ('Introdu x=');readln(x); scanf ("%d",&x);
Writeln ('F(',x,')=',F(x)); printf ("\n F(x)=%d",F(x));
Writeln ('G(',x,')=',G(x)); printf ("\n G(x)=%d",G(x));
readkey; getch();
End. }

Rezultat program Pascal recursiv Rezultat program C recursiv

22
Problema 12
Recursivitatea indirectă.
Calcularea valorilor a 2 funcţii F(x) şi G(x). Să se alcătuiască un program Pascal şi C utilizȋnd
recursia indirectă pentru a calcula valorile funcţiilor:
 x2, x3 a ( x )  5, x  0
a ( x)   și b ( x)   (x  1) 2, x  0

b ( x  2), x  3
Program Pascal recursiv-indirect Program C recursiv-indirect
uses crt; #include<stdio.h>
var x:integer; #include<conio.h>
Function A(x:integer):integer; int B(int);
Forward; int A(int x){
Function B(x:integer):integer; if(x<=3) return x*x;
begin else return B(x-2);}
if (x>=0) then B:=A(x)+5 int B(int x){
else B:=(x+1)*(x+1); end; if(x>=0) return A(x)+5;
Function A(x:integer):integer; else return(x+1)*(x+1);}
begin
if (x<=3) then A:=(x)*(x)else void main() {
A:=B(x-2);end; int x;
Begin clrscr();
Write ('introdu x=');readln(x); printf ("Introdu x=");
Writeln ('A(',x,')=',A(x)); scanf ("%d",&x);
Writeln ('B(',x,')=',B(x)); printf("\n A(x)=%d",A(x));
readkey; printf("\n B(x)=%d",B(x));
End. getch();
}

Rezultat program Pascal recursiv Rezultat program C recursiv

23
Problema 13
Recursivitatea indirectă.
Calcularea valorilor a 2 funcţii F(x) şi G(x). Să se alcătuiască un program Pascal şi C utilizȋnd
recursia indirectă pentru a calcula valorile funcţiilor:
 x2, x3  (x  1)2 , x  0  x2, x0
  
a ( x )  b ( x  2),3  x  6 b ( x )  c ( 1)  1, 0  x  5 c ( x )  b ( x  1), 0  x  5
 c ( x  1), x  6  a ( x )  5, x  5  a ( x  1), x  5
  

Program Pascal recursiv-indirect Program C recursiv-indirect


uses crt; #include <iostream.h>
var x:integer; #include <conio.h>
function a(x:integer):integer;forward; #include <iomanip.h>
function b(x:integer):integer;forward; #include <math.h>
function c(x:integer):integer; int b_(int x);
begin int c_(int x);
if (x<=0) then c:=x*x*x; int a_(int x)
if ((x>0) and (x<5)) then c:=b(x+1); {if(x<=3) return pow(x,2);
if x>=5 then c:=a(x+1); else if(x>6) return c_(x-1); else
end; return b_(x-2);}
function b(x:integer):integer; int b_(int x)
begin { if(x<0) return pow(x+1,2);
if x<=0 then b:=(x+1)*(x+1); else if(x>=5) return c_(-1)-1; return
if (x>0) and (x<5) then b:=c(-1)-1; a_(x)+5;}
if x>=5 then b:=a(x)+5; int c_(int x)
end; { if(x<0) return pow(x,2);
function a(x:integer):integer; else if(x>=5) return b_(x+1); return
begin a_(x+1);}
if(x<=3) then a:=x*x; void main()
if (x>3) and (x<6) then a:=b(x-2); {
if x>=6 then a:=c(x-1); clrscr();
end; int m, p, i=1;
begin cout<<"Calcularea valorii functiilor
clrscr; a(x), b(x) si c(x)."<<endl;
write('introduvaloarealui x:'); cout<<"Rezolvare prin metoda
readln(x); recursiei indirecte."<<endl;
writeln('a(',x,')=',a(x)); cout<<"Introdu intervalul de afisare
writeln('b(',x,')=',b(x)); m, p= ";cin>>m>>p;
writeln('c(',x,')=',c(x)); cout<<setw(20)<<"Afisare
readkey; a(x)"<<setw(25)<<"Afisare
end. b(x)"<<setw(25)<<"Afisare c(x)"<<endl;
for(int x=m; x<=p;x++){
cout<<setw(3)<<i<<".
"<<"a("<<setw(3)<<x<<") =
"<<setw(5)<<a_(x)<<";";
cout<<setw(10)<<"
"<<"b("<<setw(3)<<x<<") =
"<<setw(5)<<b_(x)<<";";
cout<<setw(10)<<"
"<<"c("<<setw(3)<<x<<") =
"<<setw(5)<<c_(x)<<";"<<endl;
i++;
}
}
24
Rezultat program Pascal recursiv Rezultat program C recursiv

25
Problema 14
Recursivitatea indirectă.
Calcularea valorilor a 2 funcţii F(x) şi G(x). Să se alcătuiască un program Pascal şi C utilizȋnd
recursia indirectă pentru a calcula valorile funcţiilor:
 a,n0  b, n  0
 

a ( n)   a b b ( n)  
 n 1 n1
,n0  a b ,n0
 n 1n1
 2

Program Pascal recursiv-indirect Program C++ recursiv-indirect


uses crt; #include<iostream>
var p,n,q:integer; #include<conio.h>
function A(n:integer):real;forward; #include<math.h>
function B(n:integer):real; using namespace std;
begin int n,p,q;
if(n=1)then B:=p else double b(int n);
B:=sqrt(A(n-1)*B(n-1));end; double a(int n){
function A; if (n==0) return q;
begin else
if(n=1)then A:=q else return (a(n-1)+b(n-1))/2;
A:=(A(n-1)+B(n-1))/2;end; }
begin double b(int n){
clrscr; if (n==0) return p;
write('n=');readln(n); else return sqrt(a(n-1)*b(n-1));
write('p=');readln(p); }
write('q=');readln(q); int main(){
writeln('A(n)=',a(n):3:2); cout<<"introdu n=";
write('B(n)=',b(n):3:2); cin>>n;
readkey; cout<<"introduceti p=";
end. cin>>p;
cout<<"introduceti q=";
cin>>q;
cout<<"A(n)="<<a(n)<<endl;
cout<<"B(n)="<<b(n)<<endl;
getch();
return 0;}

Rezultat program Pascal recursiv Rezultat program C recursiv

26
Problema 15
Recursivitatea indirectă.
Să se elaboreze un program care calculează valoarea termenilor an și bn pentru un x cunoscut. În
pascal și c++, metoda recursivă și nerecursivă.
Fie date trei serii:

ă =0 ă =0 ă =0
a ={ −1
,b = {3 și c = {3
+ +
−1 −1

−1 −1
, >0 ∗ ∗ , >0 + + , >0

√ −1 −1 √ −1 −1
3

Program Pascal recursiv- Program C++ recursiv-indirect


indirect
uses crt; #include <iostream.h>
var a, b, c, m, p, n, #include <conio.h>
i:integer; #include <iomanip.h>
function b_(n: integer): #include <math.h>
real;forward; int a, b, c;
function c_(n: integer): double b_(int n);
real;forward; double c_(int n);
function a_(n: integer): real; double a_(int n)
begin { if(n==0) return a;
if (n=0) then a_:=a else else if(n>0) return (a_(n-1)+b_(n-1)+c_(n-
a_:=(a_(n-1)+b_(n-1)+c_(n- 1))/3;}
1))/3; double b_(int n)
end; { if(n==0) return b;
function b_(n: integer): real; else
begin if(n>0) return pow(a_(n-1)*b_(n-1)*c_(n-
if (n=0) then b_:=b else 1),(double)(1)/3);}
b_:=exp((1/3)*ln(a_(n-1)*b_(n- double c_(int n)
1)*c_(n-1))); { if(n==0) return c;
end; else
function c_(n: integer): real; if(n>0) return pow(a_(n-1)+b_(n-1)+c_(n-
begin 1),(double)(1)/3);}
if (n=0) then c_:=c else void main()
c_:=exp((1/3)*ln(a_(n-1)+b_(n- { clrscr();
1)+c_(n-1))); int m, p, i=1;
end; cout<<"Calcularea valorii functiilor a(n),
begin b(n) si c(n)."<<endl;
clrscr; cout<<"Rezolvare prin metoda recursiei
writeln('Calcularea valorii indirecte."<<endl;
functiilor a(n), b(n) si cout<<"Introdu parametrii a, b, c=
c(n).'); ";cin>>a>>b>>c;
writeln('Rezolvare prin cout<<"Introdu intervalul de afisare m=0, p=
metoda recursiei indirecte.'); ";cin>>m>>p;
write('Introdu parametrii a, cout<<setw(20)<<"Afisare
b, c= '); a(n)"<<setw(27)<<"Afisare
readln(a, b, c); b(n)"<<setw(27)<<"Afisare c(n)"<<endl;
write('Introdu intervalul de for(int n=m; n<=p;n++){
afisare m, p= '); cout<<setw(3)<<i<<".
readln(m, p); "<<"a("<<setw(3)<<n<<") =
writeln('Afisare a(n)':18, "<<setw(10)<<setprecision(5)<<a_(n)<<";";
'Afisare b(n)':27, 'Afisare cout<<setw(5)<<" "<<"b("<<setw(3)<<n<<") =
c(n)':27); "<<setw(10)<<setprecision(5)<<b_(n)<<";";
i:=1; cout<<setw(5)<<" "<<"c("<<setw(3)<<n<<") =
for n:=m to p do "<<setw(10)<<setprecision(5)<<c_(n)<<";"<<endl;
begin i++;
27
writeln(i:3,'. }
a(',n:3,')= ',a_(n):10:5,'; }
b(',n:3,')= ',b_(n):10:5,';
c(',n:3,')= ',c_(n):10:5,';');
i:=i+1;
end;
end.

Rezultat program Pascal recursiv Rezultat program C recursiv

28
Problema 16
Funcția Ackermann.
Să se alcătuiască un program Pascal pentru funcţia Ackermann:

Program Pascal recursiv-indirect Program C recursiv-indirect


Program Ack_rec; #include<stdio.h>
usescrt; intAck(intm,int n){
varm,n:integer;
functionAck(m,n:integer):integer; if (m==0) return n+1;
if(n==0) return Ack(m-1,1);
begin
else
if m=0 then Ack:=n+1 returnAck(m-1,Ack(m,n-1));
else if n=0 then Ack:=Ack(m-1,1) }
elseAck:=Ack(m-1,Ack(m,n-1));
end; void main(){
begin clrscr();
clrscr; intm,n;
write('introdu m:'); readln(m); printf("introdu m:"); scanf("%d",&m);
write('introdu n:'); readln(n); printf("introdu n:"); scanf("%d",&n);
writeln('Ack(',m,',',n,')=', printf("\n
Ack(%d,%d)=%d",m,n,Ack(m,n));
Ack(m,n));
}
readkey;
end.

Rezultat program Pascal recursiv Rezultat program C recursiv


m n Ack(m,n) m n Ack(m,n)
0 0 1 0 0 1
0 1 2 0 1 2
1 0 2 1 0 2
1 1 3 1 1 3
1 2 4 1 2 4
2 1 5 2 1 5
2 2 7 2 2 7
3 0 5 3 0 5
3 1 13 3 1 13
3 2 29 3 2 29
3 3 61 3 3 61
3 4 125 3 4 125
4 0 13 4 0 13

introdu m, n: 0 0 introdu m, n: 0 0
Ack(0,0)=1 Ack(0,0)=1

29
Problema 17
Funcția Hermite.
Să se alcătuiască un program Pascal şi C pentru funcţia Hermite:

Program Pascal recursiv-indirect Program C recursiv-indirect


usescrt; #include<stdio.h>
varn,x:integer; #include<conio.h>
Function H(n,x:integer):integer; intHermite(intn,int x){
begin if (n==0) return 1;
if n=0 then H:=1 else if (n==1) return 2*x;
else if n=1 then H:=2*x else return 2*x*Hermite(n-1,x)-2*
else H:=2*x*H(n-1,x)-2*(n-1)* (n-1)*Hermite(n-2,x);
H(n-2,x); }
end; void main(){
begin intn,x;
clrscr; clrscr();
writeln('introdu n:');readln(n); printf("introdu n:");
writeln('introdu x:');readln(x); scanf("%d",&n);
writeln('Hermite(',n,',',x,')=', printf("introdu x:");
H(n,x)); scanf("%d",&x);
readkey; printf("\n
end. Hermite(%d,%d)=%d",n,x,Hermite(n,x));
}

Rezultat program Pascal recursiv Rezultat program C recursiv


m n H(m,n) m n H(m,n)
0 0 1 0 0 1
0 1 1 0 1 1
1 0 0 1 0 0
1 1 2 1 1 2
2 1 2 2 1 2
1 2 4 1 2 4
2 2 14 2 2 14
3 1 -4 3 1 -4
1 3 6 1 3 6
3 2 40 3 2 40
2 3 34 2 3 34
3 3 180 3 3 180
5 7 -3702 5 7 -3702

introdu m, n: 0 0 introdu m, n: 0 0
Hermite(0,0)=1 Hermite(0,0)=1

30
Problema 18
Funcția Cebâșev.
Să se alcăuiască un program Pascal şi unu C pentru funcţiile Cebȋşev:

Program Pascal recursiv-indirect Program C recursiv-indirect


usescrt; #include<stdio.h>
varn,x:integer; #include<conio.h>
Function T(n,x:integer):integer; intCebisev(intn,int x){
begin if (n==0) return 1;
if n=0 then T:=1 else if (n==1) return 2*x;
else if n=1 then T:=2*x else return 2*x*Cebisev(n-1,x)-2*(n-
else T:=2*x*T(n-1,x)-T(n-2,x); 1)-Cebisev(n-2,x);
end; }
begin void main(){
clrscr; intn,x;
writeln('introdu n:'); clrscr();
readln(n); printf("introdu n:"); scanf("%d",&n);
writeln('introdu x:'); printf("introdu x:"); scanf("%d",&x);
readln(x); printf("\n
writeln('Cebisev(',n,',',x,')=', Cebisev(%d,%d)=%d",n,x,Cebisev(n,x));
T(n,x)); }
readkey;
end.

Rezultat program Pascal recursiv Rezultat program C recursiv


n x T(n,x) n x T(n,x)
0 0 1 0 0 1
0 1 1 0 1 1
1 0 0 1 0 0
1 1 2 1 1 2
2 1 3 2 1 3
1 2 4 1 2 4
2 2 15 2 2 15
3 1 4 3 1 4
1 3 6 1 3 6
3 2 56 3 2 56
2 3 35 2 3 35
3 3 204 3 3 204
5 7 2602 5 7 2602

introdu m, n: 0 0 introdu m, n: 0 0
Cevisev(0,0)=1 Cevisev(0,0)=1

31
Problema 19
Funcția Manna Pnuiele.
Să se alcăuiască un program Pascal şi unu C pentru funcţiile Manna Pnuiele:

Program Pascal recursiv-indirect Program C recursiv-indirect


usescrt; #include<stdio.h>
var x:integer; #include<conio.h>
function f(x:integer):integer; int Manapnuiele(int x){
begin if (x>=12) return x-1;
if (x>=12) then F:=x-1 else return
else if x<12 then F:=F(F(x+2)); Manapnuiele(Manapnuiele(x+2));
end; }
begin void main(){
clrscr; int x;
write('introdu x:='); clrscr();
readln(x); printf("introdu x:=");
Writeln(‘F(‘,x,’)=’,F(x)); scanf("%d",&x);
readkey; printf("\X
end. Manapnuiele(%d,%d)=%d",x,
Manapnuiele(x));
getch();
}

Rezultat program Pascal recursiv Rezultat program C recursiv


x F(x) x F(x)
1 1 1 1
2 2 2 2
3 3 3 3
4 4 4 4
5 5 5 5
6 6 6 6
7 7 7 7
8 8 8 8
9 9 9 9
10 10 10 10
11 11 11 11
12 12 12 12
13 13 13 13
14 14 14 14

introdu x: 1 introdu x: 1
Manapnuiele (1)=1 Manapnuiele (1)=1

32
Problema 20
Turnurile Hanoi.
Sunt date 3 tirje x, y, z. Pe tirja x sunt plasate n discuri aşezate ȋn ordinea descrescătoare a
diametrelor. Se cere de trecut toate discurile de pe tirja x pe tirja y folosind tirja intermediară z,
astfel ȋncȋt să se respecte următoarea condiţie: discul mai mic totdeauna se află deasupra celui mai
mare la orice transfer.

Program Pascal recursiv-indirect Program C recursiv-indirect


uses crt; # include <iostream.h>
var x,y,z:char; # include<stdio.h>
n:integer; # include <conio.h>
Procedure Hanoi(n:integer;x,y,z:char); # include <math.h>
begin
if n=1 then writeln(x,y) else void Hanoi(int n,char x,char y,char
begin z){
Hanoi (n-1,x,z,y); if (n==1)
writeln (x,y); { printf("%c%c\n",x,y);}
Hanoi (n-1,z,y,x);end;end; else{
begin Hanoi(n-1,x,z,y);printf("%c%c\n",x,y);
clrscr; Hanoi(n-1,z,y,x);}
write ('Introdu numarul de discuri:'); }
readln(n); void main(){
Hanoi (n,'x','y','z'); clrscr();
readkey; int n;
end. printf ("introdu numarul de discuri
:");
scanf("%d",&n);
Hanoi(n,'x','y','z');
getch();
}

Rezultat program Pascal recursiv Rezultat program C recursiv

33
Problema 21
Compoziția a două funcții.
Sunt date două funcții f(x) și g(x):
2
2 +1<5 ( )={4+25≤<8
3 ≥8
2 ( )={
5 −3 +2≤1 2−+5>1
Se cere de găsit compziția:
1. f(g(f(x))); 2. g(f(g(x)));
3. f(g(f(g(f(x))))); 4. f(g(f(f(x))));

Program Pascal recursiv-indirect Program C recursiv-indirect


program Compozitia; #include <iostream.h>
uses crt; #include <conio.h>
var a, b, x:integer; #include <iomanip.h>
function f(x: integer): integer; #include <math.h>
begin int f(int x)
if (x<5) then f:=2*sqr(x)+1 { if (x<5) {return
else 2*pow(x,2)+1;}
if (x>=8) then f:=3 else
else if (x>=8) {return 3;}
f:=sqr(x)*sqr(x)+2; else {return
end; pow(x,4)+2;}
function g(x: integer): integer; }
begin int g(int x)
if (x<=1) then g:=5*sqr(x)-3*x+2 { if (x<=1) {return
else 5*pow(x,2)-3*x+2;}
g:=sqr(x)-x+5; else {return pow(x,2)-
end; x+5;}
begin }
clrscr; void main()
writeln('Compozitia a doua functii f(x) si { clrscr();
g(x).'); int a, b;
writeln('Rezolvare prin metoda recursiva.'); cout<<"Compozitia a doua
write('Pentu x, introdu intervalul a, b = '); functii f(x) si
readln(a, b); g(x)."<<endl;
write('f(g(f(x)))':18,'g(f(g(x)))':12); cout<<"Rezolvare prin
metoda recursiva."<<endl;
writeln('f(g(f(g(f(x)))))':18,'f(g(f(f(x))))':15); cout<<"Pentu x, introdu
for x:=a to b do intervalul a, b =
begin ";cin>>a>>b;
cout<< setw(18)<<
write('x=',x:3,':',f(g(f(x))):12,g(f(g(x))):12); "f(g(f(x)))"<< setw(12)<<
"g(f(g(x)))";
writeln(f(g(f(g(f(x))))):18,f(g(f(f(x)))):15); cout<< setw(18)<<
end; "f(g(f(g(f(x)))))"
end. <<setw(15) <<"f(g(f(f(x))))"
<< endl;
for(int x=a; x<=b;x++){
cout<< "x="<<
setw(3)<< x<<':'<<
setw(12)<< f(g(f(x)))<<
setw(12)<< g(f(g(x)));
cout<< setw(18)<<
f(g(f(g(f(x)))))<< setw(15)
<< f(g(f(f(x)))) << endl;
}

34
}

Rezultat program Pascal recursiv Rezultat program C recursiv

35
Problema 22

Algoritmul lui Euclid pentru n numere.


Să determinăm cmmdc a n numere naturale, utilizând algritmul lui Euclid.
=
(, )={ ( − , ) >
(, − ) >

Să se elaboreze un program care calculează cmmdc pentru n numere. În pascal și c++, metoda
recursivă.
Program Pascal recursiv-indirect Program C recursiv-indirect
program cmmdc_n; #include <iostream.h>
uses crt; #include <conio.h>
type vector = array[1..100] of integer; #include <math.h>
var x:vector; n,i:integer; #include <stdlib.h>
function cmmdc(a,b:integer):integer; int x[100];
begin int cmmdc(int a, int b)
if(a=b) then cmmdc:=a {
else if(a==b)
if(a>b) then cmmdc:=cmmdc(a-b,b) return a;
else else
if(b>a) then cmmdc:=cmmdc(a,b- if(a>b)
a); return cmmdc(a-b,b);
end; else
function div_imp(p,q:integer):integer; return cmmdc(a,b-a);
var mij, d1, d2:integer; }
begin int div_imp(int p, int q){
if(abs(p-q)<=1) then int mij, d1, d2;
div_imp:=cmmdc(x[p], x[q]) if(abs(p-q)<=1) {return cmmdc(x[p],
else x[q]);}
begin else{
mij:=((p+q) div 2); //div_t x //int x.quot//x.rem
d1:=div_imp(p, mij); mij=div((p+q), 2).quot;
d2:=div_imp(mij+1,q); d1=div_imp(p, mij);
div_imp:=cmmdc(d1,d2); d2=div_imp(mij+1,q);
end; return cmmdc(d1,d2);
end; }
begin }
clrscr; void main()
writeln('Algoritmul Euclid. {
Determinarea cmmdc a n numere clrscr();
naturale.'); int a, b, n, i;
writeln('Rezolvare prin metoda cout<<"Algoritmul Euclid.
recursiva.'); Determinarea cmmdc a n numere
write('introdu numarul de elemente naturale."<<endl;
n='); cout<<"Rezolvare prin metoda
readln(n); recursiva."<<endl;
writeln('Introdu elementele'); cout<<"introdu numarul de elemente
for i:=1 to n do n=";cin>>n;
begin cout<<"Introdu elementele"<<endl;
write('x[',i,']= ');readln(x[i]); for (i=1; i<=n; i++){
end; cout<<"x["<<i<<"]= ";cin>>x[i];
write('cmmdc('); }
for i:=1 to n-1 do cout<<"cmmdc(";
write(x[i],', '); for (i=1; i<=n-1; i++){
write(x[n],')= '); cout<<x[i]<<", ";}
36
writeln(div_imp(1,n)); cout<<x[n]<<")= ";
end. cout<<div_imp(1,n);
}

Rezultat program Pascal recursiv Rezultat program C recursiv

37
Problema 23
Generarea părților unui număr.
Se dă un număr natural n. Să se elaboreze programele, în pascal și c++, metoda recursivă, care
generează toate partile lui n.

Program Pascal recursiv-indirect Program C recursiv-indirect


program partitie; #include <iostream.h>
uses crt; #include <conio.h>
var n, s, nr:integer; int n, s, nr;
x:array[1..40] of integer; int x[100];
procedure tipar(k:integer); void tipar(int k)
var i:integer; {
begin nr+=1;
nr:=nr+1; for(int i=1; i<k; i++)
for i:=1 to k-1 do cout<<x[i]<<"+";
write(x[i],'+'); cout<<x[k]<<endl;
writeln(x[k]); }
end; void back_(int k)
procedure back(k:integer); {
var i:integer; if(s==n) {tipar(k-1);}
begin else
if(s=n) then tipar(k-1) for (int i=1; i<=n-s; i++)
else {
for i:=1 to n-s do x[k]=i;
begin s+=x[k];
x[k]:=i; back_(k+1);
s:=s+x[k]; s-=x[k];
back(k+1); }
s:=s-x[k]; }
end; void main()
end; {
begin clrscr();
clrscr; cout<<"Generarea partilor unui
write('Introdu numarul numar."<<endl;
n=');readln(n); cout<<"Rezolvare prin metoda
back(1); recursiva."<<endl;
writeln('Sunt ',nr,' solutii') cout<<"introdu numarul n=";cin>>n;
end. back_(1);
cout<<"Sunt "<<nr<<" solutii"<<endl;
}

38
Rezultat program Pascal recursiv Rezultat program C recursiv

39
Problema 24

Curba Hilbert.
Hilbert a găsit o curbă care poate să treacăprin fiecare punct al spațiului. Numim curba Hilbert de
ordinul k curba realizată după următoarea regulă:
k k
1. trece prin fiecare nod al grilei 2 *2 ;
2. Trece prin noduri vecine ale curbei.
Curba Hilbert are următoarele elemente:
A B C D

Program Pascal recursiv-indirect Program C recursiv-indirect


Program CurbaHilbert; #include <graphics.h>
uses Crt, Graph; #include <stdlib.h>
const n=4; h0=460; #include <stdio.h>
var Gd, Gm: Integer; #include <conio.h>
ErrCode:integer; const n=4, h0=460;
i,h,x,y,x0,y0:integer; int Gd, Gm;
procedure B(i:integer); forward; int i,h,x,y,x0,y0;
procedure C(i:integer); forward; void A(int i); void B(int i); void
procedure D(i:integer); forward; C(int i); void D(int i);
procedure A(i:integer); void A(int i){
begin if(i>0) {
if(i>0) then begin D(i-1); x=x-h; lineto(x,y);
D(i-1);x:=x-h;LineTo(x,y); A(i-1); y=y-h; lineto(x,y);
A(i-1);y:=y-h;LineTo(x,y); A(i-1); x=x+h; lineto(x,y); B(i-1);
A(i-1);x:=x+h;LineTo(x,y); B(i-1); }
end; }
end; void B(int i){
procedure B(i:integer); if(i>0) {
begin C(i-1); y=y+h; lineto(x,y);
if(i>0) then begin B(i-1); x=x+h; lineto(x,y);
C(i-1);y:=y+h;LineTo(x,y); B(i-1); y=y-h; lineto(x,y); A(i-1);
B(i-1);x:=x+h;LineTo(x,y); }
B(i-1);y:=y-h;LineTo(x,y); A(i-1); }
end; void C(int i){
end; if(i>0) {
procedure C(i:integer); B(i-1); x=x+h; lineto(x,y);
begin C(i-1); y=y+h; lineto(x,y);
if(i>0) then begin C(i-1); x=x-h; lineto(x,y); D(i-1);
B(i-1);x:=x+h;LineTo(x,y); }
C(i-1);y:=y+h;LineTo(x,y); }
C(i-1);x:=x-h;LineTo(x,y); D(i-1); void D(int i){
end; if(i>0) {
end; A(i-1); y=y-h; lineto(x,y);
procedure D(i:integer); D(i-1); x=x-h; lineto(x,y);
begin D(i-1); y=y+h; lineto(x,y); C(i-1);
if(i>0) then begin }
A(i-1);y:=y-h;LineTo(x,y); }
D(i-1);x:=x-h;LineTo(x,y); void main(void){
D(i-1);y:=y+h;LineTo(x,y); C(i-1); clrscr();
end; char msg[80];
end; int gdriver = DETECT, gmode,
40
begin errorcode;
Gd := Detect; initgraph(&gdriver, &gmode,
InitGraph(Gd, Gm, 'C:\BP\BGI'); "c:\\tcpp\\bgi");
ErrCode:=GraphResult; errorcode = graphresult();
if ErrCode = grOk then if (errorcode != grOk){
begin printf("Eroare: %s\n",
i:=0; h:=h0; x0:=h div 2; y0:=x0; grapherrormsg(errorcode));
repeat printf("Actionati orice buton
i:=i+1; h:=h div 2; pentru iesire...");
x0:=x0+(h div 2); y0:=y0+(h div getch();
2); }else{
x:=x0; y:=y0; i=0; h=h0;
HighVideo; SetColor(i); x0=div(h, 2).quot;//div_t x //int
MoveTo(x,y); x.quot//x.rem
A(i); y0=x0;
until (i=n); do{
end i++; h=div(h, 2).quot;
else x0+=div(h, 2).quot; y0+=div(h,
writeln('Eroare: ', 2).quot;
GraphErrorMsg(ErrCode)); x=x0; y=y0;
Readln; CloseGraph; highvideo(); setcolor(i);
end. moveto(x,y);
A(i);
}while(!(i==n));
//Final
getch(); closegraph();
}
}

Rezultat program Pascal recursiv Rezultat program C recursiv


N=4 N=6

41
Problema 25

Curba Sierpinski.
Sierpinski a găsit o curbă care poate să treacă prin fiecare punct al spațiului.

Program Pascal recursiv-indirect Program C recursiv-indirect


Program CurbaSierpinski; #include <graphics.h>
uses Crt, Graph; #include <conio.h>
const n=6; Cadru=2048; SizeWin=460; #include <stdlib.h>
var Gd, Gm: Integer; ErrCode:integer; #include <stdio.h>
i,h,x,y:integer; k:real; #include <dos.h>
procedure B(i:integer); forward; const n=6, Cadru=2048, SizeWin=460;
procedure C(i:integer); forward; int Gd, Gm, ErrCode;int i,h,x,y;double
procedure D(i:integer); forward; k;
procedure A(i:integer); void A(int i);void B(int i);void C(int
begin i);void D(int i);
if(i>0) then begin void A(int i){
delay(10); if(i>0) {
A(i-1);x:=x+h;y:=y- delay(10);
h;LineTo(round(x*k),round(y*k)); A(i-1);x=x+h;y=y-
B(i- h;lineto((double)x*k,(double)y*k);
1);x:=x+h;x:=x+h;LineTo(round(x*k),roun B(i-
d(y*k)); 1);x=x+h;x=x+h;lineto((double)x*k,(doub
D(i- le)y*k);
1);x:=x+h;y:=y+h;LineTo(round(x*k),roun D(i-
d(y*k)); 1);x=x+h;y=y+h;lineto((double)x*k,(doub
A(i-1); le)y*k);
end; end; A(i-1); }}
procedure B(i:integer); void B(int i){
begin if(i>0) {
if(i>0) then begin B(i-1);x=x-h;y=y-
B(i-1);x:=x-h;y:=y- h;lineto((double)x*k,(double)y*k);
h;LineTo(round(x*k),round(y*k)); C(i-1);y=y-h;y=y-
C(i-1);y:=y-h;y:=y- h;lineto((double)x*k,(double)y*k);
h;LineTo(round(x*k),round(y*k)); A(i-1);x=x+h;y=y-
A(i-1);x:=x+h;y:=y- h;lineto((double)x*k,(double)y*k);
h;LineTo(round(x*k),round(y*k)); B(i-1); }}
B(i-1); void C(int i){
end; end; if(i>0) {
procedure C(i:integer); C(i-1);x=x-
begin h;y=y+h;lineto((double)x*k,(double)y*k)
if(i>0) then begin ;
C(i-1);x:=x- D(i-1);x=x-h;x=x-
h;y:=y+h;LineTo(round(x*k),round(y*k)); h;lineto((double)x*k,(double)y*k);
D(i-1);x:=x-h;x:=x- B(i-1);x=x-h;y=y-
h;LineTo(round(x*k),round(y*k)); h;lineto((double)x*k,(double)y*k);
B(i-1);x:=x-h;y:=y- C(i-1); }}
h;LineTo(round(x*k),round(y*k)); void D(int i){
C(i-1); if(i>0) {
end; end; D(i-
procedure D(i:integer); 1);x=x+h;y=y+h;lineto((double)x*k,(doub
begin le)y*k);
if(i>0) then begin A(i-
D(i- 1);y=y+h;y=y+h;lineto((double)x*k,(doub
1);x:=x+h;y:=y+h;LineTo(round(x*k),roun le)y*k);
d(y*k)); C(i-1);x=x-

42
A(i- h;y=y+h;lineto((double)x*k,(double)y*k)
1);y:=y+h;y:=y+h;LineTo(round(x*k),roun ;
d(y*k)); D(i-1); }}
C(i-1);x:=x- void main(void){
h;y:=y+h;LineTo(round(x*k),round(y*k)); clrscr();
D(i-1); int gdriver = DETECT, gmode,
end; end; errorcode;
begin initgraph(&gdriver, &gmode,
Gd := Detect; "c:\\tcpp\\bgi");
InitGraph(Gd, Gm, 'C:\BP\BGI'); errorcode = graphresult();
ErrCode:=GraphResult; if (errorcode != grOk){
if ErrCode = grOk then printf("Graphics error: %s\n",
begin grapherrormsg(errorcode));
i:=0; h:=Cadru div 4; x:=3*h; printf("Press any key to halt:");
y:=3*h; k:=SizeWin/Cadru; getch();
repeat }else{
i:=i+1; x:=x-h; h:=h div 2; setbkcolor(15); i=0; h=div(Cadru,
y:=y+h; 4).quot; x=3*h; y=3*h;
HighVideo; SetColor(i); k=(double)SizeWin/Cadru;
SetLineStyle(SolidLn, 0, 1); do{ i=i+1; x=x-h; h=div(h, 2).quot;
MoveTo(round(x*k),round(y*k)); y=y+h;
A(i);x:=x+h;y:=y- setcolor(i);
h;LineTo(round(x*k),round(y*k)) setlinestyle(SOLID_LINE, 1, 1);
; B(i);x:=x-h;y:=y- moveto((double)x*k,(double)y*k);
h;LineTo(round(x*k),round(y*k)) A(i);x=x+h;y=y-
; C(i);x:=x- h;lineto((double)x*k,
h;y:=y+h;LineTo(round(x*k),round(y*k)); (double)y*k); B(i);x=x-h;y=y-
h;lineto((double)x*k,
D(i);x:=x+h;y:=y+h;LineTo(round(x*k),ro (double)y*k); C(i);x=x-
und(y*k)); h;y=y+h;lineto((double)x*k,(double)y*k)
until (i=n); ;
end
else D(i);x=x+h;y=y+h;lineto((double)x*k,(do
writeln('Eroare: ', uble)y*k); }
GraphErrorMsg(ErrCode)); while (!(i==n));
Readln; CloseGraph; getch(); }
end. closegraph();}

Rezultat program Pascal recursiv Rezultat program C recursiv


N=4 N=6

43
Problema 26

Covorul Sierpinski.
Vom considera o functie recursiva denumita SerpCov(), cu 3 parametri:
1. x,y-coordonatele centrului;
2. r-latura patratului central.
daca r>0, vom apela recursiv functia SerpCov() de 4 ori, pentru a desena fractalii corespunzatori celor
4 colturi ale patratului de latura r și cu centrul în punctul de coordonate (x,y);

Program Pascal recursiv-indirect Program C recursiv-indirect


Program CovorulSerpinski; #include <graphics.h>
uses graph,crt; #include <conio.h>
var L,gd,gm, ErrCode, n:integer; #include <stdlib.h>
xmax,ymax:integer; #include <stdio.h>
procedure SerpCov(x:integer; y:integer; #include <dos.h>
r:integer); int n=100;
begin void SerpCov(int x, int y, int r){
delay(1); delay(1);
if(r>0) then if(r>0){// 4 colturi
begin SerpCov(x-r, y+r, r/2);
SerpCov(x-r, y+r, Trunc(r/2)); SerpCov(x-r, y-r, r/2);
SerpCov(x-r, y-r, Trunc(r/2)); SerpCov(x+r, y-r, r/2);
SerpCov(x+r, y-r, Trunc(r/2)); SerpCov(x+r, y+r, r/2);
SerpCov(x+r, y+r, Trunc(r/2)); //fillellipse(x, y, r/2, r/2);
bar(Trunc(x-r/2), Trunc(y-r/2), bar(x-r/2, y-r/2, x+r/2,
Trunc(x+r/2), Trunc(y+r/2)); y+r/2);//peste patrat
end; }
end; }
begin void main(void){
write('n= '); readln(n); clrscr();
Gd := Detect; int gdriver = DETECT, gmode,
InitGraph(Gd, Gm, 'C:\BP\BGI'); errorcode;
ErrCode:=GraphResult; initgraph(&gdriver, &gmode,
if ErrCode = grOk then "c:\\tcpp\\bgi");
begin errorcode = graphresult();
SetBkColor(15); if (errorcode != grOk){
SetLineStyle(SolidLn, 0, 3); printf("Graphics error: %s\n",
setfillstyle(SolidFill,1); grapherrormsg(errorcode));
SerpCov(Trunc(getmaxx/2), printf("Press any key to halt:");
Trunc(getmaxy/2), n); getch();
end }else{
else setbkcolor(15);
writeln('Eroare: ', setfillstyle(SOLID_FILL,1);
GraphErrorMsg(ErrCode)); SerpCov(getmaxx()/2, getmaxy()/2,
Readln; n);
CloseGraph; getch();
end. }
closegraph();
}

44
Rezultat program Pascal recursiv Rezultat program C recursiv
N=4 N=6

45
Problema 27

Curba lui Koch pentru un triunghi echilateral.


Se consideră un triunghi echilateral. Fiecare latură a sa se transformă aşa cum se vede în figura
următoare (se împarte în trei segmente congruente, se elimină segmentul din mijloc şi se
construieşte deasupra un triunghi echilateral):

Exemplu de transformare

Program Pascal recursiv-indirect Program C recursiv-indirect


Program #include <graphics.h>
CurbaKochPentruTriunghiEchilateral; #include <iostream.h>
uses graph,crt; #include <stdlib.h>
var L,gd,gm, ErrCode, ls:integer; #include <conio.h>
xmax,ymax:integer; #include <stdio.h>
procedure initg; #include <math.h>
begin int gdriver,gmode, errorcode,ls,L;
end; void rotplan(int xc,int yc, int x1, int
procedure rotplan(xc,yc,x1, y1:integer; y1,int &x,
var x,y:integer; unghi:real); int &y,float unghi)
begin { x = ceil(xc+(x1-xc)*cos(unghi)- (y1-
x := round(xc+(x1-xc)* yc)*sin(unghi));
cos(unghi)-(y1-yc)* y = ceil(yc+(x1-xc)*sin(unghi)+ (y1-
sin(unghi)); yc)*cos(unghi));
y := round(yc+(x1-xc)* }
sin(unghi)+(y1-yc)* void desenez(int x1,int y1, int x2,int
cos(unghi)) y2,int x3,int y3) {
end; moveto(x1,y1);
procedure desenez(x1,y1,x2, lineto(div((2*x1+x2),3).quot,
y2,x3,y3:integer); div((2*y1+y2),3).quot);
begin lineto(x3,y3);
moveto(x1,y1); lineto(div((x1+2*x2),3).quot,
lineto((2*x1+x2) div 3, div((y1+2*y2),3).quot);
(2*y1+y2) div 3); lineto(x2,y2); }
lineto(x3,y3); void generator(int x1,int y1, int
lineto((x1+2*x2) div 3, x2,int y2,int n, int ls) {
(y1+2*y2) div 3); int x,y;
lineto(x2,y2); rotplan(div((2*x1+x2),3).quot,
end; div((2*y1+y2),3).quot,
procedure generator(x1,y1,x2,y2, div((x1+2*x2),3).quot,
n,ls:integer); div((y1+2*y2),3).quot,
var x,y:integer; x,y,M_PI/3);
begin if (n<ls)
rotplan((2*x1+x2) div 3, {generator(x1,y1,div((2*x1+x2),
(2*y1+y2) div 3,(x1+2*x2) div 3).quot,div((2*y1+y2),
3,(y1+2*y2) div 3,x,y,pi/3); 3).quot,n+1,ls);
if n<ls then generator(div((2*x1+x2),
begin 3).quot,div((2*y1+y2),
generator(x1,y1,(2*x1+x2) div 3).quot,x,y,n+1,ls);
3,(2*y1+y2) div 3, n+1,ls); generator(x,y,div((x1+2*x2),
generator((2*x1+x2) div 3, (2*y1+y2) 3).quot,div((y1+2*y2),
div 3, x,y,n+1,ls); 3).quot,n+1,ls);
generator(x,y,(x1+2*x2) div generator(div((x1+2*x2),
3,(y1+2*y2) div 3,n+1,ls); 3).quot,div((y1+2*y2),
generator((x1+2*x2) div 3, (y1+2*y2) 3).quot,x2,y2,n+1,ls);
46
div 3, x2,y2,n+1,ls); }
end else desenez(x1,y1,x2,y2,x,y);
else desenez(x1,y1,x2,y2,x,y); }
end; void main(){ cout<<"ls= "; cin>>ls;
begin clrscr();
write('ls= '); readln(ls); gdriver = DETECT, gmode;
initg; initgraph(&gdriver, &gmode,
Gd := Detect; "c:\\tcpp\\bgi");
InitGraph(Gd, Gm, 'C:\BP\BGI'); errorcode = graphresult();
ErrCode:=GraphResult; if (errorcode != grOk){
if ErrCode = grOk then printf("Graphics error: %s\n",
begin grapherrormsg(errorcode));
SetBkColor(15); printf("Press any key to halt:");
SetLineStyle(SolidLn, 0, 3); getch();
setcolor(red); }else{
L:=getmaxx-320; setbkcolor(15);
generator(160,getmaxy-150, setfillstyle(SOLID_FILL,1);
160+L,getmaxy-150,1,ls); setcolor(RED);
generator(160+L,getmaxy-150, 160+L setlinestyle(SOLID_LINE, 0, 3);
div 2,getmaxy-150 - L = getmaxx()-320;
L*round(sqrt(3)/2),1,ls); generator(160,getmaxy()-150,
generator(160+L div 2,getmaxy- 150- 160+L,getmaxy()-150,1,ls);
L*round(sqrt(3)/2),160, generator(160+L,getmaxy()-
getmaxy-150,1,ls); 150,160+div(L,2).quot
setfillstyle(1,green); , getmaxy()-150-
floodfill(getmaxx div 2, ceil(L*(sqrt(3)/2)),1,ls);
getmaxy div 2, red); generator(160+div(L,2).quot,
end getmaxy()-150-
else ceil(L*(sqrt(3)/2)),160,
writeln('Eroare: ', getmaxy()-150,1,ls);
GraphErrorMsg(ErrCode)); setfillstyle(1,GREEN);
Readln; floodfill(div(getmaxx(),2)
CloseGraph; .quot,div(getmaxx(),
end. 2).quot,RED);
getch();
}
closegraph();
}

Rezultat program Pascal recursiv Rezultat program C recursiv


N=2 N=4

47
Problema 28

Arborele.
Se dă un segment AB. Cu ajutorul lui se construieşte un arbore, aşa cum se vede în figura de mai
jos:

Exemplu de transformare în cazul unui arbore

Program Pascal recursiv-indirect Program C recursiv-indirect


Program Arbore; #include <graphics.h>
uses graph,crt; #include <iostream.h>
var L,gd,gm, ErrCode, ls:integer; #include <stdlib.h>
xmax,ymax:integer; #include <conio.h>
procedure initg; #include <stdio.h>
begin #include <math.h>
end; int gdriver,gmode, errorcode,ls,L;
procedure rotplan(xc,yc,x1, y1:integer; void rotplan(int xc,int yc,
var x,y:integer; unghi:real); int x1, int y1,int &x,
begin int &y,float unghi)
x := round(xc+(x1-xc)* { x = ceil(xc+(x1-xc)*cos(unghi)-
cos(unghi)-(y1-yc)* (y1-yc)*sin(unghi));
sin(unghi)); y = ceil(yc+(x1-xc)*sin(unghi)+
y := round(yc+(x1-xc)* (y1-yc)*cos(unghi));
sin(unghi)+(y1-yc)* }
cos(unghi)) void desenez(int x1,int y1, int x2,int
end; y2,int n,int ls)
procedure desenez(x1,y1,x2,y2, { int x,y;
n,ls:integer); if (n<=ls)
var x,y:integer; {
begin setcolor(1+random(14));
if n<=ls then setcolor(1);
begin moveto(x1,y1);
{setcolor(1+random(14));} lineto(x2,y2);
setcolor(1); rotplan(x2,y2,div(3*x2-
moveto(x1,y1); x1,2).quot,div(3*y2-
lineto(x2,y2); y1,2).quot,x,y,M_PI/4);
rotplan(x2,y2,(3*x2-x1) div desenez(x2,y2,x,y,n+1,ls);
2,(3*y2-y1) div 2,x,y,pi/4); rotplan(x2,y2,div(3*x2-
desenez(x2,y2,x,y,n+1,ls); x1,2).quot,div(3*y2-y1, 2).quot,x,y,-
rotplan(x2,y2,(3*x2-x1) div M_PI/4);
2,(3*y2-y1) div 2,x,y,-pi/4); desenez(x2,y2,x,y,n+1,ls);
desenez(x2,y2,x,y,n+1,ls); }
end }
end; void main()
begin { randomize(); clrscr();
randomize; cout<<"ls= "; cin>>ls;
write('ls= '); readln(ls); gdriver = DETECT, gmode;
initg; initgraph(&gdriver, &gmode,
Gd := Detect; "c:\\tcpp\\bgi");
InitGraph(Gd, Gm, 'C:\BP\BGI'); errorcode = graphresult();
ErrCode:=GraphResult; if (errorcode != grOk){
if ErrCode = grOk then printf("Graphics error: %s\n",
begin grapherrormsg(errorcode));

48
SetBkColor(15); printf("Press any key to halt:");
SetLineStyle(SolidLn, 0, 1); getch();
desenez(getmaxx div 2, getmaxy, }else{
getmaxx div 2, getmaxy-250,1,ls); setbkcolor(15);
end setlinestyle(SOLID_LINE, 1, 1);
else desenez(div(getmaxx(),2).quot,
writeln('Eroare: ', getmaxy(), div(getmaxx(),2).quot,
GraphErrorMsg(ErrCode)); getmaxy()-250, 1, ls);
Readln; getch();
CloseGraph; }
end. closegraph();
}

Rezultat program Pascal recursiv Rezultat program C recursiv


N=4 N=8

49
Problema 29

Generarea permutărilor.
Permutări a mulțimii A cu n elemente sunt toate mulțimele ordonate care se pot forma cu cele n
elemente ale lui A. Să se elaboreze un program care afișează toate permutările unei mulțimi cu
elemente de la 1 la n numere. În pascal și c++, metoda recursivă.

Program Pascal recursiv-indirect Program C recursiv-indirect


Program Permutari; #include <iostream.h>
uses crt; #include <conio.h>
var n, nn:integer; #include <iomanip.h>
sol:array [1..10] of integer; int n, nn, sol[10];
procedure init(k:integer); void init(int k){
begin sol[k]=0;
sol[k]:=0 }
end; int succesor(int k){
function succesor (k:integer):boolean; if (sol[k]<n){
begin sol[k]++;
if sol[k]<n then return 1;
begin }
sol[k]:=sol[k]+1; succesor:=true else return 0;
end }
else succesor:=false int valid(int k){
end; int i, ev=1;
function valid (k:integer):boolean; for (i=1;i<=k-1;i++)
var i:integer; if (sol[k]==sol[i]) ev=0;
begin return ev;
valid:=true; }
for i:=1 to k-1 do int solutie(int k){
if sol[i]=sol[k] then return k==n+1;
valid:=false }
end; void tipar(){
function solutie (k:integer):boolean; nn++;
begin cout<<setw(4)<<nn<<": ";
solutie:=(k=n+1) for (int i=1;i<=n;i++)
end; cout<<setw(3)<<sol[i];
procedure tipar; cout<<endl;
var i:integer; }
begin void back(int k){
nn:=nn+1; write(nn:4,'. '); if (solutie(k)) tipar();
for i:=1 to n do write(sol[i]:3); else{
writeln init(k);
end; while(succesor(k))
procedure back(k:integer); if (valid(k)) back(k+1);
begin }
if solutie(k) }
then tipar main(){
else nn=0;
begin clrscr();
init(k); cout<<"Afisare permutari."<<endl;
while succesor(k) do cout<<"Rezolvare prin metoda
if valid(k) then back(k+1) BACKTRACKING."<<endl;
end cout<<"Introdu numarul de elemente
end; n="; cin>>n;
begin back(1);
clrscr; nn:=0; }
50
writeln('Afisare permutari.');
writeln('Rezolvare prin metoda
BACKTRACKING.');
write('introdu numarul de elemente
n='); readln(n);
back(1)
end.

Rezultat program Pascal recursiv Rezultat program C recursiv

51
Problema 30

Generarea aranjamentelor.
Se dau două mulţimi A={1,2,...,p} şi B={1,2,...,n}. Se cer toate funcţiile injective definite pe A cu
p
valori în B. O astfel de problemă este una de generare a aranjamentelor de n luate câte p (A n).
Să se elaboreze un program care afișează toate aranjamentele unei mulțimi cu elemente de la 1 la n
numere a câte p. În pascal și c++, metoda recursivă.
Exemplu: p=2, n=3. Avem: 12, 21, 13, 31, 23, 32.

Program Pascal recursiv-indirect Program C recursiv-indirect


Program Aranjamente; #include <iostream.h>
uses crt; #include <conio.h>
var sol:array[1..9] of integer; #include <iomanip.h>
n, nn, p:integer; int n, nn, p, sol[10];
function valid(k:integer):boolean; int valid(int k){
var i:integer; for (int i=1;i<k;i++)
begin if (sol[k]==sol[i])
valid:=true; return 0;
for i:=1 to k-1 do return 1;
if sol[k]=sol[i] then }
valid:=false void back(int k){
end; int i,j;
procedure back(k:integer); if (k==p+1){
var i,j:integer; nn++;
begin cout<<setw(4)<<nn<<": ";
if k=p+1 then for (int i=1;i<=p;i++)
begin cout<<setw(3)<<sol[i];
nn:=nn+1; cout<<endl;
write(nn:4,'. '); }else
for i:=1 to p do for (i=1;i<=n;i++){
write(sol[i]:3); sol[k]=i;
writeln if (valid(k))
end back(k+1);
else }
for i:=1 to n do }
begin void main()
sol[k]:=i; {
if valid(k) then nn=0;
back(k+1) clrscr();
end cout<<"Afisare aranjamente."<<endl;
end; cout<<"Rezolvare prin metoda
begin BACKTRACKING."<<endl;
clrscr; nn:=0; cout<<"Introdu numarul de elemente
writeln('Afisare aranjamente.'); n="; cin>>n;
writeln('Rezolvare prin metoda cout<<"aranjamente luate cite p=";
BACKTRACKING.'); cin>>p;
write('introdu numarul de elemente back(1);
n='); readln(n); }
write('aranjamente luate cite p=');
readln(p);
back(1)
end.

52
Rezultat program Pascal recursiv Rezultat program C recursiv

53
Problema 31

Generarea combinărilor.
Fiind dată mulţimea A={1,2,...,n}, se cer toate submulţimile ei cu p elemente. Deci “generarea
combinărilor de n, luate câte p”. De exemplu, dacă n=4 şi p=3, soluţiile sunt următoarele: {1,2,3},
{1,2,4}, {1,3,4} şi {2,3,4}.
Să se elaboreze un program care afișează toate combinările unei mulțimi cu elemente de la 1 la n
numere a câte p. În pascal și c++, metoda recursivă.

Program Pascal recursiv-indirect Program C recursiv-indirect


Program Combinari; #include <iostream.h>
uses crt; #include <conio.h>
var sol:array[1..9] of integer; #include <iomanip.h>
n, nn, p:integer; int n, nn, p, sol[10];
procedure back(k:integer); void back(int k)
var i:integer; { int i;
begin if (k==p+1){
if k=p+1 then nn++;
begin cout<<setw(4)<<nn<<": ";
nn:=nn+1; for (int i=1;i<=p;i++)
write(nn:4,'. '); cout<<setw(3)<<sol[i];
for i:=1 to p do cout<<endl;
write(sol[i]:3); }else{
writeln if (k>1) sol[k]=sol[k-1];
end else sol[k]=0;
else while(sol[k]<n-p+k){
begin sol[k]++;
if k>1 then sol[k]:=sol[k-1] back(k+1);
else sol[k]:=0; }
while sol[k]<n-p+k do }
begin }
sol[k]:=sol[k]+1; void main()
back(k+1); {
end nn=0;
end clrscr();
end; cout<<"Afisare combinari."<<endl;
begin cout<<"Rezolvare prin metoda
clrscr; BACKTRACKING."<<endl;
nn:=0; cout<<"Introdu numarul de elemente
writeln('Afisare combinari.'); n="; cin>>n;
writeln('Rezolvare prin metoda cout<<"Combinari luate cite p=";
BACKTRACKING.'); cin>>p;
write('introdu numarul de elemente back(1);
n='); readln(n); }
write('Combinări luate cite p=');
readln(p);
back(1)
end.

54
Rezultat program Pascal recursiv Rezultat program C recursiv

55
Problema 32
Problema celor n dame.
Fiind dată o tablă de şah cu dimensiunea n×n, se cer toate soluţiile de aranjare a n dame, astfel încât
să nu se afle două dame pe aceeaşi linie, coloană sau diagonală (damele să nu se atace reciproc). De
exemplu, dacă n=4, o soluţie este reprezentată în figura de mai jos:

Program Pascal recursiv-indirect Program C recursiv-indirect


Program ProblemaDamelor; #include<iostream.h>
uses crt; #include<math.h>
var sol:array[1..9] of integer; n, #include<stdlib.h>
nn:integer; #include<conio.h>
function valid(k:integer):boolean; #include<iomanip.h>
var i:integer; int t[20], n, a, nn;
begin void tipar(){
valid:=true; if(((nn%20)==0)&&(nn>0)){
for i:=1 to k-1 do cout<<"Pentru continuare actionati
if (sol[k]=sol[i]) or (abs(sol[k]- orice buton..."<<endl;
sol[i])=abs(k-i)) then getch(); clrscr();
valid:=false }
end; nn++;
procedure back(k:integer); cout<<setw(4)<<nn<<". ";
var i:integer; for(int i=1;i<=n;i++)
begin cout<<t[i]<<" ";
if k=n+1 then cout<<endl;
begin {tipar} }
if(((nn mod 20)=0)and(nn>0)) then void dame(int k){
begin int i,j, corect;
writeln('Pentru continuare if(k==n+1){
actionati enter...'); readln; clrscr; tipar();
end; }else{
nn:=nn+1; write(nn:3,'. '); for(i=t[k]+1;i<=n;i++){
for i:=1 to n do t[k]=i; corect=1;
write(sol[i]:2); for(j=1;j<=k-1;j++){
writeln; if(t[j]==t[k] || abs(t[k]-
end t[j])==(k-j)) {corect=0;}
else }
begin if(corect==1) { dame(k+1);}
sol[k]:=0; {init} }
while sol[k]<n do{succesor} }
begin t[k]=0;a=t[k];
sol[k]:=sol[k]+1; }
if valid(k) then back(k+1) void main(){ clrscr();
end cout<<"Afisare celor n dame."<<endl;
end cout<<"Rezolvare prin metoda
end; BACKTRACKING."<<endl;
begin cout<<"Introdu numarul de dame n=
clrscr; nn:=0; ";cin>>n;
writeln('Afisare celor n dame.'); nn=0;
writeln('Rezolvare prin metoda dame(1);
BACKTRACKING.'); cout<<"Pentru finalizare actionati
56
write('Introdu numarul de dame n= '); orice buton..."<<endl;
readln(n); getch();
back(1); }
writeln('Pentru finalizare actionati
enter...'); readln
end.

Rezultat program Pascal recursiv Rezultat program C recursiv

57
Problema 33

Problema colorării hărţilor.


Fiind dată o hartă cu n ţări, se cere o soluţie de colorare a hărţii, utilizând cel mult 4 culori, astfel
încât două ţări cu frontieră comună să fie colorate diferit. Este demonstrat faptul că sunt suficiente
numai 4 culori pentru ca orice hartă să poată fi colorată.
Pentru exemplificare, vom considera harta din figura de mai jos, unde 1
ţările sunt numerotate cu cifre cuprinse între 1 şi 5. Pentru simplitate,
4
vom renunţa la programarea structurată şi vom opri în mod forţat 2
programul.
 În Pascal, veţi utiliza procedura halt. 3
 În C++, veţi folosi funcţia exit, cu parametrul EXIT_SUCCESS (o 4 5
constantă). Pentru a o putea utiliza, trebuie să includem fişierul antet
“stdlib.h“: #include<stdlib.h>. 4

Program Pascal recursiv-indirect Program C recursiv-indirect


program colorare_harta; #include <iostream.h>
type stiva = array[1..100] of integer; #include <iomanip.h>
var st: stiva; #include <conio.h>
i,j,n,k, variante:integer; int st[10], a[20][20], n, k, nn;
es, ev: boolean; void init(){
a: array[1..20, 1..20] of integer; st[k]=0;
procedure init(k: integer; var st:stiva }
); int am_succesor(){
begin if(st[k]<4){
st[k]:= 0; st[k]++;
end; return 1;
procedure succesor(var es: boolean; var }else{
st: stiva; k:integer); return 0;
begin }
if (st[k]<4) then }
begin int e_valid(){
st[k]:= st[k] + 1; for(int i=1; i<=k-1; i++)
es:= true; if(st[k]==st[i] && a[i][k]==1)
end return 0;
else es:= false; return 1;
end; }
procedure valid(var ev:boolean; int solutie(){
st:stiva; k:integer); return k==n;
var i:integer; }
begin void tipar(){
ev:= true; nn++;
for i:=1 to k-1 do cout<<setw(3)<<nn<<". ---------------
if( st[i] = st[k] ) and ( a[i,k]= ---"<<endl;
1) then ev:= false; for(int i=1; i<=n; i++){
end; cout<<"Tara "<<i<<", culoarea
function solutie(k:integer):boolean; "<<st[i]<<endl;
begin }
solutie:= ( k = n ) }
end; void back(){
procedure tipar; int as;
var i:integer; k=1;
begin init();
for i:= 1 to n do while(k>0){
58
writeln('Tara = ', i, '; do{
culoarea=', st[i]); }while((as=am_succesor()) &&
writeln('-------------------- '); (!e_valid()));
variante:= variante + 1; if(as){
end; if(solutie()) tipar();
Begin else{
variante:=0; k++;
write('Numarul de tari= '); init();
readln(n); }
for i:= 1 to n do }else{k--;}
for j:= 1 to i-1 do begin }
write('a[',i,',',j,']='); }
readln(a[i,j]); void main(){
a[j,i]:= a[i,j]; int i, j;
end; clrscr();
k:=1; cout<<"Introdu numarul de tari:
init(k, st); ";cin>>n;
while k > 0 do begin for(i=1; i<=n; i++){
repeat succesor(es, st, k); for(j=1; j<=(i-1); j++){
if es then valid(ev, st, k); cout<<"a["<<i<<", "<<j<<"]= ";
until (not es) or (es and ev); cin>>a[i][j];
if es then a[j][i]=a[i][j];
if solutie(k) then tipar }
else begin }
k:= k + 1; nn=0;
init(k, st); back();
end }
else k:= k - 1;
end;
writeln('Toatal variante: ',variante);
readln;
End.

Rezultat program Pascal recursiv Rezultat program C recursiv


Numarul de tari= 5 -------------------- Tara = 5; culoarea=1

a[2,1]=1 Tara = 1; culoarea=1 --------------------


a[3,1]=0 Tara = 2; culoarea=2 Tara = 1; culoarea=1
a[3,2]=1 Tara = 3; culoarea=3 Tara = 2; culoarea=2
a[4,1]=1 Tara = 4; culoarea=3 Tara = 3; culoarea=4
a[4,2]=1 Tara = 5; culoarea=1 Tara = 4; culoarea=4
a[4,3]=0 -------------------- Tara = 5; culoarea=1
a[5,1]=0 Tara = 1; culoarea=1 --------------------
a[5,2]=1 Tara = 2; culoarea=2 Tara = 1; culoarea=1
a[5,3]=1 Tara = 3; culoarea=3 Tara = 2; culoarea=2
a[5,4]=1 Tara = 4; culoarea=3 Tara = 3; culoarea=4
-------------------- Tara = 5; culoarea=4 Tara = 4; culoarea=4
Tara = 1; culoarea=1 -------------------- Tara = 5; culoarea=3
Tara = 2; culoarea=2 Tara = 1; culoarea=1 --------------------
Tara = 3; culoarea=1 Tara = 2; culoarea=2 Tara = 1; culoarea=1
Tara = 4; culoarea=3 Tara = 3; culoarea=3 Tara = 2; culoarea=3
Tara = 5; culoarea=4 Tara = 4; culoarea=4 Tara = 3; culoarea=1
-------------------- Tara = 5; culoarea=1 Tara = 4; culoarea=2
Tara = 1; culoarea=1 -------------------- Tara = 5; culoarea=4
Tara = 2; culoarea=2 Tara = 1; culoarea=1 --------------------
Tara = 3; culoarea=1 Tara = 2; culoarea=2 Tara = 1; culoarea=1
Tara = 4; culoarea=4 Tara = 3; culoarea=4 Tara = 2; culoarea=3
Tara = 5; culoarea=3 Tara = 4; culoarea=3 Tara = 3; culoarea=1
59
Tara = 4; culoarea=4 Tara = 3; culoarea=2 Tara = 2; culoarea=1
Tara = 5; culoarea=2 Tara = 4; culoarea=2 Tara = 3; culoarea=4
-------------------- Tara = 5; culoarea=3 Tara = 4; culoarea=3
Tara = 1; culoarea=1 -------------------- Tara = 5; culoarea=2
Tara = 2; culoarea=3 Tara = 1; culoarea=1 --------------------
Tara = 3; culoarea=2 Tara = 2; culoarea=4 Tara = 1; culoarea=2
Tara = 4; culoarea=2 Tara = 3; culoarea=2 Tara = 2; culoarea=1
Tara = 5; culoarea=1 Tara = 4; culoarea=3 Tara = 3; culoarea=4
-------------------- Tara = 5; culoarea=1 Tara = 4; culoarea=4
Tara = 1; culoarea=1 -------------------- Tara = 5; culoarea=2
Tara = 2; culoarea=3 Tara = 1; culoarea=1 --------------------
Tara = 3; culoarea=2 Tara = 2; culoarea=4 Tara = 1; culoarea=2
Tara = 4; culoarea=2 Tara = 3; culoarea=3 Tara = 2; culoarea=1
Tara = 5; culoarea=4 Tara = 4; culoarea=2 Tara = 3; culoarea=4
-------------------- Tara = 5; culoarea=1 Tara = 4; culoarea=4
Tara = 1; culoarea=1 -------------------- Tara = 5; culoarea=3
Tara = 2; culoarea=3 Tara = 1; culoarea=1 --------------------
Tara = 3; culoarea=2 Tara = 2; culoarea=4 Tara = 1; culoarea=2
Tara = 4; culoarea=4 Tara = 3; culoarea=3 Tara = 2; culoarea=3
Tara = 5; culoarea=1 Tara = 4; culoarea=3 Tara = 3; culoarea=1
-------------------- Tara = 5; culoarea=1 Tara = 4; culoarea=1
Tara = 1; culoarea=1 -------------------- Tara = 5; culoarea=2
Tara = 2; culoarea=3 Tara = 1; culoarea=1 --------------------
Tara = 3; culoarea=4 Tara = 2; culoarea=4 Tara = 1; culoarea=2
Tara = 4; culoarea=2 Tara = 3; culoarea=3 Tara = 2; culoarea=3
Tara = 5; culoarea=1 Tara = 4; culoarea=3 Tara = 3; culoarea=1
-------------------- Tara = 5; culoarea=2 Tara = 4; culoarea=1
Tara = 1; culoarea=1 -------------------- Tara = 5; culoarea=4
Tara = 2; culoarea=3 Tara = 1; culoarea=2 --------------------
Tara = 3; culoarea=4 Tara = 2; culoarea=1 Tara = 1; culoarea=2
Tara = 4; culoarea=4 Tara = 3; culoarea=2 Tara = 2; culoarea=3
Tara = 5; culoarea=1 Tara = 4; culoarea=3 Tara = 3; culoarea=1
-------------------- Tara = 5; culoarea=4 Tara = 4; culoarea=4
Tara = 1; culoarea=1 -------------------- Tara = 5; culoarea=2
Tara = 2; culoarea=3 Tara = 1; culoarea=2 --------------------
Tara = 3; culoarea=4 Tara = 2; culoarea=1 Tara = 1; culoarea=2
Tara = 4; culoarea=4 Tara = 3; culoarea=2 Tara = 2; culoarea=3
Tara = 5; culoarea=2 Tara = 4; culoarea=4 Tara = 3; culoarea=2
-------------------- Tara = 5; culoarea=3 Tara = 4; culoarea=1
Tara = 1; culoarea=1 -------------------- Tara = 5; culoarea=4
Tara = 2; culoarea=4 Tara = 1; culoarea=2 --------------------
Tara = 3; culoarea=1 Tara = 2; culoarea=1 Tara = 1; culoarea=2
Tara = 4; culoarea=2 Tara = 3; culoarea=3 Tara = 2; culoarea=3
Tara = 5; culoarea=3 Tara = 4; culoarea=3 Tara = 3; culoarea=2
-------------------- Tara = 5; culoarea=2 Tara = 4; culoarea=4
Tara = 1; culoarea=1 -------------------- Tara = 5; culoarea=1
Tara = 2; culoarea=4 Tara = 1; culoarea=2 --------------------
Tara = 3; culoarea=1 Tara = 2; culoarea=1 Tara = 1; culoarea=2
Tara = 4; culoarea=3 Tara = 3; culoarea=3 Tara = 2; culoarea=3
Tara = 5; culoarea=2 Tara = 4; culoarea=3 Tara = 3; culoarea=4
-------------------- Tara = 5; culoarea=4 Tara = 4; culoarea=1
Tara = 1; culoarea=1 -------------------- Tara = 5; culoarea=2
Tara = 2; culoarea=4 Tara = 1; culoarea=2 --------------------
Tara = 3; culoarea=2 Tara = 2; culoarea=1 Tara = 1; culoarea=2
Tara = 4; culoarea=2 Tara = 3; culoarea=3 Tara = 2; culoarea=3
Tara = 5; culoarea=1 Tara = 4; culoarea=4 Tara = 3; culoarea=4
-------------------- Tara = 5; culoarea=2 Tara = 4; culoarea=4
Tara = 1; culoarea=1 -------------------- Tara = 5; culoarea=1
Tara = 2; culoarea=4 Tara = 1; culoarea=2 --------------------
60
Tara = 1; culoarea=2 -------------------- Tara = 5; culoarea=3
Tara = 2; culoarea=3 Tara = 1; culoarea=3 --------------------
Tara = 3; culoarea=4 Tara = 2; culoarea=1 Tara = 1; culoarea=3
Tara = 4; culoarea=4 Tara = 3; culoarea=2 Tara = 2; culoarea=2
Tara = 5; culoarea=2 Tara = 4; culoarea=2 Tara = 3; culoarea=3
-------------------- Tara = 5; culoarea=4 Tara = 4; culoarea=1
Tara = 1; culoarea=2 -------------------- Tara = 5; culoarea=4
Tara = 2; culoarea=4 Tara = 1; culoarea=3 --------------------
Tara = 3; culoarea=1 Tara = 2; culoarea=1 Tara = 1; culoarea=3
Tara = 4; culoarea=1 Tara = 3; culoarea=2 Tara = 2; culoarea=2
Tara = 5; culoarea=2 Tara = 4; culoarea=4 Tara = 3; culoarea=3
-------------------- Tara = 5; culoarea=3 Tara = 4; culoarea=4
Tara = 1; culoarea=2 -------------------- Tara = 5; culoarea=1
Tara = 2; culoarea=4 Tara = 1; culoarea=3 --------------------
Tara = 3; culoarea=1 Tara = 2; culoarea=1 Tara = 1; culoarea=3
Tara = 4; culoarea=1 Tara = 3; culoarea=3 Tara = 2; culoarea=2
Tara = 5; culoarea=3 Tara = 4; culoarea=2 Tara = 3; culoarea=4
-------------------- Tara = 5; culoarea=4 Tara = 4; culoarea=1
Tara = 1; culoarea=2 -------------------- Tara = 5; culoarea=3
Tara = 2; culoarea=4 Tara = 1; culoarea=3 --------------------
Tara = 3; culoarea=1 Tara = 2; culoarea=1 Tara = 1; culoarea=3
Tara = 4; culoarea=3 Tara = 3; culoarea=3 Tara = 2; culoarea=2
Tara = 5; culoarea=2 Tara = 4; culoarea=4 Tara = 3; culoarea=4
-------------------- Tara = 5; culoarea=2 Tara = 4; culoarea=4
Tara = 1; culoarea=2 -------------------- Tara = 5; culoarea=1
Tara = 2; culoarea=4 Tara = 1; culoarea=3 --------------------
Tara = 3; culoarea=2 Tara = 2; culoarea=1 Tara = 1; culoarea=3
Tara = 4; culoarea=1 Tara = 3; culoarea=4 Tara = 2; culoarea=2
Tara = 5; culoarea=3 Tara = 4; culoarea=2 Tara = 3; culoarea=4
-------------------- Tara = 5; culoarea=3 Tara = 4; culoarea=4
Tara = 1; culoarea=2 -------------------- Tara = 5; culoarea=3
Tara = 2; culoarea=4 Tara = 1; culoarea=3 --------------------
Tara = 3; culoarea=2 Tara = 2; culoarea=1 Tara = 1; culoarea=3
Tara = 4; culoarea=3 Tara = 3; culoarea=4 Tara = 2; culoarea=4
Tara = 5; culoarea=1 Tara = 4; culoarea=4 Tara = 3; culoarea=1
-------------------- Tara = 5; culoarea=2 Tara = 4; culoarea=1
Tara = 1; culoarea=2 -------------------- Tara = 5; culoarea=2
Tara = 2; culoarea=4 Tara = 1; culoarea=3 --------------------
Tara = 3; culoarea=3 Tara = 2; culoarea=1 Tara = 1; culoarea=3
Tara = 4; culoarea=1 Tara = 3; culoarea=4 Tara = 2; culoarea=4
Tara = 5; culoarea=2 Tara = 4; culoarea=4 Tara = 3; culoarea=1
-------------------- Tara = 5; culoarea=3 Tara = 4; culoarea=1
Tara = 1; culoarea=2 -------------------- Tara = 5; culoarea=3
Tara = 2; culoarea=4 Tara = 1; culoarea=3 --------------------
Tara = 3; culoarea=3 Tara = 2; culoarea=2 Tara = 1; culoarea=3
Tara = 4; culoarea=3 Tara = 3; culoarea=1 Tara = 2; culoarea=4
Tara = 5; culoarea=1 Tara = 4; culoarea=1 Tara = 3; culoarea=1
-------------------- Tara = 5; culoarea=3 Tara = 4; culoarea=2
Tara = 1; culoarea=2 -------------------- Tara = 5; culoarea=3
Tara = 2; culoarea=4 Tara = 1; culoarea=3 --------------------
Tara = 3; culoarea=3 Tara = 2; culoarea=2 Tara = 1; culoarea=3
Tara = 4; culoarea=3 Tara = 3; culoarea=1 Tara = 2; culoarea=4
Tara = 5; culoarea=2 Tara = 4; culoarea=1 Tara = 3; culoarea=2
-------------------- Tara = 5; culoarea=4 Tara = 4; culoarea=1
Tara = 1; culoarea=3 -------------------- Tara = 5; culoarea=3
Tara = 2; culoarea=1 Tara = 1; culoarea=3 --------------------
Tara = 3; culoarea=2 Tara = 2; culoarea=2 Tara = 1; culoarea=3
Tara = 4; culoarea=2 Tara = 3; culoarea=1 Tara = 2; culoarea=4
Tara = 5; culoarea=3 Tara = 4; culoarea=4 Tara = 3; culoarea=2
61
Tara = 4; culoarea=2 -------------------- Tara = 2; culoarea=2
Tara = 5; culoarea=1 Tara = 1; culoarea=4 Tara = 3; culoarea=4
-------------------- Tara = 2; culoarea=1 Tara = 4; culoarea=3
Tara = 1; culoarea=3 Tara = 3; culoarea=4 Tara = 5; culoarea=1
Tara = 2; culoarea=4 Tara = 4; culoarea=2 --------------------
Tara = 3; culoarea=2 Tara = 5; culoarea=3 Tara = 1; culoarea=4
Tara = 4; culoarea=2 -------------------- Tara = 2; culoarea=3
Tara = 5; culoarea=3 Tara = 1; culoarea=4 Tara = 3; culoarea=1
-------------------- Tara = 2; culoarea=1 Tara = 4; culoarea=1
Tara = 1; culoarea=3 Tara = 3; culoarea=4 Tara = 5; culoarea=2
Tara = 2; culoarea=4 Tara = 4; culoarea=3 --------------------
Tara = 3; culoarea=3 Tara = 5; culoarea=2 Tara = 1; culoarea=4
Tara = 4; culoarea=1 -------------------- Tara = 2; culoarea=3
Tara = 5; culoarea=2 Tara = 1; culoarea=4 Tara = 3; culoarea=1
-------------------- Tara = 2; culoarea=2 Tara = 4; culoarea=1
Tara = 1; culoarea=3 Tara = 3; culoarea=1 Tara = 5; culoarea=4
Tara = 2; culoarea=4 Tara = 4; culoarea=1 --------------------
Tara = 3; culoarea=3 Tara = 5; culoarea=3 Tara = 1; culoarea=4
Tara = 4; culoarea=2 -------------------- Tara = 2; culoarea=3
Tara = 5; culoarea=1 Tara = 1; culoarea=4 Tara = 3; culoarea=1
-------------------- Tara = 2; culoarea=2 Tara = 4; culoarea=2
Tara = 1; culoarea=4 Tara = 3; culoarea=1 Tara = 5; culoarea=4
Tara = 2; culoarea=1 Tara = 4; culoarea=1 --------------------
Tara = 3; culoarea=2 Tara = 5; culoarea=4 Tara = 1; culoarea=4
Tara = 4; culoarea=2 -------------------- Tara = 2; culoarea=3
Tara = 5; culoarea=3 Tara = 1; culoarea=4 Tara = 3; culoarea=2
-------------------- Tara = 2; culoarea=2 Tara = 4; culoarea=1
Tara = 1; culoarea=4 Tara = 3; culoarea=1 Tara = 5; culoarea=4
Tara = 2; culoarea=1 Tara = 4; culoarea=3 --------------------
Tara = 3; culoarea=2 Tara = 5; culoarea=4 Tara = 1; culoarea=4
Tara = 4; culoarea=2 -------------------- Tara = 2; culoarea=3
Tara = 5; culoarea=4 Tara = 1; culoarea=4 Tara = 3; culoarea=2
-------------------- Tara = 2; culoarea=2 Tara = 4; culoarea=2
Tara = 1; culoarea=4 Tara = 3; culoarea=3 Tara = 5; culoarea=1
Tara = 2; culoarea=1 Tara = 4; culoarea=1 --------------------
Tara = 3; culoarea=2 Tara = 5; culoarea=4 Tara = 1; culoarea=4
Tara = 4; culoarea=3 -------------------- Tara = 2; culoarea=3
Tara = 5; culoarea=4 Tara = 1; culoarea=4 Tara = 3; culoarea=2
-------------------- Tara = 2; culoarea=2 Tara = 4; culoarea=2
Tara = 1; culoarea=4 Tara = 3; culoarea=3 Tara = 5; culoarea=4
Tara = 2; culoarea=1 Tara = 4; culoarea=3 --------------------
Tara = 3; culoarea=3 Tara = 5; culoarea=1 Tara = 1; culoarea=4
Tara = 4; culoarea=2 -------------------- Tara = 2; culoarea=3
Tara = 5; culoarea=4 Tara = 1; culoarea=4 Tara = 3; culoarea=4
-------------------- Tara = 2; culoarea=2 Tara = 4; culoarea=1
Tara = 1; culoarea=4 Tara = 3; culoarea=3 Tara = 5; culoarea=2
Tara = 2; culoarea=1 Tara = 4; culoarea=3 --------------------
Tara = 3; culoarea=3 Tara = 5; culoarea=4 Tara = 1; culoarea=4
Tara = 4; culoarea=3 -------------------- Tara = 2; culoarea=3
Tara = 5; culoarea=2 Tara = 1; culoarea=4 Tara = 3; culoarea=4
-------------------- Tara = 2; culoarea=2 Tara = 4; culoarea=2
Tara = 1; culoarea=4 Tara = 3; culoarea=4 Tara = 5; culoarea=1
Tara = 2; culoarea=1 Tara = 4; culoarea=1 --------------------
Tara = 3; culoarea=3 Tara = 5; culoarea=3 Toatal variante: 96
Tara = 4; culoarea=3 --------------------
Tara = 5; culoarea=4 Tara = 1; culoarea=4

62
Problema 34

Umplerea unei suprafețe închise


Se dă o matrice binară, valorile 1 delimiteaza o anumita suprafata inchisa in cadrul matricei. Se stiu
de asemenea coordonatele x si y ale unui element al matriceu, specificand un punct din interiorul
acestei suprafete. Să se scrie un program Pascal si C/C++ care va umple o suprafata inchisa, fiind
cunoscute coordonatele unui punct situat in interiorul ei.

Date inițiale: Rezultat final:


1 0 1 1 1 0 1 1
1 0 0 0 1 0 0 0
1 0 1 1 1 0 1 1
1 0 1 1 1 0 1 1

Program Pascal recursiv-indirect Program C recursiv-indirect


program umplere; #include<iostream>
uses crt;
type vector = array[0..10,0..10] of int a[10][10],i,j,m,n,x,y;
integer; using namespace std;
var i,j,m,n,x,y:integer; void scriu(int x,int y,int a[10][10]){
a: vector; if(!a[x][y]){
procedure scriu(x:integer;y:integer;var a[x][y]=1;
a:vector); scriu(x+1,y,a);
begin scriu(x,y+1,a);
if (a[x,y]=0) then scriu(x-1,y,a);
begin scriu(x,y-1,a);
a[x,y]:=1; }
scriu(x+1,y,a); }
scriu(x,y+1,a);
scriu(x-1,y,a); int main(){
scriu(x,y-1,a); cout<<"m=";
end; cin>>m;
end; cout<<"n=";
begin cin>>n;
clrscr; for(i=1;i<=m;i++)
write('m='); for(j=1;j<=n;j++){
readln(m); cout<<"a["<<i<<","<<j<<"]=";
write('n='); cin>>a[i][j];
readln(n); }
for i:=1 to m do for(i=1;i<=n;i++){
for j:=1 to n do begin a[0][i]=1;
write('a[',i,',',j,']='); a[m+1][i]=1;
readln(a[i,j]); }
end; for(i=1;i<=m;i++){
for i:=1 to n do begin a[i][0]=1;
a[0,i]:=1; a[i][n+1]=1;
a[m+1,i]:=1; }
end; cout<<"x=";
for i:=1 to m do begin cin>>x;
a[i,0]:=1; cout<<"y=";
a[i,n+1]:=1; cin>>y;
end; for(i=1;i<=m;i++){
write('x='); for(j=1;j<=n;j++)
63
readln(x); cout<<a[i][j]<<" ";
write('y='); cout<<endl;
readln(y); }
for i:=1 to m do begin scriu(x,y,a);
for j:=1 to n do cout<<endl<<endl;
write(a[i,j],' '); for(i=1;i<=m;i++){
writeln; for(j=1;j<=n;j++)
end; cout<<a[i][j]<<" ";
scriu(x,y,a); cout<<endl;
writeln; }
writeln; }
for i:=1 to m do begin
for j:=1 to n do
write(a[i,j],' ');
writeln;
end;
readkey;
end.

Rezultat program Pascal recursiv Rezultat program C recursiv

64
Problema 35

Labirintul
Se dă un labirint sub formă de matrice cu m linii şi n coloane. Fiecare element al matricei
reprezintă o cameră a labirintului. Într-una din camere, de coordonate lin şi col, se găseşte un om. Se
cere să se găsească toate ieşirile din labirint. Nu este permis ca un drum să treacă de două ori prin
aceeaşi cameră. O primă problemă care se pune este precizarea modului de codificare a ieşirilor din
fiecare cameră a labirintului.
Fie l(i,j) un element al matricei. Acesta poate lua valori între 0 şi 15. Se consideră ieşirile spre
nord, est, sud şi vest, luate în această ordine. Pentru fiecare direcţie cu ieşire se
reţine 1, iar în caz contrar, se reţine 0. Un şir de patru cifre 1 sau 0 formează un
număr în baza 2. Acest număr este convertit în baza 10 şi reţinut în l(i,j). De
exemplu, pentru o cameră care are ieşire în nord şi vest, avem 1001 (2) =9 (10).

Program Pascal recursiv-indirect Program C recursiv-indirect


program labirint; #include <iostream.h>
uses crt; int sol[100][2],l[10][10],
var sol:array [1..100,1..2] of m,n,i,j,lin,col;
integer; int vizitat(int k,int lin,
l:array [0..10,0..10] of int col)
integer; { int v=0;
m,n,i,j,lin,col:integer; for (i=1;i<=k;i++)
function vizitat(k,lin, if (sol[i][0]==lin &&
col:integer):boolean; sol[i][1]==col) v=1;
begin return v;
vizitat:=false; }
for i:=1 to k-1 do void tipar(int k,int lin,
if (sol[i,1]=lin) and int col)
(sol[i,2]=col) { cout <<" Solutie "<<endl;
then vizitat:=true; for (i=1;i<=k-1;i++)
end; cout<<sol[i][0]<<" "
procedure <<sol[i][1]<<endl;
tipar(k,lin,col:integer); if (lin==0)
begin cout<<"iesire prin nord"
writeln('Solutie'); <<endl;
for i:=1 to k-1 do else
writeln(sol[i,1],' ', if (lin==m+1)
sol[i,2]); cout<<"iesire prin sud"
if lin=0 then <<endl;
writeln('iesire prin nord') else
else if (col==0)
if lin=m+1 then cout<<"iesire prin vest"
writeln('iesire prin sud') <<endl;
else else
if col=0 then cout<<"iesire prin est"
writeln('iesire prin vest') <<endl;
else }
writeln('iesire prin est'); void back(int k, int lin,
readln; int col)
end; { if (lin==0 || lin==m+1 ||
procedure col==0 || col==n+1)
back(k,lin,col:integer); tipar(k,lin,col);
var i:integer; else
begin {
65
if (lin=0) or (lin=m+1) or sol[k][0]=lin;
(col=0) or (col=n+1) sol[k][1]=col;
then tipar(k,lin,col) for (int i=1;i<=4;i++)
else switch(i)
begin {
sol[k,1]:=lin; case 1:
sol[k,2]:=col; if (l[lin][col] & 8 &&
for i:=1 to 4 do ! vizitat(k, lin-1,col))
case i of back(k+1,lin-1,col);
1:if (l[lin,col] break;
and 8<>0) and not case 2:
vizitat(k,lin-1,col) if (l[lin][col] & 4 &&
then ! vizitat(k, lin,col+1))
back(k+1,lin-1,col); back(k+1,lin,col+1);
2:if (l[lin,col] break;
and 4<>0) and not case 3:
vizitat(k,lin,col+1) if (l[lin][col] & 2 &&
then ! vizitat(k, lin+1,col))
back(k+1,lin,col+1); back(k+1,lin+1,col);
3:if (l[lin,col] break;
and 2<>0) and not case 4:
vizitat(k,lin+1,col) if (l[lin][col] & 1 &&
then ! vizitat(k, lin,col-1))
back(k+1,lin+1,col); back(k+1,lin,col-1);
4:if (l[lin,col] break;
and 1<>0) and not }
vizitat(k,lin,col-1) }
then }
back(k+1,lin,col-1) main()
end; {case} { cout<<"M=";
end cin>>m;
end; cout<<"N=";
begin cin>>n;
write('M='); for (i=1;i<=m;i++)
readln(m); for(j=1;j<=n;j++)
write('N='); { cout<<"l["<<i<<","
readln(n); <<j<<"]=";
for i:=1 to m do cin>>l[i][j];
for j:=1 to n do }
begin cout<<"Linie=";
write('l[',i,',',j,']='); cin>>lin;
readln(l[i,j]) cout<<"Coloana= ";
end; cin>>col;
write('lin='); back(1,lin,col);
readln(lin); }
write('col=');
readln(col);
back(1,lin,col)
end.

66
Rezultat program Pascal recursiv Rezultat program C recursiv

67