Skip to content
Related Articles

Related Articles

Smallest number exceeding N whose Kth bit is set

View Discussion
Improve Article
Save Article
  • Last Updated : 13 Jan, 2022

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)

My Personal Notes
arrow_drop_up
Next

Minimize steps defined by a string required to reach the destination from a given source
Recommended Articles
Page :
Kth number exceeding N whose sum of its digits divisible by M
27, Oct 20
Construct a Matrix with no element exceeding X and sum of two adjacent elements not exceeding Y
03, Aug 20
Smallest number greater than or equal to N having sum of digits not exceeding S
05, Nov 20
Queries for number of array elements in a range with Kth Bit Set
18, Jun 18
Minimum value exceeding X whose count of divisors has different parity with count of divisors of X
18, Nov 20
Find array elements with rightmost set bit at the position of the rightmost set bit in K
09, Feb 21
Find the index at which bit must be set to maximise distance between next set bit
26, Jan 22
Lexicographically smallest permutation of size A having B integers exceeding all preceding integers
06, Oct 20
Smallest positive integer that divides all array elements to generate quotients with sum not exceeding K
18, Dec 20
Count numbers up to N having Kth bit set
29, Dec 20
Nth term where K+1th term is product of Kth term with difference of max and min digit of Kth term
22, May 20
Multiplication table till N rows where every Kth row is table of K upto Kth term
27, Feb 20
Minimum adjacent swaps required to get Kth smallest number greater than given number
19, Oct 21
Inserting M into N such that m starts at bit j and ends at bit i | Set-2
29, Aug 18
Minimum bit flips such that every K consecutive bits contain at least one set bit
11, Jun 20
Count bases which contains a set bit as the Most Significant Bit in the representation of N
18, Jun 21
Smallest number greater or equals to N such that it has no odd positioned bit set
27, Jun 19
Count number of triplets with product not exceeding a given number
30, Apr 21
Invert the Kth most significant bit of N
02, Jan 20
Kth smallest Prime Number in range L to R for Q queries
27, Dec 21
Find the kth smallest number with sum of digits as m
27, Aug 19
Kth smallest even number in range L to R
25, Nov 21
Find the Kth smallest odd length palindrome number
09, Jul 21
Find kth smallest number in range [1, n] when all the odd numbers are deleted
05, Mar 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
dbarnwal888
@dbarnwal888
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

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

Start Your Coding Journey Now!