04 - Boucles

Réponse : B. range(3, 7) génère les entiers de 3 (inclus) à 7 (exclu), soit 3, 4, 5, 6.

• A est faux : la borne supérieure est exclue (erreur fréquente : oublier que range s’arrête avant la borne).
• C est faux : la borne inférieure est incluse.
• D est faux : il manque 6 ; range(3, 7) produit quatre valeurs, pas trois.

Réponse : B. range(5) produit les valeurs 0, 1, 2, 3, 4, soit cinq itérations.

• A est faux : c’est l’erreur qui consiste à commencer à compter à 1 (la boucle commence à 0).
• C est faux : range(5) ne produit pas la valeur 5.
• D est faux : i est la variable de boucle, elle prend successivement chaque valeur de range(5).

Réponse : B. On utilise for lorsqu’on sait combien de fois on veut itérer (parcourir une liste, un range, etc.) et while lorsque le nombre de répétitions dépend d’une condition vérifiée à chaque tour.

• A est faux : la vitesse dépend du contenu de la boucle, pas du mot-clé.
• C est faux : while True: crée une boucle infinie.
• D est faux : bien que l’on puisse souvent réécrire l’une avec l’autre, while est nécessaire quand le nombre d’itérations n’est pas connu à l’avance.

Réponse : B. range(1, 4) produit 1, 2, 3. La variable s accumule la somme : 0 + 1 = 1, puis 1 + 2 = 3, puis 3 + 3 = 6.

• A est faux : c’est la valeur du dernier i, pas de la somme.
• C est faux : c’est la somme 1 + 2 + 3 + 4, comme si range(1, 4) incluait 4 (erreur de borne).
• D est faux : c’est 1 + 3, comme si on avait sauté i = 2.

Programme 1 : affiche 20 points.

Les deux boucles for sont consécutives (l’une après l’autre). La première affiche 10 points, la seconde affiche 10 points. Total : \(10 + 10 = 20\).

Programme 2 : affiche 100 points.

Les deux boucles sont imbriquées : pour chaque valeur de i (10 valeurs), la boucle interne sur j affiche 10 points. Total : \(10 \times 10 = 100\).

Point clé : l’indentation de la seconde boucle détermine si elle est consécutive (même niveau) ou imbriquée (décalée à droite).

a, b = 4, 7
trouve = False

while not trouve:
    print("À vous de jouer")
    x = int(input("x : "))
    y = int(input("y : "))
    if x == a and y == b:
        print("Coulé !")
        trouve = True
    else:
        if x == a or y == b:
            print("En vue")
        else:
            print("À l'eau")

On utilise une boucle while dont la condition est « tant que le joueur n’a pas trouvé ». La variable booléenne trouve passe à True lorsque la bonne case est touchée, ce qui met fin à la boucle.

Variante : on peut aussi utiliser while True: avec un break dans le cas « Coulé ».

for i in range(11):
    print(f"--- Table de {i} ---")
    for j in range(11):
        print(f"{i} x {j} = {i * j}")
    print()

La boucle externe parcourt les tables (de 0 à 10), la boucle interne parcourt les multiplicateurs (de 0 à 10). C’est un exemple classique de boucles imbriquées.

for n in range(1, 21):
    print(f"{n} : carré = {n**2}, cube = {n**3}")

range(1, 21) produit les entiers de 1 à 20. L’opérateur ** calcule la puissance.

taux = 1.1183
euros = 1

while euros <= 16384:
    dollars = euros * taux
    print(f"{euros} euro(s) = {dollars:.4f} dollar(s)")
    euros = euros * 2

On utilise une boucle while car la progression est géométrique (on double euros à chaque tour). Le formatage :.4f affiche quatre décimales. La boucle s’arrête quand euros dépasse 16 384.

Trace des premières valeurs : 1, 2, 4, 8, 16, 32, …, 16384 (soit 15 lignes, car \(2^{14} = 16,384\)).

n = 1
for i in range(12):
    print(n)
    n = n * 3

On part de n = 1 et on multiplie par 3 à chaque itération. Les 12 valeurs affichées sont : 1, 3, 9, 27, 81, 243, 729, 2187, 6561, 19683, 59049, 177147.

for i in range(1, 51):
    produit = 13 * i
    if produit % 7 == 0:
        print(f"13 x {i} = {produit}")

