Instructions répétitives

Info 5
INSTRUCTIONS RÉPÉTITIVES
Itérations dans un algorithme
Le recours à des itérations, également appelées boucles, est fréquent en algorithmique.
C’est un passage particulièrement délicat de la mise au point d’un algorithme, et la rédaction
d’une boucle réclamera souvent un soin tout particulier...
1
Comprendre un algorithme contenant une boucle 2
1. Ce que produit une boucle...
On considère le programme suivant, écrit en Python :
nombre_binaire=input("Donner une séquence de bits")
longueur=len(nombre_binaire)
nombre=0
puissance=1
for i in range(1,longueur+1) :
nombre=nombre+liste[longueur-i]*puissance
puissance=puissance*2
print(nombre)
Que produit l’algorithme sous-jacent ?
2. ... et pourquoi une boucle s’arrête
On considère le programme suivant, écrit en Python :
dividende=int(input("Donner un dividende"))
diviseur=int(input("Donner un diviseur"))
quotient=0
reste=dividende
while reste>=diviseur :
quotient=quotient+1
reste=reste-diviseur
print(quotient,reste)
Justifier que l’algorithme sous-jacent se termine, et préciser ce qu’il produit.
Conception d’une boucle
1. Connaît-on
le nombre de répétitions à envisager ?
:::::::::::::::::::::::::::::::::::::::::
,→ :::
Oui : alors on utilisera plutôt une boucle avec compteur du type :
for compteur in range(n) :
instruction(s)
,→ ::::
Non : la fin des répétitions est alors décidée à l’aide d’une condition, et on
utilise alors une boucle du type :
while condition :
instruction(s)
2. Dans le cadre d’un calcul répété
i. On initialise une variable à une valeur donnée ;
ii. à chaque « tour de boucle », la valeur prise par la variable doit subir le
calcul à répéter ;
iii. à la fin de la boucle, la valeur de la variable doit être celle attendue.
3. Exemples
. Pour tout entier n > 0, on appelle factorielle de n, et on note n! :
1 × 2 × · · · × (n − 1) × n si n > 1
n! =
1
si n = 0
Ecrire un algorithme prenant en entrée un entier naturel n et retournant, en
sortie, la valeur de n!.
. Un nombre entier n > 2 est dit premier lorsqu’il n’est divisible que par 1 et
lui-même.
Ecrire un algorithme prenant
en entrée un entier naturel n et retournant, en
V rai si n est premier
sortie, la valeur booléenne
F aux sinon
4. Vérification
. Au moment de vérifier qu’une boucle produit ce que l’on souhaite,
on raisonnera comme dans le premier paragraphe.
Pour bien comprendre le résultat que renvoie une boucle, on considère
souvent une variable qui subit des changements au cours de l’itération :
(a) on relève sa valeur avant la boucle ;
(b) à l’aide des instructions itérées, on détermine sa valeur à chaque tour
de boucle ;
(c) on en déduit sa valeur à l’issue de la boucle.
L’étude précédente peut concerner plusieurs variables,
voire une propriété liée à une variable.
. Terminaison d’une boucle conditionnelle
Lorsqu’un algorithme contient une telle boucle, on doit s’assurer que celleci se termine. Pour cela, on regarde, parmi les instructions qui figurent dans
l’itération, celle(s) qui modifie(nt) la condition à laquelle les instructions
sont répétées. Si lesdites instructions garantissent que cette condition ne
sera plus vérifiée au bout d’un nombre fini d’itérations, notre boucle se
termine.
−→ Par exemple, lorsqu’on calcule la somme 12 + 22 + · · · + n2 (n étant un entier
naturel non nul donné) à l’aide de la séquence :
somme=0
for i in range(1,n+1) :
somme=somme+i*i
alors la variable somme vaut, au i-ième tour de boucle, la somme de tous les carrés
jusqu’au dernier indice considéré : ceci est valable avant la boucle, pendant la boucle,
et à l’issue de la boucle.
Cette propriété s’appelle un invariant de boucle : c’est ce qui permet de justifier
rigoureusement que la boucle produit ce qu’on veut.