Shape Rule
1..i digits on row i
Row rows prints 1..rows, then one fewer digit each line, ending with a single 1.

The descending number triangle pattern is the classic first console pattern: nested loops, System.out.print vs newline, and a clear visual result. This tutorial covers the shape rule, loop structure, a live preview, algorithm steps, worked Java examples, edge cases, and complexity.
1..i digits on row i
Row rows prints 1..rows, then one fewer digit each line, ending with a single 1.
Rows
for (i = rows; i >= 1; i--) walks each line from the longest down to one digit.
Digits
for (j = 1; j <= i; j++) prints digits 1 through i on that row.
Same line / next line
Digits use System.out.print(j); end each row with System.out.println().
1–20 rows
Pick a row count and draw the descending number triangle instantly in the browser.
Complexity
Total digit prints = n(n+1)/2; extra memory stays O(1).
A descending number triangle pattern starts with the longest row and loses one digit per line. Each row prints consecutive digits from 1 up to the current row length, shrinking from top to bottom.
In Java you usually solve it with two nested for loops: the outer loop picks the row, the inner loop prints digits 1..i on that row, then System.out.println() moves to the next line.
It is the standard first pattern exercise in Java courses. Once nested loops and System.out.print click, pyramids, diamonds, and hollow shapes become much easier.
On row i, print digits 1 through i.
Outer counts down rows; inner prints digits.
System.out.print(j) in the inner loop; System.out.println() after.
Gateway to left-shifted, pyramid, and hollow patterns.
In short: for each row i from rows down to 1, print digits 1..i with System.out.print(j), then call System.out.println().
Given a positive integer rows, print a descending number triangle: each row i shows digits 1 through i, with the outer loop counting from rows down to 1.
// First 5 rows (conceptual shape)
// 12345
// 1234
// 123
// 12
// 1 | Item | Type | Description |
|---|---|---|
rows | int | Number of triangle lines to print (typically ≥ 1). |
| Printed output | text | Each row prints 1..i; the top row has rows digits, the bottom row has one digit. |
for i from rows down to 1:
for j from 1 to i:
print j (no newline)
print newline | Approach | Idea | Best for |
|---|---|---|
| Nested loops | Outer rows + inner digits | Learning and interviews |
(char)('0' + j) | Char-cast digit output | Leaner alternative to print(int) |
| Goal | Pattern |
|---|---|
| Walk each row | for (i = rows; i >= 1; i--) |
Print digits 1..i | for (j = 1; j <= i; j++) System.out.print(j); |
| End the row | System.out.println(); |
| Char-cast shortcut | System.out.print((char)('0' + j)); |
| Ascending variant | for (i = 1; i <= rows; i++) (grows upward) |
Same triangle — different ways to emit characters.
same linePrints a digit without moving to the next line
new lineEnds the current row after all digits are printed
(char)('0' + j)Writes one digit when j is 1..9
loops firstMaster nested loops before the string shortcut
Reach for this triangle when teaching or testing nested-loop basics.
Most C pattern series start here before pyramids and diamonds.
Outer/inner bound practice with an immediate visual check.
Combine loops with Scanner for a flexible row count.
Try left-shifted starts (Program 2), pyramids, or spaced digits next.
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.
Choose a row count between 1 and 20 and draw the descending number triangle in the browser.
Three complete Java programs — fixed row count, Scanner input, and a char-cast shortcut. Click View Output to reveal sample console results.
Print five rows of the descending number triangle with nested loops.
rows = 5Hard-coded height — ideal for first demos and screenshots.
public class DescendingNumberTriangle {
public static void main(String[] args) {
int rows = 5;
for (int i = rows; i >= 1; i--) {
for (int j = 1; j <= i; j++)
System.out.print(j);
System.out.println();
}
}
} When i = 5, the inner loop prints 12345. When i = 4, it prints 1234, and so on until i = 1 prints 1. System.out.println() after the inner loop starts the next row.
Let the user choose the height at runtime.
Read the row count with sc.nextInt() (check hasNextInt() in real apps).
import java.util.Scanner;
public class DescendingNumberTriangleInput {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Enter the number of rows: ");
int rows = sc.nextInt();
for (int i = rows; i >= 1; i--) {
for (int j = 1; j <= i; j++)
System.out.print(j);
System.out.println();
}
sc.close();
}
} Same nested-loop core as Example 1; only the source of rows changes. Non-numeric input leaves rows unset if you call nextInt() without checking hasNextInt() — always check it in safer labs.
Same shape using a char cast instead of System.out.print(j) for each digit.
(char)('0' + j)Write each digit with a char cast, then end the row with System.out.println().
public class DescendingNumberChar {
public static void main(String[] args) {
int rows = 5;
for (int i = rows; i >= 1; i--) {
for (int j = 1; j <= i; j++)
System.out.print((char)('0' + j));
System.out.println();
}
}
} System.out.print((char)('0' + j)) writes one digit when j is 1..9 without a format string. Same nested-loop structure as Example 1; a leaner alternative to System.out.print(j). Keep either style for exams that want both loop bounds visible.
System.out is built in; use Scanner when reading input. Set rows (fixed or from input).
for (i = rows; i >= 1; i--) selects the current line, starting at the widest.
for (j = 1; j <= i; j++) prints digits 1..i with System.out.print(j).
System.out.println() ends the row so the next outer iteration starts fresh.
Total digit prints: 1+2+…+n = n(n+1)/2 — O(n²) time, O(1) extra memory.
rows = 4Trace each outer-loop value of i (counting down) and count how many digits the inner loop prints.
i | Inner j range | Printed row | Digits this row |
|---|---|---|---|
4 | 1..4 | 1234 | 4 |
3 | 1..3 | 123 | 3 |
2 | 1..2 | 12 | 2 |
1 | 1..1 | 1 | 1 |
Total digit prints: 1 + 2 + 3 + 4 = 10 = 4×5/2.
Where this tiny pattern (and its loop structure) shows up beyond the homework prompt.
Clearest visual proof that outer and inner bounds interact.
Example: change j <= i and watch the shape change.
Foundation for inverted, pyramid, diamond, and hollow variants.
Example: Program 2 changes the inner start value each row.
Practice System.out.print vs row newline without complex math.
Example: put System.out.println() inside the inner loop by mistake.
Swap digits for letters, stars, or spaced output once the loop works.
Example: print j + " " for spaced digits on each row.
Triangular totals make O(n²) concrete for beginners.
Example: count printed digits for n = 10 → 55.
Pair the pattern with Scanner and positive-row checks.
Example: reject rows <= 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.
Why this pattern earns a permanent spot in beginner Java courses.
Wrong bounds show up immediately as a broken staircase.
Only loops and console output — no arrays or math libraries.
Invert, center, hollow, or change the fill character with small edits.
Streaming output needs no storage beyond loop counters.
Pro Tip: learn the nested-loop version first; treat (char)('0' + j) as a polish shortcut afterward.
Small habits that keep number-pattern code clean.
Use rows (or n) and keep i/j for row/column — or rename to row/col.
sc.hasNextInt()Avoid using uninitialized rows when the user types letters instead of a number.
Only call System.out.println() after the inner loop finishes the row.
rows..1 on the outer loop with j <= i matches “row i prints digits 1..i” naturally.
Trace rows = 3 on paper before coding larger demos.
Pro Tip: if the output is a vertical list of single digits, you almost certainly put System.out.println() inside the inner loop.
Mistakes that commonly break descending number patterns.
Each digit lands on its own line — you get a column, not a triangle.
→ Use System.out.print(j) for digits; System.out.println() only after the inner loop.
j <= rows prints a rectangle; wrong outer bounds flatten or invert the shape.
→ For this shape, keep j <= i.
Omitting System.out.println() glues every digit onto one endless line.
→ Always end the row after the inner loop.
Letters or empty input leave rows unset if you call nextInt() without checking hasNextInt().
→ Call sc.hasNextInt() and re-prompt on failure.
Switching to i = 0 without adjusting the inner bound prints an empty first row or wrong counts.
→ If 0-based, print digits 1..i+1 (e.g. j <= i + 1).
Check these inputs before calling the solution done.
Output is just 1 on one line.
Outer loop never runs — print nothing or show a message.
rows < 0Treat as invalid; re-prompt instead of silent empty output.
Output grows as n²/2 characters — fine for labs, noisy for huge n.
Unchecked Scanner input leaves rows unset — call sc.hasNextInt() first.
Try System.out.print(j + " ") for spaces between numbers.
Try these variations to lock in the pattern.
for (i = 1; i <= rows; i++) as outer loopsc.hasNextInt() until rows >= 1System.out.print(j + " ") between digitsn(n+1)/2 — hence O(n²) time.System.out.print(j) stays on the line; System.out.println() advances — mix them carefully.rows > 0 for interactive programs; rows = 1 should print a single 1.Quick Takeaway: outer loop picks the row, inner loop prints digits 1..i, then break the line — that is the whole pattern.
| Program | Time | Extra space |
|---|---|---|
| Nested loops (Examples 1–2) | O(rows²) | O(1) |
(char)('0' + j) (Example 3) | O(rows²) | O(1) |
The descending number triangle pattern is a small nested-loop exercise with lasting payoff: row/column thinking, System.out.print vs row newline, and O(n²) intuition. Master the classic two-loop version, then optionally try the char-cast shortcut in Example 3.
Practice the three examples above, then continue to Program 2 for a left-shifted descending triangle.
Row i prints 1..i — keep System.out.print(j) for digits and System.out.println() for the break, and validate row counts when reading input.
System.out.print(j) for digits and System.out.println() after each rowrows ≥ 1 for interactive programssc.hasNextInt() before using rowsSystem.out.println() inside the inner digit looprows = 1 edge casePrint the triangle the beginner-friendly way.
Row i prints 1..i
DefinitionControls each row
CodePrints digits with System.out.print(j)
CodeEnds each row
I/OO(n²) time
AnalysisRow i prints digits 1 through i. The outer loop counts down from rows, so the first line is longest and each row shortens by one digit — still O(n²) total prints. This is the classic first console pattern in Java labs.
Shift the start digit each row — 12345, 2345, 345, 45, 5.
12 people found this page helpful