问题：计算连接的多边形中的孔数。通过以下条件保证多边形的连通性：输入三角剖分中的每个三角形与另一个三角形至少共享一侧，并且只有一组这样连接的三角形。

输入是平面中L的n点的列表T，以及包含来自的三元组的列表0...n-1。对于T元组中的每个项，(t_1,t_2,t_3)代表L三角剖分中三角形的三个顶点（来自列表）。请注意，这是“多边形三角剖分”意义上的三角剖分，因此，在T该交叠中永远不会有两个三角形。另一个规定是您不必清理输入内容，L并且T不包含任何重复项。

示例1：如果L = {{0,0},{1,0},{0,1},{1,2}}，T = {{0,1,2},{1,2,3}}则指定的多边形的孔数为0。

示例2：如果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}}则面输入将导致输出为2。

任务是编写最短的程序（或函数），该程序以L和T作为输入并返回孔的数量。“优胜者”将被认为是字符数最少的条目（暂定结束日期为6月1日）。

输入格式样本（请注意0索引）：

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

GolfScript（23个字符）

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

假设使用GolfScript数组符号和带引号（或整数）坐标的输入格式。例如

$ 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

（在线等效）

要么

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

（在线等效）

Python，71

接下来是一个计算所需数字的程序（不是function）。

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

用法示例：

>>> 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⍴⍵,⍵}¨⍵)-⍴⍺,⍵}

该函数L以其左参数和T右参数为准。

例如：

      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

解释，从右到左：

• ⍴⍺,⍵连接两个输入向量并返回它们的长度（V + F）
• 进入下一个块：
  • ¨⍵ 将左侧的函数应用于右侧参数的每个元素并返回结果
  • ⍵,⍵ 返回与其自身串联的正确参数
  • 3 2⍴将向量参数整形为三对。在这种情况下，它将向量的第一和第二，第三和第一，第二和第三项配对在一起。
  • ,/ 将vector参数连接在一起
  • ⍵[⍋⍵] 排序正确的参数
  • ∪/ 过滤掉所有重复项
  • ⍴⊃ 将嵌套标量转换为向量，并返回其长度。
  • 整个函数返回形状（E）中的边数
• 1 是不言自明的（我希望...）

然后1+E-(V+F)，整个函数返回或1-(F+V-E)。

93岁的Mathematica（尚未打高尔夫球）

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

（为清楚起见添加了空格）

测试：

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个字符（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

请注意，我只考虑拓扑。我没有以任何方式使用顶点位置。

调用者（预期为Mathematica或JSON格式的T）：

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

测试：

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

Mathematica 76 73 72 67 62

经过大量的实验，我意识到顶点的精确位置无关紧要，因此我用图形来表示问题。基本不变性，三角形，边和顶点的数量保持不变（避免了交叉线）。

图中有两种内部“三角形”：大概有一张脸，即一个“实心”三角形，而那些没有。内部面的数量与边缘或顶点没有任何关系。这意味着在完全“填充”的图形中戳洞只会减少面的数量。我系统地玩着三角形之间的变化，并跟踪面部，顶点和边缘。最终，我意识到孔的数量始终等于1-#faces-＃vertices + #edges。事实证明这是1减去Euler特性（我仅在规则多面体的情况下才知道（尽管边缘的长度显然不重要）。

下面的函数返回输入顶点和三角形时的孔数。与我之前提交的文档不同，它不依赖于图像扫描。您可以将其视为1-欧拉的特征，即1-（F + V -E）其中F= #faces，V=＃vertices，E=＃edges。1 - (F + V -E)给定实际的面（三角形）和顶点，该函数返回孔的数量。

可以很容易地看出，去除配合物外部的任何三角形都不会影响欧拉特性，无论它与其他三角形共享一侧还是两侧。

注意：v将使用小写字母代替L原始配方；也就是说，它包含顶点本身（而不是V，即顶点数）

f用于T原始配方；也就是说，它包含三角形，表示为顶点索引的有序三元组。

码

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

（感谢Wizard先生通过消除替换规则削减了5个字符。）

例子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

零孔。

例子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

因此，示例2中有2个孔。

巨蟒，107

我意识到直接配对时比from itertools import*键入短combinations()。但是我还注意到，我的解决方案依赖于输入三角形的面，顶点的顺序一致。因此，字符数的增加不是很大。

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]))

欧拉特性方法，itertools的冗长性似乎无法避免。我想知道使用更直接的技术制作成对的顶点是否会更便宜。

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]))

用法示例：

> 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