QCM : Analyse fine des boucles en Python

[enonce]
Ce QCM propose une analyse fine des boucles Python : pièges de bornes, compteurs complexes, boucles while délicates et choix entre for et while. Choisissez la bonne réponse parmi les quatre propositions.
[/enonce]

[etape]
Dans la boucle for i in range(1, 10) :, quelle est la plus grande valeur prise par i ?
[qcm]
[option]$10$[/option]
[option correct="true"]$9$[/option]
[option]$11$[/option]
[option]$1$[/option]
[reponse statut="correct"]Exact !
La borne supérieure de range(a, b) est exclue. Pour range(1, 10), la variable i parcourt $1, 2, 3, \ldots, 9$. La plus grande valeur est donc $9$.[/reponse]
[reponse motif="$10$"]Non.
Piège classique : la borne supérieure $10$ n'est pas atteinte par i. La séquence s'arrête une unité avant la borne.[/reponse]
[reponse motif="$11$"]Non.
$11$ n'apparaît jamais dans range(1, 10) : la séquence va de $1$ à $9$ inclus.[/reponse]
[reponse motif="$1$"]Non.
$1$ est la plus petite valeur prise par i, pas la plus grande. La question porte sur la plus grande.[/reponse]
[reponse statut="incorrect"]Non.
Règle à retenir : range(a, b) parcourt de $a$ à $b - 1$.[/reponse]
[/qcm]
[/etape]

[etape]
Dans les situations suivantes, laquelle exige une boucle while plutôt qu'une boucle for ?
[qcm]
[option]Afficher les $20$ premiers carrés parfaits[/option]
[option]Calculer la somme $1 + 2 + \ldots + 100$[/option]
[option correct="true"]Trouver le plus petit entier $n$ tel que $2^n > 10^6$[/option]
[option]Afficher chaque élément d'une liste donnée[/option]
[reponse statut="correct"]Bonne réponse !
On ne connaît pas à l'avance la valeur de $n$ ; on ne peut donc pas fixer le nombre de tours dans un range. La boucle while est adaptée : on répète tant que $2^n \leqslant 10^6$.[/reponse]
[reponse motif="Afficher les $20$ premiers carrés parfaits"]Non.
Le nombre de répétitions est connu ($20$). On peut donc utiliser for i in range(1, 21) : la boucle for est plus simple.[/reponse]
[reponse motif="Calculer la somme $1 + 2 + \ldots + 100$"]Non.
Le nombre de termes est fixé ($100$). Une boucle for i in range(1, 101) convient parfaitement.[/reponse]
[reponse motif="Afficher chaque élément d'une liste donnée"]Non.
Parcourir une liste dont on connaît les éléments est typiquement le rôle d'une boucle for.[/reponse]
[reponse statut="incorrect"]Non.
Règle : for si le nombre de tours est connu à l'avance, while sinon.[/reponse]
[/qcm]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

c = 0
for i in range(100) :
    if i % 7 == 0 :
        c = c + 1
print(c)

Que s'affiche-t-il ?
[qcm]
[option]$14$[/option]
[option correct="true"]$15$[/option]
[option]$7$[/option]
[option]$100$[/option]
[reponse statut="correct"]Bravo !
Les multiples de $7$ entre $0$ et $99$ sont $0, 7, 14, 21, \ldots, 98$. Le dernier est $98 = 7 \times 14$, mais $0 = 7 \times 0$ est aussi compté. Il y en a donc $14 + 1 = 15$.[/reponse]
[reponse motif="$14$"]Non.
Vous avez oublié de compter $0$, qui est bien divisible par $7$ ($0 = 7 \times 0$). Python considère que $0 \% 7 = 0$, donc $0$ vérifie la condition.[/reponse]
[reponse motif="$7$"]Non.
$7$ est le plus petit multiple non nul de $7$ rencontré, mais la question porte sur le nombre total de multiples de $7$ entre $0$ et $99$.[/reponse]
[reponse motif="$100$"]Non.
$100$ est le nombre total de valeurs parcourues par i, pas le nombre de celles qui vérifient la condition.[/reponse]
[reponse statut="incorrect"]Non.
Les multiples de $7$ entre $0$ et $99$ sont $0, 7, 14, \ldots, 98$. Compter en incluant $0$.[/reponse]
[/qcm]
[/etape]

[etape]
On considère le programme Python ci-dessous :

i = 0
while i < 10 :
    print(i)

Que se passe-t-il lors de l'exécution ?
[qcm]
[option]Le programme affiche $0, 1, 2, \ldots, 9$ puis s'arrête[/option]
[option]Le programme n'affiche rien[/option]
[option correct="true"]Le programme affiche $0$ indéfiniment (boucle infinie)[/option]
[option]Le programme affiche $10$ puis s'arrête[/option]
[reponse statut="correct"]Parfait !
La variable i n'est jamais modifiée à l'intérieur de la boucle. La condition i < 10 reste donc toujours vraie (car $i$ reste à $0$) et la boucle tourne indéfiniment en affichant $0$.[/reponse]
[reponse motif="Le programme affiche $0, 1, 2, \ldots, 9$ puis s'arrête"]Non.
Pour cela, il faudrait incrémenter i à chaque tour avec i = i + 1. Ici, rien ne fait évoluer i.[/reponse]
[reponse motif="Le programme n'affiche rien"]Non.
La condition i < 10 est vraie au premier tour ($0 < 10$), donc le bloc s'exécute au moins une fois. Un print s'effectue donc.[/reponse]
[reponse motif="Le programme affiche $10$ puis s'arrête"]Non.
La boucle while ne s'arrête pas pile sur une valeur précise : elle continue tant que la condition est vraie. Et ici, rien ne rend la condition fausse.[/reponse]
[reponse statut="incorrect"]Non.
Rechercher si i évolue dans le corps de la boucle. Si non, la condition reste inchangée et la boucle ne s'arrête jamais.[/reponse]
[/qcm]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

S = 0
q = 1
for i in range(4) :
    S = S + q
    q = q * 2
print(S)

Que s'affiche-t-il ?
[qcm]
[option]$7$[/option]
[option]$8$[/option]
[option correct="true"]$15$[/option]
[option]$16$[/option]
[reponse statut="correct"]Exactement !
Traçons les étapes avec $S$ et $q$ :
Avant la boucle : $S = 0$, $q = 1$.
Tour $0$ : $S = 0 + 1 = 1$, $q = 2$.
Tour $1$ : $S = 1 + 2 = 3$, $q = 4$.
Tour $2$ : $S = 3 + 4 = 7$, $q = 8$.
Tour $3$ : $S = 7 + 8 = 15$, $q = 16$.
On a calculé $1 + 2 + 4 + 8 = 15$.[/reponse]
[reponse motif="$7$"]Non.
$7 = 1 + 2 + 4$ correspond à seulement trois tours de boucle. Or range(4) en fait quatre. Vérifier le dernier tour.[/reponse]
[reponse motif="$8$"]Non.
$8$ est la valeur de $q$ à la fin d'un certain tour, pas la valeur finale de S. La question porte sur S, le cumul.[/reponse]
[reponse motif="$16$"]Non.
$16$ est la valeur finale de q, pas celle de S. Ne pas confondre la variable de cumul et la variable qui évolue.[/reponse]
[reponse statut="incorrect"]Non.
Faire un tableau avec deux colonnes (S et q) et suivre les quatre tours de boucle.[/reponse]
[/qcm]
[/etape]

[etape]
On souhaite calculer la plus petite valeur de n telle que $1 + 2 + \ldots + n \geqslant 100$. Parmi les programmes ci-dessous, lequel est correct ?
[qcm]
[option]for n in range(100) : S = S + n[/option]
[option correct="true"]S = 0 ; n = 0 ; while S < 100 : n = n + 1 ; S = S + n[/option]
[option]S = 0 ; for n in range(100) : if S < 100 : S = S + n[/option]
[option]n = 0 ; while S >= 100 : n = n + 1 ; S = S + n[/option]
[reponse statut="correct"]Tu as raison !
On ne connaît pas $n$ à l'avance : il faut une boucle while. On incrémente $n$ à chaque tour et on cumule dans $S$ tant que $S < 100$. Dès que le cumul dépasse $100$, la boucle s'arrête et $n$ contient la valeur cherchée.[/reponse]
[reponse motif="for n in range(100) : S = S + n"]Non.
Ce programme ne s'arrête pas quand le seuil est atteint : il parcourt toutes les valeurs jusqu'à $99$. De plus, S n'est pas initialisée.[/reponse]
[reponse motif="S = 0 ; for n in range(100) : if S < 100 : S = S + n"]Non.
Même si le test empêche de cumuler après le seuil, la boucle for tourne toujours $100$ fois (juste sans rien ajouter). On ne s'arrête pas quand on a trouvé $n$.[/reponse]
[reponse motif="n = 0 ; while S >= 100 : n = n + 1 ; S = S + n"]Non.
La condition est inversée : on veut rester dans la boucle tant que S < 100, pas tant que S >= 100. De plus, S n'est pas initialisée.[/reponse]
[reponse statut="incorrect"]Non.
Stratégie : condition d'arrêt inconnue → boucle while. La condition écrite dans while est celle pour rester dans la boucle.[/reponse]
[/qcm]
[/etape]

QCM : Sommes, compteurs et boucle while en Python

[enonce]
Ce QCM porte sur les calculs de sommes, les compteurs et la boucle while en Python. Choisissez la bonne réponse parmi les quatre propositions.
[/enonce]

[etape]
On exécute le programme Python ci-dessous :

S = 0
for i in range(1, 11) :
    S = S + i
print(S)

Que s'affiche-t-il ?
[qcm]
[option]$10$[/option]
[option]$45$[/option]
[option correct="true"]$55$[/option]
[option]$100$[/option]
[reponse statut="correct"]Exact !
range(1, 11) parcourt les entiers de $1$ à $10$ inclus. On calcule donc la somme $1 + 2 + 3 + \ldots + 10 = 55$.[/reponse]
[reponse motif="$10$"]Non.
$10$ est la valeur finale de i, pas la somme des valeurs. À chaque tour, on ajoute i à la somme (cumul).[/reponse]
[reponse motif="$45$"]Non.
$45 = 1 + 2 + \ldots + 9$ : la borne supérieure est $11$ dans range, mais la séquence s'arrête à $10$ (inclus). Vérifier que $10$ est bien ajouté au cumul.[/reponse]
[reponse motif="$100$"]Non.
$100$ ne correspond pas à cette somme. Utiliser la formule : $1 + 2 + \ldots + n = \dfrac{n(n+1)}{2}$, ou lister les $10$ premiers entiers et les additionner.[/reponse]
[reponse statut="incorrect"]Non.
Sommer tous les entiers de $1$ à $10$. Formule utile : $\dfrac{n(n+1)}{2}$.[/reponse]
[/qcm]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

S = 0
for i in range(5) :
    S = S + i**2
print(S)

Que s'affiche-t-il ?
[qcm]
[option]$25$[/option]
[option correct="true"]$30$[/option]
[option]$10$[/option]
[option]$55$[/option]
[reponse statut="correct"]Bonne réponse !
range(5) fait prendre à i les valeurs $0, 1, 2, 3, 4$. On cumule les carrés :
$0^2 + 1^2 + 2^2 + 3^2 + 4^2 = 0 + 1 + 4 + 9 + 16 = 30$.[/reponse]
[reponse motif="$25$"]Non.
$25 = 5^2$ : il semble que vous ayez calculé $(0+1+2+3+4)^2$ au lieu de sommer les carrés un à un. On additionne $i^2$ à chaque tour, pas le carré de la somme.[/reponse]
[reponse motif="$10$"]Non.
$10 = 0 + 1 + 2 + 3 + 4$ est la somme des valeurs de $i$, pas de leurs carrés. Le ** signifie « à la puissance » : i**2 est le carré de i.[/reponse]
[reponse motif="$55$"]Non.
$55 = 1^2 + 2^2 + 3^2 + 4^2 + 5^2$ correspond à une boucle parcourant les valeurs $1$ à $5$. Or range(5) parcourt $0$ à $4$.[/reponse]
[reponse statut="incorrect"]Non.
Lister les valeurs de i, calculer $i^2$ pour chacune, puis additionner.[/reponse]
[/qcm]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

p = 1
for i in range(1, 5) :
    p = p * i
print(p)

Que s'affiche-t-il ?
[qcm]
[option]$10$[/option]
[option]$120$[/option]
[option correct="true"]$24$[/option]
[option]$5$[/option]
[reponse statut="correct"]Bravo !
range(1, 5) parcourt $1, 2, 3, 4$. À chaque tour on multiplie : $p = 1 \times 1 \times 2 \times 3 \times 4 = 24$. On calcule ainsi la factorielle $4! = 24$.[/reponse]
[reponse motif="$10$"]Non.
$10 = 1 + 2 + 3 + 4$ est la somme, pas le produit. Ici l'opérateur est * (multiplication), pas +.[/reponse]
[reponse motif="$120$"]Non.
$120 = 5!$ correspond à un parcours des entiers $1$ à $5$. Or range(1, 5) s'arrête à $4$ : la borne supérieure est exclue.[/reponse]
[reponse motif="$5$"]Non.
$5$ ne correspond à aucun cumul sensé. Tracer les valeurs successives de $p$ : $1, 1, 2, 6, 24$.[/reponse]
[reponse statut="incorrect"]Non.
Tracer p tour par tour. On initialise à $1$, puis on multiplie successivement par $1, 2, 3, 4$.[/reponse]
[/qcm]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

