Antecedentes

Para los propósitos de este desafío, un nautómata celular de estado es simplemente una función binaria fque toma dos números del estado establecido {0, 1, ..., n-1}como entradas y devuelve otro número de ese conjunto como salida. Se puede aplicar a una lista de números de longitud de al menos 2 porL = [x0, x1, x2, ..., xk-1]

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

Tenga en cuenta que la lista resultante tiene un elemento menos que el original. Un diagrama espacio-tiempo de fpartir de Lla lista de listas obtenidos aplicando repetidamente fa L, y la recogida de los resultados en una lista. La lista final tiene longitud 1. Decimos que la lista Les una secuencia de identificación para f, si cada lista de dos elementos sobre el conjunto de estados es una sublista contigua de alguna fila del diagrama de espacio-tiempo a partir de L. Esto es equivalente a la condición de que ninguna otra nCA estatal tenga ese diagrama de espacio-tiempo exacto.

Entrada

Sus entradas son un n-by- nmatriz de número entero M, una lista de números enteros Lde longitud al menos 2, y, opcionalmente, el número n. La matriz Mdefine una nCA de estado fmediante f(a,b) = M[a][b](usando indexación basada en 0). Se garantiza eso n > 0, y eso My Lsolo contiene elementos del conjunto de estados {0, 1, ..., n-1}.

Salida

Su salida será un valor de verdad consistente si Les una secuencia de identificación para la CA f, y un valor de falsedad consistente de lo contrario. Esto significa que todas las instancias "sí" dan como resultado el mismo valor verdadero y todas las instancias "no" dan como resultado el mismo valor falso.

Ejemplo

Considere las entradas n = 2, M = [[0,1],[1,0]]y L = [1,0,1,1]. La matriz Mdefine el autómata XOR binario f(a,b) = a+b mod 2, y el diagrama de espacio-tiempo a partir de Les

1 0 1 1
1 1 0
0 1
1

Este diagrama no contiene 0 0ninguna fila, por Llo que no es una secuencia de identificación, y la salida correcta es False. Si ingresamos en su L = [0,1,0,0]lugar, el diagrama espacio-tiempo es

0 1 0 0
1 1 0
0 1
1

Las filas de este diagrama contienen todos los pares extraídos del conjunto de estado, a saber 0 0, 0 1, 1 0y 1 1, por lo Les una secuencia de identificación y la salida correcta es True.

Reglas

Puede escribir un programa completo o una función. El conteo de bytes más bajo gana, y las lagunas estándar no se permiten.

Casos de prueba

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 bytes

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

Esta es una implementación muy directa de la definición (me inspiré un poco en Jakube después de mi primer intento). Se espera la entrada en orden inverso en STDIN, utilizando matrices de estilo CJam:

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

Aquí hay un arnés de prueba que ejecuta el código contra todas las entradas (convirtiéndolas primero al formato de entrada correcto). Los resultados en el campo de entrada no se usan realmente. Elimínalos si no confías en mí. ;)

Python 2: 93 bytes

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

Implementación directa: encuentre todos los pares comprimiendo, memorícelos para más adelante y aplique M a L. Repita. Compara el número de pares únicos encontrados.

La entrada es de la forma [[0,1],[1,0]], [0,1,0,0], 2.

Mathematica, 90 83 82 bytes

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

Otra implementación directa.

Uso:

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

Cierto