Maxima maxima!

11

Inspirado por esta pregunta y refinado por Luis Mendo .

Desafío

Dada una matriz 2D de enteros, cada fila tiene un valor máximo. Uno o más elementos de cada fila serán iguales al valor máximo de su fila respectiva. Su objetivo es determinar qué columna (s) contienen la mayoría de las entradas que son iguales al valor máximo de sus filas respectivas, así como el número de máximos en filas encontrados en estas columnas.

Entrada

  • La entrada será una matriz Mx no vacía N( M> 0 y N> 0) en cualquier forma que se adapte bien al idioma que elija.

Salida

  • Su programa debe devolver el índice de cada columna que contiene el número máximo de máximos por fila (ya sea como valores separados o como una lista). Se puede usar la indexación basada en 0 o en 1 (especifique en su descripción).
  • Su programa también debe devolver el número de máximos que estaban presentes en estas columnas (un solo número).
  • El orden / formato de la salida es flexible, pero debe explicarse en el texto que acompaña a su respuesta.

Información Adicional

  • Todas las entradas en la matriz de entrada serán enteros positivos.
  • Si el valor máximo de una fila es compartido por varios elementos en esa fila, todas las ocurrencias de ese valor cuentan para el total de sus columnas.
  • Si varias columnas contienen el mismo número de máximos, debe devolver una lista de todas las columnas que tenían este número de máximos.

Un ejemplo

Considerar entrada

 7  93
69  35
77  30

La fila 1 tiene un máximo de 93, que ocurre solo una vez, es decir, en la columna 2. Fila 2: ocurre en la columna 1. Fila 3: también en la columna 1. Entonces la columna ganadora es 1, con 2 máximos. Por lo tanto, la salida será [1] [2]. Si cambiamos la entrada a

 7  93
69  35
77  77

la salida será [1 2] [2], porque ambas columnas tienen 2 máximos.

Casos de prueba

input                 =>    output ( [1-based index array], [nMaxima] )
----------------------------------------------
 7  93
69  35                =>    [1], [2]
77  30

 7  93
69  35                =>    [1 2], [2]
77  77     

1   2   3   4         =>    [4], [2]
5   6   7   8

16   2   3  13
 5  11  10   8        =>    [1  2  4], [1]
 9   7   6  12    

 1   1   1   1        =>    [1  2  3  4], [1]

25   6  13  25        =>    [1  4], [1]

1
2
3                     =>    [1], [4] 
4

100                   =>    [1], [1]

Puntuación

Este es el código de golf , gana el código más corto en bytes. Tiebreaker va a la respuesta anterior.

Tabla de clasificación

A continuación se muestra un fragmento de pila para analizar todas las entradas.

Mostrar fragmento de código

code-golf number array-manipulation Suever
fuente
77
Hecho de la diversión; la reina holandesa se llama Maxima, por lo que técnicamente solo podemos tener 1 Maxima.
Bassdrop Cumberwubwubwub
1
Hecho de la diversión; También hay un CAS de código abierto llamado Maxima .
flawr

Respuestas:

3

Jalea , 9 bytes

="Ṁ€SµM,Ṁ

La entrada es una lista 2D, la salida es un par: una lista de índices basados ​​en 1 y el número máximo de máximos.

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo funciona

="Ṁ€SµM,Ṁ  Main link. Argument: M (matrix)

  Ṁ€       Apply maximum to each row.
="         Zipwith equal; compare the entries of the nth row with its maxmium.
    S      Sum; reduce across columns to count the maxima in each row.
     µ     Begin a new, monadic link. Argument: A (list of maxima)
      M    Yield all indices with maximal value.
        Ṁ  Yield the maximum of A.
       ,   Pair the results to both sides.
Dennis
fuente
3

J, 27 bytes

((I.@:=;])>./)@(+/@:=>./"1)

Este es un verbo monádico, usado de la siguiente manera en el caso del segundo ejemplo:

   f =: ((I.@:=;])>./)@(+/@:=>./"1)
   m =: 3 2 $ 7 93 69 35 77 77
   f m
+---+-+
|0 1|1|
+---+-+

La salida consta de dos cuadros y utiliza indexación basada en 0. Pruébalo aquí!

Explicación

((I.@:=;])>./)@(+/@:=>./"1)  Input is m.
(            )@(          )  Composition: apply right hand side, then left hand side.
                     >./"1   Take maximum of each row of m.
                    =        Replace row maxima by 1 and other values by 0,
                +/@:         then take sum (number of maxima) on each column.
                             The result is the array of number of row maxima in each column.
          >./                Compute the maximum of this array
 (     ;])                   and put it in a box with
  I.@:=                      the indices of those entries that are equal to it.
Zgarb
fuente
3

MATL, 17 bytes

