Découvrez le fonctionnement des algorithmes

Il arrive des situations dans la vie réelle où vous devez prendre des décisions, et sur la base de ces décisions, vous agissez en conséquence. Des situations similaires se produisent également dans la programmation où vous devez prendre des décisions en fonction d’une condition. C’est ainsi que vous pourrez lancer ou non certains blocs de code.

Revenons à notre programme et imaginons un scénario que nous n’avons pas vu jusqu’à maintenant. Nous souhaitons avoir une fonction qui nous permette d’afficher un message de victoire ou de défaite à la fin des déplacements. Plus simplement, si à la fin des déplacements, nous sommes sur la case d’arrivée, le programme affiche Vous avez gagné !  , sinon, le programme affiche Vous avez perdu !  .

Si

Le mot-clé Si  (en anglais “if”) est la structure de test la plus simple. Il est utilisé pour décider si une instruction particulière ou un bloc d'instructions sera exécuté ou non. En clair, si une   condition définie est vraie, alors un bloc d'instructions sera exécuté ; sinon, non. 

Nous pouvons, par exemple, créer une structure Si qui vérifie si le joueur se trouve dans la case d’arrivée et si c’est le cas, on affiche Vous avez gagné !  .

Nous pouvons écrire le pseudo-code suivant :

Algorithme Si_structure
Début
    Si le joueur est sur la case arrivée :
        afficher `Vous avez gagné !`
    Fin Si
Fin

Ainsi, dans cet algorithme, si le joueur est sur la case Arrivée, on affiche le messageVous avez gagné !  ,  sinon aucune instruction n’est lancée, donc nous n’avons pas de message.

En réalité, dans un algorithme, pour tester une condition nous allons utiliser des opérateurs de comparaison afin de comparer des paramètres du programme.

Pour effectuer ces tests, il existe des symboles utilisés dans la plupart des langages de programmation :

Imaginons maintenant que nous ayons une variable qui contient les coordonnées du joueur sur le labyrinthe ( joueur_coordonnées  ), et une variable qui contient aussi les coordonnées de la case d’arrivée ( arrivée_coordonnées  ).

Nous pouvons alors remplacer notre pseudo-code par le suivant :

Algorithme Si_structure
Début
    Si joueur_coordonnées == arrivée_coordonnées :
        afficher `Vous avez gagné !`
    Fin Si
Fin

Si... Sinon...

Cette fois nous avons besoin d’une autre structure conditionnelle, nous allons devoir combiner le mot-clé Si avec le mot-clé Sinon  .  En effet, le mot-clé Si seul nous dit que si une condition est vraie, elle exécutera un bloc d'instructions, et si la condition est fausse, elle ne le fera pas. Ainsi, nous devons utiliser le mot-clé Sinon avec Si pour exécuter un bloc de code lorsque la condition est fausse.

Dans le cas de notre labyrinthe, nous pouvons ajouter une structure conditionnelle à la fin de notre algorithme, qui nous permet de savoir si le joueur a gagné ou pas : si le joueur est sur la case Arrivée, dans ce cas, on affiche Vous avez gagné ! ; sinon, on affiche Vous avez perdu !  .

Algorithme Si_structure
Début
    Si joueur_coordonnées == arrivée_coordonnées :
        afficher `Vous avez gagné !`
    Sinon
        afficher `Vous avez perdu !`
    Fin Si
Fin

Combinez des conditions

Pour les conditions les plus complexes, sachez que vous pouvez faire plusieurs tests au sein d'un seul et même Si  . Pour cela, il va falloir utiliser de nouveaux mots-clés, ET  et  OU  :

• L'opérateur ET renvoie Vrai lorsque ses conditions gauche et droite sont égalementVrai  . Lorsqu'une ou les deux conditions sont fausses, le résultat obtenu par ET est également Faux  .

• L'opérateurOU renvoie Vrai lorsque sa condition gauche, droite ou les deux sont  Vrai  . La seule fois où OU renvoie False, c'est lorsque les deux conditions sont également fausses.

Testez ET

Imaginons que nous souhaitions ajouter une condition en plus pour notre message de fin de jeu. Cette fois, une fois que le joueur a fini ses déplacements, il faut vérifier que le joueur est sur la case d’arrivée et qu’il n’a pas fait plus de 10 déplacements.

Nous avons alors :

