rearanjat, și împărțit pe limbaje, redenumit

cpp/coadaBirint/labirint1

@@ -0,0 +1,6 @@
+5 5
+0 -1  0  0  0
+0 -1  0 -1  0
+0  0  0  0  0
+-1 -1 -1  0  0
+0  0  0  0  0

cpp/coadaBirint/labirint2

@@ -0,0 +1,11 @@
+10 10
+0  0  0 -1  0  0 -1  0  0  0
+-1 -1  0 -1  0  0  0  0 -1  0
+0  0  0  0  0 -1 -1  0 -1  0
+0 -1 -1 -1  0  0  0  0 -1  0
+0  0  0 -1 -1 -1  0  0  0  0
+0 -1  0  0  0  0  0 -1 -1  0
+0 -1  0 -1 -1 -1  0  0  0  0
+0  0  0  0  0  0  0 -1 -1  0
+-1 -1 -1 -1 -1  0  0  0  0  0
+0  0  0  0  0  0 -1 -1 -1  0

cpp/coadaBirint/labirint3

@@ -0,0 +1,41 @@
+40 30
+0  0  0 -1  0  0 -1  0  0  0  0  0  0 -1  0  0 -1  0  0  0  0  0  0 -1  0  0 -1  0  0  0
+-1 -1  0 -1  0  0  0  0 -1  0 -1 -1  0 -1  0  0  0  0 -1  0 -1 -1  0 -1  0  0  0  0 -1  0
+0  0  0  0  0 -1 -1  0 -1  0  0  0  0  0 -1 -1  0 -1  0  0  0  0  0  0 -1 -1  0 -1  0  0
+0 -1 -1 -1  0  0  0  0 -1  0  0 -1 -1 -1  0  0  0  0 -1  0  0 -1 -1 -1  0  0  0  0 -1  0
+0  0  0 -1 -1 -1  0  0  0  0  0  0  0 -1 -1 -1  0  0  0  0  0  0  0 -1 -1 -1  0  0  0  0
+0 -1  0  0  0  0  0 -1 -1  0  0 -1  0  0  0  0  0 -1 -1  0  0 -1  0  0  0  0  0 -1 -1  0
+0 -1  0 -1 -1 -1  0  0  0  0  0 -1  0 -1 -1 -1  0  0  0  0  0 -1  0 -1 -1 -1  0  0  0  0
+0  0  0  0  0  0  0 -1 -1  0  0  0  0  0  0  0  0 -1 -1  0  0  0  0  0  0  0  0 -1 -1  0
+-1 -1 -1 -1 -1  0  0  0  0  0 -1 -1 -1 -1 -1  0  0  0  0  0 -1 -1 -1 -1 -1  0  0  0  0  0
+0  0  0  0  0  0 -1 -1 -1  0  0  0  0  0  0  0 -1 -1 -1  0  0  0  0  0  0  0 -1 -1 -1  0
+0  0  0 -1  0  0 -1  0  0  0  0  0  0 -1  0  0 -1  0  0  0  0  0  0 -1  0  0 -1  0  0  0
+-1 -1  0 -1  0  0  0  0 -1  0 -1 -1  0 -1  0  0  0  0 -1  0 -1 -1  0 -1  0  0  0  0 -1  0
+0  0  0  0  0 -1 -1  0 -1  0  0  0  0  0 -1 -1  0 -1  0  0  0  0  0  0 -1 -1  0 -1  0  0
+0 -1 -1 -1  0  0  0  0 -1  0  0 -1 -1 -1  0  0  0  0 -1  0  0 -1 -1 -1  0  0  0  0 -1  0
+0  0  0 -1 -1 -1  0  0  0  0  0  0  0 -1 -1 -1  0  0  0  0  0  0  0 -1 -1 -1  0  0  0  0
+0 -1  0  0  0  0  0 -1 -1  0  0 -1  0  0  0  0  0 -1 -1  0  0 -1  0  0  0  0  0 -1 -1  0
+0 -1  0 -1 -1 -1  0  0  0  0  0 -1  0 -1 -1 -1  0  0  0  0  0 -1  0 -1 -1 -1  0  0  0  0
+0  0  0  0  0  0  0 -1 -1  0  0  0  0  0  0  0  0 -1 -1  0  0  0  0  0  0  0  0 -1 -1  0
+-1 -1 -1 -1 -1  0  0  0  0  0 -1 -1 -1 -1 -1  0  0  0  0  0 -1 -1 -1 -1 -1  0  0  0  0  0
+0  0  0  0  0  0 -1 -1 -1  0  0  0  0  0  0  0 -1 -1 -1  0  0  0  0  0  0  0 -1 -1 -1  0
+0  0  0 -1  0  0 -1  0  0  0  0  0  0 -1  0  0 -1  0  0  0  0  0  0 -1  0  0 -1  0  0  0
+-1 -1  0 -1  0  0  0  0 -1  0 -1 -1  0 -1  0  0  0  0 -1  0 -1 -1  0 -1  0  0  0  0 -1  0
+0  0  0  0  0 -1 -1  0 -1  0  0  0  0  0 -1 -1  0 -1  0  0  0  0  0  0 -1 -1  0 -1  0  0
+0 -1 -1 -1  0  0  0  0 -1  0  0 -1 -1 -1  0  0  0  0 -1  0  0 -1 -1 -1  0  0  0  0 -1  0
+0  0  0 -1 -1 -1  0  0  0  0  0  0  0 -1 -1 -1  0  0  0  0  0  0  0 -1 -1 -1  0  0  0  0
+0 -1  0  0  0  0  0 -1 -1  0  0 -1  0  0  0  0  0 -1 -1  0  0 -1  0  0  0  0  0 -1 -1  0
+0 -1  0 -1 -1 -1  0  0  0  0  0 -1  0 -1 -1 -1  0  0  0  0  0 -1  0 -1 -1 -1  0  0  0  0
+0  0  0  0  0  0  0 -1 -1  0  0  0  0  0  0  0  0 -1 -1  0  0  0  0  0  0  0  0 -1 -1  0
+-1 -1 -1 -1 -1  0  0  0  0  0 -1 -1 -1 -1 -1  0  0  0  0  0 -1 -1 -1 -1 -1  0  0  0  0  0
+0  0  0  0  0  0 -1 -1 -1  0  0  0  0  0  0  0 -1 -1 -1  0  0  0  0  0  0  0 -1 -1 -1  0
+0  0  0 -1  0  0 -1  0  0  0  0  0  0 -1  0  0 -1  0  0  0  0  0  0 -1  0  0 -1  0  0  0
+-1 -1  0 -1  0  0  0  0 -1  0 -1 -1  0 -1  0  0  0  0 -1  0 -1 -1  0 -1  0  0  0  0 -1  0
+0  0  0  0  0 -1 -1  0 -1  0  0  0  0  0 -1 -1  0 -1  0  0  0  0  0  0 -1 -1  0 -1  0  0
+0 -1 -1 -1  0  0  0  0 -1  0  0 -1 -1 -1  0  0  0  0 -1  0  0 -1 -1 -1  0  0  0  0 -1  0
+0  0  0 -1 -1 -1  0  0  0  0  0  0  0 -1 -1 -1  0  0  0  0  0  0  0 -1 -1 -1  0  0  0  0
+0 -1  0  0  0  0  0 -1 -1  0  0 -1  0  0  0  0  0 -1 -1  0  0 -1  0  0  0  0  0 -1 -1  0
+0 -1  0 -1 -1 -1  0  0  0  0  0 -1  0 -1 -1 -1  0  0  0  0  0 -1  0 -1 -1 -1  0  0  0  0
+0  0  0  0  0  0  0 -1 -1  0  0  0  0  0  0  0  0 -1 -1  0  0  0  0  0  0  0  0 -1 -1  0
+-1 -1 -1 -1 -1  0  0  0  0  0 -1 -1 -1 -1 -1  0  0  0  0  0 -1 -1 -1 -1 -1  0  0  0  0  0
+0  0  0  0  0  0 -1 -1 -1  0  0  0  0  0  0  0 -1 -1 -1  0  0  0  0  0  0  0 -1 -1 -1  0

cpp/coadaBirint/labirint3.cpp

@@ -0,0 +1,177 @@
+#include <iostream>
+#include <fstream>
+#include <string>
+
+struct nodInCoada {
+    int x, y;
+};
+
+struct coadaCirculara {
+    nodInCoada* coada;
+    int fata;
+    int spate;
+    int marime;
+    
+    coadaCirculara(int m) {
+        marime = m;
+        coada = new nodInCoada[marime];
+        fata = -1;
+        spate = -1;
+    }
+    
+    void adauga(int x, int y) {
+        if (fata == -1) {
+            fata = 0;
+        }
+        spate = (spate + 1) % marime;
+        coada[spate].x = x;
+        coada[spate].y = y;
+    }
+    
+    nodInCoada scoate() {
+        nodInCoada value = coada[fata];
+        if (fata == spate) {
+            fata = -1;
+            spate = -1;
+        } else {
+            fata = (fata + 1) % marime;
+        }
+        return value;
+    }
+    
+    bool eGol() {
+        return fata == -1;
+    }
+};
+
+void citesteLabirint(std::string numeLabirint,
+                            int**& labirint, int& n, int& m) {
+    std::ifstream fisier(numeLabirint);
+    fisier >> n >> m;
+    labirint = new int*[n];
+    for (int i = 0; i < n; i++) {
+        labirint[i] = new int[m];
+    }
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < m; j++) {
+            fisier >> labirint[i][j];
+        }
+    }
+}
+
+bool** creazaIstoric(int n, int m) {
+    bool** aFost = new bool*[n];
+    for (int i = 0; i < n; i++) {
+        aFost[i] = new bool[m];
+        for (int j = 0; j < m; j++) {
+            aFost[i][j] = false;
+        }
+    }
+    return aFost;
+}
+//scrie o matrice cu FALSE pentru a tine minte unde
+//a mai fost soarecele
+
+void stergeIstoric(bool** istoric, int n) {
+    for (int i = 0; i < n; i++) {
+        delete[] istoric[i];
+    }
+    delete[] istoric;
+}
+//dealoca memorie matrice bool
+
+void stergeMatriceInt(int** matrice, int n) {
+    for (int i = 0; i < n; i++) {
+        delete[] matrice[i];
+    }
+    delete[] matrice;
+}
+//dealoca memorie matrice int
+
+void laBFSirint(int** labirint, int xPlecare, int yPlecare, 
+                                int xBranza, int yBranza,
+                                int n, int m) {
+    coadaCirculara q(n * m);
+    bool** trecut = creazaIstoric(n, m);
+    
+    int** xAnterior = new int*[n];
+    int** yAnterior = new int*[n];
+    for (int i = 0; i < n; i++) {
+        xAnterior[i] = new int[m];
+        yAnterior[i] = new int[m];
+        for (int j = 0; j < m; j++) {
+            xAnterior[i][j] = -1;
+            yAnterior[i][j] = -1;
+        }
+    }
+
+    int dx[] = {-1, 1, 0, 0};
+    int dy[] = {0, 0, -1, 1};
+    //direcții de mișcare sus, jos, stânga, dreapta în 2 vectori.
+
+    //Algoritm de cautare in latime.
+    q.adauga(xPlecare, yPlecare);
+    trecut[xPlecare][yPlecare] = true;
+
+    while (!q.eGol()) {
+        nodInCoada curent = q.scoate();
+        int x = curent.x;
+        int y = curent.y;
+
+        if (x == xBranza && y == yBranza) {
+            std::cout << "Soarecu a pus gheara pe branza!\n";
+            std::cout << "Inainte sa ajunga la branza el a fost prin: ";
+            int xCurent = xBranza, yCurent = yBranza;
+            while (xCurent != -1 && yCurent != -1) {
+                std::cout << "(" << xCurent << "," << yCurent << ") ";
+                int xParinte = xAnterior[xCurent][yCurent];
+                int yParinte = yAnterior[xCurent][yCurent];
+                xCurent = xParinte;
+                yCurent = yParinte;
+            }
+            std::cout << "\n";
+            return;
+        } //Soarecu se opreste cand da de branza
+
+        //Daca nu a gasit branza cauta in pozitiile vecine
+        for (int i = 0; i < 4; i++) {
+            int xVecin = x + dx[i];
+            int yVecin = y + dy[i];
+            
+            if (xVecin >= 0 && xVecin < n && yVecin >= 0 && yVecin < m &&
+                !trecut[xVecin][yVecin] && labirint[xVecin][yVecin] != -1) {
+                
+                q.adauga(xVecin, yVecin);
+                trecut[xVecin][yVecin] = true;
+                xAnterior[xVecin][yVecin] = x;
+                yAnterior[xVecin][yVecin] = y;
+            }
+        }
+    }
+    
+    std::cout << "Branza este o minciuna! Soarecele este inchis :( \n";
+
+    //Goleste memorie!
+    stergeIstoric(trecut, n);
+    for (int i = 0; i < n; i++) {
+        delete[] xAnterior[i];
+        delete[] yAnterior[i];
+    }
+    delete[] xAnterior;
+    delete[] yAnterior;
+    delete[] q.coada;
+}
+
+int main() {
+    int** labirint;
+    int n, m;
+    std::string harta;
+    std::cout << "Selectați labirintul (scrie numele fisierului): ";
+    getline(std::cin, harta);
+    citesteLabirint(harta, labirint, n, m);
+    laBFSirint(labirint, 0, 0, n-1, m-1, n, m);
+    //am ales conltul diametral opus punctului de plecare,
+    //dar ambele pot fi arbitrare
+    stergeMatriceInt(labirint, n);
+    return 0;
+}

cpp/coadaBirint/labirint4

@@ -0,0 +1,4 @@
+3 4
+0 -1 -1 0
+-1 -1 0 0
+-1 0 0 0

cpp/elimSumMax.cpp

@@ -0,0 +1,155 @@
+// 3. Metoda Greedy (2 pct)
+// Se dau trei vectori v1, v2 și v3, fiecare conținând numere întregi pozitive, 
+// din care se pot elimina elemente doar de la începutul fiecărui vector 
+// (primul element curent).
+// Să se găsească suma maximă posibilă care poate fi obținută astfel încât suma
+// elementelor rămase în fiecare dintre cei trei vectori să fie egală.
+// Exemplu:
+// v1: {3, 2, 1, 1, 1} (Suma totală: 8)
+// v2: {4, 3, 2} (Suma totală: 9)
+// v3: {1, 1, 4, 1} (Suma totală: 7)
+
+// Output: Suma maximă egală este 5.
+// (Explicație: Din v1 eliminăm 3; din v2 eliminăm 4; din v3 eliminăm 1 și 1.
+// Toți vectorii rămân cu suma 5.)
+
+#include<iostream>
+#include<vector>
+
+void eliminaFata(std::vector<int>& v) {
+    if (v.empty()) 
+        return;
+    std::vector<int> aux;
+    for (int i = 1; i < v.size(); i++) {
+        aux.push_back(v[i]);
+    }
+    v = aux;
+}
+
+int sumaVector(std::vector<int> v){
+    int suma = 0;
+    for (int i = 0; i<v.size(); i++) {
+        suma += v[i]; 
+    }
+    return suma;
+}
+
+void scriereVector(std::vector<int>& v){
+    int n;
+    std::cout << "lungime vector: ";
+    std::cin >> n;
+    std::cout << "scrie vector: ";
+    for (int i = 0; i < n; i++) {
+        int el;
+        std::cin >> el;
+        v.push_back(el);
+    }
+}
+
+void afisareVector(std::vector<int>& v){
+    for (int i = 0; i < v.size(); i++) {
+        std::cout << v[i] << " ";
+    }
+}
+
+int lungimeMaximaDinTrei(std::vector<int>& v1, std::vector<int>& v2, std::vector<int>& v3){
+    if(v1.size() > v2.size() && v1.size() > v3.size())
+        return v1.size();
+    else if (v2.size() > v1.size() && v2.size() > v3.size())
+        return v2.size();
+    else if (v3.size() > v1.size() && v3.size() > v2.size())
+        return v3.size();
+    else
+        return v1.size(); //sunt egali in lungime
+}
+
+int gasesteCmmElComIntreRanduri(int**& mat, int& n) {
+    int CmmC = -1; 
+    for (int i = 0; i<n; i++) {
+        int suma = mat[0][i];
+        bool gasitRandDoi = false;
+        bool gasitRandTrei = false;
+        for (int j = 0; j<n; j++) {
+            if (mat[1][j] == suma) {
+                gasitRandDoi = true;
+                break; 
+            }
+        }
+        for (int k = 0; k <n; k++) {
+            if (mat[2][k] == suma) {
+                gasitRandTrei = true;
+                break;
+            }
+        }
+        if (gasitRandDoi && gasitRandTrei) {
+            if (suma > CmmC) { 
+                CmmC = suma;
+            }
+        }
+    }
+    return CmmC;
+}
+
+int main(){
+    std::vector<int> v1;
+    std::vector<int> v2;
+    std::vector<int> v3;
+    scriereVector(v1);
+    scriereVector(v2);
+    scriereVector(v3);
+    int n = lungimeMaximaDinTrei(v1, v2, v3); 
+    int** mat = new int*[3];
+    for (int i = 0; i < 3; i++) {
+        mat[i] = new int[n];
+        for (int j = 0; j < n; j++) {
+            mat[i][j] = 0;
+        }
+    }
+    
+    for (int i = 0; i < 3; i++) {
+        for (int j = 0; j < n; j++) {
+            if (i==0 && j<v1.size()) {
+                mat[i][j] = v1[j];
+            }
+            if (i==1 && j<v2.size()) {
+                mat[i][j] = v2[j];
+            }        
+            if (i==2 && j<v3.size()) {
+                mat[i][j] = v3[j];
+            }        
+        }
+    }
+
+    for (int i = 0; i < 3; i++) {
+        int suma = 0;
+        for (int j = n-1; j >= 0; j--) {
+            suma=suma+mat[i][j]; 
+            mat[i][j] = suma;
+        }
+    }
+
+    int sumaGreedy = gasesteCmmElComIntreRanduri(mat, n);
+
+    if (sumaGreedy > 0) {
+        std::cout << "Cea mai mare suma este: " << sumaGreedy << std::endl;
+        std::cout << "Uita-te în matrice de cate ori ar trebui" << std::endl;
+        std::cout << "sa ruleze funcția cu care elimin primul" << std::endl;
+        std::cout << "element al fiecărui vector." << std::endl;
+    }
+    else {
+        std::cout << "Nu există val sumă comună" << std::endl;
+    }
+    for (int i = 0; i < 3; i++) {
+        for(int j = 0; j < n; j++){
+            std::cout << mat[i][j] << " ";
+        }
+        std::cout << std::endl;
+    }
+
+    for (int i = 0; i < 3; i++) {
+        delete[] mat[i];
+    }
+    delete[] mat;
+
+    return 0;
+}

cpp/mergeSort.cpp

@@ -0,0 +1,81 @@
+// 1. Alocare Dinamică și Sortare (2 pct)
+// Să se citească de la tastatură un număr natural n și un vector de n elemente întregi,
+// alocat dinamic. Să se implementeze un algoritm de sortare eficient (QuickSort sau
+// MergeSort) pentru a ordona crescător elementele vectorului. La final, se va afișa
+// vectorul sortat și se va elibera memoria. Memoria se va aloca și dealoca manual,
+// fără a se utiliza STL.
+
+#include<iostream>
+
+int* faceVector(int& n){
+    std::cin >> n;
+    int* vec = new int[n];
+    for (int i = 0; i < n; i++){
+        std::cin >> vec[i];
+    }
+    return vec;
+}
+
+void afisareVector(int* vec, int n){
+    for (int i = 0; i < n; i++) {
+        std::cout << vec[i] << " "; 
+    }
+    std::cout<<std::endl;
+}
+
+void interclasare (int* vec, int st, int dr){
+    int i = st;
+    int mij = (st + dr)/2;
+    int j = mij + 1;
+    int k = 0;
+    int n = dr-st+1;
+    int* aux = new int[n];
+    while (i <= mij && j <= dr){
+        if (vec[i] < vec[j]) {
+            aux[k]=vec[i];
+            k++;
+            i++;
+        }
+        else {
+            aux[k]=vec[j];
+            k++;
+            j++;
+        }
+    }
+    for (; i <= mij; i++) {
+        aux[k]=vec[i];
+        k++;
+    }
+    for (; j<=dr; j++) {
+        aux[k]=vec[j];
+        k++;
+    }
+    for (int f = 0; f < n; f++) {
+        vec[st+f]=aux[f];
+    }
+    delete[] aux;
+}
+
+void mergeSort(int* vec, int st, int dr){
+    if(st >= dr){
+        return;
+    }
+    else{
+        int mij = (st+dr)/2;
+        mergeSort(vec,st, mij);
+        mergeSort(vec,mij+1, dr);
+        interclasare(vec, st,dr);
+    }
+}
+
+int main(){
+
+    int n;
+    int* vector;
+    vector = faceVector(n);
+    afisareVector(vector, n);
+    mergeSort(vector, 0, n-1);
+    afisareVector(vector, n);
+    delete[] vector;
+    return 0;
+}

