मेला राजा के लिए आठ सिक्के

Question

यह एक और पहेली का "प्रतिपक्ष" है, पज़लिंग पर मेले के राजा के लिए आठ सिक्के ।

आप पृष्ठभूमि के लिए उपरोक्त पहेली पढ़ सकते हैं। इस पहेली के बारे में विवरण इस प्रकार है।

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

उदाहरण के लिए, (ग्लोरफिंडेल के उत्तर से लिया गया)। यदि मान 1, 2, 5, 13, 34, 89, 233, 610 के सिक्कों का एक सेट दिया गया है, तो आपके प्रोग्राम को 1596 का उत्पादन करना चाहिए, क्योंकि 0 और 1596 (समावेशी) के बीच के प्रत्येक नंबर को और अधिक के योग द्वारा दर्शाया जा सकता है। दी गई सूची से 8 नंबर (संख्या दोहरा सकते हैं), जबकि 1597 को उस तरह से प्रतिनिधित्व नहीं किया जा सकता है।

गणितीय तरीके से, यदि इनपुट एक सेट S है जिसमें 8 धनात्मक पूर्णांक होते हैं, तो वांछित आउटपुट N संतुष्ट करता है कि 0 और N के बीच किसी भी संख्या n के लिए , X1, x2, x3, ..., x8 मौजूद है जैसे कि

$$x_1 + x_2 + ... + x_8 = n \quad\textrm{and}\quad x_1, x_2, ...,x_8 \in \{0\} \cup S$$

आपका लक्ष्य एक प्रोग्राम, एक फ़ंक्शन या एक स्निपेट लिखना है जो इनपुट के रूप में 8 नंबर लेता है, और ऊपर वर्णित अधिकतम एन आउटपुट करता है।

नियम:

• लचीले I / O की अनुमति है, इसलिए आपका कार्यक्रम किसी भी रूप में इनपुट ले सकता है जो सबसे उपयुक्त है। आप मान सकते हैं कि इनपुट नंबर उस तरह से हल किए गए हैं जो आपके प्रोग्राम के लिए सबसे उपयुक्त हैं।
  • यदि आपका प्रोग्राम इनपुट ऑर्डर पर निर्भर करता है, तो कृपया इसे अपने उत्तर में बताएं
• इनपुट 8 अलग, सकारात्मक पूर्णांक (शून्य नहीं) का एक सेट है। आउटपुट एक गैर-नकारात्मक पूर्णांक है।
  • यदि इनपुट सेट में कोई 1 नहीं है, तो आपके प्रोग्राम का आउटपुट 0 होना चाहिए क्योंकि 0 से 0 तक की कोई भी संख्या आवश्यकता को पूरा करती है।
  • अमान्य इनपुट (सेट में शून्य, ऋणात्मक या डुप्लिकेट नंबर) के मामले में, आपका प्रोग्राम कुछ भी कर सकता है।
• मानक खामियों को मना किया जाता है।
• आपका प्रोग्राम आधुनिक कंप्यूटर पर कुछ मिनटों के भीतर चलना चाहिए।

टेस्ट केस (ज्यादातर पज़लिंग पर जुड़े प्रश्न के उत्तर से लिए गए):

[1, 2, 3, 4, 5, 6, 7, 8] => 64
[2, 3, 4, 5, 6, 7, 8, 9] => 0
[1, 3, 4, 5, 6, 7, 8, 9] => 72
[1, 2, 5, 13, 34, 89, 233, 610] => 1596
[1, 5, 16, 51, 130, 332, 471, 1082] => 2721
[1, 6, 20, 75, 175, 474, 756, 785] => 3356

यह एक कोड-गोल्फ है , इसलिए प्रत्येक भाषा में सबसे छोटा कार्यक्रम या स्निपेट जीतता है!

Comments

अच्छी पहेली, लेकिन मुझे व्यक्तिगत रूप से लगता है कि कुछ और परीक्षण मामले हमारे प्रस्तुतियाँ का परीक्षण करने में सहायक होंगे।

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

क्या इनपुट आकार को एक पैरामीटर बनाना बेहतर नहीं होगा? ब्रूट फोर्स एप्रोच 8 से संघर्ष करेंगे

— लुइस मेंडू

@ आईबग तो सामान्य नियम कुछ ऐसा है जैसे "आधुनिक कंप्यूटर में एक मिनट के भीतर सबमिशन शड रन"। यह फजी है, लेकिन आमतौर पर काफी अच्छा है, क्योंकि जानवर बल और कुशल दृष्टिकोण के बीच अंतर बहुत बड़ा है

