जीवन एक भूलभुलैया है: चलने से पहले हमने गलत रास्ता अपना लिया

30

इनपुट:

वर्णों से युक्त भूलभुलैया:

  • -- (क्षैतिज दीवार);
  • | (वर्टिकल वॉल);
  • + (कनेक्शन);
  • (चलने की जगह);
  • I (प्रवेश);
  • U (बाहर जाएं)।

यानी एक इनपुट इस तरह दिख सकता है:

 +--+--+--+--+--+--+--+--+--+--+ 
I               |     |        | 
 +  +--+--+--+  +  +  +  +--+  + 
 |           |     |  |  |     | 
 +--+--+--+  +--+--+  +  +  +--+ 
 |           |     |     |     | 
 +  +--+--+  +  +--+--+  +--+  + 
 |     |     |     |     |     | 
 +--+  +  +--+--+  +--+--+  +  + 
 |     |        |        |  |  | 
 +  +--+--+--+  +--+--+  +  +  + 
 |     |     |     |        |  | 
 +--+  +  +--+--+  +--+--+--+--+ 
 |  |  |                 |     | 
 +  +  +--+--+--+  +--+  +  +  + 
 |     |        |  |  |  |  |  | 
 +--+--+  +  +--+  +  +  +--+  + 
 |        |     |     |  |     | 
 +  +--+--+--+  +  +  +  +  +--+ 
 |           |     |  |         U
 +--+--+--+--+--+--+--+--+--+--+

आउटपुट:

सबसे कुशल मार्ग आप चलना चाहिए भूलभुलैया के बाहर निकलने के (भूलभुलैया के माध्यम से), वर्ण ने संकेत दिया करने के लिए प्रवेश द्वार से प्राप्त करने के लिए यह दर्शाता है, बाएं, दाएं, ऊपर और नीचे (यानी >; <; ^; v)।

चुनौती नियम:

  • आप किसी भी उचित प्रारूप में इनपुट ले सकते हैं। स्ट्रिंग-एरे, सिंगल स्ट्रींग विथ न्यू-लाइन्स, 2 डी चार-एरे आदि सभी संभव इनपुट फॉर्मेट हैं।
  • आउटपुट में चार अलग-अलग वर्ण हो सकते हैं। Ie ><^v; →←↑↓; ⇒⇐⇑⇓; RLUD; 0123; ABCD; आदि।)।
  • यदि आप चाहें तो उत्पादन में रिक्त स्थान या नई-अनुगामी जोड़ सकते हैं; यह वैकल्पिक है।
  • चरण प्रति वर्ग में गिने जाते हैं ( +वर्गों के लिए चार- शब्द देखें ), और प्रति चरित्र नहीं।
  • भूलभुलैया 15x15 के माध्यम से आकार 5x5 हो सकता है, और हमेशा एक वर्ग होगा (इसलिए 5x10 mazes के लिए कोई परीक्षण मामले नहीं होंगे)।
  • आप मान सकते हैं कि हर भूलभुलैया में शुरू से अंत तक एक या एक से अधिक वैध रास्ते हैं, और आप हमेशा सबसे कम आउटपुट करते हैं (देखें परीक्षण के मामले 4 और 5)।
  • यदि एक ही लंबाई के साथ कई पथ हैं, तो आप चुन सकते हैं कि कौन सा आउटपुट करें (देखें परीक्षण केस 6)।
  • आप भूलभुलैया की सीमाओं के बाहर 'चल' नहीं सकते (परीक्षण के मामले 7 और 8 देखें)।

सामान्य नियम:

  • यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
    कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
  • मानक नियम आपके उत्तर के लिए लागू होते हैं , इसलिए आपको उचित पैरामीटर, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा कॉल।
  • डिफ़ॉल्ट लूपोल्स निषिद्ध हैं।
  • यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
  • इसके अलावा, यदि आवश्यक हो तो एक स्पष्टीकरण जोड़ें।

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

1. Input:
 +--+--+--+--+--+--+--+--+--+--+ 
I               |     |        | 
 +  +--+--+--+  +  +  +  +--+  + 
 |           |     |  |  |     | 
 +--+--+--+  +--+--+  +  +  +--+ 
 |           |     |     |     | 
 +  +--+--+  +  +--+--+  +--+  + 
 |     |     |     |     |     | 
 +--+  +  +--+--+  +--+--+  +  + 
 |     |        |        |  |  | 
 +  +--+--+--+  +--+--+  +  +  + 
 |     |     |     |        |  | 
 +--+  +  +--+--+  +--+--+--+--+ 
 |  |  |                 |     | 
 +  +  +--+--+--+  +--+  +  +  + 
 |     |        |  |  |  |  |  | 
 +--+--+  +  +--+  +  +  +--+  + 
 |        |     |     |  |     | 
 +  +--+--+--+  +  +  +  +  +--+ 
 |           |     |  |         U
 +--+--+--+--+--+--+--+--+--+--+ 

1. Output:
>v>>>vv<v>>v>v>>vvv>>>

2. Input:
 +--+--+--+--+--+ 
I   |        |  | 
 +  +--+--+  +  + 
 |        |  |  | 
 +  +--+  +  +  + 
 |  |  |     |  | 
 +  +  +--+  +  + 
 |        |     | 
 +--+  +  +--+--+ 
 |     |         U
 +--+--+--+--+--+ 

2. Output:
>vvv>>v>>>

3. Input:
 +--+--+--+--+--+ 
U      |        | 
 +  +  +--+--+  + 
 |  |     |     | 
 +--+--+  +  +--+ 
 |        |     | 
 +  +--+--+--+  + 
 |  |     |     | 
 +  +  +  +  +--+ 
 |     |         I
 +--+--+--+--+--+ 

3. Output:
<<<^<v<^^>>^<^<<

4. Input (test case with two valid paths):
 +--+--+--+--+--+ 
U      |        | 
 +  +  +--+--+  + 
 |  |           | 
 +--+--+  +  +--+ 
 |        |     | 
 +  +--+--+--+  + 
 |  |     |     | 
 +  +  +  +  +--+ 
 |     |         I
 +--+--+--+--+--+ 

4. Output:
<<^>^<^<<^<<     (<<<^<v<^^>>^<^<< is less efficient, and therefore not a valid output)

5. Input (test case with two valid paths):
                               I
+--+--+--+--+--+--+--+--+--+--+  +--+--+--+--+
|     |              |                    |  |
+  +  +  +--+--+--+  +  +--+--+  +--+--+  +  +
|  |     |        |     |        |     |     |
+--+--+--+  +--+  +  +--+--+--+--+  +--+--+--+
|     |  |  |  |     |     |           |     |
+  +  +  +  +  +--+  +  +  +  +--+--+  +--+  +
|  |        |        |  |     |        |     |
+  +--+--+--+  +--+--+  +  +--+  +--+--+  +--+
|  |     |     |        |  |     |     |     |
+  +--+  +  +--+  +--+--+  +--+--+  +  +--+  +
|  |     |        |     |           |        |
+  +  +--+--+--+--+  +  +--+--+--+  +--+  +--+
|     |     |        |        |  |     |     |
+--+--+--+  +  +--+--+  +--+  +  +--+  +--+  +
|              |     |     |        |  |  |  |
+  +--+--+--+--+  +  +  +--+--+--+  +  +  +  +
|     |  |     |  |  |        |        |  |  |
+--+  +  +  +  +  +  +--+--+  +  +  +--+  +  +
|     |     |  |  |  |           |  |     |  |
+--+  +--+--+  +  +  +  +--+--+--+  +  +  +  +
|     |        |  |  |     |        |  |  |  |
+  +--+  +--+--+  +  +--+--+  +  +--+  +  +  +
|        |     |  |     |     |  |     |  |  |
+--+--+--+  +  +  +--+  +  +--+--+  +--+  +  +
|  |        |        |     |        |     |  |
+  +  +--+--+--+--+  +--+--+  +--+--+  +--+  +
|  |              |              |     |     |
+  +  +  +--+--+--+--+--+--+--+--+  +--+  +--+
|     |                                |     |
+--+--+--+--+--+--+--+--+--+  +--+--+--+--+--+
                            U

5. Output:
v<<<v<vv<<v<v>>^>>^^>vvv>>>v>vv<vv<<v<v<^<^^^^<vvvvv<^<v<<v>v>>>>>>>v     (v<<<v<vv<<v<v>>^>>^^>vvv>>>v>vv<vv<<v<v<^<^^^^<vvvvv>v>>>^>>^>^^>vvv<v<v<<v is less efficient, and therefore not a valid output)

6. Input:
 +--+--+--+--+--+
I               |
 +  +  +  +  +  +
 |              |
 +  +  +  +  +  +
 |              |
 +  +  +  +  +  +
 |              |
 +  +  +  +  +  +
 |               U
 +--+--+--+--+--+

6. Output:
>>v>v>v>v> or >v>v>v>v>> or >>>>>vvvv> or etc. (all are equally efficient, so all 10-length outputs are valid)

7. Input:
 I  U
+  +  +--+--+--+
|  |        |  |
+  +--+--+  +  +
|     |     |  |
+--+  +  +--+  +
|        |  |  |
+  +--+  +  +  +
|     |        |
+--+  +--+--+  +
|     |        |
+--+--+--+--+--+

7. Output:
vv>v>^>^<<^

8. Input:
 +--+--+--+--+--+
 |     |        |
 +  +--+  +--+  +
I   |     |  |  |
 +  +  +--+  +  +
U   |     |  |  |
 +--+--+  +  +  +
 |     |     |  |
 +  +--+--+--+  +
 |               
 +--+--+--+--+--+

8. Output:
>v<

इस उपकरण का उपयोग करके उत्पन्न (और कुछ मामलों में थोड़ा संशोधित)।

code-golf  path-finding  maze 
— केविन क्रूज़सेन
स्रोत
10
मैंने तीसरे परीक्षण मामले के लिए एक छोटा समाधान ढूंढ लिया है! v<<<<<<^^^^^(हमेशा बॉक्स के बाहर सोचें)
— लियो
2
यदि कोई यह साबित कर सकता है कि उनके कोड में सबसे कम समय में समाधान मिलेगा, तो पर्याप्त समय और स्मृति दी जाए, क्या यह प्रतिस्पर्धा करता है? यहां तक ​​कि वास्तव में लंबे समय तक चलने वाले समय में (ब्रह्मांड फैशन का अंत)?
— 18
1
@JackBates यह एक मजाक है। वह शाब्दिक रूप से बाहर निकलने के लिए बॉक्स के चारों ओर चलता है:
— Yytsi
1
मुझे लगता है कि पहला परीक्षण मामला गलत है, यह होना चाहिए >v>>>vv<v>>v>v>>vvv>>>।
— धूम्रपान करता है
1
@KevinCruijssen उदाहरण के लिए, एक समाधान जो भूलभुलैया के अंदर खाली बक्से की मात्रा तक "v ^ <>" के प्रत्येक संयोजन का परीक्षण करता है। सही समाधान तो होगा, लेकिन गणना करने के लिए खगोलीय समय लगता है।
— यति

जवाबों:

7

रेटिना , 338 281 275 273 261 बाइट्स

¶U
¶&
+`·(\w.+)$
|$1
((.)+I.+¶.+¶(?<-2>.)+)·
$1v
+`((.)*)\+(.).*(¶(?<-2>.)*.)((\w)|·)·?
$1$4$.4$3$6
·v
-v
G`1
·U
&
{`\B·\d+.(\w+)
$1K$&
(\w+)·\d+.\B
$&$1r
(?<=\D\2.(\w+).+?¶.*\D(\d+)[·&])\B
$1v
)`\D(\d+).\B(?=.+¶.*\D\1·(\w+))
$&$2A
^.+\d·(\w+)
&$1A
M!`&\w+
I|&

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

टिप्पणियाँ

  • महत्वपूर्ण व्हाट्सएप के कारण, सभी स्थान (0x20 ) ·इस उत्तर और TIO लिंक दोनों में इंटरपंक्चर ( ) के साथ बदल दिए जाते हैं। यदि रिक्त स्थान बहाल हैं, तो कार्यक्रम ठीक काम करता है।
  • AvKrक्रमशः ऊपर, नीचे, बाएं और दाएं के लिए उपयोग करता है। उन्हें छोड़कर किसी भी पत्र के साथ प्रतिस्थापित किया जा सकता है I।
  • 15 × 15 परीक्षण मामले के लिए TIO पर लगभग 40s लेता है। धैर्य रखें।एक बार रास्ता निकल जाने के बाद सबसे छोटा रास्ता खोजने के लिए भाग को फिर से बनाया। पता चला कि बहुत समय लग रहा था।
  • 66 या अधिक कोशिकाओं के चौड़े होने वाले माज़ों पर पूरी तरह से विराम लगा सकता है लेकिन मनमानी ऊंचाई के माज़ों को संभाल सकता है। मनमानी चौड़ाई के लिए एक फिक्स +1 बाइट लेता है।

व्याख्या

कार्यक्रम में 3 चरण होते हैं:

  • एक निर्माण चरणभूलभुलैया को एक कॉम्पैक्ट प्रारूप में बदलने के लिए जो कि (नीचे विस्तृत) के साथ काम करना आसान है।
  • एक भराव चरण वास्तव में एक बाढ़ भराव एल्गोरिथ्म का उपयोग करके भूलभुलैया को हल करता है।
  • निकास पर सबसे छोटा रास्ता लौटाने के लिए एक वापसी चरण ।

स्वरूप

चूंकि मूल भूलभुलैया प्रारूप काफी अस्पष्ट है, इसलिए कार्यक्रम का पहला भाग इसे एक अलग प्रारूप में परिवर्तित करता है।

प्रकोष्ठों

मूल प्रारूप में, प्रत्येक सेल को 2 × 3 क्षेत्र के रूप में दर्शाया गया है:

+               <top wall>      <top wall>
<left wall>     <data/space>    <space>

चूंकि दाएं कॉलम में कोई जानकारी नहीं है, इसलिए प्रोग्राम किसी भी 2 × 2 क्षेत्र के रूप में कोशिकाओं की पहचान +शीर्ष-बाईं ओर करता है।

यह हमें 3 प्रकार की कोशिकाओं के साथ छोड़ देता है:

  • I सेल : कोशिकाएं जो भूलभुलैया के अंदर ठीक से होती हैं।
  • आर कोशिकाएं : कोशिकाएं जो भूलभुलैया के दाईं ओर होती हैं। ये प्रवेश द्वार या बाहर निकलने के लिए उपयोग किए जाने वाले पैडिंग द्वारा बनाए गए हैं। उदाहरण के लिए, Uटेस्ट केस 1 में निकास एक आर-सेल में है।
  • बी सेल्स : कोशिकाएं जो भूलभुलैया के नीचे होती हैं। आर-सेल की तरह, ये पैडिंग द्वारा बनाए गए हैं।

नए प्रारूप में, कोशिकाओं को एक चर-लंबाई स्ट्रिंग के रूप में दर्शाया जाता है:

<left wall> <column number> <top wall/exit marker> <path>

बाईं और ऊपरी दीवार को मूल प्रारूप से कॉपी किया गया है। स्तंभ संख्या सेल की क्षैतिज स्थिति पर आधारित है और इसका उपयोग संरेखण (सीधे एक दूसरे के नीचे / शीर्ष पर कोशिकाओं की पहचान) के लिए किया जाता है। पथ एक वर्णमाला स्ट्रिंग है जिसका उपयोग भरण चरण के दौरान उस सेल तक पहुंचने के लिए सबसे छोटे रास्ते को बचाने के लिए किया जाता है। पथ और निकास मार्कर को आगे समझाया जाएगा।

आधा कोशिकाओं

यद्यपि अधिकांश भूलभुलैया कोशिकाएं हैं, भूलभुलैया के क्षेत्र हैं जो कोशिकाएं नहीं हैं:

  • अर्ध-कोशिकाएं : यदि कोई सही गद्दी नहीं है, तो+ तो सही दीवार के साथ s कोशिकाएँ नहीं बनाती हैं क्योंकि वे अंतिम स्तंभ पर होती हैं।
  • L अर्ध-कोशिकाएँ : यदि बाईं ओर गद्दी है, तो कोशिकाएँ वहाँ नहीं बन सकती हैं क्योंकि उनमें से कोई +बाईं ओर नहीं है। उदाहरण के लिए, Iटेस्ट केस 1 में प्रवेश एल आधा सेल में है।

तकनीकी रूप से, भूलभुलैया के ऊपर टी आधा कोशिकाएं होती हैं (जब शीर्ष गद्दी होती है) और बी आधा कोशिकाएं (नीचे की दीवार के साथ जब नीचे तलछट नहीं होती) लेकिन नए प्रारूप में उनका प्रतिनिधित्व नहीं किया जाता है।

एक ही पंक्ति में पूर्ण कोशिकाओं के निर्माण के हिस्से के रूप में एक अर्ध-सेल की शीर्ष पंक्ति को हटा दिया जाएगा, इसलिए नए स्वरूप में आधी-कोशिकाओं का प्रतिनिधित्व किया जाता है

<wall/exit marker>? <path>

एक आर हाफ-सेल सिर्फ है |। एक एल हाफ-सेल्स के पास Iपथ के रूप में, बस निकास मार्कर और एक खाली पथ है, या बस एक खाली दीवार है।

प्रवेश और निकास

यदि प्रवेश भूलभुलैया के बाएं, दाएं या निचले भाग में है, तो प्रवेश मार्ग Iको स्वाभाविक रूप से पथ के रूप में (आधा) सेल में शामिल किया जाएगा, जिसे अंतिम पथ वापस करते समय हटाया जा सकता है।

यदि प्रवेश भूलभुलैया से ऊपर है, तो निर्माण चरण के दौरान पहला (नीचे) कदम उठाया जाता है क्योंकि निर्माण के दौरान टी आधा कोशिकाएं हटा दी जाती हैं। यह एक पूर्ण सेल में एक व्यावहारिक पथ रखता है। शीर्ष दीवार बाद में बंद है।

यदि निकास भूलभुलैया के बाएं, दाएं या नीचे है, तो Uस्वाभाविक रूप से एक आधा (आधा) सेल में शामिल किया जाएगा। एक मार्ग के रूप में गलत होने से बचने के लिए, गैर-अल्फ़ान्यूम निकास मार्कर &का उपयोग किया जाता है U। निकास मार्कर एक सेल या अर्ध-सेल में एम्बेडेड है (जैसा कि ऊपर निर्दिष्ट किया गया है)।

यदि निकास भूलभुलैया के ऊपर है, तो यह एकमात्र छेद होगा जो कोशिकाओं की शीर्ष पंक्ति के ऊपर जा सकता है (प्रवेश के लिए एक के बाद से, यदि मौजूद है, तो पहले से ही बंद हो जाएगा)। उस छेद तक पहुंचने वाला कोई भी रास्ता ऊपर की ओर कदम उठाकर भूलभुलैया से बाहर निकल सकता है।

अन्त में, प्रवेशद्वार या निकास वाली किसी भी B सेल को B सेल के साथ चलने से भूलभुलैया को "हल" करने से रोकने के लिए अपनी बाईं दीवार को बंद करना होगा। आर सेल्स या एल हाफ-सेल्स में प्रवेश और निकास को आगे की प्रक्रिया की जरूरत नहीं है क्योंकि बाढ़ भराव एल्गोरिथ्म उनके लिए ऊर्ध्वाधर आंदोलनों की अनुमति नहीं देता है।

उदाहरण

एक उदाहरण के रूप में, पहला परीक्षण मामला

·+--+--+--+--+--+--+--+--+--+--+·
I···············|·····|········|·
·+··+--+--+--+··+··+··+··+--+··+·
·|···········|·····|··|··|·····|·
·+--+--+--+··+--+--+··+··+··+--+·
·|···········|·····|·····|·····|·
·+··+--+--+··+··+--+--+··+--+··+·
·|·····|·····|·····|·····|·····|·
·+--+··+··+--+--+··+--+--+··+··+·
·|·····|········|········|··|··|·
·+··+--+--+--+··+--+--+··+··+··+·
·|·····|·····|·····|········|··|·
·+--+··+··+--+--+··+--+--+--+--+·
·|··|··|·················|·····|·
·+··+··+--+--+--+··+--+··+··+··+·
·|·····|········|··|··|··|··|··|·
·+--+--+··+··+--+··+··+··+--+··+·
·|········|·····|·····|··|·····|·
·+··+--+--+--+··+··+··+··+··+--+·
·|···········|·····|··|·········U
·+--+--+--+--+--+--+--+--+--+--+·

है