On parcourt les 50 premiers multiples de 13 et on filtre ceux divisibles par 7. Un nombre est multiple de 13 et de 7 s’il est multiple de \(13 \times 7 = 91\). On obtient donc : 91, 182, 273, 364, 455, 546, 637 (soit les multiples de 91 jusqu’à \(13 \times 50 = 650\)).

for i in range(1, 8):
    print("*" * i)

L’opérateur * appliqué à une chaîne la répète : "*" * 3 donne "***". La boucle va de 1 à 7 (inclus).

Variante avec boucle imbriquée :

for i in range(1, 8):
    for j in range(i):
        print("*", end="")
    print()

somme = 0
for jour in range(1, 8):
    temp = float(input(f"Température du jour {jour} : "))
    somme = somme + temp

moyenne = somme / 7
print(f"Température moyenne de la semaine : {moyenne:.1f} °C")

On accumule les sept températures dans somme, puis on divise par 7. Le schéma « accumulateur dans une boucle » est un motif fondamental en programmation.

1.

import math
for i in range(-4, 5):
    print(f"exp({i}) = {math.exp(i):.6f}")

2.

import math
for x in range(-20, 21, 2):
    print(f"exp({x}) = {math.exp(x):.6f}")

Le troisième argument de range est le pas : range(-20, 21, 2) donne \(-20, -18, \ldots, 18, 20\).

3.

import math
for entier in range(0, 31):
    x = entier / 10
    print(f"exp({x:.1f}) = {math.exp(x):.6f}")

Puisque range ne gère que des entiers, on parcourt les entiers de 0 à 30 et on divise par 10 pour obtenir le pas de 0,1.

4.

import math
x = 0.0
while x <= 3.0:
    print(f"exp({x:.1f}) = {math.exp(x):.6f}")
    x = x + 0.1

Curiosité : à cause des erreurs d’arrondi sur les flottants, x ne vaut jamais exactement 3.0 après 30 additions de 0.1. On peut observer que la dernière valeur affichée est 2.9 ou 3.0 selon les cas, car 0.1 n’est pas représentable exactement en binaire. C’est un piège classique des boucles while avec des flottants.

debuts = "JKLMNOPQ"
fin = "ack"
for lettre in debuts:
    print(lettre + fin)

On parcourt chaque caractère de la chaîne debuts et on le concatène avec fin. L’opérateur + entre deux chaînes réalise la concaténation.

Affichage : Jack, Kack, Lack, Mack, Nack, Oack, Pack, Qack.

n = int(input("Entrez un entier positif : "))
somme = 0
i = 1
while i <= n:
    somme = somme + i
    i = i + 1
print(f"La somme des entiers de 1 à {n} est {somme}")

On initialise somme à 0 et i à 1 avant la boucle ; à chaque tour, on ajoute i puis on l’incrémente.

import random

nombre_secret = random.randint(1, 100)
proposition = 0
while proposition != nombre_secret:
    proposition = int(input("Devinez le nombre (entre 1 et 100) : "))
    if proposition < nombre_secret:
        print("C'est plus grand !")
    elif proposition > nombre_secret:
        print("C'est plus petit !")
    else:
        print("Bravo, vous avez trouvé !")

Améliorations possibles : compter les tentatives, en limiter le nombre, vérifier que la saisie est bien entre 1 et 100.

n = int(input("Combien de termes ? "))
a = 0
b = 1
compteur = 0
while compteur < n:
    print(a)
    nouveau = a + b
    a = b
    b = nouveau
    compteur = compteur + 1

Les trois lignes de décalage se remplacent par une affectation simultanée : a, b = b, a + b.

mot_de_passe_correct = "NSI2026"
tentatives_restantes = 3
mot_de_passe = ""
while mot_de_passe != mot_de_passe_correct and tentatives_restantes > 0:
    mot_de_passe = input("Entrez le mot de passe : ")
    if mot_de_passe == mot_de_passe_correct:
        print("Accès autorisé")
    else:
        tentatives_restantes = tentatives_restantes - 1
        if tentatives_restantes > 0:
            print(f"Mot de passe incorrect, il reste {tentatives_restantes} tentative(s).")
        else:
            print("Accès refusé")

La condition du while combine deux conditions avec and : le mot de passe est incorrect et il reste des tentatives.