भारी बॉक्स स्टैकिंग

Question

आपके पास भारी बक्से का एक गुच्छा है और आप उन्हें सबसे कम संख्या में ढेर में ढेर करना चाहते हैं। मुद्दा यह है कि आप एक बॉक्स पर अधिक बक्से नहीं रख सकते हैं जितना कि यह समर्थन कर सकता है, इसलिए भारी बक्से को ढेर के नीचे जाना चाहिए।

चुनौती

इनपुट : पूरे किलोग्राम में बक्से के वजन की एक सूची।

आउटपुट : बक्से के ढेर का वर्णन करने वाली सूचियों की एक सूची। यह इनपुट के लिए सबसे कम संभव ढेर का उपयोग करना चाहिए। एक वैध स्टैक होने के लिए, स्टैक में प्रत्येक बॉक्स का वजन उसके ऊपर के सभी बॉक्सों के वजन के योग से अधिक या उसके बराबर होना चाहिए।

मान्य ढेर के उदाहरण

(शीर्ष क्रम से नीचे)

• [3]
• [1 1]
• [३, २, १]
• [४, २, १, १]
• [२ 6, १ 6, ६, ३, १]
• [३३, ३२, १]
• [999, 888, 99, 11, 1]

अमान्य ढेर के उदाहरण

(नीचे से ऊपर तक के क्रम में)

• [१, २]
• [३, ३, ३]
• [५, ५, १]
• [999, 888, 777]
• [४, ३, २]
• [4321, 3000, 1234, 321]

उदाहरण परीक्षण मामले

1

IN: [1, 2, 3, 4, 5, 6, 9, 12]
OUT: [[12, 6, 3, 2, 1], [9, 5, 4]]

2

IN: [87, 432, 9999, 1234, 3030]
OUT: [[9999, 3030, 1234, 432, 87]]

3

IN: [1, 5, 3, 1, 4, 2, 1, 6, 1, 7, 2, 3]
OUT: [[6, 3, 2, 1], [7, 4, 2, 1], [5, 3, 1, 1]]

4

IN: [8, 5, 8, 8, 1, 2]
OUT: [[8, 8], [8, 5, 2, 1]]

नियम और मान्यताएँ

• मानक I / O नियम और प्रतिबंधित खामियां लागू होती हैं
• I / O के लिए किसी भी सुविधाजनक प्रारूप का उपयोग करें
  • जब तक आप संगत हैं तब तक स्टैक को ऊपर से नीचे या नीचे से ऊपर तक वर्णित किया जा सकता है।
  • स्टैक्स का क्रम (उन स्टैक्स के भीतर बक्से के बजाय) कोई फर्क नहीं पड़ता।
  • तुम भी एक निर्धारित सूची के रूप में इनपुट बक्से ले सकते हैं। इनपुट के लिए ऑर्डर विशेष रूप से महत्वपूर्ण नहीं है, इसलिए जब तक कि सामान्य समस्या हल न हो रही हो।
• यदि स्टैक का एक से अधिक इष्टतम कॉन्फ़िगरेशन है, तो आप उनमें से किसी एक को आउटपुट कर सकते हैं
• आप मान सकते हैं कि कम से कम एक बॉक्स है और सभी बक्से का वजन कम से कम 1 किलो है
• आपको कम से कम 9,999 किग्रा तक वजन का समर्थन करना चाहिए।
• आपको कम से कम 9,999 कुल बॉक्स का समर्थन करना चाहिए।
• एक ही वजन वाले बक्से अप्रभेद्य होते हैं, इसलिए यह बताने की कोई आवश्यकता नहीं है कि बॉक्स का उपयोग कहाँ किया गया था।

हैप्पी गोल्फिंग! सौभाग्य!

Comments

क्या हम हल क्रम में तौल सकते हैं? (या तो आरोही या उतरते हुए)

— अर्नुलड

"आपको कम से कम 9,999 कुल बॉक्स का समर्थन करना चाहिए।" यहाँ "समर्थन" की व्याख्या कैसे की जाती है? क्या इसका मतलब यह है कि कार्यक्रम को इनपुट के इतने आकार लेने में सक्षम होना चाहिए, या इसका मतलब यह है कि कार्यक्रम वास्तव में उचित समय में जवाब प्रदान करना चाहिए? यदि यह बाद का है, तो बहुत बड़े परीक्षण मामले उपलब्ध होने चाहिए।

— जोएल

सुझाया गया परीक्षण मामला: [8, 8, 8, 5, 1]->[[8, 8], [8, 5, 1]]

— Hiatsu

या इससे भी बेहतर: [8, 5, 8, 8, 1, 2]->[[8, 8], [8, 5, 2, 1]]

— Hiatsu

@Arnauld, अन्यथा वह एक उत्तर के लिए निर्बाध छँटाई कोड जोड़ देगा, मैं कहने जा रहा हूँ हाँ , आप हल क्रम में इनपुट में ले सकते हैं।

— बीफस्टर

Answer 1

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

Œ!ŒṖ€ẎṖÄ>ḊƲ€¬ȦƊƇLÞḢ

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

स्पष्ट -3 निक कैनेडी के लिए धन्यवाद ...

ऊपर से नीचे।

स्पष्टीकरण:

Œ!ŒṖ€ẎṖÄ>ḊƲ€¬ȦƊƇLÞḢ  Arguments: S (e.g. [1, 2, 3, 4, 5])
Œ!                   Permutations (e.g. [..., [4, 1, 5, 2, 3], ...])
    €                Map link over left argument (e.g. [..., [..., [[4, 1], [5], [2, 3]], ...], ...])
  ŒṖ                  Partitions (e.g. [..., [[4, 1], [5], [2, 3]], ...])
     Ẏ               Concatenate elements (e.g. [..., ..., [[4, 1], [5], [2, 3]], ..., ...])
               Ƈ     Filter by link (e.g. [..., [[1, 3], [2], [4], [5]], ...])
              Ɗ       Create >=3-link monadic chain (e.g. [[1], [], [0]])
           €           Map link over left argument (e.g. [[1], [], [0]])
          Ʋ             Create >=4-link monadic chain (e.g. [1])
      Ṗ                  Remove last element (e.g. [4])
       Ä                 Cumulative sum (e.g. [4])
         Ḋ               [Get original argument] Remove first element (e.g. [1])
        >                Greater than (vectorizes) (e.g. [1])
            ¬          Logical NOT (vectorizes) (e.g. [[0], [], [1]])
             Ȧ         Check if non-empty and not containing zeroes after flattening (e.g. 0)
                 Þ   Sort by link (e.g. [[[1, 2, 3], [4, 5]], ..., [[5], [4], [3], [2], [1]]])
                L     Length (e.g. 4)
                  Ḣ  Pop first element (e.g. [[1, 2, 3], [4, 5]])

Comments

स्पष्टीकरण के साथ कम कॉम्पैक्ट संस्करण में कोई मौका? मैं उन लोगों से एक टन सीखता हूं।

— जॉन कीट्स सेप

@ जॉनकेट्स एक जोड़ा।

— आउटगॉल्फ

Answer 2

जावास्क्रिप्ट (Node.js),  139 122  116 बाइट्स

आरोही क्रम में क्रमबद्ध इनपुट की अपेक्षा करता है।

f=(A,s=[],[n,...a]=A,r)=>n?s.some((b,i,[...c])=>n<eval(b.join`+`)?0:f(A,c,a,c[i]=[n,...b]))?S:r?0:f(A,[...s,[]]):S=s

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

टिप्पणी की गई

f = (                        // f is a recursive function taking:
  A,                         //   A[] = input array
  s = [],                    //   s[] = list of stacks, initially empty
  [n,                        //   n   = next weight to process
      ...a] = A,             //   a[] = array of remaining weights
  r                          //   r   = recursion flag
) =>                         //
  n ?                        // if n is defined:
    s.some((b, i,            //   for each stack b[] at position i in s[],
                  [...c]) => //   using c[] as a copy of s[]:
      n < eval(b.join`+`) ?  //     if n is not heavy enough to support all values in b[]:
        0                    //       abort
      :                      //     else:
        f(                   //       do a recursive call:
          A, c, a,           //         using A[], c[] and a[]
          c[i] = [n, ...b]   //         with n prepended to c[i]
        )                    //       end of recursive call
    ) ?                      //   end of some(); if successful:
      S                      //     return S[]
    :                        //   else:
      r ?                    //     if this is a recursive call:
        0                    //       do nothing
      :                      //     else:
        f(A, [...s, []])     //       try again with an additional stack
  :                          // else:
    S = s                    //   success: save the solution in S[]

Answer 3

पायथन 3.8 (पूर्व-रिलीज़) , 178 बाइट्स

f=lambda b,s=[[]]:(a for i in range(len(s))if b[0]>=sum(s[i])for a in f(b[1:],s[:i]+[[b[0]]+s[i]]+s[i+1:]+[[]]))if b else[s]
g=lambda a:(c:=sorted(f(a),key=len)[0])[:c.index([])]

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

अब सभी संभावित इनपुट पर काम करता है। (यह TIO पर कई बार दस या अधिक बक्से के साथ निकलता है, लेकिन यह एक सही उत्तर की गणना करता है)

Comments

list(reversed(sorted(a)))sorted(a)[::-1]गोल्फ उद्देश्य के लिए के रूप में लिखा जा सकता है ।

— जोएल

आपको लगता है कि मुझे पता होगा कि अब तक, खासकर जब से मैं इतना अधिक अनुक्रमण करता हूं। धन्यवाद।

— Hiatsu

एक पक्ष की टिप्पणी के रूप में, यदि गोल्फिंग के लिए नहीं तो sorted(a, reverse=True)इसके बजाय बेहतर लिखना होगा।

— जोएल