背景

考虑一个循环锦标赛，其中每个参赛者与其他参赛者进行一场比赛。没有平局，因此每场比赛都有赢家和输家。如果对其他每位竞争者B来说，A击败B或A击败另一位竞争者C，而竞争者C又击败B，那么竞争者A是比赛的王者。可以证明，每场比赛都有至少一位国王（尽管可能有几位）。在这个挑战中，您的任务是找到给定锦标赛的国王。

输入输出

您输入的是N × N布尔矩阵T，还可以N ≥ 2是参赛者人数。每个条目T[i][j]代表选手之间的比赛的胜负i和j，值为1代表一胜i0一胜j。请注意，T[i][j] == 1-T[j][i]如果i != j。的对角线T包括0。

您的输出应为T代表比赛的国王列表，使用基于0或基于1的索引。国王的顺序无关紧要，但不应重复。

输入和输出都可以采用任何合理的格式。

规则和计分

您可以编写完整的程序或函数。最低字节数获胜，并且不允许出现标准漏洞。

测试用例

这些测试用例使用基于0的索引。对于基于1的索引，增加每个输出值。

 2 [[0,0],[1,0]] -> [1]
 3 [[0,1,0],[0,0,0],[1,1,0]] -> [2]
 3 [[0,1,0],[0,0,1],[1,0,0]] -> [0,1,2]
 4 [[0,1,1,1],[0,0,1,0],[0,0,0,0],[0,1,1,0]] -> [0]
 4 [[0,1,1,0],[0,0,1,0],[0,0,0,1],[1,1,0,0]] -> [0,2,3]
 5 [[0,1,0,0,1],[0,0,0,0,1],[1,1,0,0,0],[1,1,1,0,1],[0,0,1,0,0]] -> [3]
 5 [[0,1,0,1,0],[0,0,1,1,1],[1,0,0,0,0],[0,0,1,0,1],[1,0,1,0,0]] -> [0,1,4]
 5 [[0,0,0,0,0],[1,0,1,1,0],[1,0,0,0,1],[1,0,1,0,1],[1,1,0,0,0]] -> [1,3,4]
 6 [[0,0,0,0,0,0],[1,0,1,1,0,0],[1,0,0,1,1,0],[1,0,0,0,1,1],[1,1,0,0,0,1],[1,1,1,0,0,0]] -> [1,2,3,4,5]
 6 [[0,0,1,1,1,0],[1,0,0,1,1,1],[0,1,0,0,1,0],[0,0,1,0,0,1],[0,0,0,1,0,1],[1,0,1,0,0,0]] -> [0,1,2,3,5]
 6 [[0,1,1,0,0,1],[0,0,0,1,0,1],[0,1,0,1,1,0],[1,0,0,0,1,1],[1,1,0,0,0,0],[0,0,1,0,1,0]] -> [0,1,2,3,4,5]
 8 [[0,0,1,1,0,1,1,1],[1,0,1,0,1,1,0,0],[0,0,0,1,1,0,0,0],[0,1,0,0,0,1,0,0],[1,0,0,1,0,1,0,0],[0,0,1,0,0,0,1,0],[0,1,1,1,1,0,0,1],[0,1,1,1,1,1,0,0]] -> [0,1,4,6,7]
20 [[0,0,1,1,0,1,1,0,0,0,0,1,1,0,1,1,1,1,0,1],[1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1],[0,0,0,1,0,0,0,1,1,0,1,0,1,0,0,0,0,0,1,1],[0,0,0,0,1,1,1,1,1,1,1,1,0,0,1,0,0,1,1,1],[1,0,1,0,0,0,0,1,1,0,1,1,1,0,1,1,1,1,0,1],[0,1,1,0,1,0,1,1,1,1,1,0,1,1,1,0,1,1,0,1],[0,0,1,0,1,0,0,1,1,0,1,0,1,1,1,1,1,0,1,0],[1,0,0,0,0,0,0,0,1,0,1,1,1,1,0,0,1,1,1,0],[1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,1,1],[1,0,1,0,1,0,1,1,0,0,1,0,0,0,0,1,0,1,1,1],[1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,0,0,0,0],[0,1,1,0,0,1,1,0,0,1,0,0,1,1,1,1,1,0,1,1],[0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,1,0,1,1,1],[1,0,1,1,1,0,0,0,0,1,0,0,1,0,1,1,1,1,1,1],[0,0,1,0,0,0,0,1,0,1,1,0,0,0,0,1,1,0,0,1],[0,0,1,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,1],[0,0,1,1,0,0,0,0,0,1,1,0,1,0,0,1,0,0,1,1],[0,0,1,0,0,0,1,0,1,0,1,1,0,0,1,0,1,0,1,1],[1,0,0,0,1,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,1,0]] -> [0,1,3,4,5,7,8,11,15,17,18]

code-golf array-manipulation

— 兹加布
source

（是否存在运行时间或内存限制？）没关系。我完全误解了规格。

— 丹尼斯

@丹尼斯·诺普只要您的程序在理论上可以在无限制的时间和内存的情况下运行，就可以了。

— Zgarb

需要澄清的是：T [a] [b]与T [b] [a]相同，但从相反的角度看，所以T [a] [b] ==！T [b] [a]

— edc65

@ edc65这是一个很好的观察。我将其编辑成挑战。

— Zgarb

9

Matlab，36 35 29字节

@(T,N)find(sum(T*T>-T,2)>N-2)

让我们找出是否i是国王。然后为每个j值T[i][j]==1 OR there is a k such that T[i][k] * T[k][l] == 1。但是第二个条件也可以替换为sum_over_k(T[i][k] * T[k][l])>0，但这只是矩阵的一个条目T*T（如果您考虑T作为矩阵）。该OR可再加入重播T到这一结果，所以我们只需要检查，如果n-1该行的值i的T*T+T都大于零，看其是否i为王。这正是我的职能。

（这是MATLAB，因此索引基于1。）

MATLAB矩阵应使用分号作为行定界符进行编码：

[[0,0,0,0,0];[1,0,1,1,0];[1,0,0,0,1];[1,0,1,0,1];[1,1,0,0,0]]

— 瑕疵
source

您可能会节省一些字节，而不用size(T,1)

— Luis Mendo

7

Jelly，13 12 11个字节

a"€¹o/€oḅ1M

输出基于1。在线尝试！

或者，使用按位运算符代替数组操作：

×Ḅ|/€|ḄBS€M

同样，输出基于1。在线尝试！

背景

对于选手一，我们可以找到所有乙这样拍ç击打乙采取的所有行对应于一个ç这样Ç击败。IFR的乙^次的进入Ç ^个是1，我们有Ç击打乙。

如果我们计算选定列的所有对应条目的逻辑或，我们将得到一个向量，该向量指示A是否通过传递性击败了B。最后，将结果向量与输入矩阵的相应行进行“或”运算，得出布尔值是否为A Beat B，无论是通过传递性还是直接传递。

对于每一行重复此操作，我们计算每个向量中1的数量，因此计算每个A拍的参赛者数量。最大数量对应于比赛之王。

怎么运行的

a"€¹o/€oḅ1M  Main link. Argument: M (matrix)

   ¹         Yield M.
  €          For each row of M:
a"           Take the logical AND of each entry of that row and the corr. row of M.
    o/€      Reduce each resulting matrix by logical OR.
       o     Take the logical OR of the entries of the resulting maxtrix and the
             corr. entries of M.
        ḅ1   Convert each row from base 1 to integer, i.e. sum its elements.
          M  Get all indices of maximal sums.

×Ḅ|/€|ḄBS€M  Main link. Argument: M (matrix)

 Ḅ           Convert each row of M from base 2 to integer. Result: R
×            Multiply the entries of each column of M by the corr. integer.
  |/€        Reduce each row fo the resulting matrix by bitwise OR.
     |Ḅ      Bitwise OR the results with R.
       BS€   Convert to binary and reduce by sum.
             This counts the number of set bits for each integer.
          M  Get all indices of maximal popcounts.

— 丹尼斯
source

1

您知道吗，人们不断发布这些信息并说x“字节”，但是“ḅ”是否真的以任何标准编码以1字节编码？抱歉，但是我发现这些完全基于堆栈的超浓缩语言没有意思，因为只是将每个可能的函数分配给一个Unicode字符感觉就像在作弊。

— MattPutnam '16

2

@MattPutnam果冻使用其自己的自定义编码。（而且它也不是基于堆栈的）

— 意大利面条，

2

@MattPutnam我也有类似的想法，但他们丝毫不减损传统的高尔夫运动。没有人会因为存在这些传统语言而看不起传统语言，而且与其他SE网站不同的是，这并不完全具有“这个答案比那个答案明显更好”。同样，尽管从技术上讲不允许这样做，但他们不会更改语言来支持问题（尽管事后他们可能会意识到将来的问题有用的捷径并进行操作）。

— corsiKa

为什么这些算法会输出国王？

— xnor

@Dennis我现在看到了，它的基本布尔矩阵乘法是通过逻辑或位运算完成的。实际的矩阵乘法会不会更短？

— xnor

2

Python使用numpy，54个字节

import numpy
lambda M:(M**0+M+M*M).all(1).nonzero()[0]

接收一个numpy矩阵，输出一个基于0的索引的numpy行矩阵。

认为国王的另一种方法是将所有参选者都置于国王的联盟中，国王打败的人民，以及那些人民打败的人民都参与其中。换句话说，对于每个参赛者，在“拍子”关系中，从国王到他们最多只有2条路程。

矩阵I + M + M*M对从每个源到每个目标的0、1或2步路径数进行编码。如果玩家在此矩阵的行中只有正数条目，则为王。由于0为Falsey，因此all告诉我们行是否全部为非零。我们将其应用于每一行，并输出非零结果的索引。

— 异或
source

看起来和我的方法完全一样，但解释不同，有趣=）

— 更加模糊的

2

JavaScript（ES6），83个字节

