फाइबोनैचि अनुक्रम की कम्प्यूटेशनल जटिलता

Question

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

int Fibonacci(int n)
{
    if (n <= 1)
        return n;
    else
        return Fibonacci(n - 1) + Fibonacci(n - 2);
}

फाइबोनैचि अनुक्रम की कम्प्यूटेशनल जटिलता क्या है और इसकी गणना कैसे की जाती है?

Comments

यहाँ अच्छा जवाब।

— ग्रेग

यहां मैट्रिक्स फॉर्म सेक्शन देखें: en.wikipedia.org/wiki/Fibnote_number । इस मैट्रिक्स ^ n (एक चतुर तरीके से) करके आप O (lg n) में Fib (n) की गणना कर सकते हैं। चाल शक्ति कार्य करने में है। इस सटीक समस्या के बारे में iTunesU पर एक बहुत अच्छा व्याख्यान और ओ (lg n) में हल करने के लिए कैसे। यह कोर्स MIT लेक्चर 3 के एल्गोरिदम से शुरू होता है (इसकी निरपेक्षता मुफ्त है तो इसे देखें कि क्या आप रुचि रखते हैं)

— Aly

उपरोक्त टिप्पणियों में से कोई भी प्रश्न को संबोधित नहीं करता है, जो कि भोले संस्करण (पोस्ट कोड में) की कम्प्यूटेशनल जटिलता के बारे में है, मैट्रिक्स फॉर्म या गैर-पुनरावर्ती संगणना जैसे चालाक संस्करणों के बारे में नहीं।

— जोश मिल्थोरपे ने

एक बहुत अच्छा वीडियो यहाँ जो दोनों निम्न बाउंड जटिलता (2 ^ n / 2) और पुनरावर्ती कार्यान्वयन की ऊपरी सीमा जटिलता (2 ^ n) के बारे में बात करती है।

— RBT

एक साइड-नोट क्वेरी: क्या फिबोनाची श्रृंखला का अनुभवहीन कार्यान्वयन पुनरावृत्ति या पुनरावर्ती होना चाहिए ?

— RBT

Answer 1

आप Fib(n)समय की गणना करने के Fib(n-1)लिए समय की गणना के Fib(n-2)साथ-साथ उन्हें जोड़ने के लिए समय और साथ में जोड़ने के लिए समय फ़ंक्शन को मॉडल करते हैं ( O(1))। यह मानकर चल रहा है कि एक ही के बार-बार मूल्यांकन में एक Fib(n)ही समय लगता है - अर्थात कोई भी संस्मरण उपयोग नहीं होता है।

T(n<=1) = O(1)

T(n) = T(n-1) + T(n-2) + O(1)

आप इस पुनरावृत्ति संबंध (उदाहरण के लिए, फ़ंक्शन का उपयोग करके) को हल करते हैं और आप उत्तर के साथ समाप्त हो जाएंगे।

वैकल्पिक रूप से, आप पुनरावर्तन वृक्ष को आकर्षित कर सकते हैं, जिसमें गहराई nऔर सहज रूप से यह पता चलेगा कि यह फ़ंक्शन स्पर्शोन्मुख है । फिर आप प्रेरण द्वारा अपने अनुमान को सिद्ध कर सकते हैं।O(2n)

आधार: n = 1स्पष्ट है

मान लें , इसलिएT(n-1) = O(2n-1)

T(n) = T(n-1) + T(n-2) + O(1) जो के बराबर है

T(n) = O(2n-1) + O(2n-2) + O(1) = O(2n)

हालांकि, जैसा कि एक टिप्पणी में कहा गया है, यह तंग बाध्य नहीं है। इस फ़ंक्शन के बारे में एक दिलचस्प तथ्य यह है कि टी (एन) समान रूप से समान है Fib(n)क्योंकि दोनों को परिभाषित किया गया है

f(n) = f(n-1) + f(n-2)।

पुनरावर्तन वृक्ष की पत्तियां हमेशा वापस आ जाएंगी 1. Fib(n)पुनरावर्तन वृक्ष में पत्तियों द्वारा लौटाए गए सभी मूल्यों का योग है जो पत्तियों की गिनती के बराबर है। चूंकि प्रत्येक पत्ती गणना करने के लिए O (1) लेगी, T(n)के बराबर है Fib(n) x O(1)। नतीजतन, इस फ़ंक्शन के लिए तंग बाध्य स्वयं फाइबोनैचि अनुक्रम है (~ )। जैसा कि मैंने ऊपर उल्लेख किया है, आप जनरेटिंग फ़ंक्शंस का उपयोग करके इस तंग बाउंड का पता लगा सकते हैं।θ(1.6n)

Comments

इसके अलावा प्रेरण द्वारा सबूत। अच्छा लगा। +1

— एंड्रयू रोलिंग्स

हालांकि बाउंड टाइट नहीं है।

— कैप्टन सेगफॉल्ट

@ कैप्टन सेगफॉल्ट: हाँ। मैंने जवाब स्पष्ट किया। जैसा कि मैंने ऊपर लिखा था, आपको GF विधि का उपयोग करके तंग बाउंड मिलेगा।

— मेहरदाद आफश्री

एक मजाक के रूप में अपने StackOverflowException को इटेक करें। घातांक समय n के लिए छोटे मूल्यों के साथ काफी आसानी से समझ में आता है।

— डेविड रॉड्रिग्ज - 23

"वैकल्पिक रूप से, आप पुनरावर्ती वृक्ष को आकर्षित कर सकते हैं, जिसमें गहराई n और सहज रूप से यह पता चलेगा कि यह फ़ंक्शन asymptotically O (2n) है।" - यह पूरी तरह से झूठ है। समय की जटिलता हे (Golden_ratio ^ n)। यह कभी भी O (2 ^ n) के करीब नहीं आता है। यदि आप अनंत की ओर पहुंच सकते हैं तो यह O (Golden_ratio ^ n) के करीब पहुंच जाएगा। यह एक ऐसा उदाहरण है, दो पंक्तियों के बीच की दूरी 0.

— bob

Answer 2

बस अपने आप से पूछें कि कितने बयानों F(n)को पूरा करने के लिए निष्पादित करने की आवश्यकता है ।

के लिए F(1), उत्तर है 1(सशर्त का पहला भाग)।

के लिए F(n), उत्तर है F(n-1) + F(n-2)।

तो क्या फ़ंक्शन इन नियमों को संतुष्ट करता है? ^N (a> 1) आज़माएँ :

a ⁿ == a ^(n-1) + a ^(n-2)

^(N-2) से विभाजित करें :

एक ² == ए + 1

हल करें aऔर आप प्राप्त करें (1+sqrt(5))/2 = 1.6180339887, अन्यथा सुनहरे अनुपात के रूप में जाना जाता है ।

इसलिए यह घातीय समय लेता है।

Comments

प्रेरण द्वारा प्रमाण। अच्छा लगा। +1

— एंड्रयू रोलिंग

एक गलत जवाब के लिए 30 upvotes? :-) क्या यह अनुसरण करता है कि 1 = F (1) = (1 + sqrt (5)) / 2? और अन्य समाधान के बारे में क्या, (1-sqrt (5)) / 2?

— कार्सटन एस

नहीं, 1 1 + 1 के बराबर नहीं है। यह फ़ंक्शन उन नियमों पर व्यंग्य करता है जिनका उल्लेख प्रश्न में किया गया है।

— मोलबेडनिलो

उत्तर गलत नहीं है। यह उचित रूप से सही है। अन्य समाधान नकारात्मक है इसलिए शारीरिक रूप से समझ में नहीं आता है।

— दा टेंग

क्या कोई समझा सकता है कि एक ^ n == a ^ (n-1) + a ^ (n-2) इन नियमों को संतुष्ट करता है? यह वास्तव में कैसे संतुष्ट है, कृपया विशिष्ट रहें।

— फ्रैंक

Answer 3

मैं pgaur और rickerbh के साथ सहमत हूँ, पुनरावर्ती-रिट्रेसमेंट की जटिलता O (2 ^ n) है।

मैं नहीं बल्कि सरलीकृत द्वारा एक ही निष्कर्ष पर आया था लेकिन मेरा मानना ​​है कि अभी भी मान्य तर्क है।

सबसे पहले, यह पता लगाने के बारे में है कि Nth रिटेलर संख्याओं की गणना करते समय कितनी बार पुनरावर्ती फ़ुटबॉल फ़ंक्शन (अब से) कहा जाता है। यदि इसे 0 से n के क्रम में प्रति बार एक बार कॉल किया जाता है, तो हमारे पास O (n) है, अगर इसे प्रत्येक संख्या के लिए n बार कहा जाता है, तो हमें O (n * n), या O (n ^ 2) मिलता है। और इसी तरह।

इसलिए, जब F () को नंबर n के लिए कहा जाता है, तो F और () को 0 के बीच दिए गए नंबर के लिए कहा जाता है, जबकि हम 0 के करीब आते हैं।

पहली धारणा के रूप में, यह मुझे लगता है कि अगर हम इसे एक दृश्य तरीके से डालते हैं, तो प्रति बार एफ () प्रति यूनिट एक ड्राइंग को एक दी गई संख्या के लिए कहा जाता है, गीले को एक प्रकार का पिरामिड आकार मिलता है (अर्थात, अगर हम इकाइयों को क्षैतिज रूप से केंद्र में रखते हैं। )। कुछ इस तरह:

n              *
n-1            **
n-2           ****  
...
2           ***********
1       ******************
0    ***************************

अब, सवाल यह है कि n के बढ़ते ही इस पिरामिड का आधार कितना तेज है?

चलो एक वास्तविक मामला लेते हैं, उदाहरण के लिए एफ (6)

F(6)                 *  <-- only once
F(5)                 *  <-- only once too
F(4)                 ** 
F(3)                ****
F(2)              ********
F(1)          ****************           <-- 16
F(0)  ********************************    <-- 32

हम देखते हैं कि एफ (0) को 32 बार कहा जाता है, जो 2 ^ 5 है, जो इस नमूना मामले के लिए 2 ^ (n-1) है।

अब, हम यह जानना चाहते हैं कि F (x) को कितनी बार बुलाया जाता है, और हम देख सकते हैं कि F (0) को कितनी बार बुलाया जाता है।

अगर हम मानसिक रूप से F (6) से F (2) की सभी लाइनों को F (1) लाइन में ले जाते हैं, तो हम देखते हैं कि F (1) और F (0) लाइनें अब लंबाई में बराबर हैं। जिसका अर्थ है, कुल समय F () कहा जाता है जब n = 6 2x32 = 64 = 2 ^ 6 है।

अब, जटिलता के संदर्भ में:

O( F(6) ) = O(2^6)
O( F(n) ) = O(2^n)

Comments

F (3) को केवल 3 बार कहा जाता है और 4 बार नहीं। दूसरा पिरामिड गलत है।

— अविक

एफ (3) = 3, एफ (2) = 5, एफ (1) = 8, एफ (0) = 5. मैं इसे ठीक कर दूंगा, लेकिन मुझे नहीं लगता कि मैं इस उत्तर को एक संपादन के साथ निस्तारण कर सकता हूं।

— बर्नहार्ड बार्कर

Answer 4

MIT में इस विशिष्ट समस्या पर बहुत अच्छी चर्चा हुई । पृष्ठ 5 पर, वे इस बिंदु को बनाते हैं कि, यदि आप मानते हैं कि एक जोड़ एक कम्प्यूटेशनल इकाई लेता है, तो फाइब (एन) की गणना करने के लिए आवश्यक समय फिब (एन) के परिणाम से बहुत निकट से संबंधित है।

नतीजतन, आप सीधे फाइबोनैचि श्रृंखला के बहुत करीब सन्निकटन को छोड़ सकते हैं:

Fib(N) = (1/sqrt(5)) * 1.618^(N+1) (approximately)

इसलिए, कहा जाता है कि भोली एल्गोरिथ्म का सबसे खराब मामला प्रदर्शन है

O((1/sqrt(5)) * 1.618^(N+1)) = O(1.618^(N+1))

पुनश्च: यदि आप अधिक जानकारी चाहते हैं तो विकिपीडिया पर Nth फाइबोनैचि संख्या के बंद स्वरूप की चर्चा है ।

Comments

कोर्स लिंक के लिए धन्यवाद। बहुत अच्छा अवलोकन भी

— SwimBikeRun

Answer 5

आप इसका विस्तार कर सकते हैं और एक विज़ुअलाइज़ेशन कर सकते हैं

     T(n) = T(n-1) + T(n-2) <
     T(n-1) + T(n-1) 

     = 2*T(n-1)   
     = 2*2*T(n-2)
     = 2*2*2*T(n-3)
     ....
     = 2^i*T(n-i)
     ...
     ==> O(2^n)

Comments

मैं पहली पंक्ति को समझता हूं। लेकिन <अंत में चरित्र से कम क्यों है ? आपको कैसे मिली T(n-1) + T(n-1)?

— क़ाज़ी इरफ़ान

@QuaziIrfan: D जो एक तीर है। -> [(से कम नहीं)। अंतिम पंक्ति के संबंध में भ्रम के लिए क्षमा करें]। पहली पंक्ति के लिए, अच्छी तरह से ... T(n-1) > T(n-2)इसलिए मैं बदल सकता हूं T(n-2)और डाल सकता हूं T(n-1)। मैं केवल एक उच्च सीमा प्राप्त करूंगा जो अभी भी मान्य हैT(n-1) + T(n-2)

— टोनी टैनस

Answer 6

यह 2^(n/2)2 ^ n से ऊपरी छोर पर और ऊपरी छोर पर (जैसा कि अन्य टिप्पणियों में उल्लेख किया गया है) से घिरा हुआ है । और उस पुनरावर्ती क्रियान्वयन का एक दिलचस्प तथ्य यह है कि इसमें फिब (एन) का एक तंग स्पर्शोन्मुख बंधन है। इन तथ्यों को संक्षेप में प्रस्तुत किया जा सकता है:

T(n) = Ω(2^(n/2))  (lower bound)
T(n) = O(2^n)   (upper bound)
T(n) = Θ(Fib(n)) (tight bound)

यदि आप चाहें तो इसके बंद रूप का उपयोग करके तंग बाउंड को और कम किया जा सकता है ।

Answer 7

सबूत के जवाब अच्छे हैं, लेकिन मुझे हमेशा खुद को समझाने के लिए हाथ से कुछ पुनरावृत्तियों करना होगा। इसलिए मैंने अपने व्हाइटबोर्ड पर एक छोटा सा कॉलिंग ट्री उतारा, और नोड्स गिनना शुरू किया। मैंने अपनी संख्याओं को कुल नोड्स, लीफ नोड्स और आंतरिक नोड्स में विभाजित किया। यहाँ मुझे क्या मिला है:

IN | OUT | TOT | LEAF | INT
 1 |   1 |   1 |   1  |   0
 2 |   1 |   1 |   1  |   0
 3 |   2 |   3 |   2  |   1
 4 |   3 |   5 |   3  |   2
 5 |   5 |   9 |   5  |   4
 6 |   8 |  15 |   8  |   7
 7 |  13 |  25 |  13  |  12
 8 |  21 |  41 |  21  |  20
 9 |  34 |  67 |  34  |  33
10 |  55 | 109 |  55  |  54

क्या तुरंत छलांग लगाता है कि पत्ती नोड्स की संख्या है fib(n)। यह देखने के लिए कुछ और पुनरावृत्तियों पर ध्यान दिया गया कि आंतरिक नोड की संख्या कितनी है fib(n) - 1। इसलिए नोड्स की कुल संख्या है 2 * fib(n) - 1।

चूंकि आप कम्प्यूटेशनल जटिलता को वर्गीकृत करते हुए गुणांक को छोड़ देते हैं, इसलिए अंतिम उत्तर है θ(fib(n))।

Comments

(नहीं, मैंने अपने व्हाइटबोर्ड पर पूर्ण 10-गहरी कॉल ट्री नहीं खींची। सिर्फ 5-गहरी।);)

— बेन्क

अच्छा, मैं सोच रहा था कि फ़िश ने कितने अतिरिक्त परिवर्धन किए। यह सिर्फ 1एक ही संचायक Fib(n)समय को नहीं जोड़ रहा है , लेकिन दिलचस्प है कि यह अभी भी ठीक है θ(Fib(n))।

— पीटर कॉर्डेस

ध्यान दें कि कुछ (अधिकांश) पुनरावर्ती कार्यान्वयन समय जोड़ने में खर्च करते हैं 0, हालांकि: पुनरावर्तन आधार मामले हैं 0और 1, क्योंकि वे करते हैं Fib(n-1) + Fib(n-2)। तो शायद 3 * Fib(n) - 2से इस लिंक-केवल जवाब नोड्स की कुल संख्या, नहीं करने के लिए और अधिक सटीक है 2 * Fib(n) - 1।

— पीटर कॉर्डेस

मुझे लीफ नोड्स पर समान परिणाम नहीं मिल सकते हैं। 0 से शुरू: एफ (0) -> 1 पत्ती (खुद); एफ (1) -> 1 पत्ती (खुद); एफ (2) -> 2 लीफ़्स (एफ (1) और एफ (0)); एफ (3) -> 3 लीफ़्स; एफ (5) -> 8 लीफ़्स; आदि

— अलेक्सलोमा87

Answer 8

पुनरावर्ती एल्गोरिथ्म की समय जटिलता का अनुमान पुनरावर्तन वृक्ष के चित्रण से बेहतर लगाया जा सकता है, इस स्थिति में आवर्तन वृक्ष के पुनरावृत्ति संबंध T (n) = T (n-1) + T (n-2) + O (1) ध्यान दें प्रत्येक चरण O (1) का अर्थ निरंतर समय लेता है, क्योंकि यह ब्लॉक में यदि n के मूल्य की जांच करने के लिए केवल एक तुलना करता है। सुरक्षा की तरह होगा

          n
   (n-1)      (n-2)
(n-2)(n-3) (n-3)(n-4) ...so on

यहां बता दें कि उपरोक्त पेड़ के प्रत्येक स्तर को मैंने इसलिए निरूपित किया है,

i
0                        n
1            (n-1)                 (n-2)
2        (n-2)    (n-3)      (n-3)     (n-4)
3   (n-3)(n-4) (n-4)(n-5) (n-4)(n-5) (n-5)(n-6)

आइ के विशेष मूल्य पर कहते हैं, पेड़ समाप्त होता है, यह मामला तब होगा जब नी = 1, इसलिए मैं = एन -1, जिसका अर्थ है कि पेड़ की ऊंचाई एन -1 है। अब देखते हैं कि पेड़ में प्रत्येक एन लेयर के लिए कितना काम किया जाता है। ध्यान दें कि पुनरावृत्ति संबंध में कहा गया है कि प्रत्येक चरण में ओ (1) समय लगता है।

2^0=1                        n
2^1=2            (n-1)                 (n-2)
2^2=4        (n-2)    (n-3)      (n-3)     (n-4)
2^3=8   (n-3)(n-4) (n-4)(n-5) (n-4)(n-5) (n-5)(n-6)    ..so on
2^i for ith level

चूंकि i = n-1 प्रत्येक स्तर पर किए गए वृक्ष कार्य की ऊंचाई होगी

i work
1 2^1
2 2^2
3 2^3..so on

इसलिए किए गए कुल कार्य प्रत्येक स्तर पर किए गए कार्य का योग होगा, इसलिए यह i = n-1 के बाद से 2 ^ 0 + 2 ^ 1 + 2 ^ 2 + 2 ^ 3 ... + 2 ^ (n-1) होगा। ज्यामितीय श्रृंखला द्वारा यह योग 2 ^ n है, इसलिए यहाँ कुल समय जटिलता O (2 ^ n) है

Answer 9

मेरे अनुसार, O(2^n)जैसा कि इस कार्य में है, केवल पुनरावृत्ति में काफी समय लग रहा है (विभाजित और जीत)। हम देखते हैं कि, उपरोक्त कार्य एक पेड़ में तब तक जारी रहेगा जब तक कि पत्तियां हमारे स्तर तक नहीं पहुँच F(n-(n-1))जातीं F(1)। इसलिए, यहां जब हम पेड़ की प्रत्येक गहराई पर समय जटिलता का सामना करते हैं, तो सारांश श्रृंखला है:

1+2+4+.......(n-1)
= 1((2^n)-1)/(2-1)
=2^n -1

यह आदेश है 2^n [ O(2^n) ]।

Answer 10

गणना में पुनरावृत्ति के कारण डिजाइन द्वारा फिबोनाची के भोले पुनरावर्तन संस्करण का विस्तार किया गया है:

मूल पर आप गणना कर रहे हैं:

एफ (एन) एफ (एन -1) और एफ (एन -2) पर निर्भर करता है

एफ (एन -1) फिर से एफ (एन -2) पर निर्भर करता है और एफ (एन -3)

एफ (एन -2) फिर से एफ (एन -3) पर निर्भर करता है और एफ (एन -4)

फिर आप प्रत्येक स्तर पर 2 पुनरावर्ती कॉल कर रहे हैं जो गणना में बहुत अधिक डेटा बर्बाद कर रहे हैं, समय समारोह इस तरह दिखेगा:

T (n) = T (n-1) + T (n-2) + C, C स्थिरांक के साथ

T (n-1) = T (n-2) + T (n-3)> T (n-2) तब

T (n)> 2 * T (n-2)

...

T (n)> 2 ^ (n / 2) * T (1) = O (2 ^ (n / 2))

यह केवल एक कम बाध्य है कि आपके विश्लेषण के उद्देश्य के लिए पर्याप्त होना चाहिए लेकिन वास्तविक समय फ़ंक्शन समान फाइबोनैचि सूत्र द्वारा एक स्थिरांक का कारक है और बंद रूप को सुनहरे अनुपात के घातांक के रूप में जाना जाता है।

इसके अलावा, आप इस तरह गतिशील प्रोग्रामिंग का उपयोग करके फिबोनाची के अनुकूलित संस्करण पा सकते हैं:

static int fib(int n)
{
    /* memory */
    int f[] = new int[n+1];
    int i;

    /* Init */
    f[0] = 0;
    f[1] = 1;

    /* Fill */
    for (i = 2; i <= n; i++)
    {
        f[i] = f[i-1] + f[i-2];
    }

    return f[n];
}

यह अनुकूलित है और केवल n चरण करता है, लेकिन यह भी घातीय है।

समस्या को हल करने के लिए लागत कार्य इनपुट आकार से चरणों की संख्या तक परिभाषित किए जाते हैं। जब आप फाइबोनैचि का गतिशील संस्करण देखते हैं ( तालिका की गणना करने के लिए एन कदम) या यह जानने के लिए सबसे आसान एल्गोरिथ्म है कि क्या नंबर प्राइम ( sqrt (n) संख्या के वैध विभाजकों का विश्लेषण करने के लिए है)। आप सोच सकते हैं कि ये एल्गोरिदम O (n) या O (sqrt (n)) हैं, लेकिन यह केवल निम्नलिखित कारणों से सही नहीं है: आपके एल्गोरिथ्म का इनपुट एक नंबर है: n , बाइनरी नोटेशन का उपयोग करके इनपुट आकार a पूर्णांक n है log2 (एन) तो के एक चर परिवर्तन कर

m = log2(n) // your real input size

इनपुट आकार के कार्य के रूप में चरणों की संख्या ज्ञात करें

m = log2(n)
2^m = 2^log2(n) = n

तब इनपुट आकार के एक कार्य के रूप में आपके एल्गोरिथ्म की लागत है:

T(m) = n steps = 2^m steps

और यही कारण है कि लागत एक घातीय है।

Answer 11

फ़ंक्शन कॉल को आरेखित करके गणना करना सरल है। बस n के प्रत्येक मान के लिए फ़ंक्शन कॉल्स को जोड़ें और देखें कि संख्या कैसे बढ़ती है।

बिग O O (Z ^ n) है जहां Z स्वर्णिम अनुपात है या लगभग 1.62 है।

जैसे ही हम n को बढ़ाते हैं, लियोनार्डो संख्या और फाइबोनैचि संख्या दोनों इस अनुपात में आ जाते हैं।

अन्य बिग ओ प्रश्नों के विपरीत, इनपुट में कोई परिवर्तनशीलता नहीं है और एल्गोरिथ्म के एल्गोरिथ्म और कार्यान्वयन दोनों को स्पष्ट रूप से परिभाषित किया गया है।

जटिल गणित के गुच्छा की कोई आवश्यकता नहीं है। बस फंक्शन को आरेखित करें नीचे दिए गए कॉल और संख्याओं के लिए एक फ़ंक्शन फिट करें।

या यदि आप सुनहरे अनुपात से परिचित हैं तो आप इसे इस तरह से पहचानेंगे।

यह उत्तर स्वीकृत उत्तर की तुलना में अधिक सही है जो दावा करता है कि यह f (n) = 2 ^ n तक पहुंच जाएगा। यह कभी नहीं होगा। यह f (n) = golden_ratio ^ n पर पहुंचेगा।

2 (2 -> 1, 0)

4 (3 -> 2, 1) (2 -> 1, 0)

8 (4 -> 3, 2) (3 -> 2, 1) (2 -> 1, 0)
            (2 -> 1, 0)


14 (5 -> 4, 3) (4 -> 3, 2) (3 -> 2, 1) (2 -> 1, 0)
            (2 -> 1, 0)

            (3 -> 2, 1) (2 -> 1, 0)

22 (6 -> 5, 4)
            (5 -> 4, 3) (4 -> 3, 2) (3 -> 2, 1) (2 -> 1, 0)
                        (2 -> 1, 0)

                        (3 -> 2, 1) (2 -> 1, 0)

            (4 -> 3, 2) (3 -> 2, 1) (2 -> 1, 0)
                        (2 -> 1, 0)

Comments

क्या आप स्वर्णिम अनुपात के बारे में दावे के लिए कोई स्रोत प्रदान कर सकते हैं?

— निको हसे

Answer 12

http://www.ics.uci.edu/~eppstein/161/960109.html

time (n) = 3F (n) - 2

Comments

यह भी अच्छा है यदि आप केवल एक लिंक पोस्ट करने के बजाय अपने उत्तर की व्याख्या कर सकते हैं।

— मैग्निलेक्स

कोई स्पष्टीकरण नहीं दिया गया

— कुणाल बी।