Réaliser une boucle FOR-NEXT en Programmation Structurée
--------------------------------------------------------
Première partie
  Faire en structurée la boucle FOR-NEXT suivante:
       FOR i=1 TO 10
         <imprime la valeur de i>
       NEXT i
  Il existe plusieurs manières de résoudre ce problème .......
-------------------------------------------------------------------------------
BEGIN                       ' Exemple avec DO WHILE sur i < que 11
                            ' et impression AVANT incrément
DECLARE i AS Nibble         ' Déclaration de la variable du programme
LET i=1                     ' Initialisation de la valeur de i
DO WHILE i<11               ' Boucle tant que 'i' est plus petit que 11
  <imprime la valeur de i>  '   impression de la valeur de i
  LET i=i+1                 '   et incrémente 'i'
ENDDO                       ' Fin de la boucle
END
-------------------------------------------------------------------------------
BEGIN                       ' Exemple avec DO WHILE sur i < ou = à 10
                            ' et impression AVANT incrément
DECLARE i AS Nibble         ' Déclaration de la variable du programme
LET i=1                     ' Initialisation de la valeur de i
DO WHILE i<=10              ' Boucle tant que 'i' est plus petit ou égal à 10
  <imprime la valeur de i>  '   impression de la valeur de i

  LET i=i+1                 '   et incrémente 'i'

ENDDO                       ' Fin de la boucle

END

-------------------------------------------------------------------------------

BEGIN                       ' Exemple avec DO WHILE sur i < que 10

                            ' et Impression APRES incrément

DECLARE i AS Nibble         ' Déclaration de la variable du programme

LET i=0                     ' Initialisation de la valeur de i

DO WHILE i<10               ' Boucle tant que 'i' est plus petit que 10

  LET i=i+1                 '   incrémente 'i'

  <imprime la valeur de i>  '   puis impression de la valeur de i

ENDDO                       ' Fin de la boucle

END

-------------------------------------------------------------------------------

BEGIN                       ' Exemple avec DO WHILE sur i < ou = à 9

                            ' et Impression APRES incrément

DECLARE i AS Nibble         ' Déclaration de la variable du programme

LET i=0                     ' Initialisation de la valeur de i

DO WHILE i<=9               ' Boucle tant que 'i' est plus petit ou égal à 9

  LET i=i+1                 '   incrémente 'i'

  <imprime la valeur de i>  '   puis impression de la valeur de i

ENDDO                       ' Fin de la boucle

END

-------------------------------------------------------------------------------

BEGIN                       ' Exemple avec DO UNTIL jusqu'à ce que i > 10

                            ' et Impression AVANT incrément

DECLARE i AS Nibble         ' Déclaration de la variable du programme

LET i=1                     ' Initialisation de la valeur de i

DO                          ' Début de la boucle

  <imprime la valeur de i>  '   puis impression de la valeur de i

  LET i=i+1                 '   incrémente 'i'

UNTIL i>10                  ' Boucle jusqu'à ce que i soit > que 10

END

-------------------------------------------------------------------------------

BEGIN                       ' Exemple avec DO UNTIL jusqu'à ce que i = 11

                            ' et Impression AVANT incrément

DECLARE i AS Nibble         ' Déclaration de la variable du programme

LET i=1                     ' Initialisation de la valeur de i

DO                          ' Début de la boucle

  <imprime la valeur de i>  '   puis impression de la valeur de i

  LET i=i+1                 '   incrémente 'i'

UNTIL i=11                  ' Boucle jusqu'à ce que i soit = à 11

END

-------------------------------------------------------------------------------

BEGIN                       ' Exemple avec DO UNTIL jusqu'à ce que i > 9

                            ' et Impression APRES incrément

DECLARE i AS Nibble         ' Déclaration de la variable du programme

LET i=0                     ' Initialisation de la valeur de i

DO                          ' Début de la boucle

  LET i=i+1                 '   incrémente 'i'

  <imprime la valeur de i>  '   puis impression de la valeur de i

UNTIL i>9                   ' Boucle jusqu'à ce que i soit > que 9

END

-------------------------------------------------------------------------------

BEGIN                       ' Exemple avec DO UNTIL jusqu'à ce que i = 10

                            ' et Impression APRES incrément

DECLARE i AS Nibble         ' Déclaration de la variable du programme

LET i=0                     ' Initialisation de la valeur de i

DO                          ' Début de la boucle

  LET i=i+1                 '   incrémente 'i'

  <imprime la valeur de i>  '   puis impression de la valeur de i

UNTIL i=10                  ' Boucle jusqu'à ce que i soit = à 10

END

-------------------------------------------------------------------------------

Dans les diverses possibilités, des solutions telles que celle-çi : 

BEGIN

DECLARE i AS Nibble         ' Déclaration des variables du programme

DECLARE j AS Byte

LET i=0                     ' Initialisation des valeurs des variables

LET j=0

DO                          ' Début de la boucle

  LET i=i+1                 '   incrémente 'i'

  <imprime la valeur de i>  '   puis impression de la valeur de i

  IF i=10 THEN              '   Test de la valeur de i

    j=1                     '     et mise à jour de la variable de sortie

  ENDIF                     '   Fin du test de sortie de boucle

UNTIL j=1                  ' Boucle jusqu'à ce que j soit = à 1

END



Ne sont pas considérées comme étant "bonnes". La recherche de la solution

la plus éfficace doit toujours diriger le choix du programmeur. Et donc,

naturellement, ce genre de solution sera écartée après évaluation.

Deux variables, deux tests pour la sortie, alors que les solutions

précédentes présentaient l'avantage d'une variable et d'un test.















Deuxième partie

---------------

Faire en structurée la boucle FOR-NEXT suivante :



FOR i=a TO b STEP c

  <...>

  <Liste d'instructions>

  <...>

NEXT i



En cas de valeurs incohérentes, afficher un message d'erreur.



Pour cet exercice, les variables a,b,c et i sont supposées entières.



Voiçi une solution parmis plusieurs possibles .......

*******************************************************************************

BEGIN                          ' Début du programme



' Définition des variables utilisées a, b et c sont considérées comme

des constantes, et i est la variable de travail



DECLARE a AS Integer           ' Borne "inférieure"

DECLARE b AS Integer           ' Borne "supérieure"

DECLARE c AS Integer           ' Incrément du comptage

DECLARE i AS Integer           ' Variable de travail



LET a=<valeur de a>            ' Initialisation des "constantes"

LET b=<valeur de b>            ' avec les valeurs à tester

LET c=<valeur de c>



LET i=a                        ' Initialisation de la variable de travail



IF a<>b THEN                   ' Test si a est différent de 'b'

  IF a<b THEN                  '  Test si a est plus petit que 'b'

    IF c>0 THEN                '   Dans ce cas, 'c' doit être positif

      DO WHILE i<=b            '    Boucle tant que 'i' est plus petit que 'b'

        <...>                  '     Exécution

        <Liste d'instructions> '     de la liste

        <...>                  '     d'instructions

        LET i=i+c              '     et incrément de 'i' par 'c'

      ENDDO                    '    Fin de la boucle

    ELSE                       '   Si 'c' est nul ou négatif

      <Affiche "Erreur pour c> '    Affiche un message d'erreur

    ENDIF                      '   Fin du test de 'c positif'

  ELSE                         '  Si a est plus grand que 'b'

    IF c<0 THEN                '   Si 'c' est négatif

      DO WHILE i>=b            '    Boucle tant que 'i' est plus grand que 'b'

        <...>                  '     Exécution

        <Liste d'instructions> '     de la liste

        <...>                  '     d'instructions

        LET i=i+c              '     et diminution de 'i' de la valeur de 'c'

      ENDDO                    '    Fin de la boucle

    ELSE                       '   Si 'c' est nul ou positif

      <Affiche "Erreur pour c> '    Affiche un message d'erreur

    ENDIF                      '   Fin du cas ou 'c' est négatif

  ENDIF                        '  Fin du test de sens de la boucle

ELSE                           ' Si a est égal à b

  <Afficher "Erreur : a=b">    '   alors affiche un message d'erreur

ENDIF                          ' Fin de la comparaison de a avec b



END                            ' Fin du programme

-------------------------------------------------------------------------------







Et une autre pour le moins originale......

*******************************************************************************

BEGIN                          ' Début du programme



' Définition des variables utilisées a, b et c sont considérées comme

des constantes, et i est la variable de travail



DECLARE a AS Integer           ' Borne "inférieure"

DECLARE b AS Integer           ' Borne "supérieure"

DECLARE c AS Integer           ' Incrément du comptage

DECLARE i AS Integer           ' Variable de travail



LET a=<valeur de a>            ' Initialisation des "constantes"

LET b=<valeur de b>            ' avec les valeurs à tester

LET c=<valeur de c>



LET i=a                        ' Initialisation de la variable de travail



IF c=0 OR a=b THEN             ' Si c est égal à zéro ou a est égal à b

   <Affiche : "Impossible">    ' le comptage n'est pas possible !!

ELSE                           ' 

   IF c>0 XOR b>a THEN         ' Si c est positif et que simultanément

      <Affiche : "Impossible"> ' b est plus petit que a, ou si c est

                               ' négatif et que simultanément b est plus

                               ' grand que a, le comptage n'est pas possible

                               ' car il se termine avant de commencer !!

   ELSE                        ' Une fois les erreurs contrôlées

      DO WHILE i<b XOR b<a     ' Boucle de comptage tant que b et plus grand

                               ' que a, et que simultanément i est plus petit

                               ' que b, ou tant que b est plus petit que a,

                               ' et que simultanément i est plus grand que b

         <Affiche : i>         ' Affiche la valeur de i

         LET i = i+c           ' Incrémentation (ou décrémentation) du compteur

      ENDDO                    ' Fin de la boucle de comptage

   ENDIF                       ' Fin du test d'impossibilité

ENDIF                          ' Fin du test de "pas de comptage"



END                            ' Fin du programme