1ère NSI ndlrnsi.alwaysdata.net • Corrigé de l'évaluation
ANNÉE 2026 - 2027

Corrigé Officiel & Guide Méthodologique

Évaluation complète de Première NSI : Représentation des données, Numération, Complément à 2, Hexadécimal & Bit-Packing.

📥 PDF Imprimable (4 pages)

📌 Épreuve 1 : 20 points (Numération, Complément à 2, Débordement, Algorithme Python) • 📌 Épreuve 2 : 20 points (Hexadécimal, ASCII avancé, Bit-Packing date 24 bits, Python)
ÉPREUVE 1

Numération, Plages de valeurs, Complément à 2 & Débordement

Total : 20 points

Partie 1 : QCM Défi Numération (Règle stricte +1 / -1 / 0)

4 points
Règle de correction : Bonne réponse = +1 pt • Mauvaise réponse = -1 pt • Absence = 0 pt (Score de la partie ≥ 0 pt).
Question 1
Particularité de -128 (1000 0000₂ en signé sur 8 bits) :
✓ Réponse B : L'inversion + 1 redonne 1000 0000₂.
Explication : Sur 8 bits signés, l'intervalle est [-128 ; +127]. Si on prend -128, son inverse est 0111 1111₂ (+127), auquel on ajoute 1 : 0111 1111 + 1 = 1000 0000₂ (-128) ! Son opposé mathématique (+128) n'étant pas codable sur 8 bits, cela déclenche un dépassement de capacité.
Question 2
Addition binaire X + ~X sur 8 bits :
✓ Réponse B : Donne toujours 1111 1111₂.
Explication : Pour chaque bit i, si X[i] == 1 alors ~X[i] == 0, et inversement. La somme pour chaque colonne est toujours 1 + 0 = 1 sans jamais générer de retenue. Le résultat est donc 1111 1111₂ (255 en non signé, -1 en signé).
Question 3
Nombre minimum de bits pour coder un entier positif jusqu'à 1 000 000 :
✓ Réponse C : 20 bits.
Explication : 2¹⁹ = 524 288 (insuffisant car < 1 000 000). 2²⁰ = 1 048 576. Avec 20 bits, on code les entiers de 0 à 1 048 575, ce qui est le minimum requis.
Question 4
Addition signée 8 bits : (+112) + (+48) :
✓ Réponse B : Bit de signe à 1 ⇒ négatif (overflow).
Explication : 112 + 48 = 160. Or sur 8 bits signés, le maximum est +127. La machine stocke 1010 0000₂ qui correspond à -96. La somme de deux positifs a donné un négatif : c'est un débordement (overflow).

Partie 2 : Plages de valeurs & Entiers signés en Complément à 2

6 points
Exercice 2.1 : Plages de valeurs & Encodage de -43 3,5 points
1. Plages sur 8 bits
  • Entier non signé (0,5 pt) : 2⁸ = 256 valeurs ⇒ intervalle [ 0 ; 255 ].
  • Entier signé en complément à 2 (0,5 pt) : intervalle [ -128 ; +127 ] (de -2⁷ à 2⁷ - 1).
  • Dissymétrie de l'intervalle (1 pt) : Le zéro (0000 0000₂) ayant son bit de poids fort (bit de signe) à 0, il est rangé avec les nombres positifs/nuls. Il reste donc 127 entiers strictement positifs (+1 à +127) et 128 entiers négatifs (-1 à -128).
2. Encodage de -43 sur 8 bits (1,5 pt)
Étape 1 : Valeur absolue (+43) 43 = 32 + 8 + 2 + 1
0010 1011₂
Étape 2 : Complément à 1 (inversion) 0 ↔ 1 bit à bit
1101 0100₂
Étape 3 : Complément à 2 (+ 1) 1101 0100₂ + 1
1101 0101₂
Preuve : -128 + 64 + 16 + 4 + 1 = -128 + 85 = -43.
Exercice 2.2 : Arithmétique binaire & Débordement (Overflow) 2,5 points
Addition posée (+105) + (+51) (1,5 pt)
    Retenues :  1 1 0 0   0 1 1 0
                0 1 1 0 1 0 0 1₂   (+105)
            +   0 0 1 1 0 0 1 1₂   (+51)
            -----------------------
            =   1 0 0 1 1 1 0 0₂   (-100 en complément à 2)
Interprétation de l'overflow (1 pt)

