Skip to content
Related Articles

Related Articles

Sum of N-terms of geometric progression for larger values of N | Set 2 (Using recursion)
  • Difficulty Level : Medium
  • Last Updated : 27 Aug, 2020


A Geometric series is a series with a constant ratio between successive terms. The first term of the series is denoted by a and the common ratio is denoted by r. The series looks like this:-  a, ar, ar^2, ar^3, ar^4,... .
The task is to find the sum of such a series mod M.

Examples:

Input:  a = 1, r = 2, N = 10000, M = 10000
Output:  8751

Input:  a = 1, r = 4, N = 10000, M = 100000
Output:  12501

Approach:

  1. To find the sum of series  a + ar + ar^2 + ar^3 + . . . . + ar^N we can easily take a as common and find the sum of  1 + r + r^2 + r^3 + . . . . + r^N and multiply it with a.
  2. Steps to find the sum of above series.

    • Here, it can be resolved that:
       [1 + r + r^2 + r^3 + . . . + r^(2*n+1)] = (1+r)*(1 + (r^2) + (r^2)^2 + (r^2)^3 + . . . + (r^2)^n) .
    • If we denote,
       Sum(r, n) = 1 + r + r^2 + r^3 + . . . . + r^N. then,
       Sum(r, 2 * n + 1) = (1 + r) * Sum(r^2, n). and,
       Sum(r, 2 * n) = 1 + (r * (1 + r) * Sum(r^2, n - 1)).



      This will work as our recursive case.

    • So, the Base cases are:

                   Sum(r, 0) = 1.
                   Sum(r, 1) = 1 + r.
      

Below is the implementation of the above approach.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation to 
// illustrate the program 
#include <iostream>
using namespace std;
  
// Function to calculate the sum 
// recursively 
int SumGPUtil(long long int r,
              long long int n, 
              long long int m)
      
    // Base cases 
    if (n == 0)
        return 1;
    if (n == 1)
        return (1 + r) % m;
      
    long long int ans;
    // If n is odd 
    if (n % 2 == 1)
    
        ans = (1 + r) * 
              SumGPUtil((r * r) % m,
                        (n - 1) / 2, m);
    }
    else
    {
          
        // If n is even 
        ans = 1 + (r * (1 + r) * 
             SumGPUtil((r * r) % m, 
                       (n / 2) - 1, m));
    }
    return (ans % m);
}
  
// Function to print the value of Sum 
void SumGP(long long int a,
           long long int r,
           long long int N,
           long long int M)
{
    long long int answer;
      
    answer = a * SumGPUtil(r, N, M);
    answer = answer % M; 
      
    cout << answer << endl; 
}
  
// Driver Code 
int main()
{
      
    // First element
    long long int a = 1;
      
    // Common diffrence 
    long long int r = 4; 
      
    // Number of elements 
    long long int N = 10000; 
      
    // Mod value 
    long long int M = 100000; 
  
    SumGP(a, r, N, M);
  
    return 0;
}
  
// This code is contributed by sanjoy_62

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation to 
// illustrate the program 
import java.io.*;
  
class GFG{
  
// Function to calculate the sum 
// recursively 
static long SumGPUtil(long r, long n,
                      long m)
      
    // Base cases 
    if (n == 0)
        return 1;
    if (n == 1)
        return (1 + r) % m;
      
    long ans;
      
    // If n is odd 
    if (n % 2 == 1)
    
        ans = (1 + r) * 
              SumGPUtil((r * r) % m, 
                        (n - 1) / 2, m);
    }
    else
    {
        // If n is even 
        ans = 1 + (r * (1 + r) * 
             SumGPUtil((r * r) % m, 
                       (n / 2) - 1, m));
    }
      
    return (ans % m);
}
  
// Function to prlong the value of Sum 
static void SumGP(long a, long r,
                  long N, long M) 
{
    long answer;
    answer = a * SumGPUtil(r, N, M);
    answer = answer % M; 
      
    System.out.println(answer); 
}
  
// Driver Code 
public static void main (String[] args)
{
      
    // First element 
    long a = 1
      
    // Common diffrence 
    long r = 4;
      
    // Number of elements 
    long N = 10000;
      
    // Mod value 
    long M = 100000
  
    SumGP(a, r, N, M);
}
}
  
// This code is contributed by sanjoy_62

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation to illustrate the program 
  
# Function to calculate the sum 
# recursively
def SumGPUtil (r, n, m):
      
    # Base cases
    if n == 0: return 1
    if n == 1: return (1 + r) % m
    
    # If n is odd
    if n % 2 == 1:
        ans = (1 + r) * SumGPUtil(r * r % m,
                                  (n - 1)//2,
                                  m)
    else:
        #If n is even
        ans = 1 + r * (1 + r) * SumGPUtil(r * r % m,
                                          n//2 - 1,
                                          m)
    
    return ans % m
  
# Function to print the value of Sum
def SumGP (a, r, N, M):
      
    answer = a * SumGPUtil(r, N, M)
    answer = answer % M
    print(answer)
  
#Driver Program
if __name__== '__main__':
  
    a = 1 # first element
    r = 4 # common diffrence
    N = 10000 # Number of elements
    M = 100000 # Mod value 
  
    SumGP(a, r, N, M)

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation to 
// illustrate the program 
using System;
  
class GFG{
  
// Function to calculate the sum 
// recursively 
static long SumGPUtil(long r, long n,
                      long m)
      
    // Base cases 
    if (n == 0)
        return 1;
    if (n == 1)
        return (1 + r) % m;
      
    long ans;
      
    // If n is odd 
    if (n % 2 == 1)
    
        ans = (1 + r) * 
              SumGPUtil((r * r) % m, 
                        (n - 1) / 2, m);
    }
    else
    {
          
        // If n is even 
        ans = 1 + (r * (1 + r) * 
             SumGPUtil((r * r) % m, 
                       (n / 2) - 1, m));
    }
    return (ans % m);
}
  
// Function to prlong the value of Sum 
static void SumGP(long a, long r,
                  long N, long M)
{
    long answer;
    answer = a * SumGPUtil(r, N, M);
    answer = answer % M; 
      
    Console.WriteLine(answer); 
}
  
// Driver Code 
public static void Main() 
{
      
    // First element 
    long a = 1; 
      
    // Common diffrence 
    long r = 4; 
      
    // Number of elements 
    long N = 10000;
      
    // Mod value 
    long M = 100000; 
  
    SumGP(a, r, N, M);
}
}
  
// This code is contributed by sanjoy_62

chevron_right


Output:

12501

Time complexity: O(log N)

competitive-programming-img

My Personal Notes arrow_drop_up
Recommended Articles
Page :