1, 2, 4, 8, 16, ... 33?

Question

चुनौती

एक फ़ंक्शन / प्रोग्राम लिखें जो कि प्रसिद्ध संख्या क्रम में nया तो 'वें तत्व, या पहले nतत्वों को आउटपुट करता है :

         1, 2, 4, 8, 16 ...

ओह, रुको ... मैं पहले कुछ नंबर भूल गया:

1, 1, 1, 1, 2, 4, 8, 16 ...

बिल्ली, मैं अच्छे उपाय के लिए कुछ और जोड़ूंगा:

1, 1, 1, 1, 2, 4, 8, 16, 33, 69, 146, 312, 673, 1463, 3202, 7050, 15605, 34705 ...

---

संख्याओं को सामान्यीकृत कैटलन संख्या (शून्य-अनुक्रमित) सूत्र द्वारा दिया गया है:

$$a(n+1)= a(n) + \sum_{k=2}^{n-1} a(k)\cdot a(n-1-k)$$

कहा पे

$$a(0)= a(1)= a(2)= a(3) = 1$$

यह OEIS A004149 है ।

यदि आप अनुक्रम शून्य या एक-अनुक्रमित करना चाहते हैं, तो आप चुन सकते हैं। अनुक्रम निश्चित रूप से समान होना चाहिए, इसलिए यदि आपने इसे एक-अनुक्रमित किया है, तो आपको सूत्र को फिर से लिखना होगा।

Comments

अगर मैं यहां गलत हूं तो मुझे सुधारें, लेकिन एक-अनुक्रमित सूत्र के लिए संशोधन a(n-1-k)को a(n-k)सही में बदलना है ?

— सुमनेर १18

यह मुझे छोटी संख्या के मजबूत कानून की

— लुइस मेंडो

Answer 1

पायथन , 51 बाइट्स

f=lambda n,k=2:n<3or k<n and f(k)*f(n-k-2)+f(n,k+1)

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

सूत्र को थोड़ा सरल करता है:

$$a(n) = \sum_{k=2}^{n-1} a(k)\cdot a(n-2-k)$$

$$a(-1) = a(0)= a(1)= a(2) = 1$$

Comments

100k पर बधाई !!

— स्टीवी ग्रिफिन

जब से मैं भी स्वतंत्र रूप से इस समाधान के लिए पहुंचे, मुझे कहना पड़ेगा कि यह की दिशा में पथ थोड़ा ऊबड़ ... है

— एरिक Outgolfer

Answer 2

पर्ल 6 , 44 बाइट्स

{1,1,1,1,{sum @_[2..*]Z*@_[@_-4...0,0]}...*}

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

अनाम कोड ब्लॉक जो मूल्यों के एक आलसी अनंत अनुक्रम को लौटाता है। यह बहुत अधिक अनुक्रम को वर्णित के रूप में कार्यान्वित करता है, शॉर्टकट के साथ कि यह ज़िप तत्व को दूसरे तत्व के बाद अब तक चौथे तत्व से शुरू होने वाली सूची के रिवर्स के साथ और 1अंत में एक अतिरिक्त जोड़कर गुणा करता है ।

स्पष्टीकरण:

{                                          }  # Anonymous code block
                                       ...*   # Create an infinite sequence
 1,1,1,1,                                     # Starting with four 1s
         {                            }       # Where each new element is:
          sum                                   # The sum of
              @_[2..*]                          # The second element onwards
                      Z*                        # Zip multiplied with
                        @_[@_-4...0  ]          # The fourth last element backwards
                                   ,0           # And 1

Answer 3

05AB1E , 14 13 11 बाइट्स

$ƒˆ¯Âø¨¨¨PO

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

0-अनुक्रमित nth तत्व को आउटपुट करता है।

$                # push 1 and the input
 ƒ               # repeat (input+1) times
  ˆ              #  add the top of the stack (initially 1) to the global array
   ¯             #  push the global array
    Â            #  and a reversed copy of it
     ø           #  zip the two together, giving a list of pairs
      ¨¨¨        #  drop the last 3 pairs
         P       #  take the product of each pair (or 1 if the list is empty)
          O      #  take the sum of those products
                 #  after the last iteration, this is implicitly output;
                 #  otherwise, it's added to the global array by the next iteration

Answer 4

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

Xnor के समाधान का एक बंदरगाह ।

0 अनुक्रमित।

f=(n,k=2)=>n<3||k<n&&f(k)*f(n+~++k)+f(n,k)

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

---

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

एक तेज, कम पुनरावर्ती, लेकिन काफी लंबा समाधान।

0 अनुक्रमित।

f=(n,i,a=[p=1])=>a[n]||f(n,-~i,[...a,p+=(h=k=>k<i&&a[k]*a[i-++k]+h(k))(2)])

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

Answer 5

हास्केल, 49 43 39 बाइट्स

a n=max(sum[a k*a(n-2-k)|k<-[2..n-1]])1              

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

के लिए 0 है, तो यह करने के लिए उठाती है ।n<3summax ... 11

संपादित करें: -Jo राजा को -6 बाइट्स धन्यवाद।

Answer 6

वोल्फ्राम भाषा (गणितज्ञ) , 36 बाइट्स

Sum[#0@i#0[#-i-1],{i,3,#-1}]/. 0->1&

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

1 अनुक्रमित।

2-अनुक्रमित अनुक्रम 4 बाइट्स छोटा है Sum[#0@i#0[#-i],{i,#-4}]/. 0->1&:। इसे ऑनलाइन आज़माएं!

Comments

प्रभावशाली है कि यह निर्मित में से छोटा है CatalanNumber!

— erfink

Answer 7

05AB1E , 17 13 बाइट्स

4Å1λ£₁λ¨Â¦¦s¦¦*O+

मौजूदा 05AB1E उत्तर से कम नहीं है , लेकिन मैं अपने लिए नए 05AB1E संस्करण की पुनरावर्ती कार्यक्षमता को अभ्यास के रूप में आज़माना चाहता था। शायद कुछ बाइट्स से गोल्फ हो सकता है। संपादित करें: और यह वास्तव में, की पुनरावर्ती संस्करण देख सकते हैं @Grimy नीचे की 05AB1E जवाब है, जो 13 बाइट्स ।

पहले आउटपुट देता है $n$आइटम: इसे ऑनलाइन आज़माएं ।

0-आधारित में परिवर्तित किया जा सकता है $n$के £साथ प्रतिस्थापित करते समय 'आइटम è: इसे ऑनलाइन आज़माएँ ;
या हटाने के द्वारा एक अनंत सूची £: इसे ऑनलाइन आज़माएं ।

स्पष्टीकरण:

यह चुनौती के विवरण में प्रयुक्त सूत्र को इस तरह लागू करता है:
$a(n)= a(n-1) + \sum_{k=2}^{n-1}(a(k)\cdot a(n-1-k))$

$a(0)=a(1)=a(2)=a(3)=1$

   λ               # Create a recursive environment,
    £              # to output the first (implicit) input amount of results after we're done
4Å1                # Start this recursive list with [1,1,1,1], thus a(0)=a(1)=a(2)=a(3)=1
                   # Within the recursive environment, do the following:
      λ            #  Push the list of values in the range [a(0),a(n)]
       ¨           #  Remove the last one to make the range [a(0),a(n-1)]
        Â          #  Bifurcate this list (short for Duplicate & Reverse copy)
         ¦¦        #  Remove the first two items of the reversed list,
                   #  so we'll have a list with the values in the range [a(n-3),a(0)]
           s       #  Swap to get the [a(0),a(n-1)] list again
            ¦¦     #  Remove the first two items of this list as well,
                   #  so we'll have a list with the values in the range [a(2),a(n-1)]
              *    #  Multiply the values at the same indices in both lists,
                   #  so we'll have a list with the values [a(n-3)*a(2),...,a(0)*a(n-1)]
               O   #  Take the sum of this list
     ₁          +  #  And add it to the a(n-1)'th value
                   # (afterwards the resulting list is output implicitly)

---

@Grimy के 13 बाइट्स संस्करण ( यदि आपने अभी तक नहीं किया है तो उसके उत्तर को सुनिश्चित करें !)

1λ£λ1šÂ¨¨¨øPO

पहले आउटपुट देता है $n$आइटम: इसे ऑनलाइन आज़माएं।

इसके बजाय फिर से 0-आधारित अनुक्रमण या एक अनंत सूची में बदला जा सकता है:
- (0-आधारित) अनुक्रमण 1λèλ1šÂ¨¨¨øPO: इसे ऑनलाइन आज़माएं ;
- अनंत सूची λλ1šÂ¨¨¨øPO: ऑनलाइन प्रयास करें । (ध्यान दें कि 1 के बजाय 2 बाइट्स यहां सहेजे गए हैं, क्योंकि पुनरावर्ती वातावरण से शुरू होता है$a(0)=1$ डिफ़ॉल्ट रूप से।)

स्पष्टीकरण:

इसके बजाय वह अपने अजगर के जवाब के लिए @xnor द्वारा पाए गए फॉर्मूले को इस तरह से लागू करता है :
$a(n) = \sum_{k=2}^{n-1}(a(k)\cdot a(n-2-k))$

$a(-1) = a(0) = a(1) = a(2) = 1$

 λ             # Create a recursive environment,
  £            # to output the first (implicit) input amount of results after we're done
1              # Start this recursive list with 1, thus a(0)=1
               # Within the recursive environment, do the following:
   λ           #  Push the list of values in the range [a(0),a(n)]
    1š         #  Prepend 1 in front of this list
      Â        #  Bifurcate the list (short for Duplicate & Reverse copy)
       ¨¨¨     #  Remove (up to) the last three value in this reversed list
          ø    #  Create pairs with the list we bifurcated earlier
               #  (which will automatically remove any trailing items of the longer list)
           P   #  Get the product of each pair (which will result in 1 for an empty list)
            O  #  And sum the entire list
               # (afterwards the resulting list is output implicitly)

Comments

दिलचस्प है कि यह tio पर 40 सेकंड में एक (1200) को हल कर सकता है, जबकि अन्य पुनरावर्ती 100 से अधिक संख्या के लिए समय निकालता है ...

— स्टीवी ग्रिफिन

I also made (but didn't publish) a recursive version. It's 13 bytes for the first n terms, or 11 bytes for an infinite list. Special-casing a(n-1) costs a lot of bytes and isn't needed (see for example xnor's formula).

— Grimmy

@Grimy Do you mind if I add your recursive solutions to my answer (crediting you of course)? I will leave my original answer as well. But it's nice to see the differences between the original formula and xnor's byte-saving formula. :)

— Kevin Cruijssen

ज़रूर, यह ठीक है!

— ग्रिम्मी

@StewieGriffin हाँ, मैं भी इन पुनरावर्ती अनंत कार्यों की गति से प्रभावित था। शायद एलिक्सिर की ताकत में से एक, और निश्चित रूप से बिलिन आलसी-लोडिंग के कारण। यह n=1000.65 सेकंड में गणना करता है , लेकिन जब मैं आलसी-लोडिंग को अक्षम करता हूं, तो इसके बजाय 60 सेकंड के बाद भी समय समाप्त हो जाएगाn=25 ।

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

Answer 8

पायथन 3 , 59 बाइट्स

वास्तव में अक्षम, a(13)टीआईओ पर समाप्त नहीं होता है।

a=lambda n,k=2:n<4or(n-k<2)*a(n-1)or a(k)*a(n-k-2)+a(n,k+1)

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

Answer 9

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

1WṪ;+¥×Uṫ3SƲ;@Ʋ⁸¡

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

शून्य-अनुक्रमित लेने वाला एक विवादास्पद लिंक $n$ और से सामान्यीकृत कैटलन संख्याओं की सूची लौटाता है $0$ सेवा मेरे $n$।

Answer 10

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

1:1:1:f[1,1,1]
f(x:z)|y<-x+sum(zipWith(*)(init$init z)$reverse z)=y:f(y:x:z)

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

Answer 11

एपीएल (Dyalog विस्तारित) , 34 बाइट्स ^SBCS

-दजिमा को धन्यवाद।

अनाम उपसर्ग लंबोदर।

{⍵≤3:1⋄+/(∇⍵-1),⍵(-×⍥∇¯2+⊢)¨4…⍵}

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

Comments

@ दाज़िमा धन्यवाद TFW कोई मेरी भाषा को मुझसे बेहतर जानता है :-)

— Adám

Answer 12

जाप , 19 17 16 बाइट्स

nवें पद को आउटपुट करता है , 1-अनुक्रमित।

@Zí*Zz2)Ťx}g4Æ1

कोशिश करो

@Zí*Zz2)Ťx}g4Æ1     :Implicit input of integer U
@                    :Function taking an array as an argument via parameter Z
 Zí                  :  Interleave Z with
    Zz2              :  Z rotated clockwise by 180 degrees (simply reversing would be a bye shorter but would modify the original array)
   *                 :  Reduce each pair by multiplcation
       )             :  End interleave
        Å            :  Slice off the first element
         ¤           :  Slice off the first 2 elements
          x          :  Reduce by addition
           }         :End function
            g        :Pass the following as Z, push the result back to it and repeat until it has length U
             4Æ1     :Map the range [0,4) to 1s
                     :Implicit output of the last element

Answer 13

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

f a|a<4=1|z<-g[2..a]=sum$zipWith(*)z$reverse(1:g[0..a-4])
g=map f

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

आप या तो fकिसी अनुक्रम के एक तत्व को प्राप्त करने के लिए उपयोग कर सकते हैं , या उस सूची के सभी मानों को gप्राप्त करने के लिए मानों की एक सूची पास कर सकते हैं ।

