Skip to content
Related Articles

Related Articles

Improve Article

Count of pairs having bit size at most X and Bitwise OR equal to X

  • Last Updated : 30 Apr, 2021

Given a number X, calculate number of possible pairs (a, b) such that bitwise or of a and b is equal to X and number of bits in both a and b is less than equal to number of bits in X.

Examples: 
 

Input: X = 6 
Output: 9 
Explanation: 
The possible pairs of (a, b) are (4, 6), (6, 4), (6, 6), (6, 2), (4, 2), (6, 0), (2, 6), (2, 4), (0, 6).
Input: X = 21 
Output: 27 
Explanation: 
In total there are 27 pairs possible.

Approach: To solve the problem mentioned above follow the steps given below:

  • Iterate through every bit of given number X.
  • If the bit is 1 then from the truth table of Bitwise OR we know that there are 3 combinations possible for that given bit in number a and b that is (0, 1), (1, 0), (1, 1) that is 3 possible ways.
  • If the bit is 0 then from the truth table of Bitwise OR we know that there is only 1 combination possible for that given bit in number a and b that is (0, 0).
  • So our answer will be answer will be 3 ^ (number of on bits in X).

Below is the implementation of above approach:
 



C++




// C++ implementation to Count number of
// possible pairs of (a, b) such that
// their Bitwise OR gives the value X
 
#include <iostream>
using namespace std;
 
// Function to count the pairs
int count_pairs(int x)
{
    // Initializing answer with 1
    int ans = 1;
 
    // Iterating through bits of x
    while (x > 0) {
 
        // check if bit is 1
        if (x % 2 == 1)
 
            // multiplying ans by 3
            // if bit is 1
            ans = ans * 3;
 
        x = x / 2;
    }
    return ans;
}
 
// Driver code
int main()
{
    int X = 6;
 
    cout << count_pairs(X)
         << endl;
 
    return 0;
}
Java



// Java implementation to count number of
// possible pairs of (a, b) such that
// their Bitwise OR gives the value X
class GFG{
 
// Function to count the pairs
static int count_pairs(int x)
{
     
    // Initializing answer with 1
    int ans = 1;
 
    // Iterating through bits of x
    while (x > 0)
    {
         
        // Check if bit is 1
        if (x % 2 == 1)
 
            // Multiplying ans by 3
            // if bit is 1
            ans = ans * 3;
 
        x = x / 2;
    }
    return ans;
}
 
// Driver code
public static void main(String[] args)
{
    int X = 6;
 
    System.out.print(count_pairs(X) + "\n");
}
}
 
// This code is contributed by amal kumar choubey
Python3



# Python3 implementation to count number of
# possible pairs of (a, b) such that
# their Bitwise OR gives the value X
 
# Function to count the pairs
def count_pairs(x):
 
    # Initializing answer with 1
    ans = 1;
 
    # Iterating through bits of x
    while (x > 0):
 
        # Check if bit is 1
        if (x % 2 == 1):
 
            # Multiplying ans by 3
            # if bit is 1
            ans = ans * 3;
 
        x = x // 2;
     
    return ans;
 
# Driver code
if __name__ == '__main__':
     
    X = 6;
 
    print(count_pairs(X));
 
# This code is contributed by amal kumar choubey
C#



// C# implementation to count number of
// possible pairs of (a, b) such that
// their Bitwise OR gives the value X
using System;
class GFG{
 
  // Function to count the pairs
  static int count_pairs(int x)
  {
 
    // Initializing answer with 1
    int ans = 1;
 
    // Iterating through bits of x
    while (x > 0)
    {
 
      // Check if bit is 1
      if (x % 2 == 1)
 
        // Multiplying ans by 3
        // if bit is 1
        ans = ans * 3;
 
      x = x / 2;
    }
    return ans;
  }
 
  // Driver code
  public static void Main(String[] args)
  {
    int X = 6;
 
    Console.Write(count_pairs(X) + "\n");
  }
}
 
// This code is contributed by sapnasingh4991
Javascript



<script>
 
// javascript implementation to count number of
// possible pairs of (a, b) such that
// their Bitwise OR gives the value X   
// Function to count the pairs
    function count_pairs(x) {
 
        // Initializing answer with 1
        var ans = 1;
 
        // Iterating through bits of x
        while (x > 0) {
 
            // Check if bit is 1
            if (x % 2 == 1)
 
                // Multiplying ans by 3
                // if bit is 1
                ans = ans * 3;
 
            x = parseInt(x / 2);
        }
        return ans;
    }
 
    // Driver code
     
        var X = 6;
 
        document.write(count_pairs(X) + "\n");
 
// This code contributed by Rajput-Ji
 
</script>
Output: 
9
 
Time complexity: O(log(X))
 
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.



My Personal Notes
arrow_drop_up
Next

Set, Clear and Toggle a given bit of a number in C
Recommended Articles
Page :
Maximize count of pairs whose Bitwise AND exceeds Bitwise XOR by replacing such pairs with their Bitwise AND
22, Feb 21
Count ways to generate pairs having Bitwise XOR and Bitwise AND equal to X and Y respectively
16, Sep 20
Total pairs in an array such that the bitwise AND, bitwise OR and bitwise XOR of LSB is 1
07, May 19
Count pairs with equal Bitwise AND and Bitwise OR value
29, Oct 20
Minimum bit swaps between given numbers to make their Bitwise OR equal to Bitwise AND
21, Jun 21
Maximize count of pairs whose bitwise XOR is even by replacing such pairs with their Bitwise XOR
22, Feb 21
Non-negative pairs with sum of Bitwise OR and Bitwise AND equal to N
09, Nov 20
Count bases which contains a set bit as the Most Significant Bit in the representation of N
18, Jun 21
Count pairs from a given range having equal Bitwise OR and XOR values
31, Jan 21
Calculate Bitwise OR of two integers from their given Bitwise AND and Bitwise XOR values
02, Dec 20
Count pairs with bitwise XOR exceeding bitwise AND from a given array
04, Oct 20
Count pairs with odd Bitwise XOR that can be removed and replaced by their Bitwise OR
25, Mar 21
Count pairs whose Bitwise AND exceeds Bitwise XOR from a given array
18, Mar 21
Sum of Bitwise AND of sum of pairs and their Bitwise AND from a given array
23, Feb 21
Count of binary strings of length N having equal count of 0's and 1's and count of 1's ≥ count of 0's in each prefix substring
25, Jul 20
Maximize sum of squares of array elements possible by replacing pairs with their Bitwise AND and Bitwise OR
12, Oct 20
Find the triplet from given Bitwise XOR and Bitwise AND values of all its pairs
10, Dec 20
Count of N-size maximum sum Arrays with elements in range [0, 2^K – 1] and Bitwise AND equal to 0
09, Jul 21
Count N-length arrays of made up of elements not exceeding 2^K - 1 having maximum sum and Bitwise AND equal to 0
23, Jul 21
Count of binary strings of length N with even set bit count and at most K consecutive 1s
25, Jun 20
Minimum possible Bitwise OR of all Bitwise AND of pairs generated from two given arrays
17, Sep 20
Bitwise XOR of Bitwise AND of all pairs from two given arrays
06, May 21
Find all possible pairs with given Bitwise OR and Bitwise XOR values
31, May 21
Leftover element after performing alternate Bitwise OR and Bitwise XOR operations on adjacent pairs
01, Apr 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Mayank Rana 1
@Mayank Rana 1
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox