क्या यह पुनरावृत्ति द्वारा ड्रा है?

Question

मुसीबत:

शतरंज में, पुनरावृत्ति द्वारा ड्रा के बारे में कुछ हद तक ज्ञात नियम है। यदि एक ही स्थिति 3 बार (या अधिक) दोहराई जाती है, तो खिलाड़ी इस चाल को बनाने का इरादा रखता है जिसके कारण यह दोहराव ड्रॉ का दावा कर सकता है।

कभी-कभी किसी मध्यस्थ के लिए यह एक आसान काम होता है, अगर आखिरी कुछ चालें सिर्फ पीछे और आगे की तरफ बढ़ने वाले खिलाड़ी होते हैं। कभी-कभी यह कम तुच्छ होता है, जब बार-बार पदों के बीच टुकड़े काफी बढ़ गए हैं।

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

---

एक स्थिति क्या है?

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

---

मान्य संकेतन कैसा दिखता है?

हालांकि मैं समन्वय संकेतन की व्याख्या करने के लिए आगे बढ़ूंगा, आप अपने द्वारा चुने गए एक संकेतन प्रणाली द्वारा इनपुट लेने के लिए स्वतंत्र हैं। उसे उपलब्ध कराया:

• संकेतन में प्रत्येक वस्तु किसी या सभी का वर्णन करती है: टुकड़ा / टुकड़े शामिल; क्या चेक, चेकमेट, डबल चेक, चेकमेट या गतिरोध वितरित किया गया है; यदि एन-पासेंट कैप्चर हुआ है; प्रारंभिक स्थिति; अंतिम स्थिति।
• आपको अपने नोटेशन में पुनरावृत्ति के बारे में जानकारी नहीं हो सकती है।

इसलिए जब तक ये मानदंड पूरे नहीं हो जाते, मुझे स्वीकार करने में खुशी होती है, जब तक कि आप अपने उत्तर, अपने अंकन प्रणाली में निर्दिष्ट करते हैं। यह हो सकता है जैसे 0 अनुक्रमित पंक्ति, स्तंभ ट्यूपल्स या जो भी आपके कार्यक्रम के लिए समझ में आता है।

---

समन्वय की सूचना

समन्वय संकेतन एक संकेतन है जो विशुद्ध रूप से चाल को निर्देशांक की प्रणाली के रूप में वर्णित करता है।

एक चाल को पहले सेट से शुरुआती समन्वय के रूप में वर्णित किया जाता है {A1-H8}और फिर उसी सेट से गंतव्य फिर से समन्वयित होता है। तो राजा का गम्बित (स्ट्रिंग्स के संग्रह के रूप में) दिखेगा

{"E2-E4","E7-E5","F2-F4"}

मेरा मानना ​​है कि यह इस समस्या के लिए उपयोग करने के लिए सबसे अच्छा अंकन है क्योंकि यह बाहरी जानकारी से अटे नहीं है जैसे कि चेक हुआ है या किस प्रकार का टुकड़ा घूम रहा है। जैसा कि उल्लेख से पहले उल्लेख आपकी पसंद का हो सकता है, इसलिए आप अन्य संकेतन का उपयोग कर सकते हैं जैसे बीजीय संकेतन या आप इस संकेतन को अनुकूलित कर सकते हैं (उदाहरण के लिए डैश निकालें, या टुपल्स की सूची के रूप में लें)

---

नियम:

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

---

सामान्य नियम:

• यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
  कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
• डिफ़ॉल्ट I / O नियमों के साथ आपके उत्तर के लिए मानक नियम लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-प्रकार, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा फोन।
• डिफ़ॉल्ट लूपोल्स वर्जित हैं।
• यदि संभव हो, तो कृपया अपने कोड (यानी TIO ) के लिए एक परीक्षण के साथ एक लिंक जोड़ें ।
• साथ ही, आपके उत्तर के लिए स्पष्टीकरण जोड़ना अत्यधिक अनुशंसित है।

---

परीक्षण के मामलों

आपको इसके लिए सत्य मान लौटाना चाहिए:

