A reverse centered alphabet pyramid prints Program 28’s layered rows down to the A-center line, then mirrors them back up to the top letter — without printing the center twice.
Remember
Rule: printRow(i) = left k..0 + right 1..k with (j > i ? j : i)
Phase 1: i = k..0 Phase 2: i = 1..k
E E E E E E E E E
E D D D D D D D E
E D C C C C C D E
E D C B B B C D E
E D C B A B C D E ← center once
E D C B B B C D E
E D C C C C C D E
E D D D D D D D E
E E E E E E E E E ← top = 'E' (9×9)
Program 28 is exactly the upper half. The lower phase starts at i = 1 (B) so the A-center row is not duplicated.
Approach
How to Solve It
Two ways to emit the same diamond — duplicate the row body in both phases, or factor helpers.
Method
Idea
Best for
Two phases inline
Upper k..0, lower 1..k, same row body
Learning, interviews, exams
cell + printRow
One place owns the floor rule and both halves
Cleaner demos once the rule clicks
Pseudocode
Pseudocode
k = top - 'A'
define printRow(i):
for j from k down to 0: append (j > i ? alpha[j] : alpha[i])
for j from 1 to k: append (j > i ? alpha[j] : alpha[i])
print newline
for i from k down to 0: printRow(i) // upper
for i from 1 to k: printRow(i) // lower
Append cells without a newline, then end the row once.
Try it
Live Preview
Change the top letter and the reverse-centered diamond updates instantly — rows = width = 2k + 1.
One letter from A to F. Tap a chip or type a letter — the preview redraws as you go.
Live resultTop E · 9 rows · width 9
E E E E E E E E E
E D D D D D D D E
E D C C C C C D E
E D C B B B C D E
E D C B A B C D E
E D C B B B C D E
E D C C C C C D E
E D D D D D D D E
E E E E E E E E E
Trace
Worked Walkthrough — Top = E (k = 4)
Trace each floor and the resulting 9-letter line across both phases.
Phase
i
Floor
Printed row
Upper
4
E
E E E E E E E E E
Upper
3
D
E D D D D D D D E
Upper
2
C
E D C C C C C D E
Upper
1
B
E D C B B B C D E
Upper
0
A
E D C B A B C D E
Lower
1
B
E D C B B B C D E
Lower
2
C
E D C C C C C D E
Lower
3
D
E D D D D D D D E
Lower
4
E
E E E E E E E E E
Width is always 2×4 + 1 = 9. Total rows are 2×5 − 1 = 9. The A-center row appears only once (upper phase).
Code
JavaScript Programs
Three complete programs: fixed A–E, top-letter prompt, and a helper-function rewrite. Use View Output for sample results, or Try It Yourself to edit and run in the playground.
Example 1 — Fixed A–E
Same row logic as Program 28, printed in two phases to complete the reverse centered pyramid.
JavaScript
const k = 4; // index for 'E'
const alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
// Upper half (E down to A)
for (let i = k; i >= 0; i--) {
let line = "";
for (let j = k; j >= 0; j--) {
line += (j > i ? alpha[j] : alpha[i]) + " ";
}
for (let j = 1; j <= k; j++) {
line += (j > i ? alpha[j] : alpha[i]) + " ";
}
console.log(line.trimEnd());
}
// Lower half (B up to E) — skip repeating the A row
for (let i = 1; i <= k; i++) {
let line = "";
for (let j = k; j >= 0; j--) {
line += (j > i ? alpha[j] : alpha[i]) + " ";
}
for (let j = 1; j <= k; j++) {
line += (j > i ? alpha[j] : alpha[i]) + " ";
}
console.log(line.trimEnd());
}
E E E E E E E E E
E D D D D D D D E
E D C C C C C D E
E D C B B B C D E
E D C B A B C D E
E D C B B B C D E
E D C C C C C D E
E D D D D D D D E
E E E E E E E E E
How It Works
1. Fix the top index.k = 4 means the highest letter is E.
2. Upper phase. Floor i runs from k down to 0 — same as Program 28 through the A-center row.
3. Lower phase. Floor i runs from 1 to k so the center line is not printed twice.
4. Same row body. Both phases use left k..0 and right 1..k with j > i ? alpha[j] : alpha[i].
Example 2 — Top Letter Input
Works for A..top with the same two-phase pyramid. Prefer validating a single A–Z character.
JavaScript
const raw = (prompt("Enter top letter (like E):") || "").trim().toUpperCase();
const alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
if (!/^[A-Z]$/.test(raw)) {
console.log("Please enter a single letter A-Z.");
} else {
const k = raw.charCodeAt(0) - 65;
for (let i = k; i >= 0; i--) {
let line = "";
for (let j = k; j >= 0; j--) {
line += (j > i ? alpha[j] : alpha[i]) + " ";
}
for (let j = 1; j <= k; j++) {
line += (j > i ? alpha[j] : alpha[i]) + " ";
}
console.log(line.trimEnd());
}
for (let i = 1; i <= k; i++) {
let line = "";
for (let j = k; j >= 0; j--) {
line += (j > i ? alpha[j] : alpha[i]) + " ";
}
for (let j = 1; j <= k; j++) {
line += (j > i ? alpha[j] : alpha[i]) + " ";
}
console.log(line.trimEnd());
}
}
E E E E E E E E E
E D D D D D D D E
E D C C C C C D E
E D C B B B C D E
E D C B A B C D E
E D C B B B C D E
E D C C C C C D E
E D D D D D D D E
E E E E E E E E E
How It Works
1. cell owns the rule.j > i lives in one place.
2. printRow owns both halves. Left k..0 and right 1..k, then console.log.
3. Thin phases. The two outer loops only decide which floors to visit.
Edge Cases & Pitfalls
Check these before calling the solution done.
i = 0
Duplicate center row
If the lower phase starts at 0, the A-center line prints twice. Keep for (i = 1; i <= k; i++).
Right j = 0
Duplicate center A in a row
The right half of each row must start at 1, same as Program 28.
log inside
Column of letters
If console.log is inside either half-loop, each cell lands on its own line. Append with +=; log only after both halves.
top = A
Single A
When k = 0, upper prints A and lower never runs. A good sanity check.
Upper only
Program 28 by mistake
Forgetting the lower phase leaves the open square. Add for (i = 1; i <= k; i++) with the same row printer.
Bad input
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
Two phases inline (Examples 1–2)
O(n²)
O(n) for the current row string
Helper functions (Example 3)
O(n²)
O(n) for the current row string
For n = k + 1 letters, there are 2n - 1 rows of width 2n - 1 — still quadratic in n. Roughly twice Program 28’s cell count, minus one shared center row.
Remember
Key Takeaways
Rule: same printRow as Program 28 — upper k..0, lower 1..k.
No double center: lower phase starts at B (i = 1).
Break the row: call console.log only after both half-loops.
Complexity:O(n²) time; O(n) space for the current row string.
One line: print Program 28’s rows from k down to 0, then again from 1 up to k.
Frequently Asked Questions
The first loop decreases i from E down to A, printing each layered row toward the center. The second increases i from B back to E with the same row rule so the pyramid widens again without repeating the A-centered row.
Because the A-centered row already appears in the upper half. Starting from B prevents duplicating the center line.
If n is the number of letters from A to the top letter, total rows are 2n−1 (9 rows for A..E).
It prints the border letter when the column index j is above the current row floor i; otherwise it prints the floor letter. The same rule applies on both left and right halves of every row.
The left scan goes E down to A; the right scan goes B up to E so the middle A appears once and the row mirrors.
line += builds each letter and its trailing space on the same row. console.log inside either half-loop would log one cell per line. Log once after both halves finish.
O(n²) because there are O(n) rows and each row prints O(n) cells.
Program 28 is exactly the upper half of this pyramid. Program 29 reuses that row logic, then mirrors upward from B to E for the closed diamond.
🤔
Did you know?
Reuse Program 28’s row logic twice: first with i from E down to A, then with i from B up to E so the center row is not duplicated. Each row stays full width (2n-1 cells); total rows are also 2n-1 for n letters.
