รับรายการ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

เยลลี่ , 18 16 14 11 ไบต์

^2/Eam2µḊ¿Ṭ

เอาท์พุท[1](ความจริง) สำหรับรหัส OVSF [](เป็นเท็จ) เป็นอย่างอื่น

ลองออนไลน์!

พื้นหลัง

เช่นเดียวกับคำตอบMATLและ@ Python ของ @ LuisMendo คำตอบนี้จะตรวจสอบอาร์เรย์อินพุต "จากภายในสู่ภายนอก"

ทุกองค์ประกอบ (ไม่ทับซ้อนกัน) คู่ของรหัส OVSF ที่มีความยาวสองหรือสูงกว่านั้นเป็นสำเนาของคู่แรกโดยมีเครื่องหมายเดียวกันหรือเปลี่ยนทั้งสองอย่าง เช่นเดียวกันทุกองค์ประกอบ (ไม่ทับซ้อนกัน) 4-tuple ของรหัส OVSF ที่มีความยาวสี่หรือสูงกว่านั้นเป็นสำเนาสำเนาของ 4-tuple ตัวแรกไม่ว่าจะเป็นสัญญาณเดียวกันหรือสลับสัญญาณทั้งสอง สิ่งนี้เป็นจริงสำหรับ 8-tuples, 16-tuples และอื่น ๆ จนถึงความยาวของรหัส OVFS

วิธีหนึ่งในการตรวจสอบนี้คือการตรวจสอบทุกคู่เพื่อดูโมดูโลเท่าเทียมกันก่อนจากนั้นลบองค์ประกอบที่สองของแต่ละคู่ (ซึ่งตอนนี้เป็นข้อมูลที่ซ้ำซ้อน) หากเราทำขั้นตอนนี้ซ้ำอีกครั้งเราจะตรวจสอบสิ่งอันดับ 4 ทั้งหมด ในการทำซ้ำครั้งต่อไปเรากำลังเปรียบเทียบ 8-tuples เป็นต้น

ในที่สุดหากต้องการ 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.

Mathematica, 52 47 45 ไบต์

จำนวนไบต์ถือว่าการเข้ารหัส CP-1252 และ$CharacterEncodingตั้งค่าเป็นWindowsANSI(ค่าเริ่มต้นในการติดตั้ง Windows)

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

นี้กำหนดฟังก์ชัน variadic PlusMinusซึ่งจะนำรายชื่อการป้อนข้อมูลที่เป็นรายการแบนของการขัดแย้งและผลตอบแทนแบบบูลเช่นให้PlusMinus[1, -1, -1, 1] Trueในทางทฤษฎีแล้วมันยังสามารถใช้งานได้ในฐานะโอเปอเรเตอร์±แต่โอเปอเรเตอร์นั้นจะใช้ได้ในบริบทของยูนารีและไบนารี่ซิงแทคติค±##&[1,-1,-1,1]เท่านั้น มันจะโยนพวงของคำเตือนที่สามารถละเว้น

นี่จะเป็นการโยนคำเตือนบางอย่างซึ่งสามารถละเว้นได้

มีอาจจะอยู่ห่างเพื่อตัดรำคาญบ้างa!==b!||{a}==-{b}บางส่วน แต่ฉันไม่พบอะไรในขณะนี้ คำหลักที่ชอบSubsetQและMatrixRankยาวเกินไป : /

คำอธิบาย

วิธีการแก้ปัญหาโดยทั่วไป defers ทุกสิ่งที่ยากที่จะจับคู่รูปแบบของ Mathematica และดังนั้นจึงมีการประกาศอย่างมีสไตล์มาก นอกเหนือจาก golfitude บางส่วนในบรรทัดแรกนี่เป็นเพียงแค่เพิ่มสามคำจำกัดความที่แตกต่างกันสำหรับผู้ประกอบการ±:

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

สองแถวแรกที่สั้นลงโดยทำรังคำจำกัดความและการแสดงเป็นTrue1>0

เราควรแยกชิ้นส่วนนี้เพิ่มเติมเพื่อแสดงให้เห็นว่าสิ่งนี้กำหนดฟังก์ชั่น Variadci PlusMinusโดยใช้สัญกรณ์ตัวดำเนินการยูนารีและไบนารีเท่านั้น จับได้ว่าผู้ประกอบการทั้งหมดเป็นเพียงน้ำตาลประโยคสำหรับการแสดงออกอย่างเต็มรูปแบบ ในกรณีของเราสอดคล้องกับ± PlusMinusรหัสต่อไปนี้เทียบเท่า 100%:

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

โดยการใช้ลำดับ (เรียงคล้าย splats ในภาษาอื่น ๆ ) เป็นตัวถูกดำเนินการเพื่อให้±เราสามารถครอบคลุมจำนวนอาร์กิวเมนต์โดยพลการPlusMinusถึงแม้ว่า±จะไม่สามารถใช้งานได้มากกว่าสองข้อโต้แย้ง เหตุผลพื้นฐานคือน้ำตาล syntactic ได้รับการแก้ไขก่อนก่อนที่ลำดับใด ๆ เหล่านี้จะถูกขยาย

