C Program To Create A Matrix With Alternating Rectangles Of O And X

Creating a visual pattern within a matrix using simple characters can be a fun and practical exercise in programming. This article will guide you through developing a C program to generate a matrix filled with alternating 'O' and 'X' characters, arranged in concentric rectangular patterns.

Problem Statement

The challenge is to populate a two-dimensional character array (matrix) of given dimensions (rows and columns) such that it displays alternating layers of 'O' and 'X' in a rectangular, "target-like" fashion. The outermost rectangle should start with 'O', the next inner rectangle with 'X', and so on, switching characters for each subsequent layer.

Example

For a 5x5 matrix, the desired output would look like this:

O O O O O
O X X X O
O X O X O
O X X X O
O O O O O

Background & Knowledge Prerequisites

To understand and implement this solution, you should have a basic understanding of:

• C Programming Basics: Variables, data types, input/output operations (printf, scanf).
• Arrays: Declaring and manipulating one-dimensional and two-dimensional arrays (matrices).
• Loops: for and while loops for iteration.
• Conditional Statements: if-else for decision-making.

Use Cases or Case Studies

Generating such patterns might seem purely aesthetic, but similar logic applies in various computational scenarios:

• Game Development: Creating board game layouts, maze generation algorithms, or simple visual effects.
• Image Processing: Basic algorithms for filtering regions, applying transformations to specific areas, or generating synthetic textures.
• Data Visualization: Representing hierarchical or layered data structures in a grid format.
• Algorithmic Challenges: Common practice problems to test understanding of array manipulation and loop control.

Solution Approaches

The most intuitive and efficient way to solve this problem is by iterating through the matrix in layers, much like peeling an onion. Each layer, defined by its outer boundaries, will be filled with the current alternating character.

Approach 1: Layer-by-Layer Filling

This method involves maintaining four boundary variables: top, bottom, left, and right. In each iteration, we fill the current layer's perimeter and then shrink the boundaries inwards, switching the character for the next layer.

• One-line summary: Iterate inwards from the matrix boundaries, filling each concentric rectangle with an alternating character ('O' or 'X').

// Alternating Rectangle Matrix
#include <stdio.h>

void printMatrix(char matrix[100][100], int rows, int cols) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%c ", matrix[i][j]);
        }
        printf("\\n");
    }
}

int main() {
    int rows, cols;

    // Step 1: Get matrix dimensions from the user
    printf("Enter number of rows (max 100): ");
    scanf("%d", &rows);
    printf("Enter number of columns (max 100): ");
    scanf("%d", &cols);

    // Basic validation for dimensions
    if (rows <= 0 || cols <= 0 || rows > 100 || cols > 100) {
        printf("Invalid dimensions. Please enter positive numbers up to 100.\\n");
        return 1;
    }

    // Step 2: Declare the matrix
    char matrix[100][100];

    // Step 3: Initialize boundary variables and fill character
    int top = 0;
    int bottom = rows - 1;
    int left = 0;
    int right = cols - 1;
    char fill_char = 'O'; // Start with 'O' for the outermost layer

    // Step 4: Loop to fill layers until boundaries cross
    while (top <= bottom && left <= right) {
        // Fill top row
        for (int i = left; i <= right; i++) {
            matrix[top][i] = fill_char;
        }
        top++; // Move top boundary inwards

        // Fill right column
        for (int i = top; i <= bottom; i++) {
            matrix[i][right] = fill_char;
        }
        right--; // Move right boundary inwards

        // Fill bottom row (only if valid row exists)
        if (top <= bottom) {
            for (int i = right; i >= left; i--) {
                matrix[bottom][i] = fill_char;
            }
            bottom--; // Move bottom boundary inwards
        }

        // Fill left column (only if valid column exists)
        if (left <= right) {
            for (int i = bottom; i >= top; i--) {
                matrix[i][left] = fill_char;
            }
            left++; // Move left boundary inwards
        }

        // Switch character for the next layer
        fill_char = (fill_char == 'O') ? 'X' : 'O';
    }

    // Step 5: Print the resulting matrix
    printf("\\nGenerated Matrix:\\n");
    printMatrix(matrix, rows, cols);

    return 0;
}

Run

• Sample Output:

Enter number of rows (max 100): 5
    Enter number of columns (max 100): 6

    Generated Matrix:
    O O O O O O 
    O X X X X O 
    O X O O X O 
    O X X X X O 
    O O O O O O

• Stepwise Explanation:

1. Input Dimensions: The program prompts the user to enter the desired number of rows and columns for the matrix. Basic validation prevents invalid inputs.
2. Matrix Declaration: A 2D character array matrix[100][100] is declared to store the characters. Its size is fixed to accommodate up to 100x100 matrices.
3. Initialize Boundaries and Character:
   • top, bottom, left, right variables are set to define the initial outer boundaries of the matrix.

1. Layer Filling Loop: A while loop continues as long as top <= bottom and left <= right. This condition ensures that there is still a valid rectangular region to fill.
   • Fill Top Row: Iterates from left to right along the top row, filling it with fill_char. Then, top is incremented to move the boundary inwards.

1. Print Matrix: After the loop finishes (meaning all layers are filled), the printMatrix helper function iterates through the matrix and displays its contents neatly.

Conclusion

This article demonstrated a structured approach to populate a matrix with alternating 'O' and 'X' characters in concentric rectangular patterns using C. The layer-by-layer filling algorithm, employing four boundary pointers, provides an effective and clean solution for this type of pattern generation. Understanding this technique is beneficial for various array manipulation problems and visual programming tasks.

Summary

• The problem involves creating a matrix with alternating 'O' and 'X' characters in a layered, rectangular fashion.
• A common solution uses four boundary variables (top, bottom, left, right) to define the current rectangle.
• The algorithm iteratively fills the perimeter of the current rectangle and then shrinks the boundaries inwards.
• An alternating character (fill_char) is toggled for each new layer.
• Conditional checks (if (top <= bottom), if (left <= right)) are vital within the loop to handle cases where rows or columns might have been completely processed.