Temele 1 și 2

17.cpp

@@ -0,0 +1,54 @@
+#include <iostream>
+
+int putere (int b, int e){
+    if (e==0){
+        return 1;
+    }
+    else {
+        if(e % 2 == 0){
+            return putere(b, e/2)*putere(b, e/2);
+        }
+        else {
+            return b*putere(b, e/2)*putere(b, e/2);
+        }
+
+    }
+}
+
+int main(){
+    int n;
+    std::cout << "numarul ales este ";
+    std::cin >> n;
+    if (n<1){
+        std::cout << "numarul ales nu este un numar natural\n";
+        return 0;
+    }
+    if (n>2147483646){
+        std::cout << "numarul natural ales este prea mare pt. int de 32 bit \n";
+        return 0;
+    }
+    int n2=n;
+    int nFinal=0;
+    int lungime=0;
+    while (n2 != 0) {
+        n2 /= 10;
+        lungime++;
+    }
+    for(int i = 0; i<lungime;i++){
+        int valLaPozitie;
+        //Numarul final este o suma de de cifre (valLaPozitie) aflate
+        //la ordinele lor de magnitudine. Logica de mai jos
+        //schimba 0 urile in 1 pentru cifrele alea tinand cont
+        //de ordinul lor de magnitudine. 
+        valLaPozitie = (n/putere(10, i))%10;
+        if (valLaPozitie == 0){
+            nFinal=nFinal+putere(10, i);
+        }
+        else{
+            nFinal = nFinal + valLaPozitie*putere(10, i);
+        }
+    }
+    std::cout << n << " cu toate aparitiile cifrei 0 inlocuite cu cifra 1 este ";
+    std::cout << nFinal << std::endl;
+return 0;
+}

19_final.cpp

@@ -0,0 +1,57 @@
+#include <iostream>
+void divDoiCinci(int nrEl){
+    int nrDivDoi=0, nrDivCinci=0, nrZero=0;
+    bool zeroPrezent = false, nrNegativ=false;
+    for (int i = 0; i<nrEl; i++) {
+        int n, d=2, p;
+        std::cout << "n" << i+1 << "=";
+        std::cin >> n;
+        if(n==0){
+            zeroPrezent=true;
+            i=nrEl;
+            //Sa imi iasa din loop daca orcare dintre factori este 0
+            //produsul atunci e 0 si am un if() mai jos pentru cazul
+            //asta. Desi in enuntul problemei se cerea n natural, deci
+            //as fi putut sa il pun in if()ul care exclude nr. intregi.
+        }
+        else if(n<0){
+            nrNegativ=true;
+            break;
+        }
+        else{
+            while(n!=1)
+            {
+                p = 0;
+                while(n%d==0)
+                {
+                    n = n/d;
+                    p++;
+                }
+            if(p>0){
+                if(d==5){nrDivCinci+=p;}
+                if(d==2){nrDivDoi+=p;}
+            }
+            d++;
+            }
+        }
+    }
+    if(nrNegativ==true){
+        std::cout<<"ultimul factor nu este numar natural. \n";
+    }
+    else if(zeroPrezent==false){
+        if(nrDivDoi>nrDivCinci){nrZero=nrDivCinci;}
+        else {nrZero=nrDivDoi;}
+        std::cout<<"produsul numerelor se sfarseste cu "<< nrZero;
+        std::cout << " zero(uri). \n";
+    }
+    else {
+        std::cout << "produsul numerelor este 0, deci se termină într-un 0. \n";
+    }
+}
+int main(){
+    int nrEl;
+    std::cout << "nr de factori = ";
+    std::cin >> nrEl;
+    divDoiCinci(nrEl);
+    return 0;
+}

20.cpp

@@ -0,0 +1,37 @@
+#include <climits>
+#include <iostream>
+
+int main (){
+    int max1=INT_MIN+1;
+    int max2=INT_MIN;
+    bool continua=true;
+    int i = 0;
+    while(continua){
+        int n;
+        std::cout << "urmatorul numar este ";
+        std::cin >> n;
+        if(n>max1)
+        {
+            max2=max1;
+            max1=n;
+        }
+        else if (n>max2){
+            max2=n;
+        }
+        i++;
+        std::cout << "Mai aveti numere? (1=da, 0=nu)" << std::endl;
+        //aici daca inputul pentru continuare nu e bool se strica
+        //dar nu stiu sa verific tipul variabilei ca sa ii cer
+        //utilizatorului un input valid
+        std::cin >> continua;
+    }
+    if(i==1)
+    {
+        std::cout << "nu ati inserat decat un singur numar, acesta este "<< max1;
+        std::cout << std::endl;
+    }
+    else{
+    std::cout << "primele doua maxime sunt " << max1;
+    std::cout << " respectiv " << max2 << std::endl;
+    }
+}

det3.cpp

@@ -0,0 +1,125 @@
+#include <iostream>
+
+void dDealoc(double** mat, int n) {
+    for (int i = 0; i < n; i++) {
+        delete[] mat[i];
+    }
+    delete[] mat;
+}
+
+void dAfisareMatrice(double** mat, int n) {
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < n; j++) {
+            std::cout << mat[i][j] << " ";
+        }
+        std::cout << std::endl;
+    }
+}
+
+double** minor(double** mat, int n, int xMin, int yMin) {
+    
+    double **minor = new double*[n-1];
+    for (int i = 0; i < n-1; i++) {
+        minor[i] = new double[n-1];
+    }
+
+    int linMinor = 0;
+    for (int i = 0; i < n; i++) {
+        if (i != xMin) {
+            int colMinor = 0;        
+            for (int j = 0; j < n; j++) {
+                if (j != yMin) {
+                    minor[linMinor][colMinor] = mat[i][j];
+                    colMinor++;
+                }
+            }
+            linMinor++;
+        }
+    }
+    return minor;
+}
+
+double detDoi(double** mat) {
+    return mat[0][0] * mat[1][1] - mat[0][1] * mat[1][0];
+}
+
+double determinant(double** mat, int n) {
+    
+    double det = 0;
+
+    if (n == 1) {
+        std::cout << "1x1 nu e o dimensiune pentru care ai nevoie de un program";
+        return mat[0][0];
+    }
+    if (n == 2) {
+        return detDoi(mat);
+    }
+
+    for (int j = 0; j < n; j++) {
+        double** min = minor(mat, n, 0, j);
+        int signatura;
+        if (j % 2 == 0) {
+            signatura = 1;
+        }
+        else {
+            signatura = -1;
+        }
+
+        double deltaMinor = determinant(min, n - 1);
+        
+        det += signatura * mat[0][j] * deltaMinor;
+        dDealoc(min, n - 1); // dealoca minorul
+    }
+  
+    return det;
+}
+
+void minoriRecursivi(double** mat,int n){
+    // functie de verificare care imi scrie minorii cu min[0][j] si signatura 
+    // unii sub altii ca sa pot sa fac calculul de mana mai repede. 
+    
+    if (n == 1 || n==2) {
+        return;
+    }
+
+    for (int j = 0; j < n; j++) {
+        double** min = minor(mat, n, 0, j);
+
+        int signatura;
+        if (j % 2 == 0) {
+            signatura = 1;
+        }
+        else {
+            signatura = -1;
+        }
+
+        std::cout << signatura << " * " << mat[0][j] << std::endl;
+        dAfisareMatrice(min, n - 1);
+        std::cout << std::endl;
+
+        dDealoc(min, n - 1);
+    }
+}
+
+int main() {
+    int n;
+    std::cout << "n = ";
+    std::cin >> n;
+
+    double** a = new double*[n];
+    for (int i = 0; i < n; i++) {
+        a[i] = new double[n];
+        for (int j = 0; j < n; j++) {
+            std::cin >> a[i][j];
+        }
+    }
+
+    //minoriRecursivi(a, n);
+
+    std::cout << "A=\n";
+    dAfisareMatrice(a, n);
+    std::cout << "det(A) = " << determinant(a, n) << std::endl;
+    
+    dDealoc(a, n);
+    return 0;
+}

suma_zonelor_cardinale.cpp

@@ -0,0 +1,40 @@
+#include <iostream>
+int main(){
+    int n, sNord=0, sSud=0, sVest=0, sEast=0;
+    std::cout<<"n="; std::cin >> n;
+    int** a = new int*[n];
+    for (int i = 0; i<n; i++){
+        a[i]=new int[n];
+        for (int j = 0; j<n; j++){
+            std::cin >> a[i][j];
+        }
+    }
+    for (int i = 0; i<n; i++){
+        for (int j = 0; j<n; j++){
+            if(i<j && i+j<n-1){
+                sNord=sNord+a[i][j];
+            }
+            if(i>j && i+j<n-1){
+                sVest=sVest+a[i][j];
+            }
+            if(i>j && i+j>n-1){
+                sSud=sSud+a[i][j];
+            }
+            if(i<j && i+j>n-1){
+                sEast=sEast+a[i][j];
+            }
+        }
+    }
+
+    for (int i = 0; i < n; ++i){
+        delete [] a[i];
+    }
+    delete [] a;
+    
+    std::cout << "suma elementelor din zona cardinală N este " << sNord << std::endl;
+    std::cout << "suma elementelor din zona cardinală S este " << sSud << std::endl; 
+    std::cout << "suma elementelor din zona cardinală V este " << sVest << std::endl;
+    std::cout << "suma elementelor din zona cardinală E este " << sEast << std::endl;  
+
+    return 0;
+}

zigzag4.cpp

@@ -0,0 +1,94 @@
+#include <iostream>
+#include <queue>
+
+std::queue<int> coadaSarpelui;
+
+void citireMatricePatratica(int** mat, int n){
+    for (int i = 0; i < n; i++) {
+        mat[i] = new int[n];
+            for (int j = 0; j<n; j++){
+                std::cin >> mat[i][j];
+        }
+    }
+}
+void afisareMatrice(int** mat, int n) {
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < n; j++) {
+            std::cout << mat[i][j] << " ";
+        }
+        std::cout << std::endl;
+    }
+}
+void taieAltDiag(int** mat, int n) {
+    for (int diagSecIter = 0; diagSecIter < 2 * n - 1; diagSecIter++) {
+        // Loop cu diagonale SV-NE, care sunt 2n-1 la numar
+        
+        bool invers = (diagSecIter % 2 == 1); 
+        
+        // invers == false schimba direcția de la cea initiala, 
+        // SV-NE pt diagonala 1 formata din elementul a_11 la 
+        // directia specifica paritatii diagonalei
+
+        int latime = 0;
+
+        //i+j pe diagonale au val 0 1 2 ... max ... 2 1 0 
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if (i + j == diagSecIter) {
+                    latime++;
+                    // parcurge matricea si creste dimensiunea 
+                    // vectorului care stocheaza temporar matricile
+                    // sau latimea diagonalei in iteratia respectiva.
+                }
+            }
+        }
+
+        int* diagonalaTmp = new int[latime];
+
+        int ordine = 0;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if (i + j == diagSecIter) {
+                    diagonalaTmp[ordine] = mat[i][j];
+                    ordine++;
+                }
+            }
+        }
+
+        // Push în coadă a elementelor in ordinea corecta
+        // in functie de ordinea din vector
+        if (invers) {
+            // ordine spre SV
+            for (int i = 0; i < latime; i++) {
+                coadaSarpelui.push(diagonalaTmp[i]);
+            }
+        } else {
+            // ordine spre NE
+            for (int i = latime - 1; i >= 0; i--) {
+                coadaSarpelui.push(diagonalaTmp[i]);
+            }
+        }
+        delete[] diagonalaTmp;
+    }
+}
+int main() {
+    int n;
+    std::cout << "n = ";
+    std::cin >> n;
+    int** mat = new int*[n];
+    std::cout << "scrie matricea:\n";
+    citireMatricePatratica(mat, n);
+    std::cout << std::endl;
+    taieAltDiag(mat, n);
+    while (!coadaSarpelui.empty()) {
+        std::cout << coadaSarpelui.front() << " ";
+        coadaSarpelui.pop();
+    }
+    for (int i = 0; i < n; ++i) {
+        delete[] mat[i];
+    }
+    delete[] mat;
+    std::cout << std::endl;
+    
+    return 0;
+}