Ministerul Educaiei i Cercetrii

Colegiul Naional Alexandru Ioan Cuza, Galai

Examen de atestare profesional pentru

absolvenii claselor de matematic informatic

Profesor coordonator: Joc Genia

Elev: Bejan Florin Daniel

Clasa: a XII-a A

An colar
2014 - 2015

Tablouri unidimensionale

Argument

Tablourile unidimensionale reprezint o parte important din materia de studiu a unui

elev de liceu. Prin studiul tablourilor unidimensionale sau vectorilor s-a putut uura rezolvarea
exerciiilor i problemelor. Datorit modului simplu de nvare i reinere a noiunilor
eseniale i preferina pentru acest capitol din informatic, eu am ales tablourile
unidimensionale ca tema pentru atestat.

Noiuni teoretice
Tabloul de memorie este o structur de date intern format dintr-o mulime ordonat
de elemente, in care fiecare element are un succesor i un predecesor, exceptnd primul
element, care nu are dect succesor, i ultimul element, care nu are dect predecesor. Acestei
structuri de date i se atribuie un nume i permite memorarea mai multor date de acelai tip.

Implementarea tablourilor de memorie n limbajul C++

Pentru a crea o structur de date de tip tablou de memorie trebuie:
1. S declarm tabloul pentru a i se aloca spaiu de memorie; prin aceast operaie trebuie s
furnizm urmtoarele informaii:
1.1. numele tabloului, care va fi folosit n expresii pentru a-l identifica;
1.2. tipul elementelor tabloului;
1.3. numrul de elemente ale tabloului.
2. S dm valori elementelor tabloului prin:
2.1. iniializarea tabloului de memorie, la declararea lui;
2.2. introducerea valorilor de la tastatur;
2.3. preluarea valorilor dintr-o alt structur de date.

Declararea tablourilor de memorie n limbajul C++

Lungimea tabloului de memorie reprezint numrul de ermente ale tabloului. n
prelucrarea tabloului de memorie se folosesc dou lungimi: lungimea fizic - numrul de
elemente stabilit la declararea tabloului i lungimea logic, numrul de elemente care vor fi
prelucrate la execuia programului.

Tabloul cu o singur dimensiune - vectorul

Declararea un tablou de memorie de tip vector se face cu ajutorul instruciunii
tip_dat nume [nr_elemente];
Exemple:int v[20] - s-a declarat un vector v cu 20 de elemente de tip ntreg;float
x[100] - s-a declarat un vector x cu 100 de elemente de tip float(real);char c[50] - s-a declarat
un vector c cu 50 de elemente de tip char(caracter);
La declararea unui vector se pot atribui valori iniiale elementelor prin instruciunea:
tip_dat nume[numar_elemente] ={lista_valori};int v[3]={25, 42, 3) - s-a declarat un vector v
cu 3 elemente de tip intreg;
Referirea la un element al vectorului se face prin instruciunea nume[indice].

Algoritmi pentru prelucrarea tablourilor de memorie

Parcurgerea elementelor unui vector
Parcurgerea elementelor tabloului se face secvenial, n ordinea indicilor de la primul
element pn la ultimul element, sau invers, de la ultimul element la primul element.
//se creeaz vectorul
for(i=0; i<n; i++)
{
cout<<v[<<i<<]=;
cin>>v[i];
}
//de la primul la ultimul element
for(i=0;i<n:i++)
cout<<v[i]<< ;
coutendl;
//de la ultimul la primul element
for(i=n-1; i>=0; i--)
cout<<v[i]<< ;

tergerea unui element dintr-un vector

Pentru a terge un element cu indicele j dintr-un vector trebuie s deplasm elementele
vectorului, ncepnd cu indicele j+1, cu o poziie spre stnga. Lungimea logic a vectorului se
va micora cu un element i va fi n-1. Secvena de instruciuni pentru tergerea unui element
dintr-un vector este:
int v[100], n, i, j;
cout<<Lungimea vectorului:; cin>>n;
cout<<Poziia elementului:; cin>>j;
//se construiete vectorul
.........................................................
for(i=j; i<n; i++)
v[i]=v[i+1]; //se terge elementul
for(i=0; i<n-1; i++)
cout<<v[i]<< ;

