Jack dan Jane memutuskan untuk memainkan permainan catur untuk sementara waktu. Sayangnya, Jack agak buruk dalam memvisualisasikan. Dia merasa sulit untuk membayangkan gerakan yang mungkin untuk bagian tertentu selain bidak, tentu saja!

Tantangan Anda adalah membantu menemukan Jack opsi yang memungkinkan untuk karya yang diberikan (selain gadai).

Jika seseorang lupa, berbagai bagian dilambangkan dengan:

• K: Raja
• T: Ratu
• N: Ksatria
• B: Uskup
• R: Benteng

Sebagai contoh, pada gambar berikut Knight terletak di d4dan dapat pindah ke c2, b3, b5, c6, e6, f5, f3, e2. Untuk input yang diberikan:

Nd4

Anda akan menghasilkan:

Nc2 Nb3 Nb5 Nc6 Ne6 Nf5 Nf3 Ne2

Aturan:

• Urutan output tidak masalah selama semua gerakan yang mungkin terdaftar
• Pergerakan yang mungkin dapat dipisahkan dengan spasi putih, baris baru atau pembatas lainnya
• Input dapat diteruskan ke program sebagai parameter atau via STDIN
• Spasi putih dalam program harus dihitung, jadi manfaatkan secara optimal

Ini kode golf. (Harap menghindari penggunaan alat / utilitas yang dirancang khusus untuk tujuan itu.) Jawaban terpendek menang!

GolfScript, 94 93 karakter

Program GolfScript pertama saya! Ini membutuhkan waktu satu jam untuk mencari-cari tidak benar-benar tahu apa yang saya lakukan, tetapi saya bertahan dan saya pikir saya berhasil mempelajari dasar-dasar bahasa dan bermain golf dengan cukup baik.

Sepenuhnya golf :

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

Sumber yang dikomentari dan lebih bagus :

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

Ini mungkin terlihat seperti jawaban Claudiu, yang karena saya mereferensikan jawabannya, serta solusi C saya (yang tidak dikirim), sementara membuat jawaban saya. Dia memberikan spesimen yang baik dari program GolfScript yang bekerja (kompleks) kompleks, dan itu membantu saya belajar banyak tentang bahasa tersebut. Terima kasih, Claudiu!

Masih baru di GolfScript, jika kalian punya umpan balik, saya sangat senang mendengarnya!

Python, 217 212 220 217 213 karakter

Terikat solusi Mathematica 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)

Saya memulai dengan menghasilkan semua gerakan yang valid tetapi itu tumbuh terlalu besar sehingga pendekatannya sangat mirip dengan yang 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 karakter

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

Versi tidak disatukan:

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

Contoh penggunaan:

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

Versi ungolfed membuat papan penuh, dan kemudian memilih posisi yang benar dengan Cases, sedangkan versi golf menjatuhkan gerakan tidak valid segera dalam Tableperintah dengan mengeluarkan ##&[], yang hilang begitu saja.

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

Akan sulit untuk menyentuh Mathematica ketika itu memiliki gerakan catur bawaan: rollseyes: (dimainkan dengan baik oleh m.buettner) Saya mengambil semuanya kembali. Mengalahkan Mathematica pada usia 31!

Suntingan terakhir: penggantian case dengan fungsi, inline filter menjadi pemahaman, untuk mengalahkan entri dalam R;)

pemakaian:

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

Tidak Digubah (sesuai dengan 208 versi char sebelum 'u' diuraikan):

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

Bagaimana itu bekerja

