MINISTERUL EDUCAIEI,CERCETRII,TINERETULUI I

SPORTULUI
COLEGIUL TEHNIC MTSARI

ATESTAT
PROFESIONAL
Prof.Coordonator:
Sceanu Ion
Elev:
Lupu Lcrmioara-Marcela
Profil:
Matematic-Informatic
Colegiul Tehnic Mtsari

2015
1

MINISTERUL EDUCAIEI,CERCETRII,TINERETULUI I
SPORTULUI
COLEGIUL TEHNIC MTSARI

SUBPROGRAME
Prof.Coordonator:
Sceanu Ion
Elev:
Lupu Lcrmioara-Marcela
Profil:
Matematic-Informatic
Colegiul Tehnic Mtsari

2015
2

Cuprins

Subprograme4
Modul.7
Declararea i apelul unui subprogram.8
Funcii i proceduri pascal.11
Dezvoltarea programelor...14
Dezvoltarea ascendent
Dezvoltarea descendent (top down)
Implementri sugerate15
Probleme propuse...16
Soluiile problemelor propuse18
Bibleografie...27

Subprograme
Deseori n practic programrii se ntlnesc situaii de ndeplinire repetat
a unor secvene de program aplicate pe seturi diferite de date. Pentru a evita
aceste repetri i n scopul organizrii mai compacte a programului, n Pascal
exist posibilitatea de a separa aceste secvene de program ntr-un bloc
autonom n cadrul aceluiai program ,sub un anumit nume. Aa set de
instruciuni, ce realizeaz un anumit algoritm, se numete subprogram.
Subprogramele pot fi:
-functie -returneaz ntotdeauna o singur valoare;
-proceduri -pot returna zero, una sau mai multe valori;
Funciile i procedurile pot fi standard(existente deja n limbajul pascal) i
definite de utilizator.
Funcii standard: int, trunc, sqr, sqrt, abs, chr, ord, pred, succ;
Proceduri standard: read, readln, write, writeln, val, str, inc, dec;

Dac grupm instruciunile ntr-un subprogram, trebuie s comandm

execuia secvenei respective. Vom spune c apelm subprogramul.

Blocul de program din interiorul cruia se apeleaz un subprogram,

poart numele de modul apelant. Acesta poate fi programul principal sau
chiar un alt subprogram. Aadar subprogramele se pot apela unul pe
altul.

La fiecare apel al unui subprogram, modulul apelant poate

transmite acestuia nite date, pe care subprogramul le va folosi atunci
cnd se execut.

Aceste date se numesc parametri.

La fiecare execuie a sa, n urma unui apel, subprogramul poate s lucreze cu
alte date, pe care le-a recepionat sub forma unor parametri. Exist i
subprograme fr parametri, care opereaz direct asupra variabilelor
programului.
4

Dac grupm instruciunile ntr-un subprogram, trebuie s comandm

execuia secvenei respective. Vom spune c apelm subprogramul.

Blocul de program din interiorul cruia se apeleaz un subprogram,

poart numele de modul apelant. Acesta poate fi programul principal sau
chiar un alt subprogram. Aadar subprogramele se pot apela unul pe
altul.

La fiecare apel al unui subprogram, modulul apelant poate

transmite acestuia nite date, pe care subprogramul le va folosi atunci
cnd se execut.

Aceste date se numesc parametri.

La fiecare execuie a sa, n urma unui apel, subprogramul poate s lucreze cu
alte date, pe care le-a recepionat sub forma unor parametri. Exist i
subprograme fr parametri, care opereaz direct asupra variabilelor
programului.

Avantajele folosirii subprogramelor sunt:

O mai mare claritate i coeziune a programelor;
Posibilitatea de a executa instruciunile dintr-un subprogram de mai multe
ori, la fiecare execuie cu alte date.

Proceduri. Declarare i apel. Variabile globale i locale

O procedur este un modul de program alctuit dintr-o secven de instruciuni
care se execut ca urmare a apelrii procedurii dintr-un alt modul.
Exemplu: Fie dou numere reale a i b, realizeaz un program care afieaz
media aritmetic a celor dou numere.
Vom prezenta, pentru comparaie:
varianta cu un singur modul principal(Varianta V1)
5

 varianta n care folosim o procedur pentru calcularea mediei aritmetice

(Varianta V2)

Program sub_1
var ma,a,b:real;
begin;
write(a,b:);
readln(a,b);
ma:=(a+b)/2
writeln(ma:,ma:8:2);
readln;
end.
Program sub_1;
var ma,a,b:real;
procedure calcul media
begin
ma:=(a+b)/2
writeln(ma:,ma:8:2);
end;
begin;
write(a,b:);
readln(a,b);
calcul_media
readln;
end.
Deci, o procedur poate s primeasc date din partea modulului apelant,
date numite parametri. n cazul procedurii calcul_media, din exemplul
nostru nu are parametri. Ea folosete valorile a i b citite anterior n
programul principal.

Sunt aceste variabile cunoscute de procedur, dei ele au fost

stabilite n afara acesteia? Da, deoarece variabilele a i b au fost declarate
la nceputul programului, deci valorile lor sunt vzute n tot programul.
Acestea se numesc variabile globale.
Subprogramele sunt pri din program identificate printr-un nume, prin
intermediul cruia vor fi apelate.
Vom scrie subprograme atunci cnd:
-anumite instruciuni dintr-un program apar n mai multe locuri;
6

