54

यह बहुत व्यापक रूप से ज्ञात नहीं है, लेकिन जिसे हम फाइबोनैचि अनुक्रम, एकेए कहते हैं

1, 1, 2, 3, 5, 8, 13, 21, 34...

वास्तव में डुओनाइन अनुक्रम कहा जाता है । ऐसा इसलिए है क्योंकि अगला नंबर प्राप्त करने के लिए, आप पिछली 2 संख्याओं को जोड़ते हैं। त्रिभुज अनुक्रम भी है ,

1, 1, 1, 3, 5, 9, 17, 31, 57, 105, 193, 355, 653, 1201...

क्योंकि अगला नंबर पिछली 3 संख्याओं का योग है। और चतुर्भुज क्रम

1, 1, 1, 1, 4, 7, 13, 25, 49, 94, 181, 349, 673...

और हर किसी का पसंदीदा, पेन्टानिक अनुक्रम:

1, 1, 1, 1, 1, 5, 9, 17, 33, 65, 129...

और हेक्सानिक सीक्वेंस, सेप्टानिक सीक्वेंस, ऑक्टोनाक सीक्वेंस, और इसी तरह से एन- बोआइस सीक्वेंस तक आगे।

N-bonacci अनुक्रम हमेशा N 1s के साथ एक पंक्ति में शुरू होगा ।

चुनौती

आपको एक फ़ंक्शन या प्रोग्राम लिखना होगा जो दो नंबर N और X लेता है , और पहले X N-Bonacci नंबर प्रिंट करता है । N 0 की तुलना में पूरी संख्या में बड़ा होगा, और आप सुरक्षित रूप से मान सकते हैं कि कोई N-Bonacci नंबर आपकी भाषा में डिफ़ॉल्ट संख्या प्रकार से अधिक नहीं होगा। आउटपुट किसी भी मानव पठनीय प्रारूप में हो सकता है, और आप किसी भी उचित तरीके से इनपुट ले सकते हैं। (कमांड लाइन तर्क, फ़ंक्शन तर्क, STDIN, आदि)

हमेशा की तरह, यह कोड-गोल्फ है, इसलिए मानक खामियां लागू होती हैं और बाइट्स में सबसे कम जवाब जीतता है!

नमूना IO

#n,  x,     output
 3,  8  --> 1, 1, 1, 3, 5, 9, 17, 31
 7,  13 --> 1, 1, 1, 1, 1, 1, 1, 7, 13, 25, 49, 97, 193
 1,  20 --> 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
 30, 4  --> 1, 1, 1, 1       //Since the first 30 are all 1's
 5,  11 --> 1, 1, 1, 1, 1, 5, 9, 17, 33, 65, 129

code-golf math fibonacci

— DJMcMayhem
स्रोत

1

यार, मुझे यह विचार कुछ समय पहले आया था और इसे लिखने के लिए कभी नहीं मिला।

— मॉर्गन थ्राप

9

मेरा वोट बटन == आपका अवतार

— ETHproductions

3-बोनिसिया नहीं होगा 1, 1, 2, 4, 7जैसा कि तीसरा स्थान होगा 0 + 1 + 1? ... और इसलिए दूसरों के साथ एक?

— छाता

1

@ कोम्ब्रेला नं, आदिवासी 3 1s के साथ शुरू होता है। इस बिंदु को स्पष्ट करने के लिए मेरा संपादन देखें।

— DJMcMayhem

23

बूलफक, 6 बाइट्स

,,[;+]

आप सुरक्षित रूप से मान सकते हैं कि आपकी भाषा में डिफ़ॉल्ट संख्या प्रकार से अधिक कोई एन-बोनसीस संख्या नहीं होगी।

बूलफक में डिफ़ॉल्ट संख्या प्रकार थोड़ा है। यह मानते हुए कि इनपुट संख्या एन और एक्स तक भी फैली हुई है, और उस एन> 0 को देखते हुए, केवल दो संभावित इनपुट हैं - 10 (जो कुछ भी नहीं आउटपुट) और 11 (जो आउटपुट 1)।

,वर्तमान मेमोरी लोकेशन में थोड़ा सा पढ़ता है। एन को नजरअंदाज कर दिया जाना चाहिए क्योंकि 1. यदि एक्स 0 है, तो लूप बॉडी (चारों ओर से []) को छोड़ दिया जाता है। यदि X 1 है, तो यह आउटपुट है और फिर 0 पर फ़्लिप किया जाता है ताकि लूप रिपीट न हो।

— user253751
स्रोत

4

क्या इस तरह एक मानक खामियाजा नहीं है?

— स्टेन स्ट्रम

1

@StanStrum इस उत्तर से पहले या बाद में?

— user253751

2

मेरा मानना है कि यह पहले आया था, मुझे इसकी जांच करने दें ... मेटा लिंक ; पहला संशोधन 31 जनवरी, 2016 को 13:44 बजे था। वाह, कोई बात नहीं! मैं दो दिन की छुट्टी पर था। हालांकि, जिद्दी होने के लिए, इसके लिए अंतिम संपादन 31 जनवरी, 2016 को 16:06 पर किया गया था। Soooooo हाँ, यह मेरी किताब में ठीक है

— स्टेन

9

पायथन 2, 79 बाइट्स

n,x=input()
i,f=0,[]
while i<x:v=[sum(f[i-n:]),1][i<n];f.append(v);print v;i+=1

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

— लैम्ब्डा
स्रोत

आखिरी पंक्ति को बदलने की कोशिश करेंexec"v=[sum(f[i-n:]),1][i<n];f+=[v];print v;i+=1;"*x

— Cyoce

8

अजगर, १३

<Qu+Gs>QGEm1Q

परीक्षण सूट

nपहले के साथ इनपुट न्यूलाइन को अलग कर दिया गया ।

स्पष्टीकरण:

<Qu+Gs>QGEm1Q  ##  implicit: Q = eval(input)
  u      Em1Q  ##  read a line of input, and reduce that many times starting with
               ##  Q 1s in a list, with a lambda G,H
               ##  where G is the old value and H is the new one
   +G          ##  append to the old value
     s>QG      ##  the sum of the last Q values of the old value
<Q             ##  discard the last Q values of this list

— FryAmTheEggman
स्रोत

1

वाह, यह तेज़ था। आपके द्वारा यह पोस्ट करने से पहले मेरे पास अपना ब्राउज़र बंद करने का मुश्किल से समय था!

— DJMcMayhem

5

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

g l=sum l:g(sum l:init l)
n#x|i<-1<$[1..n]=take x$i++g i

प्रयोग उदाहरण: 3 # 8-> [1,1,1,3,5,9,17,31]।

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

i<-1<$[1..n]           -- bind i to n copies of 1
take x                 -- take the first x elements of
       i++g i          -- the list starting with i followed by (g i), which is
sum l:                 -- the sum of it's argument followed by
      g(sum l:init l)  -- a recursive call to itself with the the first element
                       -- of the argument list replaced by the sum

— nimi
स्रोत

tail lइसके बजाय नहीं होना चाहिए init l?

— गर्वित हैकेलर

@proudhaskeller: इससे कोई फर्क नहीं पड़ता। हम अंतिम nतत्वों को सूची में रखते हैं। अंत से हटाने और सामने और दूसरे रास्ते से जोड़ने के बीच कोई अंतर नहीं है, अर्थात सामने से हटाकर अंत तक जोड़ना, क्योंकि प्रारंभिक सूची केवल 1एस से बनी है।

— nimi

अच्छा मैं समझा। यह एक निफ्टी तरीका है ++[]द्वारा प्रतिस्थापित करने के लिए :!

— गौरवशाली हैकेलर

@proudhaskeller: हाँ, बिल्कुल!

— नीमी

5

पायथन 2, 55 बाइट्स

def f(x,n):l=[1]*n;exec"print l[0];l=l[1:]+[sum(l)];"*x

nसूची में अनुक्रम की एक लंबाई- विंडो को ट्रैक करता है l, योग को जोड़कर और पहले तत्व को हटाकर अद्यतन किया जाता है। पुनरावृत्तियों के लिए प्रत्येक पुनरावृत्ति का पहला तत्व प्रिंट करता है x।

सभी तत्वों को संग्रहीत करने और अंतिम nमानों को समेटने का एक अलग तरीका समान लंबाई (55) दिया गया।

def f(x,n):l=[1]*n;exec"l+=sum(l[-n:]),;"*x;print l[:x]

— XNOR
स्रोत

5

जावास्क्रिप्ट ES6 / ES2015, 107 97 85 80 बाइट्स

कुछ बाइट्स बचाने के लिए @ user81655, @Neil और @ETHproductions का धन्यवाद

(i,n)=>eval("for(l=Array(i).fill(1);n-->i;)l.push(eval(l.slice(-i).join`+`));l")

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

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

console.log(f(3,  8))// 1, 1, 1, 3, 5, 9, 17, 31
console.log(f(7,  13))// 1, 1, 1, 1, 1, 1, 1, 7, 13, 25, 49, 97, 193
console.log(f(5,  11))// 1, 1, 1, 1, 1, 5, 9, 17, 33, 65, 129

— gabrielperales
स्रोत

1

अच्छा लगा। गोल्फ युक्तियाँ के एक जोड़े: forहमेशा की तुलना में बेहतर है while, x.split('')-> [...x], ~~a-> +a, n-=1-> n--, यदि आप पूरे समारोह शरीर संलग्न आप में evalलिखने की जरूरत नहीं है return। इसके अलावा, की तुलना में भी कम [...'1'.repeat(i)]है Array(i).fill(1)और आप निकाल सकते हैं ~~से aऔर b। और आपको निकालने की अनुमति है f=।

— user81655

2

यह वही है यह मेरे सुझावों (85 बाइट्स) के साथ की तरह लग रहा है: (i,n)=>eval("for(l=Array(i).fill(1);n-->i;)l.push(l.slice(-i).reduce((a,b)=>a+b));l")। मैं बयान का क्रम बदल, संयुक्त n--में n-iऔर हटाया lकुछ अतिरिक्त बाइट्स को बचाने के लिए तर्क से।

— user81655

1

@ user81655 मुझे evalबचत नहीं मिलती ; (i,n)=>{for(l=Array(i).fill(1);n-->i;)l.push(l.slice(-i).reduce((a,b)=>a+b));return l}अभी भी 85 बाइट्स है।

— नील

@ नील मुझे 86 बाइट्स लगते हैं ...

— user81655

3

l.slice(-i).reduce((a,b)=>a+b)=>eval(l.slice(-i).join`+`)

— ETHproductions

4

ईएस 6, 66 बाइट्स

(i,n)=>[...Array(n)].map((_,j,a)=>a[j]=j<i?1:j-i?s+=s-a[j+~i]:s=i)

अफसोस की बात है mapकि आप कॉलबैक में परिणाम सरणी तक पहुंचने नहीं देंगे।

— नील
स्रोत

1

मापदंडों को करीने से बाइट सहेजें।

— झबरा

4

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

ḣ³S;
b1Ç⁴¡Uḣ

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

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

b1Ç⁴¡Uḣ  Main link. Left input: n. Right input: x.

b1       Convert n to base 1.
    ¡    Call...
  Ç        the helper link...
   ⁴       x times.
     U   Reverse the resulting array.
      ḣ  Take its first x elements.


ḣ³S;     Helper link. Argument: A (list)

ḣ³       Take the first n elements of A.
  S      Compute their sum.
   ;     Prepend the sum to A.

— डेनिस
स्रोत

3

सी ++ 11, 360 बाइट्स

