Giới thiệu

Tất cả chúng ta đều biết và yêu thích chuỗi Fibonacci của chúng tôi và đã thấy vô số thách thức về nó ở đây. Tuy nhiên, chúng tôi vẫn còn thiếu một trường hợp rất đơn giản mà câu trả lời này sẽ cung cấp: Reversed Dailymotion! Vì vậy, F_ncông việc của bạn là tìm kiếm n.

Đặc điểm kỹ thuật

Đầu vào

Đầu vào của bạn sẽ là một số nguyên không âm, được đảm bảo là một phần của chuỗi Wikipedia.

Đầu ra

Đầu ra phải là một số nguyên không âm.

Phải làm sao

Giới thiệu đã nói: Đưa ra một số Wikipedia, xuất chỉ mục của nó. Số Fiboancci theo đây được xác định là F(0)=0, F(1)=1, F(n)=F(n-1)+F(n-2)và bạn đã cho F(n)và phải trả lại n.

Trường hợp góc tiềm năng

0 là một đầu vào và đầu ra hợp lệ.
Nếu được đưa ra "1" làm đầu vào, bạn có thể xuất "1" hoặc "2", tùy thích.
Bạn luôn có thể cho rằng đầu vào của bạn thực sự là một số Wikipedia.
Bạn có thể giả sử rằng đầu vào có thể biểu diễn dưới dạng số nguyên có chữ ký 32 bit.

Ai thắng?

Đây là môn đánh gôn, vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng!
Quy tắc tiêu chuẩn áp dụng tất nhiên.

Các trường hợp thử nghiệm

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

Trên thực tế, 1 byte

f

Vâng, có một nội dung cho việc này, kể từ ngày 16 tháng 11 năm 2015 .

Dùng thử trực tuyến

Để giải trí, không có nội dung, đó là 9 byte:

╗1`F╜=`╓i

Hãy thử trực tuyến!

Giải trình:

╗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

Toán học, 25 byte

InverseFunction@Fibonacci

Chức năng. Khá tự giải thích nếu bạn hỏi tôi.

Python, 36 34 32 byte

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

Những phiên bản trước:

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

Giải trình

Ý tưởng cốt lõi là đảo ngược công thức

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

cho chúng ta biết rằng

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

để có được

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

Các tối ưu hóa golf là:

• Sử dụng len(str(n))để tính toán cơ sở nhật ký 10 mà không cần nhập log(phiên bản cũ được sử dụng .bit_length()để tính toán cơ sở nhật ký 2)
• Nâng nlên một sức mạnh, để sự gần đúng của logarit có thể phân biệt giữa các số Fibonacci liên tiếp
• Nhân với một hằng số chia tỷ lệ các giá trị để đưa chúng vào phạm vi chính xác

Sau đó, số chia được cắt bớt với độ chính xác nhỏ nhất mà tôi có thể quản lý và hệ số nhân được chọn để đưa ra kết quả chính xác cho tất cả các số Wikipedia 32 bit.

05AB1E , 3 byte

Mã số:

ÅFg

Giải trình:

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

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến! .

Thạch, 14 11 byte

5½×lØp+.Ḟ»0

Hãy thử trực tuyến!

Đây là câu trả lời Jelly đầu tiên của tôi! Điều này sử dụng thuật toán từ câu trả lời MATL . Cảm ơn Dennis vì đã cạo sạch 3 byte!

Giải trình:

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

Điều này nhận được câu trả lời đúng, bây giờ chúng ta chỉ cần xử lý trường hợp đặc biệt là '0'. Với '0' là một đối số, chúng tôi nhận được -infinity, vì vậy chúng tôi quay lại

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

Julia, 27 26 18 byte

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

Điều này sử dụng công thức nghịch đảo của Binet , với độ chính xác vừa đủ cho các số nguyên 32 bit; nó thực sự hoạt động lên đến F (153) = 42,230,279,526,998,466,217,810,220,532,898> 2 ¹⁰⁵ .

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Công thức của Binet nêu rõ như sau.

Hạn chế F với tập hợp các Fibonacci, bản đồ n → F _n có đúng ngược F → n _F .

Chúng tôi có điều đó

và tất cả những gì còn lại phải làm là xử lý trường hợp cạnh 0 .

Do đầu vào bị giới hạn ở số nguyên 32 bit, chúng tôi có thể sử dụng các chữ số thập phân ngắn thay vì các hằng số trong công thức.

• log = 0,481211825059603447… 0,48

  Thật không may, 0,5 không đủ chính xác.

• 5 = 2.2360679774997896964… 3

  Thoạt nhìn có vẻ như là một xấp xỉ khủng khiếp, nhưng chúng tôi đang sử dụng logarit và vì log 3 - log √5 = 0,29389333245105 , kết quả trước khi làm tròn sẽ bị tắt bởi một yếu tố không đổi nhỏ.

• 0,5 ≈ 0,7

  Do vượt quá so với xấp xỉ trước đó, chúng tôi thực sự có thể bỏ qua thuật ngữ này hoàn toàn và vẫn nhận được kết quả chính xác cho F> 0 . Tuy nhiên, nếu F = 0 , logarit sẽ không được xác định. 0,7 hóa ra là giá trị ngắn nhất mở rộng công thức của chúng tôi thành F = 0 .

JavaScript, 54 50 69 50 42 byte

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

Chắc chắn nó sẽ không chiến thắng, chỉ để cho vui thôi :)

Ok, kiểm tra không tiêu thụ 19 byte. WTF? Ngốc-tôi.

Bản giới thiệu! Để xem trường hợp thử nghiệm cuối cùng, bạn phải cuộn bàn điều khiển một chút.

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

Cảm ơn @edc đã rút ngắn 8 byte.

Perl 6  33 30  27 byte

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

Thử nó

Giải trình:

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

Kiểm tra:

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

Thạch , 8 byte

1+С0
¢i

Hãy thử trực tuyến! Lưu ý rằng phương pháp này quá kém hiệu quả cho trường hợp thử nghiệm cuối cùng.

Làm thế nào nó hoạt động

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

.f.bq

Hãy thử nó ở đây!

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

Python, 29 byte

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

Chia đệ quy đầu vào theo xấp xỉ tỷ lệ vàng 1,61 cho đến khi dưới 0,7 và đưa ra số lần chia.

Đối với 0, các đầu ra mã False, bằng 0 trong Python . Điều này có thể tránh được cho 2 byte

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

JavaScript (ES6), 39 33 byte

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

Ngay cả với ES7, công thức Binet nghịch đảo chiếm 47 byte:

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

Hiền nhân, 49 byte

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

Cảm ơn TuukkaX vì đã gợi ý về cách lưu sqrt(5)như sđể loại bỏ một vài byte.

Hãy thử trực tuyến .

Cách tiếp cận này sử dụng công thức nghịch đảo của Binet cung cấp một số cải tiến so với cách tiếp cận trước đó: nó nhanh hơn (thời gian không đổi so với thời gian bậc hai), nó thực sự hoạt động cho đầu vào lớn hơn và ngắn hơn!

Người dùng Python có thể tự hỏi tại sao tôi sử dụng sqrt(5)thay vì ngắn hơn 5**.5- đó là vì 5**.5được tính toán với powchức năng của C và mất độ chính xác do các vấn đề về dấu phẩy động. Nhiều hàm toán học (bao gồm sqrtvà log) bị quá tải trong Sage để trả về một giá trị chính xác, tượng trưng, ​​không làm mất độ chính xác.

MATL , 14 byte

t?5X^*17L&YlYo

Hãy thử trực tuyến!

Công cụ này sử dụng công thức nghịch đảo của Binet và vì vậy nó rất nhanh.

Hãy F biểu thị n -thứ số Fibonacci, và φ các tỷ lệ vàng . Sau đó

Mã sử ​​dụng công thức này với hai sửa đổi:

• Thay vì thêm 1/2 và làm tròn xuống, mã chỉ đơn giản làm tròn theo số nguyên gần nhất, chiếm ít byte hơn.
• Đầu vào F = 0 cần được coi là trường hợp đặc biệt.

Làm thế nào nó được thực hiện

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 byte

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

