_{Alternatywna nazwa: ChessMoveQ}

Biorąc pod uwagę listę do 32 elementów, z których każdy składa się z 4 elementów, oraz drugą listę z 4 elementami, określ, czy ruch wyszczególniony w drugim wejściu jest prawidłowym ruchem w szachy.

Pierwsza lista wskazuje pozycję wszystkich 32 elementów na planszy. Każdy element będzie podążał za strukturą <colour>, <piece-name>, <x-coord>, <y-coord>, np. ["W", "K", 5, 1], Która wskazuje, że biały król jest włączony 5, 1( e1na normalnej szachownicy). Wszystkie elementy pierwszego wejścia będą unikalne. <x-coord>i <y-coord>zawsze będzie wynosić od 1 do 8. Jednym z przykładów będzie:

[["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]]

który reprezentowałby zarząd:

Drugie wejście będzie się składać z tych samych struktur, co podlisty pierwszego, ale zamiast współrzędnych xiy wskazujących, gdzie jest kawałek, wskazują one, dokąd próbuje się przenieść.

W powyższym przykładzie prawidłowym ruchem może być ["W", "B", 4, 3](biskup przesuwa się o jedno pole do przodu i w lewo), a nieprawidłowy ruch może być taki, ["B", "R", 4, 1]jak wieża musiałaby przejść przez rycerza i pionka, aby dostać się na plac. Ponieważ ruch może odnosić się jednocześnie do wielu elementów, musisz sprawdzić, czy któryś z określonych elementów może wykonać ruch, a nie tylko jeden z nich. Na przykład pierwszy przykład dotyczy tylko jednego biskupa, ale nadal jest to ważny ruch. Jednak żadna czarna wieża nie może wykonać drugiego ruchu, więc jest nieważna.

Twoim zadaniem jest ustalenie, czy ruch wyszczególniony w drugim wejściu jest prawidłowym ruchem w szachy. Ważność reguły jest różna w zależności od elementu, który próbuje się poruszyć (kliknij nazwę elementu, aby zobaczyć schemat prawidłowych ruchów):

• Dowolny element : Żaden element nie może przejść na już zajęty kwadrat lub poza planszę, chyba że ten kwadrat jest zajęty przez element innego koloru. Na przykład biały kawałek może przejść na kwadrat zajmowany przez czarny kawałek, ale nie biały. Ponadto żadne pionki, z wyjątkiem Rycerzy, nie mogą poruszać się na pola, które są bezpośrednio zasłonięte przez inny element.
  • Przejście przez kawałek B do kwadratu C jest „bezpośrednio opór” na sztuki A jeśli jest bezpośrednio w prostej (prostopadłe lub skośne) linia pomiędzy B i C .
• Dowolny element : pozycja króla może również wpływać na ważność ruchu elementu. Jeśli którykolwiek z tych dwóch warunków jest spełniony, ruch jest nieprawidłowy:
  • Wystawiając króla na sprawdzenie, przesuwając pionek po tej samej stronie, co zagrożony król. Dotyczy to tylko sytuacji, gdy pionek przeciwny wykona ruch, a nie pionek przeciwny przesunie się, aby umieścić króla w ryzach.
  • Pozostawiając króla w ryzach, w takim przypadku musi się wyprowadzić z kręgu. Dlatego jeśli król jest w szachu, a ruch nakazuje ruch innego elementu, jest to ruch nieważny, chyba że ten drugi element uniemożliwia sprawdzenie. Kawałek może zapobiec czekowi na jeden z dwóch sposobów: albo bierze czek wykonujący kawałek, albo przeszkadza ścieżce między czekiem wykonującym a królem.
  • „Czek” to sytuacja, w której przeciwnik króla mógłby (jeśli nadejdzie ich kolej, aby wykonać ruch) legalnie przesunąć pionek na tego króla. Zasada ta nie ma zastosowania rekurencyjnego, tzn. Król jest w szachu, nawet jeśli ruch przeciwnika na tego króla pozostawiłby swojego króla w szachu.
• Pionki : pionek może poruszać się do przodu (tj. Do góry, jeśli jest biały, w dół, jeśli jest czarny) o jedno pole do niezajętego pola. Istnieją również trzy specjalne sytuacje:
  • Jeśli pion jeszcze się nie poruszył (możesz to ustalić za pomocą współrzędnej Y; białe pionki nie poruszyły się, jeśli ich współrzędna Y wynosi 2, czarne pionki nie poruszyły się, jeśli ich współrzędna Y wynosi 7), pionek wolno przesuwać się o dwa pola do przodu na wolne pole.
  • Jeśli pionek przeciwnika znajduje się po przekątnej przed pionkiem (tj. Na placu na północny zachód lub północny wschód od pionka, jeśli jest biały, lub na południowy zachód lub południowy wschód, jeśli jest czarny), pionek może poruszać się na zajmowanym polu.
  • Jeśli pionek przesunie się do ostatecznej współrzędnej Y (8 dla białych lub 1 dla czarnych) w normalnych zasadach szachowych, musi zostać awansowany na królową, wieżę, rycerza lub biskupa tego samego koloru. Do celów tego pytania wybór awansu nie ma znaczenia, czy ruch jest ważny, czy nie (i nie może być wyrażony w formacie wejściowym), ale ruchy pionków, które spowodowałyby awans, muszą być dozwolone.
• Biskupi : Biskupi mogą poruszać się między 1 a 8 kwadratami wzdłuż dowolnej ciągłej, nieprzeszkadzanej ścieżki międzysercowej (tj. Ukośnej).
• Rycerze : Rycerze mogą się poruszać wLkształcie składającym się z jednego z następujących (równoważnych) ruchów:
  • Pojedynczy kwadrat w dowolnym kierunku kardynalnym, następnie obrót o 90/270 °, a następnie ostatni ruch o 2 pola do przodu.
  • 2 kwadraty w dowolnym kierunku głównym, następnie obrót o 90/270 °, a następnie ostatni ruch o jedno pole do przodu.
  (Pamiętaj, że ścieżka rycerza nie może być blokowana przez interweniujące elementy, chociaż jej ostateczny kwadrat musi być nadal legalny).
• Gawrony : Gawrony mogą poruszać się między 1 a 8 kwadratami wzdłuż dowolnej ciągłej, nie zasłoniętej ścieżki głównej.
• Królowe : Królowe mogą poruszać się między 1 a 8 kwadratami wzdłuż dowolnej ciągłej ścieżki kardynalnej lub międzysercowej (tj. Ukośnej) bez przeszkód.
• Królowie : królowie poruszają się jak królowe, z tym, że ograniczają się do ruchu tylko o jedno pole na ruch (tzn. Król może poruszać się tylko na sąsiednie pola kardynalnie lub ukośnie). Przypominamy, że nie możesz wykonać ruchu, który pozostawia króla w ryzach; dlatego też nie możesz przenieść swojego króla na szach.

Reguły szachowe zawierają także specjalne ruchy zwane „roszowaniem” i „en passant”. Ponieważ jednak legalność tych ruchów zależy od historii gry, a nie tylko od bieżącej pozycji (a ponieważ castling wymaga przesunięcia dwóch elementów jednocześnie, co nie pasuje do formatu wejściowego), nie należy brać pod uwagę żadnego z tych ruchów istnieć (tj. ruch, który byłby rażący lub en passant, należy uznać za nielegalny).

Możesz wygenerować dowolne dwa różne wyniki, aby wskazać ważność ruchu, i możesz wprowadzić dane wejściowe wybraną metodą. Jeśli wolisz, możesz także wybrać indeksowanie 0 zamiast indeksowania 1 dla pozycji. To jest golf golfowy , więc wygrywa najkrótszy kod!

Przypadki testowe

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)

_{To wyzwanie zostało piaskownicy . Otrzymał recenzje, bez żadnego wyjaśnienia, więc i tak zdecydowałem się opublikować}

Python 2 (z python-szachy ),  141 138 134 133  132 132 bajtów

Bez robienia naprawdę interesującego kodu - ale może to może konkurować z językami golfa lub (ośmielę się o tym wspomnieć) Mathematica?

Uwaga: python-szachy jest PyPI pakiet zainstalować go na Pythonie 2.7.9+ z:
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)`)

Pełny program akceptujący wprowadzanie trzech elementów:

1. początek rekordu FEN - ciąg znaków zawierający pierwsze dwa pola. Ma to na celu określenie stanu płytki ORAZ, który kolor się porusza (ponieważ jest to informacja na wejściu w PO, podczas gdy pola od trzeciego do szóstego są „ustalone” przez PO, dlatego nie powinny być częścią wejścia)
2. nazwa utworu próbująca się poruszyć (jak podano w PO - jeden z PRNBQK)
3. plac, do którego nazwany kawałek próbuje przenieść gdzie a1jest 0, b1jest 1... a2jest8 ..., h8to 63,

Program generuje kod wyjścia, podając prawidłowe dane wejściowe:

• 1 jeśli ruch jest prawidłowy (program zgłosił błąd - z powodu podziału przez zero);
• 0 tak nie jest (program zakończył się normalnie)

(Nie) Wypróbuj online! (ponieważ pakiet python-szachy nie jest tam zainstalowany, a TIO nie zezwala na łączność z Internetem, więc kod instalacyjny pip w nagłówku nie będzie działał).

Należy pamiętać, że operator moc sprawia, że w Pythonie 1**1 == 1**0 == 0**0 == 1, ale 0**1 == 0
... stąd 1/0**1rodzi dzielenie przez zero błąd podczas 1/1**1, 1/1**0i 1/0**0wszystko się uda
(... i to w Pythonie Falsei Truezrównać się 0i 1odpowiednio).

Regex (PCRE2), 931 925 837 bajtów

To rozwiązanie odbiega od opisu problemu, ponieważ dwa wyrażenia tablicy są przekazywane do wyrażenia regularnego, zamiast jednego stanu tablicy i ruchu. Przesunięcie to wynika z różnicy między dwoma stanami planszy. Zadałem więc programowi TIO, aby wziął przypadki testowe w formacie podanym w tym pytaniu, znajdował wszystkie wystąpienia opisanego elementu na planszy i za każdym razem próbował przenieść go do miejsca docelowego i ocenić wyrażenie regularne z tą możliwością stwierdzenie, czy wyrażenie regularne zgłasza je jako prawidłowe. Jeśli to nie w porządku, daj mi znać; możliwe jest zaimplementowanie wyrażenia regularnego jako pozycja + ruch, ale byłoby ono znacznie mniej eleganckie i wymagałoby poważnego refaktoryzacji.

Tablica jest reprezentowana w formacie 8 × 8 ASCII, gdzie białe elementy są wielkie, a czarne małe: P awn, k N ight, B ishop, R ook, Q ueen, K ing. Strona czarnych (8. ranga) znajduje się na górze, a strona biała (1. ranga) na dole. Każda ranga jest oddzielona nową linią, a puste kwadraty są oznaczone jako -. Dwie pozycje na planszy są oddzielone dodatkową linią.

Rzeczywistym celem tego projektu jest walidacja całych gier, a nie tylko pojedynczych ruchów. Poniżej znajduje się aktualny stan postępu.

()?(?>|((.|
(?=.)){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)))

Wypróbuj online!

Dość wydrukowane i częściowo nie zmienione (bezwzględne rerefy zmieniają się na względne, a grupy przechwytujące zmieniają się na nie przechwytujące, lub w niektórych przypadkach atomowe ze względu na szybkość):

# 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 bajtów przy użyciu nieatomowych wywołań podprogramów, tym samym przekierowując z PCRE1 na PCRE2

Powyższa wersja została zmodyfikowana, aby nie pozwalała na bierność lub roszowanie, ale pełny projekt znajduje się obecnie w stanie, w którym zatwierdza każdy rodzaj ruchu, zaczynając od początkowego stanu planszy (który musi być standardową pozycją początkową szachów - Chess960 nie jest przynajmniej obsługiwane). Egzekwowane są pełne zasady en passant i castling.

Oto przykładowa gra zatwierdzona przez pełne wyrażenie regularne (PCRE1 - jeszcze nieukierowane) [regex101.com] .

Nieprawidłowy ruch spowoduje, że każda kolejna pozycja planszy nie będzie dopasowana / podświetlona. Wykrywanie mat / impas, a zatem wykrywanie zwycięzcy (lub remis), nie zostało jeszcze zaimplementowane; dlatego ostateczny stan tablicy w tym przykładzie nie jest podświetlony.

Oto program C / C ++, który konwertuje notację algebraiczną na format rozpoznawany przez to wyrażenie regularne. Notacja algebraiczna musi być obecnie umieszczona w formie tablicy wbudowanej w kodzie źródłowym, z osobnymi ciągami dla każdego ruchu, ale odczytywaniem go jako pojedynczego ciągu ze standardowego wejścia lub argumentu wiersza poleceń, z całą sekwencją ruchów oddzieloną spacjami i numery ruchów zakończone kropkami, są planowane.

Zacząłem też od wyrażenia regularnego, które potwierdza pełną grę wyłącznie w algebraicznej notacji szachowej, z domyślną domyślną pozycją początkową. Wszystko czego potrzebuje to pusta „zdrapka” dołączona na końcu wejścia (po liście ruchów). Jestem prawie pewien, że można to w pełni wdrożyć i planuję kiedyś to zakończyć.