कोटिंग हर पैनकेक

Question

आपके पास एक प्लेट पर पेनकेक्स का ढेर है, जिसके ऊपर सिरप का एक ग्लोब इतना गाढ़ा है कि यह नीचे की तरफ नहीं चल सकता है। आप तब तक खाने के लिए खुश नहीं होंगे जब तक कि प्रत्येक पैनकेक के दोनों चेहरे कम से कम सिरप को न छू लें, लेकिन अभी शीर्ष पैनकेक के केवल एक चेहरे के पास है।

आप जानते हैं कि सिरप कभी भी एक पैनकेक के माध्यम से सोख नहीं करेगा, लेकिन इसे दो पेनकेक्स के बीच आमने-सामने संपर्क के माध्यम से अनिश्चित काल के लिए स्थानांतरित किया जा सकता है। एक बार पैनकेक का एक चेहरा सिरप को छूने के बाद इसे हमेशा के लिए सिरप में लेपित माना जाता है, और यह किसी भी गैर-सिरप लेपित चेहरे को बनाएगा जो इसे सिरप के रूप में अच्छी तरह से छूता है। सिरप को प्लेट के ऊपर और नीचे से भी स्थानांतरित करना संभव है।

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

अपने पिछले झोंकों को देखते हुए आप यह निर्धारित कर सकते हैं कि आपके पेनकेक्स अभी तक सिरप के साथ लेपित हैं?

चुनौती

एक प्रोग्राम लिखें जो पैनकेक की संख्या के लिए एक सकारात्मक पूर्णांक एन में लेता है, और आपके द्वारा अब तक किए गए फ़्लिप के लिए सकारात्मक पूर्णांक (सभी <= एन) की एक सूची। सूची में प्रत्येक संख्या उन पैनकेक की संख्या को दर्शाती है जो फ़्लिप किए गए थे। यदि पैनकेक्स को कोट किया जा रहा है और नहीं तो फाल्सी वैल्यू होने पर एक सत्य मूल्य का उत्पादन करें। ( सच्चाई / झूठी परिभाषा )

इनपुट को स्टडिन या कमांड लाइन से आना चाहिए और आउटपुट को स्टडआउट (या निकटतम विकल्प) पर जाना चाहिए। यह ठीक है अगर आपके इनपुट को थोड़ा अतिरिक्त स्वरूपण की आवश्यकता है: उदाहरण [1, 1, 2, 2]के 1 1 2 2लिए सूची के बजाय ।

उदाहरण

एन = 2 मान लें, तो हमारे पास एक प्लेट पर दो पेनकेक्स का ढेर है, जो शीर्ष पर सिरप से शुरू होता है।

यदि सूची है 1 1 2 2, इसका मतलब है कि हम ...

• शीर्ष पैनकेक फ्लिप करें - नीचे पैनकेक के ऊपरी चेहरे को कोटिंग करें
• शीर्ष को फिर से फ्लिप करें - शीर्ष पैनकेक के मूल निचले चेहरे को कोटिंग
• दोनों को पलटें - प्लेट को कोटिंग करें
• दोनों फिर से फ्लिप करें - नीचे पैनकेक के मूल नीचे के चेहरे को कोटिंग करें

चूंकि सभी चार चेहरे लेपित हैं, इसलिए आउटपुट कुछ इस तरह होगा Trueया 1।

यदि सूची है 1 2 2 1, इसका मतलब है कि हम ...

• शीर्ष पैनकेक फ्लिप करें - नीचे पैनकेक के ऊपरी चेहरे को कोटिंग करें
• दोनों पलटें - कुछ भी नहीं कोटिंग
• दोनों को फिर से पलटें - कुछ नहीं कोटिंग
• शीर्ष को फिर से फ्लिप करें - शीर्ष पैनकेक के मूल निचले चेहरे को कोटिंग

चूंकि प्लेट को छूने वाला चेहरा अभी भी सिरप-मुक्त है, इसलिए आउटपुट कुछ इस तरह होगा Falseया 0।

टिप्पणियाँ

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

स्कोरिंग

यह कोड-गोल्फ है। बाइट्स में सबसे छोटा समाधान जीतता है।

Comments

यह एक बहुत, बहुत अच्छी चुनौती है। ;)

— सोहम चौधरी

एक फ़ंक्शन है जो एक सूची प्राप्त करता है और एक बूलियन देता है ठीक है?

— गर्वित हैकेलर

कोई बोनस होना चाहिए अगर कोई इसे इस भाषा में लागू कर सकता है ।

— grc

@grc अब बस के लिए एक इनाम है!

— केल्विन के शौक 4

पैनकेक स्टैक में मेरा समाधान Put syrup on the pancakes!:;)

— रॉडोल्फिटो

Answer 1

CJam, 32 30 29 बाइट्स

q~2@#2b\{)/(W%)1$0=|@]s:~}/:&

इसे ऑनलाइन आज़माएं।

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

$ cjam pancakes.cjam <<< '2 [1 1 2 2]'; echo
1
$ cjam pancakes.cjam <<< '2 [1 2 2 1]'; echo
0

यह काम किस प्रकार करता है

q~                            " N, L := eval(input())                                     ";
  2@#2b                       " P := base(2 ** N, 2)                                      ";
       \{                }/   " for F in L:                                               ";
         )/                   "   P := split(P, F + 1)                                    ";
           (W%)               "   T, U, V := P[1:], reverse(P[0])[:-1], reverse(P[-1])[0] ";
               1$0=|          "   V |= U[0]                                               ";
                    @]s:~     "   P := map(eval, str([U, V, T]))                          ";
                           :& " print and(P)                                              ";

Comments

CJam? CRup की तरह।

— इंगो बर्क

Answer 2

हास्केल, 92 90 86 84 114 110 99 98

एक पूर्ण कार्यक्रम की आवश्यकता बहुत कष्टप्रद है। मुझे आश्चर्य है कि किसी को इसकी आवश्यकता क्यों होगी।

m(n:s)=all(<1)$foldl(\r@(p:s)n->reverse(take n s)++(p*r!!n):drop n s)[0..n]s
main=readLn>>=print.m

यह समाधान पक्षों की सूची द्वारा पेनकेक्स के ढेर का प्रतिनिधित्व करके काम करता है, जब आसन्न पेनकेक्स उसी पक्ष को साझा करते हैं। प्रत्येक पक्ष एक संख्या है, और एक पक्ष लेपित है यदि इसका शून्य मान है।

ऐसे दोड़ो:

*Main> main
[2,1,1,2,2]
True

Comments

पायथन 2 का उपयोग नहीं करने के लिए;)

— केल्विन के शौक

@ केल्विन हॉबीज़ लोल

— गर्वित हेकेलर

मुझे डर है कि एक पूर्ण कार्यक्रम की आवश्यकता है ...

— जॉन ड्वोरक

@JDDvorak मैंने ऐसा नहीं देखा ... मैंने सिर्फ यह पूछा कि क्या कोई फ़ंक्शन प्रश्न की टिप्पणियों में ठीक है। अगर यह नहीं है, तो मैं इसे बदल

— दूंगा

@proudhaskeller अब आपको ओपी द्वारा स्पष्ट रूप से कहा गया है ... मुझे जल्द ही बदलाव की उम्मीद है।

— जॉन ड्वोरक

Answer 3

पायथन, 92 बाइट्स

मुझे लगता है कि यह काम करता है:

s=[1]+[0,0]*input()
for f in input():x=f*2;s[0]=s[x]=s[0]|s[x];s[:x]=s[x-1::-1]
print all(s)

यह याद रखने के लिए पैनकेक चेहरों (शामिल प्लेट) की एक सूची का उपयोग करता है जो सिरप के साथ लेपित हैं। पेनकेक्स सूची के भाग को उलट कर फ़्लिप किया जाता है, लेकिन किसी भी सिरप को पहले शीर्ष चेहरे और नए प्रकट चेहरे के बीच स्थानांतरित किया जाता है।

उपयोग:

$ python pancakes.py
2
1, 1, 2, 2
True

Comments

यह वास्तव में, रिवर्स करने के लिए वास्तव में चतुर तरीका है। +1

— सोहम चौधरी

ऐसा लगता है कि आप "सब कुछ सिरप है" चेक से प्लेट को बाहर कर रहे हैं। क्या आपको जरूरत है? जब सभी पैनकेक चेहरे लेपित होते हैं, तो प्लेट एक सिरप पैनकेक चेहरे को छू रही होगी, इसलिए प्लेट सिरप भी होगी।

— user2357112

@ user2357112 हां, आप सही हैं। धन्यवाद!

— grc

Answer 4

अजगर 2: 75

Grc और feersum के समाधान का एक सरलीकरण।

n,b=input()
s=[1]+[0]*n
for x in b:s[:x+1]=s[x::-1];s[x]|=s[0]
print all(s)

2*n+1पैनकेक किनारों की सिरप स्थिति को संग्रहीत करना अनावश्यक है क्योंकि स्पर्श करने वाले किनारे हमेशा समान होते हैं। इसके बजाय प्रत्येक n+1पैनकेक जंक्शनों की स्थिति को याद करता है । इस तरह, सिरप हस्तांतरण स्वचालित रूप से के लिए जिम्मेदार है।

एकमात्र अपडेट की आवश्यकता xजंक्शन पर सिरप को संरक्षित करने के लिए है जब एक फ्लिप इसे काटता है। यह द्वारा या बाद में फ्लिप-सिरप में 0प्रवेश किया जाता है x।

दो बार इनपुट लेने से वर्ण गणना प्रभावित नहीं होती है।

s=[1]+[0]*input()
for x in input():s[:x+1]=s[x::-1];s[x]|=s[0]
print all(s)

Answer 5

पायथन 2, 93 बाइट्स

सबसे पहले मैं अपना उत्तर पोस्ट करने जा रहा था, लेकिन फिर grc ने एक मिनट पहले ही एक समान पोस्ट किया था। इसलिए मैंने कुछ सुधारों के साथ आने की कोशिश की। केवल एक ही मुझे मिल सकता है एक lexicographic सूची तुलना के बजाय का उपयोग करने के लिए all()।

संपादित करें: विभिन्न इनपुट विधियों का असफल प्रयास करके एक गलती को ठीक किया गया जो वर्ण गणना को नहीं बदलता है।

n,F=input()
L=[1]+2*n*[0]
for f in F:f*=2;L[0]=L[f]=L[0]|L[f];L[:f]=L[~-f::-1]
print[1]*2*n<L

नमूना इनपुट / आउटपुट:

2, [1, 1, 2]

 

False

Answer 6

एपीएल, 77

∧/⊃{x[1]+←⍺⌷x←⍵⋄(⌽⍺↑x),⍺↓x}/(⌽1+⎕),⊂1,⎕⍴0

Answer 7

अजगर 2, 107

d=[1]+[0,0]*input()
for i in input():n=2*i;d[:n]=reversed(d[:n]);d[n]=d[n-1]=d[n]|d[n-1]
print(all(d[:-1]))

Answer 8

हास्केल, 129 125

t(m:l)=all(any(<1).(\i->foldr(\n->foldr($)[].map(n%))[i]l))[0..m]
n%i|i>n=(i:)|i<n=(n-i:)|1>0=(n:).(0:)
main=readLn>>=print.t

शायद पूरी तरह से अभी तक गोल्फ नहीं हुआ है, लेकिन यह लेपित पक्षों की सूची में हेरफेर किए बिना काम करता है। इसके बजाय, यह पीछे की ओर यह पता लगाने के लिए काम करता है कि क्या दिए गए पैनकेक का एक पक्ष कभी भी किसी ऐसी चीज के संपर्क में आया है जो शुरुआत में शीर्ष पक्ष था। foldrप्रभावी रूप से पीछे की ओर फ़्लिप की सूची का पता लगाता है, इसलिए वहाँ नहीं है reverse।

इसलिए यहाँ एल्गोरिथ्म है: हम सभी प्रासंगिक पक्षों पर मैप करते हैं ( [0..m]) और पक्षों की एक सूची बनाते हैं जो हमारा पक्ष प्रत्येक चरण से सिरप को विरासत में प्राप्त करता है, जो पीछे से शुरू होता है: शुरू में सूची बस है [i], लेकिन nपेनकेक्स के एक फ्लिप के साथ , प्रत्येक प्रविष्टि हो जाता है [n-i], तो i<n, [n,0]अगर i==nहै, और [i]यदि i>n। विचाराधीन पक्ष को लेपित किया गया है यदि और केवल यदि परिणामी सूची में सभी फ़्लिप के बाद एक 0( any (<1)) हो। allबाकी काम करता है, और mainएक चल कार्यक्रम में यह सब परिवर्तित करता है।

कार्यक्रम एक नई stdinरेखा [n_pancakes, flip1, flip2, flip3, ...]द्वारा समाप्त के रूप में इसके इनपुट को लेता है ।

Comments

दिलचस्प दृष्टिकोण।

— गर्वित हैकेलर

के बारे में कैसे बजाय उपयोग सूचियों में inherits सूची कोड के लिए फ़ंक्शन का उपयोग, यानी की n%i|i>n=[i]|i<n=[n-i]|0<1=[n,0]और बदले की foldr($)[].map(n%)है (=<<).(%), वह सब inherits नक्शा और उन्हें शामिल हो जाएगा।

— गर्वित हैकेलर

आपने मुझे अहसास कराया कि मैं स्टैक के साथ शुरू कर सकता हूं [0..]और नॉनवेज पैनकेक को कोट करने के बजाय 0 के रूप में एक लेपित पैनकेक का प्रतिनिधित्व कर सकता हूं । धन्यवाद!

— गर्वित हैकेलर