La mayoría de las filas contribuyentes

17

Dada una matriz no vacía de enteros no negativos, responda qué filas únicas contribuyen más a la suma total de elementos en la matriz.

Responda con cualquier indicación razonable, por ejemplo, una máscara del orden de aparición de las filas únicas (u orden de clasificación), o índices (basados en cero o en uno) de esos, o una submatriz compuesta por las filas (en cualquier orden) o alguna tipo de construcción de diccionario ... ¡pero explíquelo!

Ejemplos

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

Las filas únicas son [1,2,3], [2,0,4]y [6,3,0]cada una contribuye respectivamente 6, 6 y 9 cada vez que ocurren. Sin embargo, ocurren una vez, tres y dos veces respectivamente, por lo que todas sus ocurrencias respectivas contribuyen 6, 18 y 18 al total (42), por lo que las dos últimas filas son las que más contribuyen. Las respuestas válidas son por lo tanto:

[false,true,true] máscara en apariencia / orden de clasificación o
[1,2]/ [2,3] cero / índices basados en uno de los anteriores o
[[2,0,4],[6,3,0]] las filas reales
⋮

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

[false,false,true](orden de apariencia) / [false,true,false](orden de clasificación)
[2]/ [3](orden de apariencia) / [1]/ [2](orden de clasificación)
[[2,3]]
⋮

code-golf matrix subsequence

— Adán
fuente

Respuestas:

5

Jalea , 5 bytes

Ġị§§M

Pruébalo en línea!

Índices basados en 1 de elementos de entrada únicos ordenados.

— Erik el Outgolfer
fuente

3

Woha, eso es corto.

— Adám

4

Pyth , 9 bytes

-1 gracias a FryAmTheEggman!

{s.MssZ.g

Pruébalo en línea!

— Sr. Xcoder
fuente

1

La final kno es necesaria. También .M*sZ/QZ{parece ser una solución de la misma longitud entonces.

— FryAmTheEggman

1

@FryAmTheEggman Oh, jajaja, ¿cómo me olvidé del autocompletado? ¡Muchas gracias!

— Sr. Xcoder

4

R , 64 bytes

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

Pruébalo en línea!

Devuelve un vector booleano con VERDADERO / FALSO en orden de clasificación (lexicográfico).
Las filas únicas se muestran como nombres de vectores, por lo que es fácil identificar las más contribuyentes.

— digEmAll
fuente

3

Python 3 , 153 145 129 bytes

-8 bytes gracias 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]]

Pruébalo en línea!

— Betseg
fuente

2

Haskell, 60 bytes

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

Devuelve una lista de las filas.

— nimi
fuente

2

Carbón de leña , 25 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. El formato de salida predeterminado es cada elemento de fila en su propia línea y filas a doble espacio. Explicación:

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

2

Mathematica, 48 bytes

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

o

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

donde (por ejemplo)

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
fuente

2

Puede usar la taquigrafía y eliminar espacios en blanco para guardar bytes:SortBy[Gather@m,Total@*Flatten][[-1,1]]

— Pomo de la puerta

1

Parece que toma información de una variable predefinida, que no está permitida . Los envíos deben ser programas completos o funcionar de forma predeterminada.

— Dennis

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

— David G. Stork

Esto no es valido; solo devuelve una de las filas con valores más grandes en lugar de todas.

— lirtosiast el

1

JavaScript (ES6), 88 bytes

Emite una matriz de valores booleanos en orden de aparición.

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)

Pruébalo en línea!

— Arnauld
fuente

1

Groovy , 76 bytes

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

Pruébalo en línea!

Devuelve como booleanos en orden de clasificación

— Solo ASCII
fuente

1

Scala , 63 bytes

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

Pruébalo en línea!

Devuelve booleanos en orden de aparición

— Solo ASCII
fuente

1

APL (Dyalog Unicode) , 12 bytes

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

Pruébalo en línea!

-2 gracias a Adám . -1 gracias al formato de salida alternativo.

— Erik el Outgolfer
fuente

Ahora viene el desafío de la explicación ...

— Adám

1

Wolfram Language (Mathematica) , 42 bytes

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

Pruébalo en línea!

— lirtosiast
fuente

1

Python 2 , 81 78 bytes

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

Pruébalo en línea!

3 bytes gracias a Black Owl Kai .

Dada una colección de tuplas, la salida es un conjunto de esas tuplas que tienen la propiedad máxima deseada.

— Chas Brown
fuente

78 bytes

— Black Owl Kai

@ Black Owl Kai: ¡gracias! Me perdí eso ...

— Chas Brown

1

Japt , 13 11 bytes

-2 bytes de @Shaggy

ü¬®xx
m¥Urw

Pruébalo en línea!

— Luis felipe De jesus Munoz
fuente

1

11 bytes

— Shaggy

@Lanudo me ocurrió lo mismo: P

— Oliver

0

C # (compilador interactivo de Visual C #) , 126 bytes

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

Pruébalo en línea!

La mayor parte de este código se gasta sacando todos los valores duplicados, ya que el comparador predeterminado para las listas no compara los valores dentro de las listas. Eso significa que no se pueden utilizar Distinct(), GroupBy()o Containspara filtrar la lista.

— Encarnación de la ignorancia
fuente

0

K (ngn / k) , 17 bytes

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

Pruébalo en línea!

{ } funcionar con argumento x

=x grupo: forma un diccionario en el que las claves son filas y los valores son listas de sus índices en la matriz

x@indexar la matriz original con eso. el resultado es nuevamente un diccionario con las filas como claves. los valores son copias múltiples de la clave correspondiente

+//' suma hasta la convergencia de cada uno (actúa solo sobre los valores; las claves permanecen como están)

a: asignar a a

|/ máximo (de los valores)

a=|/a un diccionario de fila a booleano cuyas filas contribuyen más

& "donde", es decir, qué teclas corresponden a valores de 1

— ngn
fuente

0

Japt, 11 10 bytes

ü¬ü_xxÃÌmâ

Ejecútalo en línea

— Oliver
fuente

0

05AB1E , 10 9 bytes

ês{γOOZQÏ

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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

0

Gaia , 10 bytes

ȯẋ_¦Σ¦:⌉=¦

Pruébalo en línea!

Como Gaia no acepta listas a través de entradas muy fácilmente, esta es una función que acepta una lista desde la parte superior desde la parte superior de la pila y deja el resultado en la parte superior (como máscaras de orden ordenado).

ȯ           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

— Gato de negocios
fuente

0

J , 16 bytes

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

Pruébalo en línea!

Un verbo monádico que da el resultado booleano en orden de aparición.

Cómo funciona

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

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.

Licensed under cc by-sa 3.0 with attribution required.