 Open in App
Not now

# Find all subarray index ranges in given Array with set bit sum equal to X

• Difficulty Level : Medium
• Last Updated : 26 Apr, 2022

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++

 `// C++ program to Find all range` `// Having set bit sum X  in array` `#include ` `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;` `    ``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

 `// 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 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 ans = ``new`  `ArrayList();`   `    ``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.`

## Python3

 `# 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

## C#

 `// 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;` `    ``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.`

## Javascript

 ``

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)

My Personal Notes arrow_drop_up
Related Articles