Right-Aligned Descending Number Triangle in Python

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 Python 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 Python 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 in range(1, rows + 1): — 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 Python 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 print().

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.

Python

# rows = 5 (conceptual shape)
for i in range(1, rows + 1):
    for j in range(rows, 0, -1):
        if j > i:
            print(" ", end="")
        else:
            print(j, end="")
    print()

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
Conditional expression	`print(" " if j > i else j, end="")`	Compact console programs
User-input rows	`int(input(...))`	Flexible row count

Cheat Sheet

⚡ Quick Reference

Goal	Pattern
Walk rows	`for i in range(1, rows + 1):`
Inner loop	`for j in range(rows, 0, -1):`
Leading spaces	`if j > i: print(" ", end="") else: print(j, end="")`
End the row	`print()`
Conditional form	`print(" " if j > i else j, end="")`
User input	`int(input(...))`

Compare

📋 if/else vs Conditional 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

" " if j > i else 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 input() 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 Python programs — fixed rows, user input with conditional expression 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.

Python

for i in range(1, 6):
    for j in range(5, 0, -1):
        if j > i:
            print(" ", end="")
        else:
            print(j, end="")
    print()

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 input() instead of hard-coding 5.

Example 2 — User Input

Read rows with input() and int(); the inner loop uses rows as the fixed width.

Python

rows = int(input("Enter rows: "))
if rows < 1:
    raise SystemExit

for i in range(1, rows + 1):
    for j in range(rows, 0, -1):
        print(" " if j > i else j, end="")
    print()

How It Works

Same right-aligned core as Example 1; a conditional expression replaces if/else and rows replaces hard-coded 5. Non-numeric input raises ValueError with bare int(input()) — use try/except for 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.

Python

rows = 3

for i in range(1, rows + 1):
    for j in range(rows, 0, -1):
        if j > i:
            print(" ", end="")
        else:
            print(j, end="")
    print()

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

No imports needed for fixed rows; use input() when reading. Set rows = 5 and loop variables i, j.

Setup

Outer loop walks rows

for i in range(1, rows + 1): — ascending outer loop; one right-aligned row per iteration.

Row

Inner loop (j)

for j in range(rows, 0, -1): — print space if j > i, else print j.

Padding

New line

print() 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 print vs row newline without complex math.

Example: put print() inside the inner loop by mistake.

4. Padding character

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

Example: use print(j, end=" ") 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 input() 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. Call try/except ValueError
Use try/except ValueError so bad input does not crash when converting rows.
3. Keep print() Outside the Inner Loop
Only call print() 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 print() 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 print(j, end="") or print(" ", end=""); print() 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 in range(1, rows + 1): prints ascending digits — not the descending order this pattern needs.
→ Keep for j in range(rows, 0, -1): 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. Bare int(input())
Letters or empty input raise ValueError with bare int(input()).
→ Catch ValueError 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 input

Bare int(input()) raises ValueError on bad input — use try/except 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

Validate rows >= 1 after reading input
Then draw the triangle

Important

Notes

Padding rule. Print space when j > i; print digit j otherwise. Inner loop always runs rows times.
print(..., end="") stays on the line; print() 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 print(" " if j > i else j, end=""), then print().

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 print(). 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 in range(1, rows + 1): in the outer loop
Inner: if (j > i) print space, else print j
Keep inner loop at fixed width rows
Wrap int(input()) in try/except ValueError
State O(n²) time when asked about complexity

❌ Don’t

Call print() 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 with range(rows, 0, -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 a try/except ValueError around int(input()) or check the raw string with .isdigit() before converting so bad input does not crash the script.

What happens when rows is 1?

One row prints with no leading spaces — just 1.

Can I use conditional expressions?

Yes — print(" " if j > i else j, end="") compacts the if/else logic in Python.

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 Python 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

Python Number Pattern 29 — Mirrored Number Pattern Python Number Pattern 31 — Number-Star Diamond Pattern

Right-Aligned Descending Number Triangle in Python

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 Conditional 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. Call try/except ValueError

3. Keep print() Outside the Inner Loop

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. Bare int(input())

Edge Cases

Single digit row

Empty pattern

rows < 0

Smallest triangle

Non-numeric 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. Call `try/except ValueError`

5. Bare `int(input())`

`rows < 0`