Open in App
Not now

# Check if binary representation of a given number and its complement are anagram

• Difficulty Level : Hard
• Last Updated : 05 Jul, 2022

Given a positive number you need to check whether it’s complement and the number are anagrams or not.
Examples:

```Input : a = 4294967295
Output : Yes
Binary representation of 'a' and it's
complement are anagrams of each other

Input : a = 4
Output : No```

Simple Approach: In this approach calculation of the complement of the number is allowed.
1. Find binary representation of the number and it’s complement using simple decimal to binary representation technique.
2. Sort both the binary representations and compare them to check whether they are anagrams or not.

## CPP

 `// A simple C++ program to check if binary` `// representations of a number and it's` `// complement are anagram.` `#include ` `#define ull unsigned long long int` `using` `namespace` `std;`   `const` `int` `ULL_SIZE = 8*``sizeof``(ull);`   `bool` `isComplementAnagram(ull a)` `{` `    ``ull b = ~a; ``// Finding complement of a;`   `    ``// Find reverse binary representation of a.` `    ``bool` `binary_a[ULL_SIZE] = { 0 };` `    ``for` `(``int` `i=0; a > 0; i++)` `    ``{` `        ``binary_a[i] = a % 2;` `        ``a /= 2;` `    ``}`   `    ``// Find reverse binary representation` `    ``// of complement.` `    ``bool` `binary_b[ULL_SIZE] = { 0 };` `    ``for` `(``int` `i=0; b > 0; i++)` `    ``{` `        ``binary_b[i] = b % 2;` `        ``b /= 2;` `    ``}`   `    ``// Sort binary representations and compare` `    ``// after sorting.` `    ``sort(binary_a, binary_a + ULL_SIZE);` `    ``sort(binary_b, binary_b + ULL_SIZE);` `    ``for` `(``int` `i = 0; i < ULL_SIZE; i++)` `        ``if` `(binary_a[i] != binary_b[i])` `            ``return` `false``;`   `    ``return` `true``;` `}`   `// Driver code` `int` `main()` `{` `    ``ull a = 4294967295;` `    ``cout << isComplementAnagram(a) << endl;` `    ``return` `0;` `}`

## Java

 `// A simple JAVA program to check if binary` `// representations of a number and it's` `// complement are anagram.` `import` `java.math.BigInteger;` `import` `java.util.*;`     `class` `GFG {`   `  ``// Method to discard the signed bit of the byte array` `  ``// inorder to convert the numbers to unsigned` `  ``static` `byte``[] toUnsigned(``byte``[] byteArray)` `  ``{` `    ``BigInteger b = ``new` `BigInteger(byteArray);` `    ``b = b.ONE.shiftLeft(``128``);`   `    ``return` `b.toByteArray();` `  ``}`   `  ``//Method to check if a number and its complement` `  ``//are anagrams` `  ``static` `int` `isComplementAnagram(BigInteger a)` `  ``{` `    ``//converting a to an unsigned byte array` `    ``byte``[] binary_a = a.toByteArray();` `    ``binary_a = toUnsigned(binary_a);`   `    ``//constructing byte array of complement of a` `    ``byte``[] binary_b = ``new` `byte``[binary_a.length];`   `    ``//inverting the bits of a` `    ``for` `(``int` `i = ``0``; i < binary_a.length; i++)` `    ``{` `      ``binary_b[i] = (``byte``)(binary_a[i] ^ ``0xFF``);` `    ``}` `    ``binary_b = toUnsigned(binary_b);`   `    ``// Sort binary representations ` `    ``Arrays.sort(binary_a);` `    ``Arrays.sort(binary_b);`   `    ``//converting a and ~a to unsigned after sorting` `    ``binary_a = toUnsigned(binary_b);` `    ``binary_b = toUnsigned(binary_b);`   `    ``//comparing the binary representations` `    ``for` `(``int` `i = ``0``; i < binary_a.length; i++)` `      ``if` `(binary_a[i] != binary_b[i])` `        ``return` `0``;` `    ``return` `1``;`   `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``BigInteger a = ``new` `BigInteger(``"4294967295"``);` `    `  `    ``// Function call` `    ``System.out.println(isComplementAnagram(a));` `  ``}` `}`   `// This code is contributed by phasing17`