Le bit de signe du résultat vaut 1, indiquant un nombre négatif (-100 en complément à 2) alors que les deux opérandes sont strictement positifs (+105 et +51). La valeur théorique (+156) dépasse la valeur maximale représentable (+127). La retenue injectée dans le bit de signe sans retenue sortante provoque un débordement de capacité (overflow).

Partie 3 : Conversions de l'année 2026 & Algorithme Python

10 points
Exercice 3.1 : Décomposition & Divisions de 2026 5 points
  • 1. Encadrement (1 pt) : 2¹⁰ = 1024 ≤ 2026 < 2048 = 2¹¹ ⇒ 11 bits nécessaires.
  • 2. Méthode des puissances de 2 (2 pts) :
    2026 = 1024 + 512 + 256 + 128 + 64 + 32 + 8 + 2
    = 2¹⁰ + 2⁹ + 2⁸ + 2⁷ + 2⁶ + 2⁵ + 2³ + 2¹ ⇒ 2026₁₀ = (111 1110 1010)₂
  • 3. Divisions successives par 2 (2 pts) :
    2026 / 2 = 1013 (r=0) • 1013 / 2 = 506 (r=1) • 506 / 2 = 253 (r=0) • 253 / 2 = 126 (r=1) • 126 / 2 = 63 (r=0) • 63 / 2 = 31 (r=1) • 31 / 2 = 15 (r=1) • 15 / 2 = 7 (r=1) • 7 / 2 = 3 (r=1) • 3 / 2 = 1 (r=1) • 1 / 2 = 0 (r=1).
    En lisant de bas en haut (dernier reste = bit de poids fort) : (111 1110 1010)₂.
Exercice 3.2 : Analyse d'un algorithme de conversion en Python 5 points
1. Tableau d'état pour n = 21 (2 pts)
Tourn (début)reste (n % 2)binairen (fin : n // 2)
1211"1"10
2100"01"5
351"101"2
420"0101"1
511"10101"0 (arrêt)
  • 2. Concaténation à gauche (1,5 pt) : Chaque division extrait le bit du rang suivant (2⁰, 2¹, 2²...). On concatène à gauche (str(reste) + binaire) pour placer le bit de poids fort à gauche selon la convention usuelle d'écriture binaire.
  • 3. Nombre de tours pour n = 2026 (1,5 pt) : 2026 s'écrivant sur 11 bits (2¹⁰ ≤ 2026 < 2¹¹), 11 divisions entières successives par 2 sont nécessaires pour que n atteigne 0. La boucle s'exécutera exactement 11 fois.
ÉPREUVE 2

Hexadécimal, Table ASCII avancée & Bit-Packing d'une Date

Total : 20 points

Partie 1 : QCM Défi Hexadécimal & Manipulation de Bits (Règle stricte +1 / -1 / 0)

4 points
Question 1
Chiffres hexa pour 2³³ - 1 :
✓ Réponse B : 9 chiffres.
Explication : 2³³ - 1 s'écrit sur 33 bits à 1. Comme 1 symbole hexa équivaut à 4 bits : 8 chiffres couvrent 32 bits (< 33). Il faut donc 9 chiffres (qui couvrent jusqu'à 36 bits).
Question 2
Caractère 'C' (0100 0011₂) avec bit 5 forcé à 1 :
✓ Réponse A : 'c' (minuscule).
Explication : Le bit 5 a pour poids 2⁵ = 32. Forcer ce bit ajoute 32 au code : 'C' (67) + 32 = 99 = code ASCII de 'c'. En ASCII, le bit 5 est le bit de casse des lettres.
Question 3
En Python : (0b11101 >> 2) :
✓ Réponse B : 0b111 = 7.
Explication : Décaler à droite de 2 positions supprime les 2 bits de poids faible (01), laissant 0b111 (7). Cela correspond à la division entière 29 // 4 = 7.
Question 4
Extraire le vert (8A) sous forme d'octet de 0x3A8AFC :
✓ Réponse A : (0x3A8AFC >> 8) & 0xFF.
Explication : Le vert est sur les bits 8 à 15. Le décalage >> 8 place l'octet vert tout à droite (0x3A8A), puis le masque & 0xFF efface les bits supérieurs pour ne conserver que 0x8A.

Partie 2 : Hexadécimal & Encodage ASCII fin

