Tối đa tối đa!

11

Lấy cảm hứng từ câu hỏi này và được tinh chỉnh bởi Luis Mendo .

Thử thách

Cho một ma trận số nguyên 2D, mỗi hàng có giá trị tối đa. Một hoặc nhiều phần tử của mỗi hàng sẽ bằng giá trị tối đa của hàng tương ứng. Mục tiêu của bạn là xác định (các) cột nào chứa hầu hết các mục bằng với giá trị tối đa của hàng tương ứng cũng như số lượng cực đại theo hàng được tìm thấy trong các cột này.

Đầu vào

  • Đầu vào sẽ là một ma trận Mx không trống N( M> 0 và N> 0) dưới bất kỳ hình thức nào phù hợp với ngôn ngữ bạn chọn.

Đầu ra

  • Chương trình của bạn sẽ trả về chỉ mục của mỗi cột chứa số cực đại theo hàng tối đa (dưới dạng giá trị riêng hoặc danh sách). Có thể sử dụng lập chỉ mục 0 hoặc 1 dựa trên (chỉ định trong mô tả của bạn).
  • Chương trình của bạn cũng sẽ trả về số lượng cực đại đã có trong các cột này (một số duy nhất).
  • Thứ tự / định dạng của đầu ra là linh hoạt nhưng nên được giải thích trong văn bản kèm theo câu trả lời của bạn.

thông tin thêm

  • Tất cả các mục trong ma trận đầu vào sẽ là số nguyên dương.
  • Nếu giá trị tối đa của một hàng được chia sẻ bởi nhiều thành phần trong hàng đó, thì tất cả các lần xuất hiện của giá trị đó đều được tính vào tổng số cột của chúng.
  • Nếu nhiều cột chứa cùng số cực đại, bạn nên trả về danh sách tất cả các cột có số cực đại này.

Một ví dụ

Xem xét đầu vào

 7  93
69  35
77  30

Hàng 1 có maxium 93, chỉ xảy ra một lần, cụ thể là ở cột 2. Hàng 2: xảy ra ở cột 1. Hàng 3: cũng ở cột 1. Vì vậy, cột thắng là 1, với 2 cực đại. Do đó, đầu ra sẽ được [1] [2]. Nếu chúng ta thay đổi đầu vào thành

 7  93
69  35
77  77

đầu ra sẽ là [1 2] [2]vì cả hai cột có 2 cực đại.

Các trường hợp thử nghiệm

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]

Chấm điểm

Đây là code-golf , mã ngắn nhất tính bằng byte thắng. Tiebreaker đi đến câu trả lời trước đó.

Bảng xếp hạng

Dưới đây là một đoạn ngăn xếp để phân tích tất cả các mục.

Hiển thị đoạn mã

code-golf  number  array-manipulation 
— Kiện
nguồn
7
Sự thật thú vị; Nữ hoàng Hà Lan được gọi là Maxima, vì vậy về mặt kỹ thuật chúng ta chỉ có thể có 1 Maxima.
— Bassdrop Cumberwubwubwub
1
Sự thật thú vị; cũng có một CAS mã nguồn mở gọi là Maxima .
— flawr

Câu trả lời:

3

Thạch , 9 byte

="Ṁ€SµM,Ṁ

Đầu vào là danh sách 2D, đầu ra là một cặp: danh sách các chỉ số dựa trên 1 và số cực đại tối đa.

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

="Ṁ€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
nguồn
3

J, 27 byte

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

Đây là một động từ đơn âm, được sử dụng như sau trong trường hợp ví dụ thứ hai:

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

Đầu ra bao gồm hai hộp và sử dụng lập chỉ mục dựa trên 0. Hãy thử nó ở đây!

Giải trình

((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
nguồn
3

MATL, 17 byte

vH3$X>G=XstX>tb=f

Đầu ra đầu tiên là số cực đại tối đa và đầu ra thứ hai là các cột trong đó xảy ra điều này (lập chỉ mục dựa trên 1).

Hãy thử trực tuyến!

Giải trình

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
— Kiện
nguồn
3

MATL , 17 byte

!tvX>!G=5#fFTT#XM

Đầu vào là một mảng 2D, với các hàng được phân tách bằng dấu chấm phẩy. Vì vậy, các đầu vào cho các trường hợp thử nghiệm là

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

Đầu ra là: đầu tiên là lượng cực đại tối đa, sau đó là một hoặc nhiều chỉ số cột.

Hãy thử trực tuyến!

Giải trình

Điều này sử dụng một cách tiếp cận khác với câu trả lời của Suever .

Đầu tiên, một ma trận các giá trị logic ( truevà false) được tính toán, trong đó truechỉ ra sự hiện diện của một hàng tối đa. Sau đó, các chỉ số cột của các truegiá trị được trích xuất thành một vectơ. Cuối cùng, chế độ của vectơ đó được tính (số cực đại tối đa), cùng với tất cả các giá trị thường xuyên nhất (các chỉ số cột mong muốn).

!        % 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
nguồn
3

Pyth, 20 19 17 byte

1 byte nhờ @Suever .

1 byte nhờ @Jakube .

{MC.MhZrSsxLeSdQ8

Bộ thử nghiệm.

Đầu ra là 0-index.

Thứ tự được đảo ngược.

Tất cả đầu vào

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

Tất cả đầu ra

[[2], [0]]

[[2], [0, 1]]

[[2], [3]]

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

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

[[1], [0, 3]]

[[4], [0]]

[[1], [0]]

Làm thế nào nó hoạt động

{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.
— Nữ tu bị rò rỉ
nguồn
3

CJam , 38 35 31 byte

Ít hơn 2 byte nhờ @FryAmTheEggMan, với sự giúp đỡ từ @quartata. Cũng xin cảm ơn @Dennis vì đã xóa thêm 4 byte.

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

Đầu vào có dạng

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

Đầu ra là một mảng các chỉ số cột dựa trên 1 và một số.

Hãy thử trực tuyến!

— Luis Mendo
nguồn
q~_::e>.f=:.+_:e>_@f{=U):Ua*~}ptiết kiệm một vài byte. Biến nó thành một khối mã sẽ tiết kiệm thêm 1.
— Dennis
@Dennis Cảm ơn! Bây giờ tôi cần hiểu những gì {=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

Đầu vào là danh sách 2D của số float, đầu ra là một cặp: danh sách các chỉ số dựa trên 0 và một số nguyên.

Kiểm tra nó trên Ideone .

— Dennis
nguồn
2

Julia, 54 byte

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

Đầu vào là một ma trận, đầu ra là một cặp: danh sách các chỉ số dựa trên 1 và số cực đại tối đa.

Hãy thử trực tuyến!

— Dennis
nguồn
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)]

Trả về một mảng gồm hai phần tử; đầu tiên là số cực đại tối đa, thứ hai là mảng các cột được lập chỉ mục bằng không với số đó.

— Neil
nguồn
1

Octave, 47 46 byte

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

Điều này tạo ra một chức năng ẩn danh tự động gán cho chính nó ansvà có thể được chạy bằng cách sử dụng ans([1 2 3; 4 5 6]). Nó trả về một mảng ô gồm hai phần tử trong đó phần tử đầu tiên là số cực đại tối đa và phần thứ hai là chỉ mục dựa trên 1 của các cột chứa các cực đại này.

Tất cả các trường hợp thử nghiệm

— Kiện
nguồn
1

Python 3, 142 byte

Thuật toán ở đây về cơ bản, đi qua từng hàng và tăng số điểm của các cột có tối đa của hàng đó. Sau đó tìm điểm tối đa và tìm các cột có điểm tối đa đó và trả về chúng. Các cột được lập chỉ mục 1. Tôi đã thử một lớp lót này vào lambda, nhưng với việc tạo cột điểm theo cột, nó là 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

Các trường hợp thử nghiệm

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]
— Phi tuyến
nguồn
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]))

Người đàn ông đó đã lâu, tôi có cảm giác điều này có thể được đơn giản hóa rất nhiều. Ít nhất là nó tạo ra đầu ra chính xác.

[(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
nguồn
1

05AB1E , 14 (hoặc 12) byte

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

Đầu ra ở định dạng [[1-indexed columns-list], maxima].

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Nếu nó được phép có các mục 0trong danh sách cột mà chúng ta bỏ qua, nó có thể giảm 2 byte bằng cách xóa 0K:

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

ε               # 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
nguồn
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookie và Chính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.