Todos estamos familiarizados con la famosa secuencia de Fibonacci , que comienza con 0y 1, y cada elemento es la suma de los dos anteriores. Estos son los primeros términos (OEIS A000045 ):

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584

Dado un número entero positivo , devuelve el número más cercano de la secuencia de Fibonacci, según estas reglas:

• El número de Fibonacci más cercano se define como el número de Fibonacci con la menor diferencia absoluta con el entero dado. Por ejemplo, 34es el número de Fibonacci más cercano a 30, porque |34 - 30| = 4, que es más pequeño que el segundo más cercano 21, para el cual |21 - 30| = 9.

• Si el entero dado pertenece a la secuencia de Fibonacci, el número de Fibonacci más cercano es exactamente el mismo. Por ejemplo, el número de Fibonacci más cercano a 13es exactamente 13.

• En caso de empate, puede optar por emitir cualquiera de los números de Fibonacci que estén más cerca de la entrada o simplemente emitirlos a ambos. Por ejemplo, si la entrada es 17, todos los siguientes son válidos: 21, 13o 21, 13. En caso de que los devuelva a ambos, mencione el formato.

Se aplican las lagunas predeterminadas . Puede tomar entrada y proporcionar salida a través de cualquier método estándar . Su programa / función solo debe manejar valores de hasta 10 ⁸ .

Casos de prueba

Entrada -> Salida

1 -> 1
3 -> 3
4 -> 3 o 5 o 3, 5
6 -> 5
7 -> 8
11 -> 13
17 -> 13 o 21 o 13, 21
63 -> 55
101 -> 89
377 -> 377
467 -> 377
500 -> 610
1399 -> 1597

Tanteo

Este es el código de golf , por lo que gana el código más corto en bytes en cada idioma .

Python 2 , 43 bytes

f=lambda n,a=0,b=1:a*(2*n<a+b)or f(n,b,a+b)

Pruébalo en línea!

Itera a través de pares de números consecutivos de Fibonacci (a,b)hasta que alcanza uno donde la entrada nes menor que su punto medio (a+b)/2, luego regresa a.

Escrito como un programa (47 bytes):

n=input()
a=b=1
while 2*n>a+b:a,b=b,a+b
print a

Misma longitud :

f=lambda n,a=0,b=1:b/2/n*(b-a)or f(n,b,a+b)

Neim , 5 bytes

f𝐖𝕖S𝕔

Explicación:

f       Push infinite Fibonacci list
 𝐖                     93
  𝕖     Select the first ^ elements
        This is the maximum amount of elements we can get before the values overflow
        which means the largest value we support is 7,540,113,804,746,346,429
   S𝕔   Closest value to the input in the list

En la versión más nueva de Neim, esto se puede jugar a 3 bytes:

fS𝕔

Como las listas infinitas se han rediseñado para subir solo a su valor máximo.

Pruébalo en línea!

Python , 55 52 bytes

f=lambda x,a=1,b=1:[a,b][b-x<x-a]*(b>x)or f(x,b,a+b)

Pruébalo en línea!

R , 70 67 64 62 60 bytes

-2 bytes gracias a djhurio!

-2 bytes más gracias a djhurio (¡chico puede jugar al golf!)

F=1:0;while(F<1e8)F=c(F[1]+F[2],F);F[order((F-scan())^2)][1]

Como solo tenemos que manejar valores hasta 10^8, esto funciona.

Pruébalo en línea!

Lee n de stdin. el whilebucle genera los números de fibonacci en F(orden decreciente); en caso de empate, se devuelve el más grande. Esto activará una serie de advertencias porque while(F<1e8)solo evalúa la declaración para el primer elemento de Fcon una advertencia

Originalmente utilicé F[which.min(abs(F-n))]el enfoque ingenuo, pero @djhurio sugirió(F-n)^2 ya que el pedido será equivalente, y en orderlugar de which.min. ordersin embargo, devuelve una permutación de índices para poner su entrada en orden creciente, por lo que [1]al final necesitamos obtener solo el primer valor.

versión más rápida:

F=1:0;n=scan();while(n>F)F=c(sum(F),F[1]);F[order((F-n)^2)][‌​1]

solo almacena los dos últimos números de Fibonacci

JavaScript (ES6), 41 bytes

