Continuous Number Triangle Pattern in PHP

Beginner

⏱️ 8 min read

📚 Updated: Aug 2026

🎯 3 Code Examples

🚀 Live Preview

Running Counter

Continuous number triangle output (1, 2 3, 4 5 6, 7 8 9 10) in PHP programming

Overview

What You’ll Learn

The continuous number triangle uses a running counter k so digits keep increasing across rows — a natural step after the fill-with-5 pattern in Program 19. This tutorial covers the shape rule, counter logic, a live preview, algorithm steps, worked PHP examples, edge cases, and complexity.

Shape Rule

Continuous k++

Row 1 prints 1, row 2 prints 2 3, row 3 prints 4 5 6, and so on without restarting.

Outer Loop

1..rows

for ($i = 1; $i <= $rows; $i++) makes row i print i numbers.

Counter k

k++ each print

echo $k++ . " " prints k then increments — value carries to the next row.

echo vs PHP_EOL

Same line / next line

Numbers use echo $k++ . " "; end each row with echo PHP_EOL.

Live Preview

1–15 rows

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

O(n²)

Complexity

Total prints = rows(rows+1)/2; extra memory stays O(1).

Introduction

A continuous number triangle prints an ascending counter across rows — numbers never restart at 1 on each new line. With rows = 4, the output is 1, 2 3, 4 5 6, 7 8 9 10.

In PHP you declare $k = 1 once, print $k++ in the inner loop for i iterations per row, then echo PHP_EOL ends each row.

Why it matters?

It introduces a running counter variable — a key step after Program 19 and before jump-number patterns.

Key Highlights

Counter k

Declare $k = 1 once before both loops.

k++

Print then increment — sequence continues across rows.

Print Then Break

echo $k++ . " " in the inner loop; echo PHP_EOL after.

Series Foundation

Follow Program 19; continue to Program 21 (jump number triangle).

In short: set k = 1 once, for each row i print k++ for i numbers, then call echo PHP_EOL.

Foundation

📝 Problem & Approach

Given a positive integer rows, print a continuous number triangle: row i prints i numbers from a running counter k that starts at 1 and increments with k++ on every print.

PHP

// rows = 4 (conceptual shape)
// 1
// 2 3
// 4 5 6
// 7 8 9 10

Inputs & Outputs

Item	Type	Description
`rows`	int	Number of triangle lines to print (typically ≥ 1).
`$k`	int	Running counter — declared once, incremented each print.
Printed output	text	Row `i` has `i` spaced numbers — continuous sequence.

Minimal workflow

Pseudocode

k = 1
for i from 1 to rows:
    for j from 1 to i:
        print k then k++
    print newline

Approach comparison

Approach	Idea	Best for
Running counter k++	1, 2 3, 4 5 6, …	Learning and interviews
User-input rows	`(int) trim(fgets(STDIN));`	Flexible console programs
Custom start k	`$k = 10` before loops	Shift the whole sequence

Cheat Sheet

⚡ Quick Reference

Goal	Pattern
Walk each row	`for ($i = 1; $i <= $rows; $i++)`
Init counter	`int k = 1;` before both loops
Print and step	`echo $k++ . " ";`
End the row	`echo PHP_EOL;`
Custom start	`int k = 10;` to shift sequence
User input	`(int) trim(fgets(STDIN));`

Compare

📋 k++ vs Custom Start vs User Input

Same continuous triangle — different ways to control the counter.

k++

counter

Print k then increment — sequence continues

Declare once

$k = 1

Before both loops — not inside outer loop

Custom k

$k = 10

Shift start value in Example 3

Learning tip

no reset

Do not reset k each row for continuous output

Context

When This Pattern Shows Up

Reach for this pattern when teaching running counters and continuous sequences inside nested loops.

First lab exercise
Natural follow-up after Program 19 — introduces a single running counter.
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 Program 19 (fill-with-5) and Program 21 (jump number triangle) next.
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 15 and draw the continuous number triangle in the browser.

Hands-On

Examples Gallery

Three complete PHP programs — fixed row count, user input, and custom start value for $k. Click View Output to reveal sample console results.

📚 Getting Started

Print four rows of the continuous counter triangle with k++.

Example 1 — Fixed `rows = 4`

Hard-coded height — ideal for first demos and screenshots.

PHP

<?php
$rows = 4;
$k = 1;

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

How It Works

When i = 1, $k prints once as 1. When i = 2, $k prints 2 then 3. When i = 4, $k runs from 7 to 10 — the counter never resets. echo PHP_EOL after the inner loop starts the next row.

📈 User Input

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

Example 2 — User Input

