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.*;// Java code to demonstrate right star trianglepublic 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); }} |
Output
* * * * * * * * * * * * * * *
Time complexity: O(n2) where n is given input.
Auxiliary Space : O(1)
Using Recursion
Java
// Contributed by Manish Sharmaimport 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. }} |
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:
- Start by declaring a class named “RightTriangleStarPattern”.
- Inside the class, declare a “main” method.
- 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.
- 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”.
- Increment “i” by 1 after each iteration.
- 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.
- Inside the inner loop, print an asterisk followed by a space using the “System.out.print” statement.
- After the inner loop completes, print a newline character using the “System.out.println” statement to move to the next line.
- Run the program to see the output.
Java
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(); } }} |
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
- Set the number of rows you want to print in the triangle (‘n’).
- Initialize a variable to keep track of the number of stars to be printed in each row (‘numStars’) to 1.
- Start a loop that iterates over the rows of the triangle (‘i’).
- Within the loop for each row, start a nested loop that iterates over the columns of that row (‘j’).
- Within the inner loop, print a star (‘*’) for each column of the row.
- 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.
- Print a newline character (‘\n’) after the inner loop to move to the next line and start the next row.
- Repeat steps 4-7 for each row of the triangle.
Java
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 } }} |
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:
- Take the input ‘n’.
- Initialize a string variable ‘row’ with a single ‘*’ character.
- Use a while loop that runs n times.
- Print the current value of ‘row’.
- Append another ‘*’ character to the ‘row’ variable.
- Move to the next line using the “\n” character.
Steps:
- Take the input ‘n’.
- Initialize a string variable ‘row’ with a single ‘*’ character.
- Use a while loop that runs n times.
- Print the current value of ‘row’.
- Append another ‘*’ character to the ‘row’ variable.
- 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)
