Визначення

• Послідовність може бути не суміжною, наприклад [1, 1, 1], це підпорядкування [1, 2, 1, 2, 1].
• Рівна підрядність - це підряд, у якому кожен елемент є рівним.
• Найдовша однакова послідовність може бути не унікальною, наприклад, [1, 1]і [2, 2]обидві найдовші рівні підрядності [2, 1, 1, 2].

Вхідні дані

Непорожній список натуральних чисел в одному з форматів нижче:

• як власна реалізація масиву натуральних чисел у вашій мові
• як рядок цілих чисел, розділених рядками, у десяткових числах
• як рядок цілих чисел, розділених рядками, в одинакових
• будь-які інші розумні формати

Вихід

Усі найдовші рівні підручники в будь-якому порядку в одному з форматів нижче:

• як 2D вкладений масив у вашій мові (якщо вхід - це масив)
• як сплющений масив з рівними елементами, що є суміжними
• будь-який інший розумний формат

Оцінка балів

Хоча ми шукаємо щось довге, використовуваний код повинен бути якомога коротшим за кількістю байтів, оскільки це код-гольф

Тестові шафи

Вхідні дані:

[1, 2, 3]
[1, 2, 2, 1]
[1, 2, 3, 2, 1]
[1, 2, 1, 2, 3, 4, 1]

Виходи:

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

Зверніть увагу, що для результатів вище, будь-яке замовлення є дійсним.

Прирівняний масив також дійсний, якщо рівні елементи суміжні.

Желе , 5 байт

ĠLÐṀị

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

Як це працює

ĠLÐṀị  Main link. Argument: A (array)

Ġ      Group; partition the indices of A by their corresponding values.
 LÐṀ   Select all index arrays with maximal length.
    ị  Unindex; retrieve the items of A at the specified indices.

Брахілог , 7 байт

⊇ᶠ=ˢlᵍh

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

Пояснення

⊇ᶠ=ˢlᵍh
⊇ᶠ        Find all subsequences
  =ˢ      Keeping only those for which all elements are equal
    lᵍ    Group by length
      h   Take the first group

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

Pyth, 5 байт

S.M/Q

Тестовий набір

Пояснення:

Це неявно S.M/QZQ. .Mє максимальною функцією, тому .M/QZQвибирає всі елементи, де значення /QZ, підраховує кількість входів елемента на вході, є максимальним. Sпотім сортує список так, щоб однакові елементи були суміжними.

баш, 66 байт

sort|uniq -c|sort -rn|awk 'NR==1{a=$1}$1==a{for(i=a;i--;)print$2}'

Здається, це повинно бути набагато коротшим, але я не можу зрозуміти, як.

sort                  # sort the input
|uniq -c              # group runs of identical lines and prefix with count
|sort -rn             # sort by count, with largest at top
|awk '                # pipe to awk...
  NR==1{a=$1}         # on the first line, set the variable "a" to field 1
  $1==a{              # on any line, if first field is a (max count)...
    for(i=a;i--;)     # a times...
    print$2           # print the second field
  }
'

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

Дякуємо Leaky Nun за 3 байти!

Python 2 , 68 63 байт

lambda x:sorted(n for n in x if x.count(n)/max(map(x.count,x)))

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

Математика, 42 31 25 байт

Дякую @GregMartin за 5 байт та @MartinEnder за ще один байт!

MaximalBy[Length]@*Gather

Пояснення

MaximalBy[Length]@*Gather  (*                       {1, 2, 3, 2, 1}       *)
                   Gather  (* Gather same numbers:  {{1, 1}, {2, 2}, {3}} *)
                 @*        (* Function composition                        *)
MaximalBy[Length]          (* Find longest:         {{1, 1}, {2, 2}}      *)

Зіставлено , 55 52 43 байт

