Cours 9.6. Exercices sur les tableaux en C

Exercices

Exercice 1

Écrire une fonction moyenne() qui reçoit 3 tableaux en paramètres. La fonction calcule les moyennes individuelles de deux premiers tableaux (une moyenne pour chaque ligne des tableaux). Les moyennes sont stockées dans le troisième tableau. Calculer et afficher la moyenne des tableaux notes1 et notes2 :

note[0] = 10.10
note[1] = 11.25
note[2] = 14.25
note[3] = 9.90
note[4] = 11.60
note[5] = 11.05

#include <stdio.h> // Nombre de notes #define NB_NOTES 6 // Fonction qui affiche les notes void affiche(const float notes[], int size); // Fonction qui met les notes à zéro void init(float notes[], int size, float note); // Calcule la moyenne de deux tableaux // COMPLETER ICI int main(void) { // Tableaux de notes float notes1[NB_NOTES] = {10.2, 12.5, 18.5, 9.8, 13.2, 12.1}; float notes2[NB_NOTES]; float moyennes[NB_NOTES]; // Initialise et affiche le tableau notes2 init(notes2, NB_NOTES, 10); // Calcule la moyenne des deux tableaux // COMPLETER ICI // Affiche les moyennes affiche(moyennes, NB_NOTES); return 0; } // Calcule la moyenne des deux tableaux // COMPLETER ICI // Initialise un tableau avec note void init(float notes[], int size, float note) { int i; for (i=0;i<size;i++) notes[i]=note; } // Affiche un tableau void affiche(const float notes[], int size) { int i; for (i=0;i<size;i++) printf ("note[%d]\t= %.2f\n", i, notes[i]); }

Exercice 2

Écrire une fonction moyenneGenerale() qui reçoit un tableau en paramètres et retourne la moyenne de ce tableau. Grâce à la fonction, calculer et afficher la moyenne du tableau notes1 :

Moyenne : 12.72

#include <stdio.h> // Nombre de notes #define NB_NOTES 6 // Fonction qui affiche les notes void affiche(const float notes[], int size); // Calcule la moyenne d'un tableau // COMPLETER ICI int main(void) { // Tableaux de notes float notes1[NB_NOTES] = {10.2, 12.5, 18.5, 9.8, 13.2, 12.1}; // Calcule et affiche la moyenne du tableau notes1 // COMPLETER ICI return 0; } // Calcule la moyenne d'un tableau // COMPLETER ICI // Affiche un tableau void affiche(const float notes[], int size) { int i; for (i=0;i<size;i++) printf ("note[%d]\t= %.2f\n", i, notes[i]); }

Exercice 3

Écrire une fonction void copie(const float src[], float dest[], int size); qui reçoit 2 tableaux en paramètres. Cette fonction recopie toutes les valeurs du tableau src dans dest. Grâce à cette fonction, copier le tableau notes1 dans le tableau notes2. Vérifier en affichant notes2 :

note[0] = 10.20
note[1] = 12.50
note[2] = 18.50
note[3] = 9.80
note[4] = 13.20
note[5] = 12.10

#include <stdio.h> // Nombre de notes #define NB_NOTES 6 // Fonction qui affiche les notes void affiche(const float notes[], int size); // Copie le tableau src dans dest void copie(const float src[], float dest[], int size); int main(void) { // Tableaux de notes float notes1[NB_NOTES] = {10.2, 12.5, 18.5, 9.8, 13.2, 12.1}; float notes2[NB_NOTES]; // Copie le tableau notes1 dans le tableau note2 // et affiche notes2 // A COMPLETER return 0; } // Copie le tableau src dans dest // A COMPLETER // Affiche un tableau void affiche(const float notes[], int size) { int i; for (i=0;i<size;i++) printf ("note[%d]\t= %.2f\n", i, notes[i]); }

Exercice 4

Écrire une fonction int compare(const float t1[], const float t2[], int size); qui reçoit 2 tableaux en paramètres. Cette fonction compte le nombre d'éléments ayant le même indice et la même valeur dans les deux tableaux. Tester la fonction avec les tableaux suivants :

  float notes1[NB_NOTES] = {10.2, 12.5, 18.5, 9.8, 13.2, 12.1};
  float notes2[NB_NOTES] = {15.7, 12.5, 15.3, 9.8, 10.8, 12.1};

Il y a 3 notes identiques.

