An inverted V-shaped alphabet pattern prints a single tip letter at the top, then matching letter pairs that drift farther apart on each lower row.
Remember
Rule: left print when i == j; right print when i == k
(right scan starts at B so tip A stays alone)
A
B B
C C
D D
E E ← A–E (width 9)
Geometry matches the hollow inverted V in Star Pattern 7, but cells print letters instead of *. Stack a mirrored lower half in Program 34 to close a full alphabet diamond.
Approach
How to Solve It
Two ways to emit the same outline — start with if/else legs, then optionally share a cell helper.
Method
Idea
Best for
If/else legs
Left j and right k scans; letter when indices match
Learning, interviews, exams
Helper + ternary
One cell(row, col) used by both legs
Less duplication once the diagonals click
Pseudocode
Pseudocode
n = endLetter - 'A' // 4 when end is 'E'
for i from 0 to n:
for j from n down to 0:
print alpha[j] if i == j else " "
for k from 1 to n:
print alpha[k] if i == k else " "
print newline
Append cells without a newline, then end the row once.
Try it
Live Preview
Change the end letter and the inverted V updates instantly — including width and letter count.
One letter from A to Z. Width is 2 * (end - 'A') + 1.
Live resultA–E · 5 rows · 9 letters
A
B B
C C
D D
E E
Trace
Worked Walkthrough — A–D (n = 3)
Trace where each letter lands for every outer-loop value of i (line width = 7).
i
Left (j)
Right (k)
Letters
Printed row
0 (A)
j == 0 → A
none (k starts at 1)
1
A
1 (B)
j == 1 → B
k == 1 → B
2
B B
2 (C)
j == 2 → C
k == 2 → C
2
C C
3 (D)
j == 3 → D
k == 3 → D
2
D D
Row 0 is the only single-letter line — that is why the right loop must not start at k = 0. Total letters: 1 + 2 + 2 + 2 = 7 = 2×3 + 1.
Code
JavaScript Programs
Three complete programs: fixed A–E, end-letter prompt, and a reusable cell helper. Use View Output or Try It Yourself to explore.
Example 1 — Fixed A–E
Hard-coded range — left scan j = 4..0, right scan k = 1..4, letter when indices match.
JavaScript
const alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
for (let i = 0; i <= 4; i++) {
let line = "";
for (let j = 4; j >= 0; j--) {
if (i === j)
line += alpha[j];
else
line += " ";
}
for (let k = 1; k <= 4; k++) {
if (i === k)
line += alpha[k];
else
line += " ";
}
console.log(line);
}
2. Outer loop picks the row.i runs from 0 (tip A) to 4 (widest E pair).
3. Left diagonal.j counts from 4 down to 0; append alpha[j] only when i === j.
4. Right diagonal, then break.k runs from 1 to 4 with the same match rule, then console.log(line).
When i = 0 only the left loop prints; when i = 4 both outer columns print E.
Example 2 — End Letter Input
Read the end letter and scale both scans with n = end - 'A'. Prefer validating a single A–Z character in real apps.
JavaScript
const raw = (prompt("Enter end letter (like E):") || "").trim().toUpperCase();
const end = raw[0];
const n = end.charCodeAt(0) - 65;
const alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
for (let i = 0; i <= n; i++) {
let line = "";
for (let j = n; j >= 0; j--)
line += i === j ? alpha[j] : " ";
for (let k = 1; k <= n; k++)
line += i === k ? alpha[k] : " ";
console.log(line);
}
1. Prompt and normalize. Read a string, trim it, and take the first character as uppercase.
2. Scale the scans. For end = C, n = 2 — width 5, tip still a single A.
3. Safer input tip. Bare [0] fails on empty input. Prefer:
Safer input
const raw = (prompt("Enter end letter (like E):") || "").trim().toUpperCase();
if (raw.length !== 1 || raw < "A" || raw > "Z") {
console.log("Enter a single letter A–Z.");
} else {
const end = raw;
// … build pattern with n = end.charCodeAt(0) - 65
}
Example 3 — Helper Function
Extract one cell printer so both diagonal loops stay thin.
JavaScript
function cell(alpha, row, col) {
return row === col ? alpha[col] : " ";
}
const n = 4;
const alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
for (let i = 0; i <= n; i++) {
let line = "";
for (let j = n; j >= 0; j--)
line += cell(alpha, i, j);
for (let k = 1; k <= n; k++)
line += cell(alpha, i, k);
console.log(line);
}
1. One cell rule.cell owns the row === col decision and the space fallback.
2. Same bounds. Left still counts down from n; right still starts at 1.
3. Same shape, less copy-paste. Learn the expanded if/else first (Example 1), then refactor when the diagonals feel familiar.
Edge Cases & Pitfalls
Check these before calling the solution done.
k = 0
Duplicate tip A
Starting the right loop at k = 0 prints two As on the first row. Keep k = 1.
j ascending
Mirrored left leg
The left loop must count j from n down to 0. Ascending j flips the left diagonal.
log inside
Broken outline
If console.log is inside either inner loop, each cell lands on its own line. Append with +=; call console.log only after both loops.
end = A
Single tip
Output is just A — right loop never runs. A good sanity check.
Proportional font
Looks skewed in the IDE
Spaces and letters need a monospace font. Proportional fonts make diagonals look uneven.
Bad input
Validate one letter
Empty strings and multi-character input break naive [0] indexing — require a single A–Z character.
Analysis
Time and Space Complexity
Program
Time
Extra space
If/else legs (Examples 1–2)
O(n²)
O(1) beyond the alphabet string
Helper function (Example 3)
O(n²)
O(1) beyond the alphabet string
About n + 1 rows × 2n + 1 characters printed per row — still quadratic in n. Total letters = 2n + 1 (one tip + two per later row).
Remember
Key Takeaways
Rule: append alpha[col] only when row === col; otherwise a space.
Two legs: left j counts down from n; right k starts at 1.
Break the row: call console.log(line) only after both inner loops.
Complexity:O(n²) time; O(1) extra space beyond the alphabet string.
One line: for each row i, append a letter only when the left or right column index matches i — start the right loop at 1.
Frequently Asked Questions
Because the right block starts from index 1 (letter B), so it never matches i equals 0. Only the left block prints A on the first row.
Width is 2n+1: n+1 columns from the left block and n columns from the right block. For A–E, n is 4 and width is 9.
Program 31 is wide at the top and has a single bottom vertex. Program 33 has a single A at the top and widens downward with pairs like B B, C C.
line += appends a letter or space on the same row. console.log(line) ends the current line after both inner loops finish.
O(n²) because there are n+1 rows and each row scans O(n) positions across both blocks.
Spaces keep column alignment so the two diagonals open into a visible inverted V in a monospace console.
Use prompt, trim and toUpperCase, require a single A–Z character, and reject empty or multi-character input.
Program 34 reuses this inverted-V row logic for A..E, then mirrors D..A downward to close a full diamond without repeating the widest E row.
🤔
Did you know?
This inverted V is the upper half of the alphabet diamond. Starting the right loop at k = 1 (letter B) is deliberate: on row 0 the left loop already prints the tip A, so visiting index 0 again would duplicate it.
