Find nth Fibonacci number Using Golden ratio

Given a non-negative integer n, your task is to find the nth Fibonacci number. The Fibonacci sequence is a sequence where the next term is the sum of the previous two terms. The first two terms of the Fibonacci sequence are 0 followed by 1. The Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21

The Fibonacci sequence is defined as follows:

• F(0) = 0
• F(1) = 1
• F(n) = F(n - 1) + F(n - 2) for n > 1

Examples: 

Input: n = 5
Output: 5
Explanation: The 5th Fibonacci number is 5.

Input: n = 0
Output: 0 
Explanation: The 0th Fibonacci number is 0. 

Using Golden Ratio

The Fibonacci sequence can be approximated using the golden ratio: f_n = \mathrm{round}(f_{n-1} \times \phi) where, \phi \approx 1.618 .Since, the ratio of consecutive Fibonacci numbers approaches φ, we can use this property to compute the next number.

Till 4th term, the ratio is not much close to golden ratio (as 3/2 = 1.5, 2/1 = 2, ...). So, we will consider from 5th term to get next fibonacci number. To find out the 9th fibonacci number f9 (n = 9). Hence, this method is reliable only from the 5th term onward. After:

f6 = \mathrm{round}(f_5 \times \varphi) = 8
f7 = \mathrm{round}(f_6 \times \varphi) = 13
f8 = \mathrm{round}(f_7 \times \varphi) = 21
f9 = \mathrm{round}(f_8 \times \varphi) = 34

Note: 

• This method can calculate first 34 fibonacci numbers correctly. After that there may be difference from the correct value due to floating point arithmetic errors.
• We can optimize above solution work in O(Log n) by using Efficient Method to Compute Power.

#include <bits/stdc++.h>
using namespace std;

// function finding fibonacci number using golden ratio
int nthFibonacci(int n)
{
    // Approximate value of golden ratio
    double PHI = 1.6180339;

    // Fibonacci numbers upto n = 5
    int f[6] = {0, 1, 1, 2, 3, 5};

    // Fibonacci numbers for n < 6
    if (n < 6)
        return f[n];

    // Else start counting from 5th term
    int t = 5, fn = 5;

    while (t < n)
    {
        fn = round(fn * PHI);
        t++;
    }

    return fn;
}

// driver code
int main() {
    int n = 5;

    int ans = nthFibonacci(n);

    cout << "Fibonacci Number: " << ans << endl;

    return 0;
}

#include <stdio.h>
#include <math.h>

// function finding fibonacci number using golden ratio
int nthFibonacci(int n)
{
    // Approximate value of golden ratio
    double PHI = 1.6180339;

    // Fibonacci numbers upto n = 5
    int f[6] = {0, 1, 1, 2, 3, 5};

    // Fibonacci numbers for n < 6
    if (n < 6)
        return f[n];

    // Else start counting from 5th term
    int t = 5, fn = 5;

    while (t < n)
    {
        fn = (int)round(fn * PHI);
        t++;
    }

    return fn;
}

// driver code
int main() {
    int n = 5;

    int ans = nthFibonacci(n);

    printf("Fibonacci Number: %d\n", ans);

    return 0;
}

import java.util.*;

// solution class
class GfG {

    // function finding fibonacci number using golden ratio
    public static int nthFibonacci(int n)
    {
        // Approximate value of golden ratio
        double PHI = 1.6180339;

        // Fibonacci numbers upto n = 5
        int[] f = {0, 1, 1, 2, 3, 5};

        // Fibonacci numbers for n < 6
        if (n < 6)
            return f[n];

        // Else start counting from 5th term
        int t = 5, fn = 5;

        while (t < n)
        {
            fn = (int)Math.round(fn * PHI);
            t++;
        }

        return fn;
    }

    // driver code
    public static void main(String[] args) {
        int n = 5;

        int ans = nthFibonacci(n);

        System.out.println("Fibonacci Number: " + ans);
    }
}

import math

# function finding fibonacci number using golden ratio
def nthFibonacci(n):

    # Approximate value of golden ratio
    PHI = 1.6180339

    # Fibonacci numbers upto n = 5
    f = [0, 1, 1, 2, 3, 5]

    # Fibonacci numbers for n < 6
    if n < 6:
        return f[n]

    # Else start counting from 5th term
    t, fn = 5, 5

    while t < n:
        fn = round(fn * PHI)
        t += 1

    return fn


# driver code
if __name__ == "__main__":
    n = 5

    ans = nthFibonacci(n)

    print("Fibonacci Number:", ans)

using System;
using System.Collections.Generic;

// solution class
class GfG
{
    // function finding fibonacci number using golden ratio
    public static int nthFibonacci(int n)
    {
        // Approximate value of golden ratio
        double PHI = 1.6180339;

        // Fibonacci numbers upto n = 5
        int[] f = {0, 1, 1, 2, 3, 5};

        // Fibonacci numbers for n < 6
        if (n < 6)
            return f[n];

        // Else start counting from 5th term
        int t = 5, fn = 5;

        while (t < n)
        {
            fn = (int)Math.Round(fn * PHI);
            t++;
        }

        return fn;
    }

    // driver code
    public static void Main()
    {
        int n = 5;

        int ans = nthFibonacci(n);

        Console.WriteLine("Fibonacci Number: " + ans);
    }
}

// function finding fibonacci number using golden ratio
function nthFibonacci(n)
{
    // Approximate value of golden ratio
    let PHI = 1.6180339;

    // Fibonacci numbers upto n = 5
    let f = [0, 1, 1, 2, 3, 5];

    // Fibonacci numbers for n < 6
    if (n < 6)
        return f[n];

    // Else start counting from 5th term
    let t = 5, fn = 5;

    while (t < n)
    {
        fn = Math.round(fn * PHI);
        t++;
    }

    return fn;
}

// driver code
let n = 5;

let ans = nthFibonacci(n);

console.log("Fibonacci Number:", ans);

Fibonacci Number: 5

Time complexity: O(n)
Auxiliary space: O(1)