An inverted right-angled triangle star pattern prints a left-aligned upside-down staircase of * characters: the first row has rows stars, and each next row has one fewer down to 1.
Remember
Rule: on outer value i, print i stars (i counts down)
*****
****
***
**
* ← 5 rows
In C# you solve it with two nested for loops: the outer loop counts from rows down to 1, the inner loop prints stars for the current i, then Console.WriteLine() moves to the next line. It is the mirror of Program 1 — same inner loop, reversed outer direction.
Approach
How to Solve It
Two ways to emit the same shape — start with a countdown outer loop, then optionally use a forward formula or new string.
Method
Idea
Best for
Countdown outer
i = rows..1, inner prints i stars via Console.Write
Learning, interviews, clearest invert of Program 1
Forward + formula
i = 1..rows, print rows - i + 1 stars
When you prefer ascending counters
new string('*', i)
Build a whole row in one call while counting down
Shorter demos once loops click
Pseudocode
Pseudocode
for i from rows down to 1:
for j from 1 to i:
print "*" (no newline)
print newline
Cheat sheet
Goal
Pattern
Countdown rows
for (i = rows; i >= 1; i--)
Print i stars
for (j = 1; j <= i; j++) Console.Write("*");
End the row
Console.WriteLine();
Forward equivalent
for (j = 1; j <= rows - i + 1; j++)
One-line row shortcut
Console.WriteLine(new string('*', i)); while counting down
Change the row count and the inverted triangle updates instantly — including the triangular star total.
Whole numbers from 1 to 20. Tap a chip or type a value — the preview redraws as you go. The first line has that many stars.
Live result5 rows · 15 stars
*****
****
***
**
*
Trace
Worked Walkthrough — rows = 4
Trace each outer-loop value of i as it counts down, and count how many times the inner loop runs.
i
Inner j
Printed row
Stars
4
1..4
****
4
3
1..3
***
3
2
1..2
**
2
1
1..1
*
1
Total star prints: 4 + 3 + 2 + 1 = 10 = 4×5/2. Same triangular sum as Program 1 — time is still O(n²).
Code
C# Programs
Three complete programs: fixed rows (countdown), console input, and a new string shortcut. Use View Output to reveal sample results.
Example 1 — Fixed rows = 5
Hard-coded height with a countdown outer loop — the clearest invert of Program 1.
C#
using System;
class Program
{
static void Main()
{
int rows = 5;
for (int i = rows; i >= 1; i--)
{
for (int j = 1; j <= i; j++)
{
Console.Write("*");
}
Console.WriteLine();
}
}
}
Output
*****
****
***
**
*
How It Works
1. Set height.rows = 5 means the triangle has five lines; the first line has five stars.
2. Outer loop counts down.i runs from rows down to 1.
3. Inner loop prints stars. For each i, j runs from 1 to i, so the current row gets exactly i stars via Console.Write("*").
4. Break the line.Console.WriteLine() after the inner loop starts the next (shorter) row.
When i = 5 you get *****; when i = 4 you get ****; and so on down to one star.
Example 2 — User Input Version
Read the row count at runtime. Prefer int.TryParse in real apps (shown in the tip below).
C#
using System;
class Program
{
static void Main()
{
Console.Write("Enter the number of rows: ");
int rows = Convert.ToInt32(Console.ReadLine());
for (int i = rows; i >= 1; i--)
{
for (int j = 1; j <= i; j++)
{
Console.Write("*");
}
Console.WriteLine();
}
}
}
Output (when user enters 7)
Enter the number of rows: 7
*******
******
*****
****
***
**
*
How It Works
1. Prompt and read. Ask for a row count, then convert the line to an int.
2. Same nested-loop core. Only the source of rows changes — the countdown print logic matches Example 1.
3. Safer input tip.Convert.ToInt32 throws on letters or empty input. Prefer:
Safer input
if (!int.TryParse(Console.ReadLine(), out int rows) || rows < 1)
{
Console.WriteLine("Enter a positive whole number.");
return;
}
Example 3 — new string('*', i)
Build each row in one call while counting down — same shape, no explicit inner star loop.
C#
using System;
class Program
{
static void Main()
{
int rows = 5;
for (int i = rows; i >= 1; i--)
{
Console.WriteLine(new string('*', i));
}
}
}
Output
*****
****
***
**
*
How It Works
1. One outer loop. Still walk i from rows down to 1.
2. Build the row.new string('*', i) creates a string of length i filled with stars.
3. Print and advance.WriteLine prints that string and ends the line.
Learn the two-loop version first (Examples 1–2) so you can explain both bounds in an interview; treat this as a polish shortcut afterward.
Edge Cases & Pitfalls
Check these before calling the solution done.
Wrong direction
Upright instead of inverted
If you use i = 1..rows instead of i = rows..1, you get Program 1’s growing triangle. For the inverted shape, count down — or use rows - i + 1 stars with a forward loop.
WriteLine inside
Column of stars
If WriteLine is inside the inner loop, each star lands on its own line. Use Write for stars; WriteLine only after the inner loop.
j <= rows
Rectangle, not triangle
Inner bound must be j <= i (or j <= rows - i + 1). j <= rows prints a filled rectangle.
No WriteLine
One endless line
Omitting the row break glues every star onto a single line.
rows = 1
Single star
Output is just * on one line — a good sanity check (same as Program 1).
rows ≤ 0
Empty output
Outer loop never runs. Validate and re-prompt for interactive programs.
Bad input
Use TryParse
Convert.ToInt32 throws on letters — prefer int.TryParse.
Analysis
Time and Space Complexity
Program
Time
Extra space
Nested loops (Examples 1–2)
O(rows²)
O(1)
new string('*', i) (Example 3)
O(rows²)
O(rows) per temporary row string
Total stars printed = n + (n-1) + … + 1 = n(n+1)/2, which is still quadratic in n — identical to Program 1.
Remember
Key Takeaways
Rule: outer value i prints exactly i stars, with i counting from rows down to 1.
Same as Program 1: only the outer loop direction changes; the inner star loop stays j = 1..i.
Break the row: call WriteLine only after the inner loop.
Complexity:O(n²) time from the triangular star count; O(1) extra space for nested loops.
One line: for i from rows down to 1, print i stars with Write, then WriteLine.
Frequently Asked Questions
The outer loop runs i from rows down to 1. For each i, the inner loop prints i stars. The first output line uses i equal to rows so it is the longest; each later line has a smaller i, so the triangle points downward.
Program 1 uses for (i = 1; i <= rows; i++) so stars grow. This program uses for (i = rows; i >= 1; i--) so stars shrink. The inner loop still runs j from 1 to i.
Yes. Use for (i = 1; i <= rows; i++) and print (rows - i + 1) stars in the inner loop. Both styles produce the same shape.
Console.Write stays on the same line. Console.WriteLine ends the current line. Stars use Write; the row break uses WriteLine after the inner loop.
O(n²) for n rows. Total stars are still n(n+1)/2, same as the upright triangle.
Yes. Console.WriteLine(new string('*', i)) prints a full row in one call while i counts down.
Prefer int.TryParse(Console.ReadLine(), out rows) 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?
This inverted triangle uses the same inner loop as Program 1 — only the outer loop direction changes. Total stars stay n(n+1)/2, so complexity is still O(n²).
