Giriş

Hepimiz Fibonacci dizimizi biliyor ve seviyoruz ve burada çok sayıda zorlu görev gördük. Ancak, bu cevabın sağlayacağı çok basit bir davadan hala yoksun: Reversed fibonacci! Yani verilen F_nişi bulmak n.

Şartname

Giriş

Girişiniz, fibonacci dizisinin bir parçası olarak garanti edilen negatif olmayan bir tam sayı olacaktır.

Çıktı

Çıktı, negatif olmayan bir tamsayı da olmalıdır.

Ne yapalım?

Giriş zaten dedi: Bir fibonacci numarası verildiğinde, dizini çıktı. Fiboancci numarası burada tanımlanır F(0)=0, F(1)=1, F(n)=F(n-1)+F(n-2)ve size verilir F(n)ve geri gönderilmeleri gerekir n.

Potansiyel Köşe Kılıfları

0 geçerli bir giriş ve çıkıştır.
Giriş olarak "1" verilirse, istediğiniz gibi "1" veya "2" yazabilirsiniz.
Her zaman girişinizin aslında bir fibonacci numarası olduğunu varsayabilirsiniz.
Girişin 32 bit işaretli bir tam sayı olarak gösterilebileceğini varsayabilirsiniz.

Kim kazanır?

Bu kod-golf yani bayt cinsinden en kısa cevap kazanır!
Standart kurallar elbette geçerlidir.

Test-vakalar

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

Aslında, 1 bayt

f

Evet, 16 Kasım 2015'ten beri bunun için bir yapı var .

Çevrimiçi deneyin

Yerleşik olarak eğlence için 9 bayttır:

╗1`F╜=`╓i

Çevrimiçi deneyin!

Açıklama:

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

InverseFunction@Fibonacci

İşlev. Bana sorarsan oldukça açıklayıcı.

Python, 36 34 32 bayt

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

Önceki sürümler:

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

açıklama

Temel fikir, formülü tersine çevirmektir.

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

bu bize söyler

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

almak

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

Golf optimizasyonları:

• len(str(n))Günlük 10'u içe aktarmadan hesaplamak için kullanın log( .bit_length()günlük 2 tabanını hesaplamak için kullanılan eski sürüm )
• nLogaritma yaklaşımı ardışık Fibonacci sayıları arasında ayrım yapabilmek için bir güce yükseltin
• Sabit ile çarpmak, değerleri doğru aralıkta almak için değerleri yükseltir

Ardından, bölen yönetebildiğim kadar küçük bir kesite sahipti ve çarpan, tüm 32 bit fibonacci sayıları için doğru sonuçları vermeyi seçti.

05AB1E , 3 bayt

Kod:

ÅFg

Açıklama:

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

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin! .

Jöle, 14 11 bayt

5½×lØp+.Ḟ»0

Çevrimiçi deneyin!

Bu benim ilk Jelly cevabım! Bu MATL cevabındaki algoritmayı kullanır . Dennis'e 3 byte'ı tıraş ettiğin için teşekkürler!

Açıklama:

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

Bu doğru cevabı alır, şimdi sadece '0' özel vakasını ele almamız gerekiyor. '0' ile bir argüman olarak anlıyoruz -infinity, o yüzden geri dönüyoruz.

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

Julia, 27 26 18 bayt

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

Bu Binet'in formülünün tersini kullanır, sadece 32-bit tamsayılar için yeterli hassasiyetle; aslında F (153) = 42,230,279,526,998,466,217,810,220,532,898> 2 ^{105'e kadar çalışır} .

Çevrimiçi deneyin!

Nasıl çalışır

Binet'in formülü aşağıdakileri belirtir.

Kısıtlama F Fibonacci, haritanın setine n → F _n bir sahiptir ters hakkını F → n _F .

Bizde var

ve tek yapılması gereken, 0 kenarındaki durumla başa çıkmak .

Girdi 32 bit tamsayılarla sınırlı olduğundan, formüldeki sabitler yerine kısa ondalık değişmezler kullanabiliriz.

• log φ = 0.481211825059603447… ≈ 0,48

  Ne yazık ki, 0.5 yeterince kesin değil.

• √5 = 2.2360679774997896964… ≈ 3

  Bu ilk bakışta berbat bir yaklaşım gibi görünebilir, ancak logaritma alıyoruz ve log 3'ten beri - log √5 = 0.29389333245105… yuvarlamadan önceki sonuç sabit bir faktör tarafından kesilecek.

• 0.5 ≈ 0.7

  Önceki yaklaşımdaki fazlalık nedeniyle, bu terimi tamamen atlayabilir ve F> 0 için hala doğru sonuçlar alabiliriz . Ancak, eğer F = 0 ise, logaritma tanımsız olacaktır. 0.7 , formülümüzü F = 0'a genişleten en kısa değer olduğu ortaya çıktı .

JavaScript, 54 50 69 50 42 bayt

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

Kesinlikle kazanmayacak, sadece eğlence için :)

Tamam, sıfırı kontrol etmek 19 bayt tüketir. O NE LAN? Aptal ben.

Demo! Son test senaryosunu görmek için konsolu biraz kaydırmanız gerekir.

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

8 bayt kısaltmak için @ edc teşekkürler.

Perl 6  33 30  27 bayt

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

Dene

Açıklama:

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

Ölçek:

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

Jöle , 8 bayt

1+С0
¢i

Çevrimiçi deneyin! Bu yaklaşımın son test durumu için çok yetersiz olduğuna dikkat edin.

Nasıl çalışır

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

.f.bq

Burada dene!

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

Python, 29 bayt

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

Girdiyi, 0.7'nin altına düşene kadar altın oran yaklaşımı 1.61 ile tekrarlı bir şekilde böler ve bölüm sayısını verir.

0 için, kod çıkışları False, Python 0'a eşit olan . Bu 2 bayt için önlenebilir

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

JavaScript (ES6), 39 33 bayt

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

ES7 ile bile, ters Binet formülü 47 bayt alır:

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

Adaçayı, 49 bayt

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

Kaydetme hakkında öneri için TuukkaX sayesinde sqrt(5)olarak sbirkaç bayt tıraş etmek.

Çevrimiçi deneyin .

Binet'in formülünün tersini kullanan bu yaklaşım önceki yaklaşıma göre birkaç gelişme sunar: daha hızlıdır (ikinci dereceye göre sabit zaman), aslında daha büyük girdiler için işe yarar ve daha kısadır!

Python kullanıcıları neden sqrt(5)daha kısa kullanmak yerine neden kullandığımı merak edebilir 5**.5- bunun nedeni 5**.5C'nin powfonksiyonuyla hesaplanması ve kayan nokta sorunları nedeniyle hassasiyetini yitirmesidir. Pek çok matematiksel fonksiyon (dahil sqrtve dahil log) Sage'de kesin ve sembolik bir değer döndürmek için aşırı yüklenmiştir;

MATL , 14 bayt

t?5X^*17L&YlYo

Çevrimiçi deneyin!

Bu kullanır Binet'in formülünün tersini ve bu yüzden çok hızlı.

Let F göstermek n Fibonacci sayı oyunu bırakanların ve cp altın oranı . Sonra

Kod bu formülü iki değişiklikle kullanır:

• 1/2 eklemek ve sonra yuvarlamak yerine, kod yalnızca en az tam sayıya yuvarlanır ve bu da daha az bayt alır.
• Girdi K özel bir durum olarak, tedavi edilecek 0 ihtiyaçlarını =.

Nasıl yapılır

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 bayt

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

İdeone üzerinde test et .

JavaScript, 22 bayt

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

C, 62 58 bayt

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

Detaylı

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 bayt

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 bayt

Giriş olduğu @ngibi giriyorDECLARE @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 bayt

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

Sesos , 28 bayt

HexDump:

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

Çevrimiçi deneyin!

(Üstel zaman, çünkü Sesos'ta bir sayının kopyalanması için üstel zaman gerekir.)

İkili dosyayı oluşturmak için kullanılan derleme:

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 bayt

@ Dainichi cevapları sadece Java 8 lambdalarını kullanarak daha kısa hale getirdi. Cevap geçerli bir değer ifadesidir.

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 bayt

J1tf>=Z+~JZZQ

Test odası.

Python 2'de Yaklaşım:

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)

alternatif yaklaşım, 18 bayt

L?<b2bsyMtBtbs.IyG

Test odası.

Bu .Iters için kullanır .

Java 7, 89 bayt

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'ın 05AB1E cevabının açıklamasından ilham alındı .

Ungolfed ve test durumları:

Burada dene. (Son test durumu için zaman sınırı aşıldı, ancak bilgisayarımda yaklaşık 30-45 saniye içinde çalışıyor.)

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

Çıktı:

0
3
4
5
6
46

Perl 5.10, 48 bayt

Temelde doğru arayan nböylece F(n) = input.

-a anahtar bir bayt ekler.

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

Burada dene!

J, 32 27 17 bayt

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

İlk n Fibonacci sayıları hesaplar ve sonra n dizini bulur bu listedeki .

kullanım

Ekstra komutlar çoklu giriş / çıkışı formatlamak için kullanılır. Son test durumu, hesaplanması için daha fazla zaman gerektireceği için atlandı.

   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

açıklama

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 bayt

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

Saf işlevi; giriş 1 ise 2 döndürür.

Diğer Mathematica girişini geçmiyor, ancak sıra dışı bir yöntem sergiliyor: Nth Fibonacci sayısının, altın oranın N / 1'inin [1 / sqrt (5) katına en yakın tamsayı] olduğu bir gerçek ("5" Binet'in formülü ").

Bu nedenle, ters fonksiyon, söz konusu Fibonacci sayısının [sqrt (5) katı olan taban- [altın oran] logaritması] olacaktır. .8+Diğer değerleri berbat etmeden, tabi 0 logaritmasını yapmayız yapmak kesmek.

Japt , 10 bayt

Lo æ@U¥MgX

Çevrimiçi deneyin!

açıklama

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 bayt

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

Çevrimiçi deneyin!

Çıkış değişkeninden giriş alır ve giriş değişkeninden çıkış alır.

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

Neden ≜gerekli olduğundan tam olarak emin değilim .

Javascript (harici kütüphaneyi kullanarak) (84 bayt)

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 bağlantısı: https://github.com/mvegh1/Numerable

Kod açıklaması: Kitaplık, kimliği belirsiz bir geri dönüş değerine sahip olana kadar bir sıra oluşturan statik yönteme sahiptir. Tahmini ("i" ndex, geçerli dahili "a" rray oluşturulmuş) imzası var. Her yinelemede, iç dizinin son elemanının girişe eşit olup olmadığını kontrol ederiz, n. Değilse, bir sonraki değeri fib dizisinde döndürün. Aksi takdirde, belirteç, dizinin oluşumunu sonlandıran tanımsız bir sonuca sahiptir. Daha sonra, OP'de görüldüğü gibi 0 temeline uymak için dizinin uzunluğunu döndürürüz (ve 1'i çıkarırız).