Điều này không được biết đến rộng rãi, nhưng cái mà chúng ta gọi là chuỗi Fibonacci, AKA

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

thực sự được gọi là chuỗi Duorie . Điều này là do để có được số tiếp theo, bạn tổng 2 số trước đó. Ngoài ra còn có chuỗi Tribonacci ,

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

bởi vì số tiếp theo là tổng của 3 số trước đó. Và trình tự Quadronacci

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

Và yêu thích của mọi người, trình tự Pentanacci :

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

Và Hexanacci chuỗi, các Septanacci chuỗi, các Octonacci chuỗi, và vân vân và vân vân lên đến dãy N-Bonacci.

Chuỗi N-bonacci sẽ luôn bắt đầu với N 1s liên tiếp.

Các thách thức

Bạn phải viết một hàm hoặc chương trình lấy hai số N và X và in ra các số X N-Bonacci đầu tiên . N sẽ là một số nguyên lớn hơn 0 và bạn có thể cho rằng không có số N-Bonacci nào vượt quá loại số mặc định trong ngôn ngữ của bạn. Đầu ra có thể ở bất kỳ định dạng nào có thể đọc được của con người và bạn có thể nhận đầu vào theo bất kỳ cách hợp lý nào. (Đối số dòng lệnh, đối số chức năng, STDIN, v.v.)

Như thường lệ, đây là Code-golf, vì vậy các sơ hở tiêu chuẩn được áp dụng và câu trả lời ngắn nhất trong byte sẽ thắng!

IO mẫu

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

,,[;+]

Bạn có thể cho rằng một cách an toàn không có số N-Bonacci sẽ vượt quá loại số mặc định trong ngôn ngữ của bạn.

Kiểu số mặc định trong Boolfuck là một chút. Giả sử điều này cũng mở rộng đến các số đầu vào N và X, và cho rằng N> 0, chỉ có hai đầu vào khả dĩ - 10 (đầu ra không có gì) và 11 (đầu ra 1).

,đọc một chút vào vị trí bộ nhớ hiện tại. N bị bỏ qua vì nó phải là 1. Nếu X bằng 0, thân vòng lặp (được bao quanh bởi []) được bỏ qua. Nếu X là 1, nó là đầu ra và sau đó được lật về 0 để vòng lặp không lặp lại.

Python 2, 79 byte

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

Dùng thử trực tuyến

Bình thường, 13

<Qu+Gs>QGEm1Q

Phòng thử nghiệm

Đưa dòng mới đầu vào tách ra, với nđầu tiên.

Giải trình:

<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 byte

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

Ví dụ sử dụng: 3 # 8-> [1,1,1,3,5,9,17,31].

Làm thế nào nó hoạt động

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 byte

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

Theo dõi một ncửa sổ dài của chuỗi trong danh sách l, được cập nhật bằng cách nối thêm tổng và xóa phần tử đầu tiên. In phần tử đầu tiên mỗi lần lặp cho các xlần lặp.

Một cách tiếp cận khác nhau về việc lưu trữ tất cả các yếu tố và tổng hợp các ngiá trị cuối cùng có cùng độ dài (55).

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

Javascript ES6 / ES2015, 107 97 85 80 byte

Cảm ơn @ user81655, @Neil và @ETHproductions để lưu một số byte

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

thử trực tuyến

Các trường hợp thử nghiệm:

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 byte

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

Đáng buồn là mapsẽ không cho phép bạn truy cập vào mảng kết quả trong cuộc gọi lại.

Thạch, 12 byte

ḣ³S;
b1Ç⁴¡Uḣ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

Xin chào tôi chỉ thích câu hỏi này. Tôi biết c ++ là một ngôn ngữ rất khó để giành chiến thắng trong cuộc thi này. Nhưng tôi sẽ ném một xu bằng mọi cách.

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

Tôi sẽ để lại điều này như là lời giải thích dễ đọc của đoạn mã trên.

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

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

Hãy thử trực tuyến!

<$ có thể đã được đưa vào Prelude sau khi thử thách này được đăng.

Haskell , 53 byte

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

Hãy thử trực tuyến!

Xác định hàm nhị phân ?, được sử dụng như thế nào 3?8 == [1,1,1,3,5,9,17,31].

Hàm phụ trợ %tìm đệ quy iphần tử thứ của nchuỗi -bonacci bằng cách tính tổng các ngiá trị trước đó . Sau đó, hàm ?lập bảng các xgiá trị đầu tiên của %.

APL, 21

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

Đây là hàm lấy n làm đối số bên trái và x làm đối số bên phải.

Giải trình:

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

Các trường hợp thử nghiệm:

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

Con trăn 3, 59

Đã lưu 20 byte nhờ FryAmTheEggman.

Không phải là một giải pháp tuyệt vời, nhưng nó sẽ hoạt động ngay bây giờ.

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

