Tablouri unidimensionale (vectori)

1.1. Noţiuni teoretice

Declararea vectorului:
1
tip_elemente_vector nume_vector [dimensiune_maximă_vector]; unde:
 tip_elemente_vector - precizează tipul elementelor vectorului (întregi, reale, caracter,
etc.)
 nume_vector – identificator, precizează numele dat tabloului
 dimensiune_maximă_vector – numărul maxim de elemente din vector (o constantă
întreagă)

! Dacă vectorul conține n elemente, indicii (pozițiile) elementelor au valori întregi în

intervalul [0,n-1].

Exemple:
 int vect [25] – am declarat un tablou unidimensional (vector) cu numele vect, de maxim
25 elemente de tip întreg. Elementele vectorului au indicii în intervalul [0,24].
 float x [55] – am declarat un tablou unidimensional (vector) cu numele x, de maxim 55
elemente de tip float. Elementele vectorului au indicii în intervalul [0,54].

!Alte modalități de declarare a vectorilor:

a) # define maxim 10 //am definit constanta maxim cu valoarea 10
char vect[maxim]; //am declarat un tablou unidimensional (vector) cu numele vect, de
maxim 10 elemente de tip caracter. Elementele vectorului au indicii în intervalul [0,9].
b) tip_elemente_vector nume_vector [dimensiune_maximă_vector]= lista de valori;
Exemple:
 int vect[6]={21,22,23,24,25,26}
 float x[5]={2.3, 7.5, 2.15, 4.39, 9.1}

!Atunci când declarăm un vector cu inițializarea elementelor sale, numărul maxim de

elemente ale tabloului nu trebuie precizat neapărat deoarece compilatorul determină automat
mărimea tabloului în funcșie de numărul de elemente inițializate.
Exemple:
 char vect[]={‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’}
 float x[]={2.3, 7.5, 2.15, 4.39, 9.1}

Un element al unui vector poate fi utilizat ca orice altă variabilă. Pentru a ne referi la un
element al vectorului folosim numele vectorului și indicele elementului între paranteze pătrate.
Exemplu:
 int vect[6]={21,22,23,24,25,26}

vect = 21 22 23 24 25 26
indice (i) 0 1 2 3 4 5
cum ne vect[0] vect[1] vect[2] vect[3] vect[4] vect[5]
referim la
element
 Elementul aflat pe poziția 3 în vectorul vect are valoarea 23 (vect[2]=23).

!Pentru simplitate, se pot considera elementele vectorului începând cu poziția 1, caz în

care trebuie să avem grijă când inițializăm dimensiunea maximă a vectorului, iar pentru
elementul aflat pe poziția 0 are valoarea alocată implicit la compilare și rămâne neutilizat.

Inițializarea unui vector: 2

a. prin introducerea datelor de
la tastatură/fișier
b. prin folosirea instrucţiunii
de atribuire
c. prin utilizarea unei
constante de tip tablou
int x[10],n;
cin>>n;
for (int i=0; i<n; i++)
cin >> x[i];
//elementele vectorului x vor fi introduce de la tastatură
int a[10],n;           
for (int i=0; i<n; i++)
a[i]=2*i;                        
//toate componentele vectorului a sunt iniţializate cu 2*i (deci
elementele vectorului vor fi 0, 2,4,6,8...
int v[5] = {10,20,30,40,50};
int t[10] = {11,12,13};
// t[0] = 11, t[1] = 12, t[2] = 13; celelalte componente ale tabloului
t[3], …, t[9] au  valoarea 0 dacă tabloul este declarat global
(înainte de funcția main) sau o valoare
iniţială imprevizibilă dacă tabloul este declarat local (în interiorul
funcției main).

Afișarea elementelor unui vector:

for (int i=0; i<n; i++)
cout<<vect[i];

Operații cu vectori:
1. prelucrarea componentelor vectorului

1. Se dă de la tastatură un vector cu n componente numere întregi (1<=n<=100). Să se

scrie un program care afișează elementele care au suma cifrelor impară.
Exemplu: pentru n=5 și vectorul v=(122, 12, 24, 456, 910) se va afișa: 122, 12, 456
#include <iostream>
using namespace std;
int n,i, v[101],s,x;
int main()
{
cout<<"Dimensiunea vectorului:";
cin>>n;
for(i=1;i<=n;i++)
cin>>v[i];
for(i=1;i<=n;i++)
{
s=0;
x=v[i];
while(x!=0)
{
s=s+x%10;
x=x/10;
}
 if(s%2==1) cout<<v[i]<<" ";}
return 0;}

2. Se dă de la tastatură un vector cu n componente numere întregi (1<=n<=100). Să se

scrie un program care afișează elementele care sunt puteri ale lui 3.
Exemplu: pentru n=5 și vectorul v=(122, 12, 9, 456, 27) se va afișa: 9, 27
#include <iostream> 3
using namespace std;
int n,i, v[101],p,x;
int main()
{
cout<<"Dimensiunea vectorului:";
cin>>n;
for(i=1;i<=n;i++)
cin>>v[i];
for(i=1;i<=n;i++)
{
p=1;
while(p<v[i])
p=p*3;
if(p==v[i]) cout<<v[i]<<" ";
}
return 0;}

3. Se dă de la tastatură un vector cu n componente numere întregi (1<=n<=100). Să se

scrie un program care afișează elementele care au minim 3 cifre, iar numărul format din ultimele
2 cifre este număr prim.
Exemplu: pentru n=5 și vectorul v=(123, 12, 19, 1459, 217) se va afișa: 123, 1459, 217
#include <iostream>
using namespace std;
int n,i,v[101],b,d,x;
int main()
{
cout<<"Dimensiunea vectorului:";
cin>>n;
for(i=1;i<=n;i++)
cin>>v[i];
for(i=1;i<=n;i++)
{
if(v[i]>99)
{
x=v[i]%100;
b=1;
d=2;
while (d<=x/2 && b==1)
{
if(x%d==0) b=0;
d++;
}
if(b==1) cout<<v[i]<<" ";
}
}
 return 0;}
2. construirea unui vector

1. Se dă de la tastatură un număr natural n (1<=n<=100). Să se scrie un program care să

construiască un vector cu primele n numere cuburi perfecte nenule.
Exemplu: pentru n=5 se va afișa vectorul: 1, 8, 27, 64, 125
#include <iostream> 4
using namespace std;
int n,i, v[100];
int main()
{
cin>>n;
for(i=1;i<=n;i++)
v[i]=i*i*i;
for(i=1;i<=n;i++)
cout << v[i]<<" ";
return 0;}

2. Se dă de la tastatură un număr natural n cu cel mult 9 cifre. Să se scrie un program care

să construiască un vector cu pătratele perfecte ale cifrelor numărului de la dreapta la stânga.
Exemplu: pentru n=92645 se va afișa vectorul: 25, 16, 36, 4, 81.
#include <iostream>
using namespace std;
int n,i,k,c,v[100];
int main()
{
cin>>n;
k=0;
while(n!=0)
{
k++;
c=n%10;
v[k]=c*c;
n=n/10;
}
for(i=1;i<=k;i++)
cout << v[i]<<" ";
return 0;}

3. inserări și eliminări de componente dintr-un vector

1. Se dă de la tastatură un vector cu n componente numere naturale nenule (1<=n<=100).

Să se scrie un program care elimină din vector cel mai mare element par.
Cum procedăm?
 Citim elementele vectorului și pe măsură ce le citim determinăm și cel mai mare
element par (reținem cel mai mare element par și poziția pe care acesta se află în variabila poz)
 Elementele cu indicii poz+1, poz+2,...,nse mută spre stânga cu o poziție
 Dimensiunea n a vectorului se micșorează cu 1
 Se afișează vectorul astfel obținut

Exemplu: pentru n=5 și vectorul v=(122, 13, 25, 910, 456) se va afișa: 122, 13, 25, 456
 (elementul maxim par este 910)
Elemente vector 122 13 25 910 456
Indice 1 2 3 4 5
Dorim să eliminăm din vector elementul maxim par=910 și se află pe poziția 4 (poz=4)

Elemente vector 122 13 25 910 456

Indice 1 2 3 4 5 5
Vectorul obținut va fi:
Elemente vector 122 13 25 456
Indice 1 2 3 4
Algoritmul:
#include <iostream>
using namespace std;
int n,i,v[101],maximp=0,poz;
int main()
{
cout<<"Dimensiunea vectorului:";
cin>>n;
for(i=1;i<=n;i++)
{cin>>v[i];
if(v[i]%2==0 && v[i]>maximp) {maximp=v[i];
poz=i;}
}
for(i=poz+1;i<=n;i++)
v[i-1]=v[i];
n--;
for(i=1;i<=n;i++) cout<<v[i]<<" ";
return 0;}

2. Se dă de la tastatură un vector cu n componente numere naturale nenule (1<=n<=100) și

un număr natural p. Să se scrie un program care elimină din vector elementele care sunt prime cu
p.
Cum procedăm?
 Citim elementele vectorului și variabila p
 Parcurgem vectorul și analizăm dacă elementul de pe poziția curentă este prim cu p
 Dacă elementul de pe poziția curentă este prim cu p ștergem acest element folosind
algoritmul de la problema 1.
Observație:
Trebuie să fim atenți la indici pentru că în momentul în care în vector avem elemente aflate
pe poziții consecutive care îndeplinesc condiția este posibil să nu-l analizăm pe cel de-al doilea
(deci valoarea indicelui i crește doar dacă nu eliminăm element din vector)
Exemplu: pentru n=6, p=20 și vectorul v=(122, 13, 273, 910, 456, 121, 60) se va afișa:
122, 910, 456,60

Elemente vector 122 13 273 910 456 121 60

Indice 1 2 3 4 5 6 7
p 20 20
Nu sunt Sunt prime
prime între între ele și se
ele și se trece elimină
la următorul elementul
element
 Se obține vectorul și trebuie analizat dacă elementul care acum este pe poziția 2 este prim
cu p:

Elemente vector 122 273 910 456 121 60

Indice 1 2 3 4 5 6
p 20 20 6
Nu sunt Sunt prime
prime între între ele și se
ele și se trece elimină
la următorul elementul
element
Se obține vectorul și trebuie analizat dacă elementul care acum este pe poziția 2 este prim
cu p:

Elemente vector 122 910 456 121 60

Indice 1 2 3 4 5
p 20 20 20 20
Nu sunt Nu sunt Nu sunt Sunt prime
prime între prime între prime între între ele și se
ele și se trece ele și se trece ele și se trece elimină
la următorul la următorul la următorul elementul
element element element
Se obține vectorul și trebuie analizat dacă elementul care acum este pe poziția 4 este prim
cu p:
Elemente vector 122 910 456 60
Indice 1 2 3 4
p 20 20 20 20
Nu sunt Nu sunt Nu sunt Nu sunt
prime între prime între prime între prime între
ele și se trece ele și se trece ele și se trece ele și se trece
la următorul la următorul la următorul la următorul
element element element element

Algoritmul:
#include <iostream>
using namespace std;
int n,i,v[101],x,y,p,j,poz;
int main()
{
cout<<"Dimensiunea vectorului:";
cin>>n;
cout<<"Numarul p:";
cin>>p;
for(i=1;i<=n;i++)
cin>>v[i];
i=1;
while(i<=n)
{x=v[i];
y=p;
while (x!=y)
if (x>y) x=x-y;
else y=y-x;
if (x!=1) i++;
else {poz=i;
for(j=poz+1;j<=n;j++)
v[j-1]=v[j];
 n--;}}
for(i=1;i<=n;i++) cout<<v[i]<<" ";
return 0;}

