Un premier organigramme avec Flowgorithm
Ce que ce chapitre apporte 5 points
- Distinguer un algorithme d'un programme, et expliquer pourquoi l'ordre des instructions décide du résultat.
- Reconnaître chaque forme de Flowgorithm et dire son rôle.
- Construire un programme linéaire qui déclare ses variables, lit des saisies, calcule et affiche.
- Exécuter un programme pas à pas et suivre ses variables dans la fenêtre des variables.
- Repérer une variable non déclarée, une variable sans valeur et deux formes placées dans le mauvais ordre.
Écrire un programme demande d'ordinaire deux efforts à la fois : trouver le raisonnement, et le taper sans faute. Pour un débutant, le second masque le premier. Flowgorithm retire la syntaxe : on assemble des formes, le logiciel les exécute une par une, et chaque variable reste visible pendant le déroulé. Ce chapitre présente ses formes et construit un premier programme complet : déclarer, lire, calculer, afficher.
Un algorithme, puis un programme
Un algorithme est une suite finie d'instructions précises qui mène d'une situation de départ au résultat voulu. Il décrit le raisonnement, sans dépendre d'un langage.
Un programme est la traduction de cet algorithme dans un langage que la machine sait exécuter : ici les formes de Flowgorithm, plus tard Python.
L'algorithme est la recette ; le programme est cette même recette récrite dans la langue d'un cuisinier particulier, ici les formes de Flowgorithm, plus tard Python. Une recette juste reste juste dans une langue comme dans l'autre ; une recette fausse donne un plat raté, quelle que soit la langue dans laquelle elle est écrite.
La différence avec un cuisinier tient en un mot : la machine exécute aveuglément. Elle ne devine rien, ne corrige rien, ne saute aucune étape. « Remplir la cuve » ne lui dit rien ; « lire le volume demandé, ouvrir la vanne, ajouter ce volume au volume actuel » lui convient. Encore faut-il que chaque étape soit à sa place. Dans un organigramme, elle suit les flèches : une forme après l'autre, de haut en bas.
À retenir. Un programme ne fait que ce qui est écrit, dans l'ordre où c'est écrit. Quand le résultat est faux, la cause est dans une forme précise, et la trouver consiste à suivre l'exécution forme par forme.
Qu'est-ce qui distingue un algorithme d'un programme ?
Pourquoi passer par un outil visuel
Le parcours d'algorithmique a posé le raisonnement en pseudo-code, dont les figures se déroulent pas à pas dans la page. Flowgorithm reprend les mêmes structures et y ajoute trois choses : des types déclarés, que la machine fait respecter ; un dessin où la structure du programme se voit d'un coup d'œil ; la traduction automatique vers Python. Dans le logiciel, le programme se construit à la souris, sans demander d'écrire une seule ligne de code. Un langage comme Python impose au contraire, dès la première ligne, des parenthèses, des guillemets, une indentation exacte. Une faute de frappe arrête tout, et l'attention part vers la syntaxe au lieu du raisonnement. Flowgorithm supprime cet obstacle : chaque instruction est une forme, et les flèches donnent l'ordre.
Flowgorithm n'invente pas l'algorithme. Décider quelles valeurs lire, quel calcul faire et dans quel ordre reste le travail de la personne qui programme. L'outil sert à apprendre ce raisonnement ; il ne sert pas à écrire des logiciels. Il prolonge le pseudo-code du parcours d'algorithmique et prépare Python, qui vient ensuite : le Source Code Viewer (touche F12) montre dès maintenant chaque organigramme traduit en Python.
L'installation et la fenêtre du logiciel font l'objet du chapitre précédent, Télécharger et installer Flowgorithm. Il suffit ici d'en retenir qu'un programme vide contient déjà deux formes reliées par une flèche, Main qui marque le début et End qui marque la fin, et que tout se construit entre les deux.
Voici à quoi cela ressemble. Trois formes entre Main et End, lues de haut en bas : une case qui crée une variable, une qui lui range un texte, une qui l'affiche. Appuyer sur Exécuter, et le texte apparaît dans la console, exactement comme dans le logiciel.
Le plus petit programme utile : une déclaration, une affectation, une sortie. Le bouton « Pas à pas » avance d'une forme à la fois, et la fenêtre des variables montre le texte arriver dans « message ». Appuyer sur Exécuter, puis recommencer en pas à pas.
Les noms de ces formes, et les autres, viennent juste après. L'ordre est voulu : on regarde d'abord un programme tourner, on apprend ensuite comment ses pièces s'appellent.
Les formes de Flowgorithm
Chaque instruction a sa forme, et la forme annonce la nature de l'instruction avant même qu'on lise son contenu. Les figures de ce cours reprennent l'apparence du logiciel.
| Forme | En français | Sur les figures du cours | Rôle |
|---|---|---|---|
| Main et End | début et fin | pilule mauve | ouvrir et fermer le programme |
| Declare | déclaration | rectangle jaune pâle, barré d'un filet en haut et à gauche | créer des variables et fixer leur type |
| Input | saisie | parallélogramme bleu clair | lire une valeur au clavier et la ranger dans une variable |
| Assign | affectation | rectangle jaune pâle | ranger le résultat d'un calcul dans une variable |
| Output | affichage | parallélogramme vert clair | évaluer une expression et l'afficher |
| If | condition, « si » | losange rose | choisir entre deux chemins |
| While | boucle « tant que » | hexagone orangé | répéter tant qu'une condition est vraie, en testant avant |
| For | boucle « pour » | hexagone orangé | répéter en faisant varier un compteur |
| Do | boucle « faire, tant que » | hexagone orangé, sous le corps de la boucle | répéter en testant après le corps |
| Call | appel | rectangle mauve à deux barres verticales | transférer le contrôle à une fonction |
| Comment | commentaire | cadre en pointillés | écrire un commentaire dans l'organigramme |
| Breakpoint | point d'arrêt | absente des figures ; un octogone rouge dans le logiciel | suspendre l'exécution pour observer les variables |
La première colonne donne les noms de l'interface anglaise, ceux que ce cours emploie. La deuxième ne recopie pas l'interface française du logiciel, dont les libellés peuvent différer : elle dit en français ce qu'est chaque forme. Dans un logiciel passé en français, c'est le dessin et la couleur qui permettent de retrouver chaque forme de ce tableau.
Ce chapitre n'emploie que les quatre formes d'un programme linéaire : Declare, Input, Assign et Output. If arrive avec les conditions, While, For et Do avec les boucles, Call avec les fonctions. Comment et Breakpoint, qui ne changent rien au résultat, apparaissent dès le chapitre suivant.
Quelle forme range dans une variable une valeur tapée au clavier ?
Le premier programme
Un entrepôt prépare des palettes qui portent toutes le même nombre de colis. Le responsable saisit le nombre de palettes et le nombre de colis par palette ; le programme affiche le nombre total de colis à expédier.
Avant d'ouvrir le logiciel, écrire en français ce qui entre, ce qui sort et le calcul qui relie les deux :
- entrées : le nombre de palettes, le nombre de colis par palette ;
- sortie : le nombre total de colis ;
- calcul : total = palettes × colis par palette.
Dans Flowgorithm, la construction suit toujours le même geste :
- Ajouter une forme : survoler la flèche à l'endroit voulu, qui devient orange, puis double-cliquer (ou cliquer droit) et choisir la forme dans le menu qui s'ouvre.
- La remplir : la forme ajoutée reste grise tant qu'elle est incomplète ; double-cliquer dessus ouvre une fenêtre où saisir son contenu, et elle prend sa couleur une fois remplie.
- Recommencer sur la flèche suivante, dans l'ordre où les instructions doivent s'exécuter.
La fenêtre d'une forme Output propose aussi une case de retour à la ligne : ce cours la suppose cochée, chaque sortie occupant sa propre ligne. Ces gestes se font dans le logiciel ; sur cette page, la figure s'exécute, saisies comprises, mais ne se modifie pas.
Déclarer, lire, calculer, afficher. Une seule forme Declare crée les trois variables ; le symbole & colle le texte et la valeur dans la sortie. Exécuter avec 12 et 40, puis relancer en saisissant 0 palette : le programme répond sans broncher, et c'est au concepteur de décider si ce cas mérite un message.
Chaque forme a une seule tâche. La forme Declare vient en premier et crée les trois variables, de type Integer (entier) : les types font l'objet du chapitre suivant. Les deux formes Input rangent les saisies dans l'ordre où elles arrivent : la première saisie va dans la variable de la première forme Input, quel que soit l'ordre des noms dans la forme Declare. L'affectation, écrite totalColis = palettes * colisParPalette sur la figure, se lit de droite à gauche : calculer le produit, puis le ranger dans totalColis. Le signe = y veut dire « reçoit », et non « est égal à » : le chapitre suivant y revient.
Un nom commence par une lettre, puis enchaîne lettres et chiffres, sans espace ni tiret bas. Flowgorithm ne distingue pas les majuscules des minuscules : totalColis et TOTALCOLIS désignent la même variable. Dans ce cours, les noms s'écrivent sans accent, parce qu'ils passent tels quels dans le code traduit et que plusieurs des langages proposés, Pascal ou Fortran par exemple, refusent les lettres accentuées. Ils disent ce qu'ils contiennent : colisParPalette plutôt que c, une majuscule marquant chaque nouveau mot.
Le même programme en Python, pour situer la suite du parcours. Python, lui, sépare les mots d'un nom par un tiret bas, que Flowgorithm refuse :
Python n'a pas de forme Declare : une variable y naît à sa première affectation.
L'opérateur saisit 12 puis 40, mais les deux formes Input ont été échangées : la première lit colisParPalette. Que vaut totalColis ?
Exécuter et suivre
Flowgorithm exécute un programme de deux façons : en continu (Run), du début à la fin, ou pas à pas (Step), une forme à chaque action. En pas à pas, le logiciel surligne la forme en cours. Deux fenêtres à part, présentées au chapitre précédent, suivent l'exécution : la console (touche F10) reçoit les saisies et les sorties ; la fenêtre des variables (touche F9) montre le contenu de chaque variable à cet instant.
Les organigrammes de ce cours s'exécutent de la même façon, directement sur la page : le bouton « Exécuter » déroule tout, le bouton « Pas à pas » avance d'une forme. Dérouler le programme des palettes pas à pas avec les saisies 12 et 40 donne :
| Forme exécutée | Console | Variables après la forme |
|---|---|---|
| Declare | palettes, colisParPalette, totalColis existent, sans valeur | |
| Input palettes | saisie 12 | palettes = 12 |
| Input colisParPalette | saisie 40 | colisParPalette = 40 |
| Assign | totalColis = 480 | |
| Output | Colis à expédier : 480 | inchangées |
Recommencer ensuite avec d'autres saisies, par exemple 7 palettes : la valeur de totalColis suit, sans qu'aucune forme ne change. C'est tout l'intérêt d'un programme : le raisonnement est écrit une fois, les données changent.
Chaque variable y porte la couleur de son type : les entiers (Integer) en bleu, les réels (Real) en violet, les textes (String) en rouge, les booléens (Boolean) en bleu-vert. Dans le logiciel, c'est l'en-tête de la variable qui est coloré ; sur la page, c'est sa valeur. Une couleur inattendue signale un type mal choisi avant même que le résultat soit faux.
Deux règles se voient dans cette fenêtre.
- Une variable déclarée existe, mais n'a pas de valeur tant qu'une forme Input ou Assign ne lui en a pas donné. Sur la page, elle s'affiche avec un point d'interrogation. S'en servir dans un calcul ou une sortie avant ce moment est une erreur qui arrête l'exécution.
- Une variable non déclarée n'existe pas du tout. L'utiliser est aussi une erreur qui arrête l'exécution.
La surface d'une zone de stockage. Exécuter pas à pas : juste après la forme Declare, les trois variables existent et aucune n'a encore de valeur.
La seconde règle se constate sur la figure suivante : c'est le programme précédent, surface en moins dans la forme Declare.
La même surface, mais surface ne figure plus dans la forme Declare. Exécuter : aucune surface n'est affichée, et le message nomme la variable fautive.
L'exécution s'arrête sur l'affectation, avant la sortie : aucune ligne n'est affichée, et la console ne montre que les deux saisies, 42 et 18. Sur la page, le message est : « La variable surface n'est pas déclarée. Une forme Declare doit la créer avant tout usage. » Le logiciel affiche le sien, dans la langue de son interface.
Cette exigence n'est pas une formalité. Sans déclaration, une faute de frappe à gauche d'une affectation crée sans rien dire une seconde variable : le résultat part dans stok, et stock garde son ancienne valeur. C'est ce qui arrive en Python, où le programme tourne et donne un résultat faux. Flowgorithm refuse stok, que la forme Declare ne connaît pas, et l'erreur se voit tout de suite, sur la forme qui la contient.
Déclarer les variables qu'on lit et oublier celle qu'on calcule. La correction tient en un mot : ajouter surface à la liste de la forme Declare. Le réflexe à prendre est de relire la forme Declare en se demandant, pour chaque nom écrit ailleurs, s'il y figure.
1.Dans la fenêtre des variables, une variable apparaît en violet. De quel type est-elle ?
2.Une variable est déclarée, mais aucune forme ne lui a donné de valeur. Que se passe-t-il si une affectation l'utilise ?
3.Une affectation range un résultat dans surface, mais surface n'apparaît dans aucune forme Declare. Que se passe-t-il ?
L'ordre compte
Un magasinier saisit le stock d'une référence en début de journée, puis le nombre d'articles sortis. Le programme doit afficher le stock restant. Avec les saisies 350 et 125, la bonne version (lire, lire, calculer, afficher) affiche Stock restant : 225. Voici deux versions où seules deux formes ont été échangées, l'une et l'autre exécutables.
Afficher avant de calculer. Exécuter pas à pas : la console affiche le stock de départ, puis la fenêtre des variables montre le stock mis à jour, trop tard.
Cette version affiche Stock restant : 350, alors que stock vaut 225 à la fin. Aucune erreur ne s'affiche : le programme tourne, et le résultat est faux. C'est l'erreur la plus dangereuse, parce que rien ne la signale.
La seconde version échange la lecture des sorties et le calcul.
Calculer avant d'avoir lu. Exécuter : la seconde saisie n'est même pas demandée, la console ne montre que la première, et l'exécution s'arrête sur l'affectation.
Au moment du calcul, sorties existe mais n'a encore reçu aucune valeur : l'exécution s'arrête sur l'affectation, et aucune ligne n'est affichée. Sur la page, le message le dit mot pour mot : « La variable sorties est déclarée mais n'a encore reçu aucune valeur. » Cette erreur-là, au moins, se voit tout de suite.
À retenir. Une valeur doit être lue ou calculée avant d'être utilisée, et un résultat calculé avant d'être affiché. L'ordre d'un programme linéaire suit presque toujours la même trame : déclarer, lire, calculer, afficher.
1.Un programme lit stock, puis sorties, affiche stock, et calcule seulement ensuite stock = stock - sorties. Qu'affiche-t-il ?
2.Quelles formes suffisent à construire un programme linéaire qui lit deux mesures et affiche leur produit ?
Fil rouge : la cuve de traitement
Une station de traitement d'eau exploite plusieurs cuves cylindriques. Ce fil rouge construit, chapitre après chapitre, le programme qui les surveille. Première étape : l'opérateur saisit le nom d'une cuve et son volume actuel en litres, et le programme affiche un relevé qui reprend les deux.
- Entrées : le nom de la cuve, un texte ; le volume actuel, un nombre entier de litres.
- Sortie : une ligne qui assemble les deux.
Étape 1 du fil rouge. Deux formes Declare, car les deux variables n'ont pas le même type. Exécuter pas à pas et comparer les couleurs de nomCuve et de volumeLitres dans la fenêtre des variables.
Avec les saisies Cuve A et 21000, le programme affiche Relevé : Cuve A contient 21000 litres. Les espaces font partie des textes entre guillemets : sans l'espace après « contient », le nombre serait collé au mot. Le chapitre suivant ajoute le rayon et la hauteur de la cuve, pour calculer sa capacité et son taux de remplissage.
Mettre en pratique
Pour une pompe de relevage, donner la forme Flowgorithm de chaque instruction : créer les variables debit et minutes ; demander le débit à l'opérateur ; ranger debit * minutes dans volume ; montrer le volume à l'écran ; décider d'arrêter la pompe si le volume dépasse une limite.
- Créer les variables : Declare, qui fixe aussi leur type.
- Demander le débit : Input, puisque la valeur vient du clavier.
- Ranger le produit : Assign, un calcul dont le résultat va dans une variable.
- Montrer le volume : Output.
- Décider selon une limite : If, qui ouvre deux chemins.
La forme se choisit d'après ce que fait l'instruction, jamais d'après les mots qu'elle contient. « Demander » et « montrer » parlent tous deux de l'écran, mais l'un fait entrer une valeur, l'autre la fait sortir.
Une pompe de débit constant, en litres par minute, fonctionne pendant une durée saisie.
L'opérateur saisit 35 puis 20. Qu'affiche la console, et que contient la fenêtre des variables à la fin ?
Les saisies se rangent dans l'ordre des formes Input : 35 dans debit, 20 dans minutes. L'affectation range leur produit dans volume. Les deux sorties s'exécutent ensuite, dans l'ordre :
- Durée : 20 min
- Volume pompé : 700 litres
À la fin, la fenêtre des variables montre debit = 35, minutes = 20 et volume = 700, tous trois en bleu, puisque ce sont des entiers. Une sortie n'efface ni ne modifie aucune variable : elle ne fait que lire.
La version fautive. Suivre niveau forme après forme et prévoir les deux lignes affichées avant de déplier la réponse.
Un bac reçoit un apport d'eau. Le programme ci-dessus doit afficher le niveau avant l'apport, puis le niveau après. Avec les saisies 1200 et 350, il affiche deux fois la même valeur. Quelle forme est mal placée ?
L'affectation écrase l'ancienne valeur de niveau avant la première sortie. Les deux sorties lisent donc la même variable, qui vaut déjà 1550 : la console affiche Ancien niveau : 1550 puis Nouveau niveau : 1550.
La correction consiste à placer la sortie « Ancien niveau » au-dessus de l'affectation :
La version corrigée : elle affiche 1200, puis 1550. Exécuter pas à pas pour voir niveau changer entre les deux sorties.
Afficher avant de calculer était l'erreur du stock ; c'est ici la solution. La règle n'est donc pas « toujours afficher à la fin », mais : chaque forme doit trouver les variables dans l'état qu'elle attend.
Chapitre révisé en octobre 2026 · Une erreur dans ce chapitre ?
Dans la bibliothèque d'exercices
Reconnaître les formes, lire un organigramme de haut en bas, suivre une exécution.
- Reconnaître les formesNiveau 1
- Suivre les flèchesNiveau 2
- Ce que l'ordre changeNiveau 2
- Prévoir la consoleNiveau 2
- Le coût d'une consommation d'énergieNiveau 3
- Construire le stock du soir d'un magasinNiveau 1
- Construire le prix d'une commande de piècesNiveau 2