20 - Numération

Exercice 1 : QCM – vérification des prérequis

Pour chaque question, une seule réponse est correcte.

1. Combien de symboles utilise le système hexadécimal ?

  • A. 6
  • B. 10
  • C. 16
  • D. 2
Correction

Réponse : C. Le système hexadécimal utilise seize symboles : 0, 1, 2, …, 9, A, B, C, D, E, F.

  • A est faux : six est le nombre de lettres utilisées (A à F), pas le nombre total de symboles. C’est l’erreur la plus fréquente (confusion entre les lettres supplémentaires et le nombre total de symboles).
  • B est faux : dix est le nombre de symboles du système décimal.
  • D est faux : deux est le nombre de symboles du système binaire.

2. Quelle est la valeur décimale de $1010_2$ ?

  • A. $1010$
  • B. $12$
  • C. $10$
  • D. $20$
Correction

Réponse : C. On calcule : $1 \times 2^3 + 0 \times 2^2 + 1 \times 2^1 + 0 \times 2^0 = 8 + 0 + 2 + 0 = 10$.

  • A est faux : c’est l’erreur de lecture directe (on lit le nombre binaire comme un nombre décimal).
  • B est faux : c’est l’erreur consistant à additionner les chiffres ($1+0+1+0 = 2$) puis les multiplier par quelque chose.
  • D est faux : c’est l’erreur qui consiste à doubler le résultat ($10 \times 2 = 20$).

3. Combien de valeurs différentes peut-on coder sur un octet (huit bits) ?

  • A. 8
  • B. 128
  • C. 255
  • D. 256
Correction

Réponse : D. Sur $n$ bits, on code $2^n$ valeurs différentes. Avec $n = 8$ : $2^8 = 256$ valeurs, de 0 à 255.

  • A est faux : huit est le nombre de bits, pas le nombre de valeurs. Confusion entre bits et valeurs.
  • B est faux : $128 = 2^7$, c’est la moitié. Erreur d’exposant (oubli d’un facteur 2).
  • C est faux : $255 = 2^8 - 1$, c’est la plus grande valeur, pas le nombre total de valeurs. Erreur classique du « off-by-one ».

4. Quel nombre décimal correspond à $\text{A3}_{16}$ ?

  • A. $103$
  • B. $163$
  • C. $1003$
  • D. $\text{A3}$ n’est pas un nombre valide
Correction

Réponse : B. On calcule : $\text{A} \times 16^1 + 3 \times 16^0 = 10 \times 16 + 3 = 163$.

  • A est faux : erreur consistant à remplacer A par 10 puis concaténer ($10$ et $3$, soit $103$).
  • C est faux : erreur consistant à remplacer A par 10 puis concaténer avec un 0 ($1003$).
  • D est faux : $\text{A3}_{16}$ est parfaitement valide puisque A est un symbole hexadécimal.

5. Pour convertir rapidement un nombre binaire en hexadécimal, on regroupe les bits par paquets de :

  • A. 2
  • B. 3
  • C. 4
  • D. 8
Correction

Réponse : C. On regroupe par paquets de quatre bits car $2^4 = 16$. Chaque groupe de quatre bits correspond à un chiffre hexadécimal.

  • A est faux : des groupes de deux donneraient une base $2^2 = 4$ (quaternaire).
  • B est faux : des groupes de trois donneraient une base $2^3 = 8$ (octale).
  • D est faux : huit bits forment un octet, qui se convertit en deux chiffres hexadécimaux, pas un seul.

Exercice 2 : exemple travaillé – conversion complète

Voici la résolution complète et commentée de la conversion de $215_{10}$ dans les trois bases.

Étape 1 : décimal vers binaire (divisions successives par 2)

On divise successivement par 2 et on note les restes :

DivisionQuotientReste
$215 \div 2$$107$$1$
$107 \div 2$$53$$1$
$53 \div 2$$26$$1$
$26 \div 2$$13$$0$
$13 \div 2$$6$$1$
$6 \div 2$$3$$0$
$3 \div 2$$1$$1$
$1 \div 2$$0$$1$

On lit les restes de bas en haut : $215_{10} = 11010111_2$.

Vérification : $1 \times 128 + 1 \times 64 + 0 \times 32 + 1 \times 16 + 0 \times 8 + 1 \times 4 + 1 \times 2 + 1 \times 1 = 128 + 64 + 16 + 4 + 2 + 1 = 215$ ✓

Étape 2 : binaire vers hexadécimal (regroupement par 4)

