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 **0 ^{th}** bit.

**Examples:**

Input:N = 9Output: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 = 5Output:5

Input:N = 19Output: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 which 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 <bits/stdc++.h>` `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 ` |

**Output:**

20

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.