f=(n,x=0,y=1)=>y<n?f(n,y,x+y):y-n>n-x?x:y

<input type=number min=0 value=0 oninput=o.textContent=f(this.value)><pre id=o>0

Se redondea por preferencia.

Jalea , 9 7 bytes

-2 bytes gracias a @EriktheOutgolfer

‘RÆḞạÐṂ

Pruébalo en línea!

Consejos de golf bienvenidos :). Toma un int como entrada y devuelve una lista int.

            ' input -> 4
‘           ' increment -> 5
 R          ' range -> [1,2,3,4,5]
  ÆḞ        ' fibonacci (vectorizes) -> [1,1,2,3,5,8]
     ÐṂ     ' filter and keep the minimum by:
    ạ       ' absolute difference -> [3,3,2,1,1,4]
            ' after filter -> [3,5]

Mathematica, 30 bytes

Array[Fibonacci,2#]~Nearest~#&

Pruébalo en línea!

Código de máquina x86-64, 24 bytes

31 C0 8D 50 01 92 01 C2 39 FA 7E F9 89 D1 29 FA 29 C7 39 D7 0F 4F C1 C3

Los bytes de código anterior definen una función en código máquina x86 de 64 bits que se encuentra el número de Fibonacci más cercano al valor de entrada especificado, n.

La función sigue la convención de llamada System V AMD64 (estándar en los sistemas Gnu / Unix), de modo que el único parámetro ( n) se pasa en el EDIregistro y el resultado se devuelve en el EAXregistro.

Mnemotécnicos de montaje sin golf:

; unsigned int ClosestFibonacci(unsigned int n);
    xor    eax, eax        ; initialize EAX to 0
    lea    edx, [rax+1]    ; initialize EDX to 1

  CalcFib:
    xchg   eax, edx        ; swap EAX and EDX
    add    edx, eax        ; EDX += EAX
    cmp    edx, edi
    jle    CalcFib         ; keep looping until we find a Fibonacci number > n

    mov    ecx, edx        ; temporary copy of EDX, because we 'bout to clobber it
    sub    edx, edi
    sub    edi, eax
    cmp    edi, edx
    cmovg  eax, ecx        ; EAX = (n-EAX > EDX-n) ? EDX : EAX
    ret

Pruébalo en línea!

El código básicamente se divide en tres partes:

• La primera parte es muy simple: simplemente inicializa nuestros registros de trabajo. EAXse establece en 0 y EDXse establece en 1.

• La siguiente parte es un bucle que iterativamente calcula los números de Fibonacci a cada lado del valor de entrada, n. Este código se basa en mi implementación anterior de Fibonacci con sustracción , pero ... um ... no es con sustracción. :-) En particular, utiliza el mismo truco de calcular el número de Fibonacci usando dos variables: aquí, estos son los registros EAXy EDX. Este enfoque es extremadamente conveniente aquí, porque nos da números adyacentes de Fibonacci. El candidato potencialmente menor de lo que n se retiene EAX, mientras que el candidato potencialmente mayor de lo que n se retieneEDX. Estoy bastante orgulloso de lo apretado que pude hacer el código dentro de este bucle (y más cosquillas que lo volví a descubrir de forma independiente, y solo más tarde me di cuenta de cuán similar era a la respuesta de resta vinculada anteriormente).

• Una vez que tengamos disponibles los valores de Fibonacci candidatos EAXy EDX, es una cuestión conceptual simple de averiguar cuál está más cerca (en términos de valor absoluto) n. En realidad, teniendo un valor absoluto costaría manera demasiados bytes, por lo que acabamos de hacer una serie de sustracciones. El comentario a la derecha de la penúltima instrucción de movimiento condicional explica acertadamente la lógica aquí. Esto se mueve EDXhacia adentro EAXo se va EAXsolo, de modo que cuando la función se RETactiva, se devuelve el número de Fibonacci más cercano EAX.

En el caso de un empate, se devuelve el menor de los dos valores candidatos, ya que hemos utilizado en CMOVGlugar de CMOVGEhacer la selección. Es un cambio trivial, si prefiere el otro comportamiento. Sin embargo, devolver ambos valores no es un iniciador; solo un resultado entero, por favor!

PowerShell , 80 74 bytes

param($n)for($a,$b=1,0;$a-lt$n;$a,$b=$b,($a+$b)){}($b,$a)[($b-$n-gt$n-$a)]

