_{Nama alternatif: ChessMoveQ}

Diberikan daftar hingga 32 elemen, masing-masing terdiri dari 4 elemen, dan daftar kedua dengan 4 elemen, menentukan apakah langkah yang terperinci dalam input kedua adalah langkah catur yang valid.

Daftar pertama menunjukkan posisi semua 32 buah di papan tulis. Setiap elemen akan mengikuti struktur <colour>, <piece-name>, <x-coord>, <y-coord>, seperti ["W", "K", 5, 1], yang menunjukkan bahwa raja putih aktif 5, 1( e1di papan catur normal). Semua elemen input pertama akan unik. <x-coord>dan <y-coord>akan selalu antara 1 dan 8. Salah satu contohnya adalah:

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

yang akan mewakili dewan:

Input kedua akan terdiri dari struktur yang sama dengan sublists dari yang pertama, tetapi alih-alih koordinat x dan y yang menunjukkan di mana potongan itu, mereka menunjukkan di mana ia mencoba untuk pindah.

Untuk contoh di atas, langkah yang valid bisa saja ["W", "B", 4, 3](uskup bergerak satu kotak ke depan dan ke kiri), dan langkah yang tidak valid bisa jadi ["B", "R", 4, 1]karena benteng harus bergerak melalui ksatria, dan pion untuk sampai ke alun-alun. Karena gerakan dapat merujuk ke beberapa bagian sekaligus, Anda harus menguji apakah setiap bagian yang ditentukan dapat bergerak, bukan hanya salah satunya. Misalnya, contoh pertama hanya berlaku untuk satu uskup, tetapi itu masih merupakan langkah yang sah. Namun, tidak ada benteng hitam yang dapat melakukan langkah kedua, sehingga tidak valid.

Tugas Anda adalah menentukan apakah langkah yang diperinci dalam input kedua adalah langkah catur yang valid. Validitas aturan bervariasi, tergantung pada bagian yang mencoba untuk dipindahkan (klik pada nama bagian untuk diagram dari langkah yang valid):

• Potongan apa pun : Tidak ada potongan yang dapat bergerak ke kotak yang sudah ditempati, atau dari papan, kecuali kotak itu ditempati oleh sepotong dari warna lain. Sebagai contoh, sepotong putih dapat pindah ke kotak yang ditempati oleh sepotong hitam, tetapi bukan sepotong putih. Selain itu, tidak ada bagian, kecuali untuk Ksatria, dapat pindah ke kotak yang langsung terhalang oleh bagian lain.
  • Sebuah langkah demi sepotong B ke titik C adalah "langsung terhalang" oleh sepotong A jika A secara langsung, dalam lurus (orthogonal atau diagonal) line, antara B dan C .
• Potongan apa pun : Posisi raja juga dapat memengaruhi validitas gerakan sepotong itu. Jika salah satu dari kedua kondisi ini terpenuhi, langkah tersebut tidak valid:
  • Mengekspos raja untuk memeriksa, dengan memindahkan sepotong di sisi yang sama dengan raja yang terancam punah. Ini hanya berlaku jika bagian yang tidak menentang membuat langkah, bukannya bagian yang berlawanan bergerak untuk menempatkan raja.
  • Meninggalkan raja di cek, dalam hal ini ia harus keluar dari cek. Oleh karena itu, jika raja berada dalam kendali dan langkah tersebut menentukan bahwa bagian lain bergerak, itu adalah langkah yang tidak sah, kecuali bagian lainnya mencegah pemeriksaan. Sepotong dapat mencegah cek dalam salah satu dari dua cara: baik mengambil potongan melakukan pemeriksaan, atau menghalangi jalan antara potongan yang melakukan pemeriksaan dan raja.
  • "Cek" adalah situasi di mana lawan raja bisa (jika giliran mereka bergerak) secara legal memindahkan sepotong ke raja itu. Aturan ini tidak berlaku secara rekursif, yaitu seorang raja di cek bahkan jika gerakan oleh lawan ke raja itu akan meninggalkan raja mereka sendiri di cek.
• Bidak : Gadai dapat bergerak maju (yaitu ke atas jika putih, ke bawah jika hitam) satu kotak ke kotak kosong. Ada juga tiga situasi khusus:
  • Jika pion belum bergerak (Anda dapat menentukan ini menggunakan koordinat Y; pion putih belum bergerak jika koordinat Y-nya 2, pion hitam belum bergerak jika koordinat Y-nya adalah 7), pion diizinkan untuk memindahkan dua kotak ke depan ke kotak kosong.
  • Jika ada bagian lawan secara diagonal di depan bidak (yaitu di alun-alun di barat laut atau timur laut bidak jika putih, atau ke barat daya atau tenggara jika hitam), gadai diizinkan untuk pindah ke alun-alun yang diduduki tersebut.
  • Jika pion bergerak ke koordinat Y akhir (8 untuk putih, atau 1 untuk hitam) dalam aturan catur normal, ia harus dipromosikan menjadi ratu, benteng, ksatria, atau uskup dengan warna yang sama. Untuk keperluan pertanyaan ini, pilihan promosi tidak relevan dengan apakah langkah tersebut valid atau tidak (dan tidak dapat dinyatakan dalam format input), tetapi langkah gadai yang akan menghasilkan promosi harus diizinkan.
• Uskup : Uskup dapat bergerak antara 1 dan 8 kotak di sepanjang jalur interardinal (yaitu diagonal) yang tidak terhalang.
• Ksatria : Ksatria dapat bergerak dalam suatuLbentuk, yang terdiri dari salah satu dari langkah-langkah (setara) berikut ini:
  • Satu kotak di setiap arah mata angin, diikuti dengan putaran 90/270 °, diikuti oleh gerakan terakhir 2 kotak ke depan.
  • 2 kotak di setiap arah mata angin, diikuti oleh putaran 90/270 °, diikuti oleh langkah terakhir dari satu kotak ke depan.
  (Ingatlah bahwa jalan seorang ksatria tidak dapat dihadang dengan benda-benda yang mengintervensi, meskipun kuadrat terakhirnya masih harus legal)
• Benteng : Benteng dapat bergerak antara 1 dan 8 kotak di sepanjang jalur kardinal yang tidak terhalang terus menerus.
• Queens : Queens dapat bergerak antara 1 dan 8 kotak sepanjang jalur kardinal atau interardinal (yaitu diagonal) yang tidak terhalang.
• Raja : Raja bergerak seperti ratu, kecuali bahwa mereka terbatas pada hanya memindahkan satu kotak per gerakan (yaitu seorang raja hanya dapat pindah ke kotak yang berdekatan secara kardinal atau diagonal). Sebagai pengingat, Anda tidak bisa bergerak yang membuat raja Anda terkendali; dengan demikian Anda juga tidak bisa memindahkan raja Anda.

Aturan catur juga mengandung gerakan khusus yang disebut "castling" dan "en passant". Namun, karena legalitas gerakan ini bergantung pada sejarah permainan, bukan hanya posisi saat ini (dan karena castling membutuhkan dua potong gerakan sekaligus, yang tidak sesuai dengan format input), Anda harus mempertimbangkan kedua gerakan ini untuk ada (yaitu suatu langkah yang akan dilakukan castling atau en passant harus dianggap ilegal).

Anda dapat menampilkan dua hasil berbeda untuk menunjukkan validitas suatu langkah, dan Anda dapat mengambil input dalam metode yang Anda inginkan. Anda juga dapat memilih pengindeksan 0 daripada pengindeksan 1 untuk posisi jika Anda inginkan. Ini adalah kode-golf , sehingga kode terpendek menang!

Uji kasus

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)

_{Tantangan ini dikosongkan . Itu menerima downvotes, tanpa penjelasan apa pun, jadi saya memutuskan untuk tetap mempostingnya}

Python 2 (dengan python-catur ),  141 138 134 133  132 byte

Tanpa melakukan salah satu kode yang benar-benar menarik - tapi mungkin ini bisa bersaing dengan bahasa golf atau (berani saya sebutkan itu) Mathematica?

