Portofoliu Eugeniu Ceban1

COLEGIUL UNIVERSITĂȚII TEHNICE A
MOLDOVEI
PORTOFOLIU
la unitatea de curs
Programarea Procedurală
Elaborat: Verificat:
Elevul/a grupei RC_231 Burca Eugenia,
Nume Prenume master în informatică,
Ceban Eugeniu profesor de informatică.
Chișinău, 2024
Cuprins
1. Programarea-pasiunea mea...............................................................................................................4
2. Tipul de date fișier. Operații de specifice tipului de date fișier.......................................................5
2.1 În cadrul orelor de teorie............................................................................................................5
2.2 Probleleme rezolvate în cadrul lecției de laborator și tema pentru acasă...................................5
3. Metode de sortare.............................................................................................................................7
3.1. În cadrul orelor de teorie...........................................................................................................7
3.2. În cadrul orelor de laborator și tema pentru acasă.....................................................................7
4. Structuri. Tablouri de structuri.........................................................................................................8
4.1 Structuri......................................................................................................................................8
4.1.1 În cadrul orelor de teorie.....................................................................................................8
4.1.2 În cadrul orelor de laborator și tema pentru acasă...............................................................8
4.2 Tablouri de structuri...................................................................................................................8
5. Pointeri. Variabile Pointeri...............................................................................................................9
5.1 Variabile Pointeri.......................................................................................................................9
5.2 Pointeri și tablouri......................................................................................................................9
5.3 Alocarea dinamică a memoriei pentru tablouri. Eliberarea memoriei.......................................9
6. Subprograme..................................................................................................................................10
6.1 Subprograme 1.........................................................................................................................10
6.1.1 În cadrul orelor de teorie...................................................................................................10
6.1.2 În cadrul orelor de laborator și tema pentru acasă.............................................................10
6.2 Subprograme 2.........................................................................................................................10
6.3 Subprograme (parametri de tip tablou)....................................................................................10
-2-
6.4 Subprograme recursive.............................................................................................................10
6.5 Subprograme. Particularități în utilizare..................................................................................10
6.5.2 Realizare proiect propriu...................................................................................................11
DECLARAŢIA PRIVIND ASUMAREA RĂSPUNDERII..............................................................12
-3-
1. Programarea-pasiunea mea.
Tema „Programarea – pasiunea mea” este una care eu o consider relativă. Într-un caz, iubesc
programarea, fiind ceva ce este clasificată ca „viitorul”, dar în alt caz, nu aș alege să am un job
anume în sfera programării și scrierii a codului. De ce? Sincer să spun, găsesc asta plictisitor și
nesănătos, fiind în fața ecranului unui calculator pentru 7-8 ore într-o zi. Asta se aplică la orice Job
ce include lucrul într-un oficiu unde, similar, trebuie să iți dedici ziua ecranului calculatorului. În
același caz, nu cred că asta este o idee care se aplică tuturor, deoarece știu unii oameni care iubesc
să facă asta. Nu este ceva pentru mine. Un alt argument ar fi faptul că liniile de cod, mai ales când
ai mii de linii de cod, consider stresant și sincer greu să țin minte. Acesta este un motiv de ce am
ales să fiu un rețelist: mai puțin cod, mai mult hardware și deja codul care ai nevoie pentru a
administra o rețea de calculatoare. Nu spun că va fi ușor, dare din câte am învățat în NetAcademy
până la acest moment și la lecțiile doamnei Ludmila Peca, este ceva ce îmi place.
În concluzie, consider că programarea nu este pasiunea mea, în același timp respectâmd-o pe ea și
oamenii care o practică.
-4-
2. Tipul de date fișier. Operații de specifice tipului de date fișier
2.1 În cadrul orelor de teorie
Plasează condiția, codul și execuția de la problemele rezolvate la teorie și din prezentare
Ca de exemplu:
Programa 5
Condiție
Lunar Ionel primește de la părinți A lei pentru a achita factura pentru consumul de gaz şi
apă. În luna curentă consumul de gaze a fost de 43.23 m3, iar de apă de 67.78 m3. De la tastatură se
citește suma de bani primită de Ionel, costul unui m 3 de gaz și costul unui m3 de apă. Să se
elaboreze un program prin intermediul căruia se va afișa la ecran suma ce necesită a fi achitată de
către Ionel, cât și suma de bani rămasă.
Implementare în C++
#include<iostream>
#include<iomanip>
using namespace std;
float A,apa,gaz,rest,f;
const float g=43.23;
const float a=67.78;
main(){
cout<<"Indicati suma initiala ";cin>>A;
cout<<"Dati costul pentru un metru cub de gaz";
cin>>gaz;
cout<<"Dati costul pentru un metru cub de apa";
cin>>apa;
f=gaz*g+apa*a;
rest=A-f;
cout<<"Suma pentru achitarea facturii=";
cout<<setprecision(2)<<f<<endl;
cout<<"Lui Ionel iau ramas";
cout<<setprecision(2)<<rest<<" lei";
}
Rezultatul execuției
2.2 Probleleme rezolvate în cadrul lecției de laborator și tema pentru acasă
-5-
11) Fişierul date.in conţine un şir de caractere. De la tastatură se citeşte un şir de
caractere. Elaboraţi un program care va înlocui cifrele din şir cu semnul +. Rezultatul va
fi afişat la ecran cât şi în fişierul date.out
12) Fişierul date.in conţine un şir de caractere. De la tastatură se citeşte un şir de

