Centered Alphabet Palindrome Pyramid (A, ABA, ABCBA, ...) in Python

Beginner

⏱️ 8 min read

📚 Updated: Aug 2026

🎯 3 Code Examples

🚀 Live Preview

Mirror Loops

Centered alphabet palindrome pyramid A ABA ABCBA in Python programming

Overview

What You’ll Learn

Each row is a centered palindrome of letters: row 0 prints A, row 1 prints ABA, row 2 prints ABCBA, until the bottom row shows ABCDEDCBA for five rows. Leading spaces (rows - 1 - r) center the pyramid; ascend and descend loops mirror letters without duplicating the peak. Compare with Program 18 (left-aligned palindrome pyramid). Includes a live preview, worked Python examples, edge cases, and complexity.

Palindrome Rule

A..peak..A

Each row ascends from A to the peak, then descends from peak - 1 back to A.

Leading Spaces

rows - 1 - r

print(" " * (rows - 1 - r), end="") centers each palindrome row under the apex.

Ascend Loop

A..peak

for code in range(base, peak + 1): prints letters up to and including the peak.

Descend Loop

peak-1..A

for code in range(peak - 1, base - 1, -1): mirrors back without repeating the peak.

Live Preview

1–26 rows

Pick a row count and draw the centered palindrome pyramid in the browser instantly.

O(n²)

Complexity

Row r prints 2r + 1 letters; total letters = n² ≈ O(n²); extra memory stays O(1).

Introduction

A centered alphabet palindrome pyramid prints each row as a mirror string of letters, padded with leading spaces so the shape is centered. Row 0 prints A; each next row adds one more letter to the peak and mirrors back — ABA, ABCBA, and so on.

In Python you solve it with an outer loop over row index r, a space prefix, two inner loops for ascend and descend, and ord()/chr() — or build left and right strings and concatenate for clarity.

Why it matters?

It combines three classic pattern skills — centering with spaces, ascending sequences, and mirror loops that skip the peak — the same building blocks used in diamonds, hollow pyramids, and symmetric ASCII art. Compare with Program 18 to see how centering transforms the same palindrome rows.

Key Highlights

Leading Spaces

" " * (rows - 1 - r) — row 0 gets rows - 1 spaces; bottom row gets none.

Ascend Half

range(base, peak + 1) — prints A through the row peak letter.

Descend Half

range(peak - 1, base - 1, -1) — mirrors back starting below the peak.

No Peak Duplicate

Descend starts at peak - 1 so ABCBA stays a true palindrome.

In short: set base = ord('A'), loop r from 0 to rows - 1, print (rows - 1 - r) spaces, ascend A..peak, descend (peak-1)..A, then print() for the newline.

Foundation

📝 Problem & Approach

Given a positive integer rows, print a centered pyramid of rows lines. Row r prints (rows - 1 - r) leading spaces, then letters from A up to chr(ord('A') + r), then back down from peak - 1 to A.

Python

# First 5 rows (centered)
    A
   ABA
  ABCBA
 ABCDCBA
ABCDEDCBA

Inputs & Outputs

Item	Type	Description
`rows`	int	Number of rows (peak letter runs A through the rows-th letter). Clamp to 1–26 for A–Z demos.
Printed output	text	Centered palindrome pyramid: each row is a mirror string with leading spaces — widest row has `2*rows - 1` letters.

Minimal workflow

Pseudocode

base = ord('A')
for r from 0 to rows-1:
    print (rows-1-r) spaces
    peak = base + r
    for code from base to peak: print chr(code)
    for code from peak-1 down to base: print chr(code)
    print newline

Approach comparison

Approach	Idea	Best for
Ascend + descend loops	Two `for code in range(...)` loops with `print(..., end="")`	Learning mirror loops and peak-off-by-one
Left/right strings	`''.join(chr(c) for c in range(...))` then concatenate	Clearer debugging and row inspection
Program 18 contrast	See Program 18 (left-aligned palindrome)	Same palindrome logic without centering spaces

Cheat Sheet

⚡ Quick Reference

Goal	Pattern
Leading spaces	`print(" " * (rows - 1 - r), end="")`
Outer loop (row index)	`for r in range(rows):`
Peak letter code	`peak = base + r`
Ascend loop	`for code in range(base, peak + 1): print(chr(code), end="")`
Descend loop	`for code in range(peak - 1, base - 1, -1): print(chr(code), end="")`
End the row	`print()`
String variant	`left + right` with `''.join(chr(c) for c in range(...))`

Compare

📋 Leading Spaces vs Ascend vs Descend

Three parts of every row — pick the mental model that clicks for you.

Leading spaces

rows - 1 - r
centers row

Top row gets the most padding; bottom row aligns flush left before letters.

Ascend loop

base..peak
A, AB, ABC...

Prints letters from A up to and including the row peak.

Descend loop

peak-1..base
mirror half

Walks back down from one below the peak — avoids duplicating the center letter.

Program 18 contrast

no spaces
left-aligned

Same palindrome rows — see Program 18 without centering.

Context

When This Pattern Shows Up

Reach for centered palindrome pyramids when teaching mirror loops, spacing, and symmetric row building after diagonal patterns.

After Program 31
Program 31 places letters on two diagonals forming an X. This pattern builds full palindrome strings centered with leading spaces.
Mirror loop practice
Master the peak - 1 start index before tackling full diamonds and hollow shapes.
Centering with spaces
The (rows - 1 - r) space formula appears in centered stars, numbers, and diamond patterns.
Gateway to Program 33
Next pattern widens letter pairs — another symmetric triangle variation.
Not a UI layout tool
This is a console teaching pattern — not how you build modern app screens.

Key benefit: one program that combines centering spaces with mirror loops — the same two skills used in diamond patterns, hollow pyramids, and symmetric ASCII art far beyond alphabet demos.

Interactive

🔮 Live Preview

Choose a row count between 1 and 26 and draw the centered alphabet palindrome pyramid in the browser.

Hands-On

Examples Gallery

Three complete Python programs — fixed five rows with ascend/descend loops, console input with the same logic, and a left/right string variant for clarity. Click View Output to reveal sample console results.

📚 Getting Started

Print five rows of the centered alphabet palindrome pyramid with leading spaces and mirror loops.

Example 1 — Fixed `rows = 5`

Hard-coded height — ideal for first demos and screenshots.

Python

rows = 5
rows = max(1, min(rows, 26))

base = ord('A')

for r in range(rows):  # 0..4
    # Centering spaces
    print(" " * (rows - 1 - r), end="")

    peak = base + r

    # Ascend: A..peak
    for code in range(base, peak + 1):
        print(chr(code), end="")

    # Descend: (peak-1)..A
    for code in range(peak - 1, base - 1, -1):
        print(chr(code), end="")

    print()

How It Works

The outer loop walks row index r from 0 to 4. For each row, print(" " * (rows - 1 - r), end="") centers the palindrome, then peak = base + r sets the row peak letter. The ascend loop prints A through the peak; the descend loop mirrors from peak - 1 back to A without duplicating the center. Row 0 prints only A with four leading spaces; row 4 prints the full ABCDEDCBA with no spaces.

📈 Practical Variant

Let the user choose the height at runtime.

Example 2 — User Input Version

Read rows and clamp to 1–26. Wrap int(input()) in try/except ValueError in real apps.

Python

rows = int(input("Enter number of rows (max 26): "))
rows = max(1, min(rows, 26))

base = ord('A')

for r in range(rows):
    print(" " * (rows - 1 - r), end="")
    peak = base + r
    for code in range(base, peak + 1):
        print(chr(code), end="")
    for code in range(peak - 1, base - 1, -1):
        print(chr(code), end="")
    print()

How It Works

Same centered palindrome core as Example 1; only the row count comes from input. Three rows produce A, ABA, and ABCBA with 2, 1, and 0 leading spaces respectively.

⚡ String Join Variant

Build left and right halves as strings, then print spaces + left + right.

Example 3 — Left/Right String Variant

Build ascend and descend halves with generator expressions — same logic, easier row inspection.

Python

rows = 5
rows = max(1, min(rows, 26))

base = ord('A')

for r in range(rows):
    peak = base + r
    left = ''.join(chr(c) for c in range(base, peak + 1))
    right = ''.join(chr(c) for c in range(peak - 1, base - 1, -1))
    print(" " * (rows - 1 - r) + left + right)

How It Works

left builds the ascend half and right builds the descend half as strings. Concatenating with leading spaces produces identical output to Examples 1 and 2, but you can inspect left and right separately during debugging.

🧠 How the Algorithm Prints Rows

Set up bounds

Clamp rows, then set base = ord('A') for the alphabet starting point.

base / rows

Print leading spaces

print(" " * (rows - 1 - r), end="") centers row r before any letters.

Center

Ascend and descend

Ascend A..peak, then descend (peak-1)..A with print(chr(code), end="") in both loops.

Mirror

New line

print() ends the row after spaces and both letter loops finish; the outer loop advances r.

Break

Pattern complete

Total letters: 1 + 3 + 5 + ... + (2n-1) = n² — O(n²) time, O(1) extra memory (loop version).

Trace

🔎 Worked Walkthrough — `rows = 5`

Trace each outer-loop value of r and see how leading spaces, peak letter, ascend, and descend produce each centered palindrome row.

`r`	peak	spaces	ascend	descend	full row
0	`A`	4	`A`	(none)	`A`
1	`B`	3	`AB`	`A`	`ABA`
2	`C`	2	`ABC`	`BA`	`ABCBA`
3	`D`	1	`ABCD`	`CBA`	`ABCDCBA`
4	`E`	0	`ABCDE`	`DCBA`	`ABCDEDCBA`

Highlight rows: r = 0 (4 spaces, peak A, A only), r = 2 (2 spaces, peak C, ABCBA), r = 4 (0 spaces, peak E, ABCDEDCBA). Total letters printed: 1 + 3 + 5 + 7 + 9 = 25 = rows² for rows = 5.

Use Cases

Where centered palindrome pyramids show up beyond the homework prompt.

1. After Program 31

Program 31 uses diagonal columns for an X shape. This pattern builds full palindrome strings centered with spaces.

Example: compare diagonal X grid vs centered ABCBA rows side by side.

2. Mirror loop practice

Reinforce the peak - 1 descend start before tackling diamonds and hollow pyramids.

Example: trace row 2 (r=2) on paper: spaces=2, ascend=ABC, descend=BA.

3. Program 18 contrast

Same palindrome rows without centering — see Program 18.

Example: add print(" " * (rows - 1 - r), end="") to Program 18 to get this shape.

4. Full diamond extension

Mirror the pyramid downward to close a full alphabet diamond.

Example: after the top half, loop r from rows-2 down to 0 with the same row logic.

5. Complexity intuition

Sum of odd row lengths makes O(n²) concrete for beginners.

Example: 5 rows → 25 letters printed (1+3+5+7+9).

6. Interview warm-up

Classic nested-loop question that tests mirror logic and centering spaces.

Example: explain why descend starts at peak - 1 without running code.

Pro Tip: say “spaces, then up to peak, then down from peak minus one” before coding — that story prevents duplicated peaks and wrong indentation.

Advantages

Why this pattern earns a spot after the alphabet X pattern from Program 31.

1. Teaches Mirror Loops
Ascend then descend with peak - 1 — a pattern reused in diamonds and hollow shapes.
2. Centered Symmetry
Leading spaces create a visually balanced pyramid — every row aligns under the apex.
3. Two Implementations
Direct print loops for learning; left/right string variant for clearer debugging.
4. O(1) Extra Memory
Streaming output needs no storage beyond loop counters (string variant uses O(r) per row).

Pro Tip: when row 0 prints only A, the descend loop range is empty — that is correct, not a bug.

Usage Tips

Small habits that keep centered palindrome pyramid code clean.

1. Name peak explicitly
Use peak = base + r — keeps ascend and descend loops readable.
2. Wrap int(input()) in try/except
Avoid crashes when the user types letters instead of a number.
3. Clamp rows early
rows = max(1, min(rows, 26)) keeps demos inside A–Z.
4. Print spaces before letters
print(" " * (rows - 1 - r), end="") must run before the ascend loop each row.
5. Dry-run rows = 3
Trace A, ABA, ABCBA with 2, 1, 0 spaces on paper before coding larger demos.

Pro Tip: if the pyramid leans left, check the space count — it should be rows - 1 - r, not r.

Common Pitfalls

Mistakes that commonly break centered alphabet palindrome pyramids.

1. Duplicating peak in descend loop
Starting descend at peak instead of peak - 1 prints ABCCBA — a doubled center letter.
→ Use for code in range(peak - 1, base - 1, -1): so the peak appears only once.
2. Wrong space count
Using r spaces or rows - r misaligns the pyramid — rows lean or over-indent.
→ Use rows - 1 - r leading spaces so row 0 gets the most padding.
3. Hardcoded ASCII 65
Magic numbers like chr(65 + r) work but break readability and lowercase variants.
→ Use base = ord('A') and chr(base + r) instead of raw ASCII values.
4. Blind int(input())
Non-numeric input raises ValueError with bare int(input()).
→ Wrap int(input()) in try/except ValueError and validate range.
5. Forgetting leading spaces
Printing only palindrome letters without spaces produces a left-aligned pyramid like Program 18.
→ Print " " * (rows - 1 - r) before the ascend loop on every row.

Edge Cases

Check these inputs before calling the solution done.

rows = 1

Single letter

Output is just A (with rows - 1 spaces) — descend loop range is empty when peak equals base.

rows = 0

Empty pattern

Treat as invalid; re-prompt instead of silent empty output.

rows = 26

Full alphabet

26 rows with peak Z — bottom row prints ...Z...Z... with no leading spaces.

rows > 26

Past Z

Clamp to 26 or define a wrap/error policy before printing.

Bad input

Non-numeric input

Use try/except ValueError before clamping rows.

Case

Lowercase variant

Same loops work with base = ord('a') and lowercase output.

Drill

🎯 Practice Problems

Try these variations to lock in the pattern.

1. Compare with Program 18

Program 18: left-aligned palindrome (A, ABA, ABCBA)
This pattern: same rows with leading spaces to center
See Program 18

2. Implement string variant

Rewrite Example 1 using left and right strings
Verify identical output for rows=5

3. Compare with Program 31

Program 31: diagonal X with spaced grid
This pattern: full palindrome strings centered
See Program 31

4. Continue to Program 33

Next pattern — widening alphabet triangle
Builds on symmetric shape ideas
See Program 33

Important

Notes

Letter count. Row r prints 2r + 1 letters. Over n rows the total is n².
Descend loop: for code in range(peak - 1, base - 1, -1): — the base - 1 stop is exclusive so A is included.
left + right string variant is equivalent to the direct-print version — use whichever fits your lesson.
Clamp to 26 rows for A–Z demos; compare with Program 18 for the left-aligned version without spaces.

Quick Takeaway: outer loop sets r, print (rows - 1 - r) spaces, ascend A..peak, descend (peak-1)..A, then break the line — that is the whole centered palindrome pyramid.

Analysis

⏱️ Time and Space Complexity

Program	Time	Extra space
Ascend + descend loops (Examples 1–2)	`O(rows²)`	`O(1)`
String variant (Example 3)	`O(rows²)`	`O(r)` for left/right strings per row

Wrap Up

🎉 Conclusion

The centered alphabet palindrome pyramid combines centering spaces with mirror loops — ascend A..peak, descend (peak-1)..A. Master the direct-print version, then try the left/right string variant for clearer debugging.

Practice the three examples above, then continue to Program 33 in the alphabet pattern series.

Print leading spaces, run ascend and descend loops with peak - 1, clamp rows to 26, and compare with Program 18 (left-aligned palindrome pyramid).

View Examples Gallery Continue to Program 33

Pro Tips

💡 Best Practices

✅ Do

Set base = ord('A'), clamp rows to 1–26
Print (rows - 1 - r) leading spaces each row
Ascend range(base, peak + 1), descend range(peak - 1, base - 1, -1)
Use print(chr(code), end="") in letter loops; print() after
Compare output with Program 18 to verify centering
Try the left/right string variant for debugging

❌ Don’t

Start descend at peak — duplicates the center letter
Hardcode ASCII 65 instead of ord('A')
Use wrong space count — pyramid will lean left or right
Skip leading spaces — output matches Program 18, not centered
Call print() inside the letter loops
Let rows exceed 26 without a defined policy

Summary

Key Takeaways

Knowledge Unlocked

Five things to remember about this centered palindrome pyramid

Print the centered pyramid the beginner-friendly way.

Core concepts

▽ 01

Rule

A..peak..A

Definition

Leading spaces

rows - 1 - r

Center

↑A 03

Ascend loop

base..peak

Code

↓A 04

Descend loop

peak-1..base

Code

O 05

Complexity

O(n²) time

Analysis

❓ Frequently Asked Questions

What is a centered alphabet palindrome pyramid?

Each row is a palindrome of letters (A, ABA, ABCBA, ...) padded with leading spaces so the pyramid is centered. Row r prints (rows-1-r) spaces, then A..peak, then (peak-1)..A.

Why start the descend loop at peak - 1?

The ascend loop already prints the peak letter. Starting the mirror at peak-1 avoids duplicating the center character — ABCBA not ABCCBA.

How many leading spaces does row r need?

Print (rows - 1 - r) spaces before the letters. Row 0 gets the most spaces; the bottom row gets zero.

How does this differ from Program 18?

Program 18 prints the same palindrome rows left-aligned with no leading spaces. Program 32 adds (rows-1-r) spaces to center the pyramid.

Why clamp rows to 26?

Each row peak is chr(ord('A') + r). With rows > 26 you would need characters beyond Z unless you define a wrap or error policy.

What is the difference between print with end= and print()?

print(chr(code), end="") keeps each letter on the same row. print() ends the row after spaces, ascend, and descend finish.

What is the time complexity?

O(n²) where n is rows. Row r prints about 2r+1 letters plus spaces; the sum of odd lengths is n².

How should I read the row count safely?

Use a try/except ValueError around int(input()), or check raw.isdigit() before converting, then clamp rows between 1 and 26.

Did you Know? 🔊

Row r prints (rows - 1 - r) leading spaces, then letters from A up to the peak chr(ord('A') + r), then back down to A starting at peak - 1 so the peak is not duplicated.

Continue to Program 33

Next up: the widening alphabet triangle — build on symmetric shape ideas from this tutorial.

Program 33 tutorial →

About the author

Mari Selvan M P 🔗

Developer, cloud engineer, and technical writer

Experience 12 years building web and cloud systems
Focus Full Stack Development, AWS, and Developer Education

I write practical tutorials so students and working developers can learn by doing—from databases and APIs to deployment on AWS.

AWS Certified Developer – Associate (Credly)

12 people found this page helpful

Python Alphabet Pattern 31 — Alphabet X Pattern Python Alphabet Pattern 33 — Widening Alphabet Triangle

Centered Alphabet Palindrome Pyramid (A, ABA, ABCBA, ...) in Python

What You’ll Learn

Palindrome Rule

Leading Spaces

Ascend Loop

Descend Loop

Live Preview

O(n²)

Introduction

Why it matters?

Leading Spaces

Ascend Half

Descend Half

No Peak Duplicate

📝 Problem & Approach

Inputs & Outputs

Minimal workflow

Approach comparison

⚡ Quick Reference

📋 Leading Spaces vs Ascend vs Descend

When This Pattern Shows Up

After Program 31

Mirror loop practice

Centering with spaces

Gateway to Program 33

Not a UI layout tool

🔮 Live Preview

Examples Gallery

📚 Getting Started

Example 1 — Fixed rows = 5

How It Works

📈 Practical Variant

Example 2 — User Input Version

How It Works

⚡ String Join Variant

Example 3 — Left/Right String Variant

How It Works

🧠 How the Algorithm Prints Rows

Set up bounds

Print leading spaces

Ascend and descend

New line

Pattern complete

🔎 Worked Walkthrough — rows = 5

Use Cases

1. After Program 31

2. Mirror loop practice

3. Program 18 contrast

4. Full diamond extension

5. Complexity intuition

6. Interview warm-up

Advantages

1. Teaches Mirror Loops

2. Centered Symmetry

3. Two Implementations

4. O(1) Extra Memory

Usage Tips

1. Name peak explicitly

2. Wrap int(input()) in try/except

3. Clamp rows early

4. Print spaces before letters

5. Dry-run rows = 3

Common Pitfalls

1. Duplicating peak in descend loop

2. Wrong space count

3. Hardcoded ASCII 65

4. Blind int(input())

5. Forgetting leading spaces

Edge Cases

Single letter

Empty pattern

Full alphabet

Past Z

Non-numeric input

Lowercase variant

🎯 Practice Problems

1. Compare with Program 18

2. Implement string variant

3. Compare with Program 31

4. Continue to Program 33

Example 1 — Fixed `rows = 5`

🔎 Worked Walkthrough — `rows = 5`

2. Wrap `int(input())` in try/except