Algorithme Fonctions Et Procedures

Présentation
Il arrive fréquemment d'avoir à utiliser des calculs ou des traitements plusieurs fois dans un
programme à des endroits différents, ou avec des informations variables. A chaque fois on est alors
obligé de répéter la séquence d'instructions qui se rapportent à ces calculs ou traitements, en ne faisant
varier que le paramétrage des informations à traiter.
De la même façon si une application vient à être développée au sein d’un projet par une équipe
d’analyste/programmeur, il faut que chacun puisse travailler sur la partie qui lui a été assigné, avec la
possibilité de pouvoir vérifier la progression de son développement. L'application finale sera la
réunion de chaque partie dont le développement aura été indépendant.
Ceci peut aussi être le cas de traitements identiques dans plusieurs applications.
Pour permettre de résoudre ce type de problème, on doit adopter un mode de programmation

modulaire, en fonction du langage ceci va se traduire à la fois par une programmation structurée (Pas
de GOTO) mais aussi par un découpage adapté, résultat d’un travail d’analyse du problème à
concevoir.
L’ensemble va se traduire techniquement par :
voyons quelques exemples :

des fonctions et procédures en PASCAL
des fonctions en C
des paragraphes en COBOL (récemment fonctions norme ANS2002)
des sous programmes, fonctions et procédures en BASIC
...
Les concepts de ce type de programmation repose sur les théories du GENIE LOGICIEL, qui définit
le niveau d'attention d'un individu à 7 objets (à plus ou moins 2); ce qui sous-entend que l'on devrait
développer des procédures et des fonctions ne comprenant que 7 lignes de code (assez loin des réalités
de la programmation actuelle).
Illustrations
Les modules
Soit l’exercice permettant de traiter successivement les trois points suivants :
1. On veut afficher l’alphabet de façon croissante.

2. On veut afficher l’alphabet de façon décroissante.
3. On veut afficher la table des codes ASCII (n°, caractère) pour les codes de 32 à 255.
On note bien trois traitements indépendants les uns des autres. On peut donc envisager de les traiter de
façon individuelle (par exemple en confiant chaque module à une personne différente).
On va obtenir un algorithme principal qui va être le suivant (en adoptant une démarche décomposition
fonctionnelle) :
Début
ALPHABET_CROISANT
ALPHABET_DECROISSANT
CODE_ASCII
Fin
2
Avec l’algorithme des modules suivants (décomposition fonctionnelle) :
Procédure ALPHABET_CROISANT
Variable locale i (caractère)
Début
Pour i de ‘a’ à ‘z’ faire
Écrire (i)
Fin pour i
Fin
Procédure ALPHABET_DECROISANT
Variable locale i (caractère)
Début
Pour i de ‘z’ à ‘a’ (décroissant) faire
Écrire (i) fin pour i
Fin
Procédure CODE_ASCII
Variable locale i (entier)
Fonction ASCII (donnée ENT (entier)) résultat (caractère)
// Fonction intrinsèque qui retourne le caractère ASCII correspondant à ENT
Début
Pour i de 32 à 255 faire
Écrire (i, ASCII (i))
Fin pour
Fin
Observation :
On a la possibilité de recomposer un algorithme global en intégrant le code de chacun des modules au

niveau de l'appel de celui-ci.
3
Visualisation de l'annexe correspondante.
Les Modules sont des parties (logiques) d’un programme qui sont résolues de façon indépendantes. Un
Module se traduit algorithmiquement par une procédure sans paramètre. On note qu’un module est
comparable à un programme c’est à dire qu’il comprend sa partie de code (les instructions à exécuter)
et son environnement (les données qui seront manipulées par le code du module dans la zone décrite
par la clause variable locale qui peut être abrégée en VL).
Les fonctions
Soit les deux exercices indépendants suivants :
On veut calculer la moyenne coefficientée de trois notes pour un groupe de BTS Informatique dont
les coefficients sont 1,1,2, et pour un groupe d’auditeurs CNAM dont les coefficients sont 1,2,3...
On note que le problème du calcul coefficienté est le même pour tous les exercices, et que seuls les
coefficients changent, donc il apparaît plus simple de regrouper (factoriser) les éléments de ce calcul
de moyenne.
Pour calculer une moyenne coefficientée (le résultat), on a besoin de connaître les notes associées à
leurs coefficients respectifs (données).
Les données sont :
N1,N2,N3 (réel) les trois notes

C1,C2,C3 (réel) les trois coefficients
Le résultat est :
MOYENNE (réel) la moyenne coefficientée
Le traitement est :
MOYENNE (N1*C1+N2*C2+N3*C3)/ (C1+C2+C3)
Regroupons cette réflexion au sein d’une structure algorithmique :
fonction MOYENNE(données N1,N2,N3(réel), C1,C2,C3(réel)) résultat(réel)
début
fin
On peut maintenant écrire l’algorithme qui va traiter la moyenne du groupe des BTS informatiques
Lexique
variables :
4
i (entier) indice d’itération
NBETUDIANT (entier) nombre d’étudiant du groupe
NOM,PRENOM (chaîne) nom et prénom d’un étudiant
NOT1,NOT2 (réel) moyenne du premier et second semestre
EXAM (réel)note à l’examen final
MOY (réel) moyenne coefficientée de l’étudiant
Début
Lire (NBETUDIANT)
Pour i de 1 à NBETUDIANT faire
Lire (NOM, PRENOM, NOT1, NOT2, EXAM)
MOY MOYENNE (NOT1, NOT2, EXAM, 1, 1, 2)
Écrire (MOY)
Fin pour i
Fin
Et l'algorithme de l'exercice sur le groupe des auditeurs CNAM
Lexique :
Constantes
COEF1=1 coefficient du partiel

