Skip to content
Related Articles
Count subarrays of atleast size 3 forming a Geometric Progression (GP)
• Last Updated : 02 Mar, 2021

Given an array arr[] of N integers, the task is to find the count of all subarrays from the given array of at least size 3 forming a Geometric Progression.

Examples:

Input: arr[] = {1, 2, 4, 8}
Output: 3
Explanation: The required subarrays forming geometric progression are:

1. {1, 2, 4}
2. {2, 4, 8}
3. {1, 2, 4, 8}

Input: arr[] = {1, 2, 4, 8, 16, 24}
Output: 6
Explanation: The required subarrays forming geometric progression are:

1. {1, 2, 4}
2. {2, 4, 8}
3. {4, 8, 16}
4. {1, 2, 4, 8}
5. {2, 4, 8, 16}
6. {1, 2, 4, 8, 16}

Naive Approach: The simplest approach is to generate all the subarrays of size at least 3 and count all those subarrays forming a Geometric Progression. Print the count after checking all the subarrays.

Time Complexity: O(N3)
Auxiliary Space: O(N)

Efficient Approach: The idea is to use a property of Geometric Progression i.e., {a, b, c} is GP if and only if a*c = b. Follow the below steps to solve the problem:

• Initialize a variable, res, and count with 0 to store the total subarrays forming geometric progression and length of the current subarray.
• Traverse the given array over the range [2, N – 1] and increment the value of count if the current element forming a geometric progression i.e., arr[i]*arr[i – 2] = arr[i – 1]*arr[i – 1] Otherwise, set count as zero.
• Add count to res for each iteration in the above steps.
• After the above steps, print the value of res as the resultant count.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to count all the subarrays``// of size at least 3 forming GP``int` `numberOfGP(``int` `L[], ``int` `N)``{``    ``// If array size is less than 3``    ``if` `(N <= 2)``        ``return` `0;` `    ``// Stores the count of subarray``    ``int` `count = 0;` `    ``// Stores the count of subarray``    ``// for each iteration``    ``int` `res = 0;` `    ``// Traverse the array``    ``for` `(``int` `i = 2; i < N; ++i) {` `        ``// Check if L[i] forms GP``        ``if` `(L[i - 1] * L[i - 1]``            ``== L[i] * L[i - 2]) {``            ``++count;``        ``}` `        ``// Otherwise, update count to 0``        ``else` `{``            ``count = 0;``        ``}` `        ``// Update the final count``        ``res += count;``    ``}` `    ``// Return the final count``    ``return` `res;``}` `// Driver Code``int` `main()``{``    ``// Given array arr[]``    ``int` `arr[] = { 1, 2, 4, 8, 16, 24 };` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``// Function Call``    ``cout << numberOfGP(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program for the``// above approach``import` `java.util.*;``class` `GFG{` `// Function to count all``// the subarrays of size``// at least 3 forming GP``static` `int` `numberOfGP(``int` `L[],``                      ``int` `N)``{``  ``// If array size``  ``// is less than 3``  ``if` `(N <= ``2``)``    ``return` `0``;` `  ``// Stores the count``  ``// of subarray``  ``int` `count = ``0``;` `  ``// Stores the count``  ``// of subarray for``  ``// each iteration``  ``int` `res = ``0``;` `  ``// Traverse the array``  ``for` `(``int` `i = ``2``; i < N; ++i)``  ``{``    ``// Check if L[i] forms GP``    ``if` `(L[i - ``1``] * L[i - ``1``] ==``        ``L[i] * L[i - ``2``])``    ``{``      ``++count;``    ``}` `    ``// Otherwise, update``    ``// count to 0``    ``else``    ``{``      ``count = ``0``;``    ``}` `    ``// Update the``    ``// final count``    ``res += count;``  ``}` `  ``// Return the final count``  ``return` `res;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``  ``// Given array arr[]``  ``int` `arr[] = {``1``, ``2``, ``4``,``               ``8``, ``16``, ``24``};` `  ``int` `N = arr.length;` `  ``// Function Call``  ``System.out.print(numberOfGP(arr, N));``}``}` `// This code is contributed by gauravrajput1`

## Python3

 `# Python3 program for the above approach` `# Function to count all the subarrays``# of size at least 3 forming GP``def` `numberOfGP(L, N):``    ` `    ``# If array size is less than 3``    ``if` `(N <``=` `2``):``        ``return` `0` `    ``# Stores the count of subarray``    ``count ``=` `0` `    ``# Stores the count of subarray``    ``# for each iteration``    ``res ``=` `0` `    ``# Traverse the array``    ``for` `i ``in` `range``(``2``, N):` `        ``# Check if L[i] forms GP``        ``if` `(L[i ``-` `1``] ``*` `L[i ``-` `1``] ``=``=``                ``L[i] ``*` `L[i ``-` `2``]):``            ``count ``+``=` `1` `        ``# Otherwise, update count to 0``        ``else``:``            ``count ``=` `0` `        ``# Update the final count``        ``res ``+``=` `count` `    ``# Return the final count``    ``return` `res` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Given array arr[]``    ``arr ``=` `[ ``1``, ``2``, ``4``, ``8``, ``16``, ``24` `]` `    ``N ``=` `len``(arr)` `    ``# Function Call``    ``print``(numberOfGP(arr, N))` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the``// above approach``using` `System;``class` `GFG {` `// Function to count all``// the subarrays of size``// at least 3 forming GP``static` `int` `numberOfGP(``int``[] L,``                      ``int` `N)``{``  ``// If array size``  ``// is less than 3``  ``if` `(N <= 2)``    ``return` `0;` `  ``// Stores the count``  ``// of subarray``  ``int` `count = 0;` `  ``// Stores the count``  ``// of subarray for``  ``// each iteration``  ``int` `res = 0;` `  ``// Traverse the array``  ``for` `(``int` `i = 2; i < N; ++i)``  ``{``    ``// Check if L[i] forms GP``    ``if` `(L[i - 1] * L[i - 1] ==``        ``L[i] * L[i - 2])``    ``{``      ``++count;``    ``}` `    ``// Otherwise, update``    ``// count to 0``    ``else``    ``{``      ``count = 0;``    ``}` `    ``// Update the``    ``// final count``    ``res += count;``  ``}` `  ``// Return the final``  ``// count``  ``return` `res;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``  ``// Given array arr[]``  ``int``[] arr = {1, 2, 4, 8, 16, 24};` `  ``int` `N = arr.Length;` `  ``// Function Call``  ``Console.Write(numberOfGP(arr, N));``}``}` `// This code is contributed by Chitranayal`

## Javascript

 ``
Output
`6`

Time Complexity: O(N)
Auxiliary Space: O(N)

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