Next greater number than N with exactly one bit different in binary representation of N

Given a number N. The task is to find the smallest number which is greater than N and has only one bit different in the binary representation of N.

Note: Here N can be very large 10^9 < N < 10^15.

Examples:

Input : N = 11
Output : The next number is 15
The binary representation of 11 is 1011
So the smallest number greater than 11 
with one bit different is 1111 which is 15.

Input : N = 17
Output : The next number is 19


Simple Approach: We will run a loop from N+1 until we find a number which has exactly one bit different than N. This process might take a long time to process in case of large numbers

Efficient Approach: In the efficient approach we have to represent the number in its binary form. Now a number greater than N with only 1 bit different is only possible when we keep all the set bits of the number N intact and switch the lowest possible bit which is zero to 1.

Let us take the example, 1001 which is binary form of 9,
If we switch the set bits of 1001 to either 1000 or 0001 then we find that the numbers are 8 and 1 which are less than N. While if we turn the bits which are zero to 1 we find the numbers are 11 (1011) or 13 (1101) so if switch the lowest possible bit which is zero to 1 then we get the smallest possible number greater than N with only 1 bit different, in this case it is 11 (1011).

Note: It is guaranteed that the input number N does not have all of its bits as set. There exists at least one unset bit in the binary representation of N.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to find next greater number than N 
// with exactly one bit different in binary
// representation of N
  
#include <bits/stdc++.h>
using namespace std;
  
// Function to find next greater number than N 
// with exactly one bit different in binary
// representation of N
long long nextGreater(long long N)
{
    long long power_of_2 = 1, shift_count = 0;
  
    // It is guaranteed that there 
    // is a bit zero in the number
    while (true) {
        // If the shifted bit is zero then break
        if (((N >> shift_count) & 1) % 2 == 0)
            break;
  
        // increase the bit shift
        shift_count++;
  
        // increase the power of 2
        power_of_2 = power_of_2 * 2;
    }
  
    // set the lowest bit of the number
    return (N + power_of_2);
}
  
// Driver code
int main()
{
    long long N = 11;
  
    // display the next number
    cout << "The next number is = " << nextGreater(N);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to find next greater number than N 
// with exactly one bit different in binary 
// representation of N 
  
class GFG{
// Function to find next greater number than N 
// with exactly one bit different in binary 
// representation of N 
static int nextGreater(int N) 
    int power_of_2 = 1, shift_count = 0
  
    // It is guaranteed that there 
    // is a bit zero in the number 
    while (true) { 
        // If the shifted bit is zero then break 
        if (((N >> shift_count) & 1) % 2 == 0
            break
  
        // increase the bit shift 
        shift_count++; 
  
        // increase the power of 2 
        power_of_2 = power_of_2 * 2
    
  
    // set the lowest bit of the number 
    return (N + power_of_2); 
  
// Driver code 
public static void main(String[]a) 
    int N = 11
  
    // display the next number 
    System.out.println("The next number is = " + nextGreater(N)); 
  
}

chevron_right


Python3

# Python3 program to find next greater
# number than N with exactly one
# bit different in binary
# representation of N

# Function to find next greater
# number than N with exactly
# one bit different in binary
# representation of N
def nextGreater(N):

power_of_2 = 1;
shift_count = 0;

# It is guaranteed that there
# is a bit zero in the number
while (True):

# If the shifted bit is
# zero then break
if (((N >> shift_count) & 1) % 2 == 0):
break;

# increase the bit shift
shift_count += 1;

# increase the power of 2
power_of_2 = power_of_2 * 2;

# set the lowest bit
# of the number
return (N + power_of_2);

# Driver code
N = 11;

# display the next number
print(“The next number is =”,
nextGreater(N));

# This code is contributed by mits

C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to find next 
// greater number than N with  
// exactly one bit different in
// binary representation of N 
using System;
  
class GFG
{
// Function to find next greater 
// number than N with exactly 
// one bit different in binary 
// representation of N 
static int nextGreater(int N) 
    int power_of_2 = 1, 
        shift_count = 0; 
  
    // It is guaranteed that there 
    // is a bit zero in the number 
    while (true)
    
        // If the shifted bit is 
        // zero then break 
        if (((N >> shift_count) & 1) % 2 == 0) 
            break
  
        // increase the bit shift 
        shift_count++; 
  
        // increase the power of 2 
        power_of_2 = power_of_2 * 2; 
    
  
    // set the lowest bit 
    // of the number 
    return (N + power_of_2); 
  
// Driver code 
public static void Main() 
    int N = 11; 
  
    // display the next number 
    Console.WriteLine("The next number is = "
                               nextGreater(N)); 
}
  
// This code is contributed 
// by anuj_67

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP program to find next greater 
// number than N with exactly one
// bit different in binary
// representation of N
  
// Function to find next greater 
// number than N with exactly 
// one bit different in binary
// representation of N
function nextGreater($N)
{
    $power_of_2 = 1; 
    $shift_count = 0;
  
    // It is guaranteed that there 
    // is a bit zero in the number
    while (true)
    {
        // If the shifted bit is
        // zero then break
        if ((($N >> $shift_count) & 1) % 2 == 0)
            break;
  
        // increase the bit shift
        $shift_count++;
  
        // increase the power of 2
        $power_of_2 = $power_of_2 * 2;
    }
  
    // set the lowest bit of the number
    return ($N + $power_of_2);
}
  
// Driver code
$N = 11;
  
// display the next number
echo "The next number is = "
              nextGreater($N);
  
// This code is contributed 
// by anuj_67
?>

chevron_right


Output:

The next number is = 15

Time Complexity: O(log(N))



My Personal Notes arrow_drop_up

Second year Department of Information Technology Jadavpur University

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.