У сортуванні млинців єдиною дозволеною операцією є повернення елементів деякого префіксу послідовності. Або придумайте стопку млинців: ми вставляємо десь у стопку шпатель і перевертаємо всі млинці над шпателем.

Наприклад, послідовність 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 ). Однак я просто зрозумів, що дешевим рішенням буде викинути випадкові числа, поки ви не отримаєте бажаного результату ([новий?] Тип богосорту). Жоден із відповідей поки що цього не зробив, тому я заявляю, що ваш алгоритм не повинен покладатися на будь-яку (псевдо-) випадковість .

Поки ви все б’єте себе, ось варіант богопанкексарт в 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

Він повторює цю операцію для кожного елемента по порядку і закінчується зворотним відсортованим списком. Потім він гортає весь список, щоб залишити його повністю відсортованим.

Насправді алгоритм - це варіація 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 символів

Набагато більш компактна версія, заснована на чудовому пітонному рішенні Кіта:

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, 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 символів тому ....)

Логіка якась цікава. Він починається з каталогізації індексу кожного елемента, чи було це відсортовано. Потім він повторюється через цей каталог справа наліво. Тож застосування фліп передбачає коригування індексів нижче значення відсічення, а не фактично переміщення значень навколо. Після декількох фіналізацій мені також вдалося зберегти кілька символів, роблячи обидва фліпи за ітерацію одночасно.

Пітон 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

Це неефективно: він не знайде найкращої послідовності сортування, і дана послідовність може навіть містити відсутності (тобто гортати лише перший елемент), проте результат є дійсним.

Вихід подається у вигляді:

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

Основний алгоритм, який я використовував, є той, який згадується у статті 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;}}}}}

Безголівки:

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в довести мову до рівня Perl 5,10 вважається вільним-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--);
        }
    }
}