Trong sắp xếp pancake , thao tác được phép duy nhất là đảo ngược các phần tử của một số tiền tố của chuỗi. Hoặc, nghĩ về một chồng bánh kếp: Chúng tôi chèn một cái thìa ở đâu đó trong chồng và lật tất cả các bánh trên thìa.

Ví dụ, chuỗi 6 5 4 1 2 3có thể được sắp xếp bằng cách lật các 6phần tử đầu tiên (toàn bộ chuỗi), thu được kết quả trung gian 3 2 1 4 5 6, sau đó lật các 3phần tử đầu tiên , đến 1 2 3 4 5 6.

Vì chỉ có một thao tác, toàn bộ quá trình sắp xếp có thể được mô tả bằng một chuỗi các số nguyên, trong đó mỗi số nguyên là số phần tử / bánh để bao gồm pr flip. Đối với ví dụ trên, trình tự sắp xếp sẽ là 6 3.

Một ví dụ khác: 4 2 3 1có thể được sắp xếp với 4 2 3 2. Đây là kết quả trung gian:

         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

Nhiệm vụ:

Viết chương trình lấy danh sách các số nguyên và in trình tự sắp xếp bánh kếp hợp lệ.

Danh sách cần sắp xếp có thể là danh sách được phân tách bằng dấu cách từ stdin hoặc đối số dòng lệnh. In danh sách tuy nhiên nó thuận tiện, miễn là nó có thể đọc được.

Đây là cá tuyết!

Chỉnh sửa:

Như tôi đã nói trong các bình luận, bạn không cần phải tối ưu hóa đầu ra (tìm chuỗi ngắn nhất là NP-hard ). Tuy nhiên , tôi chỉ nhận ra rằng một giải pháp rẻ tiền sẽ là loại bỏ các số ngẫu nhiên cho đến khi bạn nhận được kết quả mong muốn (một loại bogosort [mới?]). Không có câu trả lời nào cho đến nay đã làm điều này, vì vậy bây giờ tôi tuyên bố rằng thuật toán của bạn không nên dựa vào bất kỳ sự ngẫu nhiên (giả) nào .

Trong khi tất cả các bạn tự đá mình, đây là một biến thể bogopancakesort trong Ruby 2.0 (60 ký tự), để đưa nó vào:

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

GolfScript, 34/21 ký tự

(Cảm ơn @PeterTaylor vì đã cắt 4 ký tự)

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

Bài kiểm tra trực tuyến

Phiên bản 21 ký tự ngắn hơn chỉ hoạt động cho các danh sách chỉ có các mục duy nhất

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

Bài kiểm tra trực tuyến

Cả hai phiên bản đều tạo ra các giải pháp tối ưu.

Giải thích cho giải pháp ngắn hơn:

~]         # 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

Điều này sử dụng một thuật toán khác với hầu hết những người khác được đăng. Về cơ bản, nó nắm lấy phần tử nhỏ nhất của danh sách và với hai lần lật di chuyển nó ra phía trước, giữ nguyên thứ tự của các phần tử khác.

Để di chuyển phần tử thứ n ra phía trước:

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

Nó lặp lại thao tác này cho từng thành phần theo thứ tự và kết thúc với một danh sách được sắp xếp ngược lại. Sau đó nó lật toàn bộ danh sách để sắp xếp nó đầy đủ.

Trong thực tế, thuật toán là một biến thể của giải pháp Python 90 ký tự (tất nhiên là của riêng tôi):

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 ký tự

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

Lật bánh pancake lớn nhất lên trên cùng, sau đó lật toàn bộ ngăn xếp. Loại bỏ chiếc bánh lớn nhất từ ​​dưới lên và lặp lại.

ilà chỉ số của bánh kếp lớn nhất. L=L[:i:-1]+L[:i]lật i+1bánh kếp, lật len(L)bánh xèo, rồi thả chiếc bánh cuối cùng.

Ruby 1.9 - 109 88 79 ký tự

Phiên bản nhỏ gọn hơn nhiều dựa trên giải pháp python tuyệt vời của Keith:

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

Phiên bản gốc:

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

Nếu bạn không quan tâm đến các hoạt động giả (đảo ngược các ngăn có kích thước 1 hoặc đảo ngược cùng một ngăn xếp hai lần liên tiếp), bạn có thể làm cho nó ngắn hơn một chút (96 ký tự):

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

Đưa danh sách chưa sắp xếp thành đối số dòng lệnh. Ví dụ sử dụng:

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

GolfScript, 31 29 ký tự

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

Một giải pháp GolfScript khác, cũng có thể được thử nghiệm trực tuyến .

Phiên bản trước:

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

Làm thế nào nó hoạt động: nó lật mục lớn nhất lên trên cùng và sau đó đến vị trí cuối cùng trong danh sách. Vì bây giờ nó ở đúng vị trí, chúng tôi có thể xóa nó khỏi danh sách.

~]         # 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 ký tự

Mong đợi đầu vào trên dòng lệnh.

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

