Centered Number Diamond Pattern in PHP

Q: Why does each row print 1, 3, 5, … digits?

The inner loop runs $k from 1 to 2*$i-1. As $i grows, the count becomes 1, 3, 5, 7, and so on.

Q: How is the diamond centered?

Before printing digits, the program prints $rows-$i leading spaces. Smaller rows get more spaces, so the diamond stays centered.

Q: How is the bottom half generated?

After the top half ($i=1..$rows), a second outer loop runs $i from $rows-1 down to 1 with the same space and digit logic.

Q: Why does the widest row print 123456789 for $rows=5?

On row $i=5, $k runs while $k < 2*$i, so $k goes 1..9 — nine concatenated digits.

Q: Can I add spaces between digits?

Yes. Print $k . " " inside the digit loop — see Example 3. You may need to adjust indentation.

Q: What is the time complexity?

O(n²) for n rows because total printed digits grow with the diamond width across both halves.

Q: How should I read the size safely?

Use trim(fgets(STDIN)) and is_numeric($input) before casting to int.

Q: What happens if $rows is 1?

You get a single centered row with just the digit 1.

Beginner

⏱️ 8 min read

📚 Updated: Aug 2026

🎯 3 Code Examples

🚀 Live Preview

Nested Loops + Mirror

Centered number diamond output in PHP (1, 123, 12345, … then mirrored down)

Overview

What You’ll Learn

The centered number diamond prints 1, then 123, then 12345, and so on — then mirrors back down to 1. This tutorial covers the top and bottom halves, digit loops, live preview, algorithm steps, worked PHP examples, edge cases, and complexity.

Shape Rule

Odd-width rows

Row i prints digits 1..(2*$i-1) concatenated; leading spaces center each row.

Space Loop

Center rows

for ($j = $i; $j < $rows; $j++) prints leading spaces before digits.

Digit Loop

1..2*$i-1

echo $k for $k = 1..2*$i-1 — concatenated digits per row.

Mirror Loop

Bottom half

for ($i = $rows - 1; $i >= 1; $i--) repeats the same row logic downward.

Live Preview

1–20 rows

Pick a row count and draw the centered number diamond instantly in the browser.

O(n²)

Complexity

Prints odd-width rows mirrored across n rows — n² iterations; extra memory stays O(1).

Introduction

A centered number diamond prints 1, then 123, then 12345, up to the widest row, then mirrors back down. With $rows = 5, the middle line is 123456789.

In PHP you use a top-half loop ($i = 1..$rows), leading spaces, and a digit loop ($k = 1..2*$i-1), then a bottom-half loop mirrors the same logic with $i = $rows-1..1.

Why it matters?

It combines centering spaces with a mirrored second loop — the classic two-triangle diamond pattern.

Key Highlights

Top + Bottom Halves

Grow with $i = 1..$rows, then mirror with $i = $rows-1..1.

Leading Spaces

$rows - $i spaces center each row in the diamond.

Concatenated Digits

Each row prints 1, 123, 12345, … without separators.

Series Foundation

Follow Program 43 right-aligned triangle; continue to Program 45 star cross pattern.

In short: top half grows odd-width digit rows with leading spaces; bottom half mirrors the same logic; call echo PHP_EOL after each row.

Foundation

📝 Problem & Approach

Given a positive integer $rows (e.g. 5), print a centered number diamond: odd-width digit rows grow to the middle, then mirror downward.

PHP

// $rows = 5 (conceptual shape)
//     1
//    123
//   12345
//  1234567
// 123456789
//  1234567
//   12345
//    123
//     1

Inputs & Outputs

Item	Type	Description
`$rows`	int	Height of the top half (and widest row index).
Printed output	text	Centered diamond of concatenated digits; `2*$rows - 1` total lines.

Minimal workflow

Pseudocode

for $i from 1 to $rows (top half):
    print ($rows - $i) spaces
    for $k from 1 to 2*$i-1: print $k
    print newline
for $i from $rows-1 down to 1 (bottom half):
    print ($rows - $i) spaces
    for $k from 1 to 2*$i-1: print $k
    print newline

