Concentric Number Square Pattern in PHP

Beginner

⏱️ 8 min read

📚 Updated: Aug 2026

🎯 3 Code Examples

🚀 Live Preview

Nested Loops + max($i,$j)

Concentric number square pattern in PHP (5 5 5 … down to 5 4 3 2 1 2 3 4 5)

Overview

What You’ll Learn

The concentric number square prints symmetric rows where each value comes from max($i, $j). The left half walks $j = $k..1 and the right half mirrors $j = 2..$k. This tutorial covers the rule, nested loops, live preview, algorithm steps, worked PHP examples, edge cases, and complexity.

Shape Rule

max($i,$j)

Print j when $j > $i; otherwise print i — equivalent to max($i, $j).

Left Half Loop

$j = $k..1

for ($j = $k; $j >= 1; $j--) builds the decreasing left side of each row.

Right Half Loop

$j = 2..$k

for ($j = 2; $j <= $k; $j++) mirrors the left half without duplicating the center.

Outer Loop

$i = $k..1

for ($i = $k; $i >= 1; $i--) — each row gets closer to the center value.

Live Preview

$k = 3–10

Pick a value for $k and draw the concentric number square instantly in the browser.

O(k²)

Complexity

Prints k rows with about 2*$k-1 values each — O(k²) total prints; memory stays O(1).

Introduction

A concentric number square pattern prints symmetric rows of numbers that decrease toward the center. With $k = 5, the last row becomes 5 4 3 2 1 2 3 4 5.

In PHP you loop $i = $k..1, then for each row print max($i, $j) over the left half ($j = $k..1) and right half ($j = 2..$k).

Why it matters?

It teaches a reusable grid rule — once you spot max($i,$j), the nested loops become straightforward.

Key Highlights

max($i,$j) Rule

Each cell prints the larger of the row index and column value.

Left Half

$j = $k..1 produces the decreasing left segment.

Right Mirror

$j = 2..$k mirrors without repeating the center.

Series Foundation

Follow Program 45 star cross; continue to Program 47 concentric diamond.

In short: loop $i = $k..1, print max($i,$j) for left and right halves, then echo PHP_EOL after each row.

Foundation

📝 Problem & Approach

Given $k = 5, print $k symmetric rows where each value equals max($i, $j) over mirrored column loops.

PHP

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

Inputs & Outputs

Item	Type	Description
`$k`	int	Maximum value and row count (typically ≥ 1).
Printed output	text	`$k` rows, each with `2*$k-1` space-separated numbers.

Minimal workflow

Pseudocode

for $i from $k down to 1:
    for $j from $k down to 1:
        print max($i, $j)
    for $j from 2 to $k:
        print max($i, $j)
    print newline

Approach comparison

Approach	Idea	Best for
if-else max rule	`$j > $i ? $j : $i` in both halves	Learning and interviews
User-input k	`(int) $input;`	Flexible console programs
max compact	`max($i,$j)` in both loops	Cleaner production-style code

Cheat Sheet

⚡ Quick Reference

Goal	Pattern
Walk rows	`for ($i = $k; $i >= 1; $i--)`
Left half	`for ($j = $k; $j >= 1; $j--)`
Right half	`for ($j = 2; $j <= $k; $j++)`
Value rule	`$j > $i ? $j : $i` or `max($i, $j)`
End the row	`echo PHP_EOL;`
Program 45 contrast	Star cross uses symbol conditions; this pattern uses max($i,$j) over mirrored number loops

Compare

📋 Left Half vs Right Half vs Combined

Same row cell — how max($i,$j) picks the printed number.

Left half

$j = $k..1

Decreasing column walk — prints larger edge values first

Right half

$j = 2..$k

Mirrors the left segment without duplicating the center

Value rule

max($i,$j)

Print $j when $j > $i; otherwise print $i

Learning tip

trace $i=3,$j=2

Dry-run cell (3,2): max(3,2) → prints 3

Context

When This Pattern Shows Up

Reach for this pattern when teaching max($i,$j) inside mirrored column loops.

First lab exercise
Classic follow-up after concentric squares and diamonds.
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 45 (star cross), then continue to Program 47 (concentric diamond).
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(k²) thinking.

Interactive

🔮 Live Preview

Choose a value for $k and draw the concentric number square in the browser.

Hands-On

Examples Gallery

Three complete PHP programs — fixed $k, fgets(STDIN) input, and a max compact variant. Click View Output to reveal sample console results.

📚 Getting Started

Print five rows with mirrored inner loops and the max($i,$j) rule.

Example 1 — Fixed `$k = 5`

Hard-coded size — left half $j=$k..1, right half $j=2..$k, max rule in each cell.

PHP

<?php
$k = 5;

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

How It Works

When $i = 3, $j = 2 on the left half, $j > $i is false — so the cell prints 3. When $i = 1 on the last row, the center column prints 1.

📈 Practical Variant

Let the user choose $k at runtime.

Example 2 — User Input Version

Read $k with trim(fgets(STDIN)) (check is_numeric($input) in real apps).

PHP

<?php
echo "Enter k (e.g., 5): ";
$input = trim(fgets(STDIN));
if (!is_numeric($input)) {
    echo "Invalid input." . PHP_EOL;
    exit(1);
}
$k = (int) $input;

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

How It Works

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

⚡ Readability Variant

Replace the if-else with max($i, $j) for cleaner code.

Example 3 — max Compact

Use max($i, $j) in both inner loops — same output, less branching.

PHP

<?php
$k = 5;

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

How It Works

max($i, $j) expresses the same rule as $j > $i ? $j : $i — easier to read once you know the pattern math.

🧠 How the Algorithm Prints Rows

Set up

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

Setup

Outer loop (rows)

for ($i = $k; $i >= 1; $i--) — each row gets closer to the center value.

Row

Left half loop

for ($j = $k; $j >= 1; $j--) prints the decreasing left segment of each row.

Left

Inner loop + if

Both halves print max($i,$j) with a trailing space, then echo PHP_EOL ends the row.

Cells

Concentric number square pattern complete

Total cell visits equal k×(2*$k-1) — O(k²) time, O(1) extra memory.

Trace

🔎 Worked Walkthrough — row `$i = 3`, left `$j = 2`

Trace one left-half cell to see the max($i,$j) rule in action.

Check	Result	Prints
`$j > $i` (2>3)	false	print `$i` = 3
Equivalent	`max(3,2)`	`3`
Row context	$i=3, $k=5	middle row of five

Cell output: 3 — full row has 2*$k-1 = 9 values when $k=5.

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: use max($i,$j) instead of if-else — see Example 3.

2. Pattern Series Base

Foundation for concentric layouts, symmetric grids, and distance-based rules.

Example: swap max for min(i,j) to explore a different shape.

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 numbers for letters or stars once the max rule works.

Example: print row numbers with leading spaces for alignment.

5. Complexity Intuition

Grid totals make O(k²) concrete for beginners.

Example: count values for $k=5 → 5 rows × 9 values = 45 prints.

6. Input Validation Labs

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

Example: reject k <= 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 mirror bounds (starting right half at 1) duplicate the center value.
2. Minimal Concepts
Only loops and console output — no arrays or math libraries.
3. Easy to Extend
Change k, swap max for min, or mirror rows below for a full square.
4. O(1) Extra Memory
Streaming output needs no storage beyond loop counters.

Pro Tip: learn the three-condition grid first; then try the max compact in Example 3.

Usage Tips

Small habits that keep number-pattern code clean.

1. Name Bounds Clearly
Use $k for the outer bound 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
Compact: echo max($i, $j) . " "; in both inner loops inside the inner loop.
5. Dry-Run One Small n
Trace $k = 3 on paper before coding larger demos.

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

Common Pitfalls

Mistakes that commonly break concentric number square patterns.

1. echo PHP_EOL Inside the Inner Loop
Each number lands on its own line — you get a column, not a symmetric row.
→ Use echo for each value; echo PHP_EOL only after both inner loops finish.
2. Wrong Right-Half Start
Starting the right loop at $j = 1 prints the center twice on every row.
→ Keep for ($j = 2; $j <= $k; $j++) so the center appears once.
3. Forgetting the Row Break
Omitting echo PHP_EOL glues every row onto one endless line.
→ Always end the row after both inner loops complete.
4. Unchecked fgets(STDIN) input
Letters or empty input leave $k unset.
→ Use is_numeric($input) and re-prompt on failure.
5. Hard-coding 5 everywhere
Using literal 5 in loop bounds instead of variable $k breaks dynamic input.
→ Use one $k variable for the outer bound and both inner loops.

Edge Cases

Check these inputs before calling the solution done.

$k = 1

Single row

Output is one row of 2*$k-1 numbers; for k=1 you get a single 1.

$k = 0

Empty pattern

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

Negative

`k < 0`

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

Large n

Large k

Output grows with k rows and 2*$k-1 values per row — fine for labs, noisy for huge k.

Bad input

Non-numeric fgets(STDIN) input

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

Compact

max form

Use max($i,$j) for cleaner code — see Example 3.

Drill

🎯 Practice Problems

Try these variations to lock in the pattern.

1. Change k

Try $k = 3, 4, or 6
Count 2*$k-1 values per row

2. Use min instead of max

Replace max with min(i,j) for a different shape
Compare output side by side

3. Trim trailing spaces

Build each row with StringBuilder
Trim the final space before printing

4. Next in series

Continue with Program 47 full concentric diamond
Mirror rows below the center

Important

Notes

Value count. Total numbers printed ≈ k×(2*$k-1) (e.g. 5×9 = 45 for $k=5).
echo stays on the line; echo PHP_EOL advances — mix them carefully.
Validate $k > 0 for interactive programs; $k = 1 prints one value.
Right half must start at $j = 2 so the center value is not duplicated.

Quick Takeaway: set $k, loop $i = $k..1, print max($i,$j) for left and right halves, then break the row.

Analysis

⏱️ Time and Space Complexity

Program	Time	Extra space
Nested loops (Examples 1–2)	`O(k²)`	`O(1)`
max compact (Example 3)	`O(k²)`	`O(1)`

Wrap Up

🎉 Conclusion

The concentric number square pattern combines nested loops with a simple grid fill pattern — a natural step after concentric layouts. Master the fixed-$k version first, then try user input and the max compact form in Example 3.

Practice the three examples above, then continue to Program 47 for the concentric number diamond pattern.

Every cell uses print — keep echo PHP_EOL only after the inner column loop finishes.

View Examples Gallery Continue to Program 47

Pro Tips

💡 Best Practices

✅ Do

Explain main diagonal, anti-diagonal, and left + right halves before coding
Use print(max($i,$j) + " ") and echo PHP_EOL after both inner loops
Validate $k ≥ 1 for interactive programs
Check fgets(STDIN) return value before using $k
State O(k²) time when asked about complexity

❌ Don’t

Call echo PHP_EOL between left and right halves (mid-row break)
Start the right half at $j = 1 (duplicates center)
Hard-code 5 instead of variable $k
Ignore bad console input in user-facing demos
Skip the $k = 1 edge case

Summary

Key Takeaways

Knowledge Unlocked

Five things to remember about this concentric number square pattern

Print the pattern the beginner-friendly way.

Core concepts

△ 01

Rule

Each cell prints max($i,$j)

Definition

↻ 02

Left half

$j = $k..1

Code

↓ 03

Right half

$j = 2..$k

Logic

n 04

Values per row

2*$k-1

I/O

O 05

Complexity

O(k²)

Analysis

❓ Frequently Asked Questions

Why does each row start and end with 5?

Because $k=5 is the maximum. On any row $i, column values near the edges use $j when $j>$i, so the outer columns stay at $k.

How are values chosen inside the loops?

For row $i and column $j, the program prints $j when $j>$i; otherwise $i. That is equivalent to max($i, $j).

Why does the last row become 5 4 3 2 1 2 3 4 5?

When $i=1, every $j>1 prints $j, but $j=1 prints 1 at the center — creating the full symmetric sequence.

Can I change 5 to any n?

Yes. Replace $k=5 with any positive integer. You get $k rows and 2*$k-1 values per row.

Is this a full concentric square?

This tutorial prints the top $k rows (concentric-style). A full square often mirrors rows below the center too — see Program 47.

Can I use max() instead of if-else?

Yes. echo max($i, $j) . " " works — see Example 3.

What is the time complexity?

O($k²) because $k rows each print about 2*$k-1 values.

How should I read $k safely?

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

Did you Know? 🔊

Each cell prints max($i, $j) — the left half loops $j = $k..1, the right half mirrors with $j = 2..$k. The smallest value appears at the center of the last row.

Continue to Program 47

Move on to the concentric number diamond pattern in the PHP number-pattern series.

Program 47 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 45 — Star Cross Pattern with 0s PHP Number Pattern 47 — Concentric Number Diamond

Concentric Number Square Pattern in PHP

What You’ll Learn

Shape Rule

Left Half Loop

Right Half Loop

Outer Loop

Live Preview

O(k²)

Introduction

Why it matters?

max($i,$j) Rule

Left Half

Right Mirror

Series Foundation

📝 Problem & Approach

Inputs & Outputs

Minimal workflow

Approach comparison

⚡ Quick Reference

📋 Left Half vs Right 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 $k = 5

How It Works

📈 Practical Variant

Example 2 — User Input Version

How It Works

⚡ Readability Variant

Example 3 — max Compact

How It Works

🧠 How the Algorithm Prints Rows

Set up

Outer loop (rows)

Left half loop

Inner loop + if

Concentric number square pattern complete

🔎 Worked Walkthrough — row $i = 3, left $j = 2

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. Wrong Right-Half Start

3. Forgetting the Row Break

4. Unchecked fgets(STDIN) input

5. Hard-coding 5 everywhere

Edge Cases

Single row

Empty pattern

k < 0

Large k

Non-numeric fgets(STDIN) input

max form

🎯 Practice Problems

1. Change k

2. Use min instead of max

3. Trim trailing spaces

4. Next in series

Example 1 — Fixed `$k = 5`

🔎 Worked Walkthrough — row `$i = 3`, left `$j = 2`

2. Prefer `fgets(STDIN)`

`k < 0`