Définitions

• Une sous-séquence peut ne pas être contiguë, par exemple [1, 1, 1] est une sous-séquence de [1, 2, 1, 2, 1].
• Une sous-séquence égale est une sous-séquence dans laquelle chaque élément est égal.
• La sous-séquence égale la plus longue peut ne pas être unique, par exemple [1, 1]et [2, 2]sont toutes les deux les sous-séquences égales les plus longues de [2, 1, 1, 2].

Contribution

Une liste non vide d'entiers positifs dans l'un des formats ci-dessous:

• comme l'implémentation native d'un tableau d'entiers positifs dans votre langue
• comme une chaîne d'entiers séparés par des sauts de ligne en décimal
• comme une chaîne d'entiers séparés par des sauts de ligne en unaire
• tout autre format raisonnable

Production

Toutes les sous-séquences égales les plus longues dans n'importe quel ordre dans l'un des formats ci-dessous:

• comme un tableau imbriqué 2D dans votre langue (si l'entrée est un tableau)
• comme un tableau aplati avec les éléments égaux contigus
• tout autre format raisonnable

Notation

Bien que nous recherchions quelque chose de long, le code utilisé doit être aussi court que possible en termes de nombre d'octets, car il s'agit de code-golf

Cas de test

Contributions:

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

Les sorties:

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

Notez que pour les sorties ci-dessus, toute commande est valide.

Un tableau aplati est également valide, tant que les éléments égaux sont contigus.

Gelée , 5 octets

ĠLÐṀị

Essayez-le en ligne!

Comment ça fonctionne

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

⊇ᶠ=ˢlᵍh

Essayez-le en ligne!

Explication

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

⊇L'ordre naturel de Génère d'abord les sous-séquences les plus longues, donc ce sont celles qui finissent dans le premier groupe.

Pyth, 5 octets

S.M/Q

Suite de tests

Explication:

C'est implicitement S.M/QZQ. .Mest la fonction maximale, donc .M/QZQsélectionne tous les éléments où la valeur de /QZ, compter le nombre d'occurrences de l'élément dans l'entrée, est maximale. Strie ensuite la liste afin que les éléments identiques soient contigus.

bash, 66 octets

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

Cela semble être beaucoup plus court, mais je ne sais pas comment.

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

Essayez-le en ligne!

Merci à Leaky Nun pour 3 octets!

Python 2 , 68 63 octets

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

Essayez-le en ligne!

Mathematica, 42 31 25 octets

Merci @GregMartin pour 5 octets et @MartinEnder pour un autre octet!

MaximalBy[Length]@*Gather

Explication

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

Empilé , 55 52 43 octets

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

Essayez-le en ligne!

Fonctionne en encodant la longueur d'exécution en entrée, en triant par occurrences, en conservant les occurrences pour lesquelles le nombre d'occurrences est maximal et en décodant la longueur d'exécution. Sorties à travers une liste plate, comme cela est acceptable par le défi.

En fait , 23 octets

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

Essayez-le en ligne ou exécutez tous les cas de test !

Merci à Leaky Nun d'avoir souligné une amélioration d'un octet qui aurait vraiment dû être évidente pour moi

-3 octets du format de sortie détendu

Explication:

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

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 octets

3#XMg1bX"&

Essayez-le en ligne!

Explication

Similaire à ma réponse Octave. Considérez l'entrée [10, 20, 30, 20, 10]comme exemple.

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 octets

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

Essayez-le en ligne!

Explication

Les deuxième et troisième sorties de mode(obtenues en tant que [~,b,c]=mode(...)) donnent respectivement le nombre de répétitions ( b) et un tableau de cellules de colonne ( c) des éléments les plus répétés dans l'entrée ( input(0)). Le tableau de cellules cest ensuite répété horizontalement bfois ( repmat(c,1,b)), converti en une liste séparée par des virgules ( {:}) et contaténé horizontalement ( [...]) pour donner une matrice numérique, qui est affichée ( disp(...)).

05AB1E , 8 5 octets

Sort une liste plate dans l'ordre

.M¹Ã{

Utilise l' encodage 05AB1E . Essayez-le en ligne!

CJam , 22 octets

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

Il s'agit d'un bloc (fonction) anonyme qui prend l'entrée du haut de la pile et la remplace par la sortie. La sortie est un tableau aplati avec les éléments égaux contigus.

Essayez-le en ligne!

Explication

Considérez l'entrée [10 20 30 20 10 ]comme exemple.

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

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

APL (Dyalog) , 22 octets

Requiert ⎕ML←3ce qui est par défaut sur de nombreux systèmes.

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

⎕ obtenir une entrée numérique (évaluée)

(… ) Fonction tacite
 ⍋ les indices des éléments ascendants à
 ⊃¨ chaque sélection
 ⊂  le tableau entier

⊂⍨ partition en coupant à ses augmentations

s← stocker en tant que s

≢¨ compter chacun

(… ) Fonction tacite
 ⌈/ le maximum (total)
 = est égal à
 ⊢ l'argument (les décomptes)

s/⍨ filtre s avec ça

Une fonction: {s/⍨(⌈/=⊢)≢¨s←⊂⍨⍵[⍋⍵]}

{… } Fonction anonyme où l'argument est⍵

⍵[⍋⍵] tri (index lit. avec index des éléments ascendants)

⊂⍨ partition en coupant à ses augmentations

s← stocker en tant que s

≢¨ compter chacun

(… ) Fonction tacite
 ⌈/ le maximum (total)
 = est égal à
 ⊢ l'argument (les décomptes)

s/⍨ filtre est avec cette Essayez en ligne!

PHP, 69 octets

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

Version en ligne

Format de sortie

clé = valeur, valeur = compte

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

PHP, 96 octets

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

Version en ligne

Format de sortie

1D Key = valeur

Clé 2D = position dans le tableau d'entrée pour chaque valeur

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

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

)

PHP, 97 octets

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

JavaScript (ES6), 84 83 octets

Renvoie un tableau aplati trié.

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

Cas de test

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 octets

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

Je voulais le faire en 05ab1e, mais j'ai abandonné: P

Ceci est un bloc. L'entrée et la sortie sont des tableaux sur la pile.

Essayez-le en ligne!

Explication:

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

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

Non 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 octets

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

Cela doit être mieux possible aussi, mais je suis un peu coincé.

Explication

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

Une approche totalement différente serait probablement beaucoup plus courte, donc le défi C # est toujours ouvert :)

Rubis , 57 octets

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

Essayez-le en ligne!