Find the longest Subarray with equal Sum and Product
Last Updated :
17 Apr, 2023
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++
#include <iostream>
#include <unordered_map>
#include <vector>
using namespace std;
int longestSubarray(vector< int >& arr)
{
int n = arr.size();
int max_len = 0;
unordered_map< int , int > sum_dict;
unordered_map< int , int > prod_dict;
int curr_sum = 0;
int curr_prod = 1;
for ( int i = 0; i < n; i++) {
curr_sum += arr[i];
if (arr[i] != 0) {
curr_prod *= arr[i];
}
if (curr_sum == curr_prod) {
max_len = max(max_len, i + 1);
}
else if (sum_dict.count(curr_sum - curr_prod)) {
max_len
= max(max_len,
i - sum_dict[curr_sum - curr_prod]);
}
if (sum_dict.count(curr_sum) == 0) {
sum_dict[curr_sum] = i;
}
if (prod_dict.count(curr_prod) == 0) {
prod_dict[curr_prod] = i;
}
}
return max_len;
}
int main()
{
vector< int > arr1 = { 1, 2, 1, 2, 2, 5, 6, 24 };
cout << longestSubarray(arr1) << endl;
return 0;
}
|
Java
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;
public class GFG {
public static int longestSubarray(Vector<Integer> arr) {
int n = arr.size();
int max_len = 0 ;
Map<Integer, Integer> sum_dict = new HashMap<Integer, Integer>();
Map<Integer, Integer> prod_dict = new HashMap<Integer, Integer>();
int curr_sum = 0 ;
int curr_prod = 1 ;
for ( int i = 0 ; i < n; i++) {
curr_sum += arr.get(i);
if (arr.get(i) != 0 ) {
curr_prod *= arr.get(i);
}
if (curr_sum == curr_prod) {
max_len = Math.max(max_len, i + 1 );
}
else if (sum_dict.containsKey(curr_sum - curr_prod)) {
max_len =
Math.max(max_len, i - sum_dict.get(curr_sum - curr_prod));
}
if (!sum_dict.containsKey(curr_sum)) {
sum_dict.put(curr_sum, i);
}
if (!prod_dict.containsKey(curr_prod)) {
prod_dict.put(curr_prod, i);
}
}
return max_len;
}
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 );
System.out.println(longestSubarray(arr1));
}
}
|
Python3
from collections import defaultdict
def longestSubarray(arr):
n = len (arr)
max_len = 0
sum_dict = defaultdict( int )
prod_dict = defaultdict( int )
curr_sum = 0
curr_prod = 1
for i in range (n):
curr_sum + = arr[i]
if arr[i] ! = 0 :
curr_prod * = arr[i]
if curr_sum = = curr_prod:
max_len = max (max_len, i + 1 )
elif curr_sum - curr_prod in sum_dict:
max_len = max (max_len,
i - sum_dict[curr_sum - curr_prod])
if curr_sum not in sum_dict:
sum_dict[curr_sum] = i
if curr_prod not in prod_dict:
prod_dict[curr_prod] = i
return max_len
if __name__ = = '__main__' :
arr1 = [ 1 , 2 , 1 , 2 , 2 , 5 , 6 , 24 ]
print (longestSubarray(arr1))
|
C#
using System;
using System.Collections.Generic;
public class LongestSubarray {
public static int FindLongestSubarray(List< int > arr)
{
int n = arr.Count;
int max_len = 0;
Dictionary< int , int > sumDict
= new Dictionary< int , int >();
Dictionary< int , int > prodDict
= new Dictionary< int , int >();
int curr_sum = 0;
int curr_prod = 1;
for ( int i = 0; i < n; i++) {
curr_sum += arr[i];
if (arr[i] != 0) {
curr_prod *= arr[i];
}
if (curr_sum == curr_prod) {
max_len = Math.Max(max_len, i + 1);
}
else if (sumDict.ContainsKey(curr_sum
- curr_prod)) {
max_len = Math.Max(
max_len,
i - sumDict[curr_sum - curr_prod]);
}
if (!sumDict.ContainsKey(curr_sum)) {
sumDict[curr_sum] = i;
}
if (!prodDict.ContainsKey(curr_prod)) {
prodDict[curr_prod] = i;
}
}
return max_len;
}
public static void Main()
{
List< int > arr1
= new List< int >() { 1, 2, 1, 2, 2, 5, 6, 24 };
Console.WriteLine(FindLongestSubarray(arr1));
}
}
|
Javascript
function longestSubarray(arr)
{
let n = arr.length;
let max_len = 0;
let sum_dict = new Map();
let prod_dict = new Map();
let curr_sum = 0;
let curr_prod = 1;
for (let i = 0; i < n; i++) {
curr_sum += arr[i];
if (arr[i] !== 0) {
curr_prod *= arr[i];
}
if (curr_sum === curr_prod) {
max_len = Math.max(max_len, i + 1);
}
else if (sum_dict.has(curr_sum - curr_prod)) {
max_len
= Math.max(max_len,
i - sum_dict.get(curr_sum - curr_prod));
}
if (!sum_dict.has(curr_sum)) {
sum_dict.set(curr_sum, i);
}
if (!prod_dict.has(curr_prod)) {
prod_dict.set(curr_prod, i);
}
}
return max_len;
}
let arr1 = [1, 2, 1, 2, 2, 5, 6, 24];
console.log(longestSubarray(arr1));
|
Time complexity: O(N)
Auxiliary Space: O(N)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...