Ngoài ra, đây là các trường hợp thử nghiệm:

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 byte

Chức năng để tìm ra thứ i n số -bonacci ( 82 byte ):

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

Chức năng in số k n -bonacci đầu tiên ( 58 byte ):

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

Brain-Flak , 144 124 122 byte

-20 byte nhờ Nitroden

Đây là câu trả lời Brain-Flak đầu tiên của tôi và tôi chắc chắn rằng nó có thể được cải thiện. Bất kỳ trợ giúp được đánh giá cao.

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

Hãy thử trực tuyến!

Pari / GP , 46 byte

Hàm tạo của chuỗi là:

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

Hãy thử trực tuyến!

Julia, 78 byte

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

Đây là một hàm chấp nhận hai số nguyên và trả về một mảng số nguyên. Cách tiếp cận rất đơn giản: Tạo một mảng có độ dài n, sau đó tăng mảng bằng cách thêm tổng của các nphần tử trước cho đến khi mảng có độ dài x.

Ung dung:

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 byte

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

Điều này sử dụng bản phát hành hiện tại (10.2.1) của ngôn ngữ / trình biên dịch.

Hãy thử trực tuyến!

Một vài byte bổ sung :-( do lỗi trong Ghàm (dán đầu vào; hiện đã được sửa cho lần phát hành tiếp theo)

Giải trình

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 byte

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

Sử dụng:

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

Cách tiếp cận đệ quy ngắn hơn một vài byte.

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

Ung dung

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

Husk , 9 byte

↑§¡ȯΣ↑_B1

Hãy thử trực tuyến!

Bắt đầu từ Base- 1đại diện của N (đơn giản là một danh sách các N cái) và ¡teratively tiền ( Σ) cuối cùng ( ↑_) N yếu tố và gắn kết quả vào danh sách. Cuối cùng, lấy ( ↑) các số X đầu tiên trong danh sách này và trả về chúng.

Ruby , 41 byte

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

Hãy thử trực tuyến!

R , 68 byte

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

Hãy thử trực tuyến!

K (ngn / k) , 26 24 byte

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

Hãy thử trực tuyến!

Perl 6, 52 ~ 72 47 ~ 67 byte

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

Yêu cầu mô-đun MONKEY-SEE-NO-EVAL, vì các lỗi sau:

=== SORRY! === Lỗi trong khi biên dịch -e
EVAL là một chức năng rất nguy hiểm !!! (sử dụng MONKEY-XEM-NO-EVAL để ghi đè,
nhưng chỉ khi bạn RẤT chắc chắn dữ liệu của bạn không chứa các cuộc tấn công tiêm chích)
tại -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 byte

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

Hãy thử trực tuyến!

-4 byte sử dụng PHP> = 7.1 [,$n,$x]thay vìlist(,$n,$x)

Jq 1.5 , 67 byte

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

Giả sử đầu vào được cung cấp bởi N và X, vd

def N: 5;
def X: 11;

Mở rộng

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

Hãy thử trực tuyến!

J, 31 byte

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

Ung dung:

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

giải trình

Thời gian vui vẻ với động từ sức mạnh ở dạng gerund của nó :

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

Phân tích chi tiết:

• ] {. ...Lấy các <right arg>yếu tố đầu tiên từ tất cả những thứ này sang bên phải để thực hiện công việc ...
• <left> ^: <right>áp dụng động từ <left>lặp đi lặp lại nhiều <right>lần ... trong đó <right>được chỉ định bởi gerund giữa trong (-@[] (1 #~ [), tức ]là, đối số bên phải được truyền vào chính hàm đó. Vậy là <left>gì? ...
• (] , [: +/ [ {. ])Đối số bên trái cho toàn bộ cụm từ này được chuyển đổi đầu tiên bởi gerund đầu tiên, nghĩa là , -@[. Điều đó có nghĩa là đối số bên trái của cụm từ này là phủ định của đối số bên trái cho hàm tổng thể. Điều này là cần thiết để cụm từ [ {. ]lấy các yếu tố cuối cùng từ danh sách trả lại mà chúng tôi đang xây dựng. Những người sau đó được tóm tắt : +/. Và cuối cùng được thêm vào danh sách trả lại đó : ] ,.
• Vậy danh sách trả lại được khởi tạo như thế nào? Đó là những gì gerund tiền xử lý thứ ba đạt được: (1 #~ [)- lặp lại 1 lần "trái arg" số lần.

Hãy thử trực tuyến!

Toán học, 59 byte

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

Có lẽ bạn sẽ muốn Clear@fgiữa các cuộc gọi chức năng. Đối số là n,x, giống như các trường hợp thử nghiệm.

Gọn gàng , 36 byte

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

Hãy thử trực tuyến!

Giải trình

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

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

Hãy thử trực tuyến!

Giải trình:

         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