Une pièce peut être constituée de rectangles connectés, par exemple une pièce en forme de L. Une telle pièce peut être décrite par une liste de dimensions décrivant la taille de chaque rectangle.

Supposons que vous ayez deux listes d'entrée. Le premier contient la largeur des rectangles empilés verticalement les uns sur les autres. Le second contient la hauteur des rectangles.

Par exemple, l'entrée [4 6][3 2]sera un rectangle 4 x 3 au-dessus d'un rectangle 6 x 2. La figure ci-dessous montre cette forme. Notez que les murs sont considérés comme "minces", donc ce sont les espaces entre les murs qui sont déterminés par l'entrée.

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

Le défi est le suivant: prendre une liste de dimensions en entrée et sortir la forme de la pièce en ASCII. Le format doit être comme dans les exemples de figures:

• Tous les murs horizontaux sont représentés à l'aide de traits de soulignement
• Tous les murs verticaux sont représentés à l'aide de barres
• Il ne doit pas y avoir de murs où les rectangles sont connectés
• Le mur de gauche est droit
• Pour plus de détails, jetez un œil aux cas de test

Hypothèses que vous pouvez formuler:

• Toutes les dimensions sont dans la gamme [1 ... 20]
  • Toutes les dimensions horizontales sont des nombres pairs
• Le nombre de rectangles sera dans la plage [1 ... 10]
• Seule une entrée valide est donnée
• Format d'entrée facultatif (vous pouvez décider de l'ordre des dimensions d'entrée, veuillez le préciser dans la réponse).

Cas de 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]
 __
|  |___________
|              |
|       _______|
|      |
|      |
|      |_
|     ___|
|    |
|    |_____________
|   _______________|
|  |______
|     ____|
|    |
|   _|
|__|

Rétine, 169 150 113 octets

Le nombre d'octets suppose un codage ISO 8859-1.

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

Le code contient un espace de fin sur une nouvelle ligne de fin.

Format d'entrée:

Hauteur (séparée par des espaces)
Largeur (également séparée par des espaces)

Par exemple:

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

Essayez-le en ligne!

JavaScript (ES6) 174

La seule partie critique est la rangée horizontale joignant 2 parties de largeurs différentes, avec la barre verticale sur le côté droit qui peut être au milieu ou à l'extrémité droite.

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

TESTER

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 octets

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

Merci à @StewieGriffin @KevinLau pour leur aide

Résultats

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

Rubis 191

Golf pour la première fois, c'est aussi mon premier jour avec Ruby, donc ce n'est probablement pas la chose la plus élégante du monde, mais ça va faire?

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