Dies ist nicht sehr bekannt, aber was wir die Fibonacci-Sequenz, AKA, nennen

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

heißt eigentlich die Duonacci- Sequenz. Dies liegt daran, dass Sie die vorherigen 2 Zahlen summieren, um die nächste Zahl zu erhalten. Es gibt auch die Tribonacci- Sequenz,

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

weil die nächste Zahl die Summe der vorherigen 3 Zahlen ist. Und die Quadronacci- Sequenz

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

Und jedermanns Liebling, die Pentanacci- Sequenz:

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

Und die Hexanacci- Sequenz, die Septanacci- Sequenz, die Octonacci- Sequenz und so weiter bis zur N-Bonacci-Sequenz.

Die N-Bonacci-Sequenz beginnt immer mit N Einsen in einer Reihe.

Die Herausforderung

Sie müssen eine Funktion oder ein Programm schreiben, die bzw. das zwei Zahlen N und X annimmt und die ersten X N-Bonacci-Zahlen ausgibt. N ist eine ganze Zahl größer als 0, und Sie können davon ausgehen, dass keine N-Bonacci-Zahlen den in Ihrer Sprache voreingestellten Zahlentyp überschreiten. Die Ausgabe kann in jedem für Menschen lesbaren Format erfolgen, und Sie können Eingaben auf jede vernünftige Weise vornehmen. (Befehlszeilenargumente, Funktionsargumente, STDIN usw.)

Wie üblich ist dies Code-Golf, daher gelten Standardlücken und die kürzeste Antwort in Bytes gewinnt!

Beispiel 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 Bytes

,,[;+]

Sie können davon ausgehen, dass keine N-Bonacci-Zahlen den Standard-Zahlentyp in Ihrer Sprache überschreiten.

Der Standard-Nummerntyp in Boolfuck ist ein bisschen. Angenommen, dies erstreckt sich auch auf die Eingangsnummern N und X, und wenn N> 0 ist, gibt es nur zwei mögliche Eingänge - 10 (der nichts ausgibt) und 11 (der 1 ausgibt).

,Liest ein wenig in den aktuellen Speicherort. N wird ignoriert, da es 1 sein muss. Wenn X 0 ist, wird der Schleifenkörper (umgeben von []) übersprungen. Wenn X 1 ist, wird es ausgegeben und dann auf 0 gekippt, damit sich die Schleife nicht wiederholt.

Python 2, 79 Bytes

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

Probieren Sie es online aus

Pyth, 13

<Qu+Gs>QGEm1Q

Test Suite

Trennt die Eingabezeile mit der nersten.

Erläuterung:

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

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

Anwendungsbeispiel: 3 # 8-> [1,1,1,3,5,9,17,31].

Wie es funktioniert

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 Bytes

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

Verfolgt ein Längenfenster nder Sequenz in der Liste l, das aktualisiert wird, indem die Summe angehängt und das erste Element entfernt wird. Gibt das erste Element für jede Iteration aus x.

Ein anderer Ansatz zum Speichern aller Elemente und Summieren der letzten nWerte ergab die gleiche Länge (55).

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

Javascript ES6 / ES2015, 107 97 85 80 Bytes

Vielen Dank an @ user81655, @Neil und @ETHproductions für das Speichern einiger Bytes

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

versuche es online

Testfälle:

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 Bytes

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

Leider mapkönnen Sie im Rückruf nicht auf das Ergebnisarray zugreifen.

Gelee, 12 Bytes

ḣ³S;
b1Ç⁴¡Uḣ

Probieren Sie es online!

Wie es funktioniert

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 Bytes

Hallo, mir gefällt diese Frage. Ich weiß, dass C ++ eine sehr schwierige Sprache ist, um diesen Wettbewerb zu gewinnen. Aber ich werfe auf jeden Fall einen Cent.

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

Ich lasse dies als lesbare Erklärung des obigen Codes.

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

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

Probieren Sie es online!

<$ Möglicherweise wurde Prelude eingeführt, nachdem diese Herausforderung veröffentlicht wurde.

Haskell , 53 Bytes

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

Probieren Sie es online!

Definiert die Binärfunktion ?, die wie folgt verwendet wird 3?8 == [1,1,1,3,5,9,17,31].

Die Hilfsfunktion %findet rekursiv das ith-Element der nBonacci-Sequenz durch Summieren der vorherigen nWerte. Die Funktion ?tabelliert dann die ersten xWerte von %.

APL, 21

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

Dies ist eine Funktion, die n als linkes Argument und x als rechtes Argument verwendet.

Erläuterung:

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

Testfälle:

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

Dank FryAmTheEggman 20 Bytes gespart.

Keine großartige Lösung, aber es wird vorerst funktionieren.

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

Auch hier sind Testfälle:

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 Bytes

Funktion zum Ermitteln der i-ten n- Bonacci-Zahl ( 82 Bytes ):

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

Funktion zum Drucken der ersten k n -Bonacci-Zahl ( 58 Bytes ):

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

Brain-Flak , 144 124 122 Bytes

-20 Bytes dank Nitroden

Dies ist meine erste Brain-Flak-Antwort, und ich bin sicher, dass sie verbessert werden kann. Jede Hilfe wird geschätzt.

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

Probieren Sie es online!

Pari / GP , 46 Bytes

Die generierende Funktion der Sequenz ist:

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

Probieren Sie es online!

Julia, 78 Bytes

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

Dies ist eine Funktion, die zwei ganze Zahlen akzeptiert und ein ganzzahliges Array zurückgibt. Der Ansatz ist einfach: Generieren Sie ein Array mit einer Länge n, und vergrößern Sie das Array, indem Sie die Summe der vorherigen nElemente hinzufügen, bis das Array eine Länge hat 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 Bytes

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

Dies verwendet die aktuelle Version (10.2.1) der Sprache / des Compilers.

Probieren Sie es online!

Ein paar zusätzliche Bytes :-( aufgrund eines Fehlers in der GFunktion ( Einfügeeingabe ; jetzt für die nächste Version korrigiert)

Erläuterung

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 Bytes

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

Verwendungszweck:

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

Der rekursive Ansatz ist um einige Bytes kürzer.

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

Schale , 9 Bytes

↑§¡ȯΣ↑_B1

Probieren Sie es online!

Beginnt , sich von der BASE- 1Darstellung N (einfach eine Liste von N sind) und ¡teratively Summen ( Σ) , um die letzte ( ↑_) N Elemente und fügt das Ergebnis an die Liste. Zum Schluss nimmt ( ↑) die ersten X- Nummern in dieser Liste und gibt sie zurück.

Ruby , 41 Bytes

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

Probieren Sie es online!

R , 68 Bytes

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

Probieren Sie es online!

K (NGN / k) , 26 24 Bytes

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

Probieren Sie es online!

Perl 6, 52 ~ 72 47 ~ 67 Bytes

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

Benötigt das Modul MONKEY-SEE-NO-EVALwegen des folgenden Fehlers:

=== ENTSCHULDIGUNG! === Fehler beim Kompilieren -e
EVAL ist eine sehr gefährliche Funktion !!! (Verwenden Sie MONKEY-SEE-NO-EVAL zum Überschreiben,
aber nur, wenn Sie SEHR sicher sind, dass Ihre Daten keine Injektionsangriffe enthalten.)
at -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 Bytes

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

Probieren Sie es online!

-4 Bytes mit PHP> = 7.1 [,$n,$x]anstelle vonlist(,$n,$x)

Jq 1,5 , 67 Bytes

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

Nimmt an, dass die Eingabe von N und X erfolgt, z

def N: 5;
def X: 11;

Erweitert

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

Probieren Sie es online!

J, 31 Bytes

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

Ungolfed:

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

Erläuterung

Lustige Zeiten mit dem Machtverb in seiner gerundeten Form :

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

Aufschlüsselung im Detail:

• ] {. ...Nehmen Sie die ersten <right arg>Elemente aus all diesen Dingen nach rechts, die die Arbeit erledigen ...
• <left> ^: <right>Wenden Sie das Verb <left>immer wieder <right>mal ... wo <right>durch die Mitte gerund angegeben in (-@[] (1 #~ [), das heißt ], das heißt die rechte arg in die Funktion selbst übergeben. Also was ist <left>? ...
• (] , [: +/ [ {. ])Das linke Argument zu dieser ganzen Phrase wird zuerst durch das erste Gerund transformiert, dh -@[. Das heißt, das linke Argument zu dieser Phrase ist das Negativ des linken Arguments zur Gesamtfunktion. Dies ist erforderlich, damit die Phrase [ {. ]die letzten Elemente aus der Rückgabeliste übernimmt, die wir erstellen. Diese werden dann summiert: +/. Und schließlich zu derselben Rückkehr Liste angefügt: ] ,.
• Wie wird die Rückgabeliste initialisiert? Das ist es, was das dritte Vorverarbeitungs-Gerundium bewirkt: (1 #~ [)- 1 "linkes Argument" mehrmals wiederholen.

Probieren Sie es online!

Mathematica, 59 Bytes

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

Sie möchten wahrscheinlich Clear@fzwischen Funktionsaufrufen. Argumente sind n,x, genau wie die Testfälle.

Ordentlich , 36 Bytes

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

Probieren Sie es online!

Erläuterung

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

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

Probieren Sie es online!

Erläuterung:

         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