Module 2.3 – Boucles

Objectif

Maîtriser les boucles POUR et TANT QUE. Comprendre quand utiliser chaque type de boucle et résoudre des cas réels (répétition, listes).

Théorie

Boucle POUR (For)

La boucle POUR répète un bloc de code un nombre fixe de fois.

Structure :

POUR variable DE début À fin FAIRE
    instructions
FIN POUR

Exemple : Afficher les nombres de 1 à 5

POUR i DE 1 À 5 FAIRE
    AFFICHER i
FIN POUR

Résultat : 1, 2, 3, 4, 5

Comment ça fonctionne :

1. i commence à 1
2. Exécute les instructions (affiche 1)
3. i devient 2
4. Exécute les instructions (affiche 2)
5. Continue jusqu'à ce que i atteigne 5
6. S'arrête

Boucle POUR avec pas

On peut spécifier l'incrément (le pas) :

POUR i DE 0 À 10 PAR PAS DE 2 FAIRE
    AFFICHER i
FIN POUR

Résultat : 0, 2, 4, 6, 8, 10

Boucle POUR décroissante

Compter à l'envers :

POUR i DE 10 À 1 FAIRE
    AFFICHER i
FIN POUR

Résultat : 10, 9, 8, 7, 6, 5, 4, 3, 2, 1

Boucle TANT QUE (While)

La boucle TANT QUE répète un bloc de code tant qu'une condition est vraie.

Structure :

TANT QUE condition FAIRE
    instructions
FIN TANT QUE

Exemple : Compter jusqu'à 10

compteur ← 1
TANT QUE compteur <= 10 FAIRE
    AFFICHER compteur
    compteur ← compteur + 1
FIN TANT QUE

Résultat : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

Important : Il faut modifier la condition dans la boucle, sinon boucle infinie !

Boucle infinie (à éviter)

compteur ← 1
TANT QUE compteur <= 10 FAIRE
    AFFICHER compteur
    // Oubli d'incrémenter compteur !
FIN TANT QUE

Cette boucle ne s'arrêtera jamais car compteur reste toujours 1.

Quand utiliser POUR vs TANT QUE ?

Utiliser POUR quand :

• On connaît le nombre exact d'itérations
• On parcourt une liste/tableau avec un index
• On veut répéter un nombre fixe de fois

Exemples :

• Afficher les nombres de 1 à 100
• Parcourir tous les éléments d'un tableau
• Répéter une action 5 fois

Utiliser TANT QUE quand :

• On ne connaît pas le nombre d'itérations à l'avance
• On dépend d'une condition externe
• On attend une action de l'utilisateur

Exemples :

• Demander un mot de passe jusqu'à ce qu'il soit correct
• Lire des données jusqu'à la fin d'un fichier
• Répéter jusqu'à ce que l'utilisateur tape "quitter"

Cas réels

Cas 1 : Calculer la somme d'une liste

Problème : Additionner tous les nombres d'une liste

liste ← [5, 10, 15, 20, 25]
somme ← 0
POUR i DE 0 À longueur(liste) - 1 FAIRE
    somme ← somme + liste[i]
FIN POUR
AFFICHER "Somme : " + somme

Résultat : 75

Cas 2 : Chercher un élément dans une liste

Problème : Trouver si un nombre existe dans une liste

liste ← [3, 7, 12, 5, 9]
nombre_recherche ← 5
trouve ← false
i ← 0

TANT QUE i < longueur(liste) ET trouve == false FAIRE
    SI liste[i] == nombre_recherche ALORS
        trouve ← true
    FIN SI
    i ← i + 1
FIN TANT QUE

SI trouve ALORS
    AFFICHER "Nombre trouvé à la position " + (i - 1)
SINON
    AFFICHER "Nombre non trouvé"
FIN SI

Cas 3 : Validation de saisie utilisateur

Problème : Demander un nombre valide à l'utilisateur

nombre ← -1
TANT QUE nombre < 0 OU nombre > 100 FAIRE
    LIRE nombre
    SI nombre < 0 OU nombre > 100 ALORS
        AFFICHER "Erreur : entrez un nombre entre 0 et 100"
    FIN SI
FIN TANT QUE
AFFICHER "Nombre valide : " + nombre

Cas 4 : Table de multiplication

Problème : Afficher la table de multiplication d'un nombre

LIRE nombre
POUR i DE 1 À 10 FAIRE
    resultat ← nombre * i
    AFFICHER nombre + " x " + i + " = " + resultat
FIN POUR

Avec nombre = 7 :

• 7 x 1 = 7
• 7 x 2 = 14
• 7 x 3 = 21
• ... jusqu'à 7 x 10 = 70

Boucles imbriquées

On peut mettre une boucle dans une boucle.

Exemple : Table de multiplication complète

POUR i DE 1 À 10 FAIRE
    POUR j DE 1 À 10 FAIRE
        resultat ← i * j
        AFFICHER i + " x " + j + " = " + resultat
    FIN POUR
    AFFICHER "---"  // Séparateur entre les tables
FIN POUR

Attention : Les boucles imbriquées peuvent être lentes si le nombre d'itérations est grand.

Exercice

1. Boucle POUR simple

   • Écrivez une boucle POUR qui affiche les nombres pairs de 2 à 20

2. Boucle TANT QUE

   • Écrivez une boucle TANT QUE qui demande un mot de passe jusqu'à ce que l'utilisateur entre "secret123"

3. Parcourir une liste

   • Écrivez un algorithme qui parcourt une liste de noms et affiche chacun d'eux

4. Calcul avec boucle

   • Écrivez un algorithme qui calcule la factorielle d'un nombre n (n! = 1 × 2 × 3 × ... × n)

5. Boucle avec condition

   • Écrivez un algorithme qui affiche tous les multiples de 3 entre 1 et 50

Quiz

1. Quelle boucle utiliser pour répéter exactement 10 fois ?

   • POUR
   • TANT QUE
   • Les deux fonctionnent

2. Que se passe-t-il si on oublie d'incrémenter le compteur dans une boucle TANT QUE ?

   • Le programme s'arrête
   • Boucle infinie
   • Erreur de syntaxe

3. Combien de fois s'exécute cette boucle : POUR i DE 1 À 5 FAIRE ?

   • 4 fois
   • 5 fois
   • 6 fois

4. Quand utiliser TANT QUE plutôt que POUR ?

   • Jamais, POUR est toujours mieux
   • Quand on ne connaît pas le nombre d'itérations à l'avance
   • Quand on veut aller plus vite

5. Que signifie "boucles imbriquées" ?

   • Des boucles qui ne fonctionnent pas
   • Une boucle à l'intérieur d'une autre boucle
   • Des boucles parallèles

Mini défi

Mission : Créer un système de gestion de notes

Créez un algorithme complet en pseudo-code qui :

1. Demande des notes à l'utilisateur

   • Demander combien de notes l'utilisateur veut entrer
   • Demander chaque note (entre 0 et 20)
   • Valider que chaque note est entre 0 et 20 (redemander si invalide)
   • Stocker toutes les notes dans une liste

2. Calcule des statistiques

   • La moyenne de toutes les notes
   • La note la plus haute
   • La note la plus basse
   • Le nombre de notes supérieures ou égales à 10

3. Affiche les résultats

   • Afficher toutes les statistiques calculées
   • Afficher un message selon la moyenne :

     • = 16 : "Excellent"

     • = 14 : "Très bien"

     • = 12 : "Bien"

     • = 10 : "Assez bien"

     • < 10 : "À améliorer"

Critères :

• ✅ Utiliser au moins une boucle POUR
• ✅ Utiliser au moins une boucle TANT QUE (pour la validation)
• ✅ Utiliser des conditions (SI/SINON)
• ✅ Gérer les cas d'erreur (notes invalides)
• ✅ Code clair et bien structuré

Exemple d'exécution :

Combien de notes ? 5
Note 1 : 15
Note 2 : 18
Note 3 : 12
Note 4 : 8
Note 5 : 20

Résultats :
- Moyenne : 14.6
- Note max : 20
- Note min : 8
- Notes >= 10 : 4
- Appréciation : Très bien

Objectif : Maîtriser les boucles et les combiner avec des conditions pour résoudre des problèmes complexes.

---

Validation : Vous pouvez passer au module suivant quand vous maîtrisez les boucles POUR et TANT QUE et pouvez les utiliser dans des cas pratiques.