Java Program to Print Right Triangle Star Pattern

In this article, we will learn about printing Right Triangle Star Pattern.

Examples:

Input : n = 5
Output: 
* 
* * 
* * * 
* * * * 
* * * * *  

Right Triangle Star Pattern:

import java.io.*;

// Java code to demonstrate right star triangle
public class GeeksForGeeks {
    // Function to demonstrate printing pattern
    public static void StarRightTriangle(int n)
    {
        int a, b;

        // outer loop to handle number of rows
        // k in this case
        for (a = 0; a < n; a++) {

            // inner loop to handle number of columns
            // values changing acc. to outer loop
            for (b = 0; b <= a; b++) {
                // printing stars
                System.out.print("* ");
            }

            // end-line
            System.out.println();
        }
    }

    // Driver Function
    public static void main(String args[])
    {
        int k = 5;
        StarRightTriangle(k);
    }
}

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

Time complexity: O(n²) where n is given input.
Auxiliary Space : O(1)

Using Recursion

// Contributed by Manish Sharma

import java.io.*;

class GFG 
{    
    public static void printRow(int n) // for printing a row
    {
        if(n == 0)
        {
            return;
        }
        System.out.print("* ");
        printRow(n - 1); // for next * in the current row
    }
  
    public static void changeRow(int n) // for moving to next row...n = 1 means last row
    {
        if(n == 0)
        {
            return;
        }
        changeRow(n - 1);
        printRow(n); // when call stack of changeRow method is popping out we will print row 
        System.out.print("\n"); // new line after each column
    }
  
    public static void main (String[] args) 
    {
        GFG.changeRow(5); // changeRow method is static so no need to create an object of GFG class.
    }
}

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

Time complexity: O(n²) where n is given input.
Auxiliary Space: O(n²), due to recursion call stack.

Method: Using nested loops

Approach:

The goal of this program is to print a right triangle star pattern using asterisks. We will use a nested for loop to achieve this. The outer loop will be responsible for iterating over each row of the pattern, while the inner loop will print the asterisks on each line.

Step-by-step approach:

1. Start by declaring a class named "RightTriangleStarPattern".
2. Inside the class, declare a "main" method.
3. Initialize a variable "rows" to store the number of rows to be printed in the pattern. In this example, we will use the value 5.
4. Use a "for" loop to iterate over each row of the pattern. Set the initial value of the loop variable "i" to 1 and continue looping while "i" is less than or equal to "rows".
5. Increment "i" by 1 after each iteration.
6. Inside the outer loop, use another "for" loop to print the asterisks on each line. Set the initial value of the loop variable "j" to 1 and continue looping while "j" is less than or equal to "i". Increment "j" by 1 after each iteration.
7. Inside the inner loop, print an asterisk followed by a space using the "System.out.print" statement.
8. After the inner loop completes, print a newline character using the "System.out.println" statement to move to the next line.
9. Run the program to see the output.
    

public class RightTriangleStarPattern {
    public static void main(String[] args) {
        int rows = 5; // Input number of rows

        for (int i = 1; i <= rows; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

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

The time complexity: O(n^2), where n is the number of rows

The auxiliary space complexity: O(1)

Method: Single loop with arithmetic operations

1. Set the number of rows you want to print in the triangle ('n').
2. Initialize a variable to keep track of the number of stars to be printed in each row ('numStars') to 1.
3. Start a loop that iterates over the rows of the triangle ('i').
4. Within the loop for each row, start a nested loop that iterates over the columns of that row ('j').
5. Within the inner loop, print a star ('*') for each column of the row.
6. Increment the 'numStars' variable by 1 after the inner loop is complete so that the next row has one more star than the previous row.
7. Print a newline character ('\n') after the inner loop to move to the next line and start the next row.
8. Repeat steps 4-7 for each row of the triangle.

public class RightTriangle {
    public static void main(String[] args) {
        int n = 5; // number of rows
        int numStars = 1; // number of stars to be printed in each row

        for (int i = 1; i <= n; i++) { // loop for rows
            for (int j = 1; j <= numStars; j++) { // loop for printing stars in each row
                System.out.print("* ");
            }
            numStars++; // increment the number of stars for the next row
            System.out.println(); // move to next line
        }
    }
}

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

The time complexity is O(n^2), where n is the number of rows

The auxiliary space complexity of this approach is O(1)

Approach:

1. Take the input 'n'.
2. Initialize a string variable 'row' with a single '*' character.
3. Use a while loop that runs n times.
4. Print the current value of 'row'.
5. Append another '*' character to the 'row' variable.
6. Move to the next line using the "\n" character.

Steps:

1. Take the input 'n'.
2. Initialize a string variable 'row' with a single '*' character.
3. Use a while loop that runs n times.
4. Print the current value of 'row'.
5. Append another '*' character to the 'row' variable.
6. Move to the next line using the "\n" character.

public class RightTrianglePattern {
    public static void main(String[] args) {

        int n = 5;

        String row = "*";
        int i = 1;
        while(i <= n) {
            System.out.println(row);
            row += "*";
            i++;
        }
    }
}

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

Time Complexity: O(n)
Auxiliary Space: O(n)