ING / ALSD-1 Chapitre III : Type Tableau - Vecteurs & Matrices) (2022-2023)

Chapitre III
Type Tableau – Vecteurs & Matrices
Sommaire
Chapitre III : Variables Indicées – Le type Tableau...................................3
III.1. Introduction.............................................................................................................3

III.2. Les tableaux unidimensionnels (Vecteurs).....................................................3

III.2.1. Accès à un élément du tableau........................................................................... 4
III.2.2. Représentation en mémoire............................................................................... 4
III.2.3. Déclaration d'un tableau unidimensionnel...................................................5
III.2.4. Initialisation d'un tableau unidimensionnel.................................................6
III.2.5. Manipulation de Tableaux unidimensionnels (Vecteurs).........................7
a) Somme de deux Vecteurs V1 et V2........................................................................ 8
b) Produit scalaire de deux vecteurs V1 et V2.......................................................8
c) Recherche d'un élément dans un tableau..........................................................9
d) Recherche du maximum dans un tableau unidimensionnel......................9
e) L'algorithme de Tri par sélection (permutations).........................................10

III.3. Les tableaux bidimensionnels (Matrices).......................................................11

III.3.1. Présentation de tableaux bidimensionnels..................................................11
III.3.2. Déclaration de tableaux bidimensionnels....................................................11
III.3.2. Lecture et affichage d'une matrice.................................................................12
III.3.3. Manipulation de matrice.................................................................................... 13
a) Lire et écrire un tableau bidimensionnels.......................................................13
b) Produit d'une matrice par un vecteur...............................................................13
c) Compter le nombre d'éléments négatifs, positifs et nuls dans une
matrice.............................................................................................................................. 14
d) Produit de deux matrices...................................................................................... 15

1
ING / ALSD-1 Chapitre III : Type Tableau - Vecteurs & Matrices) (2022-2023)

Cours Elearning :
https://elearning.univ-bejaia.dz/course/view.php?id=2749

Page facebook :
https://www.facebook.com/InitiationAlgoProgrammation/

La chaîne Youtube :
https://www.youtube.com/c/AlgoProgrammation1èreAnnéeTechnologie

La playlist sur le langage C :

https://youtube.com/playlist?list=PLwHHAvorm5F-tL9EXDEH0miOKmAj7iUTU

Adapté par : Redouane OUZEGGANE

[email protected] - [email protected]

2
ING / ALSD-1 Chapitre III : Type Tableau - Vecteurs & Matrices) (2022-2023)

Chapitre III : Variables Indicées – Le type Tableau

III.1. Introduction
Jusque là, nous avons vu que des variables de type simple (entier, réel, caractère, chaîne et

booléen) où chaque variable est associée à un seul espace mémoire, ne pouvant loger (ou bien

contenir) qu'une seule valeur à instant donné. Afin de représenter des données complexes comme

des tableaux de données (Tableaux statiques, vecteurs, matrices, listes, etc.) on utilise un autre type

de variables : variables indicées ou tableaux.

Exemple

Représentation d'un vecteur : soit VECT = [c1 c2 c3 c4 c5]

Ce vecteur sera représenté par le tableau (variable) VECT comme suit :

1 2 3 4 5
c1 c2 c3 c4 c5

Avec VECT[1] = c1 ; VECT[2] = c2 ; VECT[3] = c3 ; VECT[4] = c4 ; VECT[5] = c5 .

Les positions {1, 2, 3, 4, 5} représentent les indices ou indexes du tableau. Ils donnent la position

d'un élément du tableau. VECT[1], VECT[2], VECT[3], VECT[4], VECT[5] représentent les

composantes du vecteur VECT, (les éléments du tableau).

VECT[1] est la première composante du tableau VECT

VECT[2] est la deuxième composante du tableau VECT

VECT[3] est la troisième composante du tableau VECT

Etc.

III.2. Les tableaux unidimensionnels (Vecteurs)

Les tableaux à une seule dimension correspondent au tableaux avec une seule plage d'indices.

C'est-à-dire, pour accéder à une composante on a besoin d'un seul indice (valeur entière). Autrement

dit : les cases sont repérées avec un seule indice qui représente une valeur entière (valeur immédiate,

constante ou variable entière, ou expression donnant un résultat entier).

3
ING / ALSD-1 Chapitre III : Type Tableau - Vecteurs & Matrices) (2022-2023)

III.2.1. Accès à un élément du tableau

En programmation un élément de tableau est désigné par le nom du tableau suivi de l'indice (la

position) de l'élément dans le tableau. Soit :

<Nom du Tableau>[<Indice de l'élément>]
Exemple :

Soit deux Tableaux V1 et V2 où V1 contient 4 composantes et V2 contient 6 composantes :

V1 :

1 2 3 4

12.50 25.75 56.00 60.25

V2 :

1 2 3 4 5 6

24.00 38.25 28.00 70.25 63.00 96.25

On a :

V1[1] = 12.55 ; V1[2] = 25.75 ; V1[3] = 56.00 ; V1[4] = 60.25

V2[1] = 24.00; V2[2] = 38.25; V2[3] = 28.00; V2[4] = 70.25; V2[5] = 63.00 ; V2[6] = 96.25 ;

III.2.2. Représentation en mémoire

Dans la mémoire centrale de l'ordinateur (RAM), un tableau est représenté sous forme d'une

succession de cellules mémoires (cases mémoires) contiguës (l'une à la suite de l'autre). L'adresse

d'un élément de tableau est obtenue par le système en utilisant l'adresse d'implantation du tableau en

mémoire auquel est ajouté la valeur de la position de l'élément par rapport au début du tableau

(l'offset de l'élément). Pour les deux tableaux V1 et V2, on aura cette représentation en mémoire :

Adresses Mémoire
0000
0001
0002
…....
…....

4
ING / ALSD-1 Chapitre III : Type Tableau - Vecteurs & Matrices) (2022-2023)

…....
V1 0006 12.50
0007 25.75
0008 56.00
0009 60.25

….... ….
….... ….
V2 0014 24.00
0015 38.25
0016 28.00
0017 70.25
0018 63.00
0018 96.25
…....
…....

III.2.3. Déclaration d'un tableau unidimensionnel

La syntaxe à suivre pour déclarer un tableau est la suivante :

Syntaxe Algorithmique Syntaxe en C

constante const int MAX = <valeur_entière>;
MAX = <valeur_entière>
variable <type> <id_tab>[MAX];
<id_tab>:Tableau[1..MAX] de <type>;

Remarques :

✗ Ce n’est pas obligatoire d'utiliser une constante pour la taille maximale de tableau ;

cependant, c'est une bonne pratique dans la programmation

✗ La plage d'indice 1 .. MAX représente l'indice du premier élément 1 et l'indice du dernier

élément MAX.

✗ C'est pas obligatoire d'utiliser toutes les composantes du tableaux, pour cela on déclare une

variable entière N qui représente la taille du tableau à utiliser. La valeur de cette variable

5
ING / ALSD-1 Chapitre III : Type Tableau - Vecteurs & Matrices) (2022-2023)

sera introduite au cours de l'exécution (par lecture)

Exemple :
constante const int MAX = 50;
MAX = 50
variable
V:Tableau[1..MAX] de réel; real V[MAX];

V est un tableau de 50 composantes réelles (c'est comme si on a déclaré 50 variables réelles)

III.2.4. Initialisation d'un tableau unidimensionnel

Un tableau peut être initialisé en utilisant deux méthodes :

– En utilisant des affectations ;

– En utilisant la lecture à partir d'un fichier de données ou à partir de clavier.

a) Par affectations : On utilise pour cela l'opération d'affectation.

Exemple :

V[1] := 24.00; V[2] := 38.25; V[3] := 28.00; V[4] := 70.25; V[5] := 63.00 ; V[6] := 96.25;

b) Par lecture : On utilise pour cela l'opération de lecture : C'est la méthode la plus commode.

Exemple1 : Exemple d'algorithme / programme C permettant de lire et d'écrire (afficher) le tableau

précédent :
algorithme LireEcrireTableau ;
variables #include <stdio.h>
v:tableau[1..6] de réel int main()
i:entier {
Début float V[6];
écrire('Introduire V :'); int i;
pour i:=1 à 6 faire
lire(v[i]); printf("Introduire V : \n");
fin-Pour; for (i=0; i<6; i++)
écrire('Affichage de V :'); scanf ("%f", V[i]);
pour i:=1 à 6 faire printf ("Affichage V : \n") ;
écrire(v[i]); for (i=0; i<6; i++)
fin-Pour; printf ("%.2f ",V[i]);
Fin; }

À l'exécution : (RUN ou exécuter)

Introduire V :
12.50 12.75 56 60.25 36.75 65
Affichage V :
12.50 12.75 56 60.25 36.75 65

6
ING / ALSD-1 Chapitre III : Type Tableau - Vecteurs & Matrices) (2022-2023)

Exemple 2 : Lecture et écriture d'un tableau de N éléments.

algorithme LireEcrireTableau
variables #include <stdio.h>
V:Tableau[1..100] de réel
N, i:entier int main()
{
Début float V[100];
écrire('Introduire nbre d'éléments N : ') int N, i;
lire (N) printf("Introduire nbre d'éléments N : \n");
écrire('Introduire V : ') scanf ("%d" , &N);
pour i:=1 à N faire
lire (V[I]); printf("Introduire V : \n");
finPour; for (i=0; i<N ; i++)
écrire ('Affichage de V : ') ; scanf ("%f", &V[i]);
pour i:=1 à N faire printf("Affichage du V : \n") ;
écrire (V[I]); for (i=0; i<N ; i++)
finPour; printf ("%.2f", V[i]);
Fin. }

À l'exécution : (RUN ou exécuter)

Introduire le nbre d'éléments N :
6
Introduire les composantes du Tableau V :
12.50 12.75 56 60.25 36.75 65
Affichage du V :
12.50 12.75 56 60.25 36.75 65

III.2.5. Manipulation de Tableaux unidimensionnels (Vecteurs)

Les tableaux ont une grande importance en informatique, la quasi-totalité des problèmes utilisent

des structures de données sous forme de tableaux. On peut en citer le domaine du calcul matriciel,

les statistiques, les traitement de gestion, etc. La gestion et l'analyse de données nécessitent

l'organisation des données dans des tableaux pour rendre possible leur traitement informatique.

Exemples : Nous allons voir quelques exemples d'algorithmes pour les tableaux à une seule

dimension (Vecteurs).

7
ING / ALSD-1 Chapitre III : Type Tableau - Vecteurs & Matrices) (2022-2023)

a) Somme de deux Vecteurs V1 et V2

Algorithme Somme
Variables #include <stdio.h>
V1,V2,V:Tableau[1..100] de réel;
N, i:entier; int main()
Début {
float V1[100], V2[100], V[100];
Lire (N); int N, i;
pour i=1 à N faire
Lire (V1[i]); printf("Introduire nbre d'éléments N : \n");
FinPour; scanf ("%d" , &N);

pour i=1 à N faire printf("Introduire V1 : \n");

Lire (V2[i]); for (i=0; i<N ; i++)
FinPour; scanf ("%f", &V1[i]);

printf("Introduire V2 : \n");
pour i=1 à N faire for (i=0; i<N ; i++)
V[i] ← V1[i] + V2[i]; scanf ("%f", &V2[i]);
FinPour;
for (i=0; i<N ; i++)
V[i] = V1[i] + V2[i];
pour i=1 à N faire
Écrire (V[i]); printf("Affichage du V : \n") ;
FinPour; for (i=0; i<N ; i++)
Fin. printf ("%.2f", V[i]);
}

b) Produit scalaire de deux vecteurs V1 et V2

Algorithme ProduitScalaire; #include <stdio.h>

Variables int main()

V1, V2 : Tableau [1..100] de réel; {
N, i:entier; float V1[100], V2[100], V[100];
PS : réel; int N, i;
Début
Lire (N) printf("Introduire nbre d'éléments N : \n");
pour i=1 à N faire scanf ("%d" , &N);
Lire (V1[i]);
Fin-Pour; printf("Introduire V1 : \n");
pour i=1 à N faire for (i=0; i<N ; i++)
Lire (V2[i]); scanf ("%f", &V1[i]);
Fin-Pour;
printf("Introduire V2 : \n");
PS ← 0; for (i=0; i<N ; i++)
pour i=1 à N faire scanf ("%f", &V2[i]);
PS ← PS + V1[i] * V2[i];
FinPour; Ps = 0;
for (i=0; i<N ; i++)
Écrire(PS); V[i] += V1[i]*V2[i];
Fin
printf ("Produit scalaire %.2f", Ps);
}

8
ING / ALSD-1 Chapitre III : Type Tableau - Vecteurs & Matrices) (2022-2023)

c) Recherche d'un élément dans un tableau

Chercher un élément val dans un tableau à une dimension (vecteur). S'il existe on récupère son
rang.
Algorithme Recherche;
Variables #include <stdio.h>
V:Tableau[1..100] de reel; #include <stdbool.h>
Val : reel;
N, I, R:entier; int main()
Trouve : boolean; {
Début float V[100], val;
Lire (N); int n, i, pos;
pour i=1 à N faire bool trouve;
Lire (V1[i]);
FinPour printf("Donenr la taille de V : \n");
Lire (Val); scanf ("%d" , &n);
printf("Introduire V1 : \n");
i ← 1 ; for (i=0; i<n ; i++)
Trouve ← Faux; scanf ("%f", &V[i]);
TantQue (i<=N) et (Trouve=Faux) faire scanf("%f", &val);
Si V[i] = Val Alors
Trouve ← Vrai; i=0; trouve=false;
R ← i; while ((i<n) && (!trouve)){
FinSi if (V[i] == val){
i ← i + 1; trouve=true; pos = i;
Fin-Tant-Que; }
i++;
Si Trouve = Vrai Alors }
Écrire('La valeur ',Val,' exist.');
Écrire('Son Rang est : ', R); if (trouve)
Sinon printf("La valeur %f existe à la position = %d", val, pos) ;
Écrire(Val,' n''existe pas dans V.'); else
FinSi; printf("La valeur %f n’existe pas dans V", val);
Fin; }

d) Recherche du maximum dans un tableau unidimensionnel

Soient deux tableaux NOMS et NOTES contenant respectivement des noms d'étudiants et leurs
notes respectives, on veut sélectionner la meilleurs note de l'étudiant correspondant.
Algorithme Maximum; #include <stdio.h>
Variables int main()
Noms : Tableau[1..100] de chaîne; {
Notes : Tableau[1..100] de réel ; char Noms[100][100];
N, i, imax : entier; float Notes[100];
max : réel; int n, i, imax;
Début float max;
Lire (N); scanf ("%d", &n);
pour i=1 à N faire for (i=0; i<n; i++) {
Lire (Noms[i]); scanf ("%[^\n]", &Noms[i]);
Lire (Notes[i]); scanf ("%f", &Notes[i]);
Fin-Pour; }
max ← Notes[1]; imax ← 1;
max=Notes[0] ; imax=1;
pour i←2 à N faire
for (i=1; i<n; i++)
si Notes[i] > max then
{
max ← Notes[i];
if (Notes[i] > max) {
imax ← i;
max = Notes[i]; imax=i;
fin-si;
}
Fin-Pour;
}
Écrire('L''étudiant : ', Noms[imax]);
write("L'étudiant : %s", Noms[imax]);
Écrire(' a obtenu la meilleur note :');
write("a obtenu la meilleur note :%.2f", max) ;
Écrire (max);
}
Fin.

9
ING / ALSD-1 Chapitre III : Type Tableau - Vecteurs & Matrices) (2022-2023)

e) L'algorithme de Tri par sélection (permutations)

– Méthode de Tri Simple (Tri croissant)
Algorithme Tri_Selection; #include <stdio.h>
Variables int main()
T:Tableau[1..100] de reel; {
I, J, N:entier; float T[100];
Z : real; int i, j, n;
Début float Z:real;
Lire (N);
pour i=1 à N faire scanf("%d", &n);
Lire (T[i]); for (i=0; i<n; i++)
Fin-Pour; Read("%f", &T[i]);

pour i=1 à N-1 faire for (i=0; i<(n-1); i++)

pour j=(i+1) à N faire for (j=i+1; j<n; j++)
Si T[I] > T[J] Alors if (T[i] > T[j])
Z ← T[I]; {
T[I] ← T[J]; Z = T[i];
T[J] ← Z; T[i] = T[j];
Fin-Si; T[j] = z;
Fin-Pour; }
Fin-Pour;
for (i=0; i<n; i++)
pour i=1 à N faire printf("%.2f ", T[i]);
Ecrire (T[I]); }
Fin-Pour;
Fin;

10
ING / ALSD-1 Chapitre III : Type Tableau - Vecteurs & Matrices) (2022-2023)

III.3. Les tableaux bidimensionnels (Matrices)

III.3.1. Présentation de tableaux bidimensionnels

Un tableau est dit bidimensionnels (ou à deux dimensions), si chacun des ses éléments

(composant) est repéré par un couple d'indices (i, j) où i est le numéro de la ligne et j est le numéro

de la colonne où l'élément est situé. Ce type de tableau est appelé Matrice.

Soit la matrice A suivant :

A= 14.32 14.50 14.25 25.84

15.26 15.65 12.23 15.36

12.25 16.23 10.20 15.63

peut être représentée par une tableau bidimensionnels (avec deux dimensions) de trois ligne et

quatre colonnes :

A= 1 2 3 4
1 14.32 14.50 14.25 25.84
2 15.26 15.65 12.23 15.36
3 12.25 16.23 10.20 15.63

III.3.2. Déclaration de tableaux bidimensionnels

Pour déclarer la matrice A définie précédemment, on a deux façons :

1ère Façon :

ALGORITHME LANGAGE C
Variables
A:Tableau[1..3,1..4] de Réel float A[3][4];

Exemples

Une chaîne de 28 magasins, chacun comportant 4 rayons. On veut établir l'état des ventes
hebdomadaires. Ces données sont ensuite entrées dans un ordinateurs en utilisant un tableau à deux
dimensions où le premier indices repère le magasin et le second le rayon. Si VENTES est le nom du
tableau, décrire cette représentation des données.

11
ING / ALSD-1 Chapitre III : Type Tableau - Vecteurs & Matrices) (2022-2023)

VENTES 01 02 03 04
01 2872 805 3211 1560
02 2196 1225 2525 1477
03 3257 1017 3687 1951
…. …. …. …. ….
…. …. …. …. ….
…. …. …. …. ….
…. …. …. …. ….
28 2618 913 2333 982
Variables
VENTES : Tableau[1..28,1..4] de Entier

III.3.2. Lecture et affichage d'une matrice

L'algorithme (respectivement, le programme ) suivant permet de lire et d'écrire une matrice de n

ligne et m colonnes :
Algorithme LectureAffichageMatrice
Variables
mat:tableau [1..10, 1..10] de réel; #include <stdio.h>
N,M, i,j:entier; int main()
Début {
Lire (N, M); float mat[10][10];
pour i=1 à N faire int i, j, n, m;
Pour j=1 à M faire
Lire (mat[i, j]); scanf("%d %d", &n, &m);
FinPour; for (i=0; i<n; i++)
FinPour; for (j=0; j<n; j++)
scanf("%f", &mat[i][j]);
pour i=1 à N faire
Pour j=1 à M faire for (i=0; i<n; i++)
Écrire (mat[i, j]); for (j=0; j<n; j++)
FinPour; printf("%8.2f", mat[i][j]);
FinPour; }
Fin. }

On doit introduire le nombre de lignes n et le nombre de colonnes m. par la suite on introduit les

éléments de la matrice mat[i,j] / i=1...n et j=1..m

12
ING / ALSD-1 Chapitre III : Type Tableau - Vecteurs & Matrices) (2022-2023)

III.3.3. Manipulation de matrice

a) Lire et écrire un tableau bidimensionnels

Algorithme LectureEcritureMatrice #include <stdio.h>
Variables int main()
mat:tableau [1..10, 1..10] de reel; {
N,M, i,j:entier; float mat[10][10];
Début int i, j, n, m;
Lire (N, M);
pour i=1 à N faire printf("Donner n et m :");
Pour j=1 à M faire scanf("%d %d", &n, &m);
Lire (mat[i, j]); for (i=0; i<n; i++)
FinPour; for (j=0; j<m; j++)
FinPour; scanf("%f", &mat[i][j]);

pour i=1 à N faire printf("Affichage de la matrice mat :\n");

Pour j=1 à M faire for (i=0; i<n; i++) {
Écrire (mat[i, j]); for (j=0; j<m; j++)
FinPour; printf("%8.2f", mat[i][j]);
FinPour;
Fin. printf("\n");//Saut de ligne
}
}

b) Produit d'une matrice par un vecteur

(le nombre de colonne de la matrice = le nombre de composantes du vecteur)
Algorithme ProduitMatVect; #include <stdio.h>
Variables
mat : tableau [1..10, 1..10] de reel; int main()
vect : tableau [1..10] de reel; {
p : tableau [1..10] de reel; float mat[10][10],vect[10], p[10];
N,M, i,j:entier; int i, j, n, m;
Début
Lire (N, M); printf("Introduire la taille de MAT : ");
pour i=1 à N faire scanf("%d %d", &n, &m);
Pour j=1 à M faire printf("Introduire les valeurs de MAT : \n");
Lire (mat[i, j]); for (i=0; i<n; i++)
FinPour; for (j=0; j<m; j++)
FinPour; scanf("%f", &mat[i][j]);
pour i=1 à M faire printf("Introduire les valeurs de VECT : \n");
Lire(vect[i]); for (j=0; j<m; j++)
finPour scanf("%f", &vect[j]);
pour i=1 à N faire
p[i] = 0; for (i=0; i<n; i++) {
Pour j=1 à M faire p[i] = 0;
P[i] ← p[i] + mat[i, j]*vect[j]; for (j=0; j<m; j++)
FinPour; p[i] += mat[i][j] * vect[j];
FinPour; }
pour i=1 à N faire
Écrire(p[i]); printf("Produit P = MatxVect : \n");
finPour; for (i=0; i<n; i++)
Fin. printf("%8.2f", p[i]);
}

13
ING / ALSD-1 Chapitre III : Type Tableau - Vecteurs & Matrices) (2022-2023)

c) Compter le nombre d'éléments négatifs, positifs et nuls dans une matrice

