A fill-with-n number triangle prints ascending digits i..n on each row, then pads the rest with n so every row has the same width.
Remember
Rule: for i = n..1, print i..n, then pad with n (width = n)
5 5 5 5 5
4 5 5 5 5
3 4 5 5 5
2 3 4 5 5
1 2 3 4 5 ← n = 5
In C# you use a descending outer loop, a sequence loop j = i..n, a fill loop that prints n for i - 1 slots, then WriteLine() ends the row. Classic demos hard-code n = 5; the same logic works for any width.
Approach
How to Solve It
Two inner loops are the whole trick — sequence first, then pad to fixed width.
Method
Idea
Best for
Pad with n
Sequence i..n, then fill remaining slots with n
Learning, interviews, exams
Custom fill
Same structure; second loop prints a different constant
Quick variant once width clicks
Pseudocode
Pseudocode
for i from n down to 1:
for j from i to n:
print j and a space
repeat (i - 1) times:
print n and a space
print newline
Cheat sheet
Goal
Pattern
Walk rows top → bottom
for (i = n; i >= 1; i--)
Print sequence
for (j = i; j <= n; j++) Console.Write(j + " ");
Pad with n
for (j = 1; j < i; j++) Console.Write(n + " ");
End the row
Console.WriteLine();
Custom pad value
Console.Write(fill + " "); in the second loop
Write vs WriteLine
API
Effect
Use for
Console.Write
Stays on the same line
Each number plus a space
Console.WriteLine
Ends the current line
After both inner loops
Try it
Live Preview
Change the width n and the filled triangle updates instantly — every row still has n numbers.
Whole numbers from 1 to 9 (single digits). Tap a chip or type a value — the preview redraws as you go.
Live resultn = 5 · 25 numbers
5 5 5 5 5
4 5 5 5 5
3 4 5 5 5
2 3 4 5 5
1 2 3 4 5
Trace
Worked Walkthrough — n = 4
Trace each outer-loop value of i, the sequence printed, and how many pads are added.
i
Sequence
Pads
Printed row
4
4
3 × 4
4 4 4 4
3
3 4
2 × 4
3 4 4 4
2
2 3 4
1 × 4
2 3 4 4
1
1 2 3 4
0
1 2 3 4
Every row has width n, so total prints are n × n = n².
Code
C# Programs
Three complete programs: fixed n = 5, user input, and a custom fill constant. Use View Output for sample results.
Example 1 — Fixed n = 5
Outer loop counts down; first inner loop prints the sequence; second pads with n.
C#
using System;
namespace MyApp
{
class Program
{
static void Main(string[] args)
{
int n = 5;
int i, j;
for (i = n; i >= 1; i--)
{
for (j = i; j <= n; j++)
Console.Write(j + " ");
for (j = 1; j < i; j++)
Console.Write(n + " ");
Console.WriteLine();
}
}
}
}
Output
5 5 5 5 5
4 5 5 5 5
3 4 5 5 5
2 3 4 5 5
1 2 3 4 5
How It Works
1. Count down.for (i = n; i >= 1; i--) starts with a full-fill top row and ends with 1..n.
2. Sequence then pad. When i = 3, print 3 4 5, then two more 5s so the width stays 5.
3. Newline.WriteLine() after both inner loops starts the next row.
Example 2 — User Input
Read the triangle width at runtime. Prefer int.TryParse so bad input does not throw.
C#
using System;
namespace MyApp
{
class Program
{
static void Main(string[] args)
{
int n;
Console.Write("Enter the triangle width: ");
if (!int.TryParse(Console.ReadLine(), out n) || n < 1)
{
Console.WriteLine("Please enter a positive whole number.");
return;
}
for (int i = n; i >= 1; i--)
{
for (int j = i; j <= n; j++)
Console.Write(j + " ");
for (int j = 1; j < i; j++)
Console.Write(n + " ");
Console.WriteLine();
}
}
}
}
Output (when user enters 4)
4 4 4 4
3 4 4 4
2 3 4 4
1 2 3 4
How It Works
1. Validate n.TryParse rejects non-numeric input; require n >= 1.
2. Same nested loops. With n = 4, every row has four numbers ending in pads of 4 until the last row.
Example 3 — Custom Fill Constant
Pad with fill = 9 while the sequence still runs up to n = 5.
C#
using System;
namespace MyApp
{
class Program
{
static void Main(string[] args)
{
int n = 5;
int fill = 9;
int i, j;
for (i = n; i >= 1; i--)
{
for (j = i; j <= n; j++)
Console.Write(j + " ");
for (j = 1; j < i; j++)
Console.Write(fill + " ");
Console.WriteLine();
}
}
}
}
Output
5 9 9 9 9
4 5 9 9 9
3 4 5 9 9
2 3 4 5 9
1 2 3 4 5
How It Works
1. Separate fill. The sequence still uses j up to n; only the padding prints fill.
2. Same width. Each row still has five numbers — compare with Example 1 to see the pad change.
Edge Cases & Pitfalls
Check these before calling the solution done.
missing pad
Forgetting the second inner loop
Rows shrink instead of staying width n. Keep the fill loop for i - 1 pads.
wrong bound
j <= i instead of j < i in the fill loop
That adds one extra pad and makes rows wider than n.
WriteLine early
WriteLine between the two inner loops
That splits sequence and pads onto different lines. Call WriteLine() only after both loops finish.
n = 1
Single cell
Output is just 1 — a good sanity check.
n ≤ 0
Empty output
The outer loop never runs. Validate and prompt again for clearer UX.
multi-digit
n > 9
Spaces still separate values, but columns look uneven. Labs usually stick to 1–9.
Analysis
Time and Space Complexity
Program
Time
Extra space
Two inner loops (Examples 1–3)
O(n²)
O(1)
Each of n rows prints exactly n numbers, so total work is n².
Remember
Key Takeaways
Rule: for i = n..1, print i..n, then pad i - 1 times with n.
Two loops: sequence first, fill second — that is what keeps every row width n.
Write vs WriteLine: numbers stay on the line with a space; WriteLine advances after both loops.
Next step: Program 20 prints a continuous counting triangle.
One line: for each i from n down to 1, print i..n, pad with n, then WriteLine.
Frequently Asked Questions
When i = 5, the sequence loop prints j = 5 once, then the fill loop runs 4 times — all values are 5, so the row is 5 5 5 5 5.
The first inner loop prints the increasing sequence i..n. The second fills remaining positions with n so every row has the same width.
When i = 1, the sequence loop prints j = 1 to 5 and the fill loop runs zero times — no padding needed.
Console.Write stays on the same line. Console.WriteLine ends the current line. Numbers use Write(j + " "); the row break uses WriteLine after both inner loops.
Replace the hard-coded 5 with a variable n (see Example 2) or any constant you prefer for padding (see Example 3).
Rows will have different widths — the top row may be short while the bottom row is full length.
Yes, but print rows in reverse order or adjust i from 1 to n and change which row prints first.
O(n²) for width n because each of n rows prints n numbers.
Prefer int.TryParse(Console.ReadLine(), out n) so bad input does not throw FormatException.
The outer loop never runs, so nothing is printed. Validate and prompt again if you want a clear user message.
🤔
Did you know?
Each row prints an ascending sequence i..n, then pads with n so every row has width n. The second inner loop runs i - 1 times — still O(n²) total prints.
