Find subarray with given sum | Set 1 (Nonnegative Numbers)

Given an unsorted array of nonnegative integers, find a continuous subarray which adds to a given number.

Examples :

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

Input: arr[] = {1, 4, 0, 0, 3, 10, 5}, sum = 7
Ouptut: Sum found between indexes 1 and 4
Explanation: Sum of elements between indices
1 and 4 is 4 + 0 + 0 + 3 = 7

Input: arr[] = {1, 4}, sum = 0
Output: No subarray found
Explanation: There is no subarray with 0 sum

There may be more than one subarrays with sum as the given sum. The following solutions print first such subarray.



Simple Approach: A simple solution is to consider all subarrays one by one and check the sum of every subarray. Following program implements the simple solution. Run two loops: the outer loop picks a starting point I and the inner loop tries all subarrays starting from i.

  • Algorithm:
    1. Traverse the array from start to end.
    2. From every index start another loop from i to the end of array to get all subarray starting from i, keep a varibale sum to calculate the sum.
    3. For every index in inner loop update sum = sum + array[j]
    4. If the sum is equal to the given sum then print the subarray.
  • Implementation:

    C++

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    /* A simple program to print subarray 
    with sum as given sum */
    #include <bits/stdc++.h>
    using namespace std; 
      
    /* Returns true if the there is a subarray 
    of arr[] with sum equal to 'sum' otherwise 
    returns false. Also, prints the result */
    int subArraySum(int arr[], int n, int sum) 
        int curr_sum, i, j; 
      
        // Pick a starting point 
        for (i = 0; i < n; i++) 
        
            curr_sum = arr[i]; 
      
            // try all subarrays starting with 'i' 
            for (j = i + 1; j <= n; j++) 
            
                if (curr_sum == sum) 
                
                    cout << "Sum found between indexes " 
                         << i << " and " << j - 1; 
                    return 1; 
                
                if (curr_sum > sum || j == n) 
                    break
            curr_sum = curr_sum + arr[j]; 
            
        
      
        cout << "No subarray found"
        return 0; 
      
    // Driver Code
    int main() 
        int arr[] = {15, 2, 4, 8, 9, 5, 10, 23}; 
        int n = sizeof(arr) / sizeof(arr[0]); 
        int sum = 23; 
        subArraySum(arr, n, sum); 
        return 0; 
      
    // This code is contributed
    // by rathbhupendra

    chevron_right

    
    

    C

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    /* A simple program to print subarray with sum as given sum */
    #include<stdio.h>
      
    /* Returns true if the there is a subarray of arr[] with a sum equal to 'sum'
       otherwise returns false.  Also, prints the result */
    int subArraySum(int arr[], int n, int sum)
    {
        int curr_sum, i, j;
      
        // Pick a starting point
        for (i = 0; i < n; i++)
        {
            curr_sum = arr[i];
      
            // try all subarrays starting with 'i'
            for (j = i+1; j <= n; j++)
            {
                if (curr_sum == sum)
                {
                    printf ("Sum found between indexes %d and %d", i, j-1);
                    return 1;
                }
                if (curr_sum > sum || j == n)
                    break;
               curr_sum = curr_sum + arr[j];
            }
        }
      
        printf("No subarray found");
        return 0;
    }
      
    // Driver program to test above function
    int main()
    {
        int arr[] = {15, 2, 4, 8, 9, 5, 10, 23};
        int n = sizeof(arr)/sizeof(arr[0]);
        int sum = 23;
        subArraySum(arr, n, sum);
        return 0;
    }

    chevron_right

    
    

    Java

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    class SubarraySum 
    {
        /* Returns true if the there is a subarray of arr[] with a sum equal to
           'sum' otherwise returns false.  Also, prints the result */
        int subArraySum(int arr[], int n, int sum) 
        {
            int curr_sum, i, j;
      
            // Pick a starting point
            for (i = 0; i < n; i++) 
            {
                curr_sum = arr[i];
      
                // try all subarrays starting with 'i'
                for (j = i + 1; j <= n; j++) 
                {
                    if (curr_sum == sum) 
                    {
                        int p = j - 1;
                        System.out.println("Sum found between indexes " + i
                                + " and " + p);
                        return 1;
                    }
                    if (curr_sum > sum || j == n)
                        break;
                    curr_sum = curr_sum + arr[j];
                }
            }
      
            System.out.println("No subarray found");
            return 0;
        }
      
        public static void main(String[] args) 
        {
            SubarraySum arraysum = new SubarraySum();
            int arr[] = {15, 2, 4, 8, 9, 5, 10, 23};
            int n = arr.length;
            int sum = 23;
            arraysum.subArraySum(arr, n, sum);
        }
    }
      
    // This code has been contributed by Mayank Jaiswal(mayank_24)

    chevron_right

    
    

    Python3

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    # Returns true if the
    # there is a subarray
    # of arr[] with sum
    # equal to 'sum' 
    # otherwise returns
    # false. Also, prints
    # the result 
    def subArraySum(arr, n, sum):
          
        # Pick a starting 
        # point
        for i in range(n):
            curr_sum = arr[i]
          
            # try all subarrays
            # starting with 'i'
            j = i+1
            while j <= n:
              
                if curr_sum == sum:
                    print ("Sum found between")
                    print("indexes %d and %d"%( i, j-1))
                      
                    return 1
                      
                if curr_sum > sum or j == n:
                    break
                  
                curr_sum = curr_sum + arr[j]
                j += 1
      
        print ("No subarray found")
        return 0
      
    # Driver program 
    arr = [15, 2, 4, 8, 9, 5, 10, 23]
    n = len(arr)
    sum = 23
      
    subArraySum(arr, n, sum)
      
    # This code is Contributed by shreyanshi_arun.

    chevron_right

    
    

    C#

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // C# code to Find subarray
    // with given sum
    using System;
      
    class GFG 
    {
        // Returns true if the there is a
        // subarray of arr[] with sum
        // equal to 'sum' otherwise returns
        // false. Also, prints the result 
        int subArraySum(int []arr, int n, 
                                   int sum) 
        {
            int curr_sum, i, j;
      
            // Pick a starting point
            for (i = 0; i < n; i++) 
            {
                curr_sum = arr[i];
      
                // try all subarrays 
                // starting with 'i'
                for (j = i + 1; j <= n; j++) 
                {
                    if (curr_sum == sum) 
                    {
                        int p = j - 1;
                        Console.Write("Sum found between "
                                            "indexes " + i + 
                                               " and " + p);
                        return 1;
                    }
                    if (curr_sum > sum || j == n)
                        break;
                    curr_sum = curr_sum + arr[j];
                }
            }
      
            Console.Write("No subarray found");
            return 0;
        }
      
        // Driver Code
        public static void Main() 
        {
            GFG arraysum = new GFG();
            int []arr = {15, 2, 4, 8, 9, 5, 10, 23};
            int n = arr.Length;
            int sum = 23;
            arraysum.subArraySum(arr, n, sum);
        }
    }
      
    // This code has been contributed
    // by nitin mittal

    chevron_right

    
    

    PHP

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    <?php
    // A simple program to print subarray
    // with sum as given sum 
      
    /* Returns true if the there is
       a subarray of arr[] with 
       sum equal to 'sum'
       otherwise returns false. 
       Also, prints the result */
    function subArraySum($arr, $n, $sum)
    {
        $curr_sum; $i; $j;
      
        // Pick a starting point
        for ($i = 0; $i < $n; $i++)
        {
            $curr_sum = $arr[$i];
      
            // try all subarrays 
            // starting with 'i'
            for ($j = $i + 1; $j <= $n; $j++)
            {
                if ($curr_sum == $sum)
                {
                    echo "Sum found between indexes " 
                          ,$i ," and " ,$j-1 ;
                    return 1;
                }
                if ($curr_sum > $sum || $j == $n)
                    break;
            $curr_sum = $curr_sum + $arr[$j];
            }
        }
      
        echo "No subarray found";
        return 0;
    }
      
        // Driver Code
        $arr= array(15, 2, 4, 8, 9, 5, 10, 23);
        $n = sizeof($arr);
        $sum = 23;
        subArraySum($arr, $n, $sum);
        return 0;
          
    // This code is contributed by AJit
    ?>

    chevron_right

    
    


    Output :

    Sum found between indexes 1 and 4
    
  • Complexity Analysis:

    • Time Complexity: O(n^2) in worst case.
      Nested loop is used to traverse the array so the time complexity is O(n^2)
    • Space Complexity: O(1).
      As constant extra space is required.

