Décisions - AlgoTouch

Avertissement Cette page a été initialement créée avec AlgoTouch version 3, reflétant les principes fondamentaux qui restent au cœur du système. Depuis, AlgoTouch a évolué vers la version 5, offrant des fonctionnalités améliorées tout en conservant son essence originale.

Table des matières

Vidéo du tutoriel

Chapitres

Exercice d'application : maximum de deux variables

Sujet

Soit deux variables x et y .

Le programme à réaliser doit:

saisir le contenu des deux variables x et y;
afficher le contenu de la variable contenant la plus grande valeur. Par exemple, si x contient la valeur 1 et y la valeur 5 alors la valeur 5 est affichée.

Les données du problème sont accessibles sur https://algotouch.irisa.fr/agt/.

Solution en vidéo

Corrigé

Define Max
Do
  Read "Read x " x ;
  Read "Read y " y ;
  if (x > y) {
    Write "Maximum " x ;
  } else {
    // x <= y
    Write "Maximum " y ;
  }
  // ...
End

Le programme complet est accessible sur https://algotouch.irisa.fr/agt/.

Vidéo du tutoriel

Retour sur la notion d'alternative

Notions de base

Tests et Conditions

La machine peut comparer des valeurs et prendre des décisions:

comparaison x (0) et y (100);
comparaison x(0) avec la constante (50).

Exemple Calcul du prix d’un billet en fonction de l'âge de la personne:

30 euros jusqu'à 14 ans inclus;
50 euros au délà.

L'âge de la personne n'est connu qu'au moment de l'exécution du programme et donc il est nécessaire d'effectuer la comparaison avec la valeur 14.

Comparaison en AlgoTouch

En AlgoTouch, pour comparer deux valeurs:

cliquer sur l’icône représentant une bascule dans la barre d’outils;
faire glisser la première valeur sur un plateau;
faire glisser la seconde valeur sur l’autre plateau.

Automatiquement AlgoTouch active la bascule et détermine quelle valeur est la plus grande, quelle valeur est la plus petite.

Choix de la condition

Lors de la comparaison de variables et/ou de valeurs, 6 cas sont possibles:

les deux sont égales:
```
 x == y 
```
les deux sont différentes:
```
 x != y 
```
la première est strictement supérieure à la seconde:
```
 x > y 
```
la première est supérieure ou égale à la seconde:
```
 x >= y 
```
La première est inférieure strictement à la seconde:
```
 x < y 
```
La première est inférieure ou égale à la seconde:
```
 x <= y 
```

Les choix dans AlgoTouch Quand la variable age (6) est comparée à LIMIT (14>), Algotouch propose 3 possibilités:

```
 age < LIMIT 
```
```
 age != LIMIT 
```
```
 age <= LIMIT 
```

Les trois propositions sont vraies. Par contre, une seule s’avère utile par la suite, la troisième. En effet, le tarif réduit s'applique jusqu'à 14 ans compris.

Associer des actions à une condition

La comparaison des variables ou des valeurs permet de prendre des décisions. En fonction du résultat de la comparaison, une séquence d’actions ou une autre est à exécuter.

Par exemple, si l’âge est inférieur ou égal à 14 ans, le prix du billet est mis à 30 euros, dans le cas contraire, le prix du billet est mis à 50 euros.

Pour mettre en place une décision:

effectuer la comparaison;
choisir parmi les trois cas la décision qui correspond;
effectuer l’opération qui correspondant au cas.

Si l’opération est conforme aux attentes:

se placer en mode enregistrement;
effectuer la comparaison;
choisir parmi les trois cas la décision qui correspond;
effectuer l’opération qui correspondant au cas;
arrêter l’enregistrement;
exécuter le code enregistré pour vérifier la validité du programme.

Toutes ces étapes sont détaillées dans la suite de cette page.

Define PrixBillet
Do
  Read "Quel age " age ;
  if (age <= LIMIT) {
    cout = REDUIT ;
  } else {
    // age > LIMIT
    cout = PRIX ;
  }
  Write "Prix du billet " cout ;
  // ...
End

Alternative complète

Nous allons traiter l’alternative à travers un exemple de calcul du prix d’un billet en fonction de l’âge de la personne. Le prix du billet est de:

30 euros jusqu’à 14 ans inclus;
50 euros au-delà.

L’âge de la personne n’est connu qu’au moment de l’exécution du programme et donc il est nécessaire d’effectuer la comparaison avec la valeur 14. Il y aura donc deux cas à prendre en compte, avec comme exemple, des âges de 6 ans et 20 ans.

Les valeurs numériques LIMIT (14), REDUIT (30) et PRIX (50) ont été créées comme des constantes afin de pouvoir éventuellement modifier les coûts ou l’âge limite. C’est une bonne pratique en programmation.

Les données du programmes sont accessibles sur https://algotouch.irisa.fr/agt/

Le rôle des variables et constantes

age représente l'âge. Sa valeur sera à saisir par l'utilisateur;
cout représente le prix du billet. Sa valeur sera calculée par le programme en fonction de l'âge saisi;
LIMIT est l'âge limite pour le tarif réduit, 14 pour notre exemple;
PRIX est le tarif sans réduction, 50 pour notre exemple;
REDUIT est le tarif réduit, 30 pour notre exemple.

Etape 1 : comparer la variable age et LIMIT

La première étape consiste à comparer la variable age à LIMIT (14):

cliquer sur le comparateur (la balance);
faire glisser age et 14 sur les deux plateaux de la balance;
activer la balance par un clic sur le triangle qui est devenu vert;
choisir le cas qui correspond parmi les trois choix proposés:
1. age > LIMIT
2. age != LIMIT
3. age >= LIMIT
choisir un des cas, en l’occurrence le dernier;
cliquer sur « Valider ».

