Einführung

Schließlich finanziert die Filmfirma Ihren Film. Sie haben Ihnen ein maximales Budget gegeben und sie legen auch die Laufzeit Ihres Films fest.

Jetzt können Sie mit der Vorproduktion beginnen. Sie haben bereits eine Reihe von Szenen geplant, aber nicht alle passen in das Budget und der Film würde auch viel zu lange dauern. Sie kennen jedoch die Wichtigkeit jeder Szene. Ihr Ziel ist es, Szenen auszuwählen, damit der Film nicht zu teuer, zu lang und mittelmäßig wird.

Eingang

Du bekommst das running timeund das hat budgetdas Studio genehmigt:

[25, 10]

Sie haben die Liste der Szenen einschließlich running time, costsund die importancefür jeden von ihnen:

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

Wenn Arrays bei Ihnen nicht funktionieren, wählen Sie ein anderes Eingabeformat, das am besten zu Ihnen passt. Zeiten sind in Minuten. Budget und Kosten werden in Millionen zufälliger Währung angegeben. Die Wichtigkeit liegt in einem Bereich von [1–9]. Alle Zahlen sind ganze Zahlen.

Ausgabe

Geben Sie die Liste der Szenen aus, die in den Film aufgenommen werden sollen, wenn:

• Die Summe von importancewird maximiert.
• Die Kosten überschreiten nicht das Budget.
• Die Länge liegt innerhalb eines Bereichs von ± 5 Minuten von der genehmigten Laufzeit.

Die Reihenfolge der Szenen ist unwichtig und muss nicht beibehalten werden.

Sie können eine Liste von Zahlen oder ein Array ausgeben. Ihre Ausgabe kann einen auf Null oder Eins basierenden Index haben:

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

Es ist möglich, dass mehrere Lösungen für eine bestimmte Eingabe gelten. Sie müssen nur einen finden.

Einschränkungen

• Szenen können nicht gekürzt oder billiger werden.
• Jede Szene kann nur einmal enthalten sein.

Bedarf

• Ihr Programm muss zum Zeitpunkt der tatsächlichen Länge des Films beendet sein.
• Eingaben werden von STDINBefehlszeilenargumenten als Funktionsparameter oder von der nächstgelegenen Entsprechung akzeptiert .
• Sie können ein Programm oder eine Funktion schreiben. Wenn es sich um eine anonyme Funktion handelt, geben Sie bitte ein Beispiel für den Aufruf an.
• Dies ist Code-Golf, also gewinnt die kürzeste Antwort in Bytes.
• Standardlücken sind nicht zulässig.

Filme

Ihr erster Film ist eine Dokumentation über eine kleine Stadt in Deutschland namens Knapsack ¹ . Diese Stadt wurde in den 70er Jahren aus Umweltschutzgründen umgesiedelt:

Movie: [25, 10]

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

Mögliche Lösung mit Laufzeit 22, Budget 10und einer Bedeutung von 20:

0, 1, 4

Dein nächstes Projekt ist eine Folge von 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],
]

Mögliche Lösung mit Laufzeit 40, Budget 24und einer Bedeutung von 31:

0, 1, 2, 3, 4

Zum Schluss hier die Szenen für einen Film, in dem " M. McConaughey zu einer fernen Galaxie reist, um herauszufinden, dass Matt Damon zuerst dort angekommen ist ":

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

Mögliche Lösung mit Laufzeit 169, Budget 165und einer Bedeutung von 133:

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

_{¹ Jegliche Ähnlichkeit zwischen dem Problem der Herausforderung und den tatsächlichen Schauplätzen ist völlig zufällig.}

MATLAB, 100 Bytes

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

Das Problem der binären Optimierung wird durch die in Matlab2013b verfügbare Funktion bintprog gelöst. Diese Funktion wurde in neueren Matlab-Versionen durch intlinprog ersetzt .

Eingaben sind ein Vektor (m) für Filmeinschränkungen und eine Matrix (Matrixen) für die Szenen. Insbesondere ist m ein Zeilenvektor mit zwei Elementen [running_time budget], während s eine Nx3-Matrix ist, wobei N die Anzahl der Szenen ist und jede Zeile aus [running_time costs important] besteht.

Python 3, 211 197 Bytes

Diese Lösung zwingt jede Kombination von Szenen, angefangen von Kombinationen aller Szenen bis hinunter zu Kombinationen nur einer Szene, und wählt dann die Kombination von Szenen aus, die die größte Bedeutung hat. Brute-Forcing wurde eingesetzt, da der Zeitaufwand nicht besonders hoch war, obwohl er definitiv exponentiell ist. Die Ausgabe ist nullindexiert.

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 Bytes

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

Anwendungsbeispiel: (25,10) & [(5,2,4),(5,5,7),(7,1,3),(8,5,3),(12,3,9)]-> [0,1,4].

Wie es funktioniert:

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

Ich habe den Subsequenztrick vor einiger Zeit in einer Antwort von @xnor gefunden. Es ist kürzer als subsequencenötig import Data.List.

Ruby, 172 166 165 Bytes

Ich sollte wirklich prüfen, ob die Ruby-Versionen meiner Python-Antworten besser sind, bevor ich diese Python-Antworten veröffentliche. In jedem Fall ist dies derselbe brachiale Optimierungsansatz wie zuvor. Alle Tipps zum Golfen sind willkommen, einschließlich solcher, die einige aktuelle Optimierungstechniken beinhalten.

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