I nanobot automatici per l'edilizia abitativa sono stati fabbricati ed è tuo compito codificarli.

Ecco la casa creata per input 7 4 2

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

L'input è una stringa contenente le dimensioni della casa.

7 è la larghezza.

|_____|

---7---

4 è l'altezza.

|
|
|
|

2 è la profondità

 / 
/

Dato questo input, puoi creare la casa?

Il codice deve essere il più piccolo possibile in modo che possa adattarsi ai robot.

Appunti

Le dimensioni più piccole che verranno fornite come input sono 3 2 2. Il tuo programma può fare qualsiasi cosa con dimensioni inferiori a 3 2 2.

Casi test

3 2 10

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

Python 2, 128 byte

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

Stampa riga per riga. Gli indici delle righe icontano alla rovescia da da -h+1.

Rubino, 145 byte

Restituisce un elenco di stringhe. Ogni elemento nell'elenco corrisponde a una linea. Se è necessario restituire una stringa su più righe, aggiungere 3 byte da aggiungere *$/subito prima dell'ultima parentesi.

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

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

Dove \nrappresenta un carattere letterale newline. Spiegazione:

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

Modifica: salvato 2 byte grazie a @jrich.

Python 224 301 297 byte

(Ora funziona per tutte le scatole incluso 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

Spiegazione:

Comprende tre costanti: l (lunghezza), h (altezza), w (larghezza).

Se osserviamo un paio di caselle di esempio, possiamo trovare modelli nella spaziatura.

Per una casella 3 x 4 x 3, useremo i numeri per rappresentare la spaziatura tra le sezioni.

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

La riga superiore ha 4 spazi o che è w + 1. Le tre righe successive hanno w - (1 * x). X è la linea.

Questi sono schemi che continuano su tutte le linee in tutte le caselle. Pertanto, possiamo facilmente programmare questa riga per riga, moltiplicando il numero di spazi per adattarsi al modello.

Ecco un esempio per una scatola 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 byte

( Grazie a Kevin Lau per il suggerimento su come ridurre le dimensioni delle dichiarazioni ternarie! )

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

Accetta input come 3 numeri interi nell'ordine di width, height, depth. Giocherò di più nel tempo, ovunque io sia possibile.

Provalo online! (Ideone)

Spiegazione:

Ai fini di questa spiegazione, supponiamo che la funzione sia stata eseguita con gli argomenti in (3,2,3)cui 3 è la larghezza ( w), 2 è l'altezza ( h) e 3 è la profondità ( d). Detto questo, vorrei iniziare mostrando la parte principale dell'intera funzione:

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

Qui, le due liste che compongono l'intera "casa" vengono create e quindi unite da nuove linee letterali ( \n). Chiamiamoli rispettivamente elenco aed elenco be analizziamo ciascuno di essi:

• Ecco dove aviene creato l' elenco :

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

  Questo elenco contiene le prime drighe della casa. Qui, iè ogni numero nell'intervallo in 0=>(d-(d-h))+d-hcui d-h=0se negativo o zero. Per iniziare, gli d-ispazi vengono aggiunti all'elenco, seguiti da un /e quindi tutto ciò che viene restituito da un'istruzione condizionale compressa. In questa istruzione condizionale, w-2viene restituito il numero di spazi se i>1. Altrimenti -viene restituito lo stesso numero di . Quindi, questi sono seguiti da un altro /, e quindi dagli spazi, in cui il numero di spazi ora dipende dal fatto o meno i<=d-(d-h)-1. In tal caso, ivengono aggiunti spazi. Altrimenti, h-1vengono aggiunti spazi. Infine, questo è completato da a /o a |, dove |viene aggiunto se i<=d-(d-h)-1, altrimenti a/è aggiunto. In questo caso di un 3x2x3prisma, questo sarebbe restituito dalla lista a:

        /-/|
       / / |
      / / /
  

• Ecco dove bviene creato l' elenco :

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

  Questo elenco contiene il resto delle linee del prisma. In questo elenco, iè ogni intero nell'intervallo (h-(h-d))+h-d=>0in cui h-d=0se negativo o zero. Per iniziare questo elenco, innanzitutto |viene aggiunto a poiché queste righe iniziano sempre con a |. Poi, sia uno spazio, -o _si aggiunge a seconda o meno i=ho i<2. Se i<2, quindi _viene aggiunto a. Altrimenti, -viene aggiunto a se i=ho viene aggiunto uno spazio se i>ho i<ho i>2. Dopo aver preso questa decisione, w-2viene aggiunto il numero del personaggio scelto. Successivamente, ne |viene aggiunto un altro , quindi viene aggiunto uno i-1o il dnumero di spazi. Se i>h-(h-d), quindi adil numero di spazi viene aggiunto. Altrimenti, i-1viene aggiunto il numero di spazi. Infine, tutto questo è completato con a |o a /, in cui |viene aggiunto a se i>h-(h-d), o /se viene aggiunto a i<=h-(h-d). Nel caso di un 3x2x3prisma, l'elenco brestituisce:

      |-| /
      |_|/
  

Dopo che le 2 liste sono state create, vengono finalmente unite con nuove righe ( \n) letterali usando '\n'.join(). Questo è il tuo prisma completo, e in questo caso verrebbe ad apparire così:

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