A right-aligned reverse alphabet pyramid prints reverse suffixes (A, BA, CBA, …) on fixed-width rows, with leading spaces so the letters sit on the right.
Remember
Rule: scan top..A; print space while j > i, else print j
A
BA
CBA
DCBA
EDCBA ← top = E
Unlike Program 2 (left-aligned reverse prefixes E, ED, EDC…), this pattern grows reverse suffixes from the right using the j > i space test.
Approach
How to Solve It
Pick a row peak, scan the full width downward, and print spaces until the peak — then print the reverse letters.
Method
Idea
Best for
Fixed-width scan
Inner j from top..A; j > i → space else letter
Learning one-loop alignment
Explicit pad
Print width - letters spaces, then i..A
Clearer reading once the shape is clear
Pseudocode
Pseudocode
for i from 'A' to top:
for j from top down to 'A':
if j > i:
print space
else:
print j
print newline
Cheat sheet
Goal
Pattern
Row peak
for (char i = 'A'; i <= top; i++)
Fixed-width scan
for (char j = top; j >= 'A'; j--)
Space or letter
Console.Write(j > i ? ' ' : j);
Explicit pad
pad = width - (i - 'A' + 1);
Reverse suffix
for (char ch = i; ch >= 'A'; ch--) Console.Write(ch);
End the row
Console.WriteLine();
Write vs WriteLine
API
Effect
Use for
Console.Write
Stays on the same line
Each space and each letter
Console.WriteLine
Ends the current line
After the fixed-width scan
Try it
Live Preview
Change the top letter and the right-aligned reverse pyramid updates instantly — including width and row count.
Enter one letter A–J. Line width equals top - 'A' + 1; each row is that many columns.
Live resulttop E · width 5 · 5 rows
A
BA
CBA
DCBA
EDCBA
Trace
Worked Walkthrough — top = 'E'
Trace each peak i, how many pads print, and the reverse suffix that lands on the right.
i
Pads
Suffix
Printed row
A
4
A
A
B
3
BA
BA
C
2
CBA
CBA
D
1
DCBA
DCBA
E
0
EDCBA
EDCBA
Every row is width 5. Spaces appear while j > i; letters fill from the peak down to A.
Code
C# Programs
Three complete programs: fixed top E, top-letter input, and an explicit pad-then-suffix form. Use View Output to reveal sample results.
Example 1 — Fixed Top E
Outer i is the row peak. Inner j sweeps E down to A and prints a space until it reaches i.
C#
using System;
class Program
{
static void Main()
{
for (char i = 'A'; i <= 'E'; i++)
{
for (char j = 'E'; j >= 'A'; j--)
{
if (j > i)
Console.Write(" ");
else
Console.Write(j);
}
Console.WriteLine();
}
}
}
Output
A
BA
CBA
DCBA
EDCBA
How It Works
1. Outer loop picks the peak.i walks A..E — the first letter of the visible reverse suffix.
2. Inner loop scans fixed width. While j > i, print a space; otherwise print j. When i = 'C', that is ··CBA.
3. Full bottom row. When i = 'E', every column is a letter → EDCBA.
Example 2 — Top Letter Input
The pattern keeps the line width fixed to the chosen top letter. Prefer validating a single A–Z character in real apps.
C#
using System;
class Program
{
static void Main()
{
Console.Write("Enter the top letter (like E): ");
char top = Convert.ToChar(Console.ReadLine());
for (char i = 'A'; i <= top; i++)
{
for (char j = top; j >= 'A'; j--)
{
Console.Write(j > i ? ' ' : j);
}
Console.WriteLine();
}
}
}
Output (when user enters D)
Enter the top letter (like E): D
A
BA
CBA
DCBA
How It Works
1. Same j > i rule. Only the shared bounds follow top instead of the literal 'E'.
2. Width scales with top. With top = 'D' you get a 4-column right-aligned pyramid.
3. Safer input tip. Prefer a single uppercase letter:
Safer input
string raw = Console.ReadLine()?.Trim() ?? "";
if (raw.Length != 1 || raw[0] < 'A' || raw[0] > 'Z')
{
Console.WriteLine("Enter one letter A–Z.");
return;
}
char top = raw[0];
Example 3 — Pad Spaces, Then Reverse Suffix
Often clearer to read: print leading spaces first, then letters from the peak down to A.
C#
using System;
class Program
{
static void Main()
{
char top = 'E';
int width = top - 'A' + 1;
for (char i = 'A'; i <= top; i++)
{
int letters = i - 'A' + 1;
int pad = width - letters;
for (int s = 0; s < pad; s++)
Console.Write(' ');
for (char ch = i; ch >= 'A'; ch--)
Console.Write(ch);
Console.WriteLine();
}
}
}
Output
A
BA
CBA
DCBA
EDCBA
How It Works
1. Compute pad and length. Peak i needs i - 'A' + 1 letters and width - letters leading spaces.
2. Two clear loops. First pad, then print i down to A — same visual pyramid as the scan version.
3. When to use which. Keep the scan form for exams that ask one inner loop; use explicit pad when readability matters more.
Edge Cases & Pitfalls
Check these before calling the solution done.
j from A
Forward letters
Scanning upward prints AB, ABC, … instead of reverse suffixes. Keep j descending from top.
No spaces
Left-aligned
Skipping the j > i space branch left-aligns the reverse suffixes — you lose the right-aligned pyramid.
WriteLine early
Broken row
Call WriteLine only after the scan. Inside the inner loop, each cell lands on its own line.
top = 'A'
Single A
Output is just A (no pads) — a good sanity check.
Wrong compare
j >= i spaces
Using j >= i for spaces skips the peak letter. Spaces belong only while j > i.
Empty input
Convert.ToChar crash
Validate length before converting. Prefer a single A–Z character.
Analysis
Time and Space Complexity
Program
Time
Extra space
Scan / explicit pad forms
O(n²)
O(1)
For n = top - 'A' + 1 letters there are n rows and each row scans n columns — quadratic in n.
Remember
Key Takeaways
Fixed width: every row scans top..A so alignment stays consistent.
Space test: print space while j > i; otherwise print the reverse letter.
Vs Program 2: reverse suffixes on the right, not reverse prefixes on the left.
Complexity:O(n²) time; O(1) extra space.
One line: for each peak, scan top..A and print spaces until the peak, then the reverse suffix.
Frequently Asked Questions
j walks from E down to A. While j is above the current row peak i, print spaces; once j reaches i and below, print letters. That pushes the visible suffix (like CBA) to the right of a fixed-width line.
Because we print leading spaces for columns where j > i. That pushes the letters to the right and forms a right-aligned pyramid.
Descending j prints letters in reverse order (BA, CBA, DCBA). If j went upward, you would get AB, ABC, ABCD instead.
Update the loop bounds so the outer loop runs up to H and the inner scan starts from H down to A.
Console.Write stays on the same line for each cell. Console.WriteLine ends the row after the fixed-width scan finishes.
Program 2 prints reverse prefixes left-aligned (E, ED, EDC…). This pattern prints reverse suffixes right-aligned with leading spaces (A, BA, CBA…).
O(n²) for n letters because there are n rows and each row scans n positions.
Read a string, take the first character, require A–Z, and reject empty input. Cap at Z if you only want alphabetic ranges.
🤔
Did you know?
Each line has fixed width (five columns for A…E). Scanning j from E down to A, letters higher than the row peak i turn into spaces, so the visible suffix (CBA, DCBA, …) sits on the right.
