最大千里马！

11

受此问题启发，路易斯·门多（Luis Mendo）对此进行了完善。

挑战

给定一个2D整数矩阵，每一行都有一个最大值。每行的一个或多个元素将等于其相应行的最大值。您的目标是确定哪些列包含的条目数最多，这些条目等于其各自行的最大值以及在这些列中找到的按行最大值。

输入值

  • 输入将是非空Mx N矩阵（M> 0和N> 0），其格式非常适合您选择的语言。

输出量

  • 您的程序应返回包含最大行最大数（作为单独的值或列表）的每列的索引。可以使用基于0或基于1的索引（在说明中指定）。
  • 您的程序还应该返回这些列中存在的最大值（单个数字）。
  • 输出的顺序/格式是灵活的，但应在答案随附的文本中进行说明。

附加信息

  • 输入矩阵中的所有条目均为正整数。
  • 如果某行的最大值由该行中的多个元素共享，则该值的所有出现都将计入其列的总计。
  • 如果多个列包含相同的最大值，则应返回具有该最大值的所有列的列表。

一个例子

考虑输入

 7  93
69  35
77  30

第1行的最大值为93，仅出现一次，即在第2列。第2行：出现在第1列。第3行：也在第1列。所以获胜者的列为1，最大值为2。因此输出将是[1] [2]。如果我们将输入更改为

 7  93
69  35
77  77

输出为[1 2] [2]，因为两列的最大值均为2。

测试用例

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]

计分

这是代码高尔夫球，以字节为单位的最短代码获胜。Tiebreaker转到较早的答案。

排行榜

以下是用于分析所有条目的堆栈片段。

显示代码段

code-golf  number  array-manipulation 
— Suever
source
7
有趣的事实; 荷兰女王叫马克西玛（Maxima），因此从技术上讲，我们只能拥有1个马克西玛（Maxima）。
— Bassdrop Cumberwubwubwub
1
有趣的事实; 还有一个名为Maxima的开源CAS 。
— 瑕疵的

Answers:

3

果冻，9 字节

="Ṁ€SµM,Ṁ

输入是2D列表，输出是一对：从1开始的索引列表和最大数量。

在线尝试！或验证所有测试用例。

这个怎么运作

="Ṁ€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.
— 丹尼斯
source
3

J，27个字节

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

这是一个单字动词，在第二个示例中使用如下：

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

输出包含两个框，并使用基于0的索引。在这里尝试！

说明

((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.
— 兹加布
source
3

MATL，17个字节

vH3$X>G=XstX>tb=f

第一个输出是最大值的最大数量，第二个输出是出现此最大值的列（基于1的索引）。

在线尝试！

说明

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

MATL，17个字节

!tvX>!G=5#fFTT#XM

输入是2D数组，行之间用分号分隔。因此，测试用例的输入为

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

输出为：首先是最大值的最大值，然后是一个或多个列索引。

在线尝试！

说明

这使用了与Suever的答案不同的方法。

首先，计算逻辑值（true和false）的矩阵，其中true指示存在行最大值。然后，将true值的列索引提取到向量中。最终，计算出该向量的模式（最大值的最大值），以及所有频率最高的值（期望的列索引）。

!        % 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
— 路易斯·门多
source
3

Pyth，20 19 17字节

1个字节，感谢@Suever。

1个字节，感谢@Jakube。

{MC.MhZrSsxLeSdQ8

测试套件。

输出为0索引。

顺序相反。

所有输入

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

所有输出

[[2], [0]]

[[2], [0, 1]]

[[2], [3]]

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

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

[[1], [0, 3]]

[[4], [0]]

[[1], [0]]

这个怎么运作

{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.
— 漏尼姑
source
3

CJam，38 35 31字节

@FryAmTheEggMan减少了2个字节，@ quartata也提供了帮助。也感谢@Dennis删除了另外4个字节。

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

输入形式为

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

输出是一个从1开始的列索引和一个数字的数组。

在线尝试！

— 路易斯·门多
source
q~_::e>.f=:.+_:e>_@f{=U):Ua*~}p保存一些字节。将其转换为代码块将再节省1个。
— 丹尼斯
@丹尼斯谢谢！现在，我需要了解什么{=U):Ua*~}呢？
— 路易斯Mendo
2

Python 2，106字节

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

输入是2D浮点数列表，输出是一对：从0开始的索引列表和一个整数。

在Ideone上进行测试。

— 丹尼斯
source
2

朱莉娅54字节

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

输入是一个矩阵，输出是一个对：从1开始的索引列表和最大数量的最大值。

在线尝试！

— 丹尼斯
source
1

JavaScript（ES6），111个字节

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

返回由两个元素组成的数组；第一个是最大值的最大计数，第二个是具有该计数的零索引列的数组。

— 尼尔
source
1

八度，47 46字节

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

这将创建一个匿名函数，该函数自动将其自身分配给，ans并可以使用来运行ans([1 2 3; 4 5 6])。它返回一个包含两个元素的单元格数组，其中第一个元素是最大值的最大值，第二个元素是包含这些最大值的列的从1开始的索引。

所有测试用例

— Suever
source
1

Python 3，142个字节

这里的算法基本上是遍历每一行并增加具有该行最大值的列的分数。然后找到最高分，找到具有最高分的列并返回它们。列是1索引的。我尝试将其单行放入lambda中，但是逐列生成分数是153个字节。

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

测试用例

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]
— 非线性水果
source
1

Clojure，150字节

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

老兄，我觉得这可以简化很多。至少它会产生正确的输出。

[(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]]
— 尼古妮
source
1

05AB1E，14（或12）个字节

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

以格式输出[[1-indexed columns-list], maxima]。

在线尝试或验证所有测试用例。

如果允许0在我们忽略的columns-list中包含项目，则通过删除0K：可以减少2个字节：

在线尝试或验证所有测试用例。

说明：

ε               # 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)
— 凯文·克鲁伊森
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.