Growing Reverse Number Triangle in PHP

Beginner
⏱️ 8 min read
📚 Updated: Aug 2026
🎯 3 Code Examples
🚀 Live Preview
Inner loop j=i…1

What You’ll Learn

The Growing Reverse Number Triangle prints 1, 21, 321, 4321, 54321 — row $i concatenates digits $i down to 1. This tutorial covers nested-loop logic, live preview, worked PHP examples, edge cases, and O(n²) complexity.

Shape Rule

i..1 per row

Row $i prints digits $i, …, 1 with no spaces (e.g. row 3 → 321).

Nested Loops

$i = 1..$rows

Outer loop picks row $i; inner loop runs $j = $i..1.

echo $j

No spaces

echo $j concatenates digits on the same row.

Foundation

Series base

Stepping stone toward Floyd’s triangle, stars, and alphabet patterns.

Live Preview

1–20 rows

Pick a row count and draw the ascending triangle instantly in the browser.

O(n²)

Complexity

Total digits ≈ n(n+1)/2 — quadratic time; extra memory stays O(1).

Introduction

A growing reverse number triangle pattern grows each row by one digit on the left: 1, 21, 321, up to 54321 for five rows. Row $i starts at $i and counts down to 1.

In PHP the outer loop runs $i = 1..$rows, the inner loop prints $j from $i down to 1, then echo PHP_EOL moves to the next line.

Why it matters?

It is a foundational nested-loop exercise — compare with Program 4 (fixed prefix descending) and continue to Program 8 (reverse growing number pattern).

Key Highlights

Counts down

Each row begins at digit $i and prints down to 1.

Growing rows

Inner loop $j = $i..1 lengthens each row.

vs Program 4

Program 5 inner loop ascends $j = 1..$i; Program 7 counts $j = $i..1 on each row.

Series Foundation

Compare Program 5 (ascending) and Program 6 (suffix); continue to Program 8 next.

In short: for each $i from 1 to $rows, print $j from $i down to 1, then echo PHP_EOL.

📝 Problem & Approach

Given a positive integer $rows (e.g. 5), print a growing reverse Number Triangle: row $i prints digits $i down to 1 with no spaces (e.g. row 3 → 321).

PHP
// $rows = 5 (conceptual shape)
for ($i = 1; $i <= $rows; $i++) {
    for ($j = $i; $j >= 1; $j--) {
        echo $j;          // digits i..1
    }
    echo PHP_EOL;         // next row
}

Inputs & Outputs

ItemTypeDescription
$rowsintNumber of triangle lines — outer loop runs from 1 up to $rows.
$iintOuter loop — current row index; sets where the inner loop stops.
$jintInner loop — descending from $i down to 1.

Minimal workflow

Pseudocode
for i from 1 to rows:
    for j from i down to 1:
        print j
    print newline

Approach comparison

ApproachIdeaBest for
Nested loops1, 21, 321, …Learning and interviews
User-input rowsfgets(STDIN);Flexible console programs
Spaced outputecho $j . " "Easier reading per row

⚡ Quick Reference

GoalPattern
Walk rowsfor ($i = 1; $i <= $rows; $i++)
Print digits $i..1for ($j = $i; $j >= 1; $j--) echo $j;
End the rowecho PHP_EOL;
Spaced digitsecho $j . " ";
User inputfgets(STDIN);
Program 4 contrastProgram 4 uses $j = $rows..$i (fixed prefix); Program 7 uses $j = $i..1

📋 Outer Loop vs Inner Loop vs Combined

How outer row selection and inner $j = $i..1 work together.

Outer loop
for ($i = 1; $i <= $rows; $i++)

Picks row number $i — triangle height.

Inner loop
for ($j = $i; $j >= 1; $j--)

Prints exactly $i digits on row $i.

Cell value
echo $j

Concatenate digits with no spaces — 123 not 1 2 3.

Learning tip
trace i=3

Dry-run row 3: $j = 3..1 → prints 321.

Context

When This Pattern Shows Up

Reach for this pattern when teaching nested loops, growing inner bounds, and concatenated digit output.

  1. After Program 4

    Natural follow-up after left-aligned descending triangles — now the prefix grows from 1.

  2. Nested-loop warm-up

    Outer/inner bound practice with an immediate visual check.

  3. Console I/O practice

    Combine loops with fgets(STDIN) for a flexible row count.

  4. Gateway to variants

    Compare with Program 4 (descending prefix), then continue to Program 8 (reverse growing number pattern).

  5. 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.

🔮 Live Preview

Enter a row count and draw the Growing Reverse Number Triangle in the browser.

