Fácil–medio · Dígitos

Invertir un número

Lee un entero positivo e imprímelo al revés: 1234 pasa a 4321. Combina el patrón de trocear dígitos con construir un número nuevo — y esconde un matiz de ceros finales.

En una fraseReconstruye N al revés con rev = rev * 10 + n % 10 mientras troceas n: los ceros finales desaparecen solos, así que 1200 invertido es 21, no 0021.

El problema

Entrada: un entero positivo N (1 ≤ N ≤ 10⁹).

Salida: los dígitos de N en orden inverso (los ceros a la izquierda desaparecen solos: el inverso de 1200 es 21).

Ejemplos:

Entrada	Salida
`1234`	`4321`
`1200`	`21`

Tu solución

main.cpp — tu solución

Entrada personalizada para «Ejecutar mi entrada»

La corrección corre en tu navegador contra pruebas ocultas. Un bucle infinito se corta a los 3 segundos — aun así, asegúrate de que todo bucle tenga salida. Tu código se guarda solo mientras escribes.

¿Atascado? Pistas

Pista 1 — sacar y meter

Dos movimientos por vuelta: sacar el último dígito de n con n % 10 y meterlo en el resultado: rev = rev * 10 + digit;; luego n /= 10;. Traza 1234 en papel: rev pasa por 4 → 43 → 432 → 4321.

Pista 2 — por qué 1200 se vuelve 21

Cuando el dígito sacado es 0, rev * 10 + 0 solo alarga rev — pero al final 0021 como número es simplemente 21. Los enteros no guardan ceros a la izquierda; si quisieras conservarlos, necesitarías texto (otro problema).

Solución (¡inténtalo primero!)

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    int rev = 0;
    while (n > 0) {
        rev = rev * 10 + n % 10;
        n /= 10;
    }
    cout << rev << endl;
    return 0;
}

El mismo esqueleto de Contar dígitos con una línea extra. El patrón se generaliza: palíndromos, sumas de dígitos, «¿es un número de la suerte?» — todo reutiliza sacar-y-meter. Siguiente: Número palíndromo.

Análisis profundo

Por qué funciona

rev = rev * 10 + n % 10 es exactamente la operación inversa de arrancar dígitos. Arrancar y construir juntos son el kit completo para tratar números como texto.

El coste

O(d) de tiempo, O(1) de espacio: no hace falta ningún array.

Dónde falla

1200 se convierte en 21, no en 0021: los ceros finales pasan a ser ceros a la izquierda de un int y desaparecen.
Invertir 1.000.000.009 desborda int: un int de 32 bits no puede guardar todos los valores invertidos.

Siguiente paso

Reutiliza el resultado para comparar: Número palíndromo.

Dos cosas para recordar

rev = rev * 10 + dígito construye un número dígito a dígito.
La inversión puede desbordar aunque la entrada quepa.

🐞 Esta versión falla: ábrela y pruébala

Suma los dígitos en vez de desplazarlos

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    int rev = 0;
    while (n > 0) {
        rev = rev + n % 10;
        n /= 10;
    }
    cout << rev << endl;
    return 0;
}