^{Remarque: l'art des cordes peut sembler horrible ici en raison de l'étrangeté de la police SE: P :(}

Étant donné une liste de quatre tuples représentant les coins des rectangles, dessinez des rectangles translucides les uns sur les autres dans cet ordre.

Pour ce défi, vous devez avoir la plus petite coordonnée dans le coin supérieur gauche et l'axe x augmenter vers la droite et l'axe y augmenter vers le bas.

Un quadruple (x0, y0, x1, y1)ou (x0, x1, y0, y1)représente les (x, y)paires de coordonnées des coins supérieur gauche et inférieur droit d'un rectangle (vous pouvez choisir l'un des deux formats pour les rectangles mais il doit être cohérent)

Qu'est-ce que j'entends par "rectangle translucide"? Eh bien, pour ce défi, vous utiliserez le caractère espace et la plupart des personnages de dessin de boîte ; en particulier, tous ceux utilisés pour dessiner des rectangles, y compris les caractères "gras". Lorsqu'un rectangle translucide est dessiné, toutes les lignes fines de l'espace occupé disparaissent d'abord et toutes les lignes en gras deviennent fines, puis le rectangle lui-même est dessiné en lignes en gras.

Par exemple, si vous dessinez un rectangle en haut à gauche puis en bas à droite, il pourrait ressembler à ceci:

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

Pour être clair, les lignes sont allégées (gras -> mince -> aucun) pour toutes les lignes strictement à l'intérieur du rectangle (par exemple, les lignes orientées vers le bas sont affectées pour le bord supérieur mais pas le bord inférieur).

Cas de test

Un certain nombre de lignes d'entrée seront données, suivies d'un art unicode, pour chaque cas de 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

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

Générez plus de cas de test!

Règles

• L'entrée peut être dans n'importe quel format raisonnable pour une liste de quatre tuples. L' entrée peut être indexé ou un zéro-indexé le long de chaque axe (ie le coin supérieur gauche peut être l'un quelconque de (0, 0), (0, 1), (1, 0), (1, 1).
• La sortie doit être aussi unicode que celle décrite. La sortie peut ne pas avoir de nouvelle ligne de début et peut avoir au plus une nouvelle ligne de fin (après la dernière ligne). Les espaces de fin seront ignorés aux fins de ce défi.

Points de code

Les tuyaux horizontaux et verticaux audacieux et légers sont dans la gamme [U+2500, U+2503]. Les différents tuyaux d'angle sont dans la gamme [U+250C, U+251C). Les tuyaux à trois bras sont à portée [U+251C, U+253C). Les tuyaux à quatre bras sont à portée [U+253C, U+254C). Les tuyaux restants qui peuvent être trouvés dans mon programme ne sont jamais réellement utilisés.

Python 3 , 289 286 octets

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

Essayez-le en ligne!

Prend la saisie sous forme de liste de 4 tuples (x0, y0, x1, y1):, avec les caractères de pipedrawing comme suit:" ╶╺╵└┕╹┖┗╴─╼┘┴┶┚┸┺╸╾━┙┵┷┛┹┻╷┌┍│├┝╿┞┡┐┬┮┤┼┾┦╀╄┑┭┯┥┽┿┩╃╇╻┎┏╽┟┢┃┠┣┒┰┲┧╁╆┨╂╊┓┱┳┪╅╈┫╉╋"

Prend en charge les boîtes de largeur ou hauteur zéro (utilise tous les caractères de dessin de boîte).

Basé sur ma réponse à cette question , mais modifié pour modifier les cases existantes lors du dessin.

'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 octets

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

Où \nreprésente le caractère de nouvelle ligne littéral. Basé sur ma réponse aux rectangles Unicode . Explication: Un tableau de chaînes d'espaces est créé pour être dessiné. Chaque espace est ensuite traité en bouclant sur toutes les cases de l'entrée. Les caractères qui se trouvent à l'extérieur de la boîte sont ensuite ignorés, mais ceux sur le bord ou à l'intérieur sont traités davantage. Pour chacun des quatre segments de ligne constituant un personnage (chacun représenté par une puissance de 3), il y a alors trois possibilités; a) le segment se trouve juste à l'extérieur de la boîte et doit être ignoré (obtenu en passant un paramètre de 0 au lieu de la puissance de 3) b) le segment se trouve sur le bord de la boîte et doit être en gras (obtenu en appelant la hfonction) c) le segment se trouve à l'intérieur de la boîte et doit être allégé (obtenu en appelant legune fonction). Le caractère est ensuite indexé dans la chaîne Unicode. Une fois que toutes les cases ont été traitées, le tableau est ensuite joint sur les nouvelles lignes.

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