Fácil–medio · Bucles anidados

Pirámide de asteriscos

Imprime una pirámide centrada de asteriscos con N filas. Los patrones impresos hacen que los bucles dejen de ser abstractos — un off-by-one se ve.

En una fraseLa fila i son N−i espacios seguidos de 2i−1 asteriscos, con dos bucles anidados: los espacios iniciales forman parte de la salida esperada, así que una pirámide pegada a la izquierda se rechaza.

El problema

Entrada: un entero N (1 ≤ N ≤ 20).

Salida: una pirámide de N filas. La fila i (contando desde 1) lleva N − i espacios iniciales seguidos de 2i − 1 asteriscos.

Ejemplos:

Para N = 3:

  *
 ***
*****

Fila 1: 2 espacios + 1 asterisco. Fila 2: 1 espacio + 3. Fila 3: 0 espacios + 5. Los espacios cuentan — el juez los compara.

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 — piensa en filas, luego en columnas

Un for exterior por las filas i = 1…N. Por fila, dos bucles interiores: primero n - i espacios, luego 2*i - 1 asteriscos, y al final cout << endl;. Bucles anidados = cada nivel se ocupa de una sola cosa.

Pista 2 — depura con N=1 y N=2

Corre casos diminutos primero. Si N=1 sale bien pero N=2 queda torcido, el conteo de espacios va desfasado en uno — las fórmulas n - i y 2*i - 1 son todo el problema; cuéntalas del ejemplo, no las adivines.

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

int main() {
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) {
        for (int s = 0; s < n - i; s++) cout << " ";
        for (int k = 0; k < 2 * i - 1; k++) cout << "*";
        cout << endl;
    }
    return 0;
}

Cuando pase, haz remixes: triángulo rectángulo (quita el bucle de espacios), pirámide invertida (cuenta i hacia abajo), pirámide hueca (if/else dentro del bucle interior, asteriscos solo en los bordes). Los mismos tres esqueletos cubren la mitad de los problemas de patrones de internet. Siguiente: Factorial.

Análisis profundo

Por qué funciona

Dos contadores por fila —espacios y luego asteriscos— enseñan la regla de que los bucles anidados son uno por dimensión de la salida.

El coste

O(n²) caracteres impresos. La salida ya es cuadrática: ningún algoritmo puede evitarlo.

Dónde falla

  • Los espacios iniciales se comparan byte a byte: uno de más y la fila está mal. Los finales los recorta este juez (los OJ reales, normalmente no).
  • Memorizar 2*i - 1 funciona hasta que cambias la base. Deduce la cuenta a partir del número de fila.

Siguiente paso

Anidar con salida numérica: Tabla de multiplicar.

Dos cosas para recordar

  • Un bucle por cada dimensión de la salida.
  • Los espacios iniciales cuentan; los finales fallan.
🐞 Esta versión falla: ábrela y pruébala

Un espacio de más al principio de cada fila

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n - i + 1; j++) cout << " ";
        for (int j = 1; j <= 2 * i - 1; j++) cout << "*";
        cout << endl;
    }
    return 0;
}