⌂ Algorigrammes
Fiche 8 sur 13

La saisie contrôlée

Refuser les valeurs impossibles et redemander, ou répéter un programme jusqu'à un signal d'arrêt.

Après cette fiche, vous saurez :

1Le problème : l'utilisateur tape n'importe quoi

Un programme demande une note sur 20, et l'utilisateur tape 45. Ou -3. Si le programme accepte cette valeur, tous ses calculs seront faux. Il doit donc refuser les valeurs impossibles et redemander jusqu'à en recevoir une correcte. C'est la saisie contrôlée.

Sans ce contrôle, un programme peut échouer de deux façons :

Dans un programme un tant soit peu sérieux, on met donc toujours un contrôle de saisie.

2Le principe : demander, vérifier, redemander

Le schéma est toujours le même :

  1. on affiche la question et on saisit la réponse ;
  2. on vérifie la valeur dans un losange (est-elle impossible ?) ;
  3. si oui, elle est impossible : on affiche un message, et la flèche remonte pour redemander ;
  4. si non, elle est correcte : on continue le programme.
Début int note "Note sur 20 :" note note < 0 || note > 20 "Valeur impossible" "Note enregistrée : {note}" Fin oui non

Le même programme en C# :

int note;

do
{
    Console.WriteLine("Note sur 20 :");
    note = Convert.ToInt32(Console.ReadLine());

    if (note < 0 || note > 20)
    {
        Console.WriteLine("Valeur impossible");
    }
}
while (note < 0 || note > 20);

Console.WriteLine($"Note enregistrée : {note}");

Avec les saisies 25, -3 puis 14, l'écran montre :

Ce que l'ordinateur affiche
Note sur 20 :
Valeur impossible
Note sur 20 :
Valeur impossible
Note sur 20 :
Note enregistrée : 14

Remarquez que le losange pose la question de l'erreur (« la valeur est-elle impossible ? ») : la sortie oui mène donc au message et au retour, la sortie non continue.

3Le test se fait après

Dans la fiche 7, le losange était avant le corps de la boucle (« tant que ») : on pouvait ne faire aucun tour. Pour une saisie, c'est impossible : il faut demander au moins une fois avant de pouvoir vérifier la réponse. Le losange se place donc après la saisie.

