Cuprins :

1. INTRODUCERE.......................................................................................3
2. Obiectivele practicii:..................................................................................4
2.1 Obiectivele generale ale practicii instructive:.........................................4
2.2 Compentențele profesionale:...................................................................4
2.3 Competențele specifice:..........................................................................4
3. Enunțul sarcinii individuale......................................................................5
3. Descrierea modului de elaborare a aplicației..........................................7
4. Listing-ul programului............................................................................11
5. Estimarea complexității algoritmilor aplicației....................................18
6. Rezultatele testări subprogramelor........................................................19
6.1 Date de intrare.......................................................................................19
6.2 Date de ieșire.........................................................................................19
7. Concluzie...................................................................................................22
8. Bibliografie...............................................................................................23

Chișinău 2016
 1. INTRODUCERE

Stagiu de practică reprezintă activitatea desfăşurată de noi studenţii, în

conformitate cu planul de învăţământ, care are drept scop verificarea cunoştinţelor
teoretice însuşite de aceştia în cadrul programului de instruire și înafara acestuia.

Instruirea practică a elevilor este o parte componentă a procesului educaţional şi are

ca scop aprofundarea cunoştinţelor teoretice şi a formării deprinderilor practice în
pregătirea de specialitate, realizate la lecţiile practice lucrări de laborator, stagii de
practică.
Însă, rezolvarea problemelor reale presupune elaborarea unor complexe programate
mari, care includ o gamă întreagă de probleme: proiectarea sistemului, elaborarea
părţilor componente ale algoritmului, reunirea diverselor fragmente ale programului
într-un produs final, documentarea.
Practica de instruire constituie o primă lucrare complexă de sine stătătoare a
studenţilor şi va contribui la formarea şi dezvoltarea calităţilor stric necesare nu numai
viitorilor programatori, dar şi fiecărui om cult care, la sigur, va trăi şi va activa într-un
mediu bazat pe cele mai moderne tehnologii informaţionale.

Practica s-a desfășurat pe baza unei programe analitice și a unei sarcini de lucru,
întocmite de instituţia de învăţământ în care studiem. Durata practicii, formele de
evaluare, şi creditele acordate pentru activitatea de practică sunt cele cuprinse în planul
de învăţământ.

Activitatea de practică inclusă în planul de învăţământ este obligatorie şi constituie

condiţie de promovare. Prezenţa la practică este obligatorie, căci ea este posibilitatea
noastră de promovare, dezvoltare și integrare.

2
 2. Obiectivele practicii:

2.1 Obiectivele generale ale practicii instructive:

- consolidarea cunoştinţelor teoretice, obţinute de studenţi pe parcursul studierii
limbajului de programare C++ şi mediului de programare C++ Builder ;
- însuşirea tehnologiei de elaborare a programelor mari;
- dezvoltarea abilităţilor muncii de sine stătătoare şi lucrul în echipă;
- formarea deprinderilor de cercetător.

2.2 Compentențele profesionale:

1. Respectarea dreptului de autor asupra resurselor digitale, a normelor de etică
şi securitate informaţională.
2. Identificarea principiilor de funcţionare, clasificare şi proiectare a conexiunii
între echipamentele reţelelor de calculatoare.
3. Proiectarea algoritmilor şi codificarea lui într-un limbaj de programare.
4. Utilizarea metodelor şi tehnicilor eficiente de programare.
5. Elaborarea aplicaţiilor, utilizând elementele programării orientate pe obiecte.
6. Modelarea, proiectarea şi implementarea sistemelor informatice.
7. Aplicarea fundamentelor teoretice ale ştiinţelor juridice, sociale şi economice
în activitatea profesională.

2.3 Competențele specifice:

1. Analiza structurală a problemei în studiu.
2. Aplicarea principiilor programării structurate, programării procedurale şi
programării orientate pe obiecte în scrierea algoritmilor şi elaborarea aplicaţiei.
3. Utilizarea tipurilor structurate de date (tablou, şir de caractere, mulţime, articol,
fişier etc.) adecvate pentru organizarea şi prelucrarea datelor.
4. Aplicarea tehnicilor de testare şi depanare a programelor elaborate.
5. Elaborarea unei aplicaţii cu interfaţă grafică de interacţiune cu utilizatorul;
3
 6. Gestionarea informaţiei utilizând resursele Internet.

3. Enunțul sarcinii individuale

17. Pădure. Planul unei Păduri Magice de formă dreptunghiulară cu dimensiunea

nm este format din zone pătrate cu latura 1 (vezi figura 1). Pentru fiecare zonă reală
din pădure se ştie tipul copacilor care o acoperă (număr natural mai mic decât 101). O
zonă este acoperită numai cu copaci de acelaşi tip. În formă numerică planul pădurii
este redat prin tabloul A cu n linii şi m coloane.
Să se creeze o aplicație care să realizeze, la
solicitarea utilizatorului, următoarele prescripţii:
(Design-ul aplicației vă aparține).
1) Interschimbă în matricea A două linii;
indicii liniilor de interschimb se vor introduce
de la tastatură;
2) Exclude din planul tablei o coloană
marginală; poziţia coloanei (vest/est) de exclus
se va preciza de la tastatură;
3) Determină lungimea celui mai lung subşir
nedescrescător al şirului elementelor coloanei
(matricei A) cu indicele precizat de la tastatură;
4) Înscrie în tabloul liniar B[1..n] în ordinea descendentă valorile Ai,n ( 1 ≤ i ≤ n);
datele se vor sorta prin metoda interclasării;
5) Determină cota (în procente) zonelor cu copaci de tipul indicat de la tastatură, în
raport cu numărul total de zone ale planului pădurii;
6) Creează fişierul text ParCol.txt, în care se vor transcrie, pe linii, elementele
coloanelor pare ale matricei A;
7) Găseşte în matricea A un pătrat pentru care diferenţa (max –min) este minimală,
unde max, min sunt, respectiv, maximul şi minimul elementelor din pătratul selectat.
Pe ecran se vor afişa coordonatele colţurilor stânga-sus şi lungimea laturii pătratului
găsit;

8) Rezolvă problema. Prinţul Algorel se află pierdut undeva prin Pădurea Magică şi
căută cu disperare drumul înapoi spre castelul său. El se poate deplasa în cele patru
direcţii: Nord, Sud, Est şi Vest, dar nu poate să iasă din pădure fiindcă dincolo de

4
pădure e tărâmul Spânului cel Râu. In drumul său către castel, prinţul trebuie să
plătească Pădurarului Magician un diamant pentru fiecare trecere dintr-o zonă în alta în
care se schimbă tipul copacilor (adică dacă cele două zone sunt acoperite cu tipuri
diferite de copaci). Pentru trecerile între zonele acoperite de acelaşi tip de copaci el nu
plăteşte nimic.

Cum diamantele sunt resursa cea mai importantă în regat, prinţul vrea să ştie numărul
minim de diamante pe care trebuie să-l plătească pentru a ajunge la castel.

Elaboraţi un subprogram, care, cunoscând planul pădurii, adresa curentă [pl, pc] a
prinţului şi adresa [cl, cc] a castelului, îl va ajuta pe Algorel să se descurce în situaţia sa
dificilă.

Date de intrare. Pe prima linie a fişierului Padure.in se afla 6 numere naturale n, m,

pl, pc, cl,cc, separate prin spaţii, cu Exemplu:
semnificaţia de mai sus.
Padure.in Padure.out
Următoarele n linii conţin cate m
651154 2
numere naturale separate prin spatii,
00056
reprezentând tipul copacilor care
77111 Restricţii: 1 ≤ n, m ≤ 1000
acoperă fiecare zonă din Pădurea
Magică. 11131 1 ≤ pl, cl ≤ n şi 1 ≤ pc, cc
≤m
11221
Date de ieşire. Fişierul de ieşire
00900
Padure.out va conţine pe prima
00009
linie un singur număr întreg D
reprezentând minimul de diamante pe care Algorel este nevoit să-l plătească pentru a
ajunge la castel.

5
 3. Descrierea modului de elaborare a aplicației

Am elaborat programul propriu-zis cu ajutorul unui program care permite asistarea

programatorului în toate fazele de elaborare a unui program, scris intr-un limbaj de
programare (editare, depanare, compilare, execuție).
Un astfel de mediu de programare este Code Blocks. Pentru realizarea acestei sarcini a
trebuit să aplic toate cunoștințele dobândite până în prezent. El permite scrierea sursei,
compilarea acesteia, lansarea în execuție a programului executabil. În plus, oferă și alte
facilități care depășesc cadrul acestui articol.

Pentru crearea unui astfel de program am efectuat următorii pași:

1. Deschidem programul și creăm un fișier nou (File -> New -> Empty File sau
scurtătura Ctrl+Shift+N).  

6
Este foarte important ca fișierul să fie salvat corect. Acesta poate fi de tipul: C/C++
files sau All files și este recomandat să adăugăm extensia cpp. Lipsa extensiei cpp va
conduce la erori în etapele următoare. 

