$course$/QCM de NSI/Première/Numération et représentation des entiers Systèmes de numération positionnels (binaire, décimal, hexadécimal),
conversions entre bases, opérations sur les entiers naturels,
représentation des entiers relatifs en complément à deux,
dépassement de capacité, applications (couleurs, adresses mémoire).

]]> Numération et représentation des entiers — Q01 : Définition d'un bit Que désigne précisément le mot bit en informatique ?

]]> Le bit est l'unité élémentaire d'information en numérique.
Huit bits forment un octet. Les capacités de stockage usuelles
sont mesurées en octets, kilo-octets, méga-octets, etc.

]]> 1.0 0.0 0 true true abc Un groupe de huit chiffres binaires

]]> Erreur : un groupe de huit chiffres binaires s'appelle un
octet (en anglais byte), pas un bit.

]]> Une unité de mesure de la mémoire vive

]]> Erreur : le bit est plutôt l'unité élémentaire d'information.
La mémoire vive se mesure en octets, kilo-octets,
giga-octets, etc.

]]> Un chiffre binaire pouvant valoir 0 ou 1

]]> Bonne réponse : « bit » est la contraction de
binary digit. C'est l'unité élémentaire d'information,
qui ne peut prendre que deux valeurs 0 ou 1.

]]> Un nombre hexadécimal sur quatre chiffres

]]> Erreur : un chiffre hexadécimal correspond à quatre bits,
mais le bit lui-même est l'unité de base, pas un nombre
hexadécimal.

]]> Numération et représentation des entiers — Q02 : Symboles du système hexadécimal Combien de symboles différents utilise le système hexadécimal
(base 16) ?

]]> L'hexadécimal est très utilisé en informatique pour sa
compacité : un chiffre hexadécimal correspond à exactement
quatre bits, soit la moitié d'un octet. Cela rend la lecture
des données binaires beaucoup plus aisée.

]]> 1.0 0.0 0 true true abc 10

]]> Erreur : c'est le nombre de symboles du système décimal
(base 10). En hexadécimal, on a besoin de symboles
supplémentaires pour représenter 10, 11, \ldots, 15.

]]> 16

]]> Bonne réponse : la base 16 utilise 16 symboles, à savoir
les chiffres 0 à 9 pour les valeurs 0 à 9, puis les
lettres A, B, C, D, E, F pour les valeurs 10 à 15.

]]> 2

]]> Erreur : c'est le nombre de symboles de la base 2 (le
binaire), pas de la base 16.

]]> 26

]]> Erreur : confusion possible avec le nombre de lettres de
l'alphabet. L'hexadécimal utilise 10 chiffres et 6
lettres, soit 16 symboles au total.

]]> Numération et représentation des entiers — Q03 : Conversion binaire vers décimal Que vaut 1011₂ en base décimale ?

]]> Méthode : pour convertir un binaire en décimal, on associe à
chaque bit une puissance de 2 (en partant de la droite à
2⁰) et on additionne les puissances correspondant aux bits
à 1.

]]> 1.0 0.0 0 true true abc 11

]]> Bonne réponse : 1011₂ = 1 · 8 + 0 · 4 + 1 · 2 + 1 · 1 = 11₁₀.

]]> 13

]]> Erreur : confusion possible avec 1101₂. Bien lire les
bits de gauche à droite et associer chacun à sa puissance
de 2.

]]> 14

]]> Erreur : possible erreur de calcul ou décalage. Vérifier en
additionnant : 1011₂ = 8 + 2 + 1 = 11.

]]> 1011

]]> Erreur : ce serait la lecture comme un nombre décimal. Or
en base 2, chaque position a un poids différent
(puissance de 2, pas de 10).

]]> Numération et représentation des entiers — Q04 : Conversion décimal vers binaire Quelle est l'écriture binaire (sur quatre bits) de l'entier
10 ?

]]> Méthode des divisions successives par 2 : 10 = 5 × 2 + 0,
5 = 2 × 2 + 1, 2 = 1 × 2 + 0, 1 = 0 × 2 + 1.
On lit les restes de bas en haut : 1010₂.

]]> 1.0 0.0 0 true true abc 1010₂

]]> Bonne réponse : 10 = 8 + 2 = 1 · 2³ + 0 · 2² + 1 · 2¹ + 0 · 2⁰ = 1010₂.

]]> 0010₂

]]> Erreur : c'est 2₁₀. Confusion possible entre la
lecture de l'écriture décimale 10 et la valeur binaire.

]]> 1100₂

]]> Erreur : c'est 12₁₀, pas 10. Vérifier en
décomposant : 1100₂ = 8 + 4 = 12.

]]> 0101₂

]]> Erreur : c'est 5₁₀, pas 10. Possible inversion des
bits (lecture dans le mauvais sens).

]]> Numération et représentation des entiers — Q05 : Composition d'un octet Combien de bits contient un octet ?

]]> Le nom octet renvoie directement à « huit ». Le mot anglais
byte est utilisé dans la plupart des langages de
programmation.

]]> 1.0 0.0 0 true true abc 4

]]> Erreur : 4 bits forment un demi-octet (parfois appelé
quartet ou nibble), équivalent à un chiffre hexadécimal.

]]> 8

]]> Bonne réponse : un octet (en anglais byte) est un groupe
de huit bits. Il peut représenter 2⁸ = 256 valeurs
différentes.

]]> 1

]]> Erreur : un seul bit ne forme pas un octet. Un bit est
l'unité élémentaire d'information.

]]> 16

]]> Erreur : 16 bits forment deux octets, soit un short ou
word selon les architectures.

]]> Numération et représentation des entiers — Q06 : Plus grand entier naturel sur un octet Quel est le plus grand entier naturel que l'on peut représenter
sur un octet (huit bits) ?

]]> Sur n bits, on peut coder 2ⁿ valeurs différentes, soit les
entiers naturels de 0 à 2ⁿ - 1. Pour n = 8, c'est de 0
à 255.

]]> 1.0 0.0 0 true true abc 128

]]> Erreur : 128 est le seuil entre nombres positifs et
négatifs en complément à deux, mais ce n'est pas le
maximum d'un entier naturel sur un octet.

]]> 255

]]> Bonne réponse : sur huit bits, on peut coder les entiers
naturels de 0 à 2⁸ - 1 = 255. Le maximum correspond à
11111111₂.

]]> 511

]]> Erreur : 511 = 2⁹ - 1 est le maximum sur neuf bits,
pas huit.

]]> 256

]]> Erreur : un octet permet 256 valeurs différentes (de
0 à 255), mais pas la valeur 256 elle-même.

]]> Numération et représentation des entiers — Q07 : Préfixes des bases en Python En Python, quel préfixe utilise-t-on pour écrire un littéral
hexadécimal ?

]]> Python accepte trois préfixes : 0b (binaire), 0o (octal) et
0x (hexadécimal). On peut aussi utiliser int("FF", 16) pour
convertir une chaîne en entier dans une base donnée.

]]> 1.0 0.0 0 true true abc 0o

]]> Erreur : 0o est le préfixe pour l'octal (base 8),
rarement utilisé.

]]> 0b

]]> Erreur : 0b est le préfixe pour le binaire (par
exemple 0b101 == 5).

]]> 0h

]]> Erreur : 0h n'est pas un préfixe valide en Python. Cela
provoquerait une erreur de syntaxe.

]]> 0x

]]> Bonne réponse : 0x introduit un littéral hexadécimal.
Par exemple 0xFF == 255.

]]> Numération et représentation des entiers — Q08 : Bits par chiffre hexadécimal Combien de bits sont nécessaires pour coder un chiffre
hexadécimal ?

]]> Cette correspondance exacte (un chiffre hexa = quatre bits) est
très pratique : pour convertir entre binaire et hexadécimal,
on regroupe simplement les bits par paquets de quatre, sans
calcul.

]]> 1.0 0.0 0 true true abc 8

]]> Erreur : huit bits forment un octet, ce qui correspond à
deux chiffres hexadécimaux (de 00 à FF).

]]> 1

]]> Erreur : un seul bit ne permet de coder que deux valeurs
(0 et 1). Or l'hexadécimal nécessite seize valeurs.

]]> 4

]]> Bonne réponse : 2⁴ = 16, donc quatre bits suffisent à
coder les seize valeurs hexadécimales. C'est ce qui rend
la conversion entre hexadécimal et binaire si simple.

]]> 16

]]> Erreur : confusion entre la base (16 symboles) et le
nombre de bits requis. 4 bits suffisent puisque
2⁴ = 16.

]]> Numération et représentation des entiers — Q09 : Lecture d'un chiffre hexadécimal Quelle est la valeur décimale de la lettre C utilisée comme
chiffre hexadécimal ?

]]> Mémo : A vaut 10 et chaque lettre suivante incrémente
d'une unité, jusqu'à F qui vaut 15.

]]> 1.0 0.0 0 true true abc 13

]]> Erreur : 13 correspond à la lettre D. La lettre C
vient juste avant, donc vaut 12.

]]> 12

]]> Bonne réponse : les lettres A, B, C, D, E, F valent
respectivement 10, 11, 12, 13, 14, 15.

]]> 11

]]> Erreur : 11 correspond à la lettre B. La lettre C
vient juste après, donc vaut 12.

]]> 3

]]> Erreur : confusion possible avec la position de C dans
l'alphabet. En hexadécimal, A vaut 10, B vaut 11, C
vaut 12, etc.

]]> Numération et représentation des entiers — Q10 : Bit de poids fort Que désigne le bit de poids fort dans la représentation
binaire d'un nombre ?

]]> En complément à deux, le bit de poids fort joue un rôle
particulier : il indique le signe (0 pour positif, 1 pour
négatif).

]]> 1.0 0.0 0 true true abc Le bit le plus à gauche, qui correspond à la plus grande puissance de 2

]]> Bonne réponse : sur n bits, le bit de poids fort est en
position n-1, avec un poids de 2ⁿ⁻¹.

]]> Le bit le plus à droite (de poids 2⁰)

]]> Erreur : c'est le bit de poids faible. Le bit de poids
fort est au contraire celui dont la position a la plus
grande valeur.

]]> Le bit qui change le plus souvent quand on incrémente le nombre

]]> Erreur : c'est au contraire le bit de poids faible qui
change à chaque incrément. Le bit de poids fort change le
moins souvent.

]]> Le bit qui vaut systématiquement 1

]]> Erreur : un bit de poids fort peut valoir 0 ou 1,
comme tout autre bit.

]]> Numération et représentation des entiers — Q11 : Conversion binaire vers décimal sur huit bits Que vaut 01001101₂ en base décimale ?

]]> Astuce : pour les conversions sur huit bits, mémoriser les
puissances de 2 jusqu'à 2⁷ = 128. La somme des bits à 1
donne directement la valeur décimale.

]]> 1.0 0.0 0 true true abc 74

]]> Erreur de calcul : vérifier les puissances de 2 associées
aux bits à 1. On doit avoir 2⁶ + 2³ + 2² + 2⁰.

]]> 77

]]> Bonne réponse : 01001101₂ = 64 + 8 + 4 + 1 = 77₁₀.
Les bits à 1 sont aux positions 6, 3, 2, 0.

]]> 93

]]> Erreur : c'est 01011101₂. Lire attentivement les bits.

]]> 109

]]> Erreur : c'est 01101101₂, pas 01001101₂. Bien
identifier la position de chaque bit à 1.

]]> Numération et représentation des entiers — Q12 : Conversion hexadécimal vers binaire Quelle est l'écriture binaire de A3F₁₆ ?

]]> Un chiffre hexa = quatre bits. La conversion est purement
mécanique : il suffit de remplacer chaque chiffre hexa par les
quatre bits correspondants, dans l'ordre.

]]> 1.0 0.0 0 true true abc 1010001111₂

]]> Erreur : il manque deux bits. Chaque chiffre hexadécimal
doit être codé sur exactement quatre bits, en complétant
par des zéros à gauche si nécessaire.

]]> 111000111101₂

]]> Erreur : vérifier la conversion de chaque chiffre.
A → 1010, pas 1110.

]]> 101000111111₂

]]> Bonne réponse : A → 1010, 3 → 0011, F → 1111.
Mis bout à bout : 1010\ 0011\ 1111₂.

]]> 111111000110₂

]]> Erreur : on a inversé l'ordre des chiffres. Lire de gauche
à droite : A puis 3 puis F.

]]> Numération et représentation des entiers — Q13 : Addition binaire avec retenue Que vaut 1011₂ + 0110₂ (addition binaire sur quatre bits) ?

]]> L'addition binaire suit les mêmes règles que l'addition
décimale, avec retenues : 0+0 = 0, 0+1 = 1, 1+1 = 10
(retenue), 1+1+1 = 11 (retenue). Si le résultat sort de
l'intervalle de codage, on parle de dépassement.

]]> 1.0 0.0 0 true true abc 0001₂

]]> Erreur : on ne peut pas obtenir un nombre plus petit que
1011 en lui ajoutant un nombre positif. Vérifier la
retenue.

]]> 0101₂

]]> Erreur : confusion possible avec un XOR (différence) au
lieu d'une addition.

]]> 1101₂

]]> Erreur : confusion possible entre OU logique et addition.
L'addition propage des retenues, contrairement au OU.

]]> 10001₂

]]> Bonne réponse : 1011 + 0110 = 10001₂ (en posant l'addition
colonne par colonne, avec retenues). Vérification :
11 + 6 = 17 = 16 + 1 = 10001₂.

]]> Numération et représentation des entiers — Q14 : Intervalle de codage en complément à deux Sur huit bits en complément à deux, quel est l'intervalle des
entiers relatifs codables ?

]]> Sur n bits en complément à deux, l'intervalle est
[-2ⁿ⁻¹ ; 2ⁿ⁻¹ - 1]. La dissymétrie (un négatif de
plus) vient du fait que 0 est compté côté positif.

]]> 1.0 0.0 0 true true abc [-128 ; 127]

]]> Bonne réponse : sur n = 8 bits, l'intervalle est
[-2ⁿ⁻¹ ; 2ⁿ⁻¹ - 1] = [-128 ; 127].

]]> [-128 ; 128]

]]> Erreur : la valeur 128 ne peut pas être codée car
10000000₂ vaut -128 en complément à deux.

]]> [-127 ; 127]

]]> Erreur : il y a un négatif de plus que de positifs. La
plus petite valeur est -128, pas -127.

]]> [0 ; 255]

]]> Erreur : c'est l'intervalle des entiers naturels
(non signés) sur huit bits.

]]> Numération et représentation des entiers — Q15 : Calcul du complément à deux Quelle est la représentation binaire de -19 sur huit bits, en
complément à deux ?

]]> Les trois étapes du complément à deux : (1) écrire la valeur
absolue en binaire, (2) inverser tous les bits (complément à
un), (3) ajouter 1. Cela revient à calculer 2ⁿ - |x|.

]]> 1.0 0.0 0 true true abc 11101101

]]> Bonne réponse : étape par étape, 19 = 00010011, on
inverse → 11101100, on ajoute 1 → 11101101.

]]> 11101100

]]> Erreur : c'est le complément à un (inversion des bits)
mais on a oublié l'étape finale d'ajouter 1.

]]> 11101110

]]> Erreur : on a ajouté 2 au lieu de 1 après inversion,
ou on a inversé un bit de plus.

]]> 10010011

]]> Erreur : c'est la représentation naïve (signe + valeur
absolue), qui n'est pas le complément à deux. Cette
notation a des défauts qui justifient justement le
complément à deux.

]]> Numération et représentation des entiers — Q16 : Lecture d'un nombre négatif Que vaut 11111101₂ interprété en complément à deux sur huit
bits ?

]]> Méthode : si le bit de poids fort vaut 1, le nombre est
négatif. On retrouve sa valeur absolue en appliquant à
nouveau le complément à deux (inversion + 1).

]]> 1.0 0.0 0 true true abc -125

]]> Erreur : confusion possible. Vérifier en posant l'addition
00000011 + 11111101 : si on obtient 00000000 (avec
retenue ignorée), c'est bien 3 et -3.

]]> -253

]]> Erreur : on a oublié que la valeur absolue se déduit en
appliquant à nouveau le complément à deux, pas en lisant
la magnitude restante.

]]> 253

]]> Erreur : c'est la lecture comme entier naturel. Or le
bit de poids fort à 1 indique un nombre négatif en
complément à deux.

]]> -3

]]> Bonne réponse : on inverse → 00000010, on ajoute 1 →
00000011 = 3, le bit de poids fort à 1 donne le signe
négatif. Donc -3.

]]> Numération et représentation des entiers — Q17 : Couleurs HTML en hexadécimal En CSS, la couleur #FF5733 est codée en hexadécimal sur six
chiffres. Que vaut la composante rouge en décimal ?

]]> Une couleur RVB sur huit bits par composante prend la forme
#RRVVBB où chaque paire de chiffres hexa code une valeur
entre 00 et FF (0 et 255). Ici : rouge = FF = 255,
vert = 57 = 87, bleu = 33 = 51.

]]> 1.0 0.0 0 true true abc 33

]]> Erreur : confusion entre la lecture décimale et
hexadécimale. 33₁₆ = 3 · 16 + 3 = 51₁₀.

]]> 87

]]> Erreur : 87 correspond à la composante verte 57₁₆.

]]> 255

]]> Bonne réponse : la composante rouge est FF₁₆, soit
15 · 16 + 15 = 255₁₀. C'est le maximum possible
pour une composante.

]]> 51

]]> Erreur : 51 correspond à la composante bleue 33₁₆.
Les composantes sont dans l'ordre RVB (rouge, vert, bleu).

]]> Numération et représentation des entiers — Q18 : Nombre de valeurs codables Combien de valeurs différentes peut-on représenter sur n bits ?

]]> Cette croissance exponentielle explique pourquoi les
processeurs 64 bits (2⁶⁴ adresses possibles) couvrent
toute la mémoire imaginable, alors que les processeurs 32
bits (≈ 4 · 10⁹ adresses) sont déjà saturés pour
la mémoire moderne.

]]> 1.0 0.0 0 true true abc n

]]> Erreur : confusion entre le nombre de bits et le nombre de
valeurs. Avec 1 bit on a 2 valeurs, avec 2 bits on
en a 4, pas 2.

]]> 2 · n

]]> Erreur : la croissance n'est pas linéaire mais
exponentielle. Chaque bit supplémentaire double le
nombre de valeurs possibles.

]]> 2ⁿ

]]> Bonne réponse : chaque bit pouvant prendre deux valeurs
indépendamment des autres, n bits permettent
2 × 2 × ·s × 2 = 2ⁿ combinaisons.

]]> n²

]]> Erreur : la croissance n'est pas polynomiale mais
exponentielle. Pour n = 10, on a 2¹⁰ = 1024, pas
100.

]]> Numération et représentation des entiers — Q19 : Astuce rapide du complément à deux Pour calculer rapidement le complément à deux d'un nombre, on
parcourt ses bits de droite à gauche. Que fait-on ?

]]> Exemple : 20 = 00010100. On garde « ...100 » (jusqu'au
premier 1 depuis la droite) et on inverse le reste :
11101100 = -20. Cette astuce évite l'étape « inversion +
addition de 1 ».

]]> 1.0 0.0 0 true true abc On ajoute 1 à chaque bit individuellement

]]> Erreur : ce n'est pas une opération sensée en binaire
(chaque bit ne vaut que 0 ou 1).

]]> On inverse tous les bits sans exception

]]> Erreur : c'est le complément à un. L'astuce du
complément à deux laisse une partie des bits inchangée.

]]> On garde les bits jusqu'au premier 1 inclus, puis on inverse les bits suivants

]]> Bonne réponse : on conserve la partie droite (zéros et le
premier 1) et on inverse tout le reste à gauche. Cela
évite les étapes intermédiaires.

]]> On inverse les bits jusqu'au premier 1, puis on garde les suivants

]]> Erreur : c'est l'inverse de la bonne règle. On commence par
garder la partie droite, puis on inverse à gauche.

]]> Numération et représentation des entiers — Q20 : Asymétrie positifs/négatifs Pourquoi y a-t-il un négatif de plus que de positifs en
complément à deux ?

]]> Sur huit bits, on a 256 codes : 128 pour les non négatifs
(0, 1, \ldots, 127) et 128 pour les négatifs
(-128, -127, \ldots, -1). C'est une particularité du
complément à deux qu'il faut connaître.

]]> 1.0 0.0 0 true true abc Parce que le complément à deux gaspille un code

]]> Erreur : au contraire, le complément à deux n'a pas de
double représentation du zéro, il utilise donc tous les
codes possibles.

]]> Parce que la représentation est moins efficace pour les positifs

]]> Erreur : la représentation est efficace symétrique pour la
plupart des opérations. La dissymétrie tient à un autre
phénomène.

]]> Parce que 0 est compté du côté des positifs et n'a qu'une seule représentation

]]> Bonne réponse : sur n bits, on a 2ⁿ codes différents,
dont une moitié pour les négatifs et une moitié pour les
positifs. Comme 0 est compté avec les positifs, il y en
a un de moins côté positif.

]]> Parce que les nombres négatifs prennent plus de bits

]]> Erreur : tous les codes ont la même longueur en bits.
C'est la convention de signe qui crée la dissymétrie.

]]> Numération et représentation des entiers — Q21 : Dépassement de capacité Sur huit bits en complément à deux, que renvoie l'addition
127 + 1 ?

]]> Le dépassement est un piège classique en C/Java. En complément
à deux, l'incrément du plus grand positif donne le plus petit
négatif. C'est la cause de bugs célèbres (faille de
l'algorithme de tri, débordement dans les calculs financiers).

]]> 1.0 0.0 0 true true abc 0

]]> Erreur : confusion possible avec une remise à zéro après
débordement, qui se produit pour les entiers non signés
(255 + 1 = 0 mod 256). Ici, on est en signé.

]]> -128

]]> Bonne réponse : 01111111 + 00000001 = 10000000. Or sur
huit bits en complément à deux, 10000000₂ = -128. Il y
a dépassement de capacité (overflow).

]]> Une erreur Python

]]> Erreur : Python n'a pas de limite de taille des entiers,
donc cette question concerne les langages à entiers de
taille fixe (C, Java, etc.). En Python, 127 + 1 = 128
sans souci.

]]> 128

]]> Erreur : 128 n'est pas représentable sur huit bits en
complément à deux (l'intervalle s'arrête à 127). Le
résultat est donc « tordu ».

]]> Numération et représentation des entiers — Q22 : Défaut de la représentation naïve Pourquoi n'utilise-t-on pas la représentation naïve (bit de
poids fort = signe, autres bits = valeur absolue) pour coder
les entiers relatifs ?

]]> C'est précisément pour pouvoir réutiliser le circuit
d'addition standard que les processeurs adoptent le complément
à deux. La représentation naïve aurait aussi le défaut d'avoir
deux représentations du zéro (+0 et -0).

]]> 1.0 0.0 0 true true abc Parce qu'elle ne permet pas de coder les nombres négatifs

]]> Erreur : elle code bien les négatifs, mais avec deux
défauts qui la rendent peu pratique.

]]> Parce qu'elle utilise plus de bits que le complément à deux

]]> Erreur : les deux représentations utilisent le même nombre
de bits.

]]> Parce que l'addition binaire usuelle ne donne pas le bon résultat sur les négatifs

]]> Bonne réponse : avec la représentation naïve, on ne peut
plus utiliser l'additionneur standard pour les
soustractions. Le complément à deux résout ce problème :
le même circuit d'addition fonctionne pour positifs et
négatifs.

]]> Parce qu'elle est plus lente à interpréter

]]> Erreur : la lecture est en réalité plus simple (signe
+ valeur absolue). Le problème est ailleurs : dans
l'arithmétique.

]]> Numération et représentation des entiers — Q23 : Différence entre complément à un et complément à deux En quoi le complément à deux diffère-t-il du complément à un ?

]]> Le complément à un (inversion seule) crée deux représentations
du zéro (00\ldots0 et 11\ldots1). L'ajout du « +1 » du
complément à deux fait fusionner ces deux zéros et permet
d'utiliser l'arithmétique standard sans correction.

]]> 1.0 0.0 0 true true abc Le complément à un est calculé sur deux bits, le complément à deux sur deux octets

]]> Erreur : confusion sur les noms. Aucune des deux
appellations ne renvoie au nombre de bits.

]]> Le complément à deux n'utilise pas le bit de poids fort comme signe

]]> Erreur : au contraire, le bit de poids fort sert de
signe en complément à deux (0 pour positif, 1 pour
négatif).

]]> Le complément à un ne fonctionne que pour les nombres positifs

]]> Erreur : le complément à un peut s'appliquer à n'importe
quel motif binaire ; c'est juste une inversion de bits.

]]> Le complément à un inverse tous les bits ; le complément à deux inverse tous les bits puis ajoute 1

]]> Bonne réponse : le complément à un est l'étape
intermédiaire de l'opération du complément à deux. Le « +1 »
final corrige la double représentation du zéro qui
subsisterait sans cette correction.

]]> Numération et représentation des entiers — Q24 : Cas particulier de la valeur minimum Sur huit bits en complément à deux, à quoi correspond le motif
10000000₂ ?

]]> Cette valeur est piégeuse : son opposé +128 n'existe pas en
huit bits signés. Calculer -(-128) provoque un dépassement
qui ramène à -128 lui-même. C'est une source classique de
bugs en C ou Java.

]]> 1.0 0.0 0 true true abc 0

]]> Erreur : 0 est codé 00000000. Le motif 10000000 est
la plus petite valeur signée.

]]> -127

]]> Erreur : la valeur -127 correspond à 10000001₂. Le
motif 10000000 correspond à un cas un peu spécial.

]]> -128

]]> Bonne réponse : -128 = -2ⁿ⁻¹ = -2⁷. C'est la valeur
minimum codable sur huit bits en complément à deux. Cette
valeur n'a pas d'opposé représentable (il n'y a pas
+128).

]]> 128

]]> Erreur : 128 n'est pas représentable sur huit bits en
complément à deux (l'intervalle s'arrête à 127).

]]> Numération et représentation des entiers — Q25 : Entiers en Python vs en C En Python, l'expression 2 ** 100 donne un nombre entier
exact, alors qu'en C ou en Java elle provoquerait un
dépassement. Pourquoi ?

]]> Cette caractéristique est un atout pédagogique de Python :
l'élève n'a pas à se soucier des limites de codage. Mais cela
a un coût : les opérations sur de très grands entiers sont
plus lentes que sur des entiers de taille fixe.

]]> 1.0 0.0 0 true true abc Python utilise des nombres flottants pour tous les calculs entiers

]]> Erreur : Python distingue bien les entiers (int) des
flottants (float). 2¹⁰⁰ est calculé comme un entier
exact, pas approché.

]]> Python tronque silencieusement les entiers trop grands

]]> Erreur : aucune troncature. Le résultat est exact, même
pour des nombres immenses.

]]> Python fait des calculs modulo 2⁶⁴

]]> Erreur : c'est le comportement de C/Java sur entiers
64 bits. Python n'a pas de modulo implicite.

]]> Python adapte automatiquement la mémoire allouée aux entiers, sans limite fixe

]]> Bonne réponse : les entiers Python sont en précision
arbitraire. L'interpréteur réserve autant de mémoire que
nécessaire pour représenter le nombre exactement.

]]> Numération et représentation des entiers — Q26 : Conversion décimal vers hexadécimal Quelle est l'écriture hexadécimale de l'entier 195 ?

]]> Méthode des divisions successives par 16 : tant que le
quotient n'est pas nul, on note le reste et on continue avec
le quotient. Ici, 195 ÷ 16 = 12 reste 3, puis
12 ÷ 16 = 0 reste 12 (\text{C}). On lit les restes
du dernier au premier : \text{C3}_{16}.

]]> 1.0 0.0 0 true true abc \text{C3}_{16}

]]> Bonne réponse : 195 = 12 × 16 + 3. Le quotient 12
s'écrit \text{C} et le reste 3 s'écrit 3, d'où
\text{C3}_{16}.

]]> \text{C5}_{16}

]]> Erreur sur le reste : 195 - 12 × 16 = 195 - 192 = 3
(et non 5). Bien vérifier la soustraction finale qui
donne le dernier chiffre.

]]> \text{3C}_{16}

]]> Erreur : les chiffres ont été inversés. Le quotient se
lit en premier (à gauche), suivi du reste à droite. Le
bon résultat est \text{C3}_{16}.

]]> \text{A3}_{16}

]]> Erreur sur le quotient : on a pris la lettre \text{A}
(qui vaut 10) au lieu de \text{C} (qui vaut 12). Or
195 ÷ 16 = 12 reste 3, donc le chiffre des
« seize » est bien \text{C}.

]]> Numération et représentation des entiers — Q27 : Nombre minimum de bits Combien de bits sont nécessaires au minimum pour coder en
binaire l'entier naturel 287 ?

]]> Méthode : chercher le plus petit n tel que 2ⁿ - 1 ≥ 287,
ou de façon équivalente 2ⁿ ≥ 288. Ici, 2⁸ = 256 et
2⁹ = 512, donc le minimum est n = 9. De manière plus
formelle, ce nombre est \lceil \log_2(287 + 1) \rceil = 9.

]]> 1.0 0.0 0 true true abc 9

]]> Bonne réponse : on cherche le plus petit n tel que
2ⁿ > 287. Or 2⁸ = 256 (insuffisant) et 2⁹ = 512
(suffisant), donc n = 9.

]]> 7

]]> Erreur : sur 7 bits, on peut coder les entiers de 0
à 2⁷ - 1 = 127. Or 287 > 127, donc 7 bits ne
suffisent pas.

]]> 8

]]> Erreur : sur 8 bits, on couvre l'intervalle
[0 ; 2⁸ - 1] = [0 ; 255]. Comme 287 > 255, un
octet est encore insuffisant.

]]> 10

]]> Erreur : 10 bits suffisent largement (ils couvrent
jusqu'à 1023), mais ce n'est pas le minimum. Avec
9 bits, on atteint déjà 511, ce qui est suffisant
pour 287.

]]> Numération et représentation des entiers — Q28 : Décalage binaire à gauche En Python, que vaut l'expression 12 << 2 ?

]]> L'opérateur << (décalage à gauche) déplace tous les bits
vers la gauche, en complétant à droite par des zéros. Sur
l'écriture binaire de 12 = 1100₂, deux décalages donnent
110000₂ = 48. C'est l'équivalent rapide de la
multiplication par 2ᵏ ; l'opérateur inverse >> divise
entièrement par 2ᵏ.

]]> 1.0 0.0 0 true true abc 14

]]> Erreur : on a interprété << comme une addition
(12 + 2 = 14). Or l'opérateur << est un décalage de
bits, pas une addition.

]]> 48

]]> Bonne réponse : n << k décale les bits de n de k
positions vers la gauche, ce qui équivaut à multiplier
par 2ᵏ. Ici, 12 × 2² = 12 × 4 = 48.

]]> 24

]]> Erreur : on a multiplié par 2 une seule fois.
L'opérateur << décale de 2 positions, ce qui revient
à multiplier par 2² = 4, pas par 2.

]]> 3

]]> Erreur : on a effectué un décalage à droite (>>),
qui correspond à une division entière par 2ᵏ, soit
12 // 4 = 3. Ici, c'est << qui décale à gauche.

]]> Numération et représentation des entiers — Q29 : Plus grand entier non signé sur 32 bits Quel est le plus grand entier naturel (non signé) que l'on
peut représenter sur 32 bits ?

]]> Sur n bits, l'intervalle des entiers naturels codables est
[0 ; 2ⁿ - 1]. Pour 32 bits, cela donne environ
4{,}3 milliards de valeurs, ce qui correspond
historiquement à la limite de 4 Go pour la mémoire vive
adressable directement par un processeur 32 bits.

]]> 1.0 0.0 0 true true abc 2 × 32

]]> Erreur : la quantité de valeurs codables croît de façon
exponentielle, pas linéaire. Chaque bit
supplémentaire double le nombre de valeurs possibles.

]]> 2³² - 1

]]> Bonne réponse : sur n bits, le plus grand entier
naturel codable est 2ⁿ - 1. Pour n = 32, cela vaut
4 294 967 295, soit environ 4{,}3 \times 10^9.

]]> 2¹⁶

]]> Erreur : 2¹⁶ - 1 = 65 535 est le maximum sur 16
bits, pas sur 32. Doubler le nombre de bits élève le
maximum à un carré (à un près), pas en double.

]]> 2³²

]]> Erreur : on peut représenter 2³² valeurs
différentes (de 0 à 2³² - 1), mais la valeur
2³² elle-même nécessiterait 33 bits.

]]>