Definisi

• Sebuah urutan mungkin tidak bersebelahan, misalnya [1, 1, 1]adalah urutan dari [1, 2, 1, 2, 1].
• Sebuah urutan sama adalah urutan di mana setiap elemen adalah sama.
• Urutan sama panjang terpanjang mungkin tidak unik, misalnya [1, 1]dan [2, 2]keduanya sama panjang terpanjang dari [2, 1, 1, 2].

Memasukkan

Daftar bilangan bulat positif yang tidak kosong dalam salah satu format di bawah ini:

• sebagai implementasi asli dari array bilangan bulat positif dalam bahasa Anda
• sebagai string integer yang dipisahkan baris baru dalam desimal
• sebagai string integer yang dipisahkan baris baru di unary
• format wajar lainnya

Keluaran

Semua urutan yang paling panjang sama dalam urutan apa pun dalam salah satu format di bawah ini:

• sebagai array bersarang 2D dalam bahasa Anda (jika inputnya adalah array)
• sebagai array rata dengan elemen yang sama berdekatan
• format wajar lainnya

Mencetak gol

Meskipun kami mencari sesuatu yang panjang, kode yang digunakan harus sesingkat mungkin dalam hal jumlah byte, karena ini adalah kode-golf

Testcases

Input:

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

Output:

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

Perhatikan bahwa untuk output di atas, pesanan apa pun valid.

Array yang diratakan juga valid, selama elemen yang sama bersebelahan.

Jelly , 5 byte

ĠLÐṀị

Cobalah online!

Bagaimana itu bekerja

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

⊇ᶠ=ˢlᵍh

Cobalah online!

Penjelasan

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

⊇Tatanan alami menghasilkan urutan terpanjang pertama, sehingga mereka adalah yang berakhir di kelompok pertama.

Pyth, 5 byte

S.M/Q

Suite uji

Penjelasan:

Ini secara implisit S.M/QZQ. .Madalah fungsi maksimal, jadi .M/QZQpilih semua elemen di mana nilai /QZ, hitung jumlah kemunculan elemen dalam input, maksimal. Skemudian mengurutkan daftar sehingga elemen identik berdekatan.

bash, 66 byte

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

Sepertinya ini seharusnya lebih pendek, tapi aku tidak tahu caranya.

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

Cobalah online!

Terima kasih kepada Leaky Nun selama 3 byte!

Python 2 , 68 63 byte

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

Cobalah online!

Mathematica, 42 31 25 byte

Terima kasih @GregMartin untuk 5 byte dan @MartinEnder untuk byte lain!

MaximalBy[Length]@*Gather

Penjelasan

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

Ditumpuk , 55 52 43 byte

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

Cobalah online!

Bekerja dengan run-length encoding input, mengurutkan berdasarkan kejadian, menjaga kejadian yang jumlah kejadiannya maksimal, dan menjalankan decoding panjang. Keluaran melalui daftar datar, seperti yang dapat diterima oleh tantangan.

Sebenarnya , 23 byte

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

Cobalah online , atau jalankan semua test case !

Terima kasih kepada Leaky Nun karena menunjukkan peningkatan satu byte yang benar-benar sudah jelas bagi saya

-3 byte dari format output yang santai

Penjelasan:

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

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 byte

3#XMg1bX"&

Cobalah online!

Penjelasan

Mirip dengan jawaban Oktaf saya. Pertimbangkan input [10, 20, 30, 20, 10]sebagai contoh.

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

Oktaf , 47 byte

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

Cobalah online!

Penjelasan

Output kedua dan ketiga dari mode(diperoleh sebagai [~,b,c]=mode(...)) masing-masing memberikan jumlah pengulangan ( b) dan array sel kolom ( c) dari elemen yang paling berulang dalam input ( input(0)). Array sel ckemudian diulang secara horizontal bkali ( repmat(c,1,b)), dikonversi ke daftar yang dipisahkan koma ( {:}) dan dikontrakkan secara horizontal ( [...]) untuk memberikan matriks numerik, yang ditampilkan ( disp(...)).

05AB1E , 8 5 byte

Menampilkan daftar datar secara berurutan

.M¹Ã{

Menggunakan penyandian 05AB1E . Cobalah online!

CJam , 22 byte

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

Ini adalah blok anonim (fungsi) yang mengambil input dari atas tumpukan dan menggantikannya dengan output. Outputnya adalah array yang rata dengan elemen yang berdekatan.

Cobalah online!

Penjelasan

Pertimbangkan input [10 20 30 20 10 ]sebagai contoh.

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

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

APL (Dyalog) , 22 byte

Membutuhkan ⎕ML←3 yang default pada banyak sistem.

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

⎕ dapatkan input numerik (dievaluasi)

(... ) fungsi tacit
 ⍋ indeks item naik
 ⊃¨ setiap memilih dari
 ⊂  seluruh array

⊂⍨ partisi dengan memotong pada kenaikannya

s← simpan sebagai s

≢¨ tally masing-masing

(... ) fungsi tacit
 ⌈/ maksimum (penghitungan)
 = sama dengan
 ⊢  dengan argumen (penghitungan)

s/⍨ Filter s dengan itu

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

{... } fungsi anonim di mana argumen berada⍵

⍵[⍋⍵] sortir (lit. indeks dengan indeks item naik)

⊂⍨ partisi dengan memotong pada kenaikannya

s← simpan sebagai s

≢¨ tally masing-masing

(... ) fungsi tacit
 ⌈/ maksimum (penghitungan)
 = sama
 ⊢  dengan argumen (penghitungan)

s/⍨ Filter s dengan itu Cobalah secara online!

PHP, 69 Bytes

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

Versi Online

Format output

key = value, value = count

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 Online

Format output

1D Key = nilai

Kunci 2D = posisi dalam larik input untuk setiap nilai

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 byte

Mengembalikan array yang diratakan yang diurutkan.

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

Uji kasus

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 byte

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

Saya ingin melakukan ini pada 05ab1e, tetapi saya menyerah: P

Ini sebuah blok. Input dan output adalah array pada stack.

Cobalah online!

Penjelasan:

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

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

Tidak Disatukan:

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

Ini pasti mungkin lebih baik juga, namun saya agak macet.

Penjelasan

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

Mungkin pendekatan yang sama sekali berbeda akan jauh lebih pendek, sehingga tantangan C # masih terbuka :)

Ruby , 57 byte

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

Cobalah online!