पेनकिलिंग पैनकेक

Question

में पैनकेक छँटाई केवल अनुमति आपरेशन अनुक्रम में से कुछ उपसर्ग के तत्वों को उल्टा करने के लिए है। या, पेनकेक्स के ढेर के बारे में सोचें: हम स्टैक में कहीं न कहीं एक स्पैटुला डालते हैं और स्पैचुला के ऊपर सभी पेनकेक्स को फ्लिप करते हैं।

उदाहरण के लिए, अनुक्रम 6 5 4 1 2 3को पहले 6तत्वों (संपूर्ण अनुक्रम) को 3 2 1 4 5 6फ़्लिप करके, मध्यवर्ती परिणाम को उपजाने , और फिर पहले 3तत्वों को फ़्लिप करके, हल किया जा सकता है 1 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

काम:

एक प्रोग्राम लिखें जो पूर्णांक की एक सूची लेता है और एक वैध पैनकेक अनुक्रम अनुक्रमित करता है।

सॉर्ट करने के लिए सूची या तो स्टड, या कमांड लाइन तर्कों से एक अलग अंतरिक्ष सूची हो सकती है। सूची को प्रिंट करें हालांकि यह सुविधाजनक है, जब तक यह कुछ हद तक पठनीय है।

यह कोडगोल्फ है!

संपादित करें:

जैसा कि मैंने टिप्पणियों में कहा था, आपको आउटपुट का अनुकूलन करने की आवश्यकता नहीं है (सबसे छोटा अनुक्रम एनपी-हार्ड है )। हालांकि , मुझे सिर्फ यह एहसास हुआ कि जब तक आप वांछित परिणाम (एक [नया?] प्रकार का बोगोसर्ट) प्राप्त नहीं कर लेते, तब तक एक सस्ता समाधान यादृच्छिक संख्याओं को फेंकना होगा। अब तक किसी भी उत्तर ने ऐसा नहीं किया है, इसलिए मैं अब घोषणा करता हूं कि आपके एल्गोरिथ्म को किसी भी (छद्म-) यादृच्छिकता पर भरोसा नहीं करना चाहिए ।

जब आप सभी अपने आप को मार रहे हैं, तो यहां रूबी 2.0 (60 अक्षर) में एक बोगोपेंकसॉर्ट संस्करण है, इसे इसमें रगड़ने के लिए:

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

Comments

किसी भी मान्य अनुक्रम, या यह एक न्यूनतम लंबाई होना चाहिए?

— पीटर टेलर

टिनी टाइपो: दूसरा उदाहरण दिखाता है 4 3 2 1कि4 2 3 1

— भालू ५०५

(मेरा इंटरनेट नीचे चला गया क्योंकि मैंने इसे संपादित करने की कोशिश की, इसलिए मैं इसे फिर से पोस्ट करता हूं) @PeterTaylor मुझे कुछ प्रकार के अनुकूलन को इसमें शामिल करने के लिए लुभाया गया, लेकिन नहीं चुना गया। न्यूनतम अनुक्रम की लंबाई खोजना वास्तव में एनपी-कठिन है , जबकि सबसे सरल, सीधे-आगे एल्गोरिथ्म एक समाधान पा सकते हैं जो कि अधिकतम 2 एन लंबा होगा। मैं वास्तव में नहीं जानता कि मैं इसे एक कोड-चुनौती / इष्टतम आउटपुट चीज़ के रूप में कैसे आंकूंगा, और मुझे सादे कोडगॉल्फ अधिक पसंद हैं :)

— daniero

मुझे आश्चर्य है कि कोई भी इस चुनौती से अपनी प्रविष्टि पोस्ट करेगा ।

— GRC

क्या अनुक्रम को सन्निहित मूल्य होना चाहिए? 2 7 5 एक वैध इनपुट है?

Answer 1

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

यह पोस्ट किए गए अधिकांश अन्य लोगों के लिए एक अलग एल्गोरिथ्म का उपयोग करता है। मूल रूप से यह सूची के सबसे छोटे तत्व को पकड़ लेता है, और दो flips के साथ इसे आगे की ओर ले जाता है, अन्य तत्वों के क्रम को संरक्षित करता है।