• Idenya adalah untuk mewakili setiap bidang di papan tulis dengan nilai numerik, menggunakan koordinatnya sebagai angka dasar-20 dan mengurangi 200. Dengan cara ini, a1menjadi 20 * 10 + 1 - 200 = 1, h8menjadi 20 * 17 + 8 - 200 = 148, dll.

  Sekarang, kemungkinan pergerakan Uskup dapat diwakili oleh kelipatan (positif atau negatif) dari 19 - jumlah langkah yang sama (+20) dan ke kiri (-1) - atau 21 - jumlah langkah yang sama (+20) ) dan ke kanan (+1).

  Penempatan sosok setelah bergerak hanyalah jumlah dari posisi semula dan gerakannya. Setelah menambahkan angka-angka itu, kita harus memeriksa apakah jumlahnya sesuai dengan bidang yang valid di papan tulis.

  Karena basis (20) lebih dari dua kali lebih besar dari angka tertinggi yang dimungkinkan (8), jumlah tidak dapat membungkus papan, misalnya, memindahkan Bh1 tujuh langkah ke kanan dan naik akan menghasilkan posisi papan tidak valid.

• Garis

  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
  

  menghitung semua kemungkinan pergerakan potongan yang diwakili oleh angka positif.

• Perintahnya

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

  menyimpan pengenal potongan dalam variabel a , representasi numerik posisi awal dalam b dan huruf a hingga h dalam array d .

  Setelah penjepit ekspansi, eval{,} echo '$'$amenjadi eval eval echo '$'$a(kejahatan ganda), yang mengevaluasi, misalnya eval echo $K, yang mengevaluasi echo 1 19 20 21.

• for i in $c -${c// / -};do …; done loop semua gerakan yang mungkin dan rekan-rekan negatifnya.

• echo $a${d[$[(i+=b)/20]]}$[i%20] memberikan posisi akhir setelah gerakan.

• grep '[a-h][1-8]$' memastikan bahwa kami memiliki posisi dewan yang valid.

Golfscript, 144 135 karakter

Alih-alih terus mencoba golf solusi Python saya , saya menerjemahkannya ke 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}/;;}/

Terjemahan langsung tanpa banyak bermain golf sehingga kemungkinan besar dapat dikecilkan lebih jauh. Mengambil input dari stdin tanpa baris baru, coba di sini (dua baris pertama adalah untuk meniru stdin).

C 634 632 629 625 600 karakter

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

Ada saran tentang cara meningkatkan ini? Ini adalah pertama kalinya saya mengirimkan jawaban.

Haskell, 300 269 ​​karakter

Terima kasih kepada bazzargh untuk bantuan kehilangan 31 karakter ...

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}

Algoritma yang sama dengan versi Mathematica. Contoh keluaran dari ghci:

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

(Anda tidak meminta pemeriksaan kewarasan!)

Haskell, 446 karakter

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)

Disebut menggunakan jfungsi

j "Nd4"

Saya belum bekerja dengan Haskell dalam beberapa bulan, jadi itu tidak berakhir sesingkat sebagian besar solusi lain, tapi saya yakin ada beberapa optimasi yang dibuat, terutama dengan h. Saya mungkin mempersingkatnya sedikit.

q & k [ 311 262 karakter]

Ada potensi mengurangi beberapa karakter lagi. Saya akan mengurangi itu di iterasi berikutnya.

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}

Pemakaian

Benteng

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

Raja

g"ka1"
`a2`b1`b2

Ksatria

g"na1"
`b3`c2

Uskup

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

Ratu

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 karakter

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

Versi tidak disatukan:

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

Pemakaian:

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

Solusinya bahkan bisa dibaca. Namun saya menambahkan beberapa tanda kurung dan komentar untuk pembaca yang tidak terbiasa dengan kode R (pada versi yang tidak diklik).

Haskell (hipotetis), 248 karakter

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

Sayangnya, setiap kompiler Haskell yang bisa saya dapatkan sekarang memiliki masalah dengan string Unicode literal. Inilah versi (lebih panjang) yang benar-benar berfungsi:

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"

Definisi h x y=...adalah fungsi hash; bergerak valid akan hash ke nomor karakter yang ada di string 41 karakter. Ini menghilangkan kebutuhan akan pernyataan "kasus" atau yang setara.

Saya tidak berencana untuk bekerja lebih jauh tentang ini sekarang. Akan menyenangkan untuk melihat apakah seseorang dapat menggunakan fungsi hash dalam bahasa yang lebih ringkas untuk membuat solusi yang lebih pendek.