#include <stdio.h> // Nombre de notes #define NB_NOTES 6 // Fonction qui affiche les notes void affiche(const float notes[], int size); // Calcule la moyenne d'un tableau void copie(const float src[], float dest[], int size); // Retourne 1 si les deux tableaux sont identiques // COMPLETER ICI int main(void) { // Tableaux de notes float notes1[NB_NOTES] = {10.2, 12.5, 18.5, 9.8, 13.2, 12.1}; float notes2[NB_NOTES]; // Teste si les tableaux sont identiques // COMPLETER ICI // Copie le tableau notes1 dans le tableau note2 // COMPLETER ICI // Teste si les tableaux sont identiques // COMPLETER ICI return 0; } // Retourne 1 si les deux tableaux sont identiques // COMPLETER ICI // Calcule la moyenne d'un tableau void copie(const float src[], float dest[], int size) { int i; for (i=0;i<size;i++) dest[i]=src[i]; } // Affiche un tableau void affiche(const float notes[], int size) { int i; for (i=0;i<size;i++) printf ("note[%d]\t= %.2f\n", i, notes[i]); }

Exercice 5

Écrire une fonction egal() qui reçoit 2 tableaux en paramètres. Cette fonction retourne :

• 1 si les deux tableaux sont strictement identiques ;
• 0 sinon.
• Comparer les tableaux notes1 et notes2 avant et après copie :

Avant copie : Les tableaux sont différents.
Après copie : les tableaux sont identiques.

#include <stdio.h> // Nombre de notes #define SIZE 8 // Fonction qui retourne la valeur maximale d'un tableau int maxTab(int tab[], int size); int main(void) { // Déclaration et initialisation d'un tableau int tab[SIZE] = {12, 5, 8, 18, 3, 98, 0, 16}; printf ("La plus grande valeur du tableau est : %d\n", maxTab(tab, SIZE)); return 0; } int maxTab(int tab[], int size) { // Déclare une variable max // qui représente la plus grande valeur connue du tableau // Au début, on initialise max avec la première valeur (tab[0]) // COMPLETER ICI // On parcourt toutes les cellules du tableau // Si une cellule est plus grande que max, // On actualise max avec le nouveau maximum // COMPLETER ICI // Retourne max, la plus grande valeur du tableau // COMPLETER ICI }

Exercice 6

Écrire une fonction maxTab() qui reçoit un tableau et sa taille en paramètres. La fonction retourne la plus grande valeur du tableau.

int maxTab(int tab[], int size);

La plus grande valeur du tableau est : 98

#include <stdio.h> // Nombre de notes #define SIZE 8 // Fonction qui retourne la valeur maximale d'un tableau int argmax(int tab[], int size); int main(void) { // Déclaration et initialisation d'un tableau int tab[SIZE] = {12, 5, 0, 18, 8, 98, 0, 16}; printf ("Le premier indice du plus petit élément du tableau est : %d\n", argmax(tab, SIZE)); return 0; } int argmax(int tab[], int size) { // Déclare la variable imax // imax représente l'indice du plus petit élément // Initialise imax à 0 (première cellule) // COMPLETER ICI // On parcourt toutes les cellules du tableau // Si une cellule est plus petite que tab[imax], // On actualise imax avec le nouvel indice // COMPLETER ICI // Retourne imax, l'indice du plus petit // COMPLETER ICI }

Exercice 7

Écrire une fonction argmax() qui reçoit un tableau et sa taille en paramètres. La fonction retourne le premier indice du plus petit élément du tableau.

int argmax(int tab[], int size);

Le premier indice du plus petit élément du tableau est  : 2

#include <stdio.h> // Nombre de notes #define SIZE 8 // Affiche le tableau passé en paramètre void afficheTab(int tab[], int taille); // Fonction qui trie un tableau dans l'ordre croissant void tri(int tab[], int size); int main(void) { // Déclaration et initialisation d'un tableau int tab[SIZE] = {12, 5, 0, 18, 8, 98, 5, 16}; // Affiche le tableau initial printf ("Tableau initial : "); afficheTab(tab, SIZE); // Trie le tableau tri (tab, SIZE); // Affiche le tableau trié printf ("Tableau trié : "); afficheTab(tab, SIZE); return 0; } // Affiche le tableau passé en paramètre void afficheTab(int tab[], int taille) { for (int i=0 ; i<taille ; i++) printf ("%2d ", tab[i]); printf ("\n"); } // Tri le tableau dans l'ordre croissant void tri(int tab[], int taille) { // COMPLETER ICI }

Exercice 8

Écrire une fonction tri() qui reçoit un tableau et sa taille en paramètres. La fonction trie le tableau dans l'ordre croissant.

void tri(int tab[], int size);

Pour réaliser cet exercice, vous pouvez vous inspirer du tri à bulle, dont l'algorithme est présenté sur la page Wikipedia. Voici le résultat du tri :

Tableau initial : 12 54  0 18  8 98  5 16 58  4 75  5 
Tableau trié    :  0  4  5  5  8 12 16 18 54 58 75 98 

#include <stdio.h> // Nombre de notes #define SIZE 8 // Affiche le tableau passé en paramètre void afficheTab(int tab[], int taille); // Fonction qui trie un tableau dans l'ordre croissant void tri(int tab[], int size); int main(void) { // Déclaration et initialisation d'un tableau int tab[SIZE] = {12, 5, 0, 18, 8, 98, 5, 16}; // Affiche le tableau initial printf ("Tableau initial : "); afficheTab(tab, SIZE); // Trie le tableau tri (tab, SIZE); // Affiche le tableau trié printf ("Tableau trié : "); afficheTab(tab, SIZE); return 0; } // Affiche le tableau passé en paramètre void afficheTab(int tab[], int taille) { for (int i=0 ; i<taille ; i++) printf ("%2d ", tab[i]); printf ("\n"); } // Tri le tableau dans l'ordre croissant void tri(int tab[], int taille) { // COMPLETER ICI }

Voir aussi

• Cours de programmation en C
• Cours 1.1. Histoire du C
• Cours 1.2. Premier programme
• Cours 1.3. Compilation
• Cours 1.4. Les directives de compilation
• Cours 1.5. Quel compilateur choisir ?
• Cours 1.6. Les organigrammes
• Cours 2.1. Les types de variables
• Cours 2.2. Les entiers
• Cours 2.3. Les nombres décimaux
• Cours 2.4. Les caractères
• Cours 2.5. Initialisation des variables
• Cours 2.6. Le vol 501 d'Ariane
• Cours 3.1. Les opérateurs arithmétiques
• Cours 3.2. Le modulo
• Cours 3.3. Le type dans les opérations
• Cours 3.4. Les conversion de type forcé
• Cours 3.5. Les opérateurs bit à bit
• Cours 3.6. Détail des opérateurs bit à bit
• Cours 3.7. Opérateurs de décalage
• Cours 3.8. Opérateurs d'affectation
• Cours 3.9. Opérateur d'incrémentation/décrémentation
• Cours 3.10. Les opérateurs de comparaison
• Cours 3.11. Opérateurs logiques
• Cours 3.12. Priorité des opérateurs
• Cours 4.1. printf
• Cours 4.2. scanf
• Cours 4.3. putchar
• Cours 5.1. Branchement conditionnel (if...else)
• Cours 5.2. if imbriqués et indentation
• Cours 5.3. Tester des intervalles
• Cours 5.4. Opérateur conditionnel ternaire ( ?: )
• Cours 5.5. L'instruction switch..case
• Cours 5.6. Le break dans les switchs
• Cours 6.1. La boucle do..while en C
• Cours 6.2. La boucle while en C
• Cours 6.3. La boucle for
• Cours 6.4. Comment choisir une boucle en C ?
• Cours 6.5. Exercices sur les boucles en C
• Cours 7.1. Masquages
• Cours 7.2. Masquage : forçage à zéro
• Cours 7.3. Forçage à un
• Cours 7.4. Inversion de bits
• Cours 7.5. Tester un bit
• Cours 7.6. Synthèse des masquages
• Cours 8.1. Syntaxe des fonctions en C
• Cours 8.2. L'appel des fonctions
• Cours 8.3. Le mot-clé void dans les fonctions
• Cours 8.4. Le mot-clé return dans les fonctions
• Cours 8.5. Portée des variables
• Cours 8.6. Les variables globales
• Cours 8.7. Les variables statiques
• Cours 8.8. Nombres aléatoires en C
• Cours 8.9. Fonctions mathématiques en C
• Cours 9.1. Syntaxe des tableaux en C
• Cours 9.2. Initialisation des tableaux en C
• Cours 9.3. Les tableaux multidimensionnels en C
• Cours 9.4. Comment les tableaux sont stockés en mémoire en C?
• Cours 9.5. Les tableaux dans les fonctions
• Cours 10.1. Les chaines de caractères en C
• Cours 10.2. Le caractère de fin de chaîne
• Cours 10.3. La bibliothèque string.h
• Cours 10.4. Chaînes de caractères et fonctions
• Cours 11.1. Introduction aux pointeurs en C
• Cours 11.2. Syntaxe des pointeurs en C
• Cours 11.3. Allocation mémoire dynamique
• Cours 11.4. Incrémentation des pointeurs
• Cours 11.5. Passage de paramètres par pointeur
• Cours 12.1. Introduction aux structures en C
• Cours 12.2. Propriétés des structures en C
• Cours 12.3. Structures et pointeurs
• Cours 12.4. Structures et fonctions
• Cours 13.1. Fonctions récursives en C
• Cours 13.2. Profondeur des fonctions récursives
• Cours 13.3. Récursion croisée
• Cours 14.1. Exercices complémentaires

---