Biorąc pod uwagę niepustą macierz nieujemnych liczb całkowitych, odpowiedz, które unikalne wiersze najbardziej przyczyniają się do sumy elementów w macierzy.

Odpowiedz na dowolne uzasadnione wskazanie, na przykład maskę unikatowej kolejności wyświetlania wierszy (lub kolejności sortowania), indeksów (zerowych lub opartych na jednym) z nich, lub podmacierz składającą się z wierszy (w dowolnej kolejności) lub niektórych rodzaj konstruowania słownika… - ale wyjaśnij to!

Przykłady

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

Unikalnymi wierszami są [1,2,3], [2,0,4]i [6,3,0]każdy z nich wnosi odpowiednio 6, 6 i 9 za każdym razem, gdy występują. Występują one jednak odpowiednio raz, trzykrotnie i dwa razy, więc wszystkie ich wystąpienia przyczyniają się do 6, 18 i 18 do całości (42), więc te dwa ostatnie rzędy są tymi, które mają największy udział. Prawidłowe odpowiedzi to:

[false,true,true] maska ​​w wyglądzie / porządku sortowania lub
[1,2]/ [2,3] zero / jeden indeksy powyższych lub
[[2,0,4],[6,3,0]] rzeczywistych wierszy
⋮

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

[false,false,true](kolejność pojawiania się) / [false,true,false](kolejność sortowania)
[2]/ [3](kolejność pojawiania się) / [1]/ [2](kolejność sortowania)
[[2,3]]
⋮

Galaretka , 5 bajtów

Ġị§§M

Wypróbuj online!

Wskaźniki oparte na 1 posortowane unikalne elementy wejściowe.

Pyth , 9 bajtów

-1 dzięki FryAmTheEggman!

{s.MssZ.g

Wypróbuj online!

R , 64 bajty

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

Wypróbuj online!

Zwraca wektor boolowski z PRAWDA / FAŁSZ w porządku sortowania (leksykograficznym).
Unikalne wiersze są wyświetlane jako nazwy wektorowe, dzięki czemu łatwo jest zidentyfikować te, które najbardziej się do tego przyczyniły.

Python 3 , 153 145 129 bajtów

-8 bajtów dzięki @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]]

Wypróbuj online!

Haskell, 60 bajtów

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

Zwraca listę wierszy.

Węgiel , 25 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Domyślnym formatem wyjściowym jest każdy element wiersza w osobnej linii i wiersze w podwójnych odstępach. Wyjaśnienie:

  θ                         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 bajtów

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

lub

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

gdzie (na przykład)

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 bajtów

Zwraca tablicę wartości logicznych w kolejności wyglądu.

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)

Wypróbuj online!

Groovy , 76 bajtów

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

Wypróbuj online!

Zwraca jako logiczne w porządku sortowania

Scala , 63 bajty

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

Wypróbuj online!

Zwraca wartość logiczną w kolejności wyglądu

APL (Dyalog Unicode) , 12 bajtów

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

Wypróbuj online!

-2 dzięki Adámowi . -1 dzięki alternatywnemu formatowi wyjściowemu.

Wolfram Language (Mathematica) , 42 bajty

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

Wypróbuj online!

Python 2 , 81 78 bajtów

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

Wypróbuj online!

3 bajki dzięki Black Owl Kai .

Biorąc pod uwagę zbiór krotek, dane wyjściowe są zbiorem krotek mających pożądaną maksymalną właściwość.

Japt , 13 11 bajtów

-2 bajty z @Shaggy

ü¬®xx
m¥Urw

Wypróbuj online!

C # (interaktywny kompilator Visual C #) , 126 bajtów

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

Wypróbuj online!

Większość tego kodu jest wydawana na usuwanie wszystkich zduplikowanych wartości, ponieważ domyślny moduł porównujący listy nie porównuje wartości wewnątrz list. Oznacza to, że nie mogę używać Distinct(), GroupBy()lub Containsfiltrować listę.

K (ngn / k) , 17 bajtów

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

Wypróbuj online!

{ } funkcja z argumentem x

=x grupa - utwórz słownik, w którym klucze są wierszami, a wartości są listami ich indeksów w macierzy

x@zindeksuj oryginalną macierz. wynikiem jest ponownie słownik z wierszami jako kluczami. wartości są wieloma kopiami odpowiedniego klucza

+//' sumuj do momentu uzyskania zbieżności (działa tylko na wartości; klucze pozostają bez zmian)

a: Przypisać do a

|/ maksimum (wartości)

a=|/a słownik między wierszami, którego wiersze mają największy udział

& „gdzie”, tzn. które klucze odpowiadają wartości 1

Japt, 11 10 bajtów

ü¬ü_xxÃÌmâ

Uruchom to online

05AB1E , 10 9 bajtów

ês{γOOZQÏ

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

ê          # 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 bajtów

ȯẋ_¦Σ¦:⌉=¦

Wypróbuj online!

Ponieważ Gaia nie akceptuje list bardzo łatwo poprzez dane wejściowe, jest to funkcja, która akceptuje listę od góry od góry stosu i pozostawia wynik na wierzchu (jako maski posortowanego porządku).

ȯ           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 bajtów

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

Wypróbuj online!

Czasownik monadyczny, który daje wynik logiczny w kolejności pojawiania się.

Jak to działa

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