Multithreaded program generates Fibonacci series using java-answer?

Answer 1

The formula for the Fibonacci series is

Fn = Fn-1 + Fn-2 for n ≥ 2 with F0 = 0 and F1 = 1.

In layman's terms, in the Fibonacci series each successive number is the sum of the previous two numbers, starting with 1. So we have 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 etc

To do this in Java or any computer program you will need to create a recursive program, one that picks up previous values. This is quite easy, even for a beginner, once one grasps the Fibonacci fundamentals. Here is an example in Java:

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

}

}

For n, enter the number of values required, otherwise the increasing values of the results will overflow the parameters of the data display!

This code can be adapted for any progamming language, e.g. pascal, basic etc. One can even use the principles to construct a spreadsheet that will show the Fibonacci series in successive rows in Excel, for example.

• For more information, enhanced development and downloadable Java code for generating Fibonacci numbers, see 'Related links' below this box

Answer 2

// Print out the first N Fibonacci numbers in the order:

// 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765

public static final void printFib(final int N) {

int f0 = 0;

int f1 = 1;

for (int i = 0; i < N; ++i) {

System.out.println(f0);

final int temp = f1;

f1 += f0;

f0 = temp;

}

}

Answer 3

Well, you might use recursion, but that would be exceedingly inefficient. A loop would be much better in this case. The only advantage I see is for didactical purposes, that you practice recursion. Something like this; I didn't try it:

// Call the class MyMath.fib()

int fib(int number)
{
if (number <= 2) return 1;
else return fib(number - 1) + fib(number - 2);

}

Note: A recursive function (or method) is one that invokes itself.

Well, you might use recursion, but that would be exceedingly inefficient. A loop would be much better in this case. The only advantage I see is for didactical purposes, that you practice recursion. Something like this; I didn't try it:

// Call the class MyMath.fib()

int fib(int number)
{
if (number <= 2) return 1;
else return fib(number - 1) + fib(number - 2);

}

Note: A recursive function (or method) is one that invokes itself.

Well, you might use recursion, but that would be exceedingly inefficient. A loop would be much better in this case. The only advantage I see is for didactical purposes, that you practice recursion. Something like this; I didn't try it:

// Call the class MyMath.fib()

int fib(int number)
{
if (number <= 2) return 1;
else return fib(number - 1) + fib(number - 2);

}

Note: A recursive function (or method) is one that invokes itself.

Well, you might use recursion, but that would be exceedingly inefficient. A loop would be much better in this case. The only advantage I see is for didactical purposes, that you practice recursion. Something like this; I didn't try it:

// Call the class MyMath.fib()

int fib(int number)
{
if (number <= 2) return 1;
else return fib(number - 1) + fib(number - 2);

}

Note: A recursive function (or method) is one that invokes itself.

Answer 4

Here is a function to generate the nth Fibonacci number, using a recursion:

public long F (int n)

{

if (n 1)

{

return n;

}

else

{

return F (n - 1) + F (n - 2);

}

}

Note that if n < 0, the function doesn't work. You could also program it by the algebraic formula for the nth Fibonacci number, as follows:

public long F (int n)

{

double a = Math.sqrt (5); //to save code

return (long) (Math.pow ((1 + a) / 2, n) - Math.pow ((1 - a) / 2, n)) / a;

}

Answer 5

The Fibonacci series is not a good candidate for solution using a multithreaded program. This is because each term is dependent on the prior two terms, making it impossible to keep more than one thread unblocked at any one moment of time.

Answer 6

Set two variables "a" and "b" to the starting number of the Fibonacci series, for example, 1 and 1. Then, repeatedly (i.e., in a loop) set:

sum = a + b;

b = a;

a = sum;

... and print the sum (or equivalently, variable "a").

Answer 7

Well, you might use recursion, but that would be exceedingly inefficient. A loop would be much better in this case. The only advantage I see is for didactical purposes, that you practice recursion. Something like this; I didn't try it:

// Call the class MyMath.fib()

int fib(int number)
{
if (number <= 2) return 1;
else return fib(number - 1) + fib(number - 2);

}

Note: A recursive function (or method) is one that invokes itself.

Answer 8

Here is a recursive way of writing Fibonacci series

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