TP C :

TABLEAUX

Exo1 : Maximum et minimum des valeurs d'un tableau

Ecrire un programme qui dtermine la plus grande et la plus petite valeur dans un tableau d'entiers A.
Afficher ensuite la valeur et la position du maximum et du minimum. Si le tableau contient plusieurs
maxima ou minima, le programme retiendra la position du premier maximum ou minimum rencontr.
#include <stdio.h>
main()
{
/* Dclarations */
int A[50]; /* tableau donn */
int N;
/* dimension
*/
int I;
/* indice courant */
int MIN;
/* position du minimum */
int MAX;
/* position du maximum */
/* Saisie des donnes */
printf("Dimension du tableau (max.50) : ");
scanf("%d", &N );
for (I=0; I<N; I++)
{
printf("Element %d : ", I);
scanf("%d", &A[I]);
}
/* Affichage du tableau */
printf("Tableau donne :\n");
for (I=0; I<N; I++)
printf("%d ", A[I]);
printf("\n");
/* Recherche du maximum et du minimum */
MIN=0;
MAX=0;
for (I=0; I<N; I++)
{
if(A[I]>A[MAX]) MAX=I;
if(A[I]<A[MIN]) MIN=I;
}
/* Edition du rsultat */
printf("Position du minimum : %d\n", MIN);
printf("Position du maximum : %d\n", MAX);
printf("Valeur
du minimum : %d\n", A[MIN]);
printf("Valeur
du maximum : %d\n", A[MAX]);
return 0;
}

Exo 2 : Insrer une valeur dans un tableau tri

Un tableau A de dimension N+1 contient N valeurs entires tries par ordre croissant; la (N+1) ime valeur est indfinie.
Insrer une valeur VAL donne au clavier dans le tableau A de manire obtenir un tableau de N+1 valeurs tries.
Soit : 5 6 9 et 7 la valeur insrer

Correction TP

04 12 2006

#include <stdio.h>
main()
{
/* Dclarations */
int A[50]; /* tableau donn
int VAL;
/* valeur insrer
int N;
/* dimension
int I;
/* indice courant

*/
*/
*/
*/

/* Saisie des donnes */

printf("Dimension N du tableau initial (max.50) : ");
scanf("%d", &N );
for (I=0; I<N; I++)
{
printf("Element %d : ", I);
scanf("%d", &A[I]);
}
printf("Element a inserer : ");
scanf("%d", &VAL );
/* Affichage du tableau */
printf("Tableau donne : \n");
for (I=0; I<N; I++)
printf("%d ", A[I]);
printf("\n");
/* Dplacer les lments plus grands que */
/* VAL d'une position vers l'arrire.
*/
for (I=N ; (I>0) && (A[I-1] > VAL) ; I--)
A[I]=A[I-1];
/* VAL est copi la position du dernier */
/* lment dplac. */
A[I]=VAL;
/* Nouvelle dimension du tableau ! */
N++;
/* Edition des rsultats */
printf("Tableau resultat :\n");
for (I=0; I<N; I++)
printf("%d ", A[I]);
printf("\n");
return 0;

Exo 3 : Fusion de deux tableaux tris

Problme: On dispose de deux tableaux A et B (de dimensions respectives N et M), tris par ordre croissant.
Fusionner les lments de A et B dans un troisime tableau FUS tri par ordre croissant.
Mthode: Utiliser trois indices IA, IB et IFUS. Comparer A[IA] et B[IB]; remplacer FUS[IFUS] par le plus
petit des deux lments; avancer dans le tableau FUS et dans le tableau qui a contribu son lment.
Lorsque l'un des deux tableaux A ou B est puis, il suffit de recopier les lments restants de l'autre tableau
dans le tableau FUS.
main()
{
/* Dclarations */
/* Les tableaux et leurs dimensions */
int A[50], B[50], FUS[100];
int N, M;
int IA, IB, IFUS; /* indices courants */
/* Saisie des donnes */
printf("Dimension du tableau A (max.50) : ");
scanf("%d", &N );
printf("Entrer les lments de A dans l'ordre croissant :\n");
Correction TP

04 12 2006

for (IA=0; IA<N; IA++)

{
printf("Elment A[%d] : ",
scanf("%d", &A[IA]);
}
printf("Dimension du tableau B
scanf("%d", &M );
printf("Entrer les lments de
for (IB=0; IB<M; IB++)
{
printf("Elment B[%d] : ",
scanf("%d", &B[IB]);
}
/* Affichage des tableaux A et
printf("Tableau A :\n");
for (IA=0; IA<N; IA++)
printf("%d ", A[IA]);
printf("\n");
printf("Tableau B :\n");
for (IB=0; IB<M; IB++)
printf("%d ", B[IB]);
printf("\n");

IA);
(max.50) : ");
B dans l'ordre croissant :\n");
IB);
B */

/* Fusion des lments de A et B dans FUS */

/* de faon ce que FUS soit aussi tri. */
IA=0; IB=0; IFUS=0;
while ((IA<N) && (IB<M))
if(A[IA]<B[IB])
{
FUS[IFUS]=A[IA];
IFUS++;
IA++;
}
else
{
FUS[IFUS]=B[IB];
IFUS++;
IB++;
}
/* Si IA ou IB sont arrivs la fin de leur tableau, */
/* alors copier le reste de l'autre tableau.
*/
while (IA<N)
{
FUS[IFUS]=A[IA];
IFUS++;
IA++;
}
while (IB<M)
{
FUS[IFUS]=B[IB];
IFUS++;
IB++;
}
/* Edition du rsultat */
printf("Tableau FUS :\n");
for (IFUS=0; IFUS<N+M; IFUS++)
printf("%d ", FUS[IFUS]);
printf("\n");
return 0;
}
Correction TP

04 12 2006

Exo 4 : Recherche d'une valeur dans un tableau

Problme: Rechercher dans un tableau d'entiers A une valeur VAL entre au clavier. Afficher la premire
position de VAL si elle se trouve dans le tableau, sinon afficher un message correspondant. La valeur POS
qui est utilise pour mmoriser la position de la valeur dans le tableau, aura la valeur -1 aussi longtemps que
VAL n'a pas t trouve.
Implmenter deux versions:
a) La recherche squentielle
Comparer successivement les valeurs du tableau avec la valeur donne.
b) La recherche dichotomique ('recherche binaire', 'binary search')
Condition: Le tableau A doit tre tri
Comparer le nombre recherch la valeur au milieu du tableau,
- s'il y a galit ou si le tableau est puis, arrter le traitement avec un message correspondant.
- si la valeur recherche prcde la valeur actuelle du tableau, continuer la recherche dans le demi-tableau
gauche de la position actuelle.
- si la valeur recherche suit la valeur actuelle du tableau, continuer la recherche dans le demi-tableau
droite de la position actuelle.
Ecrire le programme pour le cas o le tableau A est tri par ordre croissant.
Question: Quel est l'avantage de la recherche dichotomique? Expliquer brivement.
La recherche squentielle
Comparer successivement les valeurs du tableau avec la valeur donne.

a) La recherche squentielle
#include <stdio.h>
main()
{
/* Dclarations */
int A[50]; /* tableau donn */
int VAL; /* valeur rechercher */
int POS; /* position de la valeur */
int N; /* dimension
*/
int I; /* indice courant */
/* Saisie des donnes */
printf("Dimension du tableau (max.50) : ");
scanf("%d", &N );
for (I=0; I<N; I++)
{
printf("Element %d : ", I);
scanf("%d", &A[I]);
}
printf("Element a rechercher : ");
scanf("%d", &VAL );

Correction TP

04 12 2006

/* Affichage du tableau */
printf("Tableau donne : \n");
for (I=0; I<N; I++)
printf("%d ", A[I]);
printf("\n");
/* Recherche de la position de la valeur */
POS = -1;
for (I=0 ; (I<N)&&(POS==-1) ; I++)
if (A[I]==VAL)
POS=I;
/* Edition du rsultat */
if (POS==-1)
printf("La valeur recherchee ne se trouve pas "
"dans le tableau.\n");
else
printf("La premiere valeur %d se trouve a la
position %d. \n",
VAL, POS);
return 0;
}

b) La recherche dichotomique ('recherche binaire', 'binary search')

Lalgorithme le plus intuitif pour lillustrer est le suivant :
Min -->1
Max --> Taille
Mil --> (Min+Max)/2
/*Mil=milieu*/
Tant que (Mil <> Min) Faire
Si (T [Mil] > Val)
Max --> Mil
else
Min --> Mil
Mil --> (Min+max)/2
Fin SI
Fin Tant que

Cela signifie que si la valeur existe dans le tableau, elle

ne se situe pas dans la partie situe entre sa moiti et sa
fin. Nous n'avons donc plus besoin de ce morceau.
Nous allons donc redfinir notre dlimiteur de fin
(Max) pour qu'il vienne se placer au niveau du Milieu
du tableau (fournit par Mil).
Max=Mil
Sinon, dans le cas inverse, c'est notre dlimiteur de
dbut que devra se dplacer.
Min=Mil
Le tout devant tre rpt dans une boucle qui se
terminera quand Mil et Min seront gaux

#include <stdio.h>
main()
{
/* Dclarations */
int A[50]; /* tableau donn */
int VAL;
/* valeur rechercher
*/
int POS;
/* position de la valeur */
int N;
/* dimension
*/
int I;
/* indice courant */
int INF, MIL, SUP; /* limites du champ de recherche */
/* Saisie des donnes */
printf("Dimension du tableau (max.50) : ");
scanf("%d", &N );
for (I=0; I<N; I++)
{
printf("Elment %d : ", I);
scanf("%d", &A[I]);
}
printf("Elment rechercher : ");
scanf("%d", &VAL );
/* Affichage du tableau */
printf("Tableau donn : \n");
for (I=0; I<N; I++)
printf("%d ", A[I]);
printf("\n");
/* Initialisation des limites du domaine de recherche */
INF=0;
SUP=N-1;
/* Recherche de la position de la valeur */
POS=-1;
while ((INF<=SUP) && (POS==-1))
{
MIL=(SUP+INF)/2;
if (VAL < A[MIL])
SUP=MIL-1;
else if (VAL > A[MIL])
INF=MIL+1;
else
Correction TP

04 12 2006

POS=MIL;

/* Edition du rsultat */
if (POS==-1)
printf("La valeur recherche ne se trouve pas "
"dans le tableau.\n");
else
printf("La valeur %d se trouve la position %d. \n",
VAL, POS);
return 0;

Question: Quel est l'avantage de la recherche dichotomique?

Dans le pire des cas d'une recherche squentielle, il faut traverser tout le tableau avant de trouver la valeur
ou avant d'tre sr qu'une valeur ne se trouve pas dans le tableau.

Ce type de recherche impose un nombre de tests compris entre 1 (si l'lment recherch est en
1re position) et N (si l'lment recherch est en dernire position), pour une moyenne de
(1+2+...+N)/N = [(1+N)N/2]/N = (1+N)/2 tests.
Lorsque l'information contenue dans le tableau n'est pas trie ou trie suivant un critre qu'il
n'est pas possible d'exploiter, cette recherche est la seule possible mais si le tableau est tri sur
un critre exploitable, nous allons pouvoir diminuer notablement le nombre d'oprations
effectuer par une recherche dichotomique.
Lors de la recherche dichotomique, on limine la moiti des lments du tableau chaque excution de la
boucle. Ainsi, la recherche se termine beaucoup plus rapidement.

Nous pouvons constater qu' la premire tape, nous devions prendre le milieu d'un tableau de
N lments, l'tape suivante le milieu d'un tableau de N/2 lments, puis de N/4 lments, ...
Dans le plus mauvais des cas, la recherche s'arrte quand le nombre d'lments est rduit 1 et
donc quand N/2k<=1 ou quand N<=2k c'est--dire quand k est le plus petit entier>=log 2N.
Rappel :
Dfinition
Un nombre X lev une puissance n donne un rsultat Y : y = xn.
La puissance n reprsente le logarithme de Y en base X.
Exemples
103 = 1000, 24 = 16.
Le logarithme de 1000 en base 10 est 3.
Le logarithme de 16 en base 2 est 4.
log 2 2n = n
La recherche dichotomique devient extrmement avantageuse pour la recherche dans de grands tableaux
(tris) : L'avantage de la recherche dichotomique par rapport la recherche squentielle monte alors
exponentiellement avec la grandeur du tableau trier.
Exemple:

Lors de la recherche dans un tableau de 1024 lments:

- le pire des cas pour la recherche squentielle peut entraner 1024 excutions de la boucle.
- le pire des cas pour la recherche dichotomique peut entraner 10 excutions de la boucle.
Lors de la recherche dans un tableau de 1 048 576 lments:
- le pire des cas pour la recherche squentielle peut entraner 1 048 576 excutions de la boucle.
Correction TP

04 12 2006

- le pire des cas pour la recherche dichotomique peut entraner 20 excutions de la boucle.

Correction TP

04 12 2006

Exo 5 : Tri par slection du maximum

Problme: Classer les lments d'un tableau A par ordre dcroissant.
Mthode: Parcourir le tableau de gauche droite l'aide de l'indice I. Pour chaque lment A[I] du tableau,
dterminer la position PMAX du (premier) maximum droite de A[I] et changer A[I] et A[PMAX].
Exemple:

#include <stdio.h>
main()
{
/* Dclarations */
int A[50]; /* tableau donn */
int N;
/* dimension
*/
int I;
/* rang partir duquel A n'est pas tri */
int J;
/* indice courant
*/
int TEMP; /* pour la permutation */
int PMAX; /* indique la position de l'lment */
/* maximal droite de A[I]
*/
/* Saisie des donnes */
printf("Dimension du tableau (max.50) : ");
scanf("%d", &N );
for (J=0; J<N; J++)
{
printf("Element %d : ", J);
scanf("%d", &A[J]);
}
/* Affichage du tableau */
printf("Tableau donne :\n");
for (J=0; J<N; J++)
printf("%d ", A[J]);
printf("\n");
/* Tri du tableau par slection directe du maximum. */
for (I=0; I<N-1; I++)
{
/* Recherche du maximum droite de A[I] */
PMAX=I;
for (J=I+1; J<N; J++)
if (A[J]>A[PMAX]) PMAX=J;
/* Echange de A[I] avec le maximum */
TEMP=A[I];
A[I]=A[PMAX];
Correction TP

04 12 2006

A[PMAX]=TEMP;

/* Edition du rsultat */
printf("Tableau trie :\n");
for (J=0; J<N; J++)
printf("%d ", A[J]);
printf("\n");
return 0;

Tableaux 2 dimensions
Exo 6 :
Mise zro de la diagonale principale d'une matrice
Ecrire un programme qui met zro les lments de la diagonale principale d'une matrice carre A donne.
#include <stdio.h>
main()
{
/* Dclarations */
int A[50][50]; /* matrice carre */
int N;
/* dimension de la matrice carre */
int I, J;
/* indices courants */
/* Saisie des donnes */
printf("Dimension de la matrice carree (max.50) : ");
scanf("%d", &N);
for (I=0; I<N; I++)
for (J=0; J<N; J++)
{
printf("Element[%d][%d] : ",I,J);
scanf("%d", &A[I][J]);
}
/* Affichage de la matrice */
printf("Matrice donnee :\n");
for (I=0; I<N; I++)
{
for (J=0; J<N; J++)
printf("%7d", A[I][J]);
printf("\n");
}
/* Mise zro de la diagonale principale */
for (I=0; I<N; I++)
A[I][I]=0;
/* Edition du rsultat */
printf("Matrice resultat :\n");
for (I=0; I<N; I++)
{
for (J=0; J<N; J++)
printf("%7d", A[I][J]);
printf("\n");
}
return 0;
}
Correction TP

04 12 2006

Exo 7 : Matrice unitaire

Ecrire un programme qui construit et affiche une matrice carre unitaire U de dimension N. Une matrice
unitaire est une matrice, telle que:

uij =

/1
|
\0

si i = j
si i j

#include <stdio.h>
main()
{
/* Dclarations */
int U[50][50]; /* matrice unitaire */
int N;
/* dimension de la matrice unitaire */
int I, J;
/* indices courants */
/* Saisie des donnes */
printf("Dimension de la matrice carree (max.50) : ");
scanf("%d", &N);
/* Construction de la matrice carre unitaire */
for (I=0; I<N; I++)
for (J=0; J<N; J++)
if (I==J)
U[I][J]=1;
else
U[I][J]=0;
/* Edition du rsultat */
printf("Matrice unitaire de dimension %d :\n", N);
for (I=0; I<N; I++)
{
for (J=0; J<N; J++)
printf("%7d", U[I][J]);
printf("\n");
}
return 0;
}
Remarque :
L'opration:
if (I==J)
U[I][J]=1;
else
U[I][J]=0;
peut tre simplifie par:
U[I][J] = (I==J);

Correction TP

04 12 2006

10

Exo 8 : Transposition d'une matrice

Ecrire un programme qui effectue la transposition tA d'une matrice A de dimensions N et M en une matrice
de dimensions M et N.
a) La matrice transpose sera mmorise dans une deuxime matrice B qui sera ensuite affiche.
b) La matrice A sera transpose par permutation des lments.
Rappel:
tA =

/
\
t | a b c d |
| e f g h |
| i j k l |
\
/

/
|
|
|
|
\

a
b
c
d

e
f
g
h

i
j
k
l

\
|
|
|
|
/

a)- La matrice transpose sera mmorise dans une deuxime matrice B qui sera ensuite affiche.
#include <stdio.h>
main()
{/* Dclarations */
int A[50][50]; /* matrice initiale */
int B[50][50]; /* matrice rsultat */
int N, M;
/* dimensions des matrices */
int I, J;
/* indices courants */
/* Saisie des donnes */
printf("Nombre de lignes (max.50) : ");
scanf("%d", &N );
printf("Nombre de colonnes (max.50) : ");
scanf("%d", &M );
for (I=0; I<N; I++)
for (J=0; J<M; J++)
{
printf("Element[%d][%d] : ",I,J);
scanf("%d", &A[I][J]);
}
/* Affichage de la matrice */
printf("Matrice donnee :\n");
for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("%7d", A[I][J]);
printf("\n");
}
/* Affectation de la matrice transpose B */
for (I=0; I<N; I++)
for (J=0; J<M; J++)
B[J][I]=A[I][J];
/* Edition du rsultat */
/* Attention: maintenant le rle de N et M est invers. */
printf("Matrice resultat :\n");
for (I=0; I<M; I++)
{
for (J=0; J<N; J++)
printf("%7d", B[I][J]);
printf("\n");
}
return 0;
}
Correction TP

04 12 2006

11

b)-La matrice A sera transpose par permutation des lments.

#include <stdio.h>
main()
{/* Dclarations */
int A[50][50]; /* matrice donne
*/
int N, M;
/* dimensions de la matrice */
int I, J;
/* indices courants
*/
int AIDE;
/* pour la permutation
*/
int DMAX;
/* la plus grande des deux dimensions */
/* Saisie des donnes */
printf("Nombre de lignes (max.50) : ");
scanf("%d", &N );
printf("Nombre de colonnes (max.50) : ");
scanf("%d", &M );
for (I=0; I<N; I++)
for (J=0; J<M; J++)
{
printf("Element[%d][%d] : ",I,J);
scanf("%d", &A[I][J]);
}
/* Affichage de la matrice */
printf("Matrice donnee :\n");
for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("%7d", A[I][J]);
printf("\n");
}
/* Transposition de la matrice A par permutation des */
/* lments [I][J] gauche de la diagonale principale */
/* avec les lments [J][I] droite de la diagonale. */
DMAX = (N>M) ? N : M;
for (I=0; I<DMAX; I++)
for (J=0; J<I; J++)
{
AIDE = A[I][J];
A[I][J] = A[J][I];
A[J][I] = AIDE;
}
/* Edition du rsultat */
/* Attention: maintenant le rle de N et M est invers. */
printf("Matrice resultat :\n");
for (I=0; I<M; I++)
{
for (J=0; J<N; J++)
printf("%7d", A[I][J]);
printf("\n");
}
return 0;
}

Correction TP

04 12 2006

12

Exo 9 : Multiplication d'une matrice par un rel

Ecrire un programme qui ralise la multiplication d'une matrice A par un rel X.
Rappel:
/
\
| a b c d |
X * | e f g h |
| i j k l |
\
/

/
\
| X*a X*b X*c X*d |
| X*e X*f X*g X*h |
| X*i X*j X*k X*l |
\
/

a) Le rsultat de la multiplication sera mmoris dans une deuxime matrice A qui sera ensuite affiche.
b) Les lments de la matrice A seront multiplis par X.
a)-Le rsultat de la multiplication sera mmoris dans une deuxime matrice A qui sera ensuite affiche.
#include <stdio.h>
main()
{
float A[50][50];
float B[50][50];
int N, M;
int I, J;
float X;

/* Dclarations */
/* matrice donne */
/* matrice rsultat */
/* dimensions des matrices */
/* indices courants */
/* multiplicateur */
/* Saisie des donnes */
printf("Nombre de lignes (max.50) : ");
scanf("%d", &N );
printf("Nombre de colonnes (max.50) : ");
scanf("%d", &M );
for (I=0; I<N; I++)
for (J=0; J<M; J++)
{ printf("Element[%d][%d] : ",I,J);
scanf("%f", &A[I][J]);
}
printf("Multiplicateur X : ");
scanf("%f", &X );
/* Affichage de la matrice */
printf("Matrice donnee :\n");
for (I=0; I<N; I++)
{ for (J=0; J<M; J++)
printf("%10.2f", A[I][J]);
printf("\n");
}
/* Affectation du rsultat de la multiplication B */
for (I=0; I<N; I++)
for (J=0; J<M; J++)
B[I][J] = X*A[I][J];
/* Edition du rsultat */
printf("Matrice resultat :\n");
for (I=0; I<N; I++)
{ for (J=0; J<M; J++)
printf("%10.2f", B[I][J]);
printf("\n");
}
return 0;
}
Correction TP

04 12 2006

13

b)-Les lments de la matrice A seront multiplis par X.

#include <stdio.h>
main()
{
float A[50][50];
int N, M;
int I, J;
float X;

/* Dclarations */
/* matrice donne */
/* dimensions de la matrice */
/* indices courants */
/* multiplicateur */

/* Saisie des donnes */

printf("Nombre de lignes (max.50) : ");
scanf("%d", &N );
printf("Nombre de colonnes (max.50) : ");
scanf("%d", &M );
for (I=0; I<N; I++)
for (J=0; J<M; J++)
{
printf("Element[%d][%d] : ",I,J);
scanf("%f", &A[I][J]);
}
printf("Multiplicateur X : ");
scanf("%f", &X);
/* Affichage de la matrice */
printf("Matrice donnee :\n");
for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("%10.2f", A[I][J]);
printf("\n");
}
/* Multiplication des lments de A par X */
for (I=0; I<N; I++)
for (J=0; J<M; J++)
A[I][J] *= X;
/* Edition du rsultat */
printf("Matrice resultat :\n");
for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("%10.2f", A[I][J]);
printf("\n");
}
return 0;
}

Correction TP

04 12 2006

14

Exo 10 : Addition de deux matrices

Ecrire un programme qui ralise l'addition de deux matrices A et B de mmes dimensions N et M.
Rappel:
/
\
/
\
| a b c d |
| a' b' c' d' |
| e f g h | + | e' f' g' h' |
| i j k l |
| i' j' k' l' |
\
/
\
/

