Conosciamo tutti la famosa sequenza di Fibonacci , che inizia con 0e 1, e ogni elemento è la somma delle due precedenti. Ecco i primi termini (OEIS A000045 ):

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

Dato un numero intero positivo , restituisci il numero più vicino della sequenza di Fibonacci, secondo queste regole:

• Il numero di Fibonacci più vicino è definito come il numero di Fibonacci con la più piccola differenza assoluta con l'intero dato. Ad esempio, 34è il numero di Fibonacci più vicino a 30, perché |34 - 30| = 4, che è più piccolo del secondo più vicino 21, per il quale |21 - 30| = 9.

• Se il dato numero intero appartiene alla sequenza di Fibonacci, il numero di Fibonacci più vicino è esattamente se stesso. Ad esempio, il numero di Fibonacci più vicino a 13è esattamente 13.

• In caso di pareggio, puoi scegliere di emettere uno dei numeri di Fibonacci che sono entrambi più vicini all'ingresso o semplicemente di emetterli entrambi. Ad esempio, se l'ingresso è 17, tutti i seguenti valgono: 21, 13o 21, 13. Nel caso in cui vengano restituiti entrambi, indicare il formato.

Si applicano scappatoie predefinite . Puoi prendere input e fornire output attraverso qualsiasi metodo standard . Il tuo programma / funzione deve gestire solo valori fino a 10 ⁸ .

Casi test

Ingresso -> Uscita

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

punteggio

Questo è code-golf , quindi vince il codice più breve in byte in ogni lingua !

Python 2 , 43 byte

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

Provalo online!

Scorre tra coppie di numeri consecutivi di Fibonacci (a,b)fino a raggiungere uno in cui l'input nè inferiore al loro punto medio (a+b)/2, quindi ritorna a.

Scritto come programma (47 byte):

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

Stessa lunghezza :

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

Neim , 5 byte

f𝐖𝕖S𝕔

Spiegazione:

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

Nella versione più recente di Neim, questo può essere giocato a 3 byte:

fS𝕔

Poiché gli elenchi infiniti sono stati rielaborati per arrivare solo al loro valore massimo.

Provalo online!

Python , 55 52 byte

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

Provalo online!

R , 70 67 64 62 60 byte

-2 byte grazie a djhurio!

-2 byte in più grazie a djhurio (ragazzo può giocare a golf!)

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

Dal momento che dobbiamo solo gestire i valori fino a 10^8questo, questo funziona.

Provalo online!

Legge nda stdin. il whileciclo genera i numeri di fibonacci in F(in ordine decrescente); in caso di pareggio, viene restituito il più grande. Ciò attiverà una serie di avvisi perchéwhile(F<1e8) valuta solo l'istruzione per il primo elemento di Fcon un avviso

Inizialmente ho usato F[which.min(abs(F-n))]l'approccio ingenuo, ma @djhurio ha suggerito che (F-n)^2l'ordinamento sarà equivalente e orderinvece di which.min. orderrestituisce una permutazione di indici per mettere il suo input in ordine crescente, tuttavia, quindi [1]alla fine abbiamo bisogno di ottenere solo il primo valore.

versione più veloce:

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

memorizza solo gli ultimi due numeri di fibonacci

JavaScript (ES6), 41 byte

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

Arrotonda per preferenza.

Gelatina , 9 7 byte

-2 byte grazie a @EriktheOutgolfer

‘RÆḞạÐṂ

Provalo online!

Suggerimenti per il golf benvenuti :). Prende un int per l'input e restituisce un int-list.

            ' 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 byte

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

Provalo online!

x86-64 Codice macchina, 24 byte

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

I suddetti byte di codice definiscono una funzione nel codice macchina x86 a 64 bit che trova il numero di Fibonacci più vicino al valore di input specificato, n .

La funzione segue la convenzione di chiamata AMD64 di System V (standard sui sistemi Gnu / Unix), in modo tale che l'unico parametro ( n) venga passato nel EDIregistro e il risultato venga restituito nel EAXregistro.

Mnemonici di assemblaggio non golfati:

; 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

Provalo online!

Il codice sostanzialmente si divide in tre parti:

• La prima parte è molto semplice: inizializza i nostri registri di lavoro. EAXè impostato su 0 ed EDXè impostato su 1.

• La parte successiva è un ciclo che calcola iterativamente i numeri di Fibonacci su entrambi i lati del valore di ingresso, n. Questo codice si basa sulla mia precedente implementazione di Fibonacci con sottrazione , ma ... um ... non con sottrazione. :-) In particolare, usa lo stesso trucco per calcolare il numero di Fibonacci usando due variabili: ecco i registri EAXe EDX. Questo approccio è estremamente conveniente qui, perché ci dà numeri di Fibonacci adiacenti. Il candidato potenzialmente inferiore a quello in cui n è detenuto EAX, mentre il candidato potenzialmente maggiore in cui n è detenutoEDX. Sono abbastanza orgoglioso di quanto sia stato in grado di creare il codice all'interno di questo ciclo (e ancora di più ho solleticato il fatto di averlo riscoperto in modo indipendente, e solo successivamente ho capito quanto fosse simile alla risposta di sottrazione collegata sopra).

• Una volta che abbiamo i valori di Fibonacci candidati disponibili in EAXe EDX, è una questione concettualmente semplice di capire quale è più vicino (in termini di valore assoluto) n. In realtà prendendo un valore assoluto costerebbe modo troppi byte, quindi dobbiamo solo fare una serie di sottrazioni. Il commento a destra della penultima istruzione di mossa condizionale spiega appropriatamente la logica qui. Questa operazione si muove EDXin EAX, o foglie EAXda solo, in modo che quando la funzione RETurne, il numero di Fibonacci più vicino viene restituito in EAX.

Nel caso di un pareggio, viene restituito il più piccolo dei due valori candidati, poiché abbiamo usato CMOVGinvece di CMOVGEfare la selezione. È un cambiamento banale, se preferisci l'altro comportamento. Restituire entrambi i valori non è un inizio, però; solo un risultato intero, per favore!

PowerShell , 80 74 byte

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

(Provalo online! Non risponde temporaneamente)

Soluzione iterativa. Prende input $n, imposta $a,$bessere 1,0, quindi esegue il loop con Fibonacci fino a quando $aè più grande dell'input. A quel punto, indicizziamo in ($b,$a)base al valore booleano se la differenza tra il primo elemento ed $nè maggiore di tra $ne il secondo elemento. Rimane in cantiere, l'output è implicito.

JavaScript (ES6), 67 byte

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)

Casi test

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 (Babel Node) , 41 byte

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

Basato sulla straordinaria risposta Python di ovs

Provalo online!

Ungolfed

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 byte

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

Provalo online!

Come funziona

Per tutti k ≥ 0, poiché | φ ^{- k} / √5 | <1/2, F _k = φ ^k / √5 + φ ^{- k} / √5 = round (φ ^k / √5). Quindi il valore di ritorno passa da F _{k - 1} a F _k esattamente dove k = log _φ ( n ⋅2√5) - 1, o n = φ ^{k + 1} / (2√5), che è entro 1/4 di F _{k +} 1/2 = ( F _{k - 1} + F _k ) / 2.

05AB1E , 6 byte

nÅFs.x

Provalo online!

C (gcc) , 86 85 83 76 byte

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;}

Provalo online!

Java (OpenJDK 8) , 60 57 56 byte

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

Provalo online!

-1 byte grazie a @Neil

Python 3 , 103 byte

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

Provalo online!

Purtroppo, ho dovuto usare un def invece di lambda ... Probabilmente qui c'è molto margine di miglioramento.

Risposta originale (errata):

Python 3 , 72 byte

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

Provalo online!

La mia prima presentazione PPCG. Invece di calcolare ricorsivamente i numeri di Fibonacci o di averli predefiniti, questo codice utilizza il modo in cui l'n-esimo numero di Fibonacci è il numero intero più vicino all'n-esima potenza del rapporto aureo diviso per la radice di 5.

Taxi, 2321 byte

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.

Provalo online!
Provalo online con commenti!

Non golfato con commenti:

[ 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 byte

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)

Provalo online!

Potrebbe funzionare, ma sicuramente non è veloce ...

Output Trueinvece di 1, ma in Python sono equivalenti.

dc, 52 byte

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

Provalo online!

Accetta input durante l'esecuzione utilizzando ?

Modificato per assumere la parte superiore dello stack come valore di input, -1 byte.

L'ingresso è memorizzato nel registro i. Quindi mettiamo 1 e 1 in pila per iniziare la sequenza di Fibonacci e generiamo la sequenza fino a quando non raggiungiamo un valore maggiore di i. A questo punto abbiamo due numeri nella sequenza di Fibonacci in pila: uno che è minore o uguale a ie uno che è maggiore di i. Li convertiamo nelle rispettive differenze con ie quindi confrontiamo le differenze. Infine ricostruiamo il numero di Fibonacci aggiungendo o sottraendo la differenza ai .

Oops, stavo caricando due registri nell'ordine sbagliato e poi li scambiavo, sprecando un byte.

C # (.NET Core) , 63 56 byte

-1 byte grazie a @Neil

-6 byte grazie a @Nevay

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

Provalo online!

Q / KDB +, 51 byte

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

Esagonia , 37 byte

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

Provalo online!

ungolfed:

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

Suddiviso:

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

Come alcuni altri poster, mi sono reso conto che quando il punto medio di last e curr è maggiore del target, il più piccolo dei due è il più vicino o il più vicino.

Il punto medio è (ultimo + curr) / 2. Possiamo accorciarlo perché il prossimo è già ultimo + curr e se invece moltiplichiamo il numero intero target per 2, dobbiamo solo verificare che (successivo - 2 * target)> 0, quindi restituire l'ultimo.

Brachylog , 22 byte

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

Provalo online!

Davvero tutto ciò che ho fatto qui è incollare insieme il classico di Fatalize Restituire la soluzione del numero primo più vicina e il mio Am I a Fibonacci Number? soluzione. Fortunatamente, quest'ultima opera già sulla variabile di output; sfortunatamente, include anche un taglio necessario che deve essere isolato per +2 byte, quindi l'unico punto di scelta che scarta è ⁱlasciare ≜intatto.

Japt -g , 8 byte

ò!gM ñaU

Provalo

Java 7, 244 234 byte

 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 byte

}~F>R^

Provalo online!

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

Lisp comune, 69 byte

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

Provalo online!

Perl 6 , 38 byte

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

Provalo

{   # 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
}

Per una potenziale accelerazione aggiungere .tail(2)prima .sort(…).

Nel caso di un pareggio, restituirà sempre il più piccolo dei due valori, perché sortè un ordinamento stabile. (due valori che ordinerebbero lo stesso mantengono il loro ordine)

Pyth, 19 byte

JU2VQ=+Js>2J)hoaNQJ

Provalo qui

Spiegazione

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 byte

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

Provalo online!