소개

마지막으로 영화 회사에서 영화에 자금을 지원합니다. 그들은 당신에게 최대 예산을 주었고 또한 영화의 실행 시간을 설정합니다.

이제 사전 제작부터 시작할 수 있습니다. 이미 많은 장면이 계획되어 있지만 모든 장면이 예산에 맞지는 않고 영화도 너무 길어질 것입니다. 그러나 각 장면의 중요성을 알고 있습니다. 목표는 장면을 선택하는 것입니다. 영화가 너무 비싸고 길고 평범하지는 않습니다.

입력

당신은 얻을 running time과 budget스튜디오는 승인했습니다 :

[25, 10]

당신은 다음과 같은 장면의 목록을 가지고 running time, costs그리고 importance그들 각각에 대해 :

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

배열이 작동하지 않으면 가장 적합한 다른 입력 형식을 선택하십시오. 시간은 분입니다. 예산과 비용은 수백만 개의 임의 통화로 표시됩니다. 의 범위는 ~ [1–9]입니다. 모든 숫자는 정수입니다.

산출

영화에 포함 할 장면 목록을 다음과 같이 출력합니다.

• 합 importance이 최대화됩니다.
• 비용은 예산을 초과하지 않습니다.
• 길이는 승인 된 작동 시간의 ± 5 분 범위 내에 있습니다.

장면의 순서는 중요하지 않으며 보존 할 필요가 없습니다.

숫자 목록이나 배열을 출력 할 수 있습니다. 출력은 0 또는 1 기반 인덱스를 가질 수 있습니다.

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

주어진 입력에 여러 솔루션이 적용될 수 있습니다. 하나만 찾으면됩니다.

제약

• 장면을 단축하거나 저렴하게 만들 수 없습니다.
• 각 장면은 한 번만 포함 할 수 있습니다.

요구 사항

• 프로그램은 영화의 실제 길이 시간에 완료되어야합니다.
• STDIN명령 줄 인수에서 함수 매개 변수로 또는 가장 유사한 항목에서 입력을 승인 합니다.
• 프로그램이나 함수를 작성할 수 있습니다. 익명 함수 인 경우 호출 방법의 예를 포함하십시오.
• 이것은 코드 골프 이므로 바이트 단위의 최단 답변이 승리합니다.
• 표준 허점은 허용되지 않습니다.

영화 산업

첫 번째 영화는 Knapsack ¹ 이라는 독일의 작은 마을에 관한 다큐멘터리 입니다. 이 도시는 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

마지막으로 " M. McConaughey가 먼 은하계를 여행하여 Matt Damon이 먼저 도착했다는 것을 발견 한 영화의 장면입니다 . ":

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

이진 최적화 문제는 Matlab2013b 에서 사용 가능한 bintprog 함수를 통해 해결됩니다 . 이 기능은 최신 Matlab 버전에서 intlinprog 로 대체되었습니다 .

입력은 동영상 제약 조건의 경우 벡터 (m)이고 장면의 경우 행렬입니다. 특히 m은 2 요소 행 벡터 [running_time budget]이고, s는 Nx3 행렬입니다. 여기서 N은 장면 수이고 각 행은 [running_time cost important]로 구성됩니다.

파이썬 3, 211 197 바이트

이 솔루션은 모든 장면의 조합에서 시작하여 하나의 장면 조합까지 모든 장면 조합을 무차별 적용한 다음 가장 중요한 장면 조합을 선택합니다. 시간에 따른 비용은 그리 크지 않았지만 무차별 대입법이 사용 되었음은 확실하지만 기하 급수적입니다. 출력은 인덱스가 0입니다.

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

풀기 :

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)

하스켈, 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 바이트

파이썬 답변을 게시하기 전에 파이썬 답변의 루비 버전이 골퍼인지 확인해야합니다. 여하튼, 이것은 이전과 같은 최적화에 대한 무차별 대입 방식입니다. 실제 최적화 기술과 관련된 팁을 포함하여 골프에 대한 모든 팁을 환영합니다.

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

언 골프 드 :

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