Kiểm tra nó trên Ideone .

JavaScript, 22 byte

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

C, 62 58 byte

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

Chi tiết

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 byte

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 byte

Đầu vào đi vào @nnhư trongDECLARE @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 byte

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

Vừng , 28 byte

Hexdump:

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

Hãy thử trực tuyến!

(Thời gian theo cấp số nhân vì trong Sesos sao chép một số cần thời gian theo cấp số nhân.)

Hội được sử dụng để tạo tệp nhị phân:

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 byte

Giống như câu trả lời @dainichi chỉ được thực hiện ngắn hơn bằng cách sử dụng lambdas Java 8. Câu trả lời là một biểu thức rvalue hợp lệ.

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

Ung dung:

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

Bình thường, 13 byte

J1tf>=Z+~JZZQ

Bộ thử nghiệm.

Xấp xỉ trong 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)

phương pháp thay thế, 18 byte

L?<b2bsyMtBtbs.IyG

Bộ thử nghiệm.

Điều này sử dụng .Icho nghịch đảo.

Java 7, 89 byte

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

Lấy cảm hứng từ giải thích về @Adnan 05AB1E câu trả lời 's .

Các trường hợp bất ngờ & thử nghiệm:

Hãy thử nó ở đây. (Vượt quá giới hạn thời gian cho trường hợp thử nghiệm cuối cùng, nhưng nó hoạt động trong khoảng 30-45 giây trên PC của tôi.)

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

Đầu ra:

0
3
4
5
6
46

Perl 5.10, 48 byte

Về cơ bản tìm kiếm quyền nđểF(n) = input .

-a chuyển đổi thêm một byte.

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

Hãy thử nó ở đây!

J, 32 27 17 byte

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

Tính số n Fibonacci đầu tiên và sau đó tìm chỉ số của n trong danh sách đó.

Sử dụng

Các lệnh bổ sung được sử dụng để định dạng nhiều đầu vào / đầu ra. Trường hợp thử nghiệm cuối cùng được bỏ qua vì nó sẽ cần nhiều thời gian hơn để tính toá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

Giải trình

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

Toán học, 30 byte

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

Chức năng thuần túy; trả về 2 nếu đầu vào là 1.

Không đánh bại mục nhập Mathicala khác, nhưng hiển thị một phương thức khác thường: Thực tế là (số rất tuyệt vời) rằng số Fibonacci thứ N là số nguyên gần nhất với [1 / sqrt (5) lần công suất Nth của tỷ lệ vàng] (" Công thức của Binet ").

Do đó, hàm nghịch đảo sẽ là logarit cơ sở [tỷ lệ vàng] của [sqrt (5) nhân với số Fibonacci trong câu hỏi]. Đây .8+là một hack để đảm bảo chúng ta không lấy logarit bằng 0, mà không làm hỏng các giá trị khác.

Japt , 10 byte

Lo æ@U¥MgX

Hãy thử trực tuyến!

Giải trình

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

Brachylog , 14 byte

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

Hãy thử trực tuyến!

Đưa đầu vào thông qua biến đầu ra và đầu ra thông qua biến đầu vào.

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

Tôi không hoàn toàn chắc chắn tại sao ≜cần thiết.

Javascript (sử dụng thư viện bên ngoài) (84 byte)

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

Liên kết đến lib: https://github.com/mvegh1/Enumerable

Giải thích mã: Thư viện có phương thức tĩnh tạo ra một chuỗi cho đến khi vị từ có giá trị trả về không xác định. Vị ngữ có chữ ký của ("i" ndex, nội bộ hiện tại "a" rray được tạo). Ở mỗi lần lặp, chúng tôi kiểm tra xem phần tử cuối cùng của mảng bên trong có bằng đầu vào không, n. Nếu không, trả về giá trị tiếp theo trong chuỗi sợi. Mặt khác, vị ngữ có một kết quả không xác định sẽ chấm dứt việc tạo ra chuỗi. Sau đó, chúng tôi trả về độ dài của chuỗi (và trừ 1 để tuân thủ tính năng dựa trên 0 như đã thấy trong OP