Exercices corrigés Python (Série 8)

def valide(ip):
    """Vérifie si l'adresse IPv4 est valide (4 octets dans [0,255])."""
    ad = ip.split('.')
    if len(ad) == 4:
        if 0 <= int(ad[0]) <= 255 and 0 <= int(ad[1]) <= 255 \
                and 0 <= int(ad[2]) <= 255 and 0 <= int(ad[3]) <= 255:
            return True
        else:
            return False
    else:
        return False


def binaire(nb):
    """Convertit un entier en binaire sur 8 bits (avec zéros de remplissage)."""
    val = ['0'] * 8
    binn = bin(int(nb))       # ex : '0b10011011'
    i = len(val) - len(binn[2:])
    for lettre in binn[2:]:
        val[i] = lettre
        i += 1
    return ''.join(val)       # ex : '10011011'


def classe(ip):
    """Retourne la classe (A–E) d'une adresse IPv4 valide."""
    if valide(ip):
        ad = ip.split('.')
        binn = binaire(ad[0])
        if binn[0] == '0':
            return 'A'
        elif binn[:2] == '10':
            return 'B'
        elif binn[:3] == '110':
            return 'C'
        elif binn[:4] == '1110':
            return 'D'
        else:
            return 'E'
    else:
        return False


def adresseip6(ip):
    """Convertit une IPv4 valide en bloc IPv6 (32 bits hexadécimaux)."""
    if valide(ip):
        ad = ip.split('.')
        # hex()[2:] enlève le préfixe '0x'
        bloc = (hex(int(ad[0]))[2:] + hex(int(ad[1]))[2:]
              + ':' + hex(int(ad[2]))[2:] + hex(int(ad[3]))[2:])
        return bloc + '\n'
    else:
        return ''


def Genere():
    """Lit F_IPV4.txt et génère F_IPV6.txt avec les adresses valides."""
    source = open('F_IPV4.txt', 'r')
    dest   = open('F_IPV6.txt', 'a')
    for ligne in source:
        ip = ligne.strip()
        if valide(ip):
            chaine = ip + ' : ' + classe(ip) + ' : ' + adresseip6(ip)
            dest.write(chaine)
    source.close()
    dest.close()


# Test manuel
print(valide("155.105.50.68"))      # True
print(classe("155.105.50.68"))      # B
print(adresseip6("155.105.50.68"))  # 9b69:3244

def matrice(motcle):
    """Construit la matrice 5×5 de Polybe à partir d'un mot-clé."""
    alpha = 'ABCDEFGHIJKLMNOPQRSTUVXYZ'   # alphabet sans W
    Mat = [[0] * 5 for _ in range(5)]
    Mat[0][0] = motcle[0]
    i, j = 0, 1

    # Placer les lettres du mot-clé (sans doublons)
    for pos in range(1, len(motcle)):
        if j == 5:
            i += 1; j = 0
        if motcle[pos] not in motcle[:pos]:
            Mat[i][j] = motcle[pos]
            j += 1

    # Compléter avec l'alphabet restant
    for lettre in alpha:
        if j == 5:
            i += 1; j = 0
        if lettre not in motcle:
            Mat[i][j] = lettre
            j += 1

    return Mat


def Crypter_Polybe(msg, motcle):
    """Chiffre un message selon le carré de Polybe."""
    Mat = matrice(motcle)
    res = ''
    for c in msg:
        if c == ' ':
            res += '_'
        elif c == 'W':
            res += '00'
        else:
            # Recherche de la lettre dans la matrice
            i = j = 0
            while Mat[i][j] != c:
                j += 1
                if j == 5:
                    j = 0; i += 1
            res += str(i + 1) + str(j + 1)
    return res


def Decrypter_Polybe(msg, motcle):
    """Déchiffre un message encodé selon le carré de Polybe."""
    Mat = matrice(motcle)
    res = ''
    k = 0
    while k < len(msg):
        if msg[k] == '_':
            res += ' '; k += 1
        elif msg[k] == '0':
            res += 'W'; k += 2
        else:
            i = int(msg[k]) - 1
            j = int(msg[k + 1]) - 1
            res += Mat[i][j]
            k += 2
    return res


# Test
cle  = "MYSTER"
msg  = "CHERCHER POLYBE DANS WIKIPEDIA"
code = Crypter_Polybe(msg, cle)
print(code)
print(Decrypter_Polybe(code, cle))