介绍

我在较早的挑战中定义了蚂蚁排列的类别。作为提醒，置换p的数字从0到R-1是坐立不安，如果对于每一个条目P [I]除了第一，有一些较早条目P [IK] ，使得P [I] == P [ ik]±1。作为一个有趣的事实，我还说过，对于r≥1，正好有2个^r-1长度为r的蚁群。这意味着长度为r的蚂蚁排列与长度为r-1的二元向量之间存在一一对应的关系。在这个挑战中，您的任务是实现这种对应关系。

任务

你的任务是写一个程序或函数，它在长度的二元载体1≤N≤99，并输出长度的坐立不安排列的n + 1。排列可以是基于0的基于1的（但是必须一致），并且输入和输出可以采用任何合理的格式。此外，不同的输入必须始终提供不同的输出。除此之外，您可以自由返回任何想要的蚂蚁排列。

最低字节数获胜。

例

长度为4的（从0开始）蚁群排列是

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

并且您的程序应针对长度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

果冻，12 11 10 字节

ḟẋLṭ+
0;ç/

在线尝试！或生成长度为4的所有排列。

怎么运行的

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字节

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

感谢@xnor打高尔夫球2个字节！

在Ideone上进行测试。

Python，54个字节

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

使用以下过程：

1. 在列表前添加1。
2. 对于每个0条目，将其位置写在0索引列表中。
3. 对于每个条目，请在其右边写下1的数量，而不是自己计算。
4. 逐项添加步骤2和3的结果。

例如，l=[1,0,1,0]给f(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

前置0也会得到相同的结果。这个enumerate比较笨拙，我将看看它是否可以递归地做得更好。

JavaScript（ES6），48 47 45字节

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

事实证明这类似于@ETHproductions的方法，除了我首先直接计算第一个元素，然后使用二进制矢量确定每个数字是新高还是新低。编辑：由于@ETHproductions，节省了1个字节。从零开始并随后进行调整，从而节省了2个字节。我以前的方法与@Dennis的方法相似，但是占用了54个字节：

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

Perl，33个字节

包括+1的 -p

在STDIN上将向量作为字符串而不带空格：

antsy.pl <<< 110

antsy.pl：

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

JavaScript（ES6），52个字节

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

测试一下：

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

说明

这利用了以下事实：逆向排列排列时，每个项目要么比以前的低位条目的最大值大1，或者比前面的高位条目的最小值小1。通过将较高的项表示为a 0，将较低的项表示为a 1，我们可以在长度为n的蚂蚁排列与长度为n-1的二元向量之间创建精确的一对一对应关系。

我可以用Dennis的技术做的最好的是57 51字节：

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

xnor的解决方案是56（感谢@Neil节省了1个字节）：

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

Haskell，40个字节

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

Dennis的Python解决方案通过map和完美地在Haskell中打高尔夫球fold。它比我移植直接的直接入门结构的尝试要短：

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]

批次，127个字节

@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

将输入作为命令行参数，将输出以行分隔。（可以在STDIN上以空格分隔输入，而无需额外费用。）