Hollow Square of 1s in Python

Q: What is a hollow square pattern?

A hollow square prints characters only on the border (first/last row and first/last column) and leaves the inside blank with spaces.

Q: How does the program know a cell is on the border?

It checks if i is 1 or n, or if j is 1 or n. If any condition is true, it prints 1; otherwise it prints spaces.

Q: How can I change the size from 5x5 to NxN?

Use an n variable and loop from 1 to n for both i and j. Update the border check to use n instead of 5 — see Example 2.

Q: Why print a space after each cell?

Each border cell uses "1 " (digit plus space). Interior cells use " " so columns stay aligned in the console.

Q: What is the minimum size for a hollow square?

Size 2 gives a thin border frame. Size 1 prints a single 1 with no hollow interior.

Q: How is this different from Program 41?

Program 41 prints a centered pyramid of perfect squares. Program 42 prints a hollow square grid using border conditions.

Q: How do I use a different border character?

Replace "1" with "*" or "#" in the if branch — see Example 3.

Q: What is the time complexity?

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

Q: How should I read n safely?

Use a try/except ValueError around int(input()) and validate n >= 2 for a meaningful hollow frame.

Beginner

⏱️ 7 min read

📚 Updated: Sep 2026

🎯 3 Code Examples

🚀 Live Preview

Nested Loops + If

Hollow 5x5 square pattern of 1s output in Python

Overview

What You’ll Learn

The hollow square of 1s prints a 5×5 border frame — 1 1 1 1 1 on top and bottom, 1 on the sides, spaces inside — a natural step after Program 41’s square pyramid. This tutorial covers nested loops, border conditions, a live preview, worked Python examples, edge cases, and complexity.

Shape Rule

Border only

Print 1 on the first/last row and first/last column — leave interior cells as spaces.

Outer Loop

Rows (i)

for i in range(1, n + 1): walks each row of the grid.

Inner Loop

Columns (j)

for j in range(1, n + 1): visits every column in the current row.

Border check

if condition

i == 1 or i == n or j == 1 or j == n — print 1 on the edge, space inside.

Live Preview

3–9 size

Pick a square size and draw the hollow border in the browser.

O(n²)

Complexity

Every cell in an n×n grid is visited once — total checks = n².

Introduction

A hollow square of 1s prints 1 only on the border of an n×n grid and spaces everywhere else. With n = 5, the output is a 5×5 frame of ones with a hollow center.

In Python nested loops walk every cell (i, j), an if checks whether the cell is on the border, and print(..., end=" ") keeps values on the same line.

Why it matters?

It combines nested loops with a boundary condition — a key step after Program 41’s formatted pyramid.

Key Highlights

Border rule

First/last row or column prints 1.

Grid traversal

Nested loops visit every (i, j) cell.

vs Program 41

Program 41 prints perfect squares; Program 42 prints a hollow frame.

Series Foundation

Follow Program 41; continue to Program 43 (right-aligned triangle) next.

In short: for each (i, j) in an n×n grid, print 1 on the border else a space, then print() each row.

Foundation

📝 Problem & Approach

Given a grid size n (e.g. 5), print a hollow square border of 1s using nested loops and a border condition.

Python

# n = 5 (conceptual shape)
# 1 1 1 1 1
# 1       1
# 1       1
# 1       1
# 1 1 1 1 1

Inputs & Outputs

Item	Type	Description
`n`	int	Side length of the square grid — both loops run `1..n`.
`i`	int	Outer loop — row index from `1` to `n`.
`j`	int	Inner loop — column index from `1` to `n`.

Minimal workflow

Pseudocode

for i from 1 to n:
    for j from 1 to n:
        if i is border or j is border:
            print 1
        else:
            print space
    print newline

Approach comparison

Approach	Idea	Best for
Border condition	`1 1 1 1 1` frame	Learning and interviews
User-input size	`int(input(...))`	Flexible console programs
Custom border char	Print `*` instead of `1`	Visual variety

