परिचय

हम सभी अपने फाइबोनैचि अनुक्रम को जानते हैं और उससे प्यार करते हैं और पहले से ही उस पर चुनौती का एक दृश्य देखा है। हालाँकि, हम अभी भी एक बहुत ही सरल मामले का अभाव कर रहे हैं, जो यह उत्तर प्रदान करने वाला है: उलट रिट्रेसमेंट! इसलिए F_nअपना काम ढूंढना है n।

विशिष्टता

इनपुट

आपका इनपुट एक नॉन-निगेटिव पूर्णांक होगा, जो कि फ़्रीक्वेंसी अनुक्रम का हिस्सा होने की गारंटी है।

उत्पादन

आउटपुट एक गैर-नकारात्मक पूर्णांक होना चाहिए।

क्या करें?

परिचय ने पहले ही कहा: एक संख्या को देखते हुए, इसके सूचकांक का उत्पादन करें। Fiboancci संख्या को इसके द्वारा परिभाषित किया गया है 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

— SEJPM
स्रोत

39

थोड़ा सा निट-लेने: यह नहीं माना जाना चाहिए उलटा फिबोनैकी en.m.wikipedia.org/wiki/Inverse_function

— माइकल

19

तो, iccanobiF ?!

6

@ मिचेल यह फिबोनासी का उलटा नहीं है, क्योंकि इसमें फिबोनाची फ़ंक्शन का कोई उलटा नहीं है क्योंकि यह इंजेक्शन नहीं है (क्योंकि "1" दो बार दिखाई देता है)। रिवर्स मूल रूप से "रिवर्स टेबल लुक-अप्स" के विचार से आया था, जो कि मैं लोगों से यहां करने की उम्मीद करता था (उदाहरण के लिए मैंने उनसे समस्या को हल करने के लिए ऐसा करने की अपेक्षा की थी)।

— SEJPM

9

यहां समारोह को गैर-नकारात्मक पूर्णांकों से "फाइबोनैचि फ़ंक्शन" का एक सही व्युत्क्रम माना जा सकता है, जो कि फिबोनाची संख्याओं के सेट में है। एक सही प्रतिलोम का अस्तित्व इंजेक्शन लगाने का अर्थ नहीं है।

— डेनिस

1

@SEJPM: I थोड़े ने एक कार्य की अपेक्षा की थी जैसे "एक प्रोग्राम लिखना जो कि रिट्रेन्स सीक्वेंस को पीछे की ओर ले जाता है", हालांकि।

— बरगी

58

दरअसल, 1 बाइट

हां, 16 नवंबर, 2015 से इसके लिए एक बिलिन है ।

इसे ऑनलाइन आज़माएं

मस्ती के बिना, बिलिन के बिना, यह 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

— मेगो
स्रोत

15

मेरे पास एक विचार है और एक ही विचार है जब मैं इसे देखता हूं: ಠ_ Cr

— एडिसन क्रम्प

37

मैं वास्तव में यह नहीं समझता कि आप इस तरह के एक विशिष्ट उद्देश्य के लिए प्रतीक को "बर्बाद" क्यों करेंगे

— 19-29 को

19

@ फाइबोनैचि और व्युत्क्रम फाइबोनैचि फ़ंक्शंस पहले जोड़े गए थे, जो मैंने जोड़े थे। अब भी, 39 पूरी तरह से अप्रयुक्त एकल-बाइट आदेश हैं (और कौन जानता है कि कितने अधिभार का उपयोग किया जा सकता है)। 256 प्रतीक, इस तथ्य के साथ संयुक्त हैं कि वास्तव में 5 प्रकार हैं (पूर्णांक, वास्तविक, स्ट्रिंग, Iterable, फ़ंक्शन), इसका मतलब है कि अधिकतम 1280 संभावित कार्य और 6400 संभव द्विआधारी कार्य हैं। वहाँ एक है बहुत कुछ मालूम होता है-बेकार आदेश के लिए कमरे से।

— मेगो

23

@Mego क्या आप सिर्फ सबसे अधिक निर्माण के लिए गणितज्ञों के साथ प्रतिस्पर्धा करने की कोशिश कर रहे हैं?

— अक्टूबर को gcampbell

13

दरअसल, यह सिर्फ एक बाइट है ... लोल, इस भाषा का नाम प्यार करता हूं।

— निकेल

42

गणितज्ञ, 25 बाइट्स

InverseFunction@Fibonacci

समारोह। सुंदर आत्म-व्याख्यात्मक अगर आप मुझसे पूछें।

— LegionMammal978
स्रोत

31

पायथन, 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-बिट फिबोनैकी संख्याओं के लिए सही परिणाम देने के लिए चुना गया था।

यह 32 बाइट्स होना चाहिए, क्योंकि f=गिना नहीं जाता है।

— लीक नून

2

जैसा कि पहले से ही ऊपर कहा गया है, अनाम फ़ंक्शन / अनाम लैंबडास डिफ़ॉल्ट रूप से अनुमत हैं । इसके अलावा, यदि आप अपने उत्तर को पायथन 2 तक सीमित रखते हैं और लंबे तर्क की आवश्यकता है , lambda n:~-len(`66*n**6`)//1.24तो काम करना चाहिए।

— डेनिस

19

05AB1E , 3 बाइट्स

कोड:

ÅFg

स्पष्टीकरण:

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

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

— अदनान
स्रोत

10

जेली, 14 11 बाइट्स

5½×lØp+.Ḟ»0

इसे ऑनलाइन आज़माएं!

यह मेरा पहला जेली उत्तर है! यह MATL उत्तर से एल्गोरिथ्म का उपयोग करता है । 3 बाइट्स से शेविंग करने के लिए डेनिस को धन्यवाद!

स्पष्टीकरण:

   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.

— DJMcMayhem
स्रोत

7

+1 क्योंकि स्पष्टीकरण पर टिप्पणी एक सीमा का अंत है।

— डैनियल

10

जूलिया, 27 26 18 बाइट्स

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

यह Binet के सूत्र के व्युत्क्रम का उपयोग करता है , 32-बिट पूर्णांक के लिए पर्याप्त सटीकता के साथ; यह वास्तव में F (153) = 42,230,279,526,998,466,217,810,220,532,898> 2 ¹⁰⁵ तक काम करता है ।

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

बिनेट का सूत्र निम्नलिखित बताता है।

बिनेट का सूत्र

एफ को फिबोनाची के सेट पर प्रतिबंधित करते हुए, नक्शे n → F _n का दायां उलटा F → n _{F है} ।

हमारे पास वह है

बिनेट के फार्मूले का सही उलटा

और जो कुछ करने के लिए छोड़ दिया जाता है बढ़त मामले से निपटने है 0 ।

चूंकि इनपुट 32-बिट पूर्णांक तक सीमित है, इसलिए हम सूत्र में स्थिरांक के बजाय लघु दशमलव शाब्दिक का उपयोग कर सकते हैं।

लॉग 48 = 0.481211825059603447… φ 0.48

दुर्भाग्य से, 0.5 सटीक पर्याप्त नहीं है।
√5 = 2.2360679774997896964 ... 23 3

यह पहली नज़र में एक भयंकर सन्निकटन की तरह लग सकता है, लेकिन हम लघुगणक ले रहे हैं और लॉग 3 के बाद से - लॉग 295 = 0.29389333245105… , गोलाई से पहले परिणाम एक छोटे से स्थिर कारक द्वारा बंद हो जाएगा।
0.5 ≈ 0.7

पिछले सन्निकटन से अधिक होने के कारण, हम वास्तव में इस शब्द को पूरी तरह से छोड़ सकते हैं और फिर भी F> 0 के लिए सही परिणाम प्राप्त कर सकते हैं । हालाँकि, यदि F = 0 है , तो लघुगणक अपरिभाषित होगा। 0.7 सबसे छोटा मान निकला जो हमारे सूत्र को F = 0 तक बढ़ाता है ।

— डेनिस
स्रोत

8

जावास्क्रिप्ट, 54 50 69 50 42 बाइट्स

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

निश्चित रूप से यह जीतने के लिए नहीं है, सिर्फ मनोरंजन के लिए :)

~~ठीक है, शून्य के लिए जाँच 19 बाइट्स का उपभोग करती है। WTF?~~ मूर्ख में।

डेमो! अंतिम परीक्षण मामले को देखने के लिए, आपको कंसोल को थोड़ा स्क्रॉल करना होगा।

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 बाइट से छोटा करने के लिए धन्यवाद।

— nicael
स्रोत

सरल b=>{for(j=1,i=c=0;b-i;c++)i=j+(j=i);return c}45, गोल्फ b=>(j=>{for(i=c=0;b-i;c++)i=j+(j=i)})(1)|c42.

— edc65

1

@edc वाह, यह चतुर है, धन्यवाद <3

— nicael

8

पर्ल 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

— ब्रैड गिल्बर्ट b2gills
स्रोत

1

आप first *==$_बस के साथ बदल सकते हैं first $_, क्योंकि एक नंबर एक मान्य स्मार्ट-मैचर है।

— SMLS

...इसके बजाय ऑपरेटर का उपयोग करके 24 बाइट्सfirst

— जो किंग

7

जेली , 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.

— डेनिस
स्रोत

6

पाइके, 5 बाइट्स

.f.bq

यहाँ यह कोशिश करो!

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

— नीला
स्रोत

5

पायथन, 29 बाइट्स

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

पुनरावर्ती रूप से इनपुट को स्वर्ण-अनुपात सन्निकटन 1.61 से विभाजित करता है जब तक कि यह 0.7 से नीचे नहीं हो जाता है, और विभाजन की संख्या को आउटपुट करता है।

0 के लिए, कोड आउटपुट False, जो पायथन में 0 के बराबर है । इससे 2 बाइट्स से बचा जा सकता है

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

— XNOR
स्रोत

4

जावास्क्रिप्ट (ईएस 6), 39 33 बाइट्स

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

ईएस 7 के साथ, उलटा बायनेट सूत्र 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

— नील
स्रोत

बस वितरित करें logऔर सभी स्थिरांक को पूर्वस्थापित करें ...

— चार्ली

IMHO, यदि आप नाम से लंबरदार कॉल करते हैं, तो आपको f(n,k,j+k)असाइनमेंट शामिल करना चाहिए f=और इसे +2 बाइट्स के रूप में गिनना चाहिए । अनाम लैम्ब्डा के लिए नियम यहां लागू नहीं होना चाहिए।

— चार्ली

@charlie क्षमा करें, मैं हमेशा इसके बारे में भूल गया था। फिक्स्ड।

— नील

4

ऋषि, 49 बाइट्स

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

बचत के बारे में सुझाव के लिए TuukkaX के लिए धन्यवाद sqrt(5)के रूप में sकुछ बाइट्स बंद दाढ़ी बनाने के लिए।

इसे ऑनलाइन आज़माएं ।

बिनेट के फार्मूले के व्युत्क्रम का उपयोग करते हुए यह दृष्टिकोण पिछले दृष्टिकोण पर कई सुधार प्रदान करता है: यह तेज़ है (निरंतर-समय बनाम द्विघात समय), यह वास्तव में बड़े इनपुट के लिए काम करता है, और यह छोटा है!

पायथन उपयोगकर्ता आश्चर्यचकित हो सकते हैं कि मैं sqrt(5)छोटे के बजाय क्यों उपयोग कर रहा हूं 5**.5- यह इसलिए 5**.5है क्योंकि सी के powफ़ंक्शन के साथ गणना की जाती है , और फ्लोटिंग मुद्दों के कारण सटीक खो देता है। (सहित कई गणितीय कार्य sqrtऔर log) साधु में अतिभारित रहे हैं एक सटीक, प्रतीकात्मक मूल्य है, जो नहीं है परिशुद्धता खो वापस जाने के लिए।

— मेगो
स्रोत

मैं ऋषि को बिल्कुल नहीं जानता, लेकिन क्या आप sqrt(5)एक चर में पकड़कर बाइट्स बचा सकते हैं और दो बार टाइप करने के बजाय दो बार इसका इस्तेमाल कर सकते हैं sqrt(5)?

— यति

4

MATL , 14 बाइट्स

t?5X^*17L&YlYo

इसे ऑनलाइन आज़माएं!

यह Binet के सूत्र के व्युत्क्रम का उपयोग करता है , और इसलिए यह बहुत तेज़ है।

Let एफ निरूपित n फाइबोनैचि संख्या वें, और φ सुनहरे अनुपात । फिर

कोड दो संशोधनों के साथ इस सूत्र का उपयोग करता है:

1/2 जोड़ने और फिर नीचे राउंड करने के बजाय, कोड केवल निकटतम पूर्णांक की ओर बढ़ता है, जो कम बाइट्स लेता है।
इनपुट एफ = 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

— लुइस मेंडो
स्रोत

1

वैकल्पिक दृष्टिकोण:O1G:"yy+]vGmfq

— DJMcMayhem

1

11 बाइट्स:t?17L&YlXkQ

— jimmy23013

@ jimmy23013 अच्छा तरीका! आपको निश्चित रूप से एक अलग उत्तर के रूप में पोस्ट करना चाहिए

— लुइस मेंडो

मुझे नहीं लगता कि यह एक और जवाब के लायक है, क्योंकि यह सिर्फ हटाने का एक तरीका है 5X^*। ( मैंने पहले भी ऐसा किया है ।) और मैं MATL को नहीं जानता कि संभवतः इसे सुधारते रहें।

— jimmy23013

3

पायथन, 38 बाइट्स

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

Ideone पर इसका परीक्षण करें ।

— डेनिस
स्रोत

3

जावास्क्रिप्ट, 22 बाइट्स

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

— चार्ली
स्रोत

मुझे नहीं लगा कि जब मैंने इसे देखा तो यह काम करेगा, लेकिन स्पष्ट रूप -Infinity|0से 0जावास्क्रिप्ट में है। जाओ पता लगाओ।

— डेनिस

@ डेनिस: जेएस में, बिटवाइज़ ऑपरेटर्स केवल 32 बिट्स और पिछले लेते हैं -Infinity = FFF00000 00000000। मुझे यह पता लगाने में खुशी हुई कि यह एक स्पष्ट शून्य परीक्षण की तरह नहीं होने के लिए 3 बाइट्स को बख्शता है n&&। इसके अलावा, का मुख्य उद्देश्य ( जूलिया की तरह ) के |0लिए एक विकल्प है । Math.trunc()÷

— चार्ली

3

सी, 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);
}

— Khaled.K
स्रोत

3

जावा 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

— dainichi
स्रोत

2

PPCG में आपका स्वागत है, अच्छा पहला जवाब!

— लीक नून

int c(int n){int a=0,b=1,c=0,t;for(;a<n;t=b,b+=a,a=t)c++;return c;}(परीक्षण नहीं किया गया)

— लीक नून

int c(int n){int a=0,b=1,c=0;while(a<n){c++;b+=a;a=b-a;}return c;}(परीक्षण नहीं किया गया)

— लीक नून

2

int c(int n){int a=0,b=1,c=0;for(;a<n;b+=a,a=b-a)c++;return c;}(परीक्षण नहीं किया गया)

— लीक

2

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

— Liesel
स्रोत

2

हास्केल, 45 बाइट्स

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

— डेमियन
स्रोत

2

सेसोस , 28 बाइट्स

Hexdump:

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

इसे ऑनलाइन आज़माएं!

(घातीय समय क्योंकि Sosos में एक संख्या की नकल घातीय समय की जरूरत है।)

बाइनरी फ़ाइल उत्पन्न करने के लिए असेंबली का उपयोग किया जाता है:

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

— लीक नन
स्रोत

2

जावा 8 61 बाइट्स

@Dainichi के उत्तर के समान ही जावा 8 लैम्ब्डा का उपयोग करके कम किया गया। इसका उत्तर एक मान्य अंतराल अभिव्यक्ति है।

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
स्रोत

1

पायथ, 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उलटा उपयोग करता है।

— लीक नन
स्रोत

1

जावा 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);}

@ अदनान के 05AB1E उत्तर की व्याख्या से प्रेरित ।

अनगढ़ और परीक्षण के मामले:

इसे यहाँ आज़माएँ। (अंतिम परीक्षण के मामले में समय सीमा पार हो गई, लेकिन यह मेरे पीसी पर लगभग 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));
  }
}

आउटपुट:

— केविन क्रूज़सेन
स्रोत

1

पर्ल 5.10, 48 बाइट्स

मूल रूप से सही की तलाश है nताकि F(n) = input।

-a स्विच एक बाइट जोड़ता है।

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

यहाँ यह कोशिश करो!

— पॉल पिकार्ड
स्रोत

1

जे, 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

— मील की दूरी पर
स्रोत

1

गणितज्ञ, 30 बाइट्स

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

शुद्ध कार्य; यदि इनपुट 1 है तो 2 रिटर्न।

