Definitionen

• Eine Teilfolge darf nicht zusammenhängend sein, z. B. [1, 1, 1]ist eine Teilfolge von [1, 2, 1, 2, 1].
• Eine gleiche Teilfolge ist eine Teilfolge, in der jedes Element gleich ist.
• Die längste gleiche Teilfolge darf nicht eindeutig sein, z. B. [1, 1]und [2, 2]sind beide längste gleiche Teilfolgen von [2, 1, 1, 2].

Eingang

Eine nicht leere Liste positiver Ganzzahlen in einem der folgenden Formate:

• als native Implementierung einer Reihe positiver Ganzzahlen in Ihrer Sprache
• als Zeichenfolge von durch neue Zeilen getrennten Ganzzahlen in Dezimalzahl
• als eine Folge von durch Zeilenumbrüche getrennten ganzen Zahlen in unary
• andere sinnvolle Formate

Ausgabe

Alle längsten gleichen Teilfolgen in beliebiger Reihenfolge in einem der folgenden Formate:

• als 2D-verschachteltes Array in Ihrer Sprache (wenn die Eingabe ein Array ist)
• als abgeflachtes Array, wobei die gleichen Elemente aneinander grenzen
• jedes andere vernünftige Format

Wertung

Obwohl wir etwas Langes suchen, sollte der verwendete Code in Bezug auf die Anzahl der Bytes so kurz wie möglich sein, da dies Code-Golf ist

Testfälle

Eingänge:

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

Ausgänge:

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

Beachten Sie, dass für die obigen Ausgaben jede Reihenfolge gültig ist.

Ein abgeflachtes Array ist auch gültig, solange die gleichen Elemente zusammenhängend sind.

Gelee , 5 Bytes

ĠLÐṀị

Probieren Sie es online!

Wie es funktioniert

Ġ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

Probieren Sie es online!

Erläuterung

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

⊇Die natürliche Reihenfolge von erzeugt zuerst die längsten Teilsequenzen, also sind es diejenigen, die in der ersten Gruppe enden.

Pyth, 5 Bytes

S.M/Q

Testsuite

Erläuterung:

Das ist implizit S.M/QZQ. .Mist die maximale Funktion, .M/QZQwählt also alle Elemente aus, bei denen der Wert von /QZ, Anzahl der Vorkommen des Elements in der Eingabe, maximal ist. Ssortiert dann die Liste so, dass identische Elemente aneinander grenzen.

Bash, 66 Bytes

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

Das scheint viel kürzer zu sein, aber ich kann nicht herausfinden, wie.

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

Probieren Sie es online!

Danke an Leaky Nun für 3 Bytes!

Python 2 , 68 63 Bytes

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

Probieren Sie es online!

Mathematica, 42 31 25 Bytes

Danke @GregMartin für 5 Bytes und @MartinEnder für ein weiteres Byte!

MaximalBy[Length]@*Gather

Erläuterung

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

Gestapelt , 55 52 43 Bytes

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

Probieren Sie es online!

Arbeitet mit Lauflängencodierung der Eingabe, Sortieren nach Vorkommen, Beibehalten von Vorkommen, für die die Anzahl der Vorkommen maximal ist, und Lauflängendecodierung. Ausgabe über eine flache Liste, wie von der Challenge akzeptiert.

Eigentlich 23 Bytes

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

Probieren Sie es online aus oder führen Sie alle Testfälle aus !

Vielen Dank an Leaky Nun für den Hinweis auf eine Ein-Byte-Verbesserung, die mir eigentlich klar sein sollte

-3 Bytes vom entspannten Ausgabeformat

Erläuterung:

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

Probieren Sie es online!

Erläuterung

Ähnlich wie bei meiner Octave-Antwort. Betrachten Sie die Eingabe [10, 20, 30, 20, 10]als Beispiel.

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

Oktave , 47 Bytes

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

Probieren Sie es online!

Erläuterung

Die zweiten und dritten Ausgänge von mode(erhalten als [~,b,c]=mode(...)) geben jeweils die Anzahl der Wiederholungen ( b) und ein Spaltenzellenfeld ( c) der am häufigsten wiederholten Elemente in der Eingabe ( input(0)) an. Das Zellenarray cwird dann horizontal wiederholt b( repmat(c,1,b)), in eine durch Kommas getrennte Liste umgewandelt ( {:}) und horizontal verkettet ( [...]), um eine numerische Matrix zu erhalten, die angezeigt wird ( disp(...)).

05AB1E , 8 5 Bytes

Gibt eine flache Liste in der angegebenen Reihenfolge aus

.M¹Ã{

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

CJam , 22 Bytes

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

Dies ist ein anonymer Block (eine Funktion), der die Eingabe vom oberen Rand des Stapels nimmt und mit der Ausgabe ersetzt. Die Ausgabe ist ein abgeflachtes Array, bei dem gleiche Elemente aneinandergrenzen.

Probieren Sie es online!

Erläuterung

Betrachten Sie die Eingabe [10 20 30 20 10 ]als Beispiel.

{      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

Benötigt, ⎕ML←3was auf vielen Systemen Standard ist.

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

⎕ numerische (ausgewertete) Eingabe erhalten

(… ) Implizite Funktion
 ⍋ die Indizes aufsteigender Elemente, aus denen
 ⊃¨ jeder auswählen kann
 ⊂  dem gesamten Array ausgewählt werden

⊂⍨ Partition durch Schneiden an seiner Zunahme

s← speichern als s

≢¨ zählen jeden

(… ) Stillschweigende Funktion
 ⌈/ das Maximum (Tally)
 = gleich
 ⊢  dem Argument (den Tallies)

s/⍨ Filter s damit

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

{… } Anonyme Funktion, bei der das Argument ist⍵

⍵[⍋⍵] sort (lit. index mit indizes aufsteigender artikel)

⊂⍨ Partition durch Schneiden an seiner Zunahme

s← speichern als s

≢¨ zählen jeden

(… ) Stillschweigende Funktion
 ⌈/ das Maximum (Tally)
 = gleich
 ⊢  dem Argument (den Tallies)

s/⍨ Filter s mit dem Online ausprobieren!

PHP, 69 Bytes

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

Online Version

Ausgabeformat

Schlüssel = Wert, Wert = Anzahl

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

Online Version

Ausgabeformat

1D Key = Wert

2D Key = Position im Eingabearray für jeden Wert

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

Gibt ein sortiert abgeflachtes Array zurück.

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

Testfälle

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

Ich wollte das in 05ab1e machen, aber ich habe aufgegeben: P

Das ist ein Block. Eingabe und Ausgabe sind Arrays auf dem Stapel.

Probieren Sie es online!

Erläuterung:

{                      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

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

Das muss auch besser möglich sein, aber ich stecke irgendwie fest.

Erläuterung

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

Wahrscheinlich wäre ein völlig anderer Ansatz viel kürzer, sodass die C # -Herausforderung noch offen ist :)

Ruby , 57 Bytes

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

Probieren Sie es online!