<?xml version="1.0" encoding="UTF-8"?>
<quiz>
<question type="category">
  <category>
    <text>$course$/QCM de NSI/SNT/6. Boucles non bornées : while</text>
  </category>
  <info format="html">
    <text><![CDATA[<p>La boucle while et sa condition de continuation, testée avant chaque<br/>
tour ; la variable qui doit changer pour que la boucle s'arrête ; les<br/>
boucles infinies ; compter les tours ; atteindre un seuil ; choisir<br/>
entre for et while.</p>]]></text>
  </info>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q01 : Une boucle qui compte</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<pre><code>n = 0
while n &lt; 3:
    print(n)
    n = n + 1</code></pre>
<p>Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p><code>while</code> répète son bloc tant que la condition est vraie. La<br/>
condition est vérifiée avant chaque tour : dès qu'elle est fausse, le<br/>
programme passe à la suite.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>0, 1 et 2</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la boucle tourne tant que <code>n &lt; 3</code>. Elle affiche<br/>
0, 1, 2, puis <code>n</code> vaut 3 et la condition devient fausse.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>0, 1, 2 et 3</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : quand <code>n</code> vaut 3, la condition <code>n &lt; 3</code> est fausse et<br/>
la boucle s'arrête sans afficher.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>1, 2 et 3</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : l'affichage a lieu avant l'ajout de 1, la première<br/>
valeur affichée est 0.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>0 et 1</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 2 est encore strictement inférieur à 3, un troisième<br/>
tour a lieu.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q02 : La valeur après la boucle</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<pre><code>n = 10
while n &gt; 0:
    n = n - 4
print(n)</code></pre>
<p>Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>À la sortie d'un <code>while</code>, la condition est fausse : c'est la<br/>
première valeur qui la rend fausse que l'on retrouve. Ici, le premier<br/>
nombre négatif ou nul atteint.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>-2</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>n</code> passe par 6, 2 puis -2. À -2, la condition<br/>
<code>n &gt; 0</code> est fausse et la boucle s'arrête.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>2</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 2 est encore strictement positif, un tour de plus a<br/>
lieu.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>0</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : en retirant 4 à chaque fois depuis 10, on ne passe<br/>
jamais par 0.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>-4</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : dès que <code>n</code> vaut -2, la boucle s'arrête, on ne retire<br/>
pas 4 une fois de plus.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q03 : Une variable qui ne bouge pas</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<pre><code>i = 0
while i &lt; 5:
    print(i)</code></pre>
<p>Que fait ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Une boucle <code>while</code> ne s'arrête que si quelque chose rend sa condition<br/>
fausse. Oublier de modifier la variable de la condition donne une<br/>
boucle infinie.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Il ne s'arrête jamais, <code>i</code> ne change pas</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : rien dans la boucle ne modifie <code>i</code>, la<br/>
condition <code>i &lt; 5</code> reste vraie et 0 est affiché sans fin.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Il affiche 0, 1, 2, 3 et 4</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : contrairement à <code>for</code>, <code>while</code> n'augmente pas la<br/>
variable tout seul.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Il affiche 0 une seule fois</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : après le premier tour, la condition est toujours vraie<br/>
et un nouveau tour commence.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Il s'arrête sur une erreur, <code>i</code> n'augmente pas</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : Python ne détecte pas une boucle infinie, il l'exécute.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q04 : Doubler jusqu'à dépasser</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Une somme placée augmente de 10 % par an. On cherche en combien<br/>
d'années elle double.</p>
<pre><code>somme = 100
annees = 0
while somme &lt; 200:
    somme = somme * 1.1
    annees = annees + 1
print(annees)</code></pre>
<p>Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Le <code>while</code> convient quand on ignore à l'avance le nombre de tours :<br/>
on répète jusqu'à atteindre un seuil, en comptant les tours dans une<br/>
variable.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>8</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : après 7 ans, la somme vaut environ 194.9, encore<br/>
sous 200 ; après 8 ans, environ 214.4.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>7</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : après 7 ans, la somme est encore inférieure à 200, un<br/>
tour de plus est nécessaire.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>10</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 10 % par an pendant 10 ans ne fait pas 100 %, la<br/>
croissance se compose et la somme atteint 200 avant.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>2</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 2 serait le facteur de multiplication, pas le nombre<br/>
d'années.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q05 : Compter les tours</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<pre><code>x = 1
tours = 0
while x &lt; 50:
    x = x * 3
    tours = tours + 1
print(tours, x)</code></pre>
<p>Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Une variable de comptage, augmentée de 1 à chaque tour, permet de<br/>
savoir combien de fois une boucle <code>while</code> a tourné. On lit les deux<br/>
valeurs à la sortie.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>4 81</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>x</code> passe par 3, 9, 27 et 81. Il faut 4<br/>
tours pour dépasser 50.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>3 27</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 27 est encore inférieur à 50, un tour de plus a<br/>
lieu.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>4 27</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : au dernier tour, <code>x</code> est multiplié une fois de plus<br/>
et vaut 81.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>5 243</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : à 81, la condition <code>x &lt; 50</code> est fausse, la boucle<br/>
s'arrête.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q06 : Le test vient avant le premier tour</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<pre><code>n = 5
while n &lt; 5:
    print("tour")
    n = n + 1
print("fin")</code></pre>
<p>Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Un <code>while</code> peut ne faire aucun tour : sa condition est évaluée avant<br/>
d'entrer dans le bloc. Si elle est fausse au départ, on passe<br/>
directement à la suite.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>fin</code> seulement</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la condition <code>5 &lt; 5</code> est fausse dès le départ,<br/>
le bloc n'est jamais exécuté.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>tour</code> puis <code>fin</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>while</code> teste la condition avant le premier tour, pas<br/>
après.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>tour</code> cinq fois puis <code>fin</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>n</code> vaut déjà 5, la condition est fausse d'emblée.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Rien</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : le dernier <code>print</code> est hors de la boucle et s'exécute.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q07 : Choisir la condition</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Un ventilateur doit tourner tant que la température dépasse 25<br/>
degrés. Quelle ligne commence correctement la boucle ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>La condition d'un <code>while</code> est une condition de continuation, pas<br/>
d'arrêt : on écrit ce qui doit rester vrai pour refaire un tour.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>while temperature &gt; 25:</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la condition d'un <code>while</code> exprime ce qui doit<br/>
être vrai pour continuer, ici « dépasse 25 ».</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>while temperature &lt; 25:</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : cette boucle tournerait tant qu'il fait frais, c'est<br/>
l'inverse.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>while temperature == 25:</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la boucle ne tournerait que pour exactement 25 degrés.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>if temperature &gt; 25:</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>if</code> exécute le bloc une seule fois, il ne répète pas.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q08 : Une soustraction répétée</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<pre><code>a = 27
b = 6
q = 0
while a &gt;= b:
    a = a - b
    q = q + 1
print(q, a)</code></pre>
<p>Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Cette boucle calcule une division euclidienne par soustractions<br/>
successives : le compteur donne le quotient, la valeur restante le<br/>
reste. Une trace tour par tour confirme le résultat.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>4 3</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>a</code> passe par 21, 15, 9 et 3, en 4 tours.<br/>
À 3, <code>a &gt;= 6</code> est faux. On obtient le quotient et le reste de 27<br/>
par 6.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>4 0</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 27 n'est pas un multiple de 6, il reste 3.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>5 -3</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : à 3, la condition <code>a &gt;= b</code> est fausse, on ne soustrait<br/>
pas une fois de plus.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>3 9</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 9 est encore supérieur ou égal à 6, un tour de plus a<br/>
lieu.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q09 : for ou while</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Dans laquelle de ces situations une boucle <code>while</code> est-elle<br/>
nécessaire, parce qu'on ne connaît pas le nombre de tours à<br/>
l'avance ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p><code>for</code> sert quand le nombre de répétitions est connu avant de<br/>
commencer, <code>while</code> quand il dépend de ce qui se passe pendant la<br/>
boucle, comme une saisie ou un seuil à atteindre.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Redemander un code tant qu'il est faux</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : impossible de savoir combien d'essais seront<br/>
nécessaires. On répète tant que le code est faux.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Afficher les nombres de 1 à 100</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : le nombre de tours est connu, 100, une boucle <code>for</code><br/>
suffit.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Parcourir les lettres d'un mot</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : le nombre de lettres est connu, <code>for</code> parcourt le mot<br/>
directement.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Additionner dix relevés de température</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : dix relevés, dix tours, c'est une boucle bornée.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q10 : Deux conditions de continuation</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<pre><code>essais = 0
trouve = False
while essais &lt; 3 and not trouve:
    essais = essais + 1
    if essais == 2:
        trouve = True
