Sunteți pe pagina 1din 26

Tablouri.

73

CAPITOLUL 5

TABLOURI

Tablouri unidimensionale

Tipurile structurate de date sunt combinaţii de alte tipuri definite prin descrierea
tipurilor componentelor şi prin indicarea unor metode de structurare. Datele structurate se
utilizează în cadrul aplicaţiilor care lucrează cu mai multe date şi pentru care declararea unor
variabile simple nu mai este suficientă.
Un tip structurat de date este tabloul, definit ca o structură care cuprinde un număr de
componente de acelaşi tip. Tipul componentelor se numeşte tipul de bază al tabloului.
Accesarea unei componente din cadrul tabloului se realizează prin intermediul unui indice.
Valorile indicilor identifică în mod unic componentele.
Observaţie: datorită acestei proprietăţi, o variabilă de tip tablou poate fi privită ca o
funcţie definită pe mulţimea valorilor tipului indicelui cu valori în mulţimea valorilor tipului
de bază al tabloului.
În cazul în care componentele unui tablou sunt structurate după valorile unui singur
indice tabloul se numeşte unidimensional, iar dacă ele sunt structurate după valorile mai
multor indici tabloul se numeşte multidimensional, fiecare indice definind o dimensiune.
Pentru a folosi o variabilă de tip tablou unidimensional acesta trebuie declarat înainte
de a fi utilizat.
Declaraţia unui tablou unidimensional este următoarea:
tip_bază nume_tablou[lim];
unde: tip_bază - este unul din tipurile de dată admise de C;
nume_tablou - este numele tabloului unidimensional;
lim - specifică numărul de elemente ale tabloului unidimensional(dimensiunea).
Exemplu: int a[15];
float b[20];
Tabloul a este format din 15 componente numere întregi; iar tabloul b este format din
20 de componente numere reale.
Referirea la elementul unui tablou unidimensional se realizează astfel:
- se precizează numele tabloului;
- în interiorul parantezelor drepte se precizează indicele corespunzător elementului.
Exemplu: a[5] reprezintă elementul de pe poziţia 6 din tabloul a;
b[0] reprezintă primul element din tabloul b;
b[19] reprezintă ultimul element din tabloul b.
Observaţie: numele unui tablou are ca valoare adresa primului său element.
Componentele tabloului sunt păstrate în memorie una după alta, în zone continue, în ordinea
crescătoare a valorilor indicelui.
Tablourile se pot iniţializa atunci când se declară. Un tabel unidimensional se poate
iniţializa cu următorul format:
tip_bază nume_tablou[n] = {e1,e2,…,en};
unde: e1, e2, …, en sunt expresii constante. Valorile expresiilor constante trebuie
cunoscute în momentul iniţializării tabloului unidimensional.
Observatie: - numărul expresiilor de iniţializat poate fi mai mic decât numărul
elementelor tabloului.
74 Tablouri.

- dacă toate elementele tabloului se iniţializează atunci n nu mai este necesar, iar
forma generală de iniţializare se transforma în:
tip_bază nume_tablou[ ] = {e1,e2,…,en};
Exemplu: int a[15] = {0,1,2,3,4,5,6,7,8,9};
char b[ ] = {”a”, ”b”,”c”,”d”);

Aplicaţia 1:
Se citeşte un şir de numere întregi de dimensiune n şi un numar întreg b. Să se
determine numărul de apariţii a lui b în şirul dat.
Specificarea problemei:
Date de intrare: n - dimensiunea şirului;
a[0], a[1],…..,a[n-1] - elementele şirului;
b - numărul căutat.
Date de ieşire: j - numărul de apariţii a lui b în şirul a.
Date de test: Dimensiunea sirului este = 5
a[0] = 3
a[1] = 5
a[2] = 7
a[3] = 3
a[4] = 6
b=3
Numărul de apariţii a valorii 3 in sir este: 2
Algoritmul problemei:
Algoritm căutare
citeşte n
pentru i ← 0 , n-1 execută
citeşte a[i]
sfârşit pentru
citeşte b
j← 0
pentru i ← 0, n-1 execută
dacă a[i]= b atunci j ← j +1
sfârşit dacă
sfârşit pentru
dacă j = 0 atunci scrie ”Numărul”, b, ”nu se regăseşte printre valorile şirului a”
altfel scrie ”Numărul de apariţii este”, j
sfârşit dacă
sfârşit algoritm
Programul corespunzător algoritmului este:
#include <stdio.h>
#include <conio.h>
void main ( )
{
int n, i, j, b, a[20];
clrscr ( );
printf ( ”Dimensiunea sirului este =”);
scanf ( ”%d ”, &n);
for (i = 0 ; i<n ; i++)
{ printf ( ”a[%d] = ”, i);
scanf ( ” %d ” , &a[i]); }
Tablouri. 75

printf ( ”b=”) ; scanf ( ”%d”, &b);


j = 0;
for (i=0; i<n;i++) if (a[i] = = b) j++;
if (j= = 0) printf (”\n Numarul %d nu se regaseste printre valorile sirului a”, b);
else printf (”\n Numarul de aparitii a valorii %d in sir este : %d” , b , j);
getch ( );
}
Analiza problemei:
În corpul funcţiei principale se declară variabilele cu următoarele semnificaţii:
n - reprezintă dimensiunea şirului;
i - reprezintă indicele folosit pentru accesarea elementelor din şir;
j - reprezintă numărul de apariţii a lui b în şir;
b - reprezintă numărul ce se va căuta în şir;
a - reprezintă şirul de numere întregi ce va putea avea maxim 20 de elemente.
Folosind funcţia standard scanf se vor citi: valoarea variabilei n, valorile elementelor
din şir şi valoarea lui b. Pentru citirea elementelor din şir se foloseşte structura repetitivă
reprezentată prin instrucţiunea for.
Variabila j în care se va reţine numărul de apariţii a lui b în şir se iniţializează cu
valoarea 0. Apoi, folosind structura repetitivă se parcurge şirul şi se compară fiecare element
cu numărul dat de variabila b. Dacă sunt egale atunci se incrementează valoarea variabilei j.
La final se compară valoarea variabilei j cu 0. Dacă este zero atunci numărul dat de
variabila b nu apare printre elementele şirului. Dacă j este diferit de 0 atunci numărul b se
regăseşte printre elementele şirului de j ori.

Aplicaţia 2:
Să se inverseze elementele unui şir de dimensiune cunoscută.
Specificarea problemei:
Date de intrare: n - dimensiunea şirului;
a[0], a[1], …, a[n-1] - elementele şirului.
Date de ieşire: a[n-1] ,a[n-2], …, a[0].
Date de test: Dimensiunea sirului = 6
a[0] = 3
a[1] = 6
a[2] = 1
a[3] = 5
a[4] = 9
a[5] = 8
Sirul inversat este: 8 9 5 1 6 3
Algoritmul problemei:
Algoritm inversare
citeşte n
pentru i ← 0, n-1 execută
citeşte a[i]
sfârşit pentru
pentru i ← 0, [n/2]-1 execută
aux ← a[i]
a[i] ← a[n-1-i]
a[n-1-i] ← aux
sfârşit pentru
76 Tablouri.

scrie ”Şirul inversat este: ”


pentru i←0, n-1 execută
srie a[i]
sfârşit pentru
sfârşit algoritm.
Programul corespunzător algoritmului este:
#include <stdio.h>
#include <conio.h>
void main( )
{
int n,i,aux,a[20];
clrscr ( ) ;
printf( ”Dimensiunea sirului=”) ;
scanf( ”%d”,&n) ;
for (i=0 ;i<n ;i++)
{ printf( ”a[%d]= ”,i) ;
scanf ( ”%d” ,& a[i]);
}
for (i=0;i<n/2;i++)
{
aux = a[i];
a[i]=a[n-1-i];
a[n-1-i]=aux;
}
printf( ”\n Sirul inversat este: \n”);
for (i=0;i<n;i++) printf( ”%4d”,a[i]);
getch( );
}
Analiza problemei:
Variabilele declarate în corpul funcţiei principale au urmatoarele semnificaţii:
n - reprezintă dimensiunea şirului;
i - reprezintă indicele folosit pentru accesarea elementelor din şir;
aux - variabilă auxiliară folosită pentru a interschimba elementele şirului;
a - reprezintă şirul de numere întregi ce va putea avea maxim 20 de elemente.
Pentru citirea dimensiunii şi elementelor din şir se foloseşte acelaşi procedeu ca şi în
problema anterioară. Folosind instructiunea for se accesează elementele din prima jumătate a
şirului şi se inversează cu cele din a doua jumătate prin intermediul variabilei aux. Se observă
că suma indicilor oricăror două elemente din şir ale căror valori se inversează este « n-1 ».
La final se afişează componentele şirului inversat prin intermediul instrucţiunii for.

Aplicaţia 3:
Se consideră un şir de dimensiune n. Să se construiască un nou şir format din
elementele distincte ale şirului iniţial.
Specificarea problemei:
Date de intrare: n - dimensiunea şirului;
a[0], a[1],…, a[n-1] - elementele şirului.
Date de ieşire: m - dimensiunea noului şir;
b[0], b[1], …, b[m-1] - elementele noului şir.
Date de test: Dimensiunea sirului = 8
a[0]=3
Tablouri. 77

a[1]=4
a[2]=7
a[3]=4
a[4]=9
a[5]=3
a[6]=11
a[7]=4
Sirul elementelor distincte:
3 4 7 9 11
Algoritmul problemei:
Algoritm distincte
citeşte n
pentru i←0, n-1 execută
citeşte a[i]
sfârşit pentru
m←0
b[0]←a[0]
pentru i←1, n-1 execută
j←0
cod←1
repetă
dacă b[j]=a[i] atunci cod←0
altfel j←j+1
sfârşit dacă
până când (j>m sau cod=0) ; sfârşit repetă
dacă cod=1 atunci m←m+1
b[m]←a[i]
sfârşit dacă
sfârşit pentru
m←m+1
pentru i←0, m-1 execută
Scrie b[i]
sfârşit pentru
sfarşit algoritm.
Programul corespunzător algoritmului este:
# include <stdio.h>
# include <conio.h>
void main ( )
{
int n, m,i,j,cod;
int a[30],b[30];
clrscr( );
printf( ”Dimensiunea sirului=”);
scanf( ”%”, &n);
for (i=0;i<n;i++)
{ printf( ”a[%d]= ”, i);
scanf ( ”%d ”, &a[i]);
}
m=0;
b[0]=a[0];
78 Tablouri.

for (i=1;i<n;i++)
{ j=0;
cod=1;
do
if (b[j]==a[i]) cod=0;
else j++;
while (j<=m && cod);
if (cod) { m++;
b[m]=a[i];
}
}
m++;
printf( ”\nSirul elementelor distincte :\n”);
for (i=0;i<m;i++) printf( ”%4d ”, b[i]);
getch( );
}
Analiza problemei:
În corpul funcţiei principale se declară variabile cu următoarea semnificaţie:
n - reprezintă dimensiunea şirului;
m - reprezintă dimensiunea noului şir;
i ,j - reprezintă indici folosiţi pentru accesarea elementelor din şiruri;
cod - variabilă logică folosită pentru a determina dacă elementul a[i] din şirul iniţial se
găseşte în noul şir;
a - reprezintă şirul de numere întregi ce va avea maxim 30 de elemente;
b - reprezintă şirul elementelor distincte.
După citirea valorilor datelor de intrare se iniţializează variabila m cu valoarea zero
şi primul element din şirul b va primi valoarea primului element din şirul a. Folosind
instrucţiunea « for » se va parcurge şirul a începând cu al doilea element. Prin intermediul
variabilei cod se presupune că elementul a[i] nu se găseşte în şirul b. Apoi se parcurge şirul b ,
comparând fiecare element al său cu elementul a[i]. Dacă elementul a[i] se găseşte printre
componentele şirului b atunci vatiabila cod primeşte valoarea zero şi se va trece la următorul
element din şirul a. Dacă elementul a[i] nu a fost egal cu nici un element din şirul b atunci
variabila cod îşi păstează valoarea zero. În acest caz se adaugă valoarea a[i] în şirul b.
În final se afişează elementele şirului b.

Aplicaţia 4:
Se consideră un şir de numere întregi de dimensiune n. Să se adauge în şir pe poziţia
k<n elementul a cărui valoare este dată de suma elementelor şirului.
Specificarea problemei:
Date de intrare: n - dimensiunea şirului;
a[0], a[1], …, a[n] - elementele şirului;
k - poziţia unde se adaugă noul element.
Date de iesire: n+1 - dimensiunea şirului;
a[0], a[1], …a[k-2],s, a[k-1], …a[n-1].
Date de test: Dimensiunea sirului: 5
a[0]=3
a[1]=-4
a[2]=7
a[3]=1
a[4]=0
Tablouri. 79

