Prend une liste de mots ou un texte en entrée pour construire un arbre/tas optimisé.
  • Rust 34.9%
  • Python 31.9%
  • JavaScript 13.6%
  • C++ 11.1%
  • PHP 8.5%
Find a file
2026-07-11 08:28:38 +02:00
compressor.cpp refactor: path to dico 2026-06-24 21:00:17 +02:00
compressor.js refactor: path to dico 2026-06-24 21:00:17 +02:00
compressor.php feat: increase run versions 2026-06-28 11:48:24 +02:00
compressor.py feat: increase run versions 2026-06-28 11:48:24 +02:00
compressor.rs refactor: path to dico 2026-06-24 21:00:17 +02:00
compressor_deno.js refactor: path to dico 2026-06-24 21:00:17 +02:00
dico_en.txt Ajout dico_en.txt 2020-04-10 07:51:56 +02:00
dico_fr.txt Ajout dico_fr.txt 2020-04-09 09:38:05 +02:00
LICENSE Create license 2020-04-05 22:17:33 +02:00
preformatter_txt.py Create preformatter.py 2020-04-10 08:45:33 +02:00
README.md doc: add rust 1.96 perf 2026-07-11 08:28:38 +02:00
texte.txt Add texte.txt 2020-04-08 15:17:27 +02:00

Compresseur de Dictionnaire de Mots

Aucune dépendance nécessaire.

Prend un fichier texte sans sauts de ligne en entrée pour construire un arbre/tas optimisé. C'est une base simple, mais performante pour un système d'auto complétion ou de suggestion de saisie. Cette version n'étant réalisée qu'à titre ludique, elle n'a pas vocation à être prête à l'emploi en prodution.

Le script indique le nombre de caractères reçus, de mots, et le nombre de noeuds créés. Donnant ainsi une indication sur la compression du texte fourni. Il chronomètre également le temps d'exécution.

La plupart des listes de mots utilisant le saut de ligne comme séparateur, le script preformatter_txt.py converti les sauts de ligne en espaces. Ainsi, les listes sont traités comme un paragraphe de texte lambda.

Le fichier texte.txt est un texte Lorem Ipsum généré par : https://fr.lipsum.com/
Le fichier dico_fr.txt est un fichier reformaté de : http://www.pallier.org/liste-de-mots-francais.html
Le fichier dico_en.txt est un fichier reformaté de : https://github.com/dwyl/english-words

Benchmark PHP vs Python2 vs PyPy vs Python3 vs Node JS vs Deno vs C++ vs Rust:

Ce benchmark a été crée que dans le but d'évaluer grossièrement la différence de performances entre les langages et entre les versions successives de ces langages.
Les codes ont été exécutés sur la même machine (PC portable Ubuntu 18.04, SSD Ext4, i7 8e génération, 8Go ram).
Le fichier dico_en.txt est le fichier texte utilisé pour le benchmark.
Les temps d'exécution fournis sont donnés à titre de comparaison, mais peuvent varier d'une exécution à l'autre, et différer sur un autre système/configuration. Je ne conserve que le meilleur résultat après au moins 10 essais. Enfin, le code n'est probablement pas au mieux adapté/optimisé à chaque langage, et sauf mention explicite le code n'est pas retravaillé pour ne pas travestir les résultats dans le temps.

Le temps d'exécution est en seconde. Les plus performants ont un temps d'exécution plus court (moins c'est mieux).
Les tests sont classés du plus lent au plus rapide et par version croissante.

Version Node JS:

  • v12.16.1 (2019-04)
    • 17.729s (node)
  • v18.20.4 (2022-04)
    • 31.627s (node)
  • v20.19.2 (2023-04)
    • 18.813s (node)

Nuitka:

  • v0.6.14.4 / CPython 3.8.5 (2021-04)
    • 18.282s
    • 14.759s (gc.disable)
  • v4.1.3 / CPython 3.13.5 (2026-05)
    • 17.391s
    • 16.648s (gc.disable)

Version CPython:

  • v2.7.17 (2019-10)
    • 50.187s
    • 45.365s (gc.disable)
  • v3.6.9 (2016-12)
    • 18.504s
    • 15.802s (gc.disable)
  • v3.8.5 (2019-10)
    • 16.889s
    • 13.237s (gc.disable)
  • v3.11.2 (2022-10)
    • 19.696s
    • 18.373s (gc.disable)
  • v3.13.5 (2024-10)
    • 14.560s
    • 13.199s (gc.disable)

Version Deno:

  • v1.0 (2020-05)
    • 11.035s (deno run --unstable --allow-read)
  • v1.8.3 (2021-04)
    • 10.643s (deno run --allow-read)
  • v2.8.3 (2026-06)
    • 9.699s (deno run --allow-read)

Version PyPy:

  • v2.7 (2020-04)
    • 12.602s
  • v3.6 (2020-04)
    • 10.411s
  • v3.11 (2026-05)
    • 6.974s

Version PHP:

  • v7.2.4 (2018-03)
    • 26.722s (php-cli)
    • 10.246s (gc_disable)
  • v7.4.3 (2020-02)
    • 10.053s (php-cli)
    • 8.869s (gc_disable)
  • v8.0.3 (2023-08)
    • 9.670s (php-cli)
    • 8.109s (gc_disable)
  • v8.2.31 (2026-05)
    • 13.982s (php-cli)
    • 11.677s (gc_disable)
  • v8.4.21 (2026-05)
    • 6.681s (php-cli)
    • 5.207s (gc_disable)

Version C++ (g++):

  • v7.5.0 (2019-11)
    • 8.903s (g++ -O)
  • v9.3.0 (2020-03)
    • 7.742s (g++ -O)
  • v12.2.0 (2022-08)
    • 7.725s (g++ -O)
  • v14.2.0 (2024-08)
    • 3.604s (g++ -O)

Version Rust:

  • v1.40 (2019-12)
    • 10.836s (cargo run)
    • 7.881s (cargo build --release)
  • v1.46 (2020-08)
    • 9.568s (cargo run)
    • 6.440s (cargo build --release)
  • v1.63 (2022-08)
    • 13.528s (cargo run)
    • 7.074s (cargo build --release)
  • v1.85 (2025-03)
    • 4.117s (rustc)
    • 3.541s (rustc -O)
  • v1.96.1 (2026-06)
    • 3.869s (rustc)
    • 3.251s (rustc -O)

Je vous laisse juger des performances. Il est important de noter toutefois que ces tests ne sont pas représentatifs de cas d'usage courants.

Attention, la désactivation du GC, peut entrainer des fuites de mémoire