Maxima Maksimum!

11

Terinspirasi oleh pertanyaan ini dan disempurnakan oleh Luis Mendo .

Tantangan

Diberikan matriks 2D bilangan bulat, setiap baris memiliki nilai maksimum. Satu atau lebih elemen dari setiap baris akan sama dengan nilai maksimum dari masing-masing baris. Tujuan Anda adalah untuk menentukan kolom mana yang berisi paling banyak entri yang sama dengan nilai maksimum barisnya masing-masing dan juga jumlah maksimum baris-bijaksana yang ditemukan dalam kolom ini.

Memasukkan

  • Input akan berupa matriks Mx non-kosong N( M> 0 dan N> 0) dalam bentuk apa pun yang cocok untuk bahasa pilihan Anda.

Keluaran

  • Program Anda harus mengembalikan indeks setiap kolom yang berisi jumlah maksimum baris-bijaksana maksimal (baik sebagai nilai terpisah atau daftar). Pengindeksan berbasis 0 atau 1 dapat digunakan (sebutkan dalam deskripsi Anda).
  • Program Anda juga harus mengembalikan jumlah maksimum yang ada dalam kolom ini (satu nomor).
  • Urutan / format output fleksibel tetapi harus dijelaskan dalam teks yang menyertai jawaban Anda.

informasi tambahan

  • Semua entri dalam matriks input akan menjadi bilangan bulat positif.
  • Jika nilai maksimum baris dibagi oleh beberapa elemen di baris itu, semua kemunculan nilai tersebut dihitung terhadap total kolomnya.
  • Jika beberapa kolom berisi jumlah maksimum yang sama, Anda harus mengembalikan daftar semua kolom yang memiliki jumlah maksimum ini.

Sebuah contoh

Pertimbangkan input

 7  93
69  35
77  30

Baris 1 memiliki maxium 93, yang terjadi hanya sekali, yaitu di kolom 2. Baris 2: terjadi di kolom 1. Baris 3: juga di kolom 1. Jadi kolom pemenang adalah 1, dengan 2 maxima. Dengan demikian hasilnya akan [1] [2]. Jika kami mengubah input ke

 7  93
69  35
77  77

hasilnya akan [1 2] [2], karena kedua kolom memiliki 2 maxima.

Uji Kasus

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]

Mencetak gol

Ini adalah kode-golf , kode terpendek dalam byte menang. Tiebreaker melanjutkan ke jawaban sebelumnya.

Papan peringkat

Di bawah ini adalah cuplikan tumpukan untuk menganalisis semua entri.

Tampilkan cuplikan kode

code-golf number array-manipulation Suever
sumber
7
Fakta menyenangkan; Ratu Belanda disebut Maxima, jadi secara teknis kita hanya dapat memiliki 1 Maxima.
Bassdrop Cumberwubwubwub
1
Fakta menyenangkan; ada juga CAS opensource yang disebut Maxima .
flawr

Jawaban:

3

Jelly , 9 byte

="Ṁ€SµM,Ṁ

Input adalah daftar 2D, output adalah pasangan: daftar indeks berbasis 1 dan jumlah maksimal maksimal.

Cobalah online! atau verifikasi semua kasus uji .

Bagaimana itu bekerja

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

J, 27 byte

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

Ini adalah kata kerja monadik, digunakan sebagai berikut dalam kasus contoh kedua:

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

Output terdiri dari dua kotak, dan menggunakan pengindeksan berbasis 0. Coba di sini!

Penjelasan

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

MATL, 17 byte

vH3$X>G=XstX>tb=f

Output pertama adalah jumlah maksimum maxima dan output kedua adalah kolom di mana hal ini terjadi (pengindeksan berbasis 1).

Cobalah secara Online!

Penjelasan

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

MATL , 17 byte

!tvX>!G=5#fFTT#XM

Input adalah array 2D, dengan baris yang dipisahkan oleh titik koma. Jadi input untuk kasus uji adalah

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

Output adalah: pertama jumlah maksimum maksimum, lalu satu atau lebih kolom indeks.

Cobalah online!

Penjelasan

Ini menggunakan pendekatan yang berbeda dari jawaban Suever .

Pertama, matriks nilai-nilai logis ( truedan false) dihitung, di mana truemenunjukkan keberadaan baris-maksimum. Kemudian indeks kolom truenilai diekstraksi menjadi vektor. Akhirnya, mode vektor itu dihitung (jumlah maksimum maksimum), bersama dengan semua nilai yang paling sering (indeks kolom yang diinginkan).

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

Pyth, 20 19 17 byte

1 byte terima kasih kepada @Suever .

1 byte berkat @Jakube .

{MC.MhZrSsxLeSdQ8

Suite uji.

Output diindeks 0.

Pesanan dibalik.

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

Semua keluaran

[[2], [0]]

[[2], [0, 1]]

[[2], [3]]

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

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

[[1], [0, 3]]

[[4], [0]]

[[1], [0]]

Bagaimana itu bekerja

{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.
Biarawati Bocor
sumber
3

CJam , 38 35 31 byte

2 byte lebih sedikit berkat @FryAmTheEggMan, dengan bantuan juga dari @quartata. Terima kasih juga kepada @Dennis karena menghapus 4 byte lagi.

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

Input berupa formulir

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

Output adalah array indeks kolom berbasis 1 dan angka.

Cobalah online!

Luis Mendo
sumber
q~_::e>.f=:.+_:e>_@f{=U):Ua*~}pmenghemat beberapa byte. Mengubahnya menjadi blok kode akan menghemat 1 lagi.
Dennis
@Dennis Terima kasih! Sekarang saya perlu memahami apa yang {=U):Ua*~}...
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

Input adalah daftar 2D float, output adalah pasangan: daftar indeks berbasis 0 dan integer.

Uji di Ideone .

Dennis
sumber
2

Julia, 54 byte

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

Input adalah matriks, output adalah pasangan: daftar indeks berbasis 1 dan jumlah maksimal maksimal.

Cobalah online!

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

Mengembalikan array dua elemen; yang pertama adalah jumlah maksimum maksimum, yang kedua adalah array dari kolom yang diindeks nol dengan jumlah itu.

Neil
sumber
1

Oktaf, 47 46 byte

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

Ini menciptakan fungsi anonim yang secara otomatis menempatkan dirinya ansdan dapat dijalankan menggunakan ans([1 2 3; 4 5 6]). Ini mengembalikan array sel dua elemen di mana elemen pertama adalah jumlah maksimum maksimum dan yang kedua adalah indeks berbasis 1 dari kolom yang mengandung maksimum ini.

Semua uji kasus

Suever
sumber
1

Python 3, 142 byte

Algoritma di sini pada dasarnya adalah, melalui setiap baris dan meningkatkan skor kolom yang memiliki maksimum baris itu. Kemudian cari maks skor dan temukan kolom yang memiliki skor maks dan kembalikan. Kolom adalah 1-diindeks. Saya mencoba satu-baris ini menjadi lambda, tetapi dengan menghasilkan kolom skor dengan kolom itu 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

Uji Kasus

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]
Buah Nonlinier
sumber
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]))

Man yang panjang, saya punya perasaan ini bisa disederhanakan banyak. Setidaknya itu menghasilkan output yang benar.

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

05AB1E , 14 (atau 12) byte

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

Output dalam format [[1-indexed columns-list], maxima].

Cobalah secara online atau verifikasi semua kasus uji .

Jika diizinkan memiliki item 0dalam daftar kolom yang kami abaikan, itu bisa 2 byte lebih sedikit dengan menghapus 0K:

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

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