<?xml version="1.0" encoding="UTF-8"?>
<quiz>
<question type="category">
  <category>
    <text>$course$/QCM de NSI/Première/Conditions et boucles</text>
  </category>
  <info format="html">
    <text><![CDATA[<p>Structures de contrôle Python : conditions<br/>
(<code>if</code>/<code>elif</code>/<code>else</code>), opérateurs booléens<br/>
(<code>and</code>/<code>or</code>/<code>not</code>), boucles bornées (<code>for</code>/<code>range</code>),<br/>
boucles non bornées (<code>while</code>), boucles imbriquées et<br/>
traces d'exécution.</p>]]></text>
  </info>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q01 : Syntaxe du if</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Quelle est la syntaxe correcte d'une condition<br/>
simple en Python ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Python utilise l'<strong>indentation significative</strong>.<br/>
Tous les blocs (<code>if</code>, <code>for</code>, <code>while</code>, <code>def</code>...)<br/>
se reconnaissent à leur indentation, pas à des<br/>
accolades.</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="0" format="html">
    <text><![CDATA[<pre><code>if (x &gt; 0)
    print("positif");</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : syntaxe à la C/Java. En Python, pas<br/>
de parenthèses obligatoires, deux-points<br/>
obligatoires, indentation à la place des<br/>
accolades.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<pre><code>if x &gt; 0 then
    print("positif")
end</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>then</code> et <code>end</code> n'existent pas en<br/>
Python (Lua, Ruby).</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<pre><code>if x &gt; 0:
    print("positif")</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : deux-points en fin de ligne,<br/>
indentation (4 espaces conventionnels) pour<br/>
le bloc.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<pre><code>if {x &gt; 0} print("positif")</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : pas d'accolades en Python.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q02 : elif</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>À quoi sert le mot-clé <code>elif</code> en Python ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Schéma général :<br/>
<pre><code>if cond1:
    ...
elif cond2:
    ...
else:
    ...</code></pre><br/>
Au plus <strong>un</strong> des blocs s'exécute (le premier<br/>
dont 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="0" format="html">
    <text><![CDATA[<p>C'est simplement un alias pour le mot-clé <code>if</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>elif</code> ne s'utilise qu'<strong>après</strong> un<br/>
<code>if</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>C'est un alias pour <code>else</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>else</code> n'a pas de condition. <code>elif</code><br/>
a une condition.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Cela teste si une variable existe</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : aucun rapport avec l'existence.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>C'est l'équivalent du <code>else if</code> en C/Java.</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>elif</code> permet d'enchaîner<br/>
plusieurs conditions sans imbrication<br/>
excessive. Mot-clé Python spécifique.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q03 : Opérateurs logiques</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Comment écrit-on « x est positif <strong>et</strong> pair »<br/>
en Python ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Trois opérateurs : <code>and</code> (et), <code>or</code> (ou<br/>
inclusif), <code>not</code> (négation). À noter :<br/>
évaluation paresseuse, <code>False and ...</code> ne<br/>
teste pas 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="0" format="html">
    <text><![CDATA[<p><code>x &gt; 0 &amp;&amp; x % 2 == 0</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>&amp;&amp;</code> n'existe pas en Python. C'est<br/>
la syntaxe C/Java.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>x &gt; 0 and x % 2 == 0</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : Python utilise les<br/>
mots-clés <code>and</code>, <code>or</code>, <code>not</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>x &gt; 0 et x % 2 == 0</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : Python est en anglais.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>x &gt; 0, x % 2 == 0</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la virgule produit un tuple, pas<br/>
une conjonction logique.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q04 : Boucle for range</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Combien d'itérations effectue<br/>
<code>for i in range(5):</code> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Convention Python : la borne supérieure est<br/>
<strong>exclue</strong>. <code>range(5)</code> = [0, 1, 2, 3, 4].</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="0" format="html">
    <text><![CDATA[<p>Une infinité</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>range(5)</code> est borné.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>4</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>range(5)</code> produit 5 valeurs (0, 1,<br/>
2, 3, 4).</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>5</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>range(n)</code> produit les<br/>
entiers de 0 à n-1, soit <strong>n valeurs</strong> au<br/>
total.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>6</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 5 est exclu de la séquence.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q05 : range avec deux arguments</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que produit <code>list(range(2, 7))</code> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Trois formes : <code>range(n)</code> (0 à n-1),<br/>
<code>range(a, b)</code> (a à b-1),<br/>
<code>range(a, b, pas)</code> (a à b-1 par pas).</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="0" format="html">
    <text><![CDATA[<p><code>[3, 4, 5, 6, 7]</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 2 est <strong>inclus</strong>, 7 est exclu.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>[2, 3, 4, 5, 6, 7]</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 7 est <strong>exclu</strong>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>[2, 3, 4, 5, 6]</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>range(a, b)</code> produit les<br/>
entiers de <code>a</code> (inclus) à <code>b</code> (exclu).</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>[2, 7]</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ce serait <code>range(2, 7, 5)</code> qui<br/>
donne <code>[2]</code> seulement.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q06 : Boucle while</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que fait la boucle suivante ?<br/>
<pre><code>n = 10
while n &gt; 0:
    print(n)
    n -= 1</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p><code>while</code> est une boucle <strong>non bornée</strong> : on<br/>
teste une condition à chaque tour. Bien<br/>
vérifier que la condition finira par devenir<br/>
fausse pour éviter une 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="0" format="html">
    <text><![CDATA[<p>Affiche les nombres de 1 à 10 dans l'ordre croissant</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la boucle décrémente, donc affiche<br/>
en ordre <strong>décroissant</strong>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Tourne sans fin, car <code>n</code> reste toujours positif</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>n -= 1</code> fait décroître <code>n</code> à chaque<br/>
tour ; après dix tours, <code>n</code> vaut 0 et la<br/>
condition devient fausse.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>N'affiche rien, car la condition est fausse au départ</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>n</code> vaut 10 au départ, donc <code>n &gt; 0</code><br/>
est vrai et la boucle s'exécute au moins une<br/>
fois.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Affiche les nombres de 10 à 1</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : à chaque tour, on affiche<br/>
<code>n</code>, puis on le diminue de 1, d'où un<br/>
affichage décroissant. Quand n atteint 0,<br/>
on sort.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q07 : Indentation et corps de boucle</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Qu'affiche ce code ?<br/>
<pre><code>for i in range(3):
    print("a")
print("b")</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>L'indentation délimite le corps de la boucle :<br/>
tout ce qui est décalé se répète, ce qui revient<br/>
au niveau de la ligne <code>for</code> ne s'exécute qu'une<br/>
fois, après le dernier 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>a a a b</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : seule la ligne indentée fait<br/>
partie du corps de la boucle, donc <code>a</code> est<br/>
affiché trois fois ; <code>print("b")</code> n'est<br/>
exécuté qu'une fois, après la boucle.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>a b a b a b</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>print("b")</code> n'est pas indenté, il ne<br/>
fait pas partie du corps de la boucle et n'est<br/>
exécuté qu'une seule fois, après les trois<br/>
tours.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>a b</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>range(3)</code> fournit trois valeurs, le<br/>
corps de la boucle s'exécute donc trois fois<br/>
et <code>a</code> est affiché trois fois.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>a a a</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : le programme ne s'arrête pas à la fin<br/>
de la boucle ; l'instruction <code>print("b")</code>, qui<br/>
la suit, est exécutée une fois.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q08 : Valeur finale d'un while</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que vaut <code>x</code> à la fin de ce code ?<br/>
<pre><code>x = 1
while x &lt; 20:
    x = x * 3</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Une boucle <code>while</code> peut dépasser la borne de sa<br/>
condition : le corps s'exécute une dernière fois<br/>
quand la condition est encore vraie, et c'est<br/>
cette valeur qui reste à 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="0" format="html">
    <text><![CDATA[<p>9</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : pour <code>x = 9</code>, la condition <code>9 &lt; 20</code><br/>
est encore vraie, donc un tour supplémentaire<br/>
a lieu et <code>x</code> passe à 27.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>20</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>x</code> ne prend que les valeurs 1, 3, 9,<br/>
27 ; rien ne l'arrête exactement sur la borne<br/>
20.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>27</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : trace : 1 → 3 → 9 → 27. Pour<br/>
<code>x = 27</code>, la condition <code>27 &lt; 20</code> est fausse,<br/>
la boucle s'arrête.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>81</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : un tour de trop. Dès que <code>x</code> vaut 27,<br/>
la condition est fausse et le corps n'est plus<br/>
exécuté.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q09 : Test de parité</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Quelle expression vaut <code>True</code> si et seulement<br/>
si <code>n</code> est <strong>pair</strong> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Idiome très courant. Variante :<br/>
<code>bool(n % 2)</code> est <code>True</code> ⇔ <code>n</code> est impair.</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="0" format="html">
    <text><![CDATA[<p><code>n // 2 == 0</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ce test est vrai pour n = 0 ou<br/>
n = 1, pas pour la parité.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>n % 2 == 0</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>%</code> donne le reste. Reste<br/>
nul ⇔ pair.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>n / 2 == 0</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ce test est rarement vrai (n = 0<br/>
uniquement).</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>n == 2</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : seulement vrai pour n = 2.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q10 : Boucle simple</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que fait ce code ?<br/>
<pre><code>total = 0
for i in range(1, 5):
    total += i
print(total)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Schéma d'accumulation à connaître. En Python,<br/>
on peut aussi écrire <code>sum(range(1, 5))</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>Affiche <code>10</code> (= 1+2+3+4)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>range(1, 5)</code> produit<br/>
<code>[1, 2, 3, 4]</code>. La somme vaut 10. C'est<br/>
le schéma « accumulateur ».</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Boucle infinie</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>for</code> sur un range est toujours<br/>
fini.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Affiche <code>4</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : on additionne plusieurs valeurs.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Affiche <code>15</code> (= 1+2+3+4+5)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 5 est <strong>exclu</strong> de <code>range(1, 5)</code>.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q11 : Boucles imbriquées</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Combien de fois <code>print(...)</code> est-il exécuté ?<br/>
<pre><code>for i in range(3):
    for j in range(2):
        print(i, j)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Règle : pour des boucles imbriquées, le total<br/>
est le produit des nombres d'itérations.</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="0" format="html">
    <text><![CDATA[<p>5</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ce serait additif (3 + 2), mais<br/>
c'est multiplicatif.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>3</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la double boucle multiplie les<br/>
itérations.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>9</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ce serait <code>range(3) × range(3)</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>6</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : 3 × 2 = 6 itérations.<br/>
Couples : (0,0), (0,1), (1,0), (1,1),<br/>
(2,0), (2,1).</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q12 : Évaluation paresseuse</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Pourquoi <code>False and 1/0 == 0</code> ne lève-t-il pas<br/>
<code>ZeroDivisionError</code> en Python ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Évaluation paresseuse : <code>and</code> s'arrête au<br/>
premier <code>False</code> ; <code>or</code> s'arrête au premier<br/>
<code>True</code>. Très utile pour court-circuiter des<br/>
tests coûteux ou risqués.</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="0" format="html">
    <text><![CDATA[<p>Parce que <code>==</code> est prioritaire sur <code>/</code>, donc la division n'est jamais calculée</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>/</code> est prioritaire sur <code>==</code>. Évaluée<br/>
seule, l'expression <code>1/0 == 0</code> lève bien<br/>
<code>ZeroDivisionError</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Parce que la division par zéro est tolérée par Python</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>1/0</code> lève bien <code>ZeroDivisionError</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Parce que les nombres entiers ne plantent jamais</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>1/0</code> plante en général.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Parce que <code>and</code> est paresseux : si le premier est <code>False</code>, le second est ignoré</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : Python optimise. Cela permet<br/>
des idiomes comme <code>if liste and liste[0] &gt;<br/>
0:</code> (test de non-vide avant d'accéder à<br/>
l'indice 0).</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q13 : Trace d'un arrêt anticipé</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que produit ce code ?<br/>
<pre><code>i = 0
fini = False
while i &lt; 10 and not fini:
    if i == 3:
        fini = True
    else:
        print(i)
    i = i + 1</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Tracer pas à pas : i = 0 → print(0) ; i = 1 →<br/>
print(1) ; i = 2 → print(2) ; i = 3 → <code>fini</code><br/>
passe à <code>True</code>, puis le test <code>not fini</code> échoue.</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="0" format="html">
    <text><![CDATA[<p>0 1 2 3 4 5 6 7 8 9</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : dès que <code>fini</code> passe à <code>True</code>, la<br/>
condition <code>not fini</code> devient fausse et la<br/>
boucle s'arrête, bien avant <code>i = 10</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Aucune sortie</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : au départ <code>fini</code> vaut <code>False</code>, donc<br/>
<code>not fini</code> vaut <code>True</code> et la boucle démarre ;<br/>
l'arrêt n'intervient qu'à i = 3.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>0 1 2</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : on affiche 0, 1, 2 ; au tour<br/>
i = 3, la branche <code>if</code> met <code>fini</code> à <code>True</code> sans<br/>
afficher, puis la condition du <code>while</code> devient<br/>
fausse.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>0 1 2 3</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : au tour i = 3, c'est la branche <code>if</code><br/>
qui s'exécute, pas le <code>else</code> : le 3 n'est pas<br/>
affiché.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q14 : Trace avec négation</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que produit ce code ?<br/>
<pre><code>for i in range(5):
    if not (i % 2 == 0):
        print(i)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p><code>not</code> inverse un booléen : <code>not (i % 2 == 0)</code><br/>
est vrai exactement quand <code>i</code> est impair.<br/>
Équivalent plus direct : <code>if i % 2 != 0:</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="0" format="html">
    <text><![CDATA[<p>Boucle infinie</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>for</code> sur un range est borné.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>1 3 (les impairs)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : pour i ∈ {0, 2, 4} (pairs),<br/>
<code>i % 2 == 0</code> est vrai, donc sa négation est<br/>
fausse et le <code>print</code> est sauté. Restent 1 et 3.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>0 1 2 3 4</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la condition filtre les valeurs ;<br/>
l'affichage n'a lieu que pour les impairs.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>0 2 4 (les pairs)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est l'inverse, le <code>not</code> renverse le<br/>
test de parité : on affiche ceux qui ne sont<br/>
<strong>pas</strong> pairs.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q15 : While et condition</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que fait ce code, supposant la saisie d'un<br/>
entier non nul ?<br/>
<pre><code>n = int(input())
while n != 1:
    if n % 2 == 0:
        n = n // 2
    else:
        n = 3 * n + 1
    print(n)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>La conjecture de Syracuse (1937) demeure ouverte<br/>
en mathématiques : on ne sait pas prouver que la<br/>
suite atteint toujours 1 pour tout n entier<br/>
positif.</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="0" format="html">
    <text><![CDATA[<p>Boucle infinie systématique</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : pour tout n testé jusqu'à présent,<br/>
la suite atteint 1.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Affiche la suite de Fibonacci</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : aucune relation avec Fibonacci.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Calcule la suite de Syracuse jusqu'à atteindre 1</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : c'est l'algorithme classique<br/>
dont la terminaison est une <strong>conjecture</strong><br/>
(non démontrée, mais vérifiée pour de très<br/>
grandes valeurs).</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Lève systématiquement une exception à l'exécution</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : code valide.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q16 : Bug d'imbrication</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p><pre><code>x = 5
if x &gt; 0:
    if x &gt; 10:
        print("grand")
    else:
        print("moyen")
else:
    print("négatif ou nul")</code></pre><br/>
Qu'affiche le code ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Important : l'<code>else</code> est toujours apparié au<br/>
<code>if</code> du même niveau d'indentation. Lecture<br/>
attentive nécessaire.</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="0" format="html">
    <text><![CDATA[<p>Rien</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : un cas est forcément exécuté.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>négatif ou nul</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 5 est positif.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>moyen</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : x = 5 entre dans le premier<br/>
<code>if</code> (5 &gt; 0) ; puis comme 5 ≤ 10, on<br/>
exécute le <code>else</code> interne.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>grand</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 5 n'est pas &gt; 10.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q17 : Chaînage</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>L'expression <code>0 &lt; x &lt; 100</code> en Python est<br/>
équivalente à :</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Cas pratique : <code>if 0 &lt;= i &lt; len(liste):</code> pour<br/>
vérifier qu'un indice est valide. Bien plus<br/>
lisible que <code>if i &gt;= 0 and i &lt; len(liste):</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="0" format="html">
    <text><![CDATA[<p><code>0 &lt; x or x &lt; 100</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est <code>and</code> (et), pas <code>or</code> (ou).</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p><code>0 &lt; x and x &lt; 100</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : Python autorise le<br/>
chaînage. Idiomatique pour les bornes.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur de syntaxe</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la syntaxe est valide en Python.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>(0 &lt; x) &lt; 100</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ce serait du C ou du JavaScript, pas<br/>
du Python.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q18 : Parcours de liste</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Quelle est la façon la plus pythonique d'afficher<br/>
les éléments d'une liste ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Bonne pratique : <code>for x in liste:</code> quand on<br/>
n'a pas besoin de l'indice. Si l'indice est<br/>
utile aussi, on parcourt les indices avec<br/>
<code>for i in range(len(liste)):</code> et on lit<br/>
l'élément par <code>liste[i]</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="0" format="html">
    <text><![CDATA[<pre><code>while i in liste:
    print(i)</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>i in liste</code> est un test, pas une<br/>
itération. Et <code>i</code> n'est pas défini.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<pre><code>for x in liste:
    print(x)</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : forme idiomatique Python.<br/>
Plus lisible et moins sujette aux erreurs<br/>
d'indice.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<pre><code>for i in range(len(liste)):
    print(liste[i])</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Code correct mais peu pythonique. Préférer<br/>
la boucle directe sur les éléments.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<pre><code>do print(x) for x in liste</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : syntaxe invalide en Python (peut-<br/>
être Ruby ou Perl).</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q19 : Compréhension de liste</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Quel est l'équivalent <strong>pythonique</strong> de :<br/>
<pre><code>carres = []
for i in range(10):
    carres.append(i * i)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Compréhension de liste générale :<br/>
<code>[expr for x in iterable if cond]</code>. Très<br/>
utilisée en Python pour les transformations<br/>
simples.</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>carres = [i * i for i in range(10)]</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : compréhension de liste,<br/>
plus concise et idiomatique.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>carres = [10][i * i]</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : syntaxe invalide.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>carres = [i * 2 for i in range(10)]</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>i * 2</code> calcule le <strong>double</strong>, pas le<br/>
carré : on obtient <code>[0, 2, 4, ..., 18]</code> au<br/>
lieu de <code>[0, 1, 4, ..., 81]</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>carres = range(10) ** 2</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : on ne peut pas élever un range au<br/>
carré.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q20 : Trace de while</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que vaut <code>n</code> à la fin de :<br/>
<pre><code>n = 100
while n &gt; 1:
    n = n // 2</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Cette boucle calcule combien de fois on peut<br/>
diviser n par 2. C'est le <strong>logarithme entier</strong><br/>
en base 2 (motif de complexité O(log n)).</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="0" format="html">
    <text><![CDATA[<p>Une infinité</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>n // 2</code> réduit n à chaque tour.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>1</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : trace : 100 → 50 → 25 → 12<br/>
→ 6 → 3 → 1. À ce moment, <code>1 &gt; 1</code> est faux,<br/>
on sort.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>0</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la boucle s'arrête quand n ≤ 1, donc<br/>
n vaut au moins 1 à la fin.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>2</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 2 // 2 = 1, donc on continue.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q21 : Boucle infinie</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Pourquoi cette boucle est-elle infinie ?<br/>
<pre><code>i = 0
while i &lt; 10:
    print(i)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Bug ultra-classique chez les débutants. Toujours<br/>
vérifier qu'un <strong>variant</strong> (ici, <code>i</code>) progresse<br/>
vers la condition de 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="0" format="html">
    <text><![CDATA[<p>Parce que <code>print</code> ne renvoie rien</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Le fait que <code>print</code> ne<br/>
renvoie pas de valeur<br/>
(autre que <code>None</code>) n'a<br/>
aucun lien avec la<br/>
terminaison de la boucle.<br/>
Ce qui pose problème ici,<br/>
c'est que <code>i</code> n'évolue<br/>
jamais.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Parce que <code>while</code> est toujours infini</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>while</code> peut très bien terminer.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Parce que l'initialisation <code>i = 0</code> serait fausse</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 0 &lt; 10 est vrai.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Parce que <code>i</code> n'est jamais modifié dans la boucle</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : il faut ajouter <code>i += 1</code><br/>
pour que la condition <code>i &lt; 10</code> finisse par<br/>
devenir fausse.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q22 : Borne d'un range modifiée en cours de boucle</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Qu'affiche ce code ?<br/>
<pre><code>n = 3
for i in range(n):
    n = n + 1
print(i, n)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p><code>range(n)</code> est construit une seule fois, à l'entrée<br/>
dans la boucle. Le nombre de tours est figé à ce<br/>
moment-là : modifier <code>n</code> ensuite n'allonge pas la<br/>
boucle, à la différence d'une liste que l'on<br/>
modifie pendant son parcours.</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 6</code>, car <code>range(3)</code> est calculé une fois pour toutes au début de la boucle</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>range(n)</code> est évalué une seule<br/>
fois, avec <code>n</code> valant 3 ; la boucle fait donc<br/>
trois tours (<code>i</code> vaut 0, 1 puis 2) et <code>n</code> est<br/>
incrémenté trois fois, de 3 à 6.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>La boucle ne s'arrête jamais, car <code>n</code> augmente d'une unité à chaque tour</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la borne n'est pas relue à chaque tour.<br/>
Modifier <code>n</code> dans le corps ne change pas la<br/>
suite <code>range(3)</code> déjà construite, contrairement<br/>
à une liste que l'on allonge en la parcourant.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p><code>3 6</code>, car <code>i</code> termine à la valeur de la borne de départ, c'est-à-dire 3</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>range(3)</code> produit 0, 1 et 2, jamais 3.<br/>
La dernière valeur prise par <code>i</code> est 2, car la<br/>
borne d'un <code>range</code> est exclue.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Une erreur à l'exécution, car <code>n</code> ne peut pas être modifiée pendant le parcours de <code>range(n)</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : aucune règle n'interdit d'affecter <code>n</code><br/>
dans le corps de la boucle ; le code s'exécute<br/>
sans erreur. Une fois la boucle lancée, <code>n</code> et<br/>
la suite <code>range(3)</code> sont indépendants.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q23 : Modifier en parcourant</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que se passe-t-il à l'exécution de ce code ?<br/>
<pre><code>liste = [1, 2, 3]
for x in liste:
    liste.append(x * 2)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Règle de sécurité : ne <strong>jamais</strong> modifier une<br/>
collection pendant qu'on la parcourt. Parcourir<br/>
une copie (<code>liste[:]</code>) ou construire une nouvelle<br/>
liste.</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>La boucle ne s'arrête jamais, car la liste s'allonge à chaque tour</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la boucle <code>for</code> lit la liste<br/>
telle qu'elle est au moment de chaque tour ;<br/>
comme chaque tour ajoute un élément, la fin<br/>
n'est jamais atteinte. Ne jamais modifier une<br/>
liste pendant qu'on la parcourt.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>La boucle fait trois tours et la liste finale vaut <code>[1, 2, 3, 2, 4, 6]</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : le <code>for</code> ne fige pas la liste au<br/>
départ ; il consulte sa longueur courante à<br/>
chaque tour et trouve toujours un élément de<br/>
plus. Ce résultat exigerait de parcourir une<br/>
copie, <code>for x in liste[:]:</code>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Python lève une erreur, car une liste ne peut pas être modifiée pendant son parcours</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : Python n'interdit rien ici, aucune<br/>
exception n'est levée ; c'est justement ce<br/>
silence qui rend le piège dangereux.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>La boucle fait trois tours, car <code>append</code> ne modifie pas <code>liste</code> mais en renvoie une copie</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>append</code> modifie la liste <strong>sur<br/>
place</strong> (et renvoie <code>None</code>) : c'est bien la<br/>
liste parcourue qui grandit.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q24 : Compteur avec if et elif</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Qu'affiche ce code ?<br/>
<pre><code>c = 0
for n in range(1, 16):
    if n % 3 == 0:
        c = c + 1
    elif n % 5 == 0:
        c = c + 2
print(c)</code></pre></p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Dans un <code>if</code>/<code>elif</code>, une seule branche s'exécute<br/>
par tour. Il faut donc trier chaque valeur de<br/>
<code>range(1, 16)</code> : multiples de 3 (cinq valeurs),<br/>
puis multiples de 5 restants (5 et 10).</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>9</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : cinq multiples de 3 (3, 6, 9,<br/>
12, 15) ajoutent 1 chacun ; 5 et 10 ajoutent 2<br/>
chacun ; 15, déjà pris par le <code>if</code>, n'entre<br/>
pas dans le <code>elif</code>. Total 5 + 4 = 9.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>11</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 15 est compté deux fois, comme avec<br/>
deux <code>if</code> indépendants. Avec <code>elif</code>, la<br/>
seconde condition n'est pas testée quand la<br/>
première est vraie.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>5</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la branche <code>elif</code> est ignorée ; 5 et<br/>
10, qui ne sont pas multiples de 3, y entrent<br/>
et ajoutent 2 chacun.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>7</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la branche <code>elif</code> ajoute 2, pas 1 ;<br/>
5 et 10 apportent donc 4 au total, et non 2.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q25 : Synthèse</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Parmi les affirmations suivantes, laquelle est<br/>
<strong>fausse</strong> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Le <code>while</code> teste d'abord, exécute ensuite : une<br/>
boucle <code>while</code> peut ne faire aucun tour, alors<br/>
qu'une boucle <code>for</code> sur un <code>range</code> fini termine<br/>
toujours.</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>La condition d'un <code>while</code> n'est vérifiée qu'après chaque exécution du corps</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Faux (donc bonne réponse) : la condition est<br/>
testée <strong>avant</strong> chaque tour, y compris le<br/>
premier. Si elle est fausse d'emblée, le corps<br/>
ne s'exécute jamais.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>La boucle <code>for</code> sur un <code>range</code> fini termine toujours sans intervention</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Vrai : terminaison automatique.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Les opérateurs logiques <code>and</code>, <code>or</code>, <code>not</code> permettent de combiner des conditions</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Vrai : ce sont les trois opérateurs<br/>
booléens.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>La boucle <code>while</code> peut être infinie si la condition ne devient jamais fausse</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Vrai : risque classique de bug.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q26 : Boucle de saisie validée</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>On veut que l'utilisateur saisisse un entier<br/>
strictement positif et redemander tant que la<br/>
réponse n'est pas correcte. Quel code convient le<br/>
mieux ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Schéma de validation de saisie : initialiser la<br/>
variable avec une valeur qui ne convient pas, pour<br/>
forcer un premier tour, puis répéter tant que la<br/>
valeur ne convient pas. La condition du <code>while</code><br/>
dit exactement « tant que la saisie est mauvaise ».</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="0" format="html">
    <text><![CDATA[<pre><code>for i in range(10):
    n = int(input("n ? "))</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ce code demande <strong>dix fois</strong> la valeur,<br/>
quelle que soit la qualité des saisies, et<br/>
conserve la dernière. Il ne s'arrête pas dès<br/>
qu'une bonne valeur est donnée.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<pre><code>n = 0
while n &lt;= 0:
    n = int(input("n ? "))</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>n</code> est initialisé à une valeur<br/>
invalide (0 n'est pas strictement positif), ce<br/>
qui garantit un premier passage ; la boucle<br/>
redemande ensuite tant que la saisie reste<br/>
négative ou nulle.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<pre><code>n = -1
while n &gt; 0:
    n = int(input("n ? "))</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la condition initiale <code>n &gt; 0</code> est<br/>
fausse (puisque <code>n = -1</code>), donc la boucle ne<br/>
s'exécute <strong>jamais</strong>. Aucune saisie n'est<br/>
réellement effectuée.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<pre><code>n = int(input("n ? "))
if n &lt;= 0:
    n = int(input("n ? "))</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ce code ne redemande qu'<strong>une seule fois</strong> la valeur. Si l'utilisateur entre encore<br/>
une valeur invalide à la deuxième saisie, le<br/>
programme continue avec cette valeur erronée.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q27 : if/elif vs plusieurs if</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Considérons les deux extraits suivants. En quoi<br/>
diffèrent-ils ?</p>
<pre><code># Extrait A
if x &gt; 0:
    y = 1
elif x &gt; 10:
    y = 2

# Extrait B
if x &gt; 0:
    y = 1
if x &gt; 10:
    y = 2</code></pre>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Règle pratique : utiliser <code>elif</code> lorsque les<br/>
branches s'excluent mutuellement (un seul cas est<br/>
vrai à la fois). Utiliser des <code>if</code> séparés<br/>
lorsqu'on veut <strong>vraiment</strong> que plusieurs<br/>
conditions puissent déclencher chacune leur action.</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="0" format="html">
    <text><![CDATA[<p>Ils produisent toujours le même résultat, quelle que soit la valeur de <code>x</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ils diffèrent justement quand <code>x</code> est<br/>
strictement supérieur à $10$. L'extrait A donne<br/>
$y = 1$ (la branche <code>elif</code> n'est pas testée<br/>
parce que la première est vraie), l'extrait B<br/>
donne $y = 2$ (les deux conditions s'évaluent).</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>A n'exécute qu'une seule branche ; B peut exécuter les deux</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : <code>elif</code> indique que l'on<br/>
n'évalue cette branche que si la précédente<br/>
était fausse. Avec deux <code>if</code> séparés, les deux<br/>
conditions sont toujours vérifiées<br/>
indépendamment, ce qui peut conduire à des<br/>
réaffectations indésirables.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>L'extrait A produit une erreur car <code>elif</code> ne fonctionne pas seul</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>elif</code> est un mot-clé valide en Python<br/>
tant qu'il suit un <code>if</code>. Sa présence ne<br/>
provoque aucune erreur de syntaxe.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>L'extrait B est plus rapide, car il évite le mot-clé <code>elif</code></p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la différence ne porte pas sur la<br/>
vitesse mais sur la <strong>logique</strong>. L'extrait A<br/>
peut au contraire être plus rapide, car il<br/>
n'évalue pas la deuxième condition lorsque la<br/>
première est vraie.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q28 : Parcours parallèle de deux listes</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Deux listes <code>noms</code> et <code>notes</code> de même longueur<br/>
rangent au même rang le nom d'un élève et sa note.<br/>
Quel code affiche chaque nom suivi de sa note ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Le parcours par indice <code>for i in range(len(...))</code><br/>
est le moyen d'accéder au même rang dans deux<br/>
listes. L'hypothèse « de même longueur » garantit<br/>
que <code>notes[i]</code> existe pour tout indice valide de<br/>
<code>noms</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="0" format="html">
    <text><![CDATA[<pre><code>print(noms + notes)</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la concaténation <code>noms + notes</code> produit<br/>
une seule liste juxtaposant les deux. Il n'y a<br/>
pas d'appariement, et tout est affiché en bloc.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<pre><code>for i in range(len(noms)):
    print(noms[i], notes[i])</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : l'indice <code>i</code> parcourt les<br/>
positions de 0 à <code>len(noms) - 1</code> et sert à lire<br/>
au même rang le nom et la note qui lui<br/>
correspond.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<pre><code>for nom in noms:
    for note in notes:
        print(nom, note)</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ces boucles imbriquées affichent<br/>
<strong>toutes les paires</strong> (nom, note), pas<br/>
uniquement celles de même rang. Pour deux<br/>
listes de longueur $n$, on obtient $n^2$<br/>
lignes au lieu de $n$.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<pre><code>for nom in noms:
    print(nom, notes[nom])</code></pre>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : <code>nom</code> est une chaîne, pas un indice.<br/>
<code>notes[nom]</code> lève <code>TypeError</code>, car une liste ne<br/>
s'indexe qu'avec un entier. Pour retrouver le<br/>
rang, il faut parcourir les indices.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Conditions et boucles — Q29 : Calcul d'une racine entière</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>On exécute le code suivant :</p>
<pre><code>n = 30
r = 0
while r * r &lt;= n:
    r = r + 1</code></pre>
<p>Quelle est la valeur de <code>r</code> à la sortie de la boucle ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Cet algorithme calcule le plus petit entier $r$<br/>
tel que $r^2 &gt; n$. À la sortie, $r - 1$ est la<br/>
partie entière de $\sqrt{n}$. Pour $n = 30$, on<br/>
obtient $r = 6$, et $r - 1 = 5$, conforme à<br/>
$\lfloor\sqrt{30}\rfloor = 5$.</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="0" format="html">
    <text><![CDATA[<p>$7$</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la boucle s'arrête dès que la condition<br/>
devient fausse, sans incrémenter une fois de<br/>
plus. Pour $r = 6$, on a déjà $36 &gt; 30$ : la<br/>
boucle est sortie avec $r = 6$.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>$6$</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la boucle s'arrête dès que<br/>
$r \times r &gt; n$. Pour $r = 5$, $25 \leq 30$ :<br/>
on incrémente. Pour $r = 6$, $36 &gt; 30$ : on<br/>
sort. La valeur finale est donc $r = 6$.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>$30$</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : confusion entre la valeur cible $n$ et<br/>
la variable <code>r</code>. La boucle calcule la <strong>racine carrée entière</strong> par majorant, pas la valeur de<br/>
$n$.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>$5$</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : pour $r = 5$, on a $r \times r = 25<br/>
\leq 30$, donc la condition est encore vraie.<br/>
La boucle fait au moins une itération de plus.</p>]]></text>
    </feedback>
  </answer>
</question>

</quiz>
