कितने चलते हैं?

Question

एक शतरंज बोर्ड और टुकड़े के प्रकार पर दो अलग-अलग स्थितियों को देखते हुए, उस टुकड़े को एक स्थान से दूसरे स्थान पर जाने के लिए न्यूनतम चालें चलेंगी।

नियम

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

2 पदों को किसी भी सुविधाजनक प्रारूप में लिया जा सकता है,

Example:
a8 b8 c8 d8 ... h8
a7 b7 c7 d7 ... h7
...
...
a1 b1 c1 d1 ... h1

यदि टुकड़ा वहां नहीं पहुंच सकता है, तो सकारात्मक पूर्णांक के अलावा कुछ भी आउटपुट नहीं हो सकता है।

उदाहरण

i/p ---- o/p
King
a1,a4    3
a1,h6    7
b3,h5    6

Queen
a1,a4    1
a1,h6    2
b3,f7    1

Rook
a1,a4    1
a1,h6    2
h2,c7    2

Knight
a1,a4    3
a1,h6    4
b2,d3    1
b2,c3    2
b3,c3    3
a1,b2    4

Bishop
a1,a4    -1
a1,h6    2
b2,d3    -1
e1,h4    1

Comments

राजा को १२ से १-एच ६ की आवश्यकता क्यों है? क्या राजा नहीं जा सकते हैं?

— l4m2

@ l4m2, सुधारा गया

— वेदांत

@ng, आप अनुपयोगिता को इंगित करने के लिए 0 का उपयोग कर सकते हैं, 2 स्थितियां हमेशा अलग होंगी।

— वेदांत कंडोई

सभी शूरवीर दूरी

— अरनुलद

प्राकृतिक संख्याओं की कुछ परिभाषाएँ (जैसे ISO-80000-2) में 0. सकारात्मक "पूर्णांक" के साथ प्रतिस्थापित करने की सिफारिश की गई है।

Answer 1

जावास्क्रिप्ट (Node.js) , 183 180 179 बाइट्स

with(Math)(a,b,c,d,t,x=abs(a-c),y=abs(b-d),v=x<y?y:x,q=0|.9+max(/[18][18]/.test(a+b+9+c+d)-v?x/2:3,y/2,x*y?x*y-4?(x+y)/3:3:2))=>t?t==2&x+y?0:t&1>x*y|t/2&x==y?1:t<4?2:v:q+(q+x+y&1)

इसे ऑनलाइन आज़माएं!

बढ़त के मामले के लिए लंबे समय से, जाँच के लिए अरनॉल्ड को धन्यवाद। नाइट टेस्ट

Comments

@ अर्नुलड वेल कॉर्नर वास्तव में लागत

— l4m2

मुझे लगता है कि आप अंतिम maxको एक टर्नरी के साथ बदलकर एक बाइट को बचाने में सक्षम हो सकते हैं ।

— झबरा

170 बाइट्स (मुझे लगता है कि मैं अपने फोन पर हूं।)

— झबरा

@ शगनी ने अरनुलद को गलत कहा था

— l4m2

Answer 2

APL (Dyalog Classic) , 117 107 105 103 98 98 97 95 92 89 बाइट्स

{(⍎⍺⊃'⌈/' '≢∘∪~∘0' '+/×' '{⍺∊⍵:0⋄1+⍺∇i/⍨∨⌿2=|×/↑⍵∘.-i←,⍳8 8}/,¨⊂¨↓⍵' '≢∘∪×2=.|⊢')⊣|-⌿⍵}

इसे ऑनलाइन आज़माएं!

बायाँ arg टुकड़ा प्रकार है: 0 = राजा, 1 = रानी, ​​2 = किश्ती, 3 = नाइट, 4 = बिशप; सही arg एक 2x2 मैट्रिक्स का तार है, जो प्रत्येक पंक्ति को एक स्थिति का प्रतिनिधित्व करता है; अप्राप्य के लिए रिटर्न 0

|-⌿⍵ जोड़ी की गणना करता है [abs (∆x), abs ()y)]

(⍎⍺⊃... )⊣"..." सूची से एक अभिव्यक्ति चुनता है; यदि यह एक फ़ंक्शन है, तो इसे लागू किया जाता है |-⌿⍵; यदि यह एक मूल्य है (यह केवल एक नाइट के लिए होता है), ⊣इसके बजाय इसे वापस करना सुनिश्चित करता है|-⌿⍵

• राजा: ⌈/abs (:-s ) का अधिकतम

• रानी: जीरो हटाओ ( ~∘0) और गिनती ( ≢) अद्वितीय ( ∪)

• रूक: सिग्मा ( +/) के संकेत (राक्षसी ×; 0 के लिए 0, 1 सकारात्मक के लिए)

• शूरवीर: {⍺∊⍵:0⋄1+⍺∇i/⍨∨⌿2=|×/↑⍵∘.-i←,⍳8 8}/,¨⊂¨↓⍵- प्रारंभिक स्थिति से शुरू करते हैं और अंतिम चरण में सेट होने तक नाइट चालों की पुनरावर्ती गणना करते हैं; वापसी पुनरावृत्ति गहराई

• बिशप: दो s एस के बराबर हैं? ( 2=.|⊢, समकक्ष =/2|⊢) गणना-अद्वितीय द्वारा बूलियन परिणाम (0 या 1) को गुणा करें ( ≢∘∪)

Comments

मैं प्यार करता हूँ ⍎⍺⊃। बहुत चालाक।

— जे। साले

@ J.Sallé धन्यवाद

— ngn

Answer 3

जावा (JDK) , 229 बाइट्स

(p,a,b,c,d)->{c^=a/4*7;a^=a/4*7;d^=b/4*7;b^=b/4*7;int x=c<a?a-c:c-a,y=d<b?b-d:d-b,z=(x^=y^(y=y<x?y:x))-y;return p<1?x:p<2?z*y<1?1:2:p<3?2-z%2:p<4?x+y<2?3:(a<c?a+b:c+d)+x<2|x==2&z<1?4:z+2*Math.ceil((y-z)/(y>z?3:4.)):z<1?1:~z*2&2;}

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण

• बोर्ड 0-आधारित बोर्ड है।
• लौटाया गया मान एक पूर्णांक है, जिसे दोहरे के रूप में दर्शाया गया है। कोई दशमलव भाग कभी नहीं होगा।

कोड:

(p,a,b,c,d)->{                          // double-returning lambda.
                                        // p is the piece-type (0: king, 1: queen, 2: rook, 3: knight, 4: bishop)
                                        // a is the origin-X
                                        // b is the origin-Y
                                        // c is the destination-X
                                        // d is the destination-Y
 c^=a/4*7;a^=a/4*7;                     // Mirror board if origin is in the top part of the board
 d^=b/4*7;b^=b/4*7;                     // Mirror board if origin is in the left part of the board
 int x=c<a?a-c:c-a,                     // x is the X-distance between a and c
     y=d<b?b-d:d-b,                     // y is the Y-distance between b and d
     z=(x^=y^(y=y<x?y:x))-y;            // z is the delta between x and y
                                        // also, swap x and y if necessary so that x is the greater value.
               //    At this point,
               //     x      cannot be 0 (because the two positions are different)
               //     z<1    means the origin and destination are on the same diagonal
               //     y<1    means the origin and destination are on the same horizontal/vertical line
 return
  p<1?x:                                //  For a king, just take the max distance.
  p<2?z*y<1?1:2:                        //  For a queen, just move once if in direct line, or twice.
  p<3?2-z%2:                            //  For a rook, just move once if on the same horizontal or vertical line, or twice
  p<4?                                  //  For a knight, 
   x+y<2?3:                             //   Hardcode 3 if moving to the next horizontal/vertical square
   (a<c?a+b:c+d)+x<2|x==2&z<1?4:        //   Hardcode 4 if moving 2 cases in diagonal or one case in diagonal in a corner.
   z+2*Math.ceil((y-z)/(y>z?3:4.)):     //   Compute the number of moves necessary for the usual cases
  z<1?1:                                //  For a bishop, hardcode 1 if they are on the same diagonal
   ~z*2&2;                              //   Return 2 if they have the same parity else 0.
}

क्रेडिट

• -2 बाइट्स अरनॉल्ड के लिए धन्यवाद , साथ ही मुझे यह महसूस करने के लिए कि मेरे सभी कोने-मामलों के साथ एक मुद्दा था।

Answer 4

चारकोल , 108 बाइट्स

Ｆ…β⁸Ｆ⁸⊞υ⁺ι⊕κ≔⟦⟦η⟧⟧δＷ¬№§δ±¹ζ⊞δΦυΦ§δ±¹⁼⁵ΣＥμＸ⁻℅ξ℅§κπ²≔Ｅη↔⁻℅ι℅§ζκε≡θKＩ⌈εQＩ∨∨¬⌊ε⁼⊟ε⊟ε²RＩ∨¬⌊ε²BＩ∧¬﹪Σε²∨⁼⊟ε⊟ε²NＩ⊖Ｌδ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｆ…β⁸Ｆ⁸⊞υ⁺ι⊕κ

बोर्ड के सभी 64 वर्गों को पूर्वनिर्धारित खाली सूची चर में सूचीबद्ध करें।

≔⟦⟦η⟧⟧δ

उन सूचियों की सूची बनाएं जिनकी पहली प्रविष्टि एक सूची है जिसमें प्रारंभ स्थिति है।