Read rows with (int) trim(fgets(STDIN)); $k still starts at 1.

PHP

<?php
echo "Enter the number of rows: ";
$rows = (int) trim(fgets(STDIN));
$k = 1;

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

How It Works

Same nested-loop core as Example 1; only the source of rows changes. $k is still declared once before the loops. Non-numeric input leaves rows unset if you ignore fgets(STDIN)’s return value — always check it in safer labs.

⚡ Custom Start

Start the counter from a value other than 1.

Example 3 — Custom Start `k = 10`

Shift the whole sequence by starting k at 10 instead of 1.

PHP

<?php
$rows = 4;
$k = 10;

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

How It Works

Change only the initial value of k — the inner loop and k++ logic stay the same. The sequence continues from 10 instead of 1.

🧠 How the Algorithm Prints Rows

Set up

Set $rows = 4; and use fgets(STDIN) when reading input. Set rows (fixed or from input) and $k = 1.

Setup

Outer loop (row width)

for ($i = 1; $i <= $rows; $i++) makes row i print i numbers.

Row

Inner loop + k++

echo $k++ . " " prints k then increments — value carries to the next row.

Sequence

New line

echo PHP_EOL ends the row so the next outer iteration starts fresh.

Break

Continuous triangle complete

Total prints: rows(rows+1)/2 — O(n²) time, O(1) extra memory.

Trace

🔎 Worked Walkthrough — `rows = 4`

Trace each outer-loop value of i, the starting k, and the numbers printed on each row.

`i`	Start `k`	Numbers printed	Row output
`1`	1	`1`	`1`
`2`	2	`2, 3`	`2 3`
`3`	4	`4, 5, 6`	`4 5 6`
`4`	7	`7, 8, 9, 10`	`7 8 9 10`

Total number prints: 1 + 2 + 3 + 4 = 10 = 4×5/2.

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 <= i and watch the shape change.

2. Pattern Series Base

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

Example: use (i + j) % 2 for row+column parity grids.

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: print j + " " for spaced digits on each row.

5. Complexity Intuition

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

Example: count printed digits for n = 10 still → 55.

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 C 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: learn k = 1 before the loops first; compare with custom start in Example 3.

Usage Tips

Small habits that keep number-pattern code clean.

1. Name Bounds Clearly
Declare k once before both loops — not inside the outer loop.
2. Prefer is_numeric()
Call is_numeric(trim($line)) so bad input does not leave rows uninitialized.
3. Keep echo PHP_EOL Outside
Only call echo PHP_EOL after the inner loop finishes the row.
4. Trace k on Paper
Write row i, start $k, and each $k++ step before coding.
5. Dry-Run One Small n
Trace rows = 4 on paper before coding larger demos.

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 continuous number patterns.

1. Newline Inside the Inner Loop
Each digit lands on its own line — you get a column, not a triangle.
→ Use echo $k++ . " "; echo PHP_EOL only after the inner loop.
2. Declaring k Inside the Outer Loop
$k resets each row and the sequence restarts at 1.
→ Declare int k = 1; once before both loops.
3. Using k++ After Newline
Incrementing in the wrong place skips or duplicates numbers.
→ Use post-increment inside echo $k++ . " ".
4. Forgetting the Row Break
Omitting echo PHP_EOL glues every number onto one endless line.
→ Always end the row after the inner loop.
5. Unchecked CLI input
Letters or empty input leave rows uninitialized.
→ Prefer is_numeric(trim($line)) and re-prompt on failure.

Edge Cases

Check these inputs before calling the solution done.

rows = 1

Single digit

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

Large width

Output grows as n² characters — fine for labs, noisy for huge n.

Bad input

Non-numeric CLI input

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

k inside loop

k resets each row

Declaring $k inside the outer loop restarts the sequence — not continuous.

No reset

Forgot k++

Without $k++, the same number prints repeatedly on each row.

Drill

🎯 Practice Problems

Try these variations to lock in the pattern.

1. Fill-with-5 triangle

Two inner loops with sequence + padding
Review Program 19

2. Jump number triangle

Decreasing step variable per row
Continue with Program 21

3. Reset k each row

Declare k inside outer loop
Compare output — rows restart at 1

4. No trailing space

Print space only between numbers, not after the last
Harder follow-up after this page

Important

Notes

Triangular sum. Total prints = rows(rows+1)/2 — O(n²) for n rows.
echo $k++ . " " stays on the line; echo PHP_EOL advances — mix them carefully.
Validate rows > 0 for interactive programs; rows = 1 should print a single 1.
This page is left-aligned. Centered pyramids need leading spaces — covered later in the series.

Quick Takeaway: declare $k = 1 once, print k++ for i numbers per row, then break the line.

