Les Structures itératives

Cette séance aborde les structures itératives en algorithmique, essentielles pour répéter des instructions dans un programme. Elle s’inscrit dans un cours d’initiation à la programmation et présente les boucles "TANT QUE", "REPETER ... JUSQU'A", ainsi que les boucles imbriquées. Des exemples concrets illustrent leur fonctionnement et leurs usages.

La structure TANT QUE ... FAIRE

La boucle TANT QUE ... FAIRE exécute une séquence d’instructions tant qu’une condition logique est vraie. Si la condition est fausse dès le départ, la boucle ne s’exécute pas du tout.

Sa syntaxe est :

TANT QUE <Condition> FAIRE
<Séquence d’instructions>
FIN TANT QUE

Le principe est que la condition est testée avant chaque exécution de la séquence.

Un organigramme classique montre la condition testée en premier, puis la séquence d’instructions si la condition est vraie, sinon la suite du programme.

Exemples d’utilisation

Exemple 1 : Un algorithme demande à l’utilisateur de saisir un entier tant que celui-ci n’est pas égal à zéro :

Algorithme TEST
VAR
  i (entier)
Début
  Ecrire ("donnez un entier S.V.P")
  Lire (i)
  Tant que i <> 0 FAIRE
    Ecrire ("donnez un entier S.V.P")
    Lire (i)
  Fin tant que
Fin

La boucle continue tant que l’utilisateur ne saisit pas zéro. Le nombre d’itérations n’est pas connu à l’avance.

Exemple 2 : Affichage des multiples de 10 de 10 à 50 :

i ← 1
Tant que i ≤ 5 FAIRE
  ECRIRE (i * 10)
  i ← i + 1
Fin tant que

Ce programme affiche successivement 10, 20, 30, 40, 50. Ici, le nombre d’itérations est connu à l’avance.

Exemple 3 : Si la condition est fausse dès le départ :

i ← 6
Tant que i ≤ 5 FAIRE
  ECRIRE (i * 10)
  i ← i + 1
Fin tant que

Aucune valeur n’est affichée car la condition est fausse dès le début.

Exemple 4 : Une boucle sans modification de la variable de contrôle :

i ← 1
Tant que i ≤ 5 FAIRE
  ECRIRE (i * 10)
Fin tant que

Cette boucle tourne indéfiniment car la variable i n’est jamais modifiée, ce qui crée une boucle infinie.

Exemple 5 : Une boucle avec modification incorrecte de la variable :

i ← 1
Tant que i ≤ 5 FAIRE
  ECRIRE (i * 10)
  i ← i * 2
Fin tant que

Les valeurs affichées sont 10, 20, 40. La boucle s’arrête car i dépasse 5 après quelques itérations.

Exemples d’algorithmes classiques avec TANT QUE

Calcul du factoriel :

Algorithme Facto
VAR
  n, f, i (Entier)
DEBUT
  Lire(n)
  f ← 1
  i ← n
  Tant que i ≥ 1 Faire
    f ← f * i
    i ← i - 1
  Fin Tant que
  Ecrire(n, " ! = ", f)
FIN.

Affichage des diviseurs d’un nombre :

Algorithme Diviseurs
VAR
  n, i (Entier)
DEBUT
  Lire(n)
  i ← 1
  Tant que i ≤ n Faire
    Si n Mod i = 0 Alors
      Ecrire(i)
    Fin Si
    i ← i + 1
  Fin Tant que
FIN

La structure REPETER ... JUSQU'A

La boucle REPETER ... JUSQU'A exécute la séquence d’instructions au moins une fois, puis répète cette exécution jusqu’à ce que la condition soit vraie. La condition est testée après l’exécution de la séquence.

Syntaxe :

REPETER
  <Séquence d’instructions>
JUSQU'A <Condition>

Le schéma montre que la séquence est exécutée en premier, puis la condition est testée. Si la condition est fausse, la séquence est répétée.

Exemples

Exemple 1 : Affichage des multiples de 10 de 10 à 50 :

i ← 1
REPETER
  ECRIRE (i * 10)
  i ← i + 1
JUSQU'A (i > 5)

Exemple 2 : Si la condition est fausse dès le départ :

i ← 6
REPETER
  ECRIRE (i * 10)
  i ← i + 1
JUSQU'A (i > 5)

La boucle s’exécute une fois et affiche 60, car la condition n’est testée qu’après la première exécution.

Exemple 3 : Boucle infinie :

i ← 1
REPETER
  ECRIRE (i * 10)
JUSQU'A (i > 5)

La boucle tourne indéfiniment car i n’est jamais modifié et la condition ne sera jamais vraie.

Remarque : Il faut toujours s’assurer que la condition de sortie sera vérifiée après un nombre fini d’itérations pour éviter les boucles infinies.

Exemples d’algorithmes classiques avec REPETER ... JUSQU'A

Calcul des diviseurs :

ALGORITHME Diviseurs
VAR
  n, i (Entier)
