^{nota: a arte das cordas pode parecer horrível aqui por causa da estranheza da fonte SE: P :(}

Dada uma lista de quatro tuplas representando os cantos dos retângulos, desenhe retângulos translúcidos um sobre o outro nessa ordem.

Para esse desafio, você deve ter a menor coordenada no canto superior esquerdo e o eixo x aumentando para a direita e o eixo y aumentando para baixo.

Uma tupla de quatro (x0, y0, x1, y1)ou (x0, x1, y0, y1)representa os (x, y)pares de coordenadas dos cantos superior esquerdo e inferior direito de um retângulo (você pode escolher um dos dois formatos para retângulos, mas deve ser consistente)

O que quero dizer com "retângulo translúcido"? Bem, para esse desafio, você usará o caractere de espaço e a maioria dos caracteres de desenho de caixa ; especificamente, todos os usados ​​para desenhar retângulos, incluindo caracteres "em negrito". Quando um retângulo translúcido é desenhado, primeiro todas as linhas finas no espaço ocupado desaparecem e todas as linhas em negrito se tornam finas e, em seguida, o próprio retângulo é desenhado em linhas em negrito.

Por exemplo, se você desenhar um retângulo na parte superior esquerda e depois na parte inferior direita, pode ser algo como isto:

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

Para ficar claro, as linhas são iluminadas (negrito -> fino -> nenhum) para todas as linhas estritamente dentro do retângulo (por exemplo, as linhas voltadas para baixo são afetadas pela borda superior, mas não pela borda inferior).

Casos de teste

Algum número de linhas de entrada será fornecido, seguido pela arte em Unicode, para cada caso de teste.

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

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

Gere mais casos de teste!

Regras

• A entrada pode estar em qualquer formato razoável para uma lista de quatro tuplas. A entrada pode ser um indexado ou zero indexados ao longo de cada eixo (isto é, o canto superior esquerdo pode ser qualquer um de (0, 0), (0, 1), (1, 0), (1, 1).
• A saída deve ter a arte unicode conforme descrito. A saída pode não ter novas linhas iniciais e pode ter no máximo uma nova linha à direita (após a última linha). O espaço em branco à direita será ignorado para os propósitos deste desafio.

Pontos de código

Os tubos horizontais e verticais em negrito e leves estão na faixa [U+2500, U+2503]. Os vários tubos de canto estão no intervalo [U+250C, U+251C). Os canos de três braços estão ao alcance [U+251C, U+253C). Os canos de quatro braços estão ao alcance [U+253C, U+254C). Os tubos restantes que podem ser encontrados no meu programa nunca são realmente usados.

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

Experimente online!

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

Suporta caixas com largura ou altura zero (usa todos os caracteres de desenho da caixa).

Com base na minha resposta a esta pergunta , mas modificado para alterar as caixas existentes ao desenhar.

'Ungolfed':

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), 298261 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`

Onde\n representa o caractere literal de nova linha. Com base na minha resposta aos retângulos Unicode . Explicação: Uma matriz de cadeias de espaços é criada para atrair. Cada um desses espaços é processado fazendo um loop sobre todas as caixas na entrada. Os caracteres que ficam fora da caixa são ignorados, mas os que estão na borda ou no interior são processados ​​ainda mais. Para cada um dos quatro segmentos de linha que compõem um caractere (cada um representado por uma potência de 3), existem três possibilidades; a) o segmento fica fora da caixa e deve ser ignorado (obtido com a passagem de um parâmetro de 0 em vez da potência de 3) b) o segmento fica na borda da caixa e deve estar em negrito (obtido chamando a hfunção) c) o segmento fica dentro da caixa e deve ser iluminado (alcançado chamando ogfunção). O caractere é então indexado na cadeia Unicode. Depois que todas as caixas foram processadas, a matriz é unida em novas linhas.

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