Nonary Game是一款虚构的游戏，使用同名的电子游戏三部曲进行。您的目标是找到尽可能少的代码字节（最多）可以让给定游戏逃脱的玩家人数。

游戏规则

• 有9位玩家，编号从1到9。
• 所有玩家都从同一房间开始。
• 门的数量不限，每个门的编号为1到9。门号可能重复或丢失。
• 门是房间之间的单向连接。每个门只能使用一次。
• 只有3至5名球员的团体才能进入。
• 如果一组人的模数之和为9与门的模数为9相匹配，则该组只能穿过门。
• 任何经过9门的玩家都会逃脱（获胜）。

例子

┌───┬───┬───┐
│   6   4   9
│ < │   |   |
│   3   5   9
└───┴───┴───┘ 

<代表起点。所有玩家都从这里开始。

在这种情况下，每个人都可以逃脱。有多种方法可以实现此目的，其中一种是：

• [1、2、3、4、5]经过6号门（（1 + 2 + 3 + 4 + 5）％9 = 6），而[6、7、8、9]通过3号门（（6 + 7 + 8 + 9）％9 = 3）。大家在第二个房间见面。
• [1、2、3、7]穿过门4，而[4、5、6、8、9]穿过门5。
• [1、2、3、4、8]穿过9个门之一，[5、6、7、9]穿过另一个门。

┌───┬───┐
│   │   |
│ < 8   9
│   │   |
└───┴───┘ 

这次，最多4人可以逃脱：

• [1、3、5、8、9]经过8号门。
• [1、3、5、9]经过9号门。

可能还有其他幸存者名单，例如[2、3、4]或[1、4、6、7]，但无法让4个人逃脱。

挑战

给定一张地图，输出可以逃脱的最大玩家数量。

• 不用担心，您不需要解析我可怕的图表！输入是带标签的有向图，可以用任何方便的格式表示（边集，邻接矩阵...）。
• 如果您的表示形式需要房间标签，则可以使用任何一致的值集。但是，门必须用1到9的整数表示。
• 输入将始终至少有一个9门。所有9个门始终通向出口，而其他门则永远不通。
• 您的提交可以是功能或完整程序。
• 禁止出现标准漏洞。

测试用例

输入显示为[从房间到另一个房间的门号]三元组的列表，其中0是起始房间，-1是出口。如果您选择使用其他格式，则必须对其进行适当的转换。

Input                                                                      Output
[[6, 0, 1], [3, 0, 1], [4, 1, 2], [5, 1, 2], [9, 2, -1], [9, 2, -1]]       9
[[8, 0, 1], [9, 1, -1]]                                                    4
[[9, 0, -1]]                                                               5
[[2, 0, 1], [1, 1, 2], [9, 2, -1]]                                         0
[[2, 0, 1], [3, 1, 2], [9, 2, -1]]                                         3
[[1, 0, 1], [9, 1, -1], [1, 0, 2], [9, 2, -1]]                             4
[[2, 0, 1], [3, 0, 1], [5, 1, 2], [4, 0, 2], [9, 2, -1], [9, 2, -1]]       8
[[3, 0, 1], [4, 0, 1], [5, 0, 1], [9, 1, -1], [7, 1, 2], [9, 2, -1]]       7
[[1, 0, 1], [2, 0, 1], [4, 0, 1], [9, 1, -1], [8, 1, 2], [9, 2, -1]]       6
[[6, 0, 1], [7, 0, 1], [9, 1, -1], [9, 1, -1]]                             7

JavaScript（ES6），219字节

使用位掩码而不是字符串的较慢但明显更短的版本。

f=(D,P=[511],e=m=0)=>P.map((X,r)=>[...Array(-~X)].map((_,p)=>D.map(([d,s,t],j)=>(N=(g=(n,k)=>n&&n%2+g(n>>1,++k,x+=n%2*k))(p&=X,x=0))<3|N>5|r-s|x%9^d%9||f(D.filter(_=>j--),A=[...P],e+!~t*N,A[r]^=p,A[t]^=p))),m=m>e?m:e)|m

在线尝试！

$X$$(X \operatorname{AND} p)$$0\le p\le X$

JavaScript（ES7）， 293 272  271字节

以挑战中描述的格式输入。这是蛮力搜索。

f=(D,P=[17**6+'8'],e=m=0)=>P.map((X,r)=>X&&[...X].reduce((a,x)=>[...a,...a.map(y=>y+x)],['']).map(p=>D.map(([d,s,t],j)=>p<99|p[5]|r-s|eval([...p].join`+`)%9^d%9||f(D.filter(_=>j--),A=[...P],e+!~t*p.length,A[r]=X.replace(eval(`/[${p}]/g`),''),A[t]=[A[t]]+p))),m=m>e?m:e)|m

在线尝试！（第一个测试用例在TIO上超时）

怎么样？

该数组P[]包含描述每个房间中玩家的字符串列表。

P=['241375698']$17^6=24137569$$0$

对于该X位置的每个房间r，我们计算以下项的幂集X：

[...X].reduce((a, x) => [...a, ...a.map(y => y + x)], [''])

对于其中的每个玩家组p和[d,s,t]index处的每个门j，我们测试该组是否无法通过该门：

                         // we can't pass if:
p < 99 |                 // there are less than 3 players
p[5] |                   // or there are more than 5 players
r - s |                  // or the source room s is not equal to the current room
eval([...p].join`+`) % 9 // or the sum of the players modulo 9
^ d % 9                  // does not match the ID of the door modulo 9

如果组可以通过，我们进行递归调用：

f(                       //
  D.filter(_ => j--),    // remove the door that has just been used from D[]
  A = [...P],            // use a copy A[] of P[]
  e + !~t * p.length,    // if t = -1, add the length of p to e (number of escaped guys)
  A[r] = X.replace(      // remove the players from the source room A[r]
    eval(`/[${p}]/g`),   //
    ''                   //
  ),                     //
  A[t] = [A[t]] + p      // and append them to the target room A[t]
)                        //

我们跟踪逃生玩家的最大数量，m并最终将其返回。

果冻，76字节

2ịịœc3r5¤ẎS,%9EʋƇ1ị${ḟ@;ƭⱮ€Ḋị¥ż€Ḋ{ṛṪ}¦ƒ€
ç@€Ẏ;ḷṢ€€Q
“”WẋḊ€FṀƊ9RW¤;Wçƒ@⁸ẈṪ$€Ṁ

在线尝试！

带有单个参数的完整程序，使用房间1、2，...和0作为出口的有向图。返回一个整数，该整数是可以转义的最大数目。完整的解释如下。

应该在不运行的情况下Ṣ€€Q保存4个字节，但恢复缓慢。