Cours de maths - 1ère ES-L- Les boucles

On utilise une boucle lorsqu'on veut répéter un même bloc d'instructions un certain nombre de fois.
I – Pour … allant de … à … faire
Avec ce type de boucle, le nombre d'itérations (répétitions) est connu à l'avance. On utilise donc un compteur
qui, une fois atteint une certaine valeur, arrête l'exécution de la boucle. A chaque passage dans la boucle, le
compteur sera incrémenté (+1) ou décrémenté (–1) selon le cas.
Dans ce cas, l’expression utilisée est : Pour var allant de valeur1 à valeur2 faire
Debut_Pour
instructions
Fin_Pour
Remarque : Les valeurs entières encadrant le compteur peuvent être des variables
Pour i allant de variable1 à variable2 faire
II – Tant que … faire
Avec ce type de boucle, on répète l'exécution d'un bloc d'instruction tant qu'une condition préalablement définie
est satisfaite. Le test s'effectue en début de boucle, à chaque passage.
Dans ce cas, l’expression utilisée est : Tant que condition faire
Debut_Tant_que
instructions
Fin_Tant_que
Les boucles
www.mathmaurer.com – Cours – 1ère ES-L
Exemple: Ajouter POUR … DE … A (instruction AlgoBox)
L'algorithme suivant calcule 2 exposant 3 à l'aide d'une boucle.
Variables
i, n : nombre ; (l'entier i utilisé comme compteur doit être déclaré dans les variables)
Debut
// On initialise la variable n avant son utilisation.
n ← 1 ;
// La boucle qui suit calcule 2 exposant 3. Le programme passe 3 fois dans la boucle.
Pour i allant de 1 à 3 faire
Debut_Pour
n ← 2*n ;
Fin_Pour
// On affiche la valeur de n qui est 8.
Afficher n ;
Fin
Valeurs de i et n lors de l'exécution de l'algorithme
i
n
1
2  1 = 2
2
2  2 = 4
3
2  4 = 8

Remarque : Une boucle Tant que … peut dans tous les cas remplacer une boucle Pour … allant de … à … .
III – Exercice d'application
L'objectif de l'exercice est de faire un algorithme qui effectue le division euclidienne de 2 entiers et renvoie les
valeurs du quotient et du reste.
Exemple: Ajouter TANT QUE … (instruction AlgoBox)
L'algorithme suivant demande à l'utilisateur de taper un nombre positif ou nul avec vérification.
Variables
n : nombre ;
Debut
// On initialise la variable pour entrer dans la boucle.
n ← –1 ;
Tant que n < 0 faire
Debut_Tant_que
Afficher "Taper un nombre positif ou nul."
Lire n ;
Fin_ Tant_que
// On affiche la valeur de n.
Afficher n ;
Fin
Étude du problème
Choix des variables :
dividende est le dividende ;
diviseur est le diviseur ;
quotient est le quotient ;
reste est le reste ;
Formule de calcul : dividende = diviseur  quotient + reste r avec 0  reste  diviseur
On effectue des soustractions de dividende par diviseur jusqu'à obtenir quotient et reste.
Entrées : L'utilisateur doit taper les nombres dividende et diviseur.
Sorties :
L'algorithme doit afficher les nombres quotient et reste.

Codage de l'algorithme (en langage "naturel")
Variables
dividende, diviseur, quotient, reste, var_calcul : nombre ;
Debut
quotient ← 0 ;
reste ← 0 ;
// L'utilisateur entre 2 entiers positifs dividende et diviseur tels que dividende > diviseur.
Afficher "Taper le dividende " ;
Lire dividende ;
var_calcul ← dividende ;
Afficher "Taper le diviseur " ;
Lire diviseur ;
Tant que var_calcul  diviseur faire
Debut_Tant_que
quotient ← quotient + 1 ;
var_calcul ← var_calcul – diviseur ;
Fin_ Tant_que
reste ← dividende – diviseur  quotient ;
Afficher "Le quotient est :" ;
Afficher quotient ;
Afficher "Le reste est :" ;
Afficher reste;
Fin
Codage de l'algorithme (version AlgoBox améliorée)