3. Se dă de la tastatură un vector cu n componente numere naturale nenule (1<=n<=100) și

un număr natural p. Să se scrie un program care inserează între două elemente pare aflate pe
poziții consecutive din vector valoarea p. 7
Exemplu: pentru n=5, p=20 și vectorul v=(122, 12, 273, 910, 456) se va afișa: 122, 20, 12,
273, 910, 20, 456
#include <iostream>
using namespace std;
int n,i,v[101],p,j;
int main()
{
cout<<"Dimensiunea vectorului:";
cin>>n;
cout<<"Numarul p:";
cin>>p;
for(i=1;i<=n;i++)
cin>>v[i];
i=1;
while(i<n)
{if (v[i]%2!=0 || v[i+1]%2!=0) i++;
else {
for(j=n;j>=i+1;j--)
v[j+1]=v[j];
v[i+1]=p;
n++;
i=i+2;}}
for(i=1;i<=n;i++) cout<<v[i]<<" ";
return 0;}

4. Se dă de la tastatură un vector cu n componente numere naturale nenule (1<=n<=100).

Să se scrie un program care inserează după un element număr prim pătratul perfect al acestuia.
Exemplu: pentru n=5 și vectorul v=(12, 13, 10, 7, 5) se va afișa: 12, 13, 169, 10, 7, 49, 5, 25
#include <iostream>
using namespace std;
int n,i,v[101],b,d,j,x;
int main()
{
cout<<"Dimensiunea vectorului:";
cin>>n;
for(i=1;i<=n;i++)
cin>>v[i];
i=1;
while(i<=n)
{b=1;
d=2;
x=v[i];
while (d<=v[i]/2 && b==1)
{
if(v[i]%d==0) b=0;
 d++;
}
if (b!=1) i++;
else {
for(j=n;j>=i+1;j--)
v[j+1]=v[j];
v[i+1]=x*x; 8
n++;
i=i+2;}}
for(i=1;i<=n;i++)cout<<v[i]<<" ";
return 0;}

4. ordonarea elementelor unui vector sau sortarea – presupune aranjarea

elementelor unui vector după un anumit criteriu (crescător, descrescător, alfabetic). Există mai
multe metode de sortare bazate pe algoritmi diferiți:

 Sortarea prin metoda bulelor – această metodă presupune parcurgerea vectorului și se

compară fiecare element cu cel care urmează după el. Dacă cele două elemente nu sunt în ordine
se interschimbă între ele. Vectorul se parcurge de mai multe ori până când nu mai are loc nicio
interschimbare (vectorul este sortat).
Pentru a ști când nu mai are loc nicio interschimbare folosim o variabilă logică care la
fiecare nouă parcurgere a vectorului are inițial valoarea TRUE (1- presupunem că vectorul este
sortat) și care la fiecare interschimbare va lua valoarea FALSE (0 – vectorul nu este sortat
deoarece are loc o interschimbare). Când vectorul este sortat această variabilă va avea valoarea
TRUE (1) la sfârșitul algoritmului.

Se consideră următorul vector de dimensiune 5:

v = 103 45 27 215 92
i 1 2 3 4 5

Pentru sortarea vectorului prin metoda bulelor se parcurg următorii pași:

