संख्या की न्यूनतम संख्या बिल्कुल n तक योग करने के लिए

Question

यहां पहला सवाल, अगर यह डुप्लिकेट या बुरी चुनौती है तो मुझ पर चिल्लाओ मत।

परिचय

मैंने खुद इस चुनौती के बारे में सोचा, और यह शुरुआती कोड-गोल्फरों के लिए एक अच्छी बुनियादी पहेली लगती है। यह मुझे यह तय करने में भी मदद कर सकता है कि कौन सी कोड-गोल्फिंग भाषा सीखनी है।

चुनौती

पूर्णांकों की एक ऐसी सरणी को देखते हुए जो nआउटपुट के बराबर या उससे कम होती है , उस सरणी से न्यूनतम संख्याओं की संख्या वापस करती है जो बिलकुल योग करती है n।

आप एक फ़ंक्शन या पूर्ण प्रोग्राम लिखना चुन सकते हैं।

इनपुट

आप सुरक्षित रूप से मान सकते हैं 0 <= n < 2^31।

किसी भी प्रकार की एक सरणी या सूची ( vectorC ++ या जावा के LinkedListलिए अनुमति दी जाती है), साथ में nऔर एक वैकल्पिक पैरामीटर लें length, जो सरणी की लंबाई को निर्दिष्ट करता है।

आप इनपुट को स्पेस-सेपरेटेड स्ट्रिंग के रूप में भी ले सकते हैं, nजो कॉमा या स्पेस से अलग होता है:

1 5 7 3 7 3 6 3 2 6 3,10

1 5 7 3 7 3 6 3 2 6 3 10

अगर यह आसान है।

उत्पादन

आउटपुट, या उस सरणी से न्यूनतम संख्याओं को वापस लौटाएं जो बिल्कुल योग करते हैं n। उपरोक्त उदाहरण का उपयोग करना:

1 5 7 3 7 3 6 3 2 6 3,10

आपका कार्यक्रम प्रिंट होना चाहिए:

2

क्योंकि संख्या की न्यूनतम संख्या है कि अप करने के लिए योग 10है 2( 7और 3)।

इस मामले में कि कोई समाधान नहीं है, एक नकारात्मक प्रिंट, या वापस लौटें 0, "कोई समाधान नहीं" (हालांकि वह स्मार्ट नहीं होगा), ∞(जैसा कि सुझाव दिया गया है), या किसी भी अन्य झूठा मूल्य, एक खाली स्ट्रिंग के अपवाद के साथ।

उदाहरण इनपुट और आउटपुट

इनपुट:

1 5 7 3 7 3 6 3 2 6 3,10
143 1623 1646 16336 1624 983 122,18102
5 6 9,12

आउटपुट:

2
3
-1

स्कोरिंग

यह कोड-गोल्फ है, इसलिए बाइट्स जीत में सबसे छोटा कोड है।

शीर्ष उत्तर क्रिसमस पर स्वीकार किया जाएगा।

Comments

मैंने आपकी कल्पना को संपादित किया है, क्योंकि हम आम तौर पर फ़ंक्शन और कार्यक्रमों के लिए समान I / O विधियों की अनुमति देते हैं; यहां सर्वसम्मति देखें । असहमत होने पर वापस लुढ़कने के लिए स्वतंत्र महसूस करें।

— lirtosiast

क्या हम falseबिना समाधान वाले मामलों के लिए आउटपुट दे सकते हैं?

— ETHproductions

@ETHproductions ज़रूर, वह जोड़ देगा।

— कॉफ़ीअप

क्या आप खाली आउटपुट फाल्सी पर विचार करते हैं, क्योंकि पाइथ में खाली स्ट्रिंग गलत है?

— lirtosiast

@ThomasKwa मुझे खाली स्ट्रिंग आउटपुट पसंद नहीं है, लेकिन आप इसे अपने उत्तर में "अगर x की अनुमति दी गई ..." के रूप में शामिल कर सकते हैं ...

— TheCfishCup

Answer 1

पायथ, 12 11 बाइट्स

lhafqsTQyEY

यह nइनपुट की पहली पंक्ति और दूसरी पंक्ति की सूची के रूप में लेता है ।

