Número de Harshad Um número de Harshad (ou Niven) é um número inteiro divisível pela soma dos seus próprios dígitos. Implemente um programa que faça esta verificação.
Exemplo: 18 é Harshad pois 1+8=9, e 18 é divisível por 9 .

Passo 1

O que o enunciado pede e quais informações temos:
  • Pede-se implementar um programa que verifique se um inteiro é um número de Harshad (também chamado de Niven).
  • A definição: um inteiro positivo n é Harshad se ele for divisível pela soma dos seus dígitos.
  • Entrada esperada: um inteiro n (o enunciado não especifica limites, então vamos tratar inteiros com sinal; explicito comportamento para casos especiais abaixo).
  • Saída esperada: uma indicação se n é Harshad ou não (o formato exato de saída cabe ao programa; no final vou fornecer uma implementação que imprime uma resposta legível).

Passo 2

Ideia matemática e critério de verificação (fórmula principal):
  • Seja n o número dado e seja S(n) a soma dos dígitos de n.
  • O critério é:
\text{\(n\) é Harshad} \iff n \bmod S(n) = 0.é
  • Observação: se S(n)=0 a expressão n \bmod S(n) é indefinida (divisão por zero). Isso ocorre somente quando todos os dígitos de n são zeros, ou seja, quando n=0. Portanto precisamos tratar n=0 separadamente.

Passo 3

Como calcular S(n) (duas maneiras, explicadas passo a passo):
  • Método 1 (usando string): converter n para string, percorrer cada caractere, converter de volta para inteiro e somar. É direto e legível.
  • Método 2 (usando aritmética inteira): repetir enquanto n>0:
    • pegar o último dígito com d = n \bmod 10,
    • acumular s \leftarrow s + d,
    • remover o último dígito com n \leftarrow \lfloor n / 10 \rfloor (em programação inteira: n //= 10).
    • No final s é S(n).
  • Exemplo numérico detalhado (para ver “na prática”): n=18.
    • Começando com n=18: último dígito d=18 \bmod 10 = 8. Soma parcial s=8. Atualiza n \leftarrow 18//10 = 1.
    • Agora n=1: d=1 \bmod 10 = 1. Soma s=8+1=9. Atualiza n \leftarrow 1//10 = 0.
    • Para n=18 obtivemos S(18)=9. Verificação: 18 \bmod 9 = 0 → 18 é Harshad.

Passo 4

Decisões de implementação e tratamento de casos especiais (o que meu programa fará):
  • Se a entrada n for negativa, faz sentido usar o valor absoluto para testar Harshad, porque os dígitos de -18 são os mesmos de 18. Então usarei m = |n| para computar S(m).
  • Caso m=0: todos os dígitos são zero e S(m)=0. A divisão por zero é indevida, então o programa deve escolher um comportamento. Vou optar por considerar que 0 NÃO é Harshad (porque a definição exige divisibilidade por soma dos dígitos, e a soma é zero — não se pode dividir). O programa tratará esse caso imprimindo que não é Harshad.
  • Para m>0: calcular S(m) e verificar m \bmod S(m) = 0. Se sim, imprimir que é Harshad; caso contrário, imprimir que não é Harshad.

Passo 5

Complexidade e justificativa prática (o que esperar sobre tempo/uso de memória):
  • Calcular a soma dos dígitos percorre cada dígito uma vez: se k é o número de dígitos de n, o tempo é O(k). Como k \approx \lfloor\log_{10} n\rfloor + 1, isso é muito rápido.
  • Uso de memória é constante O(1) (apenas algumas variáveis auxiliares).
  • Portanto o método é eficiente e adequado mesmo para números grandes (desde que caibam no tipo inteiro usado).

Passo 6

Sugestões de entradas e saídas de teste (para validar o programa):
  • Entrada 18 → soma dos dígitos 9, 18 \bmod 9 = 0 → saída: Harshad.
  • Entrada 19 → soma 1+9=10, 19 \bmod 10 = 9 \neq 0 → saída: não Harshad.
  • Entrada -18 → tratar como 18 → saída: Harshad.
  • Entrada 0 → soma 0, divisão indefinida → saída: não Harshad (conforme escolha aqui).
    Esses testes cobrem casos normais, negativo e o caso limite zero.

Passo 7

Boas práticas na implementação:
  • Validar a leitura da entrada (tratar espaços, fim-de-linha).
  • Usar funções pequenas: por exemplo uma função que recebe um inteiro e retorna True/False se é Harshad — facilita testar e reutilizar.
  • Evitar dividir por zero checando S(n) antes de testar a divisibilidade.
  • Escolhi apresentar a saída em português com mensagens claras: imprimir exatamente “Harshad” quando for e “Nao Harshad” quando não for (evitei acento em “Nao” para compatibilidade com diferentes terminais).

Resposta

# Programa em Python que verifica se um número é Harshad (Niven)
# Lê um inteiro da entrada e imprime "Harshad" ou "Nao Harshad"

import sys

def eh_harshad(n: int) -> bool:
    m = abs(n)
    if m == 0:
        return False  # definição: tratar 0 como não Harshad (evita divisão por zero)
    s = 0
    while m > 0:
        s += m % 10
        m //= 10
    if s == 0:
        return False
    return abs(n) % s == 0

def main():
    data = sys.stdin.read().strip()
    if not data:
        return
    try:
        n = int(data.split()[0])
    except ValueError:
        print("Entrada invalida")
        return
    if eh_harshad(n):
        print("Harshad")
    else:
        print("Nao Harshad")

if __name__ == "__main__":
    main()

Exercícios relacionados