(¡Pruébelo en línea! Temporalmente no responde)

Solución iterativa. Toma entrada $n, establece $a,$bser 1,0, y luego realiza un bucle con Fibonacci hasta$a sea ​​más grande que la entrada. En ese punto, indexamos en ($b,$a)base a Boolean si la diferencia entre el primer elemento y $nes mayor que entre $ny el segundo elemento. Eso queda en la tubería, la salida es implícita.

JavaScript (ES6), 67 bytes

f=(n,k,y)=>(g=k=>x=k>1?g(--k)+g(--k):k)(k)>n?x+y>2*n?y:x:f(n,-~k,x)

Casos de prueba

f=(n,k,y)=>(g=k=>x=k>1?g(--k)+g(--k):k)(k)>n?x+y>2*n?y:x:f(n,-~k,x)

console.log(f(1   )) // -> 1
console.log(f(3   )) // -> 3
console.log(f(4   )) // -> 3 or 5 or 3, 5
console.log(f(6   )) // -> 5
console.log(f(7   )) // -> 8
console.log(f(11  )) // -> 13
console.log(f(17  )) // -> 13 or 21 or 13, 21
console.log(f(63  )) // -> 55
console.log(f(101 )) // -> 89
console.log(f(377 )) // -> 377
console.log(f(467 )) // -> 377
console.log(f(500 )) // -> 610
console.log(f(1399)) // -> 1597

JavaScript (nodo de Babel) , 41 bytes

f=(n,i=1,j=1)=>j<n?f(n,j,j+i):j-n>n-i?i:j

Residencia en la impresionante respuesta de Python de ovs

Pruébalo en línea!

Sin golf

f=(n,i=1,j=1)=> // Function f: n is the input, i and j are the most recent two Fibonacci numbers, initially 1, 1
 j<n?           // If j is still less than n
  f(n,j,j+i)    //  Try again with the next two Fibonacci numbers
 :              // Else:
  j-n>n-i?i:j   //  If n is closer to i, return i, else return j

Python, 74 bytes

import math
r=5**.5
p=r/2+.5
lambda n:round(p**int(math.log(n*2*r,p)-1)/r)

Pruébalo en línea!

Cómo funciona

Para todos los k ≥ 0, ya que | φ ^{- k} / √5 | <1/2, F _k = φ ^k / √5 + φ ^{- k} / √5 = redondo (φ ^k / √5). Por lo tanto, el valor de retorno cambia de F _{k - 1} a F _k exactamente donde k = log _φ ( n ⋅2√5) - 1, o n = φ ^{k + 1} / (2√5), que está dentro de 1/4 de F _{k + 1/2} = ( F _{k - 1} + F _k ) / 2.

05AB1E , 6 bytes

nÅFs.x

Pruébalo en línea!

C (gcc) , 86 85 83 76 bytes

f(n){n=n<2?:f(n-1)+f(n-2);}i,j,k;g(n){for(;k<n;j=k,k=f(i++));n=k-n<n-j?k:j;}

Pruébalo en línea!

Java (OpenJDK 8) , 60 57 56 bytes

c->{int s=1,r=2;for(;c>r;s=r-s)r+=s;return c-s>r-c?r:s;}

Pruébalo en línea!

-1 byte gracias a @Neil

Python 3 , 103 bytes

import math
def f(n):d=5**.5;p=.5+d/2;l=p**int(math.log(d*n,p))/d;L=[l,p*l];return round(L[2*n>sum(L)])

Pruébalo en línea!

Lamentablemente, tuve que usar un def en lugar de lambda ... Probablemente hay mucho margen de mejora aquí.

Respuesta original (incorrecta):

Python 3 , 72 bytes

lambda n:r(p**r(math.log(d*n,p))/d)
import math
d=5**.5
p=.5+d/2
r=round

Pruébalo en línea!

Mi primera presentación de PPCG. En lugar de calcular los números de Fibonacci de forma recursiva o tenerlos predefinidos, este código usa cómo el número n-ésimo de Fibonacci es el entero más cercano a la potencia n-ésima de la proporción áurea dividida por la raíz de 5.

