क्या यह एक वैध शतरंज की चाल है?

Question

_{वैकल्पिक नाम: ChessMoveQ}

32 तत्वों तक की सूची को देखते हुए, प्रत्येक में 4 तत्वों से युक्त और 4 तत्वों के साथ एक दूसरी सूची है, यह निर्धारित करें कि क्या दूसरे इनपुट में विस्तृत कदम एक वैध शतरंज चाल है।

पहली सूची बोर्ड पर सभी 32 टुकड़ों की स्थिति को इंगित करती है। प्रत्येक तत्व संरचना का पालन करेगा <colour>, <piece-name>, <x-coord>, <y-coord>, जैसे कि ["W", "K", 5, 1], जो इंगित करता है कि सफेद राजा चालू है 5, 1( e1एक सामान्य शतरंज बोर्ड पर)। पहले इनपुट के सभी तत्व अद्वितीय होंगे। <x-coord>और <y-coord>हमेशा 1 और 8 के बीच होगा। एक उदाहरण यह होगा:

[["B", "K", 3, 8], ["B", "Q", 1, 5], ["B", "N", 4, 7], ["B", "N", 7, 8],
 ["B", "B", 2, 4], ["B", "R", 4, 8], ["B", "R", 8, 8], ["B", "P", 1, 7],
 ["B", "P", 2, 7], ["B", "P", 3, 6], ["B", "P", 5, 6], ["B", "P", 6, 7],
 ["B", "P", 7, 7], ["B", "P", 8, 7], ["W", "K", 5, 1], ["W", "Q", 6, 3],
 ["W", "N", 3, 3], ["W", "B", 5, 2], ["W", "B", 6, 4], ["W", "R", 1, 1],
 ["W", "R", 8, 1], ["W", "P", 1, 3], ["W", "P", 2, 2], ["W", "P", 3, 2],
 ["W", "P", 4, 4], ["W", "P", 6, 2], ["W", "P", 7, 2], ["W", "P", 8, 3]]

जो बोर्ड का प्रतिनिधित्व करेगा:

दूसरे इनपुट में पहले के सब्लिस्ट के रूप में समान संरचनाएं शामिल होंगी, लेकिन x और y निर्देशांक के बजाय यह दर्शाता है कि टुकड़ा कहां है, वे संकेत कर रहे हैं कि वह कहां स्थानांतरित करने की कोशिश कर रहा है।

उपरोक्त उदाहरण के लिए, एक वैध चाल हो सकती है ["W", "B", 4, 3](बिशप एक वर्ग को आगे और बाईं ओर ले जाता है), और एक अवैध चाल हो सकती है ["B", "R", 4, 1]क्योंकि बदमाश को नाइट के माध्यम से चलना होगा, और वर्ग को प्राप्त करने के लिए मोहरा होगा। जैसा कि यह कदम कई बार कई टुकड़ों को संदर्भित कर सकता है, आपको यह परीक्षण करना होगा कि क्या निर्दिष्ट टुकड़े में से कोई भी चाल बना सकता है, न कि उनमें से केवल एक। उदाहरण के लिए, पहला उदाहरण केवल एक बिशप के लिए मान्य है, लेकिन यह अभी भी एक वैध कदम है। हालांकि, न तो काला बदमाश दूसरा कदम उठा सकता है, इसलिए यह अमान्य है।

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

• कोई भी टुकड़ा : कोई भी टुकड़ा पहले से ही कब्जे वाले वर्ग या बोर्ड के बाहर नहीं जा सकता है, जब तक कि उस वर्ग को दूसरे रंग के टुकड़े पर कब्जा न हो। उदाहरण के लिए, एक सफेद टुकड़ा एक काले टुकड़े के कब्जे वाले एक वर्ग पर जा सकता है, लेकिन एक सफेद टुकड़ा नहीं। इसके अतिरिक्त, शूरवीरों को छोड़कर, कोई भी टुकड़ा, उन वर्गों पर नहीं जा सकता है जो सीधे दूसरे टुकड़े द्वारा बाधित हैं।
  • टुकड़ा द्वारा एक कदम बी वर्ग के लिए सी "सीधे बाधित" है टुकड़ा द्वारा एक अगर एक , सीधे है एक सीधी (ओर्थोगोनल या विकर्ण) लाइन में के बीच बी और सी ।
