Đầu vào

Đầu vào của bạn trong thử thách này là một danh sách các cặp số nguyên. Chúng đại diện cho các góc phía tây nam của hình vuông đơn vị trên mặt phẳng, và danh sách đại diện cho liên minh của chúng như là một tập hợp con của mặt phẳng. Ví dụ, danh sách

[(0,0),(1,0),(0,1),(1,1),(2,1),(1,2),(2,2)]

đại diện cho bộ màu đỏ trong hình này:

Đầu ra

Đầu ra Yor là một danh sách gồm bốn số nguyên, biểu diễn các tập con hình chữ nhật của mặt phẳng. (x,y,w,h)Rõ ràng hơn, một bộ tứ sẽ lặp lại một hình chữ nhật có chiều rộng w > 0và chiều cao h > 0có góc phía tây nam (x,y). Các hình chữ nhật phải tạo thành một vùng bao phủ chính xác của khu vực đầu vào, theo nghĩa là mỗi hình vuông đơn vị là một tập hợp con của một số hình chữ nhật, mỗi hình chữ nhật là một tập hợp con của khu vực và hai hình chữ nhật chỉ có thể chồng lên nhau ở viền của chúng. Để cấm các giải pháp tầm thường, lớp phủ không được chứa hai hình chữ nhật có thể được hợp nhất thành một hình chữ nhật lớn hơn.

Ví dụ, danh sách

[(0,0,2,1),(0,1,3,1),(1,2,2,1)]

đại diện cho pháp luật

của khu vực trên, trong khi bao gồm

[(0,0,2,2),(2,1,1,1),(1,2,1,1),(2,2,1,1)]

là bất hợp pháp, vì các ô vuông 1 cạnh 1 có thể được hợp nhất:

Quy tắc

Bạn có thể cung cấp một chương trình đầy đủ hoặc một chức năng. Định dạng chính xác của đầu vào và đầu ra không quan trọng, trong lý do. Số byte ngắn nhất sẽ thắng và các sơ hở tiêu chuẩn không được phép. Bạn được khuyến khích cung cấp một lời giải thích về thuật toán của bạn và một số ví dụ đầu ra.

Các trường hợp thử nghiệm

Vùng hình chữ U:

[(0,0),(0,1),(0,2),(0,3),(0,4),(0,5),(1,0),(1,1),(1,2),(1,3),(1,4),(1,5),(2,0),(2,1),(3,0),(3,1),(4,0),(4,1),(4,2),(4,3),(4,4),(4,5),(5,0),(5,1),(5,2),(5,3),(5,4),(5,5)]

Một hình tam giác lớn:

[(0,0),(0,1),(0,2),(0,3),(0,4),(0,5),(0,6),(0,7),(0,8),(0,9),(1,0),(1,1),(1,2),(1,3),(1,4),(1,5),(1,6),(1,7),(1,8),(2,0),(2,1),(2,2),(2,3),(2,4),(2,5),(2,6),(2,7),(3,0),(3,1),(3,2),(3,3),(3,4),(3,5),(3,6),(4,0),(4,1),(4,2),(4,3),(4,4),(4,5),(5,0),(5,1),(5,2),(5,3),(5,4),(6,0),(6,1),(6,2),(6,3),(7,0),(7,1),(7,2),(8,0),(8,1),(9,0)]

Một hình vuông có lỗ:

