हेक्सागोनल भूलभुलैया समय!

Question

एक और भूलभुलैया चुनौती के लिए समय है, लेकिन जैसा कि आप इसे जानते हैं।

इस चुनौती के नियम ज्यादातर भूलभुलैया की चुनौतियों से थोड़े अलग हैं। टाइल प्रकारों को इस प्रकार परिभाषित किया गया है:

• S: आपके द्वारा शुरू किए गए भूलभुलैया पर स्थान
• E: जिस स्थान पर आप जाने की कोशिश कर रहे हैं
• 0: दीवार जिसे आप पार नहीं कर सकते
• +: मंजिल जिसे आप पार कर सकते हैं

आप छह दिशाओं में से एक में यात्रा कर सकते हैं: ऊपर-बाएं, ऊपर-दाएं, बाएं, दाएं, नीचे-बाएं, या नीचे-दाएं।

\ /
-S-
/ \

भूलभुलैया नहीं लपेटता है। लक्ष्य से प्राप्त करने के लिए सबसे छोटा रास्ता स्ट्रिंग को खोजने के Sलिए है E।

इनपुट:

इनपुट अंतरिक्ष से अलग की गई रेखाएं हैं जो दिखाए गए माज़ की तरह हैं। कोई अनुगामी स्थान एक पंक्ति का अनुसरण नहीं करेगा।

आउटपुट:

एक स्ट्रिंग की R, Lहै, और Fजहां

• R आपको सही (घड़ी की दिशा में) 60 डिग्री घुमाता है
• L आपको छोड़ दिया घूमता है (घड़ी की दिशा में) 60 डिग्री
• F आपको जिस दिशा में इंगित कर रहे हैं, वहां आपको एक स्थान पर ले जाता है

आप इशारा करने लगते हैं left-up

सबसे छोटा रास्ता उत्पादित स्ट्रिंग की लंबाई से गिना जाता है, न कि आने वाले पदों की संख्या। आपके प्रोग्राम को समाधान के रूप में सबसे छोटा रास्ता प्रिंट करना होगा।

यदि भूलभुलैया अनचाहा है, तो आपको आउटपुट करना चाहिए Invalid maze!।

( >>>आउटपुट है)

     0 0 0 0
    0 + 0 + 0
   0 0 0 + + 0
  0 + 0 + 0 + 0
 0 0 + + 0 0 + 0
0 0 + 0 + 0 0 + 0
 E 0 + 0 0 + + 0 
  + + 0 + 0 + 0
   0 0 0 0 0 +
    + 0 + + +
     0 S 0 0

>>>RFRFFLFLFRFFLFFFLFLFFRFLFLFRFRFRF

  + 0 0 0 0 0 0
 0 0 0 0 0 + + 0
0 0 E 0 + 0 0 + 0
 0 0 0 0 0 0 0 +
  0 + 0 0 + + +
   0 0 + + 0 0
    S + 0 0 0

>>>Invalid maze!

0 E S

>>>LF


 E + 0
0 + + +
 0 0 S
  + +

>>>FFLF

  E
 0 +
0 + +
 0 +
  S

>>>RFFLFF

 0 E + 0 0
0 + 0 0 + +
 + 0 + + + 0
  + 0 + 0 + 0
   + + + 0 S

>>>FFLFLFFRFRFFRFF

 E 0 + + 0
0 + 0 + + 0
 + + + 0 + 0
  + 0 0 0 0 0
   + + + + 0
    + 0 S 0

>>>FLFFRFFRFLF

(ध्यान दें कि कुछ मेज़ों के अन्य समाधान हैं जो समान लंबाई के हैं, लेकिन यहां सूचीबद्ध नहीं हैं)

Comments

एक Hexagony समाधान के लिए उम्मीद ...

— bkul

मैं हेक्सागोनी समाधान के लिए 500 अंक का इनाम दूंगा।

— lirtosiast

@ lirtosiast2 साल बाद, मुझे लगता है कि हेक्सागोनी इस समस्या के लिए एक खिंचाव हो सकता है;)

— जे Atkin

चलो कुछ और वर्षों तक प्रतीक्षा करें।

— user202729

क्या कोई अनुगामी न्यूलाइन हो सकती है?

— user202729

Answer 1

पायथन 2, 291 बाइट्स

def f(M):
 Y=map(max,M).index("S");X=M[Y].find("S");V={()};Q=[(0,0,0,1,"")]
 while Q:
    try:x,y,u,v,p=s=Q.pop(0);c=(Y>=y<=X-2*x)*ord(M[Y-y][X-2*x-y])
    except:c=0
    if c==69:return p
    if{c%2*s[:4]}-V:V|={s[:4]};Q+=(x+u,y+v,u,v,p+"F"),(x,y,-v,u+v,p+"R"),(x,y,u+v,-u,p+"L")
 return"Invalid maze!"

एक फ़ंक्शन, fभूलभुलैया को पंक्तियों की सूची के रूप में ले रहा है, और यदि कोई मौजूद है, तो एक समाधान लौटाता है।

व्याख्या

से सबसे छोटा रास्ता खोजने के लिए स्थिति / दिशा जोड़े के ग्राफ पर एक चौड़ाई-पहली खोज करता Sहै E।

क्या दिलचस्प है एक हेक्सागोनल ग्रिड पर पदों और दिशाओं का प्रतिनिधित्व करने के लिए एक कॉम्पैक्ट तरीका, जो सरल "कदम" (यानी, एक निश्चित दिशा में आगे बढ़) और रोटेशन को स्वीकार करता है। यह "असली" षट्भुज ग्रिड पर निर्देशांक का प्रतिनिधित्व करने के लिए यहां जटिल संख्याओं का उपयोग करने के लिए आकर्षक है, लेकिन कई कारणों से यह बहुत अच्छा विचार नहीं है, जिनमें से सबसे गंभीर तथ्य यह है कि हमें √3 में प्लग करने की आवश्यकता है कहीं न कहीं यह काम करने के लिए (पाप 60 ° = 23/2), जो, फ़्लोटिंग-पॉइंट नंबरों का उपयोग करते समय, एक ऐसा रास्ता नहीं है जब हमें पूर्ण परिशुद्धता की आवश्यकता होती है (उदाहरण के लिए, उन राज्यों का ट्रैक रखने के लिए जिन्हें हमने पहले ही देखा है;) आप अपने जावास्क्रिप्ट कंसोल और टाइपिंग को फायरिंग की कोशिश कर सकते हैं और Math.sqrt(3)*Math.sqrt(3) == 3अपने लिए देख सकते हैं।

