Hollow Square of 1s Pattern in PHP

Beginner

⏱️ 8 min read

📚 Updated: Aug 2026

🎯 3 Code Examples

🚀 Live Preview

Boundary Checks

Hollow square of 1s output in PHP (border 1s with spaces inside)

Overview

What You’ll Learn

The hollow square of 1s prints a border of ones with blank space inside. This tutorial covers the border condition, nested loops, a live preview, algorithm steps, worked PHP examples, edge cases, and complexity.

Shape Rule

Border only

Only first/last row and first/last column print 1; interior cells stay blank.

Column Loop

$j = 1..$rows

for ($j = 1; $j <= $rows; $j++) walks every column in the current row.

Border Check

Four edges

if ($i==1 || $i==$rows || $j==1 || $j==$rows) prints "1 "; otherwise " ".

Outer Loop

Row index i

for ($i = 1; $i <= $rows; $i++) walks each row of the square grid.

Live Preview

1–20 rows

Pick a row count and draw the hollow square of 1s instantly in the browser.

O(n²)

Complexity

Visits every cell in an n×n grid — n² iterations; extra memory stays O(1).

Introduction

A hollow square of 1s prints a border of ones with empty space inside. With $rows = 5, the output is a 5×5 grid: full top and bottom rows of ones, and middle rows with ones only at the left and right edges.

In PHP you use nested loops over rows and columns, then an if that checks whether the current cell lies on the border. Border cells print "1 "; inner cells print " " to keep columns aligned.

Why it matters?

It teaches boundary detection with a simple condition — a key step before hollow rectangles, frames, and diamonds.

Key Highlights

Nested Grid

Outer loop uses $i = 1..$rows; inner loop uses $j = 1..$rows.

Border Condition

First/last row or first/last column → print 1.

Fixed Cell Width

Border uses "1 " and interior uses " " so columns line up.

Series Foundation

Follow Program 41 square pyramid; continue to Program 43 right-aligned triangle.

In short: for each row $i and column $j, print "1 " on the border and " " inside, then call echo PHP_EOL after each row.

Foundation

📝 Problem & Approach

Given a positive integer $rows (e.g. 5), print an n×n hollow square: border cells show 1, inner cells show spaces.

PHP

// $rows = 5 (conceptual shape)
// 1 1 1 1 1
// 1       1
// 1       1
// 1       1
// 1 1 1 1 1

Inputs & Outputs

Item	Type	Description
`$rows`	int	Number of rows (and columns) in the square (typically ≥ 1).
Printed output	text	Square grid of `$rows × $rows` cells; border prints `1`, interior prints spaces.

Minimal workflow

Pseudocode

for $i from 1 to $rows:
    for $j from 1 to $rows:
        if border cell: print "1 "
        else: print "  "
    print newline

Approach comparison

Approach	Idea	Best for
Border condition	`1 1 1 1 1` top row, hollow middle	Learning and interviews
User-input size	`(int) $input;`	Flexible console programs
Filled square	Always `echo "1 "`	Contrast with hollow logic

Cheat Sheet

⚡ Quick Reference

Goal	Pattern
Walk rows	`for ($i = 1; $i <= $rows; $i++)`
Walk columns	`for ($j = 1; $j <= $rows; $j++)`
Border check	`if ($i==1 \|\| $i==$rows \|\| $j==1 \|\| $j==$rows)`
End the row	`echo PHP_EOL;`
Program 41 contrast	Square pyramid uses odd widths; this pattern uses a full grid + border test

Compare

📋 Border vs Inner vs Combined

Same square cell — how the border check decides between 1 and spaces.

Border check

$i==1 || $i==$rows
|| $j==1 || $j==$rows

True on any edge cell — print "1 "

Inner cells

else branch

Interior positions print " " (two spaces)

Row width

$j = 1..$rows

Every row has exactly $rows cells

Learning tip

trace $i=3

Dry-run row 3: 1 at $j=1 and $j=5, spaces in between

Context

When This Pattern Shows Up

Reach for this pattern when teaching boundary checks inside a full row×column grid.

First lab exercise
Classic follow-up after centered pyramids and alternating rows.
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 41 (square pyramid), then continue to Program 43 (right-aligned triangle).
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 hollow square of 1s in the browser.

Hands-On

Examples Gallery

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

📚 Getting Started

Print five rows with two nested loops per line.

Example 1 — Fixed `$rows = 5`

Hard-coded size — nested loops and a border check build each row.

PHP

<?php
$rows = 5;

for ($i = 1; $i <= $rows; $i++) {
    for ($j = 1; $j <= $rows; $j++) {
        if ($i == 1 || $i == $rows || $j == 1 || $j == $rows) {
            echo "1 ";
        } else {
            echo "  ";
        }
    }
    echo PHP_EOL;
}

How It Works

When $i = 1, every $j hits the border test (top row) — five 1s print. When $i = 3, only $j = 1 and $j = 5 pass the test; the middle columns print spaces.

📈 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 = 1; $j <= $rows; $j++) {
        if ($i == 1 || $i == $rows || $j == 1 || $j == $rows) {
            echo "1 ";
        } else {
            echo "  ";
        }
    }
    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

Remove the border check to print a completely filled square.

Example 3 — Filled Square

Remove the border if and always print "1 " to get a solid square of ones.

PHP

<?php
$rows = 5;

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

How It Works

Same nested-loop structure; the inner loop always prints "1 " with no border condition.

🧠 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 each row of the square grid.

Row

Inner loop (columns)

for ($j = 1; $j <= $rows; $j++) visits every column in the current row.

Column

Border if / else

Border cells print "1 "; inner cells print " ", then echo PHP_EOL ends the row.

Hollow border square complete

Total cell visits: n² — O(n²) time, O(1) extra memory.

Trace

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

Trace one middle row to see which cells hit the border test.

`$j`	Border?	Prints
`1`	yes (`$j==1`)	`1`
`2`	no
`3`	no
`4`	no
`5`	yes (`$j==$rows`)	`1`

Row output: 1 1 — total cell visits for the full square: 5×5 = 25 = n².

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: change $j <= $rows to $j <= $i and watch the shape change.

2. Pattern Series Base

Foundation for hollow rectangles, diamonds, and framed grids.

Example: add a cols variable for a hollow rectangle.

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: swap 1 for * once the border logic works.

5. Complexity Intuition

Every cell is visited once — n² makes O(n²) concrete for beginners.

Example: count cell visits for n = 5 → 25.

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 bounds show up immediately as a misaligned or filled shape.
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: learn the border-check version first; then try the filled square 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: echo ($i==1||$i==$rows||$j==1||$j==$rows ? "1 " : " ");
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 cells per line, you almost certainly put echo PHP_EOL inside the inner loop.

Common Pitfalls

Mistakes that commonly break hollow squares of 1s.

1. echo PHP_EOL Inside the Inner Loop
Each cell lands on its own line — you get a column, not a square.
→ Use echo for each cell; echo PHP_EOL only after the inner loop.
2. Wrong Inner Bound
Using $j <= $i instead of $j <= $rows produces a triangle, not a square.
→ Keep for ($j = 1; $j <= $rows; $j++) so every row has the same width.
3. Forgetting the Row Break
Omitting echo PHP_EOL glues every cell 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. Single Space Inside
Printing one space instead of two breaks column alignment with border 1 cells.
→ Use " " (two spaces) for inner cells so columns stay aligned.

Edge Cases

Check these inputs before calling the solution done.

$rows = 1

Single cell

Output is just 1 on one 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 n² characters — 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

Filled square

Remove the border if and always print "1 " — see Example 3.

Drill

🎯 Practice Problems

Try these variations to lock in the pattern.

1. Square number pyramid

Centered rows with $m * $m
Review Program 41

2. Right-aligned triangle

Increasing numbers aligned to the right
Continue with Program 43

3. Hollow rectangle

Add a cols variable separate from $rows
Same border check on four edges

4. Star border

