Pour convertir un nombre entier positif en binaire il faut bien avoir en tête le tableau des puissances de 2 :
... | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
Voici la démarche à suivre sur un exemple : supposons que l'on veuille écrire $77_{(10)}$ en écriture binaire.
64 | 32 | 16 | 8 | 4 | 2 | 1 |
1 |
La puissance de 2 immédiatement inférieure ou égale à 77 est 64, on écrit 1 en dessous de 64 et il reste $77-64=13$.
64 | 32 | 16 | 8 | 4 | 2 | 1 |
1 | 1 |
La puissance de 2 immédiatement inférieure ou égale à 13 est 8, on écrit 1 en dessous de 8 et il reste $13-8=5$.
64 | 32 | 16 | 8 | 4 | 2 | 1 |
1 | 1 | 1 |
La puissance de 2 immédiatement inférieure ou égale à 5 est 4, on écrit 1 en dessous de 4 et il reste $5-1=1$.
64 | 32 | 16 | 8 | 4 | 2 | 1 |
1 | 1 | 1 | 1 |
La puissance de 2 immédiatement inférieure ou égal à 1 est 1, on écrit 1 en dessous de 1 et c'est fini.
En complétant les cases vides par des zéros, on obtient :
$77_{(10)}=1001101_{(2)}$
Il est aussi possible de convertir un nombre entier en binaire en effectuant des divisions successives par 2 jusqu'à obtenir un quotient nul.
Avec cette méthode la conversion de 77 en binaire donne les divisions :
Pour obtenir l'écriture en binaire, il faut écrire les restes successifs de droite à gauche, ce qui donne :
$77_{(10)}=1001101_{(2)}$
Ecrire en binaire les nombres suivants :
a) 97
1100001
$_{(2)}$
b) 195
11000011
$_{(2)}$
c) 31
11111
$_{(2)}$
d) 392
110001000
$_{(2)}$
Voici l'algorithme de la méthode par divisions où les restes successifs sont stockés dans une liste.
Variables : | $n$ est un nombre entier |
$r$ est un nombre entier | |
L est une liste d'entiers | |
Initialisation/Entrée : | L est vide |
Saisir $n$ | |
Traitement : | Faire |
$r$ prend la valeur $n\%2$ | |
Ajouter $r$ à la liste L | |
$n$ prend la valeur $(n-r)/2$ | |
Tant que $n\not=0$ | |
Sortie : | Afficher L |
Attention ! la liste affichée par cet algorithme donne les valeurs de chaque bit en commençant par le bit de poids le plus faible, pour afficher le nombre binaire il faut parcourir la liste en partant de la fin.
La structure « inversée » du Tant que assure que le contenu de la boucle est exécuté au moins une fois permettant à l'algorithme de fonctionner dans le cas particulier où $n=0$.