Herausforderung

Schreiben Sie ein Programm, das ein 11x11-Array von Ganzzahlen verwendet und ein 3D-ASCII-Blockgebäude erstellt, wobei jeder Wert im Array die Höhe einer Blockspalte an den Koordinaten darstellt, die mit der Arrayposition übereinstimmen. Eine negative Höhe ist eine "schwebende" Spalte - nur der obere Block ist sichtbar.

Beispiel

                                                        __________________
                                        ___            /\__\__\__\__\__\__\
 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,      /\__\          /\/\__\__\__\__\__\__\
 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,     /\/__/         /\/\/__/__/__/__/__/__/
 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,    /\/\__\        /\/\/\__\      /\/\/__/
 1, 0, 0, 7,-7,-7,-7,-7, 7, 0, 0,    \/\/\__\      /\/\/\/__/     /\/\/__/
 0, 0, 0, 7,-7,-7,-7,-7, 7, 0, 0,     \/\/__/     /\/\/\/\__\    /\/\/__/
 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0,      \/\__\    /\/\/\/\/__/   /\/\/__/
 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0,       \/__/    \/\/\/\/\__\_  \/\/__/
 1, 0, 0, 4, 3, 2, 1, 0, 0, 0, 1,                 \/\/\/\/__/_\_ \/__/
 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,            ___   \/\/\/__/__/_\_         ___
 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,           /\__\   \/\/__/__/__/_\       /\__\
 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1,           \/\__\   \/__/__/__/__/       \/\__\
                                             \/\__\_________         ______\/\__\
                                              \/\__\__\__\__\       /\__\__\__\__\
                                               \/__/__/__/__/       \/__/__/__/__/

Eingang

Die Eingabe ist eine Liste von 121 Ganzzahlen, die entweder von stdin gelesen (die Wahl des Trennzeichens liegt bei Ihnen) oder als Array übergeben werden (kann 1D oder 2D sein).

Die Höhen liegen im Bereich von -11 bis 11.

Ausgabe

Das generierte Gebäude kann in stdout geschrieben, direkt auf dem Bildschirm angezeigt oder als durch Zeilenumbrüche getrennte Zeichenfolge zurückgegeben werden.

Führende und nachfolgende Leerzeichen sind zulässig.

Gebäuderegeln

Die Form eines einzelnen 3D-Blocks sieht folgendermaßen aus:

 ___
/\__\
\/__/

Und ein 2x2x2-Blockwürfel sieht so aus:

  ______
 /\__\__\
/\/\__\__\
\/\/__/__/
 \/__/__/

Wenn sich Blöcke überlappen, hat ein höherer Block Vorrang vor einem niedrigeren, vorne liegende Blöcke haben Vorrang vor den weiter hinten liegenden und links liegende Blöcke haben Vorrang vor den rechts liegenden Blöcken. Der einzige Sonderfall ist, dass die oberste Zeile eines Blocks niemals ein dahinterstehendes Nicht-Leerzeichen überschreiben darf.

Die Interpretation der Spaltenhöhen lässt sich am besten anhand einer 2D-Darstellung von der Seite erklären.

HEIGHT:  1    2    3   -3   -2   -1
                  __   __
             __  |__| |__|  __
        __  |__| |__|      |__|  __
       |__| |__| |__|           |__|

Testfälle

Wenn Sie Ihre Lösung an einigen weiteren Eingaben ausprobieren möchten, habe ich hier einige Testfälle zusammengestellt .

Gewinnen

Dies ist Code-Golf , also gewinnt die kürzeste Übermittlung (in Bytes).

Kohle , 70 69 68 Bytes

≔Ｅ¹¹⮌Ｉ⪪Ｓ,θＦ²Ｆ¹¹Ｆ¹¹Ｆ¹¹«Ｊ⁻⁻⁺λκ×μ³ι⁻λκ≔§§θλμη¿∨⁼±η⊕κ‹κη¿ι“↗⊟&⁹κＵhnI”___

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

≔Ｅ¹¹⮌Ｉ⪪Ｓ,θ

Lesen Sie das Array, teilen Sie jede Zeile durch Kommas auf und setzen Sie es in eine Ganzzahl um, kehren Sie aber auch jede Zeile um, da Sie von rechts nach links zeichnen möchten, sodass die linken Spalten die rechten Spalten überschreiben. (Andere Dimensionen haben bereits das gewünschte Überschreibverhalten.)

Ｆ²Ｆ¹¹Ｆ¹¹Ｆ¹¹«

Schleife durch i) obere Zeilen und Körper k) Höhe l) Zeilen m) Spalten. (Durchlaufen Sie zuerst die oberen Zeilen und dann die Körper, um das Überschreiben von Körpern mit den oberen Zeilen zu vermeiden.)

Ｊ⁻⁻⁺λκ×μ³ι⁻λκ

Springe zur Position des Würfels.

≔§§θλμη

Ruft die Höhe in der aktuellen Zeile und Spalte ab.

¿∨⁼±η⊕κ‹κη

Testen Sie, ob für diese Zeile und Spalte ein Würfel in dieser Höhe gezeichnet werden soll.

¿ι“↗⊟&⁹κＵhnI”___

Zeichne den Körper oder die Oberseite des Würfels.

C  376   350   313   309  285 Bytes

Vielen Dank an Jonathan Frech für das Speichern von vier Bytes!

#define F for(
char*t,G[26][67],*s;i,j,e,k,v,x,y;b(){F s="\\/__//\\__\\ ___ ";*s;--y,s+=5)F e=5;e--;*t=*s<33&*t>32?*t:s[e])t=G[y]+x+e;}f(int*M){F;e<1716;++e)G[e/66][e%66]=32;F k=0;++k<12;)F i=0;i<11;++i)F j=11;j--;v+k||b())x=i+j*3+k,y=14+i-k,(v=M[i*11+j])>=k&&b();F;++e<26;)puts(G+e);}

Probieren Sie es online!

Abgerollt:

#define F for(

char *t, G[26][67], *s;
i, j, e, k, v, x, y;

b()
{
    F s="\\/__//\\__\\ ___ "; *s; --y, s+=5)
        F e=5; e--; *t=*s<33&*t>32?*t:s[e])
            t = G[y]+x+e;
}

f(int*M)
{
    F; e<1716; ++e)
        G[e/66][e%66] = 32;

    F k=0; ++k<12;)
        F i=0; i<11; ++i)
            F j=11; j--; v+k||b())
                x = i+j*3+k,
                y = 14+i-k,
                (v=M[i*11+j])>=k && b();

    F; ++e<26;)
        puts(G+e);
}

JavaScript (ES6), 277 251 Byte

a=>(n=55,$=f=>[...Array(n)].map((_,i)=>f(i)),S=$(_=>$(_=>' ')),n=11,$(l=>$(z=>$(y=>$(x=>(x=10-x,X=x*3+y+z,Y=y-z+n,Z=a[y][x])<=z&&Z+z+1?0:l?['/\\__\\','\\/__/'].map(s=>S[++Y].splice(X,5,...s)):S[Y].splice(X+1,3,...'___'))))),S.map(r=>r.join``).join`
`)

f=

a=>(n=55,$=f=>[...Array(n)].map((_,i)=>f(i)),S=$(_=>$(_=>' ')),n=11,$(l=>$(z=>$(y=>$(x=>(x=10-x,X=x*3+y+z,Y=y-z+n,Z=a[y][x])<=z&&Z+z+1?0:l?['/\\__\\','\\/__/'].map(s=>S[++Y].splice(X,5,...s)):S[Y].splice(X+1,3,...'___'))))),S.map(r=>r.join``).join`
`)

