Vấn đề : Đếm số lượng lỗ trong một đa giác được kết nối. Khả năng kết nối của đa giác được đảm bảo bởi điều kiện là mọi tam giác trong tam giác đầu vào chia sẻ ít nhất 1 cạnh với một tam giác khác và chỉ có một bộ tam giác được kết nối như vậy.

Đầu vào là danh sách Lcác nđiểm trong mặt phẳng và danh sách T3 điểm với các mục từ 0...n-1. Đối với mỗi mục trong Ttuple (t_1,t_2,t_3)đại diện cho ba đỉnh (từ danh sách L) của một tam giác trong tam giác. Lưu ý rằng đây là hình tam giác theo nghĩa 'tam giác đa giác' , vì điều này sẽ không bao giờ có hai hình tam giác trong Tsự chồng chéo đó. Một quy định bổ sung là bạn sẽ không phải vệ sinh đầu vào Lvà Tkhông chứa bất kỳ sự lặp lại nào.

Ví dụ 1 : Nếu L = {{0,0},{1,0},{0,1},{1,2}}và T = {{0,1,2},{1,2,3}}sau đó đa giác được chỉ định có số lỗ là 0.

Ví dụ 2 : Nếu L = {{0,0},{1,0},{2,0},{2,1},{2,2},{1,2},{0,2},{0,1},{.5,.5},{1.5,.5},{1.5,1.5},{.5,1.5}}và T = {{5,6,11},{5,10,11},{4,5,10},{3,8,10},{2,3,9},{2,8,9},{1,2,8},{0,1,8},{0,8,11},{0,7,11},{6,7,11},{3,4,10}}sau đó đầu vào đa giác sẽ dẫn đến đầu ra là 2.

Nhiệm vụ là viết chương trình (hoặc hàm) ngắn nhất nhận Lvà Tlàm đầu vào và trả về số lượng lỗ. 'Người chiến thắng' sẽ được công nhận là mục có số lượng ký tự ít nhất (ngày kết thúc dự kiến ​​là ngày 1 tháng 6).

Định dạng đầu vào mẫu (lưu ý lập chỉ mục 0):

0,0
1,0
0,1
1,2
0,1,2
1,2,3    

GolfScript (23 ký tự)

~.{2*2/~}%{$}%.&,@@+,-)

Giả sử định dạng đầu vào bằng cách sử dụng ký hiệu mảng GolfScript và tọa độ trích dẫn (hoặc tích phân). Ví dụ

$ golfscript codegolf11738.gs <<<END
[["0" "0"] ["1" "0"] ["2" "0"] ["2" "1"] ["2" "2"] ["1" "2"] ["0" "2"] ["0" "1"] [".5" ".5"] ["1.5" ".5"] ["1.5" "1.5"] [".5" "1.5"]] [[5 6 11] [5 10 11] [4 5 10] [3 8 10] [2 3 9] [2 8 9] [1 2 8] [0 1 8] [0 8 11] [0 7 11] [6 7 11] [3 4 10]]
END
2

(Tương đương trực tuyến )

hoặc là

$ golfscript codegolf11738.gs <<<END
[[0 0] [1 0] [0 1] [1 2]] [[0 1 2] [1 2 3]]
END
0

( Tương đương trực tuyến )

Con trăn, 71

Điều gì sau đây là một chương trình (không phải là một hàm ) tính toán số lượng mong muốn.

len(set().union(*(map(frozenset,zip(t,t[1:]+t))for t in T)))-len(L+T)+1

Ví dụ sử dụng:

>>> L = ((0,0),(1,0),(2,0),(2,1),(2,2),(1,2),(0,2),(0,1),(.5,.5),(1.5,.5),(1.5,1.5),(.5,1.5))
>>> T = ((5,6,11),(5,10,11),(4,5,10),(3,8,10),(2,3,9),(2,8,9),(1,2,8),(0,1,8),(0,8,11),(0,7,11),(6,7,11),(3,4,10))
>>> len(set().union(*(map(frozenset,zip(t,t[1:]+t))for t in T)))-len(L+T)+1
2

APL, 36

{1+(⍴⊃∪/{{⍵[⍋⍵]}¨,/3 2⍴⍵,⍵}¨⍵)-⍴⍺,⍵}

Hàm lấy Llàm đối số bên trái của nó vàT bên phải của nó.

Ví dụ:

      L←(0 0)(1 0)(0 1)(1 2)
      T←(0 1 2)(1 2 3)
      L{1+(⍴⊃∪/{{⍵[⍋⍵]}¨,/3 2⍴⍵,⍵}¨⍵)-⍴⍺,⍵}T
0
      L←(0 0)(1 0)(2 0)(2 1)(2 2)(1 2)(0 2)(0 1)(.5 .5)(1.5 .5)(1.5 1.5)(.5 1.5)
      T←(5 6 11)(5 10 11)(4 5 10)(3 8 10)(2 3 9)(2 8 9)(1 2 8)(0 1 8)(0 8 11)(0 7 11)(6 7 11)(3 4 10)
      L{1+(⍴⊃∪/{{⍵[⍋⍵]}¨,/3 2⍴⍵,⍵}¨⍵)-⍴⍺,⍵}T
2

Giải thích, đi từ phải sang trái:

• ⍴⍺,⍵ nối hai vectơ đầu vào và trả về độ dài của chúng (V + F )
• Bước vào bên trong khối tiếp theo:
  • ¨⍵ áp dụng hàm bên trái cho mọi phần tử của đối số bên phải và trả về kết quả
  • ⍵,⍵ trả về đúng đối số được nối với chính nó
  • 3 2⍴định hình đối số vector thành ba cặp. Trong trường hợp này, nó ghép các mục thứ nhất và thứ hai, thứ ba và thứ nhất và thứ hai và thứ ba của vectơ.
  • ,/ tham gia đối số vector với nhau
  • ⍵[⍋⍵] sắp xếp các đối số đúng
  • ∪/ lọc ra bất kỳ bản sao
  • ⍴⊃ biến một vô hướng lồng nhau thành một vectơ và nó trả về chiều dài của nó.
  • Toàn bộ hàm trả về số cạnh trong hình ( E)
• 1 là tự giải thích (tôi hy vọng ...)

Toàn bộ hàm sau đó trả về 1+E-(V+F), hoặc 1-(F+V-E).

Mathematica, 93 (chưa chơi gôn nhiều)

f[l_, t_] :=  Max@MorphologicalComponents[Erosion[Graphics[
                                                        GraphicsComplex[l, Polygon[t + 1]]], 1]] - 1

(Không gian được thêm vào cho rõ ràng)

Kiểm tra:

f[{{0, 0}, {1, 0}, {0, 1}, {1, 2}}, {{0, 1, 2}, {1, 2, 3}}]
(*
 -> 0
*)

{l, t} = {{{0, 0}, {1,   0}, {2,    0}, {2,     1}, {2,    2}, {1, 2}, {0, 2}, 
           {0, 1}, {.5, .5}, {1.5, .5}, {1.5, 1.5}, {.5, 1.5}}, 

           {{5, 6, 11}, {5, 10, 11}, {4, 5, 10}, {3, 8, 10}, {2, 3,  9}, 
            {2, 8,  9}, {1,  2,  8}, {0, 1,  8}, {0, 8, 11}, {0, 7, 11}, {6, 7, 11}, {3, 4, 10}}};
f[l, t]
 (*
  -> 2
 *)

Ruby, 239 ký tự (cơ thể 227)

def f t
e=t.flat_map{|x|x.permutation(2).to_a}.group_by{|x|x}.select{|_,x|x.one?}.keys
n=Hash[e]
(u,n=n,n.dup;e.map{|x|a,b=*x;n[a]=n[n[a]]=n[b]})until n==u
n.values.uniq.size+e.group_by(&:last).map{|_,x|x.size}.reduce(-1){|x,y|x+y/2-1}
end

lưu ý rằng tôi chỉ xem xét cấu trúc liên kết. Tôi không sử dụng các vị trí đỉnh theo bất kỳ cách nào.

người gọi (mong đợi T ở định dạng Mathicala hoặc JSON):

input = gets.chomp
input.gsub! "{", "["
input.gsub! "}", "]"
f eval(input)

Kiểm tra:

f [[0,1,2],[1,2,3]]
#=> 0
f [[5, 6, 11], [5, 10, 11], [4, 5, 10], [3, 8, 10], [2, 3, 9], [2, 8, 9], [1, 2, 8], [0, 1, 8], [0, 8, 11], [0, 7, 11], [6, 7, 11], [3, 4, 10]]
#=> 2
f [[1,2,3],[3,4,5],[5,6,1],[2,3,4],[4,5,6],[6,1,2]]
#=> 1

Toán học 76 73 72 67 62

Sau nhiều thử nghiệm, tôi nhận ra rằng vị trí chính xác của các đỉnh không có gì đáng lo ngại, vì vậy tôi đã trình bày vấn đề bằng đồ thị. Các bất biến thiết yếu, số lượng hình tam giác, cạnh và đỉnh vẫn bất biến (cung cấp đường chéo được tránh).

