Queries to count array elements from a given range having a single set bit

Last Updated : 15 Nov, 2021

Given an array arr[] consisting of positive integers and an array Q[][] consisting of queries, the task for every i^th query is to count array elements from the range [Q[i][0], Q[i][1]] with only one set bit.

Examples:

Input: arr[] = {12, 11, 16, 8, 2, 5, 1, 3, 256, 1}, queries[][] = {{0, 9}, {4, 9}}
Output: 6 4
Explanation:
In the range of indices [0, 9], the elements arr[2] (= 16), arr[3](= 8), arr[4]( = 2), arr[6](= 1), arr[8](= 256), arr[9](= 1) have only 1 set bit.
In the range [4, 9], the elements arr[4] (= 2), arr[6](= 1), arr[8](= 256), arr[9] (= 1) have only 1 set bit.

Input: arr[] = {2, 1, 101, 11, 4}, queries[][] = {{2, 4}, {1, 4}}
Output: 1 2

Naive Approach: The simplest approach for each query, is to iterate the range [l, r] and count the number of array elements having only one set bit by using Brian Kernighan’s Algorithm.

Time Complexity: O(Q * N*logN)
Auxiliary Space: O(1)

Efficient Approach: Follow the steps below to optimize the above approach:

Initialize a prefix sum array to store the number of elements with only one set bit.
The i-th index stores the count of array elements with only one set bit upto the i^th index.
For each query (i, j), return pre[j] – pre[i – 1], i.e. (inclusion-exclusion principle).

Below is the implementation of the above approach:

C++

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to check whether
// only one bit is set or not
int check(int x)
{
    if (((x) & (x - 1)) == 0)
        return 1;
    return 0;
}
 
// Function to perform Range-query
int query(int l, int r, int pre[])
{
    if (l == 0)
        return pre[r];
    else
        return pre[r] - pre[l - 1];
}
 
// Function to count array elements with a
// single set bit for each range in a query
void countInRange(int arr[], int N,
                  vector<pair<int, int> > queries, int Q)
{
    // Initialize array for Prefix sum
    int pre[N] = { 0 };
    pre[0] = check(arr[0]);
 
    for (int i = 1; i < N; i++) {
        pre[i] = pre[i - 1] + check(arr[i]);
    }
 
    int c = 0;
    while (Q--) {
        int l = queries.first;
        int r = queries.second;
        c++;
        cout << query(l, r, pre) << ' ';
    }
}
 
// Driver Code
int main()
{
    // Given array
    int arr[] = { 12, 11, 16, 8, 2, 5, 1, 3, 256, 1 };
 
    // Size of the array
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Given queries
    vector<pair<int, int> > queries
        = { { 0, 9 }, { 4, 9 } };
 
    // Size of queries array
    int Q = queries.size();
 
    countInRange(arr, N, queries, Q);
 
    return 0;
}

Java

// JAVA program for the above approach 
import java.util.*;
import java.io.*;
import java.math.*;
public class GFG
{
 
  // Function to check whether 
  // only one bit is set or not 
  static int check(int x) 
  { 
    if (((x) & (x - 1)) == 0) 
      return 1; 
 
    return 0; 
  } 
 
  // Function to perform Range-query 
  static int query(int l, int r, int[] pre) 
  { 
    if (l == 0) 
      return pre[r]; 
    else
      return pre[r] - pre[l - 1]; 
  } 
 
  // Function to count array elements with a 
  // single set bit for each range in a query 
  static void countInRange(int[] arr, int N,  ArrayList<Pair> queries,
                           int Q) 
  { 
 
    // Initialize array for Prefix sum 
    int[] pre = new int[N]; 
    pre[0] = check(arr[0]); 
    for(int i = 1; i < N; i++)
    {
      pre[i] = pre[i - 1] + check(arr[i]); 
    }   
    int c = 0; 
    int q = 0;    
    while (q < Q) 
    {
      int l = queries.get(q).item1; 
      int r = queries.get(q).item2; 
      c++; 
      q++;
      System.out.print(query(l, r, pre) + " "); 
    } 
  } 
 
  // A Pair class for handling queries in JAVA 
  // As, there is no in-built function of Tuple
  static class Pair
  {
    int item1, item2;
    Pair(int item1, int item2)
    {
      this.item1 = item1;
      this.item2 = item2;
    }
  } 
 
  // Driver code
  public static void main(String args[]) 
  {
 
    // Given array 
    int[] arr = { 12, 11, 16, 8, 2,
                 5, 1, 3, 256, 1 }; 
 
    // Size of the array 
    int N = arr.length; 
 
    // Given queries 
    ArrayList<Pair> queries = new ArrayList<Pair>();
    queries.add(new Pair(4,9));
    queries.add(new Pair(0,9));
 
    // Size of queries array 
    int Q = queries.size();     
    countInRange(arr, N, queries, Q); 
  }
}
 
