एक सूची को चिकना करना

Question

आपको एक प्रोग्राम या फ़ंक्शन लिखना चाहिए जो एक गैर-नकारात्मक पूर्णांक kऔर एक सॉर्ट किए गए पूर्णांक सूची Lको इनपुट और आउटपुट के रूप में लेता है या एक चिकनी सूची देता है M।

Mसूची को क्रमबद्ध रखते हुए Lअधिकांश kपूर्णांक तत्वों को सम्मिलित करके आरोही सूची से बनाया जाता है। सम्मिलित किए गए पूर्णांकों को इस तरह से चुना जाना चाहिए कि Mजितना संभव हो उतना कम होगा। हम इस छोटे से मूल्य को "चिकनाई" कहेंगे।

सूची के आगे के अंतर -1 3 8 11 15हैं 4 5 3 4और अधिकतम आगे का अंतर है 5।

साथ 2सम्मिलन की चिकनाई 2 10 15है 4और एक संभावित उत्पादन होता है 2 6 10 11 15आगे अंतर के साथ 4 4 1 4।

इनपुट

• एक गैर-नकारात्मक पूर्णांक k।
• Lकम से कम 2 तत्वों के साथ एक आरोही पूर्णांक सूची ।

उत्पादन

• आरोही पूर्णांक सूची M।
• यदि कई सही उत्तर मौजूद हैं, तो उनमें से एक बिल्कुल ठीक है (कोई भी पर्याप्त है)।
• आपके समाधान को मेरे कंप्यूटर पर एक मिनट के तहत किसी भी उदाहरण के परीक्षण के मामले को हल करना है (मैं केवल करीबी मामलों का परीक्षण करूंगा। मेरे पास एक नीचे-औसत पीसी है।)।

उदाहरण

कोष्ठक में इनपुट ( k; L) => एक संभावित आउटपुट और अधिकतम फॉरवर्ड अंतर (जो आउटपुट का हिस्सा नहीं है)

0, 10 20 => 10 20 (10)

2, 1 10 => 1 4 7 10 (3)

2, 2 10 15 => 2 6 10 11 15 (4)

3, 2 10 15 => 2 5 8 10 12 15 (3)

5, 1 21 46 => 1 8 15 21 27 33 39 46 (7)

5, 10 20 25 33 => 10 14 18 20 24 25 29 33 (4)

3, 4 4 6 9 11 11 15 16 25 28 36 37 51 61 => 4 4 6 9 11 11 15 16 22 25 28 36 37 45 51 59 61 (8)

15, 156 888 2015 => 156 269 382 495 608 721 834 888 1001 1114 1227 1340 1453 1566 1679 1792 1905 2015 (113)

8, -399 -35 -13 56 157 => -399 -347 -295 -243 -191 -139 -87 -35 -13 39 56 108 157 (52)

5, 3 3 3 => 3 3 3 3 (0)

यह कोड-गोल्फ है इसलिए सबसे छोटी प्रविष्टि जीतती है।

Answer 1

पायथ, 28 27 बाइट्स

S+Qu?smt%hHrFdC,QtQ>GvzGhvz

जैसा इनपुट दिया गया है:

3
[2, 10, 15]

प्रदर्शन। दोहन ​​परीक्षण।

नोट: जिस समय यह प्रश्न पूछा गया था, उस समय rFdअंदर उपयोग करने से संबंधित पाइथ में एक छोटा सा बग था u, जिसे मैंने अभी ठीक किया। बग ने इसे Fअंदर उपयोग करना असंभव बना दिया u, जो निश्चित रूप से इरादा नहीं था।

S+Qu?smt%hHrFdC,QtQ>GvzGhvz

                               Implicit:
                               z is the number of insertions, in string form.
                               Q is the input list.
              C,QtQ            Pairs of elements, e.g. [(2, 10), (10, 15)]
           rFd                 d = (a, b) -> range(a, b)
        %hH                    Take every H+1th element of that range
       t                       And throw out the first one.
      m                        Perform this process for each element pair
     s                         And combine the results into one list.

                               The above is a minimal set of additional elements
                               To reduce the maximal difference to H+1.

  u                     hvz    Repeat until the result stops changing, where
                               the prior result is G, H starts at 0 and
                               increases by 1 each repetition, and
                               G is initialized to eval(z)+1.
   ?               >GvzG       If not G[eval(z):], return G. In other words,
                               if the prior result was short enough, stop.
                               Also, this is always false on the initial call.
    smt%hHrFdC,QtQ             Otherwise, recalculate with H incremented.
S+Q                            Take the result, add the original list, and sort.

---

यहां एक संस्करण है जो उस समय दुभाषिया के साथ काम करेगा, जब सवाल पूछा गया था। यह 28 बाइट्स है, और बिल्कुल उसी तरह काम करता है:

S+Qu?smt%hHr.udC,QtQ>GvzGhvz

प्रदर्शन।

उपयुक्त संस्करण के लिए प्रतिबद्ध, f6b40e62

Comments

मैंने कभी भी rF<seq>दो-तत्व टुपल्स को अनपैक करने के लिए उपयोग करने के बारे में नहीं सोचा था ।

— orlp

@orlp यह एक शानदार ट्रिक है, और मैंने इसे दिन में वापस इस्तेमाल किया है जब uअलग तरीके से काम किया और eमौजूद नहीं था, urGHdकी तुलना में कम था rhd@d1। मैं इसे पायथ ट्रिक्स पेज पर डालूँगा।

— isaacg

आप एक चरित्र को काट सकते हैं, आपको इसकी आवश्यकता नहीं है U।

— orlp

@orlp धन्यवाद असल में, yvzविफल रहता है जब vz = 0, लेकिन hvzचाल है।

— isaacg

चूंकि कोड Pyth संस्करण के साथ काम नहीं करेगा जो कि उस समय उपलब्ध था जब सवाल पूछा गया था कि मैंने इस समाधान को स्वीकार नहीं करने का विकल्प चुना है। यदि आप एक उत्तर देते हैं जो बगफिक्स पर भरोसा नहीं करता है, तो मुझे पिंग करें और मैं इसे स्वीकार करूंगा।

— यादृच्छिक

Answer 2

अजगर 2, 104

def f(L,k,d=1):
 M=[];p=L[0]
 for x in L:M+=range(p+d,x,d);p=x
 return M[k:]and f(L,k,d+1)or sorted(L+M)

अलग-अलग अधिकतम वेतन वृद्धि की कोशिश करता है d, जो 1 से शुरू होता है और गिनती करता है। अंतराल में (p,x)हर d'वें नंबर पर ले जाकर क्रमिक तत्वों की प्रत्येक जोड़ी के अंतराल में भरता है । यदि Mकोटा अनुमति से अधिक लंबा है, तो उच्चतर प्रयास करने के लिए पुनरावृत्ति करता है d। अन्यथा, क्रमबद्ध और जोड़े गए मूल तत्वों की सूची देता है।

यह मेरी मशीन पर देरी के बिना सभी परीक्षण मामलों करता है।

Comments

क्या आपने 1, 1000000000 जैसी कोई कोशिश की?

— edc65

@ edc65 जो इस एल्गोरिथम को वास्तव में, वास्तव में लंबा लेगा, लेकिन मैं इससे पहले स्टैक डेप्थ तरीके से चलाता हूं।

— xnor