# 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:

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 ` `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

 `    ```

Output:

`17`

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :