3.

Subprograme externe


3.1. Sa se realizeze o unitate Pascal care sa contina subprograme pentru
realizarea operatiilor de reuniune, intersectie, diferenta si produs cartezian
dintre doua multimi.
a) Reuniunea dintre doua multimi A si B se defineste astfel:
AB={xxA sau xB}
Cunoscuta si sub numele de interclasare cu selectie, operatia de reuniune
presupune parcurgerea secventiala a multimilor initiale si trecerea n multimea
rezultat a elementelor care se regasesc n cele doua multimi, fiecare luat o singura
data.
b) Intersectia dintre doua multimi A si B se defineste astfel:
AB={xxA si xB}
Se obtine o multime cu elementele comune multimilor initiale. Daca intersectia
este vida, atunci cardinalul multimii rezultat este 0.
c) Diferenta dintre doua multimi A si B se defineste astfel:
A\B={xxA si xB}.
d) Produsul cartezian dintre doua multimi A si B se defineste astfel:
AxB={(x,y) xA si yB}.
Pentru rezolvarea problemei propuse, unitatea contine subprograme
corespunzatoare operatiilor prezentat e anterior. Se utilizeaza doua proceduri
interne pentru sortarea elementelor unui vector, respectiv pentru compactarea
elementelor unui vector (prin compactare se asigura unicitatea valorilor
elementelor din multimile initiale, eliminndu-se dublurile).
Semnificatia parametrilor formali este urmatoarea:
m, n = numarul de elemente ale multimilor initiale;
a, b = multimile initiale (vectori);
c = multimea rezultat (vector);
card = numarul de elemente ale multimii rezultat.

unit multimi;
INTERFACE
type multime=array[1..50] of integer;
produs=array[1..100] of record
x,y:integer
end;
procedure reuniune(m,n:byte; var a,b,c:multime;
var card:byte);
procedure intersectie(m,n:byte; var a,b,c:multime;
var card:byte);
procedure diferenta(m,n:byte; var a,b,c:multime;
var card:byte);
procedure produs_cartezian(m,n:byte; var a,b:multime;
var c:produs);
Algoritmi n programare. Aplicatii
IMPLEMENTATION
procedure sortare(n:byte; var v:multime);
var i:byte; aux:integer; vb:boolean;
begin
repeat
vb:=false;
for i:=1 to n-1 do
if v[i]>v[i+1] then begin
aux:=v[i];
v[i]:=v[i+1];
v[i+1]:=aux;
vb:=true
end
until not vb
end;
procedure compactare(var n:byte; var v:multime);
var i,j,k:byte;
begin
sortare(n,v);
k:=0; i:=1;
while i<=n-k do
if v[i]=v[i+1] then begin
k:=k+1;
for j:=i to n-k+1 do v[j]:=v[j+1]
end
else inc(i);
n:=n-k
end;
procedure reuniune;
const hv=maxint;
var i,j,k,l:byte;
begin
k:=0; i:=1; j:=1;
while (a[i]<>hv) or (b[j]<>hv) do
if a[i]<b[j] then begin
inc(k);
c[k]:=a[i];
inc(i);
if i>m then a[i]:=hv
end
else if a[i]>b[j] then begin
inc(k);
c[k]:=b[j];
inc(j);
if j>n then b[j]:=hv
end
else begin inc(i); if i>m then a[i]:=hv end;
card:=k
end;

Subprograme externe
procedure intersectie;
var i,j,k:byte;
begin
k:=0; i:=1; j:=1;
while (i<=m) and (j<=n) do
if a[i]=b[j] then begin
inc(k);
c[k]:=a[i];
i:=i+1
end
else if a[i]>b[j] then inc(j) else inc(i);
card:=k
end;
procedure diferenta;
var i,j,k:byte;
begin
k:=0;
for i:=1 to m do
begin
j:=1;
while (a[i]<>b[j]) and (j<=n) do inc(j);
if j>n then begin inc(k);
c[k]:=a[i]
end
end;
card:=k
end;
procedure produs_cartezian;
var i,j,k:byte;
begin
k:=0;
for i:=1 to m do
for j:=1 to n do
begin
inc(k);
c[k].x:=a[i];
c[k].y:=b[j]
end
end;
BEGIN
END.

