pengantar

Kita semua tahu dan menyukai urutan Fibonacci kami dan telah melihat segudang tantangan di sini. Namun, kami masih kekurangan kasus yang sangat sederhana yang akan diberikan jawaban ini: Reversed fibonacci! Jadi, F_ntugas Anda adalah menemukan n.

Spesifikasi

Memasukkan

Input Anda akan berupa bilangan bulat non-negatif, yang dijamin menjadi bagian dari deret fibonacci.

Keluaran

Outputnya juga harus bilangan bulat non-negatif.

Melakukan apa?

Pendahuluan sudah mengatakan: Diberi nomor Fibonacci, tampilkan indeksnya. Nomor Fiboancci dengan ini didefinisikan sebagai F(0)=0, F(1)=1, F(n)=F(n-1)+F(n-2)dan Anda diberikan F(n)dan harus kembali n.

Kasus Pojok Potensial

0 adalah in- dan output yang valid.
Jika diberi "1" sebagai input, Anda dapat menampilkan "1" atau "2", sesuai keinginan.
Anda mungkin selalu menganggap bahwa input Anda sebenarnya adalah nomor fibonacci.
Anda dapat mengasumsikan bahwa input tersebut mewakili sebagai integer bertanda 32-bit.

Yang menang?

Ini adalah kode-golf sehingga jawaban tersingkat dalam byte menang!
Aturan standar berlaku tentu saja.

Kasus uji

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

Sebenarnya 1 byte

f

Ya, ada builtin untuk ini, sejak 16 November 2015 .

Cobalah online

Untuk bersenang-senang, tanpa builtin, 9 byte:

╗1`F╜=`╓i

Cobalah online!

Penjelasan:

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

InverseFunction@Fibonacci

Fungsi. Cukup jelas jika Anda bertanya kepada saya.

Python, 36 34 32 byte

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

Versi sebelumnya:

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

Penjelasan

Gagasan intinya adalah membalik formula

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

yang memberitahu kita itu

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

mendapatkan

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

Optimalisasi golf adalah:

• Gunakan len(str(n))untuk menghitung basis log 10 tanpa mengimpor log(versi lama digunakan .bit_length()untuk menghitung basis log 2)
• Naikkan nkekuatan, sehingga perkiraan logaritma dapat membedakan antara angka Fibonacci yang berurutan
• Mengalikan dengan konstanta meningkatkan nilai untuk mendapatkan mereka dalam kisaran yang benar

Kemudian pembagi dipotong sesedikit mungkin yang saya bisa kelola dan pengali dipilih untuk memberikan hasil yang benar untuk semua angka-angka fibonacci 32-bit.

05AB1E , 3 byte

Kode:

ÅFg

Penjelasan:

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

Menggunakan pengkodean CP-1252 . Cobalah online! .

Jelly, 14 11 byte

5½×lØp+.Ḟ»0

Cobalah online!

Ini adalah jawaban Jelly pertamaku! Ini menggunakan algoritma dari jawaban MATL . Terima kasih kepada Dennis untuk mencukur 3 byte!

Penjelasan:

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

Ini mendapatkan jawaban yang benar, sekarang kita hanya perlu menangani kasus khusus '0'. Dengan '0' sebagai argumen, kami dapat -infinity, jadi kami kembali

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

Julia, 27 26 18 byte

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

Ini menggunakan kebalikan dari rumus Binet , dengan cukup presisi untuk bilangan bulat 32-bit; sebenarnya bekerja hingga F (153) = 42.230.279.526.998.466.217.810.220.532.898> 2 ¹⁰⁵ .

Cobalah online!

Bagaimana itu bekerja

Rumus Binet menyatakan sebagai berikut.

Membatasi F ke set dari peta Fibonacci, n → F _n memiliki hak terbalik F → n _F .

Kami memilikinya

dan semua yang tersisa untuk dilakukan adalah berurusan dengan kasus tepi 0 .

Karena input dibatasi untuk bilangan bulat 32-bit, kita dapat menggunakan liter desimal pendek alih-alih konstanta dalam rumus.

• log φ = 0.481211825059603447… ≈ 0.48

  Sayangnya, 0,5 tidak cukup tepat.

• √5 = 2.2360679774997896964… ≈ 3

  Itu mungkin tampak seperti perkiraan yang mengerikan pada pandangan pertama, tapi kami mengambil logaritma dan karena log 3 - log √5 = 0,29389333245105 ... , hasil sebelum pembulatan akan dimatikan oleh faktor konstan kecil.

• 0,5 ≈ 0,7

  Karena kelebihan dari perkiraan sebelumnya, kami sebenarnya bisa menghilangkan istilah ini sama sekali dan masih mendapatkan hasil yang benar untuk F> 0 . Namun, jika F = 0 , logaritma tidak akan ditentukan. 0,7 ternyata menjadi nilai terpendek yang memperpanjang rumus kami ke F = 0 .

JavaScript, 54 50 69 50 42 byte

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

Tentunya itu tidak akan menang, hanya untuk bersenang-senang :)

Ok, mengecek nol untuk konsumsi 19 byte. WTF? Bodohnya aku.

Demo! Untuk melihat test case terakhir, Anda harus sedikit menggulir konsol.

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

Terima kasih @edc untuk mempersingkat 8 byte.

Perl 6  33 30  27 byte

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

Cobalah

Penjelasan:

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

Uji:

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

Jelly , 8 byte

1+С0
¢i

