La plupart des lignes contributives

17

Étant donné une matrice non vide d'entiers non négatifs, répondez aux lignes uniques qui contribuent le plus à la somme totale des éléments de la matrice.

Répondez par toute indication raisonnable, par exemple un masque de l'ordre d'apparition des lignes uniques (ou ordre de tri), ou des indices (basés sur zéro ou un) de ceux-ci, ou une sous-matrice composée des lignes (dans n'importe quel ordre) ou certains sorte de construction de dictionnaire… - mais expliquez-le!

Exemples

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

Les lignes uniques sont [1,2,3], [2,0,4]et[6,3,0] chacun contribuant respectivement 6, 6 et 9 , chaque fois qu'ils se produisent. Cependant, ils se produisent respectivement une, trois et deux fois, de sorte que toutes leurs occurrences respectives contribuent 6, 18 et 18 au total (42), de sorte que les deux dernières lignes sont celles qui contribuent le plus. Les réponses valables sont donc:

[false,true,true] masque dans l'apparence / l'ordre de tri ou
[1,2]/ [2,3] zéro / un index basé sur les
[[2,0,4],[6,3,0]] lignes ci-dessus ou réelles
⋮

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

[false,false,true](ordre d'apparition) / [false,true,false](ordre de tri)
[2]/ [3](ordre d'apparition) / [1]/ [2](ordre de tri)
[[2,3]]
⋮

code-golf matrix subsequence Adam
la source

Réponses:

4

Pyth , 9 octets

-1 merci à FryAmTheEggman!

{s.MssZ.g

Essayez-le en ligne!

M. Xcoder
la source
1
La finale kn'est pas nécessaire. .M*sZ/QZ{Semble également être une solution de même longueur alors.
FryAmTheEggman
1
@FryAmTheEggman Oh lol comment ai-je oublié la saisie semi-automatique? Merci beaucoup!
M. Xcoder
4

R , 64 octets

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

Essayez-le en ligne!

Renvoie un vecteur booléen avec VRAI / FAUX dans l'ordre de tri (lexicographique).
Les lignes uniques sont affichées sous forme de noms de vecteur, il est donc facile d'identifier les plus contributives.

digEmAll
la source
3

Python 3 , 153 145 129 octets

-8 octets grâce à @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]]

Essayez-le en ligne!

betseg
la source
2

Haskell, 60 octets

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

Renvoie une liste des lignes.

nimi
la source
2

Fusain , 25 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Le format de sortie par défaut est chaque élément de ligne sur sa propre ligne et les lignes à double interligne. Explication:

  θ                         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
la source
2

Mathematica, 48 octets

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

ou

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

où (par exemple)

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
la source
2
Vous pouvez utiliser des raccourcis et supprimer des espaces pour économiser des octets:SortBy[Gather@m,Total@*Flatten][[-1,1]]
Poignée de porte
1
On dirait que cela prend l'entrée d'une variable prédéfinie, ce qui n'est pas autorisé . Les soumissions doivent être des programmes complets ou fonctionner par défaut.
Dennis
TakeLargestBy[Gather[m], Total[#, 2] &, 1][[1, 1]] /@ m
David G.Stork
Ce n'est pas valable; il renvoie uniquement l'une des lignes avec les plus grandes valeurs plutôt que toutes.
lirtosiast
1

JavaScript (ES6), 88 octets

Génère un tableau de valeurs booléennes dans l'ordre d'apparence.

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)

Essayez-le en ligne!

Arnauld
la source
1

Groovy , 76 octets

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

Essayez-le en ligne!

Renvoie en tant que booléens dans l'ordre de tri

ASCII uniquement
la source
1

Scala , 63 octets

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

Essayez-le en ligne!

Renvoie les booléens dans l'ordre d'apparition

ASCII uniquement
la source
1

Python 2 , 81 78 octets

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

Essayez-le en ligne!

3 octets de thx à Black Owl Kai .

Étant donné une collection de tuples, la sortie est un ensemble de ces tuples ayant la propriété maximale souhaitée.

Chas Brown
la source
78 octets
Black Owl Kai
@Black Owl Kai: merci! J'ai raté ça ...
Chas Brown
0

C # (Visual C # Interactive Compiler) , 126 octets

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

Essayez-le en ligne!

La plupart de ce code est dépensé pour supprimer toutes les valeurs en double, car le comparateur par défaut pour les listes ne compare pas les valeurs à l'intérieur des listes. Cela signifie que je ne peux pas utiliser Distinct(), GroupBy()ou Containspour filtrer la liste.

Incarnation de l'ignorance
la source
0

K (ngn / k) , 17 octets

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

Essayez-le en ligne!

{ } fonction avec argument x

=x group - forme un dictionnaire dans lequel les clés sont des lignes et les valeurs sont des listes de leurs indices dans la matrice

x@indexer la matrice d'origine avec cela. le résultat est à nouveau un dictionnaire avec les lignes comme clés. les valeurs sont plusieurs copies de la clé correspondante

+//' somme jusqu'à convergence chacun (n'agit que sur les valeurs; les clés restent telles quelles)

a: affecter à a

|/ maximum (des valeurs)

a=|/a un dictionnaire ligne-à-booléen dont les lignes contribuent le plus

& "où", c'est-à-dire quelles touches correspondent aux valeurs de 1

ngn
la source
0

05AB1E , 10 9 octets

ês{γOOZQÏ

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

ê          # 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
la source
0

Gaia , 10 octets

ȯẋ_¦Σ¦:⌉=¦

Essayez-le en ligne!

Étant donné que Gaia n'accepte pas les listes via des entrées très facilement, il s'agit d'une fonction qui accepte une liste du haut en haut de la pile et laisse le résultat en haut (sous forme de masques d'ordre trié).

ȯ           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
Chat d'affaires
la source
0

J , 16 octets

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

Essayez-le en ligne!

Un verbe monadique qui donne le résultat booléen dans l'ordre d'apparition.

Comment ça fonctionne

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