The powers of 11 pattern prints one number per line, starting at 1 and multiplying by 11 each row.
Rule: res starts at 1; each next row is res * 11
1
11
121
1331
14641 ← n = 5Unlike Program 47 (2D concentric diamond), this is a 1D sequence — one loop, one running variable, no nested loops.
One loop, one running variable — log the current value, then multiply by 11.
| Method | Idea | Best for |
|---|---|---|
| Running product | console.log(res); res *= 11; | Classic demos |
| Exponentiation | console.log(11 ** power) for power = 0..n-1 | Direct formula |
res = 1
repeat n times:
print res
res = res * 11| Goal | Pattern |
|---|---|
| Start value | let res = 1; |
| Loop rows | for (let i = 0; i < n; i++) |
| Print term | console.log(res); |
| Next term | res *= 11; |
| By power | console.log(11 ** power); |
| API | Effect | Use for |
|---|---|---|
line += … | Stays on the same row | Not needed here — one number per row |
console.log(res) | Prints the value and ends the row | Each power-of-11 term |
Same idea as C# WriteLine(res): each term is a complete line by itself.
Change the row count and the powers-of-11 sequence updates instantly.
Trace the first four rows — watch res before and after *= 11.
| Row | Print res | Then res *= 11 |
|---|---|---|
| 1 | 1 | 11 |
| 2 | 11 | 121 |
| 3 | 121 | 1331 |
| 4 | 1331 | 14641 |
Order matters: log first, then multiply — otherwise the first line becomes 11.
Three complete programs: fixed n = 5, prompt input, and an exponentiation approach. Use View Output for samples, or Try It Yourself to edit and run live.
n = 5Print the current term, then multiply by 11 for the next row.
const n = 5;
let res = 1;
for (let i = 0; i < n; i++) {
console.log(res);
res *= 11;
}1. Start at 1. res = 1 is 11^0 — the first line.
2. Log, then multiply. console.log(res) prints the current term; res *= 11 prepares the next.
3. Repeat n times. Five iterations produce 1, 11, 121, 1331, 14641.
Read n with prompt and validate before printing.
const n = parseInt(prompt("Enter number of rows:"), 10);
let res = 1;
if (!Number.isFinite(n) || n < 1) {
console.log("Please enter a positive integer.");
} else {
for (let i = 0; i < n; i++) {
console.log(res);
res *= 11;
}
}1. Prompt and validate. Use parseInt and require n >= 1.
2. Same sequence core. Only the source of n changes — print then multiply matches Example 1.
3. Entering 4. Four lines ending at 1331 (11^3).
Compute each term as 11 ** power with no running product.
const n = 5;
for (let power = 0; power < n; power++) {
console.log(11 ** power);
}1. Power from 0. 11 ** 0 is 1 — same first line as Example 1.
2. No running state. Each row is independent — useful when you need a single term by index.
3. Same sequence. For small n, results match res *= 11 exactly.
Check these before calling the solution done.
Log before multiplying
If you do res *= 11 before printing when res starts at 1, the first line becomes 11.
Number loses exactness for large n
Past roughly 15 safe digits, use BigInt (1n and *= 11n) for exact values.
Keep the factor 11
Multiplying by 10 gives 1, 10, 100, 1000… — a different pattern.
Single-row case
Output is just 1 — valid and useful for testing.
| Program | Time | Extra space |
|---|---|---|
| Running product (Examples 1–2) | O(n) | O(1) |
| Exponentiation (Example 3) | O(n) | O(1) |
One value per row — linear in n. Extra space is constant aside from printing.
console.log(res); res *= 11; — no if needed.console.log(11 ** power) for power = 0..n-1.O(n) time — one term per row.One line: print the current power-of-11 term, then multiply by 11 for the next row.
Start with let res = 1, log it, then update with res *= 11 each row. The first five lines are 1, 11, 121, 1331, 14641 — one value per line, O(n) time.
Continue with the next pattern in the JavaScript number-pattern series.
12 people found this page helpful