Đưa ra một danh sách 1s và -1s, xác định xem đó có phải là mã OVSF hợp lệ hay không (bằng cách xuất ra giá trị trung thực hoặc giá trị falsey).

Mã OVSF được định nghĩa như sau:

• [1] là mã OVSF.

• Nếu Xlà một mã OVSF, sau đó X ++ Xvà X ++ -Xđược cả hai mã OVSF.

  Dưới đây ++là nối danh sách, và -phủ nhận mọi yếu tố trong danh sách.

• Không có danh sách khác là mã OVSF hợp lệ.

Bạn có thể giả sử danh sách đầu vào chỉ chứa -1và 1, nhưng bạn phải xử lý chính xác danh sách trống, cũng như danh sách có độ dài không phải là 2.

Mã ngắn nhất (tính bằng byte) sẽ thắng.

Các trường hợp thử nghiệm

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

Thạch , 18 16 14 11 byte

^2/Eam2µḊ¿Ṭ

Đầu ra [1](trung thực) cho mã OVSF, [](giả mạo) nếu không.

Hãy thử trực tuyến!

Lý lịch

Giống như câu trả lời MATL của @ LuisMendo và câu trả lời Python của @ xnor , bài nộp này xác minh mảng đầu vào "từ trong ra ngoài".

Mỗi cặp phần tử (không chồng lấp) của mã OVSF có độ dài từ hai trở lên về cơ bản là một bản sao của cặp đầu tiên, có cùng dấu hiệu hoặc có cả hai dấu hiệu được hoán đổi. Tương tự như vậy, cứ 4 phần tử (không chồng chéo) của các phần tử của mã OVSF có độ dài bốn hoặc cao hơn về cơ bản là một bản sao của 4 tuple đầu tiên, có cùng dấu hiệu hoặc có cả hai dấu hiệu được hoán đổi. Điều tương tự cũng đúng với 8-tuples, 16-tuple, v.v., cho đến độ dài của mã OVFS.

Một cách để xác minh điều này là kiểm tra tất cả các cặp về sự cân bằng modulo trước, sau đó loại bỏ phần tử thứ hai của mỗi cặp (hiện là thông tin dư thừa). Nếu chúng tôi lặp lại quy trình này một lần nữa, về cơ bản chúng tôi sẽ kiểm tra tất cả 4 bộ dữ liệu. Trong lần lặp lại tiếp theo, chúng tôi đang so sánh 8-tuple, v.v.

Cuối cùng, nếu tất cả 2 ^k- tuple yêu cầu đều bằng modulo thì dấu và mảng đã được giảm xuống thành một đơn, đủ để kiểm tra xem phần tử còn lại có phải là 1 không .

Làm thế nào nó hoạt động

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

Toán học, 52 47 45 byte

Số lượng byte giả định mã hóa CP-1252 và $CharacterEncodingđược đặt thành WindowsANSI(mặc định trên các cài đặt Windows).

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

Điều này xác định một hàm matrixdic PlusMinus, lấy danh sách đầu vào là một danh sách phẳng các đối số và trả về một boolean, ví dụ PlusMinus[1, -1, -1, 1]cho True. Về mặt lý thuyết cũng có thể sử dụng như một toán tử ±, nhưng toán tử đó chỉ có giá trị về mặt cú pháp trong các bối cảnh đơn nhất và nhị phân, vì vậy quy ước gọi sẽ trở nên kỳ lạ : ±##&[1,-1,-1,1]. Nó sẽ ném một loạt các cảnh báo có thể bỏ qua.

Điều này cũng sẽ đưa ra một vài cảnh báo có thể bỏ qua.

Có thể có cách để rút ngắn phần hơi khó chịu a!==b!||{a}==-{b}, nhưng tôi không tìm thấy gì ngay bây giờ. Từ khóa thích SubsetQvà MatrixRankđơn giản là quá dài. : /

Giải trình

Giải pháp về cơ bản trì hoãn tất cả những điều khó khăn đối với trình so khớp mẫu của Mathicala và do đó rất có tính khai báo. Ngoài một số sân golf trên dòng đầu tiên, điều này thực sự chỉ cần thêm ba định nghĩa khác nhau cho người vận hành ±:

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

Hai hàng đầu tiên được rút ngắn bằng cách lồng các định nghĩa và biểu thị Truedưới dạng 1>0.

Chúng ta nên giải mã điều này hơn nữa để chỉ ra cách thức này thực sự xác định hàm matrixdci PlusMinusbằng cách chỉ sử dụng ký hiệu toán tử đơn nguyên và nhị phân. Điều hấp dẫn là tất cả các toán tử chỉ đơn giản là cú pháp đường cho các biểu thức đầy đủ. Trong trường hợp của chúng tôi ±tương ứng với PlusMinus. Các mã sau đây tương đương 100%:

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

Bằng cách sử dụng các chuỗi (sắp xếp các biểu tượng giống như trong các ngôn ngữ khác) làm toán hạng cho ±chúng ta có thể bao gồm một số lượng đối số tùy ý PlusMinus, mặc dù ±không thể sử dụng được nhiều hơn hai đối số. Lý do cơ bản là đường cú pháp được giải quyết trước tiên, trước khi bất kỳ chuỗi nào trong số này được mở rộng.

Về định nghĩa:

Định nghĩa đầu tiên chỉ đơn giản là một dự phòng ( ___khớp với một danh sách các đối số tùy ý). Bất cứ điều gì không phù hợp với các định nghĩa cụ thể hơn dưới đây sẽ cung cấp False.

Định nghĩa thứ hai là trường hợp cơ sở cho OVSF, danh sách chỉ chứa 1. Chúng tôi xác định điều này là True.

Cuối cùng, định nghĩa thứ ba chỉ áp dụng cho các danh sách có thể được phân tách thành X ++ Xhoặc X ++ -X, và sử dụng đệ quy kết quả cho X. Định nghĩa được giới hạn ở các danh sách này bằng cách đảm bảo họ có thể được chia thành subsequences avà bvới a__±b__và sau đó gắn các điều kiện ( /;) mà một trong hai {a}=={b}hoặc {a}==-{b}. Xác định PlusMinuslà một hàm matrixdic theo cách kỳ lạ này thông qua một toán tử tiết kiệm được 5 byte so với việc xác định một toán tử đơn nguyên ±trong danh sách.

Nhưng xin chờ chút nữa. Chúng tôi đang sử dụng a!==b!thay vì {a}=={b}. Rõ ràng, chúng tôi đang làm điều này bởi vì nó ngắn hơn hai byte, nhưng câu hỏi thú vị là tại sao nó hoạt động. Như tôi đã giải thích ở trên, tất cả các toán tử chỉ là đường cú pháp cho một số biểu thức với một cái đầu. {a}là List[a]. Nhưng alà một chuỗi (như tôi đã nói, giống như một splat trong các ngôn ngữ khác) vì vậy nếu acó 1,-1,1thì chúng ta sẽ nhận được List[1,-1,1]. Bây giờ hậu tố !là Factorial. Vì vậy, ở đây, chúng tôi sẽ nhận được Factorial[1,-1,1]. Nhưng Factorialkhông biết phải làm gì khi nó có số lượng đối số khác nhau, vì vậy điều này chỉ đơn giản là không được đánh giá. ==không thực sự quan tâm nếu thứ ở cả hai phía là danh sách, nó chỉ so sánh các biểu thức và nếu chúng bằng nhau thì nó mang lạiTrue(trong trường hợp này, nó sẽ không thực sự cung cấp Falsenếu chúng không có, nhưng các mẫu không khớp nếu điều kiện trả về bất cứ thứ gì khác True). Điều đó có nghĩa là, kiểm tra đẳng thức vẫn hoạt động nếu có ít nhất hai yếu tố trong danh sách. Nếu chỉ có một thì sao? Nếu alà 1thì a!vẫn còn 1. Nếu alà -1thì a!cho ComplexInfinity. Bây giờ, so sánh 1với chính nó vẫn hoạt động tốt tất nhiên. Nhưng ComplexInfinity == ComplexInfinityvẫn không được đánh giá, và mặc dù không đúng a == -1 == b. May mắn thay, điều này không thành vấn đề, bởi vì tình huống duy nhất này xuất hiện là PlusMinus[-1, -1]dù sao đó không phải là một OVSF hợp lệ! (Nếu điều kiện đã trở lại True, cuộc gọi đệ quy sẽ báo cáoFalsesau tất cả, do đó, việc kiểm tra không thành công.) Chúng tôi không thể sử dụng cùng một mẹo {a}==-{b}vì -không xử lý được Factorial, nó chỉ xử lý List.

Bộ so khớp mẫu sẽ chăm sóc phần còn lại và chỉ cần tìm định nghĩa chính xác để áp dụng.

Haskell, 57 byte

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

Đưa ra danh sách đầu vào l, phát triển mã OVSF sbằng cách bắt đầu từ [1]và liên tục nối hoặc shoặc -sbất kỳ phần tử nào khớp với phần tử đầu tiên khớp với l. Sau đó, kiểm tra xem kết quả lở cuối. Điều này được kiểm tra một lần scó chiều dài ít nhất là l.

Một số cấu trúc đệ quy thay thế cũng đã xảy ra để cung cấp cho 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 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

Đây là cách sử dụng một cách tiếp cận mới: Các mã độ dài OVSF được phép Nxuất hiện trong ma trận Walshlog2(N) -th , vì về cơ bản chúng được xác định bởi cùng một đệ quy:

Ma trận Walsh là trường hợp đặc biệt của ma trận Hadamard có kích thước N x Nnếu Nlà lũy thừa của hai. (Ngoài ra còn có ma trận Hadamard có kích thước khác.) MATLAB và Octave có nhiều hàm dựng sẵn tạo ra ma trận thử nghiệm để kiểm tra các thuộc tính của thuật toán số, trong số đó có hadamard(). May mắn thay cho sức mạnh của hai MATLAB là hadamard()chính xác việc xây dựng các ma trận tiếng Wales.

Vì vậy, chức năng này trước tiên kiểm tra xem độ dài đầu vào có phải là lũy thừa của hai hay không và nếu có, nó sẽ kiểm tra xem đó có phải là một hàng của ma trận kích thước Wales tương ứng hay không.

Hãy thử trực tuyến!

Python, 64 byte

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

Chia danh sách thành các phần tử được lập chỉ mục chẵn và phần tử được lập chỉ mục lẻ thông qua các lát. Kiểm tra xem các vectơ kết quả có bằng hoặc âm bằng cách nhân một với dấu được buộc bởi phần tử đầu tiên của nó không. Sau đó, thực hiện kiểm tra đệ quy tương tự trên các phần tử được lập chỉ mục chẵn.

Đối với trường hợp cơ sở, nếu kiểm tra thất bại, từ chối trừ khi danh sách là [1]. Danh sách trống cũng đặc biệt bị từ chối để tránh vòng lặp vô hạn.

Một chiến lược khác như câu trả lời Haskell của tôi cho 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

Hàm gtạo ra các nlần lặp của danh sách (tương đối không hiệu quả, length $ g n == 3^ntuy nhiên, nếu chúng tôi xóa các bản sao, chúng tôi sẽ nhận được 2^n), fkiểm tra xem danh sách của chúng tôi có nằm trong bất kỳ danh sách nào không. Cảm ơn @Zgrab cho một vài gợi ý!

Hãy thử trực tuyến!

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

Bản giới thiệu

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

Phiên bản trước đã kiểm tra các yếu tố để đảm bảo rằng chúng là 1hoặc -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)

Giải trình:

• Độ dài không thể bằng không
• Độ dài phải là lũy thừa của 2
• Phần tử đầu tiên phải là 1
• Các phần tử ở vị trí có lũy thừa bằng 2 phải là 1 hoặc -1
• Các phần tử ở các vị trí khác là sản phẩm của tất cả các phần tử trong các vị trí tương ứng với bitmask, vd a[22] == a[2] * a[4] * a[16]. Vì a[20] == a[4] * a[16]đã được kiểm tra, chỉ a[22] == a[2] * a[20]cần được kiểm tra.
• Kiểm tra trên cho kết quả suy biến vì ikhông có ít nhất hai bit được đặt. Trong trường hợp tập hợp các bit 0, nó kiểm tra xem a[0] == a[0] * a[0], đó là sai a[0] == -1, trong khi trong trường hợp tập một bit, nó sẽ kiểm tra xem a[i] == a[0] * a[i].

MATL , 21 20 byte

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

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

