Salvadera

Para los propósitos de la tarea actual, un cubo de unidad de longitud se representa en proyección oblicua con símbolos ASCII de la siguiente manera:

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

• + para los vértices
• -para los bordes X La unidad de longitud a lo largo de X está representada por cinco -entre dos vértices.
• |para los bordes Y La unidad de longitud a lo largo de Y está representada por dos |entre dos vértices.
• /para los bordes Z La unidad de longitud a lo largo de Z está representada por uno /entre dos vértices.
• Los vértices solo se dibujan donde se cruzan los tres planos.
• Los bordes solo se dibujan donde se cruzan exactamente dos planos.

Cuando se extruye una cara de unidad, se compensa con una longitud de unidad desde su posición original y se crean cuatro bordes nuevos para cada dirección (positiva y negativa).

Puede pensar en la extrusión como en dibujar los ejes de un sistema de coordenadas cartesianas 3D donde cada eje se representa como un cuboide con una sección transversal de 1x1 y una longitud nde (0,0,0)

Extruido por 1 a lo largo de X:

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

Tarea

Dados tres números para los ejes XYZ, extruya las caras de un cubo unitario simétricamente por las cantidades indicadas y rinda el resultado con los símbolos ASCII como se especificó anteriormente.

Entrada

x, y, z - números no negativos - longitudes de extrusión para los ejes respectivos. 0 significa que no hay extrusión. La entrada puede ser tres números, una lista de tres números, un triple, una cadena o cualquier cosa que sea conveniente para usted.

Salida

El dibujo ASCII del cubo después de la extrusión. Se permiten espacios en blanco iniciales y finales.

Casos de prueba

X Y Z
0 0 0

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

1 0 0

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


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


1 1 0

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

2 0 1

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

1 1 1 

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

Criterios ganadores

La solución más corta en bytes en cada idioma gana. Agregue una breve descripción del método utilizado y su código.

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

Guardado 13 bytes gracias a @Neil

Toma la entrada como una matriz [X,Y,Z]. Devuelve una matriz de caracteres.

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

Pruébalo en línea!

¿Cómo?

Pasos de dibujo

La salida consta de 15 lados, dibujados en un orden específico.

Implementación

La función de dibujo es $g$ . Funciona con los siguientes parámetros:

• $(x, y)$ : dónde comenzar a dibujar
• $w$ : ancho
• $h$ : altura
• $t$ : tipo de lado

Los vértices siempre se dibujan. Dependiendo del valor de otro parámetro $c$ , los bordes se dibujan o se borran.

Si $t=0$ , la función dibuja un lado frontal:

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

Si $t=1$ , dibuja un lado superior:

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

$t=2$

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

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

$c \in[1..8]$

Para resumir, un lado se describe completamente con:

$$\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$

Por lo tanto, necesitamos almacenar los siguientes 10 parámetros para cada lado:

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

A continuación se muestran los parámetros de los 15 lados que deben dibujarse:

$$\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}$$

We force all values into the range $[0..9]$ by applying the following operations:

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

It results in 15 numbers of exactly 10 decimal digits, which are stored as 15 groups of 7 digits in base 36.

For instance, the first side is encoded as 4032070460 and stored as 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×⍵]}

Try it online!

