도전:

양의 정수가 주어지면 적어도 두 번 발생하는 가장 긴 한 자리 수의 하위 시퀀스를 출력하고 다른 숫자의 경계 (또는 정수의 시작 / 끝)를 갖습니다.

예를 들면 :

입력 : 7888885466662716666
한 자릿수의 가장 긴 하위 시퀀스 는 길이가 5 인 88888( 7[88888]5466662716666)입니다. 그러나이 하위 시퀀스는 정수에서 한 번만 발생합니다.
대신 입력 결과 는 (적어도) 두 번 발생하므로 ( ) 7888885466662716666이어야합니다 .666678888854[6666]271[6666]

도전 규칙 :

• 서브 시퀀스 길이는 발생 횟수보다 우선합니다. (즉, input을 사용 8888858888866656665666하면 88888( [88888]5[88888]66656665666; length 5, 두 번 발생)가 아닌 666( 88888588888[666]5[666]5[666]; length 3, 세 번 발생) 출력합니다.
• 여러 하위 시퀀스의 길이가 같으면 발생 횟수가 가장 큰 시퀀스를 출력합니다. 즉, input을 사용 3331113331119111하면 111( 333[111]333[111]9[111]; length 3, 세 번 발생) 출력 하지 않고 333( [333]111[333]1119111; length 3도 두 번 발생)
• 여러 서브 시퀀스의 발생 횟수와 길이가 같으면 그 중 하나 또는 전부 (순서대로)를 출력 할 수 있습니다. 즉, input 777333777333을 사용하면 가능한 출력은 다음과 같습니다 777.; 333; [777, 333]; 또는 [333, 777].
• 하위 시퀀스에는 다른 숫자의 경계 (또는 정수의 시작 / 끝)가 있어야합니다. 즉, 입력 122222233433결과는 33( 1222222[33]4[33]; 길이 2, 두 번 발생 함)이 아닌 222( 1[222][222]33433길이 3은 둘 다 유효하지 않은 경우 두 번 발생 함).
  • 이것은 발생 카운터로 계산되는 모든 숫자에 적용됩니다. 즉, 입력 811774177781382결과는 8( [8]117741777[8]13[8]2; 길이 1, 세 번 발생)이며 77( 811[77]41[77]781382/ 811[77]417[77]81382; 길이 2, 하나의 무효로 두 번 발생) 또는 1( 8[1][1]774[1]7778[1]382; 길이 1, 두 번의 무효로 네 번 발생)입니다.
• 입력에 숫자가 포함되지 않는다고 가정 할 수 있습니다 0(와 일치 [1-9]+). (이것은 대부분의 언어가 기본적으로 출력 되는 10002000output 과 같은 테스트 사례를 처리하지 않아도됩니다 .)0000
• 입력에 항상 하나 이상의 유효한 출력이 포함되어 있다고 가정 할 수 있습니다.
• I / O는 유연합니다. 숫자 / 바이트 / 문자의 목록 / 배열 / 스트림이거나 단일 정수 대신 문자열 일 수 있습니다.

일반 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하지 마십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙이 답변에 적용 되므로 STDIN / STDOUT, 적절한 매개 변수 및 리턴 유형의 전체 프로그램과 함께 함수 / 방법을 사용할 수 있습니다. 당신의 전화.
• 기본 허점 은 금지되어 있습니다.
• 가능하면 코드 테스트 링크를 추가하십시오.
• 또한 답변에 대한 설명을 추가하는 것이 좋습니다.

테스트 사례 :

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 바이트

γТ1›ÏD€gZQÏ.M

온라인으로 사용해보십시오!

설명

γ                # 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

젤리 , 12 바이트

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

온라인으로 사용해보십시오!

이전 버전 – 14 바이트

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

온라인으로 사용해보십시오!

어떻게 작동합니까?

Œ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.

자바 스크립트 (ES6), 79 73 68 바이트

입력을 문자열로받습니다. 정수를 반환합니다.

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

온라인으로 사용해보십시오!

댓글

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

레티 나 , 56 바이트

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

N$`
$.&
-1G`

온라인으로 사용해보십시오! 링크에는 테스트 사례가 포함됩니다. 설명:

L`(.)\1*

최대 반복되는 숫자 서브 시퀀스를 모두 나열하십시오.

O`

목록을 순서대로 정렬하십시오.

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

모든 여러 하위 시퀀스를 "count"와 함께 나열합니다.

N`

개수의 오름차순으로 정렬하십시오.

.+;

카운트를 삭제하십시오.

N$`
$.&

길이의 오름차순으로 정렬하십시오. 길이가 동일한 경우 개수로 인한 이전 순서가 유지됩니다.

-1G`

가장 긴 값을 유지하십시오.

R , 102 바이트

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

온라인으로 사용해보십시오!

아직 R 답변이 없었기 때문에 시도해보기로 결정했지만 쉽지 않았습니다. 나는 그것이 좋은 접근 방법인지 잘 모르겠지만 여기에 간다.

문자 벡터를 입력 및 출력합니다.

펄 6 , 58 56 바이트

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

온라인으로 사용해보십시오!

파이썬 2 , 123120 바이트

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]

온라인으로 사용해보십시오!

Powershell, 101 바이트

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

설명 된 테스트 스크립트 :

$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"
}

산출:

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

파이썬 2 , 114 113 바이트

TFeld 덕분에 -1 바이트 .

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]

온라인으로 사용해보십시오!

하스켈, 72 바이트

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

작동 원리

(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 바이트

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

온라인으로 사용해보십시오!

• 입력 : 분리 된 정수로 구성된 벡터c(1,8,8...)

• 출력 : 분리 된 정수 자릿수로 구성된 벡터

설명과 함께 풀린 코드 :

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

정수 또는 문자 숫자의 벡터를 허용하는 대체 버전 :

R , 88 바이트

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

온라인으로 사용해보십시오!

• 입력 : 분리 문자의 벡터 또는 숫자 예를 들어 c("1","8","8"...)나c(1,8,8...)

• 출력 : 입력이 문자 벡터 인 경우 분리 문자로 구성된 벡터, 입력이 숫자 벡터 인 경우 숫자로 구성된 벡터

빨강 , 256250 바이트

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

온라인으로 사용해보십시오!

정말 이번에는 정말 긴 해결책 ... (한숨)

입력을 문자열로 사용합니다.

설명:

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
]

자바 (JDK 10) , 213 바이트

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

온라인으로 사용해보십시오!

설명 (오래됨)

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

크레딧

• Kevin Cruijssen 덕분에 -9 바이트 및 버그 발견

루비 , 68 67 바이트

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

온라인으로 사용해보십시오!

문자 배열을 입력 및 출력합니다.

이 접근 방식은 매우 간단합니다. 연속 숫자의 런을 식별하고 ( chunk단항 +을 항등 함수로 사용) 런의 크기를 기준으로 최대 값을 취합니다 (발생 횟수가 <2 인 경우 0으로 재설정). .

PCRE, 152 바이트

(\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

https://regex101.com/r/0U0dEp/1 에서 실제로 확인하십시오 (각 테스트 사례에서 첫 번째 일치 항목 만보십시오).

정규식은 그 자체로는 실제 프로그래밍 언어가 아니며 솔루션은 제한되어 있기 때문에 이것은 재미 있습니다 .P

폭이 0 인 그룹 (?:)+은 한 번만 일치하고 무한정 반복되지 않으며 PCRE가 내부적으로 그룹의 사본을 한계로 수량화하기 때문에 거기에 마법 번호 ( "{1,592}")를 사용해야했습니다. 즉, 현재 검사중인 것보다 더 긴 경쟁 세트를 찾기 위해 최대 592 개의 연속 된 자릿수 세트 만 미리 볼 수 있습니다. 이 개념에 대한 자세한 내용은 여기를 참조하십시오 .

펄 5 , 88 바이트

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

온라인으로 사용해보십시오!

다음과 같은 테스트를 통해 약간 풀리지 않습니다.

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

Wolfram Language (Mathematica) , 67 바이트

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

순수한 기능. 숫자 목록을 입력으로 취하고 하위 순서 목록 (특정 순서는 아님)을 출력으로 리턴합니다. "적어도 두 번 나타나야합니다"절을보다 명확하게 처리 할 수 ​​있는지 확실하지 않습니다. 온라인으로 사용해보십시오!

Japt -h, 12 바이트

입력 및 출력은 문자열입니다.

ò¦ ñÊf@ÓZè¶X

시도 해봐