Approach comparison

Approach	Idea	Best for
Top + bottom halves	Leading spaces, then digits `1..2*$i-1`	Learning and interviews
User-input size	`(int) $input;`	Flexible console programs
Spaced-digit diamond	Print `k + " "` between digits	More readable output

Cheat Sheet

⚡ Quick Reference

Goal	Pattern
Space loop	`for ($j = $i; $j < $rows; $j++)` (top) or `$j = $rows; $j > $i; $j--` (bottom)
Top half	`for ($i = 1; $i <= $rows; $i++)`
Bottom half mirror	`for ($i = $rows - 1; $i >= 1; $i--)`
Digit loop	`for ($k = 1; $k < $i * 2; $k++)` + `echo $k`
End the row	`echo PHP_EOL;`
Program 43 contrast	Right-aligned triangle grows one way; this pattern mirrors rows after the widest line

Compare

📋 Top Half vs Bottom Half vs Combined

Same diamond row — how centering spaces and concatenated digits work together.

Top half

$i = 1..$rows

Growing half — widest row at $i = $rows

Bottom half

$i = $rows-1..1

Mirrors top half after the middle row

Digit loop

$k = 1..2*$i-1

Prints 1, 123, 12345, … concatenated

Learning tip

trace i=3

Dry-run row 3: two spaces then 12345

Context

When This Pattern Shows Up

Reach for this pattern when teaching symmetry — two mirrored loop halves with centering spaces.

First lab exercise
Classic follow-up after right-aligned triangles and pyramids.
Nested-loop warm-up
Outer/inner bound practice with an immediate visual check.
Console I/O practice
Combine loops with fgets(STDIN) for a flexible row count.
Gateway to variants
Compare with Program 43 (right-aligned triangle), then continue to Program 45 (star cross).
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 nested loops, output sequencing, and O(n²) thinking.

Interactive

🔮 Live Preview

Choose a row count between 1 and 20 and draw the centered number diamond in the browser.

Hands-On

Examples Gallery

Three complete PHP programs — fixed row count, fgets(STDIN) input, and a spaced-digit variant. Click View Output to reveal sample console results.

📚 Getting Started

Print a full diamond with top and bottom loop pairs.

Example 1 — Fixed `$rows = 5`

Hard-coded size — top half grows, bottom half mirrors each row.

PHP

<?php
$rows = 5;

for ($i = 1; $i <= $rows; $i++) {
    for ($j = $i; $j < $rows; $j++) {
        echo " ";
    }
    for ($k = 1; $k < $i * 2; $k++) {
        echo $k;
    }
    echo PHP_EOL;
}

for ($i = $rows - 1; $i >= 1; $i--) {
    for ($j = $rows; $j > $i; $j--) {
        echo " ";
    }
    for ($k = 1; $k < $i * 2; $k++) {
        echo $k;
    }
    echo PHP_EOL;
}

How It Works

When $i = 1, four leading spaces precede a single 1. When $i = 3, two spaces precede 12345 — odd-width rows build the diamond shape.

📈 Practical Variant

Let the user choose the height at runtime.

Example 2 — User Input Version

Read the row count with trim(fgets(STDIN)) (check is_numeric($input) in real apps).

PHP

<?php
echo "Enter the number of rows: ";
$input = trim(fgets(STDIN));
if (!is_numeric($input)) {
    echo "Invalid input." . PHP_EOL;
    exit(1);
}
$rows = (int) $input;

for ($i = 1; $i <= $rows; $i++) {
    for ($j = $i; $j < $rows; $j++) {
        echo " ";
    }
    for ($k = 1; $k < $i * 2; $k++) {
        echo $k;
    }
    echo PHP_EOL;
}

for ($i = $rows - 1; $i >= 1; $i--) {
    for ($j = $rows; $j > $i; $j--) {
        echo " ";
    }
    for ($k = 1; $k < $i * 2; $k++) {
        echo $k;
    }
    echo PHP_EOL;
}

How It Works

Same nested-loop core as Example 1; only the source of $rows changes. Non-numeric input fails is_numeric($input) — validate before casting to int for safer labs.

⚡ Readability Variant

Add spaces between digits for a more readable diamond.

Example 3 — Spaced-Digit Diamond

Print a space after each digit for a more readable centered diamond.

PHP

<?php
$rows = 3;

for ($i = 1; $i <= $rows; $i++) {
    for ($j = $i; $j < $rows; $j++) {
        echo " ";
    }
    for ($k = 1; $k < $i * 2; $k++) {
        echo $k . " ";
    }
    echo PHP_EOL;
}

for ($i = $rows - 1; $i >= 1; $i--) {
    for ($j = $rows; $j > $i; $j--) {
        echo " ";
    }
    for ($k = 1; $k < $i * 2; $k++) {
        echo $k . " ";
    }
    echo PHP_EOL;
}

How It Works

Same two-loop structure; echo $k . " " adds spacing between digits and wider indent pairs keep centering.

🧠 How the Algorithm Prints Rows

Set up

echo is built in; use fgets(STDIN) when reading input. Set $rows (fixed or from input).

Setup

Outer loop (rows)

for ($i = 1; $i <= $rows; $i++) — walks the growing top half of the diamond.

Row

Space loop (center)

for ($j = $i; $j < $rows; $j++) prints leading spaces before digits.

Spaces

Bottom half (mirror)

for ($i = $rows - 1; $i >= 1; $i--) repeats the same row logic downward.

Mirror

Centered number diamond complete

Total digits printed grow on the order of n² — O(n²) time, O(1) extra memory.

Trace

🔎 Worked Walkthrough — `$rows = 5`, top-half row `$i = 3`

Trace one growing row before the mirror loop runs.

Step	Loop	Prints
Spaces	`$j = 3, 4` (2 times)
Digits	`$k = 1..5`	`12345`

Row output: 12345 — full diamond has 2*$rows - 1 lines when the bottom half mirrors the top.

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 bottom half and get a pyramid instead of a diamond.

2. Pattern Series Base

Foundation for number diamonds, centered pyramids, and mirrored patterns.

Example: swap digits for stars to build a star diamond variant.

3. Console Formatting Drills

Practice echo vs row newline without complex math.

Example: put echo PHP_EOL inside the inner loop by mistake.

4. Character Substitution

Swap digits for letters, stars, or spaced output once the loop works.

Example: print 1, 12, 123 without spaces between digits.

5. Complexity Intuition

Triangular totals make O(n²) concrete for beginners.

Example: count output lines for n = 5 → 9 (2*5-1).

6. Input Validation Labs

Pair the pattern with fgets(STDIN) 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 PHP courses.

1. Instant Visual Feedback
Wrong loop bounds show up immediately as a lopsided or off-center diamond.
2. Minimal Concepts
Only loops and console output — no arrays or math libraries.
3. Easy to Extend
Invert, center, left-align, or swap digits for stars with small edits.
4. O(1) Extra Memory
Streaming output needs no storage beyond loop counters.

Pro Tip: learn the two-loop diamond first; then try the spaced-digit variant in Example 3.

Usage Tips

Small habits that keep number-pattern code clean.

1. Name Bounds Clearly
Use $rows (or n) and keep i/j for row/column — or rename to row/col.
2. Prefer fgets(STDIN)
Avoid crashes when the user types letters instead of a number.
3. Keep echo PHP_EOL Outside
Only call echo PHP_EOL after the inner loop finishes the row.
4. Use Ternary for Compact Code
One-liner for spaces: echo " ".repeat($rows - $i)); before the digit loop.
5. Dry-Run One Small n
Trace $rows = 3 on paper before coding larger demos.

Pro Tip: if the output is a vertical list of digits per line, you almost certainly put echo PHP_EOL inside the inner loop.

Common Pitfalls

Mistakes that commonly break centered number diamonds.

