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 :
Symbole | Signification |
== | Est égal à |
> | Est supérieur à |
< | Est inférieur à |
>= | Est supérieur ou égal à |
<= | Est inférieur ou égal à |
!= | Est différent de |
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...
Néanmoins, nous avons toujours un problème. Comment allons-nous faire pour afficher le message de défaite ?
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
renvoieVrai
lorsque ses conditions gauche et droite sont égalementVrai
. Lorsqu'une ou les deux conditions sont fausses, le résultat obtenu parET
est égalementFaux
.L'opérateur
OU
renvoieVrai
lorsque sa condition gauche, droite ou les deux sontVrai
. 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 :
déplacement vers le haut | ajoutez 1 à |
déplacement vers le bas | retirez 1 à |
déplacement vers la droite | ajoutez 1 à |
déplacement vers la gauche | retirez 1 à |
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 :
Demander à l'utilisateur d’entrer le sens de déplacement.
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.
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
etOU
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 !