Number-Star Diamond Pattern in PHP

Q: Why does each row have 2*i-1 characters?

The inner loop runs while $j < $i*2, which prints 1, 3, 5, 7, 9 characters for $i = 1..5.

Q: How does the program alternate numbers and *?

It checks $j % 2. Even $j prints '*', odd $j prints the current row number $i.

Q: Why are there two outer loops?

The first loop builds the top half ($i = 1..$n). The second mirrors back down ($i = $n-1..1) to complete the diamond.

Q: What is the difference from Program 30?

Program 30 is a right-aligned descending triangle. Program 31 alternates digits and stars in a symmetric diamond shape.

Q: How do I generalize for any height?

Replace 5 with $n in both outer loops — see Example 2.

Q: What is the time complexity?

O(n²) for n rows because total printed characters grow quadratically across both halves.

Q: How should I read n safely?

Use trim(fgets(STDIN)) and check is_numeric($input) before casting to int — see Example 2 notes.

Q: What happens when n is 1?

Only one row prints — a single 1.

Q: Can I use a ternary operator?

Yes — echo ($j % 2 == 0) ? "*" : $i compacts the if/else logic in PHP.

Beginner

⏱️ 9 min read

📚 Updated: Aug 2026

🎯 3 Code Examples

🚀 Live Preview

Modulo Operator

Number-star diamond output (1, 2*2, 3*3*3 ... 5*5*5*5*5 and back to 1) in PHP programming

Overview

What You’ll Learn

The number-star diamond prints 1, 2*2, 3*3*3, … 5*5*5*5*5, then mirrors back down — a natural step after the right-aligned triangle in Program 30. This tutorial covers two outer loops, modulus alternation, a live preview, worked PHP examples, edge cases, and complexity.

Shape Rule

Diamond halves

Top half grows 1..n; bottom half mirrors n-1..1.

Top Loop

$i = 1..$n

for ($i = 1; $i <= $n; $i++) — builds the growing half of the diamond.

Bottom Loop

$i = $n-1..1

for ($i = $n - 1; $i >= 1; $i--) — mirrors the top half back down.

Modulo (j % 2)

Alternate fill

Odd $j prints $i; even $j prints *.

Live Preview

Height 3–7

Pick a height and draw the number-star diamond in the browser.

O(n²)

Complexity

Each row prints 2*$i-1 chars — total work scales as n².

Introduction

A number-star diamond pattern alternates the row number and * on each line, growing to a peak then mirroring back down. With $n = 5, you get 1, 2*2, … 5*5*5*5*5, then the same rows in reverse.

In PHP you use two outer loops (top and bottom halves) and $j % 2 inside the inner loop to alternate digit and star.

Why it matters?

It combines symmetric diamond logic with the modulus operator — a step up from Program 30’s single-loop triangle.

Key Highlights

2*i-1 chars

Inner loop runs $j < $i*2.

j % 2

Odd prints $i, even prints *.

Two halves

Top 1..n, bottom n-1..1.

Series Foundation

Follow Program 30; continue to Program 32 (triangle from 11) next.

In short: top loop $i = 1..$n, bottom loop $i = $n-1..1, inner $j % 2 alternates digit and star, then echo PHP_EOL.

Foundation

📝 Problem & Approach

Given $n = 5, print a number-star diamond: top half $i = 1..$n, bottom half $i = $n-1..1, each row alternating digit $i and * via $j % 2.

PHP

// $n = 5 (conceptual shape)
// 1
// 2*2
// 3*3*3
// 4*4*4*4
// 5*5*5*5*5
// 4*4*4*4
// 3*3*3
// 2*2
// 1

Inputs & Outputs

Item	Type	Description
`$n`	int	Diamond peak height — total lines = `2*n - 1`.
`$i`	int	Outer loop — current row number printed on odd positions.
`$j`	int	Inner loop — `$j % 2 == 0` prints `*`, else prints `$i`.

Minimal workflow

Pseudocode

for i from 1 to n:
    for j from 1 to i*2 - 1:
        if j % 2 == 0: print *
        else: print i
    print newline
for i from n-1 down to 1:
    for j from 1 to i*2 - 1:
        if j % 2 == 0: print *
        else: print i
    print newline

Approach comparison

Approach	Idea	Best for
if/else	`1`, `22`, `33*3`, …	Learning and interviews
Ternary operator	`echo ($j % 2 == 0) ? "*" : $i`	Compact console programs
User-input n	`(int) trim(fgets(STDIN));`	Flexible diamond height

Cheat Sheet

⚡ Quick Reference

Goal	Pattern
Top half	`for ($i = 1; $i <= $n; $i++)`
Bottom half	`for ($i = $n - 1; $i >= 1; $i--)`
Inner loop	`for ($j = 1; $j < $i * 2; $j++)`
Alternate fill	`if ($j % 2 == 0) echo "*"; else echo $i;`
Ternary form	`echo ($j % 2 == 0) ? "*" : $i;`
User input	`(int) trim(fgets(STDIN));`

Compare

📋 if/else vs Ternary vs User Input

Same number-star diamond — different ways to write the modulus check and control height.

Top half

$i = 1..$n

Growing rows to the peak

Bottom half

$i = $n-1..1

Mirror back down

Modulo

$j%2==0 ? * : $i

Alternate star and digit

Learning tip

2*$i-1

Characters per row

Context

When This Pattern Shows Up

Reach for this pattern when teaching symmetric diamonds, the modulus operator, and two-phase loop structures.

Post triangle exercise
Natural follow-up after Program 30 — introduces modulus and a mirrored bottom half.
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 Program 30 (right-aligned triangle) and Program 32 (triangle from 11) 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 nested loops, output sequencing, and O(n²) thinking.

Interactive

🔮 Live Preview

Choose a height between 3 and 7 and draw the number-star diamond in the browser.

Hands-On

Examples Gallery

Three complete PHP programs — fixed height, user input with ternary form, and a smaller trace demo. Click View Output to reveal sample console results.

📚 Getting Started

Print a full diamond with $n = 5 using if/else and $j % 2.

Example 1 — Fixed `$n = 5`

Hard-coded row count — ideal for first demos and screenshots.

PHP

<?php
for ($i = 1; $i <= 5; $i++) {
    for ($j = 1; $j < $i * 2; $j++) {
        if ($j % 2 == 0) {
            echo "*";
        } else {
            echo $i;
        }
    }
    echo PHP_EOL;
}

for ($i = 4; $i >= 1; $i--) {
    for ($j = 1; $j < $i * 2; $j++) {
        if ($j % 2 == 0) {
            echo "*";
        } else {
            echo $i;
        }
    }
    echo PHP_EOL;
}

How It Works

When $i = 1, the inner loop prints one character — 1. When $i = 3, it prints 3*3*3 (five characters). The bottom half mirrors from $i = 4 down to 1.

📈 User Input

Read the diamond height with fgets(STDIN) instead of hard-coding 5.

Example 2 — User Input

Read $n with (int) trim(fgets(STDIN)) to control diamond height.

PHP

<?php
echo "Enter n: ";
$n = (int) trim(fgets(STDIN));
if ($n < 1) return;

for ($i = 1; $i <= $n; $i++) {
    for ($j = 1; $j < $i * 2; $j++) {
        echo ($j % 2 == 0) ? "*" : $i;
    }
    echo PHP_EOL;
}

for ($i = $n - 1; $i >= 1; $i--) {
    for ($j = 1; $j < $i * 2; $j++) {
        echo ($j % 2 == 0) ? "*" : $i;
    }
    echo PHP_EOL;
}

How It Works

Same diamond core as Example 1; a ternary operator replaces if/else and $n replaces hard-coded 5. Non-numeric input leaves $n unset if you skip is_numeric() checks — always check it in safer labs.

⚡ Smaller Demo

Run with $n = 3 to trace every row on paper before scaling up.

Example 3 — Compact `$n = 3`

Same if/else logic with a smaller row count for quick tracing.

PHP

<?php
$n = 3;

for ($i = 1; $i <= $n; $i++) {
    for ($j = 1; $j < $i * 2; $j++) {
        if ($j % 2 == 0) {
            echo "*";
        } else {
            echo $i;
        }
    }
    echo PHP_EOL;
}

for ($i = $n - 1; $i >= 1; $i--) {
    for ($j = 1; $j < $i * 2; $j++) {
        if ($j % 2 == 0) {
            echo "*";
        } else {
            echo $i;
        }
    }
    echo PHP_EOL;
}

How It Works

Only $n changes from 5 to 3 — the if/else and two-loop structure stay identical. Trace $i = 1, 2, 3 on paper to see how row length grows as 2*$i-1.

🧠 How the Algorithm Prints Rows

Set up

Set $n = 5; and use fgets(STDIN) when reading input. Set loop variables $i, $j.

Setup

Top half

for ($i = 1; $i <= $n; $i++) — growing rows from 1 to the peak.

Top

Inner loop (j)

for ($j = 1; $j < $i * 2; $j++) — prints 2*$i-1 characters per row.

