# 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```

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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.