introduzione

Ispirato al video molto recente The Trapped Knight - Numberphile , mi è venuta una sfida.

La sequenza del cavaliere intrappolato è una sequenza intera finita di lunghezza 2016, a partire da 1, e ha le seguenti regole di costruzione:

1. Scrivi una spirale numerica nel modo seguente:

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. Posiziona un cavaliere su 1.
3. Spostare il cavaliere sulla griglia con il numero più piccolo che può andare che non sia mai stato visitato prima, secondo le regole degli scacchi (cioè 2 unità in verticale e 1 unità in orizzontale, o viceversa).
4. Ripeti finché il cavaliere non si blocca.

Ecco i primi tre passaggi:

Passo 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 

Le mosse possibili sono 10, 12, 14, 16, 18, 20, 22, 24, tra le quali la più piccola è 10, quindi il secondo termine è 10.

Passo 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 

Le mosse possibili sono 1 , 3, 23, 29, 47, 49, 51, 53, tra le quali la più piccola è 3, quindi il terzo termine è 3.

Passaggio 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 

Le mosse possibili sono 6, 8, 10 , 16, 28, 30, 32, 34, tra le quali la più piccola è 6, quindi il quarto termine è 6.

La sequenza inizia con:

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

e termina con

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

Sfida

Scrivi un programma o una funzione più breve, ricevendo un numero intero nell'intervallo [1, 2016](o [0, 2015]se viene utilizzato 0-indicizzato) come input, genera il numero su quell'indice nella sequenza di cavalieri intrappolati. Puoi scegliere di indicizzare la sequenza con 0-indicizzato o 1-indicizzato, ma devi specificare quale schema di indicizzazione usi.

Casi di test (1 indicizzato)

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

Per tutte le possibili uscite, fare riferimento a questa pagina .

Criteri vincenti

Vince il codice più breve di ogni lingua. Si applicano restrizioni sulle lacune standard.

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

Provalo online!

Come?

Una versione leggermente modificata della mia risposta a The Path Of The Wildebeest è decisamente più breve (e più veloce) di quella. Ma volevo provare un approccio diverso. Per inciso, penso che potrebbe essere più semplice implementare questo metodo in alcuni esolang.

Algoritmo:

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. Riavviamo al passaggio 2 o restituiamo l'ultimo indice trovato se abbiamo finito.

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)

Provalo online!

05AB1E , 53 byte

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

32θ$n+1$

Provalo online o verifica alcuni altri casi di test (timeout per i casi di test più grandi).

Spiegazione:

Vedi la spiegazione nella mia risposta The Path of the Wildebeest . Le uniche parti modificate sono:

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

e un finale:

θ       # Only leave the last item of the list

EDIT: una porta dell'approccio di @Arnauld nella sua risposta JavaScript (ES7) è (attualmente):

05AB1E , 57 56 byte

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

Provalo online o verifica alcuni altri casi di test (timeout per i casi di test più grandi).

Spiegazione:

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

L'input è basato su 0.

Provalo online!