Максимум Максима!

11

Вдохновленный этим вопросом и уточненный Луисом Мендо .

Вызов

Учитывая двумерную матрицу целых чисел, каждая строка имеет максимальное значение. Один или несколько элементов каждой строки будут равны максимальному значению их соответствующей строки. Ваша цель состоит в том, чтобы определить, какие столбцы содержат наибольшее количество записей, равных максимальному значению их соответствующей строки, а также числу построчных максимумов, найденных в этих столбцах.

вход

  • Входными данными будет непустая матрица Mx N( M> 0 и N> 0) в любой форме, подходящей для вашего языка по вашему выбору.

Выход

  • Ваша программа должна возвращать индекс каждого столбца, содержащего максимальное количество построчных максимумов (либо в виде отдельных значений, либо в виде списка). Можно использовать индексацию на основе 0 или 1 (укажите в своем описании).
  • Ваша программа также должна возвращать количество максимумов, которые присутствовали в этих столбцах (одно число).
  • Порядок / формат вывода является гибким, но его следует пояснить в тексте, сопровождающем ваш ответ.

Дополнительная информация

  • Все записи во входной матрице будут положительными целыми числами.
  • Если максимальное значение строки совместно используется несколькими элементами в этой строке, все вхождения этого значения засчитываются в общую сумму их столбцов.
  • Если несколько столбцов содержат одинаковое количество максимумов, вы должны вернуть список всех столбцов с таким количеством максимумов.

Пример

Рассмотрим вход

 7  93
69  35
77  30

Строка 1 имеет максимум 93, что происходит только один раз, а именно в столбце 2. Строка 2: в столбце 1. Строка 3: также в столбце 1. Таким образом, столбец-победитель равен 1 с двумя максимумами. Таким образом, выход будет [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 переходит к более раннему ответу.

Leaderboard

Ниже приведен фрагмент стека для анализа всех записей.

Показать фрагмент кода

code-golf  number  array-manipulation 
— Suever
источник
7
Забавный факт; Голландская королева называется Максима, поэтому технически у нас может быть только 1 Максима.
— Bassdrop Cumberwubwubwub
1
Забавный факт; есть также CAS с открытым исходным кодом под названием Maxima .
— flawr

Ответы:

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.
— Деннис
источник
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.
— Zgarb
источник
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
источник
3

MATL , 17 байт

!tvX>!G=5#fFTT#XM

Ввод - это двумерный массив, строки которого разделены точками с запятой. Таким образом, входные данные для тестовых случаев

[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
— Луис Мендо
источник
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.
— Дрянная Монахиня
источник
3

CJam , 38 35 31 байт

На 2 байта меньше благодаря @FryAmTheEggMan, также с помощью @quartata. Спасибо также @Dennis за удаление еще 4 байтов.

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

Вход имеет вид

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

Выходные данные - это массив индексов столбцов на основе 1 и числа.

Попробуйте онлайн!

— Луис Мендо
источник
q~_::e>.f=:.+_:e>_@f{=U):Ua*~}pсохраняет несколько байтов. Превращение его в кодовый блок сэкономит еще 1.
— Деннис
@ Деннис Спасибо! Теперь мне нужно понять, что {=U):Ua*~}значит ...
— Луис Мендо
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

Ввод - это двумерный список чисел с плавающей запятой, вывод - пара: список основанных на 0 индексов и целое число

Проверьте это на Ideone .

— Деннис
источник
2

Юлия, 54 байта

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

Входные данные представляют собой матрицу, выходные данные представляют собой пару: список индексов на основе 1 и максимальное количество максимумов.

Попробуйте онлайн!

— Деннис
источник
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)]

Возвращает массив из двух элементов; первый - это максимальное количество максимумов, второй - массив столбцов с нулевым индексом с таким количеством.

— Нил
источник
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
источник
1

Python 3, 142 байта

Алгоритм здесь в основном, пройти через каждую строку и увеличить количество столбцов, которые имеют максимум этой строки. Затем найдите максимальное количество баллов, найдите столбцы с максимальным баллом и верните их. Столбцы 1-индексированы. Я попытался выстроить это в лямбду, но с генерацией оценки столбец за столбцом это было 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]
— NonlinearFruit
источник
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]]
— NikoNyrh
источник
1

05AB1E , 14 (или 12) байтов

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

Выходы в формате [[1-indexed columns-list], maxima].

Попробуйте онлайн или проверьте все контрольные примеры .

Если 0в списке столбцов разрешено иметь элементы, которые мы игнорируем, можно удалить на 2 байта меньше, удалив 0K:

Попробуйте онлайн или проверьте все контрольные примеры .

Объяснение:

ε               # 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)
— Кевин Круйссен
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.