Diamond Pattern Printing Using Numbers In Java 8

Printing patterns in Java is an excellent way to grasp fundamental programming concepts like loops, conditional statements, and logical thinking. In this article, you will learn how to create a diamond pattern using numbers in Java 8, understanding the logic behind its construction.

Problem Statement

The goal is to print a symmetrical diamond pattern to the console, where each row consists of numbers increasing to a peak and then decreasing. The pattern's size will be determined by a user-specified input, typically referred to as the "number of rows" or "maximum number." For instance, an input of 4 should produce a diamond where the middle row reaches 4.

Example

Consider the desired output for an input n = 4:

1
  121
 12321
1234321
 12321
  121
   1

Background & Knowledge Prerequisites

To follow this tutorial, you should have a basic understanding of:

• Java Syntax: How to write and execute simple Java programs.
• Variables and Data Types: Declaring and using integer variables.
• Loops: Especially for loops, including nested loops.
• Input/Output: Using Scanner to read user input and System.out.print/println for output.

Use Cases or Case Studies

While direct pattern printing might seem purely academic, the underlying logic is applicable in various programming scenarios:

• Algorithmic Thinking: Developing patterns sharpens your ability to break down complex problems into smaller, manageable steps.
• Game Development: Creating visual effects, menu layouts, or character movement paths often involves spatial reasoning similar to pattern printing.
• Data Visualization: Generating structured output or simple graphical representations in console applications.
• Educational Tools: Demonstrating loop control, conditional logic, and string manipulation.

Solution Approaches

Creating a number diamond pattern typically involves a structured approach that divides the pattern into two halves: the upper diamond (including the widest row) and the lower inverted diamond. This method ensures symmetry and clarity.

Approach 1: Decomposing into Upper and Lower Halves

This approach involves using nested loops to print the upper half of the diamond, followed by another set of nested loops to print the lower half. This separation makes the logic easier to understand and debug.

One-line summary: Build the diamond by first printing the increasing rows up to the widest point, then printing the decreasing rows.

// Number Diamond Pattern
import java.util.Scanner;

// Main class containing the entry point of the program
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Step 1: Get user input for the number of rows
        System.out.print("Enter the number for the diamond (e.g., 4): ");
        int n = scanner.nextInt();

        // Step 2: Print the upper half of the diamond (including the middle row)
        for (int i = 1; i <= n; i++) {
            // Print leading spaces
            for (int j = 1; j <= n - i; j++) {
                System.out.print(" ");
            }
            // Print increasing numbers
            for (int j = 1; j <= i; j++) {
                System.out.print(j);
            }
            // Print decreasing numbers
            for (int j = i - 1; j >= 1; j--) {
                System.out.print(j);
            }
            System.out.println(); // Move to the next line
        }

        // Step 3: Print the lower half of the diamond
        for (int i = n - 1; i >= 1; i--) {
            // Print leading spaces
            for (int j = 1; j <= n - i; j++) {
                System.out.print(" ");
            }
            // Print increasing numbers
            for (int j = 1; j <= i; j++) {
                System.out.print(j);
            }
            // Print decreasing numbers
            for (int j = i - 1; j >= 1; j--) {
                System.out.print(j);
            }
            System.out.println(); // Move to the next line
        }

        scanner.close(); // Close the scanner
    }
}

Run

Sample output:

Enter the number for the diamond (e.g., 4): 4
   1
  121
 12321
1234321
 12321
  121
   1

Stepwise explanation for clarity:

1. Input: The program first prompts the user to enter an integer n, which determines the maximum number in the widest row and the overall size of the diamond.
2. Upper Half Loop (for (int i = 1; i <= n; i++)): This outer loop iterates n times, controlling the current row being printed. For n = 4, it runs for i = 1, 2, 3, 4.

• Leading Spaces (for (int j = 1; j <= n - i; j++)): This inner loop prints the necessary spaces before the numbers. As i increases (moving down the diamond), n - i decreases, meaning fewer spaces are printed, making the pattern widen.
• Increasing Numbers (for (int j = 1; j <= i; j++)): This loop prints numbers from 1 up to the current row number i.
• Decreasing Numbers (for (int j = i - 1; j >= 1; j--)): This loop prints numbers from i - 1 down to 1. This creates the symmetrical decreasing part of the number sequence for each row. Note that i - 1 is used to avoid duplicating the peak number.
• Newline (System.out.println();): After each row is complete, a newline character is printed to move to the next line for the subsequent row.

1. Lower Half Loop (for (int i = n - 1; i >= 1; i--)): This outer loop handles the inverted part of the diamond. It starts from n - 1 (to avoid reprinting the widest row) and goes down to 1.

• The logic for printing spaces, increasing numbers, and decreasing numbers within this loop is identical to the upper half loop. The key difference is that i is now decreasing, effectively mirroring the upper half's structure.

Conclusion

Creating a number diamond pattern in Java, while seemingly simple, is an excellent exercise for solidifying your understanding of nested loops and control flow. By breaking the problem into an upper and lower half, and carefully managing spaces and number sequences, you can build complex patterns effectively.

Summary

• Diamond patterns are typically constructed by printing an upper pyramid and a lower inverted pyramid.
• Nested for loops are essential for controlling rows, leading spaces, and the sequence of numbers.
• The logic for printing numbers often involves one loop for increasing values and another for decreasing values within the same row.
• Understanding how to vary loop bounds (n - i for spaces, i for numbers) is key to achieving the desired shape and symmetry.