Dada uma matriz não vazia de números inteiros não negativos, responda quais linhas exclusivas contribuem mais para a soma total de elementos na matriz.

Responda por qualquer indicação razoável, por exemplo, uma máscara da ordem de aparência de linhas exclusiva (ou ordem de classificação), ou índices (com base em zero ou um) daquelas, ou uma submatriz que consiste nas linhas (em qualquer ordem) ou em alguma tipo de construção de dicionário ... - mas explique!

Exemplos

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

As linhas originais são [1,2,3], [2,0,4]e [6,3,0]cada um, respectivamente, contribuindo 6, 6 e 9 de cada vez que eles ocorrem. No entanto, elas ocorrem uma vez, três vezes e duas vezes, respectivamente, de modo que todas as suas respectivas ocorrências contribuem com 6, 18 e 18 para o total (42); portanto, as duas últimas linhas são as que mais contribuem. Respostas válidas são, portanto:

[false,true,true] mascarar na aparência / ordem de classificação ou
[1,2]/ [2,3] zero / índices baseados em uma das
[[2,0,4],[6,3,0]] linhas acima ou reais
⋮

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

[false,false,true](ordem de aparência) / [false,true,false](ordem de classificação)
[2]/ [3](ordem de aparência) / [1]/ [2](ordem de classificação)
[[2,3]]
⋮

Gelatina , 5 bytes

Ġị§§M

Experimente online!

Índices baseados em 1 de elementos exclusivos classificados de entrada.

Pitão , 9 bytes

-1 graças a FryAmTheEggman!

{s.MssZ.g

Experimente online!

R , 64 bytes

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

Experimente online!

Retorna um vetor booleano com TRUE / FALSE em ordem de classificação (lexicográfico).
As linhas exclusivas são mostradas como nomes de vetores, portanto é fácil identificar as que mais contribuem.

Python 3 , 153 145 129 bytes

-8 bytes graças a @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]]

Experimente online!

Haskell, 60 bytes

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

Retorna uma lista das linhas.

Carvão , 25 bytes

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

Experimente online! Link é a versão detalhada do código. O formato de saída padrão é cada elemento da linha em sua própria linha e as linhas são espaçadas duas vezes. Explicação:

  θ                         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 bytes

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

ou

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

onde (por exemplo)

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 bytes

Gera uma matriz de valores booleanos em ordem de aparência.

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)

Experimente online!

Groovy , 76 bytes

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

Experimente online!

Retorna como booleanos na ordem de classificação

Scala , 63 bytes

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

Experimente online!

Retorna booleanos em ordem de aparência

APL (Dyalog Unicode) , 12 bytes

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

Experimente online!

-2 graças a Adám . -1 graças ao formato de saída alternativo.

Wolfram Language (Mathematica) , 42 bytes

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

Experimente online!

Python 2 , 81 78 bytes

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

Experimente online!

3 bytes de thx para Black Owl Kai .

Dada uma coleção de tuplas, a saída é um conjunto dessas tuplas com a propriedade máxima desejada.

Japonês , 13 11 bytes

-2 bytes de @Shaggy

ü¬®xx
m¥Urw

Experimente online!

C # (compilador interativo do Visual C #) , 126 bytes

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();}

Experimente online!

A maior parte desse código é gasta retirando todos os valores duplicados, pois o comparador padrão para listas não compara os valores dentro das listas. Isso significa que eu não posso usar Distinct(), GroupBy()ou Containspara filtrar a lista.

K (ngn / k) , 17 bytes

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

Experimente online!

{ } função com argumento x

=x group - forma um dicionário no qual as chaves são linhas e os valores são listas de seus índices na matriz

x@indexe a matriz original com isso. o resultado é novamente um dicionário com as linhas como chaves. os valores são várias cópias da chave correspondente

+//' soma até convergência cada (atua apenas nos valores; as chaves permanecem como estão)

a: atribuir a a

|/ máximo (dos valores)

a=|/a um dicionário linha a booleano cujas linhas contribuem mais

& "where", ou seja, quais chaves correspondem aos valores de 1

Japonês, 11 10 bytes

ü¬ü_xxÃÌmâ

Execute on-line

05AB1E , 10 9 bytes

ês{γOOZQÏ

Experimente online ou verifique todos os casos de teste .

Explicação:

ê          # 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]]

Gaia , 10 bytes

ȯẋ_¦Σ¦:⌉=¦

Experimente online!

Como o Gaia não aceita listas através de entradas com muita facilidade, esta é uma função que aceita uma lista do topo da pilha e deixa o resultado no topo (como máscaras de ordem classificada).

ȯ           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 bytes

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

Experimente online!

Um verbo monádico que fornece o resultado booleano em ordem de aparência.

Como funciona

[:(=>./)+/^: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?