Ministerul Educației, Culturii și Cercetării al Republicii Moldova

I.P. Centrul de Excelență în Informatică și Tehnologii Informaționale

RAPORTUL
STAGIULUI DE PRACTICĂ

Elevul: Chiriac Daniel

Grupa: W1722
Specialitatea: Administrarea Aplicațiilor WEB
Baza de practică:Colegiul de Informatică și Tehnologii Informaționale

Conducătorul stagiului de practică

de la Centrul de Excelență

Cazacu Doina

Chişinău 2019
Cuprins
Enunțul sarcinii individuale.............................................................................................................................3

Modul de programare a aplicației...................................................................................................................5

Listing-ul programului.....................................................................................................................................6

Rezultatele testării subprogramelor..............................................................................................................30

Funcționalitatea aplicației grafice de interacțiunea cu utilizatorul...........................................................37

Estimarea coplexității algoritmilor aplicați..................................................................................................38

Concluzie..........................................................................................................................................................39

Bibliografia......................................................................................................................................................40

2
 Enunțul sarcinii individuale

18. Spirala. Se consideră un tablou bidimensional A[1..n, 1..m] cu elemente numere întregi.

Să se creeze o aplicație care să realizeze, la solicitarea utilizatorului, următoarele prescripţii:

(Design-ul aplicației vă aparține).

1) Inserează în matricea A o nouă linie/coloană; alternativa aleasă şi numărul liniei/coloanei de inserat se va

indica de la tastatură;

2) Exclude din matricea A linia şi coloana la intersecţia căror se află primul element maximal întâlnit la
parcurgere pe linii a elementelor acestei matrice;

3) Găseşte numărul care apare cel mai frecvent în matricea A;

4) Determină media aritmetică a elementelor matricei A, care aparţin intervalului [-10, 10];

5) Sortează crescător elementele fiecărei linii ale matricei A prin metoda numărării;

6) Creează fişierul Select.txt cu n linii prin copierea subşirurilor crescătoare de lungime maximală din
liniile respective ale matricei A; dacă aşa subşiruri sunt mai multe, se va copia câte unul din ele;

7) Găseşte în componenţa matricei A o submatrice pătratică simetrică de dimensiune maximală; la ecran se

vor afişa coordonatele colţului stânga –sus şi dimensiunea submatricei găsite;

1 2 … j … m 8) Rezolvă problema. Numim spirală acel drum prin matrice care,

pornind din coltul stânga –sus, traversează element după element
1 prima linie, coboară pe ultima coloană, traversează ultima linie de la
dreapta la stânga, urcă pe prima coloană, apoi continuă cu cea de-a
2
doua linie, penultima coloană, penultima linie şi a doua coloana etc.
… Drumul se opreşte undeva în tablou, după ce toate elementele au fost
traversate. Fiecare element se vizitează o singura dată (vezi figura 1).
i
Să se stabilească dacă spirala tabloului A formează sau nu o progresie
… aritmetică. In cazul în care răspunsul este afirmativ, să se determine
valoarea ultimului element din spirală, în caz contrar –să se afişeze
valorile primelor doua elemente din spirală ale căror diferenţă nu este egală cu diferenţa dintre valorile
elementelor deja verificate.

Date de intrare. Pe prima linie a fişierului de intrare Spirala.in se află numerele naturale n şi m
separate prin spaţiu, reprezentând numărul liniilor, respectiv numărul coloanelor din tablou. Pe
următoarele n linii ale acestui fişier se afla câte m numere întregi, separate prin câte un spaţiu,
reprezentând elementele matricei A.
Date de ieşire. Dacă spirala formează progresie aritmetică, pe prima linie a fişierului de ieşire
Spirala.out se va scrie cuvântul DA. Pe următoarea linie se va scrie valoarea ultimului element din
spirală. Dacă însă spirala nu formează progresie aritmetică, pe prima linie a fişierului de ieşire se va scrie

3
cuvântul NU. Pe următoarea linie se vor scrie primele doua numere din spirală, pentru care nu este
îndeplinită proprietatea de progresie aritmetică.

Restricţii.

2≤ n, m ≤19

-32000 ≤ A[i, j] ≤ 32000 (i = 1, 2, ..., n, j = 1, 2, ..., m).

Exemplul 1: Exemplul 2:

Spirala.in Spirala.out Spirala.in Spirala.out

3 DA 23 NU

1 3 5 17 -1 -3 -5 -7 -5

15 17 7 -15 -5 -7

13 11 9

4
 Modul de programare a aplicației

Am utilizat metode de sortare,de lucrare cu fișierele,de afișare a matricilor.Am creat o interfață

grafică destul de simplă dar modernă utilizând butoane bitbtn si funcția kind.În aplicația mea sunt
utilizate metode pentru citire din fișier pentru a simplifica lucrul cu fișierele și timpul de creare a
aplicației.Deasemenea eu lucrez cu mai multe forme pentru a crea o mobilitate în aplicație.

Pe parcursul elaborării am utilizat:

-Butoane de tip BitBtn

-StringGrid

-Imagini

-Edit,MaskEdit

-Label

5
 Listing-ul programului

Parola:76625

Forma 1 (Unit1.cpp)

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
#include "Unit3.h"
#include "Unit4.h"
#include "Unit5.h"
#include "Unit6.h"
#include "Unit7.h"
#include "Unit8.h"
#include "Unit9.h"
#include "Unit10.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn1Click(TObject *Sender)
{
if(BitBtn18->Enabled==false){Form7->Show();}
else ShowMessage("Introduceti parola pentru a continua");}

6
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn17Click(TObject *Sender)
{Form1->Close();}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn9Click(TObject *Sender)
{Label2->Visible=true;
Label3->Visible=true;
Label3->Caption="Insereaza in matricea A o noua linie/coloana";}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormClick(TObject *Sender)
{Label2->Visible=false;
Label3->Visible=false; }
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn10Click(TObject *Sender)
{Label2->Visible=true;
Label3->Visible=true;
Label3->Caption="Exclude din matricea A linia/coloana la intersectia primului
element minimal";}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn11Click(TObject *Sender)
{Label2->Visible=true;
Label3->Visible=true;
Label3->Caption="Gaseste numarul cel mai frecvent in matricea A";}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn12Click(TObject *Sender)
{Label2->Visible=true;
Label3->Visible=true;
Label3->Caption="Determina media aritmetica a elementelor matricii din
intervalul [-10;10]";}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn13Click(TObject *Sender)
{Label2->Visible=true;
Label3->Visible=true;

7
Label3->Caption="Sorteaza descrescator elementele fiecarei linii prin metoda
numerarii";}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn14Click(TObject *Sender)
{Label2->Visible=true;
Label3->Visible=true;
Label3->Caption="Creeaza fisierul Select.txt cu n linii prin copierea subsirilor
crescatoare";}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn15Click(TObject *Sender)
{Label2->Visible=true;
Label3->Visible=true;
Label3->Caption="Gaseste in matrice o submatrice patratica simetrica de
dimensiune maximala";}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn16Click(TObject *Sender)
{Label2->Visible=true;
Label3->Visible=true;
Label3->Caption="Sa se stabileasca daca spirala formeaza sau nu o progresie
aritmetica";}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn18Click(TObject *Sender)
{if(MaskEdit1->Text=="76625")
{BitBtn19->Enabled=true;
BitBtn18->Enabled=false;
ShowMessage("Ati intrat cu succes");
MaskEdit1->Text="";}
else ShowMessage("Parola Incorecta");}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn2Click(TObject *Sender)
{if(BitBtn18->Enabled==false){
Form8->Show();}
else ShowMessage("Introduceti parola pentru a continua");}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn3Click(TObject *Sender)

8
{if(BitBtn18->Enabled==false){
Form3->Show();}
else ShowMessage("Introduceti parola pentru a continua");}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn4Click(TObject *Sender)
{if(BitBtn18->Enabled==false){
Form5->Show();}
else ShowMessage("Introduceti parola pentru a continua");}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn5Click(TObject *Sender){
if(BitBtn18->Enabled==false){Form4->Show();}
else ShowMessage("Introduceti parola pentru a continua");}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn6Click(TObject *Sender)
{if(BitBtn18->Enabled==false){Form9->Show();}
else ShowMessage("Introduceti parola pentru a continua");}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn7Click(TObject *Sender){
if(BitBtn18->Enabled==false){ Form10->Show();}
else ShowMessage("Introduceti parola pentru a continua");}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn8Click(TObject *Sender)
{if(BitBtn18->Enabled==false){Form6->Show();}
else ShowMessage("Introduceti parola pentru a continua");}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn19Click(TObject *Sender)
{BitBtn19->Enabled=false;
BitBtn18->Enabled=true;
MaskEdit1->Text="";
ShowMessage("Ati iesit din cont");}
//---------------------------------------------------------------------------

void __fastcall TForm1::BitBtn20Click(TObject *Sender)

9
{if(BitBtn18->Enabled==false){
Form2->Show();}
else ShowMessage("Introduceti parola pentru a continua");}
//---------------------------------------------------------------------------
Forma2 (Unit2.cpp)
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include <fstream.h>
#include <iostream.h>

#include "Unit2.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm2 *Form2;
int i,j,n,m,a[100][100];
void citire(){
ifstream f("spirala.txt");
f>>n; f>>m;
for(i=0;i<n;i++)
for(j=0;j<m;j++){
f>>a[i][j];}
f.close();}
//---------------------------------------------------------------------------
__fastcall TForm2::TForm2(TComponent* Owner)
: TForm(Owner){}
//---------------------------------------------------------------------------
void __fastcall TForm2::BitBtn1Click(TObject *Sender)
{Form2->Close();}
//---------------------------------------------------------------------------
void __fastcall TForm2::BitBtn2Click(TObject *Sender)
{citire();

10
if(n>=2 && n<=19 && m>=2 && m<=19){
StringGrid1->Visible=true;
Edit1->Text=n;
Edit2->Text=m;
StringGrid1->RowCount=n;
StringGrid1->ColCount=m;
StringGrid1->Cells[n][m];
for(i=0;i<n;i++){
for(j=0;j<m;j++){
StringGrid1->Cells[j][i]=a[i][j];}
cout<<endl;}}
else
{StringGrid1->Visible=false;
Edit1->Text="";
Edit2->Text="";
ShowMessage("Nu ati introdus corect in fisier (2<=n,m<=19)"); }}
//---------------------------------------------------------------------------
void __fastcall TForm2::BitBtn17Click(TObject *Sender)
{Form2->Close();
StringGrid1->Visible=false;
Edit1->Text="";
Edit2->Text="";}
//---------------------------------------------------------------------------
Forma 3 (Unit3.cpp)
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include <iostream.h>
#include <fstream.h>
#include "Unit3.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"

11
TForm3 *Form3;
int i,j,n,m,b[100][100];

void citiresort(){
ifstream f3("spirala.txt");
f3>>n; f3>>m;
for(i=0;i<n;i++)
for(j=0;j<m;j++){
f3>>b[i][j];
}
f3.close();};

//---------------------------------------------------------------------------
__fastcall TForm3::TForm3(TComponent* Owner)
: TForm(Owner){}
//---------------------------------------------------------------------------

void __fastcall TForm3::BitBtn17Click(TObject *Sender)

{Form3->Close();
Edit2->Text="";
StringGrid1->Visible=false;}
//---------------------------------------------------------------------------

void __fastcall TForm3::BitBtn1Click(TObject *Sender)

{citiresort();
{StringGrid1->Visible=true;
StringGrid1->RowCount=n;
StringGrid1->ColCount=m;
StringGrid1->Cells[n][m];
for(i=0;i<n;i++){
for(j=0;j<m;j++)
{StringGrid1->Cells[j][i]=b[i][j];}

12
cout<<endl;}}
{int o=1,o1,k[100],r[100],c[1000],maxim=-32000,x,contor,h,auxh;
int p=n*m;
for (i=0;i<n;i++)
for (j=0;j<m;j++)
{k[o]=StrToInt(StringGrid1->Cells[j][i]);
o++;}
for(o=0;o<p;o++){
h=k[o];contor=0;
for (o1=o;o1<p;o1++) {
if (k[o1]==h)contor++;
if (contor>maxim)
{maxim=contor;
auxh=h;}}}
if(auxh<=32000){
Edit2->Text = IntToStr(auxh);}
else ShowMessage("SUNT NUMERE CARE SUNT PREZENTE EGAL IN MATRICE!!!");
}}
//---------------------------------------------------------------------------

Forma 4 (Unit4.cpp)
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include <fstream.h>
#include <iostream.h>
#include "Unit4.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm4 *Form4;
int i,j,n,m,b[100][100];
void citiresort4(){

13
ifstream f4("spirala.txt");
f4>>n; f4>>m;
for(i=0;i<n;i++)
for(j=0;j<m;j++){
f4>>b[i][j];}
f4.close();};
//---------------------------------------------------------------------------
__fastcall TForm4::TForm4(TComponent* Owner)
: TForm(Owner){}
//---------------------------------------------------------------------------
void __fastcall TForm4::BitBtn2Click(TObject *Sender)
{citiresort4();
StringGrid1->Visible=true;
StringGrid1->RowCount=n;
StringGrid1->ColCount=m;
StringGrid1->Cells[n][m];
for(i=0;i<n;i++)
for(j=0;j<m;j++)
{StringGrid1->Cells[j][i]=b[i][j];}
cout<<endl;}

//---------------------------------------------------------------------------

void __fastcall TForm4::BitBtn17Click(TObject *Sender)

{Form4->Close();
StringGrid1->Visible=false;}
//---------------------------------------------------------------------------
void __fastcall TForm4::BitBtn1Click(TObject *Sender)
{citiresort4();
int a[100][100],i,j,k,aux;
for(i=0;i<n;i++)
for(j=0;j<m;j++)
a[i][j]=StrToInt(StringGrid1->Cells[j][i]);

14
for(k=0;k<n;k++)
for(i=0;i<m-1;i++)
for(j=i+1;j<m;j++)
if(a[k][i]<a[k][j])
{aux=a[k][i];
a[k][i]=a[k][j];
a[k][j]=aux;}
for(i=0;i<n;i++)
{for(j=0;j<m;j++)
StringGrid1->Cells[j][i]=a[i][j];}}
//---------------------------------------------------------------------------
Forma 5 (Unit5.cpp)
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include <iostream.h>
#include <fstream.h>
#include "Unit5.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm5 *Form5;
int i,j,n,m,b[100][100];
void citiresort5(){
ifstream f5("spirala.txt");
f5>>n; f5>>m;
for(i=0;i<n;i++)
for(j=0;j<m;j++){
f5>>b[i][j];}
f5.close();};
//---------------------------------------------------------------------------
__fastcall TForm5::TForm5(TComponent* Owner)
: TForm(Owner){}

15
//---------------------------------------------------------------------------
void __fastcall TForm5::BitBtn17Click(TObject *Sender)
{Form5->Close();
Edit2->Text="";
StringGrid1->Visible=false;}
//---------------------------------------------------------------------------

void __fastcall TForm5::BitBtn1Click(TObject *Sender)

{float media;int k=0; float suma=0;
citiresort5();
StringGrid1->Visible=true;
StringGrid1->RowCount=n;
StringGrid1->ColCount=m;
StringGrid1->Cells[n][m];
for(i=0;i<n;i++) {
for(j=0;j<m;j++)
{StringGrid1->Cells[j][i]=b[i][j];}
cout<<endl;}
{for(i=0;i<n;i++){
for(j=0;j<m;j++){
if(b[i][j]<=10 && b[i][j]>=-10)
{suma=suma+b[i][j];
k++;}}}
if(k>0){
media=suma/k;
Edit2->Text=FormatFloat("0.00",media) ;}
else ShowMessage("Nu exista niciun element din intervalul [-10;10]");}}
//---------------------------------------------------------------------------

Forma 6 (Unit6.cpp)
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop

16
#include <fstream.h>
#include "Unit6.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm6 *Form6;
//---------------------------------------------------------------------------
__fastcall TForm6::TForm6(TComponent* Owner)
: TForm(Owner){}
//---------------------------------------------------------------------------
void __fastcall TForm6::Button1Click(TObject *Sender)
{int v[100][100],sp[100],i,j,m,n,x,mn,k,y,nx,mx,p1,p2,h=0;
remove("Spirala.out.txt");
fstream g("spirala.txt");
ofstream f("Spirala.out.txt");
g>>n>>m;
for (int i=1;i<=n;i++)
{for (int j=1;j<=m;j++)
g>>v[i][j];
if (f.eof())break;}
g.close();
i=1;
j=1;
k=1;
x=0;
mn=m*n;
nx=n;
mx=m;
while (k<=mn) {
while (j<=mx) {sp[k]=v[i][j];j++;k++;}
x++;
mx=m-x;
j--;

17
i++;
while (i<=nx) {sp[k]=v[i][j];i++;k++;}
i--;
j--;
while (j>=x) {sp[k]=v[i][j];j--;k++;}
j++;
i--;
y=x+1;
nx=n-x;
while (i>=y) {sp[k]=v[i][j];i--;k++;}
j++;
i++;}
int q=0;
for(int k=1;k<=(m*n)-1;k++)
if(sp[k]<sp[k+1] && sp[k+1]-sp[k]==sp[2]-sp[1]) q++;
for(int k=1;k<=(m*n)-1;k++)
{if(sp[k+1]-sp[k]!=sp[2]-sp[1])
{p1=sp[k];
p2=sp[k+1];
break;}}
if(q==(m*n)-1) {f<<"Da";
f<<"\n";
f<<sp[m*n];
h++;}
if(h!=1)
{f<<"Nu";
f<<"\n";
f<<p1<<" "<<p2;}
ShowMessage("Verificati fisierul Spirala.out!!!");
Form6->Close();}
//---------------------------------------------------------------------------
void __fastcall TForm6::BitBtn17Click(TObject *Sender)
{Form6->Close();}

18
//---------------------------------------------------------------------------

Forma 7 (Unit7.cpp)
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include <iostream.h>
#include <fstream.h>
#include "Unit7.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm7 *Form7;
int i,j,n,m,b[100][100];
void citiresort7(){
ifstream f7("spirala.txt");
f7>>n; f7>>m;
for(i=0;i<n;i++)
for(j=0;j<m;j++){
f7>>b[i][j];}
f7.close();};
//---------------------------------------------------------------------------
__fastcall TForm7::TForm7(TComponent* Owner)
: TForm(Owner){}
//---------------------------------------------------------------------------
void __fastcall TForm7::BitBtn2Click(TObject *Sender)
{ ShowMessage("Introduceti doar numere integer!!!");
if(Edit1->Text!=""){
citiresort7();
{StringGrid1->Visible=true;
StringGrid1->RowCount=n;
StringGrid1->ColCount=m;
StringGrid1->Cells[n][m];

19
for(i=0;i<n;i++)
for(j=0;j<m;j++) {
{StringGrid1->Cells[j][i]=b[i][j];}
cout<<endl;
}}
{int rn = StrToInt(Edit1->Text);
m++;
StringGrid1->ColCount ++;
for(int j=m; j>rn; j--)
for(int i=0; i<n; i++)
{StringGrid1->Cells[j][i] = StringGrid1->Cells[j-1][i];}
for(int i=0; i<n; i++){
StringGrid1->Cells[rn][i] = "" ; }
StringGrid1->Cells[m][0] = m;
Edit1->Text=""; }{
StringGrid1->Width = (StringGrid1->ColCount * (StringGrid1-
>DefaultColWidth+2))-1;
StringGrid1->Height = (StringGrid1->RowCount * (StringGrid1-
>DefaultRowHeight+2))-2;
StringGrid1->ScrollBars = ssNone;} }
else ShowMessage("NU ATI INTRODUS NIMIC!!!"); }
//---------------------------------------------------------------------------
void __fastcall TForm7::BitBtn17Click(TObject *Sender)
{Form7->Close();
StringGrid1->Visible=false;}
//---------------------------------------------------------------------------
void __fastcall TForm7::BitBtn1Click(TObject *Sender)
{if(Edit2->Text!=""){
citiresort7();
{StringGrid1->Visible=true;
StringGrid1->RowCount=n;
StringGrid1->ColCount=m;
StringGrid1->Cells[n][m];
for(i=0;i<n;i++)

20
for(j=0;j<m;j++) {
{StringGrid1->Cells[j][i]=b[i][j];}
cout<<endl;}}
int x=n;{
int rn = StrToInt(Edit2->Text);
n++;
StringGrid1->RowCount ++;
for(int i=n; i>rn; i--)
for(int j=0; j<m; j++)
{StringGrid1->Cells[j][i] = StringGrid1->Cells[j][i-1]; }
for(int j=0; j<m; j++){
StringGrid1->Cells[j][rn] = "";}
StringGrid1->Cells[0][n] = x;
Edit2->Text="";}
{StringGrid1->Width = (StringGrid1->ColCount * (StringGrid1-
>DefaultColWidth+2))-1;
StringGrid1->Height = (StringGrid1->RowCount * (StringGrid1-
>DefaultRowHeight+2))-2;
StringGrid1->ScrollBars = ssNone; }}
else ShowMessage("NU ATI INTRODUS UN NUMAR!!!");}
//---------------------------------------------------------------------------
void __fastcall TForm7::BitBtn3Click(TObject *Sender)
{ int x, a[100][100],n1,m1;
ifstream spirala("spirala.txt");
spirala>>n1>>m1;
for(int i=0;i<n1;i++){
for(j=0;j<m1;j++){
spirala>>a[i][j];} }
ofstream f27("spirala.txt") ;
try{
for(i=0;i<n;i++){
for(j=0;j<m;j++){
x=StringGrid1->Cells[j][i].ToInt();}}
f27<<n<<" ";f27<<m<<endl;

21
for(i=0;i<n;i++){
for(j=0;j<m;j++){
f27<<StringGrid1->Cells[j][i].ToInt()<<" ";}
f27<<endl;}
ShowMessage("Datele au fost afisate cu succes!!!");
Form7->Close();}
catch(Exception &exception){
ShowMessage("NU ATI INTRODUS DATA DE TIP INTEGER!!!");
ofstream spirala1("spirala.txt");
spirala1<<n1<<" "<<m1<<endl;
for(i=0;i<n1;i++){
for(j=0;j<m1;j++){
spirala1<<a[i][j]<<" ";}
spirala1<<endl; }}
Form7->Close();
StringGrid1->Visible=false;}
//---------------------------------------------------------------------------
void __fastcall TForm7::BitBtn4Click(TObject *Sender)
{int x, a[100][100],n1,m1;
ifstream spirala("spirala.txt");
spirala>>n1>>m1;
for(int i=0;i<n1;i++){
for(j=0;j<m1;j++){
spirala>>a[i][j];} }
ofstream f27("spirala.txt") ;
try{
for(i=0;i<n;i++){
for(j=0;j<m;j++){
x=StringGrid1->Cells[j][i].ToInt();}}
f27<<n<<" ";f27<<m<<endl;
for(i=0;i<n;i++){
for(j=0;j<m;j++){
f27<<StringGrid1->Cells[j][i].ToInt()<<" ";}

22
f27<<endl;}
ShowMessage("Datele au fost afisate cu succes!!!");
Form7->Close();}
catch(Exception &exception){
ShowMessage("NU ATI INTRODUS DATA DE TIP INTEGER!!!");
ofstream spirala1("spirala.txt");
spirala1<<n1<<" "<<m1<<endl;
for(i=0;i<n1;i++){
for(j=0;j<m1;j++){
spirala1<<a[i][j]<<" ";}
spirala1<<endl;} }
Form7->Close();
StringGrid1->Visible=false;}
//---------------------------------------------------------------------------
void __fastcall TForm7::StringGrid1Click(TObject *Sender)
{BitBtn2->Enabled=true;
BitBtn1->Enabled=true;}
//---------------------------------------------------------------------------
Forma8 (Unit8.cpp)
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include <iostream.h>
#include <fstream.h>
#include "Unit8.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm8 *Form8;
int p1,p2,minim,x1,x2;
int i,j,n,m,b[100][100],p[100][100],back=0;
void citiresort8(){
ifstream f8("spirala.txt");

23
f8>>n; f8>>m;
for(i=0;i<n;i++)
for(j=0;j<m;j++){
f8>>b[i][j]; }
f8.close();};
//---------------------------------------------------------------------------
__fastcall TForm8::TForm8(TComponent* Owner)
: TForm(Owner){}
//---------------------------------------------------------------------------
void __fastcall TForm8::BitBtn2Click(TObject *Sender)
{citiresort8();
StringGrid1->Visible=true;
StringGrid1->RowCount=n;
StringGrid1->ColCount=m;
StringGrid1->Cells[n][m];
for(i=0;i<n;i++){
for(j=0;j<m;j++) {
StringGrid1->Cells[j][i]=b[i][j];}
cout<<endl;}
minim=b[0][0];
p1=1;p2=1;
for(i=0;i<n;i++){
for(j=0;j<m;j++){
if(b[i][j]<minim){
minim=b[i][j];
p1=j+1;
p2=i+1;
}}}
Edit1->Text = IntToStr(minim);
Edit2->Text = IntToStr(p2);
Edit3->Text = IntToStr(p1);}
//---------------------------------------------------------------------------
void __fastcall TForm8::BitBtn17Click(TObject *Sender)

24
{Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
Form8->Close();}
//---------------------------------------------------------------------------
void __fastcall TForm8::BitBtn1Click(TObject *Sender)
{for(int i=p2-1; i<n; i++)
for(int j=0; j<m; j++){
StringGrid1->Cells[j][i] = StringGrid1->Cells[j][i+1];}
n--;
StringGrid1->RowCount --; {
StringGrid1->Width = (StringGrid1->ColCount * (StringGrid1-
>DefaultColWidth+2))-1;
StringGrid1->Height = (StringGrid1->RowCount * (StringGrid1-
>DefaultRowHeight+2))-2;
StringGrid1->ScrollBars = ssNone; }
for(int j=p1-1; j<m; j++)
for(int i=0; i<n; i++)
{ StringGrid1->Cells[j][i] = StringGrid1->Cells[j+1][i];}

m--;
StringGrid1->ColCount --; {
StringGrid1->Width = (StringGrid1->ColCount * (StringGrid1-
>DefaultColWidth+2))-1;
StringGrid1->Height = (StringGrid1->RowCount * (StringGrid1-
>DefaultRowHeight+2))-2;
StringGrid1->ScrollBars = ssNone; }
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";
ShowMessage("Elementele au fost excluse!!!");}
//---------------------------------------------------------------------------
void __fastcall TForm8::BitBtn3Click(TObject *Sender)
{ ofstream f18("spirala.txt");
f18<<n<<" ";f18<<m<<endl;

25
 for(i=0;i<n;i++) {
for(j=0;j<m;j++) {
f18<<StringGrid1->Cells[j][i].c_str()<<" "; }
f18<<endl; }
ShowMessage("Datele s-au afisat cu succes!!!");
Form8->Close();
StringGrid1->Visible=false;}
//---------------------------------------------------------------------------
Forma 9 (Unit9.cpp)
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include <fstream.h>
#include <iostream.h>
#include "Unit9.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm9 *Form9;
//---------------------------------------------------------------------------
__fastcall TForm9::TForm9(TComponent* Owner)
: TForm(Owner)
{}
//---------------------------------------------------------------------------
void __fastcall TForm9::BitBtn17Click(TObject *Sender)
{Form9->Close();
Label1->Visible=false;}
//---------------------------------------------------------------------------
void __fastcall TForm9::Button1Click(TObject *Sender)
{ char filePath[] = "P1.exe";
ShellExecute(NULL, NULL, filePath, NULL, NULL, SW_SHOWMINIMIZED);
Label1->Visible=true;}
//---------------------------------------------------------------------------

26
Forma 9 (p1.cpp)
#include <iostream>
#include <fstream>
using namespace std;
ifstream f1("spirala.txt");
ofstream f2("Select.txt");
int main()
{int v[100][100],i=1,j,e,a[100],l[100],poz[100];
int m,prim,k,s,d=1;
int n;f1>>n;
int h;f1>>h;
for(e=1;e<=n;e++)
for(s=1;s<=h;s++)
f1>>v[e][s];
for(k=1;k<=n;k++)
{i=1;
for(s=1;s<=h;s++)
{a[i]=v[k][s]; i++;}
for(i=n*h;i>=1;i--)
{ l[i]=1;poz[i]=0;
for(j=i+1;j<=n*h;j++)
if(a[i]<a[j] && l[i]<1+l[j])
{l[i]=1+l[j];poz[i]=j;}
if(m<l[i]) {m=l[i];prim=i;}}
for(i=prim;i>0;i=poz[i])
f2<<a[i]<<" ";
f2<<'\n';}}
//---------------------------------------------------------------------------
Forma 10 (Unit10.cpp)
#include <vcl.h>
#pragma hdrstop
#include <fstream.h>
#include <iostream.h>

27
#include "Unit10.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
ifstream f100("submatrice.txt");
int a[100][100],max1=0, pozi,pozj, n, i,j,m,b[100][100],x1,x2;
TForm10 *Form10;
void citiresort1000(){ ifstream f1000("submatrice.txt");
f1000>>n; f1000>>m; x1=n;x2=m;
for(i=0;i<n;i++)
for(j=0;j<m;j++){
f1000>>b[i][j];} f1000.close();};
int simetric(int x, int y, int i, int j)
{ if ((i-x)!=(j-y))return 0;else
for(int a1=x;a1<i+1;a1++)for(int b1=y;b1<j+1;b1++)
if (a[a1][b1]!=a[b1][a1])return 0;
return 1;}
void submatrice(){
for(int i=1;i<n+1;i++)for(int j=1;j<n+1;j++)
for(int a=i;a<n+1;a++)for(int b=j;b<n+1;b++)
if((simetric(i,j,a,b)==1)&&(((a-i+1)*(b-j+1))> max1 ))
{pozi=i;pozj=j;max1 =(a-i+1)*(b-j+1);}}
//---------------------------------------------------------------------------
__fastcall TForm10::TForm10(TComponent* Owner)
: TForm(Owner){}
//---------------------------------------------------------------------------
void __fastcall TForm10::BitBtn17Click(TObject *Sender)
{Form10->Close();
StringGrid1->Visible=false;
Edit1->Text="";
Edit2->Text="";
Edit3->Text="";}
//---------------------------------------------------------------------------

28
void __fastcall TForm10::Button1Click(TObject *Sender)
{int m;
f100>>n;
f100>>m;
for (int i=1;i<n+1;i++)
for (int j=1;j<m+1;j++)
{f100>>a[i][j];}
submatrice();
Edit1->Text=max1;
Edit2->Text=pozi;
Edit3->Text=pozj;
f100.close();{
citiresort1000();
StringGrid1->Visible=true;
StringGrid1->RowCount=x1;
StringGrid1->ColCount=x2;
StringGrid1->Cells[x1][x2];
for(i=0;i<x1;i++){
for(j=0;j<x2;j++) {
StringGrid1->Cells[j][i]=b[i][j];}
cout<<endl;}}}

29
 Rezultatele testării subprogramelor

1.Date de intrare

1.Exemplul 1 2.Exemplul 2

2.Date de iesire

Sarcina 1:

-Inserarea unei coloane:

3.Inserarea 4.Afisarea

5.Rezultatul

30
-Inserarea unei linii:

6.Inserarea 7.Afisarea

8.Rezultatul

Sarcina 2:

-Excluderea liniei si coloanei pe pozitia elementului minimal

9.Gasirea 10.Excluderea

31
Sarcina 3:
-Cel mai frecvent numar

11.Exemplul 1 12.Exemplul 2

Sarcina 4:
-Media aritmetică a elementelor [-10;10]

13.Exemplul 1 14.Exemplul 2

32
Sarcina 5:
-Sorteaza descrescator elementele fiecariei linii prin metoda numararii

15.Obtinerea 16.Sortarea

Sarcina 6:
-Creearea fiserului Select.txt cu elemente crescatoare

17.Exemplul 1 18.Exemplul 2

33
Sarcina 7:
-Gasirea unei submatrici de marime maximala

19.Exemplul 1

20.Exemplul 2

34
Sarcina 8:

-Stabilirea dacă este o spirala

21.Exemplul 1

22.Exemplul 2

35
 Funcționalitatea aplicației grafice de interacțiunea cu utilizatorul

Fiecare buton face afisarea formei corespunzatoare ,butoanele info afiseaza sarcina pentru buton,

Este un sistem de securizare cu parola ,pina cand nu punem parola putem vizualiza doar butoanele
info cu denumirea sarcinilor ,dup ace inseram parola avem acces la tot.

Butonul “Citire/Afisare”-Deschide Forma 2 cu citirea si afisarea din fisier

Butonul “Sarcina 1”-Deschide Forma 7 cu inserarea in fisier

Butonul “Sarcina 2”-Deschide Forma 8 cu excluderea in fisier

Butonul “Sarcina 3”-Deschide Forma 3 cu afisarea numarului frecvent

Butonul “Sarcina 4”-Deschide Forma 4 cu determinarea mediei aritmetice

Butonul “Sarcina 5”-Deschide Forma 5 cu sortarea matricei

Butonul “Sarcina 6”-Deschide Forma 9 cu creearea fisierului select

Butonul “Sarcina 7”-Deschide Forma 10 cu gasirea submatricei

Butonul “Sarcina 8”-Deschide Forma 6 cu problema 8

Butonul “Iesire”-Inchide Forma 1

36
 Estimarea coplexității algoritmilor aplicați

Complexitatea algoritmilor se caracterizează prin necesarul de memorie si durata de execuție,

unde V(n)-volumul de memorie interna necesara pentru păstrarea datelor cu care apelează
algoritmul T(n)-timpul necesar execuției algoritmului, de regulă in acest timp nu se include durata
operațiilor de introducere a datelor inițialeși de extragere a rezultatelor.

n – număr natural ce caracterizează volumul datelor de intrare ale unui algoritm

Estimarea valorii V(n) poate fi realizată calculând numărul variabililor din algoritmul analizat.

Fiecare tip de date are numărul său de octeți.

Pentru estimarea timpului de execuție T(n) se caută o limită superioara a timpului cerut
analizându-se doar cazurile cele mai defavorabile. Prin ∆ vom nota timpul maxim necesar pentru a
execuția unei operații Pascal, valoarea concreta a lui ∆ depinde de mediul de programare si
performanțele calculatorului. Deci T(n)= ∆*Q(n), unde Q(n) este numărul de operații elementare
necesare pentru soluționarea problemei. Numărul de operații elementare pentru execuția unui
program C++ depinde de tipul instrucțiunii.

n = 100

Vs(n) = (n * 2) + (n2 * 2) + (8 * 2) = 2n2 + 2n + 16

37
 Concluzie

În concluzie, pot spune că după finisarea stagiului de practică apar unele deprinderi din
domeniul IT.

Lucrarea practică m-a ajutat să înțeleg mai bine cum lucrează aplicația C++ Builder.

Personal, stagiul de practică m-a ajutat să devin o persoană mai responsabilă și să înțeleg că trebuie
să mă atârn mai serios asupra itemilor oferiți.

Practica este o parte a procesului educațional, oferă elevului posibilitatea de a se manifesta în cadrul
programării, în plus, noi ne familiarizăm cu programarea.

În procesul creării programului elevul trebuie să creeze programe complexe, să folosească metode
noi de programare, să găsească soluții noi. Toate aceste acțiuni pretinde timp și eforturi fizice+
mentale.

Pe viitor voi ști asupra căror aspecte să mă axez când voi crea un program, voi fi gata să depun
maxim eforturi pentru atingerea unei performanțe noi, aceste lucruri contribuie la dezvoltarea
profesională.

Practica este o încercare pentru viitorul specialist în domeniu, aici noi dezvoltăm deprinderi noi.

38
 Bibliografia

1. Gh. Bostan. Culegere de probleme de informatică, Chişinău , Editura "Lumina. Biblioteca instituției /
Internet

2. G. Damian-Timoşenco, E. Ionaşcu-Cuciuc, Ghid de elaborare a curriculumului profesional, Chişinău, 2011.

Biblioteca instituției / Internet
3. Doina Logofătu. Bazele programării în C. Aplicaţii. Editura POLIROM, Iaşi, 2006. Biblioteca instituției /
Internet
4. Vasile Petrovici, Florin Goicea. Programarea în limbajul C. București, Editura Tehnica, 1993. Biblioteca
instituției / Internet
5. Cornelica Ivaşc, L.M. Condurache, Mona Carme Prună, D. Hrinciuc-Logofătu. Manual de informatică C++
(cl. XI). Bucureşti, editura „Petrion Impex”, 2002. Biblioteca instituției / Internet
6. D. Logofătu. C++. Probleme rezolvate şi algoritmi. Editura POLIROM, 2001. Biblioteca instituției / Internet
7. Mickey Williams, Visual C++. București, editura TEORA, 1996. Biblioteca instituției / Internet
8. A. Braicov, S. Gîncu. Borland C++Builder. Ghid de iniţiere. „Tipografia centrală”, 2009. Biblioteca
instituției / Internet
9. Emanuela Cerchez, Marinel-Paul Șerban “Programarea in limbajul C/C++ pentru liceu.” Volumul al II-lea:
Metode si tehnici de programare POLIROM 2005 Biblioteca instituției / Internet
10. Emanuela Cerchez, Marinel-Paul Șerban “ Programarea in limbajul C/C++ pentru liceu. Programare
orientata pe obiecte si programare generica cu STL.” Volumul al IV-lea: POLIROM 2013 Biblioteca
instituției / Internet
11. Marin Popa, Mariana Popa. Programare procedurală (aplicaţii C şi C++ în structuri de date şi grafică).
Editura fundaţiei România de mîine, Bucureşti, 2006. Biblioteca instituției / Internet

39