Perfect Square Spiral Pattern in PHP

Q: Why is it called a perfect square spiral?

It fills an n×n (perfect square) grid with numbers 1..n² in a clockwise spiral path, starting at the top-left and moving inward layer by layer.

Q: How do low and high work?

They mark the current layer's top/bottom row and left/right column. After filling four edges, increment $low and decrement $high to shrink the active rectangle.

Q: Why does the right-edge loop start at low + 1?

The top row already wrote the top-right corner at ($low, $high). Starting at $low + 1 avoids writing that cell twice.

Q: Can I change 10×10 to any n×n?

Yes. Allocate an n×n array and run (n + 1) / 2 layers (or ceil(n/2)). The same four edge loops work for any positive n — see Example 2.

Q: What is the time complexity?

O(n²) — every cell is assigned exactly once, so work grows with the number of cells.

Q: Can the spiral run counter-clockwise?

Yes. Reorder the four edge fills (for example left, bottom, right, top) and adjust loop bounds so corners are not duplicated.

Q: What happens when n is odd?

The innermost layer is a single cell. The last loops still work; one iteration may fill only the center (for example n=5 → center is 25).

Q: How should I read n safely?

Use trim(fgets(STDIN)) and is_numeric($input), then validate (int)$input > 0.

Beginner

⏱️ 10 min read

📚 Updated: Aug 2026

🎯 3 Code Examples

🚀 Live Preview

2D Array + Boundaries

Perfect square spiral output (10Ã—10 spiral matrix from 1 to 100) in PHP

Overview

What You’ll Learn

Program 62 generates a perfect square spiral: fill an $n×$n grid with numbers 1..n² clockwise, layer by layer, using a 2D array and shrinking boundaries. This tutorial covers the spiral fill order, boundary variables, a live preview, worked PHP examples, edge cases, and O(n²) complexity.

Shape Rule

Spiral matrix

Numbers flow clockwise around each border ring — 1..10 on the outer ring of a 10×10 grid, then inward to 100 at the center.

2D Array

2D array grid

$a = array_fill(0, $n, array_fill(0, $n, 0)) stores each cell before printing with fixed-width formatting.

Boundaries

low / high

$low and $high mark the current square ring — increment/decrement after each layer to move inward.

Four Sides

Top, right, bottom, left

Each layer fills top row, right column, bottom row, left column — incrementing counter $n each cell.

Live Preview

3–12 size

Pick grid size and draw the spiral matrix in the browser.

O(n²)

Complexity

Every cell visited once — 10×10 = 100 cells, hence O(n²) time and space.

Introduction

A perfect square spiral (spiral matrix) fills an $n×$n grid with consecutive integers flowing clockwise around shrinking border rings. With $n = 10, you get a 10×10 grid numbered 1 through 100.

In PHP allocate $a = array_fill(0, 10, array_fill(0, 10, 0)), walk each layer with $low/$high boundaries, fill four sides per ring, then print with printf("%4d", ...) fixed-width formatting.

Why it matters?

Spiral-matrix logic appears in interviews, grid simulations, and image processing — it bridges simple loops to 2D array reasoning.

Key Highlights

2D array

$a = array_fill(0, $n, array_fill(0, $n, 0)) stores the grid.

Boundaries

$low/$high track each ring.

vs Program 61

Program 61 works on one number; Program 62 fills a 2D grid.

Series Finale

Last number pattern — continue to PHP Star Patterns next.

In short: allocate $a = array_fill(0, $n, array_fill(0, $n, 0)), fill four sides per layer with shrinking boundaries, print with printf("%4d", ...).

Foundation

📝 Problem & Approach

Given grid size $n = 10, fill an $n×$n array with numbers 1..n² in a clockwise spiral starting from the top-left corner.

PHP

// $n = 4 (compact sample)
// 1   2   3   4
//12  13  14   5
//11  16  15   6
//10   9   8   7

Inputs & Outputs

Item	Type	Description
`$n`	int	Grid dimension — 10 in the fixed demo (10×10 = 100 cells).
`$a[$i][$j]`	2D array	2D array storing each cell value.
`$low, $high`	int	Current layer boundaries — start 0 and nâˆ’1, move inward each ring.
Fill counter	int	Starts at 1, increments for every cell placed.
Layers	int	`n/2` rings for even n — 5 layers when n = 10.
Print format	string	`printf("%4d", $value)` fixed width keeps columns aligned.

