Given an integer **N**, the task is to find whether the bits of **N** can be arranged in alternating manner i.e. either **0101…** or **10101…**. Assume that **N** is represented as a **32** bit integer.

**Examples:**

Input:N = 23

Output:No

“00000000000000000000000000010111” is the binary representation of 23

and the required permutation of bits is not possible.

Input:N = 524280

Output:Yes

binary(524280) = “00000000000001111111111111111000” which can be

rearranged to “01010101010101010101010101010101”.

**Approach:** Since the given integer has to be represented in 32 bits and the number of 1s must be equal to the number of 0s in its binary representation to satisfy the given condition. So, the number of set bits in N must be 16 which can be easily calculated using __builtin_popcount()

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `const` `int` `TOTAL_BITS = 32; ` ` ` `// Function that returns true if it is ` `// possible to arrange the bits of ` `// n in alternate fashion ` `bool` `isPossible(` `int` `n) ` `{ ` ` ` ` ` `// To store the count of 1s in the ` ` ` `// binary representation of n ` ` ` `int` `cnt = __builtin_popcount(n); ` ` ` ` ` `// If the number set bits and the ` ` ` `// number of unset bits is equal ` ` ` `if` `(cnt == TOTAL_BITS / 2) ` ` ` `return` `true` `; ` ` ` `return` `false` `; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `int` `n = 524280; ` ` ` ` ` `if` `(isPossible(n)) ` ` ` `cout << ` `"Yes"` `; ` ` ` `else` ` ` `cout << ` `"No"` `; ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java implementation of the approach ` `import` `java.util.*; ` ` ` `class` `GFG ` `{ ` ` ` `static` `int` `TOTAL_BITS = ` `32` `; ` ` ` `// Function that returns true if it is ` `// possible to arrange the bits of ` `// n in alternate fashion ` `static` `boolean` `isPossible(` `int` `n) ` `{ ` ` ` ` ` `// To store the count of 1s in the ` ` ` `// binary representation of n ` ` ` `int` `cnt = Integer.bitCount(n); ` ` ` ` ` `// If the number set bits and the ` ` ` `// number of unset bits is equal ` ` ` `if` `(cnt == TOTAL_BITS / ` `2` `) ` ` ` `return` `true` `; ` ` ` `return` `false` `; ` `} ` ` ` `// Driver code ` `static` `public` `void` `main (String []arr) ` `{ ` ` ` `int` `n = ` `524280` `; ` ` ` ` ` `if` `(isPossible(n)) ` ` ` `System.out.println(` `"Yes"` `); ` ` ` `else` ` ` `System.out.println(` `"No"` `); ` `} ` `} ` ` ` `// This code is contributed by 29AjayKumar ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 implementation of the approach ` `TOTAL_BITS ` `=` `32` `; ` ` ` `# Function that returns true if it is ` `# possible to arrange the bits of ` `# n in alternate fashion ` `def` `isPossible(n) : ` ` ` ` ` `# To store the count of 1s in the ` ` ` `# binary representation of n ` ` ` `cnt ` `=` `bin` `(n).count(` `'1'` `); ` ` ` ` ` `# If the number set bits and the ` ` ` `# number of unset bits is equal ` ` ` `if` `(cnt ` `=` `=` `TOTAL_BITS ` `/` `/` `2` `) : ` ` ` `return` `True` `; ` ` ` ` ` `return` `False` `; ` ` ` `# Driver code ` `if` `__name__ ` `=` `=` `"__main__"` `: ` ` ` ` ` `n ` `=` `524280` `; ` ` ` ` ` `if` `(isPossible(n)) : ` ` ` `print` `(` `"Yes"` `); ` ` ` `else` `: ` ` ` `print` `(` `"No"` `); ` ` ` `# This code is contributed by AnkitRai01 ` |

*chevron_right*

*filter_none*

## C#

`// C# implementation of the above approach ` `using` `System; ` ` ` `class` `GFG ` `{ ` `static` `int` `TOTAL_BITS = 32; ` ` ` `static` `int` `CountBits(` `int` `value) ` `{ ` ` ` `int` `count = 0; ` ` ` `while` `(value != 0) ` ` ` `{ ` ` ` `count++; ` ` ` `value &= value - 1; ` ` ` `} ` ` ` `return` `count; ` `} ` ` ` `// Function that returns true if it is ` `// possible to arrange the bits of ` `// n in alternate fashion ` `static` `bool` `isPossible(` `int` `n) ` `{ ` ` ` ` ` `// To store the count of 1s in the ` ` ` `// binary representation of n ` ` ` `int` `cnt = CountBits(n); ` ` ` ` ` `// If the number set bits and the ` ` ` `// number of unset bits is equal ` ` ` `if` `(cnt == TOTAL_BITS / 2) ` ` ` `return` `true` `; ` ` ` `return` `false` `; ` `} ` ` ` `// Driver code ` `public` `static` `void` `Main (String []arr) ` `{ ` ` ` `int` `n = 524280; ` ` ` ` ` `if` `(isPossible(n)) ` ` ` `Console.WriteLine(` `"Yes"` `); ` ` ` `else` ` ` `Console.WriteLine(` `"No"` `); ` `} ` `} ` ` ` `// This code is contributed by Mohit kumar ` |

*chevron_right*

*filter_none*

**Output:**

Yes

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.

## Recommended Posts:

- Minimum number of given operations required to convert a permutation into an identity permutation
- Minimum number of adjacent swaps required to convert a permutation to another permutation by given condition
- Find the permutation of first N natural numbers such that sum of i % P
_{i}is maximum possible - Check if bits of a number has count of consecutive set bits in increasing order
- Toggle bits of a number except first and last bits
- Check if all bits can be made same by flipping two consecutive bits
- Print numbers having first and last bits as the only set bits
- Iterating over all possible combinations in an Array using Bits
- Find smallest permutation of given number
- Find a permutation such that number of indices for which gcd(p[i], i) > 1 is exactly K
- Find permutation of n which is divisible by 3 but not divisible by 6
- Find a permutation of 2N numbers such that the result of given expression is exactly 2K
- Find the good permutation of first N natural numbers
- Find the number of sub arrays in the permutation of first N natural numbers such that their median is M
- Find permutation of first N natural numbers that satisfies the given condition
- Find the permutation p from the array q such that q[i] = p[i+1] - p[i]
- Find permutation with maximum remainder Sum
- Find permutation array from the cumulative sum array
- Find the minimum permutation of A greater than B
- Find the K-th Permutation Sequence of first N natural numbers

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.