सिक्का परिवर्तन समस्या एन सिक्के और प्रत्येक मूल्य का उपयोग कर गणना

Question

सिक्का परिवर्तन समस्या बहुत अच्छी तरह से प्रलेखित है। मूल्यवर्ग के सिक्कों की एक अनंत आपूर्ति को देखते हुए x_1करने के लिए x_mआप जो को जोड़ संयोजनों की संख्या खोजने की जरूरत है y। उदाहरण के लिए, दिए गए x = {1,2,3}और y = 4हमारे पास चार संयोजन हैं:

1. {1,1,1,1}
2. {1,1,2}
3. {1,3}
4. {2,2}

परिचय

सिक्का बदलने की समस्या के कई रूप हैं। इस भिन्नता में हमारे पास दो अतिरिक्त प्रतिबंध हैं:

1. हर संप्रदाय को कम से कम एक बार इस्तेमाल किया जाना चाहिए।
2. निश्चित रूप से सिक्कों की एक निश्चित संख्या का उपयोग कुल में किया जाना चाहिए।

उदाहरण के लिए, दिए गए x = {1,2,3}, y = 36और सिक्कों की कुल संख्या n = 15कहाँ nहै जिसका उपयोग किया जाना चाहिए, हमें चार संयोजन मिलते हैं:

1. {1,2,2,2,2,2,2,2,3,3,3,3,3,3,3} (1 वाले, 7 जुड़वाँ, 7 तिकड़ी)
2. {1,1,2,2,2,2,2,3,3,3,3,3,3,3,3} (2 वाले, 5 दोहे, 8 तारे)
3. {1,1,1,2,2,2,3,3,3,3,3,3,3,3,3} (3 वाले, 3 जुड़वां, 9 तने)
4. {1,1,1,1,2,3,3,3,3,3,3,3,3,3,3} (4 वाले, 1 जुड़वां, 10 तने)

चुनौती

चुनौती enumerateअपनी पसंद की भाषा में एक फ़ंक्शन लिखना है जो ऊपर वर्णित सभी संयोजनों को शामिल करता है:

1. मूल्यवर्ग की सूची। उदाहरण के लिए {1,5,10,25}। आप सूची या सरणियों का उपयोग कर सकते हैं।
2. एक गैर-नकारात्मक पूर्णांक yजो हर संयोजन के योग को दर्शाता है।
3. एक गैर-नकारात्मक पूर्णांक nजो सिक्कों की कुल संख्या को दर्शाता है।

तर्कों का क्रम मायने नहीं रखता। पॉइंटफ़्री फ़ंक्शंस की अनुमति है।

enumerateफ़ंक्शन का आउटपुट संयोजन की एक सूची होना चाहिए। प्रत्येक संयोजन अद्वितीय होना चाहिए और यह nपूर्णांकों की एक सूची होनी चाहिए जो इसमें जोड़ते हैं y। प्रत्येक संप्रदाय को प्रत्येक संयोजन में कम से कम एक बार दिखाई देना चाहिए और कोई भी संयोजन गायब नहीं होना चाहिए। पूर्णांकों और संयोजनों के क्रम से कोई फर्क नहीं पड़ता। आप आउटपुट के लिए सूची या सरणियों का उपयोग कर सकते हैं।

निम्नलिखित बढ़त के मामलों को ध्यान में रखें:

1. दोनों हैं yऔर nशून्य हैं और संप्रदायों के सूची रिक्त है तो उत्पादन एक संयोजन की एक सूची है, खाली संयोजन (यानी {{}})।
2. अन्यथा, यदि yशून्य है, nशून्य है या संप्रदायों की सूची खाली है तो उत्पादन शून्य संयोजनों (यानी {}) की एक सूची है ।
3. अधिक आम तौर पर, यदि yसंप्रदायों के योग से nकम या संप्रदायों की संख्या से कम है तो उत्पादन शून्य संयोजनों की एक सूची है।

स्कोरिंग बाइट्स में पूरे कार्यक्रम के आकार पर आधारित होगी। ध्यान दें कि इसमें enumerateफ़ंक्शन, सहायक फ़ंक्शन, आयात विवरण आदि शामिल हैं। इसमें परीक्षण मामले शामिल नहीं हैं।

Comments

मुझे यकीन है कि मैंने इस चुनौती को कहीं और देखा है ...

— लीक नून

मुझे आशा है कि यह प्रश्न डुप्लिकेट नहीं है। मुझे कोड गोल्फ पर एक ही सवाल नहीं मिला। इसलिए, मैंने इसे पोस्ट किया।

— आदित एम शाह

@PeterTaylor यदि yसंप्रदायों के योग से कम है तो अपने पुनरावर्ती समाधान के कुछ बिंदु पर आप आधार मामले तक पहुंचेंगे जहां संप्रदायों की सूची खाली है। इसलिए, उत्तर होगा {}(अर्थात कोई समाधान नहीं मिला)। यदि nआप संप्रदायों की संख्या से कम हैं तो आप अंततः आधार मामले में पहुँचेंगे, n = 0लेकिन जहाँ y != 0। इसलिए, उत्तर फिर से होगा {}।

— आदित एम शाह

@PeterTaylor वास्तव में। मैं कार्यान्वयन विवरण के बारे में बहुत अधिक अनुमान लगा सकता हूं। क्या आप जानते हैं कि इसे कैसे ठीक किया जाए?

— आदित एम शाह

मेरा सुझाव है कि आप "स्वीकृत" झंडे को तब तक हटा दें जब तक आपको काम करने का जवाब न मिल जाए। और सामान्य तौर पर यह स्वीकार करने से पहले कुछ दिनों तक इंतजार करना समझदारी है।

— पीटर टेलर