[(0,0),(0,1),(0,2),(0,3),(0,4),(0,5),(0,6),(0,7),(0,8),(1,0),(1,1),(1,2),(1,3),(1,4),(1,5),(1,6),(1,7),(1,8),(1,9),(2,0),(2,1),(2,2),(2,3),(2,4),(2,5),(2,6),(2,7),(2,8),(2,9),(3,0),(3,1),(3,2),(3,4),(3,5),(3,6),(3,7),(3,8),(3,9),(4,0),(4,1),(4,2),(4,3),(4,4),(4,5),(4,6),(4,7),(4,8),(4,9),(5,0),(5,1),(5,2),(5,3),(5,4),(5,5),(5,7),(5,8),(5,9),(6,1),(6,2),(6,3),(6,5),(6,6),(6,7),(6,8),(6,9),(7,0),(7,1),(7,2),(7,3),(7,4),(7,5),(7,6),(7,7),(7,8),(7,9),(8,0),(8,1),(8,2),(8,3),(8,4),(8,5),(8,6),(8,7),(8,8),(8,9),(9,0),(9,1),(9,2),(9,3),(9,4),(9,5),(9,6),(9,7),(9,8),(9,9)]

Các khu vực bị ngắt kết nối:

[(0,0),(0,1),(0,2),(0,3),(0,4),(0,5),(0,6),(0,7),(0,8),(1,0),(1,1),(1,2),(1,3),(1,4),(1,6),(1,7),(1,8),(1,9),(2,1),(2,2),(2,3),(2,4),(2,5),(2,6),(2,7),(2,8),(2,9),(4,0),(4,1),(4,2),(4,4),(4,5),(4,6),(4,7),(4,8),(4,9),(5,0),(5,1),(5,2),(5,3),(5,4),(5,5),(5,6),(5,7),(5,8),(5,9),(6,0),(6,1),(6,2),(6,4),(6,5),(6,6),(6,7),(6,8),(6,9),(8,0),(8,1),(8,2),(8,3),(8,4),(8,5),(8,6),(8,7),(8,8),(8,9),(9,0),(9,1),(9,2),(9,3),(9,7),(9,8),(9,9),(10,0),(10,1),(10,2),(10,3),(10,4),(10,5),(10,6),(10,7),(10,8),(10,9)]

Trình xác minh

Sử dụng này chương trình Python 2 để xác minh giải pháp của bạn. Nó lấy từ STDIN một danh sách các bộ dữ liệu (đầu vào) và danh sách các bộ tứ (đầu ra của bạn), được phân tách bằng dấu phẩy.

Tôi cũng viết này chương trình Python 2 để tạo ra các hình ảnh, và bạn có thể sử dụng nó quá. Nó lấy từ STDIN một danh sách các bộ dữ liệu hoặc bộ tứ và tạo ra một tệp có tên out.png. Nó đòi hỏi thư viện PIL. Bạn có thể thay đổi kích thước của các ô lưới và chiều rộng của các đường gird, nếu bạn muốn.

Con trăn: 196 193 182 ký tự

def g(r):
 for p in r:
  for q in r:
   for h in 0,1:
    if p[h::2]==q[h::2]and p[1-h]+p[~h]==q[1-h]:p[~h]+=q[~h];r.remove(q);return g(r)
 return r
f=lambda P:g([x+[1,1]for x in P])

Giải pháp đầu tiên của tôi sử dụng thuật toán chính xác giống như KSFT, do đó tôi đã thử nghiệm các phương pháp khác.

Đầu tiên tôi thực hiện một số tiền xử lý, tôi chuyển đổi tất cả các điểm thành các hình chữ nhật 1x1 nhỏ {x+(1,1)for x in P}. Với các hình chữ nhật này, tôi gọi hàm g. glặp đi lặp lại qua mỗi sự kết hợp của hình chữ nhật. Nếu nó tìm thấy 2 hình chữ nhật, có thể được hợp nhất thành một hình chữ nhật lớn hơn, nó sẽ xóa cả hai và nối thêm cái mới. Sau đó, nó gọi chính nó với bộ hình chữ nhật mới.

Sử dụng

f([[0,0],[1,0],[0,1],[1,1],[2,1],[1,2],[2,2]])

Các kết quả

Dưới đây là hình dung của kết quả. Lưu ý rằng chúng có thể hơi khác một chút trong phiên bản hiện tại. Ý tưởng là mặc dù, không có loại mô hình đáng chú ý.

