Definiciones

• Una subsecuencia puede no ser contigua, por ejemplo, [1, 1, 1]es una subsecuencia de [1, 2, 1, 2, 1].
• Una subsecuencia igual es una subsecuencia en la que cada elemento es igual.
• La subsecuencia igual más larga puede no ser única, por ejemplo, [1, 1]y [2, 2]son las subsecuencias iguales más largas de [2, 1, 1, 2].

Entrada

Una lista no vacía de enteros positivos en uno de los siguientes formatos:

• como la implementación nativa de una serie de enteros positivos en su idioma
• como una cadena de enteros separados por nueva línea en decimal
• como una cadena de enteros separados por nueva línea en unario
• cualquier otro formato razonable

Salida

Todas las subsecuencias iguales más largas en cualquier orden en uno de los formatos a continuación:

• como una matriz 2D anidada en su idioma (si la entrada es una matriz)
• como una matriz aplanada con los elementos iguales contiguos
• cualquier otro formato razonable

Puntuación

Aunque estamos buscando algo largo, el código utilizado debe ser lo más corto posible en términos de número de bytes, ya que este es el código golf

Casos de prueba

Entradas:

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

Salidas:

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

Tenga en cuenta que para las salidas anteriores, cualquier orden es válida.

Una matriz aplanada también es válida, siempre que los elementos iguales sean contiguos.

Jalea , 5 bytes

ĠLÐṀị

Pruébalo en línea!

Cómo 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.

Brachylog , 7 bytes

⊇ᶠ=ˢlᵍh

Pruébalo en línea!

Explicación

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

⊇El orden natural genera primero las subsecuencias más largas, por lo que esas son las que terminan en el primer grupo.

Pyth, 5 bytes

S.M/Q

Banco de pruebas

Explicación:

Esto es implícitamente S.M/QZQ. .Mes la función máxima, por lo que .M/QZQselecciona todos los elementos donde el valor de /QZ, cuenta el número de ocurrencias del elemento en la entrada, es máximo. Sluego ordena la lista para que elementos idénticos sean contiguos.

bash, 66 bytes

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

Parece que debería ser mucho más corto, pero no puedo entender cómo.

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

Pruébalo en línea!

¡Gracias 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)))

Pruébalo en línea!

Mathematica, 42 31 25 bytes

¡Gracias @GregMartin por 5 bytes y @MartinEnder por otro byte!

MaximalBy[Length]@*Gather

Explicación

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

Apilado , 55 52 43 bytes

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

Pruébalo en línea!

Funciona mediante la codificación de longitud de ejecución de la entrada, la clasificación por ocurrencias, manteniendo las ocurrencias para las cuales el número de ocurrencias es máximo y la decodificación de longitud de ejecución. Salidas a través de una lista plana, como lo acepta el desafío.

En realidad , 23 bytes

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

¡Pruébelo en línea o ejecute todos los casos de prueba !

Gracias a Leaky Nun por señalar una mejora de un byte que realmente debería haber sido obvia para mí.

-3 bytes del formato de salida relajado

Explicación:

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

Pruébalo en línea!

Explicación

Similar a mi respuesta Octave. Considere la entrada [10, 20, 30, 20, 10]como un ejemplo.

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

Octava , 47 bytes

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

Pruébalo en línea!

Explicación

Las salidas segunda y tercera de mode(obtenidas como [~,b,c]=mode(...)) respectivamente dan el número de repeticiones ( b) y una matriz de celdas de columna ( c) de los elementos más repetidos en la entrada ( input(0)). La matriz de celdas cse repite horizontalmente bveces ( repmat(c,1,b)), se convierte en una lista separada por comas ( {:}) y se contacta horizontalmente ( [...]) para dar una matriz numérica, que se muestra ( disp(...)).

05AB1E , 8 5 bytes

Emite una lista plana en orden

.M¹Ã{

Utiliza la codificación 05AB1E . Pruébalo en línea!

CJam , 22 bytes

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

Este es un bloque anónimo (función) que toma la entrada desde la parte superior de la pila y la repara con la salida. La salida es una matriz aplanada con elementos iguales que son contiguos.

Pruébalo en línea!

Explicación

Considere la entrada [10 20 30 20 10 ]como un ejemplo.

{      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

Requiere ⎕ML←3 cuál es el predeterminado en muchos sistemas.

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

⎕ obtener entrada numérica (evaluada)

(... ) función tácita
 ⍋ los índices de elementos ascendentes de
 ⊃¨ cada selección
 ⊂  la matriz completa

⊂⍨ partición cortando en sus aumentos

s← almacenar como s

≢¨ cuenta cada uno

(… ) Función tácita
 ⌈/ el máximo (conteo)
 = es igual
 ⊢  al argumento (los recuentos)

s/⍨ filtrar s con eso

Función: {s/⍨(⌈/=⊢)≢¨s←⊂⍨⍵[⍋⍵]}

{... } función anónima donde el argumento es⍵

⍵[⍋⍵] sort (índice iluminado con índices de elementos ascendentes)

⊂⍨ partición cortando en sus aumentos

s← almacenar como s

≢¨ cuenta cada uno

(... ) función tácita
 ⌈/ el máximo (conteo)
 = es igual
 ⊢  al argumento (los recuentos)

s/⍨ filtre s con eso ¡ Pruébelo en línea!

PHP, 69 bytes

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

Versión en línea

Formato de salida

clave = valor, valor = contar

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

Versión en línea

Formato de salida

Clave 1D = valor

Clave 2D = posición en la 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

Devuelve una matriz aplanada ordenada.

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

Casos de prueba

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~\;}

Quería hacer esto en 05ab1e, pero me di por vencido: P

Esto es un bloque La entrada y la salida son matrices en la pila.

Pruébalo en línea!

Explicación:

{                      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 %))))))

Sin golf:

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

Esto debe ser posible también mejor, sin embargo, estoy un poco atascado.

Explicación

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

Probablemente un enfoque totalmente diferente sería mucho más corto, por lo que el desafío C # todavía está abierto :)

Ruby , 57 bytes

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

Pruébalo en línea!