Count of Subarrays with sum equals k in given Binary Array

Last Updated : 8 Mar, 2026

Given a binary array arr[] and an integer k, find the count of non-empty subarrays with a sum equal to k.

Input: arr[] = {1, 0, 1, 1, 0, 1}, k = 2
Output: 6
Explanation: All valid subarrays are: {1, 0, 1}, {0, 1, 1}, {1, 1}, {1, 0, 1}, {0, 1, 1, 0}, {1, 1, 0}.

Input: arr[] = {0, 0, 0, 0, 0}, k = 0
Output: 15
Explanation: All subarrays have a sum equal to 0, and there are a total of 15 subarrays.

Try It Yourself
redirect icon

Table of Content

[Naive Approach] Checking Each Subarray - O(n^2) time and O(1) space

Consider each subarray in the array and check if the sum is equal to the target.

C++ 
#include <iostream>
#include <vector>
using namespace std;

int numberOfSubarrays(vector<int>& arr, int k) {

    int ans = 0, n = arr.size();
    
    // Check for each subarray 
    for (int i=0; i<n; i++) {
        
        int sum = 0;
        for (int j=i; j<n; j++) {
            sum += arr[j];
            
            if (sum == k) ans++;
        }
    }
    
    return ans;
}

int main() {
    vector<int> arr = { 1, 0, 1, 1, 0, 1 };
    int k = 2;

    cout << numberOfSubarrays(arr, k) << endl;

    return 0;
}
Java 
class Main {

    static int numberOfSubarrays(int[] arr, int k) {

        int ans = 0, n = arr.length;
        
        // Check for each subarray 
        for (int i = 0; i < n; i++) {
            
            int sum = 0;
            for (int j = i; j < n; j++) {
                sum += arr[j];
                
                if (sum == k) ans++;
            }
        }
        
        return ans;
    }

    public static void main(String[] args) {
        int[] arr = {1, 0, 1, 1, 0, 1};
        int k = 2;

        System.out.println(numberOfSubarrays(arr, k));
    }
}
Python 
def numberOfSubarrays(arr, k):
    ans = 0
    n = len(arr)
    
    # Check for each subarray 
    for i in range(n):
        sum = 0
        for j in range(i, n):
            sum += arr[j]
            
            if sum == k:
                ans += 1
                
    return ans

if __name__ == "__main__":
    arr = [1, 0, 1, 1, 0, 1]
    k = 2

    print(numberOfSubarrays(arr, k))
C# 
using System;

class GfG {

    static int numberOfSubarrays(int[] arr, int k) {

        int ans = 0, n = arr.Length;
        
        // Check for each subarray 
        for (int i = 0; i < n; i++) {
            
            int sum = 0;
            for (int j = i; j < n; j++) {
                sum += arr[j];
                
                if (sum == k) ans++;
            }
        }
        
        return ans;
    }

    static void Main() {
        int[] arr = {1, 0, 1, 1, 0, 1};
        int k = 2;

        Console.WriteLine(numberOfSubarrays(arr, k));
    }
}
JavaScript 
function numberOfSubarrays(arr, k) {
    let ans = 0;
    let n = arr.length;
    
    // Check for each subarray 
    for (let i = 0; i < n; i++) {
        
        let sum = 0;
        for (let j = i; j < n; j++) {
            sum += arr[j];
            
            if (sum === k) ans++;
        }
    }
    
    return ans;
}

let arr = [1, 0, 1, 1, 0, 1];
let k = 2;

console.log(numberOfSubarrays(arr, k));

Output
6

[Expected Approach] Using Sliding Window Approach - O(n) time and O(1) space

  • Use a sliding window with two pointers to count subarrays with sum â‰Ī k and â‰Ī k-1.
  • Expand the window to the right while the sum stays within the target limit.
  • For each position, the number of valid subarrays equals the distance between the two pointers.
  • The final answer is count(â‰Ī k) − count(â‰Ī k−1), which gives subarrays with sum exactly k.
C++ 
#include <iostream>
#include <vector>
using namespace std;

int atmost(vector<int>& arr, int k){
    if (k < 0)
        return 0;
        
    int n = arr.size();
    int res = 0, sum = 0, j = 0;
    
    for (int i=0; i<n; i++) {
        
        while (j < n && sum+arr[j] <= k) {
            sum += arr[j];
            j++;
        }
        
        // Number of sub-arrays starting from
        // index i that have sum atmost k will 
        // be (j-i).
        res += (j - i);
        
        // Remove the i'th index from window.
        sum -= arr[i];
    }
    
    return res;
}

