Bu çok yaygın olarak bilinmese de, Fibonacci dizisi AKA dediğimiz

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

aslında Duonacci dizisi olarak adlandırılır . Bunun nedeni bir sonraki sayıyı almak için önceki 2 sayıyı toplamanızdır. Ayrıca Tribonacci dizisi var.

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

çünkü bir sonraki sayı önceki 3 sayının toplamıdır. Ve Quadronacci dizisi

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

Ve herkesin favorisi, Pentanacci dizisi:

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

Ve Hexanacci dizisi, Septanacci dizisi, Octonacci dizisi ve benzeri, N-Bonacci dizisine kadar devam eder.

N-bonacci dizisi daima arka arkaya N 1 ile başlar .

Meydan okuma

İki sayı N ve X alan ve ilk X N-Bonacci sayılarını yazan bir işlev veya program yazmalısınız. N, 0'dan büyük bir tam sayı olacaktır ve hiçbir N-Bonacci sayısının, dilinizdeki varsayılan sayı türünü aşmayacağını güvenle kabul edebilirsiniz. Çıktı, insan tarafından okunabilir herhangi bir biçimde olabilir ve herhangi bir makul şekilde girdi alabilirsiniz. (Komut satırı argümanları, fonksiyon argümanları, STDIN, vs.)

Her zaman olduğu gibi, bu Code-golf, bu yüzden standart boşluklar geçerli ve bayt cinsinden en kısa cevap kazanıyor!

Örnek 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

Boolfuck, 6 bayt

,,[;+]

N-Bonacci numaralarının sizin dilinizde varsayılan numara tipini geçmeyeceğini güvenli bir şekilde kabul edebilirsiniz.

Boolfuck'ta varsayılan sayı türü bir bit. Bunun, N ve X giriş numaralarına da uzandığını ve N> 0 verildiğine göre, sadece iki olası girişin var olduğunu varsayalım - 10 (hiçbir şey çıkmaz) ve 11 (1 çıkış).

,mevcut hafıza konumuna biraz okur. N olması gerektiği gibi göz ardı edilir. X, 0 ise, döngü gövdesi (çevrili []) atlanır. Eğer X 1 ise, çıkış verilir ve daha sonra 0'a çevrilir, böylece döngü tekrarlanmaz.

Python 2,79 bayt

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

Çevrimiçi deneyin

Pyth, 13

<Qu+Gs>QGEm1Q

Test odası

nİlk önce girişi yeni satır ayırır .

Açıklama:

<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

Haskell, 56 bayt

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

Kullanım örneği: 3 # 8-> [1,1,1,3,5,9,17,31].

Nasıl çalışır

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

Python 2,55 bayt

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

nListedeki bir uzunluk penceresini izler l, toplamı ekleyerek ve ilk öğeyi kaldırarak güncellenir. Her bir yinelemenin ilk elemanını yazdırır x.

Tüm unsurları depolamak ve son ndeğerleri toplamak için farklı bir yaklaşım aynı uzunluğu verdi (55).

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

Javascript ES6 / ES2015, 107 97 85 80 Bayt

@ User81655, @Neil ve @ETHproductions ile bazı baytları kaydedin

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

çevrimiçi dene

Test durumları:

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

ES6, 66 bayt

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

Ne yazık ki mapgeri aramadaki sonuç dizisine erişmenize izin vermiyor.

Jöle, 12 bayt

ḣ³S;
b1Ç⁴¡Uḣ

Çevrimiçi deneyin!

Nasıl çalışır

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.

C ++ 11, 360 bayt

Merhaba ben sadece bu soruyu seviyorum. C ++ bu yarışmayı kazanmak için çok zor bir dil olduğunu biliyorum. Ama ben herhangi bir şekilde kuruş atacağım.

#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;}

Bunu yukarıdaki kodun okunabilir açıklaması olarak bırakacağım.

#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;
}

Haskell , 47 bayt

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

Çevrimiçi deneyin!

<$ Bu zorluğun yayınlanmasından sonra Prelude'a girmiş olabilirsiniz.

Haskell , 53 bayt

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

Çevrimiçi deneyin!

?Gibi kullanılan ikili işlevi tanımlar 3?8 == [1,1,1,3,5,9,17,31].

Yardımcı fonksiyon , önceki değerleri toplayarak -bonacci dizisinin th elemanını tekrarlı bir şekilde %bulur . Ardından, işlev ilk değerlerini tablo halinde verir .inn?x%

APL, 21

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

Bu, n'yi sol argümanı, x'i sağ argümanı olarak alan bir fonksiyondur .

Açıklama:

{⍵↑⍺{⍵,+/⍺↑⌽⍵}⍣⍵+⍺/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

Test durumları:

      ↑⍕¨ {⍵↑⍺{⍵,+/⍺↑⌽⍵}⍣⍵+⍺/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              

Python 3, 59

FryAmTheEggman sayesinde 20 bayt kurtarıldı.

Harika bir çözüm değil, şimdilik işe yarayacak.

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

Ayrıca, burada test durumları:

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]

Java, 82 + 58 = 140 bayt

İşlev bulmak için ith n -bonacci numarası ( 82 bayt ):

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;}

İlk k n- bonacci numarasını ( 58 bayt ) yazdırma işlevi :

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

Brain-Flak , 144 124 122 bayt

Nitroden sayesinde -20 bayt

Bu benim ilk Brain-Flak cevabım ve geliştirilebileceğinden eminim. Herhangi bir yardım takdir edilmektedir.

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

Çevrimiçi deneyin!

Pari / GP , 46 bayt

Dizinin üretici işlevi şudur:

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

Çevrimiçi deneyin!

Julia, 78 bayt

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

Bu, iki tam sayı kabul eden ve bir tam sayı dizisi döndüren bir işlevdir. Yaklaşım basittir: Uzunluğa sahip bir dizi oluşturun n, ardından ndizi uzunluğa kadar önceki öğelerin toplamını ekleyerek diziyi büyütü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

MATL , 22 26 bayt

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

Bu , dilin / derleyicinin geçerli sürümünü (10.2.1) kullanır .

Çevrimiçi deneyin!

Birkaç ekstra bayt :-( Gfonksiyondaki bir hata nedeniyle (yapıştırma girişi; şimdi bir sonraki sürüm için düzeltildi)

açıklama

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

Perl 6 , 38 bayt

->\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
}

Kullanımı:

# 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)

C, 132 bayt

Özyinelemeli yaklaşım birkaç bayt daha kısadır.

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));
}

Kabuğu , 9 bayt

↑§¡ȯΣ↑_B1

Çevrimiçi deneyin!

Den başlar BASE- 1temsil N (basitçe bir listesi , N olanlar) ve ¡teratively toplamlar ( Σ) (son ↑_) , N elemanları ve listeye sonucu ekler. Son olarak, bu listedeki ↑ilk X sayısını alır ve döndürür.

Ruby , 41 bayt

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

Çevrimiçi deneyin!

R , 68 bayt

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

Çevrimiçi deneyin!

K (ngn / k) , 26 24 bayt

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

Çevrimiçi deneyin!

Perl 6, 52 ~ 72 47 ~ 67 bayt

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

MONKEY-SEE-NO-EVALAşağıdaki hata nedeniyle modül gerektirir :

=== SORRY! === -e
EVAL derlenirken hata çok tehlikeli bir fonksiyondur !!! (geçersiz kılmak için MONKEY-SEE-NO-EVAL kullanın,
ancak yalnızca verilerinizin enjeksiyon krizi içermediğinden eminseniz)
-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)

PHP , 78 bayt

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

Çevrimiçi deneyin!

PHP kullanarak -4 bayt> = 7.1 [,$n,$x]yerinelist(,$n,$x)

Jq 1.5 , 67 bayt

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

Örneğin N ve X tarafından sağlanan girişi varsayar.

def N: 5;
def X: 11;

Expanded

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

Çevrimiçi deneyin!

J, 31 bayt

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

Ungolfed:

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

açıklama

Gerund biçimindeki güç fiiliyle eğlenceli zamanlar :

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

Ayrıntılı Arıza:

• ] {. ...<right arg>Tüm bu şeylerden ilk unsurları, işi yapan sağa alın ...
• <left> ^: <right>fiilini <left>defalarca uygulayın <right>… burada <right>ortadaki fiil tarafından belirtilen (-@[] (1 #~ [)yani ], yani fonksiyonun kendisine verilen doğru argüman. Yani nedir <left>? ...
• (] , [: +/ [ {. ])Bu tüm cümlenin sol argümanı ilk önce ilk gerund, yani -@[. Bu, bu cümlenin sol argümanının, sol argümanın genel fonksiyona negatif olduğu anlamına gelir . Bu gereklidir, böylece cümle , oluşturduğumuz geri dönüş listesindeki son öğeleri [ {. ]alır . Bu daha sonra toplanmaktadır: . Ve son olarak aynı dönüş listeye eklenir: .+/] ,
• Peki iade listesi nasıl başlatıldı? Üçüncü ön işleme işleminin gerçekleştirdiği şey: (1 #~ [)- 1 "sol arg" ı defalarca tekrarlayın.

Çevrimiçi deneyin!

Mathematica, 59 bayt

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

Muhtemelen Clear@fişlev çağrıları arasında seçim yapmak isteyeceksiniz . Argümanlar n,xtıpkı test senaryoları gibi.

Düzenli , 36 bayt

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

Çevrimiçi deneyin!

açıklama

{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`

Japt , 18 bayt

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

Çevrimiçi deneyin!

Açıklama:

         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