Dada una matriz no vacía de enteros no negativos, responda qué filas únicas contribuyen más a la suma total de elementos en la matriz.

Responda con cualquier indicación razonable, por ejemplo, una máscara del orden de aparición de las filas únicas (u orden de clasificación), o índices (basados ​​en cero o en uno) de esos, o una submatriz compuesta por las filas (en cualquier orden) o alguna tipo de construcción de diccionario ... ¡pero explíquelo!

Ejemplos

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

Las filas únicas son [1,2,3], [2,0,4]y [6,3,0]cada una contribuye respectivamente 6, 6 y 9 cada vez que ocurren. Sin embargo, ocurren una vez, tres y dos veces respectivamente, por lo que todas sus ocurrencias respectivas contribuyen 6, 18 y 18 al total (42), por lo que las dos últimas filas son las que más contribuyen. Las respuestas válidas son por lo tanto:

[false,true,true] máscara en apariencia / orden de clasificación o
[1,2]/ [2,3] cero / índices basados ​​en uno de los anteriores o
[[2,0,4],[6,3,0]] las filas reales
⋮

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

[false,false,true](orden de apariencia) / [false,true,false](orden de clasificación)
[2]/ [3](orden de apariencia) / [1]/ [2](orden de clasificación)
[[2,3]]
⋮

Jalea , 5 bytes

Ġị§§M

Pruébalo en línea!

Índices basados ​​en 1 de elementos de entrada únicos ordenados.

Pyth , 9 bytes

-1 gracias a FryAmTheEggman!

{s.MssZ.g

Pruébalo en línea!

R , 64 bytes

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

Pruébalo en línea!

Devuelve un vector booleano con VERDADERO / FALSO en orden de clasificación (lexicográfico).
Las filas únicas se muestran como nombres de vectores, por lo que es fácil identificar las más contribuyentes.

Python 3 , 153 145 129 bytes

-8 bytes gracias 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]]

Pruébalo en línea!

Haskell, 60 bytes

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

Devuelve una lista de las filas.

Carbón de leña , 25 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. El formato de salida predeterminado es cada elemento de fila en su propia línea y filas a doble espacio. Explicación:

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

o

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

donde (por ejemplo)

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

Emite una matriz de valores booleanos en orden de aparición.

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)

Pruébalo en línea!

Groovy , 76 bytes

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

Pruébalo en línea!

Devuelve como booleanos en orden de clasificación

Scala , 63 bytes

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

Pruébalo en línea!

Devuelve booleanos en orden de aparición

APL (Dyalog Unicode) , 12 bytes

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

Pruébalo en línea!

-2 gracias a Adám . -1 gracias al formato de salida alternativo.

Wolfram Language (Mathematica) , 42 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

3 bytes gracias a Black Owl Kai .

Dada una colección de tuplas, la salida es un conjunto de esas tuplas que tienen la propiedad máxima deseada.

Japt , 13 11 bytes

-2 bytes de @Shaggy

ü¬®xx
m¥Urw

Pruébalo en línea!

C # (compilador interactivo de 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();}

Pruébalo en línea!

La mayor parte de este código se gasta sacando todos los valores duplicados, ya que el comparador predeterminado para las listas no compara los valores dentro de las listas. Eso significa que no se pueden utilizar Distinct(), GroupBy()o Containspara filtrar la lista.

K (ngn / k) , 17 bytes

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

Pruébalo en línea!

{ } funcionar con argumento x

=x grupo: forma un diccionario en el que las claves son filas y los valores son listas de sus índices en la matriz

x@indexar la matriz original con eso. el resultado es nuevamente un diccionario con las filas como claves. los valores son copias múltiples de la clave correspondiente

+//' suma hasta la convergencia de cada uno (actúa solo sobre los valores; las claves permanecen como están)

a: asignar a a

|/ máximo (de los valores)

a=|/a un diccionario de fila a booleano cuyas filas contribuyen más

& "donde", es decir, qué teclas corresponden a valores de 1

Japt, 11 10 bytes

ü¬ü_xxÃÌmâ

Ejecútalo en línea

05AB1E , 10 9 bytes

ês{γOOZQÏ

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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

ȯẋ_¦Σ¦:⌉=¦

Pruébalo en línea!

Como Gaia no acepta listas a través de entradas muy fácilmente, esta es una función que acepta una lista desde la parte superior desde la parte superior de la pila y deja el resultado en la parte superior (como máscaras de orden ordenado).

ȯ           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/.~

Pruébalo en línea!

Un verbo monádico que da el resultado booleano en orden de aparición.

Cómo 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?