Given two numbers m and n. Find the position of the rightmost different bit in the binary representation of numbers. It is guaranteed that such a bit exists

Examples:

Input: m = 11, n = 9
Output: 2
Explanation: (11)₁₀ = (1011)₂, (9)₁₀ = (1001)₂
It can be seen that 2nd bit from the right is different
Input: m = 52, n = 4
Output: 5
Explanation: (52)₁₀ = (110100)₂,(4)₁₀ = (100)₂, can also be written as = (000100)₂
It can be seen that 5th bit from the right is different

Try It Yourself

Table of Content

Position of rightmost different bit using XOR:
Position of rightmost different bit using ffs() function:

Position of rightmost different bit using XOR:

Get the bitwise xor of m and n. Let it be xor_value = m ^ n. Now, find the position of rightmost set bit in xor_value. As 0 XOR 1 and 1 XOR 0 equals 1, so if a bit is set in the XOR value then it means that the bits at that position were different in the given numbers

An efficient way to find the rightmost set bit:

For n = 10, which is 00001010 in binary, we can find the position of its rightmost set bit using the expression log2(n & -n) + 1. First, we calculate -n using two's complement by inverting the bits of 10 to get 11110101 and adding 1 to obtain 11110110. Performing (n & -n) gives 00000010, which is 2 in decimal. Taking log2(2) results in 1, and adding 1 gives us 2, indicating that the rightmost set bit of 10 is at position 2 from the right. This method efficiently isolates the rightmost set bit and calculates its position using bitwise operations and logarithms.

C++

#include <bits/stdc++.h>
using namespace std;

// Function to find the position of
// rightmost set bit in 'n'
// returns 0 if there is no set bit.
int getRightMostSetBit(int n)
{
    // to handle edge case when n = 0.
    if (n == 0)
        return 0;

    return log2(n & -n) + 1;
}

// Function to find the position of
// rightmost different bit in the
// binary representations of 'm' and 'n'
// returns 0 if there is no
// rightmost different bit.
int posOfRightMostDiffBit(int m, int n)
{
    // position of rightmost different
    //  bit

    return getRightMostSetBit(m ^ n);
}

int main()
{
    int m = 52, n = 4;

    cout  << posOfRightMostDiffBit(m, n) << endl;
    return 0;
}

Java

class GFG {

    // Function to find the position of
    // rightmost set bit in 'n'
    // return 0 if there is no set bit.
    static int getRightMostSetBit(int n)
    {
        if (n == 0)
            return 0;

        return (int)((Math.log10(n & -n)) / Math.log10(2))
            + 1;
    }

    // Function to find the position of
    // rightmost different bit in the
    // binary representations of 'm' and 'n'
    static int posOfRightMostDiffBit(int m, int n)
    {
        // position of rightmost different bit
        return getRightMostSetBit(m ^ n);
    }


    public static void main(String arg[])
    {
        int m = 52, n = 4;


        System.out.print( + posOfRightMostDiffBit(m, n));
    }
}

Python

import math

# Function to find the position of
# rightmost set bit in 'n'


def getRightMostSetBit(n):
    if (n == 0):
        return 0

    return math.log2(n & -n) + 1


# Function to find the position of
# rightmost different bit in the
# binary representations of 'm' and 'n'
def posOfRightMostDiffBit(m, n):

    # position of rightmost different
    # bit
    return getRightMostSetBit(m ^ n)



if __name__ == "__main__":
    m = 52
    n = 4
    print(int(posOfRightMostDiffBit(m, n)))

using System;

class GFG {

    // Function to find the position of
    // rightmost set bit in 'n'
    static int getRightMostSetBit(int n)
    {
        if (n == 0)
            return 0;
        return (int)((Math.Log10(n & -n)) / Math.Log10(2))
            + 1;
    }

    // Function to find the position of
    // rightmost different bit in the
    // binary representations of 'm' and 'n'
    static int posOfRightMostDiffBit(int m, int n)
    {
        // position of rightmost different bit
        return getRightMostSetBit(m ^ n);
    }

    // Driver code
    public static void Main()
    {
        int m = 52, n = 4;

        // Function call
        Console.Write( posOfRightMostDiffBit(m, n));
    }
}

JavaScript

// Function to find the position 
// of rightmost set bit in 'n'
function getRightMostSetBit(n) {
    if (n === 0)
        return 0;

    return Math.log2(n & -n) + 1;
}

// Function to find the position
// of rightmost different bit
function posOfRightMostDiffBit(m, n) {
    return getRightMostSetBit(m ^ n);
}

// Driver code
let m = 52, n = 4;

console.log(posOfRightMostDiffBit(m, n));

PHP

<?php


// Function to find the position 
// of rightmost set bit in 'n'
function getRightMostSetBit($n)
{
    if ($n == 0)
      return 0;
    return log($n & -$n, (2)) + 1;
}

// Function to find the position of 
// rightmost different bit in the 
// binary representations of 'm' 
// and 'n'
function posOfRightMostDiffBit($m, $n)
{
    
    // position of rightmost
    // different bit
    return getRightMostSetBit($m ^ $n);
}


    $m = 52;
    $n = 4;
    echo posOfRightMostDiffBit($m, $n);

?>

Output

Time Complexity: O(log₂ N), this time complexity is equal to O(1) as one has to check for at most 31 bits only
Auxiliary Space: O(1)

Position of rightmost different bit using ffs() function:

ffs() function searches the first set bit from the right side and then returns the index of that bit (1-based indexing). So we can use this function on the XOR of both the values to get the index of the rightmost different bit

C++

#include <bits/stdc++.h>
using namespace std;

// function to find rightmost different
//  bit in two numbers.
int posOfRightMostDiffBit(int m, int n)
{
    return ffs(m ^ n);
}


int main()
{
    int m = 52, n = 4;

    // Function call
    cout << posOfRightMostDiffBit(m, n);
    return 0;
}