Comment faire pour réaliser une même action plusieurs fois ?
Dans le cas de notre système, nous souhaitons que l’utilisateur déplace son joueur pour terminer le jeu, sans connaître les déplacements ni le nombre de déplacements à l’avance.
Laissez-moi vous présenter les boucles !
Une boucle est une structure qui répète la même action plusieurs fois de suite. Exactement comme lorsque vous écoutez un morceau de musique en boucle.
Nous pouvons faire la même chose dans un algorithme. C'est ce qu'on appelle l'itération, qui nous permet « d'écrire du code une fois » et de « l'exécuter plusieurs fois ». Dans la programmation, on parle de boucle !
Dans la plupart des langages de programmation, nous utilisons principalement deux types de boucles : la boucle Tant que
(en anglais, while
) et la boucle Pour
(en anglais, for
).
La boucle
Tant que
est utilisée pour exécuter le corps de la boucle jusqu'à ce qu'une condition spécifique soit fausse. Nous appliquons principalement cette idée lorsque nous ne savons pas combien de fois la boucle s'exécutera.Nous utilisons la boucle
Pour
lorsque nous savons combien de fois la boucle s'exécutera. En d'autres termes, la bouclePour
nous aide à exécuter un nombre d'étapes défini par des instructions.
Utilisez la boucle Tant que
La boucle Tant que
se compose :
d'une condition de boucle ;
d'un bloc de code en tant que corps de boucle, et qui contient les instructions à exécuter itérativement.
Concrètement, la condition de la boucle est évaluée et si elle est vraie, le code dans le corps de la boucle sera exécuté. Ce processus se répète jusqu'à ce que la condition de la boucle devienne fausse.
Ainsi, nous pouvons naïvement dire que la boucle while peut être considérée comme une instruction Si
répétitive.
Voici le pseudo-code qui permet de déplacer le joueur dans le labyrinthe tant qu’il n’a pas atteint la case d’arrivée ; nous utiliserons la fonction déplacement créée dans le chapitre précédent :
Algorithme boucle_tant_que
Variable
joueur_position_x ← 0 : ENTIER
joueur_position_y ← 0 : ENTIER
arrivée_position_x ← 5 : ENTIER
arrivée_position_y ← 5 : ENTIER
Début
Tant Que joueur_position_x != arrivée_position_x ET joueur_position_y != arrivée_position_y :
déplacement(joueur_position_x, joueur_position_y)
Fin Tant Que
Fin
Grâce à cette boucle, vous n’avez plus besoin d’écrire manuellement dans l’algorithme chaque déplacement du joueur.
Vous vous dites sûrement que c’est super génial et super simple. Et c’est vrai, c’est le cas, mais il y a un “MAIS”.
Que se passe-t-il si vous demandez à lire en boucle une chanson ?
Elle pourra être jouée, potentiellement, jusqu’à la nuit des temps, car l’ordinateur ne sait pas quand il doit s’arrêter. C’est ce que nous appelons une boucle infinie ! Ainsi, si la condition de la boucle est toujours vraie, votre programme sera bloqué dans la boucle et ne s’arrêtera jamais !
Utilisez la boucle “Pour”
À l'intérieur de la boucle Pour
, nous utilisons une variable de boucle pour contrôler l'exécution de la boucle, où la valeur initiale de la variable décide du point de départ.
Donc, nous commençons par initialiser la variable de boucle à une certaine valeur.
Nous vérifions ensuite si la condition de boucle est vraie ou non.
Si la condition de la boucle est vraie, le code à l'intérieur du corps de la boucle s'exécutera.
Enfin, nous mettons à jour la variable de boucle et passons à l'itération suivante. Cette étape sera répétée jusqu'à ce que la condition de boucle devienne fausse.
Plus concrètement, la boucle Pour
nécessite 3 instructions pour itérer :
Initialisation de la variable de boucle.
Condition d’itération.
Mise à jour de la variable de boucle.
Nous pouvons par exemple imaginer que l’utilisateur doit exactement déplacer le joueur 10 fois.
Nous aurons ainsi le pseudo-code suivant :
Algorithme boucle_pour
Variable
joueur_position_x ← 0 : ENTIER
joueur_position_y ← 0 : ENTIER
max_déplacement ← 10 : ENTIER
Début
Pour i ← 0 ; i < max_déplacement; i = i + 1
déplacement(joueur_position_x, joueur_position_y)
Fin Pour
Fin
Dans ce pseudo-code, nous avons initialisé la variable de boucle i
à 0, ensuite la condition de boucle permet de spécifier qu’il faut itérer le bloc de code tant que la variable i
est inférieure au maximum de déplacements, et pour terminer nous mettons à jour la variable i
en ajoutant 1.
Vous pouvez simplifier la ligne concernant la commande Pour
de cette manière :
Pour i allant de 0 jusqu’à max_déplacement
À vous de jouer
Contexte
Actuellement dans notre labyrinthe, nous sommes obligés de préciser à l’avance chaque déplacement du joueur dans l’algorithme. Nous aimerions pouvoir laisser à l’utilisateur le choix des déplacements du joueur. Il va donc falloir utiliser une boucle pour demander à l’utilisateur quels déplacements il souhaite faire.
Consigne
Vous devez créer un algorithme qui permet de déplacer le joueur à l’aide de la fonction déplacement
créée précédemment, de la case de départ à l’arrivée. Attention, le joueur aura au maximum 15 déplacements. Si le nombre de déplacements dépasse 15, le joueur perd.
Votre objectif :
Créer une boucle qui permet de déplacer le joueur en prenant en compte la position du joueur et le nombre de déplacements.
Créer ensuite une structure conditionnelle pour la boucle, pour afficher si le joueur a gagné ou perdu.
Vérifiez votre travail
Voici le résultat à obtenir à l'issue de l'exercice :
Algorithme Labyrinthe
Variable
joueur_position_x ← 0 : ENTIER
joueur_position_y ← 0 : ENTIER
arrivée_position_x ← 5 : ENTIER
arrivée_position_y ← 5 : ENTIER
déplacement ← 0 : ENTIER
max_déplacement ← 15 : ENTIER
Début
Tant Que joueur_position_x != arrivée_position_x ET joueur_position_y != arrivée_position_y ET déplacement < 15 :
déplacement(joueur_position_x, joueur_position_y)
déplacement = déplacement + 1
Fin Tant Que
Si joueur_position_x == arrivée_position_x ET joueur_position_y == arrivée_position_y :
afficher “Vous avez gagné !”
Sinon
afficher “Vous avez perdu !”
Fin Si
Fin
En résumé
Pour résoudre un problème, nous répétons parfois une instruction de code particulière plusieurs fois jusqu'à ce qu'une condition spécifique soit satisfaite ; c’est ce qu’on appelle une boucle.
Il existe deux principaux types de boucles dans la programmation, la boucle
Tant que
et la bouclePour
.La boucle
Tant que
est utilisée pour répéter une section de code un nombre inconnu de fois, jusqu'à ce qu'une condition spécifique soit remplie.La boucle
Pour
est utilisée pour répéter une section de code un nombre de fois connu.
Nous avions vu dans le premier chapitre de cette partie comment classer les données avec des types de données simples. Nous allons maintenant nous intéresser à des données complexes. On y va !