Vous êtes sur la page 1sur 3

ALGORITHMIQUE ET LANGAGE C – L1S2–MPI TD 3 – GROUPE D1

ROSELINE DESCOUT-RENIER JEUDI 13 FÉVRIER 2014

Objectifs de la séance :
• Génération de tableau – savoir que la dimension d’un tableau doit avoir une valeur connue avant la
déclaration du tableau ;
• Boucles de parcours de tableau ;
• Conception d’algorithme sur les tableaux ;
• Gestion des générations aléatoires de nombres entiers.

Exercices étudiés pendant la séance : 1 – 3 TD3.

Exercice 1 :
Question 1 : #include <stdio.h>
• Déclaration et initialisation d’un tableau #define DIM 10
contenant certaines valeurs nulles.
• Affichage des indices des éléments nuls du int main(void) {
tableau. /* Entrées */
int tab[DIM] = {0,2,9,5,0,8,0,1,4,0};
int n;

/* Traitements et Sorties*/
for (n = 0; n < DIM; n++) {
if (tab[n] == 0) {
printf("\nL'élément %d du tableau est nul.\n", n+1);
}
}
return 0;
}

Question 2 : #include <stdio.h>


• Déclaration et initialisation d’un tableau par #define DIM 5
saisie au clavier.
• Affichage des indices des éléments nuls du int main(void) {
tableau. /* Entrées */
int tab[DIM];
int n;

for (n = 1; n <= DIM; n++) {


printf("\nSaisissez la valeur %d du tableau :", n);
scanf("%d", &tab[n-1]);
}

/* Traitements et Sorties*/
for (n = 0; n < DIM; n++) {
if (tab[n] == 0) {
printf("\nL'élément %d du tableau est nul.\n", n+1);
}
}
return 0;
}
Question 3 : #include <stdio.h>
• Génération aléatoire de la taille du tableau. #include <sys/types.h>
• Génération aléatoire des n éléments du tableau. #include <time.h>
• Génération aléatoire de l’entier elt.
• Parcours du tableau et affichage des indices des int main(void) {
éléments du tableau égaux à elt. /* Entrées */
srand(time(0));

int i, nombre = 0;
int elt = rand()%5;
int n = rand()%50;
int tab[n];

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


tab[i]=rand()%10;
}

/* Traitements et Sorties*/
for (i = 0; i < n; i++) {
if (tab[i] == elt) {
printf("\nL'élément %d du tableau est égal à %d.\n",
i+1, elt);
nombre++;
}
}
printf("\nLe nombre %d apparaît %d fois dans le
tableau.\n", elt, nombre);
return 0;
}

Exercice 3 : Tassage de tableau.

Principe de l’algorithme : soit un tableau d’entiers, dont certains sont nuls.


1 0 4 6 0 8 3 0 5 9

Il faut parcourir chaque case du tableau pour tester si la valeur contenue dans cette case est nulle.
Si elle est nulle, on décale toutes les valeurs qui se trouvent à droite de cette case, d’un cran vers la gauche :
1 0 4 6 0 8 3 0 5 9

1 4 6 0 8 3 0 5 9

On affecte ensuite la valeur 0 à la dernière case maintenant vide (choix arbitraire).


1 4 6 0 8 3 0 5 9 0

On continue de parcourir le tableau :


1 4 6 0 8 3 0 5 9 0

1 4 6 8 3 0 5 9 0 0

1 4 6 8 3 5 9 0 0 0

Remarque : chaque case est testée une seule fois : pour un tableau de 10 cases, il y aura 10 parcours de
boucle et pas plus. Il n’y a donc pas de risque de boucle infinie en ajoutant des 0 supplémentaires en fin de
tableau.
Pseudo-code : Code en C :
#include <stdio.h>
N ← 10 ; #define N 10

int main(void) {
/* Entrées */
entier i, j, taille ; int i, j, taille = 10;
tableau d’entiers tab[N] = {1, 0, 4, 6, 0, 8, 3, 0, 5, 9}; int tab[N] = {1, 0, 4, 6, 0, 8, 3, 0, 5, 9};

écrire (“ Tableau avant tassage ”) ; printf("\nTableau avant tassage :\n");


pour i allant de 0 à N – 1 faire for (i = 0; i < N; i++) {
écrire “ tab[i] ” printf("%d ", tab[i]);
finpour }

/* Traitements */
pour i allant de 0 à N – 1 faire for (i = 0; i < N; i++) {
si tab[i] == 0 faire if (tab[i] == 0) {
pour j allant de i à N – 2 faire for (j = i; j < N-1; j++) {
tab[j] = tab[j+1] ; tab[j] = tab[j+1];
tab[N – 1] = 0 ; tab[N-1] = 0;
finpour }
finsi }
finpour }
pour i allant de 0 à N faire for (i = 0; i < N; i++) {
si tab[i] == 0 faire if (tab[i] == 0) {
taille ← i ; taille = i;
sortir ; break;
finsi }
finpour }

/* Sorties */
écrire “ Tableau après tassage ” ; printf("\nTableau après tassage :\n");
pour i allant de 0 à N faire for (i = 0; i < N; i++) {
écrire “ tab[i] ” printf("%d ", tab[i]);
finpour }
écrire “ la nouvelle taille du tableau vaut taille ” printf("\nLa nouvelle taille du tableau vaut %d.\n", taille);

return 0;
}

Conclusion : écrire sur papier le comportement attendu de l’algorithme pour concevoir la structure du code
correspondant, avec les bonnes étapes et les bonnes limites de boucles.