Answer 1

05AB1E, 20 बाइट्स

g-¹sã€{Ùvy¹«DO³Qiˆ}¯

इनपुट क्रम में है: list of values, nr of coins, sum to reach।

संक्षेप में व्याख्या

1. लंबाई की सिक्का सूची के सभी क्रमांकन प्राप्त करें: final length - length of unique coin list
2. इन सूचियों में अद्वितीय सिक्कों की सूची जोड़ें।
3. यदि योग राशि के बाद मांग के बराबर है, तो सूची को बचाएं
4. आउटपुट सभी सहेजी गई सूचियाँ

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

ऑनलाइन कंपाइलर बड़ी संख्या में सिक्कों को संभाल नहीं सकता है।

Answer 2

MATL , 22 बाइट्स

Z^!S!Xu!tsi=Z)"1G@m?@!

इनपुट ऑर्डर है: संप्रदायों की सरणी, लिए गए सिक्कों की संख्या ( n), वांछित राशि ( y)।

प्रत्येक संयोजन एक अलग लाइन पर प्रदर्शित होता है। खाली आउटपुट को एक रिक्त स्ट्रिंग (इसलिए कुछ भी नहीं) के रूप में प्रदर्शित किया जाता है।

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

कोड चुनौती में उदाहरण के लिए ऑनलाइन कंपाइलर में मेमोरी से बाहर चलाता है, लेकिन एक मानक, यथोचित आधुनिक कंप्यूटर के साथ ऑफ़लाइन काम करता है:

>> matl
 > Z^!S!Xu!tsi=Z)"1G@m?@!
 > 
> [1 2 3]
> 15
> 36
1 1 1 1 2 3 3 3 3 3 3 3 3 3 3
1 1 1 2 2 2 3 3 3 3 3 3 3 3 3
1 1 2 2 2 2 2 3 3 3 3 3 3 3 3
1 2 2 2 2 2 2 2 3 3 3 3 3 3 3

व्याख्या

Z^      % Implicitly input array of denomminations and number of coins n. Compute 
        % Cartesian power. This gives 2D array with each "combination"
        % on a different row
!S!     % Sort each row
Xu      % Deduplicate rows
!       % Transpose: rows become columns. Call this array A
ts      % Push a copy, compute sum of each column
i       % Input y (desired sum)
=       % Logical array that contains true if the "combination" has the desired sum
Z)      % Keep only those columns in array A
"       % For each column
  1G    %   Push array of denominations again
  @     %   Push current column
  m     %   Is each denomination present in the column?
  ?     %   If so
    @!  %     Push current column again. Transpose into a row
        %   End if
        % End for
        % Implicitly display stack contents

Answer 3

पायथन 3, 120 106 बाइट्स

from itertools import*
lambda d,t,l:[i+d for i in combinations_with_replacement(d,l-len(d))if sum(i+d)==t]

एक अनाम फ़ंक्शन जो फ़ॉर्म के संप्रदायों (x_1, x_2, x_3 ... , x_k), लक्ष्य मान, और तर्क के माध्यम से कई सिक्कों के एक टपल का इनपुट लेता है, और फ़ॉर्म के tuples की सूची देता है [(solution_1), (solution_2), (solution_3), ... (solution_k)]।

यह काम किस प्रकार करता है

Itertools's combinations_with_replacementफ़ंक्शन का उपयोग सभी l-len(d)संयोजनों को उत्पन्न करने के लिए किया जाता है , प्रतिस्थापन के साथ, संप्रदायों के। dइन संयोजनों में से प्रत्येक को जोड़कर , यह गारंटी दी जाती है कि प्रत्येक संप्रदाय कम से कम एक बार दिखाई देता है, और नए संयोजन की लंबाई होती है l। यदि संयोजन योग के तत्व t, संयोजन को टपल के रूप में वापसी सूची में जोड़ा जाता है।

Ideone पर इसे आज़माएं

---

108 बाइट्स के लिए एक वैकल्पिक विधि

from itertools import*
lambda d,t,l:set(tuple(sorted(i+d))for i in product(d,repeat=l-len(d))if sum(i+d)==t)

एक अनाम फ़ंक्शन जो फ़ॉर्म के संप्रदायों (x_1, x_2, x_3 ... , x_k), लक्ष्य मान, और तर्क के माध्यम से कई सिक्कों के एक टपल का इनपुट लेता है, और फ़ॉर्म के tuples का एक सेट लौटाता है {(solution_1), (solution_2), (solution_3), ... (solution_k)}।

यह कैसे काम करता है (अन्य संस्करण)

यह productफ़ंक्शन का उपयोग संप्रदायों की itertoolsसभी l-len(d)व्यवस्थाओं को उत्पन्न करने के लिए करता है। dइन संयोजनों में से प्रत्येक को जोड़कर , यह गारंटी दी जाती है कि प्रत्येक संप्रदाय कम से कम एक बार दिखाई देता है, और नए संयोजन की लंबाई होती है l। यदि संयोजन के तत्वों का योग है t, तो संयोजन को क्रमबद्ध किया जाता है, सूची से टुपल में परिवर्तित किया जाता है, और रिटर्न ट्यूपल्स में जोड़ा जाता है। अंत में, कॉलिंग setकिसी भी डुप्लिकेट को निकालता है।

Ideone (अन्य संस्करण) पर इसे आज़माएं

Answer 4

जावास्क्रिप्ट (ईएस 6), 135 बाइट्स

g=(a,n,y,r)=>n>0?y>0&&a.map((x,i)=>g(a.slice(i),n-1,y-x,[...r,x])):n|y||console.log(r)
(a,n,y)=>g(a,n-a.length,a.reduce((y,x)=>y-x,y),a)