print(essais)</code></pre>
<p>Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Avec <code>and</code>, la boucle continue seulement si toutes les conditions<br/>
sont vraies. Elle s'arrête dès que l'une devient fausse : le nombre<br/>
maximal d'essais ou la réussite.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>2</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : au tour numéro 2, <code>trouve</code> devient vrai ; au<br/>
test suivant, <code>not trouve</code> est faux et la boucle s'arrête.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>3</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la boucle s'arrête dès qu'une des deux conditions<br/>
devient fausse, ici <code>not trouve</code> après le tour numéro 2.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>1</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : après 1 tours, <code>essais</code> vaut 1 et <code>trouve</code> est<br/>
encore faux, un tour de plus a lieu.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>0</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : au départ, les deux conditions sont vraies, la boucle<br/>
fait au moins un tour.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q11 : Décompte avant décollage</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<pre><code>n = 3
while n &gt; 0:
    print(n)
    n = n - 1
print("Décollage")</code></pre>
<p>Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>L'ordre des instructions dans le bloc décide de ce qui est affiché :<br/>
afficher puis diminuer donne 3, 2, 1 ; diminuer puis afficher<br/>
donnerait 2, 1, 0.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>3, 2, 1 puis <code>Décollage</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la boucle affiche puis diminue ; à 0, la<br/>
condition est fausse et le message final s'affiche.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>3, 2, 1, 0 puis <code>Décollage</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : quand <code>n</code> vaut 0, <code>n &gt; 0</code> est faux, rien n'est affiché<br/>
par la boucle.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>2, 1, 0 puis <code>Décollage</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : l'affichage a lieu avant la soustraction, on commence<br/>
par 3.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>Décollage</code> seulement</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>3 &gt; 0</code> est vrai, la boucle fait trois tours.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q12 : Une valeur jamais atteinte</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<pre><code>n = 0
while n != 10:
    n = n + 3
print(n)</code></pre>
<p>Que fait ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Une condition en <code>!=</code> est dangereuse : si la valeur exacte n'est<br/>
jamais atteinte, la boucle est infinie. Une condition en <code>&lt;</code> ou <code>&lt;=</code><br/>
s'arrête dès que le seuil est dépassé.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Il ne s'arrête jamais, <code>n</code> saute par-dessus 10</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>n</code> prend les valeurs 3, 6, 9, 12, 15… Il ne<br/>
vaut jamais exactement 10, et <code>n != 10</code> reste vrai.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Il affiche 10, une fois cette valeur atteinte</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : en avançant de 3 en 3 depuis 0, on passe de 9 à 12<br/>
sans toucher 10.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Il affiche 12, première valeur au-delà de 10</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : à 12, la condition <code>n != 10</code> est encore vraie, la<br/>
boucle continue.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Il affiche 9, dernière valeur avant 10</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 9 est différent de 10, la boucle ne s'arrête pas là.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q13 : Une somme jusqu'à un seuil</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<pre><code>s = 0
k = 1
while s &lt;= 10:
    s = s + k
    k = k + 1
print(k)</code></pre>
<p>Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Deux variables évoluent ensemble : l'accumulateur <code>s</code> et le compteur<br/>
<code>k</code>. Le <code>&lt;=</code> inclut le cas d'égalité, ce qui peut ajouter un tour par<br/>
rapport à <code>&lt;</code>.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>6</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>s</code> passe par 1, 3, 6, 10 puis 15, et <code>k</code> est<br/>
augmenté à chaque tour, 5 fois, de 1 à 6.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>5</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : à <code>s</code> égal à 10, la condition <code>s &lt;= 10</code> est encore<br/>
vraie, un tour de plus a lieu et <code>k</code> passe à 6.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>4</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : après 3 tours, <code>s</code> vaut 6, la boucle continue.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>15</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 15 est la valeur finale de <code>s</code>, mais le programme<br/>
affiche <code>k</code>.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q14 : Quand s'arrête un while</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Quand une boucle <code>while</code> s'arrête-t-elle ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Le <code>while</code> teste sa condition avant chaque tour, jamais au milieu.<br/>
Même si la condition devient fausse au milieu d'un tour, le tour va<br/>
jusqu'au bout.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Quand sa condition est fausse au moment du test, avant un tour</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la condition est évaluée avant chaque tour ;<br/>
dès qu'elle est fausse, le programme passe à la suite.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Après un nombre de tours fixé à l'avance dans l'en-tête</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est le principe de <code>for</code> avec <code>range</code>. Un <code>while</code><br/>
ignore le nombre de tours à l'avance.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Quand la variable de la condition atteint 0</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la condition peut porter sur n'importe quelle valeur,<br/>
pas seulement sur 0.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Dès que sa condition devient vraie pendant un tour</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est l'inverse, une condition vraie fait continuer.<br/>
Et le test n'a lieu qu'entre deux tours.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q15 : Redemander une saisie</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<pre><code>reponse = ""
while reponse != "oui":
    reponse = input("Continuer ? ")
print("Merci")</code></pre>
<p>L'utilisateur tape <code>non</code>, puis <code>Oui</code>, puis <code>oui</code>. Combien de fois la<br/>
question est-elle posée ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Initialiser la variable à une valeur qui rend la condition vraie<br/>
permet d'entrer dans la boucle une première fois. Ensuite, chaque<br/>
saisie est retestée jusqu'à la bonne.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>3</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>non</code> et <code>Oui</code> sont différents de <code>oui</code>, la<br/>
boucle continue. La troisième réponse arrête la boucle.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>2</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>Oui</code> avec une majuscule n'est pas égal à <code>oui</code>, la<br/>
question est reposée.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>1</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : après <code>non</code>, la condition <code>reponse != "oui"</code> reste<br/>
vraie.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Un nombre infini de fois</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la troisième saisie, <code>oui</code>, rend la condition fausse.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q16 : Deux variables qui se croisent</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<pre><code>a = 1
b = 16
while a &lt; b:
    a = a * 2
    b = b - 2
print(a, b)</code></pre>
<p>Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Quand deux variables changent dans le bloc, la trace se fait par<br/>
couples de valeurs, un couple par tour, jusqu'à celui qui rend la<br/>
condition fausse.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>16 8</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : les couples successifs sont (2, 14), (4, 12), (8, 10) puis (16, 8). À ce<br/>
moment <code>a &lt; b</code> est faux.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>8 10</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 8 est encore inférieur à 10, un tour de plus a lieu.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>16 10</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : au dernier tour, <code>b</code> est aussi modifié et passe de 10 à<br/>
8.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>32 6</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : à (16, 8), la condition est fausse, la boucle s'arrête.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q17 : Une variable non initialisée</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<pre><code>while compteur &lt; 10:
    compteur = compteur + 1
print(compteur)</code></pre>
<p>Que se passe-t-il ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Avant un <code>while</code>, on initialise les variables de la condition. C'est<br/>
la première étape du schéma : initialiser, tester, modifier dans le<br/>
bloc.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Une erreur, <code>compteur</code> n'a pas de valeur au premier test</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la condition lit <code>compteur</code> avant toute<br/>
affectation, d'où une erreur <code>NameError</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Dix tours, puis l'affichage de 10 après la boucle</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ce serait le cas avec <code>compteur = 0</code> avant la boucle.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une boucle infinie, la condition reste vraie</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : le programme s'arrête avant même le premier tour.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Aucun tour, la condition est fausse dès le départ</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la condition ne peut pas être évaluée du tout.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q18 : Diviser jusqu'à passer sous un seuil</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<pre><code>x = 100
n = 0
while x &gt; 1:
    x = x / 2
    n = n + 1
print(n)</code></pre>
<p>Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>La division <code>/</code> produit des flottants, et la condition <code>x &gt; 1</code> finit<br/>
par devenir fausse. Le compteur mesure le nombre de divisions<br/>
nécessaires.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>7</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>x</code> passe par 50.0, 25.0, 12.5, 6.25, 3.125, 1.5625 puis 0.78125, en 7 divisions.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>6</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : après 6 divisions, <code>x</code> vaut 1.5625, encore supérieur<br/>
à 1.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>8</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : après 7 divisions, <code>x</code> est inférieur ou égal à 1 et la<br/>
boucle s'arrête.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>100</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : le programme affiche le nombre de tours, pas la valeur<br/>
de départ.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q19 : Compléter pour que la boucle s'arrête</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<pre><code>niveau = 0
while niveau &lt; 5:
    print(niveau)
    ...</code></pre>
<p>Quelle instruction, à la place des points, garantit l'arrêt de la<br/>
boucle après cinq affichages ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Pour qu'un <code>while</code> s'arrête, le bloc doit modifier une variable de la<br/>
condition avec une affectation. Un calcul non affecté ne change<br/>
rien.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>niveau = niveau + 1</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>niveau</code> augmente à chaque tour et atteint 5<br/>
après cinq affichages, ce qui rend la condition fausse.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>niveau + 1</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ce calcul n'est rangé nulle part, <code>niveau</code> reste à 0 et<br/>
la boucle est infinie.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>niveau = 0</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : remettre <code>niveau</code> à 0 empêche la condition de devenir<br/>
fausse.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>print(niveau + 1)</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : afficher <code>niveau + 1</code> ne modifie pas <code>niveau</code>.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q20 : Compter les chiffres d'un nombre</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<pre><code>n = 4821
c = 0
while n &gt; 0:
    n = n // 10
    c = c + 1
print(c)</code></pre>
<p>Qu'affiche ce programme ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Diviser par 10 en division entière retire le dernier chiffre. Compter<br/>
les divisions jusqu'à 0 revient à compter les chiffres du nombre.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>4</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>n</code> passe par 482, 48, 4 puis 0, soit 4<br/>
divisions, une par chiffre.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>3</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : à 4, la condition <code>n &gt; 0</code> est encore vraie, un<br/>
tour de plus donne 0.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>5</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : à 0, la boucle s'arrête, il n'y a pas de tour<br/>
supplémentaire.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>482</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : le programme affiche le compteur <code>c</code>, pas <code>n</code>.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q21 : Un compte à rebours de trois en trois</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Qu'affiche ce programme ?<br/>
<pre><code>i = 10
while i &gt; 0:
    i = i - 3
print(i)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Un <code>while</code> continue tant que sa condition est vraie : il faut<br/>
suivre la variable jusqu'à ce que la condition devienne fausse.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>-2</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>i</code> descend de 3 en 3 tant qu'il est<br/>
strictement positif. Le dernier tour part de 1 et<br/>
aboutit à -2, qui arrête la boucle.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>1</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 1 est encore strictement positif, donc un tour<br/>
de plus a lieu.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>10</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la condition <code>i &gt; 0</code> est vraie au départ, la boucle<br/>
modifie bien <code>i</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>7</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 7 est la valeur après un seul tour, et la boucle<br/>
continue tant que <code>i</code> reste positif.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q22 : Multiplier par dix jusqu'à dépasser</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Qu'affiche ce programme ?<br/>
<pre><code>x = 1
while x &lt; 800:
    x = x * 10
print(x)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>La boucle s'arrête dès que la condition devient fausse, c'est-à-dire<br/>
à la première valeur qui atteint ou dépasse le seuil.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>1000</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>x</code> prend les valeurs 1, 10, 100, et ainsi de<br/>
suite, jusqu'à la première puissance de 10 qui atteint ou<br/>
dépasse 800, soit 1000.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>800</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>x</code> ne prend que des puissances de 10, il ne s'arrête<br/>
pas exactement sur 800.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>100</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 100 est encore inférieur à 800, donc un tour de<br/>
plus a lieu.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>1</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la condition est vraie au départ, et <code>x</code> est multiplié<br/>
au moins une fois.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q23 : Le premier multiple au-delà d'un seuil</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Qu'affiche ce programme ?<br/>
<pre><code>n = 0
while n &lt;= 50:
    n = n + 7
print(n)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Ce schéma trouve le premier multiple d'un nombre qui dépasse un<br/>
seuil : on avance pas à pas tant que le seuil n'est pas franchi.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>56</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>n</code> parcourt les multiples de 7 et s'arrête au<br/>
premier qui dépasse strictement 50, soit 56.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>49</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 49 ne dépasse pas 50, la condition <code>n &lt;= 50</code> est<br/>
encore vraie et un tour de plus a lieu.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>50</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>n</code> ne prend que des multiples de 7.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>7</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 7 est la valeur après un seul tour, et la boucle<br/>
continue tant que <code>n &lt;= 50</code>.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q24 : Combien de mois pour atteindre l'objectif</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Qu'affiche ce programme ?<br/>
<pre><code>argent = 100
mois = 0
while argent &lt; 150:
    argent = argent + 12
    mois = mois + 1
print(mois)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Deux variables évoluent ensemble : l'une avance vers l'objectif,<br/>
l'autre compte les tours. Le <code>print</code> choisit laquelle afficher.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>5</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>argent</code> part de 100 et gagne 12 par tour. Il<br/>
faut 5 tours pour atteindre ou dépasser 150, et <code>mois</code> compte<br/>
ces tours.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>4</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : après 4 tours, <code>argent</code> est encore inférieur à 150,<br/>
la boucle fait un tour de plus.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>6</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : dès que <code>argent</code> atteint 150, la condition <code>argent &lt;<br/>
150</code> est fausse et la boucle s'arrête.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>160</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 160 est la valeur finale de <code>argent</code>, mais c'est<br/>
<code>mois</code> qui est affiché.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q25 : Des nombres pairs jusqu'à un seuil</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Combien de lignes ce programme affiche-t-il, et laquelle en dernier ?<br/>
<pre><code>n = 0
while n &lt;= 6:
    print(n)
    n = n + 2</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Pour compter les lignes, on liste les valeurs prises par la<br/>
variable : 0, 2, 4, et ainsi de suite tant que la condition tient.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>4 lignes, la dernière étant <code>6</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>n</code> prend les valeurs paires de 0 à 6,<br/>
chacune affichée avant l'ajout de 2. Cela fait 4 lignes.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>3 lignes, la dernière étant <code>6</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la valeur 0 est affichée elle aussi, au premier tour.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>6 lignes, la dernière étant <code>6</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>n</code> avance de 2 en 2, il n'y a pas une ligne par<br/>
entier.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une infinité de lignes, la boucle ne s'arrêtant jamais</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>n</code> grandit à chaque tour et finit par dépasser 6.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q26 : Deux conditions pour continuer</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Qu'affiche ce programme ?<br/>
<pre><code>i = 0
s = 0
while i &lt; 10 and s &lt; 15:
    s = s + i
    i = i + 1
print(i, s)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Avec <code>and</code>, la boucle s'arrête dès que l'une des deux conditions<br/>
devient fausse. Suivre <code>i</code> et <code>s</code> tour par tour est le seul moyen<br/>
sûr de trouver l'état final.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>6 15</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la boucle continue tant que les deux conditions<br/>
sont vraies. Elle s'arrête dès que <code>s</code> atteint 15, ou que <code>i</code><br/>
atteint 10, selon ce qui arrive en premier.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>5 10</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : cet état correspond à un tour de moins. Vérifie que les<br/>
deux conditions sont encore vraies à ce moment.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>10 45</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : vérifie si la condition sur <code>s</code> arrête la boucle avant<br/>
que <code>i</code> n'atteigne 10.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>7 21</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : cet état correspond à un tour de trop, la boucle<br/>
s'arrête dès qu'une condition devient fausse.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q27 : Additionner jusqu'à un seuil</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Qu'affiche ce programme ?<br/>
<pre><code>s = 0
i = 1
while s &lt; 20:
    s = s + i
    i = i + 1
print(i)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Quand deux variables évoluent dans une boucle, l'ordre des<br/>
instructions compte : ici <code>i</code> est modifié après avoir servi.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>7</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>s</code> cumule 1, 2, 3, et ainsi de suite jusqu'à<br/>
atteindre 21, qui dépasse 20. <code>i</code> a alors été incrémenté une<br/>
fois de plus que la dernière valeur ajoutée, 6, d'où 7.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>6</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 6 est la dernière valeur ajoutée à <code>s</code>, mais <code>i</code><br/>
est incrémenté juste après l'ajout.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>21</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 21 est la valeur finale de <code>s</code>, alors que c'est <code>i</code><br/>
qui est affiché.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>20</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 20 est le seuil, ni <code>i</code> ni <code>s</code> ne s'y arrêtent<br/>
exactement.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q28 : Compter une lettre avec un indice</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Qu'affiche ce programme ?<br/>
<pre><code>mot = "anaconda"
i = 0
c = 0
while i &lt; len(mot):
    if mot[i] == "a":
        c = c + 1
    i = i + 1
print(c)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Un <code>while</code> avec un indice parcourt une chaîne caractère par<br/>
caractère. Le compteur n'avance que quand la condition est vraie.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>3</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>i</code> parcourt les indices de 0 à 7, et <code>c</code><br/>
est incrémenté à chaque lettre <code>a</code> rencontrée, soit 3 fois.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>8</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 8 est la longueur du mot, le nombre de tours, pas le<br/>
nombre de lettres <code>a</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>0</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 0 est l'indice de la première lettre <code>a</code>,<br/>
mais le programme compte les occurrences.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>5</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 5 est le nombre de lettres différentes de<br/>
<code>a</code>, le <code>if</code> compte l'inverse.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q29 : La même boucle avec while</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Quelle boucle <code>while</code> affiche exactement ce que produit<br/>
<code>for i in range(5): print(i)</code> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Toute boucle <code>for</code> sur un <code>range</code> se réécrit en <code>while</code> avec une<br/>
variable initialisée, une condition et une incrémentation. L'ordre<br/>
des instructions dans le corps change le résultat.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<pre><code>i = 0
while i &lt; 5:
    print(i)
    i = i + 1</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>i</code> part de 0, est affiché puis incrémenté, et la<br/>
boucle s'arrête avant 5. Les valeurs 0 à 4 sont affichées.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<pre><code>i = 1
while i &lt;= 5:
    print(i)
    i = i + 1</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : cette boucle affiche 1 à 5, alors que <code>range(5)</code><br/>
commence à 0 et s'arrête à 4.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<pre><code>i = 0
while i &lt;= 5:
    print(i)
    i = i + 1</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : avec <code>&lt;=</code>, la valeur 5 est affichée, ce que <code>range(5)</code><br/>
ne fait pas.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<pre><code>i = 0
while i &lt; 5:
    i = i + 1
    print(i)</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : incrémenter avant d'afficher décale tout : cette boucle<br/>
affiche 1 à 5.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>6. Boucles non bornées : while — Q30 : Compter les doublements</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Qu'affiche ce programme ?<br/>
<pre><code>e = 1
n = 0
while e &lt; 1000:
    e = e * 2
    n = n + 1
print(n)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Ce programme répond à la question « combien de fois faut-il doubler<br/>
pour dépasser un seuil ? ». Le compteur <code>n</code> en garde la trace.</p>]]></text>
  </generalfeedback>
  <defaultgrade>1.0</defaultgrade>
  <penalty>0.0</penalty>
  <hidden>0</hidden>
  <single>true</single>
  <shuffleanswers>true</shuffleanswers>
  <answernumbering>abc</answernumbering>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>10</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>e</code> double à chaque tour et <code>n</code> compte les<br/>
tours. Il faut 10 doublements pour que <code>e</code> atteigne 1024, la<br/>
première puissance de 2 qui vaut au moins 1000.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>1024</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 1024 est la valeur finale de <code>e</code>, mais le programme<br/>
affiche <code>n</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>9</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : après 9 doublements, <code>e</code> est encore inférieur à 1000,<br/>
un tour de plus a lieu.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>1000</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 1000 est le seuil, pas le nombre de tours.</p>]]></text>
    </feedback>
  </answer>
</question>

</quiz>
