Các định nghĩa

• Một chuỗi con có thể không liền kề nhau, ví dụ: [1, 1, 1]một chuỗi con của [1, 2, 1, 2, 1].
• Một chuỗi con bằng nhau là một chuỗi con trong đó mọi phần tử đều bằng nhau.
• Chuỗi con dài nhất bằng nhau có thể không phải là duy nhất, ví dụ [1, 1]và [2, 2]cả hai chuỗi con bằng nhau dài nhất của [2, 1, 1, 2].

Đầu vào

Danh sách các số nguyên dương không trống trong một trong các định dạng dưới đây:

• là triển khai riêng của một loạt các số nguyên dương trong ngôn ngữ của bạn
• dưới dạng một chuỗi các số nguyên được phân tách bằng dòng thập phân
• như một chuỗi các số nguyên phân tách dòng mới trong unary
• bất kỳ định dạng hợp lý khác

Đầu ra

Tất cả các chuỗi con bằng nhau dài nhất theo bất kỳ thứ tự nào theo một trong các định dạng dưới đây:

• dưới dạng một mảng lồng nhau 2D trong ngôn ngữ của bạn (nếu đầu vào là một mảng)
• như một mảng phẳng với các phần tử bằng nhau được tiếp giáp
• bất kỳ định dạng hợp lý khác

Chấm điểm

Mặc dù chúng tôi đang tìm kiếm một cái gì đó dài, nhưng mã được sử dụng phải càng ngắn càng tốt về số lượng byte, vì đây là mã golf

Tủ thử

Đầu vào:

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

Đầu ra:

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

Lưu ý rằng đối với các đầu ra ở trên, bất kỳ thứ tự là hợp lệ.

Một mảng dẹt cũng có giá trị, miễn là các phần tử bằng nhau tiếp giáp nhau.

Thạch , 5 byte

ĠLÐṀị

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Ġ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.

Brachylog , 7 byte

⊇ᶠ=ˢlᵍh

Hãy thử trực tuyến!

Giải trình

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

⊇Thứ tự tự nhiên tạo ra các chuỗi dài nhất trước tiên, vì vậy đó là những thứ kết thúc trong nhóm đầu tiên.

Bình thường, 5 byte

S.M/Q

Bộ kiểm tra

Giải trình:

Điều này là ngầm S.M/QZQ. .Mlà hàm tối đa, vì vậy .M/QZQchọn tất cả các phần tử trong đó giá trị của /QZ, đếm số lần xuất hiện của phần tử trong đầu vào, là tối đa. Ssau đó sắp xếp danh sách sao cho các phần tử giống nhau tiếp giáp nhau.

bash, 66 byte

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

Điều này có vẻ như nên ngắn hơn, nhưng tôi không thể tìm ra cách.

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
  }
'

Hãy thử trực tuyến!

Cảm ơn Leaky Nun cho 3 byte!

Python 2 , 68 63 byte

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

Hãy thử trực tuyến!

Toán học, 42 31 25 byte

Cảm ơn @GregMartin cho 5 byte và @MartinEnder cho một byte khác!

MaximalBy[Length]@*Gather

Giải trình

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}}      *)

Xếp chồng lên nhau , 55 52 43 byte

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

Hãy thử trực tuyến!

Hoạt động bằng cách mã hóa chiều dài đầu vào, sắp xếp theo các lần xuất hiện, giữ các lần xuất hiện mà số lần xuất hiện là tối đa và giải mã độ dài chạy. Đầu ra thông qua một danh sách phẳng, như được chấp nhận bởi thách thức.

Trên thực tế , 23 byte

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

Dùng thử trực tuyến hoặc chạy tất cả các trường hợp thử nghiệm !

Cảm ơn Leaky Nun vì đã chỉ ra một cải tiến một byte thực sự rõ ràng đối với tôi

-3 byte từ định dạng đầu ra thoải mái

Giải trình:

;╗⌠;╜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 byte

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

TOÁN , 10 byte

3#XMg1bX"&

Hãy thử trực tuyến!

Giải trình

Tương tự như câu trả lời Octave của tôi. Hãy xem xét đầu vào [10, 20, 30, 20, 10]là một ví dụ.

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

Octave , 47 byte

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

Hãy thử trực tuyến!

Giải trình

Các đầu ra thứ hai và thứ ba của mode(thu được dưới dạng [~,b,c]=mode(...)) tương ứng đưa ra số lần lặp lại ( b) và một mảng ô cột ( c) của các phần tử lặp lại nhiều nhất trong đầu vào ( input(0)). Sau đó, mảng ô cđược lặp lại theo chiều ngang b( repmat(c,1,b)), được chuyển đổi thành danh sách được phân tách bằng dấu phẩy ( {:}) và được đặt theo chiều ngang ( [...]) để đưa ra một ma trận số, được hiển thị ( disp(...)).

05AB1E , 8 5 byte

Xuất ra một danh sách phẳng theo thứ tự

.M¹Ã{

Sử dụng mã hóa 05AB1E . Hãy thử trực tuyến!

CJam , 22 byte

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

Đây là một khối ẩn danh (chức năng) lấy đầu vào từ đầu ngăn xếp và thay thế nó bằng đầu ra. Đầu ra là một mảng phẳng các phần tử không bằng nhau được tiếp giáp.

Hãy thử trực tuyến!

Giải trình

Hãy xem xét đầu vào [10 20 30 20 10 ]là một ví dụ.

{      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 byte

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

APL (Dyalog) , 22 byte

Yêu cầu ⎕ML←3mặc định trên nhiều hệ thống.

Chương trình: s/⍨(⌈/=⊢)≢¨s←⊂⍨(⍋⊃¨⊂)⎕

⎕ nhận đầu vào số (đánh giá)

(... ) chức năng ngầm
 ⍋ các chỉ số của mặt hàng tăng dần
 ⊃¨ mỗi pick từ
 ⊂  toàn bộ mảng

⊂⍨ phân vùng bằng cách cắt tăng

s← lưu trữ như s

≢¨ kiểm đếm từng

(... ) chức năng ngầm
 ⌈/ tối đa (tally)
 = tương đương với
 ⊢ các đối số (đếm sẽ tính toán)

s/⍨ bộ lọc s với điều đó

Chức năng: {s/⍨(⌈/=⊢)≢¨s←⊂⍨⍵[⍋⍵]}

{... } chức năng ẩn danh nơi đối số là⍵

⍵[⍋⍵] sắp xếp (chỉ mục sáng với chỉ số của các mục tăng dần)

⊂⍨ phân vùng bằng cách cắt tăng

s← lưu trữ như s

≢¨ kiểm đếm từng

(... ) chức năng ngầm
 ⌈/ tối đa (tally)
 = tương đương với
 ⊢ các đối số (đếm sẽ tính toán)

s/⍨ lọc s với đó Hãy thử trực tuyến!

PHP, 69 byte

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

Phiên bản trực tuyến

Định dạng đầu ra

khóa = giá trị, giá trị = đếm

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

PHP, 96 byte

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

Phiên bản trực tuyến

Định dạng đầu ra

Khóa 1D = giá trị

Khóa 2D = vị trí trong mảng đầu vào cho mỗi giá trị

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

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

)

PHP, 97 byte

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

JavaScript (ES6), 84 83 byte

Trả về một mảng phẳng được sắp xếp.

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

Các trường hợp thử nghiệm

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 byte

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

Tôi muốn làm điều này trong 05ab1e, nhưng tôi đã từ bỏ: P

Đây là một khối. Đầu vào và đầu ra là các mảng trên ngăn xếp.

Hãy thử trực tuyến!

Giải trình:

{                      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 byte

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

Ung dung:

(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 byte

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());}

Điều này cũng có thể tốt hơn, tuy nhiên tôi hơi bị mắc kẹt.

Giải trình

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ó lẽ một cách tiếp cận hoàn toàn khác sẽ ngắn hơn nhiều, vì vậy thử thách C # vẫn đang mở :)

Ruby , 57 byte

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

Hãy thử trực tuyến!