{
  "chapter": {
    "id": "numeration-entiers",
    "level": "premiere",
    "theme": "Représentation des données",
    "title": "Numération et représentation des entiers",
    "description": "Systèmes de numération positionnels (binaire, décimal, hexadécimal),\nconversions entre bases, opérations sur les entiers naturels,\nreprésentation des entiers relatifs en complément à deux,\ndépassement de capacité, applications (couleurs, adresses mémoire).",
    "parties": [
      {
        "id": "bases",
        "title": "Bases et conversions"
      },
      {
        "id": "hexadecimal",
        "title": "Hexadécimal"
      },
      {
        "id": "complement",
        "title": "Entiers signés et complément à deux"
      },
      {
        "id": "limites",
        "title": "Dimensionnement et dépassement"
      }
    ],
    "prerequisites": [],
    "references": []
  },
  "questions": [
    {
      "id": "q01",
      "difficulty": 1,
      "skills": [
        "definition",
        "vocabulaire"
      ],
      "title": "Définition d'un bit",
      "partie": "bases",
      "statement": "Que désigne précisément le mot **bit** en informatique ?",
      "options": [
        {
          "text": "Un groupe de huit chiffres binaires",
          "correct": false,
          "feedback": "Erreur : un groupe de huit chiffres binaires s'appelle un\n**octet** (en anglais *byte*), pas un bit.\n"
        },
        {
          "text": "Une unité de mesure de la mémoire vive",
          "correct": false,
          "feedback": "Erreur : le bit est plutôt l'unité élémentaire d'information.\nLa mémoire vive se mesure en octets, kilo-octets,\ngiga-octets, etc.\n"
        },
        {
          "text": "Un chiffre binaire pouvant valoir $0$ ou $1$",
          "correct": true,
          "feedback": "Bonne réponse : « bit » est la contraction de\n*binary digit*. C'est l'unité élémentaire d'information,\nqui ne peut prendre que deux valeurs $0$ ou $1$.\n"
        },
        {
          "text": "Un nombre hexadécimal sur quatre chiffres",
          "correct": false,
          "feedback": "Erreur : un chiffre hexadécimal correspond à quatre bits,\nmais le bit lui-même est l'unité de base, pas un nombre\nhexadécimal.\n"
        }
      ],
      "explanation": "Le bit est l'unité élémentaire d'information en numérique.\nHuit bits forment un octet. Les capacités de stockage usuelles\nsont mesurées en octets, kilo-octets, méga-octets, etc."
    },
    {
      "id": "q02",
      "difficulty": 1,
      "skills": [
        "hexadecimal",
        "definition"
      ],
      "title": "Symboles du système hexadécimal",
      "partie": "hexadecimal",
      "statement": "Combien de symboles différents utilise le système hexadécimal\n(base $16$) ?",
      "options": [
        {
          "text": "$10$",
          "correct": false,
          "feedback": "Erreur : c'est le nombre de symboles du système décimal\n(base $10$). En hexadécimal, on a besoin de symboles\nsupplémentaires pour représenter $10, 11, \\ldots, 15$.\n"
        },
        {
          "text": "$16$",
          "correct": true,
          "feedback": "Bonne réponse : la base $16$ utilise $16$ symboles, à savoir\nles chiffres $0$ à $9$ pour les valeurs $0$ à $9$, puis les\nlettres A, B, C, D, E, F pour les valeurs $10$ à $15$.\n"
        },
        {
          "text": "$2$",
          "correct": false,
          "feedback": "Erreur : c'est le nombre de symboles de la base $2$ (le\nbinaire), pas de la base $16$.\n"
        },
        {
          "text": "$26$",
          "correct": false,
          "feedback": "Erreur : confusion possible avec le nombre de lettres de\nl'alphabet. L'hexadécimal utilise $10$ chiffres et $6$\nlettres, soit $16$ symboles au total.\n"
        }
      ],
      "explanation": "L'hexadécimal est très utilisé en informatique pour sa\ncompacité : un chiffre hexadécimal correspond à exactement\nquatre bits, soit la moitié d'un octet. Cela rend la lecture\ndes données binaires beaucoup plus aisée."
    },
    {
      "id": "q03",
      "difficulty": 1,
      "skills": [
        "conversion",
        "binaire-decimal"
      ],
      "title": "Conversion binaire vers décimal",
      "partie": "bases",
      "statement": "Que vaut $1011_2$ en base décimale ?",
      "options": [
        {
          "text": "$11$",
          "correct": true,
          "feedback": "Bonne réponse : $1011_2 = 1 \\cdot 8 + 0 \\cdot 4 + 1 \\cdot 2 + 1 \\cdot 1 = 11_{10}$.\n"
        },
        {
          "text": "$13$",
          "correct": false,
          "feedback": "Erreur : confusion possible avec $1101_2$. Bien lire les\nbits de gauche à droite et associer chacun à sa puissance\nde $2$.\n"
        },
        {
          "text": "$14$",
          "correct": false,
          "feedback": "Erreur : possible erreur de calcul ou décalage. Vérifier en\nadditionnant : $1011_2 = 8 + 2 + 1 = 11$.\n"
        },
        {
          "text": "$1011$",
          "correct": false,
          "feedback": "Erreur : ce serait la lecture comme un nombre décimal. Or\nen base $2$, chaque position a un poids différent\n(puissance de $2$, pas de $10$).\n"
        }
      ],
      "explanation": "Méthode : pour convertir un binaire en décimal, on associe à\nchaque bit une puissance de $2$ (en partant de la droite à\n$2^0$) et on additionne les puissances correspondant aux bits\nà $1$.",
      "variants": [
        {
          "statement": "Que vaut $1011_2$ en base décimale ?",
          "options": [
            {
              "text": "$11$",
              "correct": true,
              "feedback": "Bonne réponse : $1011_2 = 1 \\cdot 8 + 0 \\cdot 4 + 1 \\cdot 2 + 1 \\cdot 1 = 11_{10}$.\n"
            },
            {
              "text": "$13$",
              "correct": false,
              "feedback": "Erreur : confusion possible avec $1101_2$. Bien lire les\nbits de gauche à droite et associer chacun à sa puissance\nde $2$.\n"
            },
            {
              "text": "$14$",
              "correct": false,
              "feedback": "Erreur : possible erreur de calcul ou décalage. Vérifier en\nadditionnant : $1011_2 = 8 + 2 + 1 = 11$.\n"
            },
            {
              "text": "$1011$",
              "correct": false,
              "feedback": "Erreur : ce serait la lecture comme un nombre décimal. Or\nen base $2$, chaque position a un poids différent\n(puissance de $2$, pas de $10$).\n"
            }
          ],
          "explanation": "Méthode : pour convertir un binaire en décimal, on associe à\nchaque bit une puissance de $2$ (en partant de la droite à\n$2^0$) et on additionne les puissances correspondant aux bits\nà $1$."
        },
        {
          "statement": "Que vaut $1101_2$ en base décimale ?",
          "options": [
            {
              "text": "$13$",
              "correct": true,
              "feedback": "Bonne réponse : $1101_2 = 1 \\cdot 8 + 1 \\cdot 4 + 0 \\cdot 2 + 1 \\cdot 1 = 13_{10}$.\n"
            },
            {
              "text": "$11$",
              "correct": false,
              "feedback": "Erreur : confusion possible avec $1011_2$. Bien lire les\nbits de gauche à droite et associer chacun à sa puissance\nde $2$.\n"
            },
            {
              "text": "$16$",
              "correct": false,
              "feedback": "Erreur : possible erreur de calcul ou décalage. Vérifier en\nadditionnant : $1101_2 = 8 + 4 + 1 = 13$.\n"
            },
            {
              "text": "$1101$",
              "correct": false,
              "feedback": "Erreur : ce serait la lecture comme un nombre décimal. Or\nen base $2$, chaque position a un poids différent\n(puissance de $2$, pas de $10$).\n"
            }
          ],
          "explanation": "Méthode : pour convertir un binaire en décimal, on associe à\nchaque bit une puissance de $2$ (en partant de la droite à\n$2^0$) et on additionne les puissances correspondant aux bits\nà $1$."
        },
        {
          "statement": "Que vaut $1110_2$ en base décimale ?",
          "options": [
            {
              "text": "$14$",
              "correct": true,
              "feedback": "Bonne réponse : $1110_2 = 1 \\cdot 8 + 1 \\cdot 4 + 1 \\cdot 2 + 0 \\cdot 1 = 14_{10}$.\n"
            },
            {
              "text": "$7$",
              "correct": false,
              "feedback": "Erreur : confusion possible avec $0111_2$. Bien lire les\nbits de gauche à droite et associer chacun à sa puissance\nde $2$.\n"
            },
            {
              "text": "$17$",
              "correct": false,
              "feedback": "Erreur : possible erreur de calcul ou décalage. Vérifier en\nadditionnant : $1110_2 = 8 + 4 + 2 = 14$.\n"
            },
            {
              "text": "$1110$",
              "correct": false,
              "feedback": "Erreur : ce serait la lecture comme un nombre décimal. Or\nen base $2$, chaque position a un poids différent\n(puissance de $2$, pas de $10$).\n"
            }
          ],
          "explanation": "Méthode : pour convertir un binaire en décimal, on associe à\nchaque bit une puissance de $2$ (en partant de la droite à\n$2^0$) et on additionne les puissances correspondant aux bits\nà $1$."
        }
      ]
    },
    {
      "id": "q04",
      "difficulty": 1,
      "skills": [
        "conversion",
        "decimal-binaire"
      ],
      "title": "Conversion décimal vers binaire",
      "partie": "bases",
      "statement": "Quelle est l'écriture binaire (sur quatre bits) de l'entier\n$10$ ?",
      "options": [
        {
          "text": "$1010_2$",
          "correct": true,
          "feedback": "Bonne réponse : $10 = 8 + 2 = 1 \\cdot 2^3 + 0 \\cdot 2^2 + 1 \\cdot 2^1 + 0 \\cdot 2^0 = 1010_2$.\n"
        },
        {
          "text": "$0010_2$",
          "correct": false,
          "feedback": "Erreur : c'est $2_{10}$. Confusion possible entre la\nlecture de l'écriture décimale $10$ et la valeur binaire.\n"
        },
        {
          "text": "$1100_2$",
          "correct": false,
          "feedback": "Erreur : c'est $12_{10}$, pas $10$. Vérifier en\ndécomposant : $1100_2 = 8 + 4 = 12$.\n"
        },
        {
          "text": "$0101_2$",
          "correct": false,
          "feedback": "Erreur : c'est $5_{10}$, pas $10$. Tous les bits ont\nété inversés ($0$ et $1$ échangés).\n"
        }
      ],
      "explanation": "Méthode des divisions successives par $2$ : $10 = 5 \\times 2 + 0$, $5 = 2 \\times 2 + 1$, $2 = 1 \\times 2 + 0$, $1 = 0 \\times 2 + 1$.\nOn lit les restes de bas en haut : $1010_2$.",
      "variants": [
        {
          "statement": "Quelle est l'écriture binaire (sur quatre bits) de l'entier\n$10$ ?",
          "options": [
            {
              "text": "$1010_2$",
              "correct": true,
              "feedback": "Bonne réponse : $10 = 8 + 2 = 1 \\cdot 2^3 + 0 \\cdot 2^2 + 1 \\cdot 2^1 + 0 \\cdot 2^0 = 1010_2$.\n"
            },
            {
              "text": "$0010_2$",
              "correct": false,
              "feedback": "Erreur : c'est $2_{10}$. Confusion possible entre la\nlecture de l'écriture décimale $10$ et la valeur binaire.\n"
            },
            {
              "text": "$1100_2$",
              "correct": false,
              "feedback": "Erreur : c'est $12_{10}$, pas $10$. Vérifier en\ndécomposant : $1100_2 = 8 + 4 = 12$.\n"
            },
            {
              "text": "$0101_2$",
              "correct": false,
              "feedback": "Erreur : c'est $5_{10}$, pas $10$. Tous les bits ont\nété inversés ($0$ et $1$ échangés).\n"
            }
          ],
          "explanation": "Méthode des divisions successives par $2$ : $10 = 5 \\times 2 + 0$, $5 = 2 \\times 2 + 1$, $2 = 1 \\times 2 + 0$, $1 = 0 \\times 2 + 1$.\nOn lit les restes de bas en haut : $1010_2$."
        },
        {
          "statement": "Quelle est l'écriture binaire (sur quatre bits) de l'entier\n$11$ ?",
          "options": [
            {
              "text": "$1011_2$",
              "correct": true,
              "feedback": "Bonne réponse : $11 = 8 + 2 + 1 = 1 \\cdot 2^3 + 0 \\cdot 2^2 + 1 \\cdot 2^1 + 1 \\cdot 2^0 = 1011_2$.\n"
            },
            {
              "text": "$0011_2$",
              "correct": false,
              "feedback": "Erreur : c'est $3_{10}$. Confusion possible entre la\nlecture de l'écriture décimale $11$ et la valeur binaire.\n"
            },
            {
              "text": "$1101_2$",
              "correct": false,
              "feedback": "Erreur : c'est $13_{10}$, pas $11$. Vérifier en\ndécomposant : $1101_2 = 8 + 4 + 1 = 13$.\n"
            },
            {
              "text": "$0100_2$",
              "correct": false,
              "feedback": "Erreur : c'est $4_{10}$, pas $11$. Tous les bits ont\nété inversés ($0$ et $1$ échangés).\n"
            }
          ],
          "explanation": "Méthode des divisions successives par $2$ : $11 = 5 \\times 2 + 1$, $5 = 2 \\times 2 + 1$, $2 = 1 \\times 2 + 0$, $1 = 0 \\times 2 + 1$.\nOn lit les restes de bas en haut : $1011_2$."
        }
      ]
    },
    {
      "id": "q05",
      "difficulty": 1,
      "skills": [
        "definition",
        "octet"
      ],
      "title": "Composition d'un octet",
      "partie": "bases",
      "statement": "Combien de bits contient un octet ?",
      "options": [
        {
          "text": "$4$",
          "correct": false,
          "feedback": "Erreur : $4$ bits forment un demi-octet (parfois appelé\n*quartet* ou *nibble*), équivalent à un chiffre hexadécimal.\n"
        },
        {
          "text": "$8$",
          "correct": true,
          "feedback": "Bonne réponse : un octet (en anglais *byte*) est un groupe\nde huit bits. Il peut représenter $2^8 = 256$ valeurs\ndifférentes.\n"
        },
        {
          "text": "$1$",
          "correct": false,
          "feedback": "Erreur : un seul bit ne forme pas un octet. Un bit est\nl'unité élémentaire d'information.\n"
        },
        {
          "text": "$16$",
          "correct": false,
          "feedback": "Erreur : $16$ bits forment deux octets, l'une des\ntailles courantes des entiers avec $8$, $32$ et $64$ bits.\n"
        }
      ],
      "explanation": "Le nom *octet* renvoie directement à « huit ». Le mot anglais\n*byte* est utilisé dans la plupart des langages de\nprogrammation."
    },
    {
      "id": "q06",
      "difficulty": 1,
      "skills": [
        "intervalle",
        "octet"
      ],
      "title": "Plus grand entier naturel sur un octet",
      "partie": "limites",
      "statement": "Quel est le plus grand entier naturel que l'on peut représenter\nsur un octet (huit bits) ?",
      "options": [
        {
          "text": "$128$",
          "correct": false,
          "feedback": "Erreur : $128$ est le seuil entre nombres positifs et\nnégatifs en complément à deux, mais ce n'est pas le\nmaximum d'un entier naturel sur un octet.\n"
        },
        {
          "text": "$255$",
          "correct": true,
          "feedback": "Bonne réponse : sur huit bits, on peut coder les entiers\nnaturels de $0$ à $2^8 - 1 = 255$. Le maximum correspond à\n$11111111_2$.\n"
        },
        {
          "text": "$511$",
          "correct": false,
          "feedback": "Erreur : $511 = 2^9 - 1$ est le maximum sur **neuf** bits,\npas huit.\n"
        },
        {
          "text": "$256$",
          "correct": false,
          "feedback": "Erreur : un octet permet $256$ valeurs **différentes** (de\n$0$ à $255$), mais pas la valeur $256$ elle-même.\n"
        }
      ],
      "explanation": "Sur $n$ bits, on peut coder $2^n$ valeurs différentes, soit les\nentiers naturels de $0$ à $2^n - 1$. Pour $n = 8$, c'est de $0$\nà $255$."
    },
    {
      "id": "q07",
      "difficulty": 1,
      "skills": [
        "python",
        "prefixes"
      ],
      "title": "Préfixes des bases en Python",
      "partie": "hexadecimal",
      "statement": "En Python, quel préfixe utilise-t-on pour écrire un littéral\nhexadécimal ?",
      "options": [
        {
          "text": "`0o`",
          "correct": false,
          "feedback": "Erreur : `0o` est le préfixe pour l'**octal** (base $8$),\nrarement utilisé.\n"
        },
        {
          "text": "`0b`",
          "correct": false,
          "feedback": "Erreur : `0b` est le préfixe pour le **binaire** (par\nexemple `0b101 == 5`).\n"
        },
        {
          "text": "`0h`",
          "correct": false,
          "feedback": "Erreur : `0h` n'est pas un préfixe valide en Python. Cela\nprovoquerait une erreur de syntaxe.\n"
        },
        {
          "text": "`0x`",
          "correct": true,
          "feedback": "Bonne réponse : `0x` introduit un littéral hexadécimal.\nPar exemple `0xFF == 255`.\n"
        }
      ],
      "explanation": "Python accepte trois préfixes : `0b` (binaire), `0o` (octal) et\n`0x` (hexadécimal). On peut aussi utiliser `int(\"FF\", 16)` pour\nconvertir une chaîne en entier dans une base donnée."
    },
    {
      "id": "q08",
      "difficulty": 1,
      "skills": [
        "hexadecimal",
        "regroupement"
      ],
      "title": "Bits par chiffre hexadécimal",
      "partie": "hexadecimal",
      "statement": "Combien de bits sont nécessaires pour coder un chiffre\nhexadécimal ?",
      "options": [
        {
          "text": "$8$",
          "correct": false,
          "feedback": "Erreur : huit bits forment un octet, ce qui correspond à\n**deux** chiffres hexadécimaux (de $00$ à $FF$).\n"
        },
        {
          "text": "$1$",
          "correct": false,
          "feedback": "Erreur : un seul bit ne permet de coder que deux valeurs\n($0$ et $1$). Or l'hexadécimal nécessite seize valeurs.\n"
        },
        {
          "text": "$4$",
          "correct": true,
          "feedback": "Bonne réponse : $2^4 = 16$, donc quatre bits suffisent à\ncoder les seize valeurs hexadécimales. C'est ce qui rend\nla conversion entre hexadécimal et binaire si simple.\n"
        },
        {
          "text": "$16$",
          "correct": false,
          "feedback": "Erreur : confusion entre la base ($16$ symboles) et le\nnombre de bits requis. $4$ bits suffisent puisque\n$2^4 = 16$.\n"
        }
      ],
      "explanation": "Cette correspondance exacte (un chiffre hexa = quatre bits) est\ntrès pratique : pour convertir entre binaire et hexadécimal,\non regroupe simplement les bits par paquets de quatre, sans\ncalcul."
    },
    {
      "id": "q09",
      "difficulty": 1,
      "skills": [
        "hexadecimal",
        "symbole"
      ],
      "title": "Lecture d'un chiffre hexadécimal",
      "partie": "hexadecimal",
      "statement": "Quelle est la valeur décimale de la lettre $C$ utilisée comme\nchiffre hexadécimal ?",
      "options": [
        {
          "text": "$13$",
          "correct": false,
          "feedback": "Erreur : $13$ correspond à la lettre $D$. La lettre $C$\nvient juste avant, donc vaut $12$.\n"
        },
        {
          "text": "$12$",
          "correct": true,
          "feedback": "Bonne réponse : les lettres A, B, C, D, E, F valent\nrespectivement $10, 11, 12, 13, 14, 15$.\n"
        },
        {
          "text": "$11$",
          "correct": false,
          "feedback": "Erreur : $11$ correspond à la lettre $B$. La lettre $C$\nvient juste après, donc vaut $12$.\n"
        },
        {
          "text": "$3$",
          "correct": false,
          "feedback": "Erreur : confusion possible avec la position de C dans\nl'alphabet. En hexadécimal, A vaut $10$, B vaut $11$, C\nvaut $12$, etc.\n"
        }
      ],
      "explanation": "Mémo : A vaut $10$ et chaque lettre suivante incrémente\nd'une unité, jusqu'à F qui vaut $15$."
    },
    {
      "id": "q10",
      "difficulty": 1,
      "skills": [
        "definition",
        "poids-fort"
      ],
      "title": "Bit de poids fort",
      "partie": "bases",
      "statement": "Que désigne le **bit de poids fort** dans la représentation\nbinaire d'un nombre ?",
      "options": [
        {
          "text": "Le bit le plus à gauche dans l'écriture du nombre",
          "correct": true,
          "feedback": "Bonne réponse : sur $n$ bits, le bit de poids fort est en\nposition $n-1$, avec un poids de $2^{n-1}$, la plus\ngrande puissance de $2$ de l'écriture.\n"
        },
        {
          "text": "Le bit le plus à droite dans l'écriture du nombre (poids $2^0$)",
          "correct": false,
          "feedback": "Erreur : c'est le bit de poids **faible**. Le bit de poids\nfort est au contraire celui dont la position a la plus\ngrande valeur.\n"
        },
        {
          "text": "Le bit qui change le plus souvent quand on incrémente le nombre",
          "correct": false,
          "feedback": "Erreur : c'est au contraire le bit de poids **faible** qui\nchange à chaque incrément. Le bit de poids fort change le\nmoins souvent.\n"
        },
        {
          "text": "Le bit qui vaut systématiquement $1$ dans tout nombre binaire",
          "correct": false,
          "feedback": "Erreur : un bit de poids fort peut valoir $0$ ou $1$,\ncomme tout autre bit.\n"
        }
      ],
      "explanation": "En complément à deux, le bit de poids fort joue un rôle\nparticulier : il indique le signe ($0$ pour positif, $1$ pour\nnégatif)."
    },
    {
      "id": "q11",
      "difficulty": 2,
      "skills": [
        "conversion",
        "binaire-decimal"
      ],
      "title": "Conversion binaire vers décimal sur huit bits",
      "partie": "bases",
      "statement": "Que vaut $01001101_2$ en base décimale ?",
      "options": [
        {
          "text": "$74$",
          "correct": false,
          "feedback": "Erreur de calcul : vérifier les puissances de $2$ associées\naux bits à $1$. On doit avoir $2^6 + 2^3 + 2^2 + 2^0$.\n"
        },
        {
          "text": "$77$",
          "correct": true,
          "feedback": "Bonne réponse : $01001101_2 = 64 + 8 + 4 + 1 = 77_{10}$.\nLes bits à $1$ sont aux positions $6, 3, 2, 0$.\n"
        },
        {
          "text": "$93$",
          "correct": false,
          "feedback": "Erreur : c'est $01011101_2$. Lire attentivement les bits.\n"
        },
        {
          "text": "$109$",
          "correct": false,
          "feedback": "Erreur : c'est $01101101_2$, pas $01001101_2$. Bien\nidentifier la position de chaque bit à $1$.\n"
        }
      ],
      "explanation": "Astuce : pour les conversions sur huit bits, mémoriser les\npuissances de $2$ jusqu'à $2^7 = 128$. La somme des bits à $1$\ndonne directement la valeur décimale.",
      "variants": [
        {
          "statement": "Que vaut $01001101_2$ en base décimale ?",
          "options": [
            {
              "text": "$74$",
              "correct": false,
              "feedback": "Erreur de calcul : vérifier les puissances de $2$ associées\naux bits à $1$. On doit avoir $2^6 + 2^3 + 2^2 + 2^0$.\n"
            },
            {
              "text": "$77$",
              "correct": true,
              "feedback": "Bonne réponse : $01001101_2 = 64 + 8 + 4 + 1 = 77_{10}$.\nLes bits à $1$ sont aux positions $6, 3, 2, 0$.\n"
            },
            {
              "text": "$93$",
              "correct": false,
              "feedback": "Erreur : c'est $01011101_2$. Lire attentivement les bits.\n"
            },
            {
              "text": "$109$",
              "correct": false,
              "feedback": "Erreur : c'est $01101101_2$, pas $01001101_2$. Bien\nidentifier la position de chaque bit à $1$.\n"
            }
          ],
          "explanation": "Astuce : pour les conversions sur huit bits, mémoriser les\npuissances de $2$ jusqu'à $2^7 = 128$. La somme des bits à $1$\ndonne directement la valeur décimale."
        },
        {
          "statement": "Que vaut $01100101_2$ en base décimale ?",
          "options": [
            {
              "text": "$98$",
              "correct": false,
              "feedback": "Erreur de calcul : vérifier les puissances de $2$ associées\naux bits à $1$. On doit avoir $2^6 + 2^5 + 2^2 + 2^0$.\n"
            },
            {
              "text": "$101$",
              "correct": true,
              "feedback": "Bonne réponse : $01100101_2 = 64 + 32 + 4 + 1 = 101_{10}$.\nLes bits à $1$ sont aux positions $6, 5, 2, 0$.\n"
            },
            {
              "text": "$117$",
              "correct": false,
              "feedback": "Erreur : c'est $01110101_2$. Lire attentivement les bits.\n"
            },
            {
              "text": "$133$",
              "correct": false,
              "feedback": "Erreur : c'est $10000101_2$, pas $01100101_2$. Bien\nidentifier la position de chaque bit à $1$.\n"
            }
          ],
          "explanation": "Astuce : pour les conversions sur huit bits, mémoriser les\npuissances de $2$ jusqu'à $2^7 = 128$. La somme des bits à $1$\ndonne directement la valeur décimale."
        },
        {
          "statement": "Que vaut $00110110_2$ en base décimale ?",
          "options": [
            {
              "text": "$51$",
              "correct": false,
              "feedback": "Erreur de calcul : vérifier les puissances de $2$ associées\naux bits à $1$. On doit avoir $2^5 + 2^4 + 2^2 + 2^1$.\n"
            },
            {
              "text": "$54$",
              "correct": true,
              "feedback": "Bonne réponse : $00110110_2 = 32 + 16 + 4 + 2 = 54_{10}$.\nLes bits à $1$ sont aux positions $5, 4, 2, 1$.\n"
            },
            {
              "text": "$70$",
              "correct": false,
              "feedback": "Erreur : c'est $01000110_2$. Lire attentivement les bits.\n"
            },
            {
              "text": "$86$",
              "correct": false,
              "feedback": "Erreur : c'est $01010110_2$, pas $00110110_2$. Bien\nidentifier la position de chaque bit à $1$.\n"
            }
          ],
          "explanation": "Astuce : pour les conversions sur huit bits, mémoriser les\npuissances de $2$ jusqu'à $2^7 = 128$. La somme des bits à $1$\ndonne directement la valeur décimale."
        }
      ]
    },
    {
      "id": "q12",
      "difficulty": 2,
      "skills": [
        "conversion",
        "hexadecimal-binaire"
      ],
      "title": "Conversion hexadécimal vers binaire",
      "partie": "bases",
      "statement": "Quelle est l'écriture binaire de $A3F_{16}$ ?",
      "options": [
        {
          "text": "$1010111111_2$",
          "correct": false,
          "feedback": "Erreur : il manque $2$ bits. Chaque chiffre\nhexadécimal doit être codé sur exactement quatre bits, en\ncomplétant par des zéros à gauche si nécessaire.\n"
        },
        {
          "text": "$101001000000_2$",
          "correct": false,
          "feedback": "Erreur : c'est l'écriture de $A40_{16}$, le dernier\nquartet est faux. Convertir chaque chiffre séparément,\nsans retenue d'un quartet à l'autre.\n"
        },
        {
          "text": "$101000111111_2$",
          "correct": true,
          "feedback": "Bonne réponse : $A \\to 1010, 3 \\to 0011, F \\to 1111$.\nMis bout à bout : $1010\\ 0011\\ 1111_2$.\n"
        },
        {
          "text": "$111100111010_2$",
          "correct": false,
          "feedback": "Erreur : c'est la conversion de $F3A_{16}$, les chiffres\nhexadécimaux ont été lus dans le mauvais ordre. Lire de\ngauche à droite : A puis 3 puis F.\n"
        }
      ],
      "explanation": "Un chiffre hexa = quatre bits. La conversion est purement\nmécanique : il suffit de remplacer chaque chiffre hexa par les\nquatre bits correspondants, dans l'ordre.",
      "variants": [
        {
          "statement": "Quelle est l'écriture binaire de $A3F_{16}$ ?",
          "options": [
            {
              "text": "$1010111111_2$",
              "correct": false,
              "feedback": "Erreur : il manque $2$ bits. Chaque chiffre\nhexadécimal doit être codé sur exactement quatre bits, en\ncomplétant par des zéros à gauche si nécessaire.\n"
            },
            {
              "text": "$101001000000_2$",
              "correct": false,
              "feedback": "Erreur : c'est l'écriture de $A40_{16}$, le dernier\nquartet est faux. Convertir chaque chiffre séparément,\nsans retenue d'un quartet à l'autre.\n"
            },
            {
              "text": "$101000111111_2$",
              "correct": true,
              "feedback": "Bonne réponse : $A \\to 1010, 3 \\to 0011, F \\to 1111$.\nMis bout à bout : $1010\\ 0011\\ 1111_2$.\n"
            },
            {
              "text": "$111100111010_2$",
              "correct": false,
              "feedback": "Erreur : c'est la conversion de $F3A_{16}$, les chiffres\nhexadécimaux ont été lus dans le mauvais ordre. Lire de\ngauche à droite : A puis 3 puis F.\n"
            }
          ],
          "explanation": "Un chiffre hexa = quatre bits. La conversion est purement\nmécanique : il suffit de remplacer chaque chiffre hexa par les\nquatre bits correspondants, dans l'ordre."
        },
        {
          "statement": "Quelle est l'écriture binaire de $7C2_{16}$ ?",
          "options": [
            {
              "text": "$111110010_2$",
              "correct": false,
              "feedback": "Erreur : il manque $3$ bits. Chaque chiffre\nhexadécimal doit être codé sur exactement quatre bits, en\ncomplétant par des zéros à gauche si nécessaire.\n"
            },
            {
              "text": "$011111000011_2$",
              "correct": false,
              "feedback": "Erreur : c'est l'écriture de $7C3_{16}$, le dernier\nquartet est faux. Convertir chaque chiffre séparément,\nsans retenue d'un quartet à l'autre.\n"
            },
            {
              "text": "$011111000010_2$",
              "correct": true,
              "feedback": "Bonne réponse : $7 \\to 0111, C \\to 1100, 2 \\to 0010$.\nMis bout à bout : $0111\\ 1100\\ 0010_2$.\n"
            },
            {
              "text": "$001011000111_2$",
              "correct": false,
              "feedback": "Erreur : c'est la conversion de $2C7_{16}$, les chiffres\nhexadécimaux ont été lus dans le mauvais ordre. Lire de\ngauche à droite : 7 puis C puis 2.\n"
            }
          ],
          "explanation": "Un chiffre hexa = quatre bits. La conversion est purement\nmécanique : il suffit de remplacer chaque chiffre hexa par les\nquatre bits correspondants, dans l'ordre."
        },
        {
          "statement": "Quelle est l'écriture binaire de $B1E_{16}$ ?",
          "options": [
            {
              "text": "$101111110_2$",
              "correct": false,
              "feedback": "Erreur : il manque $3$ bits. Chaque chiffre\nhexadécimal doit être codé sur exactement quatre bits, en\ncomplétant par des zéros à gauche si nécessaire.\n"
            },
            {
              "text": "$101100011111_2$",
              "correct": false,
              "feedback": "Erreur : c'est l'écriture de $B1F_{16}$, le dernier\nquartet est faux. Convertir chaque chiffre séparément,\nsans retenue d'un quartet à l'autre.\n"
            },
            {
              "text": "$101100011110_2$",
              "correct": true,
              "feedback": "Bonne réponse : $B \\to 1011, 1 \\to 0001, E \\to 1110$.\nMis bout à bout : $1011\\ 0001\\ 1110_2$.\n"
            },
            {
              "text": "$111000011011_2$",
              "correct": false,
              "feedback": "Erreur : c'est la conversion de $E1B_{16}$, les chiffres\nhexadécimaux ont été lus dans le mauvais ordre. Lire de\ngauche à droite : B puis 1 puis E.\n"
            }
          ],
          "explanation": "Un chiffre hexa = quatre bits. La conversion est purement\nmécanique : il suffit de remplacer chaque chiffre hexa par les\nquatre bits correspondants, dans l'ordre."
        }
      ]
    },
    {
      "id": "q13",
      "difficulty": 2,
      "skills": [
        "addition-binaire"
      ],
      "title": "Addition binaire avec retenue",
      "partie": "bases",
      "statement": "Que vaut $1011_2 + 0110_2$ ? Les opérandes sont codés sur\nquatre bits ; donnez le résultat complet de l'addition posée.",
      "options": [
        {
          "text": "$0001_2$",
          "correct": false,
          "feedback": "Erreur : la retenue finale a été perdue. La somme dépasse\nquatre bits, le résultat complet en compte cinq.\n"
        },
        {
          "text": "$1101_2$",
          "correct": false,
          "feedback": "Erreur : confusion possible avec un XOR (différence) au\nlieu d'une addition.\n"
        },
        {
          "text": "$1111_2$",
          "correct": false,
          "feedback": "Erreur : confusion possible entre OU logique et addition.\nL'addition propage des retenues, contrairement au OU.\n"
        },
        {
          "text": "$10001_2$",
          "correct": true,
          "feedback": "Bonne réponse : $1011 + 0110 = 10001_2$ (en posant l'addition\ncolonne par colonne, avec retenues). Vérification :\n$11 + 6 = 17 = 16 + 1 = 10001_2$.\n"
        }
      ],
      "explanation": "L'addition binaire suit les mêmes règles que l'addition\ndécimale, avec retenues : $0+0 = 0$, $0+1 = 1$, $1+1 = 10$\n(retenue), $1+1+1 = 11$ (retenue). Si le résultat sort de\nl'intervalle de codage, on parle de dépassement.",
      "variants": [
        {
          "statement": "Que vaut $1011_2 + 0110_2$ ? Les opérandes sont codés sur\nquatre bits ; donnez le résultat complet de l'addition posée.",
          "options": [
            {
              "text": "$0001_2$",
              "correct": false,
              "feedback": "Erreur : la retenue finale a été perdue. La somme dépasse\nquatre bits, le résultat complet en compte cinq.\n"
            },
            {
              "text": "$1101_2$",
              "correct": false,
              "feedback": "Erreur : confusion possible avec un XOR (différence) au\nlieu d'une addition.\n"
            },
            {
              "text": "$1111_2$",
              "correct": false,
              "feedback": "Erreur : confusion possible entre OU logique et addition.\nL'addition propage des retenues, contrairement au OU.\n"
            },
            {
              "text": "$10001_2$",
              "correct": true,
              "feedback": "Bonne réponse : $1011 + 0110 = 10001_2$ (en posant l'addition\ncolonne par colonne, avec retenues). Vérification :\n$11 + 6 = 17 = 16 + 1 = 10001_2$.\n"
            }
          ],
          "explanation": "L'addition binaire suit les mêmes règles que l'addition\ndécimale, avec retenues : $0+0 = 0$, $0+1 = 1$, $1+1 = 10$\n(retenue), $1+1+1 = 11$ (retenue). Si le résultat sort de\nl'intervalle de codage, on parle de dépassement."
        },
        {
          "statement": "Que vaut $1101_2 + 0111_2$ ? Les opérandes sont codés sur\nquatre bits ; donnez le résultat complet de l'addition posée.",
          "options": [
            {
              "text": "$0100_2$",
              "correct": false,
              "feedback": "Erreur : la retenue finale a été perdue. La somme dépasse\nquatre bits, le résultat complet en compte cinq.\n"
            },
            {
              "text": "$1010_2$",
              "correct": false,
              "feedback": "Erreur : confusion possible avec un XOR (différence) au\nlieu d'une addition.\n"
            },
            {
              "text": "$1111_2$",
              "correct": false,
              "feedback": "Erreur : confusion possible entre OU logique et addition.\nL'addition propage des retenues, contrairement au OU.\n"
            },
            {
              "text": "$10100_2$",
              "correct": true,
              "feedback": "Bonne réponse : $1101 + 0111 = 10100_2$ (en posant l'addition\ncolonne par colonne, avec retenues). Vérification :\n$13 + 7 = 20 = 16 + 4 = 10100_2$.\n"
            }
          ],
          "explanation": "L'addition binaire suit les mêmes règles que l'addition\ndécimale, avec retenues : $0+0 = 0$, $0+1 = 1$, $1+1 = 10$\n(retenue), $1+1+1 = 11$ (retenue). Si le résultat sort de\nl'intervalle de codage, on parle de dépassement."
        },
        {
          "statement": "Que vaut $1001_2 + 1101_2$ ? Les opérandes sont codés sur\nquatre bits ; donnez le résultat complet de l'addition posée.",
          "options": [
            {
              "text": "$0110_2$",
              "correct": false,
              "feedback": "Erreur : la retenue finale a été perdue. La somme dépasse\nquatre bits, le résultat complet en compte cinq.\n"
            },
            {
              "text": "$0100_2$",
              "correct": false,
              "feedback": "Erreur : confusion possible avec un XOR (différence) au\nlieu d'une addition.\n"
            },
            {
              "text": "$1101_2$",
              "correct": false,
              "feedback": "Erreur : confusion possible entre OU logique et addition.\nL'addition propage des retenues, contrairement au OU.\n"
            },
            {
              "text": "$10110_2$",
              "correct": true,
              "feedback": "Bonne réponse : $1001 + 1101 = 10110_2$ (en posant l'addition\ncolonne par colonne, avec retenues). Vérification :\n$9 + 13 = 22 = 16 + 6 = 10110_2$.\n"
            }
          ],
          "explanation": "L'addition binaire suit les mêmes règles que l'addition\ndécimale, avec retenues : $0+0 = 0$, $0+1 = 1$, $1+1 = 10$\n(retenue), $1+1+1 = 11$ (retenue). Si le résultat sort de\nl'intervalle de codage, on parle de dépassement."
        }
      ]
    },
    {
      "id": "q14",
      "difficulty": 2,
      "skills": [
        "intervalle",
        "complement-deux"
      ],
      "title": "Intervalle de codage en complément à deux",
      "partie": "limites",
      "statement": "Sur huit bits en complément à deux, quel est l'intervalle des\nentiers relatifs codables ?",
      "options": [
        {
          "text": "$[-128\\,;\\, 127]$",
          "correct": true,
          "feedback": "Bonne réponse : sur $n = 8$ bits, l'intervalle est\n$[-2^{n-1}\\,;\\, 2^{n-1} - 1] = [-128\\,;\\, 127]$.\n"
        },
        {
          "text": "$[-128\\,;\\, 128]$",
          "correct": false,
          "feedback": "Erreur : la valeur $128$ ne peut pas être codée car\n$10000000_2$ vaut $-128$ en complément à deux.\n"
        },
        {
          "text": "$[-127\\,;\\, 127]$",
          "correct": false,
          "feedback": "Erreur : il y a un négatif de plus que de positifs. La\nplus petite valeur est $-128$, pas $-127$.\n"
        },
        {
          "text": "$[0\\,;\\, 255]$",
          "correct": false,
          "feedback": "Erreur : c'est l'intervalle des entiers **naturels**\n(non signés) sur huit bits.\n"
        }
      ],
      "explanation": "Sur $n$ bits en complément à deux, l'intervalle est\n$[-2^{n-1}\\,;\\, 2^{n-1} - 1]$. La dissymétrie (un négatif de\nplus) vient du fait que $0$ est compté côté positif."
    },
    {
      "id": "q15",
      "difficulty": 2,
      "skills": [
        "complement-deux",
        "calcul"
      ],
      "title": "Calcul du complément à deux",
      "partie": "complement",
      "statement": "Quelle est la représentation binaire de $-19$ sur huit bits, en\ncomplément à deux ?",
      "options": [
        {
          "text": "$11101101$",
          "correct": true,
          "feedback": "Bonne réponse : étape par étape, $19 = 00010011$, on\ninverse → $11101100$, on ajoute $1$ → $11101101$.\n"
        },
        {
          "text": "$11101100$",
          "correct": false,
          "feedback": "Erreur : c'est le complément à un (inversion des bits)\nmais on a oublié l'étape finale d'ajouter $1$.\n"
        },
        {
          "text": "$11101110$",
          "correct": false,
          "feedback": "Erreur : on a ajouté $2$ au lieu de $1$ après inversion,\nou on a inversé un bit de plus.\n"
        },
        {
          "text": "$10010011$",
          "correct": false,
          "feedback": "Erreur : c'est la **représentation naïve** (signe + valeur\nabsolue), qui n'est pas le complément à deux. Cette\nnotation a des défauts qui justifient justement le\ncomplément à deux.\n"
        }
      ],
      "explanation": "Les trois étapes du complément à deux : (1) écrire la valeur\nabsolue en binaire, (2) inverser tous les bits (complément à\nun), (3) ajouter $1$. Cela revient à calculer $2^n - |x|$.",
      "variants": [
        {
          "statement": "Quelle est la représentation binaire de $-19$ sur huit bits, en\ncomplément à deux ?",
          "options": [
            {
              "text": "$11101101$",
              "correct": true,
              "feedback": "Bonne réponse : étape par étape, $19 = 00010011$, on\ninverse → $11101100$, on ajoute $1$ → $11101101$.\n"
            },
            {
              "text": "$11101100$",
              "correct": false,
              "feedback": "Erreur : c'est le complément à un (inversion des bits)\nmais on a oublié l'étape finale d'ajouter $1$.\n"
            },
            {
              "text": "$11101110$",
              "correct": false,
              "feedback": "Erreur : on a ajouté $2$ au lieu de $1$ après inversion,\nou on a inversé un bit de plus.\n"
            },
            {
              "text": "$10010011$",
              "correct": false,
              "feedback": "Erreur : c'est la **représentation naïve** (signe + valeur\nabsolue), qui n'est pas le complément à deux. Cette\nnotation a des défauts qui justifient justement le\ncomplément à deux.\n"
            }
          ],
          "explanation": "Les trois étapes du complément à deux : (1) écrire la valeur\nabsolue en binaire, (2) inverser tous les bits (complément à\nun), (3) ajouter $1$. Cela revient à calculer $2^n - |x|$."
        },
        {
          "statement": "Quelle est la représentation binaire de $-37$ sur huit bits, en\ncomplément à deux ?",
          "options": [
            {
              "text": "$11011011$",
              "correct": true,
              "feedback": "Bonne réponse : étape par étape, $37 = 00100101$, on\ninverse → $11011010$, on ajoute $1$ → $11011011$.\n"
            },
            {
              "text": "$11011010$",
              "correct": false,
              "feedback": "Erreur : c'est le complément à un (inversion des bits)\nmais on a oublié l'étape finale d'ajouter $1$.\n"
            },
            {
              "text": "$11011100$",
              "correct": false,
              "feedback": "Erreur : on a ajouté $2$ au lieu de $1$ après inversion,\nou on a inversé un bit de plus.\n"
            },
            {
              "text": "$10100101$",
              "correct": false,
              "feedback": "Erreur : c'est la **représentation naïve** (signe + valeur\nabsolue), qui n'est pas le complément à deux. Cette\nnotation a des défauts qui justifient justement le\ncomplément à deux.\n"
            }
          ],
          "explanation": "Les trois étapes du complément à deux : (1) écrire la valeur\nabsolue en binaire, (2) inverser tous les bits (complément à\nun), (3) ajouter $1$. Cela revient à calculer $2^n - |x|$."
        },
        {
          "statement": "Quelle est la représentation binaire de $-76$ sur huit bits, en\ncomplément à deux ?",
          "options": [
            {
              "text": "$10110100$",
              "correct": true,
              "feedback": "Bonne réponse : étape par étape, $76 = 01001100$, on\ninverse → $10110011$, on ajoute $1$ → $10110100$.\n"
            },
            {
              "text": "$10110011$",
              "correct": false,
              "feedback": "Erreur : c'est le complément à un (inversion des bits)\nmais on a oublié l'étape finale d'ajouter $1$.\n"
            },
            {
              "text": "$10110101$",
              "correct": false,
              "feedback": "Erreur : on a ajouté $2$ au lieu de $1$ après inversion,\nou on a inversé un bit de plus.\n"
            },
            {
              "text": "$11001100$",
              "correct": false,
              "feedback": "Erreur : c'est la **représentation naïve** (signe + valeur\nabsolue), qui n'est pas le complément à deux. Cette\nnotation a des défauts qui justifient justement le\ncomplément à deux.\n"
            }
          ],
          "explanation": "Les trois étapes du complément à deux : (1) écrire la valeur\nabsolue en binaire, (2) inverser tous les bits (complément à\nun), (3) ajouter $1$. Cela revient à calculer $2^n - |x|$."
        }
      ]
    },
    {
      "id": "q16",
      "difficulty": 2,
      "skills": [
        "complement-deux",
        "lecture"
      ],
      "title": "Lecture d'un nombre négatif",
      "partie": "complement",
      "statement": "Que vaut $11111101_2$ interprété en complément à deux sur huit\nbits ?",
      "options": [
        {
          "text": "$-125$",
          "correct": false,
          "feedback": "Erreur : confusion possible. Vérifier en posant l'addition\n$00000011 + 11111101$ : si on obtient $00000000$ (avec\nretenue ignorée), c'est bien $3$ et $-3$.\n"
        },
        {
          "text": "$-253$",
          "correct": false,
          "feedback": "Erreur : on a oublié que la valeur absolue se déduit en\nappliquant à nouveau le complément à deux, pas en lisant\nla magnitude restante.\n"
        },
        {
          "text": "$253$",
          "correct": false,
          "feedback": "Erreur : c'est la lecture comme entier **naturel**. Or le\nbit de poids fort à $1$ indique un nombre négatif en\ncomplément à deux.\n"
        },
        {
          "text": "$-3$",
          "correct": true,
          "feedback": "Bonne réponse : on inverse → $00000010$, on ajoute $1$ →\n$00000011 = 3$, le bit de poids fort à $1$ donne le signe\nnégatif. Donc $-3$.\n"
        }
      ],
      "explanation": "Méthode : si le bit de poids fort vaut $1$, le nombre est\nnégatif. On retrouve sa valeur absolue en appliquant à\nnouveau le complément à deux (inversion + $1$).",
      "variants": [
        {
          "statement": "Que vaut $11111101_2$ interprété en complément à deux sur huit\nbits ?",
          "options": [
            {
              "text": "$-125$",
              "correct": false,
              "feedback": "Erreur : confusion possible. Vérifier en posant l'addition\n$00000011 + 11111101$ : si on obtient $00000000$ (avec\nretenue ignorée), c'est bien $3$ et $-3$.\n"
            },
            {
              "text": "$-253$",
              "correct": false,
              "feedback": "Erreur : on a oublié que la valeur absolue se déduit en\nappliquant à nouveau le complément à deux, pas en lisant\nla magnitude restante.\n"
            },
            {
              "text": "$253$",
              "correct": false,
              "feedback": "Erreur : c'est la lecture comme entier **naturel**. Or le\nbit de poids fort à $1$ indique un nombre négatif en\ncomplément à deux.\n"
            },
            {
              "text": "$-3$",
              "correct": true,
              "feedback": "Bonne réponse : on inverse → $00000010$, on ajoute $1$ →\n$00000011 = 3$, le bit de poids fort à $1$ donne le signe\nnégatif. Donc $-3$.\n"
            }
          ],
          "explanation": "Méthode : si le bit de poids fort vaut $1$, le nombre est\nnégatif. On retrouve sa valeur absolue en appliquant à\nnouveau le complément à deux (inversion + $1$)."
        },
        {
          "statement": "Que vaut $11010110_2$ interprété en complément à deux sur huit\nbits ?",
          "options": [
            {
              "text": "$-86$",
              "correct": false,
              "feedback": "Erreur : confusion possible. Vérifier en posant l'addition\n$00101010 + 11010110$ : si on obtient $00000000$ (avec\nretenue ignorée), c'est bien $42$ et $-42$.\n"
            },
            {
              "text": "$-214$",
              "correct": false,
              "feedback": "Erreur : on a oublié que la valeur absolue se déduit en\nappliquant à nouveau le complément à deux, pas en lisant\nla magnitude restante.\n"
            },
            {
              "text": "$214$",
              "correct": false,
              "feedback": "Erreur : c'est la lecture comme entier **naturel**. Or le\nbit de poids fort à $1$ indique un nombre négatif en\ncomplément à deux.\n"
            },
            {
              "text": "$-42$",
              "correct": true,
              "feedback": "Bonne réponse : on inverse → $00101001$, on ajoute $1$ →\n$00101010 = 42$, le bit de poids fort à $1$ donne le signe\nnégatif. Donc $-42$.\n"
            }
          ],
          "explanation": "Méthode : si le bit de poids fort vaut $1$, le nombre est\nnégatif. On retrouve sa valeur absolue en appliquant à\nnouveau le complément à deux (inversion + $1$)."
        },
        {
          "statement": "Que vaut $10011100_2$ interprété en complément à deux sur huit\nbits ?",
          "options": [
            {
              "text": "$-28$",
              "correct": false,
              "feedback": "Erreur : confusion possible. Vérifier en posant l'addition\n$01100100 + 10011100$ : si on obtient $00000000$ (avec\nretenue ignorée), c'est bien $100$ et $-100$.\n"
            },
            {
              "text": "$-156$",
              "correct": false,
              "feedback": "Erreur : on a oublié que la valeur absolue se déduit en\nappliquant à nouveau le complément à deux, pas en lisant\nla magnitude restante.\n"
            },
            {
              "text": "$156$",
              "correct": false,
              "feedback": "Erreur : c'est la lecture comme entier **naturel**. Or le\nbit de poids fort à $1$ indique un nombre négatif en\ncomplément à deux.\n"
            },
            {
              "text": "$-100$",
              "correct": true,
              "feedback": "Bonne réponse : on inverse → $01100011$, on ajoute $1$ →\n$01100100 = 100$, le bit de poids fort à $1$ donne le signe\nnégatif. Donc $-100$.\n"
            }
          ],
          "explanation": "Méthode : si le bit de poids fort vaut $1$, le nombre est\nnégatif. On retrouve sa valeur absolue en appliquant à\nnouveau le complément à deux (inversion + $1$)."
        }
      ]
    },
    {
      "id": "q17",
      "difficulty": 2,
      "skills": [
        "hexadecimal",
        "application"
      ],
      "title": "Couleurs HTML en hexadécimal",
      "partie": "hexadecimal",
      "statement": "En CSS, la couleur `#FF5733` est codée en hexadécimal sur six\nchiffres. Que vaut la composante rouge en décimal ?",
      "options": [
        {
          "text": "$30$",
          "correct": false,
          "feedback": "Erreur : on a additionné les deux chiffres hexadécimaux\n($15 + 15$) au lieu de multiplier le premier par $16$ :\n$FF_{16} = 15 \\cdot 16 + 15 = 255_{10}$.\n"
        },
        {
          "text": "$87$",
          "correct": false,
          "feedback": "Erreur : $87$ correspond à la composante verte $57_{16}$.\n"
        },
        {
          "text": "$255$",
          "correct": true,
          "feedback": "Bonne réponse : la composante rouge est $FF_{16}$, soit\n$15 \\cdot 16 + 15 = 255_{10}$.\n"
        },
        {
          "text": "$51$",
          "correct": false,
          "feedback": "Erreur : $51$ correspond à la composante bleue $33_{16}$.\nLes composantes sont dans l'ordre RVB (rouge, vert, bleu).\n"
        }
      ],
      "explanation": "Une couleur RVB sur huit bits par composante prend la forme\n`#RRVVBB` où chaque paire de chiffres hexa code une valeur\nentre $00$ et $FF$ ($0$ et $255$). Ici : rouge = $FF = 255$,\nvert = $57 = 87$, bleu = $33 = 51$.",
      "variants": [
        {
          "statement": "En CSS, la couleur `#FF5733` est codée en hexadécimal sur six\nchiffres. Que vaut la composante rouge en décimal ?",
          "options": [
            {
              "text": "$30$",
              "correct": false,
              "feedback": "Erreur : on a additionné les deux chiffres hexadécimaux\n($15 + 15$) au lieu de multiplier le premier par $16$ :\n$FF_{16} = 15 \\cdot 16 + 15 = 255_{10}$.\n"
            },
            {
              "text": "$87$",
              "correct": false,
              "feedback": "Erreur : $87$ correspond à la composante verte $57_{16}$.\n"
            },
            {
              "text": "$255$",
              "correct": true,
              "feedback": "Bonne réponse : la composante rouge est $FF_{16}$, soit\n$15 \\cdot 16 + 15 = 255_{10}$.\n"
            },
            {
              "text": "$51$",
              "correct": false,
              "feedback": "Erreur : $51$ correspond à la composante bleue $33_{16}$.\nLes composantes sont dans l'ordre RVB (rouge, vert, bleu).\n"
            }
          ],
          "explanation": "Une couleur RVB sur huit bits par composante prend la forme\n`#RRVVBB` où chaque paire de chiffres hexa code une valeur\nentre $00$ et $FF$ ($0$ et $255$). Ici : rouge = $FF = 255$,\nvert = $57 = 87$, bleu = $33 = 51$."
        },
        {
          "statement": "En CSS, la couleur `#4A90E2` est codée en hexadécimal sur six\nchiffres. Que vaut la composante rouge en décimal ?",
          "options": [
            {
              "text": "$14$",
              "correct": false,
              "feedback": "Erreur : on a additionné les deux chiffres hexadécimaux\n($4 + 10$) au lieu de multiplier le premier par $16$ :\n$4A_{16} = 4 \\cdot 16 + 10 = 74_{10}$.\n"
            },
            {
              "text": "$144$",
              "correct": false,
              "feedback": "Erreur : $144$ correspond à la composante verte $90_{16}$.\n"
            },
            {
              "text": "$74$",
              "correct": true,
              "feedback": "Bonne réponse : la composante rouge est $4A_{16}$, soit\n$4 \\cdot 16 + 10 = 74_{10}$.\n"
            },
            {
              "text": "$226$",
              "correct": false,
              "feedback": "Erreur : $226$ correspond à la composante bleue $E2_{16}$.\nLes composantes sont dans l'ordre RVB (rouge, vert, bleu).\n"
            }
          ],
          "explanation": "Une couleur RVB sur huit bits par composante prend la forme\n`#RRVVBB` où chaque paire de chiffres hexa code une valeur\nentre $00$ et $FF$ ($0$ et $255$). Ici : rouge = $4A = 74$,\nvert = $90 = 144$, bleu = $E2 = 226$."
        },
        {
          "statement": "En CSS, la couleur `#C8102E` est codée en hexadécimal sur six\nchiffres. Que vaut la composante rouge en décimal ?",
          "options": [
            {
              "text": "$20$",
              "correct": false,
              "feedback": "Erreur : on a additionné les deux chiffres hexadécimaux\n($12 + 8$) au lieu de multiplier le premier par $16$ :\n$C8_{16} = 12 \\cdot 16 + 8 = 200_{10}$.\n"
            },
            {
              "text": "$16$",
              "correct": false,
              "feedback": "Erreur : $16$ correspond à la composante verte $10_{16}$.\n"
            },
            {
              "text": "$200$",
              "correct": true,
              "feedback": "Bonne réponse : la composante rouge est $C8_{16}$, soit\n$12 \\cdot 16 + 8 = 200_{10}$.\n"
            },
            {
              "text": "$46$",
              "correct": false,
              "feedback": "Erreur : $46$ correspond à la composante bleue $2E_{16}$.\nLes composantes sont dans l'ordre RVB (rouge, vert, bleu).\n"
            }
          ],
          "explanation": "Une couleur RVB sur huit bits par composante prend la forme\n`#RRVVBB` où chaque paire de chiffres hexa code une valeur\nentre $00$ et $FF$ ($0$ et $255$). Ici : rouge = $C8 = 200$,\nvert = $10 = 16$, bleu = $2E = 46$."
        }
      ]
    },
    {
      "id": "q18",
      "difficulty": 2,
      "skills": [
        "denombrement",
        "intervalle"
      ],
      "title": "Nombre de valeurs codables",
      "partie": "bases",
      "statement": "Combien de valeurs différentes peut-on représenter sur $n$ bits ?",
      "options": [
        {
          "text": "$n$",
          "correct": false,
          "feedback": "Erreur : confusion entre le nombre de bits et le nombre de\nvaleurs. Avec $1$ bit on a $2$ valeurs, avec $2$ bits on\nen a $4$, pas $2$.\n"
        },
        {
          "text": "$2 \\cdot n$",
          "correct": false,
          "feedback": "Erreur : la croissance n'est pas linéaire mais\n**exponentielle**. Chaque bit supplémentaire double le\nnombre de valeurs possibles.\n"
        },
        {
          "text": "$2^n$",
          "correct": true,
          "feedback": "Bonne réponse : chaque bit pouvant prendre deux valeurs\nindépendamment des autres, $n$ bits permettent\n$2 \\times 2 \\times \\cdots \\times 2 = 2^n$ combinaisons.\n"
        },
        {
          "text": "$n^2$",
          "correct": false,
          "feedback": "Erreur : la croissance n'est pas polynomiale mais\nexponentielle. Pour $n = 10$, on a $2^{10} = 1024$, pas\n$100$.\n"
        }
      ],
      "explanation": "Cette croissance exponentielle explique pourquoi les\nprocesseurs $64$ bits ($2^{64}$ adresses possibles) couvrent\ntoute la mémoire imaginable, alors que les processeurs $32$\nbits ($\\approx 4 \\cdot 10^9$ adresses) sont déjà saturés pour\nla mémoire moderne."
    },
    {
      "id": "q19",
      "difficulty": 2,
      "skills": [
        "complement-deux",
        "astuce"
      ],
      "title": "Astuce rapide du complément à deux",
      "partie": "complement",
      "statement": "Pour calculer rapidement le complément à deux d'un nombre, on\nparcourt ses bits **de droite à gauche**. Que fait-on ?",
      "options": [
        {
          "text": "On ajoute $1$ à chaque bit individuellement, colonne par colonne",
          "correct": false,
          "feedback": "Erreur : ce n'est pas une opération sensée en binaire\n(chaque bit ne vaut que $0$ ou $1$).\n"
        },
        {
          "text": "On inverse tous les bits sans exception, du poids faible au poids fort",
          "correct": false,
          "feedback": "Erreur : c'est le complément à **un**. L'astuce du\ncomplément à deux laisse une partie des bits inchangée.\n"
        },
        {
          "text": "On garde les bits jusqu'au premier $1$ inclus et on inverse le reste",
          "correct": true,
          "feedback": "Bonne réponse : on conserve la partie droite (zéros et le\npremier $1$) et on inverse tout le reste à gauche. Cela\névite les étapes intermédiaires.\n"
        },
        {
          "text": "On inverse les bits jusqu'au premier $1$, puis on garde les suivants",
          "correct": false,
          "feedback": "Erreur : c'est l'inverse de la bonne règle. On commence par\n**garder** la partie droite, puis on inverse à gauche.\n"
        }
      ],
      "explanation": "Exemple : $20 = 00010100$. On garde « ...100 » (jusqu'au\npremier $1$ depuis la droite) et on inverse le reste :\n$11101100 = -20$. Cette astuce évite l'étape « inversion +\naddition de $1$ »."
    },
    {
      "id": "q20",
      "difficulty": 2,
      "skills": [
        "complement-deux",
        "asymetrie"
      ],
      "title": "Asymétrie positifs/négatifs",
      "partie": "complement",
      "statement": "Pourquoi y a-t-il un négatif de plus que de positifs en\ncomplément à deux ?",
      "options": [
        {
          "text": "Parce que le complément à deux gaspille un code",
          "correct": false,
          "feedback": "Erreur : au contraire, le complément à deux n'a pas de\ndouble représentation du zéro, il utilise donc tous les\ncodes possibles.\n"
        },
        {
          "text": "Parce que la représentation est moins efficace pour les positifs",
          "correct": false,
          "feedback": "Erreur : la représentation est tout aussi efficace pour\nles positifs que pour les négatifs. La dissymétrie tient\nà un autre phénomène.\n"
        },
        {
          "text": "Parce que $0$ est compté du côté des positifs",
          "correct": true,
          "feedback": "Bonne réponse : sur $n$ bits, on a $2^n$ codes différents,\ndont une moitié pour les négatifs et une moitié pour les\npositifs. Comme $0$ n'a qu'une seule représentation et\nqu'il est compté avec les positifs, il y en a un de moins\ncôté positif.\n"
        },
        {
          "text": "Parce que les nombres négatifs prennent plus de bits que les positifs",
          "correct": false,
          "feedback": "Erreur : tous les codes ont la même longueur en bits.\nC'est la convention de signe qui crée la dissymétrie.\n"
        }
      ],
      "explanation": "Sur huit bits, on a $256$ codes : $128$ pour les non négatifs\n($0, 1, \\ldots, 127$) et $128$ pour les négatifs\n($-128, -127, \\ldots, -1$). C'est une particularité du\ncomplément à deux qu'il faut connaître."
    },
    {
      "id": "q21",
      "difficulty": 3,
      "skills": [
        "depassement",
        "complement-deux"
      ],
      "title": "Dépassement de capacité",
      "partie": "limites",
      "statement": "Sur huit bits en complément à deux, que renvoie l'addition\n$127 + 1$ ?",
      "options": [
        {
          "text": "$0$",
          "correct": false,
          "feedback": "Erreur : confusion possible avec une remise à zéro après\ndébordement, qui se produit pour les entiers non signés\n($255 + 1 = 0$ mod $256$). Ici, on est en signé.\n"
        },
        {
          "text": "$-128$",
          "correct": true,
          "feedback": "Bonne réponse : $01111111 + 00000001 = 10000000$. Or sur\n$8$ bits en complément à deux, $10000000_2 = -128$. Il y\na dépassement de capacité (*overflow*).\n"
        },
        {
          "text": "Une erreur Python",
          "correct": false,
          "feedback": "Erreur : Python n'a pas de limite de taille des entiers,\ndonc cette question concerne les langages à entiers de\ntaille fixe (C, Java, etc.). En Python, $127 + 1 = 128$\nsans souci.\n"
        },
        {
          "text": "$128$",
          "correct": false,
          "feedback": "Erreur : $128$ n'est pas représentable sur $8$ bits en\ncomplément à deux (l'intervalle s'arrête à $127$). Le\nrésultat est donc « tordu ».\n"
        }
      ],
      "explanation": "Le dépassement est un piège classique des langages à entiers de\ntaille fixe. En complément à deux, l'incrément du plus grand\npositif donne le plus petit négatif. C'est la cause de bugs\ncélèbres, comme le compteur de vues 32 bits de YouTube dépassé\nen 2014 par *Gangnam Style*.",
      "variants": [
        {
          "statement": "Sur huit bits en complément à deux, que renvoie l'addition\n$127 + 1$ ?",
          "options": [
            {
              "text": "$0$",
              "correct": false,
              "feedback": "Erreur : confusion possible avec une remise à zéro après\ndébordement, qui se produit pour les entiers non signés\n($255 + 1 = 0$ mod $256$). Ici, on est en signé.\n"
            },
            {
              "text": "$-128$",
              "correct": true,
              "feedback": "Bonne réponse : $01111111 + 00000001 = 10000000$. Or sur\n$8$ bits en complément à deux, $10000000_2 = -128$. Il y\na dépassement de capacité (*overflow*).\n"
            },
            {
              "text": "Une erreur Python",
              "correct": false,
              "feedback": "Erreur : Python n'a pas de limite de taille des entiers,\ndonc cette question concerne les langages à entiers de\ntaille fixe (C, Java, etc.). En Python, $127 + 1 = 128$\nsans souci.\n"
            },
            {
              "text": "$128$",
              "correct": false,
              "feedback": "Erreur : $128$ n'est pas représentable sur $8$ bits en\ncomplément à deux (l'intervalle s'arrête à $127$). Le\nrésultat est donc « tordu ».\n"
            }
          ],
          "explanation": "Le dépassement est un piège classique des langages à entiers de\ntaille fixe. En complément à deux, l'incrément du plus grand\npositif donne le plus petit négatif. C'est la cause de bugs\ncélèbres, comme le compteur de vues 32 bits de YouTube dépassé\nen 2014 par *Gangnam Style*."
        },
        {
          "statement": "Sur seize bits en complément à deux, que renvoie l'addition\n$32767 + 1$ ?",
          "options": [
            {
              "text": "$0$",
              "correct": false,
              "feedback": "Erreur : confusion possible avec une remise à zéro après\ndébordement, qui se produit pour les entiers non signés\n($65535 + 1 = 0$ mod $65536$). Ici, on est en signé.\n"
            },
            {
              "text": "$-32768$",
              "correct": true,
              "feedback": "Bonne réponse : $0111111111111111 + 0000000000000001 = 1000000000000000$. Or sur\n$16$ bits en complément à deux, $1000000000000000_2 = -32768$. Il y\na dépassement de capacité (*overflow*).\n"
            },
            {
              "text": "Une erreur Python",
              "correct": false,
              "feedback": "Erreur : Python n'a pas de limite de taille des entiers,\ndonc cette question concerne les langages à entiers de\ntaille fixe (C, Java, etc.). En Python, $32767 + 1 = 32768$\nsans souci.\n"
            },
            {
              "text": "$32768$",
              "correct": false,
              "feedback": "Erreur : $32768$ n'est pas représentable sur $16$ bits en\ncomplément à deux (l'intervalle s'arrête à $32767$). Le\nrésultat est donc « tordu ».\n"
            }
          ],
          "explanation": "Le dépassement est un piège classique des langages à entiers de\ntaille fixe. En complément à deux, l'incrément du plus grand\npositif donne le plus petit négatif. C'est la cause de bugs\ncélèbres, comme le compteur de vues 32 bits de YouTube dépassé\nen 2014 par *Gangnam Style*."
        }
      ]
    },
    {
      "id": "q22",
      "difficulty": 3,
      "skills": [
        "naive",
        "complement-deux",
        "comparaison"
      ],
      "title": "Défaut de la représentation naïve",
      "partie": "bases",
      "statement": "Pourquoi n'utilise-t-on pas la **représentation naïve** (bit de\npoids fort = signe, autres bits = valeur absolue) pour coder\nles entiers relatifs ?",
      "options": [
        {
          "text": "Parce qu'elle ne permet pas de coder les nombres négatifs",
          "correct": false,
          "feedback": "Erreur : elle code bien les négatifs, mais avec deux\ndéfauts qui la rendent peu pratique.\n"
        },
        {
          "text": "Parce qu'elle utilise plus de bits que le complément à deux",
          "correct": false,
          "feedback": "Erreur : les deux représentations utilisent le même nombre\nde bits.\n"
        },
        {
          "text": "Parce que l'addition binaire usuelle échoue sur les négatifs",
          "correct": true,
          "feedback": "Bonne réponse : avec la représentation naïve, on ne peut\nplus utiliser l'additionneur standard pour les\nsoustractions. Le complément à deux résout ce problème :\nle **même circuit** d'addition fonctionne pour positifs et\nnégatifs.\n"
        },
        {
          "text": "Parce qu'elle est plus lente à interpréter pour le processeur",
          "correct": false,
          "feedback": "Erreur : la lecture est en réalité **plus simple** (signe\n+ valeur absolue). Le problème est ailleurs : dans\nl'arithmétique.\n"
        }
      ],
      "explanation": "C'est précisément pour pouvoir réutiliser le circuit\nd'addition standard que les processeurs adoptent le complément\nà deux. La représentation naïve aurait aussi le défaut d'avoir\ndeux représentations du zéro ($+0$ et $-0$)."
    },
    {
      "id": "q23",
      "difficulty": 3,
      "skills": [
        "complement-un",
        "complement-deux"
      ],
      "title": "Différence entre complément à un et complément à deux",
      "partie": "complement",
      "statement": "En quoi le **complément à deux** diffère-t-il du **complément à un** ?",
      "options": [
        {
          "text": "Le complément à un est calculé sur deux bits, le complément à deux sur deux octets",
          "correct": false,
          "feedback": "Erreur : confusion sur les noms. Aucune des deux\nappellations ne renvoie au nombre de bits.\n"
        },
        {
          "text": "Le complément à deux n'utilise pas le bit de poids fort comme signe",
          "correct": false,
          "feedback": "Erreur : au contraire, le bit de poids fort sert de\nsigne en complément à deux ($0$ pour positif, $1$ pour\nnégatif).\n"
        },
        {
          "text": "Le complément à un ne fonctionne que pour les nombres positifs",
          "correct": false,
          "feedback": "Erreur : le complément à un peut s'appliquer à n'importe\nquel motif binaire ; c'est juste une inversion de bits.\n"
        },
        {
          "text": "Le complément à deux ajoute $1$ après l'inversion de tous les bits",
          "correct": true,
          "feedback": "Bonne réponse : le complément à un s'arrête à l'inversion\ndes bits ; c'est l'étape intermédiaire de l'opération du\ncomplément à deux. Le « $+1$ » final corrige la double\nreprésentation du zéro qui subsisterait sans cette\ncorrection.\n"
        }
      ],
      "explanation": "Le complément à un (inversion seule) crée deux représentations\ndu zéro ($00\\ldots0$ et $11\\ldots1$). L'ajout du « $+1$ » du\ncomplément à deux fait fusionner ces deux zéros et permet\nd'utiliser l'arithmétique standard sans correction."
    },
    {
      "id": "q25",
      "difficulty": 3,
      "skills": [
        "python",
        "precision-arbitraire"
      ],
      "title": "Entiers en Python vs en C",
      "partie": "hexadecimal",
      "statement": "En Python, l'expression `2 ** 100` donne un nombre entier\nexact, alors qu'en C ou en Java elle provoquerait un\ndépassement. Pourquoi ?",
      "options": [
        {
          "text": "Python utilise des nombres flottants pour tous les calculs entiers",
          "correct": false,
          "feedback": "Erreur : Python distingue bien les entiers (`int`) des\nflottants (`float`). $2^{100}$ est calculé comme un entier\nexact, pas approché.\n"
        },
        {
          "text": "Python tronque silencieusement les entiers trop grands",
          "correct": false,
          "feedback": "Erreur : aucune troncature. Le résultat est exact, même\npour des nombres immenses.\n"
        },
        {
          "text": "Python fait tous ses calculs entiers modulo $2^{64}$",
          "correct": false,
          "feedback": "Erreur : c'est le comportement de C/Java sur entiers\n$64$ bits. Python n'a pas de modulo implicite.\n"
        },
        {
          "text": "Python alloue aux entiers autant de mémoire que nécessaire",
          "correct": true,
          "feedback": "Bonne réponse : les entiers Python sont en **précision\narbitraire**. L'interpréteur adapte automatiquement, sans\nlimite fixe, la mémoire réservée pour représenter le\nnombre exactement.\n"
        }
      ],
      "explanation": "Cette caractéristique est un atout pédagogique de Python :\nl'élève n'a pas à se soucier des limites de codage. Mais cela\na un coût : les opérations sur de très grands entiers sont\nplus lentes que sur des entiers de taille fixe."
    },
    {
      "id": "q26",
      "difficulty": 2,
      "skills": [
        "conversion",
        "decimal-hexadecimal"
      ],
      "title": "Conversion décimal vers hexadécimal",
      "partie": "bases",
      "statement": "Quelle est l'écriture hexadécimale de l'entier $195$ ?",
      "options": [
        {
          "text": "$\\text{C3}_{16}$",
          "correct": true,
          "feedback": "Bonne réponse : $195 = 12 \\times 16 + 3$. Le quotient $12$\ns'écrit $\\text{C}$ et le reste $3$ s'écrit $\\text{3}$,\nd'où $\\text{C3}_{16}$.\n"
        },
        {
          "text": "$\\text{C5}_{16}$",
          "correct": false,
          "feedback": "Erreur sur le reste : $195 - 12 \\times 16 = 195 - 192 = 3$\n(et non $5$). Bien vérifier la soustraction finale qui\ndonne le dernier chiffre.\n"
        },
        {
          "text": "$\\text{3C}_{16}$",
          "correct": false,
          "feedback": "Erreur : les chiffres ont été inversés. Le quotient se\nlit en premier (à gauche), suivi du reste à droite. Le\nbon résultat est $\\text{C3}_{16}$.\n"
        },
        {
          "text": "$\\text{A3}_{16}$",
          "correct": false,
          "feedback": "Erreur sur le quotient : on a pris $\\text{A}$ (qui vaut\n$10$) au lieu de $\\text{C}$ (qui vaut $12$). Or\n$195 \\div 16 = 12$ reste $3$, donc le chiffre des\n« seize » est bien $\\text{C}$.\n"
        }
      ],
      "explanation": "Méthode des divisions successives par $16$ : tant que le\nquotient n'est pas nul, on note le reste et on continue avec\nle quotient. Ici, $195 \\div 16 = 12$ reste $3$, puis\n$12 \\div 16 = 0$ reste $12$ ($\\text{C}$). On lit les restes\ndu dernier au premier : $\\text{C3}_{16}$.",
      "variants": [
        {
          "statement": "Quelle est l'écriture hexadécimale de l'entier $195$ ?",
          "options": [
            {
              "text": "$\\text{C3}_{16}$",
              "correct": true,
              "feedback": "Bonne réponse : $195 = 12 \\times 16 + 3$. Le quotient $12$\ns'écrit $\\text{C}$ et le reste $3$ s'écrit $\\text{3}$,\nd'où $\\text{C3}_{16}$.\n"
            },
            {
              "text": "$\\text{C5}_{16}$",
              "correct": false,
              "feedback": "Erreur sur le reste : $195 - 12 \\times 16 = 195 - 192 = 3$\n(et non $5$). Bien vérifier la soustraction finale qui\ndonne le dernier chiffre.\n"
            },
            {
              "text": "$\\text{3C}_{16}$",
              "correct": false,
              "feedback": "Erreur : les chiffres ont été inversés. Le quotient se\nlit en premier (à gauche), suivi du reste à droite. Le\nbon résultat est $\\text{C3}_{16}$.\n"
            },
            {
              "text": "$\\text{A3}_{16}$",
              "correct": false,
              "feedback": "Erreur sur le quotient : on a pris $\\text{A}$ (qui vaut\n$10$) au lieu de $\\text{C}$ (qui vaut $12$). Or\n$195 \\div 16 = 12$ reste $3$, donc le chiffre des\n« seize » est bien $\\text{C}$.\n"
            }
          ],
          "explanation": "Méthode des divisions successives par $16$ : tant que le\nquotient n'est pas nul, on note le reste et on continue avec\nle quotient. Ici, $195 \\div 16 = 12$ reste $3$, puis\n$12 \\div 16 = 0$ reste $12$ ($\\text{C}$). On lit les restes\ndu dernier au premier : $\\text{C3}_{16}$."
        },
        {
          "statement": "Quelle est l'écriture hexadécimale de l'entier $173$ ?",
          "options": [
            {
              "text": "$\\text{AD}_{16}$",
              "correct": true,
              "feedback": "Bonne réponse : $173 = 10 \\times 16 + 13$. Le quotient $10$\ns'écrit $\\text{A}$ et le reste $13$ s'écrit $\\text{D}$,\nd'où $\\text{AD}_{16}$.\n"
            },
            {
              "text": "$\\text{AF}_{16}$",
              "correct": false,
              "feedback": "Erreur sur le reste : $173 - 10 \\times 16 = 173 - 160 = 13$\n(et non $15$). Bien vérifier la soustraction finale qui\ndonne le dernier chiffre.\n"
            },
            {
              "text": "$\\text{DA}_{16}$",
              "correct": false,
              "feedback": "Erreur : les chiffres ont été inversés. Le quotient se\nlit en premier (à gauche), suivi du reste à droite. Le\nbon résultat est $\\text{AD}_{16}$.\n"
            },
            {
              "text": "$\\text{8D}_{16}$",
              "correct": false,
              "feedback": "Erreur sur le quotient : on a pris $\\text{8}$ (qui vaut\n$8$) au lieu de $\\text{A}$ (qui vaut $10$). Or\n$173 \\div 16 = 10$ reste $13$, donc le chiffre des\n« seize » est bien $\\text{A}$.\n"
            }
          ],
          "explanation": "Méthode des divisions successives par $16$ : tant que le\nquotient n'est pas nul, on note le reste et on continue avec\nle quotient. Ici, $173 \\div 16 = 10$ reste $13$, puis\n$10 \\div 16 = 0$ reste $10$ ($\\text{A}$). On lit les restes\ndu dernier au premier : $\\text{AD}_{16}$."
        },
        {
          "statement": "Quelle est l'écriture hexadécimale de l'entier $220$ ?",
          "options": [
            {
              "text": "$\\text{DC}_{16}$",
              "correct": true,
              "feedback": "Bonne réponse : $220 = 13 \\times 16 + 12$. Le quotient $13$\ns'écrit $\\text{D}$ et le reste $12$ s'écrit $\\text{C}$,\nd'où $\\text{DC}_{16}$.\n"
            },
            {
              "text": "$\\text{DE}_{16}$",
              "correct": false,
              "feedback": "Erreur sur le reste : $220 - 13 \\times 16 = 220 - 208 = 12$\n(et non $14$). Bien vérifier la soustraction finale qui\ndonne le dernier chiffre.\n"
            },
            {
              "text": "$\\text{CD}_{16}$",
              "correct": false,
              "feedback": "Erreur : les chiffres ont été inversés. Le quotient se\nlit en premier (à gauche), suivi du reste à droite. Le\nbon résultat est $\\text{DC}_{16}$.\n"
            },
            {
              "text": "$\\text{BC}_{16}$",
              "correct": false,
              "feedback": "Erreur sur le quotient : on a pris $\\text{B}$ (qui vaut\n$11$) au lieu de $\\text{D}$ (qui vaut $13$). Or\n$220 \\div 16 = 13$ reste $12$, donc le chiffre des\n« seize » est bien $\\text{D}$.\n"
            }
          ],
          "explanation": "Méthode des divisions successives par $16$ : tant que le\nquotient n'est pas nul, on note le reste et on continue avec\nle quotient. Ici, $220 \\div 16 = 13$ reste $12$, puis\n$13 \\div 16 = 0$ reste $13$ ($\\text{D}$). On lit les restes\ndu dernier au premier : $\\text{DC}_{16}$."
        }
      ]
    },
    {
      "id": "q27",
      "difficulty": 2,
      "skills": [
        "intervalle",
        "dimensionnement"
      ],
      "title": "Nombre minimum de bits",
      "partie": "limites",
      "statement": "Combien de bits sont nécessaires au minimum pour coder en\nbinaire l'entier naturel $287$ ?",
      "options": [
        {
          "text": "$9$",
          "correct": true,
          "feedback": "Bonne réponse : on cherche le plus petit $n$ tel que\n$2^n > 287$. Or $2^{8} = 256$ (insuffisant) et\n$2^{9} = 512$ (suffisant), donc $n = 9$.\n"
        },
        {
          "text": "$7$",
          "correct": false,
          "feedback": "Erreur : sur $7$ bits, on peut coder les entiers de $0$\nà $2^{7} - 1 = 127$. Or $287 > 127$, donc\n$7$ bits ne suffisent pas.\n"
        },
        {
          "text": "$8$",
          "correct": false,
          "feedback": "Erreur : sur $8$ bits, on couvre l'intervalle\n$[0\\,;\\, 2^{8} - 1] = [0\\,;\\, 255]$. Comme\n$287 > 255$, c'est encore insuffisant.\n"
        },
        {
          "text": "$10$",
          "correct": false,
          "feedback": "Erreur : $10$ bits suffisent largement (ils couvrent\njusqu'à $1023$), mais ce n'est pas le **minimum**. Avec\n$9$ bits, on atteint déjà $511$, ce qui est suffisant\npour $287$.\n"
        }
      ],
      "explanation": "Méthode : chercher le plus petit $n$ tel que $2^n - 1 \\geq 287$,\nou de façon équivalente $2^n \\geq 288$. Ici, $2^{8} = 256$\net $2^{9} = 512$, donc le minimum est $n = 9$. De manière\nplus formelle, ce nombre est $\\lceil \\log_2(287 + 1) \\rceil = 9$.",
      "variants": [
        {
          "statement": "Combien de bits sont nécessaires au minimum pour coder en\nbinaire l'entier naturel $287$ ?",
          "options": [
            {
              "text": "$9$",
              "correct": true,
              "feedback": "Bonne réponse : on cherche le plus petit $n$ tel que\n$2^n > 287$. Or $2^{8} = 256$ (insuffisant) et\n$2^{9} = 512$ (suffisant), donc $n = 9$.\n"
            },
            {
              "text": "$7$",
              "correct": false,
              "feedback": "Erreur : sur $7$ bits, on peut coder les entiers de $0$\nà $2^{7} - 1 = 127$. Or $287 > 127$, donc\n$7$ bits ne suffisent pas.\n"
            },
            {
              "text": "$8$",
              "correct": false,
              "feedback": "Erreur : sur $8$ bits, on couvre l'intervalle\n$[0\\,;\\, 2^{8} - 1] = [0\\,;\\, 255]$. Comme\n$287 > 255$, c'est encore insuffisant.\n"
            },
            {
              "text": "$10$",
              "correct": false,
              "feedback": "Erreur : $10$ bits suffisent largement (ils couvrent\njusqu'à $1023$), mais ce n'est pas le **minimum**. Avec\n$9$ bits, on atteint déjà $511$, ce qui est suffisant\npour $287$.\n"
            }
          ],
          "explanation": "Méthode : chercher le plus petit $n$ tel que $2^n - 1 \\geq 287$,\nou de façon équivalente $2^n \\geq 288$. Ici, $2^{8} = 256$\net $2^{9} = 512$, donc le minimum est $n = 9$. De manière\nplus formelle, ce nombre est $\\lceil \\log_2(287 + 1) \\rceil = 9$."
        },
        {
          "statement": "Combien de bits sont nécessaires au minimum pour coder en\nbinaire l'entier naturel $1000$ ?",
          "options": [
            {
              "text": "$10$",
              "correct": true,
              "feedback": "Bonne réponse : on cherche le plus petit $n$ tel que\n$2^n > 1000$. Or $2^{9} = 512$ (insuffisant) et\n$2^{10} = 1024$ (suffisant), donc $n = 10$.\n"
            },
            {
              "text": "$8$",
              "correct": false,
              "feedback": "Erreur : sur $8$ bits, on peut coder les entiers de $0$\nà $2^{8} - 1 = 255$. Or $1000 > 255$, donc\n$8$ bits ne suffisent pas.\n"
            },
            {
              "text": "$9$",
              "correct": false,
              "feedback": "Erreur : sur $9$ bits, on couvre l'intervalle\n$[0\\,;\\, 2^{9} - 1] = [0\\,;\\, 511]$. Comme\n$1000 > 511$, c'est encore insuffisant.\n"
            },
            {
              "text": "$11$",
              "correct": false,
              "feedback": "Erreur : $11$ bits suffisent largement (ils couvrent\njusqu'à $2047$), mais ce n'est pas le **minimum**. Avec\n$10$ bits, on atteint déjà $1023$, ce qui est suffisant\npour $1000$.\n"
            }
          ],
          "explanation": "Méthode : chercher le plus petit $n$ tel que $2^n - 1 \\geq 1000$,\nou de façon équivalente $2^n \\geq 1001$. Ici, $2^{9} = 512$\net $2^{10} = 1024$, donc le minimum est $n = 10$. De manière\nplus formelle, ce nombre est $\\lceil \\log_2(1000 + 1) \\rceil = 10$."
        },
        {
          "statement": "Combien de bits sont nécessaires au minimum pour coder en\nbinaire l'entier naturel $150$ ?",
          "options": [
            {
              "text": "$8$",
              "correct": true,
              "feedback": "Bonne réponse : on cherche le plus petit $n$ tel que\n$2^n > 150$. Or $2^{7} = 128$ (insuffisant) et\n$2^{8} = 256$ (suffisant), donc $n = 8$.\n"
            },
            {
              "text": "$6$",
              "correct": false,
              "feedback": "Erreur : sur $6$ bits, on peut coder les entiers de $0$\nà $2^{6} - 1 = 63$. Or $150 > 63$, donc\n$6$ bits ne suffisent pas.\n"
            },
            {
              "text": "$7$",
              "correct": false,
              "feedback": "Erreur : sur $7$ bits, on couvre l'intervalle\n$[0\\,;\\, 2^{7} - 1] = [0\\,;\\, 127]$. Comme\n$150 > 127$, c'est encore insuffisant.\n"
            },
            {
              "text": "$9$",
              "correct": false,
              "feedback": "Erreur : $9$ bits suffisent largement (ils couvrent\njusqu'à $511$), mais ce n'est pas le **minimum**. Avec\n$8$ bits, on atteint déjà $255$, ce qui est suffisant\npour $150$.\n"
            }
          ],
          "explanation": "Méthode : chercher le plus petit $n$ tel que $2^n - 1 \\geq 150$,\nou de façon équivalente $2^n \\geq 151$. Ici, $2^{7} = 128$\net $2^{8} = 256$, donc le minimum est $n = 8$. De manière\nplus formelle, ce nombre est $\\lceil \\log_2(150 + 1) \\rceil = 8$."
        }
      ]
    },
    {
      "id": "q29",
      "difficulty": 2,
      "skills": [
        "intervalle",
        "dimensionnement"
      ],
      "title": "Plus grand entier non signé sur 32 bits",
      "partie": "limites",
      "statement": "Quel est le plus grand entier naturel (non signé) que l'on\npeut représenter sur $32$ bits ?",
      "options": [
        {
          "text": "$2 \\times 32$",
          "correct": false,
          "feedback": "Erreur : la quantité de valeurs codables croît de façon\n**exponentielle**, pas linéaire. Chaque bit\nsupplémentaire double le nombre de valeurs possibles.\n"
        },
        {
          "text": "$2^{32} - 1$",
          "correct": true,
          "feedback": "Bonne réponse : sur $n$ bits, le plus grand entier\nnaturel codable est $2^n - 1$. Pour $n = 32$, cela vaut\n$4\\,294\\,967\\,295$, soit environ $4{,}3 \\times 10^{9}$.\n"
        },
        {
          "text": "$2^{16}$",
          "correct": false,
          "feedback": "Erreur : $2^{16} - 1 = 65\\,535$ est le maximum sur\n$16$ bits, pas sur $32$. Doubler le nombre de bits\nélève le maximum à un carré (à un près), pas en double.\n"
        },
        {
          "text": "$2^{32}$",
          "correct": false,
          "feedback": "Erreur : on peut représenter $2^{32}$ valeurs\n**différentes** (de $0$ à $2^{32} - 1$), mais la valeur\n$2^{32}$ elle-même nécessiterait $33$ bits.\n"
        }
      ],
      "explanation": "Sur $n$ bits, l'intervalle des entiers naturels codables est\n$[0\\,;\\, 2^n - 1]$. Pour $32$ bits, cela donne environ\n$4{,}3 \\times 10^{9}$ valeurs. Les processeurs $32$ bits ne\npouvaient ainsi adresser directement que $4$ Go de mémoire\nvive.",
      "variants": [
        {
          "statement": "Quel est le plus grand entier naturel (non signé) que l'on\npeut représenter sur $32$ bits ?",
          "options": [
            {
              "text": "$2 \\times 32$",
              "correct": false,
              "feedback": "Erreur : la quantité de valeurs codables croît de façon\n**exponentielle**, pas linéaire. Chaque bit\nsupplémentaire double le nombre de valeurs possibles.\n"
            },
            {
              "text": "$2^{32} - 1$",
              "correct": true,
              "feedback": "Bonne réponse : sur $n$ bits, le plus grand entier\nnaturel codable est $2^n - 1$. Pour $n = 32$, cela vaut\n$4\\,294\\,967\\,295$, soit environ $4{,}3 \\times 10^{9}$.\n"
            },
            {
              "text": "$2^{16}$",
              "correct": false,
              "feedback": "Erreur : $2^{16} - 1 = 65\\,535$ est le maximum sur\n$16$ bits, pas sur $32$. Doubler le nombre de bits\nélève le maximum à un carré (à un près), pas en double.\n"
            },
            {
              "text": "$2^{32}$",
              "correct": false,
              "feedback": "Erreur : on peut représenter $2^{32}$ valeurs\n**différentes** (de $0$ à $2^{32} - 1$), mais la valeur\n$2^{32}$ elle-même nécessiterait $33$ bits.\n"
            }
          ],
          "explanation": "Sur $n$ bits, l'intervalle des entiers naturels codables est\n$[0\\,;\\, 2^n - 1]$. Pour $32$ bits, cela donne environ\n$4{,}3 \\times 10^{9}$ valeurs. Les processeurs $32$ bits ne\npouvaient ainsi adresser directement que $4$ Go de mémoire\nvive."
        },
        {
          "statement": "Quel est le plus grand entier naturel (non signé) que l'on\npeut représenter sur $16$ bits ?",
          "options": [
            {
              "text": "$2 \\times 16$",
              "correct": false,
              "feedback": "Erreur : la quantité de valeurs codables croît de façon\n**exponentielle**, pas linéaire. Chaque bit\nsupplémentaire double le nombre de valeurs possibles.\n"
            },
            {
              "text": "$2^{16} - 1$",
              "correct": true,
              "feedback": "Bonne réponse : sur $n$ bits, le plus grand entier\nnaturel codable est $2^n - 1$. Pour $n = 16$, cela vaut\n$65\\,535$, soit environ $6{,}6 \\times 10^{4}$.\n"
            },
            {
              "text": "$2^{8}$",
              "correct": false,
              "feedback": "Erreur : $2^{8} - 1 = 255$ est le maximum sur\n$8$ bits, pas sur $16$. Doubler le nombre de bits\nélève le maximum à un carré (à un près), pas en double.\n"
            },
            {
              "text": "$2^{16}$",
              "correct": false,
              "feedback": "Erreur : on peut représenter $2^{16}$ valeurs\n**différentes** (de $0$ à $2^{16} - 1$), mais la valeur\n$2^{16}$ elle-même nécessiterait $17$ bits.\n"
            }
          ],
          "explanation": "Sur $n$ bits, l'intervalle des entiers naturels codables est\n$[0\\,;\\, 2^n - 1]$. Pour $16$ bits, cela donne environ\n$6{,}6 \\times 10^{4}$ valeurs. Les processeurs $32$ bits ne\npouvaient ainsi adresser directement que $4$ Go de mémoire\nvive."
        },
        {
          "statement": "Quel est le plus grand entier naturel (non signé) que l'on\npeut représenter sur $64$ bits ?",
          "options": [
            {
              "text": "$2 \\times 64$",
              "correct": false,
              "feedback": "Erreur : la quantité de valeurs codables croît de façon\n**exponentielle**, pas linéaire. Chaque bit\nsupplémentaire double le nombre de valeurs possibles.\n"
            },
            {
              "text": "$2^{64} - 1$",
              "correct": true,
              "feedback": "Bonne réponse : sur $n$ bits, le plus grand entier\nnaturel codable est $2^n - 1$. Pour $n = 64$, cela vaut\n$18\\,446\\,744\\,073\\,709\\,551\\,615$, soit environ $1{,}8 \\times 10^{19}$.\n"
            },
            {
              "text": "$2^{32}$",
              "correct": false,
              "feedback": "Erreur : $2^{32} - 1 = 4\\,294\\,967\\,295$ est le maximum sur\n$32$ bits, pas sur $64$. Doubler le nombre de bits\nélève le maximum à un carré (à un près), pas en double.\n"
            },
            {
              "text": "$2^{64}$",
              "correct": false,
              "feedback": "Erreur : on peut représenter $2^{64}$ valeurs\n**différentes** (de $0$ à $2^{64} - 1$), mais la valeur\n$2^{64}$ elle-même nécessiterait $65$ bits.\n"
            }
          ],
          "explanation": "Sur $n$ bits, l'intervalle des entiers naturels codables est\n$[0\\,;\\, 2^n - 1]$. Pour $64$ bits, cela donne environ\n$1{,}8 \\times 10^{19}$ valeurs. Les processeurs $32$ bits ne\npouvaient ainsi adresser directement que $4$ Go de mémoire\nvive."
        }
      ]
    },
    {
      "id": "q30",
      "difficulty": 2,
      "skills": [
        "dimensionnement",
        "somme",
        "bits"
      ],
      "title": "Bits nécessaires à une somme",
      "partie": "limites",
      "statement": "Deux entiers naturels s'écrivent chacun sur $8$ bits\nau plus. Sur combien de bits au plus s'écrit leur\nsomme ?",
      "options": [
        {
          "text": "$8$ bits",
          "correct": false,
          "feedback": "$255 + 255 = 510$ dépasse $255$, le plus\ngrand entier sur $8$ bits.\n"
        },
        {
          "text": "$9$ bits",
          "correct": true,
          "feedback": "La somme vaut au plus $510$, inférieure à\n$2^{9} = 512$ : $9$ bits suffisent toujours.\n"
        },
        {
          "text": "$10$ bits",
          "correct": false,
          "feedback": "$9$ bits suffisent déjà ; un bit de plus n'est\njamais nécessaire.\n"
        },
        {
          "text": "$16$ bits",
          "correct": false,
          "feedback": "$16$ bits correspondent au produit, pas à la\nsomme.\n"
        }
      ],
      "explanation": "Additionner deux nombres de $n$ bits donne au plus\n$2 \\cdot (2^n - 1) = 2^{n+1} - 2$, qui tient sur\n$n + 1$ bits. Une retenue finale au plus : un seul\nbit supplémentaire.",
      "variants": [
        {
          "statement": "Deux entiers naturels s'écrivent chacun sur $8$ bits\nau plus. Sur combien de bits au plus s'écrit leur\nsomme ?",
          "options": [
            {
              "text": "$8$ bits",
              "correct": false,
              "feedback": "$255 + 255 = 510$ dépasse $255$, le plus\ngrand entier sur $8$ bits.\n"
            },
            {
              "text": "$9$ bits",
              "correct": true,
              "feedback": "La somme vaut au plus $510$, inférieure à\n$2^{9} = 512$ : $9$ bits suffisent toujours.\n"
            },
            {
              "text": "$10$ bits",
              "correct": false,
              "feedback": "$9$ bits suffisent déjà ; un bit de plus n'est\njamais nécessaire.\n"
            },
            {
              "text": "$16$ bits",
              "correct": false,
              "feedback": "$16$ bits correspondent au produit, pas à la\nsomme.\n"
            }
          ],
          "explanation": "Additionner deux nombres de $n$ bits donne au plus\n$2 \\cdot (2^n - 1) = 2^{n+1} - 2$, qui tient sur\n$n + 1$ bits. Une retenue finale au plus : un seul\nbit supplémentaire."
        },
        {
          "statement": "Deux entiers naturels s'écrivent chacun sur $16$ bits\nau plus. Sur combien de bits au plus s'écrit leur\nsomme ?",
          "options": [
            {
              "text": "$16$ bits",
              "correct": false,
              "feedback": "$65\\,535 + 65\\,535 = 131\\,070$ dépasse $65\\,535$, le plus\ngrand entier sur $16$ bits.\n"
            },
            {
              "text": "$17$ bits",
              "correct": true,
              "feedback": "La somme vaut au plus $131\\,070$, inférieure à\n$2^{17} = 131\\,072$ : $17$ bits suffisent toujours.\n"
            },
            {
              "text": "$18$ bits",
              "correct": false,
              "feedback": "$17$ bits suffisent déjà ; un bit de plus n'est\njamais nécessaire.\n"
            },
            {
              "text": "$32$ bits",
              "correct": false,
              "feedback": "$32$ bits correspondent au produit, pas à la\nsomme.\n"
            }
          ],
          "explanation": "Additionner deux nombres de $n$ bits donne au plus\n$2 \\cdot (2^n - 1) = 2^{n+1} - 2$, qui tient sur\n$n + 1$ bits. Une retenue finale au plus : un seul\nbit supplémentaire."
        },
        {
          "statement": "Deux entiers naturels s'écrivent chacun sur $12$ bits\nau plus. Sur combien de bits au plus s'écrit leur\nsomme ?",
          "options": [
            {
              "text": "$12$ bits",
              "correct": false,
              "feedback": "$4\\,095 + 4\\,095 = 8\\,190$ dépasse $4\\,095$, le plus\ngrand entier sur $12$ bits.\n"
            },
            {
              "text": "$13$ bits",
              "correct": true,
              "feedback": "La somme vaut au plus $8\\,190$, inférieure à\n$2^{13} = 8\\,192$ : $13$ bits suffisent toujours.\n"
            },
            {
              "text": "$14$ bits",
              "correct": false,
              "feedback": "$13$ bits suffisent déjà ; un bit de plus n'est\njamais nécessaire.\n"
            },
            {
              "text": "$24$ bits",
              "correct": false,
              "feedback": "$24$ bits correspondent au produit, pas à la\nsomme.\n"
            }
          ],
          "explanation": "Additionner deux nombres de $n$ bits donne au plus\n$2 \\cdot (2^n - 1) = 2^{n+1} - 2$, qui tient sur\n$n + 1$ bits. Une retenue finale au plus : un seul\nbit supplémentaire."
        }
      ]
    },
    {
      "id": "q31",
      "difficulty": 2,
      "skills": [
        "dimensionnement",
        "produit",
        "bits"
      ],
      "title": "Bits nécessaires à un produit",
      "partie": "limites",
      "statement": "Deux entiers naturels s'écrivent chacun sur $8$ bits\nau plus. Sur combien de bits au plus s'écrit leur\nproduit ?",
      "options": [
        {
          "text": "$9$ bits",
          "correct": false,
          "feedback": "$9$ bits suffisent pour la somme ; le produit\ngrandit bien plus vite.\n"
        },
        {
          "text": "$16$ bits",
          "correct": true,
          "feedback": "$255 \\times 255 = 65\\,025 < 2^{16} = 65\\,536$ :\n$16$ bits suffisent toujours.\n"
        },
        {
          "text": "$64$ bits",
          "correct": false,
          "feedback": "$16$ bits suffisent ; $64$ bits seraient\nun gaspillage sans justification.\n"
        },
        {
          "text": "$8$ bits",
          "correct": false,
          "feedback": "$255 \\times 255$ dépasse de loin $255$.\n"
        }
      ],
      "explanation": "Multiplier deux nombres de $n$ bits donne au plus\n$(2^n - 1)^2 < 2^{2n}$ : le produit tient sur $2n$\nbits. C'est pourquoi multiplier deux entiers de\n$32$ bits peut exiger $64$ bits.",
      "variants": [
        {
          "statement": "Deux entiers naturels s'écrivent chacun sur $8$ bits\nau plus. Sur combien de bits au plus s'écrit leur\nproduit ?",
          "options": [
            {
              "text": "$9$ bits",
              "correct": false,
              "feedback": "$9$ bits suffisent pour la somme ; le produit\ngrandit bien plus vite.\n"
            },
            {
              "text": "$16$ bits",
              "correct": true,
              "feedback": "$255 \\times 255 = 65\\,025 < 2^{16} = 65\\,536$ :\n$16$ bits suffisent toujours.\n"
            },
            {
              "text": "$64$ bits",
              "correct": false,
              "feedback": "$16$ bits suffisent ; $64$ bits seraient\nun gaspillage sans justification.\n"
            },
            {
              "text": "$8$ bits",
              "correct": false,
              "feedback": "$255 \\times 255$ dépasse de loin $255$.\n"
            }
          ],
          "explanation": "Multiplier deux nombres de $n$ bits donne au plus\n$(2^n - 1)^2 < 2^{2n}$ : le produit tient sur $2n$\nbits. C'est pourquoi multiplier deux entiers de\n$32$ bits peut exiger $64$ bits."
        },
        {
          "statement": "Deux entiers naturels s'écrivent chacun sur $16$ bits\nau plus. Sur combien de bits au plus s'écrit leur\nproduit ?",
          "options": [
            {
              "text": "$17$ bits",
              "correct": false,
              "feedback": "$17$ bits suffisent pour la somme ; le produit\ngrandit bien plus vite.\n"
            },
            {
              "text": "$32$ bits",
              "correct": true,
              "feedback": "$65\\,535 \\times 65\\,535 = 4\\,294\\,836\\,225 < 2^{32} = 4\\,294\\,967\\,296$ :\n$32$ bits suffisent toujours.\n"
            },
            {
              "text": "$128$ bits",
              "correct": false,
              "feedback": "$32$ bits suffisent ; $128$ bits seraient\nun gaspillage sans justification.\n"
            },
            {
              "text": "$16$ bits",
              "correct": false,
              "feedback": "$65\\,535 \\times 65\\,535$ dépasse de loin $65\\,535$.\n"
            }
          ],
          "explanation": "Multiplier deux nombres de $n$ bits donne au plus\n$(2^n - 1)^2 < 2^{2n}$ : le produit tient sur $2n$\nbits. C'est pourquoi multiplier deux entiers de\n$32$ bits peut exiger $64$ bits."
        },
        {
          "statement": "Deux entiers naturels s'écrivent chacun sur $12$ bits\nau plus. Sur combien de bits au plus s'écrit leur\nproduit ?",
          "options": [
            {
              "text": "$13$ bits",
              "correct": false,
              "feedback": "$13$ bits suffisent pour la somme ; le produit\ngrandit bien plus vite.\n"
            },
            {
              "text": "$24$ bits",
              "correct": true,
              "feedback": "$4\\,095 \\times 4\\,095 = 16\\,769\\,025 < 2^{24} = 16\\,777\\,216$ :\n$24$ bits suffisent toujours.\n"
            },
            {
              "text": "$96$ bits",
              "correct": false,
              "feedback": "$24$ bits suffisent ; $96$ bits seraient\nun gaspillage sans justification.\n"
            },
            {
              "text": "$12$ bits",
              "correct": false,
              "feedback": "$4\\,095 \\times 4\\,095$ dépasse de loin $4\\,095$.\n"
            }
          ],
          "explanation": "Multiplier deux nombres de $n$ bits donne au plus\n$(2^n - 1)^2 < 2^{2n}$ : le produit tient sur $2n$\nbits. C'est pourquoi multiplier deux entiers de\n$32$ bits peut exiger $64$ bits."
        }
      ]
    },
    {
      "id": "q32",
      "difficulty": 3,
      "skills": [
        "dimensionnement",
        "produit",
        "conversion",
        "calcul"
      ],
      "title": "Taille du produit de deux nombres binaires",
      "partie": "limites",
      "statement": "Soit $a = 1101_2$ et $b = 1010_2$. Sur combien de\nbits s'écrit exactement le produit $a \\times b$ ?",
      "options": [
        {
          "text": "$8$ bits",
          "correct": true,
          "feedback": "$a = 13$, $b = 10$, $a \\times b = 130 =\n10000010_2$ : $8$ bits.\n"
        },
        {
          "text": "$4$ bits",
          "correct": false,
          "feedback": "Un produit de deux nombres de quatre bits dépasse\npresque toujours $15$.\n"
        },
        {
          "text": "$7$ bits",
          "correct": false,
          "feedback": "$130$ dépasse $127 = 2^{7} - 1$, le plus grand\nentier sur $7$ bits.\n"
        },
        {
          "text": "$16$ bits",
          "correct": false,
          "feedback": "Seize bits serait la borne pour des facteurs de\nhuit bits ; ici les facteurs ont quatre bits et\n$130 < 256$.\n"
        }
      ],
      "explanation": "Convertir, multiplier, reconvertir : $13 \\times 10 =\n130$, et $128 \\le 130 < 256$ place le\nrésultat entre $2^{7}$ et $2^{8}$, donc sur $8$\nbits. La borne générale ($2n$ bits pour deux facteurs\nde $n$ bits) est atteinte ici.",
      "variants": [
        {
          "statement": "Soit $a = 1101_2$ et $b = 1010_2$. Sur combien de\nbits s'écrit exactement le produit $a \\times b$ ?",
          "options": [
            {
              "text": "$8$ bits",
              "correct": true,
              "feedback": "$a = 13$, $b = 10$, $a \\times b = 130 =\n10000010_2$ : $8$ bits.\n"
            },
            {
              "text": "$4$ bits",
              "correct": false,
              "feedback": "Un produit de deux nombres de quatre bits dépasse\npresque toujours $15$.\n"
            },
            {
              "text": "$7$ bits",
              "correct": false,
              "feedback": "$130$ dépasse $127 = 2^{7} - 1$, le plus grand\nentier sur $7$ bits.\n"
            },
            {
              "text": "$16$ bits",
              "correct": false,
              "feedback": "Seize bits serait la borne pour des facteurs de\nhuit bits ; ici les facteurs ont quatre bits et\n$130 < 256$.\n"
            }
          ],
          "explanation": "Convertir, multiplier, reconvertir : $13 \\times 10 =\n130$, et $128 \\le 130 < 256$ place le\nrésultat entre $2^{7}$ et $2^{8}$, donc sur $8$\nbits. La borne générale ($2n$ bits pour deux facteurs\nde $n$ bits) est atteinte ici."
        },
        {
          "statement": "Soit $a = 1110_2$ et $b = 1001_2$. Sur combien de\nbits s'écrit exactement le produit $a \\times b$ ?",
          "options": [
            {
              "text": "$7$ bits",
              "correct": true,
              "feedback": "$a = 14$, $b = 9$, $a \\times b = 126 =\n1111110_2$ : $7$ bits.\n"
            },
            {
              "text": "$4$ bits",
              "correct": false,
              "feedback": "Un produit de deux nombres de quatre bits dépasse\npresque toujours $15$.\n"
            },
            {
              "text": "$6$ bits",
              "correct": false,
              "feedback": "$126$ dépasse $63 = 2^{6} - 1$, le plus grand\nentier sur $6$ bits.\n"
            },
            {
              "text": "$16$ bits",
              "correct": false,
              "feedback": "Seize bits serait la borne pour des facteurs de\nhuit bits ; ici les facteurs ont quatre bits et\n$126 < 256$.\n"
            }
          ],
          "explanation": "Convertir, multiplier, reconvertir : $14 \\times 9 =\n126$, et $64 \\le 126 < 128$ place le\nrésultat entre $2^{6}$ et $2^{7}$, donc sur $7$\nbits. La borne générale ($2n$ bits pour deux facteurs\nde $n$ bits) n’est pas atteinte ici."
        },
        {
          "statement": "Soit $a = 1001_2$ et $b = 0111_2$. Sur combien de\nbits s'écrit exactement le produit $a \\times b$ ?",
          "options": [
            {
              "text": "$6$ bits",
              "correct": true,
              "feedback": "$a = 9$, $b = 7$, $a \\times b = 63 =\n111111_2$ : $6$ bits.\n"
            },
            {
              "text": "$4$ bits",
              "correct": false,
              "feedback": "Un produit de deux nombres de quatre bits dépasse\npresque toujours $15$.\n"
            },
            {
              "text": "$5$ bits",
              "correct": false,
              "feedback": "$63$ dépasse $31 = 2^{5} - 1$, le plus grand\nentier sur $5$ bits.\n"
            },
            {
              "text": "$16$ bits",
              "correct": false,
              "feedback": "Seize bits serait la borne pour des facteurs de\nhuit bits ; ici les facteurs ont quatre bits et\n$63 < 256$.\n"
            }
          ],
          "explanation": "Convertir, multiplier, reconvertir : $9 \\times 7 =\n63$, et $32 \\le 63 < 64$ place le\nrésultat entre $2^{5}$ et $2^{6}$, donc sur $6$\nbits. La borne générale ($2n$ bits pour deux facteurs\nde $n$ bits) n’est pas atteinte ici."
        }
      ]
    },
    {
      "id": "q33",
      "difficulty": 2,
      "skills": [
        "complement-a-deux",
        "poids-fort",
        "lecture"
      ],
      "title": "Le poids du bit de signe",
      "partie": "complement",
      "statement": "En complément à deux sur $8$ bits, le bit de poids fort pèse $-128$\nau lieu de $+128$. Que vaut l'octet $10000011_2$ ?",
      "options": [
        {
          "text": "$-125$",
          "correct": true,
          "feedback": "Bonne réponse : $-128 + 3 = -125$. Les sept autres bits gardent\nleurs poids habituels, seul le premier est négatif.\n"
        },
        {
          "text": "$131$",
          "correct": false,
          "feedback": "Erreur : c'est la valeur non signée, avec un bit de poids fort\nà $+128$. En complément à deux, ce bit vaut $-128$.\n"
        },
        {
          "text": "$-3$",
          "correct": false,
          "feedback": "Erreur : le bit de poids fort n'est pas un simple signe devant\nles autres bits ; il pèse $-128$, ce qui donne $-128 + 3$.\n"
        },
        {
          "text": "$3$",
          "correct": false,
          "feedback": "Erreur : $3$ est la valeur des sept bits de droite, il reste à\najouter le poids $-128$ du premier bit.\n"
        }
      ],
      "explanation": "Lire un entier signé revient à une lecture positionnelle ordinaire\noù le bit de poids fort compte négativement : c'est ce qui rend\nl'addition binaire valable pour tous les signes.",
      "variants": [
        {
          "statement": "En complément à deux sur $8$ bits, le bit de poids fort pèse $-128$\nau lieu de $+128$. Que vaut l'octet $10000011_2$ ?",
          "options": [
            {
              "text": "$-125$",
              "correct": true,
              "feedback": "Bonne réponse : $-128 + 3 = -125$. Les sept autres bits gardent\nleurs poids habituels, seul le premier est négatif.\n"
            },
            {
              "text": "$131$",
              "correct": false,
              "feedback": "Erreur : c'est la valeur non signée, avec un bit de poids fort\nà $+128$. En complément à deux, ce bit vaut $-128$.\n"
            },
            {
              "text": "$-3$",
              "correct": false,
              "feedback": "Erreur : le bit de poids fort n'est pas un simple signe devant\nles autres bits ; il pèse $-128$, ce qui donne $-128 + 3$.\n"
            },
            {
              "text": "$3$",
              "correct": false,
              "feedback": "Erreur : $3$ est la valeur des sept bits de droite, il reste à\najouter le poids $-128$ du premier bit.\n"
            }
          ],
          "explanation": "Lire un entier signé revient à une lecture positionnelle ordinaire\noù le bit de poids fort compte négativement : c'est ce qui rend\nl'addition binaire valable pour tous les signes."
        },
        {
          "statement": "En complément à deux sur $8$ bits, le bit de poids fort pèse $-128$\nau lieu de $+128$. Que vaut l'octet $10010000_2$ ?",
          "options": [
            {
              "text": "$-112$",
              "correct": true,
              "feedback": "Bonne réponse : $-128 + 16 = -112$. Les sept autres bits gardent\nleurs poids habituels, seul le premier est négatif.\n"
            },
            {
              "text": "$144$",
              "correct": false,
              "feedback": "Erreur : c'est la valeur non signée, avec un bit de poids fort\nà $+128$. En complément à deux, ce bit vaut $-128$.\n"
            },
            {
              "text": "$-16$",
              "correct": false,
              "feedback": "Erreur : le bit de poids fort n'est pas un simple signe devant\nles autres bits ; il pèse $-128$, ce qui donne $-128 + 16$.\n"
            },
            {
              "text": "$16$",
              "correct": false,
              "feedback": "Erreur : $16$ est la valeur des sept bits de droite, il reste à\najouter le poids $-128$ du premier bit.\n"
            }
          ],
          "explanation": "Lire un entier signé revient à une lecture positionnelle ordinaire\noù le bit de poids fort compte négativement : c'est ce qui rend\nl'addition binaire valable pour tous les signes."
        },
        {
          "statement": "En complément à deux sur $8$ bits, le bit de poids fort pèse $-128$\nau lieu de $+128$. Que vaut l'octet $11111001_2$ ?",
          "options": [
            {
              "text": "$-7$",
              "correct": true,
              "feedback": "Bonne réponse : $-128 + 121 = -7$. Les sept autres bits gardent\nleurs poids habituels, seul le premier est négatif.\n"
            },
            {
              "text": "$249$",
              "correct": false,
              "feedback": "Erreur : c'est la valeur non signée, avec un bit de poids fort\nà $+128$. En complément à deux, ce bit vaut $-128$.\n"
            },
            {
              "text": "$-121$",
              "correct": false,
              "feedback": "Erreur : le bit de poids fort n'est pas un simple signe devant\nles autres bits ; il pèse $-128$, ce qui donne $-128 + 121$.\n"
            },
            {
              "text": "$121$",
              "correct": false,
              "feedback": "Erreur : $121$ est la valeur des sept bits de droite, il reste à\najouter le poids $-128$ du premier bit.\n"
            }
          ],
          "explanation": "Lire un entier signé revient à une lecture positionnelle ordinaire\noù le bit de poids fort compte négativement : c'est ce qui rend\nl'addition binaire valable pour tous les signes."
        }
      ]
    },
    {
      "id": "q34",
      "difficulty": 3,
      "skills": [
        "complement-a-deux",
        "addition",
        "calcul"
      ],
      "title": "Une addition avec un nombre négatif",
      "partie": "complement",
      "statement": "Sur $8$ bits en complément à deux, on additionne $3$, codé\n$00000011_2$, et $-5$, codé $11111011_2$, en ignorant une éventuelle\nretenue sortante. Quel est le résultat ?",
      "options": [
        {
          "text": "$11111110_2$, soit $-2$",
          "correct": true,
          "feedback": "Bonne réponse : l'addition binaire ordinaire donne $11111110_2$\nune fois la retenue sortante écartée, et cet octet se lit\n$-2$ en complément à deux. Le même circuit sert aux deux\nsignes.\n"
        },
        {
          "text": "$00001000_2$, soit $8$",
          "correct": false,
          "feedback": "Erreur : $8$ serait $3 + 5$. Le second opérande est\n$-5$, et son codage en complément à deux fait bien soustraire.\n"
        },
        {
          "text": "$11111110_2$, soit $8$",
          "correct": false,
          "feedback": "Erreur : l'octet est correct mais sa lecture non. En complément\nà deux, $11111110_2$ vaut $-2$.\n"
        },
        {
          "text": "Une erreur, les nombres négatifs ne s'additionnant pas en binaire",
          "correct": false,
          "feedback": "Erreur : c'est tout l'intérêt du complément à deux : la même\naddition fonctionne quel que soit le signe des opérandes.\n"
        }
      ],
      "explanation": "En complément à deux, soustraire revient à additionner l'opposé.\nLa retenue qui sort du huitième bit est ignorée, et le résultat se\nlit avec le bit de poids fort à $-128$.",
      "variants": [
        {
          "statement": "Sur $8$ bits en complément à deux, on additionne $3$, codé\n$00000011_2$, et $-5$, codé $11111011_2$, en ignorant une éventuelle\nretenue sortante. Quel est le résultat ?",
          "options": [
            {
              "text": "$11111110_2$, soit $-2$",
              "correct": true,
              "feedback": "Bonne réponse : l'addition binaire ordinaire donne $11111110_2$\nune fois la retenue sortante écartée, et cet octet se lit\n$-2$ en complément à deux. Le même circuit sert aux deux\nsignes.\n"
            },
            {
              "text": "$00001000_2$, soit $8$",
              "correct": false,
              "feedback": "Erreur : $8$ serait $3 + 5$. Le second opérande est\n$-5$, et son codage en complément à deux fait bien soustraire.\n"
            },
            {
              "text": "$11111110_2$, soit $8$",
              "correct": false,
              "feedback": "Erreur : l'octet est correct mais sa lecture non. En complément\nà deux, $11111110_2$ vaut $-2$.\n"
            },
            {
              "text": "Une erreur, les nombres négatifs ne s'additionnant pas en binaire",
              "correct": false,
              "feedback": "Erreur : c'est tout l'intérêt du complément à deux : la même\naddition fonctionne quel que soit le signe des opérandes.\n"
            }
          ],
          "explanation": "En complément à deux, soustraire revient à additionner l'opposé.\nLa retenue qui sort du huitième bit est ignorée, et le résultat se\nlit avec le bit de poids fort à $-128$."
        },
        {
          "statement": "Sur $8$ bits en complément à deux, on additionne $10$, codé\n$00001010_2$, et $-4$, codé $11111100_2$, en ignorant une éventuelle\nretenue sortante. Quel est le résultat ?",
          "options": [
            {
              "text": "$00000110_2$, soit $6$",
              "correct": true,
              "feedback": "Bonne réponse : l'addition binaire ordinaire donne $00000110_2$\nune fois la retenue sortante écartée, et cet octet se lit\n$6$ en complément à deux. Le même circuit sert aux deux\nsignes.\n"
            },
            {
              "text": "$00001110_2$, soit $14$",
              "correct": false,
              "feedback": "Erreur : $14$ serait $10 + 4$. Le second opérande est\n$-4$, et son codage en complément à deux fait bien soustraire.\n"
            },
            {
              "text": "$00000110_2$, soit $14$",
              "correct": false,
              "feedback": "Erreur : l'octet est correct mais sa lecture non. En complément\nà deux, $00000110_2$ vaut $6$.\n"
            },
            {
              "text": "Une erreur, les nombres négatifs ne s'additionnant pas en binaire",
              "correct": false,
              "feedback": "Erreur : c'est tout l'intérêt du complément à deux : la même\naddition fonctionne quel que soit le signe des opérandes.\n"
            }
          ],
          "explanation": "En complément à deux, soustraire revient à additionner l'opposé.\nLa retenue qui sort du huitième bit est ignorée, et le résultat se\nlit avec le bit de poids fort à $-128$."
        },
        {
          "statement": "Sur $8$ bits en complément à deux, on additionne $2$, codé\n$00000010_2$, et $-9$, codé $11110111_2$, en ignorant une éventuelle\nretenue sortante. Quel est le résultat ?",
          "options": [
            {
              "text": "$11111001_2$, soit $-7$",
              "correct": true,
              "feedback": "Bonne réponse : l'addition binaire ordinaire donne $11111001_2$\nune fois la retenue sortante écartée, et cet octet se lit\n$-7$ en complément à deux. Le même circuit sert aux deux\nsignes.\n"
            },
            {
              "text": "$00001011_2$, soit $11$",
              "correct": false,
              "feedback": "Erreur : $11$ serait $2 + 9$. Le second opérande est\n$-9$, et son codage en complément à deux fait bien soustraire.\n"
            },
            {
              "text": "$11111001_2$, soit $11$",
              "correct": false,
              "feedback": "Erreur : l'octet est correct mais sa lecture non. En complément\nà deux, $11111001_2$ vaut $-7$.\n"
            },
            {
              "text": "Une erreur, les nombres négatifs ne s'additionnant pas en binaire",
              "correct": false,
              "feedback": "Erreur : c'est tout l'intérêt du complément à deux : la même\naddition fonctionne quel que soit le signe des opérandes.\n"
            }
          ],
          "explanation": "En complément à deux, soustraire revient à additionner l'opposé.\nLa retenue qui sort du huitième bit est ignorée, et le résultat se\nlit avec le bit de poids fort à $-128$."
        }
      ]
    },
    {
      "id": "q35",
      "difficulty": 2,
      "skills": [
        "hexadecimal",
        "conversion",
        "decimal"
      ],
      "title": "Conversion hexadécimal vers décimal",
      "partie": "hexadecimal",
      "statement": "Que vaut $2F_{16}$ en décimal ?",
      "options": [
        {
          "text": "$47$",
          "correct": true,
          "feedback": "Bonne réponse : $2 \\times 16 + 15 = 47$. Chaque chiffre\nhexadécimal pèse une puissance de $16$.\n"
        },
        {
          "text": "$215$",
          "correct": false,
          "feedback": "Erreur : les chiffres ont été convertis séparément puis collés.\nIl faut pondérer le premier par $16$.\n"
        },
        {
          "text": "$242$",
          "correct": false,
          "feedback": "Erreur : les poids sont inversés. Le chiffre de gauche est celui\ndes seizaines.\n"
        },
        {
          "text": "$17$",
          "correct": false,
          "feedback": "Erreur : les chiffres ne s'additionnent pas simplement, le\npremier vaut $2 \\times 16$.\n"
        }
      ],
      "explanation": "En base $16$, les positions valent $1$, $16$, $256$, et ainsi de\nsuite, et les chiffres de $A$ à $F$ valent $10$ à $15$.",
      "variants": [
        {
          "statement": "Que vaut $2F_{16}$ en décimal ?",
          "options": [
            {
              "text": "$47$",
              "correct": true,
              "feedback": "Bonne réponse : $2 \\times 16 + 15 = 47$. Chaque chiffre\nhexadécimal pèse une puissance de $16$.\n"
            },
            {
              "text": "$215$",
              "correct": false,
              "feedback": "Erreur : les chiffres ont été convertis séparément puis collés.\nIl faut pondérer le premier par $16$.\n"
            },
            {
              "text": "$242$",
              "correct": false,
              "feedback": "Erreur : les poids sont inversés. Le chiffre de gauche est celui\ndes seizaines.\n"
            },
            {
              "text": "$17$",
              "correct": false,
              "feedback": "Erreur : les chiffres ne s'additionnent pas simplement, le\npremier vaut $2 \\times 16$.\n"
            }
          ],
          "explanation": "En base $16$, les positions valent $1$, $16$, $256$, et ainsi de\nsuite, et les chiffres de $A$ à $F$ valent $10$ à $15$."
        },
        {
          "statement": "Que vaut $A3_{16}$ en décimal ?",
          "options": [
            {
              "text": "$163$",
              "correct": true,
              "feedback": "Bonne réponse : $10 \\times 16 + 3 = 163$. Chaque chiffre\nhexadécimal pèse une puissance de $16$.\n"
            },
            {
              "text": "$103$",
              "correct": false,
              "feedback": "Erreur : les chiffres ont été convertis séparément puis collés.\nIl faut pondérer le premier par $16$.\n"
            },
            {
              "text": "$58$",
              "correct": false,
              "feedback": "Erreur : les poids sont inversés. Le chiffre de gauche est celui\ndes seizaines.\n"
            },
            {
              "text": "$13$",
              "correct": false,
              "feedback": "Erreur : les chiffres ne s'additionnent pas simplement, le\npremier vaut $10 \\times 16$.\n"
            }
          ],
          "explanation": "En base $16$, les positions valent $1$, $16$, $256$, et ainsi de\nsuite, et les chiffres de $A$ à $F$ valent $10$ à $15$."
        },
        {
          "statement": "Que vaut $7C_{16}$ en décimal ?",
          "options": [
            {
              "text": "$124$",
              "correct": true,
              "feedback": "Bonne réponse : $7 \\times 16 + 12 = 124$. Chaque chiffre\nhexadécimal pèse une puissance de $16$.\n"
            },
            {
              "text": "$712$",
              "correct": false,
              "feedback": "Erreur : les chiffres ont été convertis séparément puis collés.\nIl faut pondérer le premier par $16$.\n"
            },
            {
              "text": "$199$",
              "correct": false,
              "feedback": "Erreur : les poids sont inversés. Le chiffre de gauche est celui\ndes seizaines.\n"
            },
            {
              "text": "$19$",
              "correct": false,
              "feedback": "Erreur : les chiffres ne s'additionnent pas simplement, le\npremier vaut $7 \\times 16$.\n"
            }
          ],
          "explanation": "En base $16$, les positions valent $1$, $16$, $256$, et ainsi de\nsuite, et les chiffres de $A$ à $F$ valent $10$ à $15$."
        }
      ]
    },
    {
      "id": "q36",
      "difficulty": 1,
      "skills": [
        "hexadecimal",
        "usage"
      ],
      "title": "Intérêt de l'écriture hexadécimale",
      "partie": "hexadecimal",
      "statement": "Pourquoi les adresses mémoire ou les codes de couleurs sont-ils\nsouvent écrits en hexadécimal plutôt qu'en binaire ?",
      "options": [
        {
          "text": "Parce qu'un chiffre hexadécimal remplace exactement quatre bits",
          "correct": true,
          "feedback": "Bonne réponse : l'écriture est quatre fois plus courte et la\nconversion avec le binaire se fait chiffre par chiffre, sans\ncalcul.\n"
        },
        {
          "text": "Parce que les processeurs calculent nativement en base seize",
          "correct": false,
          "feedback": "Erreur : les circuits travaillent en binaire. L'hexadécimal est\nune notation pour les humains.\n"
        },
        {
          "text": "Parce que l'hexadécimal permet de coder des nombres plus grands",
          "correct": false,
          "feedback": "Erreur : la base ne change pas les valeurs codables, seulement\nla longueur de leur écriture.\n"
        },
        {
          "text": "Parce que les lettres de A à F rendent les nombres plus lisibles",
          "correct": false,
          "feedback": "Erreur : les lettres ne sont qu'un moyen d'avoir seize symboles ;\nl'avantage vient de la correspondance avec les groupes de quatre\nbits.\n"
        }
      ],
      "explanation": "Seize est une puissance de deux : chaque chiffre hexadécimal\ncorrespond à un groupe de quatre bits, d'où une notation compacte\net facile à convertir."
    },
    {
      "id": "q37",
      "difficulty": 2,
      "skills": [
        "binaire",
        "multiplication",
        "decalage"
      ],
      "title": "Multiplier par deux en binaire",
      "partie": "bases",
      "statement": "Que vaut $1011_2 \\times 2$, en binaire ?",
      "options": [
        {
          "text": "$10110_2$",
          "correct": true,
          "feedback": "Bonne réponse : multiplier par deux décale tous les chiffres\nd'un rang vers la gauche et ajoute un $0$ à droite, comme\nmultiplier par dix ajoute un $0$ en décimal.\n"
        },
        {
          "text": "$1100_2$",
          "correct": false,
          "feedback": "Erreur : c'est $1011_2 + 1$. Multiplier par deux ne consiste pas\nà ajouter un.\n"
        },
        {
          "text": "$101_2$",
          "correct": false,
          "feedback": "Erreur : retirer le dernier chiffre divise par deux, au lieu de\nmultiplier.\n"
        },
        {
          "text": "$10111_2$",
          "correct": false,
          "feedback": "Erreur : le chiffre ajouté à droite est un $0$, pas un $1$. Un\nnombre pair se termine toujours par $0$ en binaire.\n"
        }
      ],
      "explanation": "En base deux, multiplier par $2$ revient à ajouter un $0$ à droite,\nexactement comme multiplier par $10$ en base dix.",
      "variants": [
        {
          "statement": "Que vaut $1011_2 \\times 2$, en binaire ?",
          "options": [
            {
              "text": "$10110_2$",
              "correct": true,
              "feedback": "Bonne réponse : multiplier par deux décale tous les chiffres\nd'un rang vers la gauche et ajoute un $0$ à droite, comme\nmultiplier par dix ajoute un $0$ en décimal.\n"
            },
            {
              "text": "$1100_2$",
              "correct": false,
              "feedback": "Erreur : c'est $1011_2 + 1$. Multiplier par deux ne consiste pas\nà ajouter un.\n"
            },
            {
              "text": "$101_2$",
              "correct": false,
              "feedback": "Erreur : retirer le dernier chiffre divise par deux, au lieu de\nmultiplier.\n"
            },
            {
              "text": "$10111_2$",
              "correct": false,
              "feedback": "Erreur : le chiffre ajouté à droite est un $0$, pas un $1$. Un\nnombre pair se termine toujours par $0$ en binaire.\n"
            }
          ],
          "explanation": "En base deux, multiplier par $2$ revient à ajouter un $0$ à droite,\nexactement comme multiplier par $10$ en base dix."
        },
        {
          "statement": "Que vaut $110_2 \\times 2$, en binaire ?",
          "options": [
            {
              "text": "$1100_2$",
              "correct": true,
              "feedback": "Bonne réponse : multiplier par deux décale tous les chiffres\nd'un rang vers la gauche et ajoute un $0$ à droite, comme\nmultiplier par dix ajoute un $0$ en décimal.\n"
            },
            {
              "text": "$111_2$",
              "correct": false,
              "feedback": "Erreur : c'est $110_2 + 1$. Multiplier par deux ne consiste pas\nà ajouter un.\n"
            },
            {
              "text": "$11_2$",
              "correct": false,
              "feedback": "Erreur : retirer le dernier chiffre divise par deux, au lieu de\nmultiplier.\n"
            },
            {
              "text": "$1101_2$",
              "correct": false,
              "feedback": "Erreur : le chiffre ajouté à droite est un $0$, pas un $1$. Un\nnombre pair se termine toujours par $0$ en binaire.\n"
            }
          ],
          "explanation": "En base deux, multiplier par $2$ revient à ajouter un $0$ à droite,\nexactement comme multiplier par $10$ en base dix."
        },
        {
          "statement": "Que vaut $1101_2 \\times 2$, en binaire ?",
          "options": [
            {
              "text": "$11010_2$",
              "correct": true,
              "feedback": "Bonne réponse : multiplier par deux décale tous les chiffres\nd'un rang vers la gauche et ajoute un $0$ à droite, comme\nmultiplier par dix ajoute un $0$ en décimal.\n"
            },
            {
              "text": "$1110_2$",
              "correct": false,
              "feedback": "Erreur : c'est $1101_2 + 1$. Multiplier par deux ne consiste pas\nà ajouter un.\n"
            },
            {
              "text": "$110_2$",
              "correct": false,
              "feedback": "Erreur : retirer le dernier chiffre divise par deux, au lieu de\nmultiplier.\n"
            },
            {
              "text": "$11011_2$",
              "correct": false,
              "feedback": "Erreur : le chiffre ajouté à droite est un $0$, pas un $1$. Un\nnombre pair se termine toujours par $0$ en binaire.\n"
            }
          ],
          "explanation": "En base deux, multiplier par $2$ revient à ajouter un $0$ à droite,\nexactement comme multiplier par $10$ en base dix."
        }
      ]
    },
    {
      "id": "q38",
      "difficulty": 3,
      "skills": [
        "depassement",
        "complement-a-deux",
        "calcul"
      ],
      "title": "Une somme qui change de signe",
      "partie": "limites",
      "statement": "Un programme additionne $100$ et $100$ dans une variable sur $8$\nbits signés en complément à deux. Quel résultat obtient-il ?",
      "options": [
        {
          "text": "$-56$",
          "correct": true,
          "feedback": "Bonne réponse : $200$ dépasse $127$. L'octet obtenu, $11001000_2$,\na son bit de poids fort à $1$ et se lit $200 - 256 = -56$.\n"
        },
        {
          "text": "$200$",
          "correct": false,
          "feedback": "Erreur : $200$ ne tient pas sur $8$ bits signés, dont le maximum\nest $127$. Le résultat déborde.\n"
        },
        {
          "text": "$127$, la valeur étant plafonnée au maximum",
          "correct": false,
          "feedback": "Erreur : l'arithmétique binaire ne plafonne pas, elle boucle. Le\nrésultat repart du côté négatif.\n"
        },
        {
          "text": "Une erreur signalée par le processeur",
          "correct": false,
          "feedback": "Erreur : le dépassement passe souvent inaperçu, c'est ce qui le\nrend dangereux. Python, lui, évite le problème avec des entiers\nde taille illimitée.\n"
        }
      ],
      "explanation": "Sur $8$ bits signés, les valeurs vont de $-128$ à $127$. Au-delà, la\nsomme boucle : $200$ devient $-56$.",
      "variants": [
        {
          "statement": "Un programme additionne $100$ et $100$ dans une variable sur $8$\nbits signés en complément à deux. Quel résultat obtient-il ?",
          "options": [
            {
              "text": "$-56$",
              "correct": true,
              "feedback": "Bonne réponse : $200$ dépasse $127$. L'octet obtenu, $11001000_2$,\na son bit de poids fort à $1$ et se lit $200 - 256 = -56$.\n"
            },
            {
              "text": "$200$",
              "correct": false,
              "feedback": "Erreur : $200$ ne tient pas sur $8$ bits signés, dont le maximum\nest $127$. Le résultat déborde.\n"
            },
            {
              "text": "$127$, la valeur étant plafonnée au maximum",
              "correct": false,
              "feedback": "Erreur : l'arithmétique binaire ne plafonne pas, elle boucle. Le\nrésultat repart du côté négatif.\n"
            },
            {
              "text": "Une erreur signalée par le processeur",
              "correct": false,
              "feedback": "Erreur : le dépassement passe souvent inaperçu, c'est ce qui le\nrend dangereux. Python, lui, évite le problème avec des entiers\nde taille illimitée.\n"
            }
          ],
          "explanation": "Sur $8$ bits signés, les valeurs vont de $-128$ à $127$. Au-delà, la\nsomme boucle : $200$ devient $-56$."
        },
        {
          "statement": "Un programme additionne $90$ et $50$ dans une variable sur $8$\nbits signés en complément à deux. Quel résultat obtient-il ?",
          "options": [
            {
              "text": "$-116$",
              "correct": true,
              "feedback": "Bonne réponse : $140$ dépasse $127$. L'octet obtenu, $10001100_2$,\na son bit de poids fort à $1$ et se lit $140 - 256 = -116$.\n"
            },
            {
              "text": "$140$",
              "correct": false,
              "feedback": "Erreur : $140$ ne tient pas sur $8$ bits signés, dont le maximum\nest $127$. Le résultat déborde.\n"
            },
            {
              "text": "$127$, la valeur étant plafonnée au maximum",
              "correct": false,
              "feedback": "Erreur : l'arithmétique binaire ne plafonne pas, elle boucle. Le\nrésultat repart du côté négatif.\n"
            },
            {
              "text": "Une erreur signalée par le processeur",
              "correct": false,
              "feedback": "Erreur : le dépassement passe souvent inaperçu, c'est ce qui le\nrend dangereux. Python, lui, évite le problème avec des entiers\nde taille illimitée.\n"
            }
          ],
          "explanation": "Sur $8$ bits signés, les valeurs vont de $-128$ à $127$. Au-delà, la\nsomme boucle : $140$ devient $-116$."
        },
        {
          "statement": "Un programme additionne $120$ et $10$ dans une variable sur $8$\nbits signés en complément à deux. Quel résultat obtient-il ?",
          "options": [
            {
              "text": "$-126$",
              "correct": true,
              "feedback": "Bonne réponse : $130$ dépasse $127$. L'octet obtenu, $10000010_2$,\na son bit de poids fort à $1$ et se lit $130 - 256 = -126$.\n"
            },
            {
              "text": "$130$",
              "correct": false,
              "feedback": "Erreur : $130$ ne tient pas sur $8$ bits signés, dont le maximum\nest $127$. Le résultat déborde.\n"
            },
            {
              "text": "$127$, la valeur étant plafonnée au maximum",
              "correct": false,
              "feedback": "Erreur : l'arithmétique binaire ne plafonne pas, elle boucle. Le\nrésultat repart du côté négatif.\n"
            },
            {
              "text": "Une erreur signalée par le processeur",
              "correct": false,
              "feedback": "Erreur : le dépassement passe souvent inaperçu, c'est ce qui le\nrend dangereux. Python, lui, évite le problème avec des entiers\nde taille illimitée.\n"
            }
          ],
          "explanation": "Sur $8$ bits signés, les valeurs vont de $-128$ à $127$. Au-delà, la\nsomme boucle : $130$ devient $-126$."
        }
      ]
    },
    {
      "id": "q39",
      "difficulty": 1,
      "skills": [
        "complement",
        "signe",
        "bit-de-poids-fort"
      ],
      "title": "Le signe d'un entier codé sur huit bits",
      "partie": "complement",
      "statement": "En complément à deux sur huit bits, le motif `10010110` représente un\nentier. Quel est son signe ?",
      "options": [
        {
          "text": "Négatif, le bit de poids fort étant $1$",
          "correct": true,
          "feedback": "Bonne réponse : en complément à deux, le bit de poids fort\nvaut $1$ pour les négatifs et $0$ pour les positifs. Ici le\nmotif représente $-106$.\n"
        },
        {
          "text": "Positif, le bit de poids fort étant $1$",
          "correct": false,
          "feedback": "Erreur : la valeur du bit de poids fort est juste, mais sa\nlecture est inversée ; $1$ signale un négatif.\n"
        },
        {
          "text": "Nul, le motif n'étant pas valide en complément à deux",
          "correct": false,
          "feedback": "Erreur : tout motif de huit bits représente un entier entre\n$-128$ et $127$.\n"
        },
        {
          "text": "Impossible à dire sans connaître la machine",
          "correct": false,
          "feedback": "Erreur : la convention du complément à deux suffit, le bit de\npoids fort porte le signe.\n"
        }
      ],
      "explanation": "Le bit de poids fort est le bit de signe : il pèse $-128$ sur huit\nbits, et sa présence rend la valeur négative.",
      "variants": [
        {
          "statement": "En complément à deux sur huit bits, le motif `10010110` représente un\nentier. Quel est son signe ?",
          "options": [
            {
              "text": "Négatif, le bit de poids fort étant $1$",
              "correct": true,
              "feedback": "Bonne réponse : en complément à deux, le bit de poids fort\nvaut $1$ pour les négatifs et $0$ pour les positifs. Ici le\nmotif représente $-106$.\n"
            },
            {
              "text": "Positif, le bit de poids fort étant $1$",
              "correct": false,
              "feedback": "Erreur : la valeur du bit de poids fort est juste, mais sa\nlecture est inversée ; $1$ signale un négatif.\n"
            },
            {
              "text": "Nul, le motif n'étant pas valide en complément à deux",
              "correct": false,
              "feedback": "Erreur : tout motif de huit bits représente un entier entre\n$-128$ et $127$.\n"
            },
            {
              "text": "Impossible à dire sans connaître la machine",
              "correct": false,
              "feedback": "Erreur : la convention du complément à deux suffit, le bit de\npoids fort porte le signe.\n"
            }
          ],
          "explanation": "Le bit de poids fort est le bit de signe : il pèse $-128$ sur huit\nbits, et sa présence rend la valeur négative."
        },
        {
          "statement": "En complément à deux sur huit bits, le motif `01101001` représente un\nentier. Quel est son signe ?",
          "options": [
            {
              "text": "Positif, le bit de poids fort étant $0$",
              "correct": true,
              "feedback": "Bonne réponse : en complément à deux, le bit de poids fort\nvaut $1$ pour les négatifs et $0$ pour les positifs. Ici le\nmotif représente $105$.\n"
            },
            {
              "text": "Négatif, le bit de poids fort étant $0$",
              "correct": false,
              "feedback": "Erreur : la valeur du bit de poids fort est juste, mais sa\nlecture est inversée ; $1$ signale un négatif.\n"
            },
            {
              "text": "Nul, le motif n'étant pas valide en complément à deux",
              "correct": false,
              "feedback": "Erreur : tout motif de huit bits représente un entier entre\n$-128$ et $127$.\n"
            },
            {
              "text": "Impossible à dire sans connaître la machine",
              "correct": false,
              "feedback": "Erreur : la convention du complément à deux suffit, le bit de\npoids fort porte le signe.\n"
            }
          ],
          "explanation": "Le bit de poids fort est le bit de signe : il pèse $-128$ sur huit\nbits, et sa présence rend la valeur négative."
        }
      ]
    },
    {
      "id": "q40",
      "difficulty": 2,
      "skills": [
        "complement",
        "plage",
        "calcul"
      ],
      "title": "La plage des entiers signés sur n bits",
      "partie": "complement",
      "statement": "Quels entiers peut-on représenter en complément à deux sur $16$\nbits ?",
      "options": [
        {
          "text": "De $-32768$ à $32767$",
          "correct": true,
          "feedback": "Bonne réponse : la moitié des $2^{16}$ motifs sert aux\nnégatifs, de $-2^{15}$ à $-1$, l'autre moitié aux positifs\net à zéro, de $0$ à $2^{15} - 1$.\n"
        },
        {
          "text": "De $0$ à $65535$",
          "correct": false,
          "feedback": "Erreur : c'est la plage des entiers non signés sur $16$ bits.\n"
        },
        {
          "text": "De $-32767$ à $32767$",
          "correct": false,
          "feedback": "Erreur : la plage n'est pas symétrique, il y a un négatif de\nplus que de positifs.\n"
        },
        {
          "text": "De $-65535$ à $65535$",
          "correct": false,
          "feedback": "Erreur : cela demanderait $2 \\times 65535 + 1$ motifs, plus que\nles $2^{16}$ disponibles.\n"
        }
      ],
      "explanation": "Sur $n$ bits, le complément à deux couvre $[-2^{n-1}, 2^{n-1} - 1]$ :\nles $2^n$ motifs sont partagés en deux moitiés inégales d'un.",
      "variants": [
        {
          "statement": "Quels entiers peut-on représenter en complément à deux sur $16$\nbits ?",
          "options": [
            {
              "text": "De $-32768$ à $32767$",
              "correct": true,
              "feedback": "Bonne réponse : la moitié des $2^{16}$ motifs sert aux\nnégatifs, de $-2^{15}$ à $-1$, l'autre moitié aux positifs\net à zéro, de $0$ à $2^{15} - 1$.\n"
            },
            {
              "text": "De $0$ à $65535$",
              "correct": false,
              "feedback": "Erreur : c'est la plage des entiers non signés sur $16$ bits.\n"
            },
            {
              "text": "De $-32767$ à $32767$",
              "correct": false,
              "feedback": "Erreur : la plage n'est pas symétrique, il y a un négatif de\nplus que de positifs.\n"
            },
            {
              "text": "De $-65535$ à $65535$",
              "correct": false,
              "feedback": "Erreur : cela demanderait $2 \\times 65535 + 1$ motifs, plus que\nles $2^{16}$ disponibles.\n"
            }
          ],
          "explanation": "Sur $n$ bits, le complément à deux couvre $[-2^{n-1}, 2^{n-1} - 1]$ :\nles $2^n$ motifs sont partagés en deux moitiés inégales d'un."
        },
        {
          "statement": "Quels entiers peut-on représenter en complément à deux sur $12$\nbits ?",
          "options": [
            {
              "text": "De $-2048$ à $2047$",
              "correct": true,
              "feedback": "Bonne réponse : la moitié des $2^{12}$ motifs sert aux\nnégatifs, de $-2^{11}$ à $-1$, l'autre moitié aux positifs\net à zéro, de $0$ à $2^{11} - 1$.\n"
            },
            {
              "text": "De $0$ à $4095$",
              "correct": false,
              "feedback": "Erreur : c'est la plage des entiers non signés sur $12$ bits.\n"
            },
            {
              "text": "De $-2047$ à $2047$",
              "correct": false,
              "feedback": "Erreur : la plage n'est pas symétrique, il y a un négatif de\nplus que de positifs.\n"
            },
            {
              "text": "De $-4095$ à $4095$",
              "correct": false,
              "feedback": "Erreur : cela demanderait $2 \\times 4095 + 1$ motifs, plus que\nles $2^{12}$ disponibles.\n"
            }
          ],
          "explanation": "Sur $n$ bits, le complément à deux couvre $[-2^{n-1}, 2^{n-1} - 1]$ :\nles $2^n$ motifs sont partagés en deux moitiés inégales d'un."
        },
        {
          "statement": "Quels entiers peut-on représenter en complément à deux sur $10$\nbits ?",
          "options": [
            {
              "text": "De $-512$ à $511$",
              "correct": true,
              "feedback": "Bonne réponse : la moitié des $2^{10}$ motifs sert aux\nnégatifs, de $-2^{9}$ à $-1$, l'autre moitié aux positifs\net à zéro, de $0$ à $2^{9} - 1$.\n"
            },
            {
              "text": "De $0$ à $1023$",
              "correct": false,
              "feedback": "Erreur : c'est la plage des entiers non signés sur $10$ bits.\n"
            },
            {
              "text": "De $-511$ à $511$",
              "correct": false,
              "feedback": "Erreur : la plage n'est pas symétrique, il y a un négatif de\nplus que de positifs.\n"
            },
            {
              "text": "De $-1023$ à $1023$",
              "correct": false,
              "feedback": "Erreur : cela demanderait $2 \\times 1023 + 1$ motifs, plus que\nles $2^{10}$ disponibles.\n"
            }
          ],
          "explanation": "Sur $n$ bits, le complément à deux couvre $[-2^{n-1}, 2^{n-1} - 1]$ :\nles $2^n$ motifs sont partagés en deux moitiés inégales d'un."
        }
      ]
    },
    {
      "id": "q41",
      "difficulty": 3,
      "skills": [
        "complement",
        "depassement",
        "addition"
      ],
      "title": "Une addition qui déborde dans le bit de signe",
      "partie": "complement",
      "statement": "Une machine additionne $127$ et $1$ en complément à deux sur\nhuit bits, sans détecter le dépassement. Quel résultat\naffiche-t-elle ?",
      "options": [
        {
          "text": "$-128$, la retenue ayant basculé le bit de signe",
          "correct": true,
          "feedback": "Bonne réponse : $128$ dépasse $127$ ; son motif sur huit bits\na le bit de poids fort à $1$ et se lit $128 - 256 = -128$.\n"
        },
        {
          "text": "$128$, l'addition de deux positifs étant toujours exacte",
          "correct": false,
          "feedback": "Erreur : $128$ ne tient pas sur sept bits de valeur, le\nrésultat déborde.\n"
        },
        {
          "text": "$127$, la valeur étant plafonnée au maximum",
          "correct": false,
          "feedback": "Erreur : rien ne plafonne, le motif continue au-delà et change\nde signe.\n"
        },
        {
          "text": "$0$, le dépassement remettant le résultat à zéro",
          "correct": false,
          "feedback": "Erreur : seule la retenue sortante est perdue, pas les autres\nbits.\n"
        }
      ],
      "explanation": "Additionner deux positifs peut donner un négatif en complément à\ndeux : c'est le dépassement de capacité, invisible sans\nvérification.",
      "variants": [
        {
          "statement": "Une machine additionne $127$ et $1$ en complément à deux sur\nhuit bits, sans détecter le dépassement. Quel résultat\naffiche-t-elle ?",
          "options": [
            {
              "text": "$-128$, la retenue ayant basculé le bit de signe",
              "correct": true,
              "feedback": "Bonne réponse : $128$ dépasse $127$ ; son motif sur huit bits\na le bit de poids fort à $1$ et se lit $128 - 256 = -128$.\n"
            },
            {
              "text": "$128$, l'addition de deux positifs étant toujours exacte",
              "correct": false,
              "feedback": "Erreur : $128$ ne tient pas sur sept bits de valeur, le\nrésultat déborde.\n"
            },
            {
              "text": "$127$, la valeur étant plafonnée au maximum",
              "correct": false,
              "feedback": "Erreur : rien ne plafonne, le motif continue au-delà et change\nde signe.\n"
            },
            {
              "text": "$0$, le dépassement remettant le résultat à zéro",
              "correct": false,
              "feedback": "Erreur : seule la retenue sortante est perdue, pas les autres\nbits.\n"
            }
          ],
          "explanation": "Additionner deux positifs peut donner un négatif en complément à\ndeux : c'est le dépassement de capacité, invisible sans\nvérification."
        },
        {
          "statement": "Une machine additionne $100$ et $50$ en complément à deux sur\nhuit bits, sans détecter le dépassement. Quel résultat\naffiche-t-elle ?",
          "options": [
            {
              "text": "$-106$, la retenue ayant basculé le bit de signe",
              "correct": true,
              "feedback": "Bonne réponse : $150$ dépasse $127$ ; son motif sur huit bits\na le bit de poids fort à $1$ et se lit $150 - 256 = -106$.\n"
            },
            {
              "text": "$150$, l'addition de deux positifs étant toujours exacte",
              "correct": false,
              "feedback": "Erreur : $150$ ne tient pas sur sept bits de valeur, le\nrésultat déborde.\n"
            },
            {
              "text": "$127$, la valeur étant plafonnée au maximum",
              "correct": false,
              "feedback": "Erreur : rien ne plafonne, le motif continue au-delà et change\nde signe.\n"
            },
            {
              "text": "$0$, le dépassement remettant le résultat à zéro",
              "correct": false,
              "feedback": "Erreur : seule la retenue sortante est perdue, pas les autres\nbits.\n"
            }
          ],
          "explanation": "Additionner deux positifs peut donner un négatif en complément à\ndeux : c'est le dépassement de capacité, invisible sans\nvérification."
        },
        {
          "statement": "Une machine additionne $120$ et $10$ en complément à deux sur\nhuit bits, sans détecter le dépassement. Quel résultat\naffiche-t-elle ?",
          "options": [
            {
              "text": "$-126$, la retenue ayant basculé le bit de signe",
              "correct": true,
              "feedback": "Bonne réponse : $130$ dépasse $127$ ; son motif sur huit bits\na le bit de poids fort à $1$ et se lit $130 - 256 = -126$.\n"
            },
            {
              "text": "$130$, l'addition de deux positifs étant toujours exacte",
              "correct": false,
              "feedback": "Erreur : $130$ ne tient pas sur sept bits de valeur, le\nrésultat déborde.\n"
            },
            {
              "text": "$127$, la valeur étant plafonnée au maximum",
              "correct": false,
              "feedback": "Erreur : rien ne plafonne, le motif continue au-delà et change\nde signe.\n"
            },
            {
              "text": "$0$, le dépassement remettant le résultat à zéro",
              "correct": false,
              "feedback": "Erreur : seule la retenue sortante est perdue, pas les autres\nbits.\n"
            }
          ],
          "explanation": "Additionner deux positifs peut donner un négatif en complément à\ndeux : c'est le dépassement de capacité, invisible sans\nvérification."
        }
      ]
    },
    {
      "id": "q42",
      "difficulty": 2,
      "skills": [
        "hexadecimal",
        "conversion",
        "decimal-hexadecimal"
      ],
      "title": "Conversion décimal vers hexadécimal",
      "partie": "hexadecimal",
      "statement": "Comment s'écrit $171$ en hexadécimal ?",
      "options": [
        {
          "text": "`0xAB`",
          "correct": true,
          "feedback": "Bonne réponse : $171 = 10 \\times 16 + 11$ ; on écrit chaque\nreste avec un chiffre hexadécimal, de $0$ à $9$ puis de `A`\nà `F`, du dernier quotient au premier reste.\n"
        },
        {
          "text": "`0xBA`",
          "correct": false,
          "feedback": "Erreur : les restes sont écrits dans l'ordre inverse ; le\ndernier quotient donne le chiffre de gauche.\n"
        },
        {
          "text": "`0x1011`",
          "correct": false,
          "feedback": "Erreur : les restes $10$ et $11$ ont été recopiés en\ndécimal au lieu d'être convertis en chiffres hexadécimaux.\n"
        },
        {
          "text": "`0x171`",
          "correct": false,
          "feedback": "Erreur : écrire les chiffres décimaux après `0x` donne un tout\nautre nombre.\n"
        }
      ],
      "explanation": "Divisions successives par $16$ : les restes, lus du dernier au\npremier, forment l'écriture hexadécimale.",
      "variants": [
        {
          "statement": "Comment s'écrit $171$ en hexadécimal ?",
          "options": [
            {
              "text": "`0xAB`",
              "correct": true,
              "feedback": "Bonne réponse : $171 = 10 \\times 16 + 11$ ; on écrit chaque\nreste avec un chiffre hexadécimal, de $0$ à $9$ puis de `A`\nà `F`, du dernier quotient au premier reste.\n"
            },
            {
              "text": "`0xBA`",
              "correct": false,
              "feedback": "Erreur : les restes sont écrits dans l'ordre inverse ; le\ndernier quotient donne le chiffre de gauche.\n"
            },
            {
              "text": "`0x1011`",
              "correct": false,
              "feedback": "Erreur : les restes $10$ et $11$ ont été recopiés en\ndécimal au lieu d'être convertis en chiffres hexadécimaux.\n"
            },
            {
              "text": "`0x171`",
              "correct": false,
              "feedback": "Erreur : écrire les chiffres décimaux après `0x` donne un tout\nautre nombre.\n"
            }
          ],
          "explanation": "Divisions successives par $16$ : les restes, lus du dernier au\npremier, forment l'écriture hexadécimale."
        },
        {
          "statement": "Comment s'écrit $300$ en hexadécimal ?",
          "options": [
            {
              "text": "`0x12C`",
              "correct": true,
              "feedback": "Bonne réponse : $300 = 18 \\times 16 + 12$ ; on écrit chaque\nreste avec un chiffre hexadécimal, de $0$ à $9$ puis de `A`\nà `F`, du dernier quotient au premier reste.\n"
            },
            {
              "text": "`0xC21`",
              "correct": false,
              "feedback": "Erreur : les restes sont écrits dans l'ordre inverse ; le\ndernier quotient donne le chiffre de gauche.\n"
            },
            {
              "text": "`0x1812`",
              "correct": false,
              "feedback": "Erreur : les restes $18$ et $12$ ont été recopiés en\ndécimal au lieu d'être convertis en chiffres hexadécimaux.\n"
            },
            {
              "text": "`0x300`",
              "correct": false,
              "feedback": "Erreur : écrire les chiffres décimaux après `0x` donne un tout\nautre nombre.\n"
            }
          ],
          "explanation": "Divisions successives par $16$ : les restes, lus du dernier au\npremier, forment l'écriture hexadécimale."
        },
        {
          "statement": "Comment s'écrit $202$ en hexadécimal ?",
          "options": [
            {
              "text": "`0xCA`",
              "correct": true,
              "feedback": "Bonne réponse : $202 = 12 \\times 16 + 10$ ; on écrit chaque\nreste avec un chiffre hexadécimal, de $0$ à $9$ puis de `A`\nà `F`, du dernier quotient au premier reste.\n"
            },
            {
              "text": "`0xAC`",
              "correct": false,
              "feedback": "Erreur : les restes sont écrits dans l'ordre inverse ; le\ndernier quotient donne le chiffre de gauche.\n"
            },
            {
              "text": "`0x1210`",
              "correct": false,
              "feedback": "Erreur : les restes $12$ et $10$ ont été recopiés en\ndécimal au lieu d'être convertis en chiffres hexadécimaux.\n"
            },
            {
              "text": "`0x202`",
              "correct": false,
              "feedback": "Erreur : écrire les chiffres décimaux après `0x` donne un tout\nautre nombre.\n"
            }
          ],
          "explanation": "Divisions successives par $16$ : les restes, lus du dernier au\npremier, forment l'écriture hexadécimale."
        }
      ]
    },
    {
      "id": "q43",
      "difficulty": 1,
      "skills": [
        "hexadecimal",
        "comparaison",
        "valeur"
      ],
      "title": "Comparer deux écritures hexadécimales",
      "partie": "hexadecimal",
      "statement": "Lequel de `0x9A` et `0xA0` est le plus grand ?",
      "options": [
        {
          "text": "`0xA0`, qui vaut $160$",
          "correct": true,
          "feedback": "Bonne réponse : `0x9A` vaut $154$ et `0xA0` vaut $160$.\nEn hexadécimal, les lettres `A` à `F` valent $10$ à $15$ et\ndépassent donc les chiffres.\n"
        },
        {
          "text": "`0x9A`, qui vaut $154$",
          "correct": false,
          "feedback": "Erreur : `0x9A` vaut bien $154$, mais c'est le plus petit\ndes deux.\n"
        },
        {
          "text": "Les deux sont égaux",
          "correct": false,
          "feedback": "Erreur : deux écritures hexadécimales différentes désignent\ndeux nombres différents.\n"
        },
        {
          "text": "Impossible à comparer sans passer par le binaire",
          "correct": false,
          "feedback": "Erreur : on compare en convertissant en décimal, ou chiffre\npar chiffre depuis la gauche.\n"
        }
      ],
      "explanation": "Comparer deux nombres hexadécimaux de même longueur se fait\nchiffre par chiffre depuis la gauche, les lettres valant plus que\nles chiffres.",
      "variants": [
        {
          "statement": "Lequel de `0x9A` et `0xA0` est le plus grand ?",
          "options": [
            {
              "text": "`0xA0`, qui vaut $160$",
              "correct": true,
              "feedback": "Bonne réponse : `0x9A` vaut $154$ et `0xA0` vaut $160$.\nEn hexadécimal, les lettres `A` à `F` valent $10$ à $15$ et\ndépassent donc les chiffres.\n"
            },
            {
              "text": "`0x9A`, qui vaut $154$",
              "correct": false,
              "feedback": "Erreur : `0x9A` vaut bien $154$, mais c'est le plus petit\ndes deux.\n"
            },
            {
              "text": "Les deux sont égaux",
              "correct": false,
              "feedback": "Erreur : deux écritures hexadécimales différentes désignent\ndeux nombres différents.\n"
            },
            {
              "text": "Impossible à comparer sans passer par le binaire",
              "correct": false,
              "feedback": "Erreur : on compare en convertissant en décimal, ou chiffre\npar chiffre depuis la gauche.\n"
            }
          ],
          "explanation": "Comparer deux nombres hexadécimaux de même longueur se fait\nchiffre par chiffre depuis la gauche, les lettres valant plus que\nles chiffres."
        },
        {
          "statement": "Lequel de `0x7F` et `0x80` est le plus grand ?",
          "options": [
            {
              "text": "`0x80`, qui vaut $128$",
              "correct": true,
              "feedback": "Bonne réponse : `0x7F` vaut $127$ et `0x80` vaut $128$.\nEn hexadécimal, les lettres `A` à `F` valent $10$ à $15$ et\ndépassent donc les chiffres.\n"
            },
            {
              "text": "`0x7F`, qui vaut $127$",
              "correct": false,
              "feedback": "Erreur : `0x7F` vaut bien $127$, mais c'est le plus petit\ndes deux.\n"
            },
            {
              "text": "Les deux sont égaux",
              "correct": false,
              "feedback": "Erreur : deux écritures hexadécimales différentes désignent\ndeux nombres différents.\n"
            },
            {
              "text": "Impossible à comparer sans passer par le binaire",
              "correct": false,
              "feedback": "Erreur : on compare en convertissant en décimal, ou chiffre\npar chiffre depuis la gauche.\n"
            }
          ],
          "explanation": "Comparer deux nombres hexadécimaux de même longueur se fait\nchiffre par chiffre depuis la gauche, les lettres valant plus que\nles chiffres."
        },
        {
          "statement": "Lequel de `0xFF` et `0x100` est le plus grand ?",
          "options": [
            {
              "text": "`0x100`, qui vaut $256$",
              "correct": true,
              "feedback": "Bonne réponse : `0xFF` vaut $255$ et `0x100` vaut $256$.\nEn hexadécimal, les lettres `A` à `F` valent $10$ à $15$ et\ndépassent donc les chiffres.\n"
            },
            {
              "text": "`0xFF`, qui vaut $255$",
              "correct": false,
              "feedback": "Erreur : `0xFF` vaut bien $255$, mais c'est le plus petit\ndes deux.\n"
            },
            {
              "text": "Les deux sont égaux",
              "correct": false,
              "feedback": "Erreur : deux écritures hexadécimales différentes désignent\ndeux nombres différents.\n"
            },
            {
              "text": "Impossible à comparer sans passer par le binaire",
              "correct": false,
              "feedback": "Erreur : on compare en convertissant en décimal, ou chiffre\npar chiffre depuis la gauche.\n"
            }
          ],
          "explanation": "Comparer deux nombres hexadécimaux de même longueur se fait\nchiffre par chiffre depuis la gauche, les lettres valant plus que\nles chiffres."
        }
      ]
    }
  ]
}