Dans cet article, nous explorons différentes méthodes pour implémenter un algorithme de chiffrement simple sur une chaîne de caractères contenant des lettres et des chiffres. L'objectif est d'appliquer un décalage spécifique selon la casse des lettres tout en préservant les autres caractères.

Énoncé du problème

L'algorithme doit transformer une chaîne saisie par l'utilisateur selon les règles suivantes :

• Les lettres majuscules sont remplacées par la 5ème lettre suivante dans l'alphabet (rotation circulaire).
• Les lettres minuscules sont remplacées par la 3ème lettre suivante dans l'alphabet (rotation circulaire).
• Les chiffres et symboles restent inchangés.

Exemple :
Entrée : Life is short, you need Python!
Sortie : Qlih lv vkruw, brx qhhg Ubwkrq!

Approche 1 : Calcul algébrique via les codes ASCII

Cette méthode repose sur les fonctions intégrées ord() (caractère vers entier ASCII) et chr() (entier vers caractère). Pour gérer la circularité de l'alphabet (revenir à 'A' après 'Z'), nous utilisons l'opérateur modulo % 26.

def crypter_par_calcul(message):
    resultat = ""
    for char in message:
        if 'A' <= char <= 'Z':
            # Décalage de 5 pour les majuscules
            nouveau_code = (ord(char) - ord('A') + 5) % 26
            resultat += chr(nouveau_code + ord('A'))
        elif 'a' <= char <= 's' or 't' <= char <= 'z':
            # Décalage de 3 pour les minuscules
            if char.islower():
                nouveau_code = (ord(char) - ord('a') + 3) % 26
                resultat += chr(nouveau_code + ord('a'))
        else:
            resultat += char
    return resultat

entree = input("Saisissez votre texte : ")
print(crypter_par_calcul(entree))

Approche 2 : Utilisation d'un dictionnaire de correspondance

Ici, nous créons deux chaînes de référence : l'alphabet original et l'alphabet décalé. En trouvant l'index d'un caractère dans la première chaîne, nous pouvons extraire son équivalent chiffré dans la seconde.

def crypter_par_index(message):
    alpha_normal = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
    alpha_chiffre = "FGHIJKLMNOPQRSTUVWXYZABCDEdefghijklmnopqrstuvwxyzabc"
    
    sortie = []
    for lettre in message:
        if lettre in alpha_normal:
            idx = alpha_normal.index(lettre)
            sortie.append(alpha_chiffre[idx])
        else:
            sortie.append(lettre)
    return "".join(sortie)

entree = "Life is short, you need Python!"
print(crypter_par_index(entree))

Approche 3 : Optimisation avec maketrans et translate

Python propose des méthodes de haut niveau pour la manipulation de chaînes. Le module string permet de récupérer facilement les listes de lettres, tandis que str.maketrans() génère une table de traduction efficace.

import string

def crypter_optimise(message):
    # Préparation des alphabets
    maj_orig = string.ascii_uppercase
    min_orig = string.ascii_lowercase
    
    # Création des versions décalées
    maj_decalee = maj_orig[5:] + maj_orig[:5]
    min_decalee = min_orig[3:] + min_orig[:3]
    
    # Fusion pour la table de correspondance
    table = str.maketrans(maj_orig + min_orig, maj_decalee + min_decalee)
    
    return message.translate(table)

texte_test = "Life is short, you need Python!"
print(crypter_optimise(texte_test))

Cette dernière approche est la plus performante pour traiter des volumes importants de données, car l'opération de remplacement est effectuée au niveau de l'implémentation interne de Python (en C), évitant ainsi les boucles explicites coûteuses en ressources.