Right-Aligned Descending Number Triangle in PHP

Q: Why use a fixed-width inner loop?

Running $j from $rows down to 1 on every row keeps column alignment. Spaces fill positions where $j > $i.

Beginner

⏱️ 9 min read

📚 Updated: Aug 2026

🎯 3 Code Examples

🚀 Live Preview

Condition + Loops

Right-aligned descending number triangle output ( 1, 21, 321, 4321, 54321) in PHP programming

Overview

What You’ll Learn

The right-aligned descending triangle prints 1, 21, 321, 4321, 54321 — a natural step after the spaced mirror in Program 29. This tutorial covers fixed-width loops, leading-space padding, conditional printing, a live preview, worked PHP examples, edge cases, and complexity.

Shape Rule

Spaces + digits

Each row prints leading spaces while $j > $i, then digits $i..1 in descending order.

Outer Loop

$i = 1..$rows

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

Inner Loop ($j)

$rows..1

if ($j > $i) prints space; else prints $j.

Fixed Width

Always rows

Inner loop always runs $rows times — spaces pad the left side.

Live Preview

3–9 rows

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

O(n²)

Complexity

Each row runs one loop of width $rows — total work scales as n².

Introduction

A right-aligned descending number triangle prints leading spaces on each row, then digits from $i down to 1. With $rows = 5, the triangle grows rightward: 1, 21, … 54321.

In PHP you use one fixed-width inner loop: print a space when $j > $i, otherwise print $j.

Why it matters?

It combines conditional printing with leading-space padding — a step up from Program 29’s two-loop mirror.

Key Highlights

Fixed width

Inner loop always runs $rows times.

$j > $i

Print space for leading padding.

$j <= $i

Print digit in descending order.

Series Foundation

Follow Program 29; continue to Program 31 (number-star diamond) next.

In short: for each $i, inner loop prints space or $j, then echo PHP_EOL.

Foundation

📝 Problem & Approach

Given $rows = 5, print a right-aligned descending triangle: for each $i, print spaces while $j > $i, then print digits $i..1 in a fixed-width inner loop.

PHP

// $rows = 5 (conceptual shape)
//     1
//    21
//   321
//  4321
// 54321

Inputs & Outputs

Item	Type	Description
`$rows`	int	Pattern height — also the fixed width of the inner loop.
`$i`	int	Outer loop — current row; controls how many leading spaces print.
`$j`	int	Inner loop — prints space when `$j > $i`, else prints `$j`.

Minimal workflow

Pseudocode

for $i from 1 to $rows:
    for $j from $rows down to 1:
        if $j > $i: print space
        else: print $j
    print newline

Approach comparison

Approach	Idea	Best for
if/else	`1`, `21`, …	Learning and interviews
Ternary operator	`echo ($j > $i) ? " " : $j`	Compact console programs
User-input rows	`(int) trim(fgets(STDIN));`	Flexible row count

Cheat Sheet

⚡ Quick Reference

Goal	Pattern
Walk rows	`for ($i = 1; $i <= $rows; $i++)`
Inner loop	`for ($j = $rows; $j >= 1; $j--)`
Leading spaces	`if ($j > $i) echo " "; else echo $j;`
End the row	`echo PHP_EOL;`
Ternary form	`echo ($j > $i) ? " " : $j;`
User input	`(int) trim(fgets(STDIN));`

Compare

📋 if/else vs Ternary vs User Input

Same right-aligned triangle — different ways to write the condition and control rows.

Outer loop

$i = 1..$rows

One right-aligned row per iteration

Leading spaces

$j > $i ? " " : $j

Space or digit

Inner loop

$j = $rows..1

Fixed width each row

Learning tip

$rows - $i

Leading spaces per row

Context

When This Pattern Shows Up

Reach for this pattern when teaching fixed-width loops, leading-space padding, and conditional character output.

Post alignment exercise
Natural follow-up after Program 29 — introduces right alignment with a single inner loop.
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 29 (spaced mirror) and Program 31 (number-star diamond) 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 3 and 9 and draw the right-aligned descending triangle in the browser.

