# Number of subarrays having sum exactly equal to k

• Difficulty Level : Medium
• Last Updated : 08 Jul, 2022

Given an unsorted array of integers, find the number of subarrays having a sum exactly equal to a given number k.

Examples:

Input : arr[] = {10, 2, -2, -20, 10}, k = -10
Output : 3
Explanation: Subarrays: arr[0…3], arr[1…4], arr[3..4] have a sum exactly equal to -10.

Input : arr[] = {9, 4, 20, 3, 10, 5}, k = 33
Output : 2
Explanation: Subarrays : arr[0…2], arr[2…4] have a sum exactly equal to 33.

Recommended Practice

Naive Solution: A simple solution is to traverse all the subarrays and calculate their sum. If the sum is equal to the required sum, then increment the count of subarrays. Print final count of subarray.
Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;` `int` `main()` `{` `  ``int` `arr[] = {10, 2, -2, -20, 10};` `  ``int` `k = -10;` `  ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `  ``int` `res = 0;`   `  ``// Calculate all subarrays` `  ``for` `(``int` `i = 0; i < n; i++) ` `  ``{` `    ``int` `sum = 0;` `    ``for` `(``int` `j = i; j < n; j++)` `    ``{` `      ``// Calculate required sum` `      ``sum += arr[j];` `      ``// Check if sum is equal to required sum` `      ``if` `(sum == k)` `        ``res++;` `    ``}` `  ``}` `  ``cout << (res) << endl;` `}`   `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// C program for the above approach` `#include ` `int` `main()` `{` `    ``int` `arr[] = { 10, 2, -2, -20, 10 };` `    ``int` `k = -10;` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``int` `res = 0;`   `    ``// Calculate all subarrays` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``int` `sum = 0;` `        ``for` `(``int` `j = i; j < n; j++) ` `        ``{` `          `  `            ``// Calculate required sum` `            ``sum += arr[j];` `          `  `            ``// Check if sum is equal to required sum` `            ``if` `(sum == k)` `                ``res++;` `        ``}` `    ``}` `    ``printf``(``"%d\n"``, res);` `}`   `// This code is contributed by Aditya Kumar (adityakumar129)`

## Java

 `// Java program for the above approach` `import` `java.util.*;` `class` `Solution {`   `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `arr[] = { ``10``, ``2``, -``2``, -``20``, ``10` `};` `        ``int` `k = -``10``;` `        ``int` `n = arr.length;` `        ``int` `res = ``0``;`   `        ``// calculate all subarrays` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``int` `sum = ``0``;` `            ``for` `(``int` `j = i; j < n; j++) {` `                ``// calculate required sum` `                ``sum += arr[j];` `                ``// check if sum is equal to required sum` `                ``if` `(sum == k)` `                    ``res++;` `            ``}` `        ``}` `        ``System.out.println(res);` `    ``}` `}`   `// This code is contributed by Aditya Kumar (adityakumar129)`

## Python3

 `# Python3 program for` `# the above approach` `arr ``=` `[ ``10``, ``2``, ``-``2``, ``-``20``, ``10` `]` `n ``=` `len``(arr)` `k ``=` `-``10` `res ``=` `0`   `# Calculate all subarrays` `for` `i ``in` `range``(n):` `    ``summ ``=` `0`            `    ``for` `j ``in` `range``(i, n):` `        `  `        ``# Calculate required sum` `        ``summ ``+``=` `arr[j]`   `        ``# Check if sum is equal to` `        ``# required sum` `        ``if` `summ ``=``=` `k:` `            ``res ``+``=` `1`   `print``(res)`   `# This code is contributed by kavan155gondalia`

## C#

 `// C# program for` `// the above approach` `using` `System;` `using` `System.Collections.Generic; ` `class` `GFG {` `    `  `  ``static` `void` `Main() {` `      ``int``[] arr = {10, 2, -2, -20, 10};` `      ``int` `k = -10;` `      ``int` `n = arr.Length;` `      ``int` `res = 0;` `     `  `      ``// Calculate all subarrays` `      ``for` `(``int` `i = 0; i < n; i++) ` `      ``{` `        ``int` `sum = 0;` `        ``for` `(``int` `j = i; j < n; j++)` `        ``{` `          `  `          ``// Calculate required sum` `          ``sum += arr[j];` `     `  `          ``// Check if sum is equal to` `          ``// required sum` `          ``if` `(sum == k)` `            ``res++;` `        ``}` `      ``}` `      ``Console.WriteLine(res);` `  ``}` `}`   `// This code is contributed by divyesh072019`

## Javascript

 ``

Output

`3`

Time Complexity : O(n2)

Auxiliary Space: O(1)

Efficient Solution : An efficient solution is while traversing the array, storing sum so far in currsum. Also, maintain the count of different values of currsum in a map. If the value of currsum is equal to the desired sum at any instance increment count of subarrays by one. The value of currsum exceeds the desired sum by currsum – sum. If this value is removed from currsum then the desired sum can be obtained. From the map, find the number of subarrays previously found having sum equal to currsum-sum. Excluding all those subarrays from the current subarray, gives new subarrays having the desired sum. So increase count by the number of such subarrays. Note that when currsum is equal to the desired sum then also check the number of subarrays previously having a sum equal to 0. Excluding those subarrays from the current subarray gives new subarrays having the desired sum. Increase the count by the number of subarrays having sum 0 in that case.

## C++

 `// C++ program to find number of subarrays with sum exactly` `// equal to k.` `#include ` `using` `namespace` `std;`   `// Function to find number of subarrays with sum exactly` `// equal to k.` `int` `findSubarraySum(``int` `arr[], ``int` `n, ``int` `sum)` `{` `    ``// STL map to store number of subarrays starting from` `    ``// index zero having particular value of sum.` `    ``unordered_map<``int``, ``int``> prevSum;`   `    ``int` `res = 0;`   `    ``// Sum of elements so far.` `    ``int` `currSum = 0;`   `    ``for` `(``int` `i = 0; i < n; i++) {`   `        ``// Add current element to sum so far.` `        ``currSum += arr[i];`   `        ``// If currsum is equal to desired sum, then a new` `        ``// subarray is found. So increase count of` `        ``// subarrays.` `        ``if` `(currSum == sum)` `            ``res++;`   `        ``// currsum exceeds given sum by currsum  - sum. Find` `        ``// number of subarrays having this sum and exclude` `        ``// those subarrays from currsum by increasing count` `        ``// by same amount.` `        ``if` `(prevSum.find(currSum - sum) != prevSum.end())` `            ``res += (prevSum[currSum - sum]);`   `        ``// Add currsum value to count of different values of` `        ``// sum.` `        ``prevSum[currSum]++;` `    ``}`   `    ``return` `res;` `}`   `int` `main()` `{` `    ``int` `arr[] = { 10, 2, -2, -20, 10 };` `    ``int` `sum = -10;` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``cout << findSubarraySum(arr, n, sum);` `    ``return` `0;` `}`   `// This code is contributed by Aditya Kumar (adityakumar129)`

