<?xml version="1.0" encoding="UTF-8"?>
<quiz>
<question type="category">
  <category>
    <text>$course$/QCM de NSI/Terminale/Diviser pour régner</text>
  </category>
  <info format="html">
    <text><![CDATA[<p>Paradigme diviser pour régner (étapes diviser, régner, combiner),<br/>
recherche dichotomique, tri fusion et tri rapide, exponentiation<br/>
rapide, complexité par récurrence et théorème maître.</p>]]></text>
  </info>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q01 : Étapes du paradigme diviser pour régner</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Quelles sont les <strong>trois étapes</strong> du paradigme diviser pour<br/>
régner ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Le paradigme repose sur l'idée que résoudre un sous-problème<br/>
plus petit est plus simple, et que combiner les solutions<br/>
partielles donne efficacement la solution complète. C'est<br/>
l'idée mère de la recherche dichotomique, du tri fusion, de<br/>
l'exponentiation rapide, etc.</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>Diviser, régner, combiner</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : on divise le problème en sous-problèmes<br/>
plus petits, on les résout (récursivement), puis on<br/>
combine les solutions partielles pour obtenir la solution<br/>
du problème initial.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Identifier, calculer, vérifier</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ces verbes décrivent une démarche scientifique<br/>
générale, pas la stratégie diviser pour régner.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Trier, fusionner, comparer</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ces opérations apparaissent dans le tri fusion<br/>
(un cas particulier), mais ne sont pas les trois étapes<br/>
générales du paradigme.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Initialiser, itérer, terminer</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ces étapes décrivent une boucle, pas le paradigme<br/>
diviser pour régner qui est typiquement récursif.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q02 : Complexité de la recherche dichotomique</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Quelle est la complexité au pire de la recherche dichotomique<br/>
sur un tableau trié de n éléments ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Pour n = 10⁹, la dichotomie effectue au plus 30<br/>
comparaisons. C'est l'un des gains algorithmiques les plus<br/>
spectaculaires : passer de linéaire à logarithmique.</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>O(1)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ce serait une recherche en temps constant, ce<br/>
qui n'est pas réaliste pour rechercher un élément dans<br/>
un tableau de taille variable.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>O(n)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est la complexité de la recherche <strong>linéaire</strong>.<br/>
La dichotomie est plus rapide grâce au tri préalable.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>O(n \log n)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est la complexité du tri fusion, pas d'une<br/>
recherche.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>O(\log n)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : à chaque étape, l'intervalle de recherche<br/>
est divisé par deux. Le nombre d'étapes est donc le<br/>
logarithme en base 2 de n.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q03 : Principe du tri fusion</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Quel est le principe du <strong>tri fusion</strong> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Le tri fusion est l'archétype du tri par diviser pour régner.<br/>
Sa complexité O(n \log n) ne dépend pas de l'ordre initial,<br/>
ce qui en fait un tri à comportement <strong>prévisible</strong>.</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>Couper en deux moitiés, trier chacune récursivement, puis les fusionner</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : c'est l'application directe du paradigme<br/>
diviser pour régner. La fusion de deux tableaux triés<br/>
se fait en temps linéaire en parcourant les deux<br/>
simultanément.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Chercher le plus petit élément, le placer en début, recommencer</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est le principe du tri par sélection.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Comparer chaque paire d'éléments adjacents et les permuter si nécessaire</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est le principe du tri à bulles, en O(n²).</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Insérer chaque élément à sa place dans la portion déjà triée</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est le principe du tri par insertion.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q04 : Complexité du tri fusion</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Quelle est la complexité du tri fusion sur un tableau de n<br/>
éléments ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Le tri fusion est <strong>stable</strong> (préserve l'ordre des éléments<br/>
égaux) et a une complexité <strong>garantie</strong> O(n \log n) dans<br/>
tous les cas, ce qui le rend prédictible. Son inconvénient<br/>
principal : il n'est <strong>pas en place</strong>.</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>O(2ⁿ)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : aucun tri usuel n'est exponentiel.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>O(n \log n)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : il y a \log n niveaux de récursion (on<br/>
divise par deux à chaque niveau). À chaque niveau, on<br/>
parcourt l'ensemble des n éléments lors des fusions.<br/>
Total : n \log n.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>O(n)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la fusion seule est en O(n), mais on la<br/>
répète sur \log n niveaux de récursion, ce qui donne<br/>
O(n \log n) au total.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>O(n²)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est la complexité des tris naïfs (sélection,<br/>
insertion, bulles). Le tri fusion est meilleur grâce au<br/>
paradigme DPR.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q05 : Cas de base du tri fusion</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Quel est le <strong>cas de base</strong> du tri fusion ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Choisir un cas de base à 0 ou 1 élément simplifie le<br/>
code : on n'a même pas besoin de gérer la division pour ces<br/>
cas. Cela rend la fonction parfaitement récursive.</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>Un tableau de longueur paire</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la parité ne garantit pas qu'un tableau soit<br/>
trié. Le tri fusion fonctionne pour toute parité.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Un tableau de deux éléments</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : un tableau de deux éléments peut être mal<br/>
trié. Il faut soit le diviser à nouveau, soit le trier<br/>
directement (cas particulier optimisé).</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Un tableau trié</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : on ne sait pas a priori si le tableau est trié<br/>
(sans le parcourir). Le cas de base du tri fusion est<br/>
basé sur la <strong>taille</strong>, pas sur l'ordre.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Un tableau de zéro ou un élément</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : un tableau vide ou de longueur 1 est<br/>
déjà trié par définition. La récursion s'arrête à ce<br/>
niveau, sans nouvelle découpe ni fusion.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q06 : Principe de l'exponentiation rapide</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>L'<strong>exponentiation rapide</strong> calcule aⁿ en exploitant<br/>
quelle propriété mathématique ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Pour calculer a²⁰ : la méthode naïve fait 19<br/>
multiplications, l'exponentiation rapide en fait environ<br/>
\log_2(20) \approx 5. Le gain devient énorme pour de<br/>
grands exposants (cryptographie, arithmétique modulaire).</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>a^n = (a^2)^{n/2} si n est pair, et a^n = (a^2)^{(n-1)/2} si n est impair</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : le cas pair est juste, mais le cas impair oublie<br/>
le facteur a restant : (a^2)^{(n-1)/2} = a^{n-1}, pas<br/>
aⁿ. Il faut multiplier par a une dernière fois.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>aⁿ = a + a + ·s + a (n fois)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est la définition de la multiplication, pas<br/>
de la puissance. L'exponentiation rapide ne peut pas<br/>
partir d'une somme.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>a^n = (a^{n/2})^2 si n est pair, et a^n = a \cdot (a^{(n-1)/2})^2 si n est impair</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : on divise l'exposant par deux à chaque<br/>
étape (au lieu de soustraire 1). Cela amène la<br/>
complexité de O(n) à O(\log n).</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>aⁿ = aⁿ⁻¹ · a si n ≥ 1, avec a⁰ = 1</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est la définition récursive <strong>naïve</strong> de la<br/>
puissance, en O(n). L'exponentiation rapide va beaucoup<br/>
plus vite.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q07 : Tri fusion en place ?</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Le tri fusion est-il un tri <strong>en place</strong> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Tris en place : par sélection, par insertion. Tri <strong>non en<br/>
place</strong> : tri fusion (mémoire O(n)). Cette mémoire<br/>
supplémentaire est le prix de son coût en O(n \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>Oui, mais seulement pour des listes de taille paire</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la parité n'a aucune influence sur le caractère<br/>
en place ou non.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Non, il utilise une mémoire supplémentaire proportionnelle à n</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : à chaque niveau de récursion, on crée des<br/>
tableaux pour les moitiés et la fusion. C'est l'un des<br/>
inconvénients du tri fusion, contrairement au tri par<br/>
insertion ou au tri par sélection.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Non, mais il utilise une mémoire constante</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la mémoire supplémentaire n'est pas constante,<br/>
elle est proportionnelle à la taille du tableau.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Oui, il modifie le tableau d'origine sans mémoire supplémentaire</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : le tri fusion utilise des tableaux auxiliaires<br/>
(les moitiés gauche et droite, puis le résultat fusionné).<br/>
Sa mémoire supplémentaire est en O(n).</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q08 : Pré-requis de la recherche dichotomique</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Quelle est la condition <strong>indispensable</strong> pour appliquer la<br/>
recherche dichotomique ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Si la liste n'est pas triée et que les recherches sont<br/>
occasionnelles, mieux vaut faire une recherche linéaire<br/>
qu'un tri préalable. La dichotomie est rentable quand on<br/>
prévoit de très nombreuses recherches sur la même 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>Le tableau doit être trié</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la dichotomie compare l'élément cherché<br/>
au milieu pour décider d'aller à gauche ou à droite. Si<br/>
le tableau n'est pas trié, cette comparaison ne donne<br/>
aucune information utile, et l'algorithme peut renvoyer<br/>
un faux négatif.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Le tableau doit être de taille puissance de 2</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la taille n'a pas besoin d'être une puissance<br/>
de 2. La dichotomie fonctionne pour toute taille<br/>
≥ 0.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Le tableau doit avoir une taille connue à l'avance</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est une caractéristique des tableaux Python<br/>
ou C en général, pas une contrainte de la dichotomie.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Le tableau doit contenir uniquement des entiers</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la dichotomie fonctionne sur tout type<br/>
comparable (entiers, flottants, chaînes, dates, etc.).</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q09 : Récursivité et diviser pour régner</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Pourquoi le paradigme diviser pour régner s'implémente-t-il<br/>
naturellement par <strong>récursivité</strong> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Certains algorithmes DPR ont des versions itératives plus<br/>
efficaces (recherche dichotomique itérative, exponentiation<br/>
rapide itérative), mais la version récursive est souvent<br/>
plus claire pédagogiquement.</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 ce paradigme nécessite obligatoirement le recours à la mémoïsation</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la mémoïsation concerne la programmation<br/>
dynamique, pas le diviser pour régner classique.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Parce que la récursivité est plus rapide que l'itération</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la récursivité est en réalité souvent un peu<br/>
<strong>plus lente</strong> (surcoût des appels) en Python. Son<br/>
intérêt est la lisibilité, pas la vitesse.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Parce que les sous-problèmes sont de même nature, ce qui s'exprime par récursivité</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la définition même du paradigme implique<br/>
que les sous-problèmes sont de même structure que le<br/>
problème principal. Une fonction qui s'appelle<br/>
elle-même sur le sous-problème est l'expression la plus<br/>
directe.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Parce que la récursivité est le seul moyen de coder une boucle en Python</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : Python permet aussi des boucles for et<br/>
while. La récursivité est un choix, pas une<br/>
obligation.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q10 : Fusion de deux listes triées</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Pour fusionner deux listes <strong>déjà triées</strong> de longueur n<br/>
chacune en une seule liste triée, quelle est la complexité<br/>
de l'opération ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>C'est précisément cette fusion en O(n) par niveau, répétée<br/>
sur \log n niveaux, qui donne la complexité globale en<br/>
O(n \log n) du tri fusion.</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>O(n²)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : on n'a pas besoin de comparer chaque élément à<br/>
tous les autres, seulement aux candidats en tête de<br/>
chaque liste.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>O(1)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : il faut quand même parcourir les éléments des<br/>
deux listes au moins une fois pour les disposer dans<br/>
l'ordre.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>O(n)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : on parcourt les deux listes<br/>
simultanément avec un index pour chacune. Chaque<br/>
comparaison fait avancer l'un des deux index. Au total,<br/>
on fait 2n pas, soit O(n).</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>O(n \log n)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est la complexité du tri fusion <strong>complet</strong>,<br/>
pas de la seule fusion. La fusion est l'étape<br/>
« combiner » du paradigme.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q11 : Nombre de comparaisons en dichotomie</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Combien de comparaisons effectue <strong>au pire</strong> une recherche<br/>
dichotomique sur un tableau de 1\ 000 éléments ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Repère utile : doubler la taille n'ajoute qu'<strong>une</strong><br/>
comparaison. Pour passer de 1\ 000 à 2\ 000, on passe de<br/>
10 à 11 comparaisons. C'est ce qui rend les algorithmes<br/>
logarithmiques exceptionnellement rapides à grande échelle.</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>1\ 000</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est le nombre maximal de comparaisons d'une<br/>
recherche <strong>linéaire</strong>. La dichotomie est bien plus<br/>
rapide.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>10</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : \log_2(1\ 000) \approx 9{,}97, soit<br/>
environ 10. Au pire, 10 comparaisons suffisent pour<br/>
trouver l'élément ou conclure à son absence.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>500</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la première étape de la dichotomie élimine la<br/>
moitié des candidats, mais on continue à diviser<br/>
ensuite. Le total est bien plus faible que 500.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>1</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : on ne peut pas garantir une seule comparaison<br/>
dans le pire cas. Le pire cas atteint \lceil \log_2 n \rceil<br/>
comparaisons.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q12 : Tri fusion sur un exemple</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Si l'on applique le tri fusion à la liste [5, 2, 8, 3, 9, 1],<br/>
quelle est la première étape ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Après division récursive, on obtient des sous-listes de<br/>
taille 1 (déjà triées). Puis les fusions remontent en<br/>
reconstituant des sous-listes triées de plus en plus<br/>
grandes : [2, 5], [2, 5, 8], etc. jusqu'au tableau<br/>
complet trié.</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>Comparer 5 et 2, les permuter</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est l'opération du tri à bulles. Le tri<br/>
fusion ne fait pas de comparaisons adjacentes au début.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Diviser la liste en [5, 2, 8] et [3, 9, 1]</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : on coupe la liste au milieu en deux<br/>
sous-listes de taille (presque) égale. Chaque moitié<br/>
sera triée récursivement avant la fusion finale.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Trier la liste avec une fonction sorted intégrée</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : utiliser sorted éviterait l'algorithme<br/>
étudié. La question porte sur le déroulement du tri<br/>
fusion lui-même.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Trouver le plus petit élément (1) et le placer en début</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est le tri par sélection. Le tri fusion ne<br/>
cherche pas le minimum, il découpe la liste en deux.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q13 : Complexité de l'exponentiation rapide</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Quelle est la complexité de l'exponentiation rapide pour<br/>
calculer aⁿ ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Pour n = 10¹⁸, la méthode naïve ferait 10¹⁸ - 1<br/>
multiplications (impossible). L'exponentiation rapide n'en<br/>
fait qu'une soixantaine. Indispensable en cryptographie<br/>
asymétrique (RSA).</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>O(\log n)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : à chaque appel récursif, on divise<br/>
l'exposant par deux. Il y a donc environ \log_2 n<br/>
niveaux d'appels, donc autant de multiplications.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>O(n²)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : aucune raison d'avoir une complexité quadratique<br/>
pour ce calcul.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>O(1)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la complexité dépend bien de n. Pour n<br/>
très grand, le calcul nécessite plusieurs étapes.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>O(n)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est la complexité de la méthode <strong>naïve</strong><br/>
(aⁿ = a · aⁿ⁻¹, n - 1 multiplications).<br/>
L'exponentiation rapide divise par deux au lieu de<br/>
décrémenter de 1.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q14 : Les recopies de toutes les fusions</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Le tri fusion d'un tableau de 8 éléments découpe le tableau jusqu'à des<br/>
tableaux d'un seul élément, puis fusionne les moitiés triées. Fusionner<br/>
deux tableaux de tailles a et b recopie a + b éléments dans le<br/>
résultat. Combien d'éléments sont recopiés au total par toutes les<br/>
fusions du tri ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Le coût du tri fusion se compte niveau par niveau : chaque niveau de<br/>
fusions traite les n éléments, et il y a \log_2 n niveaux de<br/>
découpage. D'où un coût de l'ordre de n \log_2 n, contre n² pour le<br/>
tri par insertion dans le pire des cas.</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>8</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 8 est le travail de la seule dernière fusion. Les niveaux<br/>
précédents fusionnent aussi, chaque fois, l'ensemble des 8 éléments<br/>
répartis en tableaux plus petits.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>7</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 7 est le nombre de fusions (4 + 2 + 1), pas le nombre<br/>
d'éléments recopiés. Une fusion recopie tous les éléments des deux<br/>
tableaux qu'elle réunit.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>24</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : on effectue 4 fusions de tableaux de 1 élément (8 recopies), puis 2 fusions de tableaux de 2 éléments (8 recopies), puis 1 fusion de tableaux de 4 éléments (8 recopies). 3 niveaux<br/>
de 8 recopies donnent 24, soit n \log_2 n pour n = 8.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>64</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 64 vaut n², l'ordre de grandeur du tri par insertion dans<br/>
le pire des cas. Le tri fusion ne recopie les 8 éléments qu'une fois<br/>
par niveau, sur 3 niveaux.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q16 : Tri fusion vs tri par insertion</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Pour trier un tableau de 1\ 000\ 000 éléments, le tri<br/>
fusion (O(n \log n)) est environ combien de fois plus<br/>
rapide que le tri par insertion (O(n²)) ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Cette différence d'ordre de grandeur explique pourquoi le<br/>
choix de l'algorithme est crucial. Sur petites entrées, les<br/>
tris simples sont compétitifs ; sur grandes entrées, les<br/>
tris en O(n \log n) deviennent indispensables.</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>2 fois</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la différence est bien plus grande. \log_2 n<br/>
n'est qu'une fraction de n pour de grandes valeurs.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>10 fois</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la différence est de plusieurs ordres de<br/>
grandeur, pas un seul facteur 10.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>1\ 000\ 000 fois</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ce serait le rapport n² / n = n, mais on<br/>
divise par n \log n, pas par n.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>50\ 000 fois</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : pour n = 1\ 000\ 000, n² = 10¹² et<br/>
n \log_2 n \approx 2 \cdot 10^7. Le rapport est<br/>
environ 50\ 000. C'est la différence entre une seconde et 14 heures sur la même machine.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q17 : Optimisation par mémoïsation</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Dans une implémentation <strong>récursive</strong> d'exponentiation<br/>
rapide, est-il utile d'ajouter de la <strong>mémoïsation</strong> ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>La distinction est cruciale : le diviser pour régner peut<br/>
avoir des sous-problèmes redondants (cas de Fibonacci) ou<br/>
uniques (cas de l'exponentiation rapide). Seul le premier<br/>
bénéficie de la mémoïsation.</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>Non, l'exponentiation rapide ne fait pas d'appels redondants</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : à chaque appel, le sous-problème est<br/>
unique (un seul exposant intermédiaire est calculé). Il<br/>
n'y a donc aucun calcul redondant, contrairement à<br/>
Fibonacci naïf.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Cela rendrait l'algorithme plus lent</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la mémoïsation seule ne ralentit pas<br/>
significativement, mais l'avantage est nul ici.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Oui, la mémoïsation accélère nettement le calcul récursif</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : à chaque appel, on calcule une seule valeur<br/>
intermédiaire (demi = puissance(a, n // 2)), pas la<br/>
même plusieurs fois. La mémoïsation n'apporterait rien.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Oui, mais seulement pour des exposants pairs</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la mémoïsation n'est utile que s'il y a des<br/>
appels redondants, ce qui n'est pas le cas ici.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q18 : Détection d'une erreur dans la dichotomie</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Dans la fonction suivante :</p>
<p>`<code>python<br/>
def recherche(x, tab):<br/>
    gauche, droite = 0, len(tab) - 1<br/>
    while gauche &lt; droite:        # ← ICI<br/>
        milieu = (gauche + droite) // 2<br/>
        if tab[milieu] == x:<br/>
            return milieu<br/>
        elif tab[milieu] &lt; x:<br/>
            gauche = milieu + 1<br/>
        else:<br/>
            droite = milieu - 1<br/>
    return -1<br/>
</code>`</p>
<p>Quel est le bug ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Erreur subtile et classique. Test concret : avec<br/>
tab = [5] et x = 5, on a gauche = droite = 0, la<br/>
condition gauche &lt; droite est fausse, on sort<br/>
immédiatement et on renvoie -1 alors que x est présent.</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>Il manque l'initialisation de la variable milieu juste avant la boucle</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : milieu est défini à l'intérieur de la boucle,<br/>
ce qui est la convention habituelle.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Le calcul de milieu est incorrect</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : le calcul (gauche + droite) // 2 est<br/>
standard et correct. Le bug est ailleurs.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>La fonction devrait être récursive pour fonctionner</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la dichotomie peut s'écrire en itératif comme<br/>
en récursif. La forme itérative est même souvent<br/>
préférée.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>La condition de boucle devrait être gauche &lt;= droite, pas &lt;</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : avec &lt; strict, on n'examine pas le<br/>
dernier élément quand gauche == droite. La fonction<br/>
peut renvoyer -1 pour un élément qui est en réalité<br/>
présent.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q19 : Où va un pixel après un quart de tour</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Une image carrée de n × n pixels est stockée dans un tableau<br/>
de tableaux : image[i][j] est le pixel de la ligne i et de la<br/>
colonne j, les indices allant de 0 à n - 1. On tourne l'image<br/>
d'un quart de tour dans le sens des aiguilles d'une montre. Où<br/>
arrive le pixel image[i][j] ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Pour tourner l'image sans créer de seconde image, on déplace les<br/>
pixels par groupes de quatre, qui s'échangent en cercle d'un<br/>
coin à l'autre : la mémoire utilisée reste constante. On peut<br/>
aussi raisonner par quarts de l'image, en appliquant le même<br/>
traitement à chacun.</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>Ligne j, colonne i</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : échanger ligne et colonne revient à retourner l'image<br/>
autour de sa diagonale, ce qui n'est pas une rotation. Le pixel<br/>
1 resterait en [0][0].</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Ligne n - 1 - i, colonne n - 1 - j</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : cette formule fait tourner l'image d'un demi-tour. Le<br/>
pixel 1, en haut à gauche, arriverait en bas à droite.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Ligne n - 1 - j, colonne i</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : cette formule correspond au quart de tour dans le sens<br/>
inverse. Sur l'image [[1, 2, 3], [4, 5, 6], [7, 8, 9]], elle<br/>
envoie le pixel 1 en bas à gauche au lieu d'en haut à droite.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Ligne j, colonne n - 1 - i</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la première ligne devient la dernière colonne.<br/>
L'image [[1, 2, 3], [4, 5, 6], [7, 8, 9]] devient<br/>
[[7, 4, 1], [8, 5, 2], [9, 6, 3]] : le pixel 1, en [0][0],<br/>
arrive en [0][2].</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q20 : Découpage déséquilibré</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que se passe-t-il si le découpage en sous-problèmes est très<br/>
<strong>déséquilibré</strong> (par exemple, une moitié contenant 1<br/>
élément et l'autre n-1 éléments) ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>C'est pour cette raison qu'un algorithme « diviser pour<br/>
régner » cherche des sous-problèmes de tailles comparables :<br/>
le tri fusion coupe toujours au milieu, ce qui lui garantit<br/>
\log_2 n niveaux et un coût en O(n \log n) dans tous<br/>
les cas.</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>La complexité reste en O(n \log n)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la complexité O(n \log n) suppose un<br/>
découpage <strong>équilibré</strong> (en deux moitiés de même taille).<br/>
Un découpage déséquilibré dégrade fortement la<br/>
performance.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>L'algorithme ne termine pas</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : tant que le découpage diminue strictement la<br/>
taille du sous-problème, l'algorithme termine. Le<br/>
problème est la <strong>performance</strong>, pas la terminaison.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>La complexité reste O(n)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : un découpage déséquilibré ne réduit pas la<br/>
taille suffisamment vite pour rester en O(n).</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>La complexité dégénère à O(n²)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : avec ce découpage, on a n niveaux de<br/>
récursion (au lieu de \log n), chacun coûtant O(n).<br/>
Le total devient O(n²), comme pour un tri par insertion.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q22 : Profondeur de la pile en tri fusion</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Pour trier un tableau de 1\ 000 éléments par tri fusion<br/>
récursif, quelle est la <strong>profondeur maximale</strong> de la pile<br/>
d'appels ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>C'est une autre force du diviser pour régner avec<br/>
découpage équilibré : la profondeur logarithmique évite<br/>
tout problème de débordement de pile, même pour des<br/>
milliards d'éléments.</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>500</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : confusion possible avec « la moitié ». La<br/>
profondeur n'est pas n/2 mais bien \log n.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>1\ 000</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : on ne descend pas 1\ 000 niveaux. Le<br/>
découpage divise par deux à chaque niveau, donc la<br/>
profondeur croît comme \log n.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>1</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : un seul appel ne suffit pas à diviser<br/>
1\ 000 éléments jusqu'au cas de base.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>10</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : \log_2(1\ 000) \approx 10 (environ).<br/>
La pile d'appels reste donc très peu profonde, ce qui<br/>
évite les RecursionError même pour de grandes entrées.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q23 : Exponentiation modulaire</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Pour calculer a^n \mod m avec de très grands entiers<br/>
(cryptographie), la méthode efficace est :</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>L'exponentiation modulaire rapide est l'opération<br/>
fondamentale du chiffrement RSA. Elle permet de calculer<br/>
a^n \mod m pour des entiers de plusieurs milliers de<br/>
bits, en quelques millisecondes.</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>Utiliser un tri fusion appliqué aux chiffres décimaux du nombre</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : aucun rapport entre tri et exponentiation<br/>
modulaire.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Utiliser une recherche dichotomique sur les diviseurs de m</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la recherche dichotomique n'a aucun rapport<br/>
avec ce calcul.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Calculer aⁿ entièrement, puis prendre le modulo</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : pour a = 1024 et n = 10⁹, aⁿ a plus<br/>
d'un milliard de chiffres et n'est pas calculable en<br/>
pratique. Il faut prendre le modulo à chaque étape.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Appliquer l'exponentiation rapide en réduisant modulo m à chaque étape</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : (a \cdot b) \mod m = ((a \mod m) \cdot (b \mod m)) \mod m,<br/>
donc on peut réduire à chaque étape sans changer le<br/>
résultat final. Cela maintient les entiers<br/>
intermédiaires petits (&lt; m²), tout en bénéficiant<br/>
de la complexité O(\log n).</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q24 : Analyse d'un nouvel algorithme DPR</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>On invente un algorithme qui, pour un tableau de n<br/>
éléments, le découpe en <strong>trois tiers</strong>, traite chaque tiers<br/>
récursivement, puis fait un travail O(n) pour combiner.<br/>
Quelle est sa complexité ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Pour évaluer le coût d'un algorithme « diviser pour<br/>
régner », on compte le travail de chaque niveau d'appels et<br/>
le nombre de niveaux : ici O(n) par niveau sur environ<br/>
\log_3 n niveaux. C'est le même raisonnement que pour le<br/>
tri fusion.</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>O(n³)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : on découpe en trois, mais chaque sous-problème<br/>
fait 1/3 de la taille originale, pas n/2. Le<br/>
résultat reste O(n \log n).</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>O(n \log_3 n)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : chaque niveau d'appels traite en tout les<br/>
n éléments, donc coûte O(n), et la taille est divisée<br/>
par trois à chaque niveau, ce qui donne environ \log_3 n<br/>
niveaux. Comme \log_3 n et \log_2 n ne diffèrent que<br/>
d'un facteur constant, c'est un coût en O(n \log n).</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>O(n)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la combinaison à elle seule est en O(n), mais<br/>
il y a aussi \log_3 n niveaux à parcourir.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>O(3ⁿ)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la complexité exponentielle apparaît avec des<br/>
appels qui ne réduisent pas la taille. Ici, on divise<br/>
la taille à chaque étape.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q25 : Reconnaître un algorithme DPR</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Parmi les algorithmes suivants, lequel <strong>n'est pas</strong> un<br/>
algorithme diviser pour régner ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Pour identifier un DPR, chercher : (1) un découpage en<br/>
sous-problèmes plus petits de même nature, (2) une<br/>
résolution récursive, (3) une étape de combinaison. Le tri<br/>
par insertion ne fait pas de découpage récursif, donc ce<br/>
n'est pas un DPR.</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>Le tri par insertion</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : le tri par insertion ne divise pas le<br/>
problème. Il itère sur les éléments et place chacun à<br/>
sa place dans la portion déjà triée. C'est un<br/>
algorithme <strong>itératif</strong> classique, pas un DPR.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>L'exponentiation rapide</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est un DPR. On réduit l'exposant de moitié<br/>
à chaque appel.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>La recherche dichotomique</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est aussi un DPR. On divise l'intervalle de<br/>
recherche par deux à chaque étape.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Le tri fusion</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est un cas d'école du paradigme. On découpe<br/>
en deux moitiés, on trie chaque moitié récursivement,<br/>
on fusionne.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q26 : Code de l'exponentiation rapide</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Quel code Python implémente correctement<br/>
l'exponentiation rapide récursive de a à la<br/>
puissance n (avec n ≥ 0) ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Idée centrale : sauvegarder le résultat de<br/>
puissance(a, n // 2) dans une variable. Sans cette<br/>
mémorisation, l'algorithme dégénère en<br/>
exponentiation naïve. C'est l'illustration la plus<br/>
simple du diviser pour régner sur un seul<br/>
sous-problème.</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>python<br/>
def puissance(a, n):<br/>
    if n == 0:<br/>
        return 1<br/>
    return a * puissance(a, n - 1)<br/>
</code>`</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est l'exponentiation <strong>naïve</strong>, en<br/>
O(n) multiplications. Elle décrémente l'exposant<br/>
de 1 à chaque étape au lieu de le diviser par<br/>
deux. La question demandait l'exponentiation<br/>
<strong>rapide</strong>.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>`<code>python<br/>
def puissance(a, n):<br/>
    return a ** n<br/>
</code>`</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : on utilise l'opérateur Python intégré, ce<br/>
qui n'illustre pas le paradigme étudié. La question<br/>
portait sur l'écriture <strong>explicite</strong> de<br/>
l'exponentiation rapide.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>`<code>python<br/>
def puissance(a, n):<br/>
    if n == 0:<br/>
        return 1<br/>
    demi = puissance(a, n // 2)<br/>
    if n % 2 == 0:<br/>
        return demi <em> demi<br/>
    return a </em> demi * demi<br/>
</code>`</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : on calcule <strong>une seule fois</strong> la<br/>
puissance pour la moitié de l'exposant, puis on<br/>
multiplie ce résultat par lui-même (et par a<br/>
supplémentaire si n est impair). Complexité<br/>
O(\log n) multiplications.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>`<code>python<br/>
def puissance(a, n):<br/>
    if n == 0:<br/>
        return 1<br/>
    if n % 2 == 0:<br/>
        return puissance(a, n // 2) <em> puissance(a, n // 2)<br/>
    return a </em> puissance(a, n // 2) * puissance(a, n // 2)<br/>
</code>`</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : on calcule <strong>deux fois</strong> la même puissance<br/>
au lieu de la stocker dans une variable. La<br/>
complexité retombe à O(n), ce qui annule l'avantage<br/>
de l'exponentiation rapide. Bug classique du<br/>
débutant.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q27 : Somme d'un tableau par diviser pour régner</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>On veut calculer la somme des éléments de t compris entre les<br/>
indices debut et fin inclus, en coupant l'intervalle en deux :</p>
<p>`<code>python<br/>
def somme(t, debut, fin):<br/>
    if debut == fin:<br/>
        return t[debut]<br/>
    milieu = (debut + fin) // 2<br/>
    return ...<br/>
</code></p>
<p>Par quoi remplacer les points de suspension pour que<br/>
somme([4, 7, 1, 3], 0, 3) renvoie 15` ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Un découpage correct répartit les cases en deux intervalles<br/>
disjoints qui les couvrent toutes, chacun strictement plus petit<br/>
que l'intervalle de départ : la récursion atteint alors toujours<br/>
le cas de base debut == fin.</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>somme(t, debut, milieu) + somme(t, milieu + 1, fin) + t[milieu]</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la case milieu est déjà comptée dans la moitié<br/>
gauche. Elle est ajoutée une seconde fois à chaque découpage, et<br/>
l'appel renvoie 27.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>somme(t, debut, milieu) + somme(t, milieu, fin)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : les deux moitiés partagent la case milieu. Pour<br/>
somme(t, 0, 1), milieu vaut 0 et le second appel est de<br/>
nouveau somme(t, 0, 1) : la récursion ne s'arrête pas et Python<br/>
lève une RecursionError.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>t[milieu] + somme(t, milieu + 1, fin)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : les cases situées avant milieu ne sont jamais<br/>
additionnées. L'appel renvoie 11, soit 7 + 1 + 3 : la valeur<br/>
4 est perdue.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>somme(t, debut, milieu) + somme(t, milieu + 1, fin)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : les deux moitiés, de debut à milieu et de<br/>
milieu + 1 à fin, couvrent chaque case une seule fois et sont<br/>
strictement plus petites. On obtient 4 + 7 + 1 + 3 = 15.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q28 : DPR sans combinaison coûteuse</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>La recherche dichotomique satisfait la récurrence<br/>
T(n) = T(n/2) + O(1). Pourquoi obtient-on<br/>
O(\log n) et non O(n \log n) comme dans le tri<br/>
fusion ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Chaque appel de la dichotomie fait un nombre constant<br/>
d'opérations, et la taille de l'intervalle est<br/>
divisée par deux à chaque appel : il y a donc environ<br/>
\log_2 n appels. Le tri fusion, lui, traite les deux<br/>
moitiés et fusionne en O(n) : chacun de ses<br/>
\log_2 n niveaux coûte O(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>Parce que la recherche dichotomique fonctionne<br/>
uniquement sur des tableaux de taille puissance de<br/>
deux</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la recherche dichotomique fonctionne pour<br/>
toute taille. Cette propriété n'a aucun rapport<br/>
avec sa complexité.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Parce que la recherche dichotomique ne relève pas<br/>
du paradigme diviser pour régner</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : elle relève bien du paradigme. Elle<br/>
divise l'espace de recherche par deux à chaque<br/>
appel, illustration classique du DPR.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Parce qu'il n'y a qu'un seul sous-problème par<br/>
appel et que la combinaison est en temps constant</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : la dichotomie ne fait qu'<strong>un seul</strong><br/>
appel récursif (sur la moitié pertinente, au lieu<br/>
de deux) et la combinaison se résume à un test<br/>
d'égalité ou de comparaison, en O(1) au lieu de<br/>
O(n). On compte environ \log_2 n appels de coût<br/>
constant, d'où O(\log n). Au tri fusion, on a deux<br/>
appels et une fusion en O(n), ce qui donne<br/>
O(n \log n).</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Parce que les comparaisons entre éléments sont<br/>
gratuites en Python et ne comptent pas dans la<br/>
complexité</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : les comparaisons coûtent du temps comme<br/>
toute opération et comptent bien dans la<br/>
complexité. Mais elles sont en nombre constant à<br/>
chaque appel récursif, ce qui fait la différence<br/>
avec une fusion en O(n).</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q29 : Trace du tri fusion</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>On applique le tri fusion à la liste<br/>
[5, 2, 8, 3]. Quelles sont les listes<br/>
passées à la fusion finale (la dernière<br/>
étape, qui produit la liste triée<br/>
complète) ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Schéma global du tri fusion : une phase<br/>
descendante de découpage récursif (jusqu'aux<br/>
singletons), suivie d'une phase remontante<br/>
de fusions successives. Pour n = 4, la<br/>
structure d'appels forme un arbre binaire<br/>
complet de hauteur \log_2 4 = 2. À chaque<br/>
niveau, le coût total des fusions est en<br/>
O(n), d'où la complexité globale en<br/>
O(n \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>[5, 2] et [8, 3]</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ce sont les deux moitiés<br/>
obtenues après le <strong>premier</strong> découpage,<br/>
mais avant les tris récursifs. À la<br/>
fusion finale, ces moitiés ont déjà<br/>
été triées et sont devenues [2, 5]<br/>
et [3, 8].</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>[2, 3, 5, 8] et []</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la fusion combine deux<br/>
moitiés non vides. Une moitié vide<br/>
signifierait qu'on a fait un seul tri<br/>
récursif suivi d'une fusion sans<br/>
contrepartie, ce qui n'est pas le<br/>
tri fusion.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>[5], [2], [8], [3]</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : ce sont les listes singletons<br/>
obtenues à la fin du découpage. La<br/>
fusion finale ne combine que <strong>deux</strong><br/>
listes, pas quatre. Quatre singletons<br/>
impliqueraient deux fusions<br/>
intermédiaires avant la fusion finale.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>[2, 5] et [3, 8]</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : on découpe d'abord en<br/>
[5, 2] et [8, 3]. On trie<br/>
récursivement chaque moitié : [5, 2]<br/>
devient [2, 5] après fusion de [5]<br/>
et [2] ; [8, 3] devient [3, 8]<br/>
après fusion de [8] et [3]. La<br/>
fusion finale combine [2, 5] et<br/>
[3, 8] pour produire [2, 3, 5, 8].</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q30 : Code de la fonction de fusion</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Quelle fonction Python implémente<br/>
correctement la <strong>fusion</strong> de deux listes<br/>
déjà triées en une seule liste triée, en<br/>
tirant parti du tri préalable (temps<br/>
linéaire, sans retrier) ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Cette fonction est le cœur du tri fusion :<br/>
la qualité de l'algorithme global vient<br/>
de l'efficacité linéaire de la fusion.<br/>
Variante intéressante : implémenter la<br/>
fusion <strong>en place</strong> dans la liste<br/>
d'origine, ce qui économise de la<br/>
mémoire. C'est cependant plus délicat à<br/>
coder et n'apporte pas de gain en<br/>
complexité asymptotique.</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>python<br/>
def fusion(a, b):<br/>
    i, j = 0, 0<br/>
    resultat = []<br/>
    while i &lt; len(a) and j &lt; len(b):<br/>
        if a[i] &lt;= b[j]:<br/>
            resultat.append(a[i])<br/>
            i += 1<br/>
        else:<br/>
            resultat.append(b[j])<br/>
            j += 1<br/>
    resultat.extend(a[i:])<br/>
    resultat.extend(b[j:])<br/>
    return resultat<br/>
</code>`</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : on utilise deux indices<br/>
i et j pour parcourir les deux<br/>
listes en parallèle. À chaque tour, on<br/>
ajoute le plus petit des deux éléments<br/>
de tête, et on avance l'indice<br/>
correspondant. Quand l'une des listes<br/>
est épuisée, on copie simplement le<br/>
reste de l'autre. Complexité : O(n + m)<br/>
où n et m sont les longueurs des<br/>
deux listes.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>`<code>python<br/>
def fusion(a, b):<br/>
    i, j = 0, 0<br/>
    resultat = []<br/>
    while i &lt; len(a) and j &lt; len(b):<br/>
        if a[i] &lt;= b[j]:<br/>
            resultat.append(a[i])<br/>
            i += 1<br/>
        else:<br/>
            resultat.append(b[j])<br/>
            j += 1<br/>
    return resultat<br/>
</code>`</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la boucle s'arrête dès que<br/>
l'une des deux listes est épuisée, et<br/>
les éléments restants de l'autre liste<br/>
sont perdus. Avec a = [1, 4, 7] et<br/>
b = [2, 3], on obtient [1, 2, 3]<br/>
au lieu de [1, 2, 3, 4, 7]. Il faut<br/>
recopier la fin de la liste non<br/>
épuisée après la boucle.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>`<code>python<br/>
def fusion(a, b):<br/>
    return sorted(a + b)<br/>
</code>`</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Cette version fonctionne mais<br/>
n'illustre pas l'algorithme : on délègue<br/>
au tri intégré, qui ne tire pas parti<br/>
du fait que a et b sont déjà<br/>
triées. Complexité : O((n+m) \log(n+m))<br/>
au lieu de O(n + m).</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>`<code>python<br/>
def fusion(a, b):<br/>
    resultat = []<br/>
    for x in a:<br/>
        for y in b:<br/>
            if x &lt;= y:<br/>
                resultat.append(x)<br/>
            else:<br/>
                resultat.append(y)<br/>
    return resultat<br/>
</code>`</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la double boucle imbriquée a<br/>
une complexité O(n · m) au lieu<br/>
de O(n + m). De plus, on ajoute des<br/>
éléments en double (chaque élément de<br/>
a est comparé à chaque élément de<br/>
b, et chaque comparaison ajoute une<br/>
valeur). Le résultat n'est ni trié, ni<br/>
de la bonne taille.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q31 : Ligne récursive du tri fusion</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>On dispose d'une fonction fusion(a, b) qui fusionne deux listes<br/>
triées en une liste triée. On complète le tri fusion suivant :</p>
<p>`<code>python<br/>
def tri_fusion(t):<br/>
    if len(t) &lt;= 1:<br/>
        return t<br/>
    milieu = len(t) // 2<br/>
    gauche = [t[i] for i in range(milieu)]<br/>
    droite = [t[i] for i in range(milieu, len(t))]<br/>
    return ...<br/>
</code>`</p>
<p>Quelle expression remplace les points de suspension pour que la<br/>
fonction trie toute liste ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Le tri fusion suit les trois étapes de la méthode : diviser la<br/>
liste en deux moitiés, résoudre chaque moitié par un appel<br/>
récursif, puis combiner les deux résultats par une fusion. Les<br/>
appels portent sur des listes strictement plus courtes, ce qui<br/>
garantit d'atteindre le cas de base.</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>fusion(tri_fusion(gauche), tri_fusion(droite))</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : chaque moitié est d'abord triée par un appel<br/>
récursif sur une liste plus courte, puis les deux moitiés triées<br/>
sont fusionnées. [4, 1, 3, 2] donne [1, 2, 3, 4].</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>fusion(gauche, droite)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : fusion suppose deux listes déjà triées, or gauche et<br/>
droite ne le sont pas. Sur [4, 1, 3, 2], la fonction renvoie<br/>
[3, 2, 4, 1].</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>tri_fusion(fusion(gauche, droite))</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la liste passée à l'appel récursif a la même longueur<br/>
que t. Le problème ne rétrécit jamais, et Python finit par lever<br/>
une RecursionError.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>tri_fusion(gauche) + tri_fusion(droite)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : l'opérateur + met les deux listes bout à bout sans<br/>
les fusionner. À aucun niveau les valeurs ne sont comparées :<br/>
[4, 1, 3, 2] est renvoyée inchangée.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q32 : Tourner une image par diviser pour régner</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Une image carrée de n × n pixels, n<br/>
puissance de 2, doit être tournée d'un quart de<br/>
tour. Comment procède la méthode diviser pour<br/>
régner ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Diviser : quatre sous-images de côté n/2. Régner :<br/>
chacune est tournée par le même procédé. Combiner :<br/>
le quadrant haut-gauche va en haut à droite, le<br/>
haut-droit en bas à droite, et ainsi de suite. Le<br/>
programme cite cet exemple pour son coût en mémoire<br/>
constant.</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>Trier les lignes de l'image par leur luminosité avant de les réécrire en colonnes</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Un tri change le contenu de l'image ; une<br/>
rotation ne fait que déplacer les pixels.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Découper l'image en deux moitiés, les échanger, puis recommencer sur chaque moitié</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Échanger deux moitiés ne produit pas une rotation<br/>
d'un quart de tour ; il faut quatre quadrants.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Découper en quatre quadrants, tourner chacun récursivement, puis permuter les quadrants</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Chaque quadrant tourné prend la place de son<br/>
voisin dans le sens de la rotation ; une image<br/>
d'un pixel est le cas de base.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Tourner les pixels un par un, de la première ligne à la dernière, sans découpage</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>C'est une méthode directe par double boucle ;<br/>
elle n'exploite ni découpage ni récursivité.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q33 : Une rotation sans image supplémentaire</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Le programme de terminale présente la rotation d'une<br/>
image d'un quart de tour comme un exemple de diviser<br/>
pour régner « avec un coût en mémoire constant ».<br/>
Qu'est-ce que cela signifie ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Une solution naïve crée une seconde image<br/>
n × n et y recopie chaque pixel à sa nouvelle<br/>
position : mémoire doublée. La version diviser pour<br/>
régner permute les quadrants dans le tableau<br/>
d'origine, avec un seul pixel de secours pour les<br/>
échanges : le coût mémoire ne dépend pas de 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>La rotation ne nécessite aucune mémoire, les pixels étant lus sans être écrits</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Les pixels changent de place : ils sont bien<br/>
réécrits, mais dans le tableau d'origine.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Les pixels sont déplacés sur place, par échanges, sans construire une seconde image</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Permuter quatre quadrants revient à échanger des<br/>
pixels quatre par quatre ; seul un pixel<br/>
temporaire est nécessaire.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>L'image tournée occupe moins de mémoire que l'image de départ</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Une rotation conserve le nombre de pixels ; la<br/>
taille ne change pas.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>La récursivité est remplacée par une boucle pour économiser la pile d'appels</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>La méthode reste récursive ; le coût évoqué<br/>
concerne l'espace de travail : aucune copie de<br/>
l'image.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q34 : Le nombre de multiplications de l'exponentiation rapide</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Pour calculer x¹⁶ par élévations au carré successives, de x<br/>
à x², x⁴, et ainsi de suite, combien de multiplications<br/>
sont nécessaires ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>L'exponentiation rapide est un diviser pour régner : xⁿ se<br/>
déduit de x^{n/2} par une seule multiplication, d'où un coût<br/>
logarithmique.</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</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : 16 = 2⁴, et chaque élévation au carré<br/>
double l'exposant : 4 multiplications au lieu de 15.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>15</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 15 est le coût de la méthode naïve, qui multiplie<br/>
par x à chaque étape.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>1</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : une seule multiplication donne x², pas x¹⁶.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>8</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : diviser l'exposant par deux une seule fois ne suffit<br/>
pas ; on recommence jusqu'à 1.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q35 : L'appel récursif de la dichotomie</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Dans cette recherche dichotomique récursive, quelle ligne doit<br/>
remplacer le commentaire ?<br/>
`<code>python<br/>
def rech(t, x, g, d):<br/>
    if g &gt; d:<br/>
        return False<br/>
    m = (g + d) // 2<br/>
    if t[m] == x:<br/>
        return True<br/>
    if t[m] &lt; x:<br/>
        # ligne à compléter<br/>
    return rech(t, x, g, m - 1)<br/>
</code>`</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>La version récursive de la dichotomie fait un seul appel, sur la<br/>
moitié qui peut contenir x : c'est un diviser pour régner sans<br/>
étape de combinaison.</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>return rech(t, x, g, m - 1)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est l'appel de l'autre cas, quand t[m] est trop<br/>
grand.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>return rech(t, x, m + 1, d)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : si t[m] est trop petit, x ne peut être qu'à<br/>
droite de m, dans l'intervalle de m + 1 à d.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>return rech(t, x, g, d)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : l'intervalle ne change pas, la récursion ne<br/>
termine jamais.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>return rech(t, x, m, d)</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : garder m dans l'intervalle peut empêcher la<br/>
récursion de progresser quand m vaut g.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q36 : Les comparaisons d'une fusion</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>La fusion de deux listes triées compare leurs premiers éléments<br/>
restants et prend le plus petit, jusqu'à épuisement d'une des deux<br/>
listes ; le reste de l'autre est recopié sans comparaison. Combien<br/>
de comparaisons demande la fusion de [1, 4, 9] et [2, 3, 10] ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Une fusion coûte au plus n + m - 1 comparaisons pour deux listes<br/>
de tailles n et m : c'est ce coût linéaire qui donne au tri<br/>
fusion sa complexité en n \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="100" format="html">
    <text><![CDATA[<p>5</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : une comparaison par élément placé tant que les<br/>
deux listes sont non vides ; dès que l'une est vide, les<br/>
éléments restants sont recopiés sans comparer.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>6</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : 6 est le nombre total d'éléments ; les derniers<br/>
sont recopiés sans comparaison.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>4</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : recompte les comparaisons une par une, jusqu'à ce<br/>
qu'une liste soit vide.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>9</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : chaque élément n'est comparé qu'au premier de l'autre<br/>
liste, pas à tous.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q37 : Le tri fusion sur une liste déjà triée</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>Que vaut le coût du tri fusion sur une liste de n éléments déjà<br/>
triée ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Le tri fusion a un coût régulier, en n \log n dans tous les cas :<br/>
un avantage sur les mauvaises listes, un léger désavantage sur les<br/>
listes presque triées.</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>n, une seule passe de fusion suffisant</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : c'est le tri par insertion qui profite d'une liste<br/>
triée, pas le tri fusion.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>n², le pire cas étant alors atteint</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : le tri fusion n'a pas de cas quadratique.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>1, le tri détectant l'ordre dès le départ</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : aucune détection n'est prévue dans l'algorithme<br/>
classique.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>De l'ordre de n \log n, comme pour toute liste</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : le tri fusion ne regarde pas si la liste est<br/>
triée. Il découpe jusqu'aux listes d'un élément et fusionne à<br/>
chaque niveau, même si les fusions sont alors un peu moins<br/>
coûteuses.</p>]]></text>
    </feedback>
  </answer>
</question>

<question type="multichoice">
  <name>
    <text>Diviser pour régner — Q38 : Un diviser pour régner à un seul sous-problème</text>
  </name>
  <questiontext format="html">
    <text><![CDATA[<p>La recherche dichotomique divise la liste en deux moitiés mais ne<br/>
poursuit que dans l'une d'elles. Est-ce un diviser pour régner ?</p>]]></text>
  </questiontext>
  <generalfeedback format="html">
    <text><![CDATA[<p>Le nombre de sous-problèmes conservés détermine le coût : un seul<br/>
donne \log n, deux avec combinaison linéaire donne n \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>Oui, mais son coût est alors de l'ordre de n \log n</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : avec un seul sous-problème de taille moitié et un<br/>
travail constant, le coût est en \log n.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Non, car la dichotomie n'est pas récursive</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : la dichotomie s'écrit naturellement de façon récursive.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="100" format="html">
    <text><![CDATA[<p>Oui, avec un seul sous-problème et sans combinaison</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Bonne réponse : diviser, régner sur une moitié, et le résultat<br/>
de la moitié est le résultat global. C'est le cas le plus simple<br/>
du paradigme, avec un coût logarithmique.</p>]]></text>
    </feedback>
  </answer>
  <answer fraction="0" format="html">
    <text><![CDATA[<p>Non, un diviser pour régner doit traiter toutes les parties</p>]]></text>
    <feedback format="html">
      <text><![CDATA[<p>Erreur : rien n'impose de traiter chaque partie ; écarter une<br/>
moitié est précisément la source de l'efficacité.</p>]]></text>
    </feedback>
  </answer>
</question>

</quiz>
