Massimi massimi!

11

Ispirato da questa domanda e perfezionato da Luis Mendo .

Sfida

Data una matrice 2D di numeri interi, ogni riga ha un valore massimo. Uno o più elementi di ciascuna riga saranno uguali al valore massimo della rispettiva riga. Il tuo obiettivo è determinare quali colonne contengono il maggior numero di voci uguali al valore massimo della rispettiva riga e al numero di massimi per riga trovati in queste colonne.

Ingresso

  • L'input sarà una matrice Mx non vuota N( M> 0 e N> 0) in qualunque forma sia adatta alla tua lingua preferita.

Produzione

  • Il programma dovrebbe restituire l' indice di ogni colonna contenente il numero massimo di massimi per riga (sia come valori separati che come elenco). È possibile utilizzare l'indicizzazione basata su 0 o 1 (specificare nella descrizione).
  • Il tuo programma dovrebbe anche restituire il numero di massimi presenti in queste colonne (un singolo numero).
  • L'ordine / formato dell'output è flessibile ma dovrebbe essere spiegato nel testo che accompagna la tua risposta.

Informazioni aggiuntive

  • Tutte le voci nella matrice di input saranno numeri interi positivi.
  • Se il valore massimo di una riga è condiviso da più elementi in quella riga, tutte le occorrenze di quel valore contano ai fini del totale delle loro colonne.
  • Se più colonne contengono lo stesso numero di massimi, è necessario restituire un elenco di tutte le colonne con questo numero di massimi.

Un esempio

Considera l'input

 7  93
69  35
77  30

La riga 1 ha un massimo di 93, che si verifica una sola volta, vale a dire alla colonna 2. Riga 2: compare alla colonna 1. Riga 3: anche alla colonna 1. Quindi la colonna vincente è 1, con 2 massimi. Quindi l'output sarà [1] [2]. Se cambiamo l'input in

 7  93
69  35
77  77

l'output sarà [1 2] [2], poiché entrambe le colonne hanno 2 massimi.

Casi test

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]

punteggio

Questo è code-golf , vince il codice più breve in byte. Tiebreaker va alla risposta precedente.

Classifica

Di seguito è riportato un frammento di stack per l'analisi di tutte le voci.

Mostra snippet di codice

code-golf  number  array-manipulation 
— Suever
fonte
7
Fatto divertente; la regina olandese si chiama Maxima, quindi tecnicamente possiamo avere solo 1 Maxima.
— Bassdrop Cumberwubwubwub,
1
Fatto divertente; c'è anche un CAS open source chiamato Maxima .
— flawr,

Risposte:

3

Gelatina , 9 byte

="Ṁ€SµM,Ṁ

L'input è un elenco 2D, l'output è una coppia: un elenco di indici basati su 1 e il numero massimo di massimi.

Provalo online! o verifica tutti i casi di test .

Come funziona

="Ṁ€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 byte

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

Questo è un verbo monadico, usato come segue nel caso del secondo esempio:

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

L'output è costituito da due caselle e utilizza l'indicizzazione basata su 0. Provalo qui!

Spiegazione

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

vH3$X>G=XstX>tb=f

Il primo output è il numero massimo di massimi e il secondo output sono le colonne in cui si è verificato (indicizzazione basata su 1).

Provalo online!

Spiegazione

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 byte

!tvX>!G=5#fFTT#XM

L'input è un array 2D, con righe separate da punti e virgola. Quindi gli input per i casi di test sono

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

L'output è: prima la quantità massima di massimi, quindi uno o più indici di colonna.

Provalo online!

Spiegazione

Questo utilizza un approccio diverso dalla risposta di Suever .

Innanzitutto viene calcolata una matrice di valori logici ( truee false), dove trueindica la presenza di un massimo di riga. Quindi gli indici di colonna dei truevalori vengono estratti in un vettore. Infine, viene calcolata la modalità di quel vettore (numero massimo di massimi), insieme a tutti i valori più frequenti (indici di colonna desiderati).

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

Pyth, 20 19 17 byte

1 byte grazie a @Suever .

1 byte grazie a @Jakube .

{MC.MhZrSsxLeSdQ8

Suite di test.

L'output è indicizzato 0.

L'ordine è invertito.

Tutti gli input

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

Tutte le uscite

[[2], [0]]

[[2], [0, 1]]

[[2], [3]]

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

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

[[1], [0, 3]]

[[4], [0]]

[[1], [0]]

Come funziona

{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.
— Perdente Suora
fonte
3

CJam , 38 35 31 byte

2 byte in meno grazie a @FryAmTheEggMan, con l'aiuto anche di @quartata. Grazie anche a @Dennis per aver rimosso altri 4 byte.

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

L'input è nella forma

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

L'output è un array di indici di colonna basati su 1 e un numero.

Provalo online!

— Luis Mendo
fonte
q~_::e>.f=:.+_:e>_@f{=U):Ua*~}psalva qualche byte. Trasformandolo in un blocco di codice si risparmierebbe 1 altro.
— Dennis,
@Dennis Grazie! Ora devo capire cosa {=U):Ua*~}fa ...
— Luis Mendo,
2

Python 2, 106 byte

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

L'input è un elenco 2D di float, l'output è una coppia: un elenco di indici basati su 0 e un numero intero.

Provalo su Ideone .

— Dennis
fonte
2

Julia, 54 byte

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

L'input è una matrice, l'output è una coppia: un elenco di indici basati su 1 e il numero massimo di massimi.

Provalo online!

— Dennis
fonte
1

JavaScript (ES6), 111 byte

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

Restituisce una matrice di due elementi; il primo è il conteggio massimo dei massimi, il secondo è l'array di colonne con indice zero con quel conteggio.

— Neil
fonte
1

Ottava, 47 46 byte

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

Ciò crea una funzione anonima che si assegna automaticamente a anse può essere eseguita utilizzando ans([1 2 3; 4 5 6]). Restituisce una matrice di celle a due elementi in cui il primo elemento è il numero massimo di massimi e il secondo è l'indice in base 1 delle colonne che contengono questi massimi.

Tutti i casi di test

— Suever
fonte
1

Python 3, 142 byte

L'algoritmo qui è fondamentalmente, passa attraverso ogni riga e aumenta il punteggio delle colonne che hanno il massimo di quella riga. Quindi trova il massimo dei punteggi e trova le colonne che hanno quel punteggio massimo e restituiscili. Le colonne sono 1 indicizzate. Ho provato a incorporare questo in un lambda, ma con la generazione dei punteggi colonna per colonna sono stati 153 byte.

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

Casi test

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 byte

(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]))

Amico che è lungo, ho la sensazione che questo potrebbe essere semplificato molto. Almeno produce l'output corretto.

[(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 (o 12) byte

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

Output nel formato [[1-indexed columns-list], maxima].

Provalo online o verifica tutti i casi di test .

Se è consentito avere elementi 0nell'elenco di colonne che ignoriamo, potrebbe essere di 2 byte in meno rimuovendo 0K:

Provalo online o verifica tutti i casi di test .

Spiegazione:

ε               # 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
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.