k=3
Noul sir este:
3 -4 7 7 1 0
Algoritmul problemei:
Algoritm adăugare
citeşte n
s←0
pentru i←0, n-1 execută
citeşte a[i]
s←s+ a[i]
sfârşit pentru
citeşte k
pentru i←n-1,k-1,-1 execută
a[i+1]←a[i]
sfârşit pentru
a[k-1]←s
n←n+1
scrie “Noul sir este : “
pentru i←0, n-1 execută
scrie a[i]
sfârşit pentru
sfârşit algoritm.
Programul corespunzător algoritmului este:
#include <conio.h>
#include <stdio.h>
void main( )
{ int n,i,k,a[30];
clrscr( );
printf(”n =”); scanf(”%d”, &n);
s=0;
for (i=0 ;i<n ;i++)
{ printf (”a[%d]= ”, i);
scanf (”%d”, &a[i]);
s+=a[i];
}
printf(”k=”); scanf(”%d”, &k);
for (i=n-1;i>=k-1;i--) a[i+1] = a[i];
a[k-1]=s;
n++;
printf(”\n Noul sir este: \n ”);
for(i=0 ;i<n ;i++) printf(”%4d”, a[i]);
getch( );
}
Analiza problemei:
În corpul funcţiei principale se declară variabile cu următoarea semnificaţie:
n - reprezintă dimensiunea şirului;
i - reprezintă indicele folosit pentru accesarea elementelor din şir;
k - reprezintă poziţia unde se adaugă noul element în şir;
s - reprezintă suma celor “n”elemente ale şirului;
a - reprezintă şirul de numere întregi ce va avea maxim 30 de elemente.
80 Tablouri.

După citirea valorilor datelor de intrare se iniţializează variabila s cu valoarea zero.


Se parcurge întreg şirul, adaugând valoarea fiecarui element din şir în variabila s. Începând de
la ultimul element din şir până la cel de pe poziţia k-1 se decalează componentele şirului cu o
poziţie spre dreapta
Elementului de pe pozitia k-1 i se atribuie valoarea variabilei s şi se modifică
dimensiunea şirului.
În final se afişează elementele şirului.

Aplicaţia 5:
Să se ordoneze crescător un şir de numere reale de dimensiune dată.
Specificarea problemei:
Date de intrare: n - dimensiunea şirului;
a[0], a[1], …, a[n-1] - elementele şirului.
Date de iesire: a[0], a[1]…, a[n-1].
Date de test: Dimensiunea sirului = 6
a[0]=40
a[1]=60
a[2]=21
a[3]=34
a[4]=70
a[5]=55
Sirul ordonat este:
21 34 40 55 60 70
Algoritmul problemei:
Algoritm ordonare
citeşte n
pentru i←0, n-1 execută
citeşte a[i]
sfârsit pentru
pentru i←0, n-2 execută
min ←a[i]
k← i
pentru j←i+1,n-1 execută
dacă (a[j]<min) atunci min←a[j]
k←j
sfârşit dacă
sfârşit pentru
dacă (k< >i) atunci a[k]←a[i]
a[i]←min
sfârşit dacă
sfârşit pentru
scrie "Sirul ordonat este:"
pentru i←0, n-1 execută
scrie a[i]
sfârşit pentru
sfârşit algoritm.
Programul corespunzător algoritmului este:
#include <stdio.h>
#include <conio.h>
void main ( )
Tablouri. 81