हाय मुझे यह सवाल पसंद है। मुझे पता है कि इस प्रतियोगिता को जीतने के लिए c ++ बहुत कठिन भाषा है। लेकिन मैं किसी भी तरह से एक पैसा भी फेंक दूंगा।

#include<vector>
#include<numeric>
#include<iostream>
using namespace std;typedef vector<int>v;void p(v& i) {for(auto&v:i)cout<<v<<" ";cout<<endl;}v b(int s,int n){v r(n<s?n:s,1);r.reserve(n);for(auto i=r.begin();r.size()<n;i++){r.push_back(accumulate(i,i+s,0));}return r;}int main(int c, char** a){if(c<3)return 1;v s=b(atoi(a[1]),atoi(a[2]));p(s);return 0;}

मैं इसे ऊपर दिए गए कोड के पठनीय स्पष्टीकरण के रूप में छोड़ दूँगा।

#include <vector>
#include <numeric>
#include <iostream>

using namespace std;
typedef vector<int> vi;

void p(const vi& in) {
    for (auto& v : in )
        cout << v << " ";
    cout << endl;
}

vi bonacci(int se, int n) {
    vi s(n < se? n : se, 1);
    s.reserve(n);
    for (auto it = s.begin(); s.size() < n; it++){
        s.push_back(accumulate(it, it + se, 0));
    }
    return s;
}

int main (int c, char** v) {
    if (c < 3) return 1;
    vi s = bonacci(atoi(v[1]), atoi(v[2]));
    p(s);
    return 0;
}

— hetepeperfan
स्रोत

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

— wizzwizz4

@ wizzwizz4 हाय, ऊपर कोड का एक गोल्फ संस्करण जोड़ा। मैंने लोगों को यह देखने के लिए कि मैंने यह कैसे किया, चारों ओर असंगठित कोड छोड़ दिया। इसके अलावा, मैं एक फ़ंक्शन बोनिक्स पढ़ना चाहता हूं जो vi लौटाता है जो अभी भी खिंचाव की तरह लगता है। मुझे लगता है कि मुझे मुख्य कार्य को कम नहीं करना चाहिए क्योंकि मानक मुख्य कार्यक्रम के प्रवेश बिंदु के रूप में मुख्य मुख्य (int, char **) का उपयोग करते हैं। इसके अलावा मेरा मानना है कि सभी चर अधिकतम 1 वर्ण लंबे हैं और सभी गैर महत्वपूर्ण व्हाट्सएप हटा दिए गए हैं।

— hetepeperfan

3

यह कोड नहीं है- "मानकों का अनुपालन करें"। यह कोड-गोल्फ है । हम अपनी भाषाओं में हेरफेर करते हैं और फायदा उठाते हैं। यदि कोई चर हैं int, तो निकालें int। यदि कोई कार्य कहा जाता है foo, तो उन्हें कॉल करें f। क्रूर हो; मानक की उपेक्षा करें और संकलक का शोषण करें। यह है कि आप कैसे गोल्फ है।

— wizzwizz4

पुंस और अच्छा कोड केवल अनगुल्ड कोड में हैं । लेकिन बेझिझक उन्हें वहां रखें; वास्तव में, यह करने के लिए सिफारिश की है। लेकिन वास्तव में, वास्तव में संकलक से मतलब है जब आप अपना कोड गोल्फ करते हैं। इसे जितना संभव हो उतना छोटा कर दें । (ओह, और यहाँ +1 मैंने वादा किया है!)

— wizzwizz4

@ wizzwizz4 क्या "int" को वैध मान रहा है? मैंने सोचा कि int int नहीं चलेगा।

— DJMcMayhem

3

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

q(h:t)=h:q(t++[h+sum t])
n?x=take x$q$1<$[1..n]

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

<$ इस चुनौती के पोस्ट होने के बाद शायद प्रस्तावना में पेश किया गया हो।

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

n%i|i>n=sum$map(n%)[i-n..i-1]|0<1=1
n?x=map(n%)[1..x]

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