Cheat Sheet

⚡ Quick Reference

Goal	Pattern
Walk rows	`for i in range(1, n + 1):`
Walk columns	`for j in range(1, n + 1):`
Border check	`if i == 1 or i == n or j == 1 or j == n:`
Print border	`print("1", end=" ")`
Print interior	`print(" ", end=" ")`
End the row	`print()`
Program 41 contrast	Perfect-square pyramid — not a hollow grid

Compare

📋 Fixed Size vs User Input vs Asterisk Border

Same hollow square — different ways to control size and border character.

Outer loop

i = 1..n

Row index

Inner loop

j = 1..n

Column index

Border

i/j == 1 or n

Edge cells print 1

Learning tip

end=" "

Keeps grid aligned

Context

When This Pattern Shows Up

Reach for this pattern when teaching boundary conditions with nested loops on a 2D grid.

After Program 41
Natural follow-up — boundary conditions on a grid instead of formatted square pyramids.
Nested-loop warm-up
Outer/inner bound practice with an immediate visual check.
Console I/O practice
Combine loops with input() for a flexible square size.
Gateway to variants
Swap 1 for * on the border — see Example 3.
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 square size between 3 and 9 and draw the hollow border in the browser.

Hands-On

Examples Gallery

Three complete Python programs — fixed size, user input, and asterisk border. Click View Output to reveal sample console results.

📚 Getting Started

Print a 5×5 hollow square border with nested loops and a border condition.

Example 1 — Fixed `n = 5`

Hard-coded grid size — ideal for first demos and screenshots.

Python

n = 5

for i in range(1, n + 1):
    for j in range(1, n + 1):
        if i == 1 or i == n or j == 1 or j == n:
            print("1", end=" ")
        else:
            print(" ", end=" ")
    print()

How It Works

When i = 1 or i = 5, every cell is on the border — all 1s. When i = 3 and j = 3, neither row nor column is on the edge — prints spaces.

📈 User Input

Read the square size with input() instead of hard-coding 5.

Example 2 — User Input Size

Read n with input() and validate n ≥ 2 (wrap in try/except ValueError in real apps).

Python

n = int(input("Enter the size (n >= 2): "))
if n < 2:
    raise ValueError("n must be at least 2")

for i in range(1, n + 1):
    for j in range(1, n + 1):
        if i == 1 or i == n or j == 1 or j == n:
            print("1", end=" ")
        else:
            print(" ", end=" ")
    print()

How It Works

Same border-check core as Example 1; only the source of n changes from a literal to user input. Non-numeric input raises ValueError with bare int(input()) — use try/except for safer labs.

⚡ Custom Border

Swap 1 for * on the border — same condition, different character.

Example 3 — Asterisk Border

Keep n = 5 but print * on the border instead of 1.

Python

n = 5

for i in range(1, n + 1):
    for j in range(1, n + 1):
        if i == 1 or i == n or j == 1 or j == n:
            print("*", end=" ")
        else:
            print(" ", end=" ")
    print()

How It Works

Only the printed character changes — "*" instead of "1" in the if branch. Loop bounds and border check stay the same as Example 1.

🧠 How the Algorithm Prints the Grid

Set up

No imports needed. Set n = 5 and loop variables i, j.

Setup

Outer loop (rows)

for i in range(1, n + 1): — walks each row of the grid.

Row

Inner loop (columns)

for j in range(1, n + 1): — visits every column in the current row.

Column

Border check

if i == 1 or i == n or j == 1 or j == n: — print 1 on the edge, space inside.

Condition

New line

print() ends the row after the inner loop finishes.

Break

Hollow square frame complete

Every cell in an n×n grid is visited — O(n²) time, O(1) extra memory.

Trace

🔎 Worked Walkthrough — `n = 5`, row `i = 3`

Trace row 3 cell by cell — which cells print 1 and which print spaces.

