Le navire de Thésée est une vieille question qui ressemble à:

Si un navire a fait remplacer toutes ses pièces d'origine, est-ce toujours le même navire?

Pour ce golf, nous allons remplacer lentement les «pièces» sur un «navire» et voir combien de temps il faut pour obtenir un tout nouveau navire.

Tâche

Un navire est composé d'au moins deux parties. Les pièces sont données sous la forme d'un tableau d'entiers positifs (non nuls), représentant l'état de la pièce.

À chaque cycle, choisissez au hasard une partie de la liste de manière uniforme. L'état de cette pièce sera réduit de un. Lorsque l'état d'une pièce atteint zéro, elle est remplacée par une nouvelle pièce. La nouvelle pièce commence avec la même valeur de condition que l'original.

Lors du premier cycle où toutes les pièces ont été remplacées (au moins) une fois, arrêtez et affichez le nombre de cycles nécessaires.

Par exemple (supposons que je choisis des pièces au hasard ici):

2 2 3  <- starting part conditions (input)
2 1 3  <- second part reduced
2 1 2  ...
2 1 1 
2 2 1  <- second part reduced to zero, replaced
1 2 1 
1 2 3  <- third part replaced
1 1 3 
2 1 3  <- first part replaced

La sortie pour cet exemple serait 8, car il a fallu huit cycles pour que toutes les pièces soient remplacées. La sortie exacte doit différer pour chaque exécution.

E / S

La seule entrée est la liste / tableau d'entiers pour l'état de la pièce. La seule sortie est un certain nombre de cycles. Vous pouvez prendre / donner ces valeurs de l'une des manières habituelles: STDIO, arguments / retours de fonction, etc.

Cas de test

Étant donné que la sortie n'est pas fixe, vous pouvez utiliser tout ce que vous voulez tester, mais voici quelques exemples à des fins de normalisation:

1 2 3 4

617 734 248 546 780 809 917 168 130 418

19384 74801 37917 81706 67361 50163 22708 78574 39406 4051 78099 7260 2241 45333 92463 45166 68932 54318 17365 36432 71329 4258 22026 23615 44939 74894 19257 49875 39764 62550 23750 4731 54121 8386 45639 54604 77456 58661 34476 49875 35689 5311 19954 80976 9299 59229 95748 42368 13721 49790

Pyth, 12 octets

f!eSXOUQQtZ1

Manifestation.

Comment ça fonctionne:

Ceci est basé sur le filtre infini de Pyth, qui teste une expression avec des entrées croissantes jusqu'à ce qu'elle retourne quelque chose de vrai, puis retourne l'entrée qui a provoqué cela. Cependant, l'expression qui sera testée n'utilisera pas la valeur d'entrée.

Au lieu de cela, l'expression modifiera la liste d'entrée en décrémentant une entrée aléatoire. Ceci est accompli via l'expression XOUQQtZ. Cela signifie augmenter l'index OUQde la liste Qde tZ. OUQest un indice aléatoire de la longueur de Q, et tZest -1. Qest initialisé dans la liste d'entrée.

Après avoir modifié Qde cette façon, nous prenons sa valeur actuelle, qui Xrevient, prenons son entrée maximale avec eS, et prenons le pas logique de cette valeur avec !. Cela renvoie une valeur véridique pour la première fois lorsque chaque élément de Qa été réduit à 0ou en dessous pour la première fois.

Pour nous assurer que le nombre renvoyé sera exactement le nombre de fois qui a Qété modifié, nous allons commencer le décompte à 1, indiquant la première fois que cela est appelé, il y a eu 1 modification. Pour voir à quoi Qressemble après chaque itération du code, consultez la version ici .

GolfScript ( 26 24 octets) / CJam ( 20 18 octets)

GolfScript:

~{$)*}{.,rand{(+}*((+}/,

Démo en ligne

CJam (même idée mais implémentation légèrement différente):

q~{_mr((+_$)*}g;],

Démo en ligne

L'entrée est sur stdin dans le formulaire [2 2 3].

C'est l' une de ces rares occasions où GolfScript de déplier opérateur est utile. Il nous permet d'accumuler les états traversés par le navire, puis de les compter à la fin. Notez que le tableau qui est compté comprend l'état initial (entrée) mais pas l'état final dans lequel le dernier élément a été réduit à 0.

Cependant, bien que CJAM ne pas déplier sa capacité à mélanger un tableau uniformément pour seulement 2 CHARS compte pour beaucoup et lui permet de sortir par le haut.

Python 3, 91 71 octets

20 (!) Octets enregistrés grâce à @xnor.

from random import*
def f(p):shuffle(p);p[0]-=1;return max(p)<1or-~f(p)

Fonction récursive s'appelant avec des valeurs de pièce plus petites jusqu'à ce que toutes les valeurs de pièce soient 0 ou négatives et que chaque fonction renvoie la valeur de retour de son enfant + 1 et la dernière appelée renvoie 1.

Python 3, 175 octets

import random
p,t=input().split(),0;f,r=[int(i)for i in p],[0]*len(p)
while 0 in r:
 f[random.randint(0,len(f)-1)]-=1;t+=1
 for x in range(len(f)):
  r[x]=int(f[x]<1)
print(t)

Pas particulièrement bien joué .

Essayez-le en ligne ici