O Curso de bases numéricas e bits é um tutorial interativo de 17 níveis que transforma o "binário" de conceito abstrato em interruptores que dá para tocar: você digita um número e as quatro notações (binária, octal, decimal e hexadecimal) mudam juntas; acende ou apaga um bit e o valor é atualizado na hora; faz dois números passarem por AND / OR / XOR / deslocamento e vê o resultado alinhado bit a bit; digita um decimal e acompanha a separação dele em sinal, expoente e mantissa, além de descobrir a qual decimal ele é exatamente igual em precisão dupla. Cada nível tem um objetivo concreto — converter um número, chegar a 200, escrever o complemento de dois de -5, calcular 5 << 3 — e o verificador responde na hora.

O curso é dividido em quatro blocos: conversão entre bases (binário ↔ decimal, potências de 2, por que hexadecimal e octal são "taquigrafia"); números com sinal (como o complemento de dois transforma subtração em soma e por que o estouro faz 127 + 1 virar -128); operações de bits (máscara com AND, ligar com OR, inverter com XOR, deslocar para multiplicar e dividir, e a aplicação direta disso nos bits de permissão 755 do Linux); e ponto flutuante (o layout dos campos do IEEE 754 e o motivo real de 0.1 + 0.2 !== 0.3).

São cerca de 45 minutos. O curso é para quem está começando a programar, para quem se prepara para entrevistas e para quem precisa consultar 0x1F, & 0xFF ou chmod 644 toda vez; não é preciso base de matemática, basta saber somar.

1. 01Veja o objetivo e os painéiso objetivo fica no topo de cada nível e os painéis abaixo mudam conforme o nível — o painel "Valores" tem campo de entrada, leitura nas quatro bases e uma fileira de interruptores de bits clicáveis, com alternância entre leitura com sinal e sem sinal; o painel "Operações" traz dois operandos e um operador, com o resultado alinhado bit a bit; o painel "Permissões" tem 9 interruptores rwx e a leitura em octal; o painel "Ponto flutuante" recebe um decimal e mostra a decomposição em 32 / 64 bits e a expansão decimal exata.
2. 02Opere e observemude a entrada, clique nos interruptores, alterne a largura em bits e todas as leituras acompanham na hora; observar faz parte do aprendizado — ao mudar 128 para a leitura com sinal, por exemplo, você vê direto o valor virar -128.
3. 03Respondana maioria dos níveis basta preencher o campo de resposta com um decimal, uma sequência binária, um hexadecimal ou um octal; os níveis de "interruptores de bits" pedem que você chegue ao valor só clicando; e o último nível de ponto flutuante é de múltipla escolha.
4. 04Confiraa barra de resultado mostra na hora se passou ou onde está o erro; respostas binárias aceitam zeros à esquerda (exceto nos níveis que pedem "exatamente 8 bits"), e hexadecimais não diferenciam maiúsculas de minúsculas e podem levar 0x.
5. 05Dicas, respostas e progresso"Dica" dá o caminho e "Ver resposta" mostra uma resposta de referência que pode ser preenchida; o progresso fica no navegador do seu aparelho e ?lesson=n leva direto a um nível.

O nível 9, "Achar o complemento de dois", pede o complemento de dois de -5 em 8 bits:

No nível 16, "Campos do IEEE 754", ao digitar 0.15625 o painel mostra:

Valor absoluto   5        0 0 0 0 0 1 0 1
Inverter bits             1 1 1 1 1 0 1 0
Somar 1                   1 1 1 1 1 0 1 1      ← resposta 11111011
Conferir  sem sinal 251, com sinal 251 − 256 = −5   ✓

0.15625 = 0.00101₂ = 1.01₂ × 2⁻³
Sinal  0
Expoente  −3 + 127 = 124 = 01111100      ← resposta 124
Mantissa  01000000000000000000000 (o 1 inicial é implícito)
32 bits 0 01111100 01000000000000000000000 = 0x3E200000

Níveis 1–2: valor posicional e conversão

Qualquer base é uma "soma de valores posicionais". O decimal 203 = 2×100 + 0×10 + 3×1; o binário 1011 = 1×8 + 0×4 + 1×2 + 1×1 = 11. Da direita para a esquerda, os valores posicionais são 1, 2, 4, 8, 16, 32, 64, 128… Converter binário em decimal é somar os valores posicionais dos bits 1; converter decimal em binário é dividir por 2 anotando os restos, ou subtrair gananciosamente as potências de 2 da maior para a menor (os interruptores do nível 7 são justamente essa visualização).

