1. Ecrivez un programme 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,
2. Complétez la 'meilleure' des trois versions de l'exercice 6.1 :
Répétez l'introduction du nombre N jusqu'à ce que N ait une valeur entre 1 et 15.
Quelle structure répétitive utilisez-vous? Pourquoi?
a) en utilisant while,
#include
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,
SOM=0;
PROD=1;
I=1;
do
{
printf("%d. nombre : ", I);
scanf("%d", &NOMB);
SOM += NOMB;
PROD *= NOMB;
I++;
}
while(I<=N);
Remplacez le bloc de traitement (en gras) de (a) par :
c) en utilisant for.
for (SOM=0, PROD=1, I=1 ; I<=N ; I++)
{
printf("%d. nombre : ", I);
scanf("%d", &NOMB);
SOM += NOMB;
PROD *= NOMB;
}
Remplacez le bloc de traitement (en gras) de (a) par :
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.
Remplacer les lignes
printf("Nombre de données : ");
scanf("%d", &N);
par
do
{
printf("Nombre de données : ");
scanf("%d", &N);
}
while(N15);
Quelle structure répétitive utilisez-vous? Pourquoi?
Comme il n'y pas d'initialisation ni de réinitialisation de variables, nous avons le choix entre while et do - while. Comme l'introduction du nombre de données doit toujours être exécuté (au moins une fois), le plus naturel sera l'utilisation de la structure do - while.
Calculez par des soustractions successives le quotient entier et le reste de la division entière de deux entiers entrés au clavier.
#include
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;
}
Calculez la factorielle N! = 123...(N-1)N d'un entier naturel N en respectant que 0!=1.
a) Utilisez while,
b) Utilisez for.
(Essayez l'une ou l'autre des solutions en déplaçant les marques des commentaires !)
#include
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++;
}
/* b */
/* Pour N=0, le résultat sera automatiquement 0!=1 */
/*
for (FACT=1.0, I=1 ; I<=N ; I++)
FACT*=I;
*/
printf ("%d! = %.0f\n", N, FACT);
return 0;
}
Calculez par multiplications successives XN de deux entiers naturels X et N entrés au clavier.
#include
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;
}
Calculez la somme des N premiers termes de la série harmonique :
1 + 1/2 + 1/3 + ... + 1/N
#include
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;
}
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.
#include
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;
}
1. 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
2. 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
#include
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;
}
Remarque :
En remplaçant la ligne
NOMB += VALD*X;
par
NOMB += pow(10, N)*X;
on n'a plus besoin de la variable VALD. Il faut cependant inclure les fonctions de la bibliothèque <math>. D'autre part, le calcul de 10N serait alors répété à chaque exécution de la boucle.
Finalement, cette variante est plus lente et plus volumineuse que la première.
#include
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 (NOMB9999);
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;
}
1. Calculez le P.G.C.D. de deux entiers naturels entrés au clavier en utilisant l'algorithme d'EUCLIDE.
2. Calculez le N-ième terme UN de la suite de FIBONACCI qui est donnée par la relation de récurrence:
Déterminez le rang N et la valeur UN du terme maximal que l'on peut calculer si on utilise pour UN :
- le type int
- le type long
- le type double
- le type long double
#include
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;
}
#include
main()
{
int U1, U2, UN; /* pour parcourir la suite */
int N; /* rang du terme demandé */
int I; /* compteur pour la boucle */
do
{
printf("Rang du terme demandé : ");
scanf("%d", &N);
}
while(N<1);
U1=U2=1; /* Initialisation des deux premiers termes */
if (N==1)
UN=U1;
else if (N==2)
UN=U2;
else
{
for (I=3 ; I<=N ; I++)
{
UN = U1+U2;
U1 = U2;
U2 = UN;
}
}
printf("Valeur du terme de rang %d : %d\n", N, UN);
return 0;
}
Rang et terme maximal calculable en utilisant les déclarations :
|
int U1, U2, UN; |
(spéc. de format : %d) | U23 = 28657 |
| long U1, U2, UN; | (spéc. de format : %ld) | U46 = 1836311903 |
| double U1, U2, UN; | (spéc. de format : %e) | U1476 = 1.306989e308 |
| long double U1, U2, UN; | (spéc. de format : %Le) | U23601 = 9.285655e4931 |
a) Calculez la racine carrée X d'un nombre réel positif A par approximations successives en utilisant la relation de récurrence suivante:
La précision du calcul J est à entrer par l'utilisateur.
b) Assurez-vous lors de l'introduction des données que la valeur pour A est un réel positif et que J est un entier naturel positif, plus petit que 50.
c) Affichez lors du calcul toutes les approximations calculées :
La 1ère approximation de la racine carrée de ... est ...
La 2e approximation de la racine carrée de ... est ...
La 3e approximation de la racine carrée de ... est ...
. . .
#include
main()
{
double A; /* donnée */
double X; /* approximation de la racine carrée de A */
int N; /* degré/précision de l'approximation */
int J; /* degré de l'approximation courante */
do
{
printf("Entrer le réel positif A : ");
scanf("%lf", &A);
}
while(A<0);
do
{
printf("Entrer le degré de l'approximation : ");
scanf("%d", &N);
}
while(N<=0 || N>=50);
for(X=A, J=1 ; J<=N ; J++)
{
X = (X + A/X) / 2;
printf("La %2d%s approximation de la racine carrée"
" de %.2f est %.2f\n", J, (J==1)?"ère":"e", A, X);
}
return 0;
}
