सबसे छोटी जोड़ श्रृंखला

Question

एक अतिरिक्त श्रृंखला 1 से शुरू होने वाले पूर्णांकों का एक क्रम है, जहां प्रारंभिक 1 के अलावा प्रत्येक पूर्णांक दो पिछले पूर्णांकों का योग है।

उदाहरण के लिए, यहां एक अतिरिक्त श्रृंखला है:

[1, 2, 3, 4, 7, 8, 16, 32, 39, 71]

यहाँ योग हैं जो इसे एक अतिरिक्त श्रृंखला बनाते हैं:

1 + 1 = 2
1 + 2 = 3
1 + 3 = 4
3 + 4 = 7
1 + 7 = 8
8 + 8 = 16
16 + 16 = 32
7 + 32 = 39
32 + 39 = 71

इस चुनौती में, आपको एक सकारात्मक पूर्णांक दिया जाएगा n, और आपको सबसे छोटी अतिरिक्त श्रृंखलाओं में से एक का उत्पादन करना होगा जो कि समाप्त होती है n।

उदाहरण - ध्यान दें कि कई संभावित आउटपुट हैं, जो आपको खोजने के लिए आवश्यक हैं एक अतिरिक्त श्रृंखला है जो बस के रूप में छोटा है:

1: [1]
2: [1, 2]
3: [1, 2, 3]
4: [1, 2, 4]
5: [1, 2, 3, 5]
6: [1, 2, 3, 6]
7: [1, 2, 3, 4, 7]
11: [1, 2, 3, 4, 7, 11]
15: [1, 2, 3, 5, 10, 15]
19: [1, 2, 3, 4, 8, 11, 19]
29: [1, 2, 3, 4, 7, 11, 18, 29]
47: [1, 2, 3, 4, 7, 10, 20, 27, 47]
71: [1, 2, 3, 4, 7, 8, 16, 32, 39, 71]

मानक I / O नियम, इत्यादि। कोड गोल्फ: सबसे कम बाइट्स जीतता है।

Comments

संबंधित

— पीटर टेलर

संबंधित OEIS अनुक्रम ।

— अरनौलद

क्या हमें चेन को रिवर्स ऑर्डर में आउटपुट करने की अनुमति है?

— अरनौल

@Arnauld नहीं, यह विशिष्ट आदेश।

— इसहाक

Answer 1

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

c=[1]:[x++[a+b]|x<-c,a<-x,b<-x]
f n=[x|x<-c,last x==n]!!0

एक जानवर बल समाधान। इसे ऑनलाइन आज़माएं!

व्याख्या

अनंत सूची cमें लंबाई के आधार पर सभी अतिरिक्त श्रृंखलाएँ होती हैं। इसे स्वयं xसे cऔर दो तत्वों से एक सूची लेकर x, और उनके योग को जोड़कर , इसे स्वयं के रूप में परिभाषित किया गया है x। फ़ंक्शन वांछित संख्या के साथ समाप्त होने वाली fपहली सूची पाता है c।

c=            -- c is the list of lists
 [1]:         -- containing [1] and
 [x           -- each list x
  ++[a+b]     -- extended with a+b
 |x<-c,       -- where x is drawn from c,
  a<-x,       -- a is drawn from x and
  b<-x]       -- b is drawn from x.
f n=          -- f on input n is:
 [x           -- take list of those lists x
 |x<-c,       -- where x is drawn from c and
  last x==n]  -- x ends with n,
 !!0          -- return its first element.

Answer 2

ब्रेकीलॉग , 14 बाइट्स

∧≜;1{j⊇Ċ+}ᵃ⁽?∋

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

