मुझे चाल बताओ

Question

जैक और जेन ने समय को दूर करने के लिए शतरंज का खेल खेलने का फैसला किया। दुर्भाग्य से, जैक कल्पना करने के बजाय बुरा है। वह निश्चित रूप से एक मोहरे के अलावा किसी दिए गए टुकड़े के लिए संभव चालों का पता लगाने के लिए कठिन लगता है, बिल्कुल!

आपकी चुनौती जैक को दिए गए टुकड़े (एक मोहरे के अलावा) के लिए संभावित विकल्प खोजने में मदद करना है।

यदि कोई भूल गया है, तो विभिन्न टुकड़ों को निरूपित किया जाता है:

• K: राजा
• प्रश्न: रानी
• N: नाइट
• ब: बिशप
• R: रूक

उदाहरण के लिए, निम्न छवि में नाइट पर स्थित है d4और करने के लिए स्थानांतरित कर सकते हैं c2, b3, b5, c6, e6, f5, f3, e2। दिए गए इनपुट के लिए:

Nd4

आप उत्पादन करेंगे:

Nc2 Nb3 Nb5 Nc6 Ne6 Nf5 Nf3 Ne2

नियम:

• आउटपुट का क्रम तब तक मायने नहीं रखता है जब तक कि सभी संभावित चालें सूचीबद्ध हैं
• संभव चाल को व्हाट्सएप, न्यूलाइन्स या किसी अन्य सीमांकक द्वारा अलग किया जा सकता है
• इनपुट को प्रोग्राम में पैरामीटर या के माध्यम से पास किया जा सकता है STDIN
• कार्यक्रम में व्हॉट्सएप की गिनती की जाएगी, इसलिए इसका अधिकतम उपयोग करें

यह कोड गोल्फ है। (कृपया किसी भी उपकरण / उपयोगिताओं का उपयोग करने से बचें, विशेष रूप से उद्देश्य के लिए डिज़ाइन किया गया है।) सबसे छोटा उत्तर जीतता है!

Comments

मेरा मानना ​​है कि यह कोड गोल्फ के रूप में ठीक काम करेगा

— जॉन ड्वोरक

कोड गोल्फ बेहतर विकल्प है। स्पष्ट हमेशा भुला दिया जाता है: मैं समझता हूं कि हम या तो एक फ़ंक्शन या प्रोग्राम सबमिट कर सकते हैं, और वह इनपुट / आउटपुट या तो स्टडिन / स्टाउट या पैरामीटर / रिटर्न मान हो सकता है। मैं सोच रहा हूँ कि रानी के लिए यहाँ पुनरावर्तन उपयोगी हो सकता है: f(x)... case "Q": {f("B");f("R")}यदि फ़ंक्शन को किसी भी तरह की आवश्यकता होती है, तो ये बाइट काउंट का हिस्सा होना चाहिए।

— लेवल रिवर सेंट

उस ग्राफ़िक में फ़ॉन्ट। xD

— cjfaure

क्या संभावित चालों को रिक्त स्थान द्वारा अलग किया जाना है या नए रूप में भी ठीक है?

— डेनिस

एक मोहरे के लिए कानूनी चालें किसी भी अन्य टुकड़े (एन पासेंट, विकर्ण कैप्चरिंग और 2-वर्ग प्रारंभिक चाल) की तुलना में अधिक जटिल हैं। इसलिए मुझे लगता है कि जैक में भी कालिंग नियम याद किए जाते हैं?

— आर्दनेव

Answer 1

GolfScript, 94 93 अक्षर

मेरा पहला कभी गोल्फस्क्रिप्ट कार्यक्रम! यह वास्तव में मुझे पता नहीं था कि मैं क्या कर रहा था, इसके चारों ओर कई घंटे की लड़खड़ाहट हुई, लेकिन मुझे लगता है कि मुझे लगता है कि मैं भाषा की बुनियादी बातों को सीखने में कामयाब रहा और इसे काफी अच्छी तरह से गोल्फ बना पाया।

पूरी तरह से गोल्फ :

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

यह क्लोडिउ के उत्तर की तरह लग सकता है, जिसका कारण यह है कि मैंने उनके जवाब का उल्लेख किया है, साथ ही मेरा (असंतुष्ट) सी समाधान, मेरा बनाते समय। उन्होंने एक (अपेक्षाकृत) जटिल, काम करने वाले गोल्फस्क्रिप्ट कार्यक्रम का एक अच्छा नमूना प्रदान किया, और इससे मुझे भाषा के बारे में बहुत कुछ सीखने में मदद मिली। तो धन्यवाद, क्लाउडीयू!

यदि आप लोगों के पास कोई प्रतिक्रिया है, तो अभी भी GolfScript के लिए नया होना, मैं इसे सुनना चाहता हूँ!

Comments

बहुत बढ़िया! अच्छा काम =)। मुझे यह देखने के लिए बाद में और अधिक बारीकी से देखना होगा कि आपको मेरी तुलना में 40 चार्ट कम कैसे मिले। क्या गोल्फस्क्रिप्ट मजेदार नहीं है?

— Claudiu

Answer 2

अजगर, 217 212 220 217 213 पात्रों

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)

मैंने सभी वैध चालें पैदा करके शुरुआत की लेकिन वह बहुत बड़ी हो गई इसलिए दृष्टिकोण मैथेमेटिका के समान है।

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

Comments

इस तर्क के साथ स्ट्रिंग वर्णों का अच्छा निष्कर्षण। बहुत बुरा यह अजगर 3 में अब काम नहीं करता है

— इवपोक

Answer 3

गणितज्ञ, 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~#)&

Ungolfed संस्करण:

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जारी करने से कमांड में अमान्य चाल को तुरंत छोड़ देता है ##&[], जो बस गायब हो जाता है।

Comments

बस इनपुट के बारे में उत्सुक है, यह है N4d? Nd4इसके बजाय नहीं होना चाहिए ?

— देवनाउल

@ देवनुल यकीन है, कि एक टाइपो है। होना चाहिए Nd4।

— मार्टिन एंडर

एक आज समारोह पता था कि सीखाChessboardDistance

— बेंत की मार

मैथेमेटिका / वुल्फ्राम भाषा के दस्तावेज़ के अनुसार, "शतरंजबोर्ड [यू, वी] मैक्स [एबीएस [यूवी]] के बराबर है।" शायद आप बाद के रूप का उपयोग करके पात्रों को बचा सकते हैं, खासकर यदि आप Abs [uv] को | uv |

— माइकल स्टर्न

@MichaelStern यही ठीक है कि मैं गोल्फ संस्करण में क्या कर रहा हूं;)। और दुर्भाग्य से ऊर्ध्वाधर पट्टियाँ Absगणितज्ञों के लिए काम नहीं करती हैं , क्योंकि वे एक पैटर्न में विकल्पों को दर्शाते हैं।

— मार्टिन एंडर

Answer 4

हास्केल 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]]

यह मुश्किल है जब गणितज्ञों को छूना मुश्किल हो जाता है जब इसमें शतरंज की चाल चलती है: रोलसे: (अच्छी तरह से खेला जाने वाला m.buettner) मैं इसे वापस ले लेता हूं। 31 से गणितज्ञ की पिटाई!

नवीनतम संपादित: एक समारोह के साथ मामले को बदल दिया, समझ में फ़िल्टर को इनलेट, आर में प्रविष्टि को हरा करने के लिए;)

उपयोग:

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

Ungolfed ('यू' इनबिल्ट होने से पहले 208 चार संस्करण से मेल खाती है):

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.

Comments

क्या आप एक अनऑर्गोलेटेड संस्करण भी पोस्ट कर सकते हैं? (आप निश्चित रूप से एक है)

— बेंत की मार

@swish I do but I don’t माइंड राइटिंग दैट अप।

— bazzargh

@ सतीश ने किया। आशा है कि अधिक समझ में आता है। अगर आपको कुछ स्पष्ट करने की आवश्यकता हो तो पूछें।

— bazzargh

अच्छा काम! आपको pieceसूची में जोड़ने की आवश्यकता क्यों है [piece,newfile, newrank]यदि आप इसे पैटर्न मिलान में उपयोग नहीं करते हैं, तो आप कुछ पात्रों को बचा सकते हैं?

— बेंत की मार

यह आउटपुट के लिए है। आप देखेंगे कि '... प्रत्येक संभावित चाल ...' में मैं इस पर पैटर्न का मिलान नहीं करता। मूल रूप से मेरे पास यह नहीं था - शतरंज की चालों को इसकी आवश्यकता नहीं है - लेकिन फिर मैंने देखा कि प्रश्न यह चाहता था, और बाकी सभी ने ऐसा किया, इसलिए यह केवल उचित था।

— बजरघ

Answer 5

बैश, 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})
  

  भंडार चर में टुकड़ा के पहचानकर्ता एक , में मूल स्थिति के संख्यात्मक प्रस्तुति ख और पत्र एक को ज सरणी में घ ।

  ब्रेस विस्तार के बाद, (दोगुनी बुराई) eval{,} echo '$'$aहो जाती है eval eval echo '$'$a, जो मूल्यांकन करता है, जैसे eval echo $K, जो मूल्यांकन करता है echo 1 19 20 21।