Algorithme compteurPNN #include <stdio.h>
Variables
mat : tableau [1..10, 1..10] de reel; int main()
N,M, i,j:entier {
nbP, nbN, nbNul : entier; float mat[10][10];
Début int i, j, n, m;
Lire (N, M); int nbP, nbN, nbNul;
pour i=1 à N faire
Pour j=1 à M faire printf("Introduire la taille de MAT : ");
Lire (mat[i, j]); scanf("%d %d", &n, &m);
FinPour; printf("Introduire les valeurs de MAT : \n");
FinPour; for (i=0; i<n; i++)
nbP ← 0; nbN ←
0; nbNul 0; ← for (j=0; j<m; j++)
scanf("%f", &mat[i][j]);
pour i=1 à N faire
Pour j=1 à M faire nbP = 0; nbN=0; nbNul=0;
Si mat[i, j] > 0 Alors
nbP ← nbP + 1; for (i=0; i<n; i++)
Sinon for (j=0; j<m; j++)
Si mat[i,j] < 0 Alors if (mat[i][j] > 0)
nbP++;
nbN ← nbN + 1; else if (mat[i][j] < 0)
Sinon nbN++;
nbNul ← nbNul + 1; else
FinSi; nbNul++;
FinSi;
FinPour; printf("Nb valeurs positives %d : \n", nbP);
FinPour; printf("Nb valeurs négatives %d : \n", nbN);
printf("Nb valeurs nulles %d : \n", nbNul);
Écrire (nbP, nbN, nbNul); }
Fin.

nbP est le compteur des nombres positifs, nbN est le compteur des nombre négatifs et nbNul est
le compteur des nombre nuls.

14
ING / ALSD-1 Chapitre III : Type Tableau - Vecteurs & Matrices) (2022-2023)

d) Produit de deux matrices

Le nombre de colonne de la première matrice = le nombre de ligne de la deuxième matrice
Algorithme compteurPNN #include <stdio.h>
Variables int main()
m1,m2 : tableau [1..10, 1..10] de reel {
N,M, L, i,j, k:entier float m1[10][10], m2[10][10];
Result:tableau [1..10, 1..10] de reel int N,M, L, i,j, k;
Début float Result[10][10];
Lire (N, M, L);
pour i=1 à N faire printf("Donnez les dim. de m1 : ");
Pour j=1 à M faire scanf ("%d %d", &N, &M);
Lire (m1[i, j]); printf('Donnez le nbre de colonnes de m2 : ');
FinPour; scanf ("%d", &L);
FinPour;
for (i=0; i<N ; i++)
pour i=1 à M faire for (j=0; j<M ; j++)
Pour j=1 à L faire scanf("%f", &m1[i][j]);
Lire (m2[i, j]);
FinPour; for (i=0; i<M ; i++)
FinPour; for (j=0; j<L ; j++)
scanf("%f", &m2[i][j]);
pour i=1 à N faire
Pour j=1 à L faire for (i=0; i<M ; i++)
Result[i, j] ←
0; for (j=0; j<L ; j++)
{
pour k=1 à M faire Result[i, j] = 0;
←
Result[i,j] Result[i,j]+ for (k=0; k<M ; k++)
m1[i,k]*m2[k,j]; Result[i,j] += m1[i,k]*m2[k,j];
finPour; }
FinPour;
FinPour; printf("La matrice Resultat=M1xM2 est :\n");
for (i=0; i<M ; i++)
pour i=1 à N faire {
Pour j=1 à L faire for (j=0 ; j<L ; j++)
Écrire (Result[i, j]); printf("%8.2f", Result[i,j]);
FinPour; printf("\n"); //Saut de ligne
FinPour; }
Fin. }

Pour réaliser le produit des deux matrices m1 et m2, il faut que le nombre de colonne de m1 soit

égale au nombre de ligne de m2. Le résultat est une matrice Result dont le nombre de ligne est le

même qui celui de m1 et le nombre de colonne est le même qui celui de m2.
Result(N, L) = m1(N, M) * m2 (M, L)
✗ Result est une matrice de N lignes et L colonnes
✗ m1 est une matrice de N lignes et M colonnes
✗ m2 est une matrice de M lignes et L colonnes
✗ L'élément Result[i, j] est calculé comme suit :
Result[i, j] = m1[i, 1] * m2[1, j] + m1[i, 2] * m2[2, j] + m1[i, 3] * m2[3, j] +
M
…............. + m1[i, M] * m2[M, j] = Σ
k=1 m1[i, k] * m2[k, j]

15