...गिना हुआ!

आप अपने कार्यक्रम को एक चर पास करेंगे जो डॉलर और / या सेंट में पैसे की मात्रा और सिक्का मूल्यों की एक सरणी का प्रतिनिधित्व करता है। आपकी चुनौती सिक्कों के दिए गए सरणी के संभावित संयोजनों की संख्या को आउटपुट करना है जो कोड को पारित की गई राशि तक जोड़ देगा। यदि नाम के सिक्कों के साथ यह संभव नहीं है, तो कार्यक्रम को वापस लौटना चाहिए 0।

अमेरिकी संख्यात्मक शब्दावली पर ध्यान दें:

1-सेंट का सिक्का: पैसा
5-सेंट का सिक्का: निकल
10-सेंट का सिक्का: dime
25-प्रतिशत सिक्का: तिमाही (तिमाही डॉलर)

उदाहरण 1:

कार्यक्रम पारित किया गया है:

12, [1, 5, 10]

(12 सेंट)

आउटपुट:

12 सेंट का उत्पादन करने के लिए नामित सिक्कों के संयोजन के 4 संभावित तरीके हैं:

12 पैसे
1 निकल और 7 पैसे
2 निकल और 2 पैसे
1 पैसा और 2 पैसा

उदाहरण 2:

कार्यक्रम पारित किया गया है:

26, [1, 5, 10, 25]

(26 सेंट)

आउटपुट:

26 सेंट के उत्पादन के लिए सिक्कों के संयोजन के 13 संभावित तरीके हैं:

26 पैसे
21 पैसे और 1 निकेल
16 पैसे और 2 निकल
11 पेनी और 3 निकल
6 पैसे और 4 निकल
1 पैसा और 5 निकल
16 पैसे और 1 पैसा
6 पैसे और 2 dimes
11 पैसे, 1 पैसा, और 1 निकल
6 पैसे, 1 पैसा, और 2 निकल
1 पैसा, 1 पैसा, और 3 निकल
1 पैसा, 2 dimes, और 1 निकल
1 चौथाई और 1 पैसा

उदाहरण 3:

कार्यक्रम पारित किया गया है:

19, [2, 7, 12]

आउटपुट:

19 सेंट का उत्पादन करने के लिए नामित सिक्कों के संयोजन के 2 संभावित तरीके हैं:

१ १२ प्रतिशत का सिक्का और १ and प्रतिशत का सिक्का
१ 1 प्रतिशत सिक्का और ६ २ प्रतिशत सिक्के

उदाहरण 4:

कार्यक्रम पारित किया गया है:

13, [2, 8, 25]

आउटपुट:

13 सेंट का उत्पादन करने के लिए नामित सिक्कों के संयोजन के कोई संभावित तरीके नहीं हैं।

यह सैंडबॉक्स के माध्यम से किया गया है। मानक खामियां लागू होती हैं। यह कोड गोल्फ है, इसलिए सबसे कम बाइट जीतता है।

— anonymous2
स्रोत

1

s / counted /

— Earn

4

@ mbomb007 चार बाइट्स के लिए s/count/earn:।

— wizzwizz4

5

मेरे लिए और मैं उन अन्य लोगों के लिए अनुमान लगाता हूं जो डॉलर के साथ भुगतान नहीं करते हैं यह स्पष्ट नहीं है कि निकेल और डाइम क्या है। यह पता लगाना मुश्किल नहीं था, लेकिन शायद आप इसे थोड़ा और अधिक अंतरराष्ट्रीय लिख सकते हैं?

— क्रिट्ज़फिट्ज़

2

@Kritzefitz। मैंने उसे प्रश्न में जोड़ दिया है।

— TRIG

2

@jpaugh: जबकि सिक्का-ओ-फ़ाइल्स सहमत हो सकता है, मुझे असहमत होना पड़ेगा। एक पैसा मानक सिक्का है जिसका मूल्य एक प्रतिशत है। चौंसठ पैसे की राशि है। चौबीस पैसे स्पष्ट रूप से पचपन सिक्के हैं। इसे "एक-प्रतिशत सिक्का", या आधिकारिक तौर पर "एक-प्रतिशत टुकड़ा" भी कहा जाता है। मैं किसी भी औपचारिक सेटिंग के बारे में नहीं सोच सकता जहाँ शब्द "पैसा" अस्वीकार्य होगा। ये लोग , जो विशेष रूप से सिक्के एकत्र करने के बारे में हैं, उन्हें इसे "पैसा" कहने में कोई समस्या नहीं है।

— माइकल ऑक्ट्स

12

जेली ( कांटा ), 2 बाइट्स

æf

यह जेली की एक शाखा पर निर्भर करता है, जहां मैं फ्रोबेनियस के परमाणुओं को हल करने के लिए काम कर रहा था, दुर्भाग्य से आप इसे ऑनलाइन नहीं आज़मा सकते।

प्रयोग

$ ./jelly eun 'æf' '12' '[1,5,10]'
4
$ ./jelly eun 'æf' '26' '[1,5,10,25]'
13
$ ./jelly eun 'æf' '19' '[2,7,12]'
2
$ ./jelly eun 'æf' '13' '[2,8,25]'
0

व्याख्या

æf  Input: total T, denominations D
æf  Frobenius count, determines the number of solutions
    of nonnegative X such that X dot-product D = T

— मील की दूरी पर
स्रोत

10

... यह भी उचित नहीं है।

— ETHproductions

... और मुझे यकीन है कि यह बहुत तेज़ है!

— जोनाथन एलन

18

हास्केल, 37 34 बाइट्स

s#l@(c:d)|s>=c=(s-c)#l+s#d
s#_=0^s

प्रयोग उदाहरण: 26 # [1,5,10,25]-> 13।

सरल पुनरावर्ती दृष्टिकोण: सूची में अगले नंबर की कोशिश करें (जब तक यह राशि के बराबर या उससे कम हो) और इसे छोड़ दें। यदि संख्या घटाना शून्य की मात्रा की ओर जाता है, तो एक 1और लें (या यदि सूची तत्वों से बाहर निकलती है) एक ले लें 0। उन योगों 1और 0एस।

संपादित करें: @ डैमियन: पुनरावृत्ति के लिए एक छोटे आधार मामले की ओर इशारा करते हुए 3 बाइट्स को बचाया (जो कि @ जवाब में भी पाया जा सकता है )।

— nimi
स्रोत

s # l @ (c: d) | s> = c = (sc) # l + s # d; s # _ = 0 ^ s

— डेमियन

और 1209 [1,5,10,33,48] और 6000 [1,5,10,33] का परिणाम क्या होगा, इसलिए मैं अपने कोड

— RosLuP

@RosLuP: 1209 # [1,5,10,33,48]-> 1314050।

— निम्मी

@nimi 1314050 के लिए मेरे पास यहां एक ही परिणाम है ... धन्यवाद ...

— RosLuP

@RosLuP: ... 537min बाद में: 6000 # [1,5,10,33]-> 22086484।

— nimi

15

गणितज्ञ, 35 22 बाइट्स

सुझाव FrobeniusSolveऔर 13 बाइट्स को बचाने के लिए मीलों के लिए धन्यवाद ।

Length@*FrobeniusSolve

एक अनाम फ़ंक्शन का मूल्यांकन करता है, जो पहले तर्क के रूप में सिक्कों की सूची और दूसरे के रूप में लक्ष्य मान लेता है। FrobeniusSolveफार्म के डायोफैंटाइन समीकरणों को हल करने के लिए एक आशुलिपि है

a₁x₁ + a₂x₂ + ... + a_nx_n = b

के लिए गैर नकारात्मक पूर्णांक से अधिक और हम सभी को समाधान देता है।x_i

— मार्टिन एंडर
स्रोत

@RosLuP इसे चलाने के लिए आपको Mathematica तक पहुंच की आवश्यकता होगी। इसके अलावा यह एक अनाम फ़ंक्शन है ताकि इसे कॉल किया जा सके, या तो इसे कोष्ठक में एनकैप्सुलेट किया जाए या इसे एक चर में संग्रहीत किया जाए। उदाहरण के लिए,(Length@*FrobeniusSolve)[{1, 7, 9}, 18]

— मील

और 1209 [1,5,10,33,48] और 6000 [1,5,10,33] का परिणाम क्या होगा, इसलिए मैं अपने कोड

— RosLuP

@RosLuP क्रमशः 1314050 और 22086484।

— मार्टिन एंडर

ठीक है यहाँ एक ही परिणाम, धन्यवाद ...

— RosLuP

इसके लिए 16 वोट तभी उचित हैं जब प्रोग्रामर ने लंबाई @ @ FrobeniusSolve लिखी हो ...

— RosLuP

12

पायथ, 8 बाइट्स

/sM{yS*E

कच्चे जानवर बल, वास्तविक परीक्षण के लिए भी स्मृति गहन। यह O (2 ^mn ) है, जहाँ n सिक्कों की संख्या है और m लक्ष्य योग है। के रूप में इनपुट लेता है target\n[c,o,i,n,s]।

/sM{yS*EQQ      (implicit Q's)
      *EQ       multiply coin list by target
     S          sort
    y           powerset (all subsequences)
   {            remove duplicates
 sM             sum all results
/        Q      count correct sums

— PurkkaKoodari
स्रोत

9

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

s%(h:t)=sum$map(%t)[s,s-h..0]
s%_=0^s

पहले सिक्के के कुछ कई का उपयोग करने से घटती हुई प्रगति में एक गैर-नकारात्मक मूल्य के लिए hआवश्यक राशि sघट जाती है [s,s-h..0], जिसे तब शेष सिक्कों के साथ बनाया जाना चाहिए। एक बार जब कोई सिक्का नहीं बचा है, तो जांच लें कि योग शून्य रूप से शून्य है 0^s।

— XNOR
स्रोत

यह आश्चर्यजनक है कि आपने एक अलग दृष्टिकोण का उपयोग करके @nimi के समान बाइट काउंट कैसे मारा।

— क्रिट्ज़फिट्ज़

9

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

f=(n,a,[c,...b]=a)=>n?n>0&&c?f(n-c,a)+f(n,b):0:1

किसी भी क्रम में सिक्कों को स्वीकार करता है। पहले सिक्के के उपयोग और न करने की कोशिश करता है, दोनों तरह से संयोजन की संख्या की पुनरावृत्ति करता है। n==0एक मिलान संयोजन का n<0मतलब है , इसका मतलब है कि सिक्के की मात्रा अधिक है, जबकि c==undefinedइसका मतलब है कि सिक्के नहीं बचे हैं। ध्यान दें कि फ़ंक्शन बहुत धीमा है और यदि आपके पास एक पैसा का सिक्का है तो निम्नलिखित फ़ंक्शन तेज है (सिक्कों के सरणी में एक पैसा का सिक्का पास न करें):

f=(n,a,[c,...b]=a)=>c?(c<=n&&f(n-c,a))+f(n,b):1

— नील
स्रोत

...धत तेरे की। वास्तविक अच्छा विचार है।

— ETHproductions

और 1209 [1,5,10,33,48] और 6000 [1,5,10,33] का परिणाम क्या होगा, इसलिए मैं अपने कोड

— RosLuP

@RosLuP दिया गया कोड अंततः आपके पहले उदाहरण के लिए 1314050 देता है। मेरा दुभाषिया दूसरे उदाहरण का मूल्यांकन करने के लिए आवश्यक पुनरावृत्ति को संभाल नहीं सकता है।

— नील

@RosLuP मैंने एक अतिरिक्त पैसे के सिक्के को ग्रहण करने के लिए फ़ंक्शन को संशोधित किया है और जो 6000 [5,10,33] के लिए 22086484 लौटा है।

— नील

@Neil ok 6000 के लिए 22086484 [1,5,10,33] ... इसके बजाय यहाँ 6000 के लिए 11239 होगा [5,10,33] (आपके द्वारा लिखी गई सरणी)

— RosLuP

7

पर्ल, 45 बाइट्स

बाइट काउंट में कोड और -pध्वज के 44 बाइट्स शामिल हैं ।

s%\S+%(1{$&})*%g,(1x<>)=~/^$_$(?{$\++})^/x}{

पहली पंक्ति पर सिक्का मान लेता है, और दूसरी पंक्ति पर लक्षित राशि:

$ perl -pE 's%\S+%(1{$&})*%g,(1x<>)=~/^$_$(?{$\++})^/x}{' <<< "1 5 10 25
26"
13

लघु स्पष्टीकरण:

-p                        # Set $_ to the value of the input, 
                          # and adds a print at the end of the code.
s%\S+%(1{$&})*%g,         # Converts each number n to (1{$&})* (to prepare the regex)
                          # This pattern does half the job.
(1x<>)                    # Converts the target to unary representation.
  =~                      # Match against.. (regex)
    /^ $_ $               # $_ contains the pattern we prepared with the first line.
     (?{$\++})            # Count the number of successful matches
     ^                    # Forces a fail in the regex since the begining can't be matched here.
    /x                    # Ignore white-spaces in the regex 
                          # (needed since the available coins are space-separated)
 }{                       # End the code block to avoid the input being printed (because of -p flag) 
                          # The print will still be executed, but $_ will be empty, 
                          # and only $\ will be printed (this variable is added after every print)

— बापू
स्रोत

6

जेली , 10 9 बाइट्स

œċÐ€S€€Fċ

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

कैसे?

œċÐ€S€€Fċ - Main link: coins, target
  Ð€      - map over right argument, or for each n in [1,2,...,target]
œċ        - combinations with replacement, possible choices of each of n coins
    S€€   - sum for each for each (values of those selections)
       F  - flatten into one list
        ċ - count occurrences of right argument

— जोनाथन एलन
स्रोत

2

पैसे से संबंधित प्रश्न में कई यूरो-प्रतीकों का उपयोग करने के लिए +1।

— steenbergh

6

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

f=(n,c)=>n?c.reduce((x,y,i)=>y>n?x:x+f(n-y,c.slice(i)),0):1

सिक्के उच्चतम से निम्नतम तक इनपुट होते हैं, जैसे f(26,[100,25,10,5,1])। यदि आपके पास एक पैसा है, तो उसे हटा दें और इसके बजाय इस तेज़ संस्करण का उपयोग करें:

f=(n,c)=>n?c.reduce((x,y,i)=>y>n?x:x+f(n-y,c.slice(i)),1):1

यह @ nimi की तरह एक पुनरावर्ती सूत्र का उपयोग करता है। मैंने मूल रूप से यह कुछ दिनों पहले लिखा था जब चुनौती अभी भी सैंडबॉक्स में थी; यह इस तरह दिखता था:

f=(n,c=[100,25,10,5])=>n?c.reduce((x,y,i)=>y>n?x:x+f(n-y,c.slice(i)),1):1

(केवल cमूल चुनौती में इसका एक निर्धारित मूल्य था), और फ़ंक्शन 0में बदलने के लिए एकमात्र अंतर है (यह दो बाइट्स छोटा था और एक bazillion समय से अधिक तेज़ी से )।.reduce1c=[100,25,10,5,1]

यहां एक संशोधित संस्करण है जो सभी संयोजनों की संख्या के बजाय सभी संयोजनों को आउटपुट करता है:

f=(n,c)=>n?c.reduce((x,y,i)=>y>n?x:[...x,...f(n-y,c.slice(i)).map(c=>[...c,y])],[]):[[]]

— ETHproductions
स्रोत

और 1209 [1,5,10,33,48] और 6000 [1,5,10,33] का परिणाम क्या होगा, इसलिए मैं अपने कोड

— RosLuP

@RosLuP मुझे क्रमशः 1314050 (5 मिनट के बाद) और एक स्टैक ओवरफ्लो (एक घंटे के बाद) मिलता है। मेरे द्वारा जोड़े गए तेज़ संस्करण के साथ, मुझे कुछ सेकंड के भीतर 1314050 और 22086484 मिलते हैं।

— ETHproductions

पहले परिणाम के लिए मेरे पुराने पेंटियम 2.8Gh कंप्यूटर के साथ 6 सेकंड, दूसरे 5 मिनट के लिए + या -

— RosLuP

5

PHP, 327 बाइट्स

function c($f,$z=0){global$p,$d;if($z){foreach($p as$m){for($j=0;$j<=$f/$d[$z];){$n=$m;$n[$d[$z]]=$j++;$p[]=$n;}}}else for($p=[],$j=0;$j<=$f/$d[$z];$j++)$p[]=[$d[$z]=>$j];if($d[++$z])c($f,$z);}$d=$_GET[a];c($e=$_GET[b]);foreach($p as$u){$s=0;foreach($u as$k=>$v)$s+=$v*$k;if($s==$e&count($u)==count($d))$t[]=$u;}echo count($t);

कोशिश करो

— जार्ग हुल्सरमन
स्रोत

5

Axiom, 63 62 बाइट्स

1 बाइट @JonathanAllan द्वारा सेव की गई

f(n,l)==coefficient(series(reduce(*,[1/(1-x^i)for i in l])),n)

यह दृष्टिकोण उत्पन्न कार्यों का उपयोग करता है। संभवतः यह कोड आकार को नीचे लाने में मदद नहीं करता था। मुझे लगता है कि यह पहली बार है जब मैं एशियोम के साथ खेल रहा हूं, मैं अपने स्वयं के कार्य को परिभाषित करने के रूप में गया हूं।

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

— क्रिश्चियन सिवर्स
स्रोत

1

मुझे पता नहीं है Axiom - क्या पहले स्थान को हटाना संभव है for?

— जोनाथन एलन

1

@JonathanAllan हाँ, यह है! अच्छा गोल्फ वृत्ति, धन्यवाद!

— क्रिश्चियन सेवर्स 23

5

आर, 81 76 63 बाइट्स

13 बाइट दूर करने के लिए @rturnbull को धन्यवाद!

function(u,v)sum(t(t(expand.grid(lapply(u/v,seq,f=0))))%*%v==u)

उदाहरण (ध्यान दें कि c(...)आप R के मानों को कैसे पास करते हैं):

f(12,c(1,5,10))
[1] 4

स्पष्टीकरण:

uवांछित मूल्य है, vसिक्का मूल्यों का वेक्टर है।

expand.grid(lapply(u/v,seq,from=0))

0 से k के सिक्कों के हर संभावित संयोजन के साथ एक डेटा फ्रेम बनाता है (k संप्रदाय पर निर्भर करता है), जहां k सबसे कम ऐसा है कि k उस समय का मान कम से कम u (प्राप्त करने का मान) है।

आम तौर पर हम इसे as.matrixएक मैट्रिक्स में बदल देते हैं, लेकिन यह कई अक्षर हैं। इसके बजाय हम ट्रांसपोज़ेशन (!) का प्रतिरूप लेते हैं जो स्वचालित रूप से इसे प्रस्तुत करता है, लेकिन कम वर्ण लेता है।

%*% vफिर प्रत्येक पंक्ति के मौद्रिक मूल्य की गणना करता है। अंतिम चरण यह गणना करना है कि उन मूल्यों में से कितने वांछित मूल्य के बराबर हैं u।

ध्यान दें कि इस की कम्प्यूटेशनल जटिलता और स्मृति आवश्यकताएं भयानक हैं लेकिन हे, यह कोड गोल्फ है।

— JDL
स्रोत

1

का अच्छा उपयोग expand.grid! और मुझे t(t())तरकीब पसंद है। चूंकि आपके फ़ंक्शन में केवल कोड की एक पंक्ति शामिल है, आप घुंघराले ब्रेसिज़ को हटा सकते हैं, जिससे आपको 2 बाइट्स मिलेंगे। इसके अलावा, आप do.call(expand.grid,lapply(u/v,seq,from=0))सिर्फ expand.grid(lapply(u/v,seq,f=0))11 बाइट की बचत के लिए स्विच कर सकते हैं ।

— rturnbull

उन लोगों के लिए धन्यवाद! मुझे कभी नहीं लगा expand.gridकि इनपुट के रूप में एक सूची होगी। यह एक शर्म की बात है कि ":"गैर-पूर्णांक के साथ अच्छी तरह से काम नहीं करता है अन्यथा lapply(u/v,":",0)एक जोड़े को अधिक बचाया होता।

— JDL

do.call(x,y)के रूप में ही है x(y), तो यह इनपुट किस प्रकार के स्वीकार किए जाते हैं के बारे में नहीं है। यदि आप वास्तव में उपयोग करना चाहते हैं :, तो मुझे लगता है कि आप उपयोग कर सकते हैं lapply(u%/%v,`:`,0), लेकिन यह एक ही बाइट गिनती है।

— 10

1

"के do.call(x,y)रूप में ही है x(y)" --- केवल yएक सूची नहीं है, जो इस मामले में है। हालांकि अपने दूसरे बिंदु पर सहमत हैं।

— JDL

3

जे, 27 बाइट्स

1#.[=](+/ .*~]#:,@i.)1+<.@%

प्रयोग

   f =: 1#.[=](+/ .*~]#:,@i.)1+<.@%
   12 f 1 5 10
4
   26 f 1 5 10 25
13
   19 f 2 7 12
2
   13 f 2 8 25
0

व्याख्या

1#.[=](+/ .*~]#:,@i.)1+<.@%  Input: target T (LHS), denominations D (RHS)
                          %  Divide T by each in D
                       <.@   Floor each
                             These are the maximum number of each denomination
                     1+      Add 1 to each, call these B
                ,@i.         Forms the range 0 the the product of B
             ]               Get B
              #:             Convert each in the range to mixed radix B
     ]                       Get D
       +/ .*~                Dot product between D and each mixed radix number
                             These are all combinations of denominations up to T
   [                         Get T
    =                        Test if each sum is equal to T
1#.                          Convert as base 1 digits to decimal (takes the sum)
                             This is the number of times each sum was true

— मील की दूरी पर
स्रोत

J इतना जबरदस्त है, फिर भी इतना

— बेहूदा है

2

TSQL, 105 बाइट्स

यह केवल 4 डॉलर के इन प्रकारों के साथ एक डॉलर तक संभाल सकता है। अनगोल्डेड संस्करण लगभग 4 डॉलर तक संभाल सकता है, लेकिन बहुत धीमा - मेरे बॉक्स पर यह 27 सेकंड लेता है। परिणाम 10045 संयोजन btw है

golfed:

DECLARE @ INT = 100
DECLARE @t table(z int)
INSERT @t values(1),(5),(10),(25)
;WITH c as(SELECT 0l,0s UNION ALL SELECT z,s+z FROM c,@t WHERE l<=z and s<@)SELECT SUM(1)FROM c WHERE s=@

Ungolfed:

-- input variables
DECLARE @ INT = 100
DECLARE @t table(z int)
INSERT @t values(1),(5),(10),(25)

-- query
;WITH c as
(
  SELECT 0l,0s
  UNION ALL
  SELECT z,s+z
  FROM c,@t
  WHERE l<=z and s<@
)
SELECT SUM(1)
FROM c
WHERE s=@
-- to allow more than 100 recursions(amounts higher than 1 dollar in this example)
OPTION(MAXRECURSION 0)

बेला

— t-clausen.dk
स्रोत

2

टिनिइलिस उत्तर , 66 बाइट्स

(d C(q((Q V)(i Q(i(l Q 0)0(i V(s(C(s Q(h V))V)(s 0(C Q(t V))))0))1

पुनरावर्ती समाधान: पहले सिक्के का उपयोग करने की कोशिश करता है और पहले सिक्के का उपयोग नहीं करता है, फिर प्रत्येक से परिणाम जोड़ता है। घातीय समय जटिलता और कोई पूंछ-पुनरावृत्ति, लेकिन यह परीक्षण के मामलों की गणना ठीक है।

अघोषित (बिल्डिंस की कुंजी: d= परिभाषित, q= बोली, i= यदि, l= कम-से-कम, s= घटाना, h= सिर, t= पूंछ):

(d combos
 (q
  ((amount coin-values)
   (i amount
    (i (l amount 0)
     0
     (i coin-values
      (s
       (combos
        (s amount (h coin-values))
        coin-values)
       (s
        0
        (combos
         amount
         (t coin-values))))
      0))
    1))))

उदाहरण का उपयोग:

tl> (d C(q((Q V)(i Q(i(l Q 0)0(i V(s(C(s Q(h V))V)(s 0(C Q(t V))))0))1
C
tl> (C 12 (q (1 5 10)))
4
tl> (C 26 (q (1 5 10 25)))
13
tl> (C 19 (q (2 7 12)))
2
tl> (C 13 (q (2 8 25)))
0
tl> (C 400 (q (1 5 10 25)))
Error: recursion depth exceeded. How could you forget to use tail calls?!

— DLosc
स्रोत

1

PHP, 130 बाइट्स

function r($n,$a){if($c=$a[0])for(;0<$n;$n-=$c)$o+=r($n,array_slice($a,1));return$o?:$n==0;}echo r($argv[1],array_slice($argv,2));

99 बाइट पुनरावर्ती कार्य (और इसे कॉल करने के 31 बाइट्स) जो लक्ष्य से वर्तमान सिक्के के मूल्य को बार-बार हटाता है और नए मूल्य और अन्य सिक्कों के साथ खुद को कॉल करता है। लक्ष्य 0 पर पहुंचने के समय की संख्या को ठीक से गिनता है। जैसे भागो:

 php -r "function r($n,$a){if($c=$a[0])for(;0<$n;$n-=$c)$o+=r($n,array_slice($a,1));return$o?:$n==0;}echo r($argv[1],array_slice($argv,2));" 12 1 5 10

— user59178
स्रोत

अगर इसे 97 से अधिक विभिन्न प्रकार के सिक्कों के साथ कहा जाता है, तो यह बिना कुछ लौटाए एक पुनरावृत्ति मृत्यु को समाप्त कर देगा, लेकिन जब तक कि सिक्के के विभिन्न प्रकार हैं, तब तक हमें इसका समर्थन करना होगा।

— user59178

1

रैकेट 275 बाइट्स

(set! l(flatten(for/list((i l))(for/list((j(floor(/ s i))))i))))(define oll'())(for((i(range 1(add1(floor(/ s(apply min l)))))))
(define ol(combinations l i))(for((j ol))(set! j(sort j >))(when(and(= s(apply + j))(not(ormap(λ(x)(equal? x j))oll)))(set! oll(cons j oll)))))oll

Ungolfed:

(define(f s l)
  (set! l              ; have list contain all possible coins that can be used
        (flatten
         (for/list ((i l))
           (for/list ((j              
                       (floor
                        (/ s i))))
             i))))
  (define oll '())                    ; final list of all solutions initialized
  (for ((i (range 1  
                  (add1
                   (floor             ; for different sizes of coin-set
                    (/ s
                       (apply min l)))))))
    (define ol (combinations l i))          ; get a list of all combinations
    (for ((j ol))                           ; test each combination
      (set! j (sort j >))
      (when (and
             (= s (apply + j))              ; sum is correct
             (not(ormap                     ; solution is not already in list
                  (lambda(x)
                    (equal? x j))
                  oll)))
        (set! oll (cons j oll))             ; add found solution to final list
        )))
  (reverse oll))

परिक्षण:

(f 4 '[1 2])
(println "-------------")
(f 12 '[1 5 10])
(println "-------------")
(f 19 '[2 7 12])
(println "-------------")
(f 8 '(1 2 3))

आउटपुट:

'((2 2) (2 1 1) (1 1 1 1))
"-------------"
'((10 1 1) (5 5 1 1) (5 1 1 1 1 1 1 1) (1 1 1 1 1 1 1 1 1 1 1 1))
"-------------"
'((12 7) (7 2 2 2 2 2 2))
"-------------"
'((3 3 2) (2 2 2 2) (3 2 2 1) (3 3 1 1) (2 2 2 1 1) (3 2 1 1 1) (2 2 1 1 1 1) (3 1 1 1 1 1) (2 1 1 1 1 1 1) (1 1 1 1 1 1 1 1))

पुनरावर्ती समाधान के बाद कुछ त्रुटि हुई है:

(define (f s l)                      ; s is sum needed; l is list of coin-types
  (set! l (sort l >))
  (define oll '())                   ; list of all solution lists
  (let loop ((l l)   
             (ol '()))               ; a solution list initialized
    (when (not (null? l))
        (set! ol (cons (first l) ol)))
    (define ols (apply + ol))        ; current sum in solution list
    (cond
      [(null? l) (remove-duplicates oll)]
      [(= ols s) (set! oll (cons ol oll))
                 (loop (rest l) '()) 
                 ]
      [(> ols s) (loop (rest l) (rest ol))
                 (loop (rest l) '())   
                 ]
      [(< ols s) (loop l ol) 
                 (loop (rest l) ol)
                 ])))

इसके लिए ठीक से काम नहीं करता है:

(f 8 '[1 2 3])

आउटपुट:

'((1 1 1 2 3) (1 2 2 3) (1 1 1 1 1 1 1 1) (2 3 3) (1 1 1 1 1 1 2) (1 1 1 1 2 2) (1 1 2 2 2) (2 2 2 2))

(1 1 3 3) संभव है लेकिन समाधान सूची में नहीं आता है।

— rnso
स्रोत

मैं रैकेट से परिचित नहीं हूं, लेकिन मैंने कुछ साल पहले इसी तरह की समस्या के लिए क्लोजर में एक समाधान लिखा था, जिसका उपयोग किया गया थाreduce

— मील

'कम' बेस रैकेट भाषा का हिस्सा नहीं है, हालांकि 'फोल्ड' उपलब्ध है। मैंने ऊपर दिए गए संशोधित समाधान को जोड़ा है क्योंकि पहले के समाधान में कुछ त्रुटि है।

— rnso

ऐसा लगता है कि लिस्प उत्साही लोगों का एक समूह एक साथ मिल गया ... और एक रैकेट बना दिया

— जो

1

लिस्प के कुछ उत्साही लोगों ने सबसे पहले एक Scheme( group.csail.mit.edu/mac/projects/scheme ) बनाया, जिसके कारण आखिरकार फुल- ब्लोइंगRacket ( रैकेट- lang.org , stackoverflow.com/questions/333397/… ) हो गई!

— rnso

1

जेली , 15 बाइट्स

s+\Fṁḷ
2*BW;ç/Ṫ

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें।

यह बिली का उपयोग किए बिना जेली में एक कुशल संस्करण लिखने के लिए एक अभ्यास के अधिक था। यह परिवर्तन करने के तरीकों की संख्या की गणना करने के लिए उपयोग किए जाने वाले विशिष्ट गतिशील प्रोग्रामिंग दृष्टिकोण पर आधारित है

व्याख्या

s+\Fṁḷ  Helper link. Input: solutions S, coin C
s       Slice the solutions into non-overlapping sublists of length C
 +\     Cumulative sum
   F    Flatten
     ḷ  Left, get S
    ṁ   Mold the sums to the shape of S

2*BW;ç/Ṫ  Main link. Input: target T, denominations D
2*        Compute 2^T
  B       Convert to binary, creates a list with 1 followed by T-1 0's
          These are the number of solutions for each value from 0 to T
          starting with no coins used
   W      Wrap it inside another array
    ;     Concatenate with D
     ç/   Reduce using the helper link
       Ṫ  Tail, return the last value which is the solution

— मील की दूरी पर
स्रोत

1

दरअसल , 15 बाइट्स

गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

╗;R`╜∙♂S╔♂Σi`Mc

Ungolfing

         Implicit input n, then the list of coins a.
╗        Save a to register 0.
;R       Duplicate n and create a range [1..n] from that duplicate.
`...`M   Map the following function over that range. Variable i.
  ╜        Push a from register 0.
  ∙        Push the i-th Cartesian power of a.
  ♂S       Sort each member of car_pow.
  ╔        Uniquify car_pow so we don't count too any duplicate coin arrangements.
  ♂Σ       Take the sum of each coin arrangement.
  i        Flatten the list.
c        Using the result of the map and the remaining n, push map.count(n).
         Implicit return.

— Sherlock9
स्रोत

0

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

from itertools import*
lambda t,L:[sum(map(lambda x,y:x*y,C,L))-t for C in product(range(t+1),repeat=len(L))].count(0)

लक्ष्य मान तक सिक्कों के सभी संयोजनों के माध्यम से Bruteforces (भले ही सबसे छोटा 1 नहीं है)।

— कार्ल नेफ
स्रोत

एक पैसा बचाया एक पैसा है

...गिना हुआ!

जेली ( कांटा ), 2 बाइट्स

प्रयोग

व्याख्या

हास्केल, 37 34 बाइट्स

गणितज्ञ, 35 22 बाइट्स

पायथ, 8 बाइट्स

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

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

पर्ल, 45 बाइट्स

जेली , 10 9 बाइट्स

कैसे?

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

PHP, 327 बाइट्स

Axiom, 63 62 बाइट्स

आर, 81 76 63 बाइट्स

जे, 27 बाइट्स

प्रयोग

व्याख्या

TSQL, 105 बाइट्स

टिनिइलिस उत्तर , 66 बाइट्स

PHP, 130 बाइट्स

रैकेट 275 बाइट्स

जेली , 15 बाइट्स

व्याख्या

दरअसल , 15 बाइट्स

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