लेकिन, हम एक छोटी सी चाल का उपयोग कर सकते हैं! जटिल संख्याओं का उपयोग करने के बजाय, आइए एक समान नस में हेक्सागोनल संख्याओं को परिभाषित करें , वास्तविक संख्याओं की एक जोड़ी के रूप में a + bh , जहां h जटिल संख्याओं से निपटने पर काल्पनिक i के समान भूमिका निभाता है । बस जटिल संख्याओं के साथ, हम विमान पर एक बिंदु के साथ जोड़ी ( ए , बी ) को जोड़ सकते हैं, जहां वास्तविक अक्ष सही इंगित करता है, काल्पनिक अक्ष 60 ° ऊपर होता है, और वे दोनों वास्तविक और जब इकाई को नियमित रूप से षट्भुज को काटते हैं। काल्पनिक भागों के बराबर 1, क्रमशः। इस समन्वय प्रणाली को भूलभुलैया की कोशिकाओं में मैप करना तुच्छ है।

I के विपरीत , निरंतर h को h ² = h - 1 के संबंध से परिभाषित किया गया है ( h के लिए हल करने से कुछ अंतर्दृष्टि प्रकट हो सकती है।) और यह बात है! हेक्सागोनल संख्याओं को जोड़ा जा सकता है और गुणा किया जा सकता है, उपरोक्त संबंध का उपयोग करते हुए, जटिल संख्याओं की तरह: ( a + bh ) + ( c + dh ) = ( a + c ) + ( b + d ) h ,
और ( a + bh ) · ( c + dh ) = ( एसी - बीडी)) + ( विज्ञापन + बीसी + बीडी ) एच । इन परिचालनों की ज्यामितीय व्याख्या उनके जटिल समकक्षों के समान है: इसके अलावा वेक्टर जोड़ है, और गुणन स्केलिंग और रोटेशन है। विशेष रूप से, एक षट्भुज संख्या 60 ° प्रति-दक्षिणावर्त घुमाने के लिए, हम इसे h से गुणा करते हैं :
( a + bh ) · h = - b + ( a + b ) h , और उसी संख्या को 60 ° दक्षिणावर्त घुमाने के लिए, हम विभाजित करते हैं। h द्वारा :
( a + bh ) / h = ( a +bh ) · (1 - h ) = (a + b) - आह । उदाहरण के लिए, हम इकाई हेक्सागोनल संख्या को सही इंगित करते हुए ले सकते हैं, 1 = (1, 0), एक पूर्ण चक्र, काउंटर-क्लॉकवाइज, इसे छह बार एच द्वारा गुणा करके :
(1, 0) · एच = (0, 1) ); (0, 1) · एच = (-1, 1); (-1, 1) · एच = (-1, 0); (-1, 0) · एच = (0, -1); (0, -1) · एच = (1, -1);
(1, -1) · एच = (1, 0)।

कार्यक्रम इस फैशन में हेक्सागोनल संख्याओं का उपयोग भूलभुलैया में वर्तमान स्थिति और वर्तमान दिशा का प्रतिनिधित्व करने के लिए, निर्दिष्ट दिशा में आगे बढ़ने के लिए, और बाईं ओर और दाईं ओर दिशा को घुमाने के लिए करता है।

Answer 2

हेक्सागोनी , 2437 बाइट्स

लंबे समय से प्रतीक्षित कार्यक्रम यहां है:

(.=$>({{{({}}{\>6'%={}{?4=$/./\_><./,{}}{<$<\?{&P'_("'"#<".>........_..\></</(\.|/<>}{0/'$.}_.....><>)<.$)).><$./$\))'"<$_.)><.>%'2{/_.>(/)|_>}{{}./..>#/|}.'/$|\})'%.<>{=\$_.\<$))<>(|\4?<.{.%.|/</{=....$/<>/...'..._.>'"'_/<}....({{>%'))}/.><.$./{}{\>$\|$(<><$?..\\<.}_>=<._..\(/.//..\}\.)))))<...2/|$\){}/{..><>).../_$..$_>{0#{{((((/|#.}><..>.<_.\(//$>))<(/.\.\})'"#4?#\_=_-..=.>(<...(..>(/\")<((.\=}}}\>{}{?<,|{>/...(...>($>{)<.>{=P&/(>//(_.)\}=#=\4#|)__.>"'()'\.'..".(\&P'&</'&\$_></}{)<\<0|\<.}.\"\.(.(.(/(\..{.>}=P/|><.(...(..."/<.{"_{{=..)..>})<|><$}}/\}}&P<\(/._...>\$'/.>}/{}}{)..|/(\'.<(\''"")$/{{}})<..'...}}>3#./\$<}|.}|..$.><${{}/>.}}{{<>(""''/..>){<}\?=}{\._=/$/=_>)\{_\._..>)</{\=._.....>(($>}}<.>5#.\/}>)<>-/(.....{\<>}}{{/)\$>=}}}))<...=...(\?{{{?<\<._...}.><..\}}/..>'P&//(\......(..\})"'/./&P'&P{}}&P'<{}\{{{({{{(.\&P=<.><$"&1}(./'"?&'&"\.|>}{?&"?&'P&/|{/&P''</(\..>P&{/&/}{}&'&},/"&P'&?<.|\}{&?"&P'&P'<._.>"&}\(>))<\=}{}<.{/}&?"&"&/"&"?&}\.|>?&"?&{{}}?&//x'&{((<._\($|(}.\/}{/>=&'P&"&/".{3?<.|\"&P'&P}{}&P'<.>&{}}?&"&'P&\=}}<.}/2?".?''5?"/?1{(}\."..../{},<../&//&"&P'&P'&"&"</{}}{{/>"?1''?.'({/}}{}<..>?&"?&}}$>)|P/<.>"&'P&'P&"&"&{/........._/"\$#1}/._.........|,($<'"}'?/_$P#"$0'${)$})$)|........(>/\.#1?<$<|.....>?&}$>=?&"?&/1$..>I;n;v;a;l;i;d;P0;m;a\|\"(}}({=/..$_...\"&P=},}}&P'<.|><....................;...>1"(}}){=/_....>'P&'P&}}_?&/#.>}?4'%\/<...@;1P;e;z<._><>"))'?=<.$$=..\&P}{&</\"><_'|/'&=}<.>{{.<.........|>(/>3")}}){=/=/_.>}P&"?/"<).}_.>?4{=:<.|_...........\$\2$'>4")}}({/."\{&P'&?/><.?|>P...."/=(>(/./(}{{\..>(<>(<>?5'"((..'/...#,</,}{{\.......;.F>..\(...}....._.._..._..._........__..'$......\.<R..$.>))<$}{{&P'&?}<.\$$.\...................$\.<>L\.\(('_"\>}P&"?&{/__/=(.(<.>_)..<...>....\..._.<.....&?=\}=&?"&<.."'>.\>))<.|>))\.|$.>&"?&{{}=P&}?&=}/{\.>&{{P/{">)<|\{<(|\(_(<>\_\?"&P'&P}{{{&<=_.>\&\?"&?<|'{/(/>{{/_>.{/=/\\.>'P&"?&"?&"?/._(\)\\>?&"/_|.>/.$/|$..\\><..\&?}{{}&P'&<}.._>{<|\{}<._$>-")<.>_)<|{)$|..>}=P&"?&"?/...{"./>'P&/=_\{?(/>(<>\(|)__.\&?}}{}&P<}.$.\&P'&P'&<\})))&=<\)<'.'_,><.>"?&'P&'/.|>?&{{}?&"?/>&"?&"?&}}<.".(\\\&?={&P<{..\"&?"&P'&<.?....|.$'\$/\"/.,.>{}{}=/..>&'P&}{{}P/\{}&P{(&?"&?"<'.(\&?"&<}..\?"&?"&<.>P&={}}?&}}P&'P&/.'.>&"?/..>P&}}{{P/\}&P'&?={&?<$}=\"."\P'<{..\'&P'&<....>'P&{}P&"?&{{<\\..>&/$.>}{?&"?/|'$&.P&$P\$'&P={(/..\P\\.\{&?"&?\...\?{{}=<$&P'&P<.,./<?\...{}=P\"&<.>=P&""'?&'P&'/$.#1.>{?1#=$\&'P/\}&P'&?={(,}<._?_&\&?{=&{*=}4<.>P&"?&"?&'P&/1_$>}?&}}=?&){?/\{}&P'&?={&?#<$

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

"पठनीय" संस्करण:

                             ( . = $ > ( { { { ( { } } { \ > 6 ' % = { } { ? 4 = $ / .
                            / \ _ > < . / , { } } { < $ < \ ? { & P ' _ ( " ' " # < " .
                           > . . . . . . . . _ . . \ > < / < / ( \ . | / < > } { 0 / ' $
                          . } _ . . . . . > < > ) < . $ ) ) . > < $ . / $ \ ) ) ' " < $ _
                         . ) > < . > % ' 2 { / _ . > ( / ) | _ > } { { } . / . . > # / | }
                        . ' / $ | \ } ) ' % . < > { = \ $ _ . \ < $ ) ) < > ( | \ 4 ? < . {
                       . % . | / < / { = . . . . $ / < > / . . . ' . . . _ . > ' " ' _ / < }
                      . . . . ( { { > % ' ) ) } / . > < . $ . / { } { \ > $ \ | $ ( < > < $ ?
                     . . \ \ < . } _ > = < . _ . . \ ( / . / / . . \ } \ . ) ) ) ) ) < . . . 2
                    / | $ \ ) { } / { . . > < > ) . . . / _ $ . . $ _ > { 0 # { { ( ( ( ( / | #
                   . } > < . . > . < _ . \ ( / / $ > ) ) < ( / . \ . \ } ) ' " # 4 ? # \ _ = _ -
                  . . = . > ( < . . . ( . . > ( / \ " ) < ( ( . \ = } } } \ > { } { ? < , | { > /
                 . . . ( . . . > ( $ > { ) < . > { = P & / ( > / / ( _ . ) \ } = # = \ 4 # | ) _ _
                . > " ' ( ) ' \ . ' . . " . ( \ & P ' & < / ' & \ $ _ > < / } { ) < \ < 0 | \ < . }
               . \ " \ . ( . ( . ( / ( \ . . { . > } = P / | > < . ( . . . ( . . . " / < . { " _ { {
              = . . ) . . > } ) < | > < $ } } / \ } } & P < \ ( / . _ . . . > \ $ ' / . > } / { } } {
             ) . . | / ( \ ' . < ( \ ' ' " " ) $ / { { } } ) < . . ' . . . } } > 3 # . / \ $ < } | . }
            | . . $ . > < $ { { } / > . } } { { < > ( " " ' ' / . . > ) { < } \ ? = } { \ . _ = / $ / =
           _ > ) \ { _ \ . _ . . > ) < / { \ = . _ . . . . . > ( ( $ > } } < . > 5 # . \ / } > ) < > - /
          ( . . . . . { \ < > } } { { / ) \ $ > = } } } ) ) < . . . = . . . ( \ ? { { { ? < \ < . _ . . .
         } . > < . . \ } } / . . > ' P & / / ( \ . . . . . . ( . . \ } ) " ' / . / & P ' & P { } } & P ' <
        { } \ { { { ( { { { ( . \ & P = < . > < $ " & 1 } ( . / ' " ? & ' & " \ . | > } { ? & " ? & ' P & /
       | { / & P ' ' < / ( \ . . > P & { / & / } { } & ' & } , / " & P ' & ? < . | \ } { & ? " & P ' & P ' <
      . _ . > " & } \ ( > ) ) < \ = } { } < . { / } & ? " & " & / " & " ? & } \ . | > ? & " ? & { { } } ? & /
     / x ' & { ( ( < . _ \ ( $ | ( } . \ / } { / > = & ' P & " & / " . { 3 ? < . | \ " & P ' & P } { } & P ' <
    . > & { } } ? & " & ' P & \ = } } < . } / 2 ? " . ? ' ' 5 ? " / ? 1 { ( } \ . " . . . . / { } , < . . / & /
   / & " & P ' & P ' & " & " < / { } } { { / > " ? 1 ' ' ? . ' ( { / } } { } < . . > ? & " ? & } } $ > ) | P / <
  . > " & ' P & ' P & " & " & { / . . . . . . . . . _ / " \ $ # 1 } / . _ . . . . . . . . . | , ( $ < ' " } ' ? /
 _ $ P # " $ 0 ' $ { ) $ } ) $ ) | . . . . . . . . ( > / \ . # 1 ? < $ < | . . . . . > ? & } $ > = ? & " ? & / 1 $
  . . > I ; n ; v ; a ; l ; i ; d ; P 0 ; m ; a \ | \ " ( } } ( { = / . . $ _ . . . \ " & P = } , } } & P ' < . |
   > < . . . . . . . . . . . . . . . . . . . . ; . . . > 1 " ( } } ) { = / _ . . . . > ' P & ' P & } } _ ? & / #
    . > } ? 4 ' % \ / < . . . @ ; 1 P ; e ; z < . _ > < > " ) ) ' ? = < . $ $ = . . \ & P } { & < / \ " > < _ '
     | / ' & = } < . > { { . < . . . . . . . . . | > ( / > 3 " ) } } ) { = / = / _ . > } P & " ? / " < ) . } _
      . > ? 4 { = : < . | _ . . . . . . . . . . . \ $ \ 2 $ ' > 4 " ) } } ( { / . " \ { & P ' & ? / > < . ? |
       > P . . . . " / = ( > ( / . / ( } { { \ . . > ( < > ( < > ? 5 ' " ( ( . . ' / . . . # , < / , } { { \
        . . . . . . . ; . F > . . \ ( . . . } . . . . . _ . . _ . . . _ . . . _ . . . . . . . . _ _ . . ' $
         . . . . . . \ . < R . . $ . > ) ) < $ } { { & P ' & ? } < . \ $ $ . \ . . . . . . . . . . . . . .
          . . . . . $ \ . < > L \ . \ ( ( ' _ " \ > } P & " ? & { / _ _ / = ( . ( < . > _ ) . . < . . . >
           . . . . \ . . . _ . < . . . . . & ? = \ } = & ? " & < . . " ' > . \ > ) ) < . | > ) ) \ . | $
            . > & " ? & { { } = P & } ? & = } / { \ . > & { { P / { " > ) < | \ { < ( | \ ( _ ( < > \ _
             \ ? " & P ' & P } { { { & < = _ . > \ & \ ? " & ? < | ' { / ( / > { { / _ > . { / = / \ \
              . > ' P & " ? & " ? & " ? / . _ ( \ ) \ \ > ? & " / _ | . > / . $ / | $ . . \ \ > < . .
               \ & ? } { { } & P ' & < } . . _ > { < | \ { } < . _ $ > - " ) < . > _ ) < | { ) $ | .
                . > } = P & " ? & " ? / . . . { " . / > ' P & / = _ \ { ? ( / > ( < > \ ( | ) _ _ .
                 \ & ? } } { } & P < } . $ . \ & P ' & P ' & < \ } ) ) ) & = < \ ) < ' . ' _ , > <
                  . > " ? & ' P & ' / . | > ? & { { } ? & " ? / > & " ? & " ? & } } < . " . ( \ \
                   \ & ? = { & P < { . . \ " & ? " & P ' & < . ? . . . . | . $ ' \ $ / \ " / . ,
                    . > { } { } = / . . > & ' P & } { { } P / \ { } & P { ( & ? " & ? " < ' . (
                     \ & ? " & < } . . \ ? " & ? " & < . > P & = { } } ? & } } P & ' P & / . '
                      . > & " ? / . . > P & } } { { P / \ } & P ' & ? = { & ? < $ } = \ " . "
                       \ P ' < { . . \ ' & P ' & < . . . . > ' P & { } P & " ? & { { < \ \ .
                        . > & / $ . > } { ? & " ? / | ' $ & . P & $ P \ $ ' & P = { ( / . .
                         \ P \ \ . \ { & ? " & ? \ . . . \ ? { { } = < $ & P ' & P < . , .
                          / < ? \ . . . { } = P \ " & < . > = P & " " ' ? & ' P & ' / $ .
                           # 1 . > { ? 1 # = $ \ & ' P / \ } & P ' & ? = { ( , } < . _ ?
                            _ & \ & ? { = & { * = } 4 < . > P & " ? & " ? & ' P & / 1 _
                             $ > } ? & } } = ? & ) { ? / \ { } & P ' & ? = { & ? # < $

Esoteric IDE पर परीक्षण किया गया: TIO बड़े परीक्षण मामलों में से कुछ पर समय निकाल सकता है लेकिन सभी सत्यापित हैं। टिमवी के लिए बहुत धन्यवाद, यह आईडीई के बिना संभव नहीं था।

काफी खाली जगह है, इसलिए मैं इसे एक साइड-लेंग 28 हेक्सागन (साइड-लेंथ 29 के बजाय) पर फिट करने में सक्षम हो सकता हूं, लेकिन यह एक बड़ा काम होगा इसलिए मैं शायद यह कोशिश नहीं करने जा रहा हूं।

मूल व्याख्या

बड़े और अधिक विस्तृत संस्करण के लिए छवियों पर क्लिक करें।

कार्य

_{नोट: विभाजन आम तौर पर सही होते हैं, लेकिन कभी-कभार एक मोटा अनुमान हो सकता है।}

यह कोड काफी "कार्यात्मक" है - जितना हेक्सागोनी इसे होने देता है। उपरोक्त आरेख में लेबल किए गए इस कोड में आठ मुख्य कार्य हैं, जिन नंबरों से उन्हें बुलाया जाता है (इसलिए उनके निर्देश सूचक संख्या उस संख्या मॉड 6 हैं)। कॉल करने के क्रम में (मोटे तौर पर), वे हैं (उद्धृत नाम स्मृति में स्थान हैं जिन्हें बाद में समझाया जाएगा):

• एस: शुरुआती फ़ंक्शन - इनपुट पढ़ता है और "संदर्भ सरणी" सेट करता है, फिर तीन पथों के साथ "पथ स्टैक" शुरू होता है F, Rऔर Lमुख्य प्रसंस्करण के लिए तैयार होता है। निर्देश सूचक 0 फ़ंक्शन 0 पर जाता है जबकि निष्पादन 1 कार्य करता है।
• 1 (-11): मुख्य कार्य - इसकी वैधता की जांच करने के लिए 3 का उपयोग करता है, 3 इसकी वैधता की जांच करने के लिए, और यदि वैध दो बार -110 / -10 कार्य करता है और फिर 4 तीन बार "पथ में नए पथों की प्रतिलिपि बनाता है।" स्टैक ”, अपने आप में लौटकर खत्म। यदि फ़ंक्शन अंतिम स्थान पर है, तो फ़ंक्शन 5 को कॉल करें।
• 2: प्रसंस्करण के लिए तैयार "पथ स्टैक" से अगला पथ हो जाता है, फ़ंक्शन -1 को कॉल करता है यदि स्टैक पर कोई पथ नहीं बचा है। कार्य 1 पर लौटता है।
• 3: मानों की एक जोड़ी के साथ-साथ मूव नंबर लेता है और "रेफरेंस एरे" को चेक करता है कि वर्तमान पथ वैध स्थान पर समाप्त हुआ है या नहीं। एक वैध स्थान या तो पहले 3 चालों के भीतर शुरू होता है, या किसी भी +2 चाल के भीतर पहले पहुंच जाता है। कार्य 1 पर लौटता है।
• -10 / -110: वर्तमान पथ की प्रतिलिपि बनाता है। कार्य 1 पर लौटता है।
• 0: फंक्शन की दिशा को प्रबंधित करने के लिए फंक्शन 1 को मदद करता है F। कार्य करने के लिए रिटर्न 1।
• 4: वर्तमान पथ की एक प्रति लेता है और फ़ंक्शन 1 के साथ इंटरलिंक करके इसे उसी पथ में बदल देता है F, Rया Lसंलग्न किया जाता है। कार्य 1 पर लौटता है।
• 5: पथ लेता है और सही पथ (जैसे FFLF) को प्रिंट करता है , फिर प्रोग्राम को समाप्त करता है।
• -1: प्रिंट Invalid maze!और टर्मिनेट।
• (डबल तीर): स्थान की कमी के कारण, फ़ंक्शन 1 / -11 को फ़ंक्शन -1 के ऊपर अंतरिक्ष में बंद होना पड़ा।

स्मृति

_{नोट: आरेख आईडीई के लिए फिर से आरेख के लिए धन्यवाद}

मेमोरी में तीन मुख्य भाग होते हैं:

• संदर्भ सरणी: प्रत्येक चरण में एक मान के साथ ग्रिड को कॉलम 2 से अलग किया जाता है:
  • 0 या तो एक का प्रतिनिधित्व करता है , 0या एक वैध जगह है कि किसी भी दिशा में जगह से बाहर निकलने की आवश्यकता होगी की तुलना में अधिक चाल पहले पहुँचा गया था।
  • 1 प्रतिनिधित्व करता है +जो अभी तक नहीं पहुंचा है।
  • (उच्च संख्या) चाल संख्या का प्रतिनिधित्व करता है जहां किसी भी दिशा में जगह से बाहर निकलने के लिए पर्याप्त चालें होती हैं।
  • 10 भी एक नई-रेखा का प्रतिनिधित्व करता है: ये कभी भी यह नहीं मानते हैं कि वे अंतिम गैर-श्वेत-स्थान वाले वर्ण का अनुसरण करते हैं।
• रेल: बायीं ओर -1एक एकल के साथ एस -2, जो कि संकरी प्रसंस्करण क्षेत्र में मेमोरी पॉइंटर को जल्दी से लौटने की अनुमति देता है।
• पाथ स्टैक: पथ आईडी के क्रम में प्रत्येक अप्रयुक्त पथ को संग्रहीत करता है (जो सीधे चाल संख्या से संबंधित है इसलिए छोटे पथों का परीक्षण किया जाता है)। पथ निम्नानुसार संग्रहीत है:
  
  • सड़ांध: वर्तमान पथ के अंत में रोटेशन: ऊपर-बाएँ के लिए 0 और बढ़ती दक्षिणावर्त 5
  • चाल: वर्तमान चाल संख्या (निर्देश - 1)
  • पथ: वर्तमान पथ, साथ चतुर्धातुक में संग्रहीत F, R, Lके रूप में 1, 2, 3क्रमशः
  • x / y: वर्तमान पथ के अंत में निर्देशांक: x + 1 -1s सही तो y मान ऊपर (हालाँकि y = 0 को 1 के रूप में संसाधित किया जाता है, संदर्भ डेटा से रेल को अलग करने के उद्देश्य से)

अन्य महत्वपूर्ण स्मृति स्थान:

1. का x / y Eयहाँ संग्रहीत है।
2. इस स्थान का उपयोग स्मृति के अंदर और बाहर पथों को परिवर्तित करने के लिए किया जाता है।
3. यह स्थान केंद्र है जहां प्रसंस्करण के दौरान प्रत्येक पथ संग्रहीत है।

Comments

अगला चरण आपके प्रोग्राम के माध्यम से सबसे छोटा भूलभुलैया मार्ग खोजने के लिए चल रहा है।

— विस्कह

मुझे पता है कि कोई इसे पोस्ट करेगा। अंत में ... / मेरे पास एक अलग योजना भी है, जिसे संभवतः आपके मुकाबले कम कोड लेना चाहिए। वास्तव में इसे लागू करने के लिए समय नहीं है।

— user202729

@ user202729 इसके बारे में सुनना दिलचस्प होगा। इस विधि को शायद कम से कम 2 आकारों में नीचे गिराया जा सकता है जो मैं कहूंगा, लेकिन वहाँ लगभग निश्चित रूप से कुछ बेहतर है।

— बोकोक्वैक

बस @lirtosiast का इंतजार है।

— J Atkin

देरी के लिए क्षमा याचना।

— lirtosiast

Answer 3

पायथन 3, 466 बाइट्स

अगर मैं गहराई-पहली खोज या किसी चीज़ का उपयोग करता तो शायद वह छोटा हो जाता। यह राक्षसी द्विजत्र का उपयोग करता है और यह काफी तेज है, लेकिन बहुत लंबा है।

कोड एक फ़ंक्शन को परिभाषित करता है Sजो भूलभुलैया के साथ एक बहुस्तरीय स्ट्रिंग लेता है और परिणाम देता है।

def F(M,L,c):y=M[:M.index(c)].count("\n");return L[y].index(c),y
def S(M):
 L=M.split("\n");Q=[("",)+F(M,L,"S")+(0,)];D={};R=range;H=len;U=R(2**30)
 while Q:
  C,*Q=sorted(Q,key=H);w,x,y,d=C
  for e in R(H(L)>y>-1<x<H(L[y])>0<H(D.get(C[1:],U))>H(w)and(L[y][x]in"+SE")*6):D[C[1:]]=w;E=(d+e)%6;Q+=[(w+",R,RR,RRR,LL,L".split(",")[e]+"F",x+[-1,1,2,1,-1,-2][E],y+[-1,-1,0,1,1,0][E],E)]
 J=min([D.get(F(M,L,"E")+(d,),U)for d in R(6)],key=H);return[J,"Invalid maze!"][J==U]

यहाँ कोड की एक परीक्षा है।

Ungolfed

def find_char(maze, lines, char):
    y = maze[:maze.index(char)].count("\n")
    return lines[y].index(char), y
def solve(maze):
    lines = maze.split("\n")
    x, y = find_char(maze, lines, "S")
    queue = [("", x, y, 0)]
    solutions = {}
    very_long = range(2**30)
    x_for_direction = [-1,1,2,1,-1,-2]
    y_for_direction = [-1,-1,0,1,1,0]
    rotations = ["","R","RR","RRR","LL","L"]
    while len(queue) > 0:
        queue = sorted(queue, key=len)
        current, *queue = queue
        route, x, y, direction = current
        if 0 <= y < len(lines) and 0 <= x < len(lines[y]) and lines[y][x] in "+SE" and len(solutions.get(current[1:], very_long)) > len(route):
            solutions[current[1:]] = route
            for change in range(6):
                changed = (direction + change) % 6
                queue += [(route + rotations[change] + "F", x + x_for_direction[changed], y + y_for_direction[changed], changed)]
    end_x, end_y = find_char(maze, lines, "E")
    solution = min([solutions.get((end_x, end_y, direction), very_long) for direction in range(6)], key=len)
    return "Invalid maze!" if solution == very_long else solution

Comments

वाह बहुत अच्छा। आपको लिखने में कितना समय लगा?

— J Atkin

@JAtkin खैर, फ़ाइल 1.5 घंटे पहले बनाई गई थी, हालांकि मुझे यकीन नहीं है कि मैंने वास्तव में कोड पर काम करने में कितना समय बिताया है। इसके अलावा, यह 3 बजे यहां है, इसलिए मेरी उत्पादकता स्पष्ट रूप से अधिकतम है।

— पुरखाकूदरी

अच्छा, मैंने 2+ घंटे बिताए, और मेरा अधिकांश पहले से ही एक मानक भूलभुलैया के लिए लिखा गया था।

— J Atkin

क्या आपके पास एक अन-गोफ़र्ड संस्करण है?

— J Atkin

@ जेटकिन इसकी आवश्यकता है, क्योंकि आपको शुरुआत में चारों ओर मुड़ना पड़ सकता है। प्रारंभिक स्थिति के बिना यह साथ काम करेगा L,,R।

— पुरकाकूदरी

Answer 4

ग्रूवी, 624 बाइट्स। फोर!

समय समय एक बड़ी गेंद के साथ रोलिंग मिल। बहु-पंक्ति स्ट्रिंग को आर्ग के रूप में ले जाता हैQ

Q={a->d=[0]*4
a.eachWithIndex{x,y->f=x.indexOf('S');e=x.indexOf('E');
if(f!=-1){d[0]=f;d[1]=y}
if(e!=-1){d[2]=e;d[3]=y}}
g=[]
s={x,y,h,i,j->if(h.contains([x, y])|y>=a.size()||x>=a[y].size()|x<0|y<0)return;k = a[y][x]
def l=h+[[x, y]]
def m=j
def n=1
if(h){
o=h[-1]
p=[x,y]
q=[p[0]-o[0],p[1]-o[1]]
n=[[-2,0]:0,[-1,-1]:1,[1,-1]:2,[2,0]:3,[1,1]:4,[-1,1]:5][q]
r=n-i
m=j+((r==-5|r==5)?' LR'[(int)r/5]:['','R','RR','LL','L'][r])+'F'}
if(k=='E')g+=m
if(k=='+'|k=='S'){s(x-2,y,l,n,m)
s(x+2,y,l,n,m)
s(x+1,y+1,l,n,m)
s(x+1,y-1,l,n,m)
s(x-1,y+1,l,n,m)
s(x-1,y-1,l,n,m)}}
s(d[0],d[1],[],1,'')
print(g.min{it.size()}?:"Invalid maze!")}

Ungolfed संस्करण:

def map =
        """
  + 0 0 0 0 0 0
 0 0 0 0 0 + + 0
0 0 E 0 + 0 0 + 0
 0 0 0 0 0 0 0 +
  0 + 0 0 + + +
   0 0 + + 0 0
    S + 0 0 0""".split('\n').findAll()
//map =
//        """
// 0 + +
//E + 0 S 0
// 0 0 0 +
//  + + +""".split('\n').findAll()

//map = [""]// TODO remove this, this is type checking only
//map.remove(0)
//reader = System.in.newReader()
//line = reader.readLine()
//while (line != '') {
//    map << line
//    line = reader.readLine()
//}

startAndEnd = [0, 0, 0, 0]
map.eachWithIndex { it, idx ->
    s = it.indexOf('S'); e = it.indexOf('E');
    if (s != -1) {
        startAndEnd[0] = s; startAndEnd[1] = idx
    }
    if (e != -1) {
        startAndEnd[2] = e; startAndEnd[3] = idx
    }
}

def validPaths = []
testMove = { x, y, visited ->// visited is an array of x y pairs that we have already visited in this tree
    if (visited.contains([x, y]) || y >= map.size() || x >= map[y].size() || x < 0 || y < 0)
        return;


    def valueAtPos = map[y][x]
    def newPath = visited + [[x, y]]

    if (valueAtPos == 'E') validPaths += [newPath]
    if (valueAtPos == '+' || valueAtPos == 'S') {
        println "$x, $y passed $valueAtPos"
        testMove(x - 2, y, newPath)
        testMove(x + 2, y, newPath)

        testMove(x + 1, y + 1, newPath)
        testMove(x + 1, y - 1, newPath)

        testMove(x - 1, y + 1, newPath)
        testMove(x - 1, y - 1, newPath)
    }
}

//if (!validPath) invalid()
testMove(startAndEnd[0], startAndEnd[1], [])
println validPaths.join('\n')

//println validPath

def smallest = validPaths.collect {
    def path = ''
    def orintation = 1
    it.inject { old, goal ->
        def chr = map[goal[1]][goal[0]]
        def sub = [goal[0] - old[0], goal[1] - old[1]]
        def newOrin = [[-2, 0]: 0, [-1, -1]: 1, [1, -1]: 2, [2, 0]: 3, [1, 1]:4, [-1, 1]:5][sub]
        def diff = newOrin - orintation// 5L -5R
        def addedPath= ((diff==-5||diff==5)?' LR'[(int)diff/5]:['', 'R', 'RR', 'LL', 'L'][diff]) + 'F'//(diff == 0) ? '' : (diff > 0 ? 'R'*diff : 'L'*(-diff)) + 'F'
//        println "old:$old, goal:$goal chr $chr, orintation $orintation, sub:$sub newOrin $newOrin newPath $addedPath diff $diff"
        path += addedPath
        orintation = newOrin
        goal
    }
    path
}.min{it.size()}
//println "paths:\n${smallest.join('\n')}"
if (smallest)
    println "path $smallest"
else
    println "Invalid maze!"

Answer 5

सी #, 600 574 बाइट्स

पूरा कार्यक्रम, STDIN से इनपुट स्वीकार करता है, STDOUT को आउटपुट देता है।

संपादित करें: रैप हैंडलिंग में एक बग था (दिए गए परीक्षण मामलों में से किसी पर भी ब्रेक नहीं) जिसने 1 बाइट को जोड़ा होगा, इसलिए मैंने क्षतिपूर्ति करने के लिए थोड़ा और गोल्फिंग किया।

using Q=System.Console;struct P{int p,d;static void Main(){string D="",L;int w=0,W=0,o,n=1;for(;(L=Q.ReadLine())!=null;D+=L)w=(o=(L+="X").Length+1)>w?o:w;for(;W<D.Length;)D=D.Insert(W+1,"".PadLeft(D[W++]>87?w-W%w:0));P[]K=new P[W*6];var T=new string[W*6];P c=K[o=0]=new P{p=D.IndexOf('S')};for(System.Action A=()=>{if(c.p>=0&c.p<W&System.Array.IndexOf(K,c)<0&&D[c.p]%8>0){T[n]=T[o]+L;K[n]=c;n=D[c.p]==69?-n:n+1;}};o<n;o++){c=K[o];L="R";c.d=++c.d%6;A();L="L";c.d=(c.d+4)%6;A();L="F";c=K[o];c.p+=new[]{~w,1-w,2,1+w,w-1,-2}[c.d%6];A();}Q.WriteLine(n>0?"Invalid maze!":T[-n]);}}

यह मानचित्र में पढ़कर शुरू होता है, (प्रत्येक पंक्ति में संलग्न होता है ताकि यह पता चले कि यह कहाँ समाप्त होता है, और नक्शे को आयताकार बनाने के लिए रिक्त स्थान के भार में जा सकता है और जोड़ सकता है, और दाईं ओर रिक्त स्थान की एक पंक्ति के साथ (यह बचाता है) हमें रैपिंग चेक के रूप में नीचे समझाया जाएगा)। यह इसमें कुछ बिंदु पर आयत की चौड़ाई का काम करता है, और मानचित्र की कुल लंबाई का पता लगाता है।

इसके बाद, यह एक ब्रेड-फ़र्स्ट-सर्च के लिए सब कुछ इनिशियलाइज़ करता है। दो बड़े पैमाने पर सरणियाँ बनाई गई हैं, एक उन सभी राज्यों को संग्रहीत करने के लिए जिन्हें हमें अपनी खोज में तलाशने की आवश्यकता है, दूसरे को उस मार्ग को रिकॉर्ड करने के लिए जिसे हमने प्रत्येक राज्य में प्राप्त करने के लिए लिया था। प्रारंभिक अवस्था को नियत सरणी में जोड़ा जाता है, जिसके शीर्ष और पूंछ के संकेत ऊपर किसी न किसी तरह सेट होते हैं। सब कुछ 1-अनुक्रमित है।

हम तब तक पुनरावृति करते हैं जब तक कि पूंछ सिर में दुर्घटनाग्रस्त हो जाती है, या कम से कम यह प्रतीत होता है कि सिर में दुर्घटनाग्रस्त हो गया है। हमारे द्वारा देखे गए प्रत्येक राज्य के लिए, हम उसी स्थिति में एक नया राज्य जोड़ने का प्रयास करते हैं जहां हमें बाएं या दाएं घुमाया जाता है, और फिर एक जहां हम आगे बढ़े हैं। दिशा-निर्देश अनुक्रमित हैं, जिसमें प्रारंभिक दिशा (डिफ़ॉल्ट 0) "ऊपर-बाएं" के अनुरूप है।

जब हम किसी राज्य को पंक्तिबद्ध करने का प्रयास करते हैं, तो उसे चेक किया जाता है, लेकिन रैप चेक नहीं किया जाता है, क्योंकि दाईं ओर रिक्त स्थान के कॉलम के कारण, जिस पर "हमें यहां रहने की अनुमति है?" जाँच करें (आपको रिक्त स्थान की अनुमति नहीं है)। यदि राज्य पंक्तिबद्ध है, तो हम यह जांचते हैं कि क्या यह Eसेल पर है, और यदि यह है, तो हम कतार के सिर को माइनस होने के लिए सेट करते हैं, जिससे मुख्य लूप बाहर निकल जाता है, और प्रिंट करने के लिए प्रोग्राम की अंतिम पंक्ति बताता है विफलता संदेश के बजाय संबंधित मार्ग से बाहर (जो दिखाता है कि क्या हम विस्तार करने के लिए राज्यों से बाहर निकलते हैं (पूंछ सिर में दुर्घटनाग्रस्त हो जाती है)।

using Q=System.Console;

// mod 8 table (the block of zeros is what we are after - it's everywhere we /can't/ go)
//   0 (space)
// O 0
// X 0
// S 3
// + 3
// E 5

struct P
{
    int p,d;
    static void Main()
    {
        // it's probably a bad thing that I have my own standards for naming this stupid read sequence by now
        string D="", // map
        L; // line/path char

        int w=0, // width
        W=0, // full length
        o, // next state to expand
        n=1; // next state to fill

        for(;(L=Q.ReadLine())!=null;D+=L) // read in map
            w=(o=(L+="X").Length+1)>w?o:w; // assertain max length (and mark end, and remove any need for wrap checking)

        // now we need to add those trailing spaces...
        for(;W<D.Length;)
            D=D.Insert(W+1,"".PadLeft(D[W++]>87?w-W%w:0)); // inject a load of spaces if we hit an X

        P[]K=new P[W*6]; // create space for due states (can't be more states than 6*number of cells)
        var T=new string[W*6]; // create space for routes (never done it this way before, kind of exciting :D)
        P c=K[o=0]=new P{p=D.IndexOf('S')}; // set first state (assignment to c is just to make the lambda shut up about unassigned variables)

        // run bfs
        for(

            System.Action A=()=> // this adds c to the list of states to be expanded, if a whole load of checks pass
            {
                if(//n>0& // we havn't already finished - we don't need this, because we can't win on the first turn, so can't win unless we go forward, which we check last
                   c.p>=0&c.p<W& // c is within bounds
                   System.Array.IndexOf(K,c)<0&& // we havn't seen c yet (the && is to prevent the following lookup IOBing)
                   D[c.p]%8>0) // and we can move here (see table at top of code)
                {
                    T[n]=T[o]+L; // store route
                    K[n]=c; // store state
                    n=D[c.p]==69?-n:n+1; // check if we are at the end, if so, set n to be negative of itself so we know, and can look up the route (otherwise, increment n)
                }
            }

            ;o<n;o++) // o<n also catches n<0
        {
            c=K[o]; // take current
            L="R"; // say we are going right
            c.d=++c.d%6; // turn right
            A(); // go!

            L="L"; // say we are going left
            c.d=(c.d+4)%6; // turn left
            A(); // go!

            L="F"; // say we - you get the picture
            c=K[o];
            c.p+=new[]{~w,1-w,2,1+w,w-1,-2}[c.d%6]; // look up direction of travel (~w = -w-1)
            A();
        }

        // check if we visited the end
        Q.WriteLine(n>0?"Invalid maze!":T[-n]); // if n<0, then we found the end, so spit out the corresponding route, otherwise, the maze is invlida
    }
}

इस साइट पर मेरे अधिकांश ग्राफ़-सर्च की तरह, मैं C # स्ट्रक्चर्स का अच्छा उपयोग कर रहा हूं, जो कि शाब्दिक मूल्य की तुलना करने के लिए डिफ़ॉल्ट है।

Answer 6

पायथन 2, 703 बाइट्स

अन्य दो संस्करणों जितना अच्छा नहीं है, लेकिन कम से कम यह हाहा काम करता है। Mभूलभुलैया पर सेट करें ।

चूँकि मुझे mazes को हल करने का कोई अनुभव नहीं है, यह सिर्फ एक brute force दृष्टिकोण से जाता है, जहाँ यह उन सभी समाधानों को खोजेगा जो इसमें खुद को वापस पार करना शामिल नहीं करता है। यह सबसे छोटे लोगों से बारी की गणना करता है, और फिर उससे सबसे छोटा परिणाम चुनता है।

z=zip;d=z((-1,1,-2,2,-1,1),(-1,-1,0,0,1,1));E=enumerate;D={};t=tuple;o=list;b=o.index
for y,i in E(M.split('\n')):
 for x,j in E(o(i)):
  c=(x,y);D[c]=j
  if j=='S':s=c
  if j=='E':e=c
def P(s,e,D,p):
 p=o(p);p.append(s);D=D.copy();D[s]=''
 for i in d:
  c=t(x+y for x,y in z(s,i))
  if c not in p and c in D:
   if D[c]=='E':L.append(p+[c])
   if D[c]=='+':P(c,e,D,p)
def R(p):
 a=[0,1,3,5,4,2];h=d[0];x=p[0];s=''
 for c in p[1:]:
  r=t(x-y for x,y in z(c,x));n=0
  while h!=r:n+=1;h=d[a[(b(a,b(d,h))+1)%6]]
  s+=['L'*(6-n),'R'*n][n<3]+'F';x=t(x+y for x,y in z(x,h))
 return s
L=[];P(s,e,D,[])
try:l=len(min(L))
except ValueError:print"Invalid maze!"
else:print min([R(i)for i in L if len(i)==l],key=len)

गन्दा ungolfed संस्करण:

maze = """
     0 0 0 0
    0 + 0 + 0
   0 0 0 + + 0
  0 + 0 + 0 + 0
 0 0 + + 0 0 + 0
0 0 + 0 + 0 0 + 0
 E 0 + 0 0 + + 0 
  + + 0 + 0 + 0
   0 0 0 0 0 +
    + 0 + + +
     0 S 0 0
     """
directions = [(-1, -1), (1, -1),
              (-2, 0), (2, 0),
              (-1, 1), (1, 1)]


maze_dict = {}
maze_lines = maze.split('\n')
for y, row in enumerate(maze_lines):
    if row:
        for x, item in enumerate(list(row)):
            coordinates = (x, y)
            maze_dict[coordinates] = item
            if item == 'S':
                start = coordinates
            elif item == 'E':
                end = coordinates

list_of_paths = []


def find_path(start, end, maze_dict, current_path=None):
    if current_path is None:
        current_path = []
    current_path = list(current_path)
    current_path.append(start)
    current_dict = maze_dict.copy()
    current_dict[start] = '0'

    for direction in directions:
        new_coordinate = (start[0] + direction[0], start[1] + direction[1])

        if new_coordinate in current_path:
            pass

        elif new_coordinate in current_dict:
            if current_dict[new_coordinate] == 'E':
                list_of_paths.append(current_path + [new_coordinate])
                break
            elif current_dict[new_coordinate] == '+':
                find_path(new_coordinate, end, current_dict, current_path)


find_path(start, end, maze_dict)


def find_route(path):

    heading_R = [0, 1, 3, 5, 4, 2]
    heading = (-1, -1)
    current_pos = path[0]
    current_heading = directions.index(heading)
    output_string = []
    for coordinate in path[1:]:
        required_heading = (coordinate[0] - current_pos[0], coordinate[1] - current_pos[1])

        count_R = 0
        while heading != required_heading:
            count_R += 1
            heading_index = directions.index(heading)
            heading_order = (heading_R.index(heading_index) + 1) % len(heading_R)
            heading = directions[heading_R[heading_order]]

        if count_R:
            if count_R > 3:
                output_string += ['L'] * (6 - count_R)
            else:
                output_string += ['R'] * count_R

        output_string.append('F')
        current_pos = (current_pos[0] + heading[0], current_pos[1] + heading[1])
    return ''.join(output_string)


routes = []
try:
    min_len = len(min(list_of_paths))
except ValueError:
    print "Invalid maze!"
else:
    for i in list_of_paths:
        if len(i) == min_len:
            routes.append(find_route(i))

    print 'Shortest route to end: {}'.format(min(routes, key=len))

Comments

आप if heading != required_heading: while heading != required_heading: बसwhile heading != required_heading:

— J Atkin

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

— पीटर

अच्छा! (15 चार मिनट भरने)

— J Atkin

<यह एक अपरिचित HTML टैग है, इसलिए SE कोई लाइक नहीं है।>

— CalculatorFeline