Représentation des nombres : complément à deux et flottants, cours et exercices corrigés

Q: Comment coder un nombre négatif en complément à deux ?

Sur n bits, un entier x < 0 est représenté par l'écriture binaire de 2^n + x. Pour -12 sur 8 bits : 256 - 12 = 244, soit 11110100. On vérifie par l'autre méthode : on écrit 12 = 00001100, on inverse les bits (11110011), puis on ajoute 1, ce qui redonne 11110100. Le bit de poids fort vaut 1 : le nombre est bien négatif.

Q: Quel est l'intervalle des entiers en complément à deux sur n bits ?

Sur n bits, le complément à deux représente les entiers de -2^(n-1) à 2^(n-1) - 1 : de -128 à 127 sur 8 bits, de -2 147 483 648 à 2 147 483 647 sur 32 bits. Dans une addition, on ignore la retenue sortante ; il y a dépassement si et seulement si deux opérandes de même signe donnent un résultat de signe contraire. Sur 8 bits, 127 + 1 donne -128.

Q: Pourquoi 0.1 + 0.2 ne donne pas 0.3 en Python ?

Un réel n'a une écriture binaire finie que s'il s'écrit k / 2^p. C'est le cas de 0,5 ou 0,375, mais pas de 0,1, 0,2 ou 0,3 : en binaire, 0,1 s'écrit 0,0 0011 0011... sans fin. Chaque flottant est donc arrondi, chaque opération aussi, et `0.1 + 0.2` affiche `0.30000000000000004`. Ce n'est pas une erreur de Python, mais une limite du calcul en flottants.

Q: Comment est codé un flottant selon la norme IEEE 754 ?

Ce codage détaillé est au programme marocain ; en France, la norme IEEE 754 est hors programme et les sujets rappellent le format utile. Un flottant s'écrit (-1)^s × m × 2^e avec 1 ≤ m < 2. En simple précision (32 bits) : 1 bit de signe, 8 bits d'exposant décalé de 127, 23 bits de mantisse. En double précision (64 bits, les flottants de Python) : 1, 11 et 52 bits, décalage 1023. Le 1 de tête de la mantisse est implicite, ce qui donne 53 chiffres binaires significatifs, soit 15 à 16 chiffres décimaux.

Q: Comment comparer deux flottants en Python ?

Jamais avec `a == b`, à cause des arrondis. On écrit `abs(a - b) <= eps`, avec une tolérance adaptée à l'ordre de grandeur, ou la tolérance relative `abs(a - b) <= eps * abs(b)`. Pour comparer à 0, on combine les deux : `abs(a - b) <= eps_rel * abs(b) + eps_abs`. Une tolérance s'écrit `1e-9` : `1-9` vaut `1.0`.

Q: Les entiers de Python peuvent-ils déborder ?

Non : les entiers de Python ne débordent jamais. Les entiers de taille fixe, eux, calculent modulo 2^n sans lever d'erreur : un scalaire `numpy` donne seulement un avertissement, un tableau `numpy` rien du tout. Les flottants, en revanche, sont limités : le plus grand vaut environ 1,8 × 10^(308), et `2.0 1024` provoque une erreur.

MPSI
PCSI
PTSI
TSI 1
TPC 1
Offert à l'essai

Bits et octets, entiers naturels et complément à deux, entiers de Python, flottants (mantisse, exposant) et limites du calcul en Python. Propre au programme marocain : composants de l'ordinateur, conversions de base, codage des flottants et des caractères.

20méthodes
36exercices corrigés
3problèmes
20pièges
50figures

Les nombres sont ceux du chapitre complet ; chaque filière voit la partie qui correspond à son programme.

