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 print_cell helper.
Method
Idea
Best for
Two scans inline
Left 0..n, right n−1..0, print when row == col
Learning, interviews, exams
print_cell helper
One function 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
Cheat sheet
Goal
Pattern
End index
int n = end - 'A'; (4 for E)
Rows
for (i = 0; i <= n; i++)
Left leg
for (j = 0; j <= n; j++) printf("%c", i == j ? alpha[j] : ' ');
Right leg
for (k = n - 1; k >= 0; k--) printf("%c", 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
Printing Letters vs Starting a New Line
API
Effect
Use for
printf("%c", ...)
Stays on the same line
Each letter or space cell
printf("\n")
Ends the current line
After both scans finish a row
putchar(ch)
Same as printing one character
Optional leaner style once loops click
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 with scanf, and a helper-function 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
#include <stdio.h>
int main(void) {
char alpha[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
int i, j, k;
for (i = 0; i <= 4; i++) {
for (j = 0; j <= 4; j++) {
if (i == j)
printf("%c", alpha[j]);
else
printf(" ");
}
for (k = 3; k >= 0; k--) {
if (i == k)
printf("%c", alpha[k]);
else
printf(" ");
}
printf("\n");
}
return 0;
}
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. Check scanf and validate a single A–Z character in real apps.
c
#include <stdio.h>
int main(void) {
char alpha[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
char end;
int n, i, j, k;
printf("Enter end letter (like E): ");
scanf(" %c", &end);
n = end - 'A';
for (i = 0; i <= n; i++) {
for (j = 0; j <= n; j++)
printf("%c", i == j ? alpha[j] : ' ');
for (k = n - 1; k >= 0; k--)
printf("%c", i == k ? alpha[k] : ' ');
printf("\n");
}
return 0;
}
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
if (scanf(" %c", &end) != 1 || end < 'A' || end > 'Z') {
printf("Enter one letter from A to Z.\n");
return 1;
}
Example 3 — Helper Function
Often clearer: one function applies the diagonal rule so left and right loops stay thin.
c
#include <stdio.h>
void print_cell(char alpha[], int row, int col) {
printf("%c", row == col ? alpha[col] : ' ');
}
int main(void) {
char alpha[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
int n = 4;
int i, j, k;
for (i = 0; i <= n; i++) {
for (j = 0; j <= n; j++)
print_cell(alpha, i, j);
for (k = n - 1; k >= 0; k--)
print_cell(alpha, i, k);
printf("\n");
}
return 0;
}
Output
A A
B B
C C
D D
E
How It Works
1. print_cell 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 ' '.
printf("\n") inside
Column of cells
If printf("\n") is inside either scan, each cell lands on its own line. Print cells with %c; break the line 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.
scanf
Leading space in format
Use scanf(" %c", &end) so a leftover newline does not become your letter. Still validate A–Z.
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 function (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 printf("\n") 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.
Check scanf(" %c", &end) == 1, require a single A–Z character (optionally toupper), and reject invalid 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.