Vùng hình chữ U:

Một hình tam giác lớn

Một hình vuông có lỗ:

Các khu vực bị ngắt kết nối:

Chỉ để cho vui: Pyth: 73 69 ký tự

D!HFGHFZHV2I&q%2>GN%2>ZNqs%2>G-1N@Z-1N X-3NG@Z-3NR!-H]Z)))RH!m+d*2]1Q

Chỉ hoạt động trong phiên bản ngoại tuyến. Lỗi trong phiên bản trực tuyến đã được sửa. Hãy thử ở đây: Trình biên dịch / thực thi Pyth . Mong đợi một danh sách các danh sách, không phải là một danh sách các bộ dữ liệu.

chỉnh sửa: Đã sử dụng một ý tưởng từ @ edc65: Thay vì xóa cả hai hình chữ nhật và tạo một hình mới, tôi thao tác một và chỉ xóa một. Trong giải pháp Python, tôi có thể sử dụng các bộ và các bộ tuple-list-tuple. -11 ký tự trong Python / -4 ký tự trong Pyth

Con trăn - 272 261 258 251 224

Tôi nghĩ rằng tôi có thể chơi golf này nhiều hơn. Tôi khá chắc chắn rằng điều này hoạt động, nhưng tôi chưa hoàn thành thử nghiệm trên tất cả các trường hợp thử nghiệm. Tôi đã hoàn thành thử nghiệm nó. Nó hoạt động cho tất cả các trường hợp thử nghiệm.

a=sorted(input())
b=[]
r=range
for i in a:
 c=set(a)-set(b);w=h=1;x,y=i
 if i in b:continue
 while not{(x,y+h)}-c:h+=1
 while all((x+w,y+j)in c for j in r(h)):w+=1
 for j in r(w):
  for k in r(h):b+=(j+x,k+y),
 print x,y,w,h

Tôi đang làm việc để thêm hình ảnh của kết quả. Chỉnh sửa: Dưới đây là kết quả từ ví dụ và các trường hợp thử nghiệm:

Tôi đang cố gắng viết điều này bằng Perl, nhưng tôi không thể tìm ra làm thế nào để có được các mảng đa chiều từ stdin mà không có một số lượng lớn các ký tự. Có ai có bất cứ đề nghị?

Con trăn 2, 139

Chương trình chấp nhận danh sách các cặp theo thứ tự được bao quanh bởi dấu ngoặc nhọn trên đầu vào tiêu chuẩn. Ví dụ,{(0,0),(1,0),(0,1),(1,1),(2,1),(1,2),(2,2)}

s=input()
while s:x,y=min(s);w=h=0;exec"while(x+w,y)in s:w+=1\nwhile%s<=s:s-=%s;h+=1"%(("{(X,y+h)for X in range(x,x+w)}",)*2);print x,y,w,h

Điều này thường gây khó chịu (không chỉ trong golf) mà Python không cho phép bài tập bên trong bài kiểm tra vòng lặp. Để giải quyết vấn đề này, tôi đã sử dụng các hoạt động định dạng chuỗi.

Toán học - 315 285 267 byte

