SOLUTIONS TD1 STRUCUTRE DES MACHINES 1 19/20

EXO1 On effectue les divisions successives de 100 par 2

Cela donne 11001002 = 10010. Le travail s’effectue de la même manière en base 3 : 10201 3 = 10010.
On obtient de façon identique les résultats suivants : 100 10 = 12104 = 4005 = 2446 = 2027 = 1448 = 1219
= 6416.
On peut obtenir certains résultats directement à partir d’autres. Ainsi, en regroupant les bits deux à
deux, 01 10 01 00, on obtient le résultat en base 4 ; en les regroupant trois à trois, on obtient la base
8, et quatre à quatre (en n’oubliant pas le zéro en tête), on obtient l’hexadécimal. De même, on

01 02 01 donne bien 1219.

EXO2
D
trouve la base 9 à partir de la base 3 en regroupant les symboles ternaires deux à deux (car 9 = 32) :
U
Toujours par la méthode des divisions et des regroupements de bits, on obtient :
9410 = 10111102 = 1368 = 5EH
14110 = 100011012 = 2158 = 8DH
AO

16310 = 101000112 = 2438 = A3H

19710 = 110001012 = 3058 = C5H
EXO3
a. 4032.0235 = 4x53 + 0 + 3x5 + 2 + 0 + 2x5-2 + 3x5-3 = 4x125 + 15 + 2 + 2x0.04 + 3x0.008
= 500 + 17 + 0.08 + 0.024 = 517.104
b. 7AE.F16 = 7x162 + 10x16 + 14 + 15x16-1 = 7x256 + 160 + 14 + 15x0.0625 = 1792 + 174 + 0.9375
D

= 1966.937510
c. 457703.178 = 100101111111000011.0011112= 25FC3.3C16
d. 80659 = 8x93 + 0 + 6x9 + 5 = 8x729 + 54 + 5 = 5832 + 59 = 5891 10
5891/16 = 368 + 3
368/16 = 23 + 0
23/16 = 1 + 7
589110 = 170316
EXO4
0,825410= 0.11010011….2 214,4510=( 11010110.0111001….)2
(88)10 = (1011000)2 =(10021)3
EXO5
a- 954110 = ( 1001010101000001)DCB 84952910= ( 100001001001010100101001)DCB
b- 100110000100DCB=( 984)10 111100100010110DCB=( 7916)10 110110010001DCB=( ?)10 ce
nombre n’existe pas en DCB
c- 100110000100DCB=( 984)10=(1111011000)2=( 1730)8=3D816 111100100010110DCB=( 7916)10
=(1111011101100)2=(17354)8 =(1EEC)16
 EXO6

Attention
Il ne faut pas confondre la représentation en complément à 2 et l’opération qui consiste à prendre le
complément à 2, c’est-à-dire à inverser tous les bits du nombre et à ajouter 1. La représentation en
complément à 2 consiste à écrire les nombres négatifs (et uniquement ceux-là) en prenant le
complément à 2 de leur valeur absolue ; quelle que soit la représentation, les nombres positifs sont
toujours écrits de la même façon.
EXO7
1) 122 – 43 = 122 + (–43). Il faut donc calculer le complément à 2 de 43. La première question à
se poser est de savoir de combien de bits on a besoin pour exprimer –43 et 122. 7 bits

D
permettent bien d’écrire les nombres de 0 à 127 mais, en complément à 2, c’est l’intervalle
de –64 à 63 qui est représenté sur 7 bits. Il en faut donc au moins 8.
U
AO

On laisse bien sûr tomber la retenue finale.

2) 101112 = 2310 et 10112 = 1110.
D

Le résultat correct est bien 25310.

EXO8
1) Voici les calculs :

