Una habitación puede estar compuesta de rectángulos conectados, por ejemplo, una habitación en forma de L. Dicha habitación se puede describir mediante una lista de dimensiones que describe el tamaño de cada rectángulo.

Suponga que tiene dos listas de entrada. El primero contiene el ancho de los rectángulos apilados verticalmente uno sobre el otro. El segundo contiene la altura de los rectángulos.

Como ejemplo, la entrada [4 6][3 2]será un rectángulo de 4 por 3 encima de un rectángulo de 6 por 2. La siguiente figura muestra esta forma. Tenga en cuenta que las paredes se consideran "delgadas", por lo tanto, los espacios entre la pared están determinados por la entrada.

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

El desafío es: tomar una lista de dimensiones como entrada y dar salida a la forma de la habitación como arte ASCII. El formato debe ser como en las figuras de muestra:

• Todas las paredes horizontales se muestran con guiones bajos
• Todas las paredes verticales se muestran con barras.
• No habrá paredes donde los rectángulos estén conectados.
• La pared izquierda es recta
• Para más detalles, eche un vistazo a los casos de prueba

Suposiciones que puedes hacer:

• Todas las dimensiones están en el rango [1 ... 20]
  • Todas las dimensiones horizontales son números pares.
• El número de rectángulos estará en el rango [1 ... 10]
• Solo se da una entrada válida
• Formato de entrada opcional (puede decidir el orden de las dimensiones de entrada, especifique en la respuesta).

Casos de prueba:

[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 bytes

El recuento de bytes asume la codificación ISO 8859-1.

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

El código contiene un espacio final en una nueva línea final.

Formato de entrada:

Altura (separada por espacios)
Ancho (también separado por espacios)

Por ejemplo:

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

Pruébalo en línea!

JavaScript (ES6) 174

La única parte crítica es la fila horizontal que une 2 partes de diferentes anchos, con la barra vertical en el lado derecho que puede estar en el medio o en el extremo derecho.

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

PRUEBA

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 bytes

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

Gracias a @StewieGriffin @KevinLau por su ayuda

Resultados

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

Rubí 191

Golf por primera vez, también es mi primer día con Ruby, así que probablemente no sea la cosa más elegante del mundo, pero ¿funcionará?

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