Labyrinth, das eine Zwischenlage erzeugt

15

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.

mschauer
quelle
Ein anderes Ausgabebeispiel wäre wahrscheinlich nützlich. Und ich erwarte, dass der Titel "one liner" sein sollte.
Calvins Hobbys
Wird das Eingabelabyrinth immer ein Rechteck sein? Könnten Sie ein größeres Beispiel geben, damit wir den Abstand sehen können?
Xnor
2
Willkommen beim Programmieren von Puzzles & Code Golf Stack Exchange! Große erste Herausforderung, aber ein paar Dinge: Kann Eingabe / Ausgabe etwas anderes als STDIN / STDOUT sein (z. B. als Funktionsargument und Rückgabewert)? Können Zeilen durch andere Zeichen als Zeilenumbrüche getrennt werden?
Türklinke
2
Die Verwendung von stdin und stdout ist nach Möglichkeit obligatorisch, ansonsten "das nächste Äquivalent". Gibt es Gründe, die Newline-Annahme zu schwächen?
Mschauer

Antworten:

5

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.

Zgarb
quelle
1

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.

mschauer
quelle
1

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>

edc65
quelle