Inversão de Número Escreva um programa que dado um número, imprima na tela a sua versão invertida.
  • Exemplo: Entrada: 1234 - Saída: 4321

Passo 1

O enunciado pede que, dado um número, o programa imprima a sua versão invertida (os dígitos na ordem contrária). Informações e exemplos fornecidos:
  • Entrada: um número (no exemplo dado, 1234).
  • Saída esperada: o número com os dígitos invertidos (no exemplo, 4321).
    O que o problema exige concretamente:
  • Ler um número (assumiremos um número inteiro, positivo, negativo ou zero).
  • Imprimir o número formado pelos dígitos invertidos, sem zeros à esquerda (por exemplo, entrada 1200 deve produzir saída 21).
  • Se o número for negativo, a saída deve manter o sinal negativo e inverter apenas os dígitos (por exemplo, entrada -120 deve produzir -21).

Passo 2

Escolha do método: vou usar o método aritmético (extração de dígitos com módulo e divisão inteira). Motivo: é um método que dá entendimento matemático do que significa “inverter dígitos” sem depender de operações de string; é simples, funciona em prova sem apelar para funções prontas e é eficiente. Em resumo, pegamos o último dígito com operação de resto por 10, adicionamos esse dígito ao final do número invertido em construção, e cortamos o último dígito do número original dividindo por 10 (divisão inteira). Repetimos até o número original ficar zerado.

Passo 3

Conceitos básicos usados (explicação didática):
  • Resto da divisão por 10: para um inteiro x, o valor x \bmod 10 (escrevemos aqui simplesmente "resto por 10") dá o último dígito de x. Ex.: para x=1234, o resto por 10 é 4.
  • Divisão inteira por 10: para um inteiro x, a operação "dividir inteiro por 10" (em muitas linguagens escrita como x // 10 ou x / 10 com truncamento) remove o último dígito. Ex.: para x=1234, a divisão inteira por 10 123.
  • Construção do número invertido: manter uma variável r (de “reversed”) iniciada em 0. A cada passo, pegar o último dígito d do número restante e atualizar r como r = r \times 10 + d. Isso “anexa” d ao final de r.
Variáveis que usaremos:
  • n: número original (inteiro lido).
  • \text{sign}: valor 1 se n \ge 0 ou -1 se n < 0.
  • m: valor absoluto de n, isto é m = |n|.
  • r: número invertido em construção, inicia em 0.

Passo 4

Algoritmo (passo a passo em pseudocódigo):
  • Ler n.
  • Definir \text{sign} = 1 se n \ge 0 senão \text{sign} = -1.
  • Definir m = |n|.
  • Definir r = 0.
  • Enquanto m > 0 faça:
    • d = m \bmod 10. (pega o último dígito)
    • r = r \times 10 + d. (anexa o dígito d ao final de r)
    • m = \lfloor m / 10 \rfloor. (remove o último dígito de m)
  • No fim, resultado = \text{sign} \times r.
  • Imprimir o resultado.
    Notas: se n = 0, o loop não roda e o resultado será 0, que é correto.

Passo 5

Exemplo passo a passo com a entrada 1234 (mostrar cada iteração):
  • Inicialmente: n = 1234. Logo \text{sign} = 1, m = 1234, r = 0.
  • Iteração 1:
    • d = m \bmod 10 = 1234 \bmod 10 = 4.
    • r = r \times 10 + d = 0 \times 10 + 4 = 4.
    • m = \lfloor m / 10 \rfloor = \lfloor 1234 / 10 \rfloor = 123.
  • Iteração 2:
    • d = 123 \bmod 10 = 3.
    • r = 4 \times 10 + 3 = 43.
    • m = \lfloor 123 / 10 \rfloor = 12.
  • Iteração 3:
    • d = 12 \bmod 10 = 2.
    • r = 43 \times 10 + 2 = 432.
    • m = \lfloor 12 / 10 \rfloor = 1.
  • Iteração 4:
    • d = 1 \bmod 10 = 1.
    • r = 432 \times 10 + 1 = 4321.
    • m = \lfloor 1 / 10 \rfloor = 0.
  • O loop termina porque m = 0. Resultado final = \text{sign} \times r = 1 \times 4321 = 4321. Este é o valor que será impresso.

Passo 6

Casos especiais e observações práticas:
  • Números com zeros finais: entrada 1200 \Rightarrow processo produz 21 (os zeros finais viram zeros iniciais que não se imprimem).
  • Número zero: entrada 0 \Rightarrow saída 0.
  • Números negativos: manter o sinal e inverter apenas os dígitos; ex.: entrada -120 \Rightarrow saída -21.
  • Overflow: em linguagens como Python não há problema (inteiros de precisão arbitrária). Em linguagens como C, Java, C# pode haver overflow se o número for muito grande; nesse caso haveria que usar tipos maiores ou tratar overflow explicitamente. Para provas de algoritmo geralmente não é necessário tratar overflow a menos que o enunciado peça.
  • Entrada não inteira: o algoritmo mostrado assume entrada inteira. Se for necessário lidar com números decimais (com vírgula/ponto), o problema muda (especificar regra de inversão para parte decimal).

Passo 7

Tradução do algoritmo para um programa mínimo em Python (explicação das linhas):
  • Ler a linha com input, converter para inteiro com int().
  • Guardar o sinal e trabalhar com o valor absoluto.
  • Laço while para extrair dígitos e construir r.
  • Imprimir o resultado final com o sinal.

Passo 8

Dicas para a prova (rápidas e motivadoras):
  • Se estiver sem tempo, a solução por string (converter para string e inverter) é muito rápida de escrever: por exemplo, em Python s[::-1] inverte a string, cuidando do sinal separadamente. Mas em prova de algoritmos às vezes preferem ver a solução aritmética.
  • Faça testes simples no papel antes de submeter: 1234, 1200, -305, 0.
  • Respire: o algoritmo é curto e tem poucos casos especiais. Você já sabe fazer!

Resposta

# Programa que lê um inteiro e imprime sua versão invertida (mantendo sinal)
n = int(input().strip())
sign = 1 if n >= 0 else -1
m = abs(n)
r = 0
while m > 0:
    d = m % 10
    r = r * 10 + d
    m //= 10
print(sign * r)

Exercícios relacionados