给定一个非负整数的非空矩阵，请回答哪些唯一行对矩阵中元素总数的贡献最大。

通过任何合理的指示来回答，例如，唯一行的出现顺序（或排序顺序）的掩码，或这些行的索引（从零或一开始的索引），或由行组成的子矩阵（以任何顺序）或某些一种字典构造……–但要解释一下！

例子

[[1,2,3],[2,0,4],[6,3,0],[2,0,4],[6,3,0],[2,0,4]]：

唯一的行是[1,2,3]，，[2,0,4]并且[6,3,0]每次出现时各自分别贡献6、6和9。但是，它们分别出现一次，三次和两次，因此它们各自的出现对总数（42）的贡献分别为6、18和18，因此后两行是贡献最大的。因此，有效的答案是：

[false,true,true] 上面或 实际行的 外观/排序顺序或
[1,2]/ [2,3]基于零/一的索引的 掩码⋮
[[2,0,4],[6,3,0]]

[[1,2],[3,1],[2,3],[1,2],[3,1],[2,3],[1,2]]

[false,false,true]（出现顺序）/ [false,true,false]（排序次序）
[2]/ [3]（出现顺序）/ [1]/ [2]（排序次序）
[[2,3]]
⋮

果冻，5个字节

Ġị§§M

在线尝试！

输入的排序后唯一元素的基于1的索引。

y，9个字节

-1感谢FryAmTheEggman！

