A V-shaped alphabet pattern prints letters only on two diagonals that meet at a single tip, with spaces everywhere else so the shape reads as a V in a monospace console.
Remember
Rule: left 0..n when i==j; right n−1..0 when i==k
A A
B B
C C
D D
E ← tip once (end = 'E')
The right scan starts at n − 1 (not n) so the tip letter prints once. Compare with Program 33 (inverted V) and Program 32 (solid palindrome pyramid).
Approach
How to Solve It
Two ways to emit the same V — inline diagonal checks, or a shared PrintCell helper.
Method
Idea
Best for
Two scans inline
Left 0..n, right n−1..0, print when row == col
Learning, interviews, exams
PrintCell helper
One method owns the diagonal rule for both legs
Cleaner demos once the tip skip clicks
Pseudocode
Pseudocode
n = end - 'A'
for i from 0 to n:
for j from 0 to n:
print (i == j ? alpha[j] : ' ')
for k from n - 1 down to 0:
print (i == k ? alpha[k] : ' ')
print newline
for (int k = n - 1; k >= 0; k--) Write(i == k ? alpha[k] : ' ');
Single tip
Right scan starts at n − 1, not n
Width
(n + 1) + n = 2n + 1
Spaces matter
Non-hits print ' ' to keep columns aligned
Write vs WriteLine
API
Effect
Use for
Console.Write
Stays on the same line
Each letter or space cell
Console.WriteLine
Ends the current line
After both scans finish a row
Try it
Live Preview
Change the end letter and the V updates instantly — width is always 2n + 1, with a single tip on the last row.
One letter from A to F. Tap a chip or type a letter — use a monospace view for alignment.
Live resultEnd E · 5 rows · width 9
A A
B B
C C
D D
E
Trace
Worked Walkthrough — End = E (n = 4)
Trace each row’s diagonal hits and the resulting 9-column line.
i
Left hit
Right hit
Printed row
0
A at j=0
A at k=0
A A
1
B at j=1
B at k=1
B B
2
C at j=2
C at k=2
C C
3
D at j=3
D at k=3
D D
4
E at j=4
(none)
E
Width is always 2×4 + 1 = 9. The tip row has no right-leg match because k never equals 4.
Code
C# Programs
Three complete programs: fixed A–E, end-letter input, and a helper-method rewrite. Use View Output to reveal sample results.
Example 1 — Fixed A–E
Two scans per row: left-to-right (A..E) and right-to-left (D..A). Letters print only when the row matches the column.
C#
using System;
class Program
{
static void Main()
{
char[] alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray();
for (int i = 0; i <= 4; i++)
{
for (int j = 0; j <= 4; j++)
{
if (i == j) Console.Write(alpha[j]);
else Console.Write(" ");
}
for (int k = 3; k >= 0; k--)
{
if (i == k) Console.Write(alpha[k]);
else Console.Write(" ");
}
Console.WriteLine();
}
}
}
Output
A A
B B
C C
D D
E
How It Works
1. Outer loop picks the row.i runs from 0 to 4 (letters A…E).
2. Left leg — main diagonal. Scan j = 0..4; print the letter only when i == j, else a space.
3. Right leg — mirrored diagonal. Scan k = 3..0; print when i == k. Starting at 3 skips a second tip.
4. Tip row. When i = 4, only the left scan can print E.
Example 2 — End Letter Input
The right scan starts at end − 1 so the vertex prints once. 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): ");
char end = Convert.ToChar(Console.ReadLine());
int n = end - 'A';
char[] alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray();
for (int i = 0; i <= n; i++)
{
for (int j = 0; j <= n; j++)
Console.Write(i == j ? alpha[j] : ' ');
for (int k = n - 1; k >= 0; k--)
Console.Write(i == k ? alpha[k] : ' ');
Console.WriteLine();
}
}
}
Output (when user enters C)
Enter end letter (like E): C
A A
B B
C
How It Works
1. Scale with n.n = end - 'A' drives both scans. For end = C, width is 2×2 + 1 = 5.
2. Same tip rule. Right loop still starts at n − 1 so the tip is a single letter.
3. Safer input tip. Prefer:
Safer input
string raw = (Console.ReadLine() ?? "").Trim().ToUpperInvariant();
if (raw.Length != 1 || raw[0] < 'A' || raw[0] > 'Z')
{
Console.WriteLine("Enter one letter from A to Z.");
return;
}
char end = raw[0];
Example 3 — Helper Method
Often clearer: one method applies the diagonal rule so left and right 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 = 0; j <= n; j++)
PrintCell(alpha, i, j);
for (int k = n - 1; k >= 0; k--)
PrintCell(alpha, i, k);
Console.WriteLine();
}
}
}
Output
A A
B B
C C
D D
E
How It Works
1. PrintCell owns the rule.row == col lives in one place for both legs.
2. Tip still skipped on the right. The right loop starts at n − 1 even with the helper.
Edge Cases & Pitfalls
Check these before calling the solution done.
k = n
Double tip
If the right scan includes index n, the last row prints the tip twice. Keep for (k = n - 1; k >= 0; k--).
No spaces
Collapsed V
Writing only letters (no spaces) packs both legs together. Non-hits must print ' '.
WriteLine inside
Column of cells
If WriteLine is inside either scan, each cell lands on its own line. Use Write for cells; WriteLine only after both scans.
end = A
Single A
When n = 0, left prints A and the right loop never runs. A good sanity check.
Wrong compare
Off-diagonal letters
Always compare the row index to the current column (i == j / i == k), not to a fixed letter.
Bad input
Validate one letter
Trim, uppercase, and require length 1 in A–Z — reject empty or multi-character lines.
Analysis
Time and Space Complexity
Program
Time
Extra space
Two scans inline (Examples 1–2)
O(n²)
O(1) (plus the fixed alphabet table)
Helper method (Example 3)
O(n²)
O(1)
For letters A..end there are n + 1 rows and each row scans 2n + 1 cells — quadratic in n.
Remember
Key Takeaways
Rule: print a letter only when row index equals column index.
Single tip: right scan starts at n − 1, not n.
Spaces keep the V: non-hits print ' '; break the row with WriteLine after both scans.
Complexity:O(n²) time; O(1) extra space.
One line: for each row, scan left 0..n and right n−1..0, printing a letter only on the diagonal.
Frequently Asked Questions
If the right scan included E, the last row would print E twice (one on each side), breaking the single vertex at the bottom tip of the V.
For n = end − 'A', the left block is n+1 columns and the right block is n columns, so total width is 2n+1 (9 for A..E).
Usually two (one per leg), except the bottom row prints one letter because the right loop cannot match the tip index.
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 form a visible 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.
Yes. Set n = end − 'A', scan j from 0 to n on the left, and scan k from n−1 down to 0 on the right.
Program 20 also practices diagonal alignment with letters; this page focuses on a V made from two opposing diagonal scans that meet at one vertex.
🤔
Did you know?
Outer i is the row index (A..E). Left scan prints only when i == j (main diagonal). Right scan runs from D down to A so the bottom vertex letter (E) appears once.
