Découvrez le fonctionnement des algorithmes

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 boucleTant 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 boucle  Pour  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”.

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 :

1. Initialisation de la variable de boucle.

2. Condition d’itération.

3. 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 :

1. 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.

2. 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 boucle Pour  .

• 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 !