{"B1-C3","B8-C6","C3-B1","C6-B8","B1-C3","B8-C6","C3-B1","C6-B8"} 
{"B1-C3","B8-C6","C3-B1","C6-B8","B1-C3","B8-C6","C3-B1","C6-B8","B1-C3","B8-C6","C3-B1","C6-B8"}
{"B1-C3","B8-C6","D2-D4","D7-D5","D1-D3","D8-D6","C3-B1","C6-B8","B1-C3","B8-C6","D3-D1","D6-D8","D1-D3","D8-D6"}
{"D2-D4","B8-C6","E2-E4","C6-D4","D1-E2","D4-E6","E2-F3","E6-D4","F3-D1","D4-C6","D1-E2","C6-D4","E1-D1","D4-C6","D1-E1","C6-D4"}
{"B1-C3","B8-C6","C3-B1","C6-B8","B1-C3","B8-C6","C3-B1","C6-B8","B1-C3","B8-C6","C3-B1","C6-B8","B1-C3"}

और इसके लिए गलत मूल्य:

{}
{"E2-E4","E7-E5","F2-F4"}
{"B1-C3","B8-C6","C3-B1","C6-B8","B1-C3","B8-C6","C3-B1","C6-B8","F2-F4","F7-F5"}
{"E2-E4","E7-E5","G1-F3","B8-C6","F1-C4","G8-F6","F3-G5","D7-D5","E4-D5","F6-D5","G5-F7"}
{"D2-D4","B8-C6","E2-E4","C6-D4","D1-E2","D4-C6","E2-D1","C6-D4","D1-E2","D4-C6","E2-D1"}
{"B1-C3","B8-C6","C3-B5","C6-B4","B5-D4","B4-D5","D4-C6","D5-C3","C6-B8","C3-B1","B8-C6","B1-C3","C6-B8","C3-B1"}
{"E2-E4","E7-E5","D1-E2","E8-E7","E1-D1","D8-E8","E2-E1","E7-D8","E1-E2","E8-E7","E2-E1","E7-E8"}

Comments

क्या हम इनपुट को एक पंक्ति-प्रमुख क्रम में गिने जाने वाले वर्गों के जोड़ों की सूची के रूप में ले सकते हैं, जो शतरंज से पूरी तरह से छुटकारा दिलाते हैं? निर्देशांक के जोड़े के जोड़े की सूची के बारे में कैसे?

— मेरा सर्वनाम 12

आप पूरी तरह से शतरंज से छुटकारा पाने में सक्षम नहीं होंगे, क्योंकि टुकड़े स्वयं और टुकड़ों को कैप्चर करना दोनों अभी भी महत्वपूर्ण हैं। आप अपने समन्वय प्रणाली को परिभाषित कर सकते हैं, हालांकि आप इसे पसंद करते हैं। मैं इस सवाल में स्पष्ट करूंगा कि इनपुट का एक वैध सेट कौन सा होगा।

— समाप्त डेटा

@ केविनक्रूजसेन मैं स्पष्ट रूप से यह कहता हूं कि प्रारंभिक राज्य की गिनती है। मुझे लगता है कि आपने देखा कि टुकड़े मायने रखते हैं, इसलिए टुकड़े का रंग करें। दूसरा आखिरी परीक्षण मामला है जहां काले और सफेद रंग के शूरवीरों की अदला-बदली होती है। अंतिम एक में रानी और राजा दोनों खिलाड़ियों के लिए चारों ओर स्वैप करते हैं

— समय समाप्त डेटा

@ExpiredData क्या आप बता सकते हैं कि तीसरा झूठा मामला गलत क्यों है? अंतिम C6-B8के बाद प्रारंभिक स्थिति तीन बार हुई है।

— Adám

आह, यह अंतिम स्थिति होनी चाहिए जो कम से कम दो बार पहले दिखाई दी।

— Adám

Answer 1

एपीएल (डायलॉग एक्सटेंडेड) , 55 49 47 45 44 बाइट्स ^{एसबीसीएस}

-4 ngn के लिए धन्यवाद।

पूरा कार्यक्रम। उलट समन्वित जोड़े की उलटी सूची के लिए संकेत:
 जैसे {"B1-C3","B8-C6"}है[[[8,2],[6,3]],[[1,2],[3,3]]]

2≤≢s∩{0,∘⊃@⍺⊃s,←⊂⍵}/⎕,⊂(⊖⍪-)¯4↑⍉6,⍪5,∘⌽⍥⍳s←3

इसे ऑनलाइन आज़माएं! ( Coordsओपी के प्रारूप का अनुवाद करने वाले उपयोगिता समारोह में शामिल हैं )

राज्यों की सूची तैयार करें:

s←3 तीन से असाइन करें s( s tates के लिए)

चूंकि 3 एक वैध बोर्ड राज्य नहीं है, इसलिए यह हमारी पुनरावृत्ति गणना को प्रभावित नहीं करेगा, और हमें असाइनमेंट के पास-थ्रू मान की आवश्यकता है ...

एक शतरंज बोर्ड प्रतिनिधित्व बनाएँ:

5… कि 5 और 3 के बीच निम्नलिखित व्युत्पन्न समारोह को लागू करने के परिणाम के लिए:
 ⍥⍳ दोनों तर्क को उनके ices ndices तक विस्तारित करें;
  [1,2,3,4,5]... [1,2,3]
 ,∘⌽ बाईं ओर दाहिनी ओर के रिवर्स के साथ समतल
  [1,2,3,4,5,3,2,1]यह अधिकारियों का प्रतिनिधित्व करते हैं

⍪ तालिका में बनाओ;
 [[1],
  [2],
  [3],
  [4],
  [5],
  [3],
  [2],
  [1]]

6, prepend (प्रत्येक पंक्ति के लिए) एक छः, पंजे का प्रतिनिधित्व;
 [[6,1],
  [6,2],
  [6,3],
  [6,4],
  [6,5],
  [6,3],
  [6,2],
  [6,1]]

⍉ स्थानांतरित;
 [[6,6,6,6,6,6,6,6],
  [1,2,3,4,5,3,2,1]]

¯4↑ नकारात्मक लें (यानी अंतिम) चार (पंक्तियाँ), शून्य के साथ पैडिंग, खाली वर्गों का प्रतिनिधित्व;
 [[0,0,0,0,0,0,0,0],
  [0,0,0,0,0,0,0,0],
  [6,6,6,6,6,6,6,6],
  [1,2,3,4,5,3,2,1]]

(… ) उस के लिए निम्नलिखित tacit फ़ंक्शन लागू करें:

 - नकारात्मक (यह विपरीत रंग का प्रतिनिधित्व करता है);
  [[ 0, 0, 0, 0, 0, 0, 0, 0],
   [ 0, 0, 0, 0, 0, 0, 0, 0],
   [-6,-6,-6,-6,-6,-6,-6,-6],
   [-1,-2,-3,-4,-5,-3,-2,-1]]

  ⊖⍪ उसके ऊपर फ़्लिप किए गए तर्क को ढेर करें, जिससे हमें पूर्ण बोर्ड मिल सके;
  [[ 1, 2, 3, 4, 5, 3, 2, 1],
   [ 6, 6, 6, 6, 6, 6, 6, 6],
   [ 0, 0, 0, 0, 0, 0, 0, 0],
   [ 0, 0, 0, 0, 0, 0, 0, 0],
   [ 0, 0, 0, 0, 0, 0, 0, 0],
   [ 0, 0, 0, 0, 0, 0, 0, 0],
   [-6,-6,-6,-6,-6,-6,-6,-6],
   [-1,-2,-3,-4,-5,-3,-2,-1]]

प्रारंभिक अवस्था के बाद चाल की सूची बनाएँ:

⊂ संलग्न करें कि (इसे एकल इकाई के रूप में माना जाए)

⎕, चालों की सूची के लिए संकेत, और प्रारंभिक अवस्था में है कि पूर्व निर्धारित करें

