इंटरएक्टिव भूलभुलैया सॉल्वर

Question

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

चूँकि उसे आपके प्रोग्राम को मेमोरी द्वारा चलाना है, इसलिए इसे जितना संभव हो उतना छोटा होना चाहिए।

नोट: मैंने इस समस्या को http://acmgnyr.org/year2016/problems.shtml से लिया है , लेकिन इसे थोड़ा अनुकूलित किया है, और जज प्रोग्राम / टेस्ट मामलों को स्वयं लिखा है।

विशिष्टता

• यह एक इंटरएक्टिव समस्या है, इसलिए आप प्रोग्राम को स्टडआउट में आउटपुट करेंगे, और स्टैडिन से प्रतिक्रियाएं लेंगे।
• चालों के अपने कार्यक्रम कर सकते हैं उत्पादन एक right, left, down, up।
• इसके बाद निम्नलिखित में से एक इनपुट के रूप में मिलेगा:
  • wall- इसका मतलब है कि बॉब ने एक दीवार पर प्रहार किया है। बॉब उसी जगह पर रहेंगे।
  • solved- बॉब ने बाहर निकल लिया! आपका कार्यक्रम अब किसी और चीज को छापे बिना भी बाहर निकल जाना चाहिए।
  • ok - बॉब दी गई दिशा में आगे बढ़ने में सक्षम था।
• यदि भूलभुलैया में कोई निकास नहीं है, तो आपके प्रोग्राम को no exitबॉब को यह बताने के लिए आउटपुट देना चाहिए कि उसे हार मान लेनी चाहिए। आपके कार्यक्रम को फिर कुछ और छापे बिना बाहर निकल जाना चाहिए।
• चूंकि बॉब बाहर निकलने की जल्दी में है, इसलिए आपके कार्यक्रम में कोई बाहरी कदम नहीं होना चाहिए। दूसरे शब्दों में, आपके प्रोग्राम को एक ही वर्ग से दो बार एक ही दिशा में जाने की अनुमति नहीं है ।
• यह कोड-गोल्फ है , इसलिए सबसे छोटा कार्यक्रम जीतता है!

उदाहरण

निम्नलिखित उदाहरणों में, Sशुरुआती वर्ग Xहै, निकास है, #एक दीवार है, और रिक्त स्थान वैध वर्ग हैं। चूंकि एक भी सही उत्तर नहीं है, ये केवल एक समाधान के उदाहरण हैं। यह भी ध्यान दें कि भूलभुलैया के चित्र सिर्फ आपके देखने के लिए हैं, और आपके प्रोग्राम को इनपुट के रूप में नहीं मिलेगा।

########
#S     #
###### #
     # #
     #X#

right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              wall
down
              ok
right
              wall
down
              ok
right
              wall
down
              solved

#####
# S #
#####

right
              ok
right
              wall
down
              wall
up
              wall
left
              ok
down
              wall
up
              wall
left
              ok
down
              wall
up
              wall
left
              wall
right
              ok
no exit
              solved

###############################
#S                            #
##############       ###      #
             #       #X#      #
             #                #
             ##################

right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              ok
right
              wall
down
              ok
right
              wall
down
              ok
right
              wall
down
              ok
right
              wall
down
              wall
left
              ok
down
              wall
up
              ok
up
              ok
left
              ok
down
              ok
down
              ok
down
              wall
left
              ok
down
              wall
up
              ok
up
              ok
left
              ok
down
              ok
down
              ok
down
              wall
left
              ok
down
              wall
up
              ok
up
              ok
left
              wall
down
              ok
left
              wall
down
              ok
left
              ok
down
              wall
up
              wall
left
              ok
down
              wall
up
              solved

चेकर कार्यक्रम

• मैंने पायथन में एक समाधान परीक्षक लिखा है। आप इसे https://gist.github.com/Maltysen/f0186019b3aa3812d812f8bb984fee19 पर देख सकते हैं ।
• इसे वैसे ही चलाएं python mazechecker.py ./mazesolver।
• यह एक फ़ोल्डर में सभी mazes पर अपने कार्यक्रम का परीक्षण करेगा mazes।
• मेज़ ऊपर से एक ही प्रारूप में अलग-अलग फाइलों में हैं।
• यह ऊपर सूचीबद्ध सभी शर्तों की जांच करता है, और यदि आपका समाधान किसी भी उल्लंघन करता है, तो आपको सूचित करता है।
• आप इसके साथ अतिरिक्त नैदानिक ​​जानकारी प्रिंट कर सकते हैं python mazechecker.py -d ./mazesolver।
• आप यहाँ एक ज़िपित mazesफ़ोल्डर पा सकते हैं । आप चाहें तो इसमें अपना खुद का ऐड भी कर सकते हैं।

Comments

यह शायद स्पष्ट रूप से लायक है कि समस्या CC-BY-NA-SA लाइसेंस के तहत जारी की गई थी, और इसलिए आपका रीमिक्स आवश्यक रूप से उसी लाइसेंस के तहत है।

— निक केनेडी

क्या हमें solvedआउटपुट कब मिलता है no exit? यदि ऐसा है तो कृपया नियमों में ही बताएं, न केवल परीक्षण मामलों में!

— wastl

" आपके कार्यक्रम को एक ही वर्ग से दो बार एक ही दिशा में जाने की अनुमति नहीं है। " इस बारे में दो प्रश्न: 1. चलो कहते हैं कि मैं स्थिति में हूं x,yऔर upजवाब के साथ wall, rightफिर जवाब के साथ wall, मैं फिर से कोशिश कर सकता हूं up, या केवल leftऔर downअभी भी उपलब्ध हैं क्योंकि मैं अभी तक इस वर्ग से स्थानांतरित नहीं हुआ हूं?

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

2. मान लीजिए कि मेरे पास यह भूलभुलैया है । इस प्रवाह के साथ: सही (ठीक); ठीक है सही); दाईं (दीवार); ऊपर (ठीक) ; ऊपर (ठीक); ऊपर (दीवार); बाईं (दीवार); नीचे (ठीक); नीचे (ठीक); नीचे (ठीक); नीचे (ठीक); नीचे (दीवार); दाईं (दीवार); ऊपर (ठीक); ऊपर (ठीक); क्या मैंने अब फिर से ऊपर जाने की अनुमति दी है, हालांकि मैंने पहले से ही उस विशिष्ट वर्ग से (बोल्ड एक पर) किया था?

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

@ केविनक्रूजसेन मैं स्पष्ट रूप से ट्रैक नहीं करता कि मैं अपने जवाब में कहां से आया हूं। इसके बजाय, मैं उन सभी दिशाओं पर नज़र रखता हूं, जिन्हें प्रत्येक वर्ग पर संसाधित किया गया था और मैं पहले गैर-स्वीकृत वर्गों की कोशिश करता हूं। जब सभी गैर-स्वीकृत वर्गों की कोशिश की गई है, तो केवल शेष कानूनी कदम वह है जहां मैं आया था (पहले से ही दौरा किया गया था, लेकिन इस दिशा में नहीं)।

— अरनुलद

Answer 1

जावास्क्रिप्ट (ईएस 6),  180  174 बाइट्स

उपयोग prompt()दिशा का उत्पादन करने और परिणाम प्राप्त करने के लिए है।

_=>(g=p=>[...'012301234'].some((d,i)=>g[p]>>d&1|i<4&g[P=[p[0]+(d-2)%2,p[1]+~-d%2]]>0?0:(r=prompt('up/left/down/right/no exit'.split`/`[g[p]|=1<<d,d]))<'s'?g(P):r<'t'))([0,0])

इसे ऑनलाइन आज़माएं! (स्वचालित I / O के साथ)

इंटरएक्टिव स्निपेट

चेतावनी : यह कोड एक त्वरित () संवाद प्रदर्शित करेगा जब तक कि 'हल' दर्ज नहीं किया जाता है या फ़ंक्शन आंकड़े बाहर निकालता है कि कोई निकास नहीं है।

(
_=>(g=p=>[...'012301234'].some((d,i)=>g[p]>>d&1|i<4&g[P=[p[0]+(d-2)%2,p[1]+~-d%2]]>0?0:(r=prompt('up/left/down/right/no exit'.split`/`[g[p]|=1<<d,d]))<'s'?g(P):r<'t'))([0,0])
)()

टिप्पणी की गई

_ => (                      // anonymous function taking no argument
  g = p =>                  // g = recursive function taking the current position p = [x, y]
    [ ...'0123',            // i<4  : try to move on squares that haven't been visited yet
      ...'0123',            // 3<i<8: try to go back to where we initially came from
      ...'4'                // i=8  : if everything failed, there must be no exit
    ].some((d, i) =>        // for each direction d at index i:
      g[p] >> d & 1         //   if this direction was already tried at this position
      | i < 4 &             //   or i is less than 4 and
      g[P = [               //   the square at the new position P = [X, Y] with:
        p[0] + (d - 2) % 2, //     X = x + dx[d]
        p[1] + ~-d % 2      //     Y = y + dy[d]
      ]] > 0 ?              //   was already visited:
        0                   //     abort
      : (                   //   else:
        r = prompt(         //     output the direction:
          [ 'up',           //       0 = up
            'left',         //       1 = left
            'down',         //       2 = down
            'right',        //       3 = right
            'no exit'       //       4 = no exit
          ][                //
            g[p] |= 1 << d, //       mark this direction as used
            d               //       d = actual index of the string to output
          ]                 //     r = result of prompt()
        )                   //
      ) < 's' ?             //     if r = 'ok':
        g(P)                //       do a recursive call at the new position
      :                     //     else:
        r < 't'             //       yield true if r = 'solved' or false if r = 'wall'
    )                       // end of some()
)([0, 0])                   // initial call to g at (0, 0)