Number of GP sequence Problem in Java

The number of GP sequence problems in Java involves determining the count of valid geometric progression sequences within a given set of numbers. Geometric progressions, defined by a common ratio, are essential in various fields. In this tutorial, we will find the count of GP sequence that has the length 3.

Example 1:

Input: inputArray[] = {1, 2, 6, 2, 3, 6, 9, 18, 3, 9}, commonRatio = 3

Output: The count of GP subsequences with length 3 and common ratio 3 is: 6

Explanation: The program calculates that there are 6 geometric progression (GP) subsequences of length 3 with a common ratio of 3 in the specified array.

Example 2:

Input: inputArray[] = {1, 3, 9, 27, 81}, commonRatio = 3

Output: The count of GP subsequences with length 3 and common ratio 3 is: 3

Explanation: The GP subsequences are {1, 3, 9}, {3, 9, 27}, and {9, 27, 81}.

Approach: Naive Approach

In the naive approach, the algorithm iterates through every triplet of elements in the array, checking if they form a geometric progression subsequence. The triple-nested iteration results in cubic time complexity, making it less efficient for larger input sizes due to its exhaustive nature.

Algorithm:

Step 1: Initialize Two HashMaps: Create left and right HashMaps to count the occurrences of each element to the left and right of the current element in the array.

Step 2: Populate Right HashMap: Iterate through the array and populate the right HashMap with the count of each element.

Step 3: Count GP Subsequences by Iterate through each array element.

Step 4: For the current element array[i]:

Step 4.1: Calculate countLeft using the left HashMap if array[i] is divisible by the ratio.

Step 4.2: Reduce array[i]'s count in the right HashMap.

Step 4.3: Determine countRight for array[i] * ratio in the right HashMap.

Step 4.4: Multiply countLeft and countRight to update the total subsequence count (result).

Step 4.5: Increment array[i]'s count in the left HashMap.

Step 6: Return Total Count: Return the total count of subsequences (result) after iterating through the array.

Implementation:

Filename: MyGPProgram.java

import java.util.*;
// Define a class named MyGPProgram
public class MyGPProgram {
    // Define a method to count GP subsequences with length 3 and common ratio r
    static long countSubsequences(int[] array, int length, int ratio) {
        // Create HashMaps to maintain counts of elements in left and right arrays
        Map<Integer, Integer> left = new HashMap<>(), right = new HashMap<>();
        // Initialize a variable to store the final result
        long result = 0;

        // Iterate through the array to populate the right HashMap
        for (int i = 0; i < length; i++)
            right.put(array[i], right.getOrDefault(array[i], 0) + 1);

        // Iterate through the array to calculate GP subsequences
        for (int i = 0; i < length; i++) {
            // Initialize variables to count left and right elements
            long countLeft = 0, countRight = 0;

            // If the current element is divisible by the ratio, update the countLeft using the left HashMap
            if (array[i] % ratio == 0)
                countLeft = left.getOrDefault(array[i] / ratio, 0);

            // Decrease the count in the right HashMap for the current element
            right.put(array[i], right.getOrDefault(array[i], 0) - 1);
            // Update countRight using the right HashMap for the current element multiplied by the ratio
            countRight = right.getOrDefault(array[i] * ratio, 0);
            
            // Update the final result by adding the product of countLeft and countRight
            result += countLeft * countRight;

            // Increase the count in the left HashMap for the current element
            left.put(array[i], left.getOrDefault(array[i], 0) + 1);
        }

        // Return the final result
        return result;
    }

    // Main method to execute the program
    public static void main(String[] args) {
        // Define an example input array
        int[] inputArray = {1, 2, 6, 2, 3, 6, 9, 18, 3, 9};
        // Get the length of the input array
        int arrayLength = inputArray.length;
        // Define the common ratio for GP subsequences
        int commonRatio = 3;

        // Call the countSubsequences method and print the result
        System.out.println("The count of GP subsequences with length 3 and common ratio " + commonRatio + " is: " +
                countSubsequences(inputArray, arrayLength, commonRatio));
    }
}

Output:

The count of GP subsequences with length 3 and common ratio 3 is: 6

Time Complexity: The time complexity is O(n) as it utilizes two loops that iterate through the input array, and the operations inside each loop are constant time, resulting in a linear overall time complexity.

Auxiliary Space: The auxiliary space complexity is O(n) because the code employs two HashMaps to maintain counts of elements, and the space required by these HashMaps scales linearly with the size of the input array.

Approach: Counting Geometric Progression (G.P.) Subsequences

The code employs a counting approach for Geometric Progression (G.P.) subsequences, utilizing hash maps to track element occurrences and efficiently calculate the count based on the given ratio. Additionally, the code leverages binomial coefficients to compute combinations, enhancing the accuracy of G.P. subsequence counts.

Algorithm:

Step 1: Calculate the binomial coefficient (n choose k) using dynamic programming in binomialCoeff.

Step 2: In countGPSubsequences, use left and right HashMaps to track the counts of elements to the left and right of the current element.

Step 3: If the ratio is 1, calculate GP subsequences using the binomial coefficient for each element's count.

Step 4: if not, iterate through the array:

Update leftCount based on the left HashMap if the current element is divisible by the ratio.
Adjust rightCount based on the right HashMap for the element times the ratio.
Update the total count of subsequences using leftCount and rightCount.
Update counts in left and right HashMaps accordingly.

Step 5: Define the array, size, and the common ratio. Call countGPSubsequences and print the result.

Implementation:

Filename: GPSequence.java

import java.util.*;
public class GPSequence {
    // Method to calculate binomial coefficient (n choose k)
    static int binomialCoeff(int n, int k) {
        int[] C = new int[k + 1];
        C[0] = 1;
        for (int i = 1; i <= n; i++) {
            for (int j = Math.min(i, k); j > 0; j--)
                C[j] = C[j] + C[j - 1];
        }
        return C[k];
    }

    // Method to count G.P. subsequences
    static long countGPSubsequences(int[] inputArray, int size, int commonRatio) {
        // Hash maps to maintain counts of elements in left and right arrays
        HashMap<Integer, Integer> left = new HashMap<>();
        HashMap<Integer, Integer> right = new HashMap<>();
        long result = 0;

        // Traverse through the elements and populate the right hash map
        for (int i = 0; i < size; i++)
            if (right.containsKey(inputArray[i])) {
                right.put(inputArray[i], right.get(inputArray[i]) + 1);
            } else {
                right.put(inputArray[i], 1);
            }

        // If the commonRatio is 1, directly calculate the G.P. subsequences count
        if (commonRatio == 1) {
            for (Map.Entry<Integer, Integer> entry : right.entrySet()) {
                result += binomialCoeff(entry.getValue(), 3);
            }
            return result;
        }

        // Traverse through all elements to find G.P. subsequences
        for (int i = 0; i < size;) {
            long leftCount = 0, rightCount = 0;

            // If the current element is divisible by commonRatio, count elements in the left hash map
            if (inputArray[i] % commonRatio == 0 && left.containsKey(inputArray[i] / commonRatio))
                leftCount = left.get(inputArray[i] / commonRatio);

            // Decrease the count in the right hash map
            if (right.containsKey(inputArray[i])) {
                right.put(inputArray[i], right.get(inputArray[i]) - 1);
            } else {
                right.put(inputArray[i], -1);
            }

            // Count the number of right elements
            if (right.containsKey(inputArray[i] * commonRatio))
                rightCount = right.get(inputArray[i] * commonRatio);

            // Calculate the answer
            result += leftCount * rightCount;

            // Update the left hash map
            if (left.containsKey(inputArray[i])) {
                left.put(inputArray[i], left.get(inputArray[i]) + 1);
            } else {
                left.put(inputArray[i], 1);
            }

            i++;
        }
        return result;
    }

    public static void main(String[] args) {
        int[] inputArray = {1, 2, 6, 2, 3, 6, 9, 18, 3, 9};
        int size = inputArray.length;
        int commonRatio = 3;

        // Print the count of G.P. subsequences with the given commonRatio
        System.out.print("Count of GP subsequences with commonRatio " + commonRatio + ": ");
        System.out.println(countGPSubsequences(inputArray, size, commonRatio));
    }
}

Output:

Count of GP subsequences with commonRatio 3: 6

Time Complexity: The outer loop in countGPSubsequences iterates through all array elements once, resulting in a time complexity of O(n), where n is the size of the input array.

Auxiliary Space: The space complexity is influenced by the two hash maps (left and right). In the worst case, where all elements are unique, the space complexity would be O(n) since each element may have an entry in both hash maps.

Next TopicPattern Matching for Switch

← prev next →