Verificador de primos aditivos: primo com soma de dígitos
O 23 é primo aditivo: é primo e os seus dígitos somam 5, que também é primo. Digite um inteiro a partir de 2 e veja as duas verificações lado a lado, para saber qual metade falha quando uma não se cumpre. 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
- 23
- Dígitos
- 2, 3
- Soma dos dígitos
- 5
Um primo aditivo é um número primo cujos dígitos decimais também somam um primo. Exemplos clássicos incluem 2, 3, 5, 7, 11, 23, 29, 41, 43, 47, 61, 67, 83, 89 e 101: cada um é primo, e a soma dos dígitos é um primo pequeno como 2, 5, 7, 11 ou 17. Números como 19 e 13 são primos, mas falham no segundo teste porque 1+9=10 e 1+3=4 são compostos.
O que é um primo aditivo e como funciona o teste duplo
Na teoria recreativa dos números, um primo aditivo (às vezes chamado de primo com soma de dígitos prima) é definido por duas condições de primalidade independentes que devem valer ao mesmo tempo. Primeiro, n em si deve ser um número primo: um inteiro maior ou igual a dois cujos únicos divisores positivos são um e ele mesmo. Segundo, se você soma os dígitos decimais de n, essa soma também deve ser prima.
A soma de dígitos é sempre um inteiro não negativo pequeno em relação a n — para qualquer inteiro seguro de JavaScript fica bem abaixo de algumas centenas —, de modo que a segunda verificação de primalidade é barata depois que os dígitos são conhecidos. Os primos de um dígito 2, 3, 5 e 7 são automaticamente primos aditivos porque a soma de dígitos coincide com o número. Exemplos de dois dígitos incluem 11 (1+1=2), 23 (2+3=5) e 29 (2+9=11).
Essa transparência é mais útil do que um simples sim ou não em salas de aula, geradores de quebra-cabeças e auditorias de dados que precisam de um rastro explicativo em vez de uma rejeição silenciosa.
Onde um verificador de primos aditivos se encaixa em fluxos reais
Professores e treinadores de olimpíadas usam um verificador de primos aditivos para conferir listas de lição de casa, gerar contraexemplos que são primos mas não aditivos e mostrar o passo da soma de dígitos ao lado do indicador final. Designers de quebra-cabeças e jogos filtram sementes candidatas para que apenas primos aditivos entrem em uma tabela de níveis, um filtro mais rigoroso do que um simples teste de primalidade e que produz uma sequência distinta que os alunos notam.
Prefira esta capacidade quando a intenção de busca ou a regra de produto for especificamente a condição dupla — não quando você só precisa de primalidade comum (use um verificador is-prime simples), não quando precisa de fatoração completa e não quando só precisa da soma de dígitos sem primalidade de nenhum dos valores.
Casos de uso
Verificação de lição de casa e olimpíadas
Confira listas de primos aditivos dos alunos e mostre qual metade da definição falhou quando um número é primo mas a soma de dígitos é composta.
Filtros de semente e níveis de quebra-cabeça
Aceite apenas primos aditivos como sementes ou IDs de nível para que a sequência seja mais rigorosa e distinta do que primos simples.
Perguntas frequentes
O que é um primo aditivo?
Um número primo cujos dígitos decimais somam um primo. Tanto n quanto a soma de dígitos devem ser primos; falhar em qualquer condição significa que n não é aditivo.
Quais entradas são aceitas?
Inteiros completos n ≥ 2 até o máximo de inteiros seguros.
Por que o 19 não é primo aditivo?
Porque cumpre só metade da definição. O 19 é primo, mas os seus dígitos somam 10, que não é. Tanto o número quanto a soma dos dígitos precisam ser primos.
Quais números são primos aditivos?
Alguns exemplos são 2, 3, 5, 7, 11, 23, 29, 41, 43, 47, 61, 67, 83, 89 e 101. Todos são primos, e a soma dos seus dígitos, como 2, 5, 7, 11 ou 17, também é prima.
O resultado mostra qual condição falhou?
Sim. Além da resposta final, você vê se o número é primo, os seus dígitos, a soma deles e se essa soma é prima, então cada recusa vem com o seu motivo.
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/additive-prime \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"n":23}'const res = await fetch("https://api.kit.forhosting.com/numth/additive-prime", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"n": 23
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/numth/additive-prime",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"n": 23
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/numth/additive-prime", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"n":23}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"n":23}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/numth/additive-prime", 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": 23
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "numth.additive_prime",
"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
Este verificador de primos aditivos aceita um único inteiro n maior ou igual a dois, informa se n é primo, lista os dígitos e a soma, diz se essa soma é prima e devolve o indicador claro is_additive_prime. A mesma aritmética pura roda grátis no navegador e na API, de modo que checagens de lição de casa e automação nunca discordam em um caso limite.
O que é um primo aditivo e como funciona o teste duplo
Contraexemplos fixam a definição: 19 é primo, mas 1+9=10 é par e maior que dois, logo 19 não é aditivo; 4 é composto e falha independentemente dos dígitos; 1 não é primo e esta API não o aceita. O endpoint sempre devolve ambos os indicadores intermediários (is_prime e digit_sum_is_prime) mais o array digits e digit_sum, para que você possa ensinar ou registrar exatamente qual metade da definição falhou quando is_additive_prime é false.
Contrato de entrada, campos de resposta e erros
O limite superior é o máximo de inteiros seguros de JavaScript, para que cada resultado permaneça exato na aritmética Number comum. Exemplo: n igual a 1 ou n igual a 0 falha com mensagem de que n deve ser maior ou igual a dois. Envie um corpo JSON com um único campo obrigatório n: um inteiro completo maior ou igual a dois, aceito como número JSON ou como string de dígitos decimais com sinal de mais opcional à esquerda. Frações, booleanos, strings vazias, notação científica, zeros à esquerda em strings de vários dígitos e valores abaixo de dois são rejeitados com invalid_input antes de qualquer trabalho de primalidade. Em caso de sucesso a resposta ecoa n, define is_prime após divisão por tentativa determinística com roda de seis passos, lista os dígitos do mais para o menos significativo, informa digit_sum como a soma simples desses dígitos, define digit_sum_is_prime com a mesma rotina de primalidade e, por fim, define is_additive_prime como o e lógico dos dois indicadores. Exemplo: n igual a 23 produz digits [2, 3], digit_sum 5, ambos os indicadores true e is_additive_prime true. Exemplo: n igual a 19 produz is_prime true, digit_sum 10, digit_sum_is_prime false e is_additive_prime false. Pedidos inválidos não são cobrados; chamadas bem-sucedidas usam o preço base publicado US$ 0,002 no caminho da API.
Onde um verificador de primos aditivos se encaixa em fluxos reais
Engenheiros de dados às vezes marcam colunas de identificadores que devem seguir restrições de números recreativos; executar este endpoint em um lote captura linhas com forma prima que falham na condição de soma de dígitos, e o digit_sum devolvido explica o motivo. Mantenha n como inteiro de pelo menos dois, trate invalid_input como correção do cliente e não como nova tentativa, armazene os indicadores intermediários se precisar de auditoria e você terá decisões reproduzíveis de primos aditivos para plugins LMS, notebooks e workers de borda sem montar um sistema de álgebra computacional.
Casos de integração
Auditoria de colunas de números recreativos
Varra identificadores importados alegados como primos aditivos; marque falhas e anexe digit_sum e ambos os indicadores ao log de auditoria.
Perguntas técnicas
O que a resposta inclui?
n, is_prime, digits, digit_sum, digit_sum_is_prime e is_additive_prime (true somente quando ambos os indicadores de primalidade são true).
19 é um primo aditivo?
Não. 19 é primo, mas 1+9=10 é composto, então is_additive_prime é false enquanto is_prime permanece true.
Quanto custa o verificador de primos aditivos?
A ferramenta do navegador é gratuita. Pedidos API usam saldo pré-pago do KIT a US$ 0,002 por chamada bem-sucedida; entrada inválida não é cobrada.