Tôi biết có một chủ đề (cũ) tương tự như thế này ( ở đây ), nhưng tôi muốn khởi động lại nó với một số sửa đổi.

Mục tiêu: tạo ra một mê cung trông ngẫu nhiên bằng thuật toán bạn chọn, sau đó xuất ra mê cung bằng đồ họa (số lượng in).

• Chiều rộng và chiều cao được xác định bởi bạn.
• Cần có ít nhất một đường dẫn từ ít nhất một lối vào đến ít nhất một lối ra.
• Định dạng của mê cung (cách bạn hiển thị, đánh dấu lối vào hoặc lối ra) cũng tùy thuộc vào bạn.
• Càng xinh, càng tốt.
• Mê cung tầm thường (ví dụ mê cung trống, mê cung lưới, mê cung kích thước 1x1) không được khuyến khích.
• Chu kỳ trong mê cung được cho phép và, được khuyến khích, nếu kết quả là hợp lý.
• Lạm dụng ngôn ngữ khuyến khích.
• Mê cung sẽ trông hợp lý ngẫu nhiên (nhưng thuật toán hoàn toàn xác định (ví dụ hỗn loạn) tạo ra điều này cũng tốt).

Chỉnh sửa: trọng tâm chính ở đây là thực hiện nhỏ nhất có thể. Tuy nhiên, tôi muốn cho phép một số chậm trễ trong giới hạn đó để khuyến khích sự sáng bóng. Tôi đã cố tình để lại chính xác những "tính năng" mà mê cung đã kết thúc mở, nhưng như một hướng dẫn sơ bộ, bạn nên cố gắng đóng gói nhiều tiếng nổ nhất vào thùng ít từ vựng nhất.

C: 265 253 byte

#define f(v)for(v=0;v<k;++v)
#define d(q,n)case q:r(c+n,c+2*n);
z[4225],i,j,k=65;r(p,c){if(!z[c]){z[p]=z[c]=1;f(p)switch(rand()%4){d(0,-k)d(1,k)d(2,-1)d(3,1)}}}main(){f(i)z[i]=z[i+4160]=z[i*k]=z[i*k+64]=z[4157]=1;r(67,132);f(i)f(j)putchar(33-z[i*k+j]);}

(Yêu cầu thiết bị đầu cuối 65 ký tự) Tạo mê cung 31x31 tương đối ngẫu nhiên với một đường dẫn được đảm bảo từ lối vào đến lối ra.

Ví dụ đầu ra (với thiết bị đầu cuối 65 ký tự mô phỏng):

 ! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 
 !     !       !   !       !     !           !             !   ! 
 !!!!! !!! !!! ! !!! ! !!! ! !!! !!!!!!! !!! !!!!!!!!! !!! ! ! ! 
 !   !   !   ! !     ! ! ! ! ! ! !       !   !         !   ! ! ! 
 ! !!!!! !!! ! !!!!!!! ! ! ! ! ! ! !!!!!!! !!! ! !!!!!!! !!! ! ! 
 !     !     !         ! !   !   !     !   !   ! !     !   ! ! ! 
 ! !!! !!!!!!!!!!!!!!!!! !!!!! !!! !!! !!! ! ! !!! !!! !!! !!! ! 
 !   !         !     !   !     !     !   ! ! ! !     !   !   ! ! 
 !!!!!!!!!!! ! ! !!! !!! ! !!!!!!!!!!!!! ! !!! ! !!!!!!! !!! ! ! 
 !           !   !       ! !             !   !     !     !     ! 
 ! !!!!!!! !!!!!!! !!!!!!! ! !!!!!!!!!!!!!!! !!!!!!! !!!!!!!!!!! 
 ! !     ! !   !     !   ! !           !   !       ! !         ! 
 ! !!! ! ! ! ! !!!!!!! ! ! ! !!!!!!!!! ! ! !!!!!!! ! ! !!!!!!! ! 
 !   ! !   ! !       ! !   ! !         ! !       ! ! !   !   ! ! 
 !!! ! !!!!! !!!!!!! ! !!!!!!! !!!!!!!!! !!! !!!!! ! !!! ! !!! ! 
 !   !   ! ! !       !   !     !   !     ! !           ! !   ! ! 
 ! !!!!! ! ! ! !!!!!!!!! ! !!!!! !!! !!!!! !!!!!!!!!!! ! ! ! ! ! 
 ! !       ! !   !   !   ! !       ! !       !   !     ! ! ! ! ! 
 ! !!!!!!!!! !!! ! ! ! !!! !!!!!!! ! !!!!!!! ! ! !!!!!!! !!! ! ! 
 !             !   ! !   !       ! !     !   ! !             ! ! 
 !!!!!!!!!!!!!!!!!!! !!! !!!!!!! ! !!!!! ! !!! !!!!!!!!!!!!!!! ! 
 !               !   !   !       !         !   !     !   !     ! 
 ! !!!!!!!!!!!!! ! ! ! !!! !!!!!!! !!!!!!!!! !!! !!! !!! ! !!! ! 
 ! !   !       !   ! ! ! !     ! ! ! !     !     !   !   !   ! ! 
 ! ! ! !!!!! !!!!!!! ! ! ! !!! ! ! ! ! !!! !!!!!!! !!! !!!!! !!! 
 !   ! !   !       ! ! !     ! !     ! ! !     !   !       !   ! 
 !!!!! ! ! !!! !!! ! ! !!!!!!! !!!!!!! ! ! !!! ! !!!!!!!!! !!! ! 
 !     ! !   !   !   !       !       ! ! ! !   !   !         ! ! 
 ! !!!!! !!! !!! !!!!!!!!!!! !!!!!!! ! ! ! !!!!!!! ! !!!!!!! ! ! 
 !         ! !           !   !       ! ! !     !   ! !       ! ! 
 !!!!!!!!!!! !!!!!!!!!!! ! !!! !!!!!!! ! !!!!! ! !!! !!!!!!!!! ! 
 !         !     !     ! ! !       !   !     ! !     !         ! 
 ! !!!!!!! !!!!! ! !!! !!! !!!!!!! ! !!!!! ! ! !!!!! ! !!!!!!!!! 
 ! !     !     !   ! !   !       ! !       ! !       !         ! 
 ! ! !!! !!!!! ! !!! !!! !!!!!!! ! !!!!!!!!! !!!!!!!!!!!!!!!!! ! 
 !     !     ! !   !   ! !     ! !       !   ! !     !         ! 
 !!!!!!!!!!! ! !!! !!! ! ! ! !!! ! ! !!!!! !!! ! !!! ! !!!!!!! ! 
 !           ! !       !   ! !   ! !       !   ! ! ! !     !   ! 
 ! !!!!!!!!!!! !!!!!!!!!!!!! ! !!! !!!!!!!!!!! ! ! ! ! !!! ! !!! 
 !       !   !             ! ! ! !   !         ! !   !   ! ! ! ! 
 !!!!!!! !!! !!!!!!!!!!!!! ! ! ! !!! ! !!!!!!! ! !!! !!!!! ! ! ! 
 !       !         !     ! ! ! !   !   !     ! !   !       !   ! 
 ! !!!!!!! !!!!!!! ! !!!!! ! ! !!! !!!!!!! ! ! !!! !!!!!!!!!!!!! 
 !   !         ! !   !       ! !           ! !   !             ! 
 ! ! ! !!!!!!! ! ! !!! !!!!!!! ! !!!!!!!!!!! ! !!!!!!!!!!!!!!! ! 
 ! ! ! !     ! !   !   ! !     !   !   !     ! !               ! 
 ! ! !!! !!! ! !!!!! !!! ! !!!!! ! ! ! !!!!!!! ! !!!!!!!!!!!!! ! 
 ! !   !   ! !   !       !   !   !   !         ! !         !   ! 
 !!!!! !!! ! !!! ! !!!!!!!!! !!!!!!! !!!!!!!!!!! !!!!! !!!!! !!! 
 !     !   !   !   !       !       !       !   !     !       ! ! 
 ! !!!!! !!!!! !!!!! !!!!! !!!!!!! !!!!!!!!! ! !!!!! !!!!!!! ! ! 
 !           !     ! !   !   !   !           !   !   !     !   ! 
 ! !!!!!!!!! !!!!! ! !!! ! !!! ! !!!!!!!!!!!!!!! ! !!! !!! !!! ! 
 ! !     !       ! !     !     !     !         ! !       !   ! ! 
 !!! !!! !!!!!!!!! !!!!! !!!!!!!!! ! !!!!!!! !!! ! !!!!!!!!! ! ! 
 !   !     !   !   !   ! !       ! !         !   ! !         ! ! 
 ! !!!!!!! ! ! ! ! !!! ! !!!!!!! ! !!!!!!!!! ! !!!!! !!!!!!!!! ! 
 !       !   !   ! !   !         !   ! !   ! ! !     !       ! ! 
 ! !!!!! !!!!!!!!! ! !!!!!!!!!!! !!! ! ! ! ! ! ! !!!!! !!!!! ! ! 
 ! !     !           !         ! ! ! !   !   ! !   !   !     ! ! 
 ! ! !!!!!!!!!!!!!!!!! !!! !!!!! ! ! !!!!!!!!! !!! ! !!!!!!!!! ! 
 ! !                     !         !               !           ! 
 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! 

