A calculadora binária executa o conjunto completo de operações que programadores precisam em números de base 2: aritmética (soma, subtração, multiplicação, divisão, exponenciação), lógica bitwise (AND, OR, XOR, NOT) e operadores de deslocamento (left shift, right shift). Cada resultado é mostrado em binário, decimal e hexadecimal ao mesmo tempo, para você conferir à mão ou colar direto no código-fonte. As entradas podem ser informadas em qualquer uma das três bases — útil quando você tem uma constante hex de um datasheet, um valor decimal de uma especificação ou um literal binário de um bitmap — e a aritmética de precisão arbitrária via BigNumber.js elimina os tetos de overflow de 32 ou 53 bits. Usos comuns: depurar operações com flags, montar netmasks, decodificar registradores de hardware, calcular valores em complemento de dois e entender como o computador realmente calcula.
O que é Binário?
Binário é o sistema numérico que os computadores realmente usam. Tem exatamente dois símbolos, 0 e 1, porque o hardware físico — transistores, domínios magnéticos, pits ópticos — consegue representar de forma confiável dois estados distintos (desligado/ligado, tensão baixa/alta) e quase nada mais com a mesma velocidade e confiabilidade. Toda estrutura de nível mais alto na computação — texto, imagens, áudio, pacotes de rede, instruções — é, no nível mais baixo, apenas bits.
Cada dígito binário se chama bit. Oito bits formam um byte (a menor unidade endereçável em quase todos os computadores modernos); 16 bits, um meio-word; 32 ou 64 bits, um word, do tamanho do registrador nativo da CPU. Dentro de um byte, os bits são numerados de 0 (menos significativo, à direita) a 7 (mais significativo, à esquerda). O bit na posição k contribui 2^k ao valor quando está ligado.
Binário é um sistema posicional como o decimal, mas com base 2 em vez de 10. O número binário 1010 expande-se como 1×2³ + 0×2² + 1×2¹ + 0×2⁰ = 8 + 0 + 2 + 0 = 10 em decimal. O dígito mais à esquerda é o mais significativo — mesma convenção do decimal. Para converter decimal para binário, divida sucessivamente por 2 e registre os restos de baixo para cima; para converter binário em decimal, some as potências de 2 em cada bit ligado.
A importância do binário não é só histórica: toda primitiva computacional — aritmética, endereços, formatos de arquivo, protocolos de rede — é definida em termos de bits e alinhamento de bytes. Entender binário diretamente é o que permite ao programador raciocinar sobre overflow, alinhamento, endianness, compressão e custo de operações. Mesmo linguagens de alto nível que escondem os bits os expõem quando o desempenho importa (bitsets, bloom filters, RoaringBitmap, CRC checksums, funções hash).
Como fazer cálculos binários?
A aritmética binária segue o mesmo algoritmo coluna por coluna que você aprendeu para decimal — a única diferença é que o alfabeto tem dois símbolos em vez de dez, então as regras de transporte/empréstimo são mais apertadas.
- Adição Binária
- Mesmo algoritmo por colunas que em decimal, mas a maior soma de um único dígito é 1 + 1 = 10₂ (que é 2 em decimal, escrito como 0 nesta coluna e 1 transportado para a esquerda).
- Regras de coluna única: 0+0=0, 0+1=1, 1+0=1, 1+1=10 (carrega 1). Com transporte de entrada: 1+1+1=11 (escreve 1, carrega 1).
- Exemplo: 1011 (11) + 1101 (13) = 11000 (24). Confira somando coluna a coluna da direita para a esquerda com transportes.
- O hardware soma binários exatamente assim usando somadores completos em cascata; CPUs modernas somam um par de 64 bits em um ciclo de clock calculando todos os transportes em paralelo (carry-lookahead).
- Subtração Binária
- Regras de coluna para subtração: 0-0=0, 1-0=1, 1-1=0, 0-1 precisa de empréstimo da próxima coluna (dá 1 nesta coluna, subtrai 1 da coluna à esquerda).
- Dentro das CPUs, a subtração quase nunca é feita por um circuito de empréstimo separado. Em vez disso, a-b é computado como a + (~b + 1) — soma com o complemento de dois de b — usando o mesmo somador.
- Exemplo: 1011 (11) - 100 (4) = 111 (7). Ou via complemento de dois: ~100 + 1 em 4 bits = 1100, depois 1011 + 1100 = 10111, descarta o bit de saída, sobra 0111 = 7.
- É por isso que inteiros em C, Java e na maioria das linguagens podem dar volta passando INT_MIN/INT_MAX silenciosamente: a + 1 volta a INT_MIN quando a == INT_MAX porque o bit de saída é descartado.
- Multiplicação Binária
- Cada bit do multiplicador é multiplicado pelo multiplicando inteiro e os produtos parciais são somados, deslocados pela posição do bit.
- Regras de bit único: 0×qualquer coisa=0, 1×qualquer coisa=ele mesmo (basta copiar).
- Exemplo: 101 (5) × 11 (3) = produtos parciais 101 (×1) e 1010 (×2, deslocado um lugar à esquerda) somados = 1111 (15).
- O hardware faz isso com um circuito multiplicador; multiplicar dois valores de 64 bits costuma ser alguns ciclos de clock no x86 moderno (IMUL), mas era caro nos primeiros CPUs — bem mais lento que somar. Por isso muitos códigos antigos usam truques de shift-and-add.
- Quando um operando é potência de 2, a multiplicação degenera em um deslocamento à esquerda (n × 8 == n << 3). Compiladores fazem isso automaticamente como redução de força; o mesmo vale para divisão por potências de 2 virando deslocamento à direita.
- Divisão Binária
- A divisão longa binária procede bit a bit: desloca o divisor para alinhar com os bits altos do dividendo, subtrai se couber (escrevendo 1 no quociente), desloca para a direita, repete. O resto é o que sobra depois da última subtração.
- Notas Práticas
- Escrever os valores de posição acima das colunas (..., 16, 8, 4, 2, 1) é o jeito mais rápido de converter binário em decimal à mão. Cada '1' contribui com seu valor posicional; some-os.
- Use hex como notação intermediária: a cada 4 dígitos binários, um dígito hex, então 1010 1011 = 0xAB, sem fazer conta. É por isso que dumps de memória e códigos de cor usam hex.
- Cuidado com o tamanho do word ao calcular em uma linguagem real: os operadores bitwise do JavaScript truncam silenciosamente os operandos para inteiros com sinal de 32 bits, então qualquer cálculo envolvendo os bits 31+ se comporta de forma surpreendente. Esta calculadora usa BigNumber.js para evitar isso.
Além da prática manual e desta calculadora, toda linguagem de programação de uso geral suporta literais binários (0b1010 em JS, Python, Rust, C++14+) e um conjunto completo de operadores bitwise. Para trabalho embarcado, consulte o datasheet do chip — layouts de bits dos registradores são quase sempre definidos em binário.
Tabela de Conversão Binário/Decimal
| Binário | Decimal |
|---|
| 0000 | 0 |
| 0001 | 1 |
| 0010 | 2 |
| 0011 | 3 |
| 0100 | 4 |
| 0101 | 5 |
| 0110 | 6 |
| 0111 | 7 |
| 1000 | 8 |
| 1001 | 9 |
| 1010 | 10 |
| 1011 | 11 |
| 1100 | 12 |
| 1101 | 13 |
| 1110 | 14 |
| 1111 | 15 |
Perguntas Frequentes
Porque o binário só tem dois símbolos, 0 e 1 — o símbolo "2" simplesmente não existe nesse sistema. Quando você atinge a contagem de dois em qualquer sistema posicional, precisa subir ao próximo valor posicional. Em decimal, 9 + 1 = 10 pelo mesmo motivo: 9 é o último símbolo de um único dígito, e somar 1 força um transporte para a coluna das dezenas. Em binário, 1 + 1 produz 0 na coluna das unidades e carrega 1 para a coluna dos dois, escrito como 10. O valor é dois — o que mudou foi só a notação. É também por isso que programadores brincam: "existem 10 tipos de pessoas no mundo: as que entendem binário e as que não". Todo sistema posicional funciona assim, inclusive o hex: F + 1 = 10 (dezesseis), e o ternário: 2 + 1 = 10 (três).
O complemento de dois é a representação universal para inteiros com sinal no hardware moderno, e funciona reinterpretando o bit mais significativo (MSB) como peso negativo. Em 8 bits, o MSB pesa −128 em vez de +128. Então 11111111 em complemento de dois é −128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = −1, e 10000000 é exatamente −128. Para negar um número: inverta todos os bits (complemento de um) e some 1. Exemplo: +5 = 00000101 → inverte para 11111010 → soma 1 = 11111011 = −5. O complemento de dois tem três propriedades desejáveis que levaram à adoção universal: (1) há apenas um zero (00000000), e não dois como em sinal-magnitude; (2) a soma funciona igual para com e sem sinal — o mesmo somador trata os dois; (3) o bit de saída do bit alto é descartado, dando aritmética modular natural e overflow previsível. Compromisso: o intervalo negativo é um a mais que o positivo (8 bits: −128 a +127), e abs(INT_MIN) dá overflow.
Operadores bitwise não são curiosidades acadêmicas — eles aparecem o tempo todo em código sensível a desempenho, código de sistema e protocolos. AND (&) testa bits e aplica máscaras: status & 0x04 verifica se o terceiro bit está ligado, padrão comum para ler flags de status ou extrair campos de uma estrutura empacotada. OR (|) liga bits: flags = flags | LOG_INFO acende uma flag sem afetar as outras. XOR (^) alterna bits ou detecta diferenças: x ^ x sempre dá 0, usado em checksums; XOR-swap troca duas variáveis sem temporária; cifragem XOR com uma chave. NOT (~) inverte todos os bits e é usado principalmente em conjunto com AND para limpar bits específicos: flags = flags & ~LOG_DEBUG desliga LOG_DEBUG sem mexer nas outras. Essas quatro operações também são os blocos de construção de abstrações de alto nível: bitmaps, bloom filters, RoaringBitmap, netmasks IP (ip & netmask dá o endereço de rede), mistura de cor em gráficos e funções hash. Quase toda CPU as implementa como instruções de um ciclo; em loops apertados, superam qualquer alternativa condicional.
Deslocamento à esquerda (<<) de qualquer tipo é inequívoco: preenche com zeros à direita, descarta bits à esquerda. À direita há dois sabores e você precisa saber qual. O lógico (>>> em JavaScript e Java, lsr no ARM) sempre preenche com 0 à esquerda, tratando o número como sem sinal — 0xFF >>> 1 = 0x7F. O aritmético (>> em JavaScript, Java, C com tipos com sinal; asr no ARM) replica o bit de sinal, preservando o sinal de um número em complemento de dois — −2 >> 1 = −1, não 0x7FFFFFFE. Importa: para campos sem sinal, use o lógico; para inteiros com sinal, o aritmético. Rotação (sem operador nativo em C ou JS, intrínsecos _rotl/_rotr no x86) gira os bits de uma ponta à outra em vez de descartá-los — útil em criptografia (AES, ChaCha usam rotações) e em funções hash de largura fixa onde se precisa de uma distribuição equilibrada. O << padrão do JavaScript trunca silenciosamente o resultado para 32 bits, então deslocamentos além do bit 31 surpreendem; esta calculadora usa BigNumber.js para manter resultados exatos em qualquer largura.
Porque 4 dígitos binários mapeiam exatamente para 1 dígito hex, sem sobra. 0000 a 1111 corresponde a 0 a F. Um valor de 32 bits são 32 dígitos binários, mas só 8 dígitos hex, que cabem em uma linha de fonte e são fáceis de ler. Hex preserva toda a estrutura de bits: cada caractere hex diz exatamente 4 bits, então 0xDEADBEEF mostra na hora o padrão de bits a um programador, enquanto 11011110101011011011111011101111 embaralha a vista. Octal (base 8) é mais antigo e agrupa bits de 3 em 3 — era comum em máquinas de 12 e 36 bits dos anos 1960 — mas octal não divide 32 redondamente, gerando lacunas; o hex ganhou. Códigos de cor RGB (#FF8800), endereços MAC, UUIDs, endereços de memória, checksums de arquivo e pontos de código Unicode (U+1F600) estão todos em hex por causa disso. Ao depurar código no nível de bits, aprender a traduzir dígitos hex de e para seus padrões binários de 4 bits no olho é uma das habilidades de maior alavancagem.
Porque o decimal 0,1 não tem representação binária exata. Em base 2, 0,1 é a fração periódica não terminante 0,000110011001100... — análogo a como 1/3 é 0,333... em decimal. IEEE 754 dupla precisão arredonda isso para 52 bits de mantissa, dando uma aproximação ligeiramente maior que 0,1. O mesmo vale para 0,2. Quando você soma as duas aproximações arredondadas e converte de volta para decimal, o erro residual aparece: 0,30000000000000004. Potências de 2 — 0,5, 0,25, 0,125 — e múltiplos inteiros delas — 0,75, 0,625 — são exatamente representáveis. Qualquer outra coisa tem erro de arredondamento. Para cálculos financeiros ou quando aritmética decimal exata é exigida, use uma biblioteca Decimal (BigDecimal em Java, Decimal em Python, BigNumber.js em JavaScript) ou escale para centavos inteiros. Para aritmética inteira binária — o foco desta calculadora — não há erro de arredondamento: inteiros até 2^53 cabem exatos em um double, e o BigNumber.js nos leva ainda além.
Depende da linguagem e do tipo inteiro. O int do C/C++ é definido pela implementação, mas tipicamente 32 bits com sinal: −2.147.483.648 a +2.147.483.647 (cerca de ±2,1 bilhões). long long é 64 bits com sinal: cerca de ±9,2 quintilhões. O Number do JavaScript é um double IEEE 754 de 64 bits, então representa inteiros exatos até 2^53 − 1 = 9.007.199.254.740.991 (Number.MAX_SAFE_INTEGER); além disso, inteiros consecutivos deixam de ser distinguíveis. Os operadores bitwise do JavaScript (&, |, ^, <<, >>, ~) trapaceiam de outro jeito: sempre truncam os dois operandos para inteiros com sinal de 32 bits e depois convertem de volta. Por isso 0x100000000 | 0 == 0, o que surpreende as pessoas. O ES2020 adicionou BigInt (literal 123n) para precisão arbitrária. Python tem int de precisão arbitrária nativo — não há overflow — mas paga um custo em runtime. Rust te obriga a escolher: u32, i64, u128, etc., e o overflow é verificado em debug, mas dá volta em release. Esta calculadora usa BigNumber.js para precisão arbitrária, então aritmética binária com centenas de dígitos funciona como esperado.
O uso de padrões binários em matemática remonta a muito antes de Leibniz — a multiplicação egípcia antiga usava decomposição binária, e o erudito indiano Pingala descreveu por volta de 200 a.C. o que equivale a um sistema posicional binário para analisar a métrica do sânscrito. Mas Gottfried Wilhelm Leibniz, no artigo de 1703 Explication de l'Arithmétique Binaire, deu o primeiro tratamento sistemático ocidental do binário como sistema numérico completo, com regras de soma, subtração, multiplicação e divisão — e observou explicitamente que todos os números podiam ser representados usando apenas 0 e 1. Leibniz se inspirou em parte em descrições dos hexagramas do I Ching, cujas 64 figuras mapeiam exatamente para números binários de 6 bits. O próximo salto levou 250 anos: a álgebra da lógica de George Boole, de 1854, mostrou que proposições podiam ser manipuladas com dois valores de verdade, e a tese de mestrado do Claude Shannon no MIT em 1937, A Symbolic Analysis of Relay and Switching Circuits, provou que a álgebra booleana implementada em relés elétricos podia realizar computação arbitrária — a base de todos os computadores digitais. O Z3 de Konrad Zuse (1941) e o ENIAC (1945) vieram pouco depois. Toda CPU hoje é, no final, uma enorme máquina de circuitos booleanos seguindo o projeto do Shannon.
Calculadora
Matemática
Tem feedback? Reporte bugs, sugira recursos ou compartilhe suas ideias — lemos todos
CALCULADORAS MATEMáTICAS32
FERRAMENTAS PARA DESENVOLVEDORES99
WUTOOLS