Các giải pháp nó in được quyết định là tối ưu phụ. (Tôi đã có một chương trình với đầu ra đẹp hơn khoảng 24 ký tự ....)

Logic là loại thú vị. Nó bắt đầu bằng cách lập danh mục chỉ mục của từng mục, theo thứ tự được sắp xếp. Sau đó, nó lặp đi lặp lại qua danh mục này từ phải sang trái. Vì vậy, áp dụng lật bao gồm điều chỉnh các chỉ số bên dưới giá trị ngưỡng, thay vì thực sự di chuyển các giá trị xung quanh. Sau khi hoàn thiện, tôi cũng đã cứu được một vài nhân vật bằng cách thực hiện đồng thời cả hai lần lật cho mỗi lần lặp.

Con trăn 2 (254)

Tìm kiếm BFS đơn giản, một số nội dung được nội tuyến, có thể được nén nhiều hơn mà không thay đổi kiểu tìm kiếm. Hy vọng rằng điều này cho thấy có thể làm thế nào để bắt đầu chơi golf một chút (quá nhiều để có trong một nhận xét đơn giản).

Sử dụng:

python script.py 4 2 3 1

(2 dấu cách = tab)

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ó không hiệu quả: nó sẽ không tìm thấy trình tự sắp xếp tốt nhất và trình tự đã cho thậm chí có thể chứa no-op (tức là chỉ lật phần tử đầu tiên), tuy nhiên đầu ra là hợp lệ.

Đầu ra được đưa ra dưới dạng:

n_1 n_2
n_3 n_4
n_5 n_6
...

Mà nên được đọc như là chuỗi của flips : n_1 n_2 n_3 n_4 n_5 n_6 .... Nếu bạn muốn có được một đầu ra như:

n_1 n_2 n_3 n_4 n_5 n_6 ...

Đơn giản chỉ cần thêm một dấu phẩy trong printtuyên bố.

Python - 282 ký tự

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

Golf đầu tiên của tôi bao giờ mã; Tôi không hề ảo tưởng mình sẽ chiến thắng , nhưng tôi đã có rất nhiều niềm vui. Đưa ra tất cả mọi thứ tên một nhân vật chắc chắn làm cho nó đáng sợ để đọc, hãy để tôi nói cho bạn biết! Điều này được chạy từ dòng lệnh, thực hiện mẫu dưới đây:

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

Không có gì đặc biệt hay sáng tạo về cách tôi đã thực hiện điều này, nhưng Câu hỏi thường gặp đề nghị đăng một phiên bản không dành cho người đọc quan tâm, vì vậy tôi đã thực hiện dưới đây:

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

Thuật toán cơ bản tôi đã sử dụng là thuật toán được đề cập trong bài viết wiki được liên kết trong câu hỏi :

Thuật toán sắp xếp bánh kếp đơn giản nhất đòi hỏi tối đa 2n − 3 lần lật. Trong thuật toán này, một biến thể của sắp xếp lựa chọn, chúng tôi đưa chiếc bánh lớn nhất chưa được sắp xếp lên trên cùng với một lần lật, sau đó đưa nó xuống vị trí cuối cùng với một lần nữa, sau đó lặp lại điều này cho những chiếc bánh còn lại.

C # - 264 259 252 237 ký tự

Sử dụng thuật toán đơn giản nhất và tạo đầu ra chính xác mà không cần lật. Có thể loại bỏ 7 ký tự nếu tôi cho phép nó bao gồm 1 (không lật) trong đầu ra, nhưng điều đó thật xấu xí.

Tôi đã sử dụng để sử dụng gotocho sân golf tối đa. Cũng lưu một số ký tự bằng cách cho phép nó thực hiện không lật (nhưng không in chúng).

Cải tiến mới nhất: giữ mảng đầu vào dưới dạng chuỗi thay vì chuyển đổi sang ints.

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

Ung dung:

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

Đây là giải pháp ban đầu của tôi, vô dụng (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 byte

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

Hãy thử trực tuyến! Tìm mức tối đa, lật nó ra phía sau và sắp xếp đệ quy danh sách còn lại.

Chỉnh sửa: -1 byte nhờ BMO

Perl 5.10 (hoặc cao hơn), 66 byte

Bao gồm +3cho -n Việc use 5.10.0đưa ngôn ngữ lên cấp độ perl 5.10 được coi là miễn phí

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

Chạy với đầu vào là một dòng trên STDIN:

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

Sắp xếp danh sách bằng cách liên tục tìm thấy bất kỳ sự đảo ngược nào, lật nó ra phía trước sau đó lật ngược lại và lật mọi thứ trở lại vị trí cũ. Và đó là tương đương với trao đổi các đảo ngược vì vậy tôi không cần phải đảo ngược (mà là vụng về trên dây vì nó sẽ đảo ngược các chữ số của các giá trị chuyển đổi ví dụ 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--);}}}

phiên bản có thể đọc đượ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--);
        }
    }
}