Có hai loại "hình tam giác" bên trong biểu đồ: những hình đó có lẽ là một khuôn mặt, tức là hình tam giác "đầy" và những hình không có. Số lượng các mặt bên trong không có bất kỳ liên quan đến các cạnh hoặc đỉnh. Điều đó có nghĩa là việc chọc các lỗ trên đồ thị "đầy" chỉ làm giảm số lượng khuôn mặt. Tôi đã chơi một cách có hệ thống với các biến thể giữa các hình tam giác, theo dõi các mặt, đỉnh và cạnh. Cuối cùng, tôi nhận ra rằng số lượng lỗ luôn bằng 1 - #faces - # vertices + #edges. Điều này hóa ra là 1 trừ đi đặc tính Euler (mà tôi chỉ biết về bối cảnh của khối đa diện thông thường (mặc dù chiều dài của các cạnh rõ ràng là không quan trọng.

Hàm bên dưới trả về số lượng lỗ khi các đỉnh và hình tam giác được nhập vào. Không giống như đệ trình trước đây của tôi, nó không dựa vào việc quét hình ảnh. Bạn có thể coi đó là đặc điểm 1 - Euler, tức là 1 - (F + V -E) trong đó F= #faces, V= # vertices, E= # edge. Hàm trả về số lượng lỗ,1 - (F + V -E) , được cho các mặt thực tế (hình tam giác) và đỉnh.

Có thể dễ dàng thấy rằng việc loại bỏ bất kỳ tam giác nào ở bên ngoài phức tạp không ảnh hưởng đến đặc tính Euler, bất kể nó có chung một hoặc 2 cạnh với các tam giác khác hay không.

Lưu ý: Chữ thường vsẽ được sử dụng thay choL cho công thức ban đầu; nghĩa là, nó chứa chính các đỉnh (không phải V, số lượng đỉnh)

f được sử dụng cho T công thức ban đầu; nghĩa là, nó chứa các hình tam giác, được biểu diễn dưới dạng bộ ba chỉ số đỉnh.

Mã

z=Length;1-z@#2-z@#+z[Union@@(Sort/@{#|#2,#2|#3,#3|#}&@@@#2)]&

(Cảm ơn thầy Wizard đã cạo sạch 5 ký tự bằng cách loại bỏ quy tắc thay thế.)

ví dụ 1

v = {{0, 0}, {1, 0}, {0, 1}, {1, 2}}; f = {{0, 1, 2}, {1, 2, 3}};

z=Length;1-z@#2-z@#+z[Union@@(Sort/@{#|#2,#2|#3,#3|#}&@@@#2)]&[v, f]

0

Không lỗ.

Ví dụ 2

v = {{0, 0}, {1, 0}, {2, 0}, {2, 1}, {2, 2}, {1, 2}, {0, 2}, {0, 1} , {.5, .5}, {1.5, .5}, {1.5, 1.5}, {.5, 1.5}}; f = {{5, 6, 11}, {5, 10, 11}, {4, 5, 10}, {3, 8, 10}, {2, 3, 9}, {2, 8, 9} , {1, 2, 8}, {0, 1, 8}, {0, 8, 11}, {0, 7, 11}, {6, 7, 11}, {3, 4, 10}};

z=Length;1-z@#2-z@#+z[Union@@(Sort/@{#|#2,#2|#3,#3|#}&@@@#2)]&[v, f]

2

Do đó, 2 lỗ trong ví dụ 2.

Con trăn, 107

Tôi nhận ra rằng việc lấy các cặp trực tiếp ngắn hơn from itertools import*và gõ combinations(). Tuy nhiên, tôi cũng nhận thấy rằng giải pháp của tôi dựa vào các mặt tam giác đầu vào có các đỉnh được liệt kê theo thứ tự nhất quán. Do đó, mức tăng trong số lượng nhân vật không phải là lớn.

f=lambda l,t:1-len(l+t)+len(set([tuple(sorted(m))for n in[[i[:2],i[1:],[i[0],i[2]]]for i in t]for m in n]))

Cách tiếp cận đặc trưng của Euler, tính dài dòng của itertools dường như là không thể tránh khỏi. Tôi tự hỏi nếu nó sẽ rẻ hơn nếu sử dụng một kỹ thuật trực tiếp hơn để tạo ra các cặp đỉnh.

from itertools import*
f=lambda l,t:1-len(l+t)+len(set([m for n in[list(combinations(i,2)) for i in t]for m in n]))

Ví dụ sử dụng:

> f([[0,0],[1,0],[0,1],[1,2]],[[0,1,2],[1,2,3]])
> 0
> f([[0,0],[1,0],[2,0],[2,1],[2,2],[1,2],[0,2],[0,1],[.5,.5],[1.5,.5],[1.5,1.5],[.5,1.5]],[[5,6,11],[5,10,11],[4,5,10],[3,8,10],[2,3,9],[2,8,9],[1,2,8],[0,1,8],[0,8,11],[0,7,11],[6,7,11],[3,4,10]])
> 2