Lý lịch

Tôi muốn xây dựng một hàng rào. Vì thế, tôi đã thu thập được một loạt các cực, và mắc kẹt chúng xuống đất. Tôi cũng đã thu thập rất nhiều bảng mà tôi sẽ đóng đinh vào các cột để làm hàng rào thực tế. Tôi có xu hướng bị mang đi khi xây dựng công cụ, và rất có thể tôi sẽ tiếp tục đóng các tấm ván vào cột cho đến khi không còn chỗ nào để đặt chúng nữa. Tôi muốn bạn liệt kê những hàng rào có thể mà tôi có thể kết thúc.

Đầu vào

Đầu vào của bạn là một danh sách các tọa độ nguyên hai chiều đại diện cho các vị trí của các cực, ở bất kỳ định dạng thuận tiện nào. Bạn có thể cho rằng nó không chứa các bản sao, nhưng bạn không thể thừa nhận bất cứ điều gì về thứ tự của nó.

Các bảng được thể hiện bằng các đường thẳng giữa các cực, và để đơn giản, chúng tôi chỉ xem xét các bảng ngang và dọc. Hai cực có thể được nối bởi một bảng nếu không có các cực hoặc bảng khác giữa chúng, có nghĩa là các bảng không thể giao nhau. Một sự sắp xếp các cực và bảng là tối đa nếu không có bảng mới nào có thể được thêm vào nó (tương đương, có một cực hoặc một bảng giữa bất kỳ hai cực theo chiều ngang hoặc dọc).

Đầu ra

Đầu ra của bạn là số lượng sắp xếp tối đa có thể được xây dựng bằng cách sử dụng các cực.

Thí dụ

Xem xét danh sách đầu vào

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

Nhìn từ trên xuống, sự sắp xếp các cực tương ứng trông giống như thế này:

  o
 o o
o    o
 o o
  o

Có chính xác ba cách sắp xếp tối đa có thể được xây dựng bằng các cực này:

  o        o        o
 o-o      o|o      o-o
o----o   o||| o   o| | o
 o-o      o|o      o-o
  o        o        o

Do đó, đầu ra chính xác là 3.

Quy tắc

Bạn có thể viết một hàm hoặc một chương trình đầy đủ. Số byte thấp nhất sẽ thắng và các sơ hở tiêu chuẩn không được phép.

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

[] -> 1
[(0,0),(1,1),(2,2)] -> 1
[(0,0),(1,0),(2,0)] -> 1
[(0,0),(0,1),(1,0),(1,1)] -> 1
[(1,0),(0,1),(-1,0),(0,-1)] -> 2
[(3,0),(1,1),(0,2),(-1,1),(-2,0),(-1,-1),(0,-2),(1,-1)] -> 3
[(0,0),(4,0),(1,1),(1,-2),(3,1),(3,-2),(2,-1),(4,-1)] -> 3
[(0,0),(4,0),(1,1),(1,-2),(3,1),(3,-2),(2,-1),(4,-1),(0,-1)] -> 4
[(0,0),(4,0),(1,1),(1,-2),(3,1),(3,-2),(2,-1),(0,-1),(2,2)] -> 5
[(0,0),(4,0),(1,1),(1,-2),(3,1),(3,-2),(2,-1),(4,-1),(0,-1),(2,2)] -> 8

Toán học, 301 byte

