Increasing-Decreasing Number Pyramid Pattern in C#

Q: Why does row 3 print 34543?

Row 3 starts at 3, prints up to 5 (345), then prints back down to 3 (43) after m = m - 2 — producing 34543.

Q: Why does each row look like a palindrome?

Each row counts up from i to the peak 2i-1, then counts back down to i. The sequence reads the same left-to-right on each line.

Q: What does m = m - 2 do?

After the increasing loop, m is one past the peak. Subtracting 2 moves it to the value just before the peak so the decreasing loop does not repeat the peak digit.

Q: How do we avoid repeating the middle number?

Step back with m = m - 2 before the decreasing loop. The decreasing loop then runs i-1 times, skipping the peak.

Q: How can I change the number of rows?

Change rows or read it from user input with TryParse — see Example 2.

Q: What is the time complexity?

O(n²) for n rows because row i prints 2i-1 digits and 1+3+5+...+(2n-1) = n² total prints.

Q: How is this different from Program 51?

Program 51 uses a continuous counter with alternating direction across rows. Program 52 resets m = i each row and builds a palindromic line per row.

Q: Can I add spaces between digits?

Yes. Print with Console.Write(m++ + space) in both loops and trim trailing space if needed.

Q: How should I read rows safely?

Prefer int.TryParse(Console.ReadLine(), out rows) so bad input does not throw FormatException.

Q: What happens when rows is 1?

One row prints 1 — the decreasing loop k < i never runs when i = 1.

Beginner

⏱️ 10 min read

📚 Updated: Aug 2026

🎯 3 Code Examples

🚀 Live Preview

Nested Loops + Palindrome Rows

Increasing-decreasing number pyramid output in C# (1, 232, 34543, 4567654, 567898765)

Overview

What You’ll Learn

Program 52 prints an increasing-decreasing number pyramid: each row is palindromic — count up from i to the peak, then back down — a natural step after Program 51’s alternating number triangle. This tutorial covers two inner loops per row, peak step-back with m = m - 2, a live preview, worked C# examples, edge cases, and complexity.

Shape Rule

Palindromic row

Row i prints i..(2i-1) ascending, then back down to i — always 2i-1 digits.

Outer Loop

i = 1..rows

for (i = 1; i <= rows; i++) sets m = i as the starting number each row.

Increasing Half

j = 1..i

for (j = 1; j <= i; j++) Console.Write(m++); prints up to the peak.

Peak Step-Back

m = m - 2

Step back before the decreasing loop so the peak digit is not printed twice.

Decreasing Half

k = 1..(i-1)

for (k = 1; k < i; k++) Console.Write(m--); mirrors the ascending half.

O(n²)

Complexity

Total prints = 1+3+5+…+(2n-1) = n² — each row grows by 2 digits.

Introduction

An increasing-decreasing number pyramid pattern prints row i as a palindrome — count up from i to the peak 2i-1, then back down to i. With rows = 5, you get 1, 232, 34543, 4567654, 567898765.

In C# set m = i each row, print the increasing half with m++, step back with m = m - 2, then print the decreasing half with m-- before WriteLine().

Why it matters?

It bridges Program 51’s alternating triangle to palindromic rows — combining two inner loops with a peak step-back trick.

Key Highlights

Increasing half

m starts at i; print i times with m++.

Peak step-back

m = m - 2 skips repeating the peak digit.

vs Program 51

Program 51 uses a continuous counter; Program 52 resets m = i and builds a palindromic row.

Series Foundation

Follow Program 51; continue to Program 53 next.

In short: set m = i, print increasing with m++, step back m = m - 2, print decreasing with m--, then WriteLine().

Foundation

📝 Problem & Approach

Given row count rows = 5, print an increasing-decreasing number pyramid — row i shows a palindromic sequence from i up to 2i-1 and back.

// rows = 5
//1
//232
//34543
//4567654
//567898765

Inputs & Outputs

Item	Type	Description
`rows`	int	How many triangle rows to print.
`i` (outer)	int	Current row index — runs from `1` to `rows`.
`m`	int	Current print value — starts at `i` each row; incremented then decremented.
`j` (increasing)	int	Prints `i` ascending digits with `m++`.
`k` (decreasing)	int	Prints `i-1` descending digits with `m--` after `m = m - 2`.
Row length	int	Row `i` prints exactly `2i-1` digits.

Minimal workflow

Pseudocode

for i from 1 to rows:
    m = i
    for j from 1 to i:
        print m; m++
    m = m - 2
    for k from 1 to i - 1:
        print m; m--
    print newline

Approach comparison

Approach	Idea	Best for
Two inner loops	Increasing `m++`, then decreasing `m--` after `m = m - 2`	Learning and interviews
Peak step-back	`m = m - 2` skips repeating the peak digit	Palindromic row construction
User-input rows	`int.TryParse(...)`	Flexible row count
Compact trace	`rows = 3` on paper first	Quick dry-runs before full demo
Spaced variant	`Console.Write(m++ + " ")`	Easier reading per row

Cheat Sheet

⚡ Quick Reference

Goal	Pattern
Outer loop	`for (i = 1; i <= rows; i++)`
Init m per row	`int m = i;`
Increasing half	`for (j = 1; j <= i; j++) Console.Write(m++);`
Peak step-back	`m = m - 2;`
Decreasing half	`for (k = 1; k < i; k++) Console.Write(m--);`
End row	`Console.WriteLine();`
Program 51 contrast	Program 51 uses a continuous counter; Program 52 builds palindromic rows with m = i

Compare

📋 Fixed Rows vs User Input vs Compact Trace

Same triangle — three ways to set row count and format output.

Fixed rows

rows = 5

Hard-coded height for demos

User input

TryParse

Read row count from console

Compact trace

rows = 3

Quick dry-run on paper

Peak step-back

m = m - 2

Skip repeating the peak digit

Palindrome

2i - 1

Digits per row i

Context

When This Pattern Shows Up

Reach for this pattern when teaching palindromic sequences, two inner loops per row, and the peak step-back trick.

Post Program 51 exercise
Natural follow-up after Program 51’s alternating triangle — introduces palindromic rows per line.
Palindrome drills
Each row reads symmetrically — good bridge to string palindrome problems.
Two halves per row
Total prints = 1+3+5+…+(2n-1) = n² — classic nested-loop complexity.
Gateway to variants
Compare Program 51 (alternating triangle) with this palindromic pyramid, then continue to Program 53.
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 palindromic rows, peak step-back, and O(n²) thinking.

Interactive

🔮 Live Preview

Choose row count between 3 and 9 and draw the increasing-decreasing number pyramid in the browser.

Hands-On

Examples Gallery

Three complete C# programs — fixed rows, user input, and a compact trace demo. Click View Output to reveal sample console results.

📚 Getting Started

Print five rows of the palindromic number pyramid with increasing then decreasing halves per row.

Example 1 — Fixed `rows = 5`

Hard-coded row count — print ascending with m++, step back with m = m - 2, then print descending with m--.

using System;

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

            for (int i = 1; i <= rows; i++)
            {
                int m = i;

                for (int j = 1; j <= i; j++)
                    Console.Write(m++);

                m = m - 2;

                for (int k = 1; k < i; k++)
                    Console.Write(m--);

                Console.WriteLine();
            }
        }
    }
}

How It Works

When i = 3, m prints 345, then m = m - 2 gives 3, and the second loop prints 43 — output 34543. When i = 1, only the increasing loop runs and the decreasing loop is skipped.

📈 User Input

Read row count from the console with safe parsing.

Example 2 — User Input Rows

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

using System;

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

            for (int i = 1; i <= rows; i++)
            {
                int m = i;

                for (int j = 1; j <= i; j++)
                    Console.Write(m++);

                m = m - 2;

                for (int k = 1; k < i; k++)
                    Console.Write(m--);

                Console.WriteLine();
            }
        }
    }
}

