Palindromic Number Pyramid Pattern in C#

Beginner

⏱️ 10 min read

📚 Updated: Aug 2026

🎯 3 Code Examples

🚀 Live Preview

Spacing + Symmetry

Palindromic number pyramid output in C# (1, 121, 12321 centered)

Overview

What You’ll Learn

Program 56 prints a centered palindromic number pyramid: each row shows 1..i..1 with leading spaces for centering — a natural step after Program 55’s column-wise triangle. This tutorial covers spacing, ascending and descending loops, a live preview, worked C# examples, edge cases, and complexity.

Shape Rule

Palindromic row

Row i prints 1..i ascending, then i-1..1 descending — always reads the same forward and backward.

Outer Loop

i = 1..rows

for (i = 1; i <= rows; i++) picks the current row and its palindromic width.

Leading Spaces

s = 1..(rows-i)

Console.Write(" ") repeated rows - i times — centers the pyramid.

Ascending Half

k = 1..i

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

Descending Half

k = i-1..1

for (k = i - 1; k >= 1; k--) Console.Write(k + " ") — mirrors without repeating the peak.

O(n²)

Complexity

Row i prints about 2i-1 digits plus spaces — total work grows as O(n²).

Introduction

A palindromic number pyramid prints a centered triangle where row i shows digits from 1 up to i and back down to 1. With rows = 5, you get 1, 1 2 1, 1 2 3 2 1, and so on — each row wider and centered with leading spaces.

In C# use an outer loop for rows, print (rows - i) space pairs, then ascending 1..i, then descending i-1..1, before WriteLine().

Why it matters?

It bridges Program 55’s column-wise fill to centered symmetry — combining spacing with ascending and descending loops on each row.

Key Highlights

Centering

(rows - i) pairs of spaces before digits.

Ascending

k = 1..i prints up to the peak.

vs Program 55

Program 55 uses column-wise 2D array fill; Program 56 prints palindromic rows with spacing.

Series Foundation

Follow Program 55; continue to Program 57 next.

In short: outer i = 1..rows, spaces rows-i, ascending 1..i, descending i-1..1, then WriteLine().

Foundation

📝 Problem & Approach

Given row count rows = 5, print a centered palindromic number pyramid — row i shows 1..i..1 with leading spaces.

// rows = 5
//      1
//    1 2 1
//  1 2 3 2 1
//1 2 3 4 3 2 1
//1 2 3 4 5 4 3 2 1

Inputs & Outputs

Item	Type	Description
`rows`	int	Pyramid height — bottom row has `rows` as peak digit.
`i` (outer)	int	Current row index — runs `1` to `rows`.
`s` (spaces)	int	Prints `(rows - i)` pairs of spaces for centering.
`k` (ascending)	int	Prints `1..i` with trailing space after each digit.
`k` (descending)	int	Prints `i-1..1` — skips repeating the peak digit.
Row width	int	Row `i` has `2i-1` digits plus leading spaces.

Minimal workflow

Pseudocode

for i from 1 to rows:
    print (rows - i) pairs of spaces
    for k from 1 to i:
        print k
    for k from i - 1 down to 1:
        print k
    print newline

Approach comparison

Approach	Idea	Best for
Three inner loops	Spaces, ascending `1..i`, descending `i-1..1`	Learning and interviews
Skip peak in descent	`k = i-1..1` avoids duplicate peak digit	Clean palindromic rows
User-input rows	`int.TryParse(...)`	Flexible pyramid size
Compact trace	`rows = 3` on paper first	Quick dry-runs before full demo
Full diamond	Mirror bottom half from `rows-1..1`	Extension after mastering pyramid

Cheat Sheet

⚡ Quick Reference

Goal	Pattern
Outer loop	`for (i = 1; i <= rows; i++)`
Leading spaces	`for (s = 1; s <= rows - i; s++) Console.Write(" ");`
Ascending half	`for (k = 1; k <= i; k++) Console.Write(k + " ");`
Descending half	`for (k = i - 1; k >= 1; k--) Console.Write(k + " ");`
End row	`Console.WriteLine();`
Program 55 contrast	Program 55 uses column-wise 2D fill; Program 56 uses centered palindromic rows

Compare

📋 Fixed Rows vs User Input vs Compact Trace

Same centered pyramid — three ways to set row count and trace the logic.

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

Centering

rows - i

Space pairs before digits

Palindrome

1..i..1

Digits per row i

Context

When This Pattern Shows Up

Reach for this pattern when teaching centered output, palindromic sequences, and combining spacing with multiple inner loops.

Post Program 55 exercise
Natural follow-up after Program 55’s column-wise triangle — introduces centering and palindromic rows.
Palindrome drills
Each row reads symmetrically — good bridge to string palindrome problems.
Three loops per row
Spaces plus ascending and descending halves — concrete nested-loop practice.
Gateway to Program 57
Compare this centered pyramid with the next pattern in the series.
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 centering, palindromic rows, and O(n²) thinking.

Interactive

🔮 Live Preview

Choose row count between 3 and 9 and draw the centered palindromic 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 a centered palindromic pyramid with five rows — spaces, ascending, and descending loops per row.

Example 1 — Fixed `rows = 5`

Hard-coded row count — print leading spaces, then ascending 1..i, then descending i-1..1.

using System;

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

            for (int i = 1; i <= rows; i++)
            {
                for (int s = 1; s <= (rows - i); s++)
                    Console.Write("  ");

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

                for (int k = i - 1; k >= 1; k--)
                    Console.Write(k + " ");

                Console.WriteLine();
            }
        }
    }
}

How It Works

When i = 3, print 2 space pairs, then 1 2 3, then 2 1 — output 1 2 3 2 1. When i = 1, only the ascending loop runs and the descending 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++)
            {
                for (int s = 1; s <= (rows - i); s++)
                    Console.Write("  ");

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

                for (int k = i - 1; k >= 1; k--)
                    Console.Write(k + " ");

                Console.WriteLine();
            }
        }
    }
}

How It Works

Same spacing and palindromic 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 spacing, ascending, and descending loops 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++)
            {
                for (int s = 1; s <= (rows - i); s++)
                    Console.Write("  ");

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

                for (int k = i - 1; k >= 1; k--)
                    Console.Write(k + " ");

                Console.WriteLine();
            }
        }
    }
}

How It Works

With only three rows you can trace every space pair and digit loop on paper before running the full rows = 5 demo.

🧠 How the Algorithm Prints Rows

Set rows

int rows = 5; controls pyramid height and spacing width.

Setup

Print leading spaces

for (s = 1; s <= rows - i; s++) Console.Write(" "); — centers row i.

Spaces

Print ascending half

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

Increase

Print descending half

for (k = i - 1; k >= 1; k--) Console.Write(k + " "); then WriteLine().

Decrease

Palindromic pyramid complete

Row i prints 2i-1 digits — O(n²) time, O(1) extra memory.

Trace

🔎 Worked Walkthrough — `rows = 5`

Trace each row’s space count, ascending half, descending half, and full line output.

`i`	Space pairs	Ascending	Descending	Row output
`1`	`4`	`1`	(skip)	`1`
`2`	`3`	`1 2`	`1`	`1 2 1`
`3`	`2`	`1 2 3`	`2 1`	`1 2 3 2 1`
`4`	`1`	`1 2 3 4`	`3 2 1`	`1 2 3 4 3 2 1`
`5`	`0`	`1 2 3 4 5`	`4 3 2 1`	`1 2 3 4 5 4 3 2 1`

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

Use Cases

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

1. Teaching Nested Loops

Spacing plus ascending and descending loops — three inner loops per row.

Example: trace each row in the walkthrough table — spaces, ascending, descending.

2. Palindrome Drills

Each row reads symmetrically — compare with Program 52's left-aligned palindrome.

Example: row 5 has no leading spaces and shows 1 2 3 4 5 4 3 2 1.

3. Console Formatting Drills

Practice Write vs WriteLine with multiple values per row.

Example: put WriteLine inside the inner loop by mistake.

4. Centering Formula

Space pairs on row i = rows - i — fewer spaces as the pyramid widens.

Example: Peak row 10 has 9 space pairs on row 1 — 19 digits on the bottom row.

5. Complexity Intuition

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

Example: Peak row 5 bottom line has 9 digits — see the walkthrough table.

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
Each row is instantly recognizable as a palindrome — spacing, ascending, and descending halves make the shape obvious.
2. Real Math Connection
Centering with spaces teaches real console alignment — not abstract loop drill.
3. Easy to Extend
Mirror the bottom half from rows-1..1 to build a full diamond, or use fixed-width formatting for larger peaks.
4. O(1) Extra Memory
Streaming output needs no storage beyond loop counters.

Pro Tip: trace rows = 3 on paper — row 2 shows 1 2 1 with 1 space pair.

Usage Tips

Small habits that keep number-pattern code clean.

1. Space pairs = rows - i
Print (rows - i) pairs of two spaces before digits on row i.
2. Prefer TryParse
Avoid crashes when the user types letters instead of a number.
3. WriteLine After Both Inner Loops
Only call WriteLine() after both inner loops finish the row.
4. Descending starts at i-1
Use for (k = i - 1; k >= 1; k--) so the peak digit is not printed twice.
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 palindromic number pyramid patterns.

1. WriteLine Inside Inner Loop
Each digit lands on its own line — you get a column, not a pyramid.
→ Use Console.Write(k + " ") for digits; WriteLine only after all three inner loops.
2. Wrong Descending Start
Starting descending at k = i prints the peak digit twice — row looks like 1 2 2 1.
→ Use for (k = i - 1; k >= 1; k--) — skip the peak in the descending half.
3. Forgetting Leading Spaces
Without leading spaces the pyramid is left-aligned, not centered.
→ Print (rows - i) pairs of two spaces before the digits on row i.
4. Forgetting WriteLine After Row
All numbers print on one long line without row breaks.
→ Add Console.WriteLine() after both inner loops complete.
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 — the descending loop does not run.

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

Bottom row has 9 digits — good for dry-runs before scaling up.

Bad input

Non-numeric ReadLine

Convert.ToInt32 throws — use TryParse.

Large rows

Wide output

Row 9 scans 17 character positions — total work grows as O(n²).

Drill

🎯 Practice Problems

Try these variations to lock in the pattern.

1. Compare with Program 55

Program 55 fills a 2D array column-wise
Program 56 prints centered palindromic rows directly

2. Build a full diamond

Print this pyramid, then mirror rows from rows-1 down to 1
Compare with Program 54's mirror diagonal diamond

3. Next in series

Continue with Program 57
Build on centered palindromic patterns

4. Fixed-width formatting

Use Console.Write($"{k,2} ") for rows beyond 9
Same loops, better alignment for multi-digit peaks

Important

Notes

Three inner loops. Spaces: s = 1..(rows-i). Ascending: k = 1..i. Descending: k = i-1..1.
Console.Write stays on the line; WriteLine advances — call it only after all three inner loops finish.
Validate rows > 0 for interactive programs; rows = 1 prints a single centered 1.
Row i prints 2i-1 digits — total work grows as O(n²) for n rows.

Quick Takeaway: spaces rows-i, ascending 1..i, descending i-1..1, then WriteLine().

Analysis

⏱️ Time and Space Complexity

Program	Time	Extra space
Nested loops (Examples 1–3)	`O(n²)`	`O(1)`
Digits on row i	`2i - 1`	No storage beyond loop counters

Wrap Up

🎉 Conclusion

The palindromic number pyramid is a natural follow-up to Program 55: centered rows built with spacing, ascending, and descending loops. Master the fixed-rows version, then try user input and the compact 3-row trace.

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

Row i prints 2i-1 palindromic digits — centered with (rows-i) space pairs.

View Examples Gallery Continue to Program 57

Pro Tips

💡 Best Practices

✅ Do

Spaces: for (s = 1; s <= rows - i; s++) Console.Write(" ");
Ascending: for (k = 1; k <= i; k++) Console.Write(k + " ");
Descending: for (k = i - 1; k >= 1; k--) Console.Write(k + " ");
Call WriteLine() after all three inner loops
Use int.TryParse for user input

❌ Don’t

Start descending at k = i — duplicates the peak digit
Skip leading spaces — pyramid won't be centered
Call WriteLine inside any 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 palindromic pyramid

Print the centered pyramid the beginner-friendly way.

Core concepts

△ 01

Rule

1..i..1 per row

Definition

▦ 02

Center

rows - i spaces

Code

↑ 03

Up

k = 1..i

Code

↓ 04

Down

k = i-1..1

Logic

O 05

Complexity

O(n²) time

Analysis

❓ Frequently Asked Questions

Why is this called a palindromic number pyramid?

Each row reads the same forward and backward: 1, 1 2 1, 1 2 3 2 1, and so on.

How do I center the pyramid?

Print (rows - i) groups of two spaces before the numbers on row i — more spaces on upper rows, fewer on lower rows.

What does this palindromic pyramid print?

A centered pyramid where row i shows 1..i ascending then i-1..1 descending, e.g. row 3: ' 1 2 3 2 1'.

How is this different from Program 55?

Program 55 fills a 2D array column-wise. Program 56 prints palindromic digits directly with spaces, ascending, and descending loops.

Why use k = i-1 down to 1 for the descending half?

Starting at i-1 avoids printing the peak digit twice — row i already printed i in the ascending loop.

How can I change the pyramid height?

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

What is the time complexity?

O(n²) for n rows because each row prints O(n) spaces and digits.

Can I build a full diamond from this?

Yes. Print this pyramid for the top half, then mirror rows from rows-1 down to 1 for the bottom half.

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 centered row prints a single 1 with (rows-1)*2 = 0 leading spaces.

Did you Know? 🔊

Each row prints 1..i..1 with leading spaces for centering. Row i has 2i-1 digits — total prints grow as O(n²) for n rows.

Continue to Program 57

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

Program 57 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 55 C# Number Pattern 57

Palindromic Number Pyramid Pattern in C#

What You’ll Learn

Shape Rule

Outer Loop

Leading Spaces

Ascending Half

Descending Half

O(n²)

Introduction

Why it matters?

Centering

Ascending

vs Program 55

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 55 exercise

Palindrome drills

Three loops per row

Gateway to Program 57

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 rows

Print leading spaces

Print ascending half

Print descending half

Palindromic pyramid complete

🔎 Worked Walkthrough — rows = 5

Use Cases

1. Teaching Nested Loops

2. Palindrome Drills

3. Console Formatting Drills

4. Centering Formula

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. Space pairs = rows - i

2. Prefer TryParse

3. WriteLine After Both Inner Loops

4. Descending starts at i-1

5. Dry-Run rows = 5

Common Pitfalls

1. WriteLine Inside Inner Loop

2. Wrong Descending Start

3. Forgetting Leading Spaces

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 55

2. Build a full diamond

3. Next in series

4. Fixed-width formatting

Example 1 — Fixed `rows = 5`

Example 3 — Compact `rows = 3`

🔎 Worked Walkthrough — `rows = 5`

`rows < 0`