Hintergrund

Fast jeder kennt die Fibonacci-Zahlen F(n) :

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

Diese werden durch die Rekursionsfunktion F(n) = F(n-1) + F(n-2)mit F(0)=0und gebildet F(1)=1. A000045

Eine eng verwandte Folge sind die Lucas-Zahlen L(m) :

2, 1, 3, 4, 7, 11, 18, 29 ...

Diese werden durch die Rekursionsfunktion L(m) = L(m-1) + L(m-2)mit L(0)=2und gebildet L(1)=1. A000032

Wir können zwischen den beiden Sequenzen basierend auf geraden / ungeraden Indizes mit der Konstruktion wechseln,
A(x) = F(x)wenn x mod 2 = 0und A(x) = L(x)sonst. Zum Beispiel A(4)ist gleich F(4)da 4 mod 2 = 0. Wir werden diese Sequenz rufen die Lucas-Nacci Zahlen , A(x):

0, 1, 1, 4, 3, 11, 8, 29, 21, 76 ...

Dies kann durch die Rekursion Funktion gebildet werden , A(x) = 3*A(x-2) - A(x-4)mit A(0)=0, A(1)=1, A(2)=1, und A(3)=4. A005013

Herausforderung

Geben Sie bei gegebener Eingabe ndie Zahlenfolge n+1bis einschließlich A(n)wie oben beschrieben aus. Es werden nur wenige Bytes (oder Byte-Äquivalente, z. B. für LabVIEW , die individuell auf Meta festgelegt wurden) gewonnen.

Eingang

Eine einzelne nicht negative Ganzzahl n.

Ausgabe

Eine Liste von Zahlen, die der Folge von Lucas-Nacci-Zahlen von A(0)bis entsprechen A(n). Die Liste muss in der oben beschriebenen Reihenfolge vorliegen.

Regeln

• Es gelten die Standardregeln für Code-Golf und Lückenbeschränkungen .
• Es gelten die Standard-Ein- / Ausgaberegeln .
• Die eingegebene Nummer kann in einem beliebigen geeigneten Format vorliegen: unär oder dezimal, gelesen von STDIN, Funktion oder Befehlszeilenargument usw. - Sie haben die Wahl.
• Die Ausgabe kann auf STDOUT gedruckt oder als Ergebnis des Funktionsaufrufs zurückgegeben werden. Wenn gedruckt, müssen geeignete Trennzeichen zur Unterscheidung der Zahlen enthalten sein (durch Leerzeichen, durch Kommas getrennt usw.).
• Bei der Ausgabe auf STDOUT sind außerdem umgebende Leerzeichen, abschließende Zeilenumbrüche usw. optional.
• Wenn die Eingabe eine Nicht-Ganzzahl oder eine negative Ganzzahl ist, kann das Programm alles oder nichts tun, da das Verhalten undefiniert ist.

Beispiele

Input -> Output
0 -> 0
5 -> 0, 1, 1, 4, 3, 11
18 -> 0, 1, 1, 4, 3, 11, 8, 29, 21, 76, 55, 199, 144, 521, 377, 1364, 987, 3571, 2584

Gelee, 12 Bytes

;2U+¥Ð¡-,1ZḢ

Probieren Sie es online!

Hintergrund

Wir können F und L auf -1 erweitern, indem wir F (-1) = 1 und L (-1) = -1 definieren. Dies stimmt mit der rekursiven Funktion überein.

Unser Programm beginnt mit

-1  1
 0  2

In jedem Schritt, um das nächste Paar zu bilden, kehren wir das letzte Paar um und addieren es zum vorletzten Paar. Beispielsweise:

[0, 2] U+¥ [-1, 1] -> [2, 0] + [-1, 1] -> [1, 1]

Wenn wir diesen Prozess für einige weitere Schritte fortsetzen, erhalten wir

-1  1
 0  2
 1  1
 1  3
 4  2
 3  7
11  5

Die Lucas-Nacci-Sequenz ist einfach die linke Spalte.

Wie es funktioniert

;2U+¥Ð¡-,1ZḢ  Niladic link. No implicit input.
              Since the link doesn't start with a nilad, the argument 0 is used.

;2            Concatenate the argument with 2, yielding [0, 2].
       -,1    Yield [-1, 1]. This is [L(-1), F(-1)].
    ¥         Create a dyadic chain of the two atoms to the left:
  U             Reverse the left argument.
   +            Add the reversed left argument and the right one, element-wise.
     С       For reasons‡, read a number n from STDIN.
              Repeatedly call the dyadic link U+¥, updating the right argument with
              the value of the left one, and the left one with the return value.
              Collect all intermediate results.
          Z   Zip the list of results, grouping the first and seconds coordinates.
           Ḣ  Head; select the list of first coordinates.

