Hollow Square Border Pattern in PHP

Beginner

⏱️ 8 min read

📚 Updated: Aug 2026

🎯 3 Code Examples

🚀 Live Preview

Border Edge Logic

Hollow square border number pattern in PHP — numbers on the frame, spaces inside

Overview

What You’ll Learn

The hollow square border prints numbers only on the edges of a grid — interior cells are spaces. For $size = 5: top row 1 2 3 4 5, right column 6..9, bottom row counts down, left column counts down. Separate counters $k, $l, $m handle each edge. This tutorial covers border conditions, live preview, worked PHP examples, edge cases, and O(n²) complexity.

Top Row

$i == 1

When $i == 1, printf column number $j — gives 1 2 3 4 5.

Right Column

$j == $size, $k++

When $j == $size (not top row), printf and increment $k — 6 7 8 9.

Bottom & Left

$l--, $m--

Bottom row ($i == $size) uses $l--; left column ($j == 1) uses $m--.

Hollow Interior

spaces

All non-border cells print three spaces — creates the hollow square look.

Live Preview

3–8 size

Pick grid size and draw the hollow square border instantly in the browser.

O(n²)

Complexity

Each row scans O(n) positions — total work grows as n².

Introduction

A hollow square border prints numbers on the frame only — top, right, bottom, and left edges each use their own counter logic.

In PHP: nested loops over $i and $j, check border with if / elseif chain, use printf("%-3d", ...) for alignment, then echo PHP_EOL.

Foundation

📝 Problem & Approach

Given $size = 5, print a 5×5 grid with numbers on the border only.

PHP

// $size = 5 (conceptual output)
// 1  2  3  4  5
// 16          6
// 15          7
// 14          8
// 13 12 11 10 9

Inputs & Outputs

Item	Type	Description
`$size`	int	Grid dimension — typically `$size` ≥ 3 for a visible hollow interior.
`$i, $j, $k`	int	Row `$i`; column `$j`; edge counters `$k`, `$l`, `$m`.
Printed output	text	`$size × $size` grid; numbers on border only; spaces inside.

Minimal workflow

Pseudocode

for $i from 1 to $size:
    for $j from 1 to $size:
        if $i==1: printf $j
        elseif $j==$size: printf $k++
        elseif $i==$size: printf $l--
        elseif $j==1: printf $m--
        else: echo spaces
    echo PHP_EOL

Approach comparison

Approach	Idea	Best for
Nested i-j loops	Border if-else chain per cell	Hollow square frame
Simple border check	Simple border boolean check	Sequential border counter — Example 3
fgets(STDIN) input	`(int) $input` for size	User-chosen grid size
Fixed-width format	`printf("%-3d", value)` keeps columns aligned	Two-digit border numbers — all examples

Cheat Sheet

⚡ Quick Reference

Goal	Pattern
Set size	`$size = 5;`
Outer loop	`for ($i = 1; $i <= $size; $i++)`
Top row	`if ($i == 1) printf("%-3d", $j)`
Right column	`elseif ($j == $size) printf("%-3d", $k++)`
Bottom row	`elseif ($i == $size) printf("%-3d", $l--)`
Left column	`elseif ($j == 1) printf("%-3d", $m--)`
Skip duplicate middle	`echo PHP_EOL;` after inner loop completes
Program 58 contrast	Hollow diamond uses edge loops per row; this pattern uses a 2D grid with four edge counters

Compare

📋 Four Border Edges

How top, right, bottom, left edges and interior spaces work together.

Top row

if ($i == 1)
  printf("%-3d", $j)

Prints 1 through size left to right.

Right column

elseif ($j == $size)
  printf("%-3d", $k++)

Increments k down the right edge.

Bottom & left

i==size → l--
j==1 → m--

Bottom and left edges count downward.

Learning tip

if order matters

Check top row first — corners belong to top/bottom conditions.

Context

When This Pattern Shows Up

Reach for this pattern when teaching border conditions, grid loops, and formatting.

First lab exercise
Classic follow-up after hollow pyramids — introduces four-edge border printing on a grid.
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 pattern size.
Gateway to variants
Compare with Program 58 (hollow diamond), then continue to Program 60 digit-removal pattern.
Not a UI layout tool
This is a console teaching pattern — not how you build modern app screens.

Key benefit: one program that locks in border logic, grid traversal, and O(n²) thinking.

