Fibonacci rückgängig gemacht!

42

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
SEJPM
quelle
39
Leichte kleinlich sein: sollte dies nicht in Betracht gezogen werden inverse Fibonacci en.m.wikipedia.org/wiki/Inverse_function
Michael
19
Also, iccanobiF ?!
6
@Michael das ist kein inverses Fibonacci, weil es kein inverses Fibonacci gibt, weil es nicht injektiv ist (weil die "1" zweimal erscheint). Die Umkehrung ergab sich ursprünglich aus der Idee von "Reverse Table Look-Ups", von denen ich erwartet hatte, dass sie dies hier tun (z. B. erwartete ich, dass sie es tun, um das Problem zu lösen).
SEJPM
9
Die Funktion hier könnte als eine Rechtsumkehrung der "Fibonacci-Funktion" von den nicht negativen ganzen Zahlen zu der Menge von Fibonacci-Zahlen angesehen werden. Die Existenz einer Rechtsumkehrung impliziert keine Injektivität.
Dennis
1
@SEJPM: Ich hatte allerdings eine Aufgabe wie "Schreibe ein Programm, das die Fibonacci-Sequenz rückwärts buchstabiert" erwartet.
Bergi

Antworten:

58

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
Mego
quelle
15
Ich habe einen Gedanken und einen Gedanken nur, wenn ich das sehe: ಠ_ಠ
Addison Crump
37
Ich verstehe nicht wirklich, warum Sie ein Symbol für einen so lächerlichen Zweck "verschwenden"
Fatalize
19
@Fatalize Die Funktionen Fibonacci und Inverse Fibonacci gehörten zu den ersten, die ich hinzugefügt habe. Sogar jetzt gibt es 39 völlig unbenutzte Einzelbyte-Befehle (und wer weiß, wie viele Überladungen verwendet werden könnten). Die 256 Symbole bedeuten in Kombination mit der Tatsache, dass es in Actually 5 Typen gibt (Integer, Real, String, Iterable, Function), dass es bis zu 1280 mögliche unäre Funktionen und 6400 mögliche binäre Funktionen gibt. Es gibt viel Platz für scheinbar nutzlose Befehle.
Mego
23
@Mego Versuchen Sie nur, mit Mathematica um die meisten integrierten Funktionen zu konkurrieren?
Gcampbell
13
Eigentlich ist es nur ein Byte ... lol, liebe diesen Sprachnamen.
Nicoleel
42

Mathematica, 25 Bytes

InverseFunction@Fibonacci

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

LegionMammal978
quelle
31

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.


quelle
es sollte 32 bytes sein, da f=nicht gezählt wird.
Undichte Nonne
2
Wie oben bereits erwähnt, sind anonyme Funktionen / unbenannte Lambdas standardmäßig zulässig . Auch wenn Sie Ihre Antwort auf Python 2 einschränken und ein langes Argument benötigen , lambda n:~-len(`66*n**6`)//1.24sollte das funktionieren.
Dennis
19

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

Adnan
quelle
10

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.
DJMcMayhem
quelle
7
+1, weil die Kommentare zur Erklärung das Ende eines Limericks bedeuten.
Daniel
10

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

Probieren Sie es online!

Wie es funktioniert

Die Binet-Formel besagt Folgendes.

Binets Formel

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

Wir haben das

rechter Kehrwert der Binet-Formel

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 .

Dennis
quelle
8

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.

nicael
quelle
Simple b=>{for(j=1,i=c=0;b-i;c++)i=j+(j=i);return c}45, Golf b=>(j=>{for(i=c=0;b-i;c++)i=j+(j=i)})(1)|c42.
Edc65
1
@edc Wow, das ist klug, danke <3
nicael
8

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
Brad Gilbert b2gills
quelle
1
Sie können first *==$_mit nur ersetzen first $_, da eine Zahl ein gültiger Smart-Matcher ist.
smls
24 Bytes mit dem ...Operator anstelle vonfirst
Jo King
7

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.
Dennis
quelle
6

