Máximo máximo!

11

Inspirado por esta pergunta e refinado por Luis Mendo .

Desafio

Dada uma matriz 2D de números inteiros, cada linha tem um valor máximo. Um ou mais elementos de cada linha serão iguais ao valor máximo de suas respectivas linhas. Seu objetivo é determinar quais colunas contêm mais entradas iguais ao valor máximo de suas respectivas linhas, bem como o número máximo de linhas encontrado nessas colunas.

Entrada

  • A entrada será uma matriz Mx não vazia N( M> 0 e N> 0), em qualquer forma que seja adequada ao seu idioma de escolha.

Resultado

  • Seu programa deve retornar o índice de cada coluna que contém o número máximo de máximos em linhas (como valores separados ou uma lista). A indexação baseada em 0 ou 1 pode ser usada (especifique na sua descrição).
  • Seu programa também deve retornar o número de máximos presentes nessas colunas (um único número).
  • A ordem / formato da saída é flexível, mas deve ser explicada no texto que acompanha sua resposta.

informação adicional

  • Todas as entradas na matriz de entrada serão números inteiros positivos.
  • Se o valor máximo de uma linha for compartilhado por vários elementos nessa linha, todas as ocorrências desse valor serão contabilizadas no total de suas colunas.
  • Se várias colunas contiverem o mesmo número de máximos, você deverá retornar uma lista de todas as colunas que possuam esse número de máximos.

Um exemplo

Considere entrada

 7  93
69  35
77  30

A linha 1 possui no máximo 93, que ocorre apenas uma vez, ou seja, na coluna 2. Linha 2: ocorre na coluna 1. Linha 3: também na coluna 1. Portanto, a coluna vencedora é 1, com 2 máximos. Assim, a saída será [1] [2]. Se mudarmos a entrada para

 7  93
69  35
77  77

a saída será [1 2] [2], porque as duas colunas têm 2 máximos.

Casos de teste

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]

Pontuação

Este é o código-golfe , o código mais curto em bytes vence. O desempatador vai para a resposta anterior.

Entre os melhores

Abaixo está um trecho de pilha para analisar todas as entradas.

Mostrar snippet de código

code-golf  number  array-manipulation 
— Suever
fonte
7
Fato engraçado; a rainha holandesa se chama Maxima, então tecnicamente só podemos ter 1 Maxima.
— Bassdrop Cumberwubwubwub
1
Fato engraçado; há também um CAS de código aberto chamado Maxima .
— Flawr 27/05

Respostas:

3

Geléia , 9 bytes

="Ṁ€SµM,Ṁ

Entrada é uma lista 2D, saída é um par: uma lista de índices baseados em 1 e o número máximo de máximos.

Experimente online! ou verifique todos os casos de teste .

Como 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
fonte
3

J, 27 bytes

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

Este é um verbo monádico, usado da seguinte forma no caso do segundo exemplo:

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

A saída consiste em duas caixas e usa indexação baseada em 0. Experimente aqui!

Explicação

((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
fonte
3

MATL, 17 bytes

vH3$X>G=XstX>tb=f

A primeira saída é o número máximo de máximos e a segunda saída são as colunas nas quais isso ocorreu (indexação baseada em 1).

Experimente Online!

Explicação

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
fonte
3

MATL , 17 bytes

!tvX>!G=5#fFTT#XM

A entrada é uma matriz 2D, com linhas separadas por ponto e vírgula. Portanto, as entradas para os casos de teste são

[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]

A saída é: primeiro a quantidade máxima de máximos, depois um ou mais índices de coluna.

Experimente online!

Explicação

Isso usa uma abordagem diferente da resposta de Suever .

Primeiro, uma matriz de valores lógicos ( truee false) é calculada, onde trueindica a presença de um máximo de linha. Em seguida, os índices da coluna dos truevalores são extraídos em um vetor. Finalmente, o modo desse vetor é calculado (número máximo de máximos), juntamente com todos os valores mais frequentes (índices de coluna desejados).

!        % 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
fonte
3

Pitão, 20 19 17 bytes

1 byte graças a @Suever .

1 byte graças a @Jakube .

{MC.MhZrSsxLeSdQ8

Suíte de teste.

A saída é indexada em 0.

A ordem é revertida.

Todas as 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 as saídas

[[2], [0]]

[[2], [0, 1]]

[[2], [3]]

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

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

[[1], [0, 3]]

[[4], [0]]

[[1], [0]]

Como 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.
— Freira Furada
fonte
3

CJam , 38 35 31 bytes

2 bytes a menos graças ao @FryAmTheEggMan, com a ajuda também de @quartata. Agradecemos também a @Dennis por remover mais 4 bytes.

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

A entrada é do formato

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

A saída é uma matriz de índices de coluna com base em 1 e um número.

Experimente online!

— Luis Mendo
fonte
q~_::e>.f=:.+_:e>_@f{=U):Ua*~}psalva alguns bytes. Transformar em um bloco de código economizaria mais 1.
— Dennis
@Dennis Thanks! Agora eu preciso entender o que {=U):Ua*~}faz ...
— 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

Entrada é uma lista 2D de flutuadores, saída é um par: uma lista de índices baseados em 0 e um número inteiro.

Teste em Ideone .

— Dennis
fonte
2

Julia, 54 bytes

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

Entrada é uma matriz, saída é um par: uma lista de índices baseados em 1 e o número máximo de máximos.

Experimente online!

— Dennis
fonte
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)]

Retorna uma matriz de dois elementos; a primeira é a contagem máxima de máximos, a segunda é a matriz de colunas indexadas a zero com essa contagem.

— Neil
fonte
1

Oitava, 47 46 bytes

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

Isso cria uma função anônima que se atribui automaticamente anse pode ser executada usando ans([1 2 3; 4 5 6]). Ele retorna uma matriz de célula de dois elementos em que o primeiro elemento é o número máximo de máximos e o segundo é o índice baseado em 1 das colunas que contêm esses máximos.

Todos os casos de teste

— Suever
fonte
1

Python 3, 142 bytes

O algoritmo aqui é basicamente, percorra cada linha e aumente a pontuação das colunas que têm o máximo dessa linha. Em seguida, encontre o máximo das pontuações e encontre as colunas que possuem essa pontuação máxima e retorne-as. As colunas são indexadas em 1. Tentei alinhar isso em um lambda, mas ao gerar as pontuações coluna por coluna, era 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 teste

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]
— NonlinearFruit
fonte
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]))

Cara, eu tenho a sensação de que isso pode ser muito simplificado. Pelo menos, produz a saída correta.

[(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
fonte
1

05AB1E , 14 (ou 12) bytes

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

Saídas no formato [[1-indexed columns-list], maxima].

Experimente online ou verifique todos os casos de teste .

Se é permitido ter itens 0na lista de colunas que ignoramos, pode ser 2 bytes a menos removendo o 0K:

Experimente online ou verifique todos os casos de teste .

Explicação:

ε               # 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
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.