Chapitre 9 — Tableaux à deux dimensions
Organiser et traiter des données structurées en lignes et en colonnes
Fiche pédagogique du chapitre
Objectifs d’apprentissage
À la fin de ce chapitre, l’étudiant devra être capable de :
- définir une matrice et distinguer ses lignes, ses colonnes et ses dimensions ;
- repérer une case à l’aide de deux indices ;
- déclarer et initialiser un tableau à deux dimensions ;
- remplir une matrice ligne par ligne ou colonne par colonne ;
- afficher une matrice sous une forme tabulaire lisible ;
- utiliser correctement deux boucles imbriquées ;
- additionner deux matrices de mêmes dimensions ;
- multiplier une matrice par un scalaire ;
- construire la transposée d’une matrice ;
- calculer la somme d’une ligne ou d’une colonne ;
- parcourir la diagonale principale et la diagonale secondaire ;
- appliquer les matrices à la gestion des notes et à la représentation d’un plateau de jeu ;
- rechercher une valeur extrême et mémoriser sa position.
Prérequis
- maîtriser les tableaux à une dimension ;
- savoir utiliser les boucles Pour, TantQue et les boucles imbriquées ;
- savoir calculer une somme, une moyenne, un minimum et un maximum ;
- savoir valider un indice et traiter les cas limites ;
- connaître les variables, les affectations et les structures conditionnelles.
Plan du chapitre
9.1 Notion de matrice
9.2 Déclaration et parcours
9.3 Opérations sur les matrices
Applications, exercices, corrigés et synthèse
Organisation pédagogique indicative
Activité | Durée indicative | Objectif principal |
|---|---|---|
| Cours | 3 h | Comprendre la représentation matricielle et les parcours à deux indices. |
| Travaux dirigés | 3 h | Écrire et tracer des traitements sur les lignes, les colonnes et les diagonales. |
| Travaux pratiques | 3 h | Implémenter des opérations matricielles et des applications. |
| Travail personnel | 2 h | Résoudre des exercices de transformation, de recherche et de synthèse. |
| Idée centrale : une matrice est un tableau dont chaque élément est identifié par deux coordonnées : un indice de ligne et un indice de colonne. |
Introduction aux tableaux à deux dimensions
De nombreuses données ne se présentent pas naturellement sous la forme d’une simple liste. Les notes d’une classe sont organisées par étudiants et par matières ; une image numérique est composée de lignes et de colonnes de pixels ; un plateau de jeu est formé de cases ; un tableau statistique croise plusieurs catégories. Dans ces situations, une structure à deux dimensions est plus adaptée qu’un tableau linéaire.
Un tableau à deux dimensions, souvent appelé matrice, peut être vu comme un tableau de tableaux. Sa manipulation repose principalement sur deux indices et sur des boucles imbriquées. La première boucle choisit généralement une ligne, tandis que la seconde parcourt les colonnes de cette ligne.
| Convention utilisée : les indices de lignes vont de 1 à L et les indices de colonnes de 1 à C. Certains langages commencent à 0 ; la traduction doit alors adapter les bornes. |
9.1 Notion de matrice
9.1.1 Définition générale
Une matrice est un tableau rectangulaire composé de valeurs de même type, disposées en lignes et en colonnes. Toutes les lignes possèdent le même nombre de colonnes. Chaque valeur est stockée dans une case repérée par un couple d’indices.
Exemple : matrice Notes de dimension 3 × 3
i \ j | 1 | 2 | 3 |
1 | 12 | 15 | 9 |
2 | 14 | 11 | 16 |
3 | 8 | 13 | 10 |
La notation Notes[2,3] désigne la valeur située sur la deuxième ligne et la troisième colonne. Dans l’exemple, Notes[2,3] vaut 16.
9.1.2 Ligne
Une ligne est un ensemble horizontal de cases. Elle est identifiée par le premier indice. Pour une ligne i fixée, les colonnes j varient de 1 à C.
| // Afficher la ligne i Pour j allant de 1 à C Faire Écrire(M[i,j]) FinPour |
- Première ligne : M[1,1], M[1,2], …, M[1,C].
- Dernière ligne : M[L,1], M[L,2], …, M[L,C].
- Ligne i : toutes les cases dont le premier indice vaut i.
9.1.3 Colonne
Une colonne est un ensemble vertical de cases. Elle est identifiée par le second indice. Pour une colonne j fixée, les lignes i varient de 1 à L.
| // Afficher la colonne j Pour i allant de 1 à L Faire Écrire(M[i,j]) FinPour | |
| Repère mnémotechnique : dans M[i,j], i indique la ligne et j indique la colonne. On lit souvent « M de i, j ». |
9.1.4 Dimension
La dimension d’une matrice est donnée par le nombre de lignes suivi du nombre de colonnes. Une matrice de L lignes et C colonnes a la dimension L × C et contient L × C cases.
Dimension | Nombre de lignes | Nombre de colonnes | Nombre de cases | Exemple d’usage |
|---|---|---|---|---|
| 2 × 3 | 2 | 3 | 6 | Deux personnes et trois mesures. |
| 5 × 4 | 5 | 4 | Cinq étudiants et quatre matières. | |
| 8 × 8 | 8 | 8 | Échiquier. | |
| N × N | N | N | Matrice carrée. | |
| 1 × C | 1 | C | Matrice-ligne. | |
| L × 1 | L | 1 | Matrice-colonne. |
Une matrice est dite carrée lorsque le nombre de lignes est égal au nombre de colonnes. Les diagonales principale et secondaire sont principalement étudiées dans ce cas.
9.1.5 Accès à une case
L’accès à une case nécessite deux indices valides. La case M[i,j] peut être lue, affichée, comparée ou modifiée.
| x <- M[2,3] // lire une case M[1,2] <- 17 // modifier une case M[i,j] <- M[i,j] + 1 // transformer une case |
Expression | Signification | Condition de validité |
|---|---|---|
| M[1,1] | Case en haut à gauche | L ≥ 1 et C ≥ 1 |
| M[L,C] | Case en bas à droite | L ≥ 1 et C ≥ 1 |
| M[i,j] | Case de coordonnées variables | 1 ≤ i ≤ L et 1 ≤ j ≤ C |
| M[0,2] | Ligne invalide avec la convention 1..L | Toujours invalide |
| M[2,C+1] | Colonne après la dernière | Toujours invalide |
| Erreur fréquente : inverser les indices. M[2,3] et M[3,2] désignent généralement deux cases différentes. |
9.1.6 Coordonnées et valeur
Les coordonnées indiquent où se trouve l’information ; la valeur indique ce qui est stocké dans la case. Pour la matrice suivante, la valeur 7 est située aux coordonnées (2,3).
i \ j | 1 | 2 | 3 |
1 | 4 | 1 | 9 |
2 | 6 | 3 | 7 |
3 | 2 | 8 | 5 |
Une même valeur peut apparaître dans plusieurs cases. La recherche d’une valeur doit donc préciser si l’on souhaite la première occurrence, toutes les occurrences ou seulement un comptage.
9.1.7 Représentation en mémoire
En mémoire, les cases d’une matrice sont généralement stockées dans un ordre linéaire. Le rangement peut être effectué ligne par ligne ou, plus rarement, colonne par colonne selon le langage et la bibliothèque utilisés. Cette organisation interne ne change pas la notation abstraite M[i,j].
Le nombre total de valeurs stockées est L × C. Une matrice de 1000 × 1000 réels contient un million d’éléments ; son coût mémoire peut donc devenir important.
9.1.8 Tableau à une dimension et matrice
Critère | Tableau à une dimension | Tableau à deux dimensions |
|---|---|---|
| Organisation | Suite linéaire | Grille de lignes et de colonnes |
| Nombre d’indices | Un indice | Deux indices |
| Accès | T[i] | M[i,j] |
| Parcours habituel | Une boucle | Deux boucles imbriquées |
| Exemples | Liste de notes | Notes par étudiant et par matière |
| Nombre d’éléments | N | L × C |
9.2 Déclaration et parcours
9.2.1 Déclaration d’une matrice
La déclaration précise le nom de la matrice, le type de ses éléments, le nombre de lignes et le nombre de colonnes. En pseudo-code, on peut écrire :
| Variables M : Tableau[1..L, 1..C] d’Entiers Notes : Tableau[1..30, 1..5] de Réels Plateau : Tableau[1..3, 1..3] de Caractères |
La déclaration réserve les cases, mais ne garantit pas qu’elles contiennent toutes une valeur utile. Une initialisation ou un remplissage est donc nécessaire avant les traitements.
9.2.2 Initialisation uniforme
Pour attribuer la même valeur à toutes les cases, on utilise deux boucles imbriquées. La boucle extérieure parcourt les lignes et la boucle intérieure parcourt les colonnes.
| Pour i allant de 1 à L Faire Pour j allant de 1 à C Faire M[i,j] <- 0 FinPour FinPour |
Le corps de la boucle intérieure est exécuté L × C fois. Pour une matrice 3 × 4, l’affectation M[i,j] <- 0 est exécutée 12 fois.
9.2.3 Remplissage ligne par ligne
Le remplissage ligne par ligne termine toutes les colonnes d’une ligne avant de passer à la ligne suivante. Il correspond à la représentation visuelle la plus naturelle.
| Algorithme Remplir_Matrice Variables M : Tableau[1..L,1..C] d’Entiers i, j : Entiers Début Pour i allant de 1 à L Faire Pour j allant de 1 à C Faire Écrire("Saisir M[", i, ",", j, "] :") Lire(M[i,j]) FinPour FinPour Fin |
Ordre de saisie pour une matrice 2 × 3 | Coordonnée |
|---|---|
| 1 | M[1,1] |
| 2 | M[1,2] |
| 3 | M[1,3] |
| 4 | M[2,1] |
| 5 | M[2,2] |
| 6 | M[2,3] |
9.2.4 Remplissage colonne par colonne
Il est également possible de parcourir d’abord les colonnes. Il suffit d’inverser l’ordre des boucles.
| Pour j allant de 1 à C Faire Pour i allant de 1 à L Faire Lire(M[i,j]) FinPour FinPour | |
| Attention : inverser les boucles modifie l’ordre de visite, mais pas les coordonnées ni les dimensions de la matrice. |
9.2.5 Affichage sous forme de tableau
Pour obtenir une représentation lisible, chaque ligne de la matrice doit être affichée sur une ligne de sortie. Les valeurs d’une même ligne sont écrites sans retour à la ligne, puis une instruction provoque le passage à la ligne suivante.
| Pour i allant de 1 à L Faire Pour j allant de 1 à C Faire ÉcrireSansRetour(M[i,j], " " ) FinPour ÉcrireLigneVide() FinPour |
La notation ÉcrireSansRetour représente une écriture qui conserve le curseur sur la même ligne. Son nom exact dépend du langage de programmation.
Résultat visuel attendu pour une matrice 2 × 3
3 | 5 | 7 |
2 | 4 | 6 |
9.2.6 Utilisation de boucles imbriquées
Une boucle imbriquée est une boucle placée à l’intérieur d’une autre. Pour chaque valeur de i, la boucle sur j est exécutée entièrement.
Étape | i | j | Case visitée |
|---|---|---|---|
| 1 | 1 | 1 | M[1,1] |
| 2 | 1 | 2 | M[1,2] |
| 3 | 1 | 3 | M[1,3] |
| 4 | 2 | 1 | M[2,1] |
| 5 | 2 | 2 | M[2,2] |
| 6 | 2 | 3 | M[2,3] |
| Invariant de parcours : au début du traitement de la ligne i, toutes les lignes précédentes sont déjà traitées. Dans la ligne i, avant la colonne j, les cases de 1 à j − 1 sont déjà traitées. |
9.2.7 Parcours partiels
Toutes les opérations ne nécessitent pas de parcourir la matrice entière. On peut sélectionner une ligne, une colonne, un rectangle, une diagonale ou seulement les cases qui vérifient une condition.
| // Parcourir les lignes debutL à finL et les colonnes debutC à finC Pour i allant de debutL à finL Faire Pour j allant de debutC à finC Faire Traiter(M[i,j]) FinPour FinPour |
- une ligne : fixer i et faire varier j ;
- une colonne : fixer j et faire varier i ;
- un sous-rectangle : faire varier i et j dans des intervalles restreints ;
- les cases du bord : tester i = 1, i = L, j = 1 ou j = C ;
- les cases intérieures : parcourir les lignes 2 à L − 1 et les colonnes 2 à C − 1.
9.2.8 Modification d’une case
Avant de modifier une case dont les coordonnées sont saisies, il faut vérifier simultanément les limites des lignes et des colonnes.
| Répéter Lire(i) Jusqu’à i >= 1 ET i <= L Répéter Lire(j) Jusqu’à j >= 1 ET j <= C Lire(nouvelleValeur) M[i,j] <- nouvelleValeur |
9.2.9 Transformation de toutes les cases
Les deux boucles peuvent appliquer la même transformation à toute la matrice.
| // Doubler toutes les valeurs Pour i allant de 1 à L Faire Pour j allant de 1 à C Faire M[i,j] <- 2 * M[i,j] FinPour FinPour |
Case | Valeur avant | Calcul | Valeur après |
|---|---|---|---|
| M[1,1] | 3 | 2 × 3 | 6 |
| M[1,2] | −1 | 2 × (−1) | −2 |
| M[2,1] | 5 | 2 × 5 | 10 |
| M[2,2] | 0 | 2 × 0 | 0 |
9.2.10 Erreurs fréquentes de parcours
Erreur | Conséquence | Correction |
|---|---|---|
| Utiliser C comme borne de i | Accès à une ligne inexistante si L ≠ C | i doit varier de 1 à L. |
| Utiliser L comme borne de j | Accès à une colonne inexistante si L ≠ C | j doit varier de 1 à C. |
| Écrire M[j,i] par inadvertance | Lecture de la transposée ou accès invalide | Respecter l’ordre ligne, colonne. |
| Oublier la boucle intérieure | Une seule case par ligne est traitée | Parcourir toutes les colonnes. |
| Oublier le retour à la ligne à l’affichage | Toutes les valeurs apparaissent sur une ligne | Ajouter un retour après chaque ligne. |
9.3 Opérations sur les matrices
9.3.1 Somme de deux matrices
Deux matrices A et B peuvent être additionnées uniquement si elles possèdent les mêmes dimensions. La matrice résultat S a la même dimension et chaque case est obtenue par l’addition des cases correspondantes.
| Si LA = LB ET CA = CB Alors Pour i allant de 1 à LA Faire Pour j allant de 1 à CA Faire S[i,j] <- A[i,j] + B[i,j] FinPour FinPour Sinon Écrire("Dimensions incompatibles.") FinSi |
Matrice A
1 | 3 |
2 | 4 |
Matrice B
5 | 1 |
7 | 2 |
Somme S = A + B
6 | 4 |
9 | 6 |
| Condition indispensable : la somme case par case n’a de sens que lorsque le nombre de lignes et le nombre de colonnes sont identiques. |
9.3.2 Produit par un scalaire
Un scalaire est une valeur unique. Multiplier une matrice par un scalaire k consiste à multiplier chaque case par k. La dimension ne change pas.
| Pour i allant de 1 à L Faire Pour j allant de 1 à C Faire R[i,j] <- k * M[i,j] FinPour FinPour |
Matrice M
2 | -1 |
0 | 3 |
Résultat pour k = 3
6 | -3 |
0 | 9 |
- si k = 1, la matrice ne change pas ;
- si k = 0, toutes les cases deviennent nulles ;
- si k = −1, chaque valeur change de signe ;
- le type du résultat doit pouvoir représenter le produit.
9.3.3 Transposée
La transposée d’une matrice M de dimension L × C est une matrice T de dimension C × L. Les lignes de M deviennent les colonnes de T. La règle est T[j,i] <- M[i,j].
| Pour i allant de 1 à L Faire Pour j allant de 1 à C Faire T[j,i] <- M[i,j] FinPour FinPour |
Matrice M de dimension 2 × 3
i \ j | 1 | 2 | 3 |
1 | 1 | 2 | 3 |
2 | 4 | 5 | 6 |
Transposée T de dimension 3 × 2
i \ j | 1 | 2 |
1 | 1 | 4 |
2 | 2 | 5 |
3 | 3 | 6 |
| Point de vigilance : la matrice résultat doit être déclarée avec les dimensions inversées : C lignes et L colonnes. |
9.3.4 Somme des éléments d’une ligne
Pour calculer la somme de la ligne r, l’indice de ligne reste fixe et l’indice de colonne varie.
| Si r >= 1 ET r <= L Alors sommeLigne <- 0 Pour j allant de 1 à C Faire sommeLigne <- sommeLigne + M[r,j] FinPour Écrire(sommeLigne) Sinon Écrire("Ligne invalide.") FinSi |
i \ j | 1 | 2 | 3 |
1 | 4 | 6 | 2 |
2 | 1 | 5 | 3 |
3 | 8 | 0 | 7 |
Pour r = 2, la somme est 1 + 5 + 3 = 9.
9.3.5 Somme de chaque ligne
Une boucle supplémentaire permet de calculer la somme de toutes les lignes. Le résultat peut être stocké dans un tableau à une dimension SommesLignes.
| Pour i allant de 1 à L Faire somme <- 0 Pour j allant de 1 à C Faire somme <- somme + M[i,j] FinPour SommesLignes[i] <- somme FinPour |
Ligne | Valeurs | Somme |
|---|---|---|
| 1 | 4, 6, 2 | 12 |
| 2 | 1, 5, 3 | 9 |
| 3 | 8, 0, 7 | 15 |
9.3.6 Somme des éléments d’une colonne
Pour une colonne c, l’indice de colonne reste fixe et l’indice de ligne varie.
| Si c >= 1 ET c <= C Alors sommeColonne <- 0 Pour i allant de 1 à L Faire sommeColonne <- sommeColonne + M[i,c] FinPour Écrire(sommeColonne) Sinon Écrire("Colonne invalide.") FinSi |
Dans la matrice précédente, la somme de la colonne 2 est 6 + 5 + 0 = 11.
9.3.7 Somme de chaque colonne
| Pour j allant de 1 à C Faire somme <- 0 Pour i allant de 1 à L Faire somme <- somme + M[i,j] FinPour SommesColonnes[j] <- somme FinPour |
Colonne | Valeurs | Somme |
|---|---|---|
| 1 | 4, 1, 8 | 13 |
| 2 | 6, 5, 0 | 11 |
| 3 | 2, 3, 7 | 12 |
9.3.8 Diagonale principale
Dans une matrice carrée N × N, la diagonale principale relie la case en haut à gauche à la case en bas à droite. Ses cases vérifient i = j.
i \ j | 1 | 2 | 3 |
1 | 1 | 2 | 3 |
2 | 4 | 5 | 6 |
3 | 7 | 8 | 9 |
Les éléments de la diagonale principale sont M[1,1] = 1, M[2,2] = 5 et M[3,3] = 9.
| sommeDP <- 0 Pour i allant de 1 à N Faire sommeDP <- sommeDP + M[i,i] FinPour | |
| Complexité : la diagonale contient N éléments. Son parcours nécessite une seule boucle et non deux boucles imbriquées. |
9.3.9 Diagonale secondaire
La diagonale secondaire relie la case en haut à droite à la case en bas à gauche. Dans une matrice N × N utilisant des indices de 1 à N, ses cases vérifient j = N − i + 1.
| sommeDS <- 0 Pour i allant de 1 à N Faire j <- N - i + 1 sommeDS <- sommeDS + M[i,j] FinPour |
i | j = N − i + 1 pour N = 4 | Case |
|---|---|---|
| 1 | 4 | M[1,4] |
| 2 | 3 | M[2,3] |
| 3 | 2 | M[3,2] |
| 4 | 1 | M[4,1] |
| Matrice d’ordre impair : la case centrale appartient aux deux diagonales. Elle ne doit être comptée qu’une fois lorsque l’on calcule la somme de leur union. |
9.3.10 Somme des deux diagonales sans double comptage
| somme <- 0 Pour i allant de 1 à N Faire somme <- somme + M[i,i] j <- N - i + 1 Si j <> i Alors somme <- somme + M[i,j] FinSi FinPour |
Le test j <> i évite d’ajouter deux fois la case centrale d’une matrice d’ordre impair.
9.3.11 Maximum d’une matrice
Pour rechercher le maximum, on initialise le maximum avec une case existante, généralement M[1,1], puis on compare toutes les autres cases. Les coordonnées sont mises à jour avec la valeur.
| maximum <- M[1,1] ligneMax <- 1 colonneMax <- 1 Pour i allant de 1 à L Faire Pour j allant de 1 à C Faire Si M[i,j] > maximum Alors maximum <- M[i,j] ligneMax <- i colonneMax <- j FinSi FinPour FinPour | |
| Pourquoi ne pas initialiser à zéro ? si toutes les valeurs sont négatives, zéro serait annoncé à tort comme maximum. Une case réelle de la matrice fournit une initialisation correcte. |
9.3.12 Comptage et recherche conditionnelle
Les schémas de comptage et de recherche des tableaux à une dimension s’étendent directement aux matrices. La différence principale est la présence de deux indices.
| compteur <- 0 Pour i allant de 1 à L Faire Pour j allant de 1 à C Faire Si M[i,j] < 0 Alors compteur <- compteur + 1 FinSi FinPour FinPour |
Pour rechercher une valeur x, on peut parcourir toute la matrice, mémoriser la première position ou afficher toutes les coordonnées où x apparaît.
9.3.13 Comparaison de deux matrices
Deux matrices sont égales si elles ont les mêmes dimensions et si toutes leurs cases correspondantes sont égales.
| egales <- Faux Si LA = LB ET CA = CB Alors egales <- Vrai i <- 1 TantQue i <= LA ET egales Faire j <- 1 TantQue j <= CA ET egales Faire Si A[i,j] <> B[i,j] Alors egales <- Faux FinSi j <- j + 1 FinTantQue i <- i + 1 FinTantQue FinSi |
Applications
Application 1 — Gestion des notes de plusieurs étudiants
On souhaite stocker les notes de L étudiants dans C matières. Chaque ligne correspond à un étudiant et chaque colonne à une matière. Cette organisation permet de calculer la moyenne d’un étudiant, la moyenne d’une matière et la moyenne générale.
Exemple de matrice Notes
i \ j | Math | Info | Physique |
E1 | 12 | 14 | 10 |
E2 | 15 | 13 | 16 |
E3 | 8 | 11 | 9 |
E4 | 17 | 15 | 18 |
| // Moyenne de chaque étudiant Pour i allant de 1 à L Faire somme <- 0 Pour j allant de 1 à C Faire somme <- somme + Notes[i,j] FinPour MoyenneEtudiant[i] <- somme / C FinPour |
| // Moyenne de chaque matière Pour j allant de 1 à C Faire somme <- 0 Pour i allant de 1 à L Faire somme <- somme + Notes[i,j] FinPour MoyenneMatiere[j] <- somme / L FinPour |
Étudiant | Moyenne |
|---|---|
| E1 | 12 |
| E2 | 14,67 |
| E3 | 9,33 |
| E4 | 16,67 |
Le tableau peut ensuite servir à déterminer l’étudiant ayant la meilleure moyenne, la matière la plus difficile ou le nombre de notes inférieures à 10.
Application 2 — Représentation d’un plateau de jeu
Un plateau de jeu peut être représenté par une matrice de caractères. Chaque case contient un symbole : par exemple « X », « O » ou « . » pour une case vide.
Exemple de plateau 3 × 3
i \ j | 1 | 2 | 3 |
1 | X | O | X |
2 | . | X | O |
3 | O | . | X |
| // Initialiser le plateau avec des cases vides Pour i allant de 1 à 3 Faire Pour j allant de 1 à 3 Faire Plateau[i,j] <- '.' FinPour FinPour | |
| // Placer un symbole après validation Si ligne >= 1 ET ligne <= 3 ET colonne >= 1 ET colonne <= 3 ET Plateau[ligne,colonne] = '.' Alors Plateau[ligne,colonne] <- symbole Sinon Écrire("Coup invalide.") FinSi | |
| Règle de conception : une matrice modélise la position des éléments, tandis que les règles du jeu sont gérées par des conditions et des fonctions complémentaires. |
Application 3 — Addition de deux matrices
L’algorithme complet vérifie les dimensions, lit les deux matrices, calcule la somme et l’affiche.
| Algorithme Addition_Matrices Variables A, B, S : Tableaux[1..L,1..C] de Réels i, j : Entiers Début Pour i allant de 1 à L Faire Pour j allant de 1 à C Faire Lire(A[i,j]) FinPour FinPour Pour i allant de 1 à L Faire Pour j allant de 1 à C Faire Lire(B[i,j]) S[i,j] <- A[i,j] + B[i,j] FinPour FinPour Pour i allant de 1 à L Faire Pour j allant de 1 à C Faire ÉcrireSansRetour(S[i,j], " " ) FinPour ÉcrireLigneVide() FinPour Fin |
Le calcul de S peut être effectué pendant la lecture de B, car la valeur A[i,j] est déjà disponible. Une autre solution consiste à séparer complètement la lecture et le traitement pour améliorer la lisibilité.
Application 4 — Recherche du maximum d’une matrice
L’objectif est d’afficher la plus grande valeur et ses premières coordonnées. La matrice doit contenir au moins une case.
| Si L > 0 ET C > 0 Alors maximum <- M[1,1] ligneMax <- 1 colonneMax <- 1 Pour i allant de 1 à L Faire Pour j allant de 1 à C Faire Si M[i,j] > maximum Alors maximum <- M[i,j] ligneMax <- i colonneMax <- j FinSi FinPour FinPour Écrire("Maximum = ", maximum) Écrire("Position = (", ligneMax, ",", colonneMax, ")") Sinon Écrire("Matrice vide.") FinSi |
Matrice | Maximum | Première position |
|---|---|---|
| [[3, 8], [5, 2]] | 8 | (1,2) |
| [[-7, -2], [-9, -4]] | −2 | (1,2) |
| [[6, 6], [1, 6]] | 6 | (1,1) |
Pour obtenir toutes les positions du maximum, on peut effectuer un second parcours après avoir déterminé sa valeur.
Synthèse du chapitre
Règles essentielles à retenir
- une matrice organise des valeurs homogènes en lignes et en colonnes ;
- une case est repérée par deux indices : M[i,j] ;
- i varie généralement de 1 à L et j de 1 à C ;
- une matrice L × C contient L × C cases ;
- le parcours complet utilise deux boucles imbriquées ;
- une ligne est parcourue en fixant i et en faisant varier j ;
- une colonne est parcourue en fixant j et en faisant varier i ;
- la somme de matrices exige des dimensions identiques ;
- la transposée d’une matrice L × C a la dimension C × L ;
- la diagonale principale vérifie i = j ;
- la diagonale secondaire vérifie j = N − i + 1 ;
- un maximum doit être initialisé avec une case existante, et non avec une valeur arbitraire.
Schémas algorithmiques réutilisables
Besoin | Boucle extérieure | Boucle intérieure ou indice |
|---|---|---|
| Parcours complet | i de 1 à L | j de 1 à C |
| Parcours d’une ligne r | Aucune ou i fixé à r | j de 1 à C |
| Parcours d’une colonne c | i de 1 à L | j fixé à c |
| Diagonale principale | i de 1 à N | M[i,i] |
| Diagonale secondaire | i de 1 à N | M[i,N−i+1] |
| Transposée | i de 1 à L | T[j,i] <- M[i,j] |
Checklist avant de valider un algorithme matriciel
- les dimensions L et C sont-elles positives et valides ? ;
- les deux indices utilisent-ils les bonnes bornes ? ;
- l’ordre ligne-colonne est-il respecté ? ;
- la matrice résultat possède-t-elle les dimensions appropriées ? ;
- la compatibilité des dimensions est-elle vérifiée avant une opération ? ;
- le retour à la ligne est-il effectué après chaque ligne lors de l’affichage ? ;
- les matrices carrées et non carrées sont-elles distinguées ? ;
- la case centrale est-elle évitée deux fois dans la somme des deux diagonales ? ;
- les valeurs négatives sont-elles correctement traitées dans la recherche du maximum ?
Travaux dirigés
Exercice 1 — Lire des coordonnées
Pour la matrice M = [[4, 7, 2], [9, 1, 6]], donner sa dimension, M[1,3], M[2,1] et les coordonnées de la valeur 1.
Exercice 2 — Remplissage et affichage
Écrire un algorithme qui lit une matrice L × C d’entiers puis l’affiche ligne par ligne.
Exercice 3 — Somme totale
Calculer la somme de toutes les cases d’une matrice et compter le nombre de valeurs strictement négatives.
Exercice 4 — Sommes des lignes
Construire un tableau SommesLignes contenant la somme de chaque ligne.
Exercice 5 — Sommes des colonnes
Construire un tableau SommesColonnes contenant la somme de chaque colonne.
Exercice 6 — Ligne la plus élevée
Déterminer le numéro de la ligne dont la somme est maximale. En cas d’égalité, conserver la première ligne.
Exercice 7 — Matrice identité
Écrire un algorithme qui construit une matrice identité N × N : 1 sur la diagonale principale et 0 ailleurs.
Exercice 8 — Diagonales
Pour une matrice carrée, calculer séparément la somme de la diagonale principale et celle de la diagonale secondaire.
Exercice 9 — Transposée
Construire et afficher la transposée d’une matrice L × C.
Exercice 10 — Symétrie
Déterminer si une matrice carrée est symétrique, c’est-à-dire si M[i,j] = M[j,i] pour toutes les cases.
Exercice 11 — Bordure
Afficher uniquement les éléments situés sur le bord d’une matrice L × C, sans afficher deux fois les coins.
Exercice 12 — Recherche de toutes les occurrences
Lire une valeur x, afficher toutes ses coordonnées dans la matrice et compter ses occurrences.
Corrigé indicatif des travaux dirigés
Corrigé de l’exercice 1
La dimension est 2 × 3. M[1,3] = 2, M[2,1] = 9 et la valeur 1 se trouve aux coordonnées (2,2).
Corrigé de l’exercice 2
| Pour i allant de 1 à L Faire Pour j allant de 1 à C Faire Lire(M[i,j]) FinPour FinPour Pour i allant de 1 à L Faire Pour j allant de 1 à C Faire ÉcrireSansRetour(M[i,j], " " ) FinPour ÉcrireLigneVide() FinPour |
Corrigé de l’exercice 3
| somme <- 0 nbNegatifs <- 0 Pour i allant de 1 à L Faire Pour j allant de 1 à C Faire somme <- somme + M[i,j] Si M[i,j] < 0 Alors nbNegatifs <- nbNegatifs + 1 FinSi FinPour FinPour |
Corrigé de l’exercice 4
| Pour i allant de 1 à L Faire somme <- 0 Pour j allant de 1 à C Faire somme <- somme + M[i,j] FinPour SommesLignes[i] <- somme FinPour |
Corrigé de l’exercice 5
| Pour j allant de 1 à C Faire somme <- 0 Pour i allant de 1 à L Faire somme <- somme + M[i,j] FinPour SommesColonnes[j] <- somme FinPour |
Corrigé de l’exercice 6
| maxSomme <- SommesLignes[1] ligneMax <- 1 Pour i allant de 2 à L Faire Si SommesLignes[i] > maxSomme Alors maxSomme <- SommesLignes[i] ligneMax <- i FinSi FinPour |
Corrigé de l’exercice 7
| Pour i allant de 1 à N Faire Pour j allant de 1 à N Faire Si i = j Alors I[i,j] <- 1 Sinon I[i,j] <- 0 FinSi FinPour FinPour |
Corrigé de l’exercice 8
| sommeDP <- 0 sommeDS <- 0 Pour i allant de 1 à N Faire sommeDP <- sommeDP + M[i,i] sommeDS <- sommeDS + M[i,N-i+1] FinPour |
Corrigé de l’exercice 9
| Pour i allant de 1 à L Faire Pour j allant de 1 à C Faire T[j,i] <- M[i,j] FinPour FinPour |
Corrigé de l’exercice 10
| symetrique <- Vrai i <- 1 TantQue i <= N ET symetrique Faire j <- i + 1 TantQue j <= N ET symetrique Faire Si M[i,j] <> M[j,i] Alors symetrique <- Faux FinSi j <- j + 1 FinTantQue i <- i + 1 FinTantQue |
Il suffit de comparer les cases situées au-dessus de la diagonale principale avec leurs symétriques.
Corrigé de l’exercice 11
| Pour i allant de 1 à L Faire Pour j allant de 1 à C Faire Si i = 1 OU i = L OU j = 1 OU j = C Alors Écrire(M[i,j]) FinSi FinPour FinPour |
Chaque case est visitée une seule fois ; les coins ne sont donc pas dupliqués.
Corrigé de l’exercice 12
| occurrences <- 0 Pour i allant de 1 à L Faire Pour j allant de 1 à C Faire Si M[i,j] = x Alors occurrences <- occurrences + 1 Écrire("(", i, ",", j, ")") FinSi FinPour FinPour Écrire("Nombre d’occurrences : ", occurrences) |
Glossaire
Terme | Définition |
|---|---|
| Matrice | Tableau rectangulaire de valeurs de même type, organisé en lignes et en colonnes. |
| Ligne | Suite horizontale de cases ayant le même premier indice. |
| Colonne | Suite verticale de cases ayant le même second indice. |
| Dimension | Couple nombre de lignes × nombre de colonnes. |
| Coordonnées | Couple (i,j) identifiant une case. |
| Matrice carrée | Matrice ayant autant de lignes que de colonnes. |
| Scalaire | Valeur unique utilisée notamment pour multiplier chaque élément d’une matrice. |
| Transposée | Matrice obtenue en échangeant les lignes et les colonnes. |
| Diagonale principale | Cases M[i,i] d’une matrice carrée. |
| Diagonale secondaire | Cases M[i,N−i+1] d’une matrice carrée. |
| Boucles imbriquées | Boucle placée à l’intérieur d’une autre boucle. |
Auto-évaluation
Répondre par « Oui », « Partiellement » ou « Non » aux affirmations suivantes :
Compétence | Oui | Partiellement | Non |
|---|---|---|---|
| Je sais définir une matrice et indiquer sa dimension. | ☐ | ☐ | ☐ |
| Je sais accéder à une case avec deux indices. | ☐ | ☐ | ☐ |
| Je sais déclarer, remplir et afficher une matrice. | ☐ | ☐ | ☐ |
| Je sais utiliser deux boucles imbriquées. | ☐ | ☐ | ☐ |
| Je sais parcourir une ligne et une colonne. | ☐ | ☐ | ☐ |
| Je sais additionner deux matrices compatibles. | ☐ | ☐ | ☐ |
| Je sais multiplier une matrice par un scalaire. | ☐ | ☐ | ☐ |
| Je sais construire une transposée. | ☐ | ☐ | ☐ |
| Je sais parcourir les deux diagonales. | ☐ | ☐ | ☐ |
| Je sais rechercher un maximum et sa position. | ☐ | ☐ | ☐ |
| Objectif de maîtrise : être capable de transformer un problème organisé en lignes et colonnes en une matrice, puis de choisir le parcours approprié sans confondre les indices. |