Dasar satu liner C64 yang terkenal

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

mencetak labirin garis miring dan garis miring terbalik.

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

Baca dalam labirin seperti itu yang terbuat dari dinding diagonal dari stdin dan cetak labirin yang sama dengan dinding horizontal dan vertikal yang terdiri dari karakter dinding "#"

Misalnya labirin kecil

/\\
\\/
///

diterjemahkan menjadi

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

     #####    

Tepatnya, setiap segmen dinding yang terisolasi memiliki panjang lima karakter, segmen dinding yang berdekatan berbagi sudut. Memindahkan karakter ke kanan / kiri / atas / bawah dalam matriks garis miring dan garis miring terbalik sesuai dengan terjemahan diagonal oleh 2 karakter secara vertikal dan 2 karakter dalam arah horizontal dalam # -matrix.

Python 3, 226 224 byte

Golf Python pertama saya, jadi mungkin sangat sub-optimal. Ini menghasilkan banyak spasi spasi, tetapi tidak ada baris sebelumnya, dan paling banyak dua ruang sebelumnya. Input perlu diberikan dengan tangan dari baris perintah (mungkin seseorang tahu cara yang lebih pendek untuk mendapatkan input multiline dengan 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))

Idenya adalah untuk menginisialisasi array besar spasi r, kemudian beralih melalui input dan ganti spasi dengan yang #diperlukan, dan akhirnya cetak seluruh array. Trik yang saya gunakan adalah membandingkan karakter z = '0'daripada menguji kesetaraan dengan '/'atau '\', yang menghemat banyak byte.

Julia, 258 byte

Solusi fungsional ...

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

Dalam urutan penampilan: fmeliputi '/' dan '\' dengan patters 5 * 5 bit mereka, hlipat setiap kelima dan mengikuti baris menjadi satu baris (ingat "segmen dinding yang berdekatan berbagi sudut") dan gmelakukan hal yang sama untuk kolom. Akhirnya, i-j,i+jputar gambar.

JavaScript (ES6), 258

Fungsi dengan maze sebagai parameter, mengembalikan output.

Tidak yakin apakah itu valid, karena aturan input / output (pokoknya menyenangkan)

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>