i = 1
while i < 20 :
    i = i * 3
print(i)

Que s'affiche-t-il ?
[qcm]
[option]$9$[/option]
[option]$20$[/option]
[option correct="true"]$27$[/option]
[option]$81$[/option]
[reponse statut="correct"]Parfait !
On suit les valeurs successives de i : $1 \to 3 \to 9 \to 27$. Tant que i < 20, on multiplie par $3$. Quand $i = 27$, la condition devient fausse, la boucle s'arrête.[/reponse]
[reponse motif="$9$"]Non.
À $i = 9$, la condition i < 20 est encore vraie ($9 < 20$). La boucle continue : on multiplie encore par $3$.[/reponse]
[reponse motif="$20$"]Non.
La boucle while ne s'arrête pas pile sur la valeur $20$ : elle multiplie par $3$ tant que la condition est vraie. La valeur de sortie est toujours une puissance de $3$.[/reponse]
[reponse motif="$81$"]Non.
À $i = 27$, la condition i < 20 est déjà fausse, donc la boucle s'arrête sans multiplier une fois de plus par $3$.[/reponse]
[reponse statut="incorrect"]Non.
Tracer les valeurs successives de i tant que la condition est vérifiée.[/reponse]
[/qcm]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

i = 1
while i <= 100 :
    i = i * 2
print(i)

Que s'affiche-t-il ?
[qcm]
[option]$64$[/option]
[option]$100$[/option]
[option correct="true"]$128$[/option]
[option]$256$[/option]
[reponse statut="correct"]C'est bien ça !
On suit les valeurs : $1, 2, 4, 8, 16, 32, 64, 128$. Avant le dernier tour, $i = 64$ et la condition $i \leqslant 100$ est vraie, on exécute donc i = i*2 = 128. Puis la condition devient fausse et la boucle s'arrête.[/reponse]
[reponse motif="$64$"]Non.
À $i = 64$, la condition $i \leqslant 100$ est encore vraie. On passe donc un tour de plus : $i$ devient $128$.[/reponse]
[reponse motif="$100$"]Non.
La variable i ne prend que des puissances de $2$ ($1, 2, 4, 8, \ldots$). La valeur $100$ n'apparaît jamais dans cette suite.[/reponse]
[reponse motif="$256$"]Non.
À $i = 128$, la condition $i \leqslant 100$ est fausse ($128 > 100$), donc la boucle s'arrête avant de multiplier à nouveau par $2$.[/reponse]
[reponse statut="incorrect"]Non.
Lister les puissances de $2$ : $1, 2, 4, \ldots$. Identifier la première qui dépasse $100$.[/reponse]
[/qcm]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

c = 0
for i in range(10) :
    if i % 2 == 0 :
        c = c + 1
print(c)

Que s'affiche-t-il ?
[qcm]
[option]$10$[/option]
[option]$4$[/option]
[option correct="true"]$5$[/option]
[option]$0$[/option]
[reponse statut="correct"]Exactement !
Le compteur c est incrémenté chaque fois que i est pair. Parmi $0, 1, 2, 3, 4, 5, 6, 7, 8, 9$, les pairs sont $0, 2, 4, 6, 8$ : il y en a $5$.[/reponse]
[reponse motif="$10$"]Non.
$10$ serait le nombre total de tours de boucle. Ici, c n'est incrémenté qu'à certaines conditions (quand $i$ est pair).[/reponse]
[reponse motif="$4$"]Non.
Piège : $0$ est aussi pair ($0 \% 2 = 0$), il faut le compter. Lister les entiers pairs entre $0$ et $9$.[/reponse]
[reponse motif="$0$"]Non.
Le compteur est incrémenté à chaque fois que la condition i % 2 == 0 est vraie. Vérifier qu'elle l'est bien au moins une fois.[/reponse]
[reponse statut="incorrect"]Non.
Lister les entiers de $0$ à $9$, compter ceux qui sont pairs. Une condition i % 2 == 0 teste la parité.[/reponse]
[/qcm]
[/etape]

Vrai/Faux : Sommes et compteurs avec for (niveau 2)

[enonce]
Pour chaque affirmation suivante sur les accumulations et compteurs avec for en Python, indiquez si elle est Vraie ou Fausse.
[/enonce]

