Rotating Alphabet Pattern in Java

Beginner
⏱️ 8 min read
📚 Updated: Aug 2026
🎯 3 Code Examples
🚀 Live Preview
Nested Loops
Rotating alphabet rows ABCDE BCDEA CDEBA DECBA EDCBA in Java programming
Overview

What You’ll Learn

Each row is a cyclic-style rotation of the same set of letters: print from the row start to E, then wrap by printing the earlier letters in reverse (without duplicating the boundary letter). This output uses adjacent letters (no spaces), matching the reference. Compare Program 25 (shrinking sequential stream) and Program 18 (palindrome halves). Includes a live preview, worked Java examples, edge cases, and complexity.

Shape Rule

Fixed length

ABCDE, BCDEA, CDEBA, … EDCBA.

Forward

Start..top

First loop prints from row start through E.

Wrap

k - 1

Earlier letters in reverse; no boundary duplicate.

Same Width

n letters

Every row prints top - A + 1 characters.

Live Preview

Top letter

Pick a top letter (A–F) and draw the rotations.

O(n²)

Complexity

n rows × n letters each.

Introduction

A rotating alphabet pattern prints fixed-length rows that start one letter later each time, completing each line by wrapping earlier letters in reverse.

In Java you solve it with nested loops (or string slices): a forward run to the top letter, then a wrap run that uses k - 1 so the join does not duplicate the row start.

Why it matters?

It teaches wrap-around indexing and how to join two ranges without a duplicated boundary — useful for rotations and circular buffers.

Key Highlights

Forward

Print start through top.

Wrap

Earlier letters in reverse.

k - 1

Avoids a duplicated join.

Fixed n

Every row has the same length.

In short: for each start i, print i..top, then print earlier letters via k-1 while counting down, then call println().

Foundation

📝 Problem & Approach

Given a top letter (or fixed E), print n fixed-length rotating rows from A through that top letter.

Java
// Five rows (adjacent letters; fixed length 5)
// ABCDE
// BCDEA
// CDEBA
// DECBA
// EDCBA

Inputs & Outputs

ItemTypeDescription
topcharLast letter in the set (e.g. E). Row count = top - 'A' + 1.
Printed outputtextn rows of n adjacent letters each (forward + reverse wrap).

Minimal workflow

Pseudocode
for i from 0 to n-1:          // or 'A'..top
    for j from i to n-1:      // forward to top
        print letter[j]
    for k from i down to 1:   // wrap earlier letters
        print letter[k - 1]
    print newline

Approach comparison

ApproachIdeaBest for
Char array + indexesalpha[j] forward; alpha[k-1] wrapMatching this classic sample
Char loopsj = i..top; wrap with (char)(k-1)User-chosen top letter
String slice + reversesuffix + reverse(prefix)Readable rewrite (Example 3)
Cheat Sheet

⚡ Quick Reference

GoalPattern
Alphabet sourcechar[] alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray();
Rowsfor (int i = 0; i <= 4; i++) (A..E)
Forwardfor (int j = i; j <= 4; j++) System.out.print(alpha[j]);
Wrapfor (int k = i; k > 0; k--) System.out.print(alpha[k - 1]);
Shrinking streamSee Program 25
Compare

📋 Forward vs Wrap vs println

Same row — three roles that build the rotation.

j = i..top
forward

Letters from row start through the top

alpha[k-1]
wrap

Earlier letters in reverse; no duplicate start

Fixed length
n

Forward + wrap always totals n letters

System.out.println
break

Ends the row after both loops

Context

When This Pattern Shows Up

Reach for this when teaching wrap-around joins and fixed-length rotations.

  1. After sequential streams

    Switch from continuous k++ fills to fixed-width rotations.

  2. Boundary-join drills

    Practice k-1 so the wrap does not repeat the start letter.

  3. Index vs char loops

    Same shape with array indexes or direct char ranges.

  4. String rotation labs

    Rewrite with suffix + reverse(prefix) for clarity.

  5. Not a UI layout tool

    This is a console teaching pattern — not how you build modern app screens.

Key benefit: printing k-1 on the wrap loop is the cleanest way to finish each row without duplicating the boundary letter.

Interactive

🔮 Live Preview

Choose a top letter from A to F and draw the rotating alphabet pattern in the browser.

Try E (classic sample) or D (four rows). Preview allows A–F.

Live result
Press "Draw pattern".
Hands-On

Examples Gallery

Three complete Java programs — fixed A–E with a char array, user-chosen top letter, and a string slice rewrite. Click View Output to reveal sample console results.

📚 Getting Started

Print five fixed-length rotating rows from A through E.

Example 1 — Fixed A–E

Forward run i..E plus wrap run using k - 1.

Java
public class RotatingAlphabet {
    public static void main(String[] args) {
        char[] alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray();

        for (int i = 0; i <= 4; i++) {
            for (int j = i; j <= 4; j++)
                System.out.print(alpha[j]);

            for (int k = i; k > 0; k--)
                System.out.print(alpha[k - 1]);

            System.out.println();
        }
    }
}

How It Works

When i = 2 (letter C), forward prints CDE and wrap prints BA via alpha[k-1] → CDEBA. Using k instead of k-1 would wrongly start the wrap with C again.

📈 Practical Variant

Let the user choose how many letters to rotate (A..top).

Example 2 — Top Letter Input

This version uses character loops directly. Prefer validating a single A–Z character from next()/charAt(0) in real apps.

Java
import java.util.Scanner;

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

        System.out.print("Enter top letter (like E): ");
        char top = sc.next().toUpperCase().charAt(0);

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

            for (char k = i; k > 'A'; k--)
                System.out.print((char)(k - 1));

            System.out.println();
        }

        sc.close();
    }
}

How It Works

Same forward + wrap rules; only the shared top letter changes. Wrap uses (char)(k - 1) so the join stays clean.

⚡ String Style

Same shape with substring + reverse of the prefix.

Example 3 — String Slice Rewrite

Often clearer to read: take the suffix from the start index, then append the reverse of the prefix.

Java
public class RotatingAlphabetString {
    public static void main(String[] args) {
        String letters = "ABCDE";

        for (int i = 0; i < letters.length(); i++) {
            String forward = letters.substring(i);
            String prefix = new StringBuilder(letters.substring(0, i)).reverse().toString();

            System.out.println(forward + prefix);
        }
    }
}

How It Works

For i = 2, forward is CDE and reversed prefix is BA → CDEBA. Same visual result as the nested-loop versions.

🧠 How the Algorithm Prints Rows

1

Row start index

i is the row start (0..4), which corresponds to letters A..E.

Start
2

Forward part

Print alpha[i] through alpha[4] (or i..top with char loops).

Forward
3

Wrap part without duplication

Count down from k = i and print alpha[k-1]. This appends earlier letters (like A) but doesn’t repeat the row start.

Wrap
4

New line

System.out.println() ends the row so the next start index can rotate again.

Break
=

Same length each row

Each row prints 5 letters, so total output is O(n²) for n letters.

Trace

🔎 Worked Walkthrough — A–E

Trace each row’s forward run, reverse wrap, and full line.

iForwardWrap (rev)Printed row
0 (A)ABCDE(empty)ABCDE
1 (B)BCDEABCDEA
2 (C)CDEBACDEBA
3 (D)DECBADECBA
4 (E)EDCBAEDCBA

Every row length is 5. Note the wrap is reverse of the prefix (so row 3 is CDEBA, not CDEAB).

Use Cases

Where this rotating alphabet pattern shows up beyond the homework prompt.

1. Wrap-Join Labs

Clearest demo of finishing a row without duplicating the start letter.

Example: print k instead of k-1 and watch the bug.

2. Pair with Program 25

Fixed-length rotations vs shrinking continuous streams.

Example: print both for n = 5 side by side.

3. Index Practice

Outer and inner loops over array indexes into the alphabet.

Example: rewrite with char loops (Example 2).

4. String Slice Rewrite

Teach suffix + reverse(prefix) (Example 3).

Example: compare nested loops vs string build.

5. Complexity Intuition

Fixed n letters per row make O(n²) easy to see.

Example: 5 rows × 5 letters = 25 prints.

6. Bridge to Program 27

Next pattern returns to right-aligned growing prefixes.

Example: continue to Program 27.

Pro Tip: say “forward to the end, then reverse the earlier letters with k-1” before coding — that story prevents a duplicated boundary.

Advantages

Why this pattern earns a spot after sequential shrinking triangles.

  1. 1. Instant Visual Feedback

    A duplicated join or wrong wrap order shows up immediately.

  2. 2. Multiple Clear Rewrites

    Array indexes, char loops, or string slices teach the same shape.

  3. 3. Wrap Practice

    A natural place to learn circular-style joins.

  4. 4. Predictable Length

    Every row has the same width, so tracing stays simple.

Pro Tip: learn the classic nested-loop version first; treat the string-slice rewrite as a clarity upgrade afterward.

Usage Tips

Small habits that keep rotating alphabet patterns clean.

  1. 1. Always Use k - 1 on Wrap

    That single offset is what prevents a duplicated boundary letter.

  2. 2. Keep Row Length Constant

    Forward + wrap must total top - A + 1 each row.

  3. 3. Validate Top Letter Input

    Require a single A–Z character; normalize case if needed.

  4. 4. Know It Is Not Pure Left Rotation

    Wrap is reverse of the prefix — expect CDEBA, not CDEAB.

  5. 5. Prefer Adjacent Letters for the Sample

    Spaces are optional for teaching; the reference has none.

Pro Tip: if you see BCDEB or CDEBC, the wrap loop almost certainly printed k instead of k - 1.

Common Pitfalls

Mistakes that commonly break rotating alphabet patterns.

  1. 1. Printing k Instead of k - 1

    Duplicates the boundary letter at the wrap join.

    → Always print alpha[k - 1] (or (char)(k - 1)).

  2. 2. Expecting Pure Left Rotations

    You may expect CDEAB but this sample produces CDEBA.

    → Remember the wrap is reverse of the prefix.

  3. 3. Off-by-One on the Outer Bound

    Using i < 4 instead of i <= 4 drops the last row.

    → For A..E indexes, loop 0..4 inclusive.

  4. 4. Blind charAt(0)

    Empty lines or multi-character input throw or take only the first char.

    → Validate a single A–Z letter after trimming.

  5. 5. Confusing with Program 25

    Using k++ and shrinking lengths builds a different pattern.

    → Keep fixed row length with forward + wrap loops.

Edge Cases

Check these inputs before calling the solution done.

top = A

Single letter

Output is just A (wrap empty).

top = E

Classic sample

Five rows through EDCBA.

top = D

Smaller set

Four rows (Example 2).

Lowercase

Case mismatch

Normalize with toUpperCase() if needed.

Bad input

Empty / multi-char

Validate before charAt(0).

top < A

Invalid range

Reject non A–Z tops so loops do not misbehave.

Drill

🎯 Practice Problems

Try these variations to lock in the pattern.

1. Pure left rotation

  • Build BCDEA, CDEAB, DEABC, EABCD
  • Compare with this reverse-wrap sample

2. String slice version

  • Use suffix + reverse(prefix) (Example 3)
  • Confirm output matches the loops

3. Add spaces

  • Print a space between letters
  • Keep the same forward + wrap logic

4. Continue to Program 27

Important

Notes

  • Forward + wrap. Print start..top, then earlier letters via k-1 in reverse.
  • Never print k on the wrap loop for this sample — it duplicates the boundary.
  • Every row has fixed length n = top - A + 1.
  • Unlike Program 25, there is no running k++ stream across shrinking rows.

Quick Takeaway: for each start, print forward to the top, wrap earlier letters with k-1, then break the line.

Analysis

⏱️ Time and Space Complexity

ProgramTimeExtra space
Array / char loops (Examples 1–2)O(n²)O(1) (plus alphabet source)
String slice (Example 3)O(n²)O(n) per row for temporary strings

For n letters, each of n rows prints n characters, so total work is O(n²).

Wrap Up

🎉 Conclusion

The rotating alphabet pattern is a small nested-loop exercise with lasting payoff: fixed-length rows, a forward run, and a reverse wrap joined without a duplicated boundary. Master the classic ABCDE…EDCBA sample, then try user input and the string-slice rewrite.

Practice the three examples above, then continue to Program 27’s right-aligned alphabet pyramid.

Print forward to the top, wrap with k-1, keep fixed row length, then break the line.

View Examples Gallery Continue to Program 27
Pro Tips

💡 Best Practices

✅ Do

  • Print wrap letters with k - 1
  • Keep every row the same length
  • Validate a single A–Z top letter for input variants
  • Trace forward + reverse wrap separately
  • State O(n²) when asked about complexity

❌ Don’t

  • Print k on the wrap loop
  • Assume pure left rotations (CDEAB)
  • Drop the last row with an exclusive outer bound
  • Confuse this with Program 25’s shrinking stream
  • Call println inside the forward or wrap loop
Summary

Key Takeaways

Knowledge Unlocked

Five things to remember about this alphabet pattern

Print the rotating alphabet pattern the beginner-friendly way.

5
Core concepts
▷ 01

Rule

Forward + wrap

Definition
-1 02

Wrap

Use k - 1

Code
n 03

Length

Fixed per row

Code
↵ 04

println

Ends each row

I/O
O 05

Complexity

O(n²) time

Analysis
🎯 You’re ready to print a rotating alphabet pattern in Java
Review Quick Reference →

❓ Frequently Asked Questions

The first loop prints from the row start through E (or your top letter). The second prints the letters before the start (wrapping) in reverse using k-1 so the boundary letter is not duplicated.
When k equals i, printing k would repeat the first letter of the row. Printing k-1 starts the wrap with the previous letter (e.g. BCDE then A gives BCDEA).
Each row prints from the row start to the end, then prints earlier letters in reverse to complete the row. That creates the rotation effect.
Yes. Forward length plus wrap length equals E-A+1, so each row has the same number of letters.
Not exactly. A pure left rotation of ABCDE would give BCDEA, CDEAB, DEABC, EABCD. This pattern wraps earlier letters in reverse, so you get CDEBA, DECBA, EDCBA.
For n letters, each of n rows prints n characters, so O(n²).
Use Scanner next(), take charAt(0) after toUpperCase(), require A–Z, and reject empty or multi-character tokens.
Yes. Index into "ABCDEFG..." or build each row with substring + StringBuilder.reverse() of the prefix — Example 3 shows a string-based rewrite.

Did you Know? 🔊

Outer i is the row start. First inner loop prints i through E. Second inner loop wraps by counting down from i and printing k - 1 (not k) so the boundary letter isn’t duplicated. Every row prints the same length: E - A + 1 letters.

Continue to Alphabet Pattern 27

Next up: right-aligned alphabet pyramids (A, A B, A B C, …).

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

Java Alphabet Pattern 25 — Sequential Decreasing Java Alphabet Pattern 27 — Right-Aligned Pyramid