Count pairs from a given range having equal Bitwise OR and XOR values

Given an integer N, the task is to find the count total number of pairs (P, Q) from the range 0 ≤ P, Q < 2^N, such that P OR Q = P XOR Q. Since the count can be very large, print it to modulo 10⁹ + 7.

Examples:

Input: N = 1
Output: 3
Explanation: The pairs (P, Q) satisfying P OR Q = P XOR Q are (0, 0), (0, 1) and (1, 0). Hence output 3.

Input: N = 3
Output: 27

Naive Approach: The simplest approach is to generate all possible pairs (P, Q) and count the pairs satisfying P OR Q = P XOR Q.

Below is the implementation of the above approach:

C++

// C++ program for the above approach

#include <bits/stdc++.h>
#define MOD 1000000007
using namespace std;

// Function to calculate
// (x^y)%MOD
long long int power(int x, int y)
{

    // Initialize result
    long long int res = 1;

    // Update x if it is more than or
    // equal to MOD
    x = x % MOD;

    while (y > 0) {

        // If y is odd, multiply
        // x with result
        if (y & 1)
            res = (res * x) % MOD;

        // y must be even now
        // y = y/2
        y = y >> 1;
        x = (x * x) % MOD;
    }

    // Return (x^y)%MOD
    return res;
}

// Function to count total pairs
void countPairs(int N)
{
    // The upper bound is 2^N
    long long int high = power(2, N);

    // Stores the count of pairs
    int count = 0;

    // Generate all possible pairs
    for (int i = 0; i < high; i++) {
        for (int j = 0; j < high; j++) {

            // Find XOR of both integers
            int X = (i ^ j);

            // Find OR of both integers
            int Y = (i | j);

            // If both are equal
            if (X == Y) {

                // Increment count
                count++;
            }
        }
    }

    // Print count%MOD
    cout << count % MOD << endl;
}

// Driver Code
int main()
{
    int N = 10;

    // Function Call
    countPairs(N);

    return 0;
}

Java

// Java program for the above approach
import java.io.*;
class GFG
{

static int MOD = 1000000007;

// Function to calculate
// (x^y)%MOD
static int power(int x, int y)
{

    // Initialize result
    int res = 1;

    // Update x if it is more than or
    // equal to MOD
    x = x % MOD;
    while (y > 0)
    {

        // If y is odd, multiply
        // x with result
        if ((y & 1) != 0)
            res = (res * x) % MOD;

        // y must be even now
        // y = y/2
        y = y >> 1;
        x = (x * x) % MOD;
    }

    // Return (x^y)%MOD
    return res;
}

// Function to count total pairs
static void countPairs(int N)
{

    // The upper bound is 2^N
    int high = power(2, N);

    // Stores the count of pairs
    int count = 0;

    // Generate all possible pairs
    for (int i = 0; i < high; i++)
    {
        for (int j = 0; j < high; j++)
        {

            // Find XOR of both integers
            int X = (i ^ j);

            // Find OR of both integers
            int Y = (i | j);

            // If both are equal
            if (X == Y)
            {

                // Increment count
                count++;
            }
        }
    }

    // Print count%MOD
    System.out.println(count % MOD);
}

// Driver Code
public static void main(String[] args)
{
    int N = 10;

    // Function Call
    countPairs(N);
}
}

// This code is contributed by susmitakundugoaldanga.

Python3

# Python program for the above approach

# Function to calculate
# (x^y)%MOD
def power(x, y):
    MOD = 1000000007

    # Initialize result
    res = 1

    # Update x if it is more than or
    # equal to MOD
    x = x % MOD
    while (y > 0):

        # If y is odd, multiply
        # x with result
        if (y & 1):
            res = (res * x) % MOD

        # y must be even now
        #  y = y/2
        y = y >> 1
        x = (x * x) % MOD

    # Return (x^y)%MOD
    return res

# Function to count total pairs
def countPairs( N):
    MOD = 1000000007

    # The upper bound is 2^N
    high = power(2, N)

    # Stores the count of pairs
    count = 0

    # Generate all possible pairs
    for i in range(high):
        for j in range(high):

            # Find XOR of both integers
            X = (i ^ j)

            # Find OR of both integers
            Y = (i | j)

            # If both are equal
            if (X == Y):

                # Increment count
                count += 1

    # Print count%MOD
    print(count % MOD)

# Driver Code
N = 10

# Function Call
countPairs(N)

# This code is contributed by rohitsingh07052.

C#

// C# program for the above approach
using System;

class GFG{

  static int MOD = 1000000007;

  // Function to calculate
  // (x^y)%MOD
  static int power(int x, int y)
  {

    // Initialize result
    int res = 1;

    // Update x if it is more than or
    // equal to MOD
    x = x % MOD;
    while (y > 0)
    {

      // If y is odd, multiply
      // x with result
      if ((y & 1) != 0)
        res = (res * x) % MOD;

      // y must be even now
      // y = y/2
      y = y >> 1;
      x = (x * x) % MOD;
    }

    // Return (x^y)%MOD
    return res;
  }

  // Function to count total pairs
  static void countPairs(int N)
  {

    // The upper bound is 2^N
    int high = power(2, N);

    // Stores the count of pairs
    int count = 0;

    // Generate all possible pairs
    for (int i = 0; i < high; i++)
    {
      for (int j = 0; j < high; j++)
      {

        // Find XOR of both integers
        int X = (i ^ j);

        // Find OR of both integers
        int Y = (i | j);

        // If both are equal
        if (X == Y)
        {

          // Increment count
          count++;
        }
      }
    }

    // Print count%MOD
    Console.WriteLine(count % MOD);
  }


  // Driver Code
  static public void Main()
  {
    int N = 10;

    // Function Call
    countPairs(N);
  }
}

// This code is contributed by susmitakundugoaldanga.

Javascript

<script>

// Javascript program for the above approach

     MOD = 1000000007;

    // Function to calculate
    // (x^y)%MOD
    function power(x , y) {

        // Initialize result
        var res = 1;

        // Update x if it is more than or
        // equal to MOD
        x = x % MOD;
        while (y > 0) {

            // If y is odd, multiply
            // x with result
            if ((y & 1) != 0)
                res = (res * x) % MOD;

            // y must be even now
            // y = y/2
            y = y >> 1;
            x = (x * x) % MOD;
        }

        // Return (x^y)%MOD
        return res;
    }

    // Function to count total pairs
    function countPairs(N) {

        // The upper bound is 2^N
        var high = power(2, N);

        // Stores the count of pairs
        var count = 0;

        // Generate all possible pairs
        for (i = 0; i < high; i++) {
            for (j = 0; j < high; j++) {

                // Find XOR of both integers
                var X = (i ^ j);

                // Find OR of both integers
                var Y = (i | j);

                // If both are equal
                if (X == Y) {

                    // Increment count
                    count++;
                }
            }
        }

        // Print count%MOD
        document.write(count % MOD);
    }

    // Driver Code

        var N = 10;

        // Function Call
        countPairs(N);

// This code contributed by Rajput-Ji

</script>

Output:

59049

Time Complexity: O(2^2*N)
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, the idea is based on the following observations:

• Consider the pair as (P, Q). Fix P and then find all the Qs which satisfy this equation. So, all the bits which are set in P will be unset in Q.
• For each unset bit in P, there are two options i.e., the corresponding bits in Q can be 0 or 1.
• So for any P, if the number of unset bits in P is u(P) then the number of Q’s will be ans1 = 2^u(P).
• Iterate over the range [0, N] using the variable i, then for each 2ⁱ will have a contribution of ^NC_i. Let this count be ans2.
• So the count of pairs is given by ∑(ans1*ans2) = (1 + 2)^N = 3^N.

Below is the implementation of the above approach:

C++

// C++ program for the above approach

#include <bits/stdc++.h>
#define MOD 1000000007
using namespace std;

// Function to find the value of (x^y)%MOD
long long int power(int x, int y)
{
    // Initialize result
    long long int res = 1;

    // Update x if it is more than or
    // equal to MOD
    x = x % MOD;

    while (y > 0) {

        // If y is odd, multiply
        // x with result
        if (y & 1)
            res = (res * x) % MOD;

        // y must be even now, then
        // update y/2
        y = y >> 1;
        x = (x * x) % MOD;
    }

    // Return (x^y)%MOD
    return res;
}

