Find subarray with given sum 

Input: arr[] = {1, 4, 20, 3, 10, 5}, sum = 33
Ouptut: Sum found between indexes 2 and 4

Input: arr[] = {10, 2, -2, -20, 10}, sum = -10
Ouptut: Sum found between indexes 0 to 3

Input: arr[] = {-10, 0, 2, -2, -20, 10}, sum = 20
Ouptut: No subarray with given sum exists

 Naive Solution:

    We pick elements one by one in outer loop and find its sum with other elements to its right till we get the given sum.
Code:

 import java.util.*;

 public class Solution {

     
    public static void main(String[] args) {
       
        int[] a = {10, 2, -2, -20, 10};
        int n = a.length;
        int sum = -10, currsum = 0;
        int index1 = -1, index2 = -1;
        
        for(int i=0; i<n; i++){
            currsum = a[i];
            for(int j = i+1; j<n; j++){
                currsum +=a[j];
                if(currsum == sum){
                    index1 = i; 
                    index2 = j;
                    break;
                }
            }
            if(currsum == sum){
                break;
            }
        }
        
        System.out.println(index1+" "+index2);
        
        
       
    }
}

 Output:

 
0 3
Efficient Solution: (with only non negative elements)

     It is based on sliding window technique similar to https://www.geeksforgeeks.org/window-sliding-technique/
Code:

 import java.util.*;

 public class Solution {

     
    public static void main(String[] args) {
       
        int[] a = {1,4,20,3,10,5};
        int n = a.length;
        int sum = 33, currsum = a[0];
        int index1 = 0, index2 = 0;
        
        while(index2<n){
            if(currsum < sum){
                index2++;
                currsum += a[index2];
            }
            
            if(currsum > sum){
                currsum -= a[index1];
                index1++;
            }
            
            if(currsum == sum){
                    break;
                }
        }
        
        System.out.println(index1+" "+index2);
        
        
       
    }
}

 Output:

 
2 4
Efficient solution (negative numbers) : O(n) auxiliary space, O(n) time

   Here we keep track of sum find so far in  map. We will calculate the currsum. If currsum is equal to given sum we will print the indices. Else we will check if the difference between currsum and sum is present in the map. This can be better understood by the illustration following the code.

 Code:

 import java.util.*;

 public class Solution {

     
    public static void main(String[] args) {
       
        int[] a = {1,4,-20,-3,-10,5};
        int n = a.length;
        int sum = -33, currsum = a[0];
        Map<Integer,Integer> map= new HashMap<Integer,Integer>();
        
        for(int i=0; i<n; i++){
            currsum += a[i];
            if(a[i] == currsum){
                System.out.println("0"+" "+i);
                break;
            }
            
            if(map.containsKey(currsum-sum)){
                int index1 = map.get(currsum-sum)+1;
                System.out.println(index1+" "+i);
                break;
            }
            
            map.put(currsum,i);
        }

     }
}

 Output:
2 4

 Illustration:


   





Comments

Post a Comment

Popular posts from this blog

Rearrange Array in Maximum-Minimum form

Given a sorted array of positive integers, rearrange the array alternately i.e first element should be the maximum value, second minimum value, third-second max, fourth-second min and so on. Naive Solution: Here we will use an auxiliary array to store the elements in correct order. For even indices of the array  Large numbers from the given array are added. For odd indices small numbers are added. Code: import java.util.*; public class Test{        public static void main(String[] args) {          Scanner in = new Scanner(System.in);     int[] a = {1,2,3,4,5,6,7,8,9};     int n = a.length;     int[] temp = new int[n];     int small = 0;     int large = n-1;     for(int i=0; i<n; i++){         if(i%2 == 0){             temp[i] = a[large--];         }  ...
Read more

Find zeroes to be flipped so that number of consecutive 1's is maximized

Image
Input: arr[] = {1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1} m = 2 Output: 5 7 We are allowed to flip maximum 2 zeroes. If we flip arr[5] and arr[7], we get 8 consecutive 1's which is maximum possible under given constraints Input: arr[] = {1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1} m = 1 Output: 7 We are allowed to flip maximum 1 zero. If we flip arr[7], we get 5 consecutive 1's which is maximum possible under given constraints. Input: arr[] = {0, 0, 0, 1} m = 4 Output: 0 1 2 Since m is more than number of zeroes, we can flip all zeroes. Steps: It is based on sliding window method. The window at any time should consists of only m zeroes. If the zerocount is below m wr is incremented. If the zerocount is more wl is incremented. Code: import java.util.*; public class Solution {       public static void main(String[] args) {         int[] a = {1,1,0,1,1,0,0,1,1,1};         int m = 2;   ...
Read more

Count substrings with same first and last character

Given a string we have check contiguous substrings with same first and last characer. Input: abcab Output: 7 (a,abca,b,bcab, c, a, b) Naive Solution: T: O(n^2) S: O(1)      We initialize the count to length of the string as each and every element contribute to its length.       In the outer loop we will pick a element. In the inner loop we will compare it other elements and if they are equal we will increment the counter.  Code: import java.util.*; public class Solution {          public static void main(String[] args) {         String str = "aba";         char[] s = str.toCharArray();         int len = s.length;         int count = len;         for(int i=0; i<len-1; i++){             for(int j=i+1; j<len; j++){               ...
Read more