Vizitiu Anamaria

Colegiul Naţional „Mihai Viteazul”
Sfâ ntu Gheorghe, judeţul Covasna
LUCRARE
DE
ATESTAT
Promoţia 2009-2010
Elev: Vizitiu Anamaria

Profesor coordonator: Ş tefă nescu Mariana
Limbajul de programare: Borland Pascal
Titlul:
Tablouri
Bidimensionale
(Matrici)
Cuprins:
Lucrare de atestat 1
CAPITOLUL I - Prezentarea lucră rii........................................3
Motivarea temei alese.................................................................3
CAPITOLUL II - Noţiuni introductive.....................................4

Declararea ........................................................................................4
Parcurgerea......................................................................................5
Citirea de la tastatură ...................................................................6
Citirea din fişier...............................................................................7
Afişarea ..............................................................................................7
CAPITOLUL III - Descrierea programului.............................8

Meniu...................................................................................................8
Generă ri .............................................................................................8
Verifică ri...........................................................................................13
Operaţii.............................................................................................23
Matrici rare.....................................................................................32
CAPITOLUL IV - Codul sursă ....................................................37

Listarea codului sursă ................................................................37
CAPITOLUL V – Bibliografie.....................................................51
CAPITOLUL I Prezentarea lucră rii
Motivarea temei alese
În limbajul Pascal, am ales tema „Tablouri bidimensionale”sau „Matrici”,
deoarece pe lâ ngă celelalte lecţii studiate la orele de informatică matricile mi-
au atras aţentia cel mai tare şi mi s-au pă rut cei mai interesanţi.
De asemenea am vrut sa îmi aprofundez cunoştinţele despre matrici şi

să mă pregă tesc pentru examenul de bacalaureat.
CAPITOLUL II Noţiuni introductive
Declararea unei matrici
O matrice este un tabel cu elemente de acelaşi tip, dispuse pe linii şi coloane.
Datorită acestei aşeză ri a elementelor, o matrice este de fapt un tablou bidimensional.
Fiecare element al matricii se află pe o anumită linie şi pe o anumită coloană . Poziţia unui
element pe linie se mai numeşte şi indicele linie, iar poziţia elementului pe coloană se mai
numeşte şi indice de coloană .
Dacă notă m variabila matrice cu a, atunci elementul de pe linia i şi coloana j în

matricea a se notează cu a[i,j].
Ilustrez în continuare o matrice a cu 3 linii şi 4 coloane, avâ nd ca elemente numere

naturale.
1 2 3 4 coloana
1 1 5 7 4
2 2 3 8 9
3 6 10 1 0
linia
Se observă cum fiecare element e reprezentat de două coordonate. De exemplu
a[3,2] = 10, asta înseamnă că elementul de pe linia 3 şi coloana 4 este 10.
O variabilă matrice se declară asemă nă tor cu o variabilă vector, cu deosebirea că în
loc de numă rul maxim de elemente, trebuie sa preciză m două valori: numă rul maxim de
linii şi numă rul maxim de coloane.
Var <id_mat>:array[<tip1>,<tip2>]of <tip_e>;
 <id_mat> indentificatorul (numele) variabilei matricei
 <tip1>,<tip2> tipul inicilor de linie şi coloană
 <tip_e> tipul elementelor matrici (shortin, integer, byte,
word, longint, real sau chiar char)
Un tip de date matrice este anonim, dar el poate fi denumit cu cuvâ ntul cheie type
(la fel ca tipurile vector).
EX: type mat=array [1..10,1..15] of real;
Var a:mat;
Tipul anonim array[1..10,1..15] of real a primit numele mat, apoi se declară variabila
matrice a ca fiind de tip mat.
Dacă am declarat o matrice a cu maxim 10 linii şi 15 coloane, asta nu înseamnă că
trebuie să folosim toate cele 150 de elemente ale sale. Aşa cum în cazul unui vector
defineam ca variabilă un numă r real de elemente (numă rul elementelor efectiv folosite), la
fel pentru o matrice a vom defini două variabile: un numă r real de linii şi un numă r real de
coloane, notate de obicei cu n şi m. În aceste condiţii, în mod implicit indicii de linie vor fi
1,2...n iar cei de coloană vor lua valori de la 1,2...m.
De exemplu pentru o matrice a cu n linii şi m coloane, elementele ei sunt:

a[1,1], a[1,2], a[1,3], ..., a[1,n] linia 1
a[2,1], a[2,2], a[2,3], …, a[2,n] linia 2
………………………………………………………………….
a[m,1], a[m,2], a[m,3], …, a[m,n] linia n
Parcurgerea unei matrici

Consideră m o matrice a, cu n linii şi m coloane. Parcurgem într-un ciclu liniile i=1, 2,
..., n.Pentru fiecare linie i, parcurgem într-un alt ciclu coloanele acesteia j=1, 2, ..., m. Pentru
fiecare valoare a lui i şi j „vizită m ” elementul a[i,j], de pe linia i şi coloana j. Prezint în
continuare algoritmul de parcurgere, precum şi ordinea în care vor fi „vizitate” elementele
matricii a.
Pentru i de la 1 la n execută
Pentru j de la 1 la m execută
<prelucrează a[i,j]>
i=1 j=1 a[1,1]

j=2 a[1,2]
……………………….
j=m a[1,m]
i=2 j=1 a[2.1]
j=2 a[2,2]
....................................
j=m a[2,m]
...................................
i=n j=1 a[n,1]
j=2 a[n,2]
....................................
j=m a[n,m]
Citirea unei matrici de la tastatură

Citim mai înâ i numă rul de linii şi coloane, n respectiv m, apoi pentru a citi
elementele matricii a folosim algoritmul de mai sus: parcurgem în două cicluri linile i=1,
2, ..., n şi coloanele j=1, 2, ..., m şi pentru fiecare linie i şi coloană j, citim elementul a[i,j].
Pentru i de la 1 la n execută
Pentru j de la 1 la m execută
Citeşte (a[i,j])
Vom scrie o procedură prin care vom citi elementele unei matrici a. Vom declara o
variabilă pentru matricea a „matrice”, cu numere întregi, pentru a putea folosii matricea în
proceduri şi funcţii.
type matrice=array[1..100,1..100] of integer;
procedure citire_mat(n,m:integer;var a:matrice);
var i,j:byte;
begin
writeln(‘Dati numarul de linii’);
Readln(n);
Writeln(‘Dati numarul de coloane’)
Readln(m);
for i:=1 to n do
for j:=1 to m do
begin
writeln('Dati elementul de pe pozitia ',i,j);
readln(a[i,j]);
end;
end;
Observă m că la fiecare pas înainte de citirea propriu-zisă a elementului a[i,j] se
tipă reşte un mesaj care ne arată la ce element am ajuns cu citirea. Lungimea liniei şi
coloanei se citesc de asemenea de la tastatură .
În cazul unei matrici pă tratice citirea ei este exact aceaşi cu diferenţa că atâ t linile
câ t şi coloanele vor fi egale.
procedure citire_mat_patrat(n:integer;var a:matrice);

var i,j:byte;
begin
writeln(‘Dati numarul de linii’);
Readln(n);
for i:=1 to n do
for j:=1 to n do begin
writeln('Dati elementul de pe pozitia ',i,j);
readln(a[i,j]);
end;
end;
Citirea unei matrici dintr-un fişier

Pentru a încă rca o matrice dintr-un fişier este necesar să parcurgem fişierul după
care să copiem datele în matrice. Să presupunem că fişierul se numeşte Date.in şi pe prima
linie sunt trecute numă rul de linii şi de coloane ale matricii (n şi m). Pe urmă toarele n linii
se gă sesc câ te m numere ce reprezintă elementele matricei, numere întregi, despă rţite
printr-un spaţiu.
Var a:matrice;
f:text;
i,j,n,m:integer;
Begin
Assign(f,’Date.in’); i se atribuie lui f fişierul date.in
Reset(f); se deschide fişierul f
Readln(f,n,m) se citesc numă rul de linii şi de coloane
For i:=1 to n do se parcurge fişierul
For j:=1 to m do
Read(f,a[i,j]); se citeşte numă rul din fişier şi in acelaşi timp el este pus
Close(f); în matrice pe poziţia a[i,j]
End;
End.
Afişarea unei matrici

Folosim tot idea algoritmului de parcurgere descris anterior, la citirea unei matrici.
Pentru a afişa fiecare linie a matricii pe un râ nd de ecran vom proceda în felul urmă tor:
parcurgem într-un ciclu liniile i=1, 2, ..., n şi pentru fiecare linie i afişă m elemenele liniei i pe
râ nd nou al ecranului şi mută m cursorul la începutul râ ndului urmă tor. Vom proiecta apoi
un alt ciclu, în care parcurgem coloanele j=1, 2, ..., m ale liniei i, şi la fiecare pas afişă m
elementul a[i,j] cu câ te un spaţiu între ele. Vom scrie o propocedură pentru a ilustra
afişarea matricii.
procedure afisare_mat(n,m:integer;var a:matrice);

