Einführung

Wir alle kennen und lieben unsere Fibonacci-Sequenz und haben hier bereits eine Vielzahl von Herausforderungen erlebt. Es fehlt uns jedoch immer noch ein sehr einfacher Fall, den diese Antwort liefern wird: Umgekehrte Fibonacci! Daher ist es F_nIhre Aufgabe, etwas zu finden n.

Spezifikation

Eingang

Ihre Eingabe ist eine nicht negative Ganzzahl, die garantiert Teil der Fibonacci-Sequenz ist.

Ausgabe

Die Ausgabe muss ebenfalls eine nicht negative Ganzzahl sein.

Was ist zu tun?

In der Einleitung heißt es bereits: Geben Sie bei gegebener Fibonacci-Zahl den Index aus. Die Fiboancci-Nummer ist hiermit definiert als F(0)=0, F(1)=1, F(n)=F(n-1)+F(n-2)und Sie sind angegeben F(n)und müssen zurückkehren n.

Mögliche Eckfälle

0 ist ein gültiger Ein- und Ausgang.
Wenn Sie als Eingabe "1" angeben, können Sie wahlweise "1" oder "2" ausgeben.
Sie können immer davon ausgehen, dass Ihre Eingabe tatsächlich eine Fibonacci-Zahl ist.
Sie können davon ausgehen, dass die Eingabe als 32-Bit-Ganzzahl mit Vorzeichen dargestellt werden kann.

Wer gewinnt?

Das ist Code-Golf, also gewinnt die kürzeste Antwort in Bytes!
Es gelten selbstverständlich Standardregeln.

Testfälle

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

Eigentlich 1 Byte

f

Ja, dafür gibt es seit dem 16. November 2015 eine integrierte Version .

Probieren Sie es online aus

Zum Spaß sind es ohne das eingebaute 9 Bytes:

╗1`F╜=`╓i

Probieren Sie es online!

Erläuterung:

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

InverseFunction@Fibonacci

Funktion. Ziemlich selbsterklärend, wenn du mich fragst.

Python, 36 34 32 Bytes

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

Vorherige Versionen:

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

Erläuterung

Die Kernidee ist, die Formel umzukehren

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

das sagt uns das

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

bekommen

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

Die Golf-Optimierungen sind:

• Verwenden Sie len(str(n))zum Berechnen Logbase 10 ohne Import log(alte Version verwendet .bit_length()zu berechnen Logbase 2)
• Erhöhen Sie nzu einer Potenz, so dass die Annäherung des Logarithmus zwischen aufeinanderfolgenden Fibonacci-Zahlen unterscheiden kann
• Das Multiplizieren mit einer Konstanten skaliert die Werte, um sie in den richtigen Bereich zu bringen

Dann wurde der Divisor mit der größtmöglichen Genauigkeit abgeschnitten und der Multiplikator ausgewählt, um die korrekten Ergebnisse für alle 32-Bit-Fibonacci-Zahlen zu erhalten.

05AB1E , 3 Bytes

Code:

ÅFg

Erläuterung:

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

Verwendet die CP-1252- Codierung. Probieren Sie es online! .

Jelly, 14 11 Bytes

5½×lØp+.Ḟ»0

Probieren Sie es online!

Dies ist meine allererste Gelee-Antwort! Dies verwendet den Algorithmus aus der MATL-Antwort . Danke an Dennis für die 3 Bytes!

Erläuterung:

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

Dies erhält die richtige Antwort, jetzt müssen wir nur noch den Sonderfall '0' behandeln. Mit '0' als Argument bekommen wir -infinity, also kehren wir zurück

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

Julia, 27 26 18 Bytes

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

Dabei wird die Umkehrung der Binet-Formel verwendet , und zwar mit einer Genauigkeit, die für 32-Bit-Ganzzahlen ausreicht. es funktioniert tatsächlich bis zu F (153) = 42.230.279.526.998.466.217.810.220.532.898> 2 ¹⁰⁵ .

Probieren Sie es online!

Wie es funktioniert

