Shape Rule
Right-aligned triangle
Row i prints i numbers from counter k, with leading spaces while j > i.

The right-aligned incremental triangle prints 1, then 2 3, then 4 5 6, … — a natural follow-up after Program 34’s zero-based i + j triangle. This tutorial covers the continuous counter k, fixed-width formatting, nested loops, a live preview, worked JavaScript examples, edge cases, and complexity.
Right-aligned triangle
Row i prints i numbers from counter k, with leading spaces while j > i.
i = 1..rows
for (let i = 1; i <= rows; i++) — one growing row per iteration.
rows..1
for (let j = rows; j >= 1; j--) — fixed width; spaces or numbers per column.
%3d format
line += String(k).padStart(3, " "); k += 1 — continuous sequence with fixed-width columns.
3–7 rows
Pick a row count and draw the right-aligned incremental triangle in the browser.
Complexity
Total prints = n(n+1)/2 — work scales as n².
A right-aligned incremental number triangle prints a continuous sequence: 1, then 2 3, then 4 5 6, and so on. With rows = 5, numbers shift right each row thanks to leading spaces.
In JavaScript you use nested loops with a counter k: append " " while j > i, otherwise line += String(k).padStart(3, " "); k += 1, then console.log(line).
It combines nested loops, a running counter, and formatted output — a step after Program 34’s formula-based triangle.
Continuous sequence.
Right alignment.
Fixed-width columns.
Follow Program 34; continue to Program 36 (decreasing) next.
In short: outer i = 1..rows, inner j = rows..1, spaces while j > i, else padStart(3) with k += 1, then console.log(line).
Given rows = 5, print a right-aligned incremental triangle: counter k starts at 1, leading spaces while j > i, then fixed-width numbers.
# rows = 5
# 1
# 2 3
# 4 5 6
# 7 8 9 10
#11 12 13 14 15 | Item | Type | Description |
|---|---|---|
rows | int | Triangle height — number of lines to print. |
i | int | Outer loop — current row (1 to rows). |
j | int | Inner loop — fixed width from rows down to 1. |
k | int | Continuous counter — starts at 1, increments per printed number. |
k = 1
for i from 1 to rows:
for j from rows down to 1:
if j > i: append 3 spaces
else: append k with padStart(3); k += 1
console.log(line) | Approach | Idea | Best for |
|---|---|---|
| Fixed rows | 1, 2 3, … | Learning and interviews |
| User-input rows | parseInt(prompt(...), 10) | Configurable triangle size |
| Compact trace | rows = 3 on paper first | Debugging loop bounds |
| Goal | Pattern |
|---|---|
| Outer loop | for (let i = 1; i <= rows; i++) |
| Inner loop | for (let j = rows; j >= 1; j--) |
| Leading spaces | if (j > i) line += " " |
| Print number | line += String(k).padStart(3, " "); k += 1 |
| End the row | console.log(line) |
| User input | parseInt(prompt(...), 10) |
Same right-aligned incremental triangle — different ways to control the row count.
i = 1..rowsOne growing row per iteration
k += 1Continuous sequence
j = rows..1Fixed width per row
j > iPrint spaces, else number
Reach for this pattern when teaching formatted console output, continuous counters, and right-aligned triangles.
Natural follow-up — adds right alignment and a continuous counter instead of a per-cell formula.
Practice padStart(3) and fixed-width columns before tackling larger patterns.
Combine loops with prompt() and Number.isFinite for flexible row counts.
Compare Program 30 (descending digits) and Program 36 (decreasing sequence) next.
This is a console teaching pattern — not how you build modern app screens.
Key benefit: one small program that locks in nested loops, formatted output, and O(n²) thinking.
Choose a row count between 3 and 7 and draw the right-aligned incremental triangle in the browser.
Three complete JavaScript programs — fixed rows, user input, and a smaller trace demo. Click View Output to reveal sample console results, or Try it Yourself to run the code live.
Print five rows of the right-aligned incremental triangle with counter k and padStart(3) formatting.
rows = 5Hard-coded row count — ideal for first demos and screenshots.
let k = 1;
const rows = 5;
for (let i = 1; i <= rows; i++) {
let line = "";
for (let j = rows; j >= 1; j--) {
if (j > i) {
line += " ";
} else {
line += String(k).padStart(3, " ");
k += 1;
}
}
console.log(line);
} When i = 1, the inner loop appends four space groups then 1. When i = 5, no leading spaces — output 11 12 13 14 15 with fixed-width columns.
Read the row count with prompt() and parseInt() instead of hard-coding 5.
Read rows with prompt() and parseInt(); the inner loop uses rows as the fixed width.
const rowsInput = prompt("Enter rows:");
const rows = parseInt(rowsInput, 10);
if (!Number.isFinite(rows) || rows < 1) {
console.log("Please enter a positive integer.");
} else {
let k = 1;
for (let i = 1; i <= rows; i++) {
let line = "";
for (let j = rows; j >= 1; j--) {
if (j > i) {
line += " ";
} else {
line += String(k).padStart(3, " ");
k += 1;
}
}
console.log(line);
}
} Same counter and formatting core as Example 1; only rows comes from user input instead of being hard-coded as 5. Non-numeric input yields NaN with bare parseInt(prompt(), 10) — validate with Number.isFinite for safer labs.
Run with rows = 3 to trace every row on paper before scaling up.
rows = 3Same nested-loop counter with a smaller row count for quick tracing.
const rows = 3;
let k = 1;
for (let i = 1; i <= rows; i++) {
let line = "";
for (let j = rows; j >= 1; j--) {
if (j > i) {
line += " ";
} else {
line += String(k).padStart(3, " ");
k += 1;
}
}
console.log(line);
} Only rows changes from 5 to 3 — the counter and spacing logic stays identical. Trace i = 1, 2, 3 on paper to see how leading spaces shrink each row.
No imports needed for fixed rows; use prompt() when reading. Set let k = 1 and loop variables i, j with const rows = 5.
for (let i = 1; i <= rows; i++) — ascending outer loop; one right-aligned row per iteration.
for (let j = rows; j >= 1; j--) — fixed width; spaces while j > i, else append k.
line += String(k).padStart(3, " "); k += 1 — fixed-width columns; counter continues across rows.
console.log(line) ends the row after the inner loop finishes.
Total numbers = n(n+1)/2 — O(n²) time, O(1) extra memory.
rows = 5Trace each outer-loop value of i, leading spaces, numbers printed from k, and full row output.
i | Leading space groups | Numbers printed | Row output |
|---|---|---|---|
1 | 4 | 1 | 1 |
2 | 3 | 2, 3 | 2 3 |
3 | 2 | 4, 5, 6 | 4 5 6 |
4 | 1 | 7, 8, 9, 10 | 7 8 9 10 |
5 | 0 | 11, 12, 13, 14, 15 | 11 12 13 14 15 |
Leading space groups per row = rows - i — zero when i = rows. Total numbers printed = rows(rows+1)/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: flip j > i to j <= i for spaces and watch alignment break.
Foundation for right-aligned variants and continuous counter patterns.
Example: compare with Program 30 (descending digits) and Program 36 (decreasing sequence).
Practice padStart(3) formatting and fixed-width columns.
Example: remove padStart(3) and watch two-digit values misalign.
Add three-space groups for alignment once the two-loop structure works.
Example: use a single space instead of " " and watch columns drift.
Triangular totals make O(n²) concrete for beginners.
Example: count printed numbers for rows = 5 — total is 1+2+3+4+5 = 15.
Pair the pattern with Number.isFinite and positive-row validation.
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 JavaScript 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: trace i, j, and k on paper for rows = 3 before coding — watch how leading spaces shrink each row.
Small habits that keep number-pattern code clean.
Counter k must start at 1 before the outer loop and persist across rows.
Number.isFiniteAvoid undefined behavior when the user types letters instead of a number.
Only call console.log(line) after the inner loop finishes the row.
Write the next value of k for each (i, j) pair before coding the loops.
Trace i = 1..3 on paper before coding the full rows = 5 demo.
Pro Tip: if the output is a vertical list of single digits per line, you almost certainly put console.log(line) inside the inner loop.
Mistakes that commonly break right-aligned incremental triangles.
Each digit lands on its own line — you get a column, not a triangle.
→ Use line += String(k).padStart(3, " "); k += 1; console.log(line) only after the inner loop.
Putting k = 1 inside the outer loop restarts the sequence on every row.
→ Declare k = 1 once before the outer loop; only increment with k += 1 when printing.
Single spaces instead of " " break column alignment with padStart(3).
→ Print three spaces while j > i to match the fixed-width number columns.
Plain line += k makes two-digit values crowd earlier columns.
→ Use line += String(k).padStart(3, " "); k += 1 for consistent column width.
parseInt(prompt())Letters or empty input yield NaN with bare parseInt(prompt(), 10).
→ Validate with Number.isFinite and re-prompt on failure.
Check these inputs before calling the solution done.
Output is just 1 with leading spaces — one value, one row.
Outer loop never runs when rows < 1 — print nothing or show a message.
rows < 1Treat as invalid; re-prompt instead of silent empty output.
Two rows: 1 and 2 3.
Bare parseInt(prompt(), 10) yields NaN on bad input — validate with Number.isFinite first.
Total numbers = rows(rows+1)/2 — grows quadratically with rows.
Try these variations to lock in the pattern.
j > i spacing, different filli, k = i(i+1)/2 + 1i more numbersrows >= 1 after reading inputlet k = 1 before loops. Inner loop runs j = rows..1 — append spaces while j > i, else padStart(3) with k += 1.line += String(k).padStart(3, " "); k += 1 stays on the line; console.log(line) advances — mix them carefully.rows >= 1 for interactive programs; rows = 1 prints a single 1.rows - i — compare with Program 30 where digits descend instead of a counter.Quick Takeaway: outer i = 1..rows, inner j = rows..1, spaces while j > i, else padStart(3) with k += 1, then console.log(line).
| Program | Time | Extra space |
|---|---|---|
| Nested loops (Examples 1–3) | O(n²) | O(1) |
| Smaller demo (Example 3) | O(n²) | O(1) |
The right-aligned incremental number triangle is a compact lesson in nested loops, continuous counters, and formatted output: append spaces while j > i, use line += String(k).padStart(3, " "); k += 1 for each number, and end each row with console.log(line). Master the fixed-rows version, then try user input and a smaller trace demo.
Practice the three examples above, then continue to Program 36 for the decreasing right-aligned sequence.
Keep k outside the outer loop — validate rows when reading from the console.
for (let i = 1; i <= rows; i++) in the outer loopfor (let j = rows; j >= 1; j--) with fixed widthline += String(k).padStart(3, " "); k += 1parseInt(prompt(), 10) with Number.isFiniteconsole.log(line) inside the inner loopk = 1 inside the outer loop" " for alignmentrows = 1 edge casePrint the pattern the beginner-friendly way.
k += 1 each print
DefinitionLeading spaces
CodeFixed width
Codeconsole.log(line) after the inner loop
O(n²) time
AnalysisA counter k starts at 1 and increments every time a number is printed. Leading spaces appear while j > i, and String(k).padStart(3, " ") keeps columns aligned as values grow past single digits.
Move on to the right-aligned decreasing number sequence in the JavaScript number-pattern series.
12 people found this page helpful