27

1S और -1s की सूची को देखते हुए , यह निर्धारित करें कि यह एक वैध OVSF कोड है या नहीं (सत्य या गलत तरीके से आउटपुट करके)।

OVSF कोड निम्नानुसार परिभाषित किए गए हैं:

[1] एक OVSF कोड है।
तो X, एक OVSF कोड है तो X ++ Xऔर X ++ -Xदोनों OVSF कोड हैं।

यहां ++सूची समाकलन है, और -सूची में प्रत्येक तत्व को नकार दिया गया है।
कोई अन्य सूची मान्य OVSF कोड नहीं हैं।

आप मान सकते हैं कि इनपुट सूची में केवल -1और है 1, लेकिन आपको खाली सूची को सही ढंग से संभालना चाहिए, साथ ही उन सूचियों को भी जिनकी लंबाई 2 की शक्ति नहीं है।

सबसे छोटा कोड (बाइट्स में) जीतता है।

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

[] -> False
[1] -> True
[-1] -> False
[1, 1] -> True
[1, -1] -> True
[1, 1, 1, 1] -> True
[1, 1, 1, 1, 1] -> False
[1, -1, -1, 1, -1, 1, 1, -1] -> True
[1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1] -> False
[1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1] -> False
[1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1] -> True

code-golf array-manipulation decision-problem

— लिन
स्रोत

5

"ओवीएसएफ" क्या है?

— NoOneIsHere

5

ऑर्थोगोनल वैरिएबल स्प्रेडिंग फैक्टर , जो कि उनके उपयोग के तरीके को संदर्भित करता है और उनके पास एक उपयोगी संपत्ति भी है। यह बहुत प्रासंगिक नहीं लगता था, लेकिन विकिपीडिया लिंक यह सब (अस्पष्ट) बताता है।

— लिन

8

जेली , 18 16 14 11 बाइट्स

^2/Eam2µḊ¿Ṭ

[1]OVSF कोड के लिए आउटपुट (सत्य), []( मिथ्या ) अन्यथा।

इसे ऑनलाइन आज़माएं!

पृष्ठभूमि

जैसा @ LuisMendo के Matl जवाब और @ XNOR के अजगर जवाब , इस प्रस्तुत सत्यापन "अंदर बाहर से" इनपुट सरणी।

OVSF कोड की दो या अधिक लंबाई वाले तत्वों की हर (गैर-अतिव्यापी) जोड़ी अनिवार्य रूप से पहली जोड़ी की एक प्रति है, या तो एक ही संकेत के साथ या दोनों संकेतों के साथ स्वैप की गई है। इसी तरह, प्रत्येक (गैर-अतिव्यापी) 4-उच्च के OVSF कोड के तत्वों के 4-टपल को अनिवार्य रूप से पहले 4-tuple की एक प्रति है, या तो समान संकेतों के साथ या दोनों संकेतों के साथ स्वैप किया गया। OVFS कोड की लंबाई तक 8-ट्यूपल, 16-ट्यूपल्स आदि के लिए भी यही सच है।

इसे सत्यापित करने का एक तरीका यह है कि सभी जोड़े समानता के लिए पहले साइन इन करें, फिर प्रत्येक जोड़ी के दूसरे तत्व को हटा दें (जो अब बेमानी जानकारी है)। यदि हम इस प्रक्रिया को एक बार फिर दोहराते हैं, तो हम अनिवार्य रूप से सभी 4-ट्यूपल्स की जांच कर रहे हैं। अगले पुनरावृत्ति में, हम 8-ट्यूपल की तुलना कर रहे हैं, आदि।

अंत में, यदि सभी आवश्यक 2 ^k- tuples साइन के बराबर थे और सरणी एक सिंगलटन पर कम हो गई है, तो यह जांचना पर्याप्त है कि क्या शेष तत्व 1 है ।

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

^2/Eam2µḊ¿Ṭ  Main link. Argument: A (array of 1's and -1's)

       µḊ¿   While dequeuing A (removing its first element) yields a non-empty
             array, execute the monadic chain to the left, updating A with the
             return value after each iteration.
^2/            Compute the bitwise XOR of each non-overlapping pair of elements of
               A. Note that 1 ^ 1 = 0 = -1 ^ -1 and 1 ^ -1 = -2 = -1 ^ 1.
               For an array of even length that consists of the same pairs modulo
               the sign, this returns either an array of 0's or an array of -2's.
               If the length is odd, it will also contain the last element, which
               is either a 1 or a -1.
   E           Test the elements of the result for equality. This yields 1 if the
               array consists solely of 0's or solely of -2's, 0 otherwise.
    a          Take the logical AND of the previous result and every element of A.
               This returns A if it passed the previous test, but replaces all of
               its elements with 0's otherwise.
     m2        Modulo 2; select every second element of A, starting with the first.
             At this point, the last return value can be:
               • [  ] if the input was empty
               • [ 1] if the input was a valid OVSF code
               • [-1] if the input was the negative of a valid OVSF code.
               • [ 0] in all other cases.
           Ṭ  Untruth; yield an array with 1's at the specified indices.
              Indexing is 1-based in Jelly, so [1] returns [1], the array with a 1
              at index 1. Since the indices -1 and 0 are non-canonical, the arrays
              [-1] and [0] are mapped to []. The empty array remains empty.

— डेनिस
स्रोत

14

गणितज्ञ, 52 47 45 बाइट्स

बाइट काउंट CP-1252 एन्कोडिंग को मानता है और $CharacterEncodingइसे WindowsANSI(विंडोज इंस्टॉलेशन पर डिफ़ॉल्ट) सेट करता है।

±___=!(±1=1>0)
a__±b__/;a!==b!||{a}==-{b}:=±a

यह एक वैरेडिक फ़ंक्शन को परिभाषित करता है PlusMinus, जो इनपुट सूची को तर्कों की एक फ्लैट सूची के रूप में लेता है और एक बूलियन PlusMinus[1, -1, -1, 1]देता है , जैसे देता है True। यह सैद्धांतिक रूप से एक ऑपरेटर के रूप में भी प्रयोग करने योग्य है ±, लेकिन यह ऑपरेटर केवल एकात्मक और द्विआधारी संदर्भों में वाक्यविन्यास रूप से मान्य है, इसलिए कॉलिंग सम्मेलन अजीब हो जाएगा ±##&[1,-1,-1,1]:। यह चेतावनियों का एक गुच्छा फेंक देगा जिसे अनदेखा किया जा सकता है।

यह कुछ चेतावनियों को भी फेंक देगा जिन्हें अनदेखा किया जा सकता है।

वहाँ हो सकता है कुछ हद तक परेशान छोटा करने के लिए दूर हो a!==b!||{a}==-{b}हिस्सा है, लेकिन मैं अभी कुछ भी नहीं लग रहा हूँ। जैसे कीवर्ड SubsetQऔर MatrixRankबस बहुत लंबे हैं। : /

व्याख्या

यह समाधान मूल रूप से मैथमेटिका के पैटर्न माचिस की सभी पेचीदा चीजों का बचाव करता है और इसलिए शैली में बहुत ही घोषणात्मक है। पहली पंक्ति में कुछ गोल्फ के अलावा, यह वास्तव में ऑपरेटर के लिए तीन अलग-अलग परिभाषाओं को जोड़ता है ±:

±___=False;
±1=True;
a__±b__/;a!==b!||{a}==-{b}:=±a

पहले दो पंक्तियों को परिभाषाओं को व्यक्त करने और के Trueरूप में व्यक्त करके छोटा किया गया था 1>0।

हमें यह दिखाने के लिए इसे फिर से तैयार करना चाहिए कि यह वास्तव PlusMinusमें केवल और गैर -बाइनरी ऑपरेटर नोटेशन का उपयोग करके एक वैरिएडिक फ़ंक्शन को कैसे परिभाषित करता है। पकड़ यह है कि सभी ऑपरेटर पूर्ण अभिव्यक्तियों के लिए बस वाक्यात्मक चीनी हैं। हमारे मामले में से ±मेल खाती है PlusMinus। निम्नलिखित कोड 100% समतुल्य है:

