Escreva um programa que solicita ao usuário um número inteiro de 4 algarismos e o programa imprime na tela o seu valor invertido.
Observação: as mensagens exibidas para o usuário deverão ser exatamente como apresentado abaixo (mensagens exibidas com os comandos input() e print()).

Exemplo de execução do programa:

Digite um inteiro de 4 algarismos: 1234
Valor invertido: 4321

Passo 1

O enunciado pede que o programa solicite ao usuário um inteiro de 4 algarismos e imprima na tela o seu valor invertido. As mensagens exibidas devem ser exatamente as seguintes:
  • Ao pedir a entrada: "Digite um inteiro de 4 algarismos: "
  • Ao mostrar o resultado: "Valor invertido: " seguido do número invertido.
Informações importantes que temos do enunciado:
  • O usuário vai digitar um inteiro de 4 algarismos (por exemplo, 1234).
  • O programa deve mostrar na tela o inteiro com os algarismos em ordem invertida (por exemplo, 4321 para entrada 1234).
  • As mensagens devem estar exatamente como no enunciado (maiúsculas, espaços e pontuação).

Passo 2

Escolha do método: existem duas formas simples de inverter os algarismos de um inteiro em Python:
  1. Usar operações aritméticas (divisão inteira e resto — método matemático).
  2. Tratar o número como texto (string) e inverter a string.
Vou usar o método aritmético porque ele mostra claramente como extrair cada algarismo — é uma técnica que aparece bastante em provas e trabalhos e não depende de funções de string. Depois eu explico rapidamente a alternativa por string, para você ter mais uma opção rápida.

Passo 3

Conceitos necessários (explicados com calma):
  • Resto da divisão (operador “módulo”): para inteiros, n \bmod 10 dá o último algarismo de n. Em Python isso é feito com n \% 10.
    • Exemplo: se n=1234, então 1234 \bmod 10 = 4.
  • Divisão inteira: \lfloor n/10\rfloor (em Python, n // 10) remove o último algarismo de n.
    • Exemplo: 1234 // 10 = 123.
      Combinar os dois permite pegar cada algarismo, do último para o primeiro.

Passo 4

Como extrair os 4 algarismos de um inteiro n (assumindo que n tem exatamente 4 algarismos positivos):
  • Defina os algarismos como a, b, c, d, onde a é o algarismo das milhares (o primeiro) e d é o algarismo das unidades (o último). Para n=1234: a=1, b=2, c=3, d=4.
  • Fórmulas para obter cada algarismo:
    • d = n \bmod 10.
    • c = \big\lfloor \dfrac{n}{10} \big\rfloor \bmod 10.
    • b = \big\lfloor \dfrac{n}{100} \big\rfloor \bmod 10.
    • a = \big\lfloor \dfrac{n}{1000} \big\rfloor.
      Em Python, usando divisão inteira e módulo, isso fica respectivamente:
  • d = n \% 10
  • c = (n // 10) \% 10
  • b = (n // 100) \% 10
  • a = n // 1000

Passo 5

Como montar o número invertido a partir desses algarismos:
  • Se os algarismos originais são a,b,c,d (em ordem de maior para menor peso), o número original vale
n = 1000a + 100b + 10c + d.
  • O número invertido (com os algarismos na ordem d,c,b,a) vale
\text{invertido} = 1000d + 100c + 10b + a.
Portanto, depois de extrair a,b,c,d, basta calcular \text{invertido}=1000d+100c+10b+a.

Passo 6

Passo a passo numérico com exemplo n=1234:
  • d = 1234 \bmod 10 = 4.
  • c = (1234 // 10) \bmod 10 = 123 \bmod 10 = 3.
  • b = (1234 // 100) \bmod 10 = 12 \bmod 10 = 2.
  • a = 1234 // 1000 = 1.
  • \text{invertido} = 1000\cdot 4 + 100\cdot 3 + 10\cdot 2 + 1 = 4000 + 300 + 20 + 1 = 4321.
    Isso produz exatamente o resultado do exemplo do enunciado.

Passo 7

Implementação em Python (explicando cada linha):
  • Ler a entrada do usuário e converter para inteiro:
    • n = int(input("Digite um inteiro de 4 algarismos: "))
  • Extrair os algarismos com operações inteiras:
    • a = n // 1000 # milhares
    • b = (n // 100) % 10 # centenas
    • c = (n // 10) % 10 # dezenas
    • d = n % 10 # unidades
  • Calcular o invertido:
    • invertido = d*1000 + c*100 + b*10 + a
  • Mostrar o resultado exatamente no formato exigido:
    • print("Valor invertido: {}".format(invertido))
Observações finais e dicas de prova:
  • Em prova, escreva claramente como extraiu cada dígito usando divisão inteira e módulo, e então mostre a expressão para recompor o número invertido.
  • Se quiser uma solução alternativa curta (não necessária agora), pode inverter a string: ler como s = input(...) e usar s[::-1] para inverter os caracteres; aí imprimir print("Valor invertido: " + s[::-1]). Essa solução preserva zeros à esquerda no resultado (por exemplo, entrada 1200 → saída 0021), enquanto a versão aritmética dá 21 (sem zeros iniciais). Escolha a que o enunciado pedir; no caso aqui não foi especificado o tratamento de zeros iniciais, então a abordagem aritmética é a mais comum.

Resposta

n = int(input("Digite um inteiro de 4 algarismos: "))
a = n // 1000
b = (n // 100) % 10
c = (n // 10) % 10
d = n % 10
invertido = d1000 + c100 + b*10 + a
print(“Valor invertido: {}”.format(invertido))

Exercícios relacionados