खंडित संख्या

Question

खंडों की संख्याओं या माप की प्रमुख संख्याओं ( OEIS A002048 ) की संख्याओं का क्रम ऐसा है कि प्रत्येक सदस्य सबसे छोटा धनात्मक (शून्य से अधिक) संख्या है, जिसे पहले लगातार संख्याओं के योग से नहीं बनाया जा सकता है,a(0) = 1 ।

उदाहरण

गणना करने के लिए a(7)हम पहले गणना करते हैं a(0->6) = [1, 2, 4, 5, 8, 10, 14]। हम तब शून्य से शुरू करते हैं और तब तक संख्याओं से गुजरते हैं जब तक कि हमें एक ऐसा नहीं मिल जाता जो अनुक्रम में एक या एक से अधिक संख्याओं का योग नहीं है।

1  = 1
2  = 2
3  = 1 + 2
4  = 4
5  = 5
6  = 2 + 4
7  = 1 + 2 + 4
8  = 8
9  = 4 + 5
10 = 10
11 = 2 + 4 + 5
12 = 1 + 2 + 4 + 5
13 = 5 + 8
14 = 14
15 = ????

चूँकि पंद्रह को किसी भी क्रमिक योग के द्वारा नहीं बनाया जा सकता है और हर संख्या पंद्रह हो सकती है अनुक्रम में अगली संख्या है। a(7) = 15

कार्य

आपका कार्य एक संख्या (मानक विधियों के माध्यम से) लेना है और इस क्रम में (मानक आउटपुट विधियों के माध्यम से) nth शब्द का उत्पादन करना है। यह कोड-गोल्फ है और आपको इस तरह से स्कोर किया जाएगा।

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

0 -> 1
1 -> 2
2 -> 4
3 -> 5
4 -> 8
5 -> 10
6 -> 14
7 -> 15
8 -> 16
9 -> 21

Answer 1

हास्केल, 62 58 बाइट्स

-4 बाइट्स @ धन्यवाद के लिए धन्यवाद!

(x:y)#z=x:filter(`notElem`scanl(+)x z)y#(x:z)
([1..]#[]!!)

अनुक्रम 0-अनुक्रमित है।

Comments

मुझे लगता है कि आपको दो और बाइट्स की आवश्यकता है और ()इसे एक उचित कार्य करने के लिए अंतिम पंक्ति के साथ घेरें। आंशिक रूप !!से लागू किया गया एक ऑपरेटर अनुभाग है और ()इसे कार्य करने के लिए संलग्न किया जाना चाहिए । इसके बिना यह केवल एक स्निपेट है जो केवल लापता तर्क के साथ एक फ़ंक्शन (या "हास्केल सख्त शब्दों का उपयोग करने के लिए" मूल्य) बन जाता है।

— नौ

सुंदर विधि! आयात हालांकि overkill की तरह लगता है; filter(`notElem`scanl(+)x z)yकरना चाहिए।

— xnor

Answer 2

पर्ल, 50 49 बाइट्स

के लिए +1 शामिल है -p

STDIN पर इनपुट के साथ चलाएं:

segmented.pl <<< 7

segmented.pl:

#!/usr/bin/perl -p
${$_-=$\}++for@F;1while${-++$\};++$#F<$_&&redo}{

व्याख्या

@F(अंतिम संख्या के साथ समाप्त होने वाले) लगातार संख्याओं की (नकारात्मक) रकमों की सूची सम्‍मिलित है। जब एक नए नंबर की खोज की जाती है तो सूची को 0 के साथ बढ़ाया जाता है और फिर नए नंबर द्वारा अपरिवर्तित बनाए रखने के लिए सभी मानों को घटा दिया जाता है।

वैश्विक %:: का उपयोग एक हैश मैपिंग के रूप में किया जाता है जो सभी (नकारात्मक) संख्याओं को ( @Fशून्य से ) गैर-शून्य मान पर देखा गया है।

$\ वर्तमान संख्या है और तब तक बढ़ जाती है जब तक कि वह उस मूल्य तक नहीं पहुंच जाती जो अभी तक नहीं है %:: ।

जिस क्रम में सब कुछ घटित होता है, उसके बारे में थोड़ा सावधान रहकर, कोई आरंभीकरण की आवश्यकता नहीं होती है, 1 ।

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

Answer 3

05AB1E , 17 16 बाइट्स

Xˆ$µ>D¯ŒOså_i¼Dˆ

व्याख्या

Xˆ                # initialize global array to [1]
  $               # push 1 and input to stack
   µ              # while counter != input
    >             # increase variable on stack
      ¯ŒO         # list of all sums of consecutive number in global array
     D   så_i     # if current stack value is not in the list
             ¼    # increase counter
              Dˆ  # add current stack value to global array

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

अदनान को 1 बाइट दिया

Comments

करता है $के बजाय Xsकाम करता है?

— अदनान

@ अदनान: हां बिल्कुल। मुझे मूर्ख। धन्यवाद!

— एमिग्ना

Answer 4

जेली , 14 13 11 बाइट्स

Ḷ߀Ẇ;ḅ1‘ḟ$Ṃ

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

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

Ḷ߀Ẇ;ḅ1‘ḟ$Ṃ  Main link. Argument: n

Ḷ            Unlength; yield [0, ..., n - 1].
 ߀          Recursively map the main link over the range.
   Ẇ         Window; yield all subarrays of consecutive elements of the result.
    ;        Append n to the array of subarrays.
     ḅ1      Convert all subarrays from base 1 to integer.
             This is equivalent to S€ (sum each), but it allows ; to hook.
         $   Combine the previous two links into a monadic chain.
       ‘       Increment all sums.
        ḟ      Filter; remove the original sums from the incremented ones.
          Ṃ  Compute the minimum.

Answer 5

पायथ - 19 17 बाइट्स

धिक्कार है एक-एक करके मेरे सारे अवगुणों को बर्बाद करते हुए। (एक ही बाइट्स गिनती, literaly incrementing Q: =hQesmaYf!}TsM.:Y)

esmaYf!}TsM.:Y)1h

टेस्ट सूट ।

Comments

कम बचत (केवल) एक बाइट का उपयोग करना। अधिक की उम्मीद ...eu+Gf!}TsM.:G))hQY

— जकुबे

@ जाकुब का नक्शा आमतौर पर इन जैसे स्व-संदर्भित अनुक्रमों के लिए छोटा होता है

— मैलेसेन

Answer 6

जावास्क्रिप्ट, 125 112 110 बाइट्स

2 बाइट्स @Neil की बदौलत सहेजे गए

f=n=>{a=[[]];for(i=1,z=0;z<=n;i++)a.some(b=>b.includes(i))||(a[z+1]=[0,...a[z++]||[]].map(v=>i+v));alert(i-1)}

पिछले जवाब

112 बाइट्स @ धन्यवाद का धन्यवाद:

f=n=>{a=[[]];for(i=1,z=0;z<=n;i++)if(!a.some(b=>b.includes(i))){a[z+1]=[0,...a[z++]||[]].map(v=>i+v)}alert(i-1)}

125 बाइट्स:

f=n=>{a=[[]];for(i=1,k=z=0;z<=n;i++)if(a.every(b=>b.every(c=>c-i))){a[i]=[i].concat((a[k]||[]).map(v=>i+v));k=i,z++}alert(k)}

Comments

के लिए b.every(c=>c-i), मैं कोशिश करता हूँ !b.includes(i)या संभवतः !a.some(b=>b.includes(i))काम करता है, जबकि [0,...a[k]||[]].map(v=>i+v)बदल सकता है [i].concat((a[k]||[]).map(v=>i+v))। क्या आपको भी वास्तव में ज़रूरत है k?

— नील

अब जब कि आपका if(!...){...}केवल एक बयान है, तो आप शायद इसे ...||(...)या के साथ बदल सकते हैं ...?0:...।

— नील

Answer 7

पायथन, 113 105 92 80 बाइट्स

s=F={1}
x=1
exec"while{x}<=s:x+=1\nF={x+j for j in{0}|F};s|=F\n"*input()
print x

मेरे द्वारा बचाए गए अंतिम बाइट्स को टोन के पर्ल जवाब से प्रेरित किया गया था: मेरी Fउसकी जैसी ही बात है @F; मेरी sअनिवार्य रूप से उसकी जैसी ही बात है %::।

Answer 8

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

(n,a=[],s=a,i=1)=>s[i]?f(n,a,s,i+1):--n?f(n,[0,...a].map(j=>s[j+=i]=j),s,i):i

मूल रूप से @ TonHospel के पर्ल उत्तर के एल्गोरिथ्म का एक पुनरावर्ती बंदरगाह।