Interactive

🔮 Live Preview

Choose pattern size n and draw the full hollow square border number pattern in the browser.

Hands-On

Examples Gallery

Three complete PHP programs — fixed $size = 5, fgets(STDIN) input, and a simple sequential-border variant. Click View Output to reveal sample console results.

📚 Getting Started

Print a 5×5 hollow frame — top row shows 1 2 3 4 5.

Example 1 — Fixed `$size = 5`

Hard-coded 5×5 grid — counters $k=6, $l=13, $m=16 with border if/elseif chain and %-3d formatting.

PHP

<?php
$k = 6;
$l = 13;
$m = 16;

for ($i = 1; $i <= 5; $i++) {
    for ($j = 1; $j <= 5; $j++) {
        if ($i == 1)
            printf("%-3d", $j);
        elseif ($j == 5)
            printf("%-3d", $k++);
        elseif ($i == 5)
            printf("%-3d", $l--);
        elseif ($j == 1)
            printf("%-3d", $m--);
        else
            echo "   ";
    }
    echo PHP_EOL;
}

How It Works

Top row prints 1..5. Right column increments k. Bottom row decrements l. Left column decrements m. Interior prints spaces.

📈 Practical Variant

Read $size with fgets(STDIN) for flexible grid dimension.

Example 2 — fgets(STDIN) Input

Generalized border logic; counters computed from grid size.

PHP

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

$k = $size + 1;
$l = 3 * $size - 2;
$m = 4 * $size - 4;

for ($i = 1; $i <= $size; $i++) {
    for ($j = 1; $j <= $size; $j++) {
        if ($i == 1) printf("%-3d", $j);
        elseif ($j == $size) printf("%-3d", $k++);
        elseif ($i == $size) printf("%-3d", $l--);
        elseif ($j == 1) printf("%-3d", $m--);
        else echo "   ";
    }
    echo PHP_EOL;
}

How It Works

Same border logic as Example 1; grid size comes from fgets(STDIN) input.

⚡ Simple Variant

Boolean border check with one sequential counter — easier logic, different number sequence.

Example 3 — Sequential Border Counter

Uses border = (i==1 || i==size || j==1 || j==size) and a single incrementing counter.

PHP

<?php
$size = 5;
$val = 1;

for ($i = 1; $i <= $size; $i++) {
    for ($j = 1; $j <= $size; $j++) {
        $border = ($i == 1 || $i == $size || $j == 1 || $j == $size);
        if ($border) printf("%-3d", $val++);
        else echo "   ";
    }
    echo PHP_EOL;
}

How It Works

One counter walks the border clockwise — simpler code but a different layout than Example 1.

🧠 How the Algorithm Fills Each Cell

Set up grid

Set $size = 5 and initialize $k=6, $l=13, $m=16. Nested loops scan every cell.

Setup

Top row

When $i == 1, printf $j — top edge reads 1 2 3 4 5.

Top

Right column

When $j == $size, printf and increment $k — right edge 6 7 8 9.

Right

Bottom & left

Bottom row uses $l--; left column uses $m--; interior echoes three spaces.

Edges

Hollow square border complete

Visits $size² cells (e.g. 25 when $size=5) — O(n²) time, O(1) extra memory.

Trace

🔎 Worked Walkthrough — cell `$i = 3, $j = 3`, `$size = 5`

Trace interior cell (3,3) — not on any border edge, so it prints spaces.

Phase	Check	Result
Border check	i=3,j=3 — not i==1, j!=size, i!=size, j!=1	not border
Interior	else branch	prints three spaces

Cell (3,3) stays hollow. Then the inner loop continues to the next column.

Use Cases

Where this tiny pattern (and its loop structure) shows up beyond the homework prompt.

1. Teaching Border Edge Logic

Clearest visual proof that outer and inner bounds interact.

Example: use fgets(STDIN) for dynamic size — see Example 2.

2. Grid Traversal

Nested i-j loops visit every cell — classic 2D grid pattern.

Example: trace size=5 — cell (3,3) is interior, prints spaces.

3. Console Formatting Drills

Practice printf("%-3d", ...) for fixed-width column alignment.

Example: compare Example 1 vs Example 3 border layouts.

4. Border Formatting

Use %-3d so two-digit border numbers stay column-aligned.

Example: row 1 prints 1..5; row 5 prints 13..9 in reverse.

5. Complexity Intuition