ตามคำจำกัดความ:

นิยามแรกเป็นเพียงทางเลือก ( ___ตรงกับรายการข้อโต้แย้งโดยพลการ) Falseอะไรที่ไม่ตรงกับคำจำกัดความเฉพาะเจาะจงมากขึ้นดังต่อไปนี้จะให้

ความหมายที่สองคือกรณีฐานสำหรับ OVSF 1รายการที่มีเพียง Trueเรากำหนดนี้จะเป็น

ในที่สุดคำจำกัดความที่สามใช้เฉพาะกับรายการที่สามารถย่อยสลายในX ++ XหรือX ++ -Xและใช้ผลลัพธ์Xซ้ำ ความหมายจะถูก จำกัด รายชื่อเหล่านี้โดยมั่นใจว่าพวกเขาสามารถแบ่งออกเป็น subsequences aและbด้วยa__±b__แล้วติดเงื่อนไข ( /;) ว่าทั้งสองหรือ{a}=={b} {a}==-{b}การกำหนดPlusMinusเป็นฟังก์ชัน Variadic ด้วยวิธีแปลก ๆ นี้ผ่านโอเปอเรเตอร์จะบันทึก5ไบต์ที่มากเกินกว่าการกำหนดโอเปอเรเตอร์ยูนารี±ในรายการ

แต่เดี๋ยวก่อนยังมีอีกมาก เรากำลังใช้แทนa!==b! {a}=={b}เห็นได้ชัดว่าเรากำลังทำสิ่งนี้เพราะมันสั้นกว่าสองไบต์ แต่คำถามที่น่าสนใจคือทำไมมันถึงได้ผล อย่างที่ฉันได้อธิบายไปแล้วข้างต้นโอเปอเรเตอร์ทั้งหมดเป็นเพียงน้ำตาลประโยคสำหรับการแสดงออกด้วยหัว เป็น{a} List[a]แต่aเป็นลำดับ (เช่นฉันกล่าวประเภทเช่นเครื่องหมายในภาษาอื่น ๆ ) ดังนั้นถ้าaเป็นแล้วเราจะได้รับ1,-1,1 List[1,-1,1]ตอนนี้ postfix คือ! ดังนั้นที่นี่เราจะได้รับFactorial Factorial[1,-1,1]แต่Factorialไม่รู้ว่าต้องทำอย่างไรเมื่อมีข้อโต้แย้งที่แตกต่างจากจำนวนหนึ่งดังนั้นสิ่งนี้ก็ยังไม่ประเมินค่า ==ไม่สนใจจริง ๆ ว่าสิ่งที่อยู่ทั้งสองข้างนั้นเป็นรายการหรือเปล่ามันแค่เปรียบเทียบการแสดงออกและถ้ามันเท่ากันมันก็ให้True(ในกรณีนี้มันจะไม่ให้จริงFalseถ้าไม่ได้ แต่รูปแบบไม่ตรงกันหากเงื่อนไขส่งคืนสิ่งอื่นนอกจากTrue) ดังนั้นนั่นหมายความว่าการตรวจสอบความเท่าเทียมกันยังคงใช้งานได้หากมีองค์ประกอบอย่างน้อยสองรายการในรายการ เกิดอะไรขึ้นถ้ามีเพียงคนเดียว? ถ้าaเป็น1แล้วยังคงเป็นa! 1ถ้าaเป็น-1แล้วจะช่วยให้a! ComplexInfinityตอนนี้เมื่อเทียบ1กับตัวเองยังคงทำงานได้ดีแน่นอน แต่ComplexInfinity == ComplexInfinityยังคง unevaluated และไม่a == -1 == bให้ความจริงแม้ว่า โชคดีที่มันไม่สำคัญเพราะมีเพียงสถานการณ์เดียวเท่านั้นที่แสดงว่าPlusMinus[-1, -1]OVSF ไม่ถูกต้อง! (หากเงื่อนไขไม่ส่งคืนTrueการเรียกซ้ำจะรายงานFalseหลังจากทั้งหมดดังนั้นมันไม่สำคัญว่าเช็คไม่ได้ออก.) เราไม่สามารถใช้เคล็ดลับเดียวกัน{a}==-{b}เพราะ-จะไม่ด้ายกว่าก็เพียงหัวข้อมากกว่าFactorialList

ตัวจับคู่รูปแบบจะดูแลส่วนที่เหลือและเพียงแค่ค้นหาคำจำกัดความที่ถูกต้องเพื่อนำไปใช้

Haskell, 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]

MATLAB / Octave , 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

