Hollow Diamond Inscribed In A Rectangle In C++ Code

In this article, you will learn how to generate a hollow diamond pattern encased within a rectangular frame using C++ programming. This involves applying nested loops and conditional logic to print specific characters in the console.

Problem Statement

Creating patterns using characters in the console is a common programming exercise that helps in understanding loops and conditional statements. The challenge here is to construct a visual pattern that displays a hollow diamond, centered and inscribed within a rectangular border. Both the diamond's perimeter and the rectangle's border should be represented by asterisks (*), while the interior of both shapes remains empty, filled with spaces. The size of the pattern should be dynamic, based on user input.

Example

Here is an example of a hollow diamond inscribed in a rectangle for an input size of 3 (which results in a 5x5 grid):

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

Background & Knowledge Prerequisites

To understand and implement the solution, a basic grasp of the following C++ concepts is essential:

• Variables and Data Types: For storing input size and loop counters.
• Input/Output Operations: Using cin to get user input and cout to print characters to the console.
• Loops: Especially for loops, for iterating through rows and columns of the pattern.
• Conditional Statements: if-else statements, for determining whether to print an asterisk or a space at each position.
• Mathematical Functions: The abs() function (from or ) for calculating absolute differences, which is useful in defining geometric patterns.

Use Cases or Case Studies

Character-based pattern generation, while seemingly simple, serves several pedagogical and practical purposes:

• Beginner Programming Practice: Excellent for reinforcing understanding of loops, nested loops, and conditional logic.
• Algorithm Design Challenges: Similar logic can be extended to more complex graphical patterns or even simple ASCII art generators.
• Console-Based UI Elements: In very basic console applications, character patterns can be used to draw borders, separators, or simple visual indicators.
• Geometric Understanding: Helps visualize coordinates and distances in a grid system.
• Debugging and Visualization: Sometimes, creating simple visual outputs can help in debugging coordinate-based algorithms.

Solution Approaches

We will implement a single, comprehensive approach that uses nested loops and specific conditional logic to render both the rectangle and the hollow diamond.

Using Nested Loops and Conditional Logic

This approach iterates through each cell of a virtual grid, calculating its row and column indices. Based on these indices, it applies conditional statements to determine if the current cell falls on the border of the rectangle or the perimeter of the hollow diamond.

// Hollow Diamond Inscribed in a Rectangle
#include <iostream> // Required for input/output operations (cin, cout)
#include <cmath>    // Required for the abs() function

int main() {
    // Step 1: Get the size from the user
    // The input 'n' determines the 'radius' of the diamond and
    // thus the overall dimensions of the square grid (2*n - 1 by 2*n - 1).
    int n;
    std::cout << "Enter the size for the diamond (e.g., 3 for a 5x5 grid): ";
    std::cin >> n;

    // Calculate total dimensions based on 'n'
    // A diamond with 'n' as its half-width/height will have
    // (2*n - 1) rows and (2*n - 1) columns.
    int total_rows = 2 * n - 1;
    int total_cols = 2 * n - 1;
    
    // The center row/column index of the grid
    int center_coord = n - 1;

    // Step 2: Iterate through each row and column of the grid
    for (int row = 0; row < total_rows; ++row) {
        for (int col = 0; col < total_cols; ++col) {
            // Step 3: Check conditions for printing '*' or ' '

            // Condition for the rectangle border
            // An asterisk is printed if the cell is on the top, bottom, left, or right edge.
            bool is_rectangle_border = (row == 0 || row == total_rows - 1 ||
                                        col == 0 || col == total_cols - 1);

            // Condition for the hollow diamond perimeter
            // A point (row, col) is on the perimeter of a diamond centered at (center_coord, center_coord)
            // with a 'radius' of center_coord if the sum of absolute differences
            // from the center equals the 'radius'.
            bool is_diamond_perimeter = (std::abs(row - center_coord) + std::abs(col - center_coord) == center_coord);

            // Step 4: Print '*' if either condition is met, otherwise print ' '
            if (is_rectangle_border || is_diamond_perimeter) {
                std::cout << "*";
            } else {
                std::cout << " ";
            }
        }
        // Move to the next line after each row is complete
        std::cout << std::endl;
    }

    return 0;
}

Run

Sample Output

When the program is run and 3 is entered as the size:

Enter the size for the diamond (e.g., 3 for a 5x5 grid): 3
*****
* * *
** **
* * *
*****

When 4 is entered as the size (resulting in a 7x7 grid):

Enter the size for the diamond (e.g., 3 for a 5x5 grid): 4
*******
*  *  *
* * * *
**   **
* * * *
*  *  *
*******

Stepwise Explanation

1. User Input for Size (n): The program first prompts the user to enter an integer n. This n determines the size of the diamond. For instance, if n=3, the diamond will have a width of 2*3 - 1 = 5 characters at its widest point.
2. Calculate Grid Dimensions:

• total_rows and total_cols are both set to 2 * n - 1. This ensures the grid is square and large enough to contain the diamond.
• center_coord is calculated as n - 1. This represents the 0-indexed row and column of the exact center of the grid, which is also the "radius" for the diamond's formula.

1. Nested Loops for Grid Traversal:

• An outer for loop iterates from row = 0 to total_rows - 1.
• An inner for loop iterates from col = 0 to total_cols - 1.
• These loops together ensure that every character position (row, col) within the total_rows by total_cols grid is processed.

1. Conditional Logic for Character Placement:

• is_rectangle_border: This boolean variable becomes true if the current (row, col) position is on the very first row (row == 0), the very last row (row == total_rows - 1), the very first column (col == 0), or the very last column (col == total_cols - 1). These conditions define the outer rectangular frame.
• is_diamond_perimeter: This boolean variable becomes true if the current (row, col) position is part of the hollow diamond's outline. The condition std::abs(row - center_coord) + std::abs(col - center_coord) == center_coord mathematically defines all points (row, col) that are at a Manhattan distance of center_coord from the (center_coord, center_coord). This forms the diamond's perimeter.

1. Printing Characters:

• Inside the inner loop, an if statement checks if (is_rectangle_border || is_diamond_perimeter). If *either* the current cell is part of the rectangle's border *or* part of the diamond's perimeter, an asterisk (*) is printed.
• Otherwise (if neither condition is true), a space ( ) is printed.

1. New Line: After the inner loop completes (meaning an entire row has been printed), std::cout << std::endl; is executed to move the cursor to the next line, ensuring the pattern is printed row by row.

Conclusion

Generating patterns like a hollow diamond inscribed in a rectangle is an excellent way to practice fundamental programming concepts. By combining nested loops and precise conditional logic, we can create complex visual outputs from simple character prints. This particular solution effectively uses mathematical properties of the diamond shape and straightforward boundary checks for the rectangle, resulting in a clean and scalable pattern.

Summary

• Problem: Create a hollow diamond pattern inside a rectangle using * characters in C++.
• Core Concepts: Nested for loops, if-else statements, std::abs() function.
• Rectangle Logic: row == 0 || row == total_rows - 1 || col == 0 || col == total_cols - 1 identifies the outer frame.
• Hollow Diamond Logic: std::abs(row - center_coord) + std::abs(col - center_coord) == center_coord identifies the diamond's perimeter.
• Combination: An asterisk is printed if a cell satisfies either the rectangle border or the diamond perimeter condition.
• Scalability: The pattern's size dynamically adjusts based on user input n.