Académique Documents
Professionnel Documents
Culture Documents
Chapitre 2
Introduction
Les structures conditionnelles
Les boucles
La démarche itérative
Introduction
En programmation procédurale comme en algorithmique (qui respecte les
contraintes fondamentales de la programmation!), l'ordre des instructions est
primordial.
Le processeur exécute les instructions dans l'ordre dans lequel elles apparaissent dans
le programme. On dit que l'exécution est séquentielle.
Une fois que le programme a fini une instruction, il passe à la suivante. Tant qu'une
instruction n'est pas terminée, il attend avant de continuer. Par exemple, une
instruction de saisie va attendre que l'utilisateur rentre une valeur au clavier avant de
continuer.
Parfois, il est nécessaire que le processeur n'exécute pas toutes les instructions, ou
encore qu'il recommence plusieurs fois les mêmes instructions. Pour cela, il faudra
casser la séquence. C'est le rôle des structures de contrôle.
- les structures répétitives, encore appelées boucles, vont permettre de répéter des
instructions un certain nombre de fois, sous certaines conditions
Dans le déroulement d'un algorithme, on doit souvent choisir entre deux actions,
suivant une condition concernant la valeur de certaines données. La structure
alternative va permettre d'effectuer des choix.
Supposons que nous ayons besoin, dans un programme, d'écrire un message précisant
si la valeur d'une variable, nommée a, est positive ou négative.
Si la condition n > 0 mentionnée après le mot Si est vraie, on exécute ce qui figure
après le mot Alors; si la condition est fausse, on exécute ce qui figure après le mot
Sinon.
Si <condition>
Alors <traitement1>
Sinon <traitement2>
Finsi
Pour une meilleure lisibilité du programme, on décale le Alors et le Sinon par rapport
au Si. On peut faire apparaître un trait vertical entre Si et Finsi.
Pour l'instant cela peut paraître superflu, mais en fait quand les programmes se
compliquent, ces règles d'écriture facilitent grandement leur relecture.
Rappelons que les traitements apparaissant après les mots Alors et Sinon, peuvent
être constitués d'une instruction simple, comme dans notre premier exemple, mais
aussi d'un ensemble d'instructions, appelé bloc d'instructions.
Algorithme choix
Variables
nb1, nb2, res: entiers
op : caractère
Début
Afficher "Entrez deux nombres"
Saisir nb1, nb2
Afficher "entrez la première lettre de l'opération voulue"
Saisir op
Si op = 's'
Alors ► premier bloc d'instructions
res nb1 + nb2
afficher "la somme est", res
Sinon ► deuxième bloc d'instructions
res nb1 * nb2
afficher "le produit est", res
Finsi
Fin
Dans nos deux exemples, les conditions que nous avons rencontré (n > 0) et
(op ='s') sont des conditions simples. Une condition simple est une comparaison de
deux expressions de même type. (n>0 type entier ou réel, op = 's' type caractère)
<,>,=,≤,≥,≠
Pour les comparaisons de caractères, on utilise l'ordre ASCII, qui respecte l’ordre
alphabétique. Une lettre placée avant une autre dans l'ordre alphabétique sera
inférieure à l'autre.
Attention, une condition simple ne veut pas dire une condition courte. Une condition
simple peut être la comparaison de deux expressions comme:
(a + b - 3) * c ≤ (5 * y –2) / 3
Application
Supposons que nous voulions afficher la valeur absolue de la différence entre deux
nombres entiers. Ces nombres entiers seront notés x et y.
Nous voulons donc afficher x – y si x est plus grand que y et y – x sinon.
Si x > y
Alors Afficher x – y
Sinon Afficher y – x
Finsi
Exemples:
Si a < 0 et b < 0
Alors…
Si (a +3 = b et c < 0) ou (a = c *2 et b ≠ c)
Alors …
Et
Une condition composée de deux conditions simples reliées par et, est vraie si les
deux conditions sont vraies.
La condition
a < 0 et b < 0
Ou
Une condition composée de deux conditions simples séparées par ou, est vraie si au
mois l'une des conditions simples est vraie.
a <0 ou b < 0
Non
Une conditions précédée par non est vraie si la condition simple est fausse et
inversement. non (a < 0) est vraie si a >=0
Ex :
Algorithme intervalles
Variables
appartient : booléen
nb : réel
Début
Afficher ''veuillez entrer un nombre réel''
Saisir nb
appartient (nb<10 et nb> 5) ou (nb >15 et nb <20)
Si appartient
Alors Afficher ''Le nombre appartient aux intervalles définies''
Sinon Afficher ''Le nombre n’appartient pas aux intervalles définies''
Finsi
Fin
Si <condition> Alors
<traitement>
Finsi
Exemple:
- la structure Tant que…Faire, qui permet d'effectuer une instruction tant qu'une
condition est satisfaite.
- la structure Pour qui permet de répéter une instruction un certain nombre de fois
- la structure Répéter…Jusqu'à, qui, comme son nom l'indique, permet de répéter
une instruction jusqu'à ce qu'une condition soit satisfaite.
Seule la boucle Tant que est fondamentale. Avec cette boucle, on peut réaliser toutes
les autres boucles alors que l'inverse n'est pas vrai. La boucle Pour est très utilisée
aussi car elle permet de simplifier la boucle Tantque lorsque le nombre de tour de
boucle est connu d’avance. La boucle Répéter, très peu utilisée, sera étudiée au
chapitre suivant.
Syntaxe:
Supposons que l'on veuille que l'algorithme calcule le cube des nombres qu'on
lui fournit et que pour arrêter, l'utilisateur doive entrer 0.
Si le nombre saisi est 0, on ne va pas afficher le cube et le traitement est terminé. Si le
nombre saisi est différent de 0, on affiche son cube et on recommence (on demande
d'entrer un nombre, on le saisit, etc.)
saisir un nombre
vérifier la condition d'exécution (x ≠ 0)
si x vaut 0, on sort de la boucle sinon on affiche le cube et on attend que
l'utilisateur entre un autre nombre
On vérifie la condition d'exécution (x ≠ 0)
si x vaut 0, on sort de la boucle sinon on affiche le cube et on attend que
l'utilisateur entre un autre nombre …
On voit donc qu'après la saisie du premier nombre, on répète les trois dernières
instructions. On va donc pouvoir les inscrire dans une boucle. La condition de
continuation (x ≠ 0) est inscrite après le tant que. Cette condition est vérifiée à chaque
fois qu'on a terminé les traitements de la boucle.
Algorithme cube
Variables
x : entier
Début
Afficher "Ce programme calcul le cube des nombres que vous entrez. Pour arrêter tapez 0."
Afficher "Entrez un nombre"
Saisir x
Tant que (x ≠ 0 ) Faire
Afficher "le cube de " , x , " est ", x*x*x
Afficher "Entrez un nombre ou 0 pour arrêter"
Saisir x
FinTQ
Afficher "Fin des itérations"
Fin
Fonctionnement de ce programme
L'utilisateur peut calculer autant de cubes qu'il désire et quand il veut arrêter, il
lui suffit de taper 0. On dit que 0 est une valeur drapeau, c'est-à-dire une valeur qui
indique la fin d'un traitement.
B. La boucle Pour
Pour < compteur> de <valeur initiale> à <valeur finale> [pas de <incrément> ] Faire
<traitement>
FinPour
ou
Pour < compteur> de <valeur initiale> à <valeur finale> [pas de <décrément> ] Faire
<traitement>
FinPour
Elle permet de faire la même chose que la boucle Tant que mais de façon plus rapide,
du moins lorsque le nombre de répétition est connu.
La variable compteur est de type entier. Elle est initialisée à la valeur initiale. Le
compteur augmente (respectivement diminue) (implicitement) de l'incrément
(respectivement du décrémént ) à chaque répétition du traitement. Lorsque la
variable compteur vaut la valeur finale, le traitement est exécuté une dernière fois
puis le programme sort de la boucle.
Exemple:
Pour x de 1 à 20 Faire
<traitement>
FinPour
Grâce à une telle structure, le traitement va être répétée 20 fois. On pourrait faire la
même chose avec une boucle tant que, mais il faudrait initialiser la variable compteur
et l'incrémenter explicitement.
x 1
Tant que x20 Faire
<traitement>
x x+1 ► incrémentation automatique
FinTantQue
Application
Affichons la table de multiplication du 7. Pour cela on va utiliser une variable a
qui varie de 1 à 10 et multiplier cette variable par 7 à chaque incrémentation. Cette
variable va aussi servir de compteur pour la structure Pour.
Algorithme multiplication7
Variables
a: entier
Début
Pour a de 1 à 10 pas de 1
Afficher a, " * 7 = ", a * 7
FinPour
Fin
A. Compter et Accumuler
Il suffit d’utiliser une variable qui va servir de compteur. Avant l’entrée dans la
boucle, le compteur est mis à 0. Ce compteur est incrémenté de 1 à chaque tour de
boucle. Pour cela, on ajoute l’instruction compteur compteur + 1 à l’intérieur
de la boucle: une telle instruction s’appelle incrémentation.
Algorithme cube
Variables
x : entier
compteur : entier
Début
Afficher "Ce programme calcul le cube des nombres que vous entrez. Pour arrêter tapez 0."
Afficher "Entrez un nombre"
Saisir x
Tant que x ≠ 0 Faire
Afficher "le cube de " , x , " est ", x*x*x
compteur compteur + 1
Afficher "Entrez un nombre ou 0 pour arrêter"
Saisir x
FinTantque
Afficher ''Vous avez demandé'', compteur, ''cubes''
Fin
Si on ne veut augmenter le compteur que dans une certaine condition (ici, dans le cas
où le nombre saisi est négatif), il suffit de placer l’incrémentation à l’intérieur
d’une structure conditionnelle.
Algorithme cube
Variables
x : entier
compteur : entier
Début
Afficher "Ce programme calcul le cube des nombres que vous entrez. Pour arrêter tapez 0."
Afficher "Entrez un nombre"
Saisir x
compteur 0
Tant que x ≠ 0 Faire
Afficher "le cube de " , x , " est ", x*x*x
Si x<0 Alors
compteur compteur + 1
FinSi
Afficher "Entrez un nombre ou 0 pour arrêter"
Saisir x
FinTantque
Afficher ''Vous avez obtenu'', compteur, '' cubes négatifs''
Fin
Afficher ''Vous avez obtenu'', cptneg, ''cubes négatifs, et'', cptpair, ''cubes pairs''
Fin
Dans certains langages, l’opérateur exposant n’existe pas. Supposons que nous ne
pouvons pas l’utiliser en algorithmique. Nous allons écrire l’algorithme qui permet de
calculer un nombre à un exposant donné. Le nombre x et l’exposant n sont saisis.
Rappel :
x1=x
x2= x*x x1*x
x3= x*x*x x2*x
x4= x*x*x*x x3*x …
On ne peut pas faire tout d’un coup le nombre de multiplication nécessaire car on ne
sait pas combien vaut l’exposant au moment d'écrire le programme. Le programmeur
ne sait pas quel exposant va taper l’utilisateur. Il y a une infinité de possibilités.
Pour contourner cette difficulté, on va répéter n fois la multiplication par x dans une
boucle.
On utilise la boucle Pour car on sait combien de fois on répète la multiplication : n
fois.
Que fait-on du résultat de la multiplication par x : on l’affecte dans une variable
résultat, que l’on va utiliser au tour suivant. Qu’est-ce qu’on multiplie par x à chaque
tour : le résultat du tour précédent.
Et au premier tour ? Il n’y a pas encore de résultat. Il suffit d’initialiser la variable
résultat avec 1.
D’où la solution suivante :
Algorithme exposant
Variables
x, n : entier ►x le nombre et n l’exposant
Début
Afficher ''veuillez entrez un nombre puis son exposant''
Saisir x, n
res 1 ►initialisation du résultat
Pour i de 1 à n Faire
res res * x ►itération
FinPour
Afficher x, ''puissance'', n, ''vaut'', res
Fin
la boucle. Entre temps, elle prend des valeurs intermédiaires qui servent à avancer
d’une valeur initiale connue vers la valeur finale recherchée.
Nous voulons trouver le plus petit parmi une liste de 100 nombres saisis par
l’utilisateur.
Comment faire ?
Il est irréaliste de déclarer 100 variables et de les comparer toutes une à une.
La saisie des nombres de la liste va se faire à l’intérieur d’une boucle à l’aide d’une
seule variable.
Pour obtenir le minimum, nous allons utiliser une itération.
A chaque tour de boucle, un nombre supplémentaire est saisi. Si on connaît le
minimum parmi tous les précédents nombres saisis, il suffit de comparer le nouveau
nombre à ce minimum pour avoir le nouveau minimum (parmi tous les nombres, y
compris le dernier).
Si le nouveau nombre saisi est plus petit que le plus petit des nombres précédents,
alors le nouveau nombre est le nouveau minimum parmi tous les nombres saisis.
Sinon, le minimum reste le même.
Avant la première saisie, il n’y a pas de minimum. En fait, lorsqu’un seul nombre est
saisi, c’est forcément lui le minimum. Donc on commence à faire la boucle à partir du
deuxième élément saisi.
Algorithme minimum
Variables
nb : réel ►pour la saisie des nombres
min : réel ►minimum
Début
Afficher ''Entrez un nombre''
Saisir nb
min nb ►le premier nombre saisi est le minimum des nombres déjà saisi car seul
Pour i de 2 à 100 Faire ►pour tous les autres éléments du 2° au dernier
Afficher ''entrez un autre nombre''
Saisir nb ►on le met en mémoire
Si nb < min Alors ► si il est plus petit que le minimum trouvé au tour précédent
min nb ► c’est lui le nouveau minimum parmi les nombre déjà saisis
Finsi
Finpour ►à la sortie de la boucle, min vaut le minimum des 100 nombres saisis
Afficher ''Le minimum des nombres saisis est'', min
Fin
Une itération consiste à un cheminement d'un état initial à un état final, celui qui
est recherché. Un état est représenté par les valeurs des variables à un moment donné.
La progression (le cheminement) vers l'état recherché se fait en passant par des états
intermédiaires.
Une boucle permet de progresser d'un état à un autre état, en se rapprochant de
l'état final. Lorsque l'état final est atteint, la boucle doit d'arrêter.
Pour "découvrir" une itération, il n'y a pas de recette miracle. Il faut utiliser son
imagination et son intelligence.
Néanmoins, la démarche suivante peut aider à trouver une itération pour
résoudre un problème.
Exercice 1 :
a) Écrire un algorithme qui saisit trois nombres et affiche le plus grand.
b) Écrire un algorithme qui saisit trois nombres et affiche le plus grand et le plus petit.
NB : On expliquera le principe de résolution (méthode) avant d'écrire les algorithmes. Cette
remarque reste valable pour tous les autres exercices de cette fiche et d'autres
Exercice 2:
Un robot conduit une voiture. Il peut exécuter trois actions ''passer'', ''ralentir'', ''passer'' en fonction
de la couleur des feux qui sera une variable caractère saisie. Proposer une méthode de travail et
l'algorithme correspondant.
Attention : un mauvais programme produit des accidents de circulation.
Exercice 3:
A partir de la saisie de deux nombres a et b, résoudre l'équation ''ax+b = 0''. Proposer une méthode
et l'algorithme correspondant.
Exercice 4:
a) Écrire un algorithme qui effectue la multiplication de deux nombres entiers par additions
successives. Faire l'analyse de la question avant de fournir l'algorithme correspondant.
b) Écrire un algorithme qui effectue la division de deux nombres entiers par soustractions
successives. Faire l'analyse de la question avant de fournir l'algorithme correspondant
Exercice 5 : (analyse puis algorithme)
a) Écrire un algorithme qui calcule la somme des n premiers entiers naturels.
b) Écrire un algorithme qui calcule la somme des n premiers entiers naturels pairs.
c) Écrire un algorithme qui calcule la somme des carrés des n premiers entiers naturels.
d) Écrire un algorithme qui calcule la somme des carrés des n premiers entiers naturels
impairs.
Exercice 1 :
Écrire un algorithme qui fait la résolution complète (solutions réelles et complexes) du trinôme du
second degré.
Exercice 2 :
Une compagnie d'assurance automobile propose à ses clients quatre familles de tarifs identifiables
par une couleur, du moins au plus onéreux : tarifs bleu, vert, orange et rouge.
Le tarif dépend de la situation du conducteur :
un conducteur de moins de 25 ans et titulaire du permis depuis moins de deux ans, se voit attribuer
le tarif rouge, si toutefois il n'a jamais été responsable d'accident. Sinon, la compagnie refuse de
l'assurer.
un conducteur de moins de 25 ans et titulaire du permis depuis plus de deux ans, ou de plus de 25
ans mais titulaire du permis depuis moins de deux ans a le droit au tarif orange s'il n'a jamais
provoqué d'accident, au tarif rouge pour un accident, sinon il est refusé.
un conducteur de plus de 25 ans titulaire du permis depuis plus de deux ans bénéficie du tarif vert
s'il n'est à l'origine d'aucun accident et du tarif orange pour un accident, du tarif rouge pour deux
accidents, et refusé audelà
De plus, pour encourager la fidélité des clients acceptés, la compagnie propose un contrat de la
couleur immédiatement la plus avantageuse s'il est entré dans la maison depuis plus d'un an.
Écrire l'algorithme permettant de saisir les données nécessaires (sans contrôle de saisie) et de traiter
ce problème. Avant de se lancer à corps perdu dans cet exercice, on pourra réfléchir un peu et
s'apercevoir qu'ils est plus simple qu'il en a l'air (cela s'appelle faire une analyse !)
Exercice 3 :
Écrire un algorithme qui demande à l’utilisateur un nombre compris entre 1 et 3 jusqu’à ce que la
réponse convienne.
Exercice 4 :
Écrire un algorithme qui demande un nombre compris entre 10 et 20, jusqu’à ce que la réponse
convienne. En cas de réponse supérieure à 20, on fera apparaître un message : « Plus petit ! », et
inversement, « Plus grand ! » si le nombre est inférieur à 10.
Exercice 5 :
Écrire un algorithme qui demande un nombre de départ, et qui ensuite affiche les dix nombres
suivants. Par exemple, si l'utilisateur entre le nombre 17, le programme affichera les nombres de 18 à
27.
Exercice 6 :
Écrire un algorithme qui demande un nombre de départ, et qui calcule la somme des entiers jusqu’à
ce nombre. Par exemple, si l’on entre 5, le programme doit calculer :
1 + 2 + 3 + 4 + 5 = 15
Exercice 7 :
Écrire un algorithme qui demande un nombre de départ, et qui calcule sa factorielle.
NB : la factorielle de 8, notée 8 !, vaut 1 x 2 x 3 x 4 x 5 x 6 x 7 x 8
Exercice 8 :
Ecrire un algorithme qui demande successivement 20 nombres à l’utilisateur, et qui lui dise ensuite
quel était le plus grand parmi ces 20 nombres :
Modifiez ensuite l’algorithme pour que le programme affiche de surcroît en quelle position avait été
saisie ce nombre :
Exercice 9 :
Réécrire l’algorithme précédent, mais cette foisci on ne connaît pas d’avance combien l’utilisateur
souhaite saisir de nombres. La saisie des nombres s’arrête lorsque l’utilisateur entre un zéro
Exercice 10 :
Ecrire un algorithme qui permette de connaître ses chances de gagner au tiercé, quarté, quinté et
autres impôts volontaires.
On demande à l’utilisateur le nombre de chevaux partants, et le nombre de chevaux joués. Les deux
messages affichés devront être :
Dans l’ordre : une chance sur X de gagner
Dans le désordre : une chance sur Y de gagner
X et Y nous sont donnés par la formule suivante, si n est le nombre de chevaux partants et p le
nombre de chevaux joués :
X = n ! / (n p) !
Y = n ! / (p ! * (n – p) !)
NB : cet algorithme peut être écrit d’une manière simple, mais relativement peu performante. Ses
performances peuvent être singulièrement augmentées par une petite astuce. Vous commencerez par
écrire la manière la plus simple, puis vous identifierez le problème, et écrirez une deuxième version
permettant de le résoudre.
Exercice 11: Écrire un programme qui fait la table de multiplication de 1 à 10 des dix premiers
entiers en utilisant les trois boucles .
Exercice 12: Écrire un programme qui fait la table de multiplication de 1 à 10 des dix entiers
compris entre un nombre X donné et X+ 20.
Exercice 13: Écrire un programme qui fait la table de multiplication de 1 à 10 des dix premiers
entiers pairs.
Exercice 14: Écrire un programme qui fait la table de multiplication de 1 à 10 de dix entiers
pairs compris entre un nombre X donné et X+ 20.
Exercice 15: Écrire un programme qui fait la table multiplication de 1 à 10 de dix entiers
impairs compris entre un nombre X donné et X+ 20.