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 ord/chr 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 i in range(ord('A'), top + 1):
Reverse columns
for j in range(top, ord('A') - 1, -1):
Diagonal test
print("*" if i == j else chr(j), end="")
Forward columns
for j in range(ord('A'), top + 1):
End the row
print()
A–Z-safe top
Require a single letter A–Z
Printing Letters vs Starting a New Line
API
Effect
Use for
print(..., end="")
Stays on the same line
Each cell (* or letter)
print()
Ends the current line
After the inner column loop
Print each cell without a newline, then end the row once.
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
Python 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 chr(j).
Python
for i in range(ord('A'), ord('E') + 1):
for j in range(ord('E'), ord('A') - 1, -1):
if i == j:
print("*", end="")
else:
print(chr(j), end="")
print()
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 chr(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.
Python
raw = input("Enter the top letter (like E): ").strip().upper()
if len(raw) != 1 or not ('A' <= raw <= 'Z'):
print("Enter one letter A–Z.")
else:
top = ord(raw)
for i in range(ord('A'), top + 1):
for j in range(top, ord('A') - 1, -1):
print("*" if i == j else chr(j), end="")
print()
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 ord('E').
2. Conditional expression."*" if i == j else chr(j) is the compact version of the if/else in Example 1.
3. Validate one letter. Require length 1 and A–Z after upper() so e behaves like E.
Example 3 — Forward A..E with Diagonal *
Flip the inner loop to A..E. The star now slides left → right on the main diagonal.
Python
for i in range(ord('A'), ord('E') + 1):
for j in range(ord('A'), ord('E') + 1):
print("*" if i == j else chr(j), end="")
print()
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 code points i == j 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.
print early
Broken row
Call bare print() 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 .upper() so e behaves like E.
Empty input
Index / convert crash
Validate length before taking raw[0] or converting — empty strings fail loudly.
Analysis
Time and Space Complexity
Program
Time
Extra space
Reverse / forward forms
O(n²)
O(1)
For top letter with offset n = top - ord('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.
print(..., end="") stays on the same line for each cell. print() 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 upper()), 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.