Width

Modulo alternation

$j % 2 == 0 prints *; odd $j prints $i.

Fill

Bottom half

for ($i = $n - 1; $i >= 1; $i--) — mirrors the top half back down.

Mirror

Number-star diamond complete

2*n-1 total rows — O(n²) time, O(1) extra memory.

Trace

🔎 Worked Walkthrough — top half `$n = 5`

Trace each outer-loop value of $i, inner-loop range, character count, and full row output.

`$i`	Inner range (`$j`)	Chars	Row output
`1`	1	1	`1`
`2`	1, 2, 3	3	`2*2`
`3`	1..5	5	`333`
`4`	1..7	7	`444*4`
`5`	1..9	9	`55555`

Characters per row = 2*$i-1. 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: flip $j % 2 logic and watch stars land on wrong positions.

2. Pattern Series Base

Foundation for inverted, pyramid, diamond, and hollow variants.

Example: continue to Program 32 for a triangle starting from 11.

3. Console Formatting Drills

Practice echo vs echo PHP_EOL without complex math.

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

4. Padding character

Add spaces between digits once the two-loop structure works.

Example: use echo $i . " " between digits for wider spacing.

5. Complexity Intuition

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

Example: count printed characters for $n = 5 — top half alone prints 25 chars.

6. Input Validation Labs

Pair the pattern with fgets(STDIN) return checks and positive-row checks.

Example: reject max <= 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 C 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 and $j on paper for $n = 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..n and bottom half n-1..1 — do not repeat the peak row.
2. Prefer trim(fgets(STDIN))
Call is_numeric(trim($line)) so bad input does not leave $n uninitialized.
3. Keep echo PHP_EOL Outside
Only call echo PHP_EOL after the inner loop finishes the row.
4. Trace j % 2 on Paper
Mark odd/even positions for each row before coding the alternation.
5. Dry-Run n = 3
Trace $i = 1..3 on paper before coding the full $n = 5 demo.

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

Common Pitfalls

Mistakes that commonly break number-star diamond patterns.

1. Newline Inside the Inner Loop
Each digit lands on its own line — you get a column, not a triangle.
→ Use echo $i or echo "*"; echo PHP_EOL only after the inner loop.
2. Flipping Modulo Logic
Using $j % 2 != 0 for stars (instead of == 0) swaps digit and star positions.
→ Even $j prints *; odd $j prints $i.
3. Wrong Inner Bound
$j <= $i * 2 adds an extra character — row length becomes even instead of odd.
→ Keep for ($j = 1; $j < $i * 2; $j++) for exactly 2*$i-1 chars.
4. Repeating the Peak Row
Starting the bottom loop at $i = $n prints the widest row twice.
→ Bottom half starts at $i = $n - 1, not $n.
5. Unchecked CLI input
Letters or empty input leave $n uninitialized.
→ Call is_numeric(trim($line)) and re-prompt on failure.

Edge Cases

Check these inputs before calling the solution done.

n = 1

Single row diamond

Output is just 1 — one row, no bottom half needed.

n = 0

Empty pattern

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

Negative

`$n < 0`

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

n = 2

Smallest diamond

Three rows: 1, 2*2, 1.

Bad input

Non-numeric CLI input

Unchecked CLI input leaves $n unset — call is_numeric() first.

Large rows

Large row count

Total lines = 2*n - 1 — grows quadratically with peak height.

Drill

🎯 Practice Problems

Try these variations to lock in the pattern.

1. Right-aligned triangle

Leading spaces with $j > $i
Review Program 30

2. Top half only

Print only $i = 1..$n without the mirror
See how the growing half works alone

3. Triangle from 11

Continue with Program 32
Formula-based increasing triangle

4. Swap fill character

Replace * with # or .
Same $j % 2 logic, different symbol

Important

Notes

Modulo rule. Odd $j prints $i; even $j prints *. Inner loop runs $j < $i*2.
echo.print stays on the line; echo PHP_EOL advances — mix them carefully.
Validate $n > 0 for interactive programs; $n = 1 prints a single 1.
Bottom half starts at $n - 1 — do not repeat the peak row at $i = $n.

