Hexagonal maze time!
Hexagony, 2437 bytes
The long-awaited program is here:
(.=$>({{{({}}{\>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'&?={&?#<$
Try it online!
"Readable" version:
( . = $ > ( { { { ( { } } { \ > 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 ' & ? = { & ? # < $
Tested on Esoteric IDE: TIO might time out on some of the larger test cases but all verified. Many thanks to Timwi, this wouldn't have been possible without the IDE.
There's quite a bit of empty space, so I might have been able to fit this onto a side-length 28 hexagon (instead of side-length 29) but that will be a massive task so I'm probably not going to attempt it.
Basic Explanation
Click the images for a larger and more detailed version.
Functions
Note: Divisions are generally correct but may occasionally be a rough guess.
This code is quite "functional" - as much as Hexagony allows it to be. There are eight main functions in this code labelled in the above diagram, named by the numbers with which they are called (so their instruction pointer numbers are that number mod 6). In (rough) order of calling, they are (quoted names are locations in memory which will be explained later):
- S: The starting function - reads the input and sets up the "reference array", then starts the "path stack" with the three paths
F,RandLready for main processing. Instruction pointer 0 moves to function 0 while the execution moves to function 1. - 1 (-11): The main function - uses 2 to get a path, 3 to check its validity, and if valid goes to function -110/-10 twice and then 4 three times to copy the new paths across into the "path stack", finishing by returning to itself. May call function 5 if the path is at the end location.
- 2: Gets the next path off the "path stack" ready for processing, calls function -1 if no paths left on the stack. Returns to function 1.
- 3: Takes a pair of values as well as the move number and checks the "reference array" to see whether the current path has ended at a valid location. A valid location is either the start within the first 3 moves, or any
+within 2 moves of it first being reached. Returns to function 1. - -10/-110: Copies the current path. Returns to function 1.
- 0: Helps function 1 to manage direction of movement with
F. Returns to function 1. - 4: Takes a copy of the current path and interlinked with function 1 changes it into the same path with either
F,RorLappended. Returns to function 1. - 5: Takes the path and prints out the correct path (e.g.
FFLF), then terminates the program. - -1: Prints
Invalid maze!and terminates. - (Double arrows): Due to lack of space, function 1/-11 had to go off into the space above function -1.
Memory
Note: Thanks to Esoteric IDE again for the diagram
The memory consists of three main parts:
- Reference array: The grid is stored columns 2 apart, with a value at each step:
- 0 represents either a
0or a valid place that was accessed more moves ago than would be required to exit the place in any direction. - 1 represents a
+that hasn't yet been reached. - (higher number) represents the move number where there will have been enough moves to exit the place in any direction.
- 10 also represents a new-line: these are never reached assuming they immediately follow the last non-white-space character.
- 0 represents either a
- Rail: Consists of
-1s with a single-2on the left, allows memory pointer to quickly return to the core processing area. - Path stack: Stores each of the untested paths in order by path ID (which is directly related to move number so the shorter paths are tested first). The path is stored as follows:
- Rot: the rotation at the end of the current path: 0 for up-left and increasing clockwise to 5
- Move: the current move number (instructions - 1)
- Path: the current path, stored in quaternary with
F,R,Las1,2,3respectively - x/y: coordinates at the end of the current path: x+1
-1s right then y values up (though y=0 is processed as 1 anyway for the purposes of separating the rail from the reference data)
Other important memory locations:
- The x/y of the
Eis stored here. - This space is used to transition paths in and out of memory.
- This location is the centre of where each path is stored during processing.
Python 2, 291 bytes
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!"
A function, f, taking the maze as a list of rows, and returning a solution, if one exists.
Explanation
Performs a breadth-first search on the graph of position/direction pairs to find the shortest path from S to E.
What's interesting is finding a compact way to represent positions and directions on a hexagonal grid, that admits simple "stepping" (i.e., moving in a certain direction) and rotation.
It's tempting to use complex numbers here, to represent coordinates on a "real" hexagonal grid, but this is not a very good idea for a number of reasons, the most serious of which is the fact that we need to plug in a √3 somewhere to make it work (sin 60° = √3/2), which, when using floating-point numbers, is a no go if we need absolute precision (e.g., for keeping track of the states we've already visited;) you can try firing up your JavaScript console and typing Math.sqrt(3)*Math.sqrt(3) == 3 and see for yourself.
But, we can use a little trick! Instead of using complex numbers, let's define hexagonal numbers in a similar vein, as a pair of real numbers a + bh, where h plays a similar role to the imaginary i when dealing with complex numbers. Just like with complex numbers, we can associate the pair (a, b) with a point on the plane, where the real axis points right, the imaginary axis points 60° up, and they both intersect the unit regular hexagon when the real and the imaginary parts equal 1, respectively. Mapping this coordinate system to the cells of the maze is trivial.
Unlike i, the constant h is defined by the relation h2 = h - 1 (solving for h might reveal some insights.)
And that's it!
Hexagonal numbers can be added and multiplied, using the above relation, much like complex numbers:
(a + bh) + (c + dh) = (a + c) + (b + d)h,
and (a + bh) · (c + dh) = (ac - bd) + (ad + bc + bd)h.
These operations have the same geometric interpretation as their complex counterparts: addition is vector addition, and multiplication is scaling and rotation.
In particular, to rotate a hexgonal number 60° counter-clockwise, we multiply it by h:
(a + bh) · h = -b + (a + b)h, and to rotate the same number 60° clockwise, we divide by h:
(a + bh) / h = (a + bh) · (1 - h) = (a + b) - ah.
For example, we can take the unit hexagonal number pointing right, 1 = (1, 0), a full circle, going counter-clockwise, by multiplying it by h six times:
(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).
The program uses hexagonal numbers in this fashion to represent the current position in the maze and the current direction, to advance in the specified direction, and to rotate the direction to the left and to the right.
Python 3, 466 bytes
Would have probably ended up smaller if I used depth-first search or something. This monstrosity uses Dijkstra and is quite fast, but very long.
The code defines a function S that takes a multiline string with the maze and returns the result.
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]
Here is a test of the code.
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