Điều kiện

Một con sâu là bất kỳ danh sách các số nguyên không âm, và nó ngoài cùng bên phải (tức là, cuối cùng phần tử) được gọi là người đứng đầu . Nếu đầu không bằng 0, sâu có một phân đoạn hoạt động bao gồm khối các phần tử tiếp giáp dài nhất bao gồm đầu và có tất cả các phần tử của nó ít nhất bằng đầu . Các giảm phân khúc hoạt động là phân khúc hoạt động với người đứng đầu giảm đi 1. Ví dụ, con sâu 3 1 2 3 2có phân khúc hoạt động 2 3 2, và phân khúc hoạt động giảm là 2 3 1.

Quy luật tiến hóa

Một con sâu tiến hóa từng bước như sau:

Trong bước t (= 1, 2, 3, ...),
    nếu đầu là 0: xóa đầu
    khác: thay thế phân đoạn hoạt động bằng các bản sao được ghép nối t + 1 của phân đoạn hoạt động giảm.

Sự thật : Bất kỳ con sâu nào cuối cùng cũng tiến hóa vào danh sách trống và số bước cần thực hiện là thời gian tồn tại của con sâu .

(Chi tiết có thể được tìm thấy trong Nguyên lý sâu , một bài báo của LD Beklemishev. Việc sử dụng "danh sách" có nghĩa là một chuỗi hữu hạn và "đầu" để chỉ phần tử cuối cùng của nó , được lấy từ bài báo này - không nên nhầm lẫn với cách sử dụng phổ biến cho các danh sách dưới dạng kiểu dữ liệu trừu tượng , trong đó phần đầu thường có nghĩa là phần tử đầu tiên .)

Ví dụ (phân đoạn hoạt động trong ngoặc đơn)

Giun: 0,1

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

Giun: 1,0

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

Giun: 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

Giun: 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

Giun: 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 = ??      

Giun: 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 = ??

Qua một bên

Tuổi thọ của giun thường rất lớn, như được thể hiện bởi các giới hạn dưới đây về mặt phân cấp phát triển nhanh tiêu chuẩn của các hàm 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)

Đáng chú ý, sâu [3] đã có một cuộc đời vượt xa số lượng của Graham , G:

f _{ω ^ω} (2) = f _{ω ²} (2) = f _ω2 (2) = f _{ω + 2} (2) = f _{ω + 1} (f _{ω + 1} (2)) >> f _{ω + 1} (64) > G

Code Golf Challenge

Viết chương trình con hàm ngắn nhất có thể với hành vi sau:

Đầu vào : Bất kỳ sâu.
Đầu ra : Tuổi thọ của sâu.

Kích thước mã được đo bằng byte.

Đây là một ví dụ (Python, golf đến khoảng 167 byte):

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

Lưu ý : Nếu t (n) là thời gian tồn tại của sâu [n], thì tốc độ tăng trưởng của t (n) gần bằng với hàm Goodstein . Vì vậy, nếu điều này có thể được đánh gôn dưới 100 byte, nó cũng có thể đưa ra câu trả lời chiến thắng cho câu hỏi Số lượng lớn nhất có thể in được . (Đối với câu trả lời đó, tốc độ tăng trưởng có thể được tăng tốc đáng kể bằng cách luôn bắt đầu bộ đếm bước ở n - cùng giá trị với con sâu [n] - thay vì bắt đầu từ 0.)

GolfScript ( 56 54 ký tự)

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

Bản demo trực tuyến

