골프는 시계 반대 방향의 사각형 나선형으로 번호가 매겨진 무한 체스 판 에서 1 번 광장에서 시작 하는 와일드 플라이 의 $n^{\text{th}}$ 위치 를 제공하는 프로그램 또는 기능을 제공합니다 . 야생 동물은 항상 그녀가 도달하지 못한 가장 낮은 번호의 사각형을 방문합니다 아직 방문했습니다.$1$

영감 : 갇힌 기사 와 OEIS A316667 .

편집 :이 시퀀스는 이제 OEIS에 A323763으로되어 있습니다.

코드는 $n^{\text{th}}$ 위치, 첫 번째 $n$ 위치를 생성하거나 입력을받지 않는 시퀀스를 생성 할 수 있습니다.

이후 그녀의 위치를 제공하는 무료 (또는 최대) 느낌 $n$ 대신 도약,하지만 그래서 당신의 대답이 명확하게 상태를 기쁘게 할 경우 확인하십시오의 입력 $n=0$ 수익률 1(또는 [1]해당되는 경우).

이것은 code-golf 이므로 목표는 선택한 언어로 가능한 한 적은 바이트로 작업 코드를 생성하는 것입니다.

참고 : 누우이 갇혀된다 (기사 그의에서 수행 흡사 $2016^{\text{th}}$ 위치, 광장 $2084$ , 낙타 그의에서 수행 $3723^{\text{rd}}$ , 광장 $7081$ ) 그녀의 $12899744968^{\text{th}}$ 광장에 위치 $12851850258$ . 이보다 큰 $n$ 의 경우 코드 동작이 정의되지 않을 수 있습니다 . ( 이를 발견 한 C ++ 코드에 대한 Deadcode에 감사합니다 !)

세부 묘사

보드는 다음과 같으며 무기한 계속됩니다.

101 100  99  98  97  96  95  94  93  92  91
102  65  64  63  62  61  60  59  58  57  90
103  66  37  36  35  34  33  32  31  56  89
104  67  38  17  16  15  14  13  30  55  88
105  68  39  18   5   4   3  12  29  54  87
106  69  40  19   6   1   2  11  28  53  86
107  70  41  20   7   8   9  10  27  52  85
108  71  42  21  22  23  24  25  26  51  84
109  72  43  44  45  46  47  48  49  50  83
110  73  74  75  76  77  78  79  80  81  82
111 112 113 114 115 116 117 118 119 120 121

누우이 는 "GNU"인 변형 체스 기물 A와 동시에 이동할 수있다 비표준 체스 조각 - 나이트 (A $(1,2)$ -leaper)와 같이 낙 (A $(1,3)$ -leaper).
따라서 그녀는 시작 위치 $1$ 에서 다음 위치 중 하나로 이동할 수 있습니다 .

  .   .   .   .   .   .   .   .   .   .   .
  .   .   .   .  35   .  33   .   .   .   .
  .   .   .   .  16   .  14   .   .   .   .
  .   .  39  18   .   .   .  12  29   .   .
  .   .   .   .   .  (1)  .   .   .   .   .
  .   .  41  20   .   .   .  10  27   .   .
  .   .   .   .  22   .  24   .   .   .   .
  .   .   .   .  45   .  47   .   .   .   .
  .   .   .   .   .   .   .   .   .   .   .

이 중 가장 낮은 값은 $10$ 이고 아직 해당 사각형을 방문하지 않았으므로 $10$ 은 시퀀스의 두 번째 용어입니다.

다음으로 그녀는 $10$ 에서 다음 위치 로 이동할 수 있습니다.

  .   .   .   .   .   .   .   .   .   .   .
  .   .   .   .   .   .  14   .  30   .   .
  .   .   .   .   .   .   3   .  29   .   .
  .   .   .   .   6   1   .   .   .  53  86
  .   .   .   .   .   .   . (10)  .   .   .
  .   .   .   .  22  23   .   .   .  51  84
  .   .   .   .   .   .  47   .  49   .   .
  .   .   .   .   .   .  78   .  80   .   .
  .   .   .   .   .   .   .   .   .   .   .

$1$$3$

---

$100$

1, 10, 3, 6, 9, 4, 7, 2, 5, 8, 11, 14, 18, 15, 12, 16, 19, 22, 41, 17, 33, 30, 34, 13, 27, 23, 20, 24, 44, 40, 21, 39, 36, 60, 31, 53, 26, 46, 25, 28, 32, 29, 51, 47, 75, 42, 45, 71, 74, 70, 38, 35, 59, 56, 86, 50, 78, 49, 52, 80, 83, 79, 115, 73, 107, 67, 64, 68, 37, 61, 93, 55, 58, 54, 84, 48, 76, 43, 69, 103, 63, 66, 62, 94, 57, 87, 125, 82, 118, 77, 113, 72, 106, 148, 65, 97, 137, 91, 129, 85

$11$$12$

자바 스크립트 (Node.js) ,  191 ... 166166  바이트

@grimy 덕분에 2 바이트를 절약했습니다 .

$N$

n=>(g=(x,y)=>n--?g(Buffer('QPNP1O?O@242Q3C3').map(m=c=>g[i=4*((x+=c%6-2)*x>(y+=c%7-2)*y?x:y)**2,i-=(x>y||-1)*(i**.5+x+y)]|i>m||(H=x,V=y,m=i))&&H,V,g[m]=1):m+1)(1,2)

온라인으로 사용해보십시오! 또는 형식화 된 버전보기

방법?

나선 지수

$(x,y)$$I$$L$

$$L=\max(|x|,|y|)$$

다음을 제공합니다.

$$\begin{array}{c|ccccccc} &-3&-2&-1&0&+1&+2&+3\\ \hline -3&3&3&3&3&3&3&3\\ -2&3&2&2&2&2&2&3\\ -1&3&2&1&1&1&2&3\\ 0&3&2&1&0&1&2&3\\ +1&3&2&1&1&1&2&3\\ +2&3&2&2&2&2&2&3\\ +3&3&3&3&3&3&3&3 \end{array}$$

그런 다음 레이어에서 위치 를 다음과 같이 계산합니다 .$P$

$$P=\begin{cases} 2L+x+y&\text{if }x>y\\ -(2L+x+y)&\text{if }x\le y \end{cases}$$

다음을 제공합니다.

$$\begin{array}{c|ccccccc} &-3&-2&-1&0&+1&+2&+3\\ \hline -3&0&1&2&3&4&5&6\\ -2&-1&0&1&2&3&4&7\\ -1&-2&-1&0&1&2&5&8\\ 0&-3&-2&-1&0&3&6&9\\ +1&-4&-3&-2&-3&-4&7&10\\ +2&-5&-4&-5&-6&-7&-8&11\\ +3&-6&-7&-8&-9&-10&-11&-12 \end{array}$$

제공 한 최종 색인 은 다음과 같습니다.$I$

$$I=4L^2-P$$

주의 : 위의 공식은 0 인덱스 나선을 제공합니다.

JS 코드에서 실제로 다음을 사용하여 즉시 계산합니다 .$4L^2$

i = 4 * (x * x > y * y ? x : y) ** 2

그리고 다음 과 같이 를 뺍니다 .$P$

i -= (x > y || -1) * (i ** 0.5 + x + y)

누우의 움직임

현재 위치 주어지면, 누우의 16 가지 가능한 목표 제곱은 다음 순서로 테스트됩니다.$(x,y)$

$$\begin{array}{c|cccccccc} &-3&-2&-1&x&+1&+2&+3\\ \hline -3&\cdot&\cdot&9&\cdot&11&\cdot&\cdot\\ -2&\cdot&\cdot&8&\cdot&10&\cdot&\cdot\\ -1&7&6&\cdot&\cdot&\cdot&12&13\\ y&\cdot&\cdot&\cdot&\bullet&\cdot&\cdot&\cdot\\ +1&5&4&\cdot&\cdot&\cdot&14&15\\ +2&\cdot&\cdot&2&\cdot&0&\cdot&\cdot\\ +3&\cdot&\cdot&3&\cdot&1&\cdot&\cdot \end{array}$$

