2.

Subprograme interne

2.1. Fie o matrice de dimensiuni mxn, reprezentând consumurile de energie

pentru fabricarea a m produse într-o perioada de n zile. Sa se scrie programul
Pascal care afiseaza pe monitor produsele care au înregistrat consumuri
constante pe întreaga perioada. Determinarea produselor care îndeplinesc
conditia ceruta se va realiza într-un subprogram.
Subprogramul este de tip procedura si are ca parametri de intrare: numarul
de produse (m), numarul de zile (n) si matricea consumurilor (a), iar ca parametri
de iesire: vectorul cu pozitiile produselor care îndeplinesc conditia ceruta (v) si
numarul acestora (p≥0). Matricea consumurilor este parcursa în subprogram
lexicografic.

program consumuri;
type matrice=array[1..15,1..20] of real;
vector=array[1..15] of byte;
var a:matrice; r:vector; m,n,i,j,k:byte;
procedure consumuri_constante(m,n:byte; a:matrice;
var p:byte; var v:vector);
var i,j:byte; x:real;
begin
p:=0;
for i:=1 to m do
begin
x:=a[i,1]; j:=2;
while (j<=n) and (a[i,j]=x) do inc(j);
if j>n then begin inc(p); v[p]:=i end
end
end;
{program principal}
begin
write(’Nr. de produse:’); readln(m);
write(’Nr. de zile: ’); readln(n);
for i:=1 to m do
for j:=1 to n do
begin
write(’consum [’,i,’,’,j,’]= ’);
readln(a[i,j])
end;
consumuri_constante(m,n,a,k,r);
if k<>0 then begin
write(’Produsele cu consumuri constante:’);
for i:=1 to k do write(r[i]:3)
end
else
writeln(’Nu exista produse cu consumuri constante!’)
end.
 Algoritmi în programare. Aplicatii

2.2. Fie o matrice de dimensiuni mxn, reprezentând vânzarile valorice a m

produse într-o perioada de n zile. Sa se scrie programul Pascal care afiseaza
pe monitor zilele în care nu s-au înregistrat vânzari. Determinarea zilelor care
îndeplinesc conditia ceruta se va realiza într-un subprogram.
Subprogramul este de tip procedura si are ca parametri de intrare: numarul
de produse (m), numarul de zile (n) si matricea vânzarilor (a), iar ca parametri de
iesire: vectorul cu zilele care îndeplinesc conditia ceruta (v) si numarul acestora
(p≥0). Matricea vânzarilor este parcursa în subprogram invers lexicografic.

program vanzari;
uses crt;
type matrice=array[1..15,1..20] of real;
vector=array[1..20] of byte;
var a:matrice; r:vector; m,n,i,j,k:byte;
procedure zile_fara_vanzari(m,n:byte; a:matrice;
var p:byte; var v:vector);
var i,j:byte;
begin
p:=0;
for j:=1 to n do
begin
i:=1;
while (i<=m) and (a[i,j]=0) do inc(i);
if i>m then begin
inc(p);
v[p]:=j
end
end
end;
{program principal}
begin
clrscr;
write(’Nr. de produse:’); readln(m);
write(’Nr. de zile: ’); readln(n);
for i:=1 to m do
for j:=1 to n do begin
write(’vanzari [’,i,’,’,j,’]=’);
readln(a[i,j])
end;
zile_fara_vanzari(m,n,a,k,r);
if k<>0 then begin
write(’Zilele fara vanzari sunt:’);
for i:=1 to k do write(r[i]:3)
end
else
writeln(’Nu exista zile fara vanzari!’);
readln
end.
Subprograme interne

2.3. Fie o matrice de dimensiuni mxn, reprezentând notele obtinute de m

studenti la n discipline. Sa se scrie programul Pascal care afiseaza pe monitor
mediile studentilor integralisti. Determinarea studentilor care îndeplinesc
conditia ceruta se va realiza într-un subprogram.
Subprogramul este de tip procedura si are ca parametri de intrare: numarul
de studenti (m), numarul de discipline (n) si matricea notelor (a), iar ca parametri
de iesire: vectorul cu pozitiile studentilor integralisti (s), vectorul cu mediile
acestora (v) si numarul de studenti care îndeplinesc conditia ceruta (p≥0). Matricea
notelor este parcursa lexicografic în subprogram. Un student integralist are note de
trecere la toate disciplinele.

