^{nota: el arte de la cadena puede verse horrible aquí debido a la rareza de la fuente SE: P :(}

Dada una lista de cuatro tuplas que representan las esquinas de los rectángulos, dibuje rectángulos translúcidos uno sobre el otro en ese orden.

Para este desafío, debe tener la coordenada más pequeña en la esquina superior izquierda y el eje x aumentando hacia la derecha y el eje y aumentando hacia abajo.

Una tupla de cuatro (x0, y0, x1, y1)o (x0, x1, y0, y1)representa los (x, y)pares de coordenadas de las esquinas superior izquierda e inferior derecha de un rectángulo (puede elegir cualquiera de los dos formatos para rectángulos, pero debe ser coherente)

¿Qué quiero decir con "rectángulo translúcido"? Bueno, para este desafío, utilizarás el carácter espacial y la mayoría de los personajes de dibujo de caja ; específicamente, todos los que se usan para dibujar rectángulos, incluidos los caracteres "en negrita". Cuando se dibuja un rectángulo translúcido, primero desaparecen todas las líneas finas en el espacio ocupado y todas las líneas en negrita se vuelven delgadas, y luego el rectángulo en sí se dibuja en líneas en negrita.

Por ejemplo, si dibuja un rectángulo en la esquina superior izquierda y luego en la esquina inferior derecha, podría verse así:

┏━━━━┓
┃    ┃
┃    ┃
┃ ┏━━╇━━┓
┃ ┃  │  ┃
┗━╉──┘  ┃
  ┃     ┃
  ┃     ┃
  ┗━━━━━┛

Para ser claros, las líneas se aclaran (negrita -> delgada -> ninguna) para todas las líneas estrictamente dentro del rectángulo (por ejemplo, las líneas que miran hacia abajo se ven afectadas por el borde superior pero no por el borde inferior).

Casos de prueba

Se proporcionará cierto número de líneas de entrada, seguidas de unicode-art, para cada caso de prueba.

0 0 5 5
5 5 10 10
3 3 7 7
2 2 8 8

┏━━━━┓     
┃    ┃     
┃ ┏━━╇━━┓  
┃ ┃┌─┴─┐┃  
┃ ┃│   │┃  
┗━╉┤   ├╊━┓
  ┃│   │┃ ┃
  ┃└─┬─┘┃ ┃
  ┗━━╈━━┛ ┃
     ┃    ┃
     ┗━━━━┛

14 5 15 9
13 2 15 16
6 4 15 11


             ┏━┓
             ┃ ┃
      ┏━━━━━━╇━┫
      ┃      │ ┃
      ┃      │ ┃
      ┃      │ ┃
      ┃      │ ┃
      ┃      │ ┃
      ┃      │ ┃
      ┗━━━━━━╈━┫
             ┃ ┃
             ┃ ┃
             ┃ ┃
             ┃ ┃
             ┗━┛

6 8 10 11
15 12 16 16
14 10 16 16
9 1 15 15

         ┏━━━━━┓ 
         ┃     ┃ 
         ┃     ┃ 
         ┃     ┃ 
         ┃     ┃ 
         ┃     ┃ 
         ┃     ┃ 
      ┏━━╉┐    ┃ 
      ┃  ┃│    ┃ 
      ┃  ┃│   ┌╊┓
      ┗━━╉┘   │┃┃
         ┃    │┠┨
         ┃    │┃┃
         ┃    │┃┃
         ┗━━━━╈┩┃
              ┗┷┛

¡Genera más casos de prueba!

Reglas

• La entrada puede estar en cualquier formato razonable para una lista de cuatro tuplas. La entrada puede ser de una sola indexada o cero indexados a lo largo de cualquiera de los ejes (es decir, la esquina superior izquierda puede ser cualquiera de (0, 0), (0, 1), (1, 0), (1, 1).
• La salida debe ser tan unicode-art como se describe. La salida puede no tener nuevas líneas iniciales y puede tener como máximo una nueva línea final (después de la última línea). Los espacios en blanco finales se ignorarán a los efectos de este desafío.

Puntos de código

Las tuberías horizontales y verticales en negrita y ligeras están en el rango [U+2500, U+2503]. Los diversos tubos de esquina están en el rango [U+250C, U+251C). Las tuberías de tres brazos están en el rango [U+251C, U+253C). Las tuberías de cuatro brazos están en el rango [U+253C, U+254C). Las tuberías restantes que se pueden encontrar en mi programa nunca se usan realmente.

Python 3 , 289 286 bytes

l,u=eval(input())
*_,w,h=map(max,zip(*l))
r=[*map(list,[' '*-~w]*-~h)]
R=range
for x,y,X,Y in l:
 for i in R(x,X+1):
  for j in R(y,Y+1):Q=i<X,y<j,x<i,j<Y;r[j][i]=u[sum(3**o*max(Q[o]*[j in(y,Y),i in(x,X)][o%2]*2,u.index(r[j][i])//3**o%3-Q[o])for o in R(4))]
for l in r:print(''.join(l))

Pruébalo en línea!

Toma la entrada como una lista de 4-tuplas:, (x0, y0, x1, y1)junto con los caracteres de dibujo de la siguiente manera:" ╶╺╵└┕╹┖┗╴─╼┘┴┶┚┸┺╸╾━┙┵┷┛┹┻╷┌┍│├┝╿┞┡┐┬┮┤┼┾┦╀╄┑┭┯┥┽┿┩╃╇╻┎┏╽┟┢┃┠┣┒┰┲┧╁╆┨╂╊┓┱┳┪╅╈┫╉╋"

Admite cajas de ancho o alto cero (usa todos los caracteres de dibujo de caja).

Basado en mi respuesta a esta pregunta , pero modificado para alterar cuadros existentes al dibujar.

'Sin golf':

u=" ╶╺╵└┕╹┖┗╴─╼┘┴┶┚┸┺╸╾━┙┵┷┛┹┻╷┌┍│├┝╿┞┡┐┬┮┤┼┾┦╀╄┑┭┯┥┽┿┩╃╇╻┎┏╽┟┢┃┠┣┒┰┲┧╁╆┨╂╊┓┱┳┪╅╈┫╉╋"

#Create array of spaces:
l=eval(input())
w,h=list(map(max,zip(*l)))[2:]
r=[[' ']*w for _ in' '*h]

for x,y,X,Y in l:
 n,m=X-1,Y-1
 for i in range(x,X):
  for j in range(y,Y):
   A,B=j in(y,m),i in(x,n)
   P=(i<n*A,y<j*B,x<i*A,j<m*B)   # Pipe sides of the new box
   Q=(i<n,y<j,x<i,j<m)           # Pipe sides that are inside the new box, and should be thinned.
   # Get new pipe (sides of new box, on top of thinned pipes of existing boxes. (u.index... is existing pipe))
   l=sum(3**o*max(P[o]*2,(u.index(r[j][i])//3**o%3)-Q[o])for o in range(4))
   #Add to 'canvas'
   r[j][i]=u[l]

print('\n'.join(''.join(l)for l in r))

JavaScript (ES6), 298 261 bytes

(a,u,m=n=>[...Array(1+Math.max(...a.map(t=>t[n])))])=>m(3).map((_,j)=>m(2).map((_,i)=>u[a.reduce((c,[x,y,v,w])=>i<x|j<y|i>v|j>w?c:(g=n=>c-=c/n%3|0&&n,h=n=>c+=n*(2-(c/n%3|0)),[i>x&&9,i<v].map(j>y&j<w?g:h),[j>y&&3,j<w&&27].map(i>x&i<v?g:h),c),0)]).join``).join`\n`

Donde \nrepresenta el carácter de nueva línea literal. Basado en mi respuesta a los rectángulos Unicode . Explicación: Se crea una matriz de cadenas de espacios para dibujar. Cada espacio se procesa haciendo un bucle sobre todos los cuadros de la entrada. Los caracteres que se encuentran fuera del cuadro se ignoran, pero los que están en el borde o en el interior se procesan más. Para cada uno de los cuatro segmentos de línea que forman un carácter (cada uno representado por una potencia de 3), existen tres posibilidades; a) el segmento se encuentra justo fuera de la caja y debe ignorarse (logrado pasando un parámetro de 0 en lugar de la potencia de 3) b) el segmento se encuentra en el borde de la caja y debe estar en negrita (logrado llamando alh función) c) el segmento se encuentra dentro de la caja y debe aligerarse (se logra llamando algfunción). El carácter se indexa en la cadena Unicode. Una vez que se han procesado todos los cuadros, la matriz se une en nuevas líneas.

f=
(a,u,m=n=>[...Array(1+Math.max(...a.map(t=>t[n])))])=>m(3).map((_,j)=>m(2).map((_,i)=>u[a.reduce((c,[x,y,v,w])=>i<x|j<y|i>v|j>w?c:(g=n=>c-=c/n%3|0&&n,h=n=>c+=n*(2-(c/n%3|0)),[i>x&&9,i<v].map(j>y&j<w?g:h),[j>y&&3,j<w&&27].map(i>x&i<v?g:h),c),0)]).join``).join`
`
;u=" ╶╺╵└┕╹┖┗╴─╼┘┴┶┚┸┺╸╾━┙┵┷┛┹┻╷┌┍│├┝╿┞┡┐┬┮┤┼┾┦╀╄┑┭┯┥┽┿┩╃╇╻┎┏╽┟┢┃┠┣┒┰┲┧╁╆┨╂╊┓┱┳┪╅╈┫╉╋";
[[
[0, 0, 5, 5],
[5, 5, 10, 10],
[3, 3, 7, 7],
[2, 2, 8, 8],
],[
[14, 5, 15, 9],
[13, 2, 15, 16],
[6, 4, 15, 11],
],[
[6, 8, 10, 11],
[15, 12, 16, 16],
[14, 10, 16, 16],
[9, 1, 15, 15],
]].map(a=>document.write(`<pre style="font-family:Consolas,Menlo,Monaco,Lucida Console,Liberation Mono,DejaVu Sans Mono,Bitstream Vera Sans Mono,Courier New,monospace,sans-serif">${f(a,u)}</pre>`));