망막 , 66 60 바이트

+1`((\d+)?(?<1>\2)*(?<!\3(?>(?<-1>\3)*)(?!.*\2)(.+)))!
$1$#1

입력은 !숫자로 사용하는 단항 정수입니다 (비 숫자가 아닌 다른 문자로 변경 될 수 있음). 출력은 단순히 문자열입니다.

온라인으로 사용해보십시오! (또는 편의상 여기에 10 진수를 입력하는 버전이 있습니다. )

테스트 목적으로, 이것은 약간의 수정 으로 많은 속도를 낼 수 있으며 , 1 분 안에 입력 220을 테스트 할 수 있습니다.

+1`((\d+)?(?<1>\2)*(?=!)(?<!\3(?>(?<-1>\3)*)(?!.*\2)(.+)))!
$1$#1

온라인으로 사용해보십시오! ( 십진수 버전. )

더 큰 숫자를 테스트하려면 대량의 입력을 공급 :하고 초기 다음에을 넣는 것이 가장 좋습니다 +. 이렇게하면 새로운 숫자 계산이 끝날 때마다 Retina가 현재 시퀀스를 인쇄합니다 (모든 숫자가 하나씩 해제 됨).

설명

솔루션은 단일 정규식 대체로 구성되며 결과가 변경을 멈출 때까지 반복적으로 입력에 적용됩니다.이 경우 정규식이 더 이상 일치하지 않기 때문에 발생합니다. +처음에이 루프를 소개합니다. 는 1(이것은 매우 첫 번째 반복 만 관련) 망막은 첫 경기를 교체 알려주는 한계입니다. 각 반복에서 스테이지는 하나의 !(왼쪽에서) 시퀀스의 다음 숫자로 바뀝니다 .

평소와 같이 밸런싱 그룹에 대한 입문서가 필요하면 SO 답변을 참조하십시오 .

다음은 주석이 달린 정규식 버전입니다. 목표는 그룹에서 최대 반복 블록 수를 캡처하는 것입니다 1.

(                 # Group 1, this will contain some repeated block at the end
                  # of the existing sequence. We mainly need this so we can
                  # write it back in the substitution. We're also abusing it
                  # for the actual counting but I'll explain that below.
  (\d+)?          # If possible (that is except on the first iteration) capture
                  # one of more digits into group 2. This is a candidate block
                  # which we're checking for maximum repetitions. Note that this
                  # will match the *first* occurrence of the block.
  (?<1>\2)*       # Now we capture as many copies of that block as possible
                  # into group 1. The reason we use group 1 is that this captures
                  # one repetition less than there is in total (because the first
                  # repetition is group 2 itself). Together with the outer
                  # (unrelated) capture of the actual group one, we fix this
                  # off-by-one error. More importantly, this additional capture
                  # from the outer group isn't added until later, such that the
                  # lookbehind which comes next doesn't see it yet, which is
                  # actually very useful.
                  # Before we go into the lookbehind note that at the end of the
                  # regex there's a '!' to ensure that we can actually reach the
                  # end of the string with this repetition of blocks. While this
                  # isn't actually checked until later, we can essentially assume
                  # that the lookbehind is only relevant if we've actually counted
                  # repetitions of a block at the end of the current sequence.

  (?<!            # We now use a lookbehind to ensure that this is actually the
                  # largest number of repetitions possible. We do this by ensuring
                  # that there is no shorter block which can be matched more
                  # often from the end than the current one. The first time this
                  # is true (since, due to the regex engine's backtracking rules,
                  # we start from longer blocks and move to shorter blocks later),
                  # we know we've found the maximum number of repetitions.
                  # Remember that lookbehinds are matched right-to-left, so
                  # you should read the explanation of the lookbehind from
                  # bottom to top.
    \3            # Try to match *another* occurrence of block 3. If this works,
                  # then this block can be used more often than the current one
                  # and we haven't found the maximum number of repetitions yet.
    (?>           # An atomic group to ensure that we're actually using up all
                  # repetitions from group 1, and don't backtrack.
      (?<-1>\3)*  # For each repetition in group 1, try to match block 3 again.
    )
    (?!.*\2)      # We ensure that this block isn't longer than the candidate
                  # block, by checking that the candidate block doesn't appear
                  # right of it.
    (.+)          # We capture a block from the end into group 3.
  )               # Lookbehind explanation starts here. Read upwards.
)
!                 # As I said above, this ensures that our block actually reaches
                  # the end of the string.

마지막으로,이 작업이 모두 끝나면 그룹의 캡처 횟수와 최대 반복 횟수에 해당하는 캡처 수를 다시 기록합니다 $1(따라서 !) $#1.

답변

->n{s='';n.times{s+=(1..n).map{|i|s=~/(\d{#{i}})\1+$/?$&.size/i: 1}.max.to_s};s[-1]}

/(.{#{i}})\1+$/
/(                 # Assign the following to group 1
  .{#{i}}          # Match `i` number of characters
         )         # End group 1
          \1+      # Match 1 or more repetitions of group 1
             $/    # Match the end of string