우리는 유명한 잘 알고있는 피보나치 시퀀스 , 그와 함께 시작 0하고 1, 각 요소는 이전 두의 합계입니다. 처음 몇 용어 (OEIS A000045 ) 는 다음과 같습니다 .

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

양의 정수가 주어지면 다음 규칙에 따라 가장 가까운 피보나치 수를 반환합니다.

• 가까운 피보나치 수는 소정의 정수와 가장 작은 절대 차와 피보나치 수로서 정의된다. 예를 들면, 34가장 가까운 피보나치 수있다 30때문에 |34 - 30| = 4, 제 가까운 하나보다 작은, 21용 |21 - 30| = 9.

• 주어진 정수가 피보나치 수열에 속하면 가장 가까운 피보나치 수는 정확히 그 자체입니다. 예를 들어, 가장 가까운 피보나치 수 13는 정확히 13입니다.

• 동점 인 경우 입력에 가장 가까운 피보나치 수 중 하나를 출력하거나 둘 다 출력하도록 선택할 수 있습니다. 예를 들어, 입력이 인 경우 , 또는 17모두 유효합니다 . 둘 다 반환하는 경우 형식을 언급하십시오.211321, 13

기본 허점이 적용됩니다. 표준 방법을 통해 입력을 받고 출력 할 수 있습니다 . 프로그램 / 기능은 최대 10 ⁸ 값만 처리해야합니다 .

테스트 사례

입력-> 출력

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

채점

이것은 code-golf 이므로 모든 언어에서 가장 짧은 바이트 코드가 이깁니다!

파이썬 2 , 43 바이트

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

온라인으로 사용해보십시오!

(a,b)입력 n이 중간 점보다 작은 1에 도달 할 때까지 연속적인 피보나치 수 쌍을 반복 (a+b)/2한 다음 반환합니다 a.

프로그램으로 작성 됨 (47 바이트) :

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

동일한 길이 :

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

Neim , 5 바이트

f𝐖𝕖S𝕔

설명:

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

최신 버전의 Neim에서는 3 바이트로 골프화 할 수 있습니다.

fS𝕔

무한 목록은 최대 값까지 올라 가기 위해 재 작업되었습니다.

온라인으로 사용해보십시오!

파이썬 , 55 52 바이트

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

온라인으로 사용해보십시오!

R , 70 67 64 62 60 바이트

djhurio 덕분에 -2 바이트!

djhurio 덕분에 -2 바이트 더 (소년 골프 가능)

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

최대 값만 처리하면되므로 10^8작동합니다.

온라인으로 사용해보십시오!

nstdin에서 읽습니다 . while루프에서 피보나치 수열 생성한다 F(순서 감소하여); 동점 일 경우 더 큰 값이 반환됩니다. while(F<1e8)첫 번째 요소에 대한 명령문 만 평가 하므로 여러 경고가 트리거됩니다.F 경고와를

원래 나는 F[which.min(abs(F-n))]순진한 접근 방식을 사용했지만 @djhurio (F-n)^2는 순서가 order대신 대신 동일 하므로 제안했습니다 which.min. order그러나 입력의 순서를 증가시키기 위해 인덱스 순열을 반환하므로 [1]결국 첫 번째 값만 가져와야합니다.

빠른 버전 :

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

마지막 두 피보나치 수만 저장

자바 스크립트 (ES6), 41 바이트

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

선호도에 따라 반올림합니다.

젤리 , 9 7 바이트

@EriktheOutgolfer 덕분에 -2 바이트

‘RÆḞạÐṂ

온라인으로 사용해보십시오!

골프 팁 :). 입력을 위해 int를 취하고 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 바이트

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

온라인으로 사용해보십시오!

x86-64 기계 코드, 24 바이트

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

위의 바이트 코드는 64 비트 x86 기계 코드에서 지정된 입력 값과 가장 가까운 피보나치 수를 찾는 함수를 정의합니다. n .

이 함수는 System V AMD64 호출 규칙 (Gnu / Unix 시스템의 표준)을 따르므로 유일한 매개 변수 ( n)가 EDI레지스터에 전달되고 결과가 EAX레지스터에 반환됩니다 .

ungolfed 어셈블리 니모닉 :

; 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

온라인으로 사용해보십시오!

코드는 기본적으로 세 부분으로 나뉩니다.

• 첫 번째 부분은 매우 간단합니다. 작업 레지스터 만 초기화합니다. EAX0 EDX으로 설정되고 1로 설정됩니다.

• 다음 부분은 입력 값의 양쪽에서 피보나치 수를 반복적으로 계산하는 루프입니다 n. 이 코드는 내 이전 피보나치 구현을 기반으로 빼기 를 사용하지만… 음…을 빼지 않습니다. :-) 특히, 두 개의 변수를 사용하여 피보나치 수를 계산하는 것과 동일한 트릭을 사용합니다. 여기서 이들은 EAX및 EDX레지스터입니다. 이 접근법은 피보나치 수에 인접 해 있기 때문에 매우 편리합니다. 후보 가에서 보다 적을 수 n 있는 EAX반면 후보 가 n 으로 유지EDX. 나는이 루프 내부에서 코드를 얼마나 단단히 만들 수 있었는지 자랑스럽게 생각합니다 (그리고 더 독립적으로 다시 발견 한 후에 더 이상 간지러워졌으며 나중에 위의 링크에서 빼기 답변과 비슷한 점을 깨달았습니다).

