A reverse alphabet right-angled triangle prints letters from a top letter down toward A, growing one character longer each row — the descending mirror of Program 1.
Remember
Rule: each row prints top..i (descending); i walks top..A
E
ED
EDC
EDCB
EDCBA ← 5 rows (top = E)
The inner loop always starts at top. Only the ending letter i moves down each row, so every line begins with the same letter and grows toward A.
Approach
How to Solve It
Count the end letter down from the top, then print from the top down to that end on each row.
Method
Idea
Best for
Char countdown
Outer i from top..A; inner j from top..i
Learning, interviews, fixed demos
Row count
top = 'A' + rows - 1, then same loops
User input for height
Pseudocode
Pseudocode
top = 'A' + rows - 1
for i from top down to 'A':
for j from top down to i:
print j (no newline)
print newline
Cheat sheet
Goal
Pattern
Pick the end letter
for (char i = top; i >= 'A'; i--)
Print top..i
for (char j = top; j >= i; j--) Console.Write(j);
Compute top from rows
char top = (char)('A' + rows - 1);
Spaced letters
Console.Write(j + " ");
End the row
Console.WriteLine();
A–Z-safe height
Clamp rows to 1–26
Write vs WriteLine
API
Effect
Use for
Console.Write
Stays on the same line
Each letter on the row
Console.WriteLine
Ends the current line
After the inner loop
Try it
Live Preview
Change the row count and the reverse triangle updates instantly — including top letter and letter totals.
Whole numbers from 1 to 10. Top letter is A + rows - 1; total letters equal n(n+1)/2.
Live result5 rows · top E · 15 letters
E
ED
EDC
EDCB
EDCBA
Trace
Worked Walkthrough — top = 'E'
Trace each end letter i and the descending run printed from E down to i.
i
Inner j
Printed row
Count
E
E..E
E
1
D
E..D
ED
2
C
E..C
EDC
3
B
E..B
EDCB
4
A
E..A
EDCBA
5
Total letters: 1 + 2 + 3 + 4 + 5 = 15 = n(n+1)/2. That triangular sum is why time is O(n²).
Code
C# Programs
Three complete programs: fixed top E, row-count input, and spaced letters. Use View Output to reveal sample results.
Example 1 — Fixed Top E
Outer loop sets the last letter for each row (E, D, C, B, A). Inner loop prints from 'E' down to that letter.
C#
using System;
class Program
{
static void Main()
{
for (char i = 'E'; i >= 'A'; i--)
{
for (char j = 'E'; j >= i; j--)
{
Console.Write(j);
}
Console.WriteLine();
}
}
}
Output
E
ED
EDC
EDCB
EDCBA
How It Works
1. Outer loop picks the end.i walks E, D, C, B, A — the last letter printed on that row.
2. Inner loop always starts at top. Print from 'E' down to i. When i = 'C', that is EDC.
3. Break the line.WriteLine() after the inner loop starts the next longer reverse run.
Example 2 — Row Count Input
Read the number of rows and compute top = 'A' + rows - 1. Prefer int.TryParse in real apps.
C#
using System;
class Program
{
static void Main()
{
Console.Write("Enter the number of rows: ");
int rows = Convert.ToInt32(Console.ReadLine());
char top = (char)('A' + rows - 1);
for (char i = top; i >= 'A'; i--)
{
for (char j = top; j >= i; j--)
{
Console.Write(j);
}
Console.WriteLine();
}
}
}
Output (when user enters 4)
Enter the number of rows: 4
D
DC
DCB
DCBA
How It Works
1. Map rows → top. For 4 rows, top becomes 'D'.
2. Same nested-loop core. Only the bounds follow top instead of the literal 'E'.
3. Safer input tip. Prefer TryParse and stay within A–Z:
Safer input
if (!int.TryParse(Console.ReadLine(), out int rows) || rows < 1 || rows > 26)
{
Console.WriteLine("Enter a row count from 1 to 26.");
return;
}
Example 3 — Spaced Letters
Print a trailing space after each letter so columns are easier to scan.
C#
using System;
class Program
{
static void Main()
{
char top = 'E';
for (char i = top; i >= 'A'; i--)
{
for (char j = top; j >= i; j--)
{
Console.Write(j + " ");
}
Console.WriteLine();
}
}
}
Output
E
E D
E D C
E D C B
E D C B A
How It Works
1. Same bounds. Outer and inner loops match Example 1 — only the printed unit changes.
2. Letter plus space.j + " " makes columns easier to read at a glance.
3. Compact tip. Trim trailing spaces later if you need a tight line without a final space.
Edge Cases & Pitfalls
Check these before calling the solution done.
Inner starts at A
Wrong order
Starting the inner loop at 'A' and counting up prints the forward triangle (Program 1), not this reverse pattern.
j from i
Missing top letter
Inner must start at top, not i. Starting at i prints a single letter per row.
WriteLine early
Broken row
Call WriteLine only after the inner loop. Inside it, each letter lands on its own line.
rows = 1
Single A
Output is just A — a good sanity check.
Past Z
Clamp to 26
More than 26 rows walks top past Z. Cap or reject the input.
Bad parse
Convert.ToInt32 crash
Prefer int.TryParse so empty or non-numeric input does not throw.
Analysis
Time and Space Complexity
Program
Time
Extra space
Fixed / input / spaced forms
O(n²)
O(1)
Total letters printed = 1 + 2 + … + n = n(n+1)/2, which is quadratic in the number of rows.
Remember
Key Takeaways
Always start at top: inner loop prints top..i, never from A upward.
End letter walks down: outer i from top..A grows each reverse row.
Mirror of Program 1: same triangle shape, descending letter order.
Complexity:O(n²) time; O(1) extra space.
One line: for each end letter counting down, print top..end, then WriteLine.
Frequently Asked Questions
The outer loop sets the last letter on each row from E down to A. For each outer letter i, the inner loop starts at E and prints down to i, so rows grow longer while letters remain in reverse order.
Because the inner loop always starts at top (E in the fixed example). Only the end letter changes with the outer-loop bound, so the triangle grows by one character each row.
Yes. Read rows from the console and set top = (char)('A' + rows - 1). Then loop i from top down to 'A' and print j from top down to i.
Use Program 1: loop upward from 'A' and print to the current end letter. This page is the descending mirror of that pattern.
Console.Write stays on the same line for each letter. Console.WriteLine ends the row after the inner loop finishes.
O(n²) for n rows, because the total printed letters are 1+2+...+n = n(n+1)/2.
Prefer int.TryParse, require n ≥ 1, and cap at 26 so the top letter stays within A–Z.
Yes. Use 'a' as the base: top = (char)('a' + rows - 1), then loop the same way downward.
🤔
Did you know?
This reverse right-angled alphabet triangle prints letters from a top letter down to A on each row. For 5 rows, the output is E, ED, EDC, EDCB, and EDCBA. In C#, decrementing a char works naturally: 'E' - 1 becomes 'D'.
