자연수 $n$ 에 함수를 정의하고 기본 10 자리수 $d_k\; d_{k-1}\; \dotsc\; d_1\; d_0$다음과 같이 d 0

인접한 숫자 d i 가 동일한 한$d_i\;d_{i-1}$ 이면왼쪽에서 오른쪽으로합계$d_i+d_{i-1}$ 로 바꿉니다. 그러한 숫자가 있으면 동일한 절차를 반복하십시오.

다시 말해, 각 반복에서 우리는 탐욕스럽게 동일한 인접 자릿수의 모든 쌍을 가져 와서 동시에 합계로 대체합니다 (가장 겹치는 경우 가장 왼쪽 쌍 사용).

예

의가 보자 $\texttt{9988}$ 예를 들면 :

1. 첫 번째 인접한 숫자는 두 개의 $\texttt{9}$
2. 우리가로 교체 그래서 $\texttt{9 + 9} = \texttt{18}$ 우리에게주는 $\texttt{1888}$
3. 우리는 여전히 첫 번째 왼쪽 오른쪽 순회에 있고 여전히 두 개의 $\texttt{8}$ 초가 있었으므로 먼저 이들을 교체해야합니다.
4. 1816 을 얻습니다$\texttt{1816}$
5. 무언가가 변경되었으므로 다른 반복을 수행해야합니다.
6. 그러나 그런 숫자가 없으므로 우리는 멈 춥니 다.

따라서이 순서에서 $9988^\text{th}$ 숫자는 $1816$ 입니다.

도전

처음 200 개의 용어는 다음과 같습니다.

0,1,2,3,4,5,6,7,8,9,10,2,12,13,14,15,16,17,18,19,20,21,4,23,24,25,26,27,28,29,30,31,32,6,34,35,36,37,38,39,40,41,42,43,8,45,46,47,48,49,50,51,52,53,54,10,56,57,58,59,60,61,62,63,64,65,12,67,68,69,70,71,72,73,74,75,76,14,78,79,80,81,82,83,84,85,86,87,16,89,90,91,92,93,94,95,96,97,98,18,10,101,102,103,104,105,106,107,108,109,20,21,4,23,24,25,26,27,28,29,120,121,14,123,124,125,126,127,128,129,130,131,132,16,134,135,136,137,138,139,140,141,142,143,18,145,146,147,148,149,150,151,152,153,154,20,156,157,158,159,160,161,162,163,164,165,4,167,168,169,170,171,172,173,174,175,176,24,178,179,180,181,182,183,184,185,186,187,26,189,190,191,192,193,194,195,196,197,198,28

당신의 임무는 그 순서 중 하나를 생성하는 것입니다

• 주어진 $n$ , 해당 시퀀스에서 $n^\text{th}$ 숫자를 반환
• 주어진 $n$ , 해당 시퀀스 의 처음 $n$ 숫자를 반환
• 또는 시퀀스를 무기한 생성합니다.

0 을 사용하도록 제출을 선택할 수 있습니다.$0$ 또는 $1$ 색인 있지만 어느 것을 지정하십시오.

테스트 사례

위의 용어를 사용할 수 있지만 다음은 더 큰 용어입니다.

222 -> 42
1633 -> 4
4488 -> 816
15519 -> 2019
19988 -> 2816
99999 -> 18189
119988 -> 21816
100001 -> 101
999999 -> 181818

파이썬 3 , 128 바이트

def t(z):j=z and(z[0]==z[1:2])+1;return[str(int(z[0])*j),*t(z[j:])]if j else''
def c(n):r="".join(t(n));return r!=n and c(r)or r

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

파이썬 2 , 97 96 93 바이트

def f(n):r=re.sub(r'(.)\1',lambda m:`int(m.group(1))*2`,n);return r!=n and f(r)or r
import re

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

비정규 버전 :

파이썬 (2) , 133 (130) 122 (112) 98 바이트

def f(n):
 r='';s=n
 while s:a=1+(s[0]==s[1:2]);r+=`int(s[0])*a`;s=s[a:]
 return r!=n and f(r)or r

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

젤리 , 11 바이트

DŒg+2/€FVµ¡

이것은 불필요하게 느린 전체 프로그램입니다.

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

대체 버전, 12 바이트

DŒg+2/€FVµƬṪ

1 바이트 더 길지만 훨씬 빠릅니다. 프로그램 또는 기능으로 작동합니다.

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

작동 원리

DŒg+2/€FVµƬṪ  Main link. Argument: n (integer)

         µ    Combine the previous links into a chain. Begin a new one.
D               Decimal; yield n's digit array in base 10.
 Œg             Group adjacent, identical digits into subarrays.
   +2/€         Map non-overlapping, pairwise sum over the subarrays.
                If there is an odd number of digits in a subarray, the
                last digit will remain untouched.
       F        Flatten; dump all sums and digits into a single array.
        V       Eval; turn the result into an integer.
          Ƭ   Execute the chain 'til the results are no longer unique.
              Return all unique results.
           Ṫ  Tail; extract the last result.

11 바이트 버전은 고정 소수점에 도달 할 때까지 호출하는 대신 입력 n에 대해 링크 n 번을 호출한다는 점을 제외하고 동일하게 작동합니다 .

하스켈, 70 바이트

until((==)=<<f)f
f(a:b:c)|a==b=show(2*read[a])++f c|1<2=a:f(b:c)
f a=a

입력은 문자열로 간주됩니다.

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

자바 스크립트, 48 47 46 바이트

문자열로 입력 및 출력합니다. nth시퀀스 의 항을 반환합니다 .

f=s=>s-(s=s.replace(/(.)\1/g,x=>x/5.5))?f(s):s

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

• 덕분에 1 바이트 절약 Arnauld
• tsh 덕분에 1 바이트 절약

펄 6 , 37 바이트

{($_,{S:g[(\d)$0]=2*$0}...*==*)[*-1]}

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

이것은 인수로 n을 주어 시퀀스의 n 번째 항을 생성하는 함수입니다.

($_, { ... } ... * == *)는 대괄호로 묶인 표현식 (단순한 정규식 대체)에 의해 생성되고 * == *, 즉 시퀀스의 마지막 두 숫자가 같을 때 중지되는 입력 번호의 연속적인 변경 순서입니다 . 그런 다음 [*-1]해당 시퀀스의 마지막 요소 만 반환 값으로 사용합니다.

레티 나 , 16 바이트

+`(.)\1
$.(2*$1*

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

+`

입력 변경이 멈출 때까지 반복하십시오.

(.)\1

인접한 숫자 쌍을 교체하십시오 ...

$.(2*$1*

... 두 자리수로. ( s $1*문자열을 생성하고 복제하고$1 _2*$.( 하여 길이를 가져옵니다. 실제로 Retina 엔진은 그보다 더 영리하고 두 배 $1입니다.)

C # (. NET 코어) , 231 , 203 , 200 , 196 , 192 바이트

편집 : 기능은 이제 185 바이트에 18을 더한 것입니다. using System.Linq;

BMO (1> 0은 true + 개행 제거와 동일)와 Mr. XCoder (f =! f 문) 덕분에!

EDIT2 : 최저 182 바이트 + 18 using System.Linq 골프 팁 몇 개를 공유 한 dana 덕분 !

EDIT3 : int []-> var, 단락 제거 &&-> & 및 ToArray-> ToList 변경에 대한 무지의 구현 덕분에! (178 바이트 + 18 사용)

EDIT4 : 무지의 구현은 할당을 변경하여 4 바이트를 떨어 뜨 렸습니다. 더미 나 계산해야합니다! 다시 감사합니다 : D

p=>{var f=1>0;while(f){var t=p.Select(n=>n-48).ToList();p="";f=!f;for(var j=0;j<t.Count;j++){if(j<t.Count-1&t[j]==t[1+j]){p+=t[j]+t[++j];f=!f;continue;}p+=t[j];}};return p;};

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

펄 5 -p , 21 바이트

s/(.)\1/$1*2/ge&&redo

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

Japt v2.0a0 -h, 15 14 바이트

nth시퀀스 의 항을 반환합니다 .

Æ=s_r/(.)\1/ÏÑ

시도 해봐

이것은 10 바이트에서 작동하지만 Japt의 재귀 대체 방법에는 버그가있는 것 같습니다.

e/(.)\1/ÏÑ

그루비 , 63 바이트

{s->r=/(\d)\1/
while(s=~r)s=s.replaceAll(r){(it[1]as int)*2}
s}

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

05AB1E , 11 바이트

Δγε2ôSO}˜J

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

Δ             # Continue until the (implicit) input no longer changes:
 γ            #  Split the integer in chunks of the same adjacent digits
              #   i.e. 199999889 → [1,99999,88,9]
  ε     }     #  Map each to:
   2ô         #   Split it into parts of size 2
              #    i.e. 99999 → [99,99,9]
     €S       #   Split each part into digits
              #    i.e. [99,99,9] → [[9,9],[9,9],[9]]
       O      #   And take the sum of each part
              #    i.e. [[9,9],[9,9],[9]] → [18,18,9]
         ˜    #  Flatten the list
              #   i.e. [[1],[18,18,9],[16],[9]] → [1,18,18,9,16,9]
          J   #  Join everything together
              #   i.e. [1,18,18,9,16,9] → 118189169
              # (And output the result implicitly at the end)
              #  i.e. output = 28189169

