Open In App

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

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Share
Report issue
Report

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)



Last Updated : 20 Sep, 2021
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads