Remove All Duplicates from a Given String in Python

Count set bits in a range

Last Updated : 15 Jul, 2022

Given a non-negative number n and two values l and r. The problem is to count the number of set bits in the range l to r in the binary representation of n, i.e, to count set bits from the rightmost lth bit to the rightmost rth bit.
Constraint: 1 <= l <= r <= number of bits in the binary representation of n.
Examples:

Input : n = 42, l = 2, r = 5
Output : 2
(42)₁₀ = (101010)₂
There are '2' set bits in the range 2 to 5.

Input : n = 79, l = 1, r = 4
Output : 4

Approach: Following are the steps:

Calculate num = ((1 << r) – 1) ^ ((1 << (l-1)) – 1). This will produce a number num having r number of bits and bits in the range l to r are the only set bits.
Count number of set bits in the number (n & num). Refer this post.

C++

// C++ implementation to count set bits in the 
// given range 
#include <bits/stdc++.h> 
  
using namespace std; 
  
// Function to get no of set bits in the 
// binary representation of 'n' 
unsigned int countSetBits(int n) 
{ 
    unsigned int count = 0; 
    while (n) { 
        n &= (n - 1); 
        count++; 
    } 
    return count; 
} 
  
// function to count set bits in the given range 
unsigned int countSetBitsInGivenRange(unsigned int n, 
                       unsigned int l, unsigned int r) 
{ 
    // calculating a number 'num' having 'r' number 
    // of bits and bits in the range l to r are the  
    // only set bits 
    int num = ((1 << r) - 1) ^ ((1 << (l - 1)) - 1); 
  
    // returns number of set bits in the range 
    // 'l' to 'r' in 'n' 
    return countSetBits(n & num); 
} 
  
// Driver program to test above 
int main() 
{ 
    unsigned int n = 42; 
    unsigned int l = 2, r = 5; 
    cout << countSetBitsInGivenRange(n, l, r); 
    return 0; 
} 

Java

// Java implementation to count set bits in the 
// given range 
class GFG { 
      
    // Function to get no of set bits in the 
    // binary representation of 'n' 
    static int countSetBits(int n) 
    { 
        int count = 0; 
        while (n > 0) { 
            n &= (n - 1); 
            count++; 
        } 
          
        return count; 
    } 
  
    // function to count set bits in the given range 
    static int countSetBitsInGivenRange(int n, int l, int r) 
    { 
          
        // calculating a number 'num' having 'r' number 
        // of bits and bits in the range l to r are the 
        // only set bits 
        int num = ((1 << r) - 1) ^ ((1 << (l - 1)) - 1); 
  
        // returns number of set bits in the range 
        // 'l' to 'r' in 'n' 
        return countSetBits(n & num); 
    } 
      
    // Driver code 
    public static void main(String[] args) 
    { 
        int n = 42; 
        int l = 2, r = 5; 
          
        System.out.print(countSetBitsInGivenRange(n, l, r)); 
    } 
} 
  
// This code is contributed by Anant Agarwal. 

Python3

# Python3 implementation to count 
# set bits in the given range 
  
# Function to get no of set bits in the 
# binary representation of 'n' 
def countSetBits(n): 
    count = 0
    while (n): 
        n &= (n - 1) 
        count = count + 1
      
    return count 
   
# function to count set bits in 
# the given range 
def countSetBitsInGivenRange(n, l,  r): 
  
    # calculating a number 'num' having 
    # 'r' number of bits and bits in the 
    # range l to r are the  only set bits 
    num = ((1 << r) - 1) ^ ((1 << (l - 1)) - 1) 
   
    # returns number of set bits in the range 
    # 'l' to 'r' in 'n' 
    return countSetBits(n & num) 
  
# Driver program to test above 
n = 42
l = 2
r = 5
ans = countSetBitsInGivenRange(n, l, r) 
print (ans) 
  
# This code is contributed by Saloni Gupta. 

C#

// C# implementation to count set bits in the 
// given range 
using System; 
  
class GFG { 
      
    // Function to get no of set bits in the 
    // binary representation of 'n' 
    static int countSetBits(int n) 
    { 
        int count = 0; 
          
        while (n>0) { 
            n &= (n - 1); 
            count++; 
        } 
          
        return count; 
    } 
       
    // function to count set bits in the given range 
    static int countSetBitsInGivenRange(int n, 
                                       int l, int r) 
    { 
          
        // calculating a number 'num' having 'r' number 
        // of bits and bits in the range l to r are the  
        // only set bits 
        int num = ((1 << r) - 1) ^ ((1 << (l - 1)) - 1); 
       
        // returns number of set bits in the range 
        // 'l' to 'r' in 'n' 
        return countSetBits(n & num); 
    } 
      
    //Driver code 
    public static void Main() 
    { 
        int n = 42; 
        int l = 2, r = 5; 
          
        Console.WriteLine(countSetBitsInGivenRange(n, l, r)); 
    } 
} 
  
// This code is contributed by Anant Agarwal. 

PHP

<?php 
// PHP implementation to count 
// set bits in the given range 
  
