Vous connaissez probablement tous la séquence des fibonacci:

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

Votre tâche est aussi simple que possible:

• Compte tenu entier NComputefibonacci(n)

mais voici la torsion:

• Faire aussi négatif N

Attendez. Quelle?

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

alors

fibonacci(-1)=1

et

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

etc...

• Il s'agit d'un code-golf, donc le programme le plus court en octets gagne.
• Vous pouvez soumettre une fonction ou un programme complet
• N est dans [-100,100]

Cas de test en 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

Allusion:

n <0 et n & 1 == 0:

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

Mathematica, 9 octets

Fibonacci

Oui, cette fonction intégrée prend en charge les nombres négatifs.

Octave, 20 octets

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

Essayez-le en ligne!

Explication

Cela utilise le fait que la séquence de fibonacci f(n)peut être écrite comme (cela devrait être une notation vectorielle matricielle):

Récursivement:

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

Explicitement:

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

Cela signifie que l'entrée supérieure droite de cette matrice à la puissance de nest la valeur f(n)que nous recherchons. Évidemment, nous pouvons également inverser cette matrice car elle a un rang complet, et la relation décrit toujours la même relation de récurrence. Cela signifie que cela fonctionne également pour les entrées négatives.

Maxima, 3 octets

 fib

prend en charge les nombres positifs et négatifs.

Essayez-le (collez) sur CESGA - Maxima en ligne

Python, 43 octets

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

Une formule directe avec le nombre d'or g. Avec fla fonction ci-dessus:

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

Alt de même longueur, aliasant uniquement la racine carrée de 5:

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

Je n'ai pas vu un moyen de créer une fonction récursive qui pourrait rivaliser avec ceux-ci. Une tentative modérément golfée pour 57 octets:

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

A titre de comparaison, une méthode itérative (60 octets en Python 2):

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

Ou, pour 58 octets:

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

JavaScript (ES6), 42 octets

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

Tester

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 octets

Je suis content du [3,2], qui pourrait certainement être joué au golf, si quelqu'un connaît un moyen, faites-le moi savoir =) (Cela fonctionnerait également avec [1,3].) Merci @LuisMendo pour -2 octets =)

IHhBiY^2)

Ceci utilise la même approche que l' annswer d'Octave . Mais pour générer la matrice

[1,1]
[1,0]

nous convertissons simplement le nombre 3et 2de décimal en binaire (ie 11et 10).

Essayez-le en ligne!

JavaScript (ES7) 37 octets

Utilise la formule de Binet .

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

Cette sortie du n^ième nombre de Fibonacci + - 0.0000000000000005.

Jolf, 2 octets

mL

Essayez-le ici!

Le fibonacci intégré, implémenté en utilisant la phiformule.

Haskell, 51 octets

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

PowerShell , 112 octets

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

Appel de démonstration:

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

Sortie de démo:

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

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

Mon regard sur toutes ces parenthèses .

Essayez-le en ligne!

Pas vraiment très petit. Il existe actuellement un bogue d'analyse qui en nécessite un à utiliser (get N)ou (+ N)au lieu de simplement N. J'ai choisi le plus petit. Cependant, je ne pense pas qu'il y ait quoi que ce soit qui puisse être fait pour jouer au golf.