6 points
Exercice 2.1 : L'Hexadécimal & les quartets 3 points
  • 1. Intérêt de la base 16 (0,5 pt) : Elle est 4 fois plus compacte que le binaire et offre une passerelle directe sans calcul complexe car 16 = 2⁴ : un chiffre hexadécimal correspond exactement à un groupe de 4 bits (quartet).
  • 2. Découpage par quartets de A = (1011 0000 1111 1101)₂ (1,5 pt) :
    (1011)₂ = 11 = B • (0000)₂ = 0 • (1111)₂ = 15 = F • (1101)₂ = 13 = D
    ⇒ A = (B0FD)₁₆
  • 3. Décomposition polynomiale de (2F8)₁₆ (1 pt) :
    (2F8)₁₆ = 2×16² + 15×16¹ + 8×16⁰ = 2×256 + 240 + 8 = 512 + 248 = 760₁₀.
Exercice 2.2 : Table ASCII & Propriété fine du bit de casse 3 points
  • 1. Encodage du mot « NSI » (1,5 pt) :
    • 'N' (78) : 78 = 4 × 16 + 14 ⇒ (4E)₁₆ = 0100 1110₂
    • 'S' (83) : 83 = 5 × 16 + 3 ⇒ (53)₁₆ = 0101 0011₂
    • 'I' (73) : 73 = 4 × 16 + 9 ⇒ (49)₁₆ = 0100 1001₂
    Taille mémoire : 3 caractères = 3 octets = 24 bits.
  • 2. Analyse de la casse (1,5 pt) :
    • 'A' = 0100 0001₂ (65) et 'a' = 0110 0001₂ (97) ⇒ seul le bit de rang 5 (poids 2⁵ = 32) passe de 0 à 1.
    • Pour 'n' : On prend 'N' (0100 1110₂) et on passe le bit 5 à 1 ⇒ 0110 1110₂ = (6E)₁₆ (soit 78 + 32 = 110₁₀).

Partie 3 : Emballage binaire (Bit-Packing) d'une Date & Python

10 points
Exercice 3.1 : Stockage compact d'une date (24 bits) 7 points
1. Justifications par puissances de 2 (1,5 pt)
  • Jour J ≤ 31 : 2⁴ = 16 < 31 ≤ 2⁵ = 32 ⇒ 5 bits suffisent.
  • Mois M ≤ 12 : 2³ = 8 < 12 ≤ 2⁴ = 16 ⇒ 4 bits suffisent.
  • Année A ≤ 2047 : 2¹⁰ = 1024 < 2048 = 2¹¹ ⇒ 11 bits suffisent (plage [0 ; 2047]).
2. Conversions individuelles (28/09/2026) (2 pts)
Jour J = 28 (5 bits) 16 + 8 + 4 = (11100)₂
Mois M = 9 (4 bits) 8 + 1 = (1001)₂
Année A = 2026 (11 bits) (111 1110 1010)₂
3 & 4. Mot de 24 bits & Hexadécimal (2,5 pts)
Organisation par champs : [0000] [111 1110 1010] [1001] [11100]
Organisation par quartets de 4 bits (de gauche à droite) :
0000 1111 1101 0101 0011 1100₂
Valeurs des quartets :
0000 = 0 • 1111 = F • 1101 = D • 0101 = 5 • 0011 = 3 • 1100 = C
⇒ Valeur hexadécimale : 0x0FD53C
5. Formule arithmétique Python (1 pt)

mot = A * 512 + M * 32 + J  (ou (A << 9) | (M << 5) | J).
Vérification arithmétique : 2026 × 512 + 9 × 32 + 28 = 1 037 312 + 288 + 28 = 1 037 628 = 0x0FD53C.

Exercice 3.2 : Questions de synthèse & Python (Site ndlrnsi) 3 points
  • 1. Instruction x = int("1101", 2) + int("A", 16) (1 pt) :
    int("1101", 2) = 13 et int("A", 16) = 10 ⇒ x = 13 + 10 = 23.
  • 2. Différence entre a = 0b1011 et b = bin(11) (1 pt) :
    • a : Type = int, Valeur = 11 (entier Python en notation binaire).
    • b : Type = str, Valeur = '0b1011' (représentation textuelle de l'entier).
  • 3. Couleur CSS #1E3A8A (1 pt) :
    Composante rouge : (1E)₁₆ = 1 × 16 + 14 = 30₁₀ (soit une intensité de 30 sur 255).