Skip to content
Related Articles
Find all triplets in a sorted array that forms Geometric Progression
• Difficulty Level : Medium
• Last Updated : 08 Apr, 2021

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 ``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);` `    ``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#

 `// 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

 ``

Output:

```1 2 4
1 4 16```

Time complexity of above solution is O(n2) as for every j, we are finding i and k in linear time.
This article is contributed by Aditya Goel. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up