program note_discipline;
uses crt;
type
matrice=array[1..15,1..20] of 0..10;
vector=array[1..15] of byte;
vector1=array[1..15] of real;
var a:matrice;
r:vector1;
s:vector;
m,n,i,j,k:byte;
procedure medii_integralisti(m,n:byte; a:matrice;
var p:byte; var v:vector1; var s:vector);
var i,j:byte; ss:real;
begin
p:=0;
for i:=1 to m do
begin
j:=1;
ss:=0;
while (j<=n) and (a[i,j]>4) do begin
ss:=ss+a[i,j];
inc(j)
end;
if j>n then
begin
inc(p);
v[p]:=ss/n;
s[p]:=i
end
end
end;
{program principal}
begin
clrscr;
write(’Nr. de studenti: ’); readln(m);
write(’Nr. de discipline:’); readln(n);
for i:=1 to m do
 Algoritmi în programare. Aplicatii

begin
writeln(’Studentul ’,i);
for j:=1 to n do begin
write(’nota la disciplina ’,j,’= ’);
readln(a[i,j])
end;
end;
medii_integralisti(m,n,a,k,r,s);
if k<>0 then
begin
writeln(’Mediile studentilor integralisti sunt:’);
for i:=1 to k do
writeln(’studentul’,s[i]:2,’ cu media’,r[i]:6:2)
end
else writeln(’Nu exista studenti integralisti!’);
readln
end.

2.4. Fie o matrice de dimensiuni mxn reprezentând profiturile nete obtinute de

m societati comerciale într-o perioada de n ani. Sa se scrie programul Pascal
care afiseaza pe monitor societatile care au înregistrat profitul net maxim în
perioada analizata. Determinarea societatilor care îndeplinesc conditia ceruta
se va realiza într-un subprogram.
Subprogramul este de tip procedura si are ca parametri de intrare: numarul
de societati(m), numarul de ani (n) si matricea profiturilor nete (a), iar ca parametri
de iesire: profitul net maxim (max), vectorul cu pozitiile societatilor care au
înregistrat profitul maxim (s) si numarul de societati care au îndeplinit conditia
(p≥1). Matricea profiturilor este parcursa lexicografic în subprogram. Profitul
maxim se calculeaza din profiturile cumulate pe n ani de fiecare societate în parte.
Maximul si pozitiile aparitiei lui se determina în etape distincte.

program profituri_nete;
uses crt;
type
matrice=array[1..15,1..20] of real;
vector=array[1..15] of byte;
vector1=array[1..15] of real;
var
a:matrice;
r:vector1;
s:vector;
m,n,i,j,k:byte;
c:real;
procedure profit_maxim(m,n:byte; a:matrice; var p:byte;
var max:real; var s:vector);
var
i,j:byte;
x:vector1;
Subprograme interne

begin
for i:=1 to m do
begin
x[i]:=0;
for j:=1 to n do x[i]:=x[i]+a[i,j];
if i=1 then max:=x[i]
else if x[i]>max then max:=x[i];
end;
p:=0;
for i:=1 to m do
if x[i]=max then begin inc(p); s[p]:=i end
end;
{program principal}
begin
clrscr;
write(’Nr. de societati:’); readln(m);
write(’Nr. de ani: ’); readln(n);
for i:=1 to m do begin
writeln(’Societatea ’,i);
for j:=1 to n do begin
write(’profitul net in anul ’,j,’= ’);
readln(a[i,j])
end
end;
profit_maxim(m,n,a,k,c,s);
writeln(’Profitul net maxim este ’,c:8:2);
write(’Societatile care l-au inregistrat: ’);
for i:=1 to k do write(s[i]:4)
end.

2.5. Sa se elaboreze un program Pascal care sa includa un subprogram pentru

determinarea liniilor unei matrice dreptunghiulare care au elem entele în
progresie aritmetica.
Subprogramul este de tip procedura si are ca parametri de intrare: matricea
de elemente reale (a), numarul de linii (m) si numarul de coloane (n), iar ca
parametri de iesire: un vector de elemente logice (v) în care vi este true daca linia
i este progresie aritmetica si false în caz contrar si un indicator de eroare (er )
care returneaza true daca numarul de coloane este mai mic decât 3 (numarul
minim de termeni necesari) . Matricea este parcursa lexicografic în subprogram.
Citirea si afisarea datelor de intrare/iesire se realizeaza în programul principal.

program determinare_linii_in_progresie;
uses crt;
type
matrice=array[1..10,1..15] of real;
vector=array[1..10] of boolean;
var a:matrice;
v:vector;
 Algoritmi în programare. Aplicatii

vb:boolean;
i,j,k,m,n:byte;
procedure linii_pa(m,n:byte; a:matrice; var v:vector;
var er:boolean);
var i,j:byte;
begin
if n<3 then er:=true
else
begin
er:=false;
for i:=1 to m do begin
v[i]:=false;
j:=2;
while (j<=n-1)and(a[i,j]=(a[i,j-1]+a[i,j+1])/2) do
inc(j);
if j>n-1 then v[i]:=true
end {for}
end {else}
end;
{programul principal}
begin
clrscr;
write('Nr. de linii: '); readln(m);
write('Nr. de coloane:'); readln(n);
for i:=1 to m do
for j:=1 to n do
begin
write('el[',i,',',j,']=');
readln(a[i,j])
end;
linii_pa(m,n,a,v,vb);
if vb then
writeln('Matricea are mai putin de 3 coloane!')
else begin
k:=0;
for i:=1 to m do
if v[i] then
begin
writeln('Linia ',i);
inc(k)
end;
if k<>0 then
writeln('Au elementele in progresie aritmetica')
else
writeln('Nu exista linii cu elemente in progresie!')
end {else};
readln
end.
Subprograme interne

2.6. Sa se elaboreze un program Pascal care sa includa un subprogram pentru

determinarea coloanelor unei matrice dreptunghice care au elementele în
progresie geometrica.
Subprogramul este de tip procedura si are ca parametri de intrare: matricea
de elemente reale (a), numarul de linii (m) si numarul de coloane (n), iar ca
parametri de iesire: un vector de elemente logice (v) în care vj este true daca
coloana j este progresie geometrica si false în caz contrar si un indicator de
eroare (er) care returneaza true daca numarul de linii este mai mic decât 3
(numarul minim de termeni necesari). Matricea este parcursa invers lexicografic în
subprogram. Citirea si afisarea datelor de ni trare/iesire se realizeaza în programul
principal.

program determinare_coloane_in_progresie;
uses crt;
type
matrice=array[1..10,1..15] of real;
vector=array[1..15] of boolean;
var
a:matrice; v:vector;
vb:boolean;
i,j,k,m,n:byte;
procedure coloane_pg(m,n:byte; a:matrice; var v:vector;
var er:boolean);
var
i,j:byte;
q:real;
begin
if m<3 then er:=true
else
begin
er:=false;
for j:=1 to n do
begin
v[j]:=false; i:=3;
while i<=m do
begin
if a[1,j]<>0 then
begin
q:=a[2,j]/a[1,j];
if a[i,j]=a[i-1,j]*q then inc(i)
else i:=m+3
end
else i:=m+5;
if i=m+1 then v[j]:=true
end {while}
end {for}
end {else}
end;
 Algoritmi în programare. Aplicatii

{programul principal}
begin
clrscr;
write('Nr. de linii: '); readln(m);
write('Nr. de coloane:'); readln(n);
for i:=1 to m do
for j:=1 to n do begin
write('el[',i,',',j,']=');
readln(a[i,j])
end;
coloane_pg(m,n,a,v,vb);
if vb then
writeln('Matricea are mai putin de 3 linii!')
else
begin
k:=0;
for j:=1 to m do
if v[j]=true then
begin
writeln('coloana ',j);
inc(k)
end;
if k<>0 then
writeln('Au elementele in progresie geometrica.')
else
writeln('Nu exista linii cu elemente in progresie!')
end {else}
end.

2.7. Sa se elaboreze un program Pascal care sa includa un subprogram pentru

