Programa C para imprimir pirámide de estrella hueca invertida

Aquí veremos cómo imprimir una pirámide de estrella hueca invertida usando un programa C. A continuación se muestran los ejemplos:

Entrada: fila = 5
Salida:
*********
 * *
  * *
   * *
     *

Entrada: fila = 7
Salida:
*************
 * *
  * *
   * *
    * *
     * *
      *

Hay 2 formas de imprimir una pirámide de estrella hueca invertida en C:

1. Usando For Loop.
2. Uso del ciclo while.

Comencemos discutiendo cada uno de estos métodos en detalle.

Usando For Loop

Acercarse:

El enfoque es utilizar tres bucles:

1. Una es controlar el número de filas.
2. El segundo es controlar los espacios en blanco.
3. El tercero es controlar el número de columnas.

Luego, al usar conceptos del bucle anidado, uno puede imprimir fácilmente el patrón.

Algoritmo:

1. Tome la entrada de valor de fila para la pirámide invertida.
2. Necesitamos usar tres bucles, uno es el bucle externo para cambiar la línea y dos bucles internos, uno para imprimir la estrella y el otro para imprimir el espacio.
3. El ciclo externo itera los tiempos de fila e imprime una nueva línea después de completar el ciclo interno.
4. El primer bucle interno se usa para imprimir el espacio de 1 a (fila_actual -1).
5. El segundo bucle interno se usa para imprimir la estrella («*» ) en la primera y última columna (es decir, longitud _of_row * 2 – (2 * Current_row – 1)) .
6. El segundo bucle itera desde 1 hasta la última columna.

A continuación se muestra el programa C para imprimir una pirámide de estrella hueca invertida usando el bucle for:

// C program to print an inverted hollow
// star pyramid using for loop
#include <stdio.h>
void pattern_fun(int row)
{
    // To iterate through the rows
    for (int j = 1; j <= row; j++)
    {
        // To print the beginning spaces
        for (int sp = 1; sp <= j - 1; sp++)
        {
            printf(" ");
        }
 
        // Iterating from jth column to
        // last column (row*2 - (2*j - 1))
        int last_col = (row * 2 - (2 * j - 1));
 
        // To iterate through column
        for (int k = 1; k <= last_col; k++)
        {
            // To Print all star for first
            // row (j==1) jth column (k==1)
            // and for last column
            // (row*2 - (2*j - 1))
            if (j == 1 || k == 1)
                printf("*");
            else if (k == last_col)
                printf("*");
            else
                printf(" ");
        }
        // Proceeding to next row.
        printf("\n");
    }
}
 
// Driver code
int main()
{
    // Number of rows
    int row = 7;
   
    // Calling the function to
    // print the pattern.
    pattern_fun(row);
    return 0;
}

*************
 *         *
  *       *
   *     *
    *   *
     * *
      *

• Complejidad de tiempo: se utiliza O(n ² ), como bucle anidado.
• Espacio auxiliar: O(1), no se requiere espacio adicional, por lo que es una constante.

Usando el ciclo while:

A continuación se muestra el programa C para imprimir una pirámide de estrella hueca invertida usando un bucle while:

// C program to print an inverted
// hollow star pyramid using while
// loop
#include <stdio.h>
void pattern_fun(int row)
{
    // Declaring and initializing
    // the loop control variables.
    int j = 1;
    int sp = 1;
    int k = 1;
 
    // To iterate through the rows
    while (j <= row)
    {
        // Initializing the space
        // control variable.
        sp = 1;
 
        // To print the beginning spaces
        while (sp <= j - 1)
        {
            printf(" ");
           
            // Incrementing the value
            sp++;
        }
       
        // Iterating from jth column to
        // last column (row*2 - (2*j - 1))
        int last_col = (row * 2 - (2 * j - 1));
 
        // Initializing the column control
        // variable.
        k = 1;
 
        // To iterate through column
        while (k <= last_col)
        {
            // To Print all star for first
            // row (j==1) jth column (k==1)
            // and for last column
            // (row*2 - (2*j - 1))
            if (j == 1 || k == 1)
                printf("*");
            else if (k == last_col)
                printf("*");
            else
                printf(" ");
           
            // Incrementing the value
            k++;
        }
       
        // Proceeding to next row.
        printf("\n");
       
        // Incrementing the value
        j++;
    }
}
 
// Driver code
int main()
{
    // Number of rows
    int row = 4;
   
    // Calling the function to
    // print the pattern.
    pattern_fun(row);
    return 0;
}

*******
 *   *
  * *
   *

• Complejidad temporal: O(n ² ), ya que se utiliza el bucle anidado.
• Espacio auxiliar: O(1), no se requiere espacio adicional, por lo que es una constante.