Related Articles

# Check if binary representations of two numbers are anagram

• Difficulty Level : Easy
• Last Updated : 29 Apr, 2021

Given two numbers you are required to check whether they are anagrams of each other or not in binary representation.
Examples:

```Input : a = 8, b = 4
Output : Yes
Binary representations of both
numbers have same 0s and 1s.

Input : a = 4, b = 5
Output : No```

Simple Approach:

1. Find Binary Representation of ‘a’ and ‘b’ using simple decimal to binary representation technique.
2. Check if two binary representations are anagram

## C++

 `// A simple C++ program to check if binary``// representations of two numbers are anagram.``#include ``#define ull unsigned long long int``using` `namespace` `std;` `const` `int` `SIZE = 8 * ``sizeof``(ull);` `bool` `bit_anagram_check(ull a, ull b)``{``    ``// Find reverse binary representation of a``    ``// and store it in binary_a[]``    ``int` `i = 0, binary_a[SIZE] = { 0 };``    ``while` `(a > 0) {``        ``binary_a[i] = a % 2;``        ``a /= 2;``        ``i++;``    ``}` `    ``// Find reverse binary representation of b``    ``// and store it in binary_a[]``    ``int` `j = 0, binary_b[SIZE] = { 0 };``    ``while` `(b > 0) {``        ``binary_b[j] = b % 2;``        ``b /= 2;``        ``j++;``    ``}` `    ``// Sort two binary representations``    ``sort(binary_a, binary_a + SIZE);``    ``sort(binary_b, binary_b + SIZE);` `    ``// Compare two sorted binary representations``    ``for` `(``int` `i = 0; i < SIZE; i++)``        ``if` `(binary_a[i] != binary_b[i])``            ``return` `false``;` `    ``return` `true``;``}` `// Driver code``int` `main()``{``    ``ull a = 8, b = 4;``    ``cout << bit_anagram_check(a, b) << endl;``    ``return` `0;``}`

## Java

 `// A simple Java program to check if binary``// representations of two numbers are anagram``import` `java.io.*;``import` `java.util.*;` `class` `GFG``{``    ``public` `static` `int` `SIZE = ``8``;``    ` `    ``// Function to check if binary representation``    ``// of two numbers are anagram``    ``static` `int` `bit_anagram_check(``long` `a, ``long` `b)``    ``{``        ``// Find reverse binary representation of a``        ``// and store it in binary_a[]``        ``int` `i = ``0``;``        ``long``[] binary_a = ``new` `long``[SIZE];``        ``Arrays.fill(binary_a, ``0``);``        ``while` `(a > ``0``)``        ``{``            ``binary_a[i] = a%``2``;``            ``a /= ``2``;``            ``i++;``        ``}`` ` `        ``// Find reverse binary representation of b``        ``// and store it in binary_a[]``        ``int` `j = ``0``;``        ``long``[] binary_b = ``new` `long``[SIZE];``        ``Arrays.fill(binary_b, ``0``);``        ``while` `(b > ``0``)``        ``{``            ``binary_b[j] = b%``2``;``            ``b /= ``2``;``            ``j++;``        ``}`` ` `        ``// Sort two binary representations``        ``Arrays.sort(binary_a);``        ``Arrays.sort(binary_b);`` ` `        ``// Compare two sorted binary representations``        ``for` `(i = ``0``; i < SIZE; i++)``            ``if` `(binary_a[i] != binary_b[i])``                ``return` `0``;`` ` `        ``return` `1``;``    ``}` `    ``// driver program``    ``public` `static` `void` `main (String[] args)``    ``{``        ``long` `a = ``8``, b = ``4``;``        ``System.out.println(bit_anagram_check(a, b));``    ``}``}` `// Contributed by Pramod Kumar`

