A diamond alphabet with stars widens then shrinks: each row repeats one letter with * between copies (B*B, C*C*C), mirrored so the widest middle row appears only once.
Remember
Rule: odd j → row letter; even j → '*'; upper 1..n then lower n-1..1
A
B*B
C*C*C
D*D*D*D
E*E*E*E*E
D*D*D*D
C*C*C
B*B
A ← half height n = 5
Unlike Program 15 (stars filling a center gap between alphabet wings), here one letter owns the whole row and stars sit between letter copies.
Approach
How to Solve It
Print an upper half that grows, then a lower half that shrinks from n-1, alternating letter and star by column index.
One method owns the letter/* run; halves only choose i
Less duplication, cleaner structure
Pseudocode
Pseudocode
for i from 1 to n:
ch = 'A' + i - 1
for j from 1 to 2*i - 1:
print '*' if j is even else ch
print newline
for i from n - 1 down to 1:
(same inner loop)
Cheat sheet
Goal
Pattern
Upper half
for (int i = 1; i <= n; i++)
Lower half
for (int i = n - 1; i >= 1; i--)
Odd width
for (int j = 1; j < i * 2; j++) → 2i-1 chars
Alternation
Console.Write(j % 2 == 0 ? "*" : ch.ToString());
Row letter
char ch = (char)('A' + i - 1);
End the row
Console.WriteLine();
A–Z-safe height
Clamp n to 1–26
Write vs WriteLine
API
Effect
Use for
Console.Write
Stays on the same line
Each letter and each star
Console.WriteLine
Ends the current line
After the alternating run
Try it
Live Preview
Change the half height and the diamond updates instantly — including middle letter and total rows.
Whole numbers from 1 to 8. Total rows = 2n - 1; middle letter is A + n - 1.
Live resultn = 5 · middle E · 9 rows
A
B*B
C*C*C
D*D*D*D
E*E*E*E*E
D*D*D*D
C*C*C
B*B
A
Trace
Worked Walkthrough — n = 3
Trace each row height, the letter, the odd-width run, and where the mirror starts.
Half
i
Letter
Width
Printed row
Upper
1
A
1
A
Upper
2
B
3
B*B
Upper
3
C
5
C*C*C
Lower
2
B
3
B*B
Lower
1
A
1
A
Lower half starts at n - 1 so C*C*C is not printed twice. Width formula: 2i - 1.
Code
C# Programs
Three complete programs: fixed n = 5, half-height input, and a PrintRow helper. Use View Output to reveal sample results.
Example 1 — Fixed Half Height 5
Odd j prints the row letter; even j prints *. Upper half prints 1..5, lower half prints 4..1.
C#
using System;
class Program
{
static void Main()
{
char[] alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray();
for (int i = 1; i <= 5; i++)
{
for (int j = 1; j < i * 2; j++)
{
if (j % 2 == 0)
Console.Write("*");
else
Console.Write(alpha[i - 1]);
}
Console.WriteLine();
}
for (int i = 4; i >= 1; i--)
{
for (int j = 1; j < i * 2; j++)
{
if (j % 2 == 0)
Console.Write("*");
else
Console.Write(alpha[i - 1]);
}
Console.WriteLine();
}
}
}
Output
A
B*B
C*C*C
D*D*D*D
E*E*E*E*E
D*D*D*D
C*C*C
B*B
A
How It Works
1. Upper half grows. Row i uses letter alpha[i - 1] and prints 2i - 1 characters.
2. Alternation. Even j prints *; odd j prints the row letter — so i = 3 becomes C*C*C.
3. Lower half mirrors. Starts at 4 so the widest row E*E*E*E*E appears only once.
Example 2 — Half Height Input
Uses a computed row letter instead of an array. Prefer int.TryParse in real apps.
C#
using System;
class Program
{
static void Main()
{
Console.Write("Enter half height (like 5): ");
int n = int.Parse(Console.ReadLine());
for (int i = 1; i <= n; i++)
{
char ch = (char)('A' + i - 1);
for (int j = 1; j < i * 2; j++)
Console.Write(j % 2 == 0 ? "*" : ch.ToString());
Console.WriteLine();
}
for (int i = n - 1; i >= 1; i--)
{
char ch = (char)('A' + i - 1);
for (int j = 1; j < i * 2; j++)
Console.Write(j % 2 == 0 ? "*" : ch.ToString());
Console.WriteLine();
}
}
}
Output (when user enters 3)
Enter half height (like 5): 3
A
B*B
C*C*C
B*B
A
How It Works
1. Same diamond rules. Only n changes the size — alternation and mirror stay identical.
2. Char from index.'A' + i - 1 replaces the alphabet array lookup.
3. Safer input tip. Prefer TryParse and stay within A–Z:
Safer input
if (!int.TryParse(Console.ReadLine(), out int n) || n < 1 || n > 26)
{
Console.WriteLine("Enter a half height from 1 to 26.");
return;
}
Example 3 — PrintRow Helper
Same diamond, less duplicated code.
C#
using System;
class Program
{
static void PrintRow(int i)
{
char ch = (char)('A' + i - 1);
for (int j = 1; j < i * 2; j++)
Console.Write(j % 2 == 0 ? "*" : ch.ToString());
Console.WriteLine();
}
static void Main()
{
int n = 5;
for (int i = 1; i <= n; i++)
PrintRow(i);
for (int i = n - 1; i >= 1; i--)
PrintRow(i);
}
}
Output
A
B*B
C*C*C
D*D*D*D
E*E*E*E*E
D*D*D*D
C*C*C
B*B
A
How It Works
1. One row printer.PrintRow(i) owns the letter/* alternation and the newline.
2. Halves only choose height. Upper loops 1..n; lower loops n-1..1 — no duplicated inner logic.
3. Easier to change. Want a different separator? Edit one method instead of two loops.
Edge Cases & Pitfalls
Check these before calling the solution done.
Lower from n
Doubled middle
Starting the lower half at n reprints the widest row. Always start at n - 1.
j <= i * 2
Even width
Using j <= i * 2 prints an extra character. Keep j < i * 2 for odd widths 1, 3, 5, …
Swap odd/even
Star first
Printing * on odd j starts each row with a star. Letters belong on odd positions.
n = 1
Single A
Output is just A; the lower half does not run — a good sanity check.
Past Z
Clamp to 26
Half height above 26 walks the middle letter past Z. Cap or reject the input.
Bad parse
int.Parse crash
Prefer int.TryParse so empty or non-numeric input does not throw.
Analysis
Time and Space Complexity
Program
Time
Extra space
Two-loop / helper forms
O(n²)
O(1)
Upper half prints 1 + 3 + … + (2n - 1) = n² characters; the lower half adds almost the same without the middle row — still quadratic in n.
Remember
Key Takeaways
Two halves: grow 1..n, then shrink n-1..1 so the middle is unique.
Odd widths: each row prints 2i - 1 characters via j < i * 2.
Alternation: odd j → letter; even j → *.
Complexity:O(n²) time; O(1) extra space.
One line: for each row height up then down, print letter and * alternating across an odd-width run.
Frequently Asked Questions
j runs 1,2,3,... Odd positions print the row letter and even positions print '*', producing lines like B*B and C*C*C.
The inner loop checks the position: even columns print '*', odd columns print the row letter. That alternates symbols cleanly.
That prints 2*i-1 characters per row (1,3,5,...), which makes the pattern widen toward the center.
The upper half already printed the widest row at i=n. Starting from n-1 mirrors without duplicating the middle row.
Console.Write stays on the same line for each letter or star. Console.WriteLine ends the row after the inner loop finishes.
Program 15 puts stars in the center of a symmetric alphabet row. This pattern repeats one letter per row and places stars between those letters, then mirrors vertically.
O(n²) for half height n because the total printed characters is proportional to 1+3+...+(2n-1) up and down.
Prefer int.TryParse, require n ≥ 1, and cap at 26 so row letters stay within A–Z.
🤔
Did you know?
Upper half prints rows 1..n; lower half prints n-1..1 so the widest row appears once. Each row runs j = 1..(2i-1). Odd j prints the row letter, even j prints *.
