Jack und Jane beschlossen, eine Partie Schach zu spielen, um sich die Zeit zu vertreiben. Leider ist Jack ziemlich schlecht darin, sich etwas vorzustellen. Er findet es natürlich schwierig, herauszufinden, welche Züge für ein bestimmtes Stück außer einem Bauern möglich sind!

Ihre Herausforderung besteht darin, Jack dabei zu helfen, die möglichen Optionen für eine bestimmte Figur (außer einem Bauern) zu finden.

Falls man es vergessen hat, werden die verschiedenen Stücke bezeichnet mit:

• K: König
• F: Königin
• N: Ritter
• B: Bischof
• R: Turm

Als Beispiel wird der Ritter in dem folgende Bild angeordnet auf d4und bewegen kann c2, b3, b5, c6, e6, f5, f3, e2. Für eine bestimmte Eingabe:

Nd4

du würdest produzieren:

Nc2 Nb3 Nb5 Nc6 Ne6 Nf5 Nf3 Ne2

Regeln:

• Die Reihenfolge der Ausgabe spielt keine Rolle, solange alle möglichen Züge aufgelistet sind
• Die möglichen Züge können durch Leerzeichen, Zeilenumbrüche oder andere Trennzeichen getrennt werden
• Die Eingabe kann als Parameter oder über an das Programm übergeben werden STDIN
• Whitespace im Programm soll gezählt werden, nutzen Sie es also optimal

Das ist Code Golf. (Vermeiden Sie es, speziell für diesen Zweck entwickelte Tools / Dienstprogramme zu verwenden.) Die kürzeste Antwort gewinnt!

GolfScript, 94 93 Zeichen

Mein erstes GolfScript-Programm! Ich habe viele Stunden gebraucht, um herumzufummeln, ohne wirklich zu wissen, was ich tat, aber ich bestand darauf und denke, ich habe es geschafft, die Grundlagen der Sprache zu lernen und es ziemlich gut zu spielen.

Vollgolfen :

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

Kommentierte und schönere Quelle :

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

Es mag aussehen wie Claudius Antwort, weil ich mich auf seine Antwort sowie auf meine (nicht eingereichte) C-Lösung bezogen habe, während ich meine Antwort gemacht habe. Er lieferte ein gutes Exemplar eines (relativ) komplexen, funktionierenden GolfScript-Programms, und es half mir, viel über die Sprache zu lernen. Also danke, Claudiu!

Da Sie noch kein GolfScript-Neuling sind, würde ich mich über Feedback freuen!

Python, 217 212 220 217 213 Zeichen

Hat die 213-Byte-Mathematica-Lösung gebunden

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)

Ich begann damit, alle gültigen Züge zu generieren, die aber zu groß wurden, sodass der Ansatz dem von Mathematica ziemlich ähnlich ist.

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

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

Ungolfed-Version:

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

Anwendungsbeispiel:

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

Die ungolfed version erstellt ein volles Board und wählt dann die richtigen Positionen mit aus Cases, wohingegen die golfed version ungültige Züge sofort im TableKommando fallen lässt, indem sie absetzt ##&[], was einfach verschwindet.

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

Es wird schwierig sein, Mathematica zu berühren, wenn Schachzüge eingebaut sind: rollseyes: (gut gespielt m.buettner) Ich nehme alles zurück. Schlage Mathematica um 31!

Letzte Änderung: Ersetzte Groß- / Kleinschreibung durch eine inline Filterfunktion zum Verständnis, um den Eintrag in R zu übertreffen;)

Verwendung:

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

Ungolfed (entspricht der 208-Zeichen-Version vor dem Einfügen von '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]$'

Wie es funktioniert

• Die Idee ist, jedes Feld auf der Tafel durch einen numerischen Wert darzustellen, wobei seine Koordinaten als Zahl zur Basis 20 genommen und 200 subtrahiert werden. Auf diese Weise a1wird 20 * 10 + 1 - 200 = 1, h8wird 20 * 17 + 8 - 200 = 148, usw.

  Jetzt können die möglichen Züge des Bischofs durch (positive oder negative) Vielfache von 19 - gleiche Anzahl von Schritten (+20) und nach links (-1) - oder 21 - gleiche Anzahl von Schritten (+20) dargestellt werden ) und rechts (+1).

  Die Platzierung der Figur nach dem Zug ist einfach die Summe ihrer ursprünglichen Position und der Bewegung. Nachdem wir diese Zahlen addiert haben, müssen wir überprüfen, ob ihre Summe einem gültigen Feld auf der Tafel entspricht.

  Da die Basis (20) mehr als doppelt so groß ist wie die höchstmögliche Zahl (8), kann die Summe nicht um das Brett gewickelt werden. Wenn Sie z. B. Bh1 sieben Schritte nach rechts und oben bewegen , wird die Position des Bretts ungültig.

• Die Linie

  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
  

  listet alle möglichen Züge der Teile auf, die durch positive Zahlen dargestellt werden.

• Die Befehle

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

  Speichert den Stückidentifikator in der Variablen a , die numerische Darstellung der ursprünglichen Position in b und die Buchstaben a bis h im Array d .

  Nach der Klammererweiterung eval{,} echo '$'$awird eval eval echo '$'$a(doppelt böse), was z. B. eval echo $Kauswertet, was auswertet echo 1 19 20 21.

• for i in $c -${c// / -};do …; done Schleifen über alle möglichen Bewegungen und ihre negativen Gegenstücke.

• echo $a${d[$[(i+=b)/20]]}$[i%20] gibt die endgültige Position nach der Bewegung an.

• grep '[a-h][1-8]$' stellt sicher, dass wir eine gültige Boardposition haben.

Golfscript, 144 135 Zeichen

Anstatt meine Python-Lösung weiter zu testen, übersetzte ich sie in 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}/;;}/

Unkomplizierte Übersetzung ohne viel Golfspiel, sodass es höchstwahrscheinlich noch weiter entfallen kann. Nimmt die Eingabe von stdin ohne eine neue Zeile an, probieren Sie es hier aus (die ersten beiden Zeilen imitieren stdin).

C 634 632 629 625 600 Zeichen

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

Irgendwelche Vorschläge, wie man das verbessern kann? Ich sende zum ersten Mal eine Antwort.

Haskell, 300 269 ​​Zeichen

Vielen Dank an bazzargh für die Hilfe beim Verlust von 31 Charakteren ...

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}

Gleicher Algorithmus wie die Mathematica-Version. Beispielausgabe von ghci:

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

(Sie haben nicht um Überprüfung der geistigen Gesundheit gebeten!)

Haskell, 446 Zeichen

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)

Wird über die jFunktion aufgerufen

j "Nd4"

Ich habe seit einigen Monaten nicht mehr mit Haskell zusammengearbeitet, daher war es nicht so kurz wie die meisten anderen Lösungen, aber ich bin sicher, dass es einige Optimierungen gibt, die hauptsächlich mit Haskell vorgenommen werden müssen h. Ich könnte es ein bisschen verkürzen.

q & k [ 311 262 Zeichen]

Es besteht die Möglichkeit, weitere Zeichen zu reduzieren. Ich werde es in der nächsten Iteration reduzieren.

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}

Verwendung

Turm

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

König

g"ka1"
`a2`b1`b2

Ritter

g"na1"
`b3`c2

Bischof

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

Königin

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 Zeichen

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

Ungolfed-Version:

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

Verwendung:

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

Die Lösung ist sogar gut lesbar. Ich habe jedoch einige Klammern und Kommentare für Leser hinzugefügt, die mit R-Code nicht vertraut sind (auf der ungolfed-Version).

Haskell (hypothetisch), 248 Zeichen

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

Leider hat jeder Haskell-Compiler, den ich gerade in die Finger bekomme, Probleme mit Unicode-String-Literalen. Hier ist die (längere) Version, die tatsächlich funktioniert:

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"

Die Definition h x y=...ist eine Hash-Funktion. Bei gültigen Zügen werden die in der 41-stelligen Zeichenfolge enthaltenen Zeichennummern mit einem Hash versehen. Dadurch entfällt die Notwendigkeit einer "case" -Anweisung oder einer gleichwertigen Anweisung.

Ich habe momentan nicht vor, weiter daran zu arbeiten. Es würde Spaß machen zu sehen, ob jemand eine Hash-Funktion in einer präziseren Sprache verwenden kann, um eine kürzere Lösung zu finden.