An odd-length alphabet triangle reprints A..end on every row, while end jumps by two letters each time — so widths are always 1, 3, 5, 7, …
Remember
Rule: end letter steps A, C, E, …; each row prints A..end
A
ABC
ABCDE
ABCDEFG
ABCDEFGHI ← 5 rows (ends A,C,E,G,I)
Unlike Program 13 (one running cursor across the whole triangle), every row here restarts at A and grows to a farther odd-step ending letter.
Approach
How to Solve It
Step the end letter by two, then print the fresh prefix A..end on each row.
Method
Idea
Best for
Char step += 2
Outer i walks A, C, E, …; inner prints A..i
Learning, interviews, fixed demos
Row index
end = 'A' + 2*(row-1)
When the user enters a row count
Pseudocode
Pseudocode
for i from 'A' to lastEnd step 2:
for j from 'A' to i:
print j (no newline)
print newline
Cheat sheet
Goal
Pattern
Step the end letter
for (char i = 'A'; i <= 'I'; i += 2)
Print the prefix
for (char j = 'A'; j <= i; j++) System.out.print(j);
End the row
System.out.println();
Row-count form
end = (char)('A' + 2 * (row - 1));
Java compound assign
i += 2 works on char (plain i = i + 2 needs a cast)
A–Y-safe height
Max 13 rows (end reaches Y)
Printing Letters vs Starting a New Line
API
Effect
Use for
System.out.print
Stays on the same line
Each letter on the row
System.out.println
Ends the current line
After the inner loop
Print characters without a newline, then end the row once.
Try it
Live Preview
Change the row count and the odd-length triangle updates instantly — including end letter and letter totals.
Whole numbers from 1 to 13. Row r ends at letter A + 2*(r-1) (A–Y).
Live result5 rows · ends I · 25 letters
A
ABC
ABCDE
ABCDEFG
ABCDEFGHI
Trace
Worked Walkthrough — rows = 4
Trace each end letter and the prefix printed from A through that end.
Row
End i
Inner j
Printed row
Count
1
A
A..A
A
1
2
C
A..C
ABC
3
3
E
A..E
ABCDE
5
4
G
A..G
ABCDEFG
7
Total letters: 1 + 3 + 5 + 7 = 16 = 4². That square sum is why time is O(r²).
Code
Java Programs
Three complete programs: fixed through I, ending-letter input, and a row-count form. Use View Output to reveal sample results.
Example 1 — Fixed through 'I'
Hard-coded ending letter — ideal for first demos and screenshots.
Java
public class OddLengthTriangle {
public static void main(String[] args) {
for (char i = 'A'; i <= 'I'; i += 2) {
for (char j = 'A'; j <= i; j++) {
System.out.print(j);
}
System.out.println();
}
}
}
Output
A
ABC
ABCDE
ABCDEFG
ABCDEFGHI
How It Works
1. Outer loop steps the end.i takes A, C, E, G, I via i += 2.
2. Inner loop restarts at A. For each i, print every letter from A through i.
3. Break the line.println() after the inner loop starts the next longer prefix.
In Java, compound assignment i += 2 works on char (plain i = i + 2 needs a cast).
Example 2 — Ending Letter Input
Read an odd-step ending letter (A, C, E, …). Prefer validating a single A–Z character in real apps.
Java
import java.util.Scanner;
public class OddLengthInput {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Enter the ending letter (odd step like I): ");
char end = sc.next().charAt(0);
for (char i = 'A'; i <= end; i += 2) {
for (char j = 'A'; j <= i; j++) {
System.out.print(j);
}
System.out.println();
}
sc.close();
}
}
Output (when user enters E)
Enter the ending letter (odd step like I): E
A
ABC
ABCDE
How It Works
1. Prompt and read. Take the first character of the next token into end.
2. Same nested-loop core. Only the outer upper bound changes — the print logic matches Example 1.
3. Safer input tip. Prefer a single uppercase letter and an odd step from A:
Safer input
String raw = sc.next().trim();
if (raw.length() != 1 || raw.charAt(0) < 'A' || raw.charAt(0) > 'Z'
|| ((raw.charAt(0) - 'A') % 2) != 0) {
System.out.println("Enter one odd-step letter A, C, E, …, Y.");
return;
}
char end = raw.charAt(0);
Example 3 — end = 'A' + 2*(row-1)
Drive the pattern from a row count instead of an ending letter.
Java
public class OddLengthRows {
public static void main(String[] args) {
int rows = 5;
for (int row = 1; row <= rows; row++) {
char end = (char)('A' + 2 * (row - 1));
for (char j = 'A'; j <= end; j++) {
System.out.print(j);
}
System.out.println();
}
}
}
Output
A
ABC
ABCDE
ABCDEFG
ABCDEFGHI
How It Works
1. Map row → end. Row 1 ends at A+0, row 2 at A+2, row 3 at A+4, and so on.
2. Print the prefix. Inner loop still walks A..end on every row.
3. Stay in A–Y. Clamp rows to 1–13 so end never walks past Y.
Edge Cases & Pitfalls
Check these before calling the solution done.
i++
Even lengths
If the outer loop uses i++ instead of i += 2, you get A, AB, ABC, … — not the odd-length pattern.
Inner starts at i
Missing prefix
Always start the inner loop at 'A'. Starting at i prints a single letter per row.
println inside
Column of letters
If println sits inside the inner loop, each letter lands on its own line. Call it only after the inner loop.
Even end letter
Messy last row
Prefer odd-step endings (A, C, E, …, Y). An even letter like D still runs but breaks the clean odd-width story.
rows = 1
Single A
Output is just A — a good sanity check.
Past Y
Clamp to 13 rows
Row 13 ends at Y. Larger values walk past Z — clamp or stop early.
Analysis
Time and Space Complexity
Program
Time
Extra space
Char step / row-count forms
O(rows²)
O(1)
Total letters printed = 1 + 3 + … + (2r - 1) = r², which is quadratic in the number of rows.
Remember
Key Takeaways
Odd ends: outer letter steps A, C, E, … with += 2.
Fresh prefix: every row prints A..end from scratch.
Break the row:print for letters; println after the inner loop.
Complexity:O(r²) time because total letters equal r²; O(1) extra space.
One line: for each end letter stepping by two, print A..end, then println.
Frequently Asked Questions
It makes the ending letter jump by two (A, C, E, ...) so each row length increases by two characters and stays odd.
The outer loop advances the ending letter by 2 (A, C, E, G, I). The inner loop prints every letter from A through that ending letter, so the count is always odd.
Because each row is a fresh prefix A..end. Starting at the end letter would skip earlier letters and change the pattern.
System.out.print stays on the same line. System.out.println ends the current line. Letters use print; the row break uses println after the inner loop.
1+3+…+(2r-1)=r². For 5 rows that is 25 letters.
O(r²) for r rows, because total System.out.print calls equal r².
The loop still runs, but you no longer get a clean set of odd-length rows aligned to A, C, E, …. Prefer an odd-step ending letter (A, C, E, …, Y) for this pattern.
Prefer reading a row count with hasNextInt(), or validate a single letter from next()/charAt(0), and keep the ending letter within A–Z.
🤔
Did you know?
Odd numbers add up to perfect squares: 1+3+5+…+(2r-1)=r². That is why this pattern prints exactly r² letters for r rows — the same count that makes the complexity O(r²).
