Posted on by Kalkicode
Code Pattern

Print Floyd's triangle

In this article, we will explore Floyd's Triangle and how to print it using Java programming language. Floyd's Triangle is a right-angled triangular pattern of numbers named after Robert Floyd. It starts with 1 and each subsequent row contains the next set of natural numbers.

floyd triangle

Problem Statement

The problem is to print Floyd's Triangle of a given number of rows. For example, if the input is 7, the output would be:

ROW SIZE : 7

1
2   3
4   5   6
7   8   9   10
11  12  13  14  15
16  17  18  19  20  21
22  23  24  25  26  27  28

We need to design a program that takes the number of rows as input and prints Floyd's Triangle accordingly.

Approach and Algorithm

To solve this problem, we can use nested loops. The outer loop iterates over the rows, and the inner loop prints the elements in each row. We maintain a counter variable to keep track of the current number to be printed. Here's the algorithm:

  1. Start with a counter variable set to 1.
  2. Loop over the rows from 1 to the given input row number.
  3. For each row, loop over the columns from 1 to the current row number.
  4. Print the value of the counter variable, followed by a tab or space for formatting.
  5. Increment the counter variable by 1.
  6. Print a new line after each row to move to the next line.
  7. Repeat steps 3-6 for all rows.

The time complexity of this algorithm is O(n^2), where n is the number of rows in Floyd's Triangle.

Code Solution

Here given code implementation process.

// Java Program for
// Print Floyd's Triangle
class MyPattern
{
    // Print floyd triangle of given rows
    public void floydTriangle(int row)
    {
        if(row <= 0 )
        {
            return;
        }
        // Display number of row
        System.out.print("ROW SIZE : " + row + "\n\n");
      
        // Counter variable is used to display triangle values
        int counter = 1;
        // Outer loop for rows
        for (int i = 0; i < row; ++i)
        {
            for (int j = 0; j <= i; j++)
            {
                // Print element value
                System.out.print(" " + counter + "\t");
                // Increase counter value by one
                counter++;
            }
            // Include new line
            System.out.print("\n");
        }
        System.out.print("\n\n");
    }
    public static void main(String[] args)
    {
        MyPattern task = new MyPattern();
        // Test
        task.floydTriangle(7);
        task.floydTriangle(5);
    }
}

Output

ROW SIZE : 7

 1
 2   3
 4   5   6
 7   8   9   10
 11  12  13  14  15
 16  17  18  19  20  21
 22  23  24  25  26  27  28


ROW SIZE : 5

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

// Include header file
#include <iostream>
using namespace std;
// C++ Program for
// Print Floyd's Triangle
class MyPattern
{
    public:
        // Print floyd triangle of given rows
        void floydTriangle(int row)
        {
            if (row <= 0)
            {
                return;
            }
            // Display number of row
            cout << "ROW SIZE : " << row << "\n\n";
            // Counter variable is used to display triangle values
            int counter = 1;
            // Outer loop for rows
            for (int i = 0; i < row; ++i)
            {
                for (int j = 0; j <= i; j++)
                {
                    // Print element value
                    cout << " " << counter << "\t";
                    // Increase counter value by one
                    counter++;
                }
                // Include new line
                cout << "\n";
            }
            cout << "\n\n";
        }
};
int main()
{
    MyPattern *task = new MyPattern();
    // Test
    task->floydTriangle(7);
    task->floydTriangle(5);
    return 0;
}

Output

ROW SIZE : 7

 1
 2   3
 4   5   6
 7   8   9   10
 11  12  13  14  15
 16  17  18  19  20  21
 22  23  24  25  26  27  28


ROW SIZE : 5

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

// C Program
// Print Floyd's triangle
#include <stdio.h>

// Print floyd triangle of given rows
void floyd_triangle(int row)
{
    printf("ROW SIZE : %d\n\n", row);
    // declare loop control variable
    int i = 0;
    int j = 0;
    // counter variable is used to display triangle values
    int counter = 1;
    for (i = 0; i < row; ++i)
    {
        for (j = 0; j <= i; j++)
        {
            printf("%d\t", counter);
            counter++;
        }
        printf("\n");
    }
    printf("\n\n");
}
int main()
{
    //Test Case
    floyd_triangle(7);
    floyd_triangle(5);
    return 0;
}

Output

ROW SIZE : 7

1
2   3
4   5   6
7   8   9   10
11  12  13  14  15
16  17  18  19  20  21
22  23  24  25  26  27  28


ROW SIZE : 5

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

package main
import "fmt"
// Go Program for
// Print Floyd's Triangle