Analysis

⏱️ Time and Space Complexity

Program	Time	Extra space
Nested loops (Examples 1–2)	`O(rows²)`	`O(1)`
Custom start (Example 3)	`O(rows²)`	`O(1)`

Wrap Up

🎉 Conclusion

The continuous number triangle is a compact lesson in running counters: declare $k once, print k++ in the inner loop, and let the sequence continue across rows. Master the fixed-rows version, then try user input and a custom start value.

Practice the three examples above, then continue to Program 21 for the jump number triangle.

Keep $k outside the outer loop — use k++ inside echo $k++ . " " and validate rows when reading input.

View Examples Gallery Continue to Program 21

Pro Tips

💡 Best Practices

✅ Do

Explain $k = 1 before both loops
Use echo $k++ . " " in the inner loop
Validate rows ≥ 1 for interactive programs
Call is_numeric(trim($line)) before using rows
State O(n²) time when asked about complexity

❌ Don’t

Call echo PHP_EOL inside the inner digit loop
Declare k inside the outer loop
Forget $k++ after each print
Skip the newline after each row
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 continuous pattern

Print the pattern the beginner-friendly way.

Core concepts

△ 01

Rule

k++ continuous

Definition

↻ 02

Declare k

Once before loops

Code

+ 03

k++

Print then increment

Code

↑ 04

Grow width

Row i prints i nums

Shape

O 05

Complexity

O(n²) time

Analysis

❓ Frequently Asked Questions

Why do numbers continue across rows instead of restarting?

Because $k is declared once ($k = 1) before the loops and incremented with $k++ every time a number is printed — its value carries over to the next row.

Why does the second row print 2 3?

Row 1 prints 1, so $k becomes 2. Row 2 prints $k twice: 2, then 3 after $k++.

What happens if I declare $k inside the outer loop?

$k resets each row and the sequence restarts at 1 — you get a growing triangle, not a continuous counter.

What is the difference between echo and PHP_EOL?

echo $k++ . " " stays on the same line with a trailing space. echo PHP_EOL ends the current line. Numbers use echo; the row break uses echo PHP_EOL after the inner loop.

How many numbers are printed for n rows?

Total prints are 1+2+...+n = n(n+1)/2.

Can I start $k from a different value?

Yes. Set $k = 10 (or any value) before the loops — the sequence continues from that start (see Example 3).

What is the time complexity?

O(n²) for n rows because total digit prints equal n(n+1)/2.

How should I read rows safely?

Use trim(fgets(STDIN)) and check is_numeric($input) before casting to int — see Example 2 notes.

What happens if rows is 0 or negative?

The outer loop never runs, so nothing is printed. Validate and prompt again if you want a clear user message.

Did you Know? 🔊

A single counter k starts at 1 and increments with k++ on every print — numbers continue across rows instead of restarting. Total prints still equal n(n+1)/2 for n rows.

Continue to Program 21

Move on to the jump number triangle in the PHP number-pattern series.

Program 21 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 19 — Fill with 5 Triangle PHP Number Pattern 21 — Jump Number Triangle

Continuous Number Triangle Pattern in PHP

What You’ll Learn

Shape Rule

Outer Loop

Counter k

echo vs PHP_EOL

Live Preview

O(n²)

Introduction

Why it matters?

Counter k

k++

Print Then Break

Series Foundation

📝 Problem & Approach

Inputs & Outputs

Minimal workflow

Approach comparison

⚡ Quick Reference

📋 k++ vs Custom Start vs User Input

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 = 4

How It Works

📈 User Input

Example 2 — User Input

How It Works

⚡ Custom Start

Example 3 — Custom Start k = 10

How It Works

🧠 How the Algorithm Prints Rows

Set up

Outer loop (row width)

Inner loop + k++

New line

Continuous triangle complete

🔎 Worked Walkthrough — rows = 4

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 is_numeric()

3. Keep echo PHP_EOL Outside

4. Trace k on Paper

5. Dry-Run One Small n

Common Pitfalls

1. Newline Inside the Inner Loop

2. Declaring k Inside the Outer Loop

3. Using k++ After Newline

4. Forgetting the Row Break

5. Unchecked CLI input

Edge Cases

Single digit

Empty pattern

rows < 0

Large width

Non-numeric CLI input

k resets each row

Forgot k++

🎯 Practice Problems

1. Fill-with-5 triangle

2. Jump number triangle

3. Reset k each row

Example 1 — Fixed `rows = 4`

Example 3 — Custom Start `k = 10`

🔎 Worked Walkthrough — `rows = 4`

2. Prefer `is_numeric()`

`rows < 0`