C Program To Make Print Rectangle Shape

Creating geometric shapes using characters is a fundamental programming exercise that introduces concepts like loops and conditional statements. In this article, you will learn how to write a C program to print various rectangle shapes, from solid to hollow, understanding the underlying logic.

Problem Statement

The challenge is to generate a rectangular pattern on the console using specific characters, typically asterisks (*). This involves arranging characters in rows and columns to form a visual rectangle of a specified height and width. This basic problem lays the groundwork for more complex pattern generation and helps in understanding iterative control structures.

Example

A simple solid rectangle of 5 rows and 10 columns would look like this:

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

Background & Knowledge Prerequisites

To understand this article, you should have a basic grasp of:

• C Language Fundamentals: Variables, data types, and input/output operations (printf, scanf).
• Loops: Especially for loops, as they are crucial for iterating through rows and columns.
• Conditional Statements: if statements will be used for creating hollow shapes.

No special imports or setup are needed beyond a standard C compiler (like GCC).

Use Cases or Case Studies

Printing character patterns, including rectangles, serves several practical purposes in programming education and application:

• Learning Loops and Control Flow: It's an excellent way to grasp how nested loops control iteration in two dimensions.
• Text-Based User Interfaces: Historically, and sometimes in embedded systems, text-based graphics are used to create simple visual layouts.
• ASCII Art Generation: A foundational skill for creating more complex ASCII art.
• Debugging and Visualization: Simple patterns can be used to visualize array structures or data grids in a console-based debugger.
• Educational Tool: Often used in introductory programming courses to teach problem-solving and algorithmic thinking.

Solution Approaches

Here are three approaches to printing rectangle shapes in C.

Approach 1: Printing a Solid Rectangle of Fixed Size

This approach demonstrates the most basic way to print a solid rectangle using nested for loops with predefined dimensions.

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

// Solid Rectangle (Fixed Size)
#include <stdio.h>

int main() {
    // Step 1: Define rectangle dimensions
    int numRows = 5;
    int numCols = 10;

    // Step 2: Outer loop for rows
    for (int i = 0; i < numRows; i++) {
        // Step 3: Inner loop for columns
        for (int j = 0; j < numCols; j++) {
            printf("*"); // Print asterisk for each column
        }
        printf("\\n"); // Move to the next line after each row
    }

    return 0;
}

Run

Sample Output:

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

Stepwise Explanation:

1. We define numRows and numCols to set the height and width of the rectangle.
2. The outer for loop (for (int i = 0; i < numRows; i++)) controls the number of rows. It runs numRows times.
3. Inside the outer loop, the inner for loop (for (int j = 0; j < numCols; j++)) controls the number of columns. It runs numCols times for each row.
4. printf("*"); prints an asterisk for each iteration of the inner loop, effectively building a row of asterisks.
5. After the inner loop completes (a full row is printed), printf("\n"); inserts a newline character, moving the cursor to the beginning of the next line, ready for the next row.

Approach 2: Printing a Solid Rectangle with User-Defined Dimensions

This approach extends the first by allowing the user to specify the rectangle's dimensions during program execution.

• Summary: Prompts the user for the number of rows and columns, then uses nested loops to print a solid rectangle according to these inputs.

// Solid Rectangle (User-Defined Size)
#include <stdio.h>

int main() {
    // Step 1: Declare variables for rows and columns
    int numRows, numCols;

    // Step 2: Prompt user for input
    printf("Enter the number of rows: ");
    scanf("%d", &numRows);
    printf("Enter the number of columns: ");
    scanf("%d", &numCols);

    // Step 3: Input validation (optional but good practice)
    if (numRows <= 0 || numCols <= 0) {
        printf("Dimensions must be positive integers.\\n");
        return 1; // Indicate an error
    }

    printf("\\nYour rectangle:\\n");

    // Step 4: Outer loop for rows
    for (int i = 0; i < numRows; i++) {
        // Step 5: Inner loop for columns
        for (int j = 0; j < numCols; j++) {
            printf("*");
        }
        printf("\\n");
    }

    return 0;
}

