"काम खत्म करो" जितना जल्दी हो सके

Question

पृष्ठभूमि

एक पल के लिए कल्पना करें कि आपके पास दिमाग सुन्न करने वाला उबाऊ काम है। हर सुबह, आपको उन कार्यों का एक संग्रह दिया जाता है, जिन्हें आपको उस दिन काम करना चाहिए। प्रत्येक कार्य की एक निश्चित अवधि होती है, और एक बार शुरू होने के बाद, इसे एक बार में पूरा किया जाना चाहिए। आपका बॉस सुस्ती को बर्दाश्त नहीं करेगा, इसलिए यदि ऐसे कार्य हैं जिन्हें आप घर जाने से पहले भी पूरा कर सकते हैं, तो आपको उनमें से एक पर काम करना होगा (आप कौन सा चुन सकते हैं)। इसके विपरीत, यदि शेष सभी कार्यों के लिए आपको ओवरटाइम काम करने की आवश्यकता होती है, तो आप जल्दी घर जा सकते हैं! इस प्रकार आपका लक्ष्य चतुर शेड्यूलिंग द्वारा आपके कार्यदिवस की लंबाई को कम करना है।

मजेदार तथ्य: यह आलसी नौकरशाही की समयबद्धता समस्या का एक प्रकार है , और यह एनपी-हार्ड ( स्रोत ) है।

इनपुट

आपके पास दो इनपुट हैं: आपके कार्यदिवस (एक सकारात्मक पूर्णांक L) में "समय इकाइयों" की संख्या , और कार्यों का संग्रह (सकारात्मक पूर्णांक का एक गैर-खाली सरणी T, कार्य अवधि का प्रतिनिधित्व)। उन्हें किसी भी क्रम में, और किसी भी उचित प्रारूप में लिया जा सकता है। सरणी में Tअवधि से अधिक कार्य हो सकते हैं L, लेकिन इसमें कम से कम एक कार्य को अधिकतम अवधि के साथ करने की गारंटी है L।

उत्पादन

एक वैध शेड्यूलS ⊆ T ऐसे कार्यों का एक सबसेट है sum(S) ≤ L, और हर कार्य जिसमें S(गिनती गुणा नहीं) की अवधि सख्ती से अधिक है L - sum(S)। आपका आउटपुट एक मान्य शेड्यूल का सबसे छोटा संभव योग होगा। दूसरे शब्दों में, आप आज काम करने वाली कम से कम संख्या इकाइयों का उत्पादन करेंगे।

उदाहरण

इनपुट पर विचार करें

L = 9
T = [3,4,4,4,2,5]

अपने दिन को शेड्यूल करने का एक तरीका यह है [4,4]: आप 8 समय इकाइयों में दो कार्य समाप्त करते हैं , और 1 इकाई शेष है। चूंकि कोई 1-यूनिट कार्य उपलब्ध नहीं है, आप घर जा सकते हैं। हालाँकि, शेड्यूल [2,5]और भी बेहतर है: आप 7 समय इकाइयों के लिए काम करते हैं, और फिर शेष सभी कार्यों में 3 या अधिक समय इकाइयाँ लगेंगी। शेड्यूल [2,4]मान्य नहीं है, क्योंकि 6 समय इकाइयों के लिए काम करने के बाद, आपके पास 3-यूनिट कार्य को पूरा करने के लिए पर्याप्त समय होगा। 7 इकाइयां इष्टतम हैं, इसलिए सही आउटपुट है 7।

नियम और स्कोरिंग

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

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

ये प्रारूप में दिए गए हैं L T -> output।

 1 [1,2] -> 1
 6 [4,1] -> 5
 7 [7,7,9] -> 7
 9 [3,4,4,4,2,5] -> 7
