Fibonacci numbers, with an one-liner in Java?

Question

I would like to know how can I find nth fibonacci number with most Javatic way with a one-line. This is my code, but i want to learn better way.

class FibonacciExample1 {
    public static void main(String[] args) {
        int n1 = 0, n2 = 1, n3, i, count = 10;
        System.out.print(n1 + " " + n2);//printing 0 and 1    

        for (i = 2; i < count; ++i)//loop starts from 2 because 0 and 1 are already printed    
        {
            n3 = n1 + n2;
            System.out.print(" " + n3);
            n1 = n2;
            n2 = n3;
        }

    }
}

"most Javatic way": the normal Java way would not to try to implement it in one lline. — Raedwald, Jun 03 '19 at 11:57

Melih Altıntaş · Accepted Answer · 2019-06-02T13:04:09.690

12

With stream api this is very easy

Fibonacci series: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55.... The first two numbers of the series are 0 and 1, and each subsequent number is the sum of the previous two. The series of Fibonacci tuples is similar; you have a sequence of a number and its successor in the series: (0, 1), (1, 1), (1, 2), (2, 3), (3, 5), (5, 8), (8, 13), (13, 21)....

iterate needs a lambda to specify the successor element. In the case of the tuple (3, 5) the successor is (5, 3+5) = (5, 8). The next one is (8, 5+8). Can you see the pattern? Given a tuple, the successor is (t[1], t[0] + t[1]). This is what the following lambda specifies: t -> new int[]{t[1],t[0] + t[1]}. By running this code you’ll get the series (0, 1), (1, 1), (1, 2), (2, 3), (3, 5), (5, 8), (8, 13), (13, 21).... Note that if you just wanted to print the normal Fibonacci series, you could use a map to extract only the first element of each tuple:

Stream.iterate(new long[]{0, 1}, t -> new long[]{t[1], t[0] + t[1]})
    .limit(10)
    .map(t -> t[0])
    .forEach(System.out::println);

this is the stream api : https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html

edited Jun 02 '19 at 13:04

answered Jun 02 '19 at 12:42

Melih Altıntaş

2,495
1
22
35

You are really quick :) – Michał Krzywański Jun 02 '19 at 12:43
@michalk thanks :) I wonder the better answers – Melih Altıntaş Jun 02 '19 at 12:50
1

In case if limit is greater then `47` the overflow occurs. – Edgar Asatryan Jun 02 '19 at 12:53
@EdgarAsatryan Yes, because Fibonacci's 48th number is bigger than `Integer.MAX_VALUE` (2,147,483,647), hence the bits of the integer are getting "overflowed". Change `int` to `long` and it will work for limit > 47 – George Z. Jun 02 '19 at 12:59
@MelihAltıntaş, Exactly. It would be reasonable to change `int` to `long` or even `BigInteger` in the answer. WDYT? – Edgar Asatryan Jun 02 '19 at 13:02
I will change the answer thanks :) – Melih Altıntaş Jun 02 '19 at 13:03

score 1 · Answer 2 · answered Jun 02 '19 at 16:13

Here's a recursive "one-liner" (the function body only has one line using a nested ternary):

public static long Fibonacci(int termNumber)
{
    return (termNumber == 1) ? 0 : (termNumber == 2) ? 1 : Fibonacci(termNumber - 1) + Fibonacci(termNumber -2);
}

Example driver:

public class Fibonacci
{
    public static void main(String[] args)
    {
        for(int i = 1; i <= 10; i++)
        {
            System.out.println("Fibonacci(" + i + ") = " + Fibonacci(i));
        }
    }

    public static long Fibonacci(int termNumber)
    {
        return (termNumber == 1) ? 0 : (termNumber == 2) ? 1 : Fibonacci(termNumber - 1) + Fibonacci(termNumber -2);
    }

}

Output:

Fibonacci numbers, with an one-liner in Java?

2 Answers2