एक फ़ंक्शन को कम करें जो वर्तमान स्थिति को सूची में जोड़ता है और एक चाल बनाता है:

{… }/ निम्नलिखित अनाम लंबोदर द्वारा कम करें:

 ⍵ सही तर्क (वर्तमान स्थिति)

 ⊂ इसे एक इकाई के रूप में मानने के लिए संलग्न करें

 s,← इन-प्लेस इसे राज्यों की सूची में जोड़ता है

 ⊃ उस स्थिति का उपयोग करने का खुलासा करें

 ... @⍺ दो निर्देशांक कि बाएं तर्क का प्रतिनिधित्व करता है के साथ तत्वों पर, रख:
  0 एक शून्य
  , पीछा
  ∘ द्वारा
  ⊃ पहले मान
^{यह प्रभावी रूप से "चाल" पहली बार में मूल्य, दूसरा समन्वय करने के लिए समन्वय एक शून्य पीछे छोड़}

जांचें कि हमारे पास अंतिम स्थिति के तीन या अधिक हैं:

s∩ उस अंतिम एक के साथ सभी राज्यों के चौराहे; इसके समान राज्यों का सबसेट

≢ उन्हें चुप कराओ

2≤ जांचें कि क्या दो या अधिक हैं (यानी अंतिम स्थिति सहित तीन या अधिक)

---

* एपीएल राइट-एसोसिएटिव है, इसलिए पहले फ़ंक्शन को प्रारंभिक अवस्था को राइट लॉजिक और लेफ्ट लॉजिक के रूप में शुरुआती चाल के साथ कहा जाता है, और फिर इसका परिणाम, नया राज्य, नए लेफ्ट तर्क के रूप में दूसरे कदम के साथ नया सही तर्क बन जाता है , आदि अंतिम परिणाम है

Comments

मुझे पूरा यकीन है कि इसे \कम करने के बजाय स्कैन का उपयोग करके काफी कम किया जा सकता है/

— Adám

इस बदसूरत हैक के साथ 2 बाइट्स सहेजें: ⍳3⊣s←⍬-> ⍳s←3। यह काम करता है क्योंकि 3एक वैध बोर्ड नहीं है इसलिए यह पुनरावृत्ति का पता लगाने को प्रभावित नहीं करेगा

— nnv

@ उंग। धन्यवाद। हम जेली के पास जा रहे हैं।

— 20

(0,⊃)@->0,∘⊃@

— ngn

@ngn किया। धन्यवाद।

— 14

Answer 2

आर , 180 177 144 बाइट्स

function(M,`+`=rep,l=c(1:5,3:1,6+8,0+16)){z=rev(Reduce(function(x,y){x[y[2:1]]=x[y]*1:0;x},M,c(l,-rev(l)),,T));sum(sapply(z,identical,el(z)))>2}

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

-3 बाइट्स का धन्यवाद Giuseppe
-29 बाइट्स की बदौलत निक कैनेडी के उपयोग Reduceऔर -rev(l)
-4 बाइट्स को उलट-पुलट करने के लिए धन्यवादz

1 से 64 के बीच पूर्णांक के वेक्टर को इनपुट के रूप में लेता है और वर्गों को दर्शाता है। TIO में उस प्रारूप में बदलने के लिए एक फ़ंक्शन शामिल है। विभिन्न टुकड़ों को 1 और 6 के बीच और -1 और -6 के बीच पूर्णांक के रूप में संग्रहीत किया जाता है।

स्पष्टीकरण:

function(M,                                # M is the vector of moves 
         `+` = rep,
         l = c(1:5, 3:1, 6 + 8, 0 + 16)) { # initial position of white pieces
  z = rev(Reduce(function(x, y) {
    x[y[2:1]] = x[y] * 1:0                 # a piece moves from y[1] to y[2]; y[1] becomes 0
    x
  }, M, c(l, -rev(l)), , T))
  sum(sapply(z, identical, el(z))) > 2    # find number of past positions identical to the last position
}

Comments

