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)
1 / 3 100%
La catégorie de ce document est-elle correcte?
Merci pour votre participation!

Faire une suggestion

Avez-vous trouvé des erreurs dans linterface ou les textes ? Ou savez-vous comment améliorer linterface utilisateur de StudyLib ? Nhésitez pas à envoyer vos suggestions. Cest très important pour nous !