^{nota: l'arte della stringa potrebbe sembrare orribile qui a causa della stranezza del carattere SE: P :(}

Dato un elenco di quattro tuple che rappresentano gli angoli dei rettangoli, disegna rettangoli traslucidi l'uno sull'altro in quell'ordine.

Per questa sfida, è necessario avere la coordinata più piccola nell'angolo in alto a sinistra e l'asse x in aumento a destra e l'asse y in aumento verso il basso.

Una quadrupla (x0, y0, x1, y1)o (x0, x1, y0, y1)rappresenta le (x, y)coppie di coordinate degli angoli in alto a sinistra e in basso a destra di un rettangolo (puoi scegliere uno dei due formati per i rettangoli ma deve essere coerente)

Cosa intendo per "rettangolo traslucido"? Bene, per questa sfida, utilizzerai il personaggio spaziale e la maggior parte dei personaggi del disegno a scatola ; in particolare, tutti quelli utilizzati per disegnare rettangoli, compresi i caratteri "in grassetto". Quando viene disegnato un rettangolo traslucido, prima scompaiono tutte le linee sottili nello spazio occupato e tutte le linee in grassetto diventano sottili, quindi il rettangolo stesso viene tracciato in linee in grassetto.

Ad esempio, se disegni un rettangolo in alto a sinistra e poi in basso a destra, potrebbe assomigliare a questo:

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

Per essere chiari, le linee vengono schiarite (grassetto -> sottile -> nessuna) per tutte le linee rigorosamente all'interno del rettangolo (ad esempio, le linee rivolte verso il basso sono interessate dal bordo superiore ma non dal bordo inferiore).

Casi test

Verrà fornito un numero di righe di input, seguito da unicode-art, per ciascun caso di test.

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 più casi di test!

Regole

• L'input può essere in qualsiasi formato ragionevole per un elenco di quattro tuple. Ingresso può essere uno indicizzato o zero indicizzati lungo uno degli assi (cioè l'angolo superiore sinistro può essere qualsiasi (0, 0), (0, 1), (1, 0), (1, 1).
• L'output deve essere unicode-art come descritto. L'output potrebbe non avere newline iniziali e al massimo una newline finale (dopo l'ultima riga). Gli spazi vuoti finali verranno ignorati ai fini di questa sfida.

Code-punti

I tubi orizzontali e verticali audaci e leggeri sono nella gamma [U+2500, U+2503]. I vari tubi angolari sono nella gamma [U+250C, U+251C). I tubi a tre bracci sono nella gamma [U+251C, U+253C). I tubi a quattro bracci sono nella gamma [U+253C, U+254C). Le rimanenti pipe che si possono trovare nel mio programma non vengono mai effettivamente utilizzate.

Python 3 , 289 286 byte

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

Provalo online!

Prende l'input come un elenco di 4 tuple: (x0, y0, x1, y1)insieme ai caratteri di disegno come segue:" ╶╺╵└┕╹┖┗╴─╼┘┴┶┚┸┺╸╾━┙┵┷┛┹┻╷┌┍│├┝╿┞┡┐┬┮┤┼┾┦╀╄┑┭┯┥┽┿┩╃╇╻┎┏╽┟┢┃┠┣┒┰┲┧╁╆┨╂╊┓┱┳┪╅╈┫╉╋"

Supporta scatole di larghezza o altezza pari a zero (utilizza tutti i caratteri di disegno delle scatole).

Basato sulla mia risposta a questa domanda , ma modificato per modificare le caselle esistenti durante il disegno.

'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), 298 261 byte

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

Dove funzione). Il carattere viene quindi indicizzato nella stringa Unicode. Una volta che tutte le caselle sono state elaborate, l'array viene quindi unito su newline.\n rappresenta il carattere letterale di newline. Sulla base della mia risposta ai rettangoli Unicode . Spiegazione: Viene creata una matrice di stringhe di spazi per disegnare. Ogni spazio viene quindi elaborato ripetendo ciclicamente tutte le caselle nell'input. I personaggi che si trovano all'esterno del riquadro vengono quindi ignorati ma quelli sul bordo o all'interno vengono elaborati ulteriormente. Per ciascuno dei quattro segmenti di linea che compongono un personaggio (ciascuno rappresentato da una potenza di 3) ci sono quindi tre possibilità; a) il segmento si trova appena fuori dalla scatola e dovrebbe essere ignorato (ottenuto passando un parametro di 0 invece della potenza di 3) b) il segmento si trova sul bordo della scatola e dovrebbe essere in grassetto (ottenuto chiamando la hfunzione) c) il segmento si trova all'interno della scatola e dovrebbe essere alleggerito (ottenuto chiamando ilg

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