Product of N terms of a given Geometric series - GeeksforGeeks

27 Jun, 2021
Given a number N, the first term ‘a’ and a common ratio ‘r’ of a Geometric Progression, the task is to find the product of first N terms of the given Geometric Progression.
Examples: 
Input: a = 1, r = 2, N = 4 Output: 64 Explanation: First four term for the above G.P. is 1, 2, 4, 8. Product of four numbers is 1*2*4*8 = 64
Input: a = 1, r = 0.5, N = 3 Output: 0.125 Explanation: First three term for the above G.P. is 1, 1/2, 1/4. Product of four numbers is 1*(1/2)*(1/4) = 1/8 = 0.125 
Naive Approach: The idea is to find all the N terms of the given geometric progression and multiply all the terms obtained.
Below is the implementation of the above approach: 
C++
Java
Python3
C#
Javascript
// C++ program for the above approach#include <bits/stdc++.h>using namespace std; // Function to calculate product of// geometric seriesfloat productOfGP(float a, float r, int n){    // Initialise final product with 1    float product = 1;     for (int i = 0; i < n; i++) {        // Multiply product with each        // term stored in a        product = product * a;        a = a * r;    }     // Return the final product    return product;} // Driver Codeint main(){    // Given first term    // and common ratio    float a = 1, r = 2;     // Number of terms    int N = 4;     // Function Call    cout << productOfGP(a, r, N);}
// Java program for the above approachimport java.util.*;class GFG{ // Function to calculate product of// geometric seriesstatic float productOfGP(float a,                         float r, int n){    // Initialise final product with 1    float product = 1;     for (int i = 0; i < n; i++)    {        // Multiply product with each        // term stored in a        product = product * a;        a = a * r;    }     // Return the final product    return product;} // Driver Codepublic static void main(String args[]){    // Given first term    // and common ratio    float a = 1, r = 2;     // Number of terms    int N = 4;     // Function Call    System.out.print(productOfGP(a, r, N));}} // This code is contributed by Code_Mech
# Python3 program for the above approach # Function to calculate product of# geometric seriesdef productOfGP(a, r, n):         # Initialise final product with 1    product = 1;     for i in range(0, n):                 # Multiply product with each        # term stored in a        product = product * a;        a = a * r;     # Return the final product    return product;     # Driver code # Given first term# and common ratioa = 1r = 2; # Number of termsN = 4; # Function Callprint(productOfGP(a, r, N)) # This code is contributed by Pratima Pandey.
// C# program for the above approachusing System;class GFG{ // Function to calculate product of// geometric seriesstatic float productOfGP(float a,                         float r, int n){    // Initialise final product with 1    float product = 1;     for (int i = 0; i < n; i++)    {        // Multiply product with each        // term stored in a        product = product * a;        a = a * r;    }     // Return the final product    return product;} // Driver Codepublic static void Main(){    // Given first term    // and common ratio    float a = 1, r = 2;     // Number of terms    int N = 4;     // Function Call    Console.Write(productOfGP(a, r, N));}} // This code is contributed by Code_Mech
<script>    // Javascript program for the above approach      // Function to calculate product of    // geometric series    function productOfGP(a, r, n)    {             // Initialise final product with 1        let product = 1;         for (let i = 0; i < n; i++)        {                     // Multiply product with each            // term stored in a            product = product * a;            a = a * r;        }         // Return the final product        return product;    }         // Given first term    // and common ratio    let a = 1, r = 2;       // Number of terms    let N = 4;       // Function Call    document.write(productOfGP(a, r, N));       // This code is contributed by divyesh072019.</script>
64
 
Efficient Approach: The efficient approach is to observe that the product of all the N terms of the given geometric progression forms a formula: 
The general G.P. is 
Product upto 1st term = Product upto 2nd term = Product upto 3rd term = Product upto 4th term = . . . Product upto N terms =   
Below is the implementation of the above approach: 
C++
Java
Python3
C#
Javascript
// C++ program for the above approach#include <bits/stdc++.h>using namespace std; // Function to calculate product of// geometric seriesfloat productOfGP(float a, float r,                  int n){    // Return the final product with the    // above formula    return pow(a, n)           * pow(r, n * (n - 1) / 2);} // Driver Codeint main(){    // Given first term    // and common ratio    float a = 1, r = 2;     // Number of terms    int N = 4;     // Function Call    cout << productOfGP(a, r, N);}
// Java program for the above approachclass GFG{     // Function to calculate product of// geometric seriesstatic float productOfGP(float a, float r, int n){         // Return the final product with the    // above formula    return (float)Math.pow(a, n) *           (float)Math.pow(r, n * (n - 1) / 2);} // Driver Codepublic static void main(String s[]){         // Given first term    // and common ratio    float a = 1, r = 2;     // Number of terms    int N = 4;     // Function Call    System.out.println(productOfGP(a, r, N));}} // This code is contributed by rutvik_56
# Python3 program for the above approach # Function to calculate product of# geometric seriesdef productOfGP(a, r, n):     # Return the final product with the    # above formula    return pow(a, n) * pow(r, n * (n - 1) // 2); # Driver Code # Given first term# and common ratioa = 1; r = 2; # Number of termsN = 4; # Function Callprint(productOfGP(a, r, N)); # This code is contributed by Code_Mech
// C# program for the above approachusing System;class GFG{     // Function to calculate product of// geometric seriesstatic float productOfGP(float a, float r, int n){         // Return the final product with the    // above formula    return (float)Math.Pow(a, n) *           (float)Math.Pow(r, n * (n - 1) / 2);} // Driver Codepublic static void Main(String[] args){         // Given first term    // and common ratio    float a = 1, r = 2;     // Number of terms    int N = 4;     // Function Call    Console.WriteLine(productOfGP(a, r, N));}} // This code is contributed by shivanisinghss2110
<script> // Javascript program for the above approach // Function to calculate product of// geometric seriesfunction productOfGP(a, r, n){         // Return the final product with the    // above formula    return Math.pow(a, n) *           Math.pow(r, n * (n - 1) / 2);} // Driver code // Given first term// and common ratiolet a = 1, r = 2; // Number of termslet N = 4; // Function Calldocument.write(productOfGP(a, r, N)); // This code is contributed by mukesh07     </script>
64
 
