Sie kennen wahrscheinlich alle die Fibonacci-Sequenz:

fibonacci(n)=fibonacci(n-1)+fibonacci(n-2)
fibonacci(0)=0
fibonacci(1)=1

Ihre Aufgabe ist so einfach wie möglich:

• Gegebenen ganzzahligen NRechenfibonacci(n)

aber hier ist die Wendung:

• Auch negativ machen N

Warten. Was?

fibonacci(1)=fibonacci(0)+fibonacci(-1)

so

fibonacci(-1)=1

und

fibonacci(-2)=fibonacci(0)-fibonacci(1)=-1

und so weiter...

• Dies ist ein Code-Golf, so dass das kürzeste Programm in Bytes gewinnt.
• Sie können eine Funktion oder ein vollständiges Programm einreichen
• N ist in [-100,100]

Testfälle in CSV:

-9;-8;-7;-6;-5;-4;-3;-2;-1;0;1;2;3;4;5;6;7;8
34;-21;13;-8;5;-3;2;-1;1;0;1;1;2;3;5;8;13;21

Hinweis:

n <0 und n & 1 == 0:

fibonacci(n)=fibonacci(abs(n))*-1

Mathematica, 9 Bytes

Fibonacci

Ja, diese integrierte Funktion unterstützt negative Zahlen.

Oktave, 20 Bytes

 @(n)([1,1;1,0]^n)(2)

Probieren Sie es online!

Erläuterung

Dies nutzt die Tatsache, dass die Fibonacci-Sequenz f(n)wie folgt geschrieben werden kann (dies sollte eine Matrixvektor-Notation sein):

Rekursiv:

[f(n+1)]  = [1  1] * [f(n)  ]
[f(n)  ]    [1  0]   [f(n-1)]

Ausdrücklich:

[f(n+1)]  = [1  1] ^n * [1]
[f(n)  ]    [1  0]      [0]

Dies bedeutet, dass der obere rechte Eintrag dieser Matrix zur Potenz von ndem Wert ist, den f(n)wir suchen. Natürlich können wir diese Matrix auch invertieren, da sie den vollen Rang hat und die Beziehung immer noch dieselbe Wiederholungsbeziehung beschreibt. Das heißt, es funktioniert auch für negative Eingänge.

Maxima, 3 Bytes

 fib

unterstützt positive und negative Zahlen.

Probieren Sie es (Paste) auf CESGA - Maxima online

Python, 43 Bytes

g=5**.5/2+.5
lambda n:(g**n-(1-g)**n)/5**.5

Eine direkte Formel mit dem goldenen Schnitt g. Mit fder obigen Funktion:

for n in range(-10,11):print f(n) 

-55.0
34.0
-21.0
13.0
-8.0
5.0
-3.0
2.0
-1.0
1.0
0.0
1.0
1.0
2.0
3.0
5.0
8.0
13.0
21.0
34.0
55.0

Gleiche Länge alt, nur Aliasing der Quadratwurzel von 5:

a=5**.5
lambda n:((a+1)**n-(1-a)**n)/a/2**n

Ich habe keine Möglichkeit gesehen, eine rekursive Funktion zu erstellen, die mit diesen konkurrieren könnte. Ein leicht golfener Versuch für 57 Bytes:

f=lambda n:n<0and(-1)**n*f(-n)or n>1and f(n-1)+f(n-2)or n

Zum Vergleich eine iterative Methode (60 Bytes in Python 2):

n=input()
a,b=0,1;exec"a,b=b,a+b;"*n+"a,b=b-a,a;"*-n
print a

Oder für 58 Bytes:

n=input()
a,b=0,1;exec"a,b=b,a+cmp(n,0)*b;"*abs(n)
print a

JavaScript (ES6), 42 Byte

f=n=>n<2?n<0?f(n+2)-f(n+1):n:f(n-2)+f(n-1)

Prüfung

f=n=>n<2?n<0?f(n+2)-f(n+1):n:f(n-2)+f(n-1)

for(i = -9; i < 9; i++) {
  console.log(i, f(i))
}

MATL , 11 9 Bytes

Ich freue mich über die [3,2], die sicherlich Golf spielen könnten, wenn jemand einen Weg kennt, lass es mich bitte wissen =) (Es würde auch funktionieren [1,3].) Danke @LuisMendo für -2 Bytes =)

IHhBiY^2)

Dies ist derselbe Ansatz wie der Octave-Annswer . Aber um die Matrix zu generieren

[1,1]
[1,0]

Wir konvertieren nur die Zahl 3und 2von dezimal nach binär (dh 11und 10).

Probieren Sie es online!

JavaScript (ES7) 37 Byte

Verwendet die Binet-Formel .

n=>((1+(a=5**.5))**n-(1-a)**n)/a/2**n

Dies gibt die n^th Fibonacci-Zahl + - aus 0.0000000000000005.

Jolf, 2 Bytes

mL

Probieren Sie es hier aus!

Das eingebaute Fibonacci, implementiert mit der phiFormel.

Haskell, 51 Bytes

s=0:scanl(+)1s;f z|even z,z<0= -f(-z);f z=s!!abs z

PowerShell , 112 Bytes

function f($n){$o=('-','+')[$n-lt0];&(({$a,$b=(2,1|%{f("$n$o$_"|iex)});"$a- $o$b"|iex},{$n*$n})[$n-in(-1..1)])}

Demo-Aufruf:

-9..9 | %{"{0,2}`t=> {1,3}" -f $_,(f($_))} 

Ausgabe der Demo:

-9  =>  34
-8  => -21
-7  =>  13
-6  =>  -8
-5  =>   5
-4  =>  -3
-3  =>   2
-2  =>  -1
-1  =>   1
 0  =>   0
 1  =>   1
 2  =>   1
 3  =>   2
 4  =>   3
 5  =>   5
 6  =>   8
 7  =>  13
 8  =>  21
 9  =>  34

Lithp , 88 Bytes

#N::((if(< N 2)((if(< N 0)((-(f(+ N 2))(f(+ N 1))))((+ N))))((+(f(- N 2))(f(- N 1))))))

Mein Blick auf all diese Klammern .

Probieren Sie es online!

Eigentlich nicht sehr klein. Derzeit ist ein Parsing-Fehler aufgetreten, für dessen Verwendung (get N)oder (+ N)anstelle von "Einfach" ein Fehler erforderlich ist N. Ich habe den kleineren gewählt. Ich glaube jedoch nicht, dass es irgendetwas gibt, was man tun könnte, um dies zu verbessern.