Au Pied Levé - À Main Levée

■ ■ ■ SOMMAIRE DU BILLET ■ ■ ■

1. L’Algorithmique
2. L’Algorithme
3. L’Algorigramme
4. Le Logigramme
5. Exercice
   
   1. Représentation en Pseudocode
   2. Représentation par un Algorigramme « Norme ISO 5807 »
   3. Représentation en Langage Pascal
   4. Représentation par un Arbre Programmatique (Programmation Structurée)
   5. Représentation par un algorigramme LCP
   6. Représentation LCP en codage de gestion (SGBD Informix)
   7. Représentation par un algorigramme CORIG
6. Liens
7. Post-scriptum
   
   • Forum Algorithmes et structures de données
   • Forum COBOL

Ce billet revisite la définition des concepts Algorithmique, Algorithme, et Algorigramme en prélude à un exercice étudiant différentes façons codées et visuelles de représenter un même algorithme.

Les différentes représentations visuelles d'un Algorithme se réfèrent aux symbolismes abordés dans le billet :

Divagations méthodologiques

■ § 1. L’Algorithmique

L’Algorithmique, c’est l’étude et la production de règles et de techniques pour concevoir des solutions à des problèmes sous la forme d’un enchainement rigoureux d’opérations à effectuer. Ces solutions exprimées dans un langage descriptif ou représentées graphiquement à l’aide de symboles sont des algorithmes.

Apprendre l’algorithmique, c’est apprendre à structurer logiquement un programme en devenir.

Si l’on compare un programme à une dissertation, l’algorithme serait le plan, une fois mis de côté la rédaction et l’orthographe.

De même qu’un plan diffère d’une dissertation classique à une dissertation juridique, les règles et techniques algorithmiques diffèrent selon le type de problématique. La logique adoptée peut être combinatoire ou séquentielle :

• La logique combinatoire raisonne selon la règle des trois unités : unité d’action, unité de temps et unité de lieu. Les résultats sont fonction et seulement fonction des données traitées dans l'instant.
  
  L’algorithmique formalise ce raisonnement.
  
  
• La logique séquentielle imagine plusieurs actions s’exécutant successivement, chaque action étant traitée en logique combinatoire. Les résultats ne dépendent pas seulement des données traitées dans l'instant mais aussi des données traitées précédemment.
  
  L’Algorithmique séquentielle ou logique séquentielle correspond à la conception d’une succession d’étapes appelées sous-états dont chacun est en interaction avec les sous-états qui le précèdent. L’algorithmique séquentielle conçoit, construit cette interdépendance entre les sous-états.
  
  Sans formalisme particulier, l’algorithmique séquentielle conçoit, construit cette interdépendance entre les sous-états.
  
  En clair, il s’agit d’être créatif face à la spécificité de la problématique.

Les règles et techniques algorithmiques diffèrent également selon la méthodologie de programmation adoptée. Si l’on excepte la norme ISO 5807 qui officialise en février 1975, le symbolisme de la programmation dite sauvage des débuts de l’informatique, les trois principales méthodologies de programmation sont apparues au début des années 1970 :

1. Norme ISO 5807 (méthode sauvage des années 60)
2. CORIG - COnception et Réalisation de l’Informatique de Gestion
3. LCP - Logique de Construction de Programme
4. PS - Programmation Structurée (Arbre Programmatique)

---

■ § 2. L’Algorithme

L’Algorithme décrit la manière dont un système réalise une tâche, soit à l’aide d’un pseudo-langage, soit en programmant une suite ordonnée d’instructions propres à un langage. Le terme d’algorithme est généralement perçu à tort comme un synonyme de programme

C’est le fil d’Ariane reliant l’énoncé d’une problématique à sa solution. On peut donc dire qu’un algorithme transforme un problème en solution. En termes plus appropriés, l’Algorithme se réfère au Fichier Logique d’Entrée (FLE) pour créer le Fichier Logique de Sortie (FLS).

Le FLE est une sélection d’attributs - d’une ou plusieurs tables BDD - dont le programme a besoin pour résoudre une problématique. À ces attributs peuvent s’ajouter d’autres informations, comme des totalisations, provenant de requêtes SQL (Programmes d’édition).

Il arrive cependant que le FLE, tel qu’il est constitué, mène la réflexion dans une impasse. L’algorithme d’équivalence ne peut pas s’obtenir entre l’état des entrées et l’état des sorties.

C’est le signe d’un FLE inadéquat, qui nécessite d’être enrichi de nouveaux attributs.

C’est le signe que la problématique ne peut être résolue directement par une réflexion ayant recours à une logique combinatoire mais indirectement par une réflexion ayant recours à une logique séquentielle.

Exemples :

[TUTORIEL] Imprimer des numéros de table en piles

[TUTORIEL] Ordre de passage d'une épreuve de concours équestre

[TUTORIEL] Homogénéiser la répartition d'un tableau

Le FLE décrit en quelque sorte l’énoncé de la problématique et le FLS sa solution.

Concrètement, l'Algorihme, c’est l’ébauche d’un programme exprimée en pseudocode et/ou décrit visuellement par un algorigramme. Bien qu’ébauche, l’algorithme interprète une suite exhaustive de tâches (conditions-actions) ordonnée logiquement.

Indépendant de tout langage de programmation, l’algorithme permet de visualiser, de modéliser, de structurer le programme à développer.

L’Algorithme doit être :

• Lisible, l'algorithme doit être compréhensible même par un non-informaticien.
• Indépendant, l'algorithme doit pouvoir être traduit en n'importe quel langage de programmation, il ne doit donc pas faire appel à des notions techniques relatives à un langage particulier ou bien à un système d'exploitation donné.
• Précis, ses éléments ne doivent pas porter à confusion.
• Concis, un algorithme ne doit pas dépasser une page. Si c'est le cas, il faut décomposer le problème en plusieurs sous-problèmes.
• Structuré, un algorithme doit être composé de différentes parties facilement identifiables.

Un algorithme peut prendre 3 formes :

1. Forme Pseudocode
   
   L’Algorithme a alors une structure linéaire comme un programme. Il décrit une démarche conceptuelle en termes simples dans un langage naturel (pseudo langage) ou dans un langage de programmation purement conventionnel (pseudocode), exempt de toute contrainte syntaxique spécifique d’un langage.
   Purement conventionnel, un pseudocode est susceptible de varier légèrement d’un livre (ou d’un enseignant) à un autre.
   
   
2. Forme Algorigramme
   
   L’Algorigramme (organigramme, logigramme, ordinogramme, diagramme) est la représentation graphique (composée de symboles méthodologiques) d’une démarche conceptuelle logique.
   
   L’Algorigramme se construit en se conformant à une méthodologie de programmation.
   
   Ce n’est pas le cas en ce qui concerne le tutoriel Introduction aux algorigrammes dont la symbolique se réfère à la norme ISO 5807 du 15 février 1985. Les symboles graphiques de cette norme datent en réalité des années 1960 et sont associés à la méthode dite sauvage de l’époque.
   
   Autrement dit, en ignorant les méthodologies de programmation, l’algorithmique stagne depuis plus d’un demi-siècle.
   
   
3. Forme mentale
   
   Les développeurs expérimentés peuvent se passer d’exprimer concrètement l’algorithme sensé précéder la programmation. L’algorithme n’en existe pas moins mentalement. La réflexion reste cependant gouvernée par une méthode de programmation, laquelle procède soit par conditions, soit par traitements.
   
   Penser par conditions
   
   Une condition n’est pas une entité, un objet que l’on peut nommer, c’est une question que l’on ne peut donc pas visualiser mentalement et qui ne permet en rien de structurer globalement sa démarche de développement.
   
   Penser par conditions implique une progression séquentielle. Structurer globalement sa démarche équivaudrait à prévoir tous les coups d’une partie d’échecs jusqu’au mat, aussi bien ses propres coups que ceux de l’adversaire.
   
   Penser par traitements
   
   L’objet d’un traitement est une entité qui s’identifie, le programme lui-même, un département, une commune, une personne, une commande, une ligne de commande, une facture, etc.
   
   À un traitement sont associés un Début-de-Traitement et une Fin-de-traitement.
   
   Il est mentalement possible de visualiser des traitements, donc de structurer sa démarche de développement et par suite son programme.
   
   Seule la méthode de programmation LCP procède par traitements. Dans certains cas bien particuliers, il est toutefois possible de lui associer les principes de la méthode CORIG.

---

■ § 3. L’Algorigramme (logigramme, organigramme, ordinogramme)

