Principiante · bucles

Cuenta atrás

Todos los bucles que has escrito empezaban en 1 y subían. Nada lo exige: el inicio, la condición y el paso son tres decisiones independientes, y este problema cambia dos de ellas.

En una frase<code>for (int i = n; i >= 1; i--)</code> escribe cada i separado por un espacio y un salto de línea al final.

El problema

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

Salida: Desde n hasta 1, separados por un solo espacio, en una línea.

Ejemplos:

Entrada	Salida
`5`	`5 4 3 2 1`
`1`	`1`

El ejemplo con n = 1 importa: es el caso donde el bucle corre exactamente una vez y ninguna lógica de separadores puede fallar. Si ese falla, el bug está en los límites del bucle, no en los espacios.

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 — Voltea las tres partes

Contar hacia arriba era i = 1; i <= n; i++. Hacia abajo es i = n; i >= 1; i-- — empieza alto, continúa mientras sea al menos 1, baja de uno en uno. Dos cambios: la dirección de la comparación y el signo del paso. Deben cambiar juntos o el bucle nunca termina.

Pista 2 — Espacios entre, no detrás

Imprime un espacio antes de cada número salvo el primero — o imprime el número y un espacio para todos menos el último. Ambas sirven; lo que falla es poner espacio tras todos incluido el último, si el juez recorta de forma inconsistente. Este sitio recorta el final de línea, pero el hábito es correcto.

Pista 3 — La trampa de n = 1

Con n = 1 el bucle corre una vez e imprime un número sin separadores. Cualquier lógica que asuma «al menos dos elementos» se rompe aquí. Ejecuta el segundo ejemplo antes de fiarte de tu formato.

Solución (¡inténtalo primero!)

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;

    for (int i = n; i >= 1; i--) {
        cout << i;
        if (i > 1) cout << " ";
    }
    cout << endl;
    return 0;
}

Los bucles descendentes son más raros pero aparecen justo donde el orden de salida importa: invertir dígitos en Invertir un número, deshacer una pila en Paréntesis equilibrados y escribir los bits en Binario. Los límites invertidos son también donde viven la mayoría de los errores de uno.

Análisis profundo

Por qué funciona

Las tres partes de un for son decisiones independientes: valor inicial, condición de continuación y paso. Contar hacia abajo es empezar alto, probar >= 1 y avanzar con --. La forma del bucle es idéntica; solo cambió la dirección.

El coste

O(n) de tiempo y O(1) de espacio extra — n iteraciones, un número y quizá un espacio por iteración.

Dónde falla

Cambiar solo uno de dirección y paso: i = n; i >= 1; i++ nunca termina, porque la condición queda verdadera para siempre.
Lógica de separadores que asume al menos dos elementos. Con n = 1 el bucle imprime un número y ningún separador — ejecuta ese ejemplo.
i > 0 frente a i >= 1: ambos sirven con enteros, pero mezclarlos con tipos sin signo o pasos decimales introduce diferencias sutiles. Elige una convención y mantenla.

Siguiente paso

La iteración invertida está donde el orden de salida importa: Invertir un número, Binario, Paréntesis equilibrados.

Dos cosas para recordar

Inicio, condición y paso son independientes — un for puede caminar en cualquier dirección.
La dirección y el signo del paso deben cambiar juntos, o el bucle nunca termina.

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

Se detiene en 2: la condición debería dejar pasar el 1

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    for (int i = n; i > 1; i--) {   // bug: drops the final 1
        cout << i << " ";
    }
    cout << endl;
    return 0;
}