Right-Aligned Incremental Number Triangle in PHP

Beginner

⏱️ 9 min read

📚 Updated: Aug 2026

🎯 3 Code Examples

🚀 Live Preview

Counter + Formatting

Right-aligned incremental number triangle output in PHP (1, 2 3, 4 5 6, ...)

Overview

What You’ll Learn

The right-aligned incremental triangle prints 1, then 2 3, then 4 5 6, … — a natural follow-up after Program 34’s zero-based $i + $j triangle. This tutorial covers the continuous counter $k, fixed-width formatting, nested loops, a live preview, worked PHP examples, edge cases, and complexity.

Shape Rule

Right-aligned triangle

Row $i prints $i numbers from counter $k, with leading spaces while $j > $i.

Outer Loop

$i = 1..$rows

for ($i = 1; $i <= $rows; $i++) — one growing row per iteration.

Inner Loop (j)

$rows..1

for ($j = $rows; $j >= 1; $j--) — fixed width; spaces or numbers per column.

Counter $k

%3d format

printf("%3d", $k++) — continuous sequence with fixed-width columns.

Live Preview

3–7 rows

Pick a row count and draw the right-aligned incremental triangle in the browser.

O(n²)

Complexity

Total prints = n(n+1)/2 — work scales as n².

Introduction

A right-aligned incremental number triangle prints a continuous sequence: 1, then 2 3, then 4 5 6, and so on. With $rows = 5, numbers shift right each row thanks to leading spaces.

In PHP you use nested loops with a counter $k: print " " while $j > $i, otherwise printf("%3d", $k++), then echo PHP_EOL.

Why it matters?

It combines nested loops, a running counter, and formatted output — a step after Program 34’s formula-based triangle.

Key Highlights

Counter $k

Continuous sequence.

$j > $i spaces

Right alignment.

%3d

Fixed-width columns.

Series Foundation

Follow Program 34; continue to Program 36 (decreasing) next.

In short: outer $i = 1..$rows, inner $j = $rows..1, spaces while $j > $i, else %3d with $k++, then echo PHP_EOL.

Foundation

📝 Problem & Approach

Given $rows = 5, print a right-aligned incremental triangle: counter $k starts at 1, leading spaces while $j > $i, then fixed-width numbers.

PHP

// $rows = 5
//              1
//           2  3
//        4  5  6
//     7  8  9 10
//11 12 13 14 15

Inputs & Outputs

Item	Type	Description
`$rows`	int	Triangle height — number of lines to print.
`$i`	int	Outer loop — current row (1 to $rows).
`$j`	int	Inner loop — fixed width from `$rows` down to 1.
`$k`	int	Continuous counter — starts at 1, increments per printed number.

Minimal workflow

Pseudocode

k = 1
for i from 1 to rows:
    for j from rows down to 1:
        if j > i: print 3 spaces
        else: print k in width 3; k++
    print newline

Approach comparison

Approach	Idea	Best for
Fixed rows	`1`, `2 3`, …	Learning and interviews
User-input rows	`(int) trim(fgets(STDIN));`	Configurable triangle size
Compact trace	`$rows = 3` on paper first	Debugging loop bounds

Cheat Sheet

⚡ Quick Reference

Goal	Pattern
Outer loop	`for ($i = 1; $i <= $rows; $i++)`
Inner loop	`for ($j = $rows; $j >= 1; $j--)`
Leading spaces	`if ($j > $i) echo " ";`
Print number	`printf("%3d", $k++);`
End the row	`echo PHP_EOL;`
User input	`(int) trim(fgets(STDIN));`

Compare

📋 Fixed vs User Input vs Compact Demo

Same right-aligned incremental triangle — different ways to control the row count.

Outer loop

$i = 1..$rows

One growing row per iteration

Counter

$k++

Continuous sequence

Inner loop

$j = $rows..1

Fixed width per row

Learning tip

$j > $i

Print spaces, else number

Context

When This Pattern Shows Up

Reach for this pattern when teaching formatted console output, continuous counters, and right-aligned triangles.

After Program 34
Natural follow-up — adds right alignment and a continuous counter instead of a per-cell formula.
Formatted output drills
Practice %3d and fixed-width columns before tackling larger patterns.
Console I/O practice
Combine loops with fgets(STDIN) and is_numeric() checks for flexible row counts.
Gateway to variants
Compare Program 30 (descending digits) and Program 36 (decreasing sequence) 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, formatted output, and O(n²) thinking.

Interactive

🔮 Live Preview

Choose a row count between 3 and 7 and draw the right-aligned incremental triangle in the browser.

Hands-On

Examples Gallery

Three complete PHP programs — fixed rows, user input, and a smaller trace demo. Click View Output to reveal sample console results.

📚 Getting Started

Print five rows of the right-aligned incremental triangle with counter $k and %3d formatting.

Example 1 — Fixed `$rows = 5`

Hard-coded row count — ideal for first demos and screenshots.

PHP

<?php
$k = 1;

for ($i = 1; $i <= 5; $i++) {
    for ($j = 5; $j >= 1; $j--) {
        if ($j > $i) {
            echo "   ";
        } else {
            printf("%3d", $k++);
        }
    }
    echo PHP_EOL;
}

How It Works

When $i = 1, the inner loop prints four space groups then 1. When $i = 5, no leading spaces — output 11 12 13 14 15 with fixed-width columns.

📈 User Input

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

Example 2 — User input rows

Read $rows with (int) trim(fgets(STDIN)); the inner loop uses $rows as the fixed width.

PHP

<?php
echo "Enter rows: ";
$input = trim(fgets(STDIN));
if (!is_numeric($input)) return;
$rows = (int) $input;
if ($rows < 1) return;

$k = 1;
for ($i = 1; $i <= $rows; $i++) {
    for ($j = $rows; $j >= 1; $j--) {
        if ($j > $i) {
            echo "   ";
        } else {
            printf("%3d", $k++);
        }
    }
    echo PHP_EOL;
}

How It Works

Same counter and formatting core as Example 1; only $rows comes from user input instead of being hard-coded as 5. Non-numeric input leaves $rows unset if you skip is_numeric() checks — always check it in safer labs.

⚡ Smaller Demo

Run with $rows = 3 to trace every row on paper before scaling up.

Example 3 — Compact `$rows = 3`

Same nested-loop counter with a smaller row count for quick tracing.

PHP

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

for ($i = 1; $i <= $rows; $i++) {
    for ($j = $rows; $j >= 1; $j--) {
        if ($j > $i) {
            echo "   ";
        } else {
            printf("%3d", $k++);
        }
    }
    echo PHP_EOL;
}

How It Works

Only $rows changes from 5 to 3 — the counter and spacing logic stays identical. Trace $i = 1, 2, 3 on paper to see how leading spaces shrink each row.

🧠 How the Algorithm Prints Rows

Set up

Set $k = 1; and $rows = 5;. Use fgets(STDIN) when reading input. Set loop variables $i, $j.

Setup

Outer loop walks rows

for ($i = 1; $i <= $rows; $i++) — ascending outer loop; one right-aligned row per iteration.

Row

Inner loop (j)

for ($j = $rows; $j >= 1; $j--) — fixed width; spaces while $j > $i, else print $k.

Width

Print counter

printf("%3d", $k++) — fixed-width columns; counter continues across rows.

Counter

New line

echo PHP_EOL ends the row after the inner loop finishes.

Break

Right-aligned triangle complete

Total numbers = n(n+1)/2 — O(n²) time, O(1) extra memory.

Trace

🔎 Worked Walkthrough — `$rows = 5`

Trace each outer-loop value of $i, leading spaces, numbers printed from $k, and full row output.

`$i`	Leading space groups	Numbers printed	Row output
`1`	4	`1`	`1`
`2`	3	`2, 3`	`2 3`
`3`	2	`4, 5, 6`	`4 5 6`
`4`	1	`7, 8, 9, 10`	`7 8 9 10`
`5`	0	`11, 12, 13, 14, 15`	`11 12 13 14 15`

Leading space groups per row = $rows - $i — zero when $i = $rows. Total numbers printed = $rows($rows+1)/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: flip $j > $i to $j <= $i for spaces and watch alignment break.

