K-th smallest positive integer having sum with given number equal to bitwise OR with given number

Given two positive integers X and K, the task is to find the K-th smallest positive integer Y, such that X + Y = X | Y, where | denotes the bitwise OR operation.

Example:

Input: X = 5, K = 1
Output: 2
Explanation: The first number is 2 as (2 + 5 = 2 | 5 )

Input: X = 5, K = 5
Output: 18
Explanation: The list of correct values is 2, 8, 10, 16, 18. The 5th number is this list is 18

Approach: Given problem can be solved following the below mentioned steps:

• Let the final value be Y. From the properties of bitwise operations, it is known that X + Y = X & Y + X | Y, where & is a bitwise AND of two numbers
• For the equation in the problem statement to be true, the value of X & Y must be 0
• So for all positions, if the ith bit is ON in X then it must be OFF for all possible solutions of Y
• For instance, if X = 1001101001 in binary (617 in decimal notation), then the last ten digits of y must be Y= 0**00*0**0, where ‘*’ denotes either zero or one. Also, we can pad any number of any digits to the beginning of the number, since all higher bits are zeroes
• So the final solution will be to treat all the positions where the bit can be 0 or 1 as a sequence from left to right and find the binary notation of K.
• Fill all positions according to the binary notation of K

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 = 5, K = 5;
    cout << KthSolution(X, K);
    return 0;
}

Java

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

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 = 5, K = 5;
        System.out.println(KthSolution(X, K));
    }
}

// This code is contributed by sanjoy_62.

Python3

# python implementation for 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(0, 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
if __name__ == "__main__":

    X = 5
    K = 5
    print(KthSolution(X, K))

    # This code is contributed by rakeshsahni

C#

// C# implementation for the above approach
using System;
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 & (1LL << i)) == 0) {

                // The i-bit of K is on
                if ((K & 1) > 0) {
                    ans |= (1LL << 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()
    {
        long X = 5, K = 5;
        Console.Write(KthSolution(X, K));
    }
}

// This code is contributed by ukasp.

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 = 5, K = 5;
        document.write(KthSolution(X, K));

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

Output

18

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