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

20

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

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

1. 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.
2. K^th 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 K^th 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 K^th 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

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>

Output

20

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