La nave di Teseo è una vecchia domanda che si presenta come:

Se a una nave sono state sostituite tutte le sue parti originali, è sempre la stessa nave?

Per questo golf, sostituiremo lentamente le "parti" su una "nave" e vedremo quanto tempo impiegherà per ottenere una nave completamente nuova.

Compito

Una nave è composta da almeno due parti. Le parti sono fornite come una matrice di numeri interi positivi (diversi da zero), che rappresentano le condizioni della parte.

Ad ogni ciclo, scegli casualmente una parte dall'elenco in modo uniforme. Le condizioni di quella parte saranno ridotte di una. Quando la condizione di una parte raggiunge lo zero, viene sostituita da una nuova parte. La nuova parte inizia con lo stesso valore di condizione dell'originale.

Nel primo ciclo in cui tutte le parti sono state sostituite (almeno) una volta, arrestare ed emettere il numero di cicli necessari.

Ad esempio (supponiamo che io scelga parti casualmente qui):

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

L'output per questo esempio sarebbe 8, poiché ci sono voluti otto cicli per sostituire tutte le parti. L'output esatto dovrebbe differire per ogni serie.

I / O

L'unico input è la lista / matrice di numeri interi per la condizione della parte. L'unico output è un numero di cicli. Puoi prendere / dare questi valori in uno dei modi usuali: STDIO, argomenti / ritorni di funzione, ecc.

Casi test

Poiché l'output non è stato risolto, è possibile utilizzare tutto ciò che si desidera testare, ma ecco un paio per scopi di standardizzazione:

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 byte

f!eSXOUQQtZ1

Dimostrazione.

Come funziona:

Questo si basa sull'infinito filtro di Pyth, che verifica un'espressione con input crescenti fino a quando non restituisce qualcosa di vero, quindi restituisce l'input che ha causato ciò. Tuttavia, l'espressione che verrà testata non utilizzerà il valore di input.

Al contrario, l'espressione modificherà l'elenco di input diminuendo una voce casuale. Questo si ottiene tramite l'espressione XOUQQtZ. Ciò significa aumentare l'indice OUQnell'elenco Qdi tZ. OUQè un indice casuale della lunghezza di Q, ed tZè -1. Qè inizializzato all'elenco di input.

Dopo aver modificato Qin questo modo, prendiamo il suo valore corrente, che Xritorna, prendiamo la sua voce massima con eSe prendiamo la logica non di quel valore con !. Ciò restituisce un valore veritiero per la prima volta quando ogni elemento di Qè stato ridotto 0o inferiore per la prima volta.

Per garantire che il numero restituito sia esattamente il numero di volte che è Qstato modificato, inizieremo il conteggio a 1, indicando la prima volta che viene chiamato, ci sono state 1 modifiche. Per vedere come Qappare dopo ogni iterazione del codice, controlla qui la versione .

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

GolfScript:

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

Demo online

CJam (stessa idea ma implementazione leggermente diversa):

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

Demo online

L'input è su stdin nel modulo [2 2 3].

Questa è una di quelle rare occasioni in cui di GolfScript dispiegarsi operatore è utile. Ci permette di accumulare gli stati attraverso i quali passa la nave e poi contarli alla fine. Si noti che l'array che viene conteggiato include lo stato iniziale (input) ma non lo stato finale in cui l'ultimo elemento è stato ridotto a 0.

Tuttavia, anche se CJam non ha Unfold la sua capacità di mescolare una matrice uniforme per soli 2 caratteri conta molto e gli permette di uscire in cima.

Python 3, 91 71 byte

20 (!) Byte salvati grazie a @xnor.

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

La funzione ricorsiva si chiama con valori di pezzo più piccoli fino a quando tutti i valori di pezzo sono 0 o negativi e ogni funzione restituisce il valore di ritorno del proprio figlio + 1 e l'ultimo chiamato restituisce 1.

Python 3, 175 byte

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)

Non particolarmente ben golfato .

Provalo online qui