でパンケーキソートのみ許可される操作をシーケンスの一部の接頭辞の要素を逆にすることです。または、パンケーキのスタックを考えます。スタックのどこかにヘラを挿入し、スパチュラの上にすべてのパンケーキをひっくり返します。

たとえば6 5 4 1 2 3、最初の6要素（シーケンス全体）を最初に反転し、中間結果を生成して3 2 1 4 5 6から最初の3要素を反転してに到達することにより、シーケンスをソートできます1 2 3 4 5 6。

操作が1つしかないため、ソートプロセス全体を整数のシーケンスで記述できます。各整数は、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からスペースで区切られたリスト、またはコマンドライン引数のいずれかです。リストを印刷しますが、多少読みやすい限りは便利です。

これはcodegolfです！

編集：

コメントで述べたように、出力を最適化する必要はありません（最短シーケンスを見つけるのは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

これは、投稿された他のほとんどのアルゴリズムとは異なるアルゴリズムを使用します。基本的に、リストの最小要素を取得し、2回フリップすることでリストを最前面に移動し、他の要素の順序を保持します。

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)、最後のパンケーキをドロップした後、パンケーキを。

Ruby 1.9の- 109の 88の 79文字

キースの優れた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のスタックを反転する、または同じスタックを2回連続で反転する）を気にしない場合は、少し短くすることができます（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、103 100文字

コマンドラインでの入力を期待します。

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

効率的ではありません。最適なソートシーケンスを見つけることができず、指定されたシーケンスにno-op（つまり、最初の要素のみを反転する）を含めることもできますが、出力は有効です。

出力は次の形式で提供されます。

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

初めてのコードゴルフ。私は勝つだろうと幻想を抱いているわけではありませんが、とても楽しかったです。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回のフリップが必要です。選択アルゴリズムのバリエーションであるこのアルゴリズムでは、まだソートされていない最大のパンケーキを1回のフリップで最上部に移動し、もう1つで最終位置に降ろしてから、残りのパンケーキについてこれを繰り返します。

C＃-264 259 252 237文字

最も単純なアルゴリズムを使用し、冗長なフリップなしで正しい出力を生成します。出力に1（フリップ以外）を含めることを許可した場合、7文字を削ることができますが、それは見苦しいです。

私はgoto最大のゴルフに使うことに頼りました。また、非フリップを実行できるようにすることでいくつかの文字を保存しました（ただし、印刷はしません）。

最新の改善：入力配列をintに変換する代わりに文字列として保持します。

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;
                }
            }
        }
    }
}

ここに私の最初の解決策、ungolfed（264 chars golfed）があります：

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

オンラインでお試しください！最大値を見つけて後ろに反転し、残りのリストを再帰的にソートします。

編集：BMOのおかげで-1バイト

Perl 5.10（以降）、66バイト

含ま+3のために5.10を無料考えられているPerlのレベルに言語をもたらすために-nuse 5.10.0

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

入力をSTDINの1行として実行します。

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--);
        }
    }
}