Java Program To Print Pyramid Pattern Of Stars

Printing patterns in programming is an excellent way to grasp fundamental looping concepts and logical thinking. Creating a pyramid pattern of stars involves careful consideration of spaces and asterisks across multiple rows. In this article, you will learn how to construct a star pyramid using nested loops in Java.

Problem Statement

The challenge is to write a Java program that generates a pyramid pattern of stars. This pattern requires a specific number of stars on each row, centered, with an increasing number of stars and decreasing number of leading spaces as the row number increases. The user should be able to specify the total number of rows for the pyramid.

Example

For an input of 5 rows, the desired output for a star pyramid would look like this:

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

Background & Knowledge Prerequisites

To understand the solution, a basic grasp of the following Java concepts is beneficial:

• Variables: Declaring and assigning values to store data like the number of rows.
• Input/Output: Using the Scanner class to read user input and System.out.print/println to display output.
• Loops (specifically for loops): Iterating a block of code a specific number of times. Nested loops are crucial for pattern printing.

Use Cases or Case Studies

Understanding how to print patterns like pyramids can be applied in various scenarios:

• Foundational Programming Logic: Excellent for beginners to practice logical thinking and build problem-solving skills with loops.
• Algorithmic Thinking: Helps develop the ability to break down a complex visual output into simpler, repeatable steps.
• Console-based UI/UX: In simple text-based applications, patterns can be used for decorative elements or separators.
• Educational Tools: Useful for demonstrating geometric shapes or visual representations in programming courses.
• Debugging Visualizations: Sometimes, pattern generation can be adapted to visualize data structures or algorithm steps in a simplified console format.

Solution Approaches

For printing a star pyramid, a common and effective approach involves using nested for loops. The outer loop controls the number of rows, while inner loops handle printing leading spaces and stars for each row.

Printing a Right-Aligned Pyramid using Nested Loops

This approach uses an outer loop to iterate through each row and two inner loops: one for printing the necessary leading spaces and another for printing the stars for that specific row.

One-line summary: Iterate through rows; for each row, print leading spaces, then print stars, ensuring proper spacing between stars for a symmetric look.

// Star Pyramid Pattern
import java.util.Scanner;

// Main class containing the entry point of the program
public class Main {
    public static void main(String[] args) {
        // Step 1: Declare a Scanner object to read user input
        Scanner scanner = new Scanner(System.in);

        // Step 2: Prompt the user to enter the number of rows
        System.out.print("Enter the number of rows for the pyramid: ");
        int numRows = scanner.nextInt();

        // Step 3: Outer loop for the number of rows
        for (int i = 0; i < numRows; i++) {
            // Step 4: Inner loop for printing leading spaces
            // The number of spaces decreases with each row
            for (int j = 0; j < numRows - i - 1; j++) {
                System.out.print(" ");
            }

            // Step 5: Inner loop for printing stars
            // The number of stars increases with each row (2*i + 1 stars)
            for (int k = 0; k <= i; k++) {
                System.out.print("* "); // Print star followed by a space for alignment
            }

            // Step 6: Move to the next line after printing stars for the current row
            System.out.println();
        }

        // Step 7: Close the scanner to prevent resource leaks
        scanner.close();
    }
}

Run

Sample Output:

Enter the number of rows for the pyramid: 5
        *
       * *
      * * *
     * * * *
    * * * * *

Stepwise Explanation for Clarity:

1. Initialize Scanner and Get Input: A Scanner object is created to read integer input from the user, determining how many rows the pyramid will have.
2. Outer Loop (for (int i = 0; i < numRows; i++)): This loop controls the total number of rows in the pyramid. The variable i represents the current row number, starting from 0.
3. Inner Loop for Spaces (for (int j = 0; j < numRows - i - 1; j++)):

• This loop prints the leading spaces before the stars on each row.
• For the first row (i=0), it prints numRows - 1 spaces.
• For subsequent rows, the number of spaces decreases by one, creating the pyramid's triangular shape.
• System.out.print(" "); prints a single space without moving to the next line.

1. Inner Loop for Stars (for (int k = 0; k <= i; k++)):

• This loop prints the stars for the current row.
• For row i, it prints i + 1 stars.
• System.out.print("* "); prints a star followed by a space. This trailing space is crucial for making the pyramid appear symmetrical and well-aligned when each star is treated as occupying two character widths (one for the star, one for its trailing space).

1. Newline (System.out.println();): After all spaces and stars for a particular row are printed, this statement moves the cursor to the next line, preparing for the stars of the next row.
2. Close Scanner: It's good practice to close the Scanner object when it's no longer needed to release system resources.

Conclusion

Creating patterns like the star pyramid is an excellent exercise for mastering nested loops and iterative logic in programming. By understanding how to control spaces and characters within nested loops, you gain valuable skills applicable to a wide range of programming problems.

Summary

• Star pyramid patterns are built using nested for loops.
• The outer loop iterates through each row of the pattern.
• Inner loops are used to print the leading spaces and the stars for each row.
• The number of leading spaces decreases with each subsequent row.
• The number of stars increases with each subsequent row.
• Adding a space after each star ("* ") helps in creating a well-aligned, symmetrical pyramid shape.