Nth तत्व को सामने की ओर ले जाने के लिए:

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-चर पायथन समाधान की भिन्नता है (मेरे अपने, निश्चित रूप से):

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

Comments

मुझे लगता है कि आप गोल्फस्क्रिप्ट के उपयोगी क्विर्क में से एक में नहीं आए हैं: आप किसी भी टोकन को एक चर के रूप में उपयोग कर सकते हैं। आप &कहीं भी उपयोग नहीं कर रहे हैं , इसलिए आपको व्हाट्सएप को हटाते sसमय प्रतिस्थापित करने में सक्षम होना चाहिए &।

— पीटर टेलर

@PeterTaylor हुह, मैं सोच रहा था कि आप फ़ौजदारी ^चुनौती में एक चर के रूप में क्यों इस्तेमाल कर सकते हैं ?) टिप के लिए धन्यवाद!

— अस्थिरता

इनपुट के लिए 3 2 1मुझे मिलता है 131211जो सही नहीं है।

— हावर्ड

@ हॉवर्ड को अब काम करने के लिए मिल गया

— अस्थिरता

@Volatility अंतिम परिवर्तन बहुत अधिक था; ;-) जैसे सूचियों को 2 1 1और अधिक क्रमबद्ध नहीं किया जा सकता है।

— हावर्ड

Answer 2

पायथन, 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]flips i+1पैनकेक्स, flips len(L)पेनकेक्स, तो पिछले पैनकेक चला जाता है।

Comments

मुझे लगा कि आपको केवल फ़्लिप करने की अनुमति थी। (यही है, मुझे नहीं लगता कि आप स्टैक से पेनकेक्स छोड़ सकते हैं)। क्या मैंने नियमों को गलत समझा? हम्म। फिर से विकी पेज पढ़ने के लिए जाता है , भले ही, अच्छा काम :) 100 से कम अक्षर मेरे लिए बहुत अद्भुत है!

— वेंडीकिड

@WendiKidd वास्तव में, उसका क्या मतलब है कि सबसे बड़ी एक को नीचे करने के बाद, वह इसे अनदेखा कर रहा है और इसके शीर्ष पर पेनकेक्स के साथ खुद को संबंधित है।

— AJMansfield

@AJMansfield आह, मैं देख रहा हूँ! धन्यवाद, जो समझ में आता है। मैं कोड नहीं पढ़ सकता (मैं पायथन के लिए बहुत नया हूं) इसलिए मैंने स्पष्टीकरण को गलत समझा :) धन्यवाद!

— वेंडीकिड

इससे पहले मैंने जो कुछ लिखा था, उसका बहुत विकास हुआ। मैंने तत्वों को हटाने के बारे में नहीं सोचा क्योंकि शुरुआत में मुझे आउटपुट की शुद्धता की जांच करनी थी (यानी बाद में छांटी गई सूची?)। वैसे: मेरा मानना ​​है कि printअभ्यस्त से कॉमा को हटाना आउटपुट को अपठनीय प्रस्तुत करता है (1 बाइट बचा :) :)

— बकुरीउ जुएल 11'13

@WendiKidd वास्तव में, आगे के निरीक्षण पर, यह वास्तव में पेनकेक्स को हटा देता है; यह केवल यह पता लगाने की आवश्यकता है कि फ़्लिप का क्रम क्या है, वास्तव में सरणी को सॉर्ट नहीं करना है।

— AJMansfield

Answer 3

रूबी 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

Answer 4

गोल्फस्क्रिप्ट, 31 29 वर्ण

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

एक और गोल्स्टस्क्रिप्ट समाधान, ऑनलाइन भी परीक्षण किया जा सकता है ।

पुराना वर्जन:

~].$-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
}/

Answer 5

पर्ल, १०३ १०० अक्षर

कमांड लाइन पर इनपुट की उम्मीद है।

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

समाधान यह प्रिंट निश्चित रूप से उप-इष्टतम हैं। (मेरे पास लगभग 24 वर्णों के बहुत अच्छे उत्पादन के साथ एक कार्यक्रम था ....)

तर्क एक तरह का दिलचस्प है। यह प्रत्येक आइटम के सूचकांक को सूचीबद्ध करने से शुरू होता है, क्या यह क्रमबद्ध क्रम में थे। इसके बाद दाएं से बाएं इस कैटलॉग के माध्यम से पुनरावृति होती है। इसलिए फ्लिप लगाने से कटऑफ वैल्यू के नीचे इंडेक्स को एडजस्ट करना शामिल है, बजाय वास्तव में मूविंग वैल्यू के। कुछ फाइनल करने के बाद, मैंने दोनों पात्रों को एक साथ प्रति फ्लिप करके कुछ पात्रों को बचाने में भी कामयाबी हासिल की।

Answer 6

पायथन 2 (254)

सरल बीएफएस-खोज, कुछ सामान इनबिल्ट है, संभवतः खोज शैली को बदले बिना अधिक संकुचित किया जा सकता है। उम्मीद है कि इससे पता चलता है कि कैसे गोल्फ को थोड़ा शुरू करना है (एक साधारण टिप्पणी में बहुत अधिक होना)।

उपयोग:

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

Comments

आप के sys.exit()साथ प्रतिस्थापित कर सकते हैं 1/0(कोडगॉल्फ में आप कभी भी परवाह नहीं करते हैं कि क्या stderr में मुद्रित हो जाता है ...)।

— बकुरीउ

यकीन है, मैं print s[::-1];1/0कुछ आकर्षण दाढ़ी बनाने के लिए कर सकता था ।

— मील

बीएफएस बहुत दिलचस्प है, लेकिन इसे 4 2 3 1देता है 2 3 2 4, जो वास्तव में अमान्य है।

— डानिएरो

@daniero वह आउटपुट कैसे अमान्य है? 4 2 3 1-> 2 4 3 1-> 3 4 2 1-> 4 3 2 1->1 2 3 4

— गैरेथ

@ गैरेथ मुझे कोई पता नहीं है! और मैंने इसे दो बार चेक किया .. ओह ठीक है, फिर कोई बात नहीं :) अच्छा समाधान, मील टी।

— डानिएरो

Answer 7

पायथन 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

यह कुशल नहीं है: यह सबसे अच्छा क्रमबद्ध अनुक्रम नहीं खोजेगा, और दिए गए अनुक्रम में नो-ऑप्स भी हो सकते हैं (अर्थात केवल पहला तत्व flipping), फिर भी आउटपुट मान्य है।

आउटपुट फॉर्म में दिया गया है:

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बयान में एक अल्पविराम जोड़ें ।

Comments

[:i][::-1]-> [i-1::-1], [:u][::-1]-> [u-1::-1], 2 चार्ट बचाता है

— अस्थिरता

वास्तव में, L[:i]=L[i-1::-1];L[:u]=[u-1::-1]एक और 3 वर्ण बचाता है

— अस्थिरता

@Volatility सुझावों के लिए धन्यवाद। शामिल।

— बकुरीउल

Answer 8

पायथन - 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

बुनियादी एल्गोरिथ्म जिसका मैंने उपयोग किया है, वह प्रश्न में जुड़े विकि लेख में उल्लिखित है :

सबसे सरल पैनकेक सॉर्टिंग एल्गोरिथ्म में अधिकतम 2n − 3 फ़्लिप की आवश्यकता होती है। इस एल्गोरिथ्म में, चयन प्रकार की भिन्नता, हम सबसे बड़े पैनकेक को एक फ्लिप के साथ अभी तक शीर्ष पर क्रमबद्ध नहीं करते हैं, और फिर इसे एक और के साथ अपनी अंतिम स्थिति में ले जाते हैं, फिर शेष पैनकेक के लिए इसे दोहराएं।

Comments

गोल्फ के लिए कुछ सुझाव: इंडेंटेशन के लिए चार स्थान बेकार हैं। बेहतर: एक स्थान का उपयोग करें; और भी बेहतर: टैब और रिक्त स्थान को और भी अधिक काटने के लिए संयोजित करें।

— जॉन ड्वोरक

t=p[:x] t=t[::-1](16 + इंडेंटेशन) को t=p[:x][::-1](13), या t=p[x-1::-1](12) तक घटाया जा सकता है । इनलाइन सब कुछ आप कर सकते हैं:p=p[x-1::-1]+p[x:]

— जॉन ड्वोरक

पीछे से गिनने के लिए नकारात्मक सूचकांकों का उपयोग करें। len(a)-nबन जाता है -n; p=p[-n-1::-1]+p[-n:]। सही संचालन का उपयोग करके आगे गोल्फ:p=p[~n::-1]+p[-n:]

— जॉन ड्वोरक

उम्म ... आप केवल अंतिम परिणाम नहीं, बल्कि पूरे फ़्लिपिंग अनुक्रम को प्रिंट करने वाले हैं।

— जॉन ड्वोरक

जन द्वारक ने क्या कहा। कोडगोल्फ में आपका स्वागत है। आप कुछ सरल उपायों द्वारा आसानी से वर्ण गणना को आधा तक काट सकते हैं; उनमें से कुछ का उल्लेख किया गया है। इसके अलावा, मध्यवर्ती चर अच्छे नहीं हैं। सूची की समझ अच्छी है। लेकिन अगर आप sys.argv का उपयोग कर रहे हैं, तो आप इनपुट के प्रत्येक नंबर को एक तर्क दे सकते हैं, तो map(int,sys.argv[1:])वही करता है जो अब आपकी 6 पहली लाइनें हैं। i=x=g=0काम करता है, लेकिन आपको चर की मात्रा में कटौती करनी चाहिए। हालांकि मैं आपको एक चीज़ दूंगा: यह एक अजगर प्रवेश है, जिसमें से मैं सबसे कम समझता हूं: D

— daniero

Answer 9

सी # - 264 259 252 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;}}}}}

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 गोल्स गोल्फ):

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

Comments

गैर-सन्निहित अनुक्रमों को संभालता नहीं है - उन इनपुट के साथ गलत परिणाम दे रहा है।

@ शत: मुझे यकीन नहीं है कि आपका क्या मतलब है। क्या आप मुझे एक उदाहरण दे सकते हैं?

— इग्बी लार्गेमन

1 22 के इनपुट को देखते हुए, परिणाम एक स्वैप करने के लिए कहता है, जिसका परिणाम 22 में होगा। मुझे लगता है कि आपके कोड में सन्निहित संख्याओं को शामिल करने की अनुक्रम की उम्मीद है (उदाहरण: 2 4 1 3), लेकिन इनपुट्स की उम्मीद नहीं है (जैसे) २ २४ ५ ५ ९ ०)।

@ शत: वास्तव में, मैंने अनुक्रम में अंतराल का समर्थन करने का कोई प्रयास नहीं किया, क्योंकि इससे कोई मतलब नहीं होगा। पैनकेक सॉर्ट का विचार वस्तुओं के ढेर को क्रमबद्ध करना है, न कि मनमानी संख्याओं का समूह। प्रत्येक ऑब्जेक्ट से जुड़ी संख्या स्टैक में इसकी उचित स्थिति की पहचान करती है। इसलिए संख्या हमेशा 1 से शुरू होगी और सन्निहित होगी।

— Igby Largeman

मुझे यकीन नहीं था, क्योंकि सवाल में "अनुक्रम" कहा गया था, और गणित में, {1, 22} एक वैध अनुक्रम है, लेकिन दोनों उदाहरण सन्निहित संख्याएँ थे। इसलिए मैंने ओपी से स्पष्टीकरण मांगा (प्रश्न पर टिप्पणी देखें)। मुझे लगता है कि यहां अधिकांश उत्तर अंतराल को ठीक कर देंगे।

Answer 10

हास्केल , 72 71 बाइट्स

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

इसे ऑनलाइन आज़माएं! अधिकतम ढूँढता है, इसे वापस फ़्लिप करता है और शेष सूची को पुनरावृत्ति करता है।

संपादित करें: बीएमओ के लिए -1 बाइट धन्यवाद

Answer 11

पर्ल 5.10 (या अधिक), 66 बाइट्स

5.10 भाषा को स्तर पर लाने के +3लिए -n The use 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)

Answer 12

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