Correction TD2 : Algorithmique et structure de donnée (Langage C)

-Les tableaux et le chaines de caractères-

Exercice 1 : Ecrire un programme qui lit la dimension N d'un tableau T du type int (dimension
maximale : 50 composantes), remplit le tableau par des valeurs entrées au clavier et affiche le tableau.
Calculer et afficher ensuite la somme des éléments du tableau.
Solution
#include <stdio.h>
int main(){
/*Déclarations*/
int T[50]; /*tableau donné*/
int N; /*dimension*/
int i; /*indice courant*/
long SOM; /* somme des éléments - type long à cause de la grandeur
prévisible du résultat. */
/* Saisie des données */
printf("Dimension du tableau (max.50) : ");
scanf("%d", &N );
/* on peut également effectuer un control de saisi*/
do{
printf("Dimension du tableau (max.50) : ");
scanf("%d", &N );
}while(N<50) ;

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

printf("Elément %d : ", i);
scanf("%d", &T[i]);}
/* Affichage du tableau */
printf("Tableau donné :\n");
for (i=0; i<N; i++) printf("%d ", T[i]);
/* Calcul de la somme */
/* on peut écrire Som=0 soit avant la boucle, soit dans la boucle*/
for (SOM=0, i=0; i<N; i++)
SOM += T[i];
/* Edition du résultat */
printf("Somme de éléments : %ld\n", SOM);
return 0;
}
Exercice 2 : On considère deux tableaux de nombres entiers, le premier contient les 10 premiers
nombres positifs paires et le second les 10 premiers nombres positifs impaires. Ecrire un Programme
qui permette de fusionner ces deux tableaux en un unique tableau contenant les 20 premiers nombres
entiers positifs. Afficher le résultat de la fusion.
Solution
#include <stdio.h>
int main(){
int Tpair[] = {0,2,4,6,8,10,12,14,16,18};
int Timpair[] = { 1, 3, 5, 7, 9, 11, 13, 15, 17, 19 };
int Tfusion [20];
for (int i = 0; i < 20; i++){
if (i % 2 == 0) Tfusion[i] = Tpair[i / 2];
else Tfusion[i] = Timpair[i / 2];
/*Affichage des éléments au cours de la créations*/
printf("%d ", Tfusion[i]);

[1]
 }
return 0;
}
Autre Solution
#include <stdio.h>
int main() {
int Tpair[10] = {0, 2, 4, 6, 8, 10, 12, 14, 16, 18};
int Timpair[10] = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
int Tfusion[20];
int indexPair = 0, indexImpair = 0;
for (int i = 0; i < 20; i++) {
if (i % 2 == 0) {
Tfusion[i] = Tpair[indexPair];
indexPair++;}
else {
Tfusion[i] = Timpair[indexImpair];
indexImpair++;}
}
/* Affichage du tableau fusionné */
printf("Tableau fusionné des 20 premiers nombres entiers positifs
:\n");
for (int i = 0; i < 20; i++) {
printf("%d ", Tfusion[i]); }
return 0;
}
Autre Solution
#include <stdio.h>
int main() {
/* Déclarations des tableaux */
int tabPair[] = {0, 2, 4, 6, 8, 10, 12, 14, 16, 18};
int tabImpair[] = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
int tabfusion[20];
/* Fusion des tableaux */
for (int i = 0; i < 10; i++) {
tabfusion[i * 2] = tabPair[i]; /*Nombres pairs*/
tabfusion[i * 2 + 1] = tabImpair[i]; /*Nombres impairs*/
}
/* Affichage du tableau fusionné */
printf("Tableau fusionné des 20 premiers nombres entiers positifs
:\n");
for (int i = 0; i < 20; i++) {
printf("%d ", tabfusion[i]);}
return 0;
}
Exercice 3 : On considère un tableau de nombres entiers contenant les élément { -2, 0, 8, 7, 1, -5, 12,
10, 25, 5 }. Ecrire un algorithme qui permette de lire au clavier les éléments de ce tableau, qui trie le
tableau en utilisant la méthode de tri par SELECTION et qui affiche le tableau trié. On obtiendra, par
exemple, l’exécution suivante : tableau trié : -5|-2|0|1|5|7|8|10|12|25|
Solution avec ordre croissant (demandé dans l’exercice)
#include <stdio.h>
#define TAILLE 10
int main() {
int tab []= { -2, 0, 8, 7, 1, -5, 12, 10, 25, 5 };
int aux; /*variable auxiliaire pour échanger*/

[2]
 /*trier par sélection le tableau*/
int indMin;
for (int i = 0; i < TAILLE; i++) {
/*rechercher la place indMin du plus petit élément dans le sous
tableau tab[i..TAILLE-1]*/
indMin = i;
for (int j = i + 1; j < TAILLE; j++){
if (tab[j] < tab[indMin])
indMin = j ; }
/*Echanger l'élément d'indice indMin avec l'élément d'indice
k*/
aux = tab[indMin];
tab[indMin] = tab[i];
tab[i] = aux;}
/*Affichage du tableau trié*/
printf("tableau trié : ");
for (int i = 0; i < TAILLE; i++){
printf("%d|", tab[i]);}
return 0;
}
Tri par sélection avec ordre décroissant( pas demandé par l’exercice)
#include <stdio.h>
#define TAILLE 10
int main() {
// Même étapes
int indMax; /*Utilisez indMax au lieu d'indMin*/
for (int i = 0; i < TAILLE; i++) {
/*Rechercher la place indMax du plus grand élément dans le sous-
tableau tab[k..TAILLE-1]*/
indMax = i;
for (int j = i + 1; j < TAILLE; j++) {
if (tab[j] > tab[indMax]) // Inversion du sens de comparaison
indMax = j;}
// Échanger l'élément d'indice indMax avec l'élément d'indice k
}
// affichage du tableau
return 0;}
Exercice 4 : 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.
Solution
#include <stdio.h>
int 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++) {

[3]
 printf("Elément[%d][%d] : ",i,j);
scanf("%d", &M[i][j]) ;}}
/* Affichage du tableau 2-dim */
printf("Tableau donné :\n");
for (i=0; i<L; i++) {
for (j=0; j<C; j++){
printf("%d", M[i][j]);}}
/* 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]);}
return 0;
}
Autres solution
#include <stdio.h>
int main() {
int M[10][10]; /*Tableau à deux dimensions 10x10*/
int V[100]; /*Tableau à une dimension avec une capacité maximale
de 10*10 = 100 éléments*/
int L, C; /*Nombre de lignes et de colonnes/
/* Demander à l'utilisateur les dimensions du tableau M (L lignes et
C colonnes)*/
do {
printf("Entrez le nombre de lignes (max. 10) : ");
scanf("%d", &L);
printf("Entrez le nombre de colonnes (max. 10) : ");
scanf("%d", &C);
} while (L > 10 || C > 10 || L <= 0 || C <= 0);
/*Demander à l'utilisateur de remplir le tableau M*/
printf("Entrez les éléments du tableau M (%d lignes x %d colonnes)
:\n", L, C);
for (int i = 0; i < L; i++) {
for (int j = 0; j < C; j++) {
printf("Elément[%d][%d] : ",i,j);
scanf("%d", &M[i][j]); }}
/*Transférer les éléments de M dans le tableau V */
int index = 0; /*Indice pour le tableau V */
for (int i = 0; i < L; i++) {
for (int j = 0; j < C; j++) {
V[index] = M[i][j];
index++; }}
/*Afficher le tableau V*/
printf("Tableau V (une dimension) contenant %d éléments :\n", L * C);
for (int i = 0; i < L * C; i++) {
printf("%d ", V[i]);}
return 0;
}
Autres solution (tableau de chaine)
#include <stdio.h>
int main() {
int L, C;

[4]
 char M[10][10];
char V[100];
/*Saisir L et C*/
do {
printf("Saisir L et C : ");
scanf("%d %d", &L, &C);
} while (L > 10 || L <= 0 || C > 10 || C <= 0);
printf("L = %d, C = %d\n", L, C);
/*Remplir la matrice*/
for (int i = 0; i < L; i++) {
for (int j = 0; j < C; j++) {
printf("Saisir l'élément M[%d][%d] : ", i, j);
/*Ajout d'un espace dans le format pour ignorer les espaces
blancs*/
scanf(" %c", &M[i][j]);}}

/*Transférer les éléments de M dans le tableau V*/

int idx = 0;
for (int i = 0; i < L; i++) {
for (int j = 0; j < C; j++) {
V[idx] = M[i][j];
idx++; }
}
/*Afficher le tableau V*/
for (int i = 0; i < L * C; i++) {
printf(" %c \n", V[i]);}

return 0;
}
Exercice 5 : Lesquelles des chaînes suivantes sont initialisées correctement ? Corrigez les
déclarations fausses et indiquez pour chaque chaîne de caractères le nombre d'octets qui sera réservé
en mémoire.
• Pour connaitre la longueur de la chaine : utiliser la fonction strlen de la bibliothèque string.h
• Example : strlen("un") donne 2, ne compte pas le caractère nul.
• Pour connaitre la taille d’un element utiliser sizeof (elem) : sizeof("un") donne 3.
• Pour connaitre la taille de type utiliser sizeof(Type) : sizeof(char) donne 1 octets.
Solution
a) char a[] = "un\ndeux\ntrois\n";
• Déclaration correcte
• Espace: 15 octets
b) char b[12] = "un deux trois";
• Déclaration incorrecte: la chaîne d'initialisation dépasse le bloc de mémoire réservé.
• Correction: char b[14] = "un deux trois"; ou mieux: char b[] = "un deux trois";
• Espace: 14octets
c) char c[] = 'abcdefg';
• Déclaration incorrecte: Les symboles '' encadrent des caractères; pour initialiser avec une
chaîne de caractères, il faut utiliser les guillemets (ou indiquer une liste de caractères).
• Correction: char c[] = "abcdefg";
• Espace: 8 octets
d) char d[10] = 'x';
• Déclaration incorrecte: Il faut utiliser une liste de caractères ou une chaîne pour l'initialisation
• Correction: char d[10] = {'x', '\0'} ou mieux: char d[10] = "x";
• Espace: 2 octets
e) char e[5] = "cinq";

