Diberikan daftar 1s dan -1s, tentukan apakah itu kode OVSF yang valid (dengan mengeluarkan nilai truey atau falsey).

Kode OVSF didefinisikan sebagai berikut:

• [1] adalah kode OVSF.

• Jika Xkode OVSF, maka X ++ Xdan X ++ -Xkeduanya kode OVSF.

  Berikut ++adalah daftar gabungan, dan -meniadakan setiap elemen dalam daftar.

• Tidak ada daftar lain yang merupakan kode OVSF yang valid.

Anda dapat menganggap daftar input hanya berisi -1dan 1, tetapi Anda harus menangani daftar kosong dengan benar, serta daftar yang panjangnya bukan kekuatan 2.

Kode terpendek (dalam byte) menang.

Uji kasus

[] -> 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

Jelly , 18 16 14 11 byte

^2/Eam2µḊ¿Ṭ

Keluaran [1](kebenaran) untuk kode OVSF, [](falsy) sebaliknya.

Cobalah online!

Latar Belakang

Seperti jawaban @ LuisMendo dari MATL dan @nama Python , kiriman ini memverifikasi array input "dari dalam ke luar".

Setiap pasangan (tanpa tumpang tindih) elemen kode OVSF dengan panjang dua atau lebih tinggi pada dasarnya adalah salinan dari pasangan pertama, baik dengan tanda yang sama atau dengan kedua tanda ditukar. Demikian juga, setiap elemen tuple (non-tumpang tindih) 4 elemen dari kode OVSF dengan panjang empat atau lebih tinggi pada dasarnya adalah salinan dari tuple 4-pertama, baik dengan tanda yang sama atau dengan kedua tanda bertukar. Hal yang sama berlaku untuk 8-tupel, 16-tupel, dll., Hingga panjang kode OVFS.

Salah satu cara untuk memverifikasi ini adalah dengan memeriksa semua pasangan untuk modul kesetaraan tanda pertama, kemudian menghapus elemen kedua dari setiap pasangan (yang sekarang menjadi informasi yang berlebihan). Jika kami mengulangi proses ini sekali lagi, pada dasarnya kami memeriksa semua 4-tupel. Dalam iterasi berikutnya, kami membandingkan 8-tupel, dll.

Akhirnya, jika semua yang diperlukan 2 ^k -tupel sama dengan modulo tanda dan array telah direduksi menjadi singleton, itu sudah cukup untuk memeriksa apakah elemen yang tersisa adalah 1 .

Bagaimana itu bekerja

^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 byte

Hitungan byte mengasumsikan pengkodean CP-1252 dan $CharacterEncodingdiatur ke WindowsANSI(default pada instalasi Windows).

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

Ini mendefinisikan fungsi variadic PlusMinus, yang mengambil daftar input sebagai daftar datar argumen dan mengembalikan boolean, misalnya PlusMinus[1, -1, -1, 1]memberi True. Ini secara teoritis juga dapat digunakan sebagai operator ±, namun operator yang hanya sintaksis berlaku dalam konteks unary dan biner, sehingga konvensi pemanggilan akan mendapatkan aneh: ±##&[1,-1,-1,1]. Ini akan membuang banyak peringatan yang bisa diabaikan.

Ini juga akan melemparkan beberapa peringatan yang dapat diabaikan.

Ada mungkin berada jauh untuk mempersingkat agak mengganggu a!==b!||{a}==-{b}sebagian, tapi aku tidak menemukan apa-apa sekarang. Kata kunci suka SubsetQdan MatrixRankterlalu panjang. : /

Penjelasan

Solusi ini pada dasarnya menentang semua hal rumit pada pencocokan pola Mathematica dan karenanya sangat deklaratif dalam gaya. Terlepas dari beberapa golfitude di baris pertama, ini benar-benar hanya menambahkan tiga definisi berbeda untuk operator ±:

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

