作为计算机科学家，您可能都熟悉pop和push的基本列表操作。这些是修改元素列表的简单操作。但是，您听说过操作失败吗？（如倒装触发器）？很简单 给定数字n，反转列表的前n个元素。这是一个例子：

>>> a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a.flop(4)
[4, 3, 2, 1, 5, 6, 7, 8, 9, 10]

翻牌操作很酷的事情是，您可以使用它对列表执行一些很酷的事情，例如对它进行排序。我们将对拖鞋做类似的事情：

给定一个整数列表，“邻居”。换句话说，对它进行排序，以便每个重复的元素连续出现。

这可以用拖鞋完成！例如，采用以下列表：

>>> a = [3, 2, 1, 4, 3, 3, 2]
>>> a.flop(4)
[4, 1, 2, 3, 3, 3, 2]
>>> a.flop(3)
[2, 1, 4, 3, 3, 3, 2]
>>> a.flop(6)
[3, 3, 3, 4, 1, 2, 2]

这使我们得出了当今挑战的定义：

给定一个整数列表，输出将导致该列表相邻的任何一组触发器。

以最后一个列表为例，您应该输出：

4
3
6

因为将列表按4，然后按3，然后按6进行翻页将产生一个相邻列表。请记住，你并不需要打印的最短的名单触发器是邻居列表。如果您已打印：

4
4
4
3
1
1
6
2
2

相反，这仍然是有效的输出。但是，你可能没有比列表的长度过大输出的数字。这是因为对于list a = [1, 2, 3]，调用a.flop(4)是没有意义的。

这里有些例子：

#Input:
[2, 6, 0, 3, 1, 5, 5, 0, 5, 1]

#Output
[3, 7, 8, 6, 9]


#Input
[1, 2]

#Output
<any list of integers under 3, including an empty list>


#Input
[2, 6, 0, 2, 1, 4, 5, 1, 3, 2, 1, 5, 6, 4, 4, 1, 4, 6, 6, 0]

#Output
[3, 19, 17, 7, 2, 4, 11, 15, 2, 7, 13, 4, 14, 2]


#Input
[1, 1, 1, 1, 2, 2, 2, -1, 4]

#Output
[]


#Input
[4, 4, 8, 8, 15, 16, 16, 23, 23, 42, 42, 15]

#Output
[12, 7]

请记住，在每个示例中，给定的输出只是一个潜在的有效输出。就像我之前说过的，与给定列表相邻的任何一组触发器都是有效的输出。您可以使用此python脚本来验证给定的触发器列表是否正确地与列表相邻。

您可以采用任何合理的格式进行输入和输出。例如，函数参数/返回值，STDIN / STDOUT，读/写文件等都有效。像往常一样，这是代码高尔夫，所以请尽可能做最短的程序，并玩得开心！:)

Haskell，98 71字节

h.r
h(x:s)|(a,b)<-span(/=x)s=l b:l s:h(b++r a)
h e=e
r=reverse
l=length

在线尝试！

说明

对于长度列表，n此方法会产生2*n触发器。它通过查看列表的最后一个元素，在列表中查找之前的相同元素并将其翻转到倒数第二个位置来工作。然后，将最后一个元素被删除的列表递归地“相邻”。

对于列表[1,2,3,1,2]，算法的工作原理如下：

[1,2,3,1,2]  flip longest prefix that ends in 2: flop 2
[2,1,3,1,2]  bring first element to second to last position: flop n-1 = flop 4
[1,3,1,2,2]  recursively work on n-1 list
[1,3,1,2]    there is no other 2: flop 0
[1,3,1,2]    flop n-1 = flop 3
[1,3,1,2]    recurse
[1,3,1]      flop 1
[1,3,1]      flop 2
[3,1,1]      recurse
[3,1]        flop 0
[3,1]        flop 1
 ...

所有这些共同产生了翻牌圈[2,4,0,3,1,2,0,1,0,0]和附近的名单[3,1,1,2,2]。

Wolfram语言（Mathematica），71个字节