2. După ce începem să scriem codul sursă, salvăm fișierul (File -> Save file sau
scurtătura Ctrl+S).

7
3. Scriem codul sursă și salvăm. La final va trebui să avem următorul fișier, afișat și mai
sus, în acest articol: 

4. Acest pas este foarte simplu, dar foarte important. Urmează compilarea și, dacă
aceasta reușește, urmează crearea executabilului și lansarea lui. Code :: Blocks oferă
mai multe opțiuni pentru aceste operații; dintre ele eu am folosit opțiunea de  Build ->
Build and run, cu scurtătura F9, care include toate aceste operații. 

8
5. Rularea programului va avea următorul efect: 

Erori la compilare:

Cazul descris mai sus este cel final; programul scris este corect, se compilează și îl
putem executa. Din nefericire, acest caz nu a fost așa de la început. Pînă a ajunge la
acesta, am trecut prin câteva compilări care erau inexecutabile din cauza unor erori..
9
La scrierea programelor greșim. Aceasta este realitatea, și nu trebuie să ne sperie.
Este important să descoperim erorile și să le corectăm. Aici intervine etapa de
compilare, care semnalează o categorie largă de erori, erorile de sintaxă. Acestea țin de
nerespectarea regulilor de scriere a programelor în C++, reguli care se învață în timp.
Imaginea de mai jos ne arată ce se întâmplă dacă omitem să scriem linia
1.using namespace std;
Observăm că în partea de jos a ferestrei se afișează o listă cu erori, pentru fiecare eroare
precizându-se linia unde s-a găsit și un scurt mesaj explicativ.

Deci pentru execuția programului este necesară maximum de atenție, corecție și

cunoștințe în domeniu. Erorile ne oferă posibilitatea de a perfecționa programul și
consider că corectarea lor este perfecționarea propriilor abilități de profesionist.

4. Listing-ul programului
#include <iostream>
#include <conio.h>
#include <stdlib.h>
10
#include <fstream>
#include <iomanip>
int l1,l2,i,j,m,n,v[20][20], temp,pl,pc,cl,cc;
int B[100];

using namespace std;

void citire()
{ ifstream f("Padure.in");
f>>n; f>>m;
f>>pl;f>>pc;
f>>cl; f>>cc;
for (i=1; i<=n; i++)
for (j=1; j<=m; j++)
{f>>v[i][j];}
f.close();}
//-------------------------------------------------
void afisare()
{for (i=1; i<=n; i++)
{for (j=1; j<=m; j++)
{cout<<v[i][j]<<" ";}
cout<<"\n";}}

void interschimbare()
{cout<<"\n Dati cele doua linii";
cout<<endl;
cin>>l1>>l2;
cout<<endl;
for (j=1; j<=m; j++)
11
 {temp=v[l1][j];
v[l1][j]=v[l2][j];
v[l2][j]=temp;}
for (i=1; i<=n; i++)
{for (j=1; j<=m; j++)
{cout<<v[i][j]<<" ";}
cout<<"\n";} }

void coloana()
{int m;
cout<<"Excludeti coloana :";
cin>>m;
cout<<"Matricea fara coloana "<<m<<" este:";
cout<<endl;
for(i=1;i<=n;i++)
{ for(j=1;j<=m;j++)
if(j!=m)
cout<<v[i][j]<<" ";
cout<<endl;}
}

void lungimea()
{int aux[n],i=0,j=0;
for (int i=0;i<=n;i++)
aux[i]=0;
cout<<"\nDati coloana: ";
int col;
12
 cin>>col;
for (int i=1; i<n; i++)
{ r1:
if (v[i][col]<=v[i+1][col])
aux[j]++;
else {j++;
i++;
goto r1; }}
cout<<endl;
int maxi=aux[0];
for (int i=1; i<=j; i++)
if (aux[i]>maxi)
maxi=aux[i];
cout<<"\nLungimea celui mai lung subsir al coloanei "<<col<<" este: "<<maxi+1;}

void tablou()
{ cout<<"\nDati intervalul liniilor: ";
int lin1,lin2;
cin>>lin1;
cin>>lin2;
int x=0;
for (int i=lin1; i<=lin2; i++)
for (int j=1; j<=m; j++)
{B[x]=v[i][j];
x++;
}
cout<<"\nAfisare tabloul B nesortat: \n";
for (int i=0; i<x; i++)
cout<<B[i]<<' ';
13
 cout<<endl;

//sortare tabloul B
x--;
int i,j, flag=1;
int temp;
for(i = 0; (i<=x) && flag; i++)
{flag = 0;
for (j=0;j<(x -1);j++)
{ if (B[j+1]> B[j])
{temp=B[j];
B[j]=B[j+1];
B[j+1]=temp;
flag=1; }
}}
cout<<"\nAfisare tabloul B SORTAT: ";
cout<<endl;
for (int i=0; i<x; i++)
cout<<B[i]<<' ';
cout<<endl; }

void cota()
{int copac=0;
float procente=0;
cout<<"Dati copacul: ";
cin>>copac;
for (int i=1; i<=n; i++)

14
 for (int j=1; j<=m; j++)
if (v[i][j]==copac)
procente+=1;
cout<<"\n Procente= "<<(procente/(n*m))*100<<setprecision(3)<<" %";}

void Inscriere()
{ ofstream g("ParCool.txt");
for (int j=1; j<=m; j++)
if (j%2==0)
{for (int i=1;i<=n;i++)
g<<v[i][j]<<' ';
g<<endl;}
g.close(); }

int main()
{ int men;
citire();
q: cout<<"\n --------------------------MENIU--------------------------------------";
cout<<"\n ALEGE OPTIUNEA DORITA";
cout<<endl;

cout<<"\n 1: Citirea datelor din fisier:";

cout<<"\n 2: Operatia de afisare";
cout<<"\n 3: Operatia de interschimbare a 2 linii";
cout<<"\n 4: Excluderea unei coloane";
cout<<"\n 5: Determinarea lungimii sirului nedescrescator";
cout<<"\n 6: Inscrierea in tabloul liniar B[1..n]";
15
 cout<<"\n 7: Determinarea cotei zonelor de copaci ";
cout<<"\n 8: Inscrie in fisier elementele coloanei pare ale matricei";
cout<<"\n 0: Exit";
cout<<endl;
cout<<"\n Aleg: ";
cin>>men;

switch (men)
{
case 1:citire();
break;
case 2:afisare();
break;
case 3:afisare(); interschimbare();
break;
case 4:afisare(); coloana();
break;
case 5:afisare(); lungimea();
break;
case 6:afisare(); tablou();
break;

case 7:afisare(); cota();

break;
case 8:Inscriere();
break;
case 0:goto exit;
}
16
getch();
system("cls");
goto q;
getch();
exit:
return 0;
}

5. Estimarea complexității algoritmilor aplicației

Teoria complexității este o ramură componentă a informaticii care se ocupă cu

studierea  complexității algoritmilor. Complexitatea reprezintă puterea de calcul
necesară implementării unui algoritm. Ea are două componente principale, și anume
complexitatea în timp și cea în spațiu.
17
Complexitatea în spațiu se referă la volumul de memorie necesar calculelor, iar cea în
timp se referă la timpul necesar efectuării calculelor, ambele fiind exprimate ca funcții
de n, unde n este mărimea datelor de intrare. Oricât de rapid ar fi un calculator, sau
oricât de mult s-ar ieftini memoria, eficienţa este factorul decisiv în alegerea unui
algoritm.
În general, complexitatea este exprimată folosind notația big O (Ỽ), notație ce reține
doar termenul care crește cel mai repede odată cu creșterea lui n[2], deoarece acest
termen are impactul cel mai mare asupra timpului de execuție al implementărilor
algoritmului, ceilalți termeni devenind neglijabili pentru valori mari ale lui n.
Ordinul de mărime Ỽ(g) se definește în felul următor:

unde g este o funcție definită pe N cu valori în R.

În termenul de complexitate pot include și procedurile care le-am folosit. Am

folosit în general un algoritm bazat pe cîteva proceduri, fiecare din ele conținînd
rezolvarea a cite o sarcină. Am deci în program următoarele proceduri: citire(), afisare(),
interschimbare(), coloana(), lungime(), tablou(), cota(), inscriere(). Am folosit proceduri
utile, scurte, corecte și usor de citit. Nu m-am piardut în detalii si am punctat exact ce
este important. De asemenea, am folosit aceste proceduri, deoarece există mai multe
modalități de a indeplini aceste sarcini si eu ca programist individual am ales doar una
dintre ele. In felul acesta am reușit să evit confuzia sau eventualele neatenții. O
procedură bine facută ajută la creșterea productivității programului. Astfel am reușit să
reduc numărul de erori și omisiuni și mie personal mi-a fost cu mult mai ușor să
efectuez aceste sarcini complexe mult mai rapid ca timp si mult mai eficient ca
productivitate.
Timpul de execuție a programului în întregime îl putem afla direct de la execuția
acestuia:

