SÉRIE 3

(EXERCICES/SOLUTIONS)
Master SEIB
2018-2019
Azzedine DLIOU
ENSA Agadir
Université Ibn Zohr
TABLEAU À UNE
DIMENSION
 EXERCICE 1
Écrire un programme qui lit la dimension N d'un
tableau T du type int, la dimension maximale ne
doit pas dépasser 20 composantes, puis :
1. Remplit le tableau par des valeurs entrées au
clavier et affiche le carré des valeurs saisies dans
le tableau;
2. Calcule et affiche la moyenne des éléments du
tableau;
3. Détermine le plus petit élément et le deuxième
plus petit élément du tableau ainsi que leurs
indices;
4. Calcule le plus grand écart existant dans le
tableau;
5. Teste si un tableau est trié;
 EXERCICE 1
6. Range les éléments du tableau T dans l'ordre
inverse sans utiliser de tableau d'aide, puis
affiche le tableau résultant;
7. Effectue un double décalage à gauche des
éléments du tableau;
8. Déclare un deuxième tableau dans lequel il
recopie toutes les valeurs impaires existantes
dans le premier tableau et complet le deuxième
tableau par des zéros;
9. Efface toutes les occurrences de valeur nulle
saisie par l'utilisateur dans le tableau T et tasse
les éléments restants, puis affiche le tableau
résultant.
 EXERCICE 1: QUESTION 1
#include <stdio.h>
main()
{ for (I=0; I<N; I++)
/* Déclarations */ {
int T[20]; /* tableau donné */ printf("Elément %d : ", I);
int N; /* dimension */ scanf("%d", &T[I]);
int I; /* indice courant */ }
/* Saisie des données */ /* Affichage carré éléms */
do printf("Tableau donné :\n");
{ for (I=0; I<N; I++)
printf("Dimension (max.20) :"); printf("%d ", T[I]*T[I]);
scanf("%d", &N ); printf("\n");
} }
while(N<1 || N>20);
 EXERCICE 1: QUESTION 2

long SOM;
/* Calcul de la somme */
for (SOM=0, I=0; I<N; I++)
SOM += T[I];
/* Edition du résultat */
printf("Somme de éléments : %ld\n", SOM);
printf("La moyenne des éléments est : %lf\n", (double)SOM/N);
 EXERCICE 1: QUESTION 3
int I_min1, I_min2; /*Indices des valeurs Min*/
if(Tab[0]<Tab[1]){ I_min1=0;
I_min2=1; }
else{ I_min1=1;
I_min2=0; }
i=2;
while(i<Taille){
if(Tab[i]<Tab[I_min1]){
I_min2=I_min1;
I_min1=i;
}
else if(Tab[i]<Tab[I_max2])
I_min2=i;
i++;
}
/* Edition du résultat */
printf("Min1=%d \t pos_Min1=%d\n", Tab[I_min1], I_min1);
printf("Min2=%d \t pos_Min2=%d\n", Tab[I_min2], I_min2);
 EXERCICE 1: QUESTION 4
int MAX, MIN; /* Valeurs Max et Min*/
int Ecart; /* Le plus grand écart dans le tableau */
MAX=MIN=T[0];
/* Calcul des valeurs du maximum et du minimum du tableau */
for (I=0; I<N; I++){
if (T[I] > MAX)
MAX=T[I];
if (T[I] < MIN)
MIN=T[I];
}
Ecart=MAX-MIN;
/* Edition des résultats */
printf("Le plus grand ecart dans le tableau est : %d\n", Ecart);
 EXERCICE 1: QUESTION 5
/* Tester si le tableau est trié */
Int j,k;
for(I=J=k=0;I<N-1;I++){
if(T[I]>= T[I+1]) J++;
if(T[I]<= T[I+1]) k++;
}
/* Edition des résultats */
If(J==N-1||k==N-1)
printf("Le tableau est trié\n");
else
printf("Le tableau est non trié\n");
 EXERCICE 1: QUESTION 6