Inserarea unui element ntr-un vector

Pentru a introduce un element n poziia k ntr-un vector trebuie s deplasm
elementele vectorului, ncepnd cu indicele k+1, cu o poziie spre dreapta i atribuirea noii
valori elementului cu indicele k. Lungimea logic a vectorului se va mri cu un element i va
fi n+1. Secvena de instruciuni pentru inserarea unui element ntr-un vector este:
int v[100], n, i, k, x;
cout<<Lungimea vectorului:; cin>>n;
cout<<Poziia elementului:; cin>>k;
cout<<Elementul:; cin>>x;
//se construiete vectorul
5

.........................................................
for(i=n; i>k; i--)
v[i]=v[i-1];
v[k]=x; //se introduce elementul
for(i=0; i<=n; i++)
cout<<v[i]<< ;

Cutarea unui element ntr-un vector nesortat

n acest caz, cutarea elementului se face prin parcurgerea secvenial pn cnd este
gsit elementul. Secvena de instruciuni pentru cutarea elementului ntr-un vector nesortat
este:
int v[100], n, i, x;
cout<<Lungimea vectorului:; cin>>n;
cout<<Elementul:; cin>>x;
//se construiete vectorul
.........................................................
i=0;
while(i<n && v[i]!=x)
i++;
if(i!=n)
cout<<Elementul se afl n poziia:<<i+1;
else
cout<<Elementul nu este n vector!;

Cutarea unui element ntr-un vector sortat Cutarea binar

Acest algoritm are la baz principiul njumtirii repetate a domeniului n care se
caut elementul, prin mprirea vectorului n doi subvectori. Notm cu s primul element al
vectorului, cu d ultimul element al vectorului i cu m indicele elementului din mijlocul
vectorului. Se compar valoarea cutat cu elementul din mijlocul vectorului. Dac cele dou
valori sunt egale, nseamn c s-a gsit elementul. Dac nu sunt egale, vectorul va fi mprit
n doi subvectori.
s=0; d=n-1; ok=0;
while(s<=d && ok==0)
{
m=(s+d)/2;
if(x==v[m])
ok=1;
else
if(x<v[m])
d=m-1;
else
s=m+1;
}
if(ok)
cout<<Poziia:<<m+1;
else
cout<<Nu este!;
6

Algoritmi pentru sortarea unui vector

Metoda seleciei directe
Prin aceast metod se aduce pe prima poziie elementul cu valoarea cea mai mic din
cele n elemente ale vectorului, apoi se aduce pe a doua poziie elementul cu valoarea cea mai
mic din cele n-1 elemente ale vectorului, etc. Secvena de instruciuni pentru algoritmul de
sortare prin metoda seleciei directe este:
int v[100], n, i, j, aux;
cout<<n= ; cin>>n;
for(i=0; i<n; i++)
cin>>v[i];
for(i=0; i<n-1; i++)
for(j=i+1; j<n; j++)
if(v[i]>v[j])
{
aux=v[i];
v[i]=v[j];
v[j]=aux;
}
for(i=0; i<n; i++)
cout<<v[i]<< ;

Metoda bulelor BUBBLE SORT

Prin aceast metod se parcurge vectorul i se compar fiecare element cu succesorul
su. Dac nu sunt n ordine cele dou elemente se interschimb ntre ele. Vectorul se parcurge
de mai multe ori, pn cnd la o parcurgere complet nu se mai execut nicio interschimbare
ntre elemente (vectorul este sortat).
int v[100], n, i, aux, gata=0;
cout<<n= ; cin>>n;
for(i=0; i<n; i++)
cin>>v[i];
while(gata==0)
{
gata=1;
for(i=0; i<n-1; i++)
if(v[i]>v[i+1])
{
aux=v[i];
v[i]=v[i+1];
v[i+1]=aux;
gata=0;
}
}
for(i=0; i<n; i++)
cout<<v[i] << ;

Algoritm pentru interclasarea a doi vectori

Interclasarea a doi vectori nseamn reuniunea celor doi vectori urmat de ordonarea
elementelor vectorului rezultat. Cei doi vectori trebuie s fie sortai.
Algoritm
Se parcurg simultan cei doi vectori pentru a se compara un element dintr-un vector cu
un element din cellalt vector. Elementul cu valoarea mai mic (sau mai mare) este copiat n
vectorul destinaie i ters din vectorul surs. Aceast operaie continu pn cnd este epuizat
unul dintre vectori. Celelalte elemente care au rmas se adaug la sfritul vectorului
destinaie.
Variabile de memorie
- vectorii a, b i c; vectorii a i b sunt vectorii surs iar vectorul c este vectorul
destinaie;
- lungimile logice ale vectorilor: n i m;
- indici pentru parcurgerea vectorilor: i pentru vectorul a, j pentru vectorul b i k
pentru vectorul c.
Secvena de instruciuni pentru interclasarea a doi vectori
int a[10], b[10], c[20], i, j, k, n, m;
//se citesc dimensiunile vectorilor
//se creeaz vectorii
.
i=0; j=0; k=0;
while(i<n && j<m)
{
if(a[i]<b[j])
{c[k]=a[i]; i++;}
else
{c[k]=b[j]; j++;}
k++;
}
if(i<n)
while(i<n)
{c[k]=a[i]; k++; i++;}
else
while(j<m)
{c[k]=b[j]; k++; j++;}
//se afieaz vectorul destinaie

Probleme rezolvate
Problema 1:
Fiind dat un vector v cu n elemente numere ntregi, s se afieze de cte ori gsim
dou elemente consecutive egale ntre ele.
#include<fstream>
using namespace std;
ifstream fin(date.in);
ofstream fout(date.out);
int main( )
{
int v[100], n, i, k;
fin>>n;
for(i=0; i<n; i++)
fin>>v[i];
k=0;
for(i=1; i<n; i++)
if(v[i]==v[i-1])
k++;
fout<<k;
fin.close( );
fout.close( );
return 0;
}

Problema 2:
Fiind dat un vector v cu n elemente numere ntregi, s se construiasc ali doi vectori:
primul va conine numai elementele pare, iar al doilea numai elementele impare ale vectorului
iniial.
#include<fstream>
using namespace std;
ifstream fin(date.in);
ofstream fout(date.out);
int main( )
{
int v[100], n, x[100], y[100], m, p, i;
fin>>n;
for(i=0; i<n; i++)
fin>>v[i];
m=0; p=0;
for(i=0; i<n; i++)
if(v[i]%2==0)
{
x[m]=v[i];
m++;
}
else
{
y[p]=v[i];
p++;
}
for(i=0; i<m; i++)
fout<<x[i]<< ;
fout<<endl;
for(i=0; i<p; i++)
fout<<y[i]<< ;
fin.close( );
fout.close( );
return 0;
}

10

Problema 3:
Se citete un vector a cu n elemente ntregi. S se transforme n mulime prin
eliminarea elementelor care se repet.
#include<fstream>
using namespace std;
ifstream fin(date.in);
ofstream fout(date.out);
int main( )
{
int a[100], n, i, k, j;
fin>>n;
for(i=1; i<=n; i++)
fin>>a[i];
for(i=1; i<n; i++)
for(j=i+1; j<=n; j++)
if(a[i]==a[j])
{
for(k=j; k<n; k++)
a[k]=a[k+1];
n--;
j--;
}
for(i=1; i<=n; i++)
fout<<a[i]<<" ";
fin.close( );
fout.close( );
return 0;
}

11

Problema 4:
Se citete un vector a cu n elemente numere ntregi. tergei toate apariiile primului
element i afiai vectorul rmas.
#include<fstream>
using namespace std;
ifstream fin(date.in);
ofstream fout(date.out);
int main( )
{
int a[100], n, i, x, k;
fin>>n;
for(i=1; i<=n; i++)
fin>>a[i];
x=a[1];
for(i=1; i<=n; i++)
if(a[i]==x)
{
for(k=i; k<n; k++)
a[k]=a[k+1];
n--; i--;
}
for(i=1; i<=n; i++)
fout<<a[i]<< ;
fin.close( );
fout.close( );
return 0;
}

12

Problema 5:
Se citete un vector a cu n elemente numere ntregi. Afiai valoarea minim din vector
i poziiile pe care apare ea. Elementele vectorului sunt numerotate de la 1 la n.
#include<fstream>
using namespace std;
ifstream fin(date.in);
ofstream fout(date.out);
int main( )
{
int a[100], n, i, minim;
fin>>n;
for(i=1; i<=n; i++)
fin>>a[i];
minim=a[1];
for(i=1; i<=n; i++)
if(a[i]<minim)
minim=a[i];
fout<<minim<<endl;
for(i=1; i<=n; i++)
if(a[i]==minim)
fout<<i<< ;
fin.close( );
fout.close( );
return 0;
}

13

Problema 6:
Se citete un vector a cu n elemente cifre. Afiai cel mai mic numr natural care se
poate forma cu toate cele n cifre din vectorul a.
#include<fstream>
using namespace std;
ifstream fin(date.in);
ofstream fout(date.out);
int main( )
{
int a[100], n, i, j, aux;
fin>>n;
for(i=1; i<=n; i++)
fin>>a[i];
for(i=1; i<=n; i++)
for(j=i+1; j<=n; j++)
if(a[i]>a[j])
{
aux=a[i];
a[i]=a[j];
a[j]=aux;
}
if(a[1]==0)
{
i=2;
while(a[i]==0)
i++;
a[1]=a[i];
a[i]=0;
}
for(i=1; i<=n; i++)
fout<<a[i];
fin.close( );
fout.close( );
return 0;
}

14

Problema 7:
Se citete un vector a cu n elemente naturale, n numr par. S se interschimbe primul element
cu cel de-al doilea, al treilea cu al patrulea, ..., penultimul cu ultimul i s se afieze vectorul astfel
obinut.

#include<fstream>
using namespace std;
ifstream fin(date.in);
ofstream fout(date.out);
int main( )
{
int a[100], n, i, aux;
fin>>n;
for(i=1; i<=n; i++)
fin>>a[i];
for(i=1; i<n; i=i+2)
{
aux=a[i];
a[i]=a[i+1];
a[i+1]=aux;
}
for(i=1; i<=n; i++)
fout<<a[i]<< ;
fin.close( );
fout.close( );
return 0;
}

Problema 8:
15

Se citete un vector a cu n elemente numere naturale. S se afieze elementele din

vector care sunt mai mici dect rsturnatul lor.
#include<fstream>
using namespace std;
ifstream fin(date.in);
ofstream fout(date.out);
int main( )
{
int n, a[100], i, r, x;
fin>>n;
for(i=1; i<=n; i++)
fin>>a[i];
for(i=1; i<=n; i++)
{
x=a[i];
r=0;
while(x>0)
{
r=r*10+x%10;
x=x/10;
}
if(r>a[i])
fout<<a[i]<<" ";
}
fin.close( );
fout.close( );
return 0;
}

Problema 9:
Se citete un vector a cu n elemente numere naturale. S se elimine din toate
elementele vectorului cifrele impare i s se afieze vectorul astfel obinut.
16

#include<fstream>
using namespace std;
ifstream fin(date.in);
ofstream fout(date.out);
int main( )
{
int n, a[100], i, p, x;
fin>>n;
for(i=1; i<=n; i++)
fin>>a[i];
for(i=1; i<=n; i++)
{
x=0; p=1;
while(a[i]>0)
{
if(a[i]%10%2==0)
{
x=x+p*(a[i]%10);
p=p*10;
}
a[i]=a[i]/10;
}
a[i]=x;
}
for(i=1; i<=n; i++)
fout<<a[i]<<" ";
fin.close( );
fout.close( );
return 0;
}

