Zadanie

Twoim zadaniem jest napisanie programu, który wyświetli pola ASCII w miejscach określonych przez dane wejściowe.

Wejście

Otrzymasz listę liczb. Format tutaj jest nieco elastyczny, że można użyć dowolnego deliminator chcesz (np 1,2,3,4, 1 2 3 4, [1,2,3,4]). Lista jest w grupach po 4 i określa xywhposzczególne pola. Szerokość i wysokość każdego pudełka będą wynosić co najmniej 2. xi widthbędą od lewej do prawej. yi heightsą od góry do dołu.

Wynik

Renderowanie można traktować jako od prawej do lewej, najpierw zaznaczając pole po prawej stronie, a po nim każde pole po nim. Dozwolone są spacje końcowe, a także jedna spacja nowej linii.

Jak obsługiwać nakładające się pola

Pole po lewej stronie danych wejściowych jest polem górnym i nic go nie nakłada. Każde pole po tym jest renderowane tylko w obszarze, który nie jest już zawarty w polu i nie zastąpi granicy już renderowanego pola.

Styl

Styl pól jest dość standardowy, z +narożnikami, -liniami poziomymi i |liniami pionowymi.

Przykłady:

( >>>oznacza wejście)

>>>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 bajtów

{⎕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]←'+'}¨⌽⍵}

Jest to funkcja, która pobiera tablicę tablic i zwraca macierz znaków.

Testy:

      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
┌───────────────────┬─────────────────────┬────┬───────────┐
│+---------+        │    +-----------+    │++  │+-------+  │
│|         |        │    |           |    │++  │|+-----+|  │
│|         |----+   │    |           |    │    │||+---+||  │
│+---------+    |   │+---------+     |    │    │|||   |||  │
│        |      |   │|         |-----+    │    │||+---+||  │
│   +----+------+   │|         |----+     │    │|+-----+|  │
│   |      |        │+---------+    |     │    │+-------+  │
│   +------+        │        |      |     │    │           │
│                   │   +----+------+     │    │           │
│                   │   |      |          │    │           │
│                   │   +------+          │    │           │
│                   │                     │    │           │
│                   │                     │    │           │
└───────────────────┴─────────────────────┴────┴───────────┘

Wyjaśnienie:

• ⎕IO←0: ustaw początek indeksu na 0.
• Utwórz macierz o odpowiednim rozmiarze:
  • ⌈⌿↑⍵: znajdź największe wartości dla x, y, w i h
  • +⌿2 2⍴: x + w oraz y + h
  • K←' '⍴⍨⌽: utwórz macierz spacji x + w * y + h i zapisz ją w K.
• Narysuj w nim pola:
  • {... }¨⌽⍵: dla każdego z pól w odwrotnej kolejności,
    • x y W H←⍵-⌊.5×⍳4: Przypisanie współrzędnych x, y, W, i H, i odjąć 1 od obu Wi H. (współrzędne są wyłączne, zakresy tablic APL są włącznie.)
    • K[Y←y+⍳H;X←x+⍳W]←' ': wypełnij bieżące pole spacjami
    • K[Y;A←x+0 W]←'|': narysuj pionowe boki
    • K[B←y+0 H;X]←'-': narysuj poziome boki
    • K[B;A]←'+': ustaw krawędzie na „+”
  • K⊣: potem wróć K.

ES6, 228 223 217 208 201 198 bajtów

Akceptuje tablicę tablic współrzędnych i zwraca ciąg znaków.

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`

Gdzie \nreprezentuje znak nowej linii.

Edycja: Zapisałem 5 bajtów, odwracając moje warunki. Zapisano kolejne 6 bajtów, przełączając się z tablicy tablic char na tablicę ciągów. Zapisano kolejne 9 bajtów, wprowadzając zmienną tymczasową. Zapisano kolejne 7 bajtów, wprowadzając funkcję pomocnika. Zapisano kolejne 3 bajty, cofając poprzednie zapisywanie!

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}

Niegolfowany w programie testowym

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 bajtów

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

Zrzuty ekranu (przycięte)

Wyjaśnienie

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

Mprzechowuje, czy znajduje się w pierwszym / ostatnim rzędzie pola ( 0= +--+, 1= | |). Przy pierwszym przejściu przez pętlę Mwynosi 0, a na wszystkich pozostałych do ostatniego - 1.

Pyth, 162 145 bajtów

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

Możesz spróbować tutaj

Dane wyjściowe zestawu testowego:

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

++
++

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

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

Straszne rozwiązanie! Tylko czekam, aż ktoś go pokona