Print 1, 11, 121, 1331… in C#

Beginner

⏱️ 9 min read

📚 Updated: Aug 2026

🎯 3 Code Examples

🚀 Live Preview

Loops + Number Sequence

Powers of 11 number pattern output in C# (1, 11, 121, 1331, 14641)

Overview

What You’ll Learn

Program 48 prints the powers-of-11 sequence: 1, 11, 121, 1331, 14641 — a natural step after Program 47’s 2D concentric diamond. This tutorial covers a simple loop with running state (res *= 11), a live preview, worked C# examples, edge cases, and complexity.

Shape Rule

Multiply by 11

Each row is the previous value times 11 — starting from 1.

Single Loop

i = 1..n

for (i = 1; i <= n; i++) prints one value per row.

Running State

res variable

res holds the current number — update with res *= 11 after each print.

Pascal Link

Early rows only

First few values mirror binomial coefficients until base-10 carries break the pattern.

Live Preview

n = 3..8

Pick row count and generate the sequence in the browser.

O(n)

Complexity

One value per row — n prints total; extra memory stays O(1).

Introduction

A powers-of-11 sequence prints one growing number per row: start at 1, then multiply by 11 for each next line. With n = 5, the output is 1, 11, 121, 1331, 14641.

In C# a single loop runs i = 1..n, a variable res holds the current value, and you print then update with res *= 11.

Why it matters?

It teaches running state in a loop — a simpler pattern after Program 47’s nested diamond grids.

Key Highlights

Start at 1

res = 1 first row.

Times 11

res *= 11 each step.

vs Program 47

Program 47 is a 2D diamond; Program 48 is a 1D sequence.

Series Foundation

Follow Program 47; continue to Program 49 next.

In short: loop i = 1..n, print res, update res *= 11, then WriteLine().

Foundation

📝 Problem & Approach

Given row count n = 5, print the powers-of-11 sequence — one growing number per line, starting at 1 and multiplying by 11 each step.

// n = 5
//1
//11
//121
//1331
//14641

Inputs & Outputs

Item	Type	Description
`n`	int	How many rows (values) to print.
`res`	int	Running value — starts at `1`, updated with `res *= 11`.
`i`	int	Loop counter from `1` to `n`.
Printed output	text	One number per line — `1`, `11`, `121`, …

Minimal workflow

Pseudocode

res = 1
for i from 1 to n:
    print res
    res = res * 11

Approach comparison

Approach	Idea	Best for
if/else on first row	`if (i == 1) res = i; else res *= 11`	Matching classic textbook code
Print then multiply	`WriteLine(res); res *= 11;`	Cleaner loop body — see Example 3
User-input n	`int.TryParse(...)`	Flexible row count
`BigInteger`	Arbitrary-precision multiply	Many rows without overflow

Cheat Sheet

⚡ Quick Reference

Goal	Pattern
Initialize	`int res = 1;`
Loop rows	`for (i = 1; i <= n; i++)`
Print value	`Console.WriteLine(res);`
Update state	`res = 11;` (or `res = res 11;`)
Classic first-row check	`if (i == 1) res = i; else res *= 11;`
Cleaner variant	Print first, multiply after — no `if` needed
Program 47 contrast	Program 47 is a 2D diamond; Program 48 is a 1D sequence

Compare

📋 if/else vs User Input vs Print-Then-Multiply

Same sequence — three ways to structure the loop and set row count.

Classic

if (i == 1)

Special-case first row before multiply

User input

TryParse(n)

Read row count from console

Cleaner loop

print; res *= 11

No if/else — print then update

Large n

BigInteger

Avoid int overflow past ~row 10

Multiplier

* 11

Each step grows by one power of 11

Context

When This Pattern Shows Up

Reach for this pattern when teaching running state, sequence growth, and single-loop output.

Post Program 47 exercise
Natural follow-up after Program 47’s nested diamond — simpler 1D sequence with one loop.
Running state
res carries value from row to row — core loop-state pattern.
Pascal connection
Early rows mirror binomial coefficients until base-10 carries break the match.
Gateway to variants
Compare Program 47 (2D diamond) and Program 49 (next in series) next.
Not a UI layout tool
This is a console teaching pattern — not how you build modern app screens.

Key benefit: one small program that locks in loop state, multiply-update logic, and O(n) thinking.

Interactive

🔮 Live Preview

Choose row count n between 3 and 8 and generate the powers-of-11 sequence in the browser.

Hands-On

Examples Gallery

Three complete C# programs — fixed rows, user input, and a cleaner print-then-multiply loop. Click View Output to reveal sample console results.

📚 Getting Started

Print five rows of the powers-of-11 sequence with the classic if/else first-row check.

Example 1 — Fixed `n = 5`

Hard-coded row count — matches the textbook version with if (i == 1).

using System;

namespace MyApp
{
    class Program
    {
        static void Main(string[] args)
        {
            int i, res = 1;

            for (i = 1; i <= 5; i++)
            {
                if (i == 1)
                    res = i;
                else
                    res = res * 11;

                Console.Write(res);
                Console.WriteLine();
            }
        }
    }
}

How It Works

Row 1 sets res = 1 and prints it. Each later row multiplies res by 11 before printing — producing 11, 121, 1331, and 14641.

📈 User Input

Read row count n from the console with safe parsing.

Example 2 — User Input n

Read n from the console with int.TryParse — reject invalid input gracefully.

using System;

namespace MyApp
{
    class Program
    {
        static void Main(string[] args)
        {
            int n;
            Console.Write("Enter number of rows: ");
            if (!int.TryParse(Console.ReadLine(), out n) || n <= 0)
            {
                Console.WriteLine("Please enter a positive integer.");
                return;
            }

            int res = 1;
            for (int i = 1; i <= n; i++)
            {
                if (i == 1)
                    res = 1;
                else
                    res = res * 11;

                Console.WriteLine(res);
            }
        }
    }
}

How It Works

Same multiply logic as Example 1; only the source of n changes. For large n, switch to BigInteger to avoid overflow.

⚡ Cleaner Loop

Print first, then multiply — no special-case if needed.

Example 3 — Print Then Multiply

Print res at the start of each iteration, then update with res *= 11.

using System;

namespace MyApp
{
    class Program
    {
        static void Main(string[] args)
        {
            int res = 1;

            for (int i = 1; i <= 5; i++)
            {
                Console.WriteLine(res);
                res *= 11;
            }
        }
    }
}

How It Works

Because res starts at 1, the first print is correct without an if. Multiply happens after printing, so the next iteration gets the updated value.

🧠 How the Algorithm Prints Rows

Initialize result

int res = 1; holds the current value to print on each row.

Setup

Loop rows

for (i = 1; i <= n; i++) runs once per printed line.

Loop

Update state (classic)

First row: res = i. Later rows: res = res * 11 — or print first, then res *= 11.

State

Print value

Console.WriteLine(res) outputs one number per row.

Output

Sequence complete

One value per row — O(n) time, O(1) extra memory.

Trace

🔎 Worked Walkthrough — `n = 5`

Trace each iteration — what res holds before and after the multiply step (print-then-multiply variant).

`i`	Prints	After `res *= 11`
`1`	`1`	`11`
`2`	`11`	`121`
`3`	`121`	`1331`
`4`	`1331`	`14641`
`5`	`14641`	`161051` (next row if continued)

Row 6 would print 161051 — the first value where digit carries break the Pascal-triangle visual match, but the multiply loop still works correctly.

Use Cases

Where this tiny pattern (and its loop structure) shows up beyond the homework prompt.

1. Running State in Loops

Classic intro to carrying a value from iteration to iteration.

Example: trace the walkthrough table for n = 5.

2. Pattern Series Base

Follow Program 47’s diamond; continue to Program 49 next.

Example: compare 2D vs 1D pattern complexity.

3. Console Formatting Drills

Practice Write vs WriteLine with one value per row.

Example: use WriteLine(res) instead of Write + WriteLine().

4. Pascal / Binomial Link

Early rows mirror binomial coefficients — great math tie-in.

Example: row 5 prints 14641 = coefficients of (a+b)&sup4;.

5. Complexity Intuition

n rows, one print each — O(n) is easy to count.

Example: 5 rows = 5 prints total.

6. Overflow Awareness

Values grow fast — intro to BigInteger for larger n.

Example: row 10 exceeds int max — use BigInteger.

Pro Tip: when an interviewer asks for patterns, explain the state variable first — then write the loop. The story matters as much as the code.

Advantages

Why this pattern earns a permanent spot in beginner C# courses.

1. Single Loop Simplicity
No nested loops — easier after Program 47’s diamond grid.
2. Minimal Concepts
Only one loop, one variable, and console output — no arrays needed.
3. Easy to Extend
Change n, swap to print-then-multiply, or use BigInteger for many rows.
4. O(1) Extra Memory
Streaming output needs no storage beyond res and loop counter.

Pro Tip: trace the walkthrough table on paper — watch how res grows by one power of 11 each row.

Usage Tips

Small habits that keep number-pattern code clean.

1. Initialize res = 1
Start with 1 so the first printed value is correct.
2. Prefer TryParse
Avoid crashes when the user types letters instead of a number.
3. Print Then Multiply
Cleaner than if (i == 1) — see Example 3.
4. Use BigInteger for Large n
int overflows around row 10 — switch to arbitrary precision.
5. Dry-Run n = 3
Trace three rows on paper before coding the full n = 5 demo.

Pro Tip: if values look wrong after row 1, check whether you multiply before or after printing.

Common Pitfalls

Mistakes that commonly break powers-of-11 sequence patterns.

1. Multiplying Before First Print
First row prints 11 instead of 1 if you multiply before printing.
→ Print first, then res *= 11 — or use the if (i == 1) check.
2. Forgetting to Update res
Every row prints 1 if you never multiply.
→ Add res = res * 11 or res *= 11 each iteration.
3. int Overflow
Values exceed int.MaxValue around row 10.
→ Use System.Numerics.BigInteger for larger row counts.
4. Wrong Multiplier
Using 10 or 12 instead of 11 produces a different sequence.
→ Confirm the pattern requires multiply-by-11.
5. Blind Convert.ToInt32
Letters or empty input throw FormatException.
→ Prefer int.TryParse and re-prompt on failure.

Edge Cases

Check these inputs before calling the solution done.

n = 1

Single row

Output is just 1 on one line.

n = 0

Empty output

Loop never runs — print nothing or show a message.

Negative

`n < 0`

Treat as invalid; re-prompt instead of silent empty output.

n = 5

Classic demo

1, 11, 121, 1331, 14641 — last row before carry breaks Pascal match.

Bad input

Non-numeric ReadLine

Convert.ToInt32 throws — use TryParse.

Large n

Overflow risk

Values grow exponentially — use BigInteger past ~row 10.

Drill

🎯 Practice Problems

Try these variations to lock in the pattern.

1. Compare with Program 47

Program 47 uses nested loops for a 2D diamond
Program 48 uses one loop and running state

2. Change n

Try n = 3 or n = 8 in the live preview
Same loop, different row count

3. Next in series

Continue with Program 49
Build on sequence patterns

4. BigInteger version

Rewrite with BigInteger res = 1
Print 15+ rows without overflow

Important

Notes

Running state. res carries the current value — update with res *= 11 after each print (or before, with an if-check).
Console.WriteLine(res) is cleaner than Write(res) + empty WriteLine().
Validate n > 0 for interactive programs; n = 1 prints a single 1.
n rows, one print each — total work is O(n) with O(1) extra memory.

Quick Takeaway: loop i = 1..n, print res, update res *= 11, then WriteLine().

Analysis

⏱️ Time and Space Complexity

Program	Time	Extra space
Single loop (Examples 1–3)	`O(n)`	`O(1)`
BigInteger variant	`O(n × d)` where d = digit count	`O(d)` for stored value

Wrap Up

🎉 Conclusion

The powers-of-11 sequence is a simple follow-up to Program 47: one loop, a running res variable, and multiply-by-11 each row. Master the fixed-n version, then try user input and the cleaner print-then-multiply loop.

Practice the three examples above, then continue to Program 49 for the next pattern in the series.

Print first, multiply after — or use if (i == 1) in the classic variant. Both produce the same first five rows.

View Examples Gallery Continue to Program 49

Pro Tips

💡 Best Practices

✅ Do

Initialize res = 1 before the loop
Print then res *= 11 for a clean loop body
Use int.TryParse for user input
Switch to BigInteger for many rows
Validate n > 0 for interactive programs

❌ Don’t

Multiply before the first print without an if-check
Forget to update res each iteration
Use int for row counts that cause overflow
Ignore bad console input in user-facing demos
Skip the walkthrough trace before coding

Summary