Parcurgerea 1:
Variabila ok=1
 i=1 și comparăm elementele v[1] cu v[2] (v[1]=103>v[2]=45 adevărat, deci cele două valori
se interschimbă între ele) și variabila ok=0
v = 103 45 27 215 92 v = 45 103 27 215 92
i 1 2 3 4 5 i 1 2 3 4 5

 i=2 și comparăm elementele v[2] cu v[3] (v[2]=103>v[3]=27 adevărat, deci cele două valori
se interschimbă între ele) și variabila ok=0
v = 45 103 27 215 92 v = 45 27 103 215 92
i 1 2 3 4 5 i 1 2 3 4 5

 i=3 și comparăm elementele v[3] cu v[4] (v[3]=103>v[4]=215 fals, deci se trece la următorul i
v = 45 27 103 215 92
i 1 2 3 4 5

 i=4 și comparăm elementele v[4] cu v[5] (v[4]=215>v[5]=92 adevărat, deci cele două valori
se interschimbă între ele) și variabila ok=0
 v= 45 27 103 215 92 v= 45 27 103 92 215
i 1 2 3 4 5 i 1 2 3 4 5

Cum după prima parcurgere variabila ok=0 se trece la o nouă parcurgere.

Parcurgerea 2:
Variabila ok=1 9
 i=1 și comparăm elementele v[1] cu v[2] (v[1]=45>v[2]=27 adevărat, deci cele două valori se
interschimbă între ele) și variabila ok=0
v = 45 27 103 92 215 v = 27 45 103 92 215
i 1 2 3 4 5 i 1 2 3 4 5

 i=2 și comparăm elementele v[2] cu v[3] (v[2]=45>v[3]=103 fals, deci se trece la următorul i
v = 27 45 103 92 215
i 1 2 3 4 5
 i=3 și comparăm elementele v[3] cu v[4] (v[3]=103>v[4]=92 adevărat, deci cele două valori
se interschimbă între ele) și variabila ok=0
v = 27 45 103 92 215 v = 27 45 92 103 215
i 1 2 3 4 5 i 1 2 3 4 5

 i=4 și comparăm elementele v[4] cu v[5] (v[4]=103>v[5]=215 fals, deci se trece la următorul i 10
v = 27 45 92 103 215
i 1 2 3 4 5

Cum după a doua parcurgere variabila ok=0 se trece la o nouă parcurgere.

Parcurgerea 3:
Variabila ok=1
 i=1 și comparăm elementele v[1] cu v[2] (v[1]=27>v[2]=45 fals, deci se trece la următorul i
v = 27 45 92 103 215
i 1 2 3 4 5
 i=2 și comparăm elementele v[2] cu v[3] (v[2]=45>v[3]=92 fals, deci se trece la următorul i
v = 27 45 92 103 215
i 1 2 3 4 5

 i=3 și comparăm elementele v[3] cu v[4] (v[3]=92>v[4]=103 fals, deci se trece la următorul i
v = 27 45 92 103 215
i 1 2 3 4 5 11
 i=4 și comparăm elementele v[4] cu v[5] (v[4]=103>v[5]=215 fals, deci se trece la următorul i
v = 27 45 92 103 215
i 1 2 3 4 5

Cum după acestă parcurgere variabila ok=1 înseamnă că vectorul este ordonat.

Să se scrie un algoritm care ordonează crescător un vector cu n elemente numere naturale.

Algoritmul:
#include <iostream>
using namespace std;
int n,i,v[101],ok=0,aux;
int main()
{
cout<<"Dimensiunea vectorului:";
cin>>n;
for(i=1;i<=n;i++)
cin>>v[i];
while (ok==0)
{ok=1;
for(i=1;i<n;i++)
if(v[i]>v[i+1]){aux=v[i];
v[i]=v[i+1];
v[i+1]=aux;
ok=0;}}
for(i=1;i<=n;i++)
cout<<v[i]<<" ";
return 0;}

 Sortarea prin selecție directă - această metodă  constă în a compara primul element

(v[1]) pe rând cu toate elementele de după el şi dacă ordinea de sortare nu este respectată, cele
două elemente se interschimbă. După efectuarea tuturor comparaţiilor, în prima poziţie ajunge
cel mai mic element din vector (în cazul ordonării crescătoare). Se compară apoi al doilea
element cu toate elementele de după el etc. La ultimul pas se compară numai ultimele două
elemente.
Se consideră următorul vector de dimensiune 5:
v = 103 45 27 215 92
i 1 2 3 4 5

Pentru sortarea vectorului prin selecție directă se parcurg următorii pași:

 Pentru i=1 luăm toate elementele începând cu poziția 2 și le comparăm cu v[1]
 v[1]=103>v[2]=45 adevărat, deci cele două valori se interschimbă între ele
v = 103 45 27 215 92 v = 45 103 27 215 92
i 1 2 3 4 5 i 1 2 3 4 5
  v[1]=45>v[3]=27 adevărat, deci cele două valori se interschimbă între ele
v= 45 103 27 215 92 v = 27 103 45 215 92
i 1 2 3 4 5 i 1 2 3 4 5

 v[1]=27>v[4]=215 fals, deci se trece la urrmătoarea poziție

v= 27 103 45 215 92
i 1 2 3 4 5 12
 v[1]=27>v[5]=92 fals, deci se trece la al doilea element din vector
v= 27 103 45 215 92
i 1 2 3 4 5
În acest moment elementul cel mai mic se află pe poziția finală.

 Pentru i=2 luăm toate elementele începând cu poziția 3 și le comparăm cu v[2]

 v[2]=103>v[3]=45 adevărat, deci cele două valori se interschimbă între ele

v= 27 103 45 215 92 v= 27 45 103 215 92

i 1 2 3 4 5 i 1 2 3 4 5

 v[2]=45>v[3]=103 fals, deci se trece la urrmătoarea poziție

v= 27 45 103 215 92
i 1 2 3 4 5
  v[2]=45>v[4]=215 fals, deci se trece la urrmătoarea poziție
v= 27 45 103 215 92
i 1 2 3 4 5

 v[2]=45>v[5]=92 fals, deci se trece la al treilea element din vector

v= 27 45 103 215 92 13
i 1 2 3 4 5

În acest moment elementul de pe poziția 2 se află pe poziția finală.

 Pentru i=3 luăm toate elementele începând cu poziția 4 și le comparăm cu v[3]
 v[3]=103>v[4]=215 fals, deci se trece la urrmătoarea poziție

v= 27 45 103 215 92
i 1 2 3 4 5

 v[3]=103>v[5]=92 adevărat, deci cele două valori se interschimbă între

v= 27 45 103 215 92 v = 27 45 92 215 103
i 1 2 3 4 5 i 1 2 3 4 5

 Pentru i=4 luăm toate elementele începând cu poziția 5 și le comparăm cu v[4]

 v[4]=215>v[5]=103 adevărat, deci cele două valori se interschimbă între
v = 27 45 92 215 103 v = 27 45 92 103 215
i 1 2 3 4 5 i 1 2 3 4 5

În acest moment vectorul este sortat crescător.

Algoritmul:
#include <iostream>
using namespace std;
int main (){
int n, v[100], i, j, k, aux, minim;
cout<<"Dimensiunea vectorului: ";
cin>>n;
for (i=1;i<=n;i++) cin>>v[i];

for (i=1;i<=n-1;i++){
minim=v[i];
k=i;
for (j=i+1;j<=n;j++)
if (v[j]<minim){
minim=v[j];
k=j;
}
aux=v[k];
v[k]=v[i];
v[i]=aux;
}
for (i=1;i<=n;i++)
cout<<v[i]<<" ";
return 0;}

 Sortarea prin numărare – metoda constă în construirea unui nou vector auxiliar C care
are aceiași dimensiune cu vectorul A și în care se vor memora elementele din A, apoi un vector
Bcare inițial are valoarea 0 și în care numărăm pentru fiecare element din A câte elemente mai
mici ca el există în vector. La finalul algoritmului se vor rescrie în ordine crescătoare elementele
vectorului A pe baza valorilor memorate în B și C.
Se consideră următorul vector de dimensiune 5:
A = 103 45 27 21 92
5 14
i 1 2 3 4 5
Pentru sortarea vectorului prin numărare se parcurg următorii pași:
Construim vectorul C în care memorăm valorile din vectorul A și vectorul B.

C= 103 45 27 21 92 B= 0 0 0 0 0
5 i 1 2 3 4 5
i 1 2 3 4 5

Determinăm elementele vectorului B astfel: B[i]= câte elemente mai mici decat A[i] sunt
în vectorul A.

Pe poziția 1 memorăm valoarea 3 deoarece în vectorul A avem 3 element mai mici decât
v[1]=103 (avem 45, 27, 92 mai mici decât 103)
A = 103 45 27 21 92 B= 3 0 0 0 0
5 i 1 2 3 4 5
i 1 2 3 4 5

Pe poziția 2 memorăm valoarea 1 deoarece în vectorul A avem 1 element mai mic decât
v[2]=45 (avem 27 mai mic decât 45)
A = 103 45 27 21 92 B= 3 1 0 0 0
5 i 1 2 3 4 5
i 1 2 3 4 5

Pe poziția 3 memorăm valoarea 0 deoarece în vectorul A avem 0 elemente mai mici decât
v[3]=27
A = 103 45 27 21 92 B= 3 1 0 0 0
5 i 1 2 3 4 5
i 1 2 3 4 5

Pe poziția 4 memorăm valoarea 4 deoarece în vectorul A avem 4 element mai mici decât
v[4]=215 (avem 103, 45, 27, 92 mai mici decât 215)
A = 103 45 27 21 92 B= 3 1 0 4 0
5 i 1 2 3 4 5
i 1 2 3 4 5

Pe poziția 5 memorăm valoarea 2 deoarece în vectorul A avem 2 element mai mici decât
v[5]=92 (avem 45, 27 mai mici decât 92)
A = 103 45 27 21 92 B= 3 1 0 4 2
5 i 1 2 3 4 5
i 1 2 3 4 5

Avem următorii vectori B și C:

C= 103 45 27 21 92 i 1 2 3 4 5
5
 B= 3 1 0 4 2 i 1 2 3 4 5

Se completează elementele vectorului A astfel:  A[B[i]+1]=C[i].

A= 27 45 92 103 215
i 1 2 3 4 5 15
Algoritmul:
#include <iostream>
using namespace std;
int n, A[100], B[100], C[100], i, j;
int main ()
{
cout<<"Dimensiunea vectorului: ";
cin>>n;
for (i=1;i<=n;i++) cin>>A[i];
for (i=1;i<=n;i++) C[i]=A[i];
for (i=1;i<n;i++)
for (j=i+1;j<=n;j++)
if (A[i]<A[j])
B[j]++;
else B[i]++;
for (i=1;i<=n;i++)
A[B[i]+1]=C[i];
for (i=1;i<=n;i++)
cout<<A[i]<<" ";
return 0;}

 Sortarea prin inserție – metoda constă în inserarea unui anumit element în șirul deja
sortat al predecesorilor săi. La fiecare pas un element este extras din vectorul iniţial şi este
introdus în vectorul de elemente sortate. Elementul este inserat în poziţia corectă în vectorul
sortat, astfel încât vectorul să rămână sortat în continuare.
Elementul aflat pe poziţia v[2] se compară cu v[1] şi încercăm să găsim poziţia în care ar
trebui să se introducă. Dacă v[2] < v[1] atunci v[2] trebuie să fie înainte, deci îl mutăm pe v[1]
pe poziţia următoare.
La un pas j avem vectorul sortat v[1],...,v[j-1] şi încercăm să-l inserăm pe v[j] astfel încât
să păstrăm vectorul ordonat între 1 şi j-1.
Pentru aceasta, se compară succesiv v[j] cu elementele v[j-1], v[j-2], ..., v[1] (în această
ordine), mutând elementul de la poziţia curentă cu o poziţie la dreapta atunci când v[i]>v[j].
Când v[i]<=v[j] procesul de inserţie se opreşte, poziţia la care se realizează inserarea
fiind i+1.
Se consideră următorul vector de dimensiune 5:
A = 103 45 27 21 92
5
i 1 2 3 4 5

Pentru sortarea vectorului prin inserție se parcurg următorii pași:

A = 103 45 27 21 92
5
i 1 2 3 4 5
 Se păstrează primul element 103 considerandu-se un subșir deja sortat. Apoi se trece la 45
și îi căutăm locul în subșir. Se observă că 45 este mai mic decât 103. Îl inserăm pe 45 înaintea lui
103 (mutăm toate elementele aflate după poziția pe care vrem să inserăm cu o poziție la
dreapta). 
A = 103 45 27 21 92
5
i 1 2 3 4 5 16
A= 103 27 215 92 A= 45 103 27 215 92
i 1 2 3 4 5 i 1 2 3 4 5

Se trece la 27 și îi căutăm locul în subșir. Se observă că 45 este mai mare decât 27. Îl
inserăm pe 27 înaintea lui 45 (mutăm toate elementele aflate după poziția pe care vrem să
inserăm cu o poziție la dreapta). 
A= 45 103 215 92 A = 27 45 103 21 92
i 1 2 3 4 5 5
i 1 2 3 4 5

Se trece la 215 și îi căutăm locul în subșir. Se observă că 215 nu este mai mic decât
elementele sortate până acum, deci nu se mută. 
A = 27 45 103 21 92
5
i 1 2 3 4 5

Se trece la 92 și îi căutăm locul în subșir. Se observă că 92 este mai mic decât 103 și mai
mare decât 45. Îl inserăm pe 92 înaintea lui 103 (mutăm toate elementele aflate după poziția pe
care vrem să inserăm cu o poziție la dreapta). 
A = 27 45 103 215 A = 27 45 92 103 215
i 1 2 3 4 5 i 1 2 3 4 5

Algoritmul:
#include <iostream>
using namespace std;
int n, v[100], i, j, k, x;
int main ()
{
cout<<"Dimensiunea vectorului: ";
cin>>n;
for (i=1;i<=n;i++) cin>>v[i];
for(i=1;i<=n;i++)
{k=1;
x=v[i];
while(x>v[k])
k=k+1;
for(j=i-1;j>=k;j--)
v[j+1]=v[j];
v[k]=x;
}
for (i=1;i<=n;i++)
cout<<v[i]<<" ";
return 0;
 }

 Căutarea unei valori într-un vector – presupune căutarea unei valori între elementele
unui vector.
Aceasta se poate realiza în două moduri:
 Căutarea secvențială – care presupune să parcurgem vectorul de la un capăt la
celălalt și să comparăm valoarea căutată cu fiecare element din vector. Pentru aceasta vom
17
folosi o variabilă gasit de tip adevărat sau fals. Presupunem inițial că valoarea căutată nu
este în vector (deci gasit=0). Parcurgem vectorul, iar dacă valoarea căutată este egală cu un
element din vector atunci variabila gasit=1 și putem opri căutarea. Dacă nu oprim căutarea
atunci pentru un vector cu n elemente se fac n comparări.
Algoritmul:
#include <iostream>
using namespace std;
int v[100],n,i,gasit,x;
int main()
{
cin>>n>>x;
for(i=1;i<=n;i++)
cin>>v[i];
for(i=1;i<=n && gasit==0;i++)
if(v[i]==x) gasit=1;
if(gasit==1)
cout << "Numarul se afla in vector";
else cout << "Numarul nu se afla in vector";
return 0;}

 Căutarea binară – se poate face numai într-un vector ordonat și presupune să

comparăm elementul de căutat cu elementul de pe poziția din mijloc a vectorului. Dacă
elementul căutat este egal cu elementul din mijloc căutarea s-a terminat, altfel dacă
numărul căutat este mai mic decât elementul din mijloc începem căutarea între
componentele vectorului din stânga, iar dacă numărul căutat este mai mare decât numărul
din mijloc începem căutarea între componentele vectorului din dreapta. Procedeul de
împărțire a vectorului în subvectori până când nu mai avem elemente.
Exemplu:
Se consideră următorul vector ordonat crescător de dimensiune 10:

v= 12 14 16 27 45 56 78 89 10 234
2
i 1 2 3 4 5 6 7 8 9 10
în care dorim să căutăm x=27

Notăm cu st primul indice al vectorului şi cu dr ultimul indice al vectorului, iar mij este
indicele elementului din mijloc al vectorului mij=(st+dr)/2.

st dr mij Explicație

1 10 (1+10)/2=5 v= 12 14 16 27 45 56 78 89 102 234

i 1 2 3 4 5 6 7 8 9 10
 x=27 < v[5]=45, deci vom continua căutarea în subvectorul din
stânga, adică dr=mij-1

v= 12 14 16 27 45 56 78 89 102 234
i 1 2 3 4 5 6 7 8 9 10
1 5 (1+5)/2=3
x=27 > v[3]=16, deci vom continua căutarea în subvectorul din 18
dreapta, adică st=mij+1

v= 12 14 16 27 45 56 78 89 102 234
i 1 2 3 4 5 6 7 8 9 10
4 5 (4+5)/2=4
x=27 = v[4]=27, deci am terminat căutarea

Algoritmul:
#include<iostream>
using namespace std;
int i,n,x,st,dr,mij,gasit,v[50];
int main()
{
cin>>n>>x;
for(i=1;i<=n;i++) cin>>v[i];
st=1;
dr=n;
gasit=0;
while (st<=dr && gasit!=1)
{
mij=(st+dr)/2;
if (v[mij]==x) gasit=1;
else if (x<v[mij]) dr=mij-1;
else st=mij+1;
}
if (gasit==1) cout<<"Numarul se afla in vector"<<endl;
else cout<<"Numarul nu se afla in vector"<<endl;
return 0;
}
1.2. Probleme propuse
1. Fişierul text NR.TXT conţine pe o singură linie, separate prin câte un singur spaţiu, cel
mult 100 de numere întregi, fiecare număr având cel mult 4 cifre. Scrieţi un program C/C++ care
citeşte numerele din fişierul NR.TXT şi afişează pe ecran, separate prin câte un spaţiu, în ordine
crescătoare, toate numerele naturale nenule din fişier. Dacă nu există astfel de numere se va afişa
pe ecran mesajul NU EXISTA. 19
Exemplu: dacă fişierul NR.TXT conţine numerele: -3 -10 0 7 -5 7 51 -800 6 3798, atunci
pe ecran se va afişa: 6 7 7 51 3798
(Variante BAC 2008 – varianta 002)

2. Scrieţi un program C/C++ care citeşte de la tastatură un număr natural n (0<n<=100) şi

cele 3*n elemente ale tabloului unidimensional v, fiecare element fiind un număr natural cu cel
mult patru cifre fiecare. Tabloul este împărţit în trei zone, cu câte n elemente: prima zonă conţine
primele n elemente din tablou, a doua zonă conţine următoarele n elemente din tablou, restul
elementelor fiind în zona a treia. Programul va interschimba primul element par (dacă există) al
zonei unu cu ultimul element impar (dacă există) al zonei trei şi apoi va scrie pe prima linie a
fişierului text BAC.TXT toate elementele tabloului, separate prin câte un spaţiu. În cazul în care
unul dintre aceste două elemente, care urmează a fi interschimbate, nu există, programul nu va
efectua nici o modificare asupra tabloului dat.
Exemplu: pentru n=3 şi v=(1 2 3 4 5 6 7 8 9), fişierul BAC.TXT va conţine: 1 9 3 4 5 6
782 (Variante BAC 2008 – varianta 007)

3. Se consideră două tablouri unidimensionale a şi b fiecare având numere naturale de

maximum patru cifre, ordonate crescător. Tabloul a conţine n (1<n<100) numere pare, iar tabloul
b conţine m (1<m<100) numere impare.
Scrieţi un program C/C++ care citeşte de la tastatură valoarea lui n şi cele n elemente ale
tabloului a, apoi valoarea lui m şi cele m elemente ale tabloului b după care scrie în fişierul
BAC.TXT un număr maxim de elemente ale tablourilor date, numerele fiiind scrise în ordine
crescătoare, separate prin câte un spaţiu, iar cele aflate pe poziţii consecutive fiind de paritate
diferită. Programul va utiliza un algoritm eficient din punct de vedere al timpului de executare.
Exemplu: pentru n=6, m=5 şi tablourile a=(2,4,8,10,14,16) şi b=(3,5,7,11,15 ) fişierul
BAC.TXT va avea următorul conţinut : 2 3 4 5 8 11 14 15 16
(Variante BAC 2008 – varianta 008)

4. Se consideră fişierul BAC.TXT ce conţine cel mult un milion de numere naturale

separate prin spatii, fiecare număr având cel mult nouă cifre.
Scrieţi un program C/C++ care citeşte toate numerele din fişierul BAC.TXT şi determină,
folosind un algoritm eficient din punct de vedere timpului de executare, cele mai mari două
numere de trei cifre care nu se află în fişier. Dacă nu pot fi determinate două astfel de numere,
programul va afişa pe ecran valoarea 0.
Exemplu: dacă fişierul BAC.TXT conţine numerele: 12 2345 123 67 989 6 999 123 67
989 999 atunci programul va afişa 998 997
(Variante BAC 2008 – varianta 009)

5. Evidenţa produselor vândute de o societate comercială este păstrată în fişierul

PRODUSE.TXT. Pentru fiecare produs se cunoaşte tipul produsului (un număr natural de cel
mult 4 cifre), cantitatea exprimată in kilograme (un număr natural mai mic sau egal cu 100) şi
preţul unui kilogram (un număr natural mai mic sau egal cu 100). Produsele de acelaşi tip pot fi
vândute în cantităţi diferite, fiecare vânzare fiind înregistrată separat. Fişierul PRODUSE.TXT
are cel mult 200000 de linii şi fiecare linie conţine trei numere naturale, separate prin câte un
spaţiu, ce reprezintă, în această ordine tipul, cantitatea şi preţul de vânzare al unui produs la un
moment dat. Să se scrie un program C/C++, care utilizând un algoritm eficient din
punct de vedere al timpului de executare, determină pentru fiecare tip de produs vândut suma
totală obţinută în urma vânzărilor. Programul va afişa pe câte o linie a ecranului tipul produsului
şi suma totală obţinută, separate prin câte un spaţiu, ca în exemplu.
Exemplu: dacă fişierul PRODUSE.TXT are conţinutul alăturat,
programul va afişa numerele următoare:
1 150 20
2 30
35 (Variante BAC 2008 – varianta 010)

6. Se citeşte de la tastatură un număr natural n (n≤500) şi apoi n cifre. Se cere să se afişeze

pe ecran cele n cifre citite, în ordine crescătoare, separate prin câte un spaţiu.
Exemplu: pentru n=19 şi cifrele 3 3 0 9 2 1 2 1 3 7 1 5 2 7 1 0 3 2 3 se va afişa pe ecran 0
0 1 1 1 1 2 2 2 2 3 3 3 3 3 5 7 7 9.
(Variante BAC 2008 – varianta 014)

7. În fişierul numere.txt sunt memorate maximum 10000 de numere naturale cu cel mult 9
cifre fiecare. Fiecare linie a fişierului conţine câte un număr. Se cere afişarea pe ecran, în ordine
descrescătoare, a tuturor cifrelor care apar în numerele din fişier. Alegeţi un algoritm de
rezolvare eficient din punct de vedere al timpului de executare.
Exemplu: dacă fişierul numere.txt conţine: 267 39628 79 se va tipări 9987766322.
(Variante BAC 2008 – varianta 016)

8. Fişierul text BAC.TXT conţine pe prima linie un număr natural nenul n (1≤n≤1000), iar
pe fiecare dintre următoarele n linii, câte două numere întregi a şi b (1<=a<=b<=32000), fiecare
pereche reprezentând un interval închis de forma [a,b].
Scrieţi un program C/C++ care determină intervalele care au proprietatea că
intersecţia cu oricare dintre celelalte n-1 intervale este vidă şi afişează pe câte o
linie a ecranului, separate printr-un spaţiu, numerele care reprezintă capetele
intervalelor determinate.
Exemplu: dacă fişierul BAC.TXT are conţinutul alăturat, pe ecran se va
afişa: 2 6 17 20
(Variante BAC 2008 – varianta 023)

9. Fişierul text BAC.TXT conţine pe prima linie numărul natural n, 1<=n<=30000, pe

următoarele n linii un tablou unidimensional de n numere întregi, ordonate crescător, iar pe
ultima linie două numere întregi a şi b (a<=b) separate de un spaţiu. Fiecare dintre cele n numere,
precum şi valorile a şi b, au cel mult patru cifre.
Scrieţi un program C/C++, eficient din punct de vedere al timpului de
executare, care afişează pe ecran cel mai mic număr întreg din intervalul închis [a,b]
care se găseşte în tabloul dat. Dacă nu există un astfel de număr programul afişează
textul NU.
Exemplu: dacă fişierul BAC.TXT are conţinutul alăturat, programul afişează
valoarea 11
(Variante BAC 2008 – varianta 024)

10. Se consideră două tablouri unidimensionale A şi B cu elemente numere naturale din

intervalul [1;10000]. Spunem că tabloul A “se poate reduce” la tabloul B dacă există o împărţire
pe secvenţe de elemente aflate pe poziţii consecutive în tabloul A astfel încât prin înlocuirea
secvenţelor cu suma elementelor acestora să se obţină, în ordine, elementele tabloului B.

De exemplu tabloul
 se poate reduce la tabloul

Fişierul text NUMERE.IN conţine pe prima linie două numere naturale nenule n şi m
(1≤m≤n≤100), pe linia a doua n numere naturale din intervalul [1;10000] şi pe linia a treia alte m
numere naturale din intervalul [1;10000]. Pe fiecare linie numerele sunt separate prin câte un 21
spaţiu.
Scrieţi un program C/C++ care citeşte toate numerele din fişierul NUMERE.IN şi verifică,
utilizând un algoritm eficient din punctul de vedere al timpului de executare, dacă tabloul
construit cu cele n numere aflate pe linia a doua în fişier se poate reduce la tabloul construit cu
cele m numere aflate pe linia a treia în fişier. Programul afişează pe ecran mesajul DA în caz
afirmativ şi mesajul NU în caz negativ.
(Variante BAC 2008 – varianta 029)

11. Fişierul text numere.txt conţine pe prima linie un număr natural n (0<n<100000), iar
pe doua linie, separate prin câte un spaţiu, n numere naturale formate din cel mult 2 cifre fiecare.
Scrieţi un program C/C++ care determină în mod eficient, din punct de vedere al timpului
de executare, numerele ce apar o singură dată în a doua linie a fişierului. Aceste numere vor fi
afişate pe ecran în ordine crescătoare, separate prin câte un spaţiu.
Exemplu: dacă fişierul numere.txt are următorul conţinut: 7 3 5 2 1 5 23 1 atunci pe ecran
se va afişa: 2 3 23.
(Variante BAC 2008 – varianta 042)

12. Fişierul text NUMERE.TXT conţine pe prima linie un număr natural n

(0<n<100000), iar pe a a doua linie n cifre, separate prin câte un spaţiu. Scrieţi un program C/C+
+ care determină în mod eficient, din punct de vedere al timpului de executare, cel mai mare
număr ce se poate forma cu toate cifrele conţinute de a doua linie a fişierului NUMERE.TXT.
Numărul determinat se va afişa pe ecran.
Exemplu: daca fişierul NUMERE.TXT are următorul conţinut: 7 2 5 3 1 5 8 9 atunci pe
ecran se va afişa: 9855321.
(Variante BAC 2008 – varianta 043)

13. Fişierul text NUMERE.TXT conţine pe prima linie un număr natural n

(0<n<100000), iar pe a doua linie n numere naturale, formate din cel mult 4 cifre, separate prin
câte un spaţiu.
Scrieţi un program C/C++ care determină în mod eficient, din punct de vedere al timpului
de executare, cifrele ce apar în scrierea numerelor situate pe a doua linie a fişierului. Programul
va afişa pe ecran aceste cifre in ordine crescătoare, separate prin câte un spaţiu.
Exemplu: daca fişierul NUMERE.TXT are următorul conţinut: 7 243 32 545 74 12 1344
90 atunci pe ecran se va afişa: 0 1 2 3 4 5 7 9.
(Variante BAC 2008 – varianta 044)

14. Fişierul text NUMERE.TXT conţine pe prima linie un număr natural n

(0<n<100000), iar pe a doua linie n numere naturale, formate din cel mult 2 cifre, separate prin
câte un spaţiu.
Scrieţi un program C/C++, eficient atât din punct de vedere al timpului de executare, care
afişează pe ecran toate numerele situate pe a doua linie a fişierului, în ordinea crescătoare a
valorilor lor, separate prin câte un spaţiu.
Exemplu: dacă fişierul NUMERE.TXT are următorul conţinut: 7 12 21 22 11 9 12 3
atunci pe ecran se va afişa: 3 9 11 12 12 21 22.
(Variante BAC 2008 – varianta 045)
 15. Scrieţi un program C/C++ care citeşte de la tastatură trei numere naturale a, b şi n, mai
mici decât 30000 fiecare, şi care construieşte în memorie un tablou unidimensional ale cărui
elemente memorează toţi multiplii lui n din intervalul închis determinat de a şi b. Programul va
afişa pe ecran numerele din tablou în ordinea crescătoare a lor, separate prin câte un spaţiu, iar
dacă nu există astfel de valori, va afişa pe ecran mesajul Nu. Intervalul închis determinat de a şi
b este [a,b] dacă a <b sau [b,a] dacă b≤a. 22
Exemplu: pentru a=65, b=31 şi n=9 tabloul va conţine valorile: 36 45 54 63.
(Variante BAC 2008 – varianta 049)

16. Fişierul BAC.IN conţine pe prima linie un număr natural n (0<n<5000), iar pe a doua
linie, separate prin câte un spaţiu, n numere naturale, formate din cel mult 4 cifre fiecare. Scrieţi
un program C/C++ care determină şi scrie în fişierul BAC.OUT, toate numerele, citite de pe a
doua linie a fişierului bac.in, care apar de cel puţin două ori. Numerele determinate se vor scrie
în ordine crescătoare, pe aceeaşi linie, separate prin câte un spaţiu.
Exemplu: dacă fişierul BAC.IN conţine pe prima linie numărul 11, iar pe linia a doua
valorile 23 12 54 12 78 345 67 23 78 934 23 atunci fişierul BAC.OUT va conţine: 12 23 78.
(Variante BAC 2008 – varianta 050)

17. Fişierul text DATE.IN conţine pe prima linie un număr natural nenul n (n≤100), iar pe
a doua linie n numere naturale nenule, separate prin câte un spaţiu, fiecare număr având
maximum 4 cifre. Scrieţi un program C/C++ care citeşte toate numerele din fişierul text
DATE.IN, construieşte în memorie un tablou unidimensional a, cu cele n elemente din fişier şi
afişează pe ecran perechile (ai, aj), 1≤i<j≤n, cu proprietatea că elementele fiecăreia dintre aceste
perechi au aceeaşi paritate. Fiecare pereche se va afişa pe câte o linie a ecranului, elementele
perechii fiind separate prin câte un spaţiu. În cazul în care nu există nicio pereche se va afişa
valoarea 0.
Exemplu: dacă fişierul DATE.IN are conţinutul
5
16 22 3 6 1
se vor afişa: 16 22
16 6
22 6
31
(Variante BAC 2008 – varianta 051)

18. Scrieţi un program C/C++ care citeşte de la tastatură un număr natural nenul n
(n<=100), apoi n numere naturale reprezentând elementele unui tablou unidimensional, şi
afişează pe ecran toate permutările circulare, cu o poziţie către stânga, ale elementelor tabloului.
Elementele fiecărei permutari se vor afişa pe câte o linie, separate prin câte un spaţiu.
Exemplu: dacă n=4 şi tabloul unidimensional 10 20 30 49, atunci se vor afişa:
10 20 30 49
20 30 49 10
30 49 10 20
49 0 20 30
(Variante BAC 2008 – varianta 053)

19. Se citesc de la tastatură un număr natural nenul n (n<=100) şi apoi cele n numere
naturale nenule, distincte, de maximum 4 cifre, reprezentând elementele unui tablou
unidimensional v.
 Scrieţi un program C/C++ care afişează câte dintre elementele tabloului pot fi scrise ca
sumă a altor două elemente ale tabloului. În cazul în care nu există niciun astfel de element se va
afişa valoarea 0.
Exemplu: dacă n=6 şi tabloul v are conţinutul 1,10,25,2,15, 3, atunci se va afişa valoarea 2
(deoarece 25=10+15, 3=1+2)
(Variante BAC 2008 – varianta 054)
23
20. Scrieţi un program C/C++ care citeşte de la tastatură un număr natural nenul n (n≤100)
şi 2*n numere naturale de maximum 3 cifre; primele n reprezintă elementele tabloului
unidimensional a, iar următoarele n elementele tabloului unidimensional b; fiecare tablou are
elementele numerotate începând de la 1. Programul construiește în memorie şi afişează pe ecran
cele n elemente ale unui tablou unidimensional c, în care orice element ci (1≤i≤n) se obţine
conform definiţiei următoare:

{
c i= a [ i ] concatenat cu b [i ],∧dacă a [ i ] < b [ i ]
b [ i ] concatenat cu a [i],∧altfel
Exemplu: dacă n=3 şi tablourile a şi b au conţinutul alăturat
a : (12, 123, 345)
b: (1, 234, 15), atunci conţinutul tabloului c este următorul: 112 123234 15345
(Variante BAC 2008 – varianta 055)

21. Fişierul text NUMERE.TXT conţine, pe o singură linie, cel mult 1000 de numere
naturale nenule cu cel mult 4 cifre fiecare, numerele fiind separate prin câte un spaţiu. Scrieţi un
program C/C++ care citeşte toate numerele din fişier şi scrie pe ecran toate numerele pare citite,
ordonate crescător. Dacă fişierul NUMERE.TXT nu conţine niciun număr par, atunci se va afişa
pe ecran mesajul nu exista.
Exemplu: dacă fişierul NUMERE.TXT conţine numerele 2 3 1 4 7 2 5 8 6, atunci pe
ecran se va afişa: 2 2 4 6 8
(Variante BAC 2008 – varianta 056)

22. Fişierul text INTRARE.TXT conţine, pe o singură linie, cel mult 100 de numere
naturale nenule de cel mult patru cifre fiecare, numerele fiind separate prin câte un spaţiu. Scrieţi
un program C/C++ care citeşte numerele din fişier şi scrie în fişierul text IESIRE.TXT toate
valorile obţinute prin însumarea a câte două numere din fişierul INTRARE.TXT, ordonate
crescător. Dacă o valoare se obţine ca sumă a mai multor perechi de numere din fişierul
INTRARE.TXT, ea va fi afişată o singură dată.
Exemplu: INTRARE.TXT IESIRE.TXT
1432 34567 (Variante BAC 2008 – varianta 057)

23. a) Fişierul DATE.IN conţine un şir de cel mult 10000 numere naturale (printre care
cel puţin un număr par şi cel puţin un număr impar), cu cel mult 2 cifre fiecare, separate prin câte
un spaţiu. Scrieţi un program C/C++ care citeşte numerele din fişierul DATE.IN şi scrie în
fişierul text DATE.OUT valorile distincte citite, separate prin câte un spaţiu, respectându-se
regula: pe prima linie vor fi scrise numerele impare în ordine crescătoare, iar pe linia a doua
numerele pare, în ordine descrescătoare. Alegeţi o metodă eficientă din punctul de vedere al
timpului de executare.
Exemplu: dacă pe prima linie a fişierului DATE.IN se află numerele: 75 12 3 3 18 75 1 3
atunci fişierul DATE.OUT va conţine: 1 3 75 18 12
b) Descrieţi succint, în limbaj natural, metoda de rezolvare folosită, explicând în ce constă
eficienţa ei (3 – 4 rânduri).
(Variante BAC 2008 – varianta 062)
 24. Fişierul text DATE.IN conţine pe prima linie , separate prin câte un spaţiu, cel mult
1000 de numere naturale, fiecare dintre ele având maximum 9 cifre.
a) Scrieţi un program C/C++ care citeşte numerele din fişierul DATE.IN şi determină cea
mai lungă secvenţă ordonată strict descrescător, formată din valori citite consecutiv din fişier.
Numerele din secvenţa găsită vor fi afişate pe ecran, pe o linie, separate prin câte un spaţiu. Dacă
sunt mai multe secvenţe care respectă condiţia impusă, se va afişa doar prima dintre acestea.
Alegeţi o metodă de rezolvare eficientă din punctul de vedere al timpului de executare. 24
Exemplu: dacă fişierul date.in conţine 5 2 9 4 3 6 3 2 1 0 8 pe ecran se afişează: 6 3 2 1 0
b) Descrieţi succint, în limbaj natural, metoda de rezolvare folosită, explicând în ce constă
eficienţa ei (3 – 4 rânduri).
(Variante BAC 2008 – varianta 064)

25. Fişierul text NUMERE.TXT conţine pe prima linie un număr natural n (1≤n≤10000)
şi pe a doua linie, n numere naturale cu cel mult 9 cifre fiecare. Aceste numere sunt dispuse în
ordine crescătoare şi separate între ele prin câte un spaţiu.
a) Scrieţi un program C/C++ care citeşte valorile din fişier şi, printr-o metodă eficientă din
punct de vedere al timpului de executare, afişează pe ecran, separate prin câte un spaţiu, în
ordine crescătoare, numerele pare de pe a doua linie a fişierului, urmate de cele impare în ordine
descrescătoare.
Exemplu: dacă fişierul NUMERE.TXT are conţinutul alăturat 6 212 412 5111 71113
81112 101112 atunci programul va afişa pe ecran 212 412 81112 101112 71113 5111
b) Descrieţi succint, în limbaj natural, metoda utilizată la punctul a, justificând eficienţa
acesteia.
(Variante BAC 2008 – varianta 068)

26. Fişierul BAC.TXT are pe prima linie două numere naturale n şi m (0<n<1000,
0<m<1000) separate prin câte un spaţiu, pe linia a doua n numere întregi ordonate strict
crescător, iar pe linia a treia m numere naturale distincte. Să se scrie un program care citeşte
toate numerele din fişier şi afişează pe ecran, despărţite prin câte un spaţiu, toate numerele din a
doua linie a fişierului care apar cel puţin o dată şi în linia a treia a acestuia
Exemplu: dacă fişierul are următorul conţinut:
65
234589
4 5 2 11 8 atunci se va afişa: 4 5 2 8, nu neapărat în această ordine.
a) Descrieţi în limbaj natural o metodă eficientă de rezolvare ca timp de executare.
b) Scrieţi programul C/C++ corespunzător metodei descrise la punctul a).
(Variante BAC 2008 – varianta 076)

27. Fişierul text BAC.IN conţine pe prima sa linie un număr natural n (0<n<10000), iar pe
următoarea linie n numere naturale din intervalul [1,100] separate prin câte un spaţiu. Se cere să
se citescă din fişier toate numerele şi să se afişeze pe ecran numărul sau numerele care apar de
cele mai multe ori printre numerele citite. Numerele afişate vor fi separate prin câte un spaţiu.
Alegeţi un algoritm de rezolvare eficient atât din punctul de vedere al timpului de executare cât
şi al gestionării memoriei.
Exemplu: pentru n=12 şi numerele 1 2 2 3 2 9 3 3 9 9 7 1 se vor afişa valorile 2, 3 şi 9.
a) Explicaţi în limbaj natural metoda utilizată justificând eficienţa acesteia (4-6 rânduri)
b) Scrieţi programul C/C++ ce rezolvă problema enunţată, corespunzător metodei descrise
la punctul a).
(Variante BAC 2008 – varianta 077)

28. Fişierul text BAC.IN conţine pe prima sa linie un număr natural n (0<n<10000), iar pe
următoarea linie n numere naturale din intervalul [1,100]. Se cere să se citescă din fişier toate
numerele şi să se afişeze pe ecran, în ordine descrescătoare, toate numerele care apar pe a doua
linie a fişierului şi numărul de apariţii ale fiecăruia. Dacă un număr apare de mai multe ori, el va
fi afişat o singură dată. Fiecare pereche „valoare - număr de apariţii” va fi afişată pe câte o linie a
ecranului, numerele fiind separate printr-un spaţiu, ca în exemplu. Alegeţi un algoritm de
rezolvare eficient din punctul de vedere al timpului de executare.
Exemplu: dacă se citeşte pentru n valoarea 12 şi apoi numerele 1 2 2 3 2 2 3 3 2 3 2 1 se
va afişa: 3 4 2 6 1 2 25
a) Explicaţi în limbaj natural metoda utilizată justificând eficienţa acesteia (4-6 rânduri)
b) Scrieţi programul C/C++ ce rezolvă problema enunţată, corespunzător metodei descrise
la punctul a).
(Variante BAC 2008 – varianta 078)

29. Se citeşte de pe prima linie a fişierului NUMERE.IN un număr natural n (0<n<10000)

şi, de pe a doua linie a fişierului, n numere naturale din intervalul [1,100] şi se cere să se afişeze
pe ecran, despărţite prin câte un spaţiu, numărul sau numerele întregi din intervalul [1,100] care
nu apar printre numerele citite. Dacă pe a doua linie a fişierului apar toate numerele din
intervalul precizat, se va afişa mesajul NU LIPSESTE NICIUN NUMAR. Alegeţi un algoritm
de rezolvare eficient atât din punctul de vedere al timpului de executare.
Exemplu: pentru fişierul NUMERE.IN cu următorul conţinut 12 4 2 3 1 6 5 7 8 9 11 10
100 se vor afişa valorile 12 13 … 99.
a) Explicaţi în limbaj natural metoda utilizată, justificând eficienţa acesteia (4-6 rânduri).
b) Scrieţi programul C/C++ ce rezolvă problema enunţată, corespunzător metodei descrise
la punctul a).
(Variante BAC 2008 – varianta 079)

30. Fişierul text BAC.IN conţine cel mult 1000 de numere naturale cu cel mult patru cifre
fiecare, despărţite prin câte un spaţiu. Scrieţi programul C/C++ care citeşte numerele din fişier şi
afişează pe ecran, în ordine crescătoare, acele numere din fişier care au toate cifrele egale. Dacă
fişierul nu conţine niciun astfel de număr, se va afişa pe ecran mesajul NU EXISTA.
Exemplu: dacă fişierul bac.in conţine numerele: 30 44 111 7 25 5 atunci pe ecran se va
afişa 5 7 44 111.
(Variante BAC 2008 – varianta 080)

31. Fişierul text NUMERE.IN conţine, pe mai multe linii, cel mult 30000 de numere
naturale nenule mai mici sau egale decât 500, despărţite prin câte un spaţiu.
a) Scrieţi programul C/C++ care, utilizând un algoritm eficient din punct de vedere al
timpului de executare, afişează pe ecran, în ordine crescătoare, toate numerele care au apărut
exact o singură dată din fişierul NUMERE.IN, despărţite prin câte un spaţiu.
Exemplu: dacă fişierul NUMERE.IN conţine numerele 2 23 34 3 8 9 9 23 6 8 9 2 4 5 23
9, se vor afişa valorile următoare: 3 4 5 6 34
b) Descrieţi succint, în limbaj natural, metoda de rezolvare folosită la punctul a), explicând
în ce constă eficienţa ei (3 – 4 rânduri).
(Variante BAC 2008 – varianta 081)

32. Scrieţi programul C/C++ care citeşte de la tastatură un număr natural n (1≤n≤100),
apoi un şir de n numere întregi, cu cel mult 2 cifre fiecare, notat a 1,a2,a3,…an, apoi un al doilea şir
de n numere întregi, cu cel mult 2 cifre fiecare, notat b1,b2,b3,…bn. Fiecare şir conţine atât valori
pare, cât şi impare. Programul afişează pe ecran suma acelor numere impare din şirul b care sunt
mai mici decât suma tuturor numerelor pare din şirul a.
Exemplu: pentru n=4 şi numerele 2,3,7,8 respectiv 44,3,1,8 se afişează valoarea 4 pentru
că numerele 3 şi 1 sunt mai mici decât suma numerelor pare din şirul a, care este 10.
 (Variante BAC 2008 – varianta 084)

33. Scrieţi programul C/C++ care citeşte de la tastatură un număr natural n (1≤n≤100),
apoi un şir de n numere întregi, cu cel mult 2 cifre fiecare, notat a 1,a2,a3,…an, apoi un al doilea şir
de n numere întregi, cu cel mult 2 cifre fiecare, notat b1,b2,b3,…bn. Fiecare şir conţine atât valori
pare, cât şi impare. Programul afişează pe ecran suma acelor numere din şirul b care sunt strict
mai mici decât media aritmetică a tuturor numerelor pare din şirul a. 26
Exemplu: pentru n=4 şi numerele 2,3,7,8 respectiv 44,3,1,8 se afişează valoarea 4 pentru
că numerele 3 şi 1 sunt mai mici decât media aritmetică a numerelor pare din şirul a, care este 5.
(Variante BAC 2008 – varianta 085)

34. Scrieţi programul C/C++ care citeşte de la tastatură un număr natural n (1≤n≤99),
impar, şi construieşte în memorie un tablou unidimensional A=(A 1, A2,…, An) cu elementele
mulţimii {1,2,...,n} astfel încât elementele de pe poziţii impare formează şirul crescător 1,2,...,
[(n+1)/2], iar elementele de pe poziţii pare şirul descrescător n,n-1,..., [(n+1)/2]+1.

Exemplu: pentru n=11 se va construi tabloul A :

1
1 11 2 3 9 4 8 5 7 6
0
Elementele tabloului se afişează pe ecran, separate prin câte un spaţiu.
(Variante BAC 2008 – varianta 093)

35. Pe prima linie a fişierului text DATE.TXT se află două numere naturale nenule n şi m
(n≤3000, m≤3000), pe a doua linie un şir de n numere naturale, ordonate crescător, având fiecare
cel mult 9 cifre, iar pe linia a treia un şir de m numere naturale, ordonate descrescător, având
fiecare cel mult 9 cifre. Numerele sunt despărţite, în cadrul liniilor, prin câte un spaţiu.
a) Scrieţi programul C/C++ care citeşte numerele din fişier şi afişează, pe ecran, doar
numerele pare din cele două şiruri, ordonate crescător. Programul nu va afişa nimic dacă nu
există numere pare în cele două şiruri. Alegeţi o metodă de rezolvare eficientă ca timp de
executare.
Exemplu: dacă fişierul are conţinutul
58
2 4 7 37 42
88 88 67 45 42 32 4 1, pe ecran se va afişa: 2 4 4 32 42 42 88 88
b) Descrieţi succint, în limbaj natural, metoda utilizată, justificând eficienţa acesteia
(Variante BAC 2008 – varianta 098)

36. Pe prima linie a fişierului text DATE.TXT se află un şir de cel mult 10000 de numere
întregi, având cel mult 4 cifre fiecare. Numerele sunt despărţite prin câte un spaţiu.
a) Scrieţi un program C/C++ care citeşte numerele din fişier şi afişează pe ecran lungimea
maximă a unei secvenţe de numere din şir, cu proprietatea că oricare două numere din secvenţă,
aflate pe poziţii consecutive, au parităţi diferite. Pe a doua linie a ecranului, programul va afişa o
secvenţă de lungime maximă, valorile fiind despărţite prin câte un spaţiu. Alegeţi o metodă de
rezolvare eficientă ca timp de executare.
Exemplu: dacă fişierul conţine, în ordine, numerele 2 4 3 2 7 4 6 2 7 8 12, se va afişa: 5 4
3274
b) Descrieţi succint, în limbaj natural, metoda utilizată, justificând eficienţa acesteia.
(Variante BAC 2008 – varianta 099)
1.3. Rezolvări probleme propuse
1.
#include <fstream>
#include <iostream>
int n, v[101],i,x,ok,aux;
using namespace std; 27
int main()
{ifstream f("nr.txt");
n=0;
while (f>>x)
if(x>0) {n++; v[n]=x;}
if (n==0) cout<<"Nu exista";
else {
while (ok==0)
{
ok=1;
for(i=1;i<n;i++)
if(v[i]>v[i+1]){aux=v[i];
v[i]=v[i+1];
v[i+1]=aux;
ok=0;}
}
for(i=1;i<=n;i++) cout<<v[i]<<" ";
}
f.close();
return 0;
}

2.
#include <fstream>
#include <iostream>
int v[301],n,i,t,p,q;
using namespace std;
int main()
{ofstream g("bac.txt");
cin>>n;
for (i=1;i<=3*n;i++)
cin>>v[i];
p=-1;
q=-1;
for(i=1; i<=n && v[i]%2!=0;i++);
if (i<n)p=i;
for(i=3*n; i>=2*n && v[i]%2==0;i--);
if (i>=2*n)q=i;
if(p!=-1 && q!=-1)
{
t=v[p];
v[p]=v[q];
v[q]=t;
}
for (i=1;i<=3*n;i++)
g<<v[i]<<" ";
g.close();
return 0;
}

3.
#include <iostream> 28
#include <fstream>
int a[101], b[101], n,m,i,j,ok;
using namespace std;
int main()
{
ofstream g("bac.txt");
cin>>n;
for (i=1;i<=n;i++) cin>>a[i];
cin>>m;
for (j=1;j<=m;j++) cin>>b[j];
if (a[1]<b[1]) {g<<a[1]<<" ";ok=1;}
else {g<<b[1]<<" ";ok=0;}
i=1;
j=1;
while(i<=n && j<=m)
if (ok%2==0) if(a[i]>b[j]) {g<<a[i]<<" ";ok=1;}
else i++;
else if (b[j]>a[i]) {g<<b[j]<<" ";ok=0;}
else j++;
if (ok%2==0) if(i<=n && a[n]>b[j]) g<<a[n];
else if(a[i]<b[m] && j<=m) g<<b[m];

g.close();
return 0;
}

4.
#include <iostream>
#include <fstream>
using namespace std;
int x[1000],nr,v[3],i,n,j;
int main()
{
ifstream f("bac.txt");
while (f>>n)
if (n>=100 && n<=999) x[n]=1;
i=999;
nr=0;
while (i>=100 && nr<2)
{
if (x[i]==0) {nr++;v[nr]=i;}
cout<<nr<<" "<<v[nr]<<endl;
i--;
}
if (nr<2) cout <<"0";
else for (j=1;j<=nr;j++) cout<<v[j]<<" ";
f.close();
return 0;
}

5.
#include <iostream> 29
#include <fstream>
using namespace std;
long int a[10001];
int x,c,p,i;
int main()
{
ifstream f("produse.txt");
while (f>>x>>c>>p)
{
if (!f.eof()) a[x]=a[x]+c*p;
}
for(i=1;i<=9999;i++)
if (a[i]!=0) cout<<i<<" "<<a[i]<< endl;
f.close();
return 0;
}

6.
#include <iostream>
int nr[10],n,i,x,k;
using namespace std;
int main()
{
cin>>n;
for(i=1;i<=n;i++)
{
cin>>x;
nr[x]++;
}
for(i=0;i<=9;i++)
if (nr[i]!=0) for(k=1;k<=nr[i];k++) cout<<i<<" ";
return 0;
}

7.
#include <fstream>
#include <iostream>
int i,j,cif[10];
long n;
using namespace std;
int main()
{
ifstream f("numere.txt");
while (f>>n)
{
 while (n!=0)
{cif[n%10]++;
n=n/10;}
}
for(i=9;i>=0;i--)
for(j=1;j<=cif[i];j++)
cout <<i<<" "; 30
f.close();
return 0;
}

8.
#include <iostream>
#include <fstream>
int a[1000],b[1000],n,i,j,ok;
using namespace std;
int main()
{
ifstream f("bac.txt");
f>>n;
for (i=1;i<=n;i++) f>>a[i]>>b[i];
for (i=1;i<=n;i++)
{
ok=1;
for (j=1;j<=n;j++)
if ((i!=j) && ((a[i]>=a[j] && a[i]<=b[j]) || (b[i]>=a[j] && b[i]<=b[j])|| (a[j]>=a[i] &&
a[j]<=b[i]) || (b[j]>=a[i] && b[j]<=b[i]))) ok=0;
if (ok==1) cout<<a[i]<<" "<<b[i]<<endl;
}
f.close();
return 0;
}

9. Se citesc elementele vectorului. Folosind căutarea binară verificăm dacă valoarea a se găsește
în vector. Dacă se găsește înseamnă că soluția este a, altfel căutarea binară ne va furniza cel mai
mic număr din vector mai mare ca a. Dacă acest număr este mai mic sau egal cu b, atunci acesta
este soluția, altfel se afișează mesajul ”NU”.
#include <iostream>
#include <fstream>
int v[30000],a,b,n,i,j,mij,st,dr,ok;
using namespace std;
int main()
{
ifstream f("bac.txt");
f>>n;
for (i=1;i<=n;i++) f>>v[i];
f>>a>>b;
st=1;
dr=n;
while(st<=dr)
{
mij=(st+dr)/2;
 if (v[mij]==a) {ok=a;break;}
else if (v[mij]<a) st=mij+1;
else dr=mij-1;
}
if (st>dr) ok=v[st];
if (ok<=b) cout<<ok;
else cout<<"NU"; 31
f.close();
return 0;
}

10. Se citește din fișierul numere.in vectorul a și apoi câte un element al vectorului b (fără a
memora vectorul b). Citim primul element din b și plecând de la primul element din a însumăm
elementele din a până ce suma elementelor devine mai mare sau egală cu elementul citit din b.
Folosim o variabilă aux (care inițial are valoarea 1) și care ne spune dacă suma elementelor din a
este egală sau diferită de elementul din b (dacă suma este diferită atunci aux devine 0). Pentru a
afișa mesajul DA trebuie ca cei doi vectori să se termine simultan și valoarea variabilei aux să
rămână 1.
#include <iostream>
#include <fstream>
int n,m,a[101],b[101],i,j,aux,x,s;
using namespace std;
int main()
{
ifstream f("numere.in");
f>>n>>m;
for(i=1;i<=n;i++)
f>>a[i];
aux=1;
i=1;
for(j=1;j<=m;j++)
{
f>>x;
s=0;
while(i<=n && s<x)
{
s=s+a[i];
i++;
}
if (s!=x) aux=0;
}
if (aux==1 && i==n+1) cout << "DA";
else cout<<"NU";
f.close();
return 0;
}

11. Vom considera un vector cu indici de la 0 la 99 și de câte ori vom citi un număr din fișier îl
vom număra (v [numărul citit] crește cu o unitate). În final vom parcurge vectorul v și dacă
acesta are valoarea 1 (adică numărul apare o singură dată în fișier) îl afișăm.
#include <iostream>
#include <fstream>
using namespace std;
int x,n,i,v[100];
int main()
{
ifstream f("numere.txt");
f>>n;
for(i=1;i<=n;i++) 32
{
f>>x;
v[x]++;
}
for(i=0;i<=99;i++)
if(v[i]==1) cout<<i<<" ";
f.close();
return 0;
}

12. Vom considera un vector cu indici de la 0 la 9 și de câte ori vom citi un număr din fișier îl
vom număra (v [numărul citit] crește cu o unitate). În final vom parcurge vectorul v și ne vom
construi numărul care se afișează.
#include <iostream>
#include <fstream>
using namespace std;
int x,n,i,v[10],j,p;
long int nr;
int main()
{
ifstream f("numere.txt");
f>>n;
for(i=1;i<=n;i++)
{
f>>x;
v[x]++;
}
p=1;
for(i=0;i<=9;i++)
for(j=1;j<=v[i];j++)
{nr=nr+i*p;
p=p*10;}
cout<<nr;
f.close();
return 0;
}

13. Vom considera un vector cu indici de la 0 la 9 și de câte ori vom citi un număr din fișier vom
lua cifrele și le vom număra (v [cifră] crește cu o unitate). În final vom parcurge vectorul v și
dacă valoarea lui este diferită de 0 vom afișa indicele.

#include <iostream>
#include <fstream>
using namespace std;
int x,n,i,v[10];
long int nr;
int main()
{
ifstream f("numere.txt");
f>>n;
for(i=1;i<=n;i++)
{ 33
f>>x;
while(x!=0)
{
v[x%10]++;
x=x/10;
}

}
for(i=0;i<=9;i++)
if (v[i]!=0) cout<<i<<" ";
f.close();
return 0;
}

14. Vom considera un vector cu indici de la 0 la 99 și de câte ori vom citi un număr din fișier îl
vom număra (v [numărul citit] crește cu o unitate). În final vom parcurge vectorul v și dacă
acesta are valoarea diferită de 0 îl afișăm de atâtea ori ât este valoarea lui v[i] (valoarea lui v[i]
reprezintă numărul de apariții ale numărului i în fișier) .

#include <iostream>
#include <fstream>
using namespace std;
int x,n,i,v[100],j;
long int nr;
int main()
{
ifstream f("numere.txt");
f>>n;
for(i=1;i<=n;i++)
{
f>>x;
v[x]++;
}

for(i=0;i<=99;i++)
for(j=1;j<=v[i];j++)
if (v[i]!=0) cout<<i<<" ";
return 0;
}

15.
#include <iostream>
using namespace std;
int n,a,b,v[100],aux,i,j;
int main()
{
cin>>a>>b>>n;
if (a>b) {aux=a;
a=b;
b=aux;}
for(i=a;i<=b;i++)
if(i%n==0){j++;v[j]=i;} 34
if (j==0) cout<<"NU";
else for (i=1;i<=j;i++) cout << v[i]<<" ";
return 0;
}

16.
#include <fstream>
using namespace std;
int n,v[10001],x,i;
int main()
{
ifstream f("bac.in");
ofstream g("bac.out");
f>>n;
for(i=1;i<=n;i++)
{
f>>x;
v[x]++;
}
for (i=0;i<=10000;i++) if (v[i]>=2) g<< i<<" ";
f.close();
g.close();
return 0;
}

17.
#include <fstream>
#include <iostream>
using namespace std;
int n,v[101],x,i,j;
int main()
{
ifstream f("date.in");
f>>n;
for(i=1;i<=n;i++)
f>>v[i];
for (i=1;i<n;i++)
for(j=i+1;j<=n;j++)
if ((v[i]%2==0 && v[j]%2==0)|| (v[i]%2==1 && v[j]%2==1)) cout<<v[i]<<" "<<v[j]<<endl;
f.close();
return 0;
}

18.
#include <fstream>
#include <iostream>
using namespace std;
int n,v[101],x,i,j;
int main()
{
ifstream f("date.in");
f>>n; 35
for(i=1;i<=n;i++)
f>>v[i];
for (i=1;i<=n;i++)
{
for (j=1;j<=n;j++) cout<<v[j]<<" ";
cout<<endl;
x=v[1];
for(j=1;j<n;j++) v[j]=v[j+1];
v[n]=x;
}
f.close();
return 0;
}

19. Considerăm un vector x cu 10000 elemente egale cu 0 inițial și care va primi valoarea 1 pe
poziția i dacă există 2 elemente în vector a căror sumă este i. Parcurgem apoi vectorul v și
verificăm dacă x[v[i]] are valoarea 1 (înseamnă că există cel puțin 2 elemente a căror sumă este
v[i]).
#include <iostream>
using namespace std;
int n,v[10001],x[10001],i,j,nr;
int main()
{
cin>>n;
for(i=1;i<=n;i++)
cin>>v[i];
for (i=1;i<n;i++)
for (j=i+1;j<=n;j++) if (v[i]+v[j]<10000) x[v[i]+v[j]]=1;
for(i=1;i<=n;i++) if (x[v[i]]==1) nr++;
cout<<nr;
return 0;
}

20.
#include <iostream>
using namespace std;
int n,a[101],b[101],c[101],i,j,nr;
int main()
{
cin>>n;
for(i=1;i<=n;i++)
cin>>a[i];
for(i=1;i<=n;i++)
cin>>b[i];
for (i=1;i<=n;i++)
if (a[i]<b[i]) if (b[i]<10) c[i]=a[i]*10+b[i];
else if(b[i]<100) c[i]=a[i]*100+b[i];
else c[i]=a[i]*1000+b[i];
else if (a[i]<10) c[i]=b[i]*10+a[i];
else if(a[i]<100) c[i]=b[i]*100+a[i];
else c[i]=b[i]*1000+a[i];
for(i=1;i<=n;i++) 36
cout<<c[i]<<" ";
return 0;
}

21. #include <iostream>

#include <fstream>
using namespace std;
int n,k,i,j,x,p,y,v[1001];
int main()
{
ifstream fin("numere.txt");
while (fin>>x)
{
if(x%2==0) {n++; v[n]=x;}
}
for(i=1;i<=n;i++)
{k=1;
x=v[i];
while(x>v[k])
k=k+1;
for(j=i-1;j>=k;j--)
v[j+1]=v[j];
v[k]=x;
}
if (n==0) cout<<"nu exista";
else for(i=1;i<=n;i++)
cout<<v[i]<<" ";
fin.close();
return 0;}

22. #include <iostream>

#include<fstream>
using namespace std;
int n,i,j,s,x,p,k,ok,aux,v[101],sum[101];
int main()
{
ifstream fin("intrare.txt");
ofstream fout("iesire.txt");
while (fin>>x)
{
ok=1;
for(i=1;i<=n;i++)
if(v[i]==x) ok=0;
if(ok==1) {n++; v[n]=x;}
 }
for(i=1;i<n;i++)
for(j=i+1;j<=n;j++)
{s=v[i]+v[j];
ok=1;
for(p=1;p<=k;p++)
if(s==sum[p]) ok=0; 37
if(ok==1) {k++;
sum[k]=s;}
}
for(i=1;i<k;i++)
for(j=i+1;j<=k;j++)
if (sum[i]>sum[j]){aux=sum[i];
sum[i]=sum[j];
sum[j]=aux;}
for(i=1;i<=k;i++)
fout<<sum[i]<<" ";
fin.close();
fout.close();
return 0;
}

23.
#include <iostream>
#include <fstream>
using namespace std;
int n,i,v[100];
ifstream fin("date.in");
ofstream fout("date.out");
int main()
{
while(fin>>n)
v[n]=1;
for(i=0;i<=99;i++)
if(i%2==1 && v[i]==1) fout<<i<<" ";
fout<<endl;
for(i=99;i>=0;i--)
if(i%2==0 && v[i]==1) fout<<i<<" ";
fin.close();
fout.close();
return 0;
}
Deoarece știm că numerele din fișier au cel mult două cifre, am folosit un vector v cu maxim 100
de elemente în care indicii reprezintă numerele de la 0 la 99 și trecând o singură dată prin fișier
pentru numărul x citit am dat elementului din vectorul v aflat pe poziția x valoarea 1. La final am
parcurs de 2 ori acest vector: prima dată de la stânga la dreapta pentru a afișa elementele impare
în ordine crescătoare, apoi de la dreapta la stânga pentru a afișa elementele pare în ordine
descrescătoare.

24.
#include <iostream>
#include <fstream>
using namespace std;
int v[1001],n,i,lg,lmax,poz;
ifstream fin("date.in");
int main()
{
fin>>v[1];
i=1; 38
lmax=0;
poz=1;
lg=0;
while(!fin.eof())
{
i++;
fin>>v[i];
if (v[i]<v[i-1]) lg++;
else lg=1;
if(lg>lmax) {lmax=lg;
poz=i;}
}
for(i=poz-lmax+1;i<=poz;i++)
cout << v[i] <<" ";
fin.close();
return 0;
}
În timp ce citim numerele din fișier ne construim vectorul și determinăm și secvența de lungime
maximă reținând poziția de final, precum și lungimea acesteia. La final vom afișa secvența
parcurgând vectorul de la poziția de final – lungimea maximă+1 până la poziția de final.