मैंने आपका एक संशोधित संस्करण [ bit.ly/2OHPexp] पर डाल दिया है । यह ठीक है TIO लेकिन एक टिप्पणी के लिए लिंक बहुत लंबा है। कोड आपके द्वारा प्रेरित है, लेकिन Reduceइसके मूल में एक संचयी का उपयोग करता है । यह 148 बाइट्स है।

— निक कैनेडी

@NickKennedy धन्यवाद! मैं वास्तव में काले टुकड़ों के लिए नकारात्मक पूर्णांक का उपयोग करने के बारे में था; मुझे खुशी है कि आपने इसे पहले किया। मुझे पसंद है कि आपने क्या कम किया है: मुझे स्पष्ट रूप से इस बारे में अधिक जानने की आवश्यकता है।

— रॉबिन राइडर

@NickKennedy मैंने z को उल्टा करके अपने संस्करण से 4 बाइट्स प्राप्त किए।

— रॉबिन राइडर

Answer 3

जेली , 41 37 बाइट्स

Ø0;6x8;“Ġ²F’D¤UN;ƊW;µị@⁹Ṫ¤¦0⁹¦$\ċṪ$>1

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

एक मोनैडिक लिंक जो इनपुट को 1-अनुक्रमित पंक्ति-प्रमुख चालों के जोड़े की सूची के रूप में लेता [from, to]है और ड्रॉ के लिए 1 देता है और 0 के लिए नहीं।

ध्यान दें कि TIO पर पाद लेख कोड ओपी द्वारा आपूर्ति किए गए चालों को संख्यात्मक प्रारूप में अनुवाद करता है, लेकिन प्रश्न के नीचे चर्चा के अनुसार, संख्यात्मक प्रारूप एक वैध इनपुट होता।

व्याख्या

Ø0                                    | 0,0
  ;6                                  | concatenate to 6 (pawn)
    x8                                | repeat each 8 times (two blank rows and 1 row of pawns)
      ;“Ġ²F’D¤                        | concatenate to 1,2,3,4,5,3,2,1
              UN;Ɗ                    | concatenate a negated flipped version to this one
                  W;                  | wrap as a list and concatenate the input list to the board
                    µ                 | start a new monadic chain
                              $\      | reduce using the two links below
                     ị@⁹Ṫ¤¦           | replace the item pointed to by the second coordinate by the value of the one at the first
                           0⁹¦        | replace the item at first coordinate with zero
                                ċṪ$   | finally count the items equal to the final one (not including it)
                                   >1 | and check of >1

Answer 4

जावास्क्रिप्ट (Node.js) ,  121  111 बाइट्स

[sq0, sq1]$[0..63]$$\text{a8}=0$$\text{b8}=1$$\text{h1}=63$

एक बूलियन मान लौटाता है।

a=>[a,...a].map(([x,y])=>r=b[b[b[y]=b[x],x]=0,b]=-~b[b],b=[...'89ABCA981111111'+10n**32n+0x7e5196ee74377])&&r>2

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

कैसे?

टुकड़े

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

हम प्रयोग करते हैं:

• 0 खाली वर्गों के लिए
• 1 / 8 / 9 / ए / बी / सी ♟ / ♜ / ♞ / ♝ / ♛ / ♚ के लिए
• 2 / 3 / 4 / 5 / 6 / 7 के लिए ♙ / ♖ / ♘ / ♗ / ♕ / ♔

बोर्ड और प्रारंभिक स्थिति

$b$

• '89ABCA981111111' → 8 काले प्रमुख टुकड़े, उसके बाद पहले 7 काले मोहरे
• 10n**32n$\text{h7}$$1$$0$
• 0x7e5196ee74377→ सभी सफेद टुकड़े ( 2222222234567543दशमलव में विस्तार)

जिसके परिणामस्वरूप:

    a b c d e f g h
  +----------------
8 | 8 9 A B C A 9 8
7 | 1 1 1 1 1 1 1 1
6 | 0 0 0 0 0 0 0 0
5 | 0 0 0 0 0 0 0 0
4 | 0 0 0 0 0 0 0 0
3 | 0 0 0 0 0 0 0 0
2 | 2 2 2 2 2 2 2 2
1 | 3 4 5 6 7 5 4 3

