在煎饼分类中，唯一允许的操作是反转序列中某些前缀的元素。或者，考虑一下一叠煎饼：我们将锅铲插入堆栈中的某个位置，然后将所有煎饼翻转到锅铲上方。

例如，6 5 4 1 2 3可以通过首先翻转第一个6元素（整个序列），产生中间结果3 2 1 4 5 6，然后翻转第一个3元素，得出来对序列进行排序1 2 3 4 5 6。

由于只有一个操作，因此整个排序过程可以由一系列整数描述，其中每个整数都是要包含pr flip的元素/煎饼的数量。对于上面的示例，排序顺序为6 3。

另一个例子：4 2 3 1可以用排序4 2 3 2。这是中间结果：

         4 2 3 1
flip 4:  1 3 2 4
flip 2:  3 1 2 4
flip 3:  2 1 3 4
flip 2:  1 2 3 4

任务：

编写一个程序，该程序需要一个整数列表并打印有效的煎饼排序顺序。

要排序的列表可以是与stdin空格分隔的列表，也可以是命令行参数。打印列表，但是它很方便，只要它有点可读即可。

这是代码高尔夫！

编辑：

正如我在评论中所说，您不需要优化输出（发现最短的序列是NP-hard）。但是，我刚刚意识到，一种便宜的解决方案是丢弃随机数，直到获得所需的结果为止（一种新的bogosort类型）。到目前为止，没有任何答案可以做到这一点，因此，我现在声明您的算法不应依赖任何（伪随机）随机性。

当您自己动手时，以下是Ruby 2.0中的bogopancakesort变体（60个字符），可以将其揉入：

a=$*.map &:to_i
a=a[0,p(v=rand(a.size)+1)].reverse+a[v..-1]while a!=a.sort

GolfScript，34/21个字符

（感谢@PeterTaylor砍掉4个字符）

~].{,,{1$=}$\}2*${.2$?.p)p.@\-+}/,

在线测试

较短的21个字符的版本仅适用于具有唯一项的列表

~].${.2$?.p)p.@\-+}/,

在线测试

两种版本均产生次优解决方案。

较短解决方案的说明：

~]         # read input from stdin
.$         # produce a sorted copy from lowest to highest
{          # iterate over the sorted list
  .2$?     # grab the index of the element
  .p       # print the index
  )p       # increment and print the index
  .@\-+    # move the element to the front
}/
,          # leave the length of the list on the stack
           # this flips the reverse sorted list to become sorted

这与大多数其他发布的算法使用不同的算法。基本上，它会抓住列表中最小的元素，并通过两次翻转将其移到最前面，以保留其他元素的顺序。

要将第n个元素移到最前面：

1 2 3 4 5 6 7   # let's move the 3rd (0-based) element to the front
# flip the first 3 elements
3 2 1 4 5 6 7
# flip the first 3+1 elements
4 1 2 3 5 6 7

它按顺序对每个元素重复此操作，最后得到反向排序的列表。然后，它翻转整个列表以使其完全排序。

实际上，该算法是90个字符的Python解决方案的一种变体（当然是我自己的）：

d=map(int,raw_input().split());i=0
while d:n=d.index(max(d));d.pop(n);print n+i,n-~i,;i+=1

Python，91个 90个字符

L=map(int,raw_input().split())
while L:i=L.index(max(L));print-~i,len(L),;L=L[:i:-1]+L[:i]

将最大的薄煎饼翻转到顶部，然后翻转整个堆栈。从底部取出最大的煎饼，然后重复。

i是最大的煎饼指数。 L=L[:i:-1]+L[:i]翻转i+1薄煎饼，翻转len(L)薄煎饼，然后放下最后一块煎饼。

红宝石1.9 - 109 88 79个字符

基于Keith出色的python解决方案的紧凑版本：

a=$*.map &:to_i;$*.map{p v=a.index(a.max)+1,a.size;a=a[v..-1].reverse+a[0,v-1]}

原始版本：

a=$*.map &:to_i
a.size.downto(2){|l|[n=a.index(a[0,l].max)+1,l].map{|v|v>1&&n<l&&p(v);a[0,v]=a[0,v].reverse}}

如果您不关心虚假操作（反转大小为1的堆栈，或连续反转两次相同的堆栈），可以将其缩短一些（96个字符）：

a=$*.map &:to_i
a.size.downto(2){|l|[a.index(a[0,l].max)+1,l].map{|v|p v;a[0,v]=a[0,v].reverse}}

将未排序的列表作为命令行参数。用法示例：

>pc.rb 4 2 3 1
4
2
3
2

GolfScript，31个 29个字符

