Blog ENI : Toute la veille numérique !
-25€ dès 75€ sur les livres en ligne, vidéos... avec le code FUSEE25. J'en profite !
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
  1. Livres et vidéos
  2. Algorithmique
  3. Les boucles
Extrait - Algorithmique Des bases à la programmation orientée objet en Java (avec exercices et corrigés) (2e édition)
Extraits du livre
Algorithmique Des bases à la programmation orientée objet en Java (avec exercices et corrigés) (2e édition) Revenir à la page d'achat du livre

Les boucles

Présentation

Les structures de contrôle vues au chapitre précédent permettent de sauter un certain nombre d’instructions en fonction des conditions, mais elles ne permettent pas de revenir en arrière pour effectuer à nouveau les instructions précédentes. Les structures de contrôle présentées dans ce chapitre, les boucles, permettent cela. Il est ainsi possible de répéter plusieurs fois un ensemble d’instructions.

La structure de contrôle Pour

Une première manière de répéter plusieurs fois un ensemble d’instructions est de les positionner dans une boucle Pour. Cette boucle répète un certain nombre de fois les instructions qu’elle contient. Vous pouvez par exemple décider de répéter dix fois les mêmes instructions. Il est nécessaire que ce nombre de répétitions soit connu avant le début de la boucle. Si ce n’est pas le cas, il faudra utiliser une des autres boucles présentées dans ce chapitre.

Syntaxe :

Pour variable <- valeurInitiale à valeurFinale 
   instructions  
FPour 

Cette boucle est délimitée entre les mots-clé Pour et FPour (Fin de Pour). Elle utilise une variable qui lui permet de connaître le nombre d’itérations, c’est-à-dire de répétitions, déjà effectuées. Cette variable est initialisée à l’entrée dans la boucle avec une valeur initiale et elle est incrémentée à chaque fin d’itération. Lorsque la variable atteint la valeur finale, la boucle est terminée et le traitement se poursuit avec les instructions positionnées après la boucle.

Exemple :

Algo TableDeMultiplication  
# affiche la table de multiplication de 7  
Variable m : entier  
Constante TABLE : entier <- 7  
Début 
 écrire("Table de " & TABLE)  Pour m <- 0 à 10 
   écrire(m & " × " & TABLE & " = " & m×TABLE)  
 FPour  
Fin 

Cet algorithme affiche tout d’abord : Table de 7. Ensuite, la boucle commence. La variable m est initialisée à la valeur zéro. Une première itération est réalisée. L’unique instruction de la boucle affiche donc la valeur de la variable m, c’est-à-dire zéro, puis la chaîne de caractères " × " suivie de la valeur...

La structure de contrôle TantQue

Une deuxième manière de répéter des instructions est d’utiliser une boucle TantQue. Contrairement à la boucle Pour, il n’est pas nécessaire de connaître avant de commencer la boucle le nombre d’itérations qui seront effectuées. Le principe de cette boucle est d’être répétée tant que la condition indiquée par celle-ci est vraie. Dans la vie de tous les jours, cela peut se traduire, par exemple, par la situation suivante : "Tant que la balance affiche un poids inférieur à 400 g, je verse de la farine".

Syntaxe :

TantQue condition 
       Instructions  
FTq 

Cette boucle est délimitée par les mots-clés TantQue et FTq (Fin de TantQue). Comme le mot-clé TantQue le suggère, la condition indiquée à sa suite correspond à ce qui doit être vrai pour commencer une première itération ou pour recommencer avec une nouvelle itération. Autrement dit, tant que cette condition est vraie, on reste dans la boucle, et dès lors que cette condition devient fausse, la boucle se termine et l’exécution se poursuit avec les instructions situées après cette boucle.

La conséquence de cela est qu’il est possible de rester à tout jamais dans une boucle TantQue ; c’est ce qui se nomme une boucle infinie.

Exemple d’un code incorrect pouvant provoquer une boucle infinie :

Algo PeutNeJamaisTerminer  
# exemple de boucle infinie si la valeur saisie  
# n'est pas la bonne réponse  
Variable saisie : texte  
Début 
 saisie <- saisir("Quelle est la capitale de la France ?")  
       #Condition  
 TantQue saisie ≠ "Paris" 
   écrire("Vous vous êtes trompé !")  
 FTq 
 écrire("Bravo !")  
Fin 

Si la valeur saisie est différente de Paris, alors la condition saisie ≠ "Paris" est vraie et on rentre alors dans la boucle. Le message d’erreur...

La structure de contrôle Répéter

Cette troisième boucle est assez similaire à la boucle TantQue. L’unique différence (mais qui fait toute la différence !) est que la condition de cette boucle n’est pas testée initialement, mais seulement après chaque itération. De ce fait, les instructions contenues dans la boucle sont exécutées au moins une fois. De même que pour la boucle TantQue, tant que cette condition est vraie, une nouvelle itération sera effectuée. Dans la vie de tous les jours, cela pourrait par exemple être utilisé pour saisir son code de carte bleue : il faut au moins le saisir une fois, mais cette opération peut être répétée si le code saisi est erroné. La condition de la boucle n’est donc pas testée initialement, mais seulement après avoir effectué une première itération.

Syntaxe :

Répéter 
    (ré)affectation de la variable de la condition 
    instructions  
TantQue condition FRépéter 

La boucle est délimitée par les mots-clés Répéter et FRépéter. Tout comme avec une boucle TantQue, il est possible de faire une boucle infinie si la variable sur laquelle porte la condition n’est jamais modifiée au sein de la boucle. À la fin de la boucle, le mot-clé TantQue est utilisé pour indiquer que la boucle sera répétée tant que la condition qui suit est vraie.

Il faut prendre garde à ne pas confondre la boucle Répéter avec une boucle TantQue même si, dans une boucle Répéter, le mot-clé TantQue est présent.

Exemple :

Algo ConvertisseurEuroBitcoin  
Variable txConversion : réel  
Variable valeurEuro : réel  
Variable encore : texte  
Début 
 txConversion <- saisir("Combien d'euros vaut 1 bitcoin ?")  
 Répéter 
   valeurEuro <- saisir("Quelle somme en euros voulez-vous " & 
             ...

Le choix de la boucle la plus adaptée

Vous avez maintenant trois boucles à votre disposition pour écrire vos algorithmes. Une question légitime à se poser est de savoir dans quelles situations préférer l’une plutôt que l’autre. Pour répondre à cette question, je vous invite à vous poser deux questions :

  • Avant de commencer la boucle, le nombre d’itérations est-il connu ?

  • Si oui, alors la boucle la plus adaptée est la boucle Pour.

  • Si non, alors il est nécessaire de se poser une nouvelle question : est-il possible de ne réaliser aucune itération de cette boucle ?

  • Si oui, alors la boucle la plus adaptée est la boucle TantQue

  • Si non, alors il faut préférer une boucle Répéter

Ces règles constituent des bonnes pratiques. Il est tout à fait possible de ne pas les respecter : par exemple, il est tout à fait possible de réaliser une boucle dont le nombre d’itérations est connu avant son début à l’aide d’une boucle TantQue ou d’une boucle Répéter ! Néanmoins, votre code sera moins facile à comprendre, donc plus difficile à maintenir et à optimiser.

En Java, il existe des mots-clés permettant de sortir de manière anticipée d’une boucle (break) ou de ne pas terminer...

Les boucles imbriquées

Dans le chapitre précédent, nous avons vu que les structures de contrôle peuvent être imbriquées les unes dans les autres. Ainsi, il est possible de mettre un Si dans une boucle. Il est également possible de nicher une boucle au sein d’une autre boucle.

Exemple d’algorithme avec une boucle imbriquée :

Algo TableDeMultiplication2  
Variable i, a, b, rep : entier  
Constante NB_QUESTIONS : entier <- 10  
Début  
 Pour i <- 1 à NB_QUESTIONS 
   a <- aléa(0, 10) 
   b <- aléa(0, 10) 
   rep <- saisir(a & " × " & b & " = ")  
   TantQue rep ≠ a*b 
     rep <- saisir("C'est faux ! Réessayez...")  
   FTq  
 FPour  
Fin 

Dans cet exemple, il y a une boucle Pour dans laquelle est nichée une boucle TantQue.

Dans un premier temps, oublions la boucle Pour et regardons le code qui est à l’intérieur. Une première interrogation sur une multiplication est posée à l’utilisateur. La boucle TantQue sert à vérifier la réponse de l’utilisateur. Si la réponse est bonne du premier coup, cette boucle sera sautée puisque la condition...

Exercices

1. La moyenne de notes (version 1)

Cet algorithme calcule la moyenne de valeurs (par exemple des notes) saisies par l’utilisateur. Tout d’abord, l’utilisateur indique le nombre de valeurs dont il souhaite connaître la moyenne. Puis, il saisit l’ensemble de ces valeurs. Enfin, la moyenne de ces valeurs s’affiche.

Voici un exemple d’affichages et de saisies possibles lors d’une exécution de l’algorithme (les valeurs saisies par l’utilisateur sont inscrites en gras italique) :

Entrez le nombre de notes :

3

Note :

12

Note :

17,5

Note :

14

La moyenne est 14,5

2. La moyenne de notes (version 2)

L’objectif est toujours de réaliser le calcul de la moyenne d’un ensemble de valeurs saisies par l’utilisateur, mais l’utilisateur n’a plus à indiquer initialement le nombre de valeurs. Il saisit les valeurs et lorsqu’il a terminé de saisir toutes les valeurs, il saisit une valeur particulière (-1) pour indiquer que les saisies sont terminées.

Exemple d’exécution de l’algorithme :

Note (-1 pour terminer) ?

9

Note (-1 pour terminer) ?

18

Note (-1 pour terminer) ?

-1

La moyenne des notes est de 13,5

3. La moyenne de notes (version 3)

Modifier l’algorithme précédent pour qu’il affiche en plus le pourcentage de notes supérieures à 10.

Exemple d’exécution de l’algorithme :

Note (-1 pour terminer) ?

14

Note (-1 pour terminer) ?

12

Note (-1 pour terminer) ?

9

Note (-1 pour terminer) ?

7

Note (-1 pour terminer) ?

10

Note (-1 pour terminer) ?

-1

Moyenne = 10,4 (60% 10)

4. Devinez à quel nombre je pense

Votre algorithme doit tirer un nombre entier aléatoirement compris entre 1 et 100. L’utilisateur doit trouver ce nombre. Pour cela, à chaque tentative de l’utilisateur, un indice lui est donné pour lui indiquer si le nombre est plus grand, plus petit ou égal à la valeur essayée. Le programme se termine lorsque l’utilisateur a trouvé le nombre.

Exemple d’exécution de l’algorithme :

À quel nombre entre 1 et 100 je pense ?

23

C’est moins !

15

C’est plus !

19

C’est moins !

17

Bravo ! Vous avez trouvé !

5. À moi de trouver

Cette fois-ci, c’est l’ordinateur qui doit deviner...

Solutions des exercices

1. La moyenne de notes (version 1)

Algo MoyenneDesNotes  
# Saisit des valeurs et calcule la moyenne  
Variable nbVal, cpt : entier  
Variable moyenne, saisie : réel  
Début 
   moyenne <- 0 
   nbVal <- saisir("Entrer le nombre de notes : ")  
   Si nbVal ≤ 0 Alors 
         écrire("Le nombre de valeurs doit être strictement positif")  
   Sinon  
         Pour cpt <- 1 à nbVal 
                 saisie <- saisir("Note : ") 
                 moyenne <- moyenne + saisie / nbVal  
         FPour 
         écrire("La moyenne est " & moyenne)  
   FSi  
Fin 

2. La moyenne de notes (version 2)

Algo MoyenneDesNotesV2  
#Calcule la moyenne des notes saisies par l'utilisateur  
#L'utilisateur saisit -1 pour finir la saisie  
Variable nbVal : entier <- 0  
Variable saisie, total : réel  
Constante STOP : entier <- -1  
Début 
   total <- 0 
   saisie <- saisir ("Note (" & STOP & " pour terminer) ?")  
   TantQue saisie ≠ STOP  
         total <- total + saisie 
         nbVal <- nbVal + 1 
         saisie <- saisir ("Note (" & STOP & " pour terminer) ?")  
   FTq  
   Si nbVal ≠ 0 Alors 
         écrire("La moyenne des notes est de " & total/nbVal)  
   Sinon 
         écrire("Aucune note n'a été saisie")  
   FSi  
Fin 

3. La moyenne de notes (version 3)

Algo MoyenneDesNotesV3  
#Calcule la moyenne et donne le taux de notes ≥ 10  
Variable nbVal : entier <- 0  
Variable nbS : entier <- 0  
Variable saisie...