// This code is contributed by jyoti369

Python3

# Python 3 program for the above approach
 
# Function to check whether
# only one bit is set or not
def check(x):
    if (((x) & (x - 1)) == 0):
        return 1
    return 0
 
# Function to perform Range-query
def query(l, r, pre):
    if (l == 0):
        return pre[r]
    else:
        return pre[r] - pre[l - 1]
 
# Function to count array elements with a
# single set bit for each range in a query
def countInRange(arr,  N, queries, Q):
 
    # Initialize array for Prefix sum
    pre = [0] * N
    pre[0] = check(arr[0])
    for i in range(1, N):
        pre[i] = pre[i - 1] + check(arr[i])
    c = 0
    while (Q > 0):
        l = queries[0]
        r = queries[1]
        c += 1
        print(query(l, r, pre), end=" ")
        Q -= 1
 
 
# Driver Code
if __name__ == "__main__":
 
    # Given array
    arr = [12, 11, 16, 8, 2, 5, 1, 3, 256, 1]
 
    # Size of the array
    N = len(arr)
 
    # Given queries
    queries = [[0, 9], [4, 9]]
 
    # Size of queries array
    Q = len(queries)
 
    countInRange(arr, N, queries, Q)
 
    # this code is contributed by chitranayal.

C#

// C# program for the above approach 
using System;
using System.Collections.Generic;
 
class GFG{
     
// Function to check whether 
// only one bit is set or not 
static int check(int x) 
{ 
    if (((x) & (x - 1)) == 0) 
        return 1; 
         
    return 0; 
} 
   
// Function to perform Range-query 
static int query(int l, int r, int[] pre) 
{ 
    if (l == 0) 
        return pre[r]; 
    else
        return pre[r] - pre[l - 1]; 
} 
 
// Function to count array elements with a 
// single set bit for each range in a query 
static void countInRange(int[] arr, int N, 
                         List<Tuple<int, int>> queries,
                         int Q) 
{ 
     
    // Initialize array for Prefix sum 
    int[] pre = new int[N]; 
    pre[0] = check(arr[0]); 
   
    for(int i = 1; i < N; i++)
    {
        pre[i] = pre[i - 1] + check(arr[i]); 
    } 
   
    int c = 0; 
    int q = 0;
     
    while (q < Q) 
    {
        int l = queries[q].Item1; 
        int r = queries[q].Item2; 
        c++; 
        q++;
        Console.Write(query(l, r, pre) + " "); 
    } 
} 
 
// Driver code
static void Main() 
{
     
    // Given array 
    int[] arr = { 12, 11, 16, 8, 2,
                  5, 1, 3, 256, 1 }; 
     
    // Size of the array 
    int N = arr.Length; 
     
    // Given queries 
    List<Tuple<int,
               int>> queries = new List<Tuple<int,
                                              int>>();
    queries.Add(new Tuple<int, int>(0, 9));
    queries.Add(new Tuple<int, int>(4, 9));
     
    // Size of queries array 
    int Q = queries.Count; 
     
    countInRange(arr, N, queries, Q); 
}
}
 
// This code is contributed by divyeshrabadiya07

Javascript

<script>
 
// JavaScript program for the above approach
 
 
// Function to check whether
// only one bit is set or not
function check(x)
{
    if (((x) & (x - 1)) == 0)
        return 1;
    return 0;
}
 
// Function to perform Range-query
function query(l, r, pre)
{
    if (l == 0)
        return pre[r];
    else
        return pre[r] - pre[l - 1];
}
 
// Function to count array elements with a
// single set bit for each range in a query
function countInRange(arr, N, queries, Q)
{
    // Initialize array for Prefix sum
    var pre = Array(N).fill(0);
    pre[0] = check(arr[0]);
 
    for (var i = 1; i < N; i++) {
        pre[i] = pre[i - 1] + check(arr[i]);
    }
 
    var c = 0;
    while (Q--) {
        var l = queries[0];
        var r = queries[1];
        c++;
        document.write( query(l, r, pre) + ' ');
    }
}
 
// Driver Code
 
// Given array
var arr = [12, 11, 16, 8, 2, 5, 1, 3, 256, 1];
 
// Size of the array
var N = arr.length;
 
// Given queries
var queries
    = [[0, 9], [4, 9 ]];
     
// Size of queries array
var Q = queries.length;
 
countInRange(arr, N, queries, Q);
 
</script>

Output:

6 4

Time Complexity: O(N*log(max(arr[i])))
Auxiliary Space: O(N)

Check if a graph constructed from an array based on given conditions consists of a cycle or not

prakersh009

Improve

Article Tags :

Practice Tags :

Queries to count array elements from a given range having a single set bit

C++

Java

Python3

C#

Javascript

Similar Reads

Thank You!

What kind of Experience do you want to share?