• for i in $c -${c// / -};do …; done सभी संभव आंदोलनों और उनके नकारात्मक समकक्षों पर छोरों।

• echo $a${d[$[(i+=b)/20]]}$[i%20] आंदोलन के बाद अंतिम स्थिति देता है।

• grep '[a-h][1-8]$' यह सुनिश्चित करता है कि हमारे पास एक मान्य बोर्ड स्थिति है।

Answer 6

गोल्फस्क्रिप्ट, 144 135 अक्षर

अपने पायथन समाधान को जारी रखने की कोशिश करने के बजाय , मैंने इसे गोल्फस्क्रिप्ट में अनुवादित किया:

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

बहुत अधिक गोल्फ के बिना सीधा अनुवाद, इसलिए यह सबसे अधिक संभावना है कि आगे दूर किया जा सकता है। एक नई लाइन के बिना स्टडिन से इनपुट लेता है, इसे यहां आज़माएं (पहली दो लाइनें स्टिक की नकल करने के लिए हैं)।

Comments

अच्छा काम करने लगता है! मुझे आशा है कि किसी को एक ब्रेनफ * सीके समाधान भी आता है।

— देवनुल

Answer 7

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

इसे बेहतर बनाने के बारे में कोई सुझाव? यह मेरा पहली बार जवाब प्रस्तुत करना है।

Comments

कोड गोल्फ में आपका स्वागत है! के साथ शुरू करने के लिए, आप अपने कोड में व्हाट्सएप को बंद कर सकते हैं। याद रखें कि यह कोड गोल्फ है, जिसका अर्थ है कि सबसे छोटा कोड जीतता है। इसलिए अपने कार्यक्रम के आकार को कम करने का प्रयास करें।

— देवनाउल

वर्ण गणना भी अपडेट करना याद रखें!

— देवनुल

@ देवनबुल आवश्यक स्थान गिने जाते हैं?

— कैलक्लिप्टो

एक और बात: Cटर्नरी ऑपरेटर ?:का उपयोग करके और वापसी मूल्य का उपयोग करके बहुत सरल किया जा सकता है printf। ( printfलिखा वर्णों की संख्या देता है, इसलिए इस मामले में यह हमेशा गैर-शून्य है।) C(P,c,r){return(0<=c)&(c<8)&(0<r)&(r<9)?printf("%c%c%d ",P,c+'a',r):0;}। एक मामूली संपादन: इसके Mबाद एक अतिरिक्त जगह है ifजिसे आप हटा सकते हैं।

— user12205

अभी, आप किसी भी नई सूची को नहीं गिन रहे हैं। जबकि उनमें से कुछ को हटाया जा सकता है, दूसरों को नहीं। आवश्यक नई सूचियों को बाइट की गिनती में निश्चित रूप से योगदान देना चाहिए।

— डेनिस

Answer 8

हास्केल, 300 269 ​​चार्ट

31 पात्रों को खोने के लिए मदद के लिए bazzargh के लिए धन्यवाद ...

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

(आप विवेक की जाँच के लिए नहीं पूछा!)

Comments

आप सिंथैटिक व्हाट्सएप से छुटकारा पा सकते हैं। मेरा उत्तर यहाँ देखें: codegolf.stackexchange.com/questions/19255/… (अधिक विशिष्ट होने के लिए, आप {h = d (x !! 1) (y !! 1); ...})

— bazzarf

Answer 9

हास्केल, 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"

मैंने हास्केल के साथ कुछ महीनों में काम नहीं किया है, इसलिए यह अन्य समाधानों की तुलना में कम नहीं था, लेकिन मुझे यकीन है कि मुख्य रूप से कुछ अनुकूलन किए गए हैं h। मैं इसे थोड़ा छोटा कर सकता हूं।

Answer 10

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

Answer 11

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

Ungolfed संस्करण:

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"

समाधान भी अच्छा पठनीय है। हालांकि मैंने आर कोड (अपरिष्कृत संस्करण पर) से अपरिचित पाठकों के लिए कुछ कोष्ठक और टिप्पणियाँ जोड़ीं।

Answer 12

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

दुर्भाग्य से, हर हास्केल संकलक मैं अपने हाथों को अभी प्राप्त कर सकता है जिसमें यूनिकोड स्ट्रिंग शाब्दिक के साथ समस्याएं हैं। यहाँ (लंबा) संस्करण है जो वास्तव में काम करता है:

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-वर्ण स्ट्रिंग में हैं। इससे "केस" कथन या समकक्ष की आवश्यकता से छुटकारा मिलता है।

मैं अभी इस पर आगे काम करने की योजना नहीं बना रहा हूं। यह देखना मजेदार होगा कि क्या कोई व्यक्ति छोटे समाधान बनाने के लिए अधिक संक्षिप्त भाषा में हैश फ़ंक्शन का उपयोग कर सकता है।