A maze generator in the shape of a maze whose corridors spell a 4-letter word:
char*M,A,Z,E=40,J[40],T[40];main(C){for(*J=A=scanf(M="%d",&C);
-- E; J[ E] =T
[E ]= E) printf("._"); for(;(A-=Z=!Z) || (printf("\n|"
) , A = 39 ,C --
) ; Z || printf (M ))M[Z]=Z[A-(E =A[J-Z])&&!C
& A == T[ A]
|6<<27<rand()||!C&!Z?J[T[E]=T[A]]=E,J[T[A]=A-Z]=A,"_.":" |"];}
char M[3],A,Z,E=40,J[40],T[40];main(C){for(*J=A=scanf("%d",&C);
If I squeeze the eyes I can read the "MAZE". :)
Sadly neither version works here with an older clang on OS X. Both variants build fine with 9 warnings each. But the old variant dies with a "Bus Error: 10", and the new variant with "Segmentation fault: 11". Same with gcc (albeit only 8 warnings.)
/edit
OK, just wrong user input. You gotta feed it a number, and not a "foobar" or another random string.
Amazing! I read you article in 2012 when the link was https://homepages.cwi.nl/~tromp/maze.html I was learning Haskell and Ocaml and wrote my own article in Chinese then https://maskray.me/blog/2012-11-02-perfect-maze-generation
Now I should fix the link.
Lovely page. Reminds me of the venerable Think Labyrinth (https://www.astrolog.org/labyrnth/algrithm.htm) page, but the live demos add a lot.
My favorite maze algorithm is a variant of the growing tree algorithm - each time you carve a cell, add it to a random one of N lists. When choosing a cell to visit, pop the last cell off the first non-empty list. It's considerably faster than the standard tree algorithm, but more importantly, changing N has a dramatic impact on the texture of the maze (compare 1 2 4 8 etc on a decently large maze).
For anyone interested in this, Jamis Buck's book 'Mazes for Programmers' is a masterpiece of the genre.
My personal favorite distinction is between the Recursive Backtracker (which creates long, winding corridors with few dead ends which is great for tower defense games) vs. Prim's Algorithm (which creates lots of short cul-de-sacs which is better for roguelikes). The bias of the algorithm dictates the feel of the game more than the graphics do.
Mike Bostock had several very lovely visualizations back on the D3.js site which I can't find. Here's a cool blogpost he wrote: https://bost.ocks.org/mike/algorithms/#maze-generation
Related? https://news.ycombinator.com/item?id=7632092 (April 2014)
I used Jamis' book extensively to build this AI tool for generating custom mazes of any shape! https://kamens.com/blog/generating-custom-mazes-with-ai
The main difference between the above tool and most custom shaped maze generators out there is breaking the assumption that the maze's outer shape must be defined by adding or removing regularly-shaped cells along the edge.
To have mazes look more human drawn, cells need to be irregular and the inner walls need naturally follow the contours of the outer shape.
You show an impressive variation of mazes, cool!
I've always known about algorithms that solve mazes, but never about actually making them. It's interesting seeing all these algorithms and how the mazes they generate look different.
Related:
Maze Generation: Recursive Division (2011) - https://news.ycombinator.com/item?id=42703816 - Jan 2025 (12 comments)
Maze Algorithms (2011) - https://news.ycombinator.com/item?id=23429368 - June 2020 (22 comments)
Representing a Toroidal Grid - https://news.ycombinator.com/item?id=10608476 - Nov 2015 (2 comments)
Maze Generation: Recursive Backtracking - https://news.ycombinator.com/item?id=4058525 - June 2012 (1 comment)
Maze Generation: Weave mazes - https://news.ycombinator.com/item?id=4052856 - June 2012 (3 comments)
Maze-generation algorithms, with JS demos - https://news.ycombinator.com/item?id=2190017 - Feb 2011 (9 comments)
Generating random mazes with the Growing Tree algorithm (w/ Javascript demo) - https://news.ycombinator.com/item?id=2148348 - Jan 2011 (6 comments)
Maze Generation: Wilson's algorithm - https://news.ycombinator.com/item?id=2123695 - Jan 2011 (11 comments)
Maze Generation: Kruskal's Algorithm - https://news.ycombinator.com/item?id=2062999 - Jan 2011 (9 comments)
Maze Generation: Eller's Algorithm - https://news.ycombinator.com/item?id=2048752 - Dec 2010 (9 comments)
Also:
Wilson's Algorithm - https://news.ycombinator.com/item?id=45549017 - Oct 2025 (9 comments)
Maze Tree - https://news.ycombinator.com/item?id=7746822 - May 2014 (38 comments)
Solving a Maze with D3.js - https://news.ycombinator.com/item?id=7631864 - April 2014 (19 comments)
Think Labyrinth: Maze Algorithms - https://news.ycombinator.com/item?id=10101728 - Aug 2015 (10 comments)
Practical algorithms and code optimization: maze generation - https://news.ycombinator.com/item?id=5431561 - March 2013 (10 comments)
Maze Algorithms - https://news.ycombinator.com/item?id=157266 - April 2008 (1 comment)
Others?
I especially like this one:
https://news.ycombinator.com/item?id=45549017
Wilson’s Algorithm gives the most pleasing visual results for me.
Added above - thanks!
of course! :D (how to approach the development of a maze algorithm)
That's not a good link for a list of past threads since the idea for the latter is to include only the ones with interesting comments.
However, it looks like a good article that could use a repost! Just not soon, since we want to give enough time for the hivemind caches to clear :) - if you want to repost it in (say) a month or two, email us at hn@ycombinator.com and we'll put it in the SCP (https://news.ycombinator.com/item?id=26998308).
Is it known which algorithms produce 'difficult' mazes? I'm imagining you could run all the maze solving algorithms against all the maze generating algorithms many times, and then calculate what the Nash equilibrium would be if the solver is trying to minimise expected time and the generator is trying to maximise it.
There is another old site ("since September 23, 1996"), my second favorite maze site, that has some articles about things like that. Like on the page below ("Tips on how to create difficult and fun Mazes, and how to solve and analyze them").
https://www.astrolog.org/labyrnth/psych.htm
I think there is a difference if you want to make it only expensive to solve using popular maze solver algorithms, vs to make it difficult for a human to solve. Many of the recommendations on that page are for how to do things that can make a maze more difficult for humans to solve, but will not always matter to an algorithm that just mechanically tries solutions in some order.
This is the kind of stuff I come here for.
seconding the jamis buck book, its one of the few programming books i actually finished. the way he explains each algorithm with visualizations makes it stick
It feels like many of the more complicated algorithms produce worse mazes (long horizontal/vertical walls, many 1-2 square dead ends next to another) than basic recursive backtracking.