Maksymalne maksima!

11

Zainspirowany tym pytaniem i dopracowany przez Luisa Mendo .

Wyzwanie

Biorąc pod uwagę macierz 2D liczb całkowitych, każdy wiersz ma maksymalną wartość. Jeden lub więcej elementów każdego rzędu będzie równe maksymalnej wartości ich odpowiedniego rzędu. Twoim celem jest określenie, które kolumny zawierają najwięcej wpisów, które są równe maksymalnej wartości odpowiedniego wiersza, a także liczbie maksymalnych wierszy znalezionych w tych kolumnach.

Wejście

  • Dane wejściowe będą niepustą macierzą Mx N( M> 0 i N> 0) w dowolnej formie, która jest dobrze dopasowana do wybranego języka.

Wynik

  • Twój program powinien zwrócić indeks każdej kolumny zawierający maksymalną liczbę maksymalnych wierszy (jako osobne wartości lub listę). Można zastosować indeksowanie 0 lub 1 (określ w opisie).
  • Twój program powinien również zwrócić liczbę maksimów, które były obecne w tych kolumnach (pojedyncza liczba).
  • Kolejność / format danych wyjściowych jest elastyczny, ale należy to wyjaśnić w tekście towarzyszącym odpowiedzi.

Dodatkowe informacje

  • Wszystkie wpisy w macierzy wejściowej będą dodatnimi liczbami całkowitymi.
  • Jeśli maksymalna wartość wiersza jest współdzielona przez wiele elementów w tym wierszu, wszystkie wystąpienia tej wartości liczą się do sumy ich kolumn.
  • Jeśli wiele kolumn zawiera tę samą liczbę maksimów, powinieneś zwrócić listę wszystkich kolumn, które miały tę liczbę maksimów.

Przykład

Rozważ wejście

 7  93
69  35
77  30

Wiersz 1 ma maksimum 93, co występuje tylko raz, a mianowicie w kolumnie 2. Wiersz 2: występuje w kolumnie 1. Wiersz 3: także w kolumnie 1. Zatem kolumna zwycięzcy to 1, z 2 maksimami. Tak więc wynik będzie [1] [2]. Jeśli zmienimy wejście na

 7  93
69  35
77  77

wyjście będzie [1 2] [2], ponieważ obie kolumny mają 2 maksima.

Przypadki testowe

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]

Punktacja

To jest code-golf , wygrywa najkrótszy kod w bajtach. Tiebreaker przechodzi do wcześniejszej odpowiedzi.

Tabela liderów

Poniżej znajduje się fragment stosu do analizy wszystkich wpisów.

Pokaż fragment kodu

code-golf  number  array-manipulation 
— Suever
źródło
7
Śmieszny fakt; holenderska królowa nazywa się Maxima, więc technicznie możemy mieć tylko 1 Maxima.
— Bassdrop Cumberwubwubwub
1
Śmieszny fakt; istnieje również CAS typu open source o nazwie Maxima .
— flawr

Odpowiedzi:

3

Galaretka , 9 bajtów

="Ṁ€SµM,Ṁ

Dane wejściowe to lista 2D, dane wyjściowe to para: lista wskaźników opartych na 1 i maksymalna liczba maksimów.

Wypróbuj online! lub zweryfikuj wszystkie przypadki testowe .

Jak to działa

="Ṁ€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
źródło
3

J, 27 bajtów

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

Jest to czasownik monadyczny, używany w następujący sposób w przypadku drugiego przykładu:

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

Dane wyjściowe składają się z dwóch pól i wykorzystują indeksowanie oparte na 0. Wypróbuj tutaj!

Wyjaśnienie

