TP 9 : Représentation des nombres (corrigé)

Mme. H. Chaabani & M. A. Ammar : Classe MP2I 16 janvier 2024

Exercice 1 : Bits et octets

Beaucoup d’ordinateurs ont actuellement une architecture dite "64-bits" ; cela signifie que leur
processeur manipule des nombres entiers dont l’écriture binaire nécessite 64 chiffres binaires
au plus.
Q1. Quel est le plus grand nombre entier naturel qu’un processeur de ce type peut manipu-
ler ?
Solution :
N = 2n − 1, pour n = 64 bits ⇒ N = 264 − 1
Q2. Quelle est la taille en octets de ces nombres ?
Solution :
La taille en octets de ces nombres 64/8 = 8 octets
Q3. Sachant qu’une minute de musique au format mp3 occupe un espace de 1 Mo, combien
d’heures de musique peut-on stocker sur un baladeur de 18 Go ?
Solution :
1 heure = 60 minutes u 60 Mo et le baladeur a une capacité de 18 Go soit 18000 Mo.
18000
Le baladeur peut donc stocker 60 = 300 heures de musique.
Q4. Avec un débit de 80 Mbits/s, combien de temps faut-il pour télécharger un fichier de 1,8
Go ?
Solution :
8 Mbits = 1 Mo donc 80 Mbits/s = 10 Mo/s
1,8× 1000
donc 10 = 180 secondes soit 3 minutes.
Q5. Une image en niveau de gris Im est un tableau à n lignes p colonnes où chaque pixel
Im[i,j] est un entier compris entre 0 (pour noir ) et 255 (pour blanc) . Nous souhaitons
savoir de combien d’espace disque a-t-on besoin pour stocker une image de dimension
512 × 728.
Solution :
Une couleur en noir et blanc est extraite d’une matrice à deux dimensions où chaque
couleur possède une valeur qui détermine sa nuance du blanc et une valeur qui déter-
mine sa nuance du noir. Le mélange des deux nuances détermine la nuance grise de la
couleur résultante.
Pour cette image on a 512 × 728 pixels chaque pixel nécessite 8 bits. En effet (255)10 =

Page 1
 (11111111)2 ce chiffre qui détermine chaque couleur nécessite donc 8 bits. Ainsi au
total, cette image nécessitera 512× 728 × 8 = 2981888 bits soit 372736 octets soit
372,736 k octets.
Q6. Que pensez-vous du stockage de l’image si elle était en couleur ? a-t-on besoin de
plus, ou de moins d’espace disque, sachant qu’un pixel dans une image couleur est une
combinaison de trois couleurs : rouge, vert et bleu.
Solution :
Cette couleur sera extraite d’une matrice à trois dimensions où chaque couleur possède
une valeur qui détermine sa nuance en : rouge, vert et bleu.
Ainsi chaque pixel nécessitera 8 × 3 bits ce qui signifie que nous aurons besoin de plus
d’espace disque pour stocker cette image.

Exercice 2 : Conversions

Q1. Trouver la représentation en base cinq des nombres (88)10 , (627)10 et (1451)10 .
Solution :
(88)10 = (323)5
(627)10 =(10002)5
(1451)10 =(21301)5
Q2. Trouver la représentation en base 10 des nombres (4413)5 et (212)5 , exprimés dans la
base 5.
Solution :
(4413)5 =(608)10
(212)5 =(57)10
Q3. Donner la représentation en base 2 des nombres 10000, 8386 et 3543.
Solution :
(10000)10 =(10011100010000)2
(8386)10 =(10000011000010)2
(3543)10 =(110111010111)2
Q4. C’est en (11110110001)2 qu’a été transmis le premier message sur internet. Exprimer
ce nombre en base 10. Le système tomba en panne après seulement 10 caractères
transmis.
Solution :
(11110110001)2 = (1969)10
Q5. Trouver la représentation binaire, puis décimale des nombres (FEDC)16 et (6A5C1)16 .
Solution :
(FEDC)16 =(1111 1110 1101 1100)2
(FEDC)16 =(65244)10

(6A5C1)16 =(0110 1010 0101 1100 0001)2

(6A5C1)16 =(435649)10

Page 2
 Q6. Soit les nombres binaires suivants :

0000 0000 0000 1100 1111 0000

0000 0000 1110 1000 0111 0001
0000 1111 1100 1111 0000 0001
1110 1010 1011 1000 0111 0001

Sur combien d’octets ces nombres sont stockés, exprimer les dans la base Octale, Hexa-
décimale et Décimale.
Solution :
(000000000000110011110000)2 = =(3312)10 =(CF0)16 =(6360)8
(000000001110100001110001)2 =(59505)10 =(E871)16 =(164161)8
(000011111100111100000001)2 =(1036033)10 =(FCF01)16 =(3747401)8
(111010101011100001110001)2 =(15382641)10 =(EAB871)16 =(72534161)8

Exercice 3 : Représentation binaire des entiers relatifs

Q1. Déterminer, sur 8 bits, le complément à deux de +66, de -130 puis de -66.
Solution :
+(66)10 = (01000010)2
-(130)10 = (impossible)2
-(66)10 = CA2(66)10 = CA1(66)10 +1 = (10111110)2

Q2. Trouver la représentation binaire sur huit bits des nombres 127 et -127.
Solution :
(127)10 = (01111111)2

(-127)10 = CA2(127)10
= CA1(127)10 +1
= CA1(01111111)2 +1
= (10000000)2 +1
= (10000001)2

Q3. Quels entiers relatifs peut-on représenter avec des mots de 8 bits ?
Solution :
-(28−1 -1) ≤ N ≤ +(28−1 -1)
⇒ -(27 -1) ≤ N ≤ +(27 -1)
⇒ -127 ≤ N ≤ 127
Combien sont-ils ?
Solution :
255 chiffres.
Q4. Trouver la représentation décimale des entiers relatifs dont les représentations binaires
sur 8 bits sont 01010101 et 10101010

Page 3
 Solution :
(01010101)2 = (85)10
(10101010)2 ⇒ 1 est un bit de signe le nombre est donc négatif
(10101010)2 = - CA1(10101010)2 = -(01010101)2 = -(85)10

Exercice 4 : Représentation des nombres à virgule flottante

Le standard utilisé par les ordinateurs :

Standard IEEE 754 simple précision (4 octets) :

(−1)s × (1, f ) × (2e−127 )

avec f = partie fractionnaire de la mantisse

— e est codé sous forme de puissances positives de 2,

— f est codé sous forme de puissances négatives de 2.
Q1. Déterminer quels flottants sont représentés par :

Solution :
e1 = (10000001)2 = (129)10
f1 = (11100000000000000000000)2 =(0.875)10

(−1)0 × 1, 875 × 2129−127 = (7.2)10

e2 = (01111110)2 = (126)10
f2 = (11111100000000000000000)2 =(0.984375536)10

(−1)1 × 1, 984375536 × 2126−127 = −(0.992187768)10

Q2. Déterminer la représentation en flottant de 32,5.

Solution :
(32,5)10 = 25 + 2−1 = (-1)0 × (100000,1)2 = 1,000001 × 2132−127
et (132)10 = (10000100)2
Donc la représentation est : (0 10000100 00000100000000000000000)2

Page 4
Exercice 5 : Programmation en C

I. Conversion d’une base b vers la base 10

Q1. La fonction b_to_10 peut s’écrire comme suivant :

// on stocke les puissances de b pour éviter de faire n calculs de puissance

unsigned b_to_10(unsigned* t, unsigned size, unsigned b) {
unsigned somme = 0;
unsigned puissance = 1; // stocke les puissances de b
for(int i = 0; i < size; i++) {
somme += t[i]*puissance; // puissance vaut b**i
puissance *= b; // multiplie puissance par b
}
return somme;
}

unsigned t[] = {0, 0, 1, 0, 1};

b_to_10(t, 5, 2); // renvoie 20

II. Conversion de la base 10 vers une base b

Q2. Soit p le nombre de chiffres de n en base b. Le plus petit nombre à p chiffres est
b p−1 (= 1 0...0 p
|{z} 2 ) et le plus grand nombre à p chiffres est b − 1 (= 1...1
|{z} 2 ). Donc :
p−1 p

b p−1 ≤ n < b p

En passant au logb (qui est une fonction strictement croissante donc préserve les inéga-
lités) :
(p − 1) ≤ logb (n) < p

=⇒ p ≤ logb (n) + 1 < p + 1

=⇒ p = blogb (n)c + 1

Q3. La fonction size_b peut s’écrire comme suivant :

unsigned size_b(unsigned n, unsigned b) {

return log(n)/log(b) + 1;
}

size_b(20, 2) // 20 = 10100_2 possède 5 chiffres en base 2

Page 5
Q4. La fonction 10_to_b peut s’écrire comme suivant :

unsigned* convert_10_to_b(unsigned n, unsigned b) {

unsigned size = log(n)/log(b) + 1;
unsigned* tab = (unsigned*)malloc(size*sizeof(unsigned));
for(int i = 0; i < size; i++) {
tab[i] = n % b;
n /= b;
}
return tab;
}

unsigned* tab = convert_10_to_b(18, 2); // 18 = 10010_2

for(int i = 0; i < 7; i++) {
printf("%u", tab[i]);
}

Page 6