La fonction Max établie au paragraphe 9.1 permet de déterminer le maximum de deux nombres réels. Pour généraliser la fonction de façon qu'elle puisse déterminer le maximum d'une suite de N nombres (N Î IN et N ³ 3), il faut introduire en programmation la structure répétitive [angl. repetitive statement; all. Wiederholung] et rendre le nombre de répétitions fonction des données du problème.
La structure répétitive permet d'exécuter une séquence d'instructions un certain nombre de fois jusqu'à ce qu'une condition déterminée est remplie ou non.
Considérons maintenant le problème de la détermination du maximum de N nombres qui sont à introduire successivement à partir du fichier standard d'entrée. Les données d'entrée sont de la forme:
X0, X1, X2, ... , XN-1, XN
La démarche consiste à réduire le problème de la détermination du maximum de N nombres au problème plus simple de la détermination du maximum de deux nombres. Si le programmeur dispose de la fonction Max décrite plus haut, l'algorithme peut s'écrire comme suit:
M0 := X0;
M1 := Max( M0, X1 );
M2 := Max( M1, X2 );
M3 := Max( M2, X3 )
...
MN := Max( MN-1, XN) pour N ³ 1.
D'une manière générale, les relations de récurrence
M0 := X0; (a)
MN := Max( MN-1, XN) pour N ³ 1 (b)
permettent de calculer le maximum de N nombres quel que soit N Î IN et N ³ 1. Il suffit de partir de la relation (a) et de répéter N fois le traitement (b). Après exécution, la valeur du maximum sera contenue dans la cellule-mémoire dénotée par l'identificateur MN.
On obtient la fonction suivante:
01 FUNCTION NMax ( X, Y: Real; N: Word ): Real;
02 VAR First, Next: Real;
03 Count: Word;
04 BEGIN
05 Write( 'Entrer un réel: ' ); Readln( First );
06 Count := 1; {initialisation}
07 WHILE Count<=N DO BEGIN
08 {bloc}
09 Write( 'Réel suivant: ' ); Readln( Next );
10 First := Max( First, Next );
11 I := I+1;
12 END; {-- WHILE, Count>N}
13 NMax := First;
14 END; {-- NMax}
Les lignes 6 à 12 sont écrites dans un nouveau schéma d'instruction appelée instruction WHILE. Cette dernière est interprétée de la manière suivante:
"Tant que l'évaluation de la condition Count<=N donne la valeur True, exécuter l'instruction suivant le mot réservé DO. Dès que l'évaluation de la condition donne False, poursuivre en séquence, c'est-à-dire, continuer après l'instruction WHILE.
Si à la première évaluation de la condition Count<=N celle-ci donne la valeur False, l'instruction suivant le mot réservé DO n'est jamais exécutée."
La structure WHILE - comme toute structure répétitive - est composée de trois éléments:
• d'une initialisation d'un compteur;
• d'une condition;
• d'un bloc d'instructions.
Toute modification d'un quelconque de ces trois éléments nécessite un contrôle de cohérence des deux autres.
Imaginons à titre d'exemple une autre initialisation dans la fonction NMax: Count := 0 à la place de Count := 1. Que se passe-t-il? Si par exemple N=0, c'est-à-dire, s'il s'agit de déterminer le maximum d'une suite ne renfermant aucun nombre, la condition de la répétitive sera vérifiée (0£0) et la fonction demandera à l'utilisateur d'introduire un réel.
Il faut donc aborder les structures répétitives avec une grande prudence:
• étudier soigneusement l'état du programme avant l'entrée dans la structure répétitive,
• s'assurer que la condition de sortie - ici Count<=N - sera effectivement réalisée à un certain moment et,
• déterminer avec précision l'état du programme à la sortie de la structure répétitive.
Un conseil:
Quand, pour une raison quelconque, on a modifié une partie respectivement d'un algorithme ou d'un programme, il est indispensable de vérifier que cette modification n'a pas eu d'effet "parasite", c'est-à-dire autre que celui recherché.
A l'heure actuelle, le mécanisme WHILE est le plus souvent implanté dans les langages de programmation évolués. Outre la variante WHILE, on envisage en Turbo-Pascal les variantes REPEAT et FOR. Ainsi, les lignes 6 à 12 de la fonction NMax peuvent être remplacées par:
Count := 1;
REPEAT
Write( 'Réel suivant: ' ); Readln( Next );
First := Max( First, Next );
I := I+1
UNTIL Count=N+1; {-- REPEAT, Count=N+1}
Les lignes précédentes sont interprétées comme suit:
"Exécuter les instructions encadrées par les parenthèses symboliques REPEAT et UNTIL aussi longtemps que l'évaluation de la condition Count=N+1 donne la valeur False. Dans ce cas, ces instructions sont exécutées toujours au moins une fois."
Une reformulation des lignes 6 à 12 de la fonction NMax s'écrit à l'aide de la structure FOR:
FOR Count:=1 TO N DO BEGIN
Write( 'Réel suivant: ' ); Readln( Next );
First := Max( First, Next);
END; {-- FOR}
Exercice: Indiquer le contenu des variables Next et Count durant l'exécution de la fonction NMax pour le fichier d'entrée suivant: 9 1 8 2 7 3 4 5 6 0
TERMES TECHNIQUES
• instruction WHILE
© Aflo Informatique , 2003-2004