Introdução

Todos nós conhecemos e amamos nossa sequência de Fibonacci e já vimos uma infinidade de desafios aqui. No entanto, ainda não temos um caso muito simples que esta resposta forneça: Fibonacci invertido! Então, dado o F_nseu trabalho é encontrar n.

Especificação

Entrada

Sua entrada será um número inteiro não negativo, que é garantido como parte da sequência de fibonacci.

Saída

A saída também deve ser um número inteiro não negativo.

O que fazer?

A introdução já dizia: Dado um número de fibonacci, produza seu índice. O número de Fiboancci é definido como F(0)=0, F(1)=1, F(n)=F(n-1)+F(n-2)e você recebe F(n)e deve retornar n.

Casos de canto em potencial

0 é uma entrada e saída válida.
Se for fornecido "1" como entrada, você poderá enviar "1" ou "2", como preferir.
Você sempre pode assumir que sua entrada é realmente um número de fibonacci.
Você pode assumir que a entrada é representável como um número inteiro assinado de 32 bits.

Quem ganha?

Isso é código-golfe, então a resposta mais curta em bytes vence!
Regras padrão se aplicam, é claro.

Casos de teste

0 -> 0
2 -> 3
3 -> 4
5 -> 5
8 -> 6
13 -> 7
1836311903 -> 46

Na verdade, 1 byte

f

Sim, existe um construído para isso, desde 16 de novembro de 2015 .

Experimente online

Por diversão, sem o builtin, são 9 bytes:

╗1`F╜=`╓i

Experimente online!

Explicação:

╗1`F╜=`╓i
╗          push input to register 0
 1`F╜=`╓   push list containing first value x (starting with x = 0) where:
   F         fib(x)
    ╜=       is equal to the input
        i  flatten the list

Mathematica, 25 bytes

InverseFunction@Fibonacci

Função. Bastante auto-explicativo, se você me perguntar.

Python, 36 34 32 bytes

lambda n:len(str(66*n**6))//1.24

Versões prévias:

f=lambda n:len(str(66*n**6))//1.24
f=lambda n:(n*n*7).bit_length()//1.4

Explicação

A idéia central é inverter a fórmula

fibonacci(n) ~ ( (1 + sqrt(5)) / 2)**n / sqrt(5)

o que nos diz que

log fibonacci(n) ~ n log((1 + sqrt(5)) / 2) - log(sqrt(5))

para obter

f(n) ~ (log(n) + log(sqrt(5))) / log((1 + sqrt(5))/2)

As otimizações de golfe são:

• Use len(str(n))para calcular a base de log 10 sem importar log(versão antiga usada .bit_length()para calcular a base de log 2)
• Levantar n a um poder, para que a aproximação do logaritmo possa distinguir entre números sucessivos de Fibonacci
• A multiplicação por uma constante aumenta os valores para colocá-los no intervalo correto

Em seguida, o divisor foi truncado com a menor precisão possível e o multiplicador escolhido para fornecer os resultados corretos para todos os números de fibonacci de 32 bits.

05AB1E , 3 bytes

Código:

ÅFg

Explicação:

ÅF   # Generate all Fibonacci numbers <= input.
  g  # Get the length of this list.

Usa a codificação CP-1252 . Experimente online! .

Geléia, 14 11 bytes

5½×lØp+.Ḟ»0

Experimente online!

Esta é a minha primeira resposta Jelly! Isso usa o algoritmo da resposta MATL . Agradecimentos a Dennis por eliminar 3 bytes!

Explicação:

   lØp      # Log Base phi
5½          # Of the square root of 5
  ×         # Times the input
      +     # Plus
       .    # 0.5
        Ḟ   # Floored

Esta é a resposta certa, agora só precisamos lidar com o caso especial de '0'. Com '0' como argumento, obtemos -infinity, então retornamos

»      # The maximum of 
 0     # Zero
       # And the previous calculated value.

Julia, 27 26 18 bytes

!n=log(3n+.7)÷.48

Isso usa o inverso da fórmula de Binet , com precisão suficiente para números inteiros de 32 bits; na verdade, funciona até F (153) = 42.230.279.526.998.466.217.810.220.532.898> 2 ¹⁰⁵ .

Experimente online!

Como funciona

A fórmula de Binet afirma o seguinte.

Restringindo F ao conjunto de Fibonacci, o mapa n → F _n tem um inverso direito F → n _F .

Nós temos isso

e tudo o que resta a fazer é lidar com o caso 0 .

Como a entrada é restrita a números inteiros de 32 bits, podemos usar literais decimais curtos em vez das constantes na fórmula.

• log φ = 0,481211825059603447… ≈ 0,48

  Infelizmente, 0,5 não é suficientemente preciso.

• √5 = 2,2360679774997896964… ≈ 3

  Pode parecer uma aproximação terrível à primeira vista, mas estamos usando logaritmos e, como log 3 - log √5 = 0,29389333245105… , o resultado antes do arredondamento será desativado por um pequeno fator constante.

• 0,5 ± 0,7

  Devido ao excesso da aproximação anterior, poderíamos realmente omitir esse termo completamente e ainda assim obter resultados corretos para F> 0 . No entanto, se F = 0 , o logaritmo será indefinido. 0,7 acabou sendo o menor valor que estende nossa fórmula para F = 0 .

JavaScript, 54 50 69 50 42 bytes

b=>(j=>{for(i=c=0;b-i;c++)i=j+(j=i)})(1)|c

Certamente não vai ganhar, apenas por diversão :)

Ok, verificar zero consome 19 bytes. WTF? Estúpido-eu.

Demo! Para ver o último caso de teste, você precisa rolar um pouco o console.

a=b=>(j=>{for(i=c=0;b-i;c++)i=j+(j=i)})(1)|c;
console.log('0: '+a(0));
console.log('2: '+a(2));
console.log('3: '+a(3));
console.log('5: '+a(5));
console.log('8: '+a(8));
console.log('13: '+a(13));
console.log('1836311903: '+a(1836311903));

Obrigado @edc pela redução de 8 bytes.

Perl 6  33 30  27 bytes

{first *==$_,:k,(0,1,*+*...*>$_)}
{first *==$_,:k,(0,1,*+*...*)}
{first $_,:k,(0,1,*+*...*)}

Tente

Explicação:

# lambda with implicit ｢$_｣ parameter
{
  first           # find the first element
    $_,           # where something is equal to the block's argument
    :k,           # return the key rather than the value

    # of the Fibonacci sequence
    ( 0, 1, * + * ... * )
    # ^--^ first two values
    #       ^---^ lambda used to generate the next in the series
    #             ^-^ generate until
    #                 ^ Whatever
}

Teste:

#! /usr/bin/env perl6
use v6.c;
use Test;

# using the safer version that stops generating
# values bigger than the input
my &fib-index = {first $_,:k,(0,1,*+*...*>$_)}

my @tests = (
  0 => 0,
  2 => 3,
  3 => 4,
  5 => 5,
  8 => 6,
  13 => 7,
  1836311903 => 46,
  1836311904 => Nil, # this is why the safe version is used here
  12200160415121876738 => 93,
  19740274219868223167 => 94,
  354224848179261915075 => 100,
);

plan +@tests + 1;

for @tests -> $_ ( :key($input), :value($expected) ) {
  cmp-ok fib-index($input), &[eqv], $expected, .gist
}

cmp-ok fib-index((0,1,*+*...*)[1000]), &[eqv], 1000, 'works up to 1000th element of Fibonacci sequence'

1..13
ok 1 - 0 => 0
ok 2 - 2 => 3
ok 3 - 3 => 4
ok 4 - 5 => 5
ok 5 - 8 => 6
ok 6 - 13 => 7
ok 7 - 1836311903 => 46
ok 8 - 1836311904 => Nil
ok 9 - 12200160415121876738 => 93
ok 10 - 19740274219868223167 => 94
ok 11 - 354224848179261915075 => 100
ok 12 - works up to 1000th element of Fibonacci sequence

Geléia , 8 bytes

1+С0
¢i

Experimente online! Observe que essa abordagem é muito ineficiente para o último caso de teste.

Como funciona

¢i     Main link. Argument: n

¢      Call the helper link niladically (i.e., without arguments).
       This yields the sequence of the first n positive Fibonacci numbers, i.e.,
       [1, 1, 2, 3, 5, ...].
 i     Find the first index of n (1-based, 0 if not found).


1+С0  Helper link. No arguments.

1      Set the left argument to 1.
    0  Yield 0.
 +С   Add both arguments, replacing the left argument with the sum and the right
       argument with the previous value of the left argument.
       Yield the array of all intermediate values of the left argument.

Pyke, 5 bytes

.f.bq

Experimente aqui!

.f    - first number where
  .b  -  fib(n)
    q - ^ == input

Python, 29 bytes

g=lambda n:n>.7and-~g(n/1.61)

Divide recursivamente a entrada pela proporção áurea 1,61 até ficar abaixo de 0,7 e gera o número de divisões.

Para 0, o código gera False, igual a 0 em Python . Isso pode ser evitado por 2 bytes

g=lambda n:n//.7and 1+g(n/1.61)

JavaScript (ES6), 39 33 bytes

f=(n,j=0,k=1)=>n>j?f(n,k,j+k)+1:0

Mesmo com o ES7, a fórmula inversa do Binet leva 47 bytes:

x=>Math.log(x*5**.5)/Math.log(.5+1.25**.5)+.5|0
x=>Math.log(x*5**.5)/Math.log((1+5**.5)/2)+.5|0
x=>Math.log(x*(p=5**.5))/Math.log((1+p)/2)+.5|0

Sábio, 49 bytes

lambda x,s=sqrt(5):x and int(log(x*s,(1+s)/2)+.5)

Agradecemos a TuukkaX pela sugestão sobre sqrt(5)como economizar salguns bytes.

Experimente online .

Essa abordagem usando uma inversa da fórmula de Binet oferece várias melhorias em relação à abordagem anterior: é mais rápida (tempo constante versus tempo quadrático), na verdade funciona para entradas maiores e é mais curta!

Os usuários de Python podem se perguntar por que estou usando, e sqrt(5)não o menor 5**.5- é porque 5**.5é calculado com a powfunção de C e perde precisão devido a problemas de ponto flutuante. Muitas funções matemáticas (incluindo sqrte log) são sobrecarregadas no Sage para retornar um valor simbólico exato, que não perde precisão.

MATL , 14 bytes

t?5X^*17L&YlYo

Experimente online!

Isso usa uma inversa da fórmula de Binet e, portanto, é muito rápido.

Seja F denotado o n- ésimo número de Fibonacci e φ a proporção áurea . Então

O código usa essa fórmula com duas modificações:

• Em vez de adicionar 1/2 e arredondar para baixo, o código simplesmente arredonda para o número inteiro mais próximo, que ocupa menos bytes.
• A entrada F = 0 precisa ser tratada como um caso especial.

Como isso é feito

t         % Take input F implicitly. Make a copy
?         % If (copy of) F is positive
  5X^     %   Push sqrt(5)
  *       %   Multiply by F
  17L     %   Push phi (predefined literal)
  &Yl     %   Two-input logarithm: first input is argument, second is base
  Yo      %   Round towards nearest integer
          % Else the input, which is 0, is left on the stack
          % End if implicitly
          % Display implicitly

Python, 38 bytes

f=lambda n,a=0,b=1:n^a and-~f(n,b,a+b)

Teste em Ideone .

JavaScript, 22 bytes

n=>Math.log(n)/.48+2|0

C, 62 58 bytes

g(c,a,b){return c-a?g(c,b,a+b)+1:0;}f(c){return g(c,0,1);}

Detalhado

int g(int c, int a, int b)
{
    if (c == a)
    {
        return 0;
    }
    else
    {
        return g(c, b, a+b) + 1;
    }
}

int f(c)
{
    return g(c, 0, 1);
}

Java 7, 70 bytes

int c(int n){int a=0,b=1,c=0,t;while(a<n){c++;t=b;b+=a;a=t;}return c;}

https://ideone.com/I4rUC5

TSQL, 143 bytes

A entrada entra @ncomo emDECLARE @n INT = 1836311903;

DECLARE @O BIGINT=0;WITH F(R,P,N)AS(SELECT @O,@O,@O+1 UNION ALL SELECT R+1,N,P+N FROM F WHERE N<=@n)SELECT MAX(R)FROM F OPTION(MAXRECURSION 0);

Haskell, 45 bytes

f x=round$log(sqrt 5*x+0.9)/log((sqrt 5+1)/2)

Sesos , 28 bytes

Hexdump:

0000000: 16f8be 766ef7 ae6d80 f90bde b563f0 7ded18 3ceffa  ...vn..m.....c.}..<..
0000015: b1c1bb af9f3f ff                                  .....?.

Experimente online!

(Tempo exponencial porque, no Sesos, a cópia de um número precisa de tempo exponencial.)

Assembly usado para gerar o arquivo binário:

set numin
set numout
get
jmp
sub 1
fwd 1
add 1
fwd 1
add 1
rwd 2
jnz    ;input input
fwd 4
add 1  ;input input 0 1
fwd 2
add 1  ;input input 0 1 0 1
rwd 4
jmp
jmp    ;input input-curr curr next iterations
sub 1
jnz    ;input 0 curr next iterations
fwd 3
add 1
jmp
sub 1
fwd 2
add 1
rwd 2
jnz    ;input 0 curr next 0 0 iterations+1
rwd 1
jmp
sub 1
fwd 1
add 1
fwd 1
add 1
rwd 2
jnz    ;input 0 curr 0 next next iterations+1
rwd 1
jmp
sub 1
fwd 1
sub 1
fwd 2
add 1
rwd 3
jnz    ;input 0 0 -curr next curr+next iterations+1
rwd 2
jmp
sub 1
fwd 2
add 1
fwd 1
add 1
rwd 3
jnz    ;0 0 input input-curr next curr+next iterations+1
fwd 3
jnz
fwd 3
put

Java 8 61 bytes

O mesmo que a resposta @dainichi foi reduzida, usando o Java 8 lambdas. A resposta é uma expressão válida de rvalue.

n->{int a=0,b=1,c=0,t;while(a<n){c++;t=b;b+=a;a=t;}return c;}

Ungolfed:

interface F
{
    int c(int n);
}

public class Main
{

    public static void main(String[] args)
    {
        F f = n->{int a=0,b=1,c=0,t;while(a<n){c++;t=b;b+=a;a=t;}return c;};
    }
}

Pitão, 13 bytes

J1tf>=Z+~JZZQ

Suíte de teste.

Aproximação em Python 2:

Z=0;J=1;T=1;Q=input()
while not J+Z>Q:
    temp=J
    J=Z
    Z=temp+J
    T += 1
print(T-1)

abordagem alternativa, 18 bytes

L?<b2bsyMtBtbs.IyG

Suíte de teste.

Isso usa .Ipara inverso.

Java 7, 89 bytes

int c(int n){int i=-1;while(f(++i)<n);return i;}int f(int n){return n<2?n:f(n-1)+f(n-2);}

Inspirado pela explicação da @Adnan resposta 05AB1E 's .

Casos não testados e de teste:

Experimente aqui. (O limite de tempo foi excedido para o último caso de teste, mas funciona em cerca de 30 a 45 segundos no meu PC.)

class Main{
  static int c(int n){
    int i = -1;
    while(f(++i) < n);
    return i;
  }

  static int f(int n){
    return n < 2
             ? n
             : f(n - 1) + f(n - 2);
  }

  public static void main(String[] a){
    System.out.println(c(0));
    System.out.println(c(2));
    System.out.println(c(3));
    System.out.println(c(5));
    System.out.println(c(8));
    System.out.println(c(1836311903));
  }
}

Saída:

0
3
4
5
6
46

Perl 5.10, 48 bytes

Basicamente, procurando o certo npara isso F(n) = input.

-a switch adiciona um byte.

$b++;while($_>$a){$c=$a;$a+=$b;$b=$c;$n++}say$n

Experimente aqui!

J, 32 27 17 bytes

i.~0,+/@(!|.)\@i.

Calcula os primeiros n números de Fibonacci e localiza o índice de n nessa lista.

Uso

Comandos extras são usados ​​para formatar várias entradas / saídas. O último caso de teste é omitido, pois exigirá muito mais tempo para calcular.

   f =: i.~0,+/@(!|.)\@i.
   (,.f"0) 0 1 2 3 5 8 13
 0 0
 1 1
 2 3
 3 4
 5 5
 8 6
13 7

Explicação

i.~0,+/@(!|.)\@i.  Input: n
               i.  Get the range [0, 1, ..., n-1]
             \@    For each prefix of that range
          |.         Reverse the prefix
         !           Find the binomial coefficient between each value in the original
                     prefix and the reversed prefix
     +/@             Sum those binomial coefficients
                   This will create the Fibonacci numbers from 1 to n
   0,              Prepend a 0 to the list of Fibonacci numbers
i.~                Find the index of n in that list and return

Mathematica, 30 bytes

Round@Log[5^.5/2+.5,.8+5^.5#]&

Função pura; retorna 2 se a entrada for 1.

Não supera a outra entrada do Mathematica, mas mostra um método incomum: é um fato (muito legal) que o número N-ésimo de Fibonacci seja o número inteiro mais próximo de [1 / sqrt (5) vezes a N-ésima potência da proporção áurea] (" Fórmula de Binet ").

Portanto, a função inversa será o logaritmo base- [proporção áurea] de [sqrt (5) vezes o número de Fibonacci em questão]. O .8+é um truque para garantir que não aceitemos o logaritmo de 0, sem estragar os outros valores.

Japonês , 10 bytes

Lo æ@U¥MgX

Experimente online!

Explicação

Lo æ@U¥MgX
Lo           // Creates a range from 0 to 99
   æ@        // Iterates through the range. Returns the first item X where:
     U¥      //   Input ==
       MgX   //   Xth Fibonacci number

Braquilog , 14 bytes

≜∧0;1⟨t≡+⟩ⁱ↖?h

Experimente online!

Leva a entrada através da variável de saída e sai através da variável de entrada.

≜                 Label the input variable, trying 0, 1, -1, 2...,
  0               then starting with 0
 ∧                (which is not necessarily the input variable)
   ;1             paired with 1,
     ⟨t≡ ⟩        replace the first element of the pair with the last element
     ⟨ ≡+⟩        and the last element of the pair with the sum of the elements
          ⁱ↖?     a number of times equal to the input variable,
             h    such that the first element of the pair is the output variable.

Não sei ao certo por que ≜é necessário.

Javascript (usando biblioteca externa) (84 bytes)

n=>_.Until((i,a)=>{l=a.length;if(a[l-1]!=n){return i<=1?i:a[l-1]+a[l-2]}}).Count()-1

Link para lib: https://github.com/mvegh1/Enumerable

Explicação do código: A biblioteca possui um método estático que cria uma sequência até o predicado ter um valor de retorno indefinido. O predicado possui uma assinatura de ("i" ndex, corrente interna "a" gerada). A cada iteração, verificamos se o último elemento da matriz interna é igual à entrada, n. Caso contrário, retorne o próximo valor na sequência fib. Caso contrário, o predicado terá um resultado indefinido que encerra a geração da sequência. Em seguida, retornamos o comprimento da sequência (e subtraímos 1 para cumprir com a base 0, como visto no OP