Dua baris pertama dipersingkat dengan menyarangkan definisi dan menyatakan Truesebagai 1>0.

Kita harus mendekonstruksi ini lebih jauh untuk menunjukkan bagaimana ini sebenarnya mendefinisikan fungsi variadci PlusMinusdengan hanya menggunakan notasi operator unary dan biner. Tangkapannya adalah bahwa semua operator hanyalah gula sintaksis untuk ekspresi penuh. Dalam kasus kami ±sesuai dengan PlusMinus. Kode berikut ini setara 100%:

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

Dengan menggunakan urutan (semacam percikan seperti dalam bahasa lain) sebagai operan untuk ±kita dapat membahas sejumlah argumen sewenang-wenang PlusMinus, meskipun ±tidak dapat digunakan dengan lebih dari dua argumen. Alasan mendasarnya adalah bahwa sintaksis gula diselesaikan terlebih dahulu, sebelum sekuens ini diperluas.

Aktif ke definisi:

Definisi pertama hanyalah mundur ( ___cocok dengan daftar argumen yang sewenang-wenang). Apa pun yang tidak cocok dengan definisi yang lebih spesifik di bawah ini akan memberikan False.

Definisi kedua adalah kasus dasar untuk OVSF, daftar yang hanya berisi 1. Kami mendefinisikan ini sebagai True.

Akhirnya, definisi ketiga hanya berlaku untuk daftar yang dapat didekomposisi menjadi X ++ Xatau X ++ -X, dan secara rekursif menggunakan hasilnya X. Definisi ini terbatas pada daftar-daftar ini dengan memastikan bahwa mereka dapat dibagi menjadi bagian-bagian berikutnya adan bdengan a__±b__dan kemudian melampirkan kondisi ( /;) yang salah satu {a}=={b}atau {a}==-{b}. Mendefinisikan PlusMinussebagai fungsi variadic dengan cara yang aneh ini melalui operator menghemat 5 byte kekalahan dari mendefinisikan operator unary ±pada daftar.

Tapi tunggu, masih ada lagi. Kami menggunakan a!==b!sebagai gantinya {a}=={b}. Jelas, kami melakukan ini karena dua byte lebih pendek, tetapi pertanyaan yang menarik adalah mengapa ini bekerja. Seperti yang saya jelaskan di atas, semua operator hanyalah gula sintaksis untuk beberapa ekspresi dengan kepala. {a}adalah List[a]. Tetapi aadalah urutan (seperti saya katakan, semacam seperti percikan dalam bahasa lain) jadi jika aini 1,-1,1maka kita mendapatkan List[1,-1,1]. Sekarang postfix !adalah Factorial. Jadi di sini, kita dapatkan Factorial[1,-1,1]. Tetapi Factorialtidak tahu apa yang harus dilakukan ketika memiliki jumlah argumen yang berbeda dari satu, jadi ini tetap tidak dievaluasi. ==tidak benar-benar peduli jika hal di kedua sisi adalah daftar, itu hanya membandingkan ekspresi, dan jika mereka sama itu memberiTrue(dalam hal ini, itu tidak akan benar-benar memberi Falsejika tidak, tetapi pola tidak cocok jika kondisi mengembalikan apa pun selain True). Jadi itu berarti, pemeriksaan kesetaraan masih berfungsi jika setidaknya ada dua elemen dalam daftar. Bagaimana jika hanya ada satu? Jika amasih 1maka a!masih 1. Jika aini -1kemudian a!memberikan ComplexInfinity. Sekarang, membandingkan 1dengan dirinya sendiri masih berfungsi dengan baik tentu saja. Tetapi ComplexInfinity == ComplexInfinitytetap tidak dievaluasi, dan meskipun tidak memberikan kebenaran a == -1 == b. Untungnya, ini tidak masalah, karena satu-satunya situasi yang muncul adalah PlusMinus[-1, -1]yang bukan OVSF yang valid pula! (Jika kondisinya kembali True, panggilan rekursif akan melaporkanFalselagipula, jadi tidak masalah kalau ceknya tidak berhasil.) Kita tidak bisa menggunakan trik yang sama karena {a}==-{b}karena -tidak akan di-threaded Factorial, itu hanya di-threaded List.

Pencocokan pola akan mengurus sisanya dan hanya menemukan definisi yang tepat untuk diterapkan.

Haskell, 57 byte

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

Diberikan daftar input l, tumbuhkan kode OVSF sdengan memulai dari [1]dan berulang kali menyatukan salah satu satau -s, mana yang membuat elemen pertama cocok dengan l. Kemudian, periksa hasilnya ldi akhir. Ini dicentang setelah smemiliki panjang setidaknya dari l.

Beberapa alternatif struktur rekursif juga terjadi untuk memberikan 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 / Oktaf , 94 byte

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

Ini menggunakan pendekatan baru: Kode OVSF mengizinkan panjang Nmuncul di log2(N)-th Walsh-matriks , karena mereka pada dasarnya ditentukan oleh rekursi yang sama:

Matriks Walsh adalah kasus khusus dari matriks Hadamard ukuran N x Njika Nkekuatan dua. (Ada juga matriks Hadamard dengan ukuran lain.) MATLAB dan Oktaf memiliki beragam fungsi bawaan yang menghasilkan matriks uji untuk menguji sifat-sifat algoritma numerik, di antaranya adalah hadamard(). Untungnya untuk kekuatan dua hadamard()usex MATLAB persis pembangunan matriks Welsh.

Jadi fungsi ini pertama-tama memeriksa apakah panjang input adalah kekuatan dua, dan jika ya, ia memeriksa apakah itu adalah deretan ukuran yang sesuai dengan matriks Welsh.

Cobalah online!

Python, 64 byte

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

Pisahkan daftar menjadi elemen yang diindeks genap dan elemen indeks yang aneh melalui potongan. Periksa apakah vektor hasil sama dengan atau negatif dengan mengalikannya dengan tanda yang dipaksakan oleh elemen pertama. Kemudian, lakukan pemeriksaan rekursif yang sama pada elemen genap.

Untuk kasus dasar, jika pemeriksaan gagal, tolak kecuali daftar tersebut [1]. Daftar kosong juga secara khusus ditolak untuk menghindari loop tak terbatas.

Strategi berbeda seperti jawaban Haskell saya memberikan 66 byte:

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 byte

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

Fungsi gmenghasilkan niterasi daftar (relatif tidak efisien, karena length $ g n == 3^n, namun jika kami menghapus duplikat, kami akan mendapatkan 2^n), fmemeriksa apakah daftar kami ada di salah satu dari mereka. Terima kasih kepada @Zgrab untuk beberapa petunjuk!

Cobalah online!

JavaScript (ES6), 130 93 87 85 83 byte

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

Demo

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 byte

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

Versi sebelumnya yang memeriksa elemen untuk memastikan bahwa mereka 1atau -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)

Penjelasan:

• Panjangnya tidak boleh nol
• Panjangnya haruslah kekuatan 2
• Elemen pertama harus 1
• Elemen dalam posisi yang memiliki kekuatan 2 harus berupa 1 atau -1
• Elemen di posisi lain adalah produk dari semua elemen di posisi yang sesuai dengan bitmask, misalnya a[22] == a[2] * a[4] * a[16]. Karena a[20] == a[4] * a[16]sudah diperiksa, hanya a[22] == a[2] * a[20]perlu diperiksa.
• Pemeriksaan di atas memberikan hasil yang merosot karena itidak memiliki setidaknya dua bit yang ditetapkan. Dalam kasus set bit nol, ia memeriksa itu a[0] == a[0] * a[0], yang salah untuk a[0] == -1, sedangkan dalam kasus set bit, ia memeriksa itu a[i] == a[0] * a[i].

MATL , 21 20 byte

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

Cobalah online! Atau verifikasi semua kasus uji .