caractere. Elaboraţi un program care va afişa doar cifrele din şir. Rezultatul va fi afişat
la ecran cât şi în fişierul date.out
-6-
-7-
3. Metode de sortare
3.1. În cadrul orelor de teorie
se includ toate programele de la ora de teorie + prezentarea de pe classroom
3.2. În cadrul orelor de laborator și tema pentru acasă
se includ toate probleme de la orele de laborator + prezentarea de pe classroom
-8-
4. Structuri. Tablouri de structuri.
4.1 Structuri.
4.1.1 În cadrul orelor de teorie
se includ toate programele de la ora de teorie + prezentarea de pe classroom
4.1.2 În cadrul orelor de laborator și tema pentru acasă
4.2 Tablouri de structuri.


Programe elaborate în laborator
Ex1
#include <iostream>
struct copil{
char nume[15]; int ziua,luna,anul;
} c1 ,c2, c3;
int main()
{
int varsta1,varsta2,varsta3;
cout<<"Date primul copil: "<<endl;
cout<< "Nume: "; cin>>c1.nume;
cout<< "Ziua: "; cin>>c1.ziua;
cout<< "Luna: "; cin>>c1.luna;
cout<< "Anul : "; cin>>c1.anul;
cout<<"Date al doilea copil: "<<endl;

cout<<"Date al treilea copil: "<<endl;

varsta1= c1.ziua+c1.luna*30+ (2024-c1.anul)*360;

-9-
cout<<c1.nume<<" are "<<varsta1<<" zile"<<endl;
if(varsta1>varsta2 )
{ if(varsta2 > varsta3)
{ cout<<"Cel mai mare este: "<<c1.nume<<endl;
cout<<"Cel mijlociu este: "<<c2.nume<<endl;
cout<<"Cel mai mic este: "<<c3.nume<<endl;}
else
}
if(varsta2 > varsta3 )
else
}
if(varsta3>varsta1 )
else
}
return 0;
}
|Ex 2
#include <iostream>
struct data{
int ziua,luna,anul;
} c1 ,c2, sum,dif;
int main()
{
-10-
cout<<"Datele despre prima variabila: "<<endl;
cout<<"Datele despre a doua variabila "<<endl;

sum.ziua=c1.ziua+c2.ziua;
sum.luna=c1.luna+c2.luna;
sum.anul=c1.anul+c2.anul;
if(sum.ziua>30){
sum.luna++;
sum.ziua -=30;
}
if(sum.luna>12){
sum.anul++;
sum.luna -=12;
}
if(c1.ziua+c1.luna*30+ c1.anul*360> c2.ziua+c2.luna*30+ c2.anul*360){

dif.ziua=c1.ziua-c2.ziua;
dif.luna=c1.luna-c2.luna;
dif.anul=c1.anul-c2.anul;
}else
{
dif.ziua=c2.ziua-c1.ziua;
dif.luna=c2.luna-c1.luna;
dif.anul=c2.anul-c1.anul;
}
if(dif.ziua<0){
dif.luna--;
dif.ziua+=30;
}
if(dif.luna<0){
dif.anul--;
dif.luna+=12;
cout<<"Data 1: "<<endl;
cout<<c1.ziua<<"/"<<c1.luna<<"/"<<c1.anul<<endl;
cout<<"Data 2: "<<endl;
cout<<c2.ziua<<"/"<<c2.luna<<"/"<<c2.anul<<endl;
-11-
cout<<"Suma: "<<endl;
cout<<sum.ziua<<"/"<<sum.luna<<"/"<<sum.anul<<endl;
cout<<"Diferenta: "<<endl;
cout<<dif.ziua<<"/"<<dif.luna<<"/"<<dif.anul<<endl;
return 0;
}
Ex 3
#include <iostream>
struct data{
int sec,min,ora;
} c1 ,c2, sum,dif;
int main()
{
cout<<"Datele despre prima variabila: "<<endl;

cout<< "Ore: "; cin>>c1.ora;
cout<< "Minute: "; cin>>c1.min;
cout<< "Secunde: "; cin>>c1.sec;
cout<<"Datele despre a doua variabila "<<endl;

cout<< "Ore: "; cin>>c2.ora;
cout<< "Minute: "; cin>>c2.min;
cout<< "Secunde : "; cin>>c2.sec;
sum.ora=c1.ora+c2.ora;
sum.min=c1.min+c2.min;
sum.sec=c1.sec+c2.sec;
if(sum.sec>60){
sum.min++;
sum.sec -=60;
}
if(sum.min>60){
sum.ora++;
sum.min -=60;
}
if(c1.sec+c1.min*60+ c1.ora*3600> c2.sec+c2.min*60+ c2.ora*3600){

dif.sec=c1.sec-c2.sec;
dif.min=c1.min-c2.min;
dif.ora=c1.ora-c2.ora;
}else
{
dif.sec=c2.sec-c1.sec;
-12-
dif.min=c2.min-c1.min;
dif.ora=c2.ora-c1.ora;
}
if(dif.sec<0){
dif.min--;
dif.sec+=60;
}
if(dif.min<0){
dif.ora--;
dif.min+=60;
cout<<"Ora 1: "<<endl;
cout<<c1.ora<<":"<<c1.min<<":"<<c1.sec<<endl;
cout<<"Ora 2: "<<endl;
cout<<c2.ora<<":"<<c2.min<<":"<<c2.sec<<endl;
cout<<"Suma: "<<endl;
cout<<sum.ora<<":"<<sum.min<<":"<<sum.sec<<endl;
cout<<"Diferenta: "<<endl;
cout<<dif.ora<<":"<<dif.min<<":"<<dif.sec<<endl;
return 0;
}
Ex 4
#include <iostream>
#include <math.h>
struct punct{
int x,y;
} A,B,C;
int main()
{
float latA,latB,latC;
cout<<"Cordonatele puctului A sunt: "<<endl; cin>>A.x>>A.y;
cout<<"Cordonatele puctului B sunt: "<<endl; cin>>B.x>>B.y;
cout<<"Cordonatele puctului C sunt: "<<endl; cin>>C.x>>C.y;
latA =(float) sqrt(pow(A.x-B.x,2) + pow(A.y-B.y,2));

latB =(float) sqrt(pow(B.x-C.x,2) + pow(B.y-C.y,2));
latC =(float) sqrt(pow(C.x-A.x,2) + pow(C.y-A.y,2));
cout<<"Latura A este: "<<latA<<endl;

cout<<"Latura B este: "<<latB<<endl;
cout<<"Latura C este: "<<latC<<endl;
-13-
return 0;
}
Ex5
#include <iostream>
int cmmdc(int a, int b) {

while (b != 0) {
int temp = b;
b = a % b;
a = temp;
}
return a;
}
struct Fractie {
int numarator;
int numitor;
};
void simplificaFractie(Fractie& fractie) {

int d = cmmdc(fractie.numarator, fractie.numitor);
fractie.numarator /= d;
fractie.numitor /= d;
}
Fractie adunaFractii(const Fractie& f1, const Fractie& f2) {

Fractie rezultat;
rezultat.numarator = f1.numarator * f2.numitor + f2.numarator * f1.numitor;
rezultat.numitor = f1.numitor * f2.numitor;
simplificaFractie(rezultat);
return rezultat;
}
Fractie scadeFractii(const Fractie& f1, const Fractie& f2) {

Fractie rezultat;
rezultat.numarator = f1.numarator * f2.numitor - f2.numarator * f1.numitor;
return rezultat;
}
Fractie inmultesteFractii(const Fractie& f1, const Fractie& f2) {

Fractie rezultat;
rezultat.numarator = f1.numarator * f2.numarator;
return rezultat;
}
-14-
Fractie imparteFractii(const Fractie& f1, const Fractie& f2) {
Fractie rezultat;
rezultat.numarator = f1.numarator * f2.numitor;
rezultat.numitor = f1.numitor * f2.numarator;
return rezultat;
}
void afisareFractie(const Fractie& fractie) {

cout << fractie.numarator << "/" << fractie.numitor;
}
int main() {
Fractie f1, f2;
cout << "Introduceti fractia 1 (numarator numitor): ";
cin >> f1.numarator >> f1.numitor;
cout << "Introduceti fractia 2 (numarator numitor): ";
cin >> f2.numarator >> f2.numitor;
Fractie suma = adunaFractii(f1, f2);

Fractie diferenta = scadeFractii(f1, f2);
Fractie produs = inmultesteFractii(f1, f2);
Fractie cat = imparteFractii(f1, f2);
cout << "Ce mai mare fractie: ";

if (f1.numarator * f2.numitor > f2.numarator * f1.numitor)
afisareFractie(f1);
else
afisareFractie(f2);
cout << endl;
cout << "Ce mai mica fractie: ";

if (f1.numarator * f2.numitor < f2.numarator * f1.numitor)
afisareFractie(f1);
else
afisareFractie(f2);
cout << endl;
cout << "Suma fractiilor: ";

afisareFractie(suma);
cout << endl;
cout << "Diferenta fractiilor: ";

afisareFractie(diferenta);
cout << endl;
cout << "Produsul fractiilor: ";

afisareFractie(produs);
cout << endl;
-15-
cout << "Catul fractiilor: ";
afisareFractie(cat);
cout << endl;
return 0;
}
Ex6
#include <iostream>
#include <fstream>
#include <cmath>
#include <algorithm>
struct Punct {
double x, y;
double distantaCentru;
};
double calculeazaDistantaCentru(const Punct& punct) {

return sqrt(punct.x * punct.x + punct.y * punct.y);
}
bool comparareDistanta(const Punct& p1, const Punct& p2) {

return p1.distantaCentru < p2.distantaCentru;
}
int main() {
ifstream fin("puncte.in");
if (!fin) {
cerr << "Nu s-a putut deschide fisierul puncte.in";
return 1;
}
int numarPuncte;
fin >> numarPuncte;
Punct *puncte = new Punct[numarPuncte];

if (!puncte) {
cerr << "Eroare la alocarea memoriei";
return 1;
}
for (int i = 0; i < numarPuncte; ++i) {

fin >> puncte[i].x >> puncte[i].y;
puncte[i].distantaCentru = calculeazaDistantaCentru(puncte[i]);
}
sort(puncte, puncte + numarPuncte, comparareDistanta);

-16-
for (int i = 0; i < numarPuncte; ++i) {
cout << "Punctul " << i + 1 << ": (" << puncte[i].x << ", " << puncte[i].y << ") - distanta
de la centru: " << puncte[i].distantaCentru << endl;
}
delete[] puncte;
return 0;
}
Ex7
#include <iostream>
#include <fstream>
#include <string>
struct Telefon {
string marca;
string culoare;
int anFabricatie;
double pret;
};
void citesteTelefoane(Telefon telefoane[], int& numarTelefoane, const string& numeFisier) {

ifstream fin(numeFisier);
if (!fin) {
cerr << "Nu s-a putut deschide fisierul " << numeFisier << endl;
return;
}
numarTelefoane = 0;
while (fin >> telefoane[numarTelefoane].marca >> telefoane[numarTelefoane].culoare >>
telefoane[numarTelefoane].anFabricatie >> telefoane[numarTelefoane].pret) {
numarTelefoane++;
}
fin.close();
}
void afiseazaTelefoane(Telefon telefoane[], int numarTelefoane) {

for (int i = 0; i < numarTelefoane; ++i) {
cout << "Marca: " << telefoane[i].marca << ", Culoare: " << telefoane[i].culoare << ",
An fabricatie: " << telefoane[i].anFabricatie << ", Pret: " << telefoane[i].pret << endl;
}
}
void afiseazaMaximAn(Telefon telefoane[], int numarTelefoane) {

int maximAn = telefoane[0].anFabricatie;
-17-
maximAn = max(maximAn, telefoane[i].anFabricatie);
}
cout << "Telefoanele cu cel mai mare an de fabricatie:" << endl;

if (telefoane[i].anFabricatie == maximAn) {
}
}
}
void afiseazaMaximPret(Telefon telefoane[], int numarTelefoane) {

double maximPret = telefoane[0].pret;
maximPret = max(maximPret, telefoane[i].pret);
}
cout << "Cele mai scumpe telefoane:" << endl;

if (telefoane[i].pret == maximPret) {
}
}
}
void cautaDupaMarca(Telefon telefoane[], int numarTelefoane, const string& marcaCautata)

{
cout << "Telefoanele cu marca " << marcaCautata << ":" << endl;
if (telefoane[i].marca == marcaCautata) {
}
}
}
void cautaDupaPret(Telefon telefoane[], int numarTelefoane, double pretMinim, double

pretMaxim) {
cout << "Telefoanele cu pret intre " << pretMinim << " si " << pretMaxim << ":" << endl;
if (telefoane[i].pret >= pretMinim && telefoane[i].pret <= pretMaxim) {
}
}
}
void sortareDupaAn(Telefon telefoane[], int numarTelefoane) {

-18-
for (int i = 0; i < numarTelefoane - 1; ++i) {
for (int j = i + 1; j < numarTelefoane; ++j) {
if (telefoane[i].anFabricatie < telefoane[j].anFabricatie) {
swap(telefoane[i], telefoane[j]);
}
}
}
cout << "Telefoanele sortate descrescator dupa anul fabricatiei:" << endl;
afiseazaTelefoane(telefoane, numarTelefoane);
}
void sortareDupaMarca(Telefon telefoane[], int numarTelefoane) {

for (int i = 0; i < numarTelefoane - 1; ++i) {
for (int j = i + 1; j < numarTelefoane; ++j) {
if (telefoane[i].marca > telefoane[j].marca) {
swap(telefoane[i], telefoane[j]);
}
}
}
cout << "Telefoanele sortate crescator dupa marca:" << endl;

}
int main() {
const int MAX_TELEFOANE = 10;
Telefon telefoane[MAX_TELEFOANE];
int numarTelefoane;
string numeFisier = "telefoane.txt";
citesteTelefoane(telefoane, numarTelefoane, numeFisier);
char optiune;
do {
cout << "\nMeniu:\n";
cout << "a) Afisare toate telefoanele\n";
cout << "b) Afisare telefoane cu cel mai mare an\n";
cout << "c) Afisare cele mai scumpe telefoane\n";
cout << "d) Cautare telefoane dupa marca\n";
cout << "e) Cautare telefoane dupa pret\n";
cout << "f) Sortare descrescatoare dupa anul fabricatiei\n";
cout << "g) Sortare crescatoare dupa marca\n";
cout << "x) Iesire din program\n";
cout << "Introduceti optiunea: ";
cin >> optiune;
switch (optiune) {
case 'a':
-19-
break;
case 'b':
afiseazaMaximAn(telefoane, numarTelefoane);
break;
case 'c':
afiseazaMaximPret(telefoane, numarTelefoane);
break;
case 'd':
{
string marcaCautata;
cout << "Introduceti marca cautata: ";
cin >> marcaCautata;
cautaDupaMarca(telefoane, numarTelefoane, marcaCautata);
}
break;
case 'e':
{
double pretMinim, pretMaxim;
cout << "Introduceti pretul minim: ";
cin >> pretMinim;
cout << "Introduceti pretul maxim: ";
cin >> pretMaxim;
cautaDupaPret(telefoane, numarTelefoane, pretMinim, pretMaxim);
}
break;
case 'f':
sortareDupaAn(telefoane, numarTelefoane);
break;
case 'g':
sortareDupaMarca(telefoane, numarTelefoane);
break;
case 'x':
cout << "Iesire din program\n";
break;
default:
cout << "Optiune invalida. Va rugam sa incercati din nou.\n";
}
} while (optiune != 'x');
return 0;
}
-20-
5. Pointeri. Variabile Pointeri.
5.1 Variabile Pointeri.
Ex3p4
#include <iostream>
int main() {
int numarCopiiInitiali = 7;
int *numarCopiiAdaugati = new int;
cout << "Introduceti numarul de copii adaugati de la cele doua scoli: ";
cin >> *numarCopiiAdaugati;
int numarTotalCopii = numarCopiiInitiali + *numarCopiiAdaugati;
cout << "Numarul total de copii care au plecat in excursie este: " << numarTotalCopii << "
copii." << endl;
delete numarCopiiAdaugati;
return 0;
}
Ex6p4
#include <iostream>
int main() {
int n;
cout << "Introduceti numarul initial de mere: ";
cin >> n;
int *primulCopil = &n;
int *alDoileaCopil = &n;
(*primulCopil)--;
(*alDoileaCopil)++;
cout << "Dupa ce primul copil mananca un mar si da unul celui de-al doilea, avem:\n";
cout << "Primul copil: " << *primulCopil << " mere\n";
cout << "Al doilea copil: " << *alDoileaCopil << " mere\n";
return 0;
}
Ex3p10
#include <iostream>
void verificarePredecesorSuccesor(int *numar1, int *numar2) {

if (*numar1 == *numar2 - 1)
cout << "Da";
-21-
else if (*numar1 == *numar2 + 1)
cout << "Da";
else
cout << "Nu";
}
int main() {
int numar1, numar2;
cout << "Introduceți două numere întregi: ";

cin >> numar1 >> numar2;
verificarePredecesorSuccesor(&numar1, &numar2);
return 0;
}
Ex6p10
#include <iostream>
void verificaGreutate(int *greutate1, int *greutate2) {

if (*greutate1 + *greutate2 <= 100) {
cout << "Pot intra ambii copii." << endl;
} else {
cout << "Intra pe rind." << endl;
}
}
int main() {
int greutate1, greutate2;
cout << "Introduceti greutatea primului copil: ";

cin >> greutate1;
cout << "Introduceti greutatea celui de-al doilea copil: ";

cin >> greutate2;
verificaGreutate(&greutate1, &greutate2);
return 0;
}
Ex3p14
#include <iostream>
int main() {
int numar1, numar2;
char operatie;
-22-
cout << "Introduceti primul numar: ";
cin >> numar1;
cout << "Introduceti al doilea numar: ";

cin >> numar2;
cout << "Introduceti operatorul (+ - * / %): ";

cin >> operatie;
int rezultat;
// Pointer la rezultat pentru a permite actualizarea sa în funcție de operatorul introdus

int *ptr_rezultat = &rezultat;
switch (operatie) {
case '+':
*ptr_rezultat = numar1 + numar2;
break;
case '-':
*ptr_rezultat = numar1 - numar2;
break;
case '*':
*ptr_rezultat = numar1 * numar2;
break;
case '/':
if (numar2 != 0)
*ptr_rezultat = numar1 / numar2;
else
cout << "Impartire la zero!" << endl;
break;
case '%':
if (numar2 != 0)
*ptr_rezultat = numar1 % numar2;
else
cout << "Impartire la zero!" << endl;
break;
default:
cout << "Operator necunoscut! Rezultatul este 0." << endl;
*ptr_rezultat = 0;
break;
}
// Afisarea rezultatului
if (operatie == '/' || operatie == '%') {
if (numar2 != 0)
cout << numar1 << " " << operatie << " " << numar2 << " = " << *ptr_rezultat << endl;
} else {
cout << numar1 << " " << operatie << " " << numar2 << " = " << *ptr_rezultat << endl;
}
-23-
return 0;
}
Ex4p16
#include <iostream>
void afisareDivizori(int numar) {

cout << "Divizorii numarului " << numar << " sunt: ";
for (int i = 1; i <= numar; ++i) {
if (numar % i == 0) {
cout << i << " ";
}
}
cout << endl;
}
int main() {
int numar;
cout << "Introduceti un numar intreg pozitiv: ";

cin >> numar;
// Pointer la numar pentru a permite pasarea valorii prin referinta

int *ptr_numar = &numar;
afisareDivizori(*ptr_numar);
return 0;
}
5.2 Pointeri și tablouri.

Ex2p22
#include <iostream>
int main() {
int n;
cout << "Introduceti dimensiunea vectorului (n < 1000): ";

cin >> n;
// Alocare dinamică a vectorului

int *vector = new int[n];
-24-
// Citirea elementelor vectorului
cout << "Introduceti elementele vectorului:\n";
for (int i = 0; i < n; ++i) {
cout << "Elementul " << i + 1 << ": ";
cin >> vector[i];
}
// Afisarea elementelor initiale

cout << "Elementele initiale ale vectorului sunt:\n";
for (int i = 0; i < n; ++i) {
cout << vector[i] << " ";
}
cout << endl;
// Mărirea fiecărui element al vectorului cu 10

for (int i = 0; i < n; ++i) {
vector[i] += 10;
}
// Afisarea elementelor modificate

cout << "Elementele vectorului dupa adaugarea valorii 10 la fiecare element:\n";
for (int i = 0; i < n; ++i) {
cout << vector[i] << " ";
}
cout << endl;
// Eliberarea memoriei alocate dinamic pentru vector

delete[] vector;
return 0;
}
Ex5p25
#include <iostream>
int main() {
int n, m;
cout << "Introduceti numarul de linii: ";

cin >> n;
cout << "Introduceti numarul de coloane: ";
cin >> m;
// Alocare dinamică a tabloului bidimensional

int **tablou = new int*[n];
for (int i = 0; i < n; ++i) {
tablou[i] = new int[m];
}
-25-
// Citirea elementelor tabloului bidimensional
cout << "Introduceti elementele tabloului:\n";
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << "Elementul [" << i << "][" << j << "]: ";
cin >> tablou[i][j];
}
}
// Afisarea elementelor initiale ale tabloului

cout << "Elementele initiale ale tabloului sunt:\n";
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << tablou[i][j] << " ";
}
cout << endl;
}
int linie;
cout << "Introduceti numarul de ordine al liniei pe care doriti sa o modificati: ";
cin >> linie;
// Verificare dacă linia introdusă de utilizator este validă

if (linie >= 0 && linie < n) {
// Mărirea elementelor liniei cu 10
for (int j = 0; j < m; ++j) {
tablou[linie][j] += 10;
}
// Afisarea tabloului dupa modificare

cout << "Elementele tabloului dupa adaugarea valorii 10 la linia " << linie << " sunt:\n";
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << tablou[i][j] << " ";
}
cout << endl;
}
} else {
cout << "Numarul de ordine al liniei introdus nu este valid." << endl;
}
// Eliberarea memoriei alocate dinamic pentru tablou

for (int i = 0; i < n; ++i) {
delete[] tablou[i];
}
delete[] tablou;
return 0;
}
-26-
5.3 Alocarea dinamică a memoriei pentru tablouri. Eliberarea memoriei.

-27-
6. Subprograme.
6.1 Subprograme 1
6.2 Subprograme 2
6.3 Subprograme (parametri de tip tablou)

6.4 Subprograme recursive.

6.5 Subprograme. Particularități în utilizare.

6.5.2 Realizare proiect propriu
-28-
-29-
DECLARAŢIA PRIVIND ASUMAREA RĂSPUNDERII
Subsemnatul, declar pe proprie răspundere că materialele prezentate în

Portofoliu, se referă la propriile activităţi şi realizări, în caz contrar urmând să suport
consecinţele, în conformitate cu legislaţia în vigoare.
Nume, Prenume:
-30-

Portofoliu Eugeniu Ceban1

Încărcat de

Informații document

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

Portofoliu Eugeniu Ceban1

Încărcat de

Drepturi de autor:

Formate disponibile

COLEGIUL UNIVERSITĂȚII TEHNICE A

2.1 În cadrul orelor de teorie

Plasează condiția, codul și execuția de la problemele rezolvate la teorie și din prezentare

2.2 Probleleme rezolvate în cadrul lecției de laborator și tema pentru acasă

12) Fişierul date.in conţine un şir de caractere. De la tastatură se citeşte un şir de

3.1. În cadrul orelor de teorie

se includ toate programele de la ora de teorie + prezentarea de pe classroom

3.2. În cadrul orelor de laborator și tema pentru acasă

se includ toate probleme de la orele de laborator + prezentarea de pe classroom

se includ toate programele de la ora de teorie + prezentarea de pe classroom

4.1.2 În cadrul orelor de laborator și tema pentru acasă

se includ toate probleme de la orele de laborator + prezentarea de pe classroom

4.2 Tablouri de structuri.

se includ toate probleme de la orele de laborator + prezentarea de pe classroom

4.2.2 În cadrul orelor de laborator și tema pentru acasă

cout<<"Date al doilea copil: "<<endl;

cout<<"Date al treilea copil: "<<endl;

varsta1= c1.ziua+c1.luna*30+ (2024-c1.anul)*360;

cout<<"Datele despre a doua variabila "<<endl;

if(c1.ziua+c1.luna*30+ c1.anul*360> c2.ziua+c2.luna*30+ c2.anul*360){

cout<<"Datele despre prima variabila: "<<endl;

cout<<"Datele despre a doua variabila "<<endl;

if(c1.sec+c1.min*60+ c1.ora*3600> c2.sec+c2.min*60+ c2.ora*3600){

latA =(float) sqrt(pow(A.x-B.x,2) + pow(A.y-B.y,2));

cout<<"Latura A este: "<<latA<<endl;

using namespace std;

int cmmdc(int a, int b) {

void simplificaFractie(Fractie& fractie) {

Fractie adunaFractii(const Fractie& f1, const Fractie& f2) {

Fractie scadeFractii(const Fractie& f1, const Fractie& f2) {

Fractie inmultesteFractii(const Fractie& f1, const Fractie& f2) {

void afisareFractie(const Fractie& fractie) {

Fractie suma = adunaFractii(f1, f2);

cout << "Ce mai mare fractie: ";

cout << "Ce mai mica fractie: ";

cout << "Suma fractiilor: ";

cout << "Diferenta fractiilor: ";

cout << "Produsul fractiilor: ";

using namespace std;

double calculeazaDistantaCentru(const Punct& punct) {

bool comparareDistanta(const Punct& p1, const Punct& p2) {

Punct *puncte = new Punct[numarPuncte];

for (int i = 0; i < numarPuncte; ++i) {

sort(puncte, puncte + numarPuncte, comparareDistanta);

using namespace std;

void citesteTelefoane(Telefon telefoane[], int& numarTelefoane, const string& numeFisier) {

void afiseazaTelefoane(Telefon telefoane[], int numarTelefoane) {

void afiseazaMaximAn(Telefon telefoane[], int numarTelefoane) {

cout << "Telefoanele cu cel mai mare an de fabricatie:" << endl;

void afiseazaMaximPret(Telefon telefoane[], int numarTelefoane) {

cout << "Cele mai scumpe telefoane:" << endl;

void cautaDupaMarca(Telefon telefoane[], int numarTelefoane, const string& marcaCautata)

void cautaDupaPret(Telefon telefoane[], int numarTelefoane, double pretMinim, double

void sortareDupaAn(Telefon telefoane[], int numarTelefoane) {

void sortareDupaMarca(Telefon telefoane[], int numarTelefoane) {

cout << "Telefoanele sortate crescator dupa marca:" << endl;

citesteTelefoane(telefoane, numarTelefoane, numeFisier);

int numarTotalCopii = numarCopiiInitiali + *numarCopiiAdaugati;

using namespace std;

void verificarePredecesorSuccesor(int *numar1, int *numar2) {

cout << "Introduceți două numere întregi: ";

using namespace std;

void verificaGreutate(int *greutate1, int *greutate2) {

cout << "Introduceti greutatea primului copil: ";

varsta1= c1.ziua+c1.luna30+ (2024-c1.anul)360;

if(c1.ziua+c1.luna30+ c1.anul360> c2.ziua+c2.luna30+ c2.anul360){

if(c1.sec+c1.min60+ c1.ora3600> c2.sec+c2.min60+ c2.ora3600){

void verificarePredecesorSuccesor(int numar1, int numar2) {

void verificaGreutate(int greutate1, int greutate2) {