জাভা রিকার্সিভ ফিবোনাচি ক্রম

Question

এই সহজ কোডটি ব্যাখ্যা করুন:

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

আমি শেষ লাইনের সাথে বিভ্রান্ত হয়েছি কারণ বিশেষত যদি এন = 5 উদাহরণস্বরূপ, তবে ফাইবোনাকি (4) + ফাইবোনাকি (3) কল করা হবে এবং এই জাতীয় অ্যালগরিদম কীভাবে সূচক 5 এ মানটি গণনা করে তা আমি বুঝতে পারি না পদ্ধতি। অনেক বিস্তারিত দিয়ে ব্যাখ্যা করুন!

Comments

দ্রষ্টব্য যে এটি পুনরাবৃত্ত হয় এবং তাত্পর্যপূর্ণ সময়ে চালিত হয়। এটি এন এর বৃহত মানগুলির পক্ষে অকার্যকর an এগুলি এখানে পাওয়া যাবে - goo.gl/hnbF5

— অ্যাডাম

@ অ্যাডামফিশার: আপনি অনুগ্রহ করে ১০,০০০ নম্বর গণনার জন্য আপনি যে কোডটি ব্যবহার করেছেন তা ভাগ করে নিতে পারেন? আমি আসলে এটি জানতে কৌতুহলী।

— শুমাইল

@ অ্যাডামফিশার আপনি যে লিঙ্কটি উল্লেখ করেছেন তা মারা গেছে।

— iRuth

এই ভিডিওটি 10 ​​মিনিট youtube.com/watch?v=t4MSwiqfLaY

— চথুরা পালিহাক্কার

এছাড়াও একটি Iterative পদ্ধতির যা আপনার পক্ষে কম কঠিন হতে পারে। কোড সহ এখানে পুনরাবৃত্ত এবং আইট্রেটিভ

— user5495300

Answer 1

ফিবোনাচি সিকোয়েন্সে প্রতিটি আইটেমটি পূর্বের দুটিটির যোগফল। সুতরাং, আপনি একটি পুনরাবৃত্ত আলগোরিদিম লিখেছেন।

সুতরাং,

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.... আমরা দেখতে পাই যে 5th elementফিবোনাচি সিকোয়েন্সের জন্য 5।

পুনরাবৃত্তি টিউটোরিয়াল জন্য এখানে দেখুন ।

Comments

এটি কাজ করবে তবে অপটিমাইজ হওয়া অবধি এবং অপটিমাইজড না হওয়া পর্যন্ত। আমার উত্তরটি একবার দেখুন পরামর্শ / মন্তব্যের ক্ষেত্রে আমাকে জানতে দিন

— এম শچ

Answer 2

আপনার কোডটিতে 2 টি সমস্যা রয়েছে:

1. ফলাফলটি int- এ সংরক্ষণ করা হয় যা কেবলমাত্র প্রথম 48 ফিবোনাচি সংখ্যাগুলি পরিচালনা করতে পারে, এর পরে পূর্ণসংখ্যা পূরণ বিয়োগ বিট এবং ফলাফলটি ভুল।
2. তবে আপনি কখনও ফিবোনাচি (50) চালাতে পারবেন না।
   কোডটি
   fibonacci(n - 1) + fibonacci(n - 2)
   খুব ভুল।
   সমস্যাটি হ'ল এটি ফাইবোনাকিকে 50 বার নয় বরং আরও অনেক কিছু বলে।
   প্রথমে এটি ফাইবোনাকি (49) + ফিবোনাচি (48),
   পরের ফিবোনাচি (48) + ফিবোনাচি (47) এবং ফাইবোনাকি (47) + ফাইবোনাকি (46)
   প্রতিবার এটি ফাইবোনাকি (এন) আরও খারাপ হয়ে ওঠে, সুতরাং জটিলতাটি হ'ল তাত্পর্যপূর্ণ।

পুনরাবৃত্তিযোগ্য কোডের পদ্ধতির:

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

Comments

যদিও অন্যান্য কয়েকটি উত্তর পুনরাবৃত্তি আরও স্পষ্টভাবে ব্যাখ্যা করে, সম্ভবত এটি গভীর স্তরের সর্বাধিক প্রাসঙ্গিক উত্তর।

— Hal50000

"পূর্ণসংখ্যা পূরণ বিয়োগ" এর অর্থ কী?

— রিচার্ড

@রিচার্ড, এটি পূর্ণসংখ্যা কীভাবে সংরক্ষণ করা হয় সে সম্পর্কে। ইনটি 2 ^ 31-1 এ পৌঁছানোর পরে পরের বিটটি সাইন সম্পর্কে, সুতরাং সংখ্যাটি নেতিবাচক হয়ে যায়।

— ক্রো

অনেক দ্রুত তারপর পুনরাবৃত্তি। একমাত্র রিজার্ভেশন হ'ল এটি n = 1 এর জন্য কাজ করবে না। অতিরিক্ত শর্ত প্রয়োজন

— v0rin

"প্রতিবার এটি 2 worse n আরও খারাপ হয়ে উঠল" আসলে মোট ফাংশন কলগুলির সংখ্যা 2*fibonacci(n+1)-1তাই এটি একইসাথে ফাইবোনাকির সংখ্যাগুলির সাথে বেড়ে যায়, যা 2 ^ n এর পরিবর্তে 1.618 ^ n হয়

— এমিল

Answer 3

সিউডো কোডে, যেখানে এন = 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 5. অন্যান্য পুনরাবৃত্তিগুলি বের করার জন্য আপনি একই পদ্ধতিটি ব্যবহার করতে পারেন।

Comments

আমি মনে করি এই উত্তরটি প্রশ্নগুলি সর্বোত্তমভাবে ব্যাখ্যা করে। সত্যিই সহজ

— অমিত

এটা ঝরঝরে। নবম পদ এবং এটি অনুসরণ করা সিরিজ উভয় মান ব্যাখ্যা করে।

— সেমিকোলন

Answer 4

পুনরাবৃত্তি কখনও কখনও উপলব্ধি করা কঠিন হতে পারে। অল্প সংখ্যক জন্য কেবল কাগজের টুকরোতে এটি মূল্যায়ন করুন:

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

আমি নিশ্চিত নই যে জাভা আসলে এটি কীভাবে মূল্যায়ন করে তবে ফলাফলটি একই রকম হবে।

Comments

দ্বিতীয় লাইনে শেষে 1 এবং 0 কোথা থেকে আসে?

— পোকন

@ পোকন ফাইব (2) = ফাইব (1) + ফাইব (0)

— টাইম

সুতরাং আপনার কাছে ফাইব (4) রয়েছে তাই এন -1 এবং এন -2 টি ফাইব (3) + ফাইব (2) হবে তবে আপনি এন -1 এবং এন -2 আবার করবেন -> ফাইব (2) + ফাইব (1) ), আপনি কোথা থেকে + ফাইব (1) + ফাইব (0) পেয়েছেন? শেষের দিকে যুক্ত হয়েছে

— পককন

@ পোকন ফাইব (2) + ফাইব (1) ফাইব (3) থেকে এসেছে, ফাইব (1) + ফাইব (0) ফাইব (2)

— টিম

Answer 5

আপনি নিম্নলিখিত হিসাবে আপনার ফাংশন সহজ করতে পারেন:

public int fibonacci(int n)  {
    if (n < 2) return n;

    return fibonacci(n - 1) + fibonacci(n - 2);
}

Comments

কিভাবে এই ছাড়া ভিন্ন এই বা এই বা এই উত্তর দিয়েছিলেন?

— টুনাকি

এটি কেবল খাটো এবং সহজেই পড়া সহজ, কোন অ্যালগোরিদম সর্বদা হওয়া উচিত =)

— ওটাভিও ফেরেরিরা

@ ওটাভিওফেরির একমাত্র উত্তর যা আমার সমস্যা সমাধান করতে সক্ষম হয়েছে, ভাল কাজ

— কেকেকেেকে ২১ শে মার্চ'১৯

Answer 6

                                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)

গুরুত্বপূর্ণ লক্ষণীয় বিষয় হল এই অ্যালগরিদমটি তাত্পর্যপূর্ণ কারণ এটি আগের গণনা করা সংখ্যার ফলাফল সংরক্ষণ করে না store যেমন এফ (এন -3) 3 বার বলা হয়।

আরও তথ্যের জন্য দাসগুপ্ত অধ্যায় 0.2 দ্বারা অ্যালগরিদম পড়ুন

Comments

একটি প্রোগ্রামিং পদ্ধতি রয়েছে যার মাধ্যমে আমরা

— ডিনামিক

Answer 7

বেশিরভাগ উত্তর ভাল থাকে এবং ফাইবোনাকিতে পুনরাবৃত্তি কীভাবে কাজ করে তা ব্যাখ্যা করে।

এখানে তিনটি কৌশল সম্পর্কে বিশ্লেষণ করা হয়েছে যার মধ্যে পুনরাবৃত্তিও অন্তর্ভুক্ত রয়েছে:

1. লুপের জন্য
2. recursion
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

অতএব আমরা দেখতে পাচ্ছি যে স্মৃতিচারণটিই সেরা সময় অনুসারে এবং লুপের সাথে খুব কাছাকাছি মিল রয়েছে।

তবে পুনরাবৃত্তি সবচেয়ে দীর্ঘ সময় নেয় এবং আপনার বাস্তব জীবনে এড়ানো উচিত। এছাড়াও যদি আপনি পুনরাবৃত্তি ব্যবহার করছেন তবে নিশ্চিত হয়ে নিন যে আপনি সমাধানটি অনুকূলিত করেছেন।

Comments

"এখানে আমরা দেখতে পারি যে লুপটি সেরা সময় অনুসারে হয়"; "লুপ সময়ের জন্য: 347688"; "স্মৃতিচারণের সময়: 327031"; 347688> 327031.

— অজাহানচর্লেস

@ কোডকনফিডেন্ট হ্যাঁ, আমি আজই সেই ভুলটি দেখেছি এবং এটি সংশোধন করতে চলেছি। যাইহোক, ধন্যবাদ :).

— প্রীতম বন্দ্যোপাধ্যায়

Answer 8

এটি আমি খুঁজে পেয়েছি এমন সেরা ভিডিও যা জাভাতে পুনরাবৃত্তি এবং ফিবোনাকির ক্রমটি পুরোপুরি ব্যাখ্যা করে।

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

Answer 9

ফাইবোনাকি পুনরাবৃত্তি সমাধানের জন্য, বৃহত সংখ্যার মান পুনরুদ্ধার করার সময়, ছোট ফিবোনাচি সংখ্যাগুলির আউটপুট সংরক্ষণ করা গুরুত্বপূর্ণ। একে বলা হয় "স্মৃতিচারণ" "

এখানে এমন একটি কোড রয়েছে যা বৃহত ফিবোনাচি নম্বর পুনরুদ্ধার করার সময় আরও ছোট ফিবোনাচি মানগুলিকে মেমোজাইজ করে use এই কোডটি দক্ষ এবং একই ফাংশনের একাধিক অনুরোধ করে না।

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

Answer 10

মধ্যে Fibonacci ক্রম, প্রথম দুটি আইটেম 0 এবং 1 হয়, একে অপরের আইটেমটি দুই পূর্ববর্তী আইটেম এর সমষ্টি। অর্থাৎ,
0 1 1 2 3 5 8 ...

সুতরাং 5 ম আইটেমটি 4 র্থ এবং তৃতীয় আইটেমগুলির যোগফল।

Answer 11

মাইকেল গুডরিচ এট আল [ফাইব (এন), ফাইব (এন -১)] এর অ্যারে ফিরিয়ে লিনিয়ার সময়ে ফিবোনাচি পুনরাবৃত্তভাবে সমাধান করার জন্য, জাভাতে ডেটা স্ট্রাকচার এবং অ্যালগরিদমগুলিতে একটি সত্যই চৌকস অ্যালগরিদম সরবরাহ করেন।

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] দেয়।

Answer 12

এখানে ও (1) সমাধান:

 private static long fibonacci(int n) {
    double pha = pow(1 + sqrt(5), n);
    double phb = pow(1 - sqrt(5), n);
    double div = pow(2, n) * sqrt(5);

    return (long) ((pha - phb) / div);
}

