# Smallest number exceeding N whose Kth bit is set

Given two integers N and K, the task is to find the smallest number greater than N whose Kth bit in its binary representation is set.

Examples:

Input: N = 15, K = 2
Output: 20
Explanation:
The binary representation of (20)10 is (10100)2. The 2nd bit(0-based indexing) from left is set in (20)10. Therefore, 20 is the smallest number greater than 15 having 2nd bit set.

Input: N = 16, K = 3
Output: 24

Naive Approach: The simplest approach is to traverse all numbers starting from N + 1 and for each number, check if its Kth bit is set or not. If such a number is found, then print that number.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include "bits/stdc++.h"` `using` `namespace` `std;`   `// Function to find the number greater` `// than n whose Kth bit is set` `int` `find_next(``int` `n, ``int` `k)` `{` `    ``// Iterate from N + 1` `    ``int` `M = n + 1;`   `    ``while` `(1) {`   `        ``// Check if Kth bit is` `        ``// set or not` `        ``if` `(M & (1ll << k))` `            ``break``;`   `        ``// Increment M for next number` `        ``M++;` `    ``}`   `    ``// Return the minimum value` `    ``return` `M;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given N and K` `    ``int` `N = 15, K = 2;`   `    ``// Function Call` `    ``cout << find_next(N, K);`   `    ``return` `0;` `}`

## Java

 `// Java program for ` `// the above approach` `import` `java.util.*;` `class` `GFG{`   `// Function to find the number greater` `// than n whose Kth bit is set` `static` `int` `find_next(``int` `n, ``int` `k)` `{` `  ``// Iterate from N + 1` `  ``int` `M = n + ``1``;`   `  ``while` `(``true``) ` `  ``{` `    ``// Check if Kth bit is` `    ``// set or not` `    ``if` `((M & (1L << k)) > ``0``)` `      ``break``;`   `    ``// Increment M for ` `    ``// next number` `    ``M++;` `  ``}`   `  ``// Return the minimum value` `  ``return` `M;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `  ``// Given N and K` `  ``int` `N = ``15``, K = ``2``;`   `  ``// Function Call` `  ``System.out.print(find_next(N, K));` `}` `}`   `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program for` `# the above approach`   `# Function to find the number ` `# greater than n whose Kth ` `# bit is set` `def` `find_next(n, k):` `  `  `    ``# Iterate from N + 1` `    ``M ``=` `n ``+` `1``;`   `    ``while` `(``True``):` `      `  `        ``# Check if Kth bit is` `        ``# set or not` `        ``if` `((M & (``1` `<< k)) > ``0``):` `            ``break``;`   `        ``# Increment M for` `        ``# next number` `        ``M ``+``=` `1``;`   `    ``# Return the ` `    ``# minimum value` `    ``return` `M;`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `  `  `    ``# Given N and K` `    ``N ``=` `15``; K ``=` `2``;`   `    ``# Function Call` `    ``print``(find_next(N, K));`   `# This code is contributed by Rajput-Ji`

## C#

 `// C# program for ` `// the above approach` `using` `System;` `class` `GFG{`   `// Function to find the ` `// number greater than n ` `// whose Kth bit is set` `static` `int` `find_next(``int` `n, ``int` `k)` `{` `  ``// Iterate from N + 1` `  ``int` `M = n + 1;`   `  ``while` `(``true``) ` `  ``{` `    ``// Check if Kth bit is` `    ``// set or not` `    ``if` `((M & (1L << k)) > 0)` `      ``break``;`   `    ``// Increment M for ` `    ``// next number` `    ``M++;` `  ``}`   `  ``// Return the minimum value` `  ``return` `M;` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `  ``// Given N and K` `  ``int` `N = 15, K = 2;`   `  ``// Function Call` `  ``Console.Write(find_next(N, K));` `}` `}`   `// This code is contributed by Rajput-Ji`

Output

```20

```

Time Complexity: O(2K)
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, there exist two possibilities:

1. Kth bit is not set: Observe that bits having positions greater than K will not be affected. Therefore, make the Kth bit set and make all bits on its left 0.
2. Kth bit is set: Find the first least significant unset bit and set it. After that, unset all the bits that are on its right.

Follow the steps below to solve the problem:

1. Check if the Kth bit of N is set. If found to be true, then find the lowest unset bit and set it and change all the bits to its right to 0.
2. Otherwise, set the Kth bit and update all the bits positioned lower than K to 0.
3. Print the answer after completing the above steps.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include "bits/stdc++.h"` `using` `namespace` `std;`   `// Function to find the number greater` `// than n whose Kth bit is set` `int` `find_next(``int` `n, ``int` `k)` `{` `    ``// Stores the resultant number` `    ``int` `ans = 0;`   `    ``// If Kth bit is not set` `    ``if` `((n & (1ll << k)) == 0) {` `        ``int` `cur = 0;`   `        ``// cur will be the sum of all` `        ``// powers of 2 < k` `        ``for` `(``int` `i = 0; i < k; i++) {`   `            ``// If the current bit is set` `            ``if` `(n & (1ll << i))` `                ``cur += 1ll << i;` `        ``}`   `        ``// Add Kth power of 2 to n and` `        ``// subtract the all powers of 2` `        ``// less than K that are set` `        ``ans = n - cur + (1ll << k);` `    ``}`   `    ``// If the kth bit is set` `    ``else` `{` `        ``int` `first_unset_bit = -1, cur = 0;`   `        ``for` `(``int` `i = 0; i < 64; i++) {`   `            ``// First unset bit position` `            ``if` `((n & (1ll << i)) == 0) {` `                ``first_unset_bit = i;` `                ``break``;` `            ``}`   `            ``// sum of bits that are set` `            ``else` `                ``cur += (1ll << i);` `        ``}`   `        ``// Add Kth power of 2 to n and` `        ``// subtract the all powers of 2` `        ``// less than K that are set` `        ``ans = n - cur` `              ``+ (1ll << first_unset_bit);`   `        ``// If Kth bit became unset` `        ``// then set it again` `        ``if` `((ans & (1ll << k)) == 0)` `            ``ans += (1ll << k);` `    ``}`   `    ``// Return the resultant number` `    ``return` `ans;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 15, K = 2;`   `    ``// Print ans` `    ``cout << find_next(N, K);`   `    ``return` `0;` `}`

## Java

 `// Java program for ` `// the above approach` `import` `java.util.*;` `class` `GFG{`   `// Function to find the number ` `// greater than n whose Kth ` `// bit is set` `static` `int` `find_next(``int` `n, ` `                     ``int` `k)` `{` `  ``// Stores the resultant ` `  ``// number` `  ``int` `ans = ``0``;`   `  ``// If Kth bit is not set` `  ``if` `((n & (1L << k)) == ``0``) ` `  ``{` `    ``int` `cur = ``0``;`   `    ``// cur will be the sum of all` `    ``// powers of 2 < k` `    ``for` `(``int` `i = ``0``; i < k; i++) ` `    ``{` `      ``// If the current bit is set` `      ``if` `((n & (1L << i)) > ``0``)` `        ``cur += 1L << i;` `    ``}`   `    ``// Add Kth power of 2 to n and` `    ``// subtract the all powers of 2` `    ``// less than K that are set` `    ``ans = (``int``)(n - cur + (1L << k));` `  ``}`   `  ``// If the kth bit is set` `  ``else` `  ``{` `    ``int` `first_unset_bit = -``1``, cur = ``0``;`   `    ``for` `(``int` `i = ``0``; i < ``64``; i++) ` `    ``{` `      ``// First unset bit position` `      ``if` `((n & (1L << i)) == ``0``) ` `      ``{` `        ``first_unset_bit = i;` `        ``break``;` `      ``}`   `      ``// sum of bits that are set` `      ``else` `        ``cur += (1L << i);` `    ``}`   `    ``// Add Kth power of 2 to n and` `    ``// subtract the all powers of 2` `    ``// less than K that are set` `    ``ans = (``int``)(n - cur + ` `          ``(1L << first_unset_bit));`   `    ``// If Kth bit became unset` `    ``// then set it again` `    ``if` `((ans & (1L << k)) == ``0``)` `      ``ans += (1L << k);` `  ``}`   `  ``// Return the resultant number` `  ``return` `ans;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `  ``int` `N = ``15``, K = ``2``;`   `  ``// Print ans` `  ``System.out.print(find_next(N, K));` `}` `}`   `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program for the above approach`   `# Function to find the number greater` `# than n whose Kth bit is set` `def` `find_next(n, k):`   `    ``# Stores the resultant number` `    ``ans ``=` `0` `    `  `    ``# If Kth bit is not set` `    ``if` `((n & (``1` `<< k)) ``=``=` `0``):` `        ``cur ``=` `0`   `        ``# cur will be the sum of all` `        ``# powers of 2 < k` `        ``for` `i ``in` `range``(k):`   `            ``# If the current bit is set` `            ``if` `(n & (``1` `<< i)):` `                ``cur ``+``=` `1` `<< i`   `        ``# Add Kth power of 2 to n and` `        ``# subtract the all powers of 2` `        ``# less than K that are set` `        ``ans ``=` `n ``-` `cur ``+` `(``1` `<< k)`   `    ``# If the kth bit is set` `    ``else``:` `        ``first_unset_bit, cur ``=` `-``1``, ``0`   `        ``for` `i ``in` `range``(``64``):`   `            ``# First unset bit position` `            ``if` `((n & (``1` `<< i)) ``=``=` `0``):` `                ``first_unset_bit ``=` `i` `                ``break`   `            ``# Sum of bits that are set` `            ``else``:` `                ``cur ``+``=` `(``1` `<< i)`   `        ``# Add Kth power of 2 to n and` `        ``# subtract the all powers of 2` `        ``# less than K that are set` `        ``ans ``=` `n ``-` `cur ``+` `(``1` `<< first_unset_bit)`   `        ``# If Kth bit became unset` `        ``# then set it again` `        ``if` `((ans & (``1` `<< k)) ``=``=` `0``):` `            ``ans ``+``=` `(``1` `<< k)`   `    ``# Return the resultant number` `    ``return` `ans` `    `  `# Driver code` `N, K ``=` `15``, ``2`   `# Print ans` `print``(find_next(N, K))`   `# This code is contributed by divyeshrabadiya07`

