Se han fabricado nanobots automáticos para la construcción de viviendas, y es su trabajo codificarlos.

Aquí está la casa creada por entrada 7 4 2

  /-----/|
 /     / |
|-----|  |
|     |  |
|     | /
|_____|/

La entrada es una cadena que contiene las dimensiones de la casa.

7 es el ancho

|_____|

---7---

4 es la altura

|
|
|
|

2 es la profundidad

 / 
/

Ante esta entrada, ¿puedes crear la casa?

Su código debe ser lo más pequeño posible para que pueda caber en los robots.

Notas

Las dimensiones más pequeñas que se le darán como entrada son 3 2 2. Su programa puede hacer cualquier cosa con dimensiones más pequeñas que 3 2 2.

Casos de prueba

3 2 10

          /-/|
         / / |
        / / /
       / / /
      / / /
     / / /
    / / /
   / / /
  / / /
 / / /
|-| /
|_|/

Python 2, 128 bytes

w,h,d=input();i=d
while-i<h:c='|/'[i>0];print' '*i+c+'- _'[(d>i!=0)+(h+i<2)]*(w-2)+c+' '*min(d-i,h-1,w+1,h-1+i)+'/|'[d-i<h];i-=1

Imprime fila por fila. Los índices de la fila icuentan hacia atrás desde dhasta -h+1.

Ruby, 145 bytes

Devuelve una lista de cadenas. Cada elemento de la lista corresponde a una línea. Si se debe devolver una cadena de varias líneas, agregue 3 bytes para agregar *$/justo antes del último paréntesis.

->w,h,d{s=' ';(0..m=d+h-1).map{|i|(i<d ?s*(d-i)+?/:?|)+(i<1||i==d ??-:i==m ??_ :s)*(w-2)+(i<d ? ?/:?|)+(i<h ?s*[i,d].min+?|:s*[m-i,h-1].min+?/)}}

JavaScript (ES6), 169 bytes

(w,h,d)=>[...Array(d+h--)].map((_,i)=>` `[r=`repeat`](i<d&&d-i)+(c=`|/`[+(i<d)])+` _-`[i&&i-d?h+d-i?0:1:2][r](w-2)+c+` `[r]((i<d?i:d)-(i>h&&i-h))+`|/`[+(i>h)]).join`\n`

Donde \nrepresenta un carácter de nueva línea literal. Explicación:

(w,h,d,)=>                          Parameters
[...Array(d+h--)].map((_,i)=>       Loop over total height = d + h
 ` `[r=`repeat`](i<d&&d-i)+         Space before roof (if applicable)
 (c=`|/`[+(i<d)])+                  Left wall/roof edge
 ` _-`[i&&i-d?h+d-i?0:1:2][r](w-2)+ Space, floor or eaves between walls
 c+                                 Right wall/roof edge (same as left)
 ` `[r]((i<d?i:d)-(i>h&&i-h))+      Right wall
 `|/`[+(i>h)]                       Back wall/floor edge
).join`                             Join everything together
`

Editar: Guardado 2 bytes gracias a @jrich.

Python 224 301 297 Bytes

(Ahora funciona para todos los cuadros, incluido 1x1x1)

l,w,h=input()
s,r,d,v,R,x=" "," - ","/","|",range,(l*3-1)
print s*(w+1)+r*l
for n in R(w):
    if n<h:e,c=v,n
    else:e,c=d,h
    print s*(w-n)+d+s*x+d+s*c+e
if h-w>=1:e,c=v,w
elif w>h:e,c=d,h
else:e,c=d,w
print s+r*l+s*c+e
for n in R(h):
    if h>w+n:e,c=v,w
    else:e,c=d,h-n-1
    print v+s*x+v+s*c+e
print r*l

Explicación:

Toma tres constantes: l (longitud), h (altura), w (ancho).

Si observamos un par de cuadros de muestra, podemos encontrar patrones en el espacio.

Para un cuadro de 3 x 4 x 3, utilizaremos números para representar el espacio entre secciones.

1234 -  -  - 
123/12345678/|
12/12345678/1|
1/12345678/12|
1 -  -  - 123|
|12345678|123/
|       8|12/
|       8|1/
|       8|/
 -  -  - 

La fila superior tiene 4 espacios o que es w + 1. Las siguientes tres líneas tienen w - (1 * x). X es la línea.

Estos son patrones que continúan a lo largo de todas las líneas en todos los cuadros. Por lo tanto, podemos programar fácilmente esta línea por línea, multiplicando el número de espacios para ajustar el patrón.