Quick Takeaway: top loop $i = 1..$n, bottom $i = $n-1..1, inner $j % 2 alternates digit and star, then echo PHP_EOL.

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)`

Wrap Up

🎉 Conclusion

The number-star diamond is a compact lesson in symmetric patterns and the modulus operator: alternate $i and * with $j % 2, grow rows in the top half, then mirror back down. Master the fixed-$n version, then try user input and a smaller trace demo.

Practice the three examples above, then continue to Program 32 for the increasing number triangle starting from 11.

Bottom half must start at $n - 1 — validate $n when reading from the console.

View Examples Gallery Continue to Program 32

Pro Tips

💡 Best Practices

✅ Do

Use top loop for ($i = 1; $i <= $n; $i++)
Bottom loop for ($i = $n - 1; $i >= 1; $i--)
Inner: $j % 2 == 0 prints *, else prints $i
Call is_numeric(trim($line)) before using $n
State O(n²) time when asked about complexity

❌ Don’t

Call echo PHP_EOL inside the inner loop
Start bottom loop at $i = $n (repeats peak row)
Use $j <= $i * 2 instead of $j < $i * 2
Flip the modulo condition
Ignore bad console input in user-facing demos
Skip the $n = 1 edge case

Summary

Key Takeaways

Knowledge Unlocked

Five things to remember about this number-star diamond

Print the pattern the beginner-friendly way.

Core concepts

△ 01

Rule

j%2: * or i

Definition

↻ 02

Two halves

Top + mirror

Code

% 03

Row width

2*i-1 chars

Code

↓ 04

Bottom start

$i = $n-1

Shape

O 05

Complexity

O(n²) time

Analysis

❓ Frequently Asked Questions

Why does each row have 2*i-1 characters?

The inner loop runs while $j < $i*2, which prints 1, 3, 5, 7, 9 characters for $i = 1..5.

How does the program alternate numbers and *?

It checks $j % 2. Even $j prints '*', odd $j prints the current row number $i.

Why are there two outer loops?

The first loop builds the top half ($i = 1..$n). The second mirrors back down ($i = $n-1..1) to complete the diamond.

What is the difference from Program 30?

Program 30 is a right-aligned descending triangle. Program 31 alternates digits and stars in a symmetric diamond shape.

How do I generalize for any height?

Replace 5 with $n in both outer loops — see Example 2.

What is the time complexity?

O(n²) for n rows because total printed characters grow quadratically across both halves.

How should I read n safely?

Use trim(fgets(STDIN)) and check is_numeric($input) before casting to int — see Example 2 notes.

What happens when n is 1?

Only one row prints — a single 1.

Can I use a ternary operator?

Yes — echo ($j % 2 == 0) ? "*" : $i compacts the if/else logic in PHP.

Did you Know? 🔊

This pattern prints a top half (1..$n) and a bottom half ($n-1..1). Each row prints 2*$i-1 characters, alternating the row number and * using $j % 2.

Continue to Program 32

Move on to the increasing number triangle starting from 11 in the PHP number-pattern series.

Program 32 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 30 — Right-Aligned Descending Triangle PHP Number Pattern 32 — Increasing Triangle from 11

Number-Star Diamond Pattern in PHP

What You’ll Learn

Shape Rule

Top Loop

Bottom Loop

Modulo (j % 2)

Live Preview

O(n²)

Introduction

Why it matters?

2*i-1 chars

j % 2

Two halves

Series Foundation

📝 Problem & Approach

Inputs & Outputs

Minimal workflow

Approach comparison

⚡ Quick Reference

📋 if/else vs Ternary vs User Input

When This Pattern Shows Up

Post triangle 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 $n = 5

How It Works

📈 User Input

Example 2 — User Input

How It Works

⚡ Smaller Demo

Example 3 — Compact $n = 3

How It Works

🧠 How the Algorithm Prints Rows

Set up

Top half

Inner loop (j)

Modulo alternation

Bottom half

Number-star diamond complete

🔎 Worked Walkthrough — top half $n = 5

Use Cases

1. Teaching Nested Loops

2. Pattern Series Base

3. Console Formatting Drills

4. Padding character

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. Two Outer Loops

2. Prefer trim(fgets(STDIN))

3. Keep echo PHP_EOL Outside

4. Trace j % 2 on Paper

5. Dry-Run n = 3

Common Pitfalls

1. Newline Inside the Inner Loop

2. Flipping Modulo Logic

3. Wrong Inner Bound

4. Repeating the Peak Row

5. Unchecked CLI input

Edge Cases

Single row diamond

Empty pattern

$n < 0

Smallest diamond

Non-numeric CLI input

Large row count

🎯 Practice Problems

1. Right-aligned triangle

2. Top half only

3. Triangle from 11

Example 1 — Fixed `$n = 5`

Example 3 — Compact `$n = 3`

🔎 Worked Walkthrough — top half `$n = 5`

2. Prefer `trim(fgets(STDIN))`

`$n < 0`