PlusMinus[___]=False;
PlusMinus[1]=True;
PlusMinus[a__,b__]/;a!==b!||{a}==-{b}:=PlusMinus[a]

अनुक्रम के रूप में (अन्य भाषाओं में छपों की तरह) का उपयोग करके ±हम एक मनमाने ढंग से तर्कों को कवर कर सकते हैं PlusMinus, भले ही ±दो से अधिक तर्कों के साथ प्रयोग करने योग्य नहीं है। मूल कारण यह है कि इनमे से किसी भी क्रम का विस्तार होने से पहले सिन्थेटिक शुगर का समाधान किया जाता है।

परिभाषाओं पर:

पहली परिभाषा बस एक गिरावट है ( ___तर्कों की एक मनमानी सूची से मेल खाती है)। जो कुछ भी नीचे विशिष्ट परिभाषाओं से मेल नहीं खाता है वह देगा False।

दूसरी परिभाषा ओवीएसएफ के लिए आधार मामला है, केवल सूची वाली सूची 1। हम इसे परिभाषित करते हैं True।

अंत में, तीसरी परिभाषा केवल उन सूचियों पर लागू होती है जिन्हें X ++ Xया तो विघटित किया जा सकता है X ++ -X, और पुनरावृत्ति के लिए परिणाम का उपयोग करता है X। परिभाषा सुनिश्चित वे subsequences में विभाजित किया जा सकता है द्वारा इन सूचियों तक ही सीमित है aऔर bसाथ a__±b__और उसके बाद हालत (संलग्न /;) है कि या तो {a}=={b}या {a}==-{b}। PlusMinusएक ऑपरेटर के माध्यम से इस अजीब तरीके से एक वैरिएड फ़ंक्शन के रूप में परिभाषित करना सूचियों पर एक यूनिरी ऑपरेटर को परिभाषित करने पर 5 बाइट बचाता है ±।

लेकिन रुकिए, और भी है। हम a!==b!इसके बजाय उपयोग कर रहे हैं {a}=={b}। जाहिर है, हम ऐसा कर रहे हैं क्योंकि यह दो बाइट्स छोटा है, लेकिन दिलचस्प सवाल यह है कि यह काम क्यों करता है। जैसा कि मैंने ऊपर बताया है, सभी ऑपरेटर सिर के साथ कुछ अभिव्यक्ति के लिए सिर्फ वाक्यविन्यास चीनी हैं। {a}है List[a]। लेकिन aएक है अनुक्रम (की तरह अन्य भाषाओं में एक सूचक की तरह की तरह मैंने कहा,) इसलिए यदि aहै 1,-1,1तो हम पाते हैं List[1,-1,1]। अब पोस्टफिक्स !है Factorial। तो यहाँ, हम मिलेगा Factorial[1,-1,1]। लेकिन Factorialयह नहीं पता है कि जब एक से भिन्न तर्क होते हैं, तो क्या करना है, इसलिए यह केवल अवमूल्यित रहता है। ==वास्तव में परवाह नहीं है अगर दोनों पक्षों की बात सूची है, यह सिर्फ भावों की तुलना करता है, और यदि वे समान हैं तो यह देता हैTrue(इस मामले में, यह वास्तव में नहीं देगा Falseयदि वे नहीं हैं, लेकिन पैटर्न मेल नहीं खाते हैं यदि स्थिति के अलावा कुछ भी वापस मिलता है True)। तो इसका मतलब है कि, अगर सूची में कम से कम दो तत्व हैं तो भी इक्विटी चेक काम करता है। यदि केवल एक ही है तो क्या होगा? अगर aहै 1तो a!अब भी है 1। अगर aहै -1तो a!देता है ComplexInfinity। अब, 1खुद की तुलना करना अभी भी ठीक काम करता है। लेकिन ComplexInfinity == ComplexInfinityनिर्लेप रहता है, और भले ही सच नहीं हैa == -1 == b । सौभाग्य से, यह कोई फर्क नहीं पड़ता, क्योंकि केवल यही स्थिति दिखाई देती है PlusMinus[-1, -1]जो कि वैसे भी एक वैध OVSF नहीं है! (यदि स्थिति वापस आ गई True, तो पुनरावर्ती कॉल रिपोर्ट करेगाFalseआखिरकार, इससे कोई फर्क नहीं पड़ता कि चेक काम नहीं करता है।) हम उसी ट्रिक का उपयोग नहीं कर सकते {a}==-{b}क्योंकि -थ्रेड ओवर नहीं होगा Factorial, यह केवल थ्रेड ओवर करता है List।

पैटर्न मैचर बाकी की देखभाल करेगा और बस लागू करने के लिए सही परिभाषा ढूंढेगा।

— मार्टिन एंडर
स्रोत

9

हास्केल, 57 बाइट्स

q=length
f l=l==until((>=q l).q)(\s->s++map(*l!!q s)s)[1]

इनपुट सूची को देखते हुए l, एक OVSF कोड बढ़ता है, sजिसमें से [1]और बार-बार sया तो -s, या जो भी पहले तत्व से मेल खाता है, को शुरू करता है l। फिर, जाँचता है कि परिणाम lअंत में है। यह जांच की जाती है कि एक बार sलंबाई कम से कम है l।

कुछ विकल्प पुनरावर्ती संरचनाएं भी देने के लिए 57 हुए:

(s%i)l|length l<=i=s==l|j<-2*i=(s++map(*l!!i)s)%j$l
[1]%1

q=length
s%l|q s>=q l=s==l|r<-s++map(*l!!q s)s=r%l
([1]%)

q=length
g s l|q s<q l=g(s++map(*l!!q s)s)l|1>0=s==l
g[1]

— XNOR
स्रोत

6

MATLAB / ऑक्टेव , 94 बाइट्स

function a=f(r);n=nnz(r);m=log2(n);a=0;if fix(m)-m==0;for c=hadamard(n);a=a+all(r==c');end;end

यह एक नए दृष्टिकोण का उपयोग कर रहा है: लंबाई के स्वीकृत ओवीएसएफ कोड - वें वॉल्श-मैट्रिक्सN में दिखाई देते हैं , क्योंकि वे मूल रूप से एक ही पुनरावृत्ति द्वारा परिभाषित होते हैं:log2(N)

$H(2^k) = H(2)\otimes H(2^{k-1})$

वाल्श मैट्रिसेस हडामर्ड-मेट्रिसेस के आकार के विशेष मामले हैं N x Nयदि Nदो की शक्ति है। (अन्य आकारों के हैडमर्ड मैट्रिसेस भी हैं।) MATLAB और ऑक्टेव में कई प्रकार के बिल्ट हैं जो संख्यात्मक एल्गोरिदम के गुणों का परीक्षण करने के लिए टेस्ट मैट्रिसेस उत्पन्न करते हैं hadamard()। सौभाग्य से दो MATLAB के hadamard()उपयोग की शक्तियों के लिए वास्तव में वेल्श-मैट्रिस का निर्माण होता है।

तो यह फ़ंक्शन पहले जांचता है कि इनपुट लंबाई दो की शक्ति है या नहीं, और यदि यह है, तो यह जाँच करता है कि यह संबंधित आकार वेल्श-मैट्रिक्स की एक पंक्ति है या नहीं।

इसे ऑनलाइन आज़माएं!

— flawr
स्रोत

5

पायथन, 64 बाइट्स

f=lambda l:[]<l[1::2]==[x*l[1]for x in l[::2]]*f(l[::2])or[1]==l

सूची को समान-अनुक्रमित तत्वों और स्लाइस के माध्यम से विषम-अनुक्रमित तत्वों में विभाजित करता है। जाँचता है कि क्या परिणाम वैक्टर या तो बराबर हैं या नकारात्मक इसके पहले तत्व द्वारा संकेत द्वारा गुणा करके। फिर, सम-अनुक्रमित तत्वों पर समान पुनरावर्ती जाँच करता है।

आधार मामले के लिए, यदि चेक विफल हो जाता है, तो सूची को अस्वीकार कर दिया जाता है [1]। अनंत लूप से बचने के लिए खाली सूची को भी विशेष रूप से खारिज कर दिया जाता है।

मेरे हास्केल जवाब की तरह एक अलग रणनीति 66 बाइट्स देती है:

f=lambda l,i=1,s=[1]:l[i:]and f(l,i*2,s+[x*l[i]for x in s])or s==l

— XNOR
स्रोत

2

हास्केल , 106 91 87 86 बाइट्स

g n|n<1=[[1]]|m<-g(n-1)=foldl(\a b->[b++map(0-)b,b++b]++a)[]m++m
f l=elem l$g$length l

फ़ंक्शन सूचियों gके nपुनरावृत्ति उत्पन्न करता है (अपेक्षाकृत अक्षम रूप से, चूंकि length $ g n == 3^n, यदि हम डुप्लिकेट को हटा देते हैं, तो हम प्राप्त करेंगे 2^n), fजांचें कि क्या हमारी सूची उनमें से किसी एक में है। कुछ संकेत के लिए @Zgrab को धन्यवाद!

इसे ऑनलाइन आज़माएं!

— flawr
स्रोत

पिछले 2 परीक्षण मामलों को चलाने से मेरे लिए कोई आउटपुट नहीं मिला।

— ओलिवर

@obarakon हां, क्योंकि gयह बहुत अक्षम है और डुप्लिकेट का एक टन पैदा करता है । ( डिबग अनुभाग की जाँच करें , यह शायद समय या स्मृति सीमाओं के कारण है।)

— दोष

2

जावास्क्रिप्ट (ईएस 6), 130 93 87 85 83 बाइट्स

f=a=>(b=a.slice(0,l=a.length/2),c=a.slice(l)+"",a==1||l&&b==c|b.map(i=>-i)==c&f(b))

डेमो

f=a=>(b=a.slice(0,l=a.length/2),c=a.slice(l)+"",a==1||l&&b==c|b.map(i=>-i)==c&f(b)),[[],[1],[-1],[1,1],[1,-1],[1,1,1,1],[1,1,1,1,1],[1,-1,-1,1,-1,1,1,-1],[1,1,1,1,-1,-1,-1,-1,1,1,1,1],[1,1,1,1,-1,-1,-1,-1,1,1,1,1,1,1,1,1],[1,1,1,1,-1,-1,-1,-1,1,1,1,1,-1,-1,-1,-1]].map(a=>console.log(`[${a}] -> ${!!f(a)}`))

स्निपेट का विस्तार करें

— पैट्रिक रॉबर्ट्स
स्रोत

2

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

a=>(l=a.length)&&!(l&l-1)&a.every((e,i)=>e==a[j=i&-i]*a[i-j])

पिछला संस्करण जिसने यह सुनिश्चित करने के लिए तत्वों की जाँच की कि वे थे 1या -1:

a=>(l=a.length)&&!(l&l-1)&a.every((e,i)=>i?(j=i&-i)<i?e==a[j]*a[i-j]:e==1|e==-1:e==1)

स्पष्टीकरण:

लंबाई शून्य नहीं हो सकती
लंबाई 2 की शक्ति होनी चाहिए
पहला तत्व 1 होना चाहिए
2 की शक्ति वाले पदों में तत्व 1 या -1 होना चाहिए
अन्य पदों में तत्व बिटमास्क के अनुरूप पदों में सभी तत्वों के उत्पाद हैं, उदाहरण के लिए a[22] == a[2] * a[4] * a[16]। चूंकि a[20] == a[4] * a[16]पहले ही जाँच की जा चुकी है, केवल a[22] == a[2] * a[20]जाँच की जानी चाहिए।
उपरोक्त जांच iकम से कम दो बिट्स सेट न करने के लिए पतित परिणाम देती है । शून्य बिट सेट के मामले में, यह जाँचता है कि a[0] == a[0] * a[0], जो गलत है a[0] == -1, जबकि एक बिट सेट के मामले में, यह जाँच करता है a[i] == a[0] * a[i]।

— नील
स्रोत

आप 4 बाइट्स को बचाने के (l=a.length)&&!(l&l-1)लिए बदल सकते हैं(l=a.length)&-l==l

— पैट्रिक रॉबर्ट्स

@PatrickRoberts क्या यह सच नहीं है l==0?

— नील

ओह, तुम सही हो। अच्छा फिर (l=a.length)&&l&-l==l? 1 बाइट बचाने के लिए ...

— पैट्रिक रॉबर्ट्स

वास्तव में कभी नहीं, [1,1,1,1,-1,-1,-1,-1,1,1,1,1,1,1,1,1]मेरे सुझावों के बिना भी आपका कार्य विफल रहता है ।

— पैट्रिक रॉबर्ट्स

@PatrickRoberts l&-l==lइसलिए काम नहीं करता क्योंकि ==इसकी पूर्वता अधिक है &। और परीक्षण के मामले में एक टाइपो के कारण काम नहीं करता है जो मुझे ठीक करने के लिए एक बाइट खर्च करने जा रहा है।

— नील

2

MATL , 21 20 बाइट्स

`2eZ}yy=&=tn1>hh]1X=

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

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

कोड सरणी को दो समान लंबाई के टुकड़ों में विभाजित करता है: पहला विषम-अनुक्रमित प्रविष्टियों के साथ, दूसरा समान-अनुक्रमित प्रविष्टियों के साथ। यदि आवश्यक हो तो दूसरे भाग में एक गद्दी शून्य के साथ दो टुकड़ों को समान लंबाई के लिए मजबूर किया जाता है। फिर कोड की जाँच करता है

दोनों टुकड़ों की संगत प्रविष्टियाँ या तो सभी समान हैं या सभी अलग हैं;
दूसरे टुकड़े में कोई प्रविष्टि शून्य नहीं है;
टुकड़ों की लंबाई 1 से अधिक है।

यदि इन तीन शर्तों को पूरा किया जाता है, तो प्रक्रिया को पहले टुकड़े पर फिर से लागू किया जाता है। यदि लूप बाहर निकलता है क्योंकि लंबाई पहले से ही 1 थी, इनपुट एक OFSV कोड है। और यह नहीं है।

शर्त 1 पुनरावृत्त OVSF कोड की परिभाषित संपत्ति का एक समान संस्करण है। लंबाई 8 की एक सरणी के लिए, सीधा दृष्टिकोण यह जांचना होगा कि प्रविष्टियां 1,2,3,4 क्रमशः 5,6,7,8 प्रविष्टियों के लिए सभी समान या सभी अलग हैं (यह परिभाषित संपत्ति है)। लेकिन हम समान रूप से जांच सकते हैं कि प्रविष्टियां 1,3,5,7 क्रमशः 2,4,6,8 प्रविष्टियों के लिए सभी समान या सभी अलग हैं; और यह कम बाइट्स का उपयोग करता है।

शर्त 2 यह सुनिश्चित करती है कि इनपुट लंबाई 2 की शक्ति है: यदि यह नहीं है, तो किसी चरण में एक पेडिंग शून्य पेश किया जाएगा।

`        % Do...while loop
  2e     %   Reshape as a two-row matrix, with a padding zero if needed
         %   Row 1 contains the original odd-indexed entries, row 2 the
         %   even-indexed
  Z}     %   Split matrix into two vectors, one corresponding to each row
  yy     %   Duplicate those two vectors
  =      %   Check if corresponding entries are equal or not
  &=     %   Matrix of all pairwise comparisons. This will give a matrix
         %   filled with ones if and only if the previous check gave all
         %   true or all false (condition 1)
  tn1>   %   Duplicate and push true if size exceeds 1, or false otherwise
         %   (condition 3)
  hh     %   Concatenate condition 1, condition 3, and the original copy of
         %   the second piece (condition 2). The resulting vector is truthy
         %   if and only if it doesn't contain any zero
]        % End
1X=      % True if top of the stack is a single 1, false otherwise

— लुइस मेंडो
स्रोत

2

हास्केल, 66 बाइट्स

याय, अनंत सूचियाँ!

o=[1]:(o>>= \x->[x++map(0-)x,x++x])
f l=l`elem`take(2*2^length l)o

वैकल्पिक संस्करण:

o=[1]:(o<**>map(>>=flip(++))[map(0-),id])
f=Data.List.Ordered.hasBy(comparing length)o

— Bergi
स्रोत

के लिए धन्यवाद (0-)चाल, मैं के साथ फंस गया था negateया((-1)*)

— Bergi

1

एपीएल, 46 बाइट्स

{0::0⋄⍵≡,1:1⋄⍬≡⍵:0⋄(∇Z↑⍵)∧(∇Y)∨∇-Y←⍵↓⍨Z←.5×⍴⍵}

काफी सरल:

आधार मामले:
- 0::0: यदि कोई त्रुटि होती है, तो 0 लौटें
- ⍵≡,1:1: यदि इनपुट बिल्कुल है [1], तो 1 लौटें
- ⍬≡⍵:0: यदि इनपुट खाली सूची है, तो 0 वापस करें
पुनरावर्ती मामला:
- Z←.5×⍴⍵: Zइनपुट की लंबाई आधी है
- Y←⍵↓⍨Z: Yइनपुट का अंतिम आधा हिस्सा है (यदि ⍴⍵यह असमान है, तो अपवाद हैंडलर को ट्रिगर करना)
- (∇Y)∨∇-Y: या तो सूची के अंतिम आधे, या सूची के अंतिम छमाही की उपेक्षा, एक OVSF कोड होना चाहिए
- (∇Z↑⍵)∧: और सूची की पहली छमाही में एक OVSF कोड होना चाहिए।