Quatre termes sont utilisés pour nommer la représentation graphique d’une structure : organigramme, algorigramme, logigramme, ordinogramme. Certains de ces termes peuvent être associés à une symbolique qui leur est propre, ce qui permet de les différencier. Une décomposition au niveau de l’instruction n’a rien à voir avec une décomposition au niveau logique des traitements. Cette distinction n’a rien d’officiel, c’est simplement le résultat d’une réflexion personnelle sur le sujet. Malgré cette distinction, l’emploi du terme Algorigramme s’impose.

Le terme Algorigramme, ayant la même racine que le terme algorithme, sous-tend l’idée d’une représentation graphique de l’algorithme assimilé à tort au programme, donc au codage.

L’algorigramme en tant que pseudo-langage visuel, recourt à une symbolique normalisée.

Les symboles normalisés datent des années 60 et de la programmation dite "sauvage". Ces symboles représentent graphiquement les instructions d’un pseudo-langage ou d’un langage. Cette symbolique sans doute normalisée mais néanmoins archaïque n’est finalement qu’un pseudo-langage visuel. C'est une représentation graphique au niveau de l’instruction digne des Shadocks et impossible à utiliser concrètement... sans normographe en plastique (orange) ou un logiciel graphique spécifique.

Norme ISO 5807 : Introduction aux algorigrammes

L’Algorigramme est sensé précéder le codage et non l’inverse. Cela dit, l’algorigramme construit à partir d’un programme déjà codé ne devrait pas être différent de l’algorigramme qui aurait dû précéder la programmation. Encore faut-il que la méthode de programmation ayant inspiré le codage corresponde à la réflexion qui inspire la construction à postériori de l’algorigramme.

La représentation graphique du raisonnement doit être indépendante du langage, de ses spécificités, et doit permettre d’appréhender aisément les fonctionnalités du programme. Représenter graphiquement son raisonnement n’est pas la même chose que représenter graphiquement son codage.

On ne construit pas un algorigramme en fonction des instructions du langage que l’on utilise. C’est à la programmation d’interpréter et de traduire l’algorigramme. L’algorigramme reste le même, quelque soient les instructions qu’offre le langage, « IF THEN ELSE », « FOR », « WHILE », « GO TO », etc.

---

■ § 4. Le Logigramme

Le Logigramme, autre appellation de l’algorigramme dit bien ce qu’il veut dire, à savoir que c’est une représentation graphique de la logique, donc du raisonnement. Il appartient ensuite au codage de concrétiser cette logique à l’aide d’instructions. La décomposition du logigramme devrait rester au niveau logique des traitements sans descendre jusqu’à l’instruction. Tout dépend de la capacité d’abstraction du programmeur.

Réaliser un logigramme suppose le recours à un symbolisme qui dépend de la méthode de programmation utilisée, si tant est qu’il y en ait une :