Le complément à deux est la façon dont un ordinateur code les entiers relatifs sur $n$ bits : un entier négatif $x$ y est représenté par l'écriture binaire de $2^n + x$ . Les réels sont rangés en flottants (signe, mantisse, exposant), codés selon la norme IEEE 754, dont le détail n'est exigible qu'au Maroc : les flottants de Python occupent 64 bits, ce qui explique que 0.1 + 0.2 affiche 0.30000000000000004. Ce chapitre fait partie de l'informatique commune de première année en MPSI, PCSI, PTSI, TSI et TPC, au Maroc et en France ; ses exercices reprennent des questions des sujets du CNC, de CCINP, de Mines-Ponts et de Centrale-Supélec. On y traite la représentation des entiers, le dépassement, les entiers de Python, l'absorption et la comparaison de deux flottants.

Ce que tu sauras faire

Un ordinateur ne manipule que des bits. Ce chapitre explique comment des nombres y sont rangés, et pourquoi certains calculs ne donnent pas le résultat attendu. À la fin, tu dois savoir :

compter les valeurs que l'on peut écrire sur $n$ bits et le nombre de bits nécessaire pour $N$ valeurs ;
calculer une taille mémoire en bits, en octets, en ko ou en Kio ;
donner la valeur d'un mot binaire, coder et décoder un entier relatif en complément à deux, repérer un dépassement ;
distinguer les entiers de Python des entiers de taille fixe ;
expliquer pourquoi 0,1 n'est pas représenté exactement, et décrire un flottant par son signe, sa mantisse et son exposant ;
prévoir les effets de l'arrondi (absorption, cancellation, dépassement) et comparer deux flottants sans écrire ==.

L'essentiel : Entiers Extrait gratuit

Un extrait de la fiche « L'essentiel » du chapitre. Les démonstrations sont dans le cours détaillé.

Sur $n$ bits	Plus petit	Plus grand	8 bits	32 bits
naturels	$0$	$2^n - 1$	0 à 255	0 à 4 294 967 295
complément à deux	$-2^{n-1}$	$2^{n-1} - 1$	$-128$ à $127$	$-2\,147\,483\,648$ à $2\,147\,483\,647$

Propriété Nombre de bits

Pour coder $N$ valeurs, il faut le plus petit $n$ tel que $2^n \geq N$ .
L'écriture binaire de $N \geq 1$ a $\lfloor \log_2 N \rfloor + 1$ chiffres.

Définition Complément à deux

$x \geq 0$ est codé par son écriture binaire sur $n$ bits ; $x < 0$ par celle de $2^n + x$ .
Calcul pratique pour $-x$ : inverser les bits de $x$ , puis ajouter 1.
Décodage : un mot de valeur naturelle $v$ qui commence par 1 représente $v - 2^n$ .

À retenir Addition et dépassement

Naturels : la somme est prise modulo $2^n$ ; une retenue sortante signale un dépassement.
Complément à deux : on ignore la retenue sortante. Il y a dépassement si et seulement si deux opérandes de même signe donnent un résultat de signe contraire. Sur 8 bits, $127 + 1$ donne $-128$ .
Les entiers de Python ne débordent jamais ; les entiers de taille fixe calculent modulo $2^n$ sans erreur (un scalaire numpy donne un avertissement, un tableau numpy rien).

Une méthode du chapitre Extrait gratuit

Méthode Coder un entier relatif en complément à deux

Quand l’utiliser

On demande l'écriture d'un entier relatif sur $n$ bits, ou l'on code une valeur qui peut être négative (une température, une variation, une tare).

Rappel de cours

Un entier $x$ de $[-2^{n-1}, 2^{n-1} - 1]$ est représenté par l'écriture binaire sur $n$ bits de $x$ si $x \geq 0$ , de $2^n + x$ si $x < 0$ . Pour $x > 0$ , le mot de $-x$ s'obtient aussi en inversant les bits du mot de $x$ , puis en ajoutant 1.

Démarche

Vérifier que $x$ est représentable : $-2^{n-1} \leq x \leq 2^{n-1} - 1$ .
Si $x \geq 0$ : écrire $x$ en binaire sur $n$ bits, en complétant à gauche par des 0.
Si $x < 0$ : calculer $2^n + x$ et l'écrire en binaire sur $n$ bits.
Vérifier par l'autre méthode : inverser les bits de $\lvert x \rvert$ , ajouter 1, en propageant les retenues.

