Cuprins:

Introducere.................................................................................................................................2

Enunțul sarcinii individuale:......................................................................................................3

Descrierea aplicației:.................................................................................................................4

Sarcina 1................................................................................................................................4

Sarcina 2................................................................................................................................5

Sarcina a 3-a..........................................................................................................................7

Sarcina 4................................................................................................................................8

Sarcinile 5 și 6.......................................................................................................................9

Sarcina 7..............................................................................................................................10

Sarcina 8. Ultima problemă.................................................................................................11

Grafica. Crearea butoanelor. Biblioteca windows.h ...........................................................13

Testarea programului...............................................................................................................16

Meniu...................................................................................................................................16

Afișare.................................................................................................................................16

Sarcina 1..............................................................................................................................16

Sarcina 2..............................................................................................................................17

Sarcina 3..............................................................................................................................17

Sarcina 4. ............................................................................................................................17

Sarcina 5/6...........................................................................................................................17

Sarcina 7..............................................................................................................................18

Sarcina 8. Problema.............................................................................................................18

Concluzie.................................................................................................................................19

Bibliografie..............................................................................................................................20
Introducere.

C++ este un limbaj de programare general, compilat. Este un limbaj multi-paradigmă,

cu verificarea statică a tipului variabilelor ce suportă programare procedurală, abstractizare a
datelor, programare orientată pe obiecte. În anii 1990, C++ a devenit unul din cele mai
populare limbaje de programare comerciale, rămânând astfel până azi.
C++ este adesea numit limbaj de programare de nivel mediu, dar asta nu înseamnă că
este mai slab sau greu de folosit faţă de un limbaj de nivel înalt de programare, cum este
BASIC sau Pascal. Este considerat limbaj de nivel mediu deoarece combină elementele unui
limbaj de programare înalt cu controlul şi flexibilitatea limbajelor de asamblare (assembler
language).
C++ permite manipularea biţilor, byte-urilor (octeţilor) şi adreselor (de memorie) -
elementele de bază cu care lucrează calculatorul.
Limbajul C este de asemenea portabil, adică este uşor să adaptaţi un software scris
pentru un anumit sistem de operare (sau calculator) la alt sistem de operare. De exemplu,
dacă puteţi converti uşor un program scris pentru UNIX într-unul care să funcţioneze pe
Windows, atunci acel program este portabil.
Pentru elaborarea lucrării de față am folosit platforma Code Blocks, fiind una foarte
ușoară și intuitivă. Ea permite scrierea sursei, compilarea acesteia și lansarea în execuție a
programului executabil dintr-o singură fereastră.
Practica de instruire ne permite să evoluăm în rolul de elaborator şi organizator al
proiectului.
În procesul lucrului de sine stătător asupra sarcinii individuale, studenţii elaborează şi
descriu algoritmi într-un limbaj de programare, testează şi depanează programele respective.
Practica de instruire constituie o primă lucrare complexă de sinestătătoare a studenţilor
şi va contribui la formarea şi dezvoltarea calităţilor strict necesare nu numai viitorilor
programatori, dar şi fiecărui om care, la sigur, va trăi şi va activa într-un mediu bazat pe cele
mai moderne tehnologii informaţionale.

1
Enunțul sarcinii individuale:
11. Arhipelagul. Planul unui arhipelag are forma unei matrice binare A cu nm (n, m ≤ 50) zone
pătrate (vezi figura 1). Se defineşte o insulă a unei matrice A aşa un obiect ce este format din elemente cu
valoarea 1 care se învecinează pe linii, pe coloane sau pe diagonale.

1 2 3 4 5 6 7 8 9 Informaţiile despre matricea în studiu sunt înregistrate în fişierul text