Algorithme operateur_ET
Début
    Si joueur_coordonnées == arrivée_coordonnées ET déplacements <= 10 :
        afficher `Vous avez gagné !`
    Sinon
        afficher `Vous avez perdu !`
    Fin Si
Fin

Notre condition combinée se dirait en français : « Si les coordonnées du joueur et les coordonnées de la case arrivée sont égales ET si le nombre de déplacements est inférieur ou égal à 10».

Testez OU

Prenons cette fois le problème autrement, une fois que le joueur a fini ses déplacements. Nous allons afficher Vous avez perdu !  , si le joueur n’est pas sur la case d’arrivée ou que le joueur a fait plus de 10 déplacements.

Algorithme operateur_OU
Début
    Si joueur_coordonnées != arrivée_coordonnées OU déplacements > 10 :
        afficher `Vous avez perdu !`
    Sinon
        afficher `Vous avez gagné !`
    Fin Si
Fin

À vous de jouer

Contexte

Pour le moment, nous n'avons pas créé de fonction qui permette de gérer les déplacements du joueur en fonction de la demande de l’utilisateur. C’est exactement ce que nous allons mettre en place maintenant.

Considérons que la fonction entrer()  permet de demander à l’utilisateur d’entrer le sens de déplacement, et retourne l’entrée de l’utilisateur.

Voici les 4 cas possibles :

• “Haut” : déplacement vers le haut ;

• “Bas” : déplacement vers le bas ;

• “Droite” : déplacement vers la droite ;

• “Gauche” : déplacement vers la gauche.

Afin de pouvoir stocker le sens de déplacement entré par l’utilisateur, vous allez devoir stocker la valeur de retour de la fonction entrer()  dans une variable, comme ceci par exemple :sens ← entrer()

Vous avez aussi besoin de deux variables qui permettent de stocker les coordonnées du joueur,  position_x et position_y  . Ces deux variables seront passées en paramètre de la fonction.

Voilà comment mettre à jour les coordonnées du joueur en fonction des déplacements :

Nous avons alors ce début de pseudo-code :

Algorithme déplacement(position_x , position_y)
Variable
    sens ← “” : CHAÎNE DE CARACTÈRES
Début
Fin

Consigne

Vous devez maintenant créer une fonction qui permette de modifier les déplacements du joueur dans le labyrinthe. En effet, cette fonction va demander à l’utilisateur d'entrer le sens de déplacement qu’il souhaite, et la fonction va modifier les coordonnées x et y du joueur en fonction du sens de déplacement.

Votre objectif :

1. Demander à l'utilisateur d’entrer le sens de déplacement.

2. Vérifier à l’aide d’une première structure conditionnelle si l’entrée de l’utilisateur est correcte en fonction des 4 possibilités. Sinon afficher un message qui stipule que l’entrée n’est pas correcte.

3. Si l’entrée de l’utilisateur est correcte :  à l’aide de plusieurs structures conditionnelles, vous allez devoir mettre à jour les coordonnées du joueur en fonction de l’entrée de l’utilisateur.

Vérifiez votre travail

Voici le résultat à obtenir à l'issue de l'exercice :

Algorithme déplacement(position_x , position_y)
Variable
    sens ← “” : CHAÎNE DE CARACTÈRES
Début
    sens ← entrer()
    Si sens == “Haut” OU sens == “Bas” OU sens == “Droite” OU sens == “Gauche” :
        Si sens == “Haut” :
        position_y = position_y + 1
        Fin Si
        Si sens == “Bas” :
        position_y = position_y - 1
        Fin Si
        Si sens == “Droite” :
        position_x = position_x + 1
        Fin Si
        Si sens == “Gauche” :
        position_x = position_x - 1
        Fin Si
    Sinon
        afficher “L’entrée n’est pas correcte”
    Fin Si
Fin

En résumé

• Les structures conditionnelles permettent de contrôler l’exécution ou non de certaines instructions.

• L'instruction Si  est utilisée pour exécuter le code si une condition est vraie.

• L'instruction if-else  est une version étendue de l’instructionSi  . Grâce au mot-clé  else  , vous pouvez choisir quelles instructions lancer si la condition n’est pas vraie.

• Les mots-clés ET et OU permettent de combiner les conditions dans les structures conditionnelles.

Dans le chapitre suivant, nous allons partir à la découverte d’une notion très intéressante de la programmation : les boucles ! D’ailleurs, vous allez pouvoir continuer à travailler les conditions même sur les boucles. Allez, on y va !