Find position of left most dis-similar bit for two numbers
Given two numbers n1 and n2. The task is to find the position of first mismatching bit in the binary representation of the two numbers from left. We need to find this bit after making lengths of binary representations of both numbers same. We make lengths same by appending 0s in the smaller number.
Note:
- For Example: n1 = 1, n2 = 7. Bitwise representation of n1 and n4 will be “1” and “111” respectively. Append two zeros to n1 to make it 100.
- Print zero if n1 is equal to n2.
Examples:
Input: n1 = 12, n2 = 34 Output: 2 Binary representation of 12 is 1100 and of 34 is 100010. First make both representations of the same length by appending 0s. So the first representation now becomes 11000. The second bit is the different bit. Input: n1 = 1, n2 = 2 Output: 2
For finding the position of leftmost dis-similar bit among bit representaion of two numbers, either bit by bit comparison can be done or a derived formula can be used. Although the time complexity for both is same.
For finding the left most dis-similar bit first of all equalize the bit length of both numbers by multiply the smaller one with pow(2, bit-length Difference). After making bit-length equal take XOR of both number. Now, leftmost dis-similar bit is clearly reflected in XOR value. Subtracting the bit-length of XOR value from bit-length of given number plus 1 is the position of leftmost dis-similar bit can be concluded.
Algorithm:
- Find bit length of n1 & n2.
- Equalize bit-length of both number by placing zero to right of smaller number (same as multiplying smaller one by pow(2, bit-length Difference) )
- Take XOR of both number
- Difference of bit-length of any number and bit-length of XOR value is required answer plus 1
Below is the implementation of the above approach:
C++
// C++ program to find the leftmost // position of first dis-similar bit #include <bits/stdc++.h> using namespace std; // Function to find first dis-similar bit int bitPos(int n1, int n2) { // return zero for equal number if (n1 == n2) return 0; /** find the 1st dis-similar bit **/ // count bit length of n1 and n2 int bitCount1 = floor(log2(n1)) + 1; int bitCount2 = floor(log2(n2)) + 1; // find bit difference and maxBit int bitDiff = abs(bitCount1 - bitCount2); int maxBitCount = max(bitCount1, bitCount2); if (bitCount1 > bitCount2) { n2 = n2 * pow(2, bitDiff); } else { n1 = n1 * pow(2, bitDiff); } int xorValue = n1 ^ n2; int bitCountXorValue = floor(log2(xorValue)) + 1; int disSimilarBitPosition = maxBitCount - bitCountXorValue + 1; return disSimilarBitPosition; } // Driver program int main() { int n1 = 53, n2 = 55; cout << bitPos(n1, n2); return 0; } |
chevron_right
filter_none
Java
// Java program to find the leftmost position of // first dis-similar bit import java.io.*; class GFG { // Function to find first dis-similar bit static int bitPos(int n1, int n2) { // return zero for equal number if (n1 == n2) return 0; /** find the 1st dis-similar bit **/ // count bit length of n1 and n2 int bitCount1 = (int)Math.floor(Math.log(n1) / Math.log(2)) + 1; int bitCount2 = (int)Math.floor(Math.log(n2) / Math.log(2)) + 1; // find bit difference and maxBit int bitDiff = Math.abs(bitCount1 - bitCount2); int maxBitCount = Math.max(bitCount1, bitCount2); if (bitCount1 > bitCount2) { n2 = n2 * (int)Math.pow(2, bitDiff); } else { n1 = n1 * (int)Math.pow(2, bitDiff); } int xorValue = n1 ^ n2; int bitCountXorValue = (int)Math.floor(Math.log(xorValue) / Math.log(2)) + 1; int disSimilarBitPosition = maxBitCount - bitCountXorValue + 1; return disSimilarBitPosition; } // Driver Code public static void main (String[] args) { int n1 = 53, n2 = 55; System.out.println(bitPos(n1, n2)); } } // This code is contributed by ajit |
chevron_right
filter_none
Python3
# Python 3 program to Find the leftmost # position of first dis-similar bit # from math lib import floor() # and log2() from math import floor, log2 # Function to find first # dis-similar bit def bitPos(n1, n2) : # return zero for equal number if n1 == n2 : return 0 # find the 1st dis-similar bit # count bit length of n1 and n bitCount1 = floor(log2(n1)) + 1 bitCount2 = floor(log2(n2)) + 1 # find bit difference and maxBit bitDiff = abs(bitCount1 - bitCount2) maxBitCount = max(bitCount1, bitCount2) if (bitCount1 > bitCount2) : n2 *= pow(2, bitDiff) else : n1 *= pow(2, bitDiff) xorValue = n1 ^ n2 bitCountXorValue = floor(log2(xorValue)) + 1 disSimilarBitPosition = (maxBitCount - bitCountXorValue + 1) return disSimilarBitPosition # Driver code if __name__ == "__main__" : n1, n2 = 53, 55 print(bitPos(n1, n2)) # This code is contributed by Ryuga |
chevron_right
filter_none
C#
// C# to find the leftmost position of // first dis-similar bit using System; class GFG { // Function to find first dis-similar bit static int bitPos(int n1, int n2) { // return zero for equal number if (n1 == n2) return 0; /** find the 1st dis-similar bit **/ // count bit length of n1 and n2 int bitCount1 = (int)Math.Floor(Math.Log(n1) / Math.Log(2)) + 1; int bitCount2 = (int)Math.Floor(Math.Log(n2) / Math.Log(2)) + 1; // find bit difference and maxBit int bitDiff = Math.Abs(bitCount1 - bitCount2); int maxBitCount = Math.Max(bitCount1, bitCount2); if (bitCount1 > bitCount2) { n2 = n2 * (int)Math.Pow(2, bitDiff); } else { n1 = n1 * (int)Math.Pow(2, bitDiff); } int xorValue = n1 ^ n2; int bitCountXorValue = (int)Math.Floor(Math.Log(xorValue) / Math.Log(2)) + 1; int disSimilarBitPosition = maxBitCount - bitCountXorValue + 1; return disSimilarBitPosition; } // Driver Code public static void Main() { int n1 = 53, n2 = 55; Console.Write(bitPos(n1, n2)); } } // This code is contributed // by Akanksha Rai |
chevron_right
filter_none
PHP
<?php // PHP program to find the leftmost // position of first dis-similar bit // Function to find first dis-similar bit function bitPos($n1, $n2) { // return zero for equal number if ($n1 == $n2) return 0; /** find the 1st dis-similar bit **/ // count bit length of n1 and n2 $bitCount1 = floor(log($n1, 2)) + 1; $bitCount2 = floor(log($n2, 2)) + 1; // find bit difference and maxBit $bitDiff = abs($bitCount1 - $bitCount2); $maxBitCount = max($bitCount1, $bitCount2); if ($bitCount1 > $bitCount2) { $n2 = $n2 * pow(2, $bitDiff); } else { $n1 = $n1 * pow(2, $bitDiff); } $xorValue = $n1 ^ $n2; $bitCountXorValue = floor(log($xorValue, 2)) + 1; $disSimilarBitPosition = $maxBitCount - $bitCountXorValue + 1; return $disSimilarBitPosition; } // Driver Code $n1 = 53; $n2 = 55; echo bitPos($n1, $n2); // This code is contributed by ajit ?> |
chevron_right
filter_none
Output:
5
Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.
Recommended Posts:
- Check whether the two numbers differ at one bit position only
- Position of rightmost common bit in two numbers
- Find position of the only set bit
- Find the value at kth position in the generated array
- Find letter's position in Alphabet using Bit operation
- Find position of given term in a series formed with only digits 4 and 7 allowed
- Find two numbers from their sum and XOR
- Find k numbers which are powers of 2 and have sum N | Set 1
- Find the XOR of first N Prime Numbers
- Find XOR of numbers from the range [L, R]
- Find average of two numbers using bit operation
- Find N distinct numbers whose bitwise Or is equal to K
- Find Two Missing Numbers | Set 2 (XOR based solution)
- Find the count of distinct numbers in a range
- Find the two numbers with odd occurrences in an unsorted array
- Find the total count of numbers up to N digits in a given base B
- Find Unique pair in an array with pairs of numbers
- Set the Left most unset bit
- Position of rightmost set bit
- Modify a bit at a given position
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.
- Sum of bit differences for numbers from 0 to N
- Partition of a set into K subsets with equal sum using BitMask and DP
- Maximum number of 0s that can be flipped such that Array has no adjacent 1s
- Find position of given term in a series formed with only digits 4 and 7 allowed
- Minimum bit flips such that every K consecutive bits contain at least one set bit
- Minimum flips required to form given binary string where every flip changes all bits to its right as well
- C program to count zeros and ones in binary representation of a number
- Find array sum using Bitwise OR after splitting given array in two halves after K circular shifts
- Count of pairs from Array with sum equal to twice their bitwise AND
- Count of integers up to N which represent a Binary number