Un vrai tableau à deux dimensions, dans la plupart des langages, n'est…

def creer_plate(L, C):
    """Matrice L x C representee par UN SEUL tableau de L*C cases."""
    assert L >= 1 and C >= 1
    return {"L": L, "C": C, "cases": [0] * (L * C)}

def lire(mp, i, j):
    assert 0 <= i < mp["L"] and 0 <= j < mp["C"], "indice hors matrice"
    return mp["cases"][i * mp["C"] + j]

def ecrire(mp, i, j, v):
    assert 0 <= i < mp["L"] and 0 <= j < mp["C"], "indice hors matrice"
    mp["cases"][i * mp["C"] + j] = v

La formule $i\times C+j$ est l'accès calculé direct du cours, appliqué deux fois : on saute $i$ lignes entières de $C$ cases, puis $j$ cases. C'est ce que fait le processeur pour un tableau à deux dimensions en C, et la raison pour laquelle parcourir une matrice ligne par ligne est plus rapide que colonne par colonne — les cases lues se suivent en mémoire.

Vérification.

mp = creer_plate(2, 3)
ecrire(mp, 0, 2, 7)
ecrire(mp, 1, 0, 5)
print(mp["cases"])       # [0, 0, 7, 5, 0, 0]

for _ in range(300):
    L, C = random.randint(1, 5), random.randint(1, 5)
    m = [[random.randint(0, 9) for _ in range(C)] for _ in range(L)]
    mp = creer_plate(L, C)
    for i in range(L):
        for j in range(C):
            ecrire(mp, i, j, m[i][j])
    for i in range(L):
        for j in range(C):
            assert lire(mp, i, j) == m[i][j]

Les $300$ matrices se transportent et se relisent à l'identique. Le tableau plat [0, 0, 7, 5, 0, 0] se lit ligne par ligne : $(0,2)=7$ est en position $0\times 3+2=2$, et $(1,0)=5$ en position $1\times 3+0=3$.

Le défaut qui disparaît. Le piège [[0] <em> C] </em> L n'a plus de sens : il n'y a qu'un seul tableau, de nombres, et [0] <em> (L </em> C) est parfaitement correct. Aucune ligne à partager, donc aucune ligne partagée par accident. On perd en revanche la commodité de m[i] — il n'existe aucun objet « ligne » — et l'on gagne une nouvelle source d'erreurs : lire(mp, 0, 3) sur une matrice $2\times 3$ désigne une case qui existe dans le tableau plat (l'indice $3$) mais qui appartient à la ligne suivante. Sans l'assertion, l'erreur serait silencieuse. Chaque représentation déplace les erreurs, elle ne les supprime pas.