दिलचस्प पोस्ट
z- अनुक्रमणिका निश्चित स्थिति के साथ काम नहीं कर रहा है जब चेक और अनचेक अपवाद चुनने के लिए टंकिनर विजेट में एक सबप्रोसेस का रीयलटाइम आउटपुट दिखाएं स्क्रीन चमक को प्रोग्रामेटिक रूप से परिवर्तित करना (पावर विजेट के साथ) एक्सएमएल में एचटीएमएल-फ़ॉर्मेट स्ट्रिंग संसाधन से टेक्स्टव्यू टेक्स्ट सेट करें Xpath का उपयोग करते हुए एक नोड के नथ्री बच्चे को प्राप्त करें कौन सा वर्ण एक URL अमान्य बनाते हैं? क्या आप जावास्क्रिप्ट कॉलबैक की प्रतीक्षा कर सकते हैं? डेल्फी 2010 और यूनिकोड को माइग्रेट करते समय 64-बिट के लिए भी तैयार करने के लिए सभी सक्रिय एएसपी.NET सत्रों की सूची स्कला बनाम पायथन के लिए स्पार्क प्रदर्शन जावास्क्रिप्ट में चर का दायरा क्या है? थ्रैड इन पथ्रेड लाइब्रेरी कोको फली कैसे स्थापित करें? यूनिक्स में कैरिएज़ रिटर्न निकालें

पायथन में फिबोनैकी अनुक्रम कैसे लिखना

मैंने मूलतः प्रोग्राम को गलत तरीके से कोडित किया था किसी श्रेणी के बीच फिबोनैचि संख्याओं को वापस करने के बजाय (अर्थात, 1 अंक की समाप्ति संख्या 20 = केवल 1 और 20 के बीच के आंकड़े =), मैंने कार्यक्रम के लिए एक श्रेणी के बीच सभी फिबोनैचि संख्या प्रदर्शित करने के लिए लिखा है (अर्थात startNumber 1, endNumber 20 प्रदर्शित करता है = प्रथम 20 फिबोनाची संख्याएं) मैंने सोचा था कि मुझे एक निश्चित-फायर कोड था। मुझे यह भी नहीं पता कि यह क्यों हो रहा है।

startNumber = int(raw_input("Enter the start number here ")) endNumber = int(raw_input("Enter the end number here ")) def fib(n): if n < 2: return n return fib(n-2) + fib(n-1) print map(fib, range(startNumber, endNumber)) 

किसी ने मेरे भाग II में बताया (जिसे डुप्लिकेट होने के लिए बंद किया गया था – https://stackoverflow.com/questions/504193/how-to-write-the-fibonacci-sequence-in-python-part-ii ) कि मैं एक लूप का उपयोग करते हुए एक जनरेटर के माध्यम से startNumber और endNumber पास करने की आवश्यकता है। क्या कोई मुझे यह करने के लिए दिशा में मुझसे बात कर सकता है? किसी भी मदद का स्वागत है


मैं एक सीखने के प्रोग्रामर हूं और मैंने एक गड़बड़ी में थोड़ा सा चलाया है मुझे एक प्रोग्राम लिखने के लिए कहा गया है जो एक उपयोगकर्ता द्वारा शुरू की गई संख्या और अंतिम संख्या (यानी startNumber = 20 endNumber = 100 और फिबोनैचि के अनुक्रम की गणना करेगा और यह उस श्रेणी के बीच केवल संख्या प्रदर्शित करेगा)। इस चाल में इसे उपयोग करने के लिए (जो मुझे नहीं पता कि पायथन में कैसे करना है? – मैं एक समावेशी सीमा का उपयोग करने के लिए इसका मतलब मान रहा हूं?)।

मैं अब तक जो कुछ भी नहीं बल्कि वास्तविक कोडिंग है:

  • फाइब अनुक्रम सूत्र को अनंत में लिखें
  • केवल नितंब अनुक्रम से समापन संख्या को समाप्त संख्या प्रदर्शित करें।

मुझे नहीं पता है कि कहां से शुरू हो रहा है और मैं विचारों के बारे में पूछ रहा हूं या यह कैसे लिखूं में अंतर्दृष्टि है मैंने भी फाइब अनुक्रम फोरमला लिखने की कोशिश की है लेकिन मैं उस पर भी खो गया हूं।

वेब के समाधान से एकत्रित समाधान "पायथन में फिबोनैकी अनुक्रम कैसे लिखना"

विकिपीडिया पर और वोल्फैम पर फिबोनैकी अनुक्रम के बारे में बहुत सारी जानकारी है। आपके द्वारा बहुत अधिक आवश्यकता पड़ सकती है वैसे भी यह जानने के लिए एक अच्छी चीज है कि इन संसाधनों का उपयोग कैसे करें (जल्दी से यदि संभव हो) आपको क्या चाहिए।

फाइब अनुक्रम सूत्र को अनंत में लिखें

गणित में, यह एक पुनरावर्ती रूप में दिया गया है:

विकिपीडिया से फिबोनैचि

प्रोग्रामिंग में, अनंत मौजूद नहीं है आप सीधे अपनी भाषा में गणित के रूप में अनुवाद करने के लिए एक रिकर्सिव फॉर्म का उपयोग कर सकते हैं, उदाहरण के लिए पायथन में यह हो जाता है:

 def F(n): if n == 0: return 0 elif n == 1: return 1 else: return F(n-1)+F(n-2) 

इसे अपनी पसंदीदा भाषा में देखें और देखें कि इस फॉर्म में बहुत समय की आवश्यकता है क्योंकि n बड़ा हो जाता है वास्तव में, यह समय में हे (2 एन ) है

उन साइटों पर चलें जो मैंने आपके साथ जुड़ी हैं और इसे देखेंगे ( भेड़िया पर):

फिबोनासी समीकरण

यह एक को लागू करने के लिए बहुत आसान है और बहुत, बहुत तेजी से गणना करने के लिए, पायथन में:

 from math import sqrt def F(n): return ((1+sqrt(5))**n-(1-sqrt(5))**n)/(2**n*sqrt(5)) 

ऐसा करने का एक अन्य तरीका परिभाषा ( विकिपीडिया से ) का पालन करना है:

अनुक्रम की पहली संख्या 0 है, दूसरी संख्या 1 है, और प्रत्येक अनुक्रम संख्या अनुक्रम की पिछली दो संख्याओं के बराबर है, अनुक्रम 0, 1, 1, 2, 3, 5, 8 को उत्पन्न करने के लिए , आदि।

यदि आपकी भाषा हेरोटरों का समर्थन करती है तो आप ऐसा कुछ कर सकते हैं:

 def F(): a,b = 0,1 while True: yield a a, b = b, a + b 

केवल नितंब अनुक्रम से समापन संख्या को समाप्त संख्या प्रदर्शित करें।

एक बार जब आप जानते हैं कि फिबोनैचि संख्या कैसे उत्पन्न करें तो आपको संख्याओं को चक्र करना होगा और जांच लें कि क्या वे दी गई शर्तों को सत्यापित करते हैं

मान लीजिए अब आप वायु सेना (एन) को लिखा है जो फाइबोनैचि अनुक्रम के एन-वें पद को वापस देता है (जैसे कि एसक्यूआरटी (5) के साथ)

अधिकतर भाषाओं में आप ऐसा कुछ कर सकते हैं:

 def SubFib(startNumber, endNumber): n = 0 cur = f(n) while cur <= endNumber: if startNumber <= cur: print cur n += 1 cur = f(n) 

अजगर में मैं इटरेटर फॉर्म का उपयोग करूँगा और इसके लिए जाना होगा:

 def SubFib(startNumber, endNumber): for cur in F(): if cur > endNumber: return if cur >= startNumber: yield cur for i in SubFib(10, 200): print i 

मेरा सुझाव है कि आप क्या पढ़ना सीखना सीखें । प्रोजेक्ट ऑलर (इसके लिए Google) आपको ऐसा करने के लिए प्रशिक्षित करेगा: पी सौभाग्य और मज़े!

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

इस अनुक्रम में सबसे छोटा पायथनिक पीढ़ी प्राप्त करने का प्रयास करते हुए मुझे यह प्रश्न मिला (बाद में एहसास हुआ कि मैंने एक अजगर संवर्धन प्रस्ताव में एक समान एक को देखा था), और मैंने अपने विशिष्ट समाधान के साथ किसी और को नहीं देखा है (हालांकि शीर्ष उत्तर करीब हो जाता है, लेकिन अभी भी कम सुरुचिपूर्ण), तो यह है कि पहले पुनरावर्ती का वर्णन करने वाली टिप्पणियों के साथ, क्योंकि मुझे लगता है कि पाठकों को यह समझने में मदद मिल सकती है:

 def fib(): a, b = 0, 1 while True: # First iteration: yield a # yield 0 to start with and then a, b = b, a + b # a will now be 1, and b will also be 1, (0 + 1) 

और उपयोग:

 for index, fibonacci_number in enumerate(fib()): print('{i:3}: {f:3}'.format(i=index, f=fibonacci_number)) if index == 10: break 

प्रिंट:

  0: 0 1: 1 2: 1 3: 2 4: 3 5: 5 6: 8 7: 13 8: 21 9: 34 10: 55 

(एट्रिब्यूशन प्रयोजनों के लिए, मैंने हाल ही में मॉड्यूल पर अजगर प्रलेखन में एक समान कार्यान्वयन देखा है, यहां तक ​​कि वेरिएबल्स a और b का उपयोग करते हुए, जो अब मुझे यह जवाब लिखने से पहले याद करते हैं। लेकिन मुझे लगता है कि यह जवाब भाषा का बेहतर उपयोग दर्शाता है।)

हाल ही में परिभाषित कार्यान्वयन

पूर्णांक अनुक्रमों के ऑनलाइन विश्वकोश फेबोनैसी अनुक्रम को लगातार रूप में परिभाषित करता है

एफ (एन) = एफ (एन -1) + एफ (एन -2) एफ (0) = 0 और एफ (1) = 1 के साथ

संक्षिप्त रूप से ये अजगर को परिभाषित करते हुए पायथन में निम्नानुसार किया जा सकता है:

 def rec_fib(n): '''inefficient recursive function as defined, returns Fibonacci number''' if n > 1: return rec_fib(n-1) + rec_fib(n-2) return n 

लेकिन गणितीय परिभाषा का यह सटीक प्रतिनिधित्व अविश्वसनीय रूप से 30 से अधिक संख्या के लिए अक्षम है, क्योंकि प्रत्येक संख्या की गणना करने के लिए उसे नीचे दिए गए प्रत्येक संख्या के लिए भी गणना करना चाहिए। आप यह दिखा सकते हैं कि निम्न का उपयोग करके यह कितना धीमा है:

 for i in range(40): print i, rec_fib(i) 

कार्यकुशलता के लिए याद किया गया पुनरावर्तन

यह गति को बेहतर बनाने के लिए याद किया जा सकता है (इस उदाहरण से इस तथ्य का फायदा उठाया जा सकता है कि फ़ंक्शन को बुलाया गया हर बार एक डिफ़ॉल्ट कीवर्ड तर्क एक ही ऑब्जेक्ट होता है, लेकिन आमतौर पर आप बिल्कुल इस तर्क के लिए अस्थायी डिफ़ॉल्ट तर्क का उपयोग नहीं करेंगे):

 def mem_fib(n, _cache={}): '''efficiently memoized recursive function, returns a Fibonacci number''' if n in _cache: return _cache[n] elif n > 1: return _cache.setdefault(n, mem_fib(n-1) + mem_fib(n-2)) return n 

आपको मिलेगा संस्करण बहुत तेजी से मिलेगा, और इससे पहले कि आप कॉफ़ी के लिए उठने के बारे में सोच सकें, इससे पहले ही आप अपनी अधिकतम पुनरावर्ती गहराई से अधिक हो जाएंगे। आप यह देखकर यह कितना तेज़ी से देख सकते हैं:

 for i in range(40): print i, mem_fib(i) 

(ऐसा लग सकता है कि हम सिर्फ नीचे कर सकते हैं, लेकिन यह वास्तव में हमें कैश का लाभ नहीं लेता, क्योंकि यह सेटडेफ़ॉल्ट को कहने से पहले ही कॉल करता है।)

 def mem_fib(n, _cache={}): '''don't do this''' if n > 1: return _cache.setdefault(n, mem_fib(n-1) + mem_fib(n-2)) return n 

फिबोनैचि अनुक्रम के पीछे का विचार निम्नलिखित पायथन कोड में दिखाया गया है:

 def fib(n): if n == 1: return 1 elif n == 0: return 0 else: return fib(n-1) + fib(n-2) 

इसका अर्थ है कि फाइब एक ऐसा कार्य है जो तीन चीजों में से एक कर सकता है। यह फाइब (1) == 1, फाइब (0) == 0, और फाइब (एन) को परिभाषित करता है:

फिब (एन -1) + फाइब (एन -2)

जहां n एक मनमाना पूर्णांक है इसका अर्थ है कि फाइब (2) उदाहरण के लिए, निम्नलिखित अंकगणित में फैलता है:

 fib(2) = fib(1) + fib(0) fib(1) = 1 fib(0) = 0 # Therefore by substitution: fib(2) = 1 + 0 fib(2) = 1 

हम फ़िब (3) की गणना कर सकते हैं जिस तरह से नीचे दिखाए अंकगणित के साथ:

 fib(3) = fib(2) + fib(1) fib(2) = fib(1) + fib(0) fib(2) = 1 fib(1) = 1 fib(0) = 0 # Therefore by substitution: fib(3) = 1 + 1 + 0 

एहसास करने के लिए महत्वपूर्ण बात यह है कि फाइब (3) को फाइब (2) की गणना के बिना गणना नहीं की जा सकती, जो कि फाइब (1) और फाइब (0) की परिभाषाओं को जानने के द्वारा गणना की जाती है। फ़ंक्शन को फ़िबोनैकी फ़ंक्शन की तरह ही कॉल करने पर इसे पुनरावर्ती कहा जाता है, और यह प्रोग्रामिंग में एक महत्वपूर्ण विषय है।

यह एक होमवर्क कार्य की तरह लग रहा है, इसलिए मैं आपके लिए शुरू / अंत भाग नहीं कर रहा हूँ। अजगर हालांकि इस के लिए एक अद्भुत अर्थपूर्ण भाषा है, इसलिए आपको समझना चाहिए कि क्या आप गणित समझते हैं, और उम्मीद है कि आप पुनरावर्तन के बारे में बताएंगे। सौभाग्य!

संपादित करें: मेरे कोड की एक संभावित आलोचना यह है कि यह सुपर-काम करने योग्य पायथन फ़ंक्शन उपज का उपयोग नहीं करता है, जो फाइबर (एन) को बहुत कम कार्य करता है। मेरा उदाहरण थोड़ी अधिक सामान्य है, क्योंकि पायथन के बाहर बहुत सी भाषाओं में वास्तव में उपज नहीं है।

क्यों न सिर्फ निम्नलिखित करता है?

 x = [1,1] for i in xrange(10): x.append(x[-1] + x[-2]) print ', '.join(str(y) for y in x) 

समय की जटिलता:

कैशिंग सुविधा फाइबोनैचि श्रृंखला के पुनरावर्ती वृक्ष में दोहराता को समाप्त करके ओ (एन) से ओ (2 ^ एन) से फाइबोनैचि श्रृंखला की गणना करने के सामान्य तरीके को कम करती है:

यहां छवि विवरण दर्ज करें

कोड:

 import sys table = [0]*1000 def FastFib(n): if n<=1: return n else: if(table[n-1]==0): table[n-1] = FastFib(n-1) if(table[n-2]==0): table[n-2] = FastFib(n-2) table[n] = table[n-1] + table[n-2] return table[n] def main(): print('Enter a number : ') num = int(sys.stdin.readline()) print(FastFib(num)) if __name__=='__main__': main() 

फिबोनैचि अनुक्रम प्रिंट करने के लिए कैनोनिकल पायथन कोड:

 a,b=1,1 while(True): print a, a,b=b,a+b # Could also use b=a+b;a=ba 

समस्या के लिए "पहले फिबोनैचि संख्या 1000 अंकों से अधिक लंबा प्रिंट करें":

 a,b=1,1 i=1 while(len(str(a))<=1000): i=i+1 a,b=b,a+b print i,len(str(a)),a 

यह काफी कुशल है, ओ (लॉग एन) मूल अंकगणितीय आपरेशनों का उपयोग करते हुए।

 def fib(n): return pow(2 << n, n + 1, (4 << 2*n) - (2 << n) - 1) % (2 << n) 

यह एक हे (1) मूल अंकगणितीय आपरेशनों का उपयोग करता है, लेकिन मध्यवर्ती परिणामों का आकार बड़ा है और ऐसा बिल्कुल भी कुशल नहीं है।

 def fib(n): return (4 << n*(3+n)) // ((4 << 2*n) - (2 << n) - 1) & ((2 << n) - 1) 

यह एक स्क्वायरिंग द्वारा एक्सोनेंटीएशन का उपयोग करके बहुपद रिंग Z [X] / (X ^ 2 – X – 1) में एक्स ^ एन की गणना करता है। उस गणना का परिणाम बहुपद फिब (एन) एक्स + फिब (एन -1) है, जिसमें से एनटी फिबोनैचि नंबर पढ़ा जा सकता है।

फिर, यह हे (लॉग एन) अंकगणितीय संचालन का उपयोग करता है और बहुत ही कुशल है।

 def mul(a, b): return a[0]*b[1]+a[1]*b[0]+a[0]*b[0], a[0]*b[0]+a[1]*b[1] def fib(n): x, r = (1, 0), (0, 1) while n: if n & 1: r = mul(r, x) x = mul(x, x) n >>= 1 return r[0] 

लूप का उपयोग करना और सिर्फ परिणाम का प्रिंट होना

 def fib(n:'upto n number')->int: if n==0: return 0 elif n==1: return 1 a=0 b=1 for i in range(0,n-1): b=a+b a=ba return b 

परिणाम

 >>>fib(50) 12586269025 >>>> >>> fib(100) 354224848179261915075 >>> 

सभी नंबरों वाली list मुद्रित करें

 def fib(n:'upto n number')->int: l=[0,1] if n==0: return l[0] elif n==1: return l a=0 b=1 for i in range(0,n-1): b=a+b a=ba l.append(b) return l 

परिणाम

 >>> fib(10) [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55] 
 def fib(): a,b = 1,1 num=eval(input("Please input what Fib number you want to be calculated: ")) num_int=int(num-2) for i in range (num_int): a,b=b,a+b print(b) 

ये सभी थोड़ा अधिक जटिल दिखते हैं, जितना उन्हें होना चाहिए। मेरा कोड बहुत सरल और तेज है:

 def fibonacci(x): List = [] f = 1 List.append(f) List.append(f) #because the fibonacci sequence has two 1's at first while f<=x: f = List[-1] + List[-2] #says that f = the sum of the last two f's in the series List.append(f) else: List.remove(List[-1]) #because the code lists the fibonacci number one past x. Not necessary, but defines the code better for i in range(0, len(List)): print List[i] #prints it in series form instead of list form. Also not necessary 

ठीक है .. सभी लंबा जवाबों के संदर्भ में थक जाने के बाद, अब अजगर में फिबोनैचि को लागू करने के लिए नीचे दिए गए सॉर्ट और मिठाई, बहुत सी सीधे अग्रेषित रास्ता ढूंढें। आप तर्क को प्राप्त करने या उपयोगकर्ता इनपुट प्राप्त करने या इसे 10000 से बदल सकते हैं, जिस तरह से आप चाहें इसे बढ़ा सकते हैं। जैसा आपको चाहिए …

 def fibonacci(): start = 0 i = 1 lt = [] lt.append(start) while start < 10000: start += i lt.append(start) i = sum(lt[-2:]) lt.append(i) print "The Fibonaccii series: ", lt 

यह दृष्टिकोण भी अच्छा प्रदर्शन करता है रन एनालिटिक्स नीचे देखें

 In [10]: %timeit fibonacci 10000000 loops, best of 3: 26.3 ns per loop 

ऐसा करने का दूसरा तरीका:

 a,n=[0,1],10 map(lambda i: reduce(lambda x,y: a.append(x+y),a[-2:]),range(n-2)) 

'ए' में सूची को असाइन करने के लिए, 'एन' के लिए पूर्णांक असाइन करना मानचित्र और कम करने के लिए अजगर में तीन सबसे शक्तिशाली कार्यों में से 2 हैं यहां नक्शा का प्रयोग केवल 'एन -2' बार को पुनरावृत्त करने के लिए किया जाता है। एक [-2:] एक सरणी के अंतिम दो तत्व मिलेंगे। a.append (x + y) पिछले दो तत्व जोड़ देगा और सरणी में संलग्न होंगे

रुबी से मूल रूप से अनुवादित:

 def fib(n): a = 0 b = 1 for i in range(1,n+1): c = a + b print c a = b b = c 

 def fib(lowerbound, upperbound): x = 0 y = 1 while x <= upperbound: if (x >= lowerbound): yield x x, y = y, x + y startNumber = 10 endNumber = 100 for fib_sequence in fib(startNumber, endNumber): print "And the next number is... %d!" % fib_sequence 

पुनरावृत्ति समय जोड़ता है छोरों को समाप्त करने के लिए, पहले import math फिर फ़ंक्शन में math.sqrt और सुनहरा अनुपात का math.sqrt करें:

 #!/usr/bin/env python3 import math def fib(n): gr = (1 + math.sqrt(5)) / 2 fib_first = (gr**n - (1 - gr)**n) / math.sqrt(5) return int(round(fib_first)) fib_final = fib(100) print(fib_final) 

रेफरी: पायथन में फाइबोनैचि नंबर

यह गणित के हेन्री के जवाब में सुधार है:

 def fib(n): a = 0 b = 1 for i in range(1,n+1): c = a + b print b a = b b = c 

कोड प्रिंटिंग सी के बजाय b को प्रिंट करना चाहिए

आउटपुट: 1,1,2,3,5 ….

ताह्ता को महसूस करने के लिए एक बहुत आसान तरीका है!

आप यह कोड http://www.learnpython.org/ का उपयोग करके स्वतंत्र रूप से ऑनलाइन कर सकते हैं

 # Set the variable brian on line 3! def fib(n): """This is documentation string for function. It'll be available by fib.__doc__() Return a list containing the Fibonacci series up to n.""" result = [] a = 0 b = 1 while a < n: result.append(a) # 0 1 1 2 3 5 8 (13) break tmp_var = b # 1 1 2 3 5 8 13 b = a + b # 1 2 3 5 8 13 21 a = tmp_var # 1 1 2 3 5 8 13 # print(a) return result print(fib(10)) # result should be this: [0, 1, 1, 2, 3, 5, 8] 
 import time start_time = time.time() #recursive solution def fib(x, y, upperLimit): return [x] + fib(y, (x+y), upperLimit) if x < upperLimit else [x] #To test : print(fib(0,1,40000000000000)) print("run time: " + str(time.time() - start_time)) 

परिणाम

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 15 9 7, 2584, 4181, 6765, 10946, 17711, 28657, 46368 , 75025, 121393, 1 9 6418, 317811, 51422 9, 832040, 134626 9, 2178309, 3524578, 5702887, 9227465, 14 9 30352, 24157817, 39088169, 63245 986, 102334155, 165580141, 267914296, 433494437, 701408733, 1134903170, 1836311903, 2971215073, 4807526976, 7778742049 , 12586269025, 20365011074, 32951280099, 53316291173, 86267571272, 139583862445, 225851433717, 365435296162, 591286729879, 956722026041, 154800875782061, 4052739537881, 6557470319842, 10610209857723, 17167680177565, 27777890035288, 44745570212853]

