Bir 1s ve -1s listesi verildiğinde , geçerli bir OVSF kodu olup olmadığını belirleyin (bir truthy veya falsey değeri yazarak).

OVSF kodları aşağıdaki gibi tanımlanır:

• [1] OVSF kodudur.

• Bir XOVSF kodu ise, o zaman X ++ Xve X ++ -Xher ikisi de OVSF kodlarıdır.

  İşte ++liste bitiştirme ve listedeki -her elemanı yok sayıyor.

• Başka hiçbir liste geçerli OVSF kodları değildir.

Sen girdi listesi yalnızca varsayabiliriz -1ve 1ancak uzunluğu 2 'lik bir güç değildir boş listeyi düzgün yanı sıra listelerini işlemesi gerekir.

En kısa kod (bayt cinsinden) kazanır.

Test durumları

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

Jöle , 18 16 14 11 bayt

^2/Eam2µḊ¿Ṭ

[1]OVSF kodları için çıkışlar (truthy), []aksi takdirde (sahte).

Çevrimiçi deneyin!

Arka fon

Gibi LuisMendo en Matl cevap @ ve @ XNOR Python cevap Bu gönderim doğrular "içeride out kadar" dizi.

İki ya da daha yüksek uzunlukta bir OVSF kodunun her biri (üst üste binmeyen) eleman çifti, esas olarak, aynı işaretlerle veya her iki işaretin takılı olduğu ilk çiftin bir kopyasıdır. Benzer şekilde, dört (veya daha yüksek) bir OVSF kodunun her bir (üst üste binmeyen) 4-parçalı elemanı, ilk 4-parçanın bir kopyasıdır, ya aynı işaretlerle ya da her iki işaretin takılı olmasıyla. Aynısı, OVFS kodunun uzunluğuna kadar, 8-tekiller, 16-tekiller vb. İçin de geçerlidir.

Bunu doğrulamanın bir yolu, önce işareti modulo için eşitlik için tüm çiftleri kontrol etmek ve ardından her bir çiftin ikinci elemanını kaldırmaktır (ki bu artık gereksizdir). Bu işlemi bir kez daha tekrarlarsak, esas olarak tüm 4 teli kontrol ediyoruz. Bir sonraki yinelemede 8-tuple vs. karşılaştırıyoruz.

Tüm gerekli olan 2 Son olarak, ^k -tuples eşit modülo işareti ve dizisi tekil düşürülmüştür, kalan elemanı olup olmadığını kontrol etmek için yeterli olan 1 .

Nasıl çalışır

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

Bayt sayısı, CP-1252 kodlamasını varsayıyor ve $CharacterEncodingayarlıyor WindowsANSI(varsayılan Windows kurulumlarında).

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

Bu PlusMinus, giriş listesini düz bir argüman listesi olarak alan ve bir boolean döndüren değişkenli bir işlevi tanımlar , örneğin PlusMinus[1, -1, -1, 1]verir True. Bir operatör olarak da teorik olarak kullanılabilir olduğunu ±, ancak çağrı kuralı garip alacağı böylece operatör, sadece sözdizimsel olarak geçerli tekli ve ikili bağlamlarda geçerli: ±##&[1,-1,-1,1]. Bu, göz ardı edilebilecek bir sürü uyarı verir.

Bu da göz ardı edilebilecek birkaç uyarı verecektir.

Orada olabilir biraz can sıkıcı kısaltmak için uzakta olmak a!==b!||{a}==-{b}parçasını, ama şu an hiçbir bulgu yok. Anahtar kelimeler gibi SubsetQve MatrixRankçok uzun. : /

açıklama

Çözüm temel olarak tüm zorlu şeyleri Mathematica'nın kalıp eşleştiricisine karşı koruyor ve bu nedenle stil açısından çok açıklayıcı. İlk satırdaki bazı golf oranlarının dışında, bu gerçekten operatör için üç farklı tanım ekliyor ±:

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