Each row scans O(n) positions — total work grows as n².

Example: count cells → 5×5 = 25 visits for size=5.

6. Input Validation Labs

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

Example: reject n <= 0 and re-prompt.

Pro Tip: when an interviewer asks for patterns, explain the outer/inner loop 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
The hollow frame appears immediately — top row, side columns, and bottom row form a clear square border.
2. Minimal Concepts
Only loops and console output — no arrays or math libraries.
3. Easy to Extend
Change $size, use fgets(STDIN), try Example 3 simple border, or continue to Program 60.
4. O(1) Extra Memory
Streaming output needs no storage beyond loop counters.

Pro Tip: learn the four-edge if-else chain first; then try fgets(STDIN) input and the simple border variant in Example 3.

Usage Tips

Small habits that keep number-pattern code clean.

1. Name Variables Clearly
Use $size for grid dimension and $i/$j/$k/$l/$m for loop and counter variables.
2. Prefer fgets(STDIN)
Avoid crashes when the user types letters instead of a number.
3. Row Break After Inner Loop
Finish the inner loop for row $i, then call echo PHP_EOL.
4. Check Border Edges in Order
Test top row first, then right column, bottom row, left column — else print spaces for interior cells.
5. Dry-Run One Small Row Count
Trace $size = 5 on paper — expect cell (3,3) to print spaces.

Pro Tip: if corner numbers look wrong, check whether $i == 1 is tested first.

Common Pitfalls

Mistakes that commonly break hollow square border number patterns.

1. echo PHP_EOL Inside an Inner Loop
Each number lands on its own line — you get a vertical stack, not a square grid row.
→ Use printf or echo inside the inner loop; echo PHP_EOL only after each row completes.
2. Wrong if-else Order
Checking $j == $size before $i == 1 misplaces corner numbers.
→ Check top row ($i == 1) first — corners belong to top/bottom edges.
3. Forgetting the Row Break
Omitting echo PHP_EOL after the inner loop glues all rows onto one line.
→ Always call echo PHP_EOL after the inner j loop completes.
4. Forgetting Fixed Width
Printing without %-3d misaligns columns when numbers reach two digits.
→ Use printf("%-3d", value) for consistent column width.
5. Unchecked fgets(STDIN) Input
Letters or empty input throw invalid input without validation.
→ Use is_numeric($input) before (int) $input.
6. Hard-coding 5 Everywhere
Using literal 5 in loop bounds instead of variable $size breaks dynamic input.
→ Use one $size variable for both outer and inner loop bounds.

Edge Cases

Check these inputs before calling the solution done.

size = 1

Single cell

Output is one number: 1 — all four edges collapse onto the same cell.

size = 0

Empty pattern

Loop never runs — print nothing or show a message.

Negative

`$size < 0`

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

Large size

Large values produce wide rows — fine for labs; use smaller size for quick demos.

Bad input

Non-numeric fgets(STDIN) input

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

size = 2

Minimal square

A 2×2 grid has no interior — every cell is on the border.

Drill

🎯 Practice Problems

Try these variations to lock in the pattern.

1. Change $size

Try $size = 3, 4, or 6
Verify interior cell (3,3) prints spaces for size=5

2. Compare variants

Run Example 1 vs Example 3 side by side
Notice different number sequences on the border

3. Skip interior branch

Remove the else spaces branch
Observe filled interior instead of hollow

4. Next in series

Continue with Program 60 digit-removal pattern
Try size=6 and verify interior cells are spaces

Important

Notes

Cell count. Grid is $size×$size; only border cells print numbers.
echo/printf stay on the line; echo PHP_EOL advances — mix them carefully.
Validate $size > 0 for interactive programs; $size = 1 prints one digit where all edges overlap.
Row logic: if-else chain — top → right → bottom → left → spaces.

Quick Takeaway: nested $i,$j loops; border if/elseif; %-3d on edges; spaces inside; then echo PHP_EOL.

Analysis

⏱️ Time and Space Complexity

Program	Time	Extra space
Fixed `$size = 5` (Example 1)	`O(n²)`	`O(1)`
fgets(STDIN) input (Example 2)	`O(n²)`	`O(1)`
Simple border (Example 3)	`O(n²)`	`O(1)`

Wrap Up

🎉 Conclusion