int numberOfSubarrays(vector<int>& arr, int k) {
    return atmost(arr, k) - atmost(arr, k - 1);
}

int main() {
    vector<int> arr = { 1, 0, 1, 1, 0, 1 };
    int k = 2;

    cout << numberOfSubarrays(arr, k) << endl;

    return 0;
}
Java 
import java.util.*;

class GfG {
    
    static int atmost(int[] arr, int k) {
        if (k < 0)
            return 0;

        int n = arr.length;
        int res = 0, sum = 0, j = 0;

        for (int i = 0; i < n; i++) {

            while (j < n && sum + arr[j] <= k) {
                sum += arr[j];
                j++;
            }

            // Number of sub-arrays starting from
            // index i that have sum atmost k will 
            // be (j-i).
            res += (j - i);

            // Remove the i'th index from window.
            sum -= arr[i];
        }

        return res;
    }

    static int numberOfSubarrays(int[] arr, int k) {
        return atmost(arr, k) - atmost(arr, k - 1);
    }

    public static void main(String[] args) {
        int[] arr = {1, 0, 1, 1, 0, 1};
        int k = 2;

        System.out.println(numberOfSubarrays(arr, k));
    }
}
Python 
# Python program to find count of Subarrays 
# with sum equals k in given Binary Array

# Function to find count of subarrays
# with sum at most k
def atmost(arr, k):
    if k < 0:
        return 0

    n = len(arr)
    res, sum_, j = 0, 0, 0

    for i in range(n):

        while j < n and sum_ + arr[j] <= k:
            sum_ += arr[j]
            j += 1

        # Number of sub-arrays starting from
        # index i that have sum atmost k will 
        # be (j-i).
        res += (j - i)

        # Remove the i'th index from window.
        sum_ -= arr[i]

    return res

# Function to find count of subarrays
# with sum equal to k
def numberOfSubarrays(arr, k):

    # Call atmost(arr, k) and atmost
    # (arr, k-1) to get the count of
    # subarrays with sum at most k
    # and sum at most k-1 respectively,
    # then subtract them to get the count
    # of subarrays with sum exactly
    # equal to k
    return atmost(arr, k) - atmost(arr, k - 1)

if __name__ == "__main__":
    arr = [1, 0, 1, 1, 0, 1]
    k = 2

    print(numberOfSubarrays(arr, k))
C# 
using System;

class GfG {

    static int atmost(int[] arr, int k) {
        if (k < 0)
            return 0;

        int n = arr.Length;
        int res = 0, sum = 0, j = 0;

        for (int i = 0; i < n; i++) {

            while (j < n && sum + arr[j] <= k) {
                sum += arr[j];
                j++;
            }

            // Number of sub-arrays starting from
            // index i that have sum atmost k will 
            // be (j-i).
            res += (j - i);

            // Remove the i'th index from window.
            sum -= arr[i];
        }

        return res;
    }

    static int numberOfSubarrays(int[] arr, int k) {

        return atmost(arr, k) - atmost(arr, k - 1);
    }

    static void Main() {
        int[] arr = {1, 0, 1, 1, 0, 1};
        int k = 2;

        Console.WriteLine(numberOfSubarrays(arr, k));
    }
}
JavaScript 
function atmost(arr, k) {
    if (k < 0)
        return 0;

    let n = arr.length;
    let res = 0, sum = 0, j = 0;

    for (let i = 0; i < n; i++) {

        while (j < n && sum + arr[j] <= k) {
            sum += arr[j];
            j++;
        }

        // Number of sub-arrays starting from
        // index i that have sum atmost k will 
        // be (j-i).
        res += (j - i);

        // Remove the i'th index from window.
        sum -= arr[i];
    }

    return res;
}

function numberOfSubarrays(arr, k) {

    return atmost(arr, k) - atmost(arr, k - 1);
}

let arr = [1, 0, 1, 1, 0, 1];
let k = 2;

console.log(numberOfSubarrays(arr, k));

Output
6
Comment
Article Tags:
DSA
Arrays
subarray
sliding-window

Explore