Concentric Number Diamond in C#

Beginner

⏱️ 9 min read

📚 Updated: Aug 2026

🎯 3 Code Examples

🚀 Live Preview

Nested Loops + Symmetry

Concentric number diamond output in C# (9x9 grid, 5..1..5 pattern)

Overview

What You’ll Learn

Program 47 prints a full concentric number diamond: top half peels from k to 1, then the bottom half mirrors from 2 back to k — a natural step after Program 46’s top-half square. This tutorial covers two outer loops with j > i logic, a live preview, worked C# examples, edge cases, and complexity.

Shape Rule

Full diamond

Top half i = k..1, bottom half i = 2..k — complete symmetric diamond.

Top Outer Loop

i = k..1

for (i = k; i >= 1; i--) prints layers from outside down to center.

Bottom Outer Loop

i = 2..k

for (i = 2; i <= k; i++) mirrors rows back out — skip i = 1 (already printed).

Cell Rule

j > i

if (j > i) print j; else print i — picks outer or current layer value.

Live Preview

k = 3..7

Pick outer value k and draw the full concentric diamond in the browser.

O(k²)

Complexity

k top rows + k - 1 bottom rows × 2k - 1 columns — total ≈ (2k-1)² prints.

Introduction

A concentric number diamond prints layers that decrease toward the center, then mirror back out to form a complete symmetric shape. With k = 5, the grid is 9 × 9 — the center cell is 1.

In C# two outer loops handle top (i = k..1) and bottom (i = 2..k) halves; each row uses two inner loops and the j > i rule.

Why it matters?

It extends Program 46 with a bottom-half loop — the key step from half-pattern to full diamond symmetry.

Key Highlights

Two outers

Top k..1, bottom 2..k.

Left + right

Two inner loops per row.

vs Program 46

Program 46 is top half only; Program 47 adds the bottom mirror.

Series Foundation

Follow Program 46; continue to Program 48 next.

In short: top loop i = k..1, bottom loop i = 2..k, cell rule j > i ? j : i, then WriteLine().

Foundation

📝 Problem & Approach

Given outer value k = 5, print a full concentric number diamond — top half peels to 1, bottom half mirrors back out.

// k = 5 (9x9)
//5 5 5 5 5 5 5 5 5
//5 4 4 4 4 4 4 4 5
//5 4 3 3 3 3 3 4 5
//5 4 3 2 2 2 3 4 5
//5 4 3 2 1 2 3 4 5
//5 4 3 2 2 2 3 4 5
//5 4 3 3 3 3 3 4 5
//5 4 4 4 4 4 4 4 5
//5 5 5 5 5 5 5 5 5

Inputs & Outputs

Item	Type	Description
`k`	int	Outer (maximum) number — also sets row count and half-width.
`i` (top)	int	Top outer loop — layer value from k down to 1.
`i` (bottom)	int	Bottom outer loop — layer value from 2 up to k.
`j`	int	Inner loop — column index for left (k..1) or right (2..k) half.
Grid size	int	`2 × k - 1` rows and columns (9 when k = 5).

Minimal workflow

Pseudocode

for i from k down to 1:           // top half
    for j from k down to 1: print j if j > i else i
    for j from 2 to k: print j if j > i else i
    print newline
for i from 2 to k:               // bottom half
    for j from k down to 1: print j if j > i else i
    for j from 2 to k: print j if j > i else i
    print newline

Approach comparison

Approach	Idea	Best for
Two outer loops + ternary	9×9 diamond for k = 5	Learning and interviews
User-input k	`int.TryParse(...)`	Flexible outer value
Ternary operator	`j > i ? j : i`	Compact one-liner per cell

Cheat Sheet

⚡ Quick Reference

Goal	Pattern
Top half	`for (i = k; i >= 1; i--)`
Bottom half	`for (i = 2; i <= k; i++)`
Left half	`for (j = k; j >= 1; j--)`
Right half	`for (j = 2; j <= k; j++)`
Cell rule	`if (j > i) Console.Write(j + " "); else Console.Write(i + " ");`
Ternary form	`Console.Write((j > i ? j : i) + " ");`
Grid size	`2 × k - 1` rows and columns
Program 46 contrast	Top-half square only — Program 47 adds bottom mirror loop

Compare

📋 Fixed k vs User Input vs Compact k=3

Same full diamond — different ways to set k and trace the two outer loops.

Top half

i = k..1

Peel toward center

Bottom half

i = 2..k

Mirror back out

Left half

j = k..1

Descending columns

Right half

j = 2..k

Mirror without center dup

Cell rule

j > i ? j : i

Outer or layer value

Context

When This Pattern Shows Up

Reach for this pattern when teaching symmetric output, layer logic, and dual inner loops.

Post Program 46 exercise
Natural follow-up after Program 46 — adds the bottom-half outer loop for a complete diamond.
Two outer loops
Top (k..1) and bottom (2..k) teach full vertical symmetry.
Layer / peel logic
j > i selects which concentric ring each cell belongs to.
Gateway to variants
Compare Program 46 (top half) and Program 48 (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 nested loops, symmetry, and O(k²) thinking.

Interactive

🔮 Live Preview

Choose outer value k between 3 and 7 and draw the full concentric diamond in the browser.

Hands-On

Examples Gallery

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

📚 Getting Started

Print a full concentric number diamond with k = 5 using two outer loops and the j > i rule.

Example 1 — Fixed `k = 5`

Hard-coded outer value — top half then bottom half for a complete 9×9 diamond.

using System;

namespace MyApp
{
    class Program
    {
        static void Main(string[] args)
        {
            int k = 5;
            int i, j;

            for (i = k; i >= 1; i--)
            {
                for (j = k; j >= 1; j--)
                    Console.Write((j > i ? j : i) + " ");
                for (j = 2; j <= k; j++)
                    Console.Write((j > i ? j : i) + " ");
                Console.WriteLine();
            }

            for (i = 2; i <= k; i++)
            {
                for (j = k; j >= 1; j--)
                    Console.Write((j > i ? j : i) + " ");
                for (j = 2; j <= k; j++)
                    Console.Write((j > i ? j : i) + " ");
                Console.WriteLine();
            }
        }
    }
}

How It Works

The first outer loop prints rows i = 5..1 (top half). The second prints i = 2..5 (bottom half) — row i = 1 is skipped because it was already the center row.

📈 User Input

Read outer value k from the console instead of hard-coding 5.

Example 2 — User Input k

Read k from the console with safe parsing — both halves adjust automatically.

using System;

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

            for (int i = k; i >= 1; i--)
            {
                for (int j = k; j >= 1; j--)
                    Console.Write((j > i ? j : i) + " ");
                for (int j = 2; j <= k; j++)
                    Console.Write((j > i ? j : i) + " ");
                Console.WriteLine();
            }

            for (int i = 2; i <= k; i++)
            {
                for (int j = k; j >= 1; j--)
                    Console.Write((j > i ? j : i) + " ");
                for (int j = 2; j <= k; j++)
                    Console.Write((j > i ? j : i) + " ");
                Console.WriteLine();
            }
        }
    }
}

How It Works

Same two-pass structure as Example 1; only the source of k changes. Grid size becomes 2k - 1 rows and columns.

⚡ Compact k = 3

Smaller outer value for quick tracing — 5 rows total (3 top + 2 bottom).

Example 3 — Compact `k = 3`

Use k = 3 to trace both outer loops quickly on paper or in interviews.

using System;

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

            for (int i = k; i >= 1; i--)
            {
                for (int j = k; j >= 1; j--)
                    Console.Write((j > i ? j : i) + " ");
                for (int j = 2; j <= k; j++)
                    Console.Write((j > i ? j : i) + " ");
                Console.WriteLine();
            }

            for (int i = 2; i <= k; i++)
            {
                for (int j = k; j >= 1; j--)
                    Console.Write((j > i ? j : i) + " ");
                for (int j = 2; j <= k; j++)
                    Console.Write((j > i ? j : i) + " ");
                Console.WriteLine();
            }
        }
    }
}

How It Works

Five rows total — three from the top loop, two from the bottom (skipping center duplicate). Easy to dry-run before scaling to k = 5.

🧠 How the Algorithm Prints Rows

Set up

using System; brings in Console. Set k = 5 as the outer value and row/layer count.

Setup

Print top half

for (i = k; i >= 1; i--) walks layers from outside down to center row.

Grid

Left half (j = k..1)

If j > i print j; else print i — builds descending left side.

Condition

Mirror bottom half

for (i = 2; i <= k; i++) prints rows back out — skips i = 1 (center already done).

Bottom

New line per row

Console.WriteLine() after both inner loops finish each row.

Break

Concentric diamond complete

Grid size 2k - 1 × 2k - 1 — O(k²) time, O(1) extra memory.

Trace

🔎 Worked Walkthrough — row `i = 3`, `k = 5`

Trace left-half columns j on row 3 — which value prints for each cell.

`j`	`j > i?`	Prints
`5`	Yes	`5`
`4`	Yes	`4`
`3`	No	`3` (i)
`2`	No	`3` (i)
`1`	No	`3` (i)

