Lý lịch

Đối với mục đích của thách thức này, một nmáy tự động di độngf ở tiểu bang chỉ đơn giản là một hàm nhị phân lấy hai số từ trạng thái được đặt {0, 1, ..., n-1}làm đầu vào và trả về một số khác từ bộ đó làm đầu ra. Nó có thể được áp dụng cho một danh sách các số có độ dài ít nhất là 2L = [x0, x1, x2, ..., xk-1]

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

Lưu ý rằng danh sách kết quả có ít hơn một yếu tố so với ban đầu. Một sơ đồ không thời gian của fbắt đầu từ Llà danh sách liệt kê thu được bằng cách liên tục áp dụng fđể L, và thu thập các kết quả trong một danh sách. Danh sách cuối cùng có chiều dài 1. Chúng ta nói rằng trong danh sách Llà một chuỗi xác định cho f, nếu mỗi danh sách hai yếu tố trên tập nhà nước là một sublist tiếp giáp của một số hàng của sơ đồ không thời gian bắt đầu từ L. Điều này tương đương với điều kiện không nCA nào khác có sơ đồ không thời gian chính xác đó.

Đầu vào

Đầu vào của bạn là một n-by- nma trận số nguyên M, một danh sách các số nguyên Lcó độ dài ít nhất 2, và tùy chọn số n. Ma trận Mxác định nCA -state fbằng cách f(a,b) = M[a][b](sử dụng lập chỉ mục dựa trên 0). Nó được đảm bảo rằng n > 0, Mvà Lchỉ và chứa các thành phần của tập trạng thái {0, 1, ..., n-1}.

Đầu ra

Đầu ra của bạn sẽ là một giá trị trung thực nhất quán nếu Llà một chuỗi xác định cho CA fvà một giá trị giả mạo nhất quán khác. Điều này có nghĩa là tất cả các kết quả "có" đều dẫn đến cùng một giá trị trung thực và tất cả các kết quả "không" đều dẫn đến cùng một giá trị giả.

Thí dụ

Hãy xem xét các yếu tố đầu n = 2, M = [[0,1],[1,0]]và L = [1,0,1,1]. Ma trận Mxác định máy tự động XOR nhị phân f(a,b) = a+b mod 2và sơ đồ không thời gian bắt đầu từ Llà

1 0 1 1
1 1 0
0 1
1

Sơ đồ này không chứa 0 0trên bất kỳ hàng nào, do đó Lkhông phải là một chuỗi xác định và đầu ra chính xác là False. Nếu chúng ta nhập L = [0,1,0,0]thay thế, sơ đồ không thời gian là

0 1 0 0
1 1 0
0 1
1

Các hàng của sơ đồ này chứa tất cả các cặp rút ra từ bộ nhà nước, cụ thể là 0 0, 0 1, 1 0và 1 1, vì vậy Llà một chuỗi xác định và đầu ra đúng là True.

Quy tắc

Bạn có thể viết một chương trình đầy đủ hoặc một chức năng. Số byte thấp nhất sẽ thắng và các sơ hở tiêu chuẩn không được phép.

Các trường hợp thử nghiệm

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

Đây là một triển khai định nghĩa rất đơn giản (tôi đã lấy một số cảm hứng từ Jakube sau nỗ lực đầu tiên của tôi). Nó hy vọng đầu vào theo thứ tự ngược lại trên STDIN, sử dụng mảng kiểu CJam:

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

Dưới đây là một khai thác thử nghiệm chạy mã chống lại tất cả các đầu vào (trước tiên chuyển đổi chúng sang định dạng đầu vào chính xác). Các kết quả trong trường đầu vào không thực sự được sử dụng. Xóa chúng nếu bạn không tin tưởng tôi. ;)

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

Thực hiện đơn giản: Tìm tất cả các cặp bằng cách nén, ghi nhớ chúng sau này và áp dụng M cho L. Lặp lại. So sánh số lượng các cặp duy nhất được tìm thấy.

Đầu vào có dạng [[0,1],[1,0]], [0,1,0,0], 2.

Toán học, 90 83 82 byte

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

Một cách thực hiện đơn giản.

Sử dụng:

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

Thật