A reverse centered alphabet pyramid prints Program 28’s layered rows down to the A-center line, then mirrors them back up to the top letter — without printing the center twice.
Remember
Rule: PrintRow(i) = left k..0 + right 1..k with (j > i ? j : i)
Phase 1: i = k..0 Phase 2: i = 1..k
E E E E E E E E E
E D D D D D D D E
E D C C C C C D E
E D C B B B C D E
E D C B A B C D E ← center once
E D C B B B C D E
E D C C C C C D E
E D D D D D D D E
E E E E E E E E E ← top = 'E' (9×9)
Program 28 is exactly the upper half. The lower phase starts at i = 1 (B) so the A-center row is not duplicated.
Approach
How to Solve It
Two ways to emit the same diamond — duplicate the row body in both phases, or factor helpers.
Method
Idea
Best for
Two phases inline
Upper k..0, lower 1..k, same row body
Learning, interviews, exams
PrintCell + PrintRow
One place owns the floor rule and both halves
Cleaner demos once the rule clicks
Pseudocode
Pseudocode
k = top - 'A'
define PrintRow(i):
for j from k down to 0: print (j > i ? alpha[j] : alpha[i])
for j from 1 to k: print (j > i ? alpha[j] : alpha[i])
print newline
for i from k down to 0: PrintRow(i) // upper
for i from 1 to k: PrintRow(i) // lower
Change the top letter and the reverse-centered diamond updates instantly — rows = width = 2k + 1.
One letter from A to F. Tap a chip or type a letter — the preview redraws as you go.
Live resultTop E · 9 rows · width 9
E E E E E E E E E
E D D D D D D D E
E D C C C C C D E
E D C B B B C D E
E D C B A B C D E
E D C B B B C D E
E D C C C C C D E
E D D D D D D D E
E E E E E E E E E
Trace
Worked Walkthrough — Top = E (k = 4)
Trace each floor and the resulting 9-letter line across both phases.
Phase
i
Floor
Printed row
Upper
4
E
E E E E E E E E E
Upper
3
D
E D D D D D D D E
Upper
2
C
E D C C C C C D E
Upper
1
B
E D C B B B C D E
Upper
0
A
E D C B A B C D E
Lower
1
B
E D C B B B C D E
Lower
2
C
E D C C C C C D E
Lower
3
D
E D D D D D D D E
Lower
4
E
E E E E E E E E E
Width is always 2×4 + 1 = 9. Total rows are 2×5 − 1 = 9. The A-center row appears only once (upper phase).
Code
C# Programs
Three complete programs: fixed A–E, top-letter input, and a helper-method rewrite. Use View Output to reveal sample results.
Example 1 — Fixed A–E
Same row logic as Program 28, printed in two phases to complete the reverse centered pyramid.
C#
using System;
class Program
{
static void Main()
{
int k = 4; // index for 'E'
char[] alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray();
// Upper half (E down to A)
for (int i = k; i >= 0; i--)
{
for (int j = k; j >= 0; j--)
Console.Write(j > i ? $"{alpha[j]} " : $"{alpha[i]} ");
for (int j = 1; j <= k; j++)
Console.Write(j > i ? $"{alpha[j]} " : $"{alpha[i]} ");
Console.WriteLine();
}
// Lower half (B up to E) — skip repeating the A row
for (int i = 1; i <= k; i++)
{
for (int j = k; j >= 0; j--)
Console.Write(j > i ? $"{alpha[j]} " : $"{alpha[i]} ");
for (int j = 1; j <= k; j++)
Console.Write(j > i ? $"{alpha[j]} " : $"{alpha[i]} ");
Console.WriteLine();
}
}
}
Output
E E E E E E E E E
E D D D D D D D E
E D C C C C C D E
E D C B B B C D E
E D C B A B C D E
E D C B B B C D E
E D C C C C C D E
E D D D D D D D E
E E E E E E E E E
How It Works
1. Fix the top index.k = 4 means the highest letter is E.
2. Upper phase. Floor i runs from k down to 0 — same as Program 28 through the A-center row.
3. Lower phase. Floor i runs from 1 to k so the center line is not printed twice.
4. Same row body. Both phases use left k..0 and right 1..k with j > i ? alpha[j] : alpha[i].
Example 2 — Top Letter Input
Works for A..top with the same two-phase pyramid. Prefer validating a single A–Z character in real apps.
C#
using System;
class Program
{
static void Main()
{
Console.Write("Enter top letter (like E): ");
char top = Convert.ToChar(Console.ReadLine());
int k = top - 'A';
char[] alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray();
for (int i = k; i >= 0; i--)
{
for (int j = k; j >= 0; j--)
Console.Write(j > i ? $"{alpha[j]} " : $"{alpha[i]} ");
for (int j = 1; j <= k; j++)
Console.Write(j > i ? $"{alpha[j]} " : $"{alpha[i]} ");
Console.WriteLine();
}
for (int i = 1; i <= k; i++)
{
for (int j = k; j >= 0; j--)
Console.Write(j > i ? $"{alpha[j]} " : $"{alpha[i]} ");
for (int j = 1; j <= k; j++)
Console.Write(j > i ? $"{alpha[j]} " : $"{alpha[i]} ");
Console.WriteLine();
}
}
}
Output (when user enters C)
Enter top letter (like E): C
C C C C C
C B B B C
C B A B C
C B B B C
C C C C C
How It Works
1. Prompt and scale.k = top - 'A' sets both phases and both halves.
2. Same diamond core. For top = C you get 5 rows of width 5 (2k + 1).
3. Safer input tip. Prefer:
Safer input
string raw = (Console.ReadLine() ?? "").Trim().ToUpperInvariant();
if (raw.Length != 1 || raw[0] < 'A' || raw[0] > 'Z')
{
Console.WriteLine("Enter one letter from A to Z.");
return;
}
char top = raw[0];
Example 3 — Helper Method
Often clearer: one method owns the floor rule; another prints a full row so both phases stay thin.
C#
using System;
class Program
{
static void PrintCell(char[] alpha, int j, int i)
{
Console.Write(j > i ? $"{alpha[j]} " : $"{alpha[i]} ");
}
static void PrintRow(char[] alpha, int k, int i)
{
for (int j = k; j >= 0; j--)
PrintCell(alpha, j, i);
for (int j = 1; j <= k; j++)
PrintCell(alpha, j, i);
Console.WriteLine();
}
static void Main()
{
int k = 4;
char[] alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray();
for (int i = k; i >= 0; i--)
PrintRow(alpha, k, i);
for (int i = 1; i <= k; i++)
PrintRow(alpha, k, i);
}
}
Output
E E E E E E E E E
E D D D D D D D E
E D C C C C C D E
E D C B B B C D E
E D C B A B C D E
E D C B B B C D E
E D C C C C C D E
E D D D D D D D E
E E E E E E E E E
How It Works
1. PrintCell owns the rule.j > i lives in one place.
2. PrintRow owns both halves. Left k..0 and right 1..k, then WriteLine.
3. Thin phases. The two outer loops only decide which floors to visit.
Edge Cases & Pitfalls
Check these before calling the solution done.
i = 0
Duplicate center row
If the lower phase starts at 0, the A-center line prints twice. Keep for (i = 1; i <= k; i++).
Right j = 0
Duplicate center A in a row
The right half of each row must start at 1, same as Program 28.
WriteLine inside
Column of letters
If WriteLine is inside either half-loop, each cell lands on its own line. Use Write for cells; WriteLine only after both halves.
top = A
Single A
When k = 0, upper prints A and lower never runs. A good sanity check.
Upper only
Program 28 by mistake
Forgetting the lower phase leaves the open square. Add for (i = 1; i <= k; i++) with the same row printer.
Bad input
Validate one letter
Trim, uppercase, and require length 1 in A–Z — reject empty or multi-character lines.
Analysis
Time and Space Complexity
Program
Time
Extra space
Two phases inline (Examples 1–2)
O(n²)
O(1) (plus the fixed alphabet table)
Helper methods (Example 3)
O(n²)
O(1)
For n = k + 1 letters, there are 2n - 1 rows of width 2n - 1 — still quadratic in n. Roughly twice Program 28’s cell count, minus one shared center row.
Remember
Key Takeaways
Rule: same PrintRow as Program 28 — upper k..0, lower 1..k.
No double center: lower phase starts at B (i = 1).
Break the row: call WriteLine only after both half-loops.
Complexity:O(n²) time; O(1) extra space.
One line: print Program 28’s rows from k down to 0, then again from 1 up to k.
Frequently Asked Questions
The first loop decreases i from E down to A, printing each layered row toward the center. The second increases i from B back to E with the same row rule so the pyramid widens again without repeating the A-centered row.
Because the A-centered row already appears in the upper half. Starting from B prevents duplicating the center line.
If n is the number of letters from A to the top letter, total rows are 2n−1 (9 rows for A..E).
It prints the border letter when the column index j is above the current row floor i; otherwise it prints the floor letter. The same rule applies on both left and right halves of every row.
The left scan goes E down to A; the right scan goes B up to E so the middle A appears once and the row mirrors.
O(n²) because there are O(n) rows and each row prints O(n) cells.
Read a line, trim it, require a single A–Z character (or ToUpperInvariant), and reject empty or multi-character input.
Program 28 is exactly the upper half of this pyramid. Program 29 reuses that row logic, then mirrors upward from B to E for the closed diamond.
🤔
Did you know?
Reuse Program 28’s row logic twice: first with i from E down to A, then with i from B up to E so the center row is not duplicated. Each row stays full width (2n-1 cells); total rows are also 2n-1 for n letters.
