Cases d'une table de hachage
Prévoyez 1 000 clés avec un facteur de charge de 0,75 et il vous faut au moins 1 334 cases, arrondies à 2 048 en puissance de deux. Vous voyez aussi la charge réelle, le nombre de clés qui tiennent et la marge restante. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Éléments
- 1 000
- Facteur de charge
- 0,75
- Arrondi
- Power of two
- Minimum de seaux
- 1 334
- Seaux
- 2 048
- Facteur de charge réel
- 0,48828125
- Capacité
- 1 536
Une table de hachage n'est rapide que si le tableau qui la sous-tend est bien dimensionné. Lorsque vous stockez n clés dans m cases, le facteur de charge α = n / m décide de la longueur des chaînes, du moment où l'adressage ouvert s'agglutine et de la fréquence d'un redimensionnement. Un m trop petit et chaque recherche parcourt un tas de collisions. Un m trop grand et vous payez de la RAM pour des emplacements vides qui n'améliorent pas la latence. Ce calculateur de nombre de cases prend le nombre d'éléments prévu, un facteur de charge cible tel que la valeur par défaut 0.75 de Java HashMap, et une stratégie d'arrondi, puis renvoie la plus petite table que l'on puisse allouer tout en maintenant l'occupation à cette cible ou en dessous. Il calcule d'abord le plafond brut ceil(n / α), puis arrondit ce plancher à la puissance de deux suivante ou au nombre premier suivant — les deux tailles que les maps de production allouent réellement. Les tailles puissance de deux correspondent aux maps à masque qui indexent avec le ET bit à bit du hachage et (m moins un). Les tailles premières correspondent aux maps à modulo qui indexent avec hash mod m.
Pourquoi le facteur de charge, et non un chiffre rond, doit choisir les cases
Le facteur de charge est le seul nombre d'occupation qui voyage d'un langage à l'autre. Java HashMap vaut 0.75 par défaut et se redimensionne lorsque la taille dépasse la capacité multipliée par ce facteur. Rust hashbrown et de nombreux ports Swiss-table se tiennent près de 0.875 avant de grandir.
Le code pédagogique classique à chaînage séparé vise souvent 0.5 ou 1.0. Dans tous les cas l'identité de planification est la même : il faut au moins ceil(n / α) emplacements si n clés doivent rester à la cible α ou en dessous. Ce plafond brut n'est presque jamais le nombre que l'on alloue.
Les implémentations à masque exigent que m soit une puissance de deux pour que l'index soit un seul ET bit à bit, d'où 1 000 clés à 0.75 deviennent 2 048 cases et non 1 334. Les implémentations à modulo préfèrent un premier afin qu'un hachage faible se répartisse encore entre classes de résidus, d'où les mêmes 1 000 clés deviennent le premier suivant supérieur ou égal à 1 334. Servez-vous de ces cinq chiffres ensemble.
Une table qui a beaucoup monté jusqu'à la puissance de deux suivante a une charge effective confortable et un headroom large ; une table tombée sur un premier voisin est plus serrée et plus proche d'un redimensionnement. Deviner 1 024 ou 4 096 parce que ces nombres ont l'air d'informatique, c'est ainsi qu'un service gaspille une page de RAM ou déclenche un redimensionnement dès la première minute de trafic.
Quand dimensionner ainsi une table, et ses limites
Servez-vous de l'outil du navigateur lorsque vous choisissez la capacité initiale d'un HashMap, rédigez un commentaire qui doit justifier pourquoi le tableau fait 2 048 et non 1 334, ou parcourez en revue la différence entre une table à masque et une table à modulo. Balayez le facteur de charge jusqu'à ce que le headroom couvre le prochain pic de croissance, puis conservez le m arrondi.
Contrastez le résultat avec un calculateur de collisions attendues une fois m connu : ce frère répond combien de clés partagent une case, tandis que cette page répond combien de cases allouer d'abord. Les deux recherches sont des tickets distincts et ne doivent pas se cannibaliser. Les résultats sont pleinement déterministes : les mêmes items, facteur de charge et arrondi produisent toujours le même vecteur, de sorte que vous pouvez figer des exemples dans les tests et le matériel pédagogique.
Il n'y a ni modèle de langage, ni service statistique externe, ni aléa. Branchez le point de terminaison sur des tutoriels de tables de hachage, des backends de compilateur qui émettent une table statique, et des modèles de service qui doivent choisir une capacité avant la première insertion.
Cas d’usage
Capacité initiale d'un HashMap et d'un dictionnaire
Indiquez la taille prévue de l'ensemble de travail et 0.75 (ou la valeur par défaut de votre exécution) pour obtenir le tableau puissance de deux que Java, Rust et la plupart des maps à masque doivent allouer.
Tables à modulo de taille première
Dimensionnez les maps classiques à chaînage séparé ou de style Hashtable qui indexent avec hash modulo m en arrondissant le plancher d'occupation au premier suivant.
Générateurs, revues et oracles de CI
Les générateurs de code et les plateformes d'entretien appellent un oracle de dimensionnement déterministe qui refuse un nombre d'éléments manquant et renvoie le même champ buckets pour les mêmes n et α.
Questions fréquentes
Faut-il arrondir le nombre de cases à une puissance de deux ou à un premier ?
Utilisez prime pour les maps à modulo telles que le Hashtable classique de Java, afin qu'un hachage faible se répartisse encore entre classes de résidus.
Que se passe-t-il si items manque ou si le facteur de charge est hors plage ?
Les échecs de validation ne sont pas facturés.
Le calculateur de cases de table de hachage est-il gratuit ?
L'outil du navigateur s'exécute gratuitement sur votre appareil.
Quel facteur de charge choisir ?
Cela dépend de la table utilisée. Le HashMap de Java vaut 0,75 par défaut, de nombreuses tables de type Swiss table, comme hashbrown en Rust, tournent autour de 0,875, et le code pédagogique vise souvent 0,5 ou 1,0. Alignez la cible sur la table qui recevra les données.
Que signifient la capacité et la marge ?
La capacité est le nombre de clés que la table arrondie accepte avant de dépasser la charge cible ; la marge est la capacité moins vos clés. Pour 1 000 clés à 0,75 dans 2 048 cases, la capacité est de 1 536 et la marge de 536.
Outils associés
Pour les développeurs — accès API
Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.
Endpoint
Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.
Appeler depuis votre stack
curl -X POST https://api.kit.forhosting.com/dev/hash-table-capacity \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"items":1000,"load_factor":0.75}'const res = await fetch("https://api.kit.forhosting.com/dev/hash-table-capacity", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"items": 1000,
"load_factor": 0.75
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/hash-table-capacity",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"items": 1000,
"load_factor": 0.75
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/hash-table-capacity", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"items":1000,"load_factor":0.75}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"items":1000,"load_factor":0.75}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/hash-table-capacity", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemple de requête
{
"items": 1000,
"load_factor": 0.75
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.hash_table_capacity",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.
Tarifs
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Limites
max_items | 1000000000 |
min_load_factor | 0.05 |
max_load_factor | 1 |
max_buckets | 34359738368 |
Erreurs
| HTTP | Code | Signification |
|---|---|---|
401 | unauthorized | Clé API absente ou invalide : vérifiez l’en-tête Authorization. |
402 | insufficient_balance | Solde insuffisant : rechargez votre compte pour lancer cette tâche. |
404 | unknown_type | Type de tâche inconnu : vérifiez le champ type de votre requête. |
429 | rate_limited | Trop de requêtes : ralentissez la cadence, puis réessayez. |
Notes techniques
Pourquoi le facteur de charge, et non un chiffre rond, doit choisir les cases
Ce calculateur rend explicite cette décision en deux temps : il rapporte min_buckets (le plancher d'occupation), buckets (l'allocation arrondie), actual_load_factor (n / m, toujours à la cible ou en dessous après arrondi), capacity (combien de clés tiennent avant de franchir la cible) et headroom (capacity moins n).
Contrat d'entrée, modes d'arrondi, formules et erreurs
Les puissances de deux se trouvent par doublement, non par astuces 32 bits, afin que les tailles au-delà de deux à la trente-et-un restent des entiers sûrs exacts. Les premiers se trouvent par division d'essai sur les candidats impairs. C'est un oracle de dimensionnement, non un dénombrement de collisions attendues : couplez-le à un outil d'occupation boules et urnes si vous avez aussi besoin de savoir combien de clés partageront un emplacement une fois m choisi. Envoyez par POST un corps JSON avec deux champs obligatoires et un facultatif. items est le nombre de clés prévu, un entier de un à un milliard ; les alias n, count, expected et keys sont acceptés. load_factor est la α cible, un nombre fini de 0.05 à 1 inclus ; les alias load et alpha sont acceptés. 0.75 est l'exemple et la valeur par défaut de Java ; 1.0 est une table pleine ; les valeurs sous 0.05 sont rejetées car elles décrivent un tableau presque vide plutôt qu'une map de travail. rounding est une énumération, power_of_two ou prime, valant power_of_two si omis ; les alias mode et strategy sont acceptés. Un domaine fini appartient à l'énumération pour que le formulaire affiche une liste et que l'API refuse les graphies inventées. Après validation le moteur calcule min_buckets = ceil(items / load_factor), corrige une seule étape flottante si le produit resterait sous n, puis fixe buckets à la puissance de deux suivante ou au premier suivant supérieur ou égal à ce plancher. Le JSON répète items, load_factor et rounding, puis renvoie min_buckets, buckets, actual_load_factor, capacity, headroom, is_power_of_two, is_prime, un champ bits uniquement sur le chemin puissance de deux (logarithme en base deux de m), et une chaîne formula. Un items manquant, un facteur de charge hors plage publiée, un nombre d'éléments non entier ou un arrondi inconnu échouent avec invalid_input en nommant le champ et ne sont pas facturés.
Où une API de nombre de cases gagne sa place, limites et tarif
Servez-vous de l'API lorsqu'un générateur de code, un bac à sable d'entretien, un planificateur de fragments de cache ou un contrôle d'intégration continue a besoin d'un JSON stable pour de nombreux couples (n, α) sous un même contrat. Chaque requête réussie est un article facturable à $0.002 ; une validation échouée ne consomme pas le solde. Les plages publiées gardent chaque dénombrement renvoyé dans les entiers sûrs IEEE-754 ordinaires et couvrent toute map en mémoire que vous dimensionneriez à la main, d'un exemple de cours à huit clés jusqu'à une table d'internement d'un milliard d'entrées.
Questions techniques
Comment choisir le nombre de cases d'une table de hachage à partir de n éléments et d'un facteur de charge ?
Envoyez items (ou n) et load_factor (par exemple 0.75). Le calculateur renvoie min_buckets = ceil(n/α) et buckets arrondi à la puissance de deux suivante ou au premier suivant, plus la charge effective, capacity et headroom.
Quelle est la différence entre min_buckets et buckets ?
min_buckets est le plancher d'occupation ceil(items / load_factor). buckets est ce plancher arrondi à une taille que l'on peut allouer. Ainsi actual_load_factor = items / buckets demeure à la cible ou en dessous.