Open In App

Sum of Fibonacci Numbers

Last Updated : 03 Apr, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report
Try it on GfG Practice
redirect icon

Given a number positive number n, find value of f0 + f1 + f2 + .... + fn where fi indicates i'th Fibonacci number. Remember that f0 = 0, f1 = 1, f2 = 1, f3 = 2, f4 = 3, f5 = 5, ... 
Examples : 

Input  : n = 3
Output : 4
Explanation : 0 + 1 + 1 + 2  = 4

Input  :  n = 4
Output :  7
Explanation : 0 + 1 + 1 + 2 + 3  = 7

Table of Content

[Naive Approach] By storing all Fibonacci numbers - O(n) time and O(n) space

The idea is simple we will first generate all Fibonacci numbers up to a given number n, then compute and print the sum of these Fibonacci numbers.

C++ 
#include <iostream>
#include <vector>
using namespace std;

int calculateSum(int n)
{
    if (n <= 0)
       return 0;

    vector<int> fibo(n+1);
    fibo[0] = 0, fibo[1] = 1;

    // Initialize result
    int sum = fibo[0] + fibo[1];

    // Add remaining terms
    for (int i=2; i<=n; i++)
    {
        fibo[i] = fibo[i-1]+fibo[i-2];
        sum += fibo[i];
    }

    return sum;
}

int main()
{
    int n = 4;
    cout << calculateSum(n) << endl;
    return 0;
}
Java 
// Java Program to find
// sum of Fibonacci numbers

import java.io.*;

class GFG {
    
    static int calculateSum(int n)
    {
        if (n <= 0)
           return 0;
     
        int fibo[]=new int[n+1];
        fibo[0] = 0; fibo[1] = 1;
     
        // Initialize result
        int sum = fibo[0] + fibo[1];
     
        // Add remaining terms
        for (int i=2; i<=n; i++)
        {
            fibo[i] = fibo[i-1]+fibo[i-2];
            sum += fibo[i];
        }
     
        return sum;
    }
     
    public static void main(String args[])
    {
        int n = 4;
        System.out.println(calculateSum(n));
    }
}
Python 
def calculateSum(n) :
    if (n <= 0) :
        return 0
 
    fibo =[0] * (n+1)
    fibo[1] = 1
 
    # Initialize result
    sm = fibo[0] + fibo[1]
 
    # Add remaining terms
    for i in range(2,n+1) :
        fibo[i] = fibo[i-1] + fibo[i-2]
        sm = sm + fibo[i]
        
    return sm

n = 4
print(calculateSum(n))
C# 
using System;

class GfG 
{
    static int calculateSum(int n)
    {
        if (n <= 0)
        return 0;
    
        int []fibo = new int[n + 1];
        fibo[0] = 0; fibo[1] = 1;
    
        // Initialize result
        int sum = fibo[0] + fibo[1];
    
        // Add remaining terms
        for (int i = 2; i <= n; i++)
        {
            fibo[i] = fibo[i - 1] + fibo[i - 2];
            sum += fibo[i];
        }
    
        return sum;
    }
    
    static void Main()
    {
        int n = 4;
        Console.WriteLine(calculateSum(n));
    }
}
JavaScript 
function calculateSum(n) {
    if (n <= 0)
        return 0;

    let fibo = new Array(n + 1);
    fibo[0] = 0;
    fibo[1] = 1;

    // Initialize result
    let sum = fibo[0] + fibo[1];

    // Add remaining terms
    for (let i = 2; i <= n; i++) {
        fibo[i] = fibo[i - 1] + fibo[i - 2];
        sum += fibo[i];
    }

    return sum;
}

let n = 4;
console.log(calculateSum(n));

Output
7

Time Complexity: O(n)
Auxiliary Space: O(n)

[Better Approach] Space Optimized - O(n) time and O(1) space

This approach is just an optimization of the above approach, Instead of using the extra array for storing the Fibonacci numbers, we can store the values in the variables. We keep the previous two numbers only because that is all we need to get the next Fibonacci number in series.

C++ 
#include <iostream>
using namespace std;

int calculateSum(int n)
{
    int a = 0, b = 0, sumf = 1;
    
    // Edge Case When n is 0
    if (n <= 0)
        return 0;

    int curr = 1;
    for (int i = 2; i <= n; i++)
    {
        // update a,b and curr
        a = b;
        b = curr;
        curr = a + b;
        sumf += curr;
    }

    return sumf;
}

int main()
{

    int n = 4;
    cout << calculateSum(n) << endl;
    return 0;
}
Java 
public class GfG{
    public static int calculateSum(int n) {
        int a = 0, b = 0, sumf = 1;
        
        // Edge Case When n is 0
        if (n <= 0)
            return 0;

        int curr = 1;
        for (int i = 2; i <= n; i++) {
            // update a,b and curr
            a = b;
            b = curr;
            curr = a + b;
            sumf += curr;
        }

        return sumf;
    }

    public static void main(String[] args) {
        int n = 4;
        System.out.println(calculateSum(n));
    }
}
Python 
def calculate_sum(n):
    a = 0
    b = 0
    sumf = 1
    
    # Edge Case When n is 0
    if n <= 0:
        return 0

    curr = 1
    for i in range(2, n + 1):
        # update a,b and curr
        a = b
        b = curr
        curr = a + b
        sumf += curr

    return sumf

n = 4
print(calculate_sum(n))
C# 
using System;

class GfG{
    static int CalculateSum(int n) {
        int a = 0, b = 0, sumf = 1;
        
        // Edge Case When n is 0
        if (n <= 0)
            return 0;

        int curr = 1;
        for (int i = 2; i <= n; i++) {
            // update a,b and curr
            a = b;
            b = curr;
            curr = a + b;
            sumf += curr;
        }

        return sumf;
    }

    static void Main() {
        int n = 4;
        Console.WriteLine(CalculateSum(n));
    }
}
JavaScript 
function calculateSum(n) {
    let a = 0, b = 0, sumf = 1;
    
    // Edge Case When n is 0
    if (n <= 0)
        return 0;

    let curr = 1;
    for (let i = 2; i <= n; i++) {
        // update a,b and curr
        a = b;
        b = curr;
        curr = a + b;
        sumf += curr;
    }

    return sumf;
}

let n = 4;
console.log(calculateSum(n));

Output
7

Time Complexity: O(n)
Auxiliary Space: O(1)

[Expected Approach] Efficient Fibonacci Sum Calculation - O(log(n)) time and O(n) space

The idea is to find relationship between the sum of Fibonacci numbers and n'th Fibonacci number.
F(i) refers to the i'th Fibonacci number. 
S(i) refers to sum of Fibonacci numbers till F(i), 
 

We can rewrite the relation F(n+1) = F(n) + F(n-1) as below
F(n-1) = F(n+1) - F(n)

Similarly,
F(n-2) = F(n) - F(n-1)
. . .
. . .
. . .
F(0) = F(2) - F(1)
-------------------------------


Adding all the equations, on left side, we have 
F(0) + F(1) + ... F(n-1) which is S(n-1).
Therefore, 
S(n-1) = F(n+1) - F(1) 
S(n-1) = F(n+1) – 1 
S(n) = F(n+2) - 1 ----(1)
In order to find S(n), simply calculate the (n+2)'th Fibonacci number and subtract 1 from the result.
F(n) can be evaluated in O(log n) time using either method 5 or method 6 in this article (Refer to methods 5 and 6).
Below is the implementation based on method 6 of this 
 

C++ 
#include <iostream>
#include <vector>
using namespace std;

// Returns n'th Fibonacci number using table f[]
int fib(vector<int>&f,int n)
{
    // Base cases
    if (n == 0)
        return 0;
    if (n == 1 || n == 2)
        return (f[n] = 1);

    // If fib(n) is already computed
    if (f[n])
        return f[n];

    int k = (n & 1)? (n+1)/2 : n/2;

    // Applying above formula [Note value n&1 is 1
    // if n is odd, else 0].
    f[n] = (n & 1)? (fib(f,k)*fib(f,k) + fib(f,k-1)*fib(f,k-1))
           : (2*fib(f,k-1) + fib(f,k))*fib(f,k);

    return f[n];
}

int calculateSum(int n)
{
    vector<int> f(n+3);
    return fib(f,n+2) - 1;
}

int main()
{
    int n = 4;
    cout << calculateSum(n) << endl;
    return 0;
}
Java 
import java.util.Arrays;

public class GfG{
    
    // Returns n'th Fibonacci number using table f[]
    static int fib(int[] f, int n) {
        
        // Base cases
        if (n == 0) return 0;
        if (n == 1 || n == 2) return (f[n] = 1);

        // If fib(n) is already computed
        if (f[n] != 0) return f[n];

        int k = (n % 2 == 1) ? (n + 1) / 2 : n / 2;

        // Applying above formula
        f[n] = (n % 2 == 1) ? (fib(f, k) * fib(f, k) + fib(f, k - 1) * fib(f, k - 1)) : (2 * fib(f, k - 1) + fib(f, k)) * fib(f, k);

        return f[n];
    }

    static int calculateSum(int n) {
        int[] f = new int[n + 3];
        return fib(f, n + 2) - 1;
    }

    public static void main(String[] args) {
        int n = 4;
        System.out.println(calculateSum(n));
    }
}
Python 
# Returns n'th Fibonacci number using table f[]
def fib(f, n):
    
    # Base cases
    if n == 0:
        return 0
    if n == 1 or n == 2:
        f[n] = 1
        return f[n]

    # If fib(n) is already computed
    if f[n]:
        return f[n]

    k = (n + 1) // 2 if n % 2 else n // 2

    # Applying above formula
    f[n] = (fib(f, k) * fib(f, k) + fib(f, k - 1) * fib(f, k - 1)) if n % 2 else (2 * fib(f, k - 1) + fib(f, k)) * fib(f, k)

    return f[n]

def calculate_sum(n):
    f = [0] * (n + 3)
    return fib(f, n + 2) - 1

if __name__ == '__main__':
    n = 4
    print(calculate_sum(n))
C# 
using System;

class GfG{
    
    // Returns n'th Fibonacci number using table f[]
    static int Fib(int[] f, int n) {
        
        // Base cases
        if (n == 0) return 0;
        if (n == 1 || n == 2) return (f[n] = 1);

        // If fib(n) is already computed
        if (f[n] != 0) return f[n];

        int k = (n % 2 == 1) ? (n + 1) / 2 : n / 2;

        // Applying above formula
        f[n] = (n % 2 == 1) ? (Fib(f, k) * Fib(f, k) + Fib(f, k - 1) * Fib(f, k - 1)) : (2 * Fib(f, k - 1) + Fib(f, k)) * Fib(f, k);

        return f[n];
    }

    static int CalculateSum(int n) {
        int[] f = new int[n + 3];
        return Fib(f, n + 2) - 1;
    }

    static void Main() {
        int n = 4;
        Console.WriteLine(CalculateSum(n));
    }
}
JavaScript 
function fib(f, n) {
    
    // Base cases
    if (n === 0) return 0;
    if (n === 1 || n === 2) return (f[n] = 1);

    // If fib(n) is already computed
    if (f[n]) return f[n];

    let k = (n % 2 === 1) ? (n + 1) / 2 : n / 2;

    // Applying above formula
    f[n] = (n % 2 === 1) ? (fib(f, k) * fib(f, k) + fib(f, k - 1) * fib(f, k - 1)) : (2 * fib(f, k - 1) + fib(f, k)) * fib(f, k);

    return f[n];
}

function calculateSum(n) {
    let f = new Array(n + 3).fill(0);
    return fib(f, n + 2) - 1;
}

const n = 4;
console.log(calculateSum(n));

Output
7

Time Complexity: O(log (n))
Auxiliary Space: O(n)


Next Article
Program to Print Fibonacci Series

C

Chirag Agarwal
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox