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

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

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

9

Time complexity: O(log(X))
Auxiliary Space: O(1)