COEF2=2 coefficient du TP
COEF3=3 coefficient de l’examen
Variables
NOM, PRENOM (chaîne) nom et prénom de l’auditeur

PARTIEL (entier) note du partiel
TP (entier) note du TP
EXAM (réel) note à l’examen final
MOYEN (réel) moyenne coefficientée de l’auditeur
Début
Lire (NOM)
Tant que NOM ‘’ faire
Lire (PRENOM, PARTIEL, TP, EXAM)
MOYEN MOYENNE(PARTIEL, TP, EXAM, COEF1, COEF2, COEF3)
Écrire (MOYEN)
Lire (NOM)
5
Fin tant que
Fin
On note que l’approche de la résolution du problème est différente dans les deux cas, mais que rien
n’empêche l’utilisation de la même fonction puisse que le traitement des moyennes est similaire à la
différence des noms d’identificateurs.
Les fonctions sont des parties (logiques) d’un programme qui sont traitées de façon
indépendantes.
Une fonction peut avoir de 0 à N données (en entrée) et elle retourne un seul résultat (en sortie).
Les procédures
Illustration 1
Soit l'exercice suivant :
On veut afficher la table de multiplication du nombre entier N pour des multiplicateurs de 1 à 10
Les données sont :
N (entier) le nombre à multiplier
Le résultat est : Aucun, il s'agit de l'action d'afficher la table de multiplication du N
Le traitement est :
Par exemple si N vaut 7

1x7=7
2 x 7 = 14
:
10 x 7 = 70
Procédure TABLE_MULTIPLICATION (données N (entier))
variable locale i (entier)
Début
pour i de 1 à 10 faire
écrire(i,’ x ‘, N,’ = ‘, i*N)
fin pour i
Fin
Cette procédure possède une donnée (en entrée) et ne fournit aucun résultat, mais une action
d'affichage
On peut écrire l'algorithme d'affichage de la table de multiplication intégrant cette procédure
6
Lexique
variables :
N (entier) le multiplicateur
Début
lire (N)
TABLE_MULTIPLICATION (N)
Fin
Illustration 2
Soit l'exercice suivant :
On veut retourner les valeurs du carré, et de la racine carrée de la constante trigonométrique ¶ (Pi).
Les données sont : aucune donnée (¶ est une constante)
Les résultats sont :
CARRE (réel) le carré de ¶

RACINE (réel) la racine carrée le ¶
Le traitement est :
CARRE = ¶²
RACINE =√¶
Procédure CARRE_RACINE_PI (résultats C, R (réel))
{Liste de fonctions intrinsèques ou prédéfinies}
Fonction carré (donnée X (réel)) résultat (réel)
Retourne le carré de X.
Fonction racine_carrée (donnée X (réel)) résultat (réel)
Retourne la racine carrée de X.
Fonction PI résultat (réel)
Retourne la valeur constante de PI (¶)
Début
C carré(PI)
R racine_carrée(PI)
Fin
donnée et retourne deux résultats
7
On peut écrire l'algorithme utilisant la procédure de calcul
Lexique
variables :
CARRE (réel) le carré de PI
RACINE (réel) la racine carrée de PI
Début
CARRE_RACINE_PI (CARRE,RACINE)
Ecrire(‘PI a pour carré ‘,CARRE,’ et pour racine carrée ‘, RACINE)
Fin
illustration 3.
soit l'exercice suivant :

On veut retourner le résultat de la division d'un nombre à un autre ; dans le cas d'une division par 0 on
retournera un code d'erreur.
Les données sont :

N (réel) le numérateur
D (réel) le diviseur
Les résultats sont :

R (réel) le résultat de la division
ERREUR (booléen) le résultat est-il correct ou non
Le traitement est :
Si D = 0
R=N/C
procédure DIVISION(données N,D(réel) résultats R(réel),ERREUR(booléen))

début
si D = 0
alors
-999999,99999 {contrôle de retour de tous les résultats}
fin si
Fin
données résultats
sortie)
On peut écrire l'algorithme utilisant la procédure de calcul

Lexique
variables :
NOMBR1 (réel) le nombre à diviser

NOMBR2 (réel) le diviseur
RES (réel) le résultat de la division
ERREUR (booléen) gestion de l'erreur de division par 0
Début
Lire(NOMBR1,NOMBR2)
8
DIVISION (NOMBR1,NOMBR2,RES,ERREUR)
Si ERREUR
Alors écrire(‘division par zéro’)
Sinon écrire(RES)
Fin si
Fin
Les procédures sont des parties (logiques) d’un programme qui sont traitées de façon
indépendantes.
Une procédure peut avoir de 0 à N données (en entrée) et elle retourne de 0 à N résultats (en
sortie).
Algorithmie des fonctions et procédures
Généralités
D’un point de vue algorithmique, il existe deux types de fonctions et procédures celles définies dans le
structure du langage (appelée intrinsèques), et celles définies par l’utilisateurs.
Attention toutefois en langage C il n’y a que des fonctions, alors qu’en PASCAL il y a les deux ; mais
cette étape de programmation est indépendante de la conception algorithmique.
Description
Une fonction ou une procédure est constituée sur le même modèle qu'un programme.
Leur rôle est d'effectuer une séquence de travail composée d'un bloc d'instructions, ceci à partir de
données (en entrée de la fonction) et de rendre un ou des résultats en fin d'exécution (en sortie de la
fonction).
Les FONCTIONS (Notation Algorithmique)
Les Fonctions intrinsèques.
En règle générale les langages bien que différents fournissent en standard les mêmes fonctions
intrinsèques.
Ce qui est le cas du carré et de la racine carré d’un nombre.
9
exemple on souhaite calculer le carré et la racine carré d’un nombre.
Hypothèse : on supposera le nombre réel et positif.
Les données du problème.