(t~SetAttributes~Orderless;u=Subsets;c=Complement;l=Select;f=FreeQ;Count[s=List@@@l[t@@@u[Sort@l[Sort/@#~u~{2},!f[#-#2&@@#,0]&]//.{a___,{x_,y_},{x_,z_},b___,{y_,z_},c___}:>{a,{x,y},b,{y,z},c}],f[#,t[{{a_,b_},{a_,c_}},{{d_,e_},{f_,e_}},___]/;d<a<f&&b<e<c]&],l_/;f[s,k_List/;k~c~l!={}&&l~c~k=={},{1}]])&

Đây là một hàm không tên, lấy tọa độ là một lồng Listvà trả về một số nguyên. Đó là, bạn có thể đặt tên cho nó và gọi nó, hoặc chỉ nối thêm

@ {{3, 0}, {1, 1}, {0, 2}, {-1, 1}, {-2, 0}, {-1, -1}, {0, -2}, {1, -1}}

Với vết lõm:

(
  t~SetAttributes~Orderless;
  u = Subsets;
  c = Complement;
  l = Select;
  f = FreeQ;
  Count[
    s = List @@@ l[
      t @@@ u[
        Sort @ l[
          Sort /@ #~u~{2}, 
          !f[# - #2 & @@ #, 0] &
        ] //. {a___, {x_, y_}, {x_, z_}, b___, {y_, z_}, c___} :> 
              {a, {x, y}, b, {y, z}, c}
      ],
      f[
        #,
        t[{{a_, b_}, {a_, c_}}, {{d_, e_}, {f_, e_}}, ___] 
          /; d < a < f && b < e < c
      ] &
    ], 
    l_ /; f[
      s, 
      k_List /; k~c~l != {} && l~c~k == {}, 
      {1}
    ]
  ]
) &

Tôi thậm chí không thể bắt đầu bày tỏ sự triển khai ngây thơ này như thế nào ... nó chắc chắn không thể mạnh mẽ hơn ...

• Nhận tất cả các cặp cực (không có thứ tự).
• Sắp xếp từng cặp và tất cả các cặp theo thứ tự chính tắc.
• Hủy các cặp không chia sẻ một tọa độ (nghĩa là không thể kết nối bằng một đường trực giao).
• Hủy cặp có thể được hình thành từ hai cặp ngắn hơn (do đó o--o--ochỉ mang lại hai hàng rào thay vì ba).
• Nhận tất cả các tập hợp con của các cặp đó - tức là tất cả các kết hợp hàng rào có thể.
• Lọc ra các kết hợp có hàng rào giao nhau.
• Đếm số lượng bộ hàng rào kết quả mà không có superset nghiêm ngặt nào có thể được tìm thấy trong danh sách.

Đáng ngạc nhiên là nó giải quyết tất cả các trường hợp thử nghiệm gần như ngay lập tức.

Một mẹo thực sự gọn gàng mà tôi phát hiện ra cho việc này là sử dụng Orderlessđể cắt giảm số lượng mẫu tôi phải khớp. Về cơ bản, khi tôi muốn bỏ các bộ hàng rào với hàng rào băng qua, tôi cần tìm một cặp hàng rào dọc và ngang và kiểm tra tình trạng trên chúng. Nhưng tôi không biết chúng sẽ xuất hiện theo thứ tự nào. Vì các mẫu danh sách thường phụ thuộc vào thứ tự, điều này sẽ dẫn đến hai mẫu thực sự dài. Vì vậy, thay vào đó tôi thay thế bằng danh sách xung quanh bằng một hàm tvới t @@@- không được xác định để nó được giữ nguyên. Nhưng chức năng đó là Orderless, vì vậy tôi chỉ có thể kiểm tra một thứ tự trong mẫu và Mathicala sẽ kiểm tra nó dựa trên tất cả các hoán vị. Sau đó, tôi đặt các danh sách trở lại vị trí với List @@@.

Tôi muốn có một tích hợp đó là a) Orderless, b) không Listable và c) không được xác định cho 0 đối số hoặc liệt kê đối số. Sau đó tôi có thể thay thế tbằng cách đó. Nhưng dường như không có một nhà điều hành như vậy.

Haskell, 318 byte

import Data.List
s=subsequences
k[(_,a,b),(_,c,d)]|a==c=f(\w->(1,a,w))b d|1<2=f(\w->(2,w,b))a c
f t u v=[t x|x<-[min u v+1..max u v-1]]
q l=nub[x|x<-map(k=<<)$s[a|a@[(_,n,m),(_,o,p)]<-s l,n==o||m==p],x++l==nubBy(\(_,a,b)(_,c,d)->a==c&&b==d)(x++l)]
m=q.map(\(a,b)->(0,a,b))
p l=sum[1|x<-m l,all(\y->y==x||x\\y/=[])$m l]

Cách sử dụng : p [(1,0),(0,1),(-1,0),(0,-1)]. Đầu ra:2

Làm thế nào nó hoạt động:

• tạo tất cả các danh sách con của danh sách đầu vào và giữ những danh sách có hai phần tử và với tọa độ x hoặc bằng y. Đây là danh sách tất cả các cặp cực nơi hàng rào có thể được xây dựng ở giữa.
• tạo tất cả danh sách con của nó
• thêm bảng cho mỗi danh sách
• xóa danh sách trong đó tọa độ xy xuất hiện hai lần (bảng và cực)
• xóa danh sách trùng lặp (chỉ bảng) để xử lý nhiều danh sách trống, vì các cực liền kề trực tiếp (ví dụ (1,0) và (1,1))
• giữ những thứ không thuộc danh sách phụ nghiêm ngặt của danh sách khác
• đếm danh sách còn lại