Ｗ¬№§δ±¹ζ

सूची की अंतिम प्रविष्टि के अंत तक दोहराएं।

⊞δΦυΦ§δ±¹⁼⁵ΣＥμＸ⁻℅ξ℅§κπ²

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

≔Ｅη↔⁻℅ι℅§ζκε

प्रारंभ और अंत पदों के बीच पूर्ण समन्वय अंतर की गणना करें।

≡θ

इनपुट टुकड़े के आधार पर चयन करें।

KＩ⌈ε

यदि यह एक राजा है तो अधिकतम पूर्ण समन्वय अंतर को प्रिंट करें।

QＩ∨∨¬⌊ε⁼⊟ε⊟ε²

यदि यह एक रानी है तो 2 प्रिंट करें जब तक कि दो अंतर समान या एक शून्य न हों।

RＩ∨¬⌊ε²

यदि यह एक बदमाश है तो 2 प्रिंट करें जब तक कि मतभेदों में से एक शून्य न हो।

BＩ∧¬﹪Σε²∨⁼⊟ε⊟ε²

यदि यह एक बिशप है, तो 0 प्रिंट करें यदि वर्ग विपरीत समानता के हैं अन्यथा 2 प्रिंट करें जब तक कि दो अंतर समान नहीं हैं।

NＩ⊖Ｌδ

यदि यह एक शूरवीर है तो अंतिम स्थिति का पता लगाने के लिए उठाए गए छोरों की संख्या को प्रिंट करें।

Answer 5

जाप , 67 बाइट्स

®ra
g[_rw}_â è}@=ã ü;@pUÌïVõ á ÈíaY})Ìde[TT]}a Ä}_è}_ra v *Zâ l}]gV

इसे ऑनलाइन आज़माएं!

वह काफी एक अनुभव था। मैंने उत्कृष्ट एपीएल उत्तर से बहुत प्रेरणा ली । मुझे संदेह है कि विशेष रूप से नाइट कोड में अभी भी बहुत अधिक गोल्फिंग संभव है।

पदों का पहला इनपुट है, फॉर्म में [[x1,x2],[y1,y2]]। इस पर भी ठीक काम करना चाहिए [[y1,y2],[x1,x2]]। टुकड़ा चयन 0 = राजा, 1 = रानी, ​​2 = नाइट, 3 = किश्ती, 4 = बिशप के साथ दूसरा इनपुट है। ध्यान दें कि APL उत्तर की तुलना में नाइट और रूक की अदला-बदली की जाती है।

स्पष्टीकरण:

®ra         :Turn absolute positions into relative movement and store in U
®           : For each of X and Y
 ra         : Get the absolute difference between the start position and the end position

g[...]gV    :Apply the appropriate function
 [...]      : A list of functions
      gV    : Get the one indicated by the second input
g           : Apply it to U

_rw}        :King function
 rw         : Get the maximum of X and Y

_â è}       :Queen function
 â          : Get unique elements
   è        : Count non-zero elements

@=ã ü;@pUÌï2õ á ÈíaY})Ìde[TT]}a Ä}  :Knight function
 =ã ü;                              : Wrap U twice (U -> [[U]])
      @                      }a Ä   : Repeat until True; return number of tries:
        UÌ                          :  Get the previous positions
          ï                         :  Cartesian product with:
           2õ                       :   The range [1,2]
              á                     :   All permutations, i.e. [[1,2],[2,1]]
                ÈíaY})              :  Apply each move to each position
       p                            :  Store the new positions
                      Ìde[TT]       :  True if any are at the destination

_è}         :Rook function
 è          : Count non-zero elements

_ra v *Zâ l}    :Bishop function
 ra             : Absolute difference between X and Y
    v           : Is divisible by 2? (returns 1 or 0)
      *         : Times:
       Zâ       :  Get the unique elements
          l     :  Count them

Comments

@ETHproductions अच्छे सुझाव। जब मैं उन्हें अंदर डाल रहा था तो मुझे पता चला कि áकाम करना [[1,2][2,1]]काफी कम हो गया है।

— कामिल दकरी

वाह, कभी इस्तेमाल करने के लिए नहीं सोचा होगा á, अच्छा!

— 1

कुछ और सुझाव: के Uबाद निहित है @, तो आप नाइट फ़ंक्शन में दो बाइट्स बचा सकते हैं। आप इसे @=ã ü;दूसरे को बचाने के लिए भी शुरू कर सकते हैं । ( ãचाल बहुत चालाक है :-))

— ETHproductions

@ETHproductions अच्छा लगता है, जिस समय U को निहित किया जाता है वह उन चीजों में से एक है जिन्हें मैंने अभी तक पूरी तरह से समझा नहीं है।

— कामिल दकरी