Conversion décimal <-> binaire

Chaque exercice est fourni avec un fichier Python à compléter et un énoncé « papier » distribué à l'élève et reproduit ci-dessous.

Remarques importantes

1. Les exercices de cette page ne sont pas classés par ordre de « difficulté », cette notion de difficulté étant subjective et dépendante de chaque élève.

2. Les solutions proposées ne sont que des propositions !
   Il existe d'autres codes valables pour répondre à chaque problème que ceux proposés ici : il ne faut pas hésiter à les soumettre à votre enseignant pour qu'il vous donne son avis sur les idées mises en oeuvre.

Décimal -> Binaire

Écrire le code d'une fonction conv_bin() qui prend en paramètre un entier positif n et renvoie un couple (b, bit) où :

• b est un tableau d'entiers correspondant à la représentation binaire de n ;
• bit correspond aux nombre de bits qui constituent b.

Exemples

>>> conv_bin(9) 
([1, 0, 0, 1], 4)

>>> conv_bin(128) 
([1, 0, 0, 0, 0, 0, 0, 0], 8)

>>> conv_bin(-1) 
AssertionError: Il faut entrer un entier positif ou nul !

Rappels

• l'opérateur // donne le quotient de la division euclidienne : 5//2 donne 2 ;
• l'opérateur % donne le reste de la division euclidienne : 5%2 donne 1.

1. Compléter la définition de la fonction conv_bin(), sans oublier d’ajouter l’assertion signalée dans l’exemple précédent.

   def conv_bin(n):
       """
       n - 
       Sortie: 
       >>> conv_bin(9) 
       ([1, 0, 0, 1], 4)
       >>> conv_bin(128) 
       ([1, 0, 0, 0, 0, 0, 0, 0], 8)
       """
       pass
   
   
   
   if __name__ == '__main__':
       import doctest
       doctest.testmod()
   

2. Compléter le docstring de cette fonction.

3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).

Une solution possible

def conv_bin(n):
    """
    n - int - entier positif ou nul
    Sortie: (list, int) - couple constitué d'un tableau des bits formant
            l'écriture binaire de n et du nombre de bits
    >>> conv_bin(9) 
    ([1, 0, 0, 1], 4)
    >>> conv_bin(128) 
    ([1, 0, 0, 0, 0, 0, 0, 0], 8)
    """
    assert isinstance(n, int) and n >=0, "Il faut entrer un entier positif ou nul !"
    if n==0:
        return ([0], 1)
    else:
        tab = []
        while n > 0:
            nouveau_bit = n%2               # reste
            tab = [nouveau_bit] + tab       # On concatène pour "insérer" à gauche
            n = n//2                        # On remplace n par le quotient
        return ( tab, len(tab) )


if __name__ == '__main__':
    import doctest
    doctest.testmod()

    print( conv_bin(97) == ([1, 1, 0, 0, 0, 0, 1], 7) )
    print( conv_bin(1) == ([1], 1) )

Binaire -> Décimal

On modélise la représentation binaire d'un entier non signé par un tableau d'entiers dont les éléments sont 0 ou 1. Par exemple, le tableau [1, 0, 1, 0, 0, 1, 1] représente l'écriture binaire de l'entier dont l'écriture décimale est :

2**6 + 2**4 + 2**1 + 2**0 = 83

À l'aide d'un parcours séquentiel, écrire le code de la fonction conv_ent() qui prend en paramètre un tableau dont les éléments sont 0 ou 1 et représentant un entier écrit en binaire. Cette fonction renvoie l'écriture décimale de l'entier positif correspondant.

Exemples

>>> conv_ent([1, 0, 1, 0, 0, 1, 1]) 
83

>>> conv_ent([1, 0, 0, 0, 0, 0, 1, 0]) 
130

>>> conv_ent('10000010') 
AssertionError: Il faut entrer un tableau non vide !

1. Compléter la définition de la fonction conv_ent(), sans oublier d’ajouter l’assertion signalée dans l’exemple précédent.

   def conv_ent(tab):
       """
       tab - 
       Sortie: 
       >>> conv_ent([1, 0, 1, 0, 0, 1, 1]) 
       83
   
       >>> conv_ent([1, 0, 0, 0, 0, 0, 1, 0]) 
       130
       """
       pass
   
   
   
   if __name__ == '__main__':
       import doctest
       doctest.testmod()
   

2. Compléter le docstring de cette fonction.

3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).

Une solution possible

def conv_ent(tab):
    """
    tab - list - tableau dont les éléments sont 0 ou 1.
          Ce tableau représente l'écriture binaire d'un entier
    Sortie: int, écriture décimale de l'entier correspondant
    >>> conv_ent([1, 0, 1, 0, 0, 1, 1]) 
    83
    >>> conv_ent([1, 0, 0, 0, 0, 0, 1, 0]) 
    130
    """
    assert isinstance(tab, list) and tab != [], "Il faut entrer un tableau non vide !"
    resultat = 0
    puis = 1
    for i in range(len(tab)-1, -1, -1):
        resultat = resultat + tab[i]*puis
        puis = puis*2
    return resultat


if __name__ == '__main__':
    import doctest
    doctest.testmod()

    print( conv_ent([1, 1, 0, 0, 0, 0, 1]) == 97 )
    print( conv_ent([1]) == 1 )

Décimal -> Binaire sous forme de chaîne

Pour rappel, la conversion d’un nombre entier positif en binaire peut s’effectuer à l’aide des divisions successives comme illustré ici :

La fonction Python binaire(), basée sur la méthode des divisions successives doit permettre de convertir un nombre entier positif en son écriture binaire sous forme de chaîne de caractères.

Exemples

>>> binaire(0)
'0'

>>> binaire(77) 
'1001101'

>>> binaire(-1) 
AssertionError: Il faut entrer un entier positif ou nul !

1. Compléter la définition de la fonction binaire(), sans oublier d’ajouter l’assertion signalée dans l’exemple précédent.

   def binaire(n):
       """
       n - 
       Sortie: 
       >>> binaire(0)
       '0'
       >>> binaire(77) 
       '1001101'
       """
       pass
   
   
   
   if __name__ == '__main__':
       import doctest
       doctest.testmod()
   

2. Compléter le docstring de cette fonction.

3. Ajouter au moins deux nouveaux tests avec affichage dans la partie principale du programme (le main).

Une solution possible

def binaire(n):
    """
    n - int, nombre entier positif
    Sortie: str - Écriture binaire de n sous forme de chaîne de caractères
    >>> binaire(0)
    '0'
    >>> binaire(77) 
    '1001101'
    """
    assert isinstance(n, int) and n >=0, "Il faut entrer un entier positif ou nul !"
    bin_n = str(n%2)
    n = n // 2
    while n != 0 :
        bin_n = str(n%2) + bin_n
        n = n//2
    return bin_n


if __name__ == '__main__':
    import doctest
    doctest.testmod()

    print(binaire(123) == '1111011')
    print(binaire(255) == '11111111')