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

Наприклад, режим

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

спробуйте у своєму браузері !

Пітон 2 - 18

max(d,key=d.count)

Оскільки здається, що ваша відповідь python не надрукована, я думаю, що саме цього ви хочете.

Додайте 6 байт для printзвичайного.

Матлаб / Октава, 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першим аргументом «S є keyаргументом.

Математика, 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 char

Анонімна функція. Список сортування від найменш розповсюдженого, беручи перший елемент.

(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 знака коротша. З. Зменшити це майже чисте рішення, яке не використовується для гольфу.

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]

Пітон - 32

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

Не чекайте рішення з 18 символів ніде в майбутньому, щоб бути чесним.

EDIT: Я виправлений і вражений.

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 байт; для читання введення з stdin (у форматі [1 2 1 3 7]) також додайте ~12 байт.)

Цей код працює за допомогою ітерації над вхідним масивом, відніманням кожного елемента з початкового масиву та підрахунком кількості залишилися елементів. Потім він використовується як ключ для сортування вихідного масиву, і повертається перший елемент відсортованого масиву.

Демонстрація в Інтернеті

Пс. Дякую Пітеру Тейлору за те, що він вказав мені на цей виклик .

Діалог APL, 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.*потрібно імпортувати, однак у спиртному лінійці вони залишаються опущеними.

Інструменти Bash + unix, 62 байти

Очікує масив у STDIN. Формат введення не враховується, якщо числа є невід’ємними цілими числами.

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

Відредаговано: уникнув підстановку в греп-аргументі. Тепер його можна безпечно запускати в не порожніх каталогах. Завдяки маневреності.

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

Налаштування

• Збережено 3 байти, скориставшись свободою вважати, що вхід призначений змінній d

Java 8, 83 байт

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

dповинен бути a 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]

Спробуйте в Інтернеті!

Редагувати: Танс для Згарба за -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;
}