Toán học, 144 132 byte

Kể từ khi thành lập, tất cả chúng ta đều biết cách hiệu quả nhất để vẽ một mê cung .

c=0;Graphics@Most[Join@@{Circle[{0,0},i,{a=c-(r=Random[](d=2Pi-1/i)&)[],a+d}],Line[{{i},{i+1}}.{{Cos[c=a+r[]],Sin@c}}]}~Table~{i,9}]

Đầu ra và ví dụ:

Tất nhiên, các dòng là các bức tường. Bạn là minotaur, người bắt đầu ở trung tâm và cần phải ra ngoài.

C: 364 byte

#define I int
m[1600],i=0,r;f(I x,I y,I l){m[80*y+x]|=l;I d[]={x-1,y,2,1,x+1,y,1,2,x,y-1,8,4,x,y+1,4,8},
s[]={5,5,5,5},j=0;for(;j<4;){L:r=rand()%4;for(I k=0;k<4;)if(s[k++]==r)goto L;s[j]=r;I*p=d+
4*s[j++],X=p[0],Y=p[1];if(!(X<0|X>79|Y<0|Y>19|m[80*Y+X])){f(X,Y,p[2]);m[80*y+x]|=p[3];}}}
main(){f(0,0,4);m[9]|=4;for(;i<1600;)putchar("#5FMP<HJR;IK:9LN"[m[i++]]+128);}

Lưu ý: ở trên, tôi đã thêm dòng mới để làm cho nó phù hợp trên trang. Đầu ra dự kiến ​​(trên thiết bị đầu cuối 80 ký tự) (ghi chú bắt đầu và kết thúc ở trên cùng bên trái):

Toán học, 134 130 ký tự