25.
a) #include <iostream>
#include <fstream>
using namespace std;
ifstream fin("numere.txt");
int np,i,n;
long x,v[10001];

int main()
{
fin>>n;
for(i=1;i<=n;i++)
{
fin>>x;
if(x%2==0)cout<<x<<" ";
else {np++;
v[np]=x;}
}
for(i=np;i>=1;i--)
cout << v[i] << " ";
fin.close();
return 0;
}
 c) Deoarece știm că numerele din fișier sunt ordonate crescător, pe măsură ce găsim că
numărul citit este par îl afișăm, iar dacă numărul este impar îl punem în vectorul v. În acest fel
numerele pare sunt afișate în ordine crescătoare, iar pentru a afișa numerele impare în ordine
descrescătoare parcurgem vectorul v de la dreapta la stânga.
Metoda este eficientă deoarece numerele se citesc din fișier, iar apoi afișăm elementele din
vector fără a utiliza o metodă de sortare.
39
26.
a) #include <iostream>
#include <fstream>
using namespace std;
ifstream fin("bac.txt");
int m,n,i,x,v[1001],st,dr,gasit,mij;

int main()
{
fin>>n>>m;
for(i=1;i<=n;i++)
fin>>v[i];

for(i=1;i<=m;i++)
{fin>>x;
st=1;
dr=n;
gasit=0;
while (st<=dr && gasit!=1)
{
mij=(st+dr)/2;
if (v[mij]==x) gasit=1;
else if (x<v[mij]) dr=mij-1;
else st=mij+1;
}
if (gasit==1) cout<<x<<" ";
}

fin.close();
return 0;
}
b) Se citesc din fișier valorile aflate pe prima linie, apoi cele n numere de pe a doua linie a
fișierului le memorăm într-un vector. În vector elementele vor fi ordonate crescător și atunci
putem citi numerele de pe linia trei unul câte unul și folosind căutarea binară vedem dacă se afșă
sau nu în vectorul v.

27.
a) Citim numărul n de numere care se află în fișier. Deoarece știm că numerele din fișier sunt în
intervalul [1,100] vom folosi un vector v cu maxim 100 de elemente și pe măsură ce citim
numerele de pe linia a doua din fișier v[numărul citit] crește cu o unitate (în acest fel vom ști de
câte ori apare fiecare număr din intervalul [1,100] în fișier). După ce am construit vectorul v,
calculăm numărul maxim din el și apoi îl mai parcurgem încă o dată pentru a afișa elementele
care apar de cele mai multe ori.

b)
#include <iostream>
#include <fstream>
using namespace std;
ifstream fin("bac.in");
int n,i,maxx,x,v[101];

int main() 40
{
fin>>n;
for(i=1;i<=n;i++)
{fin>>x;
v[x]++;}

for(i=1;i<=100;i++)
if(v[i]>maxx) maxx=v[i];
for(i=1;i<=100;i++)
if(v[i]==maxx) cout<<i<<" ";
fin.close();
return 0;
}

28.
a) Citim numărul n de numere care se află în fișier. Deoarece știm că numerele din fișier sunt în
intervalul [1,100] vom folosi un vector v cu maxim 100 de elemente și pe măsură ce citim
numerele de pe linia a doua din fișier v[numărul citit] crește cu o unitate (în acest fel vom ști de
câte ori apare fiecare număr din intervalul [1,100] în fișier). După ce am construit vectorul v,
dacă valoarea lui v[i] este diferită de 0, vom afișa poziția i (care reprezintă numărul) și v[i] care
reprezintă numărul de apariții ale numărului i în fișier.
b)
#include <iostream>
#include <fstream>
using namespace std;
ifstream fin("bac.in");
int n,i,x,v[101];

int main()
{
fin>>n;
for(i=1;i<=n;i++)
{fin>>x;
v[x]++;}

for(i=100;i>=1;i--)
if(v[i]!=0) cout<<i<<" "<<v[i]<<endl;
fin.close();
return 0;
}

29.
a) Citim numărul n de numere care se află în fișier. Deoarece știm că numerele din fișier sunt în
intervalul [1,100] vom folosi un vector v cu maxim 100 de elemente și pe măsură ce citim
numerele de pe linia a doua din fișier v[numărul citit] primește valoarea 1. După ce am construit
vectorul v, vom folosi o variabilă există care inițial primește valoarea 1 (presupunem că nu
lipsește niciun număr din fișier), apoi parcurgem vectorul și dacă valoarea lui v[i] este 0, vom
afișa poziția i (care reprezintă numărul) care lipsește și variabila exista primește valoarea 0 (deci
există numere care nu sunt în fișier). La final verificăm dacă există are valoarea 1 (deci nu am
găsit numere care nu sunt în fișier) și afișăm mesajul ”NU LIPSESTE NICIUN NUMAR”.

b) 41
#include <iostream>
#include <fstream>
using namespace std;
ifstream fin("numere.in");
int n,i,x,v[101],exista=1;

int main()
{
fin>>n;
for(i=1;i<=n;i++)
{fin>>x;
v[x]=1;}
for(i=1;i<=100;i++)
if(v[i]==0) {
cout<<i<<" ";
exista=0;
}
if (exista==1) cout<<"NU LIPSESTE NICIUN NUMAR";
fin.close();
return 0;
}

30.
#include <iostream>
#include <fstream>
using namespace std;
ifstream fin("bac.in");
int n,i,aux,c,k,x,ok,y,v[1001];

int main()
{
while (fin>>x)
{
ok=1;
y=x;
c=x%10;
while(y!=0)
{
if(c!=y%10) ok=0;
y=y/10;
}
if (ok==1) {
k++;
v[k]=x;
}
 }
ok=0;
while (ok==0)
{
ok=1;
for(i=1;i<k;i++)
if(v[i]>v[i+1]) 42
{
aux=v[i];
v[i]=v[i+1];
v[i+1]=aux;
ok=0;
}
}
for(i=1;i<=k;i++)
cout << v[i] <<" ";
return 0;
}

31.
a) #include <iostream>
#include <fstream>
using namespace std;
int n,i,v[501];
ifstream fin("numere.in");
int main()
{
while(fin>>n)
v[n]++;
for(i=1;i<=500;i++)
if(v[i]==1) cout<<i<<" ";
return 0;
}
b) Vom folosi un vector cu indicii de la 1 la 500 (deoarece știm că numerele din fișier sunt
mai mici sau egale cu 500) și de câte ori citim un număr v[numărul citit] crește cu o unitate (în
acest fel vom ști de câte ori apare fiecare număr din intervalul [1,500] în fișier). După ce am
construit vectorul v, dacă valoarea lui v[i] este egală cu 1 îl afișăm pe i.

32.
#include <iostream>

using namespace std;

int n,i,a[101],b[101],sa,sb;
int main()
{
cin>>n;
for(i=1;i<=n;i++)
{
cin>>a[i];
if(a[i]%2==0)sa=sa+a[i];
}
for(i=1;i<=n;i++)
 {
cin>>b[i];
if(b[i]%2==1 && b[i]<sa) sb=sb+b[i];
}
cout<<sb;
return 0;}
43
33.
#include <iostream>

using namespace std;

int n,i,a[101],b[101],sa,sb,na;
int main()
{
cin>>n;
for(i=1;i<=n;i++)
{
cin>>a[i];
if(a[i]%2==0){
sa=sa+a[i];
na++;}
}
for(i=1;i<=n;i++)
{
cin>>b[i];
if(b[i]%2==1 && b[i]<sa/na) sb=sb+b[i];
}
cout<<sb;
return 0;}

34.
#include <iostream>
using namespace std;
int n,i,a,b,v[100];
int main()
{
cin>>n;
a=1;
b=n;
for(i=1;i<=n;i++)
if(i%2==0) {v[i]=b;
b--;}
else {v[i]=a;
a++;}
for(i=1;i<=n;i++)
cout << v[i] << " ";
return 0;}

35.
a)
#include <iostream>
#include <fstream>
using namespace std;
ifstream fin("date.txt");
int n,m,i,j,k,la,lb,x,a[3001],b[3001];
int main()
{
fin>>n>>m;
for(i=1;i<=n;i++) 44
{
fin>>x;
if(x%2==0) {
la++;
a[la]=x;
}
}
for(i=1;i<=m;i++)
{
fin>>x;
if(x%2==0) {
lb++;
b[lb]=x;
}
}
i=1;
j=lb;
while(i<=la && j>=1)
{
if(a[i]<b[j]){
cout<<a[i]<<" ";
i++;
}
else {
cout<<b[j]<<" ";
j--;
}
}
for(k=i;k<=la;k++)
cout<<a[k]<<" ";
for(k=j;k>=1;k--)
cout<<b[k]<<" ";
return 0;}

b) Preluăm din fișier doar valorile pare pe care le memorăm în doi vectori. Deoarece
elementele de pe a doua linie sunt ordonate crescător, iar elementele de pe a treia linie sunt
ordonate descrescător înseamnă că în vectorul a vom avea valorile pare de pe prima linie în
ordine crescătoare, iar în vectorul b vom avea valorile pare în ordine descrescătoare. Elementele
celor doi vectori vor fi interclasate parcurgând vectorul a de la stânga la dreapta, iar vectorul b de
la dreapta la stânga.

36.
#include <iostream>
#include <fstream>
using namespace std;
 ifstream fin("date.txt");
int v[10001],n,i,x,y,poz,lsecv,lmax;

int main()
{
while(fin>>x)
{ 45
n++;
v[n]=x;
}
lsecv=1;
poz=1;
lmax=0;
for(i=2;i<=n;i++)
{
if(v[i]%2!=v[i-1]%2)lsecv++;
else {
lsecv=1;
poz=i;
}
if (lsecv>lmax) {
lmax=lsecv;
x=poz;
y=i;}
}
cout<<lmax<<endl;
for(i=x;i<=y;i++)
cout << v[i]<<" ";
fin.close();
return 0;
}
b) Memorăm valorile din fișier într-un vector v. Parcurgem vectorul și pentru fiecare
element dacă valoarea are paritatea diferită față de cel din față se incrementează lungimea
secvenței, altfel inițializăm o nouă secvență.
Cuprins
Tablouri unidimensionale (vectori).................................................................................................1
1.1. Noţiuni teoretice...................................................................................................................1
Operații cu vectori:................................................................................................................2
46
1. prelucrarea componentelor vectorului...................................................................2
2. construirea unui vector...........................................................................................4
3. inserări și eliminări de componente dintr-un vector..............................................4
4. ordonarea elementelor unui vector sau sortarea....................................................6
 Sortarea prin metoda bulelor.............................................................................7
 Sortarea prin selecție directă..............................................................................9
 Sortarea prin numărare....................................................................................10
 Sortarea prin inserție.........................................................................................12
 Căutarea unei valori într-un vector.................................................................13
1. Căutarea secvențială –...................................................................................13
2. Căutarea binară..............................................................................................14
1.2. Probleme propuse...............................................................................................................16
1.3. Rezolvări probleme propuse...............................................................................................24