Diagonal Mirror Number Pyramid in Python

Beginner

⏱️ 10 min read

📚 Updated: Sep 2026

🎯 3 Code Examples

🚀 Live Preview

Nested Loops + Spacing

Diagonal mirror number pyramid output in Python (1, 2 2, 3 3, 4 4, 5 5)

Overview

What You’ll Learn

Program 57 prints a diagonal mirror number pyramid: each row shows the row number twice — once on the left diagonal and once on the right — with spaces everywhere else. A natural step after Program 56’s centered palindromic pyramid. This tutorial covers conditional printing, two inner loops per row, a live preview, worked Python examples, edge cases, and complexity.

Shape Rule

Mirror diagonals

Row i prints the digit i on the left diagonal and again on the right diagonal — an inverse-V mirror shape.

Outer Loop

i = 1..rows

for i in range(1, rows + 1) picks the current row and the digit to place on both diagonals.

Left Diagonal

j = rows..1

print(i if i == j else " ", end="") — scans from the right edge inward.

Right Diagonal

k = 2..rows

print(i if i == k else " ", end="") — mirrors the left half from column 2 onward.

Conditional Print

digit or space

Every column position gets either the row digit or a single space — no other characters.

O(n²)

Complexity

Each row scans about 2×rows-1 positions — total work grows as O(n²).

Introduction

A diagonal mirror number pyramid prints the row number on two mirror diagonals with spaces everywhere else. With rows = 5, you get 1, 2 2, 3 3, and so on — forming an inverse-V shape.

In Python use an outer loop for rows, then two inner loops: the first scans j = rows..1 for the left diagonal, the second scans k = 2..rows for the right diagonal, printing the digit only when i == j or i == k.

Why it matters?

It bridges Program 56’s palindromic rows to conditional diagonal placement — combining if checks with two inner loops per row.

Key Highlights

Left diagonal

j = rows..1, print when i == j.

Right diagonal

k = 2..rows, print when i == k.

vs Program 56

Program 56 prints palindromic rows; Program 57 prints the row digit twice on mirror diagonals.

Series Foundation

Follow Program 56; continue to Program 58 next.

In short: outer i = 1..rows, left loop j = rows..1, right loop k = 2..rows, print digit or space, then print().

Foundation

📝 Problem & Approach

Given row count rows = 5, print a diagonal mirror number pyramid — row i shows digit i on left and right diagonals with spaces elsewhere.

Python

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

Inputs & Outputs

Item	Type	Description
`rows`	int	Pyramid height — bottom row has `rows` on both diagonals.
`i` (outer)	int	Current row index — runs `1` to `rows`.
`j` (left)	int	Scans `rows..1` — prints digit when `i == j`.
`k` (right)	int	Scans `2..rows` — prints digit when `i == k`.
Positions per row	int	`rows + (rows - 1) = 2×rows - 1` character slots.
Digits per row	int	Exactly `2` (except row 1 when right loop is empty for rows = 1).

Minimal workflow

Pseudocode

for i from 1 to rows:
    for j from rows down to 1:
        print i if i == j else space
    for k from 2 to rows:
        print i if i == k else space
    print newline

Approach comparison

Approach	Idea	Best for
Two inner loops	Left `j = rows..1`, right `k = 2..rows`	Learning and interviews
Conditional print	`if (i == j)` digit else space	Diagonal placement drills
User-input rows	`int(input())`	Flexible pyramid size
Compact trace	`rows = 3` on paper first	Quick dry-runs before full demo
Character swap	Replace digit with `*` for an X-shape	Visual debugging

Cheat Sheet

⚡ Quick Reference

Goal	Pattern
Outer loop	`for i in range(1, rows + 1)`
Left diagonal	`for j in range(rows, 0, -1): print(i if i == j else " ", end="")`
Right diagonal	`for k in range(2, rows + 1): print(i if i == k else " ", end="")`
End row	`print()`
Program 56 contrast	Program 56 uses palindromic rows; Program 57 uses mirror diagonals

Compare

📋 Fixed Rows vs User Input vs Compact Trace

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

Fixed rows

rows = 5

Hard-coded height for demos

User input

int(input())

Read row count from console

Compact trace

rows = 3

Quick dry-run on paper

Left half

j = rows..1

Print when i == j

Right half

k = 2..rows

Print when i == k

Context

When This Pattern Shows Up

Reach for this pattern when teaching conditional printing, diagonal placement, and combining two inner loops per row.

Post Program 56 exercise
Natural follow-up after Program 56’s palindromic pyramid — introduces conditional diagonal placement.
Diagonal drills
Each row places digits on mirror diagonals — good bridge to matrix diagonal problems.
Two loops per row
Left and right halves with if checks — concrete nested-loop practice.
Gateway to Program 58
Program 58 extends this diagonal logic to a full diamond — compare after mastering this pyramid.
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 conditional printing, mirror diagonals, and O(n²) thinking.

Interactive

🔮 Live Preview

Choose row count between 3 and 9 and draw the centered diagonal mirror number pyramid in the browser.

Hands-On

Examples Gallery

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

📚 Getting Started

Print a diagonal mirror pyramid with five rows — left and right inner loops with conditional printing per row.

Example 1 — Fixed `rows = 5`

Hard-coded row count — scan left diagonal j = rows..1, then right diagonal k = 2..rows, printing digit or space.

Python

rows = 5

for i in range(1, rows + 1):
    for j in range(rows, 0, -1):
        print(i if i == j else " ", end="")

    for k in range(2, rows + 1):
        print(i if i == k else " ", end="")

    print()

How It Works

When i = 3, the left loop prints spaces then 3 at j = 3; the right loop prints spaces then 3 at k = 3 — output 3 3. When i = 1, only the left loop places a digit; the right loop is all spaces.

📈 User Input

Read row count from the console with safe parsing.

Example 2 — User Input Rows

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

Python

try:
    rows = int(input("Enter the number of rows: "))
except ValueError:
    print("Please enter a positive integer.")
else:
    if rows <= 0:
        print("Please enter a positive integer.")
    else:
        for i in range(1, rows + 1):
            for j in range(rows, 0, -1):
                print(i if i == j else " ", end="")

            for k in range(2, rows + 1):
                print(i if i == k else " ", end="")

            print()

How It Works

Same conditional diagonal logic 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 left and right diagonal loops before scaling to 5 rows.

Python

rows = 3

for i in range(1, rows + 1):
    for j in range(rows, 0, -1):
        print(i if i == j else " ", end="")

    for k in range(2, rows + 1):
        print(i if i == k else " ", end="")

    print()

How It Works

With only three rows you can trace every i == j and i == k check on paper before running the full rows = 5 demo.

🧠 How the Algorithm Prints Rows

Set rows

int rows = 5; controls pyramid height and the maximum digit printed.

Setup

Scan left diagonal

for j in range(rows, 0, -1) — print digit when i == j, else space.

Left half

Scan right diagonal

for k in range(2, rows + 1) — print digit when i == k, else space.

Right half

End the row

Call print() after both inner loops finish — one mirror-diagonal row complete.

Newline

Diagonal mirror pyramid complete

Each row scans 2×rows-1 positions — O(n²) time, O(1) extra memory.

Trace

🔎 Worked Walkthrough — `rows = 5`

Trace each row’s left diagonal hit, right diagonal hit, and full line output.

`i`	Left hit (`j`)	Right hit (`k`)	Row output
`1`	`j = 1`	(none)	`1`
`2`	`j = 2`	`k = 2`	`2 2`
`3`	`j = 3`	`k = 3`	`3 3`
`4`	`j = 4`	`k = 4`	`4 4`
`5`	`j = 5`	`k = 5`	`5 5`

Row i always prints exactly two digits (one per diagonal) when rows > 1 — spaced across 2×rows-1 character positions.

Use Cases

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

1. Teaching Nested Loops

Two inner loops with conditional printing — classic diagonal placement drill.

Example: trace each row in the walkthrough table — left hit, right hit.

2. Diagonal Drills

Each row mirrors digits on two diagonals — compare with Program 53’s single diagonal V-shape.

Example: row 5 prints 5 at column 5 and again at column 9.

3. Output Formatting Drills

Practice print(..., end="") vs print() with digit-or-space decisions per column.

Example: put print() inside the inner loop by mistake.

4. Why k starts at 2

Starting the right loop at 2 avoids a third digit at the center — keeps exactly two prints per row.

Example: try k = 1 and see the center digit triple on some rows.

5. Complexity Intuition

Each row scans about 2n positions — makes O(n²) concrete for beginners.

Example: row 5 with rows = 5 scans 9 character slots — see the walkthrough table.

6. Input Validation Labs

Pair the pattern with try/except ValueError and positive-row validation.

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 Python courses.

1. Instant Visual Feedback
Each row instantly forms an inverse-V — two digits on mirror diagonals make the shape obvious.
2. Real Math Connection
Conditional digit-or-space printing teaches real console alignment — not abstract loop drill.
3. Easy to Extend
Swap digits for * to get an X-shape, or extend to Program 58’s full diamond.
4. O(1) Extra Memory
Streaming output needs no storage beyond loop counters.

Pro Tip: trace rows = 3 on paper — row 2 shows 2 2 with one space between the digits.

Usage Tips

Small habits that keep number-pattern code clean.

1. Left loop: j = rows..1
Print the digit when i == j; otherwise print a single space.
2. Use try/except for Input
Avoid crashing when the user types letters instead of a number.
3. Newline After Both Inner Loops
Only call print() after both inner loops finish the row.
4. Right loop starts at k = 2
Use for k in range(2, rows + 1) so the center position is not duplicated.
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 print() inside the inner loop.

Common Pitfalls

Mistakes that commonly break diagonal mirror number pyramid patterns.

1. print() Inside Inner Loop
Each digit lands on its own line — you get a column, not a pyramid.
→ Use print(i if i == j else " ", end=""); call print() only after both inner loops.
2. Right Loop Starts at 1
Starting at k = 1 can print a third digit at the center — row looks crowded.
→ Use for k in range(2, rows + 1) — mirror from column 2 onward.
3. Wrong Condition Check
Using j == rows instead of i == j places digits on the wrong diagonal.
→ Always compare the outer row index i with the inner loop variable j or k.
4. Forgetting Newline After Row
All numbers print on one long line without row breaks.
→ Add print() after both inner loops complete.
5. Unchecked int(input())
Letters or empty input raise ValueError or leave rows unset.
→ Wrap int(input()) in try/except ValueError and re-prompt on failure.

Edge Cases

Check these inputs before calling the solution done.

rows = 1

Single row

Output is just 1 — the right loop (k = 2..1) 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 two copies of 5 across 9 positions — good for dry-runs before scaling up.

Bad input

Non-numeric input

Bare int(input()) raises ValueError — wrap it in try/except.

Large rows

Wide output

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

Drill

🎯 Practice Problems

Try these variations to lock in the pattern.

1. Compare with Program 56

Program 56 prints centered palindromic rows (1..i..1)
Program 57 prints the row digit twice on mirror diagonals

2. Build Program 58 diamond

Print this pyramid, then add the inverted bottom half
Compare with Program 58’s full diagonal mirror diamond

3. Next in series

Continue with Program 58
Extend diagonal logic to a full diamond shape

4. Character swap

Replace print(i, end="") with print("*", end="")
Same loops, clean X-shape for visual debugging

Important

Notes

Two inner loops. Left: j = rows..1, print when i == j. Right: k = 2..rows, print when i == k.
print(..., end="") stays on the line; print() advances — call it only after both inner loops finish.
Validate rows > 0 for interactive programs; rows = 1 prints a single 1 on the left diagonal.
Row i scans 2×rows-1 positions — total work grows as O(n²) for n rows.

Quick Takeaway: left j = rows..1, right k = 2..rows, digit or space, then print().

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 diagonal mirror number pyramid is a natural follow-up to Program 56: each row places the row digit on two mirror diagonals with conditional printing. Master the fixed-rows version, then try user input and the compact 3-row trace.