रन टाइम: 0.04298138618469238

फाइबोनैचि श्रृंखला के लिए अजगर में यह सबसे आसान तरीका है, लेकिन result.append(second) ) द्वारा आउटपुट सरणी में [0] को समायोजित किया जाता है जिसके फलस्वरूप रिजल्ट लिस्ट दूसरा वैरिएबल होता है result.append(second) परिणामस्वरूप result.append(second)

 def fibo(num): first = 0 second = 1 result = [0] print('Fibonacci series is') for i in range(0,num): third = first + second #print(second) result.append(second) first = second second = third print(result) return fibo(7) 

आउटपुट

 Fibonacci series is [0, 1, 1, 2, 3, 5, 8, 13] 

अच्छा पायथन पुस्तक पढ़ने से प्रारंभ करें इनमें से एक पुस्तक "कैसे एक कंप्यूटर वैज्ञानिक की तरह सोचें", विशेष रूप से आपके मामले में अध्याय 5

एक पुनरावृत्त समस्या को पुनरावृत्त एक रूपांतरित करने का तरीका जानें। वहां से गणना करने में सक्षम होना चाहिए

यह सिद्धांत हो सकता है कि वे आपको जानने की कोशिश कर रहे हैं, खासकर यदि यह एक एल्गोरिदम पाठ्यक्रम है

