Calculadora de inteiros grandes
9223372036854775807 mais 1 dá exatamente 9223372036854775808, uma soma que estoura um inteiro de 64 bits com sinal, mas aqui é mantida dígito a dígito. Some dois inteiros de qualquer tamanho, sem arredondar nem dar a volta, e saiba se o resultado cabe em 64 bits. 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
- Primeiro texto
- 9223372036854775807
- Segundo texto
- 1
- Sum
- 9223372036854775808
- Quantidade de dígitos
- 19
- Sinal
- positive
Inteiros nativos de sessenta e quatro bits deixam de ser exatos no instante em que uma soma atravessa o intervalo representável. Números JavaScript perdem identidade inteira além de nove quatrilhões, valores long com sinal dão a volta ou disparam ao chegar a nove quintilhões, e registradores sem sinal não conseguem guardar dois elevado a sessenta e quatro. Esta calculadora de adição de inteiros grandes aceita dois inteiros decimais de qualquer comprimento, soma-os com aritmética escolar de vai-um e devolve a soma decimal exata como cadeia — sem arredondamento, sem wrapping e sem notação científica. Some o máximo com sinal de sessenta e quatro bits mais um e você recebe 9223372036854775808; some dois totais de livro com cem dígitos e cada algarismo é conservado. Validação recusada não é cobrada.
Por que a adição nativa falha e como o vai-um escolar permanece exato
Todo tipo inteiro nativo comum tem um teto rígido. Uma palavra com sinal de sessenta e quatro bits chega no máximo a 9223372036854775807; somar um ou envolve para um negativo grande, ou satura, ou declara overflow. Uma calculadora de adição de inteiros grandes existe para recusar esse acordo.
Cada operando é lido como cadeia de dígitos decimais com sinal, zeros à esquerda são removidos e as duas magnitudes são somadas a partir do dígito menos significativo com um vai-um de zero ou um, exatamente como no papel. Quando os sinais diferem, a magnitude menor é subtraída da maior e o sinal da maior é mantido; magnitudes opostas iguais se cancelam para zero. O resultado é escrito de volta como cadeia decimal canônica com no máximo um menos inicial e sem sinal de mais.
Como cada passo é uma operação finita de dígitos, a soma é exata para qualquer comprimento até o limite de dígitos publicado. Esse é o algoritmo inteiro: sem ponto flutuante, sem redução modular e sem modo de arredondamento.
A capacidade também informa quantos dígitos o valor absoluto da soma ocupa, se a soma é positiva, negativa ou zero, e se fica fora do intervalo com sinal de sessenta e quatro bits, para que quem ainda precise falar com um sistema de largura fixa saiba quando deve conservar a forma de cadeia.
Casos de uso
Totais de livro e de fatura além de sessenta e quatro bits
Some dois valores de dinheiro, imposto ou subunidade que já estouram um long com sinal ou uma célula de planilha, e conserve o total decimal exato como cadeia.
Oráculos de overflow para avaliadores e entrevistas
Confronte somadores de alunos ou candidatos com uma soma escolar determinística, inclusive uma cadeia de noves mais um e o overflow com sinal de sessenta e quatro bits.
Checagens de migração antes de alargar colunas inteiras
Compare um SUM de banco de dados com este total exato para ver se uma coluna ainda cabe em int64 ou precisa virar tipo decimal ou numeric.
Perguntas frequentes
Como somar dois inteiros que estouram um tipo de sessenta e quatro bits?
Envie a e b como cadeias de dígitos decimais (sinal inicial opcional).
A calculadora envolve ou satura no overflow?
Não. A soma é ilimitada dentro do limite de dígitos publicado. Não há wrapping nem clamp. Para adição saturada de largura fixa, use em vez disso uma ferramenta dedicada de inteiros saturados.
Posso somar um número negativo com um positivo?
Sim. Escreva o sinal de menos antes do valor negativo. Quando os sinais são diferentes, a magnitude menor é subtraída da maior e o sinal da maior é mantido; valores iguais e opostos dão zero.
Quantos dígitos cada número pode ter?
Até 10.000 dígitos cada, contados depois de remover os zeros à esquerda. Digite só algarismos, com sinal de mais ou de menos opcional: separadores de milhar, espaços, decimais, prefixos hexadecimais e notação científica são recusados.
Por que a planilha erra somas muito grandes?
Muitas células guardam números em ponto flutuante, que não representa todos os inteiros acima de 9.007.199.254.740.991; assim, 10^16 mais um pode ficar gravado como 10^16. Aqui os dígitos são tratados como texto e todos são mantidos.
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/bignum-add \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"a":"9223372036854775807","b":"1"}'const res = await fetch("https://api.kit.forhosting.com/dev/bignum-add", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"a": "9223372036854775807",
"b": "1"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/bignum-add",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"a": "9223372036854775807",
"b": "1"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/bignum-add", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"a":"9223372036854775807","b":"1"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"a":"9223372036854775807","b":"1"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/bignum-add", 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
{
"a": "9223372036854775807",
"b": "1"
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.bignum_add",
"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_digits | 10000 |
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
Chamadas API bem-sucedidas usam o preço-base publicado US$ 0,002.
Por que a adição nativa falha e como o vai-um escolar permanece exato
Doubles IEEE-754, que de fato são os números JSON e muitas células de planilha, perdem a capacidade de representar cada inteiro quando a magnitude passa de 9007199254740991, então 10^16 mais um já pode ser armazenado como 10^16.
Contrato de entrada, forma da resposta, limites e erros
Cadeias vazias e campos omitidos falham do mesmo modo. Depois de ler o sinal, zeros à esquerda são removidos; um valor de menos zero vira zero. Cada magnitude já recortada pode conter no máximo 10000 dígitos — esse limite é declarado e aplicado para que um muro de algarismos colado não esgote o isolado. Sinais mistos funcionam do mesmo jeito: menos cem seguido de vinte zeros, mais um, produz um negativo de dezenove dígitos. Falhas de validação não são cobradas. Envie por POST um objeto JSON com dois campos obrigatórios, a e b. Cada campo é um inteiro decimal: uma cadeia de dígitos com um mais ou um menos inicial opcional, ou um número JSON que seja um inteiro seguro. Frações, separadores de milhar, espaços no meio dos dígitos, prefixos hexadecimais e notação científica são recusados com invalid_input nomeando o campo. Em caso de sucesso o corpo ecoa as duas parcelas na forma canônica, devolve sum como o total decimal exato, digit_count como o número de dígitos do valor absoluto, sign como positive, negative ou zero, exceeds_int64 como true quando a soma não é representável como inteiro com sinal de sessenta e quatro bits, e uma cadeia curta de fórmula reafirmando sum = a + b. Exemplo: a igual a 9223372036854775807 e b igual a 1 produz sum 9223372036854775808, digit_count 19, sign positive e exceeds_int64 true. Chamadas API bem-sucedidas usam o preço-base publicado US$ 0,002.
Onde a adição exata de inteiros grandes se justifica
Pipelines de finanças e faturamento somam linhas de fatura, bases de imposto e totais de subunidades de criptomoeda que já excedem o que uma célula de planilha ou uma coluna monetária de sessenta e quatro bits consegue guardar sem arredondar. Ferramentas de criptografia e de codificação somam inteiros públicos grandes, números de série e contadores do tamanho de um hash quando só precisam de uma soma, não de uma biblioteca multiprecisão completa. Cursos de ciência da computação e treinos de entrevista de programação precisam de um oráculo que demonstre a propagação do vai-um em uma cadeia de noves mais um, e que se recuse a fingir que 2^63 menos um mais um ainda cabe em um long com sinal. Scripts de migração de dados comparam um SUM de colunas NUMERIC do banco com este endpoint para caçar overflow silencioso em uma coluna inteira que estão prestes a alargar. Como a implementação é parse de nível A puro, cada chamada bem-sucedida custa o preço-base publicado US$ 0,002 sem tokens de modelo e sem rede de saída. Mantenha cada operando dentro do limite de dígitos publicado, envie como cadeias e não como números os valores que estourariam o JSON, e fixe a soma devolvida nos testes. Assim você obtém um total exato e reproduzível para livros, avaliadores e workers de borda sem levantar um serviço próprio de aritmética de precisão arbitrária.
Perguntas técnicas
Por que valores grandes devem ser cadeias em vez de números JSON?
Números JSON são doubles IEEE-754. Inteiros maiores que 9007199254740991 não são todos representáveis, então um valor como 9223372036854775807 já seria arredondado antes do somador rodar. Cadeias de dígitos permanecem exatas.
Quais entradas são recusadas?
Falta de a ou b, cadeias vazias, frações, separadores de milhar, caracteres que não são dígitos e magnitudes com mais de 10000 dígitos falham com invalid_input e não são cobradas.
Quanto custa a calculadora de adição de inteiros grandes?
A ferramenta do navegador é gratuita. Pedidos API usam saldo KIT pré-pago a US$ 0,002 por chamada bem-sucedida; entrada inválida não é cobrada.