[etape]
On exécute le programme Python ci-dessous :

S = 0
for i in range(1, 101) :
    S = S + i
print(S)

Affirmation : Ce programme affiche la somme $1 + 2 + \ldots + 100 = 5050$.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Exactement !
range(1, 101) parcourt les entiers de $1$ à $100$ inclus.
À chaque tour, on ajoute i à S, donc à la fin S vaut $1 + 2 + \ldots + 100 = 5050$.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Rappel : range(1, 101) donne les entiers de $1$ à $100$ (la borne $101$ est exclue).
L'accumulation S = S + i dans la boucle ajoute tous ces entiers. Le résultat est $5050$.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. La boucle additionne les entiers de $1$ à $100$, la somme vaut $5050$.
[/solution]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

S = 0
for i in range(1, 5) :
    S = S + i*i
print(S)

Affirmation : Ce programme affiche $30$.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Bravo !
i prend les valeurs $1, 2, 3, 4$ et on ajoute $i^2$ à chaque tour.
On calcule $1 + 4 + 9 + 16 = 30$.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Il faut bien identifier ce que la boucle accumule.
i*i représente le carré de i, donc on additionne $1^2 + 2^2 + 3^2 + 4^2 = 1 + 4 + 9 + 16 = 30$.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. La boucle additionne les carrés $1^2, 2^2, 3^2, 4^2$, soit $1+4+9+16 = 30$.
[/solution]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

P = 0
for i in range(1, 6) :
    P = P * i
print(P)

Affirmation : Ce programme affiche $120$ (soit $1 \times 2 \times 3 \times 4 \times 5$).

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Correct !
P est initialisée à $0$. À chaque tour, P = P * i donne $0$ (car $0 \times k = 0$).
Le programme affiche donc $0$. Pour un produit, il faut initialiser P = 1.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
L'erreur classique est d'initialiser un produit à $0$ comme pour une somme.
Or $0 \times i = 0$ : la variable P reste à $0$ pendant toute la boucle. Il faut initialiser P = 1 pour un produit.[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. P étant initialisée à $0$, chaque multiplication redonne $0$. Le programme affiche $0$.
[/solution]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

c = 0
for i in range(1, 11) :
    if i % 2 == 0 :
        c = c + 1
print(c)

Affirmation : Ce programme affiche $5$.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Tu as raison !
La boucle parcourt les entiers de $1$ à $10$ et compte ceux qui sont pairs (reste nul dans la division par $2$).
Les entiers pairs sont $2, 4, 6, 8, 10$, soit $5$ valeurs. Le compteur vaut donc $5$.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Rappel : i % 2 == 0 teste si i est pair.
Parmi $1, 2, \ldots, 10$, les entiers pairs sont $2, 4, 6, 8, 10$ : il y en a $5$, donc le compteur c vaut $5$.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. La boucle compte les entiers pairs entre $1$ et $10$ : il y en a $5$ ($2, 4, 6, 8, 10$).
[/solution]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

S = 0
for i in range(10) :
    S = S + i
print(S)

Affirmation : Ce programme affiche $55$ (soit $1 + 2 + \ldots + 10$).

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Bonne réponse !
range(10) parcourt les entiers de $0$ à $9$ (borne $10$ exclue), pas de $1$ à $10$.
On calcule donc $0 + 1 + 2 + \ldots + 9 = 45$, et non $55$.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Le piège est de confondre range(10) avec range(1, 11).
range(10) produit $0, 1, 2, \ldots, 9$ ; la somme vaut $45$. Pour obtenir $1+2+\ldots+10 = 55$, il faudrait écrire range(1, 11).[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. range(10) donne $0$ à $9$ ; la somme vaut $45$. Pour avoir $55$, il faudrait range(1, 11).
[/solution]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

m = 0
for x in [5, 8, 3, 12, 7] :
    if x > m :
        m = x
print(m)

Affirmation : Ce programme affiche $12$.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Exactement !
À chaque tour, on remplace m par x si x est plus grand. La variable m stocke donc le maximum de la liste.
Le plus grand élément de $[5, 8, 3, 12, 7]$ est $12$.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Rappel : ce schéma (comparaison et mise à jour) cherche le maximum d'une liste.
Les valeurs successives de m sont $0 \to 5 \to 8 \to 8 \to 12 \to 12$. Le maximum de la liste est bien $12$.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. La boucle met à jour m avec le plus grand élément rencontré : le maximum est $12$.
[/solution]
[/etape]