介绍

当然，我们遇到了很多序列挑战，因此这是另一个挑战。

金伯林序列（A007063）如下：

1, 3, 5, 4, 10, 7, 15, 8, 20, 9, 18, 24, 31, 14, 28, 22, ...

这是通过改组常规迭代产生的：

[1] 2  3  4  5  6  7  8

序列的第一项是1。之后，我们将重新排列序列，直到使用了左侧的所有术语。改组有规律right - left - right - left - ...。由于的左侧没有术语1，因此没有改组。我们得到以下内容：

 2 [3] 4  5  6  7  8  9

在第i ^次迭代中，我们丢弃第i ^个项目并将其放在我们的序列中。这是第二次迭代，因此我们丢弃第二项。序列变为：1, 3。对于我们的下一个迭代，我们将使用上面的模式对当前迭代进行洗牌。我们从第i ^个项目的右边取出第一个未使用的项目。这恰好是4。我们将其添加到新的迭代中：

 4

现在，我们将在第i ^个项目的左侧获取第一个未使用的项目。这是2。我们将其添加到新的迭代中：

 4  2

由于第i ^个项目的左侧没有任何项目，因此我们将其余序列附加到新的迭代中：

 4  2 [5] 6  7  8  9  10  11  ...

这是我们的第三次迭代，因此我们将丢弃第三项5。这是我们序列中的第三项：

 1, 3, 5

要获得下一个迭代，只需重复该过程即可。如果不清楚，我已经制作了一个gif：

^{gif花了我比写实际帖子花了更长的时间}

任务

• 给定一个非负整数n，输出序列的前n个项
• 您可以提供功能或程序
• 这是代码高尔夫球，因此以最少的字节提交为准！

测试用例：

Input: 4
Output: 1, 3, 5, 4

Input: 8
Output: 1, 3, 5, 4, 10, 7, 15, 8

Input: 15
Output: 1, 3, 5, 4, 10, 7, 15, 8, 20, 9, 18, 24, 31, 14, 28

注意：输出中不需要逗号。例如，您可以使用换行符，或输出列表等。

Pyth，22个字节

JS*3QVQ@JN=J.i>JhN_<JN

在线尝试：演示

只需执行OP中描述的改组技术即可。

说明：

JS*3QVQ@JN=J.i>JhN_<JN
JS*3Q                    assign the list [1, 2, ..., 3*input-1] to J
     VQ                  for N in range(Q):
       @JN                  print J[N]
            .i              interleave 
              >JhN             J[N+1:] with
                  _<JN         reverse J[:N]
          =J                assign the resulting list to J

朱莉娅78 71字节

n->[(i=j=x;while j<2i-3 j=i-(j%2>0?1-j:j+2)÷2;i-=1end;i+j-1)for x=1:n]

这是一个未命名的函数，它接受整数并返回整数数组。要调用它，请将其分配给变量。

这里的方法与OEIS中描述的方法相同。

取消高尔夫：

# This computes the element of the sequence
function K(x)
    i = j = x
    while j < 2i - 3
        j = i - (j % 2 > 0 ? 1 - j : j + 2)÷2
        i -= 1
    end
    return i + j - 1
end

# This gives the first n terms of the sequence
n -> [K(i) for i = 1:n]

感谢Mauris，节省了7个字节！

Mathematica 130字节