crearea unui vector cu elementele strict pozitive din triunghiul inferior
diagonalei principale (inclusiv diagonala) dintr-o matrice patrata.
Subprogramul este de tip procedura si are ca parametri de intrare: matricea
de elemente reale (a), numarul de linii/coloane (n), iar ca parametri de iesire:
vectorul cu elementele strict pozitive (v) si numarul de elemente gasite în
triunghiul inferior (0≤k≤n(n+1)/2). Citirea si afisarea datelor de intrare/iesire se
realizeaza în programul principal.

program triunghi_inferior_diagonala_principala;
uses crt;
type matrice=array[1..15,1..15] of real;
vector=array[1..120] of real;
var a:matrice;
v:vector;
i,j,m,n:byte;
procedure creare_vector(n:byte; a:matrice; var v:vector;
var k:byte);
var i,j:byte;
Subprograme interne

begin
k:=0;
for i:=1 to n do
for j:=1 to i do
if a[i,j]>0 then begin inc(k); v[k]:=a[i,j] end
end;
{programul principal}
begin
clrscr; write('Dimensiunea matricei:'); readln(n);
for i:=1 to n do
for j:=1 to n do begin
write('el[',i,',',j,']='); readln(a[i,j])
end;
creare_vector(n,a,v,m);
if m>0 then begin
writeln('Elementele vectorului sunt:');
for i:=1 to m do write(v[i]:6:2)
end
else writeln('Nu exista elemente > 0!')
end.

2.8. Sa se elaboreze un program Pascal care sa includa un subprogram pentru

crearea unui vector cu elementele de valoare para din triunghiul superior
diagonalei secundare (inclusiv diagonala) dintr-o matrice patrata.
Subprogramul este de tip procedura si are ca parametri de intrare: matricea
de elemente naturale (a), numarul de linii/coloane (n), iar ca parametri de iesire:
vectorul cu elementele de valoare para (v) si numarul de elemente gasite în
triunghiul superior (0≤k≤n(n+1)/2). Citirea si afisarea datelor de intrare/iesire se
realizeaza în programul principal. Paritatea se defineste numai pe numere naturale
si se poate verifica în program fie prin restul împartirii la 2 (operatorul MOD), fie
prin functia ODD.

program triunghi_superior_diagonala_secundara;
uses crt;
type matrice=array[1..15,1..15] of word;
vector=array[1..120] of word;
var a:matrice; v:vector; i,j,m,n:byte;
procedure creare_vector(n:byte; a:matrice; var v:vector;
var k:byte);
var i,j:byte;
begin
k:=0;
for i:=1 to n do
for j:=1 to n-i+1 do
if a[i,j] mod 2=0 then begin
inc(k); v[k]:=a[i,j]
end
end;
 Algoritmi în programare. Aplicatii

{programul principal}
begin
clrscr; write('Dimensiunea matricei:'); readln(n);
for i:=1 to n do
for j:=1 to n do begin
write('el[',i,',',j,']=');
readln(a[i,j])
end;
creare_vector(n,a,v,m);
if m>0 then begin
writeln('Elementele vectorului sunt:');
for i:=1 to m do write(v[i]:4)
end
else writeln('Nu exista elemente pare inferior!')
end.

2.9. Sa se elaboreze un program Pascal care sa includa un subprogram pentru

determinarea mediei aritmetice a elementelor strict pozitive pentru fiecare
linie a unei matrice dreptunghiulare.
Subprogramul este de tip procedura si are ca parametri de intrare: matricea
de elemente reale (a), numarul de linii (m) si numarul de coloane (n), iar ca
parametru de iesire: vectorul cu media pe fiecare linie a matricei (v). Daca nu
exista cel putin doua elemente strict pozitive, media nu se poate calcula si vi=0.
Citirea si afisarea datelor de intrare/iesire se realizeaz a în programul principal.
program medii_aritmetice_pe_linii;
uses crt;
type matrice=array[1..10,1..15] of real;
vector=array[1..10] of real;
var a:matrice; v:vector; i,j,m,n:byte;
procedure medie_linii(m,n:byte; a:matrice; var v:vector);
var i,j,k:byte;
begin
for i:=1 to m do
begin
k:=0; v[i]:=0;
for j:=1 to n do
if a[i,j]>0 then begin
inc(k);
v[i]:=v[i]+a[i,j]
end;
if k>1 then v[i]:=v[i]/k else v[i]:=0
end
end;
{programul principal}
begin
clrscr; write('Nr. de linii: '); readln(m);
write('Nr. de coloane:'); readln(n);
for i:=1 to m do
Subprograme interne

