Calculadora de números enormes｜Soma, subtração, multiplicação e potência sem limite de dígitos (BigInt)

Ferramenta gratuita para calcular com exatidão inteiros enormes, sem erro de arredondamento. Usa o BigInt do JavaScript para realizar somas, subtrações, multiplicações, divisões inteiras (quociente e resto) e potências exatas mesmo acima de 9.007.199.254.740.991 (2^53 − 1).

Última atualização: 2026-09-06

Por que a precisão falha além de 2^53

Uma calculadora comum ou o tipo Number do JavaScript deixam de distinguir inteiros consecutivos além de 2^53 (Number.MAX_SAFE_INTEGER). O BigInt permite calcular com exatidão mesmo além desse limite.

Number.MAX_SAFE_INTEGER	9,007,199,254,740,991（2⁵³ − 1）
9007199254740992 + 1	Number: 9007199254740992 (incorreto) / BigInt: 9007199254740993 (exato)

O que significa o cálculo exato com inteiros grandes

Uma calculadora comum, e o tipo numérico da maioria das linguagens de programação — entre eles o Number do JavaScript —, não consegue guardar com exatidão inteiros acima de 2^53 − 1 (9.007.199.254.740.991); passado esse ponto surge erro de arredondamento à medida que os dígitos crescem. O cálculo exato com inteiros grandes consiste em ultrapassar esse teto e realizar somas, subtrações, multiplicações, divisões e potências com qualquer número de dígitos sem erro.

Esta ferramenta calcula com o tipo BigInt do JavaScript, de modo que não há limite prático de dígitos: inteiros de várias centenas de casas, como os que aparecem em criptografia e em programação competitiva, voltam exatos. A divisão inteira mostra ao mesmo tempo o quociente e o resto e, como as potências crescem enormemente muito depressa, impõe-se um limite superior seguro ao expoente.

Como usar a calculadora

Informe o primeiro inteiro (A) Digite o inteiro com que quer operar. Os separadores de milhar são removidos automaticamente se você os deixar.
Escolha o operador Selecione soma, subtração, multiplicação, divisão inteira (quociente e resto) ou potência.
Informe o segundo inteiro (B) Forneça o outro operando. Na potência, B é o expoente.
Confira o resultado O resultado e a quantidade de dígitos se atualizam em tempo real enquanto você digita. Na divisão inteira aparecem quociente e resto.

Dicas para aproveitar melhor

Calculadoras e planilhas comuns perdem precisão além de 2^53 (cerca de 9 quatrilhões), mas esta ferramenta usa BigInt para calcular com exatidão, sem limite de dígitos.
A divisão inteira (÷) mostra o quociente e o resto ao mesmo tempo, útil para conferir operações de módulo usadas em criptografia e funções hash.
O expoente é limitado a 1.000.000 por segurança, já que um expoente ilimitado poderia travar o navegador.
Você pode colar números com separador de milhar (por exemplo 1.234.567): eles são removidos automaticamente antes do cálculo.
Clique em "Inserir exemplo" para preencher automaticamente um caso que ultrapassa 2^53 e ver na hora a diferença em relação a uma calculadora comum.

Quando é útil

Verificar trabalhos de criptografia

Útil para estudar ou conferir técnicas como a geração de chaves RSA, que envolvem aritmética com inteiros de várias centenas a vários milhares de casas.

Conferir respostas em programação competitiva

Confirme rapidamente as respostas esperadas de problemas com inteiros de precisão arbitrária, como fatoriais grandes ou termos distantes da sequência de Fibonacci.

Detectar erro em dados numéricos grandes

Verifique se um resultado calculado numa planilha ou numa calculadora comum ultrapassou 2^53 e caiu no erro de arredondamento, comparando-o com o valor exato.

Estudo e trabalhos de matemática

Veja por si mesmo como crescem as potências e os restos de números com muitas casas, partindo de valores reais em vez de descrições.

