Column-Wise Number Triangle in Python

Q: Why do numbers jump (like 2 to 6) on the second row?

Because the triangle is filled column-wise: after finishing column 1 (1..5), the next available number is 6 for column 2.

Q: Why fill column-wise but print row-wise?

Column-wise filling creates the distinctive jumps (6, 10, 13). Row-wise printing displays the familiar triangle shape.

Q: What does this column-wise triangle print?

For rows=5: 1; 2 6; 3 7 10; 4 8 11 13; 5 9 12 14 15 — numbers increase within each column during fill.

Q: How is this different from Program 54?

Program 54 uses diagonal conditions with spaces. Program 55 uses a 2D list filled column-wise then printed row-wise.

Q: Is a 2D list necessary?

Not strictly, but it keeps fill order and print order separate — much clearer for beginners.

Q: Can I fill row-wise instead?

Yes. Loop rows first and you get the standard 1, 2 3, 4 5 6 triangle — compare both approaches.

Q: What is the time complexity?

O(n²) for n rows because total filled/printed values equal n(n+1)/2.

Q: What is the largest number printed?

For rows=n, the largest number is n(n+1)/2 — the triangular number of cells.

Q: How should I read rows safely?

Use try/except ValueError around int(input()). Bare int(input()) raises ValueError on bad input.

Q: What happens when rows is 1?

One row prints a single 1 — fill and print loops each run once.

Beginner

⏱️ 10 min read

📚 Updated: Sep 2026

🎯 3 Code Examples

🚀 Live Preview

Nested Loops + 2D Array

Column-wise filled number triangle output in Python (1; 2 6; 3 7 10; 4 8 11 13; 5 9 12 14 15)

Overview

What You’ll Learn

Program 55 prints a column-wise number triangle: fill a 2D list column by column with increasing numbers, then print row by row — a natural step after Program 54’s mirror diagonal diamond. This tutorial covers column-wise filling, row-wise printing, a live preview, worked Python examples, edge cases, and complexity.

Shape Rule

Column-wise fill

Fill column 1 with 1..rows, column 2 with the next block, and so on — then print each row left to right.

2D Array

tri[row][col]

int tri[rows+1][rows+1] stores values so fill order and print order can differ.

Fill Loop

col outer, row inner

for col in range(1, rows + 1): for row in range(col, rows + 1): tri[row][col] = num; num += 1 — column-wise assignment.

Print Loop

row outer, col inner

for row in range(1, rows + 1): for col in range(1, row + 1): print(tri[row][col], end=" ") — standard triangle output.

Live Preview

rows = 3..9

Pick row count and draw the column-wise triangle in the browser.

O(n²)

Complexity

Total values = 1+2+…+n = n(n+1)/2 — classic triangular number complexity.

Introduction

A column-wise number triangle fills numbers down each column first, then prints row by row — creating jumps like 2 6 and 3 7 10 instead of consecutive digits. With rows = 5, you get 1, 2 6, 3 7 10, 4 8 11 13, 5 9 12 14 15.

In Python, create a 2D list, fill with nested loops (col outer, row inner), then print with reversed nesting (row outer, col inner).

Why it matters?

It bridges Program 54’s conditional patterns to 2D list storage — teaching fill order vs print order as separate steps.

Key Highlights

Column fill

Outer col, inner row = col..rows.

Row print

Outer row, inner col = 1..row.

vs Program 54

Program 54 uses diagonal conditions; Program 55 uses a 2D list with column-wise filling.

Series Foundation

Follow Program 54; continue to Program 56 next.

In short: fill tri[row][col] = num; num += 1 column-wise, then print tri[row][col] row-wise with spaces between values.

Foundation

📝 Problem & Approach

Given row count rows = 5, fill a triangle column-wise with increasing numbers, then print row-wise.

Python

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

Inputs & Outputs

Item	Type	Description
`rows`	int	Triangle height — row `i` prints `i` values.
`tri[row][col]`	2D int array	2D list storing filled values — 1-based indexing.
`num`	int	Running counter incremented during column-wise fill.
`col` (fill outer)	int	Column index — runs `1` to `rows`.
`row` (fill inner)	int	Runs `col..rows` for each column during fill.
Max value	int	Largest printed number = `rows*(rows+1)/2`.

