Des nanobots automatiques de construction de maisons ont été fabriqués, et c'est à vous de les coder.

Voici la maison créée par entrée 7 4 2

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

L'entrée est une chaîne contenant les dimensions de la maison.

7 est la largeur.

|_____|

---7---

4 est la hauteur.

|
|
|
|

2 est la profondeur

 / 
/

Compte tenu de cette entrée, pouvez-vous créer la maison?

Votre code doit être aussi petit que possible afin qu'il puisse tenir dans les robots.

Remarques

Les plus petites dimensions qui vous seront données en entrée sont 3 2 2. Votre programme peut tout faire avec des dimensions plus petites que 3 2 2.

Cas de test

3 2 10

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

Python 2, 128 octets

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 ligne par ligne. Les indices de ligne idécomptent de dà -h+1.

Rubis, 145 octets

Renvoie une liste de chaînes. Chaque élément de la liste correspond à une ligne. Si une chaîne multiligne doit être renvoyée, ajoutez 3 octets à ajouter *$/juste avant le dernier crochet.

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

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

Où \nreprésente un caractère de nouvelle ligne littéral. Explication:

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

Edit: sauvé 2 octets grâce à @jrich.

Python 224 301 297 octets

(Fonctionne maintenant pour toutes les boîtes, y compris 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

Explication:

Prend trois constantes: l (longueur), h (hauteur), w (largeur).

Si nous regardons quelques exemples de boîtes, nous pouvons trouver des modèles dans l'espacement.

Pour une boîte de 3 x 4 x 3, nous utiliserons des nombres pour représenter l'espacement entre les sections.

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

La rangée du haut a 4 espaces ou qui est w + 1. Les trois lignes suivantes ont w - (1 * x). X étant la ligne.

Ce sont des modèles qui se poursuivent sur toutes les lignes dans toutes les cases. Par conséquent, nous pouvons facilement programmer cette ligne par ligne, en multipliant le nombre d'espaces pour s'adapter au motif.

Voici un exemple pour une boîte 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 octets

( Merci à Kevin Lau pour le conseil sur la réduction de la taille des déclarations ternaires! )

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

Prend l'entrée comme 3 entiers dans l'ordre de width, height, depth. Va jouer au golf au fil du temps partout où je peux.

Essayez-le en ligne! (Ideone)

Explication:

Aux fins de cette explication, supposons que la fonction a été exécutée avec les arguments (3,2,3)où 3 est la largeur ( w), 2 est la hauteur ( h) et 3 est la profondeur ( d). Cela étant dit, permettez-moi de commencer par montrer l'essentiel de l'ensemble de la fonction:

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

Ici, les deux listes qui composent toute la "maison" sont créées puis réunies par de nouvelles lignes littérales ( \n). Appelons-les respectivement liste aet liste b, et analysons chacun d'eux:

• Voici où la liste aest créée:

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

  Cette liste contient les premières dlignes de la maison. Ici, iest chaque numéro dans la plage 0=>(d-(d-h))+d-hoù d-h=0si elle est négative ou nulle. Pour commencer, des d-iespaces sont ajoutés à la liste, suivis d'un /, puis de tout ce qui est renvoyé par une instruction conditionnelle compressée. Dans cette instruction conditionnelle, le w-2nombre d'espaces est renvoyé si i>1. Sinon, le même nombre de -sont retournés. Ensuite, ceux-ci sont suivis par un autre /, puis des espaces, où le nombre d'espaces dépend maintenant de savoir si oui ou non i<=d-(d-h)-1. Si c'est le cas, des iespaces sont ajoutés. Sinon, des h-1espaces sont ajoutés. Enfin, tout cela est complété par un /ou un |, où |est ajouté si i<=d-(d-h)-1, sinon un/est ajouté. Dans ce cas d'un 3x2x3prisme, celui-ci serait retourné par liste a:

        /-/|
       / / |
      / / /
  

• Voici où la liste best créée:

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

  Cette liste contient le reste des lignes du prisme. Dans cette liste, iest tout entier dans la plage (h-(h-d))+h-d=>0où h-d=0il est négatif ou nul. Pour commencer cette liste, un premier |est ajouté car ces lignes commencent toujours par un |. Alors, que ce soit un espace, -ou _est ajouté en fonction de si oui ou non i=hou i<2. Si i<2, alors un _est ajouté. Sinon, un -est ajouté si i=h, ou un espace est ajouté si i>hou i<hou i>2. Une fois cette décision prise, le w-2numéro du personnage choisi est ajouté. Après cela, un autre |est ajouté, puis un i-1ou dplusieurs espaces sont ajoutés. Si i>h-(h-d), alors undnombre d'espaces sont ajoutés. Sinon, le i-1nombre d'espaces est ajouté. Enfin, tout cela est complété par un |ou un /, dans lequel un |est ajouté si i>h-(h-d), ou un /est ajouté si i<=h-(h-d). Dans le cas d'un 3x2x3prisme, la liste brenvoie:

      |-| /
      |_|/
  

Une fois les 2 listes créées, elles sont finalement jointes à de nouvelles lignes littérales ( \n) à l'aide de '\n'.join(). Ceci est votre prisme terminé, et dans ce cas, cela ressemblerait à ceci:

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