एक भग्न अनुक्रम के योगों का रूपांतरण

Question

पृष्ठभूमि

एक भग्न अनुक्रम एक पूर्णांक अनुक्रम होता है जहां आप प्रत्येक पूर्णांक की पहली घटना को हटा सकते हैं और पहले के समान अनुक्रम के साथ समाप्त हो सकते हैं।

इस तरह के एक बहुत ही सरल अनुक्रम को किम्बरलिंग के पैराफ्रीज कहा जाता है । आप सकारात्मक प्राकृतिक संख्याओं के साथ शुरू करते हैं:

1, 2, 3, 4, 5, 6, 7, 8, 9, ...

तो आप कुछ रिक्त स्थान में riffle:

1, _, 2, _, 3, _, 4, _, 5, _, 6, _, 7, _, 8, _, 9, ...

और फिर आप बार-बार अनुक्रम के साथ रिक्त स्थान को भरते हैं (रिक्त स्थान सहित):

1, 1, 2, _, 3, 2, 4, _, 5, 3, 6, _, 7, 4, 8, _, 9, ...
1, 1, 2, 1, 3, 2, 4, _, 5, 3, 6, 2, 7, 4, 8, _, 9, ...
1, 1, 2, 1, 3, 2, 4, 1, 5, 3, 6, 2, 7, 4, 8, _, 9, ...
1, 1, 2, 1, 3, 2, 4, 1, 5, 3, 6, 2, 7, 4, 8, 1, 9, ...

यही हमारा भग्न क्रम है! अब आंशिक रकम लेते हैं:

1, 2, 4, 5, 8, 10, 14, 15, 20, 23, 29, 31, 38, 42, 50, 51, 60, ...

लेकिन क्या होगा अगर हम इस प्रक्रिया को दोहराते हैं? "फ्रैक्टलिज़" नया अनुक्रम (यानी ऊपर दिए चरणों से प्राप्त आंशिक रकम):

1, _, 2, _, 4, _, 5, _, 8, _, 10, _, 14, _, 15, _, 20, _, 23, ...
1, 1, 2, _, 4, 2, 5, _, 8, 4, 10, _, 14, 5, 15, _, 20, 8, 23, ...
1, 1, 2, 1, 4, 2, 5, _, 8, 4, 10, 2, 14, 5, 15, _, 20, 8, 23, ...
1, 1, 2, 1, 4, 2, 5, 1, 8, 4, 10, 2, 14, 5, 15, _, 20, 8, 23, ...
1, 1, 2, 1, 4, 2, 5, 1, 8, 4, 10, 2, 14, 5, 15, 1, 20, 8, 23, ...

और आंशिक रकम फिर से लें:

1, 2, 4, 5, 9, 11, 16, 17, 25, 29, 39, 41, 55, 60, 75, 76, 96, ...

कुल्ला, दोहराना। यह पता चला है कि यह प्रक्रिया अभिसरण करती है। हर बार जब आप इस प्रक्रिया को दोहराते हैं, तो अनुक्रम का एक बड़ा उपसर्ग निश्चित रहेगा। पुनरावृत्तियों की एक अनंत राशि के बाद, आप OEIS A085765 के साथ समाप्त होंगे ।

मजेदार तथ्य: यह प्रक्रिया उसी क्रम में परिवर्तित हो जाएगी, जब तक कि हम प्राकृतिक संख्या से शुरू नहीं करते थे जब तक कि मूल अनुक्रम शुरू नहीं हो जाता 1। यदि मूल अनुक्रम किसी अन्य के साथ शुरू होता है x, तो हम x*A085765इसके बजाय प्राप्त करेंगे ।

चुनौती

एक धनात्मक पूर्णांक को देखते हुए N, Nअभिसरित अनुक्रम के वें तत्व को आउटपुट करता है ।

आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट लेने और STDOUT (या निकटतम वैकल्पिक), फ़ंक्शन रिटर्न मान या फ़ंक्शन (आउट) पैरामीटर के माध्यम से परिणाम आउटपुट कर सकते हैं।

आप चुन सकते हैं कि क्या सूचकांक N0- या 1-आधारित है।

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

अनुक्रम के साथ शुरू होता है:

1, 2, 4, 5, 9, 11, 16, 17, 26, 30, 41, 43, 59, 64, 81, 82, 108, 117, 147, 151, 192, 203, 246, 248, 307, 323, 387, 392, 473, 490, 572, 573, 681, 707, 824, 833, 980, 1010, 1161, 1165, 1357, 1398, 1601, 1612, 1858, 1901, 2149, 2151, 2458, 2517

इसलिए इनपुट 5का आउटपुट होना चाहिए 9।

यहां एक भोली सीजेएम संदर्भ कार्यान्वयन है जो पहले Nनंबर ( एसटीडीआईएनN पर दिया गया) उत्पन्न करता है । ध्यान दें कि आपके कोड को केवल Nवें तत्व को वापस करना चाहिए , न कि पूरे उपसर्ग को।

Comments

तो बस जाँच: हम A085765 के Nवें शब्द का उत्पादन कर रहे हैं , सही?

— गेमक्रॉप्स

@GamrCorps हां।

— मार्टिन एंडर

Answer 1

CJam ( 23 22 बाइट्स)

