Tematica şedinţei de laborator nr.

11
PROGRAME TURBO PASCAL

1. Calculul produsului a două matrice

Programul pentru calculul produsului a două matrice A(m,p)*B(p,n) = C(m,n), se bazează pe
următorul algoritm:
1. Citeşte dimensiunile matricelor A şi B şi elementele fiecărei matrice;
2. Calculează elementele matricei produs C;
3. Afişează matricea produs.
Pentru a reţine elementele matricelor A, B şi C se declară un tip de date tablou cu două
dimensiuni, care pentru matricea A trebuie să fie de forma array[1..m, 1..p] of real. Elementul
a[i,k] este situat pe linia i şi coloana k a matricei A. În limbajul de programare Turbo Pascal
indicii sunt asemănători în multe privinţe cu indicii matematici care, în notaţia convenţională, se
scriu în partea din dreapta jos a elementului, fără paranteze - aik.
Pentru a citi elementele matricelor A şi B se folosesc instrucţiuni repetitive For imbricate.
Elementele matricelor se citesc pe linii, începând cu prima dintre acestea. Pentru fiecare valoare
a variabilei contor a ciclului For exterior, se va executa în întregime ciclul For din interior.
Astfel, elementele matricei A se vor citi în ordinea: a[1,1], a[1,2], a[1,3],..., a[1,p], a[2,1],
a[2,2],..., a[2,p],..., a[m,1], a[ m,2],..., a[m,p]. Regula de execuţie a ciclurilor For imbricate
rămâne valabilă şi în cazul imbricării a trei instrucţiuni For, cum este cazul instrucţiunilor care
realizează calculul elementelor matricei produs C.

Program produsul_a_doua_matrice; {Varianta 1}

type
matrice=array[1..30,1..30] of real;
var
i,j,k,m,n,p: integer;
a,b,c: matrice;
begin
write ('Numarul de linii al matricei A='); readln (m);
write ('Numarul de coloane al matricei B='); readln (n);
write ('Numarul de linii al matricei B si de coloane pentru A='); readln (p);
writeln ('Precizati elementele matricei A:');
for i:=1 to m do
for k:=1 to p do
begin
write ('a(',i,',',k,')=');
readln (a[i,k]);
end;
writeln ('Precizati elementele matricei B:');
for k:=1 to p do
for j:=1 to n do
begin
write ('b(',k,',',j,')=');
readln (b[k,j]);
end;
for i:=1 to m do
for j:=1 to n do
begin
 c[i,j]:=0;
for k:=1 to p do
c[i,j]:=c[i,j]+a[i,k]*b[k,j];
end;
writeln ('Matricea C:');
for i:=1 to m do
begin
for j:=1 to n do
write (' c(',i,',',j,')=',c[i,j]:6:2);
writeln;
end;
end.

Numarul de linii al matricei A=3

Numarul de coloane al matricei B=2
Numarul de linii al matricei B si de coloane pentru A=3
Precizati elementele matricei A:
a(1,1)=5
a(1,2)=3
a(1,3)=6
a(2,1)=4
a(2,2)=0
a(2,3)=8
a(3,1)=9
a(3,2)=4
a(3,3)=11
Precizati elementele matricei B:
b(1,1)=-2
b(1,2)=6
b(2,1)=-3
b(2,2)=8
b(3,1)=9
b(3,2)=4
Matricea C:
c(1,1)= 35.00 c(1,2)= 78.00
c(2,1)= 64.00 c(2,2)= 56.00
c(3,1)= 69.00 c(3,2)=130.00

În programul prezentat mai sus se repetă o serie de instrucţiuni asemănătoare de citire a

elementelor celor două matrice, ceea ce se poate evita prin declararea unei proceduri de citire a
elementelor unei matrice, care să aibă ca parametri formali matricea ale cărei elemente se vor citi
şi dimensiunile matricei. Pentru ca elementele matricei să fie transmise în afara corpului
procedurii, parametrul formal care se referă la matrice se declară ca parametru variabilă cu tip. În
plus, mai apare un parametru valoare de tip caracter care precizează numele matricei ce se
citeşte. Pentru precizarea dimensiunilor celor două matrice s-a declarat o procedură apelată în
programul principal în cadrul unui ciclu repetitiv Repeat care asigură respectarea condiţiei ca
numărul de coloane al matricei A să fie egal cu numărul de linii al matricei B.
Mai jos este prezentată o variantă a programului pentru calculul produsului a două matrice
care conţine declaraţii şi apeluri de proceduri, prin a cărui rulare se obţine acelaşi rezultat ca şi în
cazul programului nestructurat.
 2. Descompunerea unui număr în factori primi
Programul pentru descompunerea unui număr în factori primi se bazează pe următorul
algoritm:
1. Citeşte numărul care va fi descompus în factori primi;
2. Găseşte un factor prim;
3. Determină exponentul factorului prim găsit anterior;
4. Repetă paşii 2 şi 3 până la descompunerea completă a numărului în factori primi;
5. Afişează rezultatul descompunerii numărului în factori primi şi, eventual, reia execuţia
programului pentru a descompune un alt număr.
Execuţia programului care codifică algoritmul verifică la pasul 2, la prima parcurgere a
instrucţiunilor, dacă primul factor prim posibil, 2, divide numărul de descompus.
Variabila prin care se identifică în program factorii primi este i. La începutul programului
variabila i se iniţializează cu 1, dar valoarea ei se incrementează cu 1, în mod succesiv, până ce
numărul de descompus se divide la i (restul împărţirii numărului la i este 0), ceea ce înseamnă că
s-a identificat un factor prim reprezentat de i. Exponentul factorului prim găsit este 1, dar se
iniţializează cu 0 pentru a fi majorat cu 1 într-un ciclu care se repetă atât timp cât numărul iniţial
sau câturile obţinute prin împărţire la i conduc la restul 0.
Variabilei m care reţine numărul iniţial de descompus i se atribuie succesiv valoarea câtului
împărţirii lui m la factorul prim identificat prin i, astfel încât în urma găsirii tuturor factorilor
primi şi a exponenţilor lor, variabila m va avea valoarea 1. Deci, condiţia de ieşire din bucla
repetitivă amintită la punctul 4 al algoritmului este îndeplinită când expresia logică m=1 are
valoarea “adevărat”.
De remarcat că variabila i prin care se identifică factorii primi are pe parcursul execuţiei şi
valori diferite de factorii primi, întrucât ea se majorează în mod repetat cu 1.
Algoritmul prezentat mai sus stă la baza redactării în două variante a programului pentru
descompunerea unui număr în factori primi.
În prima variantă, factorii primi şi exponenţii corespunzători fiecărui factor prim se reţin în
câte o variabilă de tip tablou cu o singură dimensiune. Indicele unui factor prim din şirul
factorilor primi este egal cu indicele exponentului său din şirul exponenţilor.
În varianta a doua de redactare a programului, factorii şi exponenţii sunt variabile de tip
întreg (integer) şi sunt afişaţi pe ecran pe măsură ce sunt găsiţi.

Program descompunere_în_factori_primi; {Varianta 1}

uses CRT;
type
vector = array[1..50] of integer;
var
factori,exponenti: vector;
m: longint;
n,i,r,c: integer;
cont: char;
begin
repeat
repeat
write('Introdu M=');
read(m);
until (m<>0) and (m<>1);
if m<0
then
m:=-m;
n:=0;
 i:=1;
repeat
repeat
i:=i+1;
r:=m mod i;
until r=0;
n:=n+1;
factori[n]:=i;
exponenti[n]:=0;
repeat
exponenti[n]:=exponenti[n]+1;
m:=m div i;
r:=m mod i;
until (r<>0) or (m=1);
until m=1;
i:=0;
repeat
i:=i+1;
writeln('F(',i,')=',factori[i],' E(',i,')=',exponenti[i]);
until i=n;
write ('Continuati(da=1/nu=0):');
cont:=readkey;
until cont='0';
end.

Introdu M=360
F(1)=2 E(1)=3
F(2)=3 E(2)=2
F(3)=5 E(3)=1
Continuati(da=1/nu=0):

3. Sortarea unui şir de valori în ordine crescătoare