Cobalah online! Perhatikan bahwa pendekatan ini terlalu tidak efisien untuk kasus uji terakhir.

Bagaimana itu bekerja

¢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

Coba di sini!

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

Python, 29 byte

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

Membagi input secara rekursif dengan perkiraan rasio emas 1,61 hingga di bawah 0,7, dan mengeluarkan jumlah divisi.

Untuk 0, output kode False, yang sama dengan 0 dalam Python . Ini dapat dihindari untuk 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

Bahkan dengan ES7, rumus Binet terbalik mengambil 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

Sage, 49 byte

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

Berkat TuukkaX untuk saran tentang menyimpan sqrt(5)sebagai smencukur beberapa byte.

Cobalah online .

Pendekatan ini menggunakan kebalikan dari formula Binet menawarkan beberapa perbaikan dibandingkan pendekatan sebelumnya: lebih cepat (waktu-konstan versus waktu kuadratik), ini sebenarnya bekerja untuk input yang lebih besar, dan lebih pendek!

Pengguna Python mungkin bertanya-tanya mengapa saya menggunakan sqrt(5)bukan yang lebih pendek 5**.5- itu karena 5**.5dihitung dengan powfungsi C , dan kehilangan presisi karena masalah floating point. Banyak fungsi matematika (termasuk sqrtdan log) kelebihan beban di Sage untuk mengembalikan nilai simbolik yang tepat, yang tidak kehilangan presisi.

MATL , 14 byte

t?5X^*17L&YlYo

Cobalah online!

Ini menggunakan kebalikan dari rumus Binet , dan itu sangat cepat.

Misalkan F menyatakan n th nomor Fibonacci, dan φ yang rasio emas . Kemudian

Kode menggunakan rumus ini dengan dua modifikasi:

• Alih-alih menambahkan 1/2 dan kemudian membulatkan ke bawah, kode hanya membulatkan ke arah integer terdekat, yang membutuhkan lebih sedikit byte.
• Input F = 0 perlu diperlakukan sebagai kasus khusus.

Bagaimana itu dilakukan

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)

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

Terperinci

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

Input masuk @nseperti padaDECLARE @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)

Sesos , 28 byte

Hexdump:

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

Cobalah online!

(Waktu eksponensial karena dalam Sesos menyalin nomor perlu waktu eksponensial.)

Majelis yang digunakan untuk menghasilkan file biner:

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

Sama seperti jawaban @dainichi hanya dibuat lebih pendek dengan menggunakan Java 8 lambdas. Jawabannya adalah ekspresi rvalue yang valid.

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

Tidak Disatukan:

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 byte

J1tf>=Z+~JZZQ

Suite uji.

Perkiraan dalam 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)

pendekatan alternatif, 18 byte

L?<b2bsyMtBtbs.IyG

Suite uji.

Ini digunakan .Iuntuk terbalik.

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

Terinspirasi oleh penjelasan @Adnan 's jawaban 05AB1E .

Kasus yang tidak disatukan & uji:

Coba di sini. (Batas waktu terlampaui untuk test case terakhir, tetapi bekerja dalam waktu sekitar 30-45 detik pada PC saya.)

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

Keluaran:

0
3
4
5
6
46

Perl 5.10, 48 byte

Pada dasarnya mencari yang benar nsehinggaF(n) = input .

-a switch menambahkan satu byte.

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

Coba di sini!

J, 32 27 17 byte

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

Menghitung angka Fibonacci n pertama dan kemudian menemukan indeks n dalam daftar itu.

Pemakaian

Perintah tambahan digunakan untuk memformat beberapa input / output. Kasing uji terakhir dihilangkan karena akan membutuhkan lebih banyak waktu untuk menghitung.

   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

Penjelasan

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 byte

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

Fungsi murni; mengembalikan 2 jika inputnya 1.

Tidak mengalahkan entri Mathematica lainnya, tetapi menampilkan metode yang tidak biasa: Ini fakta (sangat keren) bahwa angka Fibonacci N adalah bilangan bulat terdekat dengan [1 / sqrt (5) kali kekuatan N dari rasio emas] (" Rumus Binet ").

Oleh karena itu fungsi invers akan menjadi basis- [rasio emas] logaritma [sqrt (5) kali angka Fibonacci yang dimaksud]. Ini .8+adalah hack untuk memastikan kita tidak mengambil logaritma 0, tanpa mengacaukan nilai-nilai lainnya.

Japt , 10 byte

Lo æ@U¥MgX

Cobalah online!

Penjelasan

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

Cobalah online!

Mengambil input melalui variabel output dan output melalui variabel input.

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

Saya tidak sepenuhnya yakin mengapa ≜itu perlu.

Javascript (menggunakan perpustakaan eksternal) (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

Tautan ke lib: https://github.com/mvegh1/Enumerable

Penjelasan kode: Perpustakaan memiliki metode statis yang membuat urutan hingga predikat memiliki nilai balik yang tidak ditentukan. Predikat memiliki tanda tangan ("i" ndex, internal "a" rray yang dihasilkan). Pada setiap iterasi, kami memeriksa apakah elemen terakhir dari array internal sama dengan input, n. Jika tidak, kembalikan nilai berikutnya dalam urutan fib. Jika tidak, predikat memiliki hasil yang tidak ditentukan yang mengakhiri pembuatan urutan. Kemudian, kami mengembalikan panjang urutan (dan mengurangi 1 untuk mematuhi 0-ness berbasis seperti yang terlihat dalam OP