# Count of indices for which the prefix and suffix product are equal

• Last Updated : 30 Nov, 2021

Given an array arr[] of integers, the task is to find the number of indices for which the prefix product and the suffix product are equal.

Example:

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr = [4, -5, 1, 1, -2, 5, -2]
Output: 2
Explanation:  The indices on which the prefix and the suffix product are equal are given below:
At index 2 prefix and suffix product are 20
At index 3 prefix and suffix product are 20

Input: arr = [5, 0, 4, -1, -3, 0]
Output: 3
Explanation:  The indices on which the prefix and the suffix product are equal are given below:
At index 1 prefix and suffix product are 0
At index 2 prefix and suffix product are 0
At index 3 prefix and suffix product are 0
At index 4 prefix and suffix product are 0
At index 5 prefix and suffix product are 0

Naive Approach: The given problem can be solved by traversing the array arr from left to right and calculating prefix product till that index then iterating the array arr from right to left and calculating the suffix product then checking if prefix and suffix product are equal.
Time Complexity: O(N^2)

Efficient Approach: The above approach can be solved by using the Hashing technique. Follow the steps below to solve the problem:

• Traverse the array arr from right to left and at every index store the product into an auxiliary array prod
• Iterate the array arr from left to right and at every index calculate the prefix product
• For every prefix product obtained, check suffix product of the same value is present in prod
• If yes, then increment the count res by 1
• Return the result res obtained

Below is the implementation of the above approach:

## C++

 // C++ implementation for the above approach#include using namespace std; // Function to calculate number of// equal prefix and suffix product// till the same indicesint equalProdPreSuf(vector& arr){     // Initialize a variable    // to store the result    int res = 0;     // Initialize variables to    // calculate prefix and suffix sums    int preProd = 1, sufProd = 1;     // Length of array arr    int len = arr.size();     // Initialize an auxiliary array to    // store suffix product at every index    vector prod(len, 0);     // Traverse the array from right to left    for (int i = len - 1; i >= 0; i--) {         // Multiply the current        // element to sufSum        sufProd *= arr[i];         // Store the value in prod        prod[i] = sufProd;    }     // Iterate the array from left to right    for (int i = 0; i < len; i++) {         // Multiply the current        // element to preProd        preProd *= arr[i];         // If prefix product is equal to        // suffix product prod[i] then        // increment res by 1        if (preProd == prod[i]) {             // Increment the result            res++;        }    }     // Return the answer    return res;} // Driver codeint main(){     // Initialize the array    vector arr = { 4, 5, 1, 1, -2, 5, -2 };     // Call the function and    // print its result    cout << equalProdPreSuf(arr);     return 0;}     // This code is contributed by rakeshsahni

## Java

 // Java implementation for the above approach import java.io.*;import java.util.*; class GFG {     // Function to calculate number of    // equal prefix and suffix product    // till the same indices    public static int equalProdPreSuf(int[] arr)    {         // Initialize a variable        // to store the result        int res = 0;         // Initialize variables to        // calculate prefix and suffix sums        int preProd = 1, sufProd = 1;         // Length of array arr        int len = arr.length;         // Initialize an auxiliary array to        // store suffix product at every index        int[] prod = new int[len];         // Traverse the array from right to left        for (int i = len - 1; i >= 0; i--) {             // Multiply the current            // element to sufSum            sufProd *= arr[i];             // Store the value in prod            prod[i] = sufProd;        }         // Iterate the array from left to right        for (int i = 0; i < len; i++) {             // Multiply the current            // element to preProd            preProd *= arr[i];             // If prefix product is equal to            // suffix product prod[i] then            // increment res by 1            if (preProd == prod[i]) {                 // Increment the result                res++;            }        }         // Return the answer        return res;    }     // Driver code    public static void main(String[] args)    {         // Initialize the array        int[] arr = { 4, 5, 1, 1, -2, 5, -2 };         // Call the function and        // print its result        System.out.println(equalProdPreSuf(arr));    }}

## Python3

 # Python Program to implement# the above approach # Function to calculate number of# equal prefix and suffix product# till the same indicesdef equalProdPreSuf(arr):     # Initialize a variable    # to store the result    res = 0     # Initialize variables to    # calculate prefix and suffix sums    preProd = 1    sufProd = 1     # Length of array arr    Len = len(arr)     # Initialize an auxiliary array to    # store suffix product at every index    prod = [0] * Len     # Traverse the array from right to left    for i in range(Len-1, 0, -1):         # Multiply the current        # element to sufSum        sufProd *= arr[i]         # Store the value in prod        prod[i] = sufProd     # Iterate the array from left to right    for i in range(Len):         # Multiply the current        # element to preProd        preProd *= arr[i]         # If prefix product is equal to        # suffix product prod[i] then        # increment res by 1        if (preProd == prod[i]):             # Increment the result            res += 1     # Return the answer    return res  # Driver code # Initialize the arrayarr = [4, 5, 1, 1, -2, 5, -2] # Call the function and# print its resultprint(equalProdPreSuf(arr)) # This code is contributed by gfgking.

## C#

 // C# implementation for the above approachusing System; class GFG {     // Function to calculate number of    // equal prefix and suffix product    // till the same indices    public static int equalProdPreSuf(int[] arr)    {         // Initialize a variable        // to store the result        int res = 0;         // Initialize variables to        // calculate prefix and suffix sums        int preProd = 1, sufProd = 1;         // Length of array arr        int len = arr.Length;         // Initialize an auxiliary array to        // store suffix product at every index        int[] prod = new int[len];         // Traverse the array from right to left        for (int i = len - 1; i >= 0; i--) {             // Multiply the current            // element to sufSum            sufProd *= arr[i];             // Store the value in prod            prod[i] = sufProd;        }         // Iterate the array from left to right        for (int i = 0; i < len; i++) {             // Multiply the current            // element to preProd            preProd *= arr[i];             // If prefix product is equal to            // suffix product prod[i] then            // increment res by 1            if (preProd == prod[i]) {                 // Increment the result                res++;            }        }         // Return the answer        return res;    }     // Driver code    public static void Main(String[] args)    {         // Initialize the array        int[] arr = { 4, 5, 1, 1, -2, 5, -2 };         // Call the function and        // print its result        Console.Write(equalProdPreSuf(arr));    }} // This code is contributed by gfgking.

## Javascript



Output
2

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

My Personal Notes arrow_drop_up