背景

我有一排强力磁铁和一堆金属物体。磁铁会将磁铁拉到哪里？

输入值

您的输入是一个非负整数数组，其中将至少包含一个1。您可以使用任何合理的格式。

0数组的s表示空白，而1s表示固定的磁体。所有其他数字都是金属物体，它们被磁铁拉动。每个对象都被拉向最近的磁铁（如果有领带，则该对象被拉到右侧），然后沿该方向行进，直到碰到磁铁或另一个对象。最后，所有物体都聚集在磁铁周围。对象的顺序被保留。

输出量

您的输出是一个数组，其中每个对象都被拉到尽可能靠近最近的磁铁的位置。它应该具有与输入相同的格式。

例

考虑数组

[0,0,2,0,1,1,0,2,0,3,0,5,0,1,0]

最左边2的磁铁被拉向第一对磁铁，第二个磁铁也被拉向2。在3有磁铁在两个方向上四步走，所以它被拉到正确的。该5也被拉到右边，它会之间3和磁铁。正确的输出是

[0,0,0,2,1,1,2,0,0,0,0,3,5,1,0]

规则和计分

您可以编写完整的程序或函数。最低字节数获胜，并且不允许出现标准漏洞。

测试用例

[0,1,0] -> [0,1,0]
[1,0,2,0,0,1,0] -> [1,2,0,0,0,1,0]
[7,0,5,0,0,1,0] -> [0,0,0,7,5,1,0]
[1,0,3,0,1,0,3,0,1] -> [1,0,0,3,1,0,0,3,1]
[1,0,0,0,0,0,0,7,3] -> [1,7,3,0,0,0,0,0,0]
[1,2,3,4,5,6,7,8,9,10,11,0,0,0,1] -> [1,2,3,4,5,6,7,0,0,0,8,9,10,11,1]
[12,3,0,0,1,0,1,3,0,0,6,12,0,0,0,1] -> [0,0,12,3,1,0,1,3,6,0,0,0,0,0,12,1]

Pyth， 28 20

o@.e?bhaDk_x1QkQ~hZQ

感谢@ThomasKwa打高尔夫球6个字节！

通过为列表中的所有值1或更大的值分配最近的1的索引（断开到最右边的1的索引），然后按这些值对列表进行排序，会滥用稳定排序。零被赋予自己的索引作为排序值。

测试套件

验证套件

说明：

o@.e?bhaDk_x1QkQ~hZQ  ##  implicit: Q = eval(input())
o                  Q  ##  Sort Q using the values of the lambda below
 @              ~hZ   ##  select the value from the matching index of the enumerate
  .e           Q      ##  enumerate with b = value, k = index
    ?b                ##  ternary on b
      haDk_x1Q        ##  if true, this thing
              k       ##  otherwise use the index as the sort weight
          _x1Q        ##  the indices of 1 in Q, given in reverse order 
                      ##  (the reverse makes it sort to the right because of stable sorts)
       aDk            ##  sort those indices by |index - k|
      h               ##  take the first value

例：

以测试用例[1,0,3,0,1,0,3,0,1]为例。当我们应用枚举时，零将全部获得它们自己的索引作为排序值，因此我将跳过它们，并执行一和三。

对于第一个，我们得到1的索引：[0, 4, 8]。然后将其取反，并按索引的绝对值减去索引的绝对值排序，索引的绝对值在此处恰好为零。所以我们[0, 4, 8]又回来了。第一个值是0所以我们使用它。

对于这三个，我们得到了反向索引并进行了相同的排序，但是使用两个作为三个索引，因此0和和4的绝对差值都相同，因此得到：[4, 0, 8]然后取4。

然后，最终的“排序值”数组将为[0, 1, 4, 3, 4, 5, 8, 7, 8]。多亏了稳定的排序，关系被值最初出现的顺序打破了，因此我们得到了所需的最终数组。

视网膜，97 72字节

+`(?<=\b1(,1*)*?)(\B,(11+)|,(11+))\b(?!(?<-1>,1*)*,1\b)|(11+),\B
$3,$4$5

输入应该是逗号分隔的一元整数列表（前导和尾随定界符，例如[...] work都很好）。

在这里运行所有测试用例。（为方便起见，这会自动处理从十进制到十进制的转换。）

这是一个完全不同的想法，通过使用多阶段避免了昂贵的平衡组。目前，它的长度增加了6个字节，但可能更适合高尔夫运动：

,1\b
>1
\b1,
1<
(T`,`<`<1*,
)T`,`>`,1*>
+`(1+>)>
>$1
+`<(<1+\b)(?!>)
$1<
<|>
,

JavaScript（ES6），108个字节

a=>a.map(_=>a.map((x,i)=>x>1?a[j=(n=a.indexOf(1,i))<0|n-i>i-p?i-1:i+1]?0:a[a[i]=0,j]=x:x<1?0:p=i,p=-1/0))&&a

说明

遍历每个单元格，如果其中包含金属，则检查最近的磁体方向上的下一个单元格是否为空，如果是，则将其移动到那里。重复此过程很多次，直到所有金属都已移动到最大程度。

var solution =

a=>
  a.map(_=>                  // loop a.length times to ensure completeness
    a.map((x,i)=>            // for each cell item x at index i
      x>1?                   // if the cell contains metal
        a[j=                 // j = index of cell to move to
          (n=a.indexOf(1,i)) // n = index of next magnet
          <0|n-i>i-p?i-1:i+1 // set j to previous or next cell based on closest magnet
        ]?0:                 // if cell j is empty
          a[a[i]=0,j]=x      // set it to x and set cell i to 0
      :x<1?0:                // else if the cell contains a magnet
        p=i,                 // set p to the index of this magnet
      p=-1/0                 // p = index of previous magnet, initialise to -Infinity
    )
  )
  &&a                        // return a

<input type="text" id="input" value="1,2,3,4,5,6,7,8,9,10,11,0,0,0,1" />
<button onclick="result.textContent=solution(input.value.split(',').map(n=>+n))">Go</button>
<pre id="result"></pre>

PHP，337个字符

<?$i=explode(",",$argv[1]);$m=$n=[];foreach($i as$k=>$v)if($v>0)eval("array_push(\$".($v<2?"m":"n").",$k);");for($p=0;$p<count($i);$p++)foreach($i as$k=>$v)if($v>1){$i[$k]=0;$r=-1;foreach($m as$_)if($r<0||abs($k-$r)>abs($_-$k))$r=$_;while($i[$r]>0)$r+=($r<$k?1:-1);$i[$r]=$v;}$s="";foreach($i as$v)$s.=$v.",";echo substr($s,0,-1)."\n";?>

是的，这很长，因为PHP并不是真正的高尔夫语言，但是它可以工作，并且我让它很有趣，所以对我来说很好。当然，我可能会做空。

此外，还有一个小错误功能可以考虑，因此例如此处：

root@raspberrypi:~/stack# php magnet.php 12,3,0,0,1,0,1,3,0,0,6,12,0,0,0,1
0,0,3,12,1,0,1,3,6,0,0,0,0,0,12,1

看起来12神奇地领先于3，但这不是事实！

3尊重更大的数字，并使其更接近maget！