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 K^th bit in its binary representation is set.

Examples:

Input: N = 15, K = 2
Output: 20
Explanation:
The binary representation of (20)₁₀ is (10100)₂. The 2^nd bit(0-based indexing) from left is set in (20)₁₀. Therefore, 20 is the smallest number greater than 15 having 2^nd 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 K^th 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

Javascript

<script>
 
// Javascript program to implement
// the above approach
     
 // Function to find the number greater
// than n whose Kth bit is set
function find_next(n, k)
{
  // Iterate from N + 1
  let 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++;
  }
  
  // Return the minimum value
  return M;
}
 
// Driver Code
  
     // Given N and K
  let N =  15, K = 2;
  
  // Function Call
  document.write(find_next(N, K));
  
 // This code is contributed by avijitmondal1998.
</script>

Output

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

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

K^th bit is not set: Observe that bits having positions greater than K will not be affected. Therefore, make the K^th bit set and make all bits on its left 0.
K^thbit 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:

Check if the K^thbit 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.
Otherwise, set the K^th bit and update all the bits positioned lower than K to 0.
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

Javascript

<script>
// javascript program for
// the above approach
 
    // Function to find the number
    // greater than n whose Kth
    // bit is set
    function find_next(n , k) {
        // Stores the resultant
        // number
        var ans = 0;
 
        // If Kth bit is not set
        if ((n & (1 << k)) == 0) {
            var cur = 0;
 
            // cur will be the sum of all
            // powers of 2 < k
            for (i = 0; i < k; i++) {
                // If the current bit is set
                if ((n & (1 << i)) > 0)
                    cur += 1 << i;
            }
 
            // Add Kth power of 2 to n and
            // subtract the all powers of 2
            // less than K that are set
            ans = parseInt( (n - cur + (1 << k)));
        }
 
        // If the kth bit is set
        else {
            var first_unset_bit = -1, cur = 0;
 
            for (i = 0; i < 64; i++) {
                // 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 = parseInt( (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
     
        var N = 15, K = 2;
 
        // Print ans
        document.write(find_next(N, K));
         
// This code is contributed by umadevi9616
</script>