LUCRARE PENTRU ATESTAREA

COMPETENTELOR PROFESIONALE
LA INFORMATICA

1
 TEMA PROIECTULUI

Subprograme

Cuprins
Motivatie......................................................................................................................................................4
Definitie.......................................................................................................................................................4
Avantaje.......................................................................................................................................................4
Structura.......................................................................................................................................................5
Definitia...................................................................................................................................................5
Parametrii unui subprogram.........................................................................................................................6
Clasificare....................................................................................................................................................6
VIVariabile...................................................................................................................................................7

2
Transmiterea parametrilor..........................................................................................................................10
Modul de transfer al parametrilor...............................................................................................................10
Transfer prin valoare..............................................................................................................................10
Transfer prin referinţă............................................................................................................................12
Supradefinirea funcţiilor.............................................................................................................................13
Tipuri speciale de parametri.......................................................................................................................14
Funcţii recursive.........................................................................................................................................17
Aplicatii......................................................................................................................................................19
Problema nr. 1........................................................................................................................................19
Problema nr 2.........................................................................................................................................19
Problema nr. 3........................................................................................................................................20
Problema nr. 4........................................................................................................................................21
Problema nr. 5.......................................................................................................................................22
Problema nr. 6........................................................................................................................................23
Problema nr. 7........................................................................................................................................23
Problema nr. 8........................................................................................................................................24
Problema nr. 9........................................................................................................................................25
Problema nr. 10......................................................................................................................................26
Problema nr. 11......................................................................................................................................26
Problema nr. 12......................................................................................................................................28
Problema nr. 13......................................................................................................................................29
CONCLUZII..............................................................................................................................................30
Bibliografie................................................................................................................................................30

Motivatie

Am ales “Subprograme” drept tema pentru lucrarea de atestat pentru ca ele au o deosebita
importanta practica in programarea C++ iar principiul care sta la baza lor are o larga
aplicabilitate in viata de zi cu zi. Subprogramele, numite in C++ functii, fac posibila crearea

3
 programelor complicate intr-un mod eficient diminuand munca pe care programatorul o
depune. Functiile impart o problema aparent foarte complicata in mai multe probleme mai
mici care pot fi cu usurinta rezolvate. Prin interactiunea mai multor functii simple se rezolva
o problema complexa.

Definitie
Subprogramele sunt parti ale unui program definite in afara functiei main, identificabile prin
nume si aeplabile de cate ori este nevoie. Ele contin tipuri de date, variabile si instructiuni in
vederea unei anumite prelucrari. Pentru a face referire la un subprogram, in C++ se foloseste doar
notiunea de functie, spre deosebire de limbajul Pascal unde subprogramele se impart in functii si
proceduri.

Avantaje
Funcţiile :
• sunt esenţiale în construcţia blocurilor 
• permit folosirea facilităţilor oferite de programarea structurată
• permit elaborarea unor aplicaţii proprii utilizatorului
• permit obţinerea unor funcţii mai complexe prin combinareaunora mai simple, care scriu, citesc,
testează şi depanează programe
Un program C++ conţine cel putin o funcţie main() care este apelată la lansarea în execuţie a
programului, funcţii predefinite (de bibliotecă) şifuncţii construite de programator.

Structura
Un subprogram (funcţie) are o definiţie şi atâtea apeluri câte sunt necesare.
Declarare:

Dacă o funcţie este apelată dintr-o bibliotecă standard sau definită de utilizator sub forma de
fişier obiect sau dacă se află într-un alt fişier sursă, pentru a verifica validitatea apelurilor de către
compilator esteobligatorie folosirea declaraţiei acelei funcţii, declaraţie numită prototip.

4
Declaraţia are forma :
tip-rez nume(lista);

unde lista poate conţine doar tipul parametrilor şi numărul lor fără a fineapărat necesară şi
specificarea numelui lor (care este însărecomandată).Prototipul unei funcţii trebuie pus înaintea
primului apel al său, de obiceichiar la începutul programului.

Definitia unei functii este alcatuita din:

1. Antetul subprogramului

tip_returnat nume_funcţie(lista parametrilor formali)

El conține următoarele:
- tipul rezutatului dat de tip_returnat: int, char, char*, long, float, void, etc.
În cazul în care tipul rezultatului este diferit de void, corpul funcţiei trebuie să conţină cel puţin o
instrucţiune return. Instrucţiunea return va specifica valoarea calculată şi returnată de funcţie care
trebuie să fie de acelaşi tip ca şi tip_returnat.

- numele subprogramului nume_functie – este dat de cel care o defineste pentru a o putea
apela mai tarziu

- Lista parametrilor formali -listă de declaraţii de variabile separate prin virgulă. Această
listă poate să fie şi vidă.

2. Corpul functiei
{
Instructiune 1;
Instructiune 2;
Instructiune 3;
}

Corpul funcţieieste un bloc, care implementează algoritmul de calcul folosit de către funcţie. În
corpul funcţiei apar (în orice ordine) declaraţii pentru variabilele locale şi instrucţiuni.
Apelul unei funcţii care nu returnează o valoare are forma generală:
nume_funcţie (lista parametrilor efectivi);

5
 Parametrii unui subprogram
Parametri formali apar în antetul subprogramului şi sunt utilizaţi de subprogram pentru
descrierea abstractă a unui proces de calcul.
Parametri actuali apar în instrucţiunea de apelare a unui subprogram şi sunt folosiţi la execuţia
unui proces de calcul pentru valori concrete.
Parametrii formali nu sunt variabile. O variabilă este caracterizată de nume, tip, şi adresă.
Legarea unui parametru formal la o adresă se realizează în timpul execuţiei instrucţiunii de
apelare a subprogramului.

Clasificare
Subprogramele se pot clasifica dupa:
 modul de definitie
1. predefinite – ele exista in biblioteca mediului de dezvoltare al programelor C++
Exemple:
- functii matematice cu prototipul in headerul <math.h>
- functii de prelucrare a sirurilor de caractere cu prototipul in headerul <string.h>
2. definite de utilizatorin vederea rezolvarii unor sarcini specifice aplicatiei sale
 modalitate de apel
1. Funcții operand: subprogram care returnează un rezultat chiar prin numele lui, dar
eventual poate returna și alte rezultate prin intermediul parametrilor de ieșire;
Apelul unei funcții operand se realizează in expresii (atribuire, instrucțiuni de control (if, while,
for) ) sau ca parametrii ai unei alte funcții.

Tipul unei funcţii operand poate fi:

-numeric (intreg sau real)
- character
- pointer
-înregistrare(struct)
NU poate fi tablou (vectori, matrici, string-uri)

2. Funcții procedurale:subprogram care are una, mai multe sau nici o valoare, valorile se
returnează prin intermediul parametrilor; apelul unei funcții procedurale se realizează printr-o
instrucțiune procedurala cu sintaxa:
nume_subprogram (listă de parametric actuali), de exemplu sch(a,b);

Tipul unei funcţii procedurale este void.

6
 VIVariabile
Sistemul de operare alocă fiecărui program trei zone distincte în memoria internă în care se
găsesc memorate variabilele programului:
o Segment de date
o Segment de stivă
o Heap.

Există şi posibilitatea ca variabilele să fie memorate într-un anumit registru al microprocesorului,

caz în care accesul la acestea este foarte rapid.

Funcţia main.

În C, numele de funcţie main determină prima instrucţiune pe care o va executa programul.

Acesta este unica diferenţă dintre main şi celelalte funcţii.

Variabile locale

La fel cum se declară variabilele în cadrul funcţiei main, la fel se pot declara varibile în cadrul
celorlalte funcţii. Aceste variabile se numesc locale şi sunt accesibile doar de funcţia care le-a
declarat.

