Voici quelques jeux de mots originaux inspirés du fil de Adam Aaronson sur X. Le principe : appliquer des critères mathématiques ou visuels à des listes de mots français classés par longueur (de 2 à 15 lettres) pour trouver des champions inattendus.
Nous aurons besoin de dictionnaires (mots de 2 lettres à 15 lettres), les voici de façon séparés.
Mot qui parcourt la plus longue distance dans l’alphabet
En parcourant un mot lettre à lettre, on mesure la distance alphabétique entre chaque paire de lettres consécutives. Plus les lettres sautent loin dans l’alphabet, plus le score est élevé.
Exemple : « AXA » — de A à X, il y a 23 pas, puis 23 de retour de X à A, soit une distance totale de 46.
Objectif : trouver, pour chaque longueur, le mot cumulant la plus grande distance alphabétique.
Vous devriez trouver :
2 : AY (24)
3 : AXA (46)
4 : AXAT (65)
5 : RAYAT (84)
6 : ZEZAYA (115)
7 : ZEZAYAT (134)
8 : ZEZAYANT (134)
9 : ZEZAYATES (163)
10 : ZEZAYASSES (161)
11 : ZEZAYASSIEZ (168)
12 : REHYDRATATES (171)
13 : PARAPHRASATES (183)
14 : REVASCULARISAT (196)
15 : REVASCULARISERA (203)
La famille des « zézayer » (parler en substituant des « z » aux « j » ou « s ») domine largement les mots courts grâce à l’alternance entre Z, la dernière lettre, et des lettres du début de l’alphabet.
def score(mot):
return sum(abs(ord(b) - ord(a)) for a, b in zip(mot, mot[1:]))
for i in range(2, 16):
with open(f"dic{i}.txt") as f:
mots = [line.strip() for line in f if line.strip()]
solution = max(mots, key=score)
print(f"{len(solution)} : {solution} ({score(solution)})")Mots les plus étroits
Tous les caractères n’ont pas la même largeur à l’écran. En police Arial 16 px, un « i » ou un « l » occupe bien moins d’espace qu’un « m » ou un « w ». Quel mot, pour chaque longueur, tient dans le moins de pixels possible ?
Exemple : « il » écrit en Arial prend moins de place que « ma ».
Objectif : trouver, pour chaque longueur, le mot le plus étroit.
Vous devriez trouver :
2 : il (7.1)
3 : fil (11.55)
4 : fifi (16.0)
5 : flirt (21.33)
6 : rififi (24.88)
7 : jaillit (31.1)
8 : titiller (37.33)
9 : titillait (40.0)
10 : liliiflore (48.88)
11 : titillerait (54.23)
12 : illisibilite (58.65)
13 : illisibilites (66.65)
14 : infaillibilite (72.9)
15 : infaillibiliste (80.9)
Les lettres i, l, f et t sont les grandes gagnantes — et il n’est pas surprenant qu’« illisibilité » apparaisse dans le palmarès, un mot presque fait sur mesure pour ce défi !
Largeurs des lettres en Arial 16px :
# poids des lettres a → z
w = [8.9, 8.9, 8.0, 8.9, 8.9, 4.45, 8.9, 8.9, 3.55, 3.55,
8.0, 3.55, 13.3, 8.9, 8.9, 8.9, 8.9, 5.33, 8.0, 4.45,
8.9, 8.0, 11.6, 8.0, 8.0, 8.0]
# fonction de score d’un mot
def score(mot):
return sum(w[ord(c) - 65] for c in mot) # A=65
# parcours des fichiers
for i in range(2, 16):
with open(f"dic{i}.txt") as f:
mots = [line.strip() for line in f if line.strip()]
# mot avec score minimal
solution = min(mots, key=score)
print(f"{len(solution)} : {solution.lower()} ({score(solution)})")
Mots avec les lettres les plus éloignées dans l’alphabet
Cette fois, on s’intéresse non plus aux sauts entre lettres consécutives, mais à la position absolue de chaque lettre dans l’alphabet. Z vaut 26, A vaut 1. Quel mot affiche la moyenne de position la plus haute ?
Exemple : « ZUT » → Z (26) + U (21) + T (20) = 67, moyenne = 22,33.
Objectif : trouver, pour chaque longueur, le mot dont les lettres occupent en moyenne la position la plus haute dans l’alphabet.
Vous devriez trouver :
2 : WU (22.00)
3 : ZUT (22.33)
4 : YUZU (23.25)
5 : TUTUS (20.20)
6 : YOUYOU (20.33)
7 : YOUYOUS (20.14)
8 : SURTOUTS (19.12)
9 : TURLUTUTU (19.33)
10 : VOUSSOYONS (18.40)
11 : YOUYOUTIONS (18.09)
12 : YOUYOUTERONT (17.83)
13 : YOUYOUTERIONS (17.08)
14 : YOUYOUTASSIONS (17.00)
15 : POURSUIVISSIONS (16.33)
Le youyou (petit canot à rames) et ses conjugaisons s’imposent dans presque toutes les longueurs — preuve que Y, U et O sont redoutables à ce jeu-là.
def score(mot):
return sum(ord(c) - 64 for c in mot)
for i in range(2, 16):
with open(f"dic{i}.txt") as f:
mots = [line.strip() for line in f if line.strip()]
solution = max(mots, key=score)
moyenne = score(solution) / i
print(f"{len(solution)} : {solution} ({moyenne:.2f})")Mots écrits avec les n premières lettres de l’alphabet
Nouveau défi : construire des mots en se limitant à un sous-ensemble restreint de l’alphabet. On part des deux premières lettres — A et B — et on en ajoute une à chaque étape jusqu’à la quatorzième. La question est simple : quel est le mot le plus long que l’on peut écrire en n’utilisant que ces lettres-là ?
Avec seulement A et B, on est vite à court d’options : « baba » fait figure de champion avec ses quatre lettres. En ajoutant le C, « cacaba » s’impose avec six lettres. Mais attention — élargir le répertoire ne garantit pas toujours un mot plus long : « cacaba » résiste aussi à l’arrivée du D, et « dédicacée » règne sans partage sur les niveaux 9, 10 et 11.
Les vrais coups de théâtre arrivent plus tard. À 13 lettres disponibles, le lauréat inattendu est « hamamelidacée » — l’hamamélis, cet arbuste aux fleurs d’hiver — avec 13 lettres. Et à 14 lettres, « magdalénienne » lui fait jeu égal.
Vous devriez trouver :
2 (AB) : baba (4)
3 (ABC) : cacaba (6)
4 (ABCD) : cacaba (6)
5 (ABCDE) : abcedee (7)
6 (ABCDEF) : abcedee (7)
7 (ABCDEFG) : affeagee (8)
8 (ABCDEFGH) : debachage (9)
9 (ABCDEFGHI) : acidifiai (9)
10 (ABCDEFGHIJ) : acidifiai (9)
11 (ABCDEFGHIJK) : acidifiai (9)
12 (ABCDEFGHIJKL) : acidifiable (11)
13 (ABCDEFGHIJKLM) : hamamelidacee (13)
14 (ABCDEFGHIJKLMN) : academicienne (13)
def score(mot, n):
lettres_autorisees = set("abcdefghijklmnopqrstuvwxyz"[:n])
return all(c in lettres_autorisees for c in mot.lower())
for n in range(2, 15):
meilleur = ""
for i in range(2, 16):
with open(f"dic{i}.txt") as f:
mots = [line.strip() for line in f if line.strip()]
candidats = [m for m in mots if score(m, n)]
if candidats:
plus_long = max(candidats, key=len)
if len(plus_long) > len(meilleur):
meilleur = plus_long
lettres = "abcdefghijklmnopqrstuvwxyz"[:n].upper()
print(f"{n} ({lettres}) : {meilleur.lower()} ({len(meilleur)})")
Mot avec le moins de lettres différentes, pour chaque longueur
Écrire long en variant peu : c’est le défi de ce nouveau challenge. Pour chaque longueur de mot, on cherche celui qui se contente du plus petit alphabet personnel — autrement dit, celui dont les lettres se répètent le plus.
Avec deux lettres, « AA » n’en utilise qu’une seule. Avec trois, « MMM » fait pareil. Mais à partir de quatre lettres, l’exercice se complique : difficile de faire un vrai mot français avec une seule lettre répétée quatre fois. « ALLA » et « ERRER » s’en tirent avec deux lettres distinctes seulement.
La résistance dure longtemps : il faut atteindre les mots de onze lettres pour qu’une quatrième lettre s’invite enfin dans le palmarès. Et même à quinze lettres, « assassinassions » n’en mobilise que cinq — une économie remarquable pour un mot aussi long.
Vous devriez trouver :
2 : AA (1)
3 : MMM (1)
4 : ALLA (2)
5 : ERRER (2)
6 : ETETEE (2)
7 : AMASSAS (3)
8 : GNANGNAN (3)
9 : BLABLABLA (3)
10 : RESSERREES (3)
11 : ASSAGISSAIS (4)
12 : ASSAINISSAIS (4)
13 : ARRERAGEASSES (5)
14 : EINSTEINIENNES (5)
15 : ASSASSINASSIONS (5)
def score(mot):
return len(set(mot))
for i in range(2, 16):
with open(f"dic{i}.txt") as f:
mots = [line.strip() for line in f if line.strip()]
solution = min(mots, key=score)
print(f"{i} : {solution} ({score(solution)})")