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

• Last Updated : 20 Sep, 2021

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:

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

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

 ``

Output

`18`

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :