Sandkasten

Für die Zwecke der aktuellen Aufgabe wird ein Würfel mit Einheitslänge in Schrägprojektion mit ASCII-Symbolen wie folgt gerendert:

  +-----+
 /     /|
+-----+ |
|     | +
|     |/
+-----+

• + für die Eckpunkte.
• -für die X-Kanten. Die Einheitslänge entlang X wird durch fünf -zwischen zwei Eckpunkten dargestellt.
• |für die Y-Kanten. Die Einheitslänge entlang Y wird durch zwei |zwischen zwei Eckpunkten dargestellt.
• /für die Z-Kanten. Die Einheitslänge entlang Z wird durch einen /zwischen zwei Eckpunkten dargestellt.
• Scheitelpunkte werden nur dort gezeichnet, wo sich alle drei Ebenen schneiden.
• Kanten werden nur dort gezeichnet, wo sich genau zwei Ebenen schneiden.

Wenn eine Einheitsfläche extrudiert wird, wird sie von ihrer ursprünglichen Position um eine Einheitslänge versetzt, und für jede Richtung (positiv und negativ) werden vier neue Kanten erstellt.

Bei der Extrusion werden die Achsen eines kartesischen 3D-Koordinatensystems gezeichnet, wobei jede Achse als Quader mit einem Querschnitt von 1x1 und einer Länge nvon (0,0,0) dargestellt wird.

Mit 1 entlang X extrudiert:

  +-----------------+
 /                 /|   
+-----------------+ |
|                 | +
|                 |/
+-----------------+

Aufgabe

Extrudieren Sie bei drei Zahlen für die XYZ-Achsen die Flächen eines Einheitswürfels symmetrisch um die angegebenen Beträge und geben Sie das Ergebnis mit den oben angegebenen ASCII-Symbolen wieder.

Eingang

x, y, z - nicht negative Zahlen - Extrusionslängen für die jeweiligen Achsen. 0 bedeutet keine Extrusion. Die Eingabe kann aus drei Zahlen, einer Liste mit drei Zahlen, einem Tripel, einer Zeichenfolge oder einem beliebigen für Sie geeigneten Wert bestehen.

Ausgabe

Die ASCII-Zeichnung des Würfels nach der Extrusion. Führende und nachfolgende Leerzeichen sind erlaubt.

Testfälle

X Y Z
0 0 0

  +-----+
 /     /|
+-----+ |
|     | +
|     |/
+-----+

1 0 0

  +-----------------+
 /                 /|   
+-----------------+ |
|                 | +
|                 |/
+-----------------+


0 0 1   
        +-----+
       /     /|
      /     / |
     /     /  +
    /     /  /
   /     /  /
  +-----+  /
  |     | / 
  |     |/
  +-----+


1 1 0

        +-----+
       /     /|      
      +-----+ |
  +---|     | +-----+
 /    |     |/     /|
+-----+     +-----+ |
|                 | +
|                 |/
+-----+     +-----+
      |     | +
      |     |/
      +-----+

2 0 1

                +-----+
               /     /|
  +-----------+     +-----------+
 /                             /|
+-----------+     +-----------+ |
|          /     /|           | +
|         +-----+ |           |/
+---------|     | +-----------+
          |     |/
          +-----+

1 1 1 

        +-----+
       /     /|-+   
      +-----+ |/|
  +---|     | +-----+
 /    |     |/     /|
+-----+-----+-----+ |
|    /     /|     | +
|   +-----+ |     |/
+---|     | +-----+
    |     |/| +
    +-----+ |/
      +-----+

Gewinnkriterien

Die kürzeste Lösung in Bytes in jeder Sprache gewinnt. Bitte fügen Sie eine kurze Beschreibung der verwendeten Methode und Ihres Codes hinzu.

JavaScript (ES6),  525 ... 475 471  459 Bytes

13 Bytes dank @Neil eingespart

Übernimmt die Eingabe als Array [X,Y,Z]. Gibt eine Zeichenmatrix zurück.

a=>([X,Y,Z]=a,m=[],W=X*6+Z*2,'1uol9h824lsqpq17de52u1okgnv21dnjaww111qmhx1gxf4m50xg6pb42kzijq21xyh34t0h2gueq0qznnza2rrimsg3bkrxfh3yrh0em').replace(/.{7}/g,s=>[[c,x,A,y,B,w,C,h,D,t]=parseInt(s,36)+s,Y*W,Z,X,Y|!W,Z*X,X*Y*!Z,X*Z*!Y,Y*Z*!X][c]&&(g=H=>V<h&&((m[r=y-(3-B)*p+(t>1?H-V:V)+Y*3+Z*2]=m[r]||Array(W*2+9).fill` `)[x-2*(3-A)*p+(t>1?V:H-V*t)+W]=` ${c>5?'  + ':t>1?'|-':'-|'}+/+`[(H%~-w?0:+t?4:2)|!(V%~-h)],g(++H<w?H:!++V)))(V=0,p=a[c%3],w-=-3*C*p,h-=-D*p))&&m

Probieren Sie es online!

Wie?

Zeichenschritte

Die Ausgabe besteht aus 15 Seiten, die in einer bestimmten Reihenfolge gezeichnet werden.

Implementierung

$g$

• $(x, y)$
• $w$
• $h$
• $t$

$c$

$t=0$

...........      ...........
..+-----+..      ..+     +..
..|     |..  or  ..       ..
..|     |..      ..       ..
..+-----+..      ..+     +..
...........      ...........

$t=1$

...........      ...........
...+-----+.      ...+     +.
../     /..  or  ..       ..
.+-----+...      .+     +...
...........      ...........

$t=2$

......+....      ......+....
...../|....      .....  ....
....+ |....  or  ....+  ....
....| +....      ....  +....
....|/.....      ....  .....
....+......      ....+......

$(x,y)$$(w,h)$$X$$Y$$Z$

$c \in[1..8]$

Zusammenfassend ist eine Seite vollständig beschrieben mit:

$$\begin{cases} c\\ t\\ x=o_x+m_x\times P\\ y=o_y+m_y\times P\\ w=o_w+m_w\times P\\ h=o_h+m_h\times P \end{cases}$$

$P$$c$

Daher müssen wir für jede Seite die folgenden 10 Parameter speichern:

$$[c, o_x, m_x, o_y, m_y, o_w, m_w, o_h, m_h, t]$$

Nachfolgend sind die Parameter der 15 Seiten aufgeführt, die gezeichnet werden müssen:

$$\begin{array}{|c|c|} \hline \text{side} & c & o_x & m_x & o_y & m_y & o_w & m_w & o_h & m_h & t\\ \hline 0 & 4 & 0 & 0 & 2 & -3 & 7 & 0 & 4 & 6 & 0\\ 1 & 4 & 6 & 0 & 2 & -3 & 4 & 6 & 3 & 0 & 2\\ 2 & 2 & 6 & -2 & 2 & 2 & 4 & 0 & 3 & 4 & 2\\ 3 & 3 & 6 & 6 & 2 & 0 & 4 & 0 & 3 & 0 & 2\\ 4 & 3 & 0 & -6 & 2 & 0 & 7 & 12 & 4 & 0 & 0\\ 5 & 2 & 2 & 2 & 0 & -2 & 7 & 0 & 3 & 4 & 1\\ 6 & 3 & 2 & -6 & 0 & 0 & 7 & 12 & 3 & 0 & 1\\ 7 & 2 & 0 & -2 & 2 & 2 & 7 & 0 & 4 & 0 & 0\\ 8 & 5 & 6 & -2 & 2 & 2 & 4 & 0 & 1 & 2 & 2\\ 9 & 4 & 2 & 0 & 0 & -3 & 7 & 0 & 3 & 0 & 1\\ 10 & 1 & 0 & 0 & 2 & -3 & 7 & 0 & 1 & 3 & 0\\ 11 & 1 & 6 & 0 & 2 & -3 & 1 & 3 & 3 & 0 & 2\\ 12 & 6 & 0 & 0 & 2 & 0 & 7 & 0 & 4 & 0 & 0\\ 13 & 7 & 2 & 0 & 0 & 0 & 7 & 0 & 3 & 0 & 1\\ 14 & 8 & 6 & 0 & 2 & 0 & 4 & 0 & 3 & 0 & 2\\ \hline \end{array}$$

$[0..9]$

$$m_x\gets (m_x+6)/2\\ m_y\gets m_y+3\\ m_w\gets m_w/3$$

Es ergeben sich 15 Zahlen mit genau 10 Dezimalstellen, die als 15 Gruppen mit 7 Stellen in der Basis 36 gespeichert werden.

Beispielsweise wird die erste Seite als codiert 4032070460und als gespeichert 1uol9h8.

APL (Dyalog Classic) , 162 161 132 130 Bytes

{' |+/+ +-? ??? ++'[⍉(⊃~∘0)⍤1⍣3⍉↑a↑¨⍨↓(--1-⌊/∘,)2-/1⌽↑⍳⍴a←16|29|1+{2⊥+/¨∊¨=⌿¨⍵(⍉⍵)(⍉↓⍵)}⌺2 2 2{⍉⍤2⍉⌽0,⍵}⍣6↑3/↓2/6⌿1<⍵+.=⍨↑⍳1+2×⍵]}

Probieren Sie es online!

• Erzeugen Sie ein 3D-Bool-Array von Einheiten-Cubies
• repliziere jeden Cubie 6 3 2 mal entlang xyz
• mit Nullen umgeben
• für jeweils 2 × 2 × 2 Subarray compute eine Zahl zwischen 0 und 16, die dem entsprechende Ausgabe char bestimmt: in (1 + 4*cx + 2*cy + cz) mod 16denen cx, cy, czentlang der Achse x, y, z, dh Vektoren entlang dieser Achse die Anzahl von gleich Wert „rods“ sind , die besteht aus mit dem gleichen Wert: 0 0 oder 1 1. Wir machen eine Ausnahme, wenn das Subarray nur Null ist (oder nur Eins - das ist egal) und wir betrachten seine Nummer 0 anstelle von 28
• für jede Zelle berechnen, wo das entsprechende Zeichen auf dem Bildschirm gezeichnet werden soll
• Bilde für jede Zelle eine transparente (0-gepolsterte) Matrix, die nur ein undurchsichtiges "Pixel" enthält
• mischen Sie die Matrizen - an dieser Stelle haben wir ein 5d-Array mit den Dimensionen inx, iny, inz, outx, outy
• Verkleinern Sie die ersten drei Achsen, und lassen Sie nur das erste nicht transparente Element (along 0) daneben
• Verwenden Sie eine Nachschlagetabelle (eine Zeichenfolge), um die Zahlen in zu konvertieren -|/+

Vielen Dank, Scott Milner, für das Erkennen einiger +s, die als ?s gerendert wurden

Holzkohle , 325 Bytes

≔×⁶Ｎθ≔׳Ｎη≔⊗Ｎζ¿‹¹№⟦θηζ⟧⁰«Ｂ⁺⁷⊗θ⁺⁴⊗η↗↗⊕⊗ζ+⁺⁵⊗θＰ↙⊗⊕ζ↓+↓⁺²⊗η↙+↙⊕⊗ζ»«Ｆ‹⁰θ«↗+↗←+←⊖θ↙+/Ｐ→θ↓+↓²+⊖θ+»Ｆ‹⁰η«Ｊ⁶¦³↗+↗↓+↓⊖η↙+/Ｐ↑η←+←⁵↑+↑⊖η+»Ｆ‹⁰ζ«Ｊ⁸±²↓+↓↓↗+↗⊖ζ↑+↑²Ｐ↙ζ←+←⁵↙+↙⊖ζ+»Ｊ⁶¦⁰Ｆ‹⁰ζ«Ｇ↓³↙⊕ζ←⁷↑³↗⊕ζ ↙+↙⊖ζ↓+↓²+→⁵Ｐ↗ζ↑+↑²Ｐ←⁶↗+↗⊖ζ»Ｆ‹⁰η«Ｇ←⁶↑⊕η↗³→⁶↓⊕η ↑+↑⊖η←+←⁵↙+/Ｐ↓η+⁵Ｐ↗²↓+↓⊖η»Ｆ‹⁰θ«Ｇ↗²→⊕θ↓⁴↙²←⊕θ →+⊖θ↗+/↑+↑²Ｐ←θ↙+/Ｐ↓³←+←⊖θ»Ｐ↗∧∧θη²Ｐ↓∧∧ζθ³Ｐ←∧∧ηζ⁶+

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

