O resto da divisão é a única coisa que importa
A gente vê muita gente complicando isso à toa. A pergunta como saber se um numero é multiplo de outro tem uma resposta que cabe em uma linha, mas o caminho que as pessoas escolhem pra chegar lá às vezes é de doer. O conceito básico é simples: um número a é múltiplo de b quando a divisão de a por b deixa resto zero. Não tem segredo, não tem mágica. Só isso. No dia a dia, isso aparece em programação, em matemática financeira, às vezes num trabalho escolar que todo mundo quer transformar num problema existencial. A regra prática é a seguinte: pegue o número que você quer testar, divida pelo número-base e veja se o resto é exatamente zero. Se for, é múltiplo. Se não for, não é. Ponto.
Como saber se um numero é multiplo de outro na prática
A operação que resolve isso aqui se chama modulo. Em quase toda linguagem ou calculadora que existe, o símbolo é %. Você faz a % b e se o resultado vier zero, pronto. Você achou um múltiplo. Vou dar um exemplo rápido sem rodeio. Quer saber se 144 é múltiplo de 12? 144 dividido por 12 dá 12 exato, resto zero. É múltiplo. Quer saber se 150 é múltiplo de 12? 150 dividido por 12 dá 12 com resto 6. Não é. Fim de papo.
Em código, fica literalmente assim: if numero % divisor == 0: print("é múltiplo")
Só isso. Se alguém te vender um algoritmo mais longo que isso pra coisa simples, desconfie. A maioria dessas pessoas tá enchendo linguiça pra parecer inteligente ou pra vender curso. Tem uma pegadinha que todo mundo esbarra pela primeira vez: zero. Zero é múltiplo de qualquer número inteiro diferente de zero. Isso parece contra-intuitivo pra muita gente porque a intuição fala "zero não divide nada", mas na definição formal, zero dividido por qualquer coisa dá zero com resto zero. Então, sim, zero é múltiplo de 7, de 13, de 100. O que não existe é dividir por zero. Isso quebra tudo, em matemática e em programação.
No Python, se você tentar fazer algo % 0, recebe ZeroDivisionError na cara. No JavaScript, o resultado é NaN. Em C e C++, é comportamento indefinido, o que é o jeito elegante da linguagem dizer "você fez algo muito errado e agora depende da sua sorte". Na minha experiência, os bugs mais chatos que já vi na vida profissional começaram com alguém que não tratou o divisor zero antes de aplicar o módulo.
Números negativos e a regra que ninguém conta
Aqui tem um detalhe que muita gente não leva a sério até se ferrarr. Sinais negativos no módulo se comportam de forma inconsistente entre linguagens. Isso não é um pitaco, é algo que você vai encontrar no relatório de erro às 3 da manhã. Em Python, -12 % 5 retorna 3, porque o resto segue o sinal do divisor. Já em C e Java, -12 % 5 retorna -2, porque o resto herda o sinal do dividendo. O ponto importante não é a regra em si, mas o fato de que o teste de múltiplo continua funcionando independentemente do sinal. Tanto faz o resto vir 3, -2, ou outra coisa: se for zero, é múltiplo. Se não for, não é.
Eu perdi duas horas num script de validação de dados porque assumi que o resto de negativo seria sempre igual em todas as plataformas. O dado vinha de uma API em Go, eu processei num ambiente Python, e o código que eu tinha escrito confiava no sinal do resto pra tomar uma decisão secundária. A validação principal, que era só resto == 0, funcionou em todo lugar. Mas o resto da lógica desmontou. Desde aí, eu nunca mais confio em comportamento de resto com negativos entre linguagens diferentes sem verificar a documentação. Leva dois minutos e economiza horas de caça-bug.
Atalhos matemáticos que valem a pena conhecer
O operador módulo resolve 99% dos casos. Mas existem regras de divisibilidade que permitem testar múltiplos sem fazer a conta completa. Elas são úteis quando você tá na mão, sem calculadora, ou num contexto onde o custo de uma divisão inteira é alto. Divisibilidade por 2: o último dígito é par. Isso é tão básico que até criança sabe, mas já vi adulto passar cinco minutos pra saber se 384 é divisível por 2.
👉 Clique no botão abaixo para saber mais sobre o assunto!
Por 3: some os dígitos. Se o resultado for divisível por 3, o número original também é. 273: 2 mais 7 mais 3 dá 12. 12 é divisível por 3. Então 273 também é. Por 4: olhe os dois últimos dígitos. Se formarem um número divisível por 4, o todo é divisível por 4. 1.348: os dois últimos são 48. 48 é múltiplo de 4. Pronto.
Por 5: termina em 0 ou 5. Quase impossível errar. Por 9: mesma regra do 3, mas com 9. Some os dígitos e veja se some um múltiplo de 9.
Por 10: termina em zero. Simples assim. Tem regra pra 7 também, mas ela é tão desconfortável que eu só uso quando estou forçado. Divide pelo dobro do último dígito, subtrai do resto, e repete. Funciona, mas a vantagem prática équestionável perto de simplesmente rodar um módulo.
Essas regras são bonitas academicamente, mas têm limitações reais. Elas funcionam bem para números pequenos ou médios. Quando o número tem dezenas de dígitos, como em criptografia RSA, essas técnicas manuais viram piada. Nesses casos, o que se usa de verdade é fatoração prime, e isso é outro problema completamente diferente, NP-difícil na prática pra números grandes demais.
Armadilhas comuns que custam tempo
Uma das coisas mais frequentes é confundir múltiplo com divisor. Múltiplo é o resultado da multiplicação. Divisor é o número pelo qual você divide. Se você pergunta se 12 é múltiplo de 4, a resposta é sim, porque 4 vezes 3 dá 12. Se você pergunta se 4 é múltiplo de 12, a resposta é não. As pessoas invertem isso o tempo todo, especialmente quando estão cansadas ou sob pressão. Outro erro clássico é tratar float como se fosse exato. Em programação, se você trabalha com números decimais e aplica módulo, erros de precisão podem fazer um resto que deveria ser zero vir algo como 1.42108547e-15. Isso acontece com frequência em linguagens que usam ponto flutuante IEEE 754. A solução prática é usar uma tolerância, um epsilon, ao invés de comparar com zero diretamente. Em Python, por exemplo, math.isclose(resultado, 0, abs_tol=1e-9) resolve a maior parte dessas situações sem complicação.
Eu já vi gente usar floor(a / b) * b == a como alternativa ao módulo. Tecnicamente funciona pra inteiros, mas é mais lento, menos legível, e ainda assim quebra com negativos e floats da mesma forma. Não recomendo. A não ser que você esteja num ambiente extremamente restrito onde módulo não está disponível, o que é raro hoje em dia.
Quando o módulo não é a melhor ferramenta
Existe um cenário onde o teste direto de módulo simplesmente não serve: números extremamente grandes. Eu Working com dados de blockchain, já enfrentei números com centenas de dígitos decimais. Rodar uma divisão completa nesses casos consome memória e tempo desnecessários quando o objetivo é só saber se é múltiplo de algo pequeno, como 2, 3, ou 9. Nesses casos, as regras de divisibilidade acima ganham outro nível de importância. Testar se um número de 200 dígitos é divisível por 3 analisando a soma dos dígitos é infinitamente mais rápido que tentar dividir esse número enorme por 3 diretamente. A economia aqui não é em segundos, é em ordens de grandeza. Em processos batch que rodam milhões de verificações, isso se traduz em horas de processamento economizadas.
Se o seu divisor também é enorme, aí a coisa muda de figura. Fatoração em primos, algoritmo de Euclides estendido, e técnicas de criptografia entram em cena. Isso já não cabe numa resposta curta e exige ferramentas como o gmpy2 no Python ou bibliotecas similares em outras linguagens. Mas isso é um tópico separado.
Um resumo sem pretensão de resumo
Para a maioria absoluta das situações, usar o operador módulo e verificar se o resto é zero é o caminho certo. É rápido, é claro, e funciona desde que você trate os casos de divisor zero e não confie cegamente em floats. As regras de divisibilidade manual são ferramentas válidas em contextos específicos, principalmente quando a operação direta se torna proibitivamente cara ou quando você não tem acesso a uma linguagem de programação no momento. O erro mais comum é trocar a ordem dos termos ou achar que existem atalhos místicos além do que a aritmética básica já oferece. O resto da divisão é o que determina tudo. O resto zero é múltiplo. O resto diferente de zero não é. Tudo que vem depois disso é refinamento.
