Reverse Alphabet Pattern in JavaScript

Beginner
⏱️ 8 min read
📚 Updated: Aug 2026
🎯 3 Code Examples
🚀 Live Preview
Nested Loops

What You’ll Learn

The reverse alphabet pattern prints descending letters on each row, from a row-specific start letter down to A. This tutorial covers the shape rule, fixed top formula, reverse range step, a live preview, algorithm steps, worked JavaScript examples, edge cases, and complexity.

Shape Rule

Descending to A

Row 0 prints EDCBA, row 1 prints DCBA, row 2 prints CBA, down to a single A on the last row.

Outer Loop

Row index

for (let i = 0; i < rows; i++) picks the starting letter for each row — E on row 0, D on row 1, and so on.

Inner Loop

start down to A

for (let code = start; code >= base; code--): prints descending letters from the row start down to A.

line vs console.log

Same line / next line

Letters use line += String.fromCharCode(code); end each row with console.log(line).

Live Preview

1–26 rows

Pick a row count and draw the reverse descending alphabet pattern instantly in the browser.

O(n²)

Complexity

Total letters = n(n+1)/2; extra memory stays O(1).

Introduction

A reverse alphabet pattern (EDCBA to A) prints descending letters on each row — the row start moves down while every row ends at A. With five rows the console shows EDCBA, DCBA, CBA, BA, A — the mirror of Program 6’s ascending row shape.

In JavaScript you solve it with two nested for loops: compute top = "A".charCodeAt(0) + rows - 1, set start = top - i per row, append letters with for (let code = start; code >= base; code--), then call console.log(line) for the next line.

Why it matters?

It teaches per-row descending bounds with a fixed floor at A — the reverse-letter companion to Program 6. Once top = base + rows - 1 and code-- loops click, slice shortcuts and Program 8 follow naturally.

Key Highlights

Fixed Top Letter

top = "A".charCodeAt(0) + rows - 1 — for five rows, the first row starts at E.

Shrinking Start

Row i starts at String.fromCharCode(top - i) — E, then D, then C, and so on.

Reverse range

for (let code = start; code >= base; code--) counts down; line += String.fromCharCode(code) then console.log(line).

Program 4 Contrast

Program 4 grows A, BA, CBA; this pattern shrinks EDCBA, DCBA, CBA — compare both side by side.

In short: for each row i from 0 to rows - 1, append letters from start = top - i down to A with for (let code = start; code >= base; code--) and line += String.fromCharCode(code), then call console.log(line).

📝 Problem & Approach

Given a positive integer rows, print a left-aligned reverse alphabet pattern: each row prints descending letters from a row-specific start down to A (EDCBA when rows = 5).

JavaScript
# First 5 rows (conceptual shape)
# EDCBA
# DCBA
# CBA
# BA
# A

Inputs & Outputs

ItemTypeDescription
rowsintNumber of pattern lines to print (typically ≥ 1).
topint (code)First row start letter: "A".charCodeAt(0) + rows - 1.
Printed outputtextLeft-aligned rows; row i prints from String.fromCharCode(top - i) down to A.

Minimal workflow

Pseudocode
top = "A".charCodeAt(0) + rows - 1
for i from 0 to rows - 1:
    start = top - i
    for code from start down to A (code--):
        append letter to line
    log line

Approach comparison

ApproachIdeaBest for
Nested reverse loopsShrinking start + fixed floor ALearning and interviews
Fixed top formulatop = "A".charCodeAt(0) + rows - 1This pattern — shared first-row start
letters.slice(0, rows - i).split("").reverse().join("")Slice prefix then reverseShorter production-style demos

⚡ Quick Reference

GoalPattern
Fixed top lettertop = "A".charCodeAt(0) + rows - 1
Walk each rowfor (let i = 0; i < rows; i++)
Row start letterstart = top - i
Print start down to Afor (let code = start; code >= base; code--): line += String.fromCharCode(code)
End the rowconsole.log(line)
One-line row shortcutconsole.log(letters.slice(0, rows - i).split("").reverse().join(""))
Ascending prefix variantSee Program 4 — rows grow A, BA, CBA

📋 Nested reverse loop vs slice reverse

Same EDCBA-to-A shape — two ways to think about descending row bounds.

Nested reverse
for (let code = start; code >= base; code--)

Classic charCode loop — teaches descending bounds and code--

Slice reverse
letters.slice(0, rows - i).split("").reverse().join("")

Prefix slice then reverse — compact one-liner per row

Learning tip
loops first

Master nested reverse loops before the string shortcut

Context

When This Pattern Shows Up

Reach for this pattern when teaching descending letter bounds with a fixed floor at A — the reverse-letter companion to Program 6’s ascending shape.

  1. Reverse range practice

    Natural follow-up after Program 6 — same row count, letters count down to A each row.

  2. Nested-loop warm-up

    Practice for (let code = start; code >= base; code--) with an immediate visual check.

  3. prompt() input practice

    Combine loops with prompt() for a flexible row count.

  4. Gateway to variants

    Leads to reverse patterns, pyramids, and hollow shapes in the series.

  5. Not a UI layout tool

    This is a console teaching pattern — not how you build modern app screens.

Key benefit: one small program that locks in descending bounds, shrinking starts, reverse range step, output sequencing, and O(n²) thinking — the reverse-letter step after Program 6.

🔮 Live Preview

Choose a row count between 1 and 26 and draw the reverse descending alphabet pattern in the browser.

Try 5, 7, or 10. Cap is 26 letters (A–Z).

Live result
Press "Draw pattern".

Examples Gallery

Three complete JavaScript programs — fixed row count, prompt input, and a letters.slice(0, rows - i) reverse shortcut. Click View Output to reveal sample console results, or Try it Yourself to run in the browser editor.

📚 Getting Started

Print five rows with classic nested reverse loops — shrinking start, fixed floor A.

Example 1 — Fixed rows = 5

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

JavaScript
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 start = top - i;
  let line = "";
  for (let code = start; code >= base; code--) {
    line += String.fromCharCode(code);
  }
  console.log(line);
}
Try it Yourself

How It Works

When i = 0, start is E and the inner loop prints EDCBA. When i = 2, start is C and the row is CBA. When i = 4, start is A, so the last row is a single A. console.log(line) after the inner loop starts the next row.

📈 Practical Variant

Let the user choose the height at runtime.

Example 2 — User Input Version

Read the row count with prompt() and convert with parseInt() (validate with Number.isFinite in real apps).

JavaScript
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 start = top - i;
  let line = "";
  for (let code = start; code >= base; code--) {
    line += String.fromCharCode(code);
  }
  console.log(line);
}
Try it Yourself

How It Works

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.

⚡ Shortcut Style

Same shape without an explicit inner letter loop.

Example 3 — letters.slice(0, rows - i) reversed

Slice the first rows - i letters from A–Z, then reverse for each row.

JavaScript
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(0, clampedRows - i).split("").reverse().join(""));
}
Try it Yourself

How It Works

letters.slice(0, rows - i) returns the first rows - i letters in ascending order. With rows = 5, row 0 is letters.slice(0, 5).split("").reverse().join("") = EDCBA, row 2 is letters.slice(0, 3).split("").reverse().join("") = CBA, and so on. Keep the two-loop version for exams that ask you to show reverse bounds and code--.

🧠 How the Algorithm Prints Rows

1

Set up

Use prompt() when reading input. Set rows (fixed or from user), clamp to 1–26, and compute top = "A".charCodeAt(0) + rows - 1.

Setup
2

Outer loop (row index)

for (let i = 0; i < rows; i++) selects the starting letter for the current line — E on row 0, D on row 1, and so on.

Row
3

Inner loop (descending letters)

start = top - i then for (let code = start; code >= base; code--): prints each letter with line += String.fromCharCode(code).

Letters
4

New line

console.log(line) ends the row so the next outer iteration starts fresh.

Break
=

Reverse alphabet pattern complete

Total letters: n+(n-1)+…+1 = n(n+1)/2O(n²) time, O(1) extra memory.

🔎 Worked Walkthrough — rows = 5

Trace each outer-loop value i (0-based) and see what the inner loop prints from start down to fixed A.

Outer istartInner loopPrinted rowLetters this row
0Efor (code = 69; code >= 65; code--)EDCBA5
1Dfor (code = 68; code >= 65; code--)DCBA4
2Cfor (code = 67; code >= 65; code--)CBA3
3Bfor (code = 66; code >= 65; code--)BA2
4Afor (code = 65; code >= 65; code--)A1

Total letter prints: 5 + 4 + 3 + 2 + 1 = 15 = 5×6/2. Same triangular total as Programs 1, 4, and 5 — only the letter order per row differs.

Use Cases

Where this reverse descending letter pattern (and its fixed floor at A) shows up beyond the homework prompt.

1. Teaching Reverse range Bounds

Clearest visual proof that for (let code = start; code >= base; code--) counts down to A while start shrinks each row.

Example: compare side-by-side with Program 4.

2. Pattern Series Bridge

Natural step after Program 6 before Program 8’s fixed-top reverse variant.

Example: Program 8 ends rows at a fixed top letter.

3. Console Formatting Drills

Practice reverse character loops and line += String.fromCharCode(code)/console.log(line) with a shape that differs visibly from Program 6.

Example: compare ascending Program 6 vs this descending shape.

4. Character Substitution

Swap to lowercase or digits once the letter loop works.

Example: print lowercase a..z once uppercase clicks.

5. Complexity Intuition

Triangular totals make O(n²) concrete for beginners.

Example: count printed letters for n = 10 → 55.

6. Input Validation Labs

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 start = top - i and the inner loop uses step -1 down to A.

Advantages

Why this reverse descending pattern earns a spot after Program 6 in beginner JavaScript courses.

  1. 1. Instant Visual Contrast

    Side-by-side with Program 6 makes ascending vs descending row letters obvious.

  2. 2. Minimal Concepts

    Only loops and console output — no arrays or math libraries.

  3. 3. Easy to Compare

    One formula change flips between Program 6’s ascending rows and this descending shape.

  4. 4. O(1) Extra Memory

    Streaming output needs no storage beyond loop counters.

Pro Tip: master Program 6 first, then this page — the row count is the same; only letter order and range step change.

Usage Tips

Small habits that keep reverse alphabet-pattern code clean.

  1. 1. Compute top Once

    Set top = "A".charCodeAt(0) + rows - 1 before the outer loop — don’t recalculate every row.

  2. 2. Validate prompt() input

    Avoid crashes when the user types letters instead of a number.

  3. 3. Keep console.log(line) Outside

    Only call console.log(line) after the inner loop finishes the row.

  4. 4. Remember code--

    for (let code = start; code >= base; code--) includes A — descending loops need an explicit negative step.

  5. 5. Dry-Run One Small n

    Trace rows = 3 on paper — expect CBA, BA, A — before coding larger demos.

Pro Tip: if rows print in ascending order, you almost certainly forgot step -1 in the inner range.

Common Pitfalls

Mistakes that commonly break reverse descending alphabet patterns.

  1. 1. Forgetting code-- in inner loop

    Counting up with code++ prints ascending letters — the pattern needs descending order.

    → Use for (let code = start; code >= base; code--) so letters count down to A.

  2. 2. Stopping before base (A)

    Using code > base stops before A — the last letter on each row is missing.

    → Use code >= base so A is included on every row.

  3. 3. Forgetting the Row Break

    Omitting console.log(line) after the inner loop glues every letter onto one endless line.

    → Always end the row after the inner loop.

  4. 4. Blind parseInt(prompt())

    Non-numeric input returns NaN with bare parseInt(prompt()).

    → Validate with Number.isFinite and clamp range.

  5. 5. Confusing with Program 4 or Program 8

    Program 4 prints A, BA, CBA (ascending prefix). Program 8 ends rows at a fixed top letter — not the same as EDCBA-to-A.

    → This pattern: start = top - i, for (let code = start; code >= base; code--), every row ends at A.

Edge Cases

Check these inputs before calling the solution done.

rows = 1

Single letter row

Output is just A — start is A and the inner loop prints one letter.

rows = 0

Empty pattern

Outer loop never runs — print nothing or show a message.

Negative

rows < 0

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

Large n

Many rows

Output grows as n²/2 characters — fine for labs, noisy for huge n.

Bad input

Non-numeric input

parseInt(prompt()) raises ValueError — validate first.

Last row

start equals A

On the last row, start == base — inner loop prints one letter only.

🎯 Practice Problems

Try these variations to lock in the reverse descending pattern.

1. Compare with Program 4

  • Run both patterns with the same rows
  • Note ascending prefix vs descending row

2. Print digits instead

  • Replace String.fromCharCode(code) with digit logic
  • Same reverse descending structure

3. Safe input loop

  • Use Number.isFinite validation until rows >= 1
  • Then draw the reverse pattern

4. Continue the series

  • Try Program 8 — reverse rows ending at fixed top letter
  • Next step after EDCBA-to-A

Notes

  • Fixed top. top = "A".charCodeAt(0) + rows - 1 is computed once — for five rows the first row starts at E.
  • for (let code = start; code >= base; code--) must include code >= base so A is included on every row.
  • Validate rows > 0 for interactive programs; rows = 1 should print a single A.
  • Program 4 grows A, BA, CBA; Program 8 ends at a fixed top letter — compare both to see how bounds drive the shape.

Quick Takeaway: compute fixed top, shrink start each row, append with for (let code = start; code >= base; code--), then console.log(line).

⏱️ Time and Space Complexity

ProgramTimeExtra space
Nested loops (Examples 1–2)O(rows²)O(1)
letters.slice(0, rows - i).split("").reverse().join("") (Example 3)O(rows²)O(rows) per row string (temporary)
Wrap Up

🎉 Conclusion

The reverse alphabet pattern (EDCBA to A) is a compact bounds exercise with lasting payoff: fixed top, per-row shrinking start, reverse range, and O(n²) intuition. Master the classic two-loop version, then optionally shorten rows with letters.slice(0, rows - i).split("").reverse().join("").

Practice the three examples above, then continue to Program 8 for the fixed-top reverse variant in the series.

Every row ends at A — use for (let code = start; code >= base; code--), build with line += String.fromCharCode(code), log with console.log(line), and validate row counts when reading from prompt().

💡 Best Practices

✅ Do

  • Compute top = "A".charCodeAt(0) + rows - 1 once before the outer loop
  • Use start = top - i inside for (let i = 0; i < rows; i++)
  • Use for (let code = start; code >= base; code--) and line += String.fromCharCode(code)
  • Validate rows ≥ 1 for interactive programs
  • Wrap parseInt(prompt()) in Number.isFinite validation
  • State O(n²) time when asked about complexity

❌ Don’t

  • Forget step -1 on the inner range
  • Use Program 4’s ascending-prefix logic for this shape
  • Confuse this page with Program 8’s fixed-top variant
  • Skip the newline after each row
  • Ignore bad console input in user-facing demos
  • Skip the rows = 1 edge case

Key Takeaways

Knowledge Unlocked

Five things to remember about this reverse descending pattern

Print EDCBA-to-A the beginner-friendly way.

5
Core concepts
E 02

Fixed top

top = base + rows - 1

Code
03

Shrinking start

start = top - i

Code
04

code-- loop

for (let code = start; code >= base; code--)

Loop
O 05

Complexity

O(n²) time

Analysis

❓ Frequently Asked Questions

The outer loop walks i from 0 to rows-1. Each row sets start = top - i where top = "A".charCodeAt(0) + rows - 1. The inner loop uses for (let code = start; code >= base; code--) to append descending letters down to A, so row 0 is EDCBA, row 2 is CBA, and the last row is A.
For rows = 5, top is the code for E — the first letter on the top row. Each next row drops the leading letter but still ends at A.
Descending letters need for (let code = start; code >= base; code--). Stopping early or counting up prints ascending letters or skips A.
Program 4 grows each row from A up to the row letter (A, BA, CBA). This pattern starts high and counts down to A each row (EDCBA, DCBA, CBA).
O(n²) where n is the number of rows. Total logged characters equal n+(n-1)+...+1 = n(n+1)/2 — same triangular count as Programs 1, 4, and 5.
Yes. Keep letters = "ABCDEFG..." and console.log(letters.slice(0, rows - i).split("").reverse().join("")) for each row index i. Nested charCode loops teach the bounds; slice plus reverse is a compact shortcut.
Use parseInt with Number.isFinite after prompt(), then clamp rows between 1 and 26 so letter codes stay within A–Z.
Program 7 ends every row at A with a shrinking start (EDCBA to A). Program 8 keeps a fixed top letter on the right and reverses row width differently (EDCBA to E).

Did you Know? 🔊

Each row logs descending letters from a row-specific start down to A: top = "A".charCodeAt(0) + rows - 1, row i uses start = top - i and for (let code = start; code >= base; code--). Compare Program 4 (ascending row prefix A, BA, CBA) and Program 8 (reverse rows ending at fixed top letter).

Continue to Program 8

Reverse rows ending at a fixed top letter — the next alphabet pattern in the series.

Program 8 tutorial →

About the author

Mari Selvan M P
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.

12 people found this page helpful