var i,j:byte;
begin
for i:=1 to n do
begin
writeln;
for j:=1 to m do
write(a[i,j],’ ‘);
end;
end;
CAPITOLUL III Descrierea programului
Meniul
Programul se deschide cu o interfaţă prietenoasă , ce ilustrează tema lucră rii, şi 3
exemple de matrici, realizate în modul grafic. Rolul acestei interfaţe este de al introduce şi
informa pe utilizator cu privire la tema programului.
Partea care îmbină toate elementele programului este meniul. Prin crearea acestuia
s-a fă cut posibilă navigarea acestui program într-un mod foarte simplu şi anume prin
apă sarea tastei corespunză toare obţiunii dorite.
Folosind tasta „0”, din interiorul programului, se face reîntoarcerea la meniul
anterior sau chiar ieşirea din program odată ajunşi la meniul principal.
Prin apă sarea tastei „5” în meniul principal se va apela submeniul Help care este
destinat pentru informarea utilizatorului despre program, acest meniu prezentâ nd
structura programului.
Generări de matrici
Generă ri matrici cu n linii şi m coloane (nxm)
a. Să se se scrie un subprogram care să genereze o matrice cu n linii şi m coloane, astfel

încâ t prin parcurgerea acestuia linie cu linie de sus în jos şi fiecare linie de la stâ nga la
dreapta, să se obţină în ordine crescă toare toate numerele naturale de la 1 la n*m.
Exemplu: pentru n=4 şi m=3 se va genera urmă torul tablou:
1 2 3
4 5 6
7 8 9
10 11 12
Cea mai simplă metodă este de a folosi o variabilă ajută toare k,
care se iniţializează la începutul parcurgerii matricii, şi care după ce este atribuită
elementului de pe poziţia liniei i şi coloanei j creşte cu o unitate.
procedure generare_1(var a:matrice;n,m:integer);

var i,j,k:byte;
begin
k:=1; se iniţializează variabila ajută toare
for i:=1 to n do se parcurgere linia
for j:=1 to m do se parcurgere coloana
begin
a[i,j]:=k; elementului de pe linia i şi coloana j i se atribuie valoarea k
inc(k); se creşte k cu o unitate
end;
end;
b. Să se se scrie un subprogram care să genereze 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 numere pare, ordonate crescă tor.
0 2 4
6 8 10
12 14 16
18 20 22
La fel ca şi în problema anterioară se va folosi o variabilă
ajută toare şi care după ce este atribuită elementului de pe linia i şi coloana j creşte cu 2
unită ţi, deoarece diferenţa dintre 2 numere pare consecutive este 2.

var i,j,k:byte;
begin
k:=0;
for i:=1 to n do
for j:=1 to m do
begin
a[i,j]:=k;
k:=k+2;
end;
end;
c. Să se se scrie un subprogram care să genereze o matrice cu n linii şi m coloane,
formată din toate numerele naturale de la 1 la n*m, ca în exemplu.
1 2 3 4 5
10 9 8 7 6
11 12 13 14 15
20 19 18 17 16
Se atribuie elementelor de pe fiecare linie din matrice o valoare k , iniţializată cu 1 şi

incrementată cu 1 după fiecare atribuire. Liniile impare sunt completate începâ nd cu prima
coloană iar liniile pare începâ nd cu ultima coloană .

var i,j,k:byte;
begin
k:=1 se iniţializează variabila ajută toare
for i:=1 to n do se parcurge linia
if i mod 2 <> 0 then dacă indicele liniei este impar atunci
for j:=1 to m do se începe parcurgerea de la prima coloană
begin
end
else dacă indicele liniei este impar atunci
for j:=m downto 1 do se începe parcurgea de la ultima coloană
begin

end;
end;
Generă ri matrici cu n linii şi n coloane (matrici pă tratice)
a. Să se se scrie un subprogram care să genereze o matrice cu n linii şi n coloane, ca în

exemplu.
Exemplu: pentru n=6 se va genera urmă torul tablou:
0 0 0 0 0 0
0 1 1 1 1 0
0 1 2 2 1 0
0 1 2 2 1 0
0 1 1 1 1 0
0 0 0 0 0 0
Se iniţializează matricea cu 0, pentru că prima linie, prima coloană , ultima linie şi

ultima coloană nu sunt parcurse avâ nd valoarea 0. Se folosteşte o variabila K, care i-a valori
de la 1 la jumă tate din n (lungimea liniei), linile şi coloanele sunt completate începâ nd cu
poziţia 1*k pâ nă la n-k. În cazul în care n este par, matricea va avea 4 elemente în mijloc iar
dacă n este impar ea va avea un singur element.
procedure generarep_4(var a:matrice;n:integer);

var i,j,k:byte;
begin
for i:=1 to n do Iniţializarea elementelor tabloului cu 0
for j:=1 to n do
a[i,j]:=0;
for k:=1 to n div 2 do k ia valori de la 1 la jumă tate din n
for i:=1+k to n-k do Se parcurg linile si coloanele
for j:=1+k to n-k do se atribuie elementului a de pe linia i şi coloana j
a[i,j]:=k; valoarea k
end;
b. Să se scrie un subprogram care să genereze 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 3, elementele aflate în dreapta ambelor diagonale cu 2 şi restul elementelor cu 4.
0 1 1 1 0
4 0 1 0 2
4 4 0 2 2
4 0 3 0 2
0 3 3 3 0
Se parcurge întreaga matrice şi pentru fiecare element
se verifică apartenenţa lui la una dintre cele 2 diagonale sau la una dintre cele patru zone
delimitate de diagonale, completâ ndu-l cu valoarea corespunză toare zonei din care face
parte. Matricea cu indicii liniei şi coloanei pentru n=5 arată aşa:
a11 a12 a13 a14 a15
a21 a22 a23 a24 a25
a31 a32 a33 a34 a35
a41 a42 a43 a44 a45
a51 a52 a53 a54 a55
Se observă că :
Elementele de pe diagonala principală sunt de forma a11, a22, adică indicele liniei şi
indicele coloanei sunt egale;
Elementele de pe diagonala secundară sunt de forma a15, a24, adică indicele liniei
adunat cu indicele coloanei ne dă întotdeauna n+1;
Elementele aflate deasupra celor 2 diagonale sunt de forma a12, a13, a23, adică indicele
liniei este mai mic decâ t indicele coloanei, şi suma celor 2 indici este mai mică decâ t n+1;
Elementele aflate sub cele 2 diagonale sunt de forma a43, a52, a53, adică indicele liniei
este mai mare decâ t indicele coloanei, şi suma celor 2 indici este mai mai mare decâ t n+1;
Elementele aflate în dreapta celor 2 diagonale sunt de forma a34, a25, a35, adică indicele
liniei este mai mic decâ t indicele coloanei, şi suma celor 2 indici este mai mai mare decâ t
n+1;

var i,j:byte;
begin
for i:=1 to n do
for j:=1 to n do begin
if (i=j)or(i+j=n+1) then a[i,j]:=0
else if (i<j)and(i+j<n+1) then a[i,j]:=1
else if (i<j)and(i+j>n+1) then a[i,j]:=2
else if (i>j)and(i+j>n+1) then a[i,j]:=3
else a[i,j]:=4;
end;
end;
c. Să se scrie un subprogram care să genereze o matrice cu n linii şi n coloane, o

matrice triunghiulară inferior, ca în exemplu.
1 0 0 0 0
2 1 0 0 0
3 2 1 0 0
4 3 2 1 0
5 4 3 2 1
Se iniţializează matricea cu 0, se începe parcurgerea liniei,

se iniţializează variabila k cu i, variabilă ce va fi folosită pentru a umple elementele şi se
parcurge coloana pană la i, se atribuie elementului de pe poziţia i,j valoarea k, care după
fiecare atribuire scade cu o unitate.

var i,j,k:word;
begin
for i:=1 to n do
for j:=1 to n do
a[i,j]:=0;
for i:=1 to n do begin
k:=i;
for j:=1 to i do begin
a[i,j]:=k;
dec(k);
end;
end;
end;
d. Să se scrie un subprogram care să genereze o matrice cu n linii şi n coloane, o
matrice simetrică fata de diagonala secundară , ca în exemplu.
1 2 3 4 5
2 3 4 5 4
3 4 5 4 3
4 5 4 3 2
5 4 3 2 1
Se parcurge linia şi apoi coloana pâ nă la elementul de pe

coloana n-i+1, deoarece, fiind o matrice simetrică faţă de diagonala secundară la
parcurgere se umple în acelaşi timp un element dar şi simetricul ei, astfel nu e nevoie să se
facă parcurgerea totală a matrici. Pentru umplerea elementului se observă că elementul de
pe poziţia a22 va avea valoarea 3, cel de pe a23 valoarea 4 adică , indicele liniei adunat cu
indicele coloanei minus 1.
procedure generarep_7(var a:matrice;n:byte);

var i,j:byte;
begin
for i:=1 to n do
for j:=1 to n-i+1 do begin
a[i,j]:=i+j-1;
a[n-i+1,n-j+1]:=a[i,j];
end;
end;
Verificări
1. Să se scrie un subprogram care să verifice dacă o matricea citită de la tastatură este
opusă unei alte matrici citite de la tastatură . O matrice este opusa unei alte matrici dacă are
acelaşi grad şi dacă are toate elementele opuse elementelor celeilalte matrici.
Subprogramul va returna valoarea true dacă prima matrice este opusă celei de a doua şi
false dacă cele două matrici nu sunt opuse.
Exemplu: pentru matricea A şi B subrogramul va returna valoarea true iar pentru
matricea C şi D valoarea false:
1 1 1 1 -1 -1 -1 -1
1 2 1 1 -2 1
2 2 2 2 B= -2 -2 -2 -2 A= 2 C=
8 2 D= 5 -9 2
3 3 3 3 -3 -3 -3 -3
4 3 3 -2 3 7
4 4 4 4 -4 -4 -4 -4
Începem prin a pune problema dacă sunt de acelaşi grad. Astfel, compară m dacă
numă rul de linii şi coloane din prima matrice este egal cu numă rul de linii şi coloane din a
doua matrici. Se vor parcurge cele două matrici şi se observă că pentru a fi opuse elementul
de pe poziţia i, j din prima matrice A, adica a[i,j], trebuie să fie minus elementul de pe aceaşi
poziţie dar din matricea a doua B, b[i,j]. Astfel vom înmulţii elementele din matricea a doua
cu -1 şi dacă sunt egale cu elementele din prima matrice atunci cele două matrici sunt
opuse.
function verifica_opusa(var a,b:matrice;n,m,k,l:byte):boolean;
var i,j:byte;
begin
verifica_opusa:=true;
if (n=k) and (m=l) then begin
for i:=1 to n do
for j:=1 to m do
if a[i,j]<>b[i,j]*-1 then verifica_opusa:=false;
end;
2. Să se scrie un subprogram care să verifice dacă o matrice citită de la tastatură este

transpusa unei alte matrici citite tot de la tastatură . Transpusa unei matrici este matricea
obţinută prin schimbarea liniilor în coloane şi a coloanelor în linii. Noţiunea de transpusă
este valabilă doar dacă cele două matrici au acelaşi grad. Subprogramul va returna valoarea
true dacă prima matrice este transpusa celei de a doua şi false dacă prima matrice nu este
transpusa celei de a doua.
Exemplu: pentru matricea A şi B subrogramul va returna valoarea true iar pentru
matricea C şi D valoarea false:
1 2 1 1 2 4 1 2 1 1 1 8
A= B= 2 8 2 C=
2 8 3 2 8 2 D= 2 4 2
4 3 3 1 2 3 4 3 3 1 3 3
La fel ca în problema anterioară vom începe prin a studia gradele celor două matrici.
Vom parcurge matricile şi vom compara dacă elementul de pe linia i şi coloana j, a[i,j] este
egal cu elementul de pe linia j şi coloana i a celei de a doua matrici, b[j,i]. Unde A este prima
matrice iar B a doua matrice.
function verifica_transp(var a,b:matrice;n,m,k,l:integer):boolean;
var i,j:byte;
begin
verifica_transp:=true;
if (n=k)then begin
for i:=1 to n do
for j:=1 to n do
if a[i,j]<>b[j,i] then verifica_transp:=false;
end;
end;
3. Să se scrie un subprogram care să verifice dacă o matrice citită de la tastatură este o
matrice melc. O matrice melc este matricea ale că rei elemente sunt numere consecutive
aşezate circular începâ nd cu prima linie şi încheind cu elementul din mijlocul matricii.
Subprogramul va returna valoarea true dacă matricea dată este matrice melc şi false dacă
nu este matrice melc.
Exemplu: pentru matricea A subrogramul va returna valoarea true iar pentru
matricea B valoarea false.
1 2 3 1 2 1
A= 8 9 4 B= 4 9 4
7 6 5 7 5 5
Pentru rezolvarea acestei probleme se va folosii un vector care va reţine elementele

matricii parcurse în formă de melc. Dacă diferenţa elementelor din vector este 1 atunci
numerele sunt consecutive şi sunt aşezate în forma de melc.
function verifica_melc(var a:matrice;n,m:byte):boolean;

var i,d,k,p:byte;
v:array[1..100]of integer;
begin
verifica_melc:=true;
k:=n div 2;
p:=1;
for d:=1 to k do begin
for i:=d to n-d+1 do begin
v[p]:= a[d,i];
inc(p);
end;
for i:=d+1 to n-d do begin
v[p]:=a[i,n-d+1];
inc(p);
end;
for i:=n-d+1 downto d do begin
v[p]:=a[n-d+1,i];
inc(p);
end;
for i:=n-d downto d+1 do begin
v[p]:=a[i,d];
inc(p);
end;
end;
v[p]:=a[n div 2+1,n div 2+1];
for i:=2 to p-1 do
if v[i]-v[i-1]<>1 then verifica_melc:=false;
end;
Verificarea simetriei unei matrici
a. Să se scrie un subprogram care să verifice dacă o matrice citită de la tastatură este o

matrice simetrică faţă de diagonala principală . Subprogramul va returna valoarea true dacă
matricea este simetrică şi false dacă matricea nu este simetrică . O matrice este simetrică
faţă de diagonala principală , dacă elementele egal depă rtate de ea sunt egale. Pentru ca
matricea să aiba diagonală ea trebuie sa fie o matrice pă tratică .
matricea B valoarea false:
1 2 3 4 1 1 1 1
2 1 6 5
A= B= 2 2 2 2
3 6 1 4 1 1 1 1
4 5 4 1 2 2 2 2
Se observă că o matrice este simetrică dacă elementul de pe poziţia a1,2 este egal cu
elementul de pe poziţia a2,1, elementul de pe poziţia a1,3 este egal cu elementul de pe poziţia
a3,1 şi tot aşa, altfel spus, dacă elementul de pe poziţia ai,j este egal cu elementul de pe
poziţia aj,i
function verifica_1(var a:matrice;n,m:integer):boolean;

var i,j:byte;
begin
verifica_1:=false; Se parcurge linia pâ nă la n-1 şi coloana de la i+1
for i:=1 to n-1 do la m pentru a se parcurge doar jumă tate de matrice
for j:=i+1 to m do
if a[i,j]=a[j,i] then verifica_1:=true;
end;
b. Să se scrie un subprogram care să verifice dacă o matrice citită de la tastatură este

antisimetrică . O matrice este antisimetrică dacă elementele egal depă rtate de diagonala
principală sunt opuse. Subprogramul va returna valoarea true dacă matricea este
antisimetrică şi false dacă matricea nu este antisimetrică .
1 2 3 4 1 2 3 4
-2 1 2 3 2 1 2 3
A= -3 -2 1 4 B= 3 2 1 4
-4 -3 -4 1 4 3 4 1
Function verifica_antisimetrica( var a:matrice;n,m:integer):boolean;
var i,j:byte;
begin
verifica_antisimetrica:=false;
for i:=1 to n-1 do
for j:=1+i to m do
if a[i,j]=-a[j,i] then verifica_antisimetrica:=true;
end;
c. Să se scrie un subprogram care să verifice dacă o matrice citită de la tastatură este

simetrică fată de linia de mijloc verticală . O matrice este simetrică dacă elementele egal
depă rtate de linia de mijloc verticală sunt egale. Subprogramul va returna valoarea true
dacă matricea este simetrică şi false dacă matricea nu este simetrică .
1 5 5 1 1 1 1 1
2 6 6 2
A=
3 7 7 3
B= 2 2 3 3
3 3 2 2
4 8 8 4 1 1 1 1
function simetrie_verticala(var a:matrice;n,m:integer):boolean;

var vb:boolean;i,j:byte;
begin
vb:=true;
for i:=1 to n do Se parcurge coloana pâ nă la jumă tate deoarece
for j:=1 to m div 2 se compară elementele din prima jumă tate cu
if a[i,j]<>a[i,m-j+1] then cele din a 2 jumă tate a matricii
vb:=false;
simetrie_verticala:=vb;
end;
d. Să se scrie un subprogram care să verifice dacă o matrice citită de la tastatură este

simetrică fată de linia de mijloc orizontală . O matrice este simetrică dacă elementele egal
depă rtate de linia de mijloc orizontală sunt egale. Subprogramul va returna valoarea true
dacă matricea este simetrică şi false dacă matricea nu este simetrică .
1 2 3 4 1 1 1 1
5 6 7 8 2 2 3 3
A= 5 6 7 8
B=
3 3 2 2
1 2 3 4 1 1 1 1
function simetrie_orizontala(var a:matrice;n,m:integer):boolean;
var vb:boolean;i,j:byte;
begin
vb:=true;
for i:=1 to n div 2 do
for j:=1 to m do
if a[i,j]<>a[n-i+1,j] then vb:=false;
simetrie_orizontala:=vb;
end;
Verificarea naturii unei matrici
a. Să se scrie un subprogram care să verifice dacă matricea citită de la tastatura este o

matrice pă tratică . O matrice este pă tratică daca are acelaşi numă r de linii şi de coloane.
Subprogramul va returna valoarea true dacă matricea este pă tratică şi false dacă matricea
nu este pă tratică .
1 2 3 4 1 1 1
5 6 7 8 B= 2 2 2
A= 3 3 3
9 10 11 12
13 14 15 16 1 1 1

begin
verifica_5:=false;
if n=m then verifica_5:=true;
end;
b. Să se scrie un subprogram care să verifice dacă matricea citită de la tastatură este o

matrice linie. O matrice este linie daca are o linie şi m coloane. Subprogramul va returna
valoarea true dacă matricea este linie şi false dacă matricea nu este linie.
1 2 1
A= 1 2 3 4 B= 1 1 1
1 2 1

begin
verifica_3:=false;
if (n=1)and(m<>1) then verifica_3:=true;
end;
c. Să se scrie un subprogram care să verifice dacă matricea citită de la tastatură este o
matrice coloană . O matrice este coloană dacă are o coloană şi n linii. Subprogramul va
returna valoarea true dacă matricea este coloană şi false dacă matricea nu este coloană .
1
2 1 2 1
A= B= 1 1 1
3
1 1 2 1

begin
verifica_4:=false;
if(n<>1)and(m=1) then verifica_4:=true;
end;
d. Să se scrie un subprogram care să verifice dacă matricea citită de la tastatură este o

matrice nulă . O matrice este nulă dacă are toate elementele nule. Subprogramul va returna
valoarea true dacă matricea este nulă şi false dacă matricea nu este nulă .
0 0 0 1 2 1
A= 0 0 0 B= 1 1 1
0 0 0 1 2 1

var i,j:byte;
begin
verifica_2:=true;
for i:=1 to n do
for j:=1 to m do
if (a[i,j]<>0) then verifica_2:=false;
end;
e. Să se scrie un subprogram care să verifice dacă matricea citită de la tastatură este o
matrice unitate. O matrice este unitate dacă este matrice pă tratică şi dacă are toate
elementele de pe diagonala principală egale cu 1 şi restul elementelor nule. Subprogramul
va returna valoarea true dacă matricea este matrice unitate şi false dacă matricea nu este
matrice unitate.
1 0 0 1 2 1
A= 0 1 0 B= 1 1 1
0 0 1 1 2 1
function verifica_uni(var a:matrice;n,m:integer):boolean;

var i,j:byte;
vb:boolean;
begin
verifica_uni:=false;
vb:=true;
for i:=1 to n do
for j:=1 to m do
if a[i,i]<>1 then vb:=false;
if vb=true then
for i:=1 to n do
for j:=1 to m do
if(i<>j)and(a[i,j]<>0) then vb:=false;
verifica_uni:=vb;
end;
f. Să se scrie un subprogram care să verifice dacă matricea citită de la tastatură este o

matrice diagonală . O matrice este diagonală dacă este o matrice pă tratică şi dacă are toate
elementele de pe diagonala principală nenule şi restul elementelor nule. Subprogramul va
returna valoarea true dacă matricea este matrice diagonală şi false dacă matricea nu este
matrice diagonală .
1 0 0 1 2 1
A= 0 2 0 B= 1 1 1
0 0 3 1 2 1
function verifica_diag( var a:matrice;n,m:integer):boolean;

var i,j:byte;
vb:boolean;
begin
verifica_diag:=false;
vb:=true;
for i:=1 to n do
for j:=1 to m do
if a[i,i]=0 then vb:=false;
if vb=true then
for i:=1 to n do
for j:=1 to m do
if (i<>j)and (a[i,j]<>0) then vb:=false;
verifica_diag:=vb;
end;
g. Să se scrie un subprogram care să verifice dacă matricea citită de la tastatură este o

matrice triunghiulară superior. O matrice este triunghiulară superior dacă este o matrice
pă tratică şi dacă are toate elementele de sub diagonala principală nule. Subprogramul va
returna valoarea true dacă matricea este matrice triunghiulară superior şi false dacă
matricea nu este triunghiulară superior.
1 1 3 1 2 1
A= 0 2 2 B= 1 1 1
0 0 3 1 2 1
Vom pune coniţia să fie pă tratică si vom studia dacă elementele de sub diagonala
principală sunt nule.
function verifica_tri_sup(var a:matrice;n,m:integer):boolean;

var i,j:byte;
begin
verifica_tri_sup:=true;
for i:=1 to n do
for j:=1 to n do
if (i>j) and (a[i,j]<>0) then verifica_tri_sup:=false;
end;
h. Să se scrie un subprogram care să verifice dacă matricea citită de la tastatură este o

matrice triunghiulară inferior. O matrice este triunghiulară inferior dacă este o matrice
pă tratică şi dacă are toate elementele deasupa diagonalei principale nule. Subprogramul va
returna valoarea true dacă matricea este matrice triunghiulară superior şi false dacă
matricea nu este triunghiulară superior.
1 0 0 1 2 1
A= 1 2 0 B= 1 1 1
3 4 3 1 2 1
Ca şi în problema anterioară vom pune coniţia să fie pă tratică dar de data aceasta
vom studia dacă elementele aflate deasupra diagonalei principale sunt nule.
function verifica_tri_inf(var a:matrice;n,m:integer):boolean;

var i,j:byte;
begin
verifica_tri_inf:=true;
for i:=1 to n do
for j:=1 to m do
if(i<j) and( a[i,j]<>0 ) then verifica_tri_inf:=false;
end;
i. Să se scrie 2 subprograme care să verifice dacă matricea citită de la tastatură este o

matrice inversabilă . Se vor studia două cazuri: matricile de ordin 2 şi 3. O matrice este
inversabilă dacă determinantul ei este nenul. Subprogramul va returna valoarea true dacă
matricea este inversabilă şi false dacă nu este inversabilă .
Exemplu: pentru matricea A subrogramul va returna valoarea true deoarece
determinantul matricii A este 2 iar pentru matricea B valoarea false, determinantul matrici
B fiind 0:
1 1 2 1 2 1
A= 2 1 1 B= 1 1 1
1 2 1 1 2 1
Vom discuta prima data de matricile de ordin 2. Vom crea o

funcţie care să calculeze determinantul matricii şi în funcţie de valoarea ei vom vedea dacă
este sau nu inversabilă . Vom folosi formula matematică pentru determinaţii de ordin 2.
function det2(var a:matrice):Boolean;

var i,j:byte;
s:real;
begin
det2:=true;
for i:=1 to 2 do
for j:=1 to 2 do
s:=a[1,1]*a[2,2]-a[1,2]*a[2,1];
if s=0 then det2:=false;
end;
În cazul matrici de ordin 3 vom pă stra aceaşi idee de calcul, vom folosi formula
matematică , diferită de cea pentru determinanţii de ordin 2.
function det3(var a:matrice):boolean;

var i,j:byte;
s:real;
begin
det2:=true;
for i:=1 to 3 do
for j:=1 to 3 do
s:=a[1,1]*a[2,2]*a[3,3]+a[2,1]*a[3,2]*a[1,3]+a[3,1]*a[1,2]*a[2,3]
-a[3,1]*a[2,2]*a[1,3]-a[1,1]*a[3,2]*a[2,3]-a[2,1]*a[1,2]*a[3,3];
If s=0 then det3:=false;
end;
Operaţii cu matrici
Adunarea a două matrici
Să se scrie un subprogram care să calculeze suma a două matrici, subprogramul va
returna o a treia matrice formata din suma celor 2.
Exemplu: pentru matricea A adunată cu matricea B, subprogramul va returna o a 3
matrice C:
1 1 1 2 2 2 3 3 3
A= 1 1 1 B= 4 4 4
C= 5 5 5
1 1 1 6 6 6 7 7 7
Pentru
ca două matrici să se poată aduna trebuie ca cele două matrici să fie de acelaşi grad.
Observă m că elementul c[i,j] este egal cu suma dintre elemenetul de pe poziţia a[i,j] şi
elementul de poziţia b[i,j].Astfel, c[1,1]=b[1,1]+b[2,2] adica 3=2+1. Pentru că subprogramul
trebuie să returneze o matrice vom folosi o procedură .
procedure suma( var a,b:matrice;n,m,k,l:integer;Var c:matrice);

var i,j:byte;
begin
if (n=k)and(m=l) then begin
for i:=1 to n do
for j:=1 to m do
c[i,j]:=a[i,j]+b[i,j];
end;
end;
Scă derea a două matrici
Să se scrie un subprogram care să calculeze scă derea a două matrici, subprogramul
va returna o a treia matrice formată din diferenţa celor 2.
Exemplu: pentru matricea A din care se scade matricea B, subprogramul va returna
o a 3 matrice C:
4 2 4 2 2 2 2 0 2
A= 3 1 3 B= 4 4 4 C= -1 -3 -1
8 7 8 6 6 6 2 1 2
Ideea de rezolvare a problemei este aceaşi ca la adunare, diferenţa este că de data

