Sum of Fibonacci numbers at even indexes upto N terms

Given a positive integer N, the task is to find the value of F₂ + F₄ + F₆ +………+ F_2n upto N terms where F_i denotes the i-th Fibonacci number.

The Fibonacci numbers are the numbers in the following integer sequence.

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ……

Examples:

Input: n = 5
Output: 88
N = 5, So the fibonacci series will be generated from 0th term upto 10th term:
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55
Sum of elements at even indexes = 0 + 1 + 3 + 8 + 21 + 55

Input: n = 8
Output: 1596
0 + 1 + 3 + 8 + 21 + 55 + 144 + 377 + 987 = 1596.

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Method-1: This method includes solving the problem directly by finding all Fibonacci numbers till 2n and adding up the only the even indices. But this will require O(n) time complexity.

Below is the implementation of the above approach:

C++

// C++ Program to find  sum 
// of even-indiced Fibonacci numbers 
#include <bits/stdc++.h> 
using namespace std; 
  
// Computes value of first fibonacci numbers 
// and stores the even-indexed sum 
int calculateEvenSum(int n) 
{ 
    if (n <= 0) 
        return 0; 
  
    int fibo[2 * n + 1]; 
    fibo[0] = 0, fibo[1] = 1; 
  
    // Initialize result 
    int sum = 0; 
  
    // Add remaining terms 
    for (int i = 2; i <= 2 * n; i++) { 
        fibo[i] = fibo[i - 1] + fibo[i - 2]; 
  
        // For even indices 
        if (i % 2 == 0) 
            sum += fibo[i]; 
    } 
  
    // Return the alternting sum 
    return sum; 
} 
  
// Driver program to test above function 
int main() 
{ 
  
    // Get n 
    int n = 8; 
  
    // Find the even-indiced sum 
    cout << "Even indexed Fibonacci Sum upto "
         << n << " terms: "
         << calculateEvenSum(n) << endl; 
  
    return 0; 
} 

Java

// Java Program to find sum 
// of even-indiced Fibonacci numbers 
  
import java.io.*; 
  
class GFG { 
  
  
// Computes value of first fibonacci numbers 
// and stores the even-indexed sum 
static int calculateEvenSum(int n) 
{ 
    if (n <= 0) 
        return 0; 
  
    int fibo[] = new int[2 * n + 1]; 
    fibo[0] = 0; fibo[1] = 1; 
  
    // Initialize result 
    int sum = 0; 
  
    // Add remaining terms 
    for (int i = 2; i <= 2 * n; i++) { 
        fibo[i] = fibo[i - 1] + fibo[i - 2]; 
  
        // For even indices 
        if (i % 2 == 0) 
            sum += fibo[i]; 
    } 
  
    // Return the alternting sum 
    return sum; 
} 
  
// Driver program  
    public static void main (String[] args) { 
            // Get n 
    int n = 8; 
  
    // Find the even-indiced sum 
    System.out.println("Even indexed Fibonacci Sum upto "
        + n + " terms: "+ 
        + calculateEvenSum(n)); 
  
    } 
} 
  
// This code is contributed 
// by shs 

Python 3

# Python3 Program to find sum  
# of even-indiced Fibonacci numbers  
  
# Computes value of first fibonacci 
# numbers and stores the even-indexed sum  
def calculateEvenSum(n) : 
  
    if n <= 0 : 
        return 0
  
    fibo = [0] * (2 * n + 1) 
    fibo[0] , fibo[1] = 0 , 1
  
    # Initialize result 
    sum = 0
  
    # Add remaining terms  
    for i in range(2, 2 * n + 1) : 
  
        fibo[i] = fibo[i - 1] + fibo[i - 2] 
  
        # For even indices  
        if i % 2 == 0 : 
            sum += fibo[i] 
  
    # Return the alternting sum  
    return sum
  
# Driver code 
if __name__ == "__main__" : 
  
    # Get n  
    n = 8
  
    # Find the even-indiced sum  
    print("Even indexed Fibonacci Sum upto", 
           n, "terms:", calculateEvenSum(n)) 
  
# This code is contributed  
# by ANKITRAI1 

C#

// C# Program to find sum of  
// even-indiced Fibonacci numbers  
using System; 
  
class GFG 
{ 
      
// Computes value of first fibonacci 
// numbers and stores the even-indexed sum  
static int calculateEvenSum(int n)  
{  
    if (n <= 0)  
        return 0;  
  
    int []fibo = new int[2 * n + 1];  
    fibo[0] = 0; fibo[1] = 1;  
  
    // Initialize result  
    int sum = 0;  
  
    // Add remaining terms  
    for (int i = 2; i <= 2 * n; i++) 
    {  
        fibo[i] = fibo[i - 1] +  
                  fibo[i - 2];  
  
        // For even indices  
        if (i % 2 == 0)  
            sum += fibo[i];  
    }  
  
    // Return the alternting sum  
    return sum;  
}  
  
// Driver Code  
static public void Main () 
{ 
    // Get n  
    int n = 8;  
      
    // Find the even-indiced sum  
    Console.WriteLine("Even indexed Fibonacci Sum upto " + 
                    n + " terms: " + calculateEvenSum(n));  
}  
}  
  
// This code is contributed 
// by Sach_Code 

PHP

<?php 
// PHP Program to find sum of  
// even-indiced Fibonacci numbers 
  
// Computes value of first fibonacci  
// numbers and stores the even-indexed sum 
function calculateEvenSum($n) 
{ 
    if ($n <= 0) 
        return 0; 
  
    $fibo[2 * $n + 1] = array(); 
    $fibo[0] = 0; $fibo[1] = 1; 
  
    // Initialize result 
    $sum = 0; 
  
    // Add remaining terms 
    for ($i = 2; $i <= 2 * $n; $i++)  
    { 
        $fibo[$i] = $fibo[$i - 1] +  
                    $fibo[$i - 2]; 
  
        // For even indices 
        if ($i % 2 == 0) 
            $sum += $fibo[$i]; 
    } 
  
    // Return the alternting sum 
    return $sum; 
} 
  
// Driver Code 
  
// Get n 
$n = 8; 
  
// Find the even-indiced sum 
echo "Even indexed Fibonacci Sum upto " . $n .  
     " terms: " . calculateEvenSum($n) . "\n"; 
  
// This code is contributed  
// by Akanksha Rai(Abby_akku) 
?> 

Output:

Even indexed Fibonacci Sum upto 8 terms: 1596

Method-2:

It can be clearly seen that the required sum can be obtained thus:
2 ( F₂ + F₄ + F₆ +………+ F_2n ) = (F₁ + F₂ + F₃ + F₄ +………+ F_2n) – (F₁ – F₂ + F₃ – F₄ +………+ F_2n)

Now the first term can be obtained if we put 2n instead of n in the formula given here.

Thus F₁ + F₂ + F₃ + F₄ +………+ F_2n = F_2n+2 – 1.

The second term can also be found if we put 2n instead of n in the formula given here

Thus, F₁ – F₂ + F₃ – F₄ +………- F_2n = 1 + (-1)²ⁿ⁺¹F_2n-1 = 1 – F_2n-1.

So, 2 ( F₂ + F₄ + F₆ +………+ F_2n)
= F_2n+2 – 1 – 1 + F_2n-1
= F_2n+2 + F_2n-1 – 2
= F_2n + F_2n+1 + F_2n+1 – F_2n – 2
= 2 ( F_2n+1 -1)
Hence, ( F₂ + F₄ + F₆ +………+ F_2n) = F_2n+1 -1 .

So in order to find the required sum, the task is to find only F_2n+1 which requires O(log n) time.( Refer to method 5 or method 6 in this article.

Below is the implementation of the above approach:

C++

// C++ Program to find even indexed Fibonacci Sum in 
// O(Log n) time. 
  
#include <bits/stdc++.h> 
using namespace std; 
  
const int MAX = 1000; 
  
// Create an array for memoization 
int f[MAX] = { 0 }; 
  
// Returns n'th Fibonacci number 
// using table f[] 
int fib(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(k) * fib(k) + fib(k - 1) * fib(k - 1)) 
                   : (2 * fib(k - 1) + fib(k)) * fib(k); 
  
    return f[n]; 
} 
  
// Computes value of even-indexed  Fibonacci Sum 
int calculateEvenSum(int n) 
{ 
    return (fib(2 * n + 1) - 1); 
} 
  
