Linhas mais contribuintes

17

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

code-golf  matrix  subsequence 
— Adão
fonte

Respostas:

4

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.

— digEmAll
fonte
3

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!

— betseg
fonte
2

Haskell, 60 bytes

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

Retorna uma lista das linhas.

— nimi
fonte
2

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
— Neil
fonte
2

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}};
— David G. Stork
fonte
2
Você pode usar atalhos e remover espaços em branco para salvar bytes:SortBy[Gather@m,Total@*Flatten][[-1,1]]
— Maçaneta da porta
1
Parece que recebe entrada de uma variável predefinida, o que não é permitido . Os envios devem ser programas completos ou funcionar por padrão.
— Dennis
TakeLargestBy[Gather[m], Total[#, 2] &, 1][[1, 1]] /@ m
— David G. Stork
Isso não é válido; ele retorna apenas uma das linhas com maiores valores em vez de todas elas.
— lirtosiast
1

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!

— Arnauld
fonte
0

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.

— Modalidade de ignorância
fonte
0

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

— ngn
fonte
0

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]]
— Kevin Cruijssen
fonte
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
— Gato de negócios
fonte
0

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?
— Bubbler
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.