Java Program to Print Right Triangle Star Pattern (original) (raw)

Last Updated : 10 Apr, 2023

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

Examples:

Input : n = 5 Output:

*




Right Triangle Star Pattern:

Java

import java.io.*;

public class GeeksForGeeks {

`` public static void StarRightTriangle( int n)

`` {

`` int a, b;

`` for (a = 0 ; a < n; a++) {

`` for (b = 0 ; b <= a; b++) {

`` System.out.print( "* " );

`` }

`` System.out.println();

`` }

`` }

`` public static void main(String args[])

`` {

`` int k = 5 ;

`` StarRightTriangle(k);

`` }

}

Output

*




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

Using Recursion

Java

import java.io.*;

class GFG

{

`` public static void printRow( int n)

`` {

`` if (n == 0 )

`` {

`` return ;

`` }

`` System.out.print( "* " );

`` printRow(n - 1 );

`` }

`` public static void changeRow( int n)

`` {

`` if (n == 0 )

`` {

`` return ;

`` }

`` changeRow(n - 1 );

`` printRow(n);

`` System.out.print( "\n" );

`` }

`` public static void main (String[] args)

`` {

`` GFG.changeRow( 5 );

`` }

}

Output

*




Time complexity: O(n2) where n is given input.
Auxiliary Space: O(n2), 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.

Java

public class RightTriangleStarPattern {

`` public static void main(String[] args) {

`` int rows = 5 ;

`` for ( int i = 1 ; i <= rows; i++) {

`` for ( int j = 1 ; j <= i; j++) {

`` System.out.print( "* " );

`` }

`` System.out.println();

`` }

`` }

}

Output

*




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.

Java

public class RightTriangle {

`` public static void main(String[] args) {

`` int n = 5 ;

`` int numStars = 1 ;

`` for ( int i = 1 ; i <= n; i++) {

`` for ( int j = 1 ; j <= numStars; j++) {

`` System.out.print( "* " );

`` }

`` numStars++;

`` System.out.println();

`` }

`` }

}

Output

*




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.

Java

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++;

`` }

`` }

}

Output




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

Similar Reads

Java Basic Programs





















Java Pattern Programs














Java Conversion Programs















Java Classes and Object Programs
















Java Methods Programs











Java Searching Programs




Java 1-D Array Programs













Java 2-D Arrays (Matrix) Programs













Java String Programs