Chapitre 1 - Pearson France

© 2013 Pearson France – Algorithmique. Applications aux langages C, C++ et Java
Algorithmique.
Applications aux langages C, C++ et Java
Jean-Michel LÉRY
ISBN : 978-2-7440-7672-5
Exercices supplémentaires
Chapitre 1 – Les traitements logiques
L’exercice 1 montre comment obtenir un arrondi par une solution analytique.
Exercice 1 : Conversion des francs en euros
Énoncé
Écrivez l’algorithme qui convertit en euros une somme exprimée en francs. Le résultat en euros sera arrondi à la
deuxième décimale. Le taux de conversion est de 6,55957 francs pour un euro, et la seule fonction algorithmique
dont on dispose pour effectuer l’arrondi est partie_entière(x) qui retourne la valeur entière strictement inférieure
au nombre réel x (la partie entière de 2,6 est 2). Le problème sera décomposé en deux sous-problèmes : trouver
comment obtenir un arrondi entier à partir de la fonction partie_entière() , puis généraliser le calcul pour qu’il
effectue un arrondi à la deuxième décimale.
1. Faites l’analyse du problème de l’arrondi entier en travaillant sur des exemples de nombres réels. Pour
cela, mettez en correspondance une série de nombre réels (2,0, puis 2,1, puis 2,2, etc.) avec leur
arrondi entier connu, et déduisez-en le calcul algorithmique générique qui permet de passer de la
valeur réelle à son arrondi.
2. Modifiez ce calcul pour effectuer l’arrondi à 2 décimales près, et écrivez l’algorithme de conversion des
francs en euros qui utilise cette méthode.
Solution
1. Cet exercice montre que l’analyse des données est très importante. La plupart des développeurs
auront tendance à proposer une solution basée sur leurs connaissances techniques, en comparant la
partie décimale à la valeur 0,5. Si la partie décimale est inférieure à 0,5, l’arrondi correspond à la
partie entière ; sinon, l’arrondi correspond à la partie entière augmentée de la valeur 1. Cette solution
construite autour d’un test s’écrit :
pent partie_entière(x)
pdéci x - pent
Si (pdéci < 0,5) alors
Arrondi pent
Sinon
Arrondi pent + 1
FinSi
Or un test est plus coûteux en temps d’exécution qu’un simple calcul arithmétique. Il est donc préférable
d’étudier les données avant de se lancer dans une solution technique, comme le propose la figure 1.1.
En prenant une suite de nombres réels consécutifs, et en mettant en correspondance leur arrondi entier
connu, on peut faire le constat suivant. L’arrondi change à partir du nombre dont la décimale est 0,5 (ce
nombre est 2,5 pour la suite présentée). Si on ajoute simplement 0,5 à la valeur centrale 2,5, on obtient le
résultat attendu (schéma de gauche de la figure). Généralisons ce calcul en ajoutant 0,5 à tous les nombres
réels présentés et regardons le résultat obtenu (schéma de droite de la figure 1.1). Ce résultat est presque
celui qui est attendu, à la partie décimale près. Il suffit donc de ne conserver que la partie entière. Le calcul
précédent basé sur un test se réécrit ainsi beaucoup plus simplement :
Arrondi partie_entière(x+0,5)

2
L’analyse des données, même dans les cas élémentaires comme celui qui est présenté, ne doit jamais être
négligée. Elle fournit souvent des solutions plus simples à programmer.
Figure 1.1
Analyse de l’arrondi entier d’un réel.
2. Pour obtenir un arrondi à deux décimales près en utilisant la formule précédente, il suffit de multiplier le
nombre réel par 100, d’appliquer la partie entière au résultat obtenu, puis de diviser la valeur résultante par
100. La syntaxe algorithmique de ce calcul est :
Arrondi_décimal (partie_entière((x*100)+0,5))/100
Voici la décomposition de ce calcul sur le nombre 15,2449017 (conversion de 100 francs en euros). La
valeur obtenue est 15,24.
15,2449017  1524,49017  1524,49017 +0,5  1524,99017  1524  1524/100  15,24
L’algorithme conv_francs_euros utilise ce calcul pour convertir en euros une somme exprimée en francs.
Programme conv_francs_euros
Déclarations
Constante TAUX = 6,55957
Variables Euros, Francs en Réels
Début
Écrire("Entrez la valeur en Francs (ex 97.5) : ")
Lire(Francs)
Euros (partie_entière((Francs/TAUX)*100)+0.5))/100
Écrire ("Valeur en Euros :",Euros);
Fin
Les programmes sources C, C++ et Java téléchargeables qui implémentent cet algorithme se nomment
respectivement : conv_francs_euros.c , conv_francs_euros.cpp, conv_francs_euros.java .
La commande de compilation pour les programmes C et C++ est :
$ make conv_francs_euros
Voici un exemple d’exécution de ce programme :
$ conv_francs_euros
Entrez la valeur en Francs (ex 97.5) : 100
Valeur en euros : 15.24
La commande de compilation pour le programme Java est :
$ javac conv_francs_euros.java
La syntaxe pour exécuter le programme compilé Java est :
$ java conv_francs_euros

© 2013 Pearson France – Algorithmique. Applications aux langages C, C++ et Java
3
Chapitre 2 – Les traitements logiques
Les exercices proposés étudient la conception des boucles. L’exercice 4 porte sur la
complexité algorithmique et montre son incidence directe sur le temps de calcul. Les
exercices 9 à 12 traitent du problème mathématique du dénombrement.
Exercice 1 : Boucles POUR imbriquées
Énoncé
Écrivez un programme qui affiche les N premières tables de multiplication. Le programme demandera la valeur N à
l’utilisateur. Il utilisera deux boucles POUR imbriquées : la première parcourra les numéros des tables, et la
seconde effectuera la multiplication de 1 à 10 pour une table donnée. L’affichage sera de la forme :
Table de 1: 1 2 3 4 5 6 7 8 9 10
Table de 2: 2 4 6 8 10 12 14 16 18 20
...
Solution
La première boucle POUR utilise la variable table comme compteur. La boucle s’exécute de 1 à N. La seconde
boucle interne s’exécute 10 fois pour chaque valeur de N.
« PSEUDO-CODE »
Programme tables_de_multiplication
Déclarations
Variables table,i, N en Entier
Début
Écrire("Entrez le numéro de la dernière table :")
Lire(N)
Pour table variant de 1 à N Faire
Écrire("Table de ",table)
Pour i variant de 1 à 10 Faire
Écrire(table*i)
FinPour
FinPour
Fin
Les programmes sources C, C++ et Java téléchargeables qui implémentent cet algorithme se nomment
respectivement : tables_de_multiplication.c , tables_de_multiplication.cpp, tables_de_multiplication.java .
La commande de compilation pour les programmes C et C++ est :
$ make tables_de_multiplication
Voici un exemple d’exécution de ce programme :
$ tables_de_multiplication
Entrez le numéro de la dernière table :3
Table de 1: 1 2 3 4 5 6 7 8 9 10
Table de 2: 2 4 6 8 10 12 14 16 18 20
Table de 3: 3 6 9 12 15 18 21 24 27 30
La commande de compilation pour le programme Java est :
$ javac tables_de_multiplication.java
La syntaxe pour exécuter le programme compilé Java est :
$ java tables_de_multiplication
Exercice 2 : Détermination d’un nombre factoriel
Énoncé
Un entier positif x est un nombre factoriel s’il existe un autre entier y, tel que x = y!. Faites un programme qui
détermine si le nombre entré par l’utilisateur est un nombre factoriel. Réécrivez le calcul de la factorielle présenté à
l’exercice 2 du chapitre 2 du livre, en une fonction fact() .

4
Solution
L’algorithme suivant utilise la fonction fact(j) qui retourne le résultat du calcul de la factorielle de l’entier j . Une
boucle principale teste les factorielles successives 2!, 3!, …, et compare le résultat au nombre entier demandé à
l’utilisateur, i . La boucle s’arrête quand la factorielle calculée dépasse le nombre i . Comme le nombre d’itérations
n’est pas connu à l’avance, la boucle utilisée est l’instruction TANT QUE.
« PSEUDO-CODE »
Programme nombre_factoriel
Déclarations
Variables nb, fact, j en Entier
Variable trouvé en Booléen
Début
Écrire("Entrez un nombre entier positif :")
Lire(nb)
fac 1
trouvé FAUX
j 0
Tant que ((fact <= nb) ET (NON trouvé)) Faire
j j + 1
fact factorielle(j)
Si (fact = nb) Alors
trouvé VRAI
FinSi
FinTantQue
Si (trouvé = VRAI) Alors
Écrire(nb,"est la factorielle de ",j)
Sinon
Écrire(nb,"n'est pas un nombre factoriel")
FinSi
Fin
// --- fonction factorielle
Fonction factorielle(N)
Déclarations
Paramètres N en Entier
Variables i, résultat en Entier
Début
résultat 1
Pour i variant de 1 à N Faire
résultat résultat * i
FinPour
Retourner résultat
Fin
Les programmes sources C, C++ et Java téléchargeables qui implémentent cet algorithme se nomment
respectivement : nombre_factoriel.c , nombre_factoriel.cpp , nombre_factoriel.java .
La commande de compilation pour les programmes C et C++ est :
$ make nombre_factoriel
Voici un exemple d’exécution de ce programme :
$ nombre_factoriel
Entrez un nombre entier positif :24
24 est la factorielle de 4
La commande de compilation pour le programme Java est :
$ javac nombre_factoriel.java
La syntaxe pour exécuter le programme compilé Java est :
$ java nombre_factoriel

© 2013 Pearson France – Algorithmique. Applications aux langages C, C++ et Java
5
Exercice 3 : Calcul d’une fonction sin(x)
Énoncé
Cet exercice propose de réécrire le calcul de fonctions mathématiques à partir du développement en séries
entières d’après la méthode de Taylor-Mac-Laurin. Ces mathématiciens ont montré que toute fonction peut s’écrire
comme une suite d’additions (ou de soustractions) de facteurs de x. Ainsi, sinus(x) correspond au calcul :
sin(x)=x-x3
3! +x5 5! -x7 7! +...+(-1)nx2n+1 (2n+1)!
Écrivez l’algorithme qui calcule sinus(x), x étant indiqué en radians (valeur entre 0 et 2 ). La boucle de traitement
devra s’arrêter quand la précision obtenue sera suffisamment grande, ce qui se traduit par une valeur très faible du
nouveau facteur de x. La précision sera définie à la 15e décimale.
Solution
La boucle de traitement est une boucle TANT QUE, puisqu’on ne connaît pas le nombre de calculs nécessaires
pour obtenir le résultat. La boucle continue tant que le nouveau facteur calculé est supérieur à la précision voulue.
La précision définie à la 15e décimale correspond à la valeur 0,000000000000001. Dans la boucle TANT QUE, le
nouveau facteur est calculé séparément, car il sert de critère d’arrêt à la boucle. Sa valeur initiale (en dehors de la
boucle) est fixée arbitrairement afin de démarrer la boucle. L’alternance des + et des – est obtenue par le calcul (–
1)n qui multiplie le facteur calculé précédemment, pour obtenir le nouveau terme à additionner aux résultats
précédents. Le premier calcul (–1)0 donne +1 ; le deuxième, (–1)1, donne –1 ; le troisième, (–1)2, donne +1, etc.
« PSEUDO-CODE »
Programme sinus
Déclarations
Variables x, res, facteur, terme, précision en Réel
Variable n en Entier
Début
Écrire("Entrez la valeur de x:")
Lire(x)
précision 0,000000000000001
Écrire("--- calcul par séries entières ---")
res 0
n 0
facteur 9999
Tant que (facteur>précision) Faire
facteur (x**((2*n)+1))/factorielle((2*n)+1)
terme ((-1)**n)*facteur
res res + terme
Écrire(n,": sinus= ",res, " terme=",terme)
n n+1
FinTantQue
Fin
// --- fonction factorielle
Fonction factorielle(N)
Déclarations
Paramètres N en Entier
Variables i, résultat en Entier
Début
résultat 1
Pour i variant de 1 à N Faire
résultat résultat * i
FinPour
Retourner résultat
Fin
Les programmes sources C, C++ et Java téléchargeables qui implémentent cet algorithme se nomment
respectivement : sinus.c , sinus.cpp , sinus.java .
La commande de compilation pour le programme C est :
$ cc -o sinus sinus.c -lm