Boucle tant que (non bornée) | Algorithmique et programmation | 10 Exercices corrigés

Concepts & Exercices

\(\text{while condition:}\)

\(\text{bloc d'instructions}\)

Structure de répétition conditionnelle

Structure de base

while condition:
action

Répète tant que vraie

Compteur

i = 0
while i < n:
i += 1

Inc. pour éviter infini

Initialisation

variable = valeur
while condition:
action

Nécessaire avant boucle

Sortie

condition devient
false

Fin de la boucle

🎯

Définition : Une boucle while répète un bloc tant qu'une condition est vraie.

🔗

Condition : Doit éventuellement devenir fausse pour éviter boucle infinie.

✅

Nombre variable : Le nombre d'itérations n'est pas connu à l'avance.

📊

Applications : Recherche, validation d'entrée, calculs itératifs.

💡

Conseil : Vérifiez que la condition peut devenir fausse à chaque itération

🔍

Attention : Boucle infinie si la condition ne change jamais

⚡

Astuce : Mettez à jour la variable dans la condition à chaque itération

📋

Méthode : Tracez les valeurs de la variable de contrôle à chaque tour

Exercice 1

Soit i = 0. Qu'affiche la boucle while i < 3: print(i); i += 1 ?

Exercice 2

Calculer la somme des entiers de 1 à 5 avec while

Exercice 3

Soit n = 10. Compter combien de fois on divise n par 2 avec while

Exercice 4

Trouver la racine carrée entière de 25 avec while

Exercice 5

Soit x = 100. Compter les divisions par 10 jusqu'à x < 1

Exercice 6

Calculer 2^8 avec while (multiplication répétée)

Exercice 7

Trouver le plus petit entier n tel que n² > 100

Exercice 8

Soit x = 1234. Compter le nombre de chiffres avec while

Exercice 9

Calculer la factorielle de 6 avec while

Exercice 10

Trouver le PGCD de 48 et 18 avec l'algorithme d'Euclide (while)

Corrigé : Exercices 1 à 5

1 Boucle while i < 3

Définition :

Boucle while : Répète un bloc tant qu'une condition est vraie.

Méthode d'évaluation :

Initialiser la variable de contrôle
Tester la condition avant chaque itération
Exécuter le bloc si condition vraie
Modifier la variable de contrôle
Répéter jusqu'à ce que la condition devienne fausse

Code Python

                i = 0

                while i < 3:

                  print(i)

                  i += 1

Étape 1 : Initialiser la variable

i = 0 avant la boucle

Étape 2 : Itération 1

Condition: i < 3 → 0 < 3 → VRAI

Action: print(0), puis i = 0 + 1 = 1

Étape 3 : Itération 2

Condition: i < 3 → 1 < 3 → VRAI

Action: print(1), puis i = 1 + 1 = 2

Étape 4 : Itération 3

Condition: i < 3 → 2 < 3 → VRAI

Action: print(2), puis i = 2 + 1 = 3

Étape 5 : Sortie de boucle

Condition: i < 3 → 3 < 3 → FAUX

La boucle s'arrête

Réponse finale :

La boucle affiche :
0
1
2

Règles appliquées :

• Test avant exécution : La condition est testée avant chaque itération

• Modification indispensable : La variable de contrôle doit changer

• Terminaison garantie : La condition devient fausse après 3 itérations

2 Somme des entiers de 1 à 5 avec while

Définition :

Somme itérative : Accumulation progressive d'une valeur.

Code Python

                somme = 0

                i = 1

                while i <= 5:

                  somme = somme + i

                  i = i + 1

                print(somme)

Étape 1 : Initialiser les variables

somme = 0 (accumulateur), i = 1 (compteur)

Étape 2 : Itération 1 (i = 1)

Condition: i <= 5 → 1 <= 5 → VRAI

Action: somme = 0 + 1 = 1, i = 1 + 1 = 2

Étape 3 : Itération 2 (i = 2)

Condition: i <= 5 → 2 <= 5 → VRAI

Action: somme = 1 + 2 = 3, i = 2 + 1 = 3

Étape 4 : Itération 3 (i = 3)

Condition: i <= 5 → 3 <= 5 → VRAI

Action: somme = 3 + 3 = 6, i = 3 + 1 = 4

Étape 5 : Itération 4 (i = 4)

Condition: i <= 5 → 4 <= 5 → VRAI

Action: somme = 6 + 4 = 10, i = 4 + 1 = 5

Étape 6 : Itération 5 (i = 5)

Condition: i <= 5 → 5 <= 5 → VRAI

Action: somme = 10 + 5 = 15, i = 5 + 1 = 6

Étape 7 : Sortie de boucle

Condition: i <= 5 → 6 <= 5 → FAUX

La boucle s'arrête, somme = 15

Réponse finale :

La somme des entiers de 1 à 5 est 15

Règles appliquées :

• Initialisation : Variables d'accumulation et de contrôle initialisées

• Modification : La variable de contrôle est incrémentée à chaque tour

• Accumulation : La valeur est ajoutée à l'accumulateur

3 Divisions successives de n par 2

Définition :

Division itérative : Réduction progressive d'une valeur.

Code Python

                n = 10

                compte = 0

                while n > 1:

                  n = n // 2

                  compte = compte + 1

                print(compte)

Étape 1 : Initialiser les variables

n = 10 (valeur initiale), compte = 0 (compteur)

Étape 2 : Itération 1 (n = 10)

Condition: n > 1 → 10 > 1 → VRAI

Action: n = 10 // 2 = 5, compte = 0 + 1 = 1

Étape 3 : Itération 2 (n = 5)

Condition: n > 1 → 5 > 1 → VRAI

Action: n = 5 // 2 = 2, compte = 1 + 1 = 2

Étape 4 : Itération 3 (n = 2)

Condition: n > 1 → 2 > 1 → VRAI

Action: n = 2 // 2 = 1, compte = 2 + 1 = 3

Étape 5 : Sortie de boucle

Condition: n > 1 → 1 > 1 → FAUX

La boucle s'arrête, compte = 3

Réponse finale :

Il faut 3 divisions successives de 10 par 2 pour obtenir 1

Règles appliquées :

• Division entière : // pour garder les parties entières

• Compteur : Incrémenté à chaque division

• Terminaison : La condition devient fausse quand n ≤ 1

4 Racine carrée entière de 25

Définition :

Recherche itérative : Trouver un nombre dont le carré approche une valeur.

Code Python

                n = 25

                racine = 0

                while racine * racine <= n:

                  racine = racine + 1

                racine = racine - 1  # Correction pour le dépassement

                print(racine)

Étape 1 : Initialiser les variables

n = 25 (nombre), racine = 0 (solution potentielle)

Étape 2 : Itération 1 (racine = 0)

Condition: racine * racine <= n → 0*0 <= 25 → 0 <= 25 → VRAI

Action: racine = 0 + 1 = 1

Étape 3 : Itération 2 (racine = 1)

Condition: racine * racine <= n → 1*1 <= 25 → 1 <= 25 → VRAI

Action: racine = 1 + 1 = 2

Étape 4 : Itération 3 (racine = 2)

Condition: racine * racine <= n → 2*2 <= 25 → 4 <= 25 → VRAI

Action: racine = 2 + 1 = 3

Étape 5 : Itérations suivantes...

Continue jusqu'à racine = 5: 5*5 = 25 <= 25 → VRAI

racine = 5 + 1 = 6

Étape 6 : Dernière itération (racine = 6)

Condition: racine * racine <= n → 6*6 <= 25 → 36 <= 25 → FAUX

La boucle s'arrête, correction: racine = 6 - 1 = 5

Réponse finale :

La racine carrée entière de 25 est 5

Règles appliquées :

• Recherche linéaire : Teste chaque entier croissant

• Correction de dépassement : Soustrait 1 pour compenser le dernier incrément

• Condition d'arrêt : Carré dépasse la valeur cible

5 Divisions par 10 jusqu'à x < 1

Définition :

Division répétée : Réduction progressive par division.

Code Python

                x = 100

                compte = 0

                while x >= 1:

                  x = x / 10

                  compte = compte + 1

                compte = compte - 1  # Correction pour la dernière itération

                print(compte)

Étape 1 : Initialiser les variables

x = 100 (valeur initiale), compte = 0 (compteur)

Étape 2 : Itération 1 (x = 100)

Condition: x >= 1 → 100 >= 1 → VRAI

Action: x = 100 / 10 = 10.0, compte = 0 + 1 = 1

Étape 3 : Itération 2 (x = 10.0)

Condition: x >= 1 → 10.0 >= 1 → VRAI

Action: x = 10.0 / 10 = 1.0, compte = 1 + 1 = 2

Étape 4 : Itération 3 (x = 1.0)

Condition: x >= 1 → 1.0 >= 1 → VRAI

Action: x = 1.0 / 10 = 0.1, compte = 2 + 1 = 3

Étape 5 : Sortie de boucle

Condition: x >= 1 → 0.1 >= 1 → FAUX

La boucle s'arrête, correction: compte = 3 - 1 = 2

Réponse finale :

Il faut 2 divisions par 10 pour passer de 100 à une valeur inférieure à 1

Règles appliquées :

• Division flottante : / pour conserver les décimales

• Correction de comptage : Soustraction pour tenir compte de la dernière itération

• Condition d'arrêt : x devient inférieur à 1

Corrigé : Exercices 6 à 10

6 Puissance de 2 avec while

Définition :

Puissance itérative : Multiplication répétée d'un nombre par lui-même.

Code Python

                resultat = 1

                exposant = 0

                while exposant < 8:

                  resultat = resultat * 2

                  exposant = exposant + 1

                print(resultat)

Étape 1 : Initialiser les variables

resultat = 1 (élément neutre), exposant = 0 (compteur)

Étape 2 : Itérations successives

Chaque itération multiplie resultat par 2 et incrémente l'exposant

Itération 1: resultat = 1*2 = 2, exposant = 1

Itération 2: resultat = 2*2 = 4, exposant = 2

Itération 3: resultat = 4*2 = 8, exposant = 3

Itération 4: resultat = 8*2 = 16, exposant = 4

Itération 5: resultat = 16*2 = 32, exposant = 5

Itération 6: resultat = 32*2 = 64, exposant = 6

Itération 7: resultat = 64*2 = 128, exposant = 7

Itération 8: resultat = 128*2 = 256, exposant = 8

Étape 3 : Sortie de boucle

Condition: exposant < 8 → 8 < 8 → FAUX

La boucle s'arrête, resultat = 256

Réponse finale :

2^8 = 256

Règles appliquées :

• Initialisation : Résultat commence à 1 pour multiplication

• Compteur d'exposant : Contrôle le nombre de multiplications

• Accumulation multiplicative : Multiplie par la base à chaque itération

7 Trouver n tel que n² > 100

Définition :

Recherche de seuil : Trouver la première valeur qui dépasse une limite.

Code Python

                n = 1

                while n * n <= 100:

                  n = n + 1

                print(n)

Étape 1 : Initialiser la variable

n = 1 (valeur de départ)

Étape 2 : Itérations jusqu'à dépassement

n = 1: 1² = 1 ≤ 100 → continue

n = 2: 2² = 4 ≤ 100 → continue

n = 3: 3² = 9 ≤ 100 → continue

n = 4: 4² = 16 ≤ 100 → continue

n = 5: 5² = 25 ≤ 100 → continue

n = 6: 6² = 36 ≤ 100 → continue

n = 7: 7² = 49 ≤ 100 → continue

n = 8: 8² = 64 ≤ 100 → continue

n = 9: 9² = 81 ≤ 100 → continue

n = 10: 10² = 100 ≤ 100 → continue

n = 11: 11² = 121 > 100 → condition fausse, boucle s'arrête

Étape 3 : Résultat final

Le premier entier n tel que n² > 100 est 11

Réponse finale :

Le plus petit entier n tel que n² > 100 est 11

Règles appliquées :

• Recherche linéaire : Teste chaque entier croissant

• Condition d'arrêt : Carré dépasse la limite

• Seuil de dépassement : Première valeur qui satisfait la condition inverse

8 Compter les chiffres d'un nombre

Définition :

Division itérative : Réduction successive par division entière.

Code Python

                x = 1234

                nombre_chiffres = 0

                while x > 0:

                  x = x // 10

                  nombre_chiffres = nombre_chiffres + 1

                print(nombre_chiffres)

Étape 1 : Initialiser les variables

x = 1234 (nombre à analyser), nombre_chiffres = 0 (compteur)

Étape 2 : Itération 1 (x = 1234)

Condition: x > 0 → 1234 > 0 → VRAI

Action: x = 1234 // 10 = 123, nombre_chiffres = 0 + 1 = 1

Étape 3 : Itération 2 (x = 123)

Condition: x > 0 → 123 > 0 → VRAI

Action: x = 123 // 10 = 12, nombre_chiffres = 1 + 1 = 2

Étape 4 : Itération 3 (x = 12)

Condition: x > 0 → 12 > 0 → VRAI

Action: x = 12 // 10 = 1, nombre_chiffres = 2 + 1 = 3

Étape 5 : Itération 4 (x = 1)

Condition: x > 0 → 1 > 0 → VRAI

Action: x = 1 // 10 = 0, nombre_chiffres = 3 + 1 = 4

Étape 6 : Sortie de boucle

Condition: x > 0 → 0 > 0 → FAUX

La boucle s'arrête, nombre_chiffres = 4

Réponse finale :

Le nombre 1234 contient 4 chiffres

Règles appliquées :

• Division entière : // retire le dernier chiffre

• Compteur : Incrémenté à chaque suppression de chiffre

• Terminaison : Quand x devient 0, tous les chiffres ont été comptés

9 Factorielle de 6 avec while

Définition :

Factorielle : Produit de tous les entiers de 1 à n.

Code Python

                resultat = 1

                i = 1

                while i <= 6:

                  resultat = resultat * i

                  i = i + 1

                print(resultat)

Étape 1 : Initialiser les variables

resultat = 1 (élément neutre), i = 1 (facteur courant)

Étape 2 : Itération 1 (i = 1)

Condition: i <= 6 → 1 <= 6 → VRAI

Action: resultat = 1 * 1 = 1, i = 1 + 1 = 2

Étape 3 : Itération 2 (i = 2)

Condition: i <= 6 → 2 <= 6 → VRAI

Action: resultat = 1 * 2 = 2, i = 2 + 1 = 3

Étape 4 : Itération 3 (i = 3)

Condition: i <= 6 → 3 <= 6 → VRAI

Action: resultat = 2 * 3 = 6, i = 3 + 1 = 4

Étape 5 : Itération 4 (i = 4)

Condition: i <= 6 → 4 <= 6 → VRAI

Action: resultat = 6 * 4 = 24, i = 4 + 1 = 5

Étape 6 : Itération 5 (i = 5)

Condition: i <= 6 → 5 <= 6 → VRAI

Action: resultat = 24 * 5 = 120, i = 5 + 1 = 6

Étape 7 : Itération 6 (i = 6)

Condition: i <= 6 → 6 <= 6 → VRAI

Action: resultat = 120 * 6 = 720, i = 6 + 1 = 7

Étape 8 : Sortie de boucle

Condition: i <= 6 → 7 <= 6 → FAUX

La boucle s'arrête, resultat = 720

Réponse finale :

La factorielle de 6 est 720

Règles appliquées :

• Accumulation multiplicative : Multiplication progressive

• Facteur croissant : i va de 1 à 6

• Initialisation : Résultat commence à 1 pour multiplication

10 PGCD de 48 et 18 avec Euclide

Définition :

Algorithme d'Euclide : Méthode pour trouver le PGCD de deux nombres.

Code Python

                a = 48

                b = 18

                while b != 0:

                  r = a % b

                  a = b

                  b = r

                print(a)

Étape 1 : Initialiser les variables

a = 48, b = 18

Étape 2 : Itération 1

Condition: b != 0 → 18 != 0 → VRAI

r = 48 % 18 = 12

a = 18, b = 12

Étape 3 : Itération 2

Condition: b != 0 → 12 != 0 → VRAI

r = 18 % 12 = 6

a = 12, b = 6

Étape 4 : Itération 3

Condition: b != 0 → 6 != 0 → VRAI

r = 12 % 6 = 0

a = 6, b = 0

Étape 5 : Sortie de boucle

Condition: b != 0 → 0 != 0 → FAUX

La boucle s'arrête, a = 6

Réponse finale :

Le PGCD de 48 et 18 est 6

Règles appliquées :

• Algorithme d'Euclide : PGCD(a,b) = PGCD(b, a%b)

• Remplacement : a devient b, b devient a%b

• Terminaison : Quand b devient 0, a contient le PGCD

Boucle tant que (non bornée)Algorithmique et programmation

Boucle tant que (non bornée)
Algorithmique et programmation