आंशिक रकम को भग्न अनुक्रम के भी अनुक्रमित पर दिया जाता है, जो A086450 है । A086450 की परिभाषा के रूप में वहां दी गई पुनरावृत्ति इन कार्यान्वयनों का आधार है।

एक स्पष्ट "स्टैक" का उपयोग करना (डराने वाले उद्धरण में क्योंकि यह LIFO नहीं है):

{),){2md~)\),>+$)}h+,}

ऑनलाइन डेमो

विच्छेदन

{         e# Anonymous function body; for clarify, pretend it's f(x)
          e# We use a stack [x_0 ... x_i] with invariant: the result is sum_j f(x_j)
  ),      e# Initialise the stack to [0 ... x]
  )       e# Uncons x, because our loop wants one value outside the stack
  {       e# Loop. Stack holds [x_0 ... x_{i-1}] x_i
    2md   e# Split x_i into (x_i)/2 and (x_i)%2
    ~)\   e# Negate (x_i)%2 and flip under (x_i)/2
    ),>   e# If x_i was even, stack now holds [x_0 ... x_{i-1}] [0 1 ... (x_i)/2]
          e# If x_i was odd, stack now holds [x_0 ... x_{i-1}] [(x_i)/2]
    +     e# Append the two arrays
    $     e# Sort to get the new stack
    )     e# Uncons the greatest element in the new stack
  }h      e# If it is non-zero, loop
          e# We now have a stack of zeroes and a loose zero
  +,      e# Count the total number of zeroes, which is equivalent to sum_j f(0)
}

---

23 बाइट्स में मेमॉसेशन के साथ बहुत अधिक कुशल दृष्टिकोण है:

{2*1a{2md~)\){j}%>:+}j}

ऑनलाइन डेमो

Comments

मुझे यकीन है कि कुछ ऐसी भाषाएं हैं जिनमें इसे लागू करना कम होगा f(0) = 1; f(n) = f(n/2) + (n % 2 ? 0 : f(n-2)); return f(2*x), लेकिन मुझे सीजाम में उस दृष्टिकोण के साथ बचत करने का कोई तरीका नहीं मिल सकता है।

— पीटर टेलर

Answer 2

पायथन 2, 55 49 42

मुझे नहीं पता कि क्या चल रहा है, लेकिन OEIS पेज से मेपल फॉर्मूला को हरा पाना मुश्किल है। यह 0-आधारित इंडेक्सिंग का उपयोग करता है।

f=lambda n,t=0:n<1or f(n/2,n%2)-~-t*f(n-1)

@PeterTaylor के लिए धन्यवाद -6 बाइट्स।

Comments

यदि आप प्रदर्शन के बारे में परवाह नहीं करते हैं, तो 6 वर्णों को अनुकूलित करना आसान है। पहले के बाद के हिस्से orप्रभावी रूप से हैं g(n,1) = f(n/2,n%2); g(n,0) = f(n-1) + g(n,1); तो आप g(n,1)पाने के लिए आम बाहर खींच सकते हैंf=lambda n,t=0:n<1or f(n/2,n%2)+0**t*f(n-1)

— पीटर टेलर

Answer 3

हास्केल, 65

s l=[0..]>>=(\i->[l!!i,s l!!i])
r=1:(tail$scanl1(+)$s r)
f n=r!!n

Answer 4

टेंपरेचर हार्मफुल , 124

Fun<If<A<1>,Add<Ap<Fun<Ap<If<Sub<A<1>,Mul<I<2>,Div<A<1>,I<2>>>>,A<0>,A<0,1>>,Div<A<1>,I<2>>>>,A<1>>,Ap<A<0>,Sub<A<1>,T>>>,T>>

यह एक अनाम फ़ंक्शन है। यह कमोबेश वैसा ही है जैसा कि मेरे पायथन ने OEIS पृष्ठ पर मेपल सूत्र का उत्तर दिया है, सिवाय इसके कि मैंने मापांक को लागू नहीं किया, इसलिए मुझे n% 2 के बजाय nn / 2 * 2 का उपयोग करना पड़ा।

विस्तारित:

Fun<If<
    A<1>,
    Add<
        Ap<
            Fun<Ap<
                If<
                    Sub<
                        A<1>,
                        Mul<
                            I<2>,
                            Div<A<1>,I<2> >
                        >
                    >,
                    A<0>,
                    A<0,1>
                >,
                Div<A<1>,I<2>>
            >>,
            A<1>
        >,
        Ap<
            A<0>,
            Sub<A<1>, T>
        >
    >,
    T
>> 

Answer 5

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

If[#<1,1,#0[Floor@#/2]+(1-2#~Mod~1)#0[#-1]]&

Answer 6

Matlab 108 103

मैं इस तथ्य का उपयोग कर रहा हूं कि वांछित श्रृंखला https://oeis.org/A086450 का आंशिक योग है

लेकिन मेरे कार्यान्वयन की गणना जटिलता इष्टतम से दूर है, यहां तक ​​कि इस सरल पुनरावृत्ति के लिए भी।

n=input('')+1;
z=zeros(1,n);z(1)=1;
for k=1:n;
z(2*k)=z(k);
z(2*k+1)=sum(z(1:k+1));
end;
disp(sum(z(1:n)))