Kth smallest positive integer Y such that its sum with X is same as its bitwise OR with X

Given two positive integers X and K, the task is to find the K^th smallest positive integer (Y) such that the sum of X and Y is equal to Bitwise OR of X and Y, i.e. (X + Y = X | Y)

Examples:

Input: X = 5, K = 1
Output: 2
Explanation:
Consider the smallest number as 2. The sum of 2 and 5 is 2 + 5 = 7 and the Bitwise OR of 2 and 5 is 7.

Input: X = 5, K = 5
Output: 18

Approach: The given problem can be solved by below observation:

• Using the properties of bitwise operator on two numbers X and Y:
  

(X + Y) = (X & Y) + (X | Y) 

• Therefore, for the value of X + Y to be same as X | Y, the value of X & Y must be 0. 
  
• Also, we know that for X & Y to be 0, the position of set bits in X must be unset in Y, and the positions of unset bits of X can be either 0 or 1 in Y.
  
• Hence, to find Kth smallest positive number meeting above conditions, we can use combinations for the bit positions of Y that are unset in X.

To implement the above, iterate the binary representation of X from right to left, and at every iteration, consider the following cases:

• If the current bit of X is 1, the corresponding bit in Y will be 0, to get (X & Y) as 0.
• If the current bit of X is 0 and rightmost bit of K is 1, the corresponding bit of Y will be 1. This means that two combinations at current bit in Y has been used – first 0 and then 1. Then divide K by 2
• If the current bit of X is 0 and rightmost bit of K is 0, the corresponding bit of Y will be 0. This means that only one combination at current bit in Y has been used – 0. Then divide K by 2
• If K becomes 0, break the loop, stating that the Kth number has been found.

Finally, print the decimal conversion of Y as the required answer.

Below is the implementation of the above approach:

C++

// C++ implementation for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to calculate K-th smallest
// solution(Y) of equation X+Y = X|Y
long long KthSolution(long long X,
                      long long K)
{
    // Initialize the variable
      // to store the answer
    long long ans = 0;

    for (int i = 0; i < 64; i++) {

        // The i-th bit of X is off
        if (!(X & (1LL << i))) {

            // The i-bit of K is on
            if (K & 1) {
                ans |= (1LL << i);
            }

            // Divide K by 2
            K >>= 1;

            // If K becomes 0 then break
            if (!K) {
                break;
            }
        }
    }
    return ans;
}
// Driver Code
int main()
{
    long long X = 10, K = 5;
    cout << KthSolution(X, K);
    return 0;
}

Java

/*package whatever //do not write package name here */
import java.io.*;

class GFG
{

    // Function to calculate K-th smallest
    // solution(Y) of equation X+Y = X|Y
   static long KthSolution(long X, long K)
    {

        // Initialize the variable
        // to store the answer
        long ans = 0;

        for (int i = 0; i < 64; i++) {

            // The i-th bit of X is off
            if ((X & (1 << i)) == 0) {

                // The i-bit of K is on
                if ((K & 1) > 0) {
                    ans |= (1 << i);
                }

                // Divide K by 2
                K >>= 1;

                // If K becomes 0 then break
                if (K == 0) {
                    break;
                }
            }
        }
        return ans;
    }

    // Driver Code
    public static void main(String[] args)
    {
        long X = 10;
        long K = 5;
        System.out.println(KthSolution(X, K));
    }
}

// This code is contributed by maddler.

Python3

# Python Program to implement
# the above approach

# Function to calculate K-th smallest
# solution(Y) of equation X+Y = X|Y
def KthSolution(X, K):

    # Initialize the variable
    # to store the answer
    ans = 0

    for i in range(64):

        # The i-th bit of X is off
        if not (X & (1 << i)):

            # The i-bit of K is on
            if (K & 1):
                ans |= (1 << i)


            # Divide K by 2
            K >>= 1

            # If K becomes 0 then break
            if not K:
                break

    return ans

# Driver Code
X = 10
K = 5
print(KthSolution(X, K))

# This code is contributed by Saurabh Jaiswal

C#

/*package whatever //do not write package name here */
using System;

public class GFG
{

    // Function to calculate K-th smallest
    // solution(Y) of equation X+Y = X|Y
   static long KthSolution(long X, long K)
    {

        // Initialize the variable
        // to store the answer
        int ans = 0;

        for (int i = 0; i < 64; i++) {

            // The i-th bit of X is off
            if ((X & (1 << i)) == 0) {

                // The i-bit of K is on
                if ((K & 1) > 0) {
                    ans |= (1 << i);
                }

                // Divide K by 2
                K >>= 1;

                // If K becomes 0 then break
                if (K == 0) {
                    break;
                }
            }
        }
        return ans;
    }

    // Driver Code
    public static void Main(String[] args)
    {
        long X = 10;
        long K = 5;
        Console.WriteLine(KthSolution(X, K));
    }
}

// This code is contributed by Princi Singh

Javascript

    <script>
        // JavaScript Program to implement
        // the above approach


// Function to calculate K-th smallest
// solution(Y) of equation X+Y = X|Y
function KthSolution(X,K)
{
    // Initialize the variable
      // to store the answer
    let ans = 0;

    for (let i = 0; i < 64; i++) {

        // The i-th bit of X is off
        if (!(X & (1 << i))) {

            // The i-bit of K is on
            if (K & 1) {
                ans |= (1 << i);
            }

            // Divide K by 2
            K >>= 1;

            // If K becomes 0 then break
            if (!K) {
                break;
            }
        }
    }
    return ans;
}
// Driver Code

    let X = 10, K = 5;
    document.write(KthSolution(X, K));

// This code is contributed by Potta Lokesh
    </script>

Output:

17

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