[5]
 • Déclaration correcte
• Espace: 5 octets
f) char f[] = "Cette" "phrase" "est coupée";
• Déclaration correcte
• Espace: 23 octets
g) char g[2] = {'a', '\0'};
• Déclaration correcte
• Espace: 2 octets
h) char h[4] = {'a', 'b', 'c'};
• Déclaration incorrecte: Dans une liste de caractères, il faut aussi indiquer le symbole de fin de
chaîne.
• Correction: char h[4] = {'a', 'b', 'c', '\0'};
• Espace: 4 octets
i) char i[4] = "'o'";
• Déclaration correcte, mais d'une chaîne contenant les caractères'\'', 'o', '\'' et '\0'.
• Espace: 4 octets
Exercice 6 : Ecrire un programme qui lit un texte TXT (de moins de 200 caractères) et qui
enlève toutes les apparitions du charactère 'e' en tassant les éléments restants. Les
modifications se feront dans la même variable TXT.
Exemple : Cette ligne contient quelques lettres e. ➔Ctt lign contint qulqus lttrs
Solution
#include <stdio.h>
int main() {
/* Déclarations */
char TXT[201]; /* chaîne donnée */
int I ; /* indices courants */
int J; /*indice pour la nouvelle chaine sans ‘e’*/
/* Saisie des données */
printf("Entrez une ligne de texte (max.200 caractères) :\n");
gets(TXT);
/* Eliminer les lettres 'e' et comprimer : */
/* Copier les caractères de I vers J et incrémenter J */
/* seulement pour les caractères différents de 'e'. */
for (J=0,I=0 ; TXT[I] ; I++) {
/* TXT[I] : Condition de la boucle qui vérifie si le caractère à
l'indice I de TXT est nul (c'est-à-dire la fin de la chaîne). La
boucle s'exécute tant que ce n'est pas le cas.*/
TXT[J] = TXT[I];
if (TXT[I] != 'e') J++; }
/* Terminer la chaîne !! */
TXT[J]='\0';
/* Edition du résultat */
puts(TXT);
return 0;
}
Solution avec continue //fgets// printf
#include <stdio.h>
int main(){
/* Déclarations */
char TXT[201]; /* chaîne donnée */
int I ; /* indices courants */
int J; /* indice pour la nouvelle chaine sans ‘e’*/
/* Saisie des données */
printf("Entrez une ligne de texte (max.200 caractères) :\n");

[6]
 fgets(TXT, sizeof(TXT),stdin) ; // on a utilisé fgets à la place de
puts
/* Eliminer les lettres 'e' et comprimer : */
/* Copier les caractères de I vers J et incrémenter J */
/* seulement pour les caractères différents de 'e'. */
J=0;
for (I=0 ; TXT[I]!=0 ; I++) {
TXT[J] = TXT[I];
if (TXT[I] == 'e'){
continue ; }
J++;}
/* Terminer la chaîne !! */
TXT[J]='\0';
/* Edition du résultat */
printf("%s \n",TXT);
return 0; }
Solution avec while
#include <stdio.h>
int main() {
char TXT[201]; /*Chaîne donnée*/
int I = 0; /*Indice courant*/
/*Saisie des données*/
printf("Entrez une ligne de texte (max. 200 caractères) :\n");
fgets(TXT, sizeof(TXT), stdin);
/*Éliminer les lettres 'e' et comprimer la chaîne*/
int J = 0; /*Indice pour la nouvelle chaîne*/
while (TXT[I] != '\0') {
if (TXT[I] != 'e') {
TXT[J] = TXT[I];
J++;
}
I++;
}
/*Terminer la chaîne*/
TXT[J] = '\0';
/* Édition du résultat*/
printf("%s", TXT);
return 0;}
Exercice 7 : Ecrire un programme qui lit une chaîne de caractères CH et qui convertit toutes
les majuscules dans des minuscules et vice-versa. Le résultat sera mémorisé dans la même
variable CH et affiché après la conversion.
Solution
#include <stdio.h>
int main() {
/* Déclarations */
char CH[100]; /* chaîne à convertir */
int i; /* indice courant */
/* Saisie de la chaîne */
printf("Entrez la chaîne à convertir : ");
gets(CH);
/* Conversion de la chaîne */
for (i=0; CH[i]; i++) {
if (CH[i]>='A' && CH[i]<='Z')

[7]
 CH[i] = CH[i]-65+97;
else if (CH[i]>='a' && CH[i]<='z')
CH[i] = CH[i]-'a'+'A'; }
/* Affichage de la chaîne convertie */
printf("Chaîne convertie : %s\n", CH);
return 0;
}
Autre solution avec bibliotheque ctype
#include <stdio.h>
#include <ctype.h>

int main() {
char CH[100]; /*Chaîne de caractères*/
/*Saisie de la chaîne */
printf("Entrez une chaîne de caractères : ");
fgets(CH, sizeof(CH), stdin);
/*Conversion des majuscules en minuscules et vice-versa*/
for (int i = 0; CH[i]; i++) {
if (isupper(CH[i])) {
/*Si le caractère est une majuscule, le convertir en
minuscule*/
CH[i] = tolower(CH[i]);
} else if (islower(CH[i])) {
/*Si le caractère est une minuscule, le convertir en
majuscule*/
CH[i] = toupper(CH[i]);}
}
/*Afficher la chaîne convertie*/
printf("Chaîne convertie : %s", CH);
return 0;}
Autre solution avec
#include <stdio.h>
#include <string.h>
int main() {
char CH[100]; /* Chaîne de caractères */
/* Saisie de la chaîne */
printf("Entrez une chaîne de caractères : ");
fgets(CH, sizeof(CH), stdin);
/* Conversion des majuscules en minuscules et vice-versa */
for (int i = 0; i < strlen(CH); i++) {
if (CH[i] >= 'A' && CH[i] <= 'Z') {
/*Si le caractère est une majuscule, le convertir en
minuscule*/
CH[i] = CH[i] + 32;
} else if (CH[i] >= 'a' && CH[i] <= 'z') {
/*Si le caractère est une minuscule, le convertir en
majuscule*/
CH[i] = CH[i] - 32;}}
/*Afficher la chaîne convertie*/
printf("Chaîne convertie : %s", CH);
return 0;}

[8]
[9]