Run

Sample Output:

Enter the number of rows: 3
Enter the number of columns: 7

Your rectangle:
*******
*******
*******

Stepwise Explanation:

1. Variables numRows and numCols are declared to store user input.
2. printf statements prompt the user, and scanf reads integer values for the dimensions.
3. An optional if condition checks if the input dimensions are positive. If not, an error message is printed, and the program exits.
4. The nested for loops then function identically to Approach 1, but they use the user-provided numRows and numCols for their iteration limits.

Approach 3: Printing a Hollow Rectangle

This approach demonstrates how to print a rectangle where only the border is made of characters, and the interior is empty (filled with spaces).

• Summary: Uses nested loops and an if condition to print characters only for the first row, last row, first column, or last column, otherwise printing a space.

// Hollow Rectangle
#include <stdio.h>

int main() {
    // Step 1: Declare variables for rows and columns
    int numRows, numCols;

    // Step 2: Prompt user for input
    printf("Enter the number of rows: ");
    scanf("%d", &numRows);
    printf("Enter the number of columns: ");
    scanf("%d", &numCols);

    // Step 3: Input validation
    if (numRows <= 0 || numCols <= 0) {
        printf("Dimensions must be positive integers.\\n");
        return 1;
    }
    // Special case for very small rectangles that cannot be hollow
    if (numRows < 2 || numCols < 2) {
        printf("Minimum dimensions for a hollow rectangle are 2x2. Printing solid instead.\\n");
        // Fallback to solid rectangle logic for small inputs if desired, or exit.
        // For this example, we'll still try to print based on the logic, which will be solid.
    }


    printf("\\nYour hollow rectangle:\\n");

    // Step 4: Outer loop for rows
    for (int i = 0; i < numRows; i++) {
        // Step 5: Inner loop for columns
        for (int j = 0; j < numCols; j++) {
            // Step 6: Conditional check to print '*' or ' '
            if (i == 0 || i == numRows - 1 || j == 0 || j == numCols - 1) {
                printf("*"); // Print '*' for border (first/last row, first/last column)
            } else {
                printf(" "); // Print ' ' for interior
            }
        }
        printf("\\n");
    }

    return 0;
}

Run

Sample Output:

Enter the number of rows: 5
Enter the number of columns: 8

Your hollow rectangle:
********
*      *
*      *
*      *
********

Stepwise Explanation:

1. Similar to Approach 2, user input for numRows and numCols is obtained. Input validation is also present.
2. The nested for loops iterate through each cell of the rectangle.
3. The key difference is the if condition inside the inner loop:

• i == 0: Checks if it's the first row.
• i == numRows - 1: Checks if it's the last row.
• j == 0: Checks if it's the first column.
• j == numCols - 1: Checks if it's the last column.

1. If any of these conditions are true (meaning the current cell is part of the border), an asterisk (*) is printed.
2. Otherwise (if none of the conditions are true, meaning the cell is in the interior), a space ( ) is printed.
3. printf("\n"); ensures each row is printed on a new line.

Conclusion

Printing character-based rectangles is a foundational exercise in C programming that effectively demonstrates the power of nested loops and conditional statements. By understanding these approaches, you can generate solid, user-defined, and hollow rectangular patterns, providing a strong basis for more intricate graphical outputs and algorithmic problem-solving.

Summary

• Solid Rectangle (Fixed Size): Uses nested for loops with predefined dimensions to print a block of characters.
• Solid Rectangle (User-Defined Size): Extends the basic approach by incorporating scanf to allow users to input row and column counts.
• Hollow Rectangle: Employs an if condition within the nested loops to differentiate between border cells (printing a character) and interior cells (printing a space).
• Key Concept: Nested loops are essential for iterating over two-dimensional structures like rows and columns.
• Conditional Logic: if statements are crucial for creating varied patterns within the loop structure, enabling hollow shapes.