स्व-सम संख्या

Question

संख्याओं को अंकों के योग में बदलें

कोई राशि नहीं: हमें सबसे कम राशि की आवश्यकता है।
किसी भी अंक की नहीं: आप संख्या के केवल अंकों का उपयोग कर सकते हैं

उदाहरण
आपकोएक पूर्णांक इनपुट के रूप में दिया जाएगाn>0

चलिए बताते हैं n=27। आपको योग के27 रूप में व्यक्त करना होगा , केवल अंकों का उपयोग करके , कम से कम संभव तरीके से। आपको दिए गए नंबर के सभी अंकों का उपयोग करने की आवश्यकता नहीं है! [2,7]

तो 27=2+2+2+7+7+7। हम तो उन अंकों लेते हैं और उन्हें गिनती : [2,2,2,7,7,7]।
के लिए अंतिम उत्तर n=27है6

n=195सबसे कम राशि प्राप्त करने के लिए एक और उदाहरण के लिए हमें निम्नलिखित अंकों का उपयोग करना होगा:
[5,5,5,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9]और उत्तर है23

चुनौती

पूर्णांक को देखते हुए n>0, अंकों की न्यूनतम संख्या ( संख्या में समाहित) का उत्पादन होता है जो इस संख्या तक होता है

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

Input->Output

1->1  
2->1  
10->10  
58->8  
874->110  
1259->142  
12347->1765  
123456->20576  
3456789->384088  

यह कोड-गोल्फ है । बाइट्स जीत में सबसे शानदार जवाब!

Comments

क्या कोई संख्या है जो स्वयं को योग नहीं कर सकते हैं / क्या वे इनपुट होंगे?

— स्टीफन

@ स्टीफन वे सब कर सकते हैं!

@ स्टेफेन क्योंकि हर नंबर को d_0 + 10 * d_1 + 100 * d_2, आदि के रूप में व्यक्त किया जा सकता है ...

— geokavel

क्या हम इनपुट को स्ट्रिंग, चार-सरणी या पूर्णांक-सरणी के रूप में ले सकते हैं?

— केविन क्रूज़सेन

@ केविनक्रूजसेन स्ट्रिंग ठीक है। चार-सरणी या पूर्णांक-सरणी नहीं हैं।

Answer 1

भूसी , 12 बाइट्स

Lḟo=⁰ΣṁΠḣ∞d⁰

बहुत तेजी से दो अंकों की संख्या को संभालता है। इसे ऑनलाइन आज़माएं!

व्याख्या