Mã này chia mảng thành hai phần có độ dài bằng nhau: phần đầu tiên với các mục được lập chỉ mục lẻ, phần thứ hai với các mục được lập chỉ mục chẵn. Hai mảnh được buộc phải có chiều dài bằng nhau, với phần đệm bằng 0 trong giây nếu cần. Sau đó, mã kiểm tra rằng

1. Các mục tương ứng của hai phần đều bằng nhau hoặc khác nhau;
2. Không có mục trong phần thứ hai là không;
3. Độ dài của các mảnh vượt quá 1.

Nếu ba điều kiện này được đáp ứng, quy trình được áp dụng lại trên phần đầu tiên. Nếu vòng lặp được thoát vì độ dài đã là 1, thì đầu vào là mã OFSV. Khác thì không.

Điều kiện 1 lặp là phiên bản tương đương của thuộc tính xác định của mã OVSF. Đối với một mảng có độ dài 8, cách tiếp cận đơn giản sẽ là kiểm tra xem các mục 1,2,3,4 có bằng nhau hay khác với các mục 5,6,7,8 tương ứng (đây là thuộc tính xác định). Nhưng chúng ta có thể kiểm tra tương ứng rằng các mục 1,3,5,7 đều bằng nhau hoặc hoàn toàn khác với các mục 2,4,6,8 tương ứng; và điều này hóa ra là sử dụng ít byte hơn.

Điều kiện 2 đảm bảo rằng độ dài đầu vào là công suất 2: nếu không, phần đệm số 0 sẽ được giới thiệu ở một số giai đoạn.

`        % 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, danh sách vô hạn!

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

Phiên bản thay thế:

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×⍴⍵}

Khá đơn giản:

• Các trường hợp cơ sở:
  • 0::0: nếu xảy ra lỗi, trả về 0
  • ⍵≡,1:1: nếu đầu vào là chính xác [1], trả về 1
  • ⍬≡⍵:0: nếu đầu vào là danh sách trống, trả về 0
• Trường hợp đệ quy:
  • Z←.5×⍴⍵: Zlà một nửa chiều dài của đầu vào
  • Y←⍵↓⍨Z: Ylà nửa cuối của đầu vào (điều này không thành công nếu ⍴⍵không đồng đều, kích hoạt trình xử lý ngoại lệ)
  • (∇Y)∨∇-Y: hoặc nửa cuối của danh sách, hoặc phủ định của nửa cuối của danh sách, phải là mã OVSF
  • (∇Z↑⍵)∧: và nửa đầu của danh sách phải là mã OVSF.

Haskell, 69 68 byte

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

Ví dụ sử dụng: g [-1,1]-> False.

Thậm chí không hiệu quả hơn câu trả lời của @ flawr . Phải mất quá nhiều thời gian và bộ nhớ cho danh sách 4 yếu tố. Để thấy rằng danh sách mã OVSF (có rất nhiều bản sao) thực sự được tạo, hãy thử:

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

trả về

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

tức là danh sách bắt đầu với tất cả 16 danh sách thành phần (được nối 4 lần, vì [1..4]), tiếp tục với tất cả 8 danh sách thành phần và cứ tiếp tục như vậy cho đến khi kết thúc [1].

Chỉnh sửa: @xnor đã lưu một byte. Cảm ơn!

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

Hãy thử trực tuyến!

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

Xây dựng đệ quy và kiểm tra từng danh sách cho đến độ dài của danh sách đầu vào, bắt đầu bằng [1].

Giá trị trả về là JS truthy hoặc falsey, cụ thể 1hoặc truenếu hợp lệ, 0hoặc falsehoặc undefinednếu không hợp lệ.

Kiểm tra

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

Chia đầu cvào thành hai nửa avà bkiểm tra xem các sản phẩm nguyên tố của chúng có giống nhau không. Nếu vậy, kiểm tra xem nửa đầu là chuỗi hợp lệ.

Cái này là 142 byte nhưng tôi thấy nó thú vị hơn:

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

looptính toán log_2độ dài của đầu vào, iteratetạo ra các chuỗi của nhiều lần lặp đó dựa trên định nghĩa. Điều này trả về đối số đầu vào nếu nó là một chuỗi hợp lệ và mặt nilkhác.