Giới thiệu

Lấy cảm hứng từ video gần đây The Trapping Knight - Numberphile , tôi đã đưa ra một thử thách.

Chuỗi hiệp sĩ bị mắc kẹt là một chuỗi số nguyên hữu hạn có độ dài 2016, bắt đầu từ 1 và có các quy tắc xây dựng sau:

1. Viết một số xoắn ốc theo cách sau:

17 16 15 14 13 ...
18  5  4  3 12 ...
19  6  1  2 11 ...
20  7  8  9 10 ...
21 22 23 24 25 ...

2. Đặt một hiệp sĩ trên 1.
3. Di chuyển hiệp sĩ vào lưới với số lượng nhỏ nhất mà nó có thể đi mà chưa được truy cập trước đó, theo quy tắc của cờ vua (tức là 2 đơn vị theo chiều dọc và 1 đơn vị theo chiều ngang hoặc ngược lại).
4. Lặp lại cho đến khi hiệp sĩ bị mắc kẹt.

Đây là ba bước đầu tiên:

Bước 1

 17  [16]  15  [14]  13 
[18]   5    4    3  [12]
 19    6  < 1>   2   11 
[20]   7    8    9  [10]
 21  [22]  23  [24]  25 

Di chuyển có thể là 10, 12, 14, 16, 18, 20, 22, 24, trong đó nhỏ nhất là 10, vì vậy thuật ngữ thứ hai là 10.

Bước 2

  4  [ 3]  12  [29]  54
( 1)   2   11   28  [53] 
  8    9  <10>  27   52 
[23]  24   25   26  [51] 
 46  [47]  48  [49]  50 

Di chuyển có thể là 1 , 3, 23, 29, 47, 49, 51, 53, trong đó nhỏ nhất là 3, vì vậy thuật ngữ thứ ba là 3.

Bước 3

 35  [34]  33  [32]  31 
[16]  15   14   13  [30] 
  5    4  < 3>  12   29 
[ 6] ( 1)   2   11  [28] 
  7  [ 8]   9  (10)  27 

Di chuyển có thể là 6, 8, 10 , 16, 28, 30, 32, 34, trong đó nhỏ nhất là 6, vì vậy thuật ngữ thứ tư là 6.

Chuỗi sao với:

1 10 3 6 9 4 7 2 5 8 11 14 ...

và kết thúc bằng

... 2099 2284 2477 2096 2281 2474 2675 2884 3101 2880 2467 2084

Thử thách

Viết chương trình hoặc hàm ngắn nhất, nhận số nguyên trong phạm vi [1, 2016](hoặc [0, 2015]nếu sử dụng chỉ mục 0) làm đầu vào, xuất số ở chỉ mục đó trong chuỗi hiệp sĩ bị mắc kẹt. Bạn có thể chọn lập chỉ mục chuỗi với 0-index hoặc 1-index, nhưng bạn phải chỉ định sơ đồ lập chỉ mục nào bạn sử dụng.

Các trường hợp thử nghiệm (1 chỉ mục)

n    | s(n)
-----+-----
   1 |    1
   2 |   10
   3 |    3
   6 |    4
  11 |   11
  21 |   23
  51 |   95
 101 |   65
 201 |  235
 501 |  761
1001 | 1069
2001 | 1925
2016 | 2084

Đối với tất cả các đầu ra có thể, xin vui lòng tham khảo trang này .

Tiêu chí chiến thắng

Mã ngắn nhất của mỗi ngôn ngữ sẽ thắng. Hạn chế về sơ hở tiêu chuẩn áp dụng.

JavaScript (ES7),  182  181 byte

f=(n,[x,y]=[2,1],a=[...Array(4e3)].map((_,n)=>[1,-1].map(s=>(i&1?-s:s)*(i+s*n-(n>0?n:-n)>>1),i=n**.5|0,n-=i*++i)))=>n--?f(n,a.find(([X,Y],j)=>(i=j,(x-X)*(y-Y))**2==4),a,a[i]=[]):i+1

Hãy thử trực tuyến!

Làm sao?

Một phiên bản sửa đổi một chút trong câu trả lời của tôi cho The Path Of The Wildebeest chắc chắn ngắn hơn (và nhanh hơn). Nhưng tôi muốn thử một cách tiếp cận khác. Ngẫu nhiên, tôi nghĩ rằng có thể dễ dàng hơn để thực hiện phương pháp này trong một số esolang.

Thuật toán:

1. $3199$

2. $(X,Y)$

   $$((x-X)\times(y-Y))^2=4$$

   $(x,y)$

   $|x-X|=1$$|y-Y|=2$$|x-X|=2$$|y-Y|=1$

3. $(x,y)=(X,Y)$

4. Chúng tôi sẽ khởi động lại ở bước 2 hoặc trả về chỉ mục cuối cùng được tìm thấy nếu chúng tôi hoàn thành.

Node.js , 155 byte

n=>(g=(x,y)=>n--?g(Buffer('QHUbcdWJ').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)

Hãy thử trực tuyến!

05AB1E , 53 byte

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

32θ$n+1$

Dùng thử trực tuyến hoặc xác minh thêm một số trường hợp thử nghiệm (hết thời gian cho các trường hợp thử nghiệm lớn nhất).

Giải trình:

Xem lời giải thích trong câu trả lời được liên kết của tôi The Path of the Wildebeest . Các phần duy nhất được sửa đổi là:

2D(Ÿ    # Get a list in the range [-2,2]: [-2,-1,0,1,2]

và một dấu vết:

θ       # Only leave the last item of the list

EDIT: Một cổng của @Arnauld cách tiếp cận 's trong mình JavaScript (ES7) Câu trả lời là (hiện tại):

05AB1E , 57 56 byte

0D‚DˆUF64D(ŸãΣ·nàDtyÆ+yO·<.±*->}©ʒX-Pn4Q}¯¡˜2£DˆU}®J¯Jk>θ

Dùng thử trực tuyến hoặc xác minh thêm một số trường hợp thử nghiệm (hết thời gian cho các trường hợp thử nghiệm lớn nhất).

Giải trình:

‚%                # Create a pair of zeros: [0,0]
                  # (by pairing the (implicit) input with itself,
                  #  and then using modulo (implicit) input)
  DˆU             # Set both variable `X` to this, and add it to the global_array
F                 # Loop the (implicit) input amount of times:
 64D(Ÿ            #  Create a list in the range [-64,64]
      ã           #  Create each possible pair of `x,y`-coordinates
       Σ·nàDtyÆ+yO·<.±*->}
                  #  Sort this list in a spiral
        ©         #  Save it in the register (without popping)
 ʒ      }         #  Filter the list of coordinates by:
  X-              #   Subtract the coordinate of variable `X`
    P             #   Take the product
     n            #   Take the square
      4Q          #   Check if its equal to 4
                  # Since 05AB1E cannot remove inner lists, we use a workaround:
         ¯¡       # Split this list on each coordinate in the global_array
           ˜      # Flatten the entire list
            2£    # Only leave the first two integers as `x,y`-coordinate
                  # (if 05AB1E could remove inner lists, this would've been `¯Kн` instead)
              DˆU # Replace variable `X` with this, and add it to the global_array
}®                # After the loop: push all coordinates sorted in a spiral from the register
  J               # Join each coordinate together to a string
   ¯J             # Push the global_array, and also join them together to a string
                  # (if 05AB1E could index inner lists, both `J` could have been removed)
     k            # Get the index of each item of the global_array in the spiral list
      >           # Increase the 0-indexed index by 1 to make it 1-based
       θ          # And only leave the last one (which is output implicitly)

Σ·nàDtyÆ+yO·<.±*->}$x,y$

MATL , 41 37 byte

62lYLt1=i:"YYw(t5Mf'<@{}'ot_h+)X<y=])

Đầu vào là 0 dựa trên.

Hãy thử trực tuyến!