উপরের প্রয়োগের জন্য বিনেটের ফিবোনাচি নম্বর সূত্র বড় ইনপুট জন্য longপ্রতিস্থাপন করা যেতে পারে BigDecimal।

Answer 13

একটি ফিবোনাচি সিকোয়েন্স হ'ল 1 দিয়ে শুরু করে পূর্বের ফলাফলের সাথে যুক্ত হওয়ার সাথে সংখ্যার ফলাফলের যোগফল।

      so.. 1 + 1 = 2
           2 + 3 = 5
           3 + 5 = 8
           5 + 8 = 13
           8 + 13 = 21

ফিবোনাচি কী তা আমরা বুঝতে পারলে আমরা কোডটি ভাঙতে শুরু করতে পারি।

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

প্রথম যদি স্টেটমেন্ট একটি বেস কেসটি পরীক্ষা করে, যেখানে লুপটি বেরিয়ে যেতে পারে। অন্যথায় যদি নীচের বিবৃতিটি একই কাজ করে তবে এটি আবার লিখতে পারে ...

    public int fibonacci(int n)  {
        if(n < 2)
             return n;

        return fibonacci(n - 1) + fibonacci(n - 2);
    }

এখন একটি বেস কেসটি প্রতিষ্ঠিত হওয়ার পরে আমাদের কল স্ট্যাকটি বুঝতে হবে। "ফাইবোনাচি" তে আপনার প্রথম কলটি স্ট্যাকের (কলগুলির ক্রম) সমাধান করার জন্য সর্বশেষ হবে কারণ তারা কল করা হয়েছিল তার বিপরীত ক্রমে সমাধান করবে। শেষ পদ্ধতিটি প্রথমে সমাধান করে, তারপরে সর্বশেষে সেইটির আগে ডাকা হবে এবং আরও কিছু ...

সুতরাং, ফলাফলগুলির সাথে কোনও কিছু "গণনা" করার আগে সমস্ত কলগুলি প্রথমে করা হয়। 8 এর ইনপুট সহ আমরা 21 এর আউটপুট আশা করি (উপরের টেবিলটি দেখুন)।

ফাইবোনাকি (এন - 1) বেস কেস না পৌঁছানো অবধি কল করা থাকে, তারপরে এটি বেস কেসে না পৌঁছানো পর্যন্ত ফাইবোনাকি (এন - 2) বলা হয়। স্ট্যাক যখন বিপরীত ক্রমে ফলাফলের সংমিশ্রণ শুরু করে, ফলাফলটি এরকম হবে ...

1 + 1 = 1        ---- last call of the stack (hits a base case).
2 + 1 = 3        ---- Next level of the stack (resolving backwards).
2 + 3 = 5        ---- Next level of the stack (continuing to resolve).

স্ট্যাকের প্রথম কলটিতে সঠিক যোগফল না ফেরানো পর্যন্ত তারা বুদবুদ (পিছনের দিকে সমাধান) অবিরত রাখে এবং এভাবেই আপনি আপনার উত্তর পান।

এটি বলার পরে, এই অ্যালগরিদমটি খুব অদক্ষ কারণ এটি প্রতিটি শাখার জন্য একই ফলাফল গণনা করে কোডটি বিভক্ত হয়। আরও ভাল পদ্ধতির একটি "ডাউন আপ" এটি যেখানে কোনও স্মৃতিচারণ (ক্যাশিং) বা পুনরাবৃত্তি (ডিপ কল স্ট্যাক) প্রয়োজন হয় না।

তাই ভালো...

        static int BottomUpFib(int current)
        {
            if (current < 2) return current;

            int fib = 1;
            int last = 1;

            for (int i = 2; i < current; i++)
            {
                int temp = fib;
                fib += last;
                last = temp;
            }

            return fib;
        }

Answer 14

এখানে প্রদত্ত বেশিরভাগ সমাধান ও (2 ^ n) জটিলতায় চালিত হয়। পুনরাবৃত্ত গাছে অভিন্ন নোডগুলি পুনরায় গণনা করা অদক্ষ এবং সিপিইউ চক্রকে অপচয় করে।

