Maximales Maximum!

11

Inspiriert von dieser Frage und verfeinert von Luis Mendo .

Herausforderung

Bei einer 2D-Matrix von Ganzzahlen hat jede Zeile einen Maximalwert. Ein oder mehrere Elemente jeder Zeile entsprechen dem Maximalwert der jeweiligen Zeile. Ihr Ziel ist es zu bestimmen, welche Spalte (n) die meisten Einträge enthält, die dem Maximalwert der jeweiligen Zeile sowie der Anzahl der in diesen Spalten gefundenen zeilenweisen Maxima entsprechen.

Eingang

  • Die Eingabe ist eine nicht leere Mx- NMatrix ( M> 0 und N> 0) in einer beliebigen Form, die für die Sprache Ihrer Wahl gut geeignet ist.

Ausgabe

  • Ihr Programm sollte den Index jeder Spalte zurückgeben, die die maximale Anzahl zeilenweiser Maxima enthält (entweder als separate Werte oder als Liste). Es kann entweder eine 0- oder eine 1-basierte Indizierung verwendet werden (in Ihrer Beschreibung angeben).
  • Ihr Programm sollte auch die Anzahl der Maxima zurückgeben, die in diesen Spalten vorhanden waren (eine einzelne Zahl).
  • Die Reihenfolge / das Format der Ausgabe ist flexibel, sollte jedoch im Text zu Ihrer Antwort erläutert werden.

zusätzliche Information

  • Alle Einträge in der Eingabematrix sind positive ganze Zahlen.
  • Wenn der Maximalwert einer Zeile von mehreren Elementen in dieser Zeile gemeinsam genutzt wird, werden alle Vorkommen dieses Werts auf die Gesamtsumme ihrer Spalten angerechnet.
  • Wenn mehrere Spalten dieselbe Anzahl von Maxima enthalten, sollten Sie eine Liste aller Spalten zurückgeben, die diese Anzahl von Maxima hatten.

Ein Beispiel

Eingabe berücksichtigen

 7  93
69  35
77  30

Zeile 1 hat das Maximum 93, das nur einmal vorkommt, nämlich in Spalte 2. Zeile 2: tritt in Spalte 1 auf. Zeile 3: auch in Spalte 1. Die Gewinnerspalte ist also 1 mit 2 Maxima. Somit wird die Ausgabe sein [1] [2]. Wenn wir die Eingabe auf ändern

 7  93
69  35
77  77

Die Ausgabe erfolgt [1 2] [2], da beide Spalten 2 Maxima haben.

Testfälle

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]

Wertung

Dies ist Code-Golf , der kürzeste Code in Bytes gewinnt. Tiebreaker geht zur früheren Antwort.

Bestenliste

Unten finden Sie einen Stapelausschnitt zur Analyse aller Einträge.

Code-Snippet anzeigen

code-golf  number  array-manipulation 
— Suever
quelle
7
Lustige Tatsache; Die niederländische Königin heißt Maxima, technisch gesehen können wir also nur 1 Maxima haben.
— Bassdrop Cumberwubwubwub
1
Lustige Tatsache; Es gibt auch ein OpenSource-CAS namens Maxima .
— Fehler

Antworten:

3

Gelee , 9 Bytes

="Ṁ€SµM,Ṁ

Die Eingabe ist eine 2D-Liste, die Ausgabe ist ein Paar: eine Liste von 1-basierten Indizes und die maximale Anzahl von Maxima.

Probieren Sie es online aus! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

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

J, 27 Bytes

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

Dies ist ein monadisches Verb, das im Fall des zweiten Beispiels wie folgt verwendet wird:

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

Die Ausgabe besteht aus zwei Feldern und verwendet eine 0-basierte Indizierung. Probieren Sie es hier aus!

Erläuterung

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

MATL, 17 Bytes

vH3$X>G=XstX>tb=f

Die erste Ausgabe ist die maximale Anzahl von Maxima und die zweite Ausgabe sind die Spalten, in denen dies aufgetreten ist (1-basierte Indizierung).

Probieren Sie es online aus!

Erläuterung

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

MATL , 17 Bytes

!tvX>!G=5#fFTT#XM

Die Eingabe ist ein 2D-Array mit durch Semikolons getrennten Zeilen. Die Eingaben für die Testfälle sind also

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

Die Ausgabe ist: zuerst die maximale Anzahl von Maxima, dann ein oder mehrere Spaltenindizes.

Probieren Sie es online aus!

Erläuterung

Dies verwendet einen anderen Ansatz als Suevers Antwort .

Zuerst wird eine Matrix logischer Werte ( trueund false) berechnet, wobei truedas Vorhandensein eines Zeilenmaximums angezeigt wird. Dann werden die Spaltenindizes der trueWerte in einen Vektor extrahiert. Schließlich wird der Modus dieses Vektors berechnet (maximale Anzahl von Maxima), zusammen mit allen Werten, die am häufigsten sind (gewünschte Spaltenindizes).

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

Pyth, 20 19 17 Bytes

1 Byte danke an @Suever .

1 Byte dank @Jakube .

{MC.MhZrSsxLeSdQ8

Testsuite.

Die Ausgabe ist 0-indiziert.

Reihenfolge ist umgekehrt.

Alle Eingänge

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

Alle Ausgänge

[[2], [0]]

[[2], [0, 1]]

[[2], [3]]

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

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

[[1], [0, 3]]

[[4], [0]]

[[1], [0]]

Wie es funktioniert

{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.
— Undichte Nonne
quelle
3

CJam , 38 35 31 Bytes

2 Bytes weniger dank @FryAmTheEggMan, mit Hilfe auch von @quartata. Vielen Dank auch an @Dennis für das Entfernen von 4 weiteren Bytes.

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

Die Eingabe erfolgt in der Form

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

Die Ausgabe besteht aus einem Array von 1-basierten Spaltenindizes und einer Zahl.

Probieren Sie es online aus!

— Luis Mendo
quelle
q~_::e>.f=:.+_:e>_@f{=U):Ua*~}pspart ein paar Bytes. Wenn Sie es in einen Codeblock verwandeln, sparen Sie 1 weitere.
— Dennis
@ Tennis Danke! Jetzt muss ich verstehen, was {=U):Ua*~}tut ...
— 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

Die Eingabe ist eine 2D-Liste von Floats, die Ausgabe ist ein Paar: eine Liste von 0-basierten Indizes und eine Ganzzahl.

Testen Sie es auf Ideone .

— Dennis
quelle
2

Julia, 54 Bytes

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

Eingabe ist eine Matrix, Ausgabe ist ein Paar: eine Liste von 1-basierten Indizes und die maximale Anzahl von Maxima.

Probieren Sie es online aus!

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

Gibt ein Array mit zwei Elementen zurück. Die erste ist die maximale Anzahl von Maxima, die zweite ist das Array von Spalten mit null Index mit dieser Anzahl.

— Neil
quelle
1

Oktave, 47 46 Bytes

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

Dadurch wird eine anonyme Funktion erstellt, die sich automatisch zuweist ansund mit ausgeführt werden kann ans([1 2 3; 4 5 6]). Es wird ein Zellenarray mit zwei Elementen zurückgegeben, wobei das erste Element die maximale Anzahl von Maxima und das zweite der 1-basierte Index der Spalten ist, die diese Maxima enthalten.

Alle Testfälle

— Suever
quelle
1

Python 3, 142 Bytes

Der Algorithmus hier ist im Grunde, gehen Sie durch jede Zeile und erhöhen Sie die Punktzahl der Spalten, die das Maximum dieser Zeile haben. Suchen Sie dann das Maximum der Punktzahlen und suchen Sie die Spalten mit dieser Maximalpunktzahl und geben Sie sie zurück. Spalten sind 1-indiziert. Ich habe versucht, dies zu einem Lambda zu machen, aber bei der spaltenweisen Generierung der Scores waren es 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

Testfälle

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]
— Nichtlineare Frucht
quelle
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]))

Mann, das ist lang, ich habe das Gefühl, das könnte sehr vereinfacht werden. Zumindest erzeugt es die richtige Ausgabe.

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

05AB1E , 14 (oder 12) Bytes

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

Ausgaben im Format [[1-indexed columns-list], maxima].

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Wenn Elemente 0in der Spaltenliste enthalten sein dürfen, die wir ignorieren, können 2 Byte weniger sein, wenn Folgendes entfernt wird 0K:

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

ε               # 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
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.