Create endless grid spiral in java

Question

I want to create endless spiral in java like this:

I simply want to pass a number from 1-∞ and get it's spiral map.

Example:

getPoints(0); Would result in answer (0;0)

getPoints(5); Would result in answer (-1;0)

Answer 1

Think algorithmically. Identify the pattern.

The pattern is that you walk the circumference, one layer at a time.

• In round 0, you are at the center point (0,0).
• In round 1, you walk the 8 cells around it.
• In round 2, you walk the 16 cells around that.
• In round 3, you walk the 24 cells around that.

Now see the pattern:

• In each round, the walk on each side is 2 more steps, totally 8 more steps per round.
• Each round starts 1 cell to the right of the upper-left corner.
• Walking on each side starts 1 cell from the corner.

So, now that you see the pattern, you can do it like this:

• Calculate which round you are in.
• For that round, calculate which side you are on.
• Then calculate how many steps you've taken on that side.
• Finally, calculate the coordinate from that.

Answer 2

import java.util.Scanner;

class spiral 
{
    private static String getXZForMap(int np)
    {         
        // (dx, dy) is a vector - direction in which we move right now
        int dx = 0;
        int dy = 1;
        // length of current segment
        int segment_length = 1;

        // current position (x, y) and how much of current segment we passed
        int x = 0;
        int y = 0;
        int segment_passed = 0;
        if (np == 0){
            return ("(" + y + ";" + x + ")");
        }
        for (int n = 0; n < np; ++n) {
            // make a step, add 'direction' vector (dx, dy) to current position (x, y)
            x += dx;
            y += dy;
            ++segment_passed;

            if (segment_passed == segment_length) {
                // done with current segment
                segment_passed = 0;

                // 'rotate' directions
                int buffer = dy;
                dy = -dx;
                dx = buffer;

                // increase segment length if necessary
                if (dx == 0) {
                    ++segment_length;
                }
            }
        }
        return("(" + y + ";" + x + ")");
    }

    public static void main(String[] args){

        Scanner sc = new Scanner(System.in);
        int NUMBER_OF_POINTS = Integer.valueOf(args[0]);   // or delete this line  
        String spiral_map = getXZForMap(NUMBER_OF_POINTS); // and put your int here
        System.out.println(spiral_map);
    } 
}

Adapted from this answer: Algorithm for iterating over an outward spiral on a discrete 2D grid from the origin

Demo:

$ java spiral 0
(0;0)
$ java spiral 5
(-1;0)

Answer 3

public int[] getPoints(int n){
    int[] k = new int[2];
    if(n == 0){
        k[0] = 0;
        k[1] = 0;
        return k;
    }
    n--;
    int r = (int) (Math.floor((Math.sqrt(n + 1) -1) / 2) + 1);
    int p = (8 * r * (r - 1)) / 2;
    int a = (1 + n - p) % (r * 8);
    
    switch ((int) Math.floor(a / (r * 2))) {
    case 0:
        k[0] = a - r;
        k[1] = -r;
        return k;
    case 1:
        k[0] = r;
        k[1] = (a % (r * 2)) - r;
        return k;
    case 2:
        k[0] = r - (a % (r * 2));
        k[1] = r;
        return k;
    case 3:
        k[0] = -r;
        k[1] = r - (a % (r * 2));
        return k;
    }
    return null;       
}