The challenge

Your task, is to create a NxN spiral with a given size.

For example, spiral with size 5 should look like this:

00000
....0
000.0
0...0
00000

and with the size 10:

0000000000
.........0
00000000.0
0......0.0
0.0000.0.0
0.0..0.0.0
0.0....0.0
0.000000.0
0........0
0000000000

Return value should contain array of arrays, of `` and 1, for example for given size 5 result should be:

1

[[1,1,1,1,1],[0,0,0,0,1],[1,1,1,0,1],[1,0,0,0,1],[1,1,1,1,1]]

Because of the edge-cases for tiny spirals, the size will be at least 5.

General rule-of-a-thumb is, that the snake made with ‘1’ cannot touch to itself.

The solution in Java code

Option 1:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

public class Spiralizor {

    public static int[][] spiralize(int size) {
        if(size <= 0) return null;
        int[][] spiral = new int[size][size]; 
        int minCol = 0;
        int maxCol = size-1;
        int minRow = 0;
        int maxRow = size-1;
        
        for (int i = 0; i < spiral.length; i++) {
            for (int j = 0; j < spiral.length; j++) spiral[i][j] = 0;
        }
        
        while (minRow <= maxRow){
            for (int i = minCol; i <= maxCol; i++) spiral[minRow][i] = 1;
             
            for (int i = minRow; i <= maxRow; i++) spiral[i][maxCol] = 1;
            
            if(minCol != 0) minCol+=1;
            if(maxRow-1 == minRow) break;
            
            for (int i = maxCol-1; i >= minCol; i--) spiral[maxRow][i] = 1;  
            
            for (int i = maxRow-1; i >= minRow+2; i--) spiral[i][minCol] = 1;

            minCol+=1;
            minRow+=2;
            maxCol-=2; 
            maxRow-=2;
        }
        return spiral;
    }
}

Option 2:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public class Spiralizor {
    public static int[][] spiralize(int n) {
      int [][] a = new int[n][n];
      int n4 = n%4==0? 1: 0;
      for (int y = 0, c = 1; y <= n/2; y++) {
        for (int x = y; x < n -y; x++)
          a[y][x] = a[x][n-1 -y] = a[n-1 -y][n-1 -x] = a[n-1 -x][y] = c;
          c = 1-c;
        if (y+n4 < n/2) a[y+1][y] = c;
      }
      return a;
    }
}

Test cases to validate our solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

import org.junit.Test;

import static org.junit.Assert.assertArrayEquals;

public class SpiralizorTests {

    @Test
    public void test5() {
        assertArrayEquals(
                new int[][] {
                        { 1, 1, 1, 1, 1 },
                        { 0, 0, 0, 0, 1 },
                        { 1, 1, 1, 0, 1 },
                        { 1, 0, 0, 0, 1 },
                        { 1, 1, 1, 1, 1 }
                },
                Spiralizor.spiralize(5));
    }

    @Test
    public void test8() {
        assertArrayEquals(
                new int[][] {
                        { 1, 1, 1, 1, 1, 1, 1, 1 },
                        { 0, 0, 0, 0, 0, 0, 0, 1 },
                        { 1, 1, 1, 1, 1, 1, 0, 1 },
                        { 1, 0, 0, 0, 0, 1, 0, 1 },
                        { 1, 0, 1, 0, 0, 1, 0, 1 },
                        { 1, 0, 1, 1, 1, 1, 0, 1 },
                        { 1, 0, 0, 0, 0, 0, 0, 1 },
                        { 1, 1, 1, 1, 1, 1, 1, 1 },
                },
                Spiralizor.spiralize(8));
    }

}