Magia Programării VI Cu ISBN Final

OANA DABELEA SANDA POPESCU
MAGIA PROGRAMĂRII
Caiet de informatică și TIC pentru clasa a VI-a
2015
Magia programării – Caiet de informatică și TIC pentru clasa a VI-a
ISBN 978-973-0-19038-0
1
Conținut
TIPURI STRUCTURATE DE DATE............................................................................................................... 3
TIPUL TABLOU.................................................................................................................................................. 3
Tablouri unidimesionale în limbajul C++ .................................................................................................. 3
Tablouri bidimesionale în limbajul C++ ................................................................................................... 25
TIPUL FIŞIER .................................................................................................................................................. 52
HTML ................................................................................................................................................................ 61
NOȚIUNI DE BAZĂ ........................................................................................................................................... 61
FORMATARE TEXT................................................................................................................................................ 61
LISTE ................................................................................................................................................................. 64
LEGĂTURI....................................................................................................................................................... 67
IMAGINI .......................................................................................................................................................... 69
TABELE........................................................................................................................................................... 71
BIBLIOGRAFIE .............................................................................................................................................. 74
2
TIPURI STRUCTURATE DE DATE
Tipul tablou
Tablouri unidimesionale în limbajul C++
Ne propunem să realizăm programul la următoarea problemă: ”Se citeşte un şir de n numere

întregi, să se afişeze câte dintre acestea sunt mai mari decât ultimul număr citit din şir.”
La prima vedere totul pare simplu, dar observăm, cu cât n este mai mare cu atât trebuie să
declarăm mai multe variabile care să reţină numerele din şir, iar atunci când începem să realizăm şi
comparările cu ultimul număr din şir, numărul liniilor de program creşte, având impresia că
programul acesta nu o să se mai termine niciodată şi dintr-o dată ceea ce părea foarte simplu a
devenit complicat.
Dar ce vom face totuşi în astfel de cazuri sau în cazuri asemănătoare când trebuie să prelucrăm
un set de valori de acelaşi tip care sunt aşezate într-o anumită ordine?
Limbajul C++ permite ca toate aceste valori de acelaşi tip care sunt aşezate într-o anumită
ordine să fie memorate într-o singură variabilă indexată (compusă) numită tablou unidimensional
sau vector.
Fie A variabila indexată care reţine şirul nostru de numere întregi atunci:
Elementele şirului
…………………
8 17 10 11
0 1 2
Poziţiile numerelor în
primul al doilea al treilea ş.a.m.d. al n-1-lea cadrul şirului
număr număr număr număr
3
Crearea unei structure de date de tip tablou de memorie presupune mai întâi să aibă loc
declararea tabloului de memorie unidimensional (vectorului) pentru a se aloca spațiu de memorie:
tip_dată nume_tablou [număr componente];
unde:
 tip_dată: precizează tipul elementelor(componentelor) din tabloul unidimensional;

 nume_tablou: precizează numele taloului unidimesional;
 număr componente: stabileşte câte elemente(componente) are tabloul(dimensiunea);
Pentru problema noastră vom considera că numele tabloului unidimensional este A, numărul
maxim de elemente (componente) pe care le poate avea tabloul unidimensional este 100, iar tipul
elementelor din tabloul unidimensional este int.
Exemplu:
int A[100];
OBSERVAŢII:
1. Pentru a accesa componentele din tablou se folosesc indici întregi, cuprinși între paranteze
drepte. Dacă un tablou are n componente:
 prima componentă are indicele 0: A[0];
 a doua componentă are indicele 1: A[1];
 …………………………………………………….
 ultima componentă are indicele n-1: A[n-1].
2. Dimensiunea tabloului trebuie să fie o expresie constantă.
Exemplu de declaraţii corecte:
const int dim=10;
int B[dim]; // tabloul B are 10 componente de tip int;
int A[30]; // tabloul A are 30 componente de tip int;
Exemplu de declaraţie incorectă:
int dim=100;
int a[dim];
3. Tipul datelor din tablou, adică tip_dată, trebuie să fie standard sau definit de utilizator
înainte de a fi folosit.
4. La declararea unui vector se pot atribui valori inițiale elementelor, cu instrucțiunea:
4
tip_dată nume_tablou [număr componente]={listă de valori};
Exemplu de declaraţii corecte:

int a[3]={4,6,8}; //s-a declarat tabloul a cu 3 componente de tip int, unde a[0]=4; a[1]=6;
a[2]=8;
float b[2]={2.5,0.4}; //s-a declarat tabloul b are 2 componente de tip float, unde b[0]=2.5;
b[1]=0.4;
Atunci când un tablou este inițializat, la declarare, poate lipsi dimensiunea. El va avea
atâtea elemente câte valori se folosesc la inițializare.
Exemplu
int a[]={4,6,8}; //s-a declarat tabloul a cu 3 componente de tip int, unde a[0]=4; a[1]=6;
a[2]=8;
5. Pentru a folosi o componentă oarecare, fie aceasta ,,A[i]”, a unui tablou unidimensional,
vom scrie numele tabloului urmat de indicele ,, i” între paranteze drepte;
A[i] Un element (o componentă) a tabloului

unidimensional
Poziţia elementului în tabloul

unidimensional
6. Elementele unei variabile de tip tablou se reţin în memoria calculatorului una după alta;
7. Citirea şi afişarea unui vector cu componente de tip întreg se realizează astfel:
Comentarii:
#include <iostream>
using namespace std;
int a[100],i,n; - în secţiunea de declarare a variabilelor s-a
int main() declarat un vector a cu 100 componente
{ întregi;
cout<< "n=";cin>>n; - citim mai întâi numărul n, de componente al
for(i=1;i<=n;i++) { vectorului de care avem nevoie în aplicaţia
cout<<"a["<<i<<"]=";
cin>>a[i]; } noastră;
cout<<"Afisare vector"<<endl; - pentru claritatea programului vom
for(i=1;i<=n;i++) considera că prima componentă a tabloului
cout<<"a["<<i<<"]="<<a[i]<<" "; unidimensional are indicele 1;
return 0; - într-un ciclu for, parcurgem poziţiile
}
componentelor şi pentru fiecare poziţie citim
valoarea corespunzătoare;
- afişarea vectorului se face tot printr-o
parcurgere a poziţiilor componentelor într-un
ciclu for şi pentru fiecare componentă a[i], în
parte, se afişează valoarea.
5
Probleme rezolvate şi propuse spre rezolvare la orele de laborator:
1. Se consideră că avem un şir A de elemente numere întregi. Se cere să se realizeze un

program care să afişeze elementele pare ale şirului, în cazul că există.
Ex.: Fie n=5 şi a=(2, 7, 8, 1, 4), atunci elementele afişate vor fi 2,8,4.
Rezolvarea problemei 1:
#include <iostream>
int a[100],i,n,ok; Comentarii:
int main()
{
cout<< "n=";cin>>n;
- are loc citirea şirului a, cu n
for(i=1;i<=n;i++) { elemente;
cout<<"a["<<i<<"]="; - într-un ciclu for, parcurgem fiecare
cin>>a[i]; } poziţie a elementelor şi verificăm dacă
ok=0; elementul corespunzător poziţiei este
for(i=1;i<=n;i++) un număr par, dacă da, se tipăreşte
if(a[i]%2==0){ok=1;
cout<<"a["<<i<<"]="<<a[i]<<" ";}
elementul ;
if(ok==0) - s-a folosit variabila ok pentru a
cout<<"nu exista elem.pare"; verifica dacă există elemente pare în
return 0; şir.
}
2. Se consideră că avem un şir A de elemente numere întregi. Se cere să se realizeze un

program care să afişeze elementele divizibile cu 5 ale şirului, în cazul că există.
Ex: Fie n=5 şi a=(25, 7, 80, 10, 3), atunci elementele afişate vor fi: 25,80,10.
3. Se consideră că avem un şir A de elemente numere întregi de cel puţin două cifre. Se cere
săse realizeze un program care să afişeze elementele şirului care au ultima cifră impară, în
cazul că există.
Ex: Fie n=5 şi a=(28, 27, 81, 14, 33), atunci elementele afişate vor fi: 27,81,33
4. Se citește un vector cu n elemente, numere naturale. Se cere să se realizeze un program

care să afișeze elementele din vector care sunt multipli ai ultimului element.
Ex: Fie n=5 şi a=(7, 4, 9, 6, 2), atunci elementele afişate vor fi: 4,6,2.
5. Se consideră un şir B de elemente numere întregi. Se cere să se realizeze un program care

să calculeze şi să se afişeze suma elementelor din şir care se găsesc pe poziţii impare şi sunt
divizibile cu 7.
6
Ex: Fie n=5 şi a=(23, 21, 7, 22, 49), atunci suma=7+49=56.

#include <iostream> Comentarii:
int b[100],i,n,s; - are loc citirea şirului b, cu n elemente;
int main() - se iniţializează variabila în care calculăm
{ suma, în cazul nostru s, cu zero;
cout<< "n=";cin>>n;
- într-un ciclu for, parcurgem fiecare poziţie a
for(i=1;i<=n;i++) {
cout<<"b["<<i<<"]="; elementelor, iar atunci când un element se
cin>>b[i]; } află pe o poziţie impară (i%2!=0) şi elementul
s=0; corespunzător poziţiei (b[i]) este un număr
for(i=1;i<=n;i++) divizibil cu 7 (restul împărţirii numărului
if(b[i]%7==0&&i%2!=0) respectiv la 7 este egal cu 0), se adaugă
s=s+b[i];
elementul respectiv la suma s .
cout<<"s="<<s;
return 0; - în final se afişează suma care a fost calculată;
}
6. Se consideră un şir A de elemente numere întregi. Se cere să se realizeze un program care

să calculeze suma şi produsul elementelor şirului.
Ex: Fie n=5 şi a=(2, 7, 8, 1, 3), atunci suma=21, iar produsul=336.

să calculeze suma şi produsul elementelor pare ale şirului.
Ex: Fie n=5 şi a=(2, 7, 8, 1, 3), atunci suma=10, iar produsul=16.

să calculeze suma şi produsul elementelor prime ale şirului A.
Ex:Fie n=4 şi a=(7, 8, 10, 11), atunci suma= 7+11=18, iar produsul=7*11=77.

săcalculeze şi să se afişeze produsul elementelor a căror sumă a cifrelor este un număr
impar.
Ex: Fie n=5 şi a=(23, 567, 78, 22, 12), atunci produsul=5*15*3=22.
10. Se citește un vector cu n elemente, numere naturale. Să se realizezez un program care să

determine suma valorilor elementelor cuprinse între primul și ultimul element par al
vectorului, inclusiv acestea. Dacă șirul nu conține elemente pare se va afișa un mesaj
corespunzător.
Ex: Fie n=5 şi a=(23, 567, 78, 22, 12), atunci s=78+22+12=112
7
11. Se consideră un şir A de n elemente numere întregi. Se cere să se realizeze un program care
să afişeze numărul elementelor prime din şir.
Ex: Fie n=5 şi a=(5,40, 7,8, 11), atunci numărul nr=3.
#include <iostream>
Comentarii:
int a[100],i,n,nr,ok,j;
int main() - are loc citirea şirului a, cu n elemente;
{ - se iniţializează variabila pe care o folosim
cout<< "n=";cin>>n; pentru a număra câte elemente sunt prime cu
for(i=1;i<=n;i++) { zero (în cazul nostru nr=0);
cout<<"a["<<i<<"]="; - într-un ciclu for, parcurgem fiecare poziţie a
cin>>a[i]; }
nr=0; elementelor, şi verificăm dacă elementul
for(i=1;i<=n;i++) corespunzător poziţiei este prim sau nu;
{ ok=1; - dacă elementul (a[i]) este prim, variabila ok va
if(a[i]==1) ok=0; avea valoarea 1, iar variabila nr va creşte cu 1;
for(j=2;j*j<=a[i];j++) - pentru a verifica dacă un număr este prim, am
if(a[i]%j==0)
folosit algoritmul explicat în volum I;
ok=0;
if(ok==1) nr++;} - în final are loc afişarea numărului de elemente
cout<<"nr="<<nr; prime din vector;
return 0;}
12. Se consideră un şir A, de n elemente numere întregi. Se cere să se realizeze un program să

afişeze numărul elementelor pozitive din şir.
Ex: Fie n=5 şi a=(-20,1, 7,-22, 4), atunci numărul nr=3;
13. Se consideră două numere naturale x şi y şi un şir A de n elemente numere întregi. Se cere
să se realizeze un program care să afişeze numărul elementelor pare din şir, care se află în
intervalul [x, y].
Ex: Fie x=12, y=25, n=5 şi a=(10,16, 7,22, 4), atunci numărul nr=2;
14. Se dă un şir A cu n elemente numere întregi.Se cere să se realizeze un program care să

calculeze şi să se afişeze media aritmetică a elementelor impare.
Ex: Fie n=5 şi a=(5,40, 7,8, 11), atunci media =(5+7+11)/3;
8

using namespace std; - are loc citirea şirului a, cu n elemente;
int a[100],i,n,nr,s; - se iniţializează cu zero variabila nr (cu ajutorul căreia
float ma; numărăm câte elemente sunt impare) şi variabila s (în
int main()
care calculăm suma elementelor impare din vector);
{
cout<< "n=";cin>>n; - într-un ciclu for, parcurgem fiecare poziţie a
for(i=1;i<=n;i++) { elementelor, şi verificăm dacă elementul
cout<<"a["<<i<<"]="; corespunzător poziţiei este impar, dacă da, variabila nr
cin>>a[i]; } va creşte cu 1, iar variabila s va creşte cu valoarea
nr=0;s=0; elementului a[i];
for(i=1;i<=n;i++)
if(a[i]%2!=0) {s=s+a[i]; nr++;} - în final, se calculează media aritmetică a
ma=1.0*s/nr; elementelor care sunt impare (în variabila ma) şi se
cout<<"media="<<ma; afişează. Observăm că am înmulțit valoarea lui s cu 1.0
return 0;} astfel încât rezultatul să fie număr real.
-
15. Se dă un vector cu n numere naturale. Să se realizeze un program care să determine câte
-
dintre elemente au valoarea strict mai mare decât media aritmetică a elementelor
vectorului.
Ex: Fie n=5 şi a=(5,0, 2,1, 4), atunci nr =2;
16. Se dă un şir A cu n elemente numere întregi. Să se calculeze şi să se afişeze media

aritmetică a elementelor prime din şir.
Ex: Fie n=5 şi a=(5,4, 7,8, 3), atunci media =(5+7+3)/3;
17. Se dă un şir A cu n elemente numere întregi. Să se construiască şi să se afişeze un vector B

care conţine elementele pozitive din şirul A.
Ex: Fie n=5 şi a=(5,-40, 7,-8, 11), atunci vectorul construit va fi B=(5,7,11) cu k=3 elemente ;
int a[101],b[101],i,n,k; - are loc citirea şirului a, cu n elemente
int main() - folosim variabila k pentru a reţine numărul
{
cout<< "n=";cin>>n;
de elemente al vectorului B;
for(i=1;i<=n;i++) { - iniţial variabila k va fi zero;
cout<<"a["<<i<<"]="; - într-un ciclu for, parcurgem fiecare poziţie
cin>>a[i]; } a elementelor, şi verificăm dacă elementul
k=0; corespunzător poziţiei este pozitiv:
for(i=1;i<=n;i++) - dacă elementul corespunzător poziţiei i
if(a[i]>=0) {k++;
b[k]=a[i];}
(a[i]) este pozitiv, va creşte cu 1 variabila
cout<<”Afis.vector B: ”<<endl; k, iar pe poziţia k în şirul b, se va pune
for(i=1;i<=k;i++) elementul a[i];
cout<<"b["<<i<<"]="<<b[i]<<" "; - în final are loc afişarea vectorului b cu k
return 0; elemente.
}
9
18. Se dă un şir A cu n elemente numere întregi şi două numere naturale x şi y. Să se realizeze

un program care să construiască şi să se afişeze un vector B care conţine elementele aflate
pe poziţii pare şi se află în intervalul [x, y].
Ex: Fie n=5 şi A=(5,4, 7,8,6), x=4 respectiv y=10, atunci vectorul construit va fi B=(4,8) şi va
avea k=2 elemente ;
19. Se citesc două şiruri de numere întregi cu n elemente fiecare. Să se realizeze un program
care să construiască un alt şir care conţine pe fiecare poziţie suma elementelor
corespunzătoare din cele două şiruri.
Ex: Fie n=5 şi A=(15,10, 7,8, 11) respectiv B=(15,20,1,2,1), atunci vectorul construit va fi
C=(30,30,8,10,12) cu n=5 elemente;
20. Se dă un şir A cu n elemente numere întregi. Să se realizeze un program care să

construiască şi să se afişeze un vector B care conţine elementele prime din şirul A.
Ex: Fie n=5 şi A=(5,10, 7,8, 11), atunci vectorul construit va fi B=(5,7,11) şi va avea k=3
elemente ;
21. Se dă un şir A cu n elemente numere întregi. Să se realizeze un program care să

construiască şi să se afişeze un vector B care are ca elemente suma cifrelor fiecărui element
din A.
Ex: Fie n=5 şi A=(35,40,17,18,11), atunci vectorul construit va fi B=(8,4,8,9,2) cu n=5;
#include <iostream>
Comentarii:
int a[101],b[101],i,n,s,x;
int main() - are loc citirea şirului a;
{ - într-un ciclu for, parcurgem fiecare poziţie a
cout<< "n=";cin>>n; elementelor şi calculăm suma cifrelor pentru
for(i=1;i<=n;i++) { fiecare element corespunzător poziţiei în
cout<<"a["<<i<<"]=";
variabila s;
cin>>a[i]; }
for(i=1;i<=n;i++) - vectorul b construit va avea tot n
{ s=0;x=a[i]; elemente(b[1] va conţine suma cifrelor
while(x!=0) elementului a[1], ş.a.m.d. )
{s=s+x%10; - s-a folosit variabila x pentru a păstra
x=x/10;} nealterate valorile şirului a cu n elemente;
b[i]=s;}
- pentru a calcula suma cifrelor pentru fiecare
cout<<"Afis. vect.B"<<endl;
for(i=1;i<=n;i++) element al şirului, am folosit algoritmul
cout<<"b["<<i<<"]="<<b[i]<<" "; explicat în volumul I;
return 0; - în final are loc afişarea şirului b cu n
} elemente;
10
22. Se dă un şir A cu n elemente numere întregi .Să se realizeze un program care să calculeze şi
să se afişezeminimul din şirul A.
Ex: Fie n=5 şi a=(5,4, 7,1,8), atunci mimimul şirului va fi min1=1.
Comentarii:
#include <iostream>
int a[101],min1,i,n;
int main()
- pentru a afla minimul din şirul a cu n elemente procedăm
{ astfel: presupunem mai întâi că minimul ocupă chiar prima
cout<< "n=";cin>>n;
for(i=1;i<=n;i++) { poziţie a şirului, deci minimul şirului este a[1], după care
cout<<"a["<<i<<"]=";
cin>>a[i]; } parcurgem într-un ciclu for începând cu poziţia a doua toate
min1=a[1];
for(i=1;i<=n;i++)
elementele şirului şi verificăm pentru fiecare element
if(a[i]<min1) corespunzător poziţiei, dacă acesta este mai mic decât
min1=a[i];
minimul ales la pasul precedent, dacă da, atunci variabila
cout<<"minim="<<min1;
return 0; care reţine minimul min1 va lua valoarea respectivă;
}
- în final se afişează variabila min1, care reţine minimul.
23. Se dă un şir A cu n elemente numere întregi. Să se realizeze un program care să calculeze şi

să se afişezemaximul din şirul A.
Ex: Fie n=5 şi A=(5,4, 7,1,8), atunci maximul şirului va fi max1=8.
24. Se citește n, apoi încă n numere naturale, reprezentând elementele unui vector. Să se
realizeze un program care să calculeze valoarea minima și valoarea maximă a valorilor
elementelor vectorului.
Ex: Fie n=5 şi A=(5,4, 7,1,8), atunci maximul şirului va fi max1=8, iar minimul șirului va fi
min1=1

să se afişeze maximul elementelor pozitive din şirul A.
Ex: Fie n=5 şi A=(5,-10, 7,-1,8), atunci maximul elementelor pozitive va fi maxpoz=8;
11

#include <iostream>
using namespace std; Comentarii:
int a[101],maxpoz,i,n,j;
int main()
{ - are loc citirea şirului a, cu n elemente
cout<< "n=";cin>>n; - pentru a afla maximul elementelor pozitive din şirul a cu
for(i=1;i<=n;i++) {
cout<<"a["<<i<<"]="; n elemente procedăm aproximativ la fel ca şi la maximul
cin>>a[i]; } dintr-un şir;
i=1; - presupunem că maximul elementelor pozitive este
while(i<=n&&a[i]<0) i++;
if(i>n) primul element pozitiv din şir, iar pentru a-l afla se
cout<<"nu avem elemente pozitive"; procedează astfel:
else{ maxpoz=a[i];
for(j=i+1;j<=n;j++) - se iniţializează o variabilă i cu prima poziţie a şirului;
if (a[j]>0&&maxpoz<a[j]) - atâta timp cât elementul corespunzător poziţiei nu
maxpoz=a[j];}
cout<<"Maximul elem.pozitive="; este pozitiv şi mai sunt elemente în şir care nu au fost
cout<<maxpoz; verificate(i<=n), variabila i creşte cu 1;
return 0;
} - procedeul continuă până când a fost găsit primul
element pozitiv şi atunci pozmax va lua acea
valoare(pozmax=a[i]), sau au fost parcurse toate
elementele şirului şi nici un element nu este pozitiv caz
în care se va afişa un mesaj corespunzător;
- după ce a fost găsit primul element pozitiv se parcurg,
într-un ciclu, for, toate celelalte elemente se verifică
dacă sunt pozitive şi dacă sunt mai mari decât variabila
maxpoz care reţine maximul, situaţie în care aceasta îşi
va schimba valoarea;
- în final se va afişa maxpoz;

să se afişeze media aritmetică aminimului și maximului din elementele șirului A.
Ex: Fie n=5 şi a=(5,4, 7,8, 2), atunci min=2, max=8,media =(8+2)/2;

să se afişeze poziţia pe care se află maximul în şirul A.
Ex: Fie n=5 şi a=(5,-10, 7,-1,8), atunci pozmax=5;
12
Rezolvarea problemei 27
Comentarii:
#include <iostream>
int a[101],pozmax,i,n,j,max1; - pentru a afla poziţia pe care se află maximul în şirul
int main() a cu n elemente procedăm astfel: folosim două
{ variabile una care ne reţine maximul din şir max1
cout<< "n=";cin>>n; - şi alta care ne precizează poziţia pe care o ocupă în
for(i=1;i<=n;i++) {
şir maximul notată cu pozmax;
cout<<"a["<<i<<"]=";
cin>>a[i]; } - presupunem că maximul se află chiar pe prima
max1=a[1]; pozmax=1; poziţie deci variabila pozmax avea valoarea 1, iar
for(i=2;i<=n;i++) variabila max1 va avea valoarea a[1];
if (a[i]>max1) - după care parcurgem într-un ciclu for, începând cu
{max1=a[i]; poziţia a doua toate elementele şirului şi verificăm
pozmax=i;}
cout<<"Pozitie maxim= "<<pozmax;
pentru fiecare element corespunzător poziţiei dacă
return 0; acesta este mai mare decât maximul ales la pasul
} precedent, dacă da atunci variabila care reţine
maximul max1 va lua valoarea respectivă, iar
variabila pozmax va primi valoarea poziţiei
corespunzătoare;
- în final se afişează variabila pozmax, care reţine
poziţia pe care se află maximul şirului;

să afişezepoziţia pe care se află minimul în şirul A.
Ex: Fie n=5 şi A=(5,4, 7,1,8), atunci pozmin=4;
29. Se dă un şir A cu n elemente numere întregi. Să se realizeze un program care să verifice dacă
şirul are toate elementele numere pare şi să afişeze mesajul DA sau NU în caz contrar.
Ex: Fie n=5 şi a=(8,10,4,26,8), se va afişa DA;
Rezolvarea problemei 29 Comentarii:
#include <iostream> - are loc citirea şirului a, cu n elemente;
int a[101],n,i,ok; - atunci când dorim să verificăm dacă toate elementele
int main() unui şir îndeplinesc o condiţie se poate proceda astfel:
{ cout<< "n="; cin>>n; - presupunem că toate elementele şirului îndeplinesc
for(i=1;i<=n;i++) condiţia, iar pentru aceasta folosim o variabilă
cin>>a[i]; notată în program cu ok, care va fi iniţializată cu
ok=1; valoarea 1;
for(i=1;i<=n;i++)
if(a[i]%2!=0) - într-un ciclu for parcurgem toate poziţiile şirului şi
ok=0; verificăm dacă există în şir cel puţin un element
if(ok==1) corespunzător poziţiei care nu îndeplineşte
cout<<"DA"; condiţia, dacă da atunci variabila ok va primi
else valoarea 0;
cout<<"NU"; - dacă variabila ok va avea la final valoarea 1, atunci vom
return 0;} afişa mesajul “DA” (toate elementele şirului îndeplinesc
condiţia), în caz contrar se va afişa mesajul “NU”.
13
30. Se dă un şir A cu n elemente numere întregi. Să se realizeze un program care să verifice şi să

afişeze un mesaj corespunzător,dacă toate elementele din șir sunt pozitive şi mai mari decât
o valoare dată x.
Ex: Fie n=5 şi a=(8,10,4,26,8) x=24, se va afişa NU;
31. Se dă un vector cu n elemente numere naturale. Să se verifice dacă are elementele ordonate
crescător. Programul afișează pe ecran mesajul DA, dacă vectorul are elementele ordonate
crescător, sau NU, în caz contrar.
Ex: Fie n=5 şi a=(8,10,14,26,28) se va afişa DA;

afişezepoziţia pe care se află în şirul A un element egal cu un număr natural x, dacă există.
Ex: Fie n=5 , a=(8,10,4,21,8) şi x=21,se va afişa poziţia 4;

afişezedacă şirul conţine cel puţin un element nul.
Ex: Fie n=5 şi a=(8,0,4,26,8),se va afişa DA;
#include <iostream>
Comentarii:
int a[101],n,i,ok;
int main() - are loc citirea şirului a, cu n elemente şi afişarea lui pe
{ ecran;
cout<< "n="; cin>>n; - atunci când dorim să verificăm dacă există în şir un
for(i=1;i<=n;i++) element care îndeplineşte o condiţie se poate proceda
cin>>a[i]; astfel:
ok=0;
for(i=1;i<=n;i++) - presupunem că nu există nici un element al şirului
if(a[i]==0) care să îndeplinescă condiţia, iar pentru aceasta
ok=1; folosim o variabilă notată în program cu ok, care va
if(ok==1) fi iniţializată cu valoarea 0(având semnificația de
cout<<"DA"; fals);
else
- după care într-un ciclu for parcurgem toate poziţiile
cout<<"NU";
return 0; şirului şi verificăm dacă există în şir cel puţin un
} element corespunzător poziţiei care îndeplineşte
condiţia, dacă da, atunci variabila ok va primi
valoarea 1(având semnificația de adevărat);
- dacă variabila ok va avea la final valoarea 1 atunci, vom
afişa mesajul “DA” (există cel puţin un element în şir care
îndeplineşte condiţia), în caz contrar se va afişa mesajul
“NU”.
14
34. Se dă un şir A cu n elemente numere întregi. Să se realizeze un program care să verifice şi

să se afişezedacă şirul conţine cel puţin un element impar.
Ex: Fie n=5 şi A=(8,10,3,26,8),se va afişa DA.
35. Se dă un vector cu n elemente numere naturale. Să se verifice dacă toate elementele

vectorului sunt egale.Programul afișează pe ecran mesajul DA, dacă vectorul are toate
elementele egale, sau NU, în caz contrar.
Ex: Fie n=5 şi A=(8,10,3,26,8),se va afişa NU.
36. Se dau doi vectori cu câte n elemente, numere naturale. Să se realizeze un program care să
verifice dacă cei doi vectori conțin exact aceleași elemente pe poziții pare. Programul
afișând un mesaj corespunzător.
Ex: Fie n=5 şi A=(9,10,5,26,8) și B=(8,10,3,26,8) se va afișa DA.

să afişezemaximul elementelor pare din şirul A.
Ex: Fie n=5 şi a=(5,10, 7,1,8), atunci maximul elementelor pare va fi maxpare=10.
38. Se dă un şir A cu n elemente numere întregi. Să se realizeze un program care să găsească şi

să se afişeze dacă există ultimul element divizibil cu 7 din şirul A.
Ex: Fie n=5 şi a=(8,10,4,21,8), se va afişa elementul 21;
#include <iostream>
Comentarii:
using namespace std; - are loc citirea şirului a, cu n elemente şi afişarea lui pe
int a[101],n,i; ecran;
int main() - pentru afişa ultimul element al unui şir care îndeplineşte o
{ condiţie, în cazul în care există procedăm astfel:
cout<< "n="; cin>>n; - se iniţializează o variabilă notată în program cu i cu ultima
for(i=1;i<=n;i++)
cin>>a[i]; poziţie a şirului;
i=n; - atâta timp cât elementul corespunzător poziţiei nu
while(i>=1&&a[i]%7!=0) îndeplineşte condiţia şi mai sunt elemente în şir care nu
i--; au fost verificate, variabila i scade cu 1;
if(i==0)
cout<<"NU EXISTA"; - procedeul continuă până când un element îndeplineşte
else condiţia sau au fost parcurse toate elementele şirului şi
cout<<"ELEMENTUL ESTE: nici unul nu îndeplineşte condiţia;
"<<a[i]; - dacă la ieşirea din while variabila i va avea o valoare
return 0; diferită de 0, atunci se va afişa ultimul element care
} îndeplineşte condiţia, în caz contrar, se va afişa un mesaj
că nu există în şir elemente care îndeplinesc condiţia dată.
15
39. Se dă un şir A cu n elemente numere întregi. Să se realizeze un program care să găsească şi

să se afişeze primul element impar din şirul A.
Ex: Fie n=5 şi A=(8,10,5,26,8), se va afişa elementul 5;
40. Se dă un şir cu n elemente, numere naturale. Să se verifice dacă există în şir elemente care
să aibă ambii vecini de aceeaşi paritate cu el. Programul afișează pe ecran mesajul DA, dacă
există în şir elemente care să aibă ambii vecini de aceeaşi paritate cu el, respectiv NU în caz
contrar.
Ex: Fie n=5 şi A=(8,10,3,26,8),se va afişa NU.
41. Se dau doi vectori cu câte n elemente, numere naturale. Verificați dacă cei doi vectori
conțin exact aceleași elemente. Programul va afișa pe ecran mesajul DA, dacă cei doi
vectori conțin exact aceleași elemente, respectiv NU, în caz contrar.
Fie n=5 şi A=(18,10,3,26,8) și B=(10,3,8,26,18)se va afişa DA.
42. Se dă un şir A cu n elemente numere întregi. Să se realizeze un program care să verfice dacă
şirul A are toate elementele distincte.
Ex: Fie n=5 şi A=(8,10,5,26,8), se va afişa:‘NU’.
Comentarii:
#include <iostream>
int n,i,j,ok,a[101]; - are loc citirea şirului a, cu n elemente şi afişarea lui
int main() pe ecran;
{ - presupunem că toate elementele şirului sunt
cout<< "n="; cin>>n; distincte, iar pentru aceasta folosim o variabilă
for(i=1;i<=n;i++) notată în program cu ok, care va fi iniţializată cu
cin>>a[i];
ok=1;
valoarea 1;
for(i=1;i<n;i++) - parcurgem într-un ciclu for fiecare poziţie a
for(j=i+1;j<=n;j++) elementelor de la 1 la n-1 cu ajutorul variabilei de
if(a[i]==a[j]) ciclare i şi comparăm elementul corespunzător
ok=0; poziţiei i, (a[ i ] ) pe care îl vom numi pivot, cu toate
if(ok==1) elemntele care urmează în şir
cout<<"DA";
else (a[i+1],a[i+2],....,a[n]);
cout<<"NU"; - elementele care urmează în şir vor fi parcurse cu
return 0; ajutorul celui de-al doilea ciclu for, unde variabila
} de ciclare j va lua pe rând valorile i+1,i+2,.......,n.
- dacă în urma comparării elementul corespunzător
poziţiei i, a[ i ] este egal cu un element a[ j ] aflat
după el atunci variabila ok va primi valoarea 0;
- dacă variabila ok va avea la final valoarea 1 atunci,
vom afişa mesajul “DA” (toate elementele şirului
distincte), în caz contrar se va afişa mesajul “NU”.
16
În viaţa de zi cu zi suntem de multe ori puşi în situaţia următoare: să ordonăm alfabetic nume de
copii, să aşezăm în ordine crescătoare un şir de copii după înălţimile lor; de asemenea se ştie că
listele cu elevii admişi la un examen sunt afişate în ordine descrescătoare a mediilor şi exemplele pot
continua.
Pentru ca aceste situaţii să fie rezolvate uşor vom prezenta două metode de sortare:
1. sortarea prin interschimbare directă;
2. sortarea prin metoda bulelor.
Sortarea prin interschimbare directă
43. Se dă un şir A cu n elemente numere întregi. Se cere să se realizeze un program care să

sorteze şirul A în ordine crescătoare.
Ex: Fie n=5 şi A=(8,10,5,26,4), se va afişa: A=(4,5,8,10,26);

int n,i,j,x,a[101]; - are loc citirea şirului a, cu n elemente şi afişarea lui pe
int main()
ecran;
{
cout<< "n="; cin>>n; - această metodă este cea mai folosită datorită
for(i=1;i<=n;i++) algoritmului care este foarte simplu şi scurt;
cin>>a[i]; - ideea algoritmului este următoarea:
for(i=1;i<n;i++) - parcurgem într-un ciclu for fiecare poziţie a elementelor
for(j=i+1;j<=n;j++) de la 1 la n-1 cu ajutorul variabilei de ciclare i şi
if(a[i]>a[j]) comparăm elementul corespunzător poziţiei i, (a[ i ] )
{ x=a[i]; pe care îl vom numi pivot, cu toate elementele care
a[i]=a[j]; urmează în şir (a[i+1],a[i+2],....,a[n]);
a[j]=x;} - elementele care urmează în şir vor fi parcurse cu
for(i=1;i<=n;i++) ajutorul celui de-al doilea ciclu for, unde variabila de
cout<<a[i]<<" "; ciclare j va lua pe rând valorile i+1,i+2,.......,n.
return 0; - dacă în urma comparării elementul corespunzător
} poziţiei i, a[ i ] este mai mare decât un element a[ j ]
aflat după el atunci cele două variabile a[i] şi a[j] se vor
interschimba;
- în momentul în care toate elementele a[1], a[2],....,a[n-
1] au fost pivoţi , şirul a fost sortat.
Pentru exemplu nostru şirul transformărilor este:
1) 8, 10, 5, 26, 4;5,10, 8, 26, 4;4, 10, 8, 26, 5; (pivotul este a[1])
2) 4, 10, 8, 26, 5; 4, 8, 10, 26, 5; 4, 5, 10, 26, 8; (pivotul este a[2])
3) 4, 5, 10, 26, 8; 4, 5, 8, 26, 10; (pivotul este a[3])
4) 4, 5, 8, 26, 10; 4, 5, 8, 10, 26; (pivotul este a[4])
17

sorteze şirul A în ordine descrescătoare, folosind sortarea prin interschimbare directă.
Sortarea prin metoda bulelor
sorteze şirul A în ordine crescătoare.

int n,i,j,x,ok,a[101];
- are loc citirea şirului a, cu n elemente şi
int main()
afişarea lui pe ecran;
{
- pentru această metodă ideea algoritmul este
cout<< "n="; cin>>n;
for(i=1;i<=n;i++) următoarea:
cin>>a[i]; - se parcurg în mod repetat elementele
ok=0; şirului, interschimbând elementele vecine
while(ok==0) dacă nu respectă criteriul de ordonare ales
{ ok=1; de noi;
for(i=1;i<n;i++) - şirul este sortat atunci când se realizează o
if(a[i]>a[i+1]) parcurgerea fără să se interschimbe nici un
{ x=a[i]; element;
a[i]=a[i+1]; - parcurgerea în mod repetat a şirului a se
a[i+1]=x; ok=0;}} realizează cu ajutorul instrucţiunii while în
for(i=1;i<=n;i++) care condiţia de oprire este atunci când nu
cout<<a[i]<<" "; se mai realizează nicio interschimbare;
return 0; - pentru aceasta am folosit în program
} variabila ok care va avea valoarea:
- 1 dacă în parcurgerea şirului nu s-a
mai realizat nicio interschimbare de
elemente (şirul este deci sortat) ;
- 0 dacă s-a efectuat cel puţin o
interschimbare în parcurgerea respectivă;
Pentru exemplu nostru şirul transformărilor este:
1) 8, 10, 5, 26, 4; 8, 5, 10, 26, 4; 8, 5, 10, 4,26; (s-a realizat prima parcurgere a şirului, q=false);
2) 8, 5, 10, 4,26; 5, 8, 10, 4,26; 5, 8, 4, 10,26; (s-a realizat a doua parcurgere a şirului, q=false);
3) 5, 8, 4, 10,26; 5, 4, 8, 10,26; (s-a realizat a treia parcurgere a şirului, q=false);
4) 5, 4, 8, 10,26; 4, 5, 8, 10,26; (s-a realizat a patra parcurgere a şirului, q=false);
5) 4, 5, 8, 10,26; (s-a realizat a cincea parcurgere a şirului, q=true şi după cum se şi observă şirul
este sortat crescător.);
18

sorteze şirul A în ordine descrescătoare, folosind sortarea prin metoda bulelor.
47. Se dă un vector cu n elemente, numere naturale și un număr m unde n>m. Să se realizeze

un program care să ordoneze crescător primele m elemente ale vectorului și descrescător
ultimele n-m elemente.
Ex: Fie n=5 şi A=(8,10,5,26,4) și m=3, se va afişa: A=(5,8,10,26,4);
48. Se dă un vector cu n elemente, numere naturale distincte.Să se realizeze un program care

să ordoneze descrescător elementele situate înaintea valorii minime din vector și crescător
elementele situate după această valoare.
Ex: Fie n=5 şi A=(8,10,2,26,4) , se va afişa: A=(10,8,2,4,26);
49. Se citește un vector A cu n (n<=1000) elemente numere naturale. Realizați un program care
să ordoneze crescător elementele prime și plasați-le la începutul vectorului și apoi
descrescător pe cele neprime, în a doua parte a vectorului. Afișați vectorul ordonat ca în
cerință.
Ex: Fie n=5 şi A=(8,10,2,11,4) , se va afişa: A=(2,11,10,8,4);
50. Se citește un vector A cu n (n<=1000) elemente numere naturale. Realizați un program care
să verifice dacă elementele vectorului alternează ca paritate, adică oricare două elemente
alăturate au parități diferite. Răspunsul va fi DA în caz afirmativ, altfel va fi NU.
Ex: Fie n=5 şi A=(8,10,2,11,4) , se va afişa NU, iar pentru A=(3,8,7,112,47) se va afișa DA.
51. Se citește un vector cu n elemente, numere naturale. Să se afișeze elementele din vectori
care sunt multipli ai ultimului element, separate printr-un spațiu.
Ex: Fie n=5 și A=(17, 4, 9, 6, 2), se va afișa 4 6 2
#include <iostream>
int a[1001], n, i;
int main()
{
cin>>n;
for (i=1; i<=n; i++)
cin>>a[i];
for (i=1; i<=n; i++)
if (a[i]%a[n]==0) cout<<a[i]<<' ';
return 0; }
19
52. Se citește un vector cu n elemente, numere naturale. Să se afișeze elementele cu indici pari
în ordinea crescătoare a indicilor, iar elementele cu indici impari în ordinea descrescătoare
a indicilor.
Ex. Dacă n=5 și A=(7 9 2 6 8), se va afișa:
96
827
#include <iostream>
int a[1001], n, i;
int main()
{ cin>>n;
for (i=1; i<=n; i++)
cin>>a[i];
for (i=1; i<=n; i++)
if (i%2==0) cout<<a[i]<<' ';
cout<<'\n';
for (i=n; i>=1; i--)
if (i%2==1) cout<<a[i]<<' ';
return 0;}
53. Se citește un vector cu n elemente, numere naturale. Să se determine câte elemente ale
vectorului sunt egale cu diferența dintre cea mai mare și cea mai mică valoare din vector.
Ex. Dacă n=5 și A=(7 7 9 2 4), se va afișa 2 (Diferența dintre cea mai mare și cea mai mică
valoare din vector este 9 - 2 = 7. Valoarea 7 apare în vector de 2 ori.
#include <iostream>
int a[1000],i,n,Max,Min,C,d,k;
int main()
{ cin>>n;
Min=1000;
Max=0;
for(i=1;i<=n;i++) cin>>a[i];
for(i=1;i<=n;i++)
if(a[i]<Min) Min=a[i];
else if (a[i]>Max) Max=a[i];
d=Max-Min;
C=0;
for(i=1;i<=n;i++)
if(a[i]==d) C++;
cout<<C<<" ";
return 0;}
54. Se citește un vector cu n elemente, numere naturale distincte. Să se afișeze elementele

cuprinse între elementul cu valoarea minimă și cel cu valoare maximă din vector, inclusiv
acestea. Ex. pentru n=5 și A=(7 9 6 2 8), se va afișa 9 6 2
#include <iostream>
int a[1001],n,i,ok,c,x,y,r,j,amax,amin,u,t;
float b[201];
int main()
20
{ cin>>n;
c=0;
cin>>a[1];
if(n==1)
{
cout<<a[1];
return 0;
}
amax=amin=a[1];
t=u=1;
for(i=2;i<=n;i++)
{
cin>>a[i];
if(a[i]>amax)
{
t=i;
amax=a[i];
}
if(a[i]<amin)
{
u=i;
amin=a[i];
}
}
if(u<t)
{
a[0]=u;
u=t;
t=a[0];
}
for(i=t;i<=u;i++)
{
cout<<a[i]<<" ";
}
return 0;}
55. Se dă un şir cu n elemente, numere naturale. Să se verifice dacă în şir există elemente
impare. Programul afișează pe ecran mesajul DA, dacă şirul conţine elemente impare,
respectiv NU în caz contrar. Ex. Pentru n=5 și A=(2 8 6 10 8), se va afișa NU.
#include <iostream>
int n, a[1001], ok, i;
int main()
{ cin>>n;
ok=0;
for(i=1; i<=n; i++)
{
cin>>a[i];
if(a[i]%2==1) ok=1;
}
if(ok==1) cout<<"DA";
else cout<<"NU";
return 0;}
56. Se dă un şir cu n elemente, numere naturale. Să se verifice dacă toate elementele şirului au
număr par de cifre. Programul afișează pe ecran mesajul DA, dacă toate elementele şirului
21
au număr par de cifre, respectiv NU în caz contrar. Ex. Pentru n=5 și A=(2820 82 65 1026 84),
se va afișa DA.
#include <iostream>
int n, i, C, a, k, x[1001];
int main()
{ cin>>n;
C=0;
for (i=1; i<=n; i++)
{
cin>>x[i];
a=x[i];
k=0;
while (a)
{
k++;
a/=10;
}
if (k%2==0) C++;
}
if (C==n) cout<<"DA";
else cout<<"NU";
return 0;}
57. Se dă un şir cu n elemente, numere naturale. Să se verifice dacă toate elementele şirului au
toate cifrele distincte. Programul afișează pe ecran mesajul DA, dacă toate elementele
şirului au toate cifrele distincte, respectiv NU în caz contrar. Ex. Dacă n=5 și A=(84 60 102
24 6), se va afișa DA.
#include <iostream>
long long a[101], n, i, OK, x, c;
int main()
{ cin >>n;
for (i=1; i<=n; i++)
cin >>a[i];
OK=1;
for (i=1; i<=n; i++)
{
while (a[i])
{
x=a[i];
c=x%10;
x/=10;
while (x)
{
if (x%10==c) OK=0;
x/=10;
}
a[i]/=10;
}
}
if (OK==1) cout <<"DA";
else cout <<"NU";
return 0;}
22
58. Să se scrie un program care citeşte cel mult 1000000 de numere naturale din intervalul
închis [0, 9] şi determină cel mai mare număr prim citit şi numărul său de apariţii. Fişierul
de intrare ciffrecv.in conţine cel mult 1000000 numere naturale din intervalul închis [0,9],
dispuse pe mai multe linii şi separate prin spaţii (fişierul de intrare va conţine cel puţin un
num). Fişierul de ieşire ciffrecv.out va conţine pe prima linie două numere naturale MAX şi
NR_AP, cu semnificaţia din enunţ.
ciffrecv.in ciffrecv.out
1 1 2 2 5 2
5 8 9 1 9 5
#include <fstream>
ifstream f("ciffrecv.in");
ofstream g("ciffrecv.out");
long n, a, ap[10];
int main()
{
while (f>>a)
{
if (a==7) ap[7]++;
if (a==5) ap[5]++;
if (a==3) ap[3]++;
if (a==2) ap[2]++;
}
if (ap[7]!=0) g<<7<<' '<<ap[7];
else if (ap[5]!=0) g<<5<<' '<<ap[5];
else if (ap[3]!=0) g<<3<<' '<<ap[3];
else if (ap[2]!=0) g<<2<<' '<<ap[2];
return 0;}
59. Se dau mai multe numere naturale, fiecare cu cel mult 9 cifre. Să se afişeze, în ordine
descrescătoare, toate cifrele care apar în numerele date. Fişierul de intrare cifreord1.in
conţine cel mult 10.000 numere naturale, dispuse pe mai multe linii. Fişierul de ieşire
cifreord1.out va conţine cifrele determinate, ordonate descrescător, câte 20 pe o linie,
valorile de pe fiecare linie fiind separate prin spaţii. Ultima linie a fişierului poate conţine
mai puţin de 20 de cifre.
cifreord1.in cifreord1.out
301941 81912 83392 9 9 9 9 9 8 8 7 7 6 6 6 4 4 4 4 3 3 3 3
776996 431446 2 2 1 1 1 1 1 0
#include <iostream>
#include <fstream>
ifstream f("cifreord1.in");
ofstream g("cifreord1.out");
int x, ap[10], i, j, q;
int main()
{
23
while (f>>x)
{
if (x==0) ap[0]++;
else while (x)
{
ap[x%10]++;
x/=10;
}
}
for (i=9; i>=0; i--)
{
for (j=1; j<=ap[i]; j++)
{
g<<i<<' ';
q++;
if (q%20==0) g<<endl;
}
}
return 0;}
60. Fișierul de intrare nrlipsa1.in conține cel puțin 3 și cel mult 1 000 000 de numere naturale.
Se cere să se afișeze în fișierul de ieșire nrlipsa1.out, separate printr-un spaţiu, două
numere distincte, anume cel mai mic număr par cu două cifre și cel mai mare număr par cu
două cifre care NU fac parte din şir. Dacă nu există două astfel de valori, pe ecran se
afişează mesajul nu exista.
nrlipsa1.in nrlipsa1.out
7 2 40 5 10 15 11 12 18 350 14 98
#include <iostream>
#include <fstream>
ifstream f("nrlipsa1.in");
ofstream g("nrlipsa1.out");
long long x[100],a,p,q,i;
int main()
{
while(f>>a)
if(a>=10 && a<=99)
x[a]=1;
p=0;
for(i=10;i<=98&&!p;i+=2)
if(!x[i]) p=i;
q=0;
for(i=98;i>=10&&!q;i-=2)
if(!x[i]) q=i;
if(p==q) g<<"nu exista";
else g<<p<<" "<<q;
return 0;}
24
Tablouri bidimesionale în limbajul C++
Să presupunem că avem o tablă de şah şi vrem să identificăm poziţia pe care o ocupă două
piese X şi Y pe tabla de şah de mai jos:
1 2 3 4 5 6 7 8
2 X
5 Y
Figura 1:
După cum se ştie o tablă de şah are 64 de căsuţe şi cum se observă din figura 1, prima piesă X
se găseşte în căsuţa aflată la intersecţia liniei 2 cu coloana 3, iar a doua piesă Y se găseşte în căsuţa
aflată la intersecţia liniei 5 cu coloana 6. Deci, putem spunem că piesele de şah găsesc la intersecţia
unei linii cu o coloană.
Vom da tuturor pieselor de şah de pe tablă un nume comun fie acesta a şi cu ajutorul a doi
indici, unul de linie şi unul de coloană, identificăm poziţia pe care o ocupă o piesă pe tabla de şah.
Deci:
 a[2][3] - piesa de şah X se află pe linia 2 şi coloana 3;

 a[5][6] - piesa de şah Y se află pe linia 5 şi coloana 6;
25
Tabla de şah poate fi privită ca un tabel în care piesele de şah sunt elementele tabelului,
poziţionate pe linii şi coloane; datorită acestei aşezări a elementelor în tabel spunem că avem de-a
face cu un tablou bidimensional;
Se numeşte tablou bidimensional deoarece are două dimensiuni, acestea fiind date de linii şi
coloane, iar poziţia unui element din tablou este dată de indicele de linie şi indicele de coloană.
Exemplu: un element al unui tablou bidimensional a, aflat pe linia i şi coloana j, se notează cu

a[i,j], unde i este indicele de linie, iar j este indicele de coloană.
a[ i ][ j ]
indicele de linie indicele de coloană
Un tablou bidimesional în limbajul C++ se declară astfel:
tip_dată nume_tablou[nr_elemente1][nr_elemente2] ;
unde:
 tip_dată: precizează tipul elementelor (componentelor) din tabloul bidimensional.

 nume_tablou: precizează numele taloului bidimesional;
 nr_elemente1, nr_elemente2: sunt două constante întregi care specifică numărul de
elemente ale matricei pentru fiecare dimensiune; nr_elemente1-numărul de linii, iar
nr_elemente2- numărul de coloane.
OBSERVAŢII:
1. Tablurile bidimensionale se mai numesc şi matrici, iar atunci când numărul de linii într-o
matrice este egal cu numărul de coloane spunem că avem de- a face cu o matrice pătratică;
Fie matricea a, cu n linii şi n coloane :
26
 a[0][0]a[0][1]..............................a[0][ n  2]a[0][n  1] 
 
 a[1][0]a[1][1]................................a[1][n  2]a[1][n  1] 
 a[ 2][0]a[ 2][1]..............................a[ 2][ n  2]a[ 2][ n  1] 
 
 .................................................................................. 
 a[ n  1][0]a[ n  1][1]..........a[ n  1][ n  2]a[ n  1][n  1] 
 
Atenţie:
 elementele aflate pe diagonala principală a matricii pătratice sunt: a[0][0], a[1][1],

a[3][3],…., a[n-1][n-1], şi au indicele de linie egal cu indicele de coloană; mai general
vom nota un element de pe diagonala principală cu a[i,i] unde i=0,1,2,...,n-1;
 elementele aflate pe diagonala secundară a matricii pătratice sunt: a[0][n-1], a[1][n-2],

a[3][n-3],…., a[n-1][0]; mai general vom nota un element de pe diagonala secundară cu
a[i][n-i-1] unde i=0,1,2,...,n;
2. Tipul elementelor din tabloul unidimesional poate fi oarecare;

Exemple de declarare unor tablouri bidimensionale (matrici):
a) .....................
Explicaţii:
int a[100][100];
-s-a declarat o variabilă a de tip matrice care poate avea 100
…………………….
de linii şi 100 coloane, iar tipul elementelor matricei este int;
b)
Explicaţii:
........................
float a[50][100]; -s-a declarat o variabilă a de tip matrice care poate avea 50
de linii şi 100 coloane, iar tipul elementelor matricei este
………………………
real ;
Explicaţii:
c) ..................
int a[2][4]={1,2,3,4}; -s-a declarat o matrice cu valori inițiale
sau
int a[2][4]={{1,2},{3,4}} a=
27
3. Tipul datelor din tablou, adică tip_dată, trebuie să fie standard sau definit de utilizator
inainte de a fi folosit.
Exemplu: …………………..
typedef int intreg;
intreg a[10][10];
……………………
4. Deorece adresa matricei este și adresa primului element, iar indicii reprezintă deplasarea
elementului față de adresa matricei, numerotarea indicilor se face de la 0, iar 0<=i<n și
0<=j<m, unde n reprezintă numărul de linii și m numărul de coloane ale matricei.
5. Citirea şi afişarea unei matrici cu n linii şi m coloane:
Observaţie:
- la citirea matricei se va folosi înainte de citirea elementului a[i][j], forma

cout<<”[“<<i<<”,”<<j<<”]=”; pentru a marca elementul ce se citeşte în momentul repectiv :
cout<<”[“<<i<<”,”<<j<<”]=”;
- - pentru claritatea programelor vom realiza numerotarea indicilor de la 1, deci 1<=i<=n și

1<=j<=m.
#include <iostream>
Comentarii:
int a[101][101],i,j,n,m;
- în secţiuneade declarare a variabilelor s-a declarat
int main() tabloul bidimensional ( matrice) cu 101 de linii şi
{ 101 de coloane;
linia
cout<<"n=";cin>>n; coloana
- citim mai întâi în variabilele n şi m, numărul
cout<<"m=";cin>>m;
efectiv de linii şi coloane folosite în aplicaţie;
for(i=1;i<=n;i++)
for(j=1;j<=m;j++) - pentru a realiza citirea, parcurgem cu ajutorul
{ cout<<"a["<<i<<","<<j<<"]="; primului ciclu for liniile tabloului bidimensional,
cin>>a[i][j]; iar variabila de ciclare ,,i” va lua pe rând valorile 1,
} 2,....,n şi pentru fiecare linie ,,i” în parte,
for(i=1;i<=n;i++) parcurgem în al doilea ciclu for cu ajutorul
{for(j=1;j<=m;j++)
variabilei de ciclare ,,j” coloanele 1,2,...,m şi citim
cout<<a[i][j]<<" ";
cout<<endl; elementul corespunzător linie i şi coloanei j, în
} variabila a[i,j];
return 0; - pentru afişarea matricei se procedează astfel:
} - parcurgem în primul ciclu for cu ajutorul
variabilei de ciclare ,,i”, liniile 1,2,….,n, iar pentru
fiecare linie i, afişăm pe un rând toate elmentele
ei cu ajutorul celui de-al doilea ciclu for;
- cu ajutorul lui cout<<endl; trecem la linia
următoare, pentru a continua afişarea
elementelor următoarei linii pe un rând nou;
- afişarea se termină atunci când au fost parcurse
toate liniile şi afişate toate elementele.
28
Probleme rezolvate şi propuse spre rezolvare la orele de laborator:
1. Se dă o matrice A, cu n linii şi n coloane, cu elemente numere întregi. Să se realizeze un

program care afişează elementelor pare din matrice.
2 4 5
Ex: Fie matricea A=   cu n =3, se va afişa: 2,4,10,8.
10 9 13 
9 7 8 
 

program care afişează elementelor impare aflate pe linii pare din matrice.
2 4 5
Ex: Fie matricea A=   cu n =3, se va afişa: 9,13.
10 9 13 
9 7 8 
 

program care afişează elementele pozitive, aflate pe linii pare şi coloane impare în matrice.
2 4 5 3 
Ex: Fie matricea A=   cu n =4, se va afişa: 7,1,9.
7 9 3 2 
6 8 7 5 
 
1 5 9 8 

Comentarii:
#include <iostream>
using namespace std; - are loc citirea matricei a, cu n linii şi coloane;
int a[101][101],i,j,n;
int main() - parcurgem într-un ciclu for, liniile matricei
{
cout<<"n=";cin>>n; i=1,2,....,n, iar pentru fiecare linie în parte, cu
for(i=1;i<=n;i++) ajutorul celui de-al doilea ciclu for parcurgem
for(j=1;j<=n;j++) coloanele j=1,2,.....,n, corespunzătoare liniei ,,i” din
{ cout<<"a["<<i<<","<<j<<"]=";
cin>>a[i][j]; matrice şi verificăm dacă elementul curent a[i,j],
} aflat pe linii pare (i % 2==0) şi coloane impare (j
for(i=1;i<=n;i++) %2!=0) este pozitiv:
for(j=1;j<=n;j++)
if(a[i][j]>0&&i%2==0&&j%2!=0)
cout<<a[i][j]<<" "; - dacă da, are loc afişarea elementului
return 0; respectiv;
} - dacă nu, se trece la verificarea următoarelor
elemente;
- programul se termină atunci când au fost parcurse
toate elementele matricei şi s-a verificat dacă
îndeplinesc condiţiile problemei.
29

program care afişează elementele aflate deasupra diagonalei principale matrice.
2 4 5
Ex: Fie matricea A=   cu n =3, se va afişa: 4,5,13.
10 9 13 
9 7 8
 
int a[101][101],i,j,n; - are loc citirea şi afişarea matricei a, cu n linii şi coloane;
int main()
{ - pentru a înţelege mai uşor problema considerăm
cout<<"n=";cin>>n; următoarea matrice pătratică, pentru n=4;
for(i=1;i<=n;i++)
for(j=1;j<=n;j++) a[1,1] a[1,2] a[1,3] a[1,4]
{
cout<<"a["<<i<<","<<j<<"]="; a[2,1] a[2,2] a[2,3] a[2,4]
cin>>a[i][j];
} a[3,1] a[3,2] a[3,3] a[3,4]
for(i=1;i<n;i++)
for(j=i+1;j<=n;j++) a[4,1] a[4,2] a[4,3] a[4,4]
cout<<a[i][j]<<" ";
return 0; - pentru a afişa elementele de deasupra diagonalei
} principale se observă că trebuie să parcurgem numai
liniile care le conţin şi anume i=1,2,...,n-1, iar pentru
fiecare linie i, vom parcurge numai coloanele j ale liniei i
în care se află elementele, j=i+1,..., n;

program care afişează elementele aflate sub diagonala principală din matrice.
2 4 5
Ex: Fie matricea A= 10 9 13  cu n =3, se va afişa: 10,9,7.
9 7 8 

6. Se dă o matrice A, cu n linii şi n coloane, cu elemente numere întregi. Să se realizeze

program care afişează elementele de pe diagonala principală a matrici.
2 4 5
Ex: Fie matricea A= 10 9 13  cu n =3, se va afişa: 2,9,8.
9 7 8 


program care calculeză şi afişează suma elementelor pare de pe diagonala secundară a
matrici.
30
2 2 4 
Ex: Fie matricea A=  2 
2 6 2  cu n =3, s=4+26=30;
3 2 17 

Comentarii:
#include <iostream> - are loc citirea şi afişarea matricei a, cu n linii şi n
using namespace std; coloane;
int a[101][101],i,j,n,s; - pentru a înţelege mai uşor problema considerăm
int main()
{ următoarea matrice pătratică, pentru n=4;
cout<<"n=";cin>>n; a[1,1] a[1,2] a[1,3] a[1,4]
for(i=1;i<=n;i++)
for(j=1;j<=n;j++) a[2,1] a[2,2] a[2,3] a[2,4]
{
cout<<"a["<<i<<","<<j<<"]=";
a[3,1] a[3,2] a[3,3] a[3,4]
cin>>a[i][j];
}
s=0;j=n; a[4,1] a[4,2] a[4,3] a[4,4]
for(i=1;i<=n;i++)
{if(a[i][j]%2==0) - pentru a calcula suma elementelor pare de pe
s=s+a[i][j]; diagonala secundară vom proceda astfel:
j--;}
cout<<"s="<<s; - se iniţializează variabila s cu zero şi variabila j cu
return 0;
} ajutorul căreia vom parcurge coloanele cu n;
- parcurgem liniile care conţin aceste elemente,
cu ajutorul unui ciclu for, i=1,2,....,n, iar pentru
fiecare linie i, vom lua elementul de pe coloana
j care se află pe diagonala secundară şi
verificăm dacă este par, dacă da variabila s îşi
va schimba valoarea, s:=s+a[i,j];
- în final are loc afişarea sumei s.

program care calculează suma elementelor aflate deasupra diagonalei secundare din
matrice.
2 4 5
Ex: Fie matricea A= 10 9 13  cu n =3, se va afişa: s=2+4+10=16;.
 
9 8 
 7

program care calculează produsul elementele aflate sub diagonala secundară în matrice.
2 4 5
Ex: Fie matricea A= 10 9 13  cu n =3, se va afişa: p=13*7*8;.
 
9 7 8 

31

program care afişează numărul elementelor aflate sub diagonala principală din matrice şi
care sunt mai mari decât o valoare dată x.
2 4 5
Ex: Fie matricea A=   cu n =3 şi x=8 se va afişa: nr=2;.
10 9 13 
9 7 8 
 

Comentarii:
#include <iostream>
using namespace std; - are loc citirea şi afişarea matricei a, cu n linii şi n
int a[101][101],i,j,n,nr,x;
int main() coloane şi citirea variabilei x;
{
cout<<"n=";cin>>n; - pentru a înţelege mai uşor problema considerăm
for(i=1;i<=n;i++) următoarea matrice pătratică, pentru n=4;
for(j=1;j<=n;j++) a[1,1] a[1,2] a[1,3] a[1,4]
{ cout<<"a["<<i<<","<<j<<"]=";
cin>>a[i][j];
}
a[2,1] a[2,2] a[2,3] a[2,4]
cout<<"x="; cin>>x;
nr=0; a[3,1] a[3,2] a[3,3] a[3,4]
for(i=2;i<=n;i++)
for(j=1;j<=i-1;j++) a[4,1] a[4,2] a[4,3] a[4,4]
if(a[i][j]>=x)
nr++; - se iniţializează variabila nr cu zero;
cout<<"nr="<<nr;
return 0; - pentru a calcula şi afişa numărul elementelor
} aflate sub diagonala principală care sunt mai mari
decât o valoare x vom proceda astfel:
- se observă că trebuie să parcurgem numai

liniile care le conţin şi anume i=2,...,n, iar
pentru fiecare linie i, vom parcurge numai
coloanele j ale liniei i în care se află
elementele, j=1,.., i-1;
- dacă elementul curent a[i,j], este mai mare
sau egal cu x, variabila nr va creşte cu 1;
- în final are loc afişarea variabilei nr.

program care afişează numărul elementelor divizibile cu 5 din matrice.
2 4 5
Ex: Fie matricea A=   cu n =3, se va afişa: nr=2;
10 9 13 
9 7 8 
 

program care afişează şi calculează media aritmetică a elementelor din matrice.
32
 2 4 5
Ex: Fie matricea A=   cu n =3, se va afişa: media=42/9;
1 5 1 
9 7 8
 
Comentarii:
#include <iostream>
- are loc citirea şi afişarea matricei a, cu n
int a[101][101],i,j,n,s;
double med; linii şi n coloane;
int main()
{ - se iniţializează variabila s cu zero;
cout<<"n=";cin>>n;
for(i=1;i<=n;i++) - se parcurge matricea şi se calculează în
for(j=1;j<=n;j++) variabila s, suma tuturor elementelor
{ cout<<"a["<<i<<","<<j<<"]=";
cin>>a[i][j]; din matrice;
} - variabila med care reţine media
s=0; aritmetică a tuturor elementelor din
for(i=1;i<=n;i++) matrice, va fi egală cu suma/numărul de
for(j=1;j<=n;j++)
s=s+a[i][j]; elemente al matricei;
med=1.0*s/(n*n);
cout<<"media="<<med; - numărul de elemente al unei matrici
return 0; pătratice este n*n;
} - în final are loc afişarea mediei aritmetice

a matricei.
Indicaţie:
-pentru a calcula media aritmetică a elementelor, dintr-o matrice, care verifică o
condiţie, calculăm mai întâi suma elementelor care verifică acea condiţie şi numărul lor;
- Am înmulțit suma s cu 1.0 pentru a genera o valoare reală la numărătorul expresiei

ce determină media aritmetică, astfel ca rezultatul să fie real

program care afişează şi calculează media aritmetică a elementelor pare şi pozitive din
matrice.
-media aritmetică va fi egală cu suma/numărul elementelor;
2 4 5 
Ex: Fie matricea A=   cu n =3, se va afişa: media=(2+4)/2;
1  5 1 
 9 7  8
 

program care afişează şi calculează media aritmetică a elementelor prime din matrice.
2 4 5 
Ex: Fie matricea A=   cu n =3, se va afişa: media=(2+5+5+3+7)/5;
18 5 3 
9 7 8 
 
33

program care calculează şi afişează minimul din matrice.
 2 4 5
Ex: Fie matricea A=   cu n =3, se va afişa: min=2;
3 5 4 
9 7 8
 

#include<iomanip>
Comentarii:
int a[101][101],i,j,n,min1;
double med; - are loc citirea şi afişarea matricei a, cu n linii şi n
int main() coloane;
{
cout<<"n=";cin>>n; - presupunem că minimul este chiar primul
for(i=1;i<=n;i++)
for(j=1;j<=n;j++) element al matricei, se iniţializează în acest caz,
{ cout<<"a["<<i<<","<<j<<"]="; variabila min1 cu a[1,1];
cin>>a[i][j];
} - vom parcurge toate elementele matricei şi se
min1=a[1][1];
for(i=1;i<=n;i++)
verifică dacă elementul curent aflat pe lina i şi
for(j=1;j<=n;j++) coloana j, a[i,j], este mai mic decât variabila
if(min1>a[i][j]) min1, dacă da, atunci variabila min1 va lua
min1=a[i][j];
cout<<"minimul="<<min1; această valoarea (min1=a[i,j]);
return 0;
} - în final are loc afişarea variabilei care reţine
minimul.

program care calculează şi afişează maximul din matrice.
2 4 5
Ex: Fie matricea A= 10 9 13  cu n =3, se va afişa: max=13.
9 7 8 


program care afişează linia şi coloana pe care se află maximul matrici.
2 4 5
Ex: Fie matricea A= 10 9 13  cu n =3, se va afişa: lpozmax=2, cpozmax=3;
9 7 8 


program care verifică dacă elementele aflate deasupra diagonalei secundare conţin cel puţin
un element nul, afişând un mesaj corespunzător.
34
2 9 8
Ex: Fie matricea A=  2 0 7  cu n =3 se va afişa:NU
2 9 0 
 
Comentarii:
#include <iostream>
#include<iomanip>
- are loc citirea matricei a, cu n linii şi n
int a[101][101],i,j,n,min1; coloane şi afişarea ei pe ecran;
double med; - atunci când dorim să verificăm dacă există
int main() în matrice un element care îndeplineşte o
{ condiţie se poate proceda astfel:
cout<<"n=";cin>>n; - presupunem că nu există nici un
for(i=1;i<=n;i++)
element al matricei situat deasupra
for(j=1;j<=n;j++)
{ diagonalei secundare care să
cout<<"a["<<i<<","<<j<<"]="; îndeplinescă condiţia, iar pentru
cin>>a[i][j]; aceasta folosim o variabilă notată în
} program cu q, care se va iniţializa cu
q=0; valoarea 0 (false);
for(i=1;i<=n;i++)
for(j=1;j<=n-i;j++) - după care parcurgem elementele de
if(a[i][j]==0) deasupra diagonalei secundare din
q=1; matrice cu ajutorul celor două cicluri
if(q==1) for şi verificăm dacă există în matrice
cout<<"DA";
else cel puţin un element aflat pe linia i şi
cout<<"NU"; coloana j, a[i,j], care îndeplineşte
cout<<endl; condiţia, dacă da, atunci variabila q va
return 0;
} primi valoarea 1 (true);
- dacă variabila q va avea la final valoarea 1
(true) atunci, vom afişa mesajul “DA” (există
cel puţin un element nul în matrice), în caz
contrar se va afişa mesajul “NU”.

program care verifică dacă o matrice are toate elemente egale cu o valoare dată x, afişând
un mesaj corespunzător.
2 2 2 
Ex: Fie matricea A=   cu n =3 şi x=2 se va afişa:NU;
2 2 2 
 2 2 17 
 

program care verifică dacă o matrice are cel puţin un element nul, afişând un mesaj
corespunzător.
2 9 8
Ex: Fie matricea A=   cu n =3 se va afişa:DA;
2 0 7
2 9 0 

35

program care verifică dacă o matrice are numai elemente impare, afişând un mesaj
corespunzător.
Ex: Fie matricea A= 1 3 5  cu n =3, se va afişa: DA;

 
1 9 13 
9 7 17 


program care afişează matricea A obţinută prin eliminarea unei linii L1 din matrice.
2 9 8 2 9 8 ;
Ex: Fie matricea A=   cu n =3, L1=2 se va afişa A=  
2 0 7
2 9 0 
2 9 0 

#include <iostream>
#include<iomanip>
Comentarii:
int a[101][101],i,j,n,l1; - are loc citirea şi afişarea matricei a, cu n
int main() linii şi n coloane şi citirea liniei l1 care
{ urmează a fi eliminată;
cout<<"n=";cin>>n; - în acest caz, vom lăsa nemodificate
for(i=1;i<=n;i++)
elementele de pe liniile 1,2,....,l1;
for(j=1;j<=n;j++)
{ cout<<"a["<<i<<","<<j<<"]="; - iar liniile l1,....,n-1 se modifică astfel:
cin>>a[i][j]; - linia l1 va reţine elementele liniei l1+1;
} - linia l1+1 va reţine elementele liniei
cout<<"l1=";cin>>l1; l1+2;
for(i=l1;i<=n-1;i++) - procedeul continuă până când linia n-1
for(j=1;j<=n;j++)
va reţine elementele liniei n;
a[i][j]=a[i+1][j];
- în final are loc afişarea matricei
for(i=1;i<=n-1;i++) modificate, în care numărul de linii a
{for(j=1;j<=n;j++) scăzut cu 1.
cout<<a[i][j]<<" ";
cout<<endl;
}
return 0;
}

program care afişează matricea A obţinută prin eliminarea unei coloane C1 din matrice.
2 9 8 2 8
Ex: Fie matricea A=   cu n =3, C1=2 se va afişa A=  
2 0 7 2 7
2 9 0  2 0 
 
36

program care afişează matricea A obţinută prin eliminarea liniei sau liniilor care au toate
elementele identice.
2 9 8 2 9 8  ;
Ex: Fie matricea A=   cu n =3, se va afişa A=  
2 2 2
2 9 0 
2 9 0 

25. Se dă o matrice A, cu n linii şi n coloane, cu elemente numere întregi şi două linii L1 şi L2. Să
se realizeze un program care verifică dacă o matrice are linia L1 identică cu linia L2, afişând
un mesaj corespunzător.
4 4 4 
Ex: Fie matricea A=  4 4 4  cu n =3, Ll=1 şi L2=2, se va afişa:DA;
 
 9 7 8
 
26. Se dă o matrice A, cu n linii şi n coloane, cu elemente numere întregi şi două coloane C1 şi

C2. Să se realizeze un program care verifică dacă o matrice are o coloană C1 identică cu o
coloană C2, afişând un mesaj corespunzător.
2 2 2 
Ex: Fie matricea A=   cu n =3, C1=1 şi C2=2, se va afişa:DA;
2 2 2 
 2 2 17 
 
Rezolvarea problemei 26 Comentarii:
#include <iostream> - are loc citirea matricei a, cu n linii şi n

#include<iomanip> coloane şi citirea coloanelor c1 şi c2;
using namespace std; - atunci când dorim să verificăm dacă toate
int a[101][101],i,j,n,c1,c2,q;
double med;
elementele celor două coloane sunt
int main() identice se poate proceda astfel:
{ - presupunem că toate elementele celor
cout<<"n=";cin>>n; două coloane sunt identice, iar pentru
for(i=1;i<=n;i++) aceasta folosim o variabilă notată în
for(j=1;j<=n;j++) program cu q, care va fi iniţializată cu
{ cout<<"a["<<i<<","<<j<<"]=";
cin>>a[i][j];
valoarea 1 (true);
} - după care parcurgem într-un ciclu for
cout<<"c1=";cin>>c1; toate liniile matricei cu ajutorul variabilei
cout<<"c2=";cin>>c2; de ciclare ,,i”, (i=1,2,..,n), şi verificăm
q=1; dacă există în matrice cel puţin un
for(i=1;i<=n;i++) element aflat pe linia i şi coloana c1,
if(a[i][c1]!=a[i][c2])
q=0;
diferit de elementul aflat pe linia i şi
if(q==1) coloana c2, dacă da, atunci variabila q va
cout<<"Da sunt identice"; primi valoarea 0 (false);
else - dacă variabila q va avea valoarea 1(true),
cout<<"Nu sunt identice"; atunci când au fost verificate toate elemntele
return 0;}
celor două coloane, vom afişa mesajul “DA”
(elementele celor două coloane sunt identice),
în caz contrar, se va afişa mesajul “NU”.
37

program care afişează matricea A obţinută prin interschimbarea a două coloane C1 şi C2,
ale matricei.
2 9 8 2 8 9 
Ex: Fie matricea A=   cu n =3,C1=2 şi C2=3 se va afişa A=  ;
2 0 7 2 7 0 
2 9 0  2 0 9 
  

program care afişează matricea A obţinută prin interschimbarea a două linii L1 şi L2 din
matrice.
2 9 8 2 9 8
Ex: Fie matricea A=   cu n =3, L1=2 şi L2=3 se va afişa A=  
2 0 7 2 9 0
2 9 0  2 0 7 
 
