Fácil–medio · simulación

Pasos de Collatz

Si es par, divídelo entre dos; si es impar, multiplícalo por tres y súmale uno. Nadie sabe si todo número acaba llegando a 1, pero tu bucle puede comprobarlo para cualquier número que escribas.

En una fraseAplica n = n / 2 si n es par y n = 3n + 1 si es impar, contando pasos hasta llegar a 1: n = 1 tarda 0 pasos, el caso que todo el mundo olvida.

El problema

Entrada: Un entero n (1 ≤ n ≤ 100000).

Salida: Cuántos pasos hacen falta para llegar a 1. Si n ya es 1, imprime 0.

Ejemplos:

EntradaSalida
68
10

Para 6: 6 → 3 → 10 → 5 → 16 → 8 → 4 → 2 → 1. Cuenta las flechas: hay 8. Llegar a 1 es el final, no un paso más.

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 — La regla es el cuerpo de un bucle, no una fórmula

Aquí no hay fórmula cerrada: no puedes calcular la respuesta, tienes que recorrerla. Eso es un bucle while: transforma n y cuenta un paso por transformación.

Pista 2 — Par o impar, una rama cada uno

n % 2 == 0 significa par → n = n / 2. Si no → n = 3 * n + 1. La división entera es justo lo que quieres aquí: no hay resto del que preocuparse porque ya comprobaste que es par.

Pista 3 — El error de uno vive en la condición

Usa while (n != 1) e incrementa dentro del cuerpo. Si empiezas steps en 1, o incrementas después de imprimir, todas las respuestas se desvían en uno, y n = 1 imprimirá 1 en vez de 0.

Solución (¡inténtalo primero!) 
#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    int steps = 0;
    while (n != 1) {
        if (n % 2 == 0) n = n / 2;
        else n = 3 * n + 1;
        steps++;
    }
    cout << steps << endl;
    return 0;
}

Esta es la conjetura de Collatz: desde cualquier entero positivo la secuencia siempre parece llegar a 1, pero nadie lo ha demostrado. Tu programa es un pequeño experimento matemático: prueba con 27 y míralo subir hasta 9232 antes de bajar. Ese hábito de simular la regla y mirar los números es como se construye intuición cuando no hay fórmula. Sigue con Contar palabras.

Análisis profundo

Por qué funciona

Esta regla no tiene fórmula, así que no puedes calcular la respuesta: tienes que recorrerla. Convierte la regla en el cuerpo de un bucle y el conteo en un contador; esa es la forma universal de los problemas de simulación.

El coste

O(pasos), y nadie puede acotar los pasos en general: justo por eso la conjetura de Collatz sigue abierta. Para n ≤ 100000 se queda en los cientos.

Dónde falla

  • Empezar steps en 1, o incrementar después de imprimir, desvía todas las respuestas en uno, y n = 1 imprime 1 en vez de 0.
  • Escribir n > 1 en vez de n != 1 parece equivalente para positivos, pero en cuanto una errata manda la secuencia a negativo el bucle no puede terminar.

Siguiente paso

Ahora aplica "recuerda el estado mientras recorres" al texto: Contar palabras.

Dos cosas para recordar

  • Una regla sin fórmula se convierte en cuerpo de bucle: deja que la máquina camine.
  • Llegar al final no es un paso; la condición del bucle y el contador deben coincidir.
🐞 Esta versión falla: ábrela y pruébala

steps empieza en 1: todas las respuestas sobran uno

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    int steps = 1;
    while (n != 1) {
        if (n % 2 == 0) n = n / 2;
        else n = 3 * n + 1;
        steps++;
    }
    cout << steps << endl;
    return 0;
}