डॉलर विभाजन और सही परिवर्तन

Question

मेरी जेब में $ 15 हैं। इसी तरह, मैं एक ऐसे स्टोर में हूं जो बदलाव नहीं देता है। ब्राउज़ करते समय, मैं $ 10 की लागत वाली एक वस्तु (कर शामिल) करता हूं। क्या मैं बिना पैसा खोए उस वस्तु को खरीद सकता हूं?

इस मामले में, जवाब हां है। कोई फर्क नहीं पड़ता कि मेरे $ 15 को कैसे विभाजित किया गया है (एक 10 और एक 5, या तीन 5s, या कुछ और), मुझे हमेशा सटीक $ 10 की आवश्यकता होगी।

दूसरे उदाहरण के रूप में, मेरी जेब में $ 0.16 है। मुझे अन्य कितनी राशि का भुगतान करना चाहिए?

Possible Divisions:
0.01, 0.05, 0.10
0.01, 0.05 x 3
0.01 x 16
Guaranteed Exact Change:
0.01, 0.05, 0.06, 0.10, 0.11, 0.15, 0.16

अगर मेरी जेब में $ 0.27 हो तो क्या होगा?

Possible Divisions:
0.01 x 2, 0.25
0.01 x 2, 0.05, 0.10 x 2
0.01 x 2, 0.05 x 3, 0.10
0.01 x 2, 0.05 x 5
0.01 x 27
Guaranteed Exact Change:
0.01, 0.02, 0.25, 0.26, 0.27

उपरोक्त मामले में, केवल कुछ मात्रा में पैसे थे जिसके लिए मैं हमेशा सही परिवर्तन करूंगा।

आपका कार्य

सबसे छोटा प्रोग्राम (या नामित फ़ंक्शन) लिखें जो ए) लेता है एक पूर्णांक राशि और बी) इनपुट के रूप में संभावित संप्रदायों की एक सूची है, और उन धनराशि की सूची का आउटपुट करता है जिनके लिए मेरे पास पूर्ण परिवर्तन होना चाहिए। इनपुट प्रोग्राम या फ़ंक्शन के लिए STDIN या तर्क हो सकता है। मैं इनपुट स्वरूपण पर सुपर-सख्त नहीं होने जा रहा हूं; यह मेल कर सकता है कि आपके भाषा प्रारूप कैसे व्यवस्थित होते हैं।

शायद एक अधिक विस्तृत व्याख्या

मेरी जेब में एक निश्चित राशि है, जो मुद्रा के संभावित प्रदर्शनों के एक सेट से बनती है। यदि मेरे पास $ 8 है, और मुझे पता है कि संभावित मूल्यवर्ग $ 2 और $ 3 हैं, तो बिलों के केवल बहुत सारे संयोजन हैं जो मेरी जेब में हो सकते हैं। ये हैं 2+2+2+2और 3+3+2। सही मात्रा में धन का उत्पादन करने में सक्षम होने के लिए, मुझे अपनी जेब में मौजूद बिलों का उपयोग करके उस मात्रा का उत्पादन करने में सक्षम होना चाहिए। यदि मेरे पास चार 2s होते, तो मैं उत्पादन कर सकता था 2, 4, 6, or 8। अगर मेरे पास दो 3s और 2 होते, तो मैं उत्पादन कर सकता था 2, 3, 5, 6, or 8क्योंकि मुझे नहीं पता कि इनमें से कौन सा संयोजन वास्तव में मेरी जेब में है, मेरा अंतिम उत्तर कम हो गया है 2, 6, 8। ये वे मूल्य हैं जिन्हें मैं जानता हूं कि मैं अपनी जेब से उत्पादन कर सकता हूं, कुल राशि और संभावित मूल्यवर्ग।

हाथ से परिकलित उदाहरण I / O

7 [3, 4]
3, 4, 7        //only one possible division into 3 + 4

7 [3, 2]
2, 3, 4, 5, 7  //the only division is 3 + 2 + 2

6 [2, 3, 4]
6     //divisions are 2+2+2, 3+3, 2+4 

16 [1, 5, 10, 25]          //this represents one of the examples above
1, 5, 6, 10, 11, 15, 16

27 [1, 5, 10, 25]          //another example from above
1, 2, 25, 26, 27

1500 [1, 5, 10, 25, 100, 500, 1000, 2000]
500, 1000, 1500

600 [100, 500, 1000, 2000]
100, 500, 600

600 [200, 1, 5, 10, 25, 100, 500, 1000, 2000]
600

Comments

यह बहुत अस्पष्ट है।

— मोटोकू

@FryAmTheEggman मैंने एक "शायद अधिक विस्तृत विवरण जोड़ा है।" मुझे बताएं कि क्या यह अभी भी भ्रमित है। (मैंने एक किनारे के मामले को भी हटा दिया क्योंकि यह बहुत ज्यादा बेकार था।)

— PhiNotPi

मैं नहीं देखता कि तुम कैसे हो 6 [2, 3, 4]। 2+2+23 नहीं बना सकते , और 3+32 और 4 नहीं बना सकते?

— xnor

@xnor आप सही हैं, फिक्स्ड हैं।

— PhiNotPi

क्या प्रोग्राम को सभी इनपुट के लिए उचित समय में चलना चाहिए? उदाहरण के लिए मेरा सबसे छोटा विचार प्रारंभिक राशि में घातांक है और 2 ^ 1500 किसी भी चीज का एक बहुत कुछ है।

— यादृच्छिक

Answer 1

पायथन 2, 200 197 193 140 बाइट्स

f=lambda n,D,S={0}:sum([f(n-x,D,S|{x+y for y in S})for x in D],[])if n>0else[S]*-~n
g=lambda*a:(f(*a)and reduce(set.__and__,f(*a))or{0})-{0}

(टिप्स के लिए @ नब को धन्यवाद)

यहाँ चीजों को शुरू करने के लिए एक खराब गोल्फ समाधान है। के साथ कॉल g(16, [1, 5, 10, 25])- आउटपुट प्रासंगिक संप्रदायों के साथ एक सेट है।

दृष्टिकोण सीधा है, और दो चरणों में टूट गया है:

• fnसंप्रदायों D(जैसे [1, 5, 10]) तक पहुंचने के सभी तरीकों को देखता है , और प्रत्येक के लिए यह सभी मात्राओं को काम करता है जो इन संप्रदायों (जैसे set([0, 1, 5, 6, 10, 11, 15, 16])) के साथ किया जा सकता है ।
• gके परिणामों के चौराहों की गणना करता है f, फिर अंतिम उत्तर के लिए 0 निकालता है।

कार्यक्रम 1-5 और 7 के मामलों को हल करता है, 6 पर ओवरफ्लो होता है और 8 पर हमेशा के लिए लग जाता है।

यदि कोई समाधान (जैसे g(7, [2, 4, 6])) नहीं है, तो प्रोग्राम एक खाली सेट लौटाता है। यदि इस तरह के मामले के लिए एक त्रुटि को फेंक दिया जाता है, तो यहां एक छोटा है g:

g=lambda*a:reduce(set.__and__,f(*a))-{0}

Comments

g=lambda L,c=0:L and g(L[1:],c)|g(L,c+L.pop(0))or{c}थोड़ा छोटा है

— नायब

-{0}जी में जाने और [L]*-~nइसके बजाय का उपयोग करके थोड़ा अधिक[L][-n:]

— नाब

Answer 2

जावास्क्रिप्ट (ईएस 6) 162 203 207

संपादित सरणी आर में एक दूसरे को काटना परिणाम सेट करने के लिए जिस तरह से बदल दिया है। थोड़ा तेज, लेकिन एल्गोरिथ्म अभी भी बदबू आ रही है।

अधिक विस्तृत विवरण का पालन करेंगे।
शीघ्रता से: c एक पुनरावर्ती कार्य है जो सभी संभव उपविभागों को समाहित करता है। k एक पुनरावर्ती कार्य है जो पुनरावृत्ति के बिना सभी संभव योगों को गणना करता है। K फ़ंक्शन के साथ पाया गया कोई भी नया परिणाम सेट की तुलना पिछले सेट के साथ मिली, केवल सामान्य परिणाम ही रखे गए हैं।

यह इतना धीमा क्यों है? कुल, लक्ष्य 1500, और मान 1 के एक टुकड़े का प्रबंधन करने के बाद, सभी अधिभोग रकमों की गणना करना एक अच्छा विचार नहीं है।

F=(s,d,r,
  c=(s,i,t=[],v,k=(i,s,v)=>{for(;v=t[i++];)k(i,s+v);o[s]=s})=>
  {for(s||(i=k(o=[],0),r=(r||o).filter(v=>o[v]));v=d[i];++i)s<v||c(s-v,i,[...t,v])}
)=>c(s,0)||r

Ungolfed

F=(s,d)=>{
  var r
  var c=(s,i,t=[])=>
  {
    var o=[],v
    var k=(i,s)=> // find all sums for the current list t, set a flag in the o array
    {
      var v
      for(;v=t[i++];)k(i,s+v)
      o[s]=s
    }

    if (s==0) {
      k(0,0)
      if (r)
        r = r.filter(v=>o[v]) // after first loop, intersect with current
      else
        r = o.filter(v=>v) // first loop, keep all results
    } 
    else
      for(;v=d[i];++i)
      { 
        if (s >= v) 
          c(s-v, i, t.concat(v))
      }
  }
  c(s,0) // enumerate all possible set of pieces
  return r
}

फ़ायरफ़ॉक्स / फायरबग कंसोल में टेस्ट करें

F(16,[1,5,10,25])

[१, ५, ६, १०, ११, १५, १६]

(समय 84 मिसे)

F(27, [1, 5, 10, 25]) 

[१, २, २५, २६, २ 25]

(समय 147252 मिसे, तो तेजी से सोओ नहीं)

Answer 3

वोल्फ्राम मेटेमैटिक, 104 बाइट्स

Rest@*Intersection@@Map[Total]/@Subsets/@Union[Sort/@IntegerPartitions[#,#,PadLeft[{},Length[#2]#,#2]]]&

अधूरा (अंत से पढ़ें):

Rest@* // Removing 0
  Intersection@@   // Intersecting all totals
     Map[Total]/@  // Counting total of each subset
        Subsets/@  // Getting all the subsets of each partition
           Union[  // Removing duplicates 
              Sort/@ // Sorting each partition (to remove duplicates next)
                 IntegerPartitions[#,#,PadLeft[{},Length[#2]#,#2]] // Getting all Integer partitions
                ]&