• generate a 3d bool array of unit cubies
• replicate each cubie 6 3 2 times along x y z
• surround with zeroes
• for each 2×2×2 subarray compute a number between 0 and 16 that determines the corresponding output char: (1 + 4*cx + 2*cy + cz) mod 16 where cx,cy,cz are the number of same-value "rods" along axis x,y,z, i.e. vectors along that axis that consist of the same value: 0 0 or 1 1. we make an exception if the subarray is all-zero (or all-one - those don't matter) and we consider its number 0 instead of 28
• for each cell compute where the corresponding char should be drawn on screen
• for each cell build a transparent (0-padded) matrix that contains only one opaque "pixel"
• mix the matrices - at this point we have a 5d array with dimensions inx,iny,inz,outx,outy
• reduce the first three axes, keeping only the first non-transparent (≠0) item along them
• use a lookup table (a string) to convert the numbers into -|/+

thanks Scott Milner for spotting that some +s rendered as ?s

Charcoal, 325 bytes

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

Try it online! Link is to verbose version of code. Explanation:

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

Input the extrusions, but premultiply them to save bytes.

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

If at least two of the extrusions are zero, then simply draw a cuboid of dimensions (2x+1, 2y+1, 2z+1). Otherwise:

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

Print the left extrusion, if any.

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

Print the down extrusion, if any.

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

Print the back extrusion, if any.

Ｊ⁶¦⁰

The remaining extrusions all meet at this point (which doesn't get drawn until the very end!)

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

Print the front extrusion, if any, taking care to erase parts of the left and down extrusions that may overlap.

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

Print the up extrusion, if any, taking care to erase parts of the back and left extrusions that may overlap.

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

Print the right extrusion, if any, taking care to erase parts of the down and back extrusions that may overlap.

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

Draw the joins between the latter extrusions.

Charcoal, 195 164 144 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Estoy publicando esto como una respuesta separada, ya que utiliza un enfoque completamente diferente para dibujar la extrusión. Explicación:

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

Ingrese las extrusiones y calcule la mitad del tamaño del cuboide envolvente, pero en aritmética de enteros porque los rangos de carbón son siempre enteros. El origen de la salida se asigna al centro del cubo de la unidad original.

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

Pase sobre todas las coordenadas dentro (incluido el límite) del cuboide que contiene la extrusión.

Ｊ⁻λι⁺κι

Salta a la posición de salida correspondiente a esas coordenadas.

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

Desde las coordenadas dadas, mire en las ocho direcciones diagonales para determinar si la extrusión se superpone en esa dirección. Se verifica que las coordenadas observadas todavía se encuentran dentro del cuboide, y luego el número de ejes en los que se encuentra la coordenada dentro del cubo original debe ser mayor que 1. Tenga en cuenta que dado que el cubo tiene una altura de visualización impar, los valores del eje Y que se miran son enteros, mientras que los otros ejes usan coordenadas fraccionarias.

≡Σδ

Considere la cantidad de direcciones en las que se superpone la extrusión. Hay cinco casos de interés en los que queremos imprimir algo, como en el caso de cero, eso significa que este es un espacio vacío y no queremos imprimir nada, mientras que en el caso de ocho, eso significa que está dentro la extrusión y cualquier cosa que imprimiéramos estaría sobreimpresa por una capa más cerca del punto del ojo.

¹+

Si la extrusión solo se superpone en una dirección, entonces esta es una esquina exterior y necesitamos generar una +.

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

Si la extrusión se superpone en dos direcciones, entonces este es un borde exterior. Qué tipo de borde se determina a partir de la separación entre las dos superposiciones; 6 y 7 son bordes orientados hacia atrás y se sobrescribirán, 4 es un borde diagonal, 2 es un borde vertical y 1 es un borde horizontal. (Realmente calculo 7 menos la separación, ya que parece ser más fácil de hacer).

³+

Si la extrusión se superpone en tres direcciones, entonces esta es una esquina interna en el caso de que una de las extrusiones sea cero y necesitemos generar a +.

⁴§ +Σ…δ⁴¦

Si la extrusión se superpone en cuatro direcciones, entonces hay dos casos: caras (cualquier dirección) y esquinas internas en el caso con tres extrusiones positivas. En el último caso, hay un número impar de superposiciones hacia el espectador.

⁶§ |-/⌕δ⁰

Si la extrusión se superpone en seis direcciones, entonces este es un borde interno. Funciona como el complemento de un borde exterior, excepto que solo nos interesa cuando uno de los dos espacios vacíos es la dirección hacia el punto del ojo (la última entrada en la matriz).

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]}

Pruébalo en línea!

obligatorio reescribir k de mi solucion apl

mismo algoritmo, excepto que el renderizado 3d-> 2d se realiza con (el k equivalente de) la asignación del índice de dispersión en lugar de crear matrices 2d para cada elemento 3d y mezclarlos