— लुइस मेंडू

जानवर बल अभी भी "कुछ मिनट" की आपकी समय सीमा के साथ संभव है। मेरे उत्तर का थोड़ा संशोधित संस्करण मेरे 7 साल पुराने लैपटॉप पर 1m20 में अंतिम परीक्षण केस चलाता है।

— नीमी

@ अरनल्ड क्लेरिफाइड

— iBug

Answer 1

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

for i in[1]*3:x|={a+b for a in x for b in x}
while{i+1}&x:i+=1

यहाँ xएक सेट के रूप में इनपुट है, और iआउटपुट है।

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

(साभार: एरिक द आउटगोलर, मिस्टर एक्सकोडर, लिन)

Comments

96 बाइट्स ।

— १g को

x=0,*x1 बाइट बचाता है। बेहतर अभी तक, x+=0,2 बचाता है।

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

पायथन में 78 बाइट्स 2.

— लिन 15

Answer 2

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

œċⱮ8Ẏ§ṢQJƑƤS

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

मेरे फोन पर टीआईओ पर सभी परीक्षण मामलों को चलाने के लिए औसत ~ 3.7 सेकंड लगते हैं, इसलिए आश्चर्यजनक रूप से यह काफी तेज है।

व्याख्या

œċⱮ8Ẏ§ṢQJƑƤS     Monadic link / Full program.
  Ɱ8             Promote 8 to [1 ... 8] and for each value k:
