परिचय

अंत में फिल्म कंपनी आपकी फिल्म का वित्तपोषण कर रही है। उन्होंने आपको अधिकतम बजट दिया है और उन्होंने आपकी फिल्म का समय भी निर्धारित किया है।

अब आप प्री-प्रोडक्शन से शुरुआत कर सकते हैं। आपके पास पहले से योजनाबद्ध दृश्यों का एक समूह है, लेकिन उनमें से सभी बजट में फिट नहीं होंगे और फिल्म को बहुत लंबा रास्ता तय करना होगा। हालाँकि आप जानते हैं कि प्रत्येक दृश्य का महत्व क्या है। आप का लक्ष्य दृश्यों को चुनना है, कि फिल्म बहुत महंगी, बहुत लंबी और औसत दर्जे की नहीं है।

इनपुट

आपको मिल जाता है running timeऔर budgetस्टूडियो ने मंजूरी दे दी है:

[25, 10]

आपके पास दृश्यों की सूची है running time, costsऔर importanceउनमें से प्रत्येक के लिए:

[ [5, 2, 4], [7, 1, 3] ]

यदि सरणियाँ आपके लिए काम नहीं कर रही हैं, तो एक और इनपुट प्रारूप चुनें जो आपके लिए सबसे उपयुक्त हो। टाइम्स मिनटों में हैं। बजट और लागत लाखों यादृच्छिक मुद्रा में हैं। महत्व एक सीमा से है [1–9]। सभी संख्या पूर्णांक हैं।

उत्पादन

इस मामले में फिल्म में शामिल किए जाने वाले दृश्यों की सूची को आउटपुट करें:

का योग importanceअधिकतम होता है।
लागत बजट से अधिक नहीं है।
लंबाई अनुमोदित चल रहे समय के ± 5 मिनट की सीमा के भीतर है।

दृश्यों का क्रम महत्वहीन है और इसे संरक्षित करने की आवश्यकता नहीं है।

आप संख्या या एक सरणी की सूची आउटपुट कर सकते हैं। आपके आउटपुट में एक शून्य या एक-आधारित सूचकांक हो सकता है:

[0,2,5] – 0, 2, 5 – 0 2 5
[1,3,6] – 1, 3, 6 – 1 3 6

यह संभव हो सकता है, कि किसी भी इनपुट पर कई समाधान लागू होते हैं। आपको केवल एक खोजने की जरूरत है।

प्रतिबन्ध

दृश्यों को छोटा नहीं किया जा सकता है और न ही वे सस्ते हो सकते हैं।
प्रत्येक दृश्य को केवल एक बार शामिल किया जा सकता है।

आवश्यकताएँ

आपका कार्यक्रम फिल्म की वास्तविक लंबाई के समय में समाप्त होना चाहिए।
इनपुट को STDINकमांड लाइन तर्क से, फ़ंक्शन पैरामीटर के रूप में या निकटतम समकक्ष से स्वीकार किया जाता है।
आप एक कार्यक्रम या एक समारोह लिख सकते हैं। यदि यह एक अनाम फ़ंक्शन है, तो कृपया इसे कैसे लागू करें, इसका एक उदाहरण शामिल करें।
यह कोड-गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
मानक खामियों को अस्वीकार कर दिया जाता है।

चलचित्र

आपकी पहली फिल्म जर्मनी में एक छोटे से शहर के बारे में एक वृत्तचित्र है जिसे नैकपैक ¹ कहा जाता है । 70 के दशक में पर्यावरण संबंधी बाधाओं के कारण इस शहर को फिर से बसाया गया:

Movie: [25, 10]

Scenes: [
    [5,  2, 4],
    [5,  5, 7],
    [7,  1, 3],
    [8,  5, 3],
    [12, 3, 9],
]

रनिंग टाइम 22, बजट 10और इसके महत्व के साथ संभावित समाधान 20:

0, 1, 4

आपका अगला प्रोजेक्ट फ़ार्गो का एक एपिसोड है :

Movie: [45, 25]

Scenes: [
    [2,  1, 1],
    [8,  5, 9],
    [10, 6, 8],
    [10, 3, 6],
    [10, 9, 7],
    [11, 4, 3],
    [19, 5, 6],
]

रनिंग टाइम 40, बजट 24और इसके महत्व के साथ संभावित समाधान 31:

0, 1, 2, 3, 4

अंत में यहां एक फिल्म के दृश्य हैं जहां " एम। मैककोनाघी दूर की आकाशगंगा की यात्रा करते हैं ताकि यह पता लगाया जा सके कि मैट डेमन पहले वहां पहुंचे थे। "

Movie: [169, 165]

Scenes: [
    [5,  8,  2],
    [5,  20, 6],
    [6,  5,  8],
    [6,  10, 3],
    [7,  6,  5],
    [7,  9,  4],
    [7,  8,  9],
    [7,  9,  5],
    [8,  6,  8],    
    [8,  8,  8],
    [8,  5,  6],
    [9,  5,  6],
    [9,  8,  5],
    [9,  4,  6],
    [9,  6,  9],
    [9,  8,  6],
    [9,  7,  8],
    [10, 22, 4],
    [10, 12, 9],
    [11, 7,  9],
    [11, 9,  8],
    [12, 11, 5],
    [15, 21, 7],
]

रनिंग टाइम 169, बजट 165और इसके महत्व के साथ संभावित समाधान 133:

1, 2, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 19, 20, 21, 22

_{¹ चुनौती की समस्या और वास्तविक स्थानों के बीच कोई समानता पूरी तरह से संयोग है।}

code-golf optimization

— insertusernamehere
स्रोत

4

MATLAB, 100 बाइट्स

function X=o(m,s) 
X=find(bintprog(-1*s(:,3),[s(:,2)';s(:,1)';-1*s(:,1)'],[m(2);m(1)+5;5-m(1)])==1);

बाइनरी ऑप्टिमाइजेशन समस्या को मैटलैब2013 बी में उपलब्ध बिंटप्रोग फ़ंक्शन के माध्यम से हल किया जाता है ; इस फ़ंक्शन को नए Matlab संस्करणों में intlinprog द्वारा प्रतिस्थापित किया गया था ।

इनपुट्स एक वेक्टर (एम), मूवी की कमी के लिए, और एक मैट्रिक्स (एस), दृश्यों के लिए हैं। विशेष रूप से मीटर एक दो-तत्व पंक्ति वेक्टर [रनिंग_टाइम बजट] है, जबकि एस एक एनएक्स 3 मैट्रिक्स है, जहां एन दृश्यों की संख्या है और प्रत्येक पंक्ति [रनिंग_टाइम लागत महत्व] से बनी है।

— PieCot
स्रोत

2

पायथन 3, 211 197 बाइट्स

यह सॉल्यूशन सभी दृश्यों के संयोजन से शुरू होने वाले दृश्यों के हर संयोजन को एक ही दृश्य के संयोजन तक ले जाता है, फिर उन दृश्यों के संयोजन का चयन करता है जिनका अधिकतम महत्व है। ब्रूट-फोर्सिंग का उपयोग किया गया था क्योंकि समय में लागत विशेष रूप से महान नहीं थी, हालांकि यह निश्चित रूप से घातीय है। आउटपुट शून्य-अनुक्रमित है।

from itertools import*
def m(t,b,s):l=len(s);r=range(l);f=lambda y,k:sum(s[q][k]for q in y);return max([j for i in r for j in combinations(r,l-i)if t-6<f(j,0)<t+6and f(j,1)<=b],key=lambda n:f(n,2))

Ungolfing:

import itertools
def movie_scenes(time, budget, scenes):
    length = len(s)
    r = range(length)
    f = lambda film_list, index: sum(scenes[q][index]for q in film_list)
    importance = 0
    possible_films = []
    for num_scenes in r:
        for film in itertools.combinations(r, num_scenes):
            run_time = f(film, 0)
            cost = f(film, 1)
            if time-6 < run_time < time+6 and cost <= budget:
                possible_films.append(film)
    return max(possible_films, key = lambda film: f(film, 2)

— Sherlock9
स्रोत

एक के साथ आने वाले पहले व्यक्ति होने के लिए धन्यवाद - वास्तव में दो भी - बिल्ट-इन का उपयोग नहीं करने और प्रश्न पर कुछ ध्यान आकर्षित करने के लिए।

— इन्सर्टसर्नमेयर

@insertusernamehere आपका स्वागत है :)

— शर्लक

1

हास्केल, 125 बाइट्स

(m,n)&s=snd$maximum[(sum i,q)|q<-filter(>=0)<$>mapM(:[-1])[0..length s-1],(t,b,i)<-[unzip3$map(s!!)q],sum b<=n,abs(sum t-m)<6]

प्रयोग उदाहरण: (25,10) & [(5,2,4),(5,5,7),(7,1,3),(8,5,3),(12,3,9)]-> [0,1,4]।

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

let m be the running time
    n    the budget
    s    the list of scenes


    q<-filter ... s-1]                         -- loop q through the list of
                                               -- subsequences of the indices of s
                                               -- (0 based) -- details see below
                          map(s!!)q            -- extract the elements for the
                                               -- given indices                   
                    unzip3                     -- turn the list of triples
                                               -- into a triple of lists
          (t,b,i)<-[               ]           -- bind t, b and i to the lists
                                    sum b<=n   -- keep q if the sum of budgets <= n
                              abs(sum t-m)<6   -- and the time is within range
  (sum i,q)                                    -- for all leftover q make a pair
                                               -- (overall importance, q)
sum$maximum                                    -- find the maximum and drop
                                               -- overall importance


subsequence building:

                   [0..length s-1]         -- for all indices i of s
            (:[-1])                        -- make a list [i,-1]
        mapM                               -- and make the cartesian product
                                           -- e.g. [0,1] -> [[0,-1],[1,-1]] ->
                                           -- [[0,1],[0,-1],[-1,1],[-1,-1]]
filter(>=0)<$>                             -- drop all -1
                                           -- -> [[0,1],[0],[1],[]]

@Xnor के उत्तर में थोड़ी देर पहले अनुवर्ती चाल मिली । यह subsequenceआवश्यकता से कम है import Data.List।

— nimi
स्रोत

1

रूबी, 172 166 165 बाइट्स

मुझे वास्तव में जाँचना शुरू कर देना चाहिए कि क्या उन पायथन उत्तरों को पोस्ट करने से पहले मेरे पायथन उत्तरों के रूबी संस्करण गोल्फर हैं। किसी भी दर पर, यह पहले की तरह अनुकूलन के लिए एक ही जानवर-बल दृष्टिकोण है। गोल्फिंग के किसी भी सुझाव का स्वागत है, जिसमें कुछ वास्तविक अनुकूलन तकनीकें शामिल हैं।

->t,b,s{l=s.size;r=[*0...l];f=->y,k{y.reduce(0){|z,q|z+s[q][k]}};v=[];r.map{|i|r.combination(l-i).map{|j|v<<j if(t-5..t+5)===f[j,0]&&f[j,1]<=b}};v.max_by{|n|f[n,2]}}

Ungolfed:

def movie(time, budget, scenes)
  len = scenes.size
  range = [*0...len]
  f = -> y,k {y.reduce(0) {|z,q| z + s[q][k]}}
  potential_films = []
  range.map do |i|
    range.combination(len-i).map do |j|
    # len - i because range being combined must be 0..(len-1) as these are indices
    # but the number of elements in the combinations must be 1..len 
      if (time-5..time+5).include?(f[j,0]) && f[j,1] <= budget
        potential_films << j
      end
    end
  end
  return potential_films.max_by{|n|f[n,2]}
end