Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Check if B can be formed by permuting the binary digits of A

  • Last Updated : 01 Mar, 2022

Given two integer A and B, the task is to check whether the binary representation of B can be generated by permuting the binary digits of A.
Examples: 
 

Input: A = 3, B = 9 
Output: Yes 
Binary(3) = 0011 and Binary(9) = 1001
Input: A = 6, B = 7 
Output: No 
 

 

Approach: The idea is to count the number of set bits in the binary representations of both the numbers, now if they are equal then the answer is Yes or else the answer is No.
Below is the implementation of the above approach:
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function that returns true if the
// binary representation of b can be
// generated by permuting the
// binary digits of a
bool isPossible(int a, int b)
{
 
    // Find the count of set bits
    // in both the integers
    int cntA = __builtin_popcount(a);
    int cntB = __builtin_popcount(b);
 
    // If both the integers have
    // equal count of set bits
    if (cntA == cntB)
        return true;
    return false;
}
 
// Driver code
int main()
{
    int a = 3, b = 9;
 
    if (isPossible(a, b))
        cout << "Yes";
    else
        cout << "No";
 
    return 0;
}
Java



// Java implementation of the approach
class GFG
{
     
    // recursive function to count set bits
    public static int countSetBits(int n)
    {
 
        // base case
        if (n == 0)
            return 0;
        else
 
            // if last bit set add 1 else add 0
            return (n & 1) + countSetBits(n >> 1);
    }
     
    // Function that returns true if the
    // binary representation of b can be
    // generated by permuting the
    // binary digits of a
    static boolean isPossible(int a, int b)
    {
     
        // Find the count of set bits
        // in both the integers
        int cntA = countSetBits(a);
        int cntB = countSetBits(b);
     
        // If both the integers have
        // equal count of set bits
        if (cntA == cntB)
            return true;
        return false;
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int a = 3, b = 9;
     
        if (isPossible(a, b))
            System.out.println("Yes");
        else
            System.out.println("No");
    }
}
 
// This code is contributed by AnkitRai01
Python3



# Python3 implementation of the approach
 
# function to count set bits
def bitsoncount(x):
    return bin(x).count('1')
 
# Function that returns true if the
# binary representation of b can be
# generated by permuting the
# binary digits of a
def isPossible(a, b):
 
    # Find the count of set bits
    # in both the integers
    cntA = bitsoncount(a);
    cntB = bitsoncount(b);
 
    # If both the integers have
    # equal count of set bits
    if (cntA == cntB):
        return True
    return False
 
# Driver code
a = 3
b = 9
 
if (isPossible(a, b)):
    print("Yes")
else:
    print("No")
 
# This code is contributed by Sanjit Prasad
C#



// C# implementation of the approach
using System;
using System.Collections.Generic;
 
class GFG
{
     
    // recursive function to count set bits
    public static int countSetBits(int n)
    {
 
        // base case
        if (n == 0)
            return 0;
        else
 
            // if last bit set.Add 1 else.Add 0
            return (n & 1) + countSetBits(n >> 1);
    }
     
    // Function that returns true if the
    // binary representation of b can be
    // generated by permuting the
    // binary digits of a
    static bool isPossible(int a, int b)
    {
     
        // Find the count of set bits
        // in both the integers
        int cntA = countSetBits(a);
        int cntB = countSetBits(b);
     
        // If both the integers have
        // equal count of set bits
        if (cntA == cntB)
            return true;
        return false;
    }
     
    // Driver code
    public static void Main (String[] args)
    {
        int a = 3, b = 9;
     
        if (isPossible(a, b))
            Console.WriteLine("Yes");
        else
            Console.WriteLine("No");
    }
}
 
// This code is contributed by Rajput-Ji
Javascript



<script>
    // Javascript implementation of the approach
     
    // recursive function to count set bits 
    function countSetBits(n) 
    { 
   
        // base case 
        if (n == 0) 
            return 0; 
        else
   
            // if last bit set add 1 else add 0 
            return (n & 1) + countSetBits(n >> 1); 
    } 
       
    // Function that returns true if the 
    // binary representation of b can be 
    // generated by permuting the 
    // binary digits of a 
    function isPossible(a, b) 
    { 
       
        // Find the count of set bits 
        // in both the integers 
        let cntA = countSetBits(a); 
        let cntB = countSetBits(b); 
       
        // If both the integers have 
        // equal count of set bits 
        if (cntA == cntB) 
            return true; 
        return false; 
    } 
     
    let a = 3, b = 9; 
       
    if (isPossible(a, b)) 
      document.write("Yes"); 
    else
      document.write("No"); 
 
// This code is contributed by divyesh072019.
</script>
Output: 
Yes
 
Time Complexity: O(1)
Auxiliary Space: O(1)

My Personal Notes
arrow_drop_up
Previous
What is FinTech?
Next

Create a directory in Python
Recommended Articles
Page :
Largest palindromic number by permuting digits
03, Apr 18
Number formed by deleting digits such that sum of the digits becomes even and the number odd
26, Feb 20
Count of numbers upto N digits formed using digits 0 to K-1 without any adjacent 0s
03, Jul 20
Sum of all numbers that can be formed with permutations of n digits
26, Oct 16
Find maximum number that can be formed using digits of a given number
01, Aug 17
Maximum possible time that can be formed from four digits
11, Dec 18
Count of alphabets whose ASCII values can be formed with the digits of N
31, Jan 19
Greatest number less than equal to B that can be formed from the digits of A
27, Feb 19
Find the count of numbers that can be formed using digits 3, 4 only and having length at max N.
05, Mar 19
Find the largest number that can be formed by changing at most K digits
30, Sep 19
Largest number divisible by 50 that can be formed from a given set of N digits consisting of 0s and 7s only
03, Feb 21
Maximum possible time that can be formed from four digits | (Recursive Approach)
28, Oct 21
Count all prime numbers that can be formed using digits of a given number
26, Jul 21
Numbers of Length N having digits A and B and whose sum of digits contain only digits A and B
31, Jan 19
Minimum digits to be removed to make either all digits or alternating digits same
15, Aug 20
Check if the number formed by the last digits of N numbers is divisible by 10 or not
26, Sep 19
Count numbers from a given range that can be expressed as sum of digits raised to the power of count of digits
02, Mar 21
Check if a right-angled triangle can be formed by the given coordinates
21, Jul 20
Check if a right-angled triangle can be formed by moving any one of the coordinates
20, Sep 19
Check if N rectangles of equal area can be formed from (4 * N) integers
06, Jan 20
Check whether a straight line can be formed using N co-ordinate points
07, May 20
Check if a right-angled triangle can be formed by the given side lengths
11, Nov 20
Check if a Regular Bracket Sequence can be formed with concatenation of given strings
20, Sep 21
Check if sum of digits in the left half is divisible by sum of digits in the right half in the largest permutation of N
15, Jun 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
DiptayanBiswas
@DiptayanBiswas
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!