Diagonal Sides Of A Rhombus Diamond Pattern In C

Introduction

C programming offers a fantastic way to understand fundamental control structures like loops through visual patterns.

In this article, you will learn how to construct and print various rhombus and diamond patterns using C, focusing on both their filled and hollow variations.

Problem Statement

Creating symmetrical patterns, like a diamond or rhombus, in the console requires precise control over character placement (stars and spaces) across multiple rows. The challenge lies in managing the increasing and decreasing number of stars and leading spaces to form the desired geometric shape dynamically, often based on a user-defined size. This skill is crucial for developing logical thinking and mastering nested loops in C.

Example

Here's a typical output of a filled diamond pattern we aim to achieve:

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

 

Background & Knowledge Prerequisites

To follow this article effectively, you should have a basic understanding of:

• C Language Fundamentals: Basic syntax, data types, and variable declaration.
• printf() Function: For printing output to the console.
• for Loops: Essential for iteration and controlling rows and columns.
• Conditional Statements (if-else): For logic within pattern creation.
• abs() Function (from math.h): For calculating absolute values (useful for symmetry).

For all code examples, ensure you include the necessary headers:

#include  // For printf
#include   // For abs (if used)

 

 

Use Cases or Case Studies

While seemingly simple, pattern printing exercises hone skills applicable in various domains:

• Console-Based UI Design: Creating simple text-based interfaces or decorative elements in command-line applications.
• Game Development (Retro/Text-based): Crafting simple graphics for old-school text adventure games or ASCII art games.
• Educational Tools: Visualizing algorithms, particularly those involving loops and spatial reasoning.
• Competitive Programming: Frequently appears as a beginner to intermediate problem to test logical and looping skills.
• Algorithmic Thinking: Helps in breaking down complex visual problems into simpler, iterative steps.

Solution Approaches

We will explore two distinct methods to generate rhombus/diamond patterns, highlighting their "sides" and "diagonals." We'll define the diamond's size using an odd integer n representing its total height (and maximum width in stars).

Approach 1: The Two-Part Iteration (Filled Diamond Pattern)

One-line summary: Construct the diamond by first printing the top half (including the widest row) and then the symmetrical bottom half.

Code Example:

// Filled Diamond Pattern
#include <stdio.h>

int main() {
    int n = 5; // Total number of rows (must be an odd number)
    int i, j;
    int spaces, stars;
    int middle_row = n / 2; // For n=5, middle_row = 2

    // Step 1: Print the top half of the diamond (including the middle row)
    for (i = 0; i <= middle_row; i++) {
        // Calculate spaces: Decreases with each row
        spaces = middle_row - i;
        for (j = 0; j < spaces; j++) {
            printf(" ");
        }

        // Calculate stars: Increases with each row (1, 3, 5...)
        stars = 2 * i + 1;
        for (j = 0; j < stars; j++) {
            printf("*");
        }
        printf("\\n");
    }

    // Step 2: Print the bottom half of the diamond (excluding the middle row)
    for (i = middle_row - 1; i >= 0; i--) {
        // Spaces are the same as the corresponding row in the top half
        spaces = middle_row - i;
        for (j = 0; j < spaces; j++) {
            printf(" ");
        }

        // Stars are the same as the corresponding row in the top half
        stars = 2 * i + 1;
        for (j = 0; j < stars; j++) {
            printf("*");
        }
        printf("\\n");
    }

    return 0;
}

Run

Sample Output (for n=5):

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

 

Stepwise Explanation:

1. Initialization: We set n (e.g., 5) as the total height of the diamond. middlerow is calculated as n / 2 (e.g., 2).
2. Top Half Loop: The first for loop iterates from i = 0 up to middlerow.
   • Spaces: For each row i, middlerow - i spaces are printed. This creates the triangular indentation, moving from more spaces at the top to zero spaces at the widest point.

• Stars: 2 * i + 1 stars are printed. This formula ensures we start with 1 star (for i=0), then 3 (for i=1), 5 (for i=2), and so on, creating the widening effect.
• A newline \n is printed after each row.

