Individual Teoria Recursiei

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 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.

#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;
}

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

Calcularea sumei numerelor pare. Calcularea sumei numerelor pare.
Calculare Calculare
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 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.

#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; }

Calcularea sumei numerelor impare. Calcularea sumei numerelor impare.
Calculare Calculare

Calcularea sumei numerelor impare. Calcularea sumei numerelor impare.
Calculare Calculare
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.

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.

#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
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....

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.

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
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, …

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.

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
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.

uses crt; uses crt;
begin functionsuma(k:integer):integer;
clrscr; begin
readln(n); elsesuma:=suma(k-1)+5*k-4;
s:=0; end;
s:=s+5*i-4; clrscr;
readkey; readln(n);
readkey;
end.

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
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.

uses crt; uses crt;
begin function suma(k:integer):integer;
clrscr; begin
readln(n); else suma:=suma(k-1)+5*k-4;
s:=0; end;
s:=s+5*i-4; clrscr;
readkey; readln(n);
readkey;
end.

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
 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.

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.

#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
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.

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.

#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
 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
 x2, x3 a ( x )  5, x  0
a ( x)   și b ( x)   (x  1) 2, x  0

b ( x  2), x  3
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();
}
23
Problema 13
 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
  

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
25
Problema 14
 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;}
26
Problema 15
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.
28
Problema 16
Funcția Ackermann.
Să se alcătuiască un program Pascal pentru funcţia Ackermann:

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.

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:

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));
}

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
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:

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.

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
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:

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();
}

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.

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();
}
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 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
}
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 cmmdc_n; #include <iostream.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);
}
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 partitie; #include <iostream.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
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 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();
}
}

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 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();}

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 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
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 #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,
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();
}

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 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,
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();
}

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 Permutari; #include <iostream.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.
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 Aranjamente; #include <iostream.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++;
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
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 Combinari; #include <iostream.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++;
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
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 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.
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 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.

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[4,3]=0 -------------------- Tara = 5; culoarea=1
a[5,1]=0 Tara = 1; culoarea=1 --------------------
-------------------- 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
59
60
61
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 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.
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 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);
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);
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);
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
67

Individual Teoria Recursiei

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Individual Teoria Recursiei

Загружено:

Авторское право:

Доступные форматы

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

REPUBLICII MOLDOVA UNIVERSITATEA DE STAT DIN TIRASPOL

A elaborat: Andrian Dascal, masterand anul 2

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

Program Pascal nerecursiv Program Pascal recursiv

Program C nerecursiv Program C recursiv

Rezultat program C nerecursiv Rezultat program C recursiv

Program Pascal nerecursiv Program Pascal recursiv

Program C nerecursiv Program C recursiv

Rezultat program Pascal nerecursiv Rezultat program Pascal recursiv

Rezultat program C nerecursiv Rezultat program C recursiv

Program Pascal nerecursiv Program Pascal recursiv

Program C nerecursiv Program C recursiv

Rezultat program Pascal nerecursiv Rezultat program Pascal recursiv

Rezultat program C nerecursiv Rezultat program C recursiv

Program Pascal nerecursiv Program Pascal recursiv

Program C nerecursiv Program C recursiv

Rezultat program C nerecursiv Rezultat program C recursiv

Program Pascal nerecursiv Program Pascal recursiv

Program C nerecursiv Program C recursiv

Rezultat program C nerecursiv Rezultat program C recursiv

Program Pascal nerecursiv Program Pascal recursiv

Program C nerecursiv Program C recursiv

Rezultat program C nerecursiv Rezultat program C recursiv

Program Pascal nerecursiv Program Pascal recursiv

Program C nerecursiv Program C recursiv

Rezultat program C nerecursiv Rezultat program C recursiv

Program Pascal nerecursiv Program Pascal recursiv

Program C nerecursiv Program C recursiv

Rezultat program C nerecursiv Rezultat program C recursiv

Program Pascal nerecursiv Program Pascal recursiv

Program C nerecursiv Program C recursiv

Rezultat program C nerecursiv Rezultat program C recursiv

Program Pascal nerecursiv Program Pascal recursiv

Program C nerecursiv Program C recursiv

Rezultat program C nerecursiv Rezultat program C recursiv

Rezultat program Pascal recursiv Rezultat program C recursiv

Rezultat program Pascal recursiv Rezultat program C recursiv

Program Pascal recursiv-indirect Program C recursiv-indirect

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

Rezultat program Pascal recursiv Rezultat program C recursiv

Program Pascal recursiv- Program C++ recursiv-indirect

Rezultat program Pascal recursiv Rezultat program C recursiv

Program Pascal recursiv-indirect Program C recursiv-indirect

Rezultat program Pascal recursiv Rezultat program C recursiv

Program Pascal recursiv-indirect Program C recursiv-indirect

Rezultat program Pascal recursiv Rezultat program C recursiv

Program Pascal recursiv-indirect Program C recursiv-indirect

Rezultat program Pascal recursiv Rezultat program C recursiv

Program Pascal recursiv-indirect Program C recursiv-indirect

Rezultat program Pascal recursiv Rezultat program C recursiv

Program Pascal recursiv-indirect Program C recursiv-indirect

Rezultat program Pascal recursiv Rezultat program C recursiv

Program Pascal recursiv-indirect Program C recursiv-indirect

Rezultat program Pascal recursiv Rezultat program C recursiv

Algoritmul lui Euclid pentru n numere.

Rezultat program Pascal recursiv Rezultat program C recursiv

Program Pascal recursiv-indirect Program C recursiv-indirect

Program Pascal recursiv-indirect Program C recursiv-indirect

Rezultat program Pascal recursiv Rezultat program C recursiv

Program Pascal recursiv-indirect Program C recursiv-indirect

Rezultat program Pascal recursiv Rezultat program C recursiv

Program Pascal recursiv-indirect Program C recursiv-indirect

Curba lui Koch pentru un triunghi echilateral.