$course$/QCM de NSI/SNT/6. Boucles non bornées : while La boucle while et sa condition de continuation, testée avant chaque
tour ; la variable qui doit changer pour que la boucle s'arrête ; les
boucles infinies ; compter les tours ; atteindre un seuil ; choisir
entre for et while.

]]> 6. Boucles non bornées : while — Q01 : Une boucle qui compte `python
n = 0
while n < 3:
print(n)
n = n + 1
`

Qu'affiche ce programme ?

]]> while répète son bloc tant que la condition est vraie. La
condition est vérifiée avant chaque tour : dès qu'elle est fausse, le
programme passe à la suite.

]]> 1.0 0.0 0 true true abc 1, 2 et 3

]]> Erreur : l'affichage a lieu avant l'ajout de 1, la première
valeur affichée est 0.

]]> 0, 1, 2 et 3

]]> Erreur : quand n vaut 3, la condition n < 3 est fausse et
la boucle s'arrête sans afficher.

]]> 0 et 1

]]> Erreur : 2 est encore strictement inférieur à 3, un troisième
tour a lieu.

]]> 0, 1 et 2

]]> Bonne réponse : la boucle tourne tant que n < 3. Elle affiche
0, 1, 2, puis n vaut 3 et la condition devient fausse.

]]> 6. Boucles non bornées : while — Q02 : La valeur après la boucle `python
n = 10
while n > 0:
n = n - 4
print(n)
`

Qu'affiche ce programme ?

]]> À la sortie d'un while, la condition est fausse : c'est la
première valeur qui la rend fausse que l'on retrouve. Ici, le premier
nombre négatif ou nul atteint.

]]> 1.0 0.0 0 true true abc -4

]]> Erreur : dès que n vaut -2, la boucle s'arrête, on ne retire
pas 4 une fois de plus.

]]> 0

]]> Erreur : en retirant 4 à chaque fois depuis 10, on ne passe
jamais par 0.

]]> -2

]]> Bonne réponse : n passe par 6, 2 puis -2. À -2, la condition
n > 0 est fausse et la boucle s'arrête.

]]> 2

]]> Erreur : 2 est encore strictement positif, un tour de plus a
lieu.

]]> 6. Boucles non bornées : while — Q03 : Une variable qui ne bouge pas `python
i = 0
while i < 5:
print(i)
`

Que fait ce programme ?

]]> Une boucle while ne s'arrête que si quelque chose rend sa condition
fausse. Oublier de modifier la variable de la condition donne une
boucle infinie.

]]> 1.0 0.0 0 true true abc Il s'arrête sur une erreur, i n'augmente pas

]]> Erreur : Python ne détecte pas une boucle infinie, il l'exécute.

]]> Il affiche 0, 1, 2, 3 et 4

]]> Erreur : contrairement à for, while n'augmente pas la
variable tout seul.

]]> Il ne s'arrête jamais, i ne change pas

]]> Bonne réponse : rien dans la boucle ne modifie i, la
condition i < 5 reste vraie et 0 est affiché sans fin.

]]> Il affiche 0 une seule fois

]]> Erreur : après le premier tour, la condition est toujours vraie
et un nouveau tour commence.

]]> 6. Boucles non bornées : while — Q04 : Doubler jusqu'à dépasser Une somme placée augmente de 10 % par an. On cherche en combien
d'années elle double.

`python
somme = 100
annees = 0
while somme < 200:
somme = somme * 1.1
annees = annees + 1
print(annees)
`

Qu'affiche ce programme ?

]]> Le while convient quand on ignore à l'avance le nombre de tours :
on répète jusqu'à atteindre un seuil, en comptant les tours dans une
variable.

]]> 1.0 0.0 0 true true abc 10

]]> Erreur : 10 % par an pendant 10 ans ne fait pas 100 %, la
croissance se compose et la somme atteint 200 avant.

]]> 8

]]> Bonne réponse : après 7 ans, la somme vaut environ 194.9, encore
sous 200 ; après 8 ans, environ 214.4.

]]> 2

]]> Erreur : 2 serait le facteur de multiplication, pas le nombre
d'années.

]]> 7

]]> Erreur : après 7 ans, la somme est encore inférieure à 200, un
tour de plus est nécessaire.

]]> 6. Boucles non bornées : while — Q05 : Compter les tours `python
x = 1
tours = 0
while x < 50:
x = x * 3
tours = tours + 1
print(tours, x)
`

Qu'affiche ce programme ?

]]> Une variable de comptage, augmentée de 1 à chaque tour, permet de
savoir combien de fois une boucle while a tourné. On lit les deux
valeurs à la sortie.

]]> 1.0 0.0 0 true true abc 4 81

]]> Bonne réponse : x passe par 3, 9, 27 et 81. Il faut 4
tours pour dépasser 50.

]]> 5 243

]]> Erreur : à 81, la condition x < 50 est fausse, la boucle
s'arrête.

]]> 4 27

]]> Erreur : au dernier tour, x est multiplié une fois de plus
et vaut 81.

]]> 3 27

]]> Erreur : 27 est encore inférieur à 50, un tour de plus a
lieu.

]]> 6. Boucles non bornées : while — Q06 : Le test vient avant le premier tour `python
n = 5
while n < 5:
print("tour")
n = n + 1
print("fin")
`

Qu'affiche ce programme ?

]]> Un while peut ne faire aucun tour : sa condition est évaluée avant
d'entrer dans le bloc. Si elle est fausse au départ, on passe
directement à la suite.

]]> 1.0 0.0 0 true true abc Rien

]]> Erreur : le dernier print est hors de la boucle et s'exécute.

]]> tour cinq fois puis fin

]]> Erreur : n vaut déjà 5, la condition est fausse d'emblée.

]]> tour puis fin

]]> Erreur : while teste la condition avant le premier tour, pas
après.

]]> fin seulement

]]> Bonne réponse : la condition 5 < 5 est fausse dès le départ,
le bloc n'est jamais exécuté.

]]> 6. Boucles non bornées : while — Q07 : Choisir la condition Un ventilateur doit tourner tant que la température dépasse 25
degrés. Quelle ligne commence correctement la boucle ?

]]> La condition d'un while est une condition de continuation, pas
d'arrêt : on écrit ce qui doit rester vrai pour refaire un tour.

]]> 1.0 0.0 0 true true abc if temperature > 25:

]]> Erreur : if exécute le bloc une seule fois, il ne répète pas.

]]> while temperature < 25:

]]> Erreur : cette boucle tournerait tant qu'il fait frais, c'est
l'inverse.

]]> while temperature == 25:

]]> Erreur : la boucle ne tournerait que pour exactement 25 degrés.

]]> while temperature > 25:

]]> Bonne réponse : la condition d'un while exprime ce qui doit
être vrai pour continuer, ici « dépasse 25 ».

]]> 6. Boucles non bornées : while — Q08 : Une soustraction répétée `python
a = 27
b = 6
q = 0
while a >= b:
a = a - b
q = q + 1
print(q, a)
`

Qu'affiche ce programme ?

]]> Cette boucle calcule une division euclidienne par soustractions
successives : le compteur donne le quotient, la valeur restante le
reste. Une trace tour par tour confirme le résultat.

]]> 1.0 0.0 0 true true abc 4 3

]]> Bonne réponse : a passe par 21, 15, 9 et 3, en 4 tours.
À 3, a >= 6 est faux. On obtient le quotient et le reste de 27
par 6.

]]> 3 9

]]> Erreur : 9 est encore supérieur ou égal à 6, un tour de plus a
lieu.

]]> 5 -3

]]> Erreur : à 3, la condition a >= b est fausse, on ne soustrait
pas une fois de plus.

]]> 4 0

]]> Erreur : 27 n'est pas un multiple de 6, il reste 3.

]]> 6. Boucles non bornées : while — Q09 : for ou while Dans laquelle de ces situations une boucle while est-elle
nécessaire, parce qu'on ne connaît pas le nombre de tours à
l'avance ?

]]> for sert quand le nombre de répétitions est connu avant de
commencer, while quand il dépend de ce qui se passe pendant la
boucle, comme une saisie ou un seuil à atteindre.

]]> 1.0 0.0 0 true true abc Parcourir les lettres d'un mot

]]> Erreur : le nombre de lettres est connu, for parcourt le mot
directement.

]]> Additionner dix relevés de température

]]> Erreur : dix relevés, dix tours, c'est une boucle bornée.

]]> Redemander un code tant qu'il est faux

]]> Bonne réponse : impossible de savoir combien d'essais seront
nécessaires. On répète tant que le code est faux.

]]> Afficher les nombres de 1 à 100

]]> Erreur : le nombre de tours est connu, 100, une boucle for
suffit.

]]> 6. Boucles non bornées : while — Q10 : Deux conditions de continuation `python
essais = 0
trouve = False
while essais < 3 and not trouve:
essais = essais + 1
if essais == 2:
trouve = True
print(essais)
`

Qu'affiche ce programme ?

]]> Avec and, la boucle continue seulement si toutes les conditions
sont vraies. Elle s'arrête dès que l'une devient fausse : le nombre
maximal d'essais ou la réussite.

]]> 1.0 0.0 0 true true abc 3

]]> Erreur : la boucle s'arrête dès qu'une des deux conditions
devient fausse, ici not trouve après le tour numéro 2.

]]> 2

]]> Bonne réponse : au tour numéro 2, trouve devient vrai ; au
test suivant, not trouve est faux et la boucle s'arrête.

]]> 0

]]> Erreur : au départ, les deux conditions sont vraies, la boucle
fait au moins un tour.

]]> 1

]]> Erreur : après 1 tours, essais vaut 1 et trouve est
encore faux, un tour de plus a lieu.

]]> 6. Boucles non bornées : while — Q11 : Décompte avant décollage `python
n = 3
while n > 0:
print(n)
n = n - 1
print("Décollage")
`

Qu'affiche ce programme ?

]]> L'ordre des instructions dans le bloc décide de ce qui est affiché :
afficher puis diminuer donne 3, 2, 1 ; diminuer puis afficher
donnerait 2, 1, 0.

]]> 1.0 0.0 0 true true abc 2, 1, 0 puis Décollage

]]> Erreur : l'affichage a lieu avant la soustraction, on commence
par 3.

]]> 3, 2, 1, 0 puis Décollage

]]> Erreur : quand n vaut 0, n > 0 est faux, rien n'est affiché
par la boucle.

]]> Décollage seulement

]]> Erreur : 3 > 0 est vrai, la boucle fait trois tours.

]]> 3, 2, 1 puis Décollage

]]> Bonne réponse : la boucle affiche puis diminue ; à 0, la
condition est fausse et le message final s'affiche.

]]> 6. Boucles non bornées : while — Q12 : Une valeur jamais atteinte `python
n = 0
while n != 10:
n = n + 3
print(n)
`

Que fait ce programme ?

]]> Une condition en != est dangereuse : si la valeur exacte n'est
jamais atteinte, la boucle est infinie. Une condition en < ou <=
s'arrête dès que le seuil est dépassé.

]]> 1.0 0.0 0 true true abc Il ne s'arrête jamais, n saute par-dessus 10

]]> Bonne réponse : n prend les valeurs 3, 6, 9, 12, 15… Il ne
vaut jamais exactement 10, et n != 10 reste vrai.

]]> Il affiche 10, une fois cette valeur atteinte

]]> Erreur : en avançant de 3 en 3 depuis 0, on passe de 9 à 12
sans toucher 10.

]]> Il affiche 9, dernière valeur avant 10

]]> Erreur : 9 est différent de 10, la boucle ne s'arrête pas là.

]]> Il affiche 12, première valeur au-delà de 10

]]> Erreur : à 12, la condition n != 10 est encore vraie, la
boucle continue.

]]> 6. Boucles non bornées : while — Q13 : Une somme jusqu'à un seuil `python
s = 0
k = 1
while s <= 10:
s = s + k
k = k + 1
print(k)
`

Qu'affiche ce programme ?

]]> Deux variables évoluent ensemble : l'accumulateur s et le compteur
k. Le <= inclut le cas d'égalité, ce qui peut ajouter un tour par
rapport à <.

]]> 1.0 0.0 0 true true abc 5

]]> Erreur : à s égal à 10, la condition s <= 10 est encore
vraie, un tour de plus a lieu et k passe à 6.

]]> 4

]]> Erreur : après 3 tours, s vaut 6, la boucle continue.

]]> 15

]]> Erreur : 15 est la valeur finale de s, mais le programme
affiche k.

]]> 6

]]> Bonne réponse : s passe par 1, 3, 6, 10 puis 15, et k est
augmenté à chaque tour, 5 fois, de 1 à 6.

]]> 6. Boucles non bornées : while — Q14 : Quand s'arrête un while Quand une boucle while s'arrête-t-elle ?

]]> Le while teste sa condition avant chaque tour, jamais au milieu.
Même si la condition devient fausse au milieu d'un tour, le tour va
jusqu'au bout.

]]> 1.0 0.0 0 true true abc Après un nombre de tours fixé à l'avance dans l'en-tête

]]> Erreur : c'est le principe de for avec range. Un while
ignore le nombre de tours à l'avance.

]]> Quand la variable de la condition atteint 0

]]> Erreur : la condition peut porter sur n'importe quelle valeur,
pas seulement sur 0.

]]> Quand sa condition est fausse au moment du test, avant un tour

]]> Bonne réponse : la condition est évaluée avant chaque tour ;
dès qu'elle est fausse, le programme passe à la suite.

]]> Dès que sa condition devient vraie pendant un tour

]]> Erreur : c'est l'inverse, une condition vraie fait continuer.
Et le test n'a lieu qu'entre deux tours.

]]> 6. Boucles non bornées : while — Q15 : Redemander une saisie `python
reponse = ""
while reponse != "oui":
reponse = input("Continuer ? ")
print("Merci")

L'utilisateur tape non, puis Oui, puis oui`. Combien de fois la
question est-elle posée ?

]]> Initialiser la variable à une valeur qui rend la condition vraie
permet d'entrer dans la boucle une première fois. Ensuite, chaque
saisie est retestée jusqu'à la bonne.

]]> 1.0 0.0 0 true true abc 1

]]> Erreur : après non, la condition reponse != "oui" reste
vraie.

]]> 2

]]> Erreur : Oui avec une majuscule n'est pas égal à oui, la
question est reposée.

]]> Un nombre infini de fois

]]> Erreur : la troisième saisie, oui, rend la condition fausse.

]]> 3

]]> Bonne réponse : non et Oui sont différents de oui, la
boucle continue. La troisième réponse arrête la boucle.

]]> 6. Boucles non bornées : while — Q16 : Deux variables qui se croisent `python
a = 1
b = 16
while a < b:
a = a * 2
b = b - 2
print(a, b)
`

Qu'affiche ce programme ?

]]> Quand deux variables changent dans le bloc, la trace se fait par
couples de valeurs, un couple par tour, jusqu'à celui qui rend la
condition fausse.

]]> 1.0 0.0 0 true true abc 16 8

]]> Bonne réponse : les couples successifs sont (2, 14), (4, 12), (8, 10) puis (16, 8). À ce
moment a < b est faux.

]]> 32 6

]]> Erreur : à (16, 8), la condition est fausse, la boucle s'arrête.

]]> 8 10

]]> Erreur : 8 est encore inférieur à 10, un tour de plus a lieu.

]]> 16 10

]]> Erreur : au dernier tour, b est aussi modifié et passe de 10 à
8.

]]> 6. Boucles non bornées : while — Q17 : Une variable non initialisée `python
while compteur < 10:
compteur = compteur + 1
print(compteur)
`

Que se passe-t-il ?

]]> Avant un while, on initialise les variables de la condition. C'est
la première étape du schéma : initialiser, tester, modifier dans le
bloc.

]]> 1.0 0.0 0 true true abc Une boucle infinie, la condition reste vraie

]]> Erreur : le programme s'arrête avant même le premier tour.

]]> Aucun tour, la condition est fausse dès le départ

]]> Erreur : la condition ne peut pas être évaluée du tout.

]]> Dix tours, puis l'affichage de 10 après la boucle

]]> Erreur : ce serait le cas avec compteur = 0 avant la boucle.

]]> Une erreur, compteur n'a pas de valeur au premier test

]]> Bonne réponse : la condition lit compteur avant toute
affectation, d'où une erreur NameError.

]]> 6. Boucles non bornées : while — Q18 : Diviser jusqu'à passer sous un seuil `python
x = 100
n = 0
while x > 1:
x = x / 2
n = n + 1
print(n)
`

Qu'affiche ce programme ?

]]> La division / produit des flottants, et la condition x > 1 finit
par devenir fausse. Le compteur mesure le nombre de divisions
nécessaires.

]]> 1.0 0.0 0 true true abc 7

]]> Bonne réponse : x passe par 50.0, 25.0, 12.5, 6.25, 3.125, 1.5625 puis 0.78125, en 7 divisions.

]]> 6

]]> Erreur : après 6 divisions, x vaut 1.5625, encore supérieur
à 1.

]]> 100

]]> Erreur : le programme affiche le nombre de tours, pas la valeur
de départ.

]]> 8

]]> Erreur : après 7 divisions, x est inférieur ou égal à 1 et la
boucle s'arrête.

]]> 6. Boucles non bornées : while — Q19 : Compléter pour que la boucle s'arrête `python
niveau = 0
while niveau < 5:
print(niveau)
...
`

Quelle instruction, à la place des points, garantit l'arrêt de la
boucle après cinq affichages ?

]]> Pour qu'un while s'arrête, le bloc doit modifier une variable de la
condition avec une affectation. Un calcul non affecté ne change
rien.

]]> 1.0 0.0 0 true true abc print(niveau + 1)

]]> Erreur : afficher niveau + 1 ne modifie pas niveau.

]]> niveau + 1

]]> Erreur : ce calcul n'est rangé nulle part, niveau reste à 0 et
la boucle est infinie.

]]> niveau = 0

]]> Erreur : remettre niveau à 0 empêche la condition de devenir
fausse.

]]> niveau = niveau + 1

]]> Bonne réponse : niveau augmente à chaque tour et atteint 5
après cinq affichages, ce qui rend la condition fausse.

]]> 6. Boucles non bornées : while — Q20 : Compter les chiffres d'un nombre `python
n = 4821
c = 0
while n > 0:
n = n // 10
c = c + 1
print(c)
`

Qu'affiche ce programme ?

]]> Diviser par 10 en division entière retire le dernier chiffre. Compter
les divisions jusqu'à 0 revient à compter les chiffres du nombre.

]]> 1.0 0.0 0 true true abc 5

]]> Erreur : à 0, la boucle s'arrête, il n'y a pas de tour
supplémentaire.

]]> 3

]]> Erreur : à 4, la condition n > 0 est encore vraie, un
tour de plus donne 0.

]]> 482

]]> Erreur : le programme affiche le compteur c, pas n.

]]> 4

]]> Bonne réponse : n passe par 482, 48, 4 puis 0, soit 4
divisions, une par chiffre.

]]> 6. Boucles non bornées : while — Q21 : Un compte à rebours de trois en trois Qu'affiche ce programme ?
`python
i = 10
while i > 0:
i = i - 3
print(i)
`

]]> Un while continue tant que sa condition est vraie : il faut
suivre la variable jusqu'à ce que la condition devienne fausse.

]]> 1.0 0.0 0 true true abc 7

]]> Erreur : 7 est la valeur après un seul tour, et la boucle
continue tant que i reste positif.

]]> 10

]]> Erreur : la condition i > 0 est vraie au départ, la boucle
modifie bien i.

]]> 1

]]> Erreur : 1 est encore strictement positif, donc un tour
de plus a lieu.

]]> -2

]]> Bonne réponse : i descend de 3 en 3 tant qu'il est
strictement positif. Le dernier tour part de 1 et
aboutit à -2, qui arrête la boucle.

]]> 6. Boucles non bornées : while — Q22 : Multiplier par dix jusqu'à dépasser Qu'affiche ce programme ?
`python
x = 1
while x < 800:
x = x * 10
print(x)
`

]]> La boucle s'arrête dès que la condition devient fausse, c'est-à-dire
à la première valeur qui atteint ou dépasse le seuil.

]]> 1.0 0.0 0 true true abc 100

]]> Erreur : 100 est encore inférieur à 800, donc un tour de
plus a lieu.

]]> 1

]]> Erreur : la condition est vraie au départ, et x est multiplié
au moins une fois.

]]> 800

]]> Erreur : x ne prend que des puissances de 10, il ne s'arrête
pas exactement sur 800.

]]> 1000

]]> Bonne réponse : x prend les valeurs 1, 10, 100, et ainsi de
suite, jusqu'à la première puissance de 10 qui atteint ou
dépasse 800, soit 1000.

]]> 6. Boucles non bornées : while — Q23 : Le premier multiple au-delà d'un seuil Qu'affiche ce programme ?
`python
n = 0
while n <= 50:
n = n + 7
print(n)
`

]]> Ce schéma trouve le premier multiple d'un nombre qui dépasse un
seuil : on avance pas à pas tant que le seuil n'est pas franchi.

]]> 1.0 0.0 0 true true abc 7

]]> Erreur : 7 est la valeur après un seul tour, et la boucle
continue tant que n <= 50.

]]> 56

]]> Bonne réponse : n parcourt les multiples de 7 et s'arrête au
premier qui dépasse strictement 50, soit 56.

]]> 49

]]> Erreur : 49 ne dépasse pas 50, la condition n <= 50 est
encore vraie et un tour de plus a lieu.

]]> 50

]]> Erreur : n ne prend que des multiples de 7.

]]> 6. Boucles non bornées : while — Q24 : Combien de mois pour atteindre l'objectif Qu'affiche ce programme ?
`python
argent = 100
mois = 0
while argent < 150:
argent = argent + 12
mois = mois + 1
print(mois)
`

]]> Deux variables évoluent ensemble : l'une avance vers l'objectif,
l'autre compte les tours. Le print choisit laquelle afficher.

]]> 1.0 0.0 0 true true abc 4

]]> Erreur : après 4 tours, argent est encore inférieur à 150,
la boucle fait un tour de plus.

]]> 5

]]> Bonne réponse : argent part de 100 et gagne 12 par tour. Il
faut 5 tours pour atteindre ou dépasser 150, et mois compte
ces tours.

]]> 160

]]> Erreur : 160 est la valeur finale de argent, mais c'est
mois qui est affiché.

]]> 6

]]> Erreur : dès que argent atteint 150, la condition argent <
150 est fausse et la boucle s'arrête.

]]> 6. Boucles non bornées : while — Q25 : Des nombres pairs jusqu'à un seuil Combien de lignes ce programme affiche-t-il, et laquelle en dernier ?
`python
n = 0
while n <= 6:
print(n)
n = n + 2
`

]]> Pour compter les lignes, on liste les valeurs prises par la
variable : 0, 2, 4, et ainsi de suite tant que la condition tient.

]]> 1.0 0.0 0 true true abc Une infinité de lignes, la boucle ne s'arrêtant jamais

]]> Erreur : n grandit à chaque tour et finit par dépasser 6.

]]> 3 lignes, la dernière étant 6

]]> Erreur : la valeur 0 est affichée elle aussi, au premier tour.

]]> 4 lignes, la dernière étant 6

]]> Bonne réponse : n prend les valeurs paires de 0 à 6,
chacune affichée avant l'ajout de 2. Cela fait 4 lignes.

]]> 6 lignes, la dernière étant 6

]]> Erreur : n avance de 2 en 2, il n'y a pas une ligne par
entier.

]]> 6. Boucles non bornées : while — Q26 : Deux conditions pour continuer Qu'affiche ce programme ?
`python
i = 0
s = 0
while i < 10 and s < 15:
s = s + i
i = i + 1
print(i, s)
`

]]> Avec and, la boucle s'arrête dès que l'une des deux conditions
devient fausse. Suivre i et s tour par tour est le seul moyen
sûr de trouver l'état final.

]]> 1.0 0.0 0 true true abc 7 21

]]> Erreur : cet état correspond à un tour de trop, la boucle
s'arrête dès qu'une condition devient fausse.

]]> 6 15

]]> Bonne réponse : la boucle continue tant que les deux conditions
sont vraies. Elle s'arrête dès que s atteint 15, ou que i
atteint 10, selon ce qui arrive en premier.

]]> 10 45

]]> Erreur : vérifie si la condition sur s arrête la boucle avant
que i n'atteigne 10.

]]> 5 10

]]> Erreur : cet état correspond à un tour de moins. Vérifie que les
deux conditions sont encore vraies à ce moment.

]]> 6. Boucles non bornées : while — Q27 : Additionner jusqu'à un seuil Qu'affiche ce programme ?
`python
s = 0
i = 1
while s < 20:
s = s + i
i = i + 1
print(i)
`

]]> Quand deux variables évoluent dans une boucle, l'ordre des
instructions compte : ici i est modifié après avoir servi.

]]> 1.0 0.0 0 true true abc 21

]]> Erreur : 21 est la valeur finale de s, alors que c'est i
qui est affiché.

]]> 7

]]> Bonne réponse : s cumule 1, 2, 3, et ainsi de suite jusqu'à
atteindre 21, qui dépasse 20. i a alors été incrémenté une
fois de plus que la dernière valeur ajoutée, 6, d'où 7.

]]> 20

]]> Erreur : 20 est le seuil, ni i ni s ne s'y arrêtent
exactement.

]]> 6

]]> Erreur : 6 est la dernière valeur ajoutée à s, mais i
est incrémenté juste après l'ajout.

]]> 6. Boucles non bornées : while — Q28 : Compter une lettre avec un indice Qu'affiche ce programme ?
`python
mot = "anaconda"
i = 0
c = 0
while i < len(mot):
if mot[i] == "a":
c = c + 1
i = i + 1
print(c)
`

]]> Un while avec un indice parcourt une chaîne caractère par
caractère. Le compteur n'avance que quand la condition est vraie.

]]> 1.0 0.0 0 true true abc 8

]]> Erreur : 8 est la longueur du mot, le nombre de tours, pas le
nombre de lettres a.

]]> 0

]]> Erreur : 0 est l'indice de la première lettre a,
mais le programme compte les occurrences.

]]> 3

]]> Bonne réponse : i parcourt les indices de 0 à 7, et c
est incrémenté à chaque lettre a rencontrée, soit 3 fois.

]]> 5

]]> Erreur : 5 est le nombre de lettres différentes de
a, le if compte l'inverse.

]]> 6. Boucles non bornées : while — Q29 : La même boucle avec while Quelle boucle while affiche exactement ce que produit
for i in range(5): print(i) ?

]]> Toute boucle for sur un range se réécrit en while avec une
variable initialisée, une condition et une incrémentation. L'ordre
des instructions dans le corps change le résultat.

]]> 1.0 0.0 0 true true abc `python
i = 1
while i <= 5:
print(i)
i = i + 1
`

]]> Erreur : cette boucle affiche 1 à 5, alors que range(5)
commence à 0 et s'arrête à 4.

]]> `python
i = 0
while i < 5:
print(i)
i = i + 1
`

]]> Bonne réponse : i part de 0, est affiché puis incrémenté, et la
boucle s'arrête avant 5. Les valeurs 0 à 4 sont affichées.

]]> `python
i = 0
while i < 5:
i = i + 1
print(i)
`

]]> Erreur : incrémenter avant d'afficher décale tout : cette boucle
affiche 1 à 5.

]]> `python
i = 0
while i <= 5:
print(i)
i = i + 1
`

]]> Erreur : avec <=, la valeur 5 est affichée, ce que range(5)
ne fait pas.

]]> 6. Boucles non bornées : while — Q30 : Compter les doublements Qu'affiche ce programme ?
`python
e = 1
n = 0
while e < 1000:
e = e * 2
n = n + 1
print(n)
`

]]> Ce programme répond à la question « combien de fois faut-il doubler
pour dépasser un seuil ? ». Le compteur n en garde la trace.

]]> 1.0 0.0 0 true true abc 9

]]> Erreur : après 9 doublements, e est encore inférieur à 1000,
un tour de plus a lieu.

]]> 1000

]]> Erreur : 1000 est le seuil, pas le nombre de tours.

]]> 10

]]> Bonne réponse : e double à chaque tour et n compte les
tours. Il faut 10 doublements pour que e atteigne 1024, la
première puissance de 2 qui vaut au moins 1000.

]]> 1024

]]> Erreur : 1024 est la valeur finale de e, mais le programme
affiche n.

]]>