Practice the three examples above, then continue to Program 58 for the full diagonal mirror diamond.

Row i prints two copies of digit i — one on each mirror diagonal across 2×rows-1 positions.

View Examples Gallery Continue to Program 58

Pro Tips

💡 Best Practices

✅ Do

Left: for j in range(rows, 0, -1) with if i == j
Right: for k in range(2, rows + 1) with if i == k
Print a single space for non-matching positions
Call print() after both inner loops
Use try/except ValueError around int(input()) for user input

❌ Don’t

Start right loop at k = 1 — can triple-print at center
Use j == rows instead of i == j — wrong diagonal
Call print() 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 diagonal mirror pyramid

Print the mirror-diagonal pyramid the beginner-friendly way.

Core concepts

△ 01

Rule

digit i twice per row

Definition

▦ 02

Left

j = rows..1

Code

↑ 03

Right

k = 2..rows

Code

↓ 04

Check

i == j or i == k

Logic

O 05

Complexity

O(n²) time

Analysis

❓ Frequently Asked Questions

Why does each row print the number twice?

The left inner loop places the row number on the left diagonal; the right inner loop mirrors it on the right diagonal.

Why does the second inner loop start from 2?

Starting at k = 2 avoids duplicating the center position — each row prints the number at most twice.

What does this diagonal mirror pyramid print?

Row i shows the digit i on two diagonals with spaces between, e.g. row 3 with rows = 5: ' 3 3'.

How is this different from Program 56?

Program 56 prints a centered palindromic row (1..i..1). Program 57 prints only the row number twice on mirror diagonals.

Why use i == j and i == k conditions?

Each column position gets either the row digit or a space — the conditions pick exactly two print positions per row.

How can I change the pyramid height?

Change rows or read it from user input with int(input()) — see Example 2.

What is the time complexity?

O(n²) for n rows because each row scans about 2n character positions.

Can I print a character instead of a number?

Yes. Replace print(i, end="") with print("*", end="") in both diagonal print branches.

How should I read rows safely?

Use try/except ValueError around int(input()). Bare int(input()) raises ValueError on bad input.

What happens when rows is 1?

One row prints a single 1 — the right loop (k = 2..1) does not run.

Did you Know? 🔊

Each row prints the row number twice — once on the left diagonal and once on the right — with spaces everywhere else. Total positions per row = 2×rows-1.

Continue to Program 58

Move on to the full diagonal mirror diamond in the Python number-pattern series.

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

Python Number Pattern 56 — Palindromic Number Pyramid Python Number Pattern 58

Diagonal Mirror Number Pyramid in Python

What You’ll Learn

Shape Rule

Outer Loop

Left Diagonal

Right Diagonal

Conditional Print

O(n²)

Introduction

Why it matters?

Left diagonal

Right diagonal

vs Program 56

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

Diagonal drills

Two loops per row

Gateway to Program 58

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

Scan left diagonal

Scan right diagonal

End the row

Diagonal mirror pyramid complete

🔎 Worked Walkthrough — rows = 5

Use Cases

1. Teaching Nested Loops

2. Diagonal Drills

3. Output Formatting Drills

4. Why k starts at 2

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. Left loop: j = rows..1

2. Use try/except for Input

3. Newline After Both Inner Loops

4. Right loop starts at k = 2

5. Dry-Run rows = 5

Common Pitfalls

1. print() Inside Inner Loop

2. Right Loop Starts at 1

3. Wrong Condition Check

4. Forgetting Newline After Row

5. Unchecked int(input())

Edge Cases

Single row

Empty output

rows < 0

Compact trace

Non-numeric input

Wide output

🎯 Practice Problems

1. Compare with Program 56

2. Build Program 58 diamond

3. Next in series

4. Character swap

Example 1 — Fixed `rows = 5`

Example 3 — Compact `rows = 3`

🔎 Worked Walkthrough — `rows = 5`

`rows < 0`