console.log(f([
	[3, 0, 0, 0, 0, 0, 0, 0, 0, 0, -11],
	[2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
	[2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
	[1, 0, 0, 7,-7,-7,-7,-7, 7, 0, 0],
	[0, 0, 0, 7,-7,-7,-7,-7, 7, 0, 0],
	[0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0],
	[0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0],
	[1, 0, 0, 4, 3, 2, 1, 0, 0, 0, 1],
	[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
	[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
	[1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 11]
]))

26 Bytes von @ Neils Vorschlag gespeichert .

Ungolfed

a=>(
    n=55,
    $=f=>[...Array(n)].map((_,i)=>f(i)),
    S=$(_=>$(_=>' ')),
    n=11,
    $(l=>
        $(z=>$(y=>$(x=>(
            x=10-x,
            X=x*3+y+z,
            Y=y-z+n,
            Z=a[y][x],
            Z<=z && Z+z+1 || (
                l
                ? ['/\\__\\','\\/__/'].map(s=>S[++Y].splice(X,5,...s))
                : S[Y].splice(X+1,3,...'___')
            )
        ))))
    ),
    S.map(r=>r.join``).join`\n`
)

Python 2 , 243 Bytes

a=input()
s=eval(`[[' ']*55]*23`)
for h in range(7986):
 k=h%3;x=h/3%11;y=h/33%11;z=h/363%11;i=h/3993;u=y+z-x*3+30;v=y-z+10
 if~-(z>=a[y][10-x]!=~z):
	if i*k:s[v+k][u:u+5]='\//\____/\\'[k%2::2]
	if~-i:s[v][u+1+k]='_'
for l in s:print''.join(l)

Probieren Sie es online!

Eine Python-Übersetzung von Neils Charcoal-Ansatz.

APL (Dyalog Unicode) , 117 116 112 Byte ^SBCS

a←23 55⍴0⋄{i←11 0+⍵+.×3 2⍴3-7897⊤⍨6⍴5⋄(,2 5↑i↓a)←745366⊤⍨10⍴4⋄(3⍴i↓1⌽¯1⊖a)⌈←1}¨j[⍋-/↑j←⍸↑⎕↑¨⊂⌽1,11/⍳2]⋄' _/\'[a]

Probieren Sie es online!

Tcl, 380 bis 409 Bytes

User sergiol war damit beschäftigt, das sehr gut zu machen:

set X [read stdin]
proc L {a b c d e s} {time {incr z
set y -1
time {incr y
set x -1
time {if {abs([set Z [lindex $::X [expr ($y+1)*11-[incr x]-1]]])==$z|$z<$Z} {set s [string repl [string repl $s [set i [expr -3*$x+57*$y-55*abs($z)+701]] $i+$b $a] [incr i $c] $i+$e $d]}} 11} 11} 12
set s}
puts [L /\\__\\ 4 56 \\/__/ 4 [L "" -1 -55 ___ 2 [string repe [string repe \  55]\n 23]]]

Probieren Sie es online!

Ursprünglicher Inhalt

set xs [read stdin]
proc L {a b c d e s} {set z 0
while {[incr z]<12} {set y -1
while {[incr y]<11} {set x -1
while {[incr x]<11} {set Z [lindex $::xs [expr ($y+1)*11-$x-1]]
if {abs($Z)==$z||$z<$Z} {set i [expr -3*$x+57*$y-55*abs($z)+701]
set s [string repl [string repl $s $i $i+$b $a] [incr i $c] $i+$e $d]}}}}
set s}
puts [L /\\__\\ 4 56 \\/__/ 4 [L "" -1 -55 ___ 2 [string repe [string repe \  55]\n 23]]]

Probieren Sie es online!

Ach, es ist was es ist. Es ist nur ein bisschen leichter für die Augen, wenn "ungolfed"

set s [string repeat [string repeat " " 55]\n 23]

proc loops {s0 i0 io s1 i1} {
  set z  0; while {[incr z] < 12} {
  set y -1; while {[incr y] < 11} {
  set x -1; while {[incr x] < 11} {
    set Z [lindex $::xs [expr {($y+1) * 11 - $x - 1}]]
    if {abs($Z) == $z || $z < $Z} {
        set i [expr {-3*$x + 57*$y - 55*abs($z) + 701}]
        set ::s [string replace $::s $i $i+$i0 $s0]
        incr i $io
        set ::s [string replace $::s $i $i+$i1 $s1]
    }
  } } }
}

loops ""      -1 -55 \
       ___     2
loops /\\__\\  4  56 \
      \\/__/   4

puts $s

Erstellt eine Zeichenfolge gemäß den Anforderungen. Nimmt das Array von stdin. Geht von unten nach oben, von vorne nach hinten, von rechts nach links über die Zeichenfolgendaten. In zwei Durchgängen, einmal für die Oberkante und noch einmal für den Rest des Körpers jedes Würfels.

Ich habe versucht, es mit einem süßen funktionellen Lambda-Mojo zu verkleinern, aber das hat es leider größer gemacht.