Probablemente todos conozcan la secuencia de Fibonacci:

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

Su tarea es tan simple como podría ser:

• Dada número entero Nde cómputofibonacci(n)

pero aquí está el giro:

• También hacer negativo N

Espere. ¿Qué?

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

asi que

fibonacci(-1)=1

y

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

y así...

• Este es un código de golf por lo que el programa más corto en bytes gana.
• Puede enviar una función o un programa completo
• N está en [-100,100]

Testcase (s) 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

Insinuación:

n <0 y n & 1 == 0:

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

Mathematica, 9 bytes

Fibonacci

Sí, esta función integrada admite números negativos.

Octava, 20 bytes

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

Pruébalo en línea!

Explicación

Esto hace uso del hecho de que la secuencia de Fibonacci f(n)se puede escribir como (esto debería ser una notación de vector de matriz):

Recursivamente:

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

Explícitamente:

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

Esto significa que la entrada superior derecha de esta matriz a la potencia de nes el valor f(n)que estamos buscando. Obviamente, también podemos invertir esta matriz, ya que tiene rango completo, y la relación todavía describe la misma relación de recurrencia. Eso significa que también funciona para entradas negativas.

Máximo, 3 bytes

 fib

admite números positivos y negativos.

Pruébelo (pegue) en CESGA - Maxima en línea

Python, 43 bytes

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

Una fórmula directa con la proporción áurea g. Con fla función anterior:

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

Misma longitud alt, solo alias la raíz cuadrada de 5:

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

No vi una manera de hacer una función recursiva que pudiera competir con estos. Un intento moderado de 57 bytes:

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

A modo de comparación, un método iterativo (60 bytes en Python 2):

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

O, para 58 bytes:

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

JavaScript (ES6), 42 bytes

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

Prueba

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

Estoy contento con el [3,2], que seguramente se podría jugar al golf, si alguien conoce una forma, hágamelo saber =) (También funcionaría con [1,3]). Gracias @LuisMendo por -2 bytes =)

IHhBiY^2)

Esto está utilizando el mismo enfoque que la respuesta de Octave . Pero para generar la matriz

[1,1]
[1,0]

simplemente convertimos el número 3y 2de decimal a binario (es decir, 11y 10).

Pruébalo en línea!

JavaScript (ES7) 37 bytes

Utiliza la fórmula de Binet .

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

Esto genera el n^th número de Fibonacci + - 0.0000000000000005.

Jolf, 2 bytes

mL

Pruébalo aquí!

El fibonacci incorporado, implementado utilizando la phifórmula.

Haskell, 51 bytes

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

Potencia Shell , 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)])}

Llamada de demostración:

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

Salida de demostración:

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

Mi mirada a todos esos paréntesis .

Pruébalo en línea!

No muy pequeño en realidad. Actualmente hay un error de análisis que requiere uno para usar (get N)o en (+ N)lugar de simplemente N. Elegí el más pequeño. Sin embargo, no creo que se pueda hacer nada más para jugar golf.