On découpe $11010111_2$ en groupes de quatre bits en partant de la droite :

$\underbrace{1101}_{\text{D}} \quad \underbrace{0111}_7$

Chaque groupe se convertit : $1101_2 = 13_{10} = \text{D}{16}$ et $0111_2 = 7{10} = 7_{16}$.

Résultat : $215_{10} = \text{D7}_{16}$.

Vérification : $\text{D} \times 16 + 7 = 13 \times 16 + 7 = 208 + 7 = 215$ ✓

Résumé

$$215_{10} = 11010111_2 = \text{D7}_{16}$$

Exercice 3 : conversions guidées

Compléter les tableaux suivants en effectuant les conversions demandées. Les calculs intermédiaires sont guidés.

3.1 Binaire → décimal

Convertir $10110_2$ en décimal en complétant le tableau :

Position$2^4$$2^3$$2^2$$2^1$$2^0$
Puissance$16$$…$$…$$…$$…$
Bit$1$$0$$1$$1$$0$
Produit$16$$…$$…$$…$$…$

Somme : $16 + … + … + … + … = …$

Correction
Position$2^4$$2^3$$2^2$$2^1$$2^0$
Puissance$16$$8$$4$$2$$1$
Bit$1$$0$$1$$1$$0$
Produit$16$$0$$4$$2$$0$

Somme : $16 + 0 + 4 + 2 + 0 = 22$.

Donc $10110_2 = 22_{10}$.

3.2 Décimal → binaire

Convertir $53_{10}$ en binaire en complétant le tableau de divisions :

DivisionQuotientReste
$53 \div 2$$…$$…$
$… \div 2$$…$$…$
$… \div 2$$…$$…$
$… \div 2$$…$$…$
$… \div 2$$…$$…$
$… \div 2$$0$$…$

Lecture des restes de bas en haut : $53_{10} = ……._2$

Correction
DivisionQuotientReste
$53 \div 2$$26$$1$
$26 \div 2$$13$$0$
$13 \div 2$$6$$1$
$6 \div 2$$3$$0$
$3 \div 2$$1$$1$
$1 \div 2$$0$$1$

Lecture des restes de bas en haut : $53_{10} = 110101_2$.

Vérification : $32 + 16 + 4 + 1 = 53$ ✓

3.3 Hexadécimal → décimal

Convertir $\text{B4}_{16}$ en complétant :

$\text{B} \times 16^1 + 4 \times 16^0 = … \times 16 + … = …$

Correction

$\text{B} \times 16 + 4 \times 1 = 11 \times 16 + 4 = 176 + 4 = 180$.

Donc $\text{B4}{16} = 180{10}$.

3.4 Binaire ↔ hexadécimal

Convertir $\text{5F}_{16}$ en binaire en remplaçant chaque chiffre hexadécimal par quatre bits :

$5 = …._2$ et $\text{F} = ….2$, donc $\text{5F}{16} = …….._2$

Correction

$5 = 0101_2$ et $\text{F} = 1111_2$, donc $\text{5F}_{16} = 01011111_2$.

Vérification : $64 + 16 + 8 + 4 + 2 + 1 = 95$ et $5 \times 16 + 15 = 95$ ✓

Exercice 4 : conversions autonomes

Effectuer les conversions suivantes sans aide. Pour chaque question, vérifier le résultat en revenant à la base d’origine.

4.1 Binaire → décimal

  1. $00001111_2$
  2. $01100100_2$
  3. $10000001_2$
Correction
  1. $00001111_2 = 8 + 4 + 2 + 1 = 15$.
  2. $01100100_2 = 64 + 32 + 4 = 100$.
  3. $10000001_2 = 128 + 1 = 129$.

4.2 Décimal → binaire

  1. $20_{10}$
  2. $96_{10}$
  3. $200_{10}$
Correction
  1. $20 = 16 + 4 = 10100_2$. Vérification : $16 + 4 = 20$ ✓
  2. $96 = 64 + 32 = 1100000_2$. Vérification : $64 + 32 = 96$ ✓
  3. $200 = 128 + 64 + 8 = 11001000_2$. Vérification : $128 + 64 + 8 = 200$ ✓

4.3 Hexadécimal → décimal

  1. $\text{46}_{16}$
  2. $\text{CC}_{16}$
  3. $\text{FFF}_{16}$
Correction
  1. $\text{46}_{16} = 4 \times 16 + 6 = 70$.
  2. $\text{CC}_{16} = 12 \times 16 + 12 = 204$.
  3. $\text{FFF}_{16} = 15 \times 256 + 15 \times 16 + 15 = 3840 + 240 + 15 = 4095$.