The hollow square border uses four edge counters on a 2D grid — a natural step after hollow diamond patterns in Program 58. Master the fixed-$size version first, then try fgets(STDIN) input and the simple border variant in Example 3.

Practice the three examples above, then continue to Program 60 for the digit-removal number pattern.

Check border edges in order — print spaces for interior cells — one echo PHP_EOL per row.

View Examples Gallery Continue to Program 60

Pro Tips

💡 Best Practices

✅ Do

Explain top, right, bottom, left border checks before coding
Nested $i-$j loops; if/elseif for each edge; spaces inside; then echo PHP_EOL
Validate $size ≥ 3 for interactive programs
Check fgets(STDIN) return value before using $size
State O(n²) time when asked about complexity

❌ Don’t

Skip interior space branch
Print without %-3d (columns misalign)
Hard-code 5 instead of variable $size
Ignore bad console input in user-facing demos
Skip the $size = 1 edge case

Summary

Key Takeaways

Knowledge Unlocked

Five things to remember about this hollow square border number pattern

Four edges use separate counters; interior stays hollow with spaces.

Core concepts

△ 01

Rule

Grid is $size×$size

Definition

↻ 02

Nested loops

$i,$j = 1..$size

Code

↓ 03

Edge counters

$k++, $l--, $m--

Logic

n 04

Row length

$size cols/row

I/O

O 05

Complexity

O(n²)

Analysis

❓ Frequently Asked Questions

What does this pattern print?

Numbers only on the border of a square grid — interior cells are spaces creating a hollow frame.

Why use counters k, l, and m?

Each edge continues the sequence differently: $k increments on the right, $l and $m decrement on bottom and left edges.

Why use printf('%-3d', value)?

Fixed-width formatting keeps columns aligned when numbers reach two digits.

Can I change the 5×5 size?

Yes. Generalize with $k=$size+1, $l=3*$size-2, $m=4*$size-4 — see Example 2.

How is Example 3 different?

Example 3 uses a simple border check and one counter — easier but a different number sequence.

Why are there gaps inside the square?

Non-border cells print three spaces — that creates the hollow interior.

What is the time complexity?

O(n²) for an n×n grid because every cell is visited once.

How should I read size safely?

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

Did you Know? 🔊

Numbers print only on the border of a 5×5 grid: top row 1..5, right column 6..9, bottom row 13..9, left column 16..14 — interior cells are spaces.

Continue to Program 60

Move on to the digit-removal number pattern in the PHP number-pattern series.

Program 60 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 58 — Hollow Number Diamond Pattern PHP Number Pattern 60 — Number by Removing Last Digit Each Line

Hollow Square Border Pattern in PHP

What You’ll Learn

Top Row

Right Column

Bottom & Left

Hollow Interior

Live Preview

O(n²)

Introduction

📝 Problem & Approach

Inputs & Outputs

Minimal workflow

Approach comparison

⚡ Quick Reference

📋 Four Border Edges

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 $size = 5

How It Works

📈 Practical Variant

Example 2 — fgets(STDIN) Input

How It Works

⚡ Simple Variant

Example 3 — Sequential Border Counter

How It Works

🧠 How the Algorithm Fills Each Cell

Set up grid

Top row

Right column

Bottom & left

Hollow square border complete

🔎 Worked Walkthrough — cell $i = 3, $j = 3, $size = 5

Use Cases

1. Teaching Border Edge Logic

2. Grid Traversal

3. Console Formatting Drills

4. Border Formatting

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 Variables Clearly

2. Prefer fgets(STDIN)

3. Row Break After Inner Loop

4. Check Border Edges in Order

5. Dry-Run One Small Row Count

Common Pitfalls

1. echo PHP_EOL Inside an Inner Loop

2. Wrong if-else Order

3. Forgetting the Row Break

4. Forgetting Fixed Width

5. Unchecked fgets(STDIN) Input

6. Hard-coding 5 Everywhere

Edge Cases

Single cell

Empty pattern

$size < 0

Large size

Non-numeric fgets(STDIN) input

Minimal square

🎯 Practice Problems

1. Change $size

2. Compare variants

3. Skip interior branch

4. Next in series

Notes

⏱️ Time and Space Complexity

🎉 Conclusion

💡 Best Practices

Example 1 — Fixed `$size = 5`

🔎 Worked Walkthrough — cell `$i = 3, $j = 3`, `$size = 5`

2. Prefer `fgets(STDIN)`

`$size < 0`