C'è un gioco chiamato Get Home che si gioca su una scacchiera. In questo gioco c'è un singolo pezzo che viene mosso da entrambi i giocatori a turno. Ci sono alcune regole su come spostare il pezzo. In un turno un giocatore deve effettuare una delle seguenti mosse per n positivo .

• n spazi in alto

• n spazi a sinistra

• n spazi in alto ea sinistra (una diagonale)

Il giocatore che sposta il pezzo nell'angolo in alto a sinistra del tabellone vince la partita.

Ora definiremo il concetto di un quadrato perdente. In questo video (da cui ho avuto l'idea) un quadrato perdente è definito come un quadrato su cui, ogni giocatore che inizia il proprio turno sarà costretto a fare una mossa permettendo al proprio avversario di forzare una vittoria. L'esempio più semplice di un quadrato perdente sarebbe il quadrato in (1,2). Un pezzo in (1,2) può spostarsi in uno dei seguenti posti.

Tutto ciò ha un percorso diretto verso la vittoria per il prossimo giocatore.

Ne consegue anche che qualsiasi quadrato che ha un percorso di una mossa verso un quadrato perdente consente al giocatore che inizia su quel quadrato di forzare una vittoria. Ciò significa che anche un quadrato che non è a una distanza da un quadrato perdente è un quadrato perdente.

Questo ci porta a questa definizione piuttosto ordinata di un quadrato perdente:

Un quadrato perdente è un quadrato dal quale nessuna mossa può arrivare su un altro quadrato perdente e (0,0) è un quadrato perdente.

Compito

Date le coordinate di un quadrato su una scacchiera di dimensioni arbitrarie, determinare se si tratta di un quadrato perdente. Stampa due valori uno per perdere i quadrati e uno per gli altri.

Questo è code-golf, quindi le risposte verranno classificate in byte con meno byte migliori.

Casi test

Ecco tutti i quadrati perdenti su una normale scacchiera 8 per 8 (contrassegnati 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

Ecco un'immagine di una tavola 100 per 100 con quadrati perdenti segnati in nero (ogni quadrato è 2 pixel per 2 pixel).

Python 3 , 112 50 46 42 byte

^{-4 byte grazie a Jonathan Allan !}

^{-2 byte grazie a xnor !}

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

Provalo online!

Basato sulla formula per le posizioni fredde nel gioco di Wythoff e apportare alcune modifiche per produrre una formula esplicita. Spiegazione in entrata dopo aver effettivamente completato una metodologia corretta per la derivazione della formula.

Gelatina , 8 byte

ạ/×ØpḞ⁼Ṃ

Provalo online! o vedere i 60 in alto a sinistra per 60 come una griglia .

Come?

Una posizione fredda nel gioco di Wythoff è una posizione perdente. Le coordinate [n,m]danno una posizione freddo quando n = floor(kφ) = floor(mφ) - mo m = floor(kφφ) = ceil(nφ) = n + kper qualche numero naturale, ke il rapporto aureo, φ. Il primo vale quando nè inferiore a m; quest'ultimo quando mè minore di n(entrambi trattenendo 0,0).

kè quindi la differenza assoluta tra ne me se floor(abs(n-m)φ)=min(n,m)la condizione è soddisfatta.

ạ/×Ø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 byte

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

Vedo ora che questa non è la tecnica migliore, ma ho dovuto inventarmela da sola perché ho perso Internet poco dopo aver caricato questa pagina. (Avrei pubblicato qualche tempo fa se non per questi problemi di Internet ...)

In un mondo perfetto, la precisione del float non sarebbe un problema e potrei risparmiare 9 byte:

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

Altri 6 byte potrebbero essere salvati se JS supportasse il concatenamento di confronto di Python:

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

Pyth, 39 byte

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

Ho scritto questo con una funzione chiamata (ew), ed ero estremamente pigro con il golf. Sto programmando di golf parecchi byte più tardi stasera

Provalo online, con i miei test generati, pensato per alternare True / False

Spiegazione:

Le diagonali della matrice della soluzione hanno un quadrato perdente in base alla sequenza di numeri ripetuti in OEIS A005206 . From Lthrough ;è una notazione polacca piuttosto semplice da definire y(b)=b-y(y(b-1)).

Segue il resto della spiegazione

=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

Lotto, 204 byte

@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

Restituisce tramite il codice di uscita. Spiegazione: Poiché Batch ha solo aritmetica intera, ho dovuto escogitare una soluzione puramente aritmetica. Escludendo l' 0,0inserimento, le coppie di coordinate quadrate perdenti seguono la seguente regola: se il 11numero binario successivo libero è pari, allora aggiungi 3,2altrimenti aggiungi 2,1. Un test per un 11numero binario libero è se non ci sono carry quando viene moltiplicato per tre, in altre parole (i*2)+i==(i*2)^i. Ecco i primi pochi 11numeri binari liberi e le loro coordinate:

   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

ecc. Misteriosamente questa regola è sufficiente per rendere complementari le sequenze. Resta quindi da calcolare la sequenza fino a quando non raggiunge la coordinata più grande, a quel punto possiamo determinare se il quadrato sta perdendo.