सेलुलर ऑटोमेटा के लिए अनुक्रम की पहचान करना

Question

पृष्ठभूमि

इस चुनौती के प्रयोजनों के लिए, एक n-स्टेट सेलुलर ऑटोमोबोन बस एक बाइनरी फ़ंक्शन है fजो {0, 1, ..., n-1}इनपुट के रूप में सेट किए गए राज्य से दो नंबर लेता है, और आउटपुट के रूप में उस सेट से एक और नंबर देता है। इसे कम से कम 2 की लंबाई की संख्या की सूची में लागू किया जा सकता हैL = [x0, x1, x2, ..., xk-1]

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

ध्यान दें कि परिणामी सूची में मूल की तुलना में एक कम तत्व है। से शुरू करने का एक स्पेसटाइम आरेख एक सूची में बार-बार आवेदन करने और परिणाम एकत्र करने से प्राप्त सूचियों की सूची है। अंतिम सूची की लंबाई 1 है। हम कहते हैं कि सूची के लिए एक पहचान अनुक्रम है , यदि राज्य सेट पर प्रत्येक दो-तत्व सूची से शुरू होने वाले स्पेसटाइम आरेख की कुछ पंक्ति की एक सन्निहित उपसूची है । यह इस शर्त के बराबर है कि किसी भी अन्य- सीए के पास सटीक स्पेसटाइम आरेख नहीं है।fLfLLfLn

इनपुट

आपके इनपुट्स एक nहैं-n पूर्णांक मैट्रिक्स M, Lकम से कम 2 लंबाई के पूर्णांकों की एक सूची और वैकल्पिक रूप से संख्या हैं n। मैट्रिक्स Mएक को परिभाषित करता है n-state सीए fद्वारा f(a,b) = M[a][b](का उपयोग कर 0-आधारित अनुक्रमण)। यह गारंटी है कि n > 0, और वह Mऔर Lकेवल राज्य सेट के तत्व शामिल हैं {0, 1, ..., n-1}।

उत्पादन

यदि LCA के लिए एक पहचान अनुक्रम है f, और अन्यथा लगातार गलत मूल्य है, तो आपका आउटपुट एक सुसंगत सत्य मूल्य होगा । इसका मतलब यह है कि सभी "हाँ" -सांइट्स का परिणाम एक ही सत्य मूल्य में होता है, और सभी "नहीं" -स्टैंट्स एक ही मिथ्या मूल्य में परिणाम करते हैं।

उदाहरण

इनपुट पर विचार करें n = 2 , M = [[0,1],[1,0]]और L = [1,0,1,1]। मैट्रिक्स Mबाइनरी एक्सओआर ऑटोमैटोन को परिभाषित करता है f(a,b) = a+b mod 2, और इससे शुरू होने वाला स्पेसटाइम आरेख Lहै

1 0 1 1
1 1 0
0 1
1

इस आरेख में शामिल नहीं है 0 0 किसी भी पंक्ति में , इसलिए Lएक पहचान अनुक्रम नहीं है, और सही आउटपुट है False। यदि हम L = [0,1,0,0]इसके बजाय इनपुट करते हैं, तो स्पेसटाइम आरेख है

0 1 0 0
1 1 0
0 1
1

इस चित्र की पंक्तियों में राज्य सेट से खींची गई सभी जोड़ियाँ हैं, अर्थात् 0 0 , 0 1, 1 0और 1 1, इसलिए Lएक की पहचान अनुक्रम है और सही उत्पादन होता है True।

नियम

आप एक पूर्ण कार्यक्रम या एक फ़ंक्शन लिख सकते हैं। सबसे कम बाइट गिनती जीतता है, और मानक खामियों को रोक दिया जाता है।

परीक्षण के मामलों

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

Answer 1

CJam, 53 43 42 बाइट्स

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

यह परिभाषा का एक बहुत ही सीधा-सीधा कार्यान्वयन है (मैंने अपने पहले प्रयास के बाद जकुबे से कुछ प्रेरणा ली)। यह CJam- शैली सरणियों का उपयोग करके STDIN पर रिवर्स ऑर्डर में इनपुट की उम्मीद करता है:

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

यहां एक परीक्षण हार्नेस है जो सभी इनपुट के खिलाफ कोड चलाता है (उन्हें सही इनपुट प्रारूप में परिवर्तित करता है)। इनपुट क्षेत्र के परिणाम वास्तव में उपयोग नहीं किए जाते हैं। अगर आपको मुझ पर भरोसा नहीं है तो उन्हें निकाल दें। ;)

Answer 2

पायथन 2: 93 बाइट

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

सीधा कार्यान्वयन: सभी जोड़ों को जोड़कर खोजें, उन्हें बाद के लिए याद करें और एम से एल दोहराएं। पाया अद्वितीय जोड़े की संख्या की तुलना करें।

इनपुट फॉर्म का है [[0,1],[1,0]], [0,1,0,0], 2।

Answer 3

गणितज्ञ, 90 83 82 बाइट्स

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

एक और सीधा-सीधा कार्यान्वयन।

उपयोग:

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

सच