जली हुई पैनकेक समस्या

यह चुनौती फ्लिपिंग पेनकेक्स से संबंधित है ।

आपने पैनकेक सॉर्टिंग के बारे में सुना होगा , जहां पैनकेक के ढेर को आकार में क्रमबद्ध करके स्टैक में स्पैटुला डाला जाता है और स्पैचुला के ऊपर सभी पेनकेक्स को फ्लिप किया जाता है, जब तक कि प्लेटों पर पेनकेक्स सबसे छोटे सॉर्ट किए जाते हैं। जले हुए पैनकेक की समस्या थोड़ी अलग है। सभी पेनकेक्स में अब एक पक्ष होता है जिसे जलाया जाता है, और छँटाई के पूरा होने पर प्रत्येक पैनकेक के जला पक्ष को प्लेट का सामना करना पड़ता है।

उदाहरण के लिए, निम्नलिखित स्टैक दिया गया है (बाईं ओर पैनकेक का आकार। 0अर्थ बर्न-साइड डाउन और 1अर्थ बर्न-साइड राइट-अप):

1 0
3 1
2 1

आप पाने के लिए पूरे स्टैक को फ्लिप कर सकते हैं 20 30 11, प्राप्त करने के लिए शीर्ष दो को 31 21 11फ्लिप कर सकते हैं और प्राप्त करने के लिए पूरे स्टैक को फिर से फ्लिप कर सकते हैं 10 20 30, बर्न पैनकेक के एक सॉर्ट किए गए स्टैक। इस क्रम में, फ्लिप 3, फ्लिप 2, फ्लिप 3, को इस रूप में दर्शाया जा सकता है 3 2 3।

चुनौती

पेनकेक्स के आकारों की एक सरणी (जरूरी नहीं कि अद्वितीय) और उनकी अभिविन्यास को देखते हुए, किसी भी वैध जले हुए पैनकेक सॉर्टिंग अनुक्रम का उत्पादन किया जाता है, अर्थात्, फ्लिप्स का एक क्रम जो पेनकेक्स के ढेर को सबसे छोटे से सबसे बड़े से जलाए जाने वाले पक्षों के साथ क्रमबद्ध करता है।
इनपुट और आउटपुट विभाजकों के साथ किसी भी प्रकार का प्रारूप हो सकता है, लेकिन कृपया निर्दिष्ट करें कि आप किन प्रारूपों का उपयोग करते हैं और बताते हैं कि आपके इनपुट प्रारूप का कौन सा अंत स्टैक (टीओएस) के शीर्ष पर है।
शून्य पैनकेक फ़्लिप करने की अनुमति है।
इनपुट / आउटपुट में विभाजकों को मिलाने की अनुमति है।

परीक्षण के मामलों

निम्नलिखित सभी परीक्षण मामलों के लिए, इनपुट एक सूची है और आउटपुट एक अंतरिक्ष-पृथक स्ट्रिंग है, और टीओएस बाईं ओर है।

[[1, 0], [3, 1], [2, 1]]
"3 2 3"

[[5, 1], [3, 0], [4, 1], [2, 1], [1, 0]]
"5 3 4 1 3 2 1"

[[5, 1], [3, 0], [3, 0], [1, 1]]
"4 3 2 3"

हमेशा की तरह, अगर कुछ भी अस्पष्ट या गलत है, तो कृपया मुझे टिप्पणियों में बताएं। गुड लक और गुड गोल्फिंग!

— Sherlock9
स्रोत

जवाबों:

पायथन 2, 83

इनपुट के अंत में स्टैक के शीर्ष के साथ (आकार, अभिविन्यास) ट्यूपल्स की सूची होने की उम्मीद है। आउटपुट विभिन्न प्रकार के व्हाट्सएप द्वारा अलग किए गए आकारों की एक सूची है।

a=input()
while a:i=a.index(max(a));print len(a)-i,a[i][1],len(a),i;a=a[i+1:]+a[:i]

— feersum
स्रोत

जाहिर तौर पर मैं एक बेवकूफ हूं।

— लीक नून

क्या 0आउटपुट सूची की अनुमति है?

— लीक नून