Tôi nghĩ rằng thủ thuật quan trọng ở đây có lẽ là giữ sâu theo thứ tự ngược lại. Điều đó có nghĩa là nó khá nhỏ gọn để tìm độ dài của phân đoạn hoạt động: .0+.({<}+??(trong đó phần 0được thêm vào như một phần bảo vệ để đảm bảo rằng chúng ta tìm thấy một phần tử nhỏ hơn phần đầu).

Như một bên, một số phân tích về tuổi thọ của sâu. Tôi sẽ biểu thị con sâu là age, head tail(tức là theo thứ tự ngược từ ký hiệu của câu hỏi) bằng cách sử dụng số mũ để biểu thị sự lặp lại ở đầu và đuôi: vd 2^3là 2 2 2.

Bổ đề : đối với bất kỳ phân khúc hoạt động xs, có một chức năng f_xsnhư vậy mà age, xs 0 tailbiến đổi thành f_xs(age), tail.

Bằng chứng: không có phân đoạn hoạt động nào có thể chứa a 0, vì vậy độ tuổi theo thời gian chúng ta xóa mọi thứ trước khi đuôi độc lập với đuôi và do đó chỉ là một chức năng xs.

Bổ đề : cho bất kỳ phân đoạn hoạt động xs, con sâu age, xschết ở tuổi f_xs(age) - 1.

Chứng minh: bằng bổ đề trước, age, xs 0biến thành f_xs(age), []. Bước cuối cùng là xóa cái đó 0, cái mà trước đây không được chạm vào vì nó không bao giờ có thể tạo thành một phần của phân khúc hoạt động.

Với hai lemmata đó, chúng ta có thể nghiên cứu một số phân đoạn hoạt động đơn giản.

Đối với 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

vì vậy f_{1^n} = x -> f_{1^{n-1}}^{x+1}(x+2)(với trường hợp cơ sở f_{[]} = x -> x+1, hoặc nếu bạn thích f_{1} = x -> 2x+3). Chúng ta thấy rằng f_{1^n}(x) ~ A(n+1, x)ở đâu Alà hàm Ackermann-Péter.

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

Thế là đủ để xử lý 1 2( 2 1theo ký hiệu của câu hỏi):

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

Vì vậy, đầu vào 2 1chúng tôi mong đợi đầu ra ~ 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

và tôi thực sự có thể bắt đầu hiểu lý do tại sao chức năng này phát triển rất điên rồ.

GolfScript, 69 62 ký tự

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

Hàm này Cdự kiến ​​sâu trên ngăn xếp và thay thế nó bằng kết quả.

Ví dụ:

> [1 1]
19

> [2]
51

> [1 1 0]
51

Ruby - 131 ký tự

Tôi biết điều này không thể cạnh tranh với các giải pháp GolfScript ở trên và tôi khá chắc chắn rằng điều này có thể giảm điểm hoặc nhiều nhân vật hơn, nhưng thật lòng tôi rất vui vì đã có thể giải quyết vấn đề không được giải quyết. Câu đố tuyệt vời!

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}

Giải pháp trước khi chơi golf của tôi bắt nguồn từ những điều trên:

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

Sclipting (43 ký tự)

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

Điều này hy vọng đầu vào là một danh sách phân tách không gian. Điều này đưa ra câu trả lời chính xác cho 1 1và 2, nhưng vì 2 1hoặc 3mất quá nhiều thời gian nên tôi đã từ bỏ chờ đợi nó kết thúc.

Với lời bình luận:

글坼 | 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)}

điều này có thể có thể được đánh gôn hơn nữa, vì nó chỉ thực hiện tái phát khá đơn giản.

chức năng tiến hóa cơ bản {x,,(,/((x+:i)#,@[y@&w;(i:~~#y)#0;-1+]),y@&~w:&\~y<*y;1_y)@~*y}, là 65 ký tự, và sử dụng một số thủ thuật để ngừng tăng tuổi khi sâu chết. trình bao bọc ép một đầu vào của một số nguyên vào danh sách, đảo ngược đầu vào (viết ngắn hơn là lặp lại theo một con sâu đảo ngược từ ký hiệu của bạn), hỏi điểm cố định, chọn tuổi làm đầu ra và điều chỉnh kết quả để giải thích cho sự quá mức trong thế hệ trước.

nếu tôi thực hiện cưỡng chế và đảo ngược thủ công, nó giảm xuống 80 ( {-1+*({x,,(,/((x+:i)#,@[y@&w;(i:~~#y)#0;-1+]),y@&~w:&\~y<*y;1_y)@~*y}.)/(1;x)}).

vài ví dụ:

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

thật không may, có lẽ nó không được sử dụng nhiều cho Số lượng lớn nhất có thể in , ngoại trừ theo nghĩa rất lý thuyết, vì nó khá chậm, giới hạn ở số nguyên 64 bit và có lẽ không đặc biệt hiệu quả về bộ nhớ.

đặc biệt, worm 2 1và worm 3chỉ khuấy động (và có thể sẽ ném 'wsfull(ra khỏi bộ nhớ) nếu tôi để họ tiếp tục).

APL (Dyalog Unicode) , 52 byte ^SBCS

Đã lưu 7 byte nhờ @ngn và @ Adám.

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

Hãy thử trực tuyến!

Giải trình:

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

Scala, 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}

Sử dụng:

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 byte

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

Hãy thử trực tuyến!

Tôi biết rằng tôi TUYỆT VỜI đến bữa tiệc muộn, nhưng tôi nghĩ tôi sẽ thử điều này ở C, trong đó yêu cầu thực hiện danh sách liên kết. Nó hoàn toàn không được chơi gôn ngoài việc thay đổi tất cả các định danh thành các ký tự đơn, nhưng nó hoạt động!

Nói chung, tôi khá vui khi coi đây là chương trình C / C ++ thứ 3 tôi từng viết.

Haskell , 84 byte

(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

Hãy thử trực tuyến!

Cảm ơn @xnor cho hai byte.

Tôi cảm thấy nên có một cách tốt để xác định mức tăng chung, nhưng tôi chưa tìm thấy một cách ngắn nào.

Perl 5 -pa , 92 byte

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

Hãy thử trực tuyến!

Stax , 31 byte

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

Chạy và gỡ lỗi nó