{s.MssZ.g

在线尝试！

R，64字节

function(M)max(x<-tapply(rowSums(M),apply(M,1,toString),sum))==x

在线尝试！

以排序顺序（字典顺序）返回带有TRUE / FALSE的布尔向量。
唯一的行显示为矢量名称，因此很容易确定最有帮助的行。

Python 3中，153个 145 129字节

-8个字节，感谢@Mr。Xcoder！

from itertools import*
def f(l):a=[[sum(map(sum,[*s])),k]for k,s in groupby(sorted(l))];return[v[1]for v in a if v[0]==max(a)[0]]

在线尝试！

Haskell，60个字节

import Data.Lists
f x=nub$argmaxes(\e->sum e*countElem e x)x

返回行列表。

木炭，25字节

ＩΦθ∧⁼κ⌕θι⁼×№θιΣι⌈Ｅθ×№θλΣλ

在线尝试！链接是详细版本的代码。默认输出格式是每行元素在其自己的行上，行以双倍行距隔开。说明：

  θ                         Input array
 Φ                          Filtered where
     κ                      Current index
    ⁼                       Equals
      ⌕                     First index of
        ι                   Current row
       θ                    In input array
   ∧                        Logical And
           №                Count of
             ι              Current row
            θ               In input array
          ×                 Multiplied by
              Σ             Sum of
               ι            Current row
         ⁼                  Equals
                ⌈           Maximum of
                  θ         Input array
                 Ｅ          Mapped over rows
                    №       Count of
                      λ     Current row
                     θ      In input array
                   ×        Multiplied by
                       Σ    Sum of
                        λ   Current row
Ｉ                           Cast to string
                            Implicitly printed

Mathematica，48个字节

Last[SortBy[Gather[m], Total[Flatten[#]] &]][[1]]

要么

TakeLargestBy[Gather[m], Total[#, 2] &, 1][[1, 1]]

哪里（例如）

m = {{1, 2, 3}, {2, 0, 4}, {7, 9, 5}, {6, 3, 0}, {2, 0, 4}, 
     {6, 3, 0}, {2, 0, 4}, {7, 9, 5}};

JavaScript（ES6），88个字节

按出现顺序输出布尔值数组。

m=>m.map(h=o=r=>h=(v=o[r]=~~o[r]+eval(r.join`+`))<h?h:v)&&Object.keys(o).map(x=>o[x]==h)

在线尝试！

Groovy，76个字节

{l->m=l.toSet().sort().collect{it.sum()*l.count(it)}
m.collect{it==m.max()}}

在线尝试！

以排序顺序返回为布尔值

Scala，63个字节

l=>{var m=l.distinct.map(n=>n.sum*l.count(n==))
m.map(m.max==)}

在线尝试！

按出现顺序返回布尔值

APL（Dyalog Unicode），12 个字节

(⌈/=⊢)+.×∘⍴⌸

在线尝试！

-2感谢Adám。-1感谢替代输出格式。

Wolfram语言（Mathematica），42个字节

#~Position~Max@#&@(Total[#,2]&/@Gather@#)&

在线尝试！

Python 2中，81 78个字节

lambda a:{u for u in a if a.count(u)*sum(u)==max(a.count(t)*sum(t)for t in a)}

在线尝试！

3个字节至Black Owl Kai。

给定一个元组的集合，输出是具有所需最大属性的那些元组的集合。

Japt，13 11字节

@Shaggy的-2个字节

ü¬®xx
m¥Urw

在线尝试！

C＃（Visual C＃交互式编译器），126个字节

n=>{var i=n.OrderBy(a=>a.Sum()*n.Count(a.SequenceEqual));return i.Where((a,b)=>i.Take(b).Count(a.SequenceEqual)<1).Reverse();}

在线尝试！

由于列表的默认比较器不比较列表中的值，因此大部分代码都花在了删除所有重复值上。这意味着我不能使用Distinct()，GroupBy()或Contains过滤列表。

K（ngn / k），17个字节

{&a=|/a:+//'x@=x}

在线尝试！

{ } 带参数的功能 x

=x 组-形成一个字典，其中的键是行，值是它们在矩阵中的索引的列表

x@用它索引原始矩阵。结果再次是将行作为键的字典。值是相应密钥的多个副本

+//' 求和，直到每个收敛为止（仅作用于值；键保持原样）

a: 分配给 a

|/ 最大值（值）

a=|/a 行对布尔的字典，其中哪些行贡献最大

& “ where”，即哪些键对应于值1

Japt，11个10字节

ü¬ü_xxÃÌmâ

在线运行

05AB1E，10 9 字节

ês{γOOZQÏ

在线尝试或验证所有测试用例。

说明：

ê          # Sort and uniquify the (implicit) input list of lists
           #  i.e. [[2,0,4],[1,2,3],[6,3,0],[2,0,4],[6,3,0],[2,0,4]]
           #   → [[1,2,3],[2,0,4],[6,3,0]]
 s         # Swap so the (implicit) input list of lists is at the top again
  {        # Sort it
           #  i.e. [[2,0,4],[1,2,3],[6,3,0],[2,0,4],[6,3,0],[2,0,4]]
           #   → [[1,2,3],[2,0,4],[2,0,4],[2,0,4],[6,3,0],[6,3,0]]
   γ       # Group the sorted list of lists
           #  i.e. [[1,2,3],[2,0,4],[2,0,4],[2,0,4],[6,3,0],[6,3,0]]
           #   → [[[1,2,3]],[[2,0,4],[2,0,4],[2,0,4]],[[6,3,0],[6,3,0]]]
    O      # Take the sum of each inner-most lists
           #  i.e. [[[1,2,3]],[[2,0,4],[2,0,4],[2,0,4]],[[6,3,0],[6,3,0]]]
           #   → [[6],[6,6,6],[9,9]]
     O     # Take the sum of each inner list
           #  i.e. [[6],[6,6,6],[9,9]] → [6,18,18]
      Z    # Get the max (without popping the list of sums)
           #  i.e. [6,18,18] → 18
       Q   # Check for each if this max is equal to the sum
           #  i.e. [6,18,18] and 18 → [0,1,1]
        Ï  # Filter the uniquified list of lists on truthy values (and output implicitly)
           #  i.e. [[1,2,3],[2,0,4],[6,3,0]] and [0,1,1] → [[2,0,4],[6,3,0]]

盖亚 10字节

ȯẋ_¦Σ¦:⌉=¦

在线尝试！

由于Gaia不太容易通过输入接受列表，因此该函数可以从堆栈顶部开始接受列表，并将结果放在顶部（作为排序顺序的掩码）。

ȯ           Sort the list
 ẋ          Split it into runs of the same element (in this case, runs of the same row)
  _¦        Flatten each sublist
    Σ¦      Sum each sublist
      :⌉    Find the maximum sum
        =¦  Compare each sum for equality with the maximum

J，16字节

[:(=>./)+/^:2/.~

在线尝试！

以外观顺序给出布尔结果的单子动词。

怎么运行的

[:(=>./)+/^:2/.~
             /.~  Self-classify; collect identical rows in appearance order
                  For each collected rows (= a matrix),
        +/^:2       Sum all the elements into one value
[:(=>./)          Compute the boolean vector:
    >./             Is the max of the array
   =                equal to this element?