for j:=1 to n do begin

write('el[',i,',',j,']='); readln(a[i,j])
end;
medie_linii(m,n,a,v);
for i:=1 to m do
if v[i]<>0 then
writeln('Media pe linia ',i,' este ', v[i]:6:2)
else writeln('Nu exista medie pe linia ',i)
end.

2.10. Sa se elaboreze un program Pascal care sa includa un subprogram

pentru determinarea produsului vectorial dintre fiecare dou a linii ale unei
matrice dreptunghiulare.
Subprogramul este de tip procedura si are ca parametri de intrare: matricea
de elemente reale (a), numarul de linii (m) si numarul de coloane (n), iar ca
parametru de iesire: matricea rezultat (b), cu m(m-1)/2 linii si n coloane. Citirea si
afisarea datelor de intrare/iesire se realizeaza în programul principal.
program produs_vectorial;
uses crt;
type matrice=array[1..10,1..20] of real;
matrice_rez=array[1..45,1..20] of real;
var a:matrice; b:matrice_rez; i,j,m,n:byte;
procedure pv_linii(m,n:byte; a:matrice; var b:matrice_rez);
var i,j,l,k:byte;
begin
k:=0;
for i:=1 to m-1 do
for j:=i+1 to m do begin
inc(k);
for l:=1 to n do b[k,l]:=a[i,l]*a[j,l]
end
end;
{programul principal}
begin
clrscr; write('Nr. de linii: '); readln(m);
write('Nr. de coloane:'); readln(n);
for i:=1 to m do
for j:=1 to n do begin
write('el[',i,',',j,']='); readln(a[i,j])
end;
pv_linii(m,n,a,b);
writeln('Matricea rezultat este:');
for i:=1 to m*(m-1)div 2 do begin
for j:=1 to n do write(b[i,j]:6:2);
writeln
end
end.
 Algoritmi în programare. Aplicatii

2.11. Sa se realizeze un program Pascal pentru sortarea unui vector prin

tehnica quicksort.
Fie secventa (x(p),x(p+1),...,x(u)), unde p ia valoarea initiala 1, iar u este
dimensiunea vectorului. Se pozitioneaza x(p) astfel încât toate elementele din fata
lui sa fie mai mici, iar toate de dupa el sa fie mai mari, prin interschimbari repetate.
Fie aceasta pozitie i. Procedeul se reia pentru secventele (x(p),...x(i-1)), respectiv
(x(i+1),...,x(u)). Pozitionarea lui x(p) se realizeaza astfel:
a. se compara x(p) cu x(u), x(u-1),... pâna la primul u1, cu x(u1)<x(p); x(u1)
si x(p) se interschimba, iar p1=p+1;
b. se compara x(u1) cu x(p1), x(p1+1),... pâna la primul p2, cu x(p2)>x(u1);
x(u1) si x(p2) se interschimba.
c. pentru p=p2 si u=u1 se repeta pasii a) si b) pâna când p≥u.
Procedura quick realizeaza sortarea propriu-zisa a vectorului initial. Ea
apeleaza procedura poz care va împarti vectorul init ial în doi subvectori, apoi este
autoapelata procedura quick (recursivitate) pentru sortarea celor doi subvectori.

program quick_sort;
uses crt;
var x:array[1..100] of real; n,i:byte;
procedure poz(p,u:byte; var k:byte);
{ procedura returneaza pozitia finala pe care o va
ocupa elementul x[k] in vectorul sortat.}
var
i,j:byte;
l,di,dj:shortint; {di, dj = pasii de incrementare pentru
i si j, indicand sensul parcurgerii}
v:real;
begin
i:=p; j:=u; di:=0; dj:=-1;
while i<j do
if x[i]>x[j] then
begin
v:=x[i]; x[i]:=x[j]; x[j]:=v;
l:=di; di:=-dj; dj:=-l;
i:=i+di; j:=j+dj
end
else begin i:=i+di; j:=j+dj end;
k:=i
end;
procedure quick(p,u:byte);
var i:byte;
begin
if p<u then
begin
poz(p,u,i); quick(p,i-1); quick(i+1,u)
end
end;
Subprograme interne

