$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_2$ 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^0$) et on additionne les puissances correspondant aux bits
à $1$.

]]> 1.0 0.0 0 true true abc $11$

]]> Bonne réponse : $1011_2 = 1 \cdot 8 + 0 \cdot 4 + 1 \cdot 2 + 1 \cdot 1 = 11_{10}$.

]]> $13$

]]> Erreur : confusion possible avec $1101_2$. 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_2 = 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 \times 2 + 0$,
$5 = 2 \times 2 + 1$, $2 = 1 \times 2 + 0$, $1 = 0 \times 2 + 1$.
On lit les restes de bas en haut : $1010_2$.

]]> 1.0 0.0 0 true true abc $1010_2$

]]> Bonne réponse : $10 = 8 + 2 = 1 \cdot 2^3 + 0 \cdot 2^2 + 1 \cdot 2^1 + 0 \cdot 2^0 = 1010_2$.

]]> $0010_2$

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

]]> $1100_2$

]]> Erreur : c'est $12_{10}$, pas $10$. Vérifier en
décomposant : $1100_2 = 8 + 4 = 12$.

]]> $0101_2$

]]> Erreur : c'est $5_{10}$, 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^8 = 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^n$ valeurs différentes, soit les
entiers naturels de $0$ à $2^n - 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^8 - 1 = 255$. Le maximum correspond à
$11111111_2$.

]]> $511$

]]> Erreur : $511 = 2^9 - 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^4 = 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^4 = 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^{n-1}$.

]]> Le bit le plus à droite (de poids $2^0$)

]]> 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_2$ en base décimale ?

]]> Astuce : pour les conversions sur huit bits, mémoriser les
puissances de $2$ jusqu'à $2^7 = 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^6 + 2^3 + 2^2 + 2^0$.

]]> $77$

]]> Bonne réponse : $01001101_2 = 64 + 8 + 4 + 1 = 77_{10}$.
Les bits à $1$ sont aux positions $6, 3, 2, 0$.

]]> $93$

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

]]> $109$

]]> Erreur : c'est $01101101_2$, pas $01001101_2$. 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_{16}$ ?

]]> 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_2$

]]> 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_2$

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

]]> $101000111111_2$

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

]]> $111111000110_2$

]]> 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_2 + 0110_2$ (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_2$

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

]]> $0101_2$

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

]]> $1101_2$

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

]]> $10001_2$

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

]]> 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^{n-1}\,;\, 2^{n-1} - 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^{n-1}\,;\, 2^{n-1} - 1] = [-128\,;\, 127]$.

]]> $[-128\,;\, 128]$

]]> Erreur : la valeur $128$ ne peut pas être codée car
$10000000_2$ 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^n - |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_2$ 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_{16} = 3 \cdot 16 + 3 = 51_{10}$.

]]> $87$

]]> Erreur : $87$ correspond à la composante verte $57_{16}$.

]]> $255$

]]> Bonne réponse : la composante rouge est $FF_{16}$, soit
$15 \cdot 16 + 15 = 255_{10}$. C'est le maximum possible
pour une composante.

]]> $51$

]]> Erreur : $51$ correspond à la composante bleue $33_{16}$.
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^{64}$ adresses possibles) couvrent
toute la mémoire imaginable, alors que les processeurs $32$
bits ($\approx 4 \cdot 10^9$ 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 \cdot n$

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

]]> $2^n$

]]> Bonne réponse : chaque bit pouvant prendre deux valeurs
indépendamment des autres, $n$ bits permettent
$2 \times 2 \times \cdots \times 2 = 2^n$ combinaisons.

]]> $n^2$

]]> Erreur : la croissance n'est pas polynomiale mais
exponentielle. Pour $n = 10$, on a $2^{10} = 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^n$ 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_2 = -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_2$ ?

]]> 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_2$. Le
motif $10000000$ correspond à un cas un peu spécial.

]]> $-128$

]]> Bonne réponse : $-128 = -2^{n-1} = -2^7$. 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^{100}$ 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^{64}$

]]> 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 \div 16 = 12$ reste $3$, puis
$12 \div 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 \times 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 \times 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 \div 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^n - 1 \geq 287$,
ou de façon équivalente $2^n \geq 288$. Ici, $2^8 = 256$ et
$2^9 = 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^n > 287$. Or $2^8 = 256$ (insuffisant) et $2^9 = 512$
(suffisant), donc $n = 9$.

]]> $7$

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

]]> $8$

]]> Erreur : sur $8$ bits, on couvre l'intervalle
$[0\,;\, 2^8 - 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_2$, deux décalages donnent
$110000_2 = 48$. C'est l'équivalent rapide de la
multiplication par $2^k$ ; l'opérateur inverse >> divise
entièrement par $2^k$.

]]> 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^k$. Ici, $12 \times 2^2 = 12 \times 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^2 = 4$, pas par $2$.

]]> $3$

]]> Erreur : on a effectué un décalage à droite (>>),
qui correspond à une division entière par $2^k$, 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^n - 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 \times 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^{32} - 1$

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

]]> $2^{16}$

]]> Erreur : $2^{16} - 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^{32}$

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

]]>