• EAX그리고 에서 피보나치 후보 값을 사용할 수있게되면 EDX, 어느 값이 (절대 값으로) 더 가까운지를 알아내는 것은 개념적으로 간단한 문제입니다 n. 실제로 절대 값을 사용 하면 너무 많은 바이트 가 소비 되므로 일련의 빼기를 수행합니다. 두 번째 조건부 이동 명령의 오른쪽에있는 주석은 여기서 논리를 적절하게 설명합니다. 이 중 이동 EDX로 EAX, 또는 잎 EAX혼자, 그래서 함수 때 RET항아리가 가장 가까운 피보나치 번호가 반환됩니다 EAX.

동점의 경우 선택을 수행하는 대신 사용했기 때문에 두 후보 값 중 작은 값이 반환됩니다 . 다른 행동을 선호한다면 사소한 변화입니다. 그러나 두 값을 모두 반환 하는 것은 시작이 아닙니다. 하나의 정수 결과 만주세요!CMOVGCMOVGE

PowerShell , 80 74 바이트

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

(온라인으로 시도하십시오! 일시적으로 응답하지 않습니다)

반복 솔루션. 입력을받습니다$n , 세트 $a,$b될 1,0때까지 다음과 피보나치 루프 $a입력보다 크다. 이 시점 ($b,$a)에서 첫 번째 요소와 두 번째 요소 사이의 차이가 두 번째 요소 $n보다 큰지 여부의 부울 을 기준으로 색인 합니다 $n. 그것은 파이프 라인에 남아 있으며 출력은 암시 적입니다.

자바 스크립트 (ES6), 67 바이트

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)

테스트 사례

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

자바 스크립트 (Babel Node) , 41 바이트

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

ovs의 멋진 Python 답변을 기반으로

온라인으로 사용해보십시오!

언 골프

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

파이썬, 74 바이트

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

온라인으로 사용해보십시오!

작동 원리

모든 k ≥ 0에 대해 | φ ^{− k} / √5 | <1/2, F _k = φ ^k / √5 + φ ^{− k} / √5 = 원형 (φ ^k / √5). 따라서 반환 값은 F _{k -1} 에서 F _k로 정확히 전환됩니다. 여기서 k = log _φ ( n ⋅2√5)-1 또는 n = φ ^{k + 1} / (2√5) F _{k +} 1/2 = ( F _{k -1} + F _k ) / 2.

05AB1E , 6 바이트

nÅFs.x

온라인으로 사용해보십시오!

C (gcc) , 86 85 83 76 바이트

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

온라인으로 사용해보십시오!

자바 (OpenJDK 8) , 60 57 56 바이트

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

온라인으로 사용해보십시오!

@Neil 덕분에 -1 바이트

파이썬 3 , 103 바이트

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

온라인으로 사용해보십시오!

슬프게도 람다 대신 데프를 사용해야했습니다. 여기에 개선의 여지가 많이 있습니다.

원래 (잘못된) 답변 :

파이썬 3 , 72 바이트

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

온라인으로 사용해보십시오!

My first PPCG submission. Instead of either calculating Fibonacci numbers recursively or having them predefined, this code uses how the n-th Fibonacci number is the nearest integer to the n-th power of the golden ratio divided by the root of 5.

택시, 2321 바이트

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.

온라인으로 사용해보십시오!
Try it online with comments!

댓글이없는 골프 :

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

파이썬 3 , 84 바이트

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)

온라인으로 사용해보십시오!

작동 할 수도 있지만 빠르지는 않습니다 ...

True대신에 출력 1하지만 파이썬에서는 이것과 같습니다.

dc, 52 바이트

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

온라인으로 사용해보십시오!

다음을 사용하여 실행시 입력을받습니다. ?

스택 상단을 입력 값 -1 바이트로 가정하도록 편집되었습니다.

Input is stored in register i. Then we put 1 and 1 on the stack to start the Fibonacci sequence, and we generate the sequence until we hit a value greater than i. At this point we have two numbers in the Fibonacci sequence on the stack: one that is less than or equal to i, and one that is greater than i. We convert these into their respective differences with i and then compare the differences. Finally we reconstruct the Fibonacci number by either adding or subtracting the difference to i.

Oops, I was loading two registers in the wrong order and then swapping them, wasting a byte.

C# (.NET Core), 63 56 bytes

-1 byte thanks to @Neil

-6 bytes thanks to @Nevay

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

Try it online!

Q/KDB+, 51 bytes

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

Hexagony, 37 bytes

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

Try it online!

ungolfed:

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

Broken down:

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

Like some other posters, I realized that when the midpoint of last and curr is greater than the target, the smaller of the two is the closest or tied for closest.

The midpoint is at (last + curr)/2. We can shorten that because next is already last + curr, and if we instead multiply our target integer by 2, we only need to check that (next - 2*target) > 0, then return last.

Brachylog, 22 bytes

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

Try it online!

Really all I've done here is paste together Fatalize's classic Return the closest prime number solution and my own Am I a Fibonacci Number? solution. Fortunately, the latter already operates on the output variable; unfortunately, it also includes a necessary cut which has to be isolated for +2 bytes, so the only choice point it discards is ⁱ, leaving ≜ intact.

Japt -g, 8 bytes

ò!gM ñaU

Try it

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^

Try it online!

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

Common Lisp, 69 bytes

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

Try it online!

Perl 6, 38 bytes

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

Test it

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

For a potential speed-up add .tail(2) before .sort(…).

In the case of a tie, it will always return the smaller of the two values, because sort is a stable sort. (two values which would sort the same keep their order)

Pyth, 19 bytes

JU2VQ=+Js>2J)hoaNQJ

Try it here

Explanation

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)

Try it online!