(n=0;s={};Nest[(n++;AppendTo[s,z=#[[n]]];Flatten[TakeDrop[#,1+2(n-1)]/.{t___,z,r___}:> 
Riffle[{r},Reverse@{t}]])&,Range[3*#],#];s)&

我们从一个范围从1到的列表开始3x，其中x是所需的Kimberling序列项数。

在每一步，n，TakeDrop打破了当前列表转换的前表2n+1术语（其中的工作已经完成）和后部列表（其将与所述被后来加入返工前面列表）。前列表与以下模式匹配，{t___,z,r___}其中z是前列表中心的金伯林项。 r是Riffled的反面，t然后追加了后面的列表。z被删除并附加到（AppendTo）不断增长的金伯林序列上。

n通过递增，1当前列表由相同的函数通过处理Nest.

例

(n=0;s={};Nest[(n++;AppendTo[s,z=#[[n]]];Flatten[TakeDrop[#,1+2(n-1)]/.{t___,z,r___}:> 
Riffle[{r},Reverse@{t}]])&,Range[3*#],#];s)&[100]

{1、3、5、4、10、7、15、8、20、9、18、24、31、14、28、22、42、35、33、46、53、6、36、23、2 ，55，62，59，76，65，54，11，34，48，70，79，99，95，44，97，58，84，25，13，122，83，26，115，82，91 ，52，138，67，90，71，119，64，37，81，39，169，88，108，141，38，16，146，41，21，175，158，165，86，191，45 ，198、216、166、124、128、204、160、12、232、126、208、114、161、156、151、249、236、263、243、101、121、72、120、47、229 }

Python 2，76个字节

for a in range(input()):
 b=a+1
 while-~b<2*a:b=a-(b^b%-2)/2;a-=1
 print a+b

说明

经过多次golf-y转换后，这就是OEIS公式！效果很好。原始代码是

i=b=a+1
while b<2*i-3:b=i-(b+2,1-b)[b%2]/2;i-=1
print i+b-1

我首先摆脱了i它，将其替换为a+1任何地方并扩展了表达式：

b=a+1
while b<2*a-1:b=a+1-(b+2,1-b)[b%2]/2;a-=1
print a+b

然后，改写b<2*a-1为-~b<2*a以保存一个字节的空白，并将移至+1选择区，除以2，然后取反：

while-~b<2*a:b=a-(b,-b-1)[b%2]/2;a-=1

然后，-b-1是~b，所以我们可以写(b,~b)[b%2]。这等效于b^0 if b%2 else b^-1使用XOR运算符，或者使用b^b%-2。

while-~b<2*a:b=a-(b^b%-2)/2;a-=1

Pyth，29 25字节

VQ+.W<hHyN-~tN/x%Z_2Z2hNN

Jakube保存了4个字节，但是我不知道如何再读取代码。

这是旧的解决方案：

VQKhNW<hKyN=K-~tN/x%K_2K2)+KN

我的Python答案的翻译。我不太擅长Pyth，因此也许仍有缩短方法。

VQ                              for N in range(input()):
  KhN                             K = N+1
     W<hKyN                       while 1+K < 2*N:
           =K-~tN/x%K_2K2)         K = (N--) - (K%-2 xor K) / 2
                          +KN     print K + N

APL，56 44字节

{⍵<⍺+⍺-3:(⍺-1)∇⍺-4÷⍨3+(1+2×⍵)ׯ1*⍵⋄⍺+⍵-1}⍨¨⍳

这是未命名的单子列火车，它在右侧接受一个整数并返回一个数组。这与我的Julia回答大致相同。

最里面的函数是一个递归二元函数，该函数返回金伯林序列中的第n个项，给定n作为相同的左右参数。

{⍵<⍺+⍺-3:                                    ⍝ If ⍵ < 2⍺ - 3
         (⍺-1)∇⍺-4÷⍨3+(1+2×⍵)ׯ1*⍵           ⍝ Recurse, incrementing a and setting
                                             ⍝ ⍵ = ⍺ - (3 + (-1)^⍵ * (1 + 2⍵))/4
                                   ⋄⍺+⍵-1}   ⍝ Otherwise return ⍺ + ⍵ - 1

有了这些，我们就能获得序列的各个术语。但是，问题在于这是一个二进位函数，这意味着它需要两侧都带有参数。输入⍨操作员！给定一个函数f和一个输入x，f⍨x与相同x f x。因此，在本例中，将上述函数称为f，我们可以构造以下单轨列车：

f⍨¨⍳

我们申请 f对从1到输入的每个整数一个数组。

感谢Dennis，节省了12个字节！