让我们在自然数上定义一个a函数，以10个，如下所示：$n$$d_k\; d_{k-1}\; \dotsc\; d_1\; d_0$

只要相邻数字相等，就用它们的总和从左到右替换它们。如果有任何这样的数字，请重复相同的步骤。$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. 这样我们得到$\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$$1$

测试用例

您可以使用上述给定的术语，但是这里有一些较大的术语：

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

Python 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

在线尝试！

Python 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

在线尝试！

非正则表达式版本：

Python 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µƬṪ

更长一字节，但是更快。作为程序或功能工作。

在线尝试！

怎么运行的

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次链接，而不是调用它直到到达固定点为止。

Haskell，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

输入被当作字符串。

在线尝试！

JavaScript，48 47 46字节

输入和输出为字符串。返回nth序列项。

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

在线尝试

• 感谢Arnauld，节省了1个字节
• 由于tsh，节省了1个字节

Perl 6、37个字节

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

在线尝试！

这是一个函数，它以n作为参数生成序列的第n个项。

($_, { ... } ... * == *)是输入数字的连续更改的序列，该序列由方括号表达式（简单的正则表达式替换）生成，并且在时* == *（即序列中的最后两个数字相等时）停止。然后，[*-1]仅将序列的最后一个元素作为返回值。

视网膜，16字节

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

在线尝试！链接包括测试用例。说明：

+`

重复直到输入停止更改。

(.)\1

替换成对的相邻数字...

$.(2*$1*

...用两位数表示。（$1*生成$1 _s 的字符串，2*重复该字符串，并使用该字符串$.(的长度。实际上，Retina引擎比这更聪明，只是将其加倍$1。）

C＃（.NET核心），231，203，200，196，192个字节

编辑：函数现在为185字节，外加18 using System.Linq;

感谢BMO（对于1> 0等于true加上换行符删除）和XCoder先生（对于f =！f语句）！

EDIT2：using System.Linq多亏了达娜（Dana）分享了一些高尔夫球技巧，所以少了182个字节加18个字节！

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

在线尝试！

Perl 5，21 -p个字节

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

在线尝试！

Japt v2.0a0 -h，15 14个字节

返回nth序列项。

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

试试吧

这应该可以工作10个字节，但是Japt的递归替换方法中似乎有一个错误。

e/(.)\1/ÏÑ

Groovy，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语言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~#& 应用功能，直到结果停止更改。

带标志的C＃（Visual C＃交互式编译器）/u:System.Text.RegularExpressions.Regex，70字节

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

通过修改输入来输出。接受一个包含一个字符串作为输入的列表。

感谢@dana高尔夫球了整个23个字节！

在线尝试！

干净，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执行折叠过程的单个步骤的lambda 的无限应用程序（）中获取第一个重复值（）。输入作为[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 
]

Scala，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;}

在线尝试！

@ASCIIOnly极大地感谢了〜30打高尔夫球;）起初我们俩都同时发布更新，但是在某个时候他显然去了城镇！

-2感谢@EmbodimentOfIgnorance！

减少打高尔夫球的代码...

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