// Print floyd triangle of given rows
func floydTriangle(row int) {
    if row <= 0 {
        return
    }
    // Display number of row
    fmt.Print("ROW SIZE : ", row, "\n\n")
    // Counter variable is used to display triangle values
    var counter int = 1
    // Outer loop for rows
    for i := 0 ; i < row ; i++ {
        for j := 0 ; j <= i ; j++ {
            // Print element value
            fmt.Print(" ", counter, "\t")
            // Increase counter value by one
            counter++
        }
        // Include new line
        fmt.Print("\n")
    }
    fmt.Print("\n\n")
}
func main() {
    // Test
    floydTriangle(7)
    floydTriangle(5)
}

Output

ROW SIZE : 7

 1
 2   3
 4   5   6
 7   8   9   10
 11  12  13  14  15
 16  17  18  19  20  21
 22  23  24  25  26  27  28


ROW SIZE : 5

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

// Include namespace system
using System;
// Csharp Program for
// Print Floyd's Triangle
public class MyPattern
{
    // Print floyd triangle of given rows
    public void floydTriangle(int row)
    {
        if (row <= 0)
        {
            return;
        }
        // Display number of row
        Console.Write("ROW SIZE : " + row + "\n\n");
        // Counter variable is used to display triangle values
        int counter = 1;
        // Outer loop for rows
        for (int i = 0; i < row; ++i)
        {
            for (int j = 0; j <= i; j++)
            {
                // Print element value
                Console.Write(" " + counter + "\t");
                // Increase counter value by one
                counter++;
            }
            // Include new line
            Console.Write("\n");
        }
        Console.Write("\n\n");
    }
    public static void Main(String[] args)
    {
        MyPattern task = new MyPattern();
        // Test
        task.floydTriangle(7);
        task.floydTriangle(5);
    }
}

Output

ROW SIZE : 7

 1
 2   3
 4   5   6
 7   8   9   10
 11  12  13  14  15
 16  17  18  19  20  21
 22  23  24  25  26  27  28


ROW SIZE : 5

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

<?php
// Php Program for
// Print Floyd's Triangle
class MyPattern
{
    // Print floyd triangle of given rows
    public  function floydTriangle($row)
    {
        if ($row <= 0)
        {
            return;
        }
        // Display number of row
        print_r("ROW SIZE : ".strval($row).
            "\n\n");
        // Counter variable is used to display triangle values
        $counter = 1;
        // Outer loop for rows
        for ($i = 0; $i < $row; ++$i)
        {
            for ($j = 0; $j <= $i; $j++)
            {
                // Print element value
                print_r(" ".strval($counter).
                    "\t");
                // Increase counter value by one
                $counter++;
            }
            // Include new line
            print_r("\n");
        }
        print_r("\n\n");
    }
    public static
    function main($args)
    {
        $task = new MyPattern();
        // Test
        $task->floydTriangle(7);
        $task->floydTriangle(5);
    }
}
MyPattern::main(array());

Output

ROW SIZE : 7

 1
 2   3
 4   5   6
 7   8   9   10
 11  12  13  14  15
 16  17  18  19  20  21
 22  23  24  25  26  27  28


ROW SIZE : 5

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

// Node JS Program for
// Print Floyd's Triangle
class MyPattern
{
    // Print floyd triangle of given rows
    floydTriangle(row)
    {
        if (row <= 0)
        {
            return;
        }
        // Display number of row
        process.stdout.write("ROW SIZE : " + row + "\n\n");
        // Counter variable is used to display triangle values
        var counter = 1;
        // Outer loop for rows
        for (var i = 0; i < row; ++i)
        {
            for (var j = 0; j <= i; j++)
            {
                // Print element value
                process.stdout.write(" " + counter + "\t");
                // Increase counter value by one
                counter++;
            }
            // Include new line
            process.stdout.write("\n");
        }
        process.stdout.write("\n\n");
    }
}

function main()
{
    var task = new MyPattern();
    // Test
    task.floydTriangle(7);
    task.floydTriangle(5);
}
main();

Output

ROW SIZE : 7

 1
 2   3
 4   5   6
 7   8   9   10
 11  12  13  14  15
 16  17  18  19  20  21
 22  23  24  25  26  27  28


ROW SIZE : 5

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

#  Python 3 Program for
#  Print Floyd's Triangle
class MyPattern :
    #  Print floyd triangle of given rows
    def floydTriangle(self, row) :
        if (row <= 0) :
            return
        
        #  Display number of row
        print("ROW SIZE : ", row ,"\n")
        #  Counter variable is used to display triangle values
        counter = 1
        i = 0
        #  Outer loop for rows
        while (i < row) :
            j = 0
            while (j <= i) :
                #  Print element value
                print(" ", counter ,"\t", end = "")
                #  Increase counter value by one
                counter += 1
                j += 1
            
            #  Include new line
            print(end = "\n")
            i += 1
        
        print("\n")
    

def main() :
    task = MyPattern()
    #  Test
    task.floydTriangle(7)
    task.floydTriangle(5)

if __name__ == "__main__": main()

Output

ROW SIZE :  7

  1
  2       3
  4       5       6
  7       8       9       10
  11      12      13      14      15
  16      17      18      19      20      21
  22      23      24      25      26      27      28


