चंगुल को ट्रिगर करें और जैकपॉट की रक्षा करें

Question

आप एक गेमशो में भाग लेने जा रहे हैं। चुनौतियों में से एक निम्नानुसार काम करती है:

• पहले कमरे में बड़ी संख्या में समान गेंदें हैं।
• दूसरे कमरे में च्यूट की एक श्रृंखला है, जिसमें से प्रत्येक में एक सेंसर है जो गिनता है कि इसमें कितनी गेंदें रखी गई हैं। एक गेंद जिसे एक चुत में रखा जाता है, फिर उसे बरामद नहीं किया जा सकता है।
• प्रत्येक चूट को एक निश्चित संख्या में गेंदों (इसकी ट्रिगर गणना ) के बाद ट्रिगर किया जाएगा । जब यह ट्रिगर करता है तो यह रोशनी चमकता है, एक शोर करता है, और आपको इसमें कोई संदेह नहीं है कि यह ट्रिगर हो गया है।
• Nअगली चुनौती जारी रखने के लिए आपको चिट्स को ट्रिगर करना होगा ।
• आप ट्रिगर गिनती जानते हैं, लेकिन गिनती और ढलान के बीच पत्राचार नहीं।
• आपके पास पहले कमरे से दूसरे में गेंदों को ले जाने का एक अवसर है। एक बार जब आप एक गेंद को चुत में डालते हैं, तो आप अधिक गेंदों के लिए वापस नहीं जा सकते।
• प्रत्येक गेंद जिसे आप जैकपॉट से पैसे काटते हैं।

जाहिर है आप यह सुनिश्चित करना चाहते हैं कि आप चुनौती को पार कर जाएंगे, लेकिन आप खजाना नुकसान को कम करना चाहते हैं। आपको कितनी गेंदें चाहिए, यह बताने के लिए एक प्रोग्राम, फंक्शन, क्रिया आदि लिखें।

उदाहरण

मान लें कि ट्रिगर मायने रखता है 2, 4, और 10, और आप पास करने के लिए 2 chutes ट्रिगर करने की जरूरत है। 10 गेंदों के साथ पास करने की एक रणनीति है: पहली च्यूट में 4 गेंदों तक, दूसरी चुत में 4 गेंदों तक और तीसरी च्यूट में 4 गेंदों तक। चूंकि तीन में से एक च्यूट केवल 2 गेंदों के बाद ट्रिगर होगा, आप केवल कुल 10 का उपयोग करते हैं। कोई रणनीति नहीं है जो 10 से कम के साथ काम करने की गारंटी है, इसलिए यह सही आउटपुट है।

इनपुट

इनपुट में पूर्णांक ट्रिगर काउंट की एक सरणी होती है और एक पूर्णांक ट्रिगर करने के लिए chutes की संख्या देता है। आप दोनों इनपुट या तो क्रम में ले सकते हैं, और यदि आवश्यक हो तो आप सरणी की लंबाई के साथ तीसरा इनपुट ले सकते हैं।

आप मान सकते हैं कि सभी इनपुट शून्य से अधिक हैं, और यह कि जितने chutes को ट्रिगर किया जाना चाहिए, वह chutes की संख्या से अधिक नहीं है।

आप यह भी मान सकते हैं कि जब तक आप अपने उत्तर में स्पष्ट रूप से बता देते हैं कि काउंट्स छांटे गए (आरोही या अवरोही) हैं।

उत्पादन

इष्टतम रणनीति द्वारा आवश्यक गेंदों की संख्या देते हुए, आउटपुट एक पूर्णांक होना चाहिए।

परीक्षण के मामलों

प्रारूप: N counts solution

1 [2 4 10] 6
2 [2 4 10] 10
3 [2 4 10] 16
1 [3 5 5 5 5 5 5 5 5 5] 5
2 [1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 8 11] 8
2 [1 2 6 6 6 6 6 6 6 10] 16
2 [1 2 3 3 4 4 6 6 6 11] 17
3 [1 2 3 4 5 5 6] 16
3 [2 4 7 7 7 7 7 7 7] 21
5 [1 2 2 3 3 3 3 3 5 9 9 11] 27
2 [5 15 15] 25
1 [4 5 15] 10
3 [1 4 4 4] 10
2 [1 3 4] 6
2 [1 3 3 8] 8

Comments

चेतावनी: निंजा की कोशिश मत करो!

— सितंबर को आउटगोल्फ जूल

क्या आप बता सकते हैं कि आख़िरी टेस्ट केस 10 क्यों देता है? कम से कम एक ट्रिगर सुनिश्चित करने के लिए प्रत्येक में कम से कम 4 जगह एक जगह नहीं है? मैं शायद बहुत गूंगा हूं और सवाल को अच्छी तरह से नहीं पढ़ा, लेकिन मुझे यह समझ में नहीं आया।

— श्री एक्सकोडर

@Rod आपको ट्रिगर करने की गारंटी देने से पहले उनमें से दो को केवल 5 में रखना होगा, 5 * 2 = 10

— H.PWiz

@ H.PWiz धन्यवाद, अब मिल गया। चुनौती अब और अधिक जटिल लगती है ...

— श्री एक्सकोडर

@ Mr.Xcoder, हाँ, लेकिन आपको सबसे खराब स्थिति में सफल होने के लिए निश्चित होना चाहिए।

— पीटर टेलर

Answer 1

पायथन, 222 198 बाइट्स

def S(G,P,T=0):
 T=T or[0]*len(P);r=[0]*(sum(t>=p for t,p in zip(T,P))>=G)
 for i,t in enumerate(T):
    if t<max(P):a=next(p for p in P if p>t)-t;T[i]+=a;r+=[a+S(G,P,sorted(T))];T[i]-=a
 return min(r)

उपयोग है S(2, (2, 4, 10))।

किसी भी सभ्य गति से इस कार्यक्रम का परीक्षण करने के लिए, फ़ंक्शन परिभाषा के बाद इसे लगाकर संस्मरण जोड़ें:

old_s = S
mem = {}
def S(G, P, T=0):
    k = (G, tuple(P), T and tuple(T) or 0)
    if k in mem: return mem[k]
    r = old_s(G, P, T)
    mem[k] = r
    return r

---

हम एक सरणी T पर डायनेमिक प्रोग्रामिंग करते हैं जिसमें प्रत्येक च्यूट में फेंकी गई गेंदों की संख्या होती है, शुरू में सभी शून्य। एक कठोर प्रमाण प्रदान किए बिना, मेरा दावा है कि हम हर समय टी को छांट कर रख सकते हैं, अर्थात्, हम हमेशा सबसे अधिक गेंदों को अंतिम च्यूट में फेंकते हैं, जो बदले में हम मान लेंगे कि सबसे बड़ी चुट है।

यदि तब T, जब P के साथ तत्व के लिए तत्व से मेल खाता है (जो हमारी समस्या इनपुट है), तो कम से कम G (जो हमारा लक्ष्य है) तत्व बड़ा है, हमने एक समाधान ढूंढ लिया है, और हम 0 वापस करते हैं, क्योंकि हमें 0 फेंकने की आवश्यकता है अधिक गेंदों एक समाधान खोजने के लिए। इसका मतलब यह है कि अगर जी 1 है तो हमारा सबसे छोटा हिस्सा च्यूट में होना चाहिए जिसमें छोटी से छोटी ढलान की आवश्यकता के बराबर या अधिक मात्रा में गेंदें हों, और इतने बड़े जी के लिए।

अन्यथा, प्रत्येक स्थिति के लिए हम पर्याप्त गेंदों को अगली चुत की आवश्यकता के लिए अपग्रेड करने के लिए फेंक देते हैं (बीच में कुछ भी कभी भी देखने योग्य नहीं होगा) और पुनरावृत्ति करें। हम फिर इन पुनरावर्ती कॉलों की न्यूनतम राशि लौटाते हैं।

Comments

२१५ बाइट निकालकर continue।

— श्री एक्सकोडर

195 बाइट्स हटाकरenumerate

— फेलिप नारदी बतिस्ता

Answer 2

हास्केल, 124 117 100 98 91 80 78 बाइट्स

@ बेटर टेलर को 11 बाइट्स धन्यवाद दिया

0#_=0
n#a=minimum$zipWith(\x y->x*y+(n-1)#(snd.splitAt y$a))a[1..length a-n+1]

इसे ऑनलाइन आज़माएं!

(#) एक पूर्णांक और पूर्णांकों की सूची को तर्क के रूप में अवरोही क्रम में ले जाता है

उपयोग है 1#[10,4,2]

explaination:

सूची में प्रत्येक मूल्य, x, स्थिति i (1-idexed) के लिए, उस तत्व (या x के बराबर या उससे कम कुछ तत्वों की मात्रा) को निकालने के लिए सर्वोत्तम रणनीति है x गेंदों को i chutes में डालना।

प्रत्येक तत्व के लिए, x, सूची में मैं स्थिति में (n #) सूची से x * i + ((n-1) #) की स्थिति से परे सूची i (जब तक n 0 है) की गणना करता है। फिर यह जाँच की गई सभी संभावनाओं को न्यूनतम लेता है।

Answer 3

हास्केल , 54 बाइट्स

(%)0
(p%l)n|h:t<-l=p+min(p%t$n)(h%t$n-1)|n<1=p|1>0=1/0

इसे ऑनलाइन आज़माएं!

सूची को आरोही क्रम में ले जाता है।

Comments

स्वयं पर ध्यान दें: अगली बार जोर देते हैं कि आउटपुट पूर्णांक प्रकार का होना चाहिए।

— पीटर टेलर

मैं यह जानने के लिए पर्याप्त हास्केल नहीं जानता कि क्या आप एक स्पष्टीकरण जोड़ सकते हैं?

— orlp

Answer 4

पायथन, 73 बाइट्स

f=lambda n,c:n and min(c[i]*-~i+f(n-1,c[-~i:])for i in range(len(c)-n+1))

H.PWiz के हास्केल उत्तर का पोर्ट। अवरोही क्रम में इनपुट की आवश्यकता है।

Answer 5

CJam (35 बाइट्स)

{:A,,e!f<{$__(;A,+.-\Af=.*1bz}%:e<}

ऑनलाइन डेमो

N countsयह मानते हुए इनपुट लेता है कि countsआरोही क्रम में क्रमबद्ध है।

विच्छेदन

1-अनुक्रमित सरणी के रूप में अवरोही क्रम में मायने रखता है C(इसलिए दूसरा तत्व Cदूसरी सबसे बड़ी गिनती है)। मान लीजिए कि हम चुटियों को ट्रिगर करके जीतते हैं C[a_0], C[a_1], ... C[a_{N-1}]। फिर सबसे खराब स्थिति में, प्रत्येक के लिए C[a_i]हमने कम से कम C[a_i]गेंदों को प्रत्येक च्यूट में डाल दिया 1है a_i। तो हम C[a_{N-1}]गेंदों को a_{N-1}चुट में डालते हैं , एक अतिरिक्त C[a_{N-2}]गेंदों मेंa_{N-2} हैं, उनमें ...

Nगिनती के प्रत्येक सबसेट पर , जो हमें सबसे छोटी राशि देता है? तो फिर हम गिनती के सबसेट के साथ जीतने का लक्ष्य रखना चाहिए।

एनबी कोड वास्तव में आरोही क्रम में गिनती का उपयोग करता है, लेकिन मुझे लगता है कि अवरोही क्रम अधिक सहज है।

{         e# Define a block
  :A      e#   Store the sorted counts as A
  ,,e!f<  e#   Get all N-element subsets of A's indices
  {       e#   Map over these subsets S:
    $__   e#     Sort the subset and get a couple of copies
    (;A,+ e#     Remove the first element from one copy and append len(A)
    .-    e#     Pointwise subtraction, giving [S[0]-S[1] S[1]-S[2] ...]
    \Af=  e#     Get the counts [A[S[0]] A[S[1]] ...]
    .*    e#     Pointwise multiplication
    1bz   e#     Sum and take absolute value, giving the worst case score
  }%
  :e<     e#   Select the minimum worst case score
}