Nível 3: por que 1024

$2^{10} = 1024$ difere de 1000 em apenas 2,4%, e por isso o KB passou a significar 1024 bytes no começo. Daí vem a confusão que existe até hoje: fabricantes de disco rotulam 1 GB como $10^9$, o sistema operacional calcula com $2^{30}$ e um disco de 500 GB aparece com 465 GiB. A IEC criou por isso KiB, MiB e GiB (prefixos binários), adotados aos poucos pelo Linux e pelo macOS, enquanto o Windows continua mostrando GB mas calculando em GiB. Vale memorizar alguns números: $2^8 = 256$, $2^{10} = 1024$, $2^{16} = 65536$, $2^{32} \approx 4.29 \times 10^9$.

Níveis 4–6: hexadecimal e octal

O binário é longo demais para ler. O hexadecimal (0–9 mais A–F) usa um símbolo para cada 4 bits, então um byte dá exatamente dois: 11111111 = FF, 10110110 = B6. A conversão não precisa passar pelo decimal — basta cortar o binário de 4 em 4 bits da direita para a esquerda e consultar cada grupo, que é o exercício do nível 5. O octal usa um símbolo para 3 bits e era usado por máquinas de 12, 24 e 36 bits; hoje sobrevive nas permissões do Linux (755) e no escape \012 do C. Os prefixos nos programas: 0x para hexadecimal, 0o para octal e 0b para binário.

Nível 7: o bit é um interruptor

Todo inteiro não negativo tem uma única forma binária, então um número de 8 bits pode funcionar como 8 interruptores independentes (bits de flag): flags = READ | WRITE, if (flags & EXEC). É assim que o font-weight do CSS, as permissões de arquivo do Unix e os campos de flag nos cabeçalhos de protocolo de rede são empacotados. No nível 7 você precisa chegar a 200 só clicando nos interruptores — da maior potência para a menor: 200 ≥ 128 liga, sobram 72 ≥ 64 liga, sobram 8 = 2³ liga, e dá 11001000.

Níveis 8–9: complemento de dois