{programul principal}
begin
clrscr; write('Dimensiunea vectorului:'); readln(n);
write('Elementele vectorului:');
for i:=1 to n do begin
write('x[', i , ']= ');
readln(x[i])
end;
quick(1,n);
for i:=1 to n do write(x[i]:6:2,' ')
end.

2.12. Sa se realizeze programul Pascal pentru sortarea unui vector prin

tehnica de interclasare.
Pasii algoritmului sunt:
a) se împarte vectorul în doua secvente, astfel ([ ] semnifica parte întreaga) :
S1= {v(1),v(2),...,v([n/2])} si S2= {v([n/2]+1), ..., v(n)};
b) se apeleaza recursiv procedura de sortare pentru vectorii S1 si S2;
c) se interclaseaza vectorii S1 si S2, obtinându-se vectorul sortat.
Subprogramul interc realizeaza interclasarea a doi vectori. Elementele primului
vector au indicii cuprinsi între l si m, iar elementele celui de-al doilea vector au
indicii cuprinsi între m+1 si r. Procedura inters realizeaza sortarea propriu-zisa
a elementelor vectorului initial recurgând la tehnica „DIVIDE ET IMPERA”.
Vectorul este divizat în doi subvectori care se sorteaza prin dublul autoapel al
procedurii inters (recursivitate), iar rezultatele divizarii se interclaseaza apelând
procedura interc .

program inter_sort;
uses crt;
var v, par:array[1..1000] of real; n,i:word;
procedure interc(l,m,r:word);
var i,j,k:word;
begin
if l<r then begin
i:=l; j:=m+1; k:=1;
while(i<=m) and (j<=r) do
begin
if v[i]<v[j] then begin
par[k]:=v[i]; i:=i+1; k:=k+1
end
else begin
par[k]:=v[j]; j:=j+1; k:=k+1
end
end;
if i<=m then
for j:=i to m do
begin par[k]:=v[j]; k:=k+1 end
 Algoritmi în programare. Aplicatii

else
for i:=j to r do begin par[k]:=v[i]; k:=k+1 end
end;
for i:=0 to r-l do v[l+i]:=par[i+1]
end;
procedure inters(l,r:word);
var i:word;
begin
if l<r then begin
i:=(l+r)div 2; inters(l,i);inters(i+1,r);interc(l,i,r)
end
end;
{programul principal}
begin
clrscr;
write('Dimensiunea vectorului:'); readln(n);
write('Elementele vectorului:');
for i:=1 to n do begin
write('v[', i , ']= '); readln(v[i])
end;
inters(1,n);
for i:=1 to n do write(v[i]:8:2,' ')
end.

2.13. Sa se elaboreze un program Pascal care sa includa un subprogram care

verifica daca o matrice patrata este simetrica sau nu.
Subprogramul este de tip functie si are ca parametri de intrare dimensiunea
matricei (m) si matricea de elemente reale (a). Rezultatul este de tip logic. Citirea si
afisarea datelor de intrare/iesire se realizeaza în programul principal.

program verificare_matrice_simetrica;
type
matrice=array[1..10,1..10] of real;
var
a:matrice;
m,i,j:byte; {i si j sunt variabile globale}
function simetrica(m:byte; a:matrice):boolean;
var
i,j:byte; {i si j sunt variabile locale}
begin
simetrica:=true;
for i:=1 to m do
for j:=1 to i-1 do
if a[i,j] <> a[j,i] then simetrica:=false
end;
{program principal}
begin
write('Nr. de linii: '); readln(m);
write('Nr. de coloane: '); readln(n);
Subprograme interne

for i:=1 to m do
for j:=1 to n do
begin
write('(',i,',',j,')=' );
readln(a[i,j])
end;
if simetrica(m,n,a) then
writeln('Matricea este simetrica !')
else writeln('Matricea nu este simetrica !')
end.

