Maxima maximum!

11

Inspiré par cette question et raffiné par Luis Mendo .

Défi

Étant donné une matrice 2D d'entiers, chaque ligne a une valeur maximale. Un ou plusieurs éléments de chaque ligne seront égaux à la valeur maximale de leur ligne respective. Votre objectif est de déterminer la ou les colonnes qui contiennent le plus d'entrées qui sont égales à la valeur maximale de leur ligne respective ainsi que le nombre de maxima par ligne trouvés dans ces colonnes.

Contribution

  • L'entrée sera une matrice Mx non vide N( M> 0 et N> 0) sous la forme qui convient le mieux à la langue de votre choix.

Production

  • Votre programme doit renvoyer l' index de chaque colonne contenant le nombre maximal de maxima par ligne (sous forme de valeurs distinctes ou d'une liste). Vous pouvez utiliser une indexation à 0 ou à 1 (spécifiez dans votre description).
  • Votre programme doit également renvoyer le nombre de maxima présents dans ces colonnes (un seul chiffre).
  • L'ordre / format de la sortie est flexible mais doit être expliqué dans le texte accompagnant votre réponse.

Information additionnelle

  • Toutes les entrées de la matrice d'entrée seront des entiers positifs.
  • Si la valeur maximale d'une ligne est partagée par plusieurs éléments de cette ligne, toutes les occurrences de cette valeur comptent dans le total de leurs colonnes.
  • Si plusieurs colonnes contiennent le même nombre de maxima, vous devez renvoyer une liste de toutes les colonnes qui avaient ce nombre de maxima.

Un exemple

Tenez compte des commentaires

 7  93
69  35
77  30

La ligne 1 a un maximum de 93, qui n'apparaît qu'une seule fois, à savoir dans la colonne 2. La ligne 2: se produit dans la colonne 1. La ligne 3: également dans la colonne 1. La colonne gagnante est donc 1, avec 2 maxima. Ainsi, la sortie sera [1] [2]. Si nous changeons l'entrée en

 7  93
69  35
77  77

la sortie sera [1 2] [2], car les deux colonnes ont 2 maxima.

Cas de 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]

Notation

C'est le code-golf , le code le plus court en octets gagne. Tiebreaker revient à la réponse précédente.

Classement

Vous trouverez ci-dessous un extrait de pile pour analyser toutes les entrées.

Afficher l'extrait de code

code-golf number array-manipulation Suever
la source
7
Fait amusant; la reine hollandaise s'appelle Maxima, donc techniquement nous ne pouvons avoir que 1 Maxima.
Bassdrop Cumberwubwubwub
1
Fait amusant; il existe également un CAS open source appelé Maxima .
flawr

Réponses:

3

Gelée , 9 octets

="Ṁ€SµM,Ṁ

L'entrée est une liste 2D, la sortie est une paire: une liste d'indices basés sur 1 et le nombre maximal de maxima.

Essayez-le en ligne! ou vérifiez tous les cas de test .

Comment ça fonctionne

="Ṁ€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
la source
3

J, 27 octets

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

Il s'agit d'un verbe monadique, utilisé comme suit dans le cas du deuxième exemple:

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

La sortie se compose de deux cases et utilise une indexation basée sur 0. Essayez-le ici!

Explication

((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
la source
3

MATL, 17 octets

vH3$X>G=XstX>tb=f

La première sortie est le nombre maximum de maxima et la deuxième sortie est les colonnes dans lesquelles cela s'est produit (indexation basée sur 1).

Essayez-le en ligne!

Explication

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
la source
3

MATL , 17 octets

!tvX>!G=5#fFTT#XM

L'entrée est un tableau 2D, avec des lignes séparées par des points-virgules. Ainsi, les entrées pour les cas de test sont

[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 sortie est: d'abord la quantité maximale de maxima, puis un ou plusieurs indices de colonne.

Essayez-le en ligne!

Explication

Cela utilise une approche différente de la réponse de Suever .

Une matrice de valeurs logiques ( trueet false) est d'abord calculée, où trueindique la présence d'un maximum de ligne. Ensuite, les indices de colonne des truevaleurs sont extraits dans un vecteur. Enfin, le mode de ce vecteur est calculé (nombre maximum de maxima), ainsi que toutes les valeurs les plus fréquentes (indices de colonne souhaités).

!        % 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
la source
3

Pyth, 20 19 17 octets

1 octet grâce à @Suever .

1 octet grâce à @Jakube .

{MC.MhZrSsxLeSdQ8

Suite de tests.

La sortie est indexée 0.

L'ordre est inversé.

Toutes les entrées

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

Toutes les sorties

[[2], [0]]

[[2], [0, 1]]

[[2], [3]]

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

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

[[1], [0, 3]]

[[4], [0]]

[[1], [0]]

Comment ça fonctionne

{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.
Leaky Nun
la source
3

CJam , 38 35 31 octets

2 octets de moins grâce à @FryAmTheEggMan, avec l'aide également de @quartata. Merci également à @Dennis d'avoir supprimé 4 octets supplémentaires.

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

L'entrée est de la forme

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

La sortie est un tableau d'index de colonne basés sur 1 et un nombre.

Essayez-le en ligne!

Luis Mendo
la source
q~_::e>.f=:.+_:e>_@f{=U):Ua*~}penregistre quelques octets. Le transformer en un bloc de code économiserait 1 de plus.
Dennis
@Dennis Merci! Maintenant, je dois comprendre ce que {=U):Ua*~}fait ...
Luis Mendo
2

Python 2, 106 octets

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'entrée est une liste 2D de flottants, la sortie est une paire: une liste d'indices basés sur 0 et un entier.

Testez-le sur Ideone .

Dennis
la source
2

Julia, 54 octets

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

L'entrée est une matrice, la sortie est une paire: une liste d'indices basés sur 1 et le nombre maximal de maxima.

Essayez-le en ligne!

Dennis
la source
1

JavaScript (ES6), 111 octets

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

Renvoie un tableau de deux éléments; le premier est le nombre maximal de maxima, le second est le tableau de colonnes indexées zéro avec ce nombre.

Neil
la source
1

Octave, 47 46 octets

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

Cela crée une fonction anonyme qui s'assigne automatiquement anset peut être exécutée à l'aide ans([1 2 3; 4 5 6]). Il renvoie un tableau de cellules à deux éléments où le premier élément est le nombre maximal de maxima et le second est l'index basé sur 1 des colonnes contenant ces maxima.

Tous les cas de test

Suever
la source
1

Python 3, 142 octets

Ici, l'algorithme consiste essentiellement à parcourir chaque ligne et à augmenter le score des colonnes qui ont le maximum de cette ligne. Trouvez ensuite le maximum des scores et recherchez les colonnes qui ont ce score maximum et renvoyez-les. Les colonnes sont indexées 1. J'ai essayé de doubler cela en lambda, mais avec la génération des scores colonne par colonne, c'était 153 octets.

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

Cas de 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]
Non linéaire
la source
1

Clojure, 150 octets

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

Homme qui est long, j'ai le sentiment que cela pourrait être beaucoup simplifié. Au moins, il produit la sortie correcte.

[(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
la source
1

05AB1E , 14 (ou 12) octets

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

Sorties au format [[1-indexed columns-list], maxima].

Essayez-le en ligne ou vérifiez tous les cas de test .

S'il est permis d'avoir des éléments 0dans la liste des colonnes que nous ignorons, cela pourrait être 2 octets de moins en supprimant 0K:

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

ε               # 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
la source