C'est un code binaire particulier, qui a pour caractéristique principale de passer d'un nombre au nombre suivant en ne changeant qu'un seul bit.

Par exemple, on passe de 3=“00000010” à 4=“00000110”: seul le 3ème bit en partant de la droite est passé de “0” à “1”.

Ce code est très utilisé en automatisme et en informatique (hardware), parce que, dans ces techniques, le changement d'état simultané de plusieurs organes logiques est une source d'instabilité.

Il est aussi utilisé pour résoudre certains casse-tête (comme le baguenaudier par exemple: http://www.recreomath.qc.ca/dict_baguenaudier.htm). D'ailleurs, c'est pour résoudre ce jeu que ce code a été publié pour la première fois par un certain Louis Gros, clerc de notaire à Lyon, en 1872. Mais c'est l'américain Frank Gray qui déposa un brevet sur ce code en 1953.

Pour en connaitre plus: http://fr.wikipedia.org/wiki/Arithm%C3%A9tique_binaire

Voilà un exemple de progression comparée entre le code binaire normal et le code de Gray. Vous pouvez constater qu'on passe d'une ligne à la suivante en ne changeant qu'un seul bit pour le code de Gray, ce qui n'est pas vrai pour le code binaire normal:

dec.  binaire   code Gray
00    00000000  00000000
01    00000001  00000001
02    00000010  00000011
03    00000011  00000010
04    00000100  00000110
05    00000101  00000111
06    00000110  00000101
07    00000111  00000100
08    00001000  00001100
09    00001001  00001101
10    00001010  00001111
11    00001011  00001110
12    00001100  00001010
13    00001101  00001011
14    00001110  00001001
15    00001111  00001000
16    00010000  00011000
17    00010001  00011001
18    00010010  00011011
19    00010011  00011010
20    00010100  00011110

Code proposé:

#!/usr/bin/python
# -*- coding: utf-8 -*-
from __future__ import division
 
def dec2gray(n,nb=8):
    ch=""
    for k in xrange(nb,0,-1):
        ch+="01"[((n+(2**(k-1)))>>k)%2]
    return ch
 
# exemple d'utilisation
print dec2gray(14)  # affiche: "00001001"
print dec2gray(14,16)  # affiche: "0000000000001001"

En entrée de cette fonction, n est le nombre décimal que l'on veut convertir en code de Gray, et nb est le nombre de bits (8 par défaut).

Pour obtenir le nombre décimal correspondant à un code de Gray donné:

def gray2dec(ch):
    i=ch.find("1")
    if i<0:
        return 0
    lg=len(ch)
    k=lg-i
    n=(2**k)-(2**(k-1))
    while k>1:
        k-=1
        b=int(ch[lg-k])
        y=0
        while (2*y+b)*(2**k)-(2**(k-1))+(2**k)-1 < n:
            y+=1
        np=(2*y+b)*(2**k)-(2**(k-1))
        if np>n:
            n=np
    return n
 
# exemple d'utilisation
print gray2dec("00001001")  # affiche: 14

En entrée de cette fonction, le seul paramètre est la chaîne de caractère représentant le code de Gray.

Vous pouvez tester ces fonctions sur ma Calculext en ligne: http://calculext.jpvweb.com