Vous êtes sur la page 1sur 33

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

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

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 =æ

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)

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

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))


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.

Fonction ADDITION (données A,B (entier), C (réel) ) résultat (réel)


début fonction
ADDITION
fin fonction

On trouve aussi le formalisme suivant

Fonction ADDITION (données A,B (entier), C (réel) ) résultat (réel)


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 :

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


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

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

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.

Algorithme (complet)

Lexique

constantes
COEF1 = 1
COEF2 = 2
COEF3 = 4
variables Type Définition
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

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

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.

Algorithme (complet)

Lexique

constantes
C1 = 1 Coefficient du partiel
C2 = 2 Coefficients de projet
C3 = 3 Coefficients de l'examen
variables Type Définition
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

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

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
variables Type Définition
NBENFANT (entier) Nombre total d'enfants ayant participé
calculé dans le module UN_ENFANT
TOTPOINT (entier) Cumul des points obtenus par tous les enfants
calculé dans le module UN_ENFANT
MAX_POINT (entier) Nombre de points obtenus par le vainqueur
calculé dans le module UN_ENFANT
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

variables Type Définition


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 }.

lexique à ajouter au lexique principal

variables Type Définition


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 }.

lexique à ajouter au lexique principal

variables Type Définition


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
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
variables Type Définition
NBENFANT (entier) Nombre total d'enfants ayant participé
calculé dans la procédure UN_ENFANT
TOTPOINT (entier) Cumul des points obtenus par tous les enfants
calculé dans la procédure UN_ENFANT
MAX_POINT (entier) Nombre de points obtenus par le vainqueur
calculé dans la procédure UN_ENFANT
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)


ère CARAC

Début

23
Lire(REP)
Tant que majuscule(REP) = ‘O’ faire
{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
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

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


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é par la fonction LES_CATEGORIES

Début
Lire (NOM,PRENOM)
ENFANT_POINT 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 MAX_POINT ENFANT_POINT
Fin si

{comptage du nombre d'enfants et du cumul des points}


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


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é 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}
Pour CATEGORIE de 1 à NBCATEG faire
POINT_CATEG 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
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

Variables locales Type Définition


EPREUVE (entier) Indice d’itération comptant les épreuves
REUSSI (Caractère) A ‘O‘ indique que l'enfant a réussi l'épreuve
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}
Pour EPREUVE de 1 à NBEPREUV faire
Lire (REUSSI)
Si majuscule(REUSSI) = ‘O’ {si l'enfant a réussi l'épreuve}
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
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
variables Type Définition
27
NBENFANT (entier) Nombre total d'enfants ayant participé
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
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
CATEGORIE (entier) Indice d’itération comptant les catégories
POINT_CATEG (entier) Total des points obtenus par un enfant dans une catégorie
EPREUVE (entier) Indice d’itération comptant les épreuves
REUSSI (Caractère) A ‘O‘ indique que l'enfant a réussi l'épreuve

Fonction MAJUSCULE (données CARAC(caractère)) résultat (caractère)


ne la majuscule du caractère CARAC

Début

