Najbardziej przyczyniające się wiersze

17

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

code-golf  matrix  subsequence 
— Adám
źródło

Odpowiedzi:

4

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.

— digEmAll
źródło
3

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!

— betseg
źródło
2

Haskell, 60 bajtów

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

Zwraca listę wierszy.

— nimi
źródło
2

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
— Neil
źródło
2

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}};
— David G. Stork
źródło
2
Możesz użyć skrótu i ​​usunąć białe znaki, aby zapisać bajty:SortBy[Gather@m,Total@*Flatten][[-1,1]]
— Klamka
1
Wygląda na to, że pobiera dane z predefiniowanej zmiennej, co jest niedozwolone . Zgłoszenia muszą być domyślnie pełnymi programami lub funkcjami.
— Dennis
TakeLargestBy[Gather[m], Total[#, 2] &, 1][[1, 1]] /@ m
— David G. Stork
To nie jest poprawne; zwraca tylko jeden wiersz z największymi wartościami, a nie wszystkie.
— lirtosiast
1

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!

— Arnauld
źródło
0

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ę.

— Wcielenie ignorancji
źródło
0

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

— ngn
źródło
0

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]]
— Kevin Cruijssen
źródło
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
— Business Cat
źródło
0

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?
— Bubbler
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.