vH3$X>G=XstX>tb=f

La primera salida es el número máximo de máximos y la segunda salida son las columnas en las que esto ocurrió (indexación basada en 1).

Pruébalo en línea!

Explicación

v       % Vertically concatenate everything on the stack (nothing), yields []
        % Implicitly grab the input
H       % Push the number 2 to the stack
3$X>    % Compute the maximum value of each row (along the second dimension)
G       % Explicitly grab input again
=       % Compare each row of the input to the row-wise max (automatically broadcasts). 
Xs      % Sum the number of matches in each column
t       % Duplicate the array
X>      % Determine the max number of maxima in all columns
t       % Duplicate this value
b=f     % Find the index of the columns which had the maximum number of maxima
        % Implicitly display stack contents
Suever
fuente
3

MATL , 17 bytes

!tvX>!G=5#fFTT#XM

La entrada es una matriz 2D, con filas separadas por punto y coma. Entonces las entradas para los casos de prueba son

[7 93; 69 35; 77  30]
[7 93; 69 35; 77  77]
[1 2 3 4; 5 6 7 8]
[16 2 3 13; 5 11 10 8; 9 7 6 12]
[1 1 1 1]
[25 6 13 25]
[1; 2; 3; 4]
[100]

La salida es: primero la cantidad máxima de máximos, luego uno o más índices de columna.

Pruébalo en línea!

Explicación

Esto utiliza un enfoque diferente de la respuesta de Suever .

Primero se calcula una matriz de valores lógicos ( truey false), donde trueindica la presencia de un máximo de fila. Luego, los índices de columna de los truevalores se extraen en un vector. Finalmente, se calcula el modo de ese vector (número máximo de máximos), junto con todos los valores que son los más frecuentes (índices de columna deseados).

!        % Implicit input. Transpose
tv       % Duplicate. Concatenate vertically. This forces next function (max)
         % to work along columns even if input is a row vector
X>       % Maximum of each column (gives row vector)
!        % Transpose into column vector
G        % Push input again
=        % Test for equality, with broadcast. Gives matrix of true and false
5#f      % Column indices of true values, as a column vector
FTT#XM   % Mode of that vector, and all values that occur maximum number of times
         % Implicit display
Luis Mendo
fuente
3

Pyth, 20 19 17 bytes

1 byte gracias a @Suever .

1 byte gracias a @Jakube .

{MC.MhZrSsxLeSdQ8

Banco de pruebas.

La salida está indexada a 0.

El orden se invierte.

Todas las entradas

[[7,93],[69,35],[77,30]]
[[7,93],[69,35],[77,77]]
[[1,2,3,4],[5,6,7,8]]
[[16,2,3,13],[5,11,10,8],[9,7,6,12]]
[[1,1,1,1]]
[[25,6,13,25]]
[[1],[2],[3],[4]]
[[100]]

Todas las salidas

[[2], [0]]

[[2], [0, 1]]

[[2], [3]]

[[1], [0, 1, 3]]

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

[[1], [0, 3]]

[[4], [0]]

[[1], [0]]

Cómo funciona

{MC.MhZrSsxLeSdQ8

               Q   Yield input.
           L       For each array in input (as d):
            eSd      Yield maximum of d.
          x          Yield the 0-indexed indices of the maximum in d.
         s          Flatten.
        S           Sort.
       r         8  Run-length encoding.
                    Now the array is:
                      [number of maxima in column, index of column]
                      for all the columns
   .MhZ             Yield the sub-arrays whose first element is maximum.
                     The first element of each sub-array
                     is "number of maxima in column".
                     Now the array is:
                       [number of maxima in column, index of column]
                       for all the required columns
  C                 Transpose.
                    Now the array is:
                      [[number of maxima in each column],
                       [index of each required column]]
                    Note that every element in the
                    first sub-array is the same.
{M                  Deduplicate each.
Monja permeable
fuente
3

CJam , 38 35 31 bytes

2 bytes menos gracias a @FryAmTheEggMan, con ayuda también de @quartata. Gracias también a @Dennis por eliminar 4 bytes más.

q~_::e>.f=:.+_:e>_@f{=U):Ua*~}p

La entrada es de la forma

[[7 93] [69 35] [77 77]]

La salida es una matriz de índices de columna basados ​​en 1 y un número.

Pruébalo en línea!

Luis Mendo
fuente
q~_::e>.f=:.+_:e>_@f{=U):Ua*~}pGuarda algunos bytes. Convertirlo en un bloque de código ahorraría 1 más.
Dennis
@ Dennis Gracias! Ahora necesito entender lo que {=U):Ua*~}hace ...
Luis Mendo
2

Python 2, 106 bytes

x=map(sum,zip(*[map(max(r).__eq__,r)for r in input()]))
m=max(x);print[i for i,n in enumerate(x)if n==m],m

La entrada es una lista 2D de flotantes, la salida es un par: una lista de índices basados ​​en 0 y un número entero.

Pruébelo en Ideone .

Dennis
fuente
2

Julia, 54 bytes

f(x,m=maximum,t=sum(x.==m(x,2),1))=find(t.==m(t)),m(t)

La entrada es una matriz, la salida es un par: una lista de índices basados ​​en 1 y el número máximo de máximos.

Pruébalo en línea!

Dennis
fuente
1

JavaScript (ES6), 111 bytes

a=>[m=Math.max(...a=a[0].map((_,i)=>a.map(a=>c+=a[i]==Math.min(...a),c=0)|c)),[...a.keys()].filter(i=>a[i]==m)]

Devuelve una matriz de dos elementos; el primero es el recuento máximo de máximos, el segundo es la matriz de columnas indexadas a cero con ese recuento.

Neil
fuente
1

Octava, 47 46 bytes

@(r){m=max(s=sum(r==max(r,0,2),1)),find(s==m)}

Esto crea una función anónima que se asigna automáticamente ansy se puede ejecutar usando ans([1 2 3; 4 5 6]). Devuelve una matriz de celdas de dos elementos donde el primer elemento es el número máximo de máximos y el segundo es el índice basado en 1 de las columnas que contienen estos máximos.

Todos los casos de prueba

Suever
fuente
1

Python 3, 142 bytes

El algoritmo aquí es básicamente, pasar por cada fila y aumentar la puntuación de las columnas que tienen el máximo de esa fila. Luego encuentre el máximo de los puntajes y las columnas que tienen ese puntaje máximo y devuélvalos. Las columnas están indexadas en 1. Intenté unir esto en una lambda, pero al generar los puntajes columna por columna fue 153 bytes.

def f(r):
    s=[0]*len(r[0]);e=enumerate
    for x in r:
        for i,j in e(x):
            s[i]+=(0,1)[j==max(x)]
    m=max(s);return[i+1for i,j in e(s)if j==m],m

Casos de prueba

x=[[7, 93],
[69, 35],              
[77, 30]]

print(f(x)) #=>    [[1], 2]

x=[[ 7, 93],
[69, 35],             
[77, 77]]    

print(f(x)) #=>    [[1 2], 2]

x=[[1,  2,   3,  4],        
[5,  6,  7,  8]]

print(f(x)) #=>    [[4], 2]

x=[[16,  2,  3, 13],
 [5, 11, 10,  8],      
 [9,  7, 6, 12]]

print(f(x)) #=>    [[1  2  4], 1]

x=[[1,  1,  1,  1]]      

print(f(x)) #=>    [[1  2  3  4], 1]

x=[[25,   6,  13,  25]]        

print(f(x)) #=>    [[1  4], 1]

x=[[1],
[2],
[3],                   
[4]]

print(f(x)) #=>    [[1], 4] 

x=[[100]]                   

print(f(x)) #=>    [[1], 1]
Fruta no lineal
fuente
1

Clojure, 150 bytes

(fn[M](let[F(dissoc(frequencies(mapcat(fn[r](map-indexed #(if(=(apply max r)%2)%)r))M))nil)m(apply max(vals F))][(map first(filter #(#{m}(% 1))F))m]))

Hombre que es largo, tengo la sensación de que esto podría simplificarse mucho. Al menos produce la salida correcta.

[(f [[ 7  93][69  35][77  30]])
 (f [[ 7  93][69  35][77  77]])
 (f [[16   2   3  13][5  11  10   8][9   7   6  12]])]

[[(0) 2] [(1 0) 2] [(0 1 3) 1]]
NikoNyrh
fuente
1

05AB1E , 14 (o 12) bytes

εZQ}øOZ©Qƶ0K®‚

Salidas en el formato [[1-indexed columns-list], maxima].

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

Si se permite tener elementos 0en la lista de columnas que ignoramos, podrían ser 2 bytes menos al eliminar 0K:

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

Explicación:

ε               # Map each row in the (implicit) input-matrix:
 Z              #  Get the maximum of the row (without popping)
  Q             #  Check for each value in this row if its equal to the row-maximum
   }ø           # After the map: zip/transpose the matrix; swapping rows/columns
     O          # Take the sum of each inner list (the truthy/falsey values of the columns)
      Z         # Get the maximum column-sum (without popping)
       ©        # Store it in the register (without popping)
        Q       # Check for each column-sum if its equal to this maximum
         ƶ      # Multiply each truthy/falsey value in the list by its 1-based index
          0K    # Remove all 0s
            ®‚  # Pair the resulting list with the maximum we stored in the register
                # (and output the result implicitly)
Kevin Cruijssen
fuente