## Java

 `// Java program to find number of subarrays` `// with sum exactly equal to k.` `import` `java.util.HashMap;` `import` `java.util.Map;`   `public` `class` `GfG {`   `    ``// Function to find number of subarrays` `    ``// with sum exactly equal to k.` `    ``static` `int` `findSubarraySum(``int` `arr[], ``int` `n, ``int` `sum)` `    ``{` `        ``// HashMap to store number of subarrays` `        ``// starting from index zero having` `        ``// particular value of sum.` `        ``HashMap prevSum = ``new` `HashMap<>();` `        ``prevSum.put(``0``,``1``);` `        ``int` `res = ``0``;`   `        ``// Sum of elements so far.` `        ``int` `currSum = ``0``;`   `        ``for` `(``int` `i = ``0``; i < n; i++) {`   `            ``// Add current element to sum so far.` `            ``currSum += arr[i];` `            ``//calculate the sum that have to be removed` `          ``//so that we can get the desired sum` `           `  `            ``int` `removeSum=currSum-sum;`   `           ``//get count of occurrences of that sum that` `          ``//have to removed and add it to res value` `            ``if` `(prevSum.containsKey(removeSum))` `                ``res += prevSum.get(removeSum);`   `            ``// Add currsum value to count of` `            ``// different values of sum.` `            ``prevSum.put(currSum,prevSum.getOrDefault(currSum,``0``)+``1``);` `        ``}`   `        ``return` `res;` `    ``}`   `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``int` `arr[] = { ``10``, ``2``, -``2``, -``20``, ``10` `};` `        ``int` `sum = -``10``;` `        ``int` `n = arr.length;` `        ``System.out.println(findSubarraySum(arr, n, sum));` `    ``}` `}`   `// This code is contributed by Rituraj Jain`