Efficient Approach” There is an idea if all the elements of the array are positive. If a subarray has sum greater than the given sum then there is no possibility that adding elements to the current subarray the sum will be x (given sum). Idea is to use a similar approach to a sliding window. Start with an empty subarray, add elements to the subarray until the sum is less than x. If the sum is greater than x, remove elements from the start of the current subarray.

  • Algorithm:
    1. Create three variables, l=0, sum = 0
    2. Traverse the array from start to end.
    3. Update the variable sum by adding current element, sum = sum + array[i]
    4. If the sum is greater than the given sum, update the variable sum as sum = sum – array[l], and update l as , l++.
    5. If the sum is equal to given sum, print the subarray and break the loop.
  • Implementation:

    C++

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    /* An efficient program to print 
    subarray with sum as given sum */
    #include <iostream>
    using namespace std;
      
    /* Returns true if the there is a subarray of 
    arr[] with a sum equal to 'sum' otherwise 
    returns false. Also, prints the result */
    int subArraySum(int arr[], int n, int sum)
    {
        /* Initialize curr_sum as value of 
        first element and starting point as 0 */
        int curr_sum = arr[0], start = 0, i;
      
        /* Add elements one by one to curr_sum and 
        if the curr_sum exceeds the sum,
        then remove starting element */
        for (i = 1; i <= n; i++)
        {
            // If curr_sum exceeds the sum,
            // then remove the starting elements
            while (curr_sum > sum && start < i - 1)
            {
                curr_sum = curr_sum - arr[start];
                start++;
            }
      
            // If curr_sum becomes equal to sum,
            // then return true
            if (curr_sum == sum)
            
                cout << "Sum found between indexes " 
                     << start << " and " << i - 1;
                return 1;
            }
      
            // Add this element to curr_sum
            if (i < n)
            curr_sum = curr_sum + arr[i];
        }
      
        // If we reach here, then no subarray
        cout << "No subarray found";
        return 0;
    }
      
    // Driver Code
    int main()
    {
        int arr[] = {15, 2, 4, 8, 9, 5, 10, 23};
        int n = sizeof(arr) / sizeof(arr[0]);
        int sum = 23;
        subArraySum(arr, n, sum);
        return 0;
    }
      
    // This code is contributed by SHUBHAMSINGH10

    chevron_right

    
    

    C

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    /* An efficient program to print subarray with sum as given sum */
    #include<stdio.h>
      
    /* Returns true if the there is a subarray of arr[] with a sum equal to 'sum'
       otherwise returns false.  Also, prints the result */
    int subArraySum(int arr[], int n, int sum)
    {
        /* Initialize curr_sum as value of first element
           and starting point as 0 */
        int curr_sum = arr[0], start = 0, i;
      
        /* Add elements one by one to curr_sum and if the curr_sum exceeds the
           sum, then remove starting element */
        for (i = 1; i <= n; i++)
        {
            // If curr_sum exceeds the sum, then remove the starting elements
            while (curr_sum > sum && start < i-1)
            {
                curr_sum = curr_sum - arr[start];
                start++;
            }
      
            // If curr_sum becomes equal to sum, then return true
            if (curr_sum == sum)
            {
                printf ("Sum found between indexes %d and %d", start, i-1);
                return 1;
            }
      
            // Add this element to curr_sum
            if (i < n)
              curr_sum = curr_sum + arr[i];
        }
      
        // If we reach here, then no subarray
        printf("No subarray found");
        return 0;
    }
      
    // Driver program to test above function
    int main()
    {
        int arr[] = {15, 2, 4, 8, 9, 5, 10, 23};
        int n = sizeof(arr)/sizeof(arr[0]);
        int sum = 23;
        subArraySum(arr, n, sum);
        return 0;
    }

    chevron_right

    
    

    Java

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    class SubarraySum
    {
        /* Returns true if the there is a subarray of arr[] with sum equal to
           'sum' otherwise returns false.  Also, prints the result */
        int subArraySum(int arr[], int n, int sum) 
        {
            int curr_sum = arr[0], start = 0, i;
      
            // Pick a starting point
            for (i = 1; i <= n; i++) 
            {
                // If curr_sum exceeds the sum, then remove the starting elements
                while (curr_sum > sum && start < i-1)
                {
                    curr_sum = curr_sum - arr[start];
                    start++;
                }
                  
                // If curr_sum becomes equal to sum, then return true
                if (curr_sum == sum) 
                {
                    int p = i-1;
                    System.out.println("Sum found between indexes " + start
                            + " and " + p);
                    return 1;
                }
                  
                // Add this element to curr_sum
                if (i < n)
                curr_sum = curr_sum + arr[i];
                  
            }
      
            System.out.println("No subarray found");
            return 0;
        }
      
        public static void main(String[] args) 
        {
            SubarraySum arraysum = new SubarraySum();
            int arr[] = {15, 2, 4, 8, 9, 5, 10, 23};
            int n = arr.length;
            int sum = 23;
            arraysum.subArraySum(arr, n, sum);
        }
    }
      
    // This code has been contributed by Mayank Jaiswal(mayank_24)

    chevron_right

    
    

    Python3

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    # An efficient program 
    # to print subarray
    # with sum as given sum 
      
    # Returns true if the 
    # there is a subarray 
    # of arr[] with sum
    # equal to 'sum' 
    # otherwise returns 
    # false. Also, prints 
    # the result.
    def subArraySum(arr, n, sum):
          
        # Initialize curr_sum as
        # value of first element
        # and starting point as 0 
        curr_sum = arr[0]
        start = 0
      
        # Add elements one by 
        # one to curr_sum and 
        # if the curr_sum exceeds 
        # the sum, then remove 
        # starting element 
        i = 1
        while i <= n:
              
            # If curr_sum exceeds
            # the sum, then remove
            # the starting elements
            while curr_sum > sum and start < i-1:
              
                curr_sum = curr_sum - arr[start]
                start += 1
                  
            # If curr_sum becomes
            # equal to sum, then
            # return true
            if curr_sum == sum:
                print ("Sum found between indexes")
                print ("%d and %d"%(start, i-1))
                return 1
      
            # Add this element 
            # to curr_sum
            if i < n:
                curr_sum = curr_sum + arr[i]
            i += 1
      
        # If we reach here, 
        # then no subarray
        print ("No subarray found")
        return 0
      
    # Driver program
    arr = [15, 2, 4, 8, 9, 5, 10, 23]
    n = len(arr)
    sum = 23
      
    subArraySum(arr, n, sum)
      
    # This code is Contributed by shreyanshi_arun.

    chevron_right

    
    

    C#

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // An efficient C# program to print 
    // subarray with sum as given sum
    using System;
      
    class GFG 
    {
          
        // Returns true if the 
        // there is a subarray of 
        // arr[] with sum equal to
        // 'sum' otherwise returns false. 
        // Also, prints the result
        int subArraySum(int[] arr, int n, 
                                   int sum) 
        {
            int curr_sum = arr[0], 
                     start = 0, i;
      
            // Pick a starting point
            for (i = 1; i <= n; i++) 
            {
                // If curr_sum exceeds  
                // the sum, then remove
                // the starting elements
                while (curr_sum > sum && 
                       start < i - 1)
                {
                    curr_sum = curr_sum - 
                               arr[start];
                    start++;
                }
                  
                // If curr_sum becomes equal to
                // sum, then return true
                if (curr_sum == sum) 
                {
                    int p = i-1;
                    Console.WriteLine("Sum found between " +
                                         "indexes " + start+ 
                                               " and " + p);
                    return 1;
                }
                  
                // Add this element to curr_sum
                if (i < n)
                curr_sum = curr_sum + arr[i];
                  
            }
            Console.WriteLine("No subarray found");
            return 0;
        }
      
        // Driver code
        public static void Main() 
        {
            GFG arraysum = new GFG();
            int[] arr =new int[] {15, 2, 4, 8, 
                                  9, 5, 10, 23};
            int n = arr.Length;
            int sum = 23;
            arraysum.subArraySum(arr, n, sum);
        }
    }
      
    // This code has been contributed by KRV.

    chevron_right

    
    

    PHP

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    <?php
    /* An efficient program to print 
    subarray with sum as given sum */
      
    /* Returns true if the there is a 
    subarray of arr[] with sum equal 
    to 'sum' otherwise returns false. 
    Also, prints the result */
    function subArraySum($arr, $n, $sum)
    {
        /* Initialize curr_sum as 
        value of first element
        and starting point as 0 */
        $curr_sum = $arr[0]; 
        $start = 0; $i;
      
        /* Add elements one by one to 
        curr_sum and if the curr_sum 
        exceeds the sum, then remove
        starting element */
        for ($i = 1; $i <= $n; $i++)
        {
            // If curr_sum exceeds the sum, 
            // then remove the starting elements
            while ($curr_sum > $sum and 
                   $start < $i - 1)
            {
                $curr_sum = $curr_sum
                            $arr[$start];
                $start++;
            }
      
            // If curr_sum becomes equal 
            // to sum, then return true
            if ($curr_sum == $sum)
            {
                echo "Sum found between indexes" ,
                                 " ", $start, " "
                               "and "," ", $i - 1;
                return 1;
            }
      
            // Add this element
            // to curr_sum
            if ($i < $n)
            $curr_sum = $curr_sum + $arr[$i];
        }
      
        // If we reach here,
        // then no subarray
        echo "No subarray found";
        return 0;
    }
      
    // Driver Code
    $arr = array(15, 2, 4, 8, 
                  9, 5, 10, 23);
    $n = count($arr);
    $sum = 23;
    subArraySum($arr, $n, $sum);
      
    // This code has been
    // contributed by anuj_67.
    ?>

    chevron_right

    
    


    Output :

    Sum found between indexes 1 and 4
    
  • Complexity Analysis:

    • Time Complexity : O(n). Only one traversal of the array is required. So the time complexity is O(n).
    • Space Complexity: O(1), constant extra space is required.

The above solution doesn’t handle negative numbers. We can use hashing to handle negative numbers. See below set 2.

Find subarray with given sum | Set 2 (Handles Negative Numbers)

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.




My Personal Notes arrow_drop_up