1. echo PHP_EOL Inside the Inner Loop
Each digit lands on its own line — you get a column, not a diamond.
→ Use echo for spaces and numbers; echo PHP_EOL only after both inner loops.
2. Forgetting the Bottom Half
Printing only the top loop gives a pyramid, not a full diamond.
→ Add for ($i = $rows - 1; $i >= 1; $i--) after the top-half loop.
3. Forgetting the Row Break
Omitting echo PHP_EOL glues every row onto one endless line.
→ Always end the row after the inner loop.
4. Unchecked fgets(STDIN) input
Letters or empty input leave $rows unset.
→ Use is_numeric($input) and re-prompt on failure.
5. Wrong Digit Bound
Using k <= i instead of k < $i * 2 prints too few digits per row.
→ Keep for ($k = 1; $k < $i * 2; $k++) for odd-width rows 1, 3, 5, …

Edge Cases

Check these inputs before calling the solution done.

$rows = 1

Single row

Output is one centered 1 on a single line.

$rows = 0

Empty pattern

Outer loop never runs — print nothing or show a message.

Negative

`$rows < 0`

Treat as invalid; re-prompt instead of silent empty output.

Large n

Many rows

Output grows as odd-width rows mirrored plus spaces — fine for labs, noisy for huge n.

Bad input

Non-numeric fgets(STDIN) input

Unchecked fgets(STDIN) leaves $rows unset — call is_numeric($input) first.

Fill char

Spaced-digit diamond

Print k + " " between digits — see Example 3.

Drill

🎯 Practice Problems

Try these variations to lock in the pattern.

1. Star cross pattern

X shape with a middle column of stars
Continue with Program 45

2. Palindromic row diamond

Print 1 2 3 2 1 on each row instead of 12345
Keep the same centering spaces

3. Alphabet diamond

Replace digits with letters A, B, C, …
Same top and bottom loop structure

4. Spaced digits

Use echo $k . " " like Example 3
Widen indent pairs to " " when needed

Important

Notes

Digit count. Widest row prints 2*$rows-1 digits; the full diamond has 2*$rows-1 lines.
echo stays on the line; echo PHP_EOL advances — mix them carefully.
Validate $rows > 0 for interactive programs; $rows = 1 should print one indented 1.
Use echo $k to concatenate digits; add spaces in Example 3 when readability matters.

Quick Takeaway: top half grows odd-width rows, bottom half mirrors, leading spaces center each line, then break the row.

Analysis

⏱️ Time and Space Complexity

Program	Time	Extra space
Nested loops (Examples 1–2)	`O(rows²)`	`O(1)`
Spaced-digit diamond (Example 3)	`O(rows²)`	`O(1)`

Wrap Up

🎉 Conclusion

The centered number diamond combines nested loops with a simple mirror pattern — a natural step after right-aligned triangles. Master the fixed-$rows version first, then try user input and the spaced-digit diamond.

Practice the three examples above, then continue to Program 45 for the star cross pattern with 0s.

Every row prints 2*$i-1 digits — keep echo PHP_EOL only after both inner loops finish.

View Examples Gallery Continue to Program 45

Pro Tips

💡 Best Practices

✅ Do

Explain top half, bottom mirror, and digit loop before coding
Use echo $k and echo PHP_EOL after each row
Validate $rows ≥ 1 for interactive programs
Check fgets(STDIN) return value before using $rows
State O(n²) time when asked about complexity

❌ Don’t

Call echo PHP_EOL inside the inner digit loop
Skip the bottom half (you get a pyramid, not a diamond)
Use k <= i instead of k < $i * 2
Ignore bad console input in user-facing demos
Skip the $rows = 1 edge case

Summary

Key Takeaways

Knowledge Unlocked

Five things to remember about this centered number diamond

Print the pattern the beginner-friendly way.

Core concepts

△ 01

Rule

Row i prints 1..2*$i-1

Definition

↻ 02

Top half

2*$i-1 digits

Code

↓ 03

Bottom half

Mirror i down

Logic

n 04

Total lines

2*$rows - 1

I/O

O 05

Complexity

O(n²) time

Analysis

❓ Frequently Asked Questions

Why does each row print 1, 3, 5, … digits?

