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

29 Mar, 2022
Given an unsorted array arr of nonnegative integers and an integer sum, find a continuous subarray which adds to a given sum. There may be more than one subarrays with sum as the given sum, print first such subarray. Examples : 
Input: arr[] = {1, 4, 20, 3, 10, 5}, sum = 33Output: Sum found between indexes 2 and 4Sum of elements between indices 2 and 4 is 20 + 3 + 10 = 33
Input: arr[] = {1, 4, 0, 0, 3, 10, 5}, sum = 7Output: Sum found between indexes 1 and 4Sum of elements between indices 1 and 4 is 4 + 0 + 0 + 3 = 7
Input: arr[] = {1, 4}, sum = 0Output: No subarray foundThere is no subarray with 0 sum
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:  
Traverse the array from start to end.From every index start another loop from i to the end of array to get all subarray starting from i, keep a variable sum to calculate the sum.For every index in inner loop update sum = sum + array[j]If the sum is equal to the given sum then print the subarray.
Traverse the array from start to end.
From every index start another loop from i to the end of array to get all subarray starting from i, keep a variable sum to calculate the sum.
For every index in inner loop update sum = sum + array[j]
If the sum is equal to the given sum then print the subarray.
C++
C
Java
Python3
C#
PHP
Javascript
/* 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 Codeint 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
/* 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 functionint 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;}
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)
# 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.
// C# code to Find subarray// with given sumusing 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
<?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?>
<script>  /* 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){    let curr_sum=0;      // Pick a starting point    for (let i = 0; i < n; i++) {        curr_sum = arr[i];          // try all subarrays starting with 'i'        for (let j = i + 1; j <= n; j++) {            if (curr_sum == sum) {                document.write("Sum found between indexes "+i+" and "+(j - 1));                return;            }            if (curr_sum > sum || j == n)                break;            curr_sum = curr_sum + arr[j];        }    }      document.write("No subarray found");    return;}  // Driver Code  let arr= [15, 2, 4, 8, 9, 5, 10, 23];let n = arr.length;let sum = 23;subArraySum(arr, n, sum);  </script>
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:  
Create three variables, l=0, sum = 0Traverse the array from start to end.Update the variable sum by adding current element, sum = sum + array[i]If the sum is greater than the given sum, update the variable sum as sum = sum – array[l], and update l as, l++.If the sum is equal to given sum, print the subarray and break the loop.
Create three variables, l=0, sum = 0
Traverse the array from start to end.
Update the variable sum by adding current element, sum = sum + array[i]
If the sum is greater than the given sum, update the variable sum as sum = sum – array[l], and update l as, l++.
If the sum is equal to given sum, print the subarray and break the loop.
C++
C
Java
Python3
C#
PHP
Javascript
/* 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 Codeint 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
/* 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 functionint 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;}
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)
# 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 programarr = [15, 2, 4, 8, 9, 5, 10, 23]n = len(arr)sum_ = 23  subArraySum(arr, n, sum_)  # This code is Contributed by shreyanshi_arun.
// An efficient C# program to print// subarray with sum as given sumusing 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.
<?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.?>
<script>/* Returns true if the there isa subarray of arr[] with sum equal to       'sum' otherwise returns false. Also, prints the result */          function subArraySum(arr,n,sum)    {        let 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) {                let p = i - 1;                document.write(                    "Sum found between indexes " + start                    + " and " + p+"<br>");                return 1;            }               // Add this element to curr_sum            if (i < n)                curr_sum = curr_sum + arr[i];        }           document.write("No subarray found");        return 0;    }          let arr=[15, 2, 4, 8, 9, 5, 10, 23 ];    let n = arr.length;    let sum = 23;    subArraySum(arr, n, sum);          // This code is contributed by unknown2108</script>
Sum found between indexes 1 and 4
Complexity Analysis:  
Time Complexity : O(n). The Array is traversed only once to insert elements into the window. It will take O(N) timeThe Array is traversed again once to remove elements from the window. It will also take O(N) time.So the total time will be O(N) + O(N) = O(2*N), which is similar to O(N)
The Array is traversed only once to insert elements into the window. It will take O(N) time
The Array is traversed again once to remove elements from the window. It will also take O(N) time.
So the total time will be O(N) + O(N) = O(2*N), which is similar to O(N)
Space Complexity: O(1). As constant extra space is required.
YouTubeGeeksforGeeks506K subscribersFind subarray with given sum | Set 1 (Non-negative Numbers) | GeeksforGeeksWatch laterShareCopy link71/101InfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.You're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmMore videosMore videosSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 2:50•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=GY-KULykGaw" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
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)
Find subarray with given sum with negatives allowed in constant space
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
KRV
jit_t
nitin mittal
vt_m
rathbhupendra
gfg_sal_gfg
nidhi_biet
SHUBHAMSINGH10
andrew1234
ch17btech11023
mohit kumar 29
unknown2108
sooda367
sweetyty
anikakapoor
RishabhPrabhu
Amazon
Facebook
FactSet
Google
Morgan Stanley
sliding-window
subarray
subarray-sum
Visa
Zoho
Arrays
Zoho
Morgan Stanley
Amazon
FactSet
Visa
Google
Facebook
sliding-window
Arrays
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Arrays in Java
Arrays in C/C++
Write a program to reverse an array or string
Program for array rotation
Largest Sum Contiguous Subarray
Top 50 Array Coding Problems for Interviews
Stack Data Structure (Introduction and Program)
Introduction to Arrays
Multidimensional Arrays in Java