-dorim s mprim problema n subprograme;

Subprogramele pot fi:
-functie-returneaza ntotdeauna o singur valoare;
-proceduri-pot returna zero, una sau mai multe valori;
Funciile i procedurile pot fi standard(existente deja n limbajul pascal) i
definite de utilizator.
Funcii standard: int, trunc, sqr, sqrt, abs, chr, ord, pred, succ;
Proceduri standard: read, readln, write, writeln, val, str, inc, dec;
OBS! Att procedurile,ct i funciile trebuie declarate nainte de a fi apelate.

Modul
Noiunea de subprogram a aprut din necesitatea de a diminua complexitatea
unui program prin descompunerea acestuia n subprograme. Aplicarea acestui
concept reflect la un anumit nivel principiul programrii modulare. Conform
acestui principiu al ingineriei programrii, algoritmii se proiecteaz astfel nct
acetia s foloseasc module, unde prin modul nelegem o unitate structural de
sine stttoare (program, subprogram sau unitate de program). Fiecare modul
trebuie s aib un rol bine determinat i s fie conceput astfel nct s poat fi
folosit la nevoie i n cadrul unui alt program, fr a fi modificat. Orice modul
poate fi la rndul su construit din alte module.
Printre avantajele programrii modulare de care beneficiaz i conceptul de
subprogram amintim:
simplitatea i claritatea programului;
modulele sunt mai uor de descris, de testat, de corectat i eventual de
modificat; optimizarea unui program se poate realiza adesea doar prin nlocuirea
unui modul ineficient cu altul mai performant;
se evit rescrierea unui algoritm de cte ori este nevoie de acesta;
un modul o dat pus la punct va funciona la fel de bine i ntr-un alt
program care are nevoie de el;
se creeaz premisele realizrii unor aplicaii mari prin munca n echip a mai
multor programatori.
Subliniem c este important s se urmreasc creterea independenei
subprogramelor pentru a mri ansele reutilizrii lor n ct mai multe programe.
Aplicarea n practic a principiului modularitii implic stabilirea unor
detalii privind:
7

alegerea variantei optime de descompunere;

verificarea corectitudinii modului n care s-a realizat
descompunerea;
asigurarea comunicrii adecvate ntre subprograme.

Datele care asigur comunicarea ntre subprogram i modulul apelant sunt

definite ntr-o interfa a subprogramului cu exteriorul (numit lista
parametrilor formali). Restul datelor (date locale) sunt ascunse pentru exterior.
Datele definite n subprogram se numesc locale i vor tri ct timp
subprogramul respectiv este activ, din momentul activrii (apelrii) pn la
execuia ultimei instruciuni a subprogramului.
Datele definite n programul principal se numesc globale i vor fi vzute
(cu excepia celor redeclarate n subprogramul respectiv) n toate
subprogramele, deoarece programul principal este primul bloc care se activeaz
i ultimul care se dezactiveaz.
Lista parametrilor formali este declarat n antetul subprogramului i
conine parametri de intrare i/sau parametri de ieire.
n principiu, un parametru care desemneaz date strict de intrare pentru
subprogram se va transmite prin valoare, iar cel care este de ieire din
subprogram, se va transmite prin referin.

Declararea i apelul unui

subprogram
Structura unui subprogram seamn cu structura unui program:
TipSubprogram Nume(lista parametrilor formali) { antetul subprogramului }
declaraiile datelor locale
instruciune compus { descrierea algoritmului de rezolvare a subproblemei }
unde prin TipSubprogram nelegem precizarea tipului subprogramului (n
Pascal funcie sau procedur). Corpul subprogramului este format din
declaraiile locale ale sale i o instruciune compus.
Apelul subprogramului se face n partea de aciuni a modulului apelant. Dac
subprogramul returneaz o singur valoare (avem subprogram de tip funcie)
apelul poate s apar ntr-o expresie, oriunde sintaxa limbajului permite
prezena unei expresii. Dac un subprogram calculeaz mai multe valori (n
8

Pascal avem subprogram de tip procedur), apelul subprogramului are loc n

instruciunea procedural (va fi n sine o aciune i va aprea oriunde poate s
apar o instruciune).
n principiu, un apel se scrie preciznd numele subprogramului, urmat, ntre
paranteze, de lista parametrilor actuali. Efectul apelului const n activarea
subprogramului i transferul execuiei programului la prima instruciune
executabil din subprogram.
n prealabil valorile parametrilor actuali transmii prin valoare se copiaz n
variabilele care sunt parametri formali (acetia se pstreaz n timpul executrii
subprogramului n stiva de execuie), iar corespunztor parametrilor transmii
prin referin se comunic adresele parametrilor actuali. Orice modificare de
valoare asupra parametrului formal de tip referin (de tip adres) se va
efectua de fapt asupra parametrului actual corespunztor. Pentru ca acest lucru
s fie posibil, parametrul actual aferent unui parametru formal de tip referin
trebuie s fie o variabil.
Lista parametrilor actuali trebuie s aib tot atia parametri ca i lista
parametrilor formali i perechile corespondente de parametri trebuie s fie
compatibile ca tip.
S ptrundem acum mai adnc n procesul apelrii unui subprogram.
Pentru gestionarea simpl i natural a execuiei subprogramelor, se
utilizeaz o zon special a memoriei, numit stiv de execuie (Stack).
Amintim, c n general, se numete stiv o structur de date cu dou capete
baz i vrf. Introducerea, ct i extragerea de date n/dintr-o stiv este posibil
doar la unul dintre capete, numit vrful stivei. Stiva de execuie este o zon de
memorie n care se depun (i din care se extrag) date conform acestui principiu.
n urma apelului unui subprogram:
se ntrerupe executarea modulului apelant
se salveaz pe stiva de execuie urmtoarele informaii:
adresa instruciunii la care se va reveni dup execuia
subprogramulului apelat;
valorile parametrilor transmii prin valoare;
adresele parametrilor de tip referin;
se aloc spaiu pe stiv variabilelor locale;
se activeaz subprogramul (se pred controlul primei instruciuni a
acestuia);
se execut instruciunile subprogramului.
n momentul terminrii execuiei subprogramului se elimin de pe stiv toate
informaiile care s-au depus dup apelul acestuia i controlul revine primei
instruciuni de dup apel din modulul apelant.

Exemplu
Fie trei variabile a, b i c declarate n programul principal. Aceste variabile
sunt iniializate cu 0 i se apeleaz subprogramul Unu. Dup revenirea din
subprogram se afieaz valorile a, b i c.
Subprogramul Unu are doi parametri formali: x este parametru transmis prin
valoare, iar y este parametru de tip referin. n subprogram se declar variabila
local z. Acest subprogram atribuie celor trei variabile x, y i z valoarea 1.
n urmtoarea figur programul principal este simbolizat prin segmentul vertical de la 1 la 6,
punctul 2 corespunznd apelului de subprogram, iar punctul 5 primei instruciuni de dup apel. Subprogramul este reprezentat de segmentul vertical avnd
la capete punctele 3 (prima instruciune a subprogramului) i 4 (ultima
instruciune). Liniile cu sgei arat ordinea de execuie a instruciunilor din cele
dou uniti de program.
Programul principal:
Subprogram Unu(lista parametrilor formali:
variabile globale: a, b, c
x transmis prin valoare, y prin referin)
*
(T)
(T), variabil
.
...................................................
f
r
x

1
local: z
z1 b 0T
a0
c01 2
u
Apel
Unu
a,b

Pentru a prezenta modul de lucru cu stiva de execuie, vom urmri coninutul

acesteia n cele 5 puncte (momente) marcate. Variabilele globale a, b i c nu se
aloc pe stiv, ci n seciunea de date existent la dispoziia programului
principal, dar le vom preciza valorile n cele 5 momente.
Moment
1
2
3
4
5

Variabile globale Coninutul stivei

nedeterminate vid
a = 0; b = 0; c = vid
a = 0; b = 0; c = x = 0 adresa lui z
a = 0; b = 1; c = x = 1 adresa lui z = 1
a = 0; b = 1; c = vid
0;

Observm din tabel c instruciunea de atribuire x 1 nu are efect asupra

parametrului actual a, deoarece a fost transmis prin valoare, n schimb b devine
1, deoarece aciunea asupra parametrului formal y transmis prin referin s-a
10

efectuat asupra parametrului actual b.

n limbajul Pascal ntr-un program principal sau subprogram vom avea:
O parte de definiii i declaraii:
type... const...
var...
procedure...
function...

{ definiii de tip } { definiii

de constante } { declaraii de
variabile } { declaraii de
subprograme }

11

O parte de aciuni (o instruciune compus):

Begin...
instruciuni
End.
Observaie
Oricare seciune de definiie sau declaraie poate s lipseasc, n schimb
instruciunea compus trebuie s fie prezent (dar, poate fi vid).

Funcii si proceduri pascal

n limbajul Pascal subprogramele pot fi:
- funcii: calculeaz mai multe valori; una se returneaz prin numele
funciei;
- proceduri: calculeaz mai multe valori (sau nici una).
Apelul unei funcii face parte dintr-o instruciune (unde apare ntr-o
expresie), pe cnd apelul de procedur este definit ca fiind o instruciune.
Declararea unei funcii n limbajul Pascal
function Nume_funcie (lista parametrilor formali): tiprezultat;
declaraiile i definiiile locale funciei instruciune compus
Observaie
Printre instruciunile din cadrul instruciunii compuse a funciei (corpul
funciei) trebuie s existe cel puin o instruciune de atribuire prin care numelui
funciei i se atribuie o valoare.
Declararea unei proceduri n limbajul Pascal procedure NumeProcedur
(list parametrilor formali); declaraii i definiii locale procedurii
instruciune compus
Observaii (valabile n limbajul Pascal)
1) n faa oricrui parametru formal transmis prin referin se scrie cuvntul
cheie var. Parametrii formali care nu au cuvntul var n fa se consider a fi
parametri transmii prin valoare.
2) Tipul parametrilor formali se poate preciza doar cu identificator de tip;
3) Declaraiile n lista parametrilor formali sunt separate prin ;. Atunci cnd
avem mai muli parametri de acelai tip, acetia se separ prin virgul. n
urmtorul exemplu a, d, e i f sunt parametri de ieire (transmii prin
referin), b este parametru transmis prin valoare.

