Python Reverse Alphabet Pyramid Pattern (Build to A)
Beginner
6 min read
Updated: Sep 2026
3 programs
Live preview
Definition
What Is This Pattern?
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 i in range(ord('A'), top + 1):
Fixed-width scan
for j in range(top, ord('A') - 1, -1):
Space or letter
print(" " if j > i else chr(j), end="")
Explicit pad
pad = width - (i - ord('A') + 1)
Reverse suffix
for ch in range(i, ord('A') - 1, -1): print(chr(ch), end="")
End the row
print()
Printing Letters vs Starting a New Line
API
Effect
Use for
print(..., end="")
Stays on the same line
Each space and each letter
print()
Ends the current line
After the fixed-width scan
Print cells without a newline, then end the row once.
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
Python 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.
Python
for i in range(ord('A'), ord('E') + 1):
for j in range(ord('E'), ord('A') - 1, -1):
if j > i:
print(" ", end="")
else:
print(chr(j), end="")
print()
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 chr(j). When i is C, that is ··CBA.
3. Full bottom row. When i is 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.
Python
top = ord(input("Enter the top letter (like E): ").strip().upper())
for i in range(ord('A'), top + 1):
for j in range(top, ord('A') - 1, -1):
print(" " if j > i else chr(j), end="")
print()
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 ord('E').
2. Width scales with top. With top = ord('D') you get a 4-column right-aligned pyramid.
3. Safer input tip. Prefer a single uppercase letter:
Safer input
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.")
raise SystemExit
top = ord(raw)
Example 3 — Pad Spaces, Then Reverse Suffix
Often clearer to read: print leading spaces first, then letters from the peak down to A.
Python
top = ord('E')
width = top - ord('A') + 1
for i in range(ord('A'), top + 1):
letters = i - ord('A') + 1
pad = width - letters
print(" " * pad, end="")
for ch in range(i, ord('A') - 1, -1):
print(chr(ch), end="")
print()
Output
A
BA
CBA
DCBA
EDCBA
How It Works
1. Compute pad and length. Peak i needs i - ord('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.
print() early
Broken row
Call bare print() only after the scan. Inside the inner loop (or default print(chr(j))), 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
Index / ValueError
Validate length before using raw[0] or ord(top). 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 - ord('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 ord('H') and the inner scan starts from ord('H') down to ord('A').
print(ch, end="") or print(" ", end="") stays on the same line for each cell. print() 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.
Use input().strip().upper(), take the first character, require A–Z, and reject empty tokens. 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.