• Norme ISO 5807 (1985)
  
  
• Méthode PS (Programmation Structurée et son Arbre programmatique – Marie-Thérèse Bertini et Yves Tallineau, 1978)
  
  
• Méthode LCP (Logique de Construction de Programmes – Jean-Dominique Warnier, 1970-71)
  
  
• Méthode CORIG (COnception et Réalisation de l'Informatique de Gestion – Robert Mallet, 1967-68)

Le terme Logigramme est plus adapté pour définir la représentation graphique de l’approche logique d’un processus correspondant à un raisonnement par traitements. Il structure visuellement, à l’aide des symboles de deux structures types (répétitive et alternative), les étapes logiques (traitements) d’un processus, d’un programme.

Les deux structures types de la symbolique LCP peuvent se combiner pour former des structures dites complexes pouvant adopter deux formes de hiérarchie, simple ou complexe :

Les deux structures types : répétitive et alternative

• Structure répétitive (ou itérative)
  
  Pour représenter la structure répétitive dans l’algorigramme, on place un branchement conditionnel à la fin de l’ensemble répétitif.
  
  

                 ┌─────────────┐
                 │    D-PROG   │
                 └──────┬──────┘
                        │◄─────────┐
                 ┌──────┴──────┐   │
                 │   T-ARTICLE │   │
                 └──────┬──────┘   │
                        ●──────────┘
                 ┌──────┴──────┐
                 │    F-PROG   │
                 └─────────────┘
  

• Structure alternative
  
  Pour réaliser une structure alternative, on doit programmer deux actions alors que seulement l’une d’entre elles est exécutée.
  
  

                 ┌─────────────┐
                 │    D-PROG   │
                 └──────┬──────┘
              ┌─────────●─────────┐
       ┌──────┴──────┐     ┌──────┴──────┐
       │  T-ARTICLE  │     │  T-ARTICLE  │
       └─────┬───────┘     └─────┬───────┘
             └──────────┬────────┘
                 ┌──────┴──────┐
                 │    F-PROG   │
                 └─────────────┘
  

Les deux structures types de la symbolique LCP peuvent se combiner pour former des structures dites complexes pouvant adopter deux formes de hiérarchie, simple ou complexe :

• Structure répétitive complexe
  
  Une Structure Répétitive Complexe est un ensemble dans lequel on trouve plusieurs sous-ensembles de Structure Répétitive Simple.
  

               ┌─────────────┐
           010 │    D-PROG   │
               └──────┬──────┘
                      │◄────────────────┐
               ┌──────┴──────┐          │
           020 │  D-CLIENT   │          │
               └──────┬──────┘          │
                      │◄───────────┐    │
               ┌──────┴──────┐     │    │
           030 │  T-COMMANDE │     │    │
               └──────┬──────┘     │    │
                      ●────────────┘    │
               ┌──────┴──────┐          │
           040 │  INTER-21   │          │
               └──────┬──────┘          │
                      │◄───────────┐    │
               ┌──────┴──────┐     │    │
           050 │  T-FACTURE  │     │    │
               └──────┬──────┘     │    │
                      ●────────────┘    │
               ┌──────┴──────┐          │
           060 │   F-CLIENT  │          │
               └──────┬──────┘          │
                      ●─────────────────┘
               ┌──────┴──────┐
           070 │    F-PROG   │
               └─────────────┘
  

• Structure complexe mixte
  
  Un ensemble de données pris comme Référentiel comportant à son premier Niveau de subdivision plusieurs Structures simples, les unes Répétitives, les autres Alternatives est dit de Structure complexe mixte.
  
  

                 ┌─────────────┐
                 │    D-PROG   │
                 └──────┬──────┘
                        │◄──────────────────┐
                 ┌──────┴──────┐            │
                 │  D-ARTICLE  │            │
                 └──────┬──────┘            │
              ┌─────────●─────────┐         │
       ┌──────┴──────┐     ┌──────┴──────┐  │
       │  T-ARTICLE  │     │  T-ARTICLE  │  │
       └─────┬───────┘     └─────┬───────┘  │
             └──────────┬────────┘          │
                 ┌──────┴──────┐            │
                 │  F-ARTICLE  │            │
                 └──────┬──────┘            │
                        ●───────────────────┘
                 ┌──────┴──────┐
                 │    F-PROG   │
                 └─────────────┘
  

---

■ § 5. Exercice

Faire deviner un nombre (entre 1 et 100, choisi préalablement par vous) par votre programme, en moins de coups possible.

Parmi les algorithmes imaginables, le plus simple consiste à procéder par dichotomie, c'est-à-dire que le programme va à chaque moment proposer comme nombre celui qui se trouve juste au milieu des deux extrêmes possibles.

Par exemple, au tout début, les deux extrêmes étant 1 et 100, il proposera 50.

NB : Une variante plus divertissante du programme consiste à lui faire choisir au début un nombre aléatoire entre 1 et 100, différent bien sûr du nombre choisi. Ainsi les séquences de recherche sont-elles plus variées qu’avec un départ systématique à 50…

Imaginons que vous ayez pensé au nombre 23.

Quand le programme demandera si c’est 50 (son tout premier choix), vous lui répondrez (honnêtement) « Non, 50 est trop grand. »

À ce moment-là, le programme est assuré d’une chose : les extrêmes possibles sont dorénavant 1 et 49, au lieu de 1 et 100.

Il proposera alors le nombre juste au milieu de 1 et 49 : 25.

Et ainsi de suite.

Source :

Cet exercice, extrait d’un document « Bases de Programmation » du Pr. Éric Kirsch (1998-1999), fait l’objet dans ce document d’une analyse organique comparative :

• En Pseudocode,
• Par un Arbre Programmatique (Programmation Structurée),
• Par un Algorigramme Norme ISO 5807,
• En Langage Pascal

À ces différentes représentations d’un algorithme, j’en ai ajouté trois autres :

• Par un Algorigramme LCP (Logique de Construction de Programme)
• En codage de gestion (SGBD Informix)
• Par un Algorigramme CORIG

---

■ § 5.1. Représentation en Pseudocode

Conventions :

• Le symbolisme <texte> signifie « remplacer par texte ».
• Le symbolisme [texte] signifie « texte est optionnel ».

Désignation	Pseudocode conventionnel
Définition	Définir <nom> (<paramètres>)
Affectation	<variable> = opération
Entrées / Sorties	Lire (<paramètres>) ou Écrire (<paramètres>)
Itérative	Pour <variable> = <valeur> jusqu’à <valeur> [par pas de <valeur>] : ........<suite de traitements à exécuter> Fin du « Pour »
« Tant que »	Tant que <condition> : ........<suite de traitements à exécuter> Fin du « Tant que »
« Jusqu’à ce que »	Répéter : ........<suite de traitements> Jusqu’à ce que <condition>
Condition simple	Si <condition> : ........<suite de traitements> Fin du « Si »
Alternative	Si <condition> : ........<suite de traitements> ; Sinon : ........<suite de traitements> ; Fin du « Si »
« Multiple »	Quand <condition1> : ........<suite de traitements 1> ; Quand <condition2> : ........<suite de traitements 2> ; Etc. ; Autrement : ........<suite de traitements> Fin de la « Multiple »

L’exercice en Pseudocode

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Écrire « Pensez à un nombre SVP. Êtes-vous prêt ?»
Lire réponse
Inférieur = 0
Supérieur = 100
Compteur = 0
Proposition = 50

Répéter
    Compteur = compteur + 1
Écrire « Je propose », proposition
Écrire « Est-il trop grand, trop petit, ou exact ? »
Entrer réponse
Si réponse = ‘p’, inférieur = proposition + 1
Si réponse = ‘g’, supérieur = proposition - 1
Proposition = valeur entière de (inférieur + supérieur) / 2
Jusqu’à ce que réponse = ‘e’

---

■ § 5.2. Représentation en Langage Pascal

Attention ! Cette version comporte la variante plus divertissante du programme qui consiste à lui faire choisir au début, un nombre aléatoire entre 1 et 100. Ainsi les séquences de recherche sont-elles plus variées qu’avec un départ systématique à 50…

Le programme y perd en rapidité (il lui faut un coup en plus statistiquement, pour trouver le résultat), mais on y gagne un peu en distraction…
De plus, sont ajoutés quelques contrôles sur les réponses introduites.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
program nbr1;
uses crt;
var
  nombre, bi, bs, ctr : integer;
  reponse : string[1];
begin
clrscr;
randomize;
writeln ('Veuillez songer à un entier entre 1 et 100 SVP.');
writeln ('Prêt ? Alors tapez ''enter'' SVP...');
readln (reponse);
writeln;
bi := 1;
bs := 100;
ctr := 0;
nombre := random (bs - bi + 1) + bi - 1;
repeat
    ctr := ctr + 1;
    writeln (ctr, ') Je propose ', nombre, '.');
    writeln ('Est-il trop (p)etit, trop (g)rand, ou (e)xact ?');
    repeat
        readln (reponse);
        if (reponse <> 'p') and (reponse <> 'g') and (reponse <> 'e') then begin
            writeln ('(Les touches valides sont : p, g, e)');
            writeln ('Est-il trop (p)etit, trop (g)rand, ou (e)xact ?')
        end
    until (reponse = 'p') or (reponse = 'g') or (reponse = 'e');
    if reponse = 'p' then bi := nombre;
    if reponse = 'g'  then bs := nombre;
    nombre := (bi + bs) div 2
until reponse = 'e';
writeln ('< Fin du programme >');
readln (reponse)
end.

---

■ § 5.3. Représentation par un Algorigramme « Norme ISO 5807 »

Rappel de la Norme ISO 5807 :

La Norme ISO 5807 n’est pas une méthodologie mais seulement un ensemble de symboles de traitement et de logique représentant chacun une instruction ou un ensemble d’instructions :

• Symbole général « traitement » : Opération ou groupe d’opérations sur des données, instructions, etc.
• Fonction de sous-programme : Portion de programme considérée comme une simple opération.
• Entrée - Sortie : Mise à disposition d’une information à traiter ou enregistrement d’une information traitée.
• Préparation : Opération qui détermine partiellement ou complètement la voie à suivre dans un embranchement ou un sous-programme. Symbole également utilisé pour préparer une décision ou mettre un aiguillage en position.
• Embranchement : Exploitation de conditions variables impliquant le choix d'une voie parmi plusieurs. Symbole couramment utilisé pour représenter une décision ou un aiguillage.

Cette norme interprète le codage sans règle particulière de raisonnement, elle ne symbolise pas une réflexion indépendante du langage résultant d’un raisonnement méthodique. C’est comme s’exprimer en mode prose (forme ordinaire du discours qui n’est soumise à aucune règle) plutôt qu’en mode poésie (forme des mots disant plus qu'eux-mêmes par leur choix (sens et sonorités) et leur agencement (rythmes, métrique, figures de style)).

Symbolisme de la norme ISO 5807 :

Voir le billet Divagations méthodologiques
ou
le tutoriel Introduction aux algorigrammes

L’exercice représenté avec les symboles de la norme ISO 5807

---

■ § 5.4. Représentation par un Arbre Programmatique (Programmation Structurée)

Rappel des principes de la Programmation Structurée :

Le programme est structuré en niveaux. Chaque niveau est constitué d'un début, d'une fin, et d'une répétitive (ou d'une alternative) qui se trouve entre le début et la fin. Il est possible d'en avoir plusieurs mais le début et la fin sont uniques.

Le début n'est exécuté qu'une seule fois. La fin est elle aussi exécutée une seule fois. La répétitive se contente d'appeler le niveau inférieur jusqu'à ce que la condition d'arrêt soit vérifiée. Et tout se passe dans des sous-programmes appelés par des PERFORM.

Pour ce qui concerne l'alternative c'est exactement la même chose. Un PERFORM d'une procédure est réalisé dans le cas où la condition est vraie et un PERFORM d'une autre procédure est effectué dans le cas contraire.

Symbolisme de la Programmation Structurée : voir le billet Divagations méthodologiques

L’exercice représenté par un Arbre Programmatique

---

■ § 5.5. Représentation par un algorigramme LCP

Rappel des principes LCP

La méthodologie « LCP » structure le raisonnement selon une démarche par traitements, en analysant la problématique dans une approche top-down (du plus global vers le plus détaillé, par décompositions hiérarchiques successives). La représentation graphique de ce raisonnement adopte une symbolique à base de deux structures types, la structure itérative (répétitive) et la structure alternative. Lorsque les deux structures s’imbriquent, on appelle cet ensemble, une structure complexe.

La construction d’algorigrammes LCP ne se fait qu’en phase d’apprentissage de la méthode, à savoir pendant quatre à six mois selon le degré de résistance à passer d’un mode de réflexion par conditionnements à un mode de réflexion par traitements. Une fois acquis les principes LCP, il n’est plus nécessaire de représenter graphiquement son raisonnement devenu un automatisme imprimé dans la mémoire procédurale. Exemple de structure complexe :

D_PROG et F_PROG peuvent se traduire par exemple par un « WHILE » ou un « FOR »

D_TRAIT, T-MINI, T-MAXI et F-TRAIT peuvent se traduire par un « IF THEN ELSE »

L'exercice représenté par un algorigramme LCP

                             ┌─────────────────────┐
                      D_PROG │      CTR = 0        │
                             │     MINI = 1        │
                             │     MAXI = 100      │
                             │     NBRE = 1<n>100  │
                             │    CHOIX = n        │
                             └──────────┬──────────┘
                                        │◄───────────────────────────────────┐
                             ┌──────────┴──────────┐                         │
                     D_TRAIT │    NBRE :: CHOIX    │                         │
                             └──────────┬──────────┘                         │
                 < ┌────────────────────●────────────────────┐ >             │
        ┌──────────┴──────────┐                   ┌──────────┴──────────┐    │
 T_MINI │  MINI = NBRE + 1    │            T_MAXI │   MAXI = NBRE - 1   │    │
        └──────────┬──────────┘                   └──────────┬──────────┘    │
                   └────────────────────┬────────────────────┘               │
                             ┌──────────┴──────────┐                         │
                     F_TRAIT │      CTR = CTR + 1  │                         │
                             │PRINT ″ CTR : ″, CTR │                         │
                             │PRINT ″MINI : ″, MINI│                         │
                             │PRINT ″MAXI : ″, MAXI│                         │
                             │PRINT "───────────"  │                         │
                             │NBRE = (MINI+MAXI)/2 │                         │
                             │    NBRE :: CHOIX    │                         │
                             └──────────┬──────────┘ <>                      │
                                        ●────────────────────────────────────┘
                             ┌──────────┴──────────┐
                      F_PROG │PRINT "CHOIX: ", NBRE│
                             └─────────────────────┘

---

■ § 5.6. Représentation LCP en codage de gestion (SGBD Informix)

L'exercice représenté en codage de gestion

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
{ D_PROG   } CTR   = 0
             MINI  = 1
             MAXI  = 100
             NBRE  = n
             CHOIX = n
             WHILE NBRE <> CHOIX
                   DO BEGIN
{ D_TRAIT }           IF NBRE < CHOIX
{ T_MINI  }              THEN MINI = NBRE + 1
{ T_MAXI  }              ELSE MAXI = NBRE - 1
{ F_TRAIT }           LET CTR = CTR + 1
                      PRINT ″ CTR : ″, CTR  USING "##&"
                      PRINT ″MINI : ″, MINI USING "##&"
                      PRINT ″MAXI : ″, MAXI USING "##&"
                      PRINT ″───────────"
                      LET NBRE  = (MINI + MAXI) / 2
                      END
{ F_PROG   } PRINT ″CHOIX : ″, NBRE USING "##&"

---

■ § 5.7. Représentation par un algorigramme CORIG

Rappel des principes CORIG :

Les principes CORIG sont simples : il s'agit d'une écriture linéaire des programmes. Ceux-ci sont découpés en sous-fonctions comme avec la méthode des arbres programmatiques mais au lieu d'avoir au début de la partie « instructions » du programme l'appel de chaque sous-fonction de façon hiérarchique (en suivant les niveaux d'imbrications déterminés par la représentation de l'arbre), toutes les sous-fonctions sont écrites en série sous forme de « briques » fonctionnelles. La brique fonctionnelle est constituée de trois parties distinctes :

• une condition d'exécution
• la sous-fonction proprement dite
• le label de fin de l'unité fonctionnelle

En premier lieu c'est la condition d'exécution qui est testée. Si la condition est remplie le programme se poursuit en séquence. Dans le cas où la condition n'est pas vérifiée le programme effectue un saut jusqu'à la fin de l'unité fonctionnelle. Il est très important que ce saut s'effectue à la fin de l'unité courante et non au début de l'unité fonctionnelle suivante car ceci permet que chaque brique fonctionnelle soit indépendante des autres.

L'exercice représenté par un algorigramme CORIG

            ┌─────────────────────┐
     D_PROG │      CTR = 0        │
            │     MINI = 1        │
            │     MAXI = 100      │
            │     NBRE = 1<n>100  │
            │    CHOIX = n        │
            └──────────┬──────────┘
                       │◄─────────────┐
            ┌──────────┴──────────┐   │
    D_TRAII │    NBRE :: CHOIX    │   │
            └──────────┬──────────┘   │
  ┌────────────────────●        <     │
  │         ┌──────────┴──────────┐   │
  │  T_MINI │  MINI = NBRE + 1    │   │
  │         └──────────┬──────────┘   │
  └───────────────────►│              │
  ┌────────────────────●        >     │
  │         ┌──────────┴──────────┐   │
  │  T_MAXI │   MAXI = NBRE - 1   │   │
  │         └──────────┬──────────┘   │
  └───────────────────►│              │
            ┌──────────┴──────────┐   │
    F_TRAIT │      CTR = CTR + 1  │   │
            │PRINT ″ CTR : ″, CTR │   │
            │PRINT ″MINI : ″, MINI│   │
            │PRINT ″MAXI : ″, MAXI│   │
            │PRINT "───────────"  │   │
            │NBRE = (MINI+MAXI)/2 │   │
            │    NBRE :: CHOIX    │   │
            └──────────┬──────────┘   │
                       ●──────────────┘
            ┌──────────┴──────────┐
     F_PROG │PRINT "CHOIX: ", NBRE│
            └─────────────────────┘

---

■ § 6. Liens

• Pseudocode
  
  Langage algtorithmique
  Langage algorithmie
  
  
• Norme ISO 5807 (Février 1985)
  
  Introduction aux algorigrammes
  Tutoriel : Introduction aux algorigrammes
  Guide des organigrammes
  Algorithmie et Programmation
  
  
• Méthode CORIG (COnception et Réalisation de l'Informatique de Gestion – Robert Mallet, 1967-68)
  
  CORIG, histoire d'une méthode en informatique de gestion
  
  
• Méthode PS (Programmation Structurée et son Arbre Programmatique – Marie-Thérèse Bertini et Yves Tallineau, 1978)
  
  Programmation structurée (Kamal Elayouni)
  Arbres programmatiques
  Discussion : Programmation structurée (Wikipédia)
  
  
• Méthode LCP (Logique de Construction de Programmes – Jean-Dominique Warnier, 1970-71)
  
  Méthodologie de programmation LCP (Billet du blog APL-AML)
  La programmation rationnelle (Billet du blog AML-APL, d’après Yves LEROY, Centre de formation CII - janvier 1971)
  Logique de Construction des Programmes (M. Tourneur)
  LCP Warnier (Didier Genevois)
  Jean-Dominique WARNIER (Wikipédia)
  ADELI (Association pour le Développement de la Logique Informatique)

---

■ § 7. Post-scriptum

Hormis mes interventions dans certaines discussions (principalement dans le Forum Algorithmes et structures de données et exceptionnellement dans le Forum COBOL, on ne trouve aucun algorigramme sur le site DVP.

Ci-après, je vous cite les discussions et mes messages comportant des algorigrammes LCP :

§ 7.1. : Forum Algorithmes et structures de données

Discussion : Homogénéiser la répartition d'un tableau

• C’est juste un problème d’intervalles

Discussion : Algorithme pour établir un ordre de passage

• Précisions
• Pas d'algorithme, juste 3 colonnes et 2 tris
• ATTENTION ! Jeu d’essai incomplet
• Version pédagogique avec un jeu d’essai plus complet
• N_ORDRE = Concaténation de N_CAVALIER et N_CHEVAL
• Les étapes de ma réflexion
• Algorigrammes et Algorithmes
• N_CAVALIER et N_CHEVAL ne sont pas des identifiants
• Règles de déroulement d’une épreuve équestre
• Comprendre les critères de tri
• La logique séquentielle
• Penser out of the box
• Penser out of the box (suite)
• Penser out of the box (suite et fin)
• Relation utilisateur – informaticien
• PHILOSOPHIE vs TECHNICITÉ

Discussion : Un exercice d’algorithmique avec une table… circulaire

• Un exercice d’algorithmique avec une table… circulaire

Discussion : Écrire une base de programme

• Structurer sa réflexion

Discussion : Comparer un élément d'un tableau à tous les autres

• Proposition de logigramme (à vérifier)

Discussion : Sujet d’algorithmie original : imprimer des numéros de table en piles

• Sujet d’algorithmie original : imprimer des numéros de table en piles
• Le sujet n’a besoin que de deux tables et quatre attributs
• Simuler pour comprendre
• Pile et Page n’existent pas dans la BDD
• Déterminer post-it à partir de pile et page
• Suite de mon anecdote, pour patienter
• Récapitulatif des difficultés à résoudre
• Corrigé de mon Devoir de vacances

---

Discussion : Logigramme et représentation

• Symbolique LCP (Logique de Construction des Programmes)

---

Discussion : Exercice sur l'exponentiation rapide

• Ça va sans dire, mais ça va mieux en le visualisant

---

Discussion : 'Tit PB d'algo intéressant : Calendrier d'un championnat de football africain

• 'Tit PB d'algo intéressant : Calendrier d'un championnat de football africain
• Sous-forum Math
• Bonjour pseudocode,
• Bonjour pseudocode,
• Exemple pour 7 ou 8 équipes
• Besoin de précisions
• Deux objectifs : créer table MATCHS puis ecploiter la BDD
• Bonsoir,
• Retour à la case départ
• Synthèse (1ère partie)
• Synthèse (2ème partie)

---

§ 7.2. : Forum COBOL

Discussion : Une mise à jour 0,1 pour 0,n

• Transposition du programme COBOL en Base de Données et SQL

---