1s 및 -1s 목록 이 제공되면 유효한 OVSF 코드 인지 여부를 확인하십시오 (진실 또는 거짓 값 출력).

OVSF 코드는 다음과 같이 정의됩니다.

• [1] OVSF 코드입니다.

• 경우 X다음에, OVSF 코드 X ++ X와 X ++ -X모두 OVSF 코드입니다.

  다음 ++은 목록 연결이며 목록의 -모든 요소를 ​​무효화합니다.

• 유효한 다른 OVSF 코드 목록은 없습니다.

입력 목록에 -1and 만 포함되어 있다고 가정 할 수 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 코드의 출력 (거짓), []그렇지 않은 경우 (거짓)

온라인으로 사용해보십시오!

배경

마찬가지로 LuisMendo의 MATL 응답 @ 및 @ XNOR의 파이썬 대답 이 제출 검증한다 "내부의 출력에서"입력 배열.

길이가 2 이상인 OVSF 코드의 모든 (중첩되지 않은) 요소 쌍은 본질적으로 동일한 부호 또는 두 부호가 바뀐 첫 번째 쌍의 사본입니다. 마찬가지로, 길이가 4 이상인 OVSF 코드의 모든 (겹치지 않는) 4 튜플 요소는 본질적으로 동일한 부호 또는 두 부호가 바뀐 첫 번째 4 튜플의 사본입니다. 8- 튜플, 16- 튜플 등의 경우에도 OVFS 코드 길이까지 동일합니다.

이를 확인하는 한 가지 방법은 모든 쌍이 동일한 모듈로 부호를 먼저 확인한 다음 각 쌍의 두 번째 요소 (이전 정보 임)를 제거하는 것입니다. 이 과정을 한 번 더 반복하면 기본적으로 4 개의 튜플을 모두 확인하는 것입니다. 다음 반복에서는 8 튜플 등을 비교합니다.

마지막으로, 필요한 모든 ^2k 튜플이 부호가 같고 배열이 단일 톤으로 줄어든 경우 나머지 요소가 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

이 함수는 가변적 인 함수를 정의하는데 PlusMinus,이 함수 는 입력 목록을 단순한 인수 목록으로 가져오고 부울을 반환합니다 (예 : PlusMinus[1, -1, -1, 1]gives) True. 이론적으로 operator로도 사용할 수 ±있지만이 연산자는 단항 및 이진 컨텍스트에서만 구문 적으로 유효하므로 호출 규칙이 이상 ±##&[1,-1,-1,1]합니다. 무시할 수있는 많은 경고가 발생합니다.

또한 무시할 수있는 몇 가지 경고가 표시됩니다.

이 수 다소 성가신 단축 멀리 할 a!==b!||{a}==-{b}부분,하지만 난 지금 아무것도 발견 아니에요. 키워드 좋아 SubsetQ하고 MatrixRank너무 오래 간단하다. : /

설명

이 솔루션은 기본적으로 모든 까다로운 것을 Mathematica의 패턴 매처에 지연 시키므로 스타일이 매우 선언적입니다. 첫 번째 줄에서 골프를 치르는 것 외에도 연산자에 대한 세 가지 정의가 추가됩니다 ±.

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

처음 두 행은 정의를 중첩하고로 표현 True하여 줄 1>0였습니다.

PlusMinus단항 및 이항 연산자 표기법 만 사용하여 variadci 함수 를 실제로 정의하는 방법을 보여주기 위해 이것을 더 분해해야합니다 . 중요한 것은 모든 연산자가 완전한 표현을 위해 단순히 구문 설탕이라는 것입니다. 우리의 경우에 ±해당합니다 PlusMinus. 다음 코드는 100 % 동일합니다.

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

하기 피연산자 (다른 언어의 표시가 같은 것이들) 시퀀스를 이용하여 ±우리가 임의의 인수 수를 포함 할 PlusMinus지라도, ±둘 개 이상의 인수를 사용할 수 없습니다. 근본적인 이유는 이러한 서열 중 하나가 확장되기 전에 구문 설탕이 먼저 분해되기 때문입니다.

정의에 :

첫 번째 정의는 단순히 폴백입니다 ( ___임의의 인수 목록과 일치). 아래의 더 구체적인 정의와 일치하지 않는 모든 것이 제공 False됩니다.

두 번째 정의는 OVSF의 기본 사례이며이 목록에는 1. 이것을로 정의합니다 True.

마지막으로, 세 번째 정의는 또는 로 분해 될 수있는 목록 에만 적용 되며 에 대한 결과를 재귀 적으로 사용합니다 . 정의는 이들이 서브 시퀀스로 분할 할 수 있도록함으로써 이러한리스트로 제한 과 함께 다음 조건 (부착 )하거나 또는 . 정의 연산자를 통해이 이상한 방식으로 가변 함수로하는 것은 무려 저장 5 단항 연산자를 정의하는 바이트 이상 목록에 있습니다.X ++ XX ++ -XXaba__±b__/;{a}=={b}{a}==-{b}PlusMinus±

그러나 더 많은 것이 있습니다. 우리는 a!==b!대신에 사용 하고 {a}=={b}있습니다. 분명히 우리는 2 바이트가 더 짧기 때문에이 작업을 수행하지만 흥미로운 질문은 왜 작동하는지입니다. 위에서 설명했듯이 모든 연산자는 머리를 가진 표현의 구문 설탕 일뿐입니다. {a}입니다 List[a]. 그러나 aA는 순서는 (내가 말한 같은 종류의 다른 언어로 표시와 같은) 그렇다면 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평가되지 않은 남아 있고, 하지 않는 경우에도 마찬가지 제공 a == -1 == b. 운 좋게도 이것은 중요하지 않습니다. 왜냐하면 이것이 나타나는 유일한 상황은 PlusMinus[-1, -1]어쨌든 유효한 OVSF가 아닙니다! (조건이 반환 True되면 재귀 호출이보고합니다.False결국, 그것은 문제가되지 않도록 검사가 작동하지 않습니다.) 우리가 같은 트릭을 사용할 수 없습니다 {a}==-{b}(가) 있기 때문에 -이상 스레드 않을 것이다 Factorial, 그것은 단지를 통해 스레드 List.

패턴 매처는 나머지를 처리하고 적용 할 올바른 정의를 찾기 만합니다.

하스켈, 57 바이트

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

입력 목록이 주어지면 또는 첫 번째 요소와 일치하는 요소 중 하나 를 시작하여 반복적으로 연결 l하여 OVSF 코드 를 확장 합니다. 그런 다음 결과가 끝났 는지 확인합니다 . 이 길이는 길이가 적어도 한 번 확인 됩니다.s[1]s-sllsl

재귀 구조 중 일부는 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 / 옥타브 , 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에 나타납니다 .

월시 행렬은 2의 거듭 제곱 인 경우 크기 의 하다 마드 행렬 의 특수한 경우입니다 . (다른 크기의하다 마드 행렬도 있습니다.) MATLAB과 Octave에는 숫자 알고리즘의 속성을 테스트하기 위해 테스트 행렬을 생성하는 다양한 내장 함수가 있습니다. 다행스럽게도 웨일스 행렬의 구조를 정확하게 구성 하는 두 MATLAB의 강력한 성능에 대해.N x NNhadamard()hadamard()

따라서이 함수는 먼저 입력 길이가 2의 거듭 제곱인지 확인하고, 그렇다면 길이가 해당 크기의 웨일스 행렬의 행인지 확인합니다.

온라인으로 사용해보십시오!

파이썬, 64 바이트

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

목록을 슬라이스를 통해 짝수 색인 요소와 홀수 색인 요소로 분할합니다. 첫 번째 요소에 의해 강제 된 부호에 1을 곱하여 결과 벡터가 같거나 음수인지 확인합니다. 그런 다음 짝수 색인 요소에 대해 동일한 재귀 검사를 수행합니다.

기본 사례의 경우, 확인에 실패하면 목록이 아닌 경우 거부합니다 [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

하스켈 , 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에게 감사드립니다!

온라인으로 사용해보십시오!

자바 스크립트 (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)}`))

자바 스크립트 (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)

설명:

• 길이는 0이 될 수 없습니다
• 길이는 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적어도 2 비트 세트를 갖지 않은 것에 대한 퇴화 결과를 제공한다 . 비트가 0으로 설정되어 있으면를 확인하고 a[0] == a[0] * a[0], a[0] == -11을 설정하면 1을 설정합니다 a[i] == a[0] * a[i].

MATL , 21 20 바이트

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

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

이 코드는 배열을 동일한 길이의 두 조각으로 나눕니다. 첫 번째는 홀수 색인 항목이고 두 번째는 짝수 색인 항목입니다. 두 조각의 길이는 동일해야하며 필요한 경우 초 단위로 패딩이 0이됩니다. 그런 다음 코드는

1. 두 조각의 해당 항목은 모두 같거나 모두 다릅니다.
2. 두 번째 조각의 항목은 0이 아닙니다.
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의 거듭 제곱인지 확인합니다. 그렇지 않으면 일부 단계에서 패딩 0이 도입됩니다.

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

하스켈, 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 코드 여야합니다.

하스켈, 69 68 바이트

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

사용 예 : g [-1,1]-> False.

@ flawr 's answer 보다 훨씬 비효율적 입니다. 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은 바이트를 저장했습니다. 감사!

파이썬 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

온라인으로 사용해보십시오!

자바 스크립트 (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의 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+']')
})

클로저, 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.