20 [6,2,3,12,7,31] -> 17
42 [7,7,7,7,8,8,8] -> 36
42 [7,7,7,7,7,8,8,8] -> 35
42 [7,7,7,7,7,7,8,8,8] -> 36
16 [1,2,3,4,5,6,7,8,9,10] -> 13
37 [15,27,4,1,19,16,20,26,29,18] -> 23
22 [24,20,8,8,29,16,5,5,16,18,4,9] -> 18
80 [10,22,11,2,28,20,27,6,24,9,10,6,27,2,15,29,27] -> 71
59 [26,28,5,4,7,23,5,1,9,3,7,15,4,23,7,19,16,25,26] -> 52

Answer 1

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

³œ-;⁴Ṃ;¹S>⁴
ŒPÇÐfS€Ṃ

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

टीआईओ अपने 60 सेकंड समय सीमा के भीतर अंतिम परीक्षण मामलों को समाप्त करने के लिए पर्याप्त तेज़ है, भले ही बस मुश्किल से।

पृष्ठभूमि

एल्गोरिथ्म सरल और अक्षम दोनों है:

1. हम टी के सभी सबसेट उत्पन्न करते हैं, गुणाओं की गिनती करते हैं।

2. हम उन सबसेटों को रखते हुए, उन सबसेटों को फ़िल्टर करते हैं, जो S को निम्न मानदंडों में से एक से संतुष्ट करते हैं:

   • S , T से अलग है और S के तत्वों का योग और S में नहीं न्यूनतम तत्व L से बड़ा है ।

   • एस और टी समान हैं।

   फ़िल्टर्ड T (चलो इसे T ' कहते हैं) में अब कार्य की सभी सूचियाँ शामिल हैं जो केवल पर्याप्त कार्य (या कुछ ओवरटाइम) करती हैं।

3. सभी S में T ' , सबसे कम राशि वाले को चुनें।

यह काम किस प्रकार करता है

ŒPÇÐfS€Ṃ     Main link. Left input: T (list). Right input: L (integer).

ŒP           Powerset; generate all subsets of T.
   Ðf        Filter them...
  Ç            applying the helper link.
     S€      Compute the sum of each kept subset.
       Ṃ     Take the minimum.

³œ-;⁴Ṃ;¹S>⁴  Helper link. Input: A (subset of T)

³œ-          Multiset subtraction; remove the elements of A from T, counting
             multiplicities.
   ;⁴        Append L to the resulting list.
     Ṃ       Take the minimum.
             If S == T, the difference was empty and the minimum is L.
      ;¹     Prepend the minimum to A.
        S    Compute the sum.
         >⁴  Compare it with L.
             If S == T, the comparison will return 1.

Answer 2

पायथ, 26 25 बाइट्स

JEhSsMf&gJsT>hS.-QT-JsTyQ

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

मैं पिछले दो परीक्षण मामलों को चलाने में सक्षम नहीं था (वे ऑनलाइन समय निकालते हैं, मुझे लगता है), लेकिन अन्य सभी काम करते हैं। यह सिर्फ एक बुनियादी जानवर बल समाधान है।

Answer 3

रूबी, 124 बाइट्स

->(m,s){
f=proc{|l,t|t.reject!{|x|x>l}
(0...(t.size)).map{|x|
f.call(l-t[x],t[0,x]+t[(x+1)..-1])
}.max||l
}
m-f.call(m,s)
}

यह एक ब्रूट-बल समाधान है।

Answer 4

MATL , 36 बाइट्स

iTFinZ^!"2G@2#)sXKt1G>~wb+lG>A*?KhX<

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

i           % input number L
TF          % array [true, false]
in          % input array T. Get its length
Z^!         % Cartesian power and transpose. Each column is a selection from T
"           % for each selection
  2G@2#)    %   take non-selected and then selected tasks
  sXK       %   sum of selected tasks. Copy to clipboard K
  t1G>~     %   duplicate. Is sum of selected tasks <= L?
  wb        %   swap, rotate
  +         %   sum of selected tasks plus each non-selected task
  lG>A      %   are all of those numbers greater than L?
  *         %   are both conditions met?
  ?         %   if so
    Kh      %     paste current minimum (or initially L), append new value
    X<      %     compute new minimum
            %   end if implicitly
            % end for each implicitly
            % display stack implicitly