Le righe più contribuenti

17

Data una matrice non vuota di numeri interi non negativi, rispondi a quali righe univoche contribuiscono maggiormente alla somma totale degli elementi nella matrice.

Rispondi con qualsiasi indicazione ragionevole, ad esempio una maschera dell'ordine di aspetto (o dell'ordinamento) delle righe univoco, o degli indici (a base zero o uno) di questi, o una matrice secondaria costituita dalle righe (in qualsiasi ordine) o alcuni tipo di dizionario costruito ... - ma spiegalo!

Esempi

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

Le righe univoche sono [1,2,3], [2,0,4]e [6,3,0]ciascuna contribuisce rispettivamente 6, 6 e 9 ogni volta che si verificano. Tuttavia, si verificano una volta, tre volte e due volte, quindi tutte le loro rispettive occorrenze contribuiscono 6, 18 e 18 al totale (42), quindi le ultime due righe sono quelle che contribuiscono maggiormente. Le risposte valide sono quindi:

[false,true,true] maschera nell'aspetto / ordinamento o
[1,2]/ [2,3] zero / indici a base singola delle
[[2,0,4],[6,3,0]] righe precedenti o effettive
⋮

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

[false,false,true](ordine di apparizione) / [false,true,false](ordinamento)
[2]/ [3](ordine di apparizione) / [1]/ [2](ordinamento)
[[2,3]]
⋮

code-golf  matrix  subsequence 
— Adamo
fonte

Risposte:

4

R , 64 byte

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

Provalo online!

Restituisce un vettore booleano con VERO / FALSO nell'ordinamento (lessicografico).
Le righe univoche vengono visualizzate come nomi vettoriali, quindi è facile identificare quelle che contribuiscono.

— digEmAll
fonte
3

Python 3 , 153 145 129 byte

-8 byte grazie 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]]

Provalo online!

— betseg
fonte
2

Haskell, 60 byte

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

Restituisce un elenco di righe.

— Nome del modello
fonte
2

Carbone , 25 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Il formato di output predefinito è ogni elemento riga sulla propria riga e righe a doppia spaziatura. Spiegazione:

  θ                         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 byte

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

o

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

dove (ad esempio)

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
È possibile utilizzare la scorciatoia e rimuovere gli spazi bianchi per salvare i byte:SortBy[Gather@m,Total@*Flatten][[-1,1]]
— Maniglia della porta
1
Sembra che prenda input da una variabile predefinita, che non è consentita . Gli invii devono essere programmi completi o funzioni per impostazione predefinita.
— Dennis,
TakeLargestBy[Gather[m], Total[#, 2] &, 1][[1, 1]] /@ m
— David G. Stork,
Questo non è valido; restituisce solo una delle righe con i valori più grandi anziché tutte.
— lirtosiast,
1

JavaScript (ES6), 88 byte

Emette un array di valori booleani in ordine di apparizione.

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)

Provalo online!

— Arnauld
fonte
0

C # (compilatore interattivo Visual C #) , 126 byte

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

Provalo online!

Gran parte di questo codice viene impiegato per eliminare tutti i valori duplicati, poiché il comparatore predefinito per gli elenchi non confronta i valori all'interno degli elenchi. Ciò significa che non posso usare Distinct(), GroupBy()o Containsper filtrare l'elenco.

— Incarnazione dell'ignoranza
fonte
0

K (ngn / k) , 17 byte

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

Provalo online!

{ } funzione con argomento x

=x gruppo: forma un dizionario in cui le chiavi sono righe e i valori sono elenchi dei loro indici nella matrice

x@indicizza la matrice originale con quella. il risultato è di nuovo un dizionario con le righe come chiavi. i valori sono più copie della chiave corrispondente

+//' somma fino alla convergenza ciascuno (agisce solo sui valori; le chiavi rimangono così come sono)

a: assegnato a a

|/ massimo (dei valori)

a=|/a un dizionario da riga a booleana di cui le righe contribuiscono maggiormente

& "dove", ovvero quali chiavi corrispondono ai valori di 1

— NGN
fonte
0

05AB1E , 10 9 byte

ês{γOOZQÏ

Provalo online o verifica tutti i casi di test .

Spiegazione:

ê          # 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 byte

ȯẋ_¦Σ¦:⌉=¦

Provalo online!

Poiché Gaia non accetta elenchi tramite input molto facilmente, questa è una funzione che accetta un elenco dall'alto dalla cima dello stack e lascia il risultato in primo piano (come maschere di ordine ordinato).

ȯ           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
— Gatto di affari
fonte
0

J , 16 byte

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

Provalo online!

Un verbo monadico che dà il risultato booleano in ordine di apparizione.

Come funziona

[:(=>./)+/^: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
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.