Shape Rule
Vertical diamond
Widen 1..n, then mirror n-1..1 without duplicating the middle.
Diamond Alphabet & Stars in Python
Overview
What You’ll Learn
Build a vertical diamond where each row repeats the same letter, with * between letters. The pattern widens to the middle row, then mirrors back down — A, B*B, C*C*C, …, E*E*E*E*E, then back to A. Compare Program 15 (stars in the center) and Program 19 (mirrored letters with spaces). Includes a live preview, worked Python examples, edge cases, and complexity.
Row Letter
One per row
Row i uses letter chr(ord('A') + i - 1) (or alpha[i-1]).
Odd Length
2i − 1
Inner loop prints 1, 3, 5, … characters per row.
Alternate
j % 2
Odd positions print the letter; even positions print *.
Live Preview
Half height
Pick half height 1–8 and draw the diamond instantly.
O(n²)
Complexity
Odd-length rows up and down sum to O(n²).
Introduction
A diamond alphabet pattern with stars repeats one letter on each row and places * between those letters, widening to a middle row and then mirroring back down.
In Python you usually solve it with two outer loops (upper and lower halves) and an inner loop that uses j % 2 to choose letter vs star.
Why it matters?
It teaches three classic ideas at once: odd row lengths, position-based alternation, and mirroring without duplicating the widest row.
Key Highlights
Upper + Lower
Grow to n, then mirror from n-1.
Odd Widths
Rows have 1, 3, 5, … characters.
j % 2
Letter on odd, * on even.
One Letter / Row
Row i repeats letter number i.
In short: for each half-height row, print 2i-1 characters alternating letter and *, then mirror from n-1 down to 1.
Foundation
📝 Problem & Approach
Given a half height n (or fixed 5), print a vertical diamond of alternating letters and stars.
Python
# Half height 5
# A
# B*B
# C*C*C
# D*D*D*D
# E*E*E*E*E
# D*D*D*D
# C*C*C
# B*B
# AInputs & Outputs
| Item | Type | Description |
|---|---|---|
n | int | Half height (middle row letter = ‘A’ + n − 1). Cap at 26 for A–Z. |
| Printed output | text | About 2n-1 rows of letter/* patterns forming a diamond. |
Minimal workflow
Pseudocode
for i in 1..n:
ch = 'A' + i - 1
for j in 1..(2i-1):
print '*' if j even else ch
print newline
for i in (n-1)..1:
(same inner loop)Approach comparison
| Approach | Idea | Best for |
|---|---|---|
| Two outer halves | 1..n then n-1..1 | Matching this classic sample |
| Helper function | Extract “print row i” once | Avoiding duplicated inner loops |
| join rewrite | "*".join([ch]*i) style | Pythonic one-liner per row |
Cheat Sheet
⚡ Quick Reference
| Goal | Pattern |
|---|---|
| Upper half | for i in range(1, n + 1): |
| Lower half | for i in range(n - 1, 0, -1): |
| Row length | for j in range(1, i * 2): → 2i-1 chars |
| Alternate | print("*" if j % 2 == 0 else ch, end="") |
| Row letter | ch = chr(ord('A') + i - 1) or alpha[i - 1] |
| End the row | print() |
Compare
📋 Letter vs Star vs print()
Same row — different roles by column index.
Odd j
letterPrints the current row letter (A, B, C…)
Even j
*Prints the separator between letters
2i-1
widthOdd length so the row ends on a letter
print()
breakEnds the row after the alternating run
Context
When This Pattern Shows Up
Reach for this when teaching vertical mirrors and position-based alternation.
After mirrored rows
You already know half-and-mirror; now alternate symbols inside each row.
Modulo drills
Practice
j % 2for clean letter/star placement.Odd-length growth
Same 1, 3, 5… idea used in many pyramids and diamonds.
Separator swaps
Replace
*with-or spaces for variant labs.Not a UI layout tool
This is a console teaching pattern — not how you build modern app screens.
Key benefit: one modulo check plus a careful lower-half start builds a clean vertical diamond.
Interactive
🔮 Live Preview
Choose a half height between 1 and 8 and draw the diamond alphabet-and-stars pattern in the browser.
Hands-On
Examples Gallery
Three complete Python programs — fixed half height 5, user-chosen half height, and a Pythonic helper rewrite. Click View Output to reveal sample console results.
📚 Getting Started
Print the classic diamond with a letter list and two halves.
Example 1 — Fixed Half Height 5
Odd j prints the row letter; even j prints *. Upper half prints 1..5, lower half prints 4..1.
Python
alpha = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
for i in range(1, 6):
for j in range(1, i * 2):
print("*" if j % 2 == 0 else alpha[i - 1], end="")
print()
for i in range(4, 0, -1):
for j in range(1, i * 2):
print("*" if j % 2 == 0 else alpha[i - 1], end="")
print()How It Works
When i = 3, the inner loop runs j = 1..5 and prints C * C * C. The lower half starts at 4 so E*E*E*E*E appears only once.
📈 Practical Variant
Let the user choose the half height.
Example 2 — Half Height Input
Uses a computed row letter instead of an array. Wrap int(input()) in try/except ValueError in real apps.
Python
try:
n = int(input("Enter half height (like 5): "))
except ValueError:
print("Please enter a whole number.")
raise SystemExit(1)
n = max(1, min(n, 26))
for i in range(1, n + 1):
ch = chr(ord('A') + i - 1)
for j in range(1, i * 2):
print("*" if j % 2 == 0 else ch, end="")
print()
for i in range(n - 1, 0, -1):
ch = chr(ord('A') + i - 1)
for j in range(1, i * 2):
print("*" if j % 2 == 0 else ch, end="")
print()How It Works
Same alternation and mirror rules; only n changes the size. max(1, min(n, 26)) keeps row letters within A–Z.
⚡ Cleaner Structure
Extract the row printer or use a join-based one-liner per row.
Example 3 — print_row Helper / join Rewrite
Same diamond, less duplicated code. The join version builds each row as ch + "*" + ch + ... in one expression.
Python
def print_row(i):
ch = chr(ord('A') + i - 1)
print("*".join([ch] * i))
n = 5
for i in range(1, n + 1):
print_row(i)
for i in range(n - 1, 0, -1):
print_row(i)How It Works
"*".join([ch] * i) repeats the letter i times and inserts * between them — same visual as the j % 2 loop. The two outer loops only decide which row heights to print.
🧠 How the Algorithm Prints Rows
1
Upper half: 1 to n
The first outer loop runs i = 1..n, making the row length grow.
Up
2
Odd/even positions alternate
Inner loop prints 2i-1 characters: odd j prints the letter, even j prints *.
Alternate
3
Lower half mirrors down
Second outer loop runs i = n-1..1 so the widest row is not duplicated.
Mirror
4
New line
print() ends each row after the alternating run.
Break
=
Diamond made from rows
Total printed characters scale like O(n²) for half height n.
Trace
🔎 Worked Walkthrough — n = 3
Trace each half and the characters printed on each row.
| Half | i | Letter | Chars (2i−1) | Printed row |
|---|---|---|---|---|
| Upper | 1 | A | 1 | A |
| Upper | 2 | B | 3 | B*B |
| Upper | 3 | C | 5 | C*C*C |
| Lower | 2 | B | 3 | B*B |
| Lower | 1 | A | 1 | A |
Total rows: 2n - 1 = 5. Middle row C*C*C appears once.
Use Cases
Where this diamond letter/star idea shows up beyond the homework prompt.
1. Alternation Practice
Clearest alphabet demo of j % 2 choosing two symbols.
Example: swap * for - and compare.
2. Mirror Without Duplicates
Practice starting the lower half at n-1.
Example: start at n once and see the doubled middle.
3. Helper Extraction
Refactor duplicated halves into print_row (Example 3).
Example: one function, two calling loops.
4. Centered Diamond Labs
Add leading spaces later for a true 2D diamond silhouette.
Example: pad with n - i spaces before each row.
5. Complexity Intuition
Odd sums up and down make O(n²) easy to see.
Example: n=5 prints 25 + 16 = 41 characters.
6. Alphabet Caps
Practice limiting half height so letters stay in A–Z.
Example: reject n > 26 or clamp it.
Pro Tip: say “odd letter, even star, mirror from n minus one” before coding — that story prevents a doubled middle row.
Advantages
Why this pattern earns a spot among diamond and separator labs.
1. Instant Visual Feedback
Wrong modulo or a duplicated middle row shows up immediately.
2. Tiny Alternation Rule
One
j % 2check drives the whole letter/star effect.3. Easy to Refactor
A small helper or join rewrite removes duplicated upper/lower inner loops.
4. O(1) Extra Memory
Streaming output needs no storage beyond loop variables.
Pro Tip: get the upper half right first; only then add the lower half starting at n-1.
Usage Tips
Small habits that keep diamond letter/star code clean.
1. Start Lower Half at n-1
That single off-by-one avoids duplicating the widest row.
2. Keep Odd Row Lengths
Use
2i-1so every row ends on a letter, not a star.3. Use try/except ValueError
Avoid crashes when the user types letters instead of a number.
4. Cap at 26
Beyond Z you need a wrap/stop policy for row letters.
5. Extract print_row
Share one inner loop or join expression between upper and lower halves.
Pro Tip: if the middle letter row appears twice, you almost certainly started the lower half at n instead of n-1.
Common Pitfalls
Mistakes that commonly break diamond alphabet-and-star patterns.
1. Starting Lower Half at n
Duplicates the widest row in the middle.
→ Start from
n - 1.2. Even Row Length
Ending on a star breaks the letter-star-letter rhythm.
→ Print exactly
2i - 1characters.3. Flipped Modulo
Printing stars on odd positions yields
*B*instead ofB*B.→ Letter on odd
j, star on evenj.4. Blind int(input())
Letters or empty input raise
ValueError.→ Use
try/except ValueErrorand re-prompt on failure.5. Overflowing Z
Large half heights walk past the alphabet.
→ Cap
nat 26 or define a wrap policy.
Edge Cases
Check these inputs before calling the solution done.
n = 1
Single letter
Output is just A; lower half does not run.
n = 5
Classic sample
Middle row is E*E*E*E*E.
n = 3
Small diamond
Five rows through C*C*C.
n > 26
Past Z
Reject, clamp, or wrap — decide explicitly.
Bad input
Non-numeric input()
int(input()) raises ValueError — use try/except.
Separator
- or space
Same loops; only the even-position character changes.
Drill
🎯 Practice Problems
Try these variations to lock in the pattern.
1. Change the separator
- Print
-instead of* - Keep odd letter positions
2. Center the diamond
- Add
n - ileading spaces - Compare silhouette to star diamonds
3. Extract print_row
- Refactor like Example 3
- Share one inner loop or join
4. Continue to Program 22
- Right-aligned sequential alphabet pyramid
- See Program 22
Important
Notes
- Middle once. Lower half starts at
n-1so the widest row is not repeated. - Row length is always odd (
2i-1) so rows end on a letter. - Odd
j→ letter; evenj→*. - Total rows =
2n - 1for half height n.
Quick Takeaway: print odd-length letter/star rows from 1 to n, then mirror from n-1 to 1 — that is the whole diamond.
Analysis
⏱️ Time and Space Complexity
| Program | Time | Extra space |
|---|---|---|
| Fixed / input (Examples 1–2) | O(n²) | O(1) |
| Helper / join (Example 3) | O(n²) | O(1) |
Upper half prints about n² characters (sum of odds); lower half adds almost the same without the middle row — still O(n²).
🎉 Conclusion
The diamond alphabet-and-stars pattern is a small nested-loop exercise with lasting payoff: odd row lengths, position-based alternation, and a careful vertical mirror. Master the classic A…E…A sample, then try user input and a helper/join rewrite.
Practice the three examples above, then continue to Program 22’s right-aligned sequential alphabet pyramid.
Print 2i-1 characters with letter on odd positions and * on even ones, grow to n, then mirror from n-1.
Pro Tips
💡 Best Practices
✅ Do
- Start the lower half at
n - 1 - Use odd row lengths (
2i - 1) - Print letters on odd
j, stars on evenj - Use
try/except ValueErrorand cap at 26 - Extract a row helper when halves share logic
❌ Don’t
- Start the lower half at
n(duplicates middle) - Use an even character count per row
- Flip the modulo unless you want star-first rows
- Ignore alphabet overflow on large n
- Call
print()inside the alternating loop
Summary
Key Takeaways
Knowledge Unlocked
Five things to remember about this alphabet pattern
Print the diamond alphabet-and-stars pattern the beginner-friendly way.
5
Core concepts 01
Rule
Widen then mirror
Definition 02
Alternate
j % 2 letter/*
Code 03
Width
2i − 1 chars
Code 04
Mirror
Lower starts here
I/O 05
Complexity
O(n²) time
Analysis❓ Frequently Asked Questions
j runs 1,2,3,... Odd positions print the row letter and even positions print '*', producing lines like B*B and C*C*C.
The inner loop checks the position: even columns print '*', odd columns print the row letter. That alternates symbols cleanly.
That prints 2*i-1 characters per row (1,3,5,...), which makes the pattern widen toward the center.
The upper half already printed the widest row at i=n. Starting from n-1 mirrors without duplicating the middle row.
print(ch, end="") or print("*", end="") stays on the same line for each letter or star. print() ends the row after the inner loop finishes.
Program 15 puts stars in the center of a symmetric alphabet row. This pattern repeats one letter per row and places stars between those letters, then mirrors vertically.
O(n²) for half height n because the total printed characters is proportional to 1+3+...+(2n-1) up and down.
Wrap int(input()) in try/except ValueError, require n ≥ 1, and cap at 26 so row letters stay within A–Z.
Did you Know? 🔊
Upper half prints rows 1..n; lower half prints n-1..1 so the widest row appears once. Each row runs j = 1..(2i-1). Odd j prints the row letter, even j prints *.
Continue to Alphabet Pattern 22
Next up: right-aligned sequential alphabet pyramids with a running letter counter.
About the author
12 people found this page helpful