GFG App
Open App
Browser
Continue

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 ` `#include ` `#include ` `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 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 sum_dict = ``new` `HashMap();`   `        ``// Create Map to store the` `        ``// first index of each prod value` `        ``Map prod_dict = ``new` `HashMap();`   `        ``// 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 arr1 = ``new` `Vector();` `        ``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)

My Personal Notes arrow_drop_up