Compléter un programme avec une boucle

[enonce]
Une association récolte des dons. Chaque semaine, le montant collecté augmente de $3$ euros : $3$ euros la première semaine, $6$ euros la deuxième, $9$ euros la troisième, et ainsi de suite jusqu'à la dixième semaine.

On souhaite écrire un programme Python qui calcule le total récolté au bout des $10$ semaines, c'est-à-dire la somme $3 + 6 + 9 + \ldots + 30$. Le programme est donné à trous : il s'agit de le compléter ligne par ligne, puis d'anticiper son affichage.
[/enonce]

[etape]
On hésite entre une boucle for et une boucle while pour parcourir les $10$ semaines. Quel type de boucle convient le mieux ici ?
[qcm]
[option correct="true"]Une boucle for[/option]
[option]Une boucle while[/option]
[option]Les deux sont impossibles ici[/option]
[reponse statut="correct"]Exactement !
Le nombre de répétitions est connu d'avance : $10$ semaines.
Une boucle for avec range est donc la plus adaptée, car elle est faite pour répéter un nombre de fois fixé à l'avance.[/reponse]
[reponse motif="Une boucle while"]Une boucle while reste possible techniquement, mais elle n'est pas la plus naturelle ici.
Repenser à la question décisive : connaît-on à l'avance le nombre de tours à effectuer ?[/reponse]
[reponse statut="incorrect"]Les deux types de boucles peuvent répéter des instructions.
Se demander lequel est le plus adapté quand le nombre de répétitions est connu dès le départ.[/reponse]
[/qcm]
[/etape]

[etape]
Avant la boucle, il faut préparer la variable qui contiendra le total récolté. On la nomme S. Écrire la ligne d'initialisation de S.
[code-python id="init" attendu="S = 0"]
[reponse statut="correct"]Correct !
Comme aucun euro n'a encore été ajouté, le total démarre à $0$.[/reponse]
[reponse motif="S == 0"]Le double signe == sert à comparer deux valeurs, pas à affecter une valeur à une variable.[/reponse]
[reponse motif="S = 1"]Vérifier la valeur de départ : combien la somme contient-elle avant le premier ajout ?[/reponse]
[reponse statut="incorrect"]On affecte une valeur de départ à S avec le signe = simple.
Quelle valeur neutre choisir pour une somme qui n'a encore rien accumulé ?[/reponse]
[aide essai="2"]Pour une somme, la valeur de départ doit être neutre : ajouter cette valeur ne change rien au total.[/aide]
[aide essai="3"]La ligne est de la forme S = ... où ... est la valeur de départ d'une somme.[/aide]
[/code-python]
[solution]

S = 0

[/solution]
[/etape]

[etape]
La boucle est écrite for i in range(1, ...) de façon à ce que i prenne successivement les valeurs $1, 2, 3, \ldots, 10$. Par quelle valeur faut-il remplacer les pointillés pour que la borne supérieure $10$ soit bien parcourue ?
[math id="borne" attendu="11"]
[reponse statut="correct"]Exactement !
Avec range(1, 11), la valeur $11$ est exclue : i parcourt donc bien $1, 2, \ldots, 10$.[/reponse]
[reponse motif="10"]Avec range, la borne supérieure indiquée n'est jamais atteinte : elle est exclue. Vérifier si $10$ serait alors parcouru.[/reponse]
[reponse statut="incorrect"]Penser à la règle des bornes de range(a, b) : la première est incluse, la seconde est exclue.[/reponse]
[aide essai="2"]Dans range(a, b), les valeurs vont de a inclus jusqu'à b exclu.[/aide]
[aide essai="3"]Pour que le dernier tour utilise $i = 10$, la borne supérieure doit valoir un de plus que $10$.[/aide]
[/math]
[solution]La borne supérieure doit valoir $\mathbf{11}$ : avec range(1, 11), la variable i prend les valeurs $1, 2, \ldots, 10$, car $11$ est exclu.[/solution]
[/etape]

[etape]
À chaque tour de boucle, le montant de la semaine vaut $3 \times i$ euros (semaine $1$ : $3$, semaine $2$ : $6$, etc.). Écrire la ligne, à l'intérieur de la boucle, qui ajoute ce montant au total S.
[code-python id="accu" attendu="S = S + 3*i" indent="1" variantes="S = S + 3 * i || S = 3*i + S || S += 3*i"]
[reponse statut="correct"]Bien vu !
À chaque tour, le total est augmenté du montant de la semaine, ce qui réalise l'accumulation des dons.[/reponse]
[reponse motif="S = 3*i"]Cette ligne écrase le total à chaque tour au lieu de l'augmenter : il faut repartir de la valeur déjà accumulée dans S.[/reponse]
[reponse motif="S = S + i"]Le montant ajouté n'est pas i mais le montant de la semaine. Relire comment ce montant se calcule à partir de i.[/reponse]
[reponse statut="incorrect"]On veut ajouter le montant de la semaine au total déjà obtenu : la ligne réutilise donc S dans son calcul.[/reponse]
[aide essai="2"]Le principe d'accumulation : S = S + (terme à ajouter). Ici le terme est le montant de la semaine.[/aide]
[aide essai="3"]Le montant de la semaine s'écrit 3*i. La ligne réutilise l'ancienne valeur de S.[/aide]
[/code-python]
[solution]

S = S + 3*i

[/solution]
[/etape]

[etape]
Le programme complet est donc :

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

Quelle valeur s'affiche à l'écran à la fin de l'exécution ?
[math id="total" attendu="165"]
[reponse statut="correct"]Parfait !
La boucle ajoute $3, 6, 9, \ldots, 30$, dont la somme vaut $165$ : c'est le total affiché par print(S).[/reponse]
[reponse motif="30"]$30$ est le montant de la dernière semaine, pas le total accumulé sur les dix semaines.[/reponse]
[reponse motif="55"]$55$ est la somme $1 + 2 + \ldots + 10$. Or chaque terme ajouté n'est pas i mais le montant de la semaine.[/reponse]
[reponse motif="150"]Recompter le nombre de termes : la boucle effectue bien dix tours, de la semaine $1$ à la semaine $10$.[/reponse]
[reponse statut="incorrect"]Additionner les dix montants successifs, ou remarquer qu'ils sont tous multiples de $3$.[/reponse]
[aide essai="2"]Les montants ajoutés sont $3, 6, 9, \ldots, 30$. On peut factoriser par $3$.[/aide]
[aide essai="3"]La somme vaut $3 \times (1 + 2 + \ldots + 10)$. Calculer d'abord la parenthèse.[/aide]
[/math]
[solution]Les montants ajoutés sont $3, 6, 9, \ldots, 30$, soit $3 \times (1 + 2 + \ldots + 10) = 3 \times 55$.
Le programme affiche donc $\mathbf{165}$.[/solution]
[/etape]