Die Binet-Formel besagt Folgendes.

Beschränken F auf den Satz von Fibonacci, der Karte n → F _n einen hat rechte inverse F → n _F .

Wir haben das

und alles, was zu tun bleibt, ist mit dem Kantenfall 0 umzugehen .

Da die Eingabe auf 32-Bit-Ganzzahlen beschränkt ist, können anstelle der Konstanten in der Formel kurze Dezimalstellen verwendet werden.

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

  Leider ist 0,5 nicht genau genug.

• √5 = 2,2360679774997896964… ≈ 3

  Das mag auf den ersten Blick wie eine schreckliche Annäherung erscheinen, aber wir nehmen Logarithmen und da log 3 - log √5 = 0,29389333245105… , wird das Ergebnis vor der Rundung durch einen kleinen konstanten Faktor abgerundet.

• 0,5 ≈ 0,7

  Aufgrund des Überschusses aus der vorherigen Näherung können wir diesen Term sogar ganz weglassen und trotzdem korrekte Ergebnisse für F> 0 erhalten . Wenn jedoch F = 0 ist , ist der Logarithmus undefiniert. Es stellte sich heraus, dass 0,7 der kürzeste Wert ist, der unsere Formel auf F = 0 erweitert .

JavaScript, 54 50 69 50 42 Bytes

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

Sicherlich wird es nicht gewinnen, nur zum Spaß :)

Ok, das Prüfen auf Null verbraucht 19 Bytes. WTF? Ich Idiot.

Demo! Um den letzten Testfall zu sehen, müssen Sie ein wenig durch die Konsole scrollen.

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

Vielen Dank an @edc für die Kürzung um 8 Bytes.

Perl 6  33 30  27 Bytes

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

Versuch es

Erläuterung:

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

Prüfung:

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

Gelee , 8 Bytes

1+С0
¢i

Probieren Sie es online! Beachten Sie, dass dieser Ansatz für den letzten Testfall zu ineffizient ist.

Wie es funktioniert

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

.f.bq

Probieren Sie es hier aus!

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

Python, 29 Bytes

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

Dividiert die Eingabe rekursiv durch die Golden-Ratio-Approximation 1,61, bis sie unter 0,7 liegt, und gibt die Anzahl der Divisionen aus.

Für 0 wird der Code ausgegeben False, der in Python 0 entspricht . Dies kann für 2 Bytes vermieden werden

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

JavaScript (ES6), 39 33 Bytes

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

Selbst mit ES7 benötigt die inverse Binet-Formel 47 Bytes:

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

Salbei, 49 Bytes

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

Dank TuukkaX für den Vorschlag über das Speichern sqrt(5)als sein paar Bytes rasieren.

Probieren Sie es online aus .

Dieser Ansatz, der eine Umkehrung der Binet-Formel verwendet, bietet einige Verbesserungen gegenüber dem vorherigen Ansatz: Er ist schneller (konstante Zeit im Vergleich zur quadratischen Zeit), funktioniert tatsächlich für größere Eingaben und ist kürzer!

Python-Benutzer fragen sich vielleicht, warum ich sqrt(5)statt der kürzeren eine verwende 5**.5- das liegt daran, dass diese 5**.5mit der C- powFunktion berechnet wird und aufgrund von Gleitkommaproblemen an Genauigkeit verliert. Viele mathematische Funktionen (einschließlich sqrtund log) sind in Sage überladen, um einen genauen symbolischen Wert zurückzugeben, der nicht an Genauigkeit verliert.

MATL , 14 Bytes

t?5X^*17L&YlYo

Probieren Sie es online!

Dies verwendet eine Umkehrung der Binet-Formel und ist daher sehr schnell.

Sei F die n- te Fibonacci-Zahl und φ der goldene Schnitt . Dann

Der Code verwendet diese Formel mit zwei Änderungen:

• Anstatt 1/2 zu addieren und dann abzurunden, rundet der Code einfach auf die nächste Ganzzahl, die weniger Bytes benötigt.
• Eingang F = 0 muss als Sonderfall behandelt werden.

Wie es gemacht wird

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 Bytes

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

Teste es auf Ideone .

JavaScript, 22 Byte

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

C, 62 58 Bytes

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

Detailliert

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 Bytes

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 Bytes

Die Eingabe erfolgt @nwie inDECLARE @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 Bytes

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

Sesos , 28 Bytes

Hexdump:

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

Probieren Sie es online!

(Exponentialzeit, da in Sesos das Kopieren einer Zahl Exponentialzeit benötigt.)

Assembly zum Generieren der Binärdatei:

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 Bytes

Entspricht der @ dainichi-Antwort, die nur mithilfe von Java 8-Lambdas verkürzt wurde. Die Antwort ist ein gültiger Wertausdruck.

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 Bytes

J1tf>=Z+~JZZQ

Testsuite.

Annäherung in 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)

alternativer Ansatz, 18 Bytes

L?<b2bsyMtBtbs.IyG

Testsuite.

Dies wird .Ifür Inverse verwendet.

Java 7, 89 Bytes

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

Inspiriert von der Erklärung der 05AB1E -Antwort von @Adnan .

Ungolfed & Testfälle:

Probieren Sie es hier aus. (Das Zeitlimit für den letzten Testfall wurde überschritten, auf meinem PC dauert es jedoch 30-45 Sekunden.)

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

Ausgabe:

0
3
4
5
6
46

Perl 5.10, 48 Bytes

Grundsätzlich suche ich das richtige ndamit F(n) = input.

-a Schalter fügt ein Byte hinzu.

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

Probieren Sie es hier aus!

J 32 27 17 Bytes

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

Berechnet die ersten n Fibonacci-Zahlen und findet dann den Index von n in dieser Liste.

Verwendungszweck

Zusätzliche Befehle werden zum Formatieren mehrerer Ein- / Ausgaben verwendet. Der letzte Testfall entfällt, da die Berechnung viel mehr Zeit in Anspruch nimmt.

   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

Erläuterung

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 Bytes

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

Reine Funktion; Gibt 2 zurück, wenn die Eingabe 1 ist.

Schlägt den anderen Mathematica-Eintrag nicht, zeigt aber eine ungewöhnliche Methode: Es ist eine (sehr coole) Tatsache, dass die N-te Fibonacci-Zahl die nächste Ganzzahl zu [1 / sqrt (5) mal der N-ten Potenz des goldenen Schnitts] ist (" Binets Formel ").

Daher ist die Umkehrfunktion der Logarithmus der Basis [goldenes Verhältnis] von [sqrt (5) mal der fraglichen Fibonacci-Zahl]. Das .8+ist ein Hack , um sicherzustellen , dass wir nicht nehmen den Logarithmus von 0, ohne dass die anderen Werte vermasseln.

Japt , 10 Bytes

Lo æ@U¥MgX

Probieren Sie es online!

Erläuterung

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 Bytes

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

Probieren Sie es online!

Übernimmt die Eingabe über die Ausgabevariable und gibt sie über die Eingabevariable aus.

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

Ich bin mir nicht ganz sicher, warum ≜das notwendig ist.

Javascript (mit externer Bibliothek) (84 Bytes)

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

Link zu lib: https://github.com/mvegh1/Enumerable

Codeerklärung: Die Bibliothek verfügt über eine statische Methode, die eine Sequenz erstellt, bis das Prädikat einen undefinierten Rückgabewert hat. Das Prädikat hat eine Signatur von ("i" ndex, aktuelles internes "a" -Ray generiert). Bei jeder Iteration prüfen wir, ob das letzte Element des internen Arrays gleich der Eingabe n ist. Wenn nicht, geben Sie den nächsten Wert in der Fib-Sequenz zurück. Andernfalls hat das Prädikat ein undefiniertes Ergebnis, das die Generierung der Sequenz beendet. Dann geben wir die Länge der Sequenz zurück (und subtrahieren 1, um der 0-Basis zu entsprechen, wie sie im OP zu sehen ist