1. Bottom Half Loop: The second for loop iterates from i = middlerow - 1 down to 0. This mirrors the top half, but in reverse.
   • The logic for spaces (middlerow - i) and stars (2 * i + 1) remains the same as for the corresponding rows in the top half, creating the narrowing effect.

• Another newline \n ensures each row is on a new line.
• This approach explicitly shows the "sides" by the outermost stars on each row, and the "diagonals" are formed by the path traced by these outermost stars.

Approach 2: Single-Loop with Absolute Value (Hollow Diamond Pattern)

One-line summary: Use a single row loop and abs() function in the column loop to determine if a character should be printed at the boundary points forming a hollow diamond.

Code Example:

// Hollow Diamond Pattern
#include <stdio.h>
#include <math.h> // Required for abs()

int main() {
    int n = 7; // Total number of rows (must be an odd number)
    int i, j;
    int center = n / 2; // For n=7, center = 3

    // Step 1: Loop through each row
    for (i = 0; i < n; i++) {
        // Step 2: Loop through each column for potential character placement
        for (j = 0; j < n; j++) {
            // Condition to print '*' for a hollow diamond
            // This condition checks if the current (i, j) point
            // is on the boundary of a diamond rotated 45 degrees
            if (abs(i - center) + abs(j - center) == center) {
                printf("*");
            } else {
                printf(" ");
            }
        }
        printf("\\n");
    }

    return 0;
}

Run

Sample Output (for n=7):

 

Stepwise Explanation:

• 1. Initialization: We define n as the total height and center as n / 2. center represents the coordinate of the center point of the diamond when conceptually embedded in an n x n grid.
  2. Outer Loop (Rows): The first for loop iterates i from 0 to n-1 for each row.
  3. Inner Loop (Columns): The nested for loop iterates j from 0 to n-1 for each column within the current row.
  4. Hollow Condition: The core logic lies in the if statement: abs(i - center) + abs(j - center) == center.
     • This mathematical formula calculates the "Manhattan distance" (or taxicab geometry distance) from the current point (i, j) to the center point (center, center).
• When this distance equals center, it means the point (i, j) lies exactly on the boundary of the diamond shape.
• If the condition is true, is printed; otherwise, a space is printed.

1. Newline: After checking all columns for a row, a \n moves to the next line.

This approach directly emphasizes the "sides" of the rhombus by only printing the boundary characters. The "diagonals" are implicitly formed by these boundary characters and are clearly visible as the main axes of the shape.

 

Conclusion

Pattern printing in C is an excellent exercise for beginners to solidify their understanding of loops, conditional logic, and spatial reasoning. We've explored two distinct approaches: a direct two-part iteration for a filled diamond and an elegant single-loop method leveraging absolute values for a hollow diamond. Both methods demonstrate how simple characters can form complex symmetrical designs with programmatic control.

Summary

• Diamond/Rhombus Patterns: Are symmetrical geometric shapes created using characters and spaces.
• Problem: Requires careful management of spaces and stars per row to achieve the desired shape.
• Approach 1 (Filled Diamond):
• Divides the pattern into a top half (increasing stars) and a bottom half (decreasing stars).
• Uses two separate for loops for iteration.
• Formulas (middlerow - i) for spaces and (2 i + 1) for stars are key.
• Approach 2 (Hollow Diamond):
• Uses a single set of nested loops for all rows and columns.
• Leverages the abs() function to identify boundary points using the formula abs(row - center) + abs(col - center) == center.
• Only prints characters at the exact "sides" of the diamond.
• Best Practices: Always use an odd number for the diamond's height (n) to ensure perfect symmetry.

---

Challenge Your Skills!

Quiz:

1. What would happen if you used an even number for n (the total height) in the "Filled Diamond" example? How would the pattern be affected?
2. Modify the "Hollow Diamond" code to print a unique character (e.g., #) at the very top, bottom, leftmost, and rightmost points of the diamond.
3. Can you adapt the "Filled Diamond" approach to print a hollow diamond? (Hint: You'll need if conditions inside the star-printing loop.)

 

Call to Action: Experiment with the provided code snippets! Try changing the characters, adjusting the size (n), or even introducing delays between rows using sleep() (requires on Linux/macOS or windows.h on Windows for Sleep()) to see the pattern being drawn dynamically. Share your modified patterns in the comments!