LICEUL TEORETIC

DUNAREA

LUCRARE PENTRU ATESTAREA

COMPETENTELOR PROFESIONALE
LA INFORMATICA

Profesor coordonator:
Bibicu Dorin

Elev:
Ilie Dragos Gabriel
Clasa a-XII-C

-2016-

TEMA PROIECTULUI
Subprograme

Cuprins
Motivatie........................................................................................................................ 4
Definitie......................................................................................................................... 4
Avantaje......................................................................................................................... 4
Structura........................................................................................................................ 5
Definitia..................................................................................................................... 5
Parametrii unui subprogram................................................................................................ 6
Clasificare...................................................................................................................... 6
VIVariabile..................................................................................................................... 7
Transmiterea parametrilor................................................................................................. 10
Modul de transfer al parametrilor........................................................................................ 10
Transfer prin valoare.................................................................................................... 10
Transfer prin referin................................................................................................... 12
Supradefinirea funciilor................................................................................................... 13
Tipuri speciale de parametri.............................................................................................. 14
Funcii 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
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
Funciile :
sunt eseniale n construcia blocurilor
permit folosirea facilitilor oferite de programarea structurat
permit elaborarea unor aplicaii proprii utilizatorului
permit obinerea unor funcii mai complexe prin combinareaunora mai simple, care scriu, citesc,
testeaz i depaneaz programe
Un program C++ conine cel putin o funcie main() care este apelat la lansarea n execuie a
programului, funcii predefinite (de bibliotec) ifuncii construite de programator.

Structura
Un subprogram (funcie) are o definiie i attea apeluri cte sunt necesare.
Declarare:
Dac o funcie este apelat dintr-o bibliotec standard sau definit de utilizator sub forma de
fiier obiect sau dac se afl ntr-un alt fiier surs, pentru a verifica validitatea apelurilor de ctre
compilator esteobligatorie folosirea declaraiei acelei funcii, declaraie numit prototip.
Declaraia are forma :
tip-rez nume(lista);
unde lista poate conine doar tipul parametrilor i numrul lor fr a fineaprat necesar i
specificarea numelui lor (care este nsrecomandat).Prototipul unei funcii trebuie pus naintea
primului apel al su, de obiceichiar la nceputul programului.

Definitia unei functii este alcatuita din:

1. Antetul subprogramului
tip_returnat nume_funcie(lista parametrilor formali)
El conine urmtoarele:
-

tipul rezutatului dat de tip_returnat: int, char, char*, long, float, void, etc.
n cazul n care tipul rezultatului este diferit de void, corpul funciei trebuie s conin cel puin o
instruciune return. Instruciunea return va specifica valoarea calculat i returnat de funcie care
trebuie s fie de acelai 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 declaraii de variabile separate prin virgul. Aceast list
poate s fie i vid.

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

Corpul funcieieste un bloc, care implementeaz algoritmul de calcul folosit de ctre funcie. n
corpul funciei apar (n orice ordine) declaraii pentru variabilele locale i instruciuni.
Apelul unei funcii care nu returneaz o valoare are forma general:
nume_funcie (lista parametrilor efectivi);

Parametrii unui subprogram

Parametri formali apar n antetul subprogramului i sunt utilizai de subprogram pentru
descrierea abstract a unui proces de calcul.
Parametri actuali apar n instruciunea de apelare a unui subprogram i sunt folosii la execuia
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 execuiei instruciunii 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. Funcii operand: subprogram care returneaz un rezultat chiar prin numele lui, dar eventual
poate returna i alte rezultate prin intermediul parametrilor de ieire;
Apelul unei funcii operand se realizeaz in expresii (atribuire, instruciuni de control (if, while,
for) ) sau ca parametrii ai unei alte funcii.
Tipul unei funcii operand poate fi:
-numeric (intreg sau real)
- character
- pointer
-nregistrare(struct)
6

NU poate fi tablou (vectori, matrici, string-uri)

2. Funcii procedurale:subprogram care are una, mai multe sau nici o valoare, valorile se
returneaz prin intermediul parametrilor; apelul unei funcii procedurale se realizeaz printr-o
instruciune procedurala cu sintaxa:
nume_subprogram (list de parametric actuali), de exemplu sch(a,b);
Tipul unei funcii procedurale este void.

VIVariabile
Sistemul de operare aloc fiecrui program trei zone distincte n memoria intern n care se
gsesc 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.
Funcia main.
n C, numele de funcie main determin prima instruciune pe care o va executa programul.
Acesta este unica diferen dintre main i celelalte funcii.
Variabile locale
La fel cum se declar variabilele n cadrul funciei main, la fel se pot declara varibile n cadrul
celorlalte funcii. Aceste variabile se numesc locale i sunt accesibile doar de funcia care le-a
declarat.
La fel n cadrul unei funcii se pot apela i alte funcii, ca i n main, dac acestea au fost definite
naintea eventualului apel sau dac este prezent un prototip de funcie naintea funciei apelante i
o definiie de funcie n cadrul programului respectiv sau n fiierele incluse n programului
respectiv.

Variabile globale
Sunt declarate n afara oricrei funcii i pot sunt vizibile (pot fi utilizate) n tot programul (n
rogramul principal i n subprograme) din momentul declarrii lor.
Mai jos, sunt cateva exemple care ilustreaza modul de folosire a variabilelor locale si globale.
# 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 oricrei funcii.
x este variabil local, vizibil doar n cadrul funciei f1().
Se va afia:
4
10
5

#include <iostream.h>
int N;
8

void f1()
{
int x=5;
cout << endl << x;
P=2 //eroare
}
int P=9;
void main ()
{
f1();
cout << x;
P=7;//corect
}
Compilatorul genereaz eroare deoarece funcia main ncearc s acceseze variabila x care este
vizibil doar n funcia 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 afieaz 3
N este variabil global.
Poate fi accesat n cadrul oricrei funcii.
9

x este variabil local.

Poate fi accesat doar n cadrul funciei f1()
p este parametru formal.
Poate fi accesat doar n f1().

Transmiterea parametrilor
Parametrii actuali trebuie s corespund celor formali, ca numr 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 transmii i memorai n stiv sunt variabile. Numele lor
este cel din lista parametrilor formali.
Variabilele obinute n urma memorrii parametrilor transmii sunt variabile locale.
La revenirea n blocul apelant, coninutul variabilelor memorate n stiv se pierde.

Modul de transfer al parametrilor

Transfer prin valoare
Parametrului i se atribuie o valoare, o expresie sau coninutul unei variabile. Se folosete, de
obicei, numai pentru parametrii de intrare.Dac se utilizeaz, totui, 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)
10

{
int z;
z=x; x=y; y=z;
}
int main()
{
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 ieire, 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);//atenie la parametri
cout<<a<<` `<<b; //a=20, b=10
return 0;
}

11

Transfer prin referin

Subprogramul primete o adres de memorie la care este stocat variabila primit ca parametru.
Se folosete pentru parametrii de ieire, sau intrare/ieire. In lista parametrilor formali, sunt
precedai de operatorul adres de memorie (caracterul &).
Parametrii efectivi corespunztori parametrilor formali transmii prin referin TREBUIE s fie
doar variabile, adic nu pot fi constante, expresii, apeluri ale altor funcii;
Varianta 3
(transfer prin referin a parametrilor de ieire)
# 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;
}

12

Supradefinirea funciilor
C ++ permite definirea mai multor funcii cu acelainumedar cu liste de parametrii (semnturi)
diferite ca tip sau ca numr al parametrilor.Supradefinirea funciilor care au parametrii cu valori
implicite poategenera duplicarea semnturii funciilor respective, ambiguitate pe
carecompilatorul o semnleaz ca eroare.
Aceast facilitate permite obinerea unui rezultat chiar dac tipurile parametrilor difer. Ea
contribuie la simplificarea programrii pentru c permite folosirea unui singur nume de funcie
cnd programul trebuie sndeplineasc 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

13

Tipuri speciale de parametri

Parametrul tablou
Funciile care transmit ca parametru un tablou necesit declararea acelui parametru ca pointer la
tipul de baz al tabloului.
Prototipul funciei are sintaxa:
tip_baza nume_tablou;
tip_rez nume_fct (tip_baza*, alte_tipuri);
Definirea unei funcii cu parametru tablou are sintaxa:
tip_rez nume_fct (tip_baza*tab, alti_parametri)
tip_rez nume_fct (tip_baza tab[], alti parametri)

Exemplu. Funcia 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)
{
14

for (int i=0, s=0; i<n; i++)

s + = p[i];
return s;
}
Parametrul ir de caractere
irurile de caractere n C + + sunt considerate tablouri de caractere. Dac un ir de caractere este
parametrul unei funcii, pentru el sunt valabileaceleai reguli ca la parametrul tablou.
Exemplu.
Programul urmtor calculeaz numrul de caractere litere micidintr-un ir de caractere prin
funcia contor care primete ca parametrurespectivul ir. Introducerea irului se face cu funcia
de bibliotec predefinit gets() din fiierul antet stdio.h. Funcia contor atribuie
adresa parametrului ir unui pointer local psir. Acesta este folosit de funcie 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);
15

cout << Sirul introdus << sir << contine << contor (sir) <<caractere mici<<endl;
}
Dup compilare i rulare programul afieaz:
Sirul introdus Asd$%90bc contine 4 caractere mici.
Sirul introdus UN907.12CD contine 0 caractere mici.
Transmiterea structurilor unei funcii

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

persoana P;
Citeste (P);
Afiseaza(P);
}
Modificarea membrilor structurii necesita apelul prin referin pe cand pentru a afia o structur
este suficient apelul prin valoare

Funcii recursive
Dac o funcie se autoapeleaz direct sau indirect se numete recursiv. Astfel apelul unei funcii
recursive poate aprea i n definiia sa. O funcie recursiv nu are sintax special. Ea implic
existena unei stive care la fiecare apel al funciei 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 numr 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;
17

}
Calcul recursiv
#include < iostream.h>
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;
}

18

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

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()
{for(long int x=1001;x<=99999;x++)
if(prim(x) && prim(rasturnat(x))) cout<<x<<endl;
}

Problema nr. 3.Scriei definiia complet a subprogramului numar, cu trei parametri, care
primete prin intermediul parametrului n un numr natural format din cel mult 9 cifre, iar prin
intermediul parametrilor c1 i c2 cte o cifr nenul. Subprogramul caut fiecare apariie a
cifrei c1 n n, i dac aceasta apare, o nlocuiete cu c2. Subprogramul furnizeaz tot prin n
numrul astfel obinut. Dac cifra c1 nu apare n n, atunci valoarea lui n rmne 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;
20

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

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;
21

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

23

Problema nr. 5.Scriei definiia complet a subprogramului reduce, cu doi parametri, care
primete prin intermediul parametrilor a i b dou numere naturale formate din cel mult 9 cifre
fiecare. Funcia returneaz o valoare obinut din numrul a prin nsumarea acelor cifre diferite
de 0 ale numrului a care NU divid numrul b. Dac nu exist asemenea cifre, se va returna
valoarea 0.
Exemplu: pentru a=184465709 i b=18, cifrele corespunztoare cerinei 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;
}
return s;
}

Problema nr. 6.Subprogramul sfx primete prin singurul su parametru, x, un numr natural
din intervalul [100,2000000000] i returneaz valoarea 1 dac ultimele trei cifre ale numrului
sunt n ordine strict descresctoare 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++ definiia complet a subprogramului calcul, care
primete prin intermediul celor doi parametri ai si dou numere ntregi, n i k (1n10000 i
1k5), i returneaz cifra de rang k a numrului n. Rangul unei cifre este numrul su de
ordine, numerotnd cifrele de la dreapta la stnga; cifra unitilor are rangul 1. Dac numrul k
este mai mare dect numrul de cifre ale lui n, atunci funcia returneaz valoarea -1.
Exemplu : n urma apelului calcul(9243, 3) se va returna 2.
#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.Scriei definiia complet a unui subprogram s care primete prin intermediul
parametrului n un numr natural de maximum 9 cifre, prin intermediul parametrului c o cifr i

furnizeaz prin intermediul parametrului k numrul de cifre ale numrului n care aparin
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;
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 cruia primete
un numr natural de cel puin 3 cifre i cel mult 9 cifre, cu toate cifrele nenule. Subprogramul
furnizeaz tot prin intermediul parametrului k, valoarea obinut prin eliminarea primei i
ultimei cifre a numrului transmis la apel.
Exemplu: dac subprogramul primete prin intermediul parametrului k valoarea 12438, n urma
apelului subprogramului Nr, k va primi valoarea 243.
Scriei, n limbajul C/C++, definiia 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;}

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 (1n100),
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.
#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];
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 (1n100), 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]<<" ";
}

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

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-subprogramec3aen-c.pdf