A hollow diamond star pattern prints only the outline of a diamond: spaces fill the interior, and stars sit on the diagonals. Half-height rows means 2 * rows - 1 printed lines.
Remember
Rule: upper i = 1..rows, then lower i = rows-1..1
On each row, print "*" where j == i or k == i
*
* *
* *
* *
* *
* *
* *
* *
* ← rows = 5 (9 lines)
Build it by stacking Program 7 (upper hollow V) and Program 8 (lower hollow V), starting the second outer loop at rows - 1 so the waist prints once.
Approach
How to Solve It
Print one hollow row with two inner loops, then call that idea twice — ascending, then descending past the waist.
Method
Idea
Best for
Dual outer loops
Upper 1..rows, lower rows-1..1, same j/k bodies
Learning, interviews, clearest stack of P7 + P8
Helper + ternary
One printRow(i, rows) called from both halves
Less duplication once the geometry clicks
Pseudocode
Pseudocode
printHollowRow(i, rows):
for j from rows down to 1:
print "*" if i == j else " "
for k from 2 to rows:
print "*" if i == k else " "
print newline
for i from 1 to rows: // upper half
printHollowRow(i, rows)
for i from rows - 1 down to 1: // lower half (skip waist)
printHollowRow(i, rows)
Three complete programs: fixed half-height, Scanner input, and a reusable row helper. Use View Output to reveal sample results.
Example 1 — Fixed rows = 5
Upper i = 1..rows, lower i = rows-1..1, same j/k bodies.
Java
public class HollowDiamond {
public static void main(String[] args) {
int rows = 5;
// Upper half: i = 1 .. rows
for (int i = 1; i <= rows; i++) {
for (int j = rows; j >= 1; j--) {
if (i == j)
System.out.print("*");
else
System.out.print(" ");
}
for (int k = 2; k <= rows; k++) {
if (i == k)
System.out.print("*");
else
System.out.print(" ");
}
System.out.println();
}
// Lower half: skip duplicate waist
for (int i = rows - 1; i >= 1; i--) {
for (int j = rows; j >= 1; j--) {
if (i == j)
System.out.print("*");
else
System.out.print(" ");
}
for (int k = 2; k <= rows; k++) {
if (i == k)
System.out.print("*");
else
System.out.print(" ");
}
System.out.println();
}
}
}
Output
*
* *
* *
* *
* *
* *
* *
* *
*
How It Works
1. Set half-height.rows = 5 means 5 upper lines and 4 lower lines (9 total).
2. Upper half grows outward.i runs from 1 to rows. Left loop j and right loop k print * only when they equal i.
3. Lower half mirrors without a second waist.i runs from rows - 1 down to 1 with the same inner logic.
4. Break the line.System.out.println() after both inner loops starts the next outline row.
Example 2 — User Input Version
Read the half-height at runtime with Scanner. Prefer hasNextInt() in real apps (shown in the tip below).
Java
import java.util.Scanner;
public class HollowDiamondInput {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Enter the number of rows: ");
int rows = sc.nextInt();
for (int i = 1; i <= rows; i++) {
for (int j = rows; j >= 1; j--)
System.out.print(i == j ? "*" : " ");
for (int k = 2; k <= rows; k++)
System.out.print(i == k ? "*" : " ");
System.out.println();
}
for (int i = rows - 1; i >= 1; i--) {
for (int j = rows; j >= 1; j--)
System.out.print(i == j ? "*" : " ");
for (int k = 2; k <= rows; k++)
System.out.print(i == k ? "*" : " ");
System.out.println();
}
}
}
Output (when user enters 4)
Enter the number of rows: 4
*
* *
* *
* *
* *
* *
*
How It Works
1. Prompt and read. Ask for a half-height, then store it with sc.nextInt().
2. Same dual-half core. Only the source of rows changes — the print logic matches Example 1 (ternaries shorten the if/else).
if (!sc.hasNextInt()) {
System.out.println("Enter a positive whole number.");
return;
}
int rows = sc.nextInt();
if (rows < 1) {
System.out.println("Enter a positive whole number.");
return;
}
Example 3 — Helper Method
Extract one row printer so the diamond reads as “upper, then lower.”
Java
public class HollowDiamondHelper {
static void printRow(int i, int rows) {
for (int j = rows; j >= 1; j--)
System.out.print(i == j ? "*" : " ");
for (int k = 2; k <= rows; k++)
System.out.print(i == k ? "*" : " ");
System.out.println();
}
public static void main(String[] args) {
int rows = 5;
for (int i = 1; i <= rows; i++)
printRow(i, rows);
for (int i = rows - 1; i >= 1; i--)
printRow(i, rows);
}
}
Output
*
* *
* *
* *
* *
* *
* *
* *
*
How It Works
1. One row recipe.printRow owns the j/k diagonal logic and the row break.
2. Call it twice. Upper half walks i up; lower half walks i down from rows - 1.
3. Same shape, less copy-paste. Learn the expanded loops first (Example 1), then refactor when the geometry feels familiar.
Edge Cases & Pitfalls
Check these before calling the solution done.
Lower starts at rows
Double waist
If the second outer loop starts at i = rows, the widest line prints twice. Use rows - 1.
k from 1
Extra center column
Right loop must start at k = 2. Starting at 1 overlaps the left half’s last column and skews the diamond.
println inside
Broken outline
If println sits inside j or k, the outline collapses into a column. Call it only after both inner loops.
Proportional font
Looks skewed in the IDE
Spaces and stars need a monospace font (console default is fine). Proportional fonts make diagonals look uneven.
rows = 1
Single star
Upper prints one line; lower never runs. Output is just * — a good sanity check.
rows ≤ 0
Empty output
Neither outer loop runs. Validate and re-prompt for interactive programs.
Bad input
Use hasNextInt()
nextInt() throws on letters — prefer sc.hasNextInt() and require rows >= 1.
Analysis
Time and Space Complexity
Program
Time
Extra space
Dual loops (Examples 1–2)
O(rows²)
O(1)
Helper method (Example 3)
O(rows²)
O(1)
Lines printed = 2n - 1. Each line walks about 2n - 1 positions across the two inner loops, so work is still quadratic in n. Outline stars grow as 4(n - 1) for n ≥ 2 (and 1 when n = 1).
Remember
Key Takeaways
Compose halves: upper 1..rows then lower rows-1..1 — Programs 7 + 8 with one seam fix.
Diagonal rule: star only when i == j or i == k; everything else is a space.
Break the row: call println only after both inner loops.
Complexity:O(n²) time; O(1) extra space.
One line: print hollow rows for i = 1..rows, then again for i = rows-1..1, starring only the diagonals.
Frequently Asked Questions
Two sequential outer loops share the same inner structure. The first runs i from 1 to rows (upper half). The second runs i from rows minus 1 down to 1 (lower half). On each row, j and k print stars when they equal i.
The first part already prints the widest row when i equals rows. Starting the second part at rows again would duplicate that waist line. rows minus 1 mirrors the upper half without a double middle.
Yes, by mapping a loop index to an effective row i or by branching on upper vs lower half. Splitting into two loops matches Programs 7 and 8 mentally and keeps each block easy to read.
rows + (rows - 1) = 2 * rows - 1 lines. Each line is also 2 * rows - 1 characters wide.
System.out.print stays on the same line. System.out.println ends the current line. Stars and spaces use print; the row break uses println after both inner loops.
With n rows, about 2n - 1 printed lines, each with Theta(n) work across two inner loops, giving O(n²).
Program 9 draws only the outline (hollow). Program 10 fills every star in a solid diamond using spaces and 2*i-1 star runs.
Check sc.hasNextInt() before sc.nextInt() so bad input does not throw InputMismatchException.
🤔
Did you know?
This hollow diamond is a direct composition: Program 7’s upper half plus Program 8’s lower half with the duplicate middle row removed by starting the second phase at rows - 1. Total printed lines = 2 * rows - 1.