## Python3

 `# A simple C++ program to check if binary``# representations of two numbers are anagram.``SIZE ``=` `8``def` `bit_anagram_check(a, b):` `    ``# Find reverse binary representation of a``    ``# and store it in binary_a[]``    ``global` `size` `    ``i ``=` `0``    ``binary_a ``=` `[``0``] ``*` `SIZE``    ``while` `(a > ``0``):``        ``binary_a[i] ``=` `a ``%` `2``        ``a ``/``/``=` `2``        ``i ``+``=` `1` `    ``# Find reverse binary representation of b``    ``# and store it in binary_a[]``    ``j ``=` `0``    ``binary_b ``=` `[``0``] ``*` `SIZE``    ``while` `(b > ``0``):``        ``binary_b[j] ``=` `b ``%` `2``        ``b ``/``/``=` `2``        ``j ``+``=` `1` `    ``# Sort two binary representations``    ``binary_a.sort()``    ``binary_b.sort()` `    ``# Compare two sorted binary representations``    ``for` `i ``in` `range``(SIZE):``        ``if` `(binary_a[i] !``=` `binary_b[i]):``            ``return` `0``    ``return` `1` `# Driver code``if` `__name__ ``=``=` `"__main__"``:` `    ``a ``=` `8``    ``b ``=` `4``    ``print``(bit_anagram_check(a, b))` `    ``# This code is contributed by ukasp.`

## C#

 `// A simple C# program to check if``// binary representations of two``// numbers are anagram``using` `System;` `class` `GFG``{``public` `static` `int` `SIZE = 8;` `// Function to check if binary``// representation of two numbers``// are anagram``public` `static` `int` `bit_anagram_check(``long` `a,``                                    ``long` `b)``{``    ``// Find reverse binary representation``    ``// of a and store it in binary_a[]``    ``int` `i = 0;``    ``long``[] binary_a = ``new` `long``[SIZE];``    ``Arrays.Fill(binary_a, 0);``    ``while` `(a > 0)``    ``{``        ``binary_a[i] = a % 2;``        ``a /= 2;``        ``i++;``    ``}` `    ``// Find reverse binary representation ``    ``// of b and store it in binary_a[]``    ``int` `j = 0;``    ``long``[] binary_b = ``new` `long``[SIZE];``    ``Arrays.Fill(binary_b, 0);``    ``while` `(b > 0)``    ``{``        ``binary_b[j] = b % 2;``        ``b /= 2;``        ``j++;``    ``}` `    ``// Sort two binary representations``    ``Array.Sort(binary_a);``    ``Array.Sort(binary_b);` `    ``// Compare two sorted binary``    ``// representations``    ``for` `(i = 0; i < SIZE; i++)``    ``{``        ``if` `(binary_a[i] != binary_b[i])``        ``{``            ``return` `0;``        ``}``    ``}` `    ``return` `1;``}` `public` `static` `class` `Arrays``{``public` `static` `T[] CopyOf(T[] original,``                            ``int` `newLength)``{``    ``T[] dest = ``new` `T[newLength];``    ``System.Array.Copy(original, dest, newLength);``    ``return` `dest;``}` `public` `static` `T[] CopyOfRange(T[] original,``                                 ``int` `fromIndex,``                                 ``int` `toIndex)``{``    ``int` `length = toIndex - fromIndex;``    ``T[] dest = ``new` `T[length];``    ``System.Array.Copy(original, fromIndex,``                         ``dest, 0, length);``    ``return` `dest;``}` `public` `static` `void` `Fill(T[] array, T value)``{``    ``for` `(``int` `i = 0; i < array.Length; i++)``    ``{``        ``array[i] = value;``    ``}``}` `public` `static` `void` `Fill(T[] array, ``int` `fromIndex,``                           ``int` `toIndex, T value)``{``    ``for` `(``int` `i = fromIndex; i < toIndex; i++)``    ``{``        ``array[i] = value;``    ``}``}``}`  `// Driver Code``public` `static` `void` `Main(``string``[] args)``{``    ``long` `a = 8, b = 4;``    ``Console.WriteLine(bit_anagram_check(a, b));``}``}` `// This code is contributed by Shrikant13`

## Javascript

 ``

Output:

`1`

Note that 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.
Time Complexity : O (1)
Auxiliary Space : O (1) No extra space is getting used.