अन्य गणितज्ञ प्रविष्टि को हरा नहीं करता है, लेकिन एक असामान्य तरीका दिखाता है: यह एक (बहुत अच्छा) तथ्य है कि Nth फाइबोनैचि संख्या स्वर्ण अनुपात के Nth शक्ति के [1 / sqrt (5) गुना के निकटतम पूर्णांक है (") बिनेट का सूत्र ")।

इसलिए उलटा कार्य आधार होगा- [सुनहरा अनुपात] लघुगणक [प्रश्न में फिबोनाची संख्या] का [5 बार]। यह .8+सुनिश्चित करने के लिए एक हैक है कि हम अन्य मानों को खराब किए बिना, 0 का लघुगणक नहीं लेते हैं।

— ग्रेग मार्टिन
स्रोत

1

जाप , 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

— ओलिवर
स्रोत

1

ब्रेकीलॉग , 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.

मुझे पूरी तरह से यकीन नहीं है कि क्यों ≜आवश्यक है।

— असंबंधित स्ट्रिंग
स्रोत

0

जावास्क्रिप्ट (बाहरी पुस्तकालय का उपयोग करके) (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

लिंक करने के लिए लिंक: https://github.com/mvegh1/Enumerable

कोड स्पष्टीकरण: लाइब्रेरी में स्थैतिक विधि है जो एक अनुक्रम बनाती है जब तक कि विधेय का अपरिभाषित रिटर्न वैल्यू नहीं होता। विधेय में ("i" ndex, वर्तमान आंतरिक "a" rray जेनरेट) का हस्ताक्षर है। प्रत्येक पुनरावृत्ति पर, हम जांचते हैं कि आंतरिक सरणी का अंतिम तत्व इनपुट के बराबर है या नहीं। यदि नहीं, तो फ़ाइबर अनुक्रम में अगला मान लौटाएँ। अन्यथा, विधेय का एक अपरिभाषित परिणाम होता है जो अनुक्रम की पीढ़ी को समाप्त कर देता है। फिर, हम अनुक्रम की लंबाई वापस करते हैं (और 0 पर आधारित 0 के अनुसार पालन करने के लिए 1 घटाते हैं जैसा कि ओपी में देखा गया है

— applejacks01
स्रोत

यहाँ से कोड का उपयोग करके 53 बाइट्स n=>{a=c=t=0,b=1;while(a<n){c++;t=b;b+=a;a=t}return c} इसे ऑनलाइन आज़माएं!

— pixma140

फिबोनाची उलट गया!

परिचय

विशिष्टता

इनपुट

उत्पादन

क्या करें?

संभावित कॉर्नर मामले

किसी जीत?

परीक्षण के मामलों

दरअसल, 1 बाइट

गणितज्ञ, 25 बाइट्स

पायथन, 36 34 32 बाइट्स

पिछला संस्करण:

व्याख्या

05AB1E , 3 बाइट्स

जेली, 14 11 बाइट्स

जूलिया, 27 26 18 बाइट्स

यह काम किस प्रकार करता है

जावास्क्रिप्ट, 54 50 69 50 42 बाइट्स

पर्ल 6 33 30 27 बाइट्स

स्पष्टीकरण:

परीक्षा:

जेली , 8 बाइट्स

यह काम किस प्रकार करता है

पाइके, 5 बाइट्स

पायथन, 29 बाइट्स

जावास्क्रिप्ट (ईएस 6), 39 33 बाइट्स

ऋषि, 49 बाइट्स

MATL , 14 बाइट्स

यह कैसे किया है

पायथन, 38 बाइट्स

जावास्क्रिप्ट, 22 बाइट्स

सी, 62 58 बाइट्स

जावा 7, 70 बाइट्स

TSQL, 143 बाइट्स

हास्केल, 45 बाइट्स

सेसोस , 28 बाइट्स

जावा 8 61 बाइट्स

पायथ, 13 बाइट्स

वैकल्पिक दृष्टिकोण, 18 बाइट्स

जावा 7, 89 बाइट्स

पर्ल 5.10, 48 बाइट्स

जे, 32 27 17 बाइट्स

प्रयोग

व्याख्या

गणितज्ञ, 30 बाइट्स

जाप , 10 बाइट्स

व्याख्या

ब्रेकीलॉग , 14 बाइट्स

जावास्क्रिप्ट (बाहरी पुस्तकालय का उपयोग करके) (84 बाइट्स)