In my simulator's notation:
-|
AN3 => XN3|A
FN4 => XN4|FA
XE3 => FE3|A
DW3 => XW3|DA
XW1 => DW1|A
FN8 => XN8|FA
XN1 => FN1|A
CE5 => XE5|CA
HE3 => XE3|HCA
XW6 => HW6|CA
GE7 => XE7|GCA
XS6 => GS6|CA
XS2 => CS2|A
XW3 => AW3|
EN6 => XN6|E
XE1 => EE1|
CW5 => XW5|C
AW3 => XW3|AC
XE6 => AE6|C
DN8 => XN8|DC
XS7 => DS7|C
HE5 => XE5|HC
XE8 => HE8|C
GN2 => XN2|GC
XS8 => GS8|C
XS8 => CS8|
+|
Also attached is the graphical representation.
I also thought of a notation that can generally describe the 'outline' of the
solution.
The outline for the shortest solution is C(ADHG).
For Joseph DeVincentis' alternate C solution is CEADF(ADHG).
For Brian Trial's E solution is E(G(B(HG)))EADF(ADHG).
For my A solution is A(FDFC(HG))EC(ADHG).
I'm having way too much fun with this maze =).
I'm looking forward to the publication(?) of "100 Enigmatic Puzzles".
Yogy Namara
-------------
I accidentally got to your site (linked from logicmazes) and wow... what can I say...
I immediately fell in love with the fractal maze, and I want to explore
this concept further, i.e. how does one go about solving such a maze?
Also, I'm interested in a somewhat non-traditional aspect of maze solving:
given an unsolvable fractal maze, is it possible to actually make that
conclusion? What does it take to be able to make a claim like "Okay, I've
explored 'all' possible paths, and I can positively conclude that this
maze has no solution!".
Anyway, attached is (hopefully) a solution, represented as a color coded
paths. Should be pretty straightforward, but feel free to ask for
clarification.
Thanks again.
Regards
Yogy Namara
----------------------------------------------
Hello there,
I think we solved the fractal maze. We generated several solutions for it,
the most simple being the following:
In C6 -> In A30 -> Out A14 -> In D8 -> Out D18 -> In H13 -> Out H16 -> In
G2 -> Out G17 -> Out C17
the numbers correspond to the pins on each node numbered from the upper left
hand corner, clockwise, from 1-32. this is hard to explain, but if you
follow that path there, it works. also, we got several other solutions, but
they all started going into C. are there any solutions that don't involve
starting in C? just wondering
chris czyzewicz
--------------------------------
Dear Ed,
The Fractal Maze by Marc J.P. Wolf is fantastic!
Up till yesterday (before seeing Mark's design), my interpretation of the term Fractal Maze was "a fractal pattern that looks and feels like a maze". An example of this interpretation is my Dragon's Maze at www.clickmazes.com, which I developped in the 1980's. For every layer added, the maze gets one level more complex. A fractal maze of this type is easily solved by first solving the previous level, starting at level 1 which is a "Belgian maze". A variation of the Dragon's Maze design is my Garden Maze, using a hexagonal grid instead of square.
Mark Wolf found a very interesting different interpretation of the term
Fractal Maze: "a maze that actually is a fractal". Mind-blowing indeed!
Seeing his maze, immediately several wishes popped up in my mind.
1) Could someone write a java or shockwave applet that implements a fractal maze of the Mark Wolf type? I can imagine a user interface, where the maze would blow up (enlarge itself) when a next level is entered. A simpler implementation would be a row of mazes, representing the different fractal levels.
2) Could someone develop a Scott Kim style set of challenges, starting at the very beginner level? This way a larger audience could appreciate the subtleties of Mark Wolf's Fractal Maze concept.
3) Could someone develop a mechanical implementation of a Mark Wolf type
Fractal Maze? I guess that last challenge is a challenge to myself. I hope
that there are "takers" for the other challenges.
Best regards,
M. Oskar van Deventer
--------------------------------
Hm, a fractal maze might actually have an infinite path as its only solution:
+-------+
| +-+ |
start ->|--|A|--|-> finish
| +-+ |
+-------+
(Pardon the boxology; the inner square A is a copy of the outer square.)
I suppose it's arguable whether this counts as a solution. Anyway, I
guess even breadth-first search might not terminate unless it
recognized infinite regression loops.
--Doug Orleans
--------------------------------
Naming the sides North, South, East and West
( NSEW ) such that the pins near the upper left
corner are N1 and W1, and the pins near the
lower right corner are S8 and E8, I found this
solution first:
minus
IN C, N6
IN A, W3
OUT A, E6
IN D, N8
OUT D, S7
IN H, E5
OUT H, E8
IN G, N2
OUT G, S8
OUT C, S8
PLUS
I was a little disappointed that the solution
didn't involve more recursion. Here's a longer
one that does.
minus
IN E, W8
IN G, E2
IN B, S5
IN H, E3
OUT H, W6
IN G, E7
OUT G, S6
OUT B, S2
OUT G, W6
OUT E, W7
IN E, W5
OUT E, N6
IN A, W3
OUT A, E6
IN D, N8
OUT D, N1
IN F, E1
IN A, W3
OUT A, E6
IN D, N8
OUT D, S7
IN H, E5
OUT H, E8
IN G, N2
OUT G, S8
OUT F, N2
PLUS
Best regards,
Brian Trial
--------------------------------
Hi Ed...
Just a note to add my vote of approval for the Fractal maze.
I discussed the ins and outs of solving it will several
people - tho' never got round to trying. I assumed there
would be much deeper recursion so it would really need a
solver. Interesting to read the feedback from others. I'm
tempting to try what Oskar suggests (my first thought was
a 4x4x4 would be quite hard enough - so why not try generating
a few) - but not sure I'll find the time. Fascinating idea.
Andrea
www.clickmazes.com
--------------------------------
What a great maze! I loved solving it.
Solution:
From negative battery
Enter maze C at top 6
Enter maze A at left 3
Exit maze A at right 6
Enter maze D at top 8
Exit maze D at bottom 7
Enter maze H at right 5
Exit maze H at right 8
Enter maze G at top 2
Exit maze G at bottom 8
Exit maze C at bottom 8
Get to positive battery
Luke Pebody
-----------------
Perhaps you could help me with a way to express my solution, as I'm finding
it a bit awkward.
In C (through the top-side, 3rd pin from the right)
in A (through the left-side, 3rd pin from the top)
out A (through the right-side, 3rd pin from the bottom)
in D (top-side, rightmost pin)
out D (bottom-side, 2nd pin from the right)
in H (right-side, 4th from the bottom)
out H (right-side, bottommost pin)
in G (top-side, 2nd pin from the left)
out G (bottom-side, rightmost pin)
Out C (bottom-side, rightmost pin) --> PLUS
Travis Taylor
____________
Ed,
An interesting problem. I would be interested to know if there are other solutions other than the one I came up with. Or how quickly a computer was able to find the solution if programming a traditional search routine. (I did this solution by hand.)
Short answer: Enter C, pass through A, pass through D, pass through H, pass through G, exit C and proceed to +.
Thanks for the fun.
Dr. Matthew E. Coppenbarger
----------------------------------------------
from MINUS
go to into C at node 1 (my notation labels the nodes of each sub-maze clockwise starting at the top left)
exit C from node 7
go to E and enter at node 3
exit E using node 2
go to A and enter at node 7
exit A at node 4
go to D and enter at node 3
exit D at node 1
go to F and enter at node 5
(note we are still within F)
go to A and enter at node 7
exit A at node 4
(note we are still within F)
go to D and enter at node 3
this time we exit D at node 6
(note we are still within F)
go to H and enter at node 4
exit H at node 5
(note we are still within F)
go to G and enter at node 2
exit G at node 6
(note we are still within F)
now exit F at node 2
go to PLUS
Colin Backhurst - very interesting maze
----------------------------------------------
A solution to the fractal maze is
- C6 CA30 CA14 CD8 CD18 CH13 CH16 CG2 CG17 C17 +
The contacts are numbered clockwise from 1 to 32, with 1 in the upper
left.
Alex Fink
-----------------------------------------------
There was no way I was going to solve the Fractal Maze by hand. It is
too "mind blowing". But I did write a program to solve it with a
modified breadth-first search. To reduce the number of states searched,
at each iteration I only probed into the new states in the outermost
layer. Where the pins are numbered 00 to 31 starting at the left pin on
the top side and proceeding clockwise, and nodes inside nested mazes are
preceded by the letters of all nested mazes, the solution path is:
-, C05, CA29, CA13, CD07, CD17, CH12, CH15,, CG01, CG16, C16, +
Here's my program, in Python. I modified it to not stop at the first
solution, and it found this other path:
-, C05, C27, E08, E05, A29, A13, D07, D00, F08, FA29, FA13, FD07, FD17,
FH12, FH15, FG01, FG16, F01, +
But since it prunes any paths that lead into already explored states, it
won't find other paths which lead into some portion of these solutions.
It ran for a while without finding any path to the other exits.
#!/usr/bin/python
#
# Solve Mark J P Wolf's Fractal maze, from mathpuzzle.com October 18, 2003.
#
# Plan of attack is a mutant breadth-first search. At any given step, we will
# explore all new states at the outermost level at which there are new states.
newstates=[["A02","C05","E02","E24"]]
done={}
done["A02"]=["-"]
done["C05"]=["-"]
done["E02"]=["-"]
done["E24"]=["-"]
smap={}
smap["00"]=["07","17"]
smap["01"]=["16","21","G16"]
smap["02"]=["11","30","F03"]
smap["03"]=["10","26","B22"]
smap["04"]=["14","18","A07","C28"]
smap["05"]=["08","27","A29","E05"]
smap["06"]=["B02"]
smap["07"]=["00","17"]
smap["08"]=["05","27","A29","E05"]
smap["09"]=["B19"]
smap["10"]=["03","26","B22"]
smap["11"]=["02","30","F03"]
smap["12"]=["15","19","H10"]
smap["13"]=["20","29","31","C22"]
smap["14"]=["04","18","A07","C28"]
smap["15"]=["12","19","H10"]
smap["16"]=["01","21","G16"]
smap["17"]=["00","07"]
smap["18"]=["04","14","A07","C28"]
smap["19"]=["12","15","H10"]
smap["20"]=["13","29","31","C22"]
smap["21"]=["01","16","G16"]
smap["22"]=["G18"]
smap["23"]=["G19"]
smap["24"]=["G09"]
smap["25"]=["G26"]
smap["26"]=["03","10","B22"]
smap["27"]=["05","08","A29","E05"]
smap["28"]=["H03"]
smap["29"]=["13","20","31","C22"]
smap["30"]=["02","11","F03"]
smap["31"]=["13","20","29","C22"]
osmap={}
osmap["A07"]=["04","14","18","C28"]
osmap["A09"]=["B01"]
osmap["A13"]=["D07"]
osmap["A17"]=["B30"]
osmap["A27"]=["C08"]
osmap["A29"]=["05","08","27","E05"]
osmap["B01"]=["A09"]
osmap["B02"]=["06"]
osmap["B11"]=["D09"]
osmap["B19"]=["09"]
osmap["B21"]=["D01"]
osmap["B22"]=["03","10","26"]
osmap["B30"]=["A17"]
osmap["C08"]=["A27"]
osmap["C12"]=["F00"]
osmap["C16"]=["+"]
osmap["C19"]=["F20"]
osmap["C22"]=["13","20","29","31"]
osmap["C27"]=["E08"]
osmap["C28"]=["04","14","18","A07"]
osmap["D00"]=["F08"]
osmap["D01"]=["B21"]
osmap["D07"]=["A13"]
osmap["D09"]=["B11"]
osmap["D16"]=["+"]
osmap["D17"]=["H12"]
osmap["D21"]=["F13"]
osmap["D29"]=["F10"]
osmap["D31"]=["F07"]
osmap["E05"]=["05","08","27","A29"]
osmap["E08"]=["C27"]
osmap["E09"]=["F29"]
osmap["E17"]=["G04"]
osmap["E20"]=["G00"]
osmap["E23"]=["+"]
osmap["E25"]=["E27"]
osmap["E27"]=["E25"]
osmap["F00"]=["C12"]
osmap["F01"]=["+"]
osmap["F03"]=["02","11","30"]
osmap["F07"]=["D31"]
osmap["F08"]=["D00"]
osmap["F10"]=["D29"]
osmap["F13"]=["D21"]
osmap["F20"]=["C19"]
osmap["F24"]=["H06"]
osmap["F29"]=["E09"]
osmap["F31"]=["G25"]
osmap["G00"]=["E20"]
osmap["G01"]=["H15"]
osmap["G04"]=["E17"]
osmap["G09"]=["24"]
osmap["G14"]=["H25"]
osmap["G16"]=["01","16","21"]
osmap["G18"]=["22"]
osmap["G19"]=["23"]
osmap["G25"]=["F31"]
osmap["G26"]=["25"]
osmap["H03"]=["28"]
osmap["H06"]=["F24"]
osmap["H10"]=["12","15","19"]
osmap["H12"]=["D17"]
osmap["H15"]=["G01"]
osmap["H16"]=["+"]
osmap["H25"]=["G14"]
def gofrom(state):
#return the list of states which can be reached from the specified state
depth=len(state)-2
ns=[]
#part 1: go up a level, or out to another circuit on the same level
#look for state[-3:] in osmap
if osmap.has_key(state[-3:]):
stem=state[:-3]
for st in osmap[state[-3:]]:
#filter out paths to "01" and "B+" and the like
if stem=="":
if len(st)!=2:
ns.append(stem+st)
else:
if st!="+":
ns.append(stem+st)
#part 2: explore within/go down a level
#state[-2:] should always be in smap
stem=state[:-2]
for st in smap[state[-2:]]:
#filter out paths to +
if st!="+":
ns.append(stem+st)
return ns
while not done.has_key("+"):
#locate new states to process
lev=-1
for i in range(len(newstates)):
if newstates[len(newstates)-i-1]!=[]:
lev=len(newstates)-i-1
if lev==-1:
hell="Ran out of states to explore."
print done.keys()
raise hell
states=newstates[lev][:]
newstates[lev]=[]
for sta in states:
ns=gofrom(sta)
for st in ns:
if not done.has_key(st):
done[st]=done[sta]+[sta]
if len(newstates)