Der berühmte C64 Basic One Liner

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

druckt ein Labyrinth aus Schrägstrichen und Backslashes.

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

Lies in einem solchen Labyrinth aus diagonalen Wänden aus Standard und drucke dasselbe Labyrinth mit horizontalen und vertikalen Wänden aus, die aus dem Wandzeichen "#" bestehen.

Zum Beispiel das kleine Labyrinth

/\\
\\/
///

wird übersetzt in

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

     #####    

Genauer gesagt hat jedes isolierte Wandsegment die Länge von fünf Zeichen, benachbarte Wandsegmente teilen sich eine Ecke. Das Verschieben eines Zeichens nach rechts / links / oben / unten in der Matrix aus Schrägstrichen und umgekehrten Schrägstrichen entspricht einer diagonalen Übersetzung um 2 Zeichen in vertikaler und 2 Zeichen in horizontaler Richtung in der # -Matrix.

Python 3, 226 224 Bytes

Mein erster Python Golf, also wohl sehr suboptimal. Es wird eine ganze Reihe von nachgestellten Leerzeichen erzeugt, aber es gibt keine vorangestellten Zeilenumbrüche und höchstens zwei vorangestellte Leerzeichen. Die Eingabe muss von Hand über die Befehlszeile erfolgen (vielleicht kennt jemand einen kürzeren Weg, um mehrzeilige Eingaben in Python zu erhalten ...).

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))

Die Idee ist, ein großes Array von Leerzeichen zu initialisieren r, dann die Eingabe zu durchlaufen und die Leerzeichen #nach Bedarf zu ersetzen und schließlich das gesamte Array zu drucken. Ein Trick, den ich verwendet habe, besteht darin, Zeichen zu vergleichen, z = '0'anstatt die Gleichheit mit '/'oder zu testen '\', wodurch eine Menge Bytes eingespart werden.

Julia, 258 Bytes

Eine funktionale Lösung ...

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

In der Reihenfolge des Auftretens: fdeckt '/' und '\' mit ihren 5 * 5-Bit-Mustern ab, hfaltet jede fünfte und folgende Zeile in eine einzelne Zeile ( siehe "benachbarte Wandsegmente teilen sich eine Ecke") und gmacht dasselbe für die Spalten. Zum Schluss i-j,i+jdreht sich das Bild.

JavaScript (ES6), 258

Eine Funktion mit dem Labyrinth als Parameter, die die Ausgabe zurückgibt.

Unsicher, ob es gültig ist, aufgrund der Eingabe- / Ausgaberegeln (es hat trotzdem Spaß gemacht)

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>