Nous connaissons tous la célèbre séquence de Fibonacci , qui commence par 0et 1, et chaque élément est la somme des deux précédents. Voici les premiers termes (OEIS A000045 ):

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

Étant donné un entier positif , retournez le nombre le plus proche de la séquence de Fibonacci, selon ces règles:

• Le nombre de Fibonacci le plus proche est défini comme le nombre de Fibonacci avec la plus petite différence absolue avec l'entier donné. Par exemple, 34est le nombre de Fibonacci le plus proche de 30, car |34 - 30| = 4, qui est plus petit que le deuxième plus proche 21, pour lequel |21 - 30| = 9.

• Si l'entier donné appartient à la séquence de Fibonacci, le nombre de Fibonacci le plus proche est exactement lui-même. Par exemple, le nombre de Fibonacci le plus proche de 13est exactement 13.

• En cas d'égalité, vous pouvez choisir de sortir l'un des numéros de Fibonacci les plus proches de l'entrée ou simplement les sortir tous les deux. Par exemple, si l'entrée est 17, tous les éléments suivants sont valables: 21, 13ou 21, 13. Si vous les retournez tous les deux, veuillez mentionner le format.

Les échappatoires par défaut s'appliquent. Vous pouvez prendre des entrées et fournir des sorties par n'importe quelle méthode standard . Votre programme / fonction ne doit gérer que des valeurs jusqu'à 10 ⁸ .

Cas de test

Entrée -> Sortie

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

Notation

C'est le code-golf , donc le code le plus court en octets dans chaque langue gagne!

Python 2 , 43 octets

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

Essayez-le en ligne!

Itère à travers des paires de nombres de Fibonacci consécutifs (a,b)jusqu'à ce qu'il atteigne celui où l'entrée nest inférieure à leur point médian (a+b)/2, puis revient a.

Écrit en tant que programme (47 octets):

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

Même longueur :

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

Neim , 5 octets

f𝐖𝕖S𝕔

Explication:

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

Dans la dernière version de Neim, cela peut être joué à 3 octets:

fS𝕔

Comme des listes infinies ont été retravaillées pour ne remonter qu'à leur valeur maximale.

Essayez-le en ligne!

Python , 55 52 octets

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

Essayez-le en ligne!

R , 70 67 64 62 60 octets

-2 octets grâce à djhurio!

-2 octets de plus grâce à djhurio (garçon peut-il jouer au golf!)

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

Puisque nous n'avons qu'à gérer des valeurs jusqu'à 10^8, cela fonctionne.

Essayez-le en ligne!

Lit à npartir de stdin. la whileboucle génère les nombres de fibonacci en F(dans l'ordre décroissant); en cas d'égalité, le plus gros est retourné. Cela déclenchera un certain nombre d'avertissements car while(F<1e8)n'évalue l'instruction que pour le premier élément de Favec un avertissement

À l'origine, j'ai utilisé F[which.min(abs(F-n))]l'approche naïve, mais @djhurio a suggéré (F-n)^2que la commande serait équivalente et ordernon pas which.min. orderretourne une permutation d'indices pour mettre son entrée dans l'ordre croissant, cependant, nous avons donc besoin [1]à la fin d'obtenir uniquement la première valeur.

version plus rapide:

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

ne stocke que les deux derniers nombres de fibonacci

JavaScript (ES6), 41 octets

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

Arrondit par préférence.

Gelée , 9 7 octets

-2 octets grâce à @EriktheOutgolfer

‘RÆḞạÐṂ

Essayez-le en ligne!

Conseils de golf bienvenus :). Prend un int pour entrée et retourne une 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 octets

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

Essayez-le en ligne!

Code machine x86-64, 24 octets

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

Les octets de code ci - dessus définissent une fonction dans un code machine x86 64 bits qui trouve le plus proche nombre de Fibonacci de la valeur d'entrée spécifiée, n.

