La fonction get_iemepermet de récupérer le i-ème élément d'un fichier...
Les tableaux en C sont une structure de données essentielle permettant de stocker une collection d’éléments du même type en mémoire. Ils sont largement utilisés pour organiser des données linéaires telles que des listes, des vecteurs ou des séquences d’éléments. Cet article explore en détail le concept des tableaux en C, en fournissant des explications théoriques suivies de plusieurs exercices corrigés pour renforcer la compréhension.
Un tableau en C est un bloc contigu de mémoire où sont stockées des variables du même type. Chaque élément du tableau peut être accédé à l’aide d’un indice (ou index) qui commence toujours par 0.
Syntaxe de déclaration :
type nom_tableau[taille];type : le type des éléments du tableau (par exemple, int, float, char).nom_tableau : le nom que vous souhaitez donner au tableau.taille : le nombre d’éléments que le tableau peut contenir.Exemple :
int tableau[5];Ici, tableau est un tableau de 5 entiers.
Un tableau peut être initialisé lors de sa déclaration. Si le nombre d’éléments fournis est inférieur à la taille du tableau, les éléments restants seront initialisés à 0.
Exemples :
int tableau[5] = {1, 2, 3, 4, 5};
int tableau_partiel[5] = {1, 2}; // Les éléments restants seront 0Chaque élément du tableau est accédé en utilisant un indice :
tableau[0] = 10; // Assigne 10 au premier élément
int x = tableau[2]; // x prend la valeur du troisième élémentLe parcours d’un tableau est souvent effectué à l’aide d’une boucle for :
for(int i = 0; i < 5; i++) {
printf("%d ", tableau[i]);
}Exercice 1 : Trouver le Maximum d’un Tableau
Énoncé : Écrire un programme en C pour trouver le plus grand élément dans un tableau d’entiers.
Solution :
#include <stdio.h>
int main() {
int tableau[] = {10, 20, 30, 25, 15};
int max = tableau[0];
int taille = sizeof(tableau) / sizeof(tableau[0]);
for(int i = 1; i < taille; i++) {
if(tableau[i] > max) {
max = tableau[i];
}
}
printf("Le maximum est : %d\n", max);
return 0;
}Explication : On initialise max avec le premier élément du tableau, puis on parcourt les éléments restants pour mettre à jour max si un élément plus grand est trouvé.
Exercice 2 : Inverser un Tableau
Énoncé : Écrire un programme en C pour inverser les éléments d’un tableau.
Solution :
#include <stdio.h>
int main() {
int tableau[] = {1, 2, 3, 4, 5};
int taille = sizeof(tableau) / sizeof(tableau[0]);
for(int i = 0; i < taille / 2; i++) {
int temp = tableau[i];
tableau[i] = tableau[taille - i - 1];
tableau[taille - i - 1] = temp;
}
printf("Tableau inversé : ");
for(int i = 0; i < taille; i++) {
printf("%d ", tableau[i]);
}
printf("\n");
return 0;
}Explication : Le programme utilise une boucle pour échanger les éléments symétriques du tableau, de sorte que le premier devient le dernier, le second devient l’avant-dernier, et ainsi de suite.
Exercice 3 : Calculer la Somme des Éléments d’un Tableau
Énoncé : Écrire un programme en C pour calculer la somme de tous les éléments d’un tableau d’entiers.
Solution :
#include <stdio.h>
int main() {
int tableau[] = {1, 2, 3, 4, 5};
int taille = sizeof(tableau) / sizeof(tableau[0]);
int somme = 0;
for(int i = 0; i < taille; i++) {
somme += tableau[i];
}
printf("La somme des éléments est : %d\n", somme);
return 0;
}Explication : Le programme parcourt chaque élément du tableau et ajoute sa valeur à la variable somme.
Les tableaux sont une structure de données fondamentale en C, et leur maîtrise est cruciale pour tout programmeur. Grâce aux exercices corrigés présentés, vous devriez maintenant avoir une meilleure compréhension de la manière de manipuler les tableaux pour résoudre des problèmes courants. Pour aller plus loin, vous pouvez explorer les tableaux multidimensionnels, les pointeurs et la gestion dynamique des tableaux.
Pour approfondir vos compétences, essayez de résoudre les exercices suivants :
Chacun de ces exercices renforce des concepts clés liés à la manipulation des tableaux en C.
Voici les exercices demandés avec leurs solutions détaillées :
Énoncé : Écrire un programme en C qui calcule la moyenne des éléments d’un tableau d’entiers.
Détail : Le programme doit parcourir le tableau pour additionner tous les éléments, puis diviser cette somme par le nombre total d’éléments pour obtenir la moyenne.
Solution :
#include <stdio.h>
int main() {
int tableau[] = {10, 20, 30, 40, 50};
int taille = sizeof(tableau) / sizeof(tableau[0]);
int somme = 0;
float moyenne;
// Calcul de la somme des éléments
for(int i = 0; i < taille; i++) {
somme += tableau[i];
}
// Calcul de la moyenne
moyenne = (float)somme / taille;
// Affichage de la moyenne
printf("La moyenne des éléments est : %.2f\n", moyenne);
return 0;
}Explication : Le programme parcourt le tableau pour calculer la somme de tous les éléments, puis divise cette somme par le nombre d’éléments pour obtenir la moyenne. Le résultat est affiché avec deux décimales.
Énoncé : Écrire un programme en C qui trie un tableau d’entiers en ordre croissant.
Détail : Le programme doit utiliser l’algorithme de tri à bulles (ou un autre algorithme de tri simple) pour réorganiser les éléments du tableau dans l’ordre croissant.
Solution :
#include <stdio.h>
int main() {
int tableau[] = {5, 3, 8, 4, 2};
int taille = sizeof(tableau) / sizeof(tableau[0]);
int temp;
// Algorithme de tri à bulles
for(int i = 0; i < taille - 1; i++) {
for(int j = 0; j < taille - i - 1; j++) {
if(tableau[j] > tableau[j + 1]) {
// Échange des éléments
temp = tableau[j];
tableau[j] = tableau[j + 1];
tableau[j + 1] = temp;
}
}
}
// Affichage du tableau trié
printf("Tableau trié en ordre croissant : ");
for(int i = 0; i < taille; i++) {
printf("%d ", tableau[i]);
}
printf("\n");
return 0;
}Explication : Le programme utilise l’algorithme de tri à bulles pour comparer chaque paire d’éléments adjacents du tableau et les échanger si nécessaire, jusqu’à ce que le tableau soit entièrement trié en ordre croissant.
Ces exercices permettent de pratiquer des opérations fondamentales sur les tableaux, comme le calcul de la moyenne et le tri, tout en renforçant les compétences de programmation en C.
Voici quelques exercices particuliers sur les tableaux en C, accompagnés de leur solution détaillée. Ces exercices sont conçus pour mettre en pratique des concepts spécifiques et approfondir votre compréhension.
Énoncé : Écrire un programme en C qui supprime un élément spécifique d’un tableau d’entiers et décale les éléments restants pour combler l’espace laissé.
Détail : Le programme doit demander à l’utilisateur de saisir la position de l’élément à supprimer et afficher le tableau après suppression.
Solution :
#include <stdio.h>
int main() {
int tableau[] = {1, 2, 3, 4, 5};
int taille = sizeof(tableau) / sizeof(tableau[0]);
int position;
printf("Entrez la position de l'élément à supprimer (1 à %d) : ", taille);
scanf("%d", &position);
if(position < 1 || position > taille) {
printf("Position invalide.\n");
return 1;
}
// Décaler les éléments vers la gauche à partir de la position
for(int i = position - 1; i < taille - 1; i++) {
tableau[i] = tableau[i + 1];
}
taille--; // Réduire la taille du tableau
printf("Tableau après suppression : ");
for(int i = 0; i < taille; i++) {
printf("%d ", tableau[i]);
}
printf("\n");
return 0;
}Explication : Le programme décale les éléments du tableau vers la gauche à partir de la position spécifiée par l’utilisateur, puis il réduit la taille logique du tableau.
Énoncé : Écrire un programme en C qui insère un nouvel élément à une position donnée dans un tableau d’entiers.
Détail : Le programme doit demander à l’utilisateur de saisir la position d’insertion ainsi que la valeur à insérer. Le tableau doit être agrandi si nécessaire.
Solution :
#include <stdio.h>
int main() {
int tableau[6] = {1, 2, 3, 4, 5};
int taille = 5;
int position, valeur;
printf("Entrez la position d'insertion (1 à %d) : ", taille + 1);
scanf("%d", &position);
printf("Entrez la valeur à insérer : ");
scanf("%d", &valeur);
if(position < 1 || position > taille + 1) {
printf("Position invalide.\n");
return 1;
}
// Décaler les éléments vers la droite
for(int i = taille; i >= position; i--) {
tableau[i] = tableau[i - 1];
}
tableau[position - 1] = valeur;
taille++; // Augmenter la taille logique du tableau
printf("Tableau après insertion : ");
for(int i = 0; i < taille; i++) {
printf("%d ", tableau[i]);
}
printf("\n");
return 0;
}Explication : Le programme déplace les éléments du tableau vers la droite à partir de la position donnée pour faire de la place à la nouvelle valeur, puis il met à jour la taille du tableau.
Énoncé : Écrire un programme en C qui fusionne deux tableaux d’entiers en un seul tableau.
Détail : Le programme doit prendre deux tableaux, les fusionner et afficher le tableau fusionné.
Solution :
#include <stdio.h>
int main() {
int tableau1[] = {1, 2, 3};
int tableau2[] = {4, 5, 6, 7};
int taille1 = sizeof(tableau1) / sizeof(tableau1[0]);
int taille2 = sizeof(tableau2) / sizeof(tableau2[0]);
int tableau_fusion[7];
// Fusion des deux tableaux
for(int i = 0; i < taille1; i++) {
tableau_fusion[i] = tableau1[i];
}
for(int i = 0; i < taille2; i++) {
tableau_fusion[taille1 + i] = tableau2[i];
}
// Affichage du tableau fusionné
printf("Tableau fusionné : ");
for(int i = 0; i < taille1 + taille2; i++) {
printf("%d ", tableau_fusion[i]);
}
printf("\n");
return 0;
}Explication : Le programme copie d’abord les éléments du premier tableau, puis ceux du deuxième tableau, dans un tableau de taille suffisante pour contenir tous les éléments.
Énoncé : Écrire un programme en C qui sépare les nombres pairs et impairs d’un tableau d’entiers dans deux tableaux distincts.
Détail : Le programme doit parcourir un tableau d’entiers, identifier les nombres pairs et impairs, et les stocker dans deux tableaux différents.
Solution :
#include <stdio.h>
int main() {
int tableau[] = {1, 2, 3, 4, 5, 6, 7, 8};
int taille = sizeof(tableau) / sizeof(tableau[0]);
int pairs[8], impairs[8];
int index_pair = 0, index_impair = 0;
for(int i = 0; i < taille; i++) {
if(tableau[i] % 2 == 0) {
pairs[index_pair++] = tableau[i];
} else {
impairs[index_impair++] = tableau[i];
}
}
printf("Nombres pairs : ");
for(int i = 0; i < index_pair; i++) {
printf("%d ", pairs[i]);
}
printf("\n");
printf("Nombres impairs : ");
for(int i = 0; i < index_impair; i++) {
printf("%d ", impairs[i]);
}
printf("\n");
return 0;
}Explication : Le programme utilise deux tableaux pour stocker les nombres pairs et impairs respectivement, en parcourant le tableau d’origine et en triant les éléments selon leur parité.
Énoncé : Écrire un programme en C qui identifie et affiche les éléments en double dans un tableau d’entiers.
Détail : Le programme doit parcourir le tableau et détecter tout élément qui apparaît plus d’une fois.
Solution :
#include <stdio.h>
int main() {
int tableau[] = {1, 2, 3, 2, 4, 5, 3, 6, 7};
int taille = sizeof(tableau) / sizeof(tableau[0]);
int duplicata[taille];
int index_duplicata = 0;
for(int i = 0; i < taille; i++) {
for(int j = i + 1; j < taille; j++) {
if(tableau[i] == tableau[j]) {
// Vérifie si ce duplicata a déjà été ajouté
int deja_ajoute = 0;
for(int k = 0; k < index_duplicata; k++) {
if(duplicata[k] == tableau[i]) {
deja_ajoute = 1;
break;
}
}
if(!deja_ajoute) {
duplicata[index_duplicata++] = tableau[i];
}
}
}
}
printf("Éléments en double : ");
for(int i = 0; i < index_duplicata; i++) {
printf("%d ", duplicata[i]);
}
printf("\n");
return 0;
}Explication : Le programme parcourt chaque paire d’éléments du tableau pour identifier les doublons, puis il les stocke dans un tableau séparé en évitant les doublons dans cette liste.
Ces exercices vous aideront à approfondir vos compétences en manipulation de tableaux en C, tout en abordant des situations pratiques qui peuvent survenir dans des scénarios réels.
Excel permet de calculer différents types d'écarts selon le contexte, que ce soit pour des…
Les macros sont des programmes ou des scripts utilisés pour automatiser des tâches dans Excel.…
L’écart-type est une mesure statistique qui indique la dispersion des données par rapport à leur…
La composition des ventes fait référence à la répartition des ventes entre différents produits, catégories…
L’écart en pourcentage permet de comparer une valeur réelle par rapport à une valeur attendue,…
Les écarts sur charges fixes permettent d'analyser les différences entre les charges fixes budgétées et…
This website uses cookies.