Sub array that produces a given sum and product

Question

Given an array of length N. How will you find the minimum length contiguous sub-array of whose sum is S and whose product is P. For eg 5 6 1 4 6 2 9 7 fo

Answer 1

You can use a hashmap to find the answer for product in O(N) time with extra space.

Answer 2

Put two indices on the array. Lets call them i and j. Initially j = 1 and i =0. If the product between i and j is less than P, increment j. If it is greater than P, increment i. If we get something equal to p, sum up the elements (instead of summing up everytime, maintain an array where S(i) is the sum of everything to the left of it. Compute sum from i to j as S(i) - S(j)) and see whether you get S. Stop when j falls out of the array length.

This is O(n).

Answer 3

Just go from left to right, and sum all the numbers, if the sum > S, then throw away left ones.

import java.util.Arrays;

public class test {
    public static void main (String[] args) {
        int[] array = {5, 6, 1, 4, 6, 2, 9, 7};
        int length = array.length;
        int S = 17;
        int sum = 0;                       // current sum of sub array, assume all positive
        int start = 0;                     // current start of sub array
        int minLength = array.length + 1;  // length of minimum sub array found
        int minStart = 0;                  // start of of minimum sub array found
        for (int index = 0; index < length; index++) {
          sum = sum + array[index];
          // Find by add to right
          if (sum == S && index - start + 1 < minLength) {
              minLength = index - start + 1;
              minStart = start;
          }
          while (sum >= S) {
            sum = sum - array[start];
            start++;
            // Find by minus from left
            if (sum == S && index - start + 1 < minLength) {
                minLength = index - start + 1;
                minStart = start;
            }
          }
        }
        // Found
        if (minLength != length + 1) {
            System.out.println(Arrays.toString(Arrays.copyOfRange(array, minStart, minStart + minLength)));
        }
    }
}

---

For your example, I think it is OR.

Product is nothing different from sum, except for calculation.

Answer 4

pseudocode:

subStart = 0;
Sum = 0
for (i = 0; i< array.Length; i++)
    Sum = Sum + array[i];
    if (Sum < targetSum) continue;
    if (Sum == targetSum) result = min(result, i - subStart +1);
    while (Sum >= targetSum)
        Sum = Sum - array[subStart];
        subStart++;

I think that'll find the result with one pass through the array. There's a bit of detail missing there in the result value. Needs a bit more complexity there to be able to return the actual subarray if needed.

To find the Product sub-array just substitute multiplication/division for addition/subtraction in the above algorithm