Skip to content
Related Articles

Related Articles

Save Article
Improve Article
Save Article
Like Article

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

  • Difficulty Level : Hard
  • Last Updated : 14 Sep, 2021

Given two positive integers X and K, the task is to find the Kth 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:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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:
 

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




My Personal Notes arrow_drop_up
Recommended Articles
Page :