Contagem de fatores primos com multiplicidade
Conta cada fator primo de n, repetições incluídas: 12 é 2 × 2 × 3, então Ω(12) vale 3, enquanto seus primos distintos ω(12) são só 2. Você também vê as potências de primos, para conferir que os expoentes somam o valor indicado. 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
- 12
- Ômega maiúsculo
- 3
- Ômega maiúsculo
- 3
- Ômega minúsculo
- 2
O ômega grande Ω(n) conta cada fator primo de um inteiro positivo n com multiplicidade: se doze se fatora como dois ao quadrado vezes três, então Ω(12) vale três porque os primos são dois, dois e três. Esta calculadora devolve esse total após uma fatoração determinística por divisão de teste, além das potências primas ordenadas e do ômega pequeno ω(n) para comparação. Estudantes, programadores de competição e autores de pipelines usam Ω(n) quando precisam do comprimento do multiconjunto de fatores primos, e não da lista de divisores ou de uma página só de fatoração.
Ômega grande versus ômega pequeno e a fatoração
A teoria dos números distingue duas contagens intimamente relacionadas. O ômega pequeno ω(n) é o número de fatores primos distintos: o tamanho do suporte da fatoração prima. O ômega grande Ω(n) é o total de fatores primos contados com multiplicidade: a soma dos expoentes nessa mesma fatoração.
Para um produto livre de quadrados de k primos distintos, as duas funções coincidem e valem k. Para uma potência de primo p elevada a e, o ômega pequeno é um enquanto o ômega grande é e. Para um, ambos são zero pelas convenções de produto vazio e soma vazia.
Quem busca o tamanho do multiconjunto costuma digitar frases como contagem de fatores primos com multiplicidade ou ômega grande de n; essa intenção difere de pedir uma tabela completa de fatoração ou só a contagem de primos distintos. Esta capacidade foi feita para essa pergunta de comprimento do multiconjunto. Ainda assim devolve a fatoração para que você possa verificar que a soma dos expoentes iguala o Ω(n) informado, e devolve o ômega pequeno para comparações lado a lado sem uma segunda ferramenta.
O algoritmo é o clássico dos cursos elementares de teoria dos números: fatorar por divisão de teste e somar os expoentes.
Onde contagens com multiplicidade aparecem no trabalho real
Problemas de competição frequentemente pedem o total de fatores primos no sentido de multiconjunto ao analisar a função ômega prima, buscas de números altamente compostos ou as propriedades aditivas de Ω sob a multiplicação de argumentos coprimos. Professores atribuem exercícios que contrastam Ω e ω na mesma lista de inteiros e precisam de um oráculo determinístico que mostre as potências primas intermediárias. Lições de criptografia e teoria de códigos às vezes usam a soma total de expoentes como medida de complexidade de fatorações em módulos de brinquedo.
Como o motor é código parse puro, sem deriva de modelo, sem dependência de rede e sem estado armazenado, o mesmo n sempre produz a mesma resposta. Use a ferramenta gratuita do navegador para checagens rápidas e depois chame o contrato idêntico a partir de scripts quando precisar de verificação em massa.
Se mais tarde precisar da lista completa de divisores, da contagem de divisores τ(n) ou de uma página só de fatoração com outro enquadramento SEO, trate-as como intenções de busca separadas em vez de sobrecarregar esta página centrada na multiplicidade.
Casos de uso
Checagens de lição de casa e olimpíadas
Verifique Ω(n) em folhas que pedem o número de fatores primos contados com multiplicidade, com as potências primas visíveis para inspecionar a soma dos expoentes.
Contraste com o ômega pequeno
Devolve ômega grande e ômega pequeno na mesma fatoração para que estudantes e pipelines comparem comprimento do multiconjunto versus primos distintos sem uma segunda chamada.
Perguntas frequentes
O que é o ômega grande Ω(n)?
Ω(n) é o número de fatores primos de n contados com multiplicidade. Se n = p1^e1 × … × pk^ek, então Ω(n) = e1 + … + ek. Por exemplo Ω(12) = Ω(2²×3) = 3.
Como Ω(n) difere do ômega pequeno ω(n)?
O ômega pequeno ω(n) conta primos distintos (k na fatoração acima). O ômega grande soma os expoentes. Em n livres de quadrados coincidem; em potências de primo divergem.
Por que Ω(1) é igual a 0?
Por convenção a fatoração prima vazia tem soma vazia de expoentes, logo Ω(1) e ω(1) são zero.
Quanto custa calcular o ômega grande Ω(n)?
Nesta página o big omega roda grátis no seu navegador.
Quanto vale Ω(n) para uma potência de primo?
Para um primo p elevado a e, Ω vale e, porque o mesmo primo é contado e vezes, enquanto ω vale 1. Um primo sozinho, portanto, dá 1 nas duas contagens.
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/numth/prime-factor-multiplicity \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"n":12}'const res = await fetch("https://api.kit.forhosting.com/numth/prime-factor-multiplicity", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"n": 12
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/numth/prime-factor-multiplicity",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"n": 12
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/numth/prime-factor-multiplicity", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"n":12}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"n":12}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/numth/prime-factor-multiplicity", 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": 12
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "numth.prime_factor_multiplicity",
"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.
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
Você envia um inteiro positivo; valores inválidos abaixo de um falham de imediato com invalid_input e não são cobrados.
O que você envia e o que a resposta contém
Forneça um inteiro positivo n. Os aliases number e value são aceitos para widgets de formulário e SDKs que preferem um nome de campo mais amigável. Valores abaixo de um, não inteiros, campos vazios e números maiores que o máximo de inteiros seguros do JavaScript são rejeitados com invalid_input e não consomem saldo pré-pago. Em caso de sucesso o JSON inclui n normalizado, big_omega (e o alias omega_big com o mesmo valor), little_omega como contagem de primos distintos, factorization como array ascendente de objetos de primo e expoente, e uma string curta formula que documenta a identidade usada. Verificações resolvidas: doze produz big_omega três e little_omega dois porque dois ao quadrado vezes três contribui com três fatores primos com multiplicidade e dois primos distintos; um primo p produz um e um; uma potência p à k produz k e um; n igual a um produz zero e zero com fatoração vazia. O preço dos itens API bem-sucedidos é a base publicada de US$ 0,002.
Onde contagens com multiplicidade aparecem no trabalho real
Pipelines de dados e CI preferem um contrato JSON estável a uma coluna de planilha que alguém recalcula à mão.
Casos de integração
Fixtures determinísticas de pipeline
Chame o mesmo contrato puro a partir de scripts e CI para que os valores golden de Ω(n) nunca dependam de um formulário web casual nem de uma planilha instável.
Perguntas técnicas
Quais valores de n são aceitos?
Inteiros de 1 até 9007199254740991 (Number.MAX_SAFE_INTEGER). Zero, negativos, decimais e strings não numéricas falham com invalid_input e não são cobrados.