Find the longest Subarray with equal Sum and Product

Given an array arr[] of N integers, the task is to find the length of the longest subarray where the sum of the elements in the subarray is equal to the product of the elements in the subarray.

Examples:

Input: arr[] = [1, 2, 1, 2, 2, 5, 6, 24]
Output: 5
Explanation: The subarray [1, 2, 1, 2, 2] has a sum of 8 and a product of 8, hence it satisfies the given condition. This is the longest subarray with this property.

Input: arr[] = [4, 5, 6, 1, 2, 3]
Output: 3
Explanation: The subarray [1, 2, 3] has a sum of 6 and a product of 6, hence it satisfies the given condition. This is the longest subarray with this property.

Approach: This can be solved with the following idea:

Using two HashMaps and storing the sum of elements and product in each of the hashmaps. For more information read the steps.

Steps involved in the implementation of code:

• Initialize two empty unordered maps sum_dict and prod_dict. sum_dict will store the first index of each sum value encountered, while prod_dict will store the first index of each prod value encountered.
• Initialize two integers curr_sum and curr_prod to 0 and 1 respectively. These will keep track of the current sum and product of the subarray we are considering.
• Iterate the input vector arr from left to right, and for each element:
  • Add the element to curr_sum. If the element is not 0, we multiply it with curr_prod.
  • If curr_sum is equal to curr_prod, then the entire subarray from index 0 to the current index is a valid subarray that satisfies the problem statement.
  • Update max_len to be the maximum length of all valid subarrays we’ve encountered so far.
  • If curr_sum – curr_prod is in sum_dict, then there exists a subarray between the first index where we encountered curr_sum – curr_prod and the current index that satisfies the problem statement. We update max_len to be the maximum length of all valid subarrays we’ve encountered so far. We update sum_dict and prod_dict with the current curr_sum and curr_prod values
• If the current subarray’s sum is equal to the product, update the maximum length to include this subarray by comparing it with the current maximum length.
• Since the subarray starting at index 0 will always have a sum equal to the product, we do not need to check if the maximum length needs to be updated for this case.
• If the difference between the current sum and current product has been seen before (i.e., the current sum minus the current product has been seen before), it means that the subarray between the current index and the index of the previous occurrence of the difference has a product equal to its sum. In this case, we update the maximum length to include this subarray by comparing it with the current maximum length.
• Update the sum and product hash maps with the current sum and product values and their corresponding indices, if they are not already in the hash maps.

Below is the implementation of the code:

C++

// C++ Implementation of the code
#include <iostream>
#include <unordered_map>
#include <vector>
using namespace std;

// Function to find length of
// longest Subarray
int longestSubarray(vector<int>& arr)
{

    // get size of input array
    int n = arr.size();

    // Initialize variable to store
    // maximum length of subarray
    int max_len = 0;

    // Create unordered map to store the
    // first index of each sum value
    unordered_map<int, int> sum_dict;

    // Create unordered map to store the
    // first index of each prod value
    unordered_map<int, int> prod_dict;

    // Initialize variable to store current
    // sum of elements in subarray

    int curr_sum = 0;
    // Initialize variable to store current
    // product of elements in subarray
    int curr_prod = 1;

    // Loop through input array
    for (int i = 0; i < n; i++) {

        // Add current element
        // to current sum
        curr_sum += arr[i];

        // Avoid multiplying by zero
        if (arr[i] != 0) {

            // Multiply current element
            // to current product, if
            // not equal to zero
            curr_prod *= arr[i];
        }

        // If the current sum and
        // product are equal, subarray
        // from index 0 to i+1 is valid
        if (curr_sum == curr_prod) {
            max_len = max(max_len, i + 1);
        }

        // If the difference between the
        // current sum and product is found
        // in sum_dict, a valid
        // subarray exists
        else if (sum_dict.count(curr_sum - curr_prod)) {

            max_len
                = max(max_len,
                      i - sum_dict[curr_sum - curr_prod]);
        }

        // Store the first occurrence of
        // current sum in sum_dict
        if (sum_dict.count(curr_sum) == 0) {

            sum_dict[curr_sum] = i;
        }

        // Store the first occurrence of
        // current product in prod_dict
        if (prod_dict.count(curr_prod) == 0) {

            prod_dict[curr_prod] = i;
        }
    }

    // Return maximum length of valid
    // subarray
    return max_len;
}

// Driver code
int main()
{
    vector<int> arr1 = { 1, 2, 1, 2, 2, 5, 6, 24 };

    // Function call
    cout << longestSubarray(arr1) << endl;
    return 0;
}

Java

// Java Implementation of the code
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;

public class GFG {

    public static int longestSubarray(Vector<Integer> arr) {
        // get size of input array
        int n = arr.size();

        // Initialize variable to store
        // maximum length of subarray
        int max_len = 0;

        // Create Map to store the
        // first index of each sum value
        Map<Integer, Integer> sum_dict = new HashMap<Integer, Integer>();

        // Create Map to store the
        // first index of each prod value
        Map<Integer, Integer> prod_dict = new HashMap<Integer, Integer>();

        // Initialize variable to store current
        // sum of elements in subarray
        int curr_sum = 0;

        // Initialize variable to store current
        // product of elements in subarray
        int curr_prod = 1;

        // Loop through input array
        for (int i = 0; i < n; i++) {

            // Add current element
            // to current sum
            curr_sum += arr.get(i);

            // Avoid multiplying by zero
            if (arr.get(i) != 0) {

                // Multiply current element
                // to current product, if
                // not equal to zero
                curr_prod *= arr.get(i);
            }

            // If the current sum and
            // product are equal, subarray
            // from index 0 to i+1 is valid
            if (curr_sum == curr_prod) {
                max_len = Math.max(max_len, i + 1);
            }

            // If the difference between the
            // current sum and product is found
            // in sum_dict, a valid
            // subarray exists
            else if (sum_dict.containsKey(curr_sum - curr_prod)) {

                max_len =
                  Math.max(max_len, i - sum_dict.get(curr_sum - curr_prod));
            }

            // Store the first occurrence of
            // current sum in sum_dict
            if (!sum_dict.containsKey(curr_sum)) {

                sum_dict.put(curr_sum, i);
            }

            // Store the first occurrence of
            // current product in prod_dict
            if (!prod_dict.containsKey(curr_prod)) {

                prod_dict.put(curr_prod, i);
            }
        }

        // Return maximum length of valid
        // subarray
        return max_len;
    }

    // Driver code
    public static void main(String[] args) {
        Vector<Integer> arr1 = new Vector<Integer>();
        arr1.add(1);
        arr1.add(2);
        arr1.add(1);
        arr1.add(2);
        arr1.add(2);
        arr1.add(5);
        arr1.add(6);
        arr1.add(24);

        // Function call
        System.out.println(longestSubarray(arr1));
    }
}
// This code is contributed by Susobhan Akhuli

Python3

# Python implementation of the code
from collections import defaultdict

# Function to find length of
# longest Subarray
def longestSubarray(arr):
    # get size of input array
    n = len(arr)

    # Initialize variable to store
    # maximum length of subarray
    max_len = 0

    # Create dictionary to store the
    # first index of each sum value
    sum_dict = defaultdict(int)

    # Create dictionary to store the
    # first index of each prod value
    prod_dict = defaultdict(int)

    # Initialize variable to store current
    # sum of elements in subarray
    curr_sum = 0

    # Initialize variable to store current
    # product of elements in subarray
    curr_prod = 1

    # Loop through input array
    for i in range(n):

        # Add current element
        # to current sum
        curr_sum += arr[i]

        # Avoid multiplying by zero
        if arr[i] != 0:

            # Multiply current element
            # to current product, if
            # not equal to zero
            curr_prod *= arr[i]

        # If the current sum and
        # product are equal, subarray
        # from index 0 to i+1 is valid
        if curr_sum == curr_prod:
            max_len = max(max_len, i + 1)

        # If the difference between the
        # current sum and product is found
        # in sum_dict, a valid
        # subarray exists
        elif curr_sum - curr_prod in sum_dict:

            max_len = max(max_len,
                          i - sum_dict[curr_sum - curr_prod])

        # Store the first occurrence of
        # current sum in sum_dict
        if curr_sum not in sum_dict:

            sum_dict[curr_sum] = i

        # Store the first occurrence of
        # current product in prod_dict
        if curr_prod not in prod_dict:

            prod_dict[curr_prod] = i

    # Return maximum length of valid
    # subarray
    return max_len