Aquí hay una muestra para una caja de 5 x 5 x2.

 123 -  -  -  -  -
 12/12345678912345/|
 1/              /1|
 1 -  -  -  -  - 12|
 |              |12|
 |              |12|
 |              |12|
 |              |1/
 |12345678912345|/
  -  -  -  -  -

Python 3.5, 328 326 313 305 295 248 bytes

(¡ Gracias a Kevin Lau por el consejo sobre la reducción del tamaño de las declaraciones ternarias! )

def s(w,h,d):R,M=range,max;S,V,L=' |/';O=w-2;D=d-M(0,d-h);Q=h-M(0,h-d);print('\n'.join([S*(d-i)+L+' -'[i<1]*O+L+S*[h-1,i][i<=D-1]+'/|'[i<=D-1]for i in R(D+M(0,d-h))]+[V+[' -'[i==h],'_'][i<2]*O+V+S*[i-1,d][i>Q]+'/|'[i>Q]for i in R(Q+M(0,h-d),0,-1)]))

Toma la entrada como 3 enteros en el orden de width, height, depth. Jugaré más golf con el tiempo siempre que pueda.

Pruébalo en línea! (Ideona)

Explicación:

Para los propósitos de esta explicación, suponga que la función se ejecutó con los argumentos (3,2,3)donde 3 es el ancho ( w), 2 es la altura ( h) y 3 es la profundidad ( d). Dicho esto, permítanme comenzar mostrando la parte principal de toda la función:

'\n'.join([S*(d-i)+L+' -'[i<1]*O+L+S*[h-1,i][i<=D-1]+'/|'[i<=D-1]for i in R(D+M(0,d-h))]+[V+[' -'[i==h],'_'][i<2]*O+V+S*[i-1,d][i>Q]+'/|'[i>Q]for i in R(Q+M(0,h-d),0,-1)])

Aquí, las dos listas que conforman la "casa" completa se crean y luego se unen mediante nuevas líneas literales ( \n). Llamémoslos lista ay lista brespectivamente, y analicemos cada uno de ellos:

• Aquí es donde ase crea la lista :

  [S*(d-i)+L+' -'[i<1]*O+L+S*[h-1,i][i<=D-1]+'/|'[i<=D-1]for i in R(D+M(0,d-h))]
  

  Esta lista contiene las primeras dlíneas de la casa. Aquí, ies cada número en el rango 0=>(d-(d-h))+d-hen que d-h=0si es negativo o cero. Para comenzar, d-ise agregan espacios a la lista, seguidos de /ay luego lo que sea que devuelva una declaración condicional comprimida. En esta declaración condicional, w-2se devuelve el número de espacios si i>1. De lo contrario, -se devuelve el mismo número de . Luego, estos son seguidos por otro /, y luego espacios, donde el número de espacios ahora depende de si o no i<=d-(d-h)-1. Si es así, ise agregan espacios. De lo contrario, h-1se agregan espacios. Finalmente, todo esto se completa con a /o a |, donde |se agrega si i<=d-(d-h)-1, de lo contrario, un/está agregado. En este caso de un 3x2x3prisma, esto sería devuelto por la lista a:

        /-/|
       / / |
      / / /
  

• Aquí es donde bse crea la lista :

  [V+[' -'[i==h],'_'][i<2]*O+V+S*[i-1,d][i>Q]+'/|'[i>Q]for i in R(Q+M(0,h-d),0,-1)]`
  

  Esta lista contiene el resto de las líneas del prisma. En esta lista, ies cada número entero en el rango (h-(h-d))+h-d=>0donde h-d=0es negativo o cero. Para comenzar esta lista, primero |se agrega a ya que estas líneas siempre comienzan con a |. Entonces, o un espacio, -o _se añade en función de si o no i=ho i<2. Si i<2, entonces _se agrega a. De lo contrario, -se agrega a si i=h, o se agrega un espacio si i>ho i<ho i>2. Después de tomar esta decisión, w-2se agrega el número del personaje elegido. Después de esto, |se agrega otro , y luego se agrega uno i-1o dvarios espacios. Si i>h-(h-d), entonces undNúmero de espacios se agregan. De lo contrario, i-1se agrega el número de espacios. Finalmente, todo esto se completa con a |o a /, en el que |se agrega a if i>h-(h-d)o a /se agrega if i<=h-(h-d). En el caso de un 3x2x3prisma, la lista bdevuelve:

      |-| /
      |_|/
  

Después de que se hayan creado las 2 listas, finalmente se unen con nuevas líneas literales ( \n) usando '\n'.join(). Este es su prisma completo, y en este caso, se vería así:

       /-/|
      / / |
     / / /
    |-| /
    |_|/