3.2. Sa se realizeze o unitate Pascal care sa contina subprograme
pentru calcularea medie i aritmetice ponderat e , dispersiei si abaterii
medii patrate pentru un sir de observatii statistice.
Pentru rezolvarea problemelor statistice trebuie avut e n vedere, pe lnga
observatiile propriu-zise, si frecventele de aparitie a acestora n cadrul sirului
Algoritmi n programare. Aplicatii
initial. n cadrul unitatii au fost dezvoltate doua subprograme frecvente_1 si
frecvente_2, care reprezinta variante ale aceleiasi probleme.
Prima varianta determina vectorul valorilor caracteristicii observate (unice),
precum si vectorul de frecvente, prin parcurgerea secventiala a sirului initial de
observatii statistice. Pentru fiecare observatie initiala se verifica existenta n
vectorul de valori unice: daca exista, atunci se incrementeaza frecventa
corespunzatoare valorii respective, n caz contrar observatia are o valoare noua si
se adauga sirului de valori unice.
A doua varianta presupune sortarea sirului initial de observatii statistice si
obtinerea vectorului valorilor caracteristicii observate (unice) si a vectorului de
frecvente folosind algoritmul controlului dupa caracteristica.
Observatie: Cele doua variante sunt utile n cazul problemelor statistice care
necesita cunoasterea frecventelor de aparitie a valorilor caracteristicii observate (de
exemplu valoarea modala a unei serii de observatii statistice, valorile quartilelor,
decilelor etc.).
Formulele utilizate pentru determinarea indicatorilor statistici sunt:
Media aritmetica ponderata:

=
=

=
n
1 i
i
n
1 i
i i
f
f x
x , dispersia:

=
=

