Algorithme Fonctions Et Procedures [PDF]

Zitiervorschau

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 C1,C2,C3

(réel) les trois notes (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 COEF2=2 COEF3=3

coefficient du partiel coefficient du TP 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 RACINE

(réel) le carré de ¶ (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 RACINE

(réel) (réel)

le carré de PI 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) D (réel)

le numérateur 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 NOMBR2 RES ERREUR

(réel) (réel) (réel) (booléen)

le nombre à diviser le diviseur le résultat de la division 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 La racine carré du nombre

CARRE(réel) 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 Le nombre réel

A, B 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 NB_REEL,NB_RESULTAT

(entier) (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é du nom donné par l’utilisateur à la fonction de la liste des données en entrée de la fonction du mot clé du type du résultat

Fonction ADDITION (données A,B(entier),C(réel)) 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 La nom du chemin Algorithme variables LECTEUR CHEMIN

LECTEUR(entier) CHEMIN(chaîne)

(entier) (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 Le message à afficher

X, Y 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 CHAINE_A_AFFICHER

(entier) (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 le second nombre

N1 N2

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

N1 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é du nom donné par l’utilisateur à la procédure de la liste des données en entrée de la procédure de la liste des résultats en sortie de la procédure

13

Procédure INVERSE (données N1,N2 (réel), résultat N1,N2 (réel))

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) ) début fonction ADDITION fin fonction

15

(réel)

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

(réel)

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 TEST1 TEST2 EXAM MOY NOM PRENOM

Type (reel) (reel) (reel) (reel) (chaîne) (chaîne)

Définition Note du premier test Note du second test Note de l'examen Moyenne générale de l’étudiant Nom de l'étudiant 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 PARTIEL1 PARTIEL2 PARTIEL3 MOYEN

Type (reel) (reel) (reel) (reel)

Définition Note du premier partiel Note du second partiel Note du troisième partiel 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 C2 = 2 C3 = 3 variables PARTIEL PROJET EXAMEN MOYFIN MAT NOM PRENOM

Type (reel) (reel) (reel) (reel) (chaîne) (chaîne) (chaîne)

Coefficient du partiel Coefficients de projet Coefficients de l'examen Définition Note du partiel Note du projet Note de l'examen Moyenne finale de l'auditeur Matricule d'auditeur Nom de l'auditeur 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 NBEPREUV = 3 PA = 5 PB = 10 PC = 20

Nombres de catégories d'épreuves Nombres d'épreuves dans une catégorie Nombres de points obtenus pour avoir réussi l'épreuve A Nombres de points obtenus pour avoir réussi l'épreuve B Nombres de points obtenus pour avoir réussi l'épreuve C

19

variables NBENFANT

Type (entier)

TOTPOINT

(entier)

MAX_POINT

(entier)

MOYPOINT REP

(réel) (caractère)

Définition Nombre total d'enfants ayant participé calculé dans le module UN_ENFANT Cumul des points obtenus par tous les enfants calculé dans le module UN_ENFANT Nombre de points obtenus par le vainqueur calculé dans le module UN_ENFANT Moyenne générale des points obtenus 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 NOM PRENOM ENFANT_POINT

Type (chaîne) (chaîne) (entier)

Définition Nom de l'enfant courant Prénom de l'enfant courant 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 CATEGORIE POINT_CATEG

Type (entier) (entier)

Définition Indice d’itération comptant les catégories 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 EPREUVE REUSSI

Type (entier) (Caractère)

Définition Indice d’itération comptant les épreuves 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 NBEPREUV = 3 PA = 5 PB = 10 PC = 20 variables NBENFANT

Type (entier)

TOTPOINT

(entier)

MAX_POINT

(entier)

MOYPOINT REP

(réel) (caractère)

Nombres de catégories d'épreuves Nombres d'épreuves dans une catégorie Nombres de points obtenus pour avoir réussi l'épreuve A Nombres de points obtenus pour avoir réussi l'épreuve B Nombres de points obtenus pour avoir réussi l'épreuve C Définition Nombre total d'enfants ayant participé calculé dans la procédure UN_ENFANT Cumul des points obtenus par tous les enfants calculé dans la procédure UN_ENFANT Nombre de points obtenus par le vainqueur calculé dans la procédure UN_ENFANT Moyenne générale des points obtenus 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 NOM PRENOM ENFANT_POINT

Type (chaîne) (chaîne) (entier)

Définition Nom de l'enfant courant Prénom de l'enfant courant 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 CATEGORIE POINT_CATEG

Type (entier) (entier)

compte_POINT

(entier)

Définition Indice d’itération comptant les catégories Total des points obtenus par un enfant dans une catégorie calculé par la fonction LES_EPREUVES 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 EPREUVE REUSSI compte_CATEG

Type (entier) (Caractère) (entier)

Définition Indice d’itération comptant les épreuves A ‘O‘ indique que l'enfant a réussi l'épreuve 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 NBEPREUV = 3 PA = 5 PB = 10 PC = 20 variables

Type

Nombres de catégories d'épreuves Nombres d'épreuves dans une catégorie Nombres de points obtenus pour avoir réussi l'épreuve A Nombres de points obtenus pour avoir réussi l'épreuve B Nombres de points obtenus pour avoir réussi l'épreuve C Définition

27

NBENFANT TOTPOINT MAX_POINT MOYPOINT REP NOM PRENOM ENFANT_POINT CATEGORIE POINT_CATEG EPREUVE REUSSI

(entier) (entier) (entier) (réel) (caractère) (chaîne) (chaîne) (entier) (entier) (entier) (entier) (Caractère)

Nombre total d'enfants ayant participé Cumul des points obtenus par tous les enfants Nombre de points obtenus par le vainqueur Moyenne générale des points obtenus Permet de gérer la saisie Nom de l'enfant courant Prénom de l'enfant courant Total des points obtenus par un enfant Indice d’itération comptant les catégories Total des points obtenus par un enfant dans une catégorie Indice d’itération comptant les épreuves 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 NBEPREUV = 3 PA = 5 PB = 10 PC = 20 variables NBENFANT

Type (entier)

TOTPOINT

(entier)

MAX_POINT

(entier)

MOYPOINT REP

(réel) (caractère)

Nombres de catégories d'épreuves Nombres d'épreuves dans une catégorie Nombres de points obtenus pour avoir réussi l'épreuve A Nombres de points obtenus pour avoir réussi l'épreuve B Nombres de points obtenus pour avoir réussi l'épreuve C Définition Nombre total d'enfants ayant participé calculé dans la procédure UN_ENFANT Cumul des points obtenus par tous les enfants calculé dans la procédure UN_ENFANT Nombre de points obtenus par le vainqueur calculé dans la procédure UN_ENFANT Moyenne générale des points obtenus 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 NOM PRENOM ENFANT_POINT

Type (chaîne) (chaîne) (entier)

Définition Nom de l'enfant courant Prénom de l'enfant courant Total des points obtenus par un enfant calculé par la fonction LES_CATEGORIES

Fonction LES_CATEGORIES résultat (entier) variables locales CATEGORIE POINT_CATEG

Type (entier) (entier)

compte_POINT

(entier)

Définition Indice d’itération comptant les catégories Total des points obtenus par un enfant dans une catégorie calculé par la fonction LES_EPREUVES Variable du cumul des points d'un enfant pour l'ensemble des catégories

Fonction LES_EPREUVES résultat (entier) Variables locales EPREUVE REUSSI

Type (entier) (Caractère)

29

Définition Indice d’itération comptant les épreuves 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

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}

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 NBEPREUV = 3 PA = 5 PB = 10 PC = 20 variables NBENFANT

Type (entier)

TOTPOINT

(entier)

MAX_POINT

(entier)

MOYPOINT REP

(réel) (caractère)

Nombres de catégories d'épreuves Nombres d'épreuves dans une catégorie Nombres de points obtenus pour avoir réussi l'épreuve A Nombres de points obtenus pour avoir réussi l'épreuve B Nombres de points obtenus pour avoir réussi l'épreuve C Définition Nombre total d'enfants ayant participé calculé dans la procédure UN_ENFANT Cumul des points obtenus par tous les enfants calculé dans la procédure UN_ENFANT Nombre de points obtenus par le vainqueur calculé dans la procédure UN_ENFANT Moyenne générale des points obtenus 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 NOM PRENOM ENFANT_POINT

Type (chaîne) (chaîne) (entier)

Définition Nom de l'enfant courant Prénom de l'enfant courant 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 CATEGORIE POINT_CATEG

Type (entier) (entier)

compte_POINT

(entier)

Définition Indice d’itération comptant les catégories Total des points obtenus par un enfant dans une catégorie calculé par la fonction LES_EPREUVES 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 EPREUVE REUSSI compte_CATEG

Type (entier) (Caractère) (entier)

Définition Indice d’itération comptant les épreuves A ‘O‘ indique que l'enfant a réussi l'épreuve 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