Shape Rule
Repeat letter, grow width
Row 1 prints E, row 2 prints DD, up to AAAAA on the last line.
Reverse Repeating-Letter Alphabet Triangle in Python
Overview
What You’ll Learn
Same repeating idea as Program 9, but letters run E → D → C → B → A while row widths still grow 1, 2, 3, 4, 5. This tutorial covers the shape rule, countdown loops, a live preview, worked Python examples, edge cases, and complexity.
Outer Loop
Letter countdown
for i in range(ord('E'), ord('A') - 1, -1): picks the letter for each row.
Inner Loop
Repeat count
for j in range(ord('E'), i - 1, -1): runs 1, 2, 3… times — print chr(i), not the inner counter.
print end= vs print()
Same line / next line
Letters use print(..., end=""); end each row with print().
Live Preview
1–26 rows
Pick a row count and draw the reverse repeating triangle in the browser.
O(n²)
Complexity
Total letters = n(n+1)/2; extra memory stays O(1).
Introduction
A reverse repeating alphabet triangle grows by one repeated letter on each new line, counting letters downward from the top of the alphabet range. With the right angle on the left, the console shows a staircase of identical letters per row.
In Python you usually solve it with two nested for loops: the outer loop picks the row letter (counting down), the inner loop prints that same letter the right number of times, then print() moves to the next line.
Why it matters?
It locks in the difference between “which letter” (outer loop) and “how many times” (inner loop). Once that clicks, forward repeats, pyramids, and letter-countdown variants become much easier.
Key Highlights
Letters Count Down
Rows use E, then D, then C … down to A.
Width Still Grows
Row widths are still 1, 2, 3, … like Program 9.
Print Outer Letter
print(chr(i), end="") in the inner loop; print() after.
Mirror of Program 9
Same shape — reverse letter direction only.
In short: for each letter i from top down to A, print i repeatedly (growing count), then call print().
Foundation
📝 Problem & Approach
Given a positive integer rows (or a fixed top letter like 'E'), print a left-aligned triangle where each row repeats one letter and letters count downward.
Python
# First 5 rows (conceptual shape)
# E
# DD
# CCC
# BBBB
# AAAAAInputs & Outputs
| Item | Type | Description |
|---|---|---|
rows | int | Number of triangle lines (typically 1–26). Top letter = chr(ord('A') + rows - 1). |
| Printed output | text | Left-aligned rows; row k repeats letter top - (k-1) exactly k times. |
Minimal workflow
Pseudocode
top = ord('A') + rows - 1
for code from top down to ord('A'):
repeat = (top - code) + 1
for k from 1 to repeat:
print chr(code) (no newline)
print newlineApproach comparison
| Approach | Idea | Best for |
|---|---|---|
| Nested char loops | Outer letter + inner count via char range | Learning and interviews |
ch * repeat | Build a whole row in one call | Shorter production-style demos |
Cheat Sheet
⚡ Quick Reference
| Goal | Pattern |
|---|---|
| Walk letters downward | for i in range(ord('E'), ord('A') - 1, -1): |
| Grow repeat count | for j in range(ord('E'), i - 1, -1): |
| Print row letter | print(chr(i), end="") — not the inner counter |
| End the row | print() |
| One-line row shortcut | print(ch * repeat) |
| Forward letters | See Program 9 (A, BB, CCC, …) |
Compare
📋 print end= vs print() vs *
Same triangle — different ways to emit characters.
print(..., end="")
same linePrints a letter without moving to the next line
print()
new lineEnds the current row after all repeats are printed
ch * n
whole rowBuilds n copies of ch at once — skip the inner loop
Learning tip
print chr(i)Master printing the outer letter before the string shortcut
Context
When This Pattern Shows Up
Reach for this triangle when practicing letter direction vs repeat count.
After Program 9
Flip letter direction while keeping the same growing widths.
Outer vs inner roles
Clear drill: outer = which letter, inner = how many copies.
Char arithmetic practice
Compute
top = ord('A') + rows - 1and count down safely.Gateway to variants
Lowercase, hollow borders, or centered pyramids next.
Not a UI layout tool
This is a console teaching pattern — not how you build modern app screens.
Key benefit: one small program that separates letter choice from repeat count — the skill behind most alphabet patterns.
Interactive
🔮 Live Preview
Choose a row count between 1 and 26 and draw the reverse repeating alphabet triangle in the browser.
Hands-On
Examples Gallery
Three complete Python programs — fixed top letter, CLI input, and a ch * repeat shortcut. Click View Output to reveal sample console results.
📚 Getting Started
Print five rows with classic nested char loops.
Example 1 — Fixed 'E' down to 'A'
Hard-coded range — ideal for first demos and screenshots.
Python
for i in range(ord('E'), ord('A') - 1, -1):
for j in range(ord('E'), i - 1, -1):
print(chr(i), end="")
print()How It Works
When i is ord('E'), the inner loop runs once and prints E. When i is ord('D'), it prints DD, and so on until A. Printing chr(i) (not the inner counter) keeps each row uniform.
📈 Practical Variant
Let the user choose the height at runtime.
Example 2 — User Input Version
Compute top = ord('A') + rows - 1, then count down. Wrap int(input()) in try/except ValueError in real apps.
Python
rows = int(input("Enter the number of rows: "))
rows = max(1, min(rows, 26))
base = ord('A')
top = base + rows - 1
for code in range(top, base - 1, -1):
repeat = top - code + 1
for _ in range(repeat):
print(chr(code), end="")
print()How It Works
For rows = 4, top is ord('D'). Each step down increases repeat by one. Clamp rows to 1–26 so top stays within A–Z.
⚡ Shortcut Style
Same shape without an explicit inner print loop.
Example 3 — ch * repeat
Build each repeated-letter row in one call, then print it.
Python
rows = 5
base = ord('A')
top = base + rows - 1
for code in range(top, base - 1, -1):
repeat = top - code + 1
print(chr(code) * repeat)How It Works
chr(code) * repeat creates a string of length repeat filled with that letter. Great once you understand the nested-loop idea; keep the two-loop version for exams that ask you to show both bounds.
🧠 How the Algorithm Prints Rows
1
Set up
Use input() when reading input. Fix the top letter or compute it from rows.
Setup
2
Outer loop (letter)
for i in range(ord('E'), ord('A') - 1, -1): selects the character printed on the row.
E → A
3
Inner loop (count)
for j in range(ord('E'), i - 1, -1): runs 1, 2, 3… times; print chr(i) with print(chr(i), end="").
Repeats
4
New line
print() ends the row so the next outer iteration starts fresh.
Break
=
Triangle complete
Total letters: 1+2+…+n = n(n+1)/2 — O(n²) time, O(1) extra memory.
Trace
🔎 Worked Walkthrough — 'E' down to 'A'
Trace each outer-loop value of i and count how many times the inner loop runs.
i | Inner j range | Printed row | Repeats |
|---|---|---|---|
'E' | 'E'..'E' | E | 1 |
'D' | 'E'..'D' | DD | 2 |
'C' | 'E'..'C' | CCC | 3 |
'B' | 'E'..'B' | BBBB | 4 |
'A' | 'E'..'A' | AAAAA | 5 |
Total letter prints: 1 + 2 + 3 + 4 + 5 = 15 = 5×6/2.
Use Cases
Where this tiny pattern (and its loop structure) shows up beyond the homework prompt.
1. Outer vs Inner Clarity
Best demo that the printed value need not be the loop counter.
Example: swap print(chr(i), end="") for print(chr(j), end="") and watch letters step.
2. Pair with Program 9
Teach direction as a one-line change: increment vs decrement.
Example: side-by-side A/BB/CCC vs E/DD/CCC.
3. Char Math Labs
Practice ord('A') + rows - 1 without complex algorithms.
Example: rows = 7 → top = 'G'.
4. Case & Fill Variants
Swap to lowercase or mix digits once the loops work.
Example: start from 'a' + rows - 1.
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 try/except ValueError and 1–26 clamps.
Example: reject rows <= 0 or rows > 26.
Pro Tip: when explaining this pattern, say “outer picks the letter, inner only counts” before writing any code — that story prevents the print(chr(j), end="") mistake.
Advantages
Why this pattern earns a spot right after the forward repeating triangle.
1. Instant Visual Feedback
Wrong printed variable shows up immediately as stepping letters.
2. Minimal Concepts
Only loops, chars, and console output — no arrays required.
3. Easy to Mirror
Flip to Program 9 by counting letters upward instead.
4. O(1) Extra Memory
Streaming output needs no storage beyond loop counters.
Pro Tip: learn the nested-loop version first; treat ch * repeat as a polish shortcut afterward.
Usage Tips
Small habits that keep alphabet-pattern code clean.
1. Name the Roles
Use
chfor the row letter andrepeat(ork) for the count — clearer than overloadedi/j.2. Wrap
int(input())in try/exceptAvoid crashes when the user types letters instead of a number.
3. Keep print() Outside
Only call
print()after the inner loop finishes the row.4. Clamp to 26
For A–Z demos, reject or clamp
rows > 26.5. Dry-Run One Small n
Trace
rows = 3(C, BB, AAA) on paper before coding larger demos.
Pro Tip: if a row shows EDCBA-style sequences, you almost certainly printed j instead of i.
Common Pitfalls
Mistakes that commonly break reverse repeating alphabet patterns.
1. Printing
jInstead ofiRows become countdown sequences instead of repeated letters.
→ Always
print(chr(i), end="")(orch) for this shape.2. print() Inside the Inner Loop
Each letter lands on its own line — you get a column, not a triangle.
→ Use
print(..., end="")for letters;print()only after the inner loop.3. Forgetting the Row Break
Omitting
print()after the inner loop glues every letter onto one endless line.→ Always end the row after the inner loop.
4. Blind int(input())
Non-numeric input raises
ValueErrorwith bareint(input()).→ Wrap in
try/except ValueErrorand validate range.5. rows > 26 Without a Policy
ord('A') + rows - 1can leave the A–Z range.→ Clamp to 26 or define wrap/error behavior explicitly.
Edge Cases
Check these inputs before calling the solution done.
rows = 1
Single letter
Output is just A on one line.
rows = 0
Empty pattern
Treat as invalid; re-prompt instead of silent empty output.
Negative
rows < 0
Invalid height — validate before computing top.
rows > 26
Past Z
Clamp or error — char math leaves A–Z.
Bad input
Non-numeric input
int(input()) raises ValueError — validate first.
Case
Lowercase variant
Same loops work with 'a' and 'a' + rows - 1.
Drill
🎯 Practice Problems
Try these variations to lock in the pattern.
1. Flip to Program 9
- Count letters upward: A, BB, CCC, …
- Continue with Program 9
2. Lowercase version
- Use
'a' + rows - 1as the top letter - Shows the loop structure is reusable
3. Safe input loop
- Use
try/except ValueErroruntil1 <= rows <= 26 - Then draw the triangle
4. Hollow reverse triangle
- Print the letter only on borders; spaces inside
- Harder follow-up after this page
Important
Notes
- Triangular count. Total letters for n rows is
n(n+1)/2— hence O(n²) time. - Print the outer letter; the inner loop only decides how many times.
- Validate
1 <= rows <= 26for interactive A–Z programs. - This page is left-aligned. Centered pyramids need leading spaces — covered later in the series.
Quick Takeaway: outer loop picks the letter (counting down), inner loop repeats it, then break the line — that is the whole pattern.
Analysis
⏱️ Time and Space Complexity
| Program | Time | Extra space |
|---|---|---|
| Nested loops (Examples 1–2) | O(rows²) | O(1) |
ch * repeat (Example 3) | O(rows²) | O(rows) per row string (temporary) |
🎉 Conclusion
The reverse repeating alphabet triangle is a small nested-loop exercise with lasting payoff: outer letter vs inner count, char countdown, and O(n²) intuition. Master the classic two-loop version, then optionally shorten rows with ch * repeat.
Practice the three examples above, then compare with Program 9 or continue to the next alphabet pattern.
Print the outer letter with print(..., end=""), end rows with print(), and clamp row counts to 1–26 when reading input.
Pro Tips
💡 Best Practices
✅ Do
- Explain outer = letter, inner = count before coding
- Use
print(chr(i), end="")for letters andprint()after each row - Validate
1 <= rows <= 26for interactive programs - Wrap
int(input())intry/except ValueError - State O(n²) time when asked about complexity
❌ Don’t
- Print the inner-loop variable for this repeating shape
- Call
print()inside the inner letter loop - Skip the newline after each row
- Ignore bad console input in user-facing demos
- Allow
rows > 26without a clear policy
Summary
Key Takeaways
Knowledge Unlocked
Five things to remember about this alphabet pattern
Print the reverse repeating triangle the beginner-friendly way.
5
Core concepts 01
Rule
Letters down, width up
Definition 02
Outer loop
Picks the row letter
Code 03
Inner loop
Repeats with print(chr(i), end="")
04
print()
Ends each row
I/O 05
Complexity
O(n²) time
Analysis❓ Frequently Asked Questions
Program 9 uses A, BB, CCC, ... (letters increase). Program 10 uses E, DD, CCC, ... (letters decrease) with the same growing repeat counts.
On the 4th row the outer-loop letter is B, and the inner loop runs four times, printing B each time.
The inner loop only controls how many times to print. Printing the outer letter keeps the row uniform; printing the inner counter would change letters across the row.
print(ch, end="") stays on the same line. print() ends the current line. Letters use end=""; the row break uses print() after the inner loop.
O(n²) where n is the number of rows. Total printed characters equal 1+2+…+n = n(n+1)/2.
Yes. print(ch * repeat) prints a full repeated-letter row in one call. Nested loops are better for learning; ch * repeat is a handy shortcut later.
Use a try/except ValueError around int(input()), or check raw.isdigit() before converting, then clamp rows between 1 and 26 so bad input does not walk past A.
Top letter math can go past Z. Clamp to 26 for A–Z demos, or define a clear wrap/error policy.
Did you Know? 🔊
This pattern is the reverse of Program 9: row widths still grow 1, 2, 3, …, but letters run backward (E, then D, then C, …). Print the outer loop letter inside the inner loop so each row stays uniform.
Continue to Alphabet Pattern 11
Keep building letter patterns with nested loops and char math.
About the author
12 people found this page helpful