A diamond alphabet with stars widens then shrinks: each row repeats one letter with * between copies (B*B, C*C*C), mirrored so the widest middle row appears only once.
Remember
Rule: odd j → row letter; even j → '*'; upper 1..n then lower n-1..1
A
B*B
C*C*C
D*D*D*D
E*E*E*E*E
D*D*D*D
C*C*C
B*B
A ← half height n = 5
Unlike Program 15 (stars filling a center gap between alphabet wings), here one letter owns the whole row and stars sit between letter copies.
Approach
How to Solve It
Print an upper half that grows, then a lower half that shrinks from n-1, alternating letter and star by column index.
One function owns the letter/* run; halves only choose i
Less duplication, cleaner structure
Pseudocode
Pseudocode
for i from 1 to n:
ch = 'A' + i - 1
for j from 1 to 2*i - 1:
print '*' if j is even else ch
print newline
for i from n - 1 down to 1:
(same inner loop)
Cheat sheet
Goal
Pattern
Upper half
for i in range(1, n + 1):
Lower half
for i in range(n - 1, 0, -1):
Odd width
for j in range(1, i * 2): → 2i-1 chars
Alternation
print("*" if j % 2 == 0 else ch, end="")
Row letter
ch = chr(ord('A') + i - 1)
End the row
print()
A–Z-safe height
Clamp n to 1–26
Printing Letters vs Starting a New Line
API
Effect
Use for
print(..., end="")
Stays on the same line
Each letter and each star
print()
Ends the current line
After the alternating run
Print cells without a newline, then end the row once.
Try it
Live Preview
Change the half height and the diamond updates instantly — including middle letter and total rows.
Whole numbers from 1 to 8. Total rows = 2n - 1; middle letter is A + n - 1.
Live resultn = 5 · middle E · 9 rows
A
B*B
C*C*C
D*D*D*D
E*E*E*E*E
D*D*D*D
C*C*C
B*B
A
Trace
Worked Walkthrough — n = 3
Trace each row height, the letter, the odd-width run, and where the mirror starts.
Half
i
Letter
Width
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
Lower half starts at n - 1 so C*C*C is not printed twice. Width formula: 2i - 1.
Code
Python Programs
Three complete programs: fixed n = 5, half-height input(), and a print_row helper. Use View Output to reveal sample results.
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 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
for i in range(1, 6):
for j in range(1, i * 2):
if j % 2 == 0:
print("*", end="")
else:
print(alpha[i - 1], end="")
print()
for i in range(4, 0, -1):
for j in range(1, i * 2):
if j % 2 == 0:
print("*", end="")
else:
print(alpha[i - 1], end="")
print()
Output
A
B*B
C*C*C
D*D*D*D
E*E*E*E*E
D*D*D*D
C*C*C
B*B
A
How It Works
1. Upper half grows. Row i uses letter alpha[i - 1] and prints 2i - 1 characters.
2. Alternation. Even j prints *; odd j prints the row letter — so i = 3 becomes C*C*C.
3. Lower half mirrors. Starts at 4 so the widest row E*E*E*E*E appears only once.
Example 2 — Half Height Input
Uses a computed row letter instead of a string. Prefer try/except in real apps.
Python
n = int(input("Enter half height (like 5): "))
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()
Output (when user enters 3)
Enter half height (like 5): 3
A
B*B
C*C*C
B*B
A
How It Works
1. Same diamond rules. Only n changes the size — alternation and mirror stay identical.
2. Char from index.chr(ord('A') + i - 1) replaces the alphabet string lookup.
3. Safer input tip. Prefer try/except and stay within A–Z:
Safer input
try:
n = int(input("Enter half height (like 5): "))
except ValueError:
print("Enter a half height from 1 to 26.")
raise SystemExit
if n < 1 or n > 26:
print("Enter a half height from 1 to 26.")
raise SystemExit
Example 3 — print_row Helper
Same diamond, less duplicated code.
Python
def print_row(i):
ch = chr(ord('A') + i - 1)
for j in range(1, i * 2):
print("*" if j % 2 == 0 else ch, end="")
print()
n = 5
for i in range(1, n + 1):
print_row(i)
for i in range(n - 1, 0, -1):
print_row(i)
Output
A
B*B
C*C*C
D*D*D*D
E*E*E*E*E
D*D*D*D
C*C*C
B*B
A
How It Works
1. One row printer.print_row(i) owns the letter/* alternation and the newline.
2. Halves only choose height. Upper loops 1..n; lower loops n-1..1 — no duplicated inner logic.
3. Easier to change. Want a different separator? Edit one function instead of two loops.
Edge Cases & Pitfalls
Check these before calling the solution done.
Lower from n
Doubled middle
Starting the lower half at n reprints the widest row. Always start at n - 1.
j <= i * 2
Even width
Using range(1, i * 2 + 1) (or j <= i * 2) prints an extra character. Keep range(1, i * 2) for odd widths 1, 3, 5, …
Swap odd/even
Star first
Printing * on odd j starts each row with a star. Letters belong on odd positions.
n = 1
Single A
Output is just A; the lower half does not run — a good sanity check.
Past Z
Clamp to 26
Half height above 26 walks the middle letter past Z. Cap or reject the input.
Bad input
ValueError on int()
Bare int(input()) raises on letters — prefer try/except ValueError and require 1–26.
Analysis
Time and Space Complexity
Program
Time
Extra space
Two-loop / helper forms
O(n²)
O(1)
Upper half prints 1 + 3 + … + (2n - 1) = n² characters; the lower half adds almost the same without the middle row — still quadratic in n.
Remember
Key Takeaways
Two halves: grow 1..n, then shrink n-1..1 so the middle is unique.
Odd widths: each row prints 2i - 1 characters via range(1, i * 2).
Alternation: odd j → letter; even j → *.
Complexity:O(n²) time; O(1) extra space.
One line: for each row height up then down, print letter and * alternating across an odd-width run.
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 *.