La fel în cadrul unei funcţii se pot apela şi alte funcţii, ca şi în main, dacă acestea au fost definite
înaintea eventualului apel sau dacă este prezent un prototip de funcţie înaintea funcţiei apelante şi
o definiţie de funcţie în cadrul programului respectiv sau în fişierele incluse în programului
respectiv.

Variabile globale

Sunt declarate în afara oricărei funcţii şi pot sunt vizibile (pot fi utilizate) în tot programul (în
rogramul principal şi în subprograme) din momentul declarării lor.

Mai jos, sunt cateva exemple care ilustreaza modul de folosire a variabilelor locale si globale.

7
# include <iostream.h>
int N;
void f1()
{
int x=5;
N=10;
cout << endl<<N;
cout << endl << x;
}
void main ()
{
N=4;
cout << N;
f1();
}

N este variabilă globală.

Poate fi accesată în cadrul oricărei funcţii.
x este variabilă locală, vizibilă doar în cadrul funcţiei f1().
Se va afişa:
4
10
5

#include <iostream.h>
int N;
void f1()
{
int x=5;
cout << endl << x;
P=2 //eroare
}

8
int P=9;
void main ()
{
f1();
cout << x;
P=7;//corect
}

Compilatorul generează eroare deoarece funcţia main încearcă să acceseze variabila x care este
vizibilă doar în funcţia f1().
Compilatorul generează eroare deoarece P este accesată în f1() înainte de a fi declarată.

# include
<iostream.h>
int N;
void f1(int p)
{
int x=p;
cout << x;
}
void main ()
{
f1(3);}

Se afişează 3
N este variabilă globală.
Poate fi accesată în cadrul oricărei funcţii.
x este variabilă locală.
Poate fi accesată doar în cadrul funcţiei f1()
p este parametru formal.
Poate fi accesat doar în f1().

9
 Transmiterea parametrilor
Parametrii actuali trebuie să corespundă celor formali, ca număr şi tip de date. Tipul parametrilor
actuali trebuie fie să coincide cu tipul parametrilor formali, fie să poată fi convertit implicit la
tipul parametrilor formali.

Pentru memorarea parametrilor, subprogramele folosesc segmentul de stivă, la fel ca pentru

variabilele locale.
Memorarea se face în ordinea în care parametrii apar în antet.
În cadrul subprogramului, parametrii transmişi şi memoraţi în stivă sunt variabile. Numele lor
este cel din lista parametrilor formali.
Variabilele obţinute în urma memorării parametrilor transmişi sunt variabile locale.
La revenirea în blocul apelant, conţinutul variabilelor memorate în stivă se pierde.

Modul de transfer al parametrilor

Transfer prin valoare

Parametrului i se atribuie o valoare, o expresie sau conţinutul unei variabile. Se folosește, de

obicei, numai pentru parametrii de intrare.Dacă se utilizează, totuși, acest mod pentru
transmiterea rezultatelor, se pot folosi variabile de tip pointer.

Varianta 1
(transfer prin valoare a parametrilor de intrare)

# include <iostream.h>
int a,b;
void
sch (int x, int y)
{
int z;
z=x; x=y; y=z;
}
int main()
{

10
cin>>a>>b;
//a=10, b=20
sch(a,b);
cout<<a<<` `<<b;//a=10, b=20
return 0;
}

Varianta 2
(transfer prin valoare a parametrilor de ieșire, folosind pointeri)

# include <iostream.h>
int a,b;
void
sch (int *x, int *y)
{
int z;
z=*x; *x=*y; *y=z;
}
int main()
{
cin>>a>>b;//a=10, b=20
sch(&a,&b);//atenție la parametri
cout<<a<<` `<<b; //a=20, b=10
return 0;
}

Transfer prin referinţă

Subprogramul primeşte o adresă de memorie la care este stocată variabila primită ca parametru.
Se foloseşte pentru parametrii de ieşire, sau intrare/ieşire. In lista parametrilor formali, sunt
precedaţi de operatorul adresă de memorie (caracterul &).

11
Parametrii efectivi corespunzători parametrilor formali transmişi prin referinţă TREBUIE să fie
doar variabile, adică nu pot fi constante, expresii, apeluri ale altor funcţii;

Varianta 3
(transfer prin referinţă a parametrilor de ieşire)

# include <iostream.h>
int a,b;
void sch (int &x, int &y)
{
int z;
z=x; x=y; y=z;
}
int main()
{
cin>>a>>b; //a=10, b=20
sch(a,b);
// nu se poate apela sch(20, 30), parametrii actuali //TREBUIE să fie variabile
cout<<a<<` `<<b; //a=20, b=10
return 0;
}

Supradefinirea funcţiilor
C ++ permite definirea mai multor funcţii cu acelaşinumedar cu liste de parametrii (semnături)
diferite ca tip sau ca număr al parametrilor.Supradefinirea funcţiilor care au parametrii cu valori
implicite poategenera duplicarea semnăturii funcţiilor respective, ambiguitate pe
carecompilatorul o semnlează ca eroare.

12
Această facilitate permite obţinerea unui rezultat chiar dacă tipurile parametrilor diferă. Ea
contribuie la simplificarea programării pentru că permite folosirea unui singur nume de funcţie
când programul trebuie săîndeplinească o anumită sarcină.

Exemplu:

#include
< iostream.h>
int adun (int x, int y)
{
return (x+y);
}
int adun (int x, int y, int z)
{
return (x+y+z)
} 
void main ()
{
cout << ”Rezultate:”<<endl;
cout << “l0+20=”<<adun (10,20)<<endl;
cout << “15+25+35”=<<adun(15,25,35)<<endl;
}

După compilare şi rulare apare pe ecran:

Rezultate:10+20=30
15+25+35=75

Tipuri speciale de parametri

Parametrul tablou

13
Funcţiile care transmit ca parametru un tablou necesită declararea acelui parametru ca pointer la
tipul de bază al tabloului.

Prototipul funcţiei are sintaxa:

tip_baza nume_tablou;

tip_rez nume_fct (tip_baza*, alte_tipuri);

Definirea unei funcţii cu parametru tablou are sintaxa:

tip_rez nume_fct (tip_baza*tab, alti_parametri)

tip_rez nume_fct (tip_baza tab[], alti parametri) 

Exemplu. Funcţia calculează suma elementelor lui vector. Parametrul int* este tipul de bază al
parametrului vector.

#include < iostream.h>

void main ()
{
int suma (int *, int);
int vector[] = {4,2,1,5,3,6};
int dim = sizeof (vector) / sizeof (int);
cout << “Suma elementelor vectorului este:” << suma (vector,dim)<<endl;
}
int suma (int*p, int n)
{
for (int i=0, s=0; i<n; i++) 
s + = p[i];
return s;
}

14
Parametrul şir de caractere

Şirurile de caractere în C + + sunt considerate tablouri de caractere. Dacă un şir de caractere este
parametrul unei funcţii, pentru el sunt valabileaceleaşi reguli ca la parametrul tablou.

Exemplu.
Programul următor calculează numărul de caractere litere micidintr-un şir de caractere prin
funcţia contor care primeşte ca parametrurespectivul şir. Introducerea şirului se face cu funcţia
de bibliotecă predefinită gets() din fişierul antet stdio.h. Funcţia contor atribuie
adresa parametrului şir unui pointer local psir. Acesta este folosit de funcţie pentru procesarea
caracterelor din şir.

#include < iostream.h>

#include < stdio.h>
int contor (char *sir)
{int k=0;
char *psir = sir;
while (*psir! = ‘\0’)
{
if (* psir >=’a’ && * psir<=’z’)
k + = 1;
psir + + ;
}
return k;
}
void main ()
{
char sir[20];
cout << “Introduceti sirul:”;
gets (sir);
cout << “Sirul introdus” << sir << “contine” << contor (sir) <<“caractere mici”<<endl;
}

După compilare şi rulare programul afişează:

15
Sirul introdus ‘Asd$%90bc’ contine 4 caractere mici.
Sirul introdus ‘UN907.12CD’ contine 0 caractere mici.

Transmiterea structurilor unei funcţii

Exemplu:

struct persoana
{
char nume[20];
int varsta;
};
void Citeste (persoana &x)
{
cout << "Numele:";
gets(x.nume);
cout << "Varsta:";
cin >>x.varsta;
}
void Afiseaza (persoana x)
{
cout << "NUMELE: " << x.nume;
cout << endl;
cout << "VARSTA: " << x.varsta;
}
void main ()
{
clrscr();
persoana P;
Citeste (P);
Afiseaza(P);
}

16
Modificarea membrilor structurii necesita apelul prin referinţă pe cand pentru a afişa o structură
este suficient apelul prin valoare

Funcţii recursive
Dacă o funcţie se autoapelează direct sau indirect se numeşte recursivă. Astfel apelul unei funcţii
recursive poate apărea şi în definiţia sa. O funcţie recursivă nu are sintaxă specială. Ea implică
existenţa unei stive care la fiecare apel al funcţiei recursive se încarcă cu valorile parametrilor,
variabilelor locale şi rezultatului. La fiecare revenire,această stivă este descarcată. Recursivitatea
se aplică în special la prelucrarea structurilor de date de tiprecursiv cum ar fi liste, arbori, etc.

Exemplu.
Calculul nerecursiv şi recursiv al factorialului unui număr natural.

Calcul nerecursiv

#include < iostream.h>

int factorial (int n)
{
int rez=1;
for (int i=1; i<=n; i++)rez*=i;return rez;
}
void main ()
{
int num;
cout << “Introduceti un numar natural:”;
cin >>num;
cout << endl << “ Rezultat:”<< num <<”!=”<<factorial (num) << endl;
}

Calcul recursiv
#include < iostream.h>

17
int fact (int n)
{
if (n==0)
return 1;
else
return n*fact(n-1);
}
void main ()
{
int num;
cout << “Introduceti un numar natural:”;
cin >>num;
cout << endl << “ Rezultat:”<< num <<”!=”<<fact (num) << endl;
}

Aplicatii
Problema nr. 1.Să se determine cel mai mare divizor comun (c.m.m.d.c.)a doua numere întregi
citite de la tastatura.

18
Cmmdc se va calcula folosind relatia:
cmmdc(a,b)=cmmdc(a-b, b), a>b
=cmmdc(a, b-a), b>a
=a, daca a=b,
#include<iostream>
using namespace std;
int cmmdc(int a,int b)
{
if(a==b) return a;
else if(a>b) return cmmdc(a-b,b);
else return cmmdc(a,b-a);
}
int main()
{
int x,y;
cout<<"x=";cin>>x;
cout<<"y=";cin>>y;
cout<<"cmmdc este: "<<cmmdc(x,y);
}

Problema nr 2.Sa se afiseze toate numerele din intervalul [1000,99999] care au proprietatea ca
atat ele cat si rasturnatul lor sunt prime.
#include<iostream>
using namespace std;
#include<math.h>
long n,c,d,k;
int prim(long n)
{if(n==0 || n==1) return 0;
for(int i=2;i<=sqrt(n);i++)
if(n%i==0) return 0;
return 1;
}
long rasturnat(long n)
{d=0;
while(n!=0)
{c=n%10;
d=d*10+c;
n=n/10;
}
return d;
}
int main()

19
{for(long int x=1001;x<=99999;x++)
if(prim(x) && prim(rasturnat(x))) cout<<x<<endl;
}

Problema nr. 3.Scrieţi definiţia completă a subprogramului numar, cu trei parametri, care
primeşte prin intermediul parametrului n un număr natural format din cel mult 9 cifre, iar prin
intermediul parametrilor c1 şi c2 câte o cifră nenulă. Subprogramul caută fiecare apariţie a
cifrei c1 în n, şi dacă aceasta apare, o înlocuieşte cu c2. Subprogramul furnizează tot prin n
numărul astfel obţinut. Dacă cifra c1 nu apare în n, atunci valoarea lui n rămâne nemodificată.
#include<iostream>
using namespace std;
void numar( long & n,int c1,int c2)
{
int p=0,p1=1,c;
long nr=n;
while(nr)
{
p=p+1;
if(nr%10==c1)
{
p1=1;
for(int i=1;i<p;i++)
p1=p1*10;
cout<<p1<<endl;
c=n%p1;
cout<<"c="<<c;
cout<<endl;
p1=p1*10;
n=n/p1;
n=n*10+c2;
p1=p1/10;
n=n*p1+c;
cout<<n<<endl;
}
nr=nr/10;
}
}
int main()
{
long n;
int c1,c2;
cin>>n>>c1>>c2;
numar(n,c1,c2);
cout<<n;
}

20
Problema nr. 4.Ordonarea şi interclasarea a doi vectori

#include <iostream> for (int i=0;i<n;i++) cin>>x[i];

