Shape Rule
Diamond halves
Top half grows 1..rows; bottom half mirrors rows-1..1.
Diamond Number Pyramid in Python
Overview
What You’ll Learn
The centered number diamond prints 1, 123, 12345, … 123456789, then mirrors back down — a natural follow-up after Program 43’s right-aligned triangle. This tutorial covers two outer loops, centering spaces, ascending digit sequences, a live preview, worked Python examples, edge cases, and complexity.
Top Loop
i = 1..rows
for i in range(1, rows + 1): — builds the growing half of the diamond.
Bottom Loop
i = rows-1..1
for i in range(rows - 1, 0, -1): — mirrors the top half back down.
Space + digits
Center rows
Leading spaces then range(1, 2*i) prints 1 to 2*i-1.
Live Preview
Rows 3–5
Pick a height and draw the centered number diamond in the browser.
O(n²)
Complexity
Each level prints O(n) digits across O(n) levels — total work scales as n².
Introduction
A diamond number pyramid prints odd-length digit rows: 1, 123, 12345, … up to the widest row, then mirrors back down. With rows = 5, the output is a symmetric centered diamond.
In Python you use two outer loops: the first grows rows 1..rows; the second shrinks rows-1..1. Each row prints leading spaces, then digits 1 to 2*i-1 with print(k, end="").
Why it matters?
It combines two-phase loops with centering — a key step after Program 43’s right-aligned triangle.
Key Highlights
2*i-1
Odd-length rows.
Two halves
Top + bottom loops.
Centering
rows - i spaces.
Series Foundation
Follow Program 43; continue to Program 45 next.
In short: top loop i = 1..rows, bottom loop i = rows-1..1, spaces rows - i, digits range(1, 2*i), then print().
Foundation
📝 Problem & Approach
Given rows = 5, print a centered number diamond: top half grows odd-length digit rows; bottom half mirrors back down.
Python
# rows = 5
# 1
# 123
# 12345
# 1234567
#123456789
# 1234567
# 12345
# 123
# 1Inputs & Outputs
| Item | Type | Description |
|---|---|---|
rows | int | Half-height of the diamond — widest row has 2*rows-1 digits. |
i | int | Outer loop — row index (top: 1..rows; bottom: rows-1..1). |
k | int | Number loop — prints digits 1..2*i-1. |
Minimal workflow
Pseudocode
for i from 1 to rows:
print (rows - i) spaces
for k from 1 to 2*i-1: print k
print newline
for i from rows-1 down to 1:
print (rows - i) spaces
for k from 1 to 2*i-1: print k
print newlineApproach comparison
| Approach | Idea | Best for |
|---|---|---|
| Fixed rows | 1, 123, … | Learning and interviews |
| User-input rows | int(input(...)) | Configurable diamond size |
| Compact demo | rows = 3 | Paper trace before scaling up |
Cheat Sheet
⚡ Quick Reference
| Goal | Pattern |
|---|---|
| Top outer loop | for i in range(1, rows + 1): |
| Bottom outer loop | for i in range(rows - 1, 0, -1): |
| Leading spaces | print(" " * (rows - i), end="") |
| Number loop | for k in range(1, 2 * i): |
| Print digit | print(k, end="") |
| End the row | print() |
| Program 43 contrast | Right-aligned triangle — not a centered diamond |
Compare
📋 Fixed vs User Input vs Compact Demo
Same centered number diamond — different ways to control height and trace the loops.
Top loop
i = 1..rowsGrowing half
Bottom loop
i = rows-1..1Mirrored half
Digits
range(1, 2*i)Odd-length rows
Compact
rows = 3Quick paper trace
Context
When This Pattern Shows Up
Reach for this pattern when teaching two-phase loops, odd-length sequences, and centered console output.
After Program 43
Natural follow-up — moves from a right-aligned triangle to a symmetric centered diamond with two outer loops.
Two-phase loop drills
Practice separating top and bottom halves before tackling hollow or alphabet diamonds.
Console I/O practice
Combine loops with
input()for flexible row counts.Gateway to variants
Compare Program 43 (right-aligned triangle) and Program 45 (next in series) 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 locks in two-phase loops, centering spaces, and O(n²) thinking.
Interactive
🔮 Live Preview
Choose a height between 3 and 5 and draw the centered number diamond in the browser.
Hands-On
Examples Gallery
Three complete Python programs — fixed rows, user input, and compact demo. Click View Output to reveal sample console results.
📚 Getting Started
Print a centered diamond with rows = 5 using space loops and ascending digit sequences.
Example 1 — Fixed rows = 5
Hard-coded row count — ideal for first demos and screenshots.
Python
rows = 5
# top half (1, 123, 12345, ...)
for i in range(1, rows + 1):
print(" " * (rows - i), end="")
for k in range(1, 2 * i):
print(k, end="")
print()
# bottom half (..., 12345, 123, 1)
for i in range(rows - 1, 0, -1):
print(" " * (rows - i), end="")
for k in range(1, 2 * i):
print(k, end="")
print()How It Works
When i = 1, four spaces center a single 1. When i = 3, two spaces precede 12345. The bottom half mirrors from i = 4 down to 1.
📈 User Input
Read the row count with input() instead of hard-coding 5.
Example 2 — User input rows
Read rows with input() and validate rows > 0.
Python
rows = int(input("Enter the number of rows: "))
if rows < 1:
raise ValueError("rows must be at least 1")
for i in range(1, rows + 1):
print(" " * (rows - i), end="")
for k in range(1, 2 * i):
print(k, end="")
print()
for i in range(rows - 1, 0, -1):
print(" " * (rows - i), end="")
for k in range(1, 2 * i):
print(k, end="")
print()How It Works
Same space-and-number loop core as Example 1; only rows comes from user input instead of being hard-coded as 5.
⚡ Smaller Demo
Run with rows = 3 to trace every row on paper before scaling up.
Example 3 — Compact rows = 3
Same space and number loops with a smaller row count for quick tracing.
Python
rows = 3
for i in range(1, rows + 1):
print(" " * (rows - i), end="")
for k in range(1, 2 * i):
print(k, end="")
print()
for i in range(rows - 1, 0, -1):
print(" " * (rows - i), end="")
for k in range(1, 2 * i):
print(k, end="")
print()How It Works
Only rows changes from 5 to 3 — the space and number loops stay identical. Trace i = 1, 2, 3 on paper to see how row length grows as 2*i-1.
🧠 How the Algorithm Prints Rows
1
Set up
No imports needed. Set rows = 5 and loop variables i, k.
Setup
2
Top half loop
for i in range(1, rows + 1): — builds the growing half of the diamond.
Top
3
Leading spaces
print(" " * (rows - i), end="") — centers each row before digits.
Align
4
Number loop
for k in range(1, 2 * i): then print(k, end="") — odd-length digit row.
Print
5
Bottom half loop
for i in range(rows - 1, 0, -1): — mirrors the top half back down.
Mirror
=
Diamond number pyramid complete
Total printed digits grow with diamond area — O(n²) time, O(1) extra memory.
Trace
🔎 Worked Walkthrough — top half rows = 5, row i = 3
Trace row 3 on the top half — spaces, digits printed, and full row output.
| Step | Detail | Output so far |
|---|---|---|
| Spaces | rows - i = 2 spaces | |
k = 1..5 | Prints 12345 | 12345 |
print() | End row 3 | 12345 |
Characters per row = 2*i-1. Space count on top half = rows - i. Bottom half repeats rows 4, 3, 2, 1 in reverse.
Use Cases
Where this tiny pattern (and its loop structure) shows up beyond the homework prompt.
1. Teaching Nested Loops
Clearest visual proof that outer and inner bounds interact.
Example: skip the space loop and watch the diamond snap left.
2. Pattern Series Base
Foundation for inverted, pyramid, diamond, and hollow variants.
Example: continue to Program 45 for the next pattern in the series.
3. Console Formatting Drills
Practice print(..., end="") vs print() without complex math.
Example: put print() inside the inner loop by mistake.
4. Padding character
Add spaces between digits once the two-loop structure works.
Example: use print(k, end=" ") between digits for wider spacing.
5. Complexity Intuition
Diamond totals make O(n²) concrete for beginners.
Example: count printed digits for rows = 5 — top half alone prints 25 digits.
6. Input Validation Labs
Pair the pattern with input() checks and positive-row checks.
Example: reject rows <= 0 and re-prompt.
Pro Tip: when an interviewer asks for patterns, explain the outer/inner roles first — then write the loops. The story matters as much as the code.
Advantages
Why this pattern earns a permanent spot in beginner Python courses.
1. Instant Visual Feedback
Wrong bounds show up immediately as a broken staircase.
2. Minimal Concepts
Only loops and console output — no arrays or math libraries.
3. Easy to Extend
Invert, center, hollow, or change the fill character with small edits.
4. O(1) Extra Memory
Streaming output needs no storage beyond loop counters.
Pro Tip: trace i, space count, and digit loop on paper for rows = 3 before coding — watch how row length grows as 2*i-1.
Usage Tips
Small habits that keep number-pattern code clean.
1. Two Outer Loops
Top half
1..rowsand bottom halfrows-1..1— do not repeat the peak row.2. Call
try/except ValueErrorUse
try/except ValueErrorso bad input does not crash when convertingrows.3. Keep print() Outside the Inner Loop
Only call
print()after the inner loop finishes the row.4. Trace Space Count on Paper
Mark
rows - ispaces before each row’s digits before coding.5. Dry-Run rows = 3
Trace
i = 1..3on paper before coding the fullrows = 5demo.
Pro Tip: if the output is a vertical list of single digits per line, you almost certainly put print() inside the inner loop.
Common Pitfalls
Mistakes that commonly break centered number diamond patterns.
1. Newline Inside the Inner Loop
Each digit lands on its own line — you get a column, not a diamond.
→ Use
print(k, end="");print()only after the number loop.2. Skipping the Space Loop
Without leading spaces, the diamond loses its centered shape.
→ Run the space loop before the number loop on every row.
3. Wrong Inner Bound
range(1, 2 * i + 1)adds an extra digit — row length becomes even instead of odd.→ Keep
for k in range(1, 2 * i):for exactly2*i-1digits.4. Repeating the Peak Row
Starting the bottom loop at
i = rowsprints the widest row twice.→ Bottom half starts at
i = rows - 1, notrows.5. Bare
int(input())Letters or empty input raise
ValueErrorwith bareint(input()).→ Catch
ValueErrorand re-prompt on failure.
Edge Cases
Check these inputs before calling the solution done.
rows = 1
Single row diamond
Output is just 1 — one row, no bottom half needed.
rows = 0
Empty pattern
Outer loop never runs — print nothing or show a message.
Negative
rows < 1
Treat as invalid; re-prompt instead of silent empty output.
rows = 2
Smallest diamond
Three rows: 1, 123, 1.
Bad input
Non-numeric input
Bare int(input()) raises ValueError on bad input — use try/except first.
Large rows
Large row count
Total lines = 2*rows - 1 — grows quadratically with peak height.
Drill
🎯 Practice Problems
Try these variations to lock in the pattern.
1. Right-aligned triangle
- Leading spaces with
rows - i - Review Program 43
2. Top half only
- Print only
i = 1..rowswithout the mirror - See how the growing half works alone
3. Next in series
- Continue with Program 45
- Next pattern in the number-pattern series
4. Descending digits
- Print
kfrom2*i-1down to1 - Same space loops, reversed number loop
Important
Notes
- Loop rule. Top
i = 1..rows, space loop thenk = 1..2*i-1. Bottom starts atrows - 1. print(..., end="")stays on the line;print()advances — mix them carefully.- Validate
rows > 0for interactive programs;rows = 1prints a single centered1. - Bottom half starts at
rows - 1— do not repeat the peak row ati = rows.
Quick Takeaway: top loop i = 1..rows, space loop then digits k = 1..2*i-1, bottom i = rows-1..1, then print().
Analysis
⏱️ Time and Space Complexity
| Program | Time | Extra space |
|---|---|---|
| Nested loops (Examples 1–3) | O(n²) | O(1) |
| Smaller demo (Example 3) | O(n²) | O(1) |
🎉 Conclusion
The centered number diamond is a compact lesson in symmetric patterns and centering spaces: print leading spaces, print digits 1 to 2*i-1, grow rows in the top half, then mirror back down. Master the fixed-rows version, then try user input and a smaller trace demo.
Practice the three examples above, then continue to Program 45 for the next pattern in the series.
Bottom half must start at rows - 1 — validate rows when reading from the console.
Pro Tips
💡 Best Practices
✅ Do
- Use top loop
for i in range(1, rows + 1): - Bottom loop
for i in range(rows - 1, 0, -1): - Spaces then digits:
print(k, end="")fork = 1..2*i-1 - Wrap
int(input())intry/except ValueError - State O(n²) time when asked about complexity
❌ Don’t
- Call
print()inside the inner loop - Start bottom loop at
i = rows(repeats peak row) - Use
range(1, 2 * i + 1)instead ofrange(1, 2 * i) - Skip the space loop (breaks centering)
- Ignore bad console input in user-facing demos
- Skip the
rows = 1edge case
Summary
Key Takeaways
Knowledge Unlocked
Five things to remember about this number diamond
Print the pattern the beginner-friendly way.
5
Core concepts 01
2*i-1
Digits per row
Definition 02
Two halves
Top + mirror
Code 03
Row width
2*i-1 digits
Code 04
Bottom start
i = rows-1
Shape 05
Complexity
O(n²) time
Analysis❓ Frequently Asked Questions
A centered diamond of ascending digit sequences: 1, 123, 12345, 1234567, 123456789, then mirrors back down to 1.
The row prints 2*i-1 digits (odd length): 1, 3, 5, 7, 9, ... using range(1, 2*i).
Leading spaces are printed before the numbers. Top half uses print(" " * (rows - i), end=""); bottom half uses the same spacing formula.
The first loop builds the top half (i = 1..rows). The second mirrors back down (i = rows-1..1) to complete the diamond.
Program 43 is a right-aligned triangle with spaced columns. Program 44 is a symmetric centered diamond with odd-length digit rows.
Replace 5 with a rows variable in both outer loops and space bounds — see Example 2.
O(n²) for n rows because each level prints O(n) digits and there are O(n) levels.
Use try/except ValueError around int(input()) and validate rows > 0 before printing.
Only one row prints — a single centered 1.
Did you Know? 🔊
This pattern prints a top half (1..rows) and a bottom half (rows-1..1). Each row prints 2*i-1 digits (1 to 2*i-1) with leading spaces to center the diamond.
Continue to Program 45
Move on to the next pattern in the Python number-pattern series.
About the author
12 people found this page helpful