Time Complexity: O(N)Auxiliary Space: O(1)
Another Approach: 
Let there be a GP of N terms as followed:  
Product of 1st and last term =  = Product of 2nd and 2nd last term =  = Product of 3rd and 3rd last term =  = and so on... In a geometric progression, the product of the first and the last term is the same as the product of the second and second last term and so on, no matter how many terms we are considering in a geometric progression.Therefore, if and  is the first and last terms of a GP, then the product of first N terms of the GP will be  
Below is the implementation of the above approach: 
C++
Java
Python3
C#
Javascript
// C++ program for the above approach#include <bits/stdc++.h>using namespace std; // Function to calculate product of N// terms of geometric seriesfloat productOfGP(float a, float r,                  int n){    // Find the product of first    // and the last term    int an = a * pow(r, n - 1);     // Return the sqrt of the above    // expression to find the product    return sqrt(pow(a * an, n));} // Driver Codeint main(){    // Given first term    // and common ratio    float a = 1, r = 2;     // Number of terms    int N = 4;     // Function Call    cout << productOfGP(a, r, N);}
// Java program for the above approachimport java.util.*;class GFG{ // Function to calculate product of N// terms of geometric seriesstatic float productOfGP(float a, float r, int n){    // Find the product of first    // and the last term    int an = (int)(a * (int)(Math.pow(r, n - 1)));     // Return the sqrt of the above    // expression to find the product    return (int)Math.sqrt((int)Math.pow(a * an, n));} // Driver Codepublic static void main(String args[]){    // Given first term    // and common ratio    float a = 1, r = 2;     // Number of terms    int N = 4;     // Function Call    System.out.print(productOfGP(a, r, N));}} // This code is contributed by Code_Mech
# Python3 program for the above approachimport math # Function to calculate product of N# terms of geometric seriesdef productOfGP(a, r, n):         # Find the product of first    # and the last term    an = a * pow(r, n - 1);     # Return the sqrt of the above    # expression to find the product    return (math.sqrt(pow(a * an, n)))     # Driver code # Given first term# and common ratioa = 1r = 2; # Number of termsN = 4; # Function Callprint(productOfGP(a, r, N)) # This code is contributed by Pratima Pandey.
// C# program for the above approachusing System;class GFG{ // Function to calculate product of N// terms of geometric seriesstatic float productOfGP(float a, float r, int n){    // Find the product of first    // and the last term    int an = (int)(a * (int)(Math.Pow(r, n - 1)));     // Return the sqrt of the above    // expression to find the product    return (int)Math.Sqrt((int)Math.Pow(a * an, n));} // Driver Codepublic static void Main(){    // Given first term    // and common ratio    float a = 1, r = 2;     // Number of terms    int N = 4;     // Function Call    Console.Write(productOfGP(a, r, N));}} // This code is contributed by Code_Mech
<script> // Javascript program for the above approach // Function to calculate product of N// terms of geometric seriesfunction productOfGP(a, r, n){         // Find the product of first    // and the last term    let an = a * Math.pow(r, n - 1);     // Return the sqrt of the above    // expression to find the product    return Math.sqrt(Math.pow(a * an, n));} // Driver code // Given first term// and common ratiolet a = 1, r = 2; // Number of termslet N = 4; // Function Calldocument.write(productOfGP(a, r, N)); // This code is contributed by divyeshrabadiya07 </script>
64
 
rutvik_56
shivanisinghss2110
Code_Mech
dewantipandeydp
divyesh072019
mukesh07
divyeshrabadiya07
subhammahato348
Geometric Progression
series
Mathematical
Mathematical
series
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Program to print prime numbers from 1 to N.
Segment Tree | Set 1 (Sum of given range)
Count all possible paths from top left to bottom right of a mXn matrix
Modular multiplicative inverse
Fizz Buzz Implementation
Program to multiply two matrices
Check if a number is Palindrome
Count ways to reach the n'th stair
Merge two sorted arrays with O(1) extra space
Generate all permutation of a set in Python