#include <iostream>
#include<iomanip> Comentarii:
int a[101][101],i,j,n,l1,l2,x; - are loc citirea şi afişarea matricei a, cu
int main() n linii şi n coloane şi citirea liniilor l1 şi
{
l2;
cout<<"n=";cin>>n;
for(i=1;i<=n;i++) - se observă că interschimbarea a două
for(j=1;j<=n;j++) linii l1 şi l2 se reduce de fapt la
{ cout<<"a["<<i<<","<<j<<"]="; interschimbarea elementelor aflate pe
cin>>a[i][j]; linia l1 şi coloana j cu elementele aflate
} pe linia l2 şi coloana j, unde j=1,2,...,n;
cout<<"l1=";cin>>l1;
- interschimbarea valorilor a două
cout<<"l2=";cin>>l2;
for(j=1;j<=n;j++) variabile se poate realiza, după cum se
{x=a[l1][j]; ştie cu ajutorul unei variabile auxiliare
a[l1][j]=a[l2][j]; x;
a[l2][j]=x;} - în final are loc afişarea matricei
for(i=1;i<=n;i++) modificate.
{for(j=1;j<=n;j++)
cout<<a[i][j]<<" ";
cout<<endl;
}
return 0;
29. Scrieţi un program care citeşte de la tastatură două numere naturale nenule n şi m şi care
construieşte în memorie şi apoi afişează o matrice A cu n linii (numerotate de la 1 la n) şi m
coloane (numerotate de la 1 la m) cu proprietatea că fiecare element Aij memorează cea mai
38
mică dintre valorile indicilor i şi j ( 1≤i≤n, 1≤j≤m ). Ex. pentru n=4 și m=5, se va afișa
matricea
11111
12222
12333
12344
#include <iostream>
int n, m, i, j, a[21][21];
int main()
{ cin>>n>>m;
for (i=1; i<=n; i++)
for (j=1; j<=m; j++)
if (i<=j) a[i][j]=i;
else a[i][j]=j;
for (i=1; i<=n; i++)
{
for (j=1; j<=m; j++) cout<<a[i][j]<<' ';
cout<<endl;
}
return 0;}
30. Scrieţi un program care citeşte de la tastatură un număr natural n şi construieşte în memorie
o matrice cu n linii şi n coloane ale cărei elemente vor primi valori după cum urmează:
 elementele aflate pe diagonala principală a matricei vor primi valoarea 0

 elementele de pe prima coloană, cu excepţia celui aflat pe diagonala principală vor
primi valoarea n
 elementele de pe a doua coloană, cu excepţia celui aflat pe diagonala principală vor
primi valoarea n-1
…
 elementele de pe ultima coloană, cu excepţia celui aflat pe diagonala principală vor
primi valoarea 1.
Ex. dacă se citește valoare 4 pentru n, se va afișa matricea:

0 3 2 1
4 0 2 1
4 3 0 1
4 3 2 0
#include <iostream>
int a[25][25],n,t,i,j;
int main()
{
cin>>n;
for(i=1;i<=n;i++)
a[i][i]=0;
t=n;
for(j=1;j<=n;j++)
{for(i=1;i<=n;i++)
39
if(i!=j) a[i][j]=t;
t--;}
for(i=1;i<=n;i++)
{for(j=1;j<=n;j++)
cout<<a[i][j]<<' ';
cout<<'\n';
}
return 0;}
31. Scrieţi un program care citeşte de la tastatură două numere naturale nenule n şi m şi
construieşte în memorie o matrice cu n linii şi m coloane astfel încât, parcurgând tabloul
linie cu linie de sus în jos şi fiecare linie de la stânga la dreapta, să se obţină şirul primelor
n*m pătrate perfecte impare , ordonat strict crescător. Ex.n=2 și m=3 se va afișa:
1 9 25
49 81 121
#include <iostream>
int n, i, j, a[101][101], k, m;
int main()
{ cin>>n>>m;
k=1;
for(i=1; i<=n; i++)
for(j=1; j<=m; j++)
{
a[i][j]=k*k;
k+=2;
}
for(i=1; i<=n; i++)
{for(j=1; j<=m; j++)
cout<<a[i][j]<<" ";
cout<<'\n';}
return 0;}
o matrice cu n linii şi n coloane ale cărei elemente vor primi valori după cum urmează:
elementul din linia i şi coloana j primeşte ca valoare ultima cifră a produsului i*j (1≤i≤n şi
1≤j≤n). Ex. pentru n=4 se va afișa matricea:
1 2 3 4
2 4 6 8
3 6 9 2
4 8 2 6
#include <iostream>
int i, j, n, a[25][25];
int main()
{
cin>>n;
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
a[i][j]=(i*j)%10;
for(i=1;i<=n;i++)
{for(j=1;j<=n;j++)
40
cout<<a[i][j]<<" ";
cout<<"\n";
}
return 0;}
33. Scrieţi un program care citeşte de la tastatură un număr natural nenul n cu cel mult 9 cifre şi
construieşte un tablou bidimensional pătratic cu dimensiunea egală cu numărul de cifre ale
lui n, completată cu cifrele lui n.
Elementele de pe prima coloană vor fi egale cu cifra unităţilor lui n, elementele de pe a doua
coloană vor fi egale cu cifra sutelor, etc. De exemplu, dacă se citește valoarea 1359, pentru
n, se va afișa matricea:
9 5 3 1
9 5 3 1
9 5 3 1
9 5 3 1
#include <iostream>
int n,nr,k,i,j,c,a[101][101];
int main()
{ cin>>n;
k=0;
nr=n;
while (nr)
{
k++;
nr/=10;
}
for (j=1; j<=k; j++)
{
c=n%10;
for (i=1; i<=k; i++)
a[i][j]=c;
n/=10;
}
for (i=1; i<=k; i++)
{
for (j=1; j<=k; j++)
cout<<a[i][j]<<' ';
cout <<'\n';
}
return 0;}
34. Scrieţi un program care citeşte de la tastatură un număr natural n cu exact 5 cifre şi
construieşte în memorie o matrice cu 6 linii şi 6 coloane ale cărei elemente vor primi valori
după cum urmează:
 elementele aflate pe diagonala principală sunt toate nule;

 elementele de pe linia 1, aflate deasupra diagonalei principale precum şi elementele de
pe coloana 1, aflate sub diagonala principală au toate valoarea egală cu cifra unităţilor
lui n;
41

pe coloana 2, aflate sub diagonala principală au toate valoarea egală cu cifra zecilor lui
n;
…
pe coloana 6, aflate sub diagonala principală au toate valoarea egală cu cifra zecilor de
mii a lui n;
De exemplu, dacă pentru n se citește valoarea 28731, se va afișa matricea:

0 1 1 1 1 1
1 0 3 3 3 3
1 3 0 7 7 7
1 3 7 0 8 8
1 3 7 8 0 2
1 3 7 8 2 0
#include <iostream>
int n,i,j,m,a[101][101],x;
int main()
{ cin>>n;
for(i=1;i<=5;i++)
{
for(j=i+1;j<=6;j++)
{
a[i][j]=n%10;
a[j][i]=a[i][j];
}
n=n/10;
}
for(i=1;i<=6;i++)
{
for(j=1;j<=6;j++)
cout<<a[i][j]<<' ';
cout<<endl;
}
return 0;}
o matrice cu n linii şi n coloane în care elementele de pe cele două diagonale sunt egale cu
0, elementele care se află deasupra ambelor diagonale sunt egale cu 1, elementele care se
află sub ambele diagonale sunt egale cu 2, iar restul elementelor sunt egale cu 3. Ex. pentru
n=5 se va afișa matricea:
0 1 1 1 0
3 0 1 0 3
3 3 0 3 3
3 0 2 0 3
0 2 2 2 0
#include <iostream>
int i,j,n,a[25][25];
int main()
42
{
cin>>n;
for(i=1;i<=n;i++)
a[i][i]=0;
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
a[i][n-i+1]=0;
for(i=1;i<=n/2;i++)
for(j=i+1;j<n-i+1;j++)
a[i][j]=1;
for(j=1;j<=n/2;j++)
for(i=j+1;i<n-j+1;i++)
a[i][j]=3;
for(i=n;i>=1;i--)
for(j=i-1;j>=n-i+2;j--)
a[i][j]=2;
for(j=n;j>=1;j--)
for(i=j-1;i>=n-j+2;i--)
a[i][j]=3;
for(i=1;i<=n;i++)
{for(j=1;j<=n;j++)
cout<<a[i][j]<<" ";
cout<<endl;}
return 0;}
o matrice cu n linii şi n coloane, numerotate de la 1 la n, în care elementele de pe liniile cu
indice impar sunt egale cu indicele de linie, iar elementele situate pe linii cu indice par sunt
egale cu indicele de coloană. Ex. pentru n=5 se v afișa matricea:
1 1 1 1 1
1 2 3 4 5
3 3 3 3 3
1 2 3 4 5
5 5 5 5 5
#include <iostream>
int n,a[25][25],i,j;
int main()
{
cin>>n;
for (i=1; i<=n; i++)
for (j=1; j<=n; j++)
if (i%2!=0) a[i][j]=i;
else a[i][j]=j;
for (i=1; i<=n; i++)
{
for (j=1; j<=n; j++)
cout<<a[i][j]<<' ';
cout<<endl;
}
return 0;}
o matrice cu n linii şi n coloane, numerotate de la 1 la n, în care fiecare element aflat pe
chenarul exterior al matricei este egal cu suma dintre indicele liniei şi indicele coloanei pe
43
care se află, iar fiecare dintre celelalte elemente este egal cu suma celor trei “vecini” situaţi
în matrice pe linia anterioară. Ex. pentru n=5 se va afișa matricea:
2 3 4 5 6
3 9 12 15 7
4 24 36 34 8
5 64 94 78 9
6 7 8 9 10
#include <iostream>
int n, i, j, a[16][16];
int main()
{
cin>>n;
for (j=1; j<=n; j++) a[1][j]=j+1;
for (i=2; i<=n; i++) a[i][1]=i+1;
for (j=2; j<=n; j++) a[n][j]=a[n][j-1]+1;
for (i=2; i<=n; i++) a[i][n]=a[i-1][n]+1;
for (i=2; i<n; i++)
for (j=2; j<n; j++) a[i][j]=a[i-1][j-1]+a[i-1][j]+a[i-1][j+1];
for (i=1; i<=n; i++)
{
for (j=1; j<=n; j++) cout<<a[i][j]<<' ';
cout<<endl;
}
return 0;}
38. Scrieţi un program care citeşte de la tastatură două numere naturale nenule n şi m şi care
construieşte în memorie şi apoi afişează o matrice A cu n linii şi m coloane astfel încât prin
parcurgerea acesteia linie cu linie de sus în jos şi fiecare linie de la stânga la dreapta, se
obţin în ordine descrescătoare toate numerele naturale de la 1 la m*n. Ex. n=4 și m=3, se va
afișa:
12 11 10
9 8 7
6 5 4
3 2 1
#include <iostream>
int n, m, i, j, x, a[25][25];
int main()
{ cin>>n>>m;
x=n*m;
for (i=1; i<=n; i++)
for (j=1; j<=m; j++)
{
a[i][j]=x;
x--;
}
for (i=1; i<=n; i++)
{
for (j=1; j<=m; j++) cout<<a[i][j]<<' ';
cout<<endl;
}
return 0;}
44
39. Scrieţi un program care citeşte de la tastatură un număr natural n şi construieşte în

memorie o matrice cu n linii şi n coloane, numerotate de la 1 la n, în care se vor memora în
ordinea crescătoare a valorii, pe linii şi coloane, primele n*n numere naturale nenule, pare,
care nu sunt divizibile cu 3. Ex. pentru n=4 se va afișa:
2 4 8 10
14 16 20 22
26 28 32 34
38 40 44 46
#include <iostream>
int n,i,j,x,a[51][51];
int main()
{ cin>>n;
x=0;
for (i=1; i<=n; i++)
for (j=1; j<=n; j++)
{
x+=2;
if (x%3==0)
while(x%3==0) x+=2;
a[i][j]=x;
}
for (i=1; i<=n; i++)
{
for (j=1; j<=n; j++) cout<<a[i][j]<<' ';
cout<<'\n';
}
return 0;}
40. Scrieţi un program care citeşte de la tastatură doua numere naturale n şi k şi construieşte în
memorie o matrice cu n linii şi n coloane formată numai din valori 1, 2, 3 şi 4 astfel încât:
elementele aflate la intersecţia primelor k linii cu primele k coloane sunt egale cu 1,
elementele aflate la intersecţia primelor k linii cu ultimele n-k coloane sunt egale cu 2,
elementele aflate la intersecţia ultimelor n-k linii cu primele k coloane sunt egale cu 3,
elementele aflate la intersecţia ultimelor n-k linii cu ultimele n-k coloane sunt egale cu 4. De
exemplu, pentru n=5 și k=3 se va afișa matricea:
1 1 1 2 2
1 1 1 2 2
1 1 1 2 2
3 3 3 4 4
3 3 3 4 4
#include <iostream>
int n, k, i, j, a[25][25];
int main()
{ cin>>n>>k;
for (i=1; i<=k; i++)
for (j=1; j<=k; j++) a[i][j]=1;
for (i=1; i<=k; i++)
for (j=k+1; j<=n; j++) a[i][j]=2;
for (i=k+1; i<=n; i++)
45
for (j=1; j<=k; j++) a[i][j]=3;

for (i=k+1; i<=n; i++)
for (j=k+1; j<=n; j++) a[i][j]=4;
for (i=1; i<=n; i++)
{
for (j=1; j<=n; j++) cout<<a[i][j]<<' ';
cout<<endl;
}
return 0;}
41. Scrieţi un program care citeşte de la tastatură trei numere naturale n, a, b şi construieşte în
memorie o matrice cu n linii şi n coloane formată numai din valori 0, 1, 2, 3 şi 4 astfel încât:
elementele aflate pe linia a sau coloana b sunt egale cu 0, cele aflate deasupra liniei a şi la
stânga coloanei b sunt egale cu 1, cele aflate deasupra liniei a şi la dreapta coloanei b sunt
egale cu 2, cele aflate sub linia a şi la stânga coloanei b sunt egale cu 3, iar elementele aflate
sub linia a şi la dreapta coloanei b sunt egale cu 4. Ex. pentru n=5, a=4 și b=3, se va afișa
matricea:
1 1 0 2 2
1 1 0 2 2
1 1 0 2 2
0 0 0 0 0
3 3 0 4 4
#include <iostream>
int n, i, j, a, b, x[25][25];
int main()
{ cin>>n>>a>>b;
for (i=1; i<a; i++)
for (j=1; j<b; j++) x[i][j]=1;
for (i=1; i<a; i++)
for (j=b+1; j<=n; j++) x[i][j]=2;
for (i=a+1; i<=n; i++)
for (j=1; j<b; j++) x[i][j]=3;
for (i=a+1; i<=n; i++)
for (j=b+1; j<=n; j++) x[i][j]=4;
for (i=1; i<=n; i++)
{
for (j=1; j<=n; j++) cout<<x[i][j]<<' ';
cout<<endl;
}
return 0;}
o matrice cu n linii şi n coloane în care ultima linie conţine, în ordine, numerele 1, 2, 3,.., n,
elementele situate deasupra diagonalei principale sunt nule şi oricare alt element este
obţinut prin însumarea elementelor vecine cu el, aflate pe linia imediat următoare, pe
aceeaşi coloană cu el sau pe una din coloanele alăturate. Ex. pentru n=4, se va afișa
matricea:
27 0 0 0
9 18 0 0
3 6 9 0
46
1 2 3 4
#include <iostream>
int i,j,n,k,a[16][16];
int main()
{
cin>>n;
for(i=1;i<=n;i++)
a[n][i]=++k;
for(i=n-1;i>=1;i--)
for(j=1;j<=i;j++)
a[i][j]=a[i+1][j-1]+a[i+1][j]+a[i+1][j+1];
for(i=1;i<=n;i++)
{for(j=1;j<=n;j++)
cout<<a[i][j]<<' ';
cout<<'\n';}
return 0;}
43. Scrieţi un program care citeşte de la tastatură două numere naturale n şi m şi construieşte în
memorie o matrice cu n linii şi m coloane care conţine numerele naturale de la 1 la m*n,
dispuse astfel:
 prima linie conţine numerele de la 1 la m, ordonate crescător;
 a doua linie conţine numerele de la m+1 la 2*m, ordonate descrescător;
 a treia linie conţine numerele de la 2*m+1 la 3*m, ordonate crescător;
 a patra linie conţine numerele de la 3*m+1 la 4*m, ordonate descrescător;
 etc.
Ex. pentru n=4 și m=5, se va afișa matricea:

1 2 3 4 5
10 9 8 7 6
11 12 13 14 15
20 19 18 17 16
#include <iostream>
int n, m, i, j, a[16][16];
int main()
{
cin>>n>>m;
for (i=1; i<=n; i++)
if (i%2) for (j=1; j<=m; j++) a[i][j]=(i-1)*m+j;
else for (j=m; j>=1; j--) a[i][j]=(i-1)*m+m-j+1;
for (i=1; i<=n; i++)
{
for (j=1; j<=m; j++) cout<<a[i][j]<<' ';
cout<<endl;
}
return 0;}
44. Scrieţi un program care citeşte de la tastatură un număr natural n şi construieşte în memorie o
matrice cu n linii şi n coloane în care:
 toate elementele de pe prima coloană au valoarea 1;
 ultima linie conţine, în ordine strict crescătoare, numerele naturale din intervalul [1, n];
47
 oricare alt element este obţinut prin însumarea celor două elemente vecine cu el,
aflate pe linia imediat următoare şi pe aceeaşi coloană cu el, respectiv pe aceeaşi linie
cu el şi pe coloana anterioară.
Ex. pentru n=4, se va afișa matricea:

1 5 15 35
1 4 10 20
1 3 6 10
1 2 3 4
#include <iostream>
int n, m, i, j, a[16][16];
int main()
{
cin>>n;
for (i=1; i<=n; i++) a[i][1]=1;
for (j=2; j<=n; j++) a[n][j]=a[n][j-1]+1;
for (i=n-1; i>=1; i--)
for (j=2; j<=n; j++) a[i][j]=a[i][j-1]+a[i+1][j];
for (i=1; i<=n; i++)
{
for (j=1; j<=n; j++) cout<<a[i][j]<<' ';
cout<<endl;
}
return 0;}
o matrice cu n linii şi n coloane ale cărei elemente sunt numere naturale, fiecare
reprezentând ultima cifră a câte unui termen al şirului lui Fibonacci, începând de la termenul
de indice 1 şi până la termenul de indice n2 . (Se consideră şirul lui Fibonacci, definit astfel:
f1=1 , f2=1 , fn=fn-1+fn-2 , dacă n>2.) Ex. pentru n=4, se va afișa matricea:
1 1 2 3
5 8 3 1
4 5 9 4
3 7 0 7
#include <iostream>
int n, i, j, a, b, x[25][25];
int main()
{
cin>>n;
a=b=1;
x[1][1]=x[1][2]=1;
for (i=1; i<=n; i++)
for (j=1; j<=n; j++)
{
if (!(i==1&&j==1 || i==1&&j==2))
{x[i][j]=(a+b)%10;
a=b;
b=x[i][j];}
}
for (i=1; i<=n; i++)
{
for (j=1; j<=n; j++) cout<<x[i][j]<<' ';
48
cout<<endl;
}
return 0;}
46. Se dă o matrice cu n linii şi n coloane şi elemente numere naturale. Calculaţi cel mai mare
divizor comun al sumei elemente de deasupra diagonalei principale și al sumei elementelor
de sub diagonala principală. Ex. n=4 și matricea
8 3 5 6
5 5 6 5
3 8 6 5
8 4 8 8 se va afișa: 6
#include <iostream>
int a[201][201],n,i,j,s1,s2, t;
int main()
{ cin>>n;
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
cin>>a[i][j];
if(i>j) s1+=a[i][j];
if(i<j) s2+=a[i][j];
}
}
t=s1%s2;
while(t)
{
s1=s2;
s2=t;
t=s1%s2;
}
cout<<s2;
return 0;}
47. Se dă o matrice cu n linii şi n coloane şi elemente numere naturale. Să se determine suma

elementelor de pe cele două diagonale vecine cu diagonala principală. Ex. pentru datele de
intrare
5
3 1 8 5 4
7 8 5 1 2
2 2 6 7 3
9 8 1 3 6
7 5 3 1 7 se va afișa 30 (1+5+7+6+7+2+1+1)
#include <iostream>
int a[201][201],n,i,j,s,s2,k=0,ap[1001];
int main()
{
cin>>n;
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
cin>>a[i][j];
if(j==i+1||j==i-1) s+=a[i][j];
49
}
}
cout<<s;
return 0;}
48. Scrieţi un program care citeşte de la tastatură un număr natural n ( 1 ≤ n ≤ 20 ) şi apoi

elementele unui tablou bidimensional cu n linii şi n coloane, care memorează numere
naturale. Programul afişează pe ecran numărul de elemente din tablou care sunt strict mai
mari decât toate elementele cu care se învecinează direct (aflate pe aceeaşi linie dar pe o
coloană alăturată sau pe aceeaşi coloană dar pe o linie alăturată). Ex. pentru datele de
intrare:
4
1 5 1 1
2 1 2 3
1 3 4 2
2 1 2 1 se va afișa 5 (Elementele din matrice care respectă regula sunt: 5 2 3 4 2)
#include <iostream>
int n,i,a[21][21],j,k;
int main()
{ cin>>n;
for(i=1;i<=n;i++)
for(j=1;j<=n;j++) cin>>a[i][j];
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
{
if(a[i][j]>a[i][j-1] && a[i][j]>a[i][j+1] &&
a[i][j]>a[i-1][j]&&a[i][j]>a[i+1][j]) k++;
}
cout<<k;
return 0;}
49. Se dă o matrice cu m linii şi n coloane şi elemente numere naturale cu cel mult 4 cifre fiecare.
Să se determine coloanele matricei care au toate elementele egale cu aceeași valoare. Ex.
pentru datele de intrare:
4 5
2 3 7 5 7
3 3 7 4 7
7 3 7 1 7
8 3 7 6 7 se va afișa: 3 7 7
#include <iostream>
int a[51][51],i,j,m,n,Ok,C;
int main()
{ cin>>m>>n;
for (i=1; i<=m; i++)
for (j=1; j<=n; j++) cin>>a[i][j];
C=0;
for (j=1; j<=n; j++)
{
Ok=1;
for (i=2; i<=m; i++) if (a[i-1][j]!=a[i][j]) Ok=0;
50
if (Ok==1)
{
cout<<a[i-1][j]<<' ';
C++;
}
}
if (C==0) cout<<"nu exista";
return 0;}
50. Se consideră tabloul bidimensional cu m linii şi n coloane şi elemente numere naturale. Să se

construiască un nou tablou bidimensional cu n linii şi m coloane, obţinut din primul prin
rotirea acestuia în sens trigonometric cu 90 o. Fişierul de intrare rotire.in conţine pe prima
linie numerele m şi n, iar pe următoarele m linii câte n numere naturale separate prin spaţii,
reprezentând elementele tabloului. Fişierul de ieşire rotire.out va conţine tabloul nou
construit, câte o linie a tabloului pe o linie a fişierului, elementele fiecărei linii fiind separare
printr-un spațiu.
rotire.in rotire.out
4 5 25 30 35 40
21 22 23 24 25 24 29 34 39
26 27 28 29 30 23 28 33 38
31 32 33 34 35 22 27 32 37
36 37 38 39 40 21 26 31 36
#include <fstream>
ifstream f("rotire.in");
ofstream g("rotire.out");
long n, m, i, j, a[12][12], b[12][12];
int main()
{
f>>m>>n;
for (i=1; i<=m; i++)
for (j=1; j<=n; j++) f>>a[i][j];
for (i=1; i<=m; i++)
for (j=1; j<=n; j++) b[n+1-j][i]=a[i][j];
for (i=1; i<=n; i++)
{
for (j=1; j<=m; j++) g<<b[i][j]<<' ';
g<<endl;
}
return 0;
}
51
Tipul fişier
Noţiunea de fişier
Un fişier este o colecţie de date de acelaşi tip, stocate pe disc. Atât programele C++, texte scrise
într-un limbaj de programare cât şi documente Word sau desene realizate în Paint precum şi
programele executabile sau colecţii de date sunt exemple de fişiere. Un fişier fizic, existent pe disc,
este identificat printr-un nume. Fișierul are două nume:
-numele extern sau numele fizic (este numele cu care este înregistrat pe director);
-numele intern sau numele logic (este numele sub care este cunoscut în cadrul programului)
În limbajul C++ sunt implementate două tipuri de fișiere:
-fișire text conțin numai caractere reprezentate în codul ASCII(se numeşte aşa deoarece
cuprinde, de obicei, caractere de orice tip: litere, cifre, spaţii, caractere speciale) structurate pe linii;
-fișiere binare conțin o secvență de octeți, fără o structură predefinită (vor fi studiate mai
târziu).
Fişiere text.
Noi folosim fişierele pentru stocarea datelor de intrare/ieşire. Să ne imaginăm că avem de

prelucrat o matrice de 10 de linii şi 10 de coloane şi trebuie să introducem valori pentru matricea
respectivă. Le introducem, citindu-le de la tastatură, dar programul, dintr-un motiv sau altul, nu
afişează rezultatul dorit. Identificăm greşeala şi, evident, trebuie să testăm din nou, deci să
introducem din nou cele 100 de valori pentru matricea buclucaşă. Dacă nici acum nu merge… Dar
dacă matricea ar avea 100 de linii şi 100 de coloane?
Un alt exemplu care ar trebui să ne convingă de necesitatea lucrului cu fişiere este acela că
unele rezultate trebuie listate la imprimantă. Evident că pentru aceasta trebuie să fie reţinute (şi
cum, dacă nu într-un fişier?).
Fişierele ce reţin date de intrare/ieşire sunt fişiere text. Componenetele acestora sunt caractere
structurate pe linii de lungimi variabile. Fiecare linie este terminată cu un marcaj de sfârşit de linie
(caracterele CR - #13- Carriage Return - caracterul de pe poziţia 13 în codul ASCII- şi LF – #10- Line
Feed- caracterul de pe poziţia 10 în codul ASCII). Fişierul este terminat cu caracterul ^Z( Ctrl+Z).
Operațiile specifice fișierelor sunt:

-deschiderea: -pentru scriere;
-pentru citire;
52
-pentru adăugare la sfârșitul fișierului;

-închiderea;
-operații de test:
-verificarea sfârșitului de fișier;
Pentru ca un program C++ să lucreze cu un fişier text, este necesară utilizarea fișierului antet
fstream.h.
Exemplu: #include<fstream.h>
Pentru a putea citi/scrie informații dintr-un/într-un fișier folosim:
ifstream nume_fișier_logic(nume_fișier);// deschiderea unui fișier pentru a citi date
ofstream nume_fișier_logic(nume_fișier);// deschiderea unui fișier pentru a scrie date
Exemplu:
-fișier de intrare ifstream f(“date.in”);
-fișier de ieșire ofstream g(“date.out”);
Crearea unui fișier cu date ”date.in”ce urmează a fi citite prin program și afișarea numerelor
într-un fișier de ieșire ”date.out” se realizează astfel:
53
Se alege Yes, după care se introduce în căsuța de la File name numele fișierului date.in în care vor fi
datele care urmează a fi prelucrate prin program și Save.
Se alege Ok. După care se introduce pe prima linie numărul de numere ce urmează a fi citite din
fișierul date.in, iar pe linia a doua numerele.
54
După executarea programului se crează fișierul date.out care pentru a fi văzut procedăm astfel:
FILE-OPEN
Selectăm fișierul date.out și apăsăm butonul Open.
55
Citirea datelor de la tastatură și Citirea datelor din fișierul date.in și afișarea lor fișierul
afișarea lor pe ecran. date.out.
#include <iostream> #include <fstream>
using namespace std; using namespace std;
int n,x,i; ifstream f("date.in");
int main() ofstream g("date.out");
{cin>>n; int n,x,i;
for(i=1;i<=n;i++) int main()
{ cin>>x; {f>>n;
cout<<x<<" ";} for(i=1;i<=n;i++)
return 0; { f>>x; //citim în x cele n numere din fișier
} g<<x<<" ";}//scriem cele n numere în fișier
f.close(); g.close();
return 0;}
Funcții utile în prelucrarea fișierelor text

 eof()– se folosește pentru a detecta sfârșitul de fișier. Returnează valoarea 0 dacă nu am
ajuns la sfârșitul fișierului, respectiv 1 dacă am ajuns la sfârșit.
 close()-se utilizează pentru închiderea unui fișier deschis.
Exemplu: Să se citească toate numerele din fișier, până la sfârșitul acestuia(nu este cunoscut
numărul valorilor din fișier).
#include <fstream>
ifstream f("date.in");
ofstream g("date.out");
int s,n,x;
int main()
{s=0;
while( f>>x) // Expresia f>>x este folosită pentru a testa momentul în care se termină execuția
s=s+x; //repetată a instrucțiunii while.
g<<s;
return 0;}
56
Probleme rezolvate şi propuse spre rezolvare la orele de laborator
1. Se citeşte din fisierul date.in un şir de numere întregi de pe prima linie, separate printr-un
spaţiu. Să se afişeze toate numerele pozitive din fișierul date.in în fişierul date.out, unul
sub altul.
#include <fstream> date.in

ifstream f("date.in"); 2 –3 123 –45 12 –99 7 -123
int x; date.out
int main()
{while( f>>x) 2
{ 123
if(x>=0) 12
g<<x<<'\n';} 7
return 0;} 7
2. Din fişierul f1.in se citesc n numere naturale astfel: de pe prima linie valoarea lui n, iar de
pe celelalte n linii numerele naturale. Să se descompună în factori primi numerele şi să
afişeze în f1.out, fiecare descompunere pe câte un rând, factorii primi separaţi printr-un
spaţiu.
#include <fstream>
using namespace std; f1.in
ifstream f("f1.in");
3
ofstream g("f1.out");
int n,i,x,d;
120
int main()
{f>>n; 12
for(i=1;i<=n;i++)
{f>>x; 75
d=2;
while(x!=1)
{ if(x%d==0) f1.out
{x=x/d;
g<<d<<" "; } 22235
else
d++; } 223
g<<'\n';}
f.close();g.close(); 355
return 0;}
57
3. Pe prima linie a fişierului NUMERE.TXT se află o valoare naturală nenulă n, iar pe

următoarea linie se află exact n valori naturale, separate printr-un spaţiu. Scrieţi un
program care afişează în fişierul PARE.TXT toate valorile pare din cele n citite de pe a doua
linie din fişierul de intrare.
4. Din fişierul date.in se citesc mai multe numerere întregi cuprinse între 0 si 255. Să se scrie
în fişierul date.out numerele convertite în baza 2, unul sub altul.
#include <fstream>
int n,p,x,nr;
int main()
{
while(f>>x)
{p=1;nr=0;
while(x!=0)
{nr=nr+p*(x%2);
x=x/2;
p=p*10;
}
g<<nr<<endl;}
f.close();g.close();
return 0;}
5. În date.in se găseşte o matrice pătratică astfel: pe prima linie n- dimensiunea matricii şi pe

următoarele n linii matricea. Să se afişeze în date.out acele linii care au elementele în
ordine strict crescătoare.
int a[101][101],i,n,j,ok; 3
ifstream f("date.in"); 2 4 1
ofstream g("date.out"); 3 5 7
int main() 2 6 3
{ f>>n;
for(i=1;i<=n;i++)
date.out
for(j=1;j<=n;j++)
f>>a[i][j]; 3 5 7
for(i=1;i<=n;i++)
{ok=1;
for(j=1;j<n;j++)
if(a[i][j]>a[i][j+1])
ok=0;
if(ok==1)
{for(j=1;j<=n;j++)
g<<a[i][j]<<" ";
g<<'\n';}
58
} f.close(); g.close();
return 0;}
6. În fişierul date.in se gǎsesc mai multe numere naturale, scrise pe primul rând al fişierului.
Sǎ se scrie în fişierul date.out acele dintre ele care sunt palindroame.
int x,y,nr,inv; 123 12321 111 1001 100
int main()
{ while(f>>x)
{y=x;
inv=0; date.out
while(y!=0)
12321 111 1001
{inv=inv*10+y%10;
y=y/10; }
if(inv==x)
g<<x<<" ";}
return 0;}
7. Din fişierul date.in se citeşte de pe primul rând un numǎr natural, iar de pe urmǎtorul rând
n numere naturale, separate printr-un spaţiu. Sǎ se scrie pe prima linie numerele citite în
ordine crescǎtoare, în fişierul date.out.

using namespace std; 6
int a[101],i,n,j,aux; 3 5 2 1 7 4
int main()
{ f>>n;
for(i=1;i<=n;i++)
f>>a[i]; date.out
for(i=1;i<n;i++)
for(j=i+1;j<=n;j++) 1 2 3 4 5 7
if(a[i]>a[j])
{aux=a[i];
a[i]=a[j];
a[j]=aux;}
for(i=1;i<=n;i++)
g<<a[i]<<" ";
return 0;}
59
8. Se citeşte din date.in o matrice nXn: de pe prima linie se citeşte dimensiunea n a matricii,
iar de pe următoarele n linii elementele matricii. Sǎ se calculeze suma elementelor de pe
diagonala principalǎ şi secundarǎ şi să se scrie ca în exemplu în fişierul date.out.

using namespace std; 4
int a[101][101],i,n,j,s1,s2; 1234
ifstream f("date.in"); 1234
ofstream g("date.out"); 1234
int main() 2234
{
f>>n;
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
f>>a[i][j];
s1=0;s2=0; date.out
for(i=1;i<=n;i++) s1= 10
{s1+=a[i][i]; s2= 11
s2+=a[i][n-i+1];}
g<<s1<<" "<<s2;
return 0;
}
9. Fișierul text date.in conține, pe o singura linie, cel mult 1000 de numere naturale nenule,
numerele fiind separate prin câte un spațiu. Scrieți un program C/C++ care citește de la
tastatură un număr natural nenul n și numerele din fișierul date.in și care afișează pe ecran,
separate prin câte un spațiu, toate numerele din fișier care sunt divizibile cu n. Dacă fișierul
nu conține niciun astfel de număr, atunci se va afișa pe ecran mesajul NU EXISTA.
Ex: și n=10 date.in se va afișa: 500 10 40
3 500 2 10 7 40
10. Scrieţi un program C/C++ care citeşte din fişierul text date.in cel mult 100 de numere
naturale nenule aflate pe o singura linie, formate din cel mult 4 cifre fiecare, separate prin
spații și scrie în fişierul date.out numerele, în ordinea inversă față de cea în care au fost
citite, pe o singură linie separate prin spații.
Ex: se va afișa:
date.in date.out
3 5 2 10 7 40 40 7 1 0 2 5 3
60
HTML
Noțiuni de bază
HTML este prescurtarea de la Hyper Text Markup Language și este codul care stă la baza
paginilor web. Fișierele HTML au extensia .html sau .htm.
Putem scrie astfel de fișiere cu Notepad sau cu orice alt editor de text. Trebuie să fim atenție ca,
atunci când salvăm un fișier, extensia acestuia trebuie să fie .htm sau .html.
Un document html este format din elemente, marcate printr-o succesiune de tag-uri. Tag-
urile sunt simbolurile care marcheaza inceputul și sfârșitul unui element. În marea lor majoritate,
acestea apar în pereche, una de deschidere <etichetă> și una de închidere </etichetă>.
Componența unui document HTML este:
1. versiunea HTML a documentului
2. zona head cu etichetele <head></head>
3. zona body cu etichetele <body></body>
Toate paginile HTML încep cu eticheta <html> și se termină cu eticheta </html>.
În interiorul acestor etichete găsim perechea <head></head> și perechea <body></body>.
Zona head conține titlul paginii între etichetele <title> și </title>, stiluri pentru formatarea textului,
scripturi și linkuri către fișiere externe (de exemplu scripturi Javascript, fișiere de tip CSS, etc).
Conținutul etichetei title este afișat de browser pe cea mai de sus linie (banda albastră de sus).
Zona body găzduiește practic toate etichetele afișate de browser pe ecran.
Exemplu: o pagina HTML cu titlul Exemplu, iar conținutul Continut pagina
<html>
<head>
<title>Titlu</title>
</head>
<body>
Continut pagina
</body>
</html>
Comentariul in HTML, care bineînțeles nu va fi afișat de browser, poate fi introdus astfel:

Formatare text
În HTML trecerea la un rând nou se face doar prin introducerea etichetei <br>, iar pentru paragraf
nou cu eticheta <p>.
61
Exemplu
HTML Afisare
Exemplu de text. <br> Exemplu de text.

Ana are mere. Ana are mere.
<p>Exemplu de paragraf. </p>
Exemplu de paragraf.
<hr> introduce o linie linie orizontală și trecerea la un rând nou.
Folosind unele etichete specifice, textul poate fi formatat.
Spre exemplu fonturilor li se poate modifica: mărimea, culoarea, forma (normal, bold, italic),
familia (Arial, Verdana, etc.), textul poate fi aliniat pe orizontală sau verticală iar titlurile (header),
de la 1 la 6, sunt diferite ca mărime (1 cel mai mare iar 6 cel mai mic).
Etichetele <span> si </span> delimiteaza un șir de caractere în vederea formatării.
Etichetele <div> si </div> sunt similare etichetelor <span> si </span>, cu diferența că formatează
mai multe elemente și introduc un rând nou inainte și după sfârșitul zonei formatate.
Unul din atributele blocului div este align care poate lua valorile:
center aliniere pe centru

left aliniere la stanga
right aliniere la dreapta
Dacă dorim ca textul să fie afișat exact așa cum a fost introdus (text preformatat) în fișierul sursă
vom folosi pereche de etichete <pre> și </pre>.
Exemplu
HTML Afisare
Exemplu de text normal Exemplu de text normal
<b>Exemplu de text bold</b> Examplu de text bold
<i>Exemplu de text cursiv</i> Exemplu de text cursiv
<u>Exemplu de text subliniat</u> Exemplu de text subliniat
<del>Exemplu de text taiat</del> Exemplu de text taiattext taiat
Exemplu de <sup>exponent</sup> Exemplu de exponent
62
Exemplu de <sub>indice</sub> Exemplu de indice
<tt>caractere monospatiate</tt> caractere monospatiate
<cite>Citat</cite> Citat
<em>evidentiat</em> evidentiat
<code>text continand cod de computer</code> text continand cod de computer
<kbd>text continand cod de computer</kbd> text continand cod de computer
<samp>mostra de cod de computer</samp> mostra de cod de computer
<strong>text ingrosat</strong> text ingrosat
<big>mare</big> mare
<small>mic</small> mic
<font color="red">font rosu</font> font rosu
<font face="Courier">font Courier</font> font Courier
<font size="6">font size=6</font>

font size=6
<div align="center">text aliniat pe centru</div> text aliniat pe centru
<div align="left">text aliniat la stanga</div> text aliniat la stanga
<div align="right">text aliniat la dreapta</div> text aliniat la dreapta
<h1>Titlu 1</h1> Titlu 1

<h6>Titlu 6</h6>
Titlu 6
63
Legenda:
br = line break/ sfârșit de rând
p = paragraph
hr = horizontal rule
Liste
Listele sunt un mod simplu de organizare a informației și pot fi neordonate, ordonate și de definiții.
Liste neordonate
Aceste liste sunt delimitate de etichetele <ul> si </ul>, iar elementele de <li> si </li>.
Exemplu
HTML Afisare
Exemple de culori:
Exemple de culori:
<ul>
<li>rosu</li>
 rosu
<li>verde</li>
 verde
<li>albastru</li>  albastru
</ul>
Elementele listei pot fi particularizate folosind atributul type care poate lua valorile square, circle și
disc (observați afișarea)
Exemplu
HTML Afisare
Exemple de fructe:
Exemple de fructe:
<ul>
<li type="square">mere</li>
 mere
