Chơi một nước cờ hợp lệ, đưa ra một bảng trên stdin

Chương trình chơi trắng.

Ví dụ stdin:

8 ║♜ ♞ ♝ ♛ ♚ ♝ ♞ ♜
7 ║♟ ♟ ♟ ♟ … ♟ ♟ ♟
6 ║… … … … … … … …
5 ║… … … … ♟ … … …
4 ║… … … … … … … …
3 ║… … ♘ … … … … …
2 ║♙ ♙ ♙ ♙ ♙ ♙ ♙ ♙
1 ║♖ … ♗ ♕ ♔ ♗ ♘ ♖
——╚═══════════════
—— a b c d e f g h

Ví dụ tiêu chuẩn:

8 ║♜ ♞ ♝ ♛ ♚ ♝ ♞ ♜
7 ║♟ ♟ ♟ ♟ … ♟ ♟ ♟
6 ║… … … … … … … …
5 ║… … … … ♟ … … …
4 ║… … … … ♙ … … …
3 ║… … ♘ … … … … …
2 ║♙ ♙ ♙ ♙ … ♙ ♙ ♙
1 ║♖ … ♗ ♕ ♔ ♗ ♘ ♖
——╚═══════════════
—— a b c d e f g h

Bất kỳ di chuyển hợp lệ là ok. "En passant" và castling bị bỏ qua. Bạn có thể hiển thị thông báo lỗi hoặc in không có gì nếu không có động thái hợp lệ.

Câu trả lời có nhiều phiếu nhất sẽ thắng.

Tôi không phàn nàn về upvote, nhưng công bằng mà nói ... giải pháp của tôi ở đây không thực sự tuyệt vời đến thế. Ugoren là tốt hơn, ngoài việc thiếu hỗ trợ unicode. Hãy chắc chắn xem tất cả các câu trả lời trước khi bỏ phiếu, nếu bạn chỉ gặp câu hỏi này ngay bây giờ!
Dù sao.

Haskell, 893 888 904 952 (không đúc)

862 (không có di chuyển kép cầm đồ)

(Bạn đã không xác định nếu đây được coi là mã golf, nhưng đối với tôi nó nên như vậy)

χ=w⋈b;w="♙♢♤♔♕♖♗♘";b="♟♦♠♚♛♜♝♞"
μ=t⤀ζ++((\(x,y)->(x,-y))⤀)⤀μ;q c|((_,m):_)<-((==c).fst)☂(χ⋎μ)=m
t(x:y:l)=(d x,d y):t l;t _=[];d c=fromEnum c-78
ζ=["NM","NL","MMOM","MMMNMONMNOOMONOO",σ⋈δ,σ,δ,"MLOLPMPOOPMPLOLM"]
σ=l>>=(\c->'N':c:c:"N");δ=[l⋎l,reverse l⋎l]>>=(>>=(\(l,r)->[l,r]))
l="GHIJKLMOPQRSTU"
α c|c∊"♢♤"='♙'|c∊"♦♠"='♟'|c∊χ=c;π('♙':_)=6;π _=1
(⋎)=zip;(⤀)=map;(∊)=elem;(✄)=splitAt;(☂)=filter;(⋈)=(++)
φ r@(x,y)p a
 |x>7=φ(0,y+1)p a
 |y>7=[]
 |c<-a✠r=(c⌥r)p a y⋈φ(x+1,y)p a
(c⌥r)p a y
 |c==p!!0=(a☈r)c χ++const(y==π p)☂(a☈r)(p!!1)χ++(a☈r)(p!!2)('…':w)
 |c∊p=(a☈r)c χ
 |True=[]
a✠(x,y)=a!!y!!(x*2);o(x,y)=x>=0&&x<8&&y>=0&&y<8
(n➴a)(x,y)|(u,m:d)<-y✄a,(l,_:r)<-(x*2)✄m=u⋈(l⋈(n:r):d)
(a☈r@(x,y))c b=(α c➴('…'➴a)r)⤀((\r->o r&&not((a✠r)∊b))☂((\(ξ,υ)->(x+ξ,y+υ))⤀q c))
main=interact$unlines.uncurry((⋈).zipWith((⋈).(:" ║"))['8','7'..]
 .head.((all(any('♔'∊)).φ(0,0)b)☂).φ(0,0)w.(drop 3⤀)).(8✄).lines

Khi bạn đã cài đặt GHC (ví dụ như một phần của nền tảng Haskell ), bạn có thể làm chỉ

$ runhaskell def0.hs < examplechessboard.txt
8 ║♜ ♞ ♝ ♛ ♚ ♝ ♞ ♜
7 ║♟ ♟ ♟ ♟ … ♟ ♟ ♟
6 ║… … … … … … … …
5 ║… ♘ … … ♟ … … …
4 ║… … … … … … … …
3 ║… … … … … … … …
2 ║♙ ♙ ♙ ♙ ♙ ♙ ♙ ♙
1 ║♖ … ♗ ♕ ♔ ♗ ♘ ♖
——╚═══════════════
—— a b c d e f g h

C, 734 672 640 ký tự

Nhân vật được tính mà không có khoảng trắng có thể tháo rời.
Định dạng tệp tôi sử dụng không theo yêu cầu, nhưng đơn giản hóa ASCII.
Tôi cần thêm hỗ trợ ký tự Unicode, nó sẽ tốn một số characets.

char*r=" kpnbrq  KPNBRQ $ ,&)$wxy()879()8(6:GI(",B[256],*b=B,i;
e(x,d,m,V,c,r,n,p){
    for(r=0,p=b[x];m/++r;){
        n=x+d*r;
        if(p==2+8*(d<0)||n&136||!(b[n]?r=8,8^p^b[n]^8&&c&65^64:c&65^65)
            ? r=m,0
            : V?v(n,x):b[n]==1)
            return b[x]=0,b[n]=p%8-2||n/16%7?p:p+4;
    }
    return d>0&&e(x,-d,m,V,c);
}
d(x,v,m,i)char*m;{
    return(i=*m-40)?e(x,i%64,b[x]%8-2?b[x]&4?7:1:(x/16-1)%5|i%2?1:2,v,i)||d(x,v,m+1):0;
}
v(t,f){
    bcopy(B,b+=128,128);
    b[t]=b[f];b[f]=0;
    i=a(1,63);
    b=B;
    return!i;
}
a(c,n){
    return b[i=n*2-n%8]&&b[i]/8==c&&d(i,!c,r+r[b[i]%8+15]-10)||n--&&a(c,n);
}
main(){
    for(;gets(b);b+=8)for(;*b;b++)*b=strchr(r,*b)-r;b=B;
    for(i=64*!a(0,63);i<64;i++%8-7||puts(""))putchar(r[b[i*2-i%8]]);
}

Định dạng tệp đầu vào / đầu ra:
Phải chính xác 8 dòng có chính xác 8 ký tự. pnbrqkđược sử dụng cho các mảnh màu trắng, PNBRQKcho các mảnh màu đen, không gian cho không gian:

RNBQKBNR
PPPP PPP

 n  P


pppppppp
r bqkbnr

Logic khá đơn giản:
Đối với mỗi lần di chuyển có thể của từng mảnh trắng, hãy thử từng di chuyển có thể của từng mảnh đen.
Nếu không có di chuyển màu đen nào bắt được vua trắng, thì di chuyển trắng là hợp lệ.

Bảng được duy trì dưới dạng char[256], được coi là ma trận 16x16, trong đó chỉ sử dụng 8 x 8 trên cùng bên trái. Vị trí và vectơ chuyển động được giữ trong số nguyên 8 bit ( x:4,y:4). Bit thêm cho phép sử dụng số học đơn giản ( new_pos = old_pos + steps*direction), với sự phát hiện dễ dàng của cạnh bảng ( &0x88thực hiện phép thuật). r[]mã hóa ba điều:

1. 15 byte đầu tiên ánh xạ mã mảnh nội bộ (K = 1, P = 2, N = 3, B = 4, R = 5, Q = 6) thành chữ cái.
2. 6 byte tiếp theo ánh xạ mã mảnh nội bộ thành phần bù trong phần cuối (K và Q giống nhau, B là đuôi của chúng).
3. 16 byte cuối cùng mã hóa chuyển động của tất cả các mảnh, như '('+vector.

Chức năng:

1. mainđọc bảng, chuyển đổi chữ cái thành mã nội bộ, gọi ađể tìm di chuyển màu trắng, in bảng.
2. avòng lặp đệ quy trên 64 ô vuông. Đối với mỗi phần của màu bên phải (tham số c), nó tìm quy tắc chuyển động cho phần và cuộc gọi d.
3. dcác vòng lặp đệ quy trên quy tắc di chuyển được mã hóa, đó là một danh sách các vectơ, gọi echo mỗi cái. Nó đưa ra evị trí ban đầu, vectơ và giới hạn phạm vi (7 cho các mảnh trên B, 2 cho các con tốt thứ hạng thứ hai, 1 nếu không).
4. ekiểm tra tất cả các chuyển động dọc theo một vectơ. Nếu di chuyển là có thể (tức là cầm đồ di chuyển về phía trước, trong bảng, không bị chặn, cầm đồ bắt chéo), kiểm tra một trong hai điều. Đối với di chuyển màu trắng, chạy vđể xác nhận di chuyển. Đối với di chuyển màu đen, kiểm tra nếu vua trắng bị bắt. Nếu đúng, di chuyển được chơi trên bảng.
5. vxác nhận một động thái trắng. Nó sao chép bảng sang một bên, thực hiện di chuyển để kiểm tra và gọi alại, để tìm kiếm di chuyển màu đen.

Python 2.6, 886 - 1425 ký tự

Phiên bản ban đầu của tôi (trong các phiên bản) có 886 ký tự nhưng không hoàn toàn thỏa mãn thông số kỹ thuật (nó không kiểm tra để tránh người kiểm tra; thậm chí còn không xem xét các chuyển động có thể có của các mảnh màu đen).

Bây giờ nó đã (và tôi đã sửa một số lỗi trong bản gốc). Than ôi điều này đi kèm với một chi phí trong các nhân vật: 1425 bây giờ, nhưng vẫn còn rất ít chỗ để cải thiện. Phiên bản này sẽ chắc chắn hơn rất nhiều trong việc xử lý các trường hợp cạnh sau đó là phiên bản trước.

#-*-coding:utf8-*-
import sys;e=enumerate
B,W=["♟","♜","♞","♝","♛","♚"],["♙","♖","♘","♗","♕","♔"]
R={"♙":[11,42],"♖":[28],"♘":[31],"♗":[8],"♕":[8,28],"♔":[1,21]}
def F(w):return sum([[(i,j)for j,p in e(o)if p==w]for i,o in e(Z)],[])
def G(x,y):
 P=Z[x][y];D=P in W;L=[]
 for o in R[P]if D else R[unichr(ord(P.decode('utf8'))-6).encode('utf8')]:
  r,k="%02d"%o        
  for g,h in[[(-1,-1),(1,1),(-1,1),(1,-1)],[[(1,-1),(1,1)],[(-1,-1),(-1,1)]][D],[(-1,0),(1,0),(0,-1),(0,1)],[(-2,-1),(-2,1),(-1,-2),(-1,2),(1,-2),(1,2),(2,-1),(2,1)],[(-1,0)]][int(r)]:
   J=0
   for i in range(int(k)):
    T=x+(i+1)*g;U=y+(i+1)*h
    if T<0 or T>7 or U<0 or U>7:break
    M=Z[T][U]
    if not J:L.append((T,U,P,M))
    else:break
    if r in"02"and(M in W+B):
     J=1
     if not((D and M in B)or(not D and M in W)):L.pop()
    elif(r=="1"and not((D and M in B)or(not D and M in W)))or(r=="4"and((i==1 and x!=6)or M!="…")):L.pop()
 return L  
Z=[[y for y in l[5:].split()]for l in sys.stdin.readlines()[:-2]]
Q=[]
for p in R:
 for i,j in F(p):
  for M,L,c,_ in G(i,j):
   O=Z[M][L];Z[i][j]="…";Z[M][L]=c;E=[];map(E.extend,map(F,B))
   if not any(any(1 for _,_,_,I in G(v,h)if I==["♔","♚"][c in B])for v,h in E):Q.append((i,j,M,L,c))
   Z[i][j]=c;Z[M][L]=O
(x,y,X,Y,p)=Q[0];Z[x][y]="…";Z[X][Y]=p
for i,h in e(Z):print`8-i`+' ║'+' '.join(h)
print"——╚"+"═"*16+"\n—— a b c d e f g h"

Ví dụ đầu vào và đầu ra:

# ĐẦU VÀO

8 ║♜ ♞ ♝ ♝
7 ♟ ♟ ♟ Nhận ♟ ♟
6 ║
5 ║
4 ║
3 ║
2 ║♙ ♙ ♙
1 ║♖ ♘ ♗ ♕ ♔ ♗ ♘
Giáo dục
Giáo sư abcdefgh

# ĐẦU RA

8 ║♜ ♞ ♝ ♝
7 ♟ ♟ ♟ Nhận ♟ ♟
6 ║
5 ║
4 ║
3 ║
2 ║♙ ♙ ♙
1 ║♖ ♘ ♗ ♕ ♔ ♗ ♘
Giáo dục
Giáo sư abcdefgh