Try 5, 7, or 10. Larger values still work up to 20.

Live result
Press "Draw pattern".

Examples Gallery

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

📚 Getting Started

Print five rows — inner loop prints $i..1 on each line.

Example 1 — Fixed $rows = 5

Hard-coded row count — inner loop prints from $i down to 1.

PHP
<?php
$rows = 5;

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

How It Works

When $i = 3, the inner loop prints 3, 2, 1 — output 321. When $i = 5, output is 54321.

📈 User Input

Read the row count with fgets(STDIN) instead of hard-coding 5.

Example 2 — User Input Version

Read $rows with fgets(STDIN); same nested loops as Example 1.

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 = $i; $j >= 1; $j--) {
        echo $j;
    }
    echo PHP_EOL;
}

How It Works

Same nested-loop core as Example 1; only the source of $rows changes.

⚡ Formatting Variant

Add spaces between digits for easier reading.

Example 3 — Spaced Output

Print a space after each digit with echo $j . " ".

PHP
<?php
$rows = 5;

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

How It Works

Same $j = $i..1 logic; only the output format adds spaces between digits.

🧠 How the Algorithm Prints Rows

1

Set up

echo is built in; use fgets(STDIN) when reading input. Set loop variables $i, $j with $rows = 5.

Setup
2

Outer loop walks rows

for ($i = 1; $i <= $rows; $i++) — each row adds one more digit.

Row
3

Inner loop (j)

for ($j = $i; $j >= 1; $j--) — prints digits from $i down to 1.

Inner
4

New line

echo PHP_EOL ends the row after the inner loop finishes.

Break
=

Growing reverse number triangle complete

Each row grows by one digit — O(n²) time, O(1) extra memory.

🔎 Worked Walkthrough — row $i = 3

Trace row 3 to see how the inner loop builds 321.

Row $i$j rangeOutput
111
22, 121
33, 2, 1321
44 … 14321
55 … 154321

After the inner loop, echo PHP_EOL moves to the next row.

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: flip j-- to j++ and compare with Program 5 and watch digit order change.

2. Pattern Series Base

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

Example: continue to Program 8 for the reverse growing pattern.

3. Console Formatting Drills

Practice echo vs echo PHP_EOL without complex math.

Example: put echo PHP_EOL inside the inner loop by mistake.

4. Spaced Output

Add spaces between digits once the two-loop structure works.

Example: use echo $j . " " between digits on each row.

5. Complexity Intuition

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

Example: count printed digits for $rows = 5 — total is 15 (5+4+3+2+1).

6. Input Validation Labs

Pair the pattern with fgets(STDIN) return checks 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. 1. Instant Visual Feedback

    Wrong bounds show up immediately as a broken staircase.

  2. 2. Minimal Concepts

    Only loops and console output — no arrays or math libraries.

  3. 3. Easy to Extend

    Invert, center, hollow, or change the fill character with small edits.

  4. 4. O(1) Extra Memory

    Streaming output needs no storage beyond loop counters.

Pro Tip: trace $i and $j on paper for $rows = 3 before coding — watch how each row grows by one digit.

Usage Tips

Small habits that keep number-pattern code clean.

  1. 1. Match Inner Bounds

    Outer loop counts up; inner loop must run $j = $i..1 for the ascending prefix.

  2. 2. Prefer fgets(STDIN)

    Call is_numeric($input) so bad input does not leave $rows uninitialized.

  3. 3. Keep echo PHP_EOL Outside

    Only call echo PHP_EOL after the inner loop finishes the row.

  4. 4. Use echo $j for Digits

    for ($j = $i; $j >= 1; $j--) echo $j concatenates digits on one line.

  5. 5. Dry-Run $rows = 3

    Trace $i = 1, 2, 3 on paper before coding the full $rows = 5 demo.

Pro Tip: if the output is a vertical list of single digits per line, you almost certainly put echo PHP_EOL inside the inner loop.

Common Pitfalls

Mistakes that commonly break Growing Reverse Number Triangle patterns.

  1. 1. Newline Inside the Inner Loop

    Each digit lands on its own line — you get a column, not a triangle.

    → Use echo $j for digits; echo PHP_EOL only after the inner loop.

  2. 2. wrong inner direction (j++ from 1)

    Every row prints $rows digits — you get a rectangle, not a growing triangle.

    → Keep for ($j = $i; $j >= 1; $j--) so row length equals $i.

  3. 3. Descending Inner Loop

    for ($j = $i; $j >= 1; $j--) reverses digit order — still a triangle, but not 1, 21, 321.

    → Use ascending inner loop $j = $i..1 for the standard pattern.

  4. 4. Inner Starts at rows

    $j = $rows..$i produces Program 4’s fixed-prefix shape — not this pattern.

    → Use $j = $i..1 here — Program 4 uses $j = $rows..$i.

  5. 5. Unchecked fgets(STDIN) input

    Letters or empty input leave $rows uninitialized.

    → Call is_numeric($input) and re-prompt on failure.

