ভূমিকা

অবশেষে মুভি সংস্থাটি আপনার চলচ্চিত্রকে অর্থায়ন করছে। তারা আপনাকে সর্বোচ্চ বাজেট দিয়েছে এবং তারা আপনার চলচ্চিত্রের চলমান সময়ও নির্ধারণ করে।

এখন আপনি প্রাক-উত্পাদন দিয়ে শুরু করতে পারেন। আপনার কাছে ইতিমধ্যে পরিকল্পনা করা বেশ কয়েকটি দৃশ্য রয়েছে তবে এগুলির সবগুলিই বাজেটের সাথে খাপ খায় না এবং ফিল্মটি দীর্ঘ সময়ও পাবে। আপনি তবে প্রতিটি দৃশ্যের গুরুত্ব জানেন। আপনার লক্ষ্য হল দৃশ্যগুলি বেছে নেওয়া, যে সিনেমাটি খুব ব্যয়বহুল, খুব দীর্ঘ এবং মধ্যম হবে না।

ইনপুট

আপনি পাবেন 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

ম্যাটল্যাব, 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);

বাইনারি অপ্টিমাইজেশান সমস্যাটি মাতলাব ২০১৩ বি এ উপলব্ধ বিন্টপ্রোগ ফাংশনের মাধ্যমে সমাধান করা হয়েছে; এই ফাংশনটি নতুন মতলব সংস্করণগুলিতে ইনটলিনগ্রোগ দ্বারা প্রতিস্থাপিত হয়েছিল ।

ইনপুটগুলি সিনেমার সীমাবদ্ধতার জন্য ভেক্টর (মি) এবং দৃশ্যের জন্য একটি ম্যাট্রিক্স (গুলি)। বিশেষত মি একটি দ্বি-উপাদান সারি ভেক্টর [চলমান_কালীন বাজেট], যখন এস এনএক্স 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 বাইট

আমার পাইথন উত্তরগুলির রুবি সংস্করণগুলি পাইথন উত্তরগুলি পোস্ট করার আগে গল্ফিয়র কিনা তা আমার সত্যিই পরীক্ষা করা শুরু করা উচিত। যে কোনও হারে, এটি আগের মতো অপ্টিমাইজেশনের জন্য একই রকম বর্বর শক্তি পদ্ধতির। গল্ফিং সম্পর্কিত কোনও টিপস স্বাগত, যার মধ্যে কিছু আসল অপ্টিমাইজেশন কৌশল জড়িত including

->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