Problema 10:
Se citete un vector a cu n elemente numere naturale. S se afieze elementul din
vector care are numr maxim de divizori.
#include<fstream>
17

using namespace std;

ifstream fin(date.in);
ofstream fout(date.out);
int main( )
{
int n, a[100], i, k, d, max=0, nr;
fin>>n;
for(i=1; i<=n; i++)
fin>>a[i];
for(i=1; i<=n; i++)
{
k=0;
for(d=1; d<=a[i]; d++)
if(a[i]%d==0)
k++;
if(k>max)
{
max=k;
nr=a[i];
}
}
fout<<nr;
fin.close( );
fout.close( );
return 0;
}

Problema 11:
Se citete un vector cu n elemente ntregi distincte. Inversai ordinea elementelor
cuprinse ntre elementul minim i elementul maxim din vector.
#include <fstream>
using namespace std;
18

ifstream fin("date.in");
ofstream fout("date.out");
int main( )
{
int n, m, i, a[100], vmin, vmax, imin, imax, aux, st, dr;
fin>>n;
for(i=1; i<=n; i++)
fin>>a[i];
vmin=vmax=a[1];
for(i=1; i<=n; i++)
if(a[i]>vmax)
{
vmax=a[i];
imax=i;
}
else
if(a[i]<vmin)
{
vmin=a[i];
imin=i;
}
if(imin<imax)
{st=imin; dr=imax;}
else
{dr=imin; st=imax;}
while(dr>st)
{
aux=a[dr];
a[dr]=a[st];
a[st]=aux;
st++; dr--;
}
for(i=1; i<=n; i++)
fout<<a[i]<<" ";
fin.close();
fout.close();
return 0;
}

Problema 12:
Scriei un program C/C++ care citete de la tastatur un numr natural n (n cel mult
100) i apoi cele n elemente, numere naturale cu cel mult 4 cifre fiecare, ale unui tablou
unidimensional a. Programul afieaz pe o linie a ecranului suma celor n elemente ale
tabloului, pe urmtoarea linie a ecranului suma primelor n-1 elemente i aa mai departe,
astfel nct ultima linie afiat s conin doar primul element al tabloului.
19

#include<fstream>
using namespace std;
ifstream fin("date.in");
ofstream fout("date.out");
int main( )
{
int n, a[100], s=0, i;
fin>>n;
for(i=1; i<=n; i++)
{
fin>>a[i];
s=s+a[i];
}
for(i=n; i>=1; i--)
{
fout<<s<<" ";
s=s-a[i];
}
fin.close( );
fout.close ( );
return 0;
}

Problema 13:
Se consider un vector v cu elemente numere ntregi, cu lungimea n. S se rearanjeze
elementele vectorului, astfel nct, numerele pare s fie scrise naintea numerelor impare.
#include<fstream>
using namespace std;
ifstream fin("date.in");
ofstream fout("date.out");
20

int main()
{
int v[10], n, i, j, aux;
fin>>n;
for(i=0; i<n; i++)
fin>>v[i];
for(i=0; i<n-1; i++)
for(j=i+1; j<n; j++)
if(v[i]%2!=0 && v[j]%2==0 && v[i]>v[j])
{
aux=v[i];
v[i]=v[j];
v[j]=aux;
}
for(i=0; i<n; i++)
fout<<v[i]<<" ";
fin.close( );
fout.close( );
return 0;
}

Problema 14:
Se consider un vector v cu elemente numere ntregi de cel mult patru cifre fiecare, cu
lungimea n. Elementele vectorului sunt sortate cresctor. Scriei un program care afieaz
poziia pe care ar trebui inserat valoarea x (diferit de oricare valoare din tabloul v) n
vectorul v, astfel nct, vectorul s rmn sortat cresctor. Se afieaz i vectorul final.
#include<fstream>
using namespace std;
21