## Python3

 `# Python3 program to find the number of ` `# subarrays with sum exactly equal to k. ` `from` `collections ``import` `defaultdict`   `# Function to find number of subarrays  ` `# with sum exactly equal to k. ` `def` `findSubarraySum(arr, n, ``Sum``): ` ` `  `    ``# Dictionary to store number of subarrays ` `    ``# starting from index zero having  ` `    ``# particular value of sum. ` `    ``prevSum ``=` `defaultdict(``lambda` `: ``0``)` `  `  `    ``res ``=` `0` `  `  `    ``# Sum of elements so far. ` `    ``currsum ``=` `0` `  `  `    ``for` `i ``in` `range``(``0``, n):  ` `  `  `        ``# Add current element to sum so far. ` `        ``currsum ``+``=` `arr[i] ` `  `  `        ``# If currsum is equal to desired sum, ` `        ``# then a new subarray is found. So ` `        ``# increase count of subarrays. ` `        ``if` `currsum ``=``=` `Sum``:  ` `            ``res ``+``=` `1`         `  `  `        ``# currsum exceeds given sum by currsum  - sum.` `        ``# Find number of subarrays having  ` `        ``# this sum and exclude those subarrays ` `        ``# from currsum by increasing count by  ` `        ``# same amount. ` `        ``if` `(currsum ``-` `Sum``) ``in` `prevSum:` `            ``res ``+``=` `prevSum[currsum ``-` `Sum``] ` `          `  `  `  `        ``# Add currsum value to count of  ` `        ``# different values of sum. ` `        ``prevSum[currsum] ``+``=` `1` `     `  `    ``return` `res ` ` `  `if` `__name__ ``=``=` `"__main__"``:`   `    ``arr ``=`  `[``10``, ``2``, ``-``2``, ``-``20``, ``10``]  ` `    ``Sum` `=` `-``10` `    ``n ``=` `len``(arr) ` `    ``print``(findSubarraySum(arr, n, ``Sum``)) ` `    `  `# This code is contributed by Rituraj Jain`

## C#

 `// C# program to find number of subarrays` `// with sum exactly equal to k.` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG {` `    ``// Function to find number of subarrays` `    ``// with sum exactly equal to k.` `    ``public` `static` `int` `findSubarraySum(``int``[] arr,` `                                      ``int` `n, ``int` `sum)` `    ``{`   `        ``// HashMap to store number of subarrays` `        ``// starting from index zero having` `        ``// particular value of sum.` `        ``Dictionary<``int``, ``int``> prevSum = ``new` `Dictionary<``int``, ``int``>();`   `        ``int` `res = 0;`   `        ``// Sum of elements so far` `        ``int` `currsum = 0;`   `        ``for` `(``int` `i = 0; i < n; i++) {`   `            ``// Add current element to sum so far.` `            ``currsum += arr[i];`   `            ``// If currsum is equal to desired sum,` `            ``// then a new subarray is found. So` `            ``// increase count of subarrays.` `            ``if` `(currsum == sum)` `                ``res++;`   `            ``// currsum exceeds given sum by currsum` `            ``// - sum. Find number of subarrays having` `            ``// this sum and exclude those subarrays` `            ``// from currsum by increasing count by` `            ``// same amount.` `            ``if` `(prevSum.ContainsKey(currsum - sum))` `                ``res += prevSum[currsum - sum];`   `            ``// Add currsum value to count of` `            ``// different values of sum.` `            ``if` `(!prevSum.ContainsKey(currsum))` `                ``prevSum.Add(currsum, 1);` `            ``else` `{` `                ``int` `count = prevSum[currsum];` `                ``prevSum[currsum] = count + 1;` `            ``}` `        ``}` `        ``return` `res;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int``[] arr = { 10, 2, -2, -20, 10 };` `        ``int` `sum = -10;` `        ``int` `n = arr.Length;` `        ``Console.Write(findSubarraySum(arr, n, sum));` `    ``}` `}`   `// This code is contributed by` `// sanjeev2552`

## Javascript

 ``

Output

`3`

Time Complexity: O(n)
Auxiliary Space: O(n)

This article is contributed by Aarti_Rathi. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.