1. This site uses cookies. By continuing to use this site, you are agreeing to our use of cookies. Learn More.
Dismiss Notice
Welcome to our Education website, plz like our page facebook to support us. Thank You and wish you good navigation

Tableaux à une dimension en langage C: exercices avec correction

abdelouafiDec 6, 2017

    1. abdelouafi

      abdelouafi Administrator Staff Member

      Messages:
      402
      Likes Received:
      9
      Trophy Points:
      18
      Joined
      Sep 13, 2016
      Exercice 7.10 Maximum et minimum des valeurs d'un tableau


      Ecrire un programme 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é.





      Exercice 7.11 Insérer une valeur dans un tableau trié


      Un tableau A de dimension N+1 contient N valeurs entières triées par ordre croissant; la (N+1)ième valeur est indéfinie. Insérer une valeur VAL donnée au clavier dans le tableau A de manière à obtenir un tableau de N+1 valeurs triées.





      Exercice 7.12 Recherche d'une valeur dans un tableau


      Problème: Rechercher dans un tableau d'entiers A une valeur VAL entrée au clavier. Afficher la position de VAL si elle se trouve dans le tableau, sinon afficher un message correspondant. La valeur POS qui est utilisée pour mémoriser la position de la valeur dans le tableau, aura la valeur -1 aussi longtemps que VAL n'a pas été trouvée.





      Implémenter deux versions:



      a) La recherche séquentielle

      Comparer successivement les valeurs du tableau avec la valeur donnée.



      b) La recherche dichotomique ('recherche binaire', 'binary search')

      Condition: Le tableau A doit être trié

      Comparer le nombre recherché à la valeur au milieu du tableau,

      - s'il y a égalité ou si le tableau est épuisé, arrêter le traitement avec un message correspondant.

      - si la valeur recherchée précède la valeur actuelle du tableau, continuer la recherche dans le demi-tableau à gauche de la position actuelle.

      - si la valeur recherchée suit la valeur actuelle du tableau, continuer la recherche dans le demi-tableau à droite de la position actuelle.

      Ecrire le programme pour le cas où le tableau A est trié par ordre croissant.



      Question: Quel est l'avantage de la recherche dichotomique? Expliquer brièvement.





      Exercice 7.13 Fusion de deux tableaux triés


      Problème: On dispose de deux tableaux A et B (de dimensions respectives N et M), triés par ordre croissant. Fusionner les éléments de A et B dans un troisième tableau FUS trié par ordre croissant.



      Méthode: Utiliser trois indices IA, IB et IFUS. Comparer A[IA] et B[IB]; remplacer FUS[IFUS] par le plus petit des deux éléments; avancer dans le tableau FUS et dans le tableau qui a contribué son élément. Lorsque l'un des deux tableaux A ou B est épuisé, il suffit de recopier les éléments restants de l'autre tableau dans le tableau FUS.





      Exercice 7.14 Tri par sélection du maximum


      Problème: Classer les éléments d'un tableau A par ordre décroissant.

      Méthode: Parcourir le tableau de gauche à droite à l'aide de l'indice I. Pour chaque élément A du tableau, déterminer la position PMAX du (premier) maximum à droite de A et échanger A et A[PMAX].

      Exemple:

      [​IMG]





      Exercice 7.15 Tri par propagation (bubble sort)


      Problème: Classer les éléments d'un tableau A par ordre croissant.

      Méthode: En recommençant chaque fois au début du tableau, on effectue à plusieurs reprises le traitement suivant: On propage, par permutations successives, le plus grand élément du tableau vers la fin du tableau (comme une bulle qui remonte à la surface d'un liquide).

      Exemple:

      [​IMG]



      Implémenter l'algorithme en considérant que:

      * La partie du tableau (à droite) où il n'y a pas eu de permutations est triée.

      * Si aucune permutation n'a eu lieu, le tableau est trié.





      Exercice 7.16 Statistique des notes


      Ecrire un programme qui lit les points de N élèves d'une classe dans un devoir et les mémorise dans un tableau POINTS de dimension N.



      * Rechercher et afficher:

      - la note maximale,

      - la note minimale,

      - la moyenne des notes.



      * A partir des POINTS des élèves, établir un tableau NOTES de dimension 7 qui est composé de la façon suivante:

      NOTES[6] contient le nombre de notes 60

      NOTES[5] contient le nombre de notes de 50 à 59

      NOTES[4] contient le nombre de notes de 40 à 49

      ...

      NOTES[0] contient le nombre de notes de 0 à 9



      Etablir un graphique de barreaux représentant le tableau NOTES. Utilisez les symboles ####### pour la représentation des barreaux et affichez le domaine des notes en dessous du graphique.

      Idée: Déterminer la valeur maximale MAXN dans le tableau NOTES et afficher autant de lignes sur l'écran. (Dans l'exemple ci-dessous, MAXN = 6).



      Exemple:

      La note maximale est 58
      La note minimale est 13
      La moyenne des notes est 37.250000


      6 > #######
      5 > ####### #######
      4 > ####### ####### #######
      3 > ####### ####### ####### #######
      2 > ####### ####### ####### ####### #######
      1 > ####### ####### ####### ####### #######
      +-------+-------+-------+-------+-------+-------+-------+
      I 0 - 9 I 10-19 I 20-29 I 30-39 I 40-49 I 50-59 I 60 I


      D'autres exercices corrigés langage C:


      1. Exercices corrigés langage C
      2. Exercices sur Tableaux à une dimension langage c
      3. Controle N° 1 langage de programmation C - 1 ere année réseau
      4. Controle N° 1 langage C TRI 1 ere année 2018
      5. Afficher les nombres premiers en c
      6. TP sur langage C
      7. TD en langage C - 1 ere année OFPPT
      8. Nombres amis en langage C
      9. Dessiner triangle langage C
      10. Structure séquentielle - langage C
      11. structure alternative - langage c
      12. Exercice langage c if else
      13. switch ...case- exercice switch langage c
      14. La boucle while en c
      15. Examen : Langage de programmation c (2016/2017)
      16. Exercices corrigés sur les pointeurs en C
      17. Les matrices à deux dimensions en langage C - Tableaux 2 dimension
      18. Exercice langage c Tableau
      19. Trier un tableau en c
      20. Les fichiers langage c
      21. Exercice pour les intelligents
       
      Last edited: Dec 10, 2017
      Loading...
      Exercice 7.10 Maximum et minimum des valeurs d'un tableau


      Code:
      #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 */
      printf("Tableau donné :\n");
      for (I=0; I<N; I++)
           printf("%d ", A[I]);
      printf("\n");
      /* Recherche du maximum et du minimum */
      MIN=0;
      MAX=0;
      for (I=0; I<N; I++)
           {
            if(A[I]>A[MAX]) MAX=I;
            if(A[I]<A[MIN]) MIN=I;
           }
        /* Edition du résultat */
      printf("Position du minimum : %d\n", MIN);
      printf("Position du maximum : %d\n", MAX);
      printf("Valeur   du minimum : %d\n", A[MIN]);
      printf("Valeur   du maximum : %d\n", A[MAX]);
      return 0;
      }

      Exercice 7.11 Insérer une valeur dans un tableau trié
      Code:
      #include <stdio.h>[/B]
      [B]main()
      {
      /* Déclarations */
      int A[50]; /* tableau donné    */
      int VAL;   /* valeur à insérer */
      int N;     /* dimension        */
      int I;     /* indice courant   */
      
      /* Saisie des données */
      printf("Dimension N du tableau initial (max.50) : ");
      scanf("%d", &N );
      for (I=0; I<N; I++)
          {
           printf("Elément %d : ", I);
           scanf("%d", &A[I]);
          }
      printf("Elément à insérer : ");
      scanf("%d", &VAL );
      /* Affichage du tableau */
      printf("Tableau donné : \n");
      for (I=0; I<N; I++)
          printf("%d ", A[I]);
      printf("\n");
      /* Déplacer les éléments plus grands que */
      /* VAL d'une position vers l'arrière.    */
      for (I=N ; (I>0)&&(A[I-1]>VAL) ; I--)
             A[I]=A[I-1];
      /* VAL est copié à la position du dernier */
      /* élément déplacé. */
      A[I]=VAL;
      /* Nouvelle dimension du tableau ! */
      N++;
        /* Edition des résultats */
      printf("Tableau résultat :\n");
      for (I=0; I<N; I++)
          printf("%d ", A[I]);
      printf("\n");
      return 0;
      }
      


      Exercice 7.12 Recherche d'une valeur dans un tableau
      Code:
      a) La recherche séquentielle[/B][/SIZE][/B]
      [B][SIZE=4][B]
      Comparer successivement les valeurs du tableau avec la valeur donnée.
      
      #include <stdio.h>
      main()
      {
      /* Déclarations */
      int A[50]; /* tableau donné */
      int VAL;   /* valeur à rechercher   */
      int POS;   /* position de la valeur */
      int N;     /* dimension      */
      int I;     /* indice courant */
      
      /* 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]);
          }
      printf("Elément à rechercher : ");
      scanf("%d", &VAL );
      /* Affichage du tableau */
      printf("Tableau donné : \n");
      for (I=0; I<N; I++)
           printf("%d ", A[I]);
      printf("\n");
      /* Recherche de la position de la valeur */
      POS = -1;
      for (I=0 ; (I<N)&&(POS==-1) ; I++)
             if (A[I]==VAL)
                 POS=I;
        /* Edition du résultat */
      if (POS==-1)
           printf("La valeur recherchée ne se trouve pas "
                  "dans le tableau.\n");
        else
           printf("La valeur %d se trouve à la position %d. \n",
      VAL, POS);
      return 0;
      }
      b) La recherche dichotomique ('recherche binaire', 'binary search')
      
      
      #include <stdio.h>
      main()
      {
      /* Déclarations */
      int A[50]; /* tableau donné */
      int VAL;   /* valeur à rechercher   */
      int POS;   /* position de la valeur */
      int N;     /* dimension      */
      int I;     /* indice courant */
      int INF, MIL, SUP; /* limites du champ de recherche */
      /* 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]);
          }
      printf("Elément à rechercher : ");
      scanf("%d", &VAL );
      /* Affichage du tableau */
      printf("Tableau donné : \n");
      for (I=0; I<N; I++)
          printf("%d ", A[I]);
      printf("\n");
      /* Initialisation des limites du domaine de recherche */
      INF=0;
      SUP=N-1;
      /* Recherche de la position de la valeur */
      POS=-1;
      while ((INF<=SUP) && (POS==-1))
              {
               MIL=(SUP+INF)/2;
               if (VAL < A[MIL])
                     SUP=MIL-1;
               else if (VAL > A[MIL])
                     INF=MIL+1;
               else
                     POS=MIL;
              }
        /* Edition du résultat */
      if (POS==-1)
           printf("La valeur recherchée ne se trouve pas "
                  "dans le tableau.\n");
      else
           printf("La valeur %d se trouve à la position %d. \n",
      VAL, POS);
      return 0;
      }
      Question: Quel est l'avantage de la recherche dichotomique?
      
      Dans le pire des cas d'une recherche séquentielle, il faut traverser tout le tableau avant de trouver la valeur ou avant d'être sûr qu'une valeur ne se trouve pas dans le tableau.
      
      Lors de la recherche dichotomique, on élimine la moitié des éléments du tableau à chaque exécution de la boucle. Ainsi, la recherche se termine beaucoup plus rapidement.
      
      La recherche dichotomique devient extrêmement avantageuse pour la recherche dans de grands tableaux (triés) : L'avantage de la recherche dichotomique par rapport à la recherche séquentielle monte alors exponentiellement avec la grandeur du tableau à trier.
      
      Exemple:
      
      Lors de la recherche dans un tableau de 1024 éléments:
      
      -    le pire des cas pour la recherche séquentielle peut entraîner 1024 exécutions de la boucle.
      
      -    le pire des cas pour la recherche dichotomique peut entraîner 10 exécutions de la boucle.
      
      Lors de la recherche dans un tableau de 1 048 576 éléments:
      
      -    le pire des cas pour la recherche séquentielle peut entraîner 1 048 576 exécutions de la boucle.
      
      -    le pire des cas pour la recherche dichotomique peut entraîner 20 exécutions de la boucle.




      Exercice 7.13 Fusion de deux tableaux triés
      #include <stdio.h>
      main()
      {
      /* Déclarations */
      /* Les tableaux et leurs dimensions */
      int A[50], B[50], FUS[100];
      int N, M;
      int IA, IB, IFUS; /* indices courants */

      /* Saisie des données */
      printf("Dimension du tableau A (max.50) : ");
      scanf("%d", &N );
      printf("Entrer les éléments de A dans l'ordre croissant :\n");
      for (IA=0; IA<N; IA++)
      {
      printf("Elément A[%d] : ", IA);
      scanf("%d", &A[IA]);
      }
      printf("Dimension du tableau B (max.50) : ");
      scanf("%d", &M );
      printf("Entrer les éléments de B dans l'ordre croissant :\n");
      for (IB=0; IB<M; IB++)
      {
      printf("Elément B[%d] : ", IB);
      scanf("%d", &B[IB]);
      }
      /* Affichage des tableaux A et B */
      printf("Tableau A :\n");
      for (IA=0; IA<N; IA++)
      printf("%d ", A[IA]);
      printf("\n");
      printf("Tableau B :\n");
      for (IB=0; IB<M; IB++)
      printf("%d ", B[IB]);
      printf("\n");

      /* Fusion des éléments de A et B dans FUS */
      /* de façon à ce que FUS soit aussi trié. */
      IA=0; IB=0; IFUS=0;
      while ((IA<N) && (IB<M))
      if(A[IA]<B[IB])
      {
      FUS[IFUS]=A[IA];
      IFUS++;
      IA++;
      }
      else
      {
      FUS[IFUS]=B[IB];
      IFUS++;
      IB++;
      }
      /* Si IA ou IB sont arrivés à la fin de leur tableau, */
      /* alors copier le reste de l'autre tableau. */
      while (IA<N)
      {
      FUS[IFUS]=A[IA];
      IFUS++;
      IA++;
      }
      while (IB<M)
      {
      FUS[IFUS]=B[IB];
      IFUS++;
      IB++;
      }


      /* Edition du résultat */
      printf("Tableau FUS :\n");
      for (IFUS=0; IFUS<N+M; IFUS++)
      printf("%d ", FUS[IFUS]);
      printf("\n");
      return 0;
      }

      Exercice 7.14 Tri par sélection du maximum
      Code:
      #include <stdio.h>
      main()
      {
      /* Déclarations */
      int A[50]; /* tableau donné */
      int N;     /* dimension     */
      int I;     /* rang à partir duquel A n'est pas trié */
      int J;     /* indice courant      */
      int AIDE;  /* pour la permutation */
      int PMAX;  /* indique la position de l'élément */
                  /* maximal à droite de A[I]         */
      
      /* Saisie des données */
      printf("Dimension du tableau (max.50) : ");
      scanf("%d", &N );
      for (J=0; J<N; J++)
          {
           printf("Elément %d : ", J);
           scanf("%d", &A[J]);
          }
      /* Affichage du tableau */
      printf("Tableau donné :\n");
      for (J=0; J<N; J++)
          printf("%d ", A[J]);
      printf("\n");
      
      /* Tri du tableau par sélection directe du maximum. */
      for (I=0; I<N-1; I++)
           {
            /* Recherche du maximum à droite de A[I] */
            PMAX=I;
            for (J=I+1; J<N; J++)
                if (A[J]>A[PMAX]) PMAX=J;
            /* Echange de A[I] avec le maximum */
            AIDE=A[I];
            A[I]=A[PMAX];
            A[PMAX]=AIDE;
           }
        /* Edition du résultat */
      printf("Tableau trié :\n");
      for (J=0; J<N; J++)
           printf("%d ", A[J]);
      printf("\n");
      return 0;
      }
      Exercice 7.15 Tri par propagation (bubble sort)
      Code:
      #include <stdio.h>
      main()
      {
      /* Déclarations */
      int A[50]; /* tableau donné */
      int N;     /* dimension     */
      int I;     /* rang à partir duquel A est trié */
      int J;     /* indice courant      */
      int AIDE;  /* pour la permutation */
      int FIN;   /* position où la dernière permutation a eu lieu. */
              /* permet de ne pas trier un sous-ensemble déjà trié. */
      /* Saisie des données */
      printf("Dimension du tableau (max.50) : ");
      scanf("%d", &N );
      for (J=0; J<N; J++)
          {
           printf("Elément %d : ", J);
           scanf("%d", &A[J]);
          }
      /* Affichage du tableau */
      printf("Tableau donné :\n");
      for (J=0; J<N; J++)
          printf("%d ", A[J]);
      printf("\n");
      
      /* Tri du tableau par propagation de l'élément maximal. */
      for (I=N-1 ; I>0 ; I=FIN)
           {
            FIN=0;
            for (J=0; J<I; J++)
                  if (A[J]>A[J+1])
                  {
                   FIN=J;
                   AIDE=A[J];
                   A[J]=A[J+1];
                   A[J+1]=AIDE;
                  }
           }
        /* Edition du résultat */
      printf("Tableau trié :\n");
      for (J=0; J<N; J++)
           printf("%d ", A[J]);
      printf("\n");
      return 0;
      }
      Exercice 7.16 Statistique des notes
      Code:
      #include <stdio.h>
      main()
      {
      int POINTS[50];  /* tableau des points */
      int NOTES[7];    /* tableau des notes  */
      int N;           /* nombre d'élèves    */
      int I, IN;       /* compteurs d'aide   */
      int SOM;         /* somme des points   */
      int MAX, MIN;    /* maximum, minimum de points    */
      int MAXN;        /* nombre de lignes du graphique */
      
      /* Saisie des données */
      printf("Entrez le nombre d'élèves (max.50) : ");
      scanf("%d", &N);
      printf("Entrez les points des élèves:\n");
      for (I=0; I<N; I++)
          {printf("Elève %d:", I+1);
           scanf("%d", &POINTS[I]);
          }
      printf("\n");
      
      /* Calcul et affichage du maximum et du minimum des points */
      for (MAX=0, MIN=60, I=0; I<N; I++)
          {if (POINTS[I] > MAX) MAX=POINTS[I];
           if (POINTS[I] < MIN) MIN=POINTS[I];
          }
      printf("La note maximale est %d \n", MAX);
      printf("La note minimale est %d \n", MIN);
      /* Calcul et affichage de la moyenne des points */
      for (SOM=0,I=0 ; I<N ; I++)
            SOM += POINTS[I];
      printf("La moyenne des notes est %f \n", (float)SOM/N);
      /* Etablissement du tableau NOTES */
      for (IN=0 ; IN<7 ; IN++)
            NOTES[IN] = 0;
      for (I=0; I<N; I++)
            NOTES[POINTS[I]/10]++;
      /* Recherche du maximum MAXN dans NOTES */
      for (MAXN=0,IN=0 ; IN<7 ; IN++)
            if (NOTES[IN] > MAXN)
                MAXN = NOTES[IN];
      /* Affichage du graphique de barreaux */
      /* Représentation de MAXN lignes */
      for (I=MAXN; I>0; I--)
          {
           printf("\n %2d  >", I);
           for (IN=0; IN<7; IN++)
                {
                 if (NOTES[IN]>=I)
                     printf(" #######");
                 else
                     printf("        ");
                }
          }
      /* Affichage du domaine des notes */
      printf("\n      +");
      for (IN=0; IN<7; IN++)
            printf("-------+");
      printf("\n      I 0 - 9 I 10-19 I 20-29 "
              "I 30-39 I 40-49 I 50-59 I  60   I\n");
        return 0;
      }






Share This Page

Share