Minimal workflow

Pseudocode

create tri[rows+1][rows+1]
num = 1
for col from 1 to rows:
    for row from col to rows:
        tri[row][col] = num
        num += 1
for row from 1 to rows:
    for col from 1 to row:
        print tri[row][col]
    print newline

Approach comparison

Approach	Idea	Best for
2D list + column fill	Fill column-wise, print row-wise	This distinctive jump pattern
Row-wise fill	Standard 1, 2 3, 4 5 6 triangle	Comparison / simpler output
User-input rows	`int(input())`	Flexible triangle size
Compact trace	`rows = 3` on paper first	Quick dry-runs (6 cells total)
Fixed-width print	`print(f"{val:3d}", end="")`	Alignment when rows exceed 9

Cheat Sheet

⚡ Quick Reference

Goal	Pattern
Declare array	`tri = [[0] * (rows + 1) for _ in range(rows + 1)]`
Fill column-wise	`for col in range(1, rows + 1): for row in range(col, rows + 1): tri[row][col] = num; num += 1`
Print row-wise	`for row in range(1, rows + 1): for col in range(1, row + 1): print(tri[row][col], end="")`
Add spacing	`if col < row: print(" ", end="")` between values
End row	`print()`
Program 54 contrast	Program 54 uses diagonal conditions; Program 55 uses 2D list column fill

Compare

📋 Fixed Rows vs User Input vs Compact Trace

Same column-wise triangle — three ways to set row count and trace the fill order.

Fixed rows

rows = 5

Hard-coded height for demos (15 values)

User input

int(input())

Read row count from console

Compact trace

rows = 3

6-cell triangle for paper tracing

Fill order

col outer

Column-wise assignment

Print order

row outer

Row-wise display

Context

When This Pattern Shows Up

Reach for this pattern when teaching 2D lists, fill order vs print order, and triangular number sequences.

Post Program 54 exercise
Natural follow-up after Program 54’s diamond — introduces 2D list storage and column-wise filling.
2D list drills
Fill in one order, print in another — a pattern used in matrices, grids, and game boards.
Triangular numbers
Total cells = n(n+1)/2 — links loops to the triangular number formula.
Gateway to Program 56
Compare column-wise fill with the next pattern in the series.
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 2D lists, fill/print order separation, and O(n²) thinking.

Interactive

🔮 Live Preview

Choose row count between 3 and 9 and draw the column-wise number triangle in the browser.

Hands-On

Examples Gallery

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

📚 Getting Started

Fill a 5-row triangle column-wise into a 2D list, then print row-wise with spaces.

Example 1 — Fixed `rows = 5`

Hard-coded row count — fill with col outer and row = col..rows inner, then print with row outer and col = 1..row inner.

Python

rows = 5
tri = [[0] * (rows + 1) for _ in range(rows + 1)]
num = 1

for col in range(1, rows + 1):
    for row in range(col, rows + 1):
        tri[row][col] = num
        num += 1

for row in range(1, rows + 1):
    for col in range(1, row + 1):
        print(tri[row][col], end="")
        if col < row:
            print(" ", end="")
    print()

How It Works

Column 1 fills rows 1–5 with 1–5. Column 2 fills rows 2–5 with 6–9. When printed row-wise, row 2 shows 2 6 — values from columns 1 and 2 of that row.

📈 User Input

Read row count from the console with safe parsing.

Example 2 — User Input Rows

Read rows from the console with int(input()) — reject invalid input gracefully.

Python

try:
    rows = int(input("Enter the number of rows: "))
except ValueError:
    print("Please enter a positive integer.")
else:
    if rows <= 0:
        print("Please enter a positive integer.")
    else:
        tri = [[0] * (rows + 1) for _ in range(rows + 1)]
        num = 1

        for col in range(1, rows + 1):
            for row in range(col, rows + 1):
                tri[row][col] = num
                num += 1

        for row in range(1, rows + 1):
            for col in range(1, row + 1):
                print(tri[row][col], end="")
                if col < row:
                    print(" ", end="")
            print()

