Boucle Tant Que (Non Bornée) | Algorithmique Seconde

Introduction

BOUCLE TANT QUE

Algorithmique et Programmation - Seconde

Découvrez les structures algorithmiques fondamentales

Algorithmique

Boucles

Logique

Définition de la boucle Tant Que

La boucle Tant Que

DÉFINITION MATHÉMATIQUE

Définition

La boucle Tant Que (en anglais While Loop) est une structure de contrôle qui permet de répéter un bloc d'instructions tant qu'une condition est vraie.

Elle est dite non bornée car on ne connaît pas à l'avance le nombre d'itérations.

Syntaxe générale :

Tant Que condition Faire

    Instructions à exécuter

Fin Tant Que

Condition

Instructions

🔄

Fonctionnement de la boucle Tant Que

Comment ça marche ?

PRINCIPE DE FONCTIONNEMENT

Étapes du processus

1 Évaluation de la condition : Avant chaque itération, on vérifie si la condition est vraie
2 Exécution du bloc : Si la condition est vraie, on exécute les instructions
3 Bouclage : On retourne à l'étape 1
4 Sortie : Quand la condition devient fausse, on sort de la boucle

Initialisation

Condition ?

Instructions

🔄

Attention à éviter les boucles infinies !

Exemple simple

Premier exemple

ALGORITHME SIMPLE

Afficher les nombres de 1 à 5

Variables : i (entier)

Début

 i ← 1

 Tant Que i ≤ 5 Faire

  Afficher i

  i ← i + 1

 Fin Tant Que

Fin

TRACE D'EXÉCUTION

Suivi pas à pas

Itération	i	Condition	Affichage
1	1	1 ≤ 5 (VRAI)	Affiche 1
2	2	2 ≤ 5 (VRAI)	Affiche 2
3	3	3 ≤ 5 (VRAI)	Affiche 3
4	4	4 ≤ 5 (VRAI)	Affiche 4
5	5	5 ≤ 5 (VRAI)	Affiche 5
6	6	6 ≤ 5 (FAUX)	Sortie

Conditions d'arrêt

Condition d'arrêt cruciale

IMPORTANCE DE LA CONDITION

Pourquoi la condition est-elle importante ?

La condition d'arrêt est essentielle pour éviter les boucles infinies.

À chaque itération, il faut que la variable testée dans la condition change de valeur pour qu'éventuellement la condition devienne fausse.

EXEMPLE DE BOUCLE INFINIE

Erreur courante

Variables : i (entier)

Début

 i ← 1

 Tant Que i ≤ 5 Faire

  Afficher i

  // i n'est jamais modifié !

 Fin Tant Que

Fin

Cet algorithme affichera indéfiniment le nombre 1.

Toujours modifier la variable dans la condition !

Applications concrètes

Utilisations concrètes

SITUATIONS RÉELLES

Quand utiliser une boucle Tant Que ?

1 Saisie contrôlée : Demander à l'utilisateur de saisir une donnée jusqu'à ce qu'elle soit correcte
2 Calcul itératif : Calculer une approximation par itérations successives
3 Recherche : Chercher un élément dans une structure de données
4 Simulation : Modéliser un phénomène qui continue jusqu'à une condition d'arrêt

EXEMPLE : SAISIE CONTRÔLÉE

Demander un nombre positif

Variables : nb (réel)

Début

 Afficher "Entrez un nombre positif"

 Lire nb

 Tant Que nb ≤ 0 Faire

  Afficher "Erreur ! Entrez un nombre positif"

  Lire nb

 Fin Tant Que

 Afficher "Merci, vous avez saisi ", nb

Fin

Comparaison avec la boucle Pour

Différences clés

BOUCLE POUR VS BOUCLE TANT QUE

Caractéristiques principales

Critère	Boucle Pour	Boucle Tant Que
Nombre d'itérations	Connu à l'avance	Inconnu à l'avance
Structure	Bornée	Non bornée
Utilisation	Répétition fixe	Répétition conditionnelle
Risque d'erreur	Moindre	Plus élevé

ÉQUIVALENCE ENTRE LES DEUX

Exemple d'équivalence

// Boucle Pour

Pour i de 1 à 5 Faire

 Afficher i

Fin Pour

// Équivalent avec Tant Que

i ← 1

Tant Que i ≤ 5 Faire

 Afficher i

 i ← i + 1

Fin Tant Que

Exemple complexe

Calcul de la racine carrée

MÉTHODE DE HÉRON

Algorithme de calcul d'une racine carrée

La méthode de Héron permet d'approcher la racine carrée d'un nombre positif N avec une précision donnée.

Formule de récurrence : x_n+1 = (x_n + N/x_n) / 2

ALGORITHME

Implémentation avec Tant Que

Variables : N, x, x_prec, precision (réels)

Début

 Afficher "Entrez un nombre positif N"

 Lire N

 x ← N / 2  // estimation initiale

 precision ← 0.0001

 x_prec ← 0

 Tant Que |x - x_prec| > precision Faire

  x_prec ← x

  x ← (x + N/x) / 2

 Fin Tant Que

 Afficher "La racine carrée de ", N, " est environ ", x

Fin

Exercice 1

Somme des termes

ÉNONCÉ

Question

Écrire un algorithme qui demande à l'utilisateur un nombre entier n strictement positif, puis calcule la somme des entiers de 1 à n (c'est-à-dire 1 + 2 + ... + n).

Utiliser une boucle Tant Que.

AIDE

Pistes de réflexion

Il faudra une variable pour stocker la somme
Il faudra une variable pour compter les itérations
La condition d'arrêt sera atteinte quand on aura traité tous les nombres de 1 à n

Solution exercice 1

Correction détaillée

ALGORITHME COMPLET

Solution pas à pas

Variables : n, i, somme (entiers)

Début

 Afficher "Entrez un nombre entier strictement positif"

 Lire n

 somme ← 0

 i ← 1

 Tant Que i ≤ n Faire

  somme ← somme + i

  i ← i + 1

 Fin Tant Que

 Afficher "La somme des entiers de 1 à ", n, " est ", somme

Fin

TRACE D'EXÉCUTION POUR N=4

Suivi pas à pas

Itération	i	somme	Condition
Initial	1	0	-
1	1	1	1 ≤ 4 (VRAI)
2	2	3	2 ≤ 4 (VRAI)
3	3	6	3 ≤ 4 (VRAI)
4	4	10	4 ≤ 4 (VRAI)
5	5	10	5 ≤ 4 (FAUX)

Le résultat est donc 10 = 1 + 2 + 3 + 4.

Exercice 2

Recherche de seuil

ÉNONCÉ

Question

Écrire un algorithme qui recherche le plus petit entier n tel que 2ⁿ dépasse 1000.

Utiliser une boucle Tant Que.

AIDE

Pistes de réflexion

Commencer avec n = 0 et 2ⁿ = 1
Augmenter n tant que 2ⁿ ≤ 1000
Attention à ne pas créer de boucle infinie

Solution exercice 2

Correction détaillée

ALGORITHME COMPLET

Solution pas à pas

Variables : n, puissance (entiers)

Début

 n ← 0

 puissance ← 1  // 2^0 = 1

 Tant Que puissance ≤ 1000 Faire

  n ← n + 1

  puissance ← puissance * 2  // Multiplier par 2 pour avoir 2^n

 Fin Tant Que

 Afficher "Le plus petit n tel que 2^n > 1000 est ", n

 Afficher "2^", n, " = ", puissance

Fin

TRACE D'EXÉCUTION

Suivi pas à pas

Itération	n	puissance	Condition
Initial	0	1	-
1	1	2	2 ≤ 1000 (VRAI)
2	2	4	4 ≤ 1000 (VRAI)
...	...	...	...
10	10	1024	1024 ≤ 1000 (FAUX)

Le résultat est n = 10, car 2¹⁰ = 1024 > 1000 et 2⁹ = 512 ≤ 1000.

Erreurs fréquentes

Pièges à éviter

ERREURS COMMUNES

Erreurs typiques avec les boucles Tant Que

1 Oublier de modifier la variable de la condition → boucle infinie
2 Mauvaise condition de départ → la boucle ne s'exécute jamais
3 Confusion entre ≤, <, ≥, > → résultats incorrects
4 Ne pas initialiser correctement les variables → comportement imprévisible

EXEMPLES D'ERREURS

Erreurs typiques et corrections

// ERREUR : Boucle infinie

i ← 1

Tant Que i ≤ 5 Faire

 Afficher i

 // i n'est pas modifié !

Fin Tant Que

// CORRECTION :

i ← 1

Tant Que i ≤ 5 Faire

 Afficher i

 i ← i + 1  // Modification de i

Fin Tant Que

Optimisation et bonnes pratiques

Meilleures pratiques

BONNES PRATIQUES

Comment bien utiliser les boucles Tant Que

1 Toujours initialiser les variables avant la boucle
2 Modifier la variable de la condition à chaque itération
3 Tester la boucle avec des cas limites
4 Choisir la bonne boucle (Pour vs Tant Que) selon le besoin
5 Documenter la logique de la condition d'arrêt

EXEMPLE DE BONNE STRUCTURE

Modèle de structure claire

// Initialisation des variables

variable ← valeur_initiale

// Boucle avec condition d'arrêt claire

Tant Que condition_d_arret Faire

 // Corps de la boucle

 instructions

 // Mise à jour de la variable de la condition

 variable ← nouvelle_valeur

Fin Tant Que

Résumé

Points clés

CONCEPTS FONDAMENTAUX

Caractéristiques de la boucle Tant Que

Structure de contrôle itérative non bornée
Condition évaluée avant chaque itération
Nombre d'itérations inconnu à l'avance
Nécessite une condition d'arrêt bien formulée
Peut causer des boucles infinies si mal gérée

UTILISATIONS COURANTES

Quand l'utiliser ?

Saisie contrôlée
Calculs itératifs
Recherche d'éléments
Simulations
Traitements conditionnels

Maîtrisez la boucle Tant Que pour des algorithmes robustes !

Conclusion

Félicitations !

FÉLICITATIONS !

MAÎTRISE DE LA BOUCLE TANT QUE

Vous comprenez maintenant les boucles non bornées !

Continuez à pratiquer pour renforcer vos compétences en algorithmique

Compris

Retenu

Appliqué