Considerăm şirul X de N elemente pe care dorim să-l ordonăm crescător. Pentru aceasta
parcurgem şirul comparând, din aproape în aproape, vecinătăţile Xi şi Xi+1. Dacă cele două
elemente se opun criteriului de ordonare (crescătoare sau descrescătoare), ele îşi schimbă
locurile. Pentru a nu pierde conţinutul elementului receptor schimbarea se realizează prin
intermediul unei variabile ajutătoare (XAUX). Este uşor de înţeles că, în multe cazuri, trebuie să
parcurgem şirul de mai multe ori. Pentru “a şti” dacă mai este necesară continuarea procesului de
comparare, se verifică valoarea unui comutator COMU. Acesta ia valoarea 0 la fiecare revenire
la începutul şirului, şi este setat pe 1 pentru orice schimbare de vecinătăţi. Este evident faptul că
nu are importanţă de câte ori COMU ia valoarea 1, important este numai faptul că, dacă nu are
loc nici o schimbare, COMU rămâne cu valoarea 0, ceea ce înseamnă că şirul este ordonat.
Ne mai propunem ca în final să afişăm atât conţinutul iniţial al şirului X, cât şi locul ocupat
de fiecare element după sortare. În tabelul 3.1 se poate urmări cum se modifică şirul X de 7
poziţii în procesul de ordonare. Programul ordonare cere, mai întâi, numărul de elemente N din
şir (primul ciclu Repeat ... Until), apoi elementele şirului Xi (primul ciclu For). Elementele
şirului X sunt copiate în şirul Z, pentru păstrarea conţinutului iniţial, deoarece în procesul
ordonării el íşi schimbă configuraţia, iar în şirul Y se înscriu poziţiile de la 1 la N (al doilea ciclu
For). După iniţializarea variabilei NV cu valoarea N-1, reprezentând limita de parcurgere a
şirului, urmează un ciclu Repeat ... Until, de reluare a şirului, cu COMU=0. În interiorul acestui
ciclu, un alt ciclu, For, realizează compararea vecinătăţilor. Dacă acestea îşi schimbă locurile, se
schimbă şi poziţiile corespunzătoare din şirul Y, folosind variabila YAUX.
În final, programul afişează elementele şirului iniţial Z şi elementele şirului ordonat X,
indicând pentru fiecare element, atât locul final, cât şi cel iniţial.

Program ordonare;
uses CRT;
type
vector= array[1..50] of real;
vectory=array[1..50] of integer;
var
n,i,j,comu,nv,yaux: integer;
xaux: real;
x,z: vector;
y: vectory;
begin
repeat
write (‘Introduceti N=’);
read (n);
until n>1;
writeln (‘Introduceti sirul X’);
for i:=1 to n do
begin
write (‘x(‘,i,’)=’);
read (x[i]);
end;
for i:=1 to n do
begin
z[i]:=x[i];
y[i]:=i;
end;
nv:=n-1;
repeat
comu:=0;
for i:=1 to nv do
begin
j:=i+1;
if x[i] > x[j]
then
begin
xaux:=x[i];
yaux:=y[i];
x[i]:=x[j];
y[i]:=y[j];
x[j]:=xaux;
y[j]:=yaux;
comu:=1;
end;
end;
until comu=0;
writeln (‘Sirul initial’);
 for i:=1 to n do
write (‘z(‘,i,’)=’,z[i]: 6: 2,’; ‘);
writeln(‘ ‘);
writeln (‘Sirul ordonat’);
for i:=1 to n do
write (‘x(‘,i,’/’,y[i],’)=’,x[i]: 6: 2,’; ‘)
end.

Introduceti N=6
Introduceti sirul X
x(1)=173.5
x(2)=-2.07
x(3)=-35.0
x(4)=-11.0
x(5)=0.0
x(6)=4.10
Sirul initial
z(1)=173.50; z(2)= -2.07; z(3)=-35.00; z(4)=-11.00; z(5)= 0.00; z(6)= 4.10;
Sirul ordonat
x(1/3)=-35.00; x(2/4)=-11.00; x(3/2)= -2.07; x(4/5)= 0.00; x(5/6)= 4.10; x(6/1)=173.50;

Modificarea şirului X şi a comutatorului COMU în timpul execuţiei

Tabel 3.1.
X
COMU I
1 2 3 4 5 6 7
0 1 173.5 -2.07 14 -35 -11 0 4.1
1 2 -2.07 173.5 14 -35 -11 0 4.1
1 3 -2.07 14 173.5 -35 -11 0 4.1
1 4 -2.07 14 -35 173.5 -11 0 4.1
1 5 -2.07 14 -35 -11 173.5 0 4.1
1 6 -2.07 14 -35 -11 0 173.5 4.1
0 1 -2.07 14 -35 -11 0 4.1 173.5
0 2 -2.07 14 -35 -11 0 4.1 173.5
1 3 -2.07 -35 14 -11 0 4.1 173.5
... ... ..... ..... ..... ..... ..... ..... .....
0 6 -35 -11 -2.07 0 4.1 14 173.5