How It Works

Same column-fill then row-print core as Example 1; only the source of rows changes from a literal to user input.

⚡ Compact Trace

Smaller row count for quick tracing on paper or in interviews.

Example 3 — Compact `rows = 3`

Use rows = 3 to trace column fill (6 cells) before scaling to 5 rows.

Python

rows = 3
tri = [[0] * (rows + 1) for _ in range(rows + 1)]
num = 1

for col in range(1, rows + 1):
    for row in range(col, rows + 1):
        tri[row][col] = num
        num += 1

for row in range(1, rows + 1):
    for col in range(1, row + 1):
        print(tri[row][col], end="")
        if col < row:
            print(" ", end="")
    print()

How It Works

Only six cells to fill — column 1 gets 1–3, column 2 gets 4–5, column 3 gets 6. Trace each assignment on paper before running rows = 5.

🧠 How the Algorithm Fills and Prints

Create the 2D list

int tri[rows + 1][rows + 1]; — 1-based indexing for rows and columns.

Setup

Fill column-wise

for col in range(1, rows + 1): for row in range(col, rows + 1): tri[row][col] = num; num += 1.

Fill

Print row-wise

for row in range(1, rows + 1): for col in range(1, row + 1): — print stored values with spaces.

Understand the jumps

Row 2 shows 2 6 because column 1 has 2 and column 2 has 6 at row 2 — not consecutive fill order.

Logic

Column-wise triangle complete

Total values = n(n+1)/2 — O(n²) time, O(n²) array space.

Trace

🔎 Worked Walkthrough — `rows = 5`

Trace column-wise fill assignments and the resulting row output.

Column	Fills rows	Values assigned
`1`	`1..5`	`1, 2, 3, 4, 5`
`2`	`2..5`	`6, 7, 8, 9`
`3`	`3..5`	`10, 11, 12`
`4`	`4..5`	`13, 14`
`5`	`5`	`15`

`row`	Columns printed	Row output
`1`	col 1	`1`
`2`	col 1–2	`2 6`
`3`	col 1–3	`3 7 10`
`4`	col 1–4	`4 8 11 13`
`5`	col 1–5	`5 9 12 14 15`

The jump from 2 to 6 on row 2 happens because column 2 was filled after column 1 — not because of a formula on the row itself.

Use Cases

Where this tiny pattern (and its loop structure) shows up beyond the homework prompt.

1. Teaching Nested Loops

Column-wise fill then row-wise print — two distinct loop phases.

Example: trace the fill table and row output table in the walkthrough.

2. Fill-Order Drills

Changing fill order (column vs row) completely changes the output — compare both on paper.

Example: row 5 shows all five columns: 5 9 12 14 15.

3. Output Formatting Drills

Practice print(..., end="") vs print() with multiple values per row.

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

4. Triangular Numbers

Total cells = n(n+1)/2 — the nth triangular number.

Example: Peak row 10 fills 55 cells — largest value is 55.

5. Complexity Intuition

Growing inner bound makes O(n²) concrete — count prints for n rows.

Example: Peak row 5 fills 15 cells — see the walkthrough table.

6. Input Validation Labs

Pair the pattern with try/except ValueError and positive-row validation.

Example: reject rows <= 0 and re-prompt.

Pro Tip: when an interviewer asks for patterns, explain 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
Swapping fill and print loop nesting without an array produces scrambled output.
2. Real Math Connection
Column-wise fill teaches real 2D list usage — not abstract loop drill.
3. Easy to Extend
Change rows, use fixed-width format, or switch to full rectangular table.
4. O(1) Extra Memory
Streaming output needs no storage beyond loop counters.

Pro Tip: trace rows = 3 on paper — 6 cells, output 1 / 2 4 / 3 5 6.

Usage Tips

Small habits that keep number-pattern code clean.

1. Fill col outer, row inner
Column-wise fill: for col in range(1, rows + 1): for row in range(col, rows + 1):.
2. Prefer try/except
Avoid using uninitialized rows when the user types letters instead of a number.
3. Newline After Both Inner Loops
Only call print() after both inner loops finish the row.
4. Print row outer, col inner
Row-wise print: for row in range(1, rows + 1): for col in range(1, row + 1):.
5. Dry-Run rows = 5
Trace five rows on paper before coding the full 10-row demo.

Pro Tip: if the output is a vertical list of single numbers, you almost certainly put print() inside the inner loop.

Common Pitfalls

Mistakes that commonly break column-wise number triangle patterns.

1. print() Inside Inner Loop
Each number lands on its own line — you get a column, not a triangle.
→ Use print(tri[row][col], end=""); call print() only after the print inner loop.
2. Wrong Fill Loop Nesting
Using row outer during fill instead of col gives the standard consecutive triangle.
→ Use for col in range(1, rows + 1): as the fill outer loop.
3. Forgetting Spaces Between Values
Output runs together like 2610 instead of 2 6 and 3 7 10.
→ Add if col < row: print(" ", end="") between values.
4. Forgetting Newline After Row
All numbers print on one long line without row breaks.
→ Add print() after both inner loops complete.
5. Unchecked int(input())
Letters or empty input leave rows unread or raise ValueError.
→ Wrap in try/except ValueError and re-prompt on failure.

Edge Cases

Check these inputs before calling the solution done.

rows = 1

Single row

Output is just 1 — the right loop does not run.

rows = 0

Empty output

Outer loop never runs — print nothing or show a message.

Negative

`rows < 0`

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

rows = 5

Compact trace

Peak row 5 produces 9 lines — good for dry-runs.

Bad input

Non-numeric input

Unchecked int(input()) raises ValueError — use try/except.

Large rows

Wide output

Row 9 scans 17 character positions — total work grows as O(n²).

Drill

🎯 Practice Problems

Try these variations to lock in the pattern.

1. Compare with Program 54

Program 54 uses diagonal conditions with spaces
Program 55 uses a 2D list filled column-wise

2. Fill row-wise instead

Swap to row outer during fill — get 1, 2 3, 4 5 6
Compare output with the column-wise version

3. Next in series

Continue with Program 56
Build on column-wise number patterns

4. Fixed-width formatting

Use print(f"{tri[row][col]:3d}", end="") for alignment
Try rows = 10 where values reach 55

Important

Notes

Two phases. Fill: col outer, row = col..rows. Print: row outer, col = 1..row.
print(..., end="") stays on the line; print() advances — call it after the print inner loop finishes each row.
Validate rows > 0 for interactive programs; largest value = rows*(rows+1)/2.
Total values = n(n+1)/2 — fill and print each visit every cell once.

Quick Takeaway: fill tri[row][col] = num; num += 1 column-wise, print tri[row][col] row-wise with spaces, then print().

Analysis

⏱️ Time and Space Complexity

Program	Time	Extra space
Fill + print loops (Examples 1–3)	`O(n²)`	`O(n²)` for the array
Total values	`n(n+1)/2`	Largest value also `n(n+1)/2`

Wrap Up

🎉 Conclusion

The column-wise number triangle is a natural follow-up to Program 54: store values in a 2D list, fill column-wise, then print row-wise for the distinctive jump pattern. Master the fixed-rows version, then try user input and the compact 3-row trace.

Practice the three examples above, then continue to Program 56 for the next pattern in the series.

Fill order (column first) creates the jumps — row 2 shows 2 6, not 2 3.

View Examples Gallery Continue to Program 56

Pro Tips

💡 Best Practices

✅ Do

Declare int tri[rows + 1][rows + 1]
Fill: for col in range(1, rows + 1): for row in range(col, rows + 1): tri[row][col] = num; num += 1
Print: for row in range(1, rows + 1): for col in range(1, row + 1):
Add spaces with if col < row: print(" ", end="")
Use try/except for user input

❌ Don’t

Swap fill loop nesting — you get the standard consecutive triangle
Print during fill without storing — hard to get column-wise output
Call print() inside the print inner loop
Ignore bad console input in user-facing demos
Skip the rows = 3 dry-run before coding rows = 5

