Loop Control and Pattern Printing

What Is It?

What Are Loop Control Statements and Pattern Programs?

Loop control statements are keywords that alter the normal flow of a loop. While loops typically run until their condition becomes false, control statements let you exit a loop early (break), skip the current iteration (continue), or exit nested loops from an inner loop (labeled break/continue).

Pattern programs are coding problems that require printing structured shapes using characters, numbers, or symbols. They are one of the most frequently asked topics in college exams and placement interviews because they test your understanding of nested loops, loop variables, and the relationship between rows and columns.

Patterns appear simple on the surface, but solving them requires you to identify the mathematical relationship between the row number and what gets printed in each row. Once you understand this approach, you can solve any pattern.

Why Does It Matter?

Why Master Loop Control and Patterns?

1. Loop Control Is Essential for Efficient Code

break lets you exit a loop as soon as you find what you are looking for, avoiding unnecessary iterations. In a search algorithm, once the target is found, continuing to iterate is wasteful. continue lets you skip invalid or unwanted cases without nesting your logic inside if-else blocks, keeping code flat and readable.

2. Pattern Programs Build Core Loop Logic

Pattern programs force you to understand how nested loops interact. The outer loop controls rows, the inner loop(s) control what gets printed in each row. This same nested loop logic is used in matrix operations, image processing, table generation, and grid-based algorithms.

3. Placement Interviews and Coding Rounds

Pattern printing is one of the most commonly asked topics in campus placement coding rounds, particularly for companies like TCS, Infosys, Wipro, Capgemini, and Cognizant. Many online assessments include 2-3 pattern questions. Labeled break is asked in interview vivas. Mastering these gives you easy marks.

4. Foundation for Advanced Algorithms

The ability to analyze the relationship between loop variables and output is the same skill needed for algorithm design. Whether you are implementing dynamic programming tables, generating permutations, or processing 2D arrays, the thinking process is identical to pattern analysis.

Detailed Explanation

Detailed Explanation

1. The break Statement

break immediately terminates the innermost loop (for, while, or do-while) or switch statement that contains it. Control passes to the statement immediately after the terminated loop.

for (int i = 1; i <= 10; i++) {
    if (i == 6) {
        break;
    }
    System.out.print(i + " ");
}
// Output: 1 2 3 4 5

When i reaches 6, break exits the loop. Iterations 6 through 10 are never executed. Use break for early exit when a condition is met (e.g., target found in search).

2. The continue Statement

continue skips the remaining body of the current iteration and jumps to the next iteration. In a for loop, the update expression runs before the next condition check. In a while loop, control goes directly to the condition check.

for (int i = 1; i <= 10; i++) {
    if (i % 3 == 0) {
        continue;
    }
    System.out.print(i + " ");
}
// Output: 1 2 4 5 7 8 10

When i is divisible by 3, the print is skipped, but the loop continues with the next value. Use continue to skip unwanted cases without deep nesting.

3. Labeled break and continue

In nested loops, a regular break exits only the innermost loop. To exit an outer loop from inside an inner loop, use a label. A label is an identifier followed by a colon, placed before the loop.

outer:
for (int i = 1; i <= 5; i++) {
    for (int j = 1; j <= 5; j++) {
        if (i * j > 10) {
            break outer; // Exits BOTH loops
        }
        System.out.print(i * j + " ");
    }
    System.out.println();
}

break outer; exits the outer loop entirely, not just the inner one. Without the label, break would exit only the inner loop and the outer loop would continue.

Similarly, continue outer; skips the current iteration of the outer loop (not just the inner loop):

outer:
for (int i = 1; i <= 5; i++) {
    for (int j = 1; j <= 5; j++) {
        if (j == 3) {
            continue outer; // Skip to next i
        }
        System.out.print(i + "" + j + " ");
    }
}

4. return from Loops

The return statement inside a loop exits the entire method, not just the loop. This is useful in methods that search for a value and return it as soon as it is found:

public static int findIndex(int[] arr, int target) {
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == target) {
            return i; // Exits the method entirely
        }
    }
    return -1; // Not found
}

5. How to Analyze and Build Patterns

Every pattern problem follows a systematic approach. Here is the step-by-step method:

1. Identify rows: Count the number of rows. This determines the outer loop (usually for (int i = 1; i <= n; i++)).
2. For each row, identify columns: Look at what is printed in each row. Count the number of characters/spaces per row.
3. Find the relationship: Express the count of spaces and characters in terms of the row number i and the total rows n.
4. Write inner loops: One inner loop for spaces (if needed), another for the character/number/star.
5. Verify with first and last rows: Plug in i=1 and i=n to verify your formula.

6. Common Star Patterns

Right Triangle (Stars)

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

Row i has i stars. Inner loop: for (int j = 1; j <= i; j++)

Inverted Right Triangle

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

Row i has (n - i + 1) stars.

Pyramid

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

Row i has (n - i) leading spaces and (2*i - 1) stars.

Diamond

A diamond is a pyramid (upper half) plus an inverted pyramid (lower half).

7. Common Number Patterns

Floyd's Triangle

1
2 3
4 5 6
7 8 9 10

Numbers increase sequentially. Row i has i numbers.

Pascal's Triangle

         1
       1   1
     1   2   1
   1   3   3   1
 1   4   6   4   1

Each element is the sum of the two elements above it. Value = C(row, col) = row! / (col! * (row-col)!).

8. Character Patterns

A
A B
A B C
A B C D

Row i prints characters from 'A' to ('A' + i - 1). Cast int to char: (char)('A' + j).

Code Examples

public class BreakContinue {
    public static void main(String[] args) {
        // break: find first multiple of 7 in range
        System.out.print("First multiple of 7 after 50: ");
        for (int i = 51; i <= 100; i++) {
            if (i % 7 == 0) {
                System.out.println(i);
                break;
            }
        }

        // continue: print non-multiples of 3
        System.out.print("1-15 (skip multiples of 3): ");
        for (int i = 1; i <= 15; i++) {
            if (i % 3 == 0) continue;
            System.out.print(i + " ");
        }
        System.out.println();
    }
}

public class LabeledBreak {
    public static void main(String[] args) {
        // Find the first pair (i, j) where i * j > 15
        System.out.println("Products until > 15:");

        search:
        for (int i = 1; i <= 5; i++) {
            for (int j = 1; j <= 5; j++) {
                int product = i * j;
                if (product > 15) {
                    System.out.println("\nStopped at i=" + i + ", j=" + j + " (product=" + product + ")");
                    break search; // Exits BOTH loops
                }
                System.out.print(product + "\t");
            }
            System.out.println();
        }

        System.out.println("Done.");
    }
}

public class RightTriangle {
    public static void main(String[] args) {
        int n = 5;

        // Right triangle (left-aligned)
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }

        System.out.println();

        // Inverted right triangle
        for (int i = n; i >= 1; i--) {
            for (int j = 1; j <= i; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

public class Pyramid {
    public static void main(String[] args) {
        int n = 5;

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

public class Diamond {
    public static void main(String[] args) {
        int n = 5;

        // Upper half (pyramid)
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n - i; j++) System.out.print(" ");
            for (int j = 1; j <= 2 * i - 1; j++) System.out.print("*");
            System.out.println();
        }

        // Lower half (inverted pyramid, skip the middle row)
        for (int i = n - 1; i >= 1; i--) {
            for (int j = 1; j <= n - i; j++) System.out.print(" ");
            for (int j = 1; j <= 2 * i - 1; j++) System.out.print("*");
            System.out.println();
        }
    }
}

public class FloydTriangle {
    public static void main(String[] args) {
        int n = 5;
        int num = 1;

        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(num + "\t");
                num++;
            }
            System.out.println();
        }
    }
}

public class PascalTriangle {
    public static void main(String[] args) {
        int n = 6;

        for (int i = 0; i < n; i++) {
            // Leading spaces for alignment
            for (int s = 0; s < n - i - 1; s++) {
                System.out.print("  ");
            }

            int val = 1;
            for (int j = 0; j <= i; j++) {
                System.out.printf("%4d", val);
                val = val * (i - j) / (j + 1);
            }
            System.out.println();
        }
    }
}

public class CharPattern {
    public static void main(String[] args) {
        int n = 5;

        // Pattern 1: A, AB, ABC, ...
        for (int i = 0; i < n; i++) {
            for (int j = 0; j <= i; j++) {
                System.out.print((char)('A' + j) + " ");
            }
            System.out.println();
        }

        System.out.println();

        // Pattern 2: A, BB, CCC, ...
        for (int i = 0; i < n; i++) {
            for (int j = 0; j <= i; j++) {
                System.out.print((char)('A' + i) + " ");
            }
            System.out.println();
        }
    }
}

Common Mistakes

// Intention: exit both loops when found
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (i == 1 && j == 1) {
            break; // Only exits inner loop!
        }
        System.out.print(i + "" + j + " ");
    }
}
// Outer loop continues after inner break

outer:
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (i == 1 && j == 1) {
            break outer; // Exits BOTH loops
        }
        System.out.print(i + "" + j + " ");
    }
}

int i = 0;
while (i < 10) {
    if (i == 5) {
        continue; // i is never incremented past 5!
    }
    System.out.println(i);
    i++;
}

int i = 0;
while (i < 10) {
    i++;
    if (i == 5) {
        continue; // Now i was already incremented
    }
    System.out.println(i);
}

// Intended: 5-row right triangle
int n = 5;
for (int i = 0; i < n; i++) {
    for (int j = 0; j < i; j++) { // Bug: prints 0 stars in row 0
        System.out.print("* ");
    }
    System.out.println();
}

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

// Intended: pyramid
int n = 5;
for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= 2 * i - 1; j++) {
        System.out.print("*");
    }
    System.out.println();
}

int n = 5;
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();
}

Summary