Nested for loops

A. The Core Execution Principle:

A Nested Loop is simply a loop inside another loop. The fundamental rule governing nested loops is:

"For every SINGLE iteration of the Outer Loop, the Inner Loop executes completely through all its iterations from start to finish."

for (int i = 1; i <= 3; i++) {       // Outer loop (controls ROWS)
    for (int j = 1; j <= 4; j++) {   // Inner loop (controls COLUMNS)
        System.out.print("* ");      // Prints elements in current row
    }
    System.out.println();            // Advances to next line after row finishes
}

B. Total Iterations Formula:

If the outer loop executes $M$ times and the inner loop executes $N$ times for each outer step, the total number of times the innermost body statement executes is:

In the code above: $3 ext{ rows} imes 4 ext{ columns} = 12 ext{ asterisks printed}$.

A. Triangle Type A: Inner Variable Progression (1; 1 2; 1 2 3...):

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

Logic: Row number i goes 1 to 5. Column j starts at 1 and stops at i, printing j.

B. Triangle Type B: Outer Variable Repetition (1; 2 2; 3 3 3...):

for (int i = 1; i <= 5; i++) {
    for (int j = 1; j <= i; j++) {
        System.out.print(i + " "); // Prints i instead of j!
    }
    System.out.println();
}

A. Inverted Number Triangle (5 4 3 2 1; 5 4 3 2...):

for (int i = 1; i <= 5; i++) {
    for (int j = 5; j >= i; j--) {
        System.out.print(j + " ");
    }
    System.out.println();
}

B. Floyd's Triangle (Consecutive Natural Numbers):

int count = 1; // External running accumulator
for (int i = 1; i <= 4; i++) {
    for (int j = 1; j <= i; j++) {
        System.out.print(count + " ");
        count++; // Increments continuously
    }
    System.out.println();
}

A. Alphabetic Character Ladder (A; A B; A B C...):

for (char i = 'A'; i <= 'E'; i++) {
    for (char j = 'A'; j <= i; j++) {
        System.out.print(j + " ");
    }
    System.out.println();
}

B. Space-Aligned Symmetrical Star Pyramid:

To center a pyramid, the outer loop must control two consecutive inner loops: the first for leading spaces, the second for stars!

// Produces:
//     *
//    * *
//   * * *
//  * * * *
for (int i = 1; i <= 4; i++) {
    // Inner Loop 1: Leading Spaces
    for (int s = 1; s <= (4 - i); s++) {
        System.out.print(" ");
    }
    // Inner Loop 2: Asterisks
    for (int j = 1; j <= i; j++) {
        System.out.print("* ");
    }
    System.out.println(); // Newline
}

Execution State Matrix:

A. Alternating Binary 0-1 Triangle:

for (int i = 1; i <= 5; i++) {
    for (int j = 1; j <= i; j++) {
        // If row + col is even, print 1; else 0
        if ((i + j) % 2 == 0)
            System.out.print("1 ");
        else
            System.out.print("0 ");
    }
    System.out.println();
}

B. Inverted Right-Aligned Star Triangle:

// Prints:
// * * * *
//   * * *
//     * *
//       *
for (int i = 4; i >= 1; i--) {
    // Print leading spaces
    for (int s = 1; s <= (4 - i); s++) {
        System.out.print("  ");
    }
    // Print stars
    for (int j = 1; j <= i; j++) {
        System.out.print("* ");
    }
    System.out.println();
}

A. Full Symmetrical Star Diamond Pattern:

public class StarDiamond {
    public static void main(String[] args) {
        int n = 4; // Top half height

        // Top Half of Diamond
        for (int i = 1; i <= n; i++) {
            for (int s = 1; s <= (n - i); s++) System.out.print(" ");
            for (int j = 1; j <= (2 * i - 1); j++) System.out.print("*");
            System.out.println();
        }

        // Bottom Half of Diamond
        for (int i = n - 1; i >= 1; i--) {
            for (int s = 1; s <= (n - i); s++) System.out.print(" ");
            for (int j = 1; j <= (2 * i - 1); j++) System.out.print("*");
            System.out.println();
        }
    }
}

A. Hollow Star Rectangle Logic:

To print an empty hollow rectangle, print stars only on the boundaries: first row (i==1), last row (i==rows), first column (j==1), or last column (j==cols); otherwise print a space!

int rows = 5, cols = 6;
for (int i = 1; i <= rows; i++) {
    for (int j = 1; j <= cols; j++) {
        if (i == 1 || i == rows || j == 1 || j == cols) {
            System.out.print("* ");
        } else {
            System.out.print("  "); // Two spaces to match '* '
        }
    }
    System.out.println();
}

A. Continuous Alphabetical Progression (A; B C; D E F; G H I J):

char ch = 'A';
for (int i = 1; i <= 4; i++) {
    for (int j = 1; j <= i; j++) {
        System.out.print(ch + " ");
        ch++; // Continuous increment across entire triangle!
    }
    System.out.println();
}

A. Inverted Number Staircase (1 2 3 4 5; 1 2 3 4; 1 2 3; 1 2; 1):

for (int i = 5; i >= 1; i--) {
    for (int j = 1; j <= i; j++) {
        System.out.print(j + " ");
    }
    System.out.println();
}

B. Repeated Decreasing Number Staircase (5 5 5 5 5; 4 4 4 4; 3 3 3; 2 2; 1):

for (int i = 5; i >= 1; i--) {
    for (int j = 1; j <= i; j++) {
        System.out.print(i + " ");
    }
    System.out.println();
}

C. Symmetrical Number Pyramid (with Leading Spaces):

// Produces:
//    1
//   1 2
//  1 2 3
// 1 2 3 4
for (int i = 1; i <= 4; i++) {
    for (int s = 1; s <= (4 - i); s++) {
        System.out.print(" ");
    }
    for (int j = 1; j <= i; j++) {
        System.out.print(j + " ");
    }
    System.out.println();
}

A. Inverted Character Staircase (E D C B A; E D C B; E D C; E D; E):

for (char i = 'A'; i <= 'E'; i++) {
    for (char j = 'E'; j >= i; j--) {
        System.out.print(j + " ");
    }
    System.out.println();
}

B. Hollow Diagonal Pattern Logic:

To print both diagonals in an $N imes N$ square, print stars when i == j (main diagonal) or i + j == N + 1 (anti-diagonal), providing the foundation for complex geometric star patterns in competitive programming.

The 5-Step Pattern Problem Checklist:

1. Identify the total number of horizontal rows (sets outer loop count).
2. Identify how the number of columns changes per row (sets inner loop limit).
3. Check what is being printed: row variable i, column variable j, or external counter.
4. Check if there are leading spaces (requires dedicated space-printing inner loop).
5. Ensure System.out.println() executes inside outer loop after inner loop terminates.

A. Generating Pascal's Triangle Entries:

In Pascal's triangle, each number is the sum of the two numbers directly above it. Using combination mathematics, the element at row $n$ and column $r$ is given by $^nC_r = rac{n!}{r!(n-r)!}$. In Java, this can be calculated efficiently inside nested loops using the iterative multiplier: num = num * (i - j) / (j + 1);, displaying centered triangular symmetry.

If your printed pattern produces an inverted shape or prints too many characters per row, check the inner loop's boundary condition. Writing j < i instead of j <= i is the most common student error, causing the first row to be completely skipped!