Minimal workflow

Pseudocode

create nÃ—n array
set low=0, high=n-1, val=1
while low <= high:
    fill top row left→right
    fill right column top→bottom
    fill bottom row right→left
    fill left column bottom→top
    low++, high--
print array with fixed width

Approach comparison

Approach	Idea	Best for
low / high rings	Outer loop over layers, four inner loops per side	Fixed 10×10 demo (Example 1)
top/bottom/left/right	While loop shrinks all four boundaries	Configurable size (Example 2)
Compact trace	`n = 4` on paper first	Quick dry-runs
Direction array	Simulate walk with dx/dy turns	Alternative interview solution
Wider print width	`{0, 5}` or more when n² > 9999	Large grids

Cheat Sheet

⚡ Quick Reference

Goal	Pattern
Allocate	`$a = array_fill(0, $n, array_fill(0, $n, 0));`
Layer loop	`for ($layer = 0; $layer < ($n+1)/2; $layer++, $low++, $high--)`
Fill order	Top row → right col → bottom row → left col
Print cell	`printf("%4d", $a[$i][$j]);`

Compare

📋 Fixed 10Ã—10 vs User Input vs Compact 4Ã—4

Same spiral matrix — three ways to set grid size and trace the fill logic.

Fixed 10Ã—10

$n = 10

Hard-coded with low/high rings

User input

top/bottom/left/right

Configurable n from console

Compact trace

n = 4

Quick dry-run on paper

Sides

4 per layer

Top, right, bottom, left

printf("%4d")

Fixed-width columns

Context

When This Pattern Shows Up

Reach for this pattern when teaching 2D arrays, boundary control, and O(n²) grid algorithms in PHP.

Post Program 61 capstone
Natural finale for the number-pattern series — graduate from 1D loops to 2D spiral filling.
Interview preparation
Classic spiral-matrix question — explain boundary shrinking before coding.
2D array drills
Index reasoning with $a[$row][$col] and nested loop bounds.
Gateway to Star Patterns
Continue to C star-pattern programs after mastering this grid exercise.
Large n caution
Very large grids produce huge console output — cap n for demos.

Key benefit: one program that locks in 2D arrays, boundary control, and O(n²) grid thinking.

Interactive

🔮 Live Preview

Enter grid size between 3 and 8 and draw the perfect square spiral matrix in the browser.

ï»¿

Hands-On

Examples Gallery

Three complete PHP programs — fixed 10×10, fgets(STDIN) size input, and a refactored fill_spiral helper with print_matrix. Click View Output to reveal sample console results.

Example 1 — Fixed 10×10 Spiral

Hard-coded $n = 10 — four edge loops per layer with $low and $high.

PHP

<?php
$n = 10;
$a = array_fill(0, $n, array_fill(0, $n, 0));
$low = 0;
$high = $n - 1;
$val = 1;

for ($layer = 0; $layer < (int)(($n + 1) / 2); $layer++, $low++, $high--) {
    for ($j = $low; $j <= $high; $j++, $val++) $a[$low][$j] = $val;
    for ($i = $low + 1; $i <= $high; $i++, $val++) $a[$i][$high] = $val;
    for ($j = $high - 1; $j >= $low; $j--, $val++) $a[$high][$j] = $val;
    for ($i = $high - 1; $i > $low; $i--, $val++) $a[$i][$low] = $val;
}

echo "Perfect Square Spiral" . PHP_EOL;
for ($i = 0; $i < $n; $i++) {
    for ($j = 0; $j < $n; $j++)
        printf("%4d", $a[$i][$j]);
    echo PHP_EOL;
}

Example 2 — User Input Size

Read $n from the user and fill an $n×$n spiral matrix.

PHP

<?php
echo "Enter matrix size n: ";
$input = trim(fgets(STDIN));
if (!is_numeric($input) || (int) $input <= 0) {
    echo "Please enter a positive integer." . PHP_EOL;
    exit(1);
}
$n = (int) $input;

$a = array_fill(0, $n, array_fill(0, $n, 0));
$low = 0;
$high = $n - 1;
$val = 1;
for ($layer = 0; $layer < (int)(($n + 1) / 2); $layer++, $low++, $high--) {
    for ($j = $low; $j <= $high; $j++, $val++) $a[$low][$j] = $val;
    for ($i = $low + 1; $i <= $high; $i++, $val++) $a[$i][$high] = $val;
    for ($j = $high - 1; $j >= $low; $j--, $val++) $a[$high][$j] = $val;
    for ($i = $high - 1; $i > $low; $i--, $val++) $a[$i][$low] = $val;
}