Bagaimana itu bekerja

Kode membagi array menjadi dua bagian dengan panjang yang sama: yang pertama dengan entri yang diindeks ganjil, yang kedua dengan entri yang diindeks genap. Dua potong dipaksa memiliki panjang yang sama, dengan bantalan nol di detik jika diperlukan. Kemudian kode memeriksa itu

1. Entri yang sesuai dari kedua bagian itu semuanya sama atau berbeda;
2. Tidak ada entri di bagian kedua adalah nol;
3. Panjang potongan melebihi 1.

Jika ketiga kondisi ini terpenuhi, proses tersebut diterapkan kembali pada bagian pertama. Jika loop keluar karena panjangnya sudah 1, inputnya adalah kode OFSV. Kalau tidak, tidak.

Kondisi 1 yang diulang adalah versi yang setara dengan properti pendefinisian kode OVSF. Untuk larik dengan panjang say 8, pendekatan langsung adalah memeriksa bahwa entri 1,2,3,4 semuanya sama atau semuanya berbeda dengan entri 5,6,7,8 (ini adalah properti pendefinisian). Tetapi kita dapat memeriksa secara setara bahwa entri 1,3,5,7 semuanya sama atau berbeda dengan entri 2,4,6,8; dan ini ternyata menggunakan byte lebih sedikit.

Kondisi 2 memastikan bahwa panjang input adalah kekuatan 2: jika tidak, nol padding akan diperkenalkan pada beberapa tahap.

`        % 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 byte

Yay, daftar tak terbatas!

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

Versi alternatif:

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

APL, 46 byte

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

Cukup mudah:

• Kasus dasar:
  • 0::0: jika terjadi kesalahan, kembalikan 0
  • ⍵≡,1:1: jika inputnya tepat [1], kembalikan 1
  • ⍬≡⍵:0: jika inputnya adalah daftar kosong, kembalikan 0
• Kasus rekursif:
  • Z←.5×⍴⍵: Zadalah setengah panjang input
  • Y←⍵↓⍨Z: Yadalah bagian terakhir dari input (ini gagal jika ⍴⍵tidak rata, memicu pengendali pengecualian)
  • (∇Y)∨∇-Y: baik paruh terakhir daftar, atau negasi dari paruh terakhir daftar, harus berupa kode OVSF
  • (∇Z↑⍵)∧: dan paruh pertama daftar harus berupa kode OVSF.

Haskell, 69 68 byte

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

Contoh penggunaan: g [-1,1]-> False.

Bahkan lebih tidak efisien daripada jawaban @ flawr . Terlalu banyak waktu dan memori untuk 4 daftar elemen. Untuk melihat bahwa daftar kode OVSF (dengan banyak duplikat) sebenarnya dibuat, coba:

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

yang kembali

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

yaitu daftar dimulai dengan semua 16 daftar elemen (4 kali digabung, karena [1..4]), berlanjut dengan semua 8 daftar elemen dan seterusnya sampai berakhir dengan [1].

Sunting: @xnatau disimpan satu byte. Terima kasih!

Python 2 , 78 75 byte

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

Cobalah online!

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

Secara rekursif membangun dan memeriksa setiap daftar hingga panjang daftar input, dimulai dengan [1].

Nilai pengembalian adalah kebenaran atau falsey JS, khusus 1atau truejika valid, 0atau falseatau undefinedjika tidak valid.

Uji

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 byte

(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)))))

Membagi input cmenjadi dua bagian adan bdan memeriksa apakah produk elemen-bijaksana semuanya identik. Jika demikian, periksa apakah babak pertama adalah urutan yang benar.

Yang ini 142 byte tetapi saya merasa lebih menarik:

#((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))))))%)

loopmenghitung log_2panjang input, iteratemenghasilkan urutan iterasi yang banyak berdasarkan definisi. Ini mengembalikan argumen input jika urutannya valid dan nilsebaliknya.