1 1 1 0 0 1 1 1 1 1 Insule.in, care conţine pe prima linie numerele naturale n şi m,
2 1 1 0 0 1 0 0 1 1 separate prin spaţiu. Fiecare din următoarele n linii ale acestui fişier
3 0 1 0 1 1 1 1 1 1 conţine câte m cifre binare, separate prin spaţiu –elementele matricei A,
în care A[i, j] =1, dacă zona [i, j] aparţine la careva insulă, şi A[i, j]=0
4 0 0 0 0 0 0 0 0 1
în caz contrar (vezi exemplu în figura 2).
5 1 1 0 1 1 0 0 0 0 Să se creeze o aplicație care să realizeze, la solicitarea utilizatorului,
6 0 1 0 0 0 0 1 1 1 următoarele prescripţii: (Design-ul aplicației vă aparține).
7 1 0 0 1 1 0 1 0 1 1) Inserează în planul arhipelagului un nou rând / o nouă coloană;
8 1 1 0 0 1 1 1 1 1 alternativa aleasă şi numărul de ordine al rândului / coloanei, unde va
Fig.1. Planul arhipelagului. avea loc inserarea, se va preciza de la tastatură;
2) Exclude din planul arhipelagului un rând / o coloană; alternativa
aleasă şi numărul de ordine al rândului / coloanei de exclus, se va preciza de la tastatură;
3) Determină numărul de unităţi din linia/coloana matricei, numărul de ordine al cărei se tastează;
4) Afişează pe ecran lista coloanelor în ordinea descendentă a numărului de unităţi din coloane; sortarea
datelor se va realiza prin metoda numărării.
5) Calculează numărul de insule din arhipelagul în studiu;
6) Determină numărul de unităţi care aparţin celei mai mari insule;
7) Găseşte în reţeaua arhipelagului un pătrat de arie maximală, ce conţine pe diagonala secundară doar
zerouri; la ecran se va afişa aria S şi coordonatele colţurilor stânga –jos ale pătratului găsit;
8) Rezolvă problema: Se consideră două insule ale arhipelagului în studiu. Prima din insule include în
componenţa sa oraşul O1 şi portul P1, având respectiv adresele [O1i, O1j] şi [P1i, P1j], iar cea de a doua
insulă – oraşul O2 şi portul P2, având respectiv adresele [O2i, O2j] şi [P2i, P2j]. Un turist, echipat cu toate
cele necesare pentru deplasare atât pe apă cât şi pe uscat, îşi programează următorul traseu:
O1 P1 (exclusiv pe uscat), P1 P2 (exclusiv pe mare), P2 O2 (exclusiv pe uscat).
Pe întreg traseul există restricţii de deplasare: turistul se poate mişca din zona curentă în zona vecină
doar în patru direcţii West, Nord, Est, Sud. Elaboraţi un subprogram care îl va ajuta pe turist să-si realizeze
obiectivele.
Date de intrare. Numerele naturale O1i, O1j, P1i, P1j, O2i , O2j, P2i şi P2j se vor citi de la tastatură, iar
informaţiile despre zonele arhipelagului –din fişierul Insule.in, descris anterior.
Date de ieşire. Fişierul text Cale.out va conţine Insule.in Cale.out
pe prima linie numărul naturalul L –lungimea 8 9 11
celui mai scurt drum ce trebuie parcurs de turist pentru 1 1 0 0 1 1 1 1 1 2 8
a ajunge din oraşul O1 în oraşul O2, trecând 1 1 0 0 1 0 0 1 1 3 8
intermediar prin porturile P1 şi P2. 0 1 0 1 1 1 1 1 1 3 7
Fiecare din următoarele L+1 linii ale fişierului va 0 0 0 0 0 0 0 0 1 3 6
conţine câte două numere naturale, separate prin 1 1 0 1 1 0 0 0 0 4 6
spaţiu, reprezentând adresele zonelor ce formează 0 1 0 0 0 0 1 1 1 5 6
drumul găsit. Dacă există două sau mai multe drumuri 1 0 0 1 1 0 1 0 1 5 7
optime, în fişierul de ieşire se va indica numai unul 1 1 0 0 1 1 1 1 1 5 8
dintre ele. Figura 2. 6 8
Exemplu. În cazul ilustrat prin figura 1, pentru 6 9
O1i = 2, O1j =8, P1i =3, P1j = 6, O2i = 8 , O2j = 9, 7 9
8 9
Figura 3.

2
P2i =6, P2j =8, introduse de la tastatură, şi fişierul de intrare Insule.in (vezi figura 2), fişierul de ieşire
Cale.out va avea formatul din figura 3.

Descrierea aplicației:

Pentru a crea o interacțiune cu utilizatorul mai eficientă și mai comodă am folosit

biblioteca windows.h cu ajutorul căreia am creat o nouă fereastră pentru amplasarea
butoanelor și a instrucțiunilor.
La ecran datele vor fi afișate folosind output-ul standard Code Blocks, fiind o metodă
mai eficientă și ușor de elaborat.
La afișarea matricei va fi folosită funcția Afisare( ), dându-i ca parametri dimensiunile
și însăși matricea.
void Afisare(int n, int m, int A[][50])
{
cout<<"Afisarea matricei:\n";
for (int i=1; i<=n; i++)
{
for (int j=1; j<=m; j++) cout<<A[i][j]<<' ';
cout<<endl;
}
}

Datele despre matricea în studiu vor fi citite din fișierul text Insule.in , n fiind numărul
de linii, iar m – numărul de coloane. După ce datele sunt citite fișierul este închis, pentru a
nu suferi modificări nedorite pe parcursul execuției programului.

fstream f("Insule.in");
f>>n>>m;
for (int i=1; i<=n; i++)
for (int j=1; j<=m; j++)
f>>A[i][j];
f.close();

Sarcina 1.
Pentru elaborarea primei sarcini am elaborat funcția Insereaza( ), care primește ca
parametri adresele dimensiunilor matricei (pentru a putea fi modificate) și matricea A.
Această funcție ne dă posibilitatea sa alegem între înserarea unei linii sau a unei coloane,

3
după care trebuie să introducem de la tastatură n elemente pentru o coloană sau m elemente
pentru o linie nouă.

void Insereaza(int &n, int &m, int A[][50]) }

