A palindromic alphabet pyramid prints each row as letters climbing from A to a peak, then descending back to A — so every full row reads the same forward and backward.
Remember
Rule: print A..peak, then (peak-1)..A (center once)
A
ABA
ABCBA
ABCDCBA
ABCDEDCBA ← 5 rows
Unlike Program 1 (only the left half), the mirror starts at peak - 1 so the middle letter is not doubled. Row length is always odd: 2r - 1.
Approach
How to Solve It
For each row, pick a peak letter, print up to it, then mirror back without reprinting the peak.
Method
Idea
Best for
Up then down
Two loops: A..peak then (peak-1)..A
Learning, interviews, left-aligned demos
Centered
Same letters plus leading spaces
Pyramid layout under the widest row
Pseudocode
Pseudocode
for r from 0 to n - 1:
peak = 'A' + r
for ch from 'A' to peak:
print ch (no newline)
for ch from peak - 1 down to 'A':
print ch (no newline)
print newline
Cheat sheet
Goal
Pattern
Pick the peak
peak = chr(ord('A') + r)
Ascending half
for code in range(ord('A'), ord(peak) + 1): print(chr(code), end="")
Descending half
for code in range(ord(peak) - 1, ord('A') - 1, -1): print(chr(code), end="")
String / list form
Forward 0..i, then reverse i-1..0 into alpha
Center the row
print(" " * (n - r - 1), end="")
End the row
print()
A–Z-safe height
Clamp n to 1–26
Printing Letters vs Starting a New Line
API
Effect
Use for
print(..., end="")
Stays on the same line
Each letter (and optional pad spaces)
print()
Ends the current line
After both up and down halves
Print letters without a newline, then end the row once.
Try it
Live Preview
Change the row count and the palindrome pyramid updates instantly — including peak letter and letter totals.
Whole numbers from 1 to 10. Row r (0-based) peaks at A + r; total letters equal n².
Live result5 rows · peak E · 25 letters
A
ABA
ABCBA
ABCDCBA
ABCDEDCBA
Trace
Worked Walkthrough — n = 4
Trace each peak, the ascending half, the descending half, and the full palindrome.
Row r
Peak
Up
Down
Printed row
0
A
A
(none)
A
1
B
AB
A
ABA
2
C
ABC
BA
ABCBA
3
D
ABCD
CBA
ABCDCBA
Lengths: 1 + 3 + 5 + 7 = 16 = 4². Starting the down loop at the peak would wrongly print ABCCBA on row 2.
Code
Python Programs
Three complete programs: fixed A–E with a string, row-count input(), and a centered layout. Use View Output to reveal sample results.
Example 1 — Fixed A–E (String Index)
Print the forward part A..i, then print back from i-1..A.
Python
alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
for i in range(5):
for j in range(i + 1):
print(alpha[j], end="")
for k in range(i - 1, -1, -1):
print(alpha[k], end="")
print()
Output
A
ABA
ABCBA
ABCDCBA
ABCDEDCBA
How It Works
1. Outer loop grows the peak index.i runs 0..4 so peaks are A through E.
2. Forward half. Print alpha[0] through alpha[i] — the ascending side including the center.
3. Mirror without the peak. Reverse from i - 1 down to 0. Starting at i would wrongly print ABCCBA when i = 2.
Example 2 — Row Count Input
Uses ord / chr directly (no string) and computes the peak letter for each row. Prefer try/except in real apps.
Python
n = int(input("Enter number of rows (like 5): "))
for r in range(n):
peak = chr(ord('A') + r)
for code in range(ord('A'), ord(peak) + 1):
print(chr(code), end="")
for code in range(ord(peak) - 1, ord('A') - 1, -1):
print(chr(code), end="")
print()
Output (when user enters 4)
Enter number of rows (like 5): 4
A
ABA
ABCBA
ABCDCBA
How It Works
1. Map row → peak. Row r peaks at chr(ord('A') + r).
2. Same up/down core. Ascend to the peak, then descend from peak - 1 — identical logic to Example 1.
3. Safer input tip. Prefer try/except and stay within A–Z:
Safer input
try:
n = int(input("Enter number of rows (like 5): "))
except ValueError:
print("Enter a whole number from 1 to 26.")
raise SystemExit
if n < 1 or n > 26:
print("Enter a whole number from 1 to 26.")
raise SystemExit
Example 3 — Centered Palindrome Pyramid
Add leading spaces so shorter rows sit under the widest row (same idea as Program 16).
Python
n = 5
for r in range(n):
peak = chr(ord('A') + r)
print(" " * (n - r - 1), end="")
for code in range(ord('A'), ord(peak) + 1):
print(chr(code), end="")
for code in range(ord(peak) - 1, ord('A') - 1, -1):
print(chr(code), end="")
print()
Output
A
ABA
ABCBA
ABCDCBA
ABCDEDCBA
How It Works
1. Pad first. Print n - r - 1 spaces so shorter palindromes sit under the widest row.
2. Same letter logic. Up to peak, then down from peak - 1 — unchanged from Examples 1 and 2.
3. Alignment only. Centering is layout; the palindrome rule does not change.
Edge Cases & Pitfalls
Check these before calling the solution done.
Down from peak
Doubled center
Starting the reverse loop at the peak prints ABCCBA instead of ABCBA. Always start at peak - 1.
Only up
Not a palindrome
Skipping the descending half gives Program 1 style rows (A, AB, ABC…) — not this pattern.
print() early
Broken row
Call bare print() only after both halves. Inside either loop (or default print(chr(...))), each letter lands on its own line.
n = 1
Single A
Output is just A; the mirror loop does not run — a good sanity check.
Past Z
Clamp to 26
More than 26 rows walks the peak past Z. Cap or reject the input.
Bad input
ValueError on int()
Bare int(input()) raises on letters — prefer try/except ValueError and require 1–26.
Analysis
Time and Space Complexity
Program
Time
Extra space
Up/down / centered forms
O(n²)
O(1)
Row r (1-based) prints 2r - 1 letters. Over n rows the total is 1 + 3 + … + (2n - 1) = n².
Remember
Key Takeaways
Two halves: climb A..peak, then descend (peak-1)..A.
Center once: never start the reverse loop at the peak itself.
Odd lengths: each row has 2r - 1 letters; totals sum to n².
Complexity:O(n²) time; O(1) extra space.
One line: for each peak, print A..peak then (peak-1)..A so the row is a palindrome.
Frequently Asked Questions
The peak letter was already printed by the first loop. Starting the mirror at peak-1 avoids printing the center letter twice.
Print A..peak, then print (peak-1)..A so the center letter is not duplicated.
Row r prints 2r-1 letters. Over n rows the total is 1+3+...+(2n-1)=n².
Yes. Print each letter followed by a space in both halves, and update the sample output accordingly.
print(ch, end="") stays on the same line for each letter. print() ends the row after both halves finish.
Program 1 prints only the left half (A, AB, ABC…). This pattern mirrors back down so each full row is a palindrome.
O(n²) for n rows because each row prints O(n) characters and the sum of odd lengths is n².
Use try/except ValueError around int(input()), require n ≥ 1, and cap at 26 so peaks stay within A–Z.
🤔
Did you know?
Each row prints A up to the row peak, then prints back down starting from peak - 1 so the middle letter appears only once. Row length is 2r - 1 for row r, so the total characters over n rows is n².
