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?
Solution :
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.
Solution :
#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.
Solution :
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.
Solution :
#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
Solution :
#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.
Solution :
#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
Solution :
#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
Solution :
#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.
Solution :
#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;
}