Taxi, 2321 bytes

Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:s 1 l 1 r.Pickup a passenger going to Trunkers.Go to Trunkers:n 1 l 1 l.0 is waiting at Starchild Numerology.1 is waiting at Starchild Numerology.Go to Starchild Numerology:w 1 l 2 l.Pickup a passenger going to Bird's Bench.Pickup a passenger going to Cyclone.Go to Cyclone:w 1 r 4 l.[a]Pickup a passenger going to Rob's Rest.Pickup a passenger going to Magic Eight.Go to Bird's Bench:n 1 r 2 r 1 l.Go to Rob's Rest:n.Go to Trunkers:s 1 l 1 l 1 r.Pickup a passenger going to Cyclone.Go to Cyclone:w 2 r.Pickup a passenger going to Trunkers.Pickup a passenger going to Magic Eight.Go to Zoom Zoom:n.Go to Trunkers:w 3 l.Go to Magic Eight:e 1 r.Switch to plan "b" if no one is waiting.Pickup a passenger going to Firemouth Grill.Go to Firemouth Grill:w 1 r.Go to Rob's Rest:w 1 l 1 r 1 l 1 r 1 r.Pickup a passenger going to Cyclone.Go to Bird's Bench:s.Pickup a passenger going to Addition Alley.Go to Cyclone:n 1 r 1 l 2 l.Pickup a passenger going to Addition Alley.Pickup a passenger going to Bird's Bench.Go to Addition Alley:n 2 r 1 r.Pickup a passenger going to Cyclone.Go to Cyclone:n 1 l 1 l.Switch to plan "a".[b]Go to Trunkers:w 1 l.Pickup a passenger going to Cyclone.Go to Bird's Bench:w 1 l 1 r 1 l.Pickup a passenger going to Cyclone.Go to Rob's Rest:n.Pickup a passenger going to Cyclone.Go to Cyclone:s 1 l 1 l 2 l.Pickup a passenger going to Sunny Skies Park.Pickup a passenger going to What's The Difference.Pickup a passenger going to What's The Difference.Go to What's The Difference:n 1 l.Pickup a passenger going to Magic Eight.Go to Sunny Skies Park:e 1 r 1 l.Go to Cyclone:n 1 l.Pickup a passenger going to Sunny Skies Park.Pickup a passenger going to What's The Difference.Go to Sunny Skies Park:n 1 r.Pickup a passenger going to What's The Difference.Go to What's The Difference:n 1 r 1 l.Pickup a passenger going to Magic Eight.Go to Magic Eight:e 1 r 2 l 2 r.Switch to plan "c" if no one is waiting.Go to Sunny Skies Park:w 1 l 1 r.Pickup a passenger going to The Babelfishery.Go to Cyclone:n 1 l.Switch to plan "d".[c]Go to Cyclone:w 1 l 2 r.[d]Pickup a passenger going to The Babelfishery.Go to The Babelfishery:s 1 l 2 r 1 r.Pickup a passenger going to Post Office.Go to Post Office:n 1 l 1 r.

Pruébalo en línea!
Pruébalo en línea con comentarios!

Sin golf con comentarios:

