Thử thách:

Cho một số nguyên dương, xuất ra chuỗi con số đơn dài nhất xảy ra ít nhất hai lần và AND có ranh giới của một chữ số khác (hoặc bắt đầu / kết thúc của số nguyên).

Một ví dụ:

Đầu vào: 7888885466662716666
Chuỗi con dài nhất của một chữ số sẽ là 88888( 7[88888]5466662716666) với độ dài 5. Tuy nhiên, chuỗi con này chỉ xảy ra một lần trong số nguyên.
Thay vào đó, kết quả cho đầu vào 7888885466662716666phải là 6666( 78888854[6666]271[6666]), vì nó xảy ra (ít nhất) hai lần.

Quy tắc thử thách:

• Độ dài của các chuỗi con được ưu tiên hơn số lần xảy ra. (Tức là với đầu vào 8888858888866656665666, chúng ta xuất ra 88888( [88888]5[88888]66656665666; chiều dài 5, xảy ra hai lần) và không 666( 88888588888[666]5[666]5[666]; chiều dài 3, xảy ra ba lần).
• Nếu độ dài của nhiều chuỗi bằng nhau, chúng ta xuất ra một chuỗi có số lần xuất hiện lớn nhất. Tức là với đầu vào 3331113331119111, chúng ta đầu ra 111( 333[111]333[111]9[111]; chiều dài 3, xảy ra ba lần), và không 333( [333]111[333]1119111; chiều dài 3 là tốt, nhưng xảy ra hai lần)
• Nếu số lần xuất hiện và độ dài của nhiều chuỗi bằng nhau, bạn có thể xuất một trong hai hoặc tất cả (theo bất kỳ thứ tự nào). Tức là với đầu vào 777333777333, các đầu ra có thể là : 777; 333; [777, 333]; hoặc [333, 777].
• Phần tiếp theo phải có ranh giới của các chữ số khác (hoặc bắt đầu / kết thúc số nguyên). Tức là với đầu vào 122222233433kết quả là 33( 1222222[33]4[33]; chiều dài 2, xảy ra hai lần) và không 222( 1[222][222]33433, độ dài 3, xảy ra hai lần với cả hai không hợp lệ).
  • Điều này áp dụng cho tất cả các số được tính vào bộ đếm xảy ra. Tức là với đầu vào 811774177781382kết quả là 8( [8]117741777[8]13[8]2; chiều dài 1, xảy ra ba lần) và không 77( 811[77]41[77]781382/ 811[77]417[77]81382; chiều dài 2, xảy ra hai lần với một không hợp lệ) cũng không 1( 8[1][1]774[1]7778[1]382; độ dài 1, xảy ra bốn lần với hai không hợp lệ).
• Bạn có thể giả sử đầu vào sẽ không chứa bất kỳ chữ số nào 0(nó sẽ khớp [1-9]+). (Điều này là để tránh phải xử lý các trường hợp thử nghiệm như thế 10002000nên xuất ra 000, trong đó hầu hết các ngôn ngữ sẽ xuất 0theo mặc định.)
• Bạn có thể giả sử đầu vào sẽ luôn chứa ít nhất một đầu ra hợp lệ.
• I / O đều linh hoạt. Có thể là một danh sách / mảng / luồng chữ số / byte / ký tự hoặc dưới dạng chuỗi thay vì một số nguyên.

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Các quy tắc chuẩn áp dụng cho câu trả lời của bạn, vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, các chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn.
• Ngoài ra, thêm một lời giải thích cho câu trả lời của bạn rất được khuyến khích.

Các trường hợp thử nghiệm:

Input:  7888885466662716666 / [7,8,8,8,8,8,5,4,6,6,6,6,2,7,1,6,6,6,6]
Output: 6666                / [6,6,6,6]

Input:  3331113331119111 / [3,3,3,1,1,1,3,3,3,1,1,1,9,1,1,1]
Output: 111              / [1,1,1]

Input:            777333777333                   / [7,7,7,3,3,3,7,7,7,3,3,3]
Possible outputs: 777; 333; [777,333]; [333;777] / [7,7,7]; [3,3,3]; [[7,7,7],[3,3,3]]; [[3,3,3],[7,7,7]]

Input:  122222233433 / [1,2,2,2,2,2,2,3,3,4,3,3]
Output: 33           / [3,3]

Input:  811774177781382 / [8,1,1,7,7,4,1,7,7,7,8,1,3,8,2] 
Output: 8               / [8]

Input:  555153333551 / [5,5,5,1,5,3,3,3,3,5,5,1] 
Output: 1            / [1]

Input:            12321              / [1,2,3,2,1]
Possible outputs: 1; 2; [1,2]; [2,1] / [1]; [2]; [[1],[2]]; [[2],[1]]

Input:  944949949494999494 / [9,4,4,9,4,9,9,4,9,4,9,4,9,9,9,4,9,4]
Output: 4                  / [4]

Input:  8888858888866656665666 / [8,8,8,8,8,5,8,8,8,8,8,6,6,6,5,6,6,6,5,6,6,6]
Output: 88888                  / [8,8,8,8,8]

Input:  1112221112221111               / [1,1,1,2,2,2,1,1,1,2,2,2,1,1,1,1]
Output: 111; 222; [111,222]; [222,111] / [1,1,1]; [2,2,2]; [[1,1,1],[2,2,2]]; [[2,2,2],[1,1,1]]

Input:  911133111339339339339339 / [9,1,1,1,3,3,1,1,1,3,3,9,3,3,9,3,3,9,3,3,9,3,3,9]
Output: 111                      / [1,1,1]

05AB1E , 14 byte

γТ1›ÏD€gZQÏ.M

Hãy thử trực tuyến!

Giải trình

γ                # group consecutive equal elements
 Т              # count the occurrence of each group among the list of groups
   1›Ï           # keep only groups with a count greater than 1
      D€gZQÏ     # keep only those with a length equal to the greatest length
            .M   # get the most common item

Thạch , 12 byte

Œgœ-Q$LÐṀÆṃ'

Hãy thử trực tuyến!

Phiên bản trước - 14 byte

ŒgŒQ¬TịƲLÐṀÆṃ'

Hãy thử trực tuyến!

Làm thế nào nó hoạt động?

Œgœ-Q$LÐṀÆṃ' – Full program. Receives a list of digits as input.
Œg           – Group equal adjacent values.
  œ-Q$       – Multiset difference with itself deduplicate.
      LÐṀ    – Keep those that are maximal by length.
         Æṃ' – Mode. Returns the most common element(s).
-------------------------------------------------------------------------
ŒgŒQ¬TịƲLÐṀÆṃ' – Full program. Receives a list of digits as input.
Œg             – Group equal adjacent values.
  ŒQ           – Distinct sieve. Replace the first occurrences of each value by 1.
                 and the rest by 0. [1,2,3,2,3,2,5]ŒQ -> [1,1,1,0,0,0,1]       
    ¬T         – Negate and find the truthy indices.
      ịƲ       – Then index in the initial list of groups.
               – This discards the groups that only occur once.
        LÐṀ    – Find all those which are maximal by length.
           Æṃ' – And take the mode.

JavaScript (ES6), 79 73 68 byte

Đưa đầu vào dưới dạng một chuỗi. Trả về một số nguyên.

s=>[...s,r=q=0].map(o=d=>q=s^d?o[!o[q]|r[q.length]?q:r=q]=s=d:q+d)|r

Hãy thử trực tuyến!

Đã bình luận

s =>                      // s = input string, also used as the current digit
  [ ...s,                 // split s into a list of digit characters
    r =                   // r is the final result
    q =                   // q is the current digit sequence
    0                     // append a final dummy entry to force the processing of the last
  ]                       // sequence
  .map(o =                // o is an object used to keep track of encountered sequences
       d =>               // for each digit d in the array defined above:
    q =                   //   update q:
      s ^ d ?             //     if d is not equal to the current digit:
        o[                //       this statement will ultimately update o[q]
          !o[q] |         //         if q has not been previously seen
          r[q.length] ?   //         or the best result is longer than q:
            q             //           leave r unchanged
          :               //         else:
            r = q         //           set r to q
        ] = s = d         //       reset q to d, set the current digit to d
                          //       and mark q as encountered by setting o[q]
      :                   //     else:
        q + d             //       append d to q
  ) | r                   // end of map(); return r, coerced to an integer

Võng mạc , 56 byte

L`(.)\1*
O`
L$m`^(.+)(¶\1)+$
$#2;$1
N`
.+;

N$`
$.&
-1G`

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải trình:

L`(.)\1*

Liệt kê tất cả các dãy số lặp lại tối đa.

O`

Sắp xếp danh sách theo thứ tự.

L$m`^(.+)(¶\1)+$
$#2;$1

Liệt kê tất cả các chuỗi con với "số đếm" của chúng.

N`

Sắp xếp theo thứ tự tăng dần của số đếm.

.+;

Xóa số đếm.

N$`
$.&

Sắp xếp theo thứ tự tăng dần của chiều dài. (Trường hợp độ dài bằng nhau, thứ tự trước đó do số lượng được giữ nguyên.)

-1G`

Giữ giá trị cuối cùng tức là dài nhất.

R , 102 byte

function(i)rep(names(sort(-(x=(x=table(rle(i)))[rowSums(x>1)>0,,drop=F])[m<-max(rownames(x)),])[1]),m)

Hãy thử trực tuyến!

Vì chưa có câu trả lời R, tôi quyết định thử, và ... thật không dễ chút nào. Tôi thực sự không biết liệu đó có phải là một cách tiếp cận tốt hay không, nhưng rồi đây.

Đầu vào và đầu ra vectơ của các ký tự.

Perl 6 , 58 56 byte

*.comb(/(.)$0*/).Bag.max({.value>1,+.key.comb,.{*}}).key

Hãy thử trực tuyến!

Python 2 , 123 120 byte

import re
def f(s):r=re.findall(r'(\d)(\1*)',s);c=r.count;print max((len(a+b)*(c((a,b))>1),c((a,b)),a+b)for a,b in r)[2]

Hãy thử trực tuyến!

Powershell, 101 byte

($args|sls '(.)\1*'-a|%{$_.Matches}|group|?{$_.Count-1}|sort @{e={$_.Name.Length,$_.Count}})[-1].Name

Kịch bản kiểm tra kèm theo:

$f = {

(
    $args|          # for each argument (stings)
    sls '(.)\1*'-a| # searches all
    %{$_.Matches}|  # regex matches
    group|          # group it (Note: Count of each group > 0 by design)
    ?{$_.Count-1}|  # passthru groups with Count not equal 1
    sort @{         # sort all groups by 2 values
        e={$_.Name.Length,$_.Count}
    }
)[-1].Name          # returns name of last group (group with max values)

}

@(
    ,('7888885466662716666', '6666')
    ,('3331113331119111', '111')
    ,('777333777333', '777','333')
    ,('122222233433', '33')
    ,('811774177781382', '8')
    ,('555153333551','1')
    ,('12321', '1','2')
    ,('944949949494999494','4')
    ,('8888858888866656665666','88888')
    ,('1112221112221111','111','222')
) | % {
    $s,$e = $_
    $r = &$f $s
    "$($r-in$e): $r"
}

Đầu ra:

True: 6666
True: 111
True: 777
True: 33
True: 8
True: 1
True: 1
True: 4
True: 88888
True: 111

Python 2 , 114 113 byte

-1 byte nhờ TFeld .

p='';r=[];C=r.count
for c in input():r+=['']*(c!=p);r[-1]+=c;p=c
print max((len(w),C(w),w)for w in r if~-C(w))[2]

Hãy thử trực tuyến!

Haskell, 72 byte

import Data.Lists
g!x|y<-countElem x g=(y>1,1<$x,y)
(argmax=<<(!)).group

Làm thế nào nó hoạt động

(argmax=<<(!)).group       -- expands to: f i = argmax (group i !) (group i)
    group                  -- split the input list into subsequences of equal digits
                           -- e.g. "1112211" -> ["111","22","11"]

                           -- find the element of this list where the function !
                           -- returns the maximum value. First parameter to !
                           -- is the grouped input list, second parameter the
                           -- the element to look at 

g!x|
    y<-countElem x g       -- let y be the number of occurrences of x in g
  = (  ,   ,  )            -- return a triple of
     y>1                   -- a boolean y>1  (remember: True > False)  
        1<$x               -- length of x (to be exact: all elements in x
                           -- replaced by 1. This sorts the same way as the
                           -- length of x)
             y             -- y
                           -- a triples sorts lexicographical

R , 85 byte

function(x,R=rle(x),a=ave(R$v,R,FUN=length))rep(R$v[o<-order(a<2,-R$l,-a)[1]],R$l[o])

Hãy thử trực tuyến!

• Đầu vào: một vectơ gồm các chữ số nguyên tách biệt, vdc(1,8,8...)

• Đầu ra: một vectơ các chữ số nguyên tách biệt

Mã không được kiểm soát với lời giải thích:

function(x){                # x is a vector of digits : e.g. c(1,1,8,8,1,1)

R = rle(x)                  # Get the sequences of consecutive repeating digits
                            # doing run length encoding on x, i.e. : R is a list
                            # with the digits (R$values) and the number of their
                            # consecutive occurrencies (R$lengths)
                            # N.B. you can use R$v for R$values and R$l for R$lenghts

a=ave(R$v,R,FUN=length)     # Group R$v by R$l AND R$v, count the occurrencies 
                            # for each group and "unroll" the value of each 
                            # group to the original R$v length.
                            # Here basically we count the occurrencies of the same 
                            # sequence.

o<-order(a<2,-R$l,-a)[1]    # Get the indexes used to order by a < 2 then by -R$l and
                            # finally by -a; store the first index in "o".
                            # Here basically we use order to select the first sequence 
                            # repeated at least twice, in case of ties the sequence 
                            # with the greatest length and in case of ties the most 
                            # repeated sequence.

rep(R$v[o],R$v[o])          # Using the index "o", we reconstruct the sequence repeating
                            # R$l[o] times R$v[o]
}

Phiên bản thay thế chấp nhận vectơ số nguyên hoặc chữ số ký tự:

R , 88 byte

function(x,R=rle(x),a=ave(R$v,R,FUN=length))rep(R$v[o<-tail(order(a>1,R$l,a),1)],R$l[o])

Hãy thử trực tuyến!

• Đầu vào: một vectơ gồm các ký tự hoặc chữ số tách biệt, ví dụ c("1","8","8"...)hoặcc(1,8,8...)

• Đầu ra: một vectơ các ký tự được phân tách nếu đầu vào là một vectơ các ký tự, một vectơ các chữ số nếu đầu vào là một vectơ các chữ số

Đỏ , 256 250 byte

func[s][p: func[b][sort parse b[collect[any keep[copy a skip thru any a]]]]first
last sort/compare collect[foreach d p p s[if 1 < k: length? to-block d[keep/only
reduce[form unique d k]]]]func[x y][(reduce[length? x/1 x/2])< reduce[length? y/1 y/2]]]

Hãy thử trực tuyến!

Thực sự, giải pháp thực sự dài lần này ... (thở dài)

Lấy đầu vào là một chuỗi.

Giải trình:

f: func [ s ] [
    p: func [ b ] [                        ; groups and sorts the adjacent repeating items
        sort parse b [ 
            collect [                      
                any keep[
                    copy a skip thru any a ; gather any item, optionally followed by itself  
                ]
            ]
        ]
    ]
    t: copy []
    foreach d p p s [                     ; p p s transforms the input string into a block of sorted blocks of repeating digits
        if 1 < k: length? to-block d [    ; filters only the blocks that occur more than once
            insert/only t reduce [ form unique d k ] ; stores the digits and the number of occurences
                                          ; "8888858888866656665666" -> [["5" 3] ["666" 3] ["88888" 2]]
        ]
    ]
    first last sort/compare t func [ x y ] ; takes the first element (the digits) of the last block of the sorted block of items
        [ (reduce [ length? x/1 x/2 ]) < reduce [ length? y/1 y/2 ] ] ; direct comparison of the blocks
]

Java (JDK 10) , 213 byte

s->{int l=99,X[][]=new int[10][l],d,D=0,m=0,M=0;for(var x:s.split("(?<=(.))(?!\\1)"))X[x.charAt(0)-48][x.length()]++;for(;M<1&&l-->1;)for(d=0;d++<9;)if((m=X[d][l])>1&m>M){M=m;D=d;}for(;l-->0;)System.out.print(D);}

Hãy thử trực tuyến!

Giải thích (lỗi thời)

s->{                                    // Lambda for Consumer<String>
 int l=99,                              //  Length of token, max is 99.
     X[][]=new int[10][l],              //  Array containing the occurrences per token
     d,                                 //  digit value
     D=0,                               //  digit holder for best sequence candidate
     m=0,                               //  holder of the current candidate
     M=0;                               //  best candidate for the current length of token.
 for(var x:s.split("(?<=(.))(?!\\1)"))  //  Tokenize the string into digit-repeating sequences
  X[x.charAt(0)-48][x.length()]++;      //   Add one occurrence for the token
 for(;M<1&&l-->1;)                      //  While no value has been found and for each length, descending. Do not decrease length if a value has been found.
  for(d=0;d++<9;)                       //   for each digit
   if((m=X[d][l])>1&m>M){               //    if the current occurrence count is at least 2 and that count is the current greatest for the length
    M=m;D=d;                            //     mark it as the current best
   }                                    //
 for(;l-->0;)System.out.print(D);       //  Output the best-fitting subsequence.
}                                       // 

Tín dụng

• -9 byte và phát hiện lỗi nhờ Kevin Cruijssen

Ruby , 68 67 byte

->a{(b=a.chunk &:+@).max_by{|x|[(c=b.count x)<2?0:x[1].size,c]}[1]}

Hãy thử trực tuyến!

Đầu vào và đầu ra mảng của ký tự.

Cách tiếp cận khá đơn giản: chúng tôi xác định các lần chạy của các chữ số liên tiếp ( chunksử dụng hàm unary +làm hàm nhận dạng) và lấy mức tối đa - đầu tiên theo kích thước của lần chạy (đặt lại về 0 nếu số lần xuất hiện của nó là <2), sau đó bằng chính số đếm .

PCRE, 152 byte

(\d)(?<!(?=\1)..)(?=(\1*)(?!\1).*(?!\1).\1\2(?!\1))(?!(?:(?=\2((\3?+)(\d)(\5*)))){1,592}?(?=\2\3.*(?!\5).\5\6(?!\5))(?:\1(?=\1*\4\5(\7?+\5)))*+(?!\1))\2

Xem nó trong hành động trên: https://regex101.com/r/0U0dEp/1 (chỉ cần nhìn vào trận đấu đầu tiên trong mỗi trường hợp thử nghiệm)

Điều này chỉ để giải trí, vì regex không phải là ngôn ngữ lập trình thực sự và chính nó là giải pháp hạn chế: P

Bởi vì một nhóm có độ rộng bằng 0 như (?:)+chỉ khớp một lần và không lặp lại vô thời hạn, và vì PCRE tạo ra các bản sao của các nhóm được định lượng bằng giới hạn, nên tôi đã phải sử dụng một số ma thuật trong đó ("{1,592}"), trong đó có nghĩa là chúng ta chỉ có thể tìm tới 592 bộ chữ số liền kề phía trước để tìm một bộ cạnh tranh có thể dài hơn bộ hiện đang được kiểm tra. Thông tin thêm về khái niệm này ở đây .

Perl 5 , 88 byte

my($m,%s);++$i%2*$s{$_}++&&($n=$s{$_}/9+length)>$m&&($a=$_,$m=$n)for pop=~/((.)\2*)/g;$a

Hãy thử trực tuyến!

Hơi vô dụng, với các bài kiểm tra:

sub f {
  my($m,%s);
  my($i,$n,$a);           #not needed in golfed version
  ++$i % 2  *  $s{$_}++
  && ($n=$s{$_}/9+length) > $m
  && ($a=$_, $m=$n)
    for pop=~/((.)\2*)/g; #i.e. 7888885466662716666 => 7 88888 5 4 6666 2 7 1 6666
  $a
}
for(map[/\d+/g],split/\n/,join"",<DATA>){ #tests
  my($i,@e)=@$_;
  printf "%-6s   input %-24s   expected %-10s   got %s\n",
    (grep f($i) eq $_, @e) ? "Ok" : "Not ok", $i, join('|',@e), f($i);
}
__DATA__
Input:  7888885466662716666     Output: 6666
Input:  3331113331119111        Output: 111
Input:  777333777333            Output: 777|333
Input:  122222233433            Output: 33
Input:  811774177781382         Output: 8
Input:  555153333551            Output: 1
Input:  12321                   Output: 1|2
Input:  944949949494999494      Output: 4
Input:  8888858888866656665666  Output: 88888
Input:  1112221112221111        Output: 111|222

Ngôn ngữ Wolfram (Mathicala) , 67 byte

#&@@@MaximalBy[Select[Tally@Split@#,Last@#>1&],{Length@#,#2}&@@#&]&

Chức năng thuần túy. Lấy danh sách các chữ số làm đầu vào và trả về một danh sách các thứ tự (không theo thứ tự cụ thể) làm đầu ra. Không chắc chắn nếu mệnh đề "phải xuất hiện ít nhất hai lần" có thể được xử lý sạch hơn không. Hãy thử trực tuyến!

Japt -h, 12 byte

Đầu vào và đầu ra là các chuỗi.

ò¦ ñÊf@ÓZè¶X

Thử nó