Jack và Jane quyết định chơi một ván cờ để đi chơi xa. Thật không may, Jack khá tệ trong việc hình dung. Dĩ nhiên, anh thấy khó khăn khi tìm ra những động tác có thể cho một mảnh nhất định ngoài một con tốt, tất nhiên!

Thử thách của bạn là giúp tìm cho Jack những lựa chọn khả thi cho một mảnh nhất định (trừ một con tốt).

Trong trường hợp người ta đã quên, các mảnh khác nhau được ký hiệu là:

• K: Vua
• Q: Nữ hoàng
• N: Hiệp sĩ
• B: Giám mục
• R: Rook

Như một ví dụ, trong hình dưới đây Knight tọa lạc tại d4và có thể chuyển sang c2, b3, b5, c6, e6, f5, f3, e2. Đối với một đầu vào nhất định:

Nd4

bạn sẽ sản xuất:

Nc2 Nb3 Nb5 Nc6 Ne6 Nf5 Nf3 Ne2

Quy tắc:

• Thứ tự của đầu ra không quan trọng miễn là tất cả các động thái có thể được liệt kê
• Các di chuyển có thể có thể được phân tách bằng khoảng trắng, dòng mới hoặc bất kỳ dấu phân cách nào khác
• Đầu vào có thể được truyền cho chương trình dưới dạng tham số hoặc thông qua STDIN
• Khoảng trắng trong chương trình sẽ được tính, vì vậy hãy sử dụng tối ưu nó

Đây là mã golf. (Vui lòng tránh sử dụng bất kỳ công cụ / tiện ích nào được thiết kế riêng cho mục đích này.) Câu trả lời ngắn nhất sẽ thắng!

GolfScript, 94 93 ký tự

Chương trình GolfScript đầu tiên của tôi! Điều này khiến tôi mất nhiều giờ dò dẫm xung quanh không thực sự biết mình đang làm gì, nhưng tôi vẫn kiên trì và tôi nghĩ rằng tôi đã học được những điều cơ bản về ngôn ngữ và chơi golf khá tốt.

Chơi golf đầy đủ :

{}/8,{97+.3$-.*:>8,{49+.4$-.*:^2$+.[3<>^*4=>^=>^*!.2$|]"KNBRQ"8$?=*{[5$3$@]""+p}{;}if}/;;}/];

Nguồn bình luận và đẹp hơn :

{}/              # tIn fIn rIn
8,{97+           #             fTst
  .3$-.*:>       #                  fDif^2 : >
  8,{49+         #                         rTst 
    .4$-.*:^     #                              rDif^2 : ^
    2$+.         #                                     ^>+
    [3<          # These    #                              [validK
     >^*4=       # checks   #                                      validN
     >^=         # do not   #                                             validB
     >^*!        # account  #                                                    validR
     .2$|]       # for null #                                                           validQ]
    "KNBRQ"8$?=  # move;    #                          valid
    *            # * does.  #                          validNotNull
    {[5$3$@]""+p}{;}if  # print? #  fDif^2
  }/;;           #        rIn
}/];

Nó có thể trông giống như câu trả lời của Claudiu, đó là vì tôi đã tham khảo câu trả lời của anh ấy, cũng như giải pháp C (không được chấp nhận) của tôi, trong khi đưa ra câu trả lời của tôi. Anh ấy đã cung cấp một mẫu tốt về một chương trình GolfScript hoạt động (tương đối) phức tạp và nó giúp tôi học được rất nhiều về ngôn ngữ. Vì vậy, cảm ơn, Claudiu!

Vẫn còn mới đối với GolfScript, nếu các bạn có bất kỳ phản hồi nào, tôi đánh giá cao việc nghe nó!

Python, 217 212 220 217 213 ký tự

Đã gắn giải pháp Mathicala 213 byte

R=range(8)
def f((p,x,y)):
 for a in R:
    for b in R:
     A,B=abs(a-ord(x)+97),abs(b-ord(y)+49);C=max(A,B);r=(A+B==3and C<3,C<2,A*B<1,A==B,0)
     if(r['NKRBQ'.index(p)],any(r[1:]))[p=='Q']*C:print p+chr(a+97)+chr(b+49)

Tôi đã bắt đầu bằng cách tạo ra tất cả các động thái hợp lệ nhưng nó đã phát triển quá lớn nên cách tiếp cận khá giống với phương pháp Mathicala.

>>> f("Nd4")
Nb3
Nb5
Nc2
Nc6
Ne2
Ne6
Nf3
Nf5
>>> f("Qa1")
Qa2
Qa3
Qa4
Qa5
Qa6
Qa7
Qa8
Qb1
Qb2
Qc1
Qc3
Qd1
Qd4
Qe1
Qe5
Qf1
Qf6
Qg1
Qg7
Qh1
Qh8

Mathicala, 278 272 264 260 215 213 ký tự

f=(FromCharacterCode@Flatten[Table[c=Abs[#2-x];d=Abs[#3-y];b=c==d;r=#2==x||#3==y;If[Switch[#-75,0,c~Max~d<2,-9,b,7,r,6,b||r,3,!r&&c+d==3],{p,x,y},##&[]],{x,97,104},{y,49,56}]&@@ToCharacterCode@#,1]~DeleteCases~#)&

Phiên bản bị đánh cắp:

f[pos_] := (
  {piece, u, v} = ToCharacterCode@pos;
  board = Flatten[Table[{piece, i + 96, j + 48}, {i, 8}, {j, 8}], 1];
  DeleteCases[
    FromCharacterCode[
      Cases[board, {_, x_, y_} /; Switch[p,
        75, (* K *)
        ChessboardDistance[{x, y}, {u, v}] < 2,
        66, (* B *)
        Abs[u - x] == Abs[v - y],
        82, (* R *)
        u == x || v == y,
        81, (* Q *)
        Abs[u - x] == Abs[v - y] || u == x || v == y,
        78, (* N *)
        u != x && v != y && ManhattanDistance[{x, y}, {u, v}] == 3
        ]
      ]
    ], 
    pos (* remove the input position *)
  ]
)&

Ví dụ sử dụng:

f["Nd4"]
> {"Nb3", "Nb5", "Nc2", "Nc6", "Ne2", "Ne6", "Nf3", "Nf5"}

Phiên bản không được tạo ra một bảng đầy đủ, và sau đó chọn các vị trí chính xác với Cases, trong khi phiên bản đánh gôn giảm các bước di chuyển không hợp lệ ngay lập tức trong Tablelệnh bằng cách phát hành ##&[], đơn giản là biến mất.

Haskell 225 220 208 205 200 182

f=fromEnum
m[p,a,b]=[[p,c,r]|c<-"abcdefgh",r<-"12345678",let{s=abs$f a-f c;t=abs$f b-f r;g"K"=s<2&&t<2;g"Q"=g"B"||g"R";g"N"=s+t==3&&(s-t)^2<2;g"B"=s==t;g"R"=s<1||t<1}in s+t>0&&g[p]]

Sẽ rất khó để chạm vào Mathicala khi nó có các nước cờ được tích hợp sẵn: rollseyes: (chơi tốt m.buettner) Tôi lấy lại tất cả. Đánh bại Mathicala trước 31!

Chỉnh sửa mới nhất: trường hợp được thay thế bằng một hàm, bộ lọc nội tuyến thành hiểu, để đánh bại mục trong R;)

sử dụng:

ghci> m "Nd4"
["Nb3","Nb5","Nc2","Nc6","Ne2","Ne6","Nf3","Nf5"]

Ungolfed (tương ứng với phiên bản 208 char trước khi 'u' được nội tuyến):

f=fromEnum -- fromEnum is 'ord' but for all enum types,
           -- and it's in the prelude, so you don't need an extra import.
u piece dx dy= -- piece is the character eg 'K', dx/dy are absolute so >=0.
  dx+dy > 0 && -- the piece must move.
  case piece of
    'K'->dx<2&&dy<2         -- '<2' works because we already checked dx+dy>0
    'Q'->dx<1||dy<1||dx==dy -- rook or bishop move. see below.
    'N'->dx+dy == 3 &&      -- either 2+1 or 3+0. Exclude the other...
         (dx-dy)^2 < 2      -- 1^2 or 3^2, so valid move is '<2', ie '==1'
    'B'->dx==dy             -- if dx==dy, dx/=0 - we checked that. 
                            -- other moves with dx==dy are along diagonal
    _->dx<1||dy<1           -- use _ not 'R' to save space, default case is
                            -- the rook. '<1' saves chars over '==0'.
                            -- Again, dx==dy==0 edge case is excluded.
m[piece,file,rank]=       -- the move for a piece. 'parse' by pattern match.
 filter(                    -- filter...
  \[_,newfile,newrank]->    -- ...each possible move...
    u piece                 -- ...by, as everyone noticed, converting char..
      (abs$f file-f newfile) -- differences to absolute dx, dy differences,..
      (abs$f rank-f newrank)) -- and then using special routines per piece.
    [[piece,newfile, newrank] -- the output format requires these 3 things.
      |newfile<-"abcdefgh",newrank<-"12345678"] -- and this just generates moves.

Bash, 238

B={19..133..19}\ {21..147..21};K=1\ {19..21};N='18 22 39 41';R={1..7}\ {2..14..2}0;Q=$B\ $R
a=${1%??};b=$[20#${1:1}-200];c=`eval{,} echo '$'$a`;d=({a..h})
for i in $c -${c// / -};do echo $a${d[$[(i+=b)/20]]}$[i%20];done|grep '[a-h][1-8]$'

Làm thế nào nó hoạt động

• Ý tưởng là biểu diễn mọi trường trên bảng theo một giá trị số, lấy tọa độ của nó làm số 20 cơ sở và trừ 200. Cách này, a1trở thành 20 * 10 + 1 - 200 = 1, h8trở thành 20 * 17 + 8 - 200 = 148, v.v.

  Bây giờ, các bước di chuyển có thể có của Giám mục có thể được biểu thị bằng bội số (dương hoặc âm) của 19 - cùng số lượng bước lên (+20) và sang trái (-1) - hoặc 21 - cùng số lượng bước lên (+20 ) và bên phải (+1).

  Vị trí của hình sau khi di chuyển chỉ đơn giản là tổng của vị trí ban đầu và chuyển động. Sau khi thêm các số đó, chúng tôi phải kiểm tra xem tổng của chúng có tương ứng với một trường hợp lệ trên bảng không.

  Vì cơ sở (20) lớn hơn gấp đôi so với số cao nhất có thể (8), nên tổng không thể bao quanh bảng, ví dụ, di chuyển Bh1 bảy bước sang phải và lên sẽ dẫn đến vị trí bảng không hợp lệ.

• Dòng

  B={19..133..19}\ {21..147..21};K=1\ {19..21};N='18 22 39 41';R={1..7}\ {2..14..2}0;Q=$B\ $R
  

  liệt kê tất cả các chuyển động có thể có của các mảnh được biểu thị bằng số dương.

• Các lệnh

  a=${1%??};b=$[20#${1:1}-200];c=`eval{,} echo '$'$a`;d=({a..h})
  

  lưu trữ định danh của mảnh trong biến a , biểu diễn số của vị trí ban đầu trong b và các chữ cái từ a đến h trong mảng d .

  Sau khi mở rộng cú đúp, eval{,} echo '$'$atrở thành eval eval echo '$'$a(đôi khi xấu xa), mà ước tính, ví dụ, eval echo $Kđánh giá echo 1 19 20 21.

• for i in $c -${c// / -};do …; done vòng lặp trên tất cả các chuyển động có thể và các đối tác tiêu cực của họ.

• echo $a${d[$[(i+=b)/20]]}$[i%20] đưa ra vị trí cuối cùng sau phong trào.

• grep '[a-h][1-8]$' đảm bảo rằng chúng tôi có một vị trí hội đồng hợp lệ.

Golf, 144 135 ký tự

Thay vì tiếp tục thử chơi giải pháp Python của tôi , tôi đã dịch nó thành Golfscript:

{}/49-:y;97-:x;:N;8,{.x-abs:A
8,{.y-abs:B@[\]$1=:C[B
A+3=\3<&2C>B
A*1<B
A=]81N={(;{|}*}{"NKRB"N?=}if
C*{[N
2$97+@49+]''+p}{;}if
A}/;;}/

Bản dịch đơn giản mà không cần chơi gôn nhiều nên rất có thể sẽ được đưa đi xa hơn. Lấy đầu vào từ stdin mà không có dòng mới, hãy thử ở đây (hai dòng đầu tiên là bắt chước stdin).

C 634 632 629 625 600 ký tự

#define F for(;i<4;i++){
#define B ;}break;
#define O x=X,y=Y,
P,X,Y,c,r,x,y,i=0, N[8][2]={{-2,1},{-1,2},{1,2},{2,1},{-2,-1},{-1,-2},{1,-2},{2,-1}},S[4][2]={{1,0},{0,1},{-1,0},{0,-1}},D[4][2]={{-1,1},{-1,-1},{1,1},{1,-1}};
C(){return((0<=c)&(c<8)&(0<r)&(r<9))?printf("%c%c%d ",P,c+'a',r):0;}
M(int*m){c=m[0]+x,r=m[1]+y;C()?x=c,y=r,M(m):0;}
main(int a,char**v){char*p=v[1];P=*p,X=p[1]-97,Y=p[2]-48; switch(P){case 75:F c=S[i][1]+X,r=S[i][0]+Y,C(),c=D[i][1]+X,r=D[i][0]+Y,C()B case 81:F O M(D[i]),O M(S[i])B case 78:for(;i<8;i++){c=N[i][1]+X,r=N[i][0]+Y,C()B case 66:F O M(D[i])B case 82:F O M(S[i])B}}

Bất kỳ đề xuất về làm thế nào để cải thiện điều này? Đây là lần đầu tiên tôi gửi câu trả lời.

Haskell, 300 269 ​​ký tự

Cảm ơn bazzargh đã giúp đỡ mất 31 ký tự ...

import Data.Char
f x=filter(x#)[x!!0:y|y<-[v:[w]|v<-"abcdefgh",w<-"12345678"],y/=tail x]
a%b=abs(ord a-ord b)
x#y=let{h=(x!!1)%(y!!1);v=(x!!2)%(y!!2);m=max h v;n=min h v}in case(x!!0)of{'N'->m==2&&n==1;'K'->m==1;'B'->h==v;'R'->n==0;'Q'->('R':tail x)#y||('B':tail x)#y}

Thuật toán tương tự như phiên bản Mathicala. Sản lượng mẫu từ ghci:

*Main> f "Nd4"
["Nb3","Nb5","Nc2","Nc6","Ne2","Ne6","Nf3","Nf5"]
*Main> f "Ni9"
["Ng8","Nh7"]

(Bạn đã không yêu cầu kiểm tra sự tỉnh táo!)

Haskell, 446 ký tự

import Data.Char
a=[-2,-1,1,2]
b=[-1,1]
d=[1..8]
e=[-8..8]
g=[-1..1]
h 'N' c r=[(c+x,r+y)|x<-a,y<-a,3==(sum$map abs[x, y])]
h 'B' c r=[(c+x*z,r+y*z)|x<-b,y<-b,z<-d]
h 'R' c r=[(c+x,r)|x<-e]++[(c,r+y)|y<-e]
h 'Q' c r=h 'B' c r++h 'R' c r
h 'K' c r=[(c+x,r+y)|x<-g,y<-g]
l s=ord s-96
m n=chr$n+96
k ch (c,r)=ch:m c:[intToDigit r]
f (x,y)=all(`elem`[1..8])[x, y]
i n c r=map(k n).filter(/=(c,r)).filter f$h n c r
j s=i(s!!0)(l$s!!1)(digitToInt$s!!2)

Được gọi bằng jchức năng

j "Nd4"

Tôi đã không làm việc với Haskell trong một vài tháng, vì vậy cuối cùng nó không ngắn như hầu hết các giải pháp khác, nhưng tôi chắc chắn có một số tối ưu hóa được thực hiện, chủ yếu là với h. Tôi có thể rút ngắn nó một chút.

q & k [ 311 262 ký tự]

Có một tiềm năng giảm thêm một số nhân vật. Tôi sẽ giảm nó trong lần lặp lại tiếp theo.

k)o:{n:#m:&(#x)##y;((),x)[m],'n#y}

k)a:`$"c"$(o/)c:+(97;49)+/:!8

k)r:{{|x@<x}'?,/{o[x]y}'[x](|"c"$c)}
k)k:{"c"$(6h$x)+/:(o/)2 3#-1 0 1}
k)n:{"c"$(6h$x)+/:(|:'t),t:o[-1 1;2 2]}
k)b:{"c"$(6h$x)+/:(n,'n),n,'|n:-8+!17}
k)q:{,/(r;b)@\:x}

d:{(`$("rknbq"!(r;k;n;b;q))[x]y)except`$y}
g:{a inter d[x 0]@1_x}

Sử dụng

Tân binh

g"ra1"
`a2`a3`a4`a5`a6`a7`a8`b1`c1`d1`e1`f1`g1`h1

nhà vua

g"ka1"
`a2`b1`b2

Hiệp sỹ

g"na1"
`b3`c2

Giám mục

g"ba1"
`b2`c3`d4`e5`f6`g7`h8

nữ hoàng

g"qa1"
`a2`a3`a4`a5`a6`a7`a8`b1`b2`c1`c3`d1`d4`e1`e5`f1`f6`g1`g7`h1`h8

R, 203 ký tự

f=function(p,x,y){x=which((l=letters)==x);X=rep(1:8,8);Y=rep(1:8,rep(8,8));A=abs(X-x);L=abs(Y-y);B=A==L;R=!A|!L;i=switch(p,N=A+L==3&A&L,R=R,B=B,Q=R|B,K=(R|B)&A<2&L<2)&A+L>0;paste(p,l[X[i]],Y[i],sep="")}

Phiên bản bị đánh cắp:

f = function(p,x,y) {
  x = which(letters == x)  # Gives index between 1 and 8.
  X = rep(1:8, 8)          # 1,2,...,7,8,1,2,.... (8x8).
  Y = rep(1:8, rep(8,8))   # 1,1,...2,2,.....,8,8 (8x8).
  dx = abs(X-x)
  dy = abs(Y-y)
  B = (dx == dy)           # Bishop solutions
  R = (!dx | !dy)          # Rock solutions
  i = switch(p,
             N=dx+dy==3 & dx & dx,  # Sum of dist. is 3, dx and dy must be <> 0.
             R=R, 
             B=B, 
             Q=R|B,                 # Queen is merge of rock and bishop.
             K=(R|B) & dx<2 & dy<2  # King's distance is < 2.
             ) & (dx+dy > 0)        # Exclude start field.

  paste(p, letters[X[i]], Y[i], sep="")
}

Sử dụng:

> f('N', 'a', 3)
[1] "Nb1" "Nc2" "Nc4" "Nb5"

Các giải pháp thậm chí là tốt có thể đọc được. Tuy nhiên, tôi đã thêm một số dấu ngoặc đơn và nhận xét cho những người đọc không quen thuộc với mã R (trên phiên bản không được chỉnh sửa).

Haskell (giả thuyết), 248 ký tự

import Data.Char
f x=filter(o x)[x!!0:y|y<-[v:[w]|v<-"abcdefgh",w<-"12345678"],y/=tail x]
d a b=abs(ord a-ord b)
h x y=(c*(d(x!!1)(y!!1))-(d(x!!2)(y!!2)))+200*c
 where c=d (x!!0)'A'
o x y=elem(chr(h x y))"ਲ਼ੁߏߚߙÈേെ൅ൄൃ൙൪ൻඌඝථ඿౿౾౽౼౻౺౹ಐಏಠಞರಭೀ಼೐ೋೠ೚೰೩"

Thật không may, mọi trình biên dịch Haskell mà tôi có thể có được ngay bây giờ đều có vấn đề với các chuỗi ký tự Unicode. Đây là phiên bản (dài hơn) thực sự hoạt động:

import Data.Char
f x=filter(o x)[x!!0:y|y<-[v:[w]|v<-"abcdefgh",w<-"12345678"],y/=tail x]
d a b=abs(ord a-ord b)
h x y=(c*(d(x!!1)(y!!1))-(d(x!!2)(y!!2)))+200*c
 where c=d (x!!0)'A'
o x y=elem(chr(h x y))"\2611\2625\1999\2010\2009\200\3399\3398\3397\3396\3395\3394\3393\3417\3434\3451\3468\3485\3502\3519\3199\3198\3197\3196\3195\3194\3193\3216\3215\3232\3230\3248\3245\3264\3260\3280\3275\3296\3290\3312\3305"

Định nghĩa h x y=...là hàm băm; di chuyển hợp lệ sẽ băm đến số ký tự trong chuỗi 41 ký tự. Điều này được loại bỏ sự cần thiết cho một tuyên bố "trường hợp" hoặc tương đương.

Tôi không có kế hoạch làm việc thêm về điều này ngay bây giờ. Sẽ rất vui nếu thấy ai đó có thể sử dụng hàm băm bằng ngôn ngữ ngắn gọn hơn để đưa ra giải pháp ngắn hơn.