Hay un juego llamado Get Home que se juega en un tablero de ajedrez. En este juego hay una sola pieza que ambos jugadores mueven por turnos. Hay algunas reglas sobre cómo se puede mover la pieza. En un turno, un jugador debe hacer uno de los siguientes movimientos para obtener un n positivo .

• n espacios arriba

• n espacios a la izquierda

• n espacios hacia arriba y hacia la izquierda (una diagonal)

El jugador que mueve la pieza a la esquina superior izquierda del tablero gana el juego.

Ahora definiremos el concepto de un cuadrado perdedor. En este video (de donde saqué la idea), una casilla perdedora se define como una casilla en la que cualquier jugador que comience su turno se verá obligado a hacer un movimiento que permita a su oponente forzar una victoria. El ejemplo más simple de un cuadrado perdedor sería el cuadrado en (1,2). Una pieza en (1,2) puede moverse a cualquiera de los siguientes lugares.

Todos los cuales tienen un camino directo a la victoria para el próximo jugador.

También se deduce que cualquier casilla que tenga un camino de un movimiento hacia una casilla perdedora le permite al jugador que comienza en esa casilla forzar una victoria. Esto significa que cualquier casilla que no esté a un movimiento de distancia de una casilla perdedora es también una casilla perdedora.

Esto nos lleva a esta definición bastante clara de un cuadrado perdedor:

Una casilla perdedora es una casilla desde la cual ningún movimiento puede llegar a otra casilla perdedora y (0,0) es una casilla perdedora.

Tarea

Dadas las coordenadas de un cuadrado en un tablero de ajedrez de tamaño arbitrario, determine si es un cuadrado perdedor. Emite dos valores, uno para perder cuadrados y otro para otros.

Este es el código de golf, por lo que las respuestas se puntuarán en bytes, siendo mejores menos bytes.

Casos de prueba

Aquí están todas las casillas perdedoras en un tablero de ajedrez regular de 8 por 8 (marcado con 0).

0 1 1 1 1 1 1 1
1 1 0 1 1 1 1 1
1 0 1 1 1 1 1 1
1 1 1 1 1 0 1 1
1 1 1 1 1 1 1 0
1 1 1 0 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 0 1 1 1

Aquí hay una imagen de un tablero de 100 por 100 con cuadrados perdidos marcados en negro (cada cuadrado es de 2 píxeles por 2 píxeles).

Python 3 , 112 50 46 42 bytes

^{-4 bytes gracias a Jonathan Allan !}

^{-2 bytes gracias a xnor !}

lambda r,c:abs(r-c)*(3+5**.5)//2==max(r,c)

Pruébalo en línea!

Basado en la fórmula para posiciones frías en el juego de Wythoff y haciendo algunas modificaciones para producir una fórmula explícita. Explicación entrante una vez que realmente termine una metodología adecuada para la derivación de la fórmula.

Jalea , 8 bytes

ạ/×ØpḞ⁼Ṃ

Pruébalo en línea! , o vea la parte superior izquierda de 60 por 60 como una cuadrícula .

¿Cómo?

Una posición fría en el juego de Wythoff es una posición perdedora. Las coordenadas [n,m]dan una posición fría cuando n = floor(kφ) = floor(mφ) - mo m = floor(kφφ) = ceil(nφ) = n + kpor algún número natural, ky la proporción áurea, φ. El primero se cumple cuando nes menor que m; este último cuando mes menor que n(ambos manteniéndose en 0,0).

kes por lo tanto la diferencia absoluta entre ny my si floor(abs(n-m)φ)=min(n,m)se cumple la condición.

ạ/×ØpḞ⁼Ṃ - Link: list, c ([n,m])
 /       - reduce c by:
ạ        -   absolute difference = abs(n-m)
   Øp    - golden ratio yield
  ×      - multiply
     Ḟ   - floor
       Ṃ - minimum of c = min(n,m)
      ⁼  - equal?

JavaScript (ES6), 64 bytes

f=(x,y,p=5**.5/2+.5)=>x<y?f(y,x):y/p%p<1&(y/p%p-x*p%++p)**2<1e-9

Ahora veo que esta no es la mejor técnica, pero tuve que inventarla yo mismo porque perdí Internet poco después de cargar esta página. (Hubiera publicado hace un tiempo si no fuera por estos problemas de Internet ...)

En un mundo perfecto, la precisión de flotación no sería un problema y podría ahorrar 9 bytes:

f=(x,y,p=5**.5/2+.5)=>x<y?f(y,x):y/p%p<1&y/p%p==x*p%++p

Se podrían guardar 6 bytes más si JS admitiera el encadenamiento de comparación de Python:

f=(x,y,p=5**.5/2+.5)=>x<y?f(y,x):y/p%p==x*p%++p<1

Pyth, 39 bytes

=SQL?!b0-byytb;q@myd+0.fqyZytZ@Q1)-F_Qh

Escribí esto con una función con nombre (ew), y era extremadamente vago con el golf. Planeando jugar un buen número de bytes más tarde esta noche

Pruébelo en línea, con mis propias pruebas generadas, destinadas a alternar verdadero / falso

Explicación:

Las diagonales de la matriz de solución tienen un cuadrado perdedor según la secuencia de números repetidos en OEIS A005206 . De Lprincipio a fin ;es bastante fácil definir la notación polaca y(b)=b-y(y(b-1)).

El resto de la explicación sigue

=SQL?!b0-byytb;q@myd+0.fqyZytZ@Q1)-F_Qh    Full program, take stdin as [x, y], output True or False to stdout
=SQ                                        Sort input
   L?!b0-byytb;                            Named lambda as explained above
                    +0.f                   Make sequence of first max(x, y) numbers, starting with 0, 
                        qy y               For which are equal 
                          Z tZ             each element and the previous are equal
                myd                        Map this sequence to the y(index), not just index numbers
             q                             Check if are equal 
              @                  )-F_Q     the x-yth element of sequence (x-y represents which diagonal) 
                                     h(Q)  and the lower of [x,y] (Q is added by the interpreter to fix arity issues

Lote, 204 bytes

@if %1 lss %2 %0 %2 %1
@if %1==0 exit/b0
@set/au=l=i=0
:g
@set/au+=2+i%%2,l+=1+i%%2
@if %1==%n% if %2==%m% exit/b0
@if %1 leq %n% exit/b1
:l
@set/a"k=3*i^2*i^i,i+=1
@if %k%==0 goto g
@goto l

Devoluciones a través del código de salida. Explicación: Dado que Batch solo tiene aritmética de enteros, tuve que idear una solución puramente aritmética. Excluyendo la 0,0entrada, los pares de coordenadas cuadradas perdedoras siguen la siguiente regla: si el siguiente 11número binario libre es par, entonces suma de lo 3,2contrario suma 2,1. Una prueba para un 11número binario libre es si no hay acarreos cuando se multiplica por tres, en otras palabras, eso (i*2)+i==(i*2)^i. Aquí están los primeros pocos 11números binarios libres y sus coordenadas:

   0     2,1  + 3,2 =  5,3
   1     5,3  + 2,1 =  7,4
  10     7,4  + 3,2 = 10,6
 100    10,6  + 3,2 = 13,8
 101    13,8  + 2,1 = 15,9
1000    15,9  + 3,2 = 18,11
1001    18,11 + 2,1 = 20,12
1010    20,12 + 3,2 = 23,14

Misteriosamente, esta regla es suficiente para hacer que las secuencias sean complementarias. Luego queda calcular la secuencia hasta que alcanza la coordenada más grande, en cuyo punto podemos determinar si el cuadrado está perdiendo.