Dato un input di quattro numeri interi x ₁ , y ₁ , x ₂ e y ₂ , viene emesso se un re bianco negli scacchi (con coordinate ( x ₁ , y ₁ )) potrebbe catturare un pedone nero (con coordinate ( x ₂ , y ₂ )) e catturalo se il pedone si sta muovendo per promuovere una regina il più velocemente possibile.

Le coordinate del tabellone sono le seguenti:

       first coordinate (x)
             12345678

           1 .#.#.#.#
           2 #.#.#.#.
           3 .#.#.#.#
  second   4 #.#.#.#.
coordinate 5 .#.#.#.#
    (y)    6 #.#.#.#.
           7 .#.#.#.#
           8 #.#.#.#.

Supponiamo che si muova in bianco (il turno del re) e che entrambi i giocatori giochino in modo ottimale (il re si muoverà il più velocemente possibile per catturare il pedone e il pedone si sposterà il più velocemente possibile per promuovere). Le coordinate di input saranno sempre distinte e il pedone non inizierà mai con una coordinata y di 8.

Il re si sposta di un quadrato in ogni direzione ogni turno (può muoversi in diagonale) e il pedone può muovere solo di uno spazio in avanti (diminuisce la sua coordinata y), a meno che non sia nella sua posizione iniziale (con il nostro sistema di coordinate, coordinata y di 7), nel qual caso può spostare in avanti di due spazi.

L'input può essere dato come una stringa separata da spazi bianchi / virgola, una matrice di stringhe / numeri interi o quattro argomenti di funzione / riga di comando / ecc. Le coordinate possono essere fornite in qualsiasi ordine sia più conveniente / golfy (quindi, accettare input come [y ₂ , y ₁ , x ₁ , y ₂ ] va bene purché sia ​​coerente). L'output deve essere un valore di verità o falsa .

Dato che si tratta di code-golf , vince il codice più breve in byte.

Casi di prova veritieri :

5 3 3 2

6 1 1 7

3 3 3 2

4 1 4 7

7 7 1 7

1 8 1 7

Casi di prova falsi :

6 4 3 2

8 8 1 7

3 4 3 2

Gelatina , 33 byte

‘»Ɠ_2<®
Ɠ©<7
:5+Ɠ>7$¤<1.4
Ɠ_ƓA2£Ŀ

Questo programma legge le coordinate come x2\nx1\ny2\ny1da STDIN. Provalo online!

Versione non competitiva

Sfortunatamente, l'interprete Jelly ha avuto un bug quando questa domanda è stata pubblicata. Tale errore gli ha impedito di accettare più di due argomenti della riga di comando. La versione più recente di Jelly può risolvere l'attività indicata in 23 byte .

⁶>7×5
_A+⁵>6$¤+¢’»⁶_2<⁵

Provalo online!

Python 2, 53 40

lambda x,y,p,q:y-2<q>=abs(x-p)+q/7+y/8*5

Il re ha coordinate (x, y)e il pedone (p, q).

Esistono tre casi significativi:

1. Il pedone è al livello 7 e il re al livello 8. Per catturare il pedone, il re deve trovarsi sullo stesso file o su uno adiacente.

   Risultato: q = 7 ⋀ y = 8 → |x - p| ≤ 1

2. Il pedone è al livello 7. Per catturare il pedone, il re deve trovarsi entro sei file.

   Risultato: q = 7 → |x - p| ≤ 6

3. Il pedone è di livello inferiore. Per catturare il pedone, il re deve essere in grado di raggiungere il quadrato della promozione al massimo una mossa dopo il pedone.

   Risultato: q < 7 → |x - p| ≤ q ⋀ y - 1 ≤ q

La mia soluzione è proprio queste condizioni compromesse. Spero non ci siano errori questa volta.

Prolog, 48 42 byte

Codice:

p(X,Y,P,Q):-Y-2<Q,Q>=abs(X-P)+Q//7+Y//8*5.

Esempi:

p(1,8,1,7).
true

p(3,4,3,2).
false

Prolog non è una brutta sfida per la maggior parte.

Modifica: salvato 6 byte passando alla formula utilizzata nella risposta Python 2 di grc .
Sfortunatamente Prolog non può concatenare i confronti come python può e la divisione intera è più lunga di 1 byte rispetto alla divisione float.

Provalo online qui

JavaScript (ES6), 52

(x,y,u,t,d=x>u?x-u:u-x)=>(d>=y?d:y-1)<=(d<2|t<7?t:6)

Spero di aver salvato byte non usando Math.abs, Math.min, Math.max

Il pedone alla riga 7 può sfuggire allo spostamento di 2 spazi, se e solo se il re non è in una colonna vicina - ecco perché c'è un controllo dprima di sostituire 7 con 6.

Test case da eseguire in console:

;[f(5,3,3,2),f(6,1,1,7),f(3,3,3,2),f(1,8,1,7),f(6,4,3,2),f(8,8,1,7),f(3,4,3,2)]

Risultato: [true, true, true, true, false, false, false]

Rubino, 50 byte

def f(a,b,c,d)(a-c).abs<=(d==7?6-b/8*5:d)&&b-d<2;end

Gli argomenti sono (re x, re y, pedone x, pedone y), tutti numeri interi.