Termos e Condições
Um worm é qualquer lista de números inteiros não negativos e seu elemento mais à direita (ou seja, o último ) é chamado de cabeça . Se a cabeça não for 0, o worm tem um segmento ativo que consiste no bloco contíguo mais longo de elementos que inclui a cabeça e tem todos os seus elementos pelo menos tão grandes quanto a cabeça . O segmento ativo reduzido é o segmento ativo com a cabeça decrementada em 1. Por exemplo, o worm 3 1 2 3 2
possui segmento ativo 2 3 2
e o segmento ativo reduzido é 2 3 1
.
Regras da evolução
Um worm evolui passo a passo da seguinte maneira:
Na etapa t (= 1, 2, 3, ...),
se o cabeçalho for 0: exclua o cabeçalho
mais: substitua o segmento ativo por t + 1 cópias concatenadas do segmento ativo reduzido.
Fato : Qualquer worm acaba evoluindo para a lista vazia , e o número de etapas para isso é a vida útil do worm .
(Detalhes podem ser encontrados em The Worm Principle , um artigo de LD Beklemishev. O uso de "list" para significar uma sequência finita e "head" para significar seu último elemento, são retirados deste artigo - ele não deve ser confundido com o uso comum de listas como um tipo de dados abstrato , onde head geralmente significa o primeiro elemento.)
Exemplos (segmento ativo entre parênteses)
Verme: 0,1
step worm
0(1)
1 0 0 0
2 0 0
3 0
4 <- lifetime = 4
Verme: 1,0
step worm
1 0
1 (1)
2 0 0 0
3 0 0
4 0
5 <- lifetime = 5
Verme: 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
Verme: 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
Verme: 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 = ??
Verme: 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 = ??
a parte, de lado
A vida útil do worm é tipicamente enorme, como mostra os seguintes limites inferiores em termos da hierarquia padrão de funções de crescimento rápido 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)
Notavelmente, o worm [3] já tem uma vida útil que ultrapassa em muito o número de Graham , G:
f ω ω (2) = f ω 2 (2) = f ω2 (2) = f ω + 2 (2) = f ω + 1 (f ω + 1 (2)) >> f ω + 1 (64) > G.
Code Golf Challenge
Escreva o subprograma de função mais curto possível com o seguinte comportamento:
Entrada : Qualquer verme.
Saída : a vida útil do worm.O tamanho do código é medido em bytes.
Aqui está um exemplo (Python, golfs to 167 bytes):
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
NB : Se t (n) é a vida útil do worm [n], a taxa de crescimento de t (n) é aproximadamente a da função Goodstein . Então, se isso pode ser golfed abaixo de 100 bytes, ele poderia muito bem dar uma resposta vencedora para o maior número Printable questão . (Para essa resposta, a taxa de crescimento pode ser muito acelerada sempre iniciando o contador de passos em n - o mesmo valor que o worm [n] - em vez de iniciá-lo em 0.)
2 1
poderia ser pedir muito em um tempo razoável, mas um teste útil é que a seqüência deve começar (2 1)
, 2 0 2 0
, 2 0 (2)
, 2 0 (1 1 1 1)
, ...
w[0]
* que é o elemento mais à esquerda dessa lista?