Encuentra el número de Fibonacci más cercano

30

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


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 , por lo que gana el código más corto en bytes en cada idioma .

Sr. Xcoder
fuente
Caja de arena .
Sr. Xcoder
FWIW, aquí hay un código Python en SO para hacer esto de manera eficiente para entradas grandes, junto con un script que se puede usar para cronometrar varios algoritmos.
PM 2Ring
¿Se considera 0 como un entero positivo?
Alix Eisenhardt
@AlixEisenhardt No. El número entero positivon implica n ≥ 1.
Sr. Xcoder

Respuestas:

21

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)
xnor
fuente
15

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!

Okx
fuente
¿Cómo son estos 5 bytes cuando hay 2 caracteres allí? ¿Y cuál es la diferencia entre la primera y la segunda solución?
caird coinheringaahing
1
¿Estás contando bytes o caracteres? Parece que el primero es de 15 bytes y el segundo de 7 bytes.
Nateowami
Esto probablemente tiene algún tipo de página de códigos propia en la que cada carácter es un byte propio, lo que significa que el primero tiene 5 bytes y el segundo tiene 3 bytes. La diferencia entre los dos es que el primero selecciona el primer manual de 93 elementos, mientras que el segundo fragmento en una versión más nueva selecciona automáticamente el valor más alto posible que pueden manejar los idiomas int size
Roman Gräf
1
@cairdcoinheringaahing A menudo he tenido problemas con las personas que no pueden ver mis programas. Captura de pantalla
Okx
1
@ Ok Ok, interesante, no lo habría adivinado.
Nateowami
8

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

Giuseppe
fuente
1
Buena esa. -2 bytesF=1:0;n=scan();while(n>F)F=c(F[1]+F[2],F);F[order((F-n)^2)][1]
djhurio
1
Y la versión rápida con el mismo número de bytesF=1:0;n=scan();while(n>F)F=c(sum(F),F[1]);F[order((F-n)^2)][1]
djhurio
1
@djhurio agradable! muchas gracias.
Giuseppe
1
Me gusta esto. -2 bytes nuevamenteF=1:0;while(F<1e8)F=c(F[1]+F[2],F);F[order((F-scan())^2)][1]
djhurio
Usar un incorporado para generar los fibnums es más corto:numbers::fibonacci(x<-scan(),T)
JAD
6

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.

Neil
fuente
Casi idéntico a la versión en la que estaba trabajando. Al menos no usaste los mismos nombres de variables o me habría asustado.
Grax32
@Grax Huh, ahora lo mencionas, Business Cat me ganó ...
Neil
(Bueno, casi ... Hice que mi versión funcionara con 0, porque ¿por qué no?)
Neil
f=(n,x=0,y=1)=>x*(2*n<x+y)||f(n,y,x+y)Como no tiene que trabajar con 0, puede jugar un poco más al golf.
Alix Eisenhardt
6

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]
nmjcman101
fuente
Puedes eliminar µḢ.
Erik the Outgolfer
@EriktheOutgolfer como en: "Hay una manera de hacerlo si lo piensas", o como en "Si literalmente retrocediste, todavía funciona".
nmjcman101
Como en "está permitido por las reglas". : P
Erik the Outgolfer
Ah ¡Gracias! (Texto de relleno)
nmjcman101
5

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!

Cody Gray
fuente
Los listados de NASM son buenos para las respuestas de codegolf, ya que combinan los bytes del código de la máquina con la fuente comentada original de manera algo compacta. Solía nasm foo.asm -l /dev/stdout | cut -b -28,$((28+12))-recortar algunas columnas entre el código de la máquina y la fuente en una respuesta reciente.
Peter Cordes
1
En el código de 32 bits, puede obtener eax = 0 y edx = 1 en solo 4 bytes en lugar de 5, con xor eax,eax/ cdq/ inc edx. Por lo tanto, podría crear una versión de convención de llamada personalizada de 32 bits que guardó un byte.
Peter Cordes
Solía ​​hacer eso, @Peter, pero aquí hay mucha confusión sobre los envíos en "ensamblado" o "código de máquina". Aparentemente, algunos de los usuarios experimentados sostienen que hay una diferencia, y se oponen a que cuente los bytes del código de máquina para obtener una respuesta que se presenta usando mnemónicos de ensamblaje. Naturalmente, creo que esto es estúpido, porque el "ensamblaje" es solo una representación nemotécnica de los bytes de la máquina, pero me votaron. Descubrí que la presentación por separado crea menos fricción, aunque personalmente no me gusta también.
Cody Gray
El otro truco es bueno, gracias. Debería haber pensado en eso, uso cdqmucho en las respuestas de código de golf. No se requiere una convención de llamadas personalizada. Usualmente uso la __fastcallconvención de llamadas de Microsoft para código de 32 bits. Lo bueno de esto es que es compatible con GCC con una anotación, por lo que aún puede usar el servicio TIO que todos quieren ver.
Cody Gray
Ah, sí, cualquier antigua convención de registro funciona para usted. Mi respuesta codegolf más reciente necesitaba punteros en edi/ esiparalodsb / stosb, y solo x86-64 SysV hace eso (hecho divertido: a propósito por esa razón, porque algunas funciones pasan sus argumentos a memset / memcpy, y supongo que a gcc en ese momento le gustó en línea de operaciones de cadena).
Peter Cordes
4

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.

AdmBorkBork
fuente
4

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

Arnauld
fuente
4

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
Gato de negocios
fuente
Esto fue comentado en mi respuesta, pero haría que dejara de funcionar 0(no es que sea necesario; solo quiero que lo haga ):f=(n,i=1,j=1)=>n+n<i+j?i:f(n,j,j+i)
Neil
4

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.

Anders Kaseorg
fuente
Maldición, sabía que algo así tenía que ser posible. ¡Bien hecho! (+1)
SteamyRoot
3

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.

SteamyRoot
fuente
¡Buen trabajo! Bienvenido a PPCG :)
musicman523
Para calcular de manera justa el recuento de bytes de su código, creo que necesita asignar la lambda, como se muestra en las otras respuestas de Python. Sin embargo, este algoritmo no siempre funciona correctamente para n en el rango (1, 1 + 10 ** 8). Por ejemplo, n = 70 devuelve 89, pero debería devolver 55. Aquí están los n valores <120 para los que da respuestas incorrectas: (27, 44, 70, 71, 114, 115, 116). Para fines de prueba, es posible que desee utilizar la nearest_fib_PM2Rfunción que vinculé en mi comentario sobre la pregunta.
PM 2Ring
@ PM2Ring Tienes razón, cometí un error estúpido ... Ahora tengo una solución correcta, pero con muchos más bytes. En cuanto a la lambda, creo que te equivocas. Creo que las respuestas que asignan lambda solo lo hacen porque usan la recursividad. Las otras respuestas de Python 3 no asignan la primera lambda, por ejemplo.
SteamyRoot
3

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.
Tostadas de ingeniero
fuente
2

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.

notjagan
fuente
2

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.

brhfl
fuente
Se permiten funciones.
CalculatorFeline
Gracias, repetidamente me perdí eso en el texto del desafío.
brhfl
2

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!

jkelm
fuente
¿ for(;b<n;a=b,b+=c)c=a;Guardar un byte?
Neil
Puede eliminar cmediante el uso b+=a,a=b-a(debe guardar 6 bytes).
Nevay
2

Q / KDB +, 51 bytes

{w where l=min l:abs neg[x]+w:{x,sum -2#x}/[x;0 1]}
aodNap
fuente
2
Bienvenido a PPCG!
Martin Ender
2

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.

Brigmor
fuente
2

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.

Cadena no relacionada
fuente
1

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);}
0x45
fuente
¿Por qué no usas Java 8 y conviertes esto en una lambda? También puede eliminar staticsi desea seguir con Java 7.
Okx
Tiene dos errores en su código ( r>c&&s<cdebería ser r>=c&&s<=c, s-cdebería ser c-s), podría eliminar espacios en blanco no necesarios, usar int f(int i){return i<2?i:f(--i)+f(--i);}, usar una sola declaración de retorno con operador ternario en c y eliminar el manejo especial c-s==r-cya que se permite devolver cualquier valor.
Nevay
@Nevay No veo el error, lo probé sin
fallas
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)
Azul
fuente
1

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)

Brad Gilbert b2gills
fuente
1

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.

fuente