Radiații Raport

2.
Cuprins
3.Introducere:.......................................................................................................................................3
3.2 Competenţele practicii:...............................................................................................................4
3.3 Compententele profesionale:......................................................................................................4
3.4 Competentele specifice:.............................................................................................................5
4.Enunţul sarcinii individuale:.............................................................................................................6
5.Descrierea modului de elaborare a aplicatiei:...................................................................................7
Form1:..............................................................................................................................................7
Form2:..............................................................................................................................................7
Form3:..............................................................................................................................................8
Form4:..............................................................................................................................................8
6. Listing-ul programului:....................................................................................................................9
a)Unit1.cpp.......................................................................................................................................9
b)Unit1.h.........................................................................................................................................17
6. Rezultatele testării subprogramelor:...........................................................................................19
Deschiderea fișierelor:....................................................................................................................19
Excluderea din planul terenului a unui rând și coloane:................................................................19
Actualizarea conținutului zonelor de pe perimetrul marginal:.......................................................20
Determinarea dozei medii de radiație:............................................................................................20
Zona cu doza maximă de poluare:..................................................................................................20
Despre cercetator:...........................................................................................................................20
Doza minimă de radiație prmită de cercetător la traversarea terenului:.........................................21
Înscrierea liniilor impare în fișierul ImparLin:...............................................................................21
Numărul de pătrățele trasate de diagonala terenului in studiu:......................................................22
7. Estimarea complexității algoritmilor aplicați.................................................................................22
8. Concluzie:.......................................................................................................................................23
9.Bibliografie:.....................................................................................................................................24
3.Introducere:
Pentru elaborarea programului am folosit toate cunoștințele acumulate până acum la orele de
POO. Programul este alcătuit dintr-o interfață simplă pentru ca utilizatorul care nu cunoaște
programul să poată să-l folosească fără unele dificultăți.
Fiece student începător, odată cu familiarizarea și însăși programarea în diferite limbaje de
programare își dezvoltă anumite calități de programator, mai bune, sau mai puțin bune. Însă un
programator real este cel care poate rezolva orice problemă reală într-un timp și spațiu cât mai
restrains. Aceste probleme presupun elaborarea unor complexe programate mari, care includ o
gamă întreagă de metode și funcții: proiectarea sistemului, elaborarea părţilor componente ale
algoritmului, reunirea diverselor fragmente ale programului într-un produs final, documentarea 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 proces de elaborare a unui complex programat mare, permite studentului să evolueze
în rolul de elaborator şi organizator al proiectului.
În procesul lucrului de sine stătător asupra sarcinii individuale, am elaborat și descris
algoritmi în limbajul C++ Builder, am testat și depanat programe respective
Practica de Specialitate este o lucrare de programare vizuală a mea, care a contribuit și a
format niște calități necesare unui programator
Efectuând lucrarea dată, am îndeplinit obiectivele generale ale acestei practice, și anume:
- S-au format anumite deprinderi de cercetător și organizator;
- S-au însușit tehnologii de elaborare a programelor de un volum major.
- S-au consolidat cunoștințe teoretice obținute pe parcursul studierii limbajului de programare
(C++, C++ Builder);
- S-au dezvoltat abilități în munca de sine stătătoare și în echipă.
2
3.2 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.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ă.
3
3.4 Competentele 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
4.Enunţul sarcinii individuale:
16. Radiaţii. În urma unei catastrofe tehnologice o porţiune dreptunghiulară de teren de
dimensiunea nm a fost poluată cu substanţe radioactive. Pentru a descrie gradul de poluare,
terenul respectiv a fost divizat în zone pătratice de lungimea 1 (exemplu vezi în figura 1).
Informaţii mai concrete despre zonele terenului
considerat sunt înregistrate în fişierul text Radiatii.in,
care conţine pe prima linie numerele naturale n şi m,
separate prin spaţiu. Următoarele n linii ale acestui fişier
conţin câte m numere întregi dij , separate prin câte un
spaţiu, fiecare din aceste valori reprezentând numărul de
unităţi ale dozei de radiaţie pe care, eventual, ar putea să o
primească o persoana ce va parcurge zona respectivă [i, j],
1 ≤ i ≤ n, 1 ≤ j ≤ m.
Să se creeze o aplicație care să realizeze, la solicitarea
utilizatorului, următoarele prescripţii:
(Design-ul aplicației vă aparține).
1) Actualizează (prin substituire în fişierul de intrare) conţinutul zonelor de pe perimetrul
(marginea) terenului;
2) Exclude din planul terenului un rând (marginal) / o coloană (marginală); poziţia rândului;
3) Determină indicii liniilor ce conţin zone cu doză maximală de poluare;
4) Înscrie în tabloul liniar B[1..m], în ordinea ascendentă valorile d1,j, ( 1 ≤ j ≤ m); datele se vor
sorta prin metoda numărării;
5) Determină doza medie de radiaţie pe zonele întregului teren în studiu;
6) Creează fişierul text ImparLin.txt, în care se vor
transcrie liniile impare ale fişierului de intrare
Radiatii.in;
7) Determină numărul de pătrăţele trasate de diagonala
terenului în studiu; De exemplu, pentru n = 9 şi m = 12,
diagonala dreptunghiului (terenului) va trasa 18 pătrăţele (vezi
figura 2);
8) Rezolvă problema. Un cercetător trebuie să ajungă din
zona [1, 1] în zona [n, m] a terenului poluat în studiu. Trecerea
dintr–un pătrăţel în altul se poate efectua numai prin laturile
adiacente. Este cunoscut faptul că la parcurgerea pătrăţelului
[i, j] cercetătorul va primi o doză de radiaţie de dij unităţi, doza
totală reprezentând suma dozelor pătrăţelelor parcurse. Alegând diferite drumuri, cercetătorul ar
putea minimiza doza totală.
Elaboraţi un subprogram ce calculează doza totală minimă dmin.
Date de intrare. Fişierul text Radiatii.in, descris anterior;
Date de ieşire. Fişierul text Radiatii.out , va conţine pe o singură linie numărul întreg dmin.
Exemplu.
Radiatii.in Radiatii.out
3 5 9
2 100 0 100 100
1 100 0 0 0
1 0 3 100 2
5
Restricţii. 1≤ n, m ≤ 30; 1 ≤ dij ≤ 100. Timpul de execuţie nu va depăşi o secundă la un test.
6
5.Descrierea modului de elaborare a aplicatiei:
Form1:
Am adăugat 2 componente de tip TEdit pentru a introduce denumirile de fișier, 2
componente de tip TLabel pentru a adăuga comentarii la cele 2 edituri. Am adăugat 5
butoane: 1 pentru ieșire , 2 pentru deschidere , 2 pentru a salva după ce am introdus careva
schimbări. Am adăugat 2 componente de tip TStringGrid pentru a citi informația din fișier.
Am adăugat un component de tip TMainMenu pentru a ușura si simplifica accesarea
cerințelor programului.
Img. 5.1
Form2:
Aici am adăugat 2 butoane pentru calcularea si închiderea ferestrei apărute la
alegerea unei opțiuni din componeta TMainMenu. Deasemenea 2 componente TEdit
pentru introducerea dimensiunilor maxime a zonei și 3 componente de tip TLabel pentru
mesaje și afișarea rezultatului.
Img.5.2
7
8
Form3:
Aici am adăugat 1 buton pentru ștergerea liniei. Deasemenea un TEdit pentru
introducerea Nr liniei,și o componentă de tip TLabel pentru message.
Img. 5 3
Form4:
Aici am adăugat 1 buton pentru ștergerea coloanei. Deasemenea un TEdit pentru
introducerea Nr coloanei,și o componentă de tip TLabel pentru mesaje.
Img. 5 4
9
6. Listing-ul programului:
1.Programul principal:
a)Unit1.cpp
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "uPraktika3.h"
#include "uMax.h"
#include "uSredUroj.h"
#include "uRabotnik.h"
#include "uDelRow.h"
#include "uDelCol.h"
#include "Unit7.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
const int nmax = 20;
AnsiString FileName1, FileName2;
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
int GetData (int f, AnsiString *st)
{
unsigned char buf[256];
unsigned char *p = buf;
int n;
int len = 0;
do
n = FileRead(f, p, 1);
while ((n != 0)&&(*p == ' '));
while ((n != 0)&&(*p != ' ')){
if (*p == '\r'){
break;
}
len++;
p++;
}
*p = '\0';
if (len != 0)
st->printf("%s", buf);
return len;
}
//---------------------------------------------------------------------------
void GetRC(int f, int &n1, int &m)
{
unsigned char buf[256];
unsigned char *p = buf;
int n,i=0,j=0;
do
{
if (n != 0)
10
{
if (*p == '\n') i++;
if ((*p == '\n') || (*p == ' ')) j++;
}
}
while (n != 0);
n1=i;
m=j/n1;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Tab1Sizes()
{
StringGrid1->Width = (StringGrid1->ColCount * (StringGrid1-
>DefaultColWidth+2))-1;
StringGrid1->Height = (StringGrid1->RowCount * (StringGrid1-
>DefaultRowHeight+2))-2;
StringGrid1->ScrollBars = ssNone;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Tab2Sizes()
{
StringGrid2->Width = (StringGrid2->ColCount * (StringGrid2-
>DefaultColWidth+2))-1;
StringGrid2->Height = (StringGrid2->RowCount * (StringGrid2-
>DefaultRowHeight+2))-2;
StringGrid2->ScrollBars = ssNone;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::N2Click(TObject *Sender)
{
Label1->Visible = true;
Edit1->Visible = true;
}
//---------------------------------------------------------------------------
{
Label2->Visible = true;
Edit2->Visible = true;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key)
{
if (Key==VK_BACK) return;
if (Key==VK_RETURN)
{
Button4->SetFocus();
return;
}
if ( (Edit1->Text).Length() != 0 ) Button4->Visible = true;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Edit2KeyPress(TObject *Sender, char &Key)
{
if (Key==VK_BACK) return;
if (Key==VK_RETURN)
{
Button3->SetFocus();
return;
}
if ( (Edit2->Text).Length() != 0 ) Button3->Visible = true;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button3Click(TObject *Sender)
{
11
StringGrid2->Visible = true;
int f;
int ls;
AnsiString st;
if (Edit2->Text.Length() ==0 ) ShowMessage("Eror!");
else
{
FileName2=Edit2->Text;
if ( FileExists(FileName2) )
f = FileOpen(FileName2,fmOpenRead);
else {
ShowMessage("Eror!");
return;
}
if ( f != -1 )
{
GetRC(f,NRows,MColumns);
StringGrid2->RowCount = NRows + 1;
StringGrid2->ColCount = MColumns + 1;
FileClose(f);
}
else
{
Edit2->Text = "";
Edit2->SetFocus();
}
else ShowMessage("Eror!");//f = FileCreate(FileName);
if ( f != -1 )
{
for(int i=0; i<NRows; i++)
for(int j=0; j<MColumns; j++)
{
ls=GetData(f,&st);
if(ls) StringGrid2->Cells[j+1][i+1]=StrToInt(st);
}
StringGrid2->Cells[0][i+1] = i+1;
StringGrid2->Cells[j+1][0] = j+1;
FileClose(f);
}
else
{
Edit2->Text = "";
Edit2->SetFocus();
}
Tab2Sizes();
}
if (StringGrid1->Visible == true && StringGrid2->Visible == true)
{
N4->Enabled = true;
N9->Enabled = true;
N15->Enabled = true;
}
}
//---------------------------------------------------------------------------
{
12
int f;
int ls;
AnsiString st;
if (Edit1->Text.Length() ==0 ) ShowMessage("Eror!");
else
{
FileName1=Edit1->Text;
else
{
ShowMessage("Eror!");//f = FileCreate(FileName);
return;
}
if ( f != -1 )
{
GetRC(f,NRows,MColumns);
StringGrid1->RowCount = NRows + 1;
StringGrid1->ColCount = MColumns + 1;
FileClose(f);
}
else
{
Edit1->Text = "";
Edit1->SetFocus();
}
else ShowMessage("Eror!");
if ( f != -1 )
{
{
ls=GetData(f,&st);
if(ls) StringGrid1->Cells[j+1][i+1]=st;
}
StringGrid1->Cells[0][i+1] = i+1;
StringGrid1->Cells[j+1][0] = j+1;
FileClose(f);
}
else
{
Edit1->Text = "";
Edit1->SetFocus();
}
Tab1Sizes();
}
if (StringGrid1->Visible == true && StringGrid2->Visible == true)
{
N4->Enabled = true;
N9->Enabled = true;
N15->Enabled = true;
}
}
//---------------------------------------------------------------------------
{
13
Form2->FormRef = Form1;
Form2->Show();
}
//---------------------------------------------------------------------------
{
Form3->Show();
}
//---------------------------------------------------------------------------
{
Form4->Show();
}
//---------------------------------------------------------------------------
{
int k=0;
int flag;
AnsiString der[nmax*nmax], spisok="";
der[k]="0";
for(int i=1; i<=NRows; i++)
for(int j=1; j<=MColumns; j++)
{
int flag = 0;
for(int t=0; t<=k;t++)
if (StringGrid1->Cells[1][i] == der[t]) flag++;
if (flag == 0)
{
der[k]= StringGrid1->Cells[1][i];
k++;
}
}
spisok="";
for(int t=0; t<k;t++)
spisok= spisok + "\n" + der[t];
ShowMessage(spisok);
}
//---------------------------------------------------------------------------
{
NRows++;
StringGrid1->RowCount ++;
{
StringGrid1->Cells[j][NRows] = "";
StringGrid2->Cells[j][NRows] = "";
}
StringGrid1->Cells[0][NRows] = NRows;
Tab1Sizes();
Tab2Sizes();
Button1->Visible = true;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::File1Rewrite(int f)
{
AnsiString str_ln="\x0D\x0A";
AnsiString str_sp=" ";
ShowMessage(NRows);
14
{
FileWrite(f,(StringGrid1->Cells[j][i]).c_str(),(StringGrid1-
>Cells[j][i]).Length());
if (j == MColumns )
FileWrite(f,str_ln.c_str(),str_ln.Length());
else FileWrite(f,str_sp.c_str(),str_sp.Length());
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::File2Rewrite(int f)
{
AnsiString str_ln="\x0D\x0A";
AnsiString str_sp=" ";
{
FileWrite(f,(StringGrid2->Cells[j][i]).c_str(),(StringGrid2-
>Cells[j][i]).Length());
if (j == MColumns )
FileWrite(f,str_ln.c_str(),str_ln.Length());
else FileWrite(f,str_sp.c_str(),str_sp.Length());
}
}
//---------------------------------------------------------------------------
{
int f1,s;
if(FileExists(FileName1)) DeleteFile(FileName1);
f1 = FileCreate (FileName1);
if (f1!=-1)
{
File1Rewrite(f1);
FileClose(f1);
Button1->Visible = false;
}
else
}
//---------------------------------------------------------------------------
{
int f2;
if(FileExists(FileName2)) DeleteFile(FileName2);
f2 = FileCreate (FileName2);
if (f2!=-1)
{
File2Rewrite(f2);
FileClose(f2);
Button2->Visible = false;
}
else
ShowMessage("EROR!");
}
//---------------------------------------------------------------------------
{
NRows++;
for(int i=NRows; i>2; i--)
{
15
StringGrid1->Cells[j][i] = StringGrid1->Cells[j][i-1];
StringGrid2->Cells[j][i] = StringGrid2->Cells[j][i-1];
}
{
StringGrid1->Cells[j][1] = "";
StringGrid2->Cells[j][1] = "";
}
Tab1Sizes();
Tab2Sizes();
}
//---------------------------------------------------------------------------
{
MColumns++;
StringGrid1->ColCount ++;
{
StringGrid1->Cells[MColumns][i] = "";
StringGrid2->Cells[MColumns][i] = "";
}
StringGrid1->Cells[MColumns][0] = MColumns;
Tab1Sizes();
Tab2Sizes();
}
//---------------------------------------------------------------------------
{
MColumns++;
for(int j=MColumns; j>2; j--)
{
StringGrid1->Cells[j][i] = StringGrid1->Cells[j-1][i];
StringGrid2->Cells[j][i] = StringGrid2->Cells[j-1][i];
}
{
StringGrid1->Cells[1][i] = "";
StringGrid2->Cells[1][i] = "";
}
Tab1Sizes();
Tab2Sizes();
}
//---------------------------------------------------------------------------
{
Form5->Show();
}
//---------------------------------------------------------------------------
16
{
Form6->Show();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Edit1Click(TObject *Sender)
{
Edit1->Text="";
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Edit2Click(TObject *Sender)
{
Edit2->Text="";
}
//---------------------------------------------------------------------------
{
Form1->Close();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Creareafisierului1Click(TObject *Sender)
{if (Edit1->Text.Length() != 0 && Edit2->Text.Length() != 0)
{
AnsiString file = "ImparLin.txt";
AnsiString temp = Edit1->Text + "|" + Edit2->Text;
TStringList *list1 = new TStringList;
if (FileExists(file))
{
list1->LoadFromFile(file);
list1->Add("3 5 1 100 0 0 0");
}
list1->Add(temp);
list1->SaveToFile(file);
delete list1;
ShowMessage("Ati creat cu succes!");
}
}
//---------------------------------------------------------------------------
{
ShowMessage("Cercetatorul parcurge zonele de pe diagonala cit de tare se va
infecta?");
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Lungimeadiagonalei1Click(TObject *Sender)
{ Form7->FormRef=Form1;
Form7->Show();
}
17
b)Unit1.h
//---------------------------------------------------------------------------
#ifndef uPraktika3H
#define uPraktika3H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <Menus.hpp>
#include <Grids.hpp>
#include <ExtCtrls.hpp>
#include <Dialogs.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published: // IDE-managed
Components
TMainMenu *MainMenu1;
TMenuItem *N1;
TMenuItem *N2;
TMenuItem *N3;
TMenuItem *N4;
TMenuItem *N5;
TMenuItem *N6;
TMenuItem *N7;
TMenuItem *N8;
TMenuItem *N9;
TMenuItem *N10;
TMenuItem *N11;
TMenuItem *N15;
TMenuItem *N16;
TMenuItem *N17;
TEdit *Edit1;
TLabel *Label1;
TLabel *Label2;
TEdit *Edit2;
TStringGrid *StringGrid1;
TStringGrid *StringGrid2;
TButton *Button1;
TButton *Button2;
TMenuItem *N18;
TMenuItem *N19;
TButton *Button3;
TButton *Button4;
TButton *Button5;
TMenuItem *Fisier1;
TMenuItem *Creareafisierului1;
TMenuItem *Lungimeadiagonalei1;
void __fastcall File1Rewrite(int f);
void __fastcall File2Rewrite(int f);
void __fastcall Tab1Sizes();
void __fastcall Tab2Sizes();
void __fastcall N2Click(TObject *Sender);
void __fastcall Edit1KeyPress(TObject *Sender, char &Key);
void __fastcall Edit2KeyPress(TObject *Sender, char &Key);
18
void __fastcall Button1Click(TObject *Sender);
void __fastcall Edit1Click(TObject *Sender);
void __fastcall Edit2Click(TObject *Sender);
void __fastcall Creareafisierului1Click(TObject *Sender);
void __fastcall Lungimeadiagonalei1Click(TObject *Sender);
private: // User declarations
public: // User
declarations
int NRows, MColumns;
TForm1 *FormRef;
__fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif
19
6. Rezultatele testării subprogramelor:
Deschiderea fișierelor:
Img. 6
Excluderea din planul terenului a unui rând și coloane:
Img. 6.1
20
Actualizarea conținutului zonelor de pe perimetrul marginal:
Img. 6.2
Determinarea dozei medii de radiație:
Img. 6.3
Zona cu doza maximă de poluare:
Img. 6.4
Despre cercetator:
Img. 6.5
21
Doza minimă de radiație prmită de cercetător la traversarea terenului:
Img. 6.6
Img. 6.7 Img. 6.8
Înscrierea liniilor impare în fișierul ImparLin:
Img. 6.9 Img. 6.10
22
Numărul de pătrățele trasate de diagonala terenului in studiu:
Img. 6.11
7. Estimarea complexității algoritmilor aplicați

În întreg programul am avut algoritmi de complexități diferite. La punctele mai dificile cum
ar fi (1,3,4,5,7,8) am folosit și algoritmi de rezolvare mai dificili, care aveau un cod mai voluminos.
Celelalte puncte cum ar fi (2,6) au fost mai ușoare și astfel și algoritmul a fost mic. Programul
însuși a fost destul de dificil după părerea mea deoarece l-am înțeles destul de greu.
23
8. Concluzie:
Odată cu efectuarea practicii date, cel mai important lucru dedus este că mi-a format
anumite deprinderi în domeniul programării, în lucru în echipă și cu profesorul.
Efectuând programul și el fiind de o complexitate majoră, desigur că am întâlnit
anumite dificultăți și anume: la parcurgerea Stringgrid-ului, deoarece nu eram cunoscut cu
tehnologia de parcurgere; la actualizarea și excluderea datelor din fișier, dar cu ajutorul
colegilor și conducătorului de practică – mi-a reușit.
Practica de specialitate I reprezintă o parte componentă a procesului educativ care
este o perioadă importantă pentru noi, deoarece anume în timpul petrecerii practicii ne
aprofundăm cunoștințele acumulate timp de doi ani; de asemenea ne permite să aplicăm în
practică și cunoștințele teoretice la obiectul “Programării Calculatorului”.
Î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.
La rezolvarea sarcinii mele am folosit aplicații precum Borland C++ Builder (v. 6.0)
dar și CodeBlocks pentru anumiți algoritmi, ca mai apoi să-i convertesc în C++ Builder.
Sarcina a fost una dificilă, deoarece s-a folosit un limbaj inexplicabil și foarte greu
de înțeles. Cu ajutorul acestei practici am reușit să mă deprind mult în lucrul cu fișierele și
în general programele mari.
După petrecerea acestor 15 zile de practică mi-am format noi competențe și
deprinderi pentru viitor în domeniul programării orientate pe obiecte. Am aplicat pe deplin
cunoștințele despre limbajul de programare C++, acomulate pe parcursul unui an de studii.
Mai exact mi-am aprofundat cunoștințele asupra structurilor de date bidimensionale, lucrul
cu fișierele, citirea datelor din fișier, scrierea lor în fișier, efectuarea diferitor operații cu
datele din acel fișier.
24
9.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 rezolvarii problemelor de informatica în stilul orientat pe obiecte.
25

Radiații Raport

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Radiații Raport

Încărcat de

Drepturi de autor:

Formate disponibile

2.

3.3 Compententele profesionale:

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

9. Aplicarea fundamentelor teoretice ale ştiinţelor juridice, sociale şi economice în

Excluderea din planul terenului a unui rând și coloane:

Determinarea dozei medii de radiație:

Zona cu doza maximă de poluare:

Img. 6.7 Img. 6.8

Înscrierea liniilor impare în fișierul ImparLin:

Img. 6.9 Img. 6.10

7. Estimarea complexității algoritmilor aplicați

S-ar putea să vă placă și