Es wurden automatische Nanobots für den Hausbau hergestellt, und es ist Ihre Aufgabe, sie zu codieren.

Hier ist das Haus durch Eingabe erstellt 7 4 2

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

Die Eingabe ist eine Zeichenfolge, die die Abmessungen des Hauses enthält.

7 ist die Breite.

|_____|

---7---

4 ist die Höhe.

|
|
|
|

2 ist die Tiefe

 / 
/

Können Sie anhand dieser Eingabe das Haus erstellen?

Ihr Code muss so klein wie möglich sein, damit er in die Roboter passt.

Anmerkungen

Die kleinsten Maße, die Sie als Eingabe erhalten, sind 3 2 2. Ihr Programm kann alles mit Dimensionen ausführen, die kleiner als sind 3 2 2.

Testfälle

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

Druckt Zeile für Zeile. Die Zeilenindizes izählen von dbis abwärts -h+1.

Rubin, 145 Bytes

Gibt eine Liste von Zeichenfolgen zurück. Jedes Element in der Liste entspricht einer Zeile. Wenn eine mehrzeilige Zeichenfolge zurückgegeben werden muss, fügen Sie 3 Bytes *$/unmittelbar vor der letzten Klammer hinzu.

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

Wobei \nein buchstäbliches Newline-Zeichen darstellt. Erläuterung:

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

Bearbeiten: 2 Bytes dank @jrich gespeichert.

Python 224 301 297 Bytes

(Funktioniert jetzt für alle Boxen einschließlich 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

Erläuterung:

Nimmt drei Konstanten auf: l (Länge), h (Höhe), w (Breite).

Wenn wir uns ein paar Musterboxen ansehen, können wir Muster im Abstand finden.

Für ein 3 x 4 x 3-Kästchen verwenden wir Zahlen, um den Abstand zwischen Abschnitten darzustellen.

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

Die oberste Zeile hat 4 Leerzeichen oder w + 1. Die nächsten drei Zeilen haben w - (1 * x). X ist die Linie.

Dies sind Muster, die in allen Zeilen in allen Feldern fortgesetzt werden. Daher können wir diese Zeile einfach zeilenweise programmieren, indem wir die Anzahl der Leerzeichen multiplizieren, um sie dem Muster anzupassen.

Hier ist ein Beispiel für eine 5 x 5 x 2 Box.

 123 -  -  -  -  -
 12/12345678912345/|
 1/              /1|
 1 -  -  -  -  - 12|
 |              |12|
 |              |12|
 |              |12|
 |              |1/
 |12345678912345|/
  -  -  -  -  -

Python 3.5, 328 326 313 305 295 248 Bytes

( Danke an Kevin Lau für den Tipp zur Reduzierung der ternären Anweisungen! )

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

Nimmt die Eingabe als 3 Ganzzahlen in der Reihenfolge von width, height, depth. Wird mit der Zeit mehr Golf spielen, wo immer ich kann.

Probieren Sie es online! (Ideone)

Erläuterung:

Für die Zwecke dieser Erklärung wird angenommen, dass die Funktion mit den Argumenten ausgeführt wurde, bei (3,2,3)denen 3 die Breite ( w), 2 die Höhe ( h) und 3 die Tiefe ( d) ist. Lassen Sie mich dennoch zunächst den Hauptteil der gesamten Funktion zeigen:

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

Hier werden die beiden Listen, aus denen das gesamte "Haus" besteht, erstellt und dann durch wörtliche neue Zeilen ( \n) miteinander verbunden. Nennen wir sie Liste abzw. Liste bund analysieren sie:

• Hier wird die Liste aerstellt:

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

  Diese Liste enthält die ersten dZeilen des Hauses. Hier iist jede Zahl in dem Bereich, 0=>(d-(d-h))+d-hin dem sie d-h=0negativ oder null ist. Zu Beginn d-iwerden der Liste Leerzeichen hinzugefügt, gefolgt von einem /und dem von einer komprimierten bedingten Anweisung zurückgegebenen. In dieser bedingten Anweisung wird die w-2Anzahl der Leerzeichen zurückgegeben, wenn i>1. Andernfalls wird die gleiche Anzahl -zurückgegeben. Danach folgen ein weiteres /und dann Leerzeichen, wobei die Anzahl der Leerzeichen jetzt davon abhängt, ob oder nicht i<=d-(d-h)-1. Wenn dies der Fall ist, werden iLeerzeichen hinzugefügt. Andernfalls werden h-1Leerzeichen hinzugefügt. Zum Schluss wird dies alles durch a /oder a abgerundet |, wobei |if hinzugefügt wird i<=d-(d-h)-1, andernfalls a/hinzugefügt. In diesem Fall eines 3x2x3Prismas würde dies als Liste zurückgegeben a:

        /-/|
       / / |
      / / /
  

• Hier wird die Liste berstellt:

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

  Diese Liste enthält die restlichen Linien des Prismas. In dieser Liste iist jede ganze Zahl in dem Bereich , (h-(h-d))+h-d=>0wo , h-d=0wenn negativ oder Null. Um diese Liste zu beginnen, wird zunächst ein a |hinzugefügt, da diese Zeilen immer mit einem beginnen |. Dann wird entweder ein Raum, -oder _hinzugefügt werden abhängig davon , ob oder nicht i=hoder i<2. Wenn ja i<2, dann _wird a hinzugefügt. Andernfalls wird a -hinzugefügt, wenn i=h, oder ein Leerzeichen wird hinzugefügt, wenn i>hoder i<hoder i>2. Nachdem diese Entscheidung getroffen wurde, wird die w-2Nummer des gewählten Zeichens hinzugefügt. Danach wird eine weitere |hinzugefügt, und dann wird entweder eine i-1oder eine dAnzahl von Leerzeichen hinzugefügt. Wenn ja i>h-(h-d), dann adAnzahl der Leerzeichen wird hinzugefügt. Andernfalls wird die i-1Anzahl der Leerzeichen hinzugefügt. Zum Schluss wird dies alles mit a |oder a ergänzt /, wobei a |if i>h-(h-d)oder a /if hinzugefügt wird i<=h-(h-d). Im Fall eines 3x2x3Prismas gibt list bFolgendes zurück:

      |-| /
      |_|/
  

Nachdem die 2 Listen erstellt wurden, werden sie mit literal new lines ( \n) verbunden '\n'.join(). Dies ist Ihr fertiges Prisma, und in diesem Fall würde es so aussehen:

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