_{Nome alternativo: ChessMoveQ}

Dato un elenco di massimo 32 elementi, ciascuno composto da 4 elementi e un secondo elenco con 4 elementi, determina se la mossa dettagliata nel secondo input è una mossa di scacchi valida.

Il primo elenco indica la posizione di tutti i 32 pezzi sulla scacchiera. Ogni elemento seguirà la struttura <colour>, <piece-name>, <x-coord>, <y-coord>, ad esempio ["W", "K", 5, 1], che indica che il re bianco è acceso 5, 1( e1su una normale scacchiera). Tutti gli elementi del primo input saranno unici. <x-coord>e <y-coord>sarà sempre compreso tra 1 e 8. Un esempio potrebbe essere:

[["B", "K", 3, 8], ["B", "Q", 1, 5], ["B", "N", 4, 7], ["B", "N", 7, 8],
 ["B", "B", 2, 4], ["B", "R", 4, 8], ["B", "R", 8, 8], ["B", "P", 1, 7],
 ["B", "P", 2, 7], ["B", "P", 3, 6], ["B", "P", 5, 6], ["B", "P", 6, 7],
 ["B", "P", 7, 7], ["B", "P", 8, 7], ["W", "K", 5, 1], ["W", "Q", 6, 3],
 ["W", "N", 3, 3], ["W", "B", 5, 2], ["W", "B", 6, 4], ["W", "R", 1, 1],
 ["W", "R", 8, 1], ["W", "P", 1, 3], ["W", "P", 2, 2], ["W", "P", 3, 2],
 ["W", "P", 4, 4], ["W", "P", 6, 2], ["W", "P", 7, 2], ["W", "P", 8, 3]]

che rappresenterebbe il consiglio:

Il secondo input sarà costituito dalle stesse strutture delle liste secondarie del primo, ma anziché dalle coordinate xey che indicano dove si trova il pezzo, indicano dove sta cercando di spostarsi.

Per l'esempio sopra, potrebbe essere una mossa valida ["W", "B", 4, 3] (il vescovo si sposta di una casella in avanti e a sinistra) e una mossa non valida potrebbe essere ["B", "R", 4, 1]la torre che dovrebbe attraversare il cavaliere e il pedone per arrivare alla piazza. Poiché la mossa può riferirsi a più pezzi alla volta, è necessario verificare se uno dei pezzi specificati può effettuare la mossa, non solo uno di essi. Ad esempio, il primo esempio è valido per un solo vescovo, ma è ancora una mossa valida. Tuttavia, nessuna torre nera può eseguire la seconda mossa, quindi non è valida.

Il tuo compito è determinare se la mossa dettagliata nel secondo input è una mossa di scacchi valida. La validità di una regola varia a seconda del pezzo che tenta di muoversi (fare clic sul nome del pezzo per un diagramma delle mosse valide):

• Qualsiasi pezzo : nessun pezzo può spostarsi su un quadrato già occupato, o fuori dal tabellone, a meno che quel quadrato non sia occupato da un pezzo dell'altro colore. Ad esempio, un pezzo bianco può spostarsi su un quadrato occupato da un pezzo nero, ma non su un pezzo bianco. Inoltre, nessun pezzo, ad eccezione dei Cavalieri, può spostarsi in quadrati che sono ostruiti direttamente da un altro pezzo.
  • Un'azione di pezzo B a piazzare C è "direttamente ostacolato" di pezzo A se A è direttamente in linea retta (ortogonale o diagonale), tra B e C .
• Qualsiasi pezzo : la posizione del re può anche influenzare la validità della mossa di un pezzo. Se una di queste due condizioni è soddisfatta, lo spostamento non è valido:
  • Esponendo il re per controllare, spostando un pezzo sullo stesso lato del re in via di estinzione. Questo si applica solo se un pezzo non avversario fa la mossa, piuttosto che un pezzo avversario che si muove per mettere sotto controllo il re.
  • Lasciare il re sotto controllo, nel qual caso deve spostarsi fuori controllo. Pertanto, se il re è sotto controllo e la mossa impone che un altro pezzo si muova, si tratta di una mossa non valida, a meno che l'altro pezzo non impedisca il controllo. Un pezzo può impedire il controllo in due modi: o prende il pezzo eseguendo il controllo, oppure ostacola il percorso tra il pezzo che esegue il controllo e il re.
  • Un "check" è una situazione in cui l'avversario del re potrebbe (se fosse il suo turno di muoversi) legalmente spostare un pezzo su quel re. Questa regola non si applica in modo ricorsivo, cioè un re è sotto controllo anche se la mossa dell'avversario su quel re lascerebbe il proprio re sotto controllo.
• pedine : Un pedone può muovere in avanti (cioè verso l'alto se bianchi, verso il basso se il nero) un quadrato per una casella libera. Esistono anche tre situazioni speciali:
  • Se il pedone non si è ancora mosso (puoi determinarlo usando la coordinata Y; i pedoni bianchi non si sono mossi se la loro coordinata Y è 2, i pedoni neri non si sono mossi se la loro coordinata Y è 7), il pedone è consentito spostare due quadrati in avanti verso un quadrato non occupato.
  • Se c'è un pezzo di un avversario in diagonale davanti al pedone (cioè sul quadrato a nord-ovest o nord-est del pedone se è bianco, oppure a sud-ovest o sud-est se è nero), il pedone è autorizzato a spostarsi sulla piazza occupata in questione.
  • Se una pedina si sposta sull'ultima coordinata Y (8 per il bianco o 1 per il nero) nelle normali regole degli scacchi, deve essere promossa a una regina, torre, cavaliere o vescovo dello stesso colore. Ai fini di questa domanda, la scelta della promozione è irrilevante se la mossa è valida o meno (e non può essere espressa nel formato di input), ma devono essere consentite le mosse di pedone che porterebbero alla promozione.
• Vescovi : i vescovi possono spostarsi tra 1 e 8 quadrati lungo qualsiasi percorso intercardinale (cioè diagonale) continuo non ostruito.
• Cavalieri : i cavalieri possono muoversi in unaLforma, costituita da una delle seguenti mosse (equivalenti):
  • Un singolo quadrato in qualsiasi direzione cardinale, seguito da un giro di 90/270 °, seguito da una mossa finale di 2 quadrati in avanti.
  • 2 quadrati in qualsiasi direzione cardinale, seguiti da un giro di 90/270 °, seguito da una mossa finale di un singolo quadrato in avanti.
  (Ricorda che il percorso di un cavaliere non può essere bloccato da pezzi intermedi, anche se la sua casella finale deve ancora essere legale.)
• Corvi : i corvi possono muoversi tra 1 e 8 quadrati lungo qualsiasi percorso cardinale continuo non ostruito.
• Regine : le regine possono spostarsi tra 1 e 8 quadrati lungo qualsiasi percorso continuo cardinale o intercardinale (cioè diagonale) non ostruito.
• Re : i re si muovono come regine, tranne per il fatto che si limitano a muovere solo un quadrato per mossa (cioè un re può spostarsi solo su quadrati cardinali o diagonali adiacenti). Come promemoria, non puoi fare una mossa che lasci il tuo re sotto controllo; quindi non puoi nemmeno controllare il tuo re.

Le regole degli scacchi contengono anche mosse speciali chiamate "castling" e "en passant". Tuttavia, poiché la legalità di queste mosse dipende dalla storia del gioco, non solo dalla posizione corrente (e poiché il castling richiede di spostare due pezzi contemporaneamente, che non si adattano al formato di input), non dovresti considerare nessuna di queste mosse esistere (cioè una mossa che sarebbe castling o en passant dovrebbe essere considerata illegale).

È possibile produrre due risultati distinti per indicare la validità di uno spostamento e si può prendere l'input con il metodo desiderato. Puoi anche scegliere l'indicizzazione 0 anziché 1 per le posizioni, se preferisci. Questo è un codice-golf , quindi vince il codice più corto!

Casi test

Board
Move => Output (Reason)

[["B", "K", 3, 8], ["B", "Q", 1, 5], ["B", "N", 4, 7], ["B", "N", 7, 8], ["B", "B", 2, 4], ["B", "R", 4, 8], ["B", "R", 8, 8], ["B", "P", 1, 7], ["B", "P", 2, 7], ["B", "P", 3, 6], ["B", "P", 5, 6], ["B", "P", 6, 7], ["B", "P", 7, 7], ["B", "P", 8, 7], ["W", "K", 5, 1], ["W", "Q", 6, 3], ["W", "N", 3, 3], ["W", "B", 5, 2], ["W", "B", 6, 4], ["W", "R", 1, 1], ["W", "R", 8, 1], ["W", "P", 1, 3], ["W", "P", 2, 2], ["W", "P", 3, 2], ["W", "P", 4, 4], ["W", "P", 6, 2], ["W", "P", 7, 2], ["W", "P", 8, 3]]
["W", "R", 8, 2] => True (The rook on h1 can move forward one)

[['B', 'K', 6, 8], ['B', 'Q', 1, 7], ['B', 'N', 1, 3], ['B', 'N', 7, 1], ['B', 'B', 8, 8], ['B', 'B', 2, 5], ['B', 'R', 4, 3], ['B', 'R', 1, 5], ['B', 'P', 5, 5], ['B', 'P', 7, 2], ['B', 'P', 5, 7], ['B', 'P', 5, 6], ['B', 'P', 4, 4], ['W', 'K', 7, 3], ['W', 'Q', 3, 2], ['W', 'N', 4, 8], ['W', 'N', 7, 5], ['W', 'B', 1, 1], ['W', 'B', 8, 1], ['W', 'R', 1, 8], ['W', 'R', 3, 7], ['W', 'P', 8, 2], ['W', 'P', 6, 3], ['W', 'P', 4, 2], ['W', 'P', 1, 4], ['W', 'P', 8, 7]]
['W', 'N', 1, 5] => False (Neither knight to move to a5 from where they are)

[['B', 'K', 7, 3], ['B', 'Q', 2, 4], ['B', 'N', 5, 2], ['B', 'N', 1, 6], ['B', 'B', 7, 7], ['B', 'B', 1, 8], ['W', 'K', 7, 1], ['W', 'Q', 6, 1], ['W', 'N', 5, 6], ['W', 'N', 3, 3], ['W', 'B', 2, 2], ['W', 'B', 6, 5]]
['B', 'K', 8, 3] => False (The white bishop would put the king in check)

[['B', 'K', 7, 6], ['B', 'Q', 8, 3], ['B', 'N', 7, 7], ['B', 'N', 8, 7], ['B', 'B', 2, 2], ['B', 'B', 3, 8], ['B', 'R', 1, 1], ['B', 'R', 1, 6], ['B', 'P', 8, 5], ['B', 'P', 4, 3], ['B', 'P', 8, 6], ['W', 'K', 7, 8], ['W', 'Q', 7, 2], ['W', 'N', 5, 1], ['W', 'N', 4, 6], ['W', 'B', 1, 2], ['W', 'B', 2, 6], ['W', 'R', 4, 4], ['W', 'R', 3, 6], ['W', 'P', 5, 2], ['W', 'P', 6, 2]]
['B', 'N', 5, 8] => False (The white queen currently has the king in check, and this move doesn't prevent that)

[['B', 'K', 7, 6], ['B', 'Q', 8, 3], ['B', 'N', 7, 7], ['B', 'N', 8, 7], ['B', 'B', 2, 2], ['B', 'B', 3, 8], ['B', 'R', 1, 1], ['B', 'R', 1, 6], ['B', 'P', 8, 5], ['B', 'P', 4, 3], ['B', 'P', 8, 6], ['W', 'K', 7, 8], ['W', 'Q', 7, 2], ['W', 'N', 5, 1], ['W', 'N', 4, 6], ['W', 'B', 1, 2], ['W', 'B', 2, 6], ['W', 'R', 4, 4], ['W', 'R', 3, 6], ['W', 'P', 5, 2], ['W', 'P', 6, 2]]
['B', 'N', 7, 5] => True (The king is in check, and the knight blocks that)

[['B', 'K', 8, 3], ['B', 'Q', 6, 5], ['B', 'N', 7, 8], ['B', 'N', 3, 7], ['B', 'B', 4, 1], ['B', 'B', 1, 1], ['W', 'K', 7, 7], ['W', 'Q', 7, 1], ['W', 'N', 2, 2], ['W', 'N', 1, 3], ['W', 'B', 3, 5]]
['B', 'B', 2, 2] => True (takes the white knight)

[['B', 'K', 6, 1], ['B', 'Q', 6, 2], ['W', 'K', 8, 1]]
['B', 'Q', 7, 1] => True (Smallest checkmate possible, in terms of bounding box)

_{Questa sfida è stata sandbox . Ha ricevuto i voti negativi, senza alcuna spiegazione, quindi ho deciso di pubblicarlo comunque}

Python 2 (con python-chess ),  141 138 134 133  132 byte

Senza fare uno dei codici davvero interessanti, ma forse questo può competere con le lingue del golf o (oserei menzionarlo) Mathematica?

Nota: python-chess è un PyPI pacchetto di installazione su Python 2.7.9+ con:
python -m pip install python-chess)

import chess
a,p,n=input()
S=chess.Board(a+' - - 0 1')
for m in S.legal_moves:1/(m.to_square!=n)**(`p`in`S.piece_at(m.from_square)`)

Un programma completo che accetta input di tre elementi:

1. l'inizio di un record FEN - la stringa contenente i primi due campi. Questo per definire lo stato della scheda E quale colore si sta muovendo (poiché questa è l'informazione nell'input nell'OP, mentre i campi da tre a sei sono "fissati" dall'OP quindi non dovrebbe far parte dell'input)
2. il nome del pezzo che tenta di muoversi (come indicato nell'OP - uno di PRNBQK )
3. il quadrato in cui il pezzo nominato sta tentando di spostarsi dove a1è 0, b1è 1, ... a2è8 , ..., h8è 63,

Il programma emette tramite il suo codice di uscita dato un input valido:

• 1 se lo spostamento è valido (il programma ha generato un errore - a causa della divisione per zero);
• 0 non lo è (il programma è uscito normalmente)

(Non) Provalo online! (poiché il pacchetto python-chess non è installato lì e TIO non consente la connettività Internet, quindi il codice di installazione pip nell'intestazione non funzionerà).

Si noti che l'operatore di potenza in Python fa 1**1 == 1**0 == 0**0 == 1ma 0**1 == 0
... quindi 1/0**1solleva una divisione per zero mentre 1/1**1, 1/1**0e 1/0**0tutti riuscire
(... e che in Python Falsee Trueequivalere a 0e 1rispettivamente).

Regex (PCRE2), 931 925 837 byte

Questa soluzione si discosta dall'affermazione del problema in quanto due stati di board vengono passati al regex, anziché uno stato di board e uno spostamento. La mossa è dedotta dalla differenza tra i due stati del board. Quindi ho fatto il lavoro del programma TIO per prendere i casi di test nel formato fornito da questa domanda, trovare tutte le istanze del pezzo descritto sulla scheda e, con ognuna, provare a spostarlo nella posizione di destinazione e valutare il regex con quella possibilità, scoprendo se ne sono stati segnalati validi da regex. Se questo non va bene, fammi sapere; è possibile implementare una regex come position + move, ma sarebbe molto meno elegante e richiederebbe un serio refactoring.

La scheda è rappresentata in 8 × 8 ASCII dove pezzi bianchi sono maiuscoli e nero sono minuscole: P awn, k N estra, B IShop, R ook, Q ueen, K ing. Il lato nero (l'8 ° rango) è in alto e il lato bianco (il 1 ° rango) è in basso. Ogni rango è separato da una nuova riga e i quadrati vuoti sono contrassegnati come -. Le due posizioni del consiglio di amministrazione sono separate da una nuova riga aggiuntiva.

L'obiettivo reale di questo progetto è convalidare interi giochi, non solo singole mosse. Vedi sotto per lo stato attuale del progresso.

()?(?>|((.|
(?=.)){2})((?=(\X{72})-))((?=(?(1)[-a-z]|[-A-Z])))((?5)(?(?=(.*
)
)[qnrb]|p))((?5)(?(?=(?8){8}
)[QNRB]|P)))(?>((.)(?=(?5)\11)|(?(m)$)((?(1)(-(?=(?9))(?=(?3){8}((?3){9})?P(?4))(?(-1)(?=(?8){4}
))|[a-z](?=(?9))(?=(?3){7}(?2)?P(?4)))|(p(?4)((?=(?3){8}((?3){9})?-(?7))(?(-1)(?=(?8){7}
))|(?=(?3){7}(?2)?[A-Z](?7)))))|(?<e>(?6).)?(?=(?i:(?|(?(e)|(B|Q))(?27)(?(e)(B|Q))|(?(e)|(R|Q))(?31)(?(e)(R|Q))|(?(e)|(N))(?34)(?(e)(N))|(?(e)|(K))(?35)?(?(e)(K))))(?(e)(?<=(?!(?6)).)(?4)|(?6).(?5)\19))(?(e)(?=(?5)\20)|(?!(?6)).(?4)))(?<m>)|(?(+1)$)(.))+
)+\k<m>
(?!\X{0,70}((?(1)p|k)(?=(?3){7}(?2)?(?(1)K|P))|(?i:(?<E>(?!(?6))K)?((?(E)|((?6)[BQ]))(()?((?(-1)-)(?3){7}(?(-2)(?2)))+)(?(E)(?-4))|(?(E)|((?6)[RQ]))(-*|((?(-1)-)(?3){8})+)(?(E)(?-3))|(?(E)|((?6)N))((?<=..)(?2){3}|(?=.)(?2){5}|(?2){8}(?2)?)(?(E)(?-2)))(?(E)|(?&E))|K((?3){7,9})?K)))

Provalo online!

Abbastanza stampato e parzialmente non golfato (backref assoluti cambiati in relativi e gruppi di acquisizione cambiati in non-cattura, o in alcuni casi atomici per la velocità):

# Chess move validation regex (PCRE)
()?                 # decide whether to evaluate this as white's or black's move; \1 set = white, \1 unset (NPCG) = black
(?>|                # subroutines:
  ((.|\n(?=.)){2})                  # (?3) = for moving within the board, without wrapping to the next board, (?2) = (?3){2}
  ((?=                              # (?4) = assert that position of just-consumed piece is vacated on the next turn
    (\X{72})                        # (?5) = skip to the position of the just-consumed piece on the next turn
  -))
  ((?=(?(1)[-a-z]|[-A-Z])))         # (?6) = assert that the piece at the current position belongs to the current player's opponent or is empty
  ((?5)(?(?=(.*\n)\n)[qnrb]|p))     # (?7) = black pawn that might be promoted, (?8) = .*\n
  ((?5)(?(?=(?8){8}\n)[QNRB]|P))    # (?9) = white pawn that might be promoted
)
(?>
  (?>
    # Handle squares that don't change (empty->empty or pieces that doesn't move)
    (.)(?=(?5)\g{-1}) |
    # Handle a piece that moves (and optionally captures an enemy piece)
    (?(m)$)  # allow only one move to be made per turn
    (?>
      (?(1)
        (?:                                                         # white pawn
            -  (?=(?9))(?=(?3){8}((?3){9})?P(?4))(?(-1)(?=(?8){4}\n)) |   # move 1 or 2 spaces forward
          [a-z](?=(?9))(?=(?3){7}(?2)?     P(?4))                     )   # capture diagonally
      |
        (?:p(?4)(?:                                                 # black pawn
          (?=(?3){8}((?3){9})?  -  (?7))(?(-1)(?=(?8){7}\n)) |            # move 1 or 2 spaces forward
          (?=(?3){7}(?2)?     [A-Z](?7)) )                   )            # capture diagonally
      ) |
      # bishops, rooks, queens, knights, or kings
      (?<e>(?6).)?   # decide between scanning forward (<e> is unset) or backwards (<e> is captured)
      (?=
        (?i:
          (?|
            (?(e)|(B|Q)) (?&B)  (?(e)(B|Q)) | # bishops or queens
            (?(e)|(R|Q)) (?&R)  (?(e)(R|Q)) | # rooks or queens
            (?(e)|(N  )) (?&N)  (?(e)(N  )) | # knights
            (?(e)|(K  )) (?&K)? (?(e)(K  ))   # kings
          )
        )
        (?(e)(?<=(?!(?6)).)(?4)|(?6).(?5)\g{-2})   # verify that the piece moved, and optionally captured piece, are of the correct color
      )
      (?(e)(?=(?5)\g{-1})|(?!(?6)).(?4))   # verify that the piece moved is the same type and color at its destination in the next turn's board position
    )(?<m>) |
    (?(+1)$)(.)  # handle the destination/source square that a piece moved to/from (only allow matching one of these per turn)
  )+\n
)+
\k<m>         # assert that a move has taken place
\n
# don't allow moving into check  
(?!
  \X{0,70}
  (?:
    # pawns (capture diagonally)
    (?(1)p|k)(?=(?3){7}(?2)?(?(1)K|P)) |
    # bishops, rooks, queens, knights, or kings
    (?i:
      (?<E>(?!(?6))K)?   # decide between scanning forward (<E> is unset) or backwards (<E> is captured)
      (?:
        (?(E)|((?6)[BQ])) (?<B>()?((?(-1)-)(?3){7}(?(-2)(?2)))+)         (?(E)(?-4)) | # bishops or queens
        (?(E)|((?6)[RQ])) (?<R>-*|((?(-1)-)(?3){8})+)                    (?(E)(?-3)) | # rooks or queens
        (?(E)|((?6) N  )) (?<N>(?<=..)(?2){3}|(?=.)(?2){5}|(?2){8}(?2)?) (?(E)(?-2))   # knights
      )
      (?(E)|(?&E)) |
      K(?<K>(?3){7,9})?K   # kings
    )
  )
)

-88 byte utilizzando chiamate di subroutine non atomiche, quindi effettuando il retargeting da PCRE1 a PCRE2

La versione sopra è stata modificata per non consentire l'en passant o il castling, ma l'intero progetto è attualmente in uno stato in cui convalida ogni tipo di mossa, a partire dallo stato iniziale della scacchiera (che deve essere la posizione di partenza standard degli scacchi - Chess960 non è supportato, ma almeno). Vengono applicate le regole complete di en passant e castling.

Ecco un gioco di esempio convalidato da regex completo (PCRE1 - non ancora retargeted) [regex101.com] .

Una mossa non valida comporterà la mancata corrispondenza / evidenziazione di ogni successiva posizione della scacchiera. Il rilevamento di scacco matto / stallo, e quindi il rilevamento di chi è il vincitore (o se è un pareggio), non è ancora implementato; ecco perché lo stato della board finale in questo esempio non è evidenziato.

Ecco un programma C / C ++ che converte la notazione algebrica nel formato riconosciuto da questa regex. La notazione algebrica attualmente deve essere messa sotto forma di un array inline nel codice sorgente, con stringhe separate per ogni mossa, ma leggendola come stringa singola da stdin o argomento della riga di comando, con l'intera sequenza di mosse separate da spazi e sono previsti numeri di mossa con punto terminato.

Ho anche iniziato con una regex che convalida un gioco completo puramente in notazione algebrica di scacchi, con la posizione iniziale standard implicita. Tutto ciò di cui ha bisogno è un "scratch board" vuoto aggiunto alla fine dell'input (dopo l'elenco delle mosse). Sono abbastanza sicuro che sia possibile implementarlo per intero e ho intenzione di finirlo un giorno.