Wolfram Language 108 바이트

ToExpression[""<>ToString/@Total/@Flatten[Partition[#,UpTo@2]&/@Split@IntegerDigits@#,1]]&~FixedPoint~#&

설명

IntegerDigits 입력 번호를 숫자 목록으로 변환합니다.

Split 연속 반복 숫자를 그룹화합니다.

Partition[#, UpTo@2]&/@ 같은 숫자의 런을 최대 길이 2의 목록으로 나눕니다.

Flatten[...,1] 가끔 과도하게 중괄호를 제거합니다. 예를 들어 {{2,2}}는 {2,2}가됩니다.

Total/@쌍을 이루는 숫자의 합계를 합산합니다. 분리 된 숫자는 합산 할 필요가 없습니다.

ToString 총계 (및 분리 된 숫자)를 문자열로 변환합니다.

""<> 목록의 모든 문자열을 결합합니다.

ToExpression 결과를 정수로 변환합니다.

...~FixedPoint~#& 결과가 변경 될 때까지 함수를 적용합니다.

플래그 /u:System.Text.RegularExpressions.Regex가 70 바이트 인 C # (Visual C # Interactive Compiler)

s=>{for(;s[0]!=(s[0]=Replace(s[0],@"(.)\1",m=>m.Value[0]*2-96+"")););}

입력을 수정하여 출력합니다. 입력 할 문자열 하나를 포함하는 목록을받습니다.

전체 23 바이트를 골프로 한 @dana에게 감사합니다!

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

클린 , 118 바이트

import StdEnv,Data.List
$[a,b:t]|a==b=[1,(a*2)rem 10]%(1-a/5,1)++ $t=[a: $[b:t]]
$l=l

limit o iterate$o map digitToInt

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

축소 프로세스의 단일 단계를 수행하는 람다 limit의 무한 응용 프로그램 목록 ( )에서 첫 번째 반복 된 값 ( )을 가져옵니다 iterate. 로 입력이 입력되었습니다 [Char].

빨강 , 84 83 80 바이트

func[n][if parse s: form n[to some change[copy d skip d](2 * do d)to end][f s]s]

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

nth시퀀스 의 항을 반환합니다 .

설명:

Red[]
f: func [ n ] [
    if parse s: form n [  ; parse the input converted to a string
        to some change [  ; find and change one or more
            copy d skip   ; digit (in fact any character, no predefined character classes)
            d             ; followed by itself
        ] (2 * do d)      ; with its doubled numeric value 
        to end            ; go to the end of the string
    ] [ f s ]             ; call the function with the altered string if parse returned true
    s                     ; finally return the string 
]

스칼라 , 84 바이트

s=>{var t=s
while(t!=(t="(\\d)\\1".r.replaceAllIn(t,m=>s"$m"(0)*2-96+""),t)._2){}
t}

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

C # (Visual C # 대화 형 컴파일러) , 111 바이트

s=>{var t=s;do{s=t;t="";for(int i=0;i<s.Length;)t+=s[i]%48*(s[i++]!=(s+0)[i]?1:2*++i/i);}while(t!=s);return t;}

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

~ 30 골프에 대한 @ASCIIOnly에 큰 신용;) 처음에 우리는 동시에 업데이트를 게시했지만 어느 시점에서 그는 분명히 도시에 갔다!

@EmbodimentOfIgnorance 덕분에 -2!

덜 골프 코드 ...

// s is the input as a string
s=>{
  // t is another string used
  // to hold intermediate results
  var t=s;
  // the algorithm repeatedly
  // processes s and saves the
  // result to t
  do{
    // copy the last result to s
    // and blank out t
    s=t;
    t="";
    // iterate over s
    for(int i=0;i<s.Length;)
      // append either 1 or 2 times
      // the current digit to t
      t+=s[i]%48*
        // compare the current digit
        // to the next digit. to prevent
        // an out-of-bounds exception,
        // append a 0 to s which either
        // gets ignored or collapses
        // to 0
        (s[i++]!=(s+0)[i]
          // if they are different, then
          // the multiplier is 1
          ?1
          // if they are the same, then
          // the multiplier is 2, and we
          // have to increment i
          :2*++i/i);
  }
  // continue this until the input
  // and output are the same
  while(t!=s);
  return t;
}