Giới thiệu

Tôi đã định nghĩa lớp hoán vị antsy trong một thử thách trước đó . Xin nhắc lại, một hoán vị p của các số từ 0 đến r-1 là antsy, nếu với mỗi mục p [i] ngoại trừ mục đầu tiên, có một số mục nhập p [ik] trước đó sao cho p [i] == p [ ik] ± 1 . Là một thực tế thú vị, tôi cũng nói rằng cho r ≥ 1 , có chính xác 2 ^r-1 hoán vị antsy chiều dài r . Điều này có nghĩa là có một sự tương ứng một-một giữa các hoán vị antsy có độ dài r và các vectơ nhị phân có độ dài r-1. Trong thử thách này, nhiệm vụ của bạn là thực hiện một sự tương ứng như vậy.

Nhiệm vụ

Nhiệm vụ của bạn là viết một chương trình hoặc hàm lấy một vectơ nhị phân có độ dài 1 ≤ n 99 , và đưa ra một hoán vị antsy có độ dài n + 1 . Hoán vị có thể là 0 dựa trên 1 dựa trên (nhưng điều này phải nhất quán) và đầu vào và đầu ra có thể ở bất kỳ định dạng hợp lý nào. Hơn nữa, các đầu vào khác nhau phải luôn cho đầu ra khác nhau; ngoài điều đó, bạn có thể tự do trả lại bất kỳ hoán vị antsy nào bạn muốn.

Số byte thấp nhất sẽ thắng.

Thí dụ

Các hoán vị antsy (dựa trên 0) có độ dài 4 là

0 1 2 3
1 0 2 3
1 2 0 3
1 2 3 0
2 1 0 3
2 1 3 0
2 3 1 0
3 2 1 0

và chương trình của bạn sẽ trả về một trong số chúng cho mỗi vectơ tám bit có độ dài 3:

0 0 0
0 0 1
0 1 0
0 1 1
1 0 0
1 0 1
1 1 0
1 1 1

Thạch , 12 11 10 byte

ḟẋLṭ+
0;ç/

Hãy thử trực tuyến! hoặc tạo ra tất cả các hoán vị có độ dài 4 .

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

0;ç/   Main link. Argument: B (bit array)

0;     Prepend a 0 to B.
  ç/   Reduce [0] + B by the helper link.


ḟẋLṭ+  Helper link. Left argument: A (array or 0). Right argument: b (bit)

 ẋ     Repeat A b times, yielding A or [].
ḟ      Filter false; remove the elements of A or [] from A.
  L    Get the length of the resulting array.
       This yield len(A) if b = 0 and 0 if b = 1.
    +  Add b to all elements of A.
   ṭ   Tack; append the result to the left to the result to the right.

Python 2, 62 60 byte

x=0,
for n in input():x=[t-n+1for t in x]+[n*len(x)]
print x

Cảm ơn @xnor vì đã chơi golf 2 byte!

Kiểm tra nó trên Ideone .

Python, 54 byte

lambda l:[i-i*x+sum(l[i:])for i,x in enumerate([1]+l)]

Sử dụng quy trình sau:

1. Chuẩn bị 1 vào danh sách.
2. Đối với mỗi mục nhập 0, hãy viết vị trí của nó trong danh sách 0 chỉ mục.
3. Đối với mỗi mục, hãy viết số 1 bên phải, không tính chính nó.
4. Thêm kết quả của bước 2 và 3.

Ví dụ, l=[1,0,1,0]chof(l) == [2,1,3,0,4]

List with prepended 1         1 1 0 1 0

0-indexed position for 0's        2   4
Number of 1's to right        2 1 1 0 0
Sum of above two              2 1 3 0 4

Chuẩn bị 0 cũng sẽ cho kết quả tương tự. Thật enumeratelà rắc rối, tôi sẽ xem liệu nó có thể thực hiện tốt hơn đệ quy không.

JavaScript (ES6), 48 47 45 byte

a=>[h=l=0,...a.map(c=>c?--l:++h)].map(e=>e-l)

Điều này hóa ra tương tự như phương pháp @ETHproductions ', ngoại trừ tôi đã bắt đầu bằng cách tính trực tiếp phần tử đầu tiên và sau đó sử dụng vectơ nhị phân để xác định xem mỗi chữ số là mức cao mới hay mức thấp mới. Chỉnh sửa: Đã lưu 1 byte nhờ @ETHproductions. Đã lưu 2 byte bằng cách bắt đầu bằng 0 và điều chỉnh sau đó. Phương thức trước đây của tôi hóa ra tương tự như phương thức của @ Dennis, nhưng đã lấy 54 byte:

a=>a.reduce((r,b)=>[...r.map(e=>b+e),r.length*!b],[0])

Perl, 33 byte

Bao gồm +1 cho -p

Cho vector dưới dạng chuỗi không có khoảng trắng trên STDIN:

antsy.pl <<< 110

antsy.pl:

#!/usr/bin/perl -p
s%^|.%y/0//+($&?++$a:$b--).$"%eg

JavaScript (ES6), 52 byte

v=>[...v,l=0].map(x=>x?l++:h--,h=v.length).reverse()

Kiểm tra nó ra:

f=v=>[...v,l=0].map(x=>x?l++:h--,h=v.length).reverse()
g=v=>console.log(f((v.match(/[01]/g)||[]).map(x=>+x)))

<input oninput="g(this.value)" value="010">

Giải trình

Điều này lợi dụng thực tế là khi hoán vị antsy bị đảo ngược, mỗi mục sẽ nhiều hơn 1 so với mức tối đa của các mục thấp trước đó, hoặc ít hơn 1 so với mức tối thiểu của các mục cao trước đó. Bằng cách biểu thị một mục cao hơn là một 0và một mục thấp hơn như một 1, chúng ta có thể tạo ra một sự tương ứng một-một chính xác giữa các hoán vị antsy có độ dài n và các vectơ nhị phân có độ dài n - 1 .

Điều tốt nhất tôi có thể làm với kỹ thuật của Dennis là 57 51 byte:

v=>v.reduce((x,n)=>[...x.map(i=>i+n),!n*++j],[j=0])
v=>v.map(n=>x=[...x.map(i=>i+n),!n*++j],x=[j=0])&&x

Giải pháp của xnor là 56 (được lưu 1 byte nhờ @Neil):

l=>[1,...l].map((x,i)=>i*!x+eval(l.slice(i).join`+`||0))

Haskell, 40 byte

foldl(\r a->map(+0^a)r++[a*length r])[0]

Giải pháp Python của Dennis chơi golf tuyệt vời trong Haskell với mapvà fold. Nó ngắn hơn những nỗ lực của tôi để chuyển công trình trực tiếp của tôi :

f l=[i*0^x+sum(drop i l)|(i,x)<-zip[0..]$0:l]
f l=[a+c-b*c|(a,c,b)<-zip3(scanr(+)0l)[0..]$0:l]

Mẻ, 127 byte

@set s=%*
@set/an=h=l=%s: =+%
@for %%b in (%*)do @call:%%b
:0
@echo %n%
@set/an=h+=1
@exit/b
:1
@echo %n%
@set/an=l-=1

Lấy đầu vào làm tham số dòng lệnh, đầu ra được phân tách bằng dòng. (Có thể nhập dưới dạng phân tách không gian trên STDIN mà không mất thêm chi phí.)