INFORMATICĂ – Clasa a XI-a D - an școlar 2022-2023

Ianuarie 12, 2023

Fișă aplicativă - Funcții recursive

1. Să se scrie definițiile unor subprograme recursive care, având ca parametru numărul natural n
(0<n<1.000.000.000), returnează:
a. suma cifrelor lui n;
b. produsul cifrelor lui n;
c. numărul cifrelor lui n;
d. cifra maximă a lui n;
e. cifra minimă a lui n;
f. oglinditul (inversul) lui n;
g. suma divizorilor lui n;
h. produsul divizorilor lui n.
i. afiseaza reprezentarea numarului in baza 2
a. b. c.
int suma(int n) int produs(int n) int nrcifre(int n)
{ { {
if(!n) return 0; if(n<10) return n; if(n<10) return 1;
else else else
return n%10+suma(n/10); return n%10*produs(n/10); return 1+nrcifre(n/10);
} } }
d. e. f.
//varianta 1 int cifmin(int n) //varianta 1
int cifmax(int n) { int oglindit(int n, int ogl)
{ if(!n) return 9; {
if(!n) return 0; else if(!n) return ogl;
else if(n%10<cifmin(n/10)) else
if(n%10>cifmax(n/10)) return n%10; return oglindit(n/10,ogl*10+n
return n%10; else %10);
else return cifmin(n/10); }
return cifmax(n/10); } //varianta 2-in cazul in care se
} //varianta 2 cere returnarea prin parametru
//varianta 2 int cifmin(int n) void oglindit(int n, int &ogl)
int cifmax(int n) {if(n<=9) {
{if(n<=9) return n; ogl=ogl*10+n%10;
return n; else return min(n if(n>=10) oglindit(n/10, ogl);
else return max(n %10,cifmin(n/10)); }
%10,cifmax(n/10)); } //in main() se transmite ogl cu
} valoarea 0
//varianta 3-in cazul in
care se cere returnarea
prin parametru
void cifmax(int n, int
&max)
{
max=0;
if(n<10)
1
 INFORMATICĂ – Clasa a XI-a D - an școlar 2022-2023
Ianuarie 12, 2023

{ if(n>max) max=n;}
else
{
cifmax(n/10,max);
if(n%10>max) max=n%10;
}
}

g. h. i.
//varianta 1 int proddiv(int n, int d) void baza2(int n)
int sumdiv(int n, int d) { {
{ if(d==n+1) return 1; if(n>0)
if(d==n+1) return 0; if(n%d==0) {
if(n%d==0) return d*proddiv(n,d+1); baza2(n/2);
return d+sumdiv(n,d+1); else cout<<n%2;
else return proddiv(n, d+1); }
return sumdiv(n, d+1); } }
} //in main() se transmite d cu
//in main() se transmite d valoarea 1
cu valoarea 1

//varianta 2
int sumdiv(int n, int d)
{
if(d==0) return 0;
if(n%d == 0)
return d + sumdiv(n, d-
1);
else
return sumdiv(n, d-1);
}
//in main() se transmite d
cu valoarea n

2. Să se scrie definițiile unor subprograme recursive care, având ca parametri numerele naturale a și
b, returnează:
a. cel mai mare divizor comun al lor;
b. ab , unde b>0;

2
 INFORMATICĂ – Clasa a XI-a D - an școlar 2022-2023
Ianuarie 12, 2023

a. b.
//varianta 1 //varianta 1
int cmmmdc(int a, int b) int putere(int a, int b)
{ {
if(!b) return a; if(!b) return 1;
else return cmmmdc(b, a%b); else return a*putere(a, b-1);
} }
//varianta 2 //varianta 2
int cmmmdc(int a, int b) int putere(int a, int b)
{ {
if(a==b) return a; if(!b) return 1;
else int p=putere(a, b/2);
if(a>b) return cmmmdc(a-b, b); if(b%2==1) return a*p*p;
else return cmmmdc(a, b-a); else return p*p;
} }

_ _ _ _ _ _ _ _ __ _ _ _ __ _ _ _ __ _ _ _ __ _ _ _ __ _ _ _ __ _ _ _ __ _ _ _ __ _ _ _ __ _ _ _ __ _ _

Se dă un vector v cu n elemente întregi (1<=n<=50 și elementele vectorului sunt numere din intervalul
[-1.000.000.000, 1.000.000.000] ).

Să se scrie definițiile unor subprograme recursive care realizează:

3. citirea elementelor vectorului;
4. afișarea elementelor vectorului;
5. afișarea elementelor pozitive din vector;
6. afișarea pozițiilor elementelor negative din vector.

3. 4.
//citirea elementelor vectorului //elementele se memoreaza de la 0
void citeste(int v[], int n) //varianta 1
{ void afis(int v[], int n)
if(n>0) {
{ if(n>0)
citeste(v, n-1); {
cin >> v[n-1]; afis(v, n-1);
} cout << v[n-1] << ' ';
} }
}
//varianta 2
void afis(int v[], int n, int i)
{
if(i<n)
{
cout << v[i] << ' ';
afis(v, n, i+1);

3
 INFORMATICĂ – Clasa a XI-a D - an școlar 2022-2023
Ianuarie 12, 2023

}
}
5. 6.
//elementele se memoreaza de la 0 //elementele se memoreaza de la 0
void afis(int v[], int n) void afis(int v[], int n)
{ {
if(n>0) if(n>0)
{ {
afis(v, n-1); afis(v, n-1);
if(v[n-1]>0) cout << v[n-1] << ' '; if(v[n-1]<0) cout << n-1 << ' ';
} }
} }
//elementele se memoreaza de la 1
void afis(int v[], int n)
{
if(n>0)
{
afis(v, n-1);
if(v[n]>0) cout << v[n] << ' ';
}
}

Să se scrie definițiile unor subprograme recursive care calculează și returnează:

7. suma elementelor vectorului v;
8. suma elementelor cu indici în intervalul [p, q]: xp + xp+1 + …. + xq;
9. suma elementelor negative din vectorul v;
10. suma pozițiilor elementelor pare din vectorul v;
11. produsul elementelor vectorului v;
12. produsul elementelor pozitive din vectorul v;
13. produsul elementelor impare din vectorul v;
14. numărul elementelor negative din vectorul v;
15. numărul elementelor pare din vectorul v.

7. 8. 9.
int suma(int v[], int n) //varianta 1 int suma(int v[], int n)
{ int suma(int v[],int p, int q) {
if(!n) return 0; { if(!n)
else if(p==q) return v[q]; {
return v[n-1]+suma(v,n-1); else if(v[n] < 0) return
} return v[q]+suma(v, p, q-1); v[n];
} else return 0;
//varianta 2 }
int suma(int v[],int n,int i)
{ if(i==n+1) return 0; else
return v[i]+suma(v,n,i+1); if(v[n-1]<0)
4
 INFORMATICĂ – Clasa a XI-a D - an școlar 2022-2023
Ianuarie 12, 2023

} return v[n-1]+suma(v,n-1);
else return suma(v,n-1);
}

10. 11. 12.

int suma(int v[], int n) int prod(int v[], int n) int nr(int v[], int n)
{ { {
if(!n) return 0; if(!n) return 1; if(!n) return 0;
else else else
if(v[n-1]%2==0) return v[n-1]*prod(v,n-1); if(v[n-1]<0)
return n-1+suma(v,n-1); } return 1+nr(v,n-1);
else return suma(v,n-1); else return nr(v,n-1);
} }

Să se scrie definițiile unor subprograme recursive care verifică dacă:

16. toate elementele vectorului v sunt pare;
17. vectorul v conține cel puțin un element impar;
18. vectorul nu conține niciun element negativ;
19. vectorul este sortat crescător;
20. vectorul este constant.

16. 17.
int ok(int v[], int n) int ok(int v[], int n)
{ {
if(!n) return 1;//toate pare if(!n) return 0;//nu exista niciun element
else impar
if(v[n-1]%2) return 0; //element impar else
else return ok(v,n-1); if(v[n-1]%2) return 1; //element impar
} else return ok(v,n-1);
}
18. 19.
int ok(int v[], int n) int ok(int v[], int n)
{ {
if(!n) return 1;//toate pozitive if(n==1) return 1;//sir ordonat
else else
if(v[n-1]<0) return 0; //element negativ if(v[n-1]<v[n-2]) return 0;
else return ok(v,n-1); else return ok(v,n-1);
} }

Să se scrie definițiile unor subprograme recursive care determină și returnează prin parametru:
21. maximul elementelor vectorului;
22. maximul elementelor vectorului care sunt pozitive;
23. minimul elementelor vectorului;
24. minimul elementelor vectorului care sunt pare.

21. 22.
5
 INFORMATICĂ – Clasa a XI-a D - an școlar 2022-2023
Ianuarie 12, 2023

//varianta 1 //varianta 1
int maxim(int v[],int n) int minim(int v[],int n)
{ {
if(n==1) return v[0]; if(n==0)
else if(v[n]%2==0) return v[n];
if(v[n-1]>maxim(v,n-1)) return v[n-1]; else return 1000000000;
else return maxim(v,n-1); else
} if(v[n-1]%2==0)
//varianta 2-in cazul in care se cere if(v[n-1] < minim(v,n-1)) return v[n-1];
returnarea prin parametru else return minim(v,n-1);
void maxim(int v[], int n, int &max) else return minim(v,n-1);
{ }
if(n==1) //varianta 2
max=v[0]; int minim(int v[],int n)
else {
{ int min;
maxim(v, n-1, max); if(n==0)
if(v[n-1]>max) if(v[n]%2==0) return v[n];
max=v[n-1]; else return 1000000000;
} else
} min = minim(v,n-1);
if(v[n-1]%2==0)
if(v[n-1]<min) return v[n-1];
else return min;
else return min;
}

Să se scrie definițiile unor subprograme recursive care construiesc vectorul y cu proprietatea:

25. conține toate elementele pozitive din șirul v;
26. conține toate elementele divizibile cu 3 din șirul v;
27. conține pozițiile elementelor egale cu c (număr dat) din șirul v.

25. 27.
//varianta 1 void constr(int v[], int n, int z[], int &k,
void constr(int v[], int n, int z[], int &k) int c)
{ {
if(n==1) if(n==1)
{ if(v[n-1]>0) z[++k]=v[n-1];} { if(v[n-1]==c) z[++k]=n-1;}
else else
{ constr(v, n-1, z, k); { constr(v, n-1, z, k, c);
if(v[n-1]>0) z[++k]=v[n-1]; if(v[n-1]==c) z[++k]=n-1;
} }
} }
//varianta 2 //varianta 2
void constr(int v[], int n, int z[], int &k) void constr(int v[], int n, int z[], int &k,
{ int c)
6
 INFORMATICĂ – Clasa a XI-a D - an școlar 2022-2023
Ianuarie 12, 2023

{
if(n>0) if(n>0)
{ constr(v, n-1, z, k); { constr(v, n-1, z, k,c);
if(v[n-1]>0) z[++k]=v[n-1]; if(v[n-1]==c) z[++k]=n-1;
} }
} }