`j`	On border?	Prints
`1`	Yes (`j == 1`)	`1`
`2`	No
`3`	No
`4`	No
`5`	Yes (`j == n`)	`1`

Border cells per row = 4n - 4 for n ≥ 2 — total grid visits = 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: swap 1 for * on the border — see Example 3.

2. Pattern Series Base

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

Example: continue to Program 43 for a right-aligned number triangle.

3. Console Formatting Drills

Practice print vs row newline without complex math.

Example: put print() inside the inner loop by mistake.

4. Hollow rectangle

Use separate rows and cols with the same border check.

Example: change both loop bounds and border conditions.

5. Complexity Intuition

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

Example: count border cells for n = 5 — total is 16 (4n - 4).

6. Input Validation Labs

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

Example: reject n < 2 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 Python 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, j) on paper for n = 3 before coding the full n = 5 demo.

Usage Tips

Small habits that keep number-pattern code clean.

1. Keep end=" " Consistent
Border cells use print("1", end=" "); interior uses print(" ", end=" ") — same width keeps columns aligned.
2. Call try/except ValueError
Use try/except ValueError so bad input does not crash when converting n.
3. Keep print() Outside the Inner Loop
Only call print() after the inner loop finishes the row.
4. One Border Condition
i == 1 or i == n or j == 1 or j == n covers all four edges in one test.
5. Dry-Run n = 3
Trace i = 1, 2, 3 and mark border cells 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 print() inside the inner loop.

Common Pitfalls

Mistakes that commonly break hollow square border patterns.

1. Newline Inside the Inner Loop
Each cell lands on its own line — you get a column, not a square.
→ Use print("1", end=" ") or print(" ", end=" ") per cell; print() only after the inner loop.
2. Hard-Coded Size in Condition
Using i == 5 in the check breaks when n changes to 7 or 10.
→ Always use the n variable: i == n or j == n.
3. Mismatched Cell Width
Border prints "1 " but interior prints a single space — columns drift apart.
→ Use two spaces for interior: print(" ", end=" ") to match "1 " width.
4. Size Too Small
n = 1 prints a single 1 with no hollow interior; n = 2 is the thinnest frame.
→ Validate n ≥ 2 for interactive programs expecting a hollow square.
5. Bare int(input())
Letters or empty input raise ValueError with bare int(input()).
→ Catch ValueError and re-prompt on failure.

Edge Cases

Check these inputs before calling the solution done.

n = 1

Size = 1

Output is just 1 on one line — no hollow interior.

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

Size = 2

Thinnest hollow frame — four border cells forming a square ring.

Bad input

Non-numeric input

Bare int(input()) raises ValueError on bad input — use try/except first.

Large n

Large grid size

Each cell visited once — total work grows as n² for an n × n grid.

Drill

🎯 Practice Problems

Try these variations to lock in the pattern.

1. Square pyramid

Review Program 41’s m*m pyramid
Compare with Program 41

2. Filled square

Print 1 in every cell — no border check
Same nested loops, no else branch

3. Next in series

Continue with Program 43
Build on grid boundary logic

4. Asterisk border

Use "*" instead of "1"
Same condition, different character

Important

Notes

Border rule. Print 1 when i == 1 or i == n or j == 1 or j == n; else print two spaces.
print(..., end=" ") stays on the line; print() advances — mix them carefully.
Validate n ≥ 2 for interactive programs; n = 1 should print a single 1.
An n × n grid has n² cells — border cells = 4*n - 4 for n ≥ 2.

Quick Takeaway: nested loops over i, j, border check prints "1 ", else " ", then print().

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 hollow square border is a compact nested-loop lesson: visit every cell in an n × n grid and use a border condition to print 1 or spaces. Master the fixed-n version, then try user input and a custom border character.

Practice the three examples above, then continue to Program 43 for the next pattern in the series.

Border = first/last row or column — keep cell width consistent ("1 " vs " ") and validate n when reading input.

View Examples Gallery Continue to Program 43

Pro Tips

💡 Best Practices

