termes
Un ver est une liste d'entiers non négatifs, et son élément le plus à droite (c'est-à-dire le dernier ) est appelé la tête . Si la tête n'est pas égale à 0, le ver a un segment actif constitué du bloc d'éléments contigu le plus long qui comprend la tête et a tous ses éléments au moins aussi grands que la tête . Le segment actif réduit est le segment actif avec la tête décrémentée de 1. Par exemple, le ver 3 1 2 3 2
a un segment actif 2 3 2
et le segment actif réduit l'est 2 3 1
.
Règles d'évolution
Un ver évolue pas à pas comme suit:
A l'étape t (= 1, 2, 3, ...),
si la tête est 0: supprimez la tête
sinon: remplacez le segment actif par t + 1 copies concaténées du segment actif réduit.
Réalité : tout ver finit par évoluer vers la liste vide , et le nombre d'étapes pour le faire est la durée de vie du ver .
(Voir les détails se trouvent dans le ver Principe ., Un papier par LD Beklemishev L'utilisation de « liste » pour signifier une séquence finie, et « tête » pour signifier son dernier élément, est tiré de ce papier - il ne faut pas confondre avec l'utilisation courante des listes comme type de données abstrait , où head signifie généralement le premier élément.)
Exemples (segment actif entre parenthèses)
Ver: 0,1
step worm
0(1)
1 0 0 0
2 0 0
3 0
4 <- lifetime = 4
Ver: 1,0
step worm
1 0
1 (1)
2 0 0 0
3 0 0
4 0
5 <- lifetime = 5
Ver: 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
Ver: 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
Ver: 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 = ??
Ver: 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 = ??
De côté
Les durées de vie des vers sont généralement énormes, comme le montrent les limites inférieures suivantes en termes de hiérarchie standard à croissance rapide des fonctions 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)
Remarquablement, le ver [3] a déjà une durée de vie qui dépasse de loin le nombre 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
Écrivez le sous-programme de fonction le plus court possible avec le comportement suivant:
Entrée : tout ver.
Sortie : la durée de vie du ver.La taille du code est mesurée en octets.
Voici un exemple (Python, golfs à environ 167 octets):
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 : Si t (n) est la durée de vie du ver [n], alors le taux de croissance de t (n) est à peu près celui de la fonction de Goodstein . Donc, si cela peut être joué à moins de 100 octets, cela pourrait bien donner une réponse gagnante à la question imprimable du plus grand nombre . (Pour cette réponse, le taux de croissance pourrait être considérablement accéléré en démarrant toujours le compteur de pas à n - la même valeur que le ver [n] - au lieu de le démarrer à 0.)
2 1
peut - être trop demander dans un délai raisonnable, mais un test utile est que la séquence doit commencer (2 1)
, 2 0 2 0
, 2 0 (2)
, 2 0 (1 1 1 1)
, ...
w[0]
élément qui est * le plus à gauche de cette liste?