Rectangle Pattern In C++ Program

In this article, you will learn how to create and print various rectangle patterns using C++ programming, a fundamental skill for understanding nested loops and conditional logic.

Problem Statement

Displaying graphical patterns, like rectangles, using characters in a console is a classic programming exercise that solidifies understanding of control flow statements, especially nested for loops. This problem often appears in beginner programming courses and technical interviews to assess logical thinking and loop manipulation. Mastering these patterns is crucial for building more complex graphical representations or even for tasks requiring tabular output formatting.

Example

Here is an example of a simple solid rectangle pattern:

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

Background & Knowledge Prerequisites

To understand and implement rectangle patterns in C++, you should have a basic grasp of:

• Variables: For storing dimensions (rows, columns) and loop counters.
• Input/Output Operations: Using cout for printing and cin for user input.
• for Loops: Essential for iteration and repetition.
• Nested for Loops: Crucial for iterating over both rows and columns in a 2D pattern.
• Conditional Statements (if-else): Necessary for creating hollow patterns or patterns with varying characters.

All examples will use standard C++ libraries, primarily .

Use Cases or Case Studies

Understanding how to generate character patterns can be applied in various scenarios:

• Console-Based Games: Creating simple ASCII art for game elements or interfaces.
• Data Visualization: Representing simple charts or grids in a text-only environment.
• Algorithm Practice: A common problem for practicing nested loops, conditional logic, and problem-solving skills.
• Educational Tools: Demonstrating fundamental programming concepts to new learners.
• Debugging/Testing: Generating structured output for testing specific logic paths in a program.

Solution Approaches

Let's explore several ways to print rectangle patterns in C++.

Approach 1: Solid Rectangle Pattern

This approach creates a rectangle completely filled with a specified character.

• Summary: Uses nested for loops to iterate through rows and columns, printing a character for each cell.

// Solid Rectangle Pattern
#include <iostream>
using namespace std;

int main() {
    int rows = 3;
    int cols = 5;

    // Outer loop for rows
    for (int i = 0; i < rows; ++i) {
        // Inner loop for columns
        for (int j = 0; j < cols; ++j) {
            cout << "*"; // Print a character for each column
        }
        cout << endl; // Move to the next line after each row
    }

    return 0;
}

Run

• Sample Output:

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

• Stepwise Explanation:

1. Initialize rows to 3 and cols to 5 for the rectangle's dimensions.
2. The outer for loop runs rows times, controlling the current row being printed.
3. Inside the outer loop, the inner for loop runs cols times for each row.
4. The inner loop prints the * character cols times horizontally.
5. After the inner loop completes (a full row is printed), cout << endl; moves the cursor to the next line, preparing for the next row.
6. This process repeats until all rows have been printed.

Approach 2: Hollow Rectangle Pattern

This approach creates a rectangle with only its border made of characters, leaving the interior empty.

• Summary: Uses nested for loops and an if condition to print characters only for the first/last row or first/last column.

// Hollow Rectangle Pattern
#include <iostream>
using namespace std;

int main() {
    int rows = 5;
    int cols = 6;

    // Outer loop for rows
    for (int i = 1; i <= rows; ++i) { // Start from 1 for easier condition checks
        // Inner loop for columns
        for (int j = 1; j <= cols; ++j) {
            // Print '*' for the first row, last row, first column, or last column
            if (i == 1 || i == rows || j == 1 || j == cols) {
                cout << "*";
            } else {
                cout << " "; // Print space for the interior
            }
        }
        cout << endl; // Move to the next line after each row
    }

    return 0;
}

Run

• Sample Output:

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

• Stepwise Explanation:

1. Initialize rows to 5 and cols to 6.
2. The outer for loop iterates from i = 1 to rows (inclusive).
3. The inner for loop iterates from j = 1 to cols (inclusive).
4. Inside the inner loop, an if statement checks the current position:

• If i is the first row (i == 1) OR i is the last row (i == rows)
• OR j is the first column (j == 1) OR j is the last column (j == cols)
• Then, print a *.

1. Otherwise (if it's an interior cell), print a space character ( ).
2. cout << endl; moves to the next line after each row.

Approach 3: Rectangle with Number Pattern

This approach fills the rectangle with numbers, demonstrating how the loop counters can be used to generate distinct patterns.

• Summary: Uses nested for loops, printing the current column number or row number to form a sequential pattern.

// Number Rectangle Pattern
#include <iostream>
using namespace std;

int main() {
    int rows = 4;
    int cols = 5;

    // Outer loop for rows
    for (int i = 1; i <= rows; ++i) { // Using 1-based indexing for numbers
        // Inner loop for columns
        for (int j = 1; j <= cols; ++j) {
            cout << j << " "; // Print column number followed by a space
        }
        cout << endl; // Move to the next line after each row
    }

    return 0;
}

Run

• Sample Output:

  1 2 3 4 5
  1 2 3 4 5
  1 2 3 4 5
  1 2 3 4 5

• Stepwise Explanation:

1. Initialize rows to 4 and cols to 5.
2. The outer for loop iterates from i = 1 to rows.
3. The inner for loop iterates from j = 1 to cols.
4. Inside the inner loop, cout << j << " "; prints the current column number (j) followed by a space for separation. This creates a horizontal sequence of numbers.
5. After each row, cout << endl; moves to the next line.
6. If you wanted to print the row number instead, you would change cout << j << " "; to cout << i << " ";.

Conclusion

Creating rectangle patterns in C++ provides an excellent foundation for understanding nested loops and conditional logic. From simple solid blocks to hollow shapes and numerical sequences, these examples showcase how fundamental programming constructs can be combined to produce visual output. Mastering these techniques is a stepping stone to more complex graphical algorithms and data representations.

Summary

• Nested for loops are the primary tool for iterating over rows and columns to form 2D patterns.
• The outer loop typically controls the rows, and the inner loop controls the columns.
• Conditional statements (if-else) are used within the inner loop to create complex patterns like hollow shapes by deciding what to print at each position.
• Loop counters (i and j) can be printed directly to form numerical patterns.
• cout << endl; is essential after the inner loop to move to the next line for the subsequent row.