İlk iki satır, tanımların iç içe geçmesi ve olarak ifade Trueedilmesiyle kısaltılmıştır 1>0.

Bunun PlusMinus, sadece unary ve binary operator notasyonu kullanarak bir değişken değişken fonksiyonunu nasıl tanımladığını göstermek için bunu daha da yapılandırmalıyız . Catch, tüm operatörler tam ifadeler için basitçe sözdizimsel şekerdir. Bizim durumumuzda ±karşılık gelir PlusMinus. Aşağıdaki kod% 100 eşdeğerdir:

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

İkiden fazla argümanla kullanılamamasına rağmen , dizileri (diğer dillerdeki benzer uyarılar) işlenenler olarak ±kullanarak isteğe bağlı argümanları kapsayabiliriz . Temel sebep, bu dizilerin herhangi biri genişletilmeden önce, sözdizimsel şekerin ilk önce çözülmesidir.PlusMinus±

Tanımları açıkla:

İlk tanım basit bir geri dönüş ( ___rastgele bir argüman listesiyle eşleşiyor). Aşağıdaki daha spesifik tanımlarla eşleşmeyen her şey verecektir False.

İkinci tanım, sadece içeren liste olan OVSF için temel durumdur 1. Bunu tanımladık True.

Son olarak, üçüncü tanım sadece içine ayrıştırılabilecek listeler için geçerlidir X ++ Xveya X ++ -Xsonuçları yinelemeli olarak kullanır X. Tanım bu alt sıralar halinde bölünmüş olabilir sağlayarak bu listeler ile sınırlıdır ave bile a__±b__ve daha sonra durum (ekleme /;) ya {a}=={b}veya {a}==-{b}. Tanımlanması PlusMinusbir operatörün üzerinden bu garip bir şekilde variadic fonksiyonu olarak bir kuyruklu kaydeder 5 bir tek işlem işleci tanımlayan üzerinde bayt ±listelerinde.

Fakat bekleyin, dahası var. a!==b!Bunun yerine kullanıyoruz {a}=={b}. Açıkçası, bunu yapıyoruz çünkü iki byte daha kısa, ama ilginç soru neden işe yarıyor. Yukarıda açıkladığım gibi, tüm operatörler kafa ile bir ifade için sadece sözdizimsel şekerdir. {a}olduğunu List[a]. Ama abir olduğunu dizisi (Dediğim gibi çeşit diğer dillerde bir uyarının gibi) eğer öyleyse aolduğunu 1,-1,1o zaman olsun List[1,-1,1]. Şimdi postfix !olduğunu Factorial. Yani burada alacağız Factorial[1,-1,1]. Ancak Factorial, birbirinden farklı sayıda argüman olduğunda ne yapılacağını bilmez, bu nedenle bu basitçe değerlendirilmemiştir. ==Her iki taraftaki şeyin listelerde olması umrumda değil, sadece ifadeleri karşılaştırıyor ve eşit iseTrue(Bu durumda, Falseeğer yapmazlarsa aslında vermezler, ancak koşul başka bir şey döndürürse kalıplar eşleşmez True). Bu nedenle, listelerde en az iki unsur varsa eşitlik kontrolü hala çalışır. Ya sadece bir tane varsa? Eğer abir 1sonra a!hala 1. Eğer abir -1o a!verir ComplexInfinity. Şimdi, 1kendisiyle karşılaştırmak hala elbette iyi çalışıyor. Ancak ComplexInfinity == ComplexInfinitydeğerlenmemiş kalır ve yine de gerçek vermeza == -1 == b . Neyse ki, bu önemli değil, çünkü ortaya çıkan tek durum PlusMinus[-1, -1]zaten geçerli bir OVSF değil! (Durum Truedöndüyse, özyinelemeli çağrı rapor verecekFalseSonuçta, kontrolün işe yaramadığı önemli değil.) Aynı numarayı kullanamayız {a}==-{b}çünkü -iş parçacığı bitmez Factorial, sadece iş parçacığı biter List.

