Tanımlar

• Bir alt dizge bitişik olmayabilir, örneğin [1, 1, 1]bir alt dizidir [1, 2, 1, 2, 1].
• Eşit bir alt dizilim, her öğenin eşit olduğu bir alt dizidir.
• En uzun eşit altdizi benzersiz olması, örneğin olmayabilir [1, 1]ve [2, 2]her ikisi uzun eşit altdiziler vardır [2, 1, 1, 2].

Giriş

Aşağıdaki biçimlerden birinde boş olmayan pozitif tam sayı listesi:

• kendi dilinizde bir pozitif tamsayı dizisinin yerel uygulaması olarak
• ondalık olarak satırsonu ile ayrılmış tam sayı dizesi olarak
• tek satırda satırsonu ile ayrılmış tam sayı dizesi olarak
• diğer makul biçimler

Çıktı

Aşağıdaki biçimlerden birinde herhangi bir sırayla en uzun eşit alt dizilerin tümü:

• kendi dilinizde 2B iç içe dizi olarak (giriş bir dizi ise)
• eşit elemanların bitişik olduğu düzleştirilmiş bir dizi olarak
• herhangi bir diğer makul format

puanlama

Uzun bir şey aramamıza rağmen, kullanılan kod bayt sayısı açısından mümkün olduğunca kısa olmalıdır, çünkü bu kod golf

testcases

girişler:

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

Çıktılar:

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

Yukarıdaki çıkışlar için herhangi bir siparişin geçerli olduğunu unutmayın.

Eşit elemanlar bitişik olduğu sürece düzleştirilmiş bir dizi de geçerlidir.

Jöle , 5 bayt

ĠLÐṀị

Çevrimiçi deneyin!

Nasıl çalışır

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

⊇ᶠ=ˢlᵍh

Çevrimiçi deneyin!

açıklama

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

⊇'nin doğal düzeni ilk olarak en uzun alt dizileri üretir, bu yüzden ilk grupta ortaya çıkanlardır.

Pyth, 5 bayt

S.M/Q

Test odası

Açıklama:

Bu dolaylı olarak S.M/QZQ. .Mmaksimal işlevidir, bu nedenle .M/QZQdeğerinin /QZgirişteki öğenin oluşum sayısını saydığı, maksimum olduğu tüm öğeleri seçer . Sdaha sonra listeyi, özdeş öğeler bitişik olacak şekilde sıralar.

bash, 66 bayt

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

Bu çok daha kısa olmalı gibi görünüyor, ama nasıl olduğunu anlayamıyorum.

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

Çevrimiçi deneyin!

Leaky Nun'e 3 byte için teşekkürler !

Python 2 , 68 63 bayt

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

Çevrimiçi deneyin!

Mathematica, 42 31 25 bayt

@GregMartin'e 5 bayt ve @MartinEnder'e başka bir bayt için teşekkürler!

MaximalBy[Length]@*Gather

açıklama

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

Üst üste , 55 52 43 bayt

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

Çevrimiçi deneyin!

Girdiyi kodlayan çalışma uzunluğuna göre kodlanır, oluşumlara göre sıralar, gerçekleşme sayısının en yüksek olduğu oluşumları korur ve çalışma uzunluğu kod çözme. Meydan okuma tarafından kabul edilebilir olduğu gibi düz bir liste üzerinden çıktılar.

Aslında 23 bayt

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

Çevrimiçi deneyin veya tüm test senaryolarını çalıştırın !

Leaky Nun'e, benim için gerçekten açık olması gereken tek baytlık bir iyileştirmeyi işaret ettiği için teşekkürler.

Rahat çıktı biçiminden -3 bayt

Açıklama:

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

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 bayt

3#XMg1bX"&

Çevrimiçi deneyin!

açıklama

Oktav cevabıma benzer. Girişi [10, 20, 30, 20, 10]örnek olarak ele alalım.

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

Oktav , 47 bayt

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

Çevrimiçi deneyin!

açıklama

Sırasıyla mode(olarak elde edilen [~,b,c]=mode(...)) ikinci ve üçüncü çıktılar , girişte ( ) en çok tekrarlanan öğelerin tekrar sayısını ( b) ve bir sütun hücre dizisini ( c) verir input(0). Hücre dizisi cdaha sonra yatay olarak btekrarlanır ( repmat(c,1,b)), virgülle ayrılmış bir listeye ( {:}) dönüştürülür ve [...]görüntülenen ( disp(...)) bir sayısal matris vermek için yatay olarak ( ) birleştirilir.

05AB1E , 8 5 bayt

Düz bir liste sırayla çıktılar

.M¹Ã{

05AB1E kodlamasını kullanır . Çevrimiçi deneyin!

CJam , 22 bayt

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

Bu, girdiyi yığının tepesinden alan ve çıktıyla değiştiren anonim bir bloktur (işlev). Çıktı, bitişik elemanlara sahip düzleştirilmiş bir dizidir.

Çevrimiçi deneyin!

açıklama

Girişi [10 20 30 20 10 ]örnek olarak ele alalım.

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

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

APL (Dyalog) , 22 bayt

⎕ML←3Birçok sistemde varsayılan olanı gerektirir .

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

⎕ sayısal (değerlendirilmiş) girdi al

(… ) Tacit işlevi
 ⍋ ,  dizinin tamamından
 ⊃¨ seçilen her öğenin artan indeksleri
 ⊂

⊂⍨ keserek bölme

s←s  olarak sakla

≢¨ her biri taksitli

(... ) zımni fonksiyon
 ⌈/ maksimum (taksitli)  argümana ( taksitli)
 = eşittir
 ⊢

s/⍨ filtre s bununla

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

{… } Argümanın olduğu anonim işlev⍵

⍵[⍋⍵] sıralama (artan öğe endeksleriyle lit. endeksi)

⊂⍨ keserek bölme

s←s  olarak sakla

≢¨ her biri taksitli

(... ) zımni fonksiyon
 ⌈/ maksimum (taksitli)  argümana ( taksitli)
 = eşittir
 ⊢

s/⍨ Filtre s bununla çevrimiçi deneyin!

PHP, 69 Bayt

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

Çevrimiçi sürüm

Çıkış formatı

anahtar = değer, değer = sayım

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

PHP, 96 Bayt

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

Çevrimiçi sürüm

Çıkış formatı

1D Anahtarı = değer

2D Tuşu = her değer için giriş dizisindeki konum

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

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

)

PHP, 97 Bayt

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

JavaScript (ES6), 84 83 bayt

Sıralanmış düzleştirilmiş bir dizi döndürür.

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

Test senaryoları

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 bayt

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

Bunu 05ab1e'de yapmak istedim, ama vazgeçtim: P

Bu bir blok. Giriş ve çıkış yığındaki dizilerdir.

Çevrimiçi deneyin!

Açıklama:

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

#(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 Bayt

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

Bu da daha iyi mümkün olmalı, ama ben sıkıştım.

açıklama

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

Muhtemelen tamamen farklı bir yaklaşım çok daha kısa olurdu, bu yüzden C # mücadelesi hala açık :)

Ruby , 57 bayt

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

Çevrimiçi deneyin!