Alphabet X Pattern (Diagonal Letters A..E) in Python

Beginner

⏱️ 8 min read

📚 Updated: Aug 2026

🎯 3 Code Examples

🚀 Live Preview

Nested Loops

Alphabet X pattern with diagonal letters A through E in Python programming

Overview

What You’ll Learn

Each row places one letter on two diagonals forming an X shape: row 0 prints A at both ends, each next row steps inward with B, C, D, until a single E lands in the center for five rows. A column loop with left = r and right = width - 1 - r teaches 2D grid thinking. Compare with star X pattern (0 and *). Includes a live preview, worked Python examples, edge cases, and complexity.

X Rule

Two diagonals

Each row prints one letter at left and right columns; all other columns are spaces.

Left Diagonal

col = r

left = r moves one column right each row — top-left to center.

Right Diagonal

col = width - 1 - r

right = width - 1 - r moves one column left each row — top-right to center.

Grid Width

2*rows - 1

width = 2 * rows - 1 gives equal space on both sides of the center column.

Live Preview

1–26 rows

Pick a row count and draw the alphabet X pattern in the browser instantly.

O(n²)

Complexity

n rows × 2n - 1 columns per row ≈ O(n²); extra memory stays O(1).

Introduction

An alphabet X pattern places letters on two diagonals inside a grid of width 2*rows - 1. Row 0 prints A at both ends; each row steps inward until the diagonals meet at one center letter.

In Python you solve it with an outer loop over row index r, an inner column loop, and ord()/chr() — or build each row in a list and print(''.join(row)) for clarity.

Why it matters?

It teaches 2D grid coordinates — mapping row and column indices to print positions — the same skill used in matrices, game boards, and ASCII art. When left == right, both diagonals meet and only one character prints.

Key Highlights

Grid Width

width = 2 * rows - 1 — for rows=5 the grid is 9 columns wide.

Left Diagonal

left = r — column index grows one step right each row.

Right Diagonal

right = width - 1 - r — column index shrinks one step left each row.

Center Meet

When left == right, only one letter prints — not two copies.

In short: set width = 2 * rows - 1 and base = ord('A'), loop r from 0 to rows - 1, compute left = r and right = width - 1 - r, print the row letter at those columns and spaces elsewhere, then print() for the newline.

Foundation

📝 Problem & Approach

Given a positive integer rows, print an X-shaped grid of rows lines, each 2*rows - 1 characters wide. Row r prints chr(ord('A') + r) at columns left = r and right = width - 1 - r; all other positions are spaces.

Python

# First 5 rows (width = 9)
# A       A
#  B     B
#   C   C
#    D D
#     E

Inputs & Outputs

Item	Type	Description
`rows`	int	Number of rows (also the row letter runs A through the rows-th letter). Clamp to 1–26 for A–Z demos.
Printed output	text	X-shaped grid: letters on two diagonals, spaces elsewhere — width `2*rows - 1` per line.

Minimal workflow

Pseudocode

width = 2 * rows - 1
base = ord('A')
for r from 0 to rows-1:
    ch = chr(base + r)
    left = r
    right = width - 1 - r
    for c from 0 to width-1:
        print ch if c==left or c==right else space
    print newline

Approach comparison

Approach	Idea	Best for
Column loop	`for c in range(width):` print letter or space	Learning 2D grid coordinates and diagonals
Join list	Build row in a list, `print(''.join(row))`	Clearer debugging and row inspection
Star X contrast	See Program 45 (0 and * X)	Same diagonal logic with symbols instead of letters

Cheat Sheet

⚡ Quick Reference

Goal	Pattern
Grid width	`width = 2 * rows - 1`
Outer loop (row index)	`for r in range(rows):`
Row letter	`ch = chr(base + r)`
Diagonal columns	`left = r; right = width - 1 - r`
Column loop	`for c in range(width): print(ch if c==left or c==right else " ", end="")`
End the row	`print()`
List join variant	`row.append(ch if ... else " "); print(''.join(row))`

Compare

📋 Left Diagonal vs Right Diagonal vs Join Row

Three ways to think about the same X grid — pick based on what you are learning.

Left diagonal

left = r
col moves right

Top-left to center — column index equals row index.

Right diagonal

right = width-1-r
col moves left

Top-right to center — column index shrinks as rows grow.

Join row

row.append(...)
''.join(row)

Collect characters in a list, then print one string — easier to inspect each row while debugging.

Star X contrast

* on diagonals
0 elsewhere

Same diagonal positions — see Program 45 with 0 and *.

Context

When This Pattern Shows Up

Reach for diagonal column loops when you need letters (or symbols) on two crossing lines inside a fixed-width grid.

After Program 30
Program 30 mixes prefix and suffix on one line. This pattern uses a 2D grid with diagonal columns.
2D coordinates
Practice mapping (r, c) pairs to print positions before tackling matrices.
Diagonal grids
Same left/right column rule appears in star X patterns and hollow diamond shapes.
Gateway to Program 32
Next pattern builds a centered palindrome pyramid — another symmetric shape.
Not a UI layout tool
This is a console teaching pattern — not how you build modern app screens.

Key benefit: one program that proves you can map row/column indices to diagonal positions — a pattern used in matrices, game boards, and ASCII art far beyond alphabet demos.

Interactive

🔮 Live Preview

Choose a row count between 1 and 26 and draw the alphabet X pattern in the browser.

Hands-On

Examples Gallery

Three complete Python programs — fixed five rows with diagonal column loops, console input with ternary form, and a list-join variant for clarity. Click View Output to reveal sample console results.

📚 Getting Started

Print five rows of the alphabet X pattern with left/right diagonal column loops.

Example 1 — Fixed `rows = 5`

Hard-coded height — ideal for first demos and screenshots.

Python

rows = 5
rows = max(1, min(rows, 26))

width = 2 * rows - 1
base = ord('A')

for r in range(rows):  # 0..rows-1
    ch = chr(base + r)
    left = r
    right = width - 1 - r

    for c in range(width):
        if c == left or c == right:
            print(ch, end="")
        else:
            print(" ", end="")
    print()

How It Works

The outer loop walks row index r from 0 to 4. For each row, ch = chr(base + r) selects the letter and left = r, right = width - 1 - r mark the two diagonal columns. The inner loop scans every column: print the letter when c == left or c == right, otherwise print a space. On the last row left == right == 4, so only one E appears in the center.

📈 Practical Variant

Let the user choose the height at runtime.

Example 2 — User Input Version

Read rows and clamp to 1–26. Wrap int(input()) in try/except ValueError in real apps.

Python

rows = int(input("Enter number of rows (max 26): "))
rows = max(1, min(rows, 26))
width = 2 * rows - 1
base = ord('A')
for r in range(rows):
    ch = chr(base + r)
    left = r
    right = width - 1 - r
    for c in range(width):
        print(ch if (c == left or c == right) else " ", end="")
    print()

How It Works

Same diagonal grid core as Example 1; only the row count comes from input. Three rows use width 5 with letters A–C on the diagonals — row 2 prints B at columns 1 and 3.

⚡ List Join Variant

Build each row in a list, then print with ''.join(row).

Example 3 — `''.join(row)` Variant

Collect letters in a list for clearer row inspection — same logic, easier debugging.

Python

rows = 5
rows = max(1, min(rows, 26))

width = 2 * rows - 1
base = ord('A')

for r in range(rows):
    ch = chr(base + r)
    left = r
    right = width - 1 - r
    row = []

    for c in range(width):
        row.append(ch if (c == left or c == right) else " ")

    print(''.join(row))

How It Works

The column loop appends each character to row instead of printing immediately. ''.join(row) builds the full line — identical output to Examples 1 and 2, but you can inspect row before printing during debugging.

🧠 How the Algorithm Prints Rows

Set up bounds

Clamp rows, then set width = 2 * rows - 1 and base = ord('A') for the grid and alphabet.

width / base

Outer loop (row index)

for r in range(rows): walks each row from 0 to rows - 1, computing left, right, and ch.

r = 0..n-1

Column loop

for c in range(width): prints the letter at diagonal columns and spaces elsewhere with print(..., end="").

Inner loop

New line

print() ends the row after the column loop finishes; the outer loop advances r to the next row.

Break

Pattern complete

Total characters: n × (2n - 1) ≈ O(n²) — O(n²) time, O(1) extra memory (loop version).

Trace

🔎 Worked Walkthrough — `rows = 5`

Trace each outer-loop value of r and see how left, right, and the row letter produce each printed line.

`r`	Letter	`left`	`right`	Row output
0	`A`	0	8	`A A`
1	`B`	1	7	`B B`
2	`C`	2	6	`C C`
3	`D`	3	5	`D D`
4	`E`	4	4	`E` (left==right)

Total character prints: 5 × 9 = 45 = rows × width for rows = 5.

Use Cases

Where diagonal grid patterns show up beyond the homework prompt.

1. After Program 30

Program 30 mixes prefix and suffix on one line. This pattern uses a 2D grid with diagonal columns.

Example: compare fixed-width rows vs spaced X grid side by side.

2. 2D coordinate practice

Reinforce mapping (r, c) pairs to print positions before tackling matrices.

Example: trace left and right for row 2 (r=1) on paper before coding.

3. Star X patterns

Same diagonal positions with * instead of letters — see Program 45.

Example: swap ch for * and keep the column loop.

4. Number X grid

Swap letters for digits 1..n at the same diagonal columns.

Example: rows=3 prints 1 at corners and 3 in the center.

5. Complexity intuition

Rectangular totals make O(n²) concrete for beginners.

Example: 5 rows → 45 characters printed (5 × 9).

6. Interview warm-up

Classic nested-loop question that tests diagonal column indices and center merge.

Example: explain why only one E prints when rows=5 without running code.

Pro Tip: say “letter at left and right columns, space everywhere else” before coding — that story prevents wrong width or missing spaces.

Advantages

Why this pattern earns a spot after the mixed alphabet rows from Program 30.

1. Teaches 2D Grids
Row and column loops map directly to matrix coordinates — a core programming skill.
2. Symmetric Shape
The X is visually symmetric — left and right diagonals mirror each other.
3. Two Implementations
Direct print version for learning; list-join version for clearer debugging.
4. O(1) Extra Memory
Streaming output needs no storage beyond loop counters (join variant uses O(width) per row).

Pro Tip: when left == right on the last row, the or condition still prints exactly once per column — no special case needed.

Usage Tips

Small habits that keep alphabet X pattern code clean.

1. Name left and right
Use left = r and right = width - 1 - r — keep r and c for loop variables.
2. Wrap int(input()) in try/except
Avoid crashes when the user types letters instead of a number.
3. Clamp rows early
rows = max(1, min(rows, 26)) keeps demos inside A–Z.
4. Compute width once
width = 2 * rows - 1 before the row loop — do not recompute inside unless rows changes.
5. Dry-run rows = 3
Trace A at corners, B, center C on paper before coding larger demos.

Pro Tip: if the shape looks like a solid block, you likely forgot spaces — only diagonal columns should print letters.

Common Pitfalls

Mistakes that commonly break alphabet X patterns.