2.14. Sa se elaboreze un program Pascal care sa includa un subprogram care

determina urma unei matrice patrate.
Subprogramul este de tip functie si are ca parametri de intrare dimensiunea
matricei (m) si matricea de elemente reale (a). Rezultatul este de tip real. Urma
matricei se calculeaza ca suma elementelor de pe diagonala principala. Citirea si
afisarea datelor de intrare/iesire se realizeaza în programul principal.

program urma_matricei;
type matrice=array[1..10,1..10] of real;
var a:matrice; m,i,j:byte;
function urma(m:byte; a:matrice):real;
var i:byte; s:real;
begin
s:=0;
for i:=1 to m do s:=s+a[i,i];
urma:=s
end;
{program principal}
begin
write('Dimensiunea matricei: '); readln(m);
for i:=1 to m do
for j:=1 to m do begin
write('(',i,',',j,')=' ); readln(a[i,j])
end;
writeln('Urma matricei = ',urma(m,a):10:2)
end.

2.15. Sa se elaboreze un program Pascal care sa includa un subprogram care

determina amplitudinea unui sir de numere (memorate într-un vector de
elemente reale).
Amplitudinea unui sir de numere se determina ca diferenta (în valoare
absoluta) dintre maximul si minimul din sirul respectiv. Subprogramul de
determinare a amplitudinii este de tip functie si are ca parametri de intrare
dimensiunea vectorului (n) si vectorul de elemente reale (v). Rezultatul este de tip
n n
real. Deoarece min (xi ) = − max( − xi ) se construieste o functie (maxim) interna
i =1 i =1
 Algoritmi în programare. Aplicatii

subprogramului amplit care determina maximul dintr-un vector si care este

apelata de doua ori. Citirea si afisarea datelor de intrare/iesire se realizeaza în
programul principal.

program amplitudine;
uses crt;
type vector=array[1..100] of real;
var v:vector; n,i:byte;
function amplit(n:byte; v:vector):real;
var max,min:real; i:byte;
function maxim(m:byte; x:vector):real;
var r:real; i:byte;
begin
r:=x[1];
for i:=2 to m do if x[i]>r then r:=x[i];
maxim:=r
end;
begin
max:=maxim(v,n);
for i:=1 to n do v[i]:=-v[i];
min:=-maxim(v,n);
amplit:=abs(max-min)
end;
{programul principal}
begin
clrscr; write('Nr. de elemente:'); readln(n);
for i:=1 to n do
begin write('v[',i,']='); readln(v[i]) end;
writeln('Amplitudinea vectorului =',amplit(v,n):8:2);
readln
end.

2.16. Sa se elaboreze un program Pascal care sa includa un subprogram

pentru determinarea celui mai mare divizor comun dintre elementele unei
matrice dreptunghiulare.
Subprogramul cmmdc este de tip functie si are ca parametri de intrare
dimensiunile matricei (m si n) si matricea de elemente naturale (a). Rezultatul este
de tip întreg. Pentru obtinerea c.m.m.d.c. din matrice se determina c.m.m.d.c. de pe
fiecare linie si apoi c.m.m.d.c. din rezultatele partiale. Determinarea c.m.m.d.c.
dintr-un sir de numere se realizeaza prin functia cmmdc_vect, interna
subprogramului cmmdc . Citirea si afisarea datelor de intrare/iesire se realizeaza în
programul principal.

program cmmdc_mat;
uses crt;
type
matrice=array[1..10,1..15] of word;
Subprograme interne

