Shape Rule
Fixed top, shifting stop
Row 0 prints EDCBA, row 1 prints DCBA, row 2 prints CBA, down to a single A on the last row.

The reverse alphabet pattern prints descending letters on each row, from a fixed top letter down to a row-specific stop. This tutorial covers the shape rule, fixed top formula, reverse range step, a live preview, algorithm steps, worked JavaScript examples, edge cases, and complexity.
Fixed top, shifting stop
Row 0 prints EDCBA, row 1 prints DCBA, row 2 prints CBA, down to a single A on the last row.
Row index
for (let i = 0; i < rows; i++) picks the stop letter for each row — A on row 0, B on row 1, up to the top letter on the last row.
top down to stop
for (let code = top; code >= stop; code--) appends descending letters from the fixed top down to the row stop.
Same line / next line
Letters use line += String.fromCharCode(code); end each row with console.log(line).
1–26 rows
Pick a row count and draw the fixed-top reverse alphabet pattern instantly in the browser.
Complexity
Total letters = n(n+1)/2; extra memory stays O(1).
A reverse alphabet pattern (EDCBA to E) prints descending letters on each row — every row starts at the same top letter while the stop moves up each line. With five rows the console shows EDCBA, EDCB, EDC, ED, E — the fixed-top mirror of Program 7’s shrinking-start shape.
in JavaScript you solve it with two nested for loops: compute top = "A".charCodeAt(0) + rows - 1, set stop = "A".charCodeAt(0) + i per row, print letters with for (let code = top; code >= stop; code--), then call console.log(line) for the next line.
It teaches per-row descending bounds with a fixed start at the top letter — the natural follow-up after Program 7. Once stop = base + i and for (let code = top; code >= stop; code--) click, slice shortcuts and Program 9 follow naturally.
top = "A".charCodeAt(0) + rows - 1 — for five rows, every row starts at E.
Row i stops at String.fromCharCode(base + i) — A, then B, then C, up to the top letter on the last row.
for (let code = top; code >= stop; code--) counts down; line += String.fromCharCode(code) then console.log(line).
Program 7 shrinks EDCBA, DCBA, CBA; this pattern keeps E on the left and shifts the stop — compare both side by side.
In short: for each row i from 0 to rows - 1, set stop = "A".charCodeAt(0) + i, print letters from fixed top down to stop with for (let code = top; code >= stop; code--) and line += String.fromCharCode(code), then call console.log(line).
Given a positive integer rows, print a left-aligned reverse alphabet pattern: each row prints descending letters from a fixed top letter down to a row-specific stop (EDCBA when rows = 5).
# First 5 rows (conceptual shape)
# EDCBA
# EDCB
# EDC
# ED
# E | Item | Type | Description |
|---|---|---|
rows | int | Number of pattern lines to print (typically ≥ 1). |
top | int (code) | Fixed start letter on every row: "A".charCodeAt(0) + rows - 1. |
| Printed output | text | Left-aligned rows; row i logs from fixed top down to String.fromCharCode(base + i). |
top = "A".charCodeAt(0) + rows - 1
for i from 0 to rows - 1:
stop = base + i
for code from top down to stop (code--):
append letter to line
log line | Approach | Idea | Best for |
|---|---|---|
| Nested reverse loops | Fixed top + shifting stop | Learning and interviews |
| Fixed top formula | top = "A".charCodeAt(0) + rows - 1 | This pattern — shared first letter every row |
letters.slice(i, rows).split("").reverse().join("") | Slice from row index to top, then reverse | Shorter production-style demos |
| Goal | Pattern |
|---|---|
| Fixed top letter | top = "A".charCodeAt(0) + rows - 1 |
| Walk each row | for (let i = 0; i < rows; i++) |
| Row stop letter | stop = base + i |
| Print top down to stop | for (let code = top; code >= stop; code--): line += String.fromCharCode(code) |
| End the row | console.log(line) |
| One-line row shortcut | console.log(letters.slice(i, rows).split("").reverse().join("")) |
| Shifting stop variant | See Program 7 — rows end at A |
Same EDCBA-to-E shape — two ways to think about descending row bounds.
for (let code = top; code >= stop; code--)Classic charCode loop — teaches fixed top, shifting stop, and code--
letters.slice(i, rows).split("").reverse().join("")Prefix slice then reverse — compact one-liner per row
loops firstMaster nested reverse loops before the string shortcut
Reach for this pattern when teaching descending letter bounds with a fixed top letter — the natural follow-up after Program 7’s shrinking-start shape.
Natural follow-up after Program 6 — same row count, every row starts at the top letter while the stop shifts up.
Practice for (let code = top; code >= stop; code--) with an immediate visual check.
Combine loops with prompt() for a flexible row count.
Leads to reverse patterns, pyramids, and hollow shapes in the series.
This is a console teaching pattern — not how you build modern app screens.
Key benefit: one small program that locks in a fixed top letter, a rising floor, reverse range step, output sequencing, and O(n²) thinking — the fixed-start step after Program 7.
Choose a row count between 1 and 26 and draw the fixed-top reverse alphabet pattern in the browser.
Three complete JavaScript programs — fixed row count, prompt input, and a letters.slice(i, rows) reverse shortcut. Click View Output to reveal sample console results, or Try it Yourself to run in the browser editor.
Print five rows with classic nested reverse loops — fixed top, shifting stop.
rows = 5Hard-coded height — ideal for first demos and screenshots.
const rows = 5;
const base = "A".charCodeAt(0);
const top = base + rows - 1; // 'E' when rows = 5
for (let i = 0; i < rows; i++) {
const stop = base + i;
let line = "";
for (let code = top; code >= stop; code--) {
line += String.fromCharCode(code);
}
console.log(line);
} When i = 0, stop is A and the inner loop prints EDCBA. When i = 2, stop is C and the row is EDC. When i = 4, stop is E, so the last row is a single E. console.log(line) after the inner loop starts the next row.
Let the user choose the height at runtime.
Read the row count with prompt() and convert with parseInt() (validate with Number.isFinite in real apps).
const rowsInput = prompt("Enter the number of rows (max 26):");
let rows = parseInt(rowsInput, 10);
rows = Math.max(1, Math.min(rows, 26));
const base = "A".charCodeAt(0);
const top = base + rows - 1;
for (let i = 0; i < rows; i++) {
const stop = base + i;
let line = "";
for (let code = top; code >= stop; code--) {
line += String.fromCharCode(code);
}
console.log(line);
} Same charCodeAt/fromCharCode core as Example 1; only the source of rows changes. The clamp keeps letter codes within A–Z. Non-numeric input returns NaN with bare parseInt(prompt()) — validate with Number.isFinite for safer labs.
Same shape without an explicit inner letter loop.
letters.slice(i, rows) reversedSlice from row index i to the top letter, then reverse for each row.
const rows = 5;
const clampedRows = Math.max(1, Math.min(rows, 26));
const letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
for (let i = 0; i < clampedRows; i++) {
console.log(letters.slice(i, clampedRows).split("").reverse().join(""));
} letters.slice(i, rows) returns letters from index i up to index rows. With rows = 5, row 0 is letters.slice(0, 5).split("").reverse().join("") = EDCBA, row 2 is letters.slice(2, 5).split("").reverse().join("") = EDC, and so on. Keep the two-loop version for exams that ask you to show reverse bounds and code--.
Use prompt() when reading input. Set rows (fixed or from user), clamp to 1–26, and compute top = "A".charCodeAt(0) + rows - 1.
for (let i = 0; i < rows; i++) selects the stop letter for the current line — A on row 0, B on row 1, up to the top letter on the last row.
stop = base + i then for (let code = top; code >= stop; code--) appends each letter with line += String.fromCharCode(code).
console.log(line) ends the row so the next outer iteration starts fresh.
Total letters: n+(n-1)+…+1 = n(n+1)/2 — O(n²) time, O(1) extra memory.
rows = 5Trace each outer-loop value i (0-based) and see what the inner loop prints from fixed top down to row stop.
Outer i | top | stop | Inner loop | Printed row | Letters this row |
|---|---|---|---|---|---|
0 | E | A | for (code = 69; code >= 65; code--) | EDCBA | 5 |
1 | E | B | for (code = 69; code >= 66; code--) | EDCB | 4 |
2 | E | C | for (code = 69; code >= 67; code--) | EDC | 3 |
3 | E | D | for (code = 69; code >= 68; code--) | ED | 2 |
4 | E | E | for (code = 69; code >= 69; code--) | E | 1 |
Total letter prints: 5 + 4 + 3 + 2 + 1 = 15 = 5×6/2. Same triangular total as Programs 1, 4, 5, and 7 — only the letter bounds per row differ.
Where this fixed-top reverse descending letter pattern (and its shifting stop) shows up beyond the homework prompt.
Clearest visual proof that for (let code = top; code >= stop; code--) counts down from a fixed top letter while stop moves forward each row.
Example: compare side-by-side with Program 7.
Natural step after Program 7 before Program 9’s repeating-letter variant.
Example: Program 9 prints A, BB, CCC, and so on.
Practice reverse character loops and line += String.fromCharCode(code)/console.log(line) with a shape that differs visibly from Program 6 and 7.
Example: compare Program 6 ascending vs Program 7 shrinking-start vs this fixed-top shape.
Swap to lowercase or digits once the letter loop works.
Example: print lowercase a..z once uppercase clicks.
Triangular totals make O(n²) concrete for beginners.
Example: count printed letters for n = 10 → 55.
Pair the pattern with Number.isFinite validation and positive-row checks.
Example: reject rows <= 0 and re-prompt.
Pro Tip: when an interviewer asks for descending letters per row, explain that stop = base + i and the inner loop uses step -1 down to A.
Why this reverse descending pattern earns a spot after Program 7 in beginner JavaScript courses.
Side-by-side with Program 7 makes fixed top vs shrinking start obvious.
Only loops and console output — no arrays or math libraries.
One formula change flips between Program 7’s shrinking start and this shifting stop shape.
Streaming output needs no storage beyond loop counters.
Pro Tip: master Program 7 first, then this page — the row count is the same; only whether the start or stop moves changes the shape.
Small habits that keep reverse alphabet-pattern code clean.
Set top = "A".charCodeAt(0) + rows - 1 before the outer loop — don’t recalculate every row. Set stop = base + i inside the outer loop.
Avoid crashes when the user types letters instead of a number.
Only call console.log(line) after the inner loop finishes the row.
for (let code = top; code >= stop; code--) needs step -1 and stop stop - 1 so the row stop letter is included.
Trace rows = 3 on paper — expect CBA, CB, C — before coding larger demos.
Pro Tip: if rows print in ascending order, you almost certainly forgot step -1 in the inner range.
Mistakes that commonly break fixed-top reverse alphabet patterns.
Counting up with code++ logs ascending letters — the pattern needs descending order from fixed top.
→ Use for (let code = top; code >= stop; code--).
Using code > stop skips the row stop letter — the last character on each row is missing.
→ Use code >= stop so the stop letter is included.
Omitting console.log(line) after the inner loop glues every letter onto one endless line.
→ Always end the row after the inner loop.
Non-numeric input raises ValueError with bare parseInt(prompt()).
→ Wrap in Number.isFinite validation and validate range.
Program 7 shrinks the start each row but ends at A (EDCBA, DCBA). Program 6 prints ascending rows ending at a fixed top letter — not the same as EDCBA-to-E.
→ This pattern: fixed top, stop = base + i, for (let code = top; code >= stop; code--), every row starts at the top letter.
Check these inputs before calling the solution done.
Output is just the top letter — stop equals top and the inner loop prints one letter.
Outer loop never runs — print nothing or show a message.
rows < 0Treat as invalid; re-prompt instead of silent empty output.
Output grows as n²/2 characters — fine for labs, noisy for huge n.
parseInt(prompt()) raises ValueError — validate first.
On the last row, stop == top — inner loop prints one letter only.
Try these variations to lock in the fixed-top reverse pattern.
rowsString.fromCharCode(code) with digit logicNumber.isFinite validation until rows >= 1top = "A".charCodeAt(0) + rows - 1 is computed once — for five rows every row starts at E.for (let code = top; code >= stop; code--) needs step -1 and stop stop - 1 so the row stop letter is included.rows > 0 for interactive programs; rows = 1 should print a single top letter.Quick Takeaway: compute fixed top, shift stop each row, print with for (let code = top; code >= stop; code--), then break the line.
| Program | Time | Extra space |
|---|---|---|
| Nested loops (Examples 1–2) | O(rows²) | O(1) |
letters.slice(i, rows).split("").reverse().join("") (Example 3) | O(rows²) | O(rows) per row string (temporary) |
The reverse alphabet pattern (EDCBA to E) is a compact bounds exercise with lasting payoff: fixed top, fixed top, per-row shifting stop, reverse range, and O(n²) intuition. Master the classic two-loop version, then optionally shorten rows with letters.slice(i, rows).split("").reverse().join("").
Practice the three examples above, then continue to Program 9 for the repeating-letter variant in the series.
Every row starts at the top letter — use for (let code = top; code >= stop; code--), build with line += String.fromCharCode(code), log with console.log(line), and validate row counts when reading from prompt().
top = "A".charCodeAt(0) + rows - 1 once before the outer loopstop = base + i inside for (let i = 0; i < rows; i++)for (let code = top; code >= stop; code--) and line += String.fromCharCode(code)rows ≥ 1 for interactive programsparseInt(prompt()) in Number.isFinite validation-1 on the inner rangerows = 1 edge casePrint EDCBA-to-E the beginner-friendly way.
Fixed top, shifting stop each row
Definitiontop = base + rows - 1
Codestop = base + i
Codefor (let code = top; code >= stop; code--)
for (let code = top; code >= stop; code--)
I/OO(n²) time
AnalysisEach row starts at a fixed top letter and logs descending to a row-specific stop: top = "A".charCodeAt(0) + rows - 1, row i uses stop = "A".charCodeAt(0) + i and for (let code = top; code >= stop; code--). Compare Program 7 (every row ends at A) and Program 6 (ascending rows ending at fixed top letter).
Alphabet pattern A, BB, CCC, ... — the next alphabet pattern in the series.
12 people found this page helpful