2. Pattern Series Base

Foundation for right-aligned variants and continuous counter patterns.

Example: compare with Program 30 (descending digits) and Program 36 (decreasing sequence).

3. Console Formatting Drills

Practice %3d formatting and fixed-width columns.

Example: remove %3d and watch two-digit values misalign.

4. Padding character

Add three-space groups for alignment once the two-loop structure works.

Example: use a single space instead of " " and watch columns drift.

5. Complexity Intuition

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

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

6. Input Validation Labs

Pair the pattern with is_numeric($input) checks and positive-row validation.

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 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, and $k on paper for $rows = 3 before coding — watch how leading spaces shrink each row.

Usage Tips

Small habits that keep number-pattern code clean.

1. Declare $k Outside Loops
Counter $k must start at 1 before the outer loop and persist across rows.
2. Call is_numeric($input)
Avoid undefined behavior when the user types letters instead of a number.
3. Keep newline outside inner loop
Only call echo PHP_EOL after the inner loop finishes the row.
4. Trace $k on Paper
Write the next value of $k for each ($i, $j) pair before coding the loops.
5. Dry-Run $rows = 3
Trace $i = 1..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 right-aligned incremental triangles.

1. Newline Inside the Inner Loop
Each digit lands on its own line — you get a column, not a triangle.
→ Use printf("%3d", $k++); echo PHP_EOL only after the inner loop.
2. Resetting $k Each Row
Putting $k = 1 inside the outer loop restarts the sequence on every row.
→ Declare $k = 1 once before the outer loop; only increment with $k++ when printing.
3. Wrong Space Width
Single spaces instead of " " break column alignment with %3d.
→ Print three spaces while $j > $i to match the fixed-width number columns.
4. Skipping %3d
Plain echo $k++ makes two-digit values crowd earlier columns.
→ Use printf("%3d", $k++) for consistent column width.
5. Unchecked CLI input
Letters or empty input leave $rows uninitialized or unchanged.
→ Call is_numeric($input) and re-prompt on failure.

Edge Cases

Check these inputs before calling the solution done.

$rows = 1

Single row

Output is just 1 with leading spaces — one value, one row.

$rows = 0

Empty pattern

Outer loop never runs when $rows < 1 — print nothing or show a message.

Negative

`$rows < 1`

Treat as invalid; re-prompt instead of silent empty output.

$rows = 2

Smallest triangle

Two rows: 1 and 2 3.

Bad input

Non-numeric CLI input

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

Large rows

Large row count

Total numbers = $rows($rows+1)/2 — grows quadratically with rows.

Drill

🎯 Practice Problems

Try these variations to lock in the pattern.

1. Decreasing sequence

Continue with Program 36
Right-aligned triangle with decreasing numbers

2. Descending digits

Review Program 30
Same $j > $i spacing, different fill

3. Counter trace

Prove on paper: after row $i, $k = $i($i+1)/2 + 1
Each row adds $i more numbers

4. Safe input loop

Call is_numeric($input) until $rows >= 1
Then draw the triangle

Important

Notes

Counter rule. Declare $k = 1 before loops. Inner loop runs $j = $rows..1 — print spaces while $j > $i, else %3d with $k++.
printf("%3d", $k++) stays on the line; echo PHP_EOL advances — mix them carefully.
Validate $rows >= 1 for interactive programs; $rows = 1 prints a single 1.
Leading space groups = $rows - $i — compare with Program 30 where digits descend instead of a counter.

Quick Takeaway: outer $i = 1..$rows, inner $j = $rows..1, spaces while $j > $i, else %3d with $k++, then echo PHP_EOL.

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 right-aligned incremental number triangle is a compact lesson in nested loops, continuous counters, and formatted output: print spaces while $j > $i, use printf("%3d", $k++) for each number, and end each row with echo PHP_EOL. Master the fixed-$rows version, then try user input and a smaller trace demo.

Practice the three examples above, then continue to Program 36 for the decreasing right-aligned sequence.

Keep $k outside the outer loop — validate $rows when reading from the console.

