Les tableaux en langage C #include <stdio.

h>

Exercice 1: main()

{
Ecrire un programme en langage C qui lit la dimension N d'un
/* Déclarations */
tableau T du type int (dimension maximale: 50 composantes),
int T[50]; /* tableau donné */
remplit le tableau par des valeurs entrées au clavier et affiche le
int N; /* dimension */
tableau.
int I,J; /* indices courants */
Calculer et afficher ensuite la somme des éléments du tableau.
/* Saisie des données */
Solution :
printf("Dimension du tableau (max.50) : ");
#include <stdio.h>
scanf("%d", &N );
main()
for (I=0; I<N; I++)
{
{
/* Déclarations */
printf("Elément %d : ", I);
int T[50]; /* tableau donné */
scanf("%d", &T[I]);
int N; /* dimension */
}
int I; /* indice courant */
/* Affichage du tableau */
long SOM; /* somme des éléments - type long à cause */
printf("Tableau donné : \n");
/* de la grandeur prévisible du résultat. */
for (I=0; I<N; I++)
/* Saisie des données */
printf("%d ", T[I]);
printf("Dimension du tableau (max.50) : ");
printf("\n");
scanf("%d", &N );
/* Effacer les zéros et comprimer : */
for (I=0; I<N; I++)
/* Copier tous les éléments de I vers J et */
{
/* augmenter J pour les éléments non nuls. */
printf("Elément %d : ", I);
for (I=0, J=0 ; I<N ; I++)
scanf("%d", &T[I]);
{
}
T[J] = T[I];
/* Affichage du tableau */
if (T[I]) J++;
printf("Tableau donné :\n");
}
for (I=0; I<N; I++)
/* Nouvelle dimension du tableau ! */
printf("%d ", T[I]);
N = J;
printf("\n");
/* Edition des résultats */
/* Calcul de la somme */
printf("Tableau résultat :\n");
for (SOM=0, I=0; I<N; I++)
for (I=0; I<N; I++)
SOM += T[I];
printf("%d ", T[I]);
/* Edition du résultat */
printf("\n");
printf("Somme de éléments : %ld\n", SOM);
return 0;
return 0;
}
}

Exercice 2: Exercice 3:
Ecrire un programme en langage C qui lit la dimension N d'un
Ecrire un programme en langage C qui lit la dimension N d'un
tableau T du type int (dimension maximale: 50 composantes),
tableau T du type int (dimension maximale: 50 composantes),
remplit le tableau par des valeurs entrées au clavier et affiche le
remplit le tableau par des valeurs entrées au clavier et affiche le
tableau.
tableau.
Ranger ensuite les éléments du tableau T dans l'ordre inverse sans
Effacer ensuite toutes les occurrences de la valeur 0 dans le tableau T
utiliser de tableau d'aide. Afficher le tableau résultant.
et tasser les éléments restants. Afficher le tableau résultant.
Idée: Echanger les éléments du tableau à l'aide de deux indices qui
Solution :
parcourent le tableau en commençant respectivement au début et à

1
la fin du tableau et qui se rencontrent en son milieu. TNEG.

Solution : Solution :
#include <stdio.h> #include <stdio.h>

main() main()