• कोई भी टुकड़ा : राजा की स्थिति एक टुकड़े की चाल की वैधता को भी प्रभावित कर सकती है। यदि इन दोनों में से कोई एक शर्त पूरी होती है, तो यह कदम अमान्य है:
  • लुप्तप्राय राजा के रूप में एक ही तरफ एक टुकड़ा ले जाकर, राजा को जांचने के लिए उजागर करना। यह केवल तभी लागू होता है जब एक गैर-विरोध करने वाला टुकड़ा राजा को जांचने के लिए स्थानांतरित करने वाले एक विरोधी टुकड़े के बजाय कदम बनाता है।
  • जाँच में राजा, जिस स्थिति में इसे छोड़ने है की जाँच बाहर स्थानांतरित करने के। इसलिए, यदि राजा जांच में है और चाल यह निर्धारित करती है कि एक और टुकड़ा चलता है, तो यह एक अमान्य चाल है, जब तक कि दूसरा टुकड़ा चेक को रोक नहीं रहा है। एक टुकड़ा दो तरीकों में से एक को रोक सकता है: या तो यह टुकड़ा प्रदर्शन चेक ले जाता है, या यह टुकड़ा प्रदर्शन चेक और राजा के बीच के मार्ग को बाधित करता है।
  • एक "चेक" एक ऐसी स्थिति है जिसमें राजा के प्रतिद्वंद्वी (यदि यह स्थानांतरित करने की उनकी बारी थी) कानूनी तौर पर उस राजा पर एक टुकड़ा ले जा सकते हैं। यह नियम पुनरावर्ती रूप से लागू नहीं होता है, अर्थात एक राजा जांच में होता है, भले ही उस राजा के प्रतिद्वंद्वी द्वारा किए गए कदम से अपने ही राजा को रोक दिया जाए।
• पंजे : एक मोहरा आगे की ओर जा सकता है (अर्थात ऊपर की ओर सफेद, नीचे की ओर यदि काला हो) एक वर्ग रहित वर्ग में। तीन विशेष परिस्थितियाँ भी हैं:
  • यदि मोहरा अभी तक स्थानांतरित नहीं हुआ है (आप वाई-समन्वय का उपयोग करके यह निर्धारित कर सकते हैं, तो सफेद प्यादे नहीं चले गए हैं यदि उनका वाई-समन्वय 2 है, तो काले प्यादे स्थानांतरित नहीं हुए हैं यदि उनका वाई-समन्वय 7 है), प्यादा एक अनचाहे वर्ग के लिए दो वर्गों को आगे बढ़ने की अनुमति है।
  • यदि मोहरे के सामने तिरछे (यानी उत्तर-पश्चिम या उत्तर-पूर्व में चौक पर अगर यह सफेद है, या दक्षिण-पश्चिम या दक्षिण-पूर्व में काला है तो) प्यादे को विचाराधीन कब्जे वाले वर्ग पर जाने की अनुमति है।
  • यदि कोई मोहरा अंतिम Y- समन्वय (सफेद के लिए 8, या काले रंग के लिए 1) में चलता है, तो सामान्य शतरंज के नियमों में इसे रानी, ​​बदमाश, नाइट या एक ही रंग के बिशप को बढ़ावा देना चाहिए। इस प्रश्न के प्रयोजनों के लिए, पदोन्नति का विकल्प इस बात के लिए अप्रासंगिक है कि यह कदम वैध है या नहीं (और इसे इनपुट प्रारूप में व्यक्त नहीं किया जा सकता है), लेकिन प्यादा चालें जिसके परिणामस्वरूप पदोन्नति की अनुमति होनी चाहिए।
• बिशप : बिशप 1 और 8 वर्गों के बीच किसी भी निरंतर गैर-बाधित इंटरकार्डिनल (यानी विकर्ण) पथ के साथ आगे बढ़ सकते हैं।
• शूरवीरों : शूरवीरों एकLआकारमें आगे बढ़ सकते हैं, जिसमें निम्नलिखित (समतुल्य) चालें शामिल हैं:
  • किसी भी कार्डिनल दिशा में एक वर्ग, जिसके बाद 90/270 ° मोड़, उसके बाद 2 वर्ग आगे बढ़ते हैं।
  • किसी भी कार्डिनल दिशा में 2 वर्ग, एक 90/270 ° मोड़ के बाद, एक एकल वर्ग आगे की अंतिम चाल के बाद।
  (याद रखें कि एक शूरवीर का मार्ग हस्तक्षेप करने वाले टुकड़ों द्वारा अवरुद्ध नहीं किया जा सकता है, हालांकि इसका अंतिम वर्ग अभी भी कानूनी होना चाहिए।)
