Giới thiệu

Cuối cùng công ty điện ảnh đang tài trợ cho bộ phim của bạn. Họ đã cho bạn một ngân sách tối đa và họ cũng đặt thời gian chạy bộ phim của bạn.

Bây giờ bạn có thể bắt đầu với tiền sản xuất. Bạn có một loạt các cảnh đã được lên kế hoạch, nhưng không phải tất cả chúng đều phù hợp với ngân sách và bộ phim cũng sẽ kéo dài quá lâu. Tuy nhiên, bạn biết tầm quan trọng của từng cảnh. Mục tiêu của bạn là chọn các cảnh, rằng bộ phim sẽ không quá đắt, quá dài và tầm thường.

Đầu vào

Bạn nhận được running timevà budgetcác studio đã phê duyệt:

[25, 10]

Bạn có danh sách các cảnh trong đó running time, costsvà importancecho mỗi người trong số họ:

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

Nếu mảng không hoạt động cho bạn, hãy chọn một định dạng đầu vào phù hợp nhất với bạn. Thời gian là trong vài phút. Ngân sách và chi phí tính bằng hàng triệu đồng tiền ngẫu nhiên. Điều quan trọng là một phạm vi từ [1–9]. Tất cả các số là số nguyên.

Đầu ra

Xuất ra danh sách các cảnh sẽ được đưa vào phim trong vấn đề:

• Tổng của importancelà tối đa.
• Các chi phí không vượt quá ngân sách.
• Độ dài nằm trong phạm vi ± 5 phút của thời gian chạy được phê duyệt.

Thứ tự của các cảnh là không quan trọng và không cần phải được bảo tồn.

Bạn có thể xuất ra một danh sách các số hoặc một mảng. Đầu ra của bạn có thể có chỉ số dựa trên một hoặc một:

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

Có thể, nhiều giải pháp áp dụng cho bất kỳ đầu vào nào. Bạn chỉ cần tìm một.

Những ràng buộc

• Cảnh không thể rút ngắn cũng không thể rẻ hơn.
• Mỗi cảnh chỉ có thể được bao gồm một lần.

Yêu cầu

• Chương trình của bạn phải kết thúc trong thời gian thực tế của bộ phim.
• Đầu vào được chấp nhận từ STDIN, đối số dòng lệnh, dưới dạng tham số hàm hoặc từ tương đương gần nhất.
• Bạn có thể viết một chương trình hoặc một chức năng. Nếu đó là một hàm ẩn danh, vui lòng bao gồm một ví dụ về cách gọi nó.
• Đây là mã golf để câu trả lời ngắn nhất trong byte thắng.
• Sơ hở tiêu chuẩn là không được phép.

Phim

Bộ phim đầu tiên của bạn là một bộ phim tài liệu về một thị trấn nhỏ ở Đức có tên Knapsack ¹ . Thành phố này đã được tái định cư do những hạn chế về môi trường trong những năm 70:

Movie: [25, 10]

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

Giải pháp khả thi với thời gian hoạt động 22, ngân sách 10và tầm quan trọng của 20:

0, 1, 4

Dự án tiếp theo của bạn là một tập của Fargo :

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

Giải pháp khả thi với thời gian hoạt động 40, ngân sách 24và tầm quan trọng của 31:

0, 1, 2, 3, 4

Cuối cùng, đây là những cảnh cho một bộ phim mà " M. McConaughey du hành đến một thiên hà xa xôi chỉ để biết rằng Matt Damon đã đến đó trước. ":

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

Giải pháp khả thi với thời gian hoạt động 169, ngân sách 165và tầm quan trọng của 133:

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

_{¹ Bất kỳ sự tương đồng giữa vấn đề của thách thức và địa phương thực tế là hoàn toàn ngẫu nhiên.}

MATLAB, 100 byte

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

Vấn đề Tối ưu hóa nhị phân được giải quyết thông qua chức năng bintprog , có sẵn trong Matlab2013b; chức năng này đã được thay thế bởi intlinprog trong các phiên bản Matlab mới hơn.

Đầu vào là một vectơ (m), cho các ràng buộc phim và ma trận (s) cho các cảnh. Cụ thể m là một vectơ hàng hai yếu tố [running_time ngân sách], trong khi s là ma trận Nx3, trong đó N là số lượng cảnh và mỗi hàng được tạo thành từ [mức độ quan trọng của chi phí chạy].

Python 3, 211 197 byte

Giải pháp này bắt buộc mọi sự kết hợp của các cảnh bắt đầu từ sự kết hợp của tất cả các cảnh cho đến kết hợp chỉ một cảnh, sau đó chọn kết hợp các cảnh có tầm quan trọng tối đa. Brute-buộc đã được sử dụng vì chi phí trong thời gian không phải là đặc biệt lớn, mặc dù nó chắc chắn là theo cấp số nhân. Đầu ra là không có chỉ mục.

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)

Haskell, 125 byte

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

Ví dụ sử dụng: (25,10) & [(5,2,4),(5,5,7),(7,1,3),(8,5,3),(12,3,9)]-> [0,1,4].

Làm thế nào nó hoạt động:

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],[]]

Tìm thấy thủ thuật sau đó một lúc trước trong câu trả lời của @xnor. Nó ngắn hơn subsequenceyêu cầu import Data.List.

Ruby, 172 166 165 byte

Tôi thực sự nên bắt đầu kiểm tra xem các phiên bản Ruby của câu trả lời Python của tôi có phải là golfer hay không trước khi đăng các câu trả lời Python đó. Ở mức độ nào, đây là cách tiếp cận vũ phu để tối ưu hóa như trước đây. Bất kỳ lời khuyên nào về việc chơi golf đều được chào đón, bao gồm cả những mẹo liên quan đến một số kỹ thuật tối ưu hóa thực tế.

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

Ung dung:

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