Dans la partie « Instructions » le code suivant s’inscrit:

if (age <= LIMIT) {
  // age <= LIMIT
} else {
  // age > LIMIT
  // TO DO
}

Remarque Il reste maintenant à indiquer les opérations (les instructions) à effectuer dans la cas où age est inférieur ou égal à LIMIT (14).

Etape 2 : effectuer l'opération associée au cas

faire glisser la constante REDUIT (30) dans la variable cout;
cliquer sur l’icône représentant une porte de sortie, au centre de la balance pour terminer le cas.

Dans la console le code est complété ainsi:

if (age <= LIMIT) {
  cout = REDUIT ; 
}else {
  // age > LIMIT
  // TO DO
}

Etape 3 : traiter le cas non pris en compte (TO DO)

Le cas age inférieur ou égal à LIMIT (14) est enregistré et vérifié. Que doit faire notre programme quand age est supérieur à LIMIT ?

Avec AlgoTouch, il existe deux manières de compléter ce cas:

soit en exécutant le programme en mode construction avec age plus grand que LIMIT;
soit en sélectionnant dans le code la ligne Else et en complétant le cas age plus grand que LIMIT.

Première manière

La première manière de le définir est d’exécuter le programme avec age supérieur à LIMIT (14), par exemple 20:

sélectionner le bloc DO
exécuter le programme en mode construction avec l’icône flèche verte de la barre d’outils « Exécuter la sélection »;
saisir 20 pour la variable age;
le programme s’interrompt pour demander les actions à effectuer dans ce cas. AlgoTouch passe en mode enregistrement;
dans ce cas, la valeur de la constante PRIX (50) est affecté la variable cout. C’est la seule action à effectuer. Il faut terminer le cas en cliquant sur l’icône au centre de la balance.

Le code enregistré devient:

if (age <= LIMIT) {
  cout = REDUIT ;
} else {
  // age > LIMIT
  cout = PRIX ;
}

Remarquons que le commentaire « TO DO » a disparu. C’est pour indiquer au programmeur que son code est complet.

Deuxième manière

La deuxième manière de compléter le cas age inférieur ou égal à LIMIT (14) consiste à :

sélectionner la ligne } else {
placer AlgoTouch en mode enregistrement
effectuer les actions de ce cas, affecter la valeur de la constante PRIX (50) à la variable cout;
arrêter le mode enregistrement d’AlgoTouch

Remarque Cette manière de procéder est plus simple et plus rapide. L'objectif final est de supprimer tous les commentaires // TO DO dans le code.

Le code enregistré devient:

if (age <= LIMIT) {
  cout = REDUIT ;
} else {
  // age > LIMIT
  cout = PRIX ;
}

Etape 4 : rejouer le code complet

Le code étant maintenant complet, il est possible de la rejouer avec d’autres valeurs.

Le programme complet est sur https://algotouch.irisa.fr/agt/.

Règle : Indentation des instructions

Les instructions du bloc if sont indentées:
- cela signifie qu'elles sont décalées à droite de quelques caractères afin de bien les repérer à l’intérieur de ce bloc.
Les instructions du bloc else sont également indentées.

D’une façon générale, dès l’ouverture d’un bloc { ... }, les instructions sont indentées.

Alternative sans action dans la section “else”

Pour finir nous allons étudier le cas ou aucune instruction n’est nécessaire dans la section else .

Par exemple, la note d’un élève supérieure à 20 est ramenée à 20 et conservée sinon.

Les étapes à effectuer:

placer une valeur supérieure à 20 dans la variable note;
passer en mode enregistrement;
comparer note avec 20;
produire le code correspondant au cas note > 20 (affecter note à 20);
terminer ce cas en cliquant sur l’icône du comparateur;
terminer l’enregistrement.

Le code produit est :

Define SaisirNote
Do
  Read "Note " note ;
  if (note > 20) {
    note = 20 ;
  } else {
    // note <= 20
    // TO DO
  }
  Write "Note " note ;
  // ...
End

Le programme AlgoTouch incomplet est sur https://algotouch.irisa.fr/agt/.

Provoquer l’autre cas en plaçant une valeur inférieure à 20 dans la variable note , par exemple 15:

lancer l’exécution en mode construction avec l’icône flèche verte de la barre d’outils « Exécuter la sélection »;
après l’ouverture de la fenêtre « Enregistrement des instructions manquantes », quitter directement car aucune instruction n’est nécessaire dans ce cas.

Comme la section else ne contient aucune instruction, le code produit devient:

Define SaisirNote
Do
  Read "Note " note ;
  if (note > 20) {
    note = 20 ;
  }
  Write "Note " note ;
  // ...
End

Le programme AlgoTouch complet est sur https://algotouch.irisa.fr/agt/.

Remarque Il est possible aussi pour supprimer le cas note <= 20 de :

sélectionner la ligne } else {,
effacer le code en utilisant la brosse "Effacer la sélection" de la barre d'outils.

Exercice : rendre une valeur positive

Sujet

Soit une variable v . Cette variable doit être supérieure à 0.

Le programme AlgoTouch à réaliser doit:

saisir une valeur dans v;
passer la valeur de v à 0, si sa valeur est inférieure à 0.

Par exemple, si la valeur saisie de v est -3, elle devient 0.

Les données du problème sont accessibles sur ce lien https://algotouch.irisa.fr/agt/

Solution en vidéo

Corrigé

Define Positif
Do
  Read "Read v " v ;
  if (v < 0) {
    v = 0 ;
  }
  Write "Valeur de v " v ;
  // ...
End

Le programme complet est accessible sur https://algotouch.irisa.fr/agt/.

❮ Programme et exécution

itérations ❯