Lḟo=⁰ΣṁΠḣ∞d⁰  Input is n, say n = 13.
          d⁰  Digits of n: [1,3]
         ∞    Repeat infinitely: [[1,3],[1,3],[1,3],[1,3]...
        ḣ     Prefixes: [[],[[1,3]],[[1,3],[1,3]],[[1,3],[1,3],[1,3]],...
      ṁ       Map and concatenate
       Π      Cartesian product: [[],[1],[3],[1,1],[3,1],[1,3],[3,3],[1,1,1],[3,1,1],...
 ḟo           Find the first element
     Σ        whose sum
   =⁰         equals n: [3,3,3,3,1]
L             Return its length: 5

Answer 2

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

lef!-TsM`Q./

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

दुर्भाग्य से यह इनपुट पर त्रुटियों के रूप में बड़े रूप में त्रुटि है 58।

व्याख्या

lef!-TsM`Q./
          ./    All lists of integers that sum to [the input]
  f             Filter for:
    -TsM`Q           Remove all occurrences of the digits in the input
   !                 Check if falsey (i.e. an empty list)
le              Length of the last occurrence, which is the shortest because all the
                filtered partitions share the same digit pool

Comments

क्या आप एक स्पष्टीकरण जोड़ना चाहेंगे?

— जोनाह

@ जोनाहा स्पष्टीकरण जोड़ा।

— नॉटजैगन

धन्यवाद। दिलचस्प है कि पायथ में एक आदिम है जो अनिवार्य रूप से समस्या को हल करता है./

— जोनाह

12-बाइट विकल्प: lef<.{TjQ;./(फिल्टर - उचित सबसेट - इनपुट अंकों का)

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

Answer 3

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

(t=1;While[(s=IntegerPartitions[x=#,t,IntegerDigits@x])=={},t++];Tr[1^#&@@s])&  

5 सेकंड में अंतिम परीक्षण केस पाता है

Comments

थोडा छोटा:Length@IntegerPartitions[#, All, Sort@DeleteCases[0]@IntegerDigits@#, 1][[1]] &

— Kuba

Answer 4

आर , 78 बाइट्स

function(n){while(all(F-n)){F=outer(F,n%/%10^(0:nchar(n))%%10,"+")
T=T+1}
T-1}

इसे ऑनलाइन आज़माएं! (गोल्फ संस्करण)

शुद्ध जानवर बल एल्गोरिथ्म, इसलिए यह वास्तव में सभी परीक्षण मामलों को हल नहीं करता है, और मुझे लगता है कि इसने अंतिम परीक्षण के लिए 40,000 जीबी आवंटित करने की कोशिश की ...

Tआर चूक में 1इसलिए हमें एक ऑफ-बाय-एक त्रुटि मिलती है Fजिसे हम रिटर्न स्टेप पर सही कर देते हैं, लेकिन हमें वह चूक भी मिल जाती है 0जिससे भुगतान करना बंद हो जाता है।

अपुष्ट विवरण:

function(n){
 d <- n%/%10^(0:nchar(n))%%10   # digit list with a 0 appended at end
 d <- unique(d[d>0])            # filter zeros (not technically necessary)
                                # and get unique digits
 x <- 0                         # storage for sums
 i <- 0                         # counter for number of sums done
 while(!any(x==n)){             # until we find a combination
  x <- outer(x,d,"+")           # take all sums of x and d, store as x
  i <- i + 1}                   # increment counter
i}                              # return counter

इसे ऑनलाइन आज़माएं! (कम गोल्फ संस्करण)

Answer 5

पायथन 2, 168 155 144 बाइट्स

यह सबसे छोटा नहीं हो सकता है, लेकिन यह सबसे अच्छा है-पहला और वास्तविक बुरा नहीं , रनटाइम वार।

n=input()
g=sorted(set(n)-{0})[::-1]
def h(k):
 if k<0:return
 if`k`in g:return 1
 for d in g:
  f=h(k-int(d))
  if f:return 1+f
print h(int(n)) 

filter(None...अंक के है, जो मुझे लगता है मैं जबकि इस बनाने कर सकता है सीखा के रूप में 0 दूर करने के लिए है।

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

संपादित करें: 13 बाइट्स के लिए caird और चास ब्राउन के लिए धन्यवाद!

Comments

आप inputउद्धरणों से घिरे होने के लिए इनपुट का उपयोग और आवश्यकता कर सकते हैं ।

— caird coinheringaahing

यह शारीरिक सीमाओं के कारण असफल होने के लिए पूरी तरह से स्वीकार्य है, इसलिए जब तक यह सिद्धांत में सफल होता है, जो यह करता है।

— जोनाथन एलन

(के बारे में पता करने के लिए बहुत अच्छी बात है) के filter(None,sorted(map(int,set(n)))[::-1])साथ बदलकर 9 बाइट्स सहेजें । sorted(set(map(int,n))-{0})[::-1]None

— चास ब्राउन

@ChasBrown अधिकांश मामलों में आप filter(len,...)सूचियों और तारों के लिए और filter(abs,...)पूर्णांक और फ़्लोट के लिए उपयोग कर सकते हैं ।

— अंडा

Answer 6

भूसी , 13 बाइट्स

बहुत नालायक

VVo=⁰ΣMṖNṘ⁰d⁰

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

Answer 7

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

f=(n,l=0,a=n,[c,...b]=a)=>n?1/c?Math.min(!+c|+c>n?1/0:f(n-c,l+1,a),f(n,l,b)):1/0:l

<input type=number oninput=o.textContent=f(this.value)><pre id=o>

एक स्ट्रिंग के रूप में इनपुट लेता है।

Comments

क्या आप बता सकते हैं कि आप क्यों इस्तेमाल कर रहे हैं 1/0?

— ज़ाचारि

@ Zacharý मुझे सबसे छोटी राशि, यानी अंकों की न्यूनतम संख्या चाहिए। जो प्रयास अमान्य समाधान की ओर ले जाते हैं, उन्हें गिनना आवश्यक नहीं है, इसलिए उन्हें बाहर करने के लिए, वे इन्फिनिटी स्कोर करते हैं, जो न्यूनतम को प्रभावित नहीं करता है।

— नील

ओह, एहसास नहीं हुआ कि यह पुनरावर्ती है।

— Zacharý

@ Zacharý f=शुरुआत में एक बड़ा सुराग है, क्योंकि आपको इसे नॉनवेज लेम्बडास की आवश्यकता नहीं है।

— नील

Answer 8

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

->n{w,s=n.digits,0;s+=1while !w.product(*[w]*s).find{|x|x.sum==n};s+1}

बहुत धीमी गति से, सभी संभावित संयोजनों को आकार बढ़ाने की कोशिश करें जब तक कि हम एक समाधान तक नहीं पहुंचते।

TIO पर रूबी 2.4 के लिए धन्यवाद डेनिस।

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

Answer 9

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

D;0ṗµḟ€0
ÇS€=µT
Çị1ĿL€Ṃ

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

यह इतना अक्षम है, कि यह समय सीमा> _ <के कारण TIO पर तीसरे एक के बाद परीक्षण मामलों के लिए नहीं चलता है।

किसी भी गोल्फ टिप्स का स्वागत है!

Answer 10

पायथन 2 , 183 176 172 166 161 बाइट्स

def f(n,D=0,p=0,b=0):
	D=D or set(map(int,`n`))-{0}
	d=min(D);c=0;D=D-{d}
	q=[p+n/d,b][n%d>0]
	while c<min(D or{0}):q=b=f(n-c*d,D,p+c,b);c+=1
	return[q,b][q>b>0]

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

अन्य पायथन उत्तर की तुलना में लंबा है, लेकिन 987654321TIO पर एक सेकंड के तहत संयुक्त रूप से सभी परीक्षण मामलों को निष्पादित करता है ।

इस तथ्य का लाभ उठाता है कि यदि d1<d2अंक हैं, तो d2-1 d1राशि में सबसे अधिक होने की आवश्यकता है (चूंकि d2उदाहरणों को छोटी राशि के उदाहरणों से d1बदला जा सकता है )। इस प्रकार, अंकों को आरोही क्रम में छाँटना, विचार करने के लिए सबसे अधिक संभव रकम पर "केवल" हैं ; और (की कीमत की परवाह किए बिना) की अधिकतम पुनरावृत्ति गहराई ।d1d29! = 3628809n

Answer 11

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

f n=[read[c]|c<-show n,c>'0']#n!!0
s#n|n>0,x:m<-(s#).(n-)=<<s=[1+minimum(x:m)]|1<3=[0|n==0]

इसे ऑनलाइन आज़माएं! उदाहरण उपयोग: f 58पैदावार8 । दो-अंकीय संख्याओं के लिए त्वरित, बड़े इनपुट के लिए भयावह रूप से धीमा।

फ़ंक्शन fइनपुट संख्या nको शून्य की फ़िल्टरिंग करते समय अंकों की सूची में परिवर्तित करता है । फिर यह सूची और nस्वयं उस (#)फ़ंक्शन को सौंप दी जाती है , जो एकल सूची देता है। !!0इस एकल सूची के तत्व को लौटाता है।

(#)विकल्प के रूप में सिंगलटन और रिक्त सूचियों का उपयोग करता है। के एक इनपुट को देखते हुए n=58और s=[5,8]यह विचार है कि सभी अंकों को इसमें sसे घटाया जाए n, फिर पुनरावर्ती रूप से लागू करें (#)और जांचें कि किस अंक में न्यूनतम संख्या में कदम थे और परिणाम के रूप में एक प्लस इस न्यूनतम पर लौटें। पहले भाग को संगणित किया जाता है (s#).(n-)=<<s, जो कि जैसा है वैसा ही है concat(map(s#)(map(n-)s))। तो हमारे उदाहरण में पहले [58-5,58-8]गणना की जाती है, जिसके बाद या उसके बाद [[5,8]#53,[5,8]#50]परिणाम सामने आते हैं । परिणाम का मिलान पैटर्न पर किया[[7],[7]][7,7]concatx:m है यह सुनिश्चित करने के लिए कि सूची में कम से कम एक तत्व है ( minimumअन्यथा विफल रहता है), फिर 1 प्लस की एकल सूची सूची परिणाम का न्यूनतम है। अगरnशून्य शून्य था या पुनरावर्ती कॉल ने एक खाली सूची लौटा दी, हम खोज की असफल शाखा में हैं और एक खाली सूची वापस आ गई है। यदि n==0शाखा सफल हो रही थी और [0]वापस आ गई है।

---

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

f n=[d|d<-[9,8..1],show d!!0`elem`show n]#n!!0
s@(d:r)#n|n>=d,[x]<-s#(n-d)=[x+1]|1<3=r#n
s#n=[0|n==0]

इसे ऑनलाइन आज़माएं! एक और अधिक कुशल तरीका, एक सेकंड के अंदर सभी परीक्षण मामलों की जाँच करता है।

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