How It Works

Same palindromic two-loop core as Example 1; only the source of rows changes from a literal to user input.

⚡ Compact Trace

Smaller row count for quick tracing on paper or in interviews.

Example 3 — Compact `rows = 3`

Use rows = 3 to trace the increasing half, peak step-back, and decreasing half before scaling to 5 rows.

using System;

namespace MyApp
{
    class Program
    {
        static void Main(string[] args)
        {
            int rows = 3;
            for (int i = 1; i <= rows; i++)
            {
                int m = i;

                for (int j = 1; j <= i; j++)
                    Console.Write(m++);

                m = m - 2;

                for (int k = 1; k < i; k++)
                    Console.Write(m--);

                Console.WriteLine();
            }
        }
    }
}

How It Works

With only three rows you can trace every m++ and m-- step on paper before running the full rows = 5 demo.

🧠 How the Algorithm Prints Rows

Set m = i each row

Before each row, m = i — the starting digit for the palindromic sequence.

Setup

Print increasing half

for (j = 1; j <= i; j++) Console.Write(m++); — counts up to the peak.

Increase

Step back from peak

m = m - 2 — avoids printing the peak digit twice in the decreasing half.

Peak

Print decreasing half

for (k = 1; k < i; k++) Console.Write(m--); then WriteLine().

Decrease

Palindromic pyramid complete

Total prints = 1+3+5+…+(2n-1) = n² — O(n²) time, O(1) extra memory.

Trace

🔎 Worked Walkthrough — `rows = 5`

Trace each row’s increasing half, peak step-back, decreasing half, and full line output.

`i`	Peak	Increasing	After `m-2`	Decreasing	Row output
`1`	`1`	`1`	(skip)	(skip)	`1`
`2`	`3`	`23`	`2`	`2`	`232`
`3`	`5`	`345`	`3`	`43`	`34543`
`4`	`7`	`4567`	`5`	`654`	`4567654`
`5`	`9`	`56789`	`7`	`8765`	`567898765`

Row i always prints exactly 2i-1 digits — a palindromic line built from two inner loops.

Use Cases

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

1. Teaching Nested Loops

Inner bound grows with outer index — classic nested-loop exercise.

Example: trace row i = 4 in the walkthrough table.

2. Palindrome Drills

Each row reads symmetrically — good bridge to string palindrome problems.

Example: row 5 ends with 567898765 — nine digits on a palindromic line.

3. Console Formatting Drills

Practice Write vs WriteLine with multiple values per row.

Example: put WriteLine inside the inner loop by mistake.

4. Continuous Counters

Total prints = n(n+1)/2 — links loops to summation formulas.

Example: 10 rows print 55 values total.

5. Complexity Intuition

Growing inner bound makes O(n²) concrete — count prints for n rows.

Example: 5 rows = 1+2+3+4+5 = 15 prints.

6. Input Validation Labs

Pair the pattern with TryParse and positive-row checks.

Example: reject rows <= 0 and re-prompt.

Pro Tip: when an interviewer asks for patterns, explain outer/inner roles first — then write the loops. The story matters as much as the code.

Advantages

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

1. Instant Visual Feedback
Wrong inner bounds show up immediately as a broken triangle.
2. Real Math Connection
Each row is a palindromic sequence — not abstract loop drill.
3. Easy to Extend
Change rows, use fixed-width format, or switch to full rectangular table.
4. O(1) Extra Memory
Streaming output needs no storage beyond loop counters.

Pro Tip: trace row i = 3 on paper — watch m print 345, step back to 3, then print 43.

Usage Tips

Small habits that keep number-pattern code clean.

1. Inner bound = i
Row i prints exactly i values — use j <= i.
2. Prefer TryParse
Avoid crashes when the user types letters instead of a number.
3. WriteLine After Inner Loop
Only call WriteLine() after the inner loop finishes the row.
4. Fixed-Width Formatting
Trace rows = 3 on paper before coding the full rows = 5 demo.
5. Dry-Run rows = 5
Trace five rows on paper before coding the full 10-row demo.