12

4) Valoarea retumat de o funcie (innd cont de faptul c aceasta retumeaz

prin identificatorul ei o singur valoare) poate fi doar de urmtoarele tipuri:1
2 1
orice tip ntreg;
orice tip real;
caracter (Char);
Boolean;
enumerare (avnd definit identificator de tip);
subdomeniu (avnd definit identificator de tip);
string.
Exemplul 1
S se calculeze urmtoarea expresie: C (n, k)

1-2 ...
(1 2 ...n k)[l-2 ... (n k)]

Se observ c n numrtor trebuie s calculm factorialul lui n, n numitor

factori- alul lui k i factorialul lui (n - k). Vom scrie un subprogram pentru
calcularea factoria- lului lui x i l vom apela pentru n, pentru k i pentru (n - k).
Deoarece acest subprogram, corespunztor unui apel va calcula o singur
valoare, ea va fi atribuit identificatorului funciei cu care o calculm.
n programul principal declarm variabilele n i k, ele reprezint datele de
intrare. Rezultatului nu-i planificm nici o variabil, deoarece acesta va fi
accesat pentru afiare prin identificatorul funciei, n momentul apelului.
Funcia fact va avea un parametru formal x care va fi pentru acest subprogram
un parametru de intrare (deci, se va transmite prin valoare). Funcia va returna
valoarea factorialului lui x. Variabila local p este necesar, deoarece n absena
ei, ar trebui s scriem n instruciunea for instruciunea de atribuire: fact:=fact*i
care ar nsemna apelarea funciei fact n momentul n care aceasta nc este
activ. (De fapt, dac am scrie instruciunea de atribuire exact n aceast
form, compilatorul ne-ar cere parametru actual n membrul drept dup
identificatorul fact, deoarece doar n membrul stng putem scrie identificator de
funcie fr parametri, apariia n membrul drept al acestuia fiind considerat
apel de funcie**)).
Program Expresie;
var n,k:Longint;{ variabile globale }
function fact(x:Integer):Longint;
var i:Integer; p:Longint;

{ antetul funciei }
{ variabile locale }

begin
p:=l;
1
2

13

for i:=1 to x do p:=p*i;

fact:=p
Begin

