Systèmes de numération — fiche de révision

⚡ Les poids binaires — à savoir par cœur

2¹⁰	2⁹	2⁸	2⁷	2⁶	2⁵	2⁴	2³	2²	2¹	2⁰
1024	512	256	128	64	32	16	8	4	2	1

Chaque valeur est le double de sa voisine de droite. On numérote les positions à partir de 0, en partant de la droite.

n bits → 2ⁿ valeurs → de 0 à 2ⁿ − 1

Le principe de position

calcul

247₁₀ = 2×10² + 4×10¹ + 7×10⁰
1011₂ = 1×2³ + 0×2² + 1×2¹ + 1×2⁰
       = 8 + 0 + 2 + 1 = 11₁₀

En base b : b chiffres (0 à b−1), poids bⁿ.

x⁰ = 1 — la colonne de droite vaut 1 dans toutes les bases.

⚡ Le vocabulaire

bit	1 chiffre binaire : 0 ou 1
quartet	4 bits = 0 à 15 = 1 chiffre hexa
octet	8 bits = 0 à 255 = 2 chiffres hexa

Un F hexadécimal n'est pas un bit : il en vaut quatre.

2⁸ = 256 valeurs, mais la plus grande est 255.

⚡ Binaire → décimal

compter les bits → l'exposant de gauche = nb − 1
écrire les poids au-dessus
additionner seulement les colonnes à 1

calcul

101 1101₂  (7 bits → 2⁶ à gauche)
 64 32 16 8 4 2 1
  1  0  1 1 1 0 1
= 64+16+8+4+1 = 93₁₀

Finit par 1 → impair. Contrôle gratuit.

Décimal → binaire : soustractions

calcul

392 − 1×256 = 136   → 1
136 − 1×128 =   8   → 1
  8 − 0× 64 =   8   → 0
  8 − 0× 32 =   8   → 0
  8 − 0× 16 =   8   → 0
  8 − 1×  8 =   0   → 1
  0 − 0×  4 =   0   → 0
  0 − 0×  2 =   0   → 0
  0 − 0×  1 =   0   → 0

392₁₀ = 1 1000 1000₂

Le reste se reporte ligne à ligne. La dernière ligne doit donner 0.

Décimal → binaire : divisions

calcul

251 │ 2
  1 │ 125 │ 2
      1 │ 62 │ 2
           0 │ 31 │ 2
                1 │ 15 │ 2
                     1 │ 7 │ 2
                         1 │ 3 │ 2
                             1 │ 1 │ 2
                                 1 │ 0

251₁₀ = 1111 1011₂

Restes lus de bas en haut : le dernier reste est le bit de poids fort.

⚡ Addition binaire

`0+0=0`	`0+1=1`
`1+0=1`	`1+1=``10`

1+1 : on pose 0, on retient 1.

Trois ou quatre 1 dans une colonne : on additionne deux par deux. 1+1+1 = 11₂ (3) · 1+1+1+1 = 100₂ (4).

⚡ Soustraction binaire

`0−0=0`	`1−0=1`
`1−1=0`	`0−1=1` + emprunt de 2

Aligner sur le même nombre de bits avant de poser — compléter à gauche par des zéros.

Contrôle : le résultat doit être plus petit que le premier opérande.

⚡ Si A < B

A − B = − (B − A)

comparer : premier bit qui diffère, de gauche à droite
poser B − A
écrire le signe moins

Un résultat plus grand que l'opérande = un négatif en complément à deux, pas une erreur.

sur n bits : −x s'écrit 2ⁿ − x

Sur 8 bits : −4 → 256 − 4 = 252 = 1111 1100. Plage signée : −128 à +127.

Multiplication et division

0×0=0 · 0×1=0 · 1×0=0 · 1×1=1

calcul

    1 0 1 1        11
  ×   1 0 1      ×  5
  ─────────
    1 0 1 1
  0 0 0 0 ·
1 0 1 1 · ·
─────────────
1 1 0 1 1 1  = 55 ✔

a = b × q + r avec r < b

Ajouter un 0 à droite double le nombre (décalage).

⚡ La table hexadécimale

D	B	H	D	B	H
0	`0000`	0	8	`1000`	8
1	`0001`	1	9	`1001`	9
2	`0010`	2	10	`1010`	A
3	`0011`	3	11	`1011`	B
4	`0100`	4	12	`1100`	C
5	`0101`	5	13	`1101`	D
6	`0110`	6	14	`1110`	E
7	`0111`	7	15	`1111`	F

⚡ Hexa ↔ binaire : gratuit

16 = 2⁴ → 1 chiffre hexa = 4 bits

calcul

8B7₁₆ → 1000 1011 0111₂

1 1010 1111₂
→ 0001 1010 1111   ← compléter À GAUCHE
→   1    A    F    = 1AF₁₆

Le regroupement part toujours de la droite.

Décimal → hexa

Poids : 1, 16, 256, 4096, 65 536.

calcul

3151 − 12×256 = 79   → C
  79 −  4× 16 = 15   → 4
  15 − 15×  1 =  0   → F
3151₁₀ = C4F₁₆

3167 │ 16
  15 │ 197 │ 16
       5   │ 12 │ 16
             12 │  0
restes ↑ : 12,5,15 → C5F₁₆

Traduire les restes ⩾ 10 en lettres. Ou passer par le binaire : décimal → binaire → quartets → hexa.

⚡ Partie fractionnaire

2⁻¹	2⁻²	2⁻³	2⁻⁴
0,5	0,25	0,125	0,0625

Partie entière → restes à l'envers
Fractionnaire → retenues à l'endroit

calcul

0,625 × 2 = 1,25  → 1
0,25  × 2 = 0,5   → 0
0,5   × 2 = 1     → 1
        → 0,101₂

21,625₁₀ = 10101,101₂

0,1 n'existe pas en binaire

0,1₁₀ = 0,0001100110011…₂

Le motif 0011 se répète à l'infini : la machine approche.

python

>>> 0.1 + 0.2
0.30000000000000004

Donc : jamais de == entre flottants · un prix se compte en centimes entiers, ou en DECIMAL en base de données.

⚡ Les valeurs à reconnaître

Déc	Binaire	Hexa
15	`1111`	`F`
128	`1000 0000`	`80`
192	`1100 0000`	`C0`
255	`1111 1111`	`FF`
256	`1 0000 0000`	`100`
1024	`100 0000 0000`	`400`

Là où ça ressort en CIEL

Où	Exemple	À lire
Adresse IPv4	`192.168.10.1`	4 octets = 32 bits
Masque	`255.255.255.192` = /26	`192 = 1100 0000` → 24+2 bits à 1
Adresses utilisables	/26	2^(32−26) − 2 = 2⁶ − 2 = 62
Adresse MAC	`00:60:70:41:C1:D4`	12 chiffres hexa × 4 = 48 bits
Couleur web	`#2D5A27`	2D=45, 5A=90, 27=39 → rgb(45, 90, 39)
IPv6	`fe80::260:70ff:fe41:c1d4`	128 bits
Mémoire	1 kio = 1024 octets	2¹⁰, pas 1000
Permissions Linux	`chmod 755`	base 8 : 1 chiffre = 3 bits (r w x)

adresses utilisables = 2^{(32 − n)} − 2

Le « − 2 » retire l'adresse réseau (bits machine à 0) et le broadcast (tous à 1).

⚡ Les 6 contrôles gratuits

Parité : un binaire finissant par 1 est impair.
Nombre de bits : 2^k ⩽ N < 2^k+1 → k+1 bits.
Reconvertir dans l'autre sens.
Soustraction : le résultat doit être plus petit.
Division : r < b, toujours.
Base en indice : 10₂ ≠ 10₁₀ ≠ 10₁₆.