Pages

dimanche 26 janvier 2014

Exercices corrigés en langage C : Les structures répétitives en langage C

Exercice 1:

Ecrivez un programme en langage C qui lit N nombres entiers au clavier et qui affiche leur somme, leur produit et leur moyenne. Choisissez un type approprié pour les valeurs à afficher. Le nombre N est à entrer au clavier. Résolvez ce problème,
a) en utilisant while,
b) en utilisant do - while,
c) en utilisant for.
d) Laquelle des trois variantes est la plus naturelle pour ce problème?

Correction exercice 1 :

a) en utilisant while,
#include <stdio.h>
main()
{
 int N;       /* nombre de données */
 int NOMB;    /* nombre courant    */
 int I;       /* compteur */
 long SOM;    /* la somme   des nombres entrés */
 double PROD; /* le produit des nombres entrés */

 printf("Nombre de données : ");
 scanf("%d", &N);

 SOM=0;
 PROD=1;
 I=1;
 while(I<=N)
    {
     printf("%d. nombre : ", I);
     scanf("%d", &NOMB);
     SOM  += NOMB;
     PROD *= NOMB;
     I++;
    }

 printf("La somme   des %d nombres est %ld \n", N, SOM);
 printf("Le produit des %d nombres est %.0f\n", N, PROD);
 printf("La moyenne des %d nombres est %.4f\n", N, (float)SOM/N);
 return 0;
}

b) en utilisant do - while,

#include <stdio.h>
main()
{
 int N;       /* nombre de données */
 int NOMB;    /* nombre courant    */
 int I;       /* compteur */
 long SOM;    /* la somme   des nombres entrés */
 double PROD; /* le produit des nombres entrés */

 printf("Nombre de données : ");
 scanf("%d", &N);

 SOM=0;
 PROD=1;
 I=1;
 do
    {
     printf("%d. nombre : ", I);
     scanf("%d", &NOMB);
     SOM  += NOMB;
     PROD *= NOMB;
     I++;
    }
 while(I<=N);

 printf("La somme   des %d nombres est %ld \n", N, SOM);
 printf("Le produit des %d nombres est %.0f\n", N, PROD);
 printf("La moyenne des %d nombres est %.4f\n", N, (float)SOM/N);
 return 0;
}


c) en utilisant for.
main()
{
 int N;       /* nombre de données */
 int NOMB;    /* nombre courant    */
 int I;       /* compteur */
 long SOM;    /* la somme   des nombres entrés */
 double PROD; /* le produit des nombres entrés */

 printf("Nombre de données : ");
 scanf("%d", &N);

 for (SOM=0, PROD=1, I=1 ; I<=N ; I++)
    {
     printf("%d. nombre : ", I);
     scanf("%d", &NOMB);
     SOM  += NOMB;
     PROD *= NOMB;
    }

 printf("La somme   des %d nombres est %ld \n", N, SOM);
 printf("Le produit des %d nombres est %.0f\n", N, PROD);
 printf("La moyenne des %d nombres est %.4f\n", N, (float)SOM/N);
 return 0;
}


d) Laquelle des trois variantes est la plus naturelle pour ce problème?
La structure for est la plus compacte et celle qui exprime le mieux l'idée de l'algorithme. D'autre part, elle permet d'intégrer très confortablement l'initialisation et l'incrémentation des variables dans la structure.

Exercice 2:

Calculez par des soustractions successives le quotient entier et le reste de la division entière de deux entiers entrés au clavier.

Correction exercice 2 :

#include <stdio.h>
main()
{
 int NUM;   /* numérateur   de la division entière */
 int DEN;   /* dénominateur de la division entière */
 int DIV;   /* résultat de la division entière */
 int RES;   /* reste    de la division entière */

 printf("Introduisez le numérateur   : ");
 scanf("%d", &NUM);
 printf("Introduisez le dénominateur : ");
 scanf("%d", &DEN);

 RES=NUM;
 DIV=0;
 while(RES>=DEN)
    {
     RES-=DEN;
     DIV++;
    }

/* ou mieux encore : */
/*
 for (RES=NUM, DIV=0 ; RES>=DEN ; DIV++)
      RES-=DEN;
 */

 printf(" %d divisé par %d est %d reste %d\n", NUM, DEN, DIV, RES);
 return 0;
}

Exercice 3:

Calculez la factorielle N! = 1*2*3*...*(N-1)*N d'un entier naturel N en respectant que 0!=1.
a) Utilisez while,
b) Utilisez for.

Correction exercice 3 :

a)  avec la boucle while,
#include <stdio.h>
main()
{
 int  N;      /* La donnée   */
 int  I;      /* Le compteur */
 double FACT; /* La factorielle N! - Type double à */
              /* cause de la grandeur du résultat. */

 do
    {
      printf("Entrez un entier naturel : ");
     scanf("%d", &N);
    }
 while (N<0);

 /* a */
 /* Pour N=0, le résultat sera automatiquement 0!=1 */
 I=1;
 FACT=1;
 while (I<=N)
       {
        FACT*=I;
        I++;
       }

 printf ("%d! = %.0f\n", N, FACT);
 return 0;
}

b)  avec la boucle for,
#include <stdio.h>
main()
{
 int  N;      /* La donnée   */
 int  I;      /* Le compteur */
 double FACT; /* La factorielle N! - Type double à */
              /* cause de la grandeur du résultat. */

 do
    {
      printf("Entrez un entier naturel : ");
     scanf("%d", &N);
    }
 while (N<0);

for (FACT=1.0, I=1 ; I<=N ; I++)
        FACT*=I;

 printf ("%d! = %.0f\n", N, FACT);
 return 0;
}


Exercice 4:

Calculez par multiplications successives XN de deux entiers naturels X et N entrés au clavier.

Correction exercice 4 :

#include <stdio.h>
main()
{
 int  X, N;   /* Les données */
 int  I;      /* Le compteur */
 double RESU; /* Type double à cause de la */
              /* grandeur du résultat.     */

 do
    {
      printf("Entrez l'entier naturel X : ");
     scanf("%d", &X);
    }
 while (X<0);
 do
    {
      printf("Entrez l'exposant       N : ");
     scanf("%d", &N);
    }
 while (N<0);

 /* Pour N=0, le résultat sera automatiquement X^0=1 */
 for (RESU=1.0, I=1 ; I<=N ; I++)
        RESU*=X;

 /* Attention: Pour X=0 et N=0 , 0^0 n'est pas défini */
 if (N==0 && X==0)
     printf("zéro exposant zéro n'est pas défini !\n");
 else
     printf("Résultat : %d ^ %d = %.0f\n", X, N, RESU);
  return 0;
}

Exercice 5:

Calculez la somme des N premiers termes de la série harmonique :
1 + 1/2 + 1/3 + ... + 1/N

Correction exercice 5 :

#include <stdio.h>
main()
{
 int N;     /* nombre de termes à calculer */
 int I;     /* compteur pour la boucle */
 float SOM; /* Type float à cause de la précision du résultat.   */
 do
   {
     printf ("Nombre de termes: ");
    scanf ("%d", &N);
   }
 while (N<1);
 for (SOM=0.0, I=1 ; I<=N ; I++)
    SOM += (float)1/I;
  printf("La somme des %d premiers termes est %f \n", N, SOM);
 return 0;
}

Exercice 6:

Calculez la somme, le produit et la moyenne d'une suite de chiffres non nuls entrés au clavier, sachant que la suite est terminée par zéro. Retenez seulement les chiffres (0, 1 ... 9) lors de l'entrée des données et effectuez un signal sonore si les données sortent de ce domaine.

Correction exercice 6 :

#include <stdio.h>
main()
{
 int  X;      /* Le chiffre courant      */
 int  N=0;    /* Le compteur des données */
 int  SOM=0;  /* La somme actuelle       */
 long PROD=1; /* Le produit actuel  -  Type long à */
              /* cause de la grandeur du résultat. */
     */

 do
    {
      /* Saisie des données (pour perfectionnistes) */
     printf("Entrez le %d%s chiffre : ", (N+1), (N)?"e":"er");
     scanf("%d", &X);

     if (X<0||X>9)
        printf("\a");
     else if (X)
        {
         N++;
         SOM+=X;
         PROD*=X;
        }
     else if (!X && N>0)
         {/* Seulement si au moins un chiffre a été accepté */
         printf("La somme   des chiffres est %d \n", SOM);
         printf("Le produit des chiffres est %ld\n", PROD);
         printf("La moyenne des chiffres est %f \n", (float)SOM/N);
        }
    }
 while (X);
  return 0;
}

Exercice 7:

Calculez le nombre lu à rebours d'un nombre positif entré au clavier en supposant que le fichier d'entrée standard contient une suite de chiffres non nuls, terminée par zéro (Contrôlez s'il s'agit vraiment de chiffres). Exemple: Entrée: 1 2 3 4 0 Affichage: 4321

Correction exercice 7 :

#include <stdio.h>
main()
{
 int  X;       /* Le chiffre courant        */
 int  N=0;     /* Le compteur des décimales */
 long VALD=1;  /* Valeur de la position décimale courante */
 long NOMB=0;  /* Le nombre résultat                      */
 do
    {
      printf("Entrez le %d%s chiffre : ", (N+1), (N)?"e":"er");
     scanf("%d", &X);

     if (X<0||X>9)
        printf("\a");
     else if (X)
        {
         NOMB += VALD*X;
         N++;
         VALD *= 10;
        }
     else
        printf("La valeur du nombre renversé est %ld\n", NOMB);
    }
 while (X);
  return 0;
}

Exercice 8:

Calculez le nombre lu à rebours d'un nombre positif entré au clavier en supposant que le fichier d'entrée standard contient le nombre à inverser. Exemple: Entrée: 1234 Affichage: 4321

Correction exercice 8 :

#include <stdio.h>
main()
{
 int  NOMB;   /* Le nombre à inverser */
 int  NINV;   /* Le nombre inversé    */
 /* Attention: en utilisant le type int, il est impossible */
 /* d'inverser correctement des nombres comme 10033 ...    */
 do
   {
     printf("Entrez un nombre positif (<10000) : ", NOMB);
    scanf("%d", &NOMB);
   }
 while (NOMB<0 || NOMB>9999);

 NINV=0;
 while(NOMB>0)
    {
     NINV *= 10;
     NINV += NOMB%10;
     NOMB /= 10;
    }

 /* Autre possibilité : */
 /* for (NINV=0 ; NOMB>0 ; NOMB/=10)
        NINV = NINV*10 + NOMB%10;
 */

 printf("Le nombre 'inversé' est : %d\n", NINV);
 return 0;
}

Exercice 9:

Calculez le P.G.C.D. de deux entiers naturels entrés au clavier en utilisant l'algorithme d'EUCLIDE.

Correction exercice 9 :

#include <stdio.h>
main()
{
 int A, B;         /* données */
 int X, Y, RESTE;  /* var. d'aide pour l'algorithme d'Euclide */

 do
    {
      printf("Entrer l'entier A (non nul) : ");
     scanf("%d", &A);
    }
 while(!A);
 do
    {
      printf("Entrer l'entier B (non nul) : ");
     scanf("%d", &B);
    }
 while(!B);

 for (RESTE=A, X=A, Y=B ; RESTE ; X=Y, Y=RESTE)
      RESTE = X%Y;

 printf("Le PGCD de %d et de %d est %d\n", A, B, X);
 return 0;
}


Aucun commentaire:

Enregistrer un commentaire

Partenaires

Computers Blogs

Contactez-nous

Nom

E-mail *

Message *

Tous droits resérvés-www.exercices-corriges.com Seo Blogger Templates