Le nombre entier NOMBR(réel)
Les résultats du problème.

Le carré du nombre CARRE(réel)
La racine carré du nombre RACINE(réel)
Algorithme
variables :
NOMBR,CARRE,RACINE (réel)
fonction Carré(données X (réel)) résultat (réel)

retourne le carré du nombre X
fonction Racine_Carrée(données X (réel)) résultat (réel)

retourne la racine carré du nombre X
Début
Lire (NOMBR)
Carré(NOMBR)
Racine_carrée(NOMBR)
Ecrire (CARRE,RACINE)
fin
Dans le lexique on définit le profil de la fonction (paramètres données et type du résultat) ainsi que
l’action effectuée.
Dans l’algorithme on peut alors affecter la fonction à une variable résultat.
Les Fonctions utilisateurs
Prenons l’exemple d’une fonction qui effectue la somme de deux entiers, et d’un réel.
Les données du problème (de la fonction).

Les deux nombres entiers A, B
Le nombre réel C
Le résultat du problème (de la fonction).

Le résultat de l’addition des 3 nombres (réel)
Structure algorithmique de la fonction
Fonction ADDITION (données A,B (entier), C (réel) ) résultat (réel)

début fonction
ADDITION
fin fonction
On note que la fonction est composée de deux parties : l’entête, et le corps de la fonction.
Le résultat est impérativement retourné au nom de la fonction.
Voyons l’algorithme du programme utilisant la fonction ADDITION.
10
Algorithme
variables
NB_ENTIER1,NB_ENTIER2 (entier)
NB_REEL,NB_RESULTAT (réel)
début
Lire(NB_ENTIER1,NB_ENTIER2,NB_REEL)
Ecrire (NB_RESULTAT)
Fin
L’entête d’une fonction
composée
du mot clé Fonction

du nom donné par l’utilisateur à la fonction ADDITION
de la liste des données en entrée de la fonction (données A,B(entier),C(réel))
du mot clé résultat
du type du résultat (réel)
Remarque : Il est possible que la fonction n’ait aucune données en entrée.
Le corps de la fonction
composé
d’une zone de déclaration des variables locales à la fonction (absente ici)
de la liste des séquences de travail utile à la fonction ADDITION
toujours retourner le résultat au nom de la fonction
Les PROCEDURES (Notation Algorithmique)
Les procédures intrinsèques.
Au même titre que les fonctions les langages de programmation fournissent en standard des
procédures intrinsèques.
exemple on souhaite afficher le numéro du lecteur, et le chemin d’accès au répertoire où l’on se trouve
dans l’arborescence d’un disque.
Les données du problème.

aucune
Les résultats du problème.

Le numéro du lecteur LECTEUR(entier)
La nom du chemin CHEMIN(chaîne)
Algorithme
variables
LECTEUR (entier)
CHEMIN (chaîne)
procédure RETOURNE_CHEMIN(résultat LECTEUR(entier),CHEMIN(chaîne))
disque
11
début
RETOURNE_CHEMIN(LECTEUR,CHEMIN)
Ecrire (LECTEUR,CHEMIN)
Fin
Les procédures utilisateurs
Illustrations 1 : Prenons l’exemple de l’affichage d’un message à une position déterminée (abscisses,
ordonnées) à l’écran.
Les données du problème (de la procédure).

Les deux coordonnées entières X, Y
Le message à afficher MESSAGE
Le résultat du problème (de la procédure).

Le résultat est une action (vide)
Structure algorithmique de la procédure
Procédure AFFICH_MESSAG (données X,Y (entier),MESSAGE(chaîne))

début procédure
positionner_cruseur(X,Y)
écrire(MESSAGE)
fin procédure
Procédure positionner_cruseur(COLONNE,LIGNE(entier))
On note que la procédure est composée de la même façon qu’une fonction de deux parties : l’entête, et
le corps de la procédure.
Voyons l’algorithme du programme utilisant la procédure AFFICH_MESSAG.
Algorithme
variables
ABSCISSES,ORDONNEE (entier)
CHAINE_A_AFFICHER (chaîne)
début
{exemple 1}
AFFICH_MESSAG (1,24,’Le BTS Informatique c’est super !’)
{exemple 2}
Lire(CHAINE_A_AFFICHER)
AFFICH_MESSAG (1,24, CHAINE_A_AFFICHER)
{exemple 3}
Lire(ABSCISSE,ORDONNEE,CHAINE_A_AFFICHER)
AFFICH_MESSAG (ABSCISSE,ORDONNEE,CHAINE_A_AFFICHER)
fin
Illustrations 2 : écrire une procédure qui inverse deux nombres.
Les données du problème (de la fonction).

12
Le premier nombre N1
le second nombre N2
Les résultats du problème (de la fonction).
Le premier nombre inversé N1

le second nombre inversé N2
remarque : on note qu’il y a deux résultats (variables identiques en entrée, et en sortie)
Les traitements du problème (de la fonction).

On prendra soin de ne pas écraser l’une des valeurs en la stockant temporairement dans une
variable intermédiaire.
Algorithme de la procédure
Procédure INVERSE (Données N1,N2(réel)), résultats N1,N2(réel))

déclaration des variables de la fonction
INTER (réel) variable de stockage intermédiaire locale
début procédure
INTER
N1 N2
N2 INTER
fin procédure
Remarque : autre notation de l'entête ou profil de la procédure, a priori plus simple que comprendre
en prévision de la programmation.
Procédure INVERSE (Données/résultats N1,N2(réel))
Algorithme du programme utilisant la procédure
Algorithme
variables
X,Y (réel)
début
Lire(X,Y)
INVERSE(X,Y)
Ecrire(X,Y)
fin
L’entête d’une procédure
composée
du mot clé Procédure

du nom donné par l’utilisateur à la procédure INVERSE
de la liste des données en entrée de la procédure (données N1,N2 (réel),
de la liste des résultats en sortie de la procédure résultat N1,N2 (réel))
13
Remarque : La liste des données peut être vide ainsi que celle des résultats
Le corps de la procédure
composé
d’une zone de déclaration des variables locales à la procédure INTER (réel)

de la liste des séquences de travail utile à la procédure l’inversion des 2 nombres
CONCLUSION
Les fonctions ont pour rôle de rendre un résultat d’un type informatique standard à partir d’un
traitement pouvant provenir de zéro, un ou plusieurs paramètres.
Structure :
Fonction NOMFONCTION (données liste des paramètres) résultat (type_résultat)

liste des variables locales
début fonction
liste des instructions de la fonction
résultat
fin fonction
Attention : à ne pas oublier de retourner le résultat au nom de la fonction.
ont pour rôle d’appliquer une action sur des données en entrées (si elles existent),
et de fournir des résultats en sorties (si ils existent).
Il existe plusieurs formes de procédures :

Les procédures :
ni donnée en entrée, ni résultat en sortie)

un traitement) standard (module).
données en entrées
le traitement) dépend des données en entrées.
résultats en sorties
le traitement) fournit des résultats en sorties.
données en entrées/ résultats en sorties

fusion des précédentes descriptions.
Structure :
Procédure NOMPROCEDURE (données liste des entrées,résultats liste des sorties)

liste des variables locales
début procédure
liste des instructions de la procédure
fin procédure
14
Toute fonction ou procédure doit être décrite dans l’algorithme
dans le lexique s’il s’agit d’une fonction ou procédure intrinsèque (entête, définition)
en clair s’il s’agit d’une fonction ou procédure utilisateur (entête, et corps)
Remarques de notations algorithmiques
Les procédures
Il arrive assez fréquemment d’avoir dans une procédure des données qui sont aussi les résultats,
l’objectif de la procédure étant la modification de ces données, comme sur l’exemple :
Procédure INVERSE (Données N1,N2(réel)), résultats N1,N2(réel))
On trouve pour des raisons de commodités de traduction une autre écriture des en-têtes de procédures
dans ce cas.
Procédure INVERSE (Données/Résultats N1,N2(réel)))
ou encore
Procédure INVERSE (Données modifiées N1,N2(réel)))
On pourra trouver d'autres notations où les données (à l'exemple de la programmation ! ?) sont

considérées implicites (donc non notifiées), on indiquera uniquement les résultats.
Exemple :
Procédure PROC (X (réel),N(entier)), résultats Y(réel),A(entier))
Les fonctions
On a vu que dans la syntaxe de l’écriture d’une fonction on imposait d’affecter au nom de la fonction
le résultat de celle ci, comme sur l’exemple.

début fonction
ADDITION
fin fonction
On trouve aussi le formalisme suivant

début fonction
retourner (A + B + C)
fin fonction
on indique par la clause retourner() que ce qui se trouve entre les parenthèses sera le résultat de la
fonction.
À l'instar des procédures on pourra rencontrer des notations qui ne spécifient pas les données et qui
utilisent une flèche pour symboliser le retour du résultat.
Exemple :
Fonction ADDITION (A,B (entier), C (réel) ) (réel)

début fonction
ADDITION
fin fonction
15
ou
Fonction ADDITION (A,B (entier), C (réel) ) (réel)

début fonction
retourner (A + B + C)
fin fonction
Vocabulaire.
Dans ce support on a présenté une fonction ou une procédure comme une unité fonctionnelle
(regroupement d’une suite de traitements ayant un objectif logique commun) pouvant être utilisé une
ou plusieurs fois dans un ou des programmes appelants ; d’où la notion de modularité, et de
réutilisation de code.
On a décrit la fonction ou la procédure comme :
Une En-tête qui sert de protocole de communication en les utilisateurs et les développeurs. Cette
comporte les données en entrées, et les résultats en sorties.
On parle aussi de profil ou de prototype de la fonction ou procédure.
Un corps qui est composé de l’ensemble des traitements qui sont assurés par cette fonction ou
procédure. Le corps est composé d’un ensemble d’instruction tout à fait comparable à celui d’un
programme principal, et peut donc contenir ses propres variables (dites locales), et ses propres
fonctions et procédures (dites imbriquées).
CAS PRATIQUES
Etudions au travers de cas pratiques le rôle de l'utilisation de fonction, de procédure et de modules.
Réutilisation de code.
Soit la série d'exercices suivants
1) Un diplôme d’informatique est composé de deux tests et d’un examen. On veut calculer la moyenne
générale d’un étudiant, sachant que la note de l’examen est affectée du coefficient 2.
On affichera le nom, le prénom, les trois notes, et la moyenne obtenue.
2) Un diplôme de comptabilité est composé de trois partiels affectés respectivement des coefficients 1,
2, et 4. On veut connaître la moyenne d’un étudiant.
3) L’évaluation d’un module de cours du soir s’effectue à partir d’une note de partiel en Janvier, d’une
note d’examen en juin, et d’une note de projet en mai. Les notes sont affectées de coefficients (1 pour
le partiel, 2 pour le projet, et 3 pour l’examen. On veut calculer la moyenne obtenu par un auditeur de
ce module. On affichera son matricule, nom, prénom, et moyenne finale.
de trois notes coefficientées d'algorithme :

début
fin
-dessus) que l'on

placera dans une bibliothèque ce qui permettra sa réutilisation comme fonction intrinsèque
(prédéfinie) dans les différents algorithmes
16
Ce qui va permettre d'écrire les trois algorithmes suivants :
Enoncé 1
Un diplôme d’informatique est composé de deux tests et d’un examen. On veut calculer la moyenne
générale d’un étudiant, sachant que la note de l’examen est affectée du coefficient 2.
On affichera le nom, le prénom, les trois notes, et la moyenne obtenue.
Algorithme (complet)
Lexique
variables Type Définition

TEST1 (reel) Note du premier test
TEST2 (reel) Note du second test
EXAM (reel) Note de l'examen
MOY (reel) Moyenne générale de l’étudiant
NOM (chaîne) Nom de l'étudiant
PRENOM (chaîne) Prénom de l'étudiant
Début
Lire(NOM,PRENOM,TEST1,TEST2,EXAM)
Ecrire(NOM,PRENOM,TEST1,TEST2,EXAM,MOY)
Fin
Enoncé 2
Un diplôme de comptabilité est composé de trois partiels affectés respectivement des coefficients 1, 2,
et 4. On veut connaître la moyenne d’un étudiant.
Lexique
constantes
COEF1 = 1
COEF2 = 2
COEF3 = 4
PARTIEL1 (reel) Note du premier partiel
PARTIEL2 (reel) Note du second partiel
PARTIEL3 (reel) Note du troisième partiel
MOYEN (reel) Moyenne de l’étudiant
Début
Lire(PARTIEL1,PARTIEL2,PARTIEL3)
Ecrire(MOYEN)
Fin
17
Enoncé 3
L’évaluation d’un module de cours du soir s’effectue à partir d’une note de partiel en Janvier, d’une
note d’examen en juin, et d’une note de projet en mai. Les notes sont affectées de coefficients (1 pour
le partiel, 2 pour le projet, et 3 pour l’examen. On veut calculer la moyenne obtenu par un auditeur de
ce module. On affichera son matricule, nom, prénom, et moyenne finale.
Lexique
constantes
C1 = 1 Coefficient du partiel
C2 = 2 Coefficients de projet
C3 = 3 Coefficients de l'examen
PARTIEL (reel) Note du partiel
PROJET (reel) Note du projet
EXAMEN (reel) Note de l'examen
MOYFIN (reel) Moyenne finale de l'auditeur
MAT (chaîne) Matricule d'auditeur
NOM (chaîne) Nom de l'auditeur
PRENOM (chaîne) Prénom de l'auditeur
Début
Lire(MAT,NOM,PRENOM,PARTIEL,PROJET,EXAMEN)
Ecrire(MAT,NOM,PRENOM,MOYFIN)
Fin
Schéma de réutilisation du code de la fonction.
CAS PRATIQUES
Modularisation simple de traitement.
Énoncé
Un centre de vacances décide d’organiser pour les enfants (on ne connaît pas à l’avance le nombre des
enfants) un après-midi ‘grands jeux sportifs’.
Il s’agit de 5 catégories d’épreuves (codée 1 pour adresse, 2 pour débrouillardise, 3 pour résistance, 4
18
pour vitesse, 5 pour endurance), chacune de ces 5 catégories est constituée de 3 épreuves obligatoires
(A pour facile, B pour moyen, C pour difficile).
Tout enfant qui a réussi l’une des épreuves de chaque catégorie se voit attribuer :
5 points pour la première épreuve.

10 points pour la seconde épreuve.
20 points pour la troisième épreuve.
On désire connaître pour chaque enfant le nom et le prénom, le nombre de points par catégorie, ainsi
que le nombre total des points obtenus.
On veut aussi déterminer le nombre de points total ayant été obtenu par l’enfant (ou les enfants)
vainqueur(s), ainsi que la moyenne générale de l’ensemble des enfants aux ‘grands jeux sportifs’.
Schéma organisationnel.
Schématisons l'enchaînement des traitements à mettre en oeuvres qui seront définies par une série de
module algorithmique.
Développement modulaire (simple).
Cette première démarche va consister à être modulaire en développant les modules simples et en
délocalisant chaque sous problème dans un autre module comme défini par le schéma organisationnel
précédent.
La résolution du problème posé
Algorithme (principal)
Lexique
constantes
NBCATEG = 5 Nombres de catégories d'épreuves
NBEPREUV = 3 Nombres d'épreuves dans une catégorie
PA = 5 Nombres de points obtenus pour avoir réussi l'épreuve A
PB = 10 Nombres de points obtenus pour avoir réussi l'épreuve B
PC = 20 Nombres de points obtenus pour avoir réussi l'épreuve C
19
NBENFANT (entier) Nombre total d'enfants ayant participé
calculé dans le module UN_ENFANT
TOTPOINT (entier) Cumul des points obtenus par tous les enfants
MAX_POINT (entier) Nombre de points obtenus par le vainqueur
MOYPOINT (réel) Moyenne générale des points obtenus
REP (caractère) Permet de gérer la saisie
Fonction MAJUSCULE (données CARAC(caractère)) résultat (caractère)
Début
Lire(REP)
Tant que majuscule(REP) = ‘O’ faire
UN_ENFANT {délocalisation du traitement d'un enfant}
Lire (REP)
Fin de tant que
Si NBENFANT > 0
Alors TOTPOINT / NBENFANT
{résultats demandés : le nombre de points obtenus par le vainqueur et la moyenne
générale}
Ecrire (MAX_POINT, MOYPOINT)
Sinon écrire(‘aucun enfant n'a participé’)
Fin si
Fin
Module UN_ENFANT
{ce module doit permettre de déterminer le nombre de points maximum obtenus (par l'enfant
vainqueur) MAX_POINT, le nombre total d'enfants NBENFANT, et le cumul des points obtenus par
chaque enfant TOTPOINT}.
lexique à ajouter au lexique principal

NOM (chaîne) Nom de l'enfant courant
PRENOM (chaîne) Prénom de l'enfant courant
ENFANT_POINT (entier) Total des points obtenus par un enfant
calculé dans le module LES_CATEGORIES
Début
Lire (NOM,PRENOM)
LES_CATEGORIES
Ecrire (ENFANT_POINT) {résultat demandé : le total des points de l'enfant}
{recherche du maximum des points obtenus par un enfant}

Si ENFANT_POINT > MAX_POINT
Alors ENFANT_POINT
20
Fin si
{comptage du nombre d'enfants et du cumul des points}
ENFANT_POINT
Fin
Module LES_CATEGORIES
{ce module doit permettre de déterminer le nombre total de points obtenus (par un enfant) à l'ensemble
des catégories ENFANT_POINT }.

CATEGORIE (entier) Indice d’itération comptant les catégories
POINT_CATEG (entier) Total des points obtenus par un enfant dans une catégorie
calculé dans le module LES_EPREUVES
Début
ENFANT_POINT {initialisation du total des points obtenus par l'enfant}
Pour CATEGORIE de 1 à NBCATEG faire
LES_EPREUVES
Ecrire(POINT_CATEG) {résultat demandé : le total des points de la catégorie}
{on calcule le nombre de point total de l'enfant}

POINT_CATEG
Fin pour CATEGORIE
Fin
Module LES_EPREUVES
{ce module doit permettre de déterminer le nombre de points obtenus (par un enfant) aux différentes
épreuves d'une catégorie POINT_CATEG }.

EPREUVE (entier) Indice d’itération comptant les épreuves
REUSSI (Caractère) A ‘O‘ indique que l'enfant a réussi l'épreuve
Début
{initialisation du total des points de la catégorie}
Pour EPREUVE de 1 à NBEPREUV faire
Lire (REUSSI)
Si majuscule(REUSSI) = ‘O’ {si l'enfant a réussi l'épreuve}
Alors en fonction de EPREUVE valant
1 : POINT_CATEG {5 points}
2 {10 points}
3 {20 points}
fin en fonction de
Fin si
Fin pour EPREUVE
Fin
21
Remarques sur la modularisations de traitement.
La déposition fonctionnelle d'un problème en sous problème (module) permet de diminuer la

complexité des traitements à mettre en œuvre, résoudre la problématique d'un module est plus facile
que de s'attaquer à problème de façon globale.
Toutefois on peut noter que ce type de développement nécessite une bonne expérience et une maîtrise
des outils algorithmiques de la programmation structurée.
Au remarquera toutefois que la définition de chaque variable utilisée par algorithme est prévue pour
être globale ce qui est un réel inconvénient posant problème lors d'un développement en équipe, car il
faudra imposer méthodologiquement un lexique global commun (mis à jour immédiatement après
chaque création de variables) pour tous les développeurs.
On peut se rendre compte aussi de l'importance fondamentale des commentaires déjà au niveau de
l'algorithme, qui sera essentiel lors d'une maintenance corrective (corrigé des erreurs détectées en
phase de tests) ou adaptative (évolution du contexte de l'application).
Observation : On a la possibilité de recomposer un algorithme global en intégrant le code de chacun

des modules au niveau de l'appel de celui-ci.
Visualisation de l'annexe correspondante.
Autre solution : on peut remplacer chacun des modules en programmation par une procédure sans
passage de paramètres (définition d'un module), ce qui doit permettre de segmenter les traitements
(avantage), mais de garder un lexique de variables globales (inconvénient).
CAS PRATIQUES
Modularisation fonctionnelle de traitement.
Schéma organisationnel.
À partir de la même réflexion (énoncé du problème précédent) adoptons une démarche nous
permettant de développer des fonctions ou procédures algorithmiques adaptées aux besoins du
traitement de notre problème et communiquant les unes avec les autres par des flux de données et de
résultats.
22
Développement modulaire(fonctions et procédures).
Algorithme (principal)
Lexique
constantes
calculé dans la procédure UN_ENFANT

ère CARAC
Début
23
Lire(REP)
{délocalisation du traitement d'un enfant dans la procédure UN_ENFANT}
UN_ENFANT(NBENFANT, TOTPOINT, MAX_POINT)
Lire (REP)
Fin de tant que
Si NBENFANT > 0
générale}
Fin si
Fin
Procédure UN_ENFANT(donnée/résultat NBENFANT, TOTPOINT, MAX_POINT(entier))
{cette procédure doit permettre de déterminer (donc résultat) le nombre de points maximum obtenus
(par l'enfant vainqueur) MAX_POINT, le nombre total d'enfants NBENFANT, et le cumul des points
obtenus par chaque enfant TOTPOINT, à partir de l'initialisation de ces mêmes variables dans le
programme principal appelant (donc donnée). On procédera à l'affichage du total des points obtenus
par l'enfant ENFANT_POINT comme demandé dans l'énoncé}.
lexique local à la procédure
Variables locales Type Définition

calculé par la fonction LES_CATEGORIES
Début
Lire (NOM,PRENOM)
ENFANT_POINT LES_CATEGORIES

Alors MAX_POINT ENFANT_POINT
Fin si

NBENFANT NBENFANT + 1
TOTPOINT TOTPOINT + ENFANT_POINT
Fin
Fonction LES_CATEGORIES résultat (entier)
24
{cette fonction doit permettre de déterminer le nombre total de points obtenus (par un enfant) à
l'ensemble des catégories
On procédera à l'affichage du nombre de points obtenus par l'enfant dans chaque catégorie
POINT_CATEG comme demandé dans l'énoncé}
lexique local à la fonction
variables locales Type Définition

calculé par la fonction LES_EPREUVES
compte_POINT (entier) Variable du cumul des points d'un enfant pour l'ensemble des
catégories
Début
{initialisation du total des points obtenus par l'enfant}
POINT_CATEG LES_EPREUVES

POINT_CATEG
Fin pour CATEGORIE
LES_CATEGORIES {retour du résultat de la fonction}
Fin
Fonction LES_EPREUVES résultat (entier)
{cette fonction doit permettre de déterminer le nombre de points obtenus (par un enfant) aux
différentes épreuves d'une catégorie }.
lexique local à la fonction

compte_CATEG (entier) Variable de cumul des points d'un enfant pour une
catégorie d'épreuves
Début
compte_CATEG {initialisation du total des points de la catégorie}
Lire (REUSSI)
Alors POINT (EPREUVE)
Fin si
Fin pour EPREUVE
LES_EPREUVES {retour du résultat de la fonction}
Fin
Fonction POINT (donnée CODE (entier)) résultat (entier)
25
{cette fonction doit permettre de retourner le nombre de points obtenus (par un enfant) a l'épreuve de
catégorie CODE }.
Début
en fonction de CODE valant
1: PA {5 points}
2: PB {10 points}
3: PC {20 points}
fin en fonction de
Fin
Remarques sur l’utilisation des fonctions et procédures
Observations :
On a la possibilité de recomposer l’algorithme utilisant l'encapsulation des fonctions et procédures

respectant ainsi la logique de création.
L'encapsulation offre l'avantage de masquer l'organisation général du développement, mais interdit

toutefois d'envisager la réutilisation de fonctions ou procédures internes.
Visualisation de l'algorithme (fonctions et procédures encapsulées).
Ou
On peut recomposer l'algorithme en énumérant successivement au même niveau les fonctions et

procédures, ce qui pourrait permettre une utilisation de chacune dans les autres ou le programme
principal (ce qui n'entre pas directement dans le cadre de la structure de l'exercice, mais qui permet
d'illustrer la possibilité d'une utilisation multiple d'une même fonction ou procédure.
Visualisation de l'algorithme (fonctions et procédures au même niveau).
ANNEXES
Les modules
Algorithme complet de l'exercice :
Procédure ALPHABET_CROISANT
variable locale i (caractère)
début
pour i de ‘a’ à ‘z’ faire écrire(i) fin pour i
fin
Procédure ALPHABET_DECROISANT
variable locale i (caractère)
début
pour i de ‘z’ à ‘a’ (décroissant) faire écrire(i) fin pour i
fin
Procédure CODE_ASCII
variable locale i (entier)
fonction ASCII(donnée ENT(entier)) résultat (caractère)
début
26
pour i de 32 à 255 faire écrire(i,ASCII(i)) fin pour i
fin
Début {algorithme principal}

ALPHABET_CROISANT
ALPHABET_DECROISSANT
CODE_ASCII
Fin {algorithme principal}
ce qui donne l'agencement suivant :
Algorithme standard recomposé
Recomposition d'un algorithme standard à partir de la démarche modulaire de l'énoncé suivant :
Un centre de vacances décide d’organiser pour les enfants (on ne connaît pas à l’avance le nombre des
enfants) un après-midi ‘grands jeux sportifs’.
Il s’agit de 5 catégories d’épreuves (codée 1 pour adresse, 2 pour débrouillardise, 3 pour résistance, 4
pour vitesse, 5 pour endurance), chacune de ces 5 catégories est constituée de 3 épreuves obligatoires
(A pour facile, B pour moyen, C pour difficile).
Tout enfant qui a réussi l’une des épreuves de chaque catégorie se voit attribuer :
5 points pour la première épreuve.

10 points pour la seconde épreuve.
20 points pour la troisième épreuve.
On désire connaître pour chaque enfant le nom et le prénom, le nombre de points par catégorie, ainsi
que le nombre total des points obtenus.
On veut aussi déterminer le nombre de points total ayant été obtenu par l’enfant (ou les enfants)
vainqueur(s), ainsi que la moyenne générale de l’ensemble des enfants aux ‘grands jeux sportifs’.
Algorithme (global)
Lexique général
constantes
27

ne la majuscule du caractère CARAC
Début
Lire(REP)
{début UN_ENFANT }
lire (NOM,PRENOM)
{début LES_CATEGORIES }
{début LES_EPREUVES }
Lire (REUSSI)
Alors en fonction de EPREUVE valant
1 {5 points}
2 {10 points}
3 {20 points}
fin en fonction de
Fin si
Fin pour EPREUVE
{fin LES_EPREUVES }
POINT_CATEG
Fin pour CATEGORIE
{ fin LES_CATEGORIES }
Alors ENFANT_POINT
Fin si
ENFANT_POINT
{ fin UN_ENFANT }
Lire (REP)
Fin de tant que
Si NBENFANT > 0
générale}
28
Fin si
Fin
fonctions et procédures encapsulées
Algorithme (général)
Lexique
constantes
{définition des fonctions intrinsèques (prédéfinies)}

{définition des fonctions et procédures utilisateur}


POINT_CATEG (entier) Total des points obtenus par un enfant dans une
catégorie

compte_POINT (entier) Variable du cumul des points d'un enfant pour
l'ensemble des catégories

29
Début

1: PA {5 points}
2: PB {10 points}
3: PC {20 points}
fin en fonction de
Fin
Début
compte_CATEG
Lire (REUSSI)
Alors compte_CATEG POINT (EPREUVE)
Fin si
Fin pour EPREUVE

LES_EPREUVES
Fin
Début
LES_EPREUVES
Ecrire(POINT_CATEG)
Fin pour CATEGORIE

LES_CATEGORIES
Fin
Début
Lire (NOM,PRENOM)
LES_CATEGORIES
Ecrire (ENFANT_POINT)
Alors MAX_POINT
Fin si
Fin
30
Lire(REP)

Lire (REP)
Fin de tant que
Si NBENFANT > 0
Alors ENFANT
Fin si
Fonctions et procédures de même niveau
Algorithme (général)
Lexique
constantes
{définition des fonctions intrinsèques (prédéfinies)}

{définition des fonctions et procédures utilisateur}


31
Début
Lire (NOM,PRENOM)
ENFANT_POINT LES_CATEGORIES
Alors MAX_POINT ENFANT_POINT
Fin si
Fin

compte_POINT (entier) Variable du cumul des points d'un enfant pour l'ensemble des
catégories
Début

POINT_CATEG LES_EPREUVES
POINT_CATEG
Fin pour CATEGORIE

LES_CATEGORIES {retour du résultat de la fonction}
Fin

Début

Lire (REUSSI)
Alors compte_CAT POINT (EPREUVE)
Fin si
32
Fin pour EPREUVE
LES_EPREUVES {retour du résultat de la fonction}
Fin

Début

1: PA {5 points}
2: PB {10 points}
3: PC {20 points}
fin en fonction de
Fin
Lire(REP)

Lire (REP)
Fin de tant que

Si NBENFANT > 0
générale}
Fin si
Source :
http://www.labo-info.co.cc
http://www.algofree.co.cc
33

Algorithme Fonctions Et Procedures

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Algorithme Fonctions Et Procedures

Uploaded by

Copyright:

Available Formats

Présentation

Pour permettre de résoudre ce type de problème, on doit adopter un mode de programmation

L’ensemble va se traduire techniquement par :

voyons quelques exemples :

Soit l’exercice permettant de traiter successivement les trois points suivants :

1. On veut afficher l’alphabet de façon croissante.

Variable locale i (caractère)

Pour i de ‘a’ à ‘z’ faire

Variable locale i (caractère)

Pour i de ‘z’ à ‘a’ (décroissant) faire

Écrire (i) fin pour i

Variable locale i (entier)

Fonction ASCII (donnée ENT (entier)) résultat (caractère)

// Fonction intrinsèque qui retourne le caractère ASCII correspondant à ENT

Pour i de 32 à 255 faire

Écrire (i, ASCII (i))

On a la possibilité de recomposer un algorithme global en intégrant le code de chacun des modules au

Soit les deux exercices indépendants suivants :

Les données sont :

N1,N2,N3 (réel) les trois notes

MOYENNE (réel) la moyenne coefficientée

MOYENNE (N1*C1+N2*C2+N3*C3)/ (C1+C2+C3)

Regroupons cette réflexion au sein d’une structure algorithmique :

fonction MOYENNE(données N1,N2,N3(réel), C1,C2,C3(réel)) résultat(réel)

Pour i de 1 à NBETUDIANT faire

Lire (NOM, PRENOM, NOT1, NOT2, EXAM)

MOY MOYENNE (NOT1, NOT2, EXAM, 1, 1, 2)

Et l'algorithme de l'exercice sur le groupe des auditeurs CNAM

COEF1=1 coefficient du partiel

NOM, PRENOM (chaîne) nom et prénom de l’auditeur

Tant que NOM ‘’ faire

Lire (PRENOM, PARTIEL, TP, EXAM)

MOYEN MOYENNE(PARTIEL, TP, EXAM, COEF1, COEF2, COEF3)

Soit l'exercice suivant :

On veut afficher la table de multiplication du nombre entier N pour des multiplicateurs de 1 à 10

Les données sont :

N (entier) le nombre à multiplier

Le résultat est : Aucun, il s'agit de l'action d'afficher la table de multiplication du N

Par exemple si N vaut 7

Regroupons cette réflexion au sein d’une structure algorithmique :

Procédure TABLE_MULTIPLICATION (données N (entier))

variable locale i (entier)

On peut écrire l'algorithme d'affichage de la table de multiplication intégrant cette procédure

Soit l'exercice suivant :

Les données sont : aucune donnée (¶ est une constante)

Les résultats sont :

CARRE (réel) le carré de ¶

Regroupons cette réflexion au sein d’une structure algorithmique :

Procédure CARRE_RACINE_PI (résultats C, R (réel))

{Liste de fonctions intrinsèques ou prédéfinies}

Fonction carré (donnée X (réel)) résultat (réel)

Fonction racine_carrée (donnée X (réel)) résultat (réel)

Retourne la racine carrée de X.

Fonction PI résultat (réel)

Retourne la valeur constante de PI (¶)

soit l'exercice suivant :

Les données sont :

Les résultats sont :

Regroupons cette réflexion au sein d’une structure algorithmique :

procédure DIVISION(données N,D(réel) résultats R(réel),ERREUR(booléen))

On peut écrire l'algorithme utilisant la procédure de calcul

NOMBR1 (réel) le nombre à diviser

Algorithmie des fonctions et procédures

Les FONCTIONS (Notation Algorithmique)

MOYENNE (N1C1+N2C2+N3*C3)/ (C1+C2+C3)