खोई हुई प्यादा समस्या

Question

खोई हुई प्यादा समस्या

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

मूल समस्या एक nXn "शतरंज" बोर्ड और f: {1,..,n-1}X{1,..,n}X{-1,0,1} => R+वजन के एक फ़ंक्शन का वर्णन करती है । लक्ष्य नितंब रेखा में कुछ वर्ग से सबसे अच्छा रास्ता खोजने के लिए है, शीर्ष पंक्ति में कुछ अन्य वर्ग के लिए, जहां संभव चालें हैं: बाएं-ऊपर, ऊपर, दाएं-अप, और आप बोर्ड से बाहर नहीं निकल सकते हैं।

इस समस्या को ओ (एन ^ 2) में गतिशील प्रोग्रामिंग का उपयोग करके हल करना आसान है, लेकिन यह कोडगोल्फ है, और हम समय की जटिलता जैसे बेकार सामान की परवाह नहीं करते हैं ...

समस्या

इनपुट: एक नियमित रूप से शतरंज बोर्ड के अनुरूप 3-डिमेंशनल सरणी (या अपनी पसंद के कुछ अन्य संग्रह, एक फ़ंक्शन तर्क के रूप में), बिल्कुल आकार में: 7X8X3 (#linePasses X #mrowize X #movesPerPass) युक्त गैर-नकारात्मक पूर्णांक। चाल सूचकांक, और स्तंभ सूचकांक है, जहां कुछ स्थिति से लागत चलती है :(i,j)ij

• a[i][j][0]लागत के लिए यात्रा करने के लिए वर्ग के लिए छोड़ दिया है (i+1,j-1), या रेखांकन \:।
• a[i][j][1]वर्ग (i+1,j), या रेखांकन तक यात्रा करने की लागत के लिए |:।
• a[i][j][2]वर्गाकार (i+1,j+1)या रेखीय रूप से यात्रा करने की लागत के लिए /:।

आप यह मान सकते हैं कि इसमें ऐसा मार्ग नहीं होगा जो इससे अधिक हो MAX_INT।

आउटपुट: एक 8X8 ascii आउटपुट सबसे अच्छा (सबसे कम, यानी न्यूनतम राशि) पथ दिखा रहा है (यदि 1 से अधिक इष्टतम परिणाम है, तो आप अपनी पसंद का एक मनमाना पथ दिखा सकते हैं)। पथ को ऊपर से नीचे की ओर खींचा जाता है, जहां प्रत्येक पंक्ति में, मार्ग में प्यादा की स्थिति के अनुरूप वर्ण, वह है जिसे वह बनाने वाला है। उदाहरण के लिए, यदि प्यादा कॉलम 3 (कॉलम 2 से) से ऊपर-बाएँ जाने वाला है, तो आपको आकर्षित करना चाहिए:

#?######
##\#####

जहां ?अगले कदम के साथ प्रतिस्थापित किया जाना चाहिए। अंतिम स्थिति के रूप में तैयार किया जाना चाहिए X।

उदाहरण

इनपुट:

[
  [[1,1,1],[1,1,1],[0,1,1],[1,1,1],[1,1,1],[1,1,1],[1,1,1],[1,1,1]],
  [[1,1,1],[1,0,1],[1,1,1],[1,1,1],[1,1,1],[1,1,1],[1,1,1],[1,1,1]],
  [[1,1,1],[1,1,0],[1,1,1],[1,1,1],[1,1,1],[1,1,1],[1,1,1],[1,1,1]],
  [[1,1,1],[1,1,1],[1,1,0],[1,1,1],[1,1,1],[1,1,1],[1,1,1],[1,1,1]],
  [[1,1,1],[1,1,1],[1,1,1],[1,0,1],[1,1,1],[1,1,1],[1,1,1],[1,1,1]],
  [[1,1,1],[1,1,1],[1,1,1],[1,0,1],[1,1,1],[1,1,1],[1,1,1],[1,1,1]],
  [[1,1,1],[1,1,1],[1,1,1],[0,1,1],[1,1,1],[1,1,1],[1,1,1],[1,1,1]]
]

उत्पादन:

##X#####
###\####
###|####
###|####
##/#####
#/######
#|######
##\#####

इनपुट:

[
  [[41,27,38],[12,83,32],[50,53,35],[46,32,26],[55,89,82],[75,30,87],[2,11,64],[8,55,22]],
  [[56,21,0],[83,25,38],[43,75,63],[56,60,77],[68,55,89],[99,48,67],[94,30,9],[62,62,58]],
  [[23,18,40],[24,47,61],[96,45,72],[71,6,48],[75,63,98],[93,56,51],[23,31,30],[49,34,99]],
  [[20,47,42],[62,79,72],[32,28,44],[68,61,55],[62,39,57],[4,17,49],[97,85,6],[91,18,12]],
  [[51,50,11],[32,39,56],[12,82,23],[33,88,87],[60,55,22],[29,78,14],[70,11,42],[63,94,67]],
  [[75,64,60],[27,79,86],[70,72,56],[55,45,32],[95,67,12],[87,93,98],[81,36,53],[38,22,93]],
  [[31,80,50],[77,71,22],[59,46,86],[64,71,53],[41,19,95],[62,71,22],[92,80,41],[26,74,29]]
]

उत्पादन:

######X#
#####/##
####/###
#####\##
#####|##
######\#
######|#
#######\

यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है।

निष्पक्ष खेलें। कोई खामियां नहीं ...

संपादित करें:

Iv'e scala में आप देख सकते हैं एक un-golfed सीधे आगे समाधान लिखा है । एक ऐसी साइट भी है जिसे आप स्कैला कोड के साथ ऑन-लाइन खेल सकते हैं: स्कलाटाटा (बस स्कैलेकाटा को कॉपी और पेस्ट करें, और प्ले बटन दबाएं)

Answer 1

प्रश्न: 199 बाइट्स

f:{m::x;n::{@/[+/-1 0 1_\:/:(x;m[y;;|!3]);0 2;(0W,),{x,0W}]};i:*<*|r:{&/n[x;y]}\[8#0;!7];  s:{-1+{*<x}'+n[y;z]}\[();(,8#0),-1_r;!7];j:i,{x+y x}\[i;|s];-1(@[8#"#";;:;]'[j;"X","/|\\"1+s'[|!7;-1_j]]);}

टिप्पणियाँ

• Q इंटरप्रेटर (kx.com) गैर-कॉमरेटिक उपयोग के लिए मुफ़्त (विंडोज़, लिनक्स, मैक के लिए संस्करण)
• यह समाधान Q के आंतरिक कोर (आंतरिक रूप से नामित k4) का उपयोग करता है, इसलिए हमें k एक्सटेंशन के साथ स्क्रिप्टिंग फ़ाइल की आवश्यकता होती है, या k मोड में इंटरएक्टिव इंटरप्रेटर (पहले कमांड में \ कमांड)। इसके विपरीत, भाषा के 'वर्बोज़' (सुपाठ्य) संस्करण को क्यू एक्सटेंशन के साथ स्क्रिप्ट की आवश्यकता होती है, और इंटरएक्टिव इंटरप्रेटर पर डिफ़ॉल्ट मोड है।

परीक्षा

f ((1 1 1; 1 1 1; 0 1 1; 1 1 1; 1 1 1; 1 1 1; 1 1 1; 1 1 1)
   (1 1 1; 1 0 1; 1 1 1; 1 1 1; 1 1 1; 1 1 1; 1 1 1; 1 1 1)
   (1 1 1; 1 1 0; 1 1 1; 1 1 1; 1 1 1; 1 1 1; 1 1 1; 1 1 1)
   (1 1 1; 1 1 1; 1 1 0; 1 1 1; 1 1 1; 1 1 1; 1 1 1; 1 1 1)
   (1 1 1; 1 1 1; 1 1 1; 1 0 1; 1 1 1; 1 1 1; 1 1 1; 1 1 1)
   (1 1 1; 1 1 1; 1 1 1; 1 0 1; 1 1 1; 1 1 1; 1 1 1; 1 1 1)
   (1 1 1; 1 1 1; 1 1 1; 0 1 1; 1 1 1; 1 1 1; 1 1 1; 1 1 1))

##X#####
###\####
###|####
###|####
##/#####
#/######
#|######
##\#####

f ((41 27 38; 12 83 32; 50 53 35; 46 32 26; 55 89 82; 75 30 87;  2 11 64;  8 55 22)
   (56 21  0; 83 25 38; 43 75 63; 56 60 77; 68 55 89; 99 48 67; 94 30  9; 62 62 58)
   (23 18 40; 24 47 61; 96 45 72; 71  6 48; 75 63 98; 93 56 51; 23 31 30; 49 34 99)
   (20 47 42; 62 79 72; 32 28 44; 68 61 55; 62 39 57;  4 17 49; 97 85  6; 91 18 12)
   (51 50 11; 32 39 56; 12 82 23; 33 88 87; 60 55 22; 29 78 14; 70 11 42; 63 94 67)
   (75 64 60; 27 79 86; 70 72 56; 55 45 32; 95 67 12; 87 93 98; 81 36 53; 38 22 93)
   (31 80 50; 77 71 22; 59 46 86; 64 71 53; 41 19 95; 62 71 22; 92 80 41; 26 74 29))

######X#
#####/##
####/###
#####\##
######\#
######|#
######|#
#######\

व्याख्या

इलस्ट्रेशन उद्देश्य के लिए, हम दूसरा परीक्षण (मैट्रिक्स (41 27 38; 12 83 32; ....) मानते हैं।

हम मूल मैट्रिक्स (कोड स्तर पर एम) को बदलते हैं: प्रत्येक समन्वय के लिए ट्रिपल के साथ ओरेंजिमल मैट्रीज़ के बजाय, हम मैट्रिक्स को बाएं, ऊपर और दाएं विस्थापन के लिए परिभाषित करते हैं। वाम मैट्रिक्स में 7x7 मान (हम पहला स्तंभ छोड़ते हैं), ऊपर मैट्रिक्स 7x8, और दायां मैट्रिक्स 7x7 (हम अन्य कॉलम को फ़्री) करते हैं।

left                           up                         right
12 50 46 55 75 2  8       27 83 53 32 89 30 11 55     38 32 35 26 82 87 64
83 43 56 68 99 94 62      21 25 75 60 55 48 30 62     0  38 63 77 89 67 9 
24 96 71 75 93 23 49      18 47 45 6  63 56 31 34     40 61 72 48 98 51 30
62 32 68 62 4  97 91      47 79 28 61 39 17 85 18     42 72 44 55 57 49 6 
32 12 33 60 29 70 63      50 39 82 88 55 78 11 94     11 56 23 87 22 14 42
27 70 55 95 87 81 38      64 79 72 45 67 93 36 22     60 86 56 32 12 98 53
77 59 64 41 62 92 26      80 71 46 71 19 71 80 74     50 22 86 53 95 22 41

अंतिम स्थिति की गणना करने के लिए हमें न्यूनतम लागत पथ का मूल्यांकन करने की आवश्यकता है। हम प्रारंभिक लागत मान लेते हैं 0 0 0 0 0 0 0 0 (पहली पंक्ति के प्रत्येक कॉलम पर पहुंचने की लागत), और प्रत्येक अगली पंक्ति के साथ पुनरावृत्त होते हैं। प्रत्येक स्तंभ i पर, हम तीन मानों की गणना करते हैं:

• पिछले i + 1 मूल्य प्लस की लागत [i + 1] छोड़ दी। हम लागत के पहले घटक को छोड़ते हैं (शिफ्ट और एलिनिटेस कॉलम को जोड़ने के लिए) और घटक को योग

• पिछले i मूल्य की लागत से अधिक [i]। हम घटक को योग करते हैं

• पिछले i-1 मूल्य की लागत प्लस सही [i-1]। हम लागत के पिछले घटक को छोड़ देते हैं (घटक को जोड़ने के लिए शिफ्ट और एलिनिटेस कॉलम) और घटक को योग राशि

न्यूनतम गणना करने के लिए, हम अनंत और पूर्ववर्ती लागत को छोड़ते हुए अनंत को छोड़ते हुए पूर्ण लागत को पूरा करते हैं: आठ घटकों के 3 वैक्टर के साथ, घटक के न्यूनतम घटक की गणना करें। परिणामी मूल्य नए पुनरावृत्ति के लिए आधार लागत है

प्रथम पुनरावृत्ति के लिए हम मान प्राप्त करते हैं (0W Q में अनंत है)

0W 12 50 46 55 75 2  8
27 83 53 32 89 30 11 55
38 32 35 26 82 87 64 0W

और प्रत्येक कॉलम की न्यूनतम गणना करता है

27 12 35 26 55 30 2 8

सभी पुनरावृत्तियों के बाद, हमारे पास प्रत्येक वर्ग तक पहुंचने के लिए न्यूनतम लागत है (शीर्ष पर पंक्ति 0, नीचे 7)। हम केवल अंतिम कॉलम में रुचि रखते हैं, लेकिन मैं ilustrative उद्देश्यों के लिए सभी मध्यवर्ती परिणाम आकर्षित करता हूं

0   0   0   0   0   0   0   0
27  12  35  26  55  30  2   8
27  37  78  82  110 78  11  70
45  61  123 88  173 129 34  104
87  123 151 143 212 133 40  122
98  155 163 176 234 147 51  185
158 182 219 208 246 234 87  207
208 204 265 261 265 256 128 233

अब हमने अंतिम पंक्ति (कॉलम 6 पर 128) पर न्यूनतम मूल्य पाया। वह मार्ग का अंत है (ouput में X वर्ण)।

हम लागत गणना को फिर से दोहराते हैं, लेकिन अब हम प्रत्येक न्यूनतम प्राप्त करने के लिए दिशा को एनोटेट करते हैं (न्यूनतम गणना करने के लिए उपयोग किए गए 3 मानों में से जो चयनित मूल्य है)।

\|/|\///
\\\\\/|/
\\\|//|/
\\|\//|/
\\|//|\/
\\//|\|/
\|/|/|\/

हम पंक्तियों को उल्टा करते हैं, पॉज़ 6 पर 'X' डालते हैं, और कॉलम 6 पर समाप्त होने वाले केवल पथ को संरक्षित करते हैं (अन्य को # द्वारा प्रतिस्थापित किया जाता है)

######X#
#####/##
####/###
#####\##
######\#
######|#
######|#
#######\

Comments

Iv'e क्यू के बारे में कभी नहीं सुना, लेकिन इस तरह की एक विस्तृत प्रतिक्रिया के लिए धन्यवाद :)

— गिल्ड होच