A column-wise number triangle fills a 2D array down each column with increasing numbers, then prints row by row. That fill order creates jumps like 2 6 and 3 7 10 instead of consecutive digits.
In C# use int[,] tri = new int[rows + 1, rows + 1], fill with col outer, then print with row outer using Console.Write and WriteLine().
Approach
How to Solve It
Store values in a 2D array so fill order and print order can differ. Fill with col outer; print with row outer.
Method
Idea
Best for
2D array + column fill
Fill col outer, print row outer
Learning, interviews, exams
Rows input
Same logic with a user-chosen height
Practice / demos
Pseudocode
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 = num + 1
for row from 1 to rows:
for col from 1 to row:
print tri[row, col] (space between values)
print newline
Cheat sheet
Goal
Pattern
Store cells
int[,] tri = new int[rows + 1, rows + 1];
Fill column-wise
for (col = 1; col <= rows; col++) for (row = col; row <= rows; row++) tri[row, col] = num++;
Print row-wise
for (row = 1; row <= rows; row++) for (col = 1; col <= row; col++)
Space between
if (col < row) Console.Write(" ");
Total cells
rows * (rows + 1) / 2
Write vs WriteLine
API
Effect
Use for
Console.Write
Stays on the same line
Each cell value and spaces between cells
Console.WriteLine
Ends the current line
After each printed row
Try it
Live Preview
Change the row count and the column-wise triangle updates instantly — capped at 9 for readable demos.
Whole numbers from 1 to 9. Tap a chip or type a value — the preview redraws as you go.
Live resultrows = 5 · 15 cells
1
2 6
3 7 10
4 8 11 13
5 9 12 14 15
Trace
Worked Walkthrough — Fill for rows = 5
Trace how column-wise fill produces the jumps you see when printing row 2 and row 3.
2. Trace on paper. Confirm row 2 prints 2 4 — not consecutive — because of column-wise fill.
Edge Cases & Pitfalls
Check these before calling the solution done.
row outer fill
Consecutive instead of jumps
If you fill with row outer, you get 1, 2 3, 4 5 6… Keep col outer for the column-wise pattern.
0-based mix
Off-by-one indexing
These demos use 1-based tri[row, col]. Mixing 0-based loops with 1-based storage leaves holes or overwrites.
row = 1..rows fill
Upper triangle unused
During fill, start at row = col, not row = 1 — cells above the diagonal are never printed.
WriteLine
Broken rows
If WriteLine sits inside the print inner loop, each value lands on its own line. Call it only after the row finishes.
rows = 1
Single cell
Output is just 1 — a good sanity check for input validation.
Bad input
Convert.ToInt32 throws
Prefer int.TryParse so non-numeric input does not crash before the array is created.
Analysis
Time and Space Complexity
Program
Time
Extra space
Fixed / compact (Examples 1, 3)
O(n²)
O(n²) array
User input (Example 2)
O(n²)
O(n²) array
Fill and print each touch n(n+1)/2 cells. The 2D array uses O(n²) space (only the lower triangle is used).
Remember
Key Takeaways
Fill ≠ print: column-wise fill creates the jumps; row-wise print shows the triangle.
Fill bound: for each col, assign row = col..rows with num++.
Write vs WriteLine: values and spaces stay on the line; WriteLine advances after each row.
Next step: Program 56 prints a centered palindromic number pyramid.
One line: fill tri[row, col] = num++ column-wise, then print tri[row, col] row-wise.
Frequently Asked Questions
Because the triangle is filled column-wise: after finishing column 1 (1..5), the next available number is 6 for column 2.
Column-wise filling creates the distinctive jumps (6, 10, 13). Row-wise printing displays the familiar triangle shape.
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.
Program 54 uses diagonal conditions with spaces. Program 55 uses a 2D array filled column-wise then printed row-wise.
Not strictly, but it keeps fill order and print order separate — much clearer for beginners.
Yes. Loop rows first and you get the standard 1, 2 3, 4 5 6 triangle — compare both approaches.
O(n²) for n rows because total filled/printed values equal n(n+1)/2.
For rows=n, the largest number is n(n+1)/2 — the triangular number of cells.
Prefer int.TryParse(Console.ReadLine(), out rows) so bad input does not throw FormatException.
One row prints a single 1 — fill and print loops each run once.
🤔
Did you know?
Numbers are filled column-wise into a 2D array — 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²).