≔×⁶Ｎθ≔׳Ｎη≔⊗Ｎζ

Geben Sie die Extrusionen ein, multiplizieren Sie sie jedoch vorab, um Bytes zu sparen.

¿‹¹№⟦θηζ⟧⁰«Ｂ⁺⁷⊗θ⁺⁴⊗η↗↗⊕⊗ζ+⁺⁵⊗θＰ↙⊗⊕ζ↓+↓⁺²⊗η↙+↙⊕⊗ζ»«

Wenn mindestens zwei der Extrusionen Null sind, zeichnen Sie einfach einen Quader mit Abmessungen (2x + 1, 2y + 1, 2z + 1). Andernfalls:

Ｆ‹⁰θ«↗+↗←+←⊖θ↙+/Ｐ→θ↓+↓²+⊖θ+»

Drucken Sie die linke Extrusion, falls vorhanden.

Ｆ‹⁰η«Ｊ⁶¦³↗+↗↓+↓⊖η↙+/Ｐ↑η←+←⁵↑+↑⊖η+»

Drucken Sie die Daunenextrusion, falls vorhanden.

Ｆ‹⁰ζ«Ｊ⁸±²↓+↓↓↗+↗⊖ζ↑+↑²Ｐ↙ζ←+←⁵↙+↙⊖ζ+»

Drucken Sie ggf. die hintere Extrusion.

Ｊ⁶¦⁰

Die verbleibenden Extrusionen treffen sich alle an diesem Punkt (der erst am Ende gezeichnet wird!)

Ｆ‹⁰ζ«Ｇ↓³↙⊕ζ←⁷↑³↗⊕ζ ↙+↙⊖ζ↓+↓²+→⁵Ｐ↗ζ↑+↑²Ｐ←⁶↗+↗⊖ζ»

Drucken Sie die vordere Extrusion, falls vorhanden, und achten Sie darauf, Teile der linken und unteren Extrusion zu entfernen, die sich möglicherweise überlappen.

Ｆ‹⁰η«Ｇ←⁶↑⊕η↗³→⁶↓⊕η ↑+↑⊖η←+←⁵↙+/Ｐ↓η+⁵Ｐ↗²↓+↓⊖η»

Drucken Sie die Extrusion nach oben, falls vorhanden, und achten Sie darauf, Teile der hinteren und linken Extrusion, die sich möglicherweise überlappen, zu entfernen.

Ｆ‹⁰θ«Ｇ↗²→⊕θ↓⁴↙²←⊕θ →+⊖θ↗+/↑+↑²Ｐ←θ↙+/Ｐ↓³←+←⊖θ»

Drucken Sie gegebenenfalls die richtige Extrusion aus, und achten Sie darauf, Teile der Daunen- und Rückenextrusion zu entfernen, die sich möglicherweise überlappen.

Ｐ↗∧∧θη²Ｐ↓∧∧ζθ³Ｐ←∧∧ηζ⁶+

Zeichnen Sie die Verbindungen zwischen den letzteren Extrusionen.

Charcoal , 195 164 144 Bytes

≔⁺³×⁶Ｎθ≔⁺²×³Ｎη≔⊕⊗ＮζＦ…·±ζζＦ…·±ηηＦ…·±θθ«Ｊ⁻λι⁺κι≔⟦⟧δＦＥ²↔⁻⁺ιμ·⁵ＦＥ²↔⁻κνＦＥ²↔⁻⁺λξ·⁵⊞δ⌊⟦‹μζ‹νη‹ξθ‹¹№Ｅ⟦μνξ⟧‹π⊕ρ¹⟧≡Σδ¹+²§ |-/⁺⌕δ¹⌕⮌δ¹¦³+⁴§ +Σ…δ⁴¦⁶§ |-/⌕δ⁰

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Ich poste dies als separate Antwort, da es einen völlig anderen Ansatz zum Zeichnen der Extrusion verwendet. Erläuterung:

≔⁺³×⁶Ｎθ≔⁺²×³Ｎη≔⊕⊗Ｎζ

Geben Sie die Extrusionen ein und berechnen Sie die Hälfte der Größe des einschließenden Quaders, jedoch in Ganzzahlarithmetik, da die Bereiche von Charcoal immer Ganzzahlen sind. Der Ursprung der Ausgabe wird auf die Mitte des ursprünglichen Einheitswürfels abgebildet.

Ｆ…·±ζζＦ…·±ηηＦ…·±θθ«

Alle Koordinaten innerhalb (einschließlich der Begrenzung) des Quaders mit der Extrusion durchlaufen.

Ｊ⁻λι⁺κι

Springe zu der Ausgabeposition, die diesen Koordinaten entspricht.

≔⟦⟧δＦＥ²↔⁻⁺ιμ·⁵ＦＥ²↔⁻κνＦＥ²↔⁻⁺λξ·⁵⊞δ⌊⟦‹μζ‹νη‹ξθ‹¹№Ｅ⟦μνξ⟧‹π⊕ρ¹⟧

Schauen Sie von den angegebenen Koordinaten aus in alle acht diagonalen Richtungen, um festzustellen, ob sich die Extrusion in dieser Richtung überlappt. Es wird überprüft, ob die gespähten Koordinaten noch im Quader liegen, und dann muss die Anzahl der Achsen, in denen die Koordinate im ursprünglichen Würfel liegt, größer als 1 sein Das sind ganze Zahlen, während die anderen Achsen Bruchkoordinaten verwenden.

≡Σδ

Berücksichtigen Sie die Anzahl der Richtungen, in die sich die Extrusion überlappt. Es gibt fünf Fälle von Interesse, in denen wir etwas drucken möchten, wie im Fall von Null, was bedeutet, dass dies ein leerer Raum ist und wir nichts drucken möchten, während im Fall von Acht dies bedeutet, dass dies drinnen ist Die Extrusion und alles, was wir gedruckt haben, würde durch eine Schicht näher am Augenpunkt überdruckt.

¹+

Wenn sich die Extrusion nur in einer Richtung überlappt, ist dies eine äußere Ecke und wir müssen a ausgeben +.

²§ |-/⁺⌕δ¹⌕⮌δ¹¦

Wenn die Extrusion in zwei Richtungen überlappt, ist dies eine Außenkante. Welche Art von Kante wird aus dem Abstand zwischen den beiden Überlappungen bestimmt; 6 und 7 sind nach hinten gerichtete Kanten und werden überschrieben, 4 ist eine diagonale Kante, 2 ist eine vertikale Kante und 1 ist eine horizontale Kante. (Ich berechne eigentlich 7 minus der Trennung, da es einfacher zu sein scheint.)

³+

Wenn sich die Extrusion in drei Richtungen überlappt, ist dies eine innere Ecke für den Fall, dass eine der Extrusionen Null ist und wir a ausgeben müssen +.

⁴§ +Σ…δ⁴¦

Wenn sich die Extrusion in vier Richtungen überlappt, gibt es zwei Fälle: Flächen (jede Richtung) und innere Ecken im Fall mit drei positiven Extrusionen. Im letzteren Fall gibt es eine ungerade Anzahl von Überlappungen zum Betrachter hin.

⁶§ |-/⌕δ⁰

Wenn die Extrusion in sechs Richtungen überlappt, ist dies eine Innenkante. Es funktioniert wie das Komplement einer Außenkante, außer dass es uns nur interessiert, wenn einer der beiden leeren Bereiche die Richtung zum Augenpunkt ist (der letzte Eintrag im Array).

K (ngn / k) , 172 Bytes

{s:1+|/'i-:&//i:1_--':1_4#!#'2*:\a:16!29!1+2/(!3){+'+x}/'{2+':''1+':'0=':x}'{++'x}\6{+'+0,|x}/{6}#{3}#'{2}#''s#1<+/x=!s:1+2*x;" |+/+ +-? ??? ++"s#@[&*/s;s/i;{x+y*~x};,//a]}

Probieren Sie es online!

obligatorisches umschreiben meiner apl-lösung

Der gleiche Algorithmus, außer dass das Rendern von 3d-> 2d mit (dem k-Äquivalent von) Streuindexzuweisung durchgeführt wird, anstatt 2d-Matrizen für jedes 3d-Element zu erstellen und diese zu mischen