बाइनरी फ़ंक्शन को परिभाषित करता है ?, जैसे उपयोग किया जाता है 3?8 == [1,1,1,3,5,9,17,31]।

सहायक समारोह %रिकर्सिवली पाता है iकी वें तत्व nपिछले संक्षेप द्वारा -bonacci अनुक्रम nमान। उसके बाद, फ़ंक्शन ?पहले xमानों को सारणीबद्ध करता है %।

— XNOR
स्रोत

पुराना उत्तर, लेकिन क्या आपका मतलब है "सहायक कार्य %"?

— कॉनर ओ'ब्रायन

गार्ड को स्विच करने i<=nमें बदल जाएगा i>n।

— अर्जन जोहान्सन

@ WhenrjanJohansen मैंने देखा कि संपादन करते समय भी, हालाँकि पूरी विधि को वापस देखना बुरा लगता है, इसलिए मैं शायद पूरे गोल्फ को फिर से कर सकता हूँ।

— xnor

2

एपीएल, २१

{⍵↑⍺{⍵,+/⍺↑⌽⍵}⍣⍵+⍺/1}

यह एक ऐसा फंक्शन है जो अपने लेफ्ट लॉजिक के रूप में n लेता है और X अपने राइट लॉजिक के रूप में।

स्पष्टीकरण:

{⍵↑⍺{⍵,+/⍺↑⌽⍵}⍣⍵+⍺/1}
                   ⍺/1  ⍝ begin state: X ones    
                  +     ⍝ identity function (to separate it from the ⍵)
    ⍺{         }⍣⍵     ⍝ apply this function N times to it with X as left argument
      ⍵,               ⍝ result of the previous iteration, followed by...
        +/              ⍝ the sum of
          ⍺↑            ⍝ the first X of
            ⌽          ⍝ the reverse of
             ⍵         ⍝ the previous iteration
 ⍵↑                    ⍝ take the first X numbers of the result

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

      ↑⍕¨ {⍵↑⍺{⍵,+/⍺↑⌽⍵}⍣⍵+⍺/1} /¨ (3 8)(7 13)(1 20)(30 4)(5 11)
 1 1 1 3 5 9 17 31                       
 1 1 1 1 1 1 1 7 13 25 49 97 193         
 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 
 1 1 1 1                                 
 1 1 1 1 1 5 9 17 33 65 129

— मारीनस
स्रोत

2

अजगर 3, 59

20 बाइट्स को FryAmTheEggman को धन्यवाद दिया।

एक महान समाधान नहीं है, लेकिन यह अभी के लिए काम करेंगे।

def r(n,x):f=[1]*n;exec('f+=[sum(f[-n:])];'*x);return f[:x]

इसके अलावा, यहाँ परीक्षण के मामले हैं:

assert r(3, 8) == [1, 1, 1, 3, 5, 9, 17, 31]
assert r(7, 13) == [1, 1, 1, 1, 1, 1, 1, 7, 13, 25, 49, 97, 193]
assert r(30, 4) == [1, 1, 1, 1]

— मॉर्गन थ्राप्प
स्रोत

2

जावा, 82 + 58 = 140 बाइट्स

Ith n -bonacci नंबर ( 82 बाइट्स ) खोजने का कार्य :

int f(int i,int n){if(i<=n)return 1;int s=0,q=0;while(q++<n)s+=f(i-q,n);return s;}

पहले k n -bonacci नंबर ( 58 बाइट्स ) को प्रिंट करने का कार्य :

(k,n)->{for(int i=0;i<k;i++){System.out.println(f(i,n));}}

— HyperNeutrino
स्रोत

2

ब्रेन-फ्लैक , 144 124 122 बाइट्स

नाइट्रोडेन के लिए -20 बाइट्स धन्यवाद

यह मेरा पहला ब्रेन-फ्लैक उत्तर है, और मुझे यकीन है कि इसमें सुधार किया जा सकता है। किसी भी मदद की सराहना की है।