4.4 Décimal → hexadécimal

  1. $35_{10}$
  2. $256_{10}$
  3. $3167_{10}$
Correction
  1. $35 = 2 \times 16 + 3$, donc $35_{10} = \text{23}_{16}$.
  2. $256 = 1 \times 256 + 0 \times 16 + 0$, donc $256_{10} = \text{100}_{16}$.
  3. $3167 \div 16 = 197$ reste $15$ (F) ; $197 \div 16 = 12$ reste $5$ ; $12 \div 16 = 0$ reste $12$ (C). Donc $3167_{10} = \text{C5F}_{16}$. Vérification : $12 \times 256 + 5 \times 16 + 15 = 3072 + 80 + 15 = 3167$ ✓

4.5 Binaire ↔ hexadécimal

  1. Convertir $01001011_2$ en hexadécimal.
  2. Convertir $\text{F0A}_{16}$ en binaire.
  3. Convertir $11010111_2$ en hexadécimal.
Correction
  1. $0100_2 = 4$ et $1011_2 = \text{B}$, donc $01001011_2 = \text{4B}_{16}$.
  2. $\text{F} = 1111_2$, $0 = 0000_2$, $\text{A} = 1010_2$, donc $\text{F0A}_{16} = 111100001010_2$.
  3. $1101_2 = \text{D}$ et $0111_2 = 7$, donc $11010111_2 = \text{D7}_{16}$.

Exercice 5 : opérations en binaire

Effectuer les opérations suivantes directement en binaire, puis vérifier chaque résultat en convertissant en décimal.

5.1 Additions

  1. $1100_2 + 1000_2$
  2. $1001_2 + 1011_2$
  3. $1_2 + 1_2 + 1_2 + 1_2$
Correction
  1. $1100 + 1000 = 10100_2 = 20_{10}$. Vérification : $12 + 8 = 20$ ✓
  2. $1001 + 1011 = 10100_2 = 20_{10}$. Vérification : $9 + 11 = 20$ ✓
  3. $1 + 1 = 10$, $10 + 1 = 11$, $11 + 1 = 100_2 = 4_{10}$. Vérification : $1+1+1+1 = 4$ ✓

5.2 Soustractions

  1. $1100_2 - 1000_2$
  2. $1000_2 - 101_2$
Correction
  1. $1100 - 1000 = 0100_2 = 4_{10}$. Vérification : $12 - 8 = 4$ ✓
  2. $1000 - 101 = 011_2 = 3_{10}$. Vérification : $8 - 5 = 3$ ✓

Exercice 6 : couleurs HTML et adresses réseau

Les couleurs sur le Web sont définies par un code hexadécimal de la forme #RRVVBB, où RR, VV et BB sont les composantes rouge, verte et bleue, chacune comprise entre 00 et FF.

6.1 Couleurs

  1. La couleur #FF8000 correspond à l’orange. Donner en décimal la valeur de chaque composante (rouge, vert, bleu).
  2. On souhaite un violet ayant $128$ de rouge, $0$ de vert et $200$ de bleu. Écrire le code hexadécimal correspondant.
  3. Quel est le code hexadécimal du blanc ? Du noir ? Justifier.
Correction
  1. Rouge : $\text{FF}{16} = 255$. Vert : $\text{80}{16} = 128$. Bleu : $\text{00}_{16} = 0$.
  2. $128_{10} = \text{80}{16}$, $0{10} = \text{00}{16}$, $200{10} = \text{C8}_{16}$. Code : #8000C8.
  3. Blanc : toutes les composantes à $255$, soit #FFFFFF. Noir : toutes à $0$, soit #000000. En synthèse additive, le blanc est la somme de toutes les couleurs et le noir leur absence.

6.2 Adresse MAC

Une adresse MAC est constituée de six octets écrits en hexadécimal, séparés par des deux-points, par exemple : 5A:3C:01:FF:B2:10.

  1. Combien de bits comporte une adresse MAC ?
  2. Convertir le premier octet 5A en binaire puis en décimal.
  3. Combien d’adresses MAC différentes existent en théorie ?
Correction
  1. Six octets, soit $6 \times 8 = 48$ bits.
  2. $\text{5A}{16}$ : $5 = 0101_2$ et $\text{A} = 1010_2$, donc $\text{5A}{16} = 01011010_2 = 90_{10}$.
  3. $2^{48} = 281,474,976,710,656$, soit environ $281$ mille milliards d’adresses.

