Автоматические домостроительные наноботы были изготовлены, и ваша работа - кодировать их.

Вот дом, созданный входом 7 4 2

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

Вводом является строка, содержащая размеры дома.

7 это ширина.

|_____|

---7---

4 это высота.

|
|
|
|

2 это глубина

 / 
/

Учитывая этот вклад, вы можете создать дом?

Ваш код должен быть как можно меньше, чтобы он мог поместиться в роботах.

Примечания

Наименьшие размеры, которые вы получите в качестве входных данных 3 2 2. Ваша программа может делать что угодно с размерами, которые меньше, чем 3 2 2.

Testcases

3 2 10

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

Python 2, 128 байт

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

Печатает построчно. Индексы строк iотсчитываются от dдо -h+1.

Рубин, 145 байт

Возвращает список строк. Каждый элемент в списке соответствует строке. Если должна быть возвращена многострочная строка, добавьте 3 байта для добавления *$/непосредственно перед последней скобкой.

->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 байт

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

Где \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
`

Изменить: Сохранено 2 байта благодаря @jrich.

Python 224 301 297 байт

(Теперь работает для всех коробок, включая 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

Объяснение:

Принимает три константы: l (длина), h (высота), w (ширина).

Если мы посмотрим на пару ящиков с образцами, мы сможем найти шаблоны в интервале.

Для блока 3 x 4 x 3 мы будем использовать числа для представления расстояния между секциями.

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

В верхнем ряду 4 пробела или w + 1. Следующие три строки имеют w - (1 * x). Х является линией.

Это шаблоны, которые продолжаются по всем строкам во всех полях. Следовательно, мы можем легко запрограммировать эту строку построчно, умножив количество пробелов для соответствия шаблону.

Вот образец для коробки 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 байт

( Спасибо Кевину Лау за совет об уменьшении размера троичных операторов! )

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

Принимает ввод как 3 целых числа в порядке width, height, depth. Будет ли гольф больше со временем, где я могу.

Попробуйте онлайн! (Ideone)

Объяснение:

В целях этого объяснения предположим, что функция была выполнена с аргументами, (3,2,3)где 3 - ширина ( w), 2 - высота ( h), а 3 - глубина ( d). При этом позвольте мне начать с показа основной части всей функции:

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

Здесь два списка, которые составляют весь «дом», создаются, а затем объединяются буквально новыми строками ( \n). Давайте назовем их list aи list bсоответственно и проанализируем каждый из них:

• Вот где aсоздается список :

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

  Этот список содержит первые dстроки дома. Здесь iкаждое число в диапазоне, 0=>(d-(d-h))+d-hгде, d-h=0если отрицательный или ноль. Для начала d-iв список добавляются пробелы, после которых следует символ «а», /а затем все, что возвращается сжатым условным оператором. В этом условном выражении w-2число пробелов возвращается, если i>1. В противном случае -возвращается такое же количество . Затем за ними следуют другие /, а затем пробелы, где количество пробелов теперь зависит от того, стоит или нет i<=d-(d-h)-1. Если это так, то iпробелы добавляются. В противном случае h-1пробелы добавляются. Наконец, все это завершается либо a, /либо a |, где |добавляется if i<=d-(d-h)-1, в противном случае a/добавлен. В этом случае 3x2x3призмы это будет возвращено списком a:

        /-/|
       / / |
      / / /
  

• Вот где bсоздается список :

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

  Этот список содержит остальные линии призмы. В этом списке iнаходится каждое целое число в диапазоне, (h-(h-d))+h-d=>0где, h-d=0если отрицательный или ноль. Чтобы начать этот список, сначала |добавляется a, так как эти строки всегда начинаются с a |. Затем либо пробел, -либо _добавляется в зависимости от того, или нет, i=hили i<2. Если i<2, то _добавляется. В противном случае, -добавляется, если i=h, или пробел добавляется, если i>hили i<hили i>2. После принятия этого решения w-2добавляется номер выбранного персонажа. После этого |добавляется еще один , а затем добавляется либо число, i-1либо dчисло пробелов. Если i>h-(h-d), тоdколичество пробелов добавляется. В противном случае i-1добавляется количество пробелов. Наконец, все это завершается либо a, |либо a /, в котором |добавляется a if i>h-(h-d)или a /добавляется if i<=h-(h-d). В случае 3x2x3призмы список bвозвращает:

      |-| /
      |_|/
  

После того, как 2 списка были созданы, они, наконец, объединяются с помощью новых буквенных строк ( \n) с помощью '\n'.join(). Это ваша законченная призма, и в этом случае она будет выглядеть так:

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