16 쌍의 부호있는 값 을 적용하여 살펴 봅니다. 각 쌍은 단일 ASCII 문자로 인코딩됩니다.$(dx,dy)$

 ID | char. | ASCII code | c%6-2 | c%7-2 | cumulated
----+-------+------------+-------+-------+-----------
  0 |  'Q'  |     81     |   +1  |   +2  |  (+1,+2)
  1 |  'P'  |     80     |    0  |   +1  |  (+1,+3)
  2 |  'N'  |     78     |   -2  |   -1  |  (-1,+2)
  3 |  'P'  |     80     |    0  |   +1  |  (-1,+3)
  4 |  '1'  |     49     |   -1  |   -2  |  (-2,+1)
  5 |  'O'  |     79     |   -1  |    0  |  (-3,+1)
  6 |  '?'  |     63     |   +1  |   -2  |  (-2,-1)
  7 |  'O'  |     79     |   -1  |    0  |  (-3,-1)
  8 |  '@'  |     64     |   +2  |   -1  |  (-1,-2)
  9 |  '2'  |     50     |    0  |   -1  |  (-1,-3)
 10 |  '4'  |     52     |   +2  |   +1  |  (+1,-2)
 11 |  '2'  |     50     |    0  |   -1  |  (+1,-3)
 12 |  'Q'  |     81     |   +1  |   +2  |  (+2,-1)
 13 |  '3'  |     51     |   +1  |    0  |  (+3,-1)
 14 |  'C'  |     67     |   -1  |   +2  |  (+2,+1)
 15 |  '3'  |     51     |   +1  |    0  |  (+3,+1)

최소 만남 값을 추적 하고 해당 셀의 좌표를 추적합니다 .$m$$(H,V)$

최상의 후보를 찾으면 객체에 플래그를 설정하여 방문한 것으로 표시합니다.이 플래그는 주요 재귀 함수이기도합니다.$g$

첫 번째 반복에서 과 합니다. 이렇게하면 첫 번째로 선택한 셀이 이고 방문으로 표시되는 첫 번째 셀이됩니다.$x=1$$y=2$$(0,0)$

코코넛 , 337276 바이트

import math
def g((x,y))=
 A=abs(abs(x)-abs(y))+abs(x)+abs(y)
 int(A**2+math.copysign(A+x-y,.5-x-y)+1)
def f():
 p=x,y=0,0;s={p};z=[2,3,1,1]*2
 while 1:yield g(p);p=x,y=min(((a+x,b+y)for a,b in zip((1,1,2,-2,-1,-1,3,-3)*2,z+[-v for v in z])if(a+x,b+y)not in s),key=g);s.add(p)

값 생성기를 반환합니다. 아마도 더 많은 골프를 쳤을 것입니다. (특히 차이 튜플의 순서) 이 math.se answer 에서 가져온 나선형 알고리즘 .

온라인으로 사용해보십시오!

05AB1E , 77 65 58 57 52 바이트

Xˆ0UF3D(Ÿ0KãʒÄ1¢}εX+}Dε·nàDtyÆ+yO·<.±*->}D¯KßDˆkèU}¯

그의 공식 포트를 사용하여 @Arnauld 덕분에 -6 바이트 .

첫 번째 값을 10 진수 목록으로 출력합니다 .$n+1$

온라인으로 시도하십시오 ( ï바닥 글에서를 제거하여 .0출력을보다 작게 만들지 만 실제 결과를 보려면 자유롭게 제거하십시오).

코드 설명 :

Xˆ             # Put integer 1 in the global_array (global_array is empty by default)
0U             # Set variable `X` to 0 (`X` is 1 by default)
F              # Loop the (implicit) input amount of times:
 3D(Ÿ          #  Push the list in the range [-3,3]: [-3,-2,-1,0,1,2,3]
     0K        #  Remove the 0: [-3,-2,-1,1,2,3]
       ã       #  Cartesian product with itself, creating each possible pair: [[3,3],[3,2],[3,1],[3,-1],[3,-2],[3,-3],[2,3],[2,2],[2,1],[2,-1],[2,-2],[2,-3],[1,3],[1,2],[1,1],[1,-1],[1,-2],[1,-3],[-1,3],[-1,2],[-1,1],[-1,-1],[-1,-2],[-1,-3],[-2,3],[-2,2],[-2,1],[-2,-1],[-2,-2],[-2,-3],[-3,3],[-3,2],[-3,1],[-3,-1],[-3,-2],[-3,-3]]
        ʒ   }  #  Filter this list of pairs by:
         Ä     #   Where the absolute values of the pair
          1¢   #   Contains exactly one 1
               #  (We now have the following pairs left: [[3,1],[3,-1],[2,1],[2,-1],[1,3],[1,2],[1,-2],[1,-3],[-1,3],[-1,2],[-1,-2],[-1,-3],[-2,1],[-2,-1],[-3,1],[-3,-1]])
 εX+}          #  Add the variable `X` (previous coordinate) to each item in the list
 D             #  Duplicate this list of coordinates
  ε            #  Map each `x,y`-coordinate to:
   ·           #   Double both the `x` and `y` in the coordinate
    n          #   Then take the square of each
     à         #   And then pop and push the maximum of the two
   Dt          #   Duplicate this maximum, and take its square-root
     yÆ        #   Calculate `x-y`
       +       #   And add it to the square-root
   yO          #   Calculate `x+y`
     ·         #   Double it
      <        #   Decrease it by 1
       .±      #   And pop and push its signum (-1 if < 0; 0 if 0; 1 if > 0)
   *           #   Multiply these two together
    -          #   And subtract it from the duplicated maximum
   >           #   And finally increase it by 1 to make it 1-based instead of 0-based
  }D           #  After the map: Duplicate that list with values
    ¯K         #  Remove all values that are already present in the global_array
      ß        #  Pop the list of (remaining) values and push the minimum
       Dˆ      #  Duplicate this minimum, and pop and add the copy to the global_array
         k     #  Then get its index in the complete list of values
          è    #  And use that index to get the corresponding coordinate
           U   #  Pop and store this coordinate in variable `X` for the next iteration
}¯             # After the outer loop: push the global_array (which is output implicitly)

일반적인 설명 :

우리 global_array는 처음에로 시작되는의 모든 결과 (및 이미 경험 한 값)를 보유합니다 [1].
우리는 현재 보유 변수에 -coordinate 처음이다 .$x,y$X[0,0]

현재 좌표를 기준으로 도달 할 수있는 좌표 목록 은 다음과 같습니다.$x,y$

[[x+3,y+1], [x+3,y-1], [x+2,y+1], [x+2,y-1], [x+1,y+3], [x+1,y+2], [x+1,y-2], [x+1,y-3], [x-1,y+3], [x-1,y+2], [x-1,y-2], [x-1,y-3], [x-2,y+1], [x-2,y-1], [x-3,y+1], [x-3,y-1]]

위의 코드 설명에서 언급 한 목록에는 이동할 수있는 값이 있으며 현재 (변수에 저장 됨 )가 추가됩니다.$x,y$X

그런 다음이 좌표를 기준으로 나선 값을 계산합니다 . 주어진 좌표에 대해 다음 공식을 사용하여이를 수행합니다 .$x,y$$x,y$

$${T = max((2 * x) ^ 2, (2 * y) ^ 2)}$$ $${R = T - (x - y + √T) * signum((x + y) * 2 - 1) + 1}$$

@Arnauld 가 그의 대답에 사용 하는 것과 동일한 공식 이지만 double, square, -1, +1 등에 05AB1E의 내장을 사용하기 위해 다르게 작성되었습니다.

(코드의이 나선형 부분 만 실제로 보려면 : 온라인으로 시도하십시오 .)

주어진 좌표 에 대해 도달 할 수있는 모든 값을 얻은 후에 는에 이미 존재하는 모든 값을 제거 하고 (남은) 값의 최소값을 얻습니다. 그런 다음이 최소값이에 추가 되고 변수 가이 최소값 의 좌표 로 바뀝니다 .$x,y$x , yglobal_array
global_arrayX$x,y$

우리가 input횟수를 반복 한 후 , 프로그램은 이것을 global_array결과로 출력 할 것 입니다.