Pro Tip: if the output is a vertical list of single numbers, you almost certainly put WriteLine inside the inner loop.

Common Pitfalls

Mistakes that commonly break increasing-decreasing number pyramid patterns.

1. WriteLine Inside Inner Loop
Each number lands on its own line — you get a column, not a triangle.
→ Use Console.Write(m++) and Console.Write(m--); WriteLine only after both inner loops.
2. Wrong Inner Bound
Using j <= rows every row makes a full rectangle, not a triangle.
→ Use for (j = 1; j <= i; j++) — inner bound depends on outer i.
3. Forgetting m = m - 2
The peak digit prints twice — row looks like 2332 instead of 232.
→ Always step back with m = m - 2 before the decreasing loop.
4. Forgetting WriteLine After Row
All numbers print on one long line without row breaks.
→ Add Console.WriteLine() after each inner loop completes.
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.

rows = 1

Single row

Output is just 1 on one line.

rows = 0

Empty output

Outer loop never runs — print nothing or show a message.

Negative

`rows < 0`

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

rows = 5

Compact trace

Five rows ending with 567898765 — good for dry-runs.

Bad input

Non-numeric ReadLine

Convert.ToInt32 throws — use TryParse.

Large rows

Wide output

Row 9 has 9 numbers — total prints grow as n(n+1)/2.

Drill

🎯 Practice Problems

Try these variations to lock in the pattern.

1. Compare with Program 51

Program 51 uses a continuous counter with alternating direction
Program 52 resets m = i and builds palindromic rows

2. Change rows

Try rows = 4 or rows = 8 in the live preview
Same palindromic logic, different pyramid size

3. Next in series

Continue with Program 53
Build on palindromic number patterns

4. Add spacing

Print with Console.Write(m++ + " ")
Same loops, wider visual spacing

Important

Notes

Two inner loops. Set m = i. Increasing: j = 1..i with m++. Decreasing: k = 1..(i-1) with m-- after m = m - 2.
Console.Write stays on the line; WriteLine advances — call it only after the inner loop finishes.
Validate rows > 0 for interactive programs; rows = 1 prints a single 1.
Total prints = 1+3+5+…+(2n-1) = n² for n rows — each row has 2i-1 digits.

Quick Takeaway: set m = i, print increasing with m++, step back m = m - 2, print decreasing with m--, then WriteLine().

Analysis

⏱️ Time and Space Complexity

Program	Time	Extra space
Nested loops (Examples 1–3)	`O(n²)`	`O(1)`
Total prints for n rows	`n(n+1)/2` values	`2i-1` digits on row `i`

Wrap Up

🎉 Conclusion

The increasing-decreasing number pyramid is a natural follow-up to Program 51: palindromic rows built with two inner loops and a peak step-back. Master the fixed-rows version, then try user input and the compact 3-row trace.

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

Row i prints 2i-1 palindromic digits — ascending to the peak, then back down.

View Examples Gallery Continue to Program 53

Pro Tips

💡 Best Practices

✅ Do

Set int m = i at the start of each row
Increasing: for (j = 1; j <= i; j++) Console.Write(m++);
Peak step-back: m = m - 2;
Decreasing: for (k = 1; k < i; k++) Console.Write(m--);
Call WriteLine() after both inner loops

❌ Don’t

Skip m = m - 2 — the peak prints twice
Use k <= i in the decreasing loop when you meant k < i
Call WriteLine inside either inner loop
Ignore bad console input in user-facing demos
Skip the rows = 3 dry-run before coding rows = 5

Summary

Key Takeaways

Knowledge Unlocked

Five things to remember about this increasing-decreasing number pyramid

Print the pattern the beginner-friendly way.

Core concepts

△ 01

Rule

Palindromic: i up to 2i-1 down

Definition

↻ 02

Start m

m = i each row

Code

↓ 03

Peak step

m = m - 2

Code

↵ 04

Row length

2i - 1 digits

Logic

O 05

Complexity

O(n²) time

Analysis

❓ Frequently Asked Questions

Why does row 3 print 34543?

Row 3 starts at 3, prints up to 5 (345), then prints back down to 3 (43) after m = m - 2 — producing 34543.

Why does each row look like a palindrome?

Each row counts up from i to the peak 2i-1, then counts back down to i. The sequence reads the same left-to-right on each line.

What does m = m - 2 do?

After the increasing loop, m is one past the peak. Subtracting 2 moves it to the value just before the peak so the decreasing loop does not repeat the peak digit.

How do we avoid repeating the middle number?

Step back with m = m - 2 before the decreasing loop. The decreasing loop then runs i-1 times, skipping the peak.

How can I change the number of rows?

Change rows or read it from user input with TryParse — see Example 2.

What is the time complexity?

O(n²) for n rows because row i prints 2i-1 digits and 1+3+5+...+(2n-1) = n² total prints.

How is this different from Program 51?

Program 51 uses a continuous counter with alternating direction across rows. Program 52 resets m = i each row and builds a palindromic line per row.

Can I add spaces between digits?

Yes. Print with Console.Write(m++ + space) in both loops and trim trailing space if needed.

How should I read rows safely?

Prefer int.TryParse(Console.ReadLine(), out rows) so bad input does not throw FormatException.

What happens when rows is 1?

One row prints 1 — the decreasing loop k < i never runs when i = 1.

Did you Know? 🔊

Each row is palindromic: print i..(2i-1) ascending, then back down with m = m - 2 to skip the peak. Row 3 prints 34543 — total digits = 1+3+5+…+(2n-1) = n² for n rows.

Continue to Program 53

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

Program 53 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 51 C# Number Pattern 53

Increasing-Decreasing Number Pyramid Pattern in C#

What You’ll Learn

Shape Rule

Outer Loop

Increasing Half

Peak Step-Back

Decreasing Half

O(n²)

Introduction

Why it matters?

Increasing half

Peak step-back

vs Program 51

Series Foundation

📝 Problem & Approach

Inputs & Outputs

Minimal workflow

Approach comparison

⚡ Quick Reference

📋 Fixed Rows vs User Input vs Compact Trace

When This Pattern Shows Up

Post Program 51 exercise

Palindrome drills

Two halves per row

Gateway to variants

Not a UI layout tool

🔮 Live Preview

Examples Gallery

📚 Getting Started

Example 1 — Fixed rows = 5

How It Works

📈 User Input

Example 2 — User Input Rows

How It Works

⚡ Compact Trace

Example 3 — Compact rows = 3

How It Works

🧠 How the Algorithm Prints Rows

Set m = i each row

Print increasing half

Step back from peak

Print decreasing half

Palindromic pyramid complete

🔎 Worked Walkthrough — rows = 5

Use Cases

1. Teaching Nested Loops

2. Palindrome Drills

3. Console Formatting Drills

4. Continuous Counters

5. Complexity Intuition

6. Input Validation Labs

Advantages

1. Instant Visual Feedback

2. Real Math Connection

3. Easy to Extend

4. O(1) Extra Memory

Usage Tips

1. Inner bound = i

2. Prefer TryParse

3. WriteLine After Inner Loop

4. Fixed-Width Formatting

5. Dry-Run rows = 5

Common Pitfalls

1. WriteLine Inside Inner Loop

2. Wrong Inner Bound

3. Forgetting m = m - 2

4. Forgetting WriteLine After Row

5. Blind Convert.ToInt32

Edge Cases

Single row

Empty output

rows < 0

Compact trace

Non-numeric ReadLine

Wide output

🎯 Practice Problems

1. Compare with Program 51

2. Change rows

3. Next in series

4. Add spacing

Example 1 — Fixed `rows = 5`

Example 3 — Compact `rows = 3`

🔎 Worked Walkthrough — `rows = 5`

`rows < 0`