## C#

 `// C# program for ` `// the above approach` `using` `System;` `class` `GFG{`   `// Function to find the number ` `// greater than n whose Kth ` `// bit is set` `static` `int` `find_next(``int` `n, ` `                     ``int` `k)` `{` `  ``// Stores the resultant ` `  ``// number` `  ``int` `ans = 0;`   `  ``// If Kth bit is not set` `  ``if` `((n & (1L << k)) == 0) ` `  ``{` `    ``int` `cur = 0;`   `    ``// cur will be the sum of all` `    ``// powers of 2 < k` `    ``for` `(``int` `i = 0; i < k; i++) ` `    ``{` `      ``// If the current bit is set` `      ``if` `((n & (1L << i)) > 0)` `        ``cur += (``int``)1L << i;` `    ``}`   `    ``// Add Kth power of 2 to n and` `    ``// subtract the all powers of 2` `    ``// less than K that are set` `    ``ans = (``int``)(n - cur + (1L << k));` `  ``}`   `  ``// If the kth bit is set` `  ``else` `  ``{` `    ``int` `first_unset_bit = -1, cur = 0;`   `    ``for` `(``int` `i = 0; i < 64; i++) ` `    ``{` `      ``// First unset bit position` `      ``if` `((n & (1L << i)) == 0) ` `      ``{` `        ``first_unset_bit = i;` `        ``break``;` `      ``}`   `      ``// Sum of bits that are set` `      ``else` `        ``cur +=(``int``)(1L << i);` `    ``}`   `    ``// Add Kth power of 2 to n and` `    ``// subtract the all powers of 2` `    ``// less than K that are set` `    ``ans = (``int``)(n - cur + ` `          ``(1L << first_unset_bit));`   `    ``// If Kth bit became unset` `    ``// then set it again` `    ``if` `((ans & (1L << k)) == 0)` `      ``ans += (``int``)(1L << k);` `  ``}`   `  ``// Return the resultant number` `  ``return` `ans;` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `  ``int` `N = 15, K = 2;`   `  ``// Print ans` `  ``Console.Write(find_next(N, K));` `}` `}`   `// This code is contributed by Rajput-Ji`

Output

```20

```

Time Complexity: O(K)
Auxiliary Space: O(1)

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.

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.