_{다른 이름 : ChessMoveQ}

각각 4 개의 요소로 구성되는 최대 32 개의 요소 목록과 4 개의 요소로 구성된 두 번째 목록이 제공되면 두 번째 입력에 자세히 설명 된 이동이 유효한 체스 이동인지 판별하십시오.

첫 번째 목록은 보드에서 32 개 조각의 위치를 ​​나타냅니다. 각 요소의 구성을 따를 <colour>, <piece-name>, <x-coord>, <y-coord>같은 ["W", "K", 5, 1]흰색 왕에 있음을 나타내는, 5, 1( e1통상 체스 보드). 첫 번째 입력의 모든 요소는 고유합니다. <x-coord>그리고 <y-coord>항상 한 가지 예는 것 1과 8 사이에있을 것입니다 :

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

보드를 나타냅니다 :

두 번째 입력은 첫 번째 입력의 하위 목록과 동일한 구조로 구성되지만 조각이있는 위치를 나타내는 x 및 y 좌표 대신 이동하려는 위치를 나타냅니다.

위의 예에서, 유효한 이동은 ["W", "B", 4, 3](주교가 한 칸 앞으로 왼쪽으로 이동), ["B", "R", 4, 1]루크가 기사를 통해 이동해야하고 폰이 사각형으로 이동하는 것처럼 유효하지 않은 이동이 될 수 있습니다 . 이동이 시간에 여러 조각으로 참조 할 수, 당신은 여부를 테스트해야합니다 모든 지정된 조각이 이동, 그 중 단지 하나를 만들 수 있습니다. 예를 들어, 첫 번째 예는 한 주교에게만 유효하지만 여전히 유효한 이동입니다. 그러나 블랙 루크가 두 번째 이동을 수행 할 수 없으므로 유효하지 않습니다.

당신의 임무는 두 번째 입력에서 자세하게 이동이 유효한 체스 이동인지 확인하는 것입니다. 규칙의 유효성은 이동하려는 조각에 따라 다릅니다 (유효한 이동 다이어그램을 보려면 조각 이름을 클릭하십시오).

• 어떤 조각 : 다른 사각형의 조각이 차지하지 않는 한 조각은 이미 채워진 사각형으로 이동하거나 보드 밖으로 이동할 수 없습니다. 예를 들어, 흰색 조각은 흰색 조각이 아닌 검은 조각이 차지하는 사각형으로 이동할 수 있습니다. 또한 기사를 제외한 다른 조각은 다른 조각에 의해 직접 방해되는 사각형으로 이동할 수 없습니다.
  • 조각 별 움직임 B 제곱 C는 일체형으로 "직접 차단"되어 경우 A는 간에, 직선 (직교 또는 대각선) 라인에 바로 B 및 C .
• 어떤 조각 : 왕의 위치는 조각의 이동의 유효성에도 영향을 줄 수 있습니다. 이 두 조건 중 하나가 충족되면 이동이 유효하지 않은 것입니다.
  • 멸종 위기에 처한 왕과 같은 쪽에서 조각을 움직여 왕이 확인하도록 노출 시키십시오. 이것은 반대편이 왕을 체크하기 위해 움직이는 것이 아니라 반대편이 아닌 조각이 움직일 경우에만 적용됩니다.
  • 이 경우에 검사의 왕, 떠나 이 체크 밖으로 이동합니다. 따라서 왕이 점검 중이고 이동이 다른 조각이 움직 이도록 지시하는 경우 다른 조각이 검사를 방해 하지 않는 한 잘못된 이동 입니다. 조각은 두 가지 방법 중 하나를 통해 검사를 방지 할 수 있습니다. 조각을 수행하는 조각을 확인하거나 조각을 수행하는 조각과 왕 사이의 경로를 방해합니다.
  • "체크 (check)"는 왕의 상대방이 자신의 차례에 합법적으로 조각을 움직일 수있는 상황이다. 이 규칙은 재귀 적으로 적용되지 않습니다. 즉, 상대방이 그 왕으로 이동하면 자신의 왕을 확인하지 않아도 왕이 확인됩니다.
• 폰 : 폰은 빈 칸으로 한 칸 앞으로 움직일 수 있습니다 (즉, 흰색이면 위로, 검은면에는 아래로). 세 가지 특수 상황도 있습니다.
  • 폰이 아직 이동하지 않은 경우 (Y 좌표를 사용하여이를 결정할 수 있으며, Y 좌표가 2 인 경우 흰색 폰이 이동하지 않았고, Y 좌표가 7 인 경우 검은 폰이 이동하지 않은 것) 폰 두 칸을 빈 칸으로 옮길 수 있습니다.
  • 폰의 앞쪽에 대각선으로 상대방의 조각이있는 경우 (즉, 흰색이면 폰의 북서쪽 또는 북동쪽 사각형, 검은 색이면 남서쪽 또는 남동쪽 사각형) 폰은 해당 점령 광장으로 이동할 수 있습니다.
  • 폰이 일반적인 체스 규칙에서 최종 Y 좌표 (흰색은 8, 검은 색은 1)로 이동하면 같은 색의 여왕, 루크, 기사 또는 주교에게 승진시켜야합니다. 이 질문의 목적 상, 승격의 선택은 이동이 유효한지 아닌지 (입력 형식으로 표현할 수 없는지)와 관련이 없지만, 승격을 초래할 폰 이동은 허용되어야합니다.
• 주교 : 주교는 연속적인 방해받지 않는 심근 간 (즉, 대각선) 경로를 따라 1에서 8 칸 사이를 이동할 수 있습니다.
• 기사 : 기사는L다음과 같은 (동등한) 움직임 중 하나로 구성된 모양으로움직일 수 있습니다.
  • 모든 기본 방향의 단일 정사각형, 90 / 270 ° 회전, 최종적으로 2 정사각형 이동.
  • 기본 방향으로 2 칸, 90/270도 회전 한 후, 1 칸 앞으로 이동합니다.
  (마지막 정사각형은 여전히 ​​합법적이어야하지만 기사의 경로는 조각을 통해 막을 수는 없습니다.)
• 루크 : 루크는 연속적인 장애물이없는 기본 경로를 따라 1에서 8 칸 사이를 이동할 수 있습니다.
• Queens : Queens는 연속적인 추기경 또는 심근 간 (예 : 대각선) 장애물이없는 경로를 따라 1 ~ 8 개의 정사각형을 이동할 수 있습니다.
• 킹스 : 킹은 한 번에 한 칸만 움직일 수 있다는 점을 제외하고는 여왕처럼 움직입니다 (즉, 킹은 카디널 또는 대각선으로 인접한 칸으로 만 움직일 수 있습니다). 다시 말해, 당신은 왕을 점검하게하는 움직임을 만들 수 없습니다. 따라서 당신은 또한 왕을 체크 상태로 만들 수 없습니다.

체스의 규칙은 또한 "캐슬 링 (castling)"과 "엔 패넌트 (en passant)"라는 특별한 움직임을 포함합니다. 그러나 이러한 움직임의 합법성은 현재 위치뿐만 아니라 게임의 역사에 달려 있기 때문에 (캐스팅에 입력 형식에 맞지 않는 두 조각을 한 번에 이동해야하기 때문에) 이러한 움직임 중 어느 것도 고려하지 않아야합니다. 존재해야한다 (즉, 거세되거나 지나칠 행동은 불법으로 간주되어야한다).

이동의 유효성을 나타 내기 위해 두 가지 뚜렷한 결과를 출력 할 수 있으며 원하는 방법으로 입력 할 수 있습니다. 원하는 경우 위치에 대해 1- 인덱싱 대신 0- 인덱싱을 선택할 수도 있습니다. 이것은 code-golf 이므로 가장 짧은 코드가 승리합니다!

테스트 사례

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)

_{이 도전은 샌드 박스 였다. 설명없이 공표를 받았으므로 어쨌든 게시하기로 결정했습니다.}

Python 2 ( python-chess 포함 ),  141138134133132  바이트

정말 흥미로운 코드를 수행하지 않으면 골프 언어 또는 Mathematica와 경쟁 할 수 있습니까?

참고 : 파이썬 체스 A는 Pypi의 패키지와 2.7.9+ 파이썬에 설치 :
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)`)

세 가지 항목을 모두 입력 할 수있는 전체 프로그램 :

1. FEN 레코드 의 시작 -처음 두 필드를 포함하는 문자열 이것은 보드 상태와 색상이 움직이는 것을 정의하는 것입니다 (이것은 OP의 입력에있는 정보이므로 3에서 6까지의 필드는 OP에 의해 "고정"되므로 입력의 일부가 아니어야합니다)
2. 이동하려는 조각 이름 (OP에 지정된대로-중 하나 PRNBQK)
3. 명명 된 조각 곳으로 이동을 시도되는 광장 a1이다 0, b1이다 1, ... a2입니다8 , ..., h8is 63,

프로그램 유효한 입력이 주어지면 종료 코드를 통해 출력 합니다.

• 1 이동이 유효한 경우 (0으로 나누기 때문에 프로그램에서 오류가 발생 함)
• 0 그렇지 않습니다 (프로그램이 정상적으로 종료되었습니다)

(안) 온라인으로보십시오! (python-chess 패키지가 설치되어 있지 않고 TIO가 인터넷 연결을 허용하지 않으므로 헤더의 pip-install 코드가 작동하지 않기 때문에).

파이썬 전원 조작자가 유의하게 1**1 == 1**0 == 0**0 == 1하지만 0**1 == 0
... 따라서, 1/0**1제로 에러로 나누기를 발생하는 동안 1/1**1, 1/1**0그리고 1/0**0모든 성공
(... 파이썬에서 그 False와 True동일시 0하고 1, 각각).

정규식 (PCRE2), 931 925 837 바이트

이 솔루션은 하나의 보드 상태와 이동 대신 두 개의 보드 상태가 정규식으로 전달된다는 문제 설명에서 출발합니다. 이 이동은 두 보드 상태의 차이에서 유추됩니다. 그래서 TIO 프로그램 이이 질문에서 제공하는 형식으로 테스트 케이스를 가져 와서 보드에서 설명 된 모든 인스턴스를 찾은 다음 각 인스턴스를 대상 위치로 옮기고 정규 표현식을 평가하십시오. 그 가능성으로 정규 표현식에서 유효한 것으로보고 된 경우를 찾습니다. 이것이 좋지 않으면 알려주세요. 위치 + 이동으로 정규식을 구현할 수 있지만 훨씬 덜 우아하고 심각한 리팩토링이 필요합니다.

: 보드 흰색 부분은 대문자이고 흑 소문자 ASCII 8 × 8로 표현되는 P의 까끄라기 k 개의 N의 ight, B의 iShop에서, R의 OOK, Q의 ueen, K의 ING. 검은 색 (8 위)은 위쪽에 있고 흰색 (1 위)은 아래쪽에 있습니다. 각 순위는 줄 바꿈으로 구분되며 빈 사각형은로 표시됩니다 -. 두 개의 보드 위치는 추가 줄 바꿈으로 구분됩니다.

이 프로젝트의 실제 목표는 단일 동작 만이 아니라 전체 게임을 검증하는 것입니다. 현재 진행 상태는 아래를 참조하십시오.

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

온라인으로 사용해보십시오!

정교하게 인쇄되고 부분적으로 골프화되지 않음 (절대적인 역 참조가 상대로 변경되고 캡처 그룹이 캡처되지 않거나 일부 경우 속도를 위해 원자로 변경됨) :

# 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 바이트, 따라서 PCRE1에서 PCRE2로 대상 변경

위의 버전은 패배자를 허용하지 않도록 수정되었지만 전체 프로젝트는 현재 초기 보드 상태 (표준 체스 시작 위치 여야 함 – Chess960은 아니어야 함)에서 시작하여 모든 유형의 이동을 확인하는 상태에 있습니다. 적어도 지원됨). enpassant 및 castling의 전체 규칙이 적용됩니다.

다음은 정규식 (PCRE1 – 아직 대상이 지정되지 않음)에 의해 검증 된 샘플 게임입니다 [regex101.com] .

잘못된 이동은 모든 후속 보드 위치가 일치 / 강조 표시되지 않게합니다. 수감자 / 말미 탐지, 따라서 승자가 누구인지 (또는 추첨인지) 탐지는 아직 구현되지 않았습니다. 그렇기 때문에이 예제의 최종 보드 상태는 강조 표시되지 않습니다.

다음은 대수 표기법을이 정규식에서 인식되는 형식으로 변환하는 C / C ++ 프로그램입니다. 대수 표기법은 현재 각 이동에 대해 별도의 문자열을 사용하여 소스 코드에 배열 인라인 형태로 배치해야하지만 전체 이동 시퀀스가 ​​공백으로 구분되어 stdin 또는 명령 줄 인수에서 단일 문자열로 읽습니다. 점으로 끝나는 이동 번호가 계획되어 있습니다.

또한 대수 체스 표기법으로 전체 게임의 유효성을 검사하는 정규식을 시작했으며 표준 초기 위치가 암시되어 있습니다. 입력 끝에 추가 된 빈 "스크래치 보드"만 있으면됩니다 (이동 목록 뒤). 나는 이것을 완전히 구현할 수 있다고 확신하고 언젠가는 마무리 할 계획이다.