DEBUT
  Lire(n)
  i ← 1
  Répéter
    Si n Mod i = 0 Alors
      Ecrire(i)
    FinSi
    i ← i + 1
  Jusqu’à (i > n)
FIN

Calcul du factoriel :

ALGORITHME Factoriel
VAR
  n, f, i (Entier)
DEBUT
  Lire(n)
  f ← 1
  i ← n
  Si n > 0 Alors
    Répéter
      f ← f * i
      i ← i - 1
    Jusqu’à (i ≤ 1)
  FinSi
  Ecrire(n, "! = ", f)
FIN

Boucles imbriquées

Une boucle imbriquée est une boucle placée à l’intérieur d’une autre boucle. Cette structure est utile pour traiter des ensembles d’objets nécessitant un traitement répétitif multiple.

Exemple : Calcul de la moyenne des notes d’un étudiant, puis calcul des moyennes sur une classe :

Algo Moyennes
Var
  moyEtud, moyClass, note (réel)
  nbrEtud, nbrNote, i, j (entier)
Début
  écrire ("donnez le nombre d'étudiants")
  lire(nbrEtud)
  écrire ("donnez le nombre de notes par étudiant")
  lire(nbrNote)
  moyClass ← 0

  pour i de 1 à nbrEtud faire
    moyEtud ← 0
    j ← 1
    Tant que j ≤ nbrNote
      écrire ("donnez la note numéro ", j, " de l'étudiant numéro ", i)
      lire (note)
      moyEtud ← moyEtud + note / nbrNote
      j ← j + 1
    Fin Tant que
    écrire ("la moyenne de l'étudiant numéro ", i, " est ", moyEtud)
    moyClass ← moyClass + (moyEtud / nbrEtud)
  Fin pour

  écrire ("la moyenne de la classe est ", moyClass)
fin

Dans cet exemple, une boucle "Pour" extérieure parcourt les étudiants, et une boucle "Tant que" intérieure parcourt les notes de chaque étudiant.

De manière générale, deux boucles peuvent être soit disjointes (exécutées l’une après l’autre), soit imbriquées (l’une à l’intérieur de l’autre). Le schéma d’une imbrication interdit que les boucles soient parallèles sans relation.

Attention : Lorsque la boucle extérieure est une boucle "Pour", la boucle intérieure ne doit pas modifier l’indice de la boucle extérieure. De plus, si deux boucles "Pour" sont imbriquées, leurs indices doivent porter des noms différents pour éviter toute confusion.

Passage d’une structure itérative à une autre

Il est possible de traduire une boucle "Pour" en boucle "Répéter" ou "Tant que" :

Pour cpt de vi à vf Faire
  Traitement
Fin Pour

équivaut à

cpt ← vi
Répéter
  Traitement
  cpt ← suivant(cpt)
Jusqu’à (cpt > vf)

ou

cpt ← vi
Tant Que (cpt ≤ vf) Faire
  Traitement
  cpt ← suivant(cpt)
Fin Tant que

Remarque : Le passage d’une boucle "Répéter" à une boucle "Pour" n’est pas toujours possible, notamment lorsque le nombre d’itérations n’est pas connu à l’avance.

Choix de la structure itérative

Nombre d’itérations connu à l’avance	Traitement s’exécute au moins une fois	Structure recommandée
Oui	Oui	Boucle "Pour"
Oui	Non	Boucle "Tant que"
Non	Oui	Boucle "Répéter"
Non	Non	Boucle "Tant que"

Applications proposées

Travail 1 : Un nombre parfait est un nombre égal à la somme de tous ses diviseurs, excepté lui-même. Par exemple, 6 = 3 + 2 + 1 est un nombre parfait. Écrire un algorithme qui affiche tous les nombres parfaits inférieurs à 1000.

Travail 2 : Écrire un algorithme qui lit deux entiers A et B puis calcule et affiche leur PGCD (Plus Grand Commun Diviseur) en utilisant la méthode suivante :

• Si A = B, alors PGCD(A, B) = A
• Si A > B, alors PGCD(A, B) = PGCD(A – B, B)
• Si B > A, alors PGCD(A, B) = PGCD(A, B – A)

Points clés

• La boucle TANT QUE teste la condition avant d’exécuter la séquence d’instructions. Elle peut ne jamais s’exécuter si la condition est fausse dès le départ.
• La boucle REPETER ... JUSQU'A exécute la séquence au moins une fois, puis teste la condition pour décider de continuer ou non.
• Une boucle infinie survient si la condition de sortie n’est jamais atteinte, souvent à cause d’une variable de contrôle non modifiée.
• Les boucles imbriquées permettent de traiter des ensembles complexes, comme des tableaux à deux dimensions ou des groupes d’objets avec plusieurs propriétés.
• Le choix entre "Pour", "Tant que" et "Répéter" dépend du nombre d’itérations connu et de la nécessité d’exécuter la boucle au moins une fois.
• Les algorithmes classiques comme le calcul du factoriel, l’affichage des diviseurs ou le calcul du PGCD utilisent fréquemment ces structures itératives.