— मारीनस
स्रोत

1

मुझे नहीं लगता कि दूसरी छमाही के लिए ओवीएसएफ-कोडिटी की जांच करना पर्याप्त है; यह पहली छमाही या इसके नकार के बराबर होना चाहिए।

— जर्गब

1

वे कहते हैं कि BASIC एक उच्च स्तर की कमी है और APL एक उच्च स्तर की पीड़ा है: ')

— cat

वे कहते हैं कि BASIC एक उच्च स्तर की कमी है और APL एक उच्च स्तर की पीड़ा है: ')

— cat

1

हास्केल, 69 68 बाइट्स

g x=any(elem x)$scanr(\_->concat.mapM(\y->[y++y,y++map(0-)y]))[[1]]x

प्रयोग उदाहरण: g [-1,1]-> False।

@ दोष के उत्तर से भी अधिक अक्षम । 4 तत्व सूचियों के लिए बहुत अधिक समय और मेमोरी लगती है। यह देखने के लिए कि वास्तव में OVSF कोड (ढेर सारे डुप्लिकेट के साथ) की सूची बनाई गई है, कोशिश करें:

take 10 $ c $ scanr(\_->concat.mapM(\y->[y++y,y++map(0-)y]))[[1]] [1..4]

जो लौटता है

[[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],
 [1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1],
 [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],
 [1,-1,-1,1,1,-1,-1,1,1,-1,-1,1,1,-1,-1,1],
 [1,1,-1,-1,1,1,-1,-1,1,1,-1,-1,1,1,-1,-1],
 [1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1],
 [1,1,-1,-1,1,1,-1,-1,1,1,-1,-1,1,1,-1,-1],
 [1,-1,-1,1,1,-1,-1,1,1,-1,-1,1,1,-1,-1,1],
 [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],
 [1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1]]

अर्थात सूची सभी 16 तत्व सूचियों के साथ शुरू होती है (4 गुना समवर्ती, क्योंकि [1..4]), सभी 8 तत्व सूचियों के साथ जारी रहती है और इसी तरह जब तक यह समाप्त नहीं होती है [1]।

संपादित करें: @xnor ने एक बाइट को बचाया। धन्यवाद!

— nimi
स्रोत

आह, मैं पूरी तरह से भूल गया scanr!

— 22

मुझे लगता है कि आप एक बाइट काट सकते हैं any(elem x)बजाय elem x$cपरिभाषित करने के c।

— xnor

1

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

def f(x):l=len(x)/2;return[n*x[l]*f(x[:l])for n in x[l:]]==x[:l]>[]or[1]==x

इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत

0

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

f=(l,k=[1])=>l+l==k+k||l[k.length]&&f(l,k.concat(k))|f(l,k.concat(k.map(v=>-v)))

Recursively इनपुट सूची की लंबाई तक प्रत्येक सूची का निर्माण और जांच करता है, जिसके साथ शुरू होता है [1]।

वापसी मान जे एस truthy या falsey, विशेष रूप से है 1या trueवैध है, 0या falseया undefinedअगर मान्य नहीं है।

परीक्षा

f=(l,k=[1])=>l+l==k+k||l[k.length]&&f(l,k.concat(k))|f(l,k.concat(k.map(v=>-v)))

