Tâche

Votre tâche consiste à écrire un programme qui produira des boîtes ASCII aux emplacements spécifiés par l'entrée.

Contribution

Vous recevrez une liste de numéros. Le format ici est un peu flexible, que vous pouvez utiliser deliminator vous voulez (par exemple 1,2,3,4, 1 2 3 4, [1,2,3,4]). La liste est en groupes de 4 et spécifie le xywhde chaque case. La largeur et la hauteur de chaque boîte seront d'au moins 2. xet widthsont de gauche à droite. yet heightsont de haut en bas.

Production

Le rendu peut être considéré comme de droite à gauche, avec la boîte à droite dessinée en premier, et chaque boîte après cela est dessus. Les espaces de fin sont autorisés, ainsi qu'une nouvelle ligne de fin.

Comment gérer les boîtes qui se chevauchent

La case à gauche de l'entrée est la case du haut, et rien ne la chevauchera. Chaque boîte après son rendu est uniquement dans l'espace qui n'est pas déjà contenu dans une boîte et ne remplacera pas la bordure d'une boîte déjà rendue.

Style

Le style des boîtes est assez standard, +utilisé pour les coins, -utilisé pour les lignes horizontales et |utilisé pour les lignes verticales.

Exemples:

( >>>indique une entrée)

>>>0 0 11 4 7 2 8 4 3 5 8 3
+---------+
|         |
|         |---+
+---------+   |
       |      |
   +---+------+
   |      |
   +------+


>>>0 3 11 4 7 5 8 4 3 8 8 3 4 0 13 5
    +-----------+
    |           |
    |           |
+---------+     |
|         |-----+
|         |---+
+---------+   |
       |      |
   +---+------+
   |      |
   +------+


>>>0 0 2 2
++
++


>>>2 2 5 3 1 1 7 5 0 0 9 7
+-------+
|+-----+|
||+---+||
|||   |||
||+---+||
|+-----+|
+-------+

>>>0 0 3 3 2 0 3 3
+-+-+
| | |
+-+-+

APL, 116 octets

{⎕IO←0⋄K←' '⍴⍨⌽+⌿2 2⍴⌈⌿↑⍵⋄K⊣{x y W H←⍵-⌊.5×⍳4⋄K[Y←y+⍳H;X←x+⍳W]←' '⋄K[Y;A←x+0 W]←'|'⋄K[B←y+0 H;X]←'-'⋄K[B;A]←'+'}¨⌽⍵}

Il s'agit d'une fonction qui prend un tableau de tableaux et renvoie une matrice de caractères.

Tests:

      t1← (0 0 11 4)(8 2 8 4)(3 5 8 3)
      t2← (0 3 11 4)(8 5 8 4)(3 8 8 3)(4 0 13 5)
      t3← (⊂0 0 2 2)
      t4← (2 2 5 3)(1 1 7 5)(0 0 9 7)
      {⎕IO←0⋄K←' '⍴⍨⌽+⌿2 2⍴⌈⌿↑⍵⋄K⊣{x y W H←⍵-⌊.5×⍳4⋄K[Y←y+⍳H;X←x+⍳W]←' '⋄K[Y;A←x+0 W]←'|'⋄K[B←y+0 H;X]←'-'⋄K[B;A]←'+'}¨⌽⍵} ¨ t1 t2 t3 t4
┌───────────────────┬─────────────────────┬────┬───────────┐
│+---------+        │    +-----------+    │++  │+-------+  │
│|         |        │    |           |    │++  │|+-----+|  │
│|         |----+   │    |           |    │    │||+---+||  │
│+---------+    |   │+---------+     |    │    │|||   |||  │
│        |      |   │|         |-----+    │    │||+---+||  │
│   +----+------+   │|         |----+     │    │|+-----+|  │
│   |      |        │+---------+    |     │    │+-------+  │
│   +------+        │        |      |     │    │           │
│                   │   +----+------+     │    │           │
│                   │   |      |          │    │           │
│                   │   +------+          │    │           │
│                   │                     │    │           │
│                   │                     │    │           │
└───────────────────┴─────────────────────┴────┴───────────┘

Explication:

• ⎕IO←0: définissez l'origine de l'index sur 0.
• Créez une matrice de la bonne taille:
  • ⌈⌿↑⍵: trouver les plus grandes valeurs pour x, y, w et h
  • +⌿2 2⍴: x + w et y + h
  • K←' '⍴⍨⌽: créez une matrice d'espaces x + w * y + h et stockez-la K.
