Colisiones de hash esperadas
Reparta 100 claves en 128 cubetas y, de media, más de la mitad de las claves acaban compartiendo cubeta, con un factor de carga de 0,78125. También obtiene claves solas, cubetas vacías y ocupadas, claves sobrantes y colisiones por parejas. Gratis en su navegador.
- Gratis
- Funciona en su navegador
- Sin registro
- Sus datos no salen de su equipo
Ejecutar — gratis
Ejemplo resuelto
- N
- 100
- M
- 128
- Factor de carga
- 0,78125
- Claves en colisión esperadas
- 53,9975057729
- Claves únicas esperadas
- 46,0024942271
- Cubetas ocupadas esperadas
- 69,5768323316
Cuando se dispersan n claves distintas de forma uniforme en m cubetas, algunas comparten hueco incluso con un factor de carga modesto. La intuición subestima la ocupación: se recuerda la probabilidad de la paradoja del cumpleaños de que al menos un par colisione y se trata esa probabilidad como si fuera un recuento. Esta calculadora de colisiones de hash esperadas responde a otra pregunta de planificación. Emplea el modelo clásico de bolas en urnas —cada elemento elige una de m cubetas de modo independiente y uniforme— y devuelve el número esperado de claves en colisión, es decir, las que no están solas en su cubeta. Junto a esa cifra principal informa claves singleton, cubetas ocupadas y vacías, claves de desbordamiento más allá del primer ocupante, colisiones por pares y el factor de carga n dividido por m. La aritmética es una identidad de forma cerrada evaluada en espacio logarítmico, plenamente determinista, sin muestreo Monte Carlo ni modelo de lenguaje. Sirve para dimensionar una tabla hash, ajustar un factor de carga, comparar un espacio de hash de 32 bits con otro más estrecho o comprobar una afirmación de ocupación de manual antes de comprometer memoria.
Qué miden las claves en colisión esperadas en el modelo de bolas en urnas
Lance n bolas de forma independiente y uniforme en m urnas y tendrá el modelo habitual de un hash uniforme. Una clave en colisión es una bola que comparte urna con al menos otra. Esa no es la misma magnitud que la probabilidad de la paradoja del cumpleaños de que al menos dos bolas compartan urna, ni el número de coincidencias por pares.
Para planificar capacidad suele quererse un recuento: cuántas claves, en promedio, no logran un hueco privado, cuántas cubetas quedan vacías mientras otras se desbordan, y cuántas claves extra se apilan sobre el primer ocupante. La linealidad de la esperanza da respuestas limpias sin simulación. Fije una clave cualquiera.
Las otras n menos una fallan la cubeta de esa clave con probabilidad uno menos uno sobre m, de modo que la chance de que la clave elegida sea singleton es (1 − 1/m) elevada a n menos uno. Multiplique por n y tendrá el número esperado de claves singleton. Reste de n y tendrá el número esperado de claves en colisión: n veces uno menos (1 − 1/m) a la n menos uno.
El mismo argumento de ocupación da el número esperado de cubetas vacías, m veces (1 − 1/m) a la n, y por tanto el de cubetas ocupadas. Las claves de desbordamiento son los elementos más allá del primero en cada cubeta ocupada, iguales a n menos ocupadas. Las colisiones por pares equivalen a n sobre dos dividido por m, porque cualquier par concreto cae junto con probabilidad uno sobre m.
El factor de carga es simplemente n sobre m. Juntas, estas cifras indican si una tabla propuesta carece de cubetas, está apenas ocupada o ya paga un recargo de longitud de cadena que un m mayor eliminaría.
Contrato de entrada, fórmulas, estabilidad numérica y errores
Envíe dos enteros obligatorios: n, el número de elementos, y m, el número de cubetas. Ambos valores deben ser enteros finitos dentro de los límites publicados: n de uno a un billón, y m de uno a un billón, lo que cubre ejemplos de aula, mapas en memoria y un espacio de hash de 32 bits completo de cuatro mil doscientos noventa y cuatro millones novecientos sesenta y siete mil doscientos noventa y seis huecos.
Tras la validación el motor evalúa potencias de uno menos uno sobre m en espacio logarítmico como la exponencial del exponente por log1p de menos uno sobre m, de modo que n y m grandes no se desbordan hacia un cero silencioso como haría un bucle ingenuo de multiplicaciones.
Los casos especiales permanecen exactos: un solo elemento nunca colisiona; una sola cubeta con dos o más elementos hace colisionar a todas las claves; un exponente cero se trata como uno para que (1 − 1/m) a la potencia cero no se vuelva un cero a la cero indeterminado. Es un oráculo de recuento esperado bajo un hash uniforme e independiente, no un simulador de una función hash concreta ni una calculadora de probabilidad de colisión.
Planificación de capacidad, límites, precio y dónde rinden las cifras
Utilice la herramienta del navegador cuando elija el tamaño de una tabla, compare factores de carga o explique a un equipo por qué un factor de carga de uno sigue dejando una fracción grande de claves compartiendo cubeta. Incremente m hasta que las claves en colisión esperadas o las de desbordamiento queden bajo su presupuesto de servicio, y reserve un margen de crecimiento.
Contraste el resultado con una probabilidad de la paradoja del cumpleaños si también necesita la chance de que exista alguna colisión; esa probabilidad se satura cerca de uno mucho antes de que el recuento esperado de claves en colisión se vuelva grande, y por eso las dos herramientas responden a tickets distintos. Los resultados son plenamente deterministas: los mismos n y m producen siempre el mismo vector de ocupación, de modo que puede fijar ejemplos en pruebas y materiales didácticos.
No hay modelo de lenguaje, ni servicio externo de estadística, ni aleatoriedad.
Qué puede hacer con ella
Dimensionado de tablas hash y mapas
Tome n igual al número de claves del conjunto de trabajo y recorra m (huecos de la tabla) hasta que las claves en colisión esperadas y las de desbordamiento queden bajo su presupuesto de latencia.
Ocupación de fragmentos y particiones de caché
Trate los fragmentos como cubetas y las claves entrantes como bolas para estimar cuántas claves comparten una partición caliente antes de añadir capacidad o volver a dispersar.
Oráculos deterministas para lecciones y pruebas
Cursos, plataformas de entrevistas y suites de CI invocan un oráculo de ocupación estable que rechaza n o m inferiores a uno y devuelve campos idénticos ante entradas idénticas.
Preguntas frecuentes
¿Qué es una clave en colisión en esta calculadora?
Una clave que no está sola en su cubeta. El recuento esperado es n menos el número esperado de singleton. Es un recuento esperado, no la probabilidad de que al menos un par colisione.
¿En qué se diferencia de la paradoja del cumpleaños?
La paradoja del cumpleaños devuelve P(al menos un día compartido). Esta herramienta devuelve recuentos de ocupación esperados para afinar el hash: claves en colisión, desbordamiento, cubetas vacías y colisiones por pares bajo bolas en urnas.
¿Qué ocurre si n o m es inferior a 1?
Se exige al menos un elemento y al menos una cubeta; el cero y los valores negativos se rechazan y no se cobran.
¿Es gratuita la calculadora de colisiones de hash esperadas?
La herramienta del navegador se ejecuta gratis en su dispositivo.
¿Cuántas cubetas quedan vacías de media?
La cifra esperada es el número de cubetas por la probabilidad de que ninguna clave caiga en una cubeta concreta. Con 100 claves en 128 cubetas, casi la mitad de las cubetas quedan vacías, aunque más de la mitad de las claves comparten sitio.
Herramientas relacionadas
Para desarrolladores — acceso por API
Todo lo de esta página está disponible por programación. Esta sección es para equipos que quieren integrarlo en sus sistemas; el resto puede usar la herramienta de arriba sin más.
Endpoint de API
¿Prefiere automatizarlo? Un POST autenticado crea la tarea; el resultado llega por webhook o enlace firmado. La misma capacidad también se ejecuta aquí en la web, por email y desde Telegram — y pronto también desde nuestra app.
Llámela desde su stack
curl -X POST https://api.kit.forhosting.com/dev/hash-expected-collisions \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"n":100,"m":128}'const res = await fetch("https://api.kit.forhosting.com/dev/hash-expected-collisions", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"n": 100,
"m": 128
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/hash-expected-collisions",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"n": 100,
"m": 128
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/hash-expected-collisions", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"n":100,"m":128}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"n":100,"m":128}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/hash-expected-collisions", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Ejemplo de solicitud
{
"n": 100,
"m": 128
}Ejemplo de respuesta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.hash_expected_collisions",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}La API es asíncrona: la llamada devuelve un task_id al instante y el resultado llega por webhook. El polling está limitado a 1 req/s por tarea.
Precio
Precio publicado — sin tokens ni créditos inventados. Una tarea fallida no se cobra.
Límites
max_n | 1000000000000 |
max_m | 1000000000000 |
Errores
| HTTP | Código | Significado |
|---|---|---|
401 | unauthorized | API key ausente o inválida. |
402 | insufficient_balance | El saldo no cubre el precio de la tarea. |
404 | unknown_type | El tipo de tarea no existe. |
429 | rate_limited | Demasiadas peticiones. Use el webhook en vez de sondear. |
Notas técnicas
Contrato de entrada, fórmulas, estabilidad numérica y errores
Se aceptan los alias items, keys o balls para n, y buckets o bins para m. Campos ausentes, no enteros, n o m inferiores a uno y valores por encima de los máximos fallan con invalid_input y no se cobran. El cuerpo JSON repite n y m, luego devuelve load_factor, expected_colliding_keys, expected_singleton_keys, expected_occupied_buckets, expected_empty_buckets, expected_collision_buckets, expected_overflow_keys, expected_pairwise_collisions y una cadena formula que reescribe las dos identidades principales.
Planificación de capacidad, límites, precio y dónde rinden las cifras
Utilice la API cuando un script, un entorno de entrevistas, un cuaderno de ajuste de bases de datos o una comprobación de integración continua necesite JSON estable para muchos pares (n, m) bajo un mismo contrato. Cada solicitud correcta es un artículo facturable a $0.002; la validación fallida no consume saldo. Los rangos publicados mantienen la evaluación de forma cerrada dentro de dobles IEEE-754 ordinarios y cubren toda tabla hash que se dimensionaría a mano. Conecte el endpoint a tutoriales de tablas hash, planificadores de fragmentos de caché, comprobaciones de ocupación afines a Bloom u oráculos de entrevistas de programación donde prefiera las identidades exactas de bolas en urnas a histogramas de muestreo aproximado que nunca terminan de estabilizarse.
Preguntas técnicas
¿Cómo se estiman las colisiones de hash esperadas para n claves y m cubetas?
Envíe los enteros n (elementos) y m (cubetas) a dev.hash_expected_collisions. La respuesta incluye expected_colliding_keys = n*(1-(1-1/m)^(n-1)), más ocupadas, vacías, desbordamiento, por pares y load_factor.