cpp/paranteze.cpp

@@ -0,0 +1,33 @@
+#include<iostream>
+#include<stack>
+
+int main(){
+    std::string paranteze;
+    std::stack<char> stiva;
+    std::cout <<"sir de paranteze = ";
+    std::cin >> paranteze;
+    int ok=1;
+    for (int i = 0; i<paranteze.size(); i++) {
+        if(paranteze[i] == '('){
+            stiva.push('(');
+        }
+        else{
+            if (paranteze[i] == ')'){
+                if(!stiva.empty()){
+                    stiva.pop();
+                }
+                else{
+                    ok=0;
+                    break;
+                }
+            }
+        }
+    } 
+    if(ok && stiva.empty()){
+        std::cout << "((((((((e bun șirul))))))))";
+    }
+    else{
+        std::cout << "nu e bun șirul, codul tău în Lisp e stricat.";
+    }
+    return 0;
+};

cpp/stack_paranteze.cpp

@@ -1,8 +1,3 @@
-//Se dă un şir de paranteze deschise şi închise de tip (, ), [, ], {, }. Să se
-//verifice dacă şirul este corect. Pentru rezolvare folosiţi o stivă de catactere
-//implementare proprie sau std::stack. Exemplu: şirul [()()] este corect, şirul
-//([]) nu este corect, şirul ()]( nu este corect.
-//
 #include<iostream>
 #include<stack>
 
