fundo

Para os propósitos deste desafio, um nautômato celular do estado é simplesmente uma função binária fque pega dois números do conjunto de estados {0, 1, ..., n-1}como entradas e retorna outro número desse conjunto como saída. Pode ser aplicado a uma lista de números de comprimento de pelo menos 2 porL = [x0, x1, x2, ..., xk-1]

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

Observe que a lista resultante possui um elemento a menos que o original. Um diagrama de espaço-tempo de fpartida Lda lista de listas obtidos por aplicação repetida fpara L, e recolher os resultados de uma lista. A lista final possui o comprimento 1. Dizemos que a lista Lé uma sequência de identificação para f, se cada lista de dois elementos no conjunto de estados for uma sub-lista contígua de alguma linha do diagrama de espaço-tempo a partir de L. Isso é equivalente à condição de que nenhuma outra nCA do estado tenha esse diagrama de espaço-tempo exato.

Entrada

Suas entradas são uma n-by- nmatriz inteiro M, uma lista de números inteiros Lde comprimento, pelo menos, duas, e, opcionalmente, o número n. A matriz Mdefine uma nCA fdo estado f(a,b) = M[a][b](usando a indexação baseada em 0). É garantido que n > 0, e que Me Lapenas contêm elementos do conjunto de estados {0, 1, ..., n-1}.

Resultado

Sua saída deve ser um valor de verdade consistente se Lfor uma sequência de identificação para a CA fe, caso contrário, um valor de falsy consistente. Isso significa que todas as instâncias "sim" resultam no mesmo valor verdadeiro e todas as instâncias "não" resultam no mesmo valor falso.

Exemplo

Considere as entradas n = 2, M = [[0,1],[1,0]]e L = [1,0,1,1]. A matriz Mdefine o autômato binário XOR f(a,b) = a+b mod 2e o diagrama de espaço-tempo a partir de Lé

1 0 1 1
1 1 0
0 1
1

Este diagrama não contém 0 0nenhuma linha, portanto, Lnão é uma sequência de identificação e a saída correta é False. Se introduzirmos L = [0,1,0,0], o diagrama de espaço-tempo é

0 1 0 0
1 1 0
0 1
1

As linhas deste diagrama de conter todos os pares retiradas do conjunto de estado, ou seja 0 0, 0 1, 1 0e 1 1, portanto, Lé uma sequência de identificação e a saída correcta é True.

Regras

Você pode escrever um programa completo ou uma função. A menor contagem de bytes vence e as brechas padrão não são permitidas.

Casos de teste

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 é uma implementação muito direta da definição (eu me inspirei em Jakube após minha primeira tentativa). Ele espera entrada na ordem inversa no STDIN, usando matrizes no estilo CJam:

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

Aqui está um chicote de teste que executa o código em todas as entradas (convertendo-as no formato de entrada correto primeiro). Os resultados no campo de entrada não são realmente usados. Remova-os se não confiar em mim. ;)

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

Implementação direta: encontre todos os pares fechando, memorize-os para mais tarde e aplique M em L. Repita. Compare o número de pares únicos encontrados.

Entrada é da 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&

Outra implementação direta.

Uso:

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

Verdade