Ecriture d'un entier positif
Avant d'entrer dans le détail, une petite anecdote, pour laquelle il nous faut revenir un peu en arrière dans le temps... l'âge d'or de l'Arcade dans les années 1980... A cette époque, une partie sur une borne coûtait une petite pièce, laquelle pouvait offrir le privilège de jouer sans limite jusqu'au Game Over. Encore fallait-il être habile car la difficulté augmentait vite. Il existait (et existe toujours) de véritables champions du high score, en rivalisant pour conquérir les places hautes du Hall of Fame de leurs jeux préférés. C'est pour cette raison qu'à cette époque, les jeux d'arcade n'ont pas de fin. Les niveaux ne sont souvent que des copies des précédents avec davantage d'ennemis, de vitesse, etc. Un de ces jeux, le très populaire Pac-Man a pourtant une fin. Une fin assez inattendue, qui se produit lorsque le joueur atteint le 256-ème niveau. Cet écran complètement "glitché" s'appelle le Kill Screen : Et comme chacun sait, $256 = 2^8$. Coïncidence ? Pas du tout ! Nous découvrirons dans ce cours les raisons de ce bug en comprenant comment sont codés les nombres, ce qu'est un bit ainsi qu'un octet.
La notation positionnelle d'un nombre est un système de représentation des nombres comme des mots formés à partir d'un ensemble fini de chiffres de base dont nous voyons après le fonctionnement. Ca n'est pas encore très clair, mais revenons aux bases et tout s'éclaircira... Le système le plus répandu dans le monde est le système décimal qui utilise la base dix. Cela signifie qu'il possède dix chiffres de base représentés comme ceci :

La représentation graphique d'un chiffre en base dix est une convention, on pourrait lui préférer n'importe quelle autre sans changer le système numérique. Voici quelques autres exemples existants :

Valeur 0 1 2 3 4 5 6 7 8 9
Arabe oriental ٠ ١ ٢ ٣ ٤ ٥ ٦ ٧ ٨ ٩
Bengalais
Braille
Devanagari
Gujarati
Gurmukhi
Kannada
Khmer
Laotien
Malayalam
Myanmar
N'ko ߀ ߁ ߂ ߃ ߄ ߅ ߆ ߇ ߈ ߉
Oriya
Osmanya 𐒠 𐒡 𐒢 𐒣 𐒤 𐒥 𐒦 𐒧 𐒨 𐒩
Persan/Ourdou ۰ ۱ ۲ ۳ ۴ ۵ ۶ ۷ ۸ ۹
Tamoul
Télougou
Thaï
Tibétain
Pac-Man
Il semble évident que le choix de la base dix est anatomique... ... mais on pourrait tout à fait imaginer des systèmes très différents en choisissant pour certaines raisons une autre base ! Il existe d'ailleurs quelques exemples historiques et actuels de système de notation positionnelle en base non décimales : La numération Maya (IIIe - XIIIe siècles) comptait une base de vingt chiffres. Leurs représentations pouvait varier selon la nature des objets comptés. Les chiffres suivants sont utilisés pour le calcul du temps : La numération mésopotamienne (IIIe millénaire av. J.-C.) comptait une base de soixantes chiffres (eux même reposant sur un système additif) : Les premières traces de ce système présente un défaut : l'absence de zéro qui est indiqué par un espace. Il est par exemple difficile de différencier 1 et 60, notés "  " et "  ". Bien que la base dix soit quasi universelle, il existe de nombreux systèmes quinaires qui définissent les chiffres de 6 à 9 comme "une main et des unités". C'est notamment le cas pour dans langue gumatj (en voie de disparition) parlé dans la tribu Yolngu en Australie. Nous nous livrons ci-dessous à une petite expérience pour prendre du recul sur nos "habitudes décimales" en comptant des dans plusieurs bases :
init_coins() _("#container-coins").style.display="block" _("#intro-coins").style.display="none" Pour commencer, on reste dans le système décimal en regroupant les pièces par paquets de dix Pour ça on utilise nos chiffres de base et on commence à 0 quand il n'y a aucune pièce. move_coin(26,100,350) 1 pièce move_coin(25,100,345) 2 pièces move_coin(24,100,340) 3 pièces move_coin(23,100,335) 4 pièces move_coin(22,100,330) 5 pièces move_coin(21,100,325) 6 pièces move_coin(20,100,320) 7 pièces move_coin(19,100,315) 8 pièces move_coin(18,100,310) 9 pièces move_coin(17,100,305) On a autant de pièces que de chiffres de la base.
On compte 1 dizaine de pièces.
move_coin(16,140,350) 1 dizaine et 1 pièce move_coin(15,140,345) 1 dizaine et 2 pièces move_coin(14,140,340) 1 dizaine et 3 pièces move_coin(13,140,335) 1 dizaine et 4 pièces move_coin(12,140,330) 1 dizaine et 5 pièces move_coin(11,140,325) 1 dizaine et 6 pièces move_coin(10,140,320) 1 dizaine et 7 pièces move_coin(9,140,315) 1 dizaine et 8 pièces move_coin(8,140,310) 1 dizaine et 9 pièces move_coin(7,140,305) 2 dizaines de pièces sont atteintes move_coin(6,200,350) 2 dizaines et 1 pièces move_coin(5,200,345) 2 dizaines et 2 pièces move_coin(4,200,340) 2 dizaines et 3 pièces move_coin(3,200,335) 2 dizaines et 4 pièces move_coin(2,200,330) 2 dizaines et 5 pièces move_coin(1,200,325) _("#container-coins").style.display="block" 2 dizaines et 6 pièces
Ce que nous écrivons $\color{red}{2}\color{blue}{6}$
_("#container-coins").style.display="none" En base décimale, le nombre de se note : $$ {\Huge \overline{\color{red}{2}\color{blue}{6}} ^ {\large 10}} $$ _("#container-coins").style.display="block" Remettons tout en place... _("#container-coins").style.display="block" init_coins() ... et recommençons le comptage avec des paquets de cinq. move_coin(26,100,350) 1 pièce move_coin(25,100,345) 2 pièces move_coin(24,100,340) 3 pièces move_coin(23,100,335) 4 pièces move_coin(22,100,330) On a autant de pièces que de chiffres de la base.
On compte 1 cinquaine de pièces.
move_coin(21,140,350) 1 cinquaine et 1 pièce move_coin(20,140,345) 1 cinquaine et 2 pièces move_coin(19,140,340) 1 cinquaine et 3 pièces move_coin(18,140,335) 1 cinquaine et 4 pièces move_coin(17,140,330) Une nouvelle cinquaine est atteinte
On compte 2 cinquaines de pièces
move_coin(16,180,350) move_coin(15,180,345) move_coin(14,180,340) move_coin(13,180,335) move_coin(12,180,330) move_coin(11,220,350) move_coin(10,220,345) move_coin(9,220,340) move_coin(8,220,335) move_coin(7,220,330) On avance un peu jusqu'à atteindre 4 cinquaines de pièces move_coin(6,280,350) 4 cinquaines et 1 pièces move_coin(5,280,345) 4 cinquaines et 2 pièces move_coin(4,280,340) 4 cinquaines et 3 pièces move_coin(3,280,335) 4 cinquaines et 4 pièces move_coin(2,280,330) On vient de créer une cinquième cinquaine. Or, il n'y a pas de chiffre correspondant à cinq (les chiffres de base sont 0,1,2,3 et 4)... move_coin(26,100,350); move_coin(25,100,345); move_coin(24,100,340); move_coin(23,100,335); move_coin(22,100,330); move_coin(21,100,325) move_coin(20,100,320) move_coin(19,100,315) move_coin(18,100,310) move_coin(17,100,305) move_coin(16,100,300) move_coin(15,100,295) move_coin(14,100 ,290) move_coin(13,100,285) move_coin(12,100,280) move_coin(11,100,275) move_coin(10,100,270) move_coin(9,100,265) move_coin(8,100,260) move_coin(7,100,255) move_coin(6,100,250) move_coin(5,100,245) move_coin(4,100,240) move_coin(3,100,235) move_coin(2,100,230) On atteint un rang supérieur, celui de la "vingt-cinquaine" (cinq paquets de cinq) : 1 vingt-cinquaine, 0 cinquaine et 0 pièces move_coin(1,180,350) Avec la dernière pièce, on obtient :
1 vingt-cinquaine, 0 cinquaine et 1 pièces
_("#container-coins").style.display="block" 1 vingt-cinquaine, 0 cinquaine et 1 pièces
Ce que nous écrivons $\color{green}{1}\color{red}{0}\color{blue}{1}$ pièces
_("#container-coins").style.display="none" En base cinq, le nombre de se note : $$ {\Huge \overline{\color{green}{1} \color{red}{0} \color{blue}{1} } ^ {\large 5}} $$ _("#container-coins").style.display="block" C'est un peu répétitif, mais nécessaire. Remettons tout en place... _("#container-coins").style.display="block" init_coins() ... et recommençons le comptage avec des paquets de deux. En base 2 (ou binaire), les seuls chiffres disponibles sont 0 et 1 move_coin(26,50,350) 1 pièce move_coin(25,50,345) On rappelle que le chiffre "deux" n'existe pas. On atteint donc un rang supérieur, la paire :
1 paire de pièces
move_coin(24,130,350) 1 paire et 1 pièce move_coin(23,130,345) Les deux pièces forment une nouvelle paire, mais on a alors deux paires... Et comme le chiffre deux n'existe pas en binaire... move_coin(24,50,340) move_coin(23,50,335) ... on atteint le rang supérieur de la quatraine
1 quatraine de pièces
move_coin(22,130,350) 1 quatraine, 0 paire et 1 pièce. move_coin(21,130,345) 1 quatraine et 1 paire de pièces move_coin(20,210,350) 1 quatraine, 1 paire et 1 pièces move_coin(19,210,345) A ce niveau là, il va y avoir des retenues. On forme deux paires... move_coin(20,130,340) move_coin(19,130,335) ... qui forment une deuxième quatraine... move_coin(22,50,330) move_coin(21,50,325) move_coin(20,50,320) move_coin(19,50,315) ...et on atteint donc le rang supérieur :
1 huitaine de pièces
move_coin(18,130,350) 1 huitaine, 0 quatraine, 0 paire et 1 pièces move_coin(17,130,345) 1 huitaine, 0 quatraine, 1 paire de pièces move_coin(16,210,350) 1 huitaine, 0 quatraine, 1 paire et 1 pièces move_coin(16,130,340) move_coin(15,130,335) 1 huitaine et 1 quatraine de pièces move_coin(14,210,350) 1 huitaine, 1 quatraine et 1 pièces move_coin(13,210,345) 1 huitaine, 1 quatraine et 1 paire de pièces move_coin(12,290,350) 1 huitaine, 1 quatraine, 1 paire et 1 pièces move_coin(11,290,345) On a à nouveau des retenues qui démarrent avec cette deuxième paire... move_coin(12,210,340) move_coin(11,210,335) ... qui forme une nouvelle quatraine... move_coin(14,130,330) move_coin(13,130,325) move_coin(12,130,320) move_coin(11,130,315) ...puis une nouvelle huitaine... move_coin(18,50,310) move_coin(17,50,305) move_coin(16,50,300) move_coin(15,50,295) move_coin(14,50,290) move_coin(13,50,285) move_coin(12,50,280) move_coin(11,50,275) ... et on atteint donc le rang supérieur de la seizaine :
1 seizaine de pièces
move_coin(10,130,350) 1 seizaine, 0 huitaine, 0 quatraine, 0 paire et 1 pièces move_coin(9,130,345) 1 seizaine, 0 huitaine, 0 quatraine, 1 paire de pièces move_coin(8,210,350) 1 seizaine, 0 huitaine, 0 quatraine, 1 paire et 1 pièces move_coin(7,210,345) ... retenue... move_coin(8,130,340) move_coin(7,130,335) 1 seizaine, 0 huitaine et 1 quatraine de pièces move_coin(6,210,350) 1 seizaine, 0 huitaine, 1 quatraine et 1 pièces move_coin(5,210,345) 1 seizaine, 0 huitaine, 1 quatraine et 1 paire de pièces move_coin(4,290,350) 1 seizaine, 0 huitaine, 1 quatraine, 1 paire et 1 pièces move_coin(3,290,345) On a une retenue... move_coin(4,210,340) move_coin(3,210,335) ... qui forme deux quatraines... move_coin(6,130,330) move_coin(5,130,325) move_coin(4,130,320) move_coin(3,130,315) Et donc :
1 seizaine et 1 huitaine de pièces
move_coin(2,210,350) 1 seizaine, 1 huitaine, 0 quatraine, 0 paire et 1 pièces move_coin(1,210,345) $\color{purple}{1}$ seizaine, $\color{orange}{1}$ huitaine, $\color{green}{0}$ quatraine, $\color{red}{1}$ paire et $\color{blue}{0}$ pièces _("#container-coins").style.display="block" $\color{purple}{1}$ seizaine, $\color{orange}{1}$ huitaine, $\color{green}{0}$ quatraine, $\color{red}{1}$ paire et $\color{blue}{0}$ pièces
Ce que nous écrivons $\color{purple}{1}\color{orange}{1}\color{green}{0}\color{red}{1}\color{blue}{0}$ pièces
_("#container-coins").style.display="none" En binaire ou base deux, le nombre de se note : $$ {\Huge \overline{\color{purple}{1}\color{orange}{1}\color{green}{0}\color{red}{1}\color{blue}{0}} ^ {\large 2}} $$ Finalement le nombre de peut se noter : $$ { \Large \overline{26} ^ {\normalsize 10} = \overline{101} ^ {\normalsize 5} = \overline{11010}^{\normalsize 2}} $$ Finalement le nombre de peut se noter : $$ { \Large \overline{26} ^ {\normalsize 10} = \overline{101} ^ {\normalsize 5} = \overline{11010}^{\normalsize 2}} $$ (quand on ne précise pas la base, par défaut il s'agit de la base décimale)
En essayant de compter en binaire, nous avons pu obtenir les valeurs suivantes pour les premiers nombres : $$ \begin{array}{r|r} \text{base } 2 & \text{base } 10 \\ \hline 0 & 0 \\ 1 & 1 \\ 1\ 0 & 2 \\ 1\ 1 & 3 \\ 1\ 0\ 0 & 4 \\ 1\ 0\ 1 & 5 \\ 1\ 1\ 0 & 6 \\ 1\ 1\ 1 & 7 \\ 1\ 0\ 0\ 0 & 8 \\ 1\ 0\ 0\ 1 & 9 \\ 1\ 0\ 1\ 0 & 10 \\ \dots & \dots \\ \end{array} $$ Avant d'aller plus loin, il nous faut un peu de vocabulaire....
  • Les positions d'un chiffre dans un nombre binaire s'appellent des bits.
  • Un octet vaut 8 bits.
  • Le 4ème bit de $\overline{1010}^2$ vaut $1$.
  • Il faut 5 bits pour écrire en binaire le nombre $16 = \overline{10000}^2$
  • Avec $3$ bits on peut représenter $8$ nombres (de 0 à 7)
  • Avec $1$ octet on peut représenter $512$ nombres (de 0 à $\overline{1111\ 1111}^2 = 511$)
Dans l'exemple avec les pièces, comme nous ne connaissions pas le terme de bit, nous évoquions des paires, des quatraines, des huitaines, desseizaine... autrement dit, chaque bit correspond à une puissance de 2. Il faudra au moins connaître les premières : Des années 80 aux années 2000, les publicitaires de l'industrie du jeu vidéo singeaient la loi de Moore pour faire vendre les nouvelles générations de console en mettant en avant la taille en bits des données traitées par le microprocesseur. On parlait alors de génération 8bits, 16bits, 32bits, etcCet article vulgarise ce que signifie le nombre de bits d'une console retro. Ils se sont arrêtés après 64bits pour parler de consoles nextgen...

La conséquence la plus évidente de cette progression est visuelle : nombre de couleurs, taille et nombre de spritesUn sprite est une image animée de jeu telle qu'un personnage, un ennemi ou un élément de décor., nombre de polygones, etc.

Bien sûr, cette phase exponentielle ne peut pas durer indéfiniment. Il n'existe pas d'ordinateur commercialisé dont le processeur traite des données en 128 bits. Si vous voulez en apprende davantage sur la loi de Moore dans le jeu vidéo :

Revenons à nos moutons (électriques ?)... Nous allons maintenant convertir du binaire vers le décimal. Raisonnons sur l'exemple des pièces : On avait obtenu ce nombre binaire en comptant les pièces de l'exemple : $$ \overline{\color{purple}{1} \color{orange}{1} \color{green}{0} \color{red}{1} \color{blue}{0}}^2$$ $$ \begin{array}{crlcrlcrlcrlcrlc} & \color{purple}{1} & \text{ seizaine } & & \color{orange}{1} & \text{huitaine} & & \color{green}{0} & \text{quatraine} & & \color{red}{1} & \text{paire} & et & \color{blue}{0} & \text{unite} \\ =& \color{purple}{1} & \times 16 &+& \color{orange}{1} & \times 8 &+& \color{green}{0} & \times 4 &+& \color{red}{1} & \times 2 & + & \color{blue}{0} & \times 1 \\ =& \color{purple}{1} & \times 2^5 &+& \color{orange}{1} & \times 2^4 &+& \color{green}{0} & \times 2^2 &+& \color{red}{1} & \times 2^1 & + & \color{blue}{0} & \times 2^0 \end{array} $$ Ce qui nous donne la valeur décimale de $26$. Cet exemple se généralise à tout nombre binaire avec la formule suivante : Soit $b$ un nombre binaire de longueur $n$ que l'on représente de la manière suivante : $$ b=\overline{b_{n-1} b_{n-2}...b_1b_0}^2 $$
  • $b_i$ représente le $i$-ème bit du nombre $b$ en binaire.
  • $b_i = 0$ ou $1$, pour $i$ allant de $0$ à $n-1$
  • $b_0$ est appelé le bit de poids faible (le plus à droite)
  • $b_{n-1}$ est appelé le bit de poids fort (le plus à gauche)
Alors, en écriture décimale, on a : $$ b = b_{n-1} \times 2^{n-1}\ +\ b_{n-2} \times 2^{n-2}\ +\ \dots\ +\ b_{1} \times 2^{1}\ +\ b_{0} \times 2^{0} $$
La conversion dans l'autre sens est plus difficile. Il faut, à partir d'un nombre décimal obtenir sa décomposition en "paquets" de puissances de 2. Il y a deux approches possibles : Nous allons convertir en binaire le nombre $\overline{61}^{10}$. Nous allons avoir besoin des puissances de $2$ : $$ \begin{array}{|c|c|c|} \hline \text{bit } n & \color{blue}{0} & \color{red}{1} & \color{green}{2} & \color{orange}{3} & \color{purple}{4} & \color{brown}{5} & \color{Magenta}{6} & \color{OrangeRed}{7} & \color{Violet}{8} & \color{Fuchsia}{9} & \color{MidnightBlue}{10} & ... \\ \hline 2^n & \color{blue}{1} & \color{red}{2} & \color{green}{4} & \color{orange}{8} & \color{purple}{16} & \color{brown}{32} & \color{Magenta}{64} & \color{OrangeRed}{128} & \color{Violet}{256} & \color{Fuchsia}{512} & \color{MidnightBlue}{1014} & ... \\ \hline \end{array} $$
  • On cherche la puissance de $2$ la plus proche de $\color{blue}{61}$ par valeur inférieure, c'est $2^5 = \color{brown}{32}$.
  • On retire cette puissance à notre nombre, et il reste une valeur $r_0$ : $61 = \color{brown}{32} + r_0 = \color{red}{32} + 29 $ à
  • On réitère la même opération avec $r_0=29$. La puissance la plus proche est $\color{purple}{16}$.
  • Et donc $29 = \color{purple}{16} + r_1 = \color{purple}{16} + 13 $
  • Et ainsi de suite avec des puissances de plus en plus petites : $$ \begin{array}{ccc} 61 &=& \color{brown}{32} &+& \color{purple}{16} &+& \color{orange}{8} &+& \color{green}{4} &+& \color{red}{0} &+& \color{blue}{1} \\ &=& \color{brown}{1 \times 2^5} &+& \color{purple}{1 \times 2^4} &+& \color{orange}{1 \times 2^3} &+& \color{green}{1 \times 2^2} &+& \color{red}{0 \times 2^1} &+& \color{blue}{1 \times 2^0} \\ \end{array} $$
  • La décomposition nous permet de dire que $$ \overline{61}^{10} = \overline{\color{brown}{1}\color{purple}{1}\color{orange}{1}\color{green}{1}\color{red}{0}\color{blue}{1}}^{2} $$

Cette méthode, plus directe repose sur des divisions entières successives par $2$.

  • On commence avec le nombre en base 10
  • On le divise par 2 et on retient le reste (qui vaut 1 ou 0)
  • On recommence avec le quotient précédent et on retient le reste
  • On s'arrête quand le quotient est nul
  • Le nombre binaire est formé des restes (le dernier est le bit de poids fort, il faut lire à du haut vers le bas)
Nous appliquons cette méthode au nombre $\overline{61}^{10}$ : $$ \begin{array}{llll} 61 : 2 & = & 30 &+& \color{blue}{1} \\ 30 : 2 & = & 15 &+& \color{red}{0} \\ 15 : 2 & = & 7 &+& \color{green}{1} \\ 7 : 2 & = & 3 &+& \color{orange}{1} \\ 3 : 2 & = & 1 &+& \color{purple}{1} \\ 1 : 2 & = & 0 &+& \color{brown}{1} \\ \end{array} $$ En lisant de bas en haut, on obtient : $$ \overline{61}^{10} = \overline{\color{brown}{1}\color{purple}{1}\color{orange}{1}\color{green}{1}\color{red}{0}\color{blue}{1}}^{2} $$
En informatique, le binaire est la base utilisée à très bas niveau car un 1 correspond à un signal élèctrique et un 0 à l'absence de signal. Pour l'utilisateur et l'informaticien, cette base est un peu pénible. Ses nombres sont très longs à écrire et on a tendance à traiter des informations plus grandes qu'un bit (d'où l'utilisation des octets vu avant).

La base 10 est trop éloignée de l'architecture d'un ordinateur. Les bases satisfaisantes sont des puissances de 2. Le système le plus utilisé en informatique est l'hexadécimal, c'est à dire la base 16. Pour représenter 16 chiffres différents, on utilise les lettres de l'alphabet au delà de 9. $$ \begin{array}{r|r} \text{base } 2 & \text{base } 10 & \text{hex} \\ \hline 0 & 0 & 0\\ 1 & 1 & 1\\ 1\ 0 & 2 & 2\\ 1\ 1 & 3 & 3\\ 1\ 0\ 0 & 4 & 4\\ 1\ 0\ 1 & 5 & 5\\ 1\ 1\ 0 & 6 & 6\\ 1\ 1\ 1 & 7 & 7\\ 1\ 0\ 0\ 0 & 8 & 8\\ 1\ 0\ 0\ 1 & 9 & 9\\ 1\ 0\ 1\ 0 & 10 & A\\ 1\ 0\ 1\ 1 & 11 & B\\ 1\ 1\ 0\ 0 & 12 & C\\ 1\ 1\ 0\ 1 & 13 & D\\ 1\ 1\ 1\ 0 & 14 & E\\ 1\ 1\ 1\ 1 & 15 & F\\ \dots & \dots \\ \end{array} $$

On voit dans cette table que n'importe quel nombre binaire encodé sur 4 bits correspond résument à un seul chiffre hexadécimal. Cette propriété permet de convertir très simplement des nombres binaires en hexadécimal.
  • Réunir par paquets de 4 bits le nombre binaire à partir du poids faible
  • Remplacer chaque paquet de 4 par l'équivalent en hexadécimal (dans la table ci-dessus)
Pour convertir le nombre binaire $\overline{1 1 1 1 0 0}^2$ :
  • On le regroupe par paquets de 4 bits : $\color{blue}{0 0 1 1} \ \ \color{red}{1 1 0 0}$
  • On remplace par les chiffres hexadécimaux correspondants : $ \color{blue}{3} \color{red}{C} $
  • Et donc : $$\overline{1 1 1 1 0 0}^2 = \overline{3C}^{hex}$$
Les éditeurs hexadécimaux sont des outils permettant de visualiser un fichier binaire. Chaque octet est représenté comme un nombre hexadécimal à deux chiffres (entre 00 et FF). Ci-dessus un vieux jeu vidéo est édité. Les données textuelles sont décodées à droite (un caractère tient sur un octet). Pour les conversions entre hexadécimal et décimal, les méthodes sont les mêmes qu'entre le décimal et le binaire : Soit $h$ un nombre hexadécimal de longueur $n$ que l'on représente de la manière suivante : $$ h=\overline{h_{n-1} h_{n-2}... h_1 h_0}^2 $$
  • $h_i$ représente le chiffre du $i$-ème rang du nombre $h$ en hexadécimal.
  • $h_i \in \{0,1,2,...,F\}$, pour $i$ allant de $0$ à $n-1$
Alors, en écriture décimale, on a : $$ h = h_{n-1} \times 16^{n-1}\ +\ b_{n-2} \times 16^{n-2}\ +\ \dots\ +\ b_{1} \times 16^{1}\ +\ b_{0} \times 16^{0} $$
Le nombre $\overline{\color{orange}{1}\color{green}{A}\color{red}{0}\color{blue}{E}}$ vaut : $$ \begin{array}{ccccccccc} && \color{orange}{1} \times 16^3 \ \ &+& \ \ \color{green}{10} \times 16^2 \ \ &+& \ \ \color{red}{0} \times 16^1 \ \ &+& \ \ \color{blue}{14} \times 16^0 \\ &=& \color{orange}{4096} &+& \color{green}{2560} &+& \color{red}{0} &+& \color{blue}{14} \\ &=& 6670 \end{array} $$ Et donc : $$ \overline{1A0E}^{hex} = \overline{6670}^{10} $$

Cette méthode repose également sur des divisions entières successives, mais par $16$.

  • On commence avec le nombre en base 10
  • On le divise par 16 et on retient le reste (entre 0 et 15)
  • On recommence avec le quotient précédent et on retient le reste
  • On s'arrête quand le quotient est nul
  • Le nombre hexadécimal est formé des restes (le dernier est le bit de poids fort, il faut lire à du haut vers le bas)
Nous appliquons cette méthode au nombre $\overline{2547}^{10}$ : $$ \begin{array}{llll} 2547 : 16 & = & 159 &+& \color{blue}{\overline{3}^{10}} \\ 159 : 16 & = & 9 &+& \color{red}{\overline{15}^{10}} \\ 9 : 16 & = & 0 &+& \color{green}{\overline{9}^{10}} \end{array} $$ En lisant de bas en haut, on obtient : $$ \overline{61}^{10} = \overline{\color{green}{9}\color{red}{F}\color{blue}{3}}^{hex} $$ car $\color{red}{\overline{15}^{10}} = \color{red}{\overline{F}^{hex}}$

Nous comprenons maintenant que l'indice du niveau de Pac-Man était sans doute codé sur un octet ne permettant de compter que jusqu'à 255. La vidéo ci-dessous (en anglais) va dans les détails (plutôt techniques) de ce fameux fill-screen :

Il y a énormément à dire sur la représentation des nombres. Le binaire et l'hexadécimal reviendront plus tard dans l'année, entre autre pour comprendre la représentation des couleurs en CSS (chapitre web) mais également les adresses IP dans le chapitre consacré aux réseaux.