पदों का हिसाब रखना

$b$$b$

यही कारण है कि हम करते हैं:

b[b] = -~b[b]

टिप्पणी की गई

a =>                    // a[] = input
  [ a,                  // dummy entry to mark the initial position as encountered once
    ...a                // append the actual data
  ].map(([x, y]) =>     // for each pair of squares [x, y] in this array:
    r =                 //   store the last result in r
    b[                  //   update b[b]:
      b[                //     update b[x]:
        b[y] = b[x],    //       set b[y] to b[x]
        x               //       set b[x] ...
      ] = 0,            //     ... to 0
      b                 //     set b[b] ...
    ] = -~b[b],         //   ... to b[b] + 1 (or 1 if b[b] is undefined)
    b = [...(…)]        //   initialize b[] (see above)
  )                     // end of map()
  && r > 2              // return true if the last result is greater than 2

Comments

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

— डेटा

हाँ, मेरा मतलब है कि, मैं अपडेट करूँगा जब मैं कर सकता हूँ

— समय सीमा समाप्त डेटा

@ExpiredData यह अब उम्मीद के मुताबिक काम करना चाहिए।

— Arnauld

Answer 5

जावा 10, 336 330 287 285 282 276 बाइट्स

m->{var V=new java.util.HashMap();int i=64,A[]=new int[i];var t="";for(;i-->0;)t+=A[i]=(i%56<8?i%8*35%41%10%8+2:9>>i/16&1)*(i/32*2-1);V.put(t,1);for(var a:m){for(t="",A[a[1]]=A[a[0]],A[a[0]]=0,i=64;i-->0;)t+=A[i];V.compute(t,(k,v)->v!=null?(int)v+1:1);}return(int)V.get(t)>2;}

-11 बाइट्स @Arnauld को बदलने के i%56<8?"ABCDECBA".charAt(i%56%7):i%48<16?1:0लिए धन्यवाद i%56<8?i%8*35%41%10%8+2:9>>i/16&1।

$a1=0, b1=1, ..., h8=63${"E2-E4",...[[12,28],...

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

स्पष्टीकरण:

m->{                   // Method with 3D character array parameter and boolean return-type
  var V=new java.util.HashMap();
                       //  Create a Map to store the occurrences of the board-states
  int i=64,            //  Index integer, starting at 64
      A[]=new int[i];  //  Create the 8 by 8 board
  var t="";            //  Temp-String, starting empty
  for(;i-->0;)         //  Loop `i` in the range (64,0]:
    t+=                //    Append the string `t` with:
      A[i]=            //     Fill the `i`'th cell with:
        i%56<8?        //      If it's either the first or eighth row:
         i%8*35%41%10%8+2
                       //       Fill it with 2,7,3,5,9,3,7,2 based on index `i`
        :9>>i/16&1)    //      Else if it's either the second or seventh row:
                       //       Fill it with 1
                       //      Else (the third, fourth, fifth, or sixth rows):
                       //       Fill it with 0
        *(i/32*2-1);   //      Then multiply it by -1 or 1 depending on whether `i`
                       //      is below 32 or not
  V.put(t,1);          //  Then set string `t` in the map to 1 for the initial state
  for(var a:m){        //  Loop over each of the input's integer-pairs:
    for(t="",          //   Make the String empty again
        A[a[1]]=       //   Set the to-cell of the current integer-pair of the input to:
          A[a[0]],     //    The value in the from-cell of the same integer-pair
        A[a[0]]=0,     //   And then empty this from-cell
        i=65;i-->0;)   //   Inner loop `i` in the range (64,0]:
          t+=A[i];     //    Append the `i`'th value to the String `t`
    V.compute(t,(k,v)->v!=null?(int)v+1:1);}
                       //   Increase the value in the map for String `t` as key by 1
  return(int)V.get(t)  //  Return whether the value in the map for the last String `t`
          >2;}         //  is at least 3

उन्हें भरने के बाद टुकड़ों के मूल्य A[i]=(i%56<8?i%8*35%41%10%8+2:9>>i/16&1)*(i/32*2-1)हैं:

     a  b  c  d  e  f  g  h
  +------------------------
1 | -2 -7 -3 -5 -9 -3 -7 -2
2 | -1 -1 -1 -1 -1 -1 -1 -1
3 |  0  0  0  0  0  0  0  0
4 |  0  0  0  0  0  0  0  0
5 |  0  0  0  0  0  0  0  0
6 |  0  0  0  0  0  0  0  0
7 |  1  1  1  1  1  1  1  1
8 |  2  7  3  5  9  3  7  2

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

Comments

टी का उपयोग करने से बचने के तरीके के साथ थोड़ी देर के लिए कुश्ती, क्या कोई संरचना नहीं है जो आप राज्य को स्टोर करने के लिए उपयोग कर सकते हैं जो java.util.Arrays.deepHashCode की तरह कुछ करेगा? यदि ऐसा है तो बाइट का भार अतिरिक्त रूप से

— समाप्त हो जाएगा

इसके अलावा, मुझे आश्चर्य है कि यदि यह तकनीकी रूप से हैशमैप के कार्यान्वयन के आधार पर सही है, तो संभवत: शतरंज बोर्डों के लिए हैश टकराव होने वाला है क्योंकि यह संभव है कि कॉन्फ़िगरेशन बहुत बड़ा हो? मैं तुम्हें एक counterexample देने के लिए नहीं जा रहा हूँ, हालांकि!

— डेटा

@ExpiredData वास्तव में एक है java.util.Arrays.deepHashCode(A), लेकिन जाहिरा तौर पर कुछ राख अभी भी किसी भी तरह (जैसे कि पिछले परीक्षण के मामले -447346111=3में नक्शे में है ..) अगर मैं अपने वर्तमान उत्तर के परिणामी नक्शे की तुलना करता हूं और परिणामी नक्शे का उपयोगdeepHashCode(A) करता हूं । इसके अलावा, यह कम होने के बजाय 3 बाइट्स होगा, क्योंकि मुझे deepHashCode(A)दो बार (प्रारंभिक स्थिति के लिए) का उपयोग करना होगा।

— केविन क्रूज़सेन

लेकिन पहला काला किश्ती दूसरे काले बदमाश से अलग है। two positions are seen to be the same if each square on both boards is occupied by the same type of piece of the same colour

— अज्ञानता

जावा में पूरी तरह से परीक्षण नहीं किया गया है, लेकिन 6 बाइट की बचत के i%8*35%41%10%8+2लिए अभिव्यक्ति एक संभावित प्रतिस्थापन होना चाहिए "ABCDECBA".charAt(i%8)। यह पैटर्न उत्पन्न करता है [ 2, 7, 3, 5, 9, 3, 7, 2 ]।

— अरनुलद

Answer 6

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

≔↨²³⁴⁵⁶⁴³²χηＦ⁴⁸⊞η÷⁻⁴⁰ι³²Ｆ…η⁸⊞η±ιＦθ«⊞υ⮌η§≔η⊟ι§η§ι⁰§≔η⊟ι⁰»›№υ⮌η¹

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। संख्याओं के जोड़े के एक सरणी के रूप में इनपुट लेता है, जहां वर्गों की संख्या होती है A1, B1... H8(0-अनुक्रमित) इसलिए उदाहरण के लिए पहले परीक्षण मामले का प्रतिनिधित्व किया जाएगा [[[1, 18], [57, 42], [18, 1], [42, 57], [1, 18], [57, 42], [18, 1], [42, 57]]]और -यदि पुनरावृत्ति द्वारा स्थिति ड्रॉ होती है, तो यह आउटपुट करता है। रूपांतरण कार्यक्रम। ऑल - इन - वन। स्पष्टीकरण:

≔↨²³⁴⁵⁶⁴³²χη

23456432व्यक्तिगत अंकों में संख्या को विभाजित करें । ये सफेद टुकड़ों का प्रतिनिधित्व करते हैं।

Ｆ⁴⁸⊞η÷⁻⁴⁰ι³²

पंजे और खाली पंक्तियों में जोड़ें। सफेद प्यादों का मूल्य होता है 1और काले प्यादों का -1।

Ｆ…η⁸⊞η±ι

सफेद टुकड़ों की एक नकारात्मक प्रतिलिपि को संलग्न करें, जो काले टुकड़ों का प्रतिनिधित्व करते हैं।

Ｆθ«

चालों पर लूप।

⊞υ⮌η

बोर्ड की एक प्रति सहेजें। (बोर्ड को कॉपी करने के लिए उलटफेर गोल्फ का सबसे अच्छा तरीका है।)

§≔η⊟ι§η§ι⁰

स्रोत के टुकड़े के साथ गंतव्य को अपडेट करें।

§≔η⊟ι⁰

स्रोत टुकड़ा निकालें।

»›№υ⮌η¹

निर्धारित करें कि क्या वर्तमान स्थिति एक से अधिक बार पहले देखी गई थी।

Answer 7

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 204 बाइट्स

n=>{var j=new List<char[]>();var d=("ABCDECBATTTTTTTT"+new string('Z',32)+7777777712345321).ToArray();foreach(var(a,b)in n){j.Add(d.ToArray());d[b]=d[a];d[a]='Z';}return j.Count(r=>r.SequenceEqual(d))>1;}

इनपुट को पूर्णांकों के tuples की सूची के रूप में लेता है, जहां पहला पूर्णांक जहां से स्थानांतरित करना है, और दूसरा जहां स्थानांतरित करना है। 0 ए 1 का प्रतिनिधित्व करता है, 1 ए 2 है, और 63 एच 8 है।

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

n=>{
  var j=new List<char[]>();    //Initialize a list to save states of a board
  var d=("ABCDECBATTTTTTTT" +  //White pieces
  new string('Z',32) +         //Empty spaces
  7777777712345321)            //Black pieces
  .ToArray(); //Initialize the chessboard
  foreach(var(a,b)in n){       //Foreach (source square, destination square) in the input
    j.Add(d.ToArray());        //  Add the current board to the list
    d[b]=d[a];                 //  Set the destination square to the source square's value
    d[a]='Z';                  //  And set the souce square to empty
  }
  return j.Count(         //Return that the amount...
    r=>r.SequenceEqual(d) //  of past positions that are equal to the current position...
  )>1;                    //is at least two
}

Answer 8

जावा (JDK) , 246 245 244 बाइट्स

import java.util.*;n->{var j=new ArrayList<char[]>();var d=("ABCDECBATTTTTTTT"+"".repeat(32)+7777777712345321l).toCharArray();for(var k:n){j.add(d.clone());d[k[1]]=d[k[0]];d[k[0]]=1;}return j.stream().filter(x->Arrays.equals(d,x)).count()>1;}

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

import java.util.*;                   //Import the java.util package

n->{                                  //Function taking in int[][], 
                                      //where each int[] is a a pair of numbers
  var j = new ArrayList<char[]>();    //List to save each position of the chessboard
  var d =                             //The chessboard's starting position
    ("ABCDECBATTTTTTTT" +             //  All the white pieces
    "&#1".repeat(32) +                //  Plus the empty squares
    7777777712345321l)                //  And the black pieces
  .toCharArray();                     //Split to array of chars
  for(var k:n){                       //Foreach [sourceSquare, destinationSquare] in input
    j.add(d.clone());                 //  Add the current position to the list
    d[ k[1] ] = d[ k[0] ];            //  Set the destination square's value
                                      //  to the source squares
    d[ k[0] ] = 1;                    //  And clear the source square 
}                                     //End foreach
return j.stream()                     //Convert list of states to stream
  .filter(x ->                        //Filter each position by
    Arrays.equals(d,x)                //  if the position equals the final position 
  ).count() > 1;                      //And return if there are at least two
                                      //positions that are left
}