View Examples Gallery Continue to Program 36

Pro Tips

💡 Best Practices

✅ Do

Use for ($i = 1; $i <= $rows; $i++) in the outer loop
Inner: for ($j = $rows; $j >= 1; $j--) with fixed width
Counter: printf("%3d", $k++)
Call is_numeric($input) instead of ignoring bad input
State O(n²) time when asked about complexity

❌ Don’t

Call echo PHP_EOL inside the inner loop
Reset $k = 1 inside the outer loop
Use single spaces instead of " " for alignment
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 right-aligned triangle

Print the pattern the beginner-friendly way.

Core concepts

△ 01

Counter $k

$k++ each print

Definition

↻ 02

$j > $i

Leading spaces

Code

0 03

%3d

Fixed width

Code

↓ 04

Row break

echo PHP_EOL after $j loop

Shape

O 05

Complexity

O(n²) time

Analysis

❓ Frequently Asked Questions

What does incremental number triangle mean?

Numbers keep increasing across rows without resetting — row 1 prints 1, row 2 prints 2 3, row 3 prints 4 5 6, and so on.

How is the triangle right-aligned?

Before printing numbers on each row, the program prints three spaces while $j > $i. This indents the left side so numbers shift right.

Why use %3d in printf?

The format specifier reserves 3 columns per number (right-aligned), keeping columns aligned when values become two digits.

Why doesn't $k reset each row?

$k is declared outside the loops and increments with $k++ each time a number prints, so the sequence continues across rows.

How is this different from Program 30?

Program 30 prints descending digits per row. Program 35 uses a continuous counter $k with fixed-width formatting.

How do I change the number of rows?

Replace 5 with $rows in the outer loop bound — see Example 2.

What is the time complexity?

O(n²) for n rows because total prints are 1 + 2 + ... + n = 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 when rows is 1?

Only one row prints — a single 1 with leading spaces.

Did you Know? 🔊

A counter $k starts at 1 and increments every time a number is printed. Leading spaces appear while $j > $i, and printf("%3d", $k++) keeps columns aligned as values grow past single digits.

Continue to Program 36

Move on to the right-aligned decreasing number sequence in the PHP number-pattern series.

Program 36 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 34 — Increasing Triangle from 0 PHP Number Pattern 36 — Right-Aligned Decreasing Triangle

Right-Aligned Incremental Number Triangle in PHP

What You’ll Learn

Shape Rule

Outer Loop

Inner Loop (j)

Counter $k

Live Preview

O(n²)

Introduction

Why it matters?

Counter $k

$j > $i spaces

%3d

Series Foundation

📝 Problem & Approach

Inputs & Outputs

Minimal workflow

Approach comparison

⚡ Quick Reference

📋 Fixed vs User Input vs Compact Demo

When This Pattern Shows Up

After Program 34

Formatted output drills

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

📈 User Input

Example 2 — User input rows

How It Works

⚡ Smaller Demo

Example 3 — Compact $rows = 3

How It Works

🧠 How the Algorithm Prints Rows

Set up

Outer loop walks rows

Inner loop (j)

Print counter

New line

Right-aligned triangle complete

🔎 Worked Walkthrough — $rows = 5

Use Cases

1. Teaching Nested Loops

2. Pattern Series Base

3. Console Formatting Drills

4. Padding character

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. Declare $k Outside Loops

2. Call is_numeric($input)

3. Keep newline outside inner loop

4. Trace $k on Paper

5. Dry-Run $rows = 3

Common Pitfalls

1. Newline Inside the Inner Loop

2. Resetting $k Each Row

3. Wrong Space Width

4. Skipping %3d

5. Unchecked CLI input

Edge Cases

Single row

Empty pattern

$rows < 1

Smallest triangle

Non-numeric CLI input

Large row count

🎯 Practice Problems

1. Decreasing sequence

2. Descending digits

3. Counter trace

Example 1 — Fixed `$rows = 5`

Example 3 — Compact `$rows = 3`

🔎 Worked Walkthrough — `$rows = 5`

2. Call `is_numeric($input)`

`$rows < 1`