पृष्ठभूमि

गोल्तेस्तान के काल्पनिक देश की आधिकारिक मुद्रा फू है , और प्रचलन में केवल तीन प्रकार के सिक्के हैं: 3 फ़ॉस्स, 7 फ़ॉस्स और 8 फ़ॉस्। एक व्यक्ति यह देख सकता है कि इन सिक्कों का उपयोग करके कुछ राशि का भुगतान करना संभव नहीं है, जैसे 4 फ़ॉज़। फिर भी, सभी बड़ी पर्याप्त मात्रा का गठन किया जा सकता है। आपका काम सबसे बड़ी राशि का पता लगाना है जो सिक्कों के साथ नहीं बन सकती है (इस मामले में 5 फोक्स), जिसे सिक्का समस्या के रूप में जाना जाता है ।

इनपुट

आपका इनपुट सकारात्मक पूर्णांक की एक सूची है, जो संचलन में सिक्कों के मूल्यों का प्रतिनिधित्व करता है। इसके बारे में दो बातों की गारंटी है:L = [n₁, n₂, ..., n_k]

के तत्वों का GCD L1 है।
L 1 नंबर शामिल नहीं है।

यह अनसोल्ड हो सकता है और / या डुप्लिकेट हो सकता है (विशेष संस्करण सिक्के सोचें)।

उत्पादन

चूंकि जीसीडी L1 है, इसलिए प्रत्येक बड़े पर्याप्त पूर्णांक mको इसके तत्वों के गैर-नकारात्मक रैखिक संयोजन के रूप में व्यक्त किया जा सकता है; दूसरे शब्दों में, हमारे पास है

 m = a₁*n₁ + a₂*n₂ + ... + a_k*n_k

कुछ पूर्णांकों के लिए । आपका आउटपुट सबसे बड़ा पूर्णांक है जिसे इस रूप में व्यक्त नहीं किया जा सकता है। एक संकेत के रूप में, यह ज्ञात है कि आउटपुट हमेशा से कम है , यदि और ( संदर्भ ) के अधिकतम और न्यूनतम तत्व हैं ।a_i ≥ 0(n₁ - 1)*(n_k - 1)n₁n_kL

नियम

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

जब मैंने इस चुनौती को पोस्ट किया, तो उपयोगकर्ता @vihan ने बताया कि स्टैक ओवरफ्लो का एक सटीक डुप्लिकेट है । इस मेटा चर्चा के आधार पर , इस चुनौती को डुप्लिकेट के रूप में हटाया नहीं जाएगा; हालाँकि, मैं पूछता हूं कि एसओ संस्करण के आधार पर सभी उत्तरों को मूल का हवाला देना चाहिए, सामुदायिक विकी का दर्जा दिया जाना चाहिए, और यदि मूल लेखक यहां अपना उत्तर पोस्ट करना चाहते हैं, तो उन्हें हटा दिया जाना चाहिए।

परीक्षण के मामलों

[3, 7, 8] -> 5
[25, 10, 16] -> 79
[11, 12, 13, 14, 13, 14] -> 43
[101, 10] -> 899
[101, 10, 899] -> 889
[101, 10, 11] -> 89
[30, 105, 70, 42] -> 383
[2, 51, 6] -> 49

code-golf number combinatorics

— Zgarb
स्रोत

6

FrobeniusNumberगणित में

— alephalpha

3

एक तरह से बेहतर ऊपरी बाध्य, में पाया है इस पत्र है कि स्थापित (p - 1)(q - 1)के रूप में ऊपरी बाध्य है, जहां pऔर qसेट की सबसे छोटी और सबसे बड़ी तत्व हैं।

— orlp

2

क्या रन टाइम या मेमोरी उपयोग की कोई सीमा है?

— डेनिस

1

स्टैक ओवरफ्लो पर थोड़ी देर पहले इस तरह का एक कोड गोल्फ प्रश्न था

— डाउनगेट

1

मेरे पास एक 13 बाइट्स पायथ समाधान है जो [2,3]उचित समय में कर सकता है और कुछ नहीं। [2,5]स्मृति में लगभग एक लाख पायथन सूची बनाएगा।

— इसहाक

4

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

ef!fqTs.b*NYQY^UTlQS*FQ

यह बहुत धीमा है, क्योंकि यह सभी सिक्कों के उत्पाद तक सभी मूल्यों की जांच करता है। यहां एक संस्करण है जो लगभग समान है, लेकिन 1) सिक्कों के सेट को कम करता है जो एक दूसरे से विभाज्य नहीं हैं और 2) केवल मानों की जांच करता है(max(coins) - 1) * (min(coins) - 1) (47 बाइट्स) :

=Qu?.A<LiHdG+GHGQYef!fqTs.b*NYQY^UTlQS*thSQteSQ

व्याख्या

                   S            range 1 to
                    *FQ         product of input
 f                             filter by
               UT                range 0 to T 
              ^  lQ              cartesian power by number of coins
   f                            filter by
      s.b*NYQY                   sum of coin values * amounts
    qT                           equals desired number T
  !                             nothing matching that filter
e                             take last (highest) element

— PurkkaKoodari
स्रोत

8

पर्ल, ६० 54 51 बाइट्स

50 बाइट्स कोड + 1 बाइट्स कमांड लाइन

$.*=$_,$r.=1x$_."|"}{$_=$.while(1x$.--)=~/^($r)+$/

गोल्फिंग करेंगे और बाद में स्पष्टीकरण देंगे। मूल दृष्टिकोण यह है कि रेगेक्स इंजन को स्ट्रिंग मिलान के साथ कड़ी मेहनत करने दें। उदाहरण के लिए, यह ^(.{3})*(.{7})*(.{8})*$लंबाई के एक तार के खिलाफ एक रेगेक्स के समान होगा और मैच करेगाn जहां nइनपुट के उत्पाद से उतरता है जब तक कि यह मेल नहीं खाता।

ध्यान दें कि जैसे-जैसे तर्क बढ़ते जाएंगे, यह तेजी से धीमा होता जाएगा।

उपयोग: तर्क STDIN (नई लाइन से अलग) से पढ़े जाते हैं, उदाहरण के लिए:

printf "101\n10" | perl -p entry.pl

— Jarmex
स्रोत

3

आर , 84 78 बाइट्स

$a_1, a_2,\ldots$

a=scan();max((1:(b<-min(a)*max(a)))[-colSums(combn(outer(a,0:b),sum(!!a)))])

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

$a_i$ outercolSums

एक तेज़ लेकिन अधिक लंबा (दो बाइट्स) संस्करण केवल मानता है max(a):

a=scan();max((1:(min(a)*(b<-max(a))))[-apply(combn(outer(a,0:b,"*"),sum(!!a)),2,sum)])

एक थोड़ा छोटा संस्करण (78 बाइट्स) कि सबसे अधिक बार लॉग ऑन भी या पर चलाने के लिए ले जाता है बहुत अधिक स्थान कोशिश करो ऑनलाइन है

a=scan();max((1:(b<-prod(a)))[-apply(combn(outer(a,0:b,"*"),sum(!!a)),2,sum)])

— शीआन
स्रोत

1

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

def g(L):
 M=max(L);i=r=0;s=[0]*M;l=[1]+s[1:]
 while 1:
    if any(all((l+l)[o:o+min(L)])for o in range(M)):return~-s[r]*M+r
    if any(l[(i-a)%M]for a in L):l[i]=1
    else:r=i
    s[i]+=1;i=(i+1)%M

दूसरा इंडेंटेशन एसओ पर 4 रिक्त स्थान के रूप में प्रस्तुत किया गया है, जिन्हें टैब होना चाहिए।

वास्तव में 'तेज' समाधान, क्रूरता नहीं, यहां वर्णित के रूप में 'विलफ मेथड' का उपयोग करता है ।

— orlp
स्रोत

1

जावास्क्रिप्ट ईएस 6, 120 130 126 128 127 125 चार्ट

f=a=>`${r=[1|a.sort((a,b)=>a-b)]}`.repeat(a[0]*a[a.length-1]).replace(/./g,(x,q)=>r[q]|a.map(x=>r[q+x]|=r[q])).lastIndexOf(0)

वैकल्पिक 126 चार्ट संस्करण:

f=a=>{r=[1];a.sort((a,b)=>a-b);for(q=0;q<a[0]*a[a.length-1];++q)r[q]?a.map(x=>r[q+x]=1):r[q]=0;return r.join``.lastIndexOf(0)}

परीक्षा:

"[3, 7, 8] -> 5\n\
[25, 10, 16] -> 79\n\
[11, 12, 13, 14, 13, 14] -> 43\n\
[101, 10] -> 899\n\
[101, 10, 899] -> 889\n\
[101, 10, 11] -> 89\n\
[30, 105, 70, 42] -> 383\n\
[2, 51, 6] -> 49".replace(/(\[.*?\]) -> (\d+)/g, function (m, t, r) {
  return f(JSON.parse(t)) == r
})

— Qwertiy
स्रोत

1

आप बदल सकते हैं forEach(के साथmap(

— Ypnypn

0

रूबी , 108 बाइट्स

->a{b=[0];m=a.min
(1..1.0/0).map{|n|c=p
a.map{|x|c|=(b!=b-[n-x])}
c&& b<<=n
return n-m if b[-m]&&b[-m]>n-m}}

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

व्याख्या

->a{                                         input list
    b=[0];                                      list of representable integers
        m=a.min                                     minimum input
    (1..1.0/0).map{|n|                       n in range 1..
        c=p                                    c = false
          a.map{|x|c|=(b!=b-[n-x])}              check if n goes in b
            c&& b<<=n                                   put n in b
              return n-m if b[-m]&&b[-m]>n-m}}            return if m values in a row

— सिंपल ब्यूटीफुल आर्ट
स्रोत