lhafqsTQyEY     (Implicit: Q = 1st line of input; E = 2nd line)
         E      The list
        yE      Powerset (sorted by increasing length; empty set first)
   f            Filter by lambda T:
     sT         sum(T)
    q                  ==
       Q                  Q
   fqSTQyE      Sublists that sum to Q, sorted by increasing length
  a       Y     append an empty array (in case none match)
lh              take the length of the first element (0 for empty array)

इसे यहाँ आज़माएँ ।

Comments

आपका कोड और आपका स्पष्टीकरण मेल नहीं खाते हैं।

— इसहाक

@ आइसाकग नाउ फिक्स्ड।

— lirtosiast

Answer 2

जाप , 30 21 18 बाइट्स

पता चला कि एक बहुत अधिक कुशल तरीका था। ;)

Uà f_x ¥V} ml n- g

इसे ऑनलाइन टेस्ट करें! (नोट: संगतता कारणों n-से बदल दिया गया n@X-Y}है)

यह एक स्थान के रूप में इनपुट लेता है- या अल्पविराम से अलग किया गया सरणी, इसके बाद एक नंबर। undefinedसमाधान के बिना परीक्षण मामलों के लिए आउटपुट ।

Uà f_  x ¥ V} ®   l} n- g
UàfmZ{Zx ==V} mZ{Zl} n- g

            // Implicit: U = input array, V = input integer
Uà fZ{   }  // Generate all possible combinations of U, then filter to only items Z where
Zx ==V      //   the sum of Z is equal to V.
mZ{Zl}      // Map each remaining combination to its length.
n-          // Sort by subtraction; smaller items end up in the front.
g           // Take the first item.
            // Implicit: output last expression

मैं विश्वास नहीं कर सकता कि मैंने इस संस्करण के बारे में नहीं सोचा था जब मैंने मूल रूप से यह लिखा था ...

तब से कई अनुकूलन किए गए हैं जो यहाँ काम आते हैं:

• एक Uकार्यक्रम की शुरुआत में आम तौर पर बाहर छोड़ दिया जा सकता है।
• Ãके लिए एक शॉर्टकट है } ।
• n अब डिफ़ॉल्ट रूप से संख्याओं को ठीक से टाइप करें।

इनमें से प्रत्येक कुल 15 के लिए बाइट लेता है:

à f_x ¥VÃml n g

इसे ऑनलाइन टेस्ट करें!

Comments

यह 25 बाइट्स है, 21 नहीं।

— अल्बर्ट रेनशॉ

@AlbertRenshaw Japt IEC_8859-1 एन्कोडिंग का समर्थन करता है , जिसके तहत इनमें से प्रत्येक वर्ण 1 बाइट है। आप इस प्रोग्राम को IEC_8859-1-एन्कोडेड टेक्स्ट फ़ाइल के रूप में सहेज सकते हैं, फिर इसे ऑनलाइन इंटरप्रेटर पर अपलोड कर सकते हैं ।

— ETHproductions

बहुत सुंदर! मुझे सूचित करने के लिए धन्यवाद

— अल्बर्ट रेनशॉ

Answer 3

मैथेमेटिका, 73 65 बाइट्स

Min[Length/@Select[IntegerPartitions[#2,#2,#],Sort@#==Union@#&]]&

शुद्ध फ़ंक्शन, ∞यदि कोई समाधान नहीं है तो रिटर्न करता है।

Answer 4

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

यह उतना नहीं है जितना कि मैं इसे पसंद करूंगा, लेकिन बाद में इस पर काम करूंगा।

from itertools import*
def s(a,n):
 for i in range(len(a)):
  for j in permutations(a,i+1):
   if sum(j)==n:return i+1
 return 0

Answer 5

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

Min@Cases[Subsets@#,i_/;Tr@i==12:>Length@#2]&

Answer 6

CJam, 34 बाइट्स

0q~_,2,m*\f.*{:+1$=},\;0f-{,}$0=,+

इसे ऑनलाइन आज़माएं । इनपुट प्रारूप मानों की सूची के बाद का योग है, जैसे:

18102 [143 1623 1646 16336 1624 983 122]

ध्यान दें कि यदि कोई समाधान नहीं मिला है तो यह एक अपवाद को बढ़ाएगा। जब सीजेएम को कमांड लाइन से चलाया जाता है, तो अपवाद स्टैडर पर जाता है, और सही परिणाम ( 0) अभी भी स्टडआउट के लिए मुद्रित होता है। तो यह सर्वसम्मति से स्थापित होना चाहिए क्या सबमिशन को एक त्रुटि के साथ बाहर निकलने की अनुमति दी जानी चाहिए?

कोड आपकी अपेक्षा से अधिक लंबा हो सकता है। मुख्य कारण यह है कि सीजेएम के पास संयोजन बनाने के लिए कोई अंतर्निहित नहीं है। या कम से कम यह मेरा बहाना है, और मैं इसे चिपका रहा हूं।

स्पष्टीकरण:

0       Push 0 result for exception case.
q~      Get and interpret input.
_,      Copy and get length of input value list.
2,      Push [0 1].
m*      Cartesian power. This generates all possible lists of 0/1 values with the
        same length as the input value list.
\       Swap input value list to top.
f.*     Apply element-wise product of input value list with all 0/1 lists.
        We now have all combinations of values, with 0 in place of unused values.
{       Start filter block.
  :+      Sum values.
  1$      Copy target sum to top.
  =       Compare.
},      Filter.
\;      Swap target sum to top and discard.
0f-     Remove 0 values. We now have all solution lists.
{,}$    Sort by length.
0=      Get first solution, which after sorting is the shortest.
        This will raise an exception if the list of solutions is empty, bailing
        out with the initial 0 on the stack.
,       Get length of solution.
+       Add the 0 we initially pushed for the exception case.

Answer 7

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

f=(a,n,m=1e999,x)=>n&&a.map((v,i)=>(x=[...a],x.splice(i,1),x=f(x,n-v)+1)<m?m=x:0)&&m

व्याख्या

एक ले जाता है Arrayकी Numberहै और एक Numberतर्क के रूप में। Infinityकोई परिणाम नहीं होने पर कई रिटर्न देता है । यह एक पुनरावर्ती कार्य है जो nएक-एक करके सरणी से प्रत्येक तत्व को घटाता है और हटाता है n == 0।

f=(a,n,m=1e999,x)=> // m and x are not passed, they are here to declare them in the local
                    //     scope instead of globally, initialise m to Infinity
  n&&               // if n == 0, return 0
  a.map((v,i)=>     // iterate over each number in a
    (x=[...a],      // x = copy of a
    x.splice(i,1),  // remove the added number from the array
    x=f(x,n-v)+1)   // x = result for the numbers in this array
      <m?m=x:0      // set m to minimum result
  )
  &&m               // return m

परीक्षा

यह परीक्षण क्रोम में काम करने के लिए एक डिफ़ॉल्ट तर्क के बजाय बाद में सेट करता mहै Infinity(केवल फ़ायरफ़ॉक्स के बजाय)।

var solution = f=(a,n,m,x)=>n&&a.map((v,i)=>(x=[...a],x.splice(i,1),x=f(x,n-v)+1)<m?m=x:0,m=1e999)&&m

Array (space-delimited) = <input type="text" id="array" value="143 1623 1646 16336 1624 983 122" /><br />
n = <input type="number" id="N" value="18102" /><br />
<button onclick="result.textContent=solution(array.value.split` `,N.value)">Go</button>
<pre id="result"></pre>

Answer 8

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

import Data.List
n#l=head$sort[length x|x<-subsequences l,sum x==n]++[0]

0अगर कोई हल नहीं है तो लौटाता है ।

प्रयोग उदाहरण: 10 # [1,5,7,3,7,3,6,3,2,6,3]-> 2।

इनपुट सूची के सभी उप-सूचियों का पता लगाएं, lजिनका योग है n। प्रत्येक ऐसे उप-सूची और क्रमबद्ध की लंबाई लें। 0पहले एक तत्व को जोड़ें और लें।

यदि आउटपुट के लिए एकल सूची की अनुमति है, उदाहरण के लिए [2], हम 7 बाइट्स बचा सकते हैं: n#l=minimum[length x|x<-subsequences l,sum x==n] :। समाधान न होने की स्थिति में, खाली सूची []वापस कर दी जाती है।