Shape Rule
One letter, growing count
Row 1 prints A, row 2 prints BB, row 3 prints CCC, row 4 prints DDDD, row 5 prints EEEEE.
Repeating-Letter Alphabet Pattern in Python
Overview
What You’ll Learn
Row 1 is one A, row 2 is two Bs, row 3 three Cs, and so on: A, BB, CCC, DDDD, EEEEE. Contrast Program 1, where letters change inside each row. Here, the row letter stays the same and only the count grows. Next up: Program 10 reverses the letter order. Includes a live preview, worked Python examples, edge cases, and complexity.
Outer Loop
Row letter
for row in range(1, rows + 1): picks both the letter offset and how many times to repeat it on each line.
Inner Loop
Count only
for _ in range(row): print(ch, end="") prints the same letter row times — the inner loop only controls count, not which letter.
String Shortcut
ch * row
print(ch * row) repeats the letter in one line — same output as nested loops.
Live Preview
Rows 1–26
Pick a row count and draw A, BB, CCC live.
O(n²)
Complexity
1+2+…+n printed characters total.
Introduction
A repeating-letter alphabet pattern (A, BB, CCC, ...) prints one letter per row, repeated as many times as the row number. With five rows the console shows A, BB, CCC, DDDD, EEEEE — unlike Program 1, where letters change inside each row.
In Python you solve it with two nested for loops: compute ch = chr(ord('A') + row - 1), repeat that letter row times with the inner loop, then call print() for the next line. Or shorten each row to print(ch * row).
Why it matters?
It teaches that the inner loop can control repetition count while the outer loop picks the value — a key idea before Program 10’s reverse variant.
Key Highlights
Row letter
ch = chr(ord('A') + row - 1)
Inner loop
for _ in range(row) — count only.
print(ch, end="") then print().
Output
A, BB, CCC, …
In short: for each row from 1 to rows, set ch = chr(ord('A') + row - 1), print ch exactly row times with print(ch, end=""), then call print().
Foundation
📝 Problem & Approach
Given a positive integer rows, print a left-aligned repeating-letter alphabet pattern: each row prints one letter repeated row times (A, BB, CCC when rows = 5).
Python
# First 5 rows (conceptual shape)
# A
# BB
# CCC
# DDDD
# EEEEEInputs & Outputs
| Item | Type | Description |
|---|---|---|
rows / top | int / char | Number of rows; last letter is 'A' + rows - 1 (E for 5). |
| Printed output | text | Growing rows of repeated letters A, BB, CCC, … |
Minimal workflow
Pseudocode
base = ord('A')
for row from 1 to rows:
ch = chr(base + row - 1)
repeat ch exactly row times (inner loop or ch * row)
print()Approach comparison
| Approach | Idea | Best for |
|---|---|---|
| Char nested loops | Outer i++, inner count, print i | Matching this classic sample |
| Row index + char math | ch = (char)('A' + row - 1) then print row times | User-input versions; clearer count |
Cheat Sheet
⚡ Quick Reference
| Goal | Pattern |
|---|---|
| Walk each row | for row in range(1, rows + 1): |
| Row letter | ch = chr(ord('A') + row - 1) |
| Repeat letter | for _ in range(row): print(ch, end="") |
| End the row | print() |
| One-line shortcut | print(ch * row) |
| Stepping letters variant | See Program 1 — A, AB, ABC triangle |
| Reverse repeat variant | See Program 10 (E, DD, CCC, …) |
Compare
📋 Nested loop vs ch * row vs print_row helper
Same A, BB, CCC shape — three ways to think about row letter and repetition count.
Nested loop
for _ in range(row)Classic ord/chr loop — teaches letter formula and repetition count separately
ch * row
print(ch * row)String multiplication — compact one-liner per row
print_row helper
def print_row(ch, n)Extract inner loop into a function — reusable for other patterns
Learning tip
loops firstMaster nested loops before the string shortcut or helper
Context
When This Pattern Shows Up
Reach for this when teaching that the inner loop can control count while the outer variable controls the printed value.
After Program 1
Keep the same loop bounds; change only
print(chr(j), end="")toprint(chr(i), end="").Repeat-count drills
Practice decoupling “what to print” from “how many times.”
Bridge to Program 10
Next keeps repeats but walks the letter backward: E, DD, CCC.
Index-to-char practice
Map row numbers to letters with
'A' + row - 1.Not a UI layout tool
This is a console teaching pattern — not how you build modern app screens.
Key benefit: printing the outer letter inside the inner loop is the cleanest way to build a growing triangle of repeated characters.
Interactive
🔮 Live Preview
Choose 1–26 rows and draw the repeating-letter alphabet triangle in the browser.
Hands-On
Examples Gallery
Three complete Python programs — fixed A–E, user-chosen row count, and a chr(...) * row shortcut. Click View Output to reveal sample console results.
📚 Getting Started
Print five growing rows of repeated letters from A to E.
Example 1 — Fixed rows = 5
Hard-coded height — ideal for first demos and screenshots.
Python
rows = 5
base = ord('A')
for row in range(1, rows + 1):
ch = chr(base + (row - 1))
for _ in range(row):
print(ch, end="")
print()How It Works
When row = 1, ch is A and the inner loop prints it once. When row = 3, ch is C and the inner loop prints CCC. When row = 5, ch is E and the row is EEEEE. print() after the inner loop starts the next row.
📈 Practical Variant
Let the user choose how many rows to print.
Example 2 — User Input Version
Read the row count with input() and convert with int() (wrap in try/except ValueError in real apps).
Python
rows = int(input("Enter the number of rows (max 26): "))
rows = max(1, min(rows, 26))
base = ord('A')
for row in range(1, rows + 1):
ch = chr(base + (row - 1))
for _ in range(row):
print(ch, end="")
print()How It Works
For row 4, ch becomes D and the inner loop prints it four times. Cap rows at 26 so ch stays within A–Z.
⚡ Shortcut Style
Same shape with Python string multiplication.
Example 3 — ch * row String Repetition
Multiply the row letter by the row number — same triangle, one print per row.
Python
rows = 5
rows = max(1, min(rows, 26))
base = ord('A')
for row in range(1, rows + 1):
ch = chr(base + (row - 1))
print(ch * row)How It Works
chr(ord('A') + row - 1) * row builds each line in one expression. Keep the nested-loop version for exams that ask you to show outer vs inner letter logic.
🧠 How the Algorithm Prints Rows
1
Outer loop selects the row letter
i runs from 'A' to top. That’s the character printed on the row.
Row character
2
Inner loop controls the repeat count
j runs from 'A' to i, so it executes 1, 2, 3, … times as rows grow.
1..n repeats
3
Print i, not j
Printing i keeps the whole row the same letter. Printing j would change letters across the row (Program 1).
Key idea
4
New line
print() ends each row before the next letter begins.
Line break
=
Same triangle shape
Total prints are 1+2+…+n for n rows, so time complexity is O(n²).
Trace
🔎 Worked Walkthrough — rows = 5
Trace each outer-loop row value and see how the letter formula and repetition count produce each printed line.
row | Letter | Count | Output |
|---|---|---|---|
1 | A | 1 | A |
2 | B | 2 | BB |
3 | C | 3 | CCC |
4 | D | 4 | DDDD |
5 | E | 5 | EEEEE |
Highlight rows 1, 3, and 5: A ×1 → A; C ×3 → CCC; E ×5 → EEEEE. Total letter prints: 1 + 2 + 3 + 4 + 5 = 15 = 5×6/2.
Use Cases
Where this repeating-letter alphabet triangle shows up beyond the homework prompt.
1. Value vs Count Labs
Clearest demo of printing the outer variable inside the inner loop.
Example: change print(chr(i), end="") to print(chr(j), end="") and compare with Program 1.
2. Repeat Practice
Build intuition for loops that only control iteration count.
Example: rewrite the inner loop as for (int k = 0; k < n; k++).
3. Char Math
Map row indexes to letters with 'A' + row - 1.
Example: scale from 5 to 8 without rewriting loops.
4. String Helpers
Later rewrite as new string(ch, row) once the idea clicks.
Example: same output with one print per row.
5. Complexity Intuition
Triangle sums make O(n²) easy to see.
Example: 15 letters for 5 rows.
6. Series Continuity
Sits between Programs 8 and 10 in the alphabet set.
Example: revisit Program 1.
Pro Tip: say “pick the letter outside, repeat it inside” before coding — that story prevents printing j by habit.
Advantages
Why this pattern earns a spot early in the alphabet-pattern series.
1. Instant Visual Feedback
A stepping-letter row (ABC) shows immediately if you printed
j.2. Tiny Diff from Program 1
Only the printed variable changes.
3. Scales Cleanly
Change the top letter or row count and the whole triangle grows.
4. Beginner-Friendly
No padding or diagonal checks — just two loops and one print rule.
Pro Tip: master Program 1 first; this page is mostly “same loops, print the outer letter.”
Usage Tips
Small habits that keep repeating-letter alphabet triangles clean.
1. Always Print i (or ch)
Printing
jturns this into Program 1.2. Let the Inner Loop Only Count
Do not increment the character inside the inner loop.
3. Cap Rows at 26
Keep the row letter inside A–Z when taking user input.
4. Wrap int(input()) in try/except
Validate the row count before using
int(input()).5. Compute the Letter from the Row
Use
ch = (char)('A' + row - 1)when working with integer row indexes.
Pro Tip: if you see A, AB, ABC, you printed j — switch back to print(chr(i), end="").
Common Pitfalls
Mistakes that commonly break repeating-letter alphabet triangles.
1. Off-by-one in chr(base + row - 1)
Using
chr(base + row)skipsAon row 1 or starts atB. Forgettingrow - 1shifts every letter forward.→ Always use
ch = chr(base + (row - 1))with 1-basedrowvalues.2. Using range(rows) instead of range(1, rows + 1)
range(rows)starts at 0, sochr(base + row - 1)on row 0 gives wrong letters or an extra blank row.→ Use
for row in range(1, rows + 1):so row matches both letter offset and repeat count.3. rows > 26 without clamping
Row 27 would need a letter beyond
Z—chr()still returns a character but not the expected alphabet pattern.→ Clamp with
rows = max(1, min(rows, 26))after reading input.4. Printing inner counter letter (Program 1 shape)
Printing a changing letter inside the inner loop produces A, AB, ABC — Program 1, not this pattern.
→ Print the same
chevery time in the inner loop, or useprint(ch * row).5. Forgetting print() after the inner loop
Omitting
print()glues every letter onto one endless line.→ Always end the row after the inner loop (unless using
print(ch * row)alone).
Edge Cases
Check these inputs before calling the solution done.
rows = 1
Single letter
Output is just A.
rows = 5
Classic sample
A through EEEEE (Example 1).
rows = 4
Smaller triangle
Ends at DDDD (Example 2).
rows > 26
Past Z
Cap or reject — the row letter leaves the alphabet.
Bad input
Empty / non-numeric
Validate with try/except ValueError.
Lowercase
a, bb, ccc
Swap 'A' for 'a' as the base.
Drill
🎯 Practice Problems
Try these variations to lock in the pattern.
1. Flip to Program 1
- Change only
print(chr(i), end="")toprint(chr(j), end="") - Confirm you get A, AB, ABC
2. Reverse the letters
- Start the outer letter at E and count down
- Continue to Program 10
3. Scale to 8 rows
- Use the input version
- Check the last row is HHHHHHHH
4. One print per row
- Rewrite with
new string(ch, row) - Confirm the output matches Example 2
Important
Notes
- Outer picks the letter. Inner only decides how many times to print it.
- Printing
i(notj) is what keeps each row uniform. - Row lengths are 1, 2, …, n — same geometry as Program 1.
- Next up: Alphabet Pattern 10 reverses the letter order while keeping repeats.
Quick Takeaway: choose the row letter in the outer loop, then print that letter once per inner iteration — that alone builds A, BB, CCC, …
Analysis
⏱️ Time and Space Complexity
| Program | Time | Extra space |
|---|---|---|
| Inline / input (Examples 1–2) | O(n²) | O(1) |
chr(...) * row (Example 3) | O(n²) | O(1) |
For n rows you print 1+2+…+n = n(n+1)/2 characters, so total work is O(n²).
🎉 Conclusion
The repeating-letter alphabet triangle is Program 1 with a different print rule: the outer loop picks the letter, and the inner loop only repeats it. Master the classic A…EEEEE sample, then try user input and the multiplication shortcut.
Practice the three examples above, then continue to Alphabet Pattern 10.
Outer row letter from ord('A') to top; inner loop counts repeats; print chr(i) each time, then print() for the newline.
Pro Tips
💡 Best Practices
✅ Do
- Print the outer letter (
iorch) inside the inner loop - Use the inner loop only for the repeat count
- Compute
ch = (char)('A' + row - 1)for integer row indexes - Cap user row counts at 26
- State O(n²) when asked about complexity
❌ Don’t
- Print
jwhen you want A, BB, CCC - Change the letter inside the inner loop
- Forget the
- 1in the letter formula - Skip validating row-count input
- Call
print()inside the letter loop
Summary
Key Takeaways
Knowledge Unlocked
Five things to remember about this alphabet pattern
Print the repeating-letter alphabet triangle the beginner-friendly way.
5
Core concepts 01
Rule
One letter, growing repeats
Definition 02
print(chr(i), end=""), not print(chr(j), end="")
Code 03
Inner
Controls count only
Shape 04
vs Prog 1
Same loops, different print
Compare 05
Complexity
O(n²) time
Analysis❓ Frequently Asked Questions
The outer loop walks row from 1 to rows. Each row picks one letter with ch = chr(ord('A') + row - 1) and the inner loop prints that letter row times with print(ch, end=""). Row 1 prints A once, row 3 prints C three times as CCC, and row 5 prints E five times as EEEEE.
range(1, rows + 1) gives row values 1, 2, 3, … that match both the letter offset (row - 1) and the repetition count (row). range(rows) starts at 0, which breaks chr(base + row - 1) unless you add extra +1 fixes everywhere.
ord('A') is 65. For row 1 you get chr(65) = A; for row 3 you get chr(67) = C. The row - 1 converts 1-based row numbers into 0-based letter offsets from A.
Yes. After computing ch, print(ch * row) repeats the character row times in one expression. Nested loops teach repetition control; string multiplication is the compact Python shortcut.
Program 1 prints ascending letters A, AB, ABC on each row. This pattern repeats a single letter per row — A, BB, CCC — so every character on a line is identical.
Program 9 grows from A downward: A, BB, CCC, DDDD. Program 10 mirrors it from the top letter backward — E, DD, CCC, BB, A when rows = 5.
O(n²) where n is the number of rows. Total printed characters equal 1+2+3+...+n = n(n+1)/2 — the same triangular total as Programs 1, 4, 5, 7, and 8.
Use try/except ValueError around int(input()), or validate with raw.isdigit(), then clamp rows between 1 and 26 so chr(ord('A') + row - 1) never exceeds Z.
Did you Know? 🔊
Each row prints one letter repeated row times: row 1 is A, row 2 is BB, row 3 is CCC. Letter = chr(ord('A') + row - 1). Compare Program 10 (reverse repeated letters) and Program 1 (classic A.. triangle).
Continue to Program 10
Reverse repeating triangle — the next alphabet pattern in the series.
About the author
12 people found this page helpful