ถึงเวลาสำหรับการท้าทายเขาวงกตอื่น แต่ไม่ใช่อย่างที่คุณรู้

กฎสำหรับความท้าทายนี้แตกต่างจากความท้าทายทางเขาวงกตเล็กน้อย ชนิดของกระเบื้องถูกกำหนดดังนี้:

• S: ตำแหน่งบนเขาวงกตที่คุณเริ่มต้น
• E: สถานที่ที่คุณพยายามจะไป
• 0: กำแพงที่คุณไม่สามารถข้ามได้
• +: ชั้นที่คุณสามารถข้ามได้

คุณสามารถเดินทางในหนึ่งในหกทิศทาง: จากซ้ายไปขวาขึ้นไปทางซ้ายขวาไปทางซ้ายหรือลงทางขวา

\ /
-S-
/ \

เขาวงกตไม่ห่อ เป้าหมายคือการหาสตริงเส้นทางที่สั้นที่สุดที่จะได้รับจากการSE

การป้อนข้อมูล:

อินพุตคือเส้นที่คั่นด้วยช่องว่างเช่นเขาวงกตที่แสดง ไม่มีช่องว่างต่อท้ายจะเป็นไปตามบรรทัด

เอาท์พุท:

สตริง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

(โปรดทราบว่าเขาวงกตบางแห่งมีวิธีแก้ไขปัญหาอื่นที่มีความยาวเท่ากัน แต่ไม่มีอยู่ในรายการนี้)

Python 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การทำให้เขาวงกตเป็นรายการของแถวและส่งคืนโซลูชันถ้ามีอยู่

คำอธิบาย

ดำเนินการค้นหากว้างแรกบนกราฟของคู่ตำแหน่ง / ทิศทางที่จะหาเส้นทางที่สั้นที่สุดจากการSE

สิ่งที่น่าสนใจคือการหาวิธีกะทัดรัดในการแสดงตำแหน่งและทิศทางบนกริดหกเหลี่ยมที่ยอมรับ "การก้าว" อย่างง่าย (เช่นการเคลื่อนที่ในทิศทางที่แน่นอน) และการหมุน มันเป็นการดึงดูดให้ใช้จำนวนเชิงซ้อนที่นี่เพื่อเป็นตัวแทนของพิกัดบนกริดหกเหลี่ยม "ของจริง" แต่นี่ไม่ใช่ความคิดที่ดีสำหรับเหตุผลหลายประการที่ร้ายแรงที่สุดซึ่งเป็นข้อเท็จจริงที่ว่าเราต้องเสียบ√3 ที่ไหนสักแห่งที่จะทำให้มันใช้งานได้ (บาป 60 ° = 23/2) ซึ่งเมื่อใช้หมายเลขทศนิยมเป็นไปไม่ได้ถ้าเราต้องการความแม่นยำแน่นอน (เช่นเพื่อติดตามสถานะที่เราเคยไปมาแล้ว) คุณสามารถลองยิงคอนโซล JavaScript ของคุณแล้วพิมพ์Math.sqrt(3)*Math.sqrt(3) == 3และดูเอง

แต่เราสามารถใช้เคล็ดลับเล็กน้อย! แทนที่จะใช้ตัวเลขที่ซับซ้อนลองกำหนดตัวเลขหกเหลี่ยมในหลอดเลือดดำที่คล้ายกันเป็นคู่ของตัวเลขจริงa + bhโดยที่hมีบทบาทคล้ายกับจินตภาพiเมื่อจัดการกับจำนวนเชิงซ้อน เช่นเดียวกับตัวเลขที่ซับซ้อนเราสามารถเชื่อมโยงคู่ ( a , b ) กับจุดบนระนาบที่แกนจริงชี้ไปทางขวาแกนจินตภาพชี้ขึ้น 60 °และพวกเขาทั้งสองตัดหน่วยหกเหลี่ยมปกติเมื่อของจริงและ ส่วนจินตภาพเท่ากับ 1 ตามลำดับ การทำแผนที่ระบบพิกัดนี้ไปยังเซลล์ของเขาวงกตนั้นไม่สำคัญ

ซึ่งแตกต่างจากiค่าคงที่hถูกกำหนดโดยความสัมพันธ์h ² = h - 1 (การแก้ปัญหาสำหรับhอาจเปิดเผยข้อมูลเชิงลึกบางอย่าง) และนั่นแหละ! หมายเลขหกเหลี่ยมสามารถเพิ่มและคูณโดยใช้ความสัมพันธ์ดังกล่าวข้างต้นเหมือนตัวเลขที่ซับซ้อน ( + BH ) + ( C + dh ) = ( + C ) + ( B + d ) ชั่วโมง , และ ( + BH ) · ( c + dh ) = ( ac - bd
) + ( โฆษณา + BC + BD ) ชั่วโมง การดำเนินการเหล่านี้มีการตีความทางเรขาคณิตเช่นเดียวกับคู่ที่ซับซ้อนของพวกเขา: นอกจากนี้คือการเพิ่มเวกเตอร์และการคูณคือการปรับขนาดและการหมุน โดยเฉพาะอย่างยิ่งเมื่อต้องการหมุนหมายเลขหกเหลี่ยม 60 °ทวนเข็มนาฬิกาเราคูณมันด้วยh :
( a + bh ) · h = - b + ( a + b ) hและหมุนตามเข็มนาฬิกา 60 องศาเดียวกันเราหาร โดยh :
( a + bh ) / h = ( a +BH ) · (1 - ชั่วโมง ) = (A + B) - อา ตัวอย่างเช่นเราสามารถใช้หน่วยเลขฐานหกเหลี่ยมชี้ไปทางขวา 1 = (1, 0) วงกลมเต็มไปทวนเข็มนาฬิกาโดยคูณมันด้วยhหกครั้ง:
(1, 0) · h = (0, 1 ); (0, 1) · h = (-1, 1); (-1, 1) · h = (-1, 0); (-1, 0) · h = (0, -1); (0, -1) · h = (1, -1);
(1, -1) · h = (1, 0)

โปรแกรมใช้ตัวเลขหกเหลี่ยมในแบบนี้เพื่อแสดงตำแหน่งปัจจุบันในเขาวงกตและทิศทางปัจจุบันเพื่อเลื่อนไปในทิศทางที่กำหนดและหมุนทิศทางไปทางซ้ายและไปทางขวา

Hexagony , 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 อาจหมดเวลาใช้งานในกรณีทดสอบขนาดใหญ่บางกรณี แต่ผ่านการตรวจสอบทั้งหมดแล้ว ขอบคุณมากสำหรับ Timwi สิ่งนี้คงเป็นไปไม่ได้หากปราศจาก IDE

มีพื้นที่ว่างค่อนข้างน้อยดังนั้นฉันอาจใส่ลงในรูปหกเหลี่ยม 28 ด้าน (แทนที่จะเป็นด้านยาว 29) แต่นั่นจะเป็นงานที่ใหญ่มากดังนั้นฉันอาจจะไม่ลองเลย

คำอธิบายพื้นฐาน

คลิกที่ภาพเพื่อดูภาพขนาดใหญ่และละเอียดยิ่งขึ้น

ฟังก์ชั่น

_{หมายเหตุ: โดยทั่วไปหน่วยงานจะถูกต้อง แต่บางครั้งอาจเป็นการเดาคร่าวๆ}

รหัสนี้ค่อนข้าง "ใช้งานได้" - มากที่สุดเท่าที่ Hexagony อนุญาตให้ทำได้ มีแปดฟังก์ชั่นหลักในรหัสนี้มีป้ายกำกับในแผนภาพข้างต้นตั้งชื่อตามหมายเลขที่พวกเขาถูกเรียกว่า ตามลำดับ (หยาบ) ของการโทรพวกเขาคือ (ชื่อที่ยกมาเป็นตำแหน่งในหน่วยความจำซึ่งจะอธิบายภายหลัง)

• S: ฟังก์ชั่นเริ่มต้น - อ่านการป้อนข้อมูลและชุดขึ้น "อ้างอิงอาร์เรย์" จากนั้นเริ่มต้นเส้นทาง "กอง" กับสามเส้นทางF, RและLพร้อมสำหรับการประมวลผลหลัก คำสั่งตัวชี้ 0 ย้ายไปที่ฟังก์ชัน 0 ในขณะที่การดำเนินการย้ายไปยังฟังก์ชัน 1
• 1 (-11): ฟังก์ชั่นหลัก - ใช้ 2 เพื่อรับพา ธ 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

หน่วยความจำ

_{หมายเหตุ: ขอบคุณ Esoteric IDE อีกครั้งสำหรับไดอะแกรม}

หน่วยความจำประกอบด้วยสามส่วนหลัก:

• อาร์เรย์อ้างอิง: กริดจะถูกเก็บไว้ในคอลัมน์ที่ 2 แยกกันโดยมีค่าในแต่ละขั้นตอน:
  • 0 หมายถึงทั้ง , 0หรือสถานที่ที่ถูกต้องที่มีการเข้าถึงการเคลื่อนไหวมากขึ้นที่ผ่านมากว่าจะต้องออกจากสถานที่ไปในทิศทางใด
  • 1 หมายถึงสิ่ง+ที่ยังไม่ถึง
  • (จำนวนที่สูงกว่า) หมายถึงหมายเลขการย้ายที่จะมีการเคลื่อนไหวเพียงพอที่จะออกจากสถานที่ในทิศทางใด ๆ
  • 10 ยังหมายถึงบรรทัดใหม่: สิ่งเหล่านี้จะไม่ถึงถ้าสมมติว่าพวกเขาทำตามอักขระที่ไม่ใช่ white-space สุดท้ายทันที
