Напишите фрагмент кода для расчета режима (наиболее распространенного числа) списка натуральных чисел.

Например, режим

d = [4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8]

есть 1, потому что это происходит максимум в 5 раз.

Вы можете предположить, что список хранится в такой переменной, как dи имеет уникальный режим.

например: Python, 49

max(((i,d.count(i))for i in set(d)), key=lambda x:x[1])

Это код-гольф , поэтому выигрывает самое короткое решение в байтах.

К5, 6 байт

*>#:'=

Первый ( *) из нисходящих элементов ( >) подсчета каждого ( #:') группы ( =). Шаг за шагом:

  i
4 3 1 0 6 1 6 4 4 0 3 1 7 7 3 4 1 1 2 8

  =i
4 3 1 0 6 7 2 8!(0 7 8 15
 1 10 14
 2 5 11 16 17
 3 9
 4 6
 12 13
 ,18
 ,19)

  #:'=i
4 3 1 0 6 7 2 8!4 3 5 2 2 2 1 1

  >#:'=i
1 4 3 7 6 0 8 2

  *>#:'=i
1

попробуйте это в вашем браузере !

Python 2 - 18

max(d,key=d.count)

Поскольку ваш python-ответ, кажется, не печатается, я ожидаю, что это то, что вы хотите.

Добавьте 6 байтов для printнормального.

Matlab / Octave, 7 5 байтов

Неудивительно, что есть встроенная функция для поиска режимов. Как анонимная функция:

@mode

Это возвращает наиболее часто встречающийся элемент во входном векторе со связями, идущими к меньшему значению.

Сохранено 2 байта благодаря Денису!

Пиф - 6

eo/QNQ

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

Ожидает ввода на STDIN, как [4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8]. Связи разрешаются последним появлением, потому что Python выполняет стабильные сортировки.

Сортирует список по количеству значений в списке, а затем печатает последний номер списка.

Qможет быть заменено на, dесли вы инициализировали, dчтобы содержать значение до, например,=d[4 3 1 0 6 4 4 0 1 7 7 3 4 1 1 2 8)

Python-esque псевдокод:

Q=eval(input());print(sorted(Q,key=Q.count)[-1])

Полное объяснение:

            : Q=eval(input()) (implicit)
e           : ... [-1]
 o   Q      : orderby(lambda N: ...,Q)
  /QN       : count(Q,N)

Pyth orderbyработает точно так же, как Python sortedс orderbyпервым аргументом, являющимся keyаргументом.

Mathematica, 25 байтов

Last@SortBy[d,d~Count~#&]

или

#&@@SortBy[d,-d~Count~#&]

Как и в вызове, ожидается, что список будет храниться в d.

или ... 15 байт

Конечно, Mathematica не была бы Mathematica, если бы она не имела встроенного:

#&@@Commonest@d

Commonestвозвращает список всех наиболее распространенных элементов (в случае ничьей) и #&@@является игрой в гольф First@.

Рубин, 22 байта

d.max_by{|i|d.count i}

В основном это порт моего ответа Mathematica, за исключением того, что у Ruby есть прямой, max_byпоэтому мне не нужно сначала сортировать.

R, 33 25 байт

Спасибо @Hugh за сокращение помощи:

names(sort(-table(d))[1])

Оригинал:

v=table(d);names(v[which.max(v)])

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

Любые предложения по сокращению этого приветствуются!

CJam, 11 10 байт

A{A\-,}$0=

Предполагает массив в переменной с именем A . Это в основном сортировка массива на основе вхождения каждого числа в массиве, а затем выборка последнего элемента массива.

Пример использования

[1 2 3 4 4 2 6 6 6 6]:A;A{aA\/,}$W=

Выход

6

1 байт сохранен благодаря Денису!

Попробуйте это онлайн здесь

Powershell 19

($d|group)[0].Count

(это предполагает, что массив уже включен $d)

J - 12 символов

Анонимная функция. Сортирует список от большинства к наименее распространенным, беря первый элемент.

(0{~.\:#/.~)

• 0{ Первый из
• ~. Уникальные предметы
• \: Вниз по
• #/.~ частоты

Попробуйте сами.

JavaScript (ES6) 51

Просто однострочное выражение с использованием предварительно загруженной переменной d. Сортируйте массив по частоте, затем получите первый элемент.
Противный побочный эффект, оригинальный массив изменен

d.sort((a,b)=>d.map(w=>t+=(w==b)-(w==a),t=0)&&t)[0]

Как обычно, используйте .map вместо .reduce, потому что в целом он на 1 символ короче. С .reduce это «почти чистое решение без игры в гольф».

d.sort((a,b)=>d.reduce((t,w)=>t+(w==b)-(w==a),0))[0]

Наконец, решение с использованием функции, без изменения исходного массива и без глобальных переменных (62 байта):

F=d=>[...d].sort((a,b)=>d.reduce((t,w)=>t+(w==b)-(w==a),0))[0]

Тест в консоли FireFox / FireBug

d=[4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8]
d.sort((a,b)=>x.map(w=>t+=(w==b)-(w==a),t=0)&&t)[0]

Выход 1

Массив d становится:

[1, 1, 1, 1, 1, 4, 4, 4, 4, 3, 3, 3, 0, 6, 6, 0, 7, 7, 2, 8]

Python - 32

max((x.count(i),i)for i in x)[1]

Если честно, нигде в будущем не вижу решения из 18 символов.

РЕДАКТИРОВАТЬ: Я стою исправлено и впечатлен.

JavaScript, ES6, 71 байт

Немного долго, можно много играть в гольф.

f=a=>(c=b=[],a.map(x=>b[x]?b[x]++:b[x]=1),b.map((x,i)=>c[x]=i),c.pop())

Это создает функцию, fкоторая может быть вызвана как f([1,1,1,2,1,2,3,4,1,5])и вернется 1.

Попробуйте это на вашей последней консоли Firefox.

05AB1E , 3 байта

(не конкурирует - вопрос предшествует языку)

.MJ

Объяснение:

.M  # Gets the most frequent element in the [implicit] input
  J # Converts to a string, needed as the program would output "[1]" instead of "1" without this.

Если вы хотите сохранить массив в переменной вместо использования ввода, просто поместите массив в стек в начале программы.

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

C # - 49

Не могу соревноваться, используя C #, ну да ладно:

Предполагая dэто массив

d.GroupBy(i=>i).OrderBy(a=>a.Count()).Last().Key;

Баш - 29 27 символов

sort|uniq -c|sort -nr|sed q

Используй это:

sort|uniq -c|sort -nr|sed q
4
3
1
0
6
1
6
4
4
0
3
1
7
7
3
4
1
1
2
8
[ctrl-D]
5 1

то есть «1» - это режим, и он появляется пять раз.

GolfScript, 10 байт

a{a\-,}$0=

Из этого ответа я написал в Советы по игре в гольф на GolfScript . Ожидает вход в массив с именем a, возвращает результат в стеке. (Чтобы прочитать ввод из массива в стеке, добавьте :11 байтов; чтобы прочитать ввод из стандартного ввода (в формате [1 2 1 3 7]), также добавьте ~12 байтов.)

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

Демо онлайн.

Ps. Спасибо Питеру Тейлору за то, что он указал мне на этот вызов .

Дьялог АПЛ, 12 персонажей

d[⊃⍒+/∘.=⍨d]

∘.=⍨dтак же, как d∘.=d, рефлексивное внешнее произведение =. Это создает логическую матрицу, сравнивающую каждую пару элементов в d.

+/ суммирует эту матрицу вдоль одной из осей и производит вектор.

⍒оценивает вектор, т.е. сортирует его по индексам. (Как показывают глифы, ⍒оценки в порядке убывания и ⍋будут оцениваться в порядке возрастания.)

⊃берет первый индекс из оценки - индекс самого большого элемента d.

d[...] возвращает этот элемент.

Perl 6 , 21 байт

.Bag.invert.max.value

Пример:

$_ = < 4 3 1 0 6 1 6 4 4 0 3 1 7 7 3 4 1 1 2 8 >».Int;

say .Bag.invert.max.value; # implicitly calls $_.Bag…

Если есть галстук, он напечатает больше из тех, которые связали.

.BagМетод на список или массив создает хэш квантора , который связывает общее количество, сколько раз данное значение было видно с этим значением.

bag(4(4), 3(3), 1(5), 0(2), 6(2), 7(2), 2, 8)

.invertМетод создает список пар в мешке с ключом и значением выгружена. (Причина, по которой мы это называем, заключается в следующем методе, который делает то, что мы хотим)

4 => 4,  3 => 3,  5 => 1,  2 => 0,  2 => 6,  2 => 7,  1 => 2,  1 => 8

.maxМетод на список пара возвращает наибольший пар сравнения ключей первые и в случае равенства сравнения значений.
(Это потому, что именно так multi infix:<cmp>(Pair:D \a, Pair:D \b)определяется, что больше)

5 => 1

.valueМетод возвращает значение из пары. (Это был бы ключ, за которым мы следовали, если бы не .invertзвонок ранее)

1

Если вы хотите вернуть все значения, которые связаны в случае связи:

say @list.Bag.classify(*.value).max.value».key

.classifyМетод возвращает список пар , где ключи от вызова лямбда Whatever  *.valueс каждой из пар.

1 => [2 => 1, 8 => 1],
2 => [0 => 2, 6 => 2, 7 => 2],
3 => [3 => 3],
4 => [4 => 4],
5 => [1 => 5]

Затем мы звоним, .maxчтобы получить самую большую пару.

"5" => [1 => 5]

Звонок, чтобы .valueполучить нам оригинальные пары из сумки (только один в этом случае)

1 => 5

Затем мы используем метод >>.keyдля вызова .keyкаждой пары в списке, чтобы мы получили список значений, которые были замечены чаще всего.

1

Java 8: 184 байта

Stream.of(A).collect(Collectors.groupingBy(i -> i, Collectors.counting())).entrySet().stream().sorted(Map.Entry.comparingByValue(Comparator.reverseOrder())).findFirst().get().getKey();

Вход A должен быть типа Integer[]. Обратите внимание java.util.*и java.util.stream.*необходимо импортировать, однако в духе oneliner они не учтены.

Инструменты Bash + Unix, 62 байта

Ожидает массив в STDIN. Формат ввода не считается, если числа являются неотрицательными целыми числами.

grep -o [0-9]\*|sort|uniq -c|sort -n|awk 'END{print $2}'

Отредактировано: экранированный символ в аргументе grep. Теперь его можно безопасно запускать в непустых каталогах. Благодаря манатворке.

Perl, 27 байт

$Q[$a{$_}++]=$_ for@F;pop@Q

Возвращает последнее наиболее распространенное значение в случае связи.

PHP, 53 50 байт

<?=array_flip($c=array_count_values($d))[max($c)];

Запустите так:

echo '<?php $d=$argv;?><?=array_flip($c=array_count_values($d))[max($c)]; echo"\n";' | php -- 4 3 1 0 6 1 6 4 4 0 3 1 7 7 3 4 1 1 2 8

Tweaks

• Сохраненные 3 байта, используя свободу предполагать, что вход назначен переменной d

Java 8, 83 байта

d.stream().max((x,y)->Collections.frequency(d,x)-Collections.frequency(d,y)).get();

dдолжно быть Collection<Integer>.

Если Collectionsможно статически импортировать:
59 байт

d.stream().max((x,y)->frequency(d,x)-frequency(d,y)).get();

Haskell 78

import Data.List
import Data.Ord
g=head.maximumBy(comparing length).group.sort

Если импорт игнорируется, это 45 .

Haskell , 42 39 байт

f s=snd$maximum[([1|y<-s,y==x],x)|x<-s]

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

Изменить: чем Zgarb для -3 байта

Брахилог , 5 байт

ọtᵒth

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

Это на самом деле не фрагмент, но я не уверен, что будет ...

         The output is
    h    the first element of
   t     the last element of
ọ        a list of [value, number of occurrences] pairs corresponding to
         the input,
  ᵒ      sorted ascending by
 t       their last elements (the numbers of occurrences).

Clojure, 32 байта

#(apply max-key(frequencies %)%)

(frequencies %)возвращает хэш-карту, которую можно использовать как функцию. Учитывая ключ, он возвращает соответствующее значение :)

Равная длина:

#(last(sort-by(frequencies %)%))

Скала, 32

d.groupBy(a=>a).maxBy(_._2.size)

C ++ 119

int *a=std::max_element(x,x+n);int z=0,b=0,c=0;for(int i=0;i<=*a;i++){c=std::count(x,x+n,i);if(c>b){b=c;z=i;}}return z;

Полный код и тест:

#include <iostream>
#include <algorithm>
#include <vector>

int m(int *x,int n)
{
int *a=std::max_element(x,x+n);int z=0,b=0,c=0;for(int i=0;i<=*a;i++){c=std::count(x,x+n,i);if(c>b){b=c;z=i;}}return z;
}

int main()
{
int d[] = {4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8};
std::cout<<m(d,20);
return 0;
}