@@ -16,14 +11,19 @@ int main(){
     
     for (int i = 0; i < n; i++) {
         // {[(
-        if(i + 2 < n && paranteze[i] == '{' && paranteze[i+1] == '[' && paranteze[i+2] == '('){
+        if(i + 2 < n
+                && paranteze[i] == '{'
+                && paranteze[i+1] == '['
+                && paranteze[i+2] == '('){
             stiva.push('{');
             stiva.push('[');
             stiva.push('(');
             i += 2;
         }
         // [(
-        else if(i + 1 < n && paranteze[i] == '[' && paranteze[i+1] == '(') {
+        else if(i + 1 < n
+                && paranteze[i] == '['
+                && paranteze[i+1] == '(') {
             stiva.push('[');
             stiva.push('(');
             i += 1;
@@ -33,8 +33,11 @@ int main(){
             stiva.push('(');
         }
         // )]}
-        else if(i + 2 < n && paranteze[i] == ')' && paranteze[i+1] == ']' && paranteze[i+2] == '}'){
+        else if(i + 2 < n
-            if(stiva.size() >= 3){
+                && paranteze[i] == ')'
+                && paranteze[i+1] == ']'
+                && paranteze[i+2] == '}'){
+            if(stiva.size() >= 3 && stiva.top() == '('){
                 stiva.pop();
                 stiva.pop();
                 stiva.pop();
@@ -47,8 +50,10 @@ int main(){
             }
         }
         // )]
-        else if(i + 1 < n && paranteze[i] == ')' && paranteze[i+1] == ']') {
+        else if(i + 1 < n
-            if(stiva.size() >= 2){
+                && paranteze[i] == ')'
+                && paranteze[i+1] == ']') {
+            if(stiva.size() >= 2 && stiva.top() == '('){
                 stiva.pop();
                 stiva.pop();
                 i += 1;
@@ -61,7 +66,7 @@ int main(){
         }
         // )
         else if(paranteze[i] == ')'){
-            if(!stiva.empty()){
+            if(!stiva.empty() && stiva.top() == '('){
                 stiva.pop();
             }
             else{
@@ -70,6 +75,28 @@ int main(){
                 break;
             }
         }
+        // ]
+        else if(paranteze[i] == ']'){
+            if(!stiva.empty() && stiva.top() == '['){
+                stiva.pop();
+            }
+            else{
+                std::cout << "nu sunt închise ] \n";
+                ok = false;
+                break;
+            }
+        }
+        // }
+        else if(paranteze[i] == '}'){
+            if(!stiva.empty() && stiva.top() == '{'){
+                stiva.pop();
+            }
+            else{
+                std::cout << "nu sunt închise } \n";
+                ok = false;
+                break;
+            }
+        }
         else{
             std::cout << "Caracter invalid sau ordine gresita\n";
             ok = false;
@@ -78,10 +105,10 @@ int main(){
     }
     
     if(ok && stiva.empty()){
-        std::cout << "e bun sirul";
+        std::cout << "e bun sirul \n";
     }
     else if(ok){
-        std::cout << "paranteze neînchise";
+        std::cout << "paranteze neînchise \n";
     }
     
     return 0;

cpp/triPascal.cpp

@@ -0,0 +1,51 @@
+#include <iostream>
+
+// Programare Dinamică (2 pct)
+// Să se genereze primele n rânduri ale Triunghiului lui Pascal. 
+// Într-un Triunghi Pascal, fiecare număr este suma celor două 
+// numere aflate direct deasupra lui. Soluția trebuie să fie
+//  de complexitate de timp O(n2).
+// Exemplu pentru n = 4:
+// 1
+// 1 1
+// 1 2 1
+// 1 3 3 1
+//==============================================================================
+
+void scoatePascal(int n) {
+    int** pascalT = new int*[n];
+    for (int i = 0; i < n; i++) {
+        pascalT[i] = new int[i];
+    }
+
+    for (int i = 0; i < n; i++) {
+        pascalT[i][0] = 1;
+        pascalT[i][i] = 1;
+        for (int j = 1; j < i; j++) {
+            pascalT[i][j] = pascalT[i-1][j-1] + pascalT[i-1][j];
+        }
+    }
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j <= i; j++) {
+            std::cout << pascalT[i][j] << " ";
+        }
+        std::cout << std::endl;
+    }
+
+    for (int i = 0; i < 3; i++) {
+        delete pascalT[i];
+    }
+    delete[] pascalT;
+}
+
+int main() {
+    int n;
+    std::cout << "Introduceți numărul de rânduri: ";
+    std::cin >> n;
+    if (n > 0 && n <35) {
+        scoatePascal(n);
+    } else {
+        std::cout << "Numărul de rânduri trebuie să pozitiv sau mai mic decat 35."<< std::endl;
+    }
+    return 0;
+}

cpp/xlanmodDei.cpp

@@ -0,0 +1,61 @@
+// 2. Divide et Impera (2 pct)
+// Se dau trei numere întregi x, n și M. 
+// Să se calculeze eficient valoarea expresiei x^n % M folosind 
+// metoda Divide et Impera. Algoritmul trebuie să aibă o complexitate 
+// de O(log n). Atenție la gestionarea overflow-ului în timpul înmulțirilor.
+// Exemplu:
+// • Input: x = 2, n = 10, M = 1000
+// • Output: 1024 (mod 1000) = 24
+// • Input: x = 4, n = 13, M = 497
+// • Output: 67108864 (mod 497) = 445
+
+#include<iostream>
+
+int putereMoo(int b, int e, int M){
+    int rezultat = 1;
+    b = b-(b/M)*M; //b = b%M
+    while (e > 0 && M!=0){ 
+        if (e % 2 == 1){ 
+            int aux1 = rezultat*b; 
+            rezultat = aux1-(aux1/M)*M;
+        }
+        e = e/2; 
+        int aux2 = b*b;
+        b = aux2-(aux2/M)*M; 
+    }
+    return rezultat;
+}
+
+int putere(int b, int e){
+    if (e == 0) {
+        return 1;
+    }
+    else if (e == 1) {
+        return b;
+    }
+    else if (e % 2 == 0) {
+        return putere(b, e/2) * putere(b, e/2);
+    }
+    else return putere(b,e/2+1) * putere(b,e/2);
+    // complexitate O(n) pentru ca apeleaza functia de doua ori per nivel, si functia 
+    // imparte e in 2 dar fiind apelata de doua ori e de fapt 2 la puterea log in baza
+    // 2 din n, deci O(n).
+}  
+
+int putereMod(int x, int n, int M){
+    return putere(x,n) % M; // O(1)
+}
+
+
+int main(){
+    int x,n,M;
+    std::cin >> x;
+    std::cin >> n;
+    std::cin >> M;
+    int rezultat;
+    rezultat = putereMod(x, n, M);
+    std::cout << rezultat << std::endl;
+    rezultat = putereMoo(x,n,M);
+    std::cout << rezultat << std::endl;
+    return 0;
+}

tema_1/file

@@ -1 +0,0 @@
-

tema_3/etaj.cpp

@@ -1,6 +0,0 @@
-//Un anumit etaj al unei clădiri este reprezentat schematic sub forma unei matrice
-//ce conţine valorile -1 şi 0, unde -1 reprezintă zid şi 0 reprezintă spaţiu
-//liber. Pereţii sunt de grosime 1 şi uşile nu sunt marcate (se consideră tot
-//perete). Care perete poate fi dărâmat (o poziţie maractă cu -1 se va marca
-//cu 0) a. î. să se obţină o încăpere de suprafaţă maximă? Evitaţi utilizarea
-//recursivităţii. Puteti folosi queue din C++.

tema_3/labirint.cpp

@@ -1,5 +0,0 @@
-// 12. Se consideră un labirint reprezentat printr-o matrice în care zidurile sunt marcate
-// prin −1 şi drumurile prin 0. În labirint se află un şoricel pe poziţia (x0 , y0 )
-// şi o bucată de brânză pe poziţia (x1 , y1 ). Să se găsească un drum (de preferinţă
-// de lungime minimă) de la şoricel la brânză. Nu utilizaţi recursivitate! Utilizaţi
-// o coadă. Puteti folosi queue din C++.