pengantar

Terinspirasi oleh video terbaru The Trapped Knight - Numberphile , saya mendapat tantangan.

The Urutan ksatria terjebak adalah urutan bilangan bulat terbatas panjang 2016, mulai dari 1, dan memiliki aturan konstruksi berikut:

1. Tulis angka spiral dengan cara berikut:

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. Tempatkan seorang ksatria pada 1.
3. Pindahkan ksatria ke grid dengan jumlah terkecil yang bisa pergi yang belum pernah dikunjungi sebelumnya, sesuai dengan aturan catur (yaitu 2 unit secara vertikal dan 1 unit secara horizontal, atau sebaliknya).
4. Ulangi sampai ksatria macet.

Inilah tiga langkah pertama:

Langkah 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 

Kemungkinan gerakan adalah 10, 12, 14, 16, 18, 20, 22, 24, di antaranya yang terkecil adalah 10, sehingga suku kedua adalah 10.

Langkah 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 

Kemungkinan gerakan adalah 1 , 3, 23, 29, 47, 49, 51, 53, di antaranya yang terkecil adalah 3, sehingga suku ketiga adalah 3.

Langkah 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 

Kemungkinan bergerak adalah 6, 8, 10 , 16, 28, 30, 32, 34, di antaranya yang terkecil adalah 6, jadi istilah keempat adalah 6.

Urutan dibintangi dengan:

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

dan diakhiri dengan

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

Tantangan

Menulis program atau fungsi terpendek, menerima bilangan bulat dalam kisaran [1, 2016](atau [0, 2015]jika 0-diindeks digunakan) sebagai input, output angka pada indeks itu dalam urutan knight yang terperangkap. Anda dapat memilih untuk mengindeks urutan dengan 0-diindeks atau 1-diindeks, tetapi Anda harus menentukan skema pengindeksan yang Anda gunakan.

Kasus uji (1-diindeks)

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

Untuk semua kemungkinan keluaran, silakan merujuk ke halaman ini .

Kriteria Menang

Kode terpendek dari setiap bahasa menang. Batasan pada celah standar berlaku.

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

Cobalah online!

Bagaimana?

Versi yang sedikit dimodifikasi dari jawaban saya untuk The Path Of The Wildebeest jelas lebih pendek (dan lebih cepat) dari itu. Tetapi saya ingin mencoba pendekatan yang berbeda. Kebetulan, saya pikir mungkin lebih mudah untuk menerapkan metode ini di beberapa esolang.

Algoritma:

1. $3199$

2. $(X,Y)$

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

   $(x,y)$ adalah koordinat ksatria saat ini.

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

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

4. Kami memulai kembali pada langkah 2 atau mengembalikan indeks terakhir yang ditemukan jika kami selesai.

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)

Cobalah online!

05AB1E , 53 byte

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

32θ$n+1$ item .

Cobalah secara online atau verifikasi beberapa kasus uji lagi (waktu habis untuk kasus uji terbesar).

Penjelasan:

Lihat penjelasan di saya terkait The Path of the Wildebeest jawaban . Satu-satunya bagian yang dimodifikasi adalah:

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

dan sebuah trailing:

θ       # Only leave the last item of the list

EDIT: Port pendekatan @Arnauld dalam jawabannya JavaScript (ES7) adalah (saat ini):

05AB1E , 57 56 byte

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

Cobalah secara online atau verifikasi beberapa kasus uji lagi (waktu habis untuk kasus uji terbesar).

Penjelasan:

‚%                # 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=])

Input berbasis 0.

Cobalah online!