{ int n,i,j,k;
float min,a[30];
clrscr( );
printf( ”Dimensiunea sirului: ”);
scanf(”%d”, &n);
for (i=0 ;i<n ;i++)
{ printf(”a[%d]= ”, i) ;
scanf(”%f”, &a[i]);
}
for (i=0;i<n-1;i++)
{ min=a[i];
k=i;
for (j=i+1;j<n;j++)
if (a[j]<min) { min=a[j];
k=j;
}
if (k!=i) { a [k]=a[i];
a [i]=min;
}
}
printf(”\n Sirul ordonat este:\n”);
for (i=0;i<n;i++) printf(”%6.1f”, a[i];
getch( );
}
Analiza problemei:
În corpul funcţiei principale se declară variabile cu următoarea semnificaţie:
n - reprezintă dimensiunea şirului;
i, j - reprezintă indicii folosiţi pentru accesarea elementelor din şir;
min - variabilă folosită pentru a reţine valoarea minimă a unui subşir din şirul dat;
k - precizează indicele elementului din şir ce are aceeaşi valoare cu variabila ”min”;
a - reprezintă şirul de numere reale ce poate avea maxim 30 de elemente.
După declararea variabilelor, se citesc valorile datelor de intrare. Pentru fiecare valoare a
variabilei i cuprinsă între 0 şi n-2 se va calcula valoarea minimă a subşirului determinat de
elementul de indice i şi de ultimul element al şirului. Valoarea minimă se va reţine în variabila
min iar indicele elementului din subşir care are valoarea minimă se va reţine în variabila k. Iniţial
valoarea minimă este egală cu valoarea elementului a[i], iar k primeşte valoarea i. Se vor
parcurge toate elementele din şir de la indicele i+1 până la ultimul element. Dacă se găseşte un
element care are valoarea mai mică decât valoarea variabilei min atunci se modifică valorile
variabilelor min şi k astfel: variabila min primeşte valoarea elementului respectiv din şir, iar
variabila k primeşte valoarea indicelui elementului respectiv din şir. După ce s-a comparat
variabila min cu toate elementele subşirului se verifică dacă indicele valorii minime este sau nu
diferit de valoarea lui i. Dacă sunt egale atunci valoarea minimă se găseste pe poziţia de indice i.
Dacă nu sunt egale atunci se modifică şirul astfel : elementul de indice k primeşte valoarea
elementului de indice i, iar elementul de indice i primeşte valoarea variabilei min.
În final se afişează elementele şirului ordonat.
În cazul datelor de test ordonarea crescătoare a elementelor din şir se realizează astfel :
82 Tablouri.

i a={40,60,21,34,70,55} min k
0 21 60 40 34 70 55 21 2
1 21 34 40 60 70 55 34 3
2 21 34 40 60 70 55 40 2
3 21 34 40 55 70 60 55 5
4 21 34 40 55 60 70 60 5

Aplicaţia 6:
Să se interclaseze două şiruri de lungimi diferite, date crescător.
Specificarea problemei:
Date de intrare: n - dimensiunea primului şir;
a[0], a[1], …, a[n-1] - elementele primului şir;
m - dimensiunea şirului al doilea;
b[0], b[1], …b[m-1] - elementele şirului al doilea.
Date de iesire: p - dimensiunea şirului;
c[0], c[1], …, c[p-1] - elementele şirului.
Date de test: Dimensiunea primului sir = 6
a[0] = -2
a[1] = 0
a[2] = 3
a[3] = 7
a[4] = 11
a[5] = 18
Dimensiunea sirului al doilea = 4
b[0] = 1
b[1] = 3
b[2] = 8
b[3] = 13
Sirul obtinut prin interclasare:
-2 0 1 3 3 7 8 11 13 18
Algoritmul problemei:
Algoritm interclasare
citeşte n
pentru i ← 0, n-1 execută
citeşte a[i]
sfârşit pentru
citeşte m
pentru i ← 0, m-1 execută
citeste b[i]
sfârşit pentru
i ← 0; j ← 0; k ← 0
cât timp (i< n si j < m) execută
dacă a[i] < b[j] atunci c[k] ← a[i]
i ← i +1
altfel c[k] ← b[j]
j←j+1
sfârşit dacă
k ← k +1
Tablouri. 83
sfârşit cât timp

cât timp (i<n) execută


c[k] ← a[i]
k ← k +1
i ← i +1
sfârşit cât timp
cât timp (j<m) execută
c[k] ← b[j]
k ← k +1
j ← j +1
sfârşit cât timp
p←k
scrie “Şirul obţinut după interclasare”
pentru i ← 0, p-1 execută
scrie c[i]
sfârşit pentru
sfârşit algoritm
Programul corespunzător algoritmului este:
#include <stdio.h>
#include <conio.h>
void main()
{ int n,m,p,i,j,k,a[20],b[20],c[40];
clrscr( );
printf( ”Dimensiunea primului sir = ”);
scanf( ”%d ”, &n) ;
for (i=0 ; i < n ; i++) ;
{ printf ( ”a[%d] = ”, i);
scanf ( ”%d”, &a[i]);
}
printf(”Dimensiunea sirului al doilea =”);
scanf(”%d ”, &m) ;
for (i = 0 ; i <m ; i++) ;
{ printf( ”b[%d]=’’, i);
scanf( ”%d”, &b[i]);
}
i=0;j=0;k=0;
while(i<n && j<m)
{ if (a[i]<b[j]) { c[k]=a[i];
i++;
}
else { c[k]=b[j];
j++;
}
k++;
}
while(i<n) c[k++]=a[i++];
while(j<m) c[k++]=b[j++];
p=k;
printf( ”\n Sirul obtinut prin interclasare\n”);
for (k=0;k<p;k++) printf (”%4d”, c[k]);
84 Tablouri.
getch ( ); }

Analiza problemei:
În corpul funcţiei principale se declară variabile cu următoarea semnificaţie:
n, m, p - dimensiunile celor 3 şiruri;
i, j, k - reprezintă indici folosiţi pentru accesarea elementelor din şiruri;
a, b, c - reprezintă şiruri de numere întregi.
După declararea variabilelor se citesc dimensiunile şi elementele celor două şiruri.
Se urmăreşte construirea şirului c obţinut prin interclasarea celor doua şiruri a şi b. Se
iniţializează cele 3 variabile folosite pentru accesarea elementelor şirurilor cu valoarea zero.
Cât timp mai există elemente în ambele şiruri se compara cele 2 elemente şi se adaugă
elementul cel mai mic în şirul c. În şirul din care face parte valoarea mai mică se trece la
elementul următor. Se modifică şi valoarea variabilei k pentru a putea adăuga un alt element
în şirul c.
Dacă în primul şir mai există elemente dar în şirul al doilea nu mai există elemente
atunci se vor adăuga în şirul c elementele rămase din primul şir.
Dacă în primul şir nu mai există elemente dar în şirul al doilea mai există elemente
atunci se vor adăuga în şirul c elementele rămase în şirul al doilea.
La final se afişează cele p elemente ale şirului obţinut prin interclasare.
În cazul datelor de test interclasarea elementelor din cele două şiruri se realizează
astfel , unde a={-2, 0, 3, 7, 11, 18} şi b={1, 3, 8, 13}:

i a[i] j b[j] k c[k] c


0 -2 0 1 0 -2 -2
1 0 0 1 1 0 -2 0
2 3 0 1 2 1 -2 0 1
2 3 1 3 3 3 -2 0 1 3
2 3 2 8 4 3 -2 0 1 3 3
3 7 2 8 5 7 -2 0 1 3 3 7
4 11 2 8 6 8 -2 0 1 3 3 7 8
4 11 3 13 7 11 -2 0 1 3 3 7 8 11
5 18 3 13 8 13 -2 0 1 3 3 7 8 11 13
5 18 4 - 9 18 -2 0 1 3 3 7 8 11 13 18

Tablouri bidimensionale

Dacă componentele unui tablou sunt structurate după valorile a doi indici atunci
tabloul se numeşte bidimensional, fiecare indice definind o dimensiune.
Pentru a folosi o variabilă de tip tablou bidimensional acesta trebuie declarat înainte
de a fi utilizat.
Declaraţia unui tablou bidimensional este următoarea:
tip_bază nume_tablou [lim1][lim2];
unde: tip_bază - este unul din tipurile de dată admise de C;
nume_tablou - este numele tabloului bidimensional;
lim1, lim2 - specifică numărul de elemente ale tabloului bidimensional (dimensiunea).
Exemplu: int a[10][20];
float b[20][35];
Tabloul a este format din 10 linii şi 20 de coloane, având 200 de componente
numere întregi. Tabloul b este format din 20 de linii şi 35 de coloane, având 700 de
componente numere reale.
Tablouri. 85

Referirea la elementele unui tablou bidimensional se realizează astfel:


- se precizează numele tabloului;
- în interiorul parantezelor drepte se precizează indicele corespunzător liniei;
- în interiorul parantezelor drepte se precizează indicele corespunzător coloanei;
Exemplu: a[2][4] - reprezintă elementul de pe linia 3 şi coloana 5 din matrice;
b[0][0] - reprezintă primul element al matricei.
Observaţie: Numele unui tablou bidimensional are ca valoare adresa primului
său element. Componentele tabloului sunt păstrate în memorie una după alta, în zone
contigue, în ordinea crescătoare a valorilor indicilor.
Tablourile se pot iniţializa atunci când se declară. Un tablou bidimensional se poate
iniţializa cu următorul format:
tip_bază nume_tablou [n][m]={ {e11, e12, …,e1m},
{e21, e22, …,e2m},
……………….
{en1, en2, …,enm},
};
unde: e11, e12, …, enm sunt expresii constante. Valorile expresiilor constante trebuie cunoscute
în momentul iniţializării tabloului bidimensional.
Observaţii: - numărul expresiilor poate fi mai mic decât „m” în oricare din
acoladele corespunzătoare celor „n” linii ale tabloului bidimensional.
- în cazul tablourilor bidimensionale se poate omite doar numărul
liniilor din tablou, numărul coloanelor fiind obligatoriu.
Exemplu: int m[][4]= { {2,7,1}, {3, 9 } };
Tabloul „m” are 2 linii şi 4 coloane; doar 5 elemente sunt iniţializate.
- valorile neiniţializate au o valoare imprevizibilă. Dacă tabloul este
declarat static sau global atunci componentele neiniţializate se iniţializează automat cu
valoarea zero.

Aplicaţia 1:
Să se construiască o matrice pătrată de ordin „n” astfel:
- valoarea elementelor de pe diagonala secundară este egală cu coloana pe care se
găseşte elementul respectiv;
- valoarea elementelor aflate deasupra diagonalei secundare este egală cu suma
dintre linia şi coloana pe care se găseşte elementul respectiv;
- valoarea elementelor aflate sub diagonala secundară este egală cu produsul dintre
linia şi coloana pe care se găseşte elementul respectiv.
Specificarea problemei:
Date de intrare: n - ordinul matricei.
Date de ieşire: m[i][j] , ∀i,j ∈ {0,1,…,n-1}.
Date de test: Ordinul matricei=4
Matricea este:
2 3 4 4
3 4 3 8
4 2 9 12
1 8 12 16
Algoritmul probleme:
Algoritm matrice
citeşte n
pentru i ← 0,n-1 execută
86 Tablouri.
pentru j ← 0,n-1 execută

dacă i+j=n-1 atunci m[i][j] ← j+1


altfel dacă i+j<n-1 atunci m[i][j] ← (i+1)+(j+1)
altfel m[i][j] ← ( i+1)* (j+1)
sfârşit dacă
sfârşit dacă
scrie m[i][j]
sfârşit pentru
sfârşit pentru
sfârşit algoritm.
Programul corespunzător algoritmului este:
#include <stdio.h>
#include <conio.h>
void main()
{ unsigned m[20][20];
unsigned n,i,j;
printf("\nOrdinul matricei =");scanf("%u",&n);
printf("Matricea este\n");
for (i=0;i<n;i++)
{ for (j=0;j<n;j++)
{ if (i+j==n-1) m[i][j]=j+1;
else if (i+j<n-1) m[i][j]=(i+1)+(j+1);
else m[i][j]=(i+1)*(j+1);
printf("%3u",m[i][j]);
}
printf("\n");
}
getch();
}
Analiza problemei:
În corpul funcţiei principale se declară variabile cu următoarea semnificaţie:
n - reprezintă ordinul matricei;
i, j - reprezintă indici folosiţi pentru accesarea elementelor din matrice;
m - reprezintă tabloul bidimensional de numere naturale ce va putea avea maxim
400 de elemente.
Folosind funcţia standard scanf se va citi ordinul matricei. În cadrul a două structuri
repetitive cu număr fixat de paşi se determină elementele matricei astfel:
- dacă elementul se află pe diagonala secundară, adică suma dintre indicele referitor
la linie şi cel referitor la coloană este egală cu ordinul matricei minus 1, atunci valoarea
elementului este egală cu coloana pe care se găseşte;
- dacă elementul se găseşte deasupra diagonalei secundare, adică suma dintre
indicele referitor la linie şi cel referitor la coloană este strict mai mică decât ordinul matricei
minus 1, atunci valoarea elementului este egală cu suma dintre linia şi coloana pe care se
găseşte;
- dacă elementul se găseşte sub diagonala secundară, adică suma dintre indicele
referitor la linie şi cel referitor la coloană este strict mai mare decât ordinul matricei minus
1, atunci valoarea elementului este egală cu produsul dintre linia şi coloana pe care se
găseşte.
După determinarea fiecărui element din tablou, acesta se afişează folosind funcţia
printf.
Tablouri. 87

Aplicaţia 2:
Se cunosc elementele numere reale ale unei matrici pătrate. Să se determine:
- produsul elementelor de pe diagonala principală;
- suma elementelor de pe diagonala secundară;
- valoarea maximă situată deasupra diagonalei principale;
- valoarea minimă situată sub diagonala secundară.
Specificarea problemei:
Date de intrare: n - ordinul matricei;
m[i][j]; ∀i,j ∈ {0,1,…,n-1}.
Date de ieşire: p - produsul elementelor de pe diagonala principală;
s - suma elementelor de pe diagonala secundară;
max - valoarea maximă situată deasupra diagonalei principale;
min - valoarea minimă situată sub diagonala secundară.
Date de test: n=3
m[0][0]=1
m[0][1]=2
m[0][2]=3
m[1][0]=2
m[1][1]=4
m[1][2]=6
m[2][0]=1
m[2][1]=3
m[2][2]=5
Matricea este:
1.0 2.0 3.0
2.0 4.0 6.0
1.0 3.0 5.0
Produsul elementelor de pe diagonala principala : 20.000
Suma elementelor de pe diagonala secundara : 8.000
Valoarea maximă aflata deasupra diagonalei principale: 2.000
Valoarea minimă aflata sub diagonala secundara: 3.000
Algoritmul problemei:
Algoritm matrice
citeşte n
pentru i ← 0,n-1 execută
pentru j ← 0,n-1 execută
citeşte m[i][j]
sfârşit pentru
sfârşit pentru
scrie "Matricea este:"
pentru i ← 0,n-1 execută
pentru j ← 0,n-1 execută
scrie m[i][j]
sfârşit pentru
sfârşit pentru
p ← 1;s ← 0
pentru i ← 0,n-1 execută
p ← p*m[i][i]
s ← s+m[i][n-1-i]
88 Tablouri.

sfârşit pentru
scrie "Produsul elementelor de pe diagonala principala : ",p
scrie "Suma elementelor de pe diagonala secundara : ",s
max ← m[0][1]
pentru i ← 0,n-2 execută
pentru j ← i+1,n-1 execută
dacă (m[i][j]>max) atunci max ← m[i][j]
sfârşit dacă
sfârşit pentru
sfârşit pentru
scrie "Valoarea maxima aflată deasupra diagonalei principale:",max
min ← m[1][n-1]
pentru i ← 2,n-1 execută
pentru j ← n-i,n-1 execută
dacă (m[i][j]<min) atunci min ← m[i][j]
sfârşit dacă
sfârşit pentru
sfârşit pentru
scrie "Valoarea minima aflată sub diagonala secundara:",min
sfârşit algoritm
Programul corespunzător algoritmului este:
#include <stdio.h>
#include <conio.h>
void main()
{ float m[20][20],p,s,max,min;
unsigned n,i,j;
printf("\nn=");scanf("%u",&n);
for (i=0;i<n;i++)
for (j=0;j<n;j++)
{ printf("m[%u][%u]=",i,j);
scanf("%f",&m[i][j]);
}
printf("Matricea este:\n");
for (i=0;i<n;i++)
{ for (j=0;j<n;j++) printf("%6.1f",m[i][j]);
printf("\n");
}
p=1;s=0;
for (i=0;i<n;i++) { p*=m[i][i];
s+=m[i][n-1-i];
}
printf ("\nProdusul elementelor de pe diagonala principala : %.3f",p);
printf ("\nSuma elementelor de pe diagonala secundara : %.3f",s);
max=m[0][1];
for (i=0;i<n-1;i++)
for (j=i+1;j<n;j++)
if (m[i][j]>max) max=m[i][j];
printf ("\n Valoarea maxima aflata deasupra diagonalei principale: %.3f",max);
min=m[1][n-1];
Tablouri. 89

for (i=2;i<n;i++)
for (j=n-i;j<n;j++)
if (m[i][j]<min) min=m[i][j];
printf ("\n Valoarea minima aflata sub diagonala secundara: %.3f",min);
getch();
}
Analiza problemei:
În corpul funcţiei principale se declară variabile cu următoarea semnificaţie:
n - reprezintă ordinul matricei;
i, j - reprezintă indici folosiţi pentru accesarea elementelor din matrice;
m - reprezintă tabloul bidimensional de numere reale ce va putea avea maxim 400
de elemente;
p - reprezintă produsul elementelor de pe diagonala principală;
s - reprezintă suma elementelor de pe diagonala secundară;
max - reprezintă valoarea maximă situată deasupra diagonalei principale;
min - reprezintă valoarea minimă situată sub diagonala secundară.
Folosind funcţia standard scanf se va citi ordinul matricei. În cadrul a două structuri
repetitive cu număr fixat de paşi se citesc elementele matricei, apoi se afişează elementele
tabloului bidimensional.
Pentru determinarea produsului şi sumei se iniţializează variabila p cu valoarea unu
şi variabila s cu valoarea zero. În cadrul unei structuri repetitive cu număr fixat de paşi se
modifică valorile celor două variabile astfel:
- valoarea variabilei p se înmulţeşte cu valoarea elementului curent de pe
diagonala principală; valoarea obţinută se va atribui variabilei p;
- valoarea variabilei s se adună cu valoarea elementului curent de pe diagonala
secundară; valoarea obţinută se va atribui variabilei s.
După ieşirea din structura repetitivă se vor afişa valorile celor două variabile,
corespunzătoare produsului elementelor de pe diagonala principală şi sumei elementelor de
pe diagonala secundară.
Pentru determinarea valorii maxime situate deasupra diagonalei principale se
utilizează următorul procedeu:
- se iniţializează variabila max cu valoarea elementului de pe linia 1 şi coloana 2;
- în cadrul a două structuri repetitive cu număr fixat de paşi se parcurg toate
elementele matricei situate deasupra diagonalei principale. Se compară valoarea elementului
curent cu valoarea variabilei max; dacă se găseşte o valoare mai mare decât cea a variabilei
max atunci această variabilă primeşte valoarea elementului curent.
După ieşirea din structura repetitivă se va afişa valoarea variabilei max.
Pentru determinarea valorii minime situate sub diagonala secundară se utilizează
următorul procedeu:
- se iniţializează variabila min cu valoarea elementului de pe linia a doua şi ultima
coloană;
- în cadrul a două structuri repetitive cu număr fixat de paşi se parcurg toate
elementele matricei situate sub diagonala secundară. Se compară valoarea elementului
curent cu valoarea variabilei min; dacă se găseşte o valoare mai mică decât cea a variabilei
min atunci această variabilă primeşte valoarea elementului curent.
După ieşirea din structura repetitivă se va afişa valoarea variabilei min.
90 Tablouri.

Aplicaţia 3:
Să se verifice dacă o matrice pătrată este simetrică.
Specificarea problemei:
Date de intrare: n - ordinul matricei;
m[i][j]; ∀i,j ∈ {0,1,…,n-1}.
Date de ieşire: simetric.
Date de test: n=3
m[0][0]=1
m[0][1]=2
m[0][2]=4
m[1][0]=2
m[1][1]=3
m[1][2]=5
m[2][0]=4
m[2][1]=5
m[2][2]=6
Matricea este:
1 2 4
2 3 5
4 5 6
Matricea este simetrică
Algoritmul problemei:
Algoritm matrice_simetrică
citeşte n
pentru i ← 0,n-1 execută
pentru j ← 0,n-1 execută
citeşte m[i][j]
sfârşit pentru
sfârşit pentru
scrie "Matricea este: "
pentru i ← 0,n-1 execută
pentru j ← 0,n-1 execută
scrie m[i][j]
sfârşit pentru
sfârşit pentru
simetric ← 1
i←1
cât timp ((i<n) şi (simetric=1)) execută
j←0
cât timp ((j<i) şi (simetric=1)) execută
dacă m[i][j] ≠ m[j][i] atunci simetric ← 0
sfârşit dacă
j ← j+1
sfârşit cât timp
i ← i+1
sfârşit cât timp
dacă (simetric=1) atunci scrie "Matricea este simetrică"
altfel scrie "Matricea nu este simetrică"
sfârşit dacă
Tablouri. 91

sfârşit algoritm
Programul corespunzător algoritmului este:
#include<conio.h>
#include <stdio.h>
void main()
{ float m[20][20];
unsigned n,i,j;
int simetric;
printf("\nn=");scanf("%u",&n);
for (i=0;i<n;i++)
for (j=0;j<n;j++)
{ printf("m[%u][%u]=",i,j);
scanf("%f",&m[i][j]);
}
printf("\n Matricea este:\n");
for (i=0;i<n;i++)
{ for (j=0;j<n;j++) printf("%6.1f",m[i][j]);
printf("\n");}
simetric=1;i=1;
while ((i<n) && (simetric))
{ j=0;
while ((j<i) && (simetric))
{ if (m[i][j]!=m[j][i]) simetric=0;
j++;
}
i++;
}
if (simetric) printf("\n Matricea este simetrica");
else printf("\n Matricea nu este simetrica");
getch(); }
Analiza problemei:
În corpul funcţiei principale se declară variabile cu următoarea semnificaţie:
n - reprezintă ordinul matricei;
i, j - reprezintă indici folosiţi pentru accesarea elementelor din matrice;
m - reprezintă tabloul bidimensional de numere reale ce va putea avea maxim 400
de elemente;
simetric - reprezintă o variabilă de tip întreg ce poate avea doar două valori: 0 sau 1
şi care ne precizează dacă matricea este sau nu simetrică; în final dacă variabila are valoarea
unu atunci matricea este simetrică, altfel matricea nu este simetrică.
Folosind funcţia standard scanf se va citi ordinul matricei. În cadrul a două structuri
repetitive cu număr fixat de paşi se citesc elementele matricei, apoi se afişează elementele
tabloului bidimensional.
Presupunem că matricea este simetrică; în acest caz variabilei simetric i se atribuie
valoarea 1. Folosind două instrucţiuni repetitive cu test iniţial se accesează elementele
matricei situate sub diagonala principală. Dacă elementul accesat situat pe linia i şi coloana j
este diferit de elementul de pe linia j şi coloana i atunci s-a găsit o pereche de elemente din
matrice care nu îndeplineşte condiţia; deci matricea nu este simetrică. În acest caz variabila
simetric primeşte valoarea 0 şi se iese din structura repetitivă.
92 Tablouri.

În final se verifică valoarea variabilei simetric. Dacă valoarea este 1 atunci se


afişează mesajul: ”Matricea este simetrică”; dacă valoarea este 0 atunci se afişează mesajul:
„Matricea nu este simetrică”.

Aplicaţia 4:
Să se determine matricea transpusă.
Specificarea problemei:
Date de intrare: n - numărul liniilor matricei;
m - numărul coloanelor tabloului;
a[i][j]; ∀i ∈ {0,1,…,n-1}, ∀j ∈ {0,1,…,m-1}.
Date de ieşire: t[i][j]; ∀i ∈ {0,1,…,m-1}, ∀j ∈ {0,1,…,n-1}.
Date de test: Nr. linii=3
Nr. coloane=2
a[0][0]=1
a[0][1]=2
a[1][0]=2
a[1][1]=3
a[2][0]=4
a[2][1]=7
Matricea este:
1.0 2.0
2.0 3.0
4.0 7.0
Matricea transpusă este:
1.0 2.0 4.0
2.0 3.0 7.0
Algoritmul problemei:
Algoritm matrice_transpusă
citeşte n, m
pentru i ← 0, n-1 execută
pentru j ← 0, m-1 execută
citeşte a[i][j]
t[j][i] ← a[i][j]
sfârşit pentru
sfârşit pentru
scrie "Matricea este: "
pentru i ← 0,n-1 execută
pentru j ← 0,m-1 execută
scrie a[i][j]
sfârşit pentru
sfârşit pentru
scrie "Matricea transpusă este: "
pentru i ← 0,m-1 execută
pentru j ← 0,n-1 execută
scrie t[i][j]
sfârşit pentru
sfârşit pentru
sfârşit algoritm
Tablouri. 93

Programul corespunzător algoritmului este:


#include<conio.h>
#include <stdio.h>
void main()
{ float a[20][20], t[20][20];
unsigned n,m,i,j;
printf("\nNr. linii=");scanf("%u",&n);
printf("\nNr. coloane=");scanf("%u",&m);
for (i=0;i<n;i++)
for (j=0;j<m;j++)
{ printf("a[%u][%u]=",i,j);
scanf("%f",&a[i][j]);
t[j][i]=a[i][j];
}
printf("\n Matricea este:\n");
for (i=0;i<n;i++)
{ for (j=0;j<m;j++) printf("%6.1f",a[i][j]);
printf("\n");
}
printf("\n Matricea transpusa este:\n");
for (i=0;i<m;i++)
{ for (j=0;j<n;j++) printf("%6.1f",t[i][j]);
printf("\n");
}
getch();}
Analiza problemei:
În corpul funcţiei principale se declară variabile cu următoarea semnificaţie:
n - reprezintă numărul de linii din matrice;
m - reprezintă numărul de coloane din matrice;
i, j - reprezintă indici folosiţi pentru accesarea elementelor din matrice;
a, t - reprezintă tablouri bidimensionale de numere reale ce vor putea avea maxim
400 de elemente.
Folosind funcţia standard scanf se vor citi: numărul de linii din matrice şi numărul
de coloane din matrice. În cadrul a două instrucţiuni repetitive cu număr fixat de paşi se
citesc elementele matricei a şi se construieşte matricea transpusă astfel: elementul de pe
linia j şi coloana i din matricea transpusă t coincide cu elementul de pe linia i şi coloana j
din matricea dată a.
În cadrul a două instrucţiuni repetitive cu număr fixat de paşi se afişează elementele
tabloului bidimensional a, apoi elementele matricei transpuse t.

Aplicaţia 5:
Să se calculeze matricea produs a două matrici date.
Specificarea problemei:
Date de intrare: m - numărul liniilor primei matrici;
n - numărul coloanelor primei matrici şi numărul liniilor matricei a
doua;
p - numărul coloanelor matricei a doua;
a[i][j] ; ∀i ∈ {0,1,…,m-1}, ∀j ∈ {0,1,…,n-1};
b[i][j] ; ∀i ∈ {0,1,…,n-1}, ∀j ∈ {0,1,…,p-1}.
Date de ieşire: c[i][j]; ∀i ∈ {0,1,…,m-1} , ∀j ∈ {0,1,…,p-1}.
94 Tablouri.

Date de test: Prima matrice:


Nr. linii=3
Nr. coloane=2
a[0][0]=1
a[0][1]=2
a[1][0]=0
a[1][1]=3
a[2][0]=4
a[2][1]=1
A doua matrice:
Nr. linii=2
Nr. coloane=4
b[0][0]=1
b[0][1]=0
b[0][2]=2
b[0][3]=0
b[1][0]=3
b[1][1]=1
b[1][2]=-1
b[1][3]=0
Matricea produs este:
7.0 2.0 0.0 0.0
9.0 3.0 -3.0 0.0
7.0 1.0 7.0 0.0
Algoritmul problemei:
Algoritmul matrice_produs
citeşte m,n
pentru i ← 0,m-1 execută
pentru j ← 0,n-1 execută
citeşte a[i][j]
sfârşit pentru
sfârşit pentru
citeşte p
pentru i ← 0,n-1 execută
pentru j ← 0,p-1 execută
citeşte b[i][j]
sfârşit pentru
sfârşit pentru
scrie "Matricea produs este"
pentru i ← 0,m-1 execută
pentru j ← 0,p-1 execută
c[i][j] ← 0
pentru k ← 0,n-1 execută c[i][j] ← c[i][j]+a[i][k]*b[k][j]
sfârşit pentru
scrie c[i][j]
sfârşit pentru
sfârşit pentru
sfârşit algoritm
Tablouri. 95

Programul corespunzător algoritmului este:


#include <stdio.h>
#include <conio.h>
void main()
{ float a[20][20], b[20][20];
float c[20][20];
unsigned m,n,p,i,j,k;
printf("\nPrima matrice:");
printf("\nNr. linii=");scanf("%u",&m);
printf("\nNr. coloane=");scanf("%u",&n);
for (i=0;i<m;i++)
for (j=0;j<n;j++)
{ printf("a[%u][%u]=",i,j);
scanf("%f",&a[i][j]);
}
printf("\nA doua matrice:");
printf("\nNr. linii=%u",n);
printf("\nNr. coloane=");scanf("%u",&p);
for (i=0;i<n;i++)
for (j=0;j<p;j++)
{ printf("b[%u][%u]=",i,j);
scanf("%f",&b[i][j]);
}
printf("\nMatricea produs este:\n");
for (i=0;i<m;i++)
for (j=0;j<p;j++)
{ c[i][j]=0;
for (k=0;k<n;k++) c[i][j]+=a[i][k]*b[k][j];
}
for (i=0;i<m;i++)
{ for (j=0;j<p;j++) printf("%6.1f",c[i][j]);
printf("\n");
}
getch(); }
Analiza problemei:
În corpul funcţiei principale se declară variabile cu următoarea semnificaţie:
m - reprezintă numărul de linii din prima matrice;
n - reprezintă numărul de coloane din prima matrice şi numărul de linii din matricea
a doua;
i, j, k - reprezintă indici folosiţi pentru accesarea elementelor din matrice;
a, b, c - reprezintă tablouri bidimensionale de numere reale ce vor putea avea maxim
400 de elemente.
Folosind funcţia standard scanf se vor citi: numărul de linii din prima matrice şi
numărul de coloane din prima matrice. În cadrul a două instrucţiuni repetitive cu număr fixat
de paşi se citesc elementele matricei a. Numărul de linii din matricea a doua se cunoaşte, el
nu se mai citeşte. Pentru a putea înmulţi două matrice numărul de coloane din prima matrice
trebuie să fie egal cu numărul de linii din a doua matrice. Folosind aceeaşi funcţie standard
scanf se va citi numărul de coloane din matricea a doua. În cadrul a două instrucţiuni
repetitive cu număr fixat de paşi se citesc elementele matricei b.
Se construieşte matricea produs astfel:
96 Tablouri.

- elementul de pe linia i şi coloana j din matricea produs se iniţializează cu valoarea


zero;
- la această valoare se va adăuga produsul dintre elementul din prima matrice de pe
linia i şi coloana k şi elementul din a doua matrice de pe linia k şi coloana j, unde variabila k
primeşte pe rând toate valorile mulţimii {0,1,..., n −1} .
În final, în cadrul a două instrucţiuni repetitive se afişează elementele matricei
produs.

Aplicaţia 6:
Fie m, n două numere naturale şi o matrice A cu m linii şi n coloane, având
elemente numere reale. Să se interschimbe liniile matricei astfel încât suma elementelor din
linia i să fie mai mică decât suma elementelor din linia j, pentru ∀0<=i<j<m.
Specificarea problemei:
Date de intrare: m - numărul de linii din matrice;
n - numărul de coloane din matrice;
a[i][k]; ∀i ∈ {0,1,…,m-1}, ∀k ∈ {0,1,…,n-1}.
Date de ieşire: a[i][k]; ∀i ∈ {0,1,…,m-1}, ∀k ∈ {0,1,…,p-1}.
Date de test: Nr.linii=3
Nr.coloane=2
a[0][0]=6
a[0][1]=23
a[1][0]=1
a[1][1]=5
a[2][0]=7
a[2][1]=9
Matricea dată este:
6.0 23.0
1.0 5.0
2.0 9.0
Matricea modificată este:
1.0 5.0
7.0 9.0
6.0 23.0
Algoritmul problemei:
Algoritm matrice
citeşte m, n
pentru i ← 0, m-1 execută
pentru j ← 0, n-1 execută
citeşte a[i][j]
sfârşit pentru
sfârşit pentru
scrie "Matricea dată este: "
pentru i ← 0,m-1 execută
pentru j ← 0,n-1 execută
scrie a[i][j]
sfârşit pentru
sfârşit pentru
pentru i ← 0,m-1 execută
s[i] ← 0
Tablouri. 97
pentru j ← 0,n-1 execută
s[i] ← s[i]+a[i][j]
sfârşit pentru
sfârşit pentru
pentru i ← 0,m-2 execută
pentru j ← i+1,m-1 execută
dacă s[i]>s[j] atunci pentru k ← 0,n-1 execută
aux ← a[i][k]
a[i][k] ← a[j][k]
a[j][k] ← aux
sfârşit pentru
aux ← s[i]
s[i] ← s[j]
s[j] ← aux
sfârşit dacă
sfârşit pentru
sfârşit pentru
scrie "Matricea modificată este"
pentru i ← 0,m-1 execută
pentru j ← 0,n-1 execută
scrie a[i][j]
sfârşit pentru
sfârşit pentru
sfârşit algoritm.
Programul corespunzător algoritmului este:
#include <stdio.h>
#include <conio.h>
void main()
{ float a[20][20];
unsigned m,n,i,j,k;
float s[20],aux;
printf("\nNr. linii=");scanf("%u",&m);
printf("\nNr. coloane=");scanf("%u",&n);
for (i=0;i<m;i++)
for (j=0;j<n;j++)
{ printf("a[%u][%u]=",i,j);
scanf("%f",&a[i][j]);
}
printf("\nMatricea data este:\n");
for (i=0;i<m;i++)
{ for (j=0;j<n;j++) printf("%6.1f",a[i][j]);
printf("\n");
}
for (i=0;i<m;i++)
{ s[i]=0;
for (j=0;j<n;j++) s[i]+=a[i][j];
}
for (i=0;i<m-1;i++)
for (j=i+1;j<m;j++)

if (s[i]>s[j]) { for (k=0;k<n;k++) { aux=a[i][k]


98 Tablouri.
a[i][k]=a[j][k]
a[j][k]=aux
}
aux=s[i]
s[i]=s[j]
s[j]=aux
}
printf("\nMatricea modificata este:\n");
for (i=0;i<m;i++)
{ for (j=0;j<n;j++) printf("%6.1f",a[i][j]);
printf("\n");
}
getch(); }
Analiza problemei:
În corpul funcţiei principale se declară variabile cu următoarea semnificaţie:
m - reprezintă numărul de linii din matrice;
n - reprezintă numărul de coloane matrice;
i, j, k - reprezintă indici folosiţi pentru accesarea elementelor din matrice;
a - reprezintă un tabloul bidimensional de numere reale ce va putea avea maxim 400
de elemente;
s - reprezintă un tablou unidimensional de numere reale ce va putea avea maxim 20
de elemente;
aux - reprezintă o variabilă auxiliară folosită pentru interschimbarea elementelor din
cele două tablouri.
Folosind funcţia standard scanf se vor citi: numărul de linii din matrice şi numărul
de coloane din matrice. În cadrul a două instrucţiuni repetitive cu număr fixat de paşi se
citesc elementele matricei, apoi se afişează elementele matricei date.
În cadrul unei structuri repetitive se determină sumele elementelor din matrice de pe
fiecare linie în parte, aceste valori reţinându-se într-un tablou unidimensional de numere
reale.
Folosind algoritmul „selecţie” se va ordona crescător tabloul unidimensional „s” şi
se va modifica matricea în funcţie de componentele tabloului s.
În final, în cadrul a două instrucţiuni repetitive se afişează elementele matricei
modificate.