Введение

Мы все знаем и любим нашу последовательность Фибоначчи и уже видели множество испытаний здесь. Тем не менее, нам все еще не хватает очень простого случая, который даст этот ответ: обратные фибоначчи! Так что учитывая F_nвашу работу, чтобы найти n.

Спецификация

вход

Ваш ввод будет неотрицательным целым числом, которое гарантированно будет частью последовательности Фибоначчи.

Выход

Вывод также должен быть неотрицательным целым числом.

Что делать?

Во введении уже сказано: учитывая число Фибоначчи, выведите его индекс. Число Fiboancci при этом определяется как F(0)=0, F(1)=1, F(n)=F(n-1)+F(n-2)и вы даны F(n)и должны вернуться n.

Потенциальные Угловые Случаи

0 является действительным входом и выходом.
Если в качестве входных данных указано «1», вы можете вывести «1» или «2», как вам больше нравится.
Вы всегда можете предположить, что ваши данные на самом деле являются числом Фибоначчи.
Вы можете предположить, что входные данные представлены в виде 32-разрядного целого числа со знаком.

Кто выигрывает?

Это код-гольф, поэтому выигрывает самый короткий ответ в байтах!
Стандартные правила применяются конечно.

Тест-кейсы

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

На самом деле, 1 байт

f

Да, для этого есть встроенная функция с 16 ноября 2015 года .

Попробуйте онлайн

Для забавы, без встроенного, это 9 байтов:

╗1`F╜=`╓i

Попробуйте онлайн!

Объяснение:

╗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 байтов

InverseFunction@Fibonacci

Функция. Довольно очевидно, если вы спросите меня.

Python, 36 34 32 байта

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

Предыдущие версии:

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

объяснение

Основная идея состоит в том, чтобы инвертировать формулу

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

что говорит нам о том, что

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

получить

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

Оптимизация игры в гольф:

• Используется len(str(n))для вычисления базы 10 журналов без импорта log(старая версия использовалась .bit_length()для расчета базы 2 журналов)
• Поднимите nв степень, чтобы в приближении логарифма можно было различать последовательные числа Фибоначчи
• Умножение на константу увеличивает значения, чтобы получить их в правильном диапазоне

Затем делитель был усечен до минимальной точности, и я смог выбрать множитель, чтобы получить правильные результаты для всех 32-битных чисел Фибоначчи.

05AB1E , 3 байта

Код:

ÅFg

Объяснение:

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

Использует кодировку CP-1252 . Попробуйте онлайн! ,

Желе, 14 11 байт

5½×lØp+.Ḟ»0

Попробуйте онлайн!

Это мой первый желейный ответ! Это использует алгоритм из ответа MATL . Спасибо Деннису за то, что он сбрил 3 байта!

Объяснение:

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

Это дает правильный ответ, теперь нам просто нужно обработать специальный случай «0». С '0' в качестве аргумента мы получаем -infinity, поэтому мы возвращаем

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

Юлия, 27 26 18 байт

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

При этом используется обратная формула Бине , с достаточной точностью для 32-битных целых чисел; фактически он работает до F (153) = 42 230 309 526 998 466 217 810 220 532 898> 2 ¹⁰⁵ .

Попробуйте онлайн!

Как это работает

Формула Бине гласит следующее.

Ограничение F на множестве Фибоначчи, отображение N → F _п имеет право обратного F → N _F .

У нас есть это

и все, что осталось сделать, это иметь дело с краевым случаем 0 .

Поскольку ввод ограничен 32-разрядными целыми числами, мы можем использовать короткие десятичные литералы вместо констант в формуле.

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

  К сожалению, 0.5 недостаточно точен.

• √5 = 2,2360679774997896964… ≈ 3

  На первый взгляд это может показаться ужасным приближением, но мы берем логарифмы и, поскольку log 3 - log √5 = 0,29389333245105… , результат до округления будет отключен с помощью небольшого постоянного коэффициента.

• 0,5 ≈ 0,7

  Из-за превышения предыдущего приближения мы могли бы вообще опустить этот термин и все же получить правильные результаты для F> 0 . Однако, если F = 0 , логарифм будет неопределенным. 0,7 оказалось самым коротким значением, которое расширяет нашу формулу до F = 0 .

JavaScript, 54 50 69 50 42 байта

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

Конечно, это не победит, просто для удовольствия :)

Хорошо, проверка на ноль потребляет 19 байтов. WTF? Глупый я.

Демо! Чтобы увидеть последний контрольный пример, нужно немного прокрутить консоль.

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

Спасибо @edc за сокращение на 8 байтов.

Perl 6  33 30  27 байт

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

Попытайся

Объяснение:

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

Тест:

#! /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

Желе , 8 байт

1+С0
¢i

Попробуйте онлайн! Обратите внимание, что этот подход слишком неэффективен для последнего контрольного примера.

Как это работает

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

Пайк, 5 байт

.f.bq

Попробуй это здесь!

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

Python, 29 байт

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

Рекурсивно делит входные данные на приближение золотого сечения 1,61, пока оно не станет ниже 0,7, и выводит число делений.

Для 0 выводится код False, который равен 0 в Python . Этого можно избежать на 2 байта

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

JavaScript (ES6), 39 33 байта

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

Даже с ES7 обратная формула Бине занимает 47 байтов:

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

Sage, 49 байтов

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

Благодаря TuukkaX за предложение о сохранении в sqrt(5)качестве sсбрить несколько байт.

Попробуйте онлайн .

Этот подход, использующий обратную формулу Бине, предлагает несколько улучшений по сравнению с предыдущим подходом: он быстрее (постоянное время по сравнению с квадратичным), он действительно работает для больших входов и короче!

Пользователи Python могут задаться вопросом, почему я использую sqrt(5)вместо более коротких 5**.5- это потому, что 5**.5вычисляется с помощью powфункции C и теряет точность из-за проблем с плавающей запятой. Многие математические функции (включая sqrtи log) перегружены в Sage, чтобы вернуть точное символическое значение, которое не теряет точности.

MATL , 14 байтов

t?5X^*17L&YlYo

Попробуйте онлайн!

Это использует обратную формулу Бине , и поэтому это очень быстро.

Пусть F обозначает n-е число Фибоначчи, а φ - золотое сечение . затем

Код использует эту формулу с двумя модификациями:

• Вместо добавления 1/2, а затем округления, код просто округляется до ближайшего целого числа, которое занимает меньше байтов.
• Вход F = 0 должен рассматриваться как особый случай.

Как это сделано

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 байт

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

Проверьте это на Ideone .

JavaScript, 22 байта

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

C 62 58 байт

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

Детальнее

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 байт

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 байта

Ввод идет @nкак вDECLARE @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 байт

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

Sesos , 28 байт

HexDump:

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

Попробуйте онлайн!

(Экспоненциальное время, потому что при копировании числа в Sesos требуется экспоненциальное время.)

Сборка используется для генерации двоичного файла:

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 байт

То же, что и @dainichi, ответ сокращается только при использовании лямбд Java 8. Ответ является допустимым выражением.

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

Pyth, 13 байт

J1tf>=Z+~JZZQ

Тестирование.

Приближение в 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)

альтернативный подход, 18 байт

L?<b2bsyMtBtbs.IyG

Тестирование.

Это использует .Iдля обратного.

Java 7, 89 байт

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

Вдохновлен объяснением ответа @Adnan 's 05AB1E .

Ungolfed и тестовые случаи:

Попробуй это здесь. (Превышено ограничение по времени для последнего контрольного примера, но на моем компьютере оно работает примерно через 30-45 секунд.)

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

Выход:

0
3
4
5
6
46

Perl 5,10, 48 байт

В основном искал именно nтак F(n) = input.

-a Переключатель добавляет один байт.

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

Попробуй это здесь!

J, 32 27 17 байт

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

Вычисляет первые n чисел Фибоначчи, а затем находит индекс n в этом списке.

использование

Дополнительные команды используются для форматирования нескольких входов / выходов. Последний тестовый пример опущен, так как он потребует гораздо больше времени для вычислений.

   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

объяснение

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 байт

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

Чистая функция; возвращает 2, если вход 1.

Не превосходит другую запись Mathematica, но демонстрирует необычный метод: это (очень крутой) факт, что N-е число Фибоначчи является ближайшим целым числом к ​​[1 / sqrt (5) раз N-й степени золотого сечения] (" Формула Бине ").

Следовательно, обратная функция будет логарифмом по основанию [золотое сечение] [sqrt (5) раз умноженного на число Фибоначчи]. .8+Хак , чтобы убедиться , что мы не берем логарифм 0, не щуря другие значения.

Japt , 10 байт

Lo æ@U¥MgX

Попробуйте онлайн!

объяснение

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

Брахилог , 14 байт

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

Попробуйте онлайн!

Принимает ввод через выходную переменную и выводит через входную переменную.

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

Я не совсем уверен, зачем ≜это нужно.

Javascript (с использованием внешней библиотеки) (84 байта)

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

Ссылка на lib: https://github.com/mvegh1/Enumerable

Объяснение кода: в библиотеке есть статический метод, который создает последовательность, пока предикат не получит неопределенное возвращаемое значение. Предикат имеет сигнатуру ("i" ndex, текущий внутренний сгенерированный "a"). На каждой итерации мы проверяем, равен ли последний элемент внутреннего массива входу n. Если нет, верните следующее значение в последовательности fib. В противном случае предикат имеет неопределенный результат, который завершает генерацию последовательности. Затем мы возвращаем длину последовательности (и вычитаем 1, чтобы соответствовать нулю на основе 0, как видно из OP