Ou exclusif entre deux listes

L'opérateur « ou exclusif » entre deux bits renvoie 1 si le premier ou le second est égal à 1, mais pas les deux (exclusion du cas où les deux sont égaux à 1). Il est symbolisé par le caractère ⊕.
Ainsi :

  • 0 ⊕ 0 = 0
  • 0 ⊕ 1 = 1
  • 1 ⊕ 0 = 1
  • 1 ⊕ 1 = 0

On représente ici une suite de bits par une liste contenant des 0 et des 1.

Exemples :

🐍 Script Python
liste_a = [1, 0, 1, 0, 1, 1, 0, 1]
liste_b = [0, 1, 1, 1, 0, 1, 0, 0]
liste_c = [1, 1, 0, 1]
liste_d = [0, 0, 1, 1]

Écrire la fonction ou_exclusif qui prend en paramètres deux listes non vides de même longueur constituées uniquement de 0 et de 1. Cette fonction renvoie une liste où l’élément situé à la position i est le résultat, par l’opérateur « ou exclusif », des éléments à la position i des listes passées en paramètres.

En considérant les quatre exemples ci-dessus, on obtient :

🐍 Console Python
>>> ou_exclusif(liste_a, liste_b)
[1, 1, 0, 1, 1, 0, 0, 1]
>>> ou_exclusif(liste_c, liste_d)
[1, 1, 1, 0]

Contrainte

Vous ne devez pas utiliser l'opérateur ^de Python.

Compléter ci-dessous

###
# Testsbksl-nllistepy-unda = [1, 0, 1, 0, 1, 1, 0, 1]bksl-nllistepy-undb = [0, 1, 1, 1, 0, 1, 0, 0]bksl-nllistepy-undc = [1, 1, 0, 1]bksl-nllistepy-undd = [0, 0, 1, 1]bksl-nlassert oupy-undexclusif(listepy-unda, listepy-undb) == [1, 1, 0, 1, 1, 0, 0, 1]bksl-nlassert oupy-undexclusif(listepy-undc, listepy-undd) == [1, 1, 1, 0]bksl-nlbksl-nl# Autres testsbksl-nlfrom random import randintbksl-nllistepy-unde = [randint(0, 1) for i in range(100)]bksl-nllistepy-undf = [randint(0, 1) for i in range(100)]bksl-nlresultatpy-undattendu = [(listepy-unde[i] + listepy-undf[i])%2 for i in range(100)]bksl-nlassert oupy-undexclusif(listepy-unde, listepy-undf) == resultatpy-undattendubksl-nlbksl-nlbksl-nl 5/5
def oupy-undexclusif(listepy-und1, listepy-und2):bksl-nl ...bksl-nlbksl-nl# Testsbksl-nllistepy-unda = [1, 0, 1, 0, 1, 1, 0, 1]bksl-nllistepy-undb = [0, 1, 1, 1, 0, 1, 0, 0]bksl-nllistepy-undc = [1, 1, 0, 1]bksl-nllistepy-undd = [0, 0, 1, 1]bksl-nlassert oupy-undexclusif(listepy-unda, listepy-undb) == [1, 1, 0, 1, 1, 0, 0, 1]bksl-nlassert oupy-undexclusif(listepy-undc, listepy-undd) == [1, 1, 1, 0]bksl-nlbksl-nlbksl-nldef oupy-undexclusifpy-undbits(a, b):bksl-nl if a == b:bksl-nl return 0bksl-nl return 1bksl-nlbksl-nldef oupy-undexclusif(listepy-und1, listepy-und2):bksl-nl taille = len(listepy-und1)bksl-nl return [oupy-undexclusifpy-undbits(listepy-und1[i], listepy-und2[i]) for i in range(taille)]bksl-nlbksl-nl

Autres possibilités

👉 On n'est pas obligé, comme le suggère l'énoncé, de créer une fonction "ou exclusif" entre deux bits, que nous avons nommée dans cette correction ou_exclusif_bits.

Version avec ==

🐍 Script Python
def ou_exclusif(liste_1, liste_2):
    liste = []
    for i in range(len(liste_1)):
        if liste_1[i] == liste_2[i]:
            liste.append(0)
        else:
            liste.append(1)
    return liste

Version arithmétique

On remarque que :

  • \(0+0=0\)
  • \(0+1=1\)
  • \(1+0=1\)
  • \(1+1=2\) et donc \((1+1) \% 2 = 0\)
🐍 Script Python
def ou_exclusif(liste_1, liste_2):
    return [(liste_1[i] + liste_2[i]) % 2 for i in range(len(liste_1))]

Version fonctionnelle

On peut utiliser la fonction zip qui prend deux listes de même taille et renvoie la liste des couples formés les éléments de deux listes de même indice.

🐍 Script Python
def ou_exclusif(liste_1, liste_2):
    return [ou_exclusif_bits(n_1[i], n_2[i]) for n_1, n_2 in zip(liste_1, liste_2)]

Version interdite

L'opérateur « ou exclusif » entre deux bits existe en Python : ^. Il était interdit dans cet exercice.

🐍 Console Python
>>> 0 ^ 0
0
>>> 0 ^ 1
1
>>> 1 ^ 0
1
>>> 1 ^ 1
0

On aurait donc pu écrire de façon plus concise :

🐍 Script Python
def ou_exclusif(liste_1, liste_2):
    return [(liste_1[i] ^ liste_2[i]) for i in range(len(liste_1))]
Approfondissement : l'opérateur ^ de Python opère bit à bit

Par exemple :

  • \(7_{10}= 111_2\)
  • \(9_{10}=1001_2\)

Réalisons le xor bit à bit :

0 1 1 1
xor 1 0 0 1
= 1 1 1 0

Or \(1110_2=14_{10}\)

🐍 Console Python
>>> 7 ^ 9
14
Astuce

Vous pourrez écrire une fonction ou_exclusif_bits qui prend en paramètres deux entiers égaux à 0 ou 1, et renvoie l'entier obtenu avec le ou exclusif appliqué à ces deux entiers.