Generări în matrice

De ce contează?

Completezi o tablă de joc după o regulă: „pune X unde rândul și coloana sunt egale". Nu primești valorile gata făcute — le construiești tu, celulă cu celulă, după o lege clară. Generarea unei matrice e exact asta: o formulă care spune ce pui pe fiecare poziție.

Ideea: valoarea vine dintr-o formulă

La generare nu citești matricea — o construiești. Fiecare element a[i][j] se calculează dintr-o formulă în funcție de indicii i și j. Parcurgi cu două bucle și completezi.

Exemple clasice

Matrice	Regulă	Element [i][j]
identitate	1 pe diagonală	`i == j ? 1 : 0`
tabla înmulțirii	produs de indici	`(i+1) * (j+1)`
sumă de indici	adunare	`i + j`
„tablă de șah"	paritate	`(i + j) % 2`

Algoritm pas cu pas: matricea identitate 3×3

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    int a[100][100];
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            a[i][j] = (i == j) ? 1 : 0;     // 1 pe diagonala, 0 in rest

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) cout << a[i][j] << " ";
        cout << "\n";
    }
    return 0;
}

Rezultat pentru n = 3:

1 0 0
0 1 0
0 0 1

Observația-cheie

Condiția i == j selectează diagonala principală. Schimbând regula, generezi orice tipar: i + j == n - 1 dă diagonala secundară, (i + j) % 2 dă damierul. Indicii sunt „materia primă" a oricărei generări.

Generări care depind de vecini

Unele matrice se completează în ordine, fiecare element folosind valori deja generate (ex. triunghiul lui Pascal: a[i][j] = a[i-1][j-1] + a[i-1][j]). Acolo ordinea de completare contează — calculezi linia i doar după ce ai linia i-1.

Complexitate

Operație	Timp	Spațiu
generarea unei matrice n×n	O(n²)	O(n²) pentru stocare

Atingi fiecare celulă o dată → O(n²), proporțional cu numărul de celule.

Greșeli frecvente

Capcane reale la generarea matricelor:

Indexare greșită pentru tabel: tabla înmulțirii cu i*j (de la 0) dă o linie și o coloană de zerouri. Folosește (i+1)*(j+1).
Confuzi diagonalele: principală e i == j, secundară i + j == n - 1. Inversarea dă tiparul oglindit.
Ordine greșită la generări recurente: folosești a[i-1][j] înainte să fi calculat linia i-1 → citești gunoi.
Acces în afara matricei: la reguli cu vecini (a[i-1][j-1]), tratează marginile separat (i=0 sau j=0).

De reținut

Generare = completezi a[i][j] dintr-o formulă în i și j, nu din date citite.
Diagonala principală i == j, secundară i + j == n - 1, damier (i + j) % 2.
O(n²); la reguli cu vecini, respectă ordinea de completare și tratează marginile.