Padure.in
6. Rezultatele testări subprogramelor 651154
00056
77111
11131
18
11221
00900
00009
6.1 Date de intrare

Padure.out
6.2 Date de ieșire 2

 Meniul:

19
 Sarcina 1: Interschimbă în matricea A două linii ; indicii liniilor de interschimb
se vor introduce de la tastatură;

 Sarcina 2: Exclude din planul tablei o

coloană marginală; poziția coloanei
(vest/est) de exclus se va preciza de la
tastatură;

 Sarcina 3: Determină
lungimea celui mai lung
subșir nedescrescător al
șirului elementelor coloanei
(matricei A) cu indicele
precizat de la tastatură;

20
 Sarcina 4: Înscrie în tabloul liniar B[1..n] în ordinea descendentă valorile Ai , n
(1≤i≤n) ; datele se vor sorta prin metoda interclasării;

 Sarcina 5: Determină cota (procente) zonelor cu

copaci de tipul indicat de la tastatură, în raport cu
numărul total de zone ale planului pădurii;

 Sarcina 6: Creează fișierul text ParCol.txt, în care

se vor transcrie, pe linii, elelmentele coloanelor pare
ale matricei A;

7. Concluzie

21
 Cu ajutorul acestei practici am putut înţelege mai bine cum lucrează programul cu
fişiere. Am înţeles cum e mai bine să fac programul ca să fie mai eficient şi cît mai mic
în volum. În perioada practicii instructive am reuşit să recapitulez tehnicile de
pogramare şi instrucţiunile de programare.

Am aprofundat cunoştinţele în utilizarea tipurilor structurate şi de date aşa ca:

tablourile bidimensionale, fişierele, citirea datelor din fişier, înscrierea şi opererea
datelor din acestea. Practica de inițiere reprezintă o parte componentă a procesului
educativ care este o perioadă importantă pentru noi, deoarece anume in timpul petrecerii
practicii ne aprofundăm cunostințele acumulate timp de doi ani, de asemenea ne permite
să aplicăm in practică și cunostințele teoretice la obiectul “Programarea
Calculatorului”.

La rîndul său, practica de inițiere imită întregul proces de elaborare a unui

complex programat mare, care îmi permite să evoluez în rolul de elaborator şi
organizator al proiectului. Pot spune că nu a fost foarte simplă efectuarea acestei lucrări,
însă puțină informare de pe paginile WEB, ajutorul colegilor, cunoștințele personale,
ideile, aptitudinile și munca asiduă mi-au fost de mare ajutor.

Consider că pe parcursul acestor trei săptămîni și a întregii practici de

specialitate am reușit să-mi ating obiectivele profesionale formate de la început și
anume:
 dezvoltarea abilităţilor muncii de sine stătătoare ;
 lucrul în echipă;
 formarea deprinderilor de cercetător;
 însuşirea tehnologiei de elaborare a programelor mari;
 utilizarea metodelor şi tehnicilor eficiente de programare;
 și desigur proiectarea algoritmilor şi codificarea lui într-un limbaj de
programare.

8. Bibliografie
22
1. I. Bolun, I. Covalenco. “Bazele informaticii aplicate”, ediţia a III-a. Chişinău,
Editura ASEM, 2005.
2. Gh. Bostan. “Culegere de probleme de informatică”. Chişinău , Editura "Lumina”
3. A. Gremalschi, Iu. Mocanu, I. Spinei. ”INFORMATICA. Limbajul Pascal”.
Chişinău , Editura Î.E.P. Ştiinţa, 2003
4. S.Corlat, L.Ivanov, V.Bîrsan. “Informatica, Ghid de implementare a
curriculumului modernizat, pentru treapta liceală”. Chişinău, "Cartier", 2010.
5. UNIVERSITATEA DE STAT TIRASPOL COLEGIUL FINANCIAR - BANCAR
Silviu GÎNCU. “Metodologia rezolvării problemelor de informatică în stilul
orientat pe obiecte”.
6. http://www.infoarena.ro/problema/scmax
7. https://walkinthroughlife.wordpress.com/2010/11/15/programare-dinamica-subsir-
maximal-crescator/
8. https://alexmoldovan1.wikispaces.com/interschimbare+linii+matrice
9. http://algoritmifundamentali.blogspot.md/2012/10/stergere-coloaa.html
10.http://tys.ro/programare/cpp/matrici.html
11.http://www.codeblocks.org/
12.http://totuldesprecalculatoare.weebly.com/tutorial-c.html
13.http://www.pbinfo.ro/?pagina=intrebari-afisare&id=27

23