Rédaction type

« $-12$ est dans $[-128, 127]$ , donc représentable sur 8 bits. Il est représenté par l'écriture binaire de $2^8 - 12 = 244$ , soit 11110100. Vérification : $12 = 00001100$ , inversé 11110011, plus 1 : 11110100. »

Exemple traité

Coder $-12$ sur 8 bits : $256 - 12 = 244 = 128 + 64 + 32 + 16 + 4$ , soit 11110100. Le bit de poids fort vaut 1 : le nombre est bien négatif.

Erreurs fréquentes

Mettre un 1 devant l'écriture de $\lvert x \rvert$ : c'est le binaire signé, pas le complément à deux.
Oublier la retenue en ajoutant 1 après l'inversion.
Coder sur $n$ bits un entier hors de l'intervalle, par exemple $128$ sur 8 bits.

Pour s’entraîner

Exercices 5, 15 et 26.

Un exercice corrigé Extrait gratuit

Exercice Coder en complément à deux ★☆☆

Donner le complément à deux sur 8 bits de $55$ , $-5$ , $-54$ et $-128$ .
Donner le complément à deux sur 16 bits des mêmes entiers.
L'entier $200$ a-t-il un complément à deux sur 8 bits ?

Indications

Méthode 5 : sur $n$ bits, un négatif $x$ est représenté par l'écriture binaire de $2^n + x$ .
Vérifie chaque résultat par « inverser puis ajouter 1 » à partir de $\lvert x \rvert$ .

Correction détaillée

Sur 8 bits ( $2^8 = 256$ $2^{8} = 256$ ) :
- $55 = 32 + 16 + 4 + 2 + 1$ : 00110111 ;
- $-5$ : $256 - 5 = 251$ , soit 11111011 ; vérification : $5$ s'écrit 00000101, inversé 11111010, plus 1 : 11111011 ;
- $-54$ : $256 - 54 = 202 = 128 + 64 + 8 + 2$ , soit 11001010 ;
- $-128$ : $256 - 128 = 128$ , soit 10000000.
Sur 16 bits, un positif reçoit des 0 en tête, un négatif des 1 en tête (car $2^{16} + x = (2^{16} - 2^8) + (2^8 + x)$ $2^{16} + x = (2^{16} - 2^{8}) + (2^{8} + x)$ , et $2^{16} - 2^8$ $2^{16} - 2^{8}$ s'écrit avec huit 1 suivis de huit 0) :
- $55$ : 00000000 00110111 ;
- $-5$ : 11111111 11111011 ;
- $-54$ : 11111111 11001010 ;
- $-128$ : 11111111 10000000.
Non : sur 8 bits, on représente les entiers de $-128$ à $127$ , et $200 > 127$ .

Interprétation : passer de 8 à 16 bits recopie le bit de signe à gauche, sans changer la valeur.

Méthodes à retenir

Le complément à deux d'un négatif commence toujours par 1. Pour élargir un mot, on recopie son bit de poids fort. Voir la méthode 5.

Dans le chapitre complet

Le cours détaillé, toute la fiche « L'essentiel », 20 méthodes, 20 pièges corrigés, la carte mentale, 36 exercices corrigés, 3 problèmes de concours, les fiches à mémoriser et l'assistant qui répond à tes questions. Ce chapitre est offert : il s’ouvre en entier avec un compte d’essai gratuit.

Ouvrir l'essai gratuit Une question ? WhatsApp

Plan du cours

1. Information, bits et mémoire
- 1.1 Information numérique et types de données
- 1.2 Bit, octet, mot
- 1.3 Unités
- 1.4 La mémoire
- 1.5 Les composants d'un ordinateur
- 1.6 Le schéma de von Neumann
- 1.7 Hiérarchie des mémoires
2. Entiers naturels
- 2.1 Écriture en base $b$
- 2.2 Valeur d'un mot binaire
- 2.3 Entiers naturels sur $n$ bits
- 2.4 Addition binaire et dépassement
- 2.5 Passer d'une base à une autre
3. Entiers relatifs : le complément à deux
- 3.1 Le problème
- 3.2 Définition
- 3.3 Calcul pratique et décodage
- 3.4 Addition et dépassement
- 3.5 Le binaire signé (signe et valeur absolue)
4. Les entiers de Python
- 4.1 Des entiers sans limite
- 4.2 Les entiers de taille fixe dans les sujets
5. Réels, décimaux, flottants
- 5.1 Quels nombres ont une écriture binaire finie
- 5.2 Écriture binaire d'une partie fractionnaire
- 5.3 Méthode des multiplications par 2 et virgule fixe
6. La virgule flottante
- 6.1 Principe
- 6.2 Les flottants de Python
- 6.3 Représentation de 0
- 6.4 La norme IEEE 754
7. Les limites du calcul en flottants
- 7.1 L'erreur d'arrondi
- 7.2 Absorption et ordre des opérations
- 7.3 Cancellation
- 7.4 Dépassements
- 7.5 Comparer deux flottants
- 7.6 Des erreurs qui ont coûté cher
8. Représentation des caractères
- 8.1 Le code ASCII
- 8.2 Au-delà de l'ASCII

Les méthodes du chapitre

Chaque méthode est une fiche : quand l'utiliser, le rappel de cours, les étapes, la rédaction attendue sur la copie, un exemple traité, les erreurs à éviter.

Compter les valeurs sur $n$ bits et les bits nécessaires pour $N$ valeurs
Calculer une taille mémoire et l'exprimer dans la bonne unité
Calculer la valeur d'un mot binaire non signé
Additionner deux mots non signés et repérer un dépassement
Coder un entier relatif en complément à deux
Décoder un mot en complément à deux
Additionner en complément à deux et détecter un dépassement
Prévoir le résultat d'un calcul sur des entiers
Décider si un nombre est représenté exactement par un flottant
Prévoir le résultat d'un calcul en flottants
Comparer deux flottants avec une tolérance
Estimer la précision d'un flottant
Écrire un programme de conversion entre un entier et ses chiffres dans une base
Convertir un entier décimal en base 2 ou 16 par divisions successives
Passer du binaire à l'hexadécimal ou à l'octal par paquets
Coder en signe et valeur absolue et montrer ses défauts
Écrire un nombre à virgule en binaire et en virgule fixe
Encoder un réel en simple précision IEEE 754
Décoder un mot IEEE 754 de 32 ou 64 bits
Coder et décoder un texte en ASCII

Les exercices corrigés

Chaque exercice a ses indications, sa correction rédigée et ce qu'il faut en retenir.

Application directe (15)

Combien de bits ?
Coder les quatre bases de l'ADN
Valeur de mots binaires
Taille d'une image bitmap
Coder en complément à deux
Décoder des mots de 8 bits
Les bornes des entiers de 8, 16, 32 et 64 bits
Additions sur 8 bits signés
Prévoir la sortie de calculs en flottants
Mémoire d'un tableau de mesures
Conversions entre les bases 2, 8, 10 et 16
Du binaire à l'hexadécimal
Signe et valeur absolue, puis complément à deux
Nombres à virgule en binaire
Lire un message en ASCII

Entraînement (16)

Photographies et spectres d'un relevé du ciel
Pixels non signés
Un convertisseur de 10 bits signés
Le convertisseur d'un tensiomètre
Pourquoi « inverser et ajouter 1 » marche
La règle du dépassement
Entiers de Python et entiers de taille fixe
Absorption et ordre de sommation
Combien de chiffres significatifs ?
Trouver l'erreur dans un test de comparaison
Une boucle qui ne s'arrête pas
Les chiffres d'un entier dans une base
Encoder en simple précision
Décoder des mots de 32 bits
Une mémoire de 4 Mo en mots de 32 bits
Le robot à six instructions

Approfondissement (5)

Le pas d'une dérivée numérique
Racines d'un trinôme et cancellation
Coder une chaîne par un flottant
Complément à deux en Python, et preuve
Un mot de 64 bits

Les problèmes de concours

Des extraits de sujets réels, corrigés en entier, avec la durée conseillée et les méthodes mobilisées.

L'écriture binaire d'un entier
CNC 2017, filières MP, PSI et TSI, épreuve d'informatique, partie II, questions II.1 et II.2 (a, b, c)
Cacher une image dans les bits de poids faible
CNC 2026, filière PSI, épreuve d'informatique, partie III, questions 21 à 26
Pixels codés sur des entiers de taille fixe
Centrale-Supélec 2020, filières MP, PC, PSI et TSI, épreuve d'informatique, partie I, questions 1, 2, 3 et 5, et partie II, question 12, complétées

Questions fréquentes

Comment coder un nombre négatif en complément à deux ?

Sur $n$ bits, un entier $x < 0$ est représenté par l'écriture binaire de $2^n + x$ . Pour $-12$ sur 8 bits : $256 - 12 = 244$ , soit 11110100. On vérifie par l'autre méthode : on écrit $12$ = 00001100, on inverse les bits (11110011), puis on ajoute 1, ce qui redonne 11110100. Le bit de poids fort vaut 1 : le nombre est bien négatif.

Quel est l'intervalle des entiers en complément à deux sur n bits ?

Sur $n$ bits, le complément à deux représente les entiers de $-2^{n-1}$ à $2^{n-1} - 1$ : de $-128$ à $127$ sur 8 bits, de $-2\,147\,483\,648$ à $2\,147\,483\,647$ sur 32 bits. Dans une addition, on ignore la retenue sortante ; il y a dépassement si et seulement si deux opérandes de même signe donnent un résultat de signe contraire. Sur 8 bits, $127 + 1$ donne $-128$ .

Pourquoi 0.1 + 0.2 ne donne pas 0.3 en Python ?

Un réel n'a une écriture binaire finie que s'il s'écrit $k / 2^p$ . C'est le cas de 0,5 ou 0,375, mais pas de 0,1, 0,2 ou 0,3 : en binaire, 0,1 s'écrit 0,0 0011 0011... sans fin. Chaque flottant est donc arrondi, chaque opération aussi, et 0.1 + 0.2 affiche 0.30000000000000004. Ce n'est pas une erreur de Python, mais une limite du calcul en flottants.

Comment est codé un flottant selon la norme IEEE 754 ?

Ce codage détaillé est au programme marocain ; en France, la norme IEEE 754 est hors programme et les sujets rappellent le format utile. Un flottant s'écrit $(-1)^s \times m \times 2^e$ avec $1 \leq m < 2$ . En simple précision (32 bits) : 1 bit de signe, 8 bits d'exposant décalé de 127, 23 bits de mantisse. En double précision (64 bits, les flottants de Python) : 1, 11 et 52 bits, décalage 1023. Le 1 de tête de la mantisse est implicite, ce qui donne 53 chiffres binaires significatifs, soit 15 à 16 chiffres décimaux.

Comment comparer deux flottants en Python ?

Jamais avec a == b, à cause des arrondis. On écrit abs(a - b) <= eps, avec une tolérance adaptée à l'ordre de grandeur, ou la tolérance relative abs(a - b) <= eps * abs(b). Pour comparer à 0, on combine les deux : abs(a - b) <= eps_rel * abs(b) + eps_abs. Une tolérance s'écrit 1e-9 : 1**-9 vaut 1.0.

Les entiers de Python peuvent-ils déborder ?

Non : les entiers de Python ne débordent jamais. Les entiers de taille fixe, eux, calculent modulo $2^n$ sans lever d'erreur : un scalaire numpy donne seulement un avertissement, un tableau numpy rien du tout. Les flottants, en revanche, sont limités : le plus grand vaut environ $1{,}8 \times 10^{308}$ , et 2.0 ** 1024 provoque une erreur.

Comment y accéder

Ce chapitre fait partie des chapitres offerts : il s'ouvre en entier avec un compte d'essai gratuit. Créer un compte d'essai ou se connecter. Pour l'accès complet, les tarifs ou une question, écris-nous sur WhatsApp.