दिलचस्प पोस्ट
क्या मैं ट्रैक किए गए फ़ाइलों के बाहर .git फ़ोल्डर को संग्रहीत कर सकता / सकती हूं? जावास्क्रिप्ट में Google API एक ही प्रकार की वस्तुओं को अलग करने के लिए एल्गोरिथ्म सर्वर के लिए शून्य मूल्यों को पारित करने के लिए http पोस्ट विधि ArrayList को क्यों नहीं चिह्नित किया गया? फेसबुक केवल नाम और यूजर के आईडी वापस डेटा से डॉलर के संकेत ($) को कैसे रोकूं / आर में विशेष वर्णों से बचें? Qt में विगेट्स पहलू अनुपात कैसे बनाए रखा जाए? कॉरपोरेट प्रॉक्सी द्वारा अवरुद्ध बुवर कॉल जेपीए और सीतनिद्रा में होना का उपयोग करते समय आईडी पीढ़ी रणनीति का चयन कैसे करें परमिको के साथ नेस्टेड एसएसएच सत्र कैसे popen stdin को नियंत्रित करने के लिए, stdout, stderr पुनर्निर्देशन? JSLint: परिभाषित किया गया था इससे पहले इस्तेमाल किया गया था एंड्रॉइड – मैं एक एएनआर की जांच कैसे करूं? उप-क्लासिंग के दौरान स्थैतिक चर को ओवरराइड करना

जावा पुनरावर्ती फिबोनाची अनुक्रम

कृपया इस कोड को समझाएं (यह आसान है, लेकिन कृपया मेरे साथ सहन करें क्योंकि मैं अब भी एक पायदान हूं: पी):

public int fibonacci(int n) { if(n == 0) return 0; else if(n == 1) return 1; else return fibonacci(n - 1) + fibonacci(n - 2); } 

मैं आखिरी पंक्ति से उलझन में हूं क्योंकि विशेषकर अगर n = 5 उदाहरण के लिए, तो फाइबोनैचि (4) + फाइबोनैचि (3) को तथाकथित कहा जाएगा, लेकिन मुझे समझ नहीं आ रहा है कि यह एल्गोरिथम कैसे इस सूचकांक 5 से मूल्य की गणना करता है तरीका। कृपया बहुत विस्तार से समझाएं!

Solutions Collecting From Web of "जावा पुनरावर्ती फिबोनाची अनुक्रम"

फाइबोनैचि अनुक्रम में प्रत्येक आइटम पिछले दो का योग होता है। तो, आपने एक रिकर्सिव एल्गोरिथम लिखा है

इसलिए,

 fibonacci(5) = fibonacci(4) + fibonacci(3) fibonacci(3) = fibonacci(2) + fibonacci(1) fibonacci(4) = fibonacci(3) + fibonacci(2) fibonacci(2) = fibonacci(1) + fibonacci(0) 

अब आप पहले से ही fibonacci(1)==1 and fibonacci(0) == 0 जानते हैं। तो, आप बाद में अन्य मूल्यों की गणना कर सकते हैं

अभी व,

 fibonacci(2) = 1+0 = 1 fibonacci(3) = 1+1 = 2 fibonacci(4) = 2+1 = 3 fibonacci(5) = 3+2 = 5 

और 0,1,1,2,3,5,8,13,21.... अनुक्रम से 0,1,1,2,3,5,8,13,21.... हम देख सकते हैं कि 5th element के लिए 0,1,1,2,3,5,8,13,21.... अनुक्रम 5 देता है।

Recursion ट्यूटोरियल के लिए यहां देखें।

आपके कोड में 2 समस्याएं हैं:

  1. इसका परिणाम इंट में संग्रहित होता है जो केवल पहले 48 फिबोनैचि संख्या को संभाल सकता है, इसके बाद पूर्णांक भरण शून्य से थोड़ा और परिणाम गलत है।
  2. लेकिन आप कभी भी फाइबोनैचि नहीं चला सकते (50)।
    कोड
    fibonacci(n - 1) + fibonacci(n - 2)
    बहुत गलत है
    समस्या यह है कि यह फाइबोनैची को 50 बार नहीं कहता, लेकिन बहुत अधिक
    पहले इसे फिबोनासी (49) + फिबोनासी (48) कहते हैं,
    अगली फिबोनासी (48) + फिबोनासी (47) और फिबोनासी (47) + फिबोनासी (46)
    हर बार जब यह 2 ^ एन भी खराब हो गया यहां छवि विवरण दर्ज करें

