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 with cout << value << " ".

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 cout << "\n".

Foundation

📝 Problem & Approach

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

C++
// 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

ItemTypeDescription
kintOuter (maximum) number — also sets row count and half-width.
i (top)intTop outer loop — layer value from k down to 1.
i (bottom)intBottom outer loop — layer value from 2 up to k.
jintInner loop — column index for left (k..1) or right (2..k) half.
Grid sizeint2 × 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

ApproachIdeaBest for
Two outer loops + ternary9×9 diamond for k = 5Learning and interviews
User-input kcin >> k;Flexible outer value
Ternary operatorj > i ? j : iCompact one-liner per cell
Cheat Sheet

⚡ Quick Reference

GoalPattern
Top halffor (i = k; i >= 1; i--)
Bottom halffor (i = 2; i <= k; i++)
Left halffor (j = k; j >= 1; j--)
Right halffor (j = 2; j <= k; j++)
Cell ruleif (j > i) cout << j << " "; else cout << i << " ";
Ternary formcout << (j > i ? j : i) << " ";
Grid size2 × k - 1 rows and columns
Program 46 contrastTop-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.

  1. Post Program 46 exercise

    Natural follow-up after Program 46 — adds the bottom-half outer loop for a complete diamond.

  2. Two outer loops

    Top (k..1) and bottom (2..k) teach full vertical symmetry.

  3. Layer / peel logic

    j > i selects which concentric ring each cell belongs to.

  4. Gateway to variants

    Compare Program 46 (top half) and Program 48 (next in series) next.

  5. 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.

Try 3, 5, or 7. Max up to 7 in this preview.

Live result
Press "Draw pattern".
Hands-On

Examples Gallery

Three complete C++ programs — fixed k = 5, user input, and compact k = 3 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.

C++
#include <iostream>
using namespace std;

int main() {
    int k = 5;
    int i, j;

    for (i = k; i >= 1; i--) {
        for (j = k; j >= 1; j--)
            cout << (j > i ? j : i) << " ";
        for (j = 2; j <= k; j++)
            cout << (j > i ? j : i) << " ";
        cout << "\n";
    }

    for (i = 2; i <= k; i++) {
        for (j = k; j >= 1; j--)
            cout << (j > i ? j : i) << " ";
        for (j = 2; j <= k; j++)
            cout << (j > i ? j : i) << " ";
        cout << "\n";
    }

    return 0;
}

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 with cin >> k (check cin.fail() in real apps) and reject non-positive values — both halves adjust automatically.

C++
#include <iostream>
using namespace std;

int main() {
    int k;
    int i, j;

    cout << "Enter k: ";
    cin >> k;
    if (cin.fail() || k <= 0) {
        cout << "Please enter a positive integer.\n";
        return 1;
    }

    for (i = k; i >= 1; i--) {
        for (j = k; j >= 1; j--)
            cout << (j > i ? j : i) << " ";
        for (j = 2; j <= k; j++)
            cout << (j > i ? j : i) << " ";
        cout << "\n";
    }

    for (i = 2; i <= k; i++) {
        for (j = k; j >= 1; j--)
            cout << (j > i ? j : i) << " ";
        for (j = 2; j <= k; j++)
            cout << (j > i ? j : i) << " ";
        cout << "\n";
    }

    return 0;
}

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.

C++
#include <iostream>
using namespace std;

int main() {
    int k = 3;
    int i, j;

    for (i = k; i >= 1; i--) {
        for (j = k; j >= 1; j--)
            cout << (j > i ? j : i) << " ";
        for (j = 2; j <= k; j++)
            cout << (j > i ? j : i) << " ";
        cout << "\n";
    }

    for (i = 2; i <= k; i++) {
        for (j = k; j >= 1; j--)
            cout << (j > i ? j : i) << " ";
        for (j = 2; j <= k; j++)
            cout << (j > i ? j : i) << " ";
        cout << "\n";
    }

    return 0;
}

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

1

Set up

#include <iostream> using namespace std; for cout. Set k = 5 as the outer value and row/layer count.

Setup
2

Print top half

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

Grid
3

Left half (j = k..1)

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

Condition
4

Mirror bottom half

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

Bottom
5

New line per row

cout << "\n" 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.

jj > i?Prints
5Yes5
4Yes4
3No3 (i)
2No3 (i)
1No3 (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 cout << "\n" without complex math.

Example: put cout << "\n" 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 cin.fail() checks 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. 1. Instant Visual Feedback

    Wrong bounds show up immediately as a broken staircase.

  2. 2. Minimal Concepts

    Only loops and console output — no arrays or math libraries.

  3. 3. Easy to Extend

    Change k, use ternary form, or trace with k = 3 for quick dry-runs.

  4. 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. 1. Use the k Variable

    Never hard-code 5 in loop bounds — use k everywhere.

  2. 2. Check cin.fail()

    Avoid using uninitialized k when the user types letters instead of a number.

  3. 3. Keep Newline Outside

    Only call cout << "\n" after both inner loops finish the row.

  4. 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. 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 cout << "\n" inside the print loop.

Common Pitfalls

Mistakes that commonly break concentric number diamond patterns.

  1. 1. Newline Inside the Inner Loop

    Each cell lands on its own line — you get a column, not a diamond.

    → Use cout << (j > i ? j : i) << " " per cell; cout << "\n" only after both inner loops.

  2. 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. 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. 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. 5. Unchecked cin

    Letters or empty input leave k unread when cin.fail() is not checked.

    → Check cin.fail() 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 cin input

cin without checking cin.fail() is unsafe — validate input.

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.
  • cout stays on the line; cout << "\n" 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 cout << "\n".

Analysis

⏱️ Time and Space Complexity

ProgramTimeExtra 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 cout << "\n" 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.

5
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
🎯 You’re ready to print a concentric number diamond in C++
Review Quick Reference →

❓ Frequently Asked Questions

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.
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.
Program 46 prints only the top half (k rows). Program 47 adds the bottom half loop to form a complete diamond.
When column j is still outside the current row layer i, print j (the outer number). Otherwise print i (the current row value).
For k, each row has 2*k - 1 numbers. With k = 5, width is 9 columns and 9 rows.
Change the value of k or read it from user input — both outer loops and row width adjust automatically.
O(k²) because the grid has roughly (2k-1)² cells and each is printed once.
The center prints 1 — it is the deepest layer of the concentric pattern.
Yes — replace cout << value << " " with cout << value. For double-digit k, use fixed-width formatting like setw(2) from <iomanip>.

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