~].${1$?).p.2$.,p>-1%\@<+)}%,

另一个GolfScript解决方案，也可以在线进行测试。

先前版本：

~].$-1%{1$?).2$>-1%@2$<+.,\);}/

工作原理：将最大的项目翻转到列表的顶部，然后再翻转到列表的最后一个位置。由于现在位置正确，我们可以将其从列表中删除。

~]         # Convert STDIN (space separated numbers) to array
.$-1%      # Make a sorted copy (largest to smallest)
{          # Iterate over this copy
  1$?)     # Get index of item (i.e. largest item) in the remaining list,
           # due to ) the index starts with one
  .        # copy (i.e. index stays there for output)
  2$>      # take the rest of the list...
  -1%      # ... and reverse it 
  @2$<     # then take the beginning of the list
  +        # and join both. 
           # Note: these operations do both flips together, i.e.
           # flip the largest item to front and then reverse the complete stack
  .,       # Take the length of the list for output
  \);      # Remove last item from list
}/

Perl，103100个字符

期望在命令行上输入。

for(@n=sort{$ARGV[$a]<=>$ARGV[$b]}0..$#ARGV;@n;say$i+1,$/,@n+1)
{$i=pop@n;$_=@n-$_-($_<=$i&&$i)for@n}

它打印的解决方案肯定不是最佳的。（我的程序输出的结果更好，大约是24个字符。...）

逻辑有点有趣。首先，对每个项目的索引进行分类（按排序顺序）。然后，它从右到左遍历此目录。因此，应用翻转需要将索引调整到截止值以下，而不是实际移动值。经过一些整理之后，我还设法通过每次迭代同时进行两次翻转来节省了一些字符。

Python 2（254）

简单的BFS搜索，内联了一些内容，可能可以在不更改搜索样式的情况下进行更多压缩。希望这可能显示了如何开始打高尔夫球（太多内容以至于一个简单的评论）。

使用：

python script.py 4 2 3 1

（2个空格=制表符）

import sys
t=tuple
i=t(map(int,sys.argv[1:]))
g=t(range(1,len(i)+1))
q=[i]
p={}
l={}
while q:
 c=q.pop(0)
 for m in g:
  n=c[:m][::-1]+c[m:]
  if n==g:
   s=[m]
   while c!=i:s+=[l[c]];c=p[c]
   print s[::-1]
   sys.exit()
  elif n not in p:q+=[n];p[n]=c;l[n]=m

的Python2：120

L=map(int,raw_input().split())
u=len(L)
while u:i=L.index(max(L[:u]))+1;L[:i]=L[i-1::-1];L[:u]=L[u-1::-1];print i,u;u-=1

它效率不高：它将找不到最佳的排序顺序，并且给定的顺序甚至可以包含无操作（即仅翻转第一个元素），但是输出仍然有效。

输出形式为：

n_1 n_2
n_3 n_4
n_5 n_6
...

应该将其视为翻转顺序：n_1 n_2 n_3 n_4 n_5 n_6 ...。如果要获得类似以下的输出：

n_1 n_2 n_3 n_4 n_5 n_6 ...

只需在print语句中添加逗号。

Python-282个字符

import sys
s=sys.argv[1]
l=s.split()
p=[]
for c in l:
 p.append(int(c))
m=sys.maxint
n=0
while(n==(len(p)-1)):
 i=x=g=0
 for c in p:
  if c>g and c<m:
   g=c
   x=i
  i+=1
 m=g
 x+=1
 t=p[:x]
 b=p[x:]
 t=t[::-1]
 p=t+b
 a=len(p)-n;
 t=p[:a]
 b=p[a:]
 t=t[::-1]
 p=t+b
 print p
 n+=1

我第一次打高尔夫球 我不抱任何幻想，我会获胜，但是我有很多的乐趣。给所有以一个字符命名的名称肯定会让您感到恐惧，让我告诉您！这是从命令行运行的，示例实现如下：

Python PancakeSort.py "4 2 3 1"
[1, 3, 2, 4]
[2, 1, 3, 4]
[1, 2, 3, 4]

关于此操作的方式，没有什么特别之处或独创性，但是FAQ建议为感兴趣的读者发布一个非高尔夫版本，因此我在下面进行了介绍：

import sys

pancakesStr = sys.argv[1]
pancakesSplit = pancakesStr.split()
pancakesAr = []
for pancake in pancakesSplit:
    pancakesAr.append(int(pancake))

smallestSorted = sys.maxint
numSorts = 0

while(numSorts < (len(pancakesAr) - 1)):
    i = 0
    biggestIndex = 0
    biggest = 0
    for pancake in pancakesAr:
        if ((pancake > biggest) and (pancake < smallestSorted)):
            biggest = pancake
            biggestIndex = i
        i += 1

    smallestSorted = biggest  #you've found the next biggest to sort; save it off.
    biggestIndex += 1   #we want the biggestIndex to be in the top list, so +1.

    top = pancakesAr[:biggestIndex]
    bottom = pancakesAr[biggestIndex:]

    top = top[::-1] #reverse top to move highest unsorted number to first position (flip 1)
    pancakesAr = top + bottom   #reconstruct stack

    alreadySortedIndex = len(pancakesAr) - numSorts;

    top = pancakesAr[:alreadySortedIndex]
    bottom = pancakesAr[alreadySortedIndex:]

    top = top[::-1] #reverse new top to move highest unsorted number to the bottom position on the unsorted list (flip 2)
    pancakesAr = top + bottom   #reconstruct list

    print pancakesAr    #print after each flip

    numSorts += 1

print "Sort completed in " + str(numSorts) + " flips. Final stack: "
print pancakesAr

我使用的基本算法是问题中链接的Wiki文章中提到的算法：

最简单的煎饼分类算法最多需要2n-3次翻转。在此算法中，这是选择排序的一种变体，我们将尚未排序的最大煎饼移到顶部，然后再翻转一次使其降至最终位置，然后对其余的煎饼重复此操作。

C＃ - 264个259 252 237字符

使用最简单的算法并产生正确的输出，而没有多余的翻转。如果我允许在输出中包含1（非翻转）的字符，可以减少7个字符，但这很丑陋。

我求助于goto最大程度的打高尔夫球。还通过允许它执行非翻转来保存一些字符（但不打印它们）。

最新改进：将输入数组保留为字符串，而不是转换为整数。

using System.Linq;class P{static void Main(string[]a){var n=a.ToList();for(int p
=n.Count;p>0;p--){int i=n.IndexOf(p+"")+1;if(i<p){f:if(i>1)System.Console.Write
(i);n=n.Take(i).Reverse().Concat(n.Skip(i)).ToList();if(i!=p){i=p;goto f;}}}}}

取消高尔夫：

using System.Linq;
class Program
{
    static void Main(string[] args)
    {
        var numbers = args.ToList();

        for (int pancake = numbers.Count; pancake > 0; pancake--)
        {
            int index = numbers.IndexOf(pancake+"") + 1;
            if (index < pancake)
            {
                flip:

                if (index > 1)
                    System.Console.Write(index);

                numbers = numbers.Take(index)
                                 .Reverse()
                                 .Concat(numbers.Skip(index))
                                 .ToList();

                if (index != pancake)
                {
                    index = pancake;
                    goto flip;
                }
            }
        }
    }
}

这是我最初的解决方案，没有高尔夫球（打了264个字符）：

using System.Linq;
using System;

class Program
{
    static void Main(string[] args)
    {
        var numbers = args.Select(int.Parse).ToList();

        Action<int> Flip = howMany =>
        {
            Console.Write(howMany);
            numbers = numbers.Take(howMany)
                             .Reverse()
                             .Concat(numbers.Skip(howMany))
                             .ToList();
        };

        for (int pancake = numbers.Count; pancake > 0; pancake--)
        {
            int index = numbers.IndexOf(pancake) + 1;
            if (index < pancake)
            {
                if (index > 1)
                    Flip(index);
                Flip(pancake);
            }
        }
    }
}

Haskell，72 71字节

h s|(a,x:b)<-span(<maximum s)s=map length[x:a,s]++h(reverse b++a)
h e=e

在线尝试！查找最大值，将其向后翻转，然后递归排序其余列表。

编辑：-1字节感谢BMO

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"

对列表进行排序，方法是反复查找任何反转，将其翻转到最前面，然后反转，然后将所有内容翻转回原来的位置。这是等同于交换反转，所以我不需要反向（这是对串尴尬，因为这将扭转值的数字转换如12到21）

C＃-229

using System;using System.Linq;class P{static void Main(string[] a){
var n=a.ToList();Action<int>d=z=>{Console.Write(z+" ");n.Reverse(0,z);};
int c=n.Count;foreach(var s in n.OrderBy(x=>0-int.Parse(x))){
d(n.IndexOf(s)+1);d(c--);}}}

可读版本

using System;
using System.Linq;
class P {
    static void Main(string[] a) {
        var n = a.ToList();
        Action<int> d = z => { Console.Write(z + " "); n.Reverse(0, z); };
        int c = n.Count;
        foreach (var s in n.OrderBy(x => 0 - int.Parse(x))) {
            d(n.IndexOf(s) + 1); d(c--);
        }
    }
}