If[(n=Tr[1^#])<1,{},{i=Last@Ordering@#,n,n-1,i-1}~Join~#0[#~Drop~{i}]]&

在线尝试！

怎么运行的

给定一个length数组n，输出4n一系列按递增顺序对触发器进行排序的触发器：尤其是将重复的元素彼此并排放置。

这个想法是要对数组排序，我们将其最大的元素移到末尾，然后对n-1数组的第一个元素进行排序。为了避免执行翻牌操作，我们以不干扰其他元素的方式将最大元素移到末尾：

{3, 2, 1, 5, 3, 3, 2}    starting array, with largest element in position 4
{5, 1, 2, 3, 3, 3, 2}    flop 4 to put the largest element at the beginning
{2, 3, 3, 3, 2, 1, 5}    flop 7 to put the largest element at the end
{1, 2, 3, 3, 3, 2, 5}    flop 6 (7-1) to reverse the effect of flop 7 on other elements
{3, 2, 1, 3, 3, 2, 5}    flop 3 (4-1) to reverse the effect of flop 4 on other elements

通常，如果最大的元素处于位置i，则将其移至末尾的触发器序列为i, n, n-1, i-1。

Python 2，69个字节

l=input()
while l:k=l.index(max(l));print-~k,len(l),;l=l[:k:-1]+l[:k]

在线尝试！

果冻，19 17字节

ỤỤạ‘Ḣ
ỤÇÐƤĖµUż’ṚF

对列表进行排序。

在线尝试！

干净，88字节

我认为可能会有个矮一些的后卫，但我还没有找到。

import StdEnv
$[h:t]#(a,b)=span((<>)h)t
=map length[b,t]++ $(b++r a)
$e=e
r=reverse

$o r

在线尝试！

作为函数文字。运作方式与莱科尼（Laikoni）的Haskell答案相同，但打高尔夫球的方式略有不同，当然也使用不同的语言。

JavaScript，150字节

(a,f=n=>(a=[...a.slice(0, n).reverse(),...a.slice(n)],n),l=a.length,i=0)=>a.reduce(c=>[...c,f(a.indexOf(Math.max(...a.slice(0, l-i)))+1),f(l-i++)],[])

在线尝试！

JavaScript，151个字节

a=>{f=n=>(a=[...a.slice(0,n).reverse(),...a.slice(n)],n),r=[];for(i=a.length+1;--i>0;)r.push(f(a.indexOf(Math.max(...a.slice(0, i)))+1),f(i));return r}

在线尝试！

两者基本上都是通过将最大数翻转到开头然后将其翻转到后面来对数组进行排序的，对其余数组重复此操作。第一个使用reduce，第二个使用for循环。

取消高尔夫：

array => {
  let flop = n => {
    array = [...array.slice(0, n).reverse(), ...array.slice(n)]; 
    return n;
  }
  let flops = [];
  for (let i = array.length + 1; --i > 0;) 
  {
    let maxIndex = array.indexOf(Math.max(...array.slice(0, i)));
    flops.push(flop(maxIndex + 1), flop(i));
  }
  return flops;
}

Perl 5.10（或更高版本），66字节

包括+3用于-n 将use 5.10.0带来的语言水平的Perl 5.10被认为是免费的

#!/usr/bin/perl -n
use 5.10.0;
$'>=$&or$.=s/(\S+) \G(\S+)/$2 $1/*say"$. 2 $."while$.++,/\S+ /g

在STDIN上将输入作为一行运行：

flop.pl <<< "1 8 3 -5 6"

通过反复查找任何反转来对列表进行排序，将其翻转到最前面，然后翻转反转，然后将所有内容翻转回原来的位置。

出乎意料的是，很难在这本书上找到与python相同的标准：-)

C（gcc），165160字节

• 谢谢 ceilingcat节省了五个字节。

m,j,t;f(A,l)int*A;{for(j=0;j+j<l;A[j]=A[l+~j],A[l+~j++]=t)t=A[j];}F(A,l)int*A;{for(;l;f(A,++m),printf("%d,%d,",m,l),f(A,l--))for(j=m=0;j<l;j++)m=A[j]>A[m]?j:m;}

• 在线尝试！
• 验证