Py

v1 : ton code

len_a = len(a)
len_b = len(b)

if len_a != len_b:
    if len_a < len_b:
        greater_length = len_b
        a_normalized = (len_b - len_a) * '0' + a
        b_normalized = b
        len_normalized = greater_length
    else:
        greater_length = len_a
        a_normalized = a
        b_normalized = (len_a - len_b) * '0' + b
        len_normalized = greater_length
else:
    a_normalized = a
    b_normalized = b
    len_normalized = len_a

v2 : greater_length sert à que dalle

len_a = len(a)
len_b = len(b)

if len_a != len_b:
    if len_a < len_b:
        len_normalized = len_b
        a_normalized = (len_b - len_a) * '0' + a
        b_normalized = b
    else:
        len_normalized = len_a
        a_normalized = a
        b_normalized = (len_a - len_b) * '0' + b
else:
    a_normalized = a
    b_normalized = b
    len_normalized = len_a

v3 : lisibilité on « applatit » les if, beaucoup plus lisible d’un coup d’oeil

len_a = len(a)
len_b = len(b)

if len_a < len_b:
    len_normalized = len_b
    a_normalized = (len_b - len_a) * '0' + a
    b_normalized = b
elif len_a > len_b:
    len_normalized = len_a
    a_normalized = a
    b_normalized = (len_a - len_b) * '0' + b
else:
    a_normalized = a
    b_normalized = b
    len_normalized = len_a

v4 : on fait sauter un ELSE inutile

len_a = len(a)
len_b = len(b)

if len_a < len_b:
    len_normalized = len_b
    a_normalized = (len_b - len_a) * '0' + a
    b_normalized = b
elif len_a >= len_b:
    len_normalized = len_a
    a_normalized = a
    b_normalized = (len_a - len_b) * '0' + b

v5 : une variante qu’on utilise trés souvent (un else de moins = moins de travail pour le processeur)

Python

len_a = len(a)
len_b = len(b)

len_normalized = len_a
a_normalized = a
b_normalized = (len_a - len_b) * '0' + b

if len_a < len_b:
    len_normalized = len_b
    a_normalized = (len_b - len_a) * '0' + a
    b_normalized = b

v6 : max

len_a = len(a)
len_b = len(b)
len_normalized = max(len_a, len_b)

if len_a < len_b:
    a_normalized = (len_normalized - len_a) * '0' + a
    b_normalized = b
else:
    a_normalized = a
    b_normalized = (len_normalized - len_b) * '0' + b

v7 : là normalement tu t’es rendu compte que les IF ne servent à rien

len_a = len(a)
len_b = len(b)
len_normalized = max(len_a, len_b)

a_normalized = (len_normalized - len_a) * '0' + a
b_normalized = (len_normalized - len_b) * '0' + b

v8 : optimisation de bon sens

len_normalized = max(len(a), len(b))

a_normalized = (len_normalized - len(a)) * '0' + a
b_normalized = (len_normalized - len(b)) * '0' + b

FIN

v9 bonus ; tu pouvais pas deviner mais la fonction zfill est géniale pour ça

len_normalized = max(len(a), len(b))

a_normalized = a.zfill(len_normalized)
b_normalized = b.zfill(len_normalized)

plus aucune optimisation possible

Voici une autre facon de faire que je souhaite te montrer

C’est typiquement un exercice « scolaire », qui te pousse à réfléchir en amont à ce que contient ce tableau de correspondance

# Table de correspondance : (a, b, carry_in) -> (bit_sortant, carry_out)
TABLE = {
    ('0', '0', 0): ('0', 0),
    ('0', '1', 0): ('1', 0),
    ('1', '0', 0): ('1', 0),
    ('1', '1', 0): ('0', 1),
    ('0', '0', 1): ('1', 0),
    ('0', '1', 1): ('0', 1),
    ('1', '0', 1): ('0', 1),
    ('1', '1', 1): ('1', 1),
}

def addition_table(a, b):
    taille = max(len(a), len(b))
    a = a.zfill(taille)
    b = b.zfill(taille)

    carry = 0
    total_bin = ""

    for i in range(1, taille + 1):
        bit, carry = TABLE[(a[-i], b[-i], carry)]
        total_bin = bit + total_bin

    return (carry * '1') + total_bin

---

---

---

v1 de la suite de ton code

for i in range(len_normalized):
    position = len_normalized - 1 - i
    val_a = a_normalized[position]
    val_b = b_normalized[position]

    if int(val_a) + int(val_b) + carry == 0:
        carry = 0
        total_bin = '0' + total_bin
    elif int(val_a) + int(val_b) + carry == 1:
        carry = 0
        total_bin = '1' + total_bin
    elif int(val_a) + int(val_b) + carry == 2:
        carry = 1
        total_bin = '0' + total_bin
    elif int(val_a) + int(val_b) + carry == 3:
        carry = 1
        total_bin = '1' + total_bin

if carry == 1:
    total_bin = '1' + total_bin
    carry = 0

v2

for i in range(len_normalized):
    position = len_normalized - 1 - i
    val_a = a_normalized[position]
    val_b = b_normalized[position]

    somme = int(val_a) + int(val_b) + carry

    if somme == 0:
        carry = 0
        total_bin = '0' + total_bin
    elif somme == 1:
        carry = 0
        total_bin = '1' + total_bin
    elif somme == 2:
        carry = 1
        total_bin = '0' + total_bin
    elif somme == 3:
        carry = 1
        total_bin = '1' + total_bin

if carry == 1:
    total_bin = '1' + total_bin
    carry = 0

v3 : pas obligatoire mais pour le fun je te montre : on perds en lisibilité mais c’est une optimisation

L’étape suivante consiste à regrouper les cas par valeur de carry :

Si somme vaut 0 ou 1 la retenue passe à 0.

Si somme vaut 2 ou 3, la retenue passe à 1.

Le bit ajouté est ‘1’ si la somme vaut 1 ou 3, sinon ‘0’.

On sépare la décision pour la retenue et pour le bit à ajouter :

for i in range(len_normalized):
    position = len_normalized - 1 - i
    val_a = a_normalized[position]
    val_b = b_normalized[position]

    somme = int(val_a) + int(val_b) + carry

    if somme >= 2:
        carry = 1
    else:
        carry = 0

    if somme == 1 or somme == 3:
        total_bin = '1' + total_bin
    else:
        total_bin = '0' + total_bin

if carry == 1:
    total_bin = '1' + total_bin
    carry = 0

v4

for i in range(len_normalized):
    position = len_normalized - 1 - i
    val_a = a_normalized[position]
    val_b = b_normalized[position]

    somme = int(val_a) + int(val_b) + carry

    carry = somme // 2
    total_bin = str(somme % 2) + total_bin

if carry == 1:
    total_bin = '1' + total_bin
    carry = 0

v5

for i in range(1, len_normalized + 1):
    val_a = a_normalized[-i]
    val_b = b_normalized[-i]

    somme = int(val_a) + int(val_b) + carry

    carry = somme // 2
    total_bin = str(somme % 2) + total_bin

if carry == 1:
    total_bin = '1' + total_bin
    carry = 0

v6

for i in range(1, len_normalized + 1):
    somme = int(a_normalized[-i]) + int(b_normalized[-i]) + carry

    carry = somme // 2
    total_bin = str(somme % 2) + total_bin

if carry == 1:
    total_bin = '1' + total_bin

v7

for i in range(1, len_normalized + 1):
    somme = int(a_normalized[-i]) + int(b_normalized[-i]) + carry

    carry = somme // 2
    total_bin = str(somme % 2) + total_bin

total_bin = carry * '1' + total_bin