f=(r={};For[m=MemberQ;t=Table;s=Sort@#,s!={},For[{x,y,w,h}=#~Join~{1,1}&@@s;i=j=0,i<1||j<1,If[s~m~{x+w,y+a-1}~t~{a,h}==True~t~{h},w++,i++];If[s~m~{x+a-1,y+h}~t~{a,w}==True~t~{w},h++,j++]];s=s~Cases~_?(!m[Join@@t[{x+a,y+b}-1,{a,w},{b,h}],#]&);r~AppendTo~{x,y,w,h}];r)&

Với sự giúp đỡ của @ MartinBüttner.

Ung dung:

f = (
    rectangles = {};
    For[squares = Sort[#], squares != {},
        For[{x, y, w, h} = Join[squares[[1]], {1, 1}]; i = j = 0, i < 1 || j < 1,
            If[Table[MemberQ[squares, {x + w, y + a - 1}], {a, h}] == Table[True, {h}], w++, i++];
            If[Table[MemberQ[squares, {x + a - 1, y + h}], {a, w}] == Table[True, {w}], h++, j++];
        ];
        squares = Cases[squares, _ ? (!MemberQ[Join@@Table[{x + a - 1, y + b - 1}, {a, w}, {b, h}], #] &)];
        AppendTo[rectangles, {x, y, w, h}]
    ];
    rectangles
)&

Sử dụng:

In: f @ {{0,0},{1,0},{0,1},{1,1},{2,1},{1,2},{2,2}}
Out: {{0, 0, 2, 2}, {1, 2, 2, 1}, {2, 1, 1, 1}}

Các trường hợp thử nghiệm

Một vùng hình chữ U

{{0, 0, 6, 2}, {0, 2, 2, 4}, {4, 2, 2, 4}}

Một hình tam giác lớn

{{0, 0, 6, 5}, {0, 5, 3, 3}, {0, 8, 2, 1}, {0, 9, 1, 1}, {3, 5, 2, 1}, {3, 6, 1, 1}, {6, 0, 3, 2}, {6, 2, 2, 1}, {6, 3, 1, 1}, {9, 0, 1, 1}}

Một hình vuông có lỗ

{{0, 0, 6, 3}, {0, 3, 3, 6}, {1, 9, 9, 1}, {3, 4, 3, 2}, {3, 6, 2, 3}, {4, 3, 6, 1}, {5, 7, 5, 2}, {6, 1, 4, 2}, {6, 5, 4, 2}, {7, 0, 3, 1}, {7, 4, 3, 1}}

Các vùng bị ngắt kết nối

{{0, 0, 2, 5}, {0, 5, 1, 4}, {1, 6, 2, 4}, {2, 1, 1, 5}, {4, 0, 3, 3}, {4, 4, 3, 6}, {5, 3, 1, 1}, {8, 0, 3, 4}, {8, 4, 1, 6}, {9, 7, 2, 3}, {10, 4, 1, 3}}

Haskell, 158

f[]=[]
f s@((x,y):_)=(x,y,w-x,h-y):f[r|r@(a,b)<-s,a<x||a>=w||b<y||b>=h]where w=[i|i<-[x..],notElem(i,y)s]!!0;h=[i|i<-[y..],not$all(\x->elem(x,i)s)[x..w-1]]!!0

trường hợp thử nghiệm và hình ảnh sẽ ở đây trong thời gian ngắn.

Thuật toán: Lấy hình vuông đầu tiên. Tiếp cận càng xa bên phải mà không gặp phải một hình vuông không có trong đầu vào. Sau đó tiếp cận càng xa càng tốt mà không có hình vuông không có trên đầu vào. Bây giờ chúng ta có một hình chữ nhật không có hình vuông bị thiếu. Thêm nó vào đầu ra, loại bỏ tất cả các hình vuông của nó khỏi đầu vào và gọi đệ quy.

JavaScript (ES6) 148 155 199

Edit2 Một số điều chỉnh khác
Chỉnh sửa Một số golf + viết lại bằng cách sử dụng đệ quy. Không ngờ lại giảm như vậy. Bây giờ hơi khó theo dõi, nhưng thuật toán thì giống nhau.

Thuật toán tương tự như câu trả lời @jakube.

1. Mỗi điểm trở thành một hình vuông 1x1 (tiền xử lý)
2. Đối với mỗi yếu tố, hãy kiểm tra xem nó có thể được hợp nhất với một yếu tố khác
   không? Phần tử thứ nhất phát triển, phần tử thứ hai bị xóa, bắt đầu lại ở bước 2
   Khác, tiến hành phần tử tiếp theo

F=l=>
  (l.map(x=>x.push(1,1)),R=f=>
    l.some(u=>
      (l=l.filter(t=>
        [0,1].every(p=>u[p]-t[p]|u[p^=2]-t[p]|u[p^=3]-t[p]+u[p^=2]||!(f=u[p]+=t[p]))
      ),f)
    )?R():l
  )()

Kiểm tra trong đoạn trích

F=l=>(l.map(x=>x.push(1,1)),R=f=>l.some(u=>(l=l.filter(t=>[0,1].every(p=>u[p]-t[p]|u[p^=2]-t[p]|u[p^=3]-t[p]+u[p^=2]||!(f=u[p]+=t[p]))),f))?R():l)()

// Test
MyCanvas.width= 600;
MyCanvas.height = 220;
var ctx = MyCanvas.getContext("2d");
ctx.fillStyle="#f23";

Draw=(x,y,f,l)=>l.forEach(p=>ctx.fillRect(x+p[0]*f,y+p[1]*f,p[2]*f-1||f-1,p[3]*f-1||f-1));

test=[
[[0,0],[1,0],[0,1],[1,1],[2,1],[1,2],[2,2]],
[[0,0],[0,1],[0,2],[0,3],[0,4],[0,5],[1,0],[1,1],[1,2],[1,3],[1,4],[1,5],[2,0],[2,1],[3,0],[3,1],[4,0],[4,1],[4,2],[4,3],[4,4],[4,5],[5,0],[5,1],[5,2],[5,3],[5,4],[5,5]],
[[0,0],[0,1],[0,2],[0,3],[0,4],[0,5],[0,6],[0,7],[0,8],[0,9],[1,0],[1,1],[1,2],[1,3],[1,4],[1,5],[1,6],[1,7],[1,8],[2,0],[2,1],[2,2],[2,3],[2,4],[2,5],[2,6],[2,7],[3,0],[3,1],[3,2],[3,3],[3,4],[3,5],[3,6],[4,0],[4,1],[4,2],[4,3],[4,4],[4,5],[5,0],[5,1],[5,2],[5,3],[5,4],[6,0],[6,1],[6,2],[6,3],[7,0],[7,1],[7,2],[8,0],[8,1],[9,0]],
[[0,0],[0,1],[0,2],[0,3],[0,4],[0,5],[0,6],[0,7],[0,8],[1,0],[1,1],[1,2],[1,3],[1,4],[1,5],[1,6],[1,7],[1,8],[1,9],[2,0],[2,1],[2,2],[2,3],[2,4],[2,5],[2,6],[2,7],[2,8],[2,9],[3,0],[3,1],[3,2],[3,4],[3,5],[3,6],[3,7],[3,8],[3,9],[4,0],[4,1],[4,2],[4,3],[4,4],[4,5],[4,6],[4,7],[4,8],[4,9],[5,0],[5,1],[5,2],[5,3],[5,4],[5,5],[5,7],[5,8],[5,9],[6,1],[6,2],[6,3],[6,5],[6,6],[6,7],[6,8],[6,9],[7,0],[7,1],[7,2],[7,3],[7,4],[7,5],[7,6],[7,7],[7,8],[7,9],[8,0],[8,1],[8,2],[8,3],[8,4],[8,5],[8,6],[8,7],[8,8],[8,9],[9,0],[9,1],[9,2],[9,3],[9,4],[9,5],[9,6],[9,7],[9,8],[9,9]],
[[0,0],[0,1],[0,2],[0,3],[0,4],[0,5],[0,6],[0,7],[0,8],[1,0],[1,1],[1,2],[1,3],[1,4],[1,6],[1,7],[1,8],[1,9],[2,1],[2,2],[2,3],[2,4],[2,5],[2,6],[2,7],[2,8],[2,9],[4,0],[4,1],[4,2],[4,4],[4,5],[4,6],[4,7],[4,8],[4,9],[5,0],[5,1],[5,2],[5,3],[5,4],[5,5],[5,6],[5,7],[5,8],[5,9],[6,0],[6,1],[6,2],[6,4],[6,5],[6,6],[6,7],[6,8],[6,9],[8,0],[8,1],[8,2],[8,3],[8,4],[8,5],[8,6],[8,7],[8,8],[8,9],[9,0],[9,1],[9,2],[9,3],[9,7],[9,8],[9,9],[10,0],[10,1],[10,2],[10,3],[10,4],[10,5],[10,6],[10,7],[10,8],[10,9]]
]

Draw(0,0,10,test[0]),Draw(0,110,10,F(test[0]))
Draw(50,0,10,test[1]),Draw(50,110,10,F(test[1]))
Draw(130,0,10,test[2]),Draw(130,110,10,F(test[2]))
Draw(250,0,10,test[3]),Draw(250,110,10,F(test[3]))
Draw(370,0,10,test[4]),Draw(370,110,10,F(test[4]))

<canvas id=MyCanvas></canvas>

Toán học, 153 151 144 136 133

Sort[{##,1,1}&@@@Input[]]//.{a___,r:{x_,y_,__},b___,{X_,Y_,W_,H_},c___}/;r=={x,Y,X-x,H}||r=={X,y,W,Y-y}:>{a,r+Sign@{0,0,X-x,Y-y},b,c}

Thí dụ:

Đầu vào:

{{0, 0}, {1, 0}, {0, 1}, {1, 1}, {2, 1}, {1, 2}, {2, 2}}

Đầu ra:

{{0, 0, 2, 2}, {1, 2, 2, 1}, {2, 1, 1, 1}}

Đầu vào:

{{0, 0}, {0, 1}, {0, 2}, {0, 3}, {0, 4}, {0, 5}, {0, 6}, {0, 7}, {0, 8}, {1, 0}, {1, 1}, {1, 2}, {1, 3}, {1, 4}, {1, 5}, {1, 6}, {1, 7}, {1, 8}, {1, 9}, {2, 0}, {2, 1}, {2, 2}, {2, 3}, {2, 4}, {2, 5}, {2, 6}, {2, 7}, {2, 8}, {2, 9}, {3, 0}, {3, 1}, {3, 2}, {3, 4}, {3, 5}, {3, 6}, {3, 7}, {3, 8}, {3, 9}, {4, 0}, {4, 1}, {4, 2}, {4, 3}, {4, 4}, {4, 5}, {4, 6}, {4, 7}, {4, 8}, {4, 9}, {5, 0}, {5, 1}, {5, 2}, {5, 3}, {5, 4}, {5, 5}, {5, 7}, {5, 8}, {5, 9}, {6, 1}, {6, 2}, {6, 3}, {6, 5}, {6, 6}, {6, 7}, {6, 8}, {6, 9}, {7, 0}, {7, 1}, {7, 2}, {7, 3}, {7, 4}, {7, 5}, {7, 6}, {7, 7}, {7, 8}, {7, 9}, {8, 0}, {8, 1}, {8, 2}, {8, 3}, {8, 4}, {8, 5}, {8, 6}, {8, 7}, {8, 8}, {8, 9}, {9, 0}, {9, 1}, {9, 2}, {9, 3}, {9, 4}, {9, 5}, {9, 6}, {9, 7}, {9, 8}, {9, 9}}

Đầu ra:

{{0, 0, 3, 9}, {1, 9, 9, 1}, {3, 0, 3, 3}, {3, 4, 1, 5}, {4, 3, 1, 6}, {5, 3, 1, 3}, {5, 7, 1, 2}, {6, 1, 1, 3}, {6, 5, 1, 4}, {7, 0, 3, 9}}

Thuật toán:

Che khu vực với các ô vuông đơn vị, sau đó hợp nhất chúng.