// Function to get no of set bits in  
// the binary representation of 'n' 
function countSetBits($n) 
{ 
    $count = 0; 
    while ($n) 
    { 
        $n &= ($n - 1); 
        $count++; 
    } 
    return $count; 
} 
  
// function to count set  
// bits in the given range 
function countSetBitsInGivenRange($n, $l, $r) 
{ 
      
    // calculating a number 'num' 
    // having 'r' number of bits 
    // and bits in the range l to 
    // r are the only set bits 
    $num = ((1 << $r) - 1) ^  
           ((1 << ($l - 1)) - 1); 
  
    // returns number of  
    // set bits in the range 
    // 'l' to 'r' in 'n' 
    return countSetBits($n & $num); 
} 
  
    // Driver Code 
    $n = 42; 
    $l = 2; 
    $r = 5; 
    echo countSetBitsInGivenRange($n, $l, $r); 
  
// This code is contributed by Ajit. 
?> 

Javascript

<script> 
  
// Javascript implementation to  
// count set bits in the 
// given range 
  
 // Function to get no of set bits in the 
    // binary representation of 'n' 
    function countSetBits(n) 
    { 
        let count = 0; 
        while (n > 0) { 
            n &= (n - 1); 
            count++; 
        } 
            
        return count; 
    } 
    
    // function to count set  
    // bits in the given range 
    function countSetBitsInGivenRange(n, l, r) 
    { 
            
        // calculating a number 'num'  
        // having 'r' number 
        // of bits and bits in the  
        // range l to r are the 
        // only set bits 
        let num = ((1 << r) - 1) ^  
                   ((1 << (l - 1)) - 1); 
    
        // returns number of set  
        // bits in the range 
        // 'l' to 'r' in 'n' 
        return countSetBits(n & num); 
    } 
  
// driver program  
  
        let n = 42; 
        let l = 2, r = 5; 
            
     document.write(countSetBitsInGivenRange(n, l, r)); 
    
</script> 

Output:

Time Complexity: O(logn)

Auxiliary Space: O(1)

Remove All Duplicates from a Given String in Python

GeeksforGeeks

Improve

Article Tags :

Practice Tags :

Bit Magic

Similar Reads

Count unset bits in a range

Given a non-negative number n and two values l and r. The problem is to count the number of unset bits in the range l to r in the binary representation of n, i.e, to count unset bits from the rightmost lth bit to the rightmost rth bit.Examples: Input : n = 42, l = 2, r = 5 Output : 2 (42)10 = (10101

Copy set bits in a range

Given two numbers x and y, and a range [l, r] where 1 <= l, r <= 32. The task is consider set bits of y in range [l, r] and set these bits in x also.Examples : Input : x = 10, y = 13, l = 2, r = 3 Output : x = 14 Binary representation of 10 is 1010 and that of y is 1101. There is one set bit i

Python | Count set bits in a range

Given a non-negative number n and two values l and r. The problem is to count the number of set bits in the range l to r in the binary representation of n, i.e, to count set bits from the rightmost lth bit to the rightmost rth bit. Constraint: 1 <= l <= r <= number of bits in the binary rep

Count set bits in an integer

Write an efficient program to count the number of 1s in the binary representation of an integer.Examples : Input : n = 6Output : 2Binary representation of 6 is 110 and has 2 set bits Input : n = 13Output : 3Binary representation of 13 is 1101 and has 3 set bits [Naive Approach] - One by One Counting

Python | Count unset bits in a range

Given a non-negative number n and two values l and r. The problem is to count the number of unset bits in the range l to r in the binary representation of n, i.e, to count unset bits from the rightmost lth bit to the rightmost rth bit. Examples: Input : n = 42, l = 2, r = 5 Output : 2 (42)10 = (1010

Count total bits in a number

Given a positive number n, count total bit in it.Examples: Input : 13 Output : 4 Binary representation of 13 is 1101 Input : 183 Output : 8 Input : 4096 Output : 13 Method 1 (Using Log) The log2(n) logarithm in base 2 of n, which is the exponent to which 2 is raised to get n only integer and we add

Range query for count of set bits

Given an array of positive integer and q query which contains two integers, L & R. Task is to find the number of set bits for a given range. Prerequisite : Bitwise Hacks Examples : Input : Arr[] = { 1, 5, 6, 10, 9, 4 } Query : 2 L & R 1 5 2 4 Output : 9 6 Input : Arr[] = { 1, 10, 5, 2, 8, 11

Count unset bits of a number

Given a number n, count unset bits after MSB (Most Significant Bit).Examples : Input : 17 Output : 3 Binary of 17 is 10001 so unset bit is 3 Input : 7 Output : 0 A Simple Solution is to traverse through all bits and count unset bits. C/C++ Code // C++ program to count unset bits in an integer #inclu

Unset bits in the given range

Given a non-negative number n and two values l and r. The problem is to unset the bits in the range l to r in the binary representation of n, i.e, to unset bits from the rightmost lth bit to the rightmost rth bit.Constraint: 1 <= l <= r <= number of bits in the binary representation of n.Ex

Count number of set bits in a range using bitset

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 : 5 s [L : R] = "1011010100" There is only 5 set bits.Input : s = "10110", L = 2, R = 5 Output : 2 Approach: Convert