• Rail: ประกอบด้วย-1s ที่-2อยู่ทางด้านซ้ายทำให้ตัวชี้หน่วยความจำกลับไปยังพื้นที่การประมวลผลหลักได้อย่างรวดเร็ว
• Path stack: เก็บแต่ละเส้นทางที่ยังไม่ผ่านการทดสอบตาม ID พา ธ (ซึ่งเกี่ยวข้องโดยตรงกับหมายเลขการย้ายเพื่อทดสอบพา ธ ที่สั้นกว่าก่อน) เส้นทางถูกเก็บไว้ดังนี้:
  
  • Rot: การหมุนที่ส่วนท้ายของเส้นทางปัจจุบัน: 0 สำหรับซ้ายขึ้นและเพิ่มตามเข็มนาฬิกาเป็น 5
  • ย้าย: หมายเลขย้ายปัจจุบัน (คำแนะนำ - 1)
  • เส้นทาง: เส้นทางปัจจุบันที่เก็บไว้ในสี่กับF, R, Lเป็น1, 2, 3ตามลำดับ
  • x / y: พิกัดที่จุดสิ้นสุดของเส้นทางปัจจุบัน: x +1 -1ขวาแล้วค่า y ขึ้น (แม้ว่า y = 0 จะถูกประมวลผลเป็น 1 ต่อไปเพื่อวัตถุประสงค์ในการแยกรางจากข้อมูลอ้างอิง)

ตำแหน่งหน่วยความจำที่สำคัญอื่น ๆ :

1. x / y ของEถูกเก็บไว้ที่นี่
2. พื้นที่นี้ใช้เพื่อเปลี่ยนเส้นทางในและนอกหน่วยความจำ
3. ตำแหน่งนี้เป็นศูนย์กลางของที่เก็บแต่ละพา ธ ระหว่างการประมวลผล

Python 3, 466 ไบต์

คงจะมีขนาดเล็กลงถ้าฉันใช้การค้นหาเชิงลึกครั้งแรกหรือบางสิ่งบางอย่าง ความโหดร้ายนี้ใช้ Dijkstra และค่อนข้างเร็ว แต่นานมาก

รหัสกำหนดฟังก์ชั่น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

Groovy ขนาด 624 ไบต์ Fore!

เวลาได้ลูกบอลกลิ้งที่มีขนาดใหญ่ รับค่าสตริงหลายบรรทัดตามที่อ้างถึง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!")}

เวอร์ชันที่ไม่ถูกปรับแต่ง:

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!"

C #, 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]);}}

มันเริ่มต้นด้วยการอ่านในแผนที่ต่อท้าย(แต่ละบรรทัดเพื่อให้มันรู้ว่ามันอยู่ตรงไหนและสามารถย้อนกลับไปและเพิ่มภาระพื้นที่เพื่อทำให้แผนที่เป็นรูปสี่เหลี่ยมผืนผ้าและมีช่องว่างทางด้านขวา (สิ่งนี้จะช่วยประหยัด เราทำการตรวจสอบการห่อตามที่อธิบายด้านล่าง) มันใช้งานได้กับความกว้างของสี่เหลี่ยมในบางจุดและยืนยันความยาวทั้งหมดของแผนที่

ถัดไปจะเริ่มต้นทุกอย่างสำหรับการค้นหาแบบกว้าง มีการสร้างอาร์เรย์ขนาดใหญ่สองอันแบบหนึ่งเพื่อจัดเก็บสถานะทั้งหมดที่เราต้องการสำรวจในการค้นหาของเราส่วนอีกรายการหนึ่งเพื่อบันทึกเส้นทางที่เราใช้เพื่อไปยังแต่ละรัฐ สถานะเริ่มต้นจะถูกเพิ่มไปยังอาร์เรย์ที่ครบกำหนดด้วยพอยน์เตอร์หัวและหางที่ตั้งไว้ล่วงหน้าข้างบน someway ทุกอย่างมีดัชนี 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 # structs เป็นอย่างดี

Python 2, 703 ไบต์

ไม่ดีเท่าสองรุ่นอื่น ๆ แต่อย่างน้อยก็ใช้งานได้ฮ่าฮ่า ตั้งMเป็นเขาวงกต

เนื่องจากฉันไม่เคยมีประสบการณ์ในการแก้เขาวงกตมันก็ไปโดยวิธีเดรัจฉานบังคับซึ่งมันจะค้นหาวิธีแก้ปัญหาทั้งหมดที่ไม่สามารถเกี่ยวข้องกับการข้ามกลับไปเองได้ มันจะคำนวณการเลี้ยวจากระยะที่สั้นที่สุดแล้วเลือกผลลัพธ์ที่สั้นที่สุดจากการนั้น

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)

รุ่นที่ยุ่งเหยิงยุ่ง:

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))