• Dessinez-y les boîtes:
  • {... }¨⌽⍵: pour chacune des cases, dans l'ordre inverse,
    • x y W H←⍵-⌊.5×⍳4: Attribuer des coordonnées à x, y, W, et H, et soustraire 1 à la fois Wet H. (les coordonnées sont exclusives, les plages de tableaux APL sont inclusives.)
    • K[Y←y+⍳H;X←x+⍳W]←' ': remplir la case courante avec des espaces
    • K[Y;A←x+0 W]←'|': dessiner les côtés verticaux
    • K[B←y+0 H;X]←'-': dessiner les côtés horizontaux
    • K[B;A]←'+': définissez les bords sur '+'
  • K⊣: après, revenez K.

ES6, 228 223 217 208 201 198 198 octets

Accepte un tableau de tableaux de coordonnées et renvoie une chaîne.

a=>a.reverse().map(([x,y,w,h])=>[...Array(y+h)].map((_,i)=>(s=r[i]||'',r[i]=i<y?s:(s+' '.repeat(x)).slice(0,x)+(c=>c[0]+c[1].repeat(w-2)+c[0])(y-i&&y+h-1-i?'| ':'+-')+s.slice(x+w))),r=[])&&r.join`\n`

Où \nreprésente un caractère de nouvelle ligne.

Edit: sauvé 5 octets en inversant mes conditions. 6 octets supplémentaires enregistrés en passant d'un tableau de tableaux de caractères à un tableau de chaînes. 9 octets supplémentaires enregistrés en introduisant une variable temporaire. Enregistré 7 octets supplémentaires en introduisant une fonction d'assistance. Sauvegardé 3 octets supplémentaires en annulant une sauvegarde précédente!

Ruby, 153 143

->n{a=(0..m=3*n.max).map{$b=' '*m}
(*n,x,y,w,h=n 
v=w-2
h.times{|i|a[y+i][x,w]=i%~-h<1??++?-*v+?+:?|+' '*v+?|}
)while n[0]
a.delete($b);puts a}

Non testé dans le programme de test

f=->n{                                #worst case width when x=w=large number, is max input*2+1
  a=(1..m=3*n.max).map{$b=' '*m}      #find m=max value in input, make an a array of 3*m strings of 3*m spaces 
  (
    *n,x,y,w,h=n                      #extract x,y,w,h from the end of n, save the rest back to n     
    v=w-2                             #internal space in rectangle is w-2  
    h.times{|i|                       #for each row
      a[y+i][x,w]=                    #substitute the relevant characters of the relevant lines of a 
      i%~-h<1?                        #i%~-h = i%(h-1). This is zero (<1) for first and last lines of the rectangle
      ?+ + ?-*v + ?+ :?| + ' '*v +?|  # +--...--+ or |  ...  | as required
    }
  )while n[0]                         #loop until data exhausted (n[0] becomes falsy as it does not exist)
a.delete($b);puts a}                  #delete blank rows ($b is a global variable) and display

SmileBASIC, 128 125 octets

DEF B A
WHILE LEN(A)H=POP(A)W=POP(A)-2Y=POP(A)X=POP(A)FOR I=0TO H-1LOCATE X,Y+I?"+|"[M];"- "[M]*W;"+|"[M]M=I<H-2NEXT
WEND
END

Captures d'écran (recadrées)

Explication

DEF B A 'make a function and add 12 bytes :(
 WHILE LEN(A) 'repeat until array is empty
  H=POP(A):W=POP(A)-2 'get width/height
  Y=POP(A):X=POP(A) 'get x/y
  FOR I=0 TO H-1 'draw one row at a time
   LOCATE X,Y+I 'position the cursor
   PRINT "+|"[M]; 'draw left edge
   PRINT "- "[M]*W; 'draw middle
   PRINT "+|"[M] 'draw right edge
   M=I<H-2
  NEXT
 WEND
END

Mstocke si c'est sur la première / dernière ligne de la boîte ( 0= +--+, 1= | |). Lors du premier passage dans la boucle, il Mest égal à 0, et sur tous les autres jusqu'au dernier, il est égal à 1.

Pyth, 162 145 octets

J\+K*h.MZm+@d1@d3Q]*h.MZm+@d0@d2QdD:GHb XKHX@KHGb;V_QDlTR@NTVl3Vl2:+l0b+l1H?|qHtl3qH0\-?|qbtl2qb0\|d)):l0l1J:+l0tl2l1J:l0+l1tl3J:+l0tl2+l1tl3J;jK

Vous pouvez l'essayer ici

Sortie de la suite de tests:

+---------+     
|         |     
|         |----+
+---------+    |
        |      |
   +----+-+----+
   |      |     
   +------+     

++
++

+-------+
|+-----+|
||+---+||
|||   |||
||+---+||
|+-----+|
+-------+

+-+-+
| | |
+-+-+

Horrible solution! J'attends juste que quelqu'un le batte