Programa en C++ para imprimir el triángulo de Floyd

El triángulo de Floyd es una array triangular de números naturales y lleva el nombre de Robert Floyd, un renombrado científico informático conocido popularmente por el diseño del algoritmo Floyd-Warshall . Aquí, veremos cómo imprimir la pirámide triangular del patrón de Floyd usando el programa C++. A continuación se muestran los ejemplos:

Entrada: fila = 5
Salida:
1 
2 3 
4 5 6 
7 8 9 10 
11 12 13 14 15 

Entrada: fila = 4
Salida:
1 
2 3 
4 5 6 
7 8 9 10 

Algoritmo:

• Al principio, tome el número de filas como entrada.
• El siguiente paso es implementar el bucle anidado para imprimir este patrón.
• Un recuento de nombres de variables mantiene el valor de los números naturales que se van a imprimir.  

Hay 3 formas de imprimir la pirámide triangular del patrón de Floyd:

1. Uso de bucle for.
2. Uso del ciclo while.
3. Uso de recursividad.

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

1. Usando el bucle for

A continuación se muestra el programa C++ para imprimir el patrón de triángulo de Floyd usando for loop:

// C++ program to print
// Floyd's pattern triangle
// using for loop
#include <bits/stdc++.h>
using namespace std;
 
void print_patt(int row)
{
    // Initializing count to 1.
    int count = 1;
 
    // The outer loop maintains
    // the number of rows.
    for (int i = 1; i <= row; i++)
    {
        // The inner loop maintains the
        // number of column.
        for (int j = 1; j <= i; j++)
        {
            // To print the numbers
            cout << count << " ";
 
            // To keep increasing the count
            // of numbers
            count += 1;
        }
       
        // To proceed to next line.
        cout << "\n";
    }
}
 
// Driver Code
int main()
{
    int row = 5;
    print_patt(row);
    return 0;
}

1 
2 3 
4 5 6 
7 8 9 10 
11 12 13 14 15 

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

2. Usando el ciclo while

A continuación se muestra el programa C++ para imprimir el triángulo de Floyd usando el ciclo While.

// C++ program to print
// Floyd's pattern triangle
// using while loop
#include <bits/stdc++.h>
using namespace std;
 
void print_patt(int row)
{
    // Initializing count to 1.
    int count = 1;
 
    // Loop control variables.
    int i = 1, j;
 
    // The outer loop maintains
    // the number of rows.
    while (i <= row)
    {
        // Reverting the value of j to 1
        // after each iteration.
        j = 1;
 
        // The inner loop maintains the
        // number of column.
        while (j <= i)
        {
            // To print the numbers
            cout << count << " ";
 
            // To keep increasing the
            // count of numbers
            count += 1;
           
            // Increasing the count
            // of inner loop.
            j += 1;
        }
       
        // Increasing the count of outer loop.
        i += 1;
       
        // To proceed to next line.
        cout << "\n";
    }
}
 
// Driver Code
int main()
{
    int row = 5;
    print_patt(row);
    return 0;
}

1 
2 3 
4 5 6 
7 8 9 10 
11 12 13 14 15 

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

3. Usando recursividad

A continuación se muestra el programa C++ para imprimir el triángulo de Floyd usando Recursion:

// C++ program to print
// Floyd's pattern triangle
// using recursion
#include <bits/stdc++.h>
using namespace std;
 
void print_patt(int row, int curr_row,
                int count)
{
    // If row is less than 0, it
    // returns return.
    if (row <= 0)
        return;
 
    // The loop maintains the number
    // of rows.
    for (int i = 1; i <= curr_row; i++)
    {
        // To print the numbers
        cout << count << " ";
 
        // To keep increasing the count
        // of numbers
        count += 1;
    }
   
    // To proceed to next line.
    cout << "\n";
 
    // To increasing the current row
    curr_row += 1;
 
    // Calling the function recursively.
    print_patt(row - 1,
               curr_row, count);
}
 
// Driver Code
int main()
{
    int curr_row = 1;
    int count = 1;
    int row = 5;
    print_patt(row, curr_row, count);
    return 0;
}

1 
2 3 
4 5 6 
7 8 9 10 
11 12 13 14 15 

• Complejidad Temporal: O(n ² ).
• Espacio auxiliar: se utiliza O(n) como enfoque recursivo.