((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
źródło
3

MATL, 17 bajtów

vH3$X>G=XstX>tb=f

Pierwsze wyjście to maksymalna liczba maksimów, a drugie wyjście to kolumny, w których to wystąpiło (indeksowanie 1).

Wypróbuj online!

Wyjaśnienie

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
źródło
3

MATL , 17 bajtów

!tvX>!G=5#fFTT#XM

Dane wejściowe to tablica 2D z wierszami oddzielonymi średnikami. Tak są dane wejściowe dla przypadków testowych

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

Dane wyjściowe to: najpierw maksymalna ilość maksimów, a następnie jeden lub więcej indeksów kolumn.

Wypróbuj online!

Wyjaśnienie

To używa innego podejścia niż odpowiedź Suever .

Najpierw obliczana jest macierz wartości logicznych ( truei false), gdzie truewskazuje na obecność wartości maksymalnej rzędu. Następnie indeksy truewartości są wyodrębniane do wektora. Na koniec obliczany jest tryb tego wektora (maksymalna liczba maksimów) wraz ze wszystkimi wartościami, które są najczęstsze (pożądane wskaźniki kolumnowe).

!        % 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
źródło
3

Pyth, 20 19 17 bajtów

1 bajt dzięki @Suever .

1 bajt dzięki @Jakube .

{MC.MhZrSsxLeSdQ8

Zestaw testowy.

Wyjście jest indeksowane na 0.

Zamówienie jest odwrócone.

Wszystkie dane wejściowe

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

Wszystkie wyjścia

[[2], [0]]

[[2], [0, 1]]

[[2], [3]]

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

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

[[1], [0, 3]]

[[4], [0]]

[[1], [0]]

Jak to działa

{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
źródło
3

CJam , 38 35 31 bajtów

2 bajty mniej dzięki @FryAmTheEggMan, z pomocą również z @quartata. Dziękujemy również @Dennis za usunięcie 4 kolejnych bajtów.

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

Dane wejściowe mają formę

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

Dane wyjściowe to tablica indeksów kolumn na podstawie 1 i liczby.

Wypróbuj online!

— Luis Mendo
źródło
q~_::e>.f=:.+_:e>_@f{=U):Ua*~}poszczędza kilka bajtów. Przekształcenie go w blok kodu pozwoliłoby zaoszczędzić jeszcze 1.
— Dennis
@Dennis Thanks! Teraz muszę zrozumieć, co {=U):Ua*~}robi ...
— Luis Mendo
2

Python 2, 106 bajtów

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

Dane wejściowe to dwuwymiarowa lista liczb zmiennoprzecinkowych, dane wyjściowe to para: lista indeksów opartych na 0 i liczba całkowita.

Przetestuj na Ideone .

— Dennis
źródło
2

Julia, 54 bajty

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

Dane wejściowe to macierz, dane wyjściowe to para: lista wskaźników opartych na 1 i maksymalna liczba maksimów.

Wypróbuj online!

— Dennis
źródło
1

JavaScript (ES6), 111 bajtów

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

Zwraca tablicę dwóch elementów; pierwszy to maksymalna liczba maksimów, drugi to tablica kolumn o indeksie zerowym z tą liczbą.

— Neil
źródło
1

Oktawa, 47 46 bajtów

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

Tworzy to anonimową funkcję, która automatycznie przypisuje się ansi może być uruchamiana za pomocą ans([1 2 3; 4 5 6]). Zwraca dwuelementową tablicę komórek, w której pierwszy element to maksymalna liczba maksimów, a drugi to indeks oparty na 1 kolumnach zawierających te maksima.

Wszystkie przypadki testowe

— Suever
źródło
1

Python 3, 142 bajty

Algorytm polega na tym, aby przejść przez każdy wiersz i zwiększyć wynik w kolumnach, które mają maksimum tego wiersza. Następnie znajdź maksimum wyników i znajdź kolumny, które mają ten maksymalny wynik, i zwróć je. Kolumny są indeksowane 1. Próbowałem wyrównać to do lambda, ale przy generowaniu wyników kolumna po kolumnie było to 153 bajty.

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

Przypadki testowe

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]
— Nieliniowe Owoce
źródło
1

Clojure, 150 bajtów

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

Człowieku, który jest długi, mam wrażenie, że można to bardzo uprościć. Przynajmniej produkuje poprawny wynik.

[(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
źródło
1

05AB1E , 14 (lub 12) bajtów

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

Dane wyjściowe w formacie [[1-indexed columns-list], maxima].

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Jeśli dozwolone jest umieszczanie elementów 0na liście kolumn, które ignorujemy, może to być 2 bajty mniej przez usunięcie 0K:

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

ε               # 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
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.