Exercice 7 : synthèse – message codé

On souhaite transmettre le mot NSI en binaire, en utilisant le code ASCII (voir le cours sur les textes).

Les codes ASCII des lettres sont : N = $78_{10}$, S = $83_{10}$, I = $73_{10}$.

  1. Convertir chacun de ces codes en binaire sur huit bits.
  2. Écrire la suite complète de bits correspondant au mot « NSI ».
  3. Convertir cette même suite de bits en hexadécimal.
  4. Un camarade vous envoie le message hexadécimal 42 4F 4E. Décoder ce message (convertir en décimal puis en caractères ASCII, sachant que A = 65, B = 66, etc.).
Correction
  1. $78 = 64 + 8 + 4 + 2 = 01001110_2$, $83 = 64 + 16 + 2 + 1 = 01010011_2$, $73 = 64 + 8 + 1 = 01001001_2$.
  2. La suite complète : 01001110 01010011 01001001.
  3. $01001110 = \text{4E}$, $01010011 = \text{53}$, $01001001 = \text{49}$. En hexadécimal : 4E 53 49.
  4. $\text{42}{16} = 66{10}$ → B, $\text{4F}{16} = 79{10}$ → O, $\text{4E}{16} = 78{10}$ → N. Le message est BON.

Exercice 8 : complément à deux

On représente les entiers relatifs sur 8 bits en complément à deux (cours 04 - Entiers).

  1. Écrire la représentation de 37, de −37, de −1 et de −128.
  2. Quel entier représente 11110000 ? Et 01111111 ?
  3. Effectuer l’addition binaire 00000101 + 11111101 et interpréter le résultat.
  4. Quels sont le plus grand et le plus petit entiers représentables ? Que donne le calcul de 127 + 1 ?
Correction
  1. $37 = 32 + 4 + 1 = 00100101_2$. Pour −37 : on inverse chaque bit, 11011010, puis on ajoute 1 : 11011011. −1 s’écrit 11111111 (inverse de 00000001 plus 1) et −128 s’écrit 10000000.
  2. 11110000 commence par 1 : c’est un négatif. On inverse, 00001111, on ajoute 1, 00010000 = 16 : le nombre est −16. 01111111 commence par 0 : c’est $64 + 32 + 16 + 8 + 4 + 2 + 1 = 127$.
  3. 00000101 + 11111101 = 1 00000010 ; la retenue sortante est ignorée sur 8 bits, il reste 00000010 = 2. On a bien calculé $5 + (-3) = 2$ : l’addition en complément à deux fonctionne sans traitement particulier des négatifs.
  4. Le plus grand est 01111111 = 127, le plus petit 10000000 = −128. Le calcul $127 + 1$ donne 10000000, soit −128 : c’est un dépassement de capacité, le résultat change de signe.

Exercice 9 : nombres flottants

On utilise la représentation IEEE 754 sur 32 bits (cours 05 - Réels) : un bit de signe, huit bits d’exposant décalé de 127, vingt-trois bits de mantisse.

  1. Écrire 6,625 en binaire, puis sous la forme normalisée $1{,}m \times 2^e$.
  2. En déduire sa représentation sur 32 bits.
  3. Quel nombre représente 0 10000000 01000000000000000000000 ?
  4. En Python, que vaut 0.1 + 0.2 == 0.3 ? Expliquer, et proposer une façon correcte de comparer deux flottants.
Correction
  1. $6{,}625 = 4 + 2 + 0{,}5 + 0{,}125 = 110{,}101_2 = 1{,}10101_2 \times 2^2$.
  2. Signe 0 (positif) ; exposant $2 + 127 = 129 = 10000001_2$ ; mantisse : les chiffres après la virgule, 10101, complétés par des zéros jusqu’à 23 bits. Représentation : 0 10000001 10101000000000000000000.
  3. Signe 0 ; exposant $10000000_2 = 128$, soit $128 - 127 = 1$ ; mantisse 01… : le nombre vaut $1{,}01_2 \times 2^1 = 10{,}1_2 = 2{,}5$.
  4. False. Ni 0,1 ni 0,2 n’ont d’écriture binaire finie : chacun est arrondi à 23 bits (52 bits en Python, qui utilise 64 bits), et la somme des deux arrondis ne tombe pas sur l’arrondi de 0,3 (0.1 + 0.2 vaut 0.30000000000000004). On compare des flottants à une tolérance près : abs(a - b) < 1e-9, ou avec math.isclose(a, b).

19 - Algorithmes gloutons 21 - Représentation des textes