MINISTERUL EDUCAŢIEI AL REPUBLICII MOLDOVA

Centrul de Excelenţă în Informatică şi Tehnologii

Informaţionale

RAPORT
LA PRACTICA DE SPECIALITATE
SPECIALITATEA INFORMATICĂ

TEMA : Vopseaua

Cuprins

1.Introducere................................................................................................1
 Cuprins:
1.Introducere:.................................................................3
1.1 Obiectivele practicii:..............................................3
1.2 Competenţele practicii:..........................................3
1.3 Compententele profesionale:.................................4
1.4Competentele specifice:..........................................4
2.Enunţul sarcinii individuale:.......................................5
3.Listeng-ul programului:..............................................6
4.Desenul initial al formelor:.......................................23
5. Rezultatele testării subprogramelor:........................24
6. Concluzie:................................................................27
7.Bibliografie:..............................................................28

2
 1.Introducere:
Instruirea practică a elevilor reprezintă 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. Instruirea practică este obligatorie şi are menirea de a îmbina sfera
educaţională şi cea profesională.
Pascalul este limbajul fundamentul al programării moderne, de accea studierea acestui
limbaj este esențială pentru studierea limbajelor de programare contemporane.
Practica de inițiere ne pregătește de viața matură în care noi în calitate de programiști
vom fi nevoiți să elaborăm programe complexe, într-un termen limitat de timp.

1.1 Obiectivele practicii:

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 CBuilder (sau C#, Visual C+);
- î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.
.

1.2 Competenţele practicii:

Competenţele practicii:
1. Competenţe de învăţare de a învăţa să înveţi.
2. Competenţe de comunicare în limba maternă / limba de stat.
3. Competenţe de comunicare într-o limbă străină.
4. Competenţe acţiona-strategice.
5. Competenţe de autocunoaştere şi autorealizare.
6. Competenţe interpersonale, civice, morale.
7. Competenţe de bază în matematică, ştiinţe şi tehnologie.
8. Competenţe digitale, în domeniul tehnologiei informaţiei şi comunicaţiilor (TIC).
9. Competenţe culturale, interculturale (de a recepta şi a crea valori).
10. Competenţe antreprenoriale, spirit de iniţiativă şi antreprenoriat.
11. Competenţe de comunicare în limba maternă / limba de stat.
12. Competenţe de bază în matematică, ştiinţe şi tehnologie.
13. Competenţe digitale, în domeniul tehnologiei informaţiei şi comunicaţiilor (TIC).

3
 1.3 Compententele 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. Conceperea produselor multimedia.
7. Utilizarea tehnologiilor şi instrumentelor de proiectare, elaborare şi programare a aplicaţiilor
WEB.
8. Modelarea, proiectarea şi implementarea sistemelor informatice.
9. Aplicarea fundamentelor teoretice ale ştiinţelor juridice, sociale şi economice în activitatea
profesională.

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

4
 2.Enunţul sarcinii individuale:
10. Vopseaua. Se consideră o tablă de dimensiunea nm, împărţită în zone pătrate de lungimea 1
(exemplu vezi în figura 1). Fiecare zonă a tablei are o anumită înălţime.
Zona [L, C]
Informaţii mai detaliate despre zonele tablei considerate sunt
înregistrate în fişierul text Vopsea.in, care conţine pe prima
123…j…m12…iZona [i, j] linie numerele naturale n şi m, separate prin spaţiu.
…n Fig. 1. Planul tablei. Următoarele n linii ale acestui fişier conţine câte m numere
reale pozitive, separate prin câte un spaţiu, fiecare din aceste
valori reprezentând înălţimea zonei respective [i, j], 1 ≤ i ≤ n,
1 ≤ j ≤ m.
În continuare, tablei în studiu îi vom asocia o matrice
A[1..n,1..m], în care sunt înscrise înălţimile zonelor respective.
Să se creeze o aplicație care să realizeze, la solicitarea
utilizatorului, următoarele prescripţii:
(Design-ul aplicației vă aparține).
1) Înterschimbă în fişierele de intrare prima cu ultima linie;
2) Exclude din planul tablei un rând (marginal) / o coloană (marginală); poziţia rândului
(nord/sud) / coloanei (vest/est) de exclus se va preciza de la tastatură;
3) Determină dacă pentru matricea A există punct şa sau nu, iar în caz afirmativ menţionează
coordonatele şi valoarea punctului şa.
Notă. Se numeşte punct şa elementul A[is, js], care este minimal în linia is şi maximal în coloana
js.
4) Afişează pe ecran lista coloanelor tablei, în ordinea descendentă a maximelor înălţimilor zonelor
din coloanele respective; sortarea datelor se va realiza prin metoda inserţiei.
5) Determină înălţimea medie a zonelor situate pe perimetrul (marginea) tablei în studiu;
6) Creează fişierul text OrdSir.txt, în care se vor copia acele linii ale fişierului de intrare
Vopsea.in, care reprezintă şiruri  ordonate (crescător sau descrescător).
7) Găseşte în reţeaua planului tablei un pătrat de arie maximală, ce conţine pe diagonale zone doar
de înălţimi ce nu depăşesc numărul întreg H, citit de la tastatură. Laturile pătratului vor coincide cu
laturile zonelor din plan. la ecran se va afişa aria S şi coordonatele colţurilor stânga –jos şi dreapta –
sus ale pătratului găsit;

8) Rezolvă problema: Se consideră o zonă [L,C] a tablei în studiu. Să ne imaginăm că peste

această zonă curge vopsea care se prelinge peste zona vecină dacă înălţimea acesteia nu depăşeşte
înălţimea zonei deja vopsite. Prelingerea are loc în direcţie verticală şi orizontală, dar nu şi pe
diagonală. Alcătuiţi o procedură care ar determina zonele vopsite pornind de la zona iniţială [L,C];
Date de intrare. Numerele naturale L şi C se vor citi de la tastatură, iar înălţimile zonelor –din
fişierul Vopsea.in, descris anterior;

5
 Date de ieşire. Fişierul Vopsea.out, în cele n linii ale sale va conţine câte m caractere din
mulţimea {’*’, ’O’}, separate prin câte un spaţiu; cu caracterul ’*’ se vor marca zonele vopsite, iar
celelalte zone –prin caracterul ’O’.
Exemplu (zona vopsită iniţial: [L,C]=[4,3] ):
Vopsea.in Vopsea.out Restricţii:
7 6 O O O O O O 2 ≤ n,m ≤ 20
28 27 26 25 24 23 0< A[i, j] ≤ 50
* O * * * O
4 17 7 6 5 16 * * * O * *
7 8 10 12 3 1 O O * * O O
13 12 11 11 17 19 O * O * * O
16 1 18 10 5 16 * * * * O O
4 5 9 10 18 4 O O O O O O
18 17 16 11 5 3

3.Listeng-ul programului:
1.Programul principal:
a)Unit1.cpp
#include <vcl.h>
#include <iostream>
#include <fstream>
#pragma hdrstop
#include "Unit1.h"
#pragma package(smart_init)
#pragma resource "*.dfm"
using namespace std;
TForm1 *Form1;
int n,m;
int a[20][20];
TPoint ZV[400];
TPoint ZC[400];
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
Memo1->Lines->Clear();
}
//--------------------------------------------------------------------------------
6
void DeleteRowFromStringGrid(TStringGrid *Grid, int ARow)
{
int count = Grid->RowCount;
if ( count <= 1 ) return;
for ( ARow; ARow < count; ARow++ )
{
Grid->Rows[ARow] = Grid->Rows[ARow+1];
}

Grid->RowCount--;
Grid->SetFocus();
}
//--------------------------------------------------------------------------------
void DeleteColFromStringGrid(TStringGrid *Grid, int ARow)
{
int count = Grid->ColCount;
if ( count <= 1 ) return;
for ( ARow; ARow < count; ARow++ )
{
Grid->Cols[ARow] = Grid->Cols[ARow+1];
}

Grid->ColCount--;
Grid->SetFocus();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Memo1->Lines->Clear();
Memo1->Lines->LoadFromFile(Edit1->Text);

int i,j,x,q;
AnsiString s;
s = Memo1->Lines->Strings[0];

x = s.Pos(' ');
7
 n = StrToInt(s.SubString(1, x-1));
m = StrToInt(s.SubString(x+1, 2));

for(i=0; i<n; i++)

{
s = Memo1->Lines->Strings[i+1];
j=0;
do {
x = s.Pos(' ');
q = StrToInt(s.SubString(1, x-1));
a[i][j] = q;
s = s.SubString(x+1, s.Length());
j++;
}while (j < m);
};
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
int i,j,x,q;
AnsiString s;

for(int j=0; j<m; j++)

{
x = a[0][j];
a[0][j] = a[n-1][j];
a[n-1][j] = x;
}

Memo1->Lines->Clear();
s = IntToStr(n) + ' ' + IntToStr(m);
Memo1->Lines->Add(s);

for(i=0; i<n; i++)

{
8
 s = ' ';
for(j=0; j<m; j++)
s = s + IntToStr(a[i][j]) + ' ';
Memo1->Lines->Add(s.SubString(2, s.Length()));
};

Memo1->Lines->SaveToFile("Vopsea.in.txt");

}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button3Click(TObject *Sender)
{
int i,j,x,q;
AnsiString s;
s = Memo1->Lines->Strings[0];

x = s.Pos(' ');
n = StrToInt(s.SubString(1, x-1));
m = StrToInt(s.SubString(x+1, 2));

StringGrid1->RowCount = n;
StringGrid1->ColCount = m;

for(i=0; i<n; i++)

{
s = Memo1->Lines->Strings[i+1];
j=0;
do {
x = s.Pos(' ');
StringGrid1->Cells[j][i] = s.SubString(1, x-1);
s = s.SubString(x+1, s.Length());
j++;
} while (j < m);
};

}
9
//---------------------------------------------------------------------------
void __fastcall TForm1::Button4Click(TObject *Sender)
{
Close();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button5Click(TObject *Sender)
{
int a;
a=StrToInt(Edit2->Text);
DeleteRowFromStringGrid(StringGrid1, a-1);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button6Click(TObject *Sender)
{
int a;
a=StrToInt(Edit3->Text);
DeleteColFromStringGrid(StringGrid1, a-1);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button7Click(TObject *Sender)
{
int NRows,MColumns;
int L, C, max, min;
int x = 0;
bool flag;
NRows = StringGrid1->RowCount;
MColumns = StringGrid1->ColCount;

min = StrToInt(StringGrid1->Cells[0][0]);
L = -1;
C = -1;

for(int i=0; i < NRows; i++)

{
for(int j = 0; j < MColumns; j++)
10
 if(min > StrToInt(StringGrid1->Cells[j][i]))
{
min = StrToInt(StringGrid1->Cells[j][i]);
L = i;
C = j;
};

max = min;
flag = false;
int k = 0;
for(k=0; k < NRows; k++)
{
if ( k == L ) continue;
if ( max < StrToInt(StringGrid1->Cells[C][k]) )
{
flag = false;
break;
}
else
flag = true;

};
if ( flag )
{
ShowMessage("Punct sa : \n Linia = " + IntToStr(L+1) + "; Coloana = " + IntToStr(C+1) + ";
Valoarea = " + IntToStr(min));
x++;
break;
};
};
if (x == 0)
ShowMessage("Nu exista punt sa!");

}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button8Click(TObject *Sender)
11
{
int i,j,x,q;
int NN, SS;

NN = 0;
SS = 0;
for(i=0; i<n; i++)
for(j=0; j<m; j++)
{
if( (i == 0) || (j == 0) || (i == n-1) || (j == m-1) )
{
NN++;
SS+=a[i][j];
}
}

float Med = float(SS) / float(NN);

ShowMessage("Inaltimea med. = " + FloatToStrF(Med, ffFixed,10,2) );
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button10Click(TObject *Sender)
{
int i, j, max, min;
bool cresc, descr;
AnsiString s;

Memo2->Lines->Clear();
for(i=0; i<n; i++)
{
cresc = false;
descr = false;
max = a[i][0];
min = a[i][0];
s = IntToStr(a[i][0]);

for(j=1; j<m; j++)

12
 {
if (max < a[i][j])
{
max = a[i][j];
cresc = true;
s = s + ' ' + IntToStr(a[i][j]);
} else
{
cresc = false;
break;
}
};
for(j=1; j<m; j++)
{
if (min > a[i][j])
{
min = a[i][j];
descr = true;
s = s + ' ' + IntToStr(a[i][j]);
} else
{
descr = false;
break;
}
};

if (cresc || descr)
Memo2->Lines->Add(s);

};

Memo2->Lines->SaveToFile("OrdSir.txt");
ShowMessage("Fisier creat!!!");
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button11Click(TObject *Sender)
13
{
int b[2][20];
int c[20][20];
int i, j, max, C, x, y;
/*AnsiString s1 = NULL;
AnsiString s2 = NULL;*/

max = a[0][0];
C = 0;
for(j=0; j<m; j++)
{
for(i=0; i<n; i++)
{
if (max < a[i][j])
{
max = a[i][j];
C = j;
};
};

b[0][j] = max;
b[1][j] = C;
};

for(i=1 ; i<=n; i++)

if (b[0][i] > b[0][i-1])
{ x = b[0][i];
y = b[1][i];
j = i-1;
while (j >= 0 && b[0][j] < x)
{
b[0][j+1] = b[0][j];
b[1][j+1] = b[1][j];
j--;
};
b[0][j+1] = x;
14
 b[1][j+1] = y;
};

StringGrid1->RowCount = n;
StringGrid1->ColCount = m;

for(i=0; i<m; i++)

{
x = b[1][i];
j=0;
do {
StringGrid1->Cells[i][j] = IntToStr(a[j][x]);
j++;
} while (j < m);
};

}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button9Click(TObject *Sender)
{
int i,j, k, p;
int H, LMin, LMax;
TPoint SJ, SS, DJ, DS;
bool EstePatrat, dP, dS;
int Aria;

H = StrToInt(Edit4->Text);

if ( n <= m)
LMin = n;
else
LMin = m;

SS.x = 0; SS.y = 0;
SJ.x = LMin-1; SJ.y = 0;
15
DS.x = 0; DS.y = LMin-1;
DJ.x = LMin-1; DJ.y = LMin-1;

k = 0;
p = 0;

for (i = LMin; i > 0; i--)

{
EstePatrat = false; dP = false; dS = false;

for (j=0; j<=i-1; j++)

if ( a[j+k][j+p] > H )
{
dP = false;
break;
}
else
{
dP = true;
};

if (dP)
for (j=0; j<=i-1; j++)
if ( a[j+k][i-1-j+p] > H )
{
dS = false;
break;
}
else
{
dS = true;
};
EstePatrat = dP && dS;
if (EstePatrat) break;

if ( DS.y+1 < m )
16
 {
SS.y++; SJ.y++;
DS.y++; DJ.y++;
i++; p++;
}
else
{
SS.y = 0; SJ.y = 0;
DS.y = i-1; DJ.y = i-1;
p = 0;
if ( SJ.x+1 < n )
{
SS.x++; SJ.x++;
DS.x++; DJ.x++;
i++; k++;
}
else
{
SS.x = 0; SS.y = 0;
SJ.x = i-2; SJ.y = 0;
DS.x = 0; DS.y = i-2;
DJ.x = i-2; DJ.y = i-2;
p = 0; k = 0;
}
};
};
if (EstePatrat)
{
Aria = i * i;
ShowMessage("Exista patrat cu aria = " + IntToStr(Aria) + ";\nColt Stinga Jos : " +
IntToStr(SJ.x+1) + "," + IntToStr(SJ.y+1) + ";\nColt Dreapta Sus : " + IntToStr(DS.x+1) + "," +
IntToStr(DS.y+1));
}
else
ShowMessage("Nu exista asa patrat");

17
}
//---------------------------------------------------------------------------

bool EsteVerificat(int Line, int Column, int ii)

{
int k;
bool z = false;

for (k=0; k < ii; k++)

if ( (ZV[k].x == Line) && (ZV[k].y == Column) )
{
z = true;
break;
};

if ((Line < 0) || (Column <0 )) z = true;

return z;

//---------------------------------------------------------------------------
void __fastcall TForm1::Button12Click(TObject *Sender)
{
int L, C;
int i = 0, j = 0, q = 0;
int ec, cc = 0;
AnsiString s;
bool F;

s = Edit5->Text;
i = s.Pos(" ");
L = StrToInt(s.SubString(1, i-1));
C = StrToInt(s.SubString(i+1, s.Length()));

L--;
18
C--;

i = 0;
ZV[i].x = L;
ZV[i].y = C;

for(;;)
{
if ( i < cc ) break;

L = ZV[cc].x;
C = ZV[cc].y;
ec = a[L][C];

if ( (!EsteVerificat(L, C-1, i) ) && ( C-1 >= 0 ) )

{
if ( a[L][C-1] <= ec )
{
i++;
ZV[i].x = L;
ZV[i].y = C-1;
}
else
{
j++;
ZC[j].x = L;
ZC[j].y = C-1;
};
q++;
}
else q++;

if ( (!EsteVerificat(L, C+1, i) ) && ( C+1 < m ) )

{
if ( a[L][C+1] <= ec )
19
 {
i++;
ZV[i].x = L;
ZV[i].y = C+1;
}
else
{
j++;
ZC[j].x = L;
ZC[j].y = C+1;
};
q++;
}
else q++;

if ( (!EsteVerificat(L-1, C, i) ) && ( L-1 >= 0 ) )

{
if ( a[L-1][C] <= ec )
{
i++;
ZV[i].x = L-1;
ZV[i].y = C;
}
else
{
j++;
ZC[j].x = L-1;
ZC[j].y = C;
};
q++;
}
else q++;

if ( (!EsteVerificat(L+1, C, i) ) && ( L+1 < n ) )

{
if ( a[L+1][C] <= ec )
20
 {
i++;
ZV[i].x = L+1;
ZV[i].y = C;
}
else
{
j++;
ZC[j].x = L+1;
ZC[j].y = C;
};
q++;
}
else q++;

if (q == 4) { cc++; q =0;};
};

StringGrid1->RowCount = 1;
StringGrid1->ColCount = 1;

StringGrid1->RowCount = n;
StringGrid1->ColCount = m;

cc = i;
s = NULL;
Memo2->Lines->Clear();

for(i=0; i<n; i++)

{
s = NULL;
for(j=0; j<m;j++)
{
F = false;
for(q=0; q<=cc; q++)
if ( ( ZV[q].x == i ) && ( ZV[q].y == j ) )
21
 {
StringGrid1->Cells[j][i] = '*';
s = s + '*' + ' ';
F = true;
break;
}
else F = false;
if (!F)
{
StringGrid1->Cells[j][i] = 'O';
s = s + 'O' + ' ';
};
};
Memo2->Lines->Add(s.SubString(2, s.Length()));
};
Memo2->Lines->SaveToFile("Vopsea.out.txt");

}
//---------------------------------------------------------------------------
b)Unit1.h
//---------------------------------------------------------------------------

#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <Grids.hpp>
#include <ActnList.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published: // IDE-managed Components
TButton *Button1;
TButton *Button2;
TButton *Button3;
TEdit *Edit1;
TMemo *Memo1;
TButton *Button4;
TButton *Button5;
22
 TButton *Button6;
TStringGrid *StringGrid1;
TEdit *Edit2;
TEdit *Edit3;
TButton *Button7;
TButton *Button8;
TButton *Button9;
TButton *Button10;
TMemo *Memo2;
TButton *Button11;
TEdit *Edit4;
TButton *Button12;
TEdit *Edit5;
void __fastcall Button1Click(TObject *Sender);
void __fastcall Button2Click(TObject *Sender);
void __fastcall Button3Click(TObject *Sender);
void __fastcall Button4Click(TObject *Sender);
void __fastcall Button5Click(TObject *Sender);
void __fastcall Button6Click(TObject *Sender);
void __fastcall Button7Click(TObject *Sender);
void __fastcall Button8Click(TObject *Sender);
void __fastcall Button10Click(TObject *Sender);
void __fastcall Button11Click(TObject *Sender);
void __fastcall Button9Click(TObject *Sender);
void __fastcall Button12Click(TObject *Sender);
private: // User declarations
public: // User declarations
__fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

4.Desenul initial al formelor:

Am adaugat 5 componente de tip TEdit pentru a introduce denumirea fisierului si datelor..Am
adaugat 11 butoane:1 pentru iesire , 2 pentru deschidere , 8 pentru a lucre cu subprogramel. Am
adaugat 2 componente de tip TMemo pentru a citi informatia din fisier.

23
 5. Rezultatele testării subprogramelor:
 Deschiderea fisierelor:

 Interschimbarea primei linii cu ultima:

 Excluderea rindului:
24
 Excluderea unei coloane:

 Cautarea punctului sa:

 Calcularea inaltimii medii:

25
 Crearea fisierului:

 Determinarea zonelor vopsite:

26
 6. Concluzie:
Efectuind acesta practica pot sa deduc foarte multe lucruri si concluzii, dar cel mai
important consider ca dupa finisarea ei apar deja unele deprinderi din domeniul, si aceasta mi-
a dat posibilitatea de a intelege cu adevarat importanta functiei alese.
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. La fel am înţeles că trebuie să te atîrni destul de serios faţă de ceea ce faci (de
program), pentru al face mai plăcut la folosire şi mai uşor de înţeles. Mi-au apărut unele idei
pe viitor la care mă gândeam înaintedar nu ştiam cum să le fac în program.
Practica de initiere reprezinta o parte componenta a procesului – educativ care este o
perioada importanta petru noi, deoarece anume in timpul petrecerii practicii ne aprofundam
cunostintele accumulate timp de doi ani, de asemenea ne permite sa aplicam in practica si
cunostintele teoretice la obiectul “Programarii Calculatorului”.
Studentul începător se familiarizează cu programarea, de regulă, în baza elaborării şi
transcrierii într-un limbaj de programare a algoritmilor de rezolvare a unor probleme concrete
simple. Însă, rezolvarea problemelor reale presupune elaborarea unor complexe programate
mari, care include o gamă întreagă de probleme: proiectarea sistemului, elaborarea părţilor
componente ale algoritmului, reuniunea diverselor fragmente ale programului într-un produs
final, documentare etc.
Încadrul lecţiilor este posibilă examinarea doar a principiilor generale ale metodicii de
elaborare a programelor şi anumitor aspecte ale rezolvării problemelor. La rîndul său, practica
de initiere imită întregul process de elaborare a unui complex programat mare, permite
studentului să evolueze în rolul de elaborator şi organizator al proiectului.
Practica de instruire constituie o primă lucrare de sine stătătoare a studenţilor şi după
rezultatele realizării ei se pot face concluzii cu privire la pregătirea studentului pentru a activa

27
 în domeniul programării, de a evidenţia studenţii cei mai capabili pentru instruirea ulterioară
încalitate de specialist în programare.

7.Bibliografie:
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. Braicov. Turbo Pascal. Culegere de probleme, Chişinău, Editura "Prut Internaţional", 2007.
4. S.Corlat, L.Ivanov, V.Bîrsan. Informatica, Ghid de implementare a curriculumului modernizat,
pentru treapta liceală, Chişinău, "Cartier", 2010.
5. G. Damian-Timoşenco, E. Ionaşcu-Cuciuc, Ghid de elaborare a curriculumului profesional,
Chişinău, 2011.
6. A. Gremalschi, Iu. Mocanu, I. Spinei.INFORMATICA. Limbajul Pascal.Chişinău , Editura Î.E.P.
Ştiinţa, 2003.
7. UNIVERSITATEA DE STAT TIRASPOL COLEGIUL FINANCIAR - BANCAR Silviu GÎNCU
Metodologia rezolv rii problemelor de informatic în stilul orientat pe obiecte.

28