Open In App

Smallest number exceeding N whose Kth bit is set

Last Updated : 13 Jan, 2022
Comments
Improve
Suggest changes
Like Article
Like
Report

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
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(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
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)


Next Article
Smallest number exceeding N whose Kth bit is set

D
dbarnwal888
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox