A mirrored alphabet with spaces prints a growing left ramp and a matching right mirror, separated by a shrinking band of spaces until the last row meets as ABCDEEDCBA.
Remember
Rule: left A..i + spaces + right i..A (gap shrinks)
A A
AB BA
ABC CBA
ABCD DCBA
ABCDEEDCBA ← top = E
Unlike Program 18 (a continuous palindrome with no gap), this pattern keeps a middle space band that shrinks by two columns each row until both halves touch.
Approach
How to Solve It
For each peak index, print a left half, a space gap, and a mirrored right half — all aligned to a fixed total width.
Method
Idea
Best for
Dual fixed scan
Left: letter if j <= i else space; right: space if k > i else letter
Learning column conditions
Explicit gap
Print left letters, 2*(n-i) spaces, then reverse letters
Clearer reading once the shape is clear
Pseudocode
Pseudocode
n = top - 'A'
for i from 0 to n:
for j from 0 to n:
print letter j if j <= i else space
for k from n down to 0:
print space if k > i else letter k
print newline
Cheat sheet
Goal
Pattern
Half-width index
n = ord(top) - ord('A')
Left ramp
print(alpha[j] if j <= i else " ", end="")
Right ramp
print(" " if k > i else alpha[k], end="")
Explicit gap
print(" " * (2 * (n - i)), end="")
End the row
print()
Last-row meet
When i == n, gap is 0 → ABCDEEDCBA
Printing Letters vs Starting a New Line
API
Effect
Use for
print(..., end="")
Stays on the same line
Each letter and each space cell
print()
Ends the current line
After left + right (or left + gap + right)
Print cells without a newline, then end the row once.
Try it
Live Preview
Change the top letter and the mirrored space pattern updates instantly — including half-width and gap size.
Enter one letter A–J. Half-width is n = top - 'A'; each row is width 2 × (n + 1).
Live resulttop E · width 10 · 5 rows
A A
AB BA
ABC CBA
ABCD DCBA
ABCDEEDCBA
Trace
Worked Walkthrough — top = 'E' (n = 4)
Trace each peak index, the left half, the gap, and the mirrored right half.
i
Left
Gap
Right
Printed row
0
A
8
A
A A
1
AB
6
BA
AB BA
2
ABC
4
CBA
ABC CBA
3
ABCD
2
DCBA
ABCD DCBA
4
ABCDE
0
EDCBA
ABCDEEDCBA
Gap size is 2*(n - i). On the last row the halves meet and the peak letter appears twice (EE).
Code
Python Programs
Three complete programs: fixed A–E dual scan, top-letter input(), and an explicit gap form. Use View Output to reveal sample results.
Example 1 — Fixed A–E
Two fixed-width scans per row. Conditions decide whether to print a letter or a space.
Python
alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
for i in range(5):
for j in range(5):
if j <= i:
print(alpha[j], end="")
else:
print(" ", end="")
for k in range(4, -1, -1):
if k > i:
print(" ", end="")
else:
print(alpha[k], end="")
print()
Output
A A
AB BA
ABC CBA
ABCD DCBA
ABCDEEDCBA
How It Works
1. Outer loop grows the peak.i runs 0..4 so peaks are A through E.
2. Left scan. Print alpha[j] while j <= i; otherwise print a space to fill the half-width.
3. Right scan. Print spaces while k > i, then print descending letters. When i = 4, every column is a letter → ABCDEEDCBA.
Example 2 — Top Letter Input
Build the full width dynamically from the chosen top letter. Prefer validating a single A–Z character in real apps.
Python
top = input("Enter the top letter (like E): ").strip().upper()
n = ord(top) - ord('A')
alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
for i in range(n + 1):
for j in range(n + 1):
print(alpha[j] if j <= i else " ", end="")
for k in range(n, -1, -1):
print(" " if k > i else alpha[k], end="")
print()
Output (when user enters C)
Enter the top letter (like E): C
A A
AB BA
ABCCBA
How It Works
1. Map top → half-width.n = ord(top) - ord('A') sets the shared scan length for both halves.
2. Same dual-scan core. Conditional form of Example 1 — only the bounds follow n.
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 = raw
Example 3 — Letters, Gap Count, Mirror
Often clearer to read: print left letters, print 2*(n-i) spaces, then print the reverse letters.
Python
n = 4 # last index (E)
for i in range(n + 1):
for j in range(i + 1):
print(chr(ord('A') + j), end="")
print(" " * (2 * (n - i)), end="")
for k in range(i, -1, -1):
print(chr(ord('A') + k), end="")
print()
Output
A A
AB BA
ABC CBA
ABCD DCBA
ABCDEEDCBA
How It Works
1. Left letters only. Print A..i without padding inside the half.
2. Explicit gap.2*(n - i) spaces replace the leftover columns from both fixed scans.
3. Mirror from the peak. Print i..A. On the last row the gap is 0, so the peak letter appears twice.
Edge Cases & Pitfalls
Check these before calling the solution done.
Gap = n - i
Half-width gap
Forgetting the 2 * in the explicit form leaves only half the middle spaces — the mirror shifts left.
Right from i-1
Missing peak twin
Starting the right half at i - 1 removes the doubled center on the last row. Only do that if the problem asks for it.
print() early
Broken row
Call bare print() only after both halves. Inside any inner loop (or default print(ch)), each cell lands on its own line.
top = 'A'
Single AA
Output is AA (no gap) — a good sanity check.
No spaces
Wrong pattern
Skipping the space branches collapses into a continuous palindrome each row — that is Program 18, not this one.
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
Dual scan / explicit gap
O(n²)
O(1)
For half-width n + 1 letters, each of n + 1 rows prints 2(n + 1) characters — quadratic in the letter count.
Remember
Key Takeaways
Three parts: left ramp, shrinking space gap, right mirror.
Gap formula:2*(n - i) spaces between the halves.
Final meet: last row has gap 0 and a doubled peak letter.
Complexity:O(n²) time; O(1) extra space.
One line: for each peak, print left letters, a shrinking even gap, then the mirrored right letters.
Frequently Asked Questions
The left loop builds the increasing part and fills the remaining columns with spaces. The right loop fills spaces until the peak, then prints the decreasing mirror.
The spaces keep both halves fixed width so the mirror effect is aligned. The gap shrinks each row until both halves touch.
When i reaches the last letter (E), all positions satisfy the letter conditions on both sides, so both halves print letters and meet as ABCDEEDCBA.
Increase the last index/letter and update the loop bounds so the left and right halves each scan the new width.
print(ch, end="") or print(" ", end="") stays on the same line for each cell. print() ends the row after both halves finish.
Program 18 prints a continuous palindrome with no middle gap. This pattern keeps a shrinking space band between left and right ramps until the final row.
O(n²) for n letters because each row scans n columns twice (left + right).
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 row uses two fixed-width scans from A to E. The first builds the left ramp (letters when j <= i else spaces). The second builds the right ramp (spaces while k > i, else letters). The gap shrinks until the last row meets as ABCDEEDCBA.