## Python3

 `# Python3  program to check if binary` `# representations of a number and it's` `# complement are anagram.`   `ULL_SIZE ``=` `8` `*` `8`   `def` `isComplementAnagram(a):`   `    ``# Find reverse binary representation of a.` `    ``binary_a ``=` `[``0` `for` `_ ``in` `range``(ULL_SIZE)]` `    ``binary_b ``=` `[``0` `for` `_ ``in` `range``(ULL_SIZE)]`   `    ``i ``=` `0` `    ``while` `a > ``0``:`   `        ``binary_a[i] ``=` `a ``%` `2` `        ``a ``=` `int``(a ``/` `2``)` `        ``i ``+``=` `1`   `    ``# Find reverse binary representation` `    ``# of complement.` `    ``for` `i ``in` `range``(ULL_SIZE):` `        ``binary_b[i] ``=` `1` `-` `binary_a[i]`   `    ``# Sort binary representations and compare` `    ``# after sorting.` `    ``binary_a.sort()` `    ``binary_b.sort()`   `    ``for` `i ``in` `range``(ULL_SIZE):` `        ``if` `(binary_a[i] !``=` `binary_b[i]):` `            ``return` `0`   `    ``return` `1`   `# Driver code` `a ``=` `4294967295` `print``(isComplementAnagram(a))`   `# This code is contributed by phasing17`

## Javascript

 `// JS  program to check if binary` `// representations of a number and it's` `// complement are anagram.`   `const ULL_SIZE = 8 * 8;`   `function` `isComplementAnagram(a)` `{`   `    ``// Find reverse binary representation of a.`   `    ``var` `binary_a = ``new` `Array(ULL_SIZE).fill(0);` `    ``var` `binary_b = ``new` `Array(ULL_SIZE).fill(0);` `    ``for` `(``var` `i = 0; a > 0; i++)` `    ``{` `        ``binary_a[i] = a % 2;` `        ``a = Math.floor(a / 2);` `    ``}`     `    ``// Find reverse binary representation` `    ``// of complement.` `    ``for` `(``var` `i = 0; i < ULL_SIZE; i++)` `    ``{` `        ``binary_b[i] = 1 - binary_a[i];` `    ``}` `    `  `    `  `    ``// Sort binary representations and compare` `    ``// after sorting.` `    ``binary_a.sort();` `    ``binary_b.sort();`     `    ``for` `(``var` `i = 0; i < ULL_SIZE; i++)` `        ``if` `(binary_a[i] != binary_b[i])` `            ``return` `false``;`   `    ``return` `true``;` `}`   `// Driver code` `var` `a = 4294967295;` `console.log(isComplementAnagram(a));`     `//This code is contributed by phasing17`

Output:

`1`

Time Complexity : O(logn*log(logn)) where n is the given number.

Auxiliary Space: O(ULL_SIZE) where ULL_SIZE is defined constant.
Efficient Approach: Just count the number of 1’s present in the bit representation of the given number. If number of 1’s present are 32 then it’s complement will also have 32 1’s in it’s bit representation and they will be anagrams of each other.

## C++

 `// An efficient C++ program to check if binary` `// representations of a number and it's complement are anagram.` `#include ` `#define ull unsigned long long int` `using` `namespace` `std;`   `const` `int` `ULL_SIZE = 8*``sizeof``(ull);`   `// Returns true if binary representations of` `// a and b are anagram.` `bool` `bit_anagram_check(ull a)` `{` `    ``// _popcnt64(a) gives number of 1's present` `    ``// in binary representation of a. If number` `    ``// of 1s is half of total bits, return true.` `    ``return` `(_popcnt64(a) == (ULL_SIZE >> 1));` `}`   `int` `main()` `{` `    ``ull a = 4294967295;` `    ``cout << bit_anagram_check(a) << endl;` `    ``return` `0;` `}`

## Java

 `// An efficient Java program to check if binary` `// representations of a number and it's complement are anagram.` `class` `GFG ` `{`   `static` `byte` `longSize = ``8``;` `static` `int` `ULL_SIZE = ``8``*longSize;`   `// Returns true if binary representations of` `// a and b are anagram.` `static` `boolean` `bit_anagram_check(``long` `a)` `{` `    ``// _popcnt64(a) gives number of 1's present` `    ``// in binary representation of a. If number` `    ``// of 1s is half of total bits, return true.` `    ``return` `(Integer.bitCount((``int``)a) == (ULL_SIZE >> ``1``));` `}`   `// Driver code` `public` `static` `void` `main(String[] args) ` `{` `long` `a = 4294967295L;` `    ``System.out.println(bit_anagram_check(a));` `}` `}`   `/* This code contributed by PrinciRaj1992 */`

## Python3

 `# An efficient Python3 program to check ` `# if binary representations of a number ` `# and it's complement are anagram.` `ULL_SIZE ``=` `64`   `# Returns true if binary representations of` `# a and b are anagram.` `def` `bit_anagram_check(a):`   `    ``#_popcnt64(a) gives number of 1's present` `    ``# in binary representation of a. If number` `    ``# of 1s is half of total bits, return true.` `    ``return` `(``bin``(a).count(``"1"``) ``=``=` `(ULL_SIZE >> ``1``))`   `# Driver Code` `a ``=` `4294967295` `print``(``int``(bit_anagram_check(a)))`   `# This code is contributed by Mohit Kumar`

## C#

 `// An efficient C# program to check ` `// if binary representations of ` `// a number and it's complement ` `// are anagram.` `using` `System;`   `class` `GFG ` `{`   `static` `byte` `longSize = 8;` `static` `int` `ULL_SIZE = 8*longSize;`   `// Returns true if binary representations of` `// a and b are anagram.` `static` `bool` `bit_anagram_check(``long` `a)` `{` `    ``// _popcnt64(a) gives number of 1's present` `    ``// in binary representation of a. If number` `    ``// of 1s is half of total bits, return true.` `    ``return` `(BitCount((``int``)a) == (ULL_SIZE >> 1));` `}`   `static` `int` `BitCount(``int` `n)` `{` `    ``int` `count = 0;` `    ``while` `(n != 0)` `    ``{` `        ``count++;` `        ``n &= (n - 1);` `    ``}` `    ``return` `count;` `}`   `// Driver code` `public` `static` `void` `Main(String[] args) ` `{` `    ``long` `a = 4294967295L;` `    ``Console.WriteLine(bit_anagram_check(a));` `}` `}`   `// This code has been contributed by 29AjayKumar`

## PHP

 `> 1));` `}`   `function` `BitCount(``\$n``)` `{` `    ``\$count` `= 0;` `    ``while` `(``\$n` `!= 0)` `    ``{` `        ``\$count``++;` `        ``\$n` `&= (``\$n` `- 1);` `    ``}` `    ``return` `\$count``;` `}`   `// Driver code` `\$a` `= 4294967295;` `echo``(bit_anagram_check(``\$a``));`   `// This code contributed by Rajput-Ji ` `?>`

## Javascript

 ``

Output:

`1`

Time Complexity : O(1)

Auxiliary Space: O(1)
Note:
1. The answer is only dependent on the number, in the above approach we don’t even find the need to obtain the complement of the number.
2. The above code uses GCC specific functions. If we wish to write code for other compilers, we may use Count set bits in an integer.
This article is contributed by Aditya Gupta. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

My Personal Notes arrow_drop_up
Related Articles