Left Edge Loop
$j = $n..1
Scan $j from $n down to 1; echo $j when $i == $j, else a space.
Hollow Number Pyramid in PHP
Overview
What You’ll Learn
The hollow number pyramid prints each row number at the left and right edges only — spaces fill the middle. For $n = 5: 1, 2 2, 3 3, and so on. Each row uses a left loop $j = $n..1 and a right loop $k = 2..$n with $i == $j / $i == $k conditions. This tutorial covers edge-printing logic, live preview, worked PHP examples, edge cases, and O(n²) complexity.
Right Edge Loop
$k = 2..$n
Scan $k from 2 to $n; echo $k when $i == $k, else a space.
Hollow Middle
spaces only
Every position that is not an edge prints a space — that creates the hollow look.
Two Edge Digits
2n-1 cols
Row i spans 2n-1 columns — row number at left and right edges (row 1 overlaps).
Live Preview
3–12 rows
Pick row count and draw the hollow pyramid instantly in the browser.
O(n²)
Complexity
Each row scans O(n) positions — total work grows as n².
Introduction
A hollow number pyramid prints the row number at both pyramid edges and spaces everywhere else. Row 2 reads 2 2; row 3 reads 3 3 when aligned.
In PHP: outer for ($i = 1; $i <= $n; $i++), left loop $j = $n..1 with $i == $j, right loop $k = 2..$n with $i == $k, then echo PHP_EOL.
Foundation
📝 Problem & Approach
Given $n = 5, print five hollow rows — widest row has 5 at both ends.
PHP
// $n = 5 (conceptual output)
// 1
// 2 2
// 3 3
// 4 4
// 5 5Inputs & Outputs
| Item | Type | Description |
|---|---|---|
$n | int | Pyramid height — number of rows (typically ≥ 1). |
$i, $j, $k | int | Row $i; left index $j; right index $k. |
| Printed output | text | 2*$n-1 columns per row; row number at left and right edges only. |
Minimal workflow
Pseudocode
for $i from 1 to $n:
for $j from $n down to 1: echo $j if $i==$j else space
for $k from 2 to $n: echo $k if $i==$k else space
echo PHP_EOLApproach comparison
| Approach | Idea | Best for |
|---|---|---|
| Two-loop row | Left edge loop + right edge loop | Hollow edge-only rows |
| $row string | Build row without trailing spaces | Cleaner console output — Example 3 |
| fgets(STDIN) input | (int) $input for n | User-chosen pyramid height |
| Compact output | Build a $row string then echo $row | No trailing space per row — Example 3 |
Cheat Sheet
⚡ Quick Reference
| Goal | Pattern |
|---|---|
| Set n | $n = 5; |
| Outer loop | for ($i = 1; $i <= $n; $i++) |
| Left loop | for ($j = $n; $j >= 1; $j--) echo $j if $i==$j else space |
| Right loop | for ($k = 2; $k <= $n; $k++) echo $k if $i==$k else space |
| Row break | echo PHP_EOL; after both edge loops |
| Program 56 contrast | Palindromic pyramid fills every row; this pattern prints edges only with spaces inside |
Compare
📋 Left Edge vs Right Edge
How left edge loop, right edge loop, and row breaks work together.
Left edge
for ($j = $n; $j >= 1; $j--)
echo $i==$j ? $j : " "Right-aligns the left pyramid edge.
Right edge
for ($k = 2; $k <= $n; $k++)
echo $i==$k ? $k : " "Expands the right pyramid edge outward.
Learning tip
trace $i=3, $n=5Dry-run row 3: left prints 3, right prints 3, middle is spaces.
Context
When This Pattern Shows Up
Reach for this pattern when teaching edge conditions, hollow shapes, and nested loops.
First lab exercise
Classic follow-up after palindromic pyramids — introduces hollow edge-printing.
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 56 (palindromic pyramid), then continue to Program 58 hollow diamond.
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 edge conditions, hollow rows, and O(n²) thinking.
Interactive
🔮 Live Preview
Choose pattern size n and draw the full hollow number pyramid pattern in the browser.
Hands-On
Examples Gallery
Three complete PHP programs — fixed $n = 5, fgets(STDIN) input, and a compact $row string variant. Click View Output to reveal sample console results.
📚 Getting Started
Print five hollow rows — widest row shows 5 at both edges.
Example 1 — Fixed $n = 5
Hard-coded $n = 5 — left loop $j = $n..1, right loop $k = 2..$n, edge conditions $i==$j / $i==$k.
PHP
<?php
$n = 5;
for ($i = 1; $i <= $n; $i++) {
for ($j = $n; $j >= 1; $j--) {
if ($i == $j) echo $j;
else echo " ";
}
for ($k = 2; $k <= $n; $k++) {
if ($i == $k) echo $k;
else echo " ";
}
echo PHP_EOL;
}How It Works
Row 1 prints one 1 where edges overlap. Row 3 prints 3 at the left edge and 3 at the right — spaces fill the middle.
📈 Practical Variant
Read $n with fgets(STDIN) for flexible output size.
Example 2 — fgets(STDIN) Input
Same hollow edge logic; pyramid height comes from user input.
PHP
<?php
echo "Enter n: ";
$input = trim(fgets(STDIN));
if (!is_numeric($input)) {
echo "Invalid input." . PHP_EOL;
exit(1);
}
$n = (int) $input;
for ($i = 1; $i <= $n; $i++) {
for ($j = $n; $j >= 1; $j--) {
if ($i == $j) echo $j;
else echo " ";
}
for ($k = 2; $k <= $n; $k++) {
if ($i == $k) echo $k;
else echo " ";
}
echo PHP_EOL;
}How It Works
Same hollow edge logic as Example 1; height comes from fgets(STDIN) input.
⚡ Compact Variant
Build each row with string concatenation — same edge logic, cleaner assembly.
Example 3 — Compact Rows
Same edge logic; string concatenation assembles left and right halves in one buffer.
PHP
<?php
$n = 5;
for ($i = 1; $i <= $n; $i++) {
$row = "";
for ($j = $n; $j >= 1; $j--) $row .= $i == $j ? $j : " ";
for ($k = 2; $k <= $n; $k++) $row .= $i == $k ? $k : " ";
echo $row . PHP_EOL;
}How It Works
Same edge logic; building a $row string avoids repeated echo calls per character.
🧠 How the Algorithm Builds Each Row
1
Set up & outer loop
Set $n (e.g. 5). Outer loop for ($i = 1; $i <= $n; $i++) builds one hollow row per iteration.
Setup
2
Left edge loop
for ($j = $n; $j >= 1; $j--) echoes $j when $i==$j, else a space.
Left
3
Right edge loop
for ($k = 2; $k <= $n; $k++) echoes $k when $i==$k, else a space.
Right
4
Row break
echo PHP_EOL after both edge loops finish — starts the next row.
Break
=
Hollow number pyramid complete
Each row scans 2n-1 positions (e.g. 9 columns when n=5) — O(n²) time, O(1) extra memory.
Trace
🔎 Worked Walkthrough — row $i = 3, $n = 5
Trace row 3 to see left and right edge loops form 3 3.
| Phase | Loop | Row so far |
|---|---|---|
| Left edge | $j=5..1, $i==3 at $j=3 | 3 |
| Right edge | $k=2..5, $i==3 at $k=3 | 3 3 |
Final row 3: 3 3. Then echo PHP_EOL moves to row 4.
Use Cases
Where this tiny pattern (and its loop structure) shows up beyond the homework prompt.
1. Teaching Left + Right Edges
Clearest visual proof that outer and inner bounds interact.
Example: use fgets(STDIN) for dynamic rows — see Example 2.
2. Left/Right Split
Split each row into left half ($j=$n..1) and right half ($k=2..$n) for edge control.
Example: trace row 3 with n=5 — left prints 3 at column 3, right at column 5.
3. Console Formatting Drills
Practice echo PHP_EOL vs echo for multi-line vs same-line output.
Example: use string concatenation for clean rows — see Example 3.
4. Hollow Shape
Only edge positions print digits — interior stays empty for the hollow effect.
Example: row 4 reads 4 4 — two fours at the edges.
5. Complexity Intuition
Each row scans O(n) positions — total work grows as n².
Example: count columns on row 5 → 2×5-1 = 9 character positions per row.
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
Missing right edge loop shows immediately — only left digits appear.
2. Minimal Concepts
Only loops and console output — no arrays or math libraries.
3. Easy to Extend
Change
$n, usefgets(STDIN), mirror into a diamond (Program 58), or build rows with a$rowstring.4. O(1) Extra Memory
Streaming output needs no storage beyond loop counters.
Pro Tip: learn the two-loop row (left edge, right edge) first; then try fgets(STDIN) input and the $row string variant in Example 3.
Usage Tips
Small habits that keep number-pattern code clean.
1. Name Variables Clearly
Use
nfor height andi/j/kfor loop 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 loops for row
$i, then callecho PHP_EOL.4. Start Right Loop at k = 2
Starting at
k = 1duplicates the center on row 1 — usek = 2to skip overlap.5. Dry-Run One Small Row Count
Trace
$n = 5, $i = 3on paper — expect3 3with spaces between edges.
Pro Tip: if row 1 shows two digits, check whether the right loop starts at k = 2.
Common Pitfalls
Mistakes that commonly break hollow number pyramid patterns.
1. echo PHP_EOL Inside an Inner Loop
Each number lands on its own line — you get a vertical stack, not a centered pyramid row.
→ Use
echoinside left and right edge loops;echo PHP_EOLonly after they finish.2. Forgetting the Right Edge Loop
Without the
k = 2..nloop, only the left edge prints — no right-side digit.→ Add the right loop:
for ($k = 2; $k <= $n; $k++)with$i == $kcondition.3. Forgetting the Row Break
Omitting
echo PHP_EOLafter both edge loops glues all rows onto one line.→ Always call
echo PHP_EOLafter left and right edge loops complete.4. Right Loop Starts at $k = 1
Starting
$k = 1duplicates the center on row 1 — use$k = 2instead.→ Start the right half at
$k = 2to skip the overlapping center column.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
$nbreaks dynamic input.→ Use one
$nvariable for outer loop and both inner loop bounds.
Edge Cases
Check these inputs before calling the solution done.
n = 1
Single line
Output is one line: 1 — right edge overlaps left on the single column.
n = 0
Empty pattern
Loop never runs — print nothing or show a message.
Negative
$n < 0
Treat as invalid; re-prompt instead of silent empty output.
Large n
Large n
Large values produce wide rows — fine for labs; use smaller n for quick demos.
Bad input
Non-numeric fgets(STDIN) input
Unchecked fgets(STDIN) input leaves $n unset — call is_numeric($input) first.
Compact
Single-line form
Use conditional spacing to avoid trailing spaces — see Example 3.
Drill
🎯 Practice Problems
Try these variations to lock in the pattern.
1. Change $n
- Try
$n = 3,6, or8 - Verify row
ishowsiat both edges
2. $row string rows
- Build each row without trailing spaces
- Compare echo-based vs
$rowstring output
3. Skip right loop
- Omit the right loop and see only left-edge digits
- Observe missing right edge
4. Next in series
- Continue with Program 58 hollow diamond
- Try n=6 and verify row 6 reads 6 at both ends with spaces between
Important
Notes
- Cell count. Each row spans
2n-1columns; only two (or one on row 1) print digits. echostays on the line;echo PHP_EOLadvances — mix them carefully.- Validate
$n > 0for interactive programs;$n = 1prints one digit where edges overlap. - Row logic: left loop
$j=$n..1, then right loop$k=2..$n, edge conditions only.
Quick Takeaway: outer $i=1..$n; left loop $j=$n..1; right loop $k=2..$n; then echo PHP_EOL.
Analysis
⏱️ Time and Space Complexity
| Program | Time | Extra space |
|---|---|---|
Fixed $n = 5 (Example 1) | O(n²) | O(1) |
| fgets(STDIN) input (Example 2) | O(n²) | O(1) |
| Compact rows (Example 3) | O(n²) | O(1) |
🎉 Conclusion
The hollow number pyramid combines left/right edge loops with space padding — a natural step after the palindromic pyramid in Program 56. Master the fixed-$n version first, then try fgets(STDIN) input and the compact $row string variant in Example 3.
Practice the three examples above, then continue to Program 58 for the hollow number diamond pattern.
Print edge digits only — spaces everywhere else — one echo PHP_EOL per outer iteration.
Pro Tips
💡 Best Practices
✅ Do
- Explain outer
i, left loop, and right loop before coding - Echo left edge, then right edge; then
echo PHP_EOL - Validate
$n ≥ 1for interactive programs - Check
fgets(STDIN)return value before using$n - State O(n²) time when asked about complexity
❌ Don’t
- Forget the right edge loop
- Start right loop at
k = 1(duplicates center on row 1) - Hard-code 5 instead of variable
$n - Ignore bad console input in user-facing demos
- Skip the
$n = 1edge case
Summary
Key Takeaways
Knowledge Unlocked
Five things to remember about this hollow number pyramid pattern
Print row number at left and right edges; spaces fill the hollow middle.
5
Core concepts 01
Rule
Row $i has 2 edge digits (1 when $i=1)
02
Outer loop
$i = 1..$n
Code 03
Edge loops
Left $j=$n..1, right $k=2..$n
Logic 04
Row length
2n-1 cols/row
05
Complexity
O(n²)
Analysis❓ Frequently Asked Questions
Row 2 places 2 at the left edge (when $i==$j) and again at the right edge (when $i==$k), with spaces between.
On row 1, the left and right edge conditions overlap at the same column — only one 1 appears.
Left loop $j=$n..1 prints $j when $i==$j (right-aligned). Right loop $k=2..$n prints $k when $i==$k (expanding outward).
Starting at 1 would duplicate the center column on row 1. $k=2 skips the overlap.
Yes. Use a variable $n in all loop bounds — the pyramid scales to $n rows.
After rows 1..$n, mirror rows $n-1..1 with the same edge logic — see Program 58.
O(n²) because each row scans about 2*$n-1 positions to decide number or space.
Use trim(fgets(STDIN)) and is_numeric($input) before casting to int.
Did you Know? 🔊
Each row prints the row number at the left and right edges only — everything between is spaces. Row 1 overlaps at one position; row 5 reads 5 5.
Continue to Program 58
Move on to the hollow number diamond pattern in the PHP number-pattern series.
About the author
12 people found this page helpful