$course$/QCM de NSI/SNT/5. Boucles bornées : for La boucle for et la fonction range, avec un, deux ou trois arguments ;
le nombre de tours et les valeurs prises par la variable de boucle ;
les schémas de l'accumulateur et du compteur ; le parcours d'une
chaîne de caractères ; les boucles imbriquées.

]]> 5. Boucles bornées : for — Q01 : Les valeurs de range

for i in range(4):
    print(i)

Quelles valeurs sont affichées ?

]]> range(n) produit les entiers de 0 à n - 1, soit n valeurs. La
variable de boucle les prend une à une, dans l'ordre.

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

]]> Bonne réponse : range(4) fournit quatre entiers, de 0 à 3. La
valeur 4 n'en fait pas partie.

]]> 1, 2, 3 et 4

]]> Erreur : range commence à 0 quand on ne lui donne qu'un
argument.

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

]]> Erreur : ce serait cinq valeurs. range(4) s'arrête avant 4.

]]> Quatre fois le nombre 4

]]> Erreur : i change à chaque tour, il prend les valeurs
successives fournies par range.

]]> 5. Boucles bornées : for — Q02 : Combien de pas Un robot avance d'un pas à chaque tour de boucle.

for k in range(2, 7):
    avancer()

Combien de pas fait-il ?

]]> range(a, b) fournit les entiers de a inclus à b exclu, soit
b - a valeurs. Le nombre de tours ne dépend pas de ce que fait le
corps de la boucle.

]]> 1.0 0.0 0 true true abc 5

]]> Bonne réponse : k prend les valeurs 2, 3, 4, 5 et 6, soit 5
tours. Le nombre de tours vaut 7 moins 2.

]]> 6

]]> Erreur : la borne 7 est exclue, la dernière valeur est 6.

]]> 7

]]> Erreur : la boucle ne part pas de 0 mais de 2, et s'arrête avant
7.

]]> 4

]]> Erreur : de 2 à 6 inclus, il y a 5 valeurs.

]]> 5. Boucles bornées : for — Q03 : Un range qui descend

for n in range(10, 0, -3):
    print(n)

Quelles valeurs sont affichées ?

]]> range(depart, fin, pas) accepte un pas négatif pour compter à
rebours. La borne fin reste exclue, comme toujours.

]]> 1.0 0.0 0 true true abc 10, 7, 4 et 1

]]> Bonne réponse : on part de 10 et on retire 3 à chaque fois tant
qu'on reste strictement au-dessus de 0.

]]> 10, 7 et 4

]]> Erreur : 1 est encore strictement supérieur à 0, il est
affiché.

]]> 10, 7, 4, 1 et -2

]]> Erreur : -2 dépasse la borne 0, la boucle s'arrête avant.

]]> 0, 3, 6 et 9

]]> Erreur : le premier argument est le point de départ, 10, et le
pas est négatif.

]]> 5. Boucles bornées : for — Q04 : La somme des premiers entiers

total = 0
for i in range(1, 6):
    total = total + i
print(total)

Qu'affiche ce programme ?

]]> L'accumulateur est le schéma de base : une variable initialisée à 0
avant la boucle, à laquelle on ajoute une valeur à chaque tour. À la
sortie, elle contient la somme.

]]> 1.0 0.0 0 true true abc 15

]]> Bonne réponse : la boucle ajoute 1, 2, 3, 4 et 5, ce qui fait
15.

]]> 10

]]> Erreur : 10 serait la somme de 1 à 4. La valeur 5 est incluse,
seule la borne 6 est exclue.

]]> 21

]]> Erreur : 21 ajouterait 6, qui est exclu par range(1, 6).

]]> 5

]]> Erreur : total accumule les valeurs successives, il ne garde
pas la dernière.

]]> 5. Boucles bornées : for — Q05 : Compter les multiples

compte = 0
for n in range(1, 21):
    if n % 5 == 0:
        compte = compte + 1
print(compte)

Qu'affiche ce programme ?

]]> Le compteur est un accumulateur qui n'augmente que sous condition.
Une variable à 0, un if dans la boucle, et un ajout de 1 quand la
propriété est vérifiée.

]]> 1.0 0.0 0 true true abc 4

]]> Bonne réponse : entre 1 et 20, les multiples de 5 sont 5, 10, 15 et 20.

]]> 5

]]> Erreur : 25 n'est pas atteint, la boucle s'arrête à 20.

]]> 20

]]> Erreur : le compteur n'augmente que quand la condition est
vraie, pas à chaque tour.

]]> 3

]]> Erreur : 20 est bien parcouru, range(1, 21) va jusqu'à 20.

]]> 5. Boucles bornées : for — Q06 : La valeur qui reste

for i in range(3):
    x = i * 10
print(x)

Qu'affiche ce programme ?

]]> Les variables modifiées dans la boucle conservent leur dernière
valeur à la sortie. Il en va de même pour la variable de boucle
elle-même.

]]> 1.0 0.0 0 true true abc 20

]]> Bonne réponse : x est recalculé à chaque tour ; au dernier,
i vaut 2 et x vaut 20. Cette valeur subsiste après la
boucle.

]]> 30

]]> Erreur : i prend les valeurs 0, 1 et 2, jamais 3.

]]> 0

]]> Erreur : 0 est la valeur au premier tour, écrasée ensuite.

]]> Une erreur, x n'existe plus après la boucle

]]> Erreur : une variable créée dans une boucle reste accessible
après. Elle garde sa dernière valeur.

]]> 5. Boucles bornées : for — Q07 : Parcourir une chaîne

for lettre in "SNT":
    print(lettre)

Qu'affiche ce programme ?

]]> for sait parcourir une chaîne : la variable prend successivement
chaque caractère. Pas besoin de range pour cela.

]]> 1.0 0.0 0 true true abc S, N et T, sur trois lignes

]]> Bonne réponse : la boucle parcourt la chaîne caractère par
caractère, et chaque print occupe une ligne.

]]> SNT sur une seule ligne, sans retour

]]> Erreur : chaque tour affiche un seul caractère et revient à la
ligne.

]]> 0, 1 et 2, les positions des lettres

]]> Erreur : en parcourant une chaîne, la variable reçoit les
caractères, pas leurs positions.

]]> lettre trois fois, sur trois lignes

]]> Erreur : print(lettre) affiche la valeur de la variable, un
caractère différent à chaque tour.

]]> 5. Boucles bornées : for — Q08 : Compter une lettre

compte = 0
for c in "programmation":
    if c == "a":
        compte = compte + 1
print(compte)

Qu'affiche ce programme ?

]]> Compter une lettre combine le parcours d'une chaîne et le schéma du
compteur : un test sur chaque caractère, un ajout de 1 quand il
convient.

]]> 1.0 0.0 0 true true abc 2

]]> Bonne réponse : en épelant « programmation », on trouve 2 fois la
lettre a.

]]> 3

]]> Erreur : en épelant le mot, on ne trouve que 2 fois la lettre a.

]]> 1

]]> Erreur : chaque a rencontré ajoute 1, et il y en a 2.

]]> 13

]]> Erreur : 13 est le nombre de tours, mais le compteur n'augmente
que sur les a.

]]> 5. Boucles bornées : for — Q09 : Afficher avant d'ajouter

s = 0
for k in range(3):
    print(s)
    s = s + k

Qu'affiche ce programme ?

]]> La place du print dans le corps de la boucle change ce qui est
affiché. Une trace tour par tour, avec les valeurs de k et de s,
lève tout doute.

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

]]> Bonne réponse : au premier tour s vaut 0 ; puis on ajoute 0.
Au deuxième, s vaut encore 0 ; puis on ajoute 1. Au troisième,
s vaut 1.

]]> 0, 1 et 3

]]> Erreur : ce seraient les valeurs après chaque ajout. Or le
print vient avant l'ajout.

]]> 0, 1 et 2

]]> Erreur : le programme affiche s, pas k.

]]> 1, 3 et 6

]]> Erreur : k part de 0, et l'affichage précède l'ajout.

]]> 5. Boucles bornées : for — Q10 : Deux boucles imbriquées

for i in range(2):
    for j in range(3):
        print(i, j)