Answer 14

फोर्थ (gforth) , 99 81 बाइट्स

: f recursive dup 4 > if 0 over 3 do over 1- i - f i f * + loop else 1 then nip ;

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

आउटपुट nth टर्म है और इनपुट 1-अनुक्रमित है

संपादित करें: xnor के सूत्र पर स्विच करके 17 बाइट्स सहेजे गए। 1-अनुक्रमित का उपयोग करके एक और 1 बाइट को बचाया

कोड स्पष्टीकरण

: f                     \ start a new word definition
  recursive             \ mark that this word will be recursive
  dup 4 >               \ duplicate the input and check if it is greater than 4
  if                    \ if it is:
    0 over              \ create an accumulator and copy n to top of stack
    3 do                \ start counted loop from 3 to n-1
      over 1- i - f     \ recursively calculate f(n-1-i)
      i f               \ recursively calculate f(i)
      * +               \ multiply results and add to accumulator
    loop                \ end the counted loop        
  else                  \ otherwise, if n < 5
    1                   \ put 1 on the stack
  then                  \ end the if block
  nip                   \ drop n from the stack
;                       \ end the word definition

Answer 15

चारकोल , 26 बाइट्स

Ｆ⁵⊞υ¹ＦＮ⊞υΣ✂Ｅ⮌υ×κ§υλ³→Ｉ§υ±⁴

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। 0-अनुक्रमित nth संख्या को प्रिंट करता है, हालांकि यह आंतरिक रूप से 1-इंडेक्सिंग का उपयोग करके गणना करता है। स्पष्टीकरण:

Ｆ⁵⊞υ¹

से शुरू करें a[0] = a[1] = a[2] = a[3] = a[4] = 1। हां, यह 1-अनुक्रमित है, लेकिन फिर एक अतिरिक्त शून्य मूल्य के साथ। यह आपके लिए कोड गोल्फ है।

ＦＮ

एक अतिरिक्त nशब्दों की गणना करें । यह ओवरकिल है, लेकिन यह वांछित पद को खोजना आसान बनाता है जब n<5।

⊞υΣ✂Ｅ⮌υ×κ§υλ³

प्रत्येक पद के लिए, अगले पद की गणना तीन शब्दों को छोड़कर, अब तक के शब्दों के योग से गुणा किए गए शब्दों के योग के रूप में करें।

→

यह चारकोल को 2-तर्क के रूप में पार्स करने के Sliceलिए उपयोग में लाई जाने वाली एक नो-ऑप है , अन्यथा मुझे तीन शब्दों को हटाने के कम गोल्फ के तरीके का उपयोग करना होगा।

Ｉ§υ±⁴

4 वीं अंतिम अवधि आउटपुट।

Answer 16

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

J*4]1VQ=+J+eJsPP*M.t,PJ_PJ0;<J

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

पहले लौटता है $n$ अनुक्रम के तत्व।

