# Smallest number greater or equals to N such that it has no odd positioned bit set

• Last Updated : 31 May, 2022

Given an integer N, the task is to find the smallest integer X such that it has no odd position set and X â‰¥ N
Note: The positioning of bits is assumed from the right side and the first bit is assumed to be the 0th bit.

Examples:

Input: N = 9
Output: 16
16’s binary representation is 10000, which has its 4th bit
set which is the smallest number possible satisfying the given condition.
Input: N = 5
Output: 5
Input: N = 19
Output: 20

Approach: The problem can be solved using a greedy approach and some bit properties. The property that if smaller powers of two are taken exactly once and added up they can never exceed a higher power of two (e.g., (1 + 2 + 4) < 8). The following greedy approach is used to solve the above problem:

• Initially count the number of bits.
• Get the leftmost index of the set bit.
• If the leftmost set bit is at an odd index, then answer will always be (1 << (leftmost_bit_index + 1)).
• Else, greedily form a number by setting all the even bits from 0 to leftmost_bit_index. Now greedily remove a power of two from right to check if we get a number that satisfies the given conditions.
• If the above condition does not give us our number, then we simply set the next leftmost even bit and return the answer.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the above approach``#include ``using` `namespace` `std;` `// Function to count the total bits``int` `countBits(``int` `n)``{``    ``int` `count = 0;` `    ``// Iterate and find the``    ``// number of set bits``    ``while` `(n) {``        ``count++;` `        ``// Right shift the number by 1``        ``n >>= 1;``    ``}``    ``return` `count;``}` `// Function to find the nearest number``int` `findNearestNumber(``int` `n)``{` `    ``// Count the total number of bits``    ``int` `cnt = countBits(n);` `    ``// To get the position``    ``cnt -= 1;` `    ``// If the last set bit is``    ``// at odd position then``    ``// answer will always be a number``    ``// with the left bit set``    ``if` `(cnt % 2) {``        ``return` `1 << (cnt + 1);``    ``}` `    ``else` `{` `        ``int` `tempnum = 0;` `        ``// Set all the even bits which``        ``// are possible``        ``for` `(``int` `i = 0; i <= cnt; i += 2)``            ``tempnum += 1 << i;` `        ``// If the number still is less than N``        ``if` `(tempnum < n) {` `            ``// Return the number by setting the``            ``// next even set bit``            ``return` `(1 << (cnt + 2));``        ``}` `        ``else` `if` `(tempnum == n)``            ``return` `n;` `        ``// If we have reached this position``        ``// it means tempsum > n``        ``// hence turn off even bits to get the``        ``// first possible number``        ``for` `(``int` `i = 0; i <= cnt; i += 2) {` `            ``// Turn off the bit``            ``tempnum -= (1 << i);` `            ``// If it gets lower than N``            ``// then set it and return that number``            ``if` `(tempnum < n)``                ``return` `tempnum += (1 << i);``        ``}``    ``}``}` `// Driver code``int` `main()``{``    ``int` `n = 19;``    ``cout << findNearestNumber(n);``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `class` `GFG``{` `    ``// Function to count the total bits``    ``static` `int` `countBits(``int` `n)``    ``{``        ``int` `count = ``0``;` `        ``// Iterate and find the``        ``// number of set bits``        ``while` `(n > ``0``)``        ``{``            ``count++;` `            ``// Right shift the number by 1``            ``n >>= ``1``;``        ``}``        ``return` `count;``    ``}` `    ``// Function to find the nearest number``    ``static` `int` `findNearestNumber(``int` `n)``    ``{` `        ``// Count the total number of bits``        ``int` `cnt = countBits(n);` `        ``// To get the position``        ``cnt -= ``1``;` `        ``// If the last set bit is``        ``// at odd position then``        ``// answer will always be a number``        ``// with the left bit set``        ``if` `(cnt % ``2` `== ``1``)``        ``{``            ``return` `1` `<< (cnt + ``1``);``        ``}``        ``else``        ``{` `            ``int` `tempnum = ``0``;` `            ``// Set all the even bits which``            ``// are possible``            ``for` `(``int` `i = ``0``; i <= cnt; i += ``2``)``            ``{``                ``tempnum += ``1` `<< i;``            ``}` `            ``// If the number still is less than N``            ``if` `(tempnum < n)``            ``{` `                ``// Return the number by setting the``                ``// next even set bit``                ``return` `(``1` `<< (cnt + ``2``));``            ``}``            ``else``            ``if` `(tempnum == n)``            ``{``                ``return` `n;``            ``}` `            ``// If we have reached this position``            ``// it means tempsum > n``            ``// hence turn off even bits to get the``            ``// first possible number``            ``for` `(``int` `i = ``0``; i <= cnt; i += ``2``)``            ``{` `                ``// Turn off the bit``                ``tempnum -= (``1` `<< i);` `                ``// If it gets lower than N``                ``// then set it and return that number``                ``if` `(tempnum < n)``                ``{``                    ``return` `tempnum += (``1` `<< i);``                ``}``            ``}``        ``}``        ``return` `Integer.MIN_VALUE;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `n = ``19``;` `        ``System.out.println(findNearestNumber(n));``    ``}``}` `// This code is contributed by 29AjayKumar`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{` `    ``// Function to count the total bits``    ``static` `int` `countBits(``int` `n)``    ``{``        ``int` `count = 0;` `        ``// Iterate and find the``        ``// number of set bits``        ``while` `(n > 0)``        ``{``            ``count++;` `            ``// Right shift the number by 1``            ``n >>= 1;``        ``}``        ``return` `count;``    ``}` `    ``// Function to find the nearest number``    ``static` `int` `findNearestNumber(``int` `n)``    ``{` `        ``// Count the total number of bits``        ``int` `cnt = countBits(n);` `        ``// To get the position``        ``cnt -= 1;` `        ``// If the last set bit is``        ``// at odd position then``        ``// answer will always be a number``        ``// with the left bit set``        ``if` `(cnt % 2 == 1)``        ``{``            ``return` `1 << (cnt + 1);``        ``}``        ``else``        ``{` `            ``int` `tempnum = 0;` `            ``// Set all the even bits which``            ``// are possible``            ``for` `(``int` `i = 0; i <= cnt; i += 2)``            ``{``                ``tempnum += 1 << i;``            ``}` `            ``// If the number still is less than N``            ``if` `(tempnum < n)``            ``{` `                ``// Return the number by setting the``                ``// next even set bit``                ``return` `(1 << (cnt + 2));``            ``}``            ``else``            ``if` `(tempnum == n)``            ``{``                ``return` `n;``            ``}` `            ``// If we have reached this position``            ``// it means tempsum > n``            ``// hence turn off even bits to get the``            ``// first possible number``            ``for` `(``int` `i = 0; i <= cnt; i += 2)``            ``{` `                ``// Turn off the bit``                ``tempnum -= (1 << i);` `                ``// If it gets lower than N``                ``// then set it and return that number``                ``if` `(tempnum < n)``                ``{``                    ``return` `tempnum += (1 << i);``                ``}``            ``}``        ``}``        ``return` `int``.MinValue;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int` `n = 19;` `        ``Console.WriteLine(findNearestNumber(n));``    ``}``}` `// This code is contributed by anuj_67..`

## Python3

 `# Python implementation of the above approach` ` ` `# Function to count the total bits``def` `countBits(n):``    ``count ``=` `0``;`` ` `    ``# Iterate and find the``    ``# number of set bits``    ``while` `(n>``0``):``        ``count``+``=``1``;`` ` `        ``# Right shift the number by 1``        ``n >>``=` `1``;``    ``return` `count;`` ` `# Function to find the nearest number``def` `findNearestNumber(n):`` ` `    ``# Count the total number of bits``    ``cnt ``=` `countBits(n);`` ` `    ``# To get the position``    ``cnt ``-``=` `1``;`` ` `    ``# If the last set bit is``    ``# at odd position then``    ``# answer will always be a number``    ``# with the left bit set``    ``if` `(cnt ``%` `2``):``        ``return` `1` `<< (cnt ``+` `1``);`` ` `    ``else``:`` ` `        ``tempnum ``=` `0``;`` ` `        ``# Set all the even bits which``        ``# are possible``        ``for` `i ``in` `range``(``0``,cnt``+``1``,``2``):``            ``tempnum ``+``=` `1` `<< i;`` ` `        ``# If the number still is less than N``        ``if` `(tempnum < n):`` ` `            ``# Return the number by setting the``            ``# next even set bit``            ``return` `(``1` `<< (cnt ``+` `2``));`` ` `        ``elif` `(tempnum ``=``=` `n):``            ``return` `n;`` ` `        ``# If we have reached this position``        ``# it means tempsum > n``        ``# hence turn off even bits to get the``        ``# first possible number``        ``for` `i ``in` `range``(``0``,cnt``+``1``,``2``):`` ` `            ``# Turn off the bit``            ``tempnum ``-``=` `(``1` `<< i);`` ` `            ``# If it gets lower than N``            ``# then set it and return that number``            ``if` `(tempnum < n):``                ``tempnum ``+``=` `(``1` `<< i);``                ``return` `tempnum;``# Driver code``n ``=` `19``;``print``(findNearestNumber(n));` `# This code contributed by PrinciRaj1992`

## Javascript

 ``

Output:

`20`

Time Complexity: O(logn)

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up