Find all triplets in a sorted array that forms Geometric Progression

Last Updated : 20 Mar, 2023

Given a sorted array of distinct positive integers, print all triplets that forms Geometric Progression with integral common ratio.
A geometric progression is a sequence of numbers where each term after the first is found by multiplying the previous one by a fixed, non-zero number called the common ratio. For example, the sequence 2, 6, 18, 54,... is a geometric progression with common ratio 3.

Examples:

Input: 
arr = [1, 2, 6, 10, 18, 54]
Output: 
2 6 18
6 18 54

Input: 
arr = [2, 8, 10, 15, 16, 30, 32, 64]
Output: 
2 8 32
8 16 32
16 32 64

Input: 
arr = [ 1, 2, 6, 18, 36, 54]
Output: 
2 6 18
1 6 36
6 18 54

The idea is to start from the second element and fix every element as middle element and search for the other two elements in a triplet (one smaller and one greater). For an element arr[j] to be middle of geometric progression, there must exist elements arr[i] and arr[k] such that -

arr[j] / arr[i] = r and arr[k] / arr[j] = r
where r is an positive integer and 0 <= i < j and j < k <= n - 1

Below is the implementation of above idea

C++

// C++ program to find if there exist three elements in
// Geometric Progression or not
#include <iostream>
using namespace std;

// The function prints three elements in GP if exists
// Assumption: arr[0..n-1] is sorted.
void findGeometricTriplets(int arr[], int n)
{
    // One by fix every element as middle element
    for (int j = 1; j < n - 1; j++)
    {
        // Initialize i and k for the current j
        int i = j - 1, k = j + 1;

        // Find all i and k such that (i, j, k)
        // forms a triplet of GP
        while (i >= 0 && k <= n - 1)
        {
            // if arr[j]/arr[i] = r and arr[k]/arr[j] = r
            // and r is an integer (i, j, k) forms Geometric
            // Progression
            while (arr[j] % arr[i] == 0 &&
                    arr[k] % arr[j] == 0 &&
                    arr[j] / arr[i] == arr[k] / arr[j])
            {
                // print the triplet
                cout << arr[i] << " " << arr[j]
                     << " " << arr[k] << endl;

                // Since the array is sorted and elements
                // are distinct.
                k++ , i--;
            }

            // if arr[j] is multiple of arr[i] and arr[k] is
            // multiple of arr[j], then arr[j] / arr[i] !=
            // arr[k] / arr[j]. We compare their values to
            // move to next k or previous i.
            if(arr[j] % arr[i] == 0 &&
                    arr[k] % arr[j] == 0)
            {
                if(arr[j] / arr[i] < arr[k] / arr[j])
                    i--;
                else k++;
            }

            // else if arr[j] is multiple of arr[i], then
            // try next k. Else, try previous i.
            else if (arr[j] % arr[i] == 0)
                k++;
            else i--;
        }
    }
}

// Driver code
int main()
{
    // int arr[] = {1, 2, 6, 10, 18, 54};
    // int arr[] = {2, 8, 10, 15, 16, 30, 32, 64};
    // int arr[] = {1, 2, 6, 18, 36, 54};
    int arr[] = {1, 2, 4, 16};
    // int arr[] = {1, 2, 3, 6, 18, 22};
    int n = sizeof(arr) / sizeof(arr[0]);

    findGeometricTriplets(arr, n);

    return 0;
}

Java

// Java program to find if there exist three elements in
// Geometric Progression or not
import java.util.*;

class GFG 
{

// The function prints three elements in GP if exists
// Assumption: arr[0..n-1] is sorted.
static void findGeometricTriplets(int arr[], int n)
{
    // One by fix every element as middle element
    for (int j = 1; j < n - 1; j++)
    {
        // Initialize i and k for the current j
        int i = j - 1, k = j + 1;

        // Find all i and k such that (i, j, k)
        // forms a triplet of GP
        while (i >= 0 && k <= n - 1)
        {
            // if arr[j]/arr[i] = r and arr[k]/arr[j] = r
            // and r is an integer (i, j, k) forms Geometric
            // Progression
            while (i >= 0 && arr[j] % arr[i] == 0 &&
                    arr[k] % arr[j] == 0 &&
                    arr[j] / arr[i] == arr[k] / arr[j])
            {
                // print the triplet
                System.out.println(arr[i] +" " + arr[j]
                    + " " + arr[k]);

                // Since the array is sorted and elements
                // are distinct.
                k++ ; i--;
            }

            // if arr[j] is multiple of arr[i] and arr[k] is
            // multiple of arr[j], then arr[j] / arr[i] !=
            // arr[k] / arr[j]. We compare their values to
            // move to next k or previous i.
            if(i >= 0 && arr[j] % arr[i] == 0 &&
                    arr[k] % arr[j] == 0)
            {
                if(i >= 0 && arr[j] / arr[i] < arr[k] / arr[j])
                    i--;
                else k++;
            }

            // else if arr[j] is multiple of arr[i], then
            // try next k. Else, try previous i.
            else if (i >= 0 && arr[j] % arr[i] == 0)
                k++;
            else i--;
        }
    }
}

// Driver code
public static void main(String[] args) 
{
    // int arr[] = {1, 2, 6, 10, 18, 54};
    // int arr[] = {2, 8, 10, 15, 16, 30, 32, 64};
    // int arr[] = {1, 2, 6, 18, 36, 54};
    int arr[] = {1, 2, 4, 16};
    // int arr[] = {1, 2, 3, 6, 18, 22};
    int n = arr.length;

    findGeometricTriplets(arr, n);
}
}

// This code is contributed by Rajput-Ji

Python 3

# Python 3 program to find if 
# there exist three elements in
# Geometric Progression or not

# The function prints three elements 
# in GP if exists.
# Assumption: arr[0..n-1] is sorted.
def findGeometricTriplets(arr, n):

    # One by fix every element 
    # as middle element
    for j in range(1, n - 1):
    
        # Initialize i and k for 
        # the current j
        i = j - 1
        k = j + 1

        # Find all i and k such that 
        # (i, j, k) forms a triplet of GP
        while (i >= 0 and k <= n - 1):
        
            # if arr[j]/arr[i] = r and 
            # arr[k]/arr[j] = r and r 
            # is an integer (i, j, k) forms 
            # Geometric Progression
            while (arr[j] % arr[i] == 0 and
                   arr[k] % arr[j] == 0 and
                   arr[j] // arr[i] == arr[k] // arr[j]):
            
                # print the triplet
                print( arr[i] , " " , arr[j], 
                                " " , arr[k]) 

                # Since the array is sorted and 
                # elements are distinct.
                k += 1
                i -= 1

            # if arr[j] is multiple of arr[i]
            # and arr[k] is multiple of arr[j], 
            # then arr[j] / arr[i] != arr[k] / arr[j].
            # We compare their values to
            # move to next k or previous i.
            if(arr[j] % arr[i] == 0 and
                        arr[k] % arr[j] == 0):
            
                if(arr[j] // arr[i] < arr[k] // arr[j]):
                    i -= 1
                else:
                    k += 1

            # else if arr[j] is multiple of 
            # arr[i], then try next k. Else, 
            # try previous i.
            elif (arr[j] % arr[i] == 0):
                k += 1
            else:
                i -= 1

# Driver code
if __name__ =="__main__":
    
    arr = [1, 2, 4, 16]
    n = len(arr)

    findGeometricTriplets(arr, n)

# This code is contributed 
# by ChitraNayal

// C# program to find if there exist three elements 
// in Geometric Progression or not
using System;

class GFG
{
    
// The function prints three elements in GP if exists
// Assumption: arr[0..n-1] is sorted.
static void findGeometricTriplets(int []arr, int n)
{
    
    // One by fix every element as middle element
    for (int j = 1; j < n - 1; j++)
    {
        // Initialize i and k for the current j
        int i = j - 1, k = j + 1;

        // Find all i and k such that (i, j, k)
        // forms a triplet of GP
        while (i >= 0 && k <= n - 1)
        {
            // if arr[j]/arr[i] = r and arr[k]/arr[j] = r
            // and r is an integer (i, j, k) forms Geometric
            // Progression
            while (i >= 0 && arr[j] % arr[i] == 0 &&
                             arr[k] % arr[j] == 0 &&
                    arr[j] / arr[i] == arr[k] / arr[j])
            {
                // print the triplet
            Console.WriteLine(arr[i] +" " + 
                              arr[j] + " " + arr[k]);

                // Since the array is sorted and elements
                // are distinct.
                k++ ; i--;
            }

            // if arr[j] is multiple of arr[i] and arr[k] is
            // multiple of arr[j], then arr[j] / arr[i] !=
            // arr[k] / arr[j]. We compare their values to
            // move to next k or previous i.
            if(i >= 0 && arr[j] % arr[i] == 0 &&
                         arr[k] % arr[j] == 0)
            {
                if(i >= 0 && arr[j] / arr[i] < 
                             arr[k] / arr[j])
                    i--;
                else k++;
            }

            // else if arr[j] is multiple of arr[i], then
            // try next k. Else, try previous i.
            else if (i >= 0 && arr[j] % arr[i] == 0)
                k++;
            else i--;
        }
    }
}

// Driver code
static public void Main ()
{
    
    // int arr[] = {1, 2, 6, 10, 18, 54};
    // int arr[] = {2, 8, 10, 15, 16, 30, 32, 64};
    // int arr[] = {1, 2, 6, 18, 36, 54};
    int []arr = {1, 2, 4, 16};
    
    // int arr[] = {1, 2, 3, 6, 18, 22};
    int n = arr.Length;
    
    findGeometricTriplets(arr, n);
}
}

// This code is contributed by ajit.

JavaScript

<script>
// Javascript program to find if there exist three elements in
// Geometric Progression or not

    // The function prints three elements in GP if exists
    // Assumption: arr[0..n-1] is sorted.
    function findGeometricTriplets(arr,n)
    {
    
        // One by fix every element as middle element
        for (let j = 1; j < n - 1; j++)
        {
        
            // Initialize i and k for the current j
            let i = j - 1, k = j + 1;
      
            // Find all i and k such that (i, j, k)
            // forms a triplet of GP
            while (i >= 0 && k <= n - 1)
            {
            
                // if arr[j]/arr[i] = r and arr[k]/arr[j] = r
                // and r is an integer (i, j, k) forms Geometric
                // Progression
                while (i >= 0 && arr[j] % arr[i] == 0 &&
                        arr[k] % arr[j] == 0 &&
                        arr[j] / arr[i] == arr[k] / arr[j])
                {
                
                    // print the triplet
                    document.write(arr[i] +" " + arr[j]
                        + " " + arr[k]+"<br>");
      
                    // Since the array is sorted and elements
                    // are distinct.
                    k++ ; i--;
                }
      
                // if arr[j] is multiple of arr[i] and arr[k] is
                // multiple of arr[j], then arr[j] / arr[i] !=
                // arr[k] / arr[j]. We compare their values to
                // move to next k or previous i.
                if(i >= 0 && arr[j] % arr[i] == 0 &&
                        arr[k] % arr[j] == 0)
                {
                    if(i >= 0 && arr[j] / arr[i] < arr[k] / arr[j])
                        i--;
                    else k++;
                }
      
                // else if arr[j] is multiple of arr[i], then
                // try next k. Else, try previous i.
                else if (i >= 0 && arr[j] % arr[i] == 0)
                    k++;
                else i--;
            }
        }
    }
    
    // Driver code
    // int arr[] = {1, 2, 6, 10, 18, 54};
    // int arr[] = {2, 8, 10, 15, 16, 30, 32, 64};
    // int arr[] = {1, 2, 6, 18, 36, 54};
    
    let arr = [1, 2, 4, 16];
    
    // int arr[] = {1, 2, 3, 6, 18, 22};
    let n = arr.length;
    findGeometricTriplets(arr, n);
    
    // This code is contributed by avanitrachhadiya2155
</script>

Output

1 2 4
1 4 16

Time complexity of above solution is O(n²) as for every j, we are finding i and k in linear time.

Auxiliary Space: O(1), since we not used any extra space.

Analysis of Algorithms

aditya.goel

Improve

Article Tags :

Practice Tags :

Mathematical

Find all triplets in a sorted array that forms Geometric Progression

Similar Reads

Basics & Prerequisites

Data Structures

Algorithms

Advanced

Interview Preparation

Practice Problem

Thank You!

What kind of Experience do you want to share?