गैर पुनरावर्ती कोड के लिए दृष्टिकोण:

  double fibbonaci(int n){ double prev=0d, next=1d, result=0d; for (int i = 0; i < n; i++) { result=prev+next; prev=next; next=result; } return result; } 

छद्म कोड में, जहां n = 5, निम्न स्थान होता है:

फिबोनासी (4) + फिबोनैची (3)

यह टूट जाती है:

(फाइबोनासी (3) + फाइबोनेक्की (2)) + (फाइबोनासी (2) + फाइबोनेचासी (1))

यह टूट जाती है:

(((फाइबोनैचि (2) + फाइबोनेचासी (1)) + ((फाइबोनासी (1) + फाइबोनेचासी (0))) + (((फाइबोनैचि (1) + फाइबोनेचासी (0)) + 1))

यह टूट जाती है:

((((फाइबोनासी (1) + फाइबोनेचासी (0)) + 1) + ((1 + 0)) + ((1 + 0) + 1))

यह टूट जाती है:

((((1 + 0) + 1) + ((1 + 0)) + ((1 + 0) + 1))

इसका परिणाम: 5

फिबोनैची अनुक्रम 1 1 2 3 5 8 … को देखते हुए, 5 वीं तत्व 5 है। आप अन्य पुनरावृत्तियों का पता लगाने के लिए उसी पद्धति का उपयोग कर सकते हैं।

पुनरावृत्ति को कभी-कभी समझना कठिन हो सकता है बस इसे एक छोटी संख्या के लिए कागज के एक टुकड़े पर मूल्यांकन:

 fib(4) -> fib(3) + fib(2) -> fib(2) + fib(1) + fib(1) + fib(0) -> fib(1) + fib(0) + fib(1) + fib(1) + fib(0) -> 1 + 0 + 1 + 1 + 0 -> 3 

मुझे यकीन नहीं है कि जावा वास्तव में इसका मूल्यांकन क्यों करता है, लेकिन इसका परिणाम समान होगा।

  F(n) / \ F(n-1) F(n-2) / \ / \ F(n-2) F(n-3) F(n-3) F(n-4) / \ F(n-3) F(n-4) 

नोट करने के लिए महत्वपूर्ण बिंदु यह एल्गोरिथ्म घातीय है क्योंकि यह पिछले गणना संख्याओं के परिणाम को संग्रहीत नहीं करता है। जैसे एफ (एन -3) को 3 बार कहा जाता है

अधिक जानकारी के लिए दासगुप्ता अध्याय 0.2 द्वारा एल्गोरिदम का विवरण

यह सबसे अच्छा वीडियो मैंने पाया है जो पूरी तरह से पुनरावर्ती और जावा में फिबोनैकी अनुक्रम समझाता है।

http://www.youtube.com/watch?v=dsmBRUCzS7k

यह अनुक्रम के लिए उसका कोड है और उसका स्पष्टीकरण इससे बेहतर है कि मैं इसे टाइप करने की कोशिश कर रहा हूं।

 public static void main(String[] args) { int index = 0; while (true) { System.out.println(fibonacci(index)); index++; } } public static long fibonacci (int i) { if (i == 0) return 0; if (i<= 2) return 1; long fibTerm = fibonacci(i - 1) + fibonacci(i - 2); return fibTerm; } 

फाइबोनैचि रिकर्सिव समाधान के लिए, बड़ी संख्या के मूल्य को पुनः प्राप्त करते समय, छोटी फाइबोनासी संख्याओं के उत्पादन को सहेजना महत्वपूर्ण है। इसे "मेमोइज़िंग" कहा जाता है

यहां एक ऐसा कोड है जो बड़ी फाइबोनैचि संख्या को पुनः प्राप्त करते समय छोटे फाइबोनैचि मूल्यों को याद करते हैं। यह कोड कुशल है और एक ही फ़ंक्शन के एकाधिक अनुरोध नहीं करता है।

 import java.util.HashMap; public class Fibonacci { private HashMap<Integer, Integer> map; public Fibonacci() { map = new HashMap<>(); } public int findFibonacciValue(int number) { if (number == 0 || number == 1) { return number; } else if (map.containsKey(number)) { return map.get(number); } else { int fibonacciValue = findFibonacciValue(number - 2) + findFibonacciValue(number - 1); map.put(number, fibonacciValue); return fibonacciValue; } } } 

अधिकांश उत्तर अच्छे हैं और बताते हैं कि फिबोनैकी कार्यों में पुनरावर्ती कैसे काम करता है।

यहां तीन तकनीकों पर एक विश्लेषण दिया गया है जिसमें पुनरावृत्ति भी शामिल है:

  1. पाश के लिए
  2. प्रत्यावर्तन
  3. Memoization

तीनों का परीक्षण करने के लिए यहां मेरा कोड है:

 public class Fibonnaci { // Output = 0 1 1 2 3 5 8 13 static int fibMemo[]; public static void main(String args[]) { int num = 20; System.out.println("By For Loop"); Long startTimeForLoop = System.nanoTime(); // returns the fib series int fibSeries[] = fib(num); for (int i = 0; i < fibSeries.length; i++) { System.out.print(" " + fibSeries[i] + " "); } Long stopTimeForLoop = System.nanoTime(); System.out.println(""); System.out.println("For Loop Time:" + (stopTimeForLoop - startTimeForLoop)); System.out.println("By Using Recursion"); Long startTimeRecursion = System.nanoTime(); // uses recursion int fibSeriesRec[] = fibByRec(num); for (int i = 0; i < fibSeriesRec.length; i++) { System.out.print(" " + fibSeriesRec[i] + " "); } Long stopTimeRecursion = System.nanoTime(); System.out.println(""); System.out.println("Recursion Time:" + (stopTimeRecursion -startTimeRecursion)); System.out.println("By Using Memoization Technique"); Long startTimeMemo = System.nanoTime(); // uses memoization fibMemo = new int[num]; fibByRecMemo(num-1); for (int i = 0; i < fibMemo.length; i++) { System.out.print(" " + fibMemo[i] + " "); } Long stopTimeMemo = System.nanoTime(); System.out.println(""); System.out.println("Memoization Time:" + (stopTimeMemo - startTimeMemo)); } //fib by memoization public static int fibByRecMemo(int num){ if(num == 0){ fibMemo[0] = 0; return 0; } if(num ==1 || num ==2){ fibMemo[num] = 1; return 1; } if(fibMemo[num] == 0){ fibMemo[num] = fibByRecMemo(num-1) + fibByRecMemo(num -2); return fibMemo[num]; }else{ return fibMemo[num]; } } public static int[] fibByRec(int num) { int fib[] = new int[num]; for (int i = 0; i < num; i++) { fib[i] = fibRec(i); } return fib; } public static int fibRec(int num) { if (num == 0) { return 0; } else if (num == 1 || num == 2) { return 1; } else { return fibRec(num - 1) + fibRec(num - 2); } } public static int[] fib(int num) { int fibSum[] = new int[num]; for (int i = 0; i < num; i++) { if (i == 0) { fibSum[i] = i; continue; } if (i == 1 || i == 2) { fibSum[i] = 1; continue; } fibSum[i] = fibSum[i - 1] + fibSum[i - 2]; } return fibSum; } } 

यहां परिणाम दिए गए हैं:

 By For Loop 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 For Loop Time:347688 By Using Recursion 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Recursion Time:767004 By Using Memoization Technique 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Memoization Time:327031 

इसलिए हम देख सकते हैं कि मेमोअनाइजेशन सबसे अच्छा समय है और लूप मैचों के साथ निकटता से है।

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

फाइबोनैचि अनुक्रम में, पहले दो आइटम 0 और 1 हैं, प्रत्येक अन्य वस्तु दो पिछली वस्तुओं का योग है अर्थात:
0 1 1 2 3 5 8 …

इसलिए 5 वें आइटम 4 वें और तीसरे आइटम का योग है

फिब (एन), फाइब (एन -1) की एक सरणी लौटने के द्वारा रेखीय समय में फिबोनैचि को सुलझाने के लिए माइकल गुडरिक एट, जावा में डेटा स्ट्रक्चर और एल्गोरिदम में एक बहुत ही चतुर एल्गोरिथ्म प्रदान करता है।

 public static long[] fibGood(int n) { if (n < = 1) { long[] answer = {n,0}; return answer; } else { long[] tmp = fibGood(n-1); long[] answer = {tmp[0] + tmp[1], tmp[0]}; return answer; } } 

यह उपज फाइब (एन) = फिब गुड (एन) [0]

आप अपने फ़ंक्शन को सरल भी कर सकते हैं, निम्नानुसार:

 public int fibonacci(int n) { if (n < 2) return n; return fibonacci(n - 1) + fibonacci(n - 2); } 

यहां दिए गए अधिकांश समाधान ओ (2 एन एन) जटिलता में चलते हैं। रिकर्सिव पेड़ में समान नोडों की पुनरावृत्ति करना अक्षम और अपशिष्ट CPU चक्र है।

हम ओ (एन) समय में फाइबोनैचि फ़ंक्शन चलाने के लिए मेमोअनाइजेशन का उपयोग कर सकते हैं

 public static int fibonacci(int n) { return fibonacci(n, new int[n + 1]); } public static int fibonacci(int i, int[] memo) { if (i == 0 || i == 1) { return i; } if (memo[i] == 0) { memo[i] = fibonacci(i - 1, memo) + fibonacci(i - 2, memo); } return memo[i]; } 

अगर हम नीचे-गतिशील प्रोग्रामिंग मार्ग का पालन करते हैं, तो कोड के नीचे फाइबोनैचि को गणना करने के लिए पर्याप्त सरल है:

 public static int fibonacci1(int n) { if (n == 0) { return n; } else if (n == 1) { return n; } final int[] memo = new int[n]; memo[0] = 0; memo[1] = 1; for (int i = 2; i < n; i++) { memo[i] = memo[i - 1] + memo[i - 2]; } return memo[n - 1] + memo[n - 2]; } 

मुझे लगता है कि यह एक आसान तरीका है:

 public static void main(String[] args) { Scanner input = new Scanner(System.in); int number = input.nextInt(); long a = 0; long b = 1; for(int i = 1; i<number;i++){ long c = a +b; a=b; b=c; System.out.println(c); } } } 

रानीराग (स्वीकार) जवाब ठीक काम करेगा, लेकिन यह समाधान तब तक अनुकूलित नहीं है जब तक कि अनिल के उत्तर में बताए गए अनुसार इसे याद नहीं किया जाता।

पुनरावर्ती के लिए नीचे दिए गए दृष्टिकोण पर विचार करें, TestFibonacci की विधि कॉल न्यूनतम हैं

 public class TestFibonacci { public static void main(String[] args) { int n = 10; if (n == 1) { System.out.println(1); } else if (n == 2) { System.out.println(1); System.out.println(1); } else { System.out.println(1); System.out.println(1); int currentNo = 3; calFibRec(n, 1, 1, currentNo); } } public static void calFibRec(int n, int secondLast, int last, int currentNo) { if (currentNo <= n) { int sum = secondLast + last; System.out.println(sum); calFibRec(n, last, sum, ++currentNo); } } } 

यह जवाब अलग क्यों है

प्रत्येक अन्य उत्तर या तो:

  • रिटर्न के बजाय रिटर्न
  • पुनरावृत्त प्रति 2 पुनरावर्ती कॉल करता है
  • लूप का उपयोग करके प्रश्न पर ध्यान न दें

(एक तरफ: इनमें से कोई भी वास्तव में कुशल नहीं है; सीधे बिन्द के फार्मूले को सीधे एन वें शब्द की गणना करने के लिए)

टेल रिकर्सिव फिब

यहाँ एक पुनरावर्ती दृष्टिकोण है जो पिछले उत्तर और दोनों से पहले एक को पारित करके दोहराई जाने वाली कॉल से बचा जाता है।

 private static final int FIB_0 = 0; private static final int FIB_1 = 1; private int calcFibonacci(final int target) { if (target == 0) { return FIB_0; } if (target == 1) { return FIB_1; } return calcFibonacci(target, 1, FIB_1, FIB_0); } private int calcFibonacci(final int target, final int previous, final int fibPrevious, final int fibPreviousMinusOne) { final int current = previous + 1; final int fibCurrent = fibPrevious + fibPreviousMinusOne; // If you want, print here / memoize for future calls if (target == current) { return fibCurrent; } return calcFibonacci(target, current, fibCurrent, fibPrevious); } 

यह एक बुनियादी अनुक्रम है जो 1 1 2 3 5 8 के उत्पादन को प्रदर्शित करता है या प्राप्त करता है, यह एक अनुक्रम है कि पिछली संख्या का योग वर्तमान संख्या को प्रदर्शित किया जाएगा।

जावा रिकर्सिव फिबोनासी अनुक्रम ट्यूटोरियल के नीचे दिए गए लिंक को देखने की कोशिश करें

 public static long getFibonacci(int number){ if(number<=1) return number; else return getFibonacci(number-1) + getFibonacci(number-2); } 

चम्मच भोजन के लिए जावा रिकर्सिव फिबोनासी अनुक्रम ट्यूटोरियल देखें यहां क्लिक करें

बस पूरक के लिए, यदि आप बड़ी संख्याओं की गणना करने में सक्षम होना चाहते हैं, तो आपको बिगइंटेगर का उपयोग करना चाहिए

एक पुनरावर्ती उदाहरण

 import java.math.BigInteger; class Fibonacci{ public static void main(String args[]){ int n=10000; BigInteger[] vec = new BigInteger[n]; vec[0]=BigInteger.ZERO; vec[1]=BigInteger.ONE; // calculating for(int i = 2 ; i<n ; i++){ vec[i]=vec[i-1].add(vec[i-2]); } // printing for(int i = vec.length-1 ; i>=0 ; i--){ System.out.println(vec[i]); System.out.println(""); } } } 

http://en.wikipedia.org/wiki/Fibonacci_number अधिक विवरण में

 public class Fibonacci { public static long fib(int n) { if (n <= 1) return n; else return fib(n-1) + fib(n-2); } public static void main(String[] args) { int N = Integer.parseInt(args[0]); for (int i = 1; i <= N; i++) System.out.println(i + ": " + fib(i)); } } 

इसे बनाने के लिए जितनी सरल जरूरत होती है, जबकि लूप और अन्य लूप का उपयोग करने की कोई आवश्यकता नहीं है

 public class febo { public static void main(String...a) { int x[]=new int[15]; x[0]=0; x[1]=1; for(int i=2;i<x.length;i++) { x[i]=x[i-1]+x[i-2]; } for(int i=0;i<x.length;i++) { System.out.println(x[i]); } } } 
 public class FibonacciSeries { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int N = scanner.nextInt(); for (int i = 0; i <= N; i++) { int result = fibonacciSeries(i); System.out.println(result); } scanner.close(); } private static int fibonacciSeries(int n) { if (n < 0) { return 1; } else if (n > 0) { return fibonacciSeries(n - 1) + fibonacciSeries(n - 2); } return 0; } } 
  public static long fib(int n) { long population = 0; if ((n == 0) || (n == 1)) // base cases { return n; } else // recursion step { population+=fib(n - 1) + fib(n - 2); } return population; } 

फिबोनैचि श्रृंखला एक सरल कोड है जो गतिशील प्रोग्रामिंग की शक्ति को दर्शाती है। हम सभी स्कूल के दिनों से सीखते हैं कि इसे पुनरावृत्त या अधिकतम पुनरावर्ती कोड के माध्यम से चलाने के लिए है। पुनरावर्ती कोड 20 या तो तक ठीक काम करता है, यदि आप संख्याओं को बड़ा देते हैं, तो आप देखेंगे कि यह गणना करने के लिए बहुत समय लगता है। गतिशील प्रोग्रामिंग में आप कोड को निम्नानुसार देख सकते हैं और उत्तर की गणना करने के लिए सेकेंड लेते हैं।

 static double fib(int n) { if (n < 2) return n; if (fib[n] != 0) return fib[n]; fib[n] = fib(n - 1) + fib(n - 2); return fib[n]; } 

आप सरणी में मूल्यों को स्टोर करते हैं और ताज़ा गणना में आगे बढ़ते हैं, जब आप सरणी जवाब नहीं दे सकते।

साधारण फिबोनैचि

 public static void main(String[]args){ int i = 0; int u = 1; while(i<100){ System.out.println(i); i = u+i; System.out.println(u); u = u+i; } } } 
  import java.util.*; /* @ Author 12CSE54 @ Date 28.10.14 */ public class cfibonacci { public void print(int p) { int a=0,b=1,c; int q[]=new int[30]; q[0]=a; q[1]=b; for(int i=2;i<p;i++) { c=a+b; q[i]=c; a=b; b=c; } System.out.println("elements are....\n"); for(int i=0;i<q.length;i++) System.out.println(q[i]); } public static void main(String ar[])throws Exception { Scanner s=new Scanner(System.in); int n; System.out.println("Enter the number of elements\n"); n=sc.nextInt(); cfibonacci c=new cfibonacci(); c.printf(n); } } 

@ क्रो पर नजर रखी हुई है, लेकिन वह लगातार पुनरावर्ती तरीके से ऐसा करने का सही तरीका नहीं दिखाता है। यहां समाधान है:

 class Fib { static int count; public static void main(String[] args) { log(fibWrong(20)); // 6765 log("Count: " + count); // 21891 count = 0; log(fibRight(20)); // 6765 log("Count: " + count); // 19 } static long fibRight(long n) { return calcFib(n-2, 1, 1); } static long fibWrong(long n) { count++; if (n == 0 || n == 1) { return n; } else if (n < 0) { log("Overflow!"); System.exit(1); return n; } else { return fibWrong(n-1) + fibWrong(n-2); } } static long calcFib(long nth, long prev, long next) { count++; if (nth-- == 0) return next; if (prev+next < 0) { log("Overflow with " + (nth+1) + " combinations remaining"); System.exit(1); } return calcFib(nth, next, prev+next); } static void log(Object o) { System.out.println(o); } } 

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

 public static void main(String args[]){ System.out.println("This program lists the Fibonacci sequence."); int answer = 0; int startValue = 1; int sum = 0; while (answer < 10000){ System.out.println(answer); sum = add(answer,startValue); startValue = answer; answer = sum; } } //This method return the sum of addition private static int add(int A,int B){ return A+B; } 
 public long getFibonacci( int number) { if ( number <=2) { return 1; } long lRet = 0; lRet = getFibonacci( number -1) + getFibonacci( number -2); return lRet; } 
 public class Fibonaci{ static void fibonacci() { int ptr1 = 1, ptr2 = 1, ptr3 = 0; int temp = 0; BufferedReader Data=new BufferedReader (new InputStreamReader(System.in)); try { System.out.println("The Number Value's fib you required ? "); ptr3 = Integer.parseInt(Data.readLine()); System.out.print(ptr1 + " " + ptr2 + " "); for (int i = 0; i < ptr3; i++) { System.out.print(ptr1 + ptr2 + " "); temp = ptr1; ptr1 = ptr2; ptr2 = temp + ptr2; } } catch(IOException err) { System.out.println("Error!" + err); } catch(NumberFormatException err) { System.out.println("Invald Input!"); } } public static void main(String[]args)throws Exception{ Fibonaci.fibonacci(); } } 

आप ऐसा कर सकते हैं