Це не дуже широко відомо, але те, що ми називаємо послідовністю Фібоначчі, AKA

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-Боханьч.

Послідовність N-бобоніків завжди починатиметься з N 1s підряд.

Змагання

Ви повинні написати функцію або програму, яка приймає два числа N і X , і виводить перші X номери X -Бохань. N буде цілим числом більше 0, і ви можете сміливо припускати, що жодні N-бонакі не перевищуватимуть типовий номер у вашій мові. Вихід може бути у будь-якому читаному для людини форматі, і ви можете приймати дані будь-яким розумним чином. (Аргументи командного рядка, аргументи функції, STDIN тощо)

Як завжди, це Code-golf, тому застосовуються стандартні лазівки і найкоротша відповідь у байтах виграє!

Зразок 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

Болфук, 6 байт

,,[;+]

Ви можете з упевненістю припустити, що жоден номер N-Bojeca не перевищить типовий номер у вашій мові.

Тип номера за замовчуванням у Boolfuck - це трохи. Якщо припустити, це також поширюється на вхідні числа N і X, а враховуючи, що N> 0, є лише два можливі входи - 10 (що нічого не видає) і 11 (які виводить 1).

,трохи читає поточне місце в пам'яті. N ігнорується як має бути 1. Якщо X дорівнює 0, тіло циклу (оточене []) пропускається. Якщо X дорівнює 1, він виводиться, а потім перевертається на 0, щоб цикл не повторювався.

Python 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

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

Python 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]

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

Haskell , 47 байт

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

Спробуйте в Інтернеті!

<$ можливо, було введено в Прелюді після публікації цього виклику.

Haskell , 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послідовності -бонаборів шляхом підсумовування попередніх nзначень. Потім функція відображає в ?таблиці перші 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

Збережено 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]

Java, 82 + 58 = 140 байт

Функція для знаходження i-го числа n -бобочки ( 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 -бобочного числа ( 58 байт ):

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

Мозг-Флак , 144 124 122 байт

-20 байт завдяки Nitroden

Це моя перша відповідь Мозку-Флака, і я впевнений, що її можна вдосконалити. Будь-яка допомога вдячна.

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

Спробуйте в Інтернеті!

Парі / 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])

Це функція, яка приймає два цілих числа і повертає цілий масив. Підхід простий: Створіть масив з довжини n, а потім зростіть масив, додавши суму попередніх nелементів, поки масив не набере довжину 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

Perl 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 (нг / к) , 26 24 байт

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

Спробуйте в Інтернеті!

Perl 6, 52 ~ 72 47 ~ 67 байт

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

Потрібен модуль MONKEY-SEE-NO-EVALчерез таку помилку:

=== СОРІЯ! === Помилка під час компіляції -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++};

Спробуйте в Інтернеті!

-4 байти, використовуючи PHP> = 7,1 [,$n,$x]замість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 #~ [))

пояснення

Розважальні часи з дієсловом power у своїй герундійній формі :

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

Детально:

• ] {. ...Візьміть перші <right arg>елементи з усього цього матеріалу праворуч, що робить роботу ...
• <left> ^: <right>застосовувати дієслово <left>кілька <right>разів ... там, де <right>вказано середнє герундій у (-@[] (1 #~ [), тобто ], тобто правий арг перейшов у саму функцію. То що таке <left>? ...
• (] , [: +/ [ {. ])Лівий аргумент до всієї цієї фрази спочатку перетворюється першим герундом, тобто -@[. Це означає, що лівий аргумент цієї фрази є негативним лівим аргументом на загальну функцію. Це потрібно, щоб фраза [ {. ]взяла останні елементи зі списку повернення, який ми створюємо. Ті , які потім сумуються: +/. І , нарешті , додається до цього ж списку повернення: ] ,.
• То як ініціалізується список повернення? Ось що і виконує третя герунда попередньої обробки: (1 #~ [)- повторити 1 "лівий аргумент" кількість разів.

Спробуйте в Інтернеті!

Математика, 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`

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