// Driver program to test above function 
int main() 
{ 
    // Get n 
    int n = 8; 
  
    // Find the alternating sum 
    cout << "Even indexed Fibonacci Sum upto "
         << n << " terms: "
         << calculateEvenSum(n) << endl; 
  
    return 0; 
} 

Java

// Java Program to find even indexed Fibonacci Sum in  
// O(Log n) time.  
  
class GFG { 
  
    static int MAX = 1000; 
  
   // Create an array for memoization  
    static int f[] = new int[MAX]; 
  
// Returns n'th Fibonacci number  
// using table f[]  
    static int fib(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] == 1) { 
            return f[n]; 
        } 
  
        int k = (n % 2 == 1) ? (n + 1) / 2 : n / 2; 
  
        // Applying above formula [Note value n&1 is 1  
        // if n is odd, else 0].  
        f[n] = (n % 2 == 1) ? (fib(k) * fib(k) + fib(k - 1) * fib(k - 1)) 
                : (2 * fib(k - 1) + fib(k)) * fib(k); 
  
        return f[n]; 
    } 
  
// Computes value of even-indexed Fibonacci Sum  
    static int calculateEvenSum(int n) { 
        return (fib(2 * n + 1) - 1); 
    } 
  
// Driver program to test above function  
    public static void main(String[] args) { 
        // Get n  
        int n = 8; 
  
        // Find the alternating sum  
        System.out.println("Even indexed Fibonacci Sum upto "
                + n + " terms: "
                + calculateEvenSum(n)); 
    } 
} 
// This code is contributed by Rajput-Ji 

Python3

# Python3 Program to find even indexed  
# Fibonacci Sum in O(Log n) time. 
MAX = 1000; 
  
# Create an array for memoization 
f = [0] * MAX; 
  
# Returns n'th Fibonacci number 
# using table f[] 
def fib(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 == 1) else n // 2; 
  
    # Applying above formula [Note value n&1 is 1 
    # if n is odd, else 0]. 
    f[n] = (fib(k) * fib(k) + fib(k - 1) * fib(k - 1)) \ 
    if (n % 2 == 1) else (2 * fib(k - 1) + fib(k)) * fib(k); 
  
    return f[n]; 
  
# Computes value of even-indexed Fibonacci Sum 
def calculateEvenSum(n): 
    return (fib(2 * n + 1) - 1); 
  
# Driver Code 
if __name__ == '__main__': 
      
    # Get n 
    n = 8; 
  
    # Find the alternating sum 
    print("Even indexed Fibonacci Sum upto",  
          n, "terms:", calculateEvenSum(n)); 
  
# This code is contributed by PrinciRaj1992 

C#

// C# Program to find even indexed Fibonacci Sum in  
// O(Log n) time.  
using System; 
  
class GFG 
{ 
  
    static int MAX = 1000; 
  
    // Create an array for memoization  
    static int []f = new int[MAX]; 
  
    // Returns n'th Fibonacci number  
    // using table f[]  
    static int fib(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] == 1)  
        { 
            return f[n]; 
        } 
  
        int k = (n % 2 == 1) ? (n + 1) / 2 : n / 2; 
  
        // Applying above formula [Note value n&1 is 1  
        // if n is odd, else 0].  
        f[n] = (n % 2 == 1) ? (fib(k) * fib(k) +  
                                fib(k - 1) * fib(k - 1)) 
                : (2 * fib(k - 1) + fib(k)) * fib(k); 
  
        return f[n]; 
    } 
  
    // Computes value of even-indexed Fibonacci Sum  
    static int calculateEvenSum(int n)  
    { 
        return (fib(2 * n + 1) - 1); 
    } 
  
    // Driver code  
    public static void Main()  
    { 
        // Get n  
        int n = 8; 
  
        // Find the alternating sum  
        Console.WriteLine("Even indexed Fibonacci Sum upto "
                + n + " terms: "
                + calculateEvenSum(n)); 
    } 
} 
  
//This code is contributed by 29AjayKumar 

Output:

Even indexed Fibonacci Sum upto 8 terms: 1596

My Personal Notes

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

C++

Java

Python 3

C#

PHP

C++

Java

Python3

C#

Recommended Posts: