# Find all triplets in a sorted array that forms Geometric Progression

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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

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.

My Personal Notes arrow_drop_up

Improved By : chitranayal, Rajput-Ji, jit_t

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.