Como guardar números negativos? A ideia intuitiva é reservar um bit para o sinal, mas assim existiriam dois zeros, "+0" e "−0", e o circuito de soma precisaria tratar cada caso. O complemento de dois (two's complement) funciona assim: se o bit mais significativo é 1, o valor é negativo e equivale ao valor sem sinal menos $2^n$. Em 8 bits, 11111111 é 255 e também 255 − 256 = −1; 10000000 é −128. Para achar o complemento de dois de um número negativo: escreva o valor absoluto, inverta os bits e some um — −5 fica 00000101 → 11111010 → 11111011.

O encanto do complemento de dois é que a soma não precisa saber o sinal: −5 + 5 = 11111011 + 00000101 = 1 00000000, e depois de descartar o vai-um do 9º bit o resultado é exatamente 0. A subtração vira "somar o complemento" e a CPU precisa de um único somador. A faixa do complemento de dois em 8 bits vai de −128 a 127: há um negativo a mais do que positivos, porque o 0 ocupa um lugar do lado positivo.

Nível 10: estouro

A largura em bits é finita, e ao passar do limite o valor dá a volta. Em int8, 127 = 01111111; somando um, dá 10000000, que na leitura em complemento de dois é −128. É assim que o estouro de inteiro acontece em silêncio em C, Java e Go; em JavaScript, o Number comum é ponto flutuante e por isso não estoura, mas Int8Array, |0 e todas as operações de bits rodam em complemento de dois de 32 bits, e (2 ** 31) | 0 resulta em −2147483648. O famoso problema do ano 2038 é um contador de segundos com sinal de 32 bits que estoura para negativo em 2038-01-19 03:14:07 UTC; a "pontuação que fica negativa" e as "moedas que zeram" de jogos antigos são a mesma coisa.

Níveis 11–13: AND, OR e XOR

As três operações lógicas bit a bit têm usos fixos:

"Desligar" um bit é a combinação de AND com NOT: flags & ~FLAG. As duas identidades do XOR, $x \oplus x = 0$ e $x \oplus 0 = x$, estão na raiz de todos os seus usos: a ^= b; b ^= a; a ^= b troca dois números, e para achar o único elemento que aparece um número ímpar de vezes em um vetor basta aplicar XOR em todos eles.

Nível 14: deslocamento

Deslocar n bits para a esquerda é multiplicar por $2^n$ (entram zeros nos bits de baixo) e deslocar n bits para a direita é dividir por $2^n$ arredondando para baixo. 5 << 3 = 101000 = 40. O deslocamento é a multiplicação e a divisão mais baratas que existem, e o uso mais comum é empacotar campos pequenos em um inteiro: (r << 16) | (g << 8) | b junta três valores de 0 a 255 em uma cor de 24 bits, e o caminho de volta (rgb >> 8) & 0xFF extrai o G. Atenção: existem dois deslocamentos à direita — o aritmético >> preserva o bit de sinal (um negativo continua negativo) e o lógico >>> preenche com 0. Em JavaScript os deslocamentos acontecem em 32 bits, 1 << 31 dá −2147483648 e 1 << 32 equivale a 1 << 0 = 1, porque a quantidade de bits é tratada como módulo 32.

Nível 15: chmod 755

As permissões de arquivo do Linux são 9 bits: dono, grupo e outros, com 3 bits cada, na ordem leitura r = 4, escrita w = 2 e execução x = 1. A soma de cada trio dá um dígito octal: rwxr-xr-x = 7, 5, 5 → 755; rw-r--r-- = 644. É a aplicação mais direta de valores posicionais e máscaras no dia a dia de quem administra sistemas: chmod u+x é um OR com 0o100, e chmod o-w é um AND com ~0o002. Ainda pode haver os bits 10 a 12 (setuid, setgid e sticky), e é por isso que às vezes aparece um quarto dígito, como 4755.

Nível 16: os três campos do IEEE 754

Um ponto flutuante é a notação científica em binário:

Precisão simples em 32 bits = 1 bit de sinal s + 8 bits de expoente e (viés 127) + 23 bits de mantissa f; precisão dupla em 64 bits = 1 + 11 (viés 1023) + 52. A mantissa guarda só a parte fracionária, porque o 1 da parte inteira é implícito — um bit de precisão de graça. O expoente é armazenado com viés para que comparar dois pontos flutuantes bit a bit seja monotônico como comparar inteiros. 0.15625 = $0.00101_2$ = $1.01_2 \times 2^{-3}$, o campo de expoente vale −3 + 127 = 124 = 01111100 e o campo de mantissa é 01 seguido de zeros.

Alguns códigos especiais: expoente todo 0 é número subnormal (valores muito próximos de 0 e o ±0); expoente todo 1 com mantissa toda 0 é ±∞; expoente todo 1 com mantissa diferente de 0 é NaN — é por isso que 0/0 é NaN enquanto 1/0 é Infinity, e também por isso que o NaN tem vários padrões de bits e ainda assim "não é igual a si mesmo".

Nível 17: 0.1 + 0.2

Uma fração binária só representa exatamente somas de potências negativas de 2: 0,5; 0,25; 0,125… Já $\tfrac{1}{10}$ é uma dízima infinita em binário, $0.0\overline{0011}$, e a mantissa de 52 bits precisa arredondar. Então o 0.1 de precisão dupla é exatamente

um pouco maior que 0,1; o 0.2 também é um pouco maior; somando os dois e arredondando chega-se a 0,3000000000000000444…, enquanto o literal 0.3 mais próximo em precisão dupla é 0,29999999999999998889… — dois números binários diferentes, e por isso 0.1 + 0.2 === 0.3 é false. Não é um bug do JavaScript: qualquer linguagem que use IEEE 754 (Python, Java, C, Go) faz igual.

A saída depende do cenário: dinheiro pede inteiros em centavos ou uma biblioteca decimal (decimal, BigDecimal, Decimal.js); comparação pede uma margem de erro, Math.abs(a − b) < ε; exibição pede toFixed(2) só no último passo; contagem pede inteiros, e a precisão dupla representa exatamente todo inteiro dentro de $\pm 2^{53}$, acima disso é hora de usar BigInt. A questão de múltipla escolha do último nível pergunta se o 0.1 armazenado é maior ou menor que o valor real, e a resposta é "maior" — basta olhar o 55511… a partir da 18ª casa da expansão exata.

Largura em bits

o painel de valores aceita 8 / 16 / 32 bits; inteiros de 64 bits e operações de bits com BigInt não entram.

Ponto flutuante

só o layout dos campos de binary32 / binary64 do IEEE 754 e a expansão decimal exata; modos de arredondamento, desempenho de subnormais, Math.fround, meia precisão e bfloat16 ficam de fora.

Semântica das operações de bits

os deslocamentos são explicados conforme o JavaScript (32 bits com sinal); em C, deslocar um negativo para a esquerda ou além da largura é comportamento indefinido, e o curso não entra nisso.

Bits de permissão

só os 9 bits básicos e a notação octal; setuid / setgid / sticky e ACL aparecem no texto, mas não no painel.

Verificação

respostas numéricas são comparadas com exatidão; no binário zeros à esquerda são aceitos (exceto nos níveis marcados como "8 bits"); o hexadecimal ignora maiúsculas e minúsculas e aceita 0x.

O que não faz

não é uma ferramenta de conversão em lote (para dados reais use "Conversor de bases" e "Calculadora chmod"), não faz análise de erro de ponto flutuante e não trata a implementação em nível de instrução de CPU.

• "1 KB = 1000 bytes" ou "= 1024 bytes": as duas formas são usadas. Discos e redes trabalham com 1000 e memória e sistemas operacionais costumam usar 1024 (o KiB da IEC). Olhe o contexto ou veja se existe um "i".
• "Negativo é o positivo com o bit mais significativo em 1": isso é a representação em sinal e magnitude, que quase nenhum hardware usa. No complemento de dois, 10000000 é −128 e não −0, e −1 é tudo 1.
• ">> é só dividir por 2": para números negativos o arredondamento é para baixo e não para zero: −5 >> 1 dá −3, enquanto Math.trunc(−5 / 2) dá −2.
• "Ponto flutuante é impreciso": todo ponto flutuante é exatamente igual a alguma fração binária; o que é impreciso é a conversão de decimal para binário. 0,5; 0,25 e 3,0 são exatos.
• "Dá para resolver valores em dinheiro com toFixed": toFixed só arredonda na exibição, e o erro das contas intermediárias já se acumulou; dinheiro deve começar em centavos inteiros.
• "JavaScript não tem inteiro, então não tem estouro": operações de bits, Int32Array e | 0 rodam em complemento de dois de 32 bits e estouram sim; e o Number perde precisão de inteiro acima de $2^{53}$.

O curso roda inteiro no navegador: conversão entre bases, operações de bits, decomposição dos campos de ponto flutuante e expansão exata são cálculos de funções puras dentro da página, sem pedir nada a servidor; o progresso fica no localStorage do seu aparelho.

• IEEE, IEEE 754-2019, IEEE Standard for Floating-Point Arithmetic — layout dos campos de binary32 / binary64, viés, valores especiais e regras de arredondamento: https://standards.ieee.org/ieee/754/6210/(consultado em 2026-09-09)
• David Goldberg, What Every Computer Scientist Should Know About Floating-Point Arithmetic, ACM Computing Surveys 23(1), 1991 — erro de arredondamento, expansão exata e o artigo clássico sobre por que o 0.1 não cabe exatamente: https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html(consultado em 2026-09-09)
• ECMA-262, ECMAScript Language Specification, o tipo Number e as operações abstratas ToInt32 / ToUint32 — a base normativa de que as operações de bits do JavaScript rodam em complemento de dois de 32 bits: https://tc39.es/ecma262/#sec-ecmascript-language-types-number-type(consultado em 2026-09-09)
• IEEE / The Open Group, POSIX.1-2024, o utilitário chmod — definição do modo simbólico e do modo octal: https://pubs.opengroup.org/onlinepubs/9799919799/utilities/chmod.html(consultado em 2026-09-09)
• IEC 80000-13:2008, Quantities and units — Part 13: Information science and technology — definição dos prefixos binários KiB / MiB / GiB: https://www.iso.org/standard/31898.html(consultado em 2026-09-09)
• Charles Petzold, Code: The Hidden Language of Computer Hardware and Software, 2ª ed., Microsoft Press, 2022 — explicação acessível do caminho que vai do interruptor ao somador e ao complemento de dois.