ifstream fin("date.in");
ofstream fout("date.out");
int main( )
{
int v[100], n, i, s, d, m, x;
fin>>n;
for(i=1; i<=n; i++)
fin>>v[i];
fout<<endl;
fin>>x;
fout<<endl;
s=1; d=n;
while(s<=d)
{
m=(s+d)/2;
if(x<v[m])
d=m-1;
else
s=m+1;
}
fout<<"Elementul trebuie sa-l introducem in pozitia "<<s<<" .";
fout<<endl;
for(i=n+1; i>s; i--)
v[i]=v[i-1];
v[s]=x;
fout<<"Vectorul dupa inserarea elementului:";
for(i=1; i<=n+1; i++)
fout<<v[i]<<" ";
fin.close( );
fout.close( );
return 0;
}

Problema 15:
Se citete un vector cu n elemente numere naturale cu elementele numerotate ncepnd
de la 1. S se nlocuiasc fiecare element a[i] cu cea mai mare putere a lui i care este mai mic
sau egal cu a[i], exceptnd primul element al vectorului, element care va rmne neschimbat.
#include<fstream>
using namespace std;
ifstream fin("date.in");
22

ofstream fout("date.out");
int main( )
{
int a[100], n, i, p;
fin>>n;
for(i=1; i<=n; i++)
fin>>a[i];
for(i=2; i<=n; i++)
{
p=1;
while(p*i<=a[i])
p=p*i;
a[i]=p;
}
for(i=1; i<=n; i++)
fout<<a[i]<<" ";
fin.close( );
fout.close( );
return 0;
}

Problema 16:
Se citete un vector a cu n elemente numere ntregi. S se insereze ntre oricare 2
elemente alturate de semne diferite un element obinut prin lipirea valorilor absolute ale celor
2 elemente, n ordinea lor din vector.
#include<fstream>
using namespace std;
ifstream fin("date.in");
ofstream fout("date.out");
int main( )
23

{
int a[100], n, i, j, p, x;
fin>>n;
for(i=1; i<=n; i++)
fin>>a[i];
for(i=2; i<=n; i++)
{
if(a[i]*a[i-1]<0)
{
for(j=n; j>=i; j--)
a[j+1]=a[j];
n++;
p=1;
x=abs(a[i]);
while(x>0)
{
p=p*10;
x=x/10;
}
a[i]=abs(a[i-1])*p+abs(a[i]);
i++;
}
}
for(i=1; i<=n; i++)
fout<<a[i]<<" ";
fin.close( );
fout.close( );
return 0;
}

Problema 17:
Scriei programul C/C++ care citete de la tastatura un numr natural n (n<100) i un
ir cu n numere ntregi din intervalul [100 ;999] ; programul construiete un ir de numere
rezultat prin nlocuirea fiecrui numr din irul citit cu numrul obinut prin interschimbarea
cifrei unitilor cu cifra sutelor. Numerele din noul ir se vor afia pe ecran separate printr-un
singur spaiu.
#include<fstream>
using namespace std;
ifstream fin("date.in");
ofstream fout("date.out");
24

{
int n, i, r, v[20], c;
fin>>n;
for(i=1; i<=n; i++)
fin>>v[i];
for(i=1; i<=n; i++)
{
r=0;
c=v[i]%10+c;
r=r*10+c;
v[i]=v[i]/10;
c=v[i]%10;
r=r*10+c;
v[i]=v[i]/10;
r=r*10+v[i];
v[i]=r;
fout<<v[i]<< ;
}
fin.close( );
fout.close( );
return 0;
}

Problema 18:
Fiierul date.in conine pe prima linie numrul natural n (2 < = n < = 25000), pe a
doua linie un ir de n numere naturale cuprinse ntre 1 i 1000, iar pe a treia linie un numr
natural x cuprins ntre 1 i 1000. S se memoreze irul ntr-un vector i s se nlocuiasc toate
elementele egale cu x cu produsul dintre x i numrul divizorilor lui x. Vectorul rezultat va fi
afiat n fiierul date.out.
#include<fstream>
using namespace std;
ifstream fin("date.in");
ofstream fout("date.out");
25