(([{}]<>)<{({}(()))}{}>)<>{({}[()]<<>({<({}<({}<>)<>>())>[()]}{})({}<><({({}<>)<>}<>)>)<>>)}{}<>{({}<{}>())}{}{({}<>)<>}<>

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

— H.PWiz
स्रोत

2

परी / जीपी , 46 बाइट्स

अनुक्रम का निर्माण कार्य है:

\frac{(n - 1) x^{n}}{x^{n + 1} - 2 x + 1} - \frac{1}{x - 1}

$\frac{(n-1)x^n}{x^{n+1}-2x+1}-\frac{1}{x-1}$

(n,m)->Vec(n--/(x-(2-1/x)/x^n)-1/(x-1)+O(x^m))

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

— alephalpha
स्रोत

1

जूलिया, 78 बाइट्स

f(n,x)=(z=ones(Int,n);while endof(z)<x push!(z,sum(z[end-n+1:end]))end;z[1:x])

यह एक फ़ंक्शन है जो दो पूर्णांकों को स्वीकार करता है और एक पूर्णांक सरणी देता है। दृष्टिकोण सरल है: लंबाई वाले लोगों की एक सरणी उत्पन्न करें n, फिर पिछले nतत्वों का योग जोड़कर सरणी बढ़ाएं जब तक कि सरणी की लंबाई न हो x।

Ungolfed:

function f(n, x)
    z = ones(Int, n)
    while endof(z) < x
        push!(z, sum(z[end-n+1:end]))
    end
    return z[1:x]
end

— एलेक्स ए।
स्रोत

1

MATL , 22 26 बाइट्स

1tiXIX"i:XK"tPI:)sh]K)

यह भाषा / संकलक की वर्तमान रिलीज़ (10.2.1) का उपयोग करता है ।

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

कुछ अतिरिक्त बाइट्स :-( Gफ़ंक्शन में बग के कारण (पेस्ट इनपुट; अब अगली रिलीज़ के लिए सही किया गया)

व्याख्या

1tiXIX"      % input N. Copy to clipboard I. Build row array of N ones
i:XK         % input X. Build row array [1,2,...X]. Copy to clipboard I
"            % for loop: repeat X times. Consumes array [1,2,...X]
  t          % duplicate (initially array of N ones)
  PI:)       % flip array and take first N elements
  sh         % compute sum and append to array
]            % end
K)           % take the first X elements of array. Implicitly display

— लुइस मेंडो
स्रोत

1

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

->\N,\X{({@_[*-N..*].sum||1}...*)[^X]} # 38 bytes

-> \N, \X {
  (

    {

      @_[
        *-N .. * # previous N values
      ].sum      # added together

      ||     # if that produces 0 or an error
      1      # return 1

    } ... *  # produce an infinite list of such values

  )[^X]      # return the first X values produced
}

उपयोग:

# give it a lexical name
my &n-bonacci = >\N,\X{…}

for ( (3,8), (7,13), (1,20), (30,4), (5,11), ) {
  say n-bonacci |@_
}

(1 1 1 3 5 9 17 31)
(1 1 1 1 1 1 1 7 13 25 49 97 193)
(1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
(1 1 1 1)
(1 1 1 1 1 5 9 17 33 65 129)

— ब्रैड गिल्बर्ट b2gills
स्रोत

1

सी, 132 बाइट्स

पुनरावर्ती दृष्टिकोण बाइट्स के एक जोड़े से कम है।

k,n;f(i,s,j){for(j=s=0;j<i&j++<n;)s+=f(i-j);return i<n?1:s;}main(_,v)int**v;{for(n=atoi(v[1]);k++<atoi(v[2]);)printf("%d ",f(k-1));}

Ungolfed

k,n; /* loop index, n */

f(i,s,j) /* recursive function */
{
    for(j=s=0;j<i && j++<n;) /* sum previous n n-bonacci values */
        s+=f(i-j);
    return i<n?1:s; /* return either sum or n, depending on what index we're at */
}

main(_,v) int **v;
{
    for(n=atoi(v[1]);k++<atoi(v[2]);) /* print out n-bonacci numbers */
        printf("%d ", f(k-1));
}

— कोल कैमरन
स्रोत

1

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

↑§¡ȯΣ↑_B1

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

से शुरू होता है Base- 1के प्रतिनिधित्व एन (बस की एक सूची एन वाले) और ¡teratively रकम ( Σ) पिछले ( ↑_) एन तत्वों और सूची में परिणाम जोड़ देता है। अंत में, इस सूची में ↑पहले X नंबर लेता है और उन्हें वापस करता है।

— सिंह
स्रोत

1

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

->a,b{r=[1]*a;b.times{z,*r=r<<r.sum;p z}}

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

— जीबी
स्रोत

1

आर , 68 बाइट्स

function(n,x){a=1+!1:n;for(i in n+1:x){a[i]=sum(a[(i-n:1)])};a[1:x]}

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

— रॉबर्ट एस।
स्रोत

1

के (ngn / k) , २६ २४ बाइट्स

{(y-x){y,+/x#y}[-x]/x#1}

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

— घसीट
स्रोत

0

पर्ल 6, ~~52 ~ 72~~ 47 ~ 67 बाइट्स

sub a($n,$x){EVAL("1,"x$n~"+*"x$n~"...*")[^$x]}

MONKEY-SEE-NO-EVALनिम्न त्रुटि के कारण मॉड्यूल की आवश्यकता है :

=== SORRY! === संकलन करते समय त्रुटि -E
EVAL एक बहुत खतरनाक कार्य है !!! (ओवरराइड करने के लिए MONKEY-SEE-NO-EVAL का उपयोग करें,
लेकिन केवल तभी जब आप सुनिश्चित करें कि आपके डेटा में कोई इंजेक्शन हमले नहीं हैं)
: -e: 1

$ perl6 -MMONKEY-SEE-NO-EVAL -e'a(3,8).say;sub a($n,$x){EVAL("1,"x$n~"+*"x$n~"...*")[^$x]}'
(1 1 1 3 5 9 17 31)

— andlrc
स्रोत

किसी को सख्त मोड, आदि को बंद करने का एक तरीका पता है?

— andlrc

मुझे लगता है कि यदि आप प्री-क्रिसमस 2015 पर्ल 6 रिलीज़ का उपयोग करते हैं, तो यह बंदर-देखने-नो-इवेल को लागू नहीं करता है।

— बैटमैन

0

PHP , 78 बाइट्स

for(list(,$n,$x)=$argv;$i<$x;print${$i++}." ")$s+=$$i=$i<$n?1:$$d+$s-=${$d++};

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

-4 बाइट्स के [,$n,$x]बजाय PHP> = 7.1 का उपयोग करनाlist(,$n,$x)

— जार्ग हुल्सरमन
स्रोत

0

Jq 1.5 , 67 बाइट्स

def C:if length>X then.[:X]else.+=[.[-N:]|add]|C end;[range(N)|1]|C

N और X उदाहरण के लिए इनपुट प्रदान करता है

def N: 5;
def X: 11;

विस्तारित

def C:                        # . is current array
    if length>X               # stop when array is as long as X
    then .[:X]                # return first X elements
    else .+=[.[-N:]|add] | C  # recursively add sum of last N elements to array
    end
;
  [range(N)|1]                # initial state
| C

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

— jq170727
स्रोत

0

जे, 31 बाइट्स

]{.(],[:+/[{.])^:(-@[`]`(1#~[))

Ungolfed:

] {. (] , [: +/ [ {. ])^:(-@[`]`(1 #~ [))

व्याख्या

मज़ेदार समय की शक्ति क्रिया के साथ उसके गेरुंड रूप में :

(-@[`]`(1 #~ [)) NB. gerund pre-processing

विस्तार से विराम:

] {. ...इन <right arg>सभी सामानों से पहले तत्वों को उस अधिकार पर ले जाएं जो काम करता है ...
<left> ^: <right>क्रिया को <left>बार- <right>बार लागू करें ... जहां <right>मध्य गेरुंड द्वारा निर्दिष्ट किया गया है (-@[] (1 #~ [), अर्थात ], यानी, सही arg फ़ंक्शन में ही पारित हो गया। तो क्या है <left>? ...
(] , [: +/ [ {. ])इस पूरे वाक्यांश के लिए बायां तर्क पहले गेरुंड, यानी, द्वारा रूपांतरित किया गया है -@[। इसका मतलब है कि इस वाक्यांश के लिए बाएं तर्क समग्र फ़ंक्शन के लिए बाएं तर्क का नकारात्मक है। यह आवश्यक है ताकि वाक्यांश उस वापसी सूची से अंतिम तत्वों को [ {. ]ले जो हम निर्माण कर रहे हैं। उन लोगों को फिर अभिव्यक्त किया गया है :। और अंत में उसी वापसी सूची में संलग्न है :।+/] ,
तो वापसी सूची कैसे शुरू की जाती है? यही तीसरा पूर्व-प्रसंस्करण गेरुंड पूरा करता है: (1 #~ [)- बार-बार 1 "बाएं आर्ग" की संख्या दोहराएं।

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

— जोनाह
स्रोत

0

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

((f@#=1)&/@Range@#;f@n_:=Tr[f[n-#]&/@Range@#];f/@Range@#2)&

आप शायद Clear@fफ़ंक्शन कॉल के बीच चाहते हैं। तर्क n,x, परीक्षण मामलों की तरह ही हैं।

— numbermaniac
स्रोत

0

साफ , 36 बाइट्स

{x,n:n^recur(*tile(x,c(1)),sum@c,x)}

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

व्याख्या

{x,n:n^recur(*tile(x,c(1)),sum@c,x)}
{x,n:                              }   lambda taking parameters `x` and `n`
     n^                                take the first `n` terms of...
       recur(                     )        a recursive function
             *tile(x,c(1)),                whose seed is `x` `1`s
                           sum@c,          taking the sum of each window
                                 x         with a window size of `x`

— कोनोर ओ ब्रायन
स्रोत

0

जाप , 18 बाइट्स

@ZsVn)x}gK=Vì1;K¯U

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

स्पष्टीकरण:

         K=Vì1        :Start with n 1s in an array K
@      }gK            :Extend K to at least x elements by setting each new element to:
      x               : The sum of
 ZsVn                 : The previous n elements
              ;       :Then
               K¯U    :Return the first n elements of K

— कामिल दकरी
स्रोत

N-bonacci अनुक्रम प्रिंट करें

चुनौती

नमूना IO

बूलफक, 6 बाइट्स

पायथन 2, 79 बाइट्स

अजगर, १३

स्पष्टीकरण:

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

पायथन 2, 55 बाइट्स

जावास्क्रिप्ट ES6 / ES2015, 107 97 85 80 बाइट्स

ईएस 6, 66 बाइट्स

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

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

सी ++ 11, 360 बाइट्स

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

एपीएल, २१

अजगर 3, 59

जावा, 82 + 58 = 140 बाइट्स

ब्रेन-फ्लैक , 144 124 122 बाइट्स

परी / जीपी , 46 बाइट्स

जूलिया, 78 बाइट्स

MATL , 22 26 बाइट्स

व्याख्या

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

उपयोग:

सी, 132 बाइट्स

Ungolfed

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

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

आर , 68 बाइट्स

के (ngn / k) , २६ २४ बाइट्स

पर्ल 6, 52 ~ 72 47 ~ 67 बाइट्स

PHP , 78 बाइट्स

Jq 1.5 , 67 बाइट्स

जे, 31 बाइट्स

व्याख्या

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

साफ , 36 बाइट्स

व्याख्या

जाप , 18 बाइट्स

पर्ल 6, ~~52 ~ 72~~ 47 ~ 67 बाइट्स