int Aide;
/* Inverser le tableau */
for (I=0, J=N-1 ; I<J ; I++,J--)
{
/* Echange de T[I] et T[J] */
AIDE = T[I];
T[I] = T[J];
T[J] = AIDE;
}
/* Edition des résultats */
printf("Tableau résultat :\n");
for (I=0; I<N; I++)
printf("%d ", T[I]);
printf("\n");
 EXERCICE 1: QUESTION 7
int AIDE0, AIDE1;
/* Décalage à droite du tableau */
AIDE0=T[0];
AIDE1=T[1];
for (I=0; I<N-2; I++)
T[I]=T[I+1];
T[N-2]=AIDE0;
T[N-1]=AIDE1;
/* Edition du tableau */
printf("Tableau apres decalage : \n");
for (I=0; I<N; I++)
printf("%d ", T[I]);
printf("\n");
 EXERCICE 1: QUESTION 8

int T2[20];
/* Recopiage des éléments pairs */
for (I=0 ; I<N ; I++) T2[I] = 0 ;
for (I=0, J=0; I<N; I++)
if(!(T1[I]%2)) T2[J++]=T1[I];
/* Edition du tableau */
printf("Tableau apres recopiage : \n");
for (I=0; I<N; I++)
printf("%d ", T2[I]);
printf("\n");
 EXERCICE 1: QUESTION 9
/* Effacer les valeurs nulles et comprimer : */
/* Copier tous les éléments de I vers J et */
/* augmenter J pour les éléments différents de valeur nulle. */
for (I=0, J=0 ; I<N ; I++)
{
T[J] = T[I];
if (T[I]!=0) J++;
}
/* Nouvelle dimension du tableau ! */
N = J;
/* Edition des résultats */
printf("Tableau résultat :\n");
for (I=0; I<N; I++)
printf("%d ", T[I]);
printf("\n");
 EXERCICE 2
Écrire un programme qui,

1. lit deux tableaux d'entiers A et B et leurs

dimensions N et M au clavier puis échange les
éléments des deux tableaux;

2. ajoute les éléments de B à la fin de A;

3. affiche le contenu du tableau A de la question

précédente avec des étoiles. La ligne i correspond à
l'indice i-1 du tableau et le nombre d'étoiles sur cette
ligne correspond à l'entier contenu à cette case.
 EXERCICE 2 : QUESTION 1
#include <stdio.h>
main(){
/* Déclarations */
int A[100], B[50]; /* tableaux */
int N, M; /* dimensions des tableaux */
int I, J; /* indice courant */
int valeur_Case; /* variable d’aide */
/* Saisie des données */
do
{
printf("Dimension du tableau A (max.50) : ");
scanf("%d", &N );
}while(N<1||N>50);
for (I=0; I<N; I++)
{
printf("Elément %d : ", I);
scanf("%d", &A[I]);
}
do EXERCICE 2 : QUESTION 1
{
printf("Dimension du tableau B (max.50) : ");
scanf("%d", &M );
}while(M<1||M>50);
for (I=0; I<M; I++)
{
printf("Elément %d : ", I);
scanf("%d", &B[I]);
}
/* Affichage des tableaux */
printf("Tableau donné A :\n");
for (I=0; I<N; I++)
printf("%d ", A[I]);
printf("\n");
printf("Tableau donné B :\n");
for (I=0; I<M; I++)
printf("%d ", B[I]);
printf("\n");
 EXERCICE 2 : QUESTION 1
/* Echange des éléments de A et B */
for (I=0; I<N; I++){
AIDE =A[I];
A[I]=B[I];
B[I]= AIDE;
}
/* Edition du résultat après échange */
printf("Tableau A après échange :\n");
for (I=0; I<N; I++)
printf("%d ", A[I]);
printf("\n");
printf("Tableau B après échange :\n");
for (I=0; I<N; I++)
printf("%d ", B[I]);
printf("\n");
}
 EXERCICE 2 : QUESTION 2 ET 3
/* Copie de B à la fin de A */
for (I=0; I<M; I++)
A[N+I] =B[I];
/* Nouvelle dimension de A */
N += M;
/* Edition du résultat */
printf("Tableau résultat A :\n");
for (I=0; I<N; I++)
printf("%d ", A[I]);
printf("\n");
/* Edition du résultat en étoiles*/
for(I=0; I<N; I++){
valeur_Case=A[I];
for(J=0; J<valeur_Case; J++){ printf("*"); }
printf("\n");
}
}
 EXERCICE 2 : QUESTION 2 ET 3

for(i=0; i<Taille; i++){

valeur_Case=Star[i];
for(j=0; j<valeur_Case; j++)
printf("*");
printf("\n");
}
}
TABLEAU À DEUX
DIMENSIONS
 EXERCICE 3
1. Écrire un programme qui réalise l'addition de
deux matrices A et B de mêmes dimensions N et
M sans utiliser une autre matrice pour le
résultat.
2. Écrire un programme qui réalise la
multiplication d’une matrice A de dimensions N
et M avec une matrice B de dimensions M et P
pour obtenir une matrice C de dimensions N et
P:
A(N,M) * B(M,P) = C(N,P)
 EXERCICE 3 : QUESTION 1
#include <stdio.h>
main()
{
/* Déclarations */
int A[20][20]; /* matrice donnée */
int B[20][20]; /* matrice donnée */
int N, M; /* dimensions des matrices */
int I, J; /* indices courants */
/* Saisie des données */
do{
printf("Nombre de lignes (max.20) : ");
scanf("%d", &N );
}while(N<1 || N>20);
do{
printf("Nombre de colonnes (max.20) : ");
scanf("%d", &M );
}while(N<1 || N>20);
 EXERCICE 3 : QUESTION 1
printf("*** Matrice A ***\n");
for (I=0; I<N; I++)
for (J=0; J<M; J++){
printf("Elément[%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("Elément[%d][%d] : ",I,J);
scanf("%d", &B[I][J]);
}
/* Affichage des matrices */
printf("Matrice donnée A :\n");
for (I=0; I<N; I++){
for (J=0; J<M; J++)
printf("%7d", A[I][J]);
printf("\n"); }
 EXERCICE 3 : QUESTION 1
printf("Matrice donnée 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 résultat */
printf("Matrice résultat A :\n");
for (I=0; I<N; I++){
for (J=0; J<M; J++)
printf("%7d", A[I][J]);
printf("\n");
}
#include <stdio.h> EXERCICE 3 : QUESTION 2
main()
{
/* Déclarations */
int A[20][20]; /* matrice donnée */
int B[20][20]; /* matrice donnée */
int C[20][20]; /* matrice résultat */
int N, M, P; /* dimensions des matrices */
int I, J, K; /* indices courants */
/* Saisie des données */
printf("*** Matrice A ***\n");
do{
printf("Nombre de lignes de A (max.20) : ");
scanf("%d", &N );
}while(N<1 || N>20);
do{
printf("Nombre de colonnes de A (max.20) : ");
scanf("%d", &M );
}while(M<1 || M>20);
 EXERCICE 3 : QUESTION 2
for (I=0; I<N; I++)
for (J=0; J<M; J++){
printf("Elément[%d][%d] : ",I,J);
scanf("%d", &A[I][J]);
}
printf("*** Matrice B ***\n");
printf("Nombre de lignes de B : %d\n", M);
do{
printf("Nombre de colonnes de B (max.20) : ");
scanf("%d", &P );
}while(P<0 || P>20);
for (I=0; I<M; I++)
for (J=0; J<P; J++){
printf("Elément[%d][%d] : ",I,J);
scanf("%d", &B[I][J]);
}
 EXERCICE 3 : QUESTION 2
/* Affichage des matrices */
printf("Matrice donnée A :\n");
for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("%7d", A[I][J]);
printf("\n");
}
printf("Matrice donnée B :\n");
for (I=0; I<M; I++)
{
for (J=0; J<P; J++)
printf("%7d", B[I][J]);
printf("\n");
}
 EXERCICE 3 : QUESTION 2
/* Affectation du résultat 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 résultat */
printf("Matrice résultat C :\n");
for (I=0; I<N; I++)
{
for (J=0; J<P; J++)
printf("%7d", C[I][J]);
printf("\n");
}
}
 EXERCICE 4
1. Ecrire un programme qui lit les dimensions L et C d'un
tableau T à deux dimensions du type int (dimensions
maximales: 50 lignes et 50 colonnes). Remplir le tableau
par des valeurs entrées au clavier et afficher le tableau
ainsi que la somme de chaque ligne et de chaque colonne
en n'utilisant qu'une variable d'aide pour la somme.
2. Ecrire un programme qui transfère un tableau M à deux
dimensions L et C (dimensions maximales: 10 lignes et
10 colonnes) dans un tableau V à une dimension L*C.
|abcd|
| e f g h | ==> | a b c d e f g h i j k l |
|i j k l|
 EXERCICE 4 : QUESTION 1
#include <stdio.h>
main(){
/* Déclarations */
int T[50][50]; /* tableau donné */
int L, C; /* dimensions */
int I, J; /* indices courants */
long SOM; /* somme des éléments - type long à cause */
/* de la grandeur prévisible des résultats. */
/* Saisie des données */
printf("Nombre de lignes (max.50) : ");
scanf("%d", &L );
printf("Nombre de colonnes (max.50) : ");
scanf("%d", &C );
for (I=0; I<L; I++)
for (J=0; J<C; J++){
printf("Elément[%d][%d] : ",I,J);
scanf("%d", &T[I][J]);
}
 EXERCICE 4 : QUESTION 1
/* Affichage du tableau */
printf("Tableau donné :\n");
for (I=0; I<L; I++){
for (J=0; J<C; J++)
printf("%7d", T[I][J]);
printf("\n");
}
/* Calcul et affichage de la somme des lignes */
for (I=0; I<L; I++){
for (SOM=0, J=0; J<C; J++)
SOM += T[I][J];
printf("Somme - ligne %d : %ld\n",I,SOM);
}
/* Calcul et affichage de la somme des colonnes */
for (J=0; J<C; J++){
for (SOM=0, I=0; I<L; I++)
SOM += T[I][J];
printf("Somme - colonne %d : %ld\n",J,SOM);
}
}
 EXERCICE 4 : QUESTION 2
#include <stdio.h>
main(){
/* Déclarations */
int M[10][10]; /* tableau à 2 dimensions */
int V[100]; /* tableau à 1 dimension */
int L, C; /* dimensions */
int I, J; /* indices courants */
/* Saisie des données */
printf("Nombre de lignes (max.10) : ");
scanf("%d", &L );
printf("Nombre de colonnes (max.10) : ");
scanf("%d", &C );
for (I=0; I<L; I++)
for (J=0; J<C; J++)
{
printf("Elément[%d][%d] : ",I,J);
scanf("%d", &M[I][J]);
}
 EXERCICE 4 : QUESTION 2
/* Affichage du tableau 2-dim */
printf("Tableau donné :\n");
for (I=0; I<L; I++){
for (J=0; J<C; J++)
printf("%7d", M[I][J]);
printf("\n");
}
/* Transfer des éléments ligne par ligne */
for (I=0; I<L; I++)
for (J=0; J<C; J++)
V[I*C+J] = M[I][J];
/* Affichage du tableau 1-dim */
printf("Tableau résultat : ");
for (I=0; I<L*C; I++)
printf("%d ", V[I]);
printf("\n");
}
 EXERCICE 5

Rechercher dans une matrice donnée A, les

éléments qui sont à la fois un maximum sur leur
ligne et un minimum sur leur colonne.
Ces éléments sont appelés des Max-Min. Afficher
les positions et les valeurs de tous les Max-Min
trouvés.
 EXERCICE 5
#include <stdio.h>
main(){
/* Déclarations */
int A[50][50]; /* matrice donnée */
int MAX[50][50]; /*mat. indiquant maxima lignes */
int MIN[50][50]; /*mat. indiquant minima colonnes*/
int N, M; /* dimensions des matrices */
int I, J; /* indices courants */
int AIDE; /* pour la détection des extrémas */
int C; /* compteur des Min-Max */
/* Saisie des données */
printf("Nombre de lignes (max.50) : ");
scanf("%d", &N );
printf("Nombre de colonnes (max.50) : ");
scanf("%d", &M );
 EXERCICE 5
for (I=0; I<N; I++)
for (J=0; J<M; J++)
{
printf("Elément[%d][%d] : ",I,J);
scanf("%d", &A[I][J]);
}
/* Affichage de la matrice */
printf("Matrice donnée :\n");
for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("%7d", A[I][J]);
printf("\n");
}
 EXERCICE 5
/* Construction de la matrice d'aide MAX */
/* qui indique les positions de tous les */
/* maxima sur une ligne. */
for (I=0; I<N; I++)
{
/* Recherche du maximum sur la ligne I */
AIDE=A[I][0];
for (J=1; J<M; J++)
if (A[I][J]>AIDE) AIDE=A[I][J];
/* Marquage de tous les maxima sur la ligne */
for (J=0; J<M; J++)
if (A[I][J]==AIDE)
MAX[I][J]=1;
else
MAX[I][J]=0;
}
 EXERCICE 5
/* Construction de la matrice d'aide MIN */
/* qui indique les positions de tous les */
/* minima sur une colonne. */
for (J=0; J<M; J++)
{
/* Recherche du minimum sur la colonne J */
AIDE=A[0][J];
for (I=1; I<N; I++)
if (A[I][J]<AIDE) AIDE=A[I][J];
/* Marquage de tous les minima sur la colonne J */
for (I=0; I<N; I++)
if (A[I][J]==AIDE)
MIN[I][J]=1;
else
MIN[I][J]=0;
}
 EXERCICE 5
/* Edition du résultat */
/*Les composantes marquées comme extrémas*/
/* dans MAX et dans MIN sont des Max-Min. */
printf(" Max-Min :\n");
for (C=0, I=0; I<N; I++)
for (J=0; J<M; J++)
if (MAX[I][J]&&MIN[I][J]){
C++;
printf("L'élément %d\t est un maximum
sur la ligne %d\n\t\t et un
minimum sur la colonne
%d\n", A[I][J], I, J);
}
if (C==0)
printf("Tableau ne contient pas de points Max-Min.\n");
}
 EXERCICE 6

Écrire un programme qui construit le triangle de

PASCAL de degré N et le mémorise dans une
matrice carrée P de dimension N+1.
 EXERCICE 6
#include <stdio.h>
main()
{
/* Déclarations */
int P[14][14]; /* matrice résultat */
int N; /* degré du triangle */
int I, J; /* indices courants */
/* Saisie des données */
do
{
printf("Entrez le degré N du triangle (max.13) : ");
scanf("%d", &N);
}
while (N<1 || N>13);
 EXERCICE 6
/* Construction des lignes 0 à N du triangle: */
/* Calcul des composantes du triangle jusqu'à */
/* la diagonale principale. */
for (I=0; I<=N; I++){
P[I][I]=1;
P[I][0]=1;
for (J=1; J<I; J++)
P[I][J] = P[I-1][J] + P[I-1][J-1];
}
/* Edition du résultat */
printf("Triangle de Pascal de degré %d :\n", N);
for (I=0; I<=N; I++){
printf(" N=%2d", I); // Pour afficher le nbre de la ligne
for (J=0; J<=I; J++)
printf("%5d", P[I][J]);
printf("\n");
}
}