Catatan: python-catur adalah PyPI paket menginstalnya pada Python 2.7.9+ dengan:
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)`)

Input tiga program yang menerima input penuh:

1. awal catatan FEN - string yang berisi dua bidang pertama. Ini adalah untuk menentukan status papan DAN warna mana yang bergerak (karena ini adalah informasi dalam input dalam OP, sedangkan bidang tiga hingga enam "diperbaiki" oleh OP sehingga tidak boleh menjadi bagian dari input)
2. nama-sepotong yang mencoba untuk bergerak (seperti yang diberikan dalam OP - salah satu dari PRNBQK)
3. alun-alun yang bernama sepotong berupaya berpindah-pindah tempat a1adalah 0, b1adalah 1, ... a2adalah 8...,h8 adalah 63,

Program mengeluarkan melalui kode keluarnya yang diberikan input yang valid:

• 1 jika langkah itu valid (program menimbulkan kesalahan - karena pembagian dengan nol);
• 0 bukan (program keluar secara normal)

(Jangan) Coba online! (karena paket python-catur tidak diinstal di sana dan TIO tidak mengizinkan konektivitas internet sehingga kode pip-instal di header tidak akan berfungsi).

Perhatikan bahwa operator listrik di Python membuat 1**1 == 1**0 == 0**0 == 1tapi 0**1 == 0
... maka 1/0**1menimbulkan pembagian dengan nol kesalahan saat 1/1**1, 1/1**0dan 1/0**0semuanya sukses
(... dan bahwa dalam Python Falsedan Truemenyamakan ke 0dan 1masing-masing).

Regex (PCRE2), 931 925 837 byte

Solusi ini berangkat dari pernyataan masalah di mana dua negara bagian diteruskan ke regex, alih-alih satu negara bagian dan satu langkah. Langkah ini disimpulkan dari perbedaan antara dua negara bagian. Jadi saya membuatnya menjadi tugas dari program TIO untuk mengambil kasus uji dalam format yang disediakan oleh pertanyaan ini, menemukan semua contoh potongan yang dijelaskan di papan tulis, dan dengan masing-masing, cobalah memindahkannya ke posisi tujuan dan mengevaluasi regex dengan kemungkinan itu, mencari apakah ada yang dilaporkan oleh regex sebagai valid. Jika ini tidak baik, beri tahu saya; itu mungkin untuk menerapkan regex sebagai posisi + langkah, tetapi akan jauh lebih elegan dan memerlukan refactoring yang serius.

Dewan direpresentasikan dalam 8 × 8 ASCII mana potongan putih huruf besar dan huruf kecil hitam: P awn, k N ight, B Ishop, R ook, Q ueen, K ing. Sisi hitam (peringkat 8) ada di atas dan sisi putih (peringkat 1) ada di bawah. Setiap peringkat dipisahkan oleh baris baru, dan kotak kosong ditandai sebagai -. Dua posisi papan dipisahkan oleh baris baru ekstra.

Tujuan sebenarnya dari proyek ini adalah untuk memvalidasi seluruh game, bukan hanya gerakan tunggal. Lihat di bawah untuk kondisi perkembangan saat ini.

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

Cobalah online!

Dicetak cantik, dan sebagian tidak disunat (backref absolut berubah menjadi relatif, dan grup penangkap berubah menjadi non-penangkapan, atau dalam beberapa kasus atom untuk kecepatan):

# 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 dengan menggunakan panggilan subrutin non-atom, sehingga penargetan ulang dari PCRE1 ke PCRE2

Versi di atas telah dimodifikasi untuk tidak mengizinkan en passant atau castling, tetapi proyek penuh saat ini dalam keadaan di mana ia memvalidasi setiap jenis gerakan, mulai dari keadaan papan awal (yang harus menjadi posisi awal catur standar - Chess960 tidak didukung, namun setidaknya). Aturan penuh en passant dan castling diberlakukan.

Ini adalah contoh game yang divalidasi oleh regex lengkap (PCRE1 - belum ditargetkan ulang) [regex101.com] .

Langkah yang tidak valid akan menghasilkan setiap posisi dewan berikutnya tidak dicocokkan / disorot. Deteksi skakmat / jalan buntu, dan dengan demikian deteksi siapa pemenangnya (atau jika itu seri), belum dilaksanakan; itu sebabnya status dewan final dalam contoh ini tidak disorot.

Berikut ini adalah program C / C ++ yang mengubah notasi aljabar menjadi format yang dikenali oleh regex ini.Notasi aljabar saat ini harus diletakkan dalam bentuk array inline dalam kode sumber, dengan string terpisah untuk setiap gerakan, tetapi membacanya sebagai string tunggal dari stdin atau argumen baris perintah, dengan seluruh urutan gerakan dipisahkan oleh spasi dan nomor langkah dot-dihentikan, direncanakan.

Saya juga mulai dengan regex yang memvalidasi permainan penuh murni dalam notasi catur aljabar, dengan posisi awal standar yang tersirat. Yang dibutuhkan hanyalah "papan gores" kosong yang ditambahkan di akhir input (setelah daftar gerakan). Saya cukup yakin dimungkinkan untuk mengimplementasikan ini secara penuh, dan berencana menyelesaikannya kapan-kapan.