for ($i = 0; $i < $n; $i++) {
    for ($j = 0; $j < $n; $j++)
        printf("%4d", $a[$i][$j]);
    echo PHP_EOL;
}

Example 3 — fill_spiral Helper

Refactor layer logic into fill_spiral and print with print_matrix.

PHP

<?php
function fill_spiral(&$a, $n) {
    $low = 0;
    $high = $n - 1;
    $val = 1;
    for ($layer = 0; $layer < (int)(($n + 1) / 2); $layer++, $low++, $high--) {
        for ($j = $low; $j <= $high; $j++, $val++) $a[$low][$j] = $val;
        for ($i = $low + 1; $i <= $high; $i++, $val++) $a[$i][$high] = $val;
        for ($j = $high - 1; $j >= $low; $j--, $val++) $a[$high][$j] = $val;
        for ($i = $high - 1; $i > $low; $i--, $val++) $a[$i][$low] = $val;
    }
}

function print_matrix($a, $n) {
    for ($i = 0; $i < $n; $i++) {
        for ($j = 0; $j < $n; $j++)
            printf("%4d", $a[$i][$j]);
        echo PHP_EOL;
    }
}

$n = 10;
$a = array_fill(0, $n, array_fill(0, $n, 0));
fill_spiral($a, $n);
print_matrix($a, $n);

🧠 How the Algorithm Fills the Spiral

Create 2D array

$a = array_fill(0, $n, array_fill(0, $n, 0)) holds all spiral values before printing.

Setup

Set boundaries

$low = 0, $high = $n - 1 (or top/bottom/left/right) mark the current ring.

Boundaries

Fill four sides

Top row, right column, bottom row, left column — incrementing counter each cell.

Spiral

Print with fixed width

printf("%4d", $a[$i][$j]) keeps columns aligned.

Output

Perfect square spiral complete

n² cells filled and printed — O(n²) time and space.

Trace

🔎 Worked Walkthrough — first layer of `n = 4`

Trace the first (outer) ring of a 4×4 spiral — values 1 through 12 on the border, then inner 2×2 fills 13—16.

Side	Cells filled	Values placed
Top row	`(0,0)..(0,3)`	`1, 2, 3, 4`
Right column	`(1,3)..(3,3)`	`5, 6, 7`
Bottom row	`(3,2)..(3,0)`	`8, 9, 10`
Left column	`(2,0)..(1,0)`	`11, 12`
Inner 2×2	Second layer	`13, 14, 15, 16`

For $n = 10, repeat this four-side pattern for 5 concentric rings until the center cell holds 100.

Use Cases

Where spiral-matrix filling shows up beyond the homework prompt.

1. Teaching 2D Arrays

$a = array_fill(0, $n, array_fill(0, $n, 0)) with row/column indexing — a visual grid exercise for beginners.

Example: trace which cells get values 1—4 on the outer ring of a 4×4 grid.

2. Interview Prep

Classic spiral-matrix question — explain boundary shrinking before coding.

Example: walk through top → right → bottom → left for one layer.

3. Series Capstone

Final number-pattern program — graduates from 1D loops to 2D boundary control.

Example: compare Program 61’s while loop with nested spiral loops here.

4. Gateway to Star Patterns

After mastering grids, move to C star-pattern programs for shape-based output.

Example: continue to PHP Star Patterns next.

5. O(n²) Intuition

Every cell visited once — concrete quadratic complexity for grid algorithms.

Example: 10×10 = 100 cells filled and printed.

6. Grid Simulations

Spiral traversal appears in image processing, maze generation, and game maps.

Example: adapt the fill order to visit cells in spiral order without storing all values.

Pro Tip: dry-run a 4×4 grid on paper before attempting 10×10 — the four-side pattern repeats per layer.

Advantages

Why spiral-matrix exercises belong in every beginner C course.

1. Visual 2D Reasoning
Students see numbers flow around the grid — wrong boundary logic shows up immediately.
2. Nested Loop Practice
Four inner loops per layer reinforce index bounds and loop direction (forward/backward).
3. Interview-Ready Pattern
Spiral matrix is a standard coding question — this tutorial maps directly to it.
4. Scales to Any n
Same boundary approach works for odd and even sizes — only print width may need adjustment.