15 मिनट की ट्यूटोरियल में मैंने पाइथन सीखने के दौरान उपयोग किया था, इसने पाठक को एक प्रोग्राम लिखने के लिए कहा जो कि 3 इनपुट नंबरों से एक फिबोनैचि अनुक्रम की गणना करेगा (पहला फिबोनाची संख्या, दूसरा नंबर, और उस संख्या को क्रम में रोकने के लिए)। ट्यूटोरियल केवल चर को कवर किया था, अगर / उस समय तक, और उस बिंदु तक loops। अभी तक कोई कार्य नहीं है मैं निम्नलिखित कोड के साथ आया था:

 sum = 0 endingnumber = 1 print "\n.:Fibonacci sequence:.\n" firstnumber = input("Enter the first number: ") secondnumber = input("Enter the second number: ") endingnumber = input("Enter the number to stop at: ") if secondnumber < firstnumber: print "\nSecond number must be bigger than the first number!!!\n" else: while sum <= endingnumber: print firstnumber if secondnumber > endingnumber: break else: print secondnumber sum = firstnumber + secondnumber firstnumber = sum secondnumber = secondnumber + sum 

जैसा कि आप देख सकते हैं, यह वास्तव में अक्षम है, लेकिन यह काम करता है

पुनरावर्ती का उपयोग करें:

 def fib(n): if n == 0: return 0 elif n == 1: return 1 else: return fib(n-1) + fib(n-2) x=input('which fibonnaci do you want?') print fib(x) 

बस http://projecteuler.net/problem=2 के माध्यम से जा रहा था यह मेरा उस पर ले गया था

 # Even Fibonacci numbers # Problem 2 def get_fibonacci(size): numbers = [1,2] while size > len(numbers): next_fibonacci = numbers[-1]+numbers[-2] numbers.append(next_fibonacci) print numbers get_fibonacci(20) 
 def fib(x, y, n): if n < 1: return x, y, n else: return fib(y, x + y, n - 1) print fib(0, 1, 4) (3, 5, 0) # def fib(x, y, n): if n > 1: for item in fib(y, x + y, n - 1): yield item yield x, y, n f = fib(0, 1, 12) f.next() (89, 144, 1) f.next()[0] 55 

यह एक अभ्यास असाइनमेंट था जिसे मैंने पायथन प्रोग्रामिंग पर खान अकादमी के सैल पर देखा था: https://www.khanacademy.org/science/computer-science-subject/computer-science/v/exercise—write-a-fibonacci- समारोह

वह संभवतः पहले व्यक्ति नहीं हैं जो कि कुछ कार्य करने के लिए लेकिन यह भयानक है इसे अपने द्वारा बाहर लगाना मैं वास्तव में इसे बाहर figuring एक बहुत सीखा है और यह एक विस्फोट था।

मैं अनुशंसा करता हूं कि होमवर्क के लिए किसी और के कोड की कोशिश करने और कॉपी करने से पहले आप इसे खुद समझें।

उपरोक्त वीडियो में, सा प्रशिक्षक, दिखाता है कि फिबोनैचि संख्या के पीछे के पूरे सिद्धांत को दर्शाता है, और इसके साथ दिमाग में आपको इसे समझने में सक्षम होना चाहिए।

यह मुझे लगभग 10 मिनट ले गया और यह मैंने बनाया कोड है (मैं 3 दिन पहले अजगर सीख रहा हूँ और यह मेरी पहली प्रोग्रामिंग भाषा है)। अगर मैं ट्यूटोरियल से पहले वीडियो के लिए नहीं था, तो मैं कोड लिखने में सक्षम नहीं होता: https://www.khanacademy.org/science/computer-science-subject/computer-science/v/comparing-iterative- और-पुनरावर्ती-तथ्यात्मक-कार्य जो कि एक साल का पुनरावर्ती तथ्यात्मक समीकरण करते हुए एक उदाहरण देता है और आपको इस समस्या को हल करने के लिए मन-सेट प्रदान करता है।

यहां मेरा कोड है:

 def fibonacci(num): if num <= 1: #base case return num else: return fibonacci(num-1) + fibonacci(num-2) 

आप देख सकते हैं कि यदि संख्या 1 या 0 है तो आप संख्या वापस कर सकते हैं।

मुझे यह कहने से यह क्लीनर मिल रहा है कि संख्या 1 रिटर्न 1 है और यदि संख्या 0 रिटर्न 0 है

शायद यह मदद करेगा

 def fibo(n): result = [] a, b = 0, 1 while b < n: result.append(b) a, b = b, b + a return result 

इसे इस्तेमाल करे:

 def nth_fib(n): if n == 0: return 1 elif n == 1: return 0 else: return nth_fib(n - 1) + nth_fib(n - 2) 

क्लासिक फाइबोनैचि अनुक्रम के आधार पर और केवल एक लाइनर के लिए

यदि आपको सूचकांक की संख्या की आवश्यकता होती है, तो आप कम करने का उपयोग कर सकते हैं (भले ही कम हो, इसके लिए यह सबसे उपयुक्त नहीं है यह एक अच्छा व्यायाम हो सकता है)

 def fibonacci(index): return reduce(lambda r,v: r.append(r[-1]+r[-2]) or (r.pop(0) and 0) or r , xrange(index), [0, 1])[1] 

और पूरी सरणी प्राप्त करने के लिए सिर्फ या (r.pop (0) और 0) निकाल दें

 reduce(lambda r,v: r.append(r[-1]+r[-2]) or r , xrange(last_index), [0, 1]) 

इसके बारे में क्या खयाल है? मुझे लगता है कि यह अन्य सुझावों के रूप में फैंसी नहीं है क्योंकि यह अपेक्षित आउटपुट का उत्पादन करने के लिए पिछले परिणाम की प्रारंभिक विनिर्देश की मांग करता है, लेकिन मुझे लगता है कि यह एक बहुत ही पठनीय विकल्प है, यानी, यह सब करता है परिणाम और पिछले परिणाम प्रदान करना है पुनरावर्ती

 #count the number of recursions num_rec = 0 def fibonacci(num, prev, num_rec, cycles): num_rec = num_rec + 1 if num == 0 and prev == 0: result = 0; num = 1; else: result = num + prev print(result) if num_rec == cycles: print("done") else: fibonacci(result, num, num_rec, cycles) #Run the fibonacci function 10 times fibonacci(0, 0, num_rec, 10) 

यहां आउटपुट दिया गया है:

 0 1 1 2 3 5 8 13 21 34 done