introduction

Nous connaissons tous et aimons notre séquence de Fibonacci et nous avons déjà vu une myriade de défis à relever. Cependant, il nous manque encore un cas très simple que cette réponse va fournir: Fibonacci inversé! Donc, étant donné que F_nvotre travail est de trouver n.

spécification

Contribution

Votre entrée sera un entier non négatif, ce qui est garanti pour faire partie de la séquence de fibonacci.

Sortie

La sortie doit également être un entier non négatif.

Que faire?

L’introduction disait déjà: À partir d’un numéro de fibonacci, affichez son index. Le numéro FiboCancci est défini comme suit: F(0)=0, F(1)=1, F(n)=F(n-1)+F(n-2)vous êtes donné F(n)et vous devez revenir n.

Cas potentiels de coin

0 est une entrée et une sortie valide.
Si vous donnez "1" en entrée, vous pouvez sortir "1" ou "2", comme vous préférez.
Vous pouvez toujours supposer que votre entrée est en réalité un nombre de fibonacci.
Vous pouvez supposer que l'entrée est représentable sous la forme d'un entier signé 32 bits.

Qui gagne?

C'est du code-golf donc la réponse la plus courte en octets gagne!
Les règles standard s'appliquent bien sûr.

Cas de test

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

En fait, 1 octet

f

Oui, il y a une logique pour cela, depuis le 16 novembre 2015 .

Essayez-le en ligne

Pour le plaisir, sans l'integrin, c'est 9 octets:

╗1`F╜=`╓i

Essayez-le en ligne!

Explication:

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

InverseFunction@Fibonacci

Une fonction. Assez explicite si vous me demandez.

Python, 36 34 32 octets

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

Versions précédentes:

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

Explication

L'idée principale est d'inverser la formule

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

qui nous dit que

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

obtenir

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

Les optimisations de golf sont les suivantes:

• Utilisé len(str(n))pour calculer la base de journaux 10 sans importer log(ancienne version utilisée .bit_length()pour calculer la base de données 2)
• Élever nà une puissance, de sorte que l'approximation du logarithme puisse faire la distinction entre les nombres de Fibonacci successifs
• Multiplier par une constante met à l'échelle les valeurs pour les obtenir dans la plage correcte

Ensuite, le diviseur a été tronqué avec le moins de précision possible et le multiplicateur choisi pour donner les résultats corrects pour tous les nombres de fibonacci 32 bits.

05AB1E , 3 octets

Code:

ÅFg

Explication:

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

Utilise le codage CP-1252 . Essayez-le en ligne! .

Gelée, 14 à 11 octets

5½×lØp+.Ḟ»0

Essayez-le en ligne!

C'est ma toute première réponse en gelée! Ceci utilise l'algorithme de la réponse MATL . Merci à Dennis d'avoir réduit de 3 octets!

Explication:

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

Cela donne la bonne réponse, il ne reste plus qu'à gérer le cas particulier du «0». Avec '0' comme argument, nous obtenons -infinity, alors nous revenons

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

Julia, 27 26 18 octets

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

Ceci utilise l'inverse de la formule de Binet , avec juste assez de précision pour les entiers 32 bits; cela fonctionne réellement jusqu'à F (153) = 42.230.279.526.998.466.217.810.220.532.898> 2 ¹⁰⁵ .

Essayez-le en ligne!

Comment ça marche

La formule de Binet est la suivante.

La restriction de F à l'ensemble de Fibonacci, la carte n → F _n a un droit inverse F → n _F .

Nous avons cela

et tout ce qui reste à faire est de traiter le cas de bord 0 .

L'entrée étant limitée aux entiers 32 bits, nous pouvons utiliser des littéraux décimaux courts au lieu des constantes de la formule.

• log φ = 0.481211825059603447… ≈ 0.48

  Malheureusement, 0.5 n'est pas assez précis.

• √5 = 2,23606797749978969664… 3

  Cela peut sembler une première approximation, mais nous prenons des logarithmes et puisque log 3 - log √5 = 0,29389333245105… , le résultat avant arrondi est décalé d’un petit facteur constant.

• 0.5 ≈ 0.7

  En raison de l'excès par rapport à l'approximation précédente, nous pourrions en fait omettre complètement ce terme et toujours obtenir des résultats corrects pour F> 0 . Cependant, si F = 0 , le logarithme sera indéfini. 0,7 s'est avéré être la valeur la plus courte qui étend notre formule à F = 0 .

JavaScript, 54 50 69 50 42 octets

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

Ça ne va sûrement pas gagner, juste pour le plaisir :)

Ok, la vérification de zéro consomme 19 octets. WTF? Stupide que je suis.

Démo! Pour voir le dernier cas de test, vous devez faire un peu défiler la console.

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

Merci @edc pour le raccourcissement de 8 octets.

Perl 6  33 30  27 octets

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

L'essayer

Explication:

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

Tester:

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

Gelée , 8 octets

1+С0
¢i

Essayez-le en ligne! Notez que cette approche est trop inefficace pour le dernier cas de test.

Comment ça marche

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

.f.bq

Essayez-le ici!

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

Python, 29 octets

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

Divise récursivement l'entrée par l'approximation du nombre d'or 1.61 jusqu'à ce qu'elle soit inférieure à 0,7 et génère le nombre de divisions.

Pour 0, le code est généré False, ce qui correspond à 0 en Python . Cela peut être évité pour 2 octets

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

JavaScript (ES6), 39 33 octets

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

Même avec ES7, la formule inverse de Binet prend 47 octets:

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 octets

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

Merci à TuukkaX pour la suggestion de sauver sqrt(5)que de sse raser quelques octets.

Essayez-le en ligne .

Cette approche utilisant une méthode inverse de la formule de Binet offre plusieurs améliorations par rapport à la précédente: plus rapide (temps constant ou temps quadratique), elle fonctionne en fait pour les entrées plus volumineuses et plus courte!

Les utilisateurs de Python peuvent se demander pourquoi j'utilise sqrt(5)plutôt que le plus court 5**.5- c'est parce qu'il 5**.5est calculé avec la powfonction de C et perd de la précision en raison de problèmes de virgule flottante. De nombreuses fonctions mathématiques (y compris sqrtet log) sont surchargées dans Sage pour renvoyer une valeur symbolique exacte, qui ne perd pas de précision.

MATL , 14 octets

t?5X^*17L&YlYo

Essayez-le en ligne!

Cela utilise un inverse de la formule de Binet , donc c'est très rapide.

Soit F le n- ième nombre de Fibonacci et φ le nombre d' or . ensuite

Le code utilise cette formule avec deux modifications:

• Au lieu d’ajouter 1/2, puis d’arrondir, le code est arrondi au nombre entier le plus proche, ce qui prend moins d’octets.
• L'entrée F = 0 doit être traitée comme un cas spécial.

Comment c'est fait

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 octets

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

Testez-le sur Ideone .

JavaScript, 22 octets

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

C, 62 58 octets

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

Détaillé

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 octets

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 octets

L'entrée se passe @ncomme dansDECLARE @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 octets

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

Sesos , 28 octets

Hexdump:

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

Essayez-le en ligne!

(Temps exponentiel car dans Sesos, la copie d’un nombre nécessite un temps exponentiel.)

Assemblage utilisé pour générer le fichier binaire:

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 octets

Identique à @dainichi, la réponse a été raccourcie avec Java 8 lambdas. La réponse est une expression rvalue valide.

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 octets

J1tf>=Z+~JZZQ

Suite de tests.

Approximation en 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)

approche alternative, 18 octets

L?<b2bsyMtBtbs.IyG

Suite de tests.

Cela utilise .Ipour inverse.

Java 7, 89 octets

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

Inspiré par l'explication de @Adnan réponse 05AB1E de .

Ungolfed & cas de test:

Essayez ici. (La limite de temps est dépassée pour le dernier cas de test, mais cela fonctionne dans environ 30 à 45 secondes sur mon PC.)

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

Sortie:

0
3
4
5
6
46

Perl 5.10, 48 octets

Fondamentalement, chercher le bon npour que F(n) = input.

-a switch ajoute un octet.

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

Essayez-le ici!

J, 32 27 17 octets

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

Calcule les n premiers nombres de Fibonacci, puis trouve l'index de n dans cette liste.

Usage

Des commandes supplémentaires sont utilisées pour formater plusieurs entrées / sorties. Le dernier cas de test est omis car le calcul nécessitera beaucoup plus de temps.

   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

Explication

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 octets

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

Fonction pure; renvoie 2 si l'entrée est 1.

Ne bat pas l’autre entrée de Mathematica, mais présente une méthode inhabituelle: c’est un fait (très cool) que le nombre Nth de Fibonacci est l’entier le plus proche de [1 / sqrt (5) fois la Nième puissance du nombre d’or] (" Formule de Binet ").

Par conséquent, la fonction inverse sera le logarithme base- [nombre d'or] de [sqrt (5) fois le nombre de Fibonacci en question]. Le .8+est un hack pour s'assurer que nous ne prenons pas le logarithme de 0, sans foirer les autres valeurs.

Japt , 10 octets

Lo æ@U¥MgX

Essayez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne!

Prend les entrées par la variable de sortie et les sorties par la variable d’entrée.

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

Je ne suis pas tout à fait sûr pourquoi ≜est nécessaire.

Javascript (en utilisant une bibliothèque externe) (84 octets)

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

Lien vers lib: https://github.com/mvegh1/Enumerable

Explication de code: La bibliothèque a une méthode statique qui crée une séquence jusqu'à ce que le prédicat ait une valeur de retour non définie. Le prédicat a une signature de ("i" ndex, courant interne "a" généré). À chaque itération, nous vérifions si le dernier élément du tableau interne est égal à l'entrée, n. Sinon, retourne la valeur suivante dans la séquence fib. Sinon, le prédicat a un résultat non défini qui met fin à la génération de la séquence. Ensuite, nous retournons la longueur de la séquence (et soustrayons 1 pour se conformer à la valeur 0 telle qu’elle est vue dans l’OP