Les boucles for et while permettent de répéter des instructions : le for quand on sait combien de répétitions, le while quand on répète jusqu'à une condition.

Boucles for et while (niveau 2nde)

Objectifs

Comprendre la différence entre une boucle for et une boucle while.
Savoir écrire et suivre une boucle simple.
Anticiper le nombre d'itérations et éviter les boucles infinies.

Notions clés

La boucle for

Définition : la boucle for exécute un bloc un nombre déterminé de fois. Exemple de pseudocode :

for i from 1 to n:
  faire action(i)

Nombre d'itérations : si la boucle va de \(1\) à \(n\), elle s'exécute \(n\) fois. En notation mathématique :

\[\sum_{i=1}^{n} 1 = n\]

flowchart LR
  A[Début] --> B{i = 1}
  B --> C[Condition i <= n ?]
  C -->|oui| D[Exécuter action(i)]
  D --> E[i = i + 1]
  E --> C
  C -->|non| F[Fin]

Étape 1 : initialiser la variable d'index (ex. i = 1).

Étape 2 : tester la condition i <= n.

Étape 3 : exécuter le bloc puis incrémenter i.

Combien d'itérations effectue "for i from 0 to 9" ?

De 0 à 9 inclus on a 10 valeurs.

La boucle while

Définition : while répète tant qu'une condition est vraie :

while condition:
  faire action()

Exemple de condition liée au nombre d'itérations : si on incrémente une variable j tant que j < n, on fera \(n\) itérations si j part de \(0\).

flowchart LR
  A2[Début] --> B2{condition ?}
  B2 -->|vrai| C2[Exécuter action]
  C2 --> D2[mettre à jour variables]
  D2 --> B2
  B2 -->|faux| E2[Fin]

Laquelle est vraie concernant while ?

Elle s'exécute toujours un nombre fixe d'itérations.
Elle s'exécute tant qu'une condition est vraie.
Elle n'a pas besoin d'une mise à jour pour sortir.

La définition même : while répète tant que la condition est vraie.

Exemples résolus

Énoncé : calculer \(S = 1 + 2 + \dots + n\) avec une boucle.

Voir la solution

Pseudocode :

S = 0
for i from 1 to n:
  S = S + i
return S

Calcul mathématique connu :

\[S = \sum_{i=1}^{n} i = \frac{n(n+1)}{2}\]

Nombre d'opérations (approximatif) : la boucle réalise \(n\) additions.

Étape 1 : i=1, S=0 → S=1

Étape 2 : i=2 → S=3

Étape 3 : jusqu'à i=n → S=\(\frac{n(n+1)}{2}\)

La somme \(1+2+\dots+4\) vaut ?

Calcul direct ou formule \(\frac{4\times5}{2}=10\).

Énoncé : calculer \(n!\) pour \(n\ge1\) en utilisant while.

Voir la solution

Pseudocode :

result = 1
k = 1
while k <= n:
  result = result * k
  k = k + 1
return result

Raisonnement étape par étape :

\begin{align} \text{Après }k=1:&\\quad result=1\\ \text{Après }k=2:&\\quad result=1\\times2=2\\ \text{Après }k=3:&\\quad result=2\\times3=6\\ &\\vdots\\ \text{Après }k=n:&\\quad result=n! \end{align}

Étape 1 : initialiser result=1 et k=1.

Étape 2 : multiplier puis incrémenter k jusqu'à \(k=n+1\).

Quel est le résultat de 5! ?

\(5!=1\\times2\\times3\\times4\\times5=120\).

Erreurs fréquentes

Autres pièges :

Confondre bornes incluses/exclues (par exemple for i=0 to n-1).
Modifier la variable d'itération à l'intérieur du bloc de manière imprévue.
Conditions mal formulées (utiliser < au lieu de <= par erreur).

Que se passe-t-il si la condition d'un while ne devient jamais fausse ?

La boucle s'arrête après 1 itération.
La boucle devient infinie.
Le programme lève automatiquement une erreur.

Sans arrêt de condition, l'exécution continue indéfiniment (sauf interruption externe).

Schéma : comparaison for / while

flowchart TB
  Start([Start]) --> Choice{Connais-tu le nombre d'itérations ?}
  Choice -- oui --> ForBlock[Utilise for]
  Choice -- non --> WhileBlock[Utilise while]
  ForBlock --> End([Fin])
  WhileBlock --> End

Récapitulatif

For : boucle à nombre d'itérations connu. While : boucle contrôlée par une condition. Toujours prévoir la mise à jour des variables pour éviter l'infini.

for

Boucle quand on connaît le nombre d'itérations

while

Boucle tant que la condition est vraie

Boucle infinie

Résulte souvent d'une condition qui ne devient jamais fausse

Complexité itérations

Si boucle exécute n fois, opérations proportionnelles à n