✅ Do

Use for i in range(1, n + 1): and for j in range(1, n + 1):
Border: if i == 1 or i == n or j == 1 or j == n:
Print "1" on border, " " inside — both with end=" "
Validate n ≥ 2 for interactive programs
Wrap int(input()) in try/except ValueError

❌ Don’t

Call print() inside the inner cell loop
Hard-code 5 in the border condition
Use single space for interior when border uses two chars
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 hollow square border

Print the pattern the beginner-friendly way.

Core concepts

△ 01

Rule

Border cells only

Definition

↻ 02

Outer loop

Rows i = 1..n

Code

↓ 03

Inner loop

Columns j = 1..n

Code

↵ 04

Condition

i/j on edge

Logic

O 05

Complexity

O(n²) time

Analysis

❓ Frequently Asked Questions

What is a hollow square pattern?

A hollow square prints characters only on the border (first/last row and first/last column) and leaves the inside blank with spaces.

How does the program know a cell is on the border?

It checks if i is 1 or n, or if j is 1 or n. If any condition is true, it prints 1; otherwise it prints spaces.

How can I change the size from 5x5 to NxN?

Use an n variable and loop from 1 to n for both i and j. Update the border check to use n instead of 5 — see Example 2.

Why print a space after each cell?

Each border cell uses "1 " (digit plus space). Interior cells use " " so columns stay aligned in the console.

What is the minimum size for a hollow square?

Size 2 gives a thin border frame. Size 1 prints a single 1 with no hollow interior.

How is this different from Program 41?

Program 41 prints a centered pyramid of perfect squares. Program 42 prints a hollow square grid using border conditions.

How do I use a different border character?

Replace "1" with "*" or "#" in the if branch — see Example 3.

What is the time complexity?

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

How should I read n safely?

Use a try/except ValueError around int(input()) and validate n >= 2 for a meaningful hollow frame.

Did you Know? 🔊

Print 1 when i == 1, i == n, j == 1, or j == n; otherwise print spaces. A n × n grid visits n² cells — total prints = n².

Continue to Program 43

Move on to the right-aligned number triangle in the Python 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

Python Number Pattern 41 — Square Numbers Pyramid Python Number Pattern 43 — Right-Aligned Number Triangle

Hollow Square of 1s in Python

What You’ll Learn

Shape Rule

Outer Loop

Inner Loop

Border check

Live Preview

O(n²)

Introduction

Why it matters?

Border rule

Grid traversal

vs Program 41

Series Foundation

📝 Problem & Approach

Inputs & Outputs

Minimal workflow

Approach comparison

⚡ Quick Reference

📋 Fixed Size vs User Input vs Asterisk Border

When This Pattern Shows Up

After Program 41

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 Size

How It Works

⚡ Custom Border

Example 3 — Asterisk Border

How It Works

🧠 How the Algorithm Prints the Grid

Set up

Outer loop (rows)

Inner loop (columns)

Border check

New line

Hollow square frame complete

🔎 Worked Walkthrough — n = 5, row i = 3

Use Cases

1. Teaching Nested Loops

2. Pattern Series Base

3. Console Formatting Drills

4. Hollow rectangle

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. Keep end=" " Consistent

2. Call try/except ValueError

3. Keep print() Outside the Inner Loop

4. One Border Condition

5. Dry-Run n = 3

Common Pitfalls

1. Newline Inside the Inner Loop

2. Hard-Coded Size in Condition

3. Mismatched Cell Width

4. Size Too Small

5. Bare int(input())

Edge Cases

Size = 1

Empty pattern

n < 0

Size = 2

Non-numeric input

Large grid size

🎯 Practice Problems

1. Square pyramid

2. Filled square

3. Next in series

Example 1 — Fixed `n = 5`

🔎 Worked Walkthrough — `n = 5`, row `i = 3`

1. Keep `end=" "` Consistent

2. Call `try/except ValueError`

5. Bare `int(input())`

`n < 0`