Hands-On

Examples Gallery

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

📚 Getting Started

Print five rows of the right-aligned descending triangle with if/else in one inner loop.

Example 1 — Fixed `$rows = 5`

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

PHP

<?php
for ($i = 1; $i <= 5; $i++) {
    for ($j = 5; $j >= 1; $j--) {
        if ($j > $i) {
            echo " ";
        } else {
            echo $j;
        }
    }
    echo PHP_EOL;
}

How It Works

When $i = 1, the inner loop prints four spaces then 1 — output 1. When $i = 5, no leading spaces — output 54321.

📈 User Input

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

Example 2 — User Input

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

PHP

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

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

How It Works

Same right-aligned core as Example 1; a ternary operator replaces if/else and $rows replaces hard-coded 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 if/else logic with a smaller row count for quick tracing.

PHP

<?php
$rows = 3;

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

How It Works

Only $rows changes from 5 to 3 — the if/else structure 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 $rows = 5; and 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--) — print space if $j > $i, else print $j.

Padding

New line

echo PHP_EOL ends the row after the inner loop finishes.

Break

Right-aligned triangle complete

Leading spaces shrink each row — O(n²) time, O(1) extra memory.

Trace

🔎 Worked Walkthrough — `$rows = 5`

Trace each outer-loop value of $i, leading-space count, digit range, and full row output.

`$i`	Leading spaces	Digits printed	Row output
`1`	4	`1`	`1`
`2`	3	`2, 1`	`21`
`3`	2	`3, 2, 1`	`321`
`4`	1	`4, 3, 2, 1`	`4321`
`5`	0	`5, 4, 3, 2, 1`	`54321`

Leading spaces per row = $rows - $i — zero when $i = $rows.

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 inverted, pyramid, diamond, and hollow variants.

Example: continue to Program 31 for a number-star diamond 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. Padding character

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

Example: use echo $j . " " between digits for wider spacing.

5. Complexity Intuition

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

Example: count printed characters for $rows = 5 — each row prints exactly $rows characters.

6. Input Validation Labs

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

Example: reject max <= 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: trace $i and $j 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. Keep Fixed Width
Inner loop must always run $rows times — spaces pad the left side.
2. Prefer trim(fgets(STDIN))
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 $j > $i on Paper
Mark which positions print spaces vs digits for each row before coding.
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 descending triangles.

1. Newline Inside the Inner Loop
Each digit lands on its own line — you get a column, not a triangle.
→ Use echo $j or echo " "; echo PHP_EOL only after the inner loop.
2. Flipping the Condition
Using $j <= $i for spaces (instead of $j > $i) inverts which positions print digits.
→ Print space when $j > $i; print digit otherwise.
3. Wrong Inner Direction
for ($j = 1; $j <= $rows; $j++) prints ascending digits — not the descending order this pattern needs.
→ Keep for ($j = $rows; $j >= 1; $j--) so digits read $i..1.
4. Short Inner Loop
Running the inner loop only to $i removes leading spaces — output becomes left-aligned.
→ Inner loop must always run from $rows down to 1.
5. Unchecked CLI input
Letters or empty input leave $rows uninitialized.
→ Call is_numeric(trim($line)) and re-prompt on failure.

Edge Cases

Check these inputs before calling the solution done.

$rows = 1

Single digit row

Output is 1 (with $rows - 1 leading spaces).

$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 CLI input

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

Large rows

Large row count

Each row prints exactly $rows characters — total work grows as n².

Drill

🎯 Practice Problems

Try these variations to lock in the pattern.

1. Spaced mirror

Two fixed-width inner loops
Review Program 29

2. Reverse descending

Compare with Program 3
Same digits, no leading spaces

3. Number-star diamond

Continue with Program 31
Alternating digits and stars

4. Safe input loop

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

Important

Notes

