이것은 널리 알려져 있지 않지만 피보나치 시퀀스, AKA라고 부르는 것

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

실제로 Duonacci 시퀀스 라고합니다 . 다음 숫자를 얻으려면 이전 두 숫자를 합산하기 때문입니다. 도있다 Tribonacci의 순서는,

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

다음 숫자는 이전 3 개의 숫자의 합이므로 그리고 Quadronacci 시퀀스

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

그리고 모두가 가장 좋아하는 Pentanacci 시퀀스 :

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

그리고 Hexanacci 서열, Septanacci 서열, Octonacci 서열 등은 N-Bonacci 서열까지입니다.

N- 보나 치 수열은 항상 연속적으로 N 1로 시작 합니다.

도전

두 개의 숫자 N 과 X 를 취하고 첫 번째 X N- 보나 치 수를 인쇄 하는 함수 나 프로그램을 작성해야합니다 . 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

Boolfuck, 6 바이트

,,[;+]

N-Bonacci 숫자가 사용자 언어의 기본 숫자 유형을 초과하지 않는다고 가정 할 수 있습니다.

Boolfuck의 기본 숫자 유형은 약간입니다. 이것도 입력 번호 N과 X로 확장되고 N> 0이라고 가정하면 10 (아무것도 출력하지 않음)과 11 (1을 출력하는 것)의 두 가지 가능한 입력 만 있습니다.

,현재 메모리 위치로 비트를 읽습니다. N은 1이어야하므로 무시됩니다. X가 0 인 경우 루프 본문 (으로 둘러싸인 [])을 건너 뜁니다. X가 1이면 출력되고 0으로 전환되어 루프가 반복되지 않습니다.

파이썬 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

온라인으로 사용해보십시오

피스, 13

<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

하스켈, 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

파이썬 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]

자바 스크립트 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

ES6, 66 바이트

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

슬프게도 map콜백에서 결과 배열에 액세스 할 수 없습니다.

젤리, 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.

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

하스켈 , 47 바이트

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

온라인으로 사용해보십시오!

<$ 이 챌린지가 게시 된 후 Prelude에 소개되었을 수 있습니다.

하스켈 , 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].

보조 함수 는 이전 값 을 합산하여 -bonacci 시퀀스 %의 ith 요소를 재귀 적으로 찾습니다 . 그런 다음이 함수 는의 첫 번째 값을 표로 표시합니다 .nn?x%

APL, 21

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

파이썬 3, 59

FryAmTheEggman 덕분에 20 바이트를 절약했습니다.

훌륭한 해결책은 아니지만 지금은 효과가 있습니다.

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]

자바, 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));}}

뇌 플랙 , 144 (124) 122 바이트

Nitroden 덕분에 -20 바이트

이것이 내 첫 Brain-Flak 답변이며 개선 될 수 있다고 확신합니다. 도움을 주시면 감사하겠습니다.

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

온라인으로 사용해보십시오!

Pari / GP , 46 바이트

시퀀스의 생성 기능은 다음과 같습니다.

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

온라인으로 사용해보십시오!

줄리아, 78 바이트

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

두 개의 정수를 허용하고 정수 배열을 리턴하는 함수입니다. 접근 방식은 간단합니다. length의 배열을 생성 한 n다음 n배열이 length가 될 때까지 이전 요소 의 합을 추가하여 배열을 확장하십시오 x.

언 골프 드 :

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 바이트

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

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

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

언 골프

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

껍질 , 9 바이트

↑§¡ȯΣ↑_B1

온라인으로 사용해보십시오!

로부터 시작 Base- 1의 표현 N (단순히 목록 N의 것) 및 ¡teratively 합계 ( Σ) (마지막 ↑_) N 요소 목록에 결과를 추가합니다. 마지막 으로이 목록 ↑의 첫 번째 X 숫자를 ( ) 가져 와서 반환합니다.

루비 , 41 바이트

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

온라인으로 사용해보십시오!

R , 68 바이트

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

온라인으로 사용해보십시오!

K (ngn / k) , 26 24 바이트

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

온라인으로 사용해보십시오!

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

PHP , 78 바이트

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

온라인으로 사용해보십시오!

[,$n,$x]대신 PHP> = 7.1 를 사용하는 -4 바이트list(,$n,$x)

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

온라인으로 사용해보십시오!

J, 31 바이트

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

언 골프 드 :

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

설명

거동 형태의 파워 동사 와 함께하는 즐거운 시간 :

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

상세 내역 :

• ] {. ...<right arg>이 모든 것들에서 첫 번째 요소를 올바르게 수행하십시오.
• <left> ^: <right>동사 적용 <left>반복 <right>배 ... <right>중간 동명사에 의해 지정 (-@[] (1 #~ [), 즉 ], 즉, 함수 자체에 전달 된 권리 인수를. 그래서 무엇 <left>입니까? ...
• (] , [: +/ [ {. ])이 전체 구에 대한 왼쪽 주장은 먼저 첫 번째 gerund에 의해 변환됩니다 -@[. 즉,이 문구 에 대한 왼쪽 인수는 전체 함수에 대한 왼쪽 인수 의 음수 입니다. 이것은 문구 [ {. ]가 우리가 구축하고있는 반환 목록에서 마지막 요소를 가져 오도록 하기 위해 필요 합니다. 그런 다음 요약 +/됩니다.. 그리고 마지막으로 동일한 반환 목록에 추가되었습니다 ] ,.
• 그렇다면 반환 목록은 어떻게 초기화됩니까? 이것이 세 번째 전처리 gerund가 달성 한 것입니다 : (1 #~ [)-1 개의 "left arg"를 여러 번 반복하십시오.

온라인으로 사용해보십시오!

수학, 59 바이트

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

아마도 Clear@f함수 호출 사이를 원할 것입니다 . 인수는 n,x테스트 사례와 같습니다.

깔끔한 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`

apt , 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