@LeakyNun फ़्लिपिंग 0 पेनकेक्स प्रमुख रूप से संभव है। वास्तव में, मैं अभी कर रहा हूँ।

— feersum

@daniero स्टैक का शीर्ष दाईं ओर है।

— लीकी नून

@LeakyNun ओह क्षमा करें, मेरा बुरा

— दानिएरो

CJam (37 बाइट्स)

q~{__$W>#)_p/(W%\M*2,f.^+(1=p_,)pW%}h

स्टड पर CJam प्रारूप में इनपुट एक सरणी है; आउटपुट स्टडआउट पर फ्लिप लंबाई की एक नई-लाइन-अलग सूची है। स्टैक का शीर्ष सूचकांक पर है 0; 0जला पक्ष इंगित करता है, और 1नीचे जला पक्ष इंगित करता है।

ऑनलाइन डेमो

विच्छेदन

आउटपुट हमेशा 3nलंबा होता है, जहां nपेनकेक्स की संख्या होती है। पहले हम सबसे बड़े शेष पैनकेक को शीर्ष पर फ्लिप करते हैं; फिर अगर यह नीचे की तरफ जले तो हम उस एक पैनकेक को पलटें; और फिर हम इसे नीचे तक फ्लिप करते हैं और फिर से दोहराते हैं जैसे कि पेनकेक्स का ढेर एक छोटा था।

q~         e# Parse input into array
{          e# Loop...
  __$W>#)  e#   Find 1-based index of largest element in array
  _p       e#   Dup and print
  /(       e#   Split into chunks that long, and pull off the first
  W%       e#   Reverse the first chunk. Note that we don't flip the burnt/unburnt bit
  \M*      e#   Merge the remaining chunks into a single array
  2,f.^    e#   Flip *their* burnt/unburnt bits
  +        e#   Concatenate, prepending the first chunk
  (1=p     e#   Pull off the first (largest) element and print its burnt/unburnt bit
  _,)p     e#   Print the number of remaining elements plus 1 (to account for the largest)
  W%       e#   Reverse. Note that the first chunk has now been flipped twice, which is
           e#   why we have left its burnt/unburnt bit alone
}h         e# ... until we get down to an empty array

— पीटर टेलर
स्रोत

रूबी, 101 95 93 बाइट्स

बहुत गोल्फ नहीं है, मैं बस एक बोगो-प्रकार का संस्करण बनाना चाहता था। यह एक अनाम फ़ंक्शन है जो एरे की एक सरणी लेता है और पेनकेक्स को सॉर्ट करने तक यादृच्छिक फ़्लिप को प्रिंट करता है।

->a{(p r=-~rand(a.size)
a[0,r]=a[0,r].reverse.map{|x,b|[x,1-b]})while a!=a.sort||a.rassoc(1)}

आप उदाहरण के लिए इसे fकह सकते हैं और कह सकते हैंf.call [[1, 0], [3, 1], [2, 1]]

rassoc
@ शेरलॉक 9 से -2 बाइट्स के शानदार उपयोग के साथ @ जोर्डन से -5 बाइट्स

— daniero
स्रोत

के a.all?{...}साथ बदलकर आप कुछ बाइट्स बचा सकते हैं !a.rassoc(1)।

— जॉर्डन

@ जोर्डन वाह, यह वाकई शानदार है! मुझे नहीं लगता कि मैंने पहले कभी ( r) का उपयोग करने के बारे में सोचा है assoc, लेकिन इसके बारे में सोचकर, यह शायद इस साइट पर बहुत सारी समस्याओं में उपयोगी है - मुझे लगता है कि इसे रूबी गोल्फ टिप्स पोस्ट में जाना चाहिए। किसी भी तरह, धन्यवाद :) मैं भी एक और बाइट को मारने में सक्षम था, हालांकि deMorgans कानून के आवेदन और के untilसाथ प्रतिस्थापित while।

— डेनिएरो

अच्छा विचार: codegolf.stackexchange.com/questions/363/…

— जॉर्डन

चूँकि bकेवल कभी है 0या 1, 1-bयह भी काम करेगा और दो बाइट्स बचाएगा।

— शर्लक 9