• Rooks : Rooks 1 और 8 वर्गों के बीच किसी भी निरंतर गैर-बाधित कार्डिनल पथ पर जा सकते हैं।
• क्वींस : क्वींस किसी भी निरंतर कार्डिनल या इंटरकार्डिनल (यानी विकर्ण) गैर-बाधित मार्ग के साथ 1 और 8 वर्गों के बीच जा सकता है।
• किंग्स : किंग्स रानियों की तरह चलते हैं, सिवाय इसके कि वे केवल एक वर्ग प्रति चाल तक ही सीमित हैं (यानी एक राजा केवल कार्डिनल या तिरछे आसन्न वर्गों में जा सकता है)। एक अनुस्मारक के रूप में, आप एक चाल नहीं बना सकते हैं जो आपके राजा को जांच में छोड़ देता है; इस प्रकार आप अपने राजा को जांच में स्थानांतरित नहीं कर सकते।

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

आप किसी चाल की वैधता को इंगित करने के लिए किसी भी दो अलग-अलग परिणामों का उत्पादन कर सकते हैं, और आप जिस विधि से चाहते हैं उसमें इनपुट ले सकते हैं। यदि आप चाहें तो आप पदों के लिए 1-अनुक्रमण के बजाय 0-अनुक्रमण को भी चुन सकते हैं। यह एक कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है!

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

Board
Move => Output (Reason)

[["B", "K", 3, 8], ["B", "Q", 1, 5], ["B", "N", 4, 7], ["B", "N", 7, 8], ["B", "B", 2, 4], ["B", "R", 4, 8], ["B", "R", 8, 8], ["B", "P", 1, 7], ["B", "P", 2, 7], ["B", "P", 3, 6], ["B", "P", 5, 6], ["B", "P", 6, 7], ["B", "P", 7, 7], ["B", "P", 8, 7], ["W", "K", 5, 1], ["W", "Q", 6, 3], ["W", "N", 3, 3], ["W", "B", 5, 2], ["W", "B", 6, 4], ["W", "R", 1, 1], ["W", "R", 8, 1], ["W", "P", 1, 3], ["W", "P", 2, 2], ["W", "P", 3, 2], ["W", "P", 4, 4], ["W", "P", 6, 2], ["W", "P", 7, 2], ["W", "P", 8, 3]]
["W", "R", 8, 2] => True (The rook on h1 can move forward one)

[['B', 'K', 6, 8], ['B', 'Q', 1, 7], ['B', 'N', 1, 3], ['B', 'N', 7, 1], ['B', 'B', 8, 8], ['B', 'B', 2, 5], ['B', 'R', 4, 3], ['B', 'R', 1, 5], ['B', 'P', 5, 5], ['B', 'P', 7, 2], ['B', 'P', 5, 7], ['B', 'P', 5, 6], ['B', 'P', 4, 4], ['W', 'K', 7, 3], ['W', 'Q', 3, 2], ['W', 'N', 4, 8], ['W', 'N', 7, 5], ['W', 'B', 1, 1], ['W', 'B', 8, 1], ['W', 'R', 1, 8], ['W', 'R', 3, 7], ['W', 'P', 8, 2], ['W', 'P', 6, 3], ['W', 'P', 4, 2], ['W', 'P', 1, 4], ['W', 'P', 8, 7]]
['W', 'N', 1, 5] => False (Neither knight to move to a5 from where they are)

[['B', 'K', 7, 3], ['B', 'Q', 2, 4], ['B', 'N', 5, 2], ['B', 'N', 1, 6], ['B', 'B', 7, 7], ['B', 'B', 1, 8], ['W', 'K', 7, 1], ['W', 'Q', 6, 1], ['W', 'N', 5, 6], ['W', 'N', 3, 3], ['W', 'B', 2, 2], ['W', 'B', 6, 5]]
['B', 'K', 8, 3] => False (The white bishop would put the king in check)

[['B', 'K', 7, 6], ['B', 'Q', 8, 3], ['B', 'N', 7, 7], ['B', 'N', 8, 7], ['B', 'B', 2, 2], ['B', 'B', 3, 8], ['B', 'R', 1, 1], ['B', 'R', 1, 6], ['B', 'P', 8, 5], ['B', 'P', 4, 3], ['B', 'P', 8, 6], ['W', 'K', 7, 8], ['W', 'Q', 7, 2], ['W', 'N', 5, 1], ['W', 'N', 4, 6], ['W', 'B', 1, 2], ['W', 'B', 2, 6], ['W', 'R', 4, 4], ['W', 'R', 3, 6], ['W', 'P', 5, 2], ['W', 'P', 6, 2]]
['B', 'N', 5, 8] => False (The white queen currently has the king in check, and this move doesn't prevent that)

[['B', 'K', 7, 6], ['B', 'Q', 8, 3], ['B', 'N', 7, 7], ['B', 'N', 8, 7], ['B', 'B', 2, 2], ['B', 'B', 3, 8], ['B', 'R', 1, 1], ['B', 'R', 1, 6], ['B', 'P', 8, 5], ['B', 'P', 4, 3], ['B', 'P', 8, 6], ['W', 'K', 7, 8], ['W', 'Q', 7, 2], ['W', 'N', 5, 1], ['W', 'N', 4, 6], ['W', 'B', 1, 2], ['W', 'B', 2, 6], ['W', 'R', 4, 4], ['W', 'R', 3, 6], ['W', 'P', 5, 2], ['W', 'P', 6, 2]]
['B', 'N', 7, 5] => True (The king is in check, and the knight blocks that)

[['B', 'K', 8, 3], ['B', 'Q', 6, 5], ['B', 'N', 7, 8], ['B', 'N', 3, 7], ['B', 'B', 4, 1], ['B', 'B', 1, 1], ['W', 'K', 7, 7], ['W', 'Q', 7, 1], ['W', 'N', 2, 2], ['W', 'N', 1, 3], ['W', 'B', 3, 5]]
['B', 'B', 2, 2] => True (takes the white knight)

[['B', 'K', 6, 1], ['B', 'Q', 6, 2], ['W', 'K', 8, 1]]
['B', 'Q', 7, 1] => True (Smallest checkmate possible, in terms of bounding box)

_{इस चुनौती को सैंडबॉक्स किया गया था । यह बिना किसी स्पष्टीकरण के डाउनवोट प्राप्त किया, इसलिए मैंने इसे वैसे भी पोस्ट करने का निर्णय लिया}

Comments

"उसी तरफ एक टुकड़ा चलता है, जो राजा को जांचने के लिए उजागर करता है।" - यह शब्द अब फिट नहीं लगता है कि आपने शीर्षक को आगे बढ़ा दिया है। मैं इसे कुछ इस तरह से बदल दूंगा जैसे "इस टुकड़े को

— हिलाना

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

— caird coinheringaahing

किसी ने इसे कम नहीं किया ...?

— FlipTack

क्या हम इनपुट के रूप में टुकड़ों की 2d सरणी प्राप्त कर सकते हैं?

— ओवीस

@ नोव्स हाँ, यह स्वीकार्य प्रतीत होता है

— caird coinheringaahing

Answer 1

अजगर 2 ( अजगर-शतरंज के साथ ),  141 138 134 133  132 बाइट्स

वास्तव में कोई भी दिलचस्प कोड किए बिना - लेकिन शायद यह गोल्फ भाषाओं के साथ प्रतिस्पर्धा कर सकता है या (मैं इसका उल्लेख करने की हिम्मत करता हूं) गणितज्ञ?

नोट: अजगर शतरंज एक है Pypi पैकेज 2.7.9+ अजगर पर इसे स्थापित के साथ:
python -m pip install python-chess)

import chess
a,p,n=input()
S=chess.Board(a+' - - 0 1')
for m in S.legal_moves:1/(m.to_square!=n)**(`p`in`S.piece_at(m.from_square)`)

तीन वस्तुओं का इनपुट स्वीकार करने वाला एक पूर्ण कार्यक्रम:

1. FEN रिकॉर्ड की शुरुआत - पहले दो फ़ील्ड वाले स्ट्रिंग। यह बोर्ड की स्थिति को परिभाषित करने के लिए है और कौन सा रंग घूम रहा है (चूंकि यह ओपी में इनपुट की जानकारी है, जबकि छह से तीन फ़ील्ड ओपी द्वारा "निश्चित" हैं इसलिए इनपुट का हिस्सा नहीं होना चाहिए)
2. टुकड़ा-नाम को स्थानांतरित करने का प्रयास (जैसा कि ओपी में दिया गया है - एक PRNBQK)
3. वर्ग नामित टुकड़ा ले जाने के लिए प्रयास कर रहा है जहां जो करने के लिए a1है 0, b1है 1, ... a2है 8, ..., h8है 63,

कार्यक्रम इसके एक्ज़िट-कोड के माध्यम से दिए गए वैध इनपुट को आउटपुट करता है:

• 1 यदि चाल एक वैध है (कार्यक्रम में त्रुटि आई है - शून्य से विभाजन के कारण);
• 0 यह नहीं है (कार्यक्रम सामान्य रूप से बाहर हो गया)

(मत) यह ऑनलाइन कोशिश करो! (क्योंकि अजगर-शतरंज पैकेज वहां स्थापित नहीं है और TIO इंटरनेट कनेक्टिविटी की अनुमति नहीं देता है, इसलिए हेडर अभ्यस्त काम में पाइप-इंस्टॉल कोड)।

ध्यान दें कि अजगर में सत्ता ऑपरेटर बनाता है 1**1 == 1**0 == 0**0 == 1लेकिन 0**1 == 0
... इसलिए 1/0**1शून्य त्रुटि द्वारा एक विभाजन को जन्म देती है, जबकि 1/1**1, 1/1**0और 1/0**0सभी सफल हो
(... और पायथन में है कि Falseऔर Trueसमानता के लिए 0और 1क्रमशः)।

Comments

यह पूरी तरह से वैध उत्तर है, लेकिन यह एक बिल्ट-ओनली मैथेमेटिका के जवाब की तरह ही धोखा देने जैसा लगता है।

— 21

हां, इसलिए मैंने जो टिप्पणी शीर्ष पर रखी है, "वास्तव में कोई भी दिलचस्प कोड किए बिना ..." शायद जब मेरे पास कुछ और समय होगा तो मैं एक जेली एक करूंगा (जो इस मॉड्यूल को आयात नहीं कर सकता :))

— जोनाथन एलन

... मन करता है आप अभी भी कुछ प्रयास करें।

— जोनाथन एलन

पुनर्व्यवस्थित str(S.piece_at(m.from_square))==p forकरें p==str(S.piece_at(m.from_square))for, कि एक बाइट बचाना चाहिए।

— ज़ाचारि

आह, हाँ - धन्यवाद @ ज़ाचरी मैं सिर्फ यह देखना चाह रहा था कि क्या मैं बचाने के लिए बैकटिक्स के reprइस्तेमाल से पार्स कर सकता हूं str...

— जोनाथन एलन

Answer 2

रेगेक्स (पीसीआरई 2), 931 925 837 बाइट्स

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

बोर्ड का प्रतिनिधित्व 8 × 8 ASCII में किया जाता है जहां सफेद टुकड़े बड़े होते हैं और काले निचले होते हैं: P awn, k N ight, B ishop, R ook, Q ueen, K ing। ब्लैक की साइड (8 वीं रैंक) सबसे ऊपर है और व्हाइट की साइड (1 रैंक) सबसे नीचे है। प्रत्येक रैंक को एक नई रेखा से अलग किया जाता है, और खाली वर्गों को चिह्नित किया जाता है -। दो बोर्ड पदों को एक अतिरिक्त न्यूलाइन द्वारा अलग किया जाता है।

इस परियोजना का वास्तविक उद्देश्य पूरे खेल को मान्य करना है, न कि केवल एक चाल। प्रगति की वर्तमान स्थिति के लिए नीचे देखें।

()?(?>|((.|
(?=.)){2})((?=(\X{72})-))((?=(?(1)[-a-z]|[-A-Z])))((?5)(?(?=(.*
)
)[qnrb]|p))((?5)(?(?=(?8){8}
)[QNRB]|P)))(?>((.)(?=(?5)\11)|(?(m)$)((?(1)(-(?=(?9))(?=(?3){8}((?3){9})?P(?4))(?(-1)(?=(?8){4}
))|[a-z](?=(?9))(?=(?3){7}(?2)?P(?4)))|(p(?4)((?=(?3){8}((?3){9})?-(?7))(?(-1)(?=(?8){7}
))|(?=(?3){7}(?2)?[A-Z](?7)))))|(?<e>(?6).)?(?=(?i:(?|(?(e)|(B|Q))(?27)(?(e)(B|Q))|(?(e)|(R|Q))(?31)(?(e)(R|Q))|(?(e)|(N))(?34)(?(e)(N))|(?(e)|(K))(?35)?(?(e)(K))))(?(e)(?<=(?!(?6)).)(?4)|(?6).(?5)\19))(?(e)(?=(?5)\20)|(?!(?6)).(?4)))(?<m>)|(?(+1)$)(.))+
)+\k<m>
(?!\X{0,70}((?(1)p|k)(?=(?3){7}(?2)?(?(1)K|P))|(?i:(?<E>(?!(?6))K)?((?(E)|((?6)[BQ]))(()?((?(-1)-)(?3){7}(?(-2)(?2)))+)(?(E)(?-4))|(?(E)|((?6)[RQ]))(-*|((?(-1)-)(?3){8})+)(?(E)(?-3))|(?(E)|((?6)N))((?<=..)(?2){3}|(?=.)(?2){5}|(?2){8}(?2)?)(?(E)(?-2)))(?(E)|(?&E))|K((?3){7,9})?K)))

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

सुंदर-मुद्रित, और आंशिक रूप से अनगढ़ (पूर्ण बैकरेफ़्स रिश्तेदार में बदल गए, और कैप्चरिंग समूह गैर-कैप्चरिंग में बदल गए, या कुछ मामलों में गति के लिए परमाणु):

# Chess move validation regex (PCRE)
()?                 # decide whether to evaluate this as white's or black's move; \1 set = white, \1 unset (NPCG) = black
(?>|                # subroutines:
  ((.|\n(?=.)){2})                  # (?3) = for moving within the board, without wrapping to the next board, (?2) = (?3){2}
  ((?=                              # (?4) = assert that position of just-consumed piece is vacated on the next turn
    (\X{72})                        # (?5) = skip to the position of the just-consumed piece on the next turn
  -))
  ((?=(?(1)[-a-z]|[-A-Z])))         # (?6) = assert that the piece at the current position belongs to the current player's opponent or is empty
  ((?5)(?(?=(.*\n)\n)[qnrb]|p))     # (?7) = black pawn that might be promoted, (?8) = .*\n
  ((?5)(?(?=(?8){8}\n)[QNRB]|P))    # (?9) = white pawn that might be promoted
)
(?>
  (?>
    # Handle squares that don't change (empty->empty or pieces that doesn't move)
    (.)(?=(?5)\g{-1}) |
    # Handle a piece that moves (and optionally captures an enemy piece)
    (?(m)$)  # allow only one move to be made per turn
    (?>
      (?(1)
        (?:                                                         # white pawn
            -  (?=(?9))(?=(?3){8}((?3){9})?P(?4))(?(-1)(?=(?8){4}\n)) |   # move 1 or 2 spaces forward
          [a-z](?=(?9))(?=(?3){7}(?2)?     P(?4))                     )   # capture diagonally
      |
        (?:p(?4)(?:                                                 # black pawn
          (?=(?3){8}((?3){9})?  -  (?7))(?(-1)(?=(?8){7}\n)) |            # move 1 or 2 spaces forward
          (?=(?3){7}(?2)?     [A-Z](?7)) )                   )            # capture diagonally
      ) |
      # bishops, rooks, queens, knights, or kings
      (?<e>(?6).)?   # decide between scanning forward (<e> is unset) or backwards (<e> is captured)
      (?=
        (?i:
          (?|
            (?(e)|(B|Q)) (?&B)  (?(e)(B|Q)) | # bishops or queens
            (?(e)|(R|Q)) (?&R)  (?(e)(R|Q)) | # rooks or queens
            (?(e)|(N  )) (?&N)  (?(e)(N  )) | # knights
            (?(e)|(K  )) (?&K)? (?(e)(K  ))   # kings
          )
        )
        (?(e)(?<=(?!(?6)).)(?4)|(?6).(?5)\g{-2})   # verify that the piece moved, and optionally captured piece, are of the correct color
      )
      (?(e)(?=(?5)\g{-1})|(?!(?6)).(?4))   # verify that the piece moved is the same type and color at its destination in the next turn's board position
    )(?<m>) |
    (?(+1)$)(.)  # handle the destination/source square that a piece moved to/from (only allow matching one of these per turn)
  )+\n
)+
\k<m>         # assert that a move has taken place
\n
# don't allow moving into check  
(?!
  \X{0,70}
  (?:
    # pawns (capture diagonally)
    (?(1)p|k)(?=(?3){7}(?2)?(?(1)K|P)) |
    # bishops, rooks, queens, knights, or kings
    (?i:
      (?<E>(?!(?6))K)?   # decide between scanning forward (<E> is unset) or backwards (<E> is captured)
      (?:
        (?(E)|((?6)[BQ])) (?<B>()?((?(-1)-)(?3){7}(?(-2)(?2)))+)         (?(E)(?-4)) | # bishops or queens
        (?(E)|((?6)[RQ])) (?<R>-*|((?(-1)-)(?3){8})+)                    (?(E)(?-3)) | # rooks or queens
        (?(E)|((?6) N  )) (?<N>(?<=..)(?2){3}|(?=.)(?2){5}|(?2){8}(?2)?) (?(E)(?-2))   # knights
      )
      (?(E)|(?&E)) |
      K(?<K>(?3){7,9})?K   # kings
    )
  )
)

