Find all subarray index ranges in given Array with set bit sum equal to X
Last Updated :
23 Jul, 2025
Improve
Given an array arr (1-based indexing) of length N and an integer X, the task is to find and print all index ranges having a set bit sum equal to X in the array.
Examples:
Input: A[] = {1 4 3 5 7}, X = 4
Output: (1, 3), (3, 4)
Explanation: In the above array subarray having set bit sum equal to X (= 4).
Starting from index 1 to 3. {1 4 3} = (001) + (100) + (011) = 4 and
other one is from 3 to 4 {3, 5} = (011) + (101) = 4.Input: arr[] = {5, 3, 0, 4, 10}, X = 7
Output: (1 5)
Explanation: In the above array subarrays having set bit sum equal to X(= 7) start from 1 to 5 only.
Approach: The problem is solved using two pointer approach.
- Write a function countSetBit to count the number of set bits.
- Initialize a counter c=0, to store the individual count for every number in the array.
- Iterate over the array and check for every set bit and increase the counter.
- replace every number with the count of a number of set bits
- Write a function to print a range of subarrays PrintIndex
Run a loop using two pointers i and j and check for the sum as follow:- If the current index sum is less than X then, add the value at arr[j] in currsum
- else if the sum is equal to X push back the start and end index of the array and increment the counter i.
- else decrement the counter, subtract the value at arr[i] from currsum.
- Repeat the same for all elements.
Below is the implementation of the above method :
// C++ program to Find all range
// Having set bit sum X in array
#include <bits/stdc++.h>
using namespace std;
// Function to replace elements
// With their set bit count
void countSetBit(vector<int>& arr, int n)
{
int c = 0, i;
for (i = 0; i < n; i++) {
int x = arr[i];
while (x) {
int l = x % 10;
if (x & 1)
c++;
x /= 2;
}
// Replace array element
// to set bit count
arr[i] = c;
c = 0;
}
}
// Function to find range of subarrays
// having set bit sum equal to X.
void PrintIndex(vector<int> arr, int N, int X,
vector<int>& v)
{
int i = 0, j = 0, currSum = arr[0];
while (j < N && i < N) {
if (currSum == X) {
// push back index i start
// point ans end point j
// when sum == X
v.push_back(i + 1);
v.push_back(j + 1);
j++;
currSum += arr[j];
}
// when current sum is
// less than X increment j
// and add arr[j]
else if (currSum < X) {
j++;
currSum += arr[j];
}
// when current sum is
// greater than X increment j
// and subtract arr[i]
else {
currSum -= arr[i];
i++;
}
}
}
// Driver code
int main()
{
vector<int> v = { 1, 4, 3, 5, 7 };
int X = 4;
int N = v.size();
// replace all the array element into
// their set bit count value
countSetBit(v, N);
vector<int> ans;
PrintIndex(v, N, X, ans);
for (int i = 0; i < ans.size() - 1; i += 2)
cout << "(" << ans[i] << " "
<< ans[i + 1] << ")"
<< " ";
return 0;
}
// JAVA code to implement the above approach
import java.util.*;
class GFG {
// Function to replace elements
// With their set bit count
static void countSetBit(int[] arr, int n)
{
int c = 0, i;
for (i = 0; i < n; i++) {
int x = arr[i];
while (x > 0) {
int l = x % 10;
if ((x & 1) == 1)
c++;
x /= 2;
}
// Replace array element
// to set bit count
arr[i] = c;
c = 0;
}
}
// Function to find range of subarrays
// having set bit sum equal to X.
static void PrintIndex(int[] arr, int N, int X,
ArrayList<Integer> v)
{
int i = 0, j = 0, currSum = arr[0];
while (j < N && i < N) {
if (currSum == X) {
// push back index i start
// point ans end point j
// when sum == X
v.add(i + 1);
v.add(j + 1);
j++;
if (j < N)
currSum += arr[j];
}
// when current sum is
// less than X increment j
// and add arr[j]
else if (currSum < X) {
j++;
if (j < N)
currSum += arr[j];
}
// when current sum is
// greater than X increment j
// and subtract arr[i]
else {
currSum -= arr[i];
i++;
}
}
}
// Driver Code
public static void main(String[] args)
{
int[] v = { 1, 4, 3, 5, 7 };
int X = 4;
int N = v.length;
// replace all the array element into
// their set bit count value
countSetBit(v, N);
ArrayList<Integer> ans = new ArrayList<Integer>();
PrintIndex(v, N, X, ans);
for (int i = 0; i < ans.size() - 1; i += 2)
System.out.print("(" + ans.get(i) + " " + ans.get(i + 1)
+ ")"
+ " ");
}
}
// This code is contributed by sanjoy_62.
# Python program to Find all range
# Having set bit sum X in array
# Function to replace elements
# With their set bit count
def countSetBit(arr, n):
c = 0
for i in range(n):
x = arr[i]
while (x):
l = x % 10
if (x & 1):
c += 1
x = x // 2
# Replace array element
# to set bit count
arr[i] = c
c = 0
# Function to find range of subarrays
# having set bit sum equal to X.
def PrintIndex(arr, N, X, v):
i,j,currSum = 0,0,arr[0]
while (j < N and i < N):
if (currSum == X):
# append back index i start
# point ans end point j
# when sum == X
v.append(i + 1)
v.append(j + 1)
j += 1
if(j<N):
currSum += arr[j]
# when current sum is
# less than X increment j
# and add arr[j]
elif (currSum < X):
j += 1
if(j<N):
currSum += arr[j]
# when current sum is
# greater than X increment j
# and subtract arr[i]
else:
currSum -= arr[i]
i += 1
# Driver code
v = [1, 4, 3, 5, 7]
X = 4
N = len(v)
# replace all the array element into
# their set bit count value
countSetBit(v, N)
ans = []
PrintIndex(v, N, X, ans)
for i in range(0,len(ans) - 1,2):
print(f"({ans[i]} {ans[i + 1]})",end=" ")
# This code is contributed by shinjanpatra
// C# program to Find all range
// Having set bit sum X in array
using System;
using System.Collections;
class GFG {
// Function to replace elements
// With their set bit count
static void countSetBit(int[] arr, int n)
{
int c = 0, i;
for (i = 0; i < n; i++) {
int x = arr[i];
while (x > 0) {
int l = x % 10;
if ((x & 1) == 1)
c++;
x /= 2;
}
// Replace array element
// to set bit count
arr[i] = c;
c = 0;
}
}
// Function to find range of subarrays
// having set bit sum equal to X.
static void PrintIndex(int[] arr, int N, int X,
ArrayList v)
{
int i = 0, j = 0, currSum = arr[0];
while (j < N && i < N) {
if (currSum == X) {
// push back index i start
// point ans end point j
// when sum == X
v.Add(i + 1);
v.Add(j + 1);
j++;
if (j < N)
currSum += arr[j];
}
// when current sum is
// less than X increment j
// and add arr[j]
else if (currSum < X) {
j++;
if (j < N)
currSum += arr[j];
}
// when current sum is
// greater than X increment j
// and subtract arr[i]
else {
currSum -= arr[i];
i++;
}
}
}
// Driver code
public static void Main()
{
int[] v = { 1, 4, 3, 5, 7 };
int X = 4;
int N = v.Length;
// replace all the array element into
// their set bit count value
countSetBit(v, N);
ArrayList ans = new ArrayList();
PrintIndex(v, N, X, ans);
for (int i = 0; i < ans.Count - 1; i += 2)
Console.Write("(" + ans[i] + " " + ans[i + 1]
+ ")"
+ " ");
}
}
// This code is contributed by Samim Hossain Mondal.
<script>
// JavaScript program to Find all range
// Having set bit sum X in array
// Function to replace elements
// With their set bit count
const countSetBit = (arr, n) => {
let c = 0, i;
for (i = 0; i < n; i++) {
let x = arr[i];
while (x) {
let l = x % 10;
if (x & 1)
c++;
x = parseInt(x / 2);
}
// Replace array element
// to set bit count
arr[i] = c;
c = 0;
}
}
// Function to find range of subarrays
// having set bit sum equal to X.
const PrintIndex = (arr, N, X, v) => {
let i = 0, j = 0, currSum = arr[0];
while (j < N && i < N)
{
if (currSum == X)
{
// push back index i start
// point ans end point j
// when sum == X
v.push(i + 1);
v.push(j + 1);
j++;
currSum += arr[j];
}
// when current sum is
// less than X increment j
// and add arr[j]
else if (currSum < X) {
j++;
currSum += arr[j];
}
// when current sum is
// greater than X increment j
// and subtract arr[i]
else {
currSum -= arr[i];
i++;
}
}
}
// Driver code
let v = [1, 4, 3, 5, 7];
let X = 4;
let N = v.length;
// replace all the array element into
// their set bit count value
countSetBit(v, N);
let ans = [];
PrintIndex(v, N, X, ans);
for (let i = 0; i < ans.length - 1; i += 2)
document.write(`(${ans[i]} ${ans[i + 1]}) `);
// This code is contributed by rakeshsahni
</script>
Output
(1 3) (3 4)
Time Complexity: O(N * d) where d is the count of bits in an array element
Auxiliary Space: O(N)
Another Approach:
- The code defines a function called countSetBit that takes an integer x and returns the number of set bits in its binary representation.
- The code also defines another function called printSubarraysWithSetBitSumX that takes a vector of integers arr and an integer X. This function prints all the subarrays of arr whose sum of set bits is equal to X.
- Inside the printSubarraysWithSetBitSumX function, the code initializes some variables: n is the size of the input vector arr, i and j are two pointers initially set to 0, and currSum is the current sum of set bits.
- The code enters a while loop with a condition of j < n. This loop iterates through all the elements of the input vector arr.
- Inside the while loop, the code adds the count of set bits of the current element to the currSum variable and increments j by 1.
- The code then enters another while loop with a condition of currSum > X. This loop removes the set bit count of the element pointed by i from the currSum variable and increments i by 1 until the currSum becomes less than or equal to X.
- If the currSum is equal to X after the above while loop, the code prints the indices of the subarray whose sum of set bits is equal to X.
- The while loop in step 4 continues until j reaches the end of the input vector arr.
- Finally, the main function creates a vector arr containing integers {1, 4, 3, 5, 7} and sets X to 4. It then calls the printSubarraysWithSetBitSumX function with these arguments, which prints "(1, 3) (3, 4)" to the console.
Below is the implementation of the above approach:
#include <iostream>
#include <vector>
using namespace std;
int countSetBit(int x) {
int count = 0;
while (x > 0) {
count += x & 1;
x >>= 1;
}
return count;
}
void printSubarraysWithSetBitSumX(vector<int>& arr, int X) {
int n = arr.size();
int i = 0, j = 0, currSum = 0;
while (j < n) {
currSum += countSetBit(arr[j]);
j++;
while (currSum > X) {
currSum -= countSetBit(arr[i]);
i++;
}
if (currSum == X) {
cout << "(" << i + 1 << ", " << j << ") ";
}
}
}
int main() {
vector<int> arr = {1, 4, 3, 5, 7};
int X = 4;
printSubarraysWithSetBitSumX(arr, X); // prints (1, 3) (3, 4)
return 0;
}
import java.util.*;
public class SubarraysWithSetBitSum {
public static int countSetBit(int x) {
int count = 0;
while (x > 0) {
count += x & 1;
x >>= 1;
}
return count;
}
public static void printSubarraysWithSetBitSumX(ArrayList<Integer> arr, int X) {
int n = arr.size();
int i = 0, j = 0, currSum = 0;
while (j < n) {
currSum += countSetBit(arr.get(j));
j++;
while (currSum > X) {
currSum -= countSetBit(arr.get(i));
i++;
}
if (currSum == X) {
System.out.print("(" + (i + 1) + ", " + j + ") ");
}
}
}
public static void main(String[] args) {
ArrayList<Integer> arr = new ArrayList<Integer>(Arrays.asList(1, 4, 3, 5, 7));
int X = 4;
printSubarraysWithSetBitSumX(arr, X); // prints (1, 3) (3, 4)
}
}
def count_set_bits(x):
# Function to count the number of set bits (1s) in a binary representation of 'x'
count = 0
while x > 0:
count += x & 1 # Add the least significant bit of 'x' to the count
x >>= 1 # Right shift 'x' to check the next bit
return count
def print_subarrays_with_set_bit_sum_x(arr, X):
n = len(arr) # Get the length of the input array 'arr'
i, j, curr_sum = 0, 0, 0 # Initialize variables for subarray tracking
while j < n: # Iterate through the array using a sliding window (j moves forward)
curr_sum += count_set_bits(arr[j]) # Add the count of set bits in 'arr[j]' to 'curr_sum'
j += 1
while curr_sum > X: # If 'curr_sum' exceeds the target 'X', move the window's left end (i) forward
curr_sum -= count_set_bits(arr[i]) # Subtract the count of set bits in 'arr[i]' from 'curr_sum'
i += 1
if curr_sum == X: # If 'curr_sum' matches the target 'X', print the subarray
print(f"({i + 1}, {j}) ", end='')
# Main function
if __name__ == "__main__":
arr = [1, 4, 3, 5, 7] # Input array
X = 4 # Target sum of set bits
print_subarrays_with_set_bit_sum_x(arr, X) # Call the function to find and print subarrays with the target sum
using System;
using System.Collections.Generic;
public class SubarraysWithSetBitSum {
// Function to count the number of set bits in a number
public static int CountSetBit(int x) {
int count = 0;
while (x > 0) {
count += x & 1; // Increment count if the last bit is 1
x >>= 1; // Right shift the number to check the next bit
}
return count;
}
// Function to find and print subarrays with a given set bit sum
public static void PrintSubarraysWithSetBitSumX(List<int> arr, int X) {
int n = arr.Count;
int i = 0, j = 0, currSum = 0;
while (j < n) {
currSum += CountSetBit(arr[j]); // Calculate set bit sum for the current element
j++;
// Slide the window to the right while current set bit sum is greater than X
while (currSum > X) {
currSum -= CountSetBit(arr[i]); // Remove set bit count of the left element
i++;
}
// If the current set bit sum matches X, print the subarray indices
if (currSum == X) {
Console.Write("(" + (i + 1) + ", " + j + ") ");
}
}
}
public static void Main(string[] args) {
List<int> arr = new List<int> { 1, 4, 3, 5, 7 };
int X = 4;
PrintSubarraysWithSetBitSumX(arr, X); // prints (1, 3) (3, 4)
}
}
function countSetBit(x) {
let count = 0;
while (x > 0) {
count += x & 1;
x >>= 1;
}
return count;
}
function printSubarraysWithSetBitSumX(arr, X) {
const n = arr.length;
let i = 0, j = 0, currSum = 0;
while (j < n) {
currSum += countSetBit(arr[j]);
j++;
while (currSum > X) {
currSum -= countSetBit(arr[i]);
i++;
}
if (currSum === X) {
console.log(`(${i + 1}, ${j})`);
}
}
}
const arr = [1, 4, 3, 5, 7];
const X = 4;
printSubarraysWithSetBitSumX(arr, X); // prints (1, 3) (3, 4)
Output
(1, 3) (3, 4)
Time complexity: O(n*logx)
Auxiliary Space: O(n)
