sfondo

Ai fini di questa sfida, un nautoma cellularef statale è semplicemente una funzione binaria che accetta due numeri dallo stato impostato {0, 1, ..., n-1}come input e restituisce un altro numero da tale set come output. Può essere applicato a un elenco di numeri di lunghezza almeno 2 diL = [x0, x1, x2, ..., xk-1]

f(L) = [f(x0, x1), f(x1, x2), f(x2, x3), ..., f(xk-2, xk-1)]

Si noti che l'elenco risultante ha un elemento in meno rispetto all'originale. Un diagramma spazio-temporale di fpartire da Luna lista degli elenchi ottenuti da applicare ripetutamente fa L, e raccogliendo i risultati in un elenco. L'elenco finale ha lunghezza 1. Diciamo che l'elenco Lè una sequenza identificativa per f, se ogni elenco di due elementi sopra l'insieme di stati è un sottoelenco contiguo di una riga del diagramma dello spaziotempo a partire da L. Ciò equivale alla condizione che nessun altro stato nCA abbia quel diagramma spazio-tempo esatto.

Ingresso

Gli ingressi sono un n-by- nmatrice numero intero M, un elenco di interi Ldi lunghezza almeno 2, e facoltativamente il numero n. La matrice Mdefinisce una nCA statale fmediante f(a,b) = M[a][b](utilizzando l'indicizzazione basata su 0). È garantito che n > 0, e che Me Lcontengono solo elementi dello stato impostato {0, 1, ..., n-1}.

Produzione

L'output deve essere un valore di verità coerente se Lè una sequenza identificativa per la CA fe un valore di falsa coerente in caso contrario. Ciò significa che tutte le istanze "sì" danno lo stesso valore di verità e tutte le istanze "no" danno lo stesso valore di falsità.

Esempio

Considerare gli ingressi n = 2, M = [[0,1],[1,0]]e L = [1,0,1,1]. La matrice Mdefinisce l'automa XOR binario f(a,b) = a+b mod 2e il diagramma dello spaziotempo a partire da Lè

1 0 1 1
1 1 0
0 1
1

Questo diagramma non contiene 0 0alcuna riga, quindi Lnon è una sequenza identificativa e l'output corretto è False. Se L = [0,1,0,0]invece inseriamo , il diagramma dello spaziotempo è

0 1 0 0
1 1 0
0 1
1

Le righe di questo diagramma contengono tutte le coppie presenti nel set di stato, cioè 0 0, 0 1, 1 0e 1 1, quindi Lè una sequenza di identificazione e l'uscita corretta è True.

Regole

È possibile scrivere un programma completo o una funzione. Vince il conteggio di byte più basso e non sono consentite scappatoie standard.

Casi test

Trivial automaton
[[0]] [0,0] 1 -> True
Binary XOR
[[0,1],[1,0]] [1,0,1,1] 2 -> False
[[0,1],[1,0]] [1,0,1,0] 2 -> True
[[0,1],[1,0]] [0,1,0,0] 2 -> True
Addition mod 3
[[0,1,2],[1,2,0],[2,0,1]] [0,1,1,0,0,0,1,0,0] 3 -> False
[[0,1,2],[1,2,0],[2,0,1]] [0,1,1,0,0,0,1,0,1] 3 -> True
Multiplication mod 3
[[0,0,0],[0,1,2],[0,2,1]] [0,1,1,2,0,0,1,0,1] 3 -> False
[[0,0,0],[0,1,2],[0,2,1]] [0,1,1,2,2,2,1,0,1] 3 -> True
Some 4-state automata
[[3,2,2,1],[0,0,0,1],[2,1,3,1],[0,1,2,3]] [0,0,0,0,1,1,1,1] 4 -> False
[[3,2,2,1],[0,0,0,1],[2,1,3,1],[0,1,2,3]] [0,0,0,1,0,1,1,1] 4 -> False
[[3,2,2,1],[0,0,0,1],[2,1,3,1],[0,1,2,3]] [0,1,2,3,3,1,2,3,0] 4 -> True
[[0,1,2,1],[1,0,2,0],[2,2,1,0],[1,2,0,0]] [0,0,1,1,2,2,0,2,1] 4 -> False
[[0,1,2,1],[1,0,2,0],[2,2,1,0],[1,2,0,0]] [0,3,1,3,2,3,3,0,1] 4 -> False
[[0,1,2,1],[1,0,2,0],[2,2,1,0],[1,2,0,0]] [0,3,1,3,2,3,3,0,1,2] 4 -> True

CJam, 53 43 42 byte

l~:M;_,({_[\1>]zW<_{M\{=}/}%}*;](_*\L*_&,=

Questa è un'implementazione molto diretta della definizione (ho preso ispirazione da Jakube dopo il mio primo tentativo). Si aspetta input in ordine inverso su STDIN, usando array in stile CJam:

2 [1 0 1 1] [[0 1][1 0]]

Ecco un cablaggio di prova che esegue il codice su tutti gli input (convertendoli prima nel formato di input corretto). I risultati nel campo di input non sono effettivamente utilizzati. Rimuovili se non ti fidi di me. ;)

Python 2: 93 byte

M,L,n=input();a=[]
while L:z=zip(L,L[1:]);a+=z;L=[M[i][j]for i,j in z]
print len(set(a))==n*n

Implementazione semplice: trova tutte le coppie zippando, memorizzale per dopo e applica M a L. Ripeti. Confronta il numero di coppie uniche trovate.

L'input è nella forma [[0,1],[1,0]], [0,1,0,0], 2.

Mathematica, 90 83 82 byte

f=Length[Union@@Last@Reap[#2//.l_List:>Extract[#,Sow/@Partition[l+1,2,1]]]]==#3^2&

Un'altra implementazione diretta.

Uso:

f[{{0, 1}, {1, 0}}, {0, 1, 0, 0}, 2]

Vero