GeeksforGeeks App
Open App
Browser
Continue

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