Comment choisir entre Pour, Tant que et Répéter

Plan de cours

Trois outils, une seule règle de choix

Vous savez écrire les trois boucles. Reste la question cruciale au bac : laquelle choisir ? Cette leçon donne une grille de décision claire et justifie chaque cas par des exemples concrets.

Objectifs d'apprentissage

• Comparer les trois structures
• Choisir et justifier
• Convertir entre structures
• Justifier dans une copie d'examen

Concepts clés

1. Critère « nombre connu » → Pour.
2. Critère « au moins une fois » → Répéter.
3. Critère « éventuellement zéro » → Tant que.
4. Équivalence théorique des trois ; choix pour la lisibilité.

Avant de commencer — qu'est-ce que vous savez déjà ?

• Q1. Donnez un exemple où Pour est manifestement le meilleur choix.
• Q2. Donnez un exemple où Tant que est nécessaire (pas convertible en Pour).
• Q3. Donnez un exemple où Répéter est plus naturel que Tant que.

1. Le contenu du cours

1.1 Tableau de synthèse

1.2 Arbre de décision

Connaît-on le nombre EXACT d'itérations à l'avance ?
│
├── OUI ────────────────────────────► Pour…Faire
│
└── NON
    │
    Le corps doit-il toujours s'exécuter au moins une fois ?
    │
    ├── OUI ──────────────────────────► Répéter…Jusqu'à
    │
    └── NON (peut ne pas s'exécuter) ──► Tant que…Faire

1.3 Les trois pour un même problème

Énoncé : calculer la somme des entiers de 1 à 100.

Version Pour (la plus naturelle)

somme ← 0
Pour i De 1 À 100 Faire
    somme ← somme + i
FinPour

Version Tant que

somme ← 0
i ← 1
Tant que i ≤ 100 Faire
    somme ← somme + i
    i ← i + 1
FinTantQue

Version Répéter

somme ← 0
i ← 1
Répéter
    somme ← somme + i
    i ← i + 1
Jusqu'à i > 100

Verdict. Les trois donnent somme = 5050. Mais la version Pour est manifestement la plus lisible parce que :

• le compteur est géré automatiquement,
• le nombre d'itérations (100) saute aux yeux,
• pas de risque d'oublier d'incrémenter i.

1.4 Quand Pour ne suffit pas

Cas 1 — sentinelle utilisateur

Énoncé : lire des entiers jusqu'à ce que l'utilisateur tape 0, calculer leur somme.

On ne sait pas combien de saisies l'utilisateur fera. Pour est exclu.

• Tant que : on lit une fois avant d'entrer, puis on lit dans le corps. ✅
• Répéter : on lit dans le corps, on sort si x = 0. ⚠️ Mais alors 0 est compté dans la somme (à moins de tester avant).

{ Version Tant que — propre }
somme ← 0
Lire(x)
Tant que x ≠ 0 Faire
    somme ← somme + x
    Lire(x)
FinTantQue

Cas 2 — recherche conditionnelle

Énoncé : trouver le premier multiple de 7 supérieur à 1000.

On ne sait pas combien d'itérations seront nécessaires.

n ← 1001
Tant que n mod 7 ≠ 0 Faire
    n ← n + 1
FinTantQue
Écrire(n)    { 1001 → premier multiple ? Non. Continue. }

Réponse : 1001 mod 7 = 6, donc n = 1002, 1003, …, 1008. 1008 mod 7 = 0. ✅

Cas 3 — validation de saisie

Énoncé : lire une note valide entre 0 et 20.

On doit lire au moins une fois.

Répéter
    Lire(note)
Jusqu'à note ≥ 0 ET note ≤ 20

Répéter exprime parfaitement l'intention : « lire, puis vérifier ». Avec Tant que, on devrait initialiser note à une valeur invalide artificielle, ce qui est moins propre.

1.5 Conversion entre structures

Toute boucle est convertible d'un type à un autre. Voici les recettes.

Pour i De a À b Faire X FinPour ⇄ Tant que

i ← a
Tant que i ≤ b Faire
    X
    i ← i + 1
FinTantQue

Répéter X Jusqu'à C ⇄ Tant que

X                  { première exécution }
Tant que NON C Faire
    X
FinTantQue

Tant que C Faire X FinTantQue ⇄ Répéter

Si C Alors
    Répéter
        X
    Jusqu'à NON C
FinSi

1.6 Trace comparée — somme de saisies positives

Saisies : 5, 3, -1

Avec Tant que

Avec Répéter (et test pour ne pas accumuler la sentinelle)

somme ← 0
Répéter
    Lire(x)
    Si x > 0 Alors
        somme ← somme + x
    FinSi
Jusqu'à x ≤ 0

Verdict. La version Tant que est plus directe car la condition de boucle et la condition d'accumulation sont la même. Avec Répéter, il faut un Si interne — plus de code, plus de risque d'erreur.

2. Exercices pratiques

Niveau Débutant — Type bac courant

Niveau Intermédiaire — Type bac difficile

puissance ← 1
Pour i De 0 À 10 Faire
    Écrire(puissance)
    puissance ← puissance × 2
FinPour

puissance ← 1
i ← 0
Tant que i ≤ 10 Faire
    Écrire(puissance)
    puissance ← puissance × 2
    i ← i + 1
FinTantQue

puissance ← 1
i ← 0
Répéter
    Écrire(puissance)
    puissance ← puissance × 2
    i ← i + 1
Jusqu'à i > 10

Niveau Avancé — Hors bac (bonus)

x_0 = a
x_{n+1} = (x_n + a / x_n) / 2

0) Début newton
1) Lire(a)
2) x ← a
3) epsilon ← 1e-9
4) etapes ← 0
5) Répéter
       x_new ← (x + a / x) / 2
       ecart ← abs(x_new - x)
       x ← x_new
       etapes ← etapes + 1
   Jusqu'à ecart < epsilon
6) Écrire("racine(", a, ") ≈", x, "en", etapes, "étapes")
7) Fin newton

a = float(input("a > 0 : "))
x = a
epsilon = 1e-9
etapes = 0
while True:
    x_new = (x + a / x) / 2
    ecart = abs(x_new - x)
    x = x_new
    etapes += 1
    if ecart < epsilon:
        break
print(f"racine({a}) ≈ {x} en {etapes} étapes")

import math
print(f"math.sqrt({a}) = {math.sqrt(a)}")

⚠️ Erreurs fréquentes au bac

Avant le quiz, mémorisez ces pièges classiques qui font perdre des points :

• Erreur 1. Utiliser Pour quand le nombre d'itérations dépend d'une condition (saisie utilisateur, recherche). Choisir Tant que ou Répéter.
• Erreur 2. Utiliser Tant que pour une validation de saisie (mot de passe). Répéter est plus naturel : on doit lire AU MOINS une fois.
• Erreur 3. Ne pas justifier le choix de la structure dans la copie. Même un code correct perd des points sans justification.
• Erreur 4. Confondre la conversion Répéter X Jusqu'à C ⇄ Tant que NON C Faire X FinTantQue : appliquer la négation logique de la condition.

3. Quiz de vérification

En résumé

• ✅ Pour : nombre d'itérations connu.
• ✅ Tant que : pré-test, possibilité de zéro exécution.
• ✅ Répéter : post-test, au moins une exécution.
• ✅ Toujours justifier le choix en une phrase dans la copie.

Prochain chapitre : Sous-programmes — décomposer un problème en modules réutilisables.