lectiipenet.ro

Diagonalele Matricelor: “Cele Două Cruci” ale Matricei Pătratice – Materie BAC

Written by

admin

in

Bun, hai să vorbim despre un concept care pare matematic dar e de fapt foarte vizual: DIAGONALELE MATRICELOR. Nu e doar despre linii (cuvânt simplu) și poziții. E despre cum identifici elementele speciale dintr-o matrice pătratică, cele care stau pe cele două “diagonale” importante. E un concept atât de elegant încât dacă ai privi o matrice pătratică, ai vedea imediat cele două diagonale ca două cruci care o împart.

1. Ce sunt Diagonalele? “Cele Două Linii Speciale”

Gândește-te la diagonale ca la cele două linii care traversează o matrice pătratică:

  • Diagonala principală: De la stânga-sus la dreapta-jos (ca )
  • Diagonala secundară: De la dreapta-sus la stânga-jos (ca /)

Analogie cu o Tablă de Șah:

Pe tabla de șah 8×8:

  • Diagonala principală: de la a1 la h8 (alb-stânga-sus la negru-dreapta-jos)
  • Diagonala secundară: de la h1 la a8 (alb-dreapta-sus la negru-stânga-jos)

2. Matricea Pătratică: “Terenul de Joacă”

ATENȚIE: Diagonalele există DOAR la matrice pătratice (nr. rânduri = nr. coloane)!

#include <iostream>
using namespace std;

int main() {
    // Matrice pătratică 4x4
    int matrice[4][4] = {
        { 1,  2,  3,  4},
        { 5,  6,  7,  8},
        { 9, 10, 11, 12},
        {13, 14, 15, 16}
    };

    cout << "Matricea patratica 4x4:\n";
    for(int i = 0; i < 4; i++) {
        for(int j = 0; j < 4; j++) {
            cout << matrice[i][j] << "\t";
        }
        cout << endl;
    }

    return 0;
}

3. Diagonala Principală: “Linia Identității”

Regula de aur: Pe diagonala principală, indicele de rând = indicele de coloană!

#include <iostream>
using namespace std;

int main() {
    int matrice[4][4] = {
        {10, 20, 30, 40},
        {50, 60, 70, 80},
        {90, 10, 11, 12},
        {13, 14, 15, 16}
    };

    cout << "=== DIAGONALA PRINCIPALA ===\n";
    cout << "Regula: elementele unde i == j\n\n";

    cout << "Elementele de pe diagonala principala: ";
    for(int i = 0; i < 4; i++) {
        cout << matrice[i][i] << " ";  // i == j
    }
    cout << endl;

    // Demonstrație vizuală
    cout << "\nMatricea cu diagonala principala marcata:\n";
    for(int i = 0; i < 4; i++) {
        for(int j = 0; j < 4; j++) {
            if(i == j) {
                cout << "[" << matrice[i][j] << "]\t";  // În paranteze
            } else {
                cout << " " << matrice[i][j] << " \t";  // Fără paranteze
            }
        }
        cout << endl;
    }

    return 0;
}

Ce elemente sunt pe diagonala principală:

Matrice 4x4:
[10]   20    30    40
 50   [60]   70    80
 90    10   [11]   12
 13    14    15   [16]

Diagonala principala: [10] [60] [11] [16]

4. Diagonala Secundară: “Linia Oglindită”

Regula de aur: Pe diagonala secundară, indicele de rând + indicele de coloană = n-1 (unde n e dimensiunea matricei)!

#include <iostream>
using namespace std;

int main() {
    int matrice[4][4] = {
        {10, 20, 30, 40},
        {50, 60, 70, 80},
        {90, 10, 11, 12},
        {13, 14, 15, 16}
    };

    cout << "=== DIAGONALA SECUNDARA ===\n";
    cout << "Regula: elementele unde i + j == n-1 (n=4, deci i+j==3)\n\n";

    cout << "Elementele de pe diagonala secundara: ";
    for(int i = 0; i < 4; i++) {
        int j = 3 - i;  // Pentru că i + j = 3
        cout << matrice[i][j] << " ";
    }
    cout << endl;

    // Demonstrație vizuală
    cout << "\nMatricea cu diagonala secundara marcata:\n";
    for(int i = 0; i < 4; i++) {
        for(int j = 0; j < 4; j++) {
            if(i + j == 3) {  // i + j = n-1 = 3
                cout << "[" << matrice[i][j] << "]\t";
            } else {
                cout << " " << matrice[i][j] << " \t";
            }
        }
        cout << endl;
    }

    return 0;
}

Ce elemente sunt pe diagonala secundară:

Matrice 4x4:
 10    20    30   [40]
 50    60   [70]   80
 90   [10]   11    12
[13]   14    15    16

Diagonala secundara: [40] [70] [10] [13]

5. Comparație Directă între Cele Două Diagonale

#include <iostream>
using namespace std;

int main() {
    const int n = 5;  // Matrice 5x5
    int matrice[n][n];

    // Umple matricea cu numere consecutive
    int contor = 1;
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            matrice[i][j] = contor++;
        }
    }

    cout << "Matricea 5x5:\n";
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            cout << matrice[i][j] << "\t";
        }
        cout << endl;
    }

    cout << "\n=== COMPARATIE DIAGONALE ===\n\n";

    // Diagonala principala
    cout << "Diagonala principala (i == j):\n";
    cout << "Pozitii: ";
    for(int i = 0; i < n; i++) {
        cout << "[" << i << "][" << i << "] ";
    }
    cout << "\nValori:  ";
    for(int i = 0; i < n; i++) {
        cout << matrice[i][i] << "        ";
    }

    cout << "\n\nDiagonala secundara (i + j == n-1):\n";
    cout << "Pozitii: ";
    for(int i = 0; i < n; i++) {
        int j = n - 1 - i;
        cout << "[" << i << "][" << j << "] ";
    }
    cout << "\nValori:  ";
    for(int i = 0; i < n; i++) {
        int j = n - 1 - i;
        cout << matrice[i][j] << "        ";
    }

    return 0;
}

6. Operații cu Diagonalele

6.1 Suma elementelor de pe diagonala principală

#include <iostream>
using namespace std;

int main() {
    int matrice[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    int sumaDiagonalaPrincipala = 0;

    for(int i = 0; i < 3; i++) {
        sumaDiagonalaPrincipala += matrice[i][i];
    }

    cout << "Suma diagonalei principale: " 
         << sumaDiagonalaPrincipala << endl;  // 1+5+9 = 15

    return 0;
}

6.2 Suma elementelor de pe diagonala secundară

#include <iostream>
using namespace std;

int main() {
    int matrice[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    int sumaDiagonalaSecundara = 0;
    int n = 3;  // Dimensiunea matricei

    for(int i = 0; i < n; i++) {
        int j = n - 1 - i;  // Calculăm coloana
        sumaDiagonalaSecundara += matrice[i][j];
    }

    cout << "Suma diagonalei secundare: " 
         << sumaDiagonalaSecundara << endl;  // 3+5+7 = 15

    return 0;
}

6.3 Compararea sumelor diagonalelor

#include <iostream>
using namespace std;

int main() {
    int matrice[4][4] = {
        {1, 0, 0, 2},
        {0, 3, 4, 0},
        {0, 5, 6, 0},
        {7, 0, 0, 8}
    };

    int sumaPrincipala = 0;
    int sumaSecundara = 0;
    int n = 4;

    // Calcul ambele sume într-o singură parcurgere
    for(int i = 0; i < n; i++) {
        // Diagonala principala
        sumaPrincipala += matrice[i][i];

        // Diagonala secundara
        int j = n - 1 - i;
        sumaSecundara += matrice[i][j];
    }

    cout << "Suma diagonalei principale: " << sumaPrincipala << endl;
    cout << "Suma diagonalei secundare: " << sumaSecundara << endl;

    if(sumaPrincipala > sumaSecundara) {
        cout << "Diagonala principala are suma mai mare!\n";
    } else if(sumaPrincipala < sumaSecundara) {
        cout << "Diagonala secundara are suma mai mare!\n";
    } else {
        cout << "Sumele sunt egale!\n";
    }

    return 0;
}

7. Zonele Matricei Definite de Diagonale

#include <iostream>
using namespace std;

int main() {
    int matrice[5][5];
    int n = 5;

    // Umple matricea cu numere consecutive
    int contor = 1;
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            matrice[i][j] = contor++;
        }
    }

    cout << "=== ZONELE MATRICEI ===\n\n";

    // 1. Deasupra diagonalei principale (i < j)
    cout << "Deasupra diagonalei principale (i < j):\n";
    for(int i = 0; i < n; i++) {
        for(int j = i + 1; j < n; j++) {  // j > i
            cout << matrice[i][j] << " ";
        }
    }
    cout << endl;

    // 2. Sub diagonala principală (i > j)
    cout << "\nSub diagonala principala (i > j):\n";
    for(int i = 1; i < n; i++) {          // i > 0
        for(int j = 0; j < i; j++) {      // j < i
            cout << matrice[i][j] << " ";
        }
    }
    cout << endl;

    // 3. Deasupra diagonalei secundare (i + j < n-1)
    cout << "\nDeasupra diagonalei secundare (i + j < n-1):\n";
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            if(i + j < n - 1) {
                cout << matrice[i][j] << " ";
            }
        }
    }
    cout << endl;

    // 4. Sub diagonala secundară (i + j > n-1)
    cout << "\nSub diagonala secundara (i + j > n-1):\n";
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            if(i + j > n - 1) {
                cout << matrice[i][j] << " ";
            }
        }
    }

    return 0;
}

8. Matricea Unitate: “Cea mai Simplă Matrice”

Matricea unitate are 1 pe diagonala principală și 0 în rest. E ca “1” pentru matrice!

#include <iostream>
using namespace std;

int main() {
    const int n = 4;
    int unitate[n][n];

    // Construiește matricea unitate
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            if(i == j) {
                unitate[i][j] = 1;  // Pe diagonala principala
            } else {
                unitate[i][j] = 0;  // In rest
            }
        }
    }

    cout << "Matricea unitate " << n << "x" << n << ":\n";
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            cout << unitate[i][j] << " ";
        }
        cout << endl;
    }

    // Varianta mai eficientă
    cout << "\nMatricea unitate (initializare directa):\n";
    int unitate2[n][n] = {0};  // Toate elementele 0

    for(int i = 0; i < n; i++) {
        unitate2[i][i] = 1;  // Pune 1 doar pe diagonala principala
    }

    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            cout << unitate2[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}

9. Probleme Practice cu Diagonalele

Problema 1: Verifică dacă o matrice este simetrică față de diagonala principală

#include <iostream>
using namespace std;

int main() {
    int matrice[3][3] = {
        {1, 2, 3},
        {2, 4, 5},
        {3, 5, 6}
    };

    bool esteSimetrica = true;
    int n = 3;

    // Verifică simetria
    for(int i = 0; i < n; i++) {
        for(int j = i + 1; j < n; j++) {
            // Compară elementul de deasupra diagonalei cu cel de sub diagonala
            if(matrice[i][j] != matrice[j][i]) {
                esteSimetrica = false;
                break;
            }
        }
        if(!esteSimetrica) break;
    }

    if(esteSimetrica) {
        cout << "Matricea este simetrica fata de diagonala principala!\n";
    } else {
        cout << "Matricea NU este simetrica.\n";
    }

    return 0;
}

Problema 2: Schimbă diagonalele între ele

#include <iostream>
using namespace std;

int main() {
    int matrice[4][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12},
        {13, 14, 15, 16}
    };

    cout << "Matricea initiala:\n";
    for(int i = 0; i < 4; i++) {
        for(int j = 0; j < 4; j++) {
            cout << matrice[i][j] << "\t";
        }
        cout << endl;
    }

    // Schimbă diagonalele
    int n = 4;
    for(int i = 0; i < n; i++) {
        // Elementul de pe diagonala principala
        int temp = matrice[i][i];

        // Elementul de pe diagonala secundara
        int j = n - 1 - i;

        // Schimbă-le
        matrice[i][i] = matrice[i][j];
        matrice[i][j] = temp;
    }

    cout << "\nDupa schimbarea diagonalelor:\n";
    for(int i = 0; i < 4; i++) {
        for(int j = 0; j < 4; j++) {
            cout << matrice[i][j] << "\t";
        }
        cout << endl;
    }

    return 0;
}

Problema 3: Verifică dacă o matrice este “magică” pe diagonale

#include <iostream>
using namespace std;

int main() {
    int matrice[3][3] = {
        {2, 9, 4},
        {7, 5, 3},
        {6, 1, 8}
    };

    int n = 3;
    int sumaPrincipala = 0;
    int sumaSecundara = 0;

    // Calculează sumele diagonalelor
    for(int i = 0; i < n; i++) {
        sumaPrincipala += matrice[i][i];
        sumaSecundara += matrice[i][n-1-i];
    }

    cout << "Suma diagonalei principale: " << sumaPrincipala << endl;
    cout << "Suma diagonalei secundare: " << sumaSecundara << endl;

    if(sumaPrincipala == sumaSecundara) {
        cout << "Diagonalele au aceeasi suma!\n";

        // Bonus: verifică și sumele rândurilor
        bool toateEgale = true;
        int sumaReferinta = sumaPrincipala;

        for(int i = 0; i < n; i++) {
            int sumaRand = 0;
            for(int j = 0; j < n; j++) {
                sumaRand += matrice[i][j];
            }

            if(sumaRand != sumaReferinta) {
                toateEgale = false;
                break;
            }
        }

        if(toateEgale) {
            cout << "MATRICE MAGICA! Toate sumele sunt egale cu " << sumaReferinta << endl;
        }
    }

    return 0;
}

10. Diagonale în Matrici de Dimensiuni Impar vs Par

#include <iostream>
using namespace std;

int main() {
    cout << "=== DIFERENTE DIMENSIUNI IMPAR vs PAR ===\n\n";

    // Matrice 3x3 (impar)
    cout << "Matrice 3x3 (n=impar):\n";
    cout << "Elementul central: matrice[1][1]\n";
    cout << "Apare pe AMBELE diagonale!\n";
    cout << "Diagonalele se INTERSECTEAZA in centru.\n\n";

    // Matrice 4x4 (par)  
    cout << "Matrice 4x4 (n=par):\n";
    cout << "Nu exista 'element central' unic\n";
    cout << "Diagonalele NU se intersecteaza\n";
    cout << "Cele 4 elemente centrale: [1][1], [1][2], [2][1], [2][2]\n";

    return 0;
}

11. Cum Gândești cu Diagonalele: “Reguli Memorabile”

#include <iostream>
using namespace std;

int main() {
    cout << "=== REGULI DE MEMORAT ===\n\n";

    cout << "1. DIAGONALA PRINCIPALA:\n";
    cout << "   - Indicele rand = Indicele coloana\n";
    cout << "   - Formula: i == j\n";
    cout << "   - Ex: matrice[0][0], matrice[1][1], matrice[2][2]\n\n";

    cout << "2. DIAGONALA SECUNDARA:\n";
    cout << "   - Suma indicilor = n-1\n";
    cout << "   - Formula: i + j == n-1\n";
    cout << "   - Ex pentru n=4: [0][3], [1][2], [2][1], [3][0]\n\n";

    cout << "3. DEASUPRA diagonalei principale:\n";
    cout << "   - Formula: i < j\n";
    cout << "   - Ex: [0][1], [0][2], [1][2]\n\n";

    cout << "4. SUB diagonala principala:\n";
    cout << "   - Formula: i > j\n";
    cout << "   - Ex: [1][0], [2][0], [2][1]\n\n";

    cout << "5. CENTRUL matricei (doar pentru n impar):\n";
    cout << "   - Pozitia: [n/2][n/2]\n";
    cout << "   - Ex pentru n=5: [2][2]\n";

    return 0;
}

12. EXERCIȚII Practice

Exercițiul 1: Completează codul

#include <iostream>
using namespace std;

int main() {
    int matrice[4][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12},
        {13, 14, 15, 16}
    };

    // TODO: Calculează produsul elementelor de pe diagonala principala
    int produsPrincipal = 1;
    // Scrie codul aici

    cout << "Produsul diagonalei principale: " << produsPrincipal << endl;

    // TODO: Numără câte numere pare sunt pe diagonala secundară
    int numerePareSecundara = 0;
    // Scrie codul aici

    cout << "Numere pare pe diagonala secundara: " << numerePareSecundara << endl;

    return 0;
}

Soluție:

// Pentru produsul diagonalei principale:
for(int i = 0; i < 4; i++) {
    produsPrincipal *= matrice[i][i];
}

// Pentru numere pare pe diagonala secundară:
for(int i = 0; i < 4; i++) {
    int j = 3 - i;  // n=4, deci n-1=3
    if(matrice[i][j] % 2 == 0) {
        numerePareSecundara++;
    }
}

Exercițiul 2: Întrebări rapide

  1. Care este elementul de pe diagonala secundară al matricei 5×5 de pe poziția [2][?]?
  2. Cum accesezi toate elementele de sub diagonala principală?
  3. Ce are în comun elementul [0][4] și [4][0] într-o matrice 5×5?

Răspunsuri:

  1. [2][2] pentru că 2 + 2 = 4 și n-1 = 4
  2. for(int i = 1; i < n; i++) for(int j = 0; j < i; j++)
  3. Sunt ambele pe diagonala secundară (0+4=4 și 4+0=4)

În concluzie, să-ți spun ceva fundamental:

Diagonalele nu sunt doar linii abstracte într-o matrice – sunt “scheletul” ei. Dacă matricea ar fi o clădire, diagonalele ar fi grinzile principale care o susțin. Înțelegând diagonalele, înțelegi structura internă a oricărei matrice pătratice.

Dar tratarea diagonalelor ca simple colecții de elemente fără a înțelege relațiile dintre indici poate fi, paradoxal, o sursă de erori când încerci să accesezi elemente sau să faci calcule complexe.

Așa că ai grijă când lucrezi cu diagonale. Cunoștințe-ti formulele: când suntem pe diagonala principală? Când pe cea secundară? Care e relația dintre indici? Pentru că puterea de a manipula eficient matricele este goală fără înțelegerea structurii lor diagonale. Și această putere vine cu o responsabilitate: să fii precis cu formulele indicilor.

Stăpânirea diagonalelor este cheia pentru algoritmi avansați cu matrice: determinanți, valori proprii, diagonalizare. Ai grijă de ea cu aceeași seriozitate.

Comments

Leave a Reply

Your email address will not be published. Required fields are marked *

More posts