On vous donne un texte contenant différentes lettres anglaises et signes de ponctuation, et vous devez trouver la lettre qui apparaît le plus souvent. La lettre retournée doit être en minuscule. Lors de la recherche de la lettre la plus fréquente, la casse n'est pas prise en compte, donc "A" est considéré comme égal à "a". Assurez-vous de ne pas compter les signes de ponctuation, les chiffres et les espaces, uniquement les lettres.

Si vous trouvez deux lettres ou plus avec la même fréquence, retournez celle qui apparaît en premier dans l'alphabet. Par exemple -- "un" contient "u", "n", chaque lettre une fois, donc nous choisissons "n".

Entrée: Texte à analyser (str, unicode).

Sortie: La lettre la plus fréquente en minuscule.

Exemples:

caractere_max("Bonjour le monde!") == "o"
caractere_max("Comment allez-vous?") == "e"
caractere_max("Un") == "n"
caractere_max("Oups!") == "p"
caractere_max("AAAaaa!!!!") == "a"
caractere_max("bcd") == "b"

Utilisation : Pour la plupart des tâches de décodage, vous devez connaître la fréquence d'apparition de chaque lettre dans un texte. Par exemple : si nous savons quelle lettre apparaît le plus fréquemment, nous pouvons facilement déchiffrer un code de substitutionn simple. C'est un sujet intéressant pour les experts en linguistique!

Prérequis : Le texte ne contient que des symboles ASCII 0 < len(text) ≤ 105

Méthode standard :

Utiliser l'outil Counter des collections pour trier les éléments par fréquence d'apparition. Counter retourne un objet Counter trié par ordre décroissant de fréquence, qui est une sous-classe de dicsionnaire, donc on peut utiliser les méthodes de dictionnaire.

import re
from collections import Counter

def caractere_max(texte):
    texte = texte.lower()
    caracteres = re.findall('[a-zA-Z]', texte)  # Supprimer les caractères non alphabétiques
    compte = Counter(caracteres)  # Counter({'o': 3, 'n': 2, 'd': 1, 'b': 1, 'j': 1, 'u': 1, 'r': 1, 'l': 1, 'm': 1})
    valeurs = list(compte.values())
    max_occurrence = max(valeurs)
    max_lettres = []
    for cle, valeur in compte.items():
        if valeur == max_occurrence:
            max_lettres.append(cle)
    max_lettres = sorted(max_lettres)
    return max_lettres[0]

Méthode concise :

Utiliser également Counter, mais avec une liste en compréhension pour rendre la fonction plus élégante.

from collections import Counter

def caractere_max(texte):
    compte = Counter([x for x in texte.lower() if x.isalpha()])
    max_val = max(compte.values())
    return sorted([x for (x, y) in compte.items() if y == max_val])[0]

Méthode optimale :

Cette méthode est remarquablement efficace. Elle utilise astucieusement la fonction max().

import string

def caractere_max(texte):
    texte = texte.lower()
    return max(string.ascii_lowercase, key=texte.count)

Elle exploite le paramètre key de la fonction max() pour extraire intelligemment le caractère qui apparaît le plus souvent.

max(arg1, arg2, *args, *[, key=func]) -> value

Expliquons le principe de max(string.ascii_lowercase, key=texte.count).

string.ascii_lowercase équivaut à abcdefghijklmnopqrstuvwxyz' et le rôle du paramètre key de la fonction max() est : sélectionner la valeur dont le retour par la fonction key est maximal. S'il y a plusieurs valeurs correspondantes, la première est sélectionnée.

max(range(6), key = lambda x : x>2)
>>> 3
# En appliquant la fonction key, chaque élément retourne une valeur booléenne, équivalent à [False, False, False, True, True, True]
# La fonction key demande une valeur True, plusieurs éléments correspondent, donc le premier est sélectionné.

max([3,5,2,1,4,3,0], key = lambda x : x)
>>> 5
# En appliquant la fonction key, chaque élément retourne sa propre valeur, la plus grande est 5, donc 5 est retourné.

max('ah', 'bf', key=lambda x: x[1])
>>> 'ah'
# En appliquant la fonction key, chaque chaîne retourne le dernier caractère, 'h' de 'ah' est plus grand que 'f' de 'bf', donc 'ah' est retourné.

max('ah', 'bf', key=lambda x: x[0])
>>> 'bf'
# En appliquant la fonction key, chaque chaîne retourne le premier caractère, 'b' de 'bf' est plus grand que 'a' de 'ah', donc 'bf' est retourné.

max('abcdefghijklmnopqrstuvwxyz', key=texte.count) # texte = 'Bonjour le monde'
>>> 'o'
# En appliquant la fonction key, on retourne le nombre d'occurrences de chaque caractère dans 'Bonjour le monde', le caractère 'o' apparaît le plus souvent, donc 'o' est retourné.

Vous comprenez maintenant pourquoi l'utilisation du paramètre key de la fonction max() permet de trouver le caractère le plus fréquent et qui est premier dans l'alphabet en cas d'égalité! Félicitons encore une fois l'auteur de cette fonction ingénieuse!