कैसे पता जब एक FEN स्थिति कानूनी है?

Question

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

लेकिन क्या अन्य जाँच मुझे पूरी तरह से सुनिश्चित करने के लिए करनी चाहिए कि एक कानूनी कानूनी है?

Answer 1

यहाँ एक अच्छी तरह से आयोजित सूची है जिसे 99.99% + सामान्य पदों को मान्य करना चाहिए:

मंडल:

• कुल 8 कॉल हैं
• खाली वर्गों और टुकड़ों का योग प्रत्येक रैंक (पंक्ति) के लिए 8 जोड़ देता है
• खाली वर्गों के लिए लगातार संख्या नहीं हैं

किंग्स:

• देखें कि क्या वास्तव में एक w_king और एक b_king है
• सुनिश्चित करें कि राजाओं को 1 वर्ग अलग किया गया है

चेकों:

• गैर-सक्रिय रंग चेक में नहीं है
• सक्रिय रंग 3 बार से कम की जाँच की जाती है (ट्रिपल चेक असंभव है); 2 के मामले में यह कभी मोहरा नहीं है (प्यादा, बिशप, नाइट), बिशप + बिशप, नाइट + नाइट

प्यादे:

• प्रत्येक रंग से 8 से अधिक प्यादे नहीं हैं
• पहली या आखिरी रैंक (पंक्ति) में कोई प्यादे नहीं हैं क्योंकि वे या तो एक गलत शुरुआत की स्थिति में हैं या उन्हें पदोन्नत होना चाहिए।
• एन पास के वर्ग के मामले में; यह देखें कि क्या यह कानूनी रूप से बनाया गया था (उदाहरण के लिए यह x3या x6रैंक पर होना चाहिए , इसके सामने एक मोहरा (सही रंग से) होना चाहिए, और एन पास का वर्ग और इसके पीछे एक खाली है)
• लापता प्यादों (जैसे extra_pieces = Math.max(0, num_queens-1) + Math.max(0, num_rooks-2)...और फिर extra_pieces <= (8-num_pawns)) की तुलना में अधिक प्रचारित टुकड़े होने से रोकें , साथ ही आपको बिशप के लिए विशेष गणना करनी चाहिए, यदि आपके पास एक ही वर्ग रंग के दो (या अधिक) बिशप हैं, तो ये केवल मोहरे प्रचार के माध्यम से बनाए जा सकते हैं और आपको शामिल करना चाहिए यह जानकारी किसी भी तरह से ऊपर सूत्र को
• मोहरा गठन संभव है (उदाहरण के लिए एक ही क्षेत्र में कई प्यादों के मामले में, उस गठन को बनाने के लिए पर्याप्त दुश्मन के टुकड़े गायब होने चाहिए), यहां कुछ उपयोगी नियम दिए गए हैं:
  1. किसी एकल फ़ाइल (स्तंभ) में 6 से अधिक प्यादे होना असंभव है (क्योंकि प्यादे पहले और अंतिम रैंक में मौजूद नहीं हो सकते हैं)
  2. एक एकल क्षेत्र में कई मोहरे तक पहुंचने के लिए दुश्मन के लापता टुकड़े की न्यूनतम संख्या B to G 2=1, 3=2, 4=4, 5=6, 6=9 ___ A and H 2=1, 3=3, 4=6, 5=10, 6=15, उदाहरण के लिए, यदि आप ए या एच में 5 प्यादे देखते हैं, तो दूसरे खिलाड़ी को अपने 15 कैद के टुकड़ों से कम से कम 10 टुकड़े गायब होने चाहिए
  3. अगर a2 और a3 में सफेद प्यादे हैं, तो कानूनी रूप से b2 में एक नहीं हो सकता है, और इस विचार को और अधिक संभावनाओं को कवर करने के लिए विस्तारित किया जा सकता है

कैसलिंग:

• यदि राजा या किश्ती अपनी प्रारंभिक स्थिति में नहीं हैं; उस पक्ष के लिए कास्ट करने की क्षमता खो जाती है (राजा के मामले में, दोनों हार जाते हैं)

बिशप:

• पहले और अंतिम रैंक (पंक्तियों) में पंजे द्वारा फंसे हुए बिशप की तलाश करें जो उदाहरण के लिए स्थानांतरित नहीं हुए हैं:
  1. एक बिशप (कोई भी रंग) 3 प्यादों के पीछे फंस गया
  2. एक बिशप 2 गैर-शत्रु प्यादों के पीछे फंस गया ( शत्रु प्यादों द्वारा नहीं क्योंकि हम प्यादों को कम करके उस स्थिति तक पहुँच सकते हैं, हालाँकि यदि हम प्यादों की संख्या की जाँच करते हैं और extra_piecesहम यह निर्धारित कर सकते हैं कि यह मामला संभव है या नहीं)

गैर जम्परों:

• (यदि आप फिशर के शतरंज 960 को मान्य करना चाहते हैं तो इससे बचें) यदि राजा और किश्ती के बीच में गैर-कूदने वाले दुश्मन के टुकड़े हैं और बिना हिलाए अभी भी कुछ प्यादे हैं; जाँच करें कि क्या ये दुश्मन टुकड़े कानूनी रूप से वहाँ मिल सकते हैं। इसके अलावा, अपने आप से पूछें: क्या उस स्थिति को उत्पन्न करने के लिए राजा या बदमाश को स्थानांतरित करने की आवश्यकता थी? (यदि हाँ, तो हमें यह सुनिश्चित करने की ज़रूरत है कि कास्ट करने की क्षमताएँ इसे प्रतिबिंबित करें)
• यदि सभी 8 प्यादे अभी भी शुरुआती स्थिति में हैं, तो सभी गैर-कूदने वालों को अपनी प्रारंभिक रैंक (गैर-जंपर्स दुश्मन के टुकड़े संभवतः कानूनी रूप से दर्ज नहीं किए जा सकते हैं) नहीं छोड़ना चाहिए, अन्य समान विचार हैं, जैसे कि सफेद एच -पॉन एक बार चले गए, बदमाश अभी भी मोहरे के गठन के अंदर फंस जाना चाहिए, आदि।

आधी / पूरी चाल की घड़ियाँ:

• एन पास स्क्वायर के मामले में, आधी चाल की घड़ी 0 के बराबर होनी चाहिए
• HalfMoves <= ((FullMoves-1)*2)+(if BlackToMove 1 else 0), +1 या +0 स्थानांतरित करने के लिए पक्ष पर निर्भर करता है
• हॉफवॉम्स होना चाहिए x >= 0और फुलवॉव्सx >= 1

अन्य:

• सुनिश्चित करें कि FEN में वे सभी भाग हैं जो आवश्यक हैं (जैसे सक्रिय रंग, कास्ट करने की क्षमता, en passant square, आदि)

---

नोट: बनाने के लिए कोई जरूरत नहीं है 'खिलाड़ियों की तुलना में अधिक 16 टुकड़े नहीं करना चाहिए' की जांच क्योंकि अंक 'से अधिक नहीं 8 प्यादे' + 'अतिरिक्त पदोन्नत टुकड़े को रोकने के' + 'ठीक एक राजा' पहले से ही इस बात को शामिल करना चाहिए

टिप्पणी 2: इन नियमों सामान्य शतरंज के प्रारंभिक स्थिति से उत्पन्न होने वाली सत्यापित पदों के लिए करना है, नियमों में से कुछ से कुछ पदों को अमान्य कर देंगे Chess960 (अपवाद अगर व्यवस्था Nº518 से शुरू कर दिया) और उत्पन्न पहेली तो उनसे बचने एक कार्यात्मक सत्यापनकर्ता मिलता है।

Comments

आप प्यादा संरचना की भी जांच कर सकते हैं, उदाहरण के लिए सफेद प्यादे कभी भी a2, a3 और b2 पर नहीं हो सकते हैं; कोई रास्ता नहीं है एक मोहरा a3 और b2 दोनों पर हो सकता है।

— अकवाल

क्या यह कहना है कि एफईएन पदों को केवल प्रारंभिक स्थिति से प्राप्त किया जाना चाहिए? क्या होगा यदि मैं एक FEN द्वारा प्रतिनिधित्व की गई पहेली पोजीशन लेना चाहता हूं? कभी-कभी वे एक वास्तविक गेम तक पहुंचने के लिए असंभव तरीके से बनाए जाते हैं ...

— tbischel

@ मैं बिस्केल को सामान्य शतरंज के दृष्टिकोण (शतरंज 960 या अन्य उत्पन्न स्थितियों के लिए नहीं) से ये नियम बना रहा हूं , धन्यवाद मैं इसे स्पष्ट करने के लिए कहीं और इशारा कर सकता हूं

— ajax333221