1. Wrong width formula
Using width = rows or width = 2 * rows misaligns the diagonals — the X looks skewed or truncated.
→ Use width = 2 * rows - 1 so the top row has equal space on both sides.
2. Printing letter twice at center
Some beginners add a separate branch when left == right and accidentally print the letter twice.
→ The condition c == left or c == right already prints once per column — no extra branch needed.
3. Hardcoded ASCII 65
Magic numbers like chr(65 + r) work but break readability and lowercase variants.
→ Use base = ord('A') and chr(base + r) instead of raw ASCII values.
4. Blind int(input())
Non-numeric input raises ValueError with bare int(input()).
→ Wrap int(input()) in try/except ValueError and validate range.
5. Missing spaces between letters
Printing only letters without spaces collapses the X into a solid diagonal block.
→ The inner loop must print a space character for every non-diagonal column.

Edge Cases

Check these inputs before calling the solution done.

rows = 1

Single letter

Output is just A on one line — left == right == 0, so one letter at column 0.

rows = 0

Empty pattern

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

rows = 26

Full alphabet

26 rows with width 51 — last row prints Z once at the center column.

rows > 26

Past Z

Clamp to 26 or define a wrap/error policy before printing.

Bad input

Non-numeric input

Use try/except ValueError before clamping rows.

Case

Lowercase variant

Same loops work with base = ord('a') and lowercase output.

Drill

🎯 Practice Problems

Try these variations to lock in the pattern.

1. Compare with Program 30

Program 30: mixed rows ABCDE, BABCD, CBABC
This pattern: diagonal X with spaced grid
See Program 30

2. Implement join-row form

Rewrite Example 1 using row.append and ''.join(row)
Verify identical output for rows=5

3. Star X with 0 and *

Same diagonal columns with * and 0
See Program 45

4. Continue to Program 32

Next pattern — centered alphabet palindrome pyramid
Builds on symmetric shape ideas
See Program 32

Important

Notes

Grid count. Total characters for n rows is n × (2n - 1) — each row scans the full width.
Column loop: for c in range(width): with left = r and right = width - 1 - r.
''.join(row) after building in a list is equivalent to the direct-print version — use whichever fits your lesson.
Clamp to 26 rows for A–Z demos; row 26 prints Z once at the center when diagonals meet.

Quick Takeaway: outer loop sets r, compute left and right, print the row letter at diagonal columns and spaces elsewhere, then break the line — that is the whole alphabet X pattern.

Analysis

⏱️ Time and Space Complexity

Program	Time	Extra space
Column loop (Examples 1–2)	`O(rows²)`	`O(1)`
Join variant (Example 3)	`O(rows²)`	`O(width)` for the row list per line

Wrap Up

🎉 Conclusion

The alphabet X pattern teaches 2D grid thinking — mapping row and column indices to diagonal print positions. Master the direct-print version, then try the list-join variant for clearer debugging.

Practice the three examples above, then continue to Program 32 in the alphabet pattern series.

Set width, left, and right each row, run the column loop, clamp rows to 26, and compare with star X pattern (Program 45) using the same diagonal logic.

View Examples Gallery Continue to Program 32

Pro Tips

💡 Best Practices

✅ Do

Set base = ord('A'), width = 2 * rows - 1
Compute left = r and right = width - 1 - r each row
Run the column loop on every row
Print a space for non-diagonal columns — not just skip printing
Use print(ch, end="") or ternary in the column loop; print() after
Clamp rows to 1–26 for A–Z demos

❌ Don’t

Use wrong width formula — diagonals will not align
Hardcode ASCII 65 instead of ord('A')
Skip spaces — the X collapses into solid diagonals
Add a duplicate print when left == right — one column already prints once
Call print() inside the letter loops
Let rows exceed 26 without a defined policy

Summary

Key Takeaways

Knowledge Unlocked

Five things to remember about this alphabet X pattern

Print the X grid the beginner-friendly way.

Core concepts

▽ 01

Rule

Two diagonals

Definition

↓A 02

Left diagonal

left = r

Code

B→ 03

Right diagonal

width - 1 - r

Code

[] 04

Join list

''.join(row)

Alt

O 05

Complexity

