# Count number of set bits in a range using bitset

• Last Updated : 04 Jul, 2022

Given a large binary number.The task is to count the number of 1’s in a given range from L to R (1 based indexing).
Examples:

Input : s = “101101011010100000111”, L = 6, R = 15
Output :
s [L : R] = “1011010100”
There is only 5 set bits.
Input : s = “10110”, L = 2, R = 5
Output :

Approach:

• Convert the string of size len to the bitset of size N.
• There is no need of (N – len) + (L – 1) bits in the left side and (N – R) bits in the right side of the bitset .
• Remove those bits efficiently using left and right shift bitwise operation.
• Now there are all zeroes in the left side of L and right side of R, so just use count() function to get the count of 1’s in the bitset as all positions except [L, R] are ‘0’.

Below is the implementation of above approach:

## C++

 `// C++ implementation of above approach` `#include ` `using` `namespace` `std;` `#define N 32`   `// C++ function to count ` `// number of 1's using bitset` `int` `GetOne(string s, ``int` `L, ``int` `R)` `{`   `    ``int` `len = s.length();`   `    ``// Converting the string into bitset` `    ``bitset bit(s);`   `    ``// Bitwise operations` `    ``// Left shift` `    ``bit <<= (N - len + L - 1);`   `    ``// Right shifts` `    ``bit >>= (N - len + L - 1);` `    ``bit >>= (len - R);`   `    ``// Now bit has only those bits` `    ``// which are in range [L, R]`   `    ``// return count of one in [L, R]` `    ``return` `bit.count();` `}`   `// Driver code` `int` `main()` `{`   `    ``string s = ``"01010001011"``;`   `    ``int` `L = 2, R = 4;`   `    ``cout << GetOne(s, L, R);`   `    ``return` `0;` `}`

## Python3

 `# Python3 implementation of above approach `   `N ``=` `32`   `# function for converting binary` `# string into integer value` `def` `binStrToInt(binary_str):` `    ``length ``=` `len``(binary_str)` `    ``num ``=` `0` `    ``for` `i ``in` `range``(length):` `        ``num ``=` `num ``+` `int``(binary_str[i])` `        ``num ``=` `num ``*` `2` `    ``return` `num ``/` `2`     `# function to count ` `# number of 1's using bitset ` `def` `GetOne(s, L, R) : `   `    ``length ``=` `len``(s); `   `    ``# Converting the string into bitset ` `    ``bit ``=` `s.zfill(``32``-``len``(s));` `    `  `    ``bit ``=` `int``(binStrToInt(bit))`   `    ``# Bitwise operations ` `    ``# Left shift ` `    ``bit <<``=` `(N ``-` `length ``+` `L ``-` `1``); `   `    ``# Right shifts ` `    ``bit >>``=` `(N ``-` `length ``+` `L ``-` `1``); ` `    ``bit >>``=` `(length ``-` `R); `   `    ``# Now bit has only those bits ` `    ``# which are in range [L, R] `   `    ``# return count of one in [L, R] ` `    ``return` `bin``(bit).count(``'1'``); `     `# Driver code ` `if` `__name__ ``=``=` `"__main__"` `: `   `    ``s ``=` `"01010001011"``; `   `    ``L ``=` `2``; R ``=` `4``; `   `    ``print``(GetOne(s, L, R)); ` `    `  `# This code is contributed by AnkitRai01`

## C#

 `// C# implementation of above approach` `using` `System;` `using` `System.Linq;`   `class` `GFG {` `  ``static` `int` `N = 32;`   `  ``// C# function to count` `  ``// number of 1's using bit string` `  ``static` `int` `GetOne(``string` `s, ``int` `L, ``int` `R)` `  ``{`   `    ``int` `len = s.Length;`   `    ``// Converting s to an N bit representation` `    ``s = s.PadLeft(N, ``'0'``);`   `    ``// Extracting bits of the range [L, R]` `    ``string` `bit = s.Substring(N - R, R - L + 1);`   `    ``// Now bit has only those bits` `    ``// which are in range [L, R]`   `    ``// return count of one in [L, R]` `    ``return` `bit.Count(f => (f == ``'1'``));` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `Main(``string``[] args)` `  ``{`   `    ``string` `s = ``"01010001011"``;`   `    ``int` `L = 2, R = 4;`   `    ``// Function Call` `    ``Console.WriteLine(GetOne(s, L, R));` `  ``}` `}`   `// This code is contributed by phasing17`

## Javascript

 `// JavaScript implementation of above approach`   `var` `N = 32;`   `// function for converting binary` `// string into integer value` `function` `binStrToInt(binary_str)` `{` `    ``var` `length = binary_str.length;` `    ``var` `num = 0;` `    ``for` `(``var` `i = 0; i < length; i++) {` `        ``num = num + parseInt(binary_str[i]);` `        ``num = num * 2;` `    ``}` `    ``return` `num / 2;` `}`   `// function to count` `// number of 1's using bitset` `function` `GetOne(s, L, R)` `{`   `    ``var` `length = s.length;`   `    ``// Converting the string into bitset` `    ``var` `bit = ``"0"` `* (32 - length) + s;`   `    ``bit = parseInt(binStrToInt(bit));`   `    ``// Bitwise operations` `    ``// Left shift` `    ``bit <<= (N - length + L - 1);`   `    ``// Right shifts` `    ``bit >>= (N - length + L - 1);` `    ``bit >>= (length - R);`   `    ``// Now bit has only those bits` `    ``// which are in range [L, R]`   `    ``// return count of one in [L, R]` `    ``return` `bit.toString(2).split(``"1"``).length - 1;` `}`   `var` `s = ``"01010001011"``;`   `var` `L = 2;` `var` `R = 4;`   `console.log(GetOne(s, L, R));`     `//This code is contributed by phasing17`

Output:

`2`

Time Complexity: O(len)

Auxiliary Space: O(len)

My Personal Notes arrow_drop_up
Recommended Articles
Page :