सामान्य शतरंज के लिए भी, आप इन सभी जांचों को नहीं करना चाहते हैं। आप एक प्रोग्राम के साथ समाप्त होते हैं जो FEN के रूप में एक अवैध स्थिति का प्रतिनिधित्व नहीं कर सकता है। लेकिन वे अभ्यास में होते हैं - अवैध चाल कभी-कभी खेल के बाद ही देखी जाती है। क्या ऐसे खेलों से आरेख दिखाना असंभव हो सकता है, और इसी तरह?

— रेमकोगर्लिच

@ ajax333221: यह पृष्ठ , जिसमें सफेद पर अधिक से अधिक 5 प्यादे हो जाता है कानूनी खेल देता है aफ़ाइल।

Answer 2

\s*([rnbqkpRNBQKP1-8]+\/){7}([rnbqkpRNBQKP1-8]+)\s[bw-]\s(([a-hkqA-HKQ]{1,4})|(-))\s(([a-h][36])|(-))\s\d+\s\d+\s*

यहां एक नियमित अभिव्यक्ति है जो मैं यह सुनिश्चित करने के लिए उपयोग करता हूं कि एक एफईएन स्ट्रिंग वास्तव में वैध है। यह कानूनी / अवैध स्थिति के लिए कोई परीक्षण नहीं करता है, लेकिन यह एक अच्छा प्रारंभिक बिंदु है।

Comments

मुझे लगता है कि सक्रिय रंग बहुत जरूरी है (आप अनुमति दे रहे हैं -) और आधी / पूरी घड़ियां कभी-कभी वैकल्पिक होती हैं जो मुझे लगता है। इसके अलावा a-h, मैं /^\s*([rnbqkpRNBQKP1-8]+\/){7}([rnbqkpRNBQKP1-8]+)\s[bw]\s(-|K?Q?k?q?)\s(-|[a-h][36])/

— कास्ट

मैंने अभी उल्लेख किया है कि हम "प्रमोशन रैंकों में कोई मोहरे नहीं" कर सकते हैं, जैसे कुछ शुरू करने के साथ टेस्ट([rnbqkRNBQK1-8]+\/)([rnbqkpRNBQKP1-8]+\/){6}([rnbqkRNBQK1-8]+) ....

— ajax333221

घड़ियों के लिए भी यह अच्छा हो सकता है (0|[1-9][0-9]*)\s([1-9][0-9]*)क्योंकि चालों में अग्रणी शून्य नहीं हो सकता है और पूर्ण चाल 0 के साथ शुरू या नहीं हो सकती है, (कोड क्रेडिट)

— ajax333221

Answer 3

दूसरों के लिए, स्टॉकफिश इंजन में एक सरल कार्य है, जो एक एफईएन स्ट्रिंग को मान्य करता है।

bool Position::is_valid_fen(const std::string &fen) {
   std::istringstream iss(fen);
   std::string board, side, castleRights, ep;

   if (!iss) return false;

   iss >> board;

   if (!iss) return false;

   iss >> side;

   if (!iss) {
      castleRights = "-";
      ep = "-";
   } else {
      iss >> castleRights;
      if (iss)
         iss >> ep;
      else
         ep = "-";
   }

   // Let's check that all components of the supposed FEN are OK.
   if (side != "w" && side != "b") return false;
   if (castleRights != "-" && castleRights != "K" && castleRights != "Kk"
       && castleRights != "Kkq" && castleRights != "Kq" && castleRights !="KQ"
       && castleRights != "KQk" && castleRights != "KQq" && castleRights != "KQkq"
       && castleRights != "k" && castleRights != "q" && castleRights != "kq"
       && castleRights != "Q" && castleRights != "Qk" && castleRights != "Qq"
       && castleRights != "Qkq")
      return false;
   if (ep != "-") {
      if (ep.length() != 2) return false;
      if (!(ep[0] >= 'a' && ep[0] <= 'h')) return false;
      if (!((side == "w" && ep[1] == '6') || (side == "b" && ep[1] == '3')))
         return false;
   }

   // The tricky part: The board.
   // Seven slashes?
   if (std::count(board.begin(), board.end(), '/') != 7) return false;
   // Only legal characters?
   for (int i = 0; i < board.length(); i++)
      if (!(board[i] == '/' || (board[i] >= '1' && board[i] <= '8')
            || piece_type_is_ok(piece_type_from_char(board[i]))))
         return false;
   // Exactly one king per side?
   if (std::count(board.begin(), board.end(), 'K') != 1) return false;
   if (std::count(board.begin(), board.end(), 'k') != 1) return false;
   // Other piece counts reasonable?
   size_t wp = std::count(board.begin(), board.end(), 'P'),
      bp = std::count(board.begin(), board.end(), 'p'),
      wn = std::count(board.begin(), board.end(), 'N'),
      bn = std::count(board.begin(), board.end(), 'n'),
      wb = std::count(board.begin(), board.end(), 'B'),
      bb = std::count(board.begin(), board.end(), 'b'),
      wr = std::count(board.begin(), board.end(), 'R'),
      br = std::count(board.begin(), board.end(), 'r'),
      wq = std::count(board.begin(), board.end(), 'Q'),
      bq = std::count(board.begin(), board.end(), 'q');
   if (wp > 8 || bp > 8 || wn > 10 || bn > 10 || wb > 10 || bb > 10
       || wr > 10 || br > 10 || wq > 9 || bq > 10
       || wp + wn + wb + wr + wq > 15 || bp + bn + bb + br + bq > 15)
      return false;

   // OK, looks close enough to a legal position. Let's try to parse
   // the FEN and see!
   Position p;
   p.from_fen(board + " " + side + " " + castleRights + " " + ep);
   return p.is_ok(true);
}

