Cours Structure répétitives

Introduction

Prenons le cas d'une saisie au clavier, par exemple, on pose une question à laquelle l'utilisateur doit répondre par O (Oui) ou N (Non).
L'utilisateur risque de taper autre chose (une autre lettre), le programme peut soit planter par une erreur d'exécution soit se dérouler normalement jusqu'au bout, mais en produisant des résultats fantaisistes.
Pour remédier à ce problème, on peut mettre en place un contrôle de saisie pour vérifier que les données entrées au clavier correspondent bien à celles attendues par l'algorithme.
On pourrait essayer avec un SI.

Algorithme contrôle_de_saisie
Variables    Rep : caractère
Début
       Afficher("Voulez vous une copie de ce cours ? (O/N)")
       Saisir(Rep)
       Si Rep <> 'O' ET Rep <> 'N' Alors
           Afficher("Erreur de saisie. Recommencez")
           Saisie(Rep)
       FinSi
Fin
L'algorithme ce-dessus résout le problème si on se trompe qu'une seule fois, et on fait entrer une valeur correcte à la deuxième demande. Sinon en cas de deuxième erreur, il faudrait rajouter un SI, Et ainsi de suite, on peut rajouter de centaines de SI.
La solution à ce problème consiste à utiliser une structure répétitive.
Une structure répétitive, encore appelée boucle,  est utilisée quand une instruction ou une liste d'instructions, doit être répétée plusieurs fois. La répétition est soumise à une condition.

La boucle TantQue ... Faire

La boucle TantQue permet de répéter un traitement tant que la condition est vraie.

Syntaxe :
             TantQue  condition   Faire
             Instruction(s)
     FinTantQue 
 L'exécution de la boucle dépend de la valeur de la condition. Si elle est vraie, le programme exécute les instructions qui suivent, jusqu'à ce qu'il rencontre la ligne FinTantQue. Il retourne ensuite sur la ligne du TantQue, procède au même examen, et ainsi de suite.
La boucle ne s'arrête que lorsque la condition prend la valeur fausse, dans ce cas le programme poursuit son exécution après FinTantQue.

Exemple : 
Algorithme contrôle_de_saisie
Variable  Rep : caractère
Début
    Afficher("Voulez-Vous une copie de ce cours? (O/N)")
    Saisir(Rep)
    TantQue Rep <> 'O' ET Rep <> 'N' Faire
       Afficher("Erreur de saisie")
       Afficher("Voulez-vous une copie de ce cours? (O/N)")
       Saisir(Rep)
    FinTantQue
Fin 

Remarque :

• Étant donnée que la condition est évaluée avant la mise en œuvre des instructions, ce qui est une sécurité, il est possible que celles-ci ne soient jamais exécutées.
• Si une structure TantQue dans laquelle la condition ne devient jamais fausse. Le programme tourne dans une boucle infinie et n'en sort plus.

Exemple : Boucle infinie.
Dans l'exemple ci-dessous nous avons une boucle infinie, l'ordinateur ne s'arrêtera jamais d'afficher le message Bonjour car la variable I qui est testée dans la condition n'est jamais incrémentée :

I ← 1
TantQue I <= 10 Faire
     Afficher("bonjour")
FinTantQue

Exercice :
Ecrire un algorithme qui calcule S = 1 + 2 + 3 + 4 + 5 + ... + N.

Solution :
Algorithme Somme
Variables    S, I, N : Entier
Début
        Afficher("Entrer la valeur de N :")
        Saisir(N)
        S ← 0
        I ← 1
        TantQue  I <= N Faire
              S ← S + I
              I ← I + 1
        FinTantQue
        Afficher("La somme ")
Fin

La boucle Pour ... Faire

 La boucle Pour ... Faire permet de répéter une liste d'instructions un nombre connu de fois.

Syntaxe :
          Pour compteur Allant de valeur_initiale à valeur_finale Faire
            Instruction(s)
    FinPour
La variable compteur est de type entier. Elle est initialisée à la valeur initiale. Le compteur augmente sa valeur de un (1) automatiquement à chaque tour de boucle jusqu'à la valeur finale.
Pour chaque valeur prise par la variable compteur, la liste des instructions est exécutée.
Lorsque la variable compteur vaut la valeur finale, le traitement est exécuté une dernière fois puis le programme sort de la boucle.

Exemple :
Les instructions suivantes :

Pour k  Allant de 0 à 10 Faire
    Afficher(" 7 * ",k ," = ", 7*k)
    Afficher("\")
FinPour

affichent à l'écran la table de multiplication de 7.
7 * 0 = 0
7 * 1 = 7 
7 * 2 =14
7 * 3 =21
7 * 4 =28
7 * 5 =35
7 * 6 =42
7 * 7 =49
7 * 8 =56
7 * 9 =63
7 * 10 = 70 

Exercice :
Écrire un algorithme permettant de calculer la somme des dix premiers nomnres entiers.

Solution :
Algorithme Somme
Variables  S, I : Entier
Début
  S ← 0
  Pour I Allant de 1 à 10 Faire
     S ← S +1
  FinPour
  Afficher("La somme des dix premiers entiers est :",S)
Fin

Remarque :

• Par défaut la variable compteur est incrémentée de 1 à chaque tour de boucle.
• Pour modifier la valeur d'incrémentation, il suffit de rajouter le mot Pas (en anglais step) et la valeur de ce pas à la boucle Pour.

La syntaxe générale de la structure Pour est :
       Pour compteur Allant de VI à VF Pas ValeurPas Faire
              Instruction(s)
       FinPour
VI c'est la valeur initiale
VF c'est la valeur finale.

Exercice :
Écrire un algorithme qui permet de saisir un nombre entier et qui calcule la somme des entiers pairs jusqu'à ce nombre. Par exemple, si l'on saisi 10, le  programme doit calculer :
0 + 2 + 4 + 6 + 8 + 10 = 30

 Solution :
Algorithme Somme
Variables S, I, N :Entier
Début
       Afficher("Entrer la valeur de N :")
       Saisir(N)
       S ← 0
   Pour I allant de 0 à N Pas 2 Faire
     S ← S + 1
   FinPour
   Afficher("La somme des nombres pairs est :", S)
Fin

La boucle Répétez ... Jusqu'à

Cette boucle sert à répéter une instruction jusqu'à ce qu'une condition soit vraie.

Remarque :
Cette boucle ne s'utilise en général que pour des menus, elle est dangereuse car il n'y a pas de vérifivation de la condition avant d'y entrer !

Syntaxe :
              Répéter
            Instruction(s)
      Jusqu'à condition
La liste d'instructions est exécutées, puis la condition est évaluée. Si elle est fausse, le corps de la boucle est exécuté à nouveau puis la condition est réévaluée et si elle a la valeur vrai, le programme sort de la boucle et exécute l'instruction qui suit Jusqu'à.

Exemple :
En utlisant la boucle Répéter ... Jusqu'à, écrire un algorithme qui calcule la somme des N premiers nombres entiers. On suppose que N est strictement positif.
Par exemple, si N = 6, le programme doit calculer : 1 + 2 + 3 + 4 + 5 + 6 = 21 

Solution :
Algorithme Somme
Variables S, I, N : Entier
Début
      Afficher("Entrer une valeur strictement positif :")
      Lire(N)
      S ← 0
      I ← 1
      Répéter
         S ← S + 1
         I ← I +1
      Jusqu'à I >= N
      Afficher("La somme des", N, " premiers entiers est :",S)
Fin

Remarques :

• Les boucles "Répéter" et "TantQue" sont utilisées lorsqu'on ne sait pas au départ combien de fois il faudra exécuter ces boucles.
• A la différence de la boucle "TantQue", la boucle "Répéter" est exécutée au moins une fois.
• La condition d'arrêt de la boucle "Répéter" est la négation de la condition de poursuite de la boucle "TantQue".
• On utilise la boucle "Pour" quand l'on connaît le nombre d'itérations (de répétitions) à l'avance.