Faça um programa em que o usuário digite um número qualquer (com ou sem casa decimal) e o programa retorne se o número é inteiro ou não; caso o número digitado seja inteiro, retorne se ele é par ou ímpar.

Passo 1

O que o programa deve fazer (em linguagem bem direta, para eu entender o pedido):
  • Eu digito um número qualquer (pode ter casas decimais ou não).
  • O programa deve dizer se o número digitado é inteiro ou não.
  • Se o número for inteiro, o programa deve também dizer se ele é par ou ímpar.
Informações relevantes que o enunciado dá:
  • Entrada: uma string que representa um número digitado pelo usuário.
  • Saída: mensagem textual indicando “inteiro” ou “não inteiro”; se for inteiro, também indicar “par” ou “ímpar”.
Observação importante sobre a entrada: eu posso digitar o número usando vírgula (por ex.: 3,5) ou ponto (por ex.: 3.5), então é preciso tratar isso antes de converter para número.

Passo 2

Como interpretar “número inteiro” de forma prática:
  • Um número real x é inteiro quando sua parte fracionária é zero. Em outras palavras, x é inteiro se existir um inteiro n tal que x = n.
  • Em código, uma forma simples e direta de testar isso (em muitas linguagens) é verificar se a parte fracionária é zero. Em Python, por exemplo, um número em ponto flutuante x tem o método x.\text{is\_integer()} que retorna True quando a parte fracionária é zero.
  • Exemplos para fixar: 3{,}0 é inteiro; 3{,}5 não é inteiro; -2{,}0 é inteiro.

Passo 3

O que é “par” e “ímpar” (explicação simples e visual):
  • Um inteiro n é par se ele for divisível por 2, isto é, se n \bmod 2 = 0.
  • Caso contrário, n é ímpar (ou seja, n \bmod 2 = 1 para inteiros não-negativos; para negativos o resto em Python funciona igualmente: por ex. -3 \bmod 2 = 1 em sentido de paridade).
  • Exemplos: 4 é par porque 4 \bmod 2 = 0. 7 é ímpar porque 7 \bmod 2 = 1.
Aqui explico o operador resto (módulo) de forma bem prática: a \bmod b significa “o que sobra da divisão inteira de a por b”. Para testar paridade, só nos interessa b=2.

Passo 4

Decisões de implementação (por que escolhi essa abordagem que vou usar):
  • Linguagem: vou usar Python porque é simples, muito usado em prova/programa introdutório e fácil de entender.
  • Tratamento de vírgula/ponto: como eu posso digitar com vírgula, vou primeiro substituir vírgula por ponto antes de converter para número.
  • Conversão: vou tentar converter a string para um número de ponto flutuante (tipo float). Se a conversão falhar, mostro uma mensagem de entrada inválida.
  • Teste de inteiro: usar x.\text{is\_integer()} é a maneira mais direta em Python para saber se a parte fracionária é zero.
  • Teste de paridade: uma vez que eu sei que x é inteiro, converto para inteiro com \text{int}(x) e uso o operador módulo: n \bmod 2 (em Python: n \% 2).
Por que isso funciona na prova:
  • É simples, funciona para entradas como 3, 3{,}0, 3.5, -4, 1e3 (notação científica).
  • É legível e fácil de explicar durante a correção.

Passo 5

Passo a passo do algoritmo (pseudocódigo bem mastigado que eu posso escrever na prova):
  1. Ler a string digitada pelo usuário e guardar em, por exemplo, s.
  2. Substituir vírgula por ponto: s \leftarrow s com ‘,’ trocado por ‘.’.
  3. Tentar converter s para número de ponto flutuante x. Se der erro, imprimir “Entrada inválida” e terminar.
  4. Se x.\text{is\_integer()} = \text{True}, então:
    • Converter n \leftarrow \text{int}(x).
    • Calcular r \leftarrow n \bmod 2.
    • Se r = 0, imprimir “O número é inteiro e par”.
    • Caso contrário, imprimir “O número é inteiro e ímpar”.
  5. Caso x.\text{is\_integer()} = \text{False}, imprimir “O número não é inteiro”.

Passo 6

Cuidados e detalhes que posso comentar na prova (coisas que avaliam atenção):
  • Entradas com vírgula: preciso fazer a substituição para que a função de conversão aceite.
  • Entradas inválidas: devo tratar exceção de conversão e avisar o usuário em vez de quebrar o programa.
  • Conversão para inteiro: é seguro fazer \text{int}(x) só depois de garantir que x é inteiro (ou seja, que x.\text{is\_integer()} = \text{True}), para evitar perda de precisão inesperada.
  • Paridade funciona para números negativos: por exemplo, -4 é par porque -4 \bmod 2 = 0; -3 é ímpar.

Passo 7

Exemplos de execução (para eu testar mentalmente ou na prática):
  • Se eu digitar 3 → saída: “O número é inteiro e ímpar”.
  • Se eu digitar 2{,}0 → saída: “O número é inteiro e par”.
  • Se eu digitar 2{,}5 → saída: “O número não é inteiro”.
  • Se eu digitar -7 → saída: “O número é inteiro e ímpar”.
  • Se eu digitar “abc” → saída: “Entrada inválida, digite um número válido.”

Passo 8

Agora que entendemos tudo, aqui está o programa em Python pronto para usar. Ele implementa exatamente o algoritmo explicado e trata vírgula/ponto e entradas inválidas. O código está na seção de resposta final conforme pedido.

Resposta

def main():
    s = input("Digite um número: ").strip()
    # aceita vírgula como separador decimal
    s = s.replace(",", ".")
    try:
        x = float(s)
    except ValueError:
        print("Entrada inválida. Digite um número válido.")
        return

    if x.is_integer():
        n = int(x)
        if n % 2 == 0:
            print("O número é inteiro e par.")
        else:
            print("O número é inteiro e ímpar.")
    else:
        print("O número não é inteiro.")

if __name__ == "__main__":
    main()

Exercícios relacionados