Colisões de hash esperadas
Espalhe 100 chaves em 128 baldes e, em média, mais da metade das chaves acaba dividindo um balde, com fator de carga de 0,78125. Você também recebe chaves sozinhas, baldes vazios e ocupados, chaves excedentes e colisões por par. Grátis no seu navegador.
- Grátis
- Funciona no seu navegador
- Sem cadastro
- Seus dados não saem do seu aparelho
Executar grátis
Exemplo resolvido
- N
- 100
- M
- 128
- Fator de carga
- 0,78125
- Chaves em colisão esperadas
- 53,9975057729
- Chaves únicas esperadas
- 46,0024942271
- Buckets ocupados esperados
- 69,5768323316
Quando n chaves distintas são dispersas de modo uniforme em m baldes, algumas compartilham vaga mesmo com um fator de carga modesto. A intuição subestima a ocupação: as pessoas lembram a probabilidade do paradoxo do aniversário de que pelo menos um par colida e tratam essa probabilidade como se fosse uma contagem. Esta calculadora de colisões de hash esperadas responde a outra pergunta de planejamento. Usa o modelo clássico de bolas em urnas — cada item escolhe um dos m baldes de forma independente e uniforme — e devolve o número esperado de chaves em colisão, ou seja, as que não estão sozinhas no próprio balde. Ao lado dessa cifra principal informa chaves singleton, baldes ocupados e vazios, chaves de transbordo além do primeiro ocupante, colisões aos pares e o fator de carga n dividido por m. A aritmética é uma identidade de forma fechada avaliada em espaço logarítmico, totalmente determinística, sem amostragem Monte Carlo e sem modelo de linguagem. Serve para dimensionar uma tabela hash, ajustar um fator de carga, comparar um espaço de hash de 32 bits com outro mais estreito ou conferir uma afirmação de ocupação de livro antes de comprometer memória.
O que as chaves em colisão esperadas medem no modelo de bolas em urnas
Lance n bolas de forma independente e uniforme em m urnas e você terá o modelo padrão de um hash uniforme. Uma chave em colisão é uma bola que compartilha urna com pelo menos outra. Isso não é a mesma grandeza que a probabilidade do paradoxo do aniversário de que pelo menos duas bolas compartilhem urna, nem o número de coincidências aos pares.
No planejamento de capacidade costuma-se querer uma contagem: quantas chaves, em média, não conseguem uma vaga privativa, quantos baldes ficam vazios enquanto outros transbordam, e quantas chaves extras se empilham sobre o primeiro ocupante. A linearidade da esperança dá respostas limpas sem simulação. Fixe uma chave qualquer.
As outras n menos uma erram o balde dessa chave com probabilidade um menos um sobre m, de modo que a chance de a chave escolhida ser singleton é (1 − 1/m) elevada a n menos um. Multiplique por n e você terá o número esperado de chaves singleton. Subtraia de n e você terá o número esperado de chaves em colisão: n vezes um menos (1 − 1/m) na n menos um.
O mesmo argumento de ocupação produz o número esperado de baldes vazios, m vezes (1 − 1/m) na n, e portanto o de baldes ocupados. As chaves de transbordo são os itens além do primeiro em cada balde ocupado, iguais a n menos ocupados. As colisões aos pares equivalem a n escolhe dois dividido por m, porque qualquer par específico cai junto com probabilidade um sobre m.
O fator de carga é simplesmente n sobre m. Juntas, essas cifras dizem se uma tabela proposta está faminta de baldes, apenas ocupada ou já paga um imposto de comprimento de cadeia que um m maior removeria.
Contrato de entrada, fórmulas, estabilidade numérica e erros
Envie dois inteiros obrigatórios: n, o número de itens, e m, o número de baldes. Ambos os valores devem ser inteiros finitos dentro dos limites publicados: n de um a um trilhão, e m de um a um trilhão, o que cobre exemplos de sala, mapas em memória e um espaço de hash de 32 bits completo de quatro bilhões duzentos e noventa e quatro milhões novecentos e sessenta e sete mil duzentos e noventa e seis vagas.
Após a validação o motor avalia potências de um menos um sobre m em espaço logarítmico como a exponencial do expoente vezes log1p de menos um sobre m, para que n e m grandes não sofram underflow até um zero silencioso como faria um laço ingênuo de multiplicações.
Os casos especiais permanecem exatos: um único item nunca colide; um único balde com dois ou mais itens faz todas as chaves colidirem; um expoente zero é tratado como um para que (1 − 1/m) na potência zero não se torne um zero elevado a zero indeterminado. Este é um oráculo de contagem esperada sob um hash uniforme e independente, não um simulador de uma função hash particular nem uma calculadora de probabilidade de colisão.
Planejamento de capacidade, limites, preço e onde os números valem
Use a ferramenta do navegador quando for escolher o tamanho de uma tabela, comparar fatores de carga ou explicar a uma equipe por que um fator de carga igual a um ainda deixa uma fração grande de chaves compartilhando balde. Aumente m até que as chaves em colisão esperadas ou as de transbordo fiquem abaixo do orçamento de nível de serviço, e reserve uma folga para o crescimento.
Contraste o resultado com uma probabilidade do paradoxo do aniversário se também precisar da chance de existir alguma colisão; essa probabilidade satura perto de um bem antes de a contagem esperada de chaves em colisão ficar grande, por isso as duas ferramentas respondem a chamados diferentes. Os resultados são totalmente determinísticos: os mesmos n e m sempre produzem o mesmo vetor de ocupação, de modo que você pode fixar exemplos em testes e materiais didáticos. Não há modelo de linguagem, serviço externo de estatística nem aleatoriedade.
Casos de uso
Dimensionamento de tabelas hash e mapas
Tome n igual à quantidade de chaves do conjunto de trabalho e percorra m (vagas da tabela) até que as chaves em colisão esperadas e as de transbordo fiquem abaixo do orçamento de latência.
Ocupação de fatias e partições de cache
Trate as fatias como baldes e as chaves que chegam como bolas para estimar quantas chaves compartilham uma partição quente antes de acrescentar capacidade ou redispersar.
Oráculos determinísticos para aulas e testes
Cursos, plataformas de entrevistas e suítes de CI chamam um oráculo de ocupação estável que rejeita n ou m abaixo de um e devolve campos idênticos para entradas idênticas.
Perguntas frequentes
O que é uma chave em colisão nesta calculadora?
Uma chave que não está sozinha no próprio balde. A contagem esperada é n menos o número esperado de singletons. É uma contagem esperada, não a probabilidade de que pelo menos um par colida.
Em que isso difere do paradoxo do aniversário?
O paradoxo do aniversário devolve P(pelo menos um dia compartilhado). Esta ferramenta devolve contagens de ocupação esperadas para afinar o hash: chaves em colisão, transbordo, baldes vazios e colisões aos pares no modelo de bolas em urnas.
O que acontece se n ou m for menor que 1?
Exige-se pelo menos um item e pelo menos um balde; zero e valores negativos são rejeitados e não cobrados.
A calculadora de colisões de hash esperadas é gratuita?
A ferramenta do navegador roda grátis no seu dispositivo.
Quantos baldes ficam vazios em média?
O valor esperado é o número de baldes vezes a chance de nenhuma chave cair em um balde específico. Com 100 chaves em 128 baldes, quase metade dos baldes fica vazia, mesmo com mais da metade das chaves dividindo espaço.
Ferramentas relacionadas
Para desenvolvedores — acesso via API
Tudo nesta página está disponível via API. Esta seção é para equipes que querem integrar a ferramenta aos próprios sistemas; quem não precisa disso pode simplesmente usar a ferramenta acima.
Endpoint
Autenticação por token Bearer. Um único POST coloca a tarefa na fila; o resultado chega por webhook ou link assinado.
Chame do seu código
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)Exemplo de requisição
{
"n": 100,
"m": 128
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.hash_expected_collisions",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}A API é assíncrona: cada chamada devolve um task_id na hora. Se preferir polling, consulte o status a até 1 requisição por segundo.
Preço
Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.
Limites
max_n | 1000000000000 |
max_m | 1000000000000 |
Erros
| HTTP | Código | O que significa |
|---|---|---|
401 | unauthorized | Token ausente ou inválido. Confira o header Authorization. |
402 | insufficient_balance | Saldo insuficiente para esta tarefa. Faça uma recarga e tente de novo. |
404 | unknown_type | Esse tipo de tarefa não existe. Confira o campo type no catálogo. |
429 | rate_limited | Muitas requisições em pouco tempo. Espere um instante e tente de novo. |
Notas técnicas
Contrato de entrada, fórmulas, estabilidade numérica e erros
São aceitos os aliases items, keys ou balls para n, e buckets ou bins para m. Campos ausentes, não inteiros, n ou m abaixo de um e valores acima dos máximos falham com invalid_input e não são cobrados. O corpo JSON ecoa n e m, depois devolve load_factor, expected_colliding_keys, expected_singleton_keys, expected_occupied_buckets, expected_empty_buckets, expected_collision_buckets, expected_overflow_keys, expected_pairwise_collisions e uma string formula que reescreve as duas identidades principais.
Planejamento de capacidade, limites, preço e onde os números valem
Use a API quando um script, um sandbox de entrevistas, um caderno de ajuste de banco ou uma verificação de integração contínua precisar de JSON estável para muitos pares (n, m) sob o mesmo contrato. Cada requisição bem-sucedida é um item faturável a US$ 0,002; a validação com falha não consome saldo. Os intervalos publicados mantêm a avaliação de forma fechada dentro de doubles IEEE-754 ordinários e cobrem toda tabela hash que se dimensionaria à mão. Conecte o endpoint a tutoriais de tabelas hash, planejadores de fatias de cache, checagens de ocupação próximas a Bloom ou oráculos de entrevistas de programação em que você prefira as identidades exatas de bolas em urnas a histogramas de amostragem aproximada que nunca terminam de estabilizar.
Perguntas técnicas
Como estimar as colisões de hash esperadas para n chaves e m baldes?
Envie os inteiros n (itens) e m (baldes) a dev.hash_expected_collisions. A resposta inclui expected_colliding_keys = n*(1-(1-1/m)^(n-1)), além de ocupados, vazios, transbordo, aos pares e load_factor.