Вступление

Наконец, кинокомпания финансирует ваш фильм. Они дали вам максимальный бюджет, а также задают время показа вашего фильма.

Теперь вы можете начать с предварительного производства. У вас уже есть несколько запланированных сцен, но не все они вписываются в бюджет, и фильм будет слишком длинным. Однако вы знаете важность каждой сцены. Ваша цель - выбрать сцены, чтобы фильм не был слишком дорогим, слишком длинным и посредственным.

вход

Вы получаете, 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

_{¹ Любое сходство между проблемой вызова и фактическим языком совершенно случайно.}

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

Проблема двоичной оптимизации решается с помощью функции bintprog , доступной в Matlab2013b; эта функция была заменена на intlinprog в более новых версиях Matlab.

Входные данные - это вектор (m) для ограничений фильма и матрица (ы) для сцен. В частности, m представляет собой вектор строки из двух элементов [running_time budget], в то время как s представляет собой матрицу Nx3, где N - это количество сцен, и каждая строка состоит из [running_time затрат Важно].

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

Haskell, 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.

Рубин, 172 166 165 байтов

Я действительно должен начать проверять, являются ли версии Ruby моих ответов на Python более подходящими, прежде чем публиковать эти ответы на Python. В любом случае, это тот же самый метод грубой силы, что и раньше. Любые советы по игре в гольф приветствуются, в том числе те, которые связаны с некоторыми актуальными методами оптимизации.

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