Comments

ऐसा लगता है कि सभी वास्तविक सत्यापन में किया गया है position.is_okay()। यहाँ कोड सिर्फ बुनियादी जाँच के एक जोड़े को यह सुनिश्चित करने के लिए करता है कि यह सही ढंग से स्वरूपित है और यह वास्तविक सत्यापन करने के लायक है (अर्थात स्पष्ट रूप से नहीं )।

— अंडरग्राउंडोरेल

Answer 4

यहाँ एक सरल बैकग्राउंडिंग एल्गोरिथ्म है, बशर्ते कि आपके पास एक फ़ंक्शन है जो प्रत्येक बोर्ड राज्य में रिवर्स कानूनी चाल की जांच कर सकता है (जिसे स्थिति के रूप में भी जाना जाता है):

function is_legal_state(state,move)

   //Terminate if a starting state was found. This immediately implies there
   //was a legal game that generated this state, in fact the backtracking
   //can tell you precisely such a game       
   if (state in starting board state)
     return true

   //Apply some move to get to a new state, state is a persistent object
   apply_reverse_move(state,move)

   //Generate all legal "reverse" moves, that is, moves that could have
   //been performed to get to the current state from another position,
   //provided the previous position was valid. You do not have to check the
   //validness of the previous state, you just have to make sure the
   //transitioning move was valid
   legalmoves = enumerate_all_reverse_moves( state )

   for local_move in legalmoves:
     return is_legal_state(state,local_move)

   //Reverse the move that was previously applied so backtracking can
   //work properly 
   reverse_reverse_move(state,move)

   return false

Answer 5

एफईएन विनिर्देश में यह कहते हुए कुछ भी नहीं है कि प्रारंभिक सरणी से प्रतिनिधित्व की स्थिति पुन: प्राप्य होनी चाहिए। यह मानते हुए कि किसी दिए गए पद को प्रारंभिक सरणी से पहुंच योग्य नहीं है, एक अनसुलझी समस्या है।

एक मान्य FEN स्ट्रिंग में, एन मूवमेंट टारगेट स्क्वायर के साथ आधा मूव काउंट होना चाहिए; यदि कोई लक्ष्य वर्ग मौजूद है, तो आधी चाल की गिनती शून्य होनी चाहिए। आधी चाल की गिनती पूर्ण चाल संख्या के साथ भी होनी चाहिए; उदाहरण के लिए, दस की आधी चाल की गिनती तीन की पूर्ण चाल संख्या के साथ असंगत है।

Answer 6

पार्टी में देर से आना।

100% वैध होना संभव नहीं है, चाहे कोई पद कानूनी हो, लेकिन सत्यापन क्यों मायने रखता है? हम शतरंज खेल सकते हैं कि क्या स्थिति शुरुआती स्थिति (तथाकथित "गेम ऐरे") से प्राप्त होती है या नहीं। विश्लेषण करने के लिए एक बहुत ही दिलचस्प स्थिति हो सकती है लेकिन यह सिर्फ ऐसा होता है कि यह अवैध है।

तो मैं सिर्फ जाँच करेगा:

• क्या प्रत्येक पक्ष से ठीक 1 राजा है?
• क्या पहली या आठवीं रैंक पर कोई प्यादे नहीं हैं?
• क्या पहले से ही चेक देने के लिए पक्ष नहीं है?

यदि वह तीन YESes है तो हम इस आरेख से शतरंज को आगे खेल सकते हैं। और यहां तक ​​कि शर्तों की इस छोटी सूची को हम ढीला करने में सक्षम हो सकते हैं।