Skip to content
Related Articles

Related Articles

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

View Discussion
Improve Article
Save Article
Like Article
  • 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 <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




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

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




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

Javascript




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

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!