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++ 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 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 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. |
<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> |
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.
Auxiliary Space: O(1), since we not used any extra space.