⌂ Algorigrammes
Fiche 12 sur 13

De l'énoncé au dessin

Une méthode pour transformer n'importe quel énoncé en algorigramme, étape par étape.

Après cette fiche, vous saurez :

1Devant un grand énoncé

Vous connaissez maintenant tous les ingrédients : variables, saisies, calculs, conditions, boucles, compteurs, séries. Face à un énoncé de dix lignes, la difficulté n'est plus de connaître les formes, mais de savoir par où commencer.

La réponse est une méthode. Elle fonctionne pour n'importe quel énoncé.

2La méthode en six étapes

  1. Lire l'énoncé deux fois, un crayon à la main Soulignez en trois couleurs : les données (ce que l'utilisateur saisit), les résultats (ce qu'il faut afficher) et les règles (contrôles, seuils, tranches).
  2. Lister les variables Pour chaque donnée et chaque résultat, notez un nom, un type et une valeur de départ. N'oubliez pas les compteurs et les sommes (à 0).
  3. Découper en blocs Presque tous les énoncés ont la même forme : préparer (variables), répéter (une boucle sur les données), conclure (calculs finaux et affichage).
  4. Dessiner bloc par bloc Terminez un bloc avant de passer au suivant. Dans une boucle, vérifiez les trois étapes : initialiser, tester, modifier.
  5. Tester avec une table de suivi Choisissez des valeurs simples, dont des valeurs limites, et déroulez le dessin.
  6. Relire avec la liste de contrôle Voir plus bas.

3Un exemple complet : les amendes de la bibliothèque

Appliquons la méthode à l'exemple vu en classe. Voici l'énoncé tel qu'on peut le reconstituer à partir du dessin :

L'énoncé

Une bibliothèque facture une amende par jour de retard : 0,10 € de 1 à 7 jours, 0,25 € de 8 à 30 jours, 0,50 € au-delà.

Le programme demande le nombre de jours de retard (entre 0 et 365, sinon il redemande), calcule et affiche l'amende, puis propose de continuer ou de s'arrêter en tapant -1.

À la fin, il affiche le nombre total de retours, l'amende totale perçue, et le type de pénalité (faible, modérée ou élevée) le plus fréquent.

Étapes 1 et 2 : données, résultats, variables

ÉlémentRôleVariable
jours de retarddonnée saisie (0 à 365)int nbre_jours_retard
tarifs par jourrègles (trois tranches)double pen_faible = 0.10, pen_mod = 0.25, pen_elev = 0.50
amende d'un retourrésultat intermédiairedouble amende
continuer ou arrêterdonnée saisiestring encodage
nombre de retourscompteurint nbre_retours = 0
amende totalesommedouble total_amendes = 0
retours par typetrois compteursint nb_faible = 0, nb_mod = 0, nb_elev = 0

Étape 3 : les blocs

BlocCe qu'il faitFiches
Préparerrectangle de déclaration2
Répéter (jusqu'à -1)boucle « faire… tant que » qui entoure tout le traitement d'un retour7, 8
  saisie contrôléeredemander tant que les jours sont hors de 0 à 365 (une boucle dans la boucle principale)8, 10
  calcul de l'amendecascade de losanges pour les trois tranches, avec un compteur par tranche6, 9
  mise à jour des totauxnbre_retours++ et total_amendes += amende4
Conclureaffichage des totaux, puis comparaison des trois compteurs5, 6

Étape 4 : le dessin

Début int nbre_jours_retard double pen_faible = 0.10 double pen_mod = 0.25 double pen_elev = 0.50 double amende string encodage int nbre_retours = 0 double total_amendes = 0 int nb_faible = 0 int nb_mod = 0 int nb_elev = 0 "Encodez le nombre de jours de retard du client :" nbre_jours_retard nbre_jours_retard > 365 || nbre_jours_retard < 0 nbre_jours_retard >= 1 && nbre_jours_retard <= 7 amende = nbre_jours_retard * pen_faible nb_faible++ nbre_jours_retard >= 8 && nbre_jours_retard <= 30 amende = nbre_jours_retard * pen_mod nb_mod++ amende = nbre_jours_retard * pen_elev nb_elev++ "Amende de : {amende}" nbre_retours++ total_amendes += amende "Pour arrêter, tapez -1, sinon n'importe quelle touche pour continuer..." encodage encodage != "-1" "Le nombre total de retours est de : {nbre_retours} L'amende totale perçue est de : {total_amendes}" nb_faible > nb_mod && nb_faible > nb_elev "Il y a eu plus de pénalités faibles !" nb_mod > nb_faible && nb_mod > nb_elev "Il y a eu plus de pénalités modérées !" "Il y a eu plus de pénalités élevées !" Fin oui non oui non oui non oui non oui non oui non

Relisez-le avec le tableau des blocs : chaque bloc se retrouve dans le dessin, dans le même ordre.

Étape 5 : le tester

Avec les saisies 3, 20, 400 (impossible, redemandé), 40, puis -1 pour arrêter :

Ce que l'ordinateur affiche
Encodez le nombre de jours de retard du client :
Amende de : 0.30000000000000004
Pour arrêter, tapez -1, sinon n'importe quelle touche pour continuer...
Encodez le nombre de jours de retard du client :
Amende de : 5
Pour arrêter, tapez -1, sinon n'importe quelle touche pour continuer...
Encodez le nombre de jours de retard du client :
Encodez le nombre de jours de retard du client :
Amende de : 20
Pour arrêter, tapez -1, sinon n'importe quelle touche pour continuer...
Le nombre total de retours est de : 3
L'amende totale perçue est de : 25.3
Il y a eu plus de pénalités élevées !

Le test permet de repérer les cas limites que le dessin traite d'une façon à connaître :

Un bon algorigramme prévoit ces cas ou les décrit explicitement. C'est le but de l'étape 5.

4La liste de contrôle

Avant de rendre un algorigramme, vérifiez chaque point :

5Les erreurs les plus fréquentes

ErreurConséquenceRemède
Compteur ou somme sans valeur de départle programme refuse de calculermettre = 0 dans le rectangle de déclaration
Oublier de modifier le compteur de boucleboucle infinieajouter ++ dans la boucle
< au lieu de <=un tour de moins que prévudéroulez le dernier tour
Diviser par le mauvais nombremoyenne faussediviser par le nombre de valeurs réellement saisies
Deux noms différents pour la même variableune variable jamais mise à jourrelire tous les noms
Un losange sans étiquetteson ne sait plus quel chemin est « oui »toujours écrire oui / non
Une seule forme pour la question et la réponsedessin incompletun trapèze, puis un parallélogramme

6Découper un grand dessin : le sous-programme

Quand une même suite de formes revient plusieurs fois (par exemple l'affichage d'un en-tête, ou la saisie contrôlée d'une note), on peut la dessiner une seule fois, à part, et lui donner un nom. C'est un sous-programme. Dans le dessin principal, on l'appelle par son nom avec une septième forme : le rectangle à doubles barres verticales.

Début a = 5 "Bonjour" age age >= 18 calculer_total() Le début ou la fin du programme Un traitement : un calcul, ou donner une valeur à une variable Afficher quelque chose à l'écran Saisir : récupérer ce que l'utilisateur tape au clavier Une question, avec deux sorties : oui (à droite) et non Un sous-programme : un bloc réutilisable, qu'on appelle par son nom Une liaison : une flèche qui donne le sens du déroulement

Voici un programme qui affiche le même bandeau au début et à la fin. Le sous-programme afficher_bandeau() est dessiné une fois (avec son propre Début et sa propre Fin), et le programme principal l'appelle deux fois :

Le programme principal

Début string prenom afficher_bandeau() "Votre prénom :" prenom "Bonjour {prenom}" afficher_bandeau() Fin

Le sous-programme afficher_bandeau()

afficher_bandeau() "==================" " JF-Digit" "==================" Retour
Ce que l'ordinateur affiche
==================
   JF-Digit
==================
Votre prénom :
Bonjour Camille
==================
   JF-Digit
==================

À chaque appel, le programme « saute » dans le sous-programme, en exécute toutes les formes, puis revient juste après le rectangle à doubles barres.

IntérêtPourquoi
On ne redessine pasune même suite de formes est dessinée une seule fois
On corrige à un seul endroitsi le bandeau change, un seul dessin à modifier
Le dessin principal reste lisibleun grand algorigramme se découpe en morceaux avec chacun un nom

En C#, un sous-programme s'appelle une méthode. Elle peut recevoir des valeurs et en renvoyer une : c'est le sujet de la fiche 12 du cours C#. Dans ce cours, nous gardons les choses simples : le sous-programme et le programme principal partagent les mêmes variables.

7Les liaisons

Les liaisons sont les traits fléchés qui relient les formes et donnent le sens du déroulement. Quelques règles pour qu'un grand dessin reste lisible :

Si le dessin devient trop grand pour une page, c'est le signe qu'il faut le découper en sous-programmes.

→Exercices

1Dérouler une moyenneRecopier

Reproduisez cet algorigramme qui calcule la moyenne de trois températures, puis déroulez-le avec 10, 20 et 15.

Début int jour = 1 double temperature double somme = 0 double moyenne jour <= 3 "Température du jour {jour} :" temperature somme += temperature jour++ moyenne = somme / 3 "Moyenne : {moyenne}" Fin oui non

Solution

Début int jour = 1 double temperature double somme = 0 double moyenne jour <= 3 "Température du jour {jour} :" temperature somme += temperature jour++ moyenne = somme / 3 "Moyenne : {moyenne}" Fin oui non
Passagejourtemperaturesomme
test n°11?0
test n°221010
test n°332030
test n°441545
Ce que l'ordinateur affiche
Température du jour 1 :
Température du jour 2 :
Température du jour 3 :
Moyenne : 15
2Trouver les erreursModifier

Cet algorigramme devait calculer la moyenne de trois températures. Les éléments en rouge contiennent des erreurs (il y en a trois).

Début int jour = 1 double temperature double somme double moyenne jour < 3 "Température du jour {jour} :" temperature somme += temperature moyenne = somme / 3 "Moyenne : {moyenne}" Fin oui non

Trouvez-les, expliquez leur conséquence et dessinez la version corrigée.

Solution

  1. La somme n'a pas de valeur de départ (rectangle rouge) : la variable est vide, le programme ne peut pas y ajouter. Il faut écrire double somme = 0.
  2. La condition est jour < 3 (losange rouge) : on ferait seulement deux tours alors qu'il faut trois températures. Il faut jour <= 3.
  3. Le compteur jour n'est jamais augmenté dans la boucle : c'est une boucle infinie. Il faut ajouter jour++.

Version corrigée :

Début int jour = 1 double temperature double somme = 0 double moyenne jour <= 3 "Température du jour {jour} :" temperature somme += temperature jour++ moyenne = somme / 3 "Moyenne : {moyenne}" Fin oui non
3Le parkingCréer

Appliquez la méthode en six étapes à cet énoncé.

Un parking facture ses clients selon la durée de stationnement : 1,50 € par heure jusqu'à 2 heures, puis 1 € par heure supplémentaire (les 2 premières heures coûtent donc 3 € au maximum).

Le programme demande la durée en heures entières, entre 1 et 24 (sinon il affiche « Durée impossible » et redemande), affiche le prix, puis demande s'il y a un autre véhicule (o ou n). À la fin, il affiche le nombre de véhicules et le total encaissé.

Solution

Étapes 1 et 2 : les variables. Les heures (int), le prix (double), le total encaissé (double, à 0), le nombre de véhicules (int, à 0) et la réponse « un autre véhicule ? » (string).

Étape 3 : les blocs. Préparer ; répéter tant qu'il y a un autre véhicule (avec, dedans, une saisie contrôlée, un calcul à deux cas, l'affichage du prix, les totaux et la question) ; conclure en affichant les totaux.

Étape 4 : le dessin.

Début int heures double prix double total = 0 int nb_vehicules = 0 string encore "Durée en heures (1 à 24) :" heures heures < 1 || heures > 24 "Durée impossible" heures <= 2 prix = heures * 1.5 prix = 3 + (heures - 2) * 1 "Prix : {prix}" nb_vehicules++ total += prix "Un autre véhicule ? (o/n)" encore encore == "o" "Véhicules : {nb_vehicules} Total encaissé : {total}" Fin oui non oui non oui non

Étape 5 : un essai. Avec 1 h (autre véhicule : oui), 30 (impossible), 5 h (oui), puis 2 h (non) :

Ce que l'ordinateur affiche
Durée en heures (1 à 24) :
Prix : 1.5
Un autre véhicule ? (o/n)
Durée en heures (1 à 24) :
Durée impossible
Durée en heures (1 à 24) :
Prix : 6
Un autre véhicule ? (o/n)
Durée en heures (1 à 24) :
Prix : 3
Un autre véhicule ? (o/n)
Véhicules : 3  Total encaissé : 10.5

Les prix sont 1,50 € (1 h), 6 € (3 € pour les deux premières heures + 3 × 1 €) et 3 € (2 h), soit 10,50 € au total.

4Un sous-programme pour la saisieCréer

On veut la moyenne de trois notes, chacune comprise entre 0 et 20 (sinon, « Note impossible » et on redemande).

Plutôt que de dessiner trois fois la saisie contrôlée, dessinez à part un sous-programme lire_note(), puis le programme principal qui l'appelle (dans une boucle de 3 tours) et calcule la moyenne.

Solution

On dessine deux algorigrammes. D'abord le sous-programme, avec son propre Début et sa propre Fin :

lire_note() "Note (0 à 20) :" note note < 0 || note > 20 "Note impossible" Retour oui non

Puis le programme principal, qui appelle lire_note() avec le rectangle à doubles barres :

Début int i = 1 double note double somme = 0 double moyenne i <= 3 lire_note() somme += note i++ moyenne = somme / 3 "Moyenne : " , moyenne Fin oui non
Ce que l'ordinateur affiche
Note (0 à 20) :
Note impossible
Note (0 à 20) :
Note (0 à 20) :
Note (0 à 20) :
Moyenne : 10

La saisie contrôlée n'est dessinée qu'une fois, et elle sert pour les trois notes. Ici, la note 25 est refusée, puis 12, 8 et 10 sont acceptées : la moyenne est 10.

Je sais faire

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

← Fiche 11 Fiche 13 : Projet : la station météo →