această vom scă dea nu aduna.
procedure diferenta( var a,b:matrice;n,m,k,l:integer;var c:matrice);

var i,j:byte;
begin
if (n=k)and(m=l) then begin
for i:=1 to n do
for j:=1 to m do
c[i,j]:=a[i,j]-b[i,j]
end;
end;
Produsul a două matrici

Să se scrie un subprogram care să calculeze produsul a două matrici, subprogramul
va returna o a treia matrice.
Exemplu: pentru matricea A înmulţită cu matricea B, subprogramul va returna o a
3 matrice C:
2 2 10 10
A= 1 2
B= C=
1 1 4 4 6 6
procedure produs(var a,b:matrice;n,m,k:integer;var c:matrice);

var i,j,p:byte;
begin
for i:=1 to n do
for j:=1 to k do begin
c[i,j]:=0;
for p:=1 to m do
c[i,j]:=c[i,j]+a[i,p]*b[p,j];
end;
end;
Produsul unei matrici cu un scalar
Să se scrie un subprogram care să calculeze produsul unei matrici cu un scalar dat
de la tastatură , subprogramul va returna o a doua matrice.
Exemplu: pentru matricea A din înmulţită cu scalarul X=3, subprogramul va
returna matricea C:
A= 1 2 C= 3 6
1 1 3 3
Ideea de rezolvare a problemei este ca fiecare element al matrici A să se înmulţească
cu scalarul dat.
procedure prod_scalar(var a:matrice;n,m,k:integer;var c:matrice);

var i,j:byte;
begin
for i:=1 to n do
for j:=1 to m do
c[i,j]:=a[i,j]*k;
end;
Transpusa unei matrici

Să se scrie un subprogram care să afişeze transpusa unei matrici. Transpusa unei
matrici este matricea obţinută prin schimbarea liniilor în coloane şi a coloanelor în linii.
Exemplu: pentru matricea A, subprogramul va afişa matricea B.
A= 1 2 B= 1 4
4 1 2 1
Observă m că pentru afişarea transpusei matricii este nevoie de o afişare simplă ,

singura difeneţă fiind că la afişare nu vom m-ai afişa a[i,j] ci a[j,i].
procedure afisare_transp(n,m:integer;var a:matrice);

var i,j:byte;
begin
for i:=1 to n do
begin
writeln;
for j:=1 to m do
write(a[j,i]:3);
end;
Ş tergerea liniei sau coloanei unei matrici
a. Să se scrie un subprogram care să şteargă o linie citită de la tastatură .
Exemplu: pentru matricea A, subprogramul, în urma ştergerii liniei 2 va afişa
matricea B.
A= 1 4 2 B= 1 4 2
4 5 1
Pentru a şterge o linie a matrici, vom parcurge linile tabloului începâ nd de la linia ce
se vrea a fi ştersă pâ nă la n-1, iar parcurgerea coloanelor se face ca în mod normal. Fiecă rui
element îi vom schimba valoarea cu valoarea elementului de pe linia urmă toare dar aceaşi
coloană . În final vom scă dea numă rul linilor cu 1. Practic idea de ştergere a liniei este să îi
dă m elementelor de pe linii valoarea elementelor de pe liniile consecutive şi la afişare să
afişam n-1 linii. Adică dacă se vrea a fi ştersă prima linie a unei matrici de ordin 3, atunci
programul va da elementelor de pe prima linie valorile elementelor de pe linia 2, iar
elementelor de pe a 2 linie valorile elementelor de pe a 3 linie, în final scă dem numă rul
linilor cu o unitate.
procedure stergere(var a:matrice;n,m,k:integer);

var i,j:byte;
begin
writeln('Dati linia care se vrea a fi stersa');
readln(k);
for i:=k to n-1 do
for j:=1 to m do
a[i,j]:=a[i+1,j];
n:=n-1;
end;
b. Să se scrie un subprogram care să şteargă o coloană citită de la tastatură .

Exemplu: pentru matricea A, subprogramul, în urma ştergerii coloanei 2 va afişa
matricea B.
1 1 2 1 2
A= 2 1 1 B= 2 1
1 2 1 1 1
Vom proceda la fel ca în cazul ştergerii unei linii cu diferenţa că de data aceasta
vom lucra pe coloane.
procedure stergere_2(var a:matrice;n,m,k:integer);
var i,j:byte;
begin
writeln('dati coloana care se vrea a fi stersa');
readln(k);
for i:=1 to n do
for j:=k to m-1 do
a[i,j]:=a[i,j+1];
m:=m-1;
end;
c. Să se scrie un subprogram care să şteargă atâ t o coloană câ t şi o linie a matrici, citite

de la tastatură .
Exemplu: pentru matricea A, subprogramul, în urma ştergerii coloanei 2 şi liniei 1
va afişa matricea B.
1 1 2
B= 2 1
A= 2 1 1 1 1
1 2 1
procedure stergere_3(var a:matrice;n,m,k,l:integer);

var i,j:byte;
begin
writeln('dati linia care se vrea a fi stersa');
readln(k);
writeln('dati coloana care se vrea a fi stearsa');
readln(l);
for i:=k to n-1 do
for j:=1 to m do
a[i,j]:=a[i+1,j];
for i:=1 to n do
for j:=l to m-1 do
a[i,j] :=a[i,j+1];
n:=n-1;
m:=m-1;
gotoxy(10,2);
end;
Minorii unei matrici
Să se scrie un subprogram care să afişeze minorii de n-1ai unei matrici.
Exemplu: pentru matricea A, subprogramul va afişa urmă torii minori:
1 2 3 5 4 6 4 6 5 2 3
A= 6 5 4 8 9 7 9 7 8 8 9
7 8 9
1 3 1 2 2 3 1 3
7 9 7 8 5 4 6 4
1 2
6 5
Vom folosi ştergerea liniei şi coloanei explicate mai sus, şi după fiecare ştergere a
unei liniii şi a unei coloane, vom afişa matricea iar după fiecare afişare vom iniţializa din
nou matricea.
procedure minori(var a,b:matrice;n,m,k,l:integer);

var i,j:byte;
begin
b:=a;
for k:=1 to n do
for l:=1 to m do
begin
for i:=k to n-1 do
for j:=1 to m do
a[i,j]:=a[i+1,j];
for i:=1 to n do
for j:=l to m-1 do
a[i,j] :=a[i,j+1];
textcolor(11);
Writeln('Un minor este: ');
for i:=1 to n-1 do
begin
for j:=1 to m-1 do
write(a[i,j]);
end;
writeln('Pentru a vizualiza urmatorul minor apasati o tasta');
readln;
a:=b;
end;
end;
Calcularea determinantului unei matrici
Să se scrie 2 subprograme care să calculeze determinantul unei matricei citite de la
tastatură . Se vor studia două cazuri determinatul matricilor de ordin 2 şi 3.
Exemplu: pentru matricea A de ordin 2 subrogramul va returna valoarea -2 iar
pentru matricea B de ordin 3 subprogramul va returna valoarea valoarea 0.
1 1 1
A= 3 4 B= 6 5 4
5 6
3 3 3
Matrici de ordin 2
function det2(var a:matrice):real;

var i,j:byte;
s:real;
begin
for i:=1 to 2 do
for j:=1 to 2 do
s:=a[1,1]*a[2,2]-a[1,2]*a[2,1];
det2:=s;
end;
Matrici de ordin 3
function det3(var a:matrice):real;

var i,j:byte;
s:real;
begin
for i:=1 to 3 do
for j:=1 to 3 do
s:=a[1,1]*a[2,2]*a[3,3]+a[2,1]*a[3,2]*a[1,3]+a[3,1]*a[1,2]*a[2,3]
-a[3,1]*a[2,2]*a[1,3]-a[1,1]*a[3,2]*a[2,3]-a[2,1]*a[1,2]*a[3,3];
det3:=s;
end;
Odonarea lexicografică a matricilor după linie/coloană
Să se scrie un subprograme care să afişeze matricea dată ordonată lexicografic după
elementele linilor.
Exemplu: pentru matricea A subrogramul va afişa matricea B.
4 2 1 1 2 4
A= 6 5 4 B= 4 5 6
3 5 7 3 5 7
Vom parcurge linile, unde k reprezintă numă rul de linii ce trebuiesc parcurse, şi
facem o sortare crescă toare a elementelor.
procedure ordonare_linie(var a:matrice;n,m:byte);

var i,j,k:byte;
aux:integer;
begin
for k:=1 to n do
begin
for i:=1 to m do
for j:=i+1 to m do
if a[k,i]>a[k,j] then begin
aux:=a[k,i];
a[k,i]:=a[k,j];
a[k,j]:=aux;
end;
end;
Să se scrie un subprograme care să afişeze matricea dată ordonată lexicografic după

elementele coloanelor.
Exemplu: pentru matricea A subrogramul va afişa matricea B.
4 2 1 3 1 1
A= 6 1 7 B= 4 2 4
3 5 4 6 5 7
procedure ordonare_coloana(var a:matrice;n,m:byte);