Key Takeaways

Knowledge Unlocked

Five things to remember about this powers-of-11 sequence

Print the pattern the beginner-friendly way.

Core concepts

△ 01

Rule

res *= 11 each row

Definition

↻ 02

Start

res = 1

Code

↓ 03

Loop

i = 1..n

Code

↵ 04

Output

One value per line

Logic

O 05

Complexity

O(n) time

Analysis

❓ Frequently Asked Questions

How does Program 48 generate 1, 11, 121, 1331, 14641?

It starts with res = 1 and, for each next row, multiplies res by 11. This produces 1, 11, 121, 1331, 14641 for the first 5 lines.

Can I print more rows?

Yes — increase the loop limit or read n from user input. For many rows, switch to BigInteger because values grow quickly.

Why does multiplying by 11 stop matching Pascal's triangle?

11^n shows binomial coefficients only while there are no carry-overs in base-10. Once carries occur, digits no longer match the triangle.

What is the time complexity?

O(n) for n rows because the program computes and prints one value per row.

How is this different from Program 47?

Program 47 prints a 2D concentric number diamond with nested loops. Program 48 prints a 1D growing sequence with one loop.

Will int overflow?

Yes — int overflows around row 10 (14641 * 11^5 exceeds int max). Use BigInteger for larger n.

Can I simplify the if (i == 1) check?

Yes — print res first, then multiply: Console.WriteLine(res); res *= 11; — see Example 3.

What is the next value after 14641?

161051 — still valid, but digit carries mean it no longer mirrors Pascal row 5 coefficients.

Do I need nested loops?

No — a single loop with a running variable is enough for this sequence pattern.

Did you Know? 🔊

Start with res = 1, print it, then update with res = res * 11 each row. For the first five rows you get 1, 11, 121, 1331, 14641 — one value per line, O(n) time.

Continue to Program 49

Move on to the next pattern in the C# number-pattern series.

Program 49 tutorial →

About the author

Mari Selvan M P 🔗

Developer, cloud engineer, and technical writer

Experience 12 years building web and cloud systems
Focus Full Stack Development, AWS, and Developer Education

I write practical tutorials so students and working developers can learn by doing—from databases and APIs to deployment on AWS.

AWS Certified Developer – Associate (Credly)

12 people found this page helpful

C# Number Pattern 47 C# Number Pattern 49

Print 1, 11, 121, 1331… in C#

What You’ll Learn

Shape Rule

Single Loop

Running State

Pascal Link

Live Preview

O(n)

Introduction

Why it matters?

Start at 1

Times 11

vs Program 47

Series Foundation

📝 Problem & Approach

Inputs & Outputs

Minimal workflow

Approach comparison

⚡ Quick Reference

📋 if/else vs User Input vs Print-Then-Multiply

When This Pattern Shows Up

Post Program 47 exercise

Running state

Pascal connection

Gateway to variants

Not a UI layout tool

🔮 Live Preview

Examples Gallery

📚 Getting Started

Example 1 — Fixed n = 5

How It Works

📈 User Input

Example 2 — User Input n

How It Works

⚡ Cleaner Loop

Example 3 — Print Then Multiply

How It Works

🧠 How the Algorithm Prints Rows

Initialize result

Loop rows

Update state (classic)

Print value

Sequence complete

🔎 Worked Walkthrough — n = 5

Use Cases

1. Running State in Loops

2. Pattern Series Base

3. Console Formatting Drills

4. Pascal / Binomial Link

5. Complexity Intuition

6. Overflow Awareness

Advantages

1. Single Loop Simplicity

2. Minimal Concepts

3. Easy to Extend

4. O(1) Extra Memory

Usage Tips

1. Initialize res = 1

2. Prefer TryParse

3. Print Then Multiply

4. Use BigInteger for Large n

5. Dry-Run n = 3

Common Pitfalls

1. Multiplying Before First Print

2. Forgetting to Update res

3. int Overflow

4. Wrong Multiplier

5. Blind Convert.ToInt32

Edge Cases

Single row

Empty output

n < 0

Classic demo

Non-numeric ReadLine

Overflow risk

🎯 Practice Problems

1. Compare with Program 47

2. Change n

3. Next in series

4. BigInteger version

Example 1 — Fixed `n = 5`

🔎 Worked Walkthrough — `n = 5`

`n < 0`