sorted rle toarr:[1#]map MAX@K[1#K=]YES rld

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

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

Власне , 23 байти

;╗⌠;╜ck⌡M;♂NM╗⌠N╜=⌡░♂FS

Спробуйте в Інтернеті або запустіть усі тестові справи !

Дякую Leaky Nun за те, що вказав на покращення в одному байті, яке справді мало бути очевидним для мене

-3 байти з розслабленого вихідного формату

Пояснення:

;╗⌠;╜ck⌡M;♂NM╗⌠N╜=⌡░♂FS
;╗                        save a copy of the input to register 0
  ⌠;╜ck⌡M                 for each value in the input list:
   ;                        make a copy on the stack
    ╜c                      count the occurrences in the input list (from register 0)
      k                     make a list: [value, count]
         ;♂N             make a copy, take last value of each list in the 2D list
            M╗           store the maximum count in register 0
              ⌠N╜=⌡░     filter the other copy of the list of [value, count] lists:
               N╜=         take items where the count equals the maximum count
                    ♂FS  take first items (values) and sort them

Python 2, 138 байт

lambda l:[[x[0]]*x[1] for x in next(__import__('itertools').groupby(__import__('collections').Counter(l).most_common(),lambda x:x[1]))[1]]

MATL , 10 байт

3#XMg1bX"&

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

Пояснення

Схожа на мою відповідь Октави. Розглянемо вклад [10, 20, 30, 20, 10]як приклад.

3#XM   % Three-output version of mode function. Gives the first mode, the
       % number of repetitions, and a cell array with all modes
       % STACK: 10, 2, {10; 20}
g      % Convert from cell array to matrix
       % STACK: 10, 2, [10; 20]
1      % Push 1
       % STACK: 10, 2, [10; 20], 1
b      % Bubble up in the stack
       % STACK: 10, [10; 20], 1, 2
X"     % Repeat those number of times vertically and horizontally
       % STACK: 10, [10, 10; 20, 20]
&      % Specify that implicit display will show only the top of the stack.
       % Since this is singleton cell array that contains a matrix, that 
       % matrix is directly displayed

Октава , 47 байт

[~,b,c]=mode(input(0));disp([repmat(c,1,b){:}])

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

Пояснення

Другий та третій виходи mode(отримані як [~,b,c]=mode(...)) відповідно дають кількість повторів ( b) та масив комірок стовпця ( c) найбільш повторюваних елементів у вході ( input(0)). Потім масив комірок cповторюється горизонтально bраз ( repmat(c,1,b)), перетворюється у розділений комою список ( {:}) та контактується горизонтально ( [...]), щоб отримати числову матрицю, яка відображається ( disp(...)).

05AB1E , 8 5 байт

Виводить плоский список по порядку

.M¹Ã{

Використовує кодування 05AB1E . Спробуйте в Інтернеті!

CJam , 22 байти

{$e`z~\__:e>f=.*\]ze~}

Це анонімний блок (функція), який приймає вхід з верхньої частини стека і відновлює його на виході. Вихід - це сплющений масив із рівними елементами, що є суміжними.

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

Пояснення

Розглянемо вклад [10 20 30 20 10 ]як приклад.

{      e# Begin block
       e#   STACK: [10 20 30 20 10]
  $    e#   Sort
       e#   STACK: [10 10 20 20 30]
  e`   e#   Run-length encoding
       e#   STACK: [[2 10] [2 20] [1 30]]
  z    e#   Zip
       e#   STACK: [[2 2 1] [10 20 30]]
  ~    e#   Dump array contents onto the stack
       e#   STACK: [2 2 1] [10 20 30]
  \    e#   Swap
       e#   STACK: [10 20 30] [2 2 1]
  __   e#   Duplicate twice
       e#   STACK: [10 20 30] [2 2 1] [2 2 1] [2 2 1]
  :e>  e#   Fold maximum over array. Gives the maximum of the array
       e#   STACK: [10 20 30] [2 2 1] [2 2 1] 2
  f=   e#   Map "is equal" with number (2) over the array ([2 2 1])
       e#   STACK: [10 20 30] [2 2 1] [1 1 0]
  .*   e#   Vectorized multiplication
       e#   STACK: [10 20 30] [2 2 0]
  \    e#   Swap
       e#   STACK: [2 2 0] [10 20 30]
  ]    e#   Pack into array
       e#   STACK: [[2 2 0] [10 20 30]]
  z    e#   Zip
       e#   STACK: [[2 10] [2 20] [0 30]]
  e~   e#   Run-length decoding
       e#   STACK: [10 10 20 20]
}      e# End block

Perl 5, 58 байт

sub{sort grep$x{$_}>$m,grep{$/=$x{$_}++;$m=$/if$m<$/;1}@_}

APL (Dyalog) , 22 байти

Потрібно, ⎕ML←3що для багатьох систем за замовчуванням.

Програма: s/⍨(⌈/=⊢)≢¨s←⊂⍨(⍋⊃¨⊂)⎕

⎕ отримати числовий (оцінений) вхід

(… ) Мовчазно функціонують
 ⍋ індекси висхідних елементів
 ⊃¨ кожен вибір з
 ⊂ усього масиву

⊂⍨ перегородку, розрізаючи при її збільшеннях

s← зберігати як с

≢¨ підрахунок кожного

(… ) Мовчазна функція
 ⌈/ максимум (підрахунок)
 = дорівнює
 ⊢ аргументу (таллі)

s/⍨ фільтр s з цим

Функція: {s/⍨(⌈/=⊢)≢¨s←⊂⍨⍵[⍋⍵]}

{… } Анонімна функція, де є аргумент⍵

⍵[⍋⍵] сортувати (літ. індекс з індексами зростаючих елементів)

⊂⍨ перегородку, розрізаючи при її збільшеннях

s← зберігати як с

≢¨ підрахунок кожного

(… ) Мовчазна функція
 ⌈/ максимум (підрахунок)
 = дорівнює
 ⊢ аргументу (таллі)

s/⍨ фільтр S з цим спробувати його в Інтернеті!

PHP, 69 байт

<?print_r(preg_grep("#".max($r=array_count_values($_GET))."#",$r));

Інтернет-версія

Формат виводу

ключ = значення, значення = кількість

Array
(
    [1] => 2
    [2] => 2
)

PHP, 96 байт

<?foreach($_GET as$v)$r[$m[]=count($l=preg_grep("#^{$v}$#",$_GET))][$v]=$l;print_r($r[max($m)]);

Інтернет-версія

Формат виводу

1D ключ = значення

2D Key = положення у вхідному масиві для кожного значення

Array
(
    [1] => Array
        (
            [0] => 1
            [4] => 1
        )

    [2] => Array
        (
            [1] => 2
            [3] => 2
        )

)

PHP, 97 байт

<?foreach($_GET as$v)$r[count($l=preg_grep("#^{$v}$#",$_GET))][$v]=$l;ksort($r);print_r(end($r));

JavaScript (ES6), 84 83 байт

Повертає відсортований сплющений масив.

a=>a.sort().filter((_,i)=>b[i]==Math.min(...b),b=a.map(i=>a.filter(j=>i-j).length))

Тестові справи

let f =

a=>a.sort().filter((_,i)=>b[i]==Math.min(...b),b=a.map(i=>a.filter(j=>i-j).length))

console.log(JSON.stringify(f([1, 2, 3])))
console.log(JSON.stringify(f([1, 2, 2, 1])))
console.log(JSON.stringify(f([1, 2, 3, 2, 1])))
console.log(JSON.stringify(f([1, 2, 1, 2, 3, 4, 1])))

CJam, 24 байти

{$e`_$W=0=\{0=1$=},e~\;}

Я хотів це зробити в 05ab1e, але я здався: P

Це блок. Вхід і вихід - це масиви на стеку.

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

Пояснення:

{                      e# Stack:                | [1 2 3 2 1]
 $                     e# Sort:                 | [1 1 2 2 3]
  e`                   e# RLE encode:           | [[2 1] [2 2] [1 3]]
    _$W=               e# Copy elements:        | [[2 1] [2 2] [1 3]] [2 1]
       0=              e# First element:        | [[2 1] [2 2] [1 3]] 2
         \             e# Swap:                 | 2 [[2 1] [2 2] [1 3]]
          {0=1$=},     e# Filter where x[0]==2: | 2 [[2 1] [2 2]]
                  e~   e# RLE decode:           | 2 [1 1 2 2]
                    \; e# Delete back:          | [1 1 2 2]
                      }

Clojure, 65 байт

#(let[P partition-by C count](last(P C(sort-by C(P +(sort %))))))

Безголовки:

(def f #(->> %
             (sort-by      identity)   ; sort so that identical values are one after another, same as sort
             (partition-by identity)   ; partition by identity (duh!)
             (sort-by      count)      ; sort by item count
             (partition-by count)      ; partition by item count
             last))                    ; get the last partition

C #, 145 байт

l=>{var t=Enumerable.Range(0,l.Max()+1).Select(i=>l.Count(a=>a==i));return t.Select((a,i)=>Enumerable.Repeat(i,a)).Where(d=>d.Count()==t.Max());}

Це повинно бути можливим і краще, проте я якось застряг.

Пояснення

l =>                                                   //Takes the list
{                                                      //...
    var t = Enumerable.Range(0, l.Max() + 1)           //Makes a range till the count, so that the items together with their indices are double defined (i.e. the items are 0,1,2,3... and the indices are the same)
                      .Select(i =>                     //Takes the items
                          l.Count(a => a == i));       //And replaces them with the count of themselves in the list (so the item has the index with its old value and the count as it's actual value)
    return t.Select((a, i) =>                          //Then it takes this list and selects the items together with the indices
        Enumerable.Repeat(i, a))                       //Repeats them as often as they appeared in the list
                  .Where(d => d.Count() == t.Max());   //And just keeps those which appear the maximum amount of times
};                                                     //...

Можливо, зовсім інший підхід був би набагато коротшим, тому виклик C # все ще відкритий :)

Рубін , 57 байт

->a{a.reject{|i|a.map{|j|a.count j}.max>a.count(i)}.sort}

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