นี่คือการใช้วิธีการใหม่: รหัสความยาว OVSF ที่อนุญาตNปรากฏในlog2(N)-th Walsh-matrixเนื่องจากมีการกำหนดโดยการเรียกซ้ำแบบเดิม:

เมทริกซ์วอลช์เป็นกรณีพิเศษของHadamard-matricesขนาดN x Nถ้าNเป็นพลังของสอง (นอกจากนี้ยังมีการฝึกอบรม Hadamard ของขนาดอื่น ๆ .) MATLAB hadamard()และคู่มีความหลากหลายของการสร้างขึ้นในฟังก์ชั่นที่สร้างการฝึกอบรมการทดสอบเพื่อทดสอบคุณสมบัติของขั้นตอนวิธีเชิงตัวเลขหมู่พวกเขาเป็น โชคดีสำหรับพลังของการใช้งาน MATLAB สองhadamard()ชุดในการสร้างเวลช์ - เมทริกซ์

ดังนั้นฟังก์ชั่นนี้ก่อนจะตรวจสอบว่าความยาวของอินพุตนั้นเป็นกำลังสองหรือไม่และถ้าเป็นมันจะตรวจสอบว่ามันเป็นแถวขนาดเวลส์ที่สอดคล้องกันหรือไม่

ลองออนไลน์!

Python ขนาด 64 ไบต์

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

แบ่งรายการออกเป็นอิลิเมนต์ที่มีการจัดทำดัชนีแล้วและองค์ประกอบที่มีการจัดทำดัชนีคี่ผ่านสไลซ์ ตรวจสอบว่าเวกเตอร์ผลการทดสอบมีค่าเท่ากับหรือลบด้วยการคูณหนึ่งด้วยเครื่องหมายที่บังคับโดยองค์ประกอบแรก จากนั้นทำการตรวจสอบแบบเรียกซ้ำในองค์ประกอบที่จัดทำดัชนีซ้ำ

สำหรับกรณีพื้นฐานถ้าการตรวจสอบล้มเหลวปฏิเสธยกเว้นว่าเป็นรายการ [1]สำหรับกรณีฐานหากตรวจสอบล้มเหลวเสียเว้นแต่รายการเป็นรายการว่างยังถูกปฏิเสธโดยเฉพาะเพื่อหลีกเลี่ยงการวนซ้ำไม่สิ้นสุด

กลยุทธ์ที่แตกต่างกันเช่นคำตอบของฉัน Haskellให้ 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

Haskell , 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 สำหรับคำแนะนำเล็กน้อย!

ลองออนไลน์!

JavaScript (ES6), 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)}`))

JavaScript (ES6), 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
• องค์ประกอบในตำแหน่งอื่น ๆ ที่มีสินค้าของทุกองค์ประกอบในตำแหน่งที่สอดคล้องกับ bitmask 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] == -1a[i] == a[0] * a[i]

MATL , 21 20 ไบต์

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

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

มันทำงานอย่างไร

รหัสจะแบ่งอาร์เรย์ออกเป็นสองส่วนที่มีความยาวเท่ากัน: รายการแรกที่มีรายการที่มีการจัดทำดัชนีคี่รายการที่สองที่มีรายการที่จัดทำดัชนีคู่ ทั้งสองชิ้นถูกบังคับให้มีความยาวเท่ากันโดยมีศูนย์ในอีกสองถ้าจำเป็น จากนั้นรหัสตรวจสอบว่า

1. รายการที่เกี่ยวข้องของทั้งสองชิ้นมีความเท่ากันหรือต่างกัน
2. ไม่มีการป้อนข้อมูลในส่วนที่สองเป็นศูนย์
3. ความยาวของชิ้นส่วนเกิน 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

Haskell, 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

APL, 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

Haskell, 69 68 ไบต์

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

ตัวอย่างการใช้: g [-1,1]->False ->

แม้ไม่มีประสิทธิภาพมากกว่า@ flawr ของคำตอบ ใช้เวลาและหน่วยความจำมากเกินไปสำหรับรายการองค์ประกอบ 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 บันทึกไบต์ ขอบคุณ!

Python 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

ลองออนไลน์!

JavaScript (ES6), 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)))

สร้างซ้ำและตรวจสอบแต่ละรายการจนถึงความยาวของรายการอินพุตเริ่มต้นด้วย [1]ซ้ำสร้างและตรวจสอบรายชื่อแต่ละคนขึ้นอยู่กับความยาวของรายการการป้อนข้อมูลที่เริ่มต้นด้วย

ค่าส่งคืนคือ JS จริงหรือเท็จโดยเฉพาะ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+']')
})

Clojure 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))))))%)

loopคำนวณlog_2ความยาวของอินพุตiterateสร้างลำดับของการวนซ้ำจำนวนมากตามนิยาม นี่จะคืนค่าอาร์กิวเมนต์อินพุตหากเป็นลำดับที่ถูกต้องและเป็นnilอย่างอื่น