정의

• 서브 시퀀스는 인접하지 않을 수 있으며, 예를 들어 서브 [1, 1, 1]시퀀스는이다 [1, 2, 1, 2, 1].
• 동일한 하위 시퀀스는 모든 요소가 동일한 하위 시퀀스입니다.
• 가장 긴 등가 서브 시퀀스는 고유하지 않을 수 있으며, 예를 들어 [1, 1], [2, 2]가장 긴 등가 서브 시퀀스이다 [2, 1, 1, 2].

입력

아래 형식 중 하나의 비어 있지 않은 양의 정수 목록 :

• 귀하의 언어로 양의 정수 배열의 기본 구현으로
• 줄 바꿈으로 구분 된 정수 문자열 (10 진수)
• 단항의 개행으로 구분 된 정수의 문자열로
• 다른 합리적인 형식

산출

아래 형식 중 하나의 순서로 모든 가장 긴 동일한 하위 시퀀스 :

• 사용자 언어로 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.

Brachylog , 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그런 다음 동일한 요소가 연속되도록 목록을 정렬합니다.

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

온라인으로 사용해보십시오!

3 바이트의 Leaky Nun 에 감사 합니다!

파이썬 2 , 68 63 바이트

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

온라인으로 사용해보십시오!

Mathematica, 42 31 25 바이트

5 바이트의 경우 @GregMartin과 다른 바이트의 경우 @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

온라인으로 시도 하거나 모든 테스트 사례를 실행하십시오 !

정말 분명한 1 바이트 개선을 지적한 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

파이썬 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

펄 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 키 = 각 값에 대한 입력 배열의 위치

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

자바 스크립트 (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]
                      }

클로저, 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}

온라인으로 사용해보십시오!