var i,j,k:byte;
aux:integer;
begin
for k:=1 to m do
begin
for i:=1 to n do
for j:=i+1 to n do
if a[i,k]>a[j,k] then begin
aux:=a[i,k];
a[i,k]:=a[j,k];
a[j,k]:=aux;
end;
end;
Determinarea minimului şi maximului din matrice

Să se scrie un subprograme care să afişeze valoarea maximă din matricea dată .
Exemplu: pentru matricea A subrogramul va afişa valoarea 7.
4 2 1
A= 6 1 7
3 5 4
Vom parcurge matricea linie cu linie şi coloană cu coloană şi vom compara toate
elementele din matrice, câ nd gă sim ceva mai mare atunci variabila max va lua valoarea
elementului favorabil.
procedure maxim(var a:matrice;n,m:integer);

var i,j:byte;
max:integer;
begin
max:=a[1,1];
for i:=1 to n do
for j:=1 to m do
if a[i,j]>max then max:=a[i,j];
writeln('Maximul este: ',max);
end;
Să se scrie un subprograme care să afişeze valoarea minimă din matricea dată .

Exemplu: pentru matricea A subrogramul va afişa valoarea -1.
4 2 1
A= 6 -1 7
3 5 4
procedure minim(var a:matrice;n,m:integer);

var i,j,min:integer;
begin
min:=a[1,1];
for i:=1 to n do
for j:=1 to m do
if a[i,j]<min then min:=a[i,j];
writeln('Minimul este: ', min);
end;
Matrici rare
Matricile rare sunt acele matrici care conţin în mare parte elemente nule. Adică ,
vorbim de matrici de dimensiuni mari (de ex: 100*100), care au în proporţie de 80%
elemente nule.
În acest caz declararea obişnuită este nefavorabilă din mai multe puncte de vedere:
1. Memoria este ocupată într-o proporţie mai mare decâ t este nevoie.
2. Elementele trebuie introduse fiecare pe râ nd, inclusiv cele nule, ceea ce nu este
de dorit.
3. Matricea rară , fiind o matrice de dimensiuni mari, nu vom putea declara o
matrice atâ t de mare înâ t să acoperim toate posibilită ţiile.
Astfel, este de preferat o metodă prin care să fie introduse toate elementele diferite
de 0, împreună cu locaţiile lor, dar în aşa fel încâ t acestea să poată fi folosite ca în cadul unei
matrici normale.
Vom folosi un fişier text în care pe prima linie să fie scris numă rul de linii şi coloane,
practic numă rul de elemente, iar pe urmatoarele linii, linia, coloana şi valoarea elementului
nenul de pe respectiva poziţie. Astfel ,în fişier vor apă rea doar numerele nenule, împreună
cu poziţia pe care se află .
Vom crea fişierul Rare.in, ce va fi folosit pentru rezolvarea tuturor problemelor din
secţiunea matricilor rare şi care va avea urmatoarea structură :
Rare.in
100 80 numă rul de linii şi coloane
10 40 3
2 2 5 a[10,40]=3, a[2,2]=5, a[7,60]=-2 ….
7 60 -2 Prima valoare este indicele liniei, a doua valoare indicele
40 40 7 coloanei iar a treia valoare este valoarea elementului de
23 5 -1 pe poziţia respectivă .
Suma elementelor de pe diagonala principală

Să se scrie un subprogram care să calculeze suma elementelor de pe diagonala
principală .
Exemplu: pentru matricea citită din fişierul Rare.in, explicat mai sus, subrogramul
va afişa valoarea 12.
După cum am mai vă zut elementele de pe diagonala principală au indicele liniei egal
cu indicele coloanei. Astfel, vom parcurge fişierul, vom reţine în 3 variabile, linia, coloana şi
elementul, iar dacă linia este egală cu coloana in variabila S se adună elementul.
procedure suma_2;
var n,m,i,j,x,sum:integer;
f:text;
begin
sum:=0;
assign(f,'Rare.in');
reset(f);
readln(f,n,m);
while not seekeof(f) do begin
readln(f,i,j,x);
if i=j then sum:=sum+x;
end;
close(f);
Writeln('Suma elementelor de pe diagonala principala este: ',sum);
end;
Suma elementelor de pe coloane impare

Să se scrie un subprogram care să calculeze suma elementelor de pe coloanele
impare.
Exemplu: pentru matricea citită din fişierul Rare.in, subrogramul va afişa valoarea
-1 (deoarece singura coloană impară este 5 iar elementul ce se gă seşte pe ea este -1).
Vom parcurge fişierul, iar pentru fiecare coloană impară gă sită se adună elemenul
corespunză tor ei.
procedure suma_1;
var n,m,i,j,x,sum:integer;
f:text;
begin
sum:=0;
reset(f);
readln(f,n,m);
readln(f,i,j,x);
if j mod 2<>0 then sum:=sum+x;
end;
close(f);
Writeln('Suma elementelor de pe coloane impare este: ',sum);
end;
Determinarea maximului din matrice
Să se scrie un subprogram care să determine maximul din matrice.
cea mai mare din fişier adică 7.
procedure max_rare;
var n,m,i,j,x,max:integer;
f:text;
begin
max:=0;
reset(f);
readln(f,n,m);
readln(f,i,j,x);
if x>max then max:=x;
end;
Writeln('Maximul din matrice este:',max);
end;
Determinarea minimului din matrice

Să se scrie un subprogram care să determine minimă din matrice.
cea mai mică din fişier adică -2.
procedure min_rare;
var n,m,i,j,x,min:integer;
f:text;
begin
min:=0;
reset(f);
readln(f,n,m);
readln(f,i,j,x);
if x<min then min:=x;
end;
close(f);
Writeln('Minimul din matrice este: ',min);
end;
Determinarea numă rului de elemente impare din matrice
Să se scrie un subprogram care să determine numă rul de elemente impare din
matrice.
4 (matricea avâ nd elemente impare pe 3, 5, 7, -1).
procedure impare_rare;
var n,m,i,j,x,k:integer;
f:text;
begin
k:=0;
reset(f);
readln(f,n,m);
readln(f,i,j,x);
if x mod 2<>0 then inc(k);
end;
close(f);
Writeln('Numarul elementelor impare din matrice: ',k);
end;
Determinarea numă rului de elemente din intervalul [a,b]