#include <conio.h> }
using namespace std; void afisare(int x[], int n){
int a[10],b[10],na,nb,nc,c[20]; for (int i=0;i<n;i++) cout<<x[i]<<" ";}
void citire(int x[], int &n){ void ordonare(int x[], int n){
cout<<"Numarul de elemente: "; cin>>n; int i,ok,aux;
cout<<"Introduceti elementele: "; do{ok=1;
for (i=0;i<n-1;i++)
if (x[i]>x[i+1]){
ok=0;
aux=x[i];
x[i]=x[i+1];
x[i+1]=aux;
}}while(!ok);}
void inter(int v[]){
int i,j,ok=1;
for (i=0;i<na;i++) v[i]=a[i];
nc=na;
for (i=0;i<nb;i++){
ok=1;
for (j=0;j<na;j++)
if (a[j]==b[i]){
ok=0;
break;
}if (ok){
v[nc]=b[i];
nc++;
}}}
int main(){
clrscr();

21
cout<<"Primul vector: \n";
citire(a,na);
cout<<"Al doilea vector \n";
citire(b,nb);
ordonare(a,na);
ordonare(b,nb);
cout<<"Primul vector ordonat \n";
afisare(a,na);
cout<<endl;
cout<<"Al doilea vector ordonat \n";
afisare(b,nb);
cout<<endl;
cout<<"Interclasarea vectorilor \n";
inter(c);
afisare(c,nc);
getch();
}

Problema nr. 5.Scrieţi definiţia completă a subprogramului reduce, cu doi parametri, care
primeşte prin intermediul parametrilor a şi b două numere naturale formate din cel mult 9 cifre
fiecare. Funcţia returnează o valoare obţinută din numărul a prin însumarea acelor cifre diferite
de 0 ale numărului a care NU divid numărul b. Dacă nu există asemenea cifre, se va returna
valoarea 0.
Exemplu: pentru a=184465709 şi b=18, cifrele corespunzătoare cerinţei sunt 8, 4, 4, 5 şi 7, deci
valoarea returnată va fi 28 (28=8+4+4+5+7). Dacă a=2402804 şi b=8000, valoarea returnată va fi
0.

unsigned reduce(unsigned long a,

unsigned long b)
{unsigned c,s=0;
while(a>0)
{c=a%10;
if(c>0&&b%c!=0) s+=c;
a/=10;

22
 }
return s;
}

Problema nr. 6.Subprogramul sfx primeşte prin singurul său parametru, x, un număr natural
din intervalul [100,2000000000] şi returnează valoarea 1 dacă ultimele trei cifre ale numărului
sunt în ordine strict descrescătoare sau valoarea 0 în caz contrar.

Exemplu: dacă x=24973 se va returna valoarea 1.

#include<iostream>
using namespace std;
int sfx(long x)
{int a,b,c;
cout<<"x=";cin>>x;
a=x%10;
b=(x/10)%10;
c=(x/100)%10;
if ((a<b)&& (b<c))
cout<<1;
else cout<<0;}
int main ()
{long x;int a,b,c; sfx(x);}

Problema nr. 7.Să se scrie în limbajul C/C++ definiţia completă a subprogramului calcul, care
primeşte prin intermediul celor doi parametri ai săi două numere întregi, n şi k (1≤n≤10000 şi
1≤k≤5), şi returnează cifra de rang k a numărului n. Rangul unei cifre este numărul său de
ordine, numerotând cifrele de la dreapta la stânga; cifra unităţilor are rangul 1. Dacă numărul k
este mai mare decât numărul de cifre ale lui n, atunci funcţia returnează valoarea -1.

Exemplu : în urma apelului calcul(9243, 3) se va returna 2.

23
#include<iostream>
#include<math.h>
using namespace std;
int calcul(int n, int k)
{int p=0,c;
while (n!=0)
{c=n%10;
p++;
n=n/10;
if(p==k) cout<<c;}
if (k>p) return -1;}
int main ()
{int n,k,p,c;
cout<<"n:";cin>>n;
cout<<"k";cin>>k; calcul(n,k);}

Problema nr. 8.Scrieţi definiţia completă a unui subprogram s care primeşte prin intermediul
parametrului n un număr natural de maximum 9 cifre, prin intermediul parametrului c o cifră şi
furnizează prin intermediul parametrului k numărul de cifre ale numărului n care aparţin
intervalului [c-1,c+1].

Exemplu: pentru n=1233 şi c=3, k va avea valoarea 3, iar pentru n=650 şi c=3, k vaavea
valoarea 0.

#include<iostream>
using namespace std;
void s(long n,int c)
{int k,t,c1,c2;
k=0; cout<<"n=";cin>>n;
cout<<"c=";cin>>c;
c1=c-1;c2=c+1;
while(n!=0)
{ t=n%10;

24
 if (t>=c1 && t<=c2)
k++;
n=n/10;}
cout<<k;}
void main()
{ long n; int c,c1,c2,k,t;
s(n,c);}

Problema nr. 9.Subprogramul Nr are un singur parametru, k, prin intermediul căruia primeşte
un număr natural de cel puţin 3 cifre şi cel mult 9 cifre, cu toate cifrele nenule. Subprogramul
furnizează tot prin intermediul parametrului k, valoarea obţinută prin eliminarea primei şi
ultimei cifre a numărului transmis la apel.

Exemplu: dacă subprogramul primeşte prin intermediul parametrului k valoarea 12438, în urma
apelului subprogramului Nr, k va primi valoarea 243.

Scrieţi, în limbajul C/C++, definiţia completă a subprogramului Nr.

#include<fstream.h>
#include<stdlib.h>
#include<string.h>
char s[10];
void nr(long &k)
{ ltoa(k,s,10);
strcpy(s,s+1);
s[strlen(s)-1]='\0';
k=atol(s);
}
void main()
{ long n;
cout<<"n:";cin>>n;
nr(n); cout<<n;}

25
Problema nr. 10.Scrieti definitia completa a unui subprogram vect01 care primeste prin
intermediul primului parametru, n, un numar natural nenul mai mic sau egal cu 20, prin
intermediul celui de-al doilea parametru, v, un tablou unidimensional cu n elemente format din
numere intregi din intervalul [-100,100] si care returneaza valoarea 1 daca tabloul este format
din n-1 valori egale cu 0 si o singura valoare egala cu 1; in orice alt caz subprogramul
returneaza valorea 0.

#include <iostream>
Using namespace std;
int vect01(int n, int v[100])
{ int i, ct0=0, ct1=0;
for (i=1;i<=n;i++)
{ if (v[i]==0) ct0++;
if (v[i]==1) ct1++;
}
if (ct0==n-1 && ct1==1)
return 1;
elsereturn 0;
}
intmain()
{
int m[100],i,a;
cout<<"Dati a:"; cin>>a;
for(i=1;i<=a;i++)
cin>>m[i];
cout<<vect01(a,m);
}

Problema nr. 11.Pe prima linie a fisierul text pro2.txt se afla o valoare naturala n (1≤n≤100),
iar pe urmatoarea linie se afla n valori naturale distincte de cel mult 4 cifre fiecare, valori
despartite prin cate un spatiu.
Scrieti programul C/C++ care afiseaza pe ecran toate numerele prime de pe a doua linie a
fisierului pro2.txt, in ordine crescatoare a valorilor lor. Numerele vor fi afisate pe o singura linie
separate prin cate un spatiu.

26
#include<fstream.h>
#include<math.h>
int b[101],i,j,n,a[101],aux;
ifstream f("pro2.txt");
int prim(int x)
{
if(x==1)
return 0;
else
{
for(i=2;i<=sqrt(x);i++)
if(x%i==0)
return 0;
}
return 1;
}
void citire()
{ f>>n;
for(i=1;i<=n;i++)
{ f>>a[i]; }
}
void main()
{
citire();
for( int k=1;k<=n;k++)
if(prim(a[k]))
{ j++;
b[j]=a[k];
}
for(i=1;i<j;i++)
for(k=i+1;k<=j;k++)
if(b[i]>b[k])
{ aux=b[i];

27
 b[i]=b[k];
b[k]=aux;
}
for(i=1;i<=j;i++)
cout<<b[i]<<" ";
}

Problema nr. 12.Scrieti un program C/C++ care citeste de la tastatura un numar natural nenul
n (1≤n≤100), construieste in memorie si apoi afiseaza pe ecran un tablou unidimensional a,
avand n elemente. Tabloul a se completeaza cu numerele naturale de la 1 la n, astfel : se
memoreaza valoarea 1 pe pozitia 1, valoarea 2 pe pozitia n, 3 pe pozitia 2, 4 pe pozitia n-1, 5 pe
pozitia 3, etc.
Elementele tabloului se afiseaza cu cate un spatiu intre ele.
#include<iostream>
#include<math.h>
using namespace std;
int n,i,a[100];
void citire()
{
cin>>n;
for(i=1;i<=ceil((float)n/2);i++)
a[i]=2*i-1;
for(i=n;i>ceil((float)n/2);i--)
a[i]=2*(n-i)+2;
}
int main()
{
citire();
for(i=1;i<=n;i++)
cout<<a[i]<<" ";
}

28
Problema nr. 13 Fisierul problema4.in contine pe prima linie un numar natural n(n<100) iar pe
a doua linie n numere mai mici decat 1000 separate prin spatiu. Scrieti programul C/C++ ce
determina cate elemente situate pe a doua linie din fisier sunt egale cu partea intreaga a mediei
lor aritmetice.
Exemplu : Daca fisierul problema8.in contine :
5
23435
se va afisa 2 (media aritmetica este 3.4 si exista 2 numere egale cu 3).
#include<fstream.h>
ifstream f("pro4.in");
b n,a[100],i,ok,med,s;
void citire()
{
f>>n;
for(i=1;i<=n;i++)
{
f>>a[i];
}
}
void fct()
{
for(i=1;i<=n;i++)
s=s+a[i];
med=s/n;
for(i=1;i<=n;i++)
if(a[i]==med)
ok++;
cout<<ok;
}
void main()
{
citire();
fct();
}
29
 CONCLUZII

Subprogramele au o serie de avantaje care fac programarea mai usoara si mai eficienta.
Impartirea unei probleme mari in mai multe probleme mici este un principiu aplicabil in viata de
zi cu zi, fapt care m-a determinat sa aleg aceasta tema pentru sustinerea lucrarii de atestat la
informatica.

Bibliografie
http://fmi.unibuc.ro/ro/pdf/2012/admitere/Subprograme.pdf

http://89.121.249.92/2010-2011/Catedre/Informatica/11/Subprograme.pdf

http://www.scribd.com/doc/21297279/50/Parametrul-tablou#page=45

http://profinfocntv.files.wordpress.com/2012/02/noc89biuni-teoretice-referitoare-la-
subprograme-c3aen-c.pdf

30