ROW SIZE :  5

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

#  Ruby Program for
#  Print Floyd's Triangle
class MyPattern 
    #  Print floyd triangle of given rows
    def floydTriangle(row) 
        if (row <= 0) 
            return
        end

        #  Display number of row
        print("ROW SIZE : ", row ,"\n\n")
        #  Counter variable is used to display triangle values
        counter = 1
        i = 0
        #  Outer loop for rows
        while (i < row) 
            j = 0
            while (j <= i) 
                #  Print element value
                print(" ", counter ,"\t")
                #  Increase counter value by one
                counter += 1
                j += 1
            end

            #  Include new line
            print("\n")
            i += 1
        end

        print("\n\n")
    end

end

def main() 
    task = MyPattern.new()
    #  Test
    task.floydTriangle(7)
    task.floydTriangle(5)
end

main()

Output

ROW SIZE : 7

 1  
 2   3  
 4   5   6  
 7   8   9   10 
 11  12  13  14  15 
 16  17  18  19  20  21 
 22  23  24  25  26  27  28 


ROW SIZE : 5

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


// Scala Program for
// Print Floyd's Triangle
class MyPattern()
{
    // Print floyd triangle of given rows
    def floydTriangle(row: Int): Unit = {
        if (row <= 0)
        {
            return;
        }
        // Display number of row
        print("ROW SIZE : " + row + "\n\n");
        // Counter variable is used to display triangle values
        var counter: Int = 1;
        var i: Int = 0;
        // Outer loop for rows
        while (i < row)
        {
            var j: Int = 0;
            while (j <= i)
            {
                // Print element value
                print(" " + counter + "\t");
                // Increase counter value by one
                counter += 1;
                j += 1;
            }
            // Include new line
            print("\n");
            i += 1;
        }
        print("\n\n");
    }
}
object Main
{
    def main(args: Array[String]): Unit = {
        var task: MyPattern = new MyPattern();
        // Test
        task.floydTriangle(7);
        task.floydTriangle(5);
    }
}

Output

ROW SIZE : 7

 1
 2   3
 4   5   6
 7   8   9   10
 11  12  13  14  15
 16  17  18  19  20  21
 22  23  24  25  26  27  28


ROW SIZE : 5

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

// Swift 4 Program for
// Print Floyd's Triangle
class MyPattern
{
    // Print floyd triangle of given rows
    func floydTriangle(_ row: Int)
    {
        if (row <= 0)
        {
            return;
        }
        // Display number of row
        print("ROW SIZE : ", row ,"\n");
        // Counter variable is used to display triangle values
        var counter: Int = 1;
        var i: Int = 0;
        // Outer loop for rows
        while (i < row)
        {
            var j: Int = 0;
            while (j <= i)
            {
                // Print element value
                print(" ", counter ,"\t", terminator: "");
                // Increase counter value by one
                counter += 1;
                j += 1;
            }
            // Include new line
            print(terminator: "\n");
            i += 1;
        }
        print("\n");
    }
}
func main()
{
    let task: MyPattern = MyPattern();
    // Test
    task.floydTriangle(7);
    task.floydTriangle(5);
}
main();

Output

ROW SIZE :  7

  1
  2       3
  4       5       6
  7       8       9       10
  11      12      13      14      15
  16      17      18      19      20      21
  22      23      24      25      26      27      28


ROW SIZE :  5

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

// Kotlin Program for
// Print Floyd's Triangle
class MyPattern
{
    // Print floyd triangle of given rows
    fun floydTriangle(row: Int): Unit
    {
        if (row <= 0)
        {
            return;
        }
        // Display number of row
        print("ROW SIZE : " + row + "\n\n");
        // Counter variable is used to display triangle values
        var counter: Int = 1;
        var i: Int = 0;
        // Outer loop for rows
        while (i < row)
        {
            var j: Int = 0;
            while (j <= i)
            {
                // Print element value
                print(" " + counter + "\t");
                // Increase counter value by one
                counter += 1;
                j += 1;
            }
            // Include new line
            print("\n");
            i += 1;
        }
        print("\n\n");
    }
}
fun main(args: Array < String > ): Unit
{
    val task: MyPattern = MyPattern();
    // Test
    task.floydTriangle(7);
    task.floydTriangle(5);
}

Output

ROW SIZE : 7

 1
 2   3
 4   5   6
 7   8   9   10
 11  12  13  14  15
 16  17  18  19  20  21
 22  23  24  25  26  27  28


ROW SIZE : 5

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

Finally

In this article, we have learned about Floyd's Triangle and how to print it using Java. We discussed the problem statement and provided a step-by-step algorithm to solve it. The Java code implementation was also explained, along with the expected output. Floyd's Triangle is a fascinating pattern that can be generated using simple loops. It helps in understanding nested loops and pattern printing in programming.

Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment