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
range(..., 2)
Outer i walks A, C, E, …; inner prints A..i
Learning, interviews, fixed demos
Row index
end = ord('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 i in range(ord('A'), ord('I') + 1, 2):
Print the prefix
for j in range(ord('A'), i + 1): print(chr(j), end="")
End the row
print()
Row-count form
end = ord('A') + 2 * (row - 1)
One-line row shortcut
print(letters[:2*row-1])
A–Y-safe height
Max 13 rows (end reaches Y)
Printing Letters vs Starting a New Line
API
Effect
Use for
print(ch, end="")
Stays on the same line
Each letter on the row
print()
Ends the current line
After the inner loop
Print letters 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
Python 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.
Python
for i in range(ord('A'), ord('I') + 1, 2):
for j in range(ord('A'), i + 1):
print(chr(j), end="")
print()
Output
A
ABC
ABCDE
ABCDEFG
ABCDEFGHI
How It Works
1. Outer loop steps the end.i takes A, C, E, G, I via range(..., 2).
2. Inner loop restarts at A. For each i, print every letter from A through i.
3. Break the line. Bare print() after the inner loop starts the next longer prefix.
Example 2 — Ending Letter Input
Read an odd-step ending letter (A, C, E, …). Prefer validating a single A–Z character in real apps.
Python
raw = input("Enter the ending letter (odd step like I): ").strip().upper()
if len(raw) != 1 or not ('A' <= raw <= 'Z') or (ord(raw) - ord('A')) % 2 != 0:
print("Enter one odd-step letter A, C, E, …, Y.")
else:
end = ord(raw)
for i in range(ord('A'), end + 1, 2):
for j in range(ord('A'), i + 1):
print(chr(j), end="")
print()
Output (when user enters E)
Enter the ending letter (odd step like I): E
A
ABC
ABCDE
How It Works
1. Prompt and validate. Require one uppercase letter whose offset from A is even (A, C, E, …, Y).
2. Same nested-loop core. Only the outer upper bound changes — the print logic matches Example 1.
3. Reject even ends. Letters like B or D fail the % 2 check so the odd-width story stays clean.
Example 3 — end = ord('A') + 2*(row-1)
Drive the pattern from a row count instead of an ending letter.
Python
rows = 5
for row in range(1, rows + 1):
end = ord('A') + 2 * (row - 1)
for j in range(ord('A'), end + 1):
print(chr(j), end="")
print()
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.
step 1
Even lengths
If the outer loop uses step 1 instead of 2, you get A, AB, ABC, … — not the odd-length pattern.
Inner starts at i
Missing prefix
Always start the inner loop at ord('A'). Starting at i prints a single letter per row.
print early
Column of letters
If bare print() (or default print(chr(j))) sits inside the inner loop, each letter lands on its own line. Use end="" for letters; call print() 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
Step-2 / 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 range(..., 2).
Fresh prefix: every row prints A..end from scratch.
Break the row:end="" for letters; bare print() 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 print().
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.
print(ch, end="") stays on the same line. print() ends the current line. Letters use end=""; the row break uses print() after the inner loop.
1+3+…+(2r-1)=r². For 5 rows that is 25 letters.
O(r²) for r rows, because total printed letters 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 single uppercase letter and checking (ord(end) - ord('A')) % 2 == 0, or read a row count with try/except ValueError and clamp to 1–13.
🤔
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²).