Termos sobre inteiros grandes

BigInt: O tipo de dado do JavaScript para lidar com exatidão com inteiros de comprimento ilimitado. Diferentemente do tipo Number comum, calcula sem erro inteiros acima de 2^53.
Inteiro de precisão arbitrária (bignum): Mecanismo para representar inteiros além da faixa que um computador manipula nativamente, sem limite de casas. Internamente os dígitos são geridos como um vetor e o cálculo se faz sobre essa base.
Number.MAX_SAFE_INTEGER: O maior inteiro que o tipo Number do JavaScript guarda com segurança e sem erro: 2^53 − 1, ou seja, 9.007.199.254.740.991. Além dele, inteiros vizinhos deixam de se distinguir.
Divisão inteira: Divisão que não produz decimais e separa o resultado em quociente — a parte inteira — e resto. Quando há números negativos, o quociente é truncado em direção a zero.
RSA: Criptossistema de chave pública que usa como chave o produto de dois números primos grandes. A aritmética com inteiros de 2048 bits, mais de 600 casas decimais, é corriqueira, de modo que o tratamento de precisão arbitrária é indispensável.

Perguntas frequentes

O tipo Number comum do JavaScript é um número de ponto flutuante de precisão dupla (IEEE 754), que só consegue representar com segurança inteiros até 2^53 − 1 (9.007.199.254.740.991). Além desse limite, inteiros consecutivos se tornam indistinguíveis e os cálculos perdem precisão. Esta ferramenta evita completamente esse limite usando o tipo BigInt.

Não. O BigInt é um tipo do JavaScript pensado para admitir apenas inteiros, e não consegue representar frações. Para cálculos com casas decimais, use a nossa Calculadora comum.

O resto é A − (quociente × B), em que o quociente é truncado em direção a zero. Por exemplo, −7 ÷ 2 resulta em quociente −3 e resto −1.

É útil sempre que uma calculadora comum não tem precisão suficiente: conferir operações com chaves RSA (centenas a milhares de dígitos), calcular fatoriais enormes ou verificar aritmética de precisão arbitrária em programação competitiva.

Não há um limite fixo, mas a memória e a velocidade de processamento do navegador impõem restrições práticas. Números com milhares de dígitos são calculados instantaneamente; casos extremos (como um expoente acima de 1.000.000) são limitados por segurança.

Curiosidade — Por que os computadores não lidam bem com números enormes

A representação numérica nos computadores sempre teve um limite rígido. O tipo de ponto flutuante de 64 bits (precisão dupla), padrão na maioria das linguagens de programação, só consegue representar com segurança inteiros até 2^53 − 1 (9.007.199.254.740.991), porque sua mantissa tem apenas 53 bits. Além disso, surgem erros de arredondamento ao representar esses inteiros. A nossa própria ferramenta Calculadora tem exatamente essa mesma limitação de precisão.

Os inteiros de precisão arbitrária (conhecidos como "bignums") resolvem esse problema. Por volta de 2020, o JavaScript passou a incluir um novo tipo chamado BigInt em todos os navegadores principais, permitindo aritmética inteira exata sem limite de dígitos além da memória disponível. Internamente, um bignum é armazenado como uma sequência de blocos de dígitos, então o tempo de cálculo cresce com o número de dígitos — há uma troca real entre exatidão e velocidade.

Essa tecnologia é indispensável em criptografia. Chaves RSA, por exemplo, costumam usar inteiros de 2048 bits (mais de 600 dígitos decimais), e bibliotecas de precisão arbitrária são usadas no mundo todo para calcular as multiplicações e exponenciações modulares exigidas por essas chaves.

A programação competitiva costuma envolver fatoriais enormes (100! tem 158 dígitos) ou termos distantes da sequência de Fibonacci. Os tipos numéricos comuns acumulam erro no meio desses cálculos, então dominar bignums muitas vezes separa uma solução correta de uma incorreta.

Ver todas as curiosidades