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

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

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right






                        filter_none









Java














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















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



















                        chevron_right







                        filter_none









Python 3














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# 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 



















                        chevron_right







                        filter_none









C#














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















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



















                        chevron_right







                        filter_none










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.



          
          
          
          

            

    

        My Personal Notes
        arrow_drop_up
    

    

        
        

            
            
        

    


Recommended Posts:

Improved By :  chitranayal, Rajput-Ji, jit_t


      
      
      
      

      

      
					
		

    Article Tags : 
Arrays

           	
Practice Tags : 
Arrays

        

         

         
 
         
        Be the First to upvote.

                

        



        
        
        
        
        

    

            

            2.8
            

            

             
                 Based on 28 vote(s)
                    

            
            
            
            
            
        

        
        

        

        

        

        

        

        


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