• Objet : Méthode d'élaboration d'un algorithme
• Niveau requis :

  débutant, avisé
• Commentaires : Pour les problèmes complexes, on divise le problème
  et on cherche un algorithme simple (procédure)
  pour chaque élément du programme ou algorithme globale

Une procédure est un morceau de programme en langage formel utilisable dans un gros programme.

Elle contient donc un petit algorithme.

Comment présenter une procédure (son petit algorithme) pour qu'elle soit réutilisable par n'importe qui et dans n'importe quel langage de programmation ?

La méthode suivante répond à ces deux exigences. Et décrit une méthode pour élaborer ces petits algorithmes que l'on appelle procédure.

La méthode d'approche d'un problème d'algorithme doit se décomposer en six étapes ; le résultat obtenu, de l'analyse du problème, c'est la procédure. La dernière étape de cette méthode donne l'algorithme de la procédure.

Imaginons un client, un jury, n'importe qui cherche une solution générale, codable en n'importe quel langage de programmation, car ce qu'on a comme programme pour une application informatique, n'est pas super. Par ce qu'on est un super concepteur, on a une idée de comment faire quelque chose, ou comment faire mieux quelque chose. Mais on est pas tout seul. Il faut être compris par les autres, et aussi permettre à son idée d'être choisie. Plus elle sera claire, parlante pour ceux des autres branches, électroniciens, clients, etc, etc, mieux cela voudra.

Pour ce faire, il faut savoir exposé ce qu'est le problème à résoudre AVANT de donner la solution qui permet de le résoudre.

Prenons pour exemple, une procédure qui compte les voyelles d'un mot comporte trois étapes.

Il s'agit distinguer l'exposé de la procédure de la procédure elle-même.

Les six étapes pour présenter une procédure :

1. poser le problème (la moulinette);
2. définition de la nature (type) des données ;
3. le jeu d'essai ;
4. définition de l'interface (ce que fait dans cette procédure en termes algorithmiques) ;
5. définition en termes algorithmique du programme de test ;
6. la procédure

On cherchera à exprimer la résolution en meta-langage d'une procédure qui permet de retourner le nombre de voyelles contenu dans une phrase.

On partira du principe que cette phrase est arrêtée par un point.

Entrée       |                          | Sortie    
phrase ----> | procédure compte voyelle |----> nombre de voyelles

On définit les types.

• Phrase :

On crée un type phrase pour le type “chaîne de caractère”

chaine = tableau[N] de caractères

chaine : nom de ce nouveau type
tableau : mot clé [N] : taille du tableau ou indice maximal de caractères : nature ou type

Il permet de penser aux cas limites pour définir plus en détail ce qu'il faut faire avec cette procédure.
En tant que débutant, on pose que la condition d'arrêt est donnée. C'est-à-dire on n'envisagera pas le cas où l'utilisateur oublie le point à sa phrase.

  | phrase    |  nombre de voyelles  |
1 |"oiseau."  |   5                  |  
2 | "."       |   0                  |
3 |"kwskwz."  |   0                  |
4 |"oie."     |   3                  |

1) L'utilisateur rentre un mot.
2) Et si l'utilisateur ne rentre que la condition d'arrêt, est-ce que doit contenir la procédure pour que le programme fonctionne ?
3) l'utilisateur est polonais ; pas de voyelle à son mot
4) Il choisit un mot contenant que des voyelles

Quand le problème se compliquera, il pourra y avoir plusieurs interfaces.
Il s'agit là de réécrire ce qu'on a définit précédemment en termes algorithmiques.

Voilà comment le formalisme exige que soit déterminé l'interface de la procédure :

procédure CompteVoyelle(entrée phrase : chaine , sortie nbrVoyelle : entier)
 
// CompteVoyelle : Cette procédure permet de compter les voyelles d'une phrase.
// phrase : c'est la phrase analysée
// nbrVoyelle : nombre de voyelles (a e i o u) d'une phrase

Là encore on définit le QUOI²⁾, et pas encore le COMMENT³⁾.

CONSTANTES
 
N = 43 // taille maximum d'une phrase
STOP = '.' // Caractère terminateur
 
TYPE
chaine = tableau[N] de caractère
 
VARIABLES
Texte : chaine // texte à analyser
nbV : entier // nombre de voyelles du texte
 
PROCÉDURE 
CompteVoyelle
/*On colle là ce qu'on a rédigé précédemment, "la notice" de la procédure*/
 
  début
       écrire ("Donnez votre texte.")
       lire (Texte)
       comptevoyelle(texte , nbV)
  fin

On voit que ce programme de test utilise la notice de la procédure CompteVoyelle est utilise le type chaine avec des variables nommées différemment. (Chacun est maître chez soi !).

C'est le programme que le concepteur lit pour lui-même est vérifié que sa procédure fonctionne.

C'est le programme de la procédure.
On rédige cette fois en termes algorithmiques ce que définissait la notice de la procédure à l'étape n°4, en langage imaginaire. C'est ce programme que le codeur en C ; C# ; C++ ; Pascal ; Ada … lira et traduira dans le langage de programmation qui est le sien.

INTERFACE
procédure CompteVoyelle(entrée phrase : chaine , sortie nbrVoyelle : entier)
 
// CompteVoyelle : Cette procédure permet de compter les voyelles d'une phrase.
// phrase : c'est la phrase analysée
// nbrVoyelle : nombre de voyelles (a e i o u) d'une phrase
 
VARIABLES
 
i : entier
 
  début
 
       i := 1 // indice de parcours
       nbVoyelle := 0 // nombre de voyelle cherché dans la phrase
 
       TQ  phrase[i] <> STOP  faire
 
            // Traiter un caractère
 
              SI ((phrase[1] = 'a') OU (phrase[1] = 'e') OU (phrase[1] = 'i') OU (phrase[1] = 'o')
                  OU (phrase[1] = 'u') OU (phrase[1] = 'y'))
 
                 ALORS
                 nbVoyelle := nbVoyelle + 1
 
               FINSI
 
          i := i + 1
 
       FinTQ