=
n
1 i
i
n
1 i
i
2
i
2
f
f ) x (x
s si
abaterea medie patrata:
2
s s = . Semnificatia parametrilor formali este
urmatoarea:
n = numarul de observatii statistice (parametru de intrare) ;
x = sirul initial de observatii statistice (parametru de intrare) ;
y = multimea valorilor unice ale caracteristicii (parametru de iesire);
f = vectorul de frecvente asociat multimii y (parametru de iesire);
k = numarul de valori unice identificate n x - cardinalul multimii y
(parametru de iesire) .

unit statist;
INTERFACE
type vector=array[1..50] of real;
vector1=array[1..50] of byte;
procedure frecvente_1(n:byte; var x,y:vector; var f:vector1;
var k:byte);
procedure frecvente_2(n:byte; var x,y:vector; var f:vector1;
var k:byte);
function media(n:byte; var x:vector):real;
function dispersia(n:byte; var x:vector):real;
function abaterea_medie_patratica(n:byte; var x:vector):real;
IMPLEMENTATION
var
y:vector; f:vector1;
dim:byte;
Subprograme externe
procedure sortare(n:byte; var v:vector);
var i:byte; aux:real; vb:boolean;
begin
repeat
vb:=false;
for i:=1 to n-1 do
if v[i]>v[i+1] then begin
aux:=v[i]; v[i]:=v[i+1]; v[i+1]:=aux;
vb:=true end
until not vb
end;
procedure frecvente_1;
var i,j:byte;
begin
y[1]:=x[1]; f[1]:=1; k:=1;
for i:=2 to n do
begin
j:=1;
while (x[i]<>y[j]) and (j<=k) do inc(j);
if j<=k then inc(f[j])
else begin inc(k);y[k]:=x[i]; f[k]:=1 end
end
end;
procedure frecvente_2;
var i:byte;
begin
sortare(n,x); k:=0; i:=1;
while i<=n do
begin
k:=k+1; y[k]:=x[i]; f[k]:=0;
while (x[i]=y[k]) and (i<=n) do
begin inc(f[k]); inc(i) end
end
end;
function media;
var s:real; dim,i:byte;
begin
frecvente_1(n,x,y,f,dim);
if dim=n then
begin
s:=0;
for i:=1 to n do s:=s+x[i];
media:=s/n {medie aritmetica simpla}
end
else begin
s:=0;
for i:=1 to dim do s:=s+y[i]*f[i];
media:=s/n {medie aritmetica ponderata}
end
end;
Algoritmi n programare. Aplicatii
function dispersia;
var
m:real; dim,i:byte; s:real;
begin
m:=media(n,x,y,f);
frecvente_2(n,x,y,f,dim);
s:=0;
for i:=1 to dim do s:=s+sqr(y[i]-m)*f[i];
dispersia:=s/n
end;
function abaterea_medie_patratica;
begin
abaterea_medie_patratica:=sqrt(dispersia(n,x,y,f))
end;
end.

3.3. Sa se construiasca o unitate Pascal care sa contina subprograme pentru
lucrul cu masive de date, pentru rezolvarea urmatoarelor operatii:
determinarea valorii unui polinom ntr-un punct dat;
determinarea numarului de elemente pare de pe fiecare linie a unei
matrice;
nsumarea elementelor strict negative ale unui masiv tridimensional;
inserarea valorii 0 ntre oricare doua elemente ale unui vector dat;
determinarea liniilor cu elementele n ordine strict crescatoare dintr-o
matrice dreptunghiulara;
cautarea unei valori date ntr-un vector neordonat;
determinarea valorii maxime din fiecare plan al unui masiv
tridimensional;
numararea aparitiilor ntr-un text a tuturor literelor alfabetului englez;
cautarea unei valori date ntr-un vector ordonat;
determinarea transpusei unei matrice dreptunghiulare;
compactarea unui vector prin eliminarea elementelor maxim si minim;
ridicarea unei matrice patrate la o putere data;
transformarea literelor mici dintr-un sir n litere mari;
determinarea maximului de pe fiecare coloana dintr-o matrice
dreptunghiulara;
determinarea mediei geometrice a elementelor unui vector;
determinarea mediei aritmetice a elementelor strict negative dintr-un
vector;
determinarea produsului vectorial dintre diagonalele principala si
secundara ale unei matrice patrate;
determinarea produsului scalar dintre diagonalele principala si
secundara ale unei matrice patrate;
determinarea produsului elementelor strict pozitive dintr-un vector;
determinarea mediei aritmetice a elementelor nenule dintr-un vector;
determinarea mediei armonice a tuturor elementelor unui vector;
Subprograme externe
determinarea produsului a doua matrice dreptunghiulare;
adunarea a doua matrice cu elemente logice;
nmultirea a doua matrice cu elemente logice;
sortarea crescatoare a elementelor unui vector prin metoda bulelor
(prin interschimbare);
sortarea crescatoare a elementelor unui vector prin metoda selectiei
(minime succesive);
interclasarea a doi vectori;
nmultirea unui vector cu o matrice.
Unitatea masive va contine, pe lnga subprogramele de rezolvare a cerintelor
problemei, patru subprograme pentru citirea si afisarea unui vector, respectiv
citirea si afisarea unei matrice.

unit masive;
INTERFACE
uses crt;
type {tipuri publice}
masiv3d=array[1..10,1..10,1..10] of real;
matrice=array[1..20,1..20] of real;
matrice1=array[1..20,1..20] of word;
matrice2=array[1..20,1..20] of boolean;
vector=array[1..100] of real;
vector1=array[1..20] of byte;
vector2=array['A'..'Z'] of byte;
{determinarea valorii unui polinom intr-un punct dat}
function polinom(grad:byte; x:real; var coef:vector):real;
{determinarea numarului de elemente pare de pe fiecare linie
a unei matrice}
procedure el_pare(m,n:byte; a:matrice1; var rez:vector1);
{insumarea elementelor strict negative ale unui masiv
tridimensional}
function suma_tridim(m,n,p:byte; var t:masiv3d):real;
{inserarea valorii 0 intre oricare doua elemente ale unui
vector}
procedure inserare_0(var n:byte; var v:vector);
{determinarea liniilor cu elementele in ordine strict
crescatoare dintr-o matrice dreptunghiulara 2 variante}
procedure linii_cresc1(m,n:byte; a:matrice;
var nr:byte; var v:vector1);
procedure linii_cresc2(m,n:byte; a:matrice; var v:vector1);
{cautarea unei valori intr-un vector neordonat 2 variante}
function cautare1(n:byte; v:vector; x:real):boolean;
function cautare2(n:byte; v:vector; x:real):byte;
{determinarea valorii maxime din fiecare plan al unui masiv
tridimensional}
procedure maxim_plan3d(m,n,p:byte; var t:masiv3d;
var v:vector);
Algoritmi n programare. Aplicatii
{numararea aparitiilor intr-un text a tuturor literelor
alfabetului englez}
procedure litere(s:string; var v:vector2);

{cautarea unei valori date intr-un vector ordonat}
function cautare_binara(n:byte; v:vector; x:real):byte;
{determinarea transpusei unei matrice dreptunghice}
procedure transpusa(var m,n:byte; a:matrice; var at:matrice);
{compactarea unui vector prin eliminarea elementelor maxim si
minim}
procedure compactare(var n:byte; var v:vector);
{ridicarea unei matrice patrate la o putere data}
procedure matrice_la_putere(n,p:byte; a:matrice;
var ap:matrice);
{transformarea literelor mici dintr-un sir in litere mari}
procedure transformare_litere(var s:string);
{determinarea maximului de pe fiecare coloana dintr-o matrice
dreptunghiulara}
procedure maxim_coloane(m,n:byte; a:matrice; var v:vector);
{determinarea mediei geometrice a elementelor unui vector}
procedure medie_geom(n:byte; v:vector; var mg:real;
var er:boolean);
{determinarea mediei aritmetice a elementelor strict negative
dintr-un vector}
function medie_aritm_negative(n:byte; v:vector):real;
{determinarea produsului vectorial dintre diagonalele
principala si secundara ale unei matrice patrate}
procedure produs_vectorial_diagonale(n:byte; a:matrice;
var pv:vector);
{determinarea produsului scalar dintre diagonalele principala
si secundara ale unei matrice patrate}
function produs_scalar_diagonale(n:byte; a:matrice):real;
{determinarea produsului elementelor strict pozitive dintr-un
vector}
function produs_elem_pozitive(n:byte; v:vector):real;
{determinarea mediei aritmetice a elementelor nenule dintr-un
vector}
function ma_nenule(n:byte; v:vector):real;
{determinarea mediei armonice a elementelor unui vector}
procedure medie_armonica(n:byte; v:vector; var mh:real;
var er:boolean);
{determinarea produsului a doua matrice dreptunghiulare}
procedure produs_matrice(m,n,p:byte; a,b:matrice;
var c:matrice);
{adunarea a doua matrice cu elemente booleene}
procedure suma_matrice_logice(m,n:byte; a,b:matrice2;
var c:matrice2);
{inmultirea a doua matrice cu elemente booleene}
procedure produs_matrice_logice(m,n,p:byte; a,b:matrice2;
var c:matrice2);
Subprograme externe
{sortarea crescatoare a elementelor unui vector prin metoda
bulelor (prin interschimbare)}
procedure sortare1(n:byte; var v:vector);
{sortarea crescatoare a elementelor unui vector prin metoda
selectiei (minime succesive)}
procedure sortare2(n:byte; var v:vector);
{interclasarea a doi vectori}
procedure interclasare(n,m:byte; a,b:vector; var c:vector);
{inmultirea unui vector cu o matrice}
procedure vector_x_matrice(m,n:byte; v:vector; a:matrice;
var x:vector);
{proceduri auxiliare de citire/afisare vectori si matrice}
procedure citire_vector(var n:byte; var v:vector);
procedure afisare_vector(n:byte; v:vector);
procedure citire_matrice(var m,n:byte; var a:matrice);
procedure afisare_matrice(m,n:byte; a:matrice);

IMPLEMENTATION
var {variabile globale unitatii, nepublice}
i,j,k:byte;
function polinom;
var
val,temp:real;
begin
temp:=1; val:=coef[1];
for i:=2 to grad+1 do
begin
temp:=temp*x;
val:=val+coef[i]*temp
end;
polinom:=val
end;
procedure el_pare;
{matricea trebuie sa aiba elemente naturale}
begin
for i:=1 to m do begin
rez[i]:=0;
for j:=1 to n do
if (a[i,j] mod 2)=0 then inc(rez[i])
end
end;
function suma_tridim;
{daca rezultatul este 0 inseamna ca masivul nu contine
elemente strict negative}
var s:real;
begin
s:=0;
for i:=1 to m do
for j:=1 to n do
for k:=1 to p do
Algoritmi n programare. Aplicatii
if t[i,j,k]<0 then s:=s+t[i,j,k];
suma_tridim:=s
end;
procedure inserare_0; {vector rezultat are 2n-1 elemente}
begin
k:=n; i:=2;
while i<=2*n-1 do begin
inc(k);
for j:=k downto i+1 do v[j]:=v[j-1];
v[i]:=0; inc(i,2)
end;
n:=k
end;
procedure linii_cresc1;
{vectorul rezultat v este compact si contine nr>=0 elemente}
begin
nr:=0;
for i:=1 to m do begin
j:=1;
while (j<=n-1) and (a[i,j]<a[i,j+1]) do inc(j);
if j>n-1 then begin nr:=nr+1; v[nr]:=i end
end
end;
procedure linii_cresc2;
{vectorul rezultat are elem. binare: v(i)=1 daca linia i a
matricei are elem. crescatoare si v(i)=0 in caz contrar}
begin
for i:=1 to m do begin
j:=1;
while (j<=n-1) and (a[i,j]<a[i,j+1]) do inc(j);
if j>n-1 then v[i]:=1 else v[i]:=0
end
end;
function cautare1;
{se verifica doar existenta unei valori date intr-un vector}
begin
i:=1;
while (i<=n) and (v[i]<>x) do inc(i);
if i>n then cautare1:=false else cautare1:=true
end;
function cautare2;
{se verifica existenta valorii si se determina
pozitia primei aparitii}
begin
cautare2:=0; {valoarea cautata nu exista in vector}
i:=1;
while i<=n do
if v[i]=x then begin
cautare2:=i;{valoarea cautata exista in vector}
i:=n+1 {fortarea iesirii din bucla while}
Subprograme externe
end
else inc(i)
end;
procedure maxim_plan3d;
{masivul tridimensional este tratat ca un vector
de matrice, de maxim 10 componente}
begin
for i:=1 to m do
begin
v[i]:=t[i,1,1];
for j:=1 to n do
for k:=1 to p do
if t[i,j,k]>v[i] then v[i]:=t[i,j,k]
end
end;
procedure litere;
{nu se fac deosebiri intre litere mari si mici}
var i:char;
begin
for i:='A' to 'Z' do v[i]:=0;
for j:=1 to length(s) do inc(v[upcase(s[j])])
end;
function cautare_binara;
{vectorul are elementele obligatoriu sortate}
var cb,prim,ultim:byte;
begin
prim:=1; ultim:=n; cb:=0;
repeat
i:=(prim+ultim) div 2;
if v[i]=x then cb:=i
else if x<v[i] then ultim:=i-1
else prim:=i+1
until (cb<>0) or (prim>ultim);
cautare_binara:=cb
end;
procedure transpusa;
{transpusa se construieste invers lexicografic}
begin
for i:=1 to m do
for j:=1 to n do
at[j,i]:=a[i,j]
end;
procedure compactare;
{dupa compactare vectorul v are n>=0 componente}
var min,max:real;
begin
min:=v[1]; max:=v[1]; {se determina min si max}
for i:=2 to n do
if v[i]<min then min:=v[i]
else if v[i]>max then max:=v[i];
Algoritmi n programare. Aplicatii
k:=0; i:=1;
while i<=n-k do {se elimina elem. egale cu min sau max}
begin
if (v[i]=min) or (v[i]=max) then
begin
for j:=i to n-k-1 do v[j]:=v[j+1];
inc(k);
end
else inc(i)
end;
n:=n-k {nr. de componente dupa compactare}
end;
procedure matrice_la_putere;
{puterea este p>=0}
var b:matrice;
l:byte;
begin
for i:=1 to n do {initializare matrice unitate}
for j:=1 to n do
if i=j then ap[i,j]:=1 else ap[i,j]:=0;
for k:=1 to p do {ridicare la puterea p}
begin
for i:=1 to n do
for j:=1 to n do
begin
b[i,j]:=0;
for l:=1 to n do b[i,j]:=b[i,j]+ap[i,l]*a[l,j]
end;
for i:=1 to n do
for j:=1 to n do
ap[i,j]:=b[i,j]
end
end;
procedure transformare_litere;
begin
for i:=1 to length(s) do s[i]:=upcase(s[i])
end;
procedure maxim_coloane;
begin
for j:=1 to n do {vectorul poate avea max. 20 de elem.}
begin
v[j]:=a[1,j];
for i:=2 to m do if a[i,j]>v[j] then v[j]:=a[i,j]
end
end;
procedure medie_geom;
begin
er:=false; mg:=1;
for i:=1 to n do mg:=mg*v[i];
if mg>=0 then mg:=exp(ln(mg)/n)
Subprograme externe
else if (n mod 2)=1 then mg:=-exp(ln(-mg)/n)
else er:=true {media nu se poate calcula}
end;
function medie_aritm_negative;
var ma:real;
begin
ma:=0; k:=0;
for i:=1 to n do
if v[i]<0 then begin ma:=ma+v[i]; inc(k) end;
if k>1 then medie_aritm_negative:=ma/k
else medie_aritm_negative:=0 {media nu se poate calcula}
end;
procedure produs_vectorial_diagonale;
begin for i:=1 to n do pv[i]:=a[i,i]*a[i,n-i+1]
end;
function produs_scalar_diagonale;
var ps:real;
begin
ps:=0;
for i:=1 to n do ps:=ps+a[i,i]*a[i,n-i+1];
produs_scalar_diagonale:=ps
end;
function produs_elem_pozitive;
var p:real; k:boolean;
begin
p:=1; k:=false; {k este variabila semafor}
for i:=1 to n do
if v[i]>0 then begin
p:=p*v[i];
k:=true {exista elemente pozitive}
end;
if k then produs_elem_pozitive:=p
else produs_elem_pozitive:=0 {nu exista elemente pozitive}
end;
function ma_nenule;
var ma:real;
begin
ma:=0; k:=0; {k este variabila semafor, dar si contor}
for i:=1 to n do
if v[i]<>0 then begin ma:=ma+v[i]; inc(k) end;
if k>1 then ma_nenule:=ma/k
else ma_nenule:=0 {nu exista elemente diferite de 0}
end;
procedure medie_armonica;
{daca er=true, atunci media armonica nu se poate calcula}
begin
mh:=0; er:=false; i:=1;
while (i<=n) and (v[i]<>0) do begin
mh:=mh+1/v[i]; inc(i)
end;
Algoritmi n programare. Aplicatii
if i>n then if mh<>0 then mh:=n/mh else er:=true
else er:=true
end;
procedure produs_matrice;
begin
for i:=1 to m do
for j:=1 to p do
begin
c[i,j]:=0;
for k:=1 to n do c[i,j]:=c[i,j]+a[i,k]*b[k,j]
end
end;
procedure suma_matrice_logice;
{adunarea a 2 valori logice este SAU logic}
begin
for i:=1 to m do
for j:=1 to n do c[i,j]:=a[i,j] or b[i,j]
end;
procedure produs_matrice_logice;
{inmultirea a 2 valori logice este SI logic}
begin
for i:=1 to m do
for j:=1 to p do
begin
c[i,j]:=false;
for k:=1 to n do c[i,j]:=c[i,j]or(a[i,k]and b[k,j])
end
end;
procedure sortare1; {metoda bulelor}
var vb:boolean;
aux:real;
begin
repeat
vb:=false;
for i:=1 to n-1 do
if v[i]>v[i+1] then begin
aux:=v[i]; v[i]:=v[i+1]; v[i+1]:=aux; vb:=true
end
until not vb
end;
procedure sortare2; {metoda selectiei}
var aux:real;
begin
for i:=1 to n-1 do
for j:=i+1 to n do
if v[i]>v[j] then begin
aux:=v[i]; v[i]:=v[j]; v[j]:=aux
end
end;
procedure interclasare; {card(a) + card(b) = maxim 100}
Subprograme externe
var l:byte;
begin
k:=0; i:=1; j:=1;
while (i<=m) and (j<=n) do begin
inc(k);
if a[i]<b[j] then begin c[k]:=a[i]; inc(i) end
else begin c[k]:=b[j]; inc(j) end
end;
if i>m then for l:=j to n do begin
inc(k); c[k]:=b[l]
end
else for l:=i to m do begin
inc(k); c[k]:=a[l]
end
end;
procedure vector_x_matrice;
begin
for j:=1 to n do begin
x[j]:=0;
for i:=1 to m do x[j]:=x[j]+v[i]*a[i,j]
end
end;
procedure citire_vector; {cate un element pe rand}
begin
write('Nr. de elemente:'); readln(n);
for i:=1 to n do begin
write('el[',i,']='); readln(v[i])
end
end;
procedure afisare_vector; {pe acelasi rand al monitorului}
begin
for i:=1 to n do write(v[i]:6:2)
end;

procedure citire_matrice; {cate un element pe rand}
begin
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;
end;
procedure afisare_matrice; {sub forma matriceala}
begin
for i:=1 to m do begin
for j:=1 to n do write(a[i,j]:6:2);
writeln
end
Algoritmi n programare. Aplicatii
end;
BEGIN
END.
3.4. Sa se realizeze programul Pascal care apeleaza subprograme din unitatea
conceputa la exercitiul 3.3.
Programul principal care apeleaza unitatea masive este conceput
multifunctional (modularizat), astfel nct utilizatorul sa poata opta pentru una din
functiuni, avnd posibilitatea reluarii prin citirea de la tastatura a optiunii dorite.

program apelator_masive;
uses masive,crt;
var a,b,c:matrice;
x,y,z:vector;
a1:matrice1;
v1:vector1;
v2:vector2;
t:masiv3D;
s:string;
cc:char;
i,j,k,l,m,n,opt:byte;
p:real;
vb:boolean;
procedure meniu;
begin
clrscr;
textcolor(yellow+blink);
gotoxy(25,1); write(' APLICATIE CU SUBPROGRAME ');
textcolor(white);
gotoxy(1,5); write(' 1 ? Valoare polinom intr-un punct dat');
gotoxy(1,6); write(' 2 ? Elemente pare pe linie matrice');
gotoxy(1,7); write(' 3 ? Suma elemente negative masiv 3D');
gotoxy(1,8); write(' 4 ? Inserare 0 intre elemente vector');
gotoxy(1,9); write(' 5 ? Linii cu elemente crescatoare var1');
gotoxy(1,10); write(' 6 ? Linii cu elemente crescatoare var2');
gotoxy(1,11); write(' 7 ? Cautare in vector oarecare var1');
gotoxy(1,12); write(' 8 ? Cautare in vector oarecare var2');
gotoxy(1,13); write(' 9 ? Maxim din fiecare plan masiv 3D');
gotoxy(1,14); write('10 ? Aparitii litere in text');
gotoxy(1,15); write('11 ? Cautare in vector ordonat');
gotoxy(1,16); write('12 ? Transpusa unei matrice');
gotoxy(1,17); write('13 ? Compactare vector eliminand max/min');
gotoxy(1,18); write('14 ? Matrice la o putere data');
gotoxy(41,5); write('|15 ? Transformare litere mici in mari');
gotoxy(41,6); write('|16 ? Maxim pe fiecare coloana matrice');
gotoxy(41,7); write('|17 ? Medie geometrica elemente vector');
gotoxy(41,8); write('|18 ? Medie aritmetica elemente < 0');
gotoxy(41,9); write('|19 ? Produs vectorial intre diagonale');
gotoxy(41,10); write('|20 ? Produs scalar intre diagonale');
gotoxy(41,11); write('|21 ? Produs elemente > 0 din vector');
gotoxy(41,12); write('|22 ? Medie aritmetica elemente nenule');
gotoxy(41,13); write('|23 ? Medie armonica elemente vector');
gotoxy(41,14); write('|24 ? Inmultirea a doua matrice');
gotoxy(41,15); write('|25 ? Sortare vector prin interschimbare');
Subprograme externe
gotoxy(41,16); write('|26 ? Sortare vector prin selectie');
gotoxy(41,17); write('|27 ? Interclasarea a doi vectori');
gotoxy(41,18); write('|28 ? Inmultire vector cu matrice');
textcolor(magenta+blink);
gotoxy(27,20); write('Pentru iesire tastati 0');
textcolor(yellow+blink);
gotoxy(30,22); clreol; write('Alegeti optiunea: ');
textcolor(white); readln(opt)
end;
{programul principal}
begin
meniu;
while opt<>0 do begin
case opt of
1: begin
clrscr; write('Gradul polinomului:'); readln(n);
writeln('Coeficientii polinomului:');
for i:=1 to n+1 do
begin
write('coeficientul lui x la puterea ',i-1,' = ');
readln(x[i])
end;
write('Punctul pentru care se va calcula valoarea:');
readln(p);
writeln('Valoarea polinomului in punctul',p:3:0,
' este ',polinom(n,p,x):6:2);
readln
end;
2: 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(a1[i,j])
end;
el_pare(m,n,a1,v1);
for i:=1 to m do
writeln('Pe linia',i:2,' se afla',v1[i]:2,
' elemente pare');
readln
end;
3: begin
clrscr;
write('Nr. de plane 3D:'); readln(l);
write('Nr. linii pe plan:'); readln(m);
write('Nr. coloane pe plan:'); readln(n);
for i:=1 to l do
for j:=1 to m do
for k:=1 to n do begin
write('el[',i,',',j,',',k,']=');
readln(t[i,j,k])
end;
p:=suma_tridim(l,m,n,t);
if p<>0 then
Algoritmi n programare. Aplicatii
writeln('Suma elementelor < 0 din masiv este:',p:6:2)
else writeln('Nu exista elemente negative!');
readln
end;
4: begin
clrscr;
citire_vector(n,x);
inserare_0(n,x);
afisare_vector(n,x);
readln
end;
5: begin
clrscr;
citire_matrice(m,n,a);
linii_cresc1(m,n,a,k,v1);
if k>0 then begin
write('Liniile cu elemente in ordine crescatoare:');
for i:=1 to k do write(v1[i]:2)
end
else
writeln('Nu exista linii cu elem. in ordine crescatoare!');
readln
end;
6: begin
clrscr; vb:=false;
citire_matrice(m,n,a);
linii_cresc2(m,n,a,v1);
for i:=1 to m do
if v1[i]=1 then begin
writeln('linia',i:2,); vb:=true
end;
if not vb then writeln('Nu exista linii!');
readln
end;
7: begin
clrscr;
citire_vector(n,x);
write('Valoarea de cautat:'); readln(p);
if cautare1(n,x,p) then writeln('Valoare existenta!')
else write('Valoare inexistenta!');
readln
end;
8: begin
clrscr;
citire_vector(n,x);
write('Valoarea de cautat:'); readln(p);
l:=cautare2(n,x,p);
if l<>0 then
writeln('Prima aparitie este pe pozitia',l:3)
else write('Valoarea nu exista in vector!');
readln
end;
9: begin
clrscr;
write('Nr. de plane 3D:'); readln(l);
Subprograme externe
write('Nr. linii pe plan:'); readln(m);
write('Nr. coloane pe plan:'); readln(n);
for i:=1 to l do
for j:=1 to m do
for k:=1 to n do begin
write('el[',i,',',j,',',k,']=');
readln(t[i,j,k])
end;
maxim_plan3d(l,m,n,t,x);
write('Elementele maxime din fiecare plan sunt:');
afisare_vector(l,x);
readln
end;
10: begin
clrscr;
writeln('Textul de prelucrat:'); readln(s);
litere(s,v2);
writeln('Frecventele de aparitie a literelor sunt:');
for cc:='A' to 'Z' do write(cc:2);
writeln;
for cc:='A' to 'Z' do write(v2[cc]:2);
readln
end;
11: begin
clrscr;
citire_vector(n,x);
write('Valoarea de cautat:'); readln(p);
l:=cautare_binara(n,x,p);
if l=0 then
write('Valoare inexistenta sau vector nesortat!')
else write('Valoarea apare pe pozitia',l:3);
readln
end;
12: begin
clrscr;
citire_matrice(m,n,a);
transpusa(m,n,a,b);
writeln('Matricea transpusa este:');
afisare_matrice(n,m,b);
readln
end;
13: begin
clrscr;
citire_vector(n,x);
compactare(n,x);
if n=0 then
writeln('Vectorul rezultat are cardinalul = 0')
else begin
writeln('Vectorul compactat este:');
afisare_vector(n,x)
end;
readln
end;
14: begin
clrscr;
Algoritmi n programare. Aplicatii
citire_matrice(n,n,a);
write('Puterea la care se va ridica matricea:');
readln(l);
matrice_la_putere(n,l,a,b);
writeln('Matricea rezultat este:');
afisare_matrice(n,n,b);
readln
end;
15: begin
clrscr;
writeln('Textul de prelucrat:'); readln(s);
transformare_litere(s);
writeln('Textul transformat in litere mari este:');
writeln(s);
readln
end;
16: begin
clrscr;
citire_matrice(m,n,a);
maxim_coloane(m,n,a,x);
writeln('Elementele maxime pe fiecare coloana sunt:');
afisare_vector(n,x);
readln
end;
17: begin
clrscr;
citire_vector(n,x);
medie_geom(n,x,p,vb);
if vb then
writeln('Media geometrica nu se poate calcula!')
else writeln('Media geometrica este',p:6:2);
readln
end;
18: begin
clrscr;
citire_vector(n,x);
p:=medie_aritm_negative(n,x);
if p<0 then writeln('Media aritmetica este',p:6:2)
else writeln('Nu exista elemente negative in vector!');
readln
end;
19: begin
clrscr;
citire_matrice(n,n,a);
produs_vectorial_diagonale(n,a,x);
writeln('Rezultatul este:');
afisare_vector(n,x);
readln
end;
20: begin
clrscr;
citire_matrice(n,n,a);
writeln('Produsul scalar este',
produs_scalar_diagonale(n,a):6:2);
readln
Subprograme externe
end;
21: begin
clrscr;
citire_vector(n,x);
p:=produs_elem_pozitive(n,x);
if p>0 then writeln('Produsul este',p:6:2)
else writeln('Nu exista elemente pozitive!');
readln
end;
22: begin
clrscr;
citire_vector(n,x);
p:=ma_nenule(n,x);
if p<>0 then writeln('Media aritmetica este',p:6:2)
else writeln('Nu exista elemente nenule in vector!');
readln
end;
23: begin
clrscr;
citire_vector(n,x);
medie_armonica(n,x,p,vb);
if vb then
writeln('Media armonica nu se poate calcula!')
else writeln('Media armonica este',p:6:2);
readln
end;
24: begin
clrscr;
citire_matrice(m,n,a);
citire_matrice(k,l,b);
if n<>k then writeln('Dimensiuni incompatibile!')
else begin
produs_matrice(m,n,l,a,b,c);
writeln('Matricea rezultat este:');
afisare_matrice(m,l,c)
end;
readln
end;
25: begin
clrscr;
citire_vector(n,x);
sortare1(n,x);
writeln('Vectorul sortat prin interschimbare este:');
afisare_vector(n,x);
readln
end;
26: begin
clrscr;
citire_vector(n,x);
sortare2(n,x);
writeln('Vectorul sortat prin selectie este:');
afisare_vector(n,x);
readln
end;
27: begin
Algoritmi n programare. Aplicatii
clrscr;
writeln('ATENTIE! Vectorii trebuie sa fie sortati !!!');
writeln('Primul vector');
citire_vector(n,x);
writeln('Al doilea vector');
citire_vector(m,y);
interclasare(n,m,x,y,z);
writeln('Vectorul rezultat al interclasarii este:');
afisare_vector(n+m,z);
readln
end;
28: begin
clrscr;
citire_vector(n,x);
citire_matrice(m,k,a);
if n<>m then writeln('Dimensiuni incompatibile!')
else begin
vector_x_matrice(m,k,x,a,y);
writeln('Rezultatul inmultirii este:');
afisare_vector(k,y)
end;
readln
end
else begin
gotoxy(48,22);clreol;
textcolor(red+blink);
write('OPTIUNE ERONATA!',#7);
readln;
textcolor(white)
end
end;
meniu
end
end.

Dupa lansarea n executie a programului apelator, ecranul principal va arata ca n
figura urmatoare, utilizatorul avnd posibilitatea de a alege o optiune de la 1 la 28,
iar pentru iesirea din aplicatie, optiunea 0.

Subprograme externe

Programul apelator_masive nu include apelul subprogramelor care
lucreaza cu masive de elemente logice: suma_matrice_logice si
produs_matrice_logice. Pentru includerea acestora este nevoie de proceduri
speciale de citire/afisare, avnd n vedere particularitatile tipului Pascal
BOOLEAN, care nu poate fi citit din fisiere (si, implicit, de la tastatura), iar la
scriere se comporta diferit, n functie de tipul fisierului: binar sau TEXT (cazul
monitorului).
Pentru citirea datelor de tip logic de la tastatura este nevoie de stabilirea
unei conventii (de exemplu introducerea valorii 0 pentru fals si 1 pentru adevarat),
initializarea datelor booleene urmnd a fi realizata prin atribuire. Afisarea datelor
logice poate fi realizata fie prin valorile de adevar 0 si 1 (caz n care trebuie
refacuta conventia de la citire), fie direct, tinnd cont ca datele de tip BOOLEAN
se pot scrie n fisiere TEXT, prin conversia la sirurile de caractere TRUE si
FALSE.

program citire_afisare_matrice_booleana;
var
a:array[1..10,1..20] of boolean;
i,j,m,n,x:byte;
begin
write('Nr. de linii: ');
readln(m);
write('Nr. de coloane: ');
readln(n);

{citirea matricei booleene}
writeln('Elementele matricei (0-fals si 1-adevarat) ');
for i:=1 to m do
for j:=1 to n do
begin
write('el(',i,',',j,')= ');
Algoritmi n programare. Aplicatii
readln(x); {nu se fac validari}
{construirea matricei booleene}
if x=0 then a[i,j]:=false
else a[i,j]:=true
end;

{afisarea matricei booleene, cu valori 0 si 1}
for i:=1 to m do
begin
for j:=1 to n do
begin
if a[i,j]= false then x:=0 else x:=1;
write(x:2)
end;
writeln
end;

{afisarea matricei booleene, cu valori FALSE si TRUE}
for i:=1 to m do
begin
for j:=1 to n do write(a[i,j]:6);
writeln
end
end.