^‡ С blick auf die beiden links: 2und U+¥. Da der am weitesten links stehende ein Nil ist, kann er nicht der Körper der Schleife sein. Daher U+¥wird als Hauptteil eine Zahl aus der Eingabe gelesen. Da es keine Befehlszeilenargumente gibt, wird diese Nummer aus STDIN gelesen.

CJam, 21 20 Bytes

Vielen Dank an Sp3000 für das Speichern von 1 Byte.

TXX4ri{1$3*4$-}*?;]p

Teste es hier.

Erläuterung

Verwendet einfach die in der Herausforderungsspezifikation angegebene Wiederholung.

TXX4 e# Push 0 1 1 4 as base cases.
ri   e# Read input and convert to integer N.
{    e# Run this N times...
  1$ e#   Copy a(n-2).
  3* e#   Multiply by 3.
  4$ e#   Copy a(n-4).
  -  e#   Subtract.
}*
?;   e# Discard the last three values, using a ternary operation and popping the result.
]p   e# Wrap the rest in an array and pretty-print it.

Perl 6, 42 Bytes

{(0,1,1,4,{$^b;$^d;3*$^c-$^a}...*)[0..$_]}

Verwendung

> my &f = {(0,1,1,4,{$^b;$^d;3*$^c-$^a}...*)[0..$_]}
-> ;; $_? is raw { #`(Block|184122176) ... }
> f(0)
(0)
> f(5)
(0 1 1 4 3 11)
> f(18)
(0 1 1 4 3 11 8 29 21 76 55 199 144 521 377 1364 987 3571 2584)

Haskell, 59 , 57 , 56 , 52 , 51 Bytes

l a=2*mod a 2:scanl(+)1(l a)
f n=[l i!!i|i<-[0..n]]

Die Seriendefinition wurde anhand dieser Antwort angepasst .

Weniger golfen:

fibLike start = start : scanl (+) 1 (fibLike start)
whichStart i = (2*mod i 2)
lucasNacci i = fibLike (whichStart i) !! i
firstN n = [ lucasNacci i | i <- [0..n]]

fibLike startgibt eine unendliche Liste definiert: f(0)=start, f(1)=1, f(n)=f(n-1) + f(n-2). whichStart iGibt 2 für ungerade Eingaben (Lucas-Reihe) oder 0 für gerade Eingaben (Fibonacci-Reihe) zurück. lucasNacci igibt die i-te Lucas-nacci-Nummer an. firstN nKarten über die Liste.

Ein Byte von Boomerang gespeichert.

ES6, 65 Bytes

n=>[...Array(n)].map(_=>a.shift(a.push(a[2]*3-a[0])),a=[0,1,1,4])

Verwendet die in der Frage angegebene Wiederholungsrelation.

Retina , 70 62 59 Bytes

1
¶$`1
m`^(11)*1$
$&ff
m`$
 f
+`1(f*) (f*)
$2 $2$1
 f*

f
1

Probieren Sie es online aus

• Die Eingabe erfolgt in unärer Basis, n 1s.
• 1? $`¶- Erstellen Sie für jede Zahl eine Zeile von 0 bis n : , 1, 11, 111, 1111, ...
• m`^(11)*1$ $&ff- ffAn ungerade Zeilen anhängen . Dadurch wird die Funktion mit L (0) = 2 gesetzt.
• m`$  f-  fAn alle Zeilen anhängen (Leerzeichen beachten). Dies setzt die Funktion für Fibonacci-Zahlen auf 0 und 1 und für Lucas-Zahlen auf 2 und 1.
• +`1(f*) (f*) $2 $2$1 - Schleife: Berechne F (n + 1) = F (n) + F (n-1), solange noch 1s vorhanden sind.
•  f*   - Entfernen Sie F (n + 1) vom Ende jeder Zeile.
• Ersetzen Sie fs zurück auf 1s. Wenn dies nicht benötigt wird und wir bei fs bleiben können , beträgt die Länge nur 55 Bytes.

Oracle SQL 11.2, 218 216 201 Bytes

WITH v(a,b,c,d,i)AS(SELECT 0,1,1,4,3 FROM DUAL UNION ALL SELECT b,c,d,3*c-a,i+1 FROM v WHERE i<:1)SELECT SIGN(LEVEL-1) FROM DUAL WHERE LEVEL-1<=:1 CONNECT BY LEVEL<4UNION ALL SELECT d FROM v WHERE:1>2;

Nicht golfen

WITH v(a,b,c,d,i) AS 
(
  SELECT 0,1,1,4,3 FROM DUAL 
  UNION ALL 
  SELECT b,c,d,3*c-a,i+1 FROM v WHERE i<:1
)
SELECT SIGN(LEVEL-1) FROM DUAL WHERE LEVEL-1<=:1 CONNECT BY LEVEL<4
UNION ALL SELECT d FROM v WHERE:1>2;

Ich habe es geschafft, ein paar Bytes zu gewinnen, indem ich die SIGN-Funktion verwendet habe, um die ersten drei Elemente der Sequenz zu generieren.

Japt, 25 22 21 Bytes

Uò £MgXf2)+X%2*Mg°X)r

