挑战

给定整数n≥4，输出整数[0，n-1]的排列，其属性是没有两个连续的整数彼此相邻。排列的值pi是abs(pi[i] - i)所有索引的总和i。

例子

• (1, 3, 0, 2) 有价值 6
• (0, 2, 4, 1, 3) 有价值 6
• (0, 2, 4, 1, 3, 5) 有价值 6
• (0, 2, 4, 1, 5, 3, 6) 有价值 8

答案分数

答案的分数是排列值的总和n = 4 .. 14加上代码占用的字节数。分数越低越好。您的代码必须为的所有这些值提供有效的输出n。

您必须能够在计算机上运行提交以完成操作。

如果是平局，则导致相关分数的最后编辑时间将作为决定者。

这不是因为同样的问题这一个？

链接的问题的答案对于该问题没有竞争力，因为它们不努力优化排列的值。例如n=10，[1, 3, 5, 7, 9, 0, 2, 4, 6, 8]大多数答案给出的排列给出的值为30。您可以做得更好。

对于问题的置换部分，总的最佳值最多为120。（感谢@Laikoni。）而Dennis对先前问题的回答得分为222。（感谢@ user202729。）

果冻，36 34 33 32 31 30字节，结果：120

感谢丹尼斯-1个字节！（虽然该功能将挑战推迟了，但暗含了修复果冻错误的隐患）

ðRḟISị“Ƥ¿‘Ʋœ?$;@µ2x5~4¦ṁ_4$Ä’

新功能：累计总和（Ä）。

在线尝试！

使用1索引。

也需要线性时间。

假设| i-p _i | |，此C ++程序生成按字典顺序排列的最小排列。≤宽度（其中宽度是硬编码的常数）对于所有0≤我<N ，随着时间复杂度大约为O（宽度² ×2 ^2×宽度 ×n）个（这仅仅是O（n）的固定宽度）：在线尝试！

怎么样？

1. 编写一个C ++程序，尝试以最佳方式解决问题。

2. 观察图案。我们注意到，除最后4个元素外，所有元素的序列均为的前缀

   0 2 4 1 3 5 7 9 6 8 10 12 14 11 13 15 17 19 16 18 20 22 24 21 23 25 ...
   

3. 计算序列的增量差。

   2 2 -3 2 2 2 2 -3 2 2 2 2 -3 2 2 2 2 -3 2 2 2 2 -3 2 2
   

   注意期间5。

4. Jelly的实现：

   • 从上面的序列中选取n-4个第一元素。上）。

   • 对于最后4个元素，只需蛮力所有24种可能性。O（1） 。

     （注意：我不再从32字节版本开始强行使用所有24种可能性）

CJam（60位元组+ 120 = 180分数）

{_5/4*8e!961=7_)er<:A\,^e!{A\+}%{2ew::-:z1&!},{_$.-:z1b}$0=}

具有集成评分功能的在线测试套件

扩展到n = 24

解剖

{
  _5/4*        e# Work out how much of the hard-coded prefix to use
  8e!961=7_)er e# Prefix [0 2 4 1 3 5 8 6]
               e# I identified this by brute forcing up to n=10 and looking for patterns
               e# I then used the identified prefix [0 2 4 1] to brute-force further
  <:A          e# Take the desired prefix of the hard-coded array, and store a copy in A
  \,^e!        e# Generate all permutations of the values in [0 .. n-1] which aren't in A
  {A\+}%       e# Prepend A to each of them
  {            e# Filter...
    2ew::-     e#   Take each difference of two consecutive elements
    :z         e#   Find their absolute values
    1&         e#   Test whether 1 is among those absolute values
    !          e#   Reject if it is
  },
  {            e# Sort by...
    _$.-       e#   Take pairwise differences of permutation with the identity
    :z         e#   Absolute values
    1b         e#   Add them (by interpreting in base 1)
  }$
  0=           e# Take the first
}

Haskell，146 + 89得分+字节

f i|k<-mod i 4=scanl(+)1$take(i-2-k)(cycle[2,-3,2,3])++[[2],[2,2],[5,-3,2],[5,-3,2,2]]!!k

重复模式[1,3,0,2]，最后一次 mod i 4手动调整元素。

先前的算法（132 + 116）：

f i=last$filter(\a->all(`elem`a)[0..i-1]).(!!(i-1)).iterate((\l->map((:l).(+head l))[-3,2,-2,3])=<<)$pure<$>[i-3..i]

暴力破解正确的长度为±2或±3的跳数。选择其中包含正确数字的最后一个，似乎效果很好，并且比实现分数便宜得多。Tio的时间比最后一个分数（18分）还快用完了。

在线尝试！

Japt，120 + 20 = 140

（从另一个挑战中复制我的解决方案中的一个，我的得分为227）

o á k_äa d¥1ÃñxÈaYÃg

试试看或使用此版本检查分数。两种版本都可能在9左右开始对您不利。

说明

o                        :Range [0,input)
  á                      :All permutations
    k_      Ã            :Remove sub-arrays that return true
      äa                 :  Get the consecutive absolute differnces
         d¥1             :  Do any equal 1?
               È  Ã      :Pass the integers in each remaining sub-array through a function
                aY       :  Get the absolute difference with the integer's index
              x          :Reduce by addition
             ñ           :Sort the main array by those values
                   ñ     :Return the first sub-array

Ruby，120分+ 11210691 82字节

->n{(0...n).map{|a|a+(a+2)%5-([[],[],[0,4,3],[-1,4,4,4],[1,1,6,1]][n%5][a-n]||2)}}

在线尝试！

顺序基本上是 (a-2)+(a+2)%5。

如果n mod 5不是0或1，则最后3或4个元素不同。

这仍然是半硬编码的，总是找到最佳的解决方案，也许可以再打一些，但我的想法已经用完了。

JavaScript（Node.js），148分+ 109 73字节

n=>[...Array(n)].map(_=>l=!m|l>n%5+2&&l>m+2?[+m,m=l+2][0]:l+2,m=n>4,l=~m)

在线尝试！说明：l跟踪生成的最后一个数字，并m跟踪与l; 相反的奇偶校验的下一个数字。一旦l超过m+2，就交换变量。在序列的开头进行调整，以使长度不是5的倍数的序列不会遗漏任何数字，并且对进行另一调整n=4。