Sum of Fibonacci Numbers (original) (raw)

Last Updated : 23 Jul, 2025

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

Try It Yourself

Table of Content

• [Naive Approach] By storing all Fibonacci numbers - O(n) time and O(n) space
• [Better Approach] Space Optimized - O(n) time and O(1) space
• [Expected Approach] Efficient Fibonacci Sum Calculation - O(log(n)) time and O(n) space

**[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 #include 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));

`

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

`

**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 #include using namespace std;

// Returns n'th Fibonacci number using table f[] int fib(vector&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 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));

`

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