/
\
| a+a' b+b' c+c' d+d' |
| e+e' f+f' g+g' h+h' |
| i+i' j+j' k+k' l+l' |
\
/

a) Le rsultat de l'addition sera mmoris dans une troisime matrice C qui sera ensuite affiche.
b) La matrice B est ajoute A.
a) Le rsultat de l'addition sera mmoris dans une troisime matrice C qui sera ensuite affiche.
#include <stdio.h>
main()
{
/* Dclarations */
int A[50][50]; /* matrice donne */
int B[50][50]; /* matrice donne */
int C[50][50]; /* matrice rsultat */
int N, M; /* dimensions des matrices */
int I, J; /* indices courants */
/* Saisie des donnes */
printf("Nombre de lignes (max.50) : ");
scanf("%d", &N );
printf("Nombre de colonnes (max.50) : ");
scanf("%d", &M );
printf("*** Matrice A ***\n");
for (I=0; I<N; I++)
for (J=0; J<M; J++)
{
printf("Element[%d][%d] : ",I,J);
scanf("%d", &A[I][J]);
}
printf("*** Matrice B ***\n");
for (I=0; I<N; I++)
for (J=0; J<M; J++)
{
printf("Element[%d][%d] : ",I,J);
scanf("%d", &B[I][J]);
}
/* Affichage des matrices */

Correction TP

04 12 2006

printf("Matrice donnee A :\n");

for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("%7d", A[I][J]);
printf("\n");
}
printf("Matrice donnee B :\n");
for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("%7d", B[I][J]);
printf("\n");
}
/* Affectation du rsultat de l'addition C */
for (I=0; I<N; I++)
for (J=0; J<M; J++)
C[I][J] = A[I][J]+B[I][J];
/* Edition du rsultat */
printf("Matrice resultat C :\n");
for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("%7d", C[I][J]);
printf("\n");
}
return 0;
}

15

b) La matrice B est ajoute A.

#include <stdio.h>
main()
{ /* Dclarations */
int A[50][50]; /* matrice donne et rsultat */
int B[50][50]; /* matrice donne */
int N, M; /* dimensions des matrices */
int I, J; /* indices courants */
/* Saisie des donnes */
printf("Nombre de lignes (max.50) : ");
scanf("%d", &N );
printf("Nombre de colonnes (max.50) : ");
scanf("%d", &M );
printf("*** Matrice A ***\n");
for (I=0; I<N; I++)
for (J=0; J<M; J++)
{
printf("Elment[%d][%d] : ",I,J);
scanf("%d", &A[I][J]);
}
printf("*** Matrice B ***\n");
for (I=0; I<N; I++)
for (J=0; J<M; J++)
{
printf("Element[%d][%d] : ",I,J);
scanf("%d", &B[I][J]);
}
/* Affichage des matrices */
printf("Matrice donnee A :\n");
for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("%7d", A[I][J]);
printf("\n");
}
printf("Matrice donnee B :\n");
for (I=0; I<N; I++)
{ for (J=0; J<M; J++)
printf("%7d", B[I][J]);
printf("\n");
}
/* Addition de B A */
for (I=0; I<N; I++)
for (J=0; J<M; J++)
A[I][J] += B[I][J];
/* Edition du rsultat */
printf("Matrice resultat A :\n");
for (I=0; I<N; I++)
{ for (J=0; J<M; J++)
printf("%7d", A[I][J]);
printf("\n");
}
return 0;
Correction TP

04 12 2006

16

Correction TP

04 12 2006

17

Exo 11 : Multiplication de deux matrices

En multipliant une matrice A de dimensions N et M avec une matrice B de dimensions M et P on obtient une
matrice C de dimensions N et P:
A(N,M) * B(M,P) = C(N,P)

La multiplication de deux matrices se fait en multipliant les composantes des deux matrices lignes par
colonnes:

Rappel:

/
|
|
|
|
\

a
e
h
k

b
f
i
l

c
g
j
m

\
|
|
|
|
/

/
\
| p q |
| r s |
| t u |
\
/

/
|
|
|
|
\

a*p
e*p
h*p
k*p

+
+
+
+

b*r
f*r
i*r
l*r

+
+
+
+

c*t
g*t
j*t
m*t

a*q
e*q
h*q
k*q

+
+
+
+

b*s
f*s
i*s
l*s

+
+
+
+

c*u
g*u
j*u
m*u

\
|
|
|
|
/

Ecrire un programme qui effectue la multiplication de deux matrices A et B. Le rsultat de la multiplication

sera mmoris dans une troisime matrice C qui sera ensuite affiche.
#include <stdio.h>
main()
{ /* Dclarations */
int A[50][50]; /* matrice donne */
int B[50][50]; /* matrice donne */
int C[50][50]; /* matrice rsultat */
int N, M, P; /* dimensions des matrices */
int I, J, K; /* indices courants */
/* Saisie des donnes */
printf("*** Matrice A ***\n");
printf("Nombre de lignes de A (max.50) : ");
scanf("%d", &N );
printf("Nombre de colonnes de A (max.50) : ");
scanf("%d", &M );
for (I=0; I<N; I++)
for (J=0; J<M; J++)
{printf("Elment[%d][%d] : ",I,J);
scanf("%d", &A[I][J]);
}
printf("*** Matrice B ***\n");
printf("Nombre de lignes de B : %d\n", M);
printf("Nombre de colonnes de B (max.50) : ");
scanf("%d", &P );
for (I=0; I<M; I++)
for (J=0; J<P; J++)
{ printf("Element[%d][%d] : ",I,J);
scanf("%d", &B[I][J]);
}
/* Affichage des matrices */
printf("Matrice donnee A :\n");
Correction TP

04 12 2006

for (I=0; I<N; I++)

{ for (J=0; J<M; J++)
printf("%7d", A[I][J]);
printf("\n");
}
printf("Matrice donnee B :\n");
for (I=0; I<M; I++)
{
for (J=0; J<P; J++)
printf("%7d", B[I][J]);
printf("\n");
}
// Affectation du rsultat de la multiplication C
for (I=0; I<N; I++)
for (J=0; J<P; J++)
{
C[I][J]=0;
for (K=0; K<M; K++)
C[I][J] += A[I][K]*B[K][J];
}
/* Edition du rsultat */
printf("Matrice resultat C :\n");
for (I=0; I<N; I++)
{
for (J=0; J<P; J++)
printf("%7d", C[I][J]);
printf("\n");
}
return 0;
}
18