{ iniializarea factorialului }
{ calcularea factorialului }
{ atribuire identificatorului funciei

ReadLn(n,k);
WriteLn(fact(n)/(fact(k)*fact(n-k)))
End.

Exemplul 2
Se consider urmtorul program. Ce afieaz acesta?
Program Exemplu2; var
i:Integer;
function Suma(n:Integer):Integer; var
S:Integer;
begin
S:=0;
for i:=1 to 5 do
S:=S+n;
suma:=S
end;
Begin
for i:=1 to 5 do begin
Write(i,' ');
Write(suma(i),' ');
WriteLn(i)
end
End.
S urmrim variaia variabilelor:
programul principal ncepe cu ciclul for, prima valoare a variabilei i este
1;
se afieaz 1;
se apeleaz subprogramul cu parametrul actual i, a crui valoare se
copiaz n n, deoarece este transmis prin valoare;
n subprogram se calculeaz S, care va avea valoarea 0 + 1 + 1 + 1 + 1 +
1 = 5;
se atribuie valoarea 5 identificatorului de funcie;
se afieaz valoarea 5;
Urmeaz o alt afiare a variabilei i i (surpriz!) se afieaz 5 (ultima valoare a
lui i conform ciclului for din subprogram), ceea ce conduce i la terminarea
instruciunii for din programul principal.
14

Se observ c valoarea variabilei globale i s-a modificat din greeal n

subprogram. Pentru a evita astfel de greeli se va urmri ca variabilele folosite
de subprogram s fie ntotdeauna definite local subprogramului n care se
folosesc.
Pentru a obine rezultatele dorite, n programul de mai sus se va aduga n
partea de declaraii locale a funciei Suma declaraia: var i:integer.

Dezvoltarea programelor
Dac, n procesul proiectrii algoritmilor, o problem se descompune n
subprobleme i acestea se descompun la rndul lor n alte subprobleme pn
cnd se obin subprobleme care nu necesit continuarea procesului de divizare
spunem c avem un program dezvoltat descendent (top down). Aceast tehnic
corespunde modului n care uzual se proiecteaz algoritmii, folosind
subalgoritmi. Tehnica de proiectare n care se pornete de la unele programe
iniiale, acestea fiind folosite pentru a construi module din ce n ce mai
sofisticate care, asamblate s rezolve problema, se numete bottom up.

Dezvoltarea ascendent (bottom up)

Un program dezvoltat ascendent va avea toate subprogramele declarate unul
dup altul n programul principal. O astfel de abordare are ca avantaj faptul c
subprogramele sunt mai uor de testat i de controlat.
Program principal
Subprogram A

Subprogram C

Instruciunea compus a
programului principal

15

Trebuie menionat faptul c fiecare subprogram va putea apela numai

subprograme declarate anterior propriei declaraii. Din aceast restricie de
vizibilitate decurge i dezavantajul acestui stil de lucru care const n
dependena subprogramelor de unele subprograme definite anterior.

Dezvoltarea descendent (top down)

ntr-un program dezvoltat descendent fiecare subprogram va avea n propria
zon de definiii i declaraii subprogramele pe care le folosete. In cazul
subprogramelor imbricate unul n cellalt funcioneaz aceleai reguli ca ntre
unitatea de program principal i subprogram, adic entitile declarate, de
exemplu, conform figurii urmtoare, n subprogramul A se vd n
subprogramele B, C i D. Astfel, de regul, lista parametrilor se scurteaz.
Program principal Subprogram A
Subprogram B
Subprogram C
Subprogram D
Instruciunea compus a
subprogramului B
v________________
Instruciunea compus a
subprogramului A
Instruciunea compus a
programului principal

Implementri sugerate

n scopul formrii deprinderilor de a lucra cu subprograme v recomandm s:

1. rezolvai majoritatea problemelor tratate pn acum, n care problema
iniial se descompune n subprobleme folosind subprograme;
16

2.
3.

rezolvai probleme n care un acelai subprogram se apeleaz n mod repetat

pentru date diferite;
realizai un unit propriu care conine toate problemele rezolvate cu
subprograme i scrierea unor programe care folosesc acest unit.

Probleme propuse
Cifre comune
S se afieze cifrele comune a dou numere naturale date.
Date de intrare
Cele dou numere se citesc de pe primele dou linii ale fiierului comun.in.
Date de ieire
Cifrele comune ale celor dou numere se vor scrie n fiierul comun.out,
desprite prin cte un spaiu. n cazul n care nu exist nici o cifr comun, n
fiierul de ieire se va scrie 'Nu exista cifre comune.'.
Restrici
1

<
COMUN.OU
T

23

numrnumr2 < 1000000000.

Exemple COMUN.IN
12345 9377722
COMUN.IN

COMUN.OUT

12345
9877788

Nu exista cifre comune.

Prime i inversele lor prime

17

S se genereze toate perechile de numere prime formate din trei cifre care au
proprietatea de a fi, unul inversul celuilalt. Aici prin invers nelegem numrul
format din cifrele numrului dat, n ordine invers.
Date de ieire
n fiierul de ieire prime.out se vor scrie perechile de numere, cte una pe
fiecare linie, desprite prin cte un spaiu.
Exemplu
PRIME.OUT
101 1 107 701 113 311 131 131102

Eliminare de numere perfecte i

prietene
Se consider un ir de numere naturale. S se elimine din acest ir toate
numerele perfecte, precum i perechile de numere prietene aflate pe poziii
consecutive.
Date de intrare
Pe prima linie a fiierului sir. in se afl elementele irului, separate prin spaii.
Date de ieire
Elementele rmase n ir dup eliminare, se vor scrie n fiierul sir.out, separate
prin cte un spaiu.
Restricii i precizri
1< nr< 1000000000.
Exemple
SIR.IN
11 28 6 133 220 284 7 99

SIR.OUT

11 133 7 99

Generarea cuvntului de lungime

maxim
S se determine cuvntul de lungime maxim care poate fi construit din literele
unui text, astfel nct caracterele cuvntului s fie n ordine alfabetic i s fie
18

culese din text exact n ordinea n care se afl n cuvnt (nu neaprat pe poziii
succesive).
Date de intrare
Pe prima linie a fiierului de intrare cuv.in se afl textul dat.
Date de ieire
Cuvntul determinat, care are lungime maxim se va scrie n fiierul cuv.out.
Restricii i precizri
textul are cel mult 255 de caractere;
n text exist cuvinte formate din litere mici ale alfabetului englez i
spaii.
Exemplu
cuv.in
iarba si iasca

CUV.OUT

abis

Soluiile problemelor propuse

Cifre comune
Versiunea de algoritm prezentat n continuare se bazeaz pe operaiile cu
mulimi. n acest caz este necesar un subprogram care s construiasc o mulime
din cifrele unui numr. Subproblemele care vor fi implementate cu subprograme
n cazul acestei probleme, vor fi:
citirea numerelor;

crearea mulimii de cifre, (mulimile le implementm cu ajutorul irurilor,

dar dup ce se va nva tipul set (n Pascal), se recomand, ca exerciiu,
implementarea programului, folosind acest tip de structur de date);
afiarea cifrelor aparinnd interseciei de mulimi.
n Pascal declaraia irului care reprezint mulimea va fi:
type multime de cifre=array[0..9] of Boolean; var
A,B,inters:multime de cifre;
Dac, de exemplu, valoarea elementului A[i] este adevrat, nseamn c cifra
i face parte din mulimea A.
Subalgoritm Creare mulime(numr,M):

{ subprogram tip procedur }

19

pentru cifra=0,9 execut:

M[cifra] ^ fals
sfrit pentru
ct timp numr ^ 0 execut:
cifra ^ rest[numr/10]
M[cifra] ^ adevrat
numr ^ [numr/10]
sfr it ct timp
sfrit subalgoritm

{ deocamdat mulimeaMeste vid }

{ cifra exist n numr }

Intersecia mulimii A cu B este un ir de valori logice, unde un element are

valoarea adevrat dac, cifra corespunztoare se regsete i n A i n B.
Subalgoritm Intersecie(A,B,inters):
pentru cifra=0,9 execut:
inters[cifra] ^ fals
sfrit pentru
pentru cifra=0,9 execut:

{ subprogram tip procedur }

{ deocamdat intersecia este vid }

dac A[cifra] i B[cifra] atunci { dac cifra se afl i n A i n B }

inters[cifra] ^ adevrat
sfrit dac sfrit pentru sfrit subalgoritm
Pentru afiare, verificm apartenena cifrei cifra, (cifra = 0, 1,
9) la
mulimea in
tersecie inters. Dac mulimea este vid, afim mesajul cerut n enun.
Subalgoritm Afiare(inters):
exist ^ fals
pentru cifra=0,9 execut: dac
inters[cifra] atunci scrie cifra
exist ^ adevrat
sfrit dac sfrit
pentru dac nu exist
atunci
scrie 'Nu exist cifre comune.'
sfrit dac sfrit
subalgoritm

{ subprogram tip procedur }

{ am gsit o cifr comun }

Programul principal va apela subprogramele n ordinea lor fireasc: citire,

creare mulime A, creare mulime B, determinare intersecie i afiarea
interseciei.

Prime i inversele lor prime

20

O prim idee de rezolvare ar fi de a genera pe rnd toate numerele de trei cifre

(de la 100 la 999, eventual de la 101 la 997) i de a verifica dac att numrul,
ct i acel numr care conine cifrele numrului dat n ordine invers sunt sau nu
numere prime. n caz afirmativ acestea le-am scrie n fiierul de ieire.
Observm c pentru fiecare numr studiat suntem nevoii s verificm de
dou ori dac un numr este prim (o dat pentru numrul dat, a doua oar pentru
numrul generat din cifrele numrului luate n ordine invers). Acesta este un
motiv suficient de puternic pentru a scrie un subalgoritm pentru verificarea
primalitii unui numr. Subprogramul va fi apelat odat pentru numrul dat i
apoi pentru inversul su.
Subalgoritm Prim(nr):
{ subprogram tip funcie }
limita ^ parte ntreag din rdcina ptrat a lui nr
divizor ^ limita
ct timp nr nu se mparte exact la divizor execut: divizor
^ divizor - 1
sfrit ct timp
{ dac s-a gsit cel puin un divizor >1 numrul nr nu este
prim } dac divizor = 1 atunci prim ^ adevrat altfel prim ^ fals
sfrit dac sfrit subalgoritm Determinarea numrului format din cifrele
numrului dat n ordine invers o putem realiza cu subalgoritmul Invers, care n
Pascal va fi o funcie care va returna valoarea numrului nou.
Subalgoritm Invers(nr):
inv ^ 0
ct timp nr ^ 0 execut:
cifra ^ rest[nr/10] inv ^ inv*10 +
cifra nr ^ [nr/10]
sfr it ct timp invers ^ inv
sfrit subalgoritm

{ subprogram tip funcie }

Algoritm Prime:
{ algoritmul corespunztor programului principal }
pentru numr=101,997 execut:
dac Prim(numr) i Prim(invers(numr)) atunci scrie
numr,invers
sfrit dac sfrit pentru
sfrit algoritm
n urma executrii programului care implementeaz acest algoritm observm
c fiecare pereche este afiat de dou ori. Dac dorim s evitm afiarea dubl,
este necesar modificarea algoritmului.
21

Dac punem condiia ca prima cifr a primului numr s fie mai mic sau
egal cu ultima cifr a primului numr, vom evita afirile duble. Al doilea
numr se construiete ntotdeauna din primul i deci nu este necesar s punem
condiii asupra lui. Numerele din perechi astfel construite vor fi generate
cresctor. Instruciunea alternativ din structura de tip pentru s-ar putea scrie
astfel: dac [numr/100] < rest[numr/10] atunci...
n acest algoritm, instruciunea pentru se va relua de 997 - 101 + 1 = 897 ori.
ntr-o alt abordare a acestei probleme generm primul numr din cifrele a, b
i c i al doilea din aceleai cifre, dar n ordine invers, innd cont totodat i
de condiia ca prima cifr s fie mai mare sau egal cu a treia. Aceast variant
are i avantajul de a evita generarea dublurilor fr a folosi o condiie
suplimentar. De asemenea, nu vom lua n considerare ca posibil numr avnd
proprietatea solicitat dect numerele impare. Un numr impar are ultima cifr
impar, deci n ciclul for care genereaz a treia cifr se vor construi numere
doar cu cele 5 cifre impare (1, 3, 5, 7, 9).
Astfel, numrul executrilor corpului ciclului este 10 9 5 = 450 (care este
mai mic dect numrul executrilor n cazul primei variante: 897). n plus,
aceast variant nu necesit apelul subalgoritmului invers, deoarece inversul
numrului poate fi construit printr-o simpl atribuire. Subalgoritmul de
verificare a primalitii se va executa doar de 332 de ori, deoarece dac despre
numr se constat c nu este prim, numrul invers nu se mai verific.
Algoritm Prime i inversate prime 2:
pentru a=1,9 execut:
{ prima cifr din numr nu poate fi 0 }
pentru b=0 la 9 execut:
{ ultima cifr trebuie s fie cel puin egal
cu prima cifr }
pentru c=a la 9 execut:
dac c este numr impar atunci { limitm generarea la numere impare }
numr ^ a*100 + b*10 + c invers ^ c*100 + b*10 + a dac Prim(numr) i
Prim(invers) atunci scrie numr,invers sfrit dac sfrit dac sfrit pentru
sfrit pentru sfrit pentru sfrit algoritm.

Eliminare de numere perfecte i

prietene
Cerina acestei probleme este de a elimina dintr-un ir numerele perfecte sau
perechile de numere prietene aflate pe poziii consecutive n ir. Se observ c
22

aciunea principal este de a elimina unul sau dou elemente dintr-un ir, pe
baza unei condiii date.
Subalgoritmul Elimin va elimina elementul avnd indicele poziie din irul a
i va returna irul modificat, precum i dimensiunea actualizat a acestuia.
Subalgoritm Elimin(a,n,poziie):
{ subprogram tip procedur }
pentru i=poziie,n-1 execut:
{ se deplaseaz elementele tabloului }
a[i] ^ a[i + 1]
{ cu o poziie la stnga, ncepnd cu poziie + 1 }
sfrit pentru
{ numrul de elemente scade }
n^n1
sfrit
subalgoritm
Proprietile numerelor care trebuie eliminate:
numr perfect: este egal cu suma divizorilor mai mici dect el nsui;
numere prietene: perechi de numere n care un numr este egal cu suma
divizorilor celuilalt (mai mici dect acesta) i invers.
Se observ c n ambele situaii este nevoie de suma divizorilor proprii (plus
1) ai numrului. Deci, va fi util s scriem un subprogram care calculeaz aceast
sum.
Subalgoritm Suma divizori(numr):
{ subprogram tip funcie }
s^1
{ n aceast sum se adaug i 1 }
pentru d=2,[numr/2] execut: dac
rest[numr/d] = 0 atunci s ^ s + d sfrit dac
sfrit pentru Suma divizori ^ d sfrit
subalgoritm
Cele dou subprograme care verific dac un numr este perfect, respectiv
dac dou numere date sunt prietene vor returna o valoare de adevr (adevrat
sau fals).
Subalgoritm Perfect(numr):
{ subprogram tip funcie }
dac Suma divizori(numr) = numr atunci Perfect ^
adevrat
altfel
Perfect ^ fals
sfrit dac sfrit
subalgoritm
Subalgoritm Prietene(numr1,numr2):
{ subprogram tip funcie }
dac (Suma divizori(numr1) = numr2) i
(Suma divizori(numr2) = numri) atunci Prietene ^ adevrat altfel Prietene ^
fals sfrit dac sfrit subalgoritm.
23

Generarea cuvntului de lungime

maxim
n rezolvarea acestei probleme avem nevoie de dou tablouri de lucru:
Elementele irului L vor fi lungimi de cuvinte. Li pstreaz lungimea cea
mai mare posibil a cuvntului care ncepe cu litera care n text se afl pe
poziia i. Aceste cuvinte trebuie s respecte cerina ca literele din
componena lor s fie n ordine alfabetic.
Tabloul urm l construim pentru a asigura posibilitatea de a afia cel mai lung
cuvnt gsit. urmi va conine pentru a i-a liter din cel mai lung cuvnt,
indicele (n textul dat) a literei urmtoare n cuvnt.
Textul dat l vom parcurge de la sfrit spre nceput, ceea ce nseamn c
vom iniializa valoarea Ln cu 1, avnd semnificaia c cel mai lung cuvnt care
ncepe cu a n-a liter din text are lungimea 1. De asemenea, putem iniializa i
valoarea elementului urmn cu 0, deoarece tim c dup ultimul element nu poate
urma nici unul.

textul a p a
c u r g e
Indice i 2 3 4 5 6 7 8 9 10
L
urm

l i
11 1
2

n
1
31
0

n cele ce urmeaz vom cuta s determinm acel cel mai lung cuvnt n faa
cruia este permis s alipim a i-a liter din textul dat. Evident, aceasta, dac este
permis, nu poate fi la acest pas dect ultima liter. n concluzie L12 va fi egal cu
2 (cel mai lung cuvnt care ncepe cu a 12-a liter din text are lungimea 2), iar
urm12 va fi 13 (dup a 12-a liter urmeaz a 13-a):

24

textul a p a
c u r g e
Indice 1 2 3 4 5 6 7 8 9 10
L
urm

l i
11 1
2
1
3

n
1
1
0

Studiem litera l. Aceasta nu poate fi pus n faa literei i, deoarece ncalc

cerina privind ordonarea alfabetic, dar se poate pune n faa literei n. Deci, cel
mai lung
cuvnt care
textul a p a
c u r g e
l i n litera l are
ncepe cu
lungimea 2, Indice 1 2 3 4 5 6 7 8 9 10 11 1 1 iar
urmtoarea L
2 22 31 liter din
cuvnt este urm
1 1 0 din nou a
13-a.
3 3

Caracterul urmtor este spaiu. Acesta nu intr n configuraia nici unui

cuvnt, deci elementele corespunztoare din irul L i urm vor fi egale cu 0.
Urmeaz s studiem caracterul e. Acesta se poate pune n faa lui l, n faa lui i
i n faa lui n. Alegem dintre cele trei posibiliti pe aceea care conduce la un
cuvnt mai lung. Dintre literele l i i o alegem pe prima, i astfel cel mai lung
cuvnt care ncepe cu litera e are lungimea 3, iar urmtoarea liter este a 11-a.

textul a p a
c u r g
Indice i 2 3 4 5 6 7 8
L
urm

e
9
3
1
1

1
0
0

l
11
2
1
3

i
1
2
1
3

n
13
1
0

Litera g nu poate fi pus n faa lui e, n schimb poate fi pus n faa lui l, i i
n. Procedm cu litera g la fel cum am procedat cu e. Literele r i u nu pot fi puse
n faa nici uneia dintre literele luate n considerare pn acum, deci valorile
corespunztoare lor sunt 1 n irul L i 0 n irul urm. Litera c poate fi pus n
faa tuturor caracterelor; alegem acea posibilitate care d natere la un cuvnt
25

mai lung. Aceasta este g. Continund acest procedeu pn la epuizarea irului,

ajungem la urmtoarele valori n cele dou iruri L i urm:

textul a P a
c u r
indice 1 2 3 4 5 6 7
L
5 2 5 0 4 1 1

g
8
3

e
9
3

1
0
0

urm

1
1

1
1

0 8 0 0

l
11
2
1
3

i
1
2
2
1
3

n
13
1
0

Dup ce am construit aceste dou iruri, lungimea celui mai lung cuvnt este
egal cu valoarea elementului maxim din irul L. Deoarece noi trebuie s afim
nu lungimea, ci cuvntul, vom proceda n felul urmtor. Afim acel caracter
(din text) care are indicele egal cu indicele elementului maxim din irul L (cu
aceast liter ncepe cel mai lung cuvnt). Elementul irului urm, avnd acest
indice conine indicele literei urmtoare, care se afieaz. Urmrind astfel
coninutul irului urm afim literele celui mai lung cuvnt pn la sfritul
acestuia (valoarea corespunztoare ultimei litere n irul urm este 0).
textul a P a
c u r
Indice
3 4 5
7
1 2
6
L
5 2 5 0 4 1 1
urm

5 6 5 0 8 0 0

g
8
3
1
1

e
9
3
1
1

l
1
0
0
0

n
13

11 12
2 2 1
1 13 0
3

Afim a, deoarece valoarea maxim n irul L se afl pe poziia 1.

Apoi: urm1 = 5, afim caracterul c (poziia 5); urm5 = 8, afim litera g
(poziia 8); urm8 = 11, afim litera l (poziia l1); urm11 = 13, afim
litera n (poziia 13); urm13 = 0, deci afiarea se termin.
Subalgoritmul care modeleaz prelucrarea descris este urmtorul:
Subalgoritm Caut(n,textul):
L[n] ^ 1
{ cel mai lung cuvnt care ncepe cu a n-a litera are lungimea
1}
urm[n] ^ 0
{ dup ultima liter nu urmeaz alt caracter }
pentru i=n-1,1 execut: max ^ 0
indice ^ 0
26

pentru j=i+1,n execut:

{ ncercm s punem litera textul[i] n faa lui textul[j] } dac
(textul[i] ^ '
') i (textul[j] ^ '
') i
(textul[i] < textul[j]) atunci dac L[j] >
max atunci { dintre literele n faa crora se poate } { pune a i-a liter, o
alegem pe cea cu care ncepe cel mai lung cuvnt } max ^ L[j] indice ^ j
sfrit dac sfrit dac sfrit pentru dac textul[i] ^ '
' atunci
{ cel mai lung cuvnt care ncepe cu a i-a liter este egal cu lungimea celui
mai } L[i] ^ max + 1 { lung cuvnt n faa cruia punem a i-a liter (max) + 1 }
altfel
L[i] ^ 0
{ dac am avut caracter spaiu }
sfrit dac
urm[i] ^ indice { n indice am inut minte n faa crei litere o punem }
sfrit pentru
Maxim
{ cutm lungimea maxim din L }
Scrie
sfrit subalgoritm
n subalgoritmul de afiare indice reprezint indicele elementului maxim n
irul L.
Subalgoritm Scrie:
scrie textul[indice]
{ afim litera cu care ncepe cel mai lung cuvnt }
i ^ urm[indice]
{ indicele literei urmtoare }
ct timp i > 0 execut:
{ ct timp exist urmtor }
scrie textul[i]
i ^ urm[i]
{ indicele literei care urmeaz dup cea afiat }
sfr it ct timp sfrit
subalgoritm
Subprogramele Maxim i Scrie fac parte din zona de declaraii a
subprogramului Caut. Astfel toate variabilele declarate n Caut sunt accesibile
din subprogramele Maxim i Scrie, acestea neavnd astfel nevoie de parametri.

27

BIBLEOGRAFIE
https://www.scribd.com/search?query=grafuri+neorientate
http://www.referat.ro/referate/download/Subprograme_Pascal_2
f86e.html
http://info.mcip.ro/?cap=subprograme
http://www.yandex.com

28