[ Find the Fibonacci number closest to the input ]
[ Inspired by: https://codegolf.stackexchange.com/q/133365 ]


[ n = STDIN ]
Go to Post Office: west 1st left 1st right 1st left.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery: south 1st left 1st right.
Pickup a passenger going to Trunkers.
Go to Trunkers: north 1st left 1st left.


[ Initialize with F0=0 and F1=1 ]
0 is waiting at Starchild Numerology.
1 is waiting at Starchild Numerology.
Go to Starchild Numerology: west 1st left 2nd left.
Pickup a passenger going to Bird's Bench.
Pickup a passenger going to Cyclone.
Go to Cyclone: west 1st right 4th left.


[ For (i = 1; n > F(i); i++) { Store F(i) at Rob's Rest and F(i-1) at Bird's Bench } ]
[a]
Pickup a passenger going to Rob's Rest.
Pickup a passenger going to Magic Eight.
Go to Bird's Bench: north 1st right 2nd right 1st left.
Go to Rob's Rest: north.
Go to Trunkers: south 1st left 1st left 1st right.
Pickup a passenger going to Cyclone.
Go to Cyclone: west 2nd right.
Pickup a passenger going to Trunkers.
Pickup a passenger going to Magic Eight.
Go to Zoom Zoom: north.
Go to Trunkers: west 3rd left.
Go to Magic Eight: east 1st right.
Switch to plan "b" if no one is waiting.

[ n >= F(i) so iterate i ]
Pickup a passenger going to Firemouth Grill.
Go to Firemouth Grill: west 1st right.
Go to Rob's Rest: west 1st left 1st right 1st left 1st right 1st right.
Pickup a passenger going to Cyclone.
Go to Bird's Bench: south.
Pickup a passenger going to Addition Alley.
Go to Cyclone: north 1st right 1st left 2nd left.
Pickup a passenger going to Addition Alley.
Pickup a passenger going to Bird's Bench.
Go to Addition Alley: north 2nd right 1st right.
Pickup a passenger going to Cyclone.
Go to Cyclone: north 1st left 1st left.
Switch to plan "a".


[b]
[ F(i) > n which means n >= F(i-1) and we need to figure out which is closer and print it]
Go to Trunkers: west 1st left.
Pickup a passenger going to Cyclone.
Go to Bird's Bench: west 1st left 1st right 1st left.
Pickup a passenger going to Cyclone.
Go to Rob's Rest: north.
Pickup a passenger going to Cyclone.
Go to Cyclone: south 1st left 1st left 2nd left.
Pickup a passenger going to Sunny Skies Park.
Pickup a passenger going to What's The Difference.
Pickup a passenger going to What's The Difference.
[ Passengers:n, n, F(i-1) ]
Go to What's The Difference: north 1st left.
Pickup a passenger going to Magic Eight.
[ Passengers:n, n-F(i-1) ]
Go to Sunny Skies Park: east 1st right 1st left.
Go to Cyclone: north 1st left.
Pickup a passenger going to Sunny Skies Park.
Pickup a passenger going to What's The Difference.
[ Passengers: n-F(i-1), F(i-1), F(i) ]
Go to Sunny Skies Park: north 1st right.
Pickup a passenger going to What's The Difference.
[ Passengers: n-F(i-1), F(i), n ]
Go to What's The Difference: north 1st right 1st left.
[ Passengers: n-F(i-1), F(i)-n ]
Pickup a passenger going to Magic Eight.
Go to Magic Eight: east 1st right 2nd left 2nd right.
Switch to plan "c" if no one is waiting.

[ If no one was waiting, then {n-F(i-1)} < {F(i)-n} so we return F(i-1) ]
Go to Sunny Skies Park: west 1st left 1st right.
Pickup a passenger going to The Babelfishery.
Go to Cyclone: north 1st left.
Switch to plan "d".

[c]
[ Otherwise {n-F(i-1)} >= {F(i)-n} so we return F(i) ]
[ Note: If we didn't switch to plan c, we still pickup F(i) but F(i-1) will be the *first* passenger and we only pickup one at The Babelfishery ]
[ Note: Because of how Magic Eight works, we will always return F(i) in the event of a tie ]
Go to Cyclone: west 1st left 2nd right.
[d]
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery: south 1st left 2nd right 1st right.
Pickup a passenger going to Post Office.
Go to Post Office: north 1st left 1st right.

Python 3 , 84 bytes

lambda k:min(map(f,range(2*k)),key=lambda n:abs(n-k))
f=lambda i:i<3or f(i-1)+f(i-2)

Pruébalo en línea!

Puede funcionar, pero ciertamente no es rápido ...

Salidas en Truelugar de 1, pero en Python son equivalentes.

cc, 52 bytes

si1d[dsf+lfrdli>F]dsFxli-rlir-sdd[lild-pq]sDld<Dli+p

Pruébalo en línea!

Toma entrada en la carrera usando ?

Editado para asumir la parte superior de la pila como valor de entrada, -1 byte.

La entrada se almacena en el registro i. Luego ponemos 1 y 1 en la pila para comenzar la secuencia de Fibonacci, y generamos la secuencia hasta que alcancemos un valor mayor que i. En este punto tenemos dos números en la secuencia de Fibonacci en la pila: uno que es menor o igual que i, y uno que es mayor que i. Los convertimos en sus respectivas diferencias iy luego comparamos las diferencias. Finalmente, reconstruimos el número de Fibonacci sumando o restando la diferencia ai .

Vaya, estaba cargando dos registros en el orden incorrecto y luego los intercambiaba, desperdiciando un byte.

C # (.NET Core) , 63 56 bytes

-1 byte gracias a @Neil

-6 bytes gracias a @Nevay

n=>{int a=0,b=1;for(;b<n;a=b-a)b+=a;return n-a>b-n?b:a;}

Pruébalo en línea!

Q / KDB +, 51 bytes

{w where l=min l:abs neg[x]+w:{x,sum -2#x}/[x;0 1]}

Hexagonía , 37 bytes.

?\=-${&"*.2}+".|'=='.@.&}1.!_|._}$_}{

Pruébalo en línea!

sin golf:

   ? \ = - 
  $ { & " * 
 . 2 } + " .
| ' = = ' . @
 . & } 1 . !
  _ | . _ }
   $ _ } { 

Desglosado:

start:
? { 2 ' * //set up 2*target number
" ' 1     //initialize curr to 1

main loop:
} = +     //next + curr + last
" -       //test = next - (2*target)
branch: <= 0 -> continue; > 0 -> return

continue:
{ } = &   //last = curr
} = &     //curr = next


