मॉड-फोल्ड को पहचानें

Question

कार्य

एक परिभाषित आधुनिक गुना फार्म के एक समारोह के रूप f (x) = एक्स% एक ₁  % एक ₂  % ...% एक _{कश्मीर} , जहां एक _मैं धनात्मक पूर्णांक और कर रहे हैं कश्मीर ≥ 0 । (यहां, % बाएं-सहयोगी मॉडुलो ऑपरेटर है।)

की एक सूची को देखते हुए n पूर्णांक y ₀ , ..., वाई _n-1 , यदि वहां मौजूद एक आधुनिक गुना निर्धारित च ताकि प्रत्येक y _मैं  = च (i) ।

आप अपने फ़ंक्शन / प्रोग्राम के लिए किसी भी दो आउटपुट Y और N को चुन सकते हैं और ठीक कर सकते हैं । यदि ऐसी कोई एफ मौजूद है , तो आपको हमेशा वाई को वापस करना होगा / प्रिंट करना होगा ; यदि नहीं, तो आपको हमेशा एन को वापस / प्रिंट करना होगा । (ये हो सकता है true/ false, या 1/ 0, या false/ true, आदि) अपने जवाब में इन का उल्लेख करें।

बाइट्स में सबसे कम सबमिशन जीतता है।

उदाहरण

F (x) = x% 7% 3 को परिभाषित करें । इसके मूल्य शुरू होते हैं:

|   x  | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | ...
| f(x) | 0 | 1 | 2 | 0 | 1 | 2 | 0 | 0 | 1 | 2 | ...

इस प्रकार, 0 1 2 0 1 2 0 0 1 2हमारे समाधान के इनपुट के रूप में, हम Y को प्रिंट करेंगे, क्योंकि यह f उस क्रम को उत्पन्न करता है। हालाँकि, 0 1 0 1 2इनपुट के रूप में, हम N को प्रिंट करेंगे, क्योंकि कोई भी f उस क्रम को उत्पन्न नहीं करता है।

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

जब आउटपुट Y होता है तब दिए गए सूत्र केवल संदर्भ के लिए होते हैं; आपको किसी भी बिंदु पर उन्हें प्रिंट नहीं करना चाहिए।

0 1 2 3 4 5              Y    (x)
1                        N
0 0 0                    Y    (x%1)
0 1 2 0 1 2 0 0 1 2      Y    (x%7%3)
0 0 1                    N
0 1 2 3 4 5 6 0 0 1 2    Y    (x%8%7)
0 1 2 0 1 2 0 1 2 3      N
0 2 1 0 2 1 0 2 1        N
0 1 0 0 0 1 0 0 0 0 1    Y    (x%9%4%3%2)

Comments

क्या कोई समय या स्मृति सीमाएं हैं?

— डेनिस

क्या मैं इसके बजाय सत्य मूल्यों और गलत मूल्यों का उत्पादन कर सकता हूं?

— लीक नन

@ कमज़ोर मैं नहीं बल्कि आप चाहते हैं। मैं सत्य-असत्य का बहुत बड़ा प्रशंसक नहीं हूं; मैं स्पष्ट रूप से इसे और अधिक उद्देश्य विकल्प के रूप में आज़मा रहा हूं जो आपको अभी भी स्वतंत्रता देता है।

— लिन

@ लियन यह सिर्फ मैं हूं या आपने अभी भी इसे ठीक नहीं किया है?

— लीके नन

स्मृति / समय की कमी के बारे में: मुझे नहीं लगता कि मैं किसी भी चुनौती के लिए खुद को जोड़ूंगा, लेकिन मैं बाइट्स में सबसे कम उत्तर के लिए एक इनाम चला सकता हूं जो मेरे प्रत्येक परीक्षण मामलों में से कुछ का जवाब उचित समय लंबाई में दे सकता है।

— लिन

Answer 1

अजगर, 14 बाइट्स

}Qm%M+RdUQy_Sl

लौटता है True/False। इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

स्पष्टीकरण:

}Qm%M+RdUQy_SlQ   implicit Q (=input) at the end
             lQ   length of input list
            S     create the list [1, 2, ..., len]
           _      reverse => [len, ..., 2, 1]
          y       generate all subsets (these are all possible mod-folds)
  m               map each subset d to:
        UQ           take the range [0, 1, ..., len-1]
     +Rd             transform each number into a list by prepending it to d
                     e.g. if mod-fold = [7,3], than it creates:
                        [[0,7,3], [1,7,3], [2,7,3], [3,7,3], ...]
   %M                fold each list by the modulo operator
                  this gives all possible truthy sequences of length len
}Q                so checking if Q appears in the list returns True or False

अजगर, 11 बाइट्स

q%M.e+k_tx0

@ फेरसुम के विचार के आधार पर । मैंने वास्तव में सबसेट पीढ़ी के लिए शून्य-सूचकांकों का उपयोग करने के बारे में सोचा था, लेकिन यह महसूस नहीं किया कि सभी शून्य-सूचकांकों को पहले से ही समाधान होना चाहिए।

Answer 2

पायथन 3, 239 218 बाइट्स

from itertools import*
lambda z:z in[[eval(''.join([str(l)]+['%'+str(i[::-1][k])for k in range(len(i))]))for l in range(len(z))]for i in(i for j in(combinations(range(1,len(z)+1),i+1)for i in range(len(z)))for i in j)]

एक अनाम फ़ंक्शन जो किसी सूची का इनपुट लेता है zऔर रिटर्न Trueया के Falseलिए Yऔर N।

यह @Jakube के उत्तर के समान एक विधि का उपयोग करता है , और यद्यपि यह अनिवार्य रूप से एक क्रूर बल है, बहुत तेज़ी से चलता है।

from itertools import*               Import everything from the Python module for
                                     iterable generation
lambda z                             Anonymous function with input list z
combinations(range(1,len(z)+1),i+1)  Yield all sorted i+1 length subsets of the range
                                     [1,len(z)]...
...for i in range(len(z))            ...for all possible subset lengths
(i for j in(...)for i in j)          Flatten, yielding an iterator containing all possible
                                     mod-fold values as separate lists
...for i in...                       For all possible mod-fold values...
...for k in range(len(i))            ...for all mod-fold values indices k...
...for l in range(len(z))            ...for all function domain values in [0,len(z)-1]...
[str(l)]+['%'+str(i[::-1][k])...]    ...create a list containing each character of the
                                     expression representing the function defined by the
                                     mod-fold values (reversed such that the divisors
                                     decrease in magnitude) applied to the domain value...
 eval(''.join(...))                  ...concatenate to string and evaluate...
 [...]                               ...and pack all the values for that particular
                                     function as a list
 [...]                               Pack all lists representing all functions into a list
 ...:z in...                         If z is in this list, it must be a valid mod-fold, so
                                     return True. Else, return False

Ideone पर इसे आज़माएं

Answer 3

पायथन 2, 69 बाइट्स

f=lambda a,i=0:i/len(a)or a[i]in[a[i-1]+1,i,0][i<=max(a)::2]*f(a,i+1)

उपयोग करता है True/ False।

एक मॉड-फोल्डेबल श्रृंखला की विशेषता क्या है इसका जवाब पहले की तुलना में कम दिलचस्प लगता है। यह फॉर्म 0, 1, ..., M - 1, 0, 1, ... x ₁ , 0, 1, ..., x ₂ , ... की एक श्रंखला है , जैसे कि सभी i, 0 के लिए। <= x _i <एम। इस तरह के अनुक्रम को सरणी में शून्य के सभी (0-आधारित) सूचकांकों के मॉड श्रृंखला द्वारा उत्पादित किया जा सकता है, पहले को छोड़कर।

Answer 4

जेली , 19 15 14 बाइट्स

LṗLUZ’1¦%/sLe@

सत्य के लिए 1 लौटाता है , 0 झूठे के लिए। इसे ऑनलाइन आज़माएं!

एल्गोरिथ्म O (n ⁿ ) है , जहां n सूची की लंबाई है, यह अधिकांश परीक्षण मामलों के लिए बहुत धीमा और स्मृति-गहन है।

एक संशोधित संस्करण - जो दूसरे के Lसाथ बदल देता है 5- का उपयोग सभी परीक्षण मामलों को सत्यापित करने के लिए किया जा सकता है । ध्यान दें कि यह संशोधित संस्करण मनमाने ढंग से लंबी सूचियों के लिए काम नहीं करेगा।

यह काम किस प्रकार करता है

LṗLUZ’1¦%/sLe@  Main link. Argument: A (array of integers)

L L             Yield the length l of A.
 ṗ              Take the l-th Cartesian power of [1, ..., l], i.e., construct
                all arrays of length l that consist of elements of [1, ..., l].
   U            Upend/reverse each array. This way, the first l arrays start
                with [1, ..., l], as do the next l arrays, etc.
    Z           Zip/transpose the array of arrays.
     ’1¦        Decrement the first array to map [1, ..., l] to [0, ..., l - 1].
        %/      Reduce the array's columns by modulus/residue.
          sL    Split the result into chunks of length l.
            e@  Verify if A belongs to the resulting array.

Comments

क्या आप एक स्पष्टीकरण जोड़ सकते हैं? जैसा कि किसी ने जेली (अभी तक) का उपयोग नहीं किया है, मुझे नहीं पता कि यह कैसे काम करता है।

— स्टीवन एच।

जैसे ही मैं गोल्फ कर रहा हूँ, मैं एक जोड़ दूंगा। अभी भी कुछ चीजें हैं जिन्हें मैं पहले आजमाना चाहता हूं।

— डेनिस

मैंने एक स्पष्टीकरण दिया है (और दिया है)।

— डेनिस

Answer 5

जावास्क्रिप्ट (ईएस 6), 98 बाइट्स

a=>a.every((n,i)=>n?n<(l+=p==i)&&n==p++:p=1,l=p=1)

@ फेरेसम की खोज पर स्विच करके 48 बाइट्स को बचाया। nसरणी में कोई भी दिया गया मान या तो शून्य है, जिस स्थिति में अगली भविष्यवाणी p1 है, या यह अगली भविष्यवाणी के बराबर है, जिस स्थिति pमें वेतन वृद्धि होती है। हम यह भी लंबाई को मापने lकी तुलना द्वारा प्रारंभिक दृश्य के pलिए i, के रूप में nकरना चाहिए हमेशा से भी कम हो lहर समय।

Answer 6

पायथन 2, 103 99 बाइट्स

f=lambda l,r:r==x or l and f(l-1,[t%l for t in r])|f(l-1,r)
x=input();l=len(x);print+f(l,range(l))

सच्चाई के लिए 1 प्रिंट और झूठी के लिए 0 । Ideone पर इसका परीक्षण करें ।