J*4]1VQ=+J+eJsPP*M.t,PJ_PJ0;<JQ # Full program, last Q = input (implicitly added)
J*4]1                  # J = 4 * [1] (=[1,1,1,1])
VQ                     # for N in range(Q):
  =+J                  #  J +=
     +eJ               #   J[-1] + 
        s              #    sum(                           )
           *M          #     map(__operator_mul,          )
             .t      0 #      transpose(          , pad=0)
               ,       #       [       ,         ]
                PJ     #         J[:-1] 
                  _PJ  #                 J[1::-1]
<JQ                    # J[::Q]

वैकल्पिक: को वापस करने के <साथ बदलें@$n$अनुक्रम का-तत्व, ०-अनुक्रमित।

Answer 17

रूबी , 42 41 बाइट्स

f=->n{n<4?1:(4..n).sum{|i|f[i-1]*f[n-i]}}

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

1-अनुक्रमित (1 बाइट बचाने के लिए)

Answer 18

ऑक्टेव , 73 बाइट्स

g=(1:4).^0;for(i=3:(n=input('')))g(i+2)=g(4:i+1)*g(i-(2:i-1))';end;g(end)

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

-2 बाइट्स स्टिव ग्रिफिन की बदौलत। एक बार फिर, आवधिक दृष्टिकोण कार्यात्मक पुनरावर्ती दृष्टिकोण पर जीतता है। वह एक नीचे दिखाया गया है।

ऑक्टेव , 75 बाइट्स

f(f=@(a)@(n){@()sum(arrayfun(@(k)a(a)(k)*a(a)(n-2-k),2:n-1)),1}{2-(n>3)}())

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

कैप्चा यह सत्यापित करना चाहता था कि यह पोस्ट करते समय मैं एक मानव था। सच कहूं, तो मुझे यकीन नहीं है ।

Comments

मैं पाश दृष्टिकोण को छोटा करने के लिए कोई स्पष्ट तरीके नहीं देख सकता ... यह बहुत अच्छी तरह से गोल्फ दिखता है! इसके अलावा, यह अक्सर नहीं होता है कि मैं ऑक्टेव में शून्य-आधारित अनुक्रमण देखता हूं :)

— स्टीवी ग्रिफिन

@StewieGriffin चूंकि रिकर्सन में कुछ ऑफ़सेट्स हैं, इसलिए यदि आप शून्य- या एक अनुक्रमण को चुनते हैं तो यह वास्तव में कोई मायने नहीं रखता है। मुझे लगता है कि अगर मैं 2-इंडेक्सिंग करता तो शायद मैं कुछ बाइट्स को शेव कर सकता था, लेकिन ऐसा लगता था कि यह धोखा है। वैसे भी, आपका अंतर्ज्ञान सही था - किसी भी तरह, यह वास्तव में एक गुमनाम पुनरावर्ती तरीके से छोटा था। मुझे लगता है कि मुख्य लाभ यह है कि यह चार प्रारंभिक मूल्यों को बहुत अच्छी तरह से बनाता है क्योंकि यह सिर्फ 1 रिटर्न देता है n<4।

— 13

@StewieGriffin बेशक, अच्छा पुराना मैट्रिक्स गुणा है। बहुत बढ़िया!

— सैनचाइज

Answer 19

पर्ल 5 -MList::Util=sum , 61 बाइट्स

sub a{my$b=-2+pop;$b<2||sum a($b+1),map{a($_)*a($b-$_)}2..$b}

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

Answer 20

C / C ++ , 70 69 67 बाइट्स

-1 बाइट जोनाथन को धन्यवाद।

int a(int n){int k=2,s=0;while(++k<n)s+=a(k)*a(n+~k);return s?s:1;}

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

Comments

कर सकते हैं a(n-1-k) है a(n+~k)?

— जोनाथन फ्रेच

@ जोनाथनफ्रेच भी a(++k)*a(n-k) काम करने की संभावना है, और यह आगे से 2 बाइट्स छोड़ देता है for। लेकिन मुझे अपरिभाषित व्यवहार की गंध आती है।

— पोलफोसोल ఠ_ఠ

यह एक अनुक्रमण मुद्दा प्रतीत होता है; निश्चित रूप से यू.बी.

— जोनाथन फ्रेच