Nanoboty do automatycznego budowania domów zostały sfabrykowane i ich zadaniem jest ich kodowanie.

Oto dom stworzony przez dane wejściowe 7 4 2

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

Dane wejściowe to ciąg znaków zawierający wymiary domu.

7 jest szerokość.

|_____|

---7---

4 jest wysokość.

|
|
|
|

2 to głębokość

 / 
/

Biorąc pod uwagę ten wkład, czy możesz stworzyć dom?

Twój kod musi być jak najmniejszy, aby zmieścił się w robotach.

Notatki

Najmniejsze wymiary, które otrzymasz jako dane wejściowe, to 3 2 2. Twój program może zrobić wszystko z wymiarami mniejszymi niż 3 2 2.

Przypadki testowe

3 2 10

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

Python 2, 128 bajtów

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

Drukuje rząd po rzędzie. Indeksy wierszy iodliczają od ddo -h+1.

Rubin, 145 bajtów

Zwraca listę ciągów. Każdy element na liście odpowiada linii. Jeśli trzeba zwrócić ciąg wielowierszowy, dodaj 3 bajty, aby dodać *$/bezpośrednio przed ostatnim nawiasiem.

->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 bajtów

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

Gdzie \nreprezentuje dosłowny znak nowej linii. Wyjaśnienie:

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

Edycja: Zapisano 2 bajty dzięki @jrich.

Python 224 301 297 bajtów

(Teraz działa dla wszystkich pudeł, w tym 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

Wyjaśnienie:

Przyjmuje trzy stałe: l (długość), h (wysokość), w (szerokość).

Jeśli spojrzymy na kilka przykładowych pól, możemy znaleźć wzory w odstępach.

W przypadku pola 3 x 4 x 3 użyjemy liczb do przedstawienia odstępów między sekcjami.

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

Górny rząd ma 4 spacje lub w + 1. Następne trzy linie mają w - (1 * x). X jest linią.

Są to wzorce, które trwają we wszystkich liniach we wszystkich polach. Dlatego możemy łatwo zaprogramować tę linię po linii, mnożąc liczbę spacji pasujących do wzoru.

Oto próbka dla pudełka 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 bajtów

( Podziękowania dla Kevina Lau za poradę na temat zmniejszania wielkości trójkowych oświadczeń! )

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

Pobiera dane wejściowe jako 3 liczby całkowite w kolejności width, height, depth. Będę grał w golfa z czasem, gdziekolwiek będę mógł.

Wypróbuj online! (Ideone)

Wyjaśnienie:

Dla celów tego wyjaśnienia załóżmy, że funkcja została wykonana z argumentami, (3,2,3)gdzie 3 to szerokość ( w), 2 to wysokość ( h), a 3 to głębokość ( d). To powiedziawszy, zacznę od pokazania głównej części całej funkcji:

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

Tutaj tworzone są dwie listy składające się na cały „dom”, a następnie łączone ze sobą dosłownie nowe linie ( \n). Nazwijmy je odpowiednio listą ai listą bi przeanalizujmy każdą z nich:

• Oto gdzie atworzona jest 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))]
  

  Ta lista zawiera pierwsze dwiersze domu. Tutaj ijest każda liczba z zakresu, w 0=>(d-(d-h))+d-hktórym wartość d-h=0jest ujemna lub zero. Aby rozpocząć, d-ispacje są dodawane do listy, po której następuje a, /a następnie wszystko, co jest zwracane przez skompresowaną instrukcję warunkową. W tej instrukcji warunkowej w-2zwracana jest liczba spacji, jeślii>1 . W przeciwnym razie -zwracana jest ta sama liczba . Następnie następują po nich kolejne /, a następnie spacje, w których liczba spacji zależy teraz od tego, czy i<=d-(d-h)-1. Jeśli tak, ito dodaje się spacje. W przeciwnym razie h-1dodaje się spacje. Wreszcie, wszystko to jest uzupełnione przez a /lub a |, gdzie |dodaje się, jeśli i<=d-(d-h)-1w przeciwnym razie a/jest dodany. W tym przypadku 3x2x3pryzmatu byłby zwracany przez listę a:

        /-/|
       / / |
      / / /
  

• Oto gdzie btworzona jest 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)]`
  

  Ta lista zawiera resztę linii pryzmatu. Na tej liście ijest każda liczba całkowita z zakresu, w (h-(h-d))+h-d=>0którym wartość h-d=0jest ujemna lub zero. Aby rozpocząć tę listę, najpierw |dodaje się a, ponieważ linie te zawsze zaczynają się od |. Następnie, albo przestrzeń, -albo _dodaje się w zależności od tego, czy nie i=hlub i<2. Jeśli i<2, _to dodaje się a. W przeciwnym razie -dodaje się a i=h, lub spację, jeśli i>hlub i<hlub i>2. Po podjęciu tej decyzji w-2dodaje się numer wybranej postaci. Następnie |dodaje się kolejną , a następnie dodaje jedną i-1lub dkilka spacji. Jeśli i>h-(h-d), to adliczba spacji została dodana. W przeciwnym razie i-1dodawana jest liczba spacji. Wreszcie, wszystko to jest uzupełnione albo a |albo a /, w których a |jest dodawane jeśli i>h-(h-d)lub a /jest dodawane jeśli i<=h-(h-d). W przypadku 3x2x3pryzmatu lista bzwraca:

      |-| /
      |_|/
  

Po utworzeniu 2 list są one ostatecznie łączone za pomocą dosłownie nowych wierszy ( \n) przy użyciu '\n'.join(). To jest twój ukończony pryzmat i w tym przypadku wyglądałby tak:

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