Test avant (tant que)Test après (faire… tant que)
Place du losangeavant le corps de la boucleaprès le corps de la boucle
Nombre minimum de tours0 (si la condition est fausse d'emblée)1 (on passe toujours une fois)
Code C#while (condition) { ... }do { ... } while (condition);
Sert pourcompter, parcourirles saisies, les menus

Deux façons de lire un test en fin de boucle

Il existe deux lectures d'une même boucle à test en fin. Elles sont équivalentes : il suffit d'inverser la condition pour passer de l'une à l'autre.

« Faire… tant que » (ce cours, l'exemple de classe, le C#)« Répéter… jusqu'à » (certains schémas du syllabus)
Condition du losangela condition pour continuerla condition pour s'arrêter
On remonte quand la réponse est…oui (à droite)non
On sort quand la réponse est…nonoui
Répéter 100 foisi < 100i = 100
Code C#do { ... } while (i < 100);(pas d'équivalent direct : on inverse la condition)

Voici la boucle « qui se répète 100 fois » (un compteur : initialisation, incrémentation, test) dessinée dans notre convention. Le dessin du syllabus, avec i = 100, remonte sur « non » ; ici on écrit la condition inverse, i < 100, et on remonte sur « oui ».

Début int i = 0 int total = 0 total += 2 i++ i < 100 "Tours : {i} Total : {total}" Fin oui non
Ce que l'ordinateur affiche
Tours : 100   Total : 200

À retenir

Une saisie contrôlée utilise toujours un test après : on demande d'abord, on vérifie ensuite.

4Écrire la condition d'erreur

Le losange contient la condition de la valeur impossible, pas celle de la valeur correcte. Pour une note entre 0 et 20, une note est impossible si elle est plus petite que 0 OU plus grande que 20 :

note < 0 || note > 20

Attention

Avec une borne basse et une borne haute, c'est toujours || (ou).

Écrire note < 0 && note > 20 serait une condition jamais vraie (aucun nombre n'est à la fois inférieur à 0 et supérieur à 20). Toutes les valeurs seraient acceptées.

Vérifions avec les valeurs limites : 0 et 20 sont acceptées, -1 et 21 refusées.

Valeur saisieRésultat
-1refusée, on redemande
0acceptée
20acceptée
21refusée, on redemande

5Quand il n'y a qu'une seule bonne valeur

Un code secret n'a qu'une valeur correcte. La condition d'erreur est alors « différent de » :

Début int code "Code secret :" code code != 1234 "Code erroné" "Bienvenue !" Fin oui non
Ce que l'ordinateur affiche
Code secret :
Code erroné
Code secret :
Code erroné
Code secret :
Bienvenue !

Des messages différents pour guider l'utilisateur

Le message d'erreur n'est pas obligatoirement le même à chaque fois. Dans un jeu où il faut deviner un nombre, le programme peut dire si l'essai est trop petit ou trop grand. Les messages se placent alors dans le corps de la boucle, avec des losanges, et le test en fin ne sert qu'à décider si l'on continue :

Début int secret = 42 int essai "Votre essai :" essai essai < secret "Trop petit" essai > secret "Trop grand" essai != secret "Bravo !" Fin oui non oui non oui non
Ce que l'ordinateur affiche
Votre essai :
Trop petit
Votre essai :
Trop grand
Votre essai :
Bravo !

Comparez avec la note contrôlée : là, un seul message suffisait, placé sur le chemin du retour. Ici, il y en a deux, donc deux losanges avant le test.

6Répéter tout un programme

Le même mécanisme permet de recommencer le programme tant que l'utilisateur le demande. Ici, un calculateur de prix TTC qu'on relance tant qu'on répond « o » :

Début double prix double prix_ttc string encore "Prix hors taxe :" prix prix_ttc = prix * 1.21 "Prix TTC : {prix_ttc}" "Un autre calcul ? (o/n)" encore encore == "o" Fin oui non

Il n'y a pas de message : la sortie oui remonte directement. C'est la structure de l'exemple vu en classe (« Pour arrêter, tapez -1, sinon n'importe quelle touche »).

7S'arrêter avec une valeur spéciale

Quand on ne sait pas combien de valeurs l'utilisateur va saisir, on convient d'une valeur qui veut dire « j'ai fini » : -1, 0... On l'appelle une valeur sentinelle. Ici, on additionne des nombres jusqu'à ce qu'on tape -1 :

Début int nombre int somme = 0 "Nombre (-1 pour arrêter) :" nombre nombre != -1 somme += nombre "Nombre (-1 pour arrêter) :" nombre "Somme : {somme}" Fin oui non

Observez l'astuce : on lit une première fois avant la boucle, et on relit à la fin de chaque tour. Ainsi, le test « nombre différent de -1 ? » a toujours une valeur à examiner, et le -1 n'est jamais ajouté à la somme.

Passagenombresomme
test n°150
test n°235
test n°3108
test n°4-118

Avec 5, 3, 10 puis -1, la somme finale est 18.

Une condition qui porte sur un cumul

La condition d'arrêt n'est pas toujours une valeur saisie : elle peut porter sur un total qui grandit. Ici, on remplit un panier jusqu'à ce que le total atteigne 50 € :

Début double prix double total = 0 "Prix d'un article :" prix total += prix total < 50 "Total du panier : {total}" Fin oui non
Ce que l'ordinateur affiche
Prix d'un article :
Prix d'un article :
Prix d'un article :
Total du panier : 60

Le total est mis à jour dans la boucle, puis testé à la fin. On répète tant que le total est inférieur à 50 : dès qu'il vaut 50 ou plus, on s'arrête (la dernière valeur peut le faire dépasser).

À retenir

→Exercices

1Le code secretRecopier

Reproduisez cet algorigramme. Avec les saisies 1111, 0 puis 1234, combien de fois le message « Code erroné » est-il affiché ?

Début int code "Code secret :" code code != 1234 "Code erroné" "Bienvenue !" Fin oui non

Solution

Début int code "Code secret :" code code != 1234 "Code erroné" "Bienvenue !" Fin oui non
Ce que l'ordinateur affiche
Code secret :
Code erroné
Code secret :
Code erroné
Code secret :
Bienvenue !

Le message est affiché deux fois (pour 1111 et pour 0). Avec 1234, la condition code != 1234 est fausse : on sort de la boucle.

2Contrôler un âgeModifier

Voici la saisie d'une note sur 20.

Début int note "Note sur 20 :" note note < 0 || note > 20 "Valeur impossible" "Note enregistrée : {note}" Fin oui non

Adaptez-la pour saisir un âge entre 0 et 120, avec le message « Âge impossible ».

Solution

Quatre éléments changent : la variable, la question, la condition d'erreur et le message.

Début int age "Votre âge :" age age < 0 || age > 120 "Âge impossible" "Âge enregistré : {age}" Fin oui non
Valeur saisieRésultat
-1refusée, on redemande
0acceptée
120acceptée
121refusée, on redemande
3Les carrés jusqu'à zéro (syllabus P3·3)Créer

Dessinez l'algorigramme qui lit des nombres, l'un à la suite de l'autre, affiche le carré de chacun, et s'arrête dès qu'on entre 0.

Solution

Le 0 est la valeur sentinelle. On lit avant la boucle, puis à la fin de chaque tour : ainsi, le 0 n'a pas de carré affiché.

Début int nombre int carre "Nombre (0 pour arrêter) :" nombre nombre != 0 carre = nombre * nombre "Son carré est : " , carre "Nombre (0 pour arrêter) :" nombre Fin oui non
Passagenombrecarre
test n°13?
test n°2-29
test n°354
test n°4025
Ce que l'ordinateur affiche
Nombre (0 pour arrêter) :
Son carré est : 9
Nombre (0 pour arrêter) :
Son carré est : 4
Nombre (0 pour arrêter) :
Son carré est : 25
Nombre (0 pour arrêter) :
4La caisseCréer

Dessinez l'algorigramme d'une caisse. L'utilisateur saisit les prix de ses articles un par un, et tape 0 quand il a fini. Le programme affiche alors le nombre d'articles et le total à payer.

Indice : lisez une première fois avant la boucle.

Solution

Début double prix double total = 0 int nb_articles = 0 "Prix de l'article (0 pour terminer) :" prix prix != 0 total += prix nb_articles++ "Prix de l'article (0 pour terminer) :" prix "{nb_articles} article(s) : {total} euros" Fin oui non
Passageprixnb_articlestotal
test n°12.500
test n°2412.5
test n°31.526.5
test n°4038

Avec 2.5, 4, 1.5 puis 0 : 3 articles, 8 euros. Le 0 n'est jamais compté parmi les articles, grâce à la lecture avant la boucle et à la relecture en fin de tour.

5Un nombre entre 10 et 20 (syllabus P3·4)Créer

Dessinez l'algorigramme qui demande un nombre compris entre 10 et 20, et recommence jusqu'à ce que la réponse convienne. En cas de réponse supérieure à 20, il affiche « Plus petit ! » ; si elle est inférieure à 10, il affiche « Plus grand ! ».

Solution

Deux messages différents : comme dans le jeu du nombre à deviner, ils se placent dans le corps de la boucle, avec deux losanges. Le test en fin pose la question de l'erreur (nombre < 10 || nombre > 20) :

Début int nombre "Entrez un nombre entre 10 et 20 :" nombre nombre > 20 "Plus petit !" nombre < 10 "Plus grand !" nombre < 10 || nombre > 20 "Merci : " , nombre Fin oui non oui non oui non
Ce que l'ordinateur affiche
Entrez un nombre entre 10 et 20 :
Plus petit !
Entrez un nombre entre 10 et 20 :
Plus grand !
Entrez un nombre entre 10 et 20 :
Merci : 15

Valeurs limites : 10 et 20 sont acceptés (ni « plus petit » ni « plus grand »).

6Jusqu'à ce que la somme atteigne 100 (syllabus P3·5)Créer

Dessinez l'algorigramme qui fait entrer des nombres, l'un après l'autre, jusqu'à ce que leur somme soit supérieure ou égale à 100. Il affiche la somme atteinte.

Solution

La somme est mise à jour dans la boucle. Le test en fin dit si l'on continue : tant que la somme est inférieure à 100.

Début int nombre int somme = 0 "Entrez un nombre :" nombre somme += nombre "Somme actuelle : " , somme somme < 100 "Somme atteinte : " , somme Fin oui non
Ce que l'ordinateur affiche
Entrez un nombre :
Somme actuelle : 40
Entrez un nombre :
Somme actuelle : 75
Entrez un nombre :
Somme actuelle : 105
Somme atteinte : 105

Avec 40, 35 puis 30, la somme passe 75 puis dépasse 100 (105) : la dernière valeur peut la faire dépasser. Avec un seul nombre égal à 100, la boucle s'arrête dès le premier tour, car 100 < 100 est faux.

7Une table de multiplication au choix (syllabus P3·6)Créer

Dessinez l'algorigramme qui demande un nombre compris entre 1 et 10 (avec contrôle de saisie), puis affiche la table de multiplication de ce nombre, de ×1 à ×10.

Solution

Deux boucles l'une après l'autre : d'abord la saisie contrôlée (test en fin), puis le défilement de 1 à 10 (test au début, comme à la fiche 7).

Début int nombre int i = 1 int resultat "Quelle table (de 1 à 10) ?" nombre nombre < 1 || nombre > 10 "Valeur impossible" i <= 10 resultat = nombre * i "{nombre} x {i} = {resultat}" i++ Fin oui non oui non
Ce que l'ordinateur affiche
Quelle table (de 1 à 10) ?
Valeur impossible
Quelle table (de 1 à 10) ?
7 x 1 = 7
7 x 2 = 14
7 x 3 = 21
7 x 4 = 28
7 x 5 = 35
7 x 6 = 42
7 x 7 = 49
7 x 8 = 56
7 x 9 = 63
7 x 10 = 70

Le 12, refusé, ne provoque que le message « Valeur impossible » ; la table n'est dessinée qu'une fois un nombre valide obtenu. Ne confondez pas ces deux boucles avec des boucles imbriquées : ici, elles se suivent (la fiche suivante montre le cas où l'une est dans l'autre).

Je sais faire

Une case qui coince ? Relisez la partie concernée avant de passer à la fiche suivante.

← Fiche 7 Fiche 9 : Compteurs, sommes, minimum et maximum →