แจ็คและเจนตัดสินใจเล่นเกมหมากรุกในขณะที่ไม่อยู่ น่าเสียดายที่แจ็คค่อนข้างแย่ในการสร้างภาพ เขาพบว่ามันยากที่จะคิดการเคลื่อนไหวที่เป็นไปได้สำหรับชิ้นส่วนที่กำหนดนอกเหนือจากจำนำแน่นอน!

ความท้าทายของคุณคือช่วยค้นหาแจ็คตัวเลือกที่เป็นไปได้สำหรับชิ้นส่วนที่ระบุ (นอกเหนือจากการจำนำ)

ในกรณีที่ลืมแล้วชิ้นส่วนต่าง ๆ จะถูกแทนด้วย:

• K: ราชา
• ถาม: ราชินี
• N: อัศวิน
• B: อธิการ
• R: โกง

ตัวอย่างเช่นในภาพต่อไปนี้อัศวินตั้งอยู่ที่d4และสามารถย้ายไปc2, b3, b5, c6, e6, f5, ,f3 e2สำหรับอินพุตที่กำหนด:

Nd4

คุณจะผลิต:

Nc2 Nb3 Nb5 Nc6 Ne6 Nf5 Nf3 Ne2

กฎ:

• ลำดับของผลลัพธ์ไม่สำคัญตราบใดที่มีการเคลื่อนไหวที่เป็นไปได้ทั้งหมดที่ระบุไว้
• การเคลื่อนไหวที่เป็นไปได้สามารถคั่นด้วยช่องว่างบรรทัดใหม่หรือตัวคั่นอื่น ๆ
• อินพุตสามารถส่งผ่านไปยังโปรแกรมเป็นพารามิเตอร์หรือผ่าน STDIN
• ช่องว่างในโปรแกรมจะถูกนับดังนั้นควรใช้ให้เกิดประโยชน์สูงสุด

นี่คือรหัสกอล์ฟ (โปรดหลีกเลี่ยงการใช้เครื่องมือ / ยูทิลิตี้ใด ๆ ที่ออกแบบมาเพื่อวัตถุประสงค์โดยเฉพาะ) คำตอบที่สั้นที่สุดชนะ!

GolfScript, 94 93 ตัวอักษร

โปรแกรม GolfScript ครั้งแรกของฉัน! ฉันใช้เวลาหลายชั่วโมงในการคลำหาสิ่งที่ฉันกำลังทำอยู่ แต่ฉันยืนยันและฉันคิดว่าฉันสามารถเรียนรู้พื้นฐานภาษาและกอล์ฟได้ดีพอสมควร

golfed อย่างเต็มที่ :

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

ความเห็นและแหล่งที่มาดีกว่า :

{}/              # 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
}/];

อาจดูเหมือนคำตอบของ Claudiu ซึ่งเป็นเพราะฉันอ้างถึงคำตอบของเขาเช่นเดียวกับโซลูชัน C ของฉัน (ไม่ได้ส่ง) ในขณะที่กำลังขุด เขาให้ตัวอย่างที่ดีของโปรแกรมซับซ้อน (ค่อนข้าง) ทำงานกับ GolfScript และมันช่วยให้ฉันเรียนรู้มากมายเกี่ยวกับภาษา ขอบคุณมาก Claudiu!

ยังใหม่กับ GolfScript ถ้าพวกคุณมีข้อเสนอแนะใด ๆ ฉันขอขอบคุณที่ได้ยิน

Python, 217 212 220 217 213 ตัวอักษร

เชื่อมโยงโซลูชัน Mathematica ขนาด 213 ไบต์

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)

ฉันเริ่มต้นด้วยการสร้างการเคลื่อนไหวที่ถูกต้องทั้งหมด แต่มันขยายใหญ่เกินไปดังนั้นวิธีการจึงค่อนข้างคล้ายกับ Mathematica

>>> 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

Mathematica, 278 272 264 260 215 213 ตัวละคร

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~#)&

เวอร์ชันที่ไม่ถูกปรับแต่ง:

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 *)
  ]
)&

ตัวอย่างการใช้งาน:

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

เวอร์ชั่นที่ไม่ได้สร้างจะสร้างกระดานเต็มและจากนั้นเลือกตำแหน่งที่ถูกต้องด้วยCasesในขณะที่รุ่นที่เล่นกอล์ฟจะปล่อยการเคลื่อนไหวที่ไม่ถูกต้องทันทีในTableคำสั่งโดยการออก##&[]ซึ่งก็หายไป

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

มันจะเป็นเรื่องยากที่จะสัมผัส Mathematica เมื่อมันมีท่าหมากรุกในตัว: rollseyes: (เล่นได้ดี m.buettner)ฉันเอามันกลับมาทั้งหมด ตี Mathematica โดย 31!

แก้ไขล่าสุด: เคสที่ถูกแทนที่ด้วยฟังก์ชันตัวกรองแบบอินไลน์เข้าสู่ความเข้าใจเพื่อเอาชนะรายการใน R;)

การใช้งาน:

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

Ungolfed (ตรงกับรุ่น char 208 ก่อนที่จะใส่ 'u'):

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]$'

มันทำงานอย่างไร

• ความคิดที่จะเป็นตัวแทนของข้อมูลบนกระดานทุกโดยค่าตัวเลขการพิกัดเป็นเลขฐาน 20 และ 200 ลบด้วยวิธีนี้a1จะกลายเป็น20 * 10 + 1 - 200 = 1, h8กลาย20 * 17 + 8 - 200 = 148เป็นต้น

  ตอนนี้การเคลื่อนไหวที่เป็นไปได้ของอธิการสามารถแสดงด้วยทวีคูณ (บวกหรือลบ) ของ 19 - จำนวนก้าวเท่ากัน (+20) และทางซ้าย (-1) - หรือ 21 - จำนวนก้าวเท่ากัน (+20) ) และทางขวา (+1)

  ตำแหน่งของร่างหลังจากการเคลื่อนย้ายเป็นเพียงผลรวมของตำแหน่งเดิมและการเคลื่อนไหว หลังจากเพิ่มตัวเลขเหล่านั้นเราต้องตรวจสอบว่าผลรวมของพวกเขาสอดคล้องกับเขตข้อมูลที่ถูกต้องบนกระดาน

  เนื่องจากฐาน (20) มีขนาดใหญ่กว่าสองเท่าของจำนวนสูงสุดที่เป็นไปได้ (8) ผลรวมไม่สามารถล้อมรอบกระดานได้เช่นการย้ายBh1เจ็ดขั้นตอนไปทางขวาและขึ้นจะส่งผลให้ตำแหน่งของบอร์ดไม่ถูกต้อง

• เส้น

  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})
  

  ร้านค้าระบุชิ้นในตัวแปรตำแหน่งเดิมเป็นตัวเลขแสดงในขและตัวอักษรไปชั่วโมงในอาร์เรย์d

  หลังจากที่ขยายตัวรั้งeval{,} echo '$'$aกลายเป็นeval eval echo '$'$a(ทวีคูณความชั่วร้าย) ซึ่งประเมินเช่นซึ่งประเมินeval echo $Kecho 1 19 20 21

• for i in $c -${c// / -};do …; done วนซ้ำไปมาการเคลื่อนไหวที่เป็นไปได้ทั้งหมดและลูกน้องเชิงลบของพวกเขา

• echo $a${d[$[(i+=b)/20]]}$[i%20] ให้ตำแหน่งสุดท้ายหลังจากการเคลื่อนไหว

• grep '[a-h][1-8]$' ทำให้แน่ใจว่าเรามีตำแหน่งคณะกรรมการที่ถูกต้อง

Golfscript, 144 135 ตัวอักษร

แทนที่จะลองเล่นPythonอย่างต่อเนื่องฉันแปลมันเป็น 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}/;;}/

การแปลที่ตรงไปตรงมาโดยไม่ต้องเล่นกอล์ฟมากนัก รับอินพุตจาก stdin โดยไม่ขึ้นบรรทัดใหม่ลองที่นี่ (สองบรรทัดแรกคือเลียนแบบ stdin)

C 634 632 629 625 600 ตัวอักษร

#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}}

ข้อเสนอแนะใด ๆ เกี่ยวกับวิธีการปรับปรุงนี้? นี่เป็นครั้งแรกที่ฉันส่งคำตอบ

Haskell, 300 269 ​​ตัวอักษร

ขอบคุณ bazzargh สำหรับความช่วยเหลือในการเสีย 31 ตัวอักษร ...

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}

อัลกอริทึมเช่นเดียวกับเวอร์ชั่น Mathematica ตัวอย่างผลลัพธ์จาก ghci:

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

(คุณไม่ได้ขอให้มีการตรวจสติ!)

Haskell, 446 ตัวอักษร

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)

เรียกได้ว่าใช้jฟังก์ชั่น

j "Nd4"

ฉันไม่ได้ทำงานกับ Haskell ในไม่กี่เดือนดังนั้นมันไม่ได้จบลงด้วยการที่สั้นที่สุดของการแก้ปัญหาอื่น ๆ hแต่ผมแน่ใจว่ามีการเพิ่มประสิทธิภาพบางอย่างที่จะทำส่วนใหญ่กับ ฉันอาจย่อให้สั้นลง

q & k [ 311 262 ตัวอักษร]

มีความเป็นไปได้ที่จะลดจำนวนอักขระเพิ่มขึ้น ฉันจะลดมันในการทำซ้ำครั้งต่อไป

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}

การใช้

โกง

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

กษัตริย์

g"ka1"
`a2`b1`b2

อัศวิน

g"na1"
`b3`c2

โคน

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

พระราชินี

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 ตัวอักษร

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="")}

เวอร์ชันที่ไม่ถูกปรับแต่ง:

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="")
}

การใช้งาน:

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

วิธีแก้ปัญหานั้นดีแม้อ่านได้ อย่างไรก็ตามฉันได้เพิ่มวงเล็บและความคิดเห็นสำหรับผู้อ่านที่ไม่คุ้นเคยกับรหัส R (ในเวอร์ชันที่ไม่ดี)

Haskell (สมมุติ), 248 ตัวอักษร

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))"ਲ਼ੁߏߚߙÈേെ൅ൄൃ൙൪ൻඌඝථ඿౿౾౽౼౻౺౹ಐಏಠಞರಭೀ಼೐ೋೠ೚೰೩"

น่าเสียดายที่ผู้รวบรวม Haskell ทุกคนที่ฉันสามารถเข้าใจได้ตอนนี้มีปัญหากับตัวอักษรสตริง Unicode นี่คือเวอร์ชัน (อีกต่อไป) ที่ใช้งานได้จริง:

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"

คำจำกัดความh x y=...คือฟังก์ชันแฮช การเคลื่อนไหวที่ถูกต้องจะแฮชไปยังหมายเลขตัวละครที่อยู่ในสตริง 41 อักขระ สิ่งนี้ทำให้ไม่จำเป็นต้องมีคำสั่ง "case" หรือเทียบเท่า

ฉันไม่ได้วางแผนที่จะทำงานเพิ่มเติมในตอนนี้ มันคงจะสนุกถ้าได้เห็นคนที่สามารถใช้ฟังก์ชั่นแฮชในภาษาที่กระชับกว่านี้เพื่อแก้ปัญหาที่สั้นกว่านี้