Definições

• Uma subsequência pode não ser contígua, por exemplo, [1, 1, 1]é uma subsequência de [1, 2, 1, 2, 1].
• Uma subsequência igual é uma subsequência na qual cada elemento é igual.
• A subsequência igual mais longa pode não ser única, por exemplo, [1, 1]e [2, 2]são as duas subsequências iguais mais longas de [2, 1, 1, 2].

Entrada

Uma lista não vazia de números inteiros positivos em um dos formatos abaixo:

• como a implementação nativa de uma matriz de números inteiros positivos no seu idioma
• como uma sequência de números inteiros separados por nova linha em decimal
• como uma sequência de números inteiros separados por nova linha em
• quaisquer outros formatos razoáveis

Resultado

Todas as subsequências iguais mais longas em qualquer ordem em um dos formatos abaixo:

• como uma matriz aninhada 2D no seu idioma (se a entrada for uma matriz)
• como uma matriz achatada com os elementos iguais sendo contíguos
• qualquer outro formato razoável

Pontuação

Embora estejamos procurando algo longo, o código usado deve ser o mais curto possível em termos de número de bytes, já que este é um código-golfe

Casos de teste

Entradas:

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

Saídas:

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

Observe que, para as saídas acima, qualquer pedido é válido.

Uma matriz nivelada também é válida, desde que os elementos iguais sejam contíguos.

Gelatina , 5 bytes

ĠLÐṀị

Experimente online!

Como funciona

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

Braquilog , 7 bytes

⊇ᶠ=ˢlᵍh

Experimente online!

Explicação

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

⊇A ordem natural da primeira gera as subsequências mais longas primeiro, então essas são as que terminam no primeiro grupo.

Pitão, 5 bytes

S.M/Q

Suíte de teste

Explicação:

Isso é implicitamente S.M/QZQ. .Mé a função máxima, portanto, .M/QZQseleciona todos os elementos em que o valor de /QZ, conte o número de ocorrências do elemento na entrada, é máximo. Sem seguida, classifica a lista para que elementos idênticos sejam contíguos.

bash, 66 bytes

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

Parece que deve ser bem mais curto, mas não consigo descobrir como.

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

Experimente online!

Obrigado a Leaky Nun por 3 bytes!

Python 2 , 68 63 bytes

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

Experimente online!

Mathematica, 42 31 25 bytes

Obrigado @GregMartin por 5 bytes e @MartinEnder por outro byte!

MaximalBy[Length]@*Gather

Explicação

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

Empilhados , 55 52 43 bytes

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

Experimente online!

Funciona codificando a entrada no comprimento da execução, classificando por ocorrências, mantendo ocorrências para as quais o número de ocorrências é máximo e decodificando a duração da execução. Resultados através de uma lista simples, como é aceitável pelo desafio.

Na verdade , 23 bytes

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

Experimente online ou execute todos os casos de teste !

Obrigado a Leaky Nun por apontar uma melhoria de um byte que realmente deveria ter sido óbvia para mim

-3 bytes do formato de saída relaxado

Explicação:

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

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 bytes

3#XMg1bX"&

Experimente online!

Explicação

Semelhante à minha resposta do Oitava. Considere a entrada [10, 20, 30, 20, 10]como um exemplo.

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

Oitava , 47 bytes

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

Experimente online!

Explicação

A segunda e terceira saídas de mode(obtidas como [~,b,c]=mode(...)), respectivamente, fornecem o número de repetições ( b) e uma matriz de células da coluna ( c) dos elementos mais repetidos na entrada ( input(0)). A matriz de células cé repetida horizontalmente bvezes ( repmat(c,1,b)), convertida em uma lista separada por vírgulas ( {:}) e contatada horizontalmente ( [...]) para fornecer uma matriz numérica, que é exibida ( disp(...)).

05AB1E , 8 5 bytes

Produz uma lista simples em ordem

.M¹Ã{

Usa a codificação 05AB1E . Experimente online!

CJam , 22 bytes

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

Este é um bloco (função) anônimo que pega a entrada da parte superior da pilha e a substitui pela saída. A saída é uma matriz nivelada com os elementos iguais sendo contíguos.

Experimente online!

Explicação

Considere a entrada [10 20 30 20 10 ]como um exemplo.

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

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

APL (Dyalog) , 22 bytes

Requer ⎕ML←3qual é o padrão em muitos sistemas.

Programa: s/⍨(⌈/=⊢)≢¨s←⊂⍨(⍋⊃¨⊂)⎕

⎕ obter entrada numérica (avaliada)

(… ) Função tácita
 ⍋ os índices de itens ascendentes,
 ⊃¨ cada um dos itens selecionados de
 ⊂ toda a matriz

⊂⍨ partição cortando seus aumentos

s← armazenar como s

≢¨ registro cada

(… ) Função tácita,
 ⌈/ o máximo (registro)
 = é igual
 ⊢ ao argumento (os registros)

s/⍨ filtro s com isso

Função: {s/⍨(⌈/=⊢)≢¨s←⊂⍨⍵[⍋⍵]}

{... } função anônima em que argumento é⍵

⍵[⍋⍵] ordenar (lit. índice com índices de itens ascendentes)

⊂⍨ partição cortando seus aumentos

s← armazenar como s

≢¨ registro cada

(… ) Função tácita,
 ⌈/ o máximo (registro)
 = é igual
 ⊢ ao argumento (os registros)

s/⍨ filter s with that Experimente online!

PHP, 69 bytes

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

Versão Online

Formato de saída

chave = valor, valor = contagem

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

PHP, 96 bytes

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

Versão Online

Formato de saída

Chave 1D = valor

Tecla 2D = posição na matriz de entrada para cada valor

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

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

)

PHP, 97 bytes

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

JavaScript (ES6), 84 83 bytes

Retorna uma matriz nivelada classificada.

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

Casos de teste

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 bytes

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

Eu queria fazer isso em 05ab1e, mas desisti: P

Isto é um bloco. Entrada e saída são matrizes na pilha.

Experimente online!

Explicação:

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

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

Ungolfed:

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

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

Isso deve ser possível melhor também, no entanto, eu estou meio que preso.

Explicação

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
};                                                     //...

Provavelmente, uma abordagem totalmente diferente seria muito mais curta, então o desafio do C # ainda está aberto :)

Ruby , 57 bytes

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

Experimente online!