소개

우리 모두는 피보나치 수열을 알고 사랑하며 이미 여기에서 수많은 도전을 보았습니다. 그러나 우리는 여전히이 대답이 제공 할 매우 간단한 경우가 부족합니다 : 역 피보나치! 그래서 F_n당신의 직업은 찾을 것 n입니다.

사양

입력

입력 값은 음이 아닌 정수이며 피보나치 수열의 일부로 보장됩니다.

산출

출력도 음이 아닌 정수 여야합니다.

무엇을해야합니까?

소개는 이미 말했다 : 피보나치 수를 감안할 때 색인을 출력하십시오. 여기에 피보 안치 번호는로 정의되어 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

예, 2015 년 11 월 16 일부터 내장되어 있습니다.

온라인으로 사용해보십시오

재미있게도 내장 기능이 없으면 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

기능. 당신이 나에게 물어 보면 꽤 자명하다.

파이썬, 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 바이트를 줄여 준 Dennis에게 감사합니다!

설명:

   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 비트 정수를위한 충분한 정밀도 로 Binet 공식 의 역수를 사용합니다 . 실제로 최대 작동 F (153) = 42,230,279,526,998,466,217,810,220,532,898> 2 ⁽¹⁰⁵⁾ .

온라인으로 사용해보십시오!

작동 원리

Binet의 공식은 다음과 같습니다.

F 를 피보나치 세트로 제한 하면, 맵 n → F _n 은 오른쪽 역 F → n _F 입니다.

우리는 그것을 가지고

그리고 남은 일은 edge case 0을 처리하는 것입니다 .

입력은 32 비트 정수로 제한되므로 수식의 상수 대신 짧은 10 진수 리터럴을 사용할 수 있습니다.

• 로그 φ = 0.481211825059603447… ≈ 0.48

  불행히도 0.5 는 정확하지 않습니다.

• √5 = 2.2360679774997896964… ≈ 3

  즉, 첫눈에 끔찍한 근사처럼 보일 수도 있지만, 우리가 대수을 복용하고 이후하고 로그 3 - 로그 √5 = 0.29389333245105 ... 작은 상수 계수 꺼집니다 반올림 전에 결과.

• 0.5≈ 0.7

  이전 근사값을 초과하여 실제로이 항을 생략하고 F> 0에 대한 올바른 결과를 얻을 수 있습니다. 그러나 F = 0 이면 로그가 정의되지 않습니다. 0.7 은 우리의 공식을 F = 0으로 확장하는 가장 짧은 값으로 밝혀졌습니다 .

자바 스크립트, 54 50 69 50 42 바이트

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

확실히 그것은 재미를 위해 이길 수 없습니다 :)

좋아, 0을 확인하면 19 바이트가 소비됩니다. 이런 씨발? 바보 야

데모! 마지막 테스트 사례를 보려면 콘솔을 약간 스크롤해야합니다.

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 바이트 단축 된 @edc에게 감사합니다.

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

파이썬, 29 바이트

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

입력 값을 0.7 미만이 될 때까지 입력 값을 황금비 근사값 1.61로 재귀 적으로 나누고 나눗셈 수를 출력합니다.

0의 경우 코드가 출력 되는데False , 이는 파이썬에서 0과 같습니다 . 이것은 2 바이트 동안 피할 수 있습니다

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

자바 스크립트 (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

세이지, 49 바이트

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

몇 바이트를 절약 sqrt(5)할 s수있는 절약 방법에 대한 제안에 대해 TuukkaX에게 감사드립니다 .

온라인으로 사용해보십시오 .

Binet 공식의 역수를 사용하는이 방법은 이전 방법에 비해 몇 가지 개선 된 기능을 제공합니다. 더 빠르며 (일정 시간 대 2 차 시간) 실제로 더 큰 입력에 적용되며 더 짧습니다!

파이썬 사용자는 내가 왜 sqrt(5)더 짧은 대신 사용하는지 궁금 할 것입니다. 5**.5왜냐하면 5**.5C의 pow함수로 계산 되고 부동 소수점 문제로 인해 정밀도가 떨어 지기 때문 입니다 . Sage에는 많은 수학 함수 ( sqrt및 포함 log)가 오버로드되어 정밀도를 잃지 않는 정확한 기호 값을 반환합니다.

MATL , 14 바이트

t?5X^*17L&YlYo

온라인으로 사용해보십시오!

이것은 Binet의 공식의 역수를 사용 하므로 매우 빠릅니다.

하자 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

파이썬, 38 바이트

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

Ideone에서 테스트하십시오 .

자바 스크립트, 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);
}

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

하스켈, 45 바이트

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

Sesos , 28 바이트

16 진 덤프 :

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

자바 8 61 바이트

@dainichi 답변과 동일하게 Java 8 람다를 사용하여 짧아졌습니다. 정답은 유효한 rvalue 식입니다.

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

언 골프 드 :

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

테스트 스위트.

파이썬 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역으로 사용 합니다.

자바 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 의 05AB1E 답변 에 대한 설명에서 영감을 얻었습니다 .

언 골프 및 테스트 사례 :

여기에서 시도하십시오. (마지막 테스트 케이스의 시간 제한을 초과했지만 내 PC에서 약 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 스위치는 1 바이트를 추가합니다.

$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#]&

순수한 기능; 입력이 1이면 2를 반환합니다.

다른 Mathematica 항목을이기는 것은 아니지만 특이한 방법을 보여줍니다. Nth 피보나치 수는 [1 / sqrt (5) 곱하기 황금비의 N 번째 거듭 제곱]에 가장 가까운 정수임] ( " Binet 's formula ").

따라서 역함수는 [문제의 피보나치 수에 대한 sqr (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

Brachylog , 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.

왜 ≜필요한지 잘 모르겠습니다 .

자바 스크립트 (외부 라이브러리 사용) (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 시퀀스에서 다음 값을 반환하십시오. 그렇지 않으면, 술어에는 정의되지 않은 결과가있어 시퀀스 생성을 종료합니다. 그런 다음 시퀀스의 길이를 반환하고 OP에서 볼 수 있듯이 0 기준을 준수하기 위해 1을 뺍니다.