Padding rule. Print space when $j > $i; print digit $j otherwise. Inner loop always runs $rows times.
echo.print stays on the line; echo PHP_EOL advances — mix them carefully.
Validate $rows > 0 for interactive programs; $rows = 1 prints one digit with $rows - 1 leading spaces.
Leading spaces per row = $rows - $i — compare with Program 3 where there are no leading spaces.

Quick Takeaway: outer loop $i = 1..$rows, inner $j > $i ? " " : $j, 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 descending number triangle is a compact lesson in fixed-width loops and leading-space padding: print spaces while $j > $i, then print digits in descending order, 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 31 for the number-star diamond pattern.

Inner loop must always use $rows as the width — validate $rows when reading from the console.

View Examples Gallery Continue to Program 31

Pro Tips

💡 Best Practices

✅ Do

Use for ($i = 1; $i <= $rows; $i++) in the outer loop
Inner: if ($j > $i) print space, else print $j
Keep inner loop at fixed width $rows
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 loop
Shorten the inner loop below $rows
Flip the space/digit condition ($j <= $i for spaces)
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

Rule

$j>$i spaces, else $j

Definition

↻ 02

Fixed width

$j = $rows..1

Code

← 03

Leading spaces

$rows - $i per row

Code

↓ 04

Digits

Print $i..1

Shape

O 05

Complexity

O(n²) time

Analysis

❓ Frequently Asked Questions

Why does the output look right-aligned?

Leading spaces are printed while $j > $i. Smaller rows get more spaces, pushing digits to the right edge.

How are numbers printed in descending order?

The inner loop runs $j from $rows down to 1. When $j <= $i, it prints $j — naturally producing $i..1 on each row.

Why use a fixed-width inner loop?

Running $j from $rows down to 1 on every row keeps column alignment. Spaces fill positions where $j > $i.

How is this different from Program 3?

Program 3 prints a left-aligned reverse descending triangle with no leading spaces. Program 30 pads with spaces for right alignment.

How do I generalize for any row count?

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

What is the time complexity?

O(n²) for n rows because each row runs a fixed-width inner loop of n iterations.

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?

One row prints with no leading spaces — just 1.

Can I use a ternary operator?

Yes — echo ($j > $i) ? " " : $j compacts the if/else logic in PHP.

Did you Know? 🔊

This pattern uses a fixed column width ($rows). For each row $i, the inner loop prints spaces while $j > $i, then prints digits in descending order — producing a right-aligned triangle.

Continue to Program 31

Move on to the number-star diamond pattern in the PHP number-pattern series.

Program 31 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 29 — Mirrored Number Pattern PHP Number Pattern 31 — Number-Star Diamond Pattern

Right-Aligned Descending Number Triangle in PHP

What You’ll Learn

Shape Rule

Outer Loop

Inner Loop ($j)

Fixed Width

Live Preview

O(n²)

Introduction

Why it matters?

Fixed width

$j > $i

$j <= $i

Series Foundation

📝 Problem & Approach

Inputs & Outputs

Minimal workflow

Approach comparison

⚡ Quick Reference

📋 if/else vs Ternary vs User Input

When This Pattern Shows Up

Post alignment 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 = 5

How It Works

📈 User Input

Example 2 — User Input

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)

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. Keep Fixed Width

2. Prefer trim(fgets(STDIN))

3. Keep echo PHP_EOL Outside

4. Trace $j > $i on Paper

5. Dry-Run rows = 3

Common Pitfalls

1. Newline Inside the Inner Loop

2. Flipping the Condition

3. Wrong Inner Direction

4. Short Inner Loop

5. Unchecked CLI input

Edge Cases

Single digit row

Empty pattern

$rows < 0

Smallest triangle

Non-numeric CLI input

Large row count

🎯 Practice Problems

1. Spaced mirror

2. Reverse descending

3. Number-star diamond

4. Safe input loop

Example 1 — Fixed `$rows = 5`

Example 3 — Compact `$rows = 3`

🔎 Worked Walkthrough — `$rows = 5`

2. Prefer `trim(fgets(STDIN))`

`$rows < 0`