Display an ASCII diamond with nested for loops

Question

I am trying to display a diamond of asterisks using nested for loops.

Here is my code so far:

public class Diamond {
    public static void main(String[] args) {
        int size = 9;
        for (int i = 1; i <= size; i += 2) {
            for (int k = size; k >= i; k -= 2) {
                System.out.print(" ");
            }
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }// end loop

        for (int i = 1; i <= size; i += 2) {
            for (int k = 1; k <= i; k += 2) {
                System.out.print(" ");
            }
            for (int j = size; j >= i; j--) {
                System.out.print("*");
            }
            System.out.println();
        }// end loop
    }
}

This is close, but I'm printing the line of 9 asterisks twice.

How can I adjust the second for loop to start the output at 7 asterisks and 2 spaces?

Answer 1

In your first for loop remove = mark and just use < e.g.

for (int i = 1; i < size; i += 2)

Full code:

int size = 9;

for (int i = 1; i < size; i += 2) {
    for (int k = size; k >= i; k -= 2) {
        System.out.print(" ");
    }
    for (int j = 1; j <= i; j++) {
        System.out.print("*");
    }
    System.out.println();
}// end loop

for (int i = 1; i <= size; i += 2) {
    for (int k = 1; k <= i; k += 2) {
        System.out.print(" ");
    }
    for (int j = size; j >= i; j--) {
        System.out.print("*");
    }
    System.out.println();
}// end loop

Output:

     *
    ***
   *****
  *******
 *********
  *******
   *****
    ***
     *

Answer 2

java-11

By using String#repeat, introduced as part of Java-11, you can do it with a single loop.

public class Main {
    public static void main(String[] args) {
        int size = 9;
        int midRowNum = size / 2 + 1;
        for (int i = 1 - midRowNum; i < midRowNum; i++) {
            System.out.println(" ".repeat(Math.abs(i)) + "*".repeat((midRowNum - Math.abs(i)) * 2 - 1));
        }
    }
}

Output:

    *
   ***
  *****
 *******
*********
 *******
  *****
   ***
    *

By increasing the amount of space by one character, you can also print a variant of the diamond:

public class Main {
    public static void main(String[] args) {
        int size = 9;
        int midRowNum = size / 2 + 1;
        for (int i = 1 - midRowNum; i < midRowNum; i++) {
            System.out.println("  ".repeat(Math.abs(i)) + "* ".repeat((midRowNum - Math.abs(i)) * 2 - 1));
        }
    }
}

Output:

        * 
      * * * 
    * * * * * 
  * * * * * * * 
* * * * * * * * * 
  * * * * * * * 
    * * * * * 
      * * * 
        * 

Answer 3

int n = 9;
for (int i = 0; i < n; i++) {
    for (int k = n - 1; k > i; k--) {
        System.out.print(" ");
    }
    for (int j = 0; j < 2 * i + 1; j++) {
        System.out.print("*");
    }
    System.out.println("");
}
for (int j = 0; j < n - 1; j++) {
    for (int k = j; k >= 0; k--) {
        System.out.print(" ");
    }
    for (int i = 2 * (n - j - 1) - 1; i > 0; i--) {
        System.out.print("*");
    }
    System.out.println("");
}

Output:

        *
       ***
      *****
     *******
    *********
   ***********
  *************
 ***************
*****************
 ***************
  *************
   ***********
    *********
     *******
      *****
       ***
        *

Answer 4

Just for fun... :) try my code....

public class Diamond {
    static String sp(int n) {
        String s = "";
        for (int i = 0; i < n; i++)
            s += " ";
        return s;
    }

    static String st(int n) {
        String s = "";
        for (int i = 0; i < n; i++)
            s += "*";
        return s;
    }

    static int abs(int n) {
        if (n < 0)
            return -n;
        else
            return n;
    }

    public static void main(String[] args) {
        int size = 9;
        for (int i = 0; i < size; i++) {
            System.out.println(sp(abs((size - 1) / 2 - i)) +
                    st(abs(9 - 2 * ((i + 5) % (size)))) +
                    sp(abs((size - 1) / 2 - i)));
        }
    }
}

Output:

    *    
   ***   
  *****  
 ******* 
*********
 ******* 
  *****  
   ***   
    *    

Answer 5

Try this code. Using Math.abs will be a lot simple.

import java.util.Scanner;

public class MakeDiamond {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("Let's Creat Diamonds");
            System.out.println("If number increases Diamonds gets bigger. " +
                    "Please input number lager than 1 : ");

            int user_input = sc.nextInt(); //gets user's input
            System.out.println("");

            int x = user_input;
            int front_space = -5;
            for (int i = 0; i < 2 * user_input + 1; i++) {
                for (int a = front_space; a < Math.abs(i - user_input); a++) {
                    System.out.print("    ");
                }

                if (i < user_input + 1) {
                    for (int b = 0; b < 2 * i + 1; b++) {
                        System.out.print("*  ");
                    }

                } else if (i > user_input) {
                    for (int c = 0; c < 2 * x - 1; c++) {
                        System.out.print("*  ");
                    }
                    x--;
                }
                System.out.print('\n');
            }

            System.out.println("\nRun Again? 1 = Run,  2 = Exit : ");

            int restart = sc.nextInt();
            System.out.println("");
            if (restart == 2) {
                System.out.println("Exit the Program.");
                System.exit(0);
                sc.close();
            }
        }
    }
}

Answer 6

You can print a diamond of asterisks (mathematical operators) with for loops:

int m = 4;
int n = 4;
for (int i = -m; i <= m; i++) {
    for (int j = -n; j <= n; j++) {
        int val = Math.abs(i) + Math.abs(j);
        System.out.print(val > Math.max(m, n) ? " " : "∗");
        if (j < n) {
            System.out.print(" ");
        } else {
            System.out.println();
        }
    }
}

Output:

        ∗        
      ∗ ∗ ∗      
    ∗ ∗ ∗ ∗ ∗    
  ∗ ∗ ∗ ∗ ∗ ∗ ∗  
∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗
  ∗ ∗ ∗ ∗ ∗ ∗ ∗  
    ∗ ∗ ∗ ∗ ∗    
      ∗ ∗ ∗      
        ∗        

---

You can create a 2d array with a diamond of asterisks using IntStreams:

int m = 4;
int n = 4;
String[][] arr = IntStream.rangeClosed(-m, m)
        .mapToObj(i -> IntStream.rangeClosed(-n, n)
                .map(j -> Math.abs(i) + Math.abs(j))
                .mapToObj(j -> j > Math.max(m, n) ? " " : "∗")
                .toArray(String[]::new))
        .toArray(String[][]::new);

// formatted output
Arrays.stream(arr)
        .map(row -> Arrays.stream(row)
                .collect(Collectors.joining(" ", "[ ", " ]")))
        .forEach(System.out::println);

[         ∗         ]
[       ∗ ∗ ∗       ]
[     ∗ ∗ ∗ ∗ ∗     ]
[   ∗ ∗ ∗ ∗ ∗ ∗ ∗   ]
[ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ]
[   ∗ ∗ ∗ ∗ ∗ ∗ ∗   ]
[     ∗ ∗ ∗ ∗ ∗     ]
[       ∗ ∗ ∗       ]
[         ∗         ]

---

^{See also:
• Empty diamond shape with numbers
• Filling a 2d array with numbers in a rhombus form}

Answer 7

You can use two nested for loops and one if else statement as follows:

public static void main(String[] args) {
    int n = 5;
    for (int i = -n; i <= n; i++) {
        for (int j = -n; j <= n; j++)
            if (Math.abs(i) + Math.abs(j) <= n
                    // in chessboard order
                    && (i + j) % 2 != 0)
                System.out.print("*");
            else
                System.out.print(" ");
        System.out.println();
    }
}

Output:

     *     
    * *    
   * * *   
  * * * *  
 * * * * * 