test=`[] -> False
[1] -> True
[-1] -> False
[1, 1] -> True
[1, -1] -> True
[1, 1, 1, 1] -> True
[1, 1, 1, 1, 1] -> False
[1, -1, -1, 1, -1, 1, 1, -1] -> True
[1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1] -> False
[1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1] -> False
[1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1] -> True`
.split('\n')

test.forEach(r=>{
  input = r.match(/-?1/g)||[]
  check = r.slice(-4) == 'True'
  result = f(input)
  console.log(result, check, '['+input+']')
})

स्निपेट का विस्तार करें

— edc65
स्रोत

0

क्लोजर, 118 बाइट्स

(defn f[C](or(=(count C)1)(let[l(/(count C)2)[a b](split-at l C)](and(> l 0)(=(count b)l)(apply =(map * a b))(f a)))))

विभाजन इनपुट cदो हिस्सों में aऔर bऔर चेक अगर उनके तत्व के लिहाज से उत्पादों सब समान हैं। यदि हां, तो जांच लें कि पहली छमाही वैध अनुक्रम है।

यह एक 142 बाइट्स है, लेकिन मुझे यह अधिक दिलचस्प लगा:

#((set(nth(iterate(fn[I](mapcat(fn[i][(concat i i)(concat i(map - i))])I))[[1][-1]])(loop[l(count %)i 0](if(< l 2)i(recur(/ l 2)(inc i))))))%)

looplog_2इनपुट की लंबाई की गणना , iterateपरिभाषा के आधार पर कई पुनरावृत्तियों के अनुक्रम उत्पन्न करता है। यह इनपुट तर्क लौटाता है यदि यह एक मान्य अनुक्रम है और nilअन्यथा।

— NikoNyrh
स्रोत

क्या यह एक OVSF कोड है?

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

जेली , 18 16 14 11 बाइट्स

पृष्ठभूमि

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

गणितज्ञ, 52 47 45 बाइट्स

व्याख्या

हास्केल, 57 बाइट्स

MATLAB / ऑक्टेव , 94 बाइट्स

पायथन, 64 बाइट्स

हास्केल , 106 91 87 86 बाइट्स

जावास्क्रिप्ट (ईएस 6), 130 93 87 85 83 बाइट्स

डेमो

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

MATL , 21 20 बाइट्स

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

हास्केल, 66 बाइट्स

एपीएल, 46 बाइट्स

हास्केल, 69 68 बाइट्स

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

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

क्लोजर, 118 बाइट्स