Dovresti scrivere un programma o una funzione che riceve una stringa che rappresenta una scacchiera con solo pedine come input e output o restituisce se è possibile catturare sulla board.

L'input è in una notazione simile a una FEN che descrive le posizioni di pedine bianche e nere senza altri pezzi presenti. Dovresti decidere se esiste una pedina che può catturare una pedina nemica.

Ogni rango è descritto, iniziando dal rango 8 e finendo con il rango 1; all'interno di ogni rango, i contenuti di ciascun quadrato sono descritti dal file "a" al file "h". Ogni pedone è identificato da una singola lettera (pedone bianco = "P", pedone nero = "p",). I quadrati vuoti vengono annotati usando le cifre da 1 a 8 (il numero di quadrati vuoti) e "/" separa i ranghi. (parzialmente tratto da Wikipedia)

Per esempio

8/pppppppp/8/8/4P3/8/PPPP1PPP/8

descrive la scheda

--------

pppppppp


    P   

PPPP PPP

--------

Una pedina bianca può catturarne una nera se quella nera è posizionata diagonalmente in alto da essa (il nero è su-sinistra o su-destra) e una pedina nera può catturarne una bianca se quella bianca è diagonalmente sotto di essa (il bianco è in basso a sinistra o in basso a destra). Nessun'altra mossa di cattura ( en passant ) dovrebbe essere presa in considerazione.

Ingresso

• Una stringa simile alla FEN composta dai caratteri 12345678pP/.
• L'input descrive le pedine di una posizione di gioco di scacchi valida. Ciò significa (tra gli altri vincoli più complessi) ci saranno al massimo 8 pedine per ogni lato e nessuna pedina nei ranghi 1 e 8.

Produzione

• Se esiste una possibile acquisizione per entrambe le parti, dovresti generare un valore di verità e un valore di falsa in caso contrario.

Esempi

Ingressi con output sincero (uno per riga)

8/7p/6P1/8/8/8/8/8
8/8/p7/1P6/3P3p/8/8/8
8/2P5/8/4P1p1/2p2P2/3p4/3p1P2/8
8/P7/8/5P2/2pp4/3P2p1/3pP3/8
8/P7/p7/p1P1P3/1P3p2/8/1p6/8
8/4p1P1/2P2P1P/2p1pPpp/8/6P1/pP1p4/8

Ingressi con uscita falsy (uno per riga)

8/8/8/8/8/8/8/8
8/7P/6p1/8/8/8/8/8
8/7p/7P/8/8/8/8/8
8/pppppppp/8/8/8/8/PPPPPPPP/8
8/p7/8/1p6/5P2/8/8/8
8/p7/P7/2P1p1p1/2p5/8/PP6/8

Questo è il codice golf, quindi vince l'ingresso più breve.

Pyth, 25 byte

/smC,>JsXz`M9*LN9dJ,8T"Pp

Suite di test

passi:

Trasforma l'input sostituendo le cifre con il numero equivalente di virgolette ( N). Questo è salvato in J. Quindi tagliamo i primi 8 o 10 caratteri e comprimiamo il risultato con l'originale. Qualsiasi coppia di acquisizione verrà trasformata in "Pp", quindi troviamo il conteggio di quella stringa nell'elenco risultante. Questo è l'output.

Come bonus, questo in realtà conta il numero di acquisizioni possibili nell'input.

Retina , 33 29 byte

T`d`w
)`\d
$0.
_

p.{7}(..)?P

Per eseguire il codice da un singolo file, utilizzare il -sflag.

Dovrebbe essere facilmente battibile da qualcosa come Perl in cui l'espansione delle cifre in stringhe di spazi (o altri caratteri) non occupa 17 byte.

L'output è positivo (verità) se esiste una possibile acquisizione e zero (falsa) se non lo è.

Spiegazione

T`d`w
)`\d
$0.

Questo è un ciclo di due fasi. Il primo è uno stadio di traslitterazione che diminuisce ogni cifra e trasforma gli zeri in caratteri di sottolineatura. Perché? Perché ded wespandere le seguenti due righe:

0123456789
_0123456789AB...YZab...yz

Se l'insieme target di uno stadio di traslitterazione è più lungo dell'insieme sorgente, i caratteri estranei vengono ignorati, quindi il comportamento in declino (onestamente, è stata solo una fortuna che ho deciso di mettere il carattere di sottolineatura davanti alle cifre quando si espandeva la wclasse di caratteri) .

Quindi il secondo stadio è un rimpiazzo, che aggiunge un .a ogni cifra. Ciò significa che per ogni cifra n, nsi aggiungono periodi prima cifra è trasformato in una sottolineatura.

_
<empty>

Questo elimina solo i caratteri di sottolineatura.

p.{7}(..)?P

Finalmente troviamo le partite. Dato che stiamo ignorando en passant, le acquisizioni sono possibili solo se c'è una pe poi una Pdiagonale sotto di essa. Nella stringa lineare, ciò significa semplicemente che ci devono essere 7 o 9 caratteri tra i due pedoni. Questo corrisponde a .{7}(..)?(cioè abbina 7 caratteri e poi, facoltativamente, abbina altri due).

Una tale fase di match restituisce il numero di match trovati.

Javascript, 272 caratteri

function h(t){b=[[]];for(i=-1;i++<7;){c=0;b.push(l=[]);for(j=-1;j++<7;){o=t.split('/')[i][j];switch(o){case'P':l[c++]=-1;break;case'p':l[c++]=1;break;default:c+=parseInt(o);}}}b.push([]);for(i=1;i<9;i++)for(j=0;j<8;j++)if((p=b[i][j])&&(b[i+p][j-1]||b[i+p][j+1]))return 1;}

Probabilmente c'è molto margine di miglioramento.

Rubino, 145 123 46 byte

->b{b.gsub(/\d/){|x|?.*x.to_i}=~/p.{7}(..)?P/}

Non so perché non ci abbia pensato in primo luogo. È molto più breve e anche abbastanza leggibile.

Ecco il test: http://ideone.com/Gzav8N

Il vecchio approccio:

->b{l={}
r=p
b.split(?/).map{|s|c={}
i=0
s.chars.map{|x|n=x.to_i;c[i]=x;i+=n<1?1:n;x==?P&&r||=l[i-2]==?p||l[i]==?p}
l=c}
r}

Test online: http://ideone.com/9L01lf , versione prima del golf: http://ideone.com/CSmqlW

Una cronologia delle modifiche è disponibile qui .

ES6, 64 byte

Un conteggio di byte appropriato, se dura!

f=s=>/p.{7}(..)?P/.test(s.replace(/\d/g,n=>"        ".slice(-n)))

In realtà ho pensato a questa soluzione senza prima leggere le altre risposte, ma non mi dispiacerà se non mi credi.

Perl 5, 30 byte

29, più 1 per -peanziché-e

s/\d/1x$&/ge;$_=/p.{7}(..)?P/

Una copia del Perl della risposta di Ruby di w0lf .

PHP, 94 87 80 byte

for(;$i++<8;)$t[$i]=$s.=" ";echo preg_match("#p.{7}(..)?P#",strtr($argv[1],$t));

Quel loop + strtrè molto più breve rispetto preg_replace_callbacka str_pad.

Gelatina, 88 84 79 72 69 65 64 63 60 byte

Sicuramente margini di miglioramento. Non competitivo perché Jelly è stata creata prima della domanda. Grazie a @lirtosiast per avermelo detto!

ØDṖḊ
”_x
e1£¬
1£iЀ2Ŀ€
x"3Ŀ€;"ÇFṣ”/
w€⁾pPn0
5ĿUŒDÇ
5ĿŒD6ĿoÇS