एक सरणी खींचो

Question

पहले मैंने एक सरणी को कुचलने की प्रक्रिया को परिभाषित किया

एक क्रश में हमने दायें से बायें सरणी को पढ़ा। अगर एक बिंदु पर हम एक ही तत्व में से दो का सामना करते हैं तो हम पहले एक को हटाते हैं और दूसरे को दोगुना करते हैं।

उदाहरण के लिए यहाँ निम्नलिखित सरणी को कुचलने की प्रक्रिया है

[5,2,2,4]
 ^
[5,2,2,4]
   ^
[5,2,2,4]
     ^
[5,4,4]
   ^
[5,4,4]
     ^
[5,8]
   ^

ध्यान दें कि एक ही तत्व कई बार ढह सकता है। उदाहरण में एक ही पास में 2,2,4ढह गया था 8।

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

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

यह कोड-गोल्फ है इसलिए उत्तर बाइट्स में मापा जाने वाले उनके स्रोत के आकार के साथ कम बाइट्स के साथ बेहतर होंगे।

इससे पहले कि आप अपना जवाब देना शुरू करें, मैं सिर्फ यह कहना चाहता हूं कि यह चुनौती जितना लगता है उससे कहीं अधिक कठिन है। अपने अंतर्ज्ञान को जांचें जैसे ही आप जाते हैं और सुनिश्चित करते हैं कि आपका उत्तर सभी परीक्षण मामलों को पास करता है।

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

[] -> []
[5] -> [5]
[6] -> [3,3]
[8] -> [1,1,1,1,1,1,1,1]
[4,8] -> [1,1,1,1,1,1,1,1,1,1,2]
[2,8] -> [1, 1, 1, 1, 2, 1, 1, 1, 1]
[4,4] -> [1,1,1,1,1,1,1,1]

Comments

क्षमा करें, लेकिन मैं अभी भी नियम को नहीं समझ सकता। के बजाय [1,1,1,1,1,1,1,1,1,1,2]उत्पादन क्यों ? इस होना चाहिए , , , , , , , , , ? [4, 8][8, 4][1,>1,1,1,1,1,1,1,1,1,2][2,1,>1,1,1,1,1,1,1,2][2,>2,1,1,1,1,1,1,2][4,1,>1,1,1,1,1,2][4,2,1,>1,1,1,2][4,2,>2,1,1,2][4,>4,1,1,2][8,1,>1,2][8,2,>2][8,4]

— tsh

@tsh मुझे लगता है कि आपके काम करने के तरीके में गलत धारणा है। यहाँ पथ यह पहली पास ले जाता है: [1,>1,1,1,1,1,1,1,1,1,2], [2,>1,1,1,1,1,1,1,1,2], [2,1,>1,1,1,1,1,1,1,2], [2,2,>1,1,1,1,1,1,2], [2,2,1,>1,1,1,1,1,2], [2,2,2,>1,1,1,1,2], [2,2,2,1,>1,1,1,2], [2,2,2,2,>1,1,2], [2,2,2,2,1,>1,2], [2,2,2,2,2,>2], [2,2,2,2,4>], दूसरा पास: [2,>2,2,2,4], [4,>2,2,4], [4,2,>2,4], [4,4,>4], [4,8>]। उम्मीद है कि इसे साफ करता है। यदि आप पिछले प्रश्न को देखने के लिए कुछ कोड चाहते हैं, तो जवाब है कि क्रशिंग फ़ंक्शन को लागू करें।

— तदर्थ गार्फ हंटर

क्या यह ठीक है अगर मैं संख्याओं को आउटपुट करता हूं, प्रत्येक को एक नई रेखा से अलग किया जाता है?

— स्कॉट

@scottinet यह एक सूची को आउटपुट करने का एक उचित तरीका है। आगे बढ़ें।

— तदर्थ गार्फ हंटर

परीक्षण के मामले [4, 4]को हटा दिया जाना चाहिए, क्योंकि हम उस सरणी को एक खिंचाव => क्रश अनुक्रम के बाद कभी नहीं प्राप्त कर सकते हैं, क्योंकि यह समाप्त हो जाएगा[8]

— स्काउटनेट

Answer 1

जावास्क्रिप्ट (Node.js) , 237 221 213 186 बाइट्स

f=a=>a.map(b=>{for(i=1;~b%2;b/=2)i*=2;return Array(i).fill(b)}).reduce((t,c,i,s)=>{b=c.slice();if(i)r=2*s[--i].length,b.length>=r&&b[0]==s[i][0]?b[r-2]+=b.pop():b;return t.concat(b)},[])

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

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

उदाहरण के लिए:

[1, 1, 1, 1, 1, 1]देता है [4,2]एक बार कुचल दिया, लेकिन [1, 1, 1, 1, 2]में परिणाम[2, 4]

चुनौती यह निर्धारित करने के लिए है कि वास्तव में एक क्रश अवरोधक कहाँ रखा जाना चाहिए ताकि परिणामस्वरूप सरणी को कुचलने से सही परिणाम मिले:

• क्रश ब्लॉकर को केवल तभी रखा जाना चाहिए जब पिछली खिंची गई संख्या वर्तमान के बराबर हो, और यदि वर्तमान में फैला हुआ क्रम पिछले वाले की तुलना में अधिक होता है। उदाहरण के लिए, [2, 4]एक क्रश अवरोधक की आवश्यकता है (बढ़ाया संख्या है 1, बार-बार, और [1, 1]की तुलना में कम है [1,1,1,1]), लेकिन [4, 2]और [2, 6]एक की आवश्यकता नहीं है
• अगर हम nपिछले फैलाए गए अनुक्रम को कहते हैं, और यदि ऊपर की स्थिति सत्यापित है, तो वर्तमान अनुक्रम अनुक्रम की पुनरावृत्ति है n। पिछली संख्या के क्रश अनुक्रम को बाधित करने के लिए, हमें क्रैक ब्लॉकर nको वर्तमान संख्या के दूसरे अनुक्रम के अंत में फैलाने के लिए रखना होगा । उदाहरण: [2, 8] => [(1, 1)=n, (1, 1) + (2) + (1, 1) + ...]या[4, 8] => [(1, 1, 1, 1)=n, (1, 1, 1, 1) + (1, 1, 2) + ...]

Answer 2

जेली , 42 बाइट्स

ṪḤ,⁼?⁹⁸;µ/Ḋ$¹L’$?ÐĿċ³
ṗЀ⁸ẎS⁼¥Ðfµ€ŒpẎ€ÇÐfṪ

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

पूरा कार्यक्रम। बेहद अक्षम, लेकिन काम करता है।

Answer 3

पायथन 2 , 230 228 226 बाइट्स

इनपुट के रूप में एक ही राशि के साथ सभी संभावित सूचियों को पुनरावृत्त करके काम करता है। उन लोगों को निकालना जो सबसे लंबे समय तक एक का चयन करते हुए, कुछ कुचल राज्य में इनपुट सरणी के बराबर नहीं होते हैं।

ifमुख्य फ़ंक्शन को हटाकर -2 बाइट्स संपादित करें

संपादित करें: -2 अनावश्यक स्क्वायर ब्रैकेट को हटाकर बाइट्स

lambda x:max((c(z[:],x),len(z),z)for z in b(sum(x)))[2]
def c(x,y):
 i=e=1
 while x[i:]:
	if x[~-i]==x[i]:del x[i];i-=1;x[i]*=2;e=2
	i+=1
 return x==y or~-e and c(x,y)
b=lambda s:[z+[-~i]for i in range(s)for z in b(s+~i)]+[[]]

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

व्याख्या

मुख्य फ़ंक्शन, सभी संभावित समाधान खोजने और सबसे लंबे समय तक चयन करने के लिए जिम्मेदार है

lambda x:max((c(z[:],x),len(z),z)for z in b(sum(x)))[2]

क्रश फ़ंक्शन, यह जांचता है कि क्या y क्रशों में से एक के बराबर है।

def c(x,y):
 i=e=1
 while x[i:]:
	if x[~-i]==x[i]:del x[i];i-=1;x[i]*=2;e=2
	i+=1
 return x==y or~-e and c(x,y)

दिए गए योग के साथ सभी संभावित क्रम उत्पन्न करें

b=lambda s:[z+[-~i]for i in range(s)for z in b(s+~i)]+[[]]

Answer 4

05AB1E , 41 37 बाइट्स

vy[DÉ#2÷]DYQX©NoDU‹&sDV¸X∍sić·®·Íǝ}»,

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

मेरे जावास्क्रिप्ट समाधान का पोर्ट।

स्पष्टीकरण:

vy                   for each member of the list
[DÉ#2÷]              divide by 2 until odd: stack = stretched value, N = iterations
DYQ                  stetched value equal to the previous one?
X©NoDU‹              previous size < current one? (+store the new size in X)
&                    AND on the 2 previous tests
sDV¸X∍s              build a list of the new stretched value repeated X times
                      (+store the new stetched value in Y)
ić·®·Íǝ}             if the previous tests are true:
                       reduce the result list size by 1
                       multiply by 2 the number at the crush block position
»,                   join by newline + print the list