Una stanza può essere composta da rettangoli collegati, ad esempio una stanza a forma di L. Tale stanza può essere descritta da un elenco di dimensioni che descrivono le dimensioni di ciascun rettangolo.

Supponiamo di avere due elenchi di input. Il primo contiene la larghezza dei rettangoli sovrapposti verticalmente. Il secondo contiene l'altezza dei rettangoli.

Ad esempio, l'input [4 6][3 2]sarà un rettangolo 4 per 3 sopra un rettangolo 6 per 2. La figura seguente mostra questa forma. Si noti che i muri sono considerati "sottili", quindi sono gli spazi tra il muro che sono determinati dall'input.

[4 6][3 2]
 ____
|    |
|    |
|    |_
|      |
|______|

La sfida è: prendere un elenco di dimensioni come input e produrre la forma della stanza come ASCII-art. Il formato deve essere come nelle figure di esempio:

• Tutte le pareti orizzontali sono mostrate usando i trattini bassi
• Tutte le pareti verticali vengono visualizzate mediante barre
• Non devono esserci pareti in cui i rettangoli sono collegati
• La parete sinistra è dritta
• Per maggiori dettagli, dai un'occhiata ai casi di test

Ipotesi che puoi fare:

• Tutte le dimensioni sono nell'intervallo [1 ... 20]
  • Tutte le dimensioni orizzontali sono numeri pari
• Il numero di rettangoli sarà compreso nell'intervallo [1 ... 10]
• Viene fornito solo un input valido
• Formato di input facoltativo (è possibile decidere l'ordine delle dimensioni di input, specificare nella risposta).

Casi test:

[2][1]
 __
|__|

---

[4][2]
 ____
|    |
|____|

---

[2 6 2 4][2 2 1 3]
 __
|  |
|  |___
|      |
|   ___|
|  |_
|    |
|    |
|____|

---

[2 14 6 8 4 18 2 10 4 2][1 2 3 1 2 1 1 1 2 1]
 __
|  |___________
|              |
|       _______|
|      |
|      |
|      |_
|     ___|
|    |
|    |_____________
|   _______________|
|  |______
|     ____|
|    |
|   _|
|__|

Retina, 169 150 113 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

\ D +
$ *
{+ R`1 (1 * ¶ [^ |] * (1+))
$ 1¶ | $ 2 |
} `(¶. *) 1+
$ 1
1
_
(\ | _ +) \ | (? = ¶ \ 1 _ (_ +))
$ 1 | $ 2
T`w`` (\ | _ +) _? (? = _ * \ |. * ¶ \ 1)
^ ¶
 

Il codice contiene uno spazio finale su una nuova riga finale.

Formato di input:

Altezza (separata da spazi)
Larghezza (separata anche da spazi)

Per esempio:

1 2 3 1 2 1 1 1 2 1
2 14 6 8 4 18 2 10 4 2

Provalo online!

JavaScript (ES6) 174

L'unica parte critica è la fila orizzontale che unisce 2 parti di diversa larghezza, con la barra verticale sul lato destro che può essere al centro o all'estremità destra.

(p,h,q=-1,R=(n,s=' ')=>s.repeat(n))=>[...p,0].map((x,i)=>(x>q?p=x:(p=q,q=x),(~q?`
|`+R(q+(x<p)-!x)+R(x>q,'|'):' ')+R(p+~q+!x,'_')+R(x<p,'|')+R(h[i]-1,`
|${R(q=x)}|`))).join``

TEST

f=(p,h,q=-1,R=(n,s=' ')=>s.repeat(n))=>[...p,0].map((x,i)=>(x>q?p=x:(p=q,q=x),(~q?`
|`+R(q+(x<p)-!x)+R(x>q,'|'):' ')+R(p+~q+!x,'_')+R(x<p,'|')+R(h[i]-1,`
|${R(q=x)}|`))).join``

// Less golfed

F=(p,h, q=-1, 
   R=(n,s=' ')=>s.repeat(n)
  )=>
  [...p, 0].map((x,i)=> (
    x>q? p=x : (p=q,q=x),
    (q>=0?`\n|`+R(q+(x<p)-!x)+R(x>q,'|'):' ')
    + R(p+~q+!x,'_') + R(x<p,'|')
    + R(h[i]-1,`\n|${R(q=x)}|`)
  )).join``

console.log=x=>O.textContent+=x+'\n'

;[  
  [[2],[1]],
  [[4],[2]],
  [[2, 6, 2, 4],[2, 2, 1, 3]],
  [[2, 14, 6, 8, 4, 18, 2, 10, 4, 2],[1, 2, 3, 1, 2, 1, 1, 1, 2, 1]]
].forEach(t=>{
  var w=t[0],h=t[1]
  console.log('['+w+'] ['+h+']\n'+f(w,h)+'\n')
})

<pre id=O></pre>

Python 3, 230 223 222 217 byte

def f(a):b=a[0]+[0];m=' _';print('\n'.join([' '+'_'*b[0]+' ']+['|'+' '*min(b[l],b[l+1])+m[b[l+1]<1]*(b[l]>b[l+1])+m[k]*(b[l]-b[l+1]-1)+'|'+m[k]*(b[l+1]-b[l]-1)for l,i in enumerate(zip(*a))for k in[0]*(i[1]-1)+[1]]))

Grazie a @StewieGriffin @KevinLau per il loro aiuto

risultati

>>> f([[2, 14, 6, 8, 4, 18, 2, 10, 4, 2],[1, 2, 3, 1, 2, 1, 1, 1, 2, 1]])
 __ 
|  |___________
|              |
|       _______|
|      | 
|      | 
|      |_
|     ___|
|    |             
|    |_____________
|   _______________|
|  |_______
|     _____|
|    |
|   _|
|__|

Rubino 191

La prima volta che gioco a golf, è anche il mio primo giorno con Ruby, quindi probabilmente non è la cosa più elegante del mondo, ma lo farà?

def f(x)
a=x[0]+[0]
puts" #{'_'*a[0]} "
for i in 0..x[1].length-1
n,m=a[i,2].sort
puts"|#{' '*a[i]}|\n"*(x[1][i]-1)+'|'+' '*n+(a[i+1]<1?'_':m>a[i]?'|':' ')+'_'*(m-n-1)+(n<a[i]?'|':'')
end
end