Como Saber Se Um Numero É Multiplo De Outro

A regra básica, mas com detalhes que as pessoas costumam ignorar

Para saber se um número é múltiplo de outro, você divide o primeiro pelo segundo e vê se o resto é zero. Isso é tudo. A função MOD ou operador % em programação faz exatamente isso. Se 12 % 3 == 0, então 12 é múltiplo de 3. Se não for, não é. O resto da divisão euclidiana é a única coisa que importa aqui. Muita gente complicando porque acha que precisa de algo mais avançado. Não precisa. Divisão com resto zero é o critério completo e definitivo.

como saber se um numero é multiplo de outro na prática

Na prática, você vai usar isso em código, em planilhas, ou de cabeça para números pequenos. Em Python, por exemplo, é literalmente a % b == 0. Em Excel, =RESIDUO(A1;B1). Em JavaScript, o mesmo %. O operador de resto existe em praticamente qualquer linguagem que tenha aritmética inteira, e o comportamento é padronizado desde os anos 1970. Não há ambiguidade quando ambos os operandos são inteiros positivos. Aqui vai algo que ninguém ensina: o problema real aparece com números negativos e com ponto flutuante. O resto da divisão de -12 % 5 pode retornar -2 ou 3 dependendo da linguagem e do padrão de arredondamento. Em Python o resultado segue o divisor (-12 % 5 == 3), mas em C e Java o sinal do resto herda o dividendo (-12 % 5 == -2). Se o seu código precisa funcionar em múltiplas plataformas, não confie cegamente no operador % com negativos. Use uma função de módulo euclidiano própria: ((a % b) + b) % b. Isso normaliza o resto para sempre ficar entre 0 e b-1, independentemente da linguagem. Com ponto flutuante, a situação é pior. 0.1 + 0.2 não é exatamente 0.3 em IEEE 754. Então verificar se um float é múltiplo de outro float pode falhar de formas estranhas. Se você está trabalhando com valores decimais que deveriam ser inteiros (preços, medidas, timestamps convertidos), use uma tolerância epsilon ou, melhor ainda, trabale com inteiros desde o início multiplicando por uma potência de 10. Eu gastei duas semanas rastreando um bug em um sistema de faturamento onde valores em reais estavam sendo comparados com % depois de passarem por conversões sucessivas de float. O problema era que 49.99 não era representável exatamente, e o resto da divisão por 0.01 dava algo como 0.009999999999997. Troquei tudo para centavos inteiros e o bug sumiu imediatamente.

Atalhos mentais que valem a pena memorizar

Divisibilidade por 2: o último dígito é par. Por 5: termina em 0 ou 5. Por 10: termina em 0. Por 3 e por 9: some todos os dígitos; se a soma for divisível por 3 (ou 9), o número original também é. Por 11: some dígitos em posições pares e ímpares separadamente; se a diferença entre essas somas for múltipla de 11, o número é divisível por 11. Esses atalhos são úteis para verificação rápida sem calculadora, mas têm limitações sérias. Eles funcionam porque o sistema numérico é decimal e as bases 3, 9 e 11 têm relações específicas com 10. Não existe um atalho universal para qualquer divisor arbitrário. Se você precisa verificar divisibilidade por 7, 13, 17, ou qualquer primo maior que 11, a divisão direta ou o operador módulo é o caminho. O atalho para 7 existe (dobrar o último dígito e subtrair do resto, repetir), mas é mais lento que simplesmente fazer a divisão na maioria dos casos práticos. Um detalhe técnico importante que programadores juniores frequentemente passam por alto: em linguagens com tipos inteiros de largura fixa, operações de módulo em valores muito grandes podem estourar antes mesmo de chegar ao resultado. Em C, por exemplo, long long vai até 2^63-1. Se você está processando números gerados por alguma função criptográfica ou hash que produz valores maiores que isso, precisará de uma biblioteca de aritmética de grande precisão ou implementar o módulo passo a passo digitando o número como string. Li uma vez um colega tentar calcular fib(100000) % 1000000007 usando inteiros de 64 bits e o programa simplesmente retornava valores absurdo porque o número de Fibonacci já tinha transbordado o tipo muito antes do módulo. A solução correta era aplicar o módulo em cada passo da recursão, usando a propriedade (a * b) % m = ((a % m) * (b % m)) % m. Isso mantém os números sempre dentro da faixa do tipo.

Quando o método simplesmente não funciona

O operador de resto falha de forma silenciosa quando o divisor é zero. Isso é óbvio, mas em códigos reais eu vejo gente passando variáveis de configuração que vêm de um arquivo ou rede, sem validar se o valor é não-nulo. Uma exceção de divisão por zero mata o processo ou retorna NaN, e aí você perde horas rastreando onde a dados entrou com valor inválido. Sempre valide o divisor antes de chamar o módulo. Em Python isso lança ZeroDivisionError, em JavaScript retorna NaN, em Java lança ArithmeticException. O comportamento é inconsistente entre linguagens, o que torna essa validação ainda mais crítica em sistemas multi-linguagem. Outro caso onde o conceito de múltiplo perde o sentido é com frações e irracionais. Zero é múltiplo de qualquer número inteiro não nulo, mas nenhum número não nulo é múltiplo de zero. Isso parece trivial até alguém tentar implementar uma lista de múltiplos começando do zero e se confundir com a definição. E números irracionais como não têm múltiplos inteiros no sentido tradicional — você pode perguntar se um número racional é múltiplo de , mas a resposta é sempre "não" exceto para o zero, e a pergunta em si normalmente indica um erro de modelagem. Se você precisa verificar múltiplos em contextos onde a precisão decimal é fundamental (financeiro, científico, engenharia), considere usar bibliotecas de aritmética decimal em vez de ponto flutuante nativo. Python tem decimal.Decimal, JavaScript tem bibliotecas como bignumber.js, e em C++ existem várias opções como GMP e MPFR. O custo de performance existe — operações decimais são tipicamente 10 a 100 vezes mais lentas que inteiros — mas para verificações de divisibilidade que acontecem esporadicamente, essa diferença é irrelevante comparada ao custo de bugs silenciosos.

No final das contas, saber como saber se um numero é multiplo de outro se resume a entender o que o operador de resto faz, saber onde ele falha, e escolher a ferramenta certa para o contexto. Não tem mágica. Divisão com resto zero é o conceito, resto zero é a verificação, e o resto (perdoe o trocadilho) é toda a implementação.