ในการเรียงแพนเค้กการดำเนินการที่อนุญาตเท่านั้นคือการย้อนกลับองค์ประกอบของคำนำหน้าบางส่วนของลำดับ หรือคิดว่าเป็นแพนเค้กกอง: เราใส่ไม้พายเข้าไปในกองและหมุนแพนเค้กทั้งหมดเหนือไม้พาย

ยกตัวอย่างเช่นลำดับ6 5 4 1 2 3สามารถจัดเรียงตามพลิกแรกแรก6องค์ประกอบ (ทั้งลำดับ) ผลผลิตผลกลาง3 2 1 4 5 6และจากนั้นพลิกแรกองค์ประกอบที่เดินทางมาถึง31 2 3 4 5 6

เนื่องจากมีการดำเนินการเพียงครั้งเดียวกระบวนการเรียงลำดับทั้งหมดจึงสามารถอธิบายได้ด้วยลำดับของจำนวนเต็มโดยที่จำนวนเต็มแต่ละจำนวนคือจำนวนองค์ประกอบ / แพนเค้กเพื่อรวมการพลิกหน้า ตัวอย่างข้างต้นลำดับการเรียงลำดับ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 ) อย่างไรก็ตามฉันเพิ่งรู้ว่าวิธีแก้ปัญหาราคาถูกคือการโยนตัวเลขสุ่มจนกว่าคุณจะได้ผลลัพธ์ที่ต้องการ (เป็นโบกี้แบบใหม่ [??]) ไม่มีคำตอบเพื่อให้ห่างไกลได้กระทำนี้ดังนั้นตอนนี้เราประกาศว่าอัลกอริทึมของคุณไม่ควรพึ่งพา (หลอก)

ในขณะที่คุณกำลังเตะตัวเองนี่คือตัวแปร bogopancakesort ใน Ruby 2.0 (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

มันทำซ้ำการดำเนินการนี้สำหรับแต่ละองค์ประกอบตามลำดับและจบลงด้วยรายการเรียงกลับกัน จากนั้นจะพลิกรายการทั้งหมดเพื่อจัดเรียงอย่างสมบูรณ์

ในความเป็นจริงอัลกอริทึมเป็นรูปแบบของโซลูชัน Python 90-char (ของฉันเองแน่นอน):

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 ตัวอักษร

รุ่นที่กะทัดรัดกว่านี้มากขึ้นอยู่กับโซลูชันหลามของ Keith:

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

รับรายการที่ไม่เรียงลำดับเป็น args ของบรรทัดคำสั่ง ตัวอย่างการใช้งาน:

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

Simple BFS-search, บางสิ่งอินไลน์, อาจถูกบีบอัดได้มากกว่าโดยไม่เปลี่ยนสไตล์การค้นหา หวังว่านี่จะแสดงให้เห็นว่าจะเริ่มเล่นกอล์ฟได้อย่างไร (มากเกินไปที่จะแสดงความคิดเห็นอย่างง่าย)

ใช้:

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-ops (เช่นการพลิกเฉพาะองค์ประกอบแรก) แต่ผลลัพธ์นั้นถูกต้อง

เอาท์พุทจะได้รับในรูปแบบ:

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]

ไม่มีอะไรพิเศษเป็นพิเศษหรือเป็นความคิดสร้างสรรค์เกี่ยวกับวิธีที่ฉันได้ทำไป แต่คำถามที่พบบ่อยแนะนำให้โพสต์เวอร์ชันที่ไม่ใช่กอล์ฟสำหรับผู้อ่านที่สนใจดังนั้นฉันได้ทำดังนี้

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 ตัวอักษร

ใช้อัลกอริทึมที่ง่ายที่สุดและสร้างเอาต์พุตที่ถูกต้องโดยไม่ต้องพลิกซ้ำซ้อน สามารถโกนทิ้งได้ 7 ตัวถ้าฉันอนุญาตให้มันรวม 1 (ไม่หมุน) ในผลลัพธ์ แต่นั่นน่าเกลียด

ฉันใช้เพื่อgotoการเล่นกอล์ฟอย่างสูงสุด บันทึกบางตัวอักษรด้วยการอนุญาตให้ทำแบบไม่พลิก (แต่ไม่พิมพ์)

การปรับปรุงล่าสุด: ทำให้อาร์เรย์อินพุตเป็นสตริงแทนที่จะแปลงเป็น 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;}}}}}

Ungolfed:

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

ลองออนไลน์! ค้นหาค่าสูงสุดพลิกไปทางด้านหลังและเรียงลำดับรายการที่เหลือซ้ำ

แก้ไข: -1 ไบต์ขอบคุณBMO

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:

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