Geometric Progression

A sequence of numbers is called a Geometric progression if the ratio of any two consecutive terms is always the same.

In simple terms, A geometric series is a list of numbers where each number, or term, is found by multiplying the previous term by a common ratio r. The general form of Geometric Progression is:

GP-series

Where,
            a = First term
            r = common ratio
            ar^n-1 = nth term

Example: 

The sequence 2, 4, 8, 16 is a GP because ratio of any two consecutive terms in the series (common difference) is same (4 / 2 = 8 / 4 = 16 / 8 = 2). 

The geometric progression is of two types:

1. Finite geometric progression
2. Infinite geometric progression.

1. Finite geometric progression

In finite geometric progression contains a finite number of terms. The last term is always defined in this type of progression. 

Example:

The sequence 1/2,1/4,1/8,1/16,…,1/32768 is a finite geometric series where the first term is 1/2 and the last term is 1/32768.

2. Infinite geometric progression

Infinite geometric progression contains an infinite number of terms.  The last term is not defined in this type of progression.

Example:

Sequence 3, 9, 27, 81, … is an infinite series where the first term is 3 but the last term is not defined.

Fact about Geometric Progression:

1. Initial term: In a geometric progression, the first number is called the initial term.
2. Common ratio: The ratio between a term in the sequence and the term before it is called the “common ratio.” 
3. The behavior of a geometric sequence depends on the value of the common ratio. If the common ratio is:
   • Positive, the terms will all be the same sign as the initial term.
   • Negative, the terms will alternate between positive and negative.
   • Greater than 1, there will be exponential growth towards positive or negative infinity (depending on the sign of the initial term). 
   • 1, the progression is a constant sequence.
   • Between -1 and 1 but not zero, there will be exponential decay towards zero.
   • -1, the progression is an alternating sequence.
   • Less than -1, for the absolute values there is exponential growth towards (unsigned) infinity, due to the alternating sign.

The formula for the nth term of a Geometric Progression:

If ‘a1′ is the first term and ‘r’ is the common ratio. Thus, the explicit formula for nth term of finite GP series:

 Nth term of a Geometric Progression

The formula for the sum of the nth term of Geometric Progression: 

Sum of the Nth term of Geometric Progression

How do we check whether a series is a Geometric progression or not?

The property of the GP series is that the ratio of the consecutive terms is same. 

Approach: 

1. First calculate the common ratio r by arr[1] / arr[0]
2. Iterate over an array and calculate the ratio of the consecutive terms.
3. Check if the calculated ratio is not equal to the common ratio r
   • Return false
4. After traversal, if the calculated ratio is equal to the common ratio r every time 
   • Return true

Below is the implementation of the above approach:

C++

// C++ program to check if a given array
// can form geometric progression

#include <bits/stdc++.h>

using namespace std;

bool is_geometric(int arr[], int n)

{
    if (n == 1)
        return true;

    // Calculate ratio
    int ratio = arr[1] / (arr[0]);

    // Check the ratio of the remaining
    for (int i = 1; i < n; i++) {
        if ((arr[i] / (arr[i - 1])) != ratio) {
            return false;
        }
    }
    return true;
}

// Driven Program
int main()
{
    int arr[] = { 2, 6, 18, 54 };
    int n = sizeof(arr) / sizeof(arr[0]);

    (is_geometric(arr, n)) ? (cout << "True" << endl)
                           : (cout << "False" << endl);

    return 0;
}

Java

// Java program to check if a given array
// can form geometric progression
import java.util.Arrays;

class GFG {

    // function to check series is
    // geometric progression or not
    static boolean is_geometric(int arr[], int n)
    {
        if (n == 1)
            return true;

        // Calculate ratio
        int ratio = arr[1] / (arr[0]);

        // Check the ratio of the remaining
        for (int i = 1; i < n; i++) {
            if ((arr[i] / (arr[i - 1])) != ratio) {
                return false;
            }
        }
        return true;
    }

    // driver code
    public static void main(String[] args)
    {
        int arr[] = { 2, 6, 18, 54 };
        int n = arr.length;

        if (is_geometric(arr, n))
            System.out.println("True");
        else
            System.out.println("False");
    }
}

Python3

def is_geometric(li):
    if len(li) <= 1:
        return True

    # Calculate ratio
    ratio = li[1]/float(li[0])

    # Check the ratio of the remaining
    for i in range(1, len(li)):
        if li[i]/float(li[i-1]) != ratio:
            return False
    return True

print(is_geometric([2, 6, 18, 54]))

C#

// C# program to check if a given array
// can form geometric progression
using System;

class Geeks {

    static bool is_geometric(int[] arr, int n)
    {
        if (n == 1)
            return true;

        // Calculate ratio
        int ratio = arr[1] / (arr[0]);

        // Check the ratio of the remaining
        for (int i = 1; i < n; i++) {
            if ((arr[i] / (arr[i - 1])) != ratio) {
                return false;
            }
        }
        return true;
    }

    // Driven Program
    public static void Main(String[] args)
    {
        int[] arr = new int[] { 2, 6, 18, 54 };
        int n = arr.Length;

        if (is_geometric(arr, n))
            Console.WriteLine("True");
        else
            Console.WriteLine("False");
    }
}

PHP

<?php
function is_geometric($arr)
{
    if (sizeof($arr) <= 1)
        return True;
    # Calculate ratio
    $ratio = $arr[1]/$arr[0];

    # Check the ratio of the remaining
    for($i=1; $i<sizeof($arr); $i++)
    {
        if (($arr[$i]/($arr[$i-1])) != $ratio)
        {
            return "Not a geometric sequence";
        }
    }
  return "Geometric  sequence";
}
$my_arr1 = array(2, 6, 18, 54);


print_r(is_geometric($my_arr1)."\n");
print_r(is_geometric($my_arr2)."\n");
?>

Javascript

<script>

// Javascript program to check if a given array
// can form geometric progression

// Function to check series is
// geometric progression or not
function is_geometric(arr, n)
{
    if (n == 1)
        return true;

    // Calculate ratio
    let ratio = parseInt(arr[1] / (arr[0]));

    // Check the ratio of the remaining
    for(let i = 1; i < n; i++)
    {
        if (parseInt((arr[i] /
                     (arr[i - 1]))) != ratio)
        {
            return false;
        }
    }
    return true;
}

// Driver code
let arr = [ 2, 6, 18, 54 ];
let n = arr.length;

(is_geometric(arr, n)) ?
(document.write("True")) :
(document.write("False"));

// This code is contributed by souravmahato348

</script>

Output

True

Time Complexity: O(n), Where n is the length of the given array.

Auxiliary Space: O(1)

Basic Program related to Geometric Progression 

• Program to print GP (Geometric Progression)
• Program for sum of geometric series
• Find the missing number in Geometric Progression
• Program for N-th term of Geometric Progression series
• Find all triplets in a sorted array that forms Geometric Progression
• Removing a number from array to make it Geometric Progression
• Minimum number of operations to convert a given sequence into a Geometric Progression
• Number of GP (Geometric Progression) subsequences of size 3

More problems related to Geometric Progression 

• Find the sum of series 3, -6, 12, -24 . . . upto N terms
• Find the sum of the series 2, 5, 13, 35, 97
• Area of squares formed by joining mid points repeatedly
• Longest Geometric Progression

Recent Articles on Geometric Progression!