作为本赛季末最成功的足球^BE队的球迷，我常常想知道我最喜欢的球队是否仍然有理论上的机会成为冠军。您在这项挑战中的任务是为我回答这个问题。

输入值

您将收到三个输入：当前表，剩余比赛列表以及我们感兴趣的球队的当前位置。

输入1：在当前表，数字的顺序是该我个号是由团队获得的点我为止。例如，输入 [93, 86, 78, 76, 75]对下表进行编码（仅最后一列很重要）：

输入2：剩余比赛，一组元组，其中每个元组（i，j）代表第i队和第j队之间的剩余比赛。在上面的示例中，第二个输入[(1,2), (4,3), (2,3), (3,2), (1,2)]表示其余匹配为：

Chelsea vs Tottenham, Liverpool vs Man. City, Tottenham vs Man. City, Man. City vs Tottenham, Chelsea vs Tottenham

输入3：我们感兴趣的球队的当前职位。例如，2上面示例的输入表示我们想知道热刺是否仍然可以成为冠军。

输出量

对于形式（i，j）的每个剩余匹配项，有三种可能的结果：

• I队获胜：I队获得3分，J队获得0分
• J队获胜：I队获得0分，J队获得3分
• 平局：i队和j队均获得1分

如果所有剩余比赛都有结果，则必须输出一个真实值，以使最后没有其他球队的得分超过第3输入中指定的球队。否则，输出一个伪造的值。

示例：考虑来自以上部分的示例性输入：

输入1 = [93, 86, 78, 76, 75]，输入2 = [(1,2), (4,3), (2,3), (3,2), (1,2)]，输入3 =2

如果团队2赢得了其所有剩余比赛（即(1,2), (2,3), (3,2), (1,2)），则将获得4 * 3 = 12的额外积分；这些比赛没有其他球队得到任何积分。假设其他剩余比赛（即(4,3)）是平局。那么最终分数将是：

 Team 1: 93, Team 2: 86 + 12 = 98, Team 3: 78 + 1 = 79, Team 4: 76 + 1 = 77, Team 5: 75

这意味着我们已经为剩下的比赛找到了一些结果，因此没有其他团队比团队有更多的积分2，因此此输入的输出必须是真实的。

细节

• 您可以假定第一个输入为有序序列，即对于i < j，第i个条目等于或大于第j个条目。可以将第一输入作为列表，字符串等。
• 您可以将第二个输入作为字符串，元组列表等。或者，您可以将其视为一个二维数组a，其中a[i][j]是(i,j)剩余匹配项列表中表单的条目数。例如，a[1][2] = 2, a[2][3] = 1, a[3][2] = 1, a[4][3] = 1 对应于[(1,2), (4,3), (2,3), (3,2), (1,2)]。
• 对于第二个和第三个输入，您可以假设0索引而不是1索引。
• 您可以按任意顺序输入这三个输入。

请指定您在答案中选择的确切输入格式。

_{旁节点：在“ 三分规则下，足球淘汰难以决定 ”中，证明这一挑战的根本问题是NP完全的。有趣的是，如果只赢得2分，那么该问题在多项式时间内可以解决。}

测试用例

所有的测试用例的格式为Input1，Input2，Input3。

真相：

• [93, 86, 78, 76, 75]，[(1,2), (4,3), (2,3), (3,2), (1,2)]，2
• [50]，[]，1
• [10, 10, 10]，[]，3
• [15, 10, 8]，[(2,3), (1,3), (1,3), (3,1), (2,1)]，2

虚假：

• [10, 9, 8]，[]，2
• [10, 9, 9]，[(2,3), (3,2)]，1
• [21, 12, 11]，[(2,1), (1,2), (2,3), (1,3), (1,3), (3,1), (3,1)]，2

优胜者

这是代码高尔夫球，因此最短的正确答案（以字节为单位）获胜。在第一个正确答案发布后的一周内，将选择获奖者。

Haskell（Lambdabot），84个字节

感谢@bartavelle为我节省了一个字节。

如果没有Lambdabot，请加上20个字节并import Control.Lens加上一个换行符。

该函数以与OP中所述相同的顺序获取其参数，索引为0。它的第二个参数（剩余匹配列表）是索引的平面列表（例如[1,2,4,1]与对应[(Team 1 vs Team 2), (Team 4 vs Team 1)]）。

规则对于是否允许这样做有些含糊。如果不允许，该函数可以采用示例提供的格式输入-元组列表。在这种情况下，由于要替换a:b:r为，所以要在此解决方案的分数中添加2个字节(a,b):r。

(!)=(+~).element
(t?(a:b:r))s=any(t?r)[a!3$s,b!3$s,b!1$a!1$s]
(t?_)s=s!!t==maximum s

说明：

第一行定义了!类型为的三个变量的中缀函数，该函数(!) :: Int -> Int -> [Int] -> [Int]将增加列表中给定索引处的值。由于代码通常比单词更容易理解（并且因为Haskell语法可能很奇怪），所以下面是Python的翻译：

def add(index, amount, items):
    items[index] += amount
    return items

第二行定义了另一个中缀函数?，也包含三个变量（挑战输入）。我将在此处更可读地重写它：

(t ? a:b:r) s = any (t ? r) [a ! 3 $ s, b ! 3 $ s, (b ! 1 $ a) ! 1 $ s]
(t ? _) s = (s !! t) == maximum s

这是穷举搜索的递归实现。它根据剩下的三个结果重复出现在剩余的游戏列表中，然后，当列表为空时，检查我们的团队是否拥有最大积分。再次在（非惯用的）Python中，这是：

def can_still_win(standings, games_left, our_team):
    if games_left == []:
        return standings[our_team] == max(standings)
    team1, team2, other_games = games_left[0], games_left[1], games_left[2:]
    team1Wins, team2Wins, tie = standings.copy(), standings.copy(), standings.copy()
    team1Wins[team1] += 3
    team2Wins[team2] += 3
    tie[team1] += 1
    tie[team2] += 1
    return (can_still_win(team1Wins, other_games, our_team)
            or can_still_win(team2Wins, other_games, our_team)
            or can_still_win(tie, other_games, our_team))

在线尝试！

^*可悲的是，TiO不支持Lens，因此该链接实际上不会运行。

Microsoft SQL Server，792个字节

CREATE FUNCTION my.f(@s XML,@m XML,@ INT)RETURNS TABLE RETURN
WITH s AS(SELECT s.value('@p','INT')p FROM @s.nodes('S')s(s)),
m AS(SELECT m.value('@i','INT')i,m.value('@j','INT')j FROM @m.nodes('M')m(m)),
a AS(SELECT ROW_NUMBER()OVER(ORDER BY-p)t,p FROM s),
b AS(SELECT p+3*(SELECT COUNT(*)FROM m WHERE t IN(i,j))o FROM a WHERE t=@),
c AS(SELECT i,j,ROW_NUMBER()OVER(ORDER BY 1/0)k FROM m WHERE @ NOT IN(i,j)),
d AS(SELECT COUNT(*)u,POWER(3,COUNT(*))-1 v FROM c UNION ALL SELECT u,v-1 FROM d WHERE v>0),
e AS(SELECT v,u,v/3 q,v%3 r FROM d UNION ALL SELECT v,u-1,q/3,q%3 FROM e WHERE u>1),
f AS(SELECT v,p+SUM(IIF(t=i,r,(2-r))%3*3/2)s FROM a,c,e WHERE t IN(i,j)AND k=u GROUP BY v,t,p),
g AS(SELECT MAX(s)x FROM f GROUP BY v)SELECT SUM(IIF(o<ISNULL(x,p),0,1))f FROM a,(b OUTER APPLY g)WHERE t=1;

对于错误的结果，该函数返回0，对于正确的结果，返回大于0。

整个代码段：

SET NOCOUNT ON;
--USE tempdb;
USE rextester;
GO
IF SCHEMA_ID('my') IS NULL EXEC('CREATE SCHEMA my');
ELSE BEGIN
  IF OBJECT_ID('my.f', 'IF') IS NOT NULL DROP FUNCTION my.f;
  IF OBJECT_ID('my.s', 'U') IS NOT NULL DROP TABLE my.s;
  IF OBJECT_ID('my.m', 'U') IS NOT NULL DROP TABLE my.m;
  IF OBJECT_ID('my.c', 'U') IS NOT NULL DROP TABLE my.c;
