A symmetric alphabet pyramid prints centered palindromic rows: each line climbs from A to a peak letter, then mirrors back down to A without repeating the peak.
Remember
Rule: spaces + A..i + (i−1)..A
A
ABA
ABCBA
ABCDCBA
ABCDEDCBA ← top = 'E'
Three stages per row: leading spaces for centering, ascending A..i, then descending (i − 1)..A. Compare with Program 24 (similar palindromes) and Program 31 (hollow V).
Approach
How to Solve It
Two ways to emit the same pyramid — a classic bridge variable (--n), or an explicit descending loop.
Method
Idea
Best for
Bridge variable
After A..i, set n = k - 1 and append alpha[--n]
Matching classic textbook / exam style
Explicit mirror
Loop p from i - 1 down to 0
Clearer demos once the skip-center rule clicks
Pseudocode
Pseudocode
end = top - 'A'
for i from 0 to end:
line = ""
append (end - i) spaces
for k from 0 to i: append alpha[k] // A..i
for p from i-1 to 0: append alpha[p] // (i-1)..A
print line
Cheat sheet
Goal
Pattern
Top index
const end = top.charCodeAt(0) - 65; (4 for E)
Rows
for (let i = 0; i <= end; i++)
Leading spaces
for (let j = end; j > i; j--) line += " ";
Ascending half
for (let k = 0; k <= i; k++) line += alpha[k];
Bridge mirror
let n = k - 1; for (m = 0; m < i; m++) line += alpha[--n];
Explicit mirror
for (let p = i - 1; p >= 0; p--) line += alpha[p];
Letters on row i
2i + 1 (peak printed once)
Printing Letters vs Starting a New Line
API
Effect
Use for
line += ch
Stays on the same row
Each space and letter
console.log(line)
Ends the current row
After spaces + ascending + mirror finish a row
Append cells without a newline, then end the row once.
Try it
Live Preview
Change the top letter and the centered palindrome pyramid updates instantly — row i has 2i + 1 letters.
One letter from A to F. Tap a chip or type a letter — use a monospace view for centering.
Live resultTop E · 5 rows · base 9 letters
A
ABA
ABCBA
ABCDCBA
ABCDEDCBA
Trace
Worked Walkthrough — Top = E (end = 4)
Trace padding, ascending half, and mirrored descending half for each row.
i
Spaces
Ascending
Mirror
Printed row
0
4
A
(none)
A
1
3
AB
A
ABA
2
2
ABC
BA
ABCBA
3
1
ABCD
CBA
ABCDCBA
4
0
ABCDE
DCBA
ABCDEDCBA
After ascending, k = i + 1, so n = k - 1 = i. The first --n lands on i - 1.
Code
JavaScript Programs
Three complete programs: fixed A–E with a bridge variable, top-letter prompt, and an explicit mirror loop. Use View Output for sample results, or Try It Yourself to edit and run in the playground.
Example 1 — Fixed A–E
Matches the reference logic using a bridge variable n = k - 1 to append the descending half.
JavaScript
const alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
for (let i = 0; i <= 4; i++) {
let line = "";
for (let j = 4; j > i; j--) {
line += " ";
}
let k;
for (k = 0; k <= i; k++) {
line += alpha[k];
}
let n = k - 1;
for (let m = 0; m < i; m++) {
line += alpha[--n];
}
console.log(line);
}
1. Pad for centering. Spaces run from 4 down while j > i.
2. Ascend to the peak. Append alpha[0..i] — when i = 2, that is ABC.
3. Bridge past the peak. After the ascending loop, k = i + 1, so n = k - 1 = i.
4. Mirror without a double center. Each --n appends the previous letter — for i = 2, that yields BA and the full row ABCBA.
Example 2 — Top Letter Input
The loops adapt to the new size automatically. Validate a single A–Z character from prompt.
JavaScript
const raw = (prompt("Enter top letter (like E):") || "").trim().toUpperCase();
const alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
if (!/^[A-Z]$/.test(raw)) {
console.log("Enter one letter from A to Z.");
} else {
const end = raw.charCodeAt(0) - 65;
for (let i = 0; i <= end; i++) {
let line = "";
for (let j = end; j > i; j--) {
line += " ";
}
let k;
for (k = 0; k <= i; k++) {
line += alpha[k];
}
let n = k - 1;
for (let m = 0; m < i; m++) {
line += alpha[--n];
}
console.log(line);
}
}
1. Scale with end.end = topCode − 65 drives padding, ascending, and mirror loops together.
2. Same core. For top = C you get three centered rows ending at ABCBA.
3. Safer input tip. Trim, uppercase, and require /^[A-Z]$/ — reject empty or multi-character prompts.
Example 3 — Explicit Mirror Loop
Often easier to read: after appending A..i, loop p from i - 1 down to 0.
JavaScript
const end = 4;
const alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
for (let i = 0; i <= end; i++) {
let line = "";
for (let j = end; j > i; j--) {
line += " ";
}
for (let k = 0; k <= i; k++) {
line += alpha[k];
}
for (let p = i - 1; p >= 0; p--) {
line += alpha[p];
}
console.log(line);
}
1. Same three stages. Spaces, then ascending, then mirror — only the mirror syntax changes.
2. Peak stays unique.p starts at i - 1, so the center letter is never printed twice.
3. Same output. Matches the bridge-variable version exactly.
Edge Cases & Pitfalls
Check these before calling the solution done.
Mirror from i
Double center letter
If the descending loop starts at i instead of i - 1, you get ABCCBA. Skip the peak.
Spaces off
Left-aligned pyramid
Keep for (j = end; j > i; j--). Starting at end - 1 or using >= shifts the centering.
log inside
Column of characters
If console.log is inside any of the three loops, each character lands on its own line. Append with += until the row is done.
top = A
Single A
When end = 0, you print one row: A (no spaces, no mirror). A good sanity check.
Wrong n
Bridge off by one
After ascending, k is already i + 1. Use n = k - 1, then --n — not n = k.
Bad prompt
Validate one letter
Trim, uppercase, and require length 1 in A–Z — reject empty or multi-character prompts.
Analysis
Time and Space Complexity
Program
Time
Extra space
Bridge variable (Examples 1–2)
O(n²)
O(n) for the current line string
Explicit mirror (Example 3)
O(n²)
O(n) for the current line string
For n = end + 1 rows, each row prints O(n) spaces and letters — quadratic in n.
Remember
Key Takeaways
Rule: spaces + A..i + (i − 1)..A.
Skip the peak once: mirror starts at i - 1 (or --n after n = k - 1).
Break the row: call console.log(line) only after all three stages.
Complexity:O(n²) time from padding and letters per row.
One line: pad, append A up to the peak, then mirror back to A without reprinting the peak.
Frequently Asked Questions
It appends A..i ascending, then appends (i-1)..A descending. This mirrors the left half without repeating the center letter.
After the ascending loop, k is one past the peak letter. Setting n = k-1 makes n equal the peak, and then --n starts the descending half from the previous letter.
The padding shifts each row to the right so the pyramid is centered under the widest row.
O(n²) for n rows because each row prints O(n) spaces and letters.
After printing A..i, the mirror part starts from i-1 down to A. That avoids duplicating the peak letter.
Trim and uppercase the prompt result, require a single A–Z character, and reject empty or multi-character input.
Ascending prints i+1 letters and descending prints i letters, so the row has 2i+1 letters before counting spaces.
Program 18 is another palindromic alphabet pyramid approach. This page follows the classic bridge-variable style with n = k-1 and --n.
🤔
Did you know?
Each row has three stages: leading spaces for centering, then letters A..i ascending, then letters (i-1)..A descending. The reference keeps a bridge variable n = k - 1 after the ascending loop and appends alpha[--n] to avoid duplicating the center letter.