vector=array[1..15] of word;
var a:matrice;
m,n,i,j:byte;
c:word;
function cmmdc(m,n:byte; a:matrice):word;
var x,y:vector;
i,j:byte;
function cmmdc_vect(n:byte; v:vector):word;
var i:byte;
deim,imp,rest:word;
begin
deim:=v[1]; rest:=0; i:=2;
while (i<=n) and (rest<>1) do
begin
imp:=v[i];
repeat
rest:=deim mod imp;
deim:=imp;
imp:=rest
until rest<2;
inc(i)
end;
if rest<>1 then cmmdc_vect:=deim
else cmmdc_vect:=1
end;
begin
for i:=1 to m do
begin
for j:=1 to n do x[j]:=a[i,j]; {salvare linie i}
y[i]:=cmmdc_vect(n,x) {cmmdc de pe linia i}
end;
cmmdc:=cmmdc_vect(m,y)
end;
{programul principal}
begin
clrscr;
write('Nr. de linii:'); readln(m);
write('Nr. de coloane:'); readln(n);
for i:=1 to m do
for j:=1 to n do
begin
write('a[',i,',',j,']=');
readln(a[i,j])
end;
c:=cmmdc(m,n,a);
if c<>1 then writeln('CMMDC din matrice =',c:4)
else writeln('Numere prime intre ele!');
readln
end.
 Algoritmi în programare. Aplicatii

2.17. Sa se elaboreze un program Pascal care sa contina subprograme pentru

determinarea permutarilor (P n), aranjamentelor (Ank) si combinarilor (C nk).
Se construiesc trei subprograme de tip functie. Functia permutari
calculeaza Pn=n!, functia aranjamente calculeaza An k=Pn/Pn- k si functia
combinari calculeaza Cn k=An k/P k. Parametrii de intrare si rezultatele sunt de tip
întreg si nu se fac validari. Citirea si afisarea datelor de intrare/iesire se realizeaza
în programul principal.

program p_a_c;
var
n,k:byte;
function permutari(n:byte):real;
var
i:byte;
r:real;
begin
r:=1;
for i:=2 to n do r:=r*i;
permutari:=r
end;
function aranjamente(n,k:byte):longint;
begin
aranjamente:=trunc(permutari(n)/permutari(n-k))
end;
function combinari(n,k:byte):longint;
begin
combinari:=trunc(aranjamente(n,k)/permutari(k))
end;
{programul principal}
begin
write('n = '); readln(n);
write('k (0<k≤n) = '); readln(k);
writeln('Permutari de',n,' = ',permutari(n):10:0);
writeln('Aranjamente de ',n,' luate cate ',k,' = ',
aranjamente(n,k));
writeln('Combinari de ',n,' luate cate ',k,' = ',
combinari(n,k))
end.

2.18. Sa se elaboreze un program Pascal care sa includa un subprogram

pentru interclasarea a doua siruri de caractere neordonate.
Subprogramul interclasare este de tip functie si are ca parametri de
intrare cele doua siruri de caractere (s1 si s2). Rezultatul este de tip STRING (de
lungime maxima). Pentru ordonarea sirurilor se utilizeaza o procedura de sortare
sortare_sir, interna functiei interclasare . Citirea si afisarea datelor de
intrare/iesire se realizeaza în programul principal.
Subprograme interne

program siruri;
uses crt;
var s1,s2,s:string;
function interclasare(var s1,s2:string):string;
var
rez:string;
i,j,k,l:byte;
procedure sortare_sir(var s:string);
var
i,j:byte; c:char;
begin
for i:=1 to length(s)-1 do
for j:=i+1 to length(s) do
if s[i]>s[j] then begin
c:=s[i];
s[i]:=s[j];
s[j]:=c
end
end;
begin
sortare_sir(s1);
sortare_sir(s2);
i:=1; j:=1; k:=0;
while (i<=length(s1)) and (j<=length(s2)) do
if s1[i]<s2[j] then begin
inc(k);
rez[k]:=s1[i];
inc(i)
end
else begin
inc(k);
rez[k]:=s2[j];
inc(j)
end;
if i>length(s1) then
for l:=j to length(s2) do
begin
inc(k);
rez[k]:=s2[l]
end
else
for l:=i to length(s1) do
begin
inc(k);
rez[k]:=s1[l]
end;
{memorare lungime efectiva}
rez[0]:=chr(length(s1)+length(s2));
interclasare:=rez
end;
 Algoritmi în programare. Aplicatii

{programul principal}
begin
clrscr;
writeln('Primul sir (maxim 126 de caractere):');
readln(s1);
write('Al doilea sir (maxim 126 de caractere):');
readln(s2);
writeln('Sirul rezultat este:');
writeln(interclasare(s1,s2))
readln
end.