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 PrintCell(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
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
C# Programs
Three complete programs: fixed A–E, end-letter input, and a reusable cell helper. Use View Output to reveal sample results.
Example 1 — Fixed A–E
Hard-coded range — left scan j = 4..0, right scan k = 1..4, letter when indices match.
C#
using System;
class Program
{
static void Main()
{
char[] alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray();
for (int i = 0; i <= 4; i++)
{
for (int j = 4; j >= 0; j--)
{
if (i == j)
Console.Write(alpha[j]);
else
Console.Write(" ");
}
for (int k = 1; k <= 4; k++)
{
if (i == k)
Console.Write(alpha[k]);
else
Console.Write(" ");
}
Console.WriteLine();
}
}
}
Output
A
B B
C C
D D
E E
How It Works
1. Alphabet table.alpha[0] is A, alpha[4] is E.
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; print alpha[j] only when i == j.
4. Right diagonal, then break.k runs from 1 to 4 with the same match rule, then WriteLine.
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.
C#
using System;
class Program
{
static void Main()
{
Console.Write("Enter end letter (like E): ");
string line = Console.ReadLine();
char end = char.ToUpperInvariant(line.Trim()[0]);
int n = end - 'A';
char[] alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray();
for (int i = 0; i <= n; i++)
{
for (int j = n; j >= 0; j--)
Console.Write(i == j ? alpha[j] : ' ');
for (int k = 1; k <= n; k++)
Console.Write(i == k ? alpha[k] : ' ');
Console.WriteLine();
}
}
}
Output (when user enters C)
Enter end letter (like E): C
A
B B
C C
How It Works
1. Prompt and normalize. Read a line, 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] throws on empty input. Prefer:
Safer input
string line = (Console.ReadLine() ?? "").Trim();
if (line.Length != 1 || !char.IsLetter(line[0]))
{
Console.WriteLine("Enter a single letter A–Z.");
return;
}
char end = char.ToUpperInvariant(line[0]);
if (end < 'A' || end > 'Z')
{
Console.WriteLine("Enter a single letter A–Z.");
return;
}
Example 3 — Helper Method
Extract one cell printer so both diagonal loops stay thin.
C#
using System;
class Program
{
static void PrintCell(char[] alpha, int row, int col)
{
Console.Write(row == col ? alpha[col] : ' ');
}
static void Main()
{
int n = 4;
char[] alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray();
for (int i = 0; i <= n; i++)
{
for (int j = n; j >= 0; j--)
PrintCell(alpha, i, j);
for (int k = 1; k <= n; k++)
PrintCell(alpha, i, k);
Console.WriteLine();
}
}
}
Output
A
B B
C C
D D
E E
How It Works
1. One cell rule.PrintCell 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.
WriteLine inside
Broken outline
If WriteLine is inside either inner loop, each cell lands on its own line. Use Write for cells; WriteLine 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 lines 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 array
Helper method (Example 3)
O(n²)
O(1) beyond the alphabet array
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: print 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 WriteLine only after both inner loops.
Complexity:O(n²) time; O(1) extra space beyond the alphabet table.
One line: for each row i, print 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.
Console.Write stays on the same line. Console.WriteLine ends the current line. Letters and spaces use Write; the row break uses WriteLine after both inner loops.
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.
Read a line, trim it, require a single A–Z character (or ToUpperInvariant), 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.
