Exercices corrigés Python (Série 5)

import re

def encoder_rle(CH):
    """
    Encode CH en RLE. Version avec itertools.groupby.
    groupby groupe les caractères identiques consécutifs.
    """
    from itertools import groupby
    return ''.join(str(sum(1 for _ in groupe)) + c
                   for c, groupe in groupby(CH))


def decoder_rle(code):
    """
    Décode une chaîne RLE.
    re.findall(r'(\d+)([A-Za-z])') extrait les couples (nombre, lettre).
    """
    return ''.join(c * int(n) for n, c in re.findall(r'(\d+)([A-Za-z])', code))


# Tests
original = "aaaFyBssssssssssssazz"
code     = encoder_rle(original)
retour   = decoder_rle(code)

print(f"Original : {original}")
print(f"Encodé   : {code}")
print(f"Décodé   : {retour}")
print(f"Sans perte : {original == retour}")

def crypter_mc(s):
    """
    Chiffre le mot s par substitution basée sur la fréquence de chaque lettre.
    Version avec chr/ord pour éviter la dépendance à la chaîne alpha.
    """
    res = ''
    for lettre in s:
        n     = s.count(lettre)
        K     = 2 * n if n % 2 == 1 else n // 2
        pos   = ord(lettre) - ord('A')         # position 0–25
        res  += chr(ord('A') + (pos + K) % 26) # nouvelle lettre
    return res


# Vérification lettre par lettre
def expliquer(s):
    print(f"Mot : {s}")
    print(f"{'Lettre':<8} {'n':>3} {'K':>4} {'→':>3}")
    for c in s:
        n = s.count(c)
        K = 2*n if n % 2 == 1 else n // 2
        pos = ord(c) - ord('A')
        nc  = chr(ord('A') + (pos + K) % 26)
        print(f"  {c:<6} {n:>3} {K:>4}   {nc}")
    print(f"Chiffré : {crypter_mc(s)}\n")


expliquer("HAPPY")
expliquer("BANANA")

def crypter(ch):
    """ROT+1 : cas particulier du chiffre de César avec d=1."""
    return ''.join(chr(ord('A') + (ord(c) - ord('A') + 1) % 26) for c in ch)


# Généralisation : décoder = ROT+25 (ou ROT-1)
def decrypter(ch):
    return ''.join(chr(ord('A') + (ord(c) - ord('A') - 1) % 26) for c in ch)


msg  = "ABCCZABEY"
code = crypter(msg)
print(f"Chiffré : {code}")
print(f"Décodé  : {decrypter(code)}")

def cesar(s, d):
    """Chiffre de César — chiffrement si d > 0, déchiffrement si d < 0."""
    return ''.join(chr(ord('A') + (ord(c) - ord('A') + d) % 26)
                   for c in s.upper() if c.isalpha())


def dechiffrer_cesar(s, d):
    """Déchiffrement = chiffrement avec le décalage opposé."""
    return cesar(s, -d)


def bruteforce_cesar(code):
    """Essayer les 26 décalages possibles (attaque par force brute)."""
    print("Attaque par force brute :")
    for d in range(26):
        print(f"  d={d:2} → {cesar(code, -d)}")


# Tests
msg  = "ABCDEFGH"
code = cesar(msg, 3)
print(f"Chiffré  : {code}")
print(f"Déchiffré: {dechiffrer_cesar(code, 3)}")
print()
bruteforce_cesar("KHOOR")   # 'KHOOR' est 'HELLO' chiffré avec d=3

import random
import string

def crypter_alea(msg, cle='HYLUJPVREAKBNDOFSQZCWMGITX'):
    """Chiffrement par substitution alphabétique."""
    table = str.maketrans('ABCDEFGHIJKLMNOPQRSTUVWXYZ', cle)
    return msg.upper().translate(table)


def decrypter_alea(code, cle='HYLUJPVREAKBNDOFSQZCWMGITX'):
    """Déchiffrement : inverse la table de substitution."""
    table = str.maketrans(cle, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
    return code.translate(table)


def generer_cle():
    """Génère une clé aléatoire valide (permutation de A–Z)."""
    lettres = list(string.ascii_uppercase)
    random.shuffle(lettres)
    return ''.join(lettres)


# Tests
cle  = 'HYLUJPVREAKBNDOFSQZCWMGITX'
msg  = "ABCDEFZ"
code = crypter_alea(msg, cle)
back = decrypter_alea(code, cle)
print(f"Original : {msg}")
print(f"Chiffré  : {code}")
print(f"Déchiffré: {back}")

def vigenere_chiffrer(msg, cle):
    """
    Chiffrement de Vigenère.
    - Ignore les espaces (les conserve dans le résultat).
    - La clé ne progresse que sur les lettres de l'alphabet.
    """
    alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    res   = []
    k     = 0   # index dans la clé (avance seulement sur les lettres)

    for c in msg.upper():
        if c in alpha:
            d      = alpha.index(cle.upper()[k % len(cle)])
            pos    = alpha.index(c)
            res.append(alpha[(pos + d) % 26])
            k += 1
        else:
            res.append(c)   # conserver espaces et ponctuation

    return ''.join(res)


def vigenere_dechiffrer(code, cle):
    """Déchiffrement : décalage négatif."""
    alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    res   = []
    k     = 0
    for c in code.upper():
        if c in alpha:
            d   = alpha.index(cle.upper()[k % len(cle)])
            pos = alpha.index(c)
            res.append(alpha[(pos - d) % 26])
            k += 1
        else:
            res.append(c)
    return ''.join(res)


# Tests
cle  = "VIGENERE"
msg  = "IL FAUT CODER CETTE PHRASE"
code = vigenere_chiffrer(msg, cle)
back = vigenere_dechiffrer(code, cle)

print(f"Original : {msg}")
print(f"Chiffré  : {code}")
print(f"Déchiffré: {back}")