Centrul de Excelenta

In Informatică si Tehnologii Informationale

Disciplina: Programarea calculatoarelor

Lucrare de studiu individuală nr.1
Tema: Elaborarea programelor destinate prelucrarii structurilor dinamice de date

A efectuat: Ceban Ion

A verificat: Dovgani L.

Grupa: R - 1821

Nota:

0
 Chisinau – 2019

Cuprins:

1. Enuntul problemei:.........................................................................................................................................2
2. Schitarea algoritmului programului :.............................................................................................................2
3. Listingul programului:...................................................................................................................................2
4. Teste program:................................................................................................................................................6
5. Prezentarea solutiilor programului:................................................................................................................6
6. Concluzie:......................................................................................................................................................8
7. Webografie:....................................................................................................................................................8

1
Scopul lucrării: De elaborat algoritmul și de creat un program, în limbajul de programare C++ conform
sarcinilor.

1. Enuntul problemei:
Fie P si Q doua polinoame, de gradul N cu coeficienti, ce vor fi memorati in doua liste liniare. Sa se obtina
in lista coeficietilor lui P, coeficientii polinomului P+Q, apoi lista Q sa se distruga.

2. Schitarea algoritmului programului :

Se introduce variabilele de la tastatura->se citesc variabilele->se afișează rezultatul, utilizând algoritumul:
Parcurgerea polinomului->bool isConstant = true; // Primul lucru pe care il citim intr-o ecuatie trebuie sa fie
un coefficient->if (isConstant && isNumber(it)) { // Daca e coeficient si e numar modificam variabila asta
constant = constant * 10 + (it - '0');->Daca nu e coefictient sau nu e numar inseamna ca nu ne mai uitam la
un coefficient->if (it == '+' || it == '-') // Ar putea sa fie '+' sau '-', ceea ce inseamna ca vom parsa din nou o
constanta->if (!isLetter(it)) // Daca nu avem o litera inseamna ca e probabil ca dupa sa avem o putere->Daca
avem o litera adaugam in lista coeficientul gasit pana acum->La sfarsit e posibil sa mai avem un coeficient.

3. Listingul programului:
#include <iostream>
#include <string>

struct Node_t
{
int info;
Node_t* next;
};

constexpr bool isNumber(char c)

{
return c >= '0' && c <= '9';
}

constexpr bool isLetter(char c)

{
return (c >= 'a' && c <= 'z') ||
(c >= 'A' && c <= 'Z');
}

// Parcurgerea polinomului
Node_t* getConstants(const std::string& equation)
{
Node_t* list = nullptr;
bool isConstant = true; // Primul lucru pe care il citim intr-o
ecuatie trebuie sa fie un coeficient
bool isPower = false;

int constant = 0;

2
 for (const auto it : equation)
{
if (isConstant && isNumber(it))
{ // Daca e coeficient si e numar modificam variabila asta
constant = constant * 10 + (it - '0');
}
else
{ // Daca nu e coefictient sau nu e numar inseamna ca nu ne mai
uitam la un coeficient
isConstant = false;

if (it == '+' || it == '-') // Ar putea sa fie '+' sau '-',

ceea ce inseamna ca vom parsa din nou o constanta
{
constant = 0;
isConstant = true;
isPower = false;
}
else
{
if (!isLetter(it)) // Daca nu avem o litera inseamna ca
e probabil ca dupa sa avem o putere
{
isPower = true;
}
else
{ // Daca avem o litera adaugam in lista coeficientul
gasit pana acum
if (list)
{
Node_t* nextNode = new Node_t;
nextNode->info = constant;
nextNode->next = list;
list = nextNode;
}
else
{
list = new Node_t;
list->info = constant;
list->next = nullptr;
}
}
}
}
}
// La sfarsit e posibil sa mai avem un coeficient
if (list && !isPower)
{
Node_t* nextNode = new Node_t;
nextNode->info = constant;
nextNode->next = list;
list = nextNode;

3
 }
else if (!isPower)
{
list = new Node_t;
list->info = constant;
list->next = nullptr;
}
return list;
}

int main()
{
std::string P, Q;
std::cout << "Care este primul polinom?\n";
std::getline(std::cin, P);
std::cout << "Care este al doilea polinom?\n";
std::getline(std::cin, Q);
std::cout << "P = " << P << "\nQ = " << Q;
Node_t* PConstants = getConstants(P);
Node_t* QConstants = getConstants(Q);

Node_t* startP = PConstants;

Node_t* startQ = QConstants;
while (PConstants && QConstants)
{
PConstants->info = PConstants->info + QConstants->info;
PConstants = PConstants->next;
QConstants = QConstants->next;
}
std::cout << "\nSuma coeficientilor:";

while (startP)
{
std::cout << startP->info << ' ';
startP = startP->next;
}

while (startQ)
{
Node_t* nextNode = startQ->next;
delete startQ;
startQ = nextNode;
}
}

4. Teste program:

4
5. Prezentarea solutiilor programului:
Struct:
Struct este o structura de date care iti permite sa grupezi mai multe elemente sub o singura umbrela. Aceste
elemente sunt denumite „membrii” si pot avea tipuri diferite.

Int:
De exemplu tipul întreg (int) este definit prin:
- mulţimea valorilor reprezentând numere întregi (între -32768 şi 32767)
- mulţimea operatorilor : +, -, *, /, %
- mulţimea restricţiilor: pentru operatorul / împărţitorul nu poate fi 0, etc.
5
 constexpr bool:
Folosind-o, putem crea variabile, functii si chiar obiecte care vor fi calculate în faza de compilare. Acest
lucru este convenabil, deoarece inainte, trebuia sa utilizam sabloane pentru astfel de scopuri.

Bool:
Tipul boolean sau tipul de dată logic este tipul ce are două valori: true şi false.
Acest tip este folosit în contextele booleene, acolo unde expresia este evaluată* la true sau false. De
exemplu, în condiţia de la if sau while.
O variabilă de tip bool se declară normal, ca orice variabilă.

Else:
Sa presupunem ca doriti sa executati o instructiune atunci când o conditie este TRUE si o alta instructiune
când conditia este FALSE. Instructiunea else va permite sa procedati astfel, dupa cum urmeaza:

If(conditie) {
Instructiune(1);
Instructiune(2);
..................
}
else {
Instructiune(3);
Instructiune(4);
..................
}

While:
Instrucţiunea while îşi inserează în mod repetat în fluxul de execuţie instrucţiunea sa corp,
atât timp cât expresia-test este adevarată (are o valoare nenulă).
6. Concluzie:
Code::Blocks este un IDE performant, gratuit, cross-platform si foarte adaptabil la necesitatile
dezvoltatorului. Mi-a placut foarte mult sa lucrez cu solutia constexpr bool, deoarece putem crea variabile,
functii si chiar obiecte care vor fi calculate în faza de compilare. Acest lucru este convenabil, deoarece
inainte, trebuia sa utilizam sabloane pentru astfel de scopuri si imi pare bine ca am dus acest program pana
la capat, fara intreruperi grave si obstacole. Unele momente erau cazuri putin mai grele, dar in final am
inteles care sunt problemele si le-am rezolvat

7. Webografie:
Resursele de unde m-am inspirit:
http://www.cplusplus.com/forum/
https://www.programmersforum.ru/forumdisplay.php?f=13
https://www.youtube.com/