int main( )
{
int n, v[100], i, x, d, nr;
fin>>n;
for(i=1; i<=n; i++)
f>>v[i];
fin>>x;
for(i=1; i<=n; i++)
{
if(v[i]==x)
{
nr=2;
for(d=2; d<=v[i]/2; d++)
if(v[i]%d==0)
nr++;
v[i]=nr*x;
}
fout<<v[i]<<" ";
}
fin.close( );
fout.close( );
return 0;
}

Problema 19:
Se citete un vector cu componente numere naturale. S se afieze numrul cifrelor
nule cu care se termin numrul format din produsul celor n componente.
#include <fstream>
using namespace std;
ifstream fin("date.in");
ofstream fout("date.out");
int main( )
{
int a[100], n, i, p2=0, p5=0;
26

fin>>n;
for (i=0; i<n; i++)
fin>>a[i];
for (i=0; i<n; i++)
{
while(a[i]%2==0)
{
p2++;
a[i]=a[i]/2;
}
while(a[i]%5==0)
{
p5++;
a[i]=a[i]/5;
}
}
if(p2<p5)
fout<<p2;
else
fout<<p5;
fin.close( );
fout.close( );
return 0;
}

Problema 20:
Se d un vector a cu n elemente numere naturale i o valoare natural s. Afiai toate
secvenele de valori din vectorul a care au suma egal cu s.
#include<fstream>
using namespace std;
ifstream fin("date.in");
ofstream fout("date.out");
int main( )
{
int a[100], s[100], n, i, j, k, s;
fin>>n;
27

s[0]=0;
for(i=1; i<=n; i++)
{
fin>>a[i];
s[i]=s[i-1]+a[i];
}
fin>>s;
for(i=1; i<n; i++)
for(j=i; j<=n; j++)
if(s[j]-s[i-1]==s)
{
for(k=i; k<=j; k++)
fout<<a[k]<<" ";
fout<<"\n";
}
fin.close();
fout.close();
return 0;
}

28

Bibliografie
Manual informatic clasa a IX-a A, editura: Didactica si Pedagogica, anul apariiei: 2012,
autori: Mariana Miloescu
Manual informatic clasa a X-a A, editura: Didactica si Pedagogica, anul apariiei: 2011,
autori: Mariana Miloescu

Webografie
http://www.cnchogastecuci.ro/portofoliu/vectori/index.html
info.mcip.ro/?cap=Tablouri

Cuprin

29

Noiuni teoretice.......................................................................................4
Algoritmi pentru prelucrarea tablourilor de memorie..............................................5
Parcurgerea elementelor unui vector..............................................................5
tergerea unui element dintr-un vector...........................................................5
Inserarea unui element ntr-un vector.............................................................5
Cutarea unui element ntr-un vector nesortat...................................................6
Cutarea unui element ntr-un vector sortat Cutarea binar.................................6
Algoritmi pentru sortarea unui vector...............................................................7
Metoda seleciei directe.............................................................................7
Metoda bulelor BUBBLE SORT.................................................................7
Algoritm pentru interclasarea a doi vectori..........................................................8
Probleme rezolvate....................................................................................9
Problema 1:.........................................................................................9
Problema 2:.......................................................................................10
Problema 3:.......................................................................................11
Problema 4:.......................................................................................12
Problema 5:.......................................................................................13
Problema 6:.......................................................................................14
Problema 7:.......................................................................................15
Problema 8:.......................................................................................16
Problema 9:.......................................................................................17
Problema 10:......................................................................................18
Problema 11:......................................................................................19
Problema 12:......................................................................................20
Problema 13:......................................................................................21
Problema 14:......................................................................................22
Problema 15:......................................................................................23
Problema 16:......................................................................................24
Problema 17:......................................................................................25
Problema 18:......................................................................................26
Problema 19:......................................................................................27
Problema 20:......................................................................................28
Bibliografie...........................................................................................29

30