The inner loop runs $k from 1 to 2*$i-1. As $i grows, the count becomes 1, 3, 5, 7, and so on.

How is the diamond centered?

Before printing digits, the program prints $rows-$i leading spaces. Smaller rows get more spaces, so the diamond stays centered.

How is the bottom half generated?

After the top half ($i=1..$rows), a second outer loop runs $i from $rows-1 down to 1 with the same space and digit logic.

Why does the widest row print 123456789 for $rows=5?

On row $i=5, $k runs while $k < 2*$i, so $k goes 1..9 — nine concatenated digits.

Can I add spaces between digits?

Yes. Print $k . " " inside the digit loop — see Example 3. You may need to adjust indentation.

What is the time complexity?

O(n²) for n rows because total printed digits grow with the diamond width across both halves.

How should I read the size safely?

Use trim(fgets(STDIN)) and is_numeric($input) before casting to int.

What happens if $rows is 1?

You get a single centered row with just the digit 1.

Did you Know? 🔊

Each row prints digits 1..(2*$i-1) concatenated without spaces. Leading spaces center the shape; a second loop mirrors the top half downward.

Continue to Program 45

Move on to the star cross pattern with 0s in the PHP number-pattern series.

Program 45 tutorial →

About the author

Mari Selvan M P 🔗

Developer, cloud engineer, and technical writer

Experience 12 years building web and cloud systems
Focus Full Stack Development, AWS, and Developer Education

I write practical tutorials so students and working developers can learn by doing—from databases and APIs to deployment on AWS.

AWS Certified Developer – Associate (Credly)

12 people found this page helpful

PHP Number Pattern 43 — Right-Aligned Increasing Triangle PHP Number Pattern 45 — Star Cross Pattern with 0s

Centered Number Diamond Pattern in PHP

What You’ll Learn

Shape Rule

Space Loop

Digit Loop

Mirror Loop

Live Preview

O(n²)

Introduction

Why it matters?

Top + Bottom Halves

Leading Spaces

Concatenated Digits

Series Foundation

📝 Problem & Approach

Inputs & Outputs

Minimal workflow

Approach comparison

⚡ Quick Reference

📋 Top Half vs Bottom Half vs Combined

When This Pattern Shows Up

First lab exercise

Nested-loop warm-up

Console I/O practice

Gateway to variants

Not a UI layout tool

🔮 Live Preview

Examples Gallery

📚 Getting Started

Example 1 — Fixed $rows = 5

How It Works

📈 Practical Variant

Example 2 — User Input Version

How It Works

⚡ Readability Variant

Example 3 — Spaced-Digit Diamond

How It Works

🧠 How the Algorithm Prints Rows

Set up

Outer loop (rows)

Space loop (center)

Bottom half (mirror)

Centered number diamond complete

🔎 Worked Walkthrough — $rows = 5, top-half row $i = 3

Use Cases

1. Teaching Nested Loops

2. Pattern Series Base

3. Console Formatting Drills

4. Character Substitution

5. Complexity Intuition

6. Input Validation Labs

Advantages

1. Instant Visual Feedback

2. Minimal Concepts

3. Easy to Extend

4. O(1) Extra Memory

Usage Tips

1. Name Bounds Clearly

2. Prefer fgets(STDIN)

3. Keep echo PHP_EOL Outside

4. Use Ternary for Compact Code

5. Dry-Run One Small n

Common Pitfalls

1. echo PHP_EOL Inside the Inner Loop

2. Forgetting the Bottom Half

3. Forgetting the Row Break

4. Unchecked fgets(STDIN) input

5. Wrong Digit Bound

Edge Cases

Single row

Empty pattern

$rows < 0

Many rows

Non-numeric fgets(STDIN) input

Spaced-digit diamond

🎯 Practice Problems

1. Star cross pattern

2. Palindromic row diamond

3. Alphabet diamond

4. Spaced digits

Example 1 — Fixed `$rows = 5`

🔎 Worked Walkthrough — `$rows = 5`, top-half row `$i = 3`

2. Prefer `fgets(STDIN)`

`$rows < 0`