def base2(n):
    if n == 0:
        return [0]
    L = []
    while n > 0:
        L.append(n % 2)
        n //= 2
    return L[::-1]
# ou
def base2(n):
    L = []
    while n//2 > 0:
        L.append(n % 2)
        n //= 2
    L.append(n)
    return L[::-1]
# ou
def base2(n):
    L = []
    while n//2 > 0:
        L = [n % 2] + L
        n //= 2
    return [n % 2] +L


def base10(L):
    """Convertit une liste binaire L en entier base 10."""
    n = 0
    for k in range(len(L)):
        b = L[k]
        n += b * 2 ** (n-k-1)
    return n
def base10(L):
    L = L[::-1] # tech chaussette
    n = 0
    for k in range(len(L)):
        b = L[k]
        n += b * 2 ** k
    return n

def base10_horner(L):
    n = 0
    for bit in L:
        n = n * 2 + bit
    return n

# ou version rec
def b10_horner(L):
    if len(L)==1: return L[0]
    return 2*b10_horner(L[:-1]) + L[-1]

def base2_octet(n, k=8):
    """Convertit un entier n en binaire sur k bits."""
    L = base2(n)
    return [0] * (k - len(L)) + L


def somme(L1, L2):
    n = len(L1)
    retenue =  0
    L3 = n *[0]
    for k in range(n):
        i = n-1-k
        s = L1[i] + L2[i] + retenue
        if s == 3:
            L3[k] = 1
            retenue = 1
        elif s == 2:
            L3[k] = 0
            retenue = 1
        else :
            L3[k] = s
            retenue = 0
    return L3


def base2_rel(n, k=8):
    """Convertit un entier relatif n en base 2 avec un bit de signe."""
    if n >= 0:
        return [0] + base2_octet(n, k - 1)
    else:
        return [1] + base2_octet(-n, k - 1)


def base2_rel_2(n, k=8):
    """Convertit un entier relatif n en base 2 avec la méthode du complément à 2."""
    if n >= 0:
        return base2_octet(n, k)
    else:
        complement = base2_octet((1 << k) + n, k)
        return complement


def base2_rel_3(n, k=8):
    """Convertit un entier relatif n en base 2 avec la méthode du complément à 2 (inversion des bits + 1)."""
    if n >= 0:
        return base2_octet(n, k)
    else:
        L = base2_octet(abs(n), k)
        L = [1 - bit for bit in L]  # Inversion des bits
        for i in range(k - 1, -1, -1):
            if L[i] == 0:
                L[i] = 1
                break
            else:
                L[i] = 0
        return L