A rotating alphabet pattern reprints the same letter set each row, starting one letter further along and wrapping earlier letters in reverse so every line stays the same length.
Remember
Rule: for start i, print i..top, then reverse wrap of A..(i-1)
ABCDE
BCDEA
CDEBA
DECBA
EDCBA ← top = 'E' (5 letters each row)
Not a pure left rotation: after BCDEA you get CDEBA (reverse wrap), not CDEAB. Print k - 1 on the wrap loop so the row-start letter is not duplicated.
Approach
How to Solve It
Two ways to emit the same rows — nested index/char loops, then optionally a suffix + reverse-prefix rewrite.
Method
Idea
Best for
Forward + wrap
Print i..top, then wrap with k - 1
Learning, interviews, exams
String slice
Suffix from i + reverse of prefix
Readable rewrite once the idea clicks
Pseudocode
Pseudocode
for i from 'A' to top:
for j from i to top:
print j
for k from i down to 'B':
print (k - 1)
print newline
for (int j = i; j <= 4; j++) Console.Write(alpha[j]);
Reverse wrap
for (int k = i; k > 0; k--) Console.Write(alpha[k - 1]);
End the row
Console.WriteLine();
Row length
top - 'A' + 1 (same on every row)
Avoid double start
Print k - 1, not k, on the wrap loop
Write vs WriteLine
API
Effect
Use for
Console.Write
Stays on the same line
Each letter on forward and wrap
Console.WriteLine
Ends the current line
After both inner loops
Try it
Live Preview
Change the top letter and the rotating rows update instantly — every line stays the same length.
One letter from A to F. Tap a chip or type a letter — the preview redraws as you go.
Live resultTop E · 5 rows · 5 letters/row
ABCDE
BCDEA
CDEBA
DECBA
EDCBA
Trace
Worked Walkthrough — A–E
Trace each row’s forward run, reverse wrap, and full line.
i
Forward
Wrap (rev)
Printed row
0 (A)
ABCDE
(empty)
ABCDE
1 (B)
BCDE
A
BCDEA
2 (C)
CDE
BA
CDEBA
3 (D)
DE
CBA
DECBA
4 (E)
E
DCBA
EDCBA
Every row length is 5. Note the wrap is the reverse of the prefix — row 3 is CDEBA, not CDEAB.
Code
C# Programs
Three complete programs: fixed A–E, top-letter input, and a string-slice rewrite. Use View Output to reveal sample results.
Example 1 — Fixed A–E
Forward run i..E plus wrap run using k - 1.
C#
using System;
class Program
{
static void Main()
{
char[] alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray();
for (int i = 0; i <= 4; i++)
{
for (int j = i; j <= 4; j++)
Console.Write(alpha[j]);
for (int k = i; k > 0; k--)
Console.Write(alpha[k - 1]);
Console.WriteLine();
}
}
}
Output
ABCDE
BCDEA
CDEBA
DECBA
EDCBA
How It Works
1. Index the alphabet.alpha[0] is A, alpha[4] is E.
2. Outer loop picks the start.i runs from 0 to 4 — one start letter per row.
3. Forward run. Print alpha[j] from i through 4.
4. Reverse wrap. Count k down from i and print alpha[k - 1] so the start letter is not repeated.
When i = 2 (letter C), forward prints CDE and wrap prints BA → CDEBA.
Example 2 — Top Letter Input
Same forward + wrap rules with character loops. Prefer validating a single A–Z character in real apps.
C#
using System;
class Program
{
static void Main()
{
Console.Write("Enter top letter (like E): ");
char top = Convert.ToChar(Console.ReadLine());
for (char i = 'A'; i <= top; i++)
{
for (char j = i; j <= top; j++)
Console.Write(j);
for (char k = i; k > 'A'; k--)
Console.Write((char)(k - 1));
Console.WriteLine();
}
}
}
Output (when user enters D)
Enter top letter (like E): D
ABCD
BCDA
CDBA
DCBA
How It Works
1. Prompt and read. Ask for a top letter, then convert the line to a char.
2. Same wing rules. Forward is i..top; wrap uses (char)(k - 1) so the join stays clean.
3. Safer input tip. Prefer:
Safer input
string raw = (Console.ReadLine() ?? "").Trim().ToUpperInvariant();
if (raw.Length != 1 || raw[0] < 'A' || raw[0] > 'Z')
{
Console.WriteLine("Enter one letter from A to Z.");
return;
}
char top = raw[0];
Example 3 — String Slice Rewrite
Often clearer to read: take the suffix from the start index, then append the reverse of the prefix.
C#
using System;
class Program
{
static void Main()
{
string letters = "ABCDE";
for (int i = 0; i < letters.Length; i++)
{
string forward = letters.Substring(i);
char[] prefix = letters.Substring(0, i).ToCharArray();
Array.Reverse(prefix);
Console.WriteLine(forward + new string(prefix));
}
}
}
Output
ABCDE
BCDEA
CDEBA
DECBA
EDCBA
How It Works
1. Slice the suffix.letters.Substring(i) is the forward run from the start index.
2. Reverse the prefix. Letters before i are reversed and appended — same wrap as Examples 1–2.
3. One WriteLine. Concatenate and print the full row in a single call.
For i = 2, forward is CDE and reversed prefix is BA → CDEBA.
Edge Cases & Pitfalls
Check these before calling the solution done.
Print k
Duplicate start letter
If the wrap loop prints k instead of k - 1, rows like BCDE B repeat the start. Always use k - 1.
Forward wrap
Pure left rotation
Appending the prefix in order gives CDEAB, not CDEBA. This pattern reverses the wrap.
WriteLine inside
Column of letters
If WriteLine is inside either inner loop, each letter lands on its own line. Use Write for letters; WriteLine only after both loops.
top = A
Single letter
Output is just A — wrap never runs. A good sanity check.
top < A
Empty output
Outer loop never runs if top < 'A'. Validate A–Z before looping.
Bad input
Validate one letter
Trim, uppercase, and require length 1 in A–Z — reject empty or multi-character lines.
Analysis
Time and Space Complexity
Program
Time
Extra space
Forward + wrap (Examples 1–2)
O(n²)
O(1) (plus the fixed alphabet table)
String slice (Example 3)
O(n²)
O(n) per temporary row string
For n = top - 'A' + 1 letters, each of n rows prints n characters — still quadratic in n.
Remember
Key Takeaways
Rule: for start i, print i..top, then reverse wrap of A..(i-1).
No duplicate start: wrap with k - 1, not k.
Break the row: call WriteLine only after both loops.
Complexity:O(n²) time; O(1) extra space for nested loops.
One line: for each start i, print i..top, then the reverse of A..(i-1), then WriteLine().
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²).
Read a line, trim it, require a single A–Z character (or ToUpperInvariant), and reject empty or multi-character input.
Yes. Index into "ABCDEFG..." or build each row with substring + 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.