Edge Cases

Check these inputs before calling the solution done.

rows = 1

Single digit row

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.

rows = 2

Smallest triangle

Two rows: 1 and 21.

Bad input

Non-numeric fgets(STDIN) input

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

Large rows

Large row count

Each row prints $i digits — total work grows as n(n+1)/2.

🎯 Practice Problems

Try these variations to lock in the pattern.

1. Compare Program 4

  • Program 4: fixed prefix 54321, 5432…
  • Review Program 4

2. Invert outer loop

  • Use for ($i = $rows; $i >= 1; $i--)
  • Same inner loop — tallest row first

3. Next in series

  • Continue with Program 8
  • Reverse growing pattern 5, 54, 543…

4. Spaced output

  • Use echo $j . " " between digits
  • Same loops, wider visual spacing

Notes

  • Descending inner loop. Outer loop: $i = 1..$rows. Inner loop: $j = $i..1 with echo $j.
  • 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.
  • Row $i prints exactly $i digits — compare with Program 4 where each row prints $rows - $i + 1 digits.

Quick Takeaway: outer loop $i = 1..$rows, inner loop $j = $i..1 with echo $j, then echo PHP_EOL.

⏱️ Time and Space Complexity

ProgramTimeExtra space
Nested loops (Examples 1–3)O(n²)O(1)
Spaced output (Example 3)O(n²)O(1)
Wrap Up

🎉 Conclusion

The Growing Reverse Number Triangle is a compact nested-loop lesson: outer loop grows rows while the inner loop prints digits $i down to 1. Master the fixed-$rows version, then try user input and spaced output.

Practice the three examples above, then continue to Program 8 for the reverse growing number pattern (5, 54, 543, 5432, 54321).

Row $i prints $i..1 — keep echo $j for digits and echo PHP_EOL for the row break.

💡 Best Practices

✅ Do

  • Use for ($i = 1; $i <= $rows; $i++) in the outer loop
  • Inner: for ($j = $i; $j >= 1; $j--) prints digits i..1
  • Use echo $j for digits and echo PHP_EOL after each row
  • Validate $rows ≥ 1 for interactive programs
  • Call is_numeric($input) before using $rows

❌ Don’t

  • Call echo PHP_EOL inside the inner digit loop
  • Use j++ from 1 when you meant Program 5 — this pattern needs j-- from $i
  • Forget echo PHP_EOL inside the inner loop — digits must stay on one row
  • Ignore bad console input in user-facing demos
  • Skip the $rows = 1 edge case

Key Takeaways

Knowledge Unlocked

Five things to remember about this growing reverse number triangle

Print the pattern the beginner-friendly way.

5
Core concepts
02

Outer loop

Counts up $rows

Code
03

Inner loop

$j = $i down to 1

Code
04

Newline

Ends each row

Shape
O 05

Complexity

O(n²) time

Analysis

❓ Frequently Asked Questions

Each row must print digits from $i down to 1. Using $j-- after starting at $j = $i gives 321 on row 3 instead of 123.
The outer loop runs $i from 1 to $rows. For each row $i, the inner loop runs $j from $i down to 1 and echoes $j, then echo PHP_EOL ends the row.
Program 5 prints 1, 12, 123 (inner loop $j = 1..$i ascending). Program 7 prints 1, 21, 321 (same outer loop, inner loop $j = $i..1 descending).
Program 6 uses a descending outer loop and prints 5, 45, 345 (inner $j = $i..$rows). Program 7 uses an ascending outer loop and counts $j down on each row (1, 21, 321).
Yes. Use echo $j . " " inside the inner loop — see Example 3.
O(n²) for n rows. Total printed digits are 1+2+...+n = n(n+1)/2.
Use trim(fgets(STDIN)) and is_numeric($input) before casting to int.
The outer loop never runs, so nothing is printed. Validate and prompt again if you want a clear user message.

Did you Know? 🔊

Outer loop grows row index $i; inner loop prints $j from $i down to 11, 21, 321, … O(n²) for $n rows.

Continue to Program 8

Move on to the reverse growing number pattern in the PHP number-pattern series.

Program 8 tutorial →

About the author

Mari Selvan M P
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.

12 people found this page helpful