{ {

/* Déclarations */ /* Déclarations */

int T[50]; /* tableau donné */ /* Les tableaux et leurs dimensions */

int N; /* dimension */ int T[50], TPOS[50], TNEG[50];

int I,J; /* indices courants */ int N, NPOS, NNEG;

int AIDE; /* pour l'échange */ int I; /* indice courant */

/* Saisie des données */ /* Saisie des données */

printf("Dimension du tableau (max.50) : "); printf("Dimension du tableau (max.50) : ");

scanf("%d", &N ); scanf("%d", &N );

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

{ {

printf("Elément %d : ", I); printf("Elément %d : ", I);

scanf("%d", &T[I]); scanf("%d", &T[I]);

} }

/* Affichage du tableau */ /* Affichage du tableau */

printf("Tableau donné : \n"); printf("Tableau donné :\n");

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

printf("%d ", T[I]); printf("%d ", T[I]);

printf("\n"); printf("\n");

/* Inverser le tableau */ /* Initialisation des dimensions de TPOS et TNEG */

for (I=0, J=N-1 ; I<J ; I++,J--) NPOS=0;

/* Echange de T[I] et T[J] */ NNEG=0;

{ /* Transfer des données */

AIDE = T[I]; for (I=0; I<N; I++)

T[I] = T[J]; { if (T[I]>0) {

T[J] = AIDE; TPOS[NPOS]=T[I];

} NPOS++;

/* Edition des résultats */ }

printf("Tableau résultat :\n"); if (T[I]<0) {

for (I=0; I<N; I++) TNEG[NNEG]=T[I];

printf("%d ", T[I]); NNEG++;

printf("\n"); }

return 0; }

} /* Edition du résultat */

Exercice 4: printf("Tableau TPOS :\n");

Ecrire un programme en langage C qui lit la dimension N d'un for (I=0; I<NPOS; I++)

tableau T du type int (dimension maximale: 50 composantes), printf("%d ", TPOS[I]);

remplit le tableau par des valeurs entrées au clavier et affiche le printf("\n");

tableau. printf("Tableau TNEG :\n");

Copiez ensuite toutes les composantes strictement positives dans un for (I=0; I<NNEG; I++)

deuxième tableau TPOS et toutes les valeurs strictement négatives printf("%d ", TNEG[I]);

dans un troisième tableau TNEG. Afficher les tableaux TPOS et printf("\n");

2
return 0; Ecrire un programme en langage C qui lit les dimensions L et C d'un

} tableau T à deux dimensions du type int (dimensions maximales: 50 lignes

Exercice 5: et 50 colonnes). Remplir le tableau par des valeurs entrées au clavier et

Ecrire un programme en langage C qui lit les dimensions L et C afficher le tableau ainsi que la somme de chaque ligne et de chaque colonne

d'un tableau T à deux dimensions du type int (dimensions en n'utilisant qu'une variable d'aide pour la somme.

maximales: 50 lignes et 50 colonnes). Remplir le tableau par des Solution :

valeurs entrées au clavier et afficher le tableau ainsi que la somme de #include <stdio.h>

tous ses éléments. main()

Solution : {

#include <stdio.h> /* Déclarations */

main() int T[50][50]; /* tableau donné */

{ int L, C; /* dimensions */

/* Déclarations */ int I, J; /* indices courants */

int T[50][50]; /* tableau donné */ long SOM; /* somme des éléments - type long à cause */

int L, C; /* dimensions */ /* de la grandeur prévisible des résultats. */

int I, J; /* indices courants */ /* Saisie des données */

long SOM; /* somme des éléments - type long à cause */ printf("Nombre de lignes (max.50) : ");

/* de la grandeur prévisible du résultat. */ scanf("%d", &L );

/* Saisie des données */ printf("Nombre de colonnes (max.50) : ");

printf("Nombre de lignes (max.50) : "); scanf("%d", &C );

scanf("%d", &L ); for (I=0; I<L; I++)

printf("Nombre de colonnes (max.50) : "); for (J=0; J<C; J++)

scanf("%d", &C ); {

for (I=0; I<L; I++) printf("Elément[%d][%d] : ",I,J);

for (J=0; J<C; J++) scanf("%d", &T[I][J]);

{ }

printf("Elément[%d][%d] : ",I,J); /* Affichage du tableau */

scanf("%d", &T[I][J]); printf("Tableau donné :\n");

} for (I=0; I<L; I++)

/* Affichage du tableau */ {

printf("Tableau donné :\n"); for (J=0; J<C; J++)

for (I=0; I<L; I++) printf("%7d", T[I][J]);

{ printf("\n");

for (J=0; J<C; J++) }

printf("%7d", T[I][J]); /* Calcul et affichage de la somme des lignes */

printf("\n"); for (I=0; I<L; I++)

} {

/* Calcul de la somme */ for (SOM=0, J=0; J<C; J++)

for (SOM=0, I=0; I<L; I++) SOM += T[I][J];

for (J=0; J<C; J++) printf("Somme - ligne %d : %ld\n",I,SOM);

SOM += T[I][J]; }

/* Edition du résultat */ /* Calcul et affichage de la somme des colonnes */

printf("Somme des éléments : %ld\n", SOM); for (J=0; J<C; J++)

return 0; {

} for (SOM=0, I=0; I<L; I++)

Exercice 6: SOM += T[I][J];

3
 printf("Somme - colonne %d : %ld\n",J,SOM); /* Affichage du tableau 1-dim */

} printf("Tableau résultat : ");

return 0; for (I=0; I<L*C; I++)

} printf("%d ", V[I]);

Exercice 7: printf("\n");

Ecrire un programme en langage C qui transfère un tableau M à return 0;

deux dimensions L et C (dimensions maximales: 10 lignes et 10 }

colonnes) dans un tableau V à une dimension L*C. Exercice 8:

Exemple: Ecrire un programme en langage C qui calcule le produit scalaire de
/ \ deux vecteurs d'entiers U et V (de même dimension).
|abcd| / \ Exemple:
| e f g h | ==> | a b c d e f g h i j k l | / \ / \
|ijkl | \ / | 3 2 -4 | * | 2 -3 5 | = 3*2+2*(-3)+(-4)*5 = -20
\ / \ / \ /
Solution : Solution :
#include <stdio.h> #include <stdio.h>

main() main()

{ {

/* Déclarations */ /* Déclarations */

int M[10][10]; /* tableau à 2 dimensions */ int U[50], V[50]; /* tableaux donnés */

int V[100]; /* tableau à 1 dimension */ int N; /* dimension */

int L, C; /* dimensions */ int I; /* indice courant */

int I, J; /* indices courants */ long PS; /* produit scalaire */

/* Saisie des données */ /* Saisie des données */

printf("Nombre de lignes (max.10) : "); printf("Dimension des tableaux (max.50) : ");

scanf("%d", &L ); scanf("%d", &N );

printf("Nombre de colonnes (max.10) : "); printf("** Premier tableau **\n");

scanf("%d", &C ); for (I=0; I<N; I++)

for (I=0; I<L; I++) {

for (J=0; J<C; J++) printf("Elément %d : ", I);

{ scanf("%d", &U[I]);

printf("Elément[%d][%d] : ",I,J); }

scanf("%d", &M[I][J]); printf("** Deuxième tableau **\n");

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

/* Affichage du tableau 2-dim */ {

printf("Tableau donné :\n"); printf("Elément %d : ", I);

for (I=0; I<L; I++) scanf("%d", &V[I]);

{ }

for (J=0; J<C; J++) /* Calcul du produit scalaire */

printf("%7d", M[I][J]); for (PS=0, I=0; I<N; I++)

printf("\n"); PS += (long)U[I]*V[I];

} /* Edition du résultat */

/* Transfer des éléments ligne par ligne */ printf("Produit scalaire : %ld\n", PS);

for (I=0; I<L; I++) return 0;

for (J=0; J<C; J++) }

V[I*C+J] = M[I][J]; Exercice 9:

4
Ecrire un programme en langage C qui détermine 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é.

Solution :
#include <stdio.h>

main()

/* Déclarations */

int A[50]; /* tableau donné */

int N; /* dimension */

int I; /* indice courant */

int MIN; /* position du minimum */

int MAX; /* position du maximum */

/* Saisie des données */

printf("Dimension du tableau (max.50) : ");

scanf("%d", &N );

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

printf("Elément %d : ", I);

scanf("%d", &A[I]);

/* Affichage du tableau */