Să se scrie un subprogram care să determine numă rul de elemente din intervalul
[a,b], cu a şi b citite de la tastatură , ce apar în matrice.
Exemplu: pentru matricea citită din fişierul Rare.in, şi pentru intervalul [6,20]
subrogramul va afişa valoarea 1 (matricea avâ nd doar elementul 7 din intervalul dat).
procedure nr_rare;
var n,m,i,j,x,k,a,b:integer;
f:text;
begin
repeat
writeln('Se citesc capetele intervalului');
writeln('Dati capul intervalului');
readln(a);
writeln('Dati coada intervalului');
readln(b);
if a>b then
writeln('Interval incorect');
until(a<b);
k:=0;
reset(f);
readln(f,n,m);
readln(f,i,j,x);
if (x>=a)and(x<=b) then inc(k);
end;
close(f);
Writeln('Numarul de elemente din [',a,',', b,']:',k);
end;
CAPITOLUL IV Codul sursă
uses Crt,graph;
type matrice=array[1..100,1..100] of integer;
procedure interfata;
var grDriver: Integer;
grMode: Integer;
ErrCode: Integer;
s:string;
i,j,xx:integer;
begin
grDriver := Detect;
InitGraph(grDriver, grMode,'d:\limbaje\bp7\bgi\');
ErrCode := GraphResult;
if ErrCode = grOk then
begin
moveto(190,130);
setcolor(11);
setbkcolor(black);
settextstyle(1,0,1);
setusercharsize(2,1,2,1);
outtext('Matrici');
setcolor(9);
moveto(180,210);
outtext('Tablouri bidimensionale');
setcolor(9);
line(100,420,220,420);
line(100,420,100,300);
line(100,300,220,300);
line(220,300,220,420);
line(130,420,130,300);
line(160,420,160,300);
line(190,420,190,300);
line(100,330,220,330);
line(100,360,220,360);
line(100,390,220,390);
setcolor(11);
for i:=0 to 3 do
for j:=0 to 3 do
begin
randomize;
xx:=random(2);
str(xx,s);
outtextxy(110+30*(i mod 4),300+30*(j mod 4),s);
delay(500);
end;
setcolor(9);
line(250,420,370,420);
line(250,420,250,300);
line(250,300,370,300);
line(370,300,370,420);
line(280,420,280,300);
line(310,420,310,300);
line(340,420,340,300);
line(250,330,370,330);
line(250,360,370,360);
line(250,390,370,390);
setcolor(11);
for j:=0 to 3 do
for i:=0 to 3 do
begin
randomize;
xx:=random(5);
str(xx,s);
delay(500);
end;
setcolor(9);
line(400,420,520,420);
line(400,420,400,300);
line(400,300,520,300);
line(520,300,520,420);
line(430,420,430,300);
line(460,420,460,300);
line(490,420,490,300);
line(520,330,400,330);
line(520,360,400,360);
line(520,390,400,390);
setcolor(11);
for i:=1 to 4 do
for j:=1 to 4 do
begin
randomize;
xx:=random(1);
str(xx,s);
delay(500);
end;
moveto(150,440);
setcolor(4);
setusercharsize(3,2,3,5);
outtext('Apasati ENTER pentru a intra in meniu...');
Readln;
CloseGraph;
end;
end;
{program pincipal - meniul}
var n,i,j,k,m,l,sum:integer;
a,c,B:matrice;
opt,o:byte;
x,y,t:char;
d:real;
f:text;
grDriver: Integer;
grMode: Integer;
ErrCode: Integer;
begin
interfata;
textcolor(white);
textbackground(black);
clrscr;
repeat
textcolor(10);
gotoxy(2,2);
writeln('Sunteti in meniul principal');
gotoxy(30,8);
writeln('Alegeti optiunea:');
gotoxy(26,10);
textcolor(white);
writeln('1. Generari de matrici');
gotoxy(26,12);
writeln('2. Verificari de matrici');
gotoxy(26,14);
writeln('3. Operatii cu matrici');
gotoxy(26,16);
writeln('4. Matrici rare');
gotoxy(26,18);
Writeln('5. Help');
gotoxy(26,20);
writeln('0. Iesire');
textcolor(green);
gotoxy(15,24);
readln(opt);
textcolor(white);
case opt of
1:begin
clrscr;
repeat
textcolor(10);
gotoxy(2,2);
writeln('Sectiunea generari de matrici:');
gotoxy(29,10);
gotoxy(26,12);
textcolor(white);
writeln('1. Generare matrici nxm');
gotoxy(26,14);
writeln('2. Generare matrici patratice');
gotoxy(26,16);
writeln('0. Intoarcere');
textcolor(green);
gotoxy(15,24);
readln(o);
textcolor(white);
case o of
1:begin
clrscr;
repeat
textcolor(10);
gotoxy(2,2);
writeln('Sectiunea generari de matrici nxm');
gotoxy(28,9);
gotoxy(26,11);
textcolor(white);
writeln('a. Generare#1');
gotoxy(26,13);
writeln('b. Generare#2');
gotoxy(26,15);
writeln('c. Generare#3');
gotoxy(26,17);
textcolor(green);
gotoxy(15,24);
readln(x);
textcolor(green);
case x of
'a': generare_1(a,n,m);
'b': generare_2(a,n,m);
'c': generare_3(a,n,m);
end;
clrscr;
textcolor(white);
until x='0';
end;
2:begin
clrscr;
repeat
textcolor(10);
gotoxy(2,2);
writeln('Sectiunea generari de matrici patratice');
gotoxy(27,9);
textcolor(white);
gotoxy(25,11);
writeln('a. Generare#1');
gotoxy(25,13);
writeln('b. Generare#2');
gotoxy(25,15);
writeln('c. Generare#3');
gotoxy(25,17);
writeln('d. Generare#4');
gotoxy(25,19);
textcolor(green);
gotoxy(15,24);
readln(x);
textcolor(white);
case x of
'a':generarep_4(a,n);
'b':generarep_5(a,n);
'c':generarep_6(a,n);
'd':generarep_7(a,n);
end;
clrscr;
until x='0';
end;
end;
clrscr;
until o=0;
end;
2:begin
clrscr;
repeat
gotoxy(2,2);
textcolor(10);
Writeln('Sectiunea verificari');
gotoxy(24,7);
textcolor(white);
gotoxy(15,9);
writeln('1. Se verifica simetria unei matrici');
gotoxy(15,11);
writeln('2. Se verifica natura matricii');
gotoxy(15,13);
writeln('3. Se verifica daca matricea A este opusa matricii B');
gotoxy(15,15);
writeln('4. Se verifica daca matricea A este transpusa matricii B');
gotoxy(15,17);
writeln('5. Se verifica daca e triunghiulara');
gotoxy(15,19);
writeln('6. Se verifica daca e matrice melc');
gotoxy(15,21);
writeln('7. Se verifica daca e inversabila');
gotoxy(15,23);
textcolor(green);
gotoxy(15,24);
readln(o);
textcolor(white);
case o of
1:begin
clrscr;
repeat
gotoxy(2,2);
textcolor(10);
writeln('Sectiunea verifica simetria');
gotoxy(7,9);
writeln('Alegeti optiunea');
gotoxy(5,11);
textcolor(white);
writeln('a. Se verifica daca matricea e simetrica fata de diagonala principala');
gotoxy(5,13);
writeln('b. Se verifica daca matricea este antisimetrica');
gotoxy(5,15);
writeln('c. Se verifica daca matricea e simetrica fata de linia de mijloc verticala');
gotoxy(5,17);
writeln('d. Se verifica daca matricea e simetrica fata de linia de mijloc orizontala');
gotoxy(5,19);
textcolor(green);
gotoxy(15,24);
readln(x);
textcolor(white);
case x of
'a':verifica_1(a,n,m);
'b':verifica_antisimetrica(a,n,m);
'c':simetrie_verticala(a,n,m);
'd':simetrie_orizontala(a,n,m);
end;
clrscr;
until x='0';
end;
2:begin
clrscr;
repeat
gotoxy(2,2);
textcolor(10);
writeln('Sectiunea verifica natura matricii');
gotoxy(27,7);
gotoxy(25,9);
textcolor(white);
writeln('a. Matrice nula');
gotoxy(25,11);
writeln('b. Matrice linie');
gotoxy(25,13);
writeln('c. Matrice coloana');
gotoxy(25,15);
writeln('d. Matrice patratica');
gotoxy(25,17);
writeln('e. Matrice unitate');
gotoxy(25,19);
writeln('f. Matrice diagonala');
gotoxy(25,21);
textcolor(green);
gotoxy(15,24);
readln(x);
textcolor(white);
case x of
'a':verifica_2(a,n,m);
'b':verifica_3(a,n,m);
'c':verifica_4(a,n,m);
'd':verifica_5(a,n,m);
'e':verifica_uni(a,n,m);
'f':verifica_diag(a,n,m);
end;
clrscr;
until x='0';
end;
3:verifica_opusa(a,b,n,m,k,l);
4:verifica_transp(a,b,n,m,k,l);
5:begin
clrscr;
repeat
gotoxy(2,2);
textcolor(10);
writeln('Sectiunea verifica triunghiulara');
gotoxy(25,9);
gotoxy(23,11);
textcolor(white);
writeln('a. Triunghiulara superior');
gotoxy(23,13);
writeln('b. Triunghiulara inferior');
gotoxy(23,15);
textcolor(green);
gotoxy(15,24);
readln(x);
textcolor(white);
case x of
'a':verifica_tri_sup(a,n,m);
'b': verifica_tri_inf(a,n,m)
end;
clrscr;
until x='0';
end;
6:verifica_melc(a,n,m);
7:begin
clrscr;
repeat
textcolor(10);
gotoxy(2,2);
writeln('Sectiunea verificare inversabila');
gotoxy(28,9);
writeln('Alegeti o optiunea:');
gotoxy(26,11);
textcolor(white);
writeln('a. Matrice de ordinul 2');
gotoxy(26,13);
writeln('b. Matrice de ordinul 3');
gotoxy(26,15);
textcolor(green);
gotoxy(15,24);
readln(x);
textcolor(white);
case x of
'a':verif_inv2(a,n,m);
'b':verif_inv3(a,n,m);
end;
clrscr;
until x='0';
end;
end;
clrscr;
until o=0;
end;
3:begin
clrscr;
repeat
gotoxy(2,2);
textcolor(10);
writeln('Sunteti in sectiunea operatii cu matrici:');
gotoxy(25,4);
gotoxy(23,5);
textcolor(white);
writeln('1. Adunarea a 2 matrici');
gotoxy(23,7);
writeln('2. Scadeare a 2 matrici');
gotoxy(23,9);
writeln('3. Produsul a 2 matrici');
gotoxy(23,11);
writeln('4. Produsul unei matrici cu un scalar');
gotoxy(23,13);
writeln('5. Transpusa unei matrici');
gotoxy(23,15);
writeln('6. Stergere');
gotoxy(23,17);
writeln('7. Calcularea determinantului');
gotoxy(23,19);
writeln('8. Ordonare lecicografica');
gotoxy(23,21);
writeln('9. Determinare min si max din matrice');
gotoxy(23,23);
writeln('10. Minorii matricii');
gotoxy(23,25);
textcolor(green);
gotoxy(15,26);
readln(o);
textcolor(white);
case o of
1: suma(a,b,n,m,k,l,c);
2:diferenta(a,b,n,m,k,l,c);
3:produs(a,b,n,m,k,l,c);
4:prod_scalar(a,n,m,k,c);
5:transpusa(a,n,m);
6:begin
clrscr;
repeat
textcolor(10);
gotoxy(2,2);
writeln('Sectiunea stergere');
gotoxy(25,9);
writeln('Alegeti o optiune');
gotoxy(23,11);
textcolor(white);
writeln('a. Stergerea liniei');
gotoxy(23,13);
writeln('b. Stergerea coloanei');
gotoxy(23,15);
writeln('c. Stergerea liniei si coloanei');
gotoxy(23,17);
textcolor(green);
gotoxy(15,24);
readln(x);
textcolor(white);
clrscr;
case x of
'a':stergere(a,n,m,k);
'b':stergere_2(a,n,m,k);
'c': stergere_3(a,n,m,k,l);
end;
clrscr;
until x='0';
end;
7:begin
clrscr;
repeat
gotoxy(2,2);
textcolor(10);
writeln('Sectiunea determinant');
gotoxy(27,9);
gotoxy(25,11);
textcolor(white);
writeln('a. Matrici de ordin 2');
gotoxy(25,13);
writeln('b. Matrici de ordin 3');
gotoxy(25,15);
writeln('0. Pentru intoarcere');
textcolor(green);
gotoxy(15,24);
readln(x);
textcolor(white);
clrscr;
case x of
'a':begin
clrscr;
gotoxy(5,5);
writeln('Se citeste matricea');
n:=2;
citire_mat_patrat(n,a);
clrscr;
d:=det2(a);
gotoxy(10,2);
textcolor(11);
writeln('D=',d:8:2);
textcolor(12);
writeln;
writeln('Apasati o tasta pentru a continua...');
textcolor(green);
readln;
textcolor(white);
end;
'b':begin
clrscr;
gotoxy(5,5);
writeln('Se citeste matricea');
n:=3;
citire_mat_patrat(n,a);
clrscr;
d:=det3(a);
gotoxy(10,2);
textcolor(11);
writeln('D=',d:8:2);
textcolor(12);
writeln;
writeln('Apasati o tasta pentru a continua...');
textcolor(green);
readln;
textcolor(white);
end;
end;
clrscr;
until x='0';
end;
8:begin
clrscr;
repeat
gotoxy(2,2);
textcolor(10);
writeln('Sectiunea ordonare lexicografica');
gotoxy(25,9);
gotoxy(23,11);
textcolor(white);
writeln('a. Ordonarea lexicografica a elementelor de pe linii');
gotoxy(23,13);
writeln('b. Ordonarea lexicografica a elementelor de pe coloane');
gotoxy(23,15);
textcolor(green);
gotoxy(15,24);
readln(x);
textcolor(white);
clrscr;
case x of
'a':ordonare_linie(a,n,m);
'b':ordonare_coloana(a,n,m);
end;
clrscr;
until x='0';
end;
9:begin
clrscr;
repeat
gotoxy(2,2);
textcolor(10);
writeln('Sectiunea determinare min si max');
gotoxy(25,9);
gotoxy(23,11);
textcolor(white);
writeln('a. Determinarea minimului din matrice');
gotoxy(23,13);
writeln('b. Determinarea maximului din matrice');
gotoxy(23,15);
textcolor(green);
gotoxy(15,24);
textcolor(green);
readln(x);
textcolor(white);
clrscr;
case x of
'a':minim(a,n,m);
'b':maxim(a,n,m);
end;
clrscr;
until x='0';
end;
10:minori(a,b,n,m,k,l);
end;
clrscr;
until o=0;
end;
4:begin
clrscr;
repeat
gotoxy(2,2);
textcolor(10);
writeln('Sunteti in sectiunea matrici rare:');
gotoxy(28,8);
gotoxy(23,10);
textcolor(white);
writeln('1. Suma elementelor de pe diagonala principala');
gotoxy(23,12);
writeln('2. Suma elementelor de pe coloane impare');
gotoxy(23,14);
writeln('3. Maximul din matrice');
gotoxy(23,16);
writeln('4. Minimul din matrice');
gotoxy(23,18);
writeln('5. Numarul de elemente impare din matrice');
gotoxy(23,20);
writeln('6. Numarul de elemente din intervalul [a,b]');
gotoxy(23,22);
textcolor(green);
gotoxy(15,24);
readln(o);
textcolor(white);
case o of
1:suma_2;
2:suma_1;
3:max_rare;
4:min_rare;
5:impare_rare;
6:nr_rare;
end;
clrscr;
until o=0;
end;
5:help;
end;
until(opt=0);
end.
CAPITOLUL V Bibliografie
 Manual de clasa a X-a intensiv;
Autor: George Daniel Mateescu, Pavel Florin Moraru
 Manual de clasa a XI-a neintensiv;
Autor: George Daniel Mateescu, Pavel Florin Moraru
 Informatică intensiv: Manual pentru clasa a XI-a
Autor: Mariana Milosescu

Vizitiu Anamaria

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Vizitiu Anamaria

Uploaded by

Copyright:

Available Formats

Colegiul Naţional „Mihai Viteazul”

Sfâ ntu Gheorghe, judeţul Covasna

Elev: Vizitiu Anamaria

CAPITOLUL II - Noţiuni introductive.....................................4

CAPITOLUL III - Descrierea programului.............................8

CAPITOLUL IV - Codul sursă ....................................................37

CAPITOLUL I Prezentarea lucră rii

De asemenea am vrut sa îmi aprofundez cunoştinţele despre matrici şi

CAPITOLUL II Noţiuni introductive

Declararea unei matrici

Dacă notă m variabila matrice cu a, atunci elementul de pe linia i şi coloana j în

Ilustrez în continuare o matrice a cu 3 linii şi 4 coloane, avâ nd ca elemente numere

De exemplu pentru o matrice a cu n linii şi m coloane, elementele ei sunt:

Parcurgerea unei matrici

i=1 j=1 a[1,1]

Citirea unei matrici de la tastatură

procedure citire_mat_patrat(n:integer;var a:matrice);

Citirea unei matrici dintr-un fişier

Afişarea unei matrici

procedure afisare_mat(n,m:integer;var a:matrice);

CAPITOLUL III Descrierea programului

a. Să se se scrie un subprogram care să genereze o matrice cu n linii şi m coloane, astfel

procedure generare_1(var a:matrice;n,m:integer);

procedure generare_2(var a:matrice;n,m:integer);

Se atribuie elementelor de pe fiecare linie din matrice o valoare k , iniţializată cu 1 şi

procedure generare_3(var a:matrice;n,m:integer);

inc(k); se creşte k cu o unitate

Generă ri matrici cu n linii şi n coloane (matrici pă tratice)

a. Să se se scrie un subprogram care să genereze o matrice cu n linii şi n coloane, ca în

Se iniţializează matricea cu 0, pentru că prima linie, prima coloană , ultima linie şi

procedure generarep_4(var a:matrice;n:integer);

b. Să se scrie un subprogram care să genereze o matrice cu n linii şi n coloane în care

procedure generarep_5(var a:matrice;n:integer);

c. Să se scrie un subprogram care să genereze o matrice cu n linii şi n coloane, o

Se iniţializează matricea cu 0, se începe parcurgerea liniei,

procedure generarep_6(var a:matrice;n:integer);

Se parcurge linia şi apoi coloana pâ nă la elementul de pe

procedure generarep_7(var a:matrice;n:byte);

2. Să se scrie un subprogram care să verifice dacă o matrice citită de la tastatură este

Pentru rezolvarea acestei probleme se va folosii un vector care va reţine elementele

function verifica_melc(var a:matrice;n,m:byte):boolean;

a. Să se scrie un subprogram care să verifice dacă o matrice citită de la tastatură este o

function verifica_1(var a:matrice;n,m:integer):boolean;

b. Să se scrie un subprogram care să verifice dacă o matrice citită de la tastatură este

c. Să se scrie un subprogram care să verifice dacă o matrice citită de la tastatură este

function simetrie_verticala(var a:matrice;n,m:integer):boolean;

d. Să se scrie un subprogram care să verifice dacă o matrice citită de la tastatură este

Verificarea naturii unei matrici

a. Să se scrie un subprogram care să verifice dacă matricea citită de la tastatura este o

function verifica_5(var a:matrice;n,m:integer):boolean;

b. Să se scrie un subprogram care să verifice dacă matricea citită de la tastatură este o

function verifica_3(var a:matrice;n,m:integer):boolean;

function verifica_4(var a:matrice;n,m:integer):boolean;

d. Să se scrie un subprogram care să verifice dacă matricea citită de la tastatură este o

function verifica_2(var a:matrice;n,m:integer):boolean;

function verifica_uni(var a:matrice;n,m:integer):boolean;

f. Să se scrie un subprogram care să verifice dacă matricea citită de la tastatură este o

function verifica_diag( var a:matrice;n,m:integer):boolean;

g. Să se scrie un subprogram care să verifice dacă matricea citită de la tastatură este o

function verifica_tri_sup(var a:matrice;n,m:integer):boolean;

h. Să se scrie un subprogram care să verifice dacă matricea citită de la tastatură este o

function verifica_tri_inf(var a:matrice;n,m:integer):boolean;

i. Să se scrie 2 subprograme care să verifice dacă matricea citită de la tastatură este o

Vom discuta prima data de matricile de ordin 2. Vom crea o