C64 cơ bản nổi tiếng một lót

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

in một mê cung của dấu gạch chéo và dấu gạch chéo ngược.

\\/\\\//\/\////\\/\/
\/\///\\///////\//\/
/\\\//\//\////\\//\\
\////\//\//\/\\\\\\/
/\/\\///\\\\/\\\\/\\
\/\//\\\\\\//\/\////
/\//\\///\/\///\////
\/\\\//\\/\\\//\\/\/
//////\\/\\/\/\/\///
\\/\/\\////\/\/\\/\/

Đọc trong mê cung như vậy làm bằng các bức tường chéo từ stdin và in ra cùng một mê cung với các bức tường ngang và dọc bao gồm các nhân vật tường "#"

Ví dụ như mê cung nhỏ

/\\
\\/
///

Dịch sang

     #####
     #   #
     # # # #
     # # # #
 ##### # # #
       #   #
   #########

     #####    

Nói chính xác, mỗi phân đoạn tường bị cô lập có độ dài năm ký tự, các phân đoạn tường liền kề chia sẻ một góc. Di chuyển một ký tự sang phải / trái / trên / xuống trong ma trận dấu gạch chéo và dấu gạch chéo ngược tương ứng với một bản dịch chéo bởi 2 ký tự theo chiều dọc và 2 ký tự theo hướng ngang trong # -matrix.

Python 3, 226 224 byte

Golf Python đầu tiên của tôi, vì vậy có lẽ rất tối ưu. Nó tạo ra rất nhiều khoảng trắng theo sau, nhưng không có dòng mới nào trước và nhiều nhất là hai khoảng trắng trước. Đầu vào cần phải được cung cấp bằng tay từ dòng lệnh (có thể ai đó biết một cách ngắn hơn để nhận đầu vào đa dòng trong Python ...).

e,z,s=enumerate,'0',list(iter(input,""))
p=''.join(s)*5
r=[len(p)*[' ']for _ in p]
for y,l in e(s):
 for x,c in e(l):
  for i in range(-2,3):r[2*(x+y+(s>[z]))+i*(c>z)][2*(x+len(s)-y)+i*(c<z)]='#'
for l in r:print(''.join(l))

Ý tưởng là để khởi tạo một mảng lớn các không gian r , sau đó lặp qua các đầu vào và thay thế không gian với #khi cần thiết, và cuối cùng là in toàn bộ mảng. Một mẹo tôi đã sử dụng là so sánh các ký tự với z = '0'thay vì kiểm tra tính bằng '/'hoặc '\', giúp tiết kiệm một loạt byte.

Julia, 258 byte

Một giải pháp chức năng ...

A=split(readall(STDIN))
q(i,j)=fld(i-1,j)
n,^ =A[].(3),q
f(i,j)=try A[1+i^5][1+j^5]<'0'?(i+j)%5==1:(i-j)%5==0catch 0end
h(i,j)=f(i+i^4,j)|f(i+(i-1)^4,j)
g(i,j)=h(i,j+j^4)|h(i,j+(j-1)^4)
for i=1:6length(A),j=-n-5:2n;print(" #"[1+g(i-j,i+j)],j==2n?"\n":"")end

Theo thứ tự xuất hiện: fbao phủ '/' và '\' bằng các patters 5 * 5 bit của chúng, hgấp mỗi dòng thứ năm và theo sau thành một dòng duy nhất (nhớ lại "các đoạn tường liền kề chia sẻ một góc") và gthực hiện tương tự cho các cột. Cuối cùng, i-j,i+jxoay hình ảnh.

JavaScript (ES6), 258

Một hàm với mê cung là một tham số, trả về đầu ra.

Không chắc chắn nếu nó hợp lệ, do các quy tắc đầu vào / đầu ra (dù sao nó cũng vui)

f=m=>([...m].map(c=>{if(c<' ')x=sx-=2,y=sy+=2;else for(x+=2,y+=2,d=c>'0',i=y-3*d,j=x-3*!d,c=5;c--;)o[i+=d][j+=!d]='#';},w=m.search`
`,h=m.match(/\n/g).length,sy=y=0,sx=x=h*2,o=Array(z=(w+h+1)*2).fill(' ').map(x=>Array(z).fill(x))),o.map(r=>r.join``).join`
`)

// LESS GOLFED

U=m=>(
  w=m.search`\n`,
  h=m.match(/\n/g).length,
  o=Array(z=(w+h+1)*2).fill(' ').map(x=>Array(z).fill(x)),
  sy=y=0,
  sx=x=h*2,
  [...m].forEach(c=>{
    if(c<' ')x=sx-=2,y=sy+=2
    else for(x+=2,y+=2,d=c>'0',i=y-3*d,j=x-3*!d,c=5;c--;)o[i+=d][j+=!d]='#';
  }),
  o.map(r=>r.join``).join`\n`  
)

// TEST
out=x=>O.innerHTML+=x+'\n'

test=`\\\\/\\\\\\//\\/\\////\\\\/\\/
\\/\\///\\\\///////\\//\\/
/\\\\\\//\\//\\////\\\\//\\\\
\\////\\//\\//\\/\\\\\\\\\\\\/
/\\/\\\\///\\\\\\\\/\\\\\\\\/\\\\
\\/\\//\\\\\\\\\\\\//\\/\\////
/\\//\\\\///\\/\\///\\////
\\/\\\\\\//\\\\/\\\\\\//\\\\/\\/
//////\\\\/\\\\/\\/\\/\\///
\\\\/\\/\\\\////\\/\\/\\\\/\\/`
out(test),out(f(test))

<pre id=O></pre>