Pro Tip: trace the first layer of n = 4 on paper — values 1—12 on the border before the inner 2×2 fills 13—16.

Usage Tips

Small habits that keep spiral-matrix code clean.

1. Fill Four Sides in Order
Top → right → bottom → left — skipping or reordering breaks the spiral.
2. Skip Corner Overlap
Start right column at $low + 1, bottom row at $high - 1 — corners are already filled.
3. Use Fixed Print Width
printf("%4d", $value) keeps columns aligned for $n up to 10×10.
4. Guard Inner Sides
When using top/bottom/left/right, check top <= bottom before bottom and left fills.
5. Start with n = 4
Dry-run a 4×4 grid on paper before coding the 10×10 demo.

Pro Tip: if numbers jump or repeat, check whether a side loop includes an already-filled corner cell.

Common Pitfalls

Mistakes that commonly break spiral-matrix programs.

1. Double-Filling Corners
Starting every side at the same corner overwrites cells — spiral breaks at turns.
→ Skip the first cell on right, bottom, and left sides after the top row.
2. Wrong Layer Count
Running too many or too few outer iterations leaves cells empty or overwritten.
→ Use n/2 layers for even n — 5 rings when n = 10.
3. Missing Boundary Guards
On odd n or the last layer, bottom/left fills may run when boundaries crossed.
→ Wrap bottom and left fills with if (top <= bottom) checks.
4. Misaligned Output
Printing without fixed width makes large numbers shift columns.
→ Use printf("%4d", ...) or wider when $n² exceeds 9999.
5. Row/Column Confusion
Swapping $a[$i][$j] indices fills transposed or scrambled output.
→ Top row uses fixed row i, varying column j.

Edge Cases

Check these inputs before calling the solution done.

n = 1

Single cell

Grid holds only value 1 — one layer, one print.

n = 2

Smallest ring

Four cells in one layer — good minimal test case.

n = 3

Odd size

Center cell 9 filled in the innermost layer — verify boundary guards.

n = 0

Invalid size

Reject with a message — do not allocate a zero-length array.

Bad input

Non-numeric fgets(STDIN)

Unchecked fgets(STDIN) leaves $n unset — check with is_numeric($input).

Large n

Huge console output

Cap n for demos — O(n²) cells means O(n²) print lines.

Drill

🎯 Practice Problems

Try these variations to lock in the spiral pattern.

1. Compare with Program 61

Program 61 uses 1D while loop
Program 62 fills a 2D grid with boundaries

2. Counter-clockwise spiral

Reverse fill order: left, bottom, right, top
Same boundaries, opposite direction

3. Continue to Star Patterns

Next: PHP Star Patterns
Shape-based output after number grids

4. Paper trace

Dry-run n = 4 before coding 10×10
Fill the walkthrough table by hand

Important

Notes

Cell count. An n×n grid holds n² values — 100 cells when n = 10.
Each layer shrinks boundaries by 1 on all sides — $low++ and $high-- after four sides.
The while-loop variant (top/bottom/left/right) generalizes to any positive n without hard-coding layer count.
This is the final program in the PHP number-pattern series — star patterns come next.

Quick Takeaway: allocate $a = array_fill(0, $n, array_fill(0, $n, 0)), fill four sides per layer, tighten boundaries, print with printf("%4d", ...).

Analysis

⏱️ Time and Space Complexity

Program	Time	Extra space
Fixed 10×10 (Example 1)	`O(n²)` — n = 10, 100 cells	`O(n²)` for the array
User input (Example 2)	`O(n²)`	`O(n²)`
Compact 4×4 (Example 3)	`O(n²)` — n = 4, 16 cells	`O(n²)`

Wrap Up

🎉 Conclusion

The perfect square spiral is a capstone 2D-array exercise: boundary control, four-side fills, and O(n²) grid thinking. Master the fixed 10×10 version, then try user input with configurable n and the compact 4×4 trace.

Practice the three examples above, then continue to PHP Star Patterns — the next chapter after number patterns.

Fill top → right → bottom → left per layer, tighten boundaries, print with fixed width — validate n when reading from the console.

View Examples Gallery Continue to Star Patterns

Pro Tips

💡 Best Practices

✅ Do

Explain four-side fill order before coding
Skip corner overlap on right, bottom, left sides
Use printf("%4d", ...) for aligned columns
Guard bottom/left fills with boundary checks
Dry-run n = 4 on paper first
State O(n²) time when asked about complexity