Summary

Key Takeaways

Knowledge Unlocked

Five things to remember about this column-wise triangle

Print the jump pattern the beginner-friendly way.

Core concepts

△ 01

Rule

Fill column-wise, print row-wise

Definition

▦ 02

2D list

tri[row][col]

Code

↓ 03

Fill

col outer, row inner

Code

→ 04

Print

row outer, col inner

Logic

O 05

Complexity

n(n+1)/2 values

Analysis

❓ Frequently Asked Questions

Why do numbers jump (like 2 to 6) on the second row?

Because the triangle is filled column-wise: after finishing column 1 (1..5), the next available number is 6 for column 2.

Why fill column-wise but print row-wise?

Column-wise filling creates the distinctive jumps (6, 10, 13). Row-wise printing displays the familiar triangle shape.

What does this column-wise triangle print?

For rows=5: 1; 2 6; 3 7 10; 4 8 11 13; 5 9 12 14 15 — numbers increase within each column during fill.

How is this different from Program 54?

Program 54 uses diagonal conditions with spaces. Program 55 uses a 2D list filled column-wise then printed row-wise.

Is a 2D list necessary?

Not strictly, but it keeps fill order and print order separate — much clearer for beginners.

Can I fill row-wise instead?

Yes. Loop rows first and you get the standard 1, 2 3, 4 5 6 triangle — compare both approaches.

What is the time complexity?

O(n²) for n rows because total filled/printed values equal n(n+1)/2.

What is the largest number printed?

For rows=n, the largest number is n(n+1)/2 — the triangular number of cells.

How should I read rows safely?

Use try/except ValueError around int(input()). Bare int(input()) raises ValueError on bad input.

What happens when rows is 1?

One row prints a single 1 — fill and print loops each run once.

Did you Know? 🔊

Numbers are filled column-wise into a 2D list — column 1 gets 1..n, column 2 gets the next block, and so on — then printed row-wise. Total values = n(n+1)/2, so O(n²).

Continue to Program 56

Move on to the next pattern in the Python number-pattern series.

Program 56 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 54 — Mirror Diagonal Diamond Python Number Pattern 56

Column-Wise Number Triangle in Python

What You’ll Learn

Shape Rule

2D Array

Fill Loop

Print Loop

Live Preview

O(n²)

Introduction

Why it matters?

Column fill

Row print

vs Program 54

Series Foundation

📝 Problem & Approach

Inputs & Outputs

Minimal workflow

Approach comparison

⚡ Quick Reference

📋 Fixed Rows vs User Input vs Compact Trace

When This Pattern Shows Up

Post Program 54 exercise

2D list drills

Triangular numbers

Gateway to Program 56

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

⚡ Compact Trace

Example 3 — Compact rows = 3

How It Works

🧠 How the Algorithm Fills and Prints

Create the 2D list

Fill column-wise

Print row-wise

Understand the jumps

Column-wise triangle complete

🔎 Worked Walkthrough — rows = 5

Use Cases

1. Teaching Nested Loops

2. Fill-Order Drills

3. Output Formatting Drills

4. Triangular Numbers

5. Complexity Intuition

6. Input Validation Labs

Advantages

1. Instant Visual Feedback

2. Real Math Connection

3. Easy to Extend

4. O(1) Extra Memory

Usage Tips

1. Fill col outer, row inner

2. Prefer try/except

3. Newline After Both Inner Loops

4. Print row outer, col inner

5. Dry-Run rows = 5

Common Pitfalls

1. print() Inside Inner Loop

2. Wrong Fill Loop Nesting

3. Forgetting Spaces Between Values

4. Forgetting Newline After Row

5. Unchecked int(input())

Edge Cases

Single row

Empty output

rows < 0

Compact trace

Non-numeric input

Wide output

🎯 Practice Problems

1. Compare with Program 54

2. Fill row-wise instead

3. Next in series

4. Fixed-width formatting

Example 1 — Fixed `rows = 5`

Example 3 — Compact `rows = 3`

🔎 Worked Walkthrough — `rows = 5`

`rows < 0`