[etape]
On modifie maintenant le projet : l'association veut savoir au bout de combien de semaines le total récolté atteint ou dépasse $100$ euros. Cette fois, le nombre de tours n'est plus connu d'avance. Quel type de boucle est désormais le plus adapté ?
[qcm]
[option]Une boucle for avec range[/option]
[option correct="true"]Une boucle while[/option]
[option]Aucune boucle n'est nécessaire[/option]
[reponse statut="correct"]Tout à fait !
On ne sait pas d'avance combien de semaines seront nécessaires pour atteindre $100$ euros : on répète tant que le total reste inférieur au seuil.
C'est exactement le rôle d'une boucle while.[/reponse]
[reponse motif="Une boucle for avec range"]Une boucle for demande de fixer à l'avance le nombre de tours. Or ici, c'est précisément ce nombre que l'on cherche.[/reponse]
[reponse statut="incorrect"]Il faut bien répéter une addition plusieurs fois.
Comme le nombre de répétitions dépend d'un seuil à atteindre, se demander quelle boucle s'arrête sur une condition.[/reponse]
[/qcm]
[solution]Le nombre de tours dépend d'un seuil à franchir et n'est pas connu d'avance : on utilise une boucle while, qui répète tant que la condition « total inférieur à $100$ » est vraie.
En suivant les totaux successifs $3, 9, 18, 30, 45, 63, 84, 108$, le seuil de $100$ euros est dépassé au bout de $8$ semaines.[/solution]
[/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 : Boucles for et range (niveau 1)

[enonce]
Pour chaque affirmation suivante sur la boucle for et la fonction range en Python, indiquez si elle est Vraie ou Fausse.
[/enonce]

[etape]
Affirmation : L'instruction range(5) génère les entiers $1$, $2$, $3$, $4$, $5$.

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Bonne réponse !
range(5) génère les entiers de $0$ à $4$ (inclus), soit $0, 1, 2, 3, 4$.
La borne supérieure ($5$) est exclue et la valeur de départ est $0$ par défaut.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Attention : en Python, range(n) commence à $0$ (pas à $1$) et s'arrête avant $n$.
range(5) génère donc $0, 1, 2, 3, 4$ — cinq valeurs, mais à partir de $0$.[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. range(5) génère $0, 1, 2, 3, 4$ (et non $1$ à $5$).
[/solution]
[/etape]

[etape]
Affirmation : L'instruction range(2, 6) génère les entiers $2$, $3$, $4$, $5$.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Exactement !
range(2, 6) parcourt les entiers de $2$ (inclus) à $6$ (exclu), soit $2, 3, 4, 5$.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Rappel : range(a, b) génère les entiers de $a$ à $b-1$.
Pour range(2, 6), cela donne $2, 3, 4, 5$ (la borne $6$ est exclue).[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. range(2, 6) parcourt $2, 3, 4, 5$ — borne de départ incluse, borne d'arrivée exclue.
[/solution]
[/etape]

[etape]
Affirmation : Dans la boucle for i in range(3, 10) :, la variable i prend la valeur $10$ au dernier tour.

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Bravo !
range(3, 10) fait varier i de $3$ à $9$ (inclus).
La borne supérieure ($10$) est exclue : i ne prend jamais la valeur $10$.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Le piège classique est d'inclure la borne supérieure.
range(a, b) s'arrête avant $b$ : ici, i prend les valeurs $3, 4, 5, 6, 7, 8, 9$, puis la boucle se termine.[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. range(3, 10) s'arrête à $9$ ; i ne prend jamais la valeur $10$.
[/solution]
[/etape]

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

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

Affirmation : Ce programme affiche Bonjour $4$ fois.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]C'est bien ça !
range(4) produit $4$ valeurs ($0, 1, 2, 3$), donc le bloc est exécuté $4$ fois.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Rappel : range(n) produit $n$ valeurs (de $0$ à $n-1$), donc la boucle s'exécute $n$ fois.
Ici, for i in range(4) répète le bloc $4$ fois : Bonjour est affiché $4$ fois.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. range(4) produit $4$ valeurs, donc la boucle s'exécute $4$ fois.
[/solution]
[/etape]

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

for i in [1, 2, 5, 11] :
    print(i, end=" ")

Affirmation : Ce programme affiche 1 2 5 11.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Correct !
Dans une boucle for, la variable prend successivement chacune des valeurs de la liste.
i parcourt donc $1$, $2$, $5$ puis $11$ et chaque valeur est affichée séparée par un espace.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Rappel : for i in [liste] parcourt les valeurs de la liste dans l'ordre.
Le paramètre end=" " de print sépare les affichages par un espace au lieu d'un retour à la ligne.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. i prend successivement les valeurs $1, 2, 5, 11$ ; chacune est affichée à la suite séparée par un espace.
[/solution]
[/etape]

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

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

Affirmation : Ce programme affiche $10$.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Bravo !
i prend les valeurs $1, 2, 3, 4$ (la borne $5$ est exclue).
On calcule donc $S = 1 + 2 + 3 + 4 = 10$.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Il faut bien identifier les valeurs parcourues : range(1, 5) donne $1, 2, 3, 4$.
$S$ reçoit successivement $0+1 = 1$, puis $1+2 = 3$, puis $3+3 = 6$, puis $6+4 = 10$. Le programme affiche $10$.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. range(1, 5) donne $1, 2, 3, 4$ ; leur somme vaut $10$.
[/solution]
[/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]

Nombres triangulaires et Python

On appelle nombre triangulaire d'ordre $ n $ la somme des nombres entiers naturels compris entre $ 1 $ et $ n $ :

On notera :

$ T_n = 1 + 2 + 3 + \cdots + n $

Par exemple, le nombre triangulaire d'ordre $ 4 $ est :

$ T_4 = 1 + 2 + 3 + 4 = 10. $

C'est le nombre de points représentés sur la figure ci-dessous :

Compléter le programme Python ci-dessous afin qu'il calcule et affiche le nombre triangulaire d'ordre $ 20 $ :
```
T=0
for n in range(...) :
     T = T + n
print(T)
```
On souhaite déterminer pour quelle valeur de $ n $ le nombre triangulaire d'ordre $ n $ est supérieur ou égal à $ 1~000 $.

Compléter le programme Python ci-dessous afin qu'il affiche ce nombre $ n $.
```
T=0
n=0
while T < 1000 :
     n = n+1
     T = T+n
print(n)
```
Saisir ce programme dans un éditeur Python. Quelle valeur de $ n $ obtient-on ?

Corrigé

Dans le programme proposé, la variable T représente le nombre triangulaire d'ordre n.

Pour calculer le nombre triangulaire d'ordre 20, il faut effectuer la somme des entiers compris (au sens large) entre $ 1 $ et $ 20 $.

Comme range(a,b) renvoie la liste des valeurs comprises (au sens large) entre a et b-1 ; il faut donc utiliser l'instruction range(1, 21 ) pour créer la boucle (l'instruction range(0, 21) ou range(21) est aussi valable puisqu'elle ne fait qu'ajouter $ 0 $ à cette somme).

Ensuite, à chaque étape de la boucle, on ajoute n à T.

Voici le programme complet :
```
T=0
for n in range(1,21) :
   T = T+n
print(T)
```
L'exécution de ce programme affiche la valeur 210.
Cette fois, on ne connait pas, dès le départ, le nombre d'itérations. On doit donc utiliser une boucle while (boucle non bornée).

Ici, la variable T représente le nombre triangulaire d'ordre n.

On sort de la boucle lorsque T >= 1000, c'est à dire qu'on reste dans la boucle tant que T < 1000.

À chaque passage dans la boucle, on incrémente n puis on l'ajoute au nombre T :
```
T=0
n=0
while T < 1000 :
   n = n+1
   T = T+n
print(n)
```

Ce programme affiche le nombre $ 45 $ comme résultat.

→ Pour réviser : Parcourir des entiers avec for et range

Algorithme : Somme d’entiers

Écrire un algorithme qui demande de saisir un entier naturel $ n $ et qui affiche pour résultat la somme $ 1+2+3+. . . +n $

Par exemple, si l'utilisateur saisit le nombre 7, l'algorithme affichera 28 (car $ 1+2+3+4+5+6+7=28 $).

Corrigé

Le nombre d'additions est connu dès le départ (il dépend de $n$) : on utilise donc une boucle for qui parcourt les entiers de $1$ à $n$. La variable somme accumule les valeurs successives.

n = int(input("Entrer un entier naturel : "))
somme = 0
for i in range(1, n + 1):
    somme = somme + i
print(somme)

L'instruction range(1, n + 1) parcourt les entiers de $1$ à $n$ (la borne $n + 1$ est exclue). À chaque tour de boucle, on ajoute i à somme.

Par exemple, pour $n = 7$, le programme affiche $28$.