Combien de lignes ce programme affiche-t-il ?

]]> Quand une boucle en contient une autre, le nombre total de passages
est le produit des nombres de tours. Ici, (0, 0), (0, 1), et
ainsi de suite jusqu'à (0, 2), puis la même chose pour chaque
valeur suivante de i.

]]> 1.0 0.0 0 true true abc 6

]]> Bonne réponse : pour chacune des 2 valeurs de i, la boucle
intérieure fait 3 tours, soit 2 fois 3 lignes.

]]> 5

]]> Erreur : les tours se multiplient, ils ne s'additionnent pas.

]]> 3

]]> Erreur : la boucle intérieure est relancée entièrement pour
chaque valeur de i.

]]> 2

]]> Erreur : chaque tour de la boucle extérieure déclenche 3
affichages.

]]> 5. Boucles bornées : for — Q11 : La dernière valeur affichée

for i in range(1, 10, 2):
    print(i)

Quelle est la dernière valeur affichée ?

]]> Avec trois arguments, range part du premier, avance du troisième
et s'arrête avant le deuxième. Ici, il énumère 1, 3, 5, 7 et 9.

]]> 1.0 0.0 0 true true abc 9

]]> Bonne réponse : les valeurs sont 1, 3, 5, 7 et 9. La suivante,
11, dépasse la borne.

]]> 10

]]> Erreur : la borne 10 est exclue, et de toute façon le pas de 2
ne l'atteint pas.

]]> 7

]]> Erreur : 9 est encore strictement inférieur à 10, il est
affiché.

]]> 8

]]> Erreur : en partant de 1 avec un pas de 2, on ne passe que par
1, 3, 5 et ainsi de suite.

]]> 5. Boucles bornées : for — Q12 : Un produit

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

Qu'affiche ce programme ?

]]> Pour accumuler un produit, on initialise à 1, pas à 0. Le schéma est
celui de l'accumulateur, avec une multiplication à la place de
l'addition.

]]> 1.0 0.0 0 true true abc 24

]]> Bonne réponse : 1 fois 2 fois 3 fois 4 font 24.

]]> 120

]]> Erreur : 120 inclurait le facteur 5, exclu par range(1, 5).

]]> 10

]]> Erreur : 10 serait la somme de 1 à 4, or la boucle multiplie.

]]> 0

]]> Erreur : p part de 1, pas de 0. Un produit initialisé à 0
resterait nul.

]]> 5. Boucles bornées : for — Q13 : Modifier la variable de boucle

for i in range(3):
    i = i + 10
    print(i)

Qu'affiche ce programme ?

]]> Au début de chaque tour, for donne à sa variable la valeur suivante
de range, quoi qu'on lui ait fait au tour précédent. Modifier la
variable de boucle n'influence pas le nombre de tours.

]]> 1.0 0.0 0 true true abc 10, 11 et 12

]]> Bonne réponse : à chaque tour, i reçoit la valeur suivante de
range, 0, 1 et 2, avant l'ajout de 10.

]]> 10, 21 et 32

]]> Erreur : la modification de i ne se cumule pas. range
réaffecte i au début de chaque tour.

]]> 10, puis une erreur

]]> Erreur : modifier la variable de boucle est autorisé, même si
c'est déconseillé.

]]> 0, 1 et 2

]]> Erreur : l'ajout de 10 a lieu avant l'affichage.

]]> 5. Boucles bornées : for — Q14 : La borne exclue La valeur 5 est-elle affichée par la boucle suivante ?

for i in range(5):
    print(i)

]]> range(n) compte de 0 à n - 1. Retenir que la borne est exclue
évite l'erreur classique du « tour de trop » ou du « tour de moins ».

]]> 1.0 0.0 0 true true abc Non, range(5) s'arrête à 4

]]> Bonne réponse : range(5) fournit 0, 1, 2, 3 et 4, soit cinq
valeurs, mais pas 5.

]]> Oui, en dernier

]]> Erreur : la borne donnée à range est toujours exclue.

]]> Oui, en premier

]]> Erreur : la boucle commence à 0.

]]> Oui, cinq fois de suite

]]> Erreur : i change à chaque tour et ne vaut jamais 5.

]]> 5. Boucles bornées : for — Q15 : Compléter une boucle On veut afficher tous les entiers de 3 à 12 inclus. Quelle ligne
convient ?

]]> Pour parcourir de a à b inclus, on écrit range(a, b + 1). Le
« plus un » compense l'exclusion de la borne.

]]> 1.0 0.0 0 true true abc for n in range(3, 13):

]]> Bonne réponse : pour inclure 12, la borne exclue doit être 13.

]]> for n in range(3, 12):

]]> Erreur : 12 serait exclu, la boucle s'arrêterait à 11.

]]> for n in range(12):

]]> Erreur : cette boucle part de 0 et s'arrête à 11.

]]> for n in range(13, 3):

]]> Erreur : avec un départ supérieur à la borne et un pas positif,
range est vide : aucun tour.

]]> 5. Boucles bornées : for — Q16 : La somme des nombres pairs

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

Qu'affiche ce programme ?

]]> Accumulateur et condition se combinent : on n'ajoute une valeur que
si elle vérifie le test. C'est le schéma d'une somme sélective.

]]> 1.0 0.0 0 true true abc 30

]]> Bonne réponse : 2, 4, 6, 8 et 10 font 30.

]]> 25

]]> Erreur : 25 est la somme des impairs de 1 à 9. La condition
retient les pairs.

]]> 55

]]> Erreur : 55 serait la somme de tous les entiers de 1 à 10, sans
la condition.

]]> 20

]]> Erreur : 10 est bien parcouru, range(1, 11) va jusqu'à 10.

]]> 5. Boucles bornées : for — Q17 : Chercher un maximum

maxi = 0
for x in range(1, 6):
    valeur = x * (6 - x)
    if valeur > maxi:
        maxi = valeur
print(maxi)

Qu'affiche ce programme ?

]]> Pour trouver un maximum, on garde une variable mise à jour chaque
fois qu'une valeur la dépasse. À la fin, elle contient la plus
grande valeur rencontrée.

]]> 1.0 0.0 0 true true abc 9

]]> Bonne réponse : les valeurs calculées sont 5, 8, 9, 8 et 5. La
plus grande est 9, atteinte pour x égal à 3.

]]> 8

]]> Erreur : 8 est dépassé par 9 au tour numéro 3.

]]> 5

]]> Erreur : 5 est la dernière valeur calculée, mais maxi garde la
plus grande rencontrée.

]]> 6

]]> Erreur : 6 n'est jamais une valeur de x * (6 - x).

]]> 5. Boucles bornées : for — Q18 : Un compte à rebours

for t in range(3, 0, -1):
    print(t)
print("Partez")

Qu'affiche ce programme ?

]]> Un pas négatif fait décroître la variable de boucle. Les règles sont
inchangées : départ inclus, borne exclue.

]]> 1.0 0.0 0 true true abc 3, 2, 1 puis Partez

]]> Bonne réponse : le pas -1 fait descendre de 3 à 1, la borne 0
étant exclue, puis la ligne hors de la boucle s'exécute.

]]> 3, 2, 1, 0 puis Partez

]]> Erreur : la borne 0 est exclue, même en descendant.

]]> 2, 1, 0 puis Partez

]]> Erreur : le départ est le premier argument, 3.

]]> Partez seulement

]]> Erreur : range(3, 0, -1) fournit bien trois valeurs.

]]> 5. Boucles bornées : for — Q19 : Construire une chaîne

mot = ""
for c in "abc":
    mot = c + mot
print(mot)

Qu'affiche ce programme ?

]]> Une chaîne peut servir d'accumulateur : on part de la chaîne vide et
on concatène à chaque tour. L'ordre de la concaténation décide du
sens de la chaîne obtenue.

]]> 1.0 0.0 0 true true abc cba

]]> Bonne réponse : chaque caractère est placé devant ce qui est
déjà construit : a, puis ba, puis cba.

]]> abc

]]> Erreur : ce serait le résultat de mot = mot + c, qui ajoute à
la fin.

]]> abcabc

]]> Erreur : chaque tour n'ajoute qu'un caractère.

]]> ccc

]]> Erreur : mot conserve les caractères précédents.

]]> 5. Boucles bornées : for — Q20 : Un range vide

for i in range(5, 5):
    print(i)
print("Fin")

Qu'affiche ce programme ?

]]> Une boucle for sur un range vide ne s'exécute pas du tout, sans
erreur. C'est un cas à prévoir quand les bornes viennent d'un calcul.

]]> 1.0 0.0 0 true true abc Fin seulement

]]> Bonne réponse : range(5, 5) ne contient aucune valeur, la
boucle ne fait aucun tour, et le programme continue.

]]> 5 puis Fin

]]> Erreur : la borne 5 est exclue, il ne reste rien à parcourir.

]]> Une erreur, un range ne peut pas être vide

]]> Erreur : un range vide est parfaitement valable, la boucle
est simplement sautée.

]]> 0, 1, 2, 3, 4 puis Fin

]]> Erreur : ce serait range(5). Avec deux arguments, le départ
est 5.

]]> 5. Boucles bornées : for — Q21 : Un message répété Combien de fois ce programme affiche-t-il hop ?

for i in range(3):
    print("hop")

]]> range(n) produit n valeurs, et le corps de la boucle est exécuté
une fois pour chacune.

]]> 1.0 0.0 0 true true abc 3 fois

]]> Bonne réponse : range(3) fournit 3 valeurs, de 0 à 2,
donc le corps de la boucle s'exécute 3 fois.

]]> 2 fois

]]> Erreur : range(3) s'arrête avant 3, mais commence à 0, ce
qui fait bien 3 valeurs.

]]> 4 fois

]]> Erreur : la valeur 3 elle-même n'est pas comprise dans
range(3).

]]> Une seule fois, i n'étant pas utilisé

]]> Erreur : la boucle se répète même si i ne sert pas dans le
corps.

]]> 5. Boucles bornées : for — Q22 : Une table de multiplication partielle Qu'affiche ce programme, les valeurs étant lues ligne par ligne ?

for i in range(1, 4):
    print(i * 10)

]]> range(1, 4) donne 1, 2, 3 : la première borne est incluse, la
seconde exclue.

]]> 1.0 0.0 0 true true abc 10 20 30

]]> Bonne réponse : i prend les valeurs 1, 2 et 3, et chacune est
multipliée par 10.

]]> 10 20 30 40

]]> Erreur : la borne 4 est exclue, i ne la prend jamais.

]]> 0 10 20

]]> Erreur : range(1, 4) commence à 1, pas à 0.

]]> 1 2 3

]]> Erreur : c'est i * 10 qui est affiché, pas i.

]]> 5. Boucles bornées : for — Q23 : Un accumulateur qui avance de deux en deux Qu'affiche ce programme ?

s = 0
for i in range(3):
    s = s + 2
print(s)

]]> Une boucle qui ajoute une constante calcule une multiplication :
3 tours de + 2 donnent 6.

]]> 1.0 0.0 0 true true abc 6

]]> Bonne réponse : la boucle tourne 3 fois et ajoute 2 à chaque
tour, soit 6 au total.

]]> 3

]]> Erreur : 3 est le nombre de tours, mais chaque tour ajoute 2.

]]> 2

]]> Erreur : s grandit à chaque tour, il ne reste pas à 2.

]]> 5

]]> Erreur : il ne s'agit pas d'ajouter 2 une fois à 3, mais
d'ajouter 2 à chacun des 3 tours.

]]> 5. Boucles bornées : for — Q24 : Les impairs d'une plage Qu'affiche ce programme, les valeurs étant lues ligne par ligne ?

for i in range(5):
    if i % 2 == 1:
        print(i)

]]> Un if dans une boucle sélectionne certains tours. Ici, le reste
de la division par 2 reconnaît les impairs.

]]> 1.0 0.0 0 true true abc 1 3

]]> Bonne réponse : seules les valeurs dont le reste par 2 vaut 1,
les impairs, sont affichées, et 5 est exclu de la plage.

]]> 1 3 5

]]> Erreur : range(5) s'arrête à 4, la valeur 5 n'est
jamais testée.

]]> 0 2 4

]]> Erreur : i % 2 == 1 retient les impairs, pas les pairs.

]]> 0 1 2 3 4

]]> Erreur : le if filtre les valeurs, toutes ne sont pas
affichées.

]]> 5. Boucles bornées : for — Q25 : Compter au-delà d'un seuil Qu'affiche ce programme ?

n = 0
for i in range(10):
    if i > 6:
        n = n + 1
print(n)

]]> Un compteur n'avance que lorsque la condition est vraie. Compter
les tours retenus demande d'écrire la liste des valeurs qui
passent le test.

]]> 1.0 0.0 0 true true abc 3

]]> Bonne réponse : les valeurs de range(10) strictement
supérieures à 6 vont de 7 à 9, il y en a 3.

]]> 4

]]> Erreur : i > 6 exclut 6 lui-même, et range(10) s'arrête
à 9.

]]> 6

]]> Erreur : 6 est le seuil, pas le nombre de valeurs qui le
dépassent.

]]> 10

]]> Erreur : seules les valeurs qui vérifient la condition sont
comptées.

]]> 5. Boucles bornées : for — Q26 : Des carrés ligne par ligne Qu'affiche ce programme ? Les lignes sont données séparées par des
virgules.

for i in range(3):
    print(i, i * i)

]]> Un print dans la boucle produit une ligne par tour, avec les
valeurs calculées à ce tour.

]]> 1.0 0.0 0 true true abc 0 0, 1 1, 2 4

]]> Bonne réponse : pour chaque valeur de i, de 0 à 2, la ligne
affiche i puis son carré.

]]> 1 1, 2 4, 3 9

]]> Erreur : range(3) commence à 0 et exclut 3.

]]> 0 0, 1 2, 2 4

]]> Erreur : i * i est le carré de i, pas son double.

]]> 3 9

]]> Erreur : le print est dans la boucle, une ligne par tour est
affichée.

]]> 5. Boucles bornées : for — Q27 : Une somme de doubles Qu'affiche ce programme ?

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

]]> Pour suivre un accumulateur, on note la valeur ajoutée à chaque
tour et on additionne : ici 0, 2, 4, et ainsi de suite jusqu'à
8.

]]> 1.0 0.0 0 true true abc 20

]]> Bonne réponse : les doubles de 0 à 4 s'additionnent : la
somme de 0 à 4 vaut 10, et son double 20.

]]> 10

]]> Erreur : 10 est la somme des valeurs de i sans le
doublement.

]]> 8

]]> Erreur : 8 est seulement la dernière valeur ajoutée,
total accumule toutes les autres.

]]> 0

]]> Erreur : total part de 0 mais grandit à chaque tour.

]]> 5. Boucles bornées : for — Q28 : La somme des multiples de trois Qu'affiche ce programme ?

s = 0
for i in range(10):
    if i % 3 == 0:
        s = s + i
print(s)

]]> Filtre et accumulateur se combinent : le if choisit les valeurs,
l'addition les cumule.

]]> 1.0 0.0 0 true true abc 18

]]> Bonne réponse : seuls les multiples de 3 inférieurs à 10 sont
ajoutés, 0 compris, et leur somme vaut 18.

]]> 4

]]> Erreur : 4 est le nombre de multiples de 3 retenus, pas leur
somme.

]]> 45

]]> Erreur : 45 est la somme de toutes les valeurs de
range(10), sans le filtre.

]]> 10

]]> Erreur : 10 est la borne de la plage, elle n'est même pas
parcourue.

]]> 5. Boucles bornées : for — Q29 : Un triangle d'étoiles Qu'affiche ce programme ? Les lignes sont données séparées par des
virgules.

for i in range(3):
    print("*" * (i + 1))

]]> Multiplier une chaîne par un entier la répète. Combiné à une
boucle, cela dessine des figures ligne par ligne.

]]> 1.0 0.0 0 true true abc , ,

]]> Bonne réponse : au tour i, la chaîne "*" est répétée
i + 1 fois, donc 1, puis 2, et ainsi de suite jusqu'à 3.

]]> , , ***

]]> Erreur : le nombre d'étoiles dépend de i, il change à chaque
tour.

]]> , *

]]> Erreur : range(3) donne 3 tours, et le dernier affiche 3
étoiles grâce au + 1.

]]> *

]]> Erreur : chaque tour produit sa propre ligne, et "" k
colle les étoiles sans espace.

]]> 5. Boucles bornées : for — Q30 : Des sommes affichées au fil de la boucle Qu'affiche ce programme, les valeurs étant lues ligne par ligne ?

y = 0
for x in range(4):
    y = y + x
    print(y)

]]> Afficher dans la boucle montre l'évolution de l'accumulateur ;
afficher après la boucle ne montre que sa valeur finale.

]]> 1.0 0.0 0 true true abc 0 1 3 6

]]> Bonne réponse : y cumule les valeurs de x et est affiché
après chaque ajout, d'où les sommes successives.

]]> 0 1 2 3

]]> Erreur : c'est y qui est affiché, pas x.

]]> 6

]]> Erreur : le print est dans la boucle, il y a une ligne par
tour.

]]> 1 3 6 10

]]> Erreur : range(4) commence à 0, donc la première somme vaut
0.

]]>