// Function to count total pairs
void countPairs(int N)
{
    // Finding 3^N % 10^9+7
    cout << power(3, N);
}

// Driver Code
int main()
{
    int N = 10;

    // Function Call
    countPairs(N);

    return 0;
}

Java

// Java program for the above approach
import java.util.*;

class GFG
{
  static final int MOD = 1000000007;

  // Function to find the value of (x^y)%MOD
  static int power(int x, int y)
  {

    // Initialize result
    int res = 1;

    // Update x if it is more than or
    // equal to MOD
    x = x % MOD;
    while (y > 0)
    {

      // If y is odd, multiply
      // x with result
      if (y % 2== 1)
        res = (res * x) % MOD;

      // y must be even now, then
      // update y/2
      y = y >> 1;
      x = (x * x) % MOD;
    }

    // Return (x^y)%MOD
    return res;
  }

  // Function to count total pairs
  static void countPairs(int N)
  {

    // Finding 3^N % 10^9+7
    System.out.print(power(3, N));
  }

  // Driver Code
  public static void main(String[] args)
  {
    int N = 10;

    // Function Call
    countPairs(N);
  }
}

// This code is contributed by shikhasingrajput

Python3

# Python program for the above approach
MOD = 1000000007;

# Function to find the value of (x^y)%MOD
def power(x, y):

    # Initialize result
    res = 1;

    # Update x if it is more than or
    # equal to MOD
    x = x % MOD;
    while (y > 0):

        # If y is odd, multiply
        # x with result
        if (y % 2 == 1):
            res = (res * x) % MOD;

        # y must be even now, then
        # update y/2
        y = y >> 1;
        x = (x * x) % MOD;

    # Return (x^y)%MOD
    return res;

# Function to count total pairs
def countPairs(N):

    # Finding 3^N % 10^9+7
    print(power(3, N));

# Driver Code
if __name__ == '__main__':
    N = 10;

    # Function Call
    countPairs(N);

# This code is contributed by 29AjayKumar

C#

// C# program for the above approach
using System;
public class GFG
{
  static readonly int MOD = 1000000007;

  // Function to find the value of (x^y)%MOD
  static int power(int x, int y)
  {

    // Initialize result
    int res = 1;

    // Update x if it is more than or
    // equal to MOD
    x = x % MOD;
    while (y > 0)
    {

      // If y is odd, multiply
      // x with result
      if (y % 2== 1)
        res = (res * x) % MOD;

      // y must be even now, then
      // update y/2
      y = y >> 1;
      x = (x * x) % MOD;
    }

    // Return (x^y)%MOD
    return res;
  }

  // Function to count total pairs
  static void countPairs(int N)
  {

    // Finding 3^N % 10^9+7
    Console.Write(power(3, N));
  }

  // Driver Code
  public static void Main(String[] args)
  {
    int N = 10;

    // Function Call
    countPairs(N);
  }
}

// This code contributed by shikhasingrajput

Javascript

<script>

// Javascript program for the above approach
     var MOD = 1000000007;

    // Function to find the value of (x^y)%MOD
    function power(x , y) {

        // Initialize result
        var res = 1;

        // Update x if it is more than or
        // equal to MOD
        x = x % MOD;
        while (y > 0) {

            // If y is odd, multiply
            // x with result
            if (y % 2 == 1)
                res = (res * x) % MOD;

            // y must be even now, then
            // update y/2
            y = y >> 1;
            x = (x * x) % MOD;
        }

        // Return (x^y)%MOD
        return res;
    }

    // Function to count total pairs
    function countPairs(N) {

        // Finding 3^N % 10^9+7
        document.write(power(3, N));
    }

    // Driver Code

        var N = 10;

        // Function Call
        countPairs(N);

// This code contributed by Rajput-Ji

</script>

Output: 

59049

Time Complexity: O(log N) 
Auxiliary Space: O(1)