La fonction suit la convention d'appel System V AMD64 (standard sur les systèmes Gnu / Unix), de sorte que le seul paramètre ( n) est passé dans le EDIregistre et le résultat est retourné dans le EAXregistre.

Mnémoniques d'assemblage non golfés:

; 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

Essayez-le en ligne!

Le code se divise essentiellement en trois parties:

• La première partie est très simple: elle initialise simplement nos registres de travail. EAXest défini sur 0 et EDXdéfini sur 1.

• La partie suivante est une boucle qui permet de calculer de manière itérative les nombres de Fibonacci de part et d' autre de la valeur d'entrée, n. Ce code est basé sur mon implémentation précédente de Fibonacci avec soustraction , mais… euh… n'est pas avec soustraction. :-) En particulier, il utilise la même astuce pour calculer le nombre de Fibonacci en utilisant deux variables - ici, ce sont les registres EAXet EDX. Cette approche est extrêmement pratique ici, car elle nous donne des nombres de Fibonacci adjacents. Le candidat potentiellement inférieur à celui n détenu EAX, tandis que le candidat potentiellement supérieur à celui n détenuEDX. Je suis assez fier de la façon dont j'ai pu serrer le code à l'intérieur de cette boucle (et encore plus chatouillé que je l'ai redécouvert indépendamment, et que j'ai réalisé plus tard à quel point c'était similaire à la réponse de soustraction liée ci-dessus).

• Une fois que nous avons les valeurs de Fibonacci candidates disponibles dans EAXet EDX, il s'agit d'une question conceptuellement simple de déterminer laquelle est la plus proche (en termes de valeur absolue) n. En fait, prendre une valeur absolue coûterait beaucoup trop d'octets, nous ne faisons donc qu'une série de soustractions. Le commentaire à droite de l'avant-dernière instruction de déplacement conditionnel explique bien la logique ici. Ce soit se déplace EDXdans EAX, ou les feuilles EAXseules, de sorte que lorsque la fonction RETUrnes, le nombre le plus proche est retourné Fibonacci dans EAX.

Dans le cas d'une égalité, la plus petite des deux valeurs candidates est retournée, puisque nous avons utilisé CMOVGau lieu de CMOVGEfaire la sélection. C'est un changement trivial, si vous préférez l'autre comportement. Le retour des deux valeurs n'est cependant pas un démarreur; un seul résultat entier, s'il vous plaît!

PowerShell , 80 74 octets

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

(Essayez-le en ligne! Ne répond pas temporairement)

Solution itérative. Prend l'entrée $n, définit $a,$bêtre 1,0, puis boucle avec Fibonacci jusqu'à ce qu'elle $asoit plus grande que l'entrée. À ce stade, nous indexons en ($b,$a)basé sur Boolean si la différence entre le premier élément et $nest supérieure à celle entre $net le deuxième élément. Cela reste sur le pipeline, la sortie est implicite.

JavaScript (ES6), 67 octets

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)

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

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

Basé sur la réponse impressionnante d'Ovs en Python

Essayez-le en ligne!

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

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

Essayez-le en ligne!

Comment ça marche

Pour tout k ≥ 0, puisque | φ ^{- k} / √5 | <1/2, F _k = φ ^k / √5 + φ ^{- k} / √5 = rond (φ ^k / √5). Ainsi, la valeur de retour passe de F _{k - 1} à F _k exactement où k = log _φ ( n ⋅2√5) - 1, ou n = φ ^{k + 1} / (2√5), qui est à 1/4 de F _{k +} 1/2 = ( F _{k - 1} + F _k ) / 2.

05AB1E , 6 octets

nÅFs.x

Essayez-le en ligne!

C (gcc) , 86 85 83 76 octets

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

Essayez-le en ligne!

Java (OpenJDK 8) , 60 57 56 octets

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

Essayez-le en ligne!

-1 octet grâce à @Neil

Python 3 , 103 octets

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

Essayez-le en ligne!

Malheureusement, j'ai dû utiliser un def au lieu de lambda ... Il y a probablement beaucoup de place à l'amélioration ici.

Réponse originale (incorrecte):

Python 3 , 72 octets

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

Essayez-le en ligne!

Ma première soumission PPCG. Au lieu de calculer les nombres de Fibonacci de manière récursive ou de les avoir prédéfinis, ce code utilise la façon dont le nième nombre de Fibonacci est l'entier le plus proche de la nième puissance du nombre d'or divisé par la racine de 5.

Taxi, 2321 octets

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.

Essayez-le en ligne!
Essayez-le en ligne avec des commentaires!

Non golfé avec commentaires:

[ Find the Fibonacci number closest to the input ]
[ Inspired by: /codegolf//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 octets

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)

Essayez-le en ligne!

Cela peut fonctionner, mais ce n'est certainement pas rapide ...

Sorties Trueau lieu de 1, mais en Python, elles sont équivalentes.

dc, 52 octets

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

Essayez-le en ligne!

Prend l'entrée lors de l'exécution en utilisant ?

Modifié pour supposer le haut de la pile comme valeur d'entrée, -1 octet.

L'entrée est stockée dans le registre i. Ensuite, nous mettons 1 et 1 sur la pile pour démarrer la séquence de Fibonacci, et nous générons la séquence jusqu'à ce que nous atteignions une valeur supérieure à i. À ce stade, nous avons deux nombres dans la séquence de Fibonacci sur la pile: un qui est inférieur ou égal à i, et un qui est supérieur à i. Nous les convertissons en leurs différences respectives avec ipuis comparons les différences. Enfin, nous reconstruisons le nombre de Fibonacci en ajoutant ou en soustrayant la différence à i.

Oups, je chargeais deux registres dans le mauvais ordre, puis les échangeais, gaspillant un octet.

C # (.NET Core) , 63 56 octets

-1 octet grâce à @Neil

-6 octets grâce à @Nevay

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

Essayez-le en ligne!

Q / KDB +, 51 octets

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

Hexagonie , 37 octets

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

Essayez-le en ligne!

non golfé:

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

En panne:

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

Comme certaines autres affiches, je me suis rendu compte que lorsque le milieu de dernier et de curr est supérieur à la cible, le plus petit des deux est le plus proche ou à égalité pour le plus proche.

Le point médian est à (last + curr) / 2. Nous pouvons raccourcir cela parce que next est déjà last + curr, et si nous multiplions à la place notre entier cible par 2, nous devons seulement vérifier que (next - 2 * target)> 0, puis retourner en dernier.

Brachylog , 22 octets

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

Essayez-le en ligne!

Vraiment tout ce que j'ai fait ici est de coller ensemble la solution classique de Fatalize Retourner le nombre premier le plus proche et ma propre Suis-je un numéro de Fibonacci? Solution. Heureusement, cette dernière opère déjà sur la variable de sortie; malheureusement, il inclut également une coupure nécessaire qui doit être isolée pour +2 octets, donc le seul point de choix qu'il rejette est de le ⁱlaisser ≜intact.

Japt -g , 8 octets

ò!gM ñaU

Essayez-le

Java 7, 244 234 octets

 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 octets

}~F>R^

Essayez-le en ligne!

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

Lisp commun, 69 octets

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

Essayez-le en ligne!

Perl 6 , 38 octets

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

Essaye-le

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

Pour une accélération potentielle, ajoutez .tail(2)avant .sort(…).

Dans le cas d'une égalité, elle renverra toujours la plus petite des deux valeurs, car il sorts'agit d'un tri stable. (deux valeurs qui trieraient les mêmes gardent leur ordre)

Pyth, 19 octets

JU2VQ=+Js>2J)hoaNQJ

Essayez-le ici

Explication

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 octets

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

Essayez-le en ligne!