# Driver code
if __name__ == '__main__':
    arr1 = [1, 2, 1, 2, 2, 5, 6, 24]

    # Function call
    print(longestSubarray(arr1))

# This code is contributed by Susobhan Akhuli

C#

// C# Implementation of the code
using System;
using System.Collections.Generic;

public class LongestSubarray {
  public static int FindLongestSubarray(List<int> arr)
  {
    // get size of input array
    int n = arr.Count;

    // Initialize variable to store
    // maximum length of subarray
    int max_len = 0;

    // Create dictionary to store the
    // first index of each sum value
    Dictionary<int, int> sumDict
      = new Dictionary<int, int>();

    // Create dictionary to store the
    // first index of each prod value
    Dictionary<int, int> prodDict
      = new Dictionary<int, int>();

    // Initialize variable to store current
    // sum of elements in subarray
    int curr_sum = 0;

    // Initialize variable to store current
    // product of elements in subarray
    int curr_prod = 1;

    // Loop through input array
    for (int i = 0; i < n; i++) {
      // Add current element
      // to current sum
      curr_sum += arr[i];

      // Avoid multiplying by zero
      if (arr[i] != 0) {
        // Multiply current element
        // to current product, if
        // not equal to zero
        curr_prod *= arr[i];
      }

      // If the current sum and
      // product are equal, subarray
      // from index 0 to i+1 is valid
      if (curr_sum == curr_prod) {
        max_len = Math.Max(max_len, i + 1);
      }

      // If the difference between the
      // current sum and product is found
      // in sumDict, a valid
      // subarray exists
      else if (sumDict.ContainsKey(curr_sum
                                   - curr_prod)) {
        max_len = Math.Max(
          max_len,
          i - sumDict[curr_sum - curr_prod]);
      }

      // Store the first occurrence of
      // current sum in sumDict
      if (!sumDict.ContainsKey(curr_sum)) {
        sumDict[curr_sum] = i;
      }

      // Store the first occurrence of
      // current product in prodDict
      if (!prodDict.ContainsKey(curr_prod)) {
        prodDict[curr_prod] = i;
      }
    }

    // Return maximum length of valid
    // subarray
    return max_len;
  }

  // Driver code
  public static void Main()
  {
    List<int> arr1
      = new List<int>() { 1, 2, 1, 2, 2, 5, 6, 24 };

    // Function call
    Console.WriteLine(FindLongestSubarray(arr1));
  }
}

Javascript

// JavaScript Implementation of the code

// Function to find length of
// longest Subarray
function longestSubarray(arr)
{

    // get size of input array
    let n = arr.length;

    // Initialize variable to store
    // maximum length of subarray
    let max_len = 0;

    // Create map to store the
    // first index of each sum value
    let sum_dict = new Map();

    // Create map to store the
    // first index of each prod value
    let prod_dict = new Map();

    // Initialize variable to store current
    // sum of elements in subarray
    let curr_sum = 0;

    // Initialize variable to store current
    // product of elements in subarray
    let curr_prod = 1;

    // Loop through input array
    for (let i = 0; i < n; i++) {

// Add current element
// to current sum
curr_sum += arr[i];

// Avoid multiplying by zero
if (arr[i] !== 0) {

    // Multiply current element
    // to current product, if
    // not equal to zero
    curr_prod *= arr[i];
}

// If the current sum and
// product are equal, subarray
// from index 0 to i+1 is valid
if (curr_sum === curr_prod) {
    max_len = Math.max(max_len, i + 1);
}

// If the difference between the
// current sum and product is found
// in sum_dict, a valid
// subarray exists
else if (sum_dict.has(curr_sum - curr_prod)) {
    max_len
        = Math.max(max_len,
              i - sum_dict.get(curr_sum - curr_prod));
}

// Store the first occurrence of
// current sum in sum_dict
if (!sum_dict.has(curr_sum)) {
    sum_dict.set(curr_sum, i);
}

// Store the first occurrence of
// current product in prod_dict
if (!prod_dict.has(curr_prod)) {
    prod_dict.set(curr_prod, i);
}
    }

    // Return maximum length of valid
    // subarray
    return max_len;
}

// Driver code
let arr1 = [1, 2, 1, 2, 2, 5, 6, 24];

// Function call
console.log(longestSubarray(arr1));

// This code is contributed by Susobhan Akhuli.

Output

5

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