条款

一个蠕虫是负整数的任何名单，以及其最右边（即最后一个）元素称为头。如果头部不为0，则蠕虫的活动段由最长的连续元素块组成，该元素块包括头部，并且其所有元素至少与头部一样大。在简约有效段是主动段与由1。例如递减的头，所述蜗杆3 1 2 3 2具有活性片段2 3 2，以及减少的活性段2 3 1。

进化规则

蠕虫逐步演化如下：

在步骤t（= 1，2，3，...）中，
    如果头为0：删除头，
    否则：用缩减的活动段的t + 1级联副本替换活动段。

事实：任何蠕虫最终都会演变成空列表，而这样做的步骤就是蠕虫的生存期。

（有关详细信息，请参阅LD Beklemishev撰写的《蠕虫原理》。“列表”是指有限序列，“头”是指最后一个元素的用法，摘自本文—请勿混淆）并将列表作为抽象数据类型常用，其中head通常表示第一个元素。）

示例（括号中的活动部分）

蠕虫：0,1

step    worm
         0(1)
1        0 0 0
2        0 0 
3        0
4           <- lifetime = 4

蠕虫：1,0

step    worm
         1 0
1       (1)
2        0 0 0
3        0 0 
4        0
5           <- lifetime = 5

蠕虫：1,1

step    worm
        (1 1)
1        1 0 1 0 
2        1 0(1) 
3        1 0 0 0 0 0
4        1 0 0 0 0
5        1 0 0 0
...
8       (1) 
9        0 0 0 0 0 0 0 0 0 0
10       0 0 0 0 0 0 0 0 0
...
18       0
19           <- lifetime = 19

蠕虫：2

step    worm
        (2)
1       (1 1)
2        1 0 1 0 1 0
3        1 0 1 0(1)
4        1 0 1 0 0 0 0 0 0
5        1 0 1 0 0 0 0 0
6        1 0 1 0 0 0 0
...
10       1 0(1)
11       1 0 0 0 0 0 0 0 0 0 0 0 0 0
12       1 0 0 0 0 0 0 0 0 0 0 0 0
...
24      (1)
25       0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
...
50       0
51          <- lifetime = 51

蠕虫：2,1

        (2 1)
1        2 0 2 0
2        2 0(2)
3        2 0(1 1 1 1)
4        2 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0
5        2 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0(1 1 1)
6        2 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0
7        2 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0(1 1)
8        2 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0{1 0}^9
...
??          <- lifetime = ??      

蠕虫：3

step    worm
        (3)
1       (2 2)
2       (2 1 2 1 2 1)
3        2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2 0 
4        2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1(2)
5        2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2 0(2 1 2 1 1 1 1 1 1 1)
6        2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2 0{2 1 2 1 1 1 1 1 1 0}^7
7        2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2 0{2 1 2 1 1 1 1 1 1 0}^6 (2 1 2 1 1 1 1 1 1) 
...      ...
??          <- lifetime = ??

在旁边

蠕虫的寿命通常是巨大的，如在标准的条件通过如下所示的下界快速增长的层次结构的函数f _α：

worm                lower bound on lifetime
----------------    ------------------------------------------
11..10 (k 1s)       f_k(2)
2                   f_ω(2)
211..1 (k 1s)       f_(ω+k)(2)
2121..212 (k 2s)    f_(ωk)(2)
22..2 (k 2s)        f_(ω^k)(2)
3                   f_(ω^ω)(2)
...
n                   f_(ω^ω^..^ω)(2) (n-1 ωs)  >  f_(ε_0) (n-1)

值得注意的是，蠕虫[3]的寿命已经远远超过了格雷厄姆数 G：

˚F _{ω ^ω}（2）= F _{ω ²}（2）= F _ω2（2）= F _{（ω）+ 2}（2）= F _{（ω）+ 1}（F _{（ω）+ 1}（2））>> F _{（ω）+ 1}（64） >G。

高尔夫挑战赛

编写具有以下行为的最短函数子程序：

输入：任何蠕虫。
输出：蠕虫的生存期。

代码大小以字节为单位。

这是一个示例（Python，可读取约167个字节）：

from itertools import *
def T(w):
    w=w[::-1]
    t=0
    while w:
        t+=1
        if w[0]:a=list(takewhile(lambda e:e>=w[0],w));a[0]-=1;w=a*(t+1)+w[len(a):]
        else:w=w[1:]
    return t

注意：如果t（n）是蠕虫的生存期[n]，则t（n）的增长率大约是Goodstein函数的增长率。因此，如果可以将其压缩到100字节以下，则可以很好地回答“ 最大数字可打印”问题。（对于该答案，可以通过始终将步数计数器始终从n开始（与蠕虫[n]相同的值）而不是从0开始，来大大提高增长率。）

GolfScript（56 54个字符）

{-1%0\{\)\.0={.0+.({<}+??\((\+.@<2$*\+}{(;}if.}do;}:L;

在线演示

我认为这里的关键技巧可能是使蠕虫保持相反的顺序。这意味着找到活动段的长度非常紧凑：（.0+.({<}+??在其中0添加作为保护，以确保我们找到一个小于头部的元素）。

顺便说一句，蠕虫寿命的一些分析。我将蠕虫表示为age, head tail（即，与问题符号相反的顺序），使用指数表示头部和尾部的重复：例如2^3is 2 2 2。

引理（Lemma）：对于任何活动段xs，都有一个f_xs可以age, xs 0 tail转换为的函数f_xs(age), tail。

证明：任何活动句段都不能包含a 0，因此到我们删除尾部之前的所有内容时的年龄与尾部无关，因此仅是的函数xs。

引诱：对于任何活跃的部分xs，蠕虫都会age, xs在死亡时死亡f_xs(age) - 1。

证明：由上一个引理age, xs 0转化为f_xs(age), []。最后一步是删除that 0，这是以前没有涉及的，因为它永远无法形成活动段的一部分。

通过这两个引理，我们可以研究一些简单的活动段。

对于n > 0，

age, 1^n 0 xs -> age+1, (0 1^{n-1})^{age+1} 0 xs
              == age+1, 0 (1^{n-1} 0)^{age+1} xs
              -> age+2, (1^{n-1} 0)^{age+1} xs
              -> f_{1^{n-1}}^{age+1}(age+2), xs

因此f_{1^n} = x -> f_{1^{n-1}}^{x+1}(x+2)（使用base case f_{[]} = x -> x+1，或者如果您愿意f_{1} = x -> 2x+3）。我们看到Ackermann–Péter函数f_{1^n}(x) ~ A(n+1, x)在哪里A。

age, 2 0 xs -> age+1, 1^{age+1} 0 xs
            -> f_{1^{age+1}}(age+1)

这足以解决问题1 2（2 1在问题的表示法中）：

1, 1 2 -> 2, 0 2 0 2
       -> 3, 2 0 2
       -> f_{1^4}(4), 2
       -> f_{1^{f_{1^4}(4)+1}}(f_{1^4}(4)+1) - 1, []

因此，给定输入，2 1我们期望输出〜A(A(5,4), A(5,4))。

1, 3 -> 2, 2 2
     -> 3, 1 2 1 2 1 2
     -> 4, 0 2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2
     -> 5, 2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2
     -> f_{21212}^4(5) - 1

age, 2 1 2 1 2 -> age+1, (1 1 2 1 2)^{age+1}
               -> age+2, 0 1 2 1 2 (1 1 2 1 2)^age
               -> age+3, 1 2 1 2 (1 1 2 1 2)^age

我真的可以理解为什么这个功能如此疯狂地增长了。

GolfScript，69 62个字符

{0:?~%{(.{[(]{:^0=2$0+0=<}{\(@\+}/}{,:^}if;^?):?)*\+.}do;?}:C;

该函数C期望蠕虫在堆栈上，并用结果替换它。

例子：

> [1 1]
19

> [2]
51

> [1 1 0]
51

Ruby-131个字符

我知道这不能与上面的GolfScript解决方案竞争，而且我很确定可以将分数降低或减少更多字符，但是老实说，我很高兴能够解决这个难题。大难题！

f=->w{t=0;w.reverse!;until w==[];t+=1;if w[0]<1;w.shift;else;h=w.take_while{|x|x>=w[0]};h[0]-=1;w.shift h.size;w=h*t+h+w;end;end;t}

从上面推导出的我的预解决方案：

def life_time(worm)
  step = 0
  worm.reverse!
  until worm.empty?
    step += 1
    if worm.first == 0
      worm.shift
    else
      head = worm.take_while{ |x| x >= worm.first }
      head[0] -= 1
      worm.shift(head.size)
      worm = head * (step + 1) + worm
    end
  end
  step
end

滑动（43个字符）

글坼가⑴감套擘終長①加⒈丟倘⓶增⓶가采⓶擘❷小終⓷丟❶長貶❷가掊貶插①增復合감不가終終

这期望输入为以空格分隔的列表。这会为1 1和输出正确的答案2，但是对于2 1或3来说花费的时间太长，所以我放弃了等待它完成的过程。

有评论：

글坼 | split at spaces
가⑴ | iteration count = 0

감套 | while:
  擘終長①加⒈丟 | remove zeros from end and add to iteration count
  倘 | if the list is not empty:
    ⓶增⓶ | increment iteration count
    가采⓶擘❷小終⓷丟 | separate out active segment
    ❶長貶❷가掊貶插 | compute reduced active segment
    ①增復合 | repeat reduced active segment and concat
    감 | continue while loop
  不 | else
    가 | stop while loop
  終 | end if
終 | end while

k（83）

worm:{-1+*({x,,(,/((x+:i)#,@[y@&w;(i:~~#y)#0;-1+]),y@&~w:&\~y<*y;1_y)@~*y}.)/(1;|,/x)}

这可能可以进一步进行，因为它可以非常直接地实现重复。

基本的进化函数，{x,,(,/((x+:i)#,@[y@&w;(i:~~#y)#0;-1+]),y@&~w:&\~y<*y;1_y)@~*y}是65个字符，并使用一些技巧来阻止蠕虫死亡时增加年龄。包装器将单个整数的输入强制转换为列表，反转输入（以递归方式将蠕虫写成与您的记号相反的蠕虫要短一些），索取固定点，选择使用期限作为输出并调整结果以解决上一代产品中的过冲问题。

如果我手动执行强制和反向操作，则它会降至80（{-1+*({x,,(,/((x+:i)#,@[y@&w;(i:~~#y)#0;-1+]),y@&~w:&\~y<*y;1_y)@~*y}.)/(1;x)}）。

一些例子：

  worm 1 1 0
51
  worm 2
51
  worm 1 1
19

不幸的是，对于最大数量的可打印件，它可能用不了多少，除了从理论上讲，它，因为它相当慢，仅限于64位整数，并且可能不是特别节省内存。

特别是，worm 2 1和worm 3刚刚翻腾（并可能会抛出'wsfull（内存不足），如果我让他们继续下去）。

APL（Dyalog Unicode），52 字节^SBCS

@ngn和@Adám节省了7个字节。

0{⍬≡⍵:⍺⋄n←⍺+1⋄0=⊃⍵:n∇1↓⍵⋄n∇∊(⊂1n/-∘1@1¨)@1⊆∘⍵⍳⍨⌊\⍵}⌽

在线尝试！

说明：

0{...}⌽    ⍝ A monadic function train. We define a recursive function with two
           ⍝ arguments: zero (our counter), and the reverse of our input
⍬≡⍵:⍺      ⍝ Our base case - if our input is an empty list, return our counter
n←⍺+1      ⍝ Define 'n' as our counter plus 1
0=⊃⍵:n∇1↓⍵ ⍝ If the first element of the input is zero, recurse with the tail
           ⍝ of our input and n
⌊\⍵        ⍝ Minimum-expand: creates a new list from our input where each element
           ⍝ is the incremental minimum     
⍳⍨         ⍝ Applies above to both sides of the index-of function. Index-of returns
           ⍝ the index of the first occurence of each element in the left-side list.
           ⍝ At this point, a (reversed) input list of [3 4 5 2 3 4] would result
           ⍝ in [1 1 1 4 4 4]
⊆∘⍵        ⍝ Partition, composed with our input. Partition creates sublists of the
           ⍝ right input whenever the integer list in the left input increases.
           ⍝ This means we now have a list of sub-lists, with the first element
           ⍝ being the worm's active segment.
(...)@1    ⍝ Take the active segment and apply the following function train...
-∘1@1¨     ⍝ Subtract 1 from the first element of the active segment
1n/        ⍝ Replicate the resultant list above n+1 times
⊂          ⍝ Enclose the above, so as to keep the original shape of our sub-array
∊          ⍝ Enlist everything above together - this recursively concatenates our
           ⍝ new active segment with the remainder of the list
n∇         ⍝ Recurse with the above and n

斯卡拉198

type A=List[Int]
def T(w:A)={def s(i:Int,l:A):Stream[A]=l match{case f::r=>l#::s(i+1,if(f<1)r
else{val(h,t)=l.span(_>=l(0));List.fill(i)(h(0)-1::h.tail).flatten++t})
case _=>Stream()};s(2,w).length}

用法：

scala> T(List(2))
res0: Int = 51

K，95

{i::0;#{~x~,0}{((x@!b),,[;r]/[i+:1;r:{@[x;-1+#x;-1+]}@_(b:0^1+*|&h>x)_x];-1_x)@0=h:*|x:(),x}\x}

。

k)worm:{i::0;#{~x~,0}{((x@!b),,[;r]/[i+:1;r:{@[x;-1+#x;-1+]}@_(b:0^1+*|&h>x)_x];-1_x)@0=h:*|x:(),x}\x}
k)worm 2
51
k)worm 1 1
19
q)worm 1 1 0 0 0 0
635

C（gcc），396字节

#define K malloc(8)
typedef*n;E(n e,n o){n s=K,t=s;for(*s=*o;o=o[1];*t=*o)t=t[1]=K;t[1]=e;e=s;}main(c,f,l,j,a)n*f;{n w=K,x=w;for(;l=--c;x=x[1]=K)*x=atoi(f[c]);for(;w&&++l;)if(*w){n v=K,z=v,u=w,t=K;for(a=*v=*w;(u=u[1])&&*u>=*w;*z=*u)z=z[1]=K;for(x=v[1],v=K,*v=a-1,1[u=v]=x;u;u=u[1])w=w[1];for(j=~l;j++;)u=t=E(t,v);for(;(u=u[1])&&(x=u[1])&&x[1];);u[1]=0;w=w?E(w,t):t;}else w=w[1];printf("%d",--l);}

在线尝试！

我知道我晚会很晚，但是我想我会用C来尝试这一点，这需要一个链表实现。除了将所有标识符更改为单个字符外，它根本不是真正的高尔夫球手，但它确实起作用！

总而言之，考虑到这是我编写的第三个C / C ++程序，我非常高兴。

Haskell，84个字节

(0!).reverse
n!(x:y)|x<1=(n+1)!y|(a,b)<-span(>=x)y=(n+1)!(([-1..n]*>x-1:a)++b)
n!_=n

在线尝试！

感谢@xnor提供了两个字节。

我觉得应该有一种排除常见增量的好方法，但是我还没有找到一个简短的增量。

Perl -pa 5，92个字节

while(@F){++$\;my@a;if($b=pop@F){unshift@a,pop@F while$F[-1]>=$b;push@F,(@a,--$b)x($\+1)}}}{

在线尝试！

Stax，31 个字节

àîz7αan♣óàNµK2☻₧⌡▐`Γl½f{♂♂_KZÖÄ

运行并调试