Algorithme Fonctions Et Procedures

33

description

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

Transcript of Algorithme Fonctions Et Procedures

Page 1: Algorithme Fonctions Et Procedures
Page 2: Algorithme Fonctions Et Procedures

2

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

Page 3: Algorithme Fonctions Et Procedures

3

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.

Page 4: Algorithme Fonctions Et Procedures

4

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 :

Page 5: Algorithme Fonctions Et Procedures

5

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)

Page 6: Algorithme Fonctions Et Procedures

6

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

1 x 7 = 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

Page 7: Algorithme Fonctions Et Procedures

7

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

Page 8: Algorithme Fonctions Et Procedures

8

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)

Page 9: Algorithme Fonctions Et Procedures

9

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.

Page 10: Algorithme Fonctions Et Procedures

10

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.

Page 11: Algorithme Fonctions Et Procedures

11

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

Page 12: Algorithme Fonctions Et Procedures

12

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

Page 13: Algorithme Fonctions Et Procedures

13

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

Page 14: Algorithme Fonctions Et Procedures

14

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

Page 15: Algorithme Fonctions Et Procedures

15

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

Page 16: Algorithme Fonctions Et Procedures

16

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

Page 17: Algorithme Fonctions Et Procedures

17

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

Page 18: Algorithme Fonctions Et Procedures

18

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

Page 19: Algorithme Fonctions Et Procedures

19

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

Page 20: Algorithme Fonctions Et Procedures

20

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

Page 21: Algorithme Fonctions Et Procedures

21

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

Page 22: Algorithme Fonctions Et Procedures

22

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.

Page 23: Algorithme Fonctions Et Procedures

23

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

Page 24: Algorithme Fonctions Et Procedures

24

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)

Page 25: Algorithme Fonctions Et Procedures

25

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

Page 26: Algorithme Fonctions Et Procedures

26

{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

Page 27: Algorithme Fonctions Et Procedures

27

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

Page 28: Algorithme Fonctions Et Procedures

28

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}

Page 29: Algorithme Fonctions Et Procedures

29

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

Page 30: Algorithme Fonctions Et Procedures

30

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

Page 31: Algorithme Fonctions Et Procedures

31

Début {algorithme principal}

0

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

Page 32: Algorithme Fonctions Et Procedures

32

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

Page 33: Algorithme Fonctions Et Procedures

33

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