Graph[Range@273,Reap[Do[c@n/._c:>#0[Sow[#<->n];n],{n,RandomSample@AdjacencyList[g=GridGraph@{13,21},c@#=#]}]&@1][[2,1]],Options@g]

Trên thực tế, chúng ta có thể sử dụng thuật toán này để tạo ra một mê cung từ bất kỳ đồ thị (không xác định) nào.

Ví dụ: tạo mê cung từ biểu đồ tham quan của hiệp sĩ 8 * 8 ( KnightTourGraph[8,8]):

Graph[Range@64,Reap[Do[c@n/._c:>#0[Sow[#<->n];n],{n,RandomSample@AdjacencyList[g=KnightTourGraph[8,8],c@#=#]}]&@1][[2,1]],Options@g]

Bash, 53 byte

w=(╱ ╲);while true;do echo -n ${w[RANDOM%2]};done

Ý tưởng tương tự với mã C64. Sử dụng các ký tự Unicode làm dấu gạch chéo vì chúng trông đẹp hơn nhiều trong một thiết bị đầu cuối hỗ trợ Unicode. Đầu ra mẫu trên OS X Terminal (phông chữ Menlo):

JavaScript (ES6), 174

Đây là người xây dựng mê cung mà tôi đã sử dụng trong thử thách khác này , chỉ chơi gôn. Đây là một hàm có 2 tham số: hàng và cột. Mê cung hoàn toàn được kết nối không có vòng lặp, vì vậy bất kỳ vị trí nào cũng có thể là điểm bắt đầu hoặc điểm kết thúc.

(r,c,o=2*c+2,i=2*r*o+o,z=[],F=(p,i=Math.random()*4)=>[o,1,-o,-1].map((s,j,d)=>z[s=p+2*d[j+i&3]]>0&&(z[s]=z[(p+s)/2]=' ',F(s))))=>{for(;i--;)z[i]=i%o?8:`\n`;F(o+2);return''+z}

Thí dụ

f(7,10)

Đầu ra

,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
,8, , , ,8, , , , , ,8, , , , , , , , , ,8,
,8, ,8, ,8,8,8, ,8, ,8,8,8,8,8,8,8, ,8, ,8,
,8, , , ,8, , , ,8, , , ,8, , , , , ,8, ,8,
,8, ,8,8,8, ,8,8,8,8,8, ,8, ,8,8,8,8,8, ,8,
,8, ,8, , , , , ,8, ,8, ,8, ,8, , , , , ,8,
,8, ,8, ,8,8,8, ,8, ,8, ,8, ,8, ,8,8,8,8,8,
,8, ,8, ,8, , , ,8, , , , , ,8, ,8, , , ,8,
,8, ,8, ,8, ,8,8,8,8,8,8,8,8,8, ,8, ,8,8,8,
,8, ,8, ,8, , , , , , , ,8, , , ,8, , , ,8,
,8, ,8, ,8,8,8,8,8,8,8, ,8,8,8, ,8,8,8, ,8,
,8, ,8, , , , , , , ,8, , , ,8, , , , , ,8,
,8, ,8,8,8,8,8,8,8,8,8,8,8, ,8,8,8,8,8, ,8,
,8, , , , , , , , , , , , , ,8, , , , , ,8,
,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8

Kiểm tra

f=
(r,c,o=2*c+2,i=2*r*o+o,z=[],F=(p,i=Math.random()*4)=>[o,1,-o,-1].map((s,j,d)=>z[s=p+2*d[j+i&3]]>0&&(z[s]=z[(p+s)/2]=' ',F(s))))=>{for(;i--;)z[i]=i%o?8:`\n`;F(o+2);return''+z}
    
function update() {    
  O.textContent='';
  [r,c]=I.value.match(/\d+/g)
  O.textContent=f(r,c)
}  

update()

pre { line-height: 0.8em }

Rows,Columns <input id=I oninput='update()' value='8,12'>
<pre id=O></pre>

ZX cơ bản - 54 ký tự

a$="/\":for i=1 to 24*32:print a$(1+int(rnd*2));:next

Đây là mê cung hiển thị một tuyến đường xuyên qua nó (khoảng cách giữa các dòng)

và một đoạn nhỏ từ khi tôi mới làm điều này (vài năm trước) và dành một chút thời gian để làm đồ họa tốt hơn.

BBC BASIC, 18 byte

Một cải tiến về độ dài trên phiên bản vòng lặp vô hạn C64 23 byte của @nneonneo. VDU gửi một ký tự duy nhất đến bộ điều khiển VDU: 2 + 1 * 45 = ASCII 47 /hoặc 2 + 2 * 45 = ASCII 92\

  VDU2+RND(2)*45:RUN

BBC BASIC, 35 byte / 107 95 byte

35 byte chỉ dành cho dòng cuối cùng, cung cấp một mê cung 25 hàng trong bố cục 40 cột. MODE1 đảm bảo rằng không còn khoảng trống thừa giữa các dòng. Phần còn lại của chương trình là tùy chọn và cải thiện định dạng. Các câu lệnh VDU23 xác định lại phông chữ cho các ký tự 47 và 92 (8 byte tạo thành một bitmap 8x8.) Tôi bao gồm một pixel ánh sáng ở cả bốn góc để ngăn không cho chạy thẳng bị chèn ép. Tác dụng phụ của việc này là một chấm xuất hiện trong những viên kim cương rỗng. Tổng cộng 107 byte bao gồm 2 dòng mới.

  VDU23,47,131,7,14,28,56,112,224,193
  VDU23,92,193,224,112,56,28,14,7,131
  MODE9FORa=0TO999VDU2+RND(2)*45:NEXT

Chỉnh sửa chương trình này có thể được rút ngắn xuống 95 byte bằng cách mã hóa một số mã VDU 8 bit thành các giá trị endian nhỏ 16 bit (ký hiệu là dấu chấm phẩy sau chúng thay vì dấu phẩy) và biểu thị câu lệnh MODE dưới dạng một cặp mã VDU, như sau .

VDU23,47,1923;7182;28728;49632;23,92,57537;14448;3612;33543;22,9:FORa=0TO999VDU2+RND(2)*45:NEXT

Đầu ra

Sử dụng BBC Basic cho Windows từ bbcbasic.co.uk

Chỉ dòng cuối cùng, 35 byte

Toàn bộ chương trình, 107 95 byte

Như tôi đã nhận xét về câu trả lời của @ Brian, dấu gạch chéo chia hình vuông thành 2 hình tam giác tối, mỗi hình có chính xác 2 lối vào / lối ra. Điều này đảm bảo một con đường (tầm thường, không phân chia) từ bất kỳ điểm nào trên rìa mê cung đến một điểm khác trên rìa mê cung. Nhiều trong số này rất ngắn, nhưng dường như luôn có một vài cái dài. Tất nhiên, ở giữa mê cung cũng có một số vòng lặp.

Vì các câu trả lời khác không đề cập đến nó, tôi muốn nhìn kỹ vào các khu vực ánh sáng. Chúng bị giới hạn bởi các vùng tối, do đó, như một hệ quả của tuyên bố đưa ra ở trên, một vùng ánh sáng được giới hạn bên ngoài bởi N vùng tối chạm vào rìa của trường tại điểm N (chính xác là nhiều). Do đó, một số vùng ánh sáng khá lớn xảy ra và những dạng mê cung phân nhánh này rất thú vị.

Trong ví dụ dưới đây, bạn có thể thấy đầu ra thô (đơn sắc) từ chương trình của tôi. Bên dưới đó (sử dụng Windows Paint) tôi đã tô màu hai vùng tối dài nhất màu xanh lam. Sau đó, tôi tô màu khu vực ánh sáng lớn nhất bằng màu vàng và hai khu vực giới hạn bởi màu xanh lam là màu đỏ và màu xanh lá cây. Các mê cung màu vàng, xanh lá cây (và thậm chí là màu đỏ) khá thú vị và không tầm thường.

EDIT - Tự động chọn mê cung và lựa chọn bắt đầu / kết thúc

Đối với một dòng nữa (59 ký tự), chương trình có thể tự động chọn ra tối đa 6 mê cung bằng cách chọn hình vuông ngẫu nhiên và lấp đầy các màu đỏ, xanh lá cây, vàng, xanh dương, đỏ tươi và lục lam. Nó không phải lúc nào cũng tìm thấy đủ 6, bởi vì nếu nó chọn một hình vuông ngẫu nhiên đã được tô màu thì nó không làm gì cả.

Phần còn lại của mã bên dưới chọn ra một khởi đầu cho mỗi màu bằng cách quét từng cột từ trên xuống dưới và từ trái sang phải và chọn ô vuông đầu tiên mà nó gặp. Nó chọn một kết thúc bằng cách quét theo hướng ngược lại.

Điều này tạo ra một tập hợp các mê cung đầy màu sắc, đan xen. Đôi khi chúng đan xen vào nhau trông giống như những mê cung phải băng qua đâu đó. Nhưng tất nhiên, họ không!

Mã bổ sung và đầu ra 59 + 187 = 246 ký tự bổ sung sẽ được thêm vào cuối chương trình gốc (để nâng cao ngoài thông số câu hỏi.)

  GCOL135FORa=1TO6GCOLa FILLRND(40)*32-16,RND(25)*32+208:NEXT   :REM set background to grey so fill can identify. For each colour 1 to 6, pick a point in the centre of a character and flood fill (characters are logically 32x32 although they are physically only 8x8 pixels.)
  f=126:g=126                                                   :REM flags 1111110 to indicate which starts and ends have not been allocated yet
  FORx=0TO39FORy=0TO24                                          :REM maze is 40x25. There is some blank space at the bottom of the screen (32 rows total)
  p=POINT(x*32+16,1008-y*32)                                    :REM check start point. Text origin is at top of screen, Graphics origin is at bottom, 1280x1024 logical. therefore y offset is 1024-32/2=1008.
  IFf AND2^p f=f-2^p:VDU31,x,y,17,p,79                          :REM if start for colour P has not been allocated yet, allocate it now. VDU31,X,Y go to that square. VDU 17,p select text colour. VDU 79 print an "O"                 
  p=POINT(1264-x*32,240+y*32)                                   :REM check end point
  IFg AND2^p g=g-2^p:VDU31,39-x,24-y,17,p,79                    :REM if end for colour P has not been allocated yet, allocate it now.
  NEXT:NEXT
  VDU31;26                                                      :REM get the cursor off the board. Move to (0,26). Semicolon used instead of comma here indicating that 31 is a 16 bit small endian value, equivalent to VDU31,0,26 or PRINTTAB(0,26)

C: 235 byte

#define P(X,Y)M[(Y+40)*80+X+40]=rand()%49/6;
#define B(X,Y)P(X,Y)P(Y,X)
M[6400],r,i;main(){for(i=0;i<40;i+=2){int x=i,y=0,e=1-x;while(x>=y)
{B(x,y)B(-x,y)B(-x,-y)B(x,-y)++y;e+=e<0?2*y+1:2*(y-x--);}}for(i=0;
i<6400;)putchar(64>>!M[i++]);}

Lưu ý: ở trên, tôi đã thêm dòng mới để làm cho nó phù hợp trên trang. Đầu ra dự kiến ​​(trên thiết bị đầu cuối 80 ký tự):

Tôi lấy làm tiếc rằng đây không phải là một mê cung rất khó khăn (trên thực tế, không yêu cầu quay lại các vòng trong (và bạn sẽ có thể tìm thấy một con đường từ chu vi đến trung tâm một cách tầm thường). Tuy nhiên, nó có một triển khai tốt đẹp của vòng tròn Bresenham vẽ thuật toán ở lõi của nó.

Tôi đã giúp con tôi làm điều này, để học một chút về lập trình: http://jsfiddle.net/fs2000/4KLUC 432 / bạn thích nó như thế nào?

Hàng hóa 64 BASIC - 38 byte

10 PRINT CHR$(205.5+RND(1)); : GOTO 10

Đây không phải là phát minh của tôi, tôi chỉ đơn giản là lặp lại một chương trình rất đẹp và ngắn từ những ngày đã qua. Trên thực tế, có cả một cuốn sách có tên 10 PRINT CHR$(205.5+RND(1)); : GOTO 10kỷ niệm đoạn mã này!

Bạn có thể thấy đầu ra trên video YouTube này ; đây là một screencap:

Ở đây tại câu hỏi StackOverflow này có nhiều triển khai hơn của chương trình tạo mê cung này. Việc triển khai chương trình ngắn nhất là chương trình C64 BASIC 23 byte sau đây được đăng bởi tác giả của câu hỏi đó:

1?cH(109.5+rN(1));:gO1

trong đó các chữ cái viết thường được nhập nguyên trạng và các chữ cái viết hoa được nhập bằng phím Shift (chúng có các chữ xuất hiện khác nhau trên màn hình C64 thực tế).

Java: 700

Đây là một trình cộng tường đệ quy. Thuật toán được phác thảo trên trang web này :

public class Z{int i,j,u=20,v=u,g[][]=new int[v][u];public static void main(String[]a){new Z().d(0,0,20,20,0).p();}int q(int m){return(int)(Math.random()*m);}<T>void z(T m){System.out.print(m);}void p(){for(i=0;i++<u*2;z("_"));for(i=0;i<v;i++){z("\n|");for(j=0;j<u;j++){boolean b=i+2>v,s=g[i][j]%2>0||b;z(s?"_":" ");z(g[i][j]>1||j+2>u?"|":s&(j+1<u&&g[i][j+1]%2>0||b)?"_":" ");}}}Z d(int x,int y,int w,int h,int o){int a=x,b=y,c=a,d=b,e,f;boolean t=o<1;if(t){b+=q(h-2);c+=q(w);}else{a+=q(w-2);d+=q(h);}for(i=t?w:h;i-->0;j=t?a++:b++)if(a!=c&&b!=d)g[b][a]|=t?1:2;e=t?w:a-x+1;f=t?b-y+1:h;if(e>2&&f>2)d(x,y,e,f,e<f?0:1);e=t?w:x+w-a-1;f=t?y+h-b-1:h;if(e>2&&f>2)d(t?x:a+1,t?b+1:y,e,f,e<f?0:1);return this;}}

Về cơ bản, nó chia mỗi hình chữ nhật thành hai với một bức tường (và lối đi), sau đó chia đôi thành hai, v.v ... Nó tạo ra một mê cung "hoàn hảo" - một không có chu kỳ - có đường dẫn từ mọi điểm đến mọi điểm khác. Rất nhiều ngõ cụt, vì vậy nó không "tầm thường" trong bất kỳ ý nghĩa nào đối với các mê cung lớn hơn.

Vì vậy, lối vào và lối ra có thể được quyết định tùy ý. Nếu tôi phải chọn một, nó sẽ chỉ nói trên / trái và dưới / phải.

Nó được vẽ bằng ascii có chiều rộng gấp đôi, vì vậy tốt nhất là bạn nên chuyển đầu ra thành tệp nếu bạn đang thực hiện một trong bất kỳ kích thước nào. Đây là 20x20 trong bảng điều khiển:

Và 100x100 trong notepad ++ (tôi phải thu nhỏ để lấy tất cả, vì vậy nó hơi ... nhỏ ):

Mã có ngắt dòng:

public class Z{
    int i,j,u=20,v=u,g[][]=new int[v][u];
    public static void main(String[]a){
        new Z().d(0,0,20,20,0).p();
    }

    int q(int m){return(int)(Math.random()*m);}
    <T>void z(T m){System.out.print(m);}

    void p(){
        for(i=0;i++<u*2;z("_"));
        for(i=0;i<v;i++){
            z("\n|");
            for(j=0;j<u;j++){
                boolean b=i+2>v,s=g[i][j]%2>0||b;
                z(s?"_":" ");
                z(g[i][j]>1||j+2>u?"|":s&(j+1<u&&g[i][j+1]%2>0||b)?"_":" ");
            }
        }
    }

    Z d(int x,int y,int w,int h,int o){
        int a=x,b=y,c=a,d=b,e,f;
        boolean t=o<1;
        if(t){
            b+=q(h-2);
            c+=q(w);
            }
        else{
            a+=q(w-2);
            d+=q(h);
        }

        for(i=t?w:h;i-->0;j=t?a++:b++)
            if(a!=c&&b!=d)
                g[b][a]|=t?1:2;

        e=t?w:a-x+1;f=t?b-y+1:h;
        if(e>2&&f>2)d(x,y,e,f,e<f?0:1);
        e=t?w:x+w-a-1;f=t?y+h-b-1:h;
        if(e>2&&f>2)d(t?x:a+1,t?b+1:y,e,f,e<f?0:1);
        return this;
    }
}

ZX cơ bản - 281 ký tự

Đây là nhiều hơn một mê cung "thích hợp", ít golf hơn, nhưng mê cung hơn. Vì vậy, được gọi là thuật toán mê cung nhị phân, mỗi ô có thể có một lối ra đi xuống hoặc phải, nhưng không phải cả hai. (Bây giờ bao gồm Bắt đầu "S" được đánh dấu và Kết thúc "E", để ngăn chặn việc đi thẳng dọc theo một bên).

"::" là cách ZXB nhập các ký tự đồ họa Spectrum vào tệp văn bản, tương đương với ký tự khối được bán.

randomize:border 1:paper 1:ink 6:cls
for x=0 to 30 step 2
 for y=0 to 20 step 2
  r=1+int(rnd*2)
  if x=30 and r=1 then 
   r=2
  end if
  if y=20 and r=2 then
   r=1
  end if
  print at y,x;"\::"
  print at y+(r=2),x+(r=1);"\::"
 next
next
print inverse 1;at 0,0;"S";at 20,31;"E"

C- 244

#include <unistd.h>
#include <windows.h>
int main(i,j,rv,rs){srand( time(0));for (i = 0; i < 80; i++)for (j = 0; j <50 ; j++){rv = rand() %10;rs = rand() %100;if(rs < 10 || rs  > 90)continue;if(rv<4){gotoxy(i,j);printf("%c", '#');}}return 0;}

Đây là cách nó trông như thế nào:

Lưu ý: giải pháp này được lấy cảm hứng từ trò chơi cấp 8 không đáng tin cậy : vào rừng.