printing the results of a fibonacci series

Question

I know that the coding for the Fibonacci series is:

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

I was wondering if there is a way, using the aforementioned code, to print the previous results of the series, but neither using a void function (that acts only like a printer of the series) or calling the fibonacci funcion for each calculation

I do not want to do this

for (int i=0;i<4;i++){
     System.out.prinntln(fib(i));
}

Intead I want to only call the function once, like this:

fib(4);

and that the printing is:

0,1,1,2,3

of course using recursion

Any idea? Thanks

Answer 1

You could write another method void printFib(int n) and then use the loop to print each fib(n) within this method. A method that returns a value really shouldn't be printing anything. But if you compute each number iteratively as Zane said, you can have a void method that computes and prints the values. I don't see any way to print the values within the recursive Fibonacci method.

Answer 2

A simple example on Fibonnaci series.

class Fibonacci {
public static void main(String args[]) {

    fibonacciSeries(6);

}

static void fibonacciSeries(int num) {
    int a = 0, b = 1, i, c;

    for (i = 0; i <= num; i++) {
        if (i <= 1) {
            c = i;
        } else {
            c = a + b;
            a = b;
            b = c;
        }
        System.out.print(c);
        if(i != num) {
            System.out.print(",");
        }
    }
}

Output:

0,1,1,2,3,5,8

Answer 3

I hope its easy way to print Fibonacci Series

Fibonacci Series

public class Fib
{
public static void main(String[] args)
{
int first=0,second=1;next;
System.out.prinf("%d %d ",first,second);
    for(int i=0;i<=10;i++)
    {
     next=first+second;
     first=second;
     second=next;
     System.out.printf("%d ",second);
       }
   }
}

Output

0 1 1 2 3 5 8 13 21 34 55 89

Answer 4

Ok, so I didn't see you would like to keep the recursion.

Then how about this:

public class fib {

  static int fibonacci(int value, boolean printThis) {
    int result;
    if (value==0 || value==1) {
      result = value;
      if (printThis) {
        System.out.print(result);
        System.out.print(", ");
      }
    } else {
      if (printThis) {
        result =  fibonacci(value-1, true)+fibonacci(value-2, false);
        System.out.print(result);
        System.out.print(", ");
      } else {
        result = fibonacci(value-1, false)+fibonacci(value-2, false);
      }
    }
    return result;
  }

  public static void main(String []args) {
    fibonacci(7, true);
    System.out.println();
  }
}

I don't see that you can do without the boolean printThis to control that only one path of the tree spawned by the recursion over two values is printed. To make this a little clearer, see how you could do this for faculty recursively.

The recursion calls the computation backwards, so faculty(n) is called before of faculty(n-1). As you want print the value of faculty(n-1) before faculty(n), you need to print before you return the value, like this:

static int faculty(int v) {
  int result;
  if (v==0) {
    result = 1;
  } else {
    result = v*faculty(v-1);
  }
  System.out.print(result);
  System.out.print(", ");
  return result;
}

This will give you the values in ascending order. I hope you can forgive the last comma, you will need to define an additional function if you want to get rid of this without a boolean parameter controlling this.

So you see you can do for faculty without the boolean to control the printing.

But that is due to the fact that faculty will not span a tree of recursive calls, but is just a single sequence of calls. As said before, I only see that you can control the printing if you have a whole tree of calls by adding a boolean functions.

Is that what you were after?

Anyway, here's still my first answer (which is more efficient, and will give you the same output faster):

Compute the Fibonacci numbers iteratively instead of recursively.

The easiest way is to use an array fib[]. Initialize with fib[0] = 0, fib[1] = 1. Then iterate over i = 2 to n, where fib[i] = fib[i-1] + fib [i-2].

It's also easy to tune this so you don't need the full array, but only two variables to store fib[i-1], fib[i-2].

And in fact, you could take this iterative loop and then again make it a recursive loop, but it would have a different structure than your original fibonacci function.

Answer 5

int sum = 1;
int n1 = 0 , n2 = 1;

for(int i = 0; i < 10; i++)
{
    if(i < 1)
    {
        System.out.print(i);
        System.out.print(" ");
    }
    else if(i > 1)
    {
        System.out.print(sum);
        System.out.print(" ");
        sum = n1 + n2;
        n1 = n2;
        n2 = sum;
    }
}

Answer 6

So far, this is the most efficient and fastest way I could came out for the Fibonacci Sequence:

FIBONACCI DYNAMIC VERSION

public static BigInteger getFibonacciDynamic(long n) {

    BigInteger[] fibonacci = new BigInteger[(int) n + (n == 0 ? 2 : 1)];
    fibonacci[0] = BigInteger.valueOf(0);
    fibonacci[1] = BigInteger.valueOf(1);

    for (int i = 2; i <= n; i++) {
        fibonacci[i] = fibonacci[i - 1].add(fibonacci[i - 2]);
    }

    return fibonacci[(int) n];
}

You could run it this way for the first 1000 values:

public static void main(String[] args) {

    int index = 0;
    while (index < 1000) {
        long time = System.currentTimeMillis();
        BigInteger value = getFibonacciDynamic(index);
        System.out.println("VALUE: " + value + " TOOK: " + (System.currentTimeMillis() - time) + "ms" + " OF INDEX: " + index);
        index++;
    }
}

And will print out:

VALUE: 0 TOOK: 0ms OF INDEX: 0
VALUE: 1 TOOK: 0ms OF INDEX: 1
VALUE: 1 TOOK: 0ms OF INDEX: 2
VALUE: 2 TOOK: 0ms OF INDEX: 3
VALUE: 3 TOOK: 0ms OF INDEX: 4
VALUE: 5 TOOK: 0ms OF INDEX: 5
VALUE: 8 TOOK: 0ms OF INDEX: 6
VALUE: 13 TOOK: 0ms OF INDEX: 7
VALUE: 21 TOOK: 0ms OF INDEX: 8
VALUE: 34 TOOK: 0ms OF INDEX: 9
VALUE: 55 TOOK: 0ms OF INDEX: 10
VALUE: 89 TOOK: 0ms OF INDEX: 11
VALUE: 144 TOOK: 0ms OF INDEX: 12
VALUE: 233 TOOK: 0ms OF INDEX: 13
VALUE: 377 TOOK: 0ms OF INDEX: 14
VALUE: 610 TOOK: 0ms OF INDEX: 15
VALUE: 987 TOOK: 0ms OF INDEX: 16
VALUE: 1597 TOOK: 0ms OF INDEX: 17
VALUE: 2584 TOOK: 0ms OF INDEX: 18
VALUE: 4181 TOOK: 0ms OF INDEX: 19
VALUE: 6765 TOOK: 0ms OF INDEX: 20
... till index 1000 with always < 10ms for each value

If you use recursive at index 45 is going to take this long:

FIBONACCI RECURSIVE

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

---- PRINT ----
VALUE: 1134903170 TOOK: 9991ms OF INDEX: 45