return:
{ } ! @   //print last

Al igual que algunos otros carteles, me di cuenta de que cuando el punto medio de last y curr es mayor que el objetivo, el más pequeño de los dos es el más cercano o el más cercano.

El punto medio está en (last + curr) / 2. Podemos acortar eso porque next ya es last + curr, y si en cambio multiplicamos nuestro entero objetivo por 2, solo necesitamos verificar que (next - 2 * target)> 0, luego regrese último.

Brachylog , 22 bytes

;I≜-.∧{0;1⟨t≡+⟩ⁱhℕ↙.!}

Pruébalo en línea!

Realmente, todo lo que he hecho aquí es pegar el clásico de Fatalize. Devolver la solución del número primo más cercano y la mía. ¿Soy un número de Fibonacci? solución. Afortunadamente, este último ya opera en la variable de salida; desafortunadamente, también incluye un corte necesario que debe aislarse para +2 bytes, por lo que el único punto de elección que descarta es ⁱdejarlo ≜intacto.

Japt -g , 8 bytes

ò!gM ñaU

Intentalo

Java 7, 244 234 bytes

 String c(int c){for(int i=1;;i++){int r=f(i);int s=f(i-1);if(r>c && s<c){if(c-s == r-c)return ""+r+","+s;else if(s-c > r-c)return ""+r;return ""+s;}}} int f(int i){if(i<1)return 0;else if(i==1)return 1;else return f(i-2)+f(i-1);}

Pyke , 6 bytes

}~F>R^

Pruébalo en línea!

}      -    input*2
 ~F    -   infinite list of the fibonacci numbers
   >   -  ^[:input]
    R^ - closest_to(^, input)

Lisp común, 69 bytes

(lambda(n)(do((x 0 y)(y 1(+ x y)))((< n y)(if(<(- n x)(- y n))x y))))

Pruébalo en línea!

Perl 6 , 38 bytes

{(0,1,*+*...*>$_).sort((*-$_).abs)[0]}

Pruébalo

{   # bare block lambda with implicit parameter ｢$_｣

  ( # generate Fibonacci sequence

    0, 1,  # seed the sequence
    * + *  # WhateverCode lambda that generates the rest of the values
    ...    # keep generating until
    * > $_ # it generates one larger than the original input
           # (that larger value is included in the sequence)

  ).sort(           # sort it by
    ( * - $_ ).abs  # the absolute difference to the original input
  )[0]              # get the first value from the sorted list
}

Para una posible aceleración agregue .tail(2)antes .sort(…).

En el caso de un empate, siempre devolverá el menor de los dos valores, porque sortes un tipo estable. (dos valores que ordenarían lo mismo mantienen su orden)

Pyth, 19 bytes

JU2VQ=+Js>2J)hoaNQJ

Pruébalo aquí

Explicación

JU2VQ=+Js>2J)hoaNQJ
JU2                  Set J = [0, 1].
   VQ=+Js>2J)        Add the next <input> Fibonacci numbers.
              oaNQJ  Sort them by distance to <input>.
             h       Take the first.

Haskell, 48 bytes

(%)a b x|abs(b-x)>abs(a-x)=a|1>0=b%(a+b)$x
(1%2)

Pruébalo en línea!