Nanobots automáticos para construção de casas foram fabricados, e é seu trabalho codificá-los.

Aqui é a casa criada pela entrada 7 4 2

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

A entrada é uma sequência que contém as dimensões da casa.

7 é a largura.

|_____|

---7---

4 é a altura

|
|
|
|

2 é a profundidade

 / 
/

Dada essa entrada, você pode criar a casa?

Seu código deve ser o menor possível para caber nos robôs.

Notas

As menores dimensões que você receberá como entrada são 3 2 2. Seu programa pode fazer qualquer coisa com dimensões menores que 3 2 2.

Casos de teste

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 linha por linha. Os índices de linha são idecrescentes de daté -h+1.

Ruby, 145 bytes

Retorna uma lista de strings. Cada elemento da lista corresponde a uma linha. Se for necessário retornar uma cadeia de linhas múltiplas, adicione 3 bytes para adicionar *$/logo antes do último colchete.

->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`

Onde \nrepresenta um caractere literal de nova linha. Explicação:

(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: salvou 2 bytes graças a @jrich.

Pitão 224 301 297 Bytes

(Agora funciona para todas as caixas, incluindo 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

Explicação:

Toma em três constantes: l (comprimento), h (altura), w (largura).

Se olharmos para algumas caixas de amostra, podemos encontrar padrões no espaçamento.

Para uma caixa 3 x 4 x 3, usaremos números para representar o espaçamento entre as seções.

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

A linha superior tem 4 espaços ou que é w + 1. As próximas três linhas têm w - (1 * x). X sendo a linha.

Esses são padrões que continuam ao longo de todas as linhas em todas as caixas. Portanto, podemos programar facilmente essa linha por linha, multiplicando o número de espaços para ajustar-se ao padrão.

Aqui está uma amostra para uma caixa 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

( Obrigado a Kevin Lau pela dica sobre como reduzir o tamanho das declarações ternárias! )

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

Recebe a entrada como 3 números inteiros na ordem de width, height, depth. Golf mais com o tempo sempre que posso.

Experimente online! (Ideona)

Explicação:

Para os fins desta explicação, assuma que a função foi executada com os argumentos em (3,2,3)que 3 é a largura ( w), 2 é a altura ( h) e 3 é a profundidade ( d). Dito isto, deixe-me começar mostrando a parte principal de toda a função:

'\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)])

Aqui, as duas listas que compõem a "casa" inteira são criadas e depois unidas por novas linhas literais ( \n). Vamos chamá-los de lista ae lista b, respectivamente, e analisar cada um deles:

• Aqui é onde a lista aé criada:

  [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 contém as primeiras dlinhas da casa. Aqui, ié cada número no intervalo em 0=>(d-(d-h))+d-hque d-h=0se negativo ou zero. Para começar, os d-iespaços são adicionados à lista, seguidos por a /e, em seguida, o que for retornado por uma instrução condicional compactada. Nesta declaração condicional, o w-2número de espaços será retornado se i>1. Caso contrário, o mesmo número de -será retornado. Em seguida, eles são seguidos por outro /e, em seguida, espaços, onde o número de espaços agora depende se deve ou não i<=d-(d-h)-1. Se estiver, os iespaços serão adicionados. Caso contrário, os h-1espaços serão adicionados. Finalmente, tudo isso é /complementado por a ou a |, onde é adicionado. Neste caso de um| é adicionado se i<=d-(d-h)-1, caso contrário, um/3x2x3prisma, isso seria retornado por lista a:

        /-/|
       / / |
      / / /
  

• Aqui é onde a lista bé criada:

  [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 contém o restante das linhas do prisma. Nesta lista, ié cada número inteiro no intervalo em (h-(h-d))+h-d=>0que h-d=0se for negativo ou zero. Para iniciar esta lista, primeiro |é adicionado a, pois essas linhas sempre começam com a |. Então, seja um espaço, -ou _é adicionado dependendo se ou não i=hou i<2. Se i<2, a _é adicionado. Caso contrário, a -é adicionado se i=h, ou um espaço é adicionado se i>hou i<hou i>2. Após esta decisão ser tomada, o w-2número do personagem escolhido é adicionado. Depois disso, outro |é adicionado e, em seguida, um i-1oud número de espaços é adicionado. Se i>h-(h-d), então umdnúmero de espaços são adicionados. Caso contrário, o i-1número de espaços será adicionado. Por fim, tudo isso é |complementado com a ou a /, no qual a |é adicionado se i>h-(h-d), ou a /é adicionado se i<=h-(h-d). No caso de um 3x2x3prisma, a lista bretorna:

      |-| /
      |_|/
  

Depois que as 2 listas foram criadas, elas finalmente são unidas com literalmente novas linhas ( \n) usando '\n'.join(). Este é o seu prisma completo e, nesse caso, ficaria assim:

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