Lire(REP)
Tant que majuscule(REP) = ‘O’ faire
{début UN_ENFANT }
lire (NOM,PRENOM)
{début LES_CATEGORIES }
{initialisation du total des points obtenus par l'enfant}
Pour CATEGORIE de 1 à NBCATEG faire
{début LES_EPREUVES }
{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 {5 points}
2 {10 points}
3 {20 points}
fin en fonction de
Fin si
Fin pour EPREUVE
{fin 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 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
Fin si
{comptage du nombre d'enfants et du cumul des points}
ENFANT_POINT
{ fin 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}
28
Ecrire (MAX_POINT, MOYPOINT)
Sinon écrire(‘aucun enfant n'a participé’)
Fin si
Fin

fonctions et procédures encapsulées

Algorithme (général)

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
variables Type Définition
NBENFANT (entier) Nombre total d'enfants ayant participé
calculé dans la procédure UN_ENFANT
TOTPOINT (entier) Cumul des points obtenus par tous les enfants
calculé dans la procédure UN_ENFANT
MAX_POINT (entier) Nombre de points obtenus par le vainqueur
calculé dans la procédure UN_ENFANT
MOYPOINT (réel) Moyenne générale des points obtenus
REP (caractère) Permet de gérer la saisie

{définition des fonctions intrinsèques (prédéfinies)}


Fonction MAJUSCULE (données CARAC(caractère)) résultat (caractère)

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

Procédure UN_ENFANT(donnée/résultat NBENFANT, TOTPOINT, MAX_POINT(entier))

Variables locales Type Définition


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é par la fonction LES_CATEGORIES

Fonction LES_CATEGORIES résultat (entier)

variables locales Type Définition


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é par la fonction LES_EPREUVES


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

Fonction LES_EPREUVES résultat (entier)

Variables locales Type Définition


EPREUVE (entier) Indice d’itération comptant les épreuves
REUSSI (Caractère) A ‘O‘ indique que l'enfant a réussi l'épreuve

29
compte_CATEG (entier) Variable de cumul des points d'un enfant pour une
catégorie d'épreuves

Fonction POINT (donnée CODE (entier)) résultat (entier)

Début

en fonction de CODE valant


1: PA {5 points}
2: PB {10 points}
3: PC {20 points}
fin en fonction de

Fin

Début

compte_CATEG
Pour EPREUVE de 1 à NBEPREUV faire

Lire (REUSSI)
Si majuscule(REUSSI) = ‘O’ {si l'enfant a réussi l'épreuve}
Alors compte_CATEG POINT (EPREUVE)
Fin si

Fin pour EPREUVE


LES_EPREUVES

Fin

Début

Pour CATEGORIE de 1 à NBCATEG faire

LES_EPREUVES
Ecrire(POINT_CATEG)

Fin pour CATEGORIE


LES_CATEGORIES

Fin

Début

Lire (NOM,PRENOM)
LES_CATEGORIES
Ecrire (ENFANT_POINT)
Si ENFANT_POINT > MAX_POINT
Alors MAX_POINT
Fin si
{comptage du nombre d'enfants et du cumul des points}
NBENFANT NBENFANT + 1
TOTPOINT TOTPOINT + ENFANT_POINT

Fin
30
Début {algorithme principal}

Lire(REP)
Tant que majuscule(REP) = ‘O’ faire

{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
Alors ENFANT
Ecrire (MAX_POINT, MOYPOINT)
Sinon écrire(‘aucun enfant n'a participé’)
Fin si

Fin {algorithme principal}

Fonctions et procédures de même niveau

Algorithme (général)

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
variables Type Définition
NBENFANT (entier) Nombre total d'enfants ayant participé
calculé dans la procédure UN_ENFANT
TOTPOINT (entier) Cumul des points obtenus par tous les enfants
calculé dans la procédure UN_ENFANT
MAX_POINT (entier) Nombre de points obtenus par le vainqueur
calculé dans la procédure UN_ENFANT
MOYPOINT (réel) Moyenne générale des points obtenus
REP (caractère) Permet de gérer la saisie

{définition des fonctions intrinsèques (prédéfinies)}


Fonction MAJUSCULE (données CARAC(caractère)) résultat (caractère)

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


Procédure UN_ENFANT(donnée/résultat NBENFANT, TOTPOINT, MAX_POINT(entier))

Variables locales Type Définition


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é par la fonction LES_CATEGORIES

31
Début

Lire (NOM,PRENOM)
ENFANT_POINT 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 MAX_POINT ENFANT_POINT
Fin si
{comptage du nombre d'enfants et du cumul des points}
NBENFANT NBENFANT + 1
TOTPOINT TOTPOINT + ENFANT_POINT

Fin

Fonction LES_CATEGORIES résultat (entier)

variables locales Type Définition


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é 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}


Pour CATEGORIE de 1 à NBCATEG faire

POINT_CATEG 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


LES_CATEGORIES {retour du résultat de la fonction}

Fin

Fonction LES_EPREUVES résultat (entier)

Variables locales Type Définition


EPREUVE (entier) Indice d’itération comptant les épreuves
REUSSI (Caractère) A ‘O‘ indique que l'enfant a réussi l'épreuve
compte_CATEG (entier) Variable de cumul des points d'un enfant pour une
catégorie d'épreuves

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 compte_CAT POINT (EPREUVE)
Fin si

32
Fin pour EPREUVE
LES_EPREUVES {retour du résultat de la fonction}

Fin

Fonction POINT (donnée CODE (entier)) résultat (entier)


Début

en fonction de CODE valant


1: PA {5 points}
2: PB {10 points}
3: PC {20 points}
fin en fonction de

Fin

Début {algorithme principal}

Lire(REP)
Tant que majuscule(REP) = ‘O’ faire

{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
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 {algorithme principal}

Source :
http://www.labo-info.co.cc
http://www.algofree.co.cc

33

Vous aimerez peut-être aussi