A decreasing alphabet pattern is Program 1 flipped: each row still prints letters forward from A, but row length shrinks from n down to 1.
Rule: for i = n..1, print A .. (A+i-1)
ABCDE
ABCD
ABC
AB
A ← 5 rowsCompare Program 1 (grows A, AB, ABC) and Program 4 (counts down to A: A, BA, CBA). Program 6 keeps full width while the start letter moves forward.
Outer loop shrinks the letter count; inner loop still prints A forward for that many letters.
| Method | Idea | Best for |
|---|---|---|
Nested ord/chr | range(rows, 0, -1) + range(base, base + i) | Learning, interviews, exams |
| String slice | print(letters[:i]) while i shrinks | Compact shortcut once the idea clicks |
base = 'A'
for i from rows down to 1: // letter count
for code from base to base+i-1: // A forward
print code
print newline| Goal | Pattern |
|---|---|
| Shrink rows | for i in range(rows, 0, -1): |
| Print A..length | for code in range(base, base + i): |
| Print letter | print(chr(code), end="") |
| End the row | print() |
| Slice shortcut | print(letters[:i]) |
| vs Program 1 | Same inner loop; outer goes down instead of up |
| vs Program 4 | Here letters ascend; Program 4 descends to A |
| API | Effect | Use for |
|---|---|---|
print(chr(code), end="") | Stays on the same row | Each letter in the ascending run |
print() | Ends the current row | After the inner loop |
Print letters without a newline, then end the row once.
Change the row count and the decreasing pattern updates instantly — first row is always the longest.
rows = 3Outer i walks 3 → 2 → 1. Each row prints A forward for i letters.
i | Inner run | Printed row |
|---|---|---|
3 | A..C | ABC |
2 | A..B | AB |
1 | A..A | A |
Total letters are n+(n-1)+…+1 = n(n+1)/2 → O(n²).
Three complete programs: fixed height, row-count input(), and a slice shortcut. Use View Output for sample results.
rows = 5Outer loop shrinks the length; inner loop prints A forward.
rows = 5
base = ord("A")
for i in range(rows, 0, -1):
for code in range(base, base + i):
print(chr(code), end="")
print()1. Shrink the count. range(rows, 0, -1) yields 5, 4, 3, 2, 1.
2. Print A forward. When i = 5, range(base, base + 5) prints ABCDE; when i = 1, just A.
3. Newline. Bare print() after the inner loop starts the next shorter row.
Read how many rows to print. Cap at 26 so letters stay in A–Z.
raw = input("Enter the number of rows (max 26): ").strip()
try:
rows = int(raw)
except ValueError:
print("Please enter a whole number.")
raise SystemExit(1)
rows = max(1, min(rows, 26))
base = ord("A")
for i in range(rows, 0, -1):
for code in range(base, base + i):
print(chr(code), end="")
print()1. Validate rows. Parse an integer, then clamp to 1..26.
2. Same shrinking core. Four rows start at ABCD and end at A.
letters[:i]Slice the alphabet for each shrinking length — no inner letter loop.
rows = 5
letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
for i in range(rows, 0, -1):
print(letters[:i])1. One slice. letters[:i] is the first i letters (ABCDE when i = 5).
2. Same shape. Identical output to Example 1 — keep the nested-loop version for exams that ask for ord/chr bounds.
Check these before calling the solution done.
range(1, rows + 1)That outer loop is Program 1. Keep range(rows, 0, -1) for the decreasing shape.
range(rows, -1, -1)Including 0 makes an empty last row. Stop at 1 with range(rows, 0, -1).
print() inside the inner loopUse end="" for letters; call bare print() only after the ascending run.
Cap rows at 26 so base + i - 1 stays in A–Z.
Output is just A — a good sanity check.
Catch ValueError from int(...) before the outer loop.
| Program | Time | Extra space |
|---|---|---|
| Nested loops (Examples 1–2) | O(n²) | O(1) |
| Slice shortcut (Example 3) | O(n²) | O(n) per row for the slice string |
There are n rows printing n+(n-1)+…+1 letters, so total work is n(n+1)/2.
i = n..1, print A through the i-th letter.letters[:i] inside a shrinking outer loop.One line: for each length from n down to 1, print A forward that many letters.
Row i prints letters from A through the i-th letter, with i shrinking each row: ABCDE, ABCD, …, A. Total letters for n rows is still n(n+1)/2 — O(n²).
Keep a fixed end letter while the start letter moves forward each row.
12 people found this page helpful