ভারী বক্স স্ট্যাকিং

27

আপনার কাছে প্রচুর ভারী বাক্স রয়েছে এবং আপনি এগুলি কয়েকটি সংখ্যক স্ট্যাকের মধ্যে স্ট্যাক করতে চান। সমস্যাটি হ'ল আপনি কোনও বাক্সকে সমর্থন করার চেয়ে বেশি বাক্স স্ট্যাক করতে পারবেন না, তাই ভারী বাক্সগুলি অবশ্যই একটি স্ট্যাকের নীচে যেতে হবে।

চ্যালেঞ্জ

ইনপুট : পুরো কেজি বাক্সের ওজনের একটি তালিকা।

আউটপুট : বাক্সের স্ট্যাকগুলি বর্ণনা করে এমন তালিকার একটি তালিকা। এটি অবশ্যই ইনপুটটির জন্য সম্ভাব্য কয়েকটি সংখ্যক স্ট্যাক ব্যবহার করবে। একটি বৈধ স্ট্যাক হতে, স্ট্যাকের প্রতিটি বাক্সের ওজন তার উপরের সমস্ত বাক্সের ওজনের যোগফলের চেয়ে বড় বা সমান হতে হবে।

বৈধ স্ট্যাকের উদাহরণ

(নীচে থেকে শীর্ষে অর্ডার)

  • [3]
  • [১, ১]
  • [3, 2, 1]
  • [৪, ২, ১, ১]
  • [২ 27, ১,,,, ৩, ১]
  • [৩৩, ৩২, ১]
  • [999, 888, 99, 11, 1]

অবৈধ স্ট্যাকের উদাহরণ

(নীচ থেকে উপরের ক্রমে)

  • [১, ২]
  • [3, 3, 3]
  • [৫, ৫, ১]
  • [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 এর জন্য যে কোনও সুবিধাজনক বিন্যাস ব্যবহার করুন
    • স্ট্যাকগুলি নীচে থেকে নীচে বা নীচে থেকে উপরে বর্ণিত হতে পারে যতক্ষণ আপনি সামঞ্জস্যপূর্ণ হন।
    • স্ট্যাকের ক্রমটি (st স্ট্যাকগুলির মধ্যে বাক্সের চেয়ে) কিছু যায় আসে না।
    • আপনি একটি প্রস্তাবিত তালিকা হিসাবে ইনপুট বাক্সগুলি নিতে পারেন। অর্ডার ইনপুটটির জন্য বিশেষভাবে গুরুত্বপূর্ণ নয়, যতক্ষণ না সাধারণ সমস্যা বাছাইয়ের দ্বারা নিজেই সমাধান করা হচ্ছে না।
  • যদি স্ট্যাকগুলির একাধিক অনুকূল কনফিগারেশন থাকে তবে আপনি সেগুলির কোনওটিকে আউটপুট করতে পারেন
  • আপনি ধরে নিতে পারেন যে এখানে কমপক্ষে একটি বাক্স রয়েছে এবং সমস্ত বাক্সের ওজন কমপক্ষে 1 কেজি
  • আপনাকে অবশ্যই সর্বনিম্ন 9,999 কেজি পর্যন্ত ওজন সমর্থন করতে হবে।
  • আপনাকে সর্বনিম্ন 9,999 টি মোট বাক্স সমর্থন করতে হবে।
  • একই ওজনযুক্ত বাক্সগুলি পৃথক পৃথক, তাই কোন বাক্সটি কোথায় ব্যবহৃত হয়েছিল তা উল্লেখ করার দরকার নেই।

শুভ গল্ফিং! শুভকামনা!

code-golf  optimization 
— Beefster
সূত্র
2
আমরা কি বাছাই করে ওজন নিতে পারি? (হয় আরোহী বা সাজানো)
— Arnauld
4
"আপনাকে সর্বনিম্ন মোট 9,999 টি বাক্স সমর্থন করতে হবে।" "সমর্থন" এখানে কীভাবে ব্যাখ্যা করা হয়? এর অর্থ কি এই যে প্রোগ্রামটি এমন আকারের ইনপুট নিতে সক্ষম হবে বা এর অর্থ কি এই প্রোগ্রামটি আসলে যুক্তিসঙ্গত সময়ে উত্তর সরবরাহ করতে হবে? যদি এটি পরবর্তী হয়, তবে আরও অনেক বড় পরীক্ষার কেস সরবরাহ করা উচিত।
— জোয়েল
1
প্রস্তাবিত পরীক্ষার কেস: [8, 8, 8, 5, 1]->[[8, 8], [8, 5, 1]]
— হিয়াটসু
3
বা আরও ভাল: [8, 5, 8, 8, 1, 2]->[[8, 8], [8, 5, 2, 1]]
— হায়াতসু
2
@ আর্নল্ড, যেহেতু অন্যথায় এটি উত্তরে বর্ণা .্য বাছাইকরণ কোড যুক্ত করবে, আমি হ্যাঁ বলব , আপনি সাজানো ক্রমে ইনপুটগুলি নিতে পারেন।
— গরুর মাংস

উত্তর:

5

জেলি , 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]])
— এরিক দ্য আউটগল্ফার
সূত্র
ব্যাখ্যা সহ কম কমপ্যাক্ট সংস্করণে কোনও সুযোগ? আমি তাদের কাছ থেকে একটি টন শিখছি।
— জন কেটস
1
পছন্দ করেছেন
— এরিক আউটগল্ফার
5

জাভাস্ক্রিপ্ট (নোড.জেএস),  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[]
— Arnauld
সূত্র
2

পাইথন 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([])]

এটি অনলাইন চেষ্টা করুন!

এখন সমস্ত সম্ভাব্য ইনপুটগুলিতে কাজ করে। (এটি দশ বা ততোধিক বাক্সের সাহায্যে টিআইওতে বেরিয়ে আসে তবে এটি একটি সঠিক উত্তর গণনা করে)

— Hiatsu
সূত্র
2
list(reversed(sorted(a)))sorted(a)[::-1]গল্ফিং উদ্দেশ্যে হিসাবে লেখা যেতে পারে ।
— জোয়েল
আপনি ভাববেন যে আমি এতক্ষণে জানব, বিশেষত যেহেতু আমি আরও অনেক ইনডেক্সিং করি। ধন্যবাদ।
— হিয়াটসু
ঠিক পাশের মন্তব্য হিসাবে, গল্ফিংয়ের জন্য না হলে এটির sorted(a, reverse=True)পরিবর্তে আরও ভাল লেখা ।
— জোয়েল
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.