œċ                    Generate all combinations of k elements from the list.
    Ẏ§           Tighten, then sum. Flatten to a 2D list then sum each.
      ṢQ         Sort the result and remove equal entries.
        JƑƤ      For each prefix of this list, return 1 if it is equal to its length range, 0 otherwise.
           S     Finally, sum the result (counts the 1's which is equivalent to what is being asked).

Answer 3

हास्केल, 56 50 बाइट्स

g c=[x|x<-[1..],all((/=x).sum)$mapM(0:)$c<$c]!!0-1

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

एक जानवर बल दृष्टिकोण। 0सिक्कों की सूची में जोड़ें और 8 पिक्स के सभी संयोजनों का प्रयास करें। पहला नंबर खोजें जो nकिसी भी पिक्स के योग के बराबर न हो और वापस लौट आए n-1।

[1, 2, 5, 13, 34, 89, 233, 610]मेरे 7 साल पुराने लैपटॉप हार्डवेयर के लिए लगभग 5m30s लेता है ।

संपादित करें: -6 बाइट्स @ अर्जन जोहान्सन को धन्यवाद

एक छोटा संस्करण (-2 बाइट्स, फिर से @ Johanrjan जोहानसन के लिए धन्यवाद) है

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

g c=[x|x<-[1..],all((/=x).sum)$mapM(:0:c)c]!!0-1

लेकिन यह काफी अधिक मेमोरी का उपयोग करता है और मेरी मशीन पर भारी पेजिंग में चलता है और "कुछ ही मिनटों में" खत्म नहीं होता है।

Comments

आप उपयोग कर सकते हैं mapM(0:)$c<$c। (वास्तव में mapM(:0:c)cकाम करना चाहिए, लेकिन दिए गए टेस्ट केस के लिए TIO पर कई बार आउट होना चाहिए।)

— अर्जन जोहान्सन

Answer 4

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

Żœċ8§ḟ’$Ṃ

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

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

Żœċ8§ḟ’$Ṃ  Main link. Argument: A (array)

Ż          Prepend a 0 to A.
 œċ8       Take all combinations of length 8, with repetitions.
    §      Take the sum of each combination.
       $   Combine the two links to the left into a monadic chain.
      ’      Decrement all sums.
     ḟ       Filterfalse; keep only sums that do not appear in the decremented sums.
        Ṃ  Take the minimum.

Comments

Żṗ8§ḟ’$Ṃएक बाइट बचाता है, लेकिन मुझे यकीन नहीं है कि 8.5 मिनट के रूप में कुछ गिना जाता है ।

— डेनिस

Answer 5

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 53 बाइट्स

LengthWhile[CoefficientList[(1+Tr[x^#])^8,x],#>0&]-1&

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

Answer 6

जावास्क्रिप्ट (ईएस 6),  100 88 80  76 बाइट्स

यह अनिवार्य रूप से एक जानवर-बल खोज है, लेकिन इसे गति देने के लिए छंटाई के साथ बढ़ाया गया है। परीक्षण मामलों के लिए औसत निष्पादन समय TIO पर 1 सेकंड के करीब है।

मान लेता है कि इनपुट सरणी उच्चतम से सबसे कम तक क्रमबद्ध है।

a=>[...Array(a[0]*9)].findIndex(g=(i=8,s)=>s*i>0?a.every(x=>g(i-1,s-x)):s)-1

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

टिप्पणी की गई

a =>                      // a[] = input array
  [...Array(a[0] * 9)]    // create an array of 9 * max(a) entries
  .findIndex(             // find the position of the first truthy result
    g = (i = 8, s) =>     // g = recursive function taking a counter i, initialized to 8
                          //     and a sum s, initialized to the position in the above array
      s * i > 0 ?         //   if s is positive and i is not equal to 0:
        a.every(x =>      //     for each value x in a[]:
          g(i - 1, s - x) //       do a recursive call with i - 1 and s - x
        )                 //     end of every()
      :                   //   else:
        s                 //     yield s (s = 0 means success and makes findIndex go on)
  ) - 1                   // end of findIndex(); decrement the result

Answer 7

पायथन 2 , 145 बाइट्स

from itertools import*
x=set(map(sum,reduce(chain,map(combinations_with_replacement,[input()]*9,range(9)))))
print~-min(set(range(1,max(x)+2))-x)

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

Answer 8

परी / जीपी , 57 बाइट्स

a->n=-1;while(polcoeff((1+sum(i=1,8,x^a[i]))^8,n++),);n-1

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

Comments

क्या यह जनरेटिंग फंक्शन का उपयोग कर रहा है?

— उज्जवल

@donbright हाँ।

— एलेफाल्फा

यह कमाल है .. कुछ जवाबों में से एक समाधान के लिए मजबूर नहीं करता है। भाषाओं का एक बहुत शायद बहुपद प्रतीकात्मक सुविधाओं में नहीं बनाया है। परी जीपी मस्त है।

— उज्ज्वल

Answer 9

पायथन 2 , 125 115 111 बाइट्स

lambda c:sum(i==j for i,j in enumerate(sorted(set(map(sum,product([0]+c,repeat=8))))))-1
from itertools import*

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

इनपुट के रूप में पूर्णांकों की सूची की अपेक्षा करता है।

स्पष्टीकरण:

# an anonymous function
lambda c:
                                                          # get all length-8 combinations of values, from (0,0,0,0,0,0,0,0) to (8,8,8,8,8,8,8,8)
                                                          # zero is added to ensure that combinations of fewer than 8 coins are represented Ex:(1,0,0,0,0,0,0,0)
                                                          product([0]+c,repeat=8)
                                                  # for each combination, sum the values
                                                  map(sum,.......................)
                                       # get unique values, then sort them smallest to largest
                                       sorted(set(................................))
             # for each index, value pair, return if the index is equal to the value
             i==j for i,j in enumerate(.............................................)
         # in Python arithmetic, False is 0 and True is 1. So, count how many items match their index.
         # Since zero was added to the list, there will always be one extra match (0==0). So offset by one.
         sum(........................................................................)-1
from itertools import*

Answer 10

पर्ल 6, 65 63 41 बाइट्स ( 39 37 चार्ट )

{@_=(0,|@_)X+(0,|@_)for ^3;($_ if $_==$++for @_.sort.unique)-1}

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

यह एक अनाम ब्लॉक है जो एक सरणी के रूप में अपना डेटा पास करता है। (0,|@_)एक त्वरित तरीका एक जोड़ने के लिए है 0करने के लिए @_, और भले ही यह दो बार किया है, यह अभी भी एक सा से कम है @_.push: 0;जो तब के बाद रिक्त स्थान की आवश्यकता होगी _। यह एक क्रूर बल दृष्टिकोण है जो इस तथ्य पर थोड़ा सा चीज करता है कि यह 8 संयोजन है। क्रॉस जोड़ने के बाद, अनुक्रमिक मूल्यों के लिए एक अनाम सूची बनाई जाती है। गणित संचालकों के साथ, सूची उनकी लंबाई का मूल्यांकन करती है, इसलिए -1 दोहरी ड्यूटी खींचती है: 0 के लिए लेखांकन और इंट के लिए जोर।

यह इसका मीठा समय ले सकता है, लेकिन पहले एक या दोनों (0,|@_)को बदलकर इसे काफी हद तक खत्म किया जा सकता है। यदि आप पहली बार बहुत धीमा महसूस करते हैं तो स्कोर में +7 (रनटाइम <60s) या +14 (रनटाइम <10s) जोड़ता है (मैंने 60 सेकंड के बाद टाइमआउट से बचने के लिए लिंक किए गए कोड के लिए ऐसा किया था)।(0,|@_.unique)for

संपादित करें: टिप्पणियों में जोकिंग ने इसमें सुधार किया (एक ही विचार, क्रॉस ऐड, फिर अंतिम लगातार परिणाम) एक आश्चर्यजनक 39 वर्णों (41 बाइट्स) के लिए:

{(@_=@_ X+0,|@_)xx 3;first *+1∉@_,^∞}

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

अंतिम सारणीकरण को 0 की आवश्यकता नहीं है, केवल एक बार में 0 को जोड़ने के लिए कुछ बाइट्स को बचाकर। xx 3पाश के लिए की नकल करता है (अब भी सिक्के 2 के एक शक्ति होने पर चीज)। firstउप रिटर्न अनंत सूची में पहले नंबर 0..*( ^Infभी संभव है, लेकिन अंतरिक्ष को बचाने नहीं करता है) जिसका +1पार जोड़ा सूची का सदस्य नहीं है। मेरी तरह, यह धीमा है, इसलिए पहले 7 के uniqueबाद +7 जोड़ें यदि आपको लगता है कि यह दिशानिर्देशों के लिए बहुत धीमा है।

Comments

48 बाइट्स । तकनीकी रूप से, इसकी uniqueआवश्यकता नहीं है, लेकिन यह इसे बहुत तेज करता है

— जो किंग

@ अच्छा, मुझे नहीं पता कि मैं का उपयोग करने के बारे में क्यों नहीं सोचा xx। मुझे पता था कि सेट फ़ंक्शंस का उपयोग करके बहुत कम तरीके से अंतिम सारणीकरण करने का एक तरीका होना चाहिए, लेकिन मेरा दिमाग काम नहीं कर रहा था।

— user0721090601

xx 1होना चाहिएxx 3

— जो राजा

@ जॉकिंग तय इसके अलावा मुझे एहसास हुआ कि दो चार (लेकिन कोई बाइट्स) का उपयोग करके बचाया जा सकता है^∞

— user0721090601

वास्तव में, आप (1...*∉@_)-1उपयोग करने के बजाय कुछ बाइट्स को बचा सकते हैं first, (जो मुझे पता है कि वही तरीका है जो मैंने यहां इस्तेमाल किया है )

— जो किंग

Answer 11

जावास्क्रिप्ट (Node.js) , 171 145 115 बाइट्स

f=(s,n=3)=>n?f(s=new Set(a=[0,...s]),n-1,a.map(m=>a.map(n=>s.add(m+n)))):Math.min(...[...s].filter(m=>!s.has(m+1)))

इसे ऑनलाइन आज़माएं! पोर्ट ऑफ @ मार्क पायथन 3 उत्तर। फ़ायरफ़ॉक्स में 108 बाइट्स 30-57:

f=(s,n=3)=>n?f(new Set((for(n of s=[0,...s])for(m of s)n+m)),n-1):Math.min(...[...s].filter(m=>!s.has(m+1)))

Answer 12

वोल्फ्राम भाषा (गणितज्ञ) , 46 बाइट्स

0//.x_/;Min[Tr/@FrobeniusSolve[#,x+1]]<9:>x+1&

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

जानवर बल दृष्टिकोण: पूर्णांकों की गिनती की जाँच करता है जब तक कि यह एक मूल्य तक नहीं पहुंचता है जो 8 सिक्कों के लिए भुगतान नहीं किया जा सकता है। बहुत, बहुत धीमा (टियो टाइम आउट), लेकिन मुझे यकीन है कि हालत सही है।

Answer 13

क्लीन , 161 बाइट्स

import StdEnv,Data.List
$l=:[1:_]#k=sort(nub(map sum(iter 8(concatMap(\[h:t]=[[e,h:t]\\e<-[0:l]|e>=h]))[[0]])))
=length(takeWhile((>=)1)(zipWith(-)(tl k)k))
$_=0

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