Symmetric Alphabet, Star Center in Java

Beginner

⏱️ 8 min read

📚 Updated: Aug 2026

🎯 3 Code Examples

🚀 Live Preview

Nested Loops

Symmetric alphabet pattern with stars between mirrored halves in Java programming

Overview

What You’ll Learn

Build rows that mirror letters from both ends, while * fills the center gap as the letter half shortens. For top = 'E', the output begins with ABCDEEDCBA and ends with A********A. Includes a live preview, worked Java examples, edge cases, and complexity.

Shape Rule

Left | stars | right

Each row: A..end, then even stars, then end..A.

Outer Loop

End letter countdown

for (char i = top; i >= 'A'; i--) picks the letter half end.

Three Parts

Prefix, gap, mirror

Print left letters, 2*(top-i) stars, then mirrored letters.

Fixed Width

2n chars / row

Every row stays the same length as letters shrink and stars grow.

Live Preview

1–13 rows

Pick a row count and draw the symmetric star-center pattern in the browser.

O(n²)

Complexity

n rows × 2n chars = O(n²); extra memory stays O(1).

Introduction

A symmetric alphabet pattern with a star center keeps a fixed row width while swapping letter space for stars. The left half shrinks from A..top toward A, the center grows with an even number of * characters, and the right half mirrors the left.

In Java you usually solve it with an outer countdown plus three inner loops (or a string shortcut for the stars): left letters, stars, then mirrored letters, then System.out.println().

Why it matters?

It is a classic multi-part row exercise: prefix, gap, and mirror. Once that clicks, hollow diamonds, butterfly patterns, and other fixed-width symmetric shapes become much easier.

Key Highlights

Three Segments

Left letters, center stars, right mirror.

Even Star Gap

Stars = 2*(top - i) — always even.

Constant Width

Every row has exactly 2n characters.

Double Middle

First row doubles the peak letter when stars = 0.

In short: for each end letter i from top down to A, print A..i, then 2*(top-i) stars, then i..A, then break the line.

Foundation

📝 Problem & Approach

Given a positive integer rows (or a fixed top letter like 'E'), print a fixed-width symmetric pattern of alphabet halves with a growing star center.

Java

// First 5 rows (conceptual shape)
// ABCDEEDCBA
// ABCD**DCBA
// ABC****CBA
// AB******BA
// A********A

Inputs & Outputs

Item	Type	Description
`rows`	int	Number of lines (typically 1–26). Top letter = `'A' + rows - 1`.
Printed output	text	Each row has width `2*rows`: left letters + even stars + mirrored letters.

Minimal workflow

Pseudocode

top = 'A' + rows - 1
for i from top down to 'A':
    print letters A..i
    print 2*(top - i) stars
    print letters i..A
    print newline

Approach comparison

Approach	Idea	Best for
Three nested loops	Left + stars + right explicitly	Learning and interviews
`"*".repeat(stars)`	Build the gap in one call	Shorter production-style demos

Cheat Sheet

⚡ Quick Reference

Goal	Pattern
Walk row ends	`for (char i = top; i >= 'A'; i--)`
Left half	`for (char j = 'A'; j <= i; j++) System.out.print(j);`
Star gap	`int stars = 2 * (top - i);`
Right half	`for (char m = i; m >= 'A'; m--) System.out.print(m);`
Star shortcut	`System.out.print("*".repeat(stars));`
End the row	`System.out.println();`

Compare

📋 print vs Stars vs Mirror

Same row — three roles that must stay in order.

Left print(j)

A..i

Ascending prefix for this row’s end letter

Center stars

2*(top-i)

Even gap that grows as letters shrink

Right print(m)

i..A

Descending mirror of the left half

System.out.println

new line

Only after all three parts finish

Context

When This Pattern Shows Up

Reach for this shape when practicing multi-part fixed-width rows.

After simpler triangles
Combine ascending, descending, and fill in one row.
Center-gap drills
Same idea as hollow stars: letters shrink, filler grows.
Symmetry checks
Visual test that left and right halves stay mirrors.
Gateway to Program 16
Next: centered alphabet pyramids with leading spaces.
Not a UI layout tool
This is a console teaching pattern — not how you build modern app screens.

Key benefit: one program that locks in prefix + gap + mirror thinking while keeping row width constant.

Interactive

🔮 Live Preview

Choose a row count between 1 and 13 and draw the symmetric alphabet / star-center pattern in the browser.

Hands-On

Examples Gallery

Three complete Java programs — fixed top letter, console input, and a String.repeat star shortcut. Click View Output to reveal sample console results.

📚 Getting Started

Print five rows with three explicit inner loops.

Example 1 — Fixed `top = 'E'`

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

Java

public class StarCenterSymmetric {
    public static void main(String[] args) {
        char top = 'E';

        for (char i = top; i >= 'A'; i--) {
            for (char j = 'A'; j <= i; j++) {
                System.out.print(j);
            }

            int stars = 2 * (top - i);
            for (int s = 1; s <= stars; s++) {
                System.out.print("*");
            }

            for (char m = i; m >= 'A'; m--) {
                System.out.print(m);
            }

            System.out.println();
        }
    }
}

How It Works

When i = 'E', left prints ABCDE, stars = 0, right prints EDCBA — hence the doubled E. As i falls, the letter halves shrink and the even star gap grows, keeping width 10.

📈 Practical Variant

Let the user choose the height at runtime.

Example 2 — User Input Version

Compute top = 'A' + rows - 1, then reuse the same three-part row. Check hasNextInt() in real apps.

Java

import java.util.Scanner;

public class StarCenterInput {
    public static void main(String[] args) {
        int rows;
        Scanner sc = new Scanner(System.in);

        System.out.print("Enter the number of rows: ");
        rows = sc.nextInt();

        char top = (char)('A' + rows - 1);

        for (char i = top; i >= 'A'; i--) {
            for (char j = 'A'; j <= i; j++) {
                System.out.print(j);
            }

            int stars = 2 * (top - i);
            for (int s = 1; s <= stars; s++) {
                System.out.print("*");
            }

            for (char m = i; m >= 'A'; m--) {
                System.out.print(m);
            }

            System.out.println();
        }

        sc.close();
    }
}

How It Works

For rows = 4, top is 'D' and each row has width 8. Clamp rows to 1–26 so top stays within A–Z.

⚡ Shortcut Style

Same shape with a one-call star gap.

Example 3 — `"*".repeat(stars)`

Keep the letter loops; build the center gap in one call.

Java

public class StarCenterString {
    public static void main(String[] args) {
        char top = 'E';

        for (char i = top; i >= 'A'; i--) {
            for (char j = 'A'; j <= i; j++) {
                System.out.print(j);
            }

            int stars = 2 * (top - i);
            System.out.print("*".repeat(stars));

            for (char m = i; m >= 'A'; m--) {
                System.out.print(m);
            }

            System.out.println();
        }
    }
}

How It Works

"*".repeat(stars) creates the whole gap at once. Great once you understand the three-part row; keep the explicit star loop for exams that ask you to show all bounds.

🧠 How the Algorithm Prints Rows

Set up

Import java.util.Scanner when reading input. Fix top or compute it from rows.

Setup

Outer loop (end letter)

i goes from top down to 'A' — that is the letter half end.

E → A

Left + stars

Print A..i, then 2*(top - i) stars for the center gap.

Prefix + gap

Mirror + break

Print i..A, then System.out.println() to end the fixed-width row.

Mirror

Pattern complete

n rows × 2n characters = O(n²) time, O(1) extra memory.

Trace

🔎 Worked Walkthrough — `top = 'E'`

Trace each outer-loop value of i and check left, stars, and right.

`i`	Left	Stars	Right	Full row
`'E'`	`ABCDE`	0	`EDCBA`	`ABCDEEDCBA`
`'D'`	`ABCD`	2	`DCBA`	`ABCD**DCBA`
`'C'`	`ABC`	4	`CBA`	`ABC****CBA`
`'B'`	`AB`	6	`BA`	`AB******BA`
`'A'`	`A`	8	`A`	`A********A`

Every row has length 10 = 2×5. Total characters: 5×10 = 50.

Use Cases

Where this multi-part row pattern shows up beyond the homework prompt.

1. Multi-Part Rows

Clearest demo that one row can be several loops in sequence.

Example: omit the right half and watch symmetry break.

2. Fixed-Width Shapes

Letters shrink while filler grows so width stays constant.

Example: count chars on every row — always 2n.

3. Mirror Practice

Ascending then descending loops over the same end letter.

Example: swap right loop direction and break the palindrome.

4. Fill-Character Variants

Swap * for #, spaces, or digits once the structure works.

Example: use "#".repeat(stars).

5. Complexity Intuition

Constant-width rows make O(n²) obvious: n × 2n prints.

Example: n = 10 → 200 characters.

6. Input Validation Labs

Pair with hasNextInt() and 1–26 clamps for A–Z.

Example: reject rows > 26.

Pro Tip: say “left, gap, right” before coding — that story prevents forgetting the mirror half or misplacing println.

Advantages

Why this pattern earns a spot after simpler alphabet triangles.

1. Instant Visual Feedback
Wrong star count or missing mirror shows up immediately as broken symmetry.
2. Composable Skills
Reuses ascending loops, descending loops, and fill loops together.
3. Easy to Customize
Change the fill character or skip the doubled middle with small edits.
4. Clear Complexity Story
Fixed width 2n makes O(n²) easy to explain in interviews.

Pro Tip: learn the three-loop version first; treat "*".repeat(stars) as a polish shortcut afterward.

Usage Tips

Small habits that keep symmetric star-center code clean.

1. Name the Three Parts
Comment or structure code as left / stars / right so the order stays obvious.
2. Prefer hasNextInt()
Avoid crashes when the user types letters instead of a number.
3. Keep println Last
Only call println() after left, stars, and right all finish.
4. Use Even Star Counts
Stick to 2*(top - i) so the gap stays even and centered.
5. Dry-Run One Small n
Trace rows = 3 (ABCCBA / AB**BA / A****A) on paper first.

Pro Tip: if the first row is ABCDEDCBA (one E), you started the right half at i - 1 — fine as a variant, but not this page’s default.

Common Pitfalls

Mistakes that commonly break symmetric star-center patterns.

1. Forgetting the Mirror Half
You get only left letters and stars — no symmetry.
→ Always print i..A after the star gap.
2. Wrong Star Formula
Using top - i (not doubled) misaligns the center and shrinks the width.
→ Keep stars = 2 * (top - i).
3. println Too Early
Breaking after the left half splits one logical row into three lines.
→ Call println only after left + stars + right.
4. Blind nextInt()
Letters or empty input throw InputMismatchException.
→ Check hasNextInt() and re-prompt on failure.
5. Reversing the Left Half
Printing the left side descending changes the intended pattern.
→ Left is always ascending A..i; right is descending i..A.

Edge Cases

Check these inputs before calling the solution done.

rows = 1

Single doubled letter

Output is AA (left A + right A, zero stars).

rows = 0

Empty pattern

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

First row

Doubled peak

Expect ...EE... style middle when stars = 0.

rows > 26

Past Z

Clamp or error — char math leaves A–Z.

Bad input

Non-numeric input

nextInt() throws — check hasNextInt().

Fill char

Not only `*`

Same structure works with #, spaces, or digits.

Drill

🎯 Practice Problems

Try these variations to lock in the pattern.

1. Single middle letter

Start right half at i - 1 when stars = 0
First row becomes ABCDEDCBA

2. Change the fill

Use # or spaces instead of *
Keep the 2*(top-i) count

3. Safe input loop

Use hasNextInt() until 1 <= rows <= 26
Then draw the pattern

4. Continue to Program 16

Centered alphabet pyramid next
See Program 16

Important

Notes

Fixed width. Each row has 2n characters; total work is 2n² — O(n²).
Star count must be 2*(top - i) for this centered even gap.
First row doubles the peak letter because left ends at i and right starts at i.
Validate 1 <= rows <= 26 for interactive A–Z programs.

Quick Takeaway: left A..i, even star gap, right i..A, then break the line — that is the whole pattern.

Analysis

⏱️ Time and Space Complexity

Program	Time	Extra space
Three loops (Examples 1–2)	`O(n²)`	`O(1)`
`"*".repeat(stars)` (Example 3)	`O(n²)`	`O(n)` temporary gap string per row

Each of the n rows prints exactly 2n characters, so total prints are 2n².

Wrap Up

🎉 Conclusion

The symmetric alphabet / star-center pattern is a multi-part nested-loop exercise with lasting payoff: prefix, even gap, and mirror on a fixed-width row. Master the three-loop version, then optionally shorten the star gap with "*".repeat(stars).

Practice the three examples above, then continue to Program 16’s centered alphabet pyramid.

Print left, then 2*(top-i) stars, then the mirror — and call println only after all three parts.

View Examples Gallery Continue to Program 16

Pro Tips

💡 Best Practices

✅ Do

Structure each row as left / stars / right
Use stars = 2 * (top - i) for an even center
Call println only after all three parts
Validate 1 <= rows <= 26 for interactive programs
State O(n²) via n rows × 2n characters

❌ Don’t

Skip the mirrored right half
Use a non-doubled star count for this shape
Break the line between the three parts
Print the left half in reverse
Allow rows > 26 without a clear policy

Summary

Key Takeaways

Knowledge Unlocked

Five things to remember about this alphabet pattern

Print the symmetric star-center pattern the beginner-friendly way.

Core concepts

△ 01

Rule

Left | stars | right

Definition

↻ 02

Outer loop

End letter top→A

Code

* 03

Star gap

2*(top-i) stars

Code

↵ 04

println

After all three parts

I/O

O 05

Complexity

O(n²) time

Analysis

❓ Frequently Asked Questions

Why does the first row contain two E letters in the middle?

The left half prints A..E, and the right half prints E..A. When there are zero stars on the first row, E appears as the last character of the left half and the first character of the right half.

How many stars are printed on each row?

Stars per row are 2*(top - end). For top=E: 0, 2, 4, 6, 8 stars as end goes E, D, C, B, A.

Why is the star count always even?

Because it is computed as 2*(top - i), which is always a multiple of 2.

Can I remove the duplicate middle letter?

Yes. You can start the right half from (char)(i - 1) instead of i when there are zero stars, so the first row becomes ABCDEDCBA.

What is the difference between print and println?

System.out.print stays on the same line. System.out.println ends the current line. Letters and stars use print; the row break uses println after all three parts.

What is the time complexity?

O(n²) for n rows. Each row prints a total of 2n characters (letters + stars), repeated across n rows.

Can I use String.repeat for the center?

Yes. System.out.print("*".repeat(stars)) prints the whole gap in one call (Java 11+). Nested star loops are fine for learning; String.repeat is a handy shortcut later.

How should I read the row count safely?

Check sc.hasNextInt() before sc.nextInt() and clamp rows between 1 and 26 so bad input does not throw InputMismatchException or walk past Z.

Did you Know? 🔊

Each row is: ascending letters from A to the row end, then 2*(top - end) stars, then descending letters back to A. The middle letter appears twice when star count is 0, producing ABCDEEDCBA on the first row. Total width stays constant at 2n characters per row.

Continue to Alphabet Pattern 16

Next up: a centered alphabet pyramid with leading spaces and a running letter counter.

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

Java Alphabet Pattern 14 — Odd-Length Triangle Java Alphabet Pattern 16 — Centered Pyramid

Symmetric Alphabet, Star Center in Java

What You’ll Learn

Shape Rule

Outer Loop

Three Parts

Fixed Width

Live Preview

O(n²)

Introduction

Why it matters?

Three Segments

Even Star Gap

Constant Width

Double Middle

📝 Problem & Approach

Inputs & Outputs

Minimal workflow

Approach comparison

⚡ Quick Reference

📋 print vs Stars vs Mirror

When This Pattern Shows Up

After simpler triangles

Center-gap drills

Symmetry checks

Gateway to Program 16

Not a UI layout tool

🔮 Live Preview

Examples Gallery

📚 Getting Started

Example 1 — Fixed top = 'E'

How It Works

📈 Practical Variant

Example 2 — User Input Version

How It Works

⚡ Shortcut Style

Example 3 — "*".repeat(stars)

How It Works

🧠 How the Algorithm Prints Rows

Set up

Outer loop (end letter)

Left + stars

Mirror + break

Pattern complete

🔎 Worked Walkthrough — top = 'E'

Use Cases

1. Multi-Part Rows

2. Fixed-Width Shapes

3. Mirror Practice

4. Fill-Character Variants

5. Complexity Intuition

6. Input Validation Labs

Advantages

1. Instant Visual Feedback

2. Composable Skills

3. Easy to Customize

4. Clear Complexity Story

Usage Tips

1. Name the Three Parts

2. Prefer hasNextInt()

3. Keep println Last

4. Use Even Star Counts

5. Dry-Run One Small n

Common Pitfalls

1. Forgetting the Mirror Half

2. Wrong Star Formula

3. println Too Early

4. Blind nextInt()

5. Reversing the Left Half

Edge Cases

Single doubled letter

Empty pattern

Doubled peak

Past Z

Non-numeric input

Not only *

🎯 Practice Problems

1. Single middle letter

2. Change the fill

3. Safe input loop

4. Continue to Program 16

Example 1 — Fixed `top = 'E'`

Example 3 — `"*".repeat(stars)`

🔎 Worked Walkthrough — `top = 'E'`

2. Prefer `hasNextInt()`

Not only `*`