❌ Don’t

Double-fill corner cells on adjacent sides
Swap row and column indices in $a[$i][$j]
Run too many outer layer iterations
Allocate array when n <= 0
Skip the n = 4 dry-run before 10×10

Summary

Key Takeaways

Knowledge Unlocked

Five things to remember about this spiral pattern

Print the perfect square spiral the beginner-friendly way.

Core concepts

△ 01

Rule

Fill clockwise per layer

Definition

[,] 02

2D Array

2D array stores grid

Structure

4 03

Sides

Top, right, bottom, left

Order

↔ 04

Boundaries

/ shrink inward

Control

O 05

Complexity

O(n²) time & space

Analysis

❓ Frequently Asked Questions

Why is it called a perfect square spiral?

It fills an n×n (perfect square) grid with numbers 1..n² in a clockwise spiral path, starting at the top-left and moving inward layer by layer.

How do low and high work?

They mark the current layer's top/bottom row and left/right column. After filling four edges, increment $low and decrement $high to shrink the active rectangle.

Why does the right-edge loop start at low + 1?

The top row already wrote the top-right corner at ($low, $high). Starting at $low + 1 avoids writing that cell twice.

Can I change 10×10 to any n×n?

Yes. Allocate an n×n array and run (n + 1) / 2 layers (or ceil(n/2)). The same four edge loops work for any positive n — see Example 2.

What is the time complexity?

O(n²) — every cell is assigned exactly once, so work grows with the number of cells.

Can the spiral run counter-clockwise?

Yes. Reorder the four edge fills (for example left, bottom, right, top) and adjust loop bounds so corners are not duplicated.

What happens when n is odd?

The innermost layer is a single cell. The last loops still work; one iteration may fill only the center (for example n=5 → center is 25).

How should I read n safely?

Use trim(fgets(STDIN)) and is_numeric($input), then validate (int)$input > 0.

Did you Know? 🔊

Fills n×n matrix in spiral order using $low/$high boundaries — top, right, bottom, left edges per layer. O(n²) time and space.

Continue to PHP Star Patterns

Number patterns complete — move on to star-shaped output programs.

PHP Star Patterns →

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 61 — Progressive Reverse-Build Number Pattern PHP Star Pattern Programs

Perfect Square Spiral Pattern in PHP

What You’ll Learn

Shape Rule

2D Array

Boundaries

Four Sides

Live Preview

O(n²)

Introduction

Why it matters?

2D array

Boundaries

vs Program 61

Series Finale

📝 Problem & Approach

Inputs & Outputs

Minimal workflow

Approach comparison

⚡ Quick Reference

📋 Fixed 10Ã—10 vs User Input vs Compact 4Ã—4

When This Pattern Shows Up

Post Program 61 capstone

Interview preparation

2D array drills

Gateway to Star Patterns

Large n caution

🔮 Live Preview

Examples Gallery

Example 1 — Fixed 10×10 Spiral

Example 2 — User Input Size

Example 3 — fill_spiral Helper

🧠 How the Algorithm Fills the Spiral

Create 2D array

Set boundaries

Fill four sides

Print with fixed width

Perfect square spiral complete

🔎 Worked Walkthrough — first layer of n = 4

Use Cases

1. Teaching 2D Arrays

2. Interview Prep

3. Series Capstone

4. Gateway to Star Patterns

5. O(n²) Intuition

6. Grid Simulations

Advantages

1. Visual 2D Reasoning

2. Nested Loop Practice

3. Interview-Ready Pattern

4. Scales to Any n

Usage Tips

1. Fill Four Sides in Order

2. Skip Corner Overlap

3. Use Fixed Print Width

4. Guard Inner Sides

5. Start with n = 4

Common Pitfalls

1. Double-Filling Corners

2. Wrong Layer Count

3. Missing Boundary Guards

4. Misaligned Output

5. Row/Column Confusion

Edge Cases

Single cell

Smallest ring

Odd size

Invalid size

Non-numeric fgets(STDIN)

Huge console output

🎯 Practice Problems

1. Compare with Program 61

2. Counter-clockwise spiral

3. Continue to Star Patterns

4. Paper trace

Notes

⏱️ Time and Space Complexity

🎉 Conclusion

💡 Best Practices

✅ Do

❌ Don’t

🔎 Worked Walkthrough — first layer of `n = 4`