 GeeksforGeeks App
Open App Browser
Continue

# Minimize steps to make two integers equal by incrementing them or doing bitwise OR of them

Given two positive integers A and B. The task is to make them equal using minimum operations such that:

• A = A + 1 (increase a by 1).
• B = B + 1 (increase b by 1).
• A = A | B (replace A with the bitwise OR of A and B).

Examples:

Input: A = 5, B = 9
Output: 4
Explanation: It is better to use first operation i.e increase A by 1 four times,
Input: A = 2, B = 5
Output: 2
Explanation: It is better to apply second operation then third operation,

Greedy Approach: The problem can be solved using Greedy technique with the help of Bit manipulation.

Intuition:

• Try to increase A or B by 1, the steps will be the maximum steps possible.
• Now to reduce these steps,
• We need to find an intermediate number X such that X OR B = B, because only then we can jump more than 1 number in a single step.
• Once we have found possible values for X, we can check that which value among them is reachable for A in least steps.
• Those least steps + 1 step (for doing bitwise OR of X with B) will be one of the lesser number of steps for A to reach B.
• Another way to reduce these steps:
• Consider the case when instead of making X OR B = B, we find possible values of Y such that A OR Y = Y, as B can also be moved as per given problem.
• So we can find least step needed to move B to Y and then add 1 more step to do bitwise OR of A with B.
• Now try to find the minimum among the both possible lesser steps as the required number of steps to change A to B.

Illustration:

Suppose A = 2, B = 5

Case 1: Possible value of X such that (X OR B = B) => [0, 1, 4, 5]
Now the steps required to convert A to B if we convert A to each possible value of X first, are:
Convert A to 0  => not possible as we cannot decrement A
Convert A to 1  => not possible as we cannot decrement A
Convert A to 4  => 2 increment operation, and then 1 operation for 4 OR 5 to make A as 5. Hence total operation = 3
Convert A to 5  => 3 increment operation to make A as 5. Hence total operation = 3
Case 2: Possible value of Y such that (A OR Y = Y) => [2, 6, 7, …]
Now the steps required to convert A to B if we convert B to each possible value of Y first, are:
Convert B to 2  => not possible as we cannot decrement B
Convert B to 6  => 1 increment operation, and then 1 operation for 2 OR 6 to make A as 6. Hence total operation = 2
Convert B to 7  => 2 increment operation, and then 1 operation for 2 OR 7 to make A as 7. Hence total operation = 3
Similarly for any conversion of B to value greater than 7 will take more steps.

Therefore the least steps required to convert A to B using given operations =  min(3, 2) = 2 steps.

Follow the steps mentioned below to implement the approach:

• Iterate from i = A to B and check if (i | B) is the same as B and the steps required for that.
• Find the minimum steps (say x) required to make A and B equal in this way.
• Now iterate for j = B to B+x:
• Check if that j satisfies case 2 as mentioned above.
• Update the minimum steps required to make A and B equal.
• Return the minimum number of steps.

Below is the implementation of the above approach:

## C++

 `// C++ code to implement the approach``#include ``using` `namespace` `std;` `// Function to find min steps``// to convert A to B``int` `AToB(``int` `a, ``int` `b)``{``    ``int` `ans = INT_MAX;` `    ``// If a is greater than b, swap them``    ``if` `(a > b) {``        ``int` `temp = b;``        ``b = a;``        ``a = temp;``    ``}` `    ``// Check for every i from 0 to b``    ``for` `(``int` `i = a; i <= b; i++) {` `        ``// If i or b equals to b then``        ``// update the answer``        ``if` `((i | b) == b) {``            ``int` `j = ``abs``(a - i);``            ``if` `(i != b)``                ``j++;``            ``ans = min(ans, j);``        ``}``    ``}` `    ``for` `(``int` `i = b + 1; i <= b + ans; i++) {``        ``if` `((i | a) == i) {``            ``ans = min(ans, i - b + 1);``        ``}``    ``}` `    ``return` `ans;``}` `// Driver Code``int` `main()``{``    ``int` `A = 2;``    ``int` `B = 5;``    ``cout << AToB(A, B);``    ``return` `0;``}` `// This code is contributed by Rohit Pradhan`

## Java

 `// Java code to implement the approach` `import` `java.io.*;``import` `java.lang.*;``class` `GFG {` `    ``// Function to find min steps``    ``// to convert A to B``    ``public` `static` `int` `AToB(``int` `a, ``int` `b)``    ``{``        ``int` `ans = Integer.MAX_VALUE;` `        ``// If a is greater than b, swap them``        ``if` `(a > b) {``            ``int` `temp = b;``            ``b = a;``            ``a = temp;``        ``}` `        ``// Check for every i from 0 to b``        ``for` `(``int` `i = a; i <= b; i++) {` `            ``// If i or b equals to b then``            ``// update the answer``            ``if` `((i | b) == b) {``                ``int` `j = Math.abs(a - i);``                ``if` `(i != b)``                    ``j++;``                ``ans = Math.min(ans, j);``            ``}``        ``}` `        ``for` `(``int` `i = b + ``1``; i <= b + ans; i++) {``            ``if` `((i | a) == i) {``                ``ans = Math.min(ans, i - b + ``1``);``            ``}``        ``}` `        ``return` `ans;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `A = ``2``;``        ``int` `B = ``5``;``        ``System.out.println(AToB(A, B));``    ``}``}`

## Python3

 `# Python3 code to implement the approach``INT_MAX ``=` `2147483647` `# Function to find min steps``# to convert A to B``def` `AToB(a, b):` `    ``ans ``=` `INT_MAX` `    ``# If a is greater than b, swap them``    ``if` `(a > b):``        ``temp ``=` `b``        ``b ``=` `a``        ``a ``=` `temp` `    ``# Check for every i from 0 to b``    ``for` `i ``in` `range``(a, b``+``1``):` `        ``# If i or b equals to b then``        ``# update the answer``        ``if` `((i | b) ``=``=` `b):``            ``j ``=` `abs``(a ``-` `i)``            ``if` `(i !``=` `b):``                ``j ``+``=` `1``            ``ans ``=` `min``(ans, j)` `    ``for` `i ``in` `range``(b``+``1``, b``+``ans``+``1``):``        ``if` `((i | a) ``=``=` `i):``            ``ans ``=` `min``(ans, i ``-` `b ``+` `1``)` `    ``return` `ans` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``A ``=` `2``    ``B ``=` `5``    ``print``(AToB(A, B))` `# This code is contributed by rakeshsahni`

## C#

 `// C# code to implement the above approach``using` `System;` `class` `GFG {` `  ``// Function to find min steps``  ``// to convert A to B``  ``public` `static` `int` `AToB(``int` `a, ``int` `b)``  ``{``    ``int` `ans = Int32.MaxValue;` `    ``// If a is greater than b, swap them``    ``if` `(a > b) {``      ``int` `temp = b;``      ``b = a;``      ``a = temp;``    ``}` `    ``// Check for every i from 0 to b``    ``for` `(``int` `i = a; i <= b; i++) {` `      ``// If i or b equals to b then``      ``// update the answer``      ``if` `((i | b) == b) {``        ``int` `j = Math.Abs(a - i);``        ``if` `(i != b)``          ``j++;``        ``ans = Math.Min(ans, j);``      ``}``    ``}` `    ``for` `(``int` `i = b + 1; i <= b + ans; i++) {``      ``if` `((i | a) == i) {``        ``ans = Math.Min(ans, i - b + 1);``      ``}``    ``}` `    ``return` `ans;``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main()``  ``{``    ``int` `A = 2;``    ``int` `B = 5;``    ``Console.Write(AToB(A, B));``  ``}``}` `// This code is contributed by sanjoy_62.`

## Javascript

 ``

Output

`2`

Time Complexity: O(B * log B)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up