pengantar

Akhirnya perusahaan film membiayai film Anda. Mereka telah memberi Anda anggaran maksimum dan mereka juga mengatur waktu tayang film Anda.

Sekarang Anda bisa mulai dengan pra-produksi. Anda memiliki banyak adegan yang sudah direncanakan, tetapi tidak semuanya sesuai dengan anggaran dan filmnya akan terlalu lama. Namun Anda tahu pentingnya setiap adegan. Tujuan Anda adalah memilih adegan, bahwa filmnya tidak akan terlalu mahal, terlalu lama dan biasa-biasa saja.

Memasukkan

Anda mendapatkan running timedan budgetstudio telah menyetujui:

[25, 10]

Anda memiliki daftar adegan termasuk running time, costsdan importanceuntuk masing-masing:

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

Jika array tidak bekerja untuk Anda, pilih format input lain yang paling sesuai dengan Anda. Waktu dalam hitungan menit. Anggaran dan biaya dalam jutaan mata uang acak. Yang penting adalah rentang dari [1–9]. Semua angka adalah bilangan bulat.

Keluaran

Keluarkan daftar adegan yang akan dimasukkan ke dalam film dalam hal:

• Jumlah importancedimaksimalkan.
• Biaya tidak melebihi anggaran.
• Panjangnya berada dalam kisaran ± 5 menit dari waktu berjalan yang disetujui.

Urutan adegan tidak penting dan tidak perlu dipertahankan.

Anda dapat menampilkan daftar angka atau array. Output Anda dapat memiliki indeks berbasis nol atau satu:

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

Dimungkinkan, beberapa solusi berlaku untuk input yang diberikan. Anda hanya perlu menemukannya.

Kendala

• Adegan tidak bisa dipersingkat juga tidak bisa lebih murah.
• Setiap adegan hanya dapat dimasukkan satu kali.

Persyaratan

• Program Anda harus selesai tepat pada saat durasi film sebenarnya.
• Input diterima dari STDIN, argumen baris perintah, sebagai parameter fungsi atau dari padanan terdekat.
• Anda dapat menulis suatu program atau fungsi. Jika ini adalah fungsi anonim, harap sertakan contoh cara memintanya.
• Ini adalah kode-golf sehingga jawaban terpendek dalam byte menang.
• Celah standar tidak diijinkan.

Film

Film pertama Anda adalah film dokumenter tentang kota kecil di Jerman bernama Knapsack ¹ . Kota ini dimukimkan kembali karena kendala lingkungan di tahun 70-an:

Movie: [25, 10]

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

Kemungkinan solusi dengan waktu berjalan 22, anggaran, 10dan pentingnya 20:

0, 1, 4

Proyek Anda berikutnya adalah episode 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],
]

Kemungkinan solusi dengan waktu berjalan 40, anggaran, 24dan pentingnya 31:

0, 1, 2, 3, 4

Akhirnya, inilah adegan untuk sebuah film di mana " M. McConaughey bepergian ke galaksi yang jauh hanya untuk mengetahui bahwa Matt Damon yang pertama kali ke sana. ":

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

Kemungkinan solusi dengan waktu berjalan 169, anggaran, 165dan pentingnya 133:

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

_{¹ Kemiripan antara masalah tantangan dan lokal sebenarnya sepenuhnya kebetulan.}

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

Masalah Binary Optimization diselesaikan melalui fungsi bintprog , tersedia di Matlab2013b; fungsi ini digantikan oleh intlinprog di versi Matlab yang lebih baru.

Input adalah vektor (m), untuk kendala film, dan matriks untuk adegan. Secara khusus m adalah vektor baris dua elemen [anggaran running_time], sedangkan s adalah matriks Nx3, di mana N adalah jumlah adegan dan setiap baris terdiri dari [kepentingan biaya running_time].

Python 3, 211 197 byte

Solusi ini memaksa semua kombinasi adegan mulai dari kombinasi semua adegan hingga kombinasi hanya satu adegan, lalu memilih kombinasi adegan yang memiliki kepentingan maksimum. Brute-forcing digunakan sebagai biaya dalam waktu tidak terlalu besar, meskipun jelas eksponensial. Outputnya diindeks nol.

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

Tidak melakukan pelanggaran:

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]

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

Bagaimana itu bekerja:

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

Menemukan trik selanjutnya beberapa saat yang lalu dalam jawaban @xnor. Ini lebih pendek dari subsequenceyang dibutuhkan import Data.List.

Ruby, 172 166 165 byte

Saya benar-benar harus mulai memeriksa apakah versi Ruby dari jawaban Python saya lebih golf sebelum memposting jawaban Python itu. Bagaimanapun, ini adalah pendekatan brute-force yang sama untuk optimasi seperti sebelumnya. Segala tip tentang bermain golf dipersilakan, termasuk yang melibatkan beberapa teknik optimasi yang sebenarnya.

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

Tidak Disatukan:

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