Desen eşleştiricisi geri kalanı halledecek ve basitçe uygulanacak doğru tanımı bulacaktır.

Haskell, 57 bayt

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

Verilen giriş listesi l, ilk elemanın hangisine uyduğunu veya hangisi ile sbaşlayıp [1]tekrar tekrar birleştirerek bir OVSF kodu oluşturur . Ardından sonucun sonunda olduğunu kontrol eder . Bu kontrol bir kez en az bir uzunluğa sahiptir .s-sllsl

Bazı alternatifler özyinelemeli yapılar da 57 verdi:

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

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

Bu yeni bir yaklaşım kullanıyor: uzunlukta izin OVSF kodları Ngörünür log2(N)th Walsh-matris temel olarak aynı yineleme ile tanımlandığı gibi olduğu:

Walsh matrisleri özel durumlarıdır A. Edison-matrisleri boyutu N x NiseN ikisinin bir güçtür. (Diğer boyutlarda Hadamard matrisleri de vardır.) MATLAB ve Octave, sayısal algoritmaların özelliklerini test etmek için test matrisleri üreten çeşitli fonksiyonlara sahiptir hadamard(). Neyse ki iki hadamard()MATLAB'ın yetkileri için, ustalıkla Galce matrislerinin inşası.

Dolayısıyla bu fonksiyon ilk önce giriş uzunluğunun iki gücünün olup olmadığını kontrol eder ve eğer öyleyse, karşılık gelen boyutta Galce-matrisin bir satırı olup olmadığını kontrol eder.

Çevrimiçi deneyin!

Python, 64 bayt

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

Listeyi çift dizinli öğelere ve tek dizinli öğelere dilimler halinde böler. Sonuç vektörlerinin ilk eleman tarafından zorlanan işaret ile çarpılarak eşit veya negatif olup olmadığını kontrol eder. Sonra, aynı indeksli çift indeksli elemanlar üzerinde kontrol eder.

Temel durumda, kontrol başarısız olursa, liste olmadığı sürece reddeder [1]. Boş liste ayrıca sonsuz bir döngüyü önlemek için özellikle reddedilir.

Haskell cevabım gibi farklı bir strateji 66 bayt veriyor:

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 bayt

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

İşlev , listelerin yinelemesini goluşturur n(göreceli olarak verimli değil, çünkü length $ g n == 3^nyinelemeleri silersek alacağız 2^n), flistemizin herhangi birinde olup olmadığını kontrol eder. Birkaç ipucu için @ Zgrab'a teşekkürler!

Çevrimiçi deneyin!

JavaScript (ES6), 130 93 87 85 83 bayt

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

gösteri

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 bayt

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

Olduklarını sağlamak için elemanlar kontrol Önceki sürüm 1veya -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)

Açıklama:

• Uzunluk sıfır olamaz
• Uzunluk 2 güç olmalıdır
• İlk eleman 1 olmalı
• 2 olan bir pozisyondaki elemanlar 1 veya -1 olmalıdır
• Diğer pozisyonlardaki elemanlar, tüm unsurların bit maskesine karşılık gelen pozisyonlardaki ürünleridir a[22] == a[2] * a[4] * a[16]; Yana a[20] == a[4] * a[16]zaten kontrol edilmiştir, sadece a[22] == a[2] * a[20]kontrol edilmesi gerekmektedir.
• Yukarıdaki kontrol, ien az iki bit ayarlanmamış olduğu için yozlaşmış sonuçlar verir . Sıfır bitlerin ayarlanması durumunda, bir bitlik bir ayar durumunda a[0] == a[0] * a[0], bunun yanlış olduğu sonucunu a[0] == -1kontrol eder a[i] == a[0] * a[i].

MATL , 21 20 bayt

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

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

Nasıl çalışır