Replace "1 " with "* "
Keep the same nested-loop structure

Important

Notes

Cell count. Total cell visits for an n×n square is n² — border cells are 4n - 4 when n > 1.
echo stays on the line; echo PHP_EOL advances — mix them carefully.
Validate $rows > 0 for interactive programs; $rows = 1 should print a single 1.
Use "1 " on borders and " " inside so columns stay aligned.

Quick Takeaway: nested row/column loops, border check for edges, fixed-width print tokens, then break the line.

Analysis

⏱️ Time and Space Complexity

Program	Time	Extra space
Nested loops (Examples 1–2)	`O($rows²)`	`O(1)`
Filled square (Example 3)	`O($rows²)`	`O(1)`

Wrap Up

🎉 Conclusion

The hollow square of 1s combines nested loops with a simple border condition — a natural step after centered pyramids. Master the fixed-$rows version first, then try user input and the filled square.

Practice the three examples above, then continue to Program 43 for the right-aligned increasing number triangle.

Every row has $rows cells — keep echo PHP_EOL only after the inner loop finishes.

View Examples Gallery Continue to Program 43

Pro Tips

💡 Best Practices

✅ Do

Explain row loop, column loop, and border if before coding
Use "1 " / " " 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 cell loop
Skip the border check (you get a filled square instead)
Use one space for inner cells when two are needed
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 hollow square of 1s

Print the pattern the beginner-friendly way.

Core concepts

△ 01

Rule

Border cells print 1

Definition

↻ 02

Border check

Four edge conditions

Code

↓ 03

Inner cells

Print two spaces

Logic

n 04

Total visits

n² cells

I/O

O 05

Complexity

O(n²) time

Analysis

❓ Frequently Asked Questions

What makes this square hollow?

Only border positions print 1. All inner positions print spaces, so the center stays blank.

How does the program detect border cells?

It checks $i==1 or $i==$rows (top/bottom) or $j==1 or $j==$rows (left/right). If any is true, it prints 1.

Why print two spaces inside?

Each cell uses a fixed width so columns align. Border cells use "1 " and inner cells use " ".

Can I make the size dynamic?

Yes. Replace the fixed 5 with a $rows variable and read it with fgets(STDIN) — see Example 2.

How do I print a filled square instead?

Remove the if condition and always print "1 " in the inner loop — see Example 3.

What is the time complexity?

O(n²) for an n×n square because both loops visit every cell once.

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 "1 " on one line — technically a 1×1 border square.

Did you Know? 🔊

Only border cells print 1 — when $i is the first or last row, or $j is the first or last column. Inner cells print spaces, which creates the hollow look.

Continue to Program 43

Move on to the right-aligned increasing number triangle in the PHP number-pattern series.

Program 43 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 41 — Square Number Pyramid PHP Number Pattern 43 — Right-Aligned Increasing Triangle

Hollow Square of 1s Pattern in PHP

What You’ll Learn

Shape Rule

Column Loop

Border Check

Outer Loop

Live Preview

O(n²)

Introduction

Why it matters?

Nested Grid

Border Condition

Fixed Cell Width

Series Foundation

📝 Problem & Approach

Inputs & Outputs

Minimal workflow

Approach comparison

⚡ Quick Reference

📋 Border vs Inner 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 — Filled Square

How It Works

🧠 How the Algorithm Prints Rows

Set up

Outer loop (rows)

Inner loop (columns)

Border if / else

Hollow border square complete

🔎 Worked Walkthrough — $rows = 5, 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. Wrong Inner Bound

3. Forgetting the Row Break

4. Unchecked fgets(STDIN) input

5. Single Space Inside

Edge Cases

Single cell

Empty pattern

$rows < 0

Many rows

Non-numeric fgets(STDIN) input

Filled square

🎯 Practice Problems

1. Square number pyramid

2. Right-aligned triangle

3. Hollow rectangle

4. Star border

Example 1 — Fixed `$rows = 5`

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

2. Prefer `fgets(STDIN)`

`$rows < 0`