O básico que todo mundo deveria saber antes de complicar
Se você está perguntando isso, provavelmente precisa de uma resposta rápida para algum script, planilha ou validação de formulário. A coisa é simples: 25 dividido por 2 dá 12 com resto 1. Não cabe jeito, o número 25 é par ou ímpar tem resposta única e já era.
Como verificar na prática
A regra operativa é sempre a mesma: pegue o número, divida por dois e veja se sobra algo. Se sobrar 1, é ímpar. Se sobrar 0, é par. Em Python você escreve 25 % 2 e recebe 1. Em JavaScript, a mesma coisa. Em SQL, 25 MOD 2. Funciona em qualquer linguagem razoável que eu já tenha enfrentado. Tem uma pegadinha que ninguém avisa no tutorial introdutório. Números negativos também seguem a mesma lógica, mas a implementação do operador módulo varia entre linguagens. Em Python, -25 % 2 retorna 1. Em C e Java, pode retornar -1 dependendo do compilador. Se o seu código precisa lidar com negativos e você está usando C-like, esse detalhe já me custou uma noite de depuração em um sistema de loteria que processava entradas aleatórias de jogadores.
O meu workaround foi simples: criar uma função helper que normaliza o resto antes de testar paridade. Em vez de confiar no comportamento nativo do operador módulo, eu fazia abs(n) % 2. O abs resolve o problema de forma determinística e o resto do código não precisa saber que a linguagem está fazendo algo diferente por baixo dos panos. Funciona há anos sem surpresas. Outro ponto que passa batido: números muito grandes. Quando você trabalha com aritmética de precisão arbitrária — BigInt em JavaScript, BigInteger em Java, ou a biblioteca GMP em C — a verificação de paridade ainda é O(1), porque só importa o último dígito binário. Não há necessidade de dividir o número inteiro por dois. Basta checar o bit menos significativo. Em binário, 25 é 11001, e o último bit é 1, então é ímpar. Isso economiza operações em ciclos tight de processamento em lote, especialmente quando você está Validando milhões de IDs de transação por segundo.
👉 Clique no botão abaixo para saber mais sobre o assunto!
Se o seu contexto é validação de formulário web, a verificação no front-end é conveniente mas não segura. Alguém pode enviar um payload bruto contendo 24. A validação real precisa rodar no back-end, e aí você usa a mesma lógica acima com os dados que realmente vieram da requisição. Eu vi gente colocar a validação só no JavaScript do navegador e depois levar dados corrompidos pro banco de dados durante um evento de alta demanda. O resultado foi fila de processamento travada por dados que não satisfaziam o formato esperado.
Quando essa verificação sai pela culatra
A paridade é um conceito tão básico que as pessoas esquecem de considerar casos onde ela não se aplica. Números decimais, frações, valores Float que vieram de divisão anterior — tudo isso entra numa zona cinzenta. Por exemplo, 25.0 em muitos sistemas de tipagem dinâmica pode passar por uma função que espera inteiro e gerar erro de casting silencioso, dependendo da linguagem. Sempre verifique se o tipo é efetivamente integer antes de chamar a lógica de paridade. Outro caso que quebra bastante gente é hashcode e indexação de arrays. Às vezes você usa paridade para determinar se um elemento vai pro bucket par ou ímpar de uma estrutura customizada. Se o hash não está bem balanceado, você acaba com buckets desproporcionais e a operação que deveria ser O(1) vira O(n) em prática. A solução não é abandoning a paridade, mas sim usar um hash mais uniforme antes de aplicar o módulo.
Se o seu problema envolve gerar números pares ou ímpares em sequência — algo comum em sistemas de ticketing ou filas — evite simplesmente incrementar e verificar paridade repetidamente. É mais barato manter um flag booleano que alterna a cada iteração. Custa um bit de memória e elimina o operador módulo completamente do loop. Em batch processes que rodam milhares de iterações por segundo, essa economia parece pequena mas se acumula rápido.