END;
GO
CREATE TABLE my.c( -- Test cases
  c INT PRIMARY KEY CLUSTERED CHECK(c > 0), -- Test Case Id
  n INT CHECK(n > 0), -- Current position of the team of interest
);
CREATE TABLE my.s( -- Standings
  a INT FOREIGN KEY REFERENCES my.c(c) CHECK(a > 0), -- Test cAse Id
  p INT CHECK(p > 0) -- Team pts
);
CREATE TABLE my.m( -- Matches
  s INT FOREIGN KEY REFERENCES my.c(c) CHECK(s > 0), -- Test caSe Id
  i INT CHECK(i > 0), -- Team i
  j INT CHECK(j > 0), -- Team j
  CHECK(i != j)
);
GO
INSERT my.c(c, n) VALUES (1, 2), (2, 1), (3, 3), (4, 2), (5, 2), (6, 1), (7, 2);
INSERT my.s(a, p) VALUES (1, 93), (1, 86), (1, 78), (1, 76), (1, 75),
(2, 50), (3, 10), (3, 10), (3, 10), (4, 15), (4, 10), (4, 8),
(5, 10), (5, 9), (5, 8), (6, 10), (6, 9), (6, 9), (7, 21), (7, 12), (7, 11);
INSERT my.m(s, i, j) VALUES (1, 1, 2), (1, 4, 3), (1, 2, 3), (1, 3, 2), (1, 1, 2),
(4, 2, 3), (4, 1, 3), (4, 1, 3),(4, 3, 1), (4, 2, 1), (6, 2, 3), (6, 3, 2),
(7, 2, 1), (7, 1, 2), (7, 2, 3), (7, 1, 3), (7, 1, 3), (7, 3, 1), (7, 3, 1);
GO
CREATE FUNCTION my.f(@s XML,@m XML,@ INT)RETURNS TABLE RETURN
WITH s AS(SELECT s.value('@p','INT')p FROM @s.nodes('S')s(s)),
m AS(SELECT m.value('@i','INT')i,m.value('@j','INT')j FROM @m.nodes('M')m(m)),
a AS(SELECT ROW_NUMBER()OVER(ORDER BY-p)t,p FROM s),
b AS(SELECT p+3*(SELECT COUNT(*)FROM m WHERE t IN(i,j))o FROM a WHERE t=@),
c AS(SELECT i,j,ROW_NUMBER()OVER(ORDER BY 1/0)k FROM m WHERE @ NOT IN(i,j)),
d AS(SELECT COUNT(*)u,POWER(3,COUNT(*))-1 v FROM c UNION ALL SELECT u,v-1 FROM d WHERE v>0),
e AS(SELECT v,u,v/3 q,v%3 r FROM d UNION ALL SELECT v,u-1,q/3,q%3 FROM e WHERE u>1),
f AS(SELECT v,p+SUM(IIF(t=i,r,(2-r))%3*3/2)s FROM a,c,e WHERE t IN(i,j)AND k=u GROUP BY v,t,p),
g AS(SELECT MAX(s)x FROM f GROUP BY v)SELECT SUM(IIF(o<ISNULL(x,p),0,1))f FROM a,(b OUTER APPLY g)WHERE t=1;
GO
SELECT c, f
FROM my.c
OUTER APPLY(SELECT p FROM my.s S WHERE a = c FOR XML AUTO)S(s)
OUTER APPLY(SELECT i, j FROM my.m M WHERE s = c FOR XML AUTO)M(m)
OUTER APPLY my.f(s, m, n)
ORDER BY c
OPTION(MAXRECURSION 0);

在线检查！

Python 2，242 221字节

from itertools import*
def u(S,M,t,O):
 for m,o in zip(M,O):
  if t in m:S[t]+=3
  else:S[m[0]]+=(1,3,0)[o];S[m[1]]+=(1,0,3)[o]
 return S[t]>=max(S)
f=lambda s,m,t:any(u(s[:],m,t,O)for O in product([0,1,2],repeat=len(m)))

在线尝试！

在第一次通过基本高尔夫思维之后。使用基于0的索引进行输入；TIO中的测试用例通过功能对此进行调整F。

该product([0,1,2],repeat=len(m))迭代在每场比赛，除非团队的利益的（TOI）平手/输/赢评估可能的结果是比赛的一部分，（其中，该TOI总是假定赢）。

JavaScript（ES6），145个字节

(s,d,t,o=[],g=(c=s,i=0)=>d[i]?[3,,0,3,1,1].map((a,j)=>(j%=2,r=j?r:[...c],r[d[i][j]]+=a,g(r,i+1))):o.push(c))=>o.some(r=>r[t]==Math.max(...r),g())

将得分输入作为数组（[93,86,78,76,75]），即将进行的游戏作为2值数组的数组（[[0,1],[3,2],[1,2],[2,1],[0,1]]），将团队索引作为整数（1）。一切都是0索引。

测试片段

let f=
(s,d,t,o=[],g=(c=s,i=0)=>d[i]?[3,,0,3,1,1].map((a,j)=>(j%=2,r=j?r:[...c],r[d[i][j]]+=a,g(r,i+1))):o.push(c))=>o.some(r=>r[t]==Math.max(...r),g())

console.log("---Truthy---")
console.log(f([93, 86, 78, 76, 75], [[0,1], [3,2], [1,2], [2,1], [0,1]], 1))
console.log(f([50], [], 0))
console.log(f([10, 10, 10], [], 2))
console.log(f([15, 10, 8], [[1,2], [0,2], [0,2], [2,0], [1,0]], 1))
console.log("---Falsy---")
console.log(f([10, 9, 8], [], 1))
console.log(f([10, 9, 9], [[1,2],[2,1]], 0))
console.log(f([21, 12, 11], [[1,0], [0,1], [1,2], [0,2], [0,2], [2,0], [2,0]], 1))

.as-console-wrapper{max-height:100%!important}