-88 बाइट्स गैर-परमाणु सबरूटीन कॉल का उपयोग करके, इस प्रकार PCRE1 से PCRE2 में पुन: आवर्ती

उपरोक्त संस्करण को संशोधित किया गया है ताकि एन पास या कास्ट करने की अनुमति न हो, लेकिन पूर्ण परियोजना वर्तमान में एक ऐसी स्थिति में है जहां यह हर प्रकार की चाल को मान्य करता है, प्रारंभिक बोर्ड राज्य में शुरू होता है (जो मानक शतरंज की प्रारंभिक स्थिति होनी चाहिए - शतरंज 960 नहीं है) समर्थित, अभी तक कम से कम)। एन पास और कास्टिंग के पूर्ण नियम लागू किए गए हैं।

यहाँ एक नमूना गेम पूर्ण रेगेक्स द्वारा मान्य है (PCRE1 - अभी तक रिटारगेट नहीं किया गया है) [regex101.com] ।

अमान्य कदम का परिणाम प्रत्येक बाद की बोर्ड स्थिति में मिलान / हाइलाइट नहीं होगा। चेकमेट / गतिरोध का पता लगाने, और इस प्रकार यह पता लगाना कि विजेता कौन है (या यदि यह ड्रॉ है), तो अभी तक लागू नहीं किया गया है; इसीलिए इस उदाहरण में अंतिम बोर्ड स्थिति पर प्रकाश नहीं डाला गया है।

यहां एक C / C ++ प्रोग्राम है जो बीजीय संकेतन को इस रेगेक्स द्वारा मान्यता प्राप्त प्रारूप में परिवर्तित करता है। बीजीय संकेतन को वर्तमान में स्रोत कोड में एक सरणी इनलाइन के रूप में रखा जाना चाहिए, प्रत्येक चाल के लिए अलग-अलग तार के साथ, लेकिन इसे स्टड या कमांड-लाइन तर्क से एकल स्ट्रिंग के रूप में पढ़ना, रिक्त स्थान के साथ चाल के पूरे अनुक्रम के साथ। और डॉट-टर्मिनेटेड मूव नंबर, योजनाबद्ध है।

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

Comments

जब से मैं सुडोकू सत्यापन प्रश्न के लिए एक 3000-बाइट regex राक्षसी खाँसी (एक बड़ी गलती, जीत का जवाब 75 से कम में मिल गया) को देखते हुए मैं इससे बहुत ज्यादा नहीं भरा था। सचमुच इस बात को साबित करता है कि कभी-कभी जब आप किसी समस्या को हल करने के लिए रेगेक्स का उपयोग करते हैं, तो आप दो समस्याओं को समाप्त कर देते हैं

— मूल्य इंक

@ValueInk हेह, शायद तुम सही हो, लेकिन मैं इसका (या शायद इसकी वजह से) इसकी अव्यवहारिकता की परवाह किए बिना आनंद लेता हूं। आपकी टिप्पणी ने मुझे उस सुडोकू प्रश्न का उत्तर देने का प्रयास करने के लिए प्रेरित किया, लेकिन मैंने केवल 200 बाइट्स प्रबंधित किए । ओह अच्छा।

— डेडकोड