अन-मर्ज ए लिस्ट

Question

परिचय

आप में से अधिकांश संख्याओं की सूची को सॉर्ट करने के लिए मर्ज सॉर्ट एल्गोरिथ्म से परिचित हैं । एल्गोरिथ्म के हिस्से के रूप में, एक सहायक फ़ंक्शन लिखता है जिसे mergeदो सॉर्ट की गई सूचियों को एक सॉर्ट की गई सूची में संयोजित किया जाता है। पायथन-जैसे स्यूडोकोड में, फ़ंक्शन आमतौर पर कुछ इस तरह दिखता है:

function merge(A, B):
  C = []
  while A is not empty or B is not empty:
    if A is empty:
      C.append(B.pop())
    else if B is empty or A[0] ≤ B[0]:
      C.append(A.pop())
    else:
      C.append(B.pop())
  return C

विचार के पहले तत्व के छोटे पॉपिंग रखना है Aऔर Bजब तक दोनों सूचियों खाली हैं, और में परिणामों को एकत्र C। यदि Aऔर Bदोनों को क्रमबद्ध किया जाता है, तो ऐसा है C।

इसके विपरीत, यदि Cएक क्रमबद्ध सूची है, और हम किसी भी दो subsequences में इसे विभाजित Aऔर Bफिर, Aऔर Bभी हल कर रहे हैं और merge(A, B) == C। दिलचस्प है, यह जरूरी नहीं कि अगर Cछँटा नहीं है, जो हमें इस चुनौती के लिए लाता है।

इनपुट

आपका इनपुट सूची के रूप में दिए गए कुछ के लिए पहले 2*nनॉनजेटिव पूर्णांकों का क्रमपरिवर्तन है ।[0, 1, 2, ..., 2*n-1]n > 0C

उत्पादन

यदि आपकी सूची में दो सूची Aऔर Bलंबाई nजैसे कि C == merge(A, B), और एक मिथ्या मूल्य मौजूद है, तो आपका आउटपुट एक सत्य मान होगा । चूंकि इनपुट में कोई डुप्लिकेट नहीं है, इसलिए आपको चिंता करने की ज़रूरत नहीं है कि mergeफ़ंक्शन में संबंध कैसे टूटे हैं ।

नियम और बोनस

आप एक फ़ंक्शन या पूर्ण प्रोग्राम लिख सकते हैं। सबसे कम बाइट गिनती जीतता है, और मानक खामियों को रोक दिया जाता है।

ध्यान दें कि आपको सूचियों की गणना करने की आवश्यकता नहीं है Aऔर B"हां" उदाहरणों में। हालाँकि, यदि आप वास्तव में सूचियों का उत्पादन करते हैं, तो आपको -20% का बोनस मिलता है । इस बोनस का दावा करने के लिए, आपको केवल एक जोड़ी सूचियों को आउटपुट करना होगा, सभी संभावनाओं को नहीं। दृढ़ता से टाइप की गई भाषाओं में दावा करने के लिए इस बोनस को आसान बनाने के लिए, इसे "नहीं" उदाहरणों में खाली सूचियों की एक जोड़ी का उत्पादन करने की अनुमति है।

ब्रूट फोर्सिंग की मनाही नहीं है, लेकिन पिछले चार टेस्ट मामलों में से सभी की कुल संख्या में गणना करने के लिए -10% बोनस है ।

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

केवल एक संभावित आउटपुट "हां" उदाहरणों में दिया गया है।

[1,0] -> False
[0,1] -> [0] [1]
[3,2,1,0] -> False
[0,3,2,1] -> False
[0,1,2,3] -> [0,1] [2,3]
[1,4,0,3,2,5] -> False
[4,2,0,5,1,3] -> [4,2,0] [5,1,3]
[3,4,1,2,5,0] -> [4,1,2] [3,5,0]
[6,2,9,3,0,7,5,1,8,4] -> False
[5,7,2,9,6,8,3,4,1,0] -> False
[5,6,0,7,8,1,3,9,2,4] -> [6,0,8,1,3] [5,7,9,2,4]
[5,3,7,0,2,9,1,6,4,8] -> [5,3,7,0,2] [9,1,6,4,8]
[0,6,4,8,7,5,2,3,9,1] -> [8,7,5,2,3] [0,6,4,9,1]
[9,6,10,15,12,13,1,3,8,19,0,16,5,7,17,2,4,11,18,14] -> False
[14,8,12,0,5,4,16,9,17,7,11,1,2,10,18,19,13,15,6,3] -> False
[4,11,5,6,9,14,17,1,3,15,10,12,7,8,0,18,19,2,13,16] -> [4,17,1,3,15,10,12,7,8,0] [11,5,6,9,14,18,19,2,13,16]
[9,4,2,14,7,13,1,16,12,11,3,8,6,15,17,19,0,10,18,5] -> [9,4,2,16,12,11,3,8,6,15] [14,7,13,1,17,19,0,10,18,5]

Answer 1

पायथ, 39 * 0.9 * 0.8 = 28.08

#aY->QxQeS-QsY&YsY)KfqylTlQmsdty_Y%tlKK

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

Input:  [5,3,7,0,2,9,1,6,4,8]
Output: ([9, 1, 6, 4, 8], [5, 3, 7, 0, 2])
Input:  [5,7,2,9,6,8,3,4,1,0]
Output: [] (falsy value)

आप इसे ऑनलाइन परीक्षण कर सकते हैं , लेकिन यह ऑफ़लाइन संस्करण की तुलना में थोड़ा धीमा हो सकता है। ऑफ़लाइन संस्करण मेरे लैपटॉप पर <0.15 सेकंड में परीक्षण मामलों में से प्रत्येक को हल करता है।

संभवतः (एक) पहली बार, एक पायथ समाधान सक्रिय रूप से अपवादों का उपयोग करता है (यह कम से कम 1 चार बचाया)। यह पीटर टेलर के समाधान के समान विचार का उपयोग करता है।

                         preinitialisations: Q = input(), Y = []
#                 )     while 1: (infinite loop)
        eS-QsY             finds the biggest, not previous used, number
      xQ                   finds the index
    >Q                     all elements from ... to end
   -          &YsY         but remove all used elements
 aY                        append the resulting list to Y

When all numbers are used, finding the biggest number fails, 
throws an exception and the while loop ends.  
This converts [5,3,7,0,2,9,1,6,4,8] to [[9, 1, 6, 4, 8], [7, 0, 2], [5, 3]]

        msdty_Y  combine the lists each for every possible subset of Y (except the empty subset)
 fqylTlQ         and filter them for lists T with 2*len(T) == len(Q)
K                and store them in K

%tlKK        print K[::len(K)-1] (prints first and last if K, else empty list)

पायथ, 30 * 0.9 = 27.0

मैंने वास्तव में परिणामी सूचियों को छापे बिना इसे हल करने की कोशिश नहीं की है। लेकिन यहां ऊपर दिए गए कोड के आधार पर एक त्वरित समाधान है।

#aY->QxQeS-QsY&YsY)fqylsTlQtyY

मैंने मूल रूप से केवल प्रिंट स्टेटमेंट ही निकाला था। हालांकि आउटपुट काफी बदसूरत है।

Input:  [0,1,2,3]
Output: [[[3], [2]], [[3], [1]], [[2], [1]], [[3], [0]], [[2], [0]], [[1], [0]]] (truthy value)
Input:  [5,7,2,9,6,8,3,4,1,0]
Output: [] (falsy value)

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

Comments

आपको लग सकता है कि (K[0], Q-K[0])प्रिंट करने के बजाय आप प्रिंट कर सकते हैं (K[0], K[-1])। मैं नहीं जानता कि क्या यह एक बचत देगा, हालांकि।

— पीटर टेलर

@PeterTaylor धन्यवाद, 2 वर्ण सहेजे गए

— जकुबे

@PeterTaylor और यहां तक ​​कि 2 और चार्ट, अगर मैं प्रिंट करता हूं K[::len(K)-1]।

— जकुबे

Answer 2

गोल्फस्क्रिप्ट (35 * 0.9 = 31.5)

{.$-1>/~,)\.}do;]1,\{{1$+}+%}/)2/&,

ऑनलाइन डेमो काफी धीमी है: अपने कंप्यूटर पर, यह 0.04 सेकंड से कम समय में परीक्षण के सभी चलाता है, तो मैं 10% कमी का दावा।

व्याख्या

C का प्रत्यय जो C में सबसे बड़ी संख्या से शुरू होता है, उसी सूची से आना चाहिए। फिर इस तर्क को (सी - प्रत्यय) पर लागू किया जा सकता है, ताकि समस्या कम हो जाए।

Answer 3

एपीएल, 62 50 44 * 90% = 39.6

{(l÷2)⌷↑(⊢∨⌽)/(2-/(1,⍨⍵≥⌈\⍵)/⍳l+1),⊂l=⍳l←⍴⍵}

इसे यहाँ आज़माएँ।