Testen Sie es online!

Hintergrund

Es ist etwas schwierig, eine Fibonacci-Sequenz in Japt zu erstellen, aber wir haben eine integrierte Funktion Mg, um dies für uns zu tun. Dies gibt uns jedoch nur die Fibonacci-Sequenz, nicht die Lucas-Sequenz. Wir können die Lucas-Sequenz ziemlich einfach mit diesem Trick erreichen:

N    F(N-1)  F(N+1)  F(N-1)+F(N+1)
0    1       1       2
1    0       1       1
2    1       2       3
3    1       3       4
4    2       5       7
5    3       8       11
6    5       13      18
7    8       21      29

Wie Sie sehen können, F(N-1) + F(N+1)ist L(N)für alle gleich N. Da wir jedoch nur Lucas-Zahlen für die ungeraden Indizes benötigen, können wir die beiden Formeln zu einer kombinieren:

N    N-N%2  N+N%2    F(N-N%2)  F(N+N%2)*(N%2)  F(N-N%2)+F(N+N%2)*(N%2)
0    0      0        0         0               0
1    0      2        0         1               1
2    2      2        1         0               1
3    2      4        1         3               4
4    4      4        3         0               3
5    4      6        3         8               11
6    6      6        8         0               8
7    6      8        8         21              29

Wie es funktioniert

Uò £  MgX-1 +X%2*Mg° X)r
Uò mX{MgX-1 +X%2*Mg++X)r

             // Implicit: U = input integer
Uò mX{       // Create the inclusive range [0..U], and map each item X to:
MgXf2)+      //  Floor X to a multiple of 2, calculate this Fibonacci number, and add:
+X%2*Mg++X)  //  Calculate the (X+1)th Fibonacci number and multiply by X%2.
)r           //  Round the result. (The built-in Fibonacci function returns
             //  a decimal number on higher inputs.)

Mathematica, 52 51 Bytes

If[#>2,3#0[#-2]-#0[#-4],#-If[#>1,1,0]]&/@0~Range~#&

Ganz ähnlich wie oben bei Martin habe ich einige Zeit damit verbracht, einen kürzeren Weg zu finden, um die "Basisfälle" für die Funktion zu definieren. Polynominterpolation war eine Pleite, daher habe ich die Erweiterung in Negative verwendet, um eine ziemlich kurze Definition zu erhalten.

Mathematica, 56 Bytes

f@0=0
f@1=f@2=1
f@3=4
f@n_:=3f[n-2]-f[n-4];
f/@0~Range~#&

Sehr einfache Implementierung. Definiert eine Hilfsfunktion fund wertet sie dann zu einer unbenannten Funktion aus, die fauf einen Bereich angewendet wird, um alle Ergebnisse zu erhalten. Das fühlt sich unnötig umständlich an.

Eine einzelne unbenannte Funktion scheint jedoch ein Byte länger zu sein:

Switch[#,0,0,1,1,2,1,3,4,_,3#0[#-2]-#0[#-4]]&/@0~Range~#&

MATL , 17 18 Bytes

0ll4i:"y3*5$y-](x

Fast direkte Übersetzung von Martins CJam-Antwort .

Probieren Sie es online!

0ll4       % push first four numbers: 0,1,1,4
i:         % input n and generate array [1,2,...,n]
"          % for loop. Repeat n times
  y        % copy second-top element from stack
  3*       % multiply by 3
  5$y      % copy fifth-top element from stack
  -        % subtract. This is the next number in the sequence
]          % end loop
(x         % indexing operation and delete. This gets rid of top three numbers

Brachylog , 51 Bytes

:0re{:4<:[0:1:1:4]rm!.|-4=:1&I,?-2=:1&*3-I=.}w,@Sw\

Dies nimmt eine Zahl als Eingabe und druckt diese in STDOUT aus, wobei die einzelnen Zahlen durch Leerzeichen voneinander getrennt sind.

Erläuterung

§ Main predicate

:0re{...}               § Enumerate integers between 0 and the Input, pass the integer 
                        § as input to sub-predicate 1      
         w,@Sw          § Write sub-predicate 1's output, then write a space
              \         § Backtrack (i.e. take the next integer in the enumeration)


§ Sub-predicate 1

:4<                     § If the input is less than 4
   :[0:1:1:4]rm!.       § Then return the integer in the list [0,1,1,4] at index Input

|                       § Else

-4=:1&I,                § I = sub_predicate_1(Input - 4)
        ?-2=:1&*3-I=.   § Output = sub_predicate_1(Input - 2) * 3 - I

Die Kürzung !in der ersten Regel von Unterprädikat 1 ist notwendig, damit wir beim Zurückverfolgen ( \) nicht in einer Endlosschleife enden, in der der Interpreter die zweite Regel für eine Eingabe unter 4 versucht.

Mathematica, 41 Bytes

LinearRecurrence[{0,3,0,-1},{0,1,1,4},#]&

Groovy, 50 Bytes

x={a,b=0,c=1,d=1,e=4->a<0?:[b,x(a-1,c,d,e,3*d-b)]}

Dies definiert die Funktion x, die n als erstes Argument aufnimmt und den Basisfall der ersten vier Zahlen in der Fibocas-Sequenz als Standardargumente für den Rest der Funktion hat.

a hier ist n. b, c, d und e sind die nächsten vier Elemente in der Sequenz.

Es dekrementiert n und rekursiv, bis n kleiner als Null ist. Wenn es rekursiv ist, addiert es das erste Element in seiner aktuellen Sequenz zum endgültigen Rückgabewert. Die neuen Werte für die nächsten vier Elemente in der Sequenz werden dem rekursiven Aufruf übergeben - die letzten drei Elemente werden auf die ersten drei verschoben, und ein neues viertes Element wird aus zwei der vorherigen Elemente mit 3 * db generiert.

Neue Werte werden durch Listenverschachtelungen begrenzt, da groovy mehrere Werte zurückgeben kann, indem sie in eine Liste eingefügt werden. Daher gibt jeder Aufruf das aktuelle erste Element und das Ergebnis der Rekursion zurück, bei dem es sich um eine eigene Liste handelt.

R , 55 Bytes

A=c(0,1,1,4);for(x in 4:scan()+1)A[x]=3*A[x-2]-A[x-4];A

Probieren Sie es online!

• -24 Bytes dank JayCe

Pylone , 19

Dies ist eine ziemlich direkte Übersetzung von Martins Ansatz.

0114{@-4@-33*-,i}=4

Wie es funktioniert:

0114    # Push 0, 1, 1, 4 to the stack.
{       # Start a for loop.
 @-4    # Get the stack element at index -4
 @-3    # Get the stack element at index -3
 3      # Push 3 to the stack.
 *      # Multiply the top two elements of the stack.
 -      # Subtract the top two elements of the stack.
  ,     # Switch to loop iterations.
 i      # Get command line args.
}       # End for loop.
=4      # Discard the top 4 elements of the stack.

DUP , 32 Bytes

[a:0 1$4[a;1-$a:][1ø3*4ø-]#%%]

Try it here!

Ein anonymes Lambda, das eine Folge von Zahlen auf dem Stapel hinterlässt. Verwendung:

8[a:0 1$4[a;1-$a:][1ø3*4ø-]#%%]!

Erläuterung

[                              {start lambda}
 a:                            {save input number to a}
   0 1$4                       {base cases to get us started}
        [       ][       ]#    {while loop}
         a;1-$a:               {a--, check if a>0}
                  1ø3*4ø-      {3*stack[n-2]-stack[n-4]}

                           %%  {discard top 2 stack items}
                             ] {end lambda}

Python 2, 71 Bytes

def a(n,x=0,y=1,z=2,w=1,p=0):
 if~n:print[x,z][p];a(n-1,y,x+y,w,z+w,~p)

Das scheint definitiv zu lang. Es hat mich jedoch gefreut, dass ich den bitweisen notOperator ... zweimal verwenden durfte. Einmal als eine Art Parität hin und her, und einmal, um die Rekursion zu beenden, wenn nerreicht -1.

Die Variable pist immer entweder 0oder -1und wechselt zwischen Einträgen 0oder -1der Liste. (Wenn Sie den Eintrag -1einer Python-Liste wählen, müssen Sie das letzte Element auswählen.)

C ++ Template Meta Programming, 130 Bytes

template<int X>struct L{enum{v=3*L<X-2>::v-L<X-4>::v};};
#define D(X,A) template<>struct L<X>{enum{v=A};};
D(0,0)D(1,1)D(2,1)D(3,4)

Rekursive Definitionen schreien irgendwie nach C ++ TMP, Verwendung:

L<x>::v

mit xdem, was A(x)du magst.