Il y a débordement dans le premier et le dernier cas. On pourrait croire que le résultat de 100 + 100,
c’est-à-dire 110010002, est correct car il se lit bien 27 + 26 + 23= 200. Mais il ne faut pas oublier qu’on
est en représentation en complément à 2 et qu’on ne peut donc pas choisir de le lire de cette façon-
là. Il faut lire le résultat comme un nombre négatif.
2) Il ne peut pas y avoir de débordement lorsque l’on additionne deux nombres de signes
contraires car la valeur absolue du résultat est toujours inférieure aux valeurs absolues
des deux opérandes ; elle est donc toujours représentable.
Si A et B sont positifs, a7 et b7 valent 0. r vaut donc toujours 0 et s7 peut valoir 0 (le résultat est donc
positif, c’est correct) ou 1 (le résultat est négatif, il y a débordement). Si A et B sont négatifs, a 7 et b7
valent 1. r vaut donc toujours 1 et s7 peut valoir 1 (le résultat est donc négatif, c’est correct) ou 0 (le
résultat est positif, il y a débordement). On a donc débordement si les deux opérandes sont de
mêmes signes et si s7 et r sont complémentaires.
Si les deux opérandes sont de signes contraires, l’un des deux bits de poids fort vaut 1 et l’autre 0. r 6
et r sont alors égaux et il n’y a jamais débordement. Si les deux opérandes sont positifs, le bit de
poids fort des deux opérandes vaut 0 (donc r vaut 0) et le signe du résultat est identique à r 6.
Autrement dit, il y a débordement quand r6 vaut 1 et r vaut 0. Si les deux opérandes sont négatifs, le
bit de poids fort vaut 1 (donc r vaut 1) et le signe du résultat a la même valeur que r 6 . Il y a donc
débordement quand r vaut 1 et r6 vaut 0 (donnant un résultat, incorrect, positif). Au final, on a bien
débordement quand r et r6 sont complémentaires.
.
EXO9
500= 1,953125× 28= (1+ 2-1 + 2-2 + 2-3 + 2-4 + 2-6 )× 28
D
U
Cela donne 0 10000111 11110100000000000000000. On a un bit de signe égal à 0, un exposant égal
à 8 + 127 et les premiers bits de la pseudo-mantisse qui exprime 0,953125.
AO

−3, 5= −1,75× 21= −(1+ 2-1 + 2-2 )× 21

Cela donne 1 10000000 11000000000000000000000. On a un bit de signe égal à 1 car le nombre est
négatif, un exposant égal à 1 + 127 et les premiers bits de la pseudo-mantisse qui exprime 0,75.
0, 40625= 1,625× 2-2= (1+ 2-1 + 2-3 )× 2-2
Cela donne 0 01111101 10100000000000000000000. On a un bit de signe égal à 0, un exposant égal
à –2 + 127 et les premiers bits de la pseudo-mantisse qui exprime 0,625.
D

EXO10.
Compléter les tables :

Addition en octal Multiplication en octal

+ 0 1 2 3 4 5 6 7 * 0 1 2 3 4 5 6 7
0 0 1 2 3 4 5 6 7 0 0 0 0 0 0 0 0 0
1 1 2 3 4 5 6 7 10 1 0 1 2 3 4 5 6 7
2 2 3 4 5 6 7 10 11 2 0 2 4 6 10 12 14 16
3 3 4 5 6 7 10 11 12 3 0 3 6 11 14 17 22 25
4 4 5 6 7 10 11 12 13 4 0 4 10 14 20 24 30 34
5 5 6 7 10 11 12 13 14 5 0 5 12 17 24 31 36 41
6 6 7 10 11 12 13 14 15 6 0 6 14 22 30 36 44 52
7 7 10 11 12 13 14 15 16 7 0 7 16 25 34 41 52 6 1

EXO11.
Effectuer les opérations suivantes
 A b a+b a—b a*b
(11011)2 (1101)2 (101000)2 (1110)2 (101011111)2
(45)8 (32)8 (77)8 (13)8 (1702)8
(A2A)16 (ABC)16 (998)16 (5CBF4)16
(92)16
EXO12

a) 11000111+00011001=11100000 ; 0001101+0000101=10010 ; 0A+17=21 ; C8+5B=123

b) 01000111-00011001= 101110 ; 1001101-0000101= 1001000 , 0A-17= F3 ; C8-
5B=6D

EXO13 Une solution est de construire la séquence de code de Gray pour obtenir la réponse
est d'utiliser un algorithme de conversion Gray à binaire naturel). Voici la réponse finale :

a) 28 b) 2 c) 14 d) 1 e) 21 f) 3
EXO14
Pour la parité paire il faut que le nombre de « 1 » de tous les bits y compris le bit de parité
soit un nombre pair

D
Pour la parité impaire il faut que le nombre de « 1 » de tous les bits y compris le bit de parité
soit un nombre impair
U
a) 1 b) 0 c) 0 d) 1 e) 1 f) 0 g) 1 h) 0 i) 0 j) 1
AO

EXO15
a- for (i= 0 ; i < L ; i++) ac[i]= ad[L – 1 –i] ;
ou encore, sans aucun risque, avec une variable k qui suit le mouvement de i :

k = L-1 ;
D

for(i=0 ; i< L ;i++) { ac[i]= ad[k] ; k-- ; }

b- gauche = 0 ; droite = L – 1 ;
while (gauche < droite) { aux = a[g] ; a[g] = a[d] ; a[d] = aux ; /* échange des contenus des
cases */
gauche ++ ; droite -- ;
}
EXO16
A-Conversion d’un nombre (en binaire) en nombre (en base 10) par programmation

gauche = 0 ; droite = L – 1 ; /* mise à l’envers du tableau a[L] */

while (gauche < droite) { aux = a[g] ; a[g] = a[d] ; a[d] = aux ; /* échange des contenus des cases */
gauche ++ ; droite -- ;
}
cumul=0 ; /* à la fin, cumul contiendra le nombre en base 10 */
for(i = 0 ; i < L ; i++) cumul += a[i] * pow(2, i) ; /* pow est la fonction puissance */
printf(« %d », cumul) ;
On peut éviter la lourdeur de la fonction puissance pow, en constatant qu’à chaque étape la
puissance est multipliée par deux. D’où la modification des dernières lignes du programme
précédent, avec l’introduction de la variable puissance :

cumul=0 ; puissance = 1 ;
for(i = 0 ; i < L ; i++) { cumul += a[i] * puissance ; puissance = 2*puissance ;}
printf(« %d », cumul) ;

Meilleure méthode de programmation

Plaçons le nombre binaire de longueur L (suivant ses puissances décroissantes) dans un tableau
a[L]. Par exemple pour L = 6, le nombre 110101 est tel que a[0]=1, a[1]=1, a[2]=0, a[3]=1, a[4]=0,
a[5]=1. On utilise alors une méthode dite à la Horner :
110101 = a[0] . 25 + a[1] . 24 + a[2] . 23 + a[3] . 24 + a[4] . 21 + a[5] . 20
= 1 . 25 + 1 . 2 4 + 0 . 23 + 1 . 22 + 0 . 21 + 1 . 20
= 1 . 20 + 0 . 2 1 + 1 . 22 + 0 . 2 3 + 1 . 2 4 + 1 . 2 5
= 1 + 2 (0 . 20 + 1 . 21 + 0 . 22 + 1 . 23 + 1 . 24)
= 1 + 2 (0 + 2 (1 . 20 + 0 . 21 + 1 . 22 + 1 . 23))
= 1 + 2 (0 + 2 (1 + 2 (0 . 20 + 1 . 21 + 1 . 22)))
= 1 + 2 (0 + 2 (1 + 2 (0 + 2 (1 . 20 + 1 . 21))))
D
U
= 1 + 2 (0 + 2 (1 + 2 (0 + 2 (1 + 2 . 1))))
soit = a[5] + 2 (a[4] + 2 (a[3] + 2 (a[2] + 2 (a[1] + 2 a[0]))))
Pour le programme itératif, on va de droite à gauche pour le calcul. On commence par placer le
AO

a[0] final dans une variable cumul, puis on double et on ajoute a[1] pour avoir le nouveau cumul,
puis on double et on ajoute a[2], et ainsi de suite.
Mettre le nombre de longueur L donnée dans la tableau a[L]

cumul= a[0] ;
for(i=1 ; i < L ; i++) cumul = 2*cumul + a[i] ;
D

printf(« %d », cumul) ;

B-Passage d’un nombre en base 10 au nombre en binaire par programmation

a- Recherche répétée de la plus forte puissance de 2 inférieure ou égale au nombre
Programme (exhaustif, avec les déclarations)
#include <stdio.h>
#include <stdlib.h>
#define N 53
int a[10];
int main()
{ int nombre, puissance, exposant,nb1,exposantmax,i;
nombre=N; nb1=0;
while (nombre>0)
{ nb1++;
puissance = 1; exposant = 0;
while ( 2*puissance <= nombre)
 { puissance = 2* puissance;
exposant ++;
}
if (nb1==1) exposantmax=exposant;
a[exposant]=1;
nombre -= puissance;
}
printf("Ecriture suivant les puissances croissantes\n");
for(i=0;i<=exposantmax; i++) printf("%d ",a[i]);
printf("\n\nEcriture suivant les puissances décroissantes\n");
for(i=exposantmax; i>=0; i--) printf("%d ",a[i]);
getchar();return 0;
}
a- Deuxième méthode, par divisions successives par 2
q = N; i=0;
while (q>0)
{ r[i]= q%2;

}
q = q/2;
i++;

D
U
longueur=i;
printf("Ecriture suivant les puissances croissantes :\n");
for(j=0; j<longueur; j++) printf("%d ",r[j]);
AO

printf("\n\nEcriture suivant les puissances décroissantes :\n");

for(j=longueur-1;j>=0; j--) printf("%d ",r[j]);
Cette deuxième méthode, moins évidente à trouver que la première, est nettement plus simple. Il
convient de bien la connaître.
D