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
source

Réponses:

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
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
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
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
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
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
source
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
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
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
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
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
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.