मुझे हाल ही में एक अजीब अनियमित शतरंज बोर्ड मिला है। यह वर्ग सभी जगह हैं और सभी जुड़े हुए भी नहीं हैं। कम से कम वे अभी भी एक नियमित ग्रिड पर रखी हैं। मैं बोर्ड पर खेलने के लिए सक्षम होने के लिए शतरंज के नियमों को अनुकूलित करना चाहता हूं, लेकिन इसके साथ शुरू करने के लिए, मुझे एक टुकड़े की आवश्यकता है जो वास्तव में बोर्ड पर कहीं भी जा सकता है, और ऐसा लगता है कि एक छलांग मेरे लिए सबसे अच्छा शर्त है।
लीपर्स शूरवीरों की परी शतरंज सामान्यीकरण हैं। लीपर्स को दो पूर्णांक m और n द्वारा परिमाणित किया जाता है और m वर्गों को एक दिशा में और फिर लंबवत दिशा में दूसरे n वर्ग को स्थानांतरित कर सकते हैं । मानक नाइट के लिए, हमारे पास (एम, एन) = (2, 1) है । इस पूरे कदम को एकल कूद माना जाता है ताकि लक्ष्य के रास्ते में कोई भी वर्ग खाली या मौजूद न हो।
चुनौती
आपको सकारात्मक 2 डी पूर्णांक निर्देशांक की एक सूची के रूप में "शतरंज बोर्ड" दिया गया है जो बोर्ड के भाग का प्रतिनिधित्व करते हैं। आपका काम एक लीपर खोजना है, जो पर्याप्त चाल को देखते हुए, बोर्ड पर किसी भी वर्ग तक पहुंच सकता है।
आइए कुछ उदाहरण देखें। मानक शतरंजबोर्ड 8x8 वर्गों की एक नियमित ग्रिड का उपयोग करता है (ध्यान दें कि हम इस चुनौती के लिए सफेद और काले वर्गों के बीच अंतर नहीं करते हैं):
########
########
########
########
########
########
########
########
मानक नाइट उन सभी तक पहुंच सकता है, इसलिए (2, 1)एक वैध आउटपुट होगा। हालांकि, (1, 1)उदाहरण के लिए मान्य नहीं होगा, क्योंकि इस तरह का एक टुकड़ा केवल चौकों तक पहुंच सकता है, जहां यह शुरू होता है। (1, 0)दूसरी तरफ एक वैध आउटपुट भी होगा, क्योंकि सभी वर्ग ऑर्थोगोनली जुड़े हुए हैं।
अब अगर हमारे पास एक अनियमित बोर्ड है जैसे:
# #
# # #
# # #
# #
#
तब संभव समाधान हैं (1, 1)और (3, 1)। हमारे पास पूरी तरह से डिस्कनेक्ट किए गए क्षेत्रों जैसे एक बोर्ड भी हो सकता है:
#### ####
#### ####
#### ####
#### ####
मानक शूरवीर (2, 1)अभी भी सभी वर्गों तक पहुंच सकता है, जो वास्तव में एकमात्र समाधान है।
और अंत में, निम्नलिखित सरल बोर्ड को किसी भी लीपर द्वारा पूरी तरह से पूरा नहीं किया जा सकता है:
#
##
ध्यान दें कि इनपुट प्रारूप ASCII प्रतिनिधित्व के रूप में नहीं होगा बल्कि इसके बजाय निर्देशांक की एक सूची होगी। उदाहरण के लिए ऊपर दूसरा उदाहरण दिया जा सकता है:
[[1, 1], [5, 1], [2, 2], [4, 2], [6, 2], [3, 3], [5, 3], [7, 3], [2, 4], [4, 4], [5, 5]]
नियम
आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट लेने और STDOUT (या निकटतम वैकल्पिक), फ़ंक्शन रिटर्न मान या फ़ंक्शन (आउट) पैरामीटर के माध्यम से परिणाम आउटपुट कर सकते हैं, एक प्रोग्राम या फ़ंक्शन लिख सकते हैं।
इनपुट निर्देशांक किसी भी सुविधाजनक सूची प्रारूप (फ्लैट सूची, जोड़े की सूची, जटिल पूर्णांक की सूची, लगातार विभाजक के साथ स्ट्रिंग, आदि) में लिया जा सकता है।
आउटपुट दो पूर्णांक m और n होना चाहिए जो कि लीपर की पहचान करता है यदि कोई समाधान मौजूद है (दो अलग-अलग पूर्णांकों के रूप में, एक सूची, गैर-संख्यात्मक सीमांकक के साथ एक स्ट्रिंग, आदि)। यदि कोई समाधान मौजूद नहीं है, तो आप किसी भी सुसंगत मूल्य का उत्पादन कर सकते हैं जो संभवतः एक वैध लीपर नहीं हो सकता है। इसमें (0, 0)आपके सामान्य प्रारूप में पूर्णांकों की जोड़ी शामिल है , साथ ही कुछ भी जो गैर-नकारात्मक पूर्णांकों की जोड़ी नहीं है।
आपके कार्यक्रम को एक मिनट के भीतर परीक्षण के किसी भी मामले को संभालने की आवश्यकता है । यह कुछ हद तक फ़र्ज़ी प्रतिबंध है, लेकिन सामान्य ज्ञान का उपयोग करें: यदि आपकी मशीन पर 2 मिनट लगते हैं, तो मुझे लगता है कि हम यह मान सकते हैं कि यह किसी और पर 1 के भीतर चल सकता है, लेकिन अगर इसमें 20 की संभावना कम है। प्रत्येक परीक्षण के मामले को सेकंड के एक मामले में हल करना मुश्किल नहीं होना चाहिए, इसलिए यह नियम केवल भोली जानवर बल पर शासन करने के लिए कार्य करता है।
मानक कोड-गोल्फ नियम लागू होते हैं।
परीक्षण के मामलों
प्रत्येक परीक्षण मामला प्रपत्र का है board => all valid leapers। याद रखें कि आपको केवल उन में से एक को आउटपुट करने की आवश्यकता है। यदि लीपर्स की सूची खाली है, तो ऐसा कुछ वापस करना सुनिश्चित करें जो वैध लीपर नहीं है।
Examples above:
[[1, 1], [1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [1, 7], [1, 8], [2, 1], [2, 2], [2, 3], [2, 4], [2, 5], [2, 6], [2, 7], [2, 8], [3, 1], [3, 2], [3, 3], [3, 4], [3, 5], [3, 6], [3, 7], [3, 8], [4, 1], [4, 2], [4, 3], [4, 4], [4, 5], [4, 6], [4, 7], [4, 8], [5, 1], [5, 2], [5, 3], [5, 4], [5, 5], [5, 6], [5, 7], [5, 8], [6, 1], [6, 2], [6, 3], [6, 4], [6, 5], [6, 6], [6, 7], [6, 8], [7, 1], [7, 2], [7, 3], [7, 4], [7, 5], [7, 6], [7, 7], [7, 8], [8, 1], [8, 2], [8, 3], [8, 4], [8, 5], [8, 6], [8, 7], [8, 8]] => [[0, 1], [1, 2], [1, 4], [2, 3], [3, 4]]
[[1, 1], [5, 1], [2, 2], [4, 2], [6, 2], [3, 3], [5, 3], [7, 3], [2, 4], [4, 4], [5, 5]] => [[1, 1], [1, 3]]
[[1, 1], [2, 2], [3, 2]] => []
[[1, 1], [1, 2], [1, 3], [1, 4], [2, 1], [2, 2], [2, 3], [2, 4], [3, 1], [3, 2], [3, 3], [3, 4], [4, 1], [4, 2], [4, 3], [4, 4], [6, 1], [6, 2], [6, 3], [6, 4], [7, 1], [7, 2], [7, 3], [7, 4], [8, 1], [8, 2], [8, 3], [8, 4], [9, 1], [9, 2], [9, 3], [9, 4]] => [[1, 2]]
Square boards:
[[1, 1], [1, 2], [2, 1], [2, 2]] => [[0, 1]]
[[1, 1], [1, 2], [1, 3], [2, 1], [2, 2], [2, 3], [3, 1], [3, 2], [3, 3]] => [[0, 1]]
[[1, 1], [1, 2], [1, 3], [1, 4], [2, 1], [2, 2], [2, 3], [2, 4], [3, 1], [3, 2], [3, 3], [3, 4], [4, 1], [4, 2], [4, 3], [4, 4]] => [[0, 1], [1, 2]]
[[1, 1], [1, 2], [1, 3], [1, 4], [1, 5], [2, 1], [2, 2], [2, 3], [2, 4], [2, 5], [3, 1], [3, 2], [3, 3], [3, 4], [3, 5], [4, 1], [4, 2], [4, 3], [4, 4], [4, 5], [5, 1], [5, 2], [5, 3], [5, 4], [5, 5]] => [[0, 1], [1, 2]]
[[1, 1], [1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [2, 1], [2, 2], [2, 3], [2, 4], [2, 5], [2, 6], [3, 1], [3, 2], [3, 3], [3, 4], [3, 5], [3, 6], [4, 1], [4, 2], [4, 3], [4, 4], [4, 5], [4, 6], [5, 1], [5, 2], [5, 3], [5, 4], [5, 5], [5, 6], [6, 1], [6, 2], [6, 3], [6, 4], [6, 5], [6, 6]] => [[0, 1], [1, 2], [2, 3]]
[[1, 1], [1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [1, 7], [2, 1], [2, 2], [2, 3], [2, 4], [2, 5], [2, 6], [2, 7], [3, 1], [3, 2], [3, 3], [3, 4], [3, 5], [3, 6], [3, 7], [4, 1], [4, 2], [4, 3], [4, 4], [4, 5], [4, 6], [4, 7], [5, 1], [5, 2], [5, 3], [5, 4], [5, 5], [5, 6], [5, 7], [6, 1], [6, 2], [6, 3], [6, 4], [6, 5], [6, 6], [6, 7], [7, 1], [7, 2], [7, 3], [7, 4], [7, 5], [7, 6], [7, 7]] => [[0, 1], [1, 2], [2, 3]]
Miscellaneous:
[[1, 1], [2, 1]] => [[0, 1]]
[[1, 1], [1, 2]] => [[0, 1]]
[[1, 1], [12, 35]] => [[11, 34]]
[[1, 1], [1, 2], [2, 1], [2, 2], [6, 1], [6, 2], [6, 3], [6, 4], [7, 1], [7, 2], [7, 3], [7, 4], [8, 1], [8, 2], [8, 3], [8, 4], [9, 1], [9, 2], [9, 3], [9, 4]] => []
[[1, 1], [1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [2, 1], [2, 2], [2, 3], [2, 4], [2, 5], [2, 6], [3, 1], [3, 2], [3, 5], [3, 6], [4, 1], [4, 2], [4, 5], [4, 6], [5, 1], [5, 2], [5, 3], [5, 4], [5, 5], [5, 6], [6, 1], [6, 2], [6, 3], [6, 4], [6, 5], [6, 6]] => [[0, 1], [1, 2], [1, 4]]
[[2, 2], [2, 4], [2, 6], [2, 8], [4, 2], [4, 4], [4, 6], [4, 8], [6, 2], [6, 4], [6, 6], [6, 8], [8, 2], [8, 4], [8, 6], [8, 8]] => [[0, 2], [2, 4]]
Random boards:
[[1, 5], [1, 9], [2, 6], [2, 8], [2, 10], [2, 12], [3, 5], [3, 7], [3, 9], [3, 11], [3, 13], [4, 2], [4, 4], [4, 6], [4, 8], [4, 14], [5, 1], [5, 3], [5, 5], [5, 7], [6, 2], [6, 4], [7, 1], [8, 2]] => [[1, 1], [1, 3]]
[[1, 3], [1, 4], [1, 5], [1, 6], [1, 7], [2, 1], [2, 2], [2, 3], [2, 4], [2, 7], [3, 1], [3, 2], [3, 3], [3, 4], [3, 6], [3, 7], [4, 2], [4, 3], [4, 4], [4, 5], [4, 6], [5, 3], [5, 4], [5, 6]] => [[0, 1], [1, 2]]
[[1, 8], [2, 6], [2, 10], [3, 3], [3, 4], [3, 8], [4, 1], [4, 11], [5, 3], [5, 9], [6, 12], [8, 11], [10, 10], [11, 12], [12, 6], [12, 8], [13, 6], [13, 8], [13, 10], [13, 11], [14, 5], [14, 7], [14, 8], [14, 13], [14, 14], [15, 7], [15, 9], [15, 11], [15, 12], [16, 6], [16, 7], [16, 9], [16, 13], [16, 14], [17, 10], [17, 12], [18, 8], [18, 12], [20, 9], [21, 11], [22, 13], [23, 10], [23, 11], [23, 15], [24, 12]] => [[1, 2]]
[[1, 17], [1, 21], [3, 11], [3, 15], [3, 19], [3, 23], [5, 13], [5, 21], [7, 11], [7, 15], [7, 19], [9, 1], [9, 13], [9, 17], [11, 3], [11, 7], [11, 15], [11, 19], [13, 5], [13, 9], [13, 13], [13, 17], [13, 21], [15, 11], [15, 15], [15, 19], [17, 13], [17, 17]] => [[2, 2], [2, 6], [2, 10]]
[[1, 3], [2, 4], [2, 5], [3, 6], [4, 1], [5, 3], [5, 6], [5, 7], [6, 12], [6, 14], [6, 21], [7, 9], [7, 19], [8, 9], [8, 15], [8, 17], [8, 18], [8, 24], [9, 12], [9, 19], [10, 12], [10, 14], [10, 17], [10, 21], [11, 22], [12, 15], [12, 17], [12, 24], [13, 16], [14, 20], [14, 21], [14, 26], [15, 13], [15, 19], [16, 18], [16, 23], [17, 16], [17, 24]] => [[2, 3]]
[[1, 11], [3, 13], [4, 10], [6, 14], [8, 12], [9, 9], [9, 15], [12, 8], [13, 5], [13, 19], [13, 21], [14, 8], [15, 1], [15, 17], [16, 4], [16, 14], [16, 18], [16, 20], [17, 21], [18, 2], [18, 16], [18, 18], [19, 9], [19, 13], [19, 15], [20, 12], [21, 1], [21, 17], [22, 4], [22, 10], [23, 7]] => [[1, 3]]
[[1, 39], [6, 37], [8, 32], [10, 27], [11, 31], [11, 35], [12, 22], [16, 21], [16, 29], [16, 33], [18, 34], [21, 3], [21, 9], [21, 19], [23, 8], [23, 14], [23, 22], [23, 24], [23, 36], [24, 6], [25, 13], [25, 17], [26, 1], [26, 11], [28, 6], [28, 20], [28, 26], [28, 30], [28, 34], [30, 11], [30, 15], [30, 21], [32, 6], [33, 28], [33, 32], [35, 13], [35, 23]] => [[2, 5]]
एक विशेष मामले के रूप में, ध्यान दें कि केवल एक सेल वाले बोर्ड के लिए, कोई भी लीपर काम करता है, लेकिन आपका आउटपुट वास्तविक लीपर के अनुरूप होना चाहिए, इसलिए [0, 0]यह मान्य आउटपुट नहीं है।
[[1, 0], [0, 1]]?
(2,1)कैसा है? अगर मैं गलत हूं तो मुझे सुधारो, लेकिन मुझे पूरा यकीन है कि शूरवीर किसी एक दिशा में 3 वर्ग को स्थानांतरित कर सकते हैं, और फिर किसी भी दिशा में 1 वर्ग पिछले एक तरफ सीधा हो सकता है, इसलिए यह इसके बजाय होना चाहिए(3,1)।