I·3-·6-·9-·12-·15-|18-·21-|24-·27-·30-|33·
·|3··6-·9-·12-|15··18·|21·|24·|27-·30·|33·
·|3-·6-·9-·12·|15-·18-|21··24·|27··30-|33·
·|3··6-|9-·12·|15··18-|21-·24·|27-·30·|33·
·|3-·6·|9··12-·15-|18··21-·24-|27·|30·|33·
·|3··6-|9-·12-|15··18-|21-·24··27·|30·|33·
·|3-|6·|9··12-·15-·18··21-·24-|27-·30-|33·
·|3··6·|9-·12-·15-|18·|21-|24·|27·|30·|33·
·|3-·6-·9·|12··15-|18··21·|24·|27-·30·|33·
·|3··6-·9-·12-|15··18·|21·|24··27··30-·33&

नए प्रारूप में। आप यहाँ अन्य मज़ारों को परिवर्तित कर सकते हैं ।

निर्माण चरण

निर्माण चरण कार्यक्रम की पहली 13 पंक्तियों को बनाता है।

¶U
¶&

मार्कर से बाहर निकलने के लिए एल हाफ-सेल में बाहर निकलता है

+`·(\w.+)$
|$1

प्रवेश द्वार के बाईं ओर की दीवारों को जोड़ता है और बी सेल्स में बाहर निकलता है

((.)+I.+¶.+¶(?<-2>.)+)·
$1v

पहला कदम अगर प्रवेश चक्रव्यूह से ऊपर है

+`((.)*)\+(.).*(¶(?<-2>.)*.)((\w)|·)·?
$1$4$.4$3$6

वास्तविक रूपांतरण करता है

·v
-v

शीर्ष-प्रवेश छेद को बंद करता है

G`1

केवल एक के साथ लाइनों रखता है 1। चूँकि mazes कम से कम 5 कोशिकाएँ चौड़ी होती हैं और स्तंभ संख्याएँ 3 की वृद्धि पर होती हैं, इसलिए नए-स्वरूप वाली कोशिकाओं की एक पंक्ति में 10 और 19 के बीच एक कॉलम संख्या होनी चाहिए।

·U
&

मार्कर से बाहर निकलने के लिए आर सेल या बी सेल में बाहर निकलता है

चरण भरें

भरण चरण कार्यक्रम की अगली 8 पंक्तियों को बनाता है। यह प्रवेश द्वार से वहां तक ​​पहुंचने के लिए कम से कम पथ के साथ सभी कोशिकाओं को भरने के लिए बाढ़ भराव एल्गोरिथ्म का उपयोग करता है।

{`

पूरे भूलभुलैया को भरने के लिए एक लूप पर पूरे भराव चरण को डालता है।

\B·\d+.(\w+)
$1K$&

प्रत्येक कोशिका बाएं चलने में सक्षम होती है। यदि सेल बाईं ओर ले जाने में सक्षम है

  1. यह एक गैर-खाली रास्ता है
  2. इसमें एक खाली दीवार है; तथा
  3. सेल या एल आधा सेल इसके बाईं ओर एक खाली रास्ता है
(\w+)·\d+.\B
$&$1r

फिर, प्रत्येक सेल सही स्थानांतरित करने में सक्षम होता है। यदि सही हो तो एक सेल सही तरीके से चलने में सक्षम है

  1. यह एक गैर-खाली रास्ता है
  2. सेल के दाईं ओर एक खाली दीवार है; तथा
  3. इसके दाईं ओर सेल के पास एक खाली रास्ता है
(?<=\D\2.(\w+).+?¶.*\D(\d+)[·&])\B
$1v

फिर, प्रत्येक कोशिका नीचे जाने में सक्षम होती है। एक सेल अगर नीचे ले जाने में सक्षम है

  1. यह एक गैर-खाली रास्ता है
  2. इसके दाईं ओर कम से कम एक सेल या आधा सेल है (यानी यह R सेल नहीं है)
  3. इसके नीचे की सेल (यानी एक ही कॉलम नंबर वाली अगली लाइन पर सेल) एक खाली शीर्ष दीवार है या बाहर निकलने वाला मार्कर है; तथा
  4. इसके नीचे के सेल में एक खाली रास्ता है

ध्यान दें कि एल हाफ़-सेल नीचे नहीं जा सकते क्योंकि उनके पास कॉलम नंबर नहीं हैं।

\D(\d+).\B(?=.+¶.*\D\1·(\w+))
$&$2A

फिर, प्रत्येक कोशिका ऊपर जाने में सक्षम होती है। एक सेल अगर ऊपर ले जाने में सक्षम है

  1. यह एक गैर-खाली रास्ता है
  2. यह एक खाली शीर्ष दीवार है
  3. इसके ऊपर के सेल में इसके दाईं ओर कम से कम एक सेल या आधा सेल है; तथा
  4. इसके ऊपर के सेल में एक खाली रास्ता है

वापसी का चरण

वापसी चरण कार्यक्रम की अंतिम 5 पंक्तियों को बनाता है। यह चरण बाहर निकलने की सेल में भरे हुए मार्ग को खोजता है और लौटाता है।

निकास पर पथ का पैटर्न इस बात पर निर्भर करता है कि निकास कहाँ है:

  1. यदि निकास एल हाफ सेल में है, तो वह आधा सेल होगा & <path>
  2. यदि निकास R सेल या B सेल में है, तो वह सेल होगा <left wall> <column number> & <path>
  3. यदि निकास टी हाफ-सेल में है, तो जैसा कि ऊपर उल्लेख किया गया है, आई सेल बाहर निकलने के लिए अग्रणी है <left wall> <column number> · <path>और शीर्ष पंक्ति पर होगा ।
^.+\d·(\w+)
&$1A

शीर्ष पंक्ति पर एक रिक्त शीर्ष दीवार और एक गैर-रिक्त पथ के साथ एक सेल ढूँढता है। यह अंतिम चरण और निकास मार्कर को जोड़कर पिछले मामले की देखभाल करता है।

M!`&\w+

एक बाहर निकलने के मार्कर के बाद एक गैर-रिक्त पथ से मेल खाता और वापस करता है।

I|&

निकास मार्कर और Iपथ के उपसर्ग को निकालता है ।

— TwiNight
स्रोत
क्यों AvKr? क्या उनका कोई अर्थ है / क्या वे अपनी मूल भाषा में अप, डाउन, लेफ्ट और राइट के लिए संक्षिप्त हैं, या कोई और कारण है कि आपने उन विशिष्ट वर्णों को क्यों चुना है?
— केविन क्रूज़सेन
@KevinCruijssen केवल इसलिए कि मुझे अल्फ़ान्यूमेरिक वर्णों का उपयोग करना चाहिए और AvKrअल्फ़ान्यूम में तीरों के लिए निकटतम चीज़ है।
— ट्विनट
12

पर्ल 6 , 259 295 बाइट्स

{my \a=S:g/(.)$0+/{$0 x($/.comb+.5)*2/3}/;sub f (\c,\v,*@p) {with (c ne any v)&&a.lines».comb[+c[0];+c[1]] ->$_ {for (/\s/??10011221!!/I/??a~~/^\N*I|I\N*$/??2101!!1012!!'').comb X-1 {f [c Z+$^a,$^b],(|v,c),@p,chr 8592+$++}
take @p if /U/}}
[~] (gather f a~~/(\N+\n)*(.)*I/,[]).min(+*)[1,3...*]}

यह काम किस प्रकार करता है

  1. my \a = S:g/ (.) $0+ /{ $0 x ($/.chars + .5) * 2/3 }/;

यह भूलभुलैया को निचोड़ता है ताकि प्रत्येक कोशिका के अंदर 2x1 अंतरिक्ष वर्णों के बजाय 1x1 हो:

 + - + - + - + - + - + + - + - + - + - + - + - + 
मैं | | | मैं | | |
 + + - + - + + + + + - + - + + + + 
 | | | | | | | |
 + + - + + + + + + + + + + + + 
 | | | | | -> | | | | |
 + + + - + + + + + + + + + + + + 
 | | | | | |
 + - + + + - + - + + - + + + - + - + 
 | | यू | | यू
 + - + - + - + - + - + + - + - + - + - + - + - +

  1. sub f (\c,\v,*@p) {
    with (c ne any v) &&                   # If the coordinate wasn't visited yet
         lines».comb[+c[0];+c[1]] -> $_ {  # and a character exists there...
        for (                          # For each vector...
             /\s/ ?? 10011221 !!       #  from a cell: (0,-1), (-1,0), (0,1), (1,0)
             /I/  ?? a~~/^\N*I|I\N*$/
                      ?? 2101          #  from a top/bottom entrance: (1,0), (-1,0)
                      !! 1012          #  from a left/right entrance: (0,-1), (0,1)
                  !! ''                #  otherwise: none
            ).comb X-1 {
            f                       #   Recurse with arguments:
                [c Z+ $^a, $^b],    #     c plus the vector
                (|v, c),            #     v with c appended
                @p, chr 8592 + $++  #     p with the correct Unicode arrow appended
        }
        take @p if /U/
    }
}

यह पुनरावर्ती पथ-खोज कार्य है। यह तीन पैरामीटर लेता है: वर्तमान समन्वय c=(y,x), पहले से ही देखे गए निर्देशांक की सूची v, और pअब तक लिए गए पथ (तीर वर्णों की सूची के रूप में)।

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

  1. [~] (gather f a ~~ /(\N+\n)*(.)*I/, []).min(+*)[1,3...*]

पुनरावर्ती फ़ंक्शन को शुरू में पत्र के समन्वय के साथ कहा जाता है I, जो एक रेगेक्स का उपयोग करके पाया जाता है।

gatherकीवर्ड सभी मूल्यों जिस पर जमा करता takeसमारोह के अंदर बुलाया गया था, यानी सभी वैध गैर चक्रीय भूलभुलैया के माध्यम से पथ।

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

— SMLS
स्रोत
मेरी चुनौती को पूरा करने वाले पहले महान काम पर सबसे पहले! :) स्मार्ट आप वास्तविक आंदोलन / गिनती को कम करने के लिए दो रिक्त स्थान को एक में कैसे बदल दिया है। मुझ से +1। वैसे भी, कुछ टिप्पणियों के बाद दो नए परीक्षण मामले जोड़े गए थे। क्या आप अपने समाधान के साथ इन कार्यों को सत्यापित कर सकते हैं? (इसके अलावा, क्या पर्ल 6 में एक टीआईओ या अन्य ऑनलाइन कंपाइलर हैं, जिनसे आप एक लिंक जोड़ सकते हैं?)
— केविन क्रूज़सेन
@ केविनक्रूजसेन: यह नए परीक्षण-मामलों में भूलभुलैया के आसपास चला गया। :( मैंने अभी कोड तय किया है। tio.run पर्ल 6 का समर्थन करता है, लेकिन किसी कारण से, यह वहां काम नहीं करता है ... शायद इसका बहुत पुराना पर्ल 6 संस्करण है?
— एसएमएस करता है।
महान काम कोड फिक्सिंग। पहले से ही अपना उत्तर पोस्ट करने के बाद भूलभुलैया से गुजरने के नियम को निर्दिष्ट करने के लिए क्षमा करें, लेकिन इसे इतनी तेजी से ठीक करने के लिए chapeau। और TIO संस्करण के बारे में मुझे कुछ पता नहीं है। वास्तव में मेरी विशेषज्ञता नहीं ..
— केविन क्रूज़सेन
चूंकि आप चार महीने पहले मेरी चुनौती का जवाब देने वाले पहले थे, इसलिए मैंने आपको इनाम दिया। :) और स्वीकार थोड़ा कम रेटिना जवाब के लिए है।
— केविन क्रूज़सेन
5

पायथन 2: 302 बाइट्स

from re import*
r=lambda x:[''.join(_)for _ in zip(*x)][::-1]
z=',l)for l in s]'
def f(s,b=1,o=0,n=0):
 exec("s=[sub('(..).(?!$)',r'\\1'%s;"%z+"s=r([sub(' I ','+I+'%s);"%z*4)*b+"t=[sub('I  ','@@I'"+z
 if'I U'in`s`or n>3:return`o%4`+n/4*`s`
 return min(`o%4`+f(t,0,o,4*(t==s)),f(r(s),0,o+1,n+1),key=len)

एक ही लंबाई के साथ तार के एक सरणी के रूप में इनपुट लेता है। 0दाएं के लिए प्रिंट , 1नीचे के लिए, 2बाएं के लिए, और 3ऊपर के लिए।

व्याख्या

मैंने अन्य उत्तरों की तुलना में एक अलग दृष्टिकोण लिया। सामान्य विचार: सीधे आगे बढ़ने और बोर्ड को 90 डिग्री घुमाने के बीच सबसे छोटा रास्ता खोजने के लिए पुनरावर्ती खोज करें।

from re import*
r=lambda x:[''.join(_)for _ in zip(*x)][::-1] #Rotates the board counterclockwise
z=',l)for l in s]'    #Suffix for hacky exec golfing
def f(s,b=1,o=0,n=0): #b is 1 on initial call, 0 on every recursion
                      #o is orientation
                      #n is number of rotations
 exec("s=[sub('(..).(?!$)',r'\\1'%s;"%z  #Squeeze the maze
      +"s=r([sub(' I ','+I+'%s);"%z*4)   #Add walls around the I to keep it in the maze
      *b                                 #Only if b is 1
      +"t=[sub('I  ','@@I'"+z            #Attempt to move right

 if'I U'in`s`or n>3:return`o%4`+n/4*`s`  #If the I is next to the U, return the orientation
                                         #If there were 4 rotations, return a long string
 return min(                             #Return the path with the shortest length:
            `o%4`+f(t,0,o,4*(t==s)),       #Moving forward if possible
            f(r(s),0,o+1,n+1),             #Rotating the board
        key=len)

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

— deltaepsilon3
स्रोत
3
Welcome to PPCG! This is a great first answer, and I'm impressed you decided to do a pretty tough challenge as your first. Also smart how you've put walls around the I to prevent the path from going outside the maze. Enjoy your stay, and +1 from me. :)
— Kevin Cruijssen
2

JavaScript (ES6), 356 bytes

a=>(a=a.map(s=>s.filter((_,i)=>!i|i%3)),g=([x,y])=>a[y]&&a[y][x],o=[],c=([x,y],m="",v=[])=>[[0,1],[1,0],[0,-1],[-1,0]].map(([j,k],i)=>(p=[x+j,y+k],!m&(!y|y>a[l="length"]-2)==i%2|v.includes(""+p)||(g(p)<"!"?c(p,m+"v>^<"[i],[...v,""+p]):g(p)=="U"?o.push(m.replace(/(.)\1/g,"$1")):0))),a.map((h,i)=>h.map((k,j)=>k=="I"&&c([j,i]))),o.sort((a,b)=>a[l]-b[l])[0])

Takes input as a 2D array of characters. Each line must be left-padded by one space and have no trailing space, no matter where the start/end points are.

Uses smls's idea of squishing the maze to make each cell 1x1 and removing repeated arrows from the output.

Ungolfed and Explained

a=>(
    a=a.map(s=>s.filter((_,i)=>!i|i%3)),    // squish the maze to 1x1 cells
    g=([x,y])=>a[y]&&a[y][x],               // helper func to get maze value
    o=[],                                   // resulting movesets
    c=([x,y], m="", v=[]) =>                // recursive func to search
                                            // takes current point, moves, and visited spots
        [[0,1],[1,0],[0,-1],[-1,0]].map(([j,k],i)=>(// for each direction
            p=[x+j,y+k],
            !m & (!y | y>a[l="length"]-2) == i%2 |  // if first move, prevent moving out of maze
                v.includes(""+p) || (               // also prevent if already visited
                    g(p)<"!" ?                      // is this a space?
                        c(p, m+"v>^<"[i], [...v,""+p]) // check this spot recursively
                    : g(p)=="U" ?                   // if this the end?
                        o.push(                     // add moves to moveset
                            m.replace(/(.)\1/g,"$1")) // with double arrows removed
                    : 0
                )
        )),

    a.map((h,i)=>h.map((k,j)=>      // find the starting "I" and
        k=="I" && c([j,i])          // begin recursion at that point
    )),

    o.sort((a,b)=>a[l]-b[l])[0]     // get shortest path
)

Test Snippet

Show code snippet

— Justin Mariner
स्रोत
1

Retina, 416 bytes

T` `+`^.*| ?¶.|.*$
I
#
{+` (\w)
d$1
+`(\w) 
$1a
+`(¶(.)*) (.*¶(?<-2>.)*(?(2)(?!))\w)
$1s$3
}+m`(^(.)*\w.*¶(?<-2>.)*(?(2)(?!))) 
$1w
^
w¶
w((.|¶)*(¶(.)*#.*¶(?<-4>.)*(?(4)(?!))(s)|#(d)|(a)#))
$4$5$6¶$1
{`^(.*d)(¶(.|¶)*)#(\w)
$1$4$2 #
^(.*a)(¶(.|¶)*)(\w)#
$1$4$2# 
^(.*s)(¶(.|¶)*¶(.)*)#(.*¶(?<-4>.)*(?(4)(?!)))(\w)
$1$6$2 $5#
}`^(.*w)(¶(.|¶)*¶(.)*)(\w)(.*¶(?<-4>.)*(?(4)(?!)))#
$1$5$2#$6 
s`U.*

(a|d)\1\1?
$1
ss
s
ww
w

Try it online! Had I seen this question when it was originally posted, this is probably the answer I would have given, so I'm posting it anyway, even though there's a much better answer in Retina. Explanation:

T` `+`^.*| ?¶.|.*$

Fill in the border. This avoids walking around the outside of the maze (e.g. for test case 7).

I
#

Place a non-alphabetic marker at the entrance.

{+` (\w)
d$1
+`(\w) 
$1a
+`(¶(.)*) (.*¶(?<-2>.)*(?(2)(?!))\w)
$1s$3
}+m`(^(.)*\w.*¶(?<-2>.)*(?(2)(?!))) 
$1w

Flood fill from the exit to the entrance. At each step, use a letter to indicate the best direction to go (wasd - this might be familiar to gamers; I had also considered hjkl but I found it too confusing). Additionally, prefer to repeat the same direction; this avoids going left/right in between two vertically adjacent cells.

^
w¶

Assume the first step is down.

w((.|¶)*(¶(.)*#.*¶(?<-4>.)*(?(4)(?!))(s)|#(d)|(a)#))
$4$5$6¶$1

But if there's a letter above, left or right of the entrance, change that to the first step.

{`^(.*d)(¶(.|¶)*)#(\w)
$1$4$2 #
^(.*a)(¶(.|¶)*)(\w)#
$1$4$2# 
^(.*s)(¶(.|¶)*¶(.)*)#(.*¶(?<-4>.)*(?(4)(?!)))(\w)
$1$6$2 $5#
}`^(.*w)(¶(.|¶)*¶(.)*)(\w)(.*¶(?<-4>.)*(?(4)(?!)))#
$1$5$2#$6

Move the marker in the direction of the last move, reading the direction of the next move from the square that the marker is moving to, and add that to the list of directions. This repeats until the U is reached.

s`U.*

Delete everything after the directions as it's not needed any more.

(a|d)\1\1?
$1
ss
s
ww
w

The original grid is on a 3×2 layout. While moving vertically if we zig-zag horizontally the flood fill will optimise the movement and only move 3n-1 characters horizontally, so when dividing by three, we need to round up. Vertically we just divide by 2.

I also investigated a true square grid solution i.e where the character matrix is itself square rather than being a 3×2 layout with an optional border. While probably nonconforming to the question, the ability to transpose reduced the byte count to 350: Try it online!

— Neil
स्रोत
Nice answer, +1! I do see in your TIO link you've added two - around both the entrance and exit characters. Since the challenge is mainly about going through the maze I guess it's fine, but I'm curious: what were the issues when you hadn't placed those walls above/below the I and U? Also, could you verify this works for test case 7 with the I and U at the top instead of sides? TIO exceeds the 60 second limit, so I'm unable to test it myself. Although reading your explanation of first trying to go down by default, I assume it should work fine.
— Kevin Cruijssen
@KevinCruijssen The "secondary" answer works for test case 7 but requires extra characters: Try it online! continued...
— Neil
@KevinCruijssen The "main" answer had a bug whereby it couldn't cope with the exit on the top line at all. It also has a similar bug to the "secondary" answer whereby it prefers to walk around the outside of the maze if it can. (Also, I didn't get anywhere near the 60 second limit.)
— Neil
Actually, I could fix both answers by filling in the border. I'll do that later when I have time.
— Neil
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.