O(n²) time

Analysis

❓ Frequently Asked Questions

What is the alphabet X pattern?

Letters sit on two diagonals forming an X shape. Row r prints chr(ord('A') + r) at column left = r and column right = width - 1 - r inside a grid of width 2*rows - 1.

Why is there only one letter on the last row?

On the final row left equals right at the center column. The condition c == left or c == right is true for only one column, so one letter prints — not two.

How do left and right column indices work?

For row index r (0-based), left = r moves down-right. right = width - 1 - r moves down-left. They converge at the center when r equals rows - 1.

Why is width = 2*rows - 1?

The X needs equal space on both sides of the center. For rows=5 the widest row has A at columns 0 and 8, so width is 9 = 2*5 - 1.

Why clamp rows to 26?

Each row uses letters starting at A through the r-th letter. With rows > 26 you would need characters beyond Z unless you define a wrap policy.

What is the difference between print with end= and print()?

print(ch, end="") keeps each character on the same row. print() ends the row after the inner column loop finishes.

What is the time complexity?

O(n²) where n is rows. There are n rows and each row scans width = 2*n - 1 columns.

How should I read the row count safely?

Use a try/except ValueError around int(input()), or check raw.isdigit() before converting, then clamp rows between 1 and 26.

Did you Know? 🔊

Row r prints letter chr(ord('A') + r) at columns left = r and right = width - 1 - r in a grid of width 2*rows - 1. On the last row both diagonals meet, so only one E appears in the center.

Continue to Program 32

Next up: the centered alphabet palindrome pyramid — build on symmetric shape ideas from this tutorial.

Program 32 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 Alphabet Pattern 30 — Mixed Alphabet Pattern Python Alphabet Pattern 32 — Centered Alphabet Palindrome Pyramid

Alphabet X Pattern (Diagonal Letters A..E) in Python

What You’ll Learn

X Rule

Left Diagonal

Right Diagonal

Grid Width

Live Preview

O(n²)

Introduction

Why it matters?

Grid Width

Left Diagonal

Right Diagonal

Center Meet

📝 Problem & Approach

Inputs & Outputs

Minimal workflow

Approach comparison

⚡ Quick Reference

📋 Left Diagonal vs Right Diagonal vs Join Row

When This Pattern Shows Up

After Program 30

2D coordinates

Diagonal grids

Gateway to Program 32

Not a UI layout tool

🔮 Live Preview

Examples Gallery

📚 Getting Started

Example 1 — Fixed rows = 5

How It Works

📈 Practical Variant

Example 2 — User Input Version

How It Works

⚡ List Join Variant

Example 3 — ''.join(row) Variant

How It Works

🧠 How the Algorithm Prints Rows

Set up bounds

Outer loop (row index)

Column loop

New line

Pattern complete

🔎 Worked Walkthrough — rows = 5

Use Cases

1. After Program 30

2. 2D coordinate practice

3. Star X patterns

4. Number X grid

5. Complexity intuition

6. Interview warm-up

Advantages

1. Teaches 2D Grids

2. Symmetric Shape

3. Two Implementations

4. O(1) Extra Memory

Usage Tips

1. Name left and right

2. Wrap int(input()) in try/except

3. Clamp rows early

4. Compute width once

5. Dry-run rows = 3

Common Pitfalls

1. Wrong width formula

2. Printing letter twice at center

3. Hardcoded ASCII 65

4. Blind int(input())

5. Missing spaces between letters

Edge Cases

Single letter

Empty pattern

Full alphabet

Past Z

Non-numeric input

Lowercase variant

🎯 Practice Problems

1. Compare with Program 30

2. Implement join-row form

3. Star X with 0 and *

4. Continue to Program 32

Example 1 — Fixed `rows = 5`

Example 3 — `''.join(row)` Variant

🔎 Worked Walkthrough — `rows = 5`

2. Wrap `int(input())` in try/except