Hintergrund

Für die Zwecke dieser Herausforderung ist ein nzellularer Automat mit einfachem fZustand einfach eine Binärfunktion , die zwei Zahlen aus dem {0, 1, ..., n-1}als Eingaben eingestellten Zustand nimmt und eine andere Zahl aus dieser Menge als Ausgabe zurückgibt. Es kann auf eine Liste von Zahlen mit einer Länge von mindestens 2 mal angewendet werdenL = [x0, x1, x2, ..., xk-1]

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

Beachten Sie, dass die resultierende Liste ein Element weniger enthält als das Original. Ein Raumzeitdiagramm zum fStarten von List die Liste der Listen, die durch wiederholtes Anwenden fauf Lund Sammeln der Ergebnisse in einer Liste erhalten werden. Die endgültige Liste hat die Länge 1. Wir sagen, dass die Liste Leine identifizierende Sequenz für ist f, wenn jede Liste mit zwei Elementen über dem Statussatz eine zusammenhängende Unterliste einer Zeile des Raumzeitdiagramms ist, beginnend mit L. Dies entspricht der Bedingung, dass keine andere nCA mit genauem Raumzeitdiagramm vorliegt.

Eingang

Ihre Eingänge sind eine n-by- nganzzahlige Matrix M, wird eine Liste von ganzen Zahlen mit Leiner Länge von mindestens 2 ist , und gegebenenfalls die Zahl n. Die Matrix Mdefiniert eine nCA fmit dem Status " f(a,b) = M[a][b](unter Verwendung der 0-basierten Indizierung). Es ist garantiert, dass n > 0und dass Mund Lnur Elemente der Zustandsmenge enthalten sind {0, 1, ..., n-1}.

Ausgabe

Ihre Ausgabe muss ein konsistenter Wahrheitswert sein, wenn Les sich um eine identifizierende Sequenz für die fZertifizierungsstelle handelt, und ansonsten ein konsistenter Falschwert. Dies bedeutet, dass alle "Ja" -Instanzen den gleichen Wahrheitswert und alle "Nein" -Instanzen den gleichen Falschwert ergeben.

Beispiel

Betrachten Sie die Eingänge n = 2, M = [[0,1],[1,0]]und L = [1,0,1,1]. Die Matrix Mdefiniert die binären XOR - Automaten f(a,b) = a+b mod 2, und das Raum - Zeit - Diagramm von Ausgang LIST

1 0 1 1
1 1 0
0 1
1

Dieses Diagramm enthält 0 0keine Zeile, List also keine identifizierende Sequenz und die richtige Ausgabe ist False. Wenn wir L = [0,1,0,0]stattdessen eingeben, ist das Raumzeitdiagramm

0 1 0 0
1 1 0
0 1
1

Die Zeilen dieses Diagramms alle Paare von den Zustand versetzt gezeichnet enthalten, nämlich 0 0, 0 1, 1 0und 1 1, so List eine Identifizierungssequenz und die korrekte Ausgabe ist True.

Regeln

Sie können ein vollständiges Programm oder eine Funktion schreiben. Die niedrigste Byteanzahl gewinnt und Standardschlupflöcher sind nicht zulässig.

Testfälle

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*_&,=

Dies ist eine sehr einfache Implementierung der Definition (ich habe mich nach meinem ersten Versuch von Jakube inspirieren lassen). Es erwartet eine Eingabe in umgekehrter Reihenfolge auf STDIN unter Verwendung von Arrays im CJam-Stil:

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

Hier ist ein Testkabelbaum , der den Code für alle Eingaben ausführt (zuerst in das richtige Eingabeformat konvertiert). Die Ergebnisse im Eingabefeld werden nicht verwendet. Entferne sie, wenn du mir nicht vertraust. ;)

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

Einfache Implementierung: Finden Sie alle Paare durch Zippen, merken Sie sie sich für später und wenden Sie M auf L an. Wiederholen. Vergleichen Sie die Anzahl der gefundenen eindeutigen Paare.

Die Eingabe erfolgt in der Form [[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&

Eine weitere einfache Implementierung.

Verwendungszweck:

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

Wahr