a=>a.map((b,i)=>b.every((c,j)=>c|i==j|b.some((d,k)=>d&a[k][j]))&&r.push(i),r=[])&&r

— 尼尔
source

您可以使用a => a.map（（b，i）=> b.every（（c，j）=> c | i == j | b.some（（d，k）=> d＆a [ k] [j]））&& i + 1）.filter（a => a），但这意味着您必须输出1-indexed，这真是一个不小的惊喜

— Charlie Wynn

2

MATL，12 10 9字节

Xy+HY^!Af

输入的是：首先是参赛者的数量，然后在单独的行上是一个矩阵，其中的行用分号分隔。输出基于1。

例如，第五个测试用例有输入

4
[0,1,1,0; 0,0,1,0; 0,0,0,1; 1,1,0,0]

最后一个测试用例已经输入

20
[0,0,1,1,0,1,1,0,0,0,0,1,1,0,1,1,1,1,0,1; 1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1; 0,0,0,1,0,0,0,1,1,0,1,0,1,0,0,0,0,0,1,1; 0,0,0,0,1,1,1,1,1,1,1,1,0,0,1,0,0,1,1,1; 1,0,1,0,0,0,0,1,1,0,1,1,1,0,1,1,1,1,0,1; 0,1,1,0,1,0,1,1,1,1,1,0,1,1,1,0,1,1,0,1; 0,0,1,0,1,0,0,1,1,0,1,0,1,1,1,1,1,0,1,0; 1,0,0,0,0,0,0,0,1,0,1,1,1,1,0,0,1,1,1,0; 1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,1,1; 1,0,1,0,1,0,1,1,0,0,1,0,0,0,0,1,0,1,1,1; 1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,0,0,0,0; 0,1,1,0,0,1,1,0,0,1,0,0,1,1,1,1,1,0,1,1; 0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,1,0,1,1,1; 1,0,1,1,1,0,0,0,0,1,0,0,1,0,1,1,1,1,1,1; 0,0,1,0,0,0,0,1,0,1,1,0,0,0,0,1,1,0,0,1; 0,0,1,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,1; 0,0,1,1,0,0,0,0,0,1,1,0,1,0,0,1,0,0,1,1; 0,0,1,0,0,0,1,0,1,0,1,1,0,0,1,0,1,0,1,1; 1,0,0,0,1,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0; 0,0,0,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,1,0]

在线尝试！

说明

Xy    % Implicitly take input: number. Push identity matrix with that size
+     % Implicitly take input: matrix. Add to identity matrix
HY^   % Matrix square
!     % Transpose
A     % Row vector with true entries for columns that contain all nonzero values
f     % Indices of nonzero values

— 路易斯·门多
source

1

MATL <果冻\ m /

— 瑕疵的

1

的Javascript 136 131 121 112字节

(n,m)=>m.map((a,k)=>eval(a.map((o,i)=>o||eval(a.map((p,j)=>p&&m[j][i]).join`|`)).join`+`)>n-2&&k+1).filter(a=>a)

拨打电话：

f=(n,m)=>m.map((a,k)=>eval(a.map((o,i)=>o||eval(a.map((p,j)=>p&&m[j][i]).join`|`)).join`+`)>n-2&&k+1).filter(a=>a)

f(20,[[0,0,1,1,0,1,1,0,0,0,0,1,1,0,1,1,1,1,0,1],
     [1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1],
     [0,0,0,1,0,0,0,1,1,0,1,0,1,0,0,0,0,0,1,1],         
     [0,0,0,0,1,1,1,1,1,1,1,1,0,0,1,0,0,1,1,1],
     [1,0,1,0,0,0,0,1,1,0,1,1,1,0,1,1,1,1,0,1],         
     [0,1,1,0,1,0,1,1,1,1,1,0,1,1,1,0,1,1,0,1],
     [0,0,1,0,1,0,0,1,1,0,1,0,1,1,1,1,1,0,1,0],         
     [1,0,0,0,0,0,0,0,1,0,1,1,1,1,0,0,1,1,1,0],
     [1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,1,1],         
     [1,0,1,0,1,0,1,1,0,0,1,0,0,0,0,1,0,1,1,1],
     [1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,0,0,0,0],         
     [0,1,1,0,0,1,1,0,0,1,0,0,1,1,1,1,1,0,1,1],
     [0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,1,0,1,1,1],         
     [1,0,1,1,1,0,0,0,0,1,0,0,1,0,1,1,1,1,1,1],
     [0,0,1,0,0,0,0,1,0,1,1,0,0,0,0,1,1,0,0,1],         
     [0,0,1,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,1],
     [0,0,1,1,0,0,0,0,0,1,1,0,1,0,0,1,0,0,1,1],         
     [0,0,1,0,0,0,1,0,1,0,1,1,0,0,1,0,1,0,1,1],
     [1,0,0,0,1,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0],             
     [0,0,0,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,1,0]])

监视，因为输出是按1索引编制的（保存了一些字节，不试图滤除0与否）

— 查理·永利
source

谁是比赛的王者？

背景