Left half of center row (i = 1): 5 4 3 2 1. Right half mirrors to 2 3 4 5 — full center row: 5 4 3 2 1 2 3 4 5. Bottom loop then prints rows i = 2..5 to complete the 9×9 diamond.

Use Cases

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

1. Teaching Nested Loops

Clearest visual proof that outer and inner bounds interact.

Example: change k to 3 for a quick trace — see Example 3.

2. Pattern Series Base

Foundation for concentric layers, symmetric grids, and peel-down patterns.

Example: continue to Program 48 for the next pattern in the series.

3. Console Formatting Drills

Practice Write vs WriteLine without complex math.

Example: put WriteLine inside the inner loop by mistake.

4. Symmetry Practice

Two inner loops teach left-right mirroring without string reversal.

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

5. Complexity Intuition

2k - 1 rows × 2k - 1 columns makes O(k²) concrete.

Example: count cells for k = 5 — 9 × 9 = 81 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 the 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 bounds show up immediately as a broken staircase.
2. Minimal Concepts
Only loops and console output — no arrays or math libraries.
3. Easy to Extend
Change k, use ternary form, or trace with k = 3 for quick dry-runs.
4. O(1) Extra Memory
Streaming output needs no storage beyond loop counters.

Pro Tip: trace row i = 3 on paper — watch how j > i switches from outer values to the current layer.

Usage Tips

Small habits that keep number-pattern code clean.

1. Use the k Variable
Never hard-code 5 in loop bounds — use k everywhere.
2. Prefer TryParse
Avoid crashes when the user types letters instead of a number.
3. Keep WriteLine Outside
Only call WriteLine() after the inner loop finishes the row.
4. Two Inner Loops
Left half uses j = k..1; right half uses j = 2..k — do not repeat j = 1 on the right.
5. Dry-Run k = 3
Trace all three rows on paper before coding the full k = 5 demo.

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

Common Pitfalls

Mistakes that commonly break concentric number diamond patterns.

1. WriteLine Inside the Inner Loop
Each cell lands on its own line — you get a column, not a diamond.
→ Use Write((j > i ? j : i) + " ") per cell; WriteLine only after both inner loops.
2. Right Loop Starts at 2
Starting the right half at j = 1 duplicates the center digit on every row.
→ Use for (j = 2; j <= k; j++) for the mirror half.
3. Forgetting Bottom Half
Only the top loop runs — output stops at the center row like Program 46.
→ Add for (i = 2; i <= k; i++) with the same inner loops after the top half.
4. k Too Small
k = 1 prints a single 1; k = 2 gives a minimal 3×3 diamond.
→ Validate k >= 2 for interactive programs expecting a visible pattern.
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.

k = 1

Single cell

Output is just 1 on one line — no layers to peel.

k = 0

Empty pattern

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

Negative

`k < 0`

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

k = 2

Minimal diamond

3×3 grid — 2 2 2, 2 1 2, 2 2 2.

Bad input

Non-numeric ReadLine

Convert.ToInt32 throws — use TryParse.

Large rows

Large row count

Each row prints 2k - 1 cells — total work grows as k².

Drill

🎯 Practice Problems

Try these variations to lock in the pattern.

1. Concentric square

Review Program 46’s top-half only pattern
Compare with Program 46

2. Change k

Try k = 4 or k = 7 — grid becomes (2k-1)×(2k-1)
Same two outer loops, different size

3. Next in series

Continue with Program 48
Build on full-diamond logic

4. Skip center duplicate

Bottom loop starts at i = 2, not i = 1
Prevents printing the center row twice

Important

Notes

Two outer loops. Top: i = k..1. Bottom: i = 2..k (skip center duplicate). Same inner loops and cell rule in both.
Console.Write stays on the line; WriteLine advances — call it only after both inner loops finish.
Validate k > 0 for interactive programs; k = 1 prints a single 1.
2k - 1 rows × 2k - 1 columns — total prints ≈ (2k - 1)².

Quick Takeaway: top loop i = k..1, bottom loop i = 2..k, cell rule j > i ? j : i, then WriteLine().

Analysis

⏱️ Time and Space Complexity

Program	Time	Extra space
Nested loops (Examples 1–3)	`O(k²)`	`O(1)`
Smaller demo (Example 3)	`O(k²)`	`O(1)`

Wrap Up

🎉 Conclusion

The concentric number diamond extends Program 46 with a bottom-half outer loop: top (i = k..1) plus bottom (i = 2..k) using the same j > i cell rule. Master the fixed-k version, then try user input and the compact k = 3 trace.

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

Two outer loops — top k..1, bottom 2..k — skip i = 1 in the bottom loop to avoid duplicating the center row.

View Examples Gallery Continue to Program 48

Pro Tips

💡 Best Practices

✅ Do

Top: for (i = k; i >= 1; i--), Bottom: for (i = 2; i <= k; i++)
Left: j = k..1, Right: j = 2..k per row
Print j if j > i, else i
Skip i = 1 in bottom loop (center already printed)
Validate k ≥ 2 for interactive programs

❌ Don’t

Call WriteLine inside the inner cell loop
Forget the bottom half loop — pattern stops at center
Start bottom loop at i = 1 — duplicates center row
Ignore bad console input in user-facing demos
Skip the k = 3 dry-run before coding k = 5

Summary

Key Takeaways

Knowledge Unlocked

Five things to remember about this concentric number diamond

Print the pattern the beginner-friendly way.

Core concepts

△ 01

Rule

Two outer loops

Definition

↻ 02

Top half

i = k..1

Code

↓ 03

Bottom half

i = 2..k

Code

↵ 04

Cell rule

j > i ? j : i

Logic

O 05

Grid

(2k-1)² cells

Analysis

❓ Frequently Asked Questions

What does Program 47 print?

A full concentric number diamond where the outer layer is k (e.g. 5), values decrease to 1 at the center, then increase back to k — a 9×9 grid when k = 5.

Why are there two outer loops?

The first prints the top half (i = k down to 1). The second prints the bottom half (i = 2 up to k) to mirror the shape.

How is this different from Program 46?

Program 46 prints only the top half (k rows). Program 47 adds the bottom half loop to form a complete diamond.

What does j > i mean?

When column j is still outside the current row layer i, print j (the outer number). Otherwise print i (the current row value).

How wide is the output?

For k, each row has 2*k - 1 numbers. With k = 5, width is 9 columns and 9 rows.

How can I change k?

Change the value of k or read it from user input — both outer loops and row width adjust automatically.

What is the time complexity?

O(k²) because the grid has roughly (2k-1)² cells and each is printed once.

What does the center cell print?

The center prints 1 — it is the deepest layer of the concentric pattern.

Can I print without spaces?

Yes — replace Console.Write(value + " ") with Console.Write(value). For double-digit k, use fixed-width formatting.

Did you Know? 🔊

Print top half with for (i = k; i >= 1; i--), then bottom half with for (i = 2; i <= k; i++). Each cell: j > i ? j : i. Grid size = 2k - 1 rows and columns.

Continue to Program 48

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

Program 48 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 46 C# Number Pattern 48

Concentric Number Diamond in C#

What You’ll Learn

Shape Rule

Top Outer Loop

Bottom Outer Loop

Cell Rule

Live Preview

O(k²)

Introduction

Why it matters?

Two outers

Left + right

vs Program 46

Series Foundation

📝 Problem & Approach

Inputs & Outputs

Minimal workflow

Approach comparison

⚡ Quick Reference

📋 Fixed k vs User Input vs Compact k=3

When This Pattern Shows Up

Post Program 46 exercise

Two outer loops

Layer / peel logic

Gateway to variants

Not a UI layout tool

🔮 Live Preview

Examples Gallery

📚 Getting Started

Example 1 — Fixed k = 5

How It Works

📈 User Input

Example 2 — User Input k

How It Works

⚡ Compact k = 3

Example 3 — Compact k = 3

How It Works

🧠 How the Algorithm Prints Rows

Set up

Print top half

Left half (j = k..1)

Mirror bottom half

New line per row

Concentric diamond complete

🔎 Worked Walkthrough — row i = 3, k = 5

Use Cases

1. Teaching Nested Loops

2. Pattern Series Base

3. Console Formatting Drills

4. Symmetry Practice

5. Complexity Intuition

6. Input Validation Labs

Advantages

1. Instant Visual Feedback

2. Minimal Concepts

3. Easy to Extend

4. O(1) Extra Memory

Usage Tips

1. Use the k Variable

2. Prefer TryParse

3. Keep WriteLine Outside

4. Two Inner Loops

5. Dry-Run k = 3

Common Pitfalls

1. WriteLine Inside the Inner Loop

2. Right Loop Starts at 2

3. Forgetting Bottom Half

4. k Too Small

5. Blind Convert.ToInt32

Edge Cases

Single cell

Empty pattern

k < 0

Minimal diamond

Non-numeric ReadLine

Large row count

🎯 Practice Problems

1. Concentric square

2. Change k

3. Next in series

Example 1 — Fixed `k = 5`

Example 3 — Compact `k = 3`

🔎 Worked Walkthrough — row `i = 3`, `k = 5`

2. Prefer `TryParse`

`k < 0`