# Compter avec des Boucles
## Introduction
L'algorithmique est l'art de résoudre des problèmes de manière systématique. Une tâche fondamentale et récurrente en programmation est la répétition d'une séquence d'instructions. Les **boucles** sont les structures de contrôle qui permettent cette répétition, souvent dans le but de "compter" des occurrences, d'itérer sur des collections de données, ou d'exécuter des actions un nombre spécifique ou conditionnel de fois.
Ce chapitre explore les différents types de boucles et leurs mécanismes pour gérer des processus itératifs, en s'appuyant sur les concepts de logique combinatoire et d'algorigrammes pour visualiser et structurer ces répétitions.
> [!video] Vidéo explicative
> <iframe width="560" height="315" src="https://www.youtube.com/embed/7d2Gf6DFwZg?si=sM_8mvIKuT178WhA" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
## 1. Le Concept d'Itération
> [!definition] Itération
> L'**itération** désigne le processus de répétition d'une séquence d'opérations ou d'instructions. Chaque répétition est appelée une "itération". Les boucles sont les outils algorithmiques pour implémenter l'itération.
L'itération est au cœur de nombreux algorithmes, permettant de traiter de grandes quantités de données, d'effectuer des calculs répétitifs ou de simuler des processus.
## 2. Les Types de Boucles pour Compter
Il existe principalement trois types de boucles, chacune adaptée à des scénarios spécifiques de comptage ou de répétition.
### 2.1. La Boucle `POUR` (ou `FOR`)
La boucle `POUR` est utilisée lorsque le nombre d'itérations est connu à l'avance ou peut être déterminé par une plage définie. Elle est idéale pour compter de manière prédictible.
> [!theorem] Principe de la boucle `POUR`
> La boucle `POUR` exécute un bloc d'instructions un nombre fixe de fois, en utilisant généralement une variable d'itération qui prend des valeurs successives dans un intervalle donné.
**Pseudo-code :**
```
POUR variable DE debut À fin [PAS pas] FAIRE
{
// Instructions à répéter
}
```
- `variable` : Variable d'itération (souvent appelée compteur ou index).
- `debut` : Valeur initiale de la variable.
- `fin` : Valeur finale (inclusive ou exclusive selon l'implémentation du langage) que la variable peut atteindre.
- `pas` (optionnel) : Incrément ou décrément de la variable à chaque itération. Par défaut, le pas est de 1.
> [!example] Exemple : Compter de 1 à 5
>
> ```
> POUR i DE 1 À 5 FAIRE
> {
> AFFICHER "Compteur : ", i
> }
> ```
> **Sortie attendue :**
> Compteur : 1
> Compteur : 2
> Compteur : 3
> Compteur : 4
> Compteur : 5
> [!note] Remarque sur la variable d'itération
> La variable d'itération (`i` dans l'exemple) est automatiquement gérée par la boucle. Sa portée et sa valeur après la boucle peuvent varier selon les langages de programmation.
### 2.2. La Boucle `TANT QUE` (ou `WHILE`)
La boucle `TANT QUE` est utilisée lorsque le nombre d'itérations n'est pas connu à l'avance et dépend d'une condition qui doit rester vraie pour que la boucle continue. La condition est évaluée *avant* chaque exécution du corps de la boucle.
> [!theorem] Principe de la boucle `TANT QUE`
> La boucle `TANT QUE` exécute un bloc d'instructions tant qu'une condition spécifiée est vraie. Si la condition est fausse dès le départ, le bloc n'est jamais exécuté.
**Pseudo-code :**
```
TANT QUE condition FAIRE
{
// Instructions à répéter
}
```
- `condition` : Expression logique qui doit être vraie pour que la boucle continue.
> [!example] Exemple : Compter jusqu'à une valeur aléatoire
>
> ```
> entier compteur <- 0
> entier valeur_limite <- GENERER_NOMBRE_ALEATOIRE_ENTRE(1, 10)
>
> TANT QUE compteur < valeur_limite FAIRE
> {
> AFFICHER "Compteur : ", compteur
> compteur <- compteur + 1
> }
> AFFICHER "La limite (", valeur_limite, ") a été atteinte."
> ```
> Dans cet exemple, le nombre d'itérations dépend de la valeur aléatoire générée, qui n'est pas connue à l'avance.
> [!warning] Attention aux boucles infinies
> Si la condition de la boucle `TANT QUE` ne devient jamais fausse, la boucle s'exécutera indéfiniment, provoquant un blocage du programme. Assurez-vous toujours qu'une instruction à l'intérieur de la boucle puisse modifier la condition pour qu'elle devienne fausse à un moment donné.
## 3. Mécanismes de Comptage dans les Boucles
Le "comptage" au sein des boucles implique généralement la modification d'une variable numérique à chaque itération.
- **Incrémentation :** Augmenter la valeur d'un compteur.
Ex: `compteur <- compteur + 1` ou `compteur++` (notation fréquente en programmation).
- **Décrémentation :** Diminuer la valeur d'un compteur.
Ex: `compteur <- compteur - 1` ou `compteur--`.
Ces opérations sont fondamentales pour suivre le nombre d'itérations, parcourir des indices de tableaux, ou simuler des comptes à rebours.
> [!tip] Préparation pour Python
> Les concepts de boucles `POUR` et `TANT QUE` se traduisent directement en Python avec les mots-clés `for` et `while`.
## Résumé
Les boucles sont des structures de contrôle essentielles en algorithmique pour la répétition d'instructions, permettant de "compter" ou d'itérer.
- La boucle **`POUR`** est utilisée pour un nombre d'itérations *connu*.
- La boucle **`TANT QUE`** répète tant qu'une condition est *vraie*, et permet de compter le nombre d'itérations *réalisées*.
La maîtrise de ces structures est fondamentale pour la conception d'algorithmes efficaces et est un prérequis indispensable pour l'apprentissage de tout langage de programmation.
## 🗓️ Historique
> **Dernière mise à jour :** `26 octobre 2025`
> **Rédigé par :** [[Julien DUQUENNOY]]