Professional Documents
Culture Documents
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.
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
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
Début
Écrire (i)
Fin pour i
Fin
Procédure ALPHABET_DECROISANT
Début
Fin
Procédure CODE_ASCII
Début
Fin pour
Fin
Observation :
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
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).
Le résultat est :
Le traitement est :
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)
Écrire (MOY)
Fin pour i
Fin
Lexique :
Constantes
Variables
Début
Lire (NOM)
É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
Le traitement est :
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
6
Lexique
variables :
N (entier) le multiplicateur
Début
lire (N)
TABLE_MULTIPLICATION (N)
Fin
Illustration 2
On veut retourner les valeurs du carré, et de la racine carrée de la constante trigonométrique ¶ (Pi).
Le traitement est :
CARRE = ¶²
RACINE =æ
Retourne le carré de X.
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.
Le traitement est :
Si D = 0
R=N/C
fin si
Fin
données résultats
sortie)
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).
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).
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.
Algorithme
variables :
NOMBR,CARRE,RACINE (réel)
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.
Prenons l’exemple d’une fonction qui effectue la somme de deux entiers, et d’un réel.
On note que la fonction est composée de deux parties : l’entête, et le corps de la fonction.
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
composé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
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.
Algorithme
variables
LECTEUR (entier)
CHEMIN (chaîne)
disque
11
début
RETOURNE_CHEMIN(LECTEUR,CHEMIN)
Ecrire (LECTEUR,CHEMIN)
Fin
Illustrations 1 : Prenons l’exemple de l’affichage d’un message à une position déterminée (abscisses,
ordonnées) à l’écran.
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.
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
Algorithme de la 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.
Algorithme
variables
X,Y (réel)
début
Lire(X,Y)
INVERSE(X,Y)
Ecrire(X,Y)
fin
composée
Le corps de la procédure
composé
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 :
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).
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.
Structure :
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)
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)))
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.
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 :
15
ou
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.
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
Réutilisation de code.
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.
fin
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
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
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
Début
Lire(MAT,NOM,PRENOM,PARTIEL,PROJET,EXAMEN)
Ecrire(MAT,NOM,PRENOM,MOYFIN)
Fin
CAS PRATIQUES
É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 :
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.
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.
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
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
Début
Lire (NOM,PRENOM)
LES_CATEGORIES
Ecrire (ENFANT_POINT) {résultat demandé : le total des points de l'enfant}
ENFANT_POINT
Fin
Module LES_CATEGORIES
{ce module doit permettre de déterminer le nombre total de points obtenus (par un enfant) à l'ensemble
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}
Module LES_EPREUVES
{ce module doit permettre de déterminer le nombre de points obtenus (par un enfant) aux différentes
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.
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).
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
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
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
{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
Début
Lire (NOM,PRENOM)
ENFANT_POINT LES_CATEGORIES
Ecrire (ENFANT_POINT) {résultat demandé : le total des points de l'enfant}
24
{cette fonction doit permettre de déterminer le nombre total de points obtenus (par un enfant) à
On procédera à l'affichage du nombre de points obtenus par l'enfant dans chaque catégorie
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}
{cette fonction doit permettre de déterminer le nombre de points obtenus (par un enfant) aux
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
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
Observations :
Ou
ANNEXES
Les modules
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
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 :
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
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
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
29
compte_CATEG (entier) Variable de cumul des points d'un enfant pour une
catégorie d'épreuves
Début
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
Début
LES_EPREUVES
Ecrire(POINT_CATEG)
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
Si NBENFANT > 0
Alors ENFANT
Ecrire (MAX_POINT, MOYPOINT)
Sinon écrire(‘aucun enfant n'a participé’)
Fin si
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
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
Début
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
Début
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
Fin
Lire(REP)
Tant que majuscule(REP) = ‘O’ faire
Source :
http://www.labo-info.co.cc
http://www.algofree.co.cc
33