Pyke, 5 Bytes

.f.bq

Probieren Sie es hier aus!

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

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)
xnor
quelle
4

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
Neil
quelle
Verteilen Sie einfach die logund berechnen Sie alle Konstanten vor ...
Charlie
IMHO, wenn Sie das Lambda rekursiv mit Namen aufrufen f(n,k,j+k), sollten Sie die Zuweisung einschließen f=und als +2 Bytes zählen . Die Regel für unbenannte Lambdas sollte hier nicht gelten.
Charlie
@charlie Sorry, das habe ich immer vergessen. Fest.
Neil
4

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.

Mego
quelle
Ich kenne Sage überhaupt nicht, aber könnten Sie Bytes sparen, indem Sie die sqrt(5)Variable in einer Position halten und sie zweimal verwenden, anstatt sie zweimal einzugeben sqrt(5)?
Yytsi
4

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

Bildbeschreibung hier eingeben

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
Luis Mendo
quelle
1
Alternativer Ansatz:O1G:"yy+]vGmfq
DJMcMayhem
1
11 Bytes:t?17L&YlXkQ
Jimmy23013
@ jimmy23013 Netter Ansatz! Sie sollten dies definitiv als separate Antwort posten
Luis Mendo
Ich denke nicht, dass es eine andere Antwort wert ist, da es nur ein Weg ist, das zu entfernen 5X^*. ( Ich habe das schon einmal gemacht .) Und ich kenne MATL nicht genug, um es möglicherweise weiter zu verbessern.
Jimmy23013
3

Python, 38 Bytes

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

Teste es auf Ideone .

Dennis
quelle
3

JavaScript, 22 Byte

n=>Math.log(n)/.48+2|0
Charlie
quelle
Ich dachte nicht, dass das funktionieren würde, wenn ich es sehe, aber anscheinend -Infinity|0ist es 0in JavaScript. Stelle dir das vor.
Dennis
@ Tennis: In JS nehmen bitweise Operatoren nur die letzten 32 Bits und -Infinity = FFF00000 00000000. Ich war froh herauszufinden, dass es 3 Bytes spart, weil ich keinen expliziten Zero-Test voranstellen muss n&&. Abgesehen davon ist der Hauptzweck von |0ein Ersatz für Math.trunc()(wie ÷in Julia).
Charlie
3

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);
}
Khaled.K
quelle
3

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

Dainichi
quelle
2
Willkommen bei PPCG, schöne erste Antwort!
Undichte Nonne
int c(int n){int a=0,b=1,c=0,t;for(;a<n;t=b,b+=a,a=t)c++;return c;}(nicht getestet)
Leaky Nun
int c(int n){int a=0,b=1,c=0;while(a<n){c++;b+=a;a=b-a;}return c;}(nicht getestet)
Leaky Nun
2
int c(int n){int a=0,b=1,c=0;for(;a<n;b+=a,a=b-a)c++;return c;}(nicht getestet)
Leaky Nun
2

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);
Liesel
quelle
2

Haskell, 45 Bytes

f x=round$log(sqrt 5*x+0.9)/log((sqrt 5+1)/2)
Damien
quelle
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
Undichte Nonne
quelle
2

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;};
    }
}
BananyaDev
quelle
1

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.

Undichte Nonne
quelle
1

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
Kevin Cruijssen
quelle
1

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!

Paul Picard
quelle
1

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
Meilen
quelle
1

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.

Greg Martin
quelle
1

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
Oliver
quelle
1

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.

Nicht verwandte Zeichenfolge
quelle
0

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

Bildbeschreibung hier eingeben

applejacks01
quelle
53 Bytes mit dem Code von hier n=>{a=c=t=0,b=1;while(a<n){c++;t=b;b+=a;a=t}return c} Probieren Sie es online!
Pixma140