A reverse alphabet with diagonal star prints each row as letters from the top letter down to A, but replaces exactly one cell with * where the row key equals the column letter (i == j).
Remember
Rule: print j from top..A; when i == j print '*' instead
EDCB*
EDC*A
ED*BA
E*CBA
*DCBA ← top = E (star slides right → left)
Outer i walks A..E (which letter becomes the star). Inner j walks E..A (what would print in each column). The match slides the star one column left each row.
Approach
How to Solve It
Nested char loops plus one equality test — print a star on the diagonal, the column letter everywhere else.
Method
Idea
Best for
Reverse columns
Inner j from top..A; star slides right → left
Main pattern, interviews
Forward columns
Inner j from A..top; star slides left → right
Comparing diagonal directions
Pseudocode
Pseudocode
for i from 'A' to top:
for j from top down to 'A':
if i == j:
print '*'
else:
print j
print newline
Cheat sheet
Goal
Pattern
Row key (which letter is *)
for (char i = 'A'; i <= top; i++)
Reverse columns
for (char j = top; j >= 'A'; j--)
Diagonal test
Console.Write(i == j ? '*' : j);
Forward columns
for (char j = 'A'; j <= top; j++)
End the row
Console.WriteLine();
A–Z-safe top
Require a single letter A–Z
Write vs WriteLine
API
Effect
Use for
Console.Write
Stays on the same line
Each cell (* or letter)
Console.WriteLine
Ends the current line
After the inner column loop
Try it
Live Preview
Change the top letter and the reverse diagonal-star grid updates instantly — including size and star path.
Enter one letter A–Z. Grid size is n × n where n = top - 'A' + 1.
Live resulttop E · 5×5 · star right→left
EDCB*
EDC*A
ED*BA
E*CBA
*DCBA
Trace
Worked Walkthrough — top = 'E'
Trace each row key i, where i == j fires, and the printed line.
i
Columns j
Star at
Printed row
A
E D C B A
rightmost (A)
EDCB*
B
E D C B A
column B
EDC*A
C
E D C B A
column C
ED*BA
D
E D C B A
column D
E*CBA
E
E D C B A
leftmost (E)
*DCBA
Exactly one * per row. As i climbs A→E, the match moves left through the reverse letter scan.
Code
C# Programs
Three complete programs: fixed top E, top-letter input, and a forward-column contrast. Use View Output to reveal sample results.
Example 1 — Fixed Top E
Outer i runs A..E. Inner j runs E..A. When i == j, print *; otherwise print j.
C#
using System;
class Program
{
static void Main()
{
for (char i = 'A'; i <= 'E'; i++)
{
for (char j = 'E'; j >= 'A'; j--)
{
if (i == j)
Console.Write("*");
else
Console.Write(j);
}
Console.WriteLine();
}
}
}
Output
EDCB*
EDC*A
ED*BA
E*CBA
*DCBA
How It Works
1. Outer loop picks the star letter.i takes A, B, C, D, E — the letter that becomes * on that row.
2. Inner loop prints reverse letters.j scans E..A. When i == j, print *; otherwise print j.
3. Star slides left. Row A matches at the right (EDCB*); row E matches at the left (*DCBA).
Example 2 — Top Letter Input
Read the top letter (like E or D) and generate the same pattern for A..top. 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(i == j ? '*' : j);
}
Console.WriteLine();
}
}
}
Output (when user enters D)
Enter the top letter (like E): D
DCB*
DC*A
D*BA
*CBA
How It Works
1. Same diagonal rule. Only the bounds follow top instead of the literal 'E'.
2. Ternary form.i == j ? '*' : j is the compact version of the if/else in Example 1.
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 — Forward A..E with Diagonal *
Flip the inner loop to A..E. The star now slides left → right on the main diagonal.
C#
using System;
class Program
{
static void Main()
{
for (char i = 'A'; i <= 'E'; i++)
{
for (char j = 'A'; j <= 'E'; j++)
{
Console.Write(i == j ? '*' : j);
}
Console.WriteLine();
}
}
}
Output
*BCDE
A*CDE
AB*DE
ABC*E
ABCD*
How It Works
1. Same diagonal test.i == j still marks exactly one cell per row.
2. Column order flips. Printing A..E instead of E..A reverses letter order and sends the star left → right.
3. Compare with Example 1. Inner-loop direction controls both the letter sequence and which way the star travels.
Edge Cases & Pitfalls
Check these before calling the solution done.
Wrong compare
No diagonal
Comparing row index to column index (ints) instead of i == j (chars) will not mark the letter diagonal correctly.
Always print j
Missing star
Forgetting the i == j branch prints a plain reverse (or forward) letter square with no asterisk.
WriteLine early
Broken row
Call WriteLine only after the inner loop. Inside it, each cell lands on its own line.
top = 'A'
Single *
Output is just * on one line — a good sanity check.
Lowercase
Unexpected range
Normalize input with char.ToUpperInvariant so e behaves like E.
Empty input
Convert.ToChar crash
Convert.ToChar("") throws. Validate length before converting.
Analysis
Time and Space Complexity
Program
Time
Extra space
Reverse / forward forms
O(n²)
O(1)
For top letter with offset n = top - 'A' + 1, the nested loops print an n × n grid — quadratic in n.
Remember
Key Takeaways
Diagonal rule: print * when i == j; otherwise print the column letter.
Reverse scan: inner j from top..A sends the star right → left.
Direction flip: A..top columns reverse the letter order and the star path.
Complexity:O(n²) time for an n × n grid; O(1) extra space.
One line: for each row key i, print reverse letters and replace the cell where i == j with *.
Frequently Asked Questions
i walks A..E down the rows while j scans E..A across columns. The condition i == j marks one diagonal position per row, which gets replaced by '*'.
Because i increases each row, but the printed letters go from E down to A across the row. The match i==j occurs at a different column each time, sliding the star left.
The star prints when i == j, so each row replaces exactly one character at the matching column.
Yes. Replace '*' with any symbol (like '#' or '@') in the conditional branch.
Console.Write stays on the same line for each cell. Console.WriteLine ends the row after the inner loop finishes.
You print forward letters instead of E..A, and the star slides the other way (left to right on the main diagonal).
O(n²) for an n×n letter grid because every row prints n characters.
Read a string, take the first character, require A–Z (or a–z), and reject empty input. Cap at Z if you only want alphabetic ranges.
🤔
Did you know?
The diagonal is defined by i == j while the row prints letters from E down to A. Since i increases A..E each row, the star moves one position left each line: EDCB*, EDC*A, ED*BA, E*CBA, *DCBA.