ও (এন) সময়ে ফিবোনাচি ফাংশন চালাতে আমরা মেমোইজেশন ব্যবহার করতে পারি

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

Answer 15

এই উত্তরটি কেন আলাদা

অন্য প্রতিটি উত্তর হয়:

• রিটার্নের পরিবর্তে প্রিন্ট করুন
• পুনরাবৃত্তির জন্য 2 পুনরাবৃত্ত কলগুলি করে
• লুপগুলি ব্যবহার করে প্রশ্নটিকে উপেক্ষা করে

(সরাইয়া: এই কেউই আসলে কার্যকরী; ব্যবহার Binet 'স সূত্র সরাসরি এন নিরূপণ ^তম শব্দ)

টেল রিকার্সিভ ফিব

এখানে একটি পুনরাবৃত্তির পদ্ধতি যা পূর্ববর্তী উত্তর এবং এর আগে একটি উত্তর দুটি দিয়ে দ্বি-পুনরাবৃত্ত কলকে এড়িয়ে চলে।

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

Answer 16

এটি একটি মৌলিক অনুক্রম যা প্রদর্শন করে বা 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);
}

চামচ খাওয়ানোর জন্য জাভা রিকার্সিভ ফিবোনাচি সিকোয়েন্স টিউটোরিয়াল দেখুন এখানে ক্লিক করুন

Comments

তার কী বোঝার দরকার ছিল তা হল কোডটি কীভাবে কাজ করে এবং কেন এটি লিখিত হয় সেভাবে লেখা হয়।

— আদর্শ

আমার মনে হয় আমি আমার প্রথম বাক্যে উল্লেখ করেছি এটি কীভাবে কাজ করে? আমি কোডটি আরও সহজ করার জন্য লিখছি। বিটিডব্লিউ, দুঃখিত।

— জেমেলসন গাল্যাং

আপনার কোডে কোনও ভুল নেই। এই কোডটি কীভাবে কাজ করেছে তা কেবলমাত্র লোকটিই বুঝতে চেয়েছিল। উত্তরটি র‌্যান্যাগ দ্বারা পরীক্ষা করুন। এই ধরণের কিছু :)

— আদর্শ

আহ্ ঠিক আছে, দুঃখিত আমি স্ট্যাকওভারফ্লোতে এখানেই আছি। কেবলমাত্র to _ ^

— জয়মেলসন গালং

Answer 17

আমি মনে করি এটি একটি সহজ উপায়:

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

Answer 18

রনর্যাগ (স্বীকৃত) উত্তরটি ঠিক কাজ করবে তবে এটি অনিলের উত্তরে বর্ণিত হিসাবে মুখস্থ না হওয়া অবধি সমাধানের অনুকূল সমাধান নয়।

পুনরাবৃত্তির জন্য নীচের পদ্ধতির বিবেচনা করুন, পদ্ধতি কলগুলি 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);
        }
    }

}

Answer 19

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

Answer 20

একটি অভ্যন্তরীণ কনকন্ট্র্যান্ট হ্যাশম্যাপ ব্যবহার করে যা তাত্ত্বিকভাবে এই পুনরাবৃত্তির প্রয়োগটি একটি বহুবিধ পরিবেশে সঠিকভাবে পরিচালনা করার অনুমতি দিতে পারে, আমি একটি ফাইব ফাংশন প্রয়োগ করেছি যা বিগইন্টিজার এবং পুনরাবৃত্তি উভয়ই ব্যবহার করে। প্রথম 100 টি fib সংখ্যা গণনা করতে প্রায় 53ms নেয়।

private final Map<BigInteger,BigInteger> cacheBig  
    = new ConcurrentHashMap<>();
public BigInteger fibRecursiveBigCache(BigInteger n) {
    BigInteger a = cacheBig.computeIfAbsent(n, this::fibBigCache);
    return a;
}
public BigInteger fibBigCache(BigInteger n) {
    if ( n.compareTo(BigInteger.ONE ) <= 0 ){
        return n;
    } else if (cacheBig.containsKey(n)){
        return cacheBig.get(n);
    } else {
        return      
            fibBigCache(n.subtract(BigInteger.ONE))
            .add(fibBigCache(n.subtract(TWO)));
    }
}

পরীক্ষার কোডটি হ'ল:

@Test
public void testFibRecursiveBigIntegerCache() {
    long start = System.currentTimeMillis();
    FibonacciSeries fib = new FibonacciSeries();
    IntStream.rangeClosed(0,100).forEach(p -&R {
        BigInteger n = BigInteger.valueOf(p);
        n = fib.fibRecursiveBigCache(n);
        System.out.println(String.format("fib of %d is %d", p,n));
    });
    long end = System.currentTimeMillis();
    System.out.println("elapsed:" + 
    (end - start) + "," + 
    ((end - start)/1000));
}

এবং পরীক্ষা থেকে আউটপুট হয়:
    ।
    ।
    ।
    ।
    ।
    93 এর fib 12200160415121876738
    94 এর fib 19740274219868223167
    95 এর fib 31940434634990099905
    96 এর fib 51680708854858323072
    97 এর fib 83621143489848422977
    98 এর fib 135301852344706746049
    99 এর fib 218922995834555169026
    100 এর fib হ'ল 354224848179261915075
    অতিবাহিত: 58,0

Answer 21

এখানে একটি ওলাইন ফ্যাবনাচি পুনরাবৃত্তি:

public long fib( long n ) {
        return n <= 0 ? 0 : n == 1 ? 1 : fib( n - 1 ) + fib( n - 2 );
}

Answer 22

এটা চেষ্টা কর

private static int fibonacci(int n){
    if(n <= 1)
        return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

Answer 23

কেবলমাত্র পরিপূরক হিসাবে, আপনি যদি আরও বড় সংখ্যা গণনা করতে সক্ষম হতে চান তবে আপনার বিগইন্টিজার ব্যবহার করা উচিত।

একটি পুনরাবৃত্তি উদাহরণ।

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

Answer 24

আরও বিশদে http://en.wikedia.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));
    }

}

লুপ এবং অন্যান্য লুপ ব্যবহার করার প্রয়োজন নেই এমন প্রয়োজনটিকে এটিকে সহজ করুন

Answer 25

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

Answer 26

ব্যবহার while:

public int fib(int index) {
    int tmp = 0, step1 = 0, step2 = 1, fibNumber = 0;
    while (tmp < index - 1) {
        fibNumber = step1 + step2;
        step1 = step2;
        step2 = fibNumber;
        tmp += 1;
    };
    return fibNumber;
}

এই সমাধানটির সুবিধাটি হ'ল কোডটি পড়া এবং এটি বুঝতে সহায়তা করে আশা করা সহজ

Answer 27

একটি ফিবোনাচি ক্রমটি এমন একটি যা সংখ্যার ফলাফলের সমষ্টি হয় তারপরে আমরা পূর্বের ফলাফলটি যুক্ত করেছি, আমাদের 1 থেকে শুরু করা উচিত al পূর্ববর্তী নম্বর এবং আমি অবস্থান পরিবর্তন করেছি। আমি 1 থেকে 15 পর্যন্ত ফিবোনাচি সিকোয়েন্সটি অনুসন্ধান করছি।

public static void main(String args[]) {

    numbers(1,1,15);
}


public static int numbers(int a, int temp, int target)
{
    if(target <= a)
    {
        return a;
    }

    System.out.print(a + " ");

    a = temp + a;

    return numbers(temp,a,target);
}

Answer 28

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

Answer 29

সিম্পল ফিবোনাচি

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

Comments

তাই আপনাকে স্বাগতম। যদিও আপনার উত্তরটি ফিবোনাচি ক্রম গণনা করে। আপনার উত্তর ওপিকে উত্তর দেয় না, যিনি পুনরাবৃত্তির কার্যকারিতা সম্পর্কে জিজ্ঞাসা করেছিলেন।

— জেমস কে

Answer 30

@ ক্রো স্পট রয়েছে, তবে তিনি পুনরাবৃত্তভাবে এটি করার সঠিক উপায়টি দেখান না। সমাধান এখানে:

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