{ else if (q==2)
int q,i,j, AUX[50][50], x, y; {
cout<<"Rind nou (1) / Coloana noua (2) : "; cout<<"Dati nr. de ordine al coloanei: ";
cin>>q; int c; cin>>c;
if (q==1) x=1; y=1;
{ if (c>0 && c<=m+1)
cout<<"Dati nr. de ordine al rindului: "; {
int r; cin>>r; m++;
if (r>0 && r<=n+1) x=1; y=1;
{ for (i=1; i<=n; i++)
n++; {
int x=1, y=1; for (j=c; j<=m; j++)
for (i=r; i<=n; i++) {
{ AUX[x][y]=A[i][j]; y++;
for (j=1; j<=m; j++) }
{ x++; y=1;
AUX[x][y]=A[i][j]; y++; }
} cout<<"Dati elementele noii coloane ("
x++; y=1; <<n<<" elemente) : ";
} for (i=1; i<=n; i++) cin>>A[i][c];
cout<<"Dati elementele noului rind (" x=1; y=1;
<<m<<" elemente): "; for (i=1; i<=n; i++)
for (j=1; j<=m; j++) cin>>A[r][j]; {
x=1; y=1; for (j=c+1; j<=m; j++)
for (i=r+1; i<=n; i++) {
{ A[i][j]=AUX[x][y]; y++;
for (j=1; j<=m; j++) }
{ x++; y=1;
A[i][j]=AUX[x][y]; y++; }
}
x++; }
y=1; else cout<<"Error!";
} }
else cout<<"ERROR";
} }
else cout<<"ERROR!";

Sarcina 2.
Pentru sarcina a 2-a va fi folosită funcția Exclude( ), care primește ca parametri
adresele variabilelor n și m (pentru ca modificarile să fie vizibile în afara funcției) și matricea
însăși. La fel ne dă posibilitatea de a alege între excluderea unui rând sau a unei coloane,

4
după care va trebui sa dăm de la tastatură numărul de ordine al rândului sau a coloanei ce
urmează să fie exclusă.

void Exclude(int &n, int &m, int A[][50])

{ else if (q==2) //coloana
int q,i,j, AUX[50][50], x, y; {
cout<<"Exclude rind (1) / Exclude coloana (2) : "; cout<<"Dati nr. de ordine al coloanei: ";
cin>>q; int c;
if (q==1) // rind cin>>c;
{ if (c>0 && c<=m)
cout<<"Dati nr. de ordine al rindului: "; {
int r; for (i=1; i<=n; i++) A[i][c]=0;
cin>>r; //elementele coloanei sunt egalate cu 0
if (r>0 && r<=n)
{ x=1; y=1;
for (j=1; j<=m; j++) for (i=1; i<=n; i++)
A[r][j]=0; {
x=1; y=1; for (j=c+1; j<=m; j++)
for (i=r+1; i<=n; i++) {
{ AUX[x][y]=A[i][j];
for (j=1; j<=m; j++) y++;
{ }
AUX[x][y]=A[i][j]; x++; y=1;
y++; }
} for (i=1; i<=n; i++) A[i][m]=0;
x++; y=1; //elementele ultimei coloane sunt egalate cu 0
} m--;
for (j=1; j<=m; j++) A[n][j]=0; x=1; y=1;
//elementele ultimului rind sunt egalate cu 0 for (i=1; i<=n; i++)
n--; {
x=1; y=1; for (j=c; j<=m; j++)
for (i=r; i<=n; i++) {
{ A[i][j]=AUX[x][y];
for (j=1; j<=m; j++) y++;
{ }
A[i][j]=AUX[x][y]; x++; y=1;
y++; }
} }
x++; }
y=1; else cout<<"ERROR!";
} // este aleasa alta varianta
} }
}

5
 Sarcina a 3-a va fi rezolvată cu ajutorul funcției Unitati( ), având ca parametri
dimensiunile și matricea. Această funcție ne dă posibilitatea să alegem între determinarea
numărului de unități ale unei linii sau ale unei coloane numărul de ordine fiind citit de la
tastatură.

void Unitati(int n, int m, int A[][50])

{
cout<<"(L) Linie / (C) Coloana: "; char c; cin>>c;
if (c=='L' || c=='l')
{
cout<<"Dati nr. de ordine al rindului: "; int r; r1: cin>>r;
if (r>0 && r<=n)
{
int x=0;
for (int j=1; j<=m; j++)
if (A[r][j]==1) x++;
cout<<"Linia "<<r<<" are "<<x<<" unitati.";
}
else
{
cout<<"Error! Dati din nou nr. de ordine al rindului: ";
goto r1;
}
}
else if (c=='C' || c=='c')
{
cout<<"Dati nr. de ordine al coloanei: "; int c;
co1: cin>>c;
if (c>0 && c<=m)
{
int x=0;
for (int i=1; i<=n; i++) if (A[i][c]==1) x++;
cout<<"Coloana "<<c<<" are "<<x<<" unitati.";
}
else { cout<<"Error! Dati din nou nr. de ordine al coloanei: "; goto co1; }
}
}

6
 Sarcina 4. Sortarea coloanelor după numărul de unități prin metoda numărării va fi
realizată cu ajutorul funcției Sort_Coloane( ). Această funcție va folosi 3 tablouri auxiliare,
și anume tabloul B[2][20] care va memora numărul de unități al fiecărei coloane din matricea
inițială și tablourile C[2][20] și D[20], necesare pentru sortare prin metoda numărării.

7
 void Sort_Coloane(int n, int m, int A[][50])
{
int B[2][20],C[2][20], D[20], i,j;
for (j=1; j<=m; j++) B[0][j]=0;
for (j=1; j<=m; j++)
for (i=1; i<=n; i++)
if (A[i][j]==1) B[0][j]++;
for (j=1; j<=m; j++) B[1][j]=j;
// Sortarea prin numarare
// Pasul 1 fac o copie a vectorului B in vectorul C
for(j=1; j<=m; j++)
{ C[0][j]=B[0][j]; C[1][j]=B[1][j]; }
// Pas 2 crearea vectorului D
for (j=1; j<=m; j++) D[j]=0;
// determinam pentru fiecare element cate elemente sunt mai mici
for (i=1; i<=m; i++)
for (j=i+1; j<=m; j++)
if ( B[0][i] < B[0][j] ) D[j]++;
else D[i]++;
// Pasul 3 Se rescriu elementele lui B in ordine crescatoare
for (i=1; i<=m; i++)
{
B[0][D[i]+1]=C[0][i];
B[1][D[i]+1]=C[1][i];
}
cout<<"\nVectorul sortat (unitati): \n";
for (j=1; j<=m; j++) cout<<B[0][j]<<' ';
cout<<"\nVectorul sortat (pozitia initiala a coloanei): \n";
for (j=1; j<=m; j++) cout<<B[1][j]<<' ';

cout<<"\nColoanele sortate dupa unitati: \n";

for (i=1; i<=n; i++)
{
for (j=1; j<=m; j++) cout<<A[i][B[1][j]]<<' ';
cout<<endl;
}
}

Sarcinile 5 și 6, având un caracter asemănător le-am inclus într-o singură funcție:

Nr_Insule( ), care folosind o functie recursivă auxiliară Cauta( ) ce utilizează algoritmul
Undei Lee, determină numărul de insule și respectiv numărul de unități al fiecărei insule.

8
 void Cauta(int i, int j, int B[][50], int &nr)
{
if (B[i][j]==1)
{
nr++;
B[i][j]=0;
Cauta(i-1,j-1,B,nr);
Cauta(i,j-1,B,nr);
Cauta(i+1,j-1,B,nr);
Cauta(i-1,j,B,nr);
Cauta(i+1,j,B,nr);
Cauta(i-1,j+1,B,nr);
Cauta(i,j+1,B,nr);
Cauta(i+1,j+1,B,nr);
}
else return;
}

void Nr_Insule(int n, int m, int A[][50])

{
int B[50][50], i, j;
for (i=1; i<=n; i++) for (j=1; j<=m; j++) B[i][j]=A[i][j];
for (i=0; i<=n+1; i++) { B[i][0]=0; B[i][m+1]=0; }
for (j=0; j<=m+1; j++) { B[0][j]=0; B[n+1][j]=0; }
bool ok;
int x=1, nr; i=1; j=1;
for (i=1; i<=n; i++)
{
for (j=1; j<=m; j++)
if (B[i][j]==1)
{
nr=0;
Cauta(i,j,B,nr);
cout<<x<<": "<<nr<<" unitati;"<<endl;
x++;
}
}
}

Sarcina 7. Funcția Patrat( ) – caută în matricea primită ca parametru un pătrat de arie

maximă, ce conține pe diagonala secundară doar zerouri.

9
Această funcție caută și înscrie într-o matrice auxiliară toate pătratele ce conțin pe diagonala
segundară zerouri, apoi caută și afișează pe ecran pătratul de arie maximă.
void Patrat(int n, int m, int A[][50])
{
int i,j,B[50][50], C[3][50], x=1;
for (i=1; i<=50; i++) C[2][i]=0;
for (i=1; i<=n; i++)
for (j=1; j<=m; j++)
B[i][j]=A[i][j];

for (i=n; i>=1; i--)

{
for (j=1; j<=m; j++)
if (B[i][j]==0)
{
C[0][x]=i; C[1][x]=j;
while (B[i][j]==0)
{
C[2][x]++;
B[i][j]=1;
if (i-1<1 || j+1>m) goto q1;
i--; j++;
}
q1:
for (int k=1; k<=C[2][x]; k++)
{
i++; j--;
}
x++;
}
}
int maxi=C[2][1];
for (i=2; i<=x; i++) if (C[2][i]>maxi) maxi=C[2][i];
int no=0;
for (i=1; i<=x; i++) if (C[2][i]==maxi) no++;
cout<<"\nIn arhipelagul dat sunt "<<no<<" patrate de arie maxima
("<<maxi<<'*'<<maxi<<"= "<<maxi*maxi<<')'<<endl;
for (i=1; i<=x; i++)
if (C[2][i]==maxi) cout<<'('<<C[0][i]<<';'<<C[1][i]<<")
si"<<'('<<C[0][i]-maxi+1<<';'<<C[1][i]+maxi-1<<')'<<endl;
}

10
Sarcina 8. Ultima problemă.
Sarcina dată presupune gasirea celui mai scurt drum pentru traversarea a 2 orașe, după
următorul traseu: O1P1 (pe uscat), P1P2 (pe mare), P2O2 (pe uscat).
Această sarcină, fiind una de o complexitate ridicată, a necesitat eleborarea mai multor
subprograme.
Pentru a simplifica problema, am împărțit-o în 3 părți, fiecare parte reprezentând unul
din cele 3 trasee.
Funcția inside( ) va avea grijă ca în procesul de verificare a traseului sa nu se
părăsească limitile matricei.
int inside(int i, int j, int n, int m)
{
return i>=1 && i<=n && j>=1 && j<=m;
}

Funcția afis( ), va rescrie primul traseu, iar funcția afis_2( ) va rescrie cel de al 2-lea și
al 3-lea traseu. Singura diferență dintre a 2-a funcție este că va rescrie începând cu al 2-lea
pas, pentru a nu apărea repetări ale pașilor din traseul trecut.
void afis(int pmin, int sol[20][3], void afis_2(int pmin, int sol[20][3],
int sol_2[100][3]) int sol_2[100][3])
{ {
for (int i=1;i<=pmin;i++) for (int i=2;i<=pmin;i++)
{ {
pasi++; pasi++;
sol_2[pasi][1]=sol[i][1]; sol_2[pasi][1]=sol[i][1];
sol_2[pasi][2]=sol[i][2]; sol_2[pasi][2]=sol[i][2];
} }
} }

Funcția scrie( ) va rescrie toți pașii în fișierul de ieșire Cale.out.

void scrie(int pasi, int sol_2[100][3])
{
ofstream g("Cale.out");
g<<pasi<<endl;
for(int i=1;i<=pasi;i++)
g<<" "<<sol_2[i][1]<<","<<sol_2[i][2]<<endl;
g.close();
}

11
 Funcțiile back( ) și back_2( ) vor răspunde de gasirea traseelor propriu zise. Funcția
back cauta cele 2 trasee de pe uscat, iar back_2 – traseul de pe mare.
void back(int i,int j, int pas, int xi, int yi, int void back_2(int i,int j, int pas, int n, int m, int
n, int m, int A[][50]) A[][50])
{ {
int inou, jnou,k; int inou, jnou,k;
if(i==xi && j==yi) if(i==P2i && j==P2j)
alege(pas-1); alege(pas-1);
else else
for(k=0; k<=3; k++) for(k=0; k<=3; k++)
{ {
inou=i+di[k]; inou=i+di[k];
jnou=j+dj[k]; jnou=j+dj[k];
if(inside(inou,jnou,n,m) && if(inside(inou,jnou,n,m) &&
A[inou][jnou]==1 ) // ==0 A[inou][jnou]==0 ) // ==0
{ {
A[inou][jnou]=pas; A[inou][jnou]=pas;
x[pas][1]=inou; x[pas][1]=inou;
x[pas][2]=jnou; x[pas][2]=jnou;
back(inou,jnou,pas+1,xi,yi,n,m,A); back_2(inou,jnou,pas+1,n,m,A);
A[inou][jnou]=1; //=0 A[inou][jnou]=0; //=0
} }
} }
} }

Funcția Ultima_problema( ) va coordona celelalte funcții, incepând cu citirea

coordonatelor orașelor și porturilor, gasind cele trei trasee și finisând cu scrierea datelor în
fișierul de ieșire.
void Ultima_problema(int n, int m, int A[][50])
{
citire();
A[O1i][O1j]=1; x[1][1]=O1i; x[1][2]=O1j; back(O1i,O1j,2,P1i,P1j,n,m,A); afis(pmin,sol,sol_2);

pmin=20; A[P1i][P1j]=1; A[P2i][P2j]=0; x[1][1]=P1i; x[1][2]=P1j; back_2(P1i,P1j,2,n,m,A);

A[P2i][P2j]=1; afis_2(pmin,sol,sol_2);

pmin=20; A[P2i][P2j]=1; x[1][1]=P2i; x[1][2]=P2j;

back(P2i,P2j,2,O2i,O2j,n,m,A); afis_2(pmin,sol,sol_2);

scrie(pasi,sol_2);
}

12
 Grafica. Crearea butoanelor. Biblioteca windows.h .

case WM_CREATE:
hwndLbl = CreateWindow(TEXT("STATIC"), TEXT("Meniu:"),
WS_VISIBLE | WS_CHILD | WS_BORDER, 70,10,60,20,
hwnd, (HMENU) ID_LABEL, NULL, NULL);
hwndcmd = CreateWindow(TEXT("BUTTON"), TEXT("1) Citire date din fisier"),
WS_VISIBLE | WS_CHILD, 50,50,150,25,
hwnd, (HMENU) 1, NULL, NULL);
hwndcmd = CreateWindow(TEXT("BUTTON"), TEXT("2) Afisare pe ecran"),
WS_VISIBLE | WS_CHILD, 50,80,150,25,
hwnd, (HMENU) 2, NULL, NULL);
hwndcmd = CreateWindow(TEXT("BUTTON"), TEXT("3) Inserare"),
WS_VISIBLE | WS_CHILD, 50,110,150,25,
hwnd, (HMENU) 3, NULL, NULL);
hwndcmd = CreateWindow(TEXT("BUTTON"), TEXT("4) Excludere"),
WS_VISIBLE | WS_CHILD, 50,140,150,25,
hwnd, (HMENU) 4, NULL, NULL);
hwndcmd = CreateWindow(TEXT("BUTTON"), TEXT("5) Nr. unitati"),
WS_VISIBLE | WS_CHILD, 50,170,150,25,
hwnd, (HMENU) 5, NULL, NULL);
hwndcmd = CreateWindow(TEXT("BUTTON"), TEXT("6) Sortare coloane"),
WS_VISIBLE | WS_CHILD, 270,50,160,25,
hwnd, (HMENU) 6, NULL, NULL);
hwndcmd = CreateWindow(TEXT("BUTTON"), TEXT("7) Nr. insule"),
WS_VISIBLE | WS_CHILD, 270,80,160,25,
hwnd, (HMENU) 7, NULL, NULL);
hwndcmd = CreateWindow(TEXT("BUTTON"), TEXT("8) Patrat arie maxima"),
WS_VISIBLE | WS_CHILD, 270,110,160,25,
hwnd, (HMENU) 8, NULL, NULL);
hwndcmd = CreateWindow(TEXT("BUTTON"), TEXT("9) Problema insule"),
WS_VISIBLE | WS_CHILD, 270,140,160,25,
hwnd, (HMENU) 9, NULL, NULL);
hwndcmd = CreateWindow(TEXT("BUTTON"), TEXT("Sterge ecran"),
WS_VISIBLE | WS_CHILD, 270,170,160,25,
hwnd, (HMENU) 10, NULL, NULL);
hwndcmd = CreateWindow(TEXT("BUTTON"), TEXT("EXIT!"),
WS_VISIBLE | WS_CHILD, 350,300,150,25,
hwnd, (HMENU) 99, NULL, NULL);
hwndedit = CreateWindow(TEXT("EDIT"), TEXT("Introduceti de la tastatura"),
WS_VISIBLE | WS_CHILD, 50,300,250,25,
hwnd, (HMENU) 100, NULL, NULL);
system("color 72");
break;

13
Butoanele. Atribuirea de acțiuni.

case WM_COMMAND:
switch (LOWORD(wParam))
{
case 1:
{
MessageBox(hwnd, "Datele au fost citite", "Citire", MB_OK | MB_ICONINFORMATION);
fstream f("Insule.in");
f>>n>>m;

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

for (int j=1; j<=m; j++)
f>>A[i][j];
f.close();

//PostQuitMessage (0);
break;
}

case 2:
MessageBox(hwnd, "Datele vor fi afisate", "Afisare", MB_OK | MB_ICONINFORMATION);
Afisare(n,m,A);
break;

case 3:
{
MessageBox(hwnd, "Datele vor fi inserate", "Insereaza", MB_OK | MB_ICONINFORMATION);
Insereaza(n,m,A);
ofstream h("Insule.in");
h<<n<<' '<<m<<endl;
for (int i=1; i<=n; i++)
{
for (int j=1; j<=m; j++)
h<<A[i][j]<<' ';
h<<endl;

14
 case 4:
{
Exclude(n,m,A);
ofstream h("Insule.in");
h<<n<<' '<<m<<endl;
for (int i=1; i<=n; i++)
{
for (int j=1; j<=m; j++)
h<<A[i][j]<<' ';
h<<endl;
}
h.close();
MessageBox(hwnd, "Fisierul 'Insule.in' a fost modificat!", "INFO", MB_OK | MB_ICONINFORMATION);
break;
}

case 5:
Unitati(n,m,A);
break;

case 6:
Sort_Coloane(n,m,A);
break;

case 7:
Nr_Insule(n,m,A);
break;

case 8:
Patrat(n,m,A);
break;

case 9:
Ultima_problema(n,m,A);
MessageBox(hwnd, "Rezultatele au fost inscrise in fisierul Cale.out", "INFO", MB_OK |
MB_ICONINFORMATION);
break;

case 10:
MessageBox(hwnd, "Ecranul va fi curatit", "CLEAR", MB_OK | MB_ICONINFORMATION);
system("cls");
break;

case 99:
PostQuitMessage (0);
break;
}

15
Testarea programului

Meniu.

Afișare.

Sarcina 1.

16
Sarcina 2.

Sarcina 3.

Sarcina 4.

Sarcina 5/6

17
 Sarcina 7.

Sarcina 8. Problema.

18
Concluzie

Efectuând acestă lucrare practică am obținut unele deprinderi în domeniul programării,

iar aceast fapt mi-a dat posibilitatea de a înțelege cu adevărat importanța, dar și
complexitatea specialității pe care am ales-o.
Lucrând la lucrarea individuală am conștientizat faptul ca o interfață atractivă și ușor
de utilizat, precum și un consum redus de memorie și un timp de execuție cât mai mic sunt
niște calități de bază ale oricărei aplicații sau joc.
Practica instructiva reprezintă o parte componentă a procesului educative, care este o
perioadă importantă pentru noi, deoarece anume în timpul petrecerii practicii ne aprofundăm
cunoștințele accumulate timp de doi ani, de asemenea ne permite să aplicăm în practică și
cunoștințele teoretice obținute la disciplina “Programarea 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 programe
complexe de dimensiuni mari, care includ 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.
În cadrul 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 instruire 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 în domeniul programării, de a evidenţia studenţii cei mai capabili pentru instruirea
ulterioară în calitate de specialist în programare.

19
Bibliografie

1. Memorator de Informatică pentru cl. X-a:C++/Mihai Nancu - Bucureşti, 2005

2. http://www.cyberforum.ru/cpp-builder/thread1081397.html
3. http://www.cplusplus.com/doc/tutorial/arrays/
4. http://www.cyberforum.ru/cpp-builder/thread630896.html
5. http://www.softtime.ru/cpp/read.php?id_forum=1&id_theme=952
6. Totul despre C şi C++ (Kris Jamsa, Lars Klander)
7. Manual complet C++ (Herbert Schildt)
8. http://www.limbajul-c.wikispaces.com
9. http://www.nformaticasalaoruandra.weebly.com

20