एक जानवर-बल सबमिशन जो पुनरावृत्ति को गहरा करने का उपयोग करके सभी संभावित अतिरिक्त श्रृंखलाओं का निर्माण करता है, जब एक सही तर्क युक्त श्रृंखला को रोक दिया जाता है। अधिकांश ब्राचलॉग सबमिशन के विपरीत, यह एक फ़ंक्शन सबमिशन है, जो अपने सही तर्क (पारंपरिक रूप से आउटपुट कहा जाता है) के माध्यम से इनपुट करता है और अपने बाएं तर्क के माध्यम से आउटपुट (पारंपरिक रूप से इनपुट कहा जाता है); यह करना कुछ हद तक विवादास्पद है, लेकिन इस विषय पर सबसे ज्यादा वोट पाने वाला मेटा उत्तर कहता है कि यह कानूनी है (और ऐसा करना हमारे सामान्य I / O कार्यों के लिए चूक के अनुरूप है)। यदि हम इनपुट और आउटपुट का उपयोग पारंपरिक तरीके से करते हैं, तो यह 16 बाइट्स होगा (∧≜;1{j⊇Ċ+}ᵃ⁽.∋?∧), क्योंकि प्रोग्राम का राइट-हैंड साइड निहित बाधा का उपयोग करने में सक्षम नहीं होगा (इस तरह उस विकलांग की आवश्यकता होगी, और 2 बाइट्स की कीमत पर दिया गया एक नया स्पष्ट बाधा)।

व्याख्या

∧≜;1{j⊇Ċ+}ᵃ⁽?∋
∧               Disable implicit constraint to read the left argument
 ≜;        ⁽    Evaluation order hint: minimize number of iterations
    {    }ᵃ     Repeatedly run the following:
   1      ᵃ       From {1 on the first iteration, results seen so far otherwise}
     j            Make {two} copies of each list element
      ⊇           Find a subset of the elements
       Ċ          which has size 2
        +         and which sums to {the new result for the next iteration}
             ∋    If the list of results seen so far contains {the right argument}
            ?     Output it via the left argument {then terminate}

यहां एक दिलचस्प सूक्ष्मता यह है कि पहले पुनरावृत्ति पर क्या होता है, जहां इनपुट अन्य पुनरावृत्तियों की तरह एक सूची के बजाय एक संख्या है; हम नंबर 1 से शुरू करते हैं, हर अंक की दो प्रतियाँ बनाते हैं (संख्या 11 बनाते हैं), फिर इसका 2-अंक बाद में पाते हैं (संख्या 11 भी)। फिर हम इसकी अंक राशि लेते हैं, जो कि 2 है, और जैसा [1,2]कि हम चाहते हैं, ऐसा क्रम शुरू होता है । भविष्य पुनरावृत्तियों पर, हम की तरह एक सूची के साथ शुरू कर रहे हैं [1,2], के लिए यह दोगुना [1,2,1,2](तब एक दो तत्व परिणाम को ले जा, [1,1], [1,2], [2,1], या [2,2]); स्पष्ट रूप से, इनमें से प्रत्येक का जोड़ जोड़ श्रृंखला के अगले तत्वों को मान्य करेगा।

यह थोड़ा निराश करने वाली बात है कि मूल्यांकन आदेश संकेत की यहाँ आवश्यकता है, विशेष रूप से ≜घटक (ऐसा प्रतीत होता है कि ᵃइसका मूल्यांकन क्रम अंदर से बाहर की बजाय डिफ़ॉल्ट रूप से इंगित करता है, इस प्रकार ≜समस्या को लागू करने के लिए बल्कि क्रूड का उपयोग होता है)।

Comments

मैंने इस चुनौती को करने के लिए एक छोटा रास्ता खोजने के लिए लगभग 30 मिनट की कोशिश की थी। मेरा समाधान इस तरह से लंबा था।

— घातक

@ फ़ेटलाइज़: ᵃउन बिल्डिंस में से एक है जो शायद ही कभी आती है, लेकिन जब आपको इसकी आवश्यकता होती है, तो आपको वास्तव में इसकी आवश्यकता होती है, क्योंकि अन्य नियंत्रण निर्माणों का उपयोग करके इसे लागू करने के लिए कोई दूर से चलने वाला तरीका नहीं है। एक बार जब मुझे लगा कि यह एक ᵃचुनौती है, तो बाकी लोग वहां से सीधे चले आए।

Answer 3

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

’ŒP;€µ+þ;1Fḟ@µÐḟḢ

घातीय समय में लेक्सोग्राफिक रूप से पहला समाधान आउटपुट करता है।

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

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

’ŒP;€µ+þ;1Fḟ@µÐḟḢ  Main link. Argument: n (integer)

’                  Decrement; n-1.
 ŒP                Powerset; generate all subarrays of [1, ..., n-1], sorted first
                   by length, then lexicographically.
   ;€              Append n to all generate subarrays.
     µ       µÐḟ   Filterfalse; keep only subarrays for which the chain between the
                   two chain separators (µ) returns a falsy value.
     µ             Monadic chain. Argument: A (array of integers)
      +þ               Add table; compute the sums of all pairs of elements in x,
                       grouping the results by the right addend.
        ;1             Append 1 to the resulting 2D array.
          F            Flatten the result.
           ḟ@          Filterfalse swapped; remove all elements of A that appear in
                       the result. This yields an empty list for addition chains.
                Ḣ  Head; select the first result.

Answer 4

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

संपादित करें: सूची को गैर-रिवर्स क्रम में आउटपुट करने के लिए तय की गई

n=>(g=(s,a=[1])=>s-n?s>n||a.map(v=>g(v+=s,a.concat(v))):r=1/r|r[a.length]?a:r)(r=1)&&r

डेमो

let f =

n=>(g=(s,a=[1])=>s-n?s>n||a.map(v=>g(v+=s,a.concat(v))):r=1/r|r[a.length]?a:r)(r=1)&&r

for(n = 1; n <= 15; n++) {
  console.log(n, '-->', JSON.stringify(f(n)));
}

Answer 5

PHP, 195 बाइट्स

function p($a){global$argn,$r;if(!$r||$a<$r)if(end($a)==$argn)$r=$a;else foreach($a as$x)foreach($a as$y)in_array($w=$x+$y,$a)||$w>$argn||$w<=max($a)?:p(array_merge($a,[$w]));}p([1]);print_r($r);

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

Comments

दुर्भाग्य से यह एल्गोरिथम इष्टतम उत्तर नहीं देता है, उदाहरण के लिए 15.

— नील

@ अब यह अब लंबा है लेकिन यह काम करता है। मेरे पास इस समय कोई आइडिया नहीं है कि कैसे तय किया जाए कि दोनों में से कौन सा तरीका सही है। शायद primes की गिनती एक भूमिका निभाती है

— Jörg Hülsermann

यह कोड 149 टेस्ट पास नहीं करता है। लंबाई 10 होनी चाहिए, 11 नहीं

— J42161217

@ जेनी_माथी ने ठीक किया

— जार्ज ह्यूल्समैन ने

Answer 6

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

t={};s={1};(Do[While[Last@s!=#,s={1};While[Last@s<#,AppendTo[s,RandomChoice@s+Last@s]]];t~AppendTo~s;s={1},10^4];First@SortBy[t,Length@#&])&

।

हर बार जब आप इसे चलाते हैं तो एक अलग लघु श्रृंखला बनाता है

यह कोशिश करें
कि कोड को ctrl + v, जगह इनपुट के साथ कोड पेस्ट करें [[71] कोड के अंत में और शिफ्ट + एंटर दबाएं

Comments

जैसा कि मेरे पास गणितज्ञों तक पहुंच नहीं है, यह 15 की इनपुट के लिए किस श्रृंखला की लंबाई देता है?

— नील

सही एक {1, 2, 3, 5, 10, 15}

— J42161217

इनपुट 149 के लिए, मुझे आपके प्रोग्राम से लंबाई 11 की एक श्रृंखला मिली, लेकिन लंबाई 10 ( [1,2,4,5,9,18,36,72,77,149]) में से एक मौजूद है । ऐसा लगता है कि आपका कार्यक्रम यादृच्छिक नमूने का उपयोग करता है और इष्टतम समाधान खोजने की गारंटी नहीं है।

— जर्गब

तय! लेकिन इसमें अधिक समय लगता है

— J42161217

Answer 7

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

h-DsM^N2/#QyS

परीक्षण सूट

शाब्दिक रूप से पहली सबसे छोटी श्रृंखला देता है। यह काफी धीमा है, लेकिन यह बुरा नहीं है - 19लगभग 30 सेकंड में pypy का उपयोग करके पूरा होता है।

@ डेनिस के समाधान से कुछ विचार।

मैं वास्तव में इस एक को पसंद करता हूं - इसमें एक टन स्वच्छ चाल शामिल है।

स्पष्टीकरण:

h-DsM^N2/#QyS
h-DsM^N2/#QySQ    Implicit variable introduction
            SQ    Inclusive range, 1 to input.
           y      Subsets - all subsets of the input, sorted by length then lexicographically
                  Only sorted subsets will be generated.
                  Our addition chain will be one of these.
        /#Q       Filter for presence of the input.
  D               Order by
 -                What's left after we remove
     ^N2          All pairs of numbers in the input
   sM             Summed
h                 Output the list that got sorted to the front.

यह समझना अभी भी थोड़ा कठिन है, लेकिन मुझे थोड़ा और विस्तार से समझाने की कोशिश करते हैं।

हम शुरू करते हैं ySQ, जो [1, 2, ... Q]आकार के बढ़ते क्रम में सभी संभव ऑर्डर किए गए सबसेट को पूरा करता है । सबसे छोटी जोड़ श्रृंखला निश्चित रूप से इनमें से एक है, लेकिन हमें इसे खोजने की आवश्यकता है।

पहली चीज जो हम करेंगे, वह सूची को फ़िल्टर करने के लिए केवल उन सूचियों को रखने के लिए है जिनमें एक है Q। हम इसके साथ करते हैं /#Q।

अगला, हम एक निश्चित फ़ंक्शन के परिणाम को हटाने के बाद सूची को छोड़ देते हैं। -Dकुछ हटाने के बाद शेष द्वारा आदेश।

हम जो चीज निकालते हैं वह वह सूची है sM^N2, जहां Nसे हम चीजों को हटा रहे हैं। खुद ^N2के Nसाथ कार्टेशियन उत्पाद देता है, दो तत्वों के सभी संभव जोड़े N। sMफिर प्रत्येक जोड़े को जोड़ते हैं।

इस निष्कासन के बाद, सबसे छोटा संभव परिणाम क्या है? खैर, इनपुट सूची में सबसे छोटा तत्व निश्चित रूप से रहेगा, क्योंकि सभी संख्याएं सकारात्मक हैं, इसलिए दो संख्याओं में से कोई भी राशि सबसे छोटी संख्या से अधिक होगी। और कम से कम एक संख्या होगी, क्योंकि हमने जांच की थी कि इनपुट सूची में मौजूद था। इसलिए, सबसे छोटा संभव परिणाम तब होगा जब छोटी संख्या को छोड़कर प्रत्येक संख्या सूची में दो अन्य संख्याओं का योग हो, और सूची में सबसे छोटी संख्या 1. है। इस मामले में, छँटाई कुंजी होगी [1]। इन आवश्यकताओं का मतलब है कि सूची में एक अतिरिक्त श्रृंखला होनी चाहिए।

तो, हम आगे की श्रृंखलाओं को जोड़ते हैं। याद रखें कि yआकार के बढ़ते क्रम में इसकी सबसेट देता है, इसलिए जो सूची सामने की ओर क्रमबद्ध है, वह सबसे छोटी जोड़ श्रृंखलाओं में से एक होनी चाहिए। hउस सूची का चयन करता है।