Printing a Alphabet Full Pyramid | Alphabet Patterns in C

After mastering the mirrored triangle, you are ready to construct the Alphabet Full Pyramid. This pattern is the hallmark of intermediate C programming, requiring precise control over both spaces and multiple character sequences in a single row.

What You Will Learn

This tutorial will guide you through creating a symmetric, centered alphabet pyramid. You will learn how to balance leading spaces with two separate inner loops: one for the ascending sequence and one for the descending sequence.

Prerequisites:

• Strong understanding of nested for loops.

• Familiarity with printing characters and handling spaces.

Final Output:

For a 5-row pyramid, the output will look like this:

     A
   ABA
  ABCBA
 ABCDCBA
ABCDEDCBA

Deconstructing the Pattern: The Logic

1. The Visual Representation

A full pyramid is composed of three distinct parts per row:

• Leading Spaces: These decrease as the row index increases, centering the pyramid.

• Ascending Sequence: Prints letters from 'A' up to the row-dependent limit.

• Descending Sequence: Prints letters back down to 'A'.

2. Problem Statement

The goal is to create a centered, symmetric pyramid. We must calculate the number of spaces for alignment and manage two loops that generate a mirrored character sequence for every row.

3. Pattern Analysis & Logic

• Outer Loop: Manages the rows, running from $i = 0$ to $n-1$.

• Space Loop: Prints $(n - i - 1)$ spaces to ensure proper centering.

• Ascending Loop: Prints characters starting from 'A' up to the current row limit.

• Descending Loop: Prints characters backward from the character just before the peak, back down to 'A'.

The Code Implementation

#include <stdio.h>

int main() {
    int n = 5; // Number of rows in the pyramid

    for (int i = 0; i < n; i++) {
        // 1. Print leading spaces
        for (int k = 0; k < n - i - 1; k++) {
            printf(" ");
        }

        // 2. Print ascending characters
        for (int j = 0; j <= i; j++) {
            printf("%c", 'A' + j);
        }

        // 3. Print descending characters
        for (int j = i - 1; j >= 0; j--) {
            printf("%c", 'A' + j);
        }

        // Move to the next line
        printf("\n");
    }

    return 0;
}

Explanation:

• Space Loop (k): Reduces the number of spaces per row as the pyramid grows, keeping the structure centered.

• Ascending Loop (j): Prints the sequence 'A', 'AB', 'ABC', etc., depending on the row index i.

• Descending Loop (j): This loop starts at i - 1 and counts down to 0, creating the "mirror" half of the pyramid.

Sample Output and Analysis

User Input:

• The code is configured for n = 5.

Program Output:

     A
   ABA
  ABCBA
 ABCDCBA
ABCDEDCBA

Output Analysis: In row i=2, we print 2 spaces, then print 'ABC' (ascending), then 'BA' (descending). The combination of these three loops ensures perfect symmetry.

Common Mistakes and Troubleshooting

• Descending Loop Logic: A common error is starting the descending loop at i instead of i - 1, which causes the peak letter to be repeated twice.

• Alignment: If the pyramid looks skewed, check that your space loop condition is strictly n - i - 1.

Complexity Analysis

• Time Complexity: O(n^2), as the nested structure iterates across the rows and columns.

• Space Complexity: O(1), as it uses a fixed amount of variables regardless of n.

Conclusion

By combining spaces with bidirectional character sequences, you have successfully built a professional, symmetric full pyramid. This is the pinnacle of the foundation-level pattern series.

For all Pattern Programs list click here: 

…till the next post, bye-bye & take care