* * * * * *
 * * * * * 
  * * * *  
   * * *   
    * *    
     *     

Answer 8

Try this code:

I have changed the first loop:

for (int i = 1; i <= size-1; i += 2) {

---

int size = 9;

for (int i = 1; i <= size - 1; i += 2) {
    for (int k = size; k >= i; k -= 2) {
        System.out.print(" ");
    }
    for (int j = 1; j <= i; j++) {
        System.out.print("*");
    }
    System.out.println();
}// end loop

for (int i = 1; i <= size; i += 2) {
    for (int k = 1; k <= i; k += 2) {
        System.out.print(" ");
    }
    for (int j = size; j >= i; j--) {
        System.out.print("*");
    }
    System.out.println();
}// end loop

Answer 9

This code is working fine. Just you need to remove one extra line which is repeating twice...

class Diamond {
    public static void main(String[] args) {
        int size = 9;
        for (int i = 1; i <= size; i += 2) {
            for (int k = size; k >= i; k -= 2) {
                System.out.print(" ");
            }
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }// end loop

        for (int i = 1; i <= size; i += 2) {
            for (int k = 1; k <= i + 2; k += 2) { // I made change here
                System.out.print(" ");
            }
            for (int j = size - 2; j >= i; j--) { // I made change here
                System.out.print("*");
            }
            System.out.println();
        }// end loop
    }
}

Output:

     *
    ***
   *****
  *******
 *********
  *******
   *****
    ***
     *
      

Answer 10

Another answer for fun, to try out JDK16 records. Rather than loop over the different indexes in a row, this Diamond shape uses Math.abs in simple declaration:

public record Diamond(int midx, int midy, int size) implements Shape {
    public int right() { return midx + size; }
    public int top()   { return midy + size; }

    /** Check if shape is drawn at this x,y position */
    public boolean intersects(int x, int y) {
        return Math.abs(midx-x) + Math.abs(midy-y) <= size;
    }
}

Add interface for all Shape classes and a general purpose draw to print out asterisks for any intersecting shape:

public interface Shape {
    /** Check if shape is drawn at this x,y position */
    boolean intersects(int x, int y);

    /** Max X position used by this shape */
    int right();
    /** Max Y position used by this shape */
    int top();

    /** Draw a series of shapes */
    public static void draw(Shape ... shapes) {
        // Work out largest X, Y coordinates (and print the shape list):
        int ymax = Arrays.stream(shapes).peek(System.out::println)
                                        .mapToInt(Shape::top  ).max().getAsInt();
        int xmax = Arrays.stream(shapes).mapToInt(Shape::right).max().getAsInt();
        System.out.println();

        // Visit all X,Y and see what will be printed
        for (int y = ymax ; y > 0; y--) {
            for (int x = 1 ; x <= xmax; x++) {
                boolean hit = false;
                for (int i = 0; !hit && i < shapes.length; i++) {
                    hit = shapes[i].intersects(x,y);
                }
                System.out.print(hit ? "*" : " ");
            }
            System.out.println();
        }
        System.out.println();
    }
}

... and a main to draw as many shapes as you wish - it is easy to define new ASCII art Shape classes:

public static void main(String[] args) {
    Shape.draw(new Diamond(10, 7, 5));
    Shape.draw(new Diamond(10, 7, 3), new Diamond(17, 5, 3), new Diamond(22, 8, 1));
}

This prints:

Diamond[midx=10, midy=7, size=5]

         *     
        ***    
       *****   
      *******  
     ********* 
    ***********
     ********* 
      *******  
       *****   
        ***    
         *     
               

Diamond[midx=8, midy=7, size=5]
Diamond[midx=17, midy=5, size=3]
Diamond[midx=22, midy=8, size=1]

       *               
      ***              
     *****             
    *******          * 
   *********    *   ***
  ***********  ***   * 
   *********  *****    
    *******  *******   
     *****    *****    
      ***      ***     
       *        *      
                       

---

^{See also: Draw two ASCII spruce trees of specific heights}