<li type="circle">pere</li>
o pere
<li type="disc">prune</li>  prune
</ul>
Liste ordonate
Aceste liste sunt delimitate de etichetele <ol> și </ol>, iar elementele de <li> și </li>.
Exemplu
64
HTML Afisare
Exemple de combustibili:
Exemple de combustibili:
<ol>
<li>benzina</li>
1. benzina
<li>motorina</li>
2. motorina
<li>gaz lichefiat</li> 3. gaz lichefiat
</ol>
Elementele listei pot fi particularizate folosind atributul type care poate lua valorile A (litere mari), a
(litere mici), I (cifre romane mari), i (cifre romane mici), 1 (opțiunea default):
Exemplu
HTML Afisare
Medii de stocare:
Medii de stocare:
<ol>
<li type="I">HDD-ul</li>
I. HDD-ul
<li type="I">discheta</li>
II. discheta
<li type="I">CD-ROM-ul</li> III. CD-ROM-ul
</ol>
Liste de definiții
Aceste liste sunt delimitate de etichetele <dl> si </dl>. Termenii listei sunt delimitați de etichetele
<dt> și </dt>, iar definițiile termenilor de <dd> și </dd>.
Exemplu
HTML Afisare
Legenda: Legenda:
<dl> HTML
<dt>HTML</dt>
<dd>Hyper Text Mark-ul Language</dd> Hyper Text Mark-ul Language
<dt>IP</dt>
<dd>Internet Protocol</dd> IP
</dl> Internet Protocol
65
Listele pot fi imbricate, adică în interior pot conține una sau mai multe liste.
Exemplu
HTML Afisare
<ol> 1. Monitoare
<li>Monitoare o CRT
<ul> o LCD
2. Imprimante
<li>CRT</li>
o cu jet de cerneala
<li>LCD</li> o laser
</ul>
</li>
<li>Imprimante
<ul>
<li>cu jet de cerneala</li>
<li>laser</li>
</ul>
</li>
</ol>
Legenda:
ul = listă neordonată dt = termen al unei liste
ol = listă ordonată dd = derscrierea unui termen al listei
li = item al unei liste

dl = definiția listei
66
Legături
Legatura (link-ul) este o etichetă foarte importantă în HTML deoarece dă posibilitate utilizatorului
să navigheze de la o pagina la alta. De obicei link-ul este subliniat iar atunci când suntem deasupra
lui cursorul își schimbă forma.
Link-ul este definit cu etichetele <a> si </a> și are atributele:
href - adresa fișierului destinație

target - în ce fereastra se va deschide fișierul destinație
title - o mică descriere asociată legăturii afișată în momentulîin care mouse-ul se află
deasupra legăturii
<a href="adresa-fisier" target="_blank" title="titlu">
Adresa fisierului destinație poate fi exprimată astfel:
nume fișier, dacă se afla în același folder cu pagina curentă
<a href="fisier.html">
folder/nume fisier,dacă se află in alt folder
<a href="folder/fisier.html">
adresa URL, fiind adresa completă a paginii
<a href="http://www.proba.ro/fisier.html">
Atributul target poate lua valorile:
_blank pagina va fi încărcată într-o nouă fereastră

_parent pagina va fi încărcată în fereastra părinte
_top pagina va fi încărcată în fereastra top a cadrului
_self pagina va fi încărcată în aceeași fereastră
Exemplu: link catre pagina https://infopascupas.wordpress.com/
HTML Afisare
<a href="https://infopascupas.wordpress.com/">Site
Site de pregătire
de pregatire</a>
67
Exemplu: link catre pagina https://infopascupas.wordpress.com/ încarcată într-o nouă fereastră
HTML Afisare
<a href="https://infopascupas.wordpress.com/"
Site de pregătire
target="_blank">Site de pregatire</a>
Putem insera un link către o adresa de e-mail putând asocia și un subiect prestabilit
HTML Afisare
<a href="mailto:test@test.ro">Send e-mail</a> Send e-mail
<a href='mailto:test@test.ro?subject="subiect prestabilit"'>Send e-

Send e-mail
mail</a>
Culoarea linkurilor
Poate fi modificata introducand in eticheta body urmatoarele atribute:
LINK legatura nevizitată (default albatru)

VLINK legatura vizitată (default rosu)
ALINK legatură activă (nu prea se folosește - default portocaliu)
Exemplu:
<html>
<head>
<title>Exemplul 3_3</title>
</head>
<body link="green" vlink="black" alink="yellow">
<a href="link.html">Link</a>
</body>
</html>
Ancore
Se pot adăuga puncte de reper (ancore) pentru o deplasare mai ușoară în cazul unor pagini HTML
lungi sau către un loc anume aflat într-o altă pagină.
Ancora se definește tot între etichetele <a> și </a>, dar cu atributul name. Pentru a face trimitere
către ancoră se introduce un link cu atributul href având ca valoare denumirea ancorei.
Exemplu:
Ancora <a name="nume">Ancora</a>
68
Link catre ancora aflata in aceeasi <a href="#nume">Inapoi la ancora</a>

pagina
Link catre ancora aflata in alta <a href="pagina.html#nume">Inapoi la ancora din

pagina pagina.html</a>
Link din imagine

Putem folosi o imagine pentru un link. Primul exemplu este cu chenar, iar al doilea fără chenar.
HTML Afisare
<a href="http://www.drogoreanu.ro"><img src="images/poza.jpg"

width="100" height="75" alt="poza" border="1"></a>
<a href="http://www.drogoreanu.ro"><img src="images/poza.jpg"

width="100" height="75" alt="poza" border="0"></a>
Imagini
Folosind imagini, pagină capătă un plus de atractivitate.
Câteva din formatele de imagini utilizate în paginile web sunt: JPEG (*.jpg sau *.jpeg), GIF (*.gif),
BMP (*.bmp), PNG (*.png).
Eticheta folosită pentru inserarea unei imagini in pagina este <img> și are urmatoarele atribute:
src = sursa, locul unde se află imaginea
width = lățimea imaginii
height = înălțimea imaginii
alt = numele care înlocuiește imaginea până aceasta se încarcă sau când nu a fost găsită
border = chenar (0 = lipsa bordura)
Dimensiunea imaginii afișate de browser este stabilită de argumentele width si height.

În cazul în care cele 2 argumente (width si height) sunt diferite de dimensiunile fișierului imagine,
browserul va redimensiona imaginea afișată.
Recomandare:
Eticheta img va contine mereu argumentele:

- height și width, astfel browserul va putea afișa corect pagina chiar înainte ca imaginea să
fie încărcată complet
69
- alt, existența valorii acestui atribut este utilă din punct de vedere SEO (Search Engine
Optimization)
Exemplu: o imagine cu lățime 100px, înălțime 75px, alt=poza și border=0 și încă o dată cu border=1
HTML Afisare
<img src="poza.jpg" width="100" height="75"

alt="poza" border="0">

alt="poza" border="1">
Exemplu: acceasi imagine care contine atributele alt si title (verificati cu Internet Explorer si Firefox)
HTML Afisare

alt="poza" title="poza">
Dacă doriți ca textul să încadreze imaginea, adăugați etichetei img atributul align
HTML Afisare
<img src="poza.jpg" width="100" height="75" alt="poza"

align="right"> text text text text text text text text text
text text text text text
text text text text text text text text text text text text text
text text
text text text text
70
<img src="poza.jpg" width="100" height="75" alt="poza"

align="left"> text text text text text text text text text text
text text text text text text text text text text text text text
text
text text text text
Tabele
Aceste etichete au o mare utilizare deoarece tabele constituie structura care stă la baza organizării
marii majorități a paginilor web.
Tabelul este format din linii și coloane împărțind zona în celule. Fiecare celulă păstrează informația
care va fi afișată. Pentru o afișare corectă a tabelului, fiecare rând va avea același număr de celule.
Dacă dorim ca o celulă să fie goală vom introduce un spațiu gol (space).
Pentru inserarea unui tabel este folosită perechea de etichete <table> și </table>, pentru un rând
<tr> și </tr> iar pentru o celulă <td> și </td>.
Tabele pot fi imbricate, adică în interior pot conține unul sau mai multe tabele.
Exemplu: tabel cu 2 coloane și 2 randuri, border 1, coloana 1 lățime 80px, coloana 2 lățime 160px,
fiecare celulă are o altă culoare de fond (bgcolor).
HTML Afisare
<table border="1">
<tr><td width="80" bgcolor="red">rosu</td><td width="160" rosu galben
bgcolor="yellow">galben</td></tr><tr><td
bgcolor="white">alb</td><td bgcolor="green">verde</td></tr> alb verde
</table>
Atributele etichetei table sunt:

border = bordura (0 = lipsa bordura)
width = lățimea tabelului
height = înălțimea tabelului
bgcolor = culoarea de fundal
background = imaginea de fundal
71
cellspacing = distanța între celule

cellpadding = distanța dintre marginea celulei și conținut
Atributele etichetei td sunt:

align = aliniere pe orizontală a conținutului (left=stânga, right=dreapta, center=centru)
valign = aliniere pe verticală a conținutului (top=sus, bottom=jos, middle=mijloc)
width = lățimea celulei
height = înălțimea celulei
bgcolor = culoarea de fundal
background = imaginea de fundal
colspan = unesște celula cu cea din dreapta ei
rowspan = unește celula cu cea de sub ea
Dacă dorim să evidențiem conținutul primului rând (capul de tabel) putem folosi perechea de
etichete <th> și </th> în locul etichetelor <td> si </td>. Astfel conținutul celulei va fi afișat îngroșat
și aliniat pe mijloc.
Exemplu: un tabel cu 3 randuri și 2 coloane folosind pe primul rând etichetele <th> si </th>
HTML Afisare
Titlul Titlul
<table border="1"> 1 2
<tr><th width="120">Titlul 1</th><th width="120">Titlul
2</th></tr><tr><td>1</td><td>2</td></tr><tr><td>3</td><td>4</td></tr> 1 2
</table>
3 4
Eticheta caption va adaugă o linie text deasupra tabelului, centrată pe mijloc, de obicei folosită ca
fiind un titlu al tabelului. Caption se plasează obligatoriu imediat după tag-ul table, dar înainte de
prima etichetă tr.
Exempl
u: un tabel cu 4 rânduri și 2 coloane folosind eticheta caption
HTML Afisare
<table border="1">
Necesar componente
<caption>Necesar componente</caption><tr><th
width="120">Produse</th><th Produse Cantitate
width="120">Cantitate</th></tr><tr><td>Procesoare</td><td>1
buc.</td></tr><tr><td>Placi de baza</td><td>1
buc.</td></tr><tr><td>Memorii</td><td>2 buc.</td></tr>
Procesoare 1 buc.
</table>
72
Placi de
1 buc.
baza
Memorii 2 buc.
Legenda:
tr = Definește un rând într-o tabelă
td = Definește o celulă într-un tabel
th = Definește o celulă de tip antet de tabel
73
BIBLIOGRAFIE
1. SANDA POPESCU Primii pași în programare, Informatică pentru clasele V-IX, 2005
OANA DABELEA Limbajul Pascal
2. TUDOR SORIN Informatică

Manual pentru clasa a IX-a, Editura L&S INFOMAT, 2000
3. MARIANA MILOȘESCU Informatică

Manual pentru clasa a IX-a, Editura Didactică şi Pedagogică 2004
4. http://infopascupas.wordpress.com
5. http://pbinfo.ro
ISBN 978-973-0-19038-0
74

Magia Programării VI Cu ISBN Final

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Magia Programării VI Cu ISBN Final

Încărcat de

Drepturi de autor:

Formate disponibile

OANA DABELEA SANDA POPESCU

TIPURI STRUCTURATE DE DATE

Tablouri unidimesionale în limbajul C++

Ne propunem să realizăm programul la următoarea problemă: ”Se citeşte un şir de n numere

tip_dată nume_tablou [număr componente];

 tip_dată: precizează tipul elementelor(componentelor) din tabloul unidimensional;

tip_dată nume_tablou [număr componente]={listă de valori};

Exemplu de declaraţii corecte:

A[i] Un element (o componentă) a tabloului

Poziţia elementului în tabloul

Probleme rezolvate şi propuse spre rezolvare la orele de laborator:

1. Se consideră că avem un şir A de elemente numere întregi. Se cere să se realizeze un

2. Se consideră că avem un şir A de elemente numere întregi. Se cere să se realizeze un

4. Se citește un vector cu n elemente, numere naturale. Se cere să se realizeze un program

5. Se consideră un şir B de elemente numere întregi. Se cere să se realizeze un program care

Ex: Fie n=5 şi a=(23, 21, 7, 22, 49), atunci suma=7+49=56.

6. Se consideră un şir A de elemente numere întregi. Se cere să se realizeze un program care

7. Se consideră un şir A de elemente numere întregi. Se cere să se realizeze un program care

8. Se consideră un şir A de elemente numere întregi. Se cere să se realizeze un program care

9. Se consideră un şir A de elemente numere întregi. Se cere să se realizeze un program care

10. Se citește un vector cu n elemente, numere naturale. Să se realizezez un program care să

12. Se consideră un şir A, de n elemente numere întregi. Se cere să se realizeze un program să

14. Se dă un şir A cu n elemente numere întregi.Se cere să se realizeze un program care să

Rezolvarea problemei 14:

16. Se dă un şir A cu n elemente numere întregi. Să se calculeze şi să se afişeze media

17. Se dă un şir A cu n elemente numere întregi. Să se construiască şi să se afişeze un vector B

18. Se dă un şir A cu n elemente numere întregi şi două numere naturale x şi y. Să se realizeze

20. Se dă un şir A cu n elemente numere întregi. Să se realizeze un program care să

21. Se dă un şir A cu n elemente numere întregi. Să se realizeze un program care să

23. Se dă un şir A cu n elemente numere întregi. Să se realizeze un program care să calculeze şi

25. Se dă un şir A cu n elemente numere întregi. Să se realizeze un program care să calculeze şi

Rezolvarea problemei 25:

26. Se dă un şir A cu n elemente numere întregi. Să se realizeze un program care să calculeze şi

27. Se dă un şir A cu n elemente numere întregi. Să se realizeze un program care să calculeze şi

28. Se dă un şir A cu n elemente numere întregi. Să se realizeze un program care să calculeze şi

30. Se dă un şir A cu n elemente numere întregi. Să se realizeze un program care să verifice şi să

32. Se dă un şir A cu n elemente numere întregi. Să se realizeze un program care să verifice şi să

33. Se dă un şir A cu n elemente numere întregi. Să se realizeze un program care să verifice şi să

34. Se dă un şir A cu n elemente numere întregi. Să se realizeze un program care să verifice şi

35. Se dă un vector cu n elemente numere naturale. Să se verifice dacă toate elementele

37. Se dă un şir A cu n elemente numere întregi. Să se realizeze un program care să calculeze şi

38. Se dă un şir A cu n elemente numere întregi. Să se realizeze un program care să găsească şi

39. Se dă un şir A cu n elemente numere întregi. Să se realizeze un program care să găsească şi

Sortarea prin interschimbare directă

43. Se dă un şir A cu n elemente numere întregi. Se cere să se realizeze un program care să

#include <iostream> Comentarii:

Pentru exemplu nostru şirul transformărilor este:

44. Se dă un şir A cu n elemente numere întregi. Se cere să se realizeze un program care să

#include <iostream> Comentarii:

Pentru exemplu nostru şirul transformărilor este:

46. Se dă un şir A cu n elemente numere întregi. Se cere să se realizeze un program care să

47. Se dă un vector cu n elemente, numere naturale și un număr m unde n>m. Să se realizeze

48. Se dă un vector cu n elemente, numere naturale distincte.Să se realizeze un program care

54. Se citește un vector cu n elemente, numere naturale distincte. Să se afișeze elementele

Tablouri bidimesionale în limbajul C++

 a[2][3] - piesa de şah X se află pe linia 2 şi coloana 3;

Exemplu: un element al unui tablou bidimensional a, aflat pe linia i şi coloana j, se notează cu

indicele de linie indicele de coloană

Un tablou bidimesional în limbajul C++ se declară astfel:

 tip_dată: precizează tipul elementelor (componentelor) din tabloul bidimensional.

 elementele aflate pe diagonala principală a matricii pătratice sunt: a[0][0], a[1][1],

 elementele aflate pe diagonala secundară a matricii pătratice sunt: a[0][n-1], a[1][n-2],

2. Tipul elementelor din tabloul unidimesional poate fi oarecare;