에서는 팬케이크 정렬 만 허용하는 동작 시퀀스의 일부 요소 프리픽스의 역이다. 또는 팬케이크 스택을 생각해보십시오. 스택 어딘가에 주걱을 넣고 주걱 위의 모든 팬케이크를 뒤집습니다.

예를 들어, 서열은 6 5 4 1 2 3제 반전 처음으로 분류 될 수 6중간 결과를 산출 요소 (전체 순서) 3 2 1 4 5 6다음, 제 뒤집기 3에 도착 소자 1 2 3 4 5 6.

하나의 연산 만이 있기 때문에, 전체 분류 프로세스는 일련의 정수로 설명 될 수 있으며, 여기서 각 정수는 pr 플립을 포함하는 요소 / 팬케이크의 수이다. 위의 예에서 정렬 순서 는입니다 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입니다 ). 그러나 , 나는 당신이 원하는 결과를 얻을 때까지 ([new?] 유형의 bogosort) 임의의 숫자를 버리는 것이 싼 해결책이라는 것을 깨달았습니다. 지금까지 아무도 대답 을하지 않았 으므로 이제 알고리즘이 (의사) 임의성에 의존해서는 안된다고 선언 합니다 .

모두 자신을 차는 동안 Ruby 2.0 (60 문자)의 bogopancakesort 변형이 있습니다.

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

GolfScript, 34/21 자

(4 개의 문자를 자르 신 @PeterTaylor에게 감사드립니다)

~].{,,{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

파이썬, 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의 훌륭한 파이썬 솔루션을 기반으로 한 훨씬 더 컴팩트 한 버전 :

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

펄, 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 문자 전에 훨씬 좋은 출력을 가진 프로그램을 가지고있었습니다 ....)

논리는 흥미 롭습니다. 정렬 순서대로 각 항목의 색인을 카탈로그 화하여 시작합니다. 그런 다음이 카탈로그를 오른쪽에서 왼쪽으로 반복합니다. 플립을 적용하려면 실제로 값을 이동하는 대신 컷오프 값 아래로 인덱스를 조정해야합니다. 약간의 finagling 후 나는 반복 당 두 플립을 동시에 수행하여 몇 개의 문자를 절약 할 수있었습니다.

파이썬 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

파이썬 2 : 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명령문에 쉼표를 추가하십시오 .

파이썬-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

내가 사용한 기본 알고리즘 은 질문에 링크 된 위키 기사 에서 언급 한 것입니다 .

가장 간단한 팬케이크 정렬 알고리즘에는 최대 2n-3 플립이 필요합니다. 선택 알고리즘의 변형 인이 알고리즘에서, 우리는 아직 분류되지 않은 가장 큰 팬케이크를 한 번의 플립으로 맨 위로 가져간 다음 한 번 더 최종 위치로 내려간 다음 나머지 팬케이크에 대해 이것을 반복합니다.

C # -26459252 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;
                }
            }
        }
    }
}

여기 내 초기 솔루션, ungolfed (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);
            }
        }
    }
}

하스켈 , 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.05.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--);
        }
    }
}