Kod, diziyi iki eşit uzunlukta parçaya böler: birincisi tek dizinli girişleri, ikincisi çift dizinli girişleri içerir. İki parça, gerekirse ikinci bir dolgu sıfırıyla eşit uzunlukta olmaya zorlanır. Sonra kod bu kontrol eder

1. İki parçanın karşılık gelen girişleri ya tamamen eşit ya da tamamen farklıdır;
2. İkinci parçadaki giriş sıfır değil;
3. Parçaların uzunluğu 1'i aşıyor.

Bu üç koşul yerine getirilirse, işlem ilk parçaya tekrar uygulanır. Döngü uzunluğu zaten 1 olduğundan çıkıldıysa, giriş bir OFSV kodudur. Başka değil.

Yinelenen Durum 1, OVSF kodlarının tanımlayıcı özelliğinin eşdeğer bir versiyonudur. Sözü geçen uzunluğu 8 olan bir dizi için basit yaklaşım, 1,2,3,4 girişlerinin sırasıyla 5,6,7,8 girişlerine eşit veya tamamen farklı olup olmadığını kontrol etmek olacaktır (bu tanımlayıcı özelliktir). Ancak, 1,3,5,7 girişlerinin sırasıyla 2,4,6,8 girişlerine eşit veya tamamen farklı olduğunu kontrol edebiliriz; ve bu daha az byte kullanmaktadır.

Koşul 2, giriş uzunluğunun 2 değerinde bir güç olmasını sağlar: eğer değilse, bir aşamada bir doldurma sıfırı verilir.

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

Yay, sonsuz listeler!

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

Alternatif versiyonlar:

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

APL, 46 bayt

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

Yeterince açıksözlü:

• Temel durumlar:
  • 0::0: bir hata oluşursa, 0 döndür
  • ⍵≡,1:1: giriş tam olarak ise [1], 1 döndür
  • ⍬≡⍵:0: giriş boş liste ise, 0 döndür
• Özyinelemeli dava:
  • Z←.5×⍴⍵: Zgirişin yarısı kadar
  • Y←⍵↓⍨Z: Ygirişin son yarısıdır ( ⍴⍵dengesizse bu durum başarısız olur , istisna işleyicisini tetikler)
  • (∇Y)∨∇-Y: listenin son yarısı veya listenin son yarısının ihmali OVSF kodu olmalıdır.
  • (∇Z↑⍵)∧: ve listenin ilk yarısı bir OVSF kodu olmalıdır.

Haskell, 69 68 bayt

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

Kullanım örneği: g [-1,1]->False .

@ Flawr'ın cevabından çok daha fazla verimsiz . 4 element listesi için çok fazla zaman ve hafıza gerekiyor. OVSF kodlarının listesinin (bir çok kopya ile birlikte) gerçekten oluşturulduğunu görmek için şunu deneyin:

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

hangi döner

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

yani liste, 16 öğe listesinin tamamı ile başlar (çünkü, 4 kez birleştirilmiş) [1..4] ), 8 öğe listesinin tümü ile devam eder, vb [1].

Düzenleme: @xnor bir bayt kaydetti. Teşekkürler!

Python 2 , 78 75 bayt

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

Çevrimiçi deneyin!

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

Her listeyi tekrar tekrar oluşturur ve giriş listesinin uzunluğuna kadar kontrol eder [1] .

Dönüş değeri özellikle JS truthy veya Falsey olduğu 1ya true, eğer geçerli 0ya falseyaundefined geçerli değilse.

Ölçek

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 bayt

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

Böler giriş cikiye ave bve bunların öğeye ürünler her aynıysa kontroller. Eğer öyleyse, ilk yarının geçerli bir sıralama olduğunu kontrol eder.

Bu bir 142 bayt ama daha ilginç buldum:

#((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 hesaplar log_2girişin uzunluğunuiterate , tanımlamaya dayanarak bu yinelemelerin dizisini oluşturur. Bu, geçerli bir dizi ise nilaksi takdirde girdi argümanını döndürür .