Count of operations to make numbers equal by adding power of 2

Last Updated : 28 Jul, 2022

Given three positive integers X, Y, and Z and an integer N, the task is to make them equal by adding 2^i-1 for the i^th operation to any one of these 3 numbers. Find the number of moves required to make these 3 numbers equal where the total number of operations performed is N. If they cannot be made equal print -1.

Examples:

Input: X = 1, Y = 6, Z = 7, N = 30
Output: 3
Explanation: Here in first operation we add 2^1-1= 2⁰= 1 to Y so that it become equal to Z and in second move we add 2^2-1 = 2 to X and value of X become 3 and then in third move we add 2^3-1=4 to X such that its value become 7. Hence these three numbers are equal in 3 moves.

Input: X = 4, Y = 5, Z = 4, N = 20
Output: -1

Approach: The problem can be solved based on the following observation:

Observations:

Here 2^i-1 has one set bit i.e. 01,10,100,1000 and so on .

We have to convert these 3 numbers X, Y, and Z into binary numbers and make their least significant bit equal by adding 2^i-1to any one of these three numbers and doing same thing to each bit of the number until the most significant bit becomes equal also count the number of moves simultaneously.

After performing operation if all bits of these three numbers get equal then print the number of moves else print -1.

Follow the steps mentioned below to implement the idea:

Start iterating from i = 0 to N-1:
- Check if adding 2ⁱ to any number makes the ith least significant bit same for all of them.
- If not then return -1.
- Otherwise, continue the process till all the numbers are the same or N steps are performed.
If all the number becomes equal then return the steps required.

Below is the implementation of the above approach.

C++

// C++ code to implement the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if the bit is set or not
int chk(int n, int bit) { return ((n & bit) != 0) ? 1 : 0; }
 
// Function to find
// the minimum number of moves
int minMove(int X, int Y, int Z, int N)
{
    int count = 0;
    bool ans = true;
    for (int i = 0; i <= N; i++) {
 
        if (X == Y && Y == Z)
            break;
 
        // Left shifting of bit
        int bit = (1 << i);
 
        int cnt = chk(X, bit) + chk(Y, bit) + chk(Z, bit);
 
        if (cnt == 0 || cnt == 3) {
            ans = false;
            break;
        }
        else if (cnt == 1) {
            if (chk(X, bit) == 1)
                X += bit;
            else if (chk(Y, bit) == 1)
                Y += bit;
            else
                Z += bit;
        }
        else {
            if (chk(X, bit) == 0)
                X += bit;
            else if (chk(Y, bit) == 0)
                Y += bit;
            else
                Z += bit;
        }
        count++;
    }
    return (ans && X == Y && Y == Z) ? count : -1;
}
 
// Driver code
int main()
{
    int X = 1, Y = 6, Z = 7, N = 30;
 
    // Function call
    cout << minMove(X, Y, Z, N);
 
    return 0;
}
 
    // This code is contributed by rakeshsahni

Java

// Java code to implement the approach
 
import java.io.*;
 
class GFG {
     
    // Function to check if the bit is set or not
    static int chk(int n, int bit)
    {
        return ((n & bit) != 0) ? 1 : 0;
    }
   
    // Function to find
    // the minimum number of moves
    public static int minMove(int X, int Y, 
                              int Z, int N)
    {
        int count = 0;
        boolean ans = true;
        for (int i = 0; i <= N; i++) {
 
            if (X == Y && Y == Z)
                break;
 
            // Left shifting of bit
            int bit = (1 << i);
 
            int cnt
                = chk(X, bit) + chk(Y, bit) + chk(Z, bit);
 
            if (cnt == 0 || cnt == 3) {
                ans = false;
                break;
            }
            else if (cnt == 1) {
                if (chk(X, bit) == 1)
                    X += bit;
                else if (chk(Y, bit) == 1)
                    Y += bit;
                else
                    Z += bit;
            }
            else {
                if (chk(X, bit) == 0)
                    X += bit;
                else if (chk(Y, bit) == 0)
                    Y += bit;
                else
                    Z += bit;
            }
            count++;
        }
        return (ans && X == Y && Y == Z) ? count : -1;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int X = 1, Y = 6, Z = 7, N = 30;
 
        // Function call
        System.out.println(minMove(X, Y, Z, N));
    }
}

Python3

# Python code to implement the approach
 
# Function to check if the bit is set or not
def chk(n, bit):
    return 1 if (n & bit) != 0 else 0
 
# Function to find the minimum number of moves
def minMove(X, Y, Z, N):
    count = 0
    ans = True
    for i in range(N+1):
 
        if X == Y and Y == Z:
            break
 
        # Left shifting of bit
        bit = (1 << i)
 
        cnt = chk(X, bit) + chk(Y, bit) + chk(Z, bit)
 
        if cnt == 0 or cnt == 3:
            ans = False
            break
 
        elif cnt == 1:
            if chk(X, bit) == 1:
                X += bit
            elif chk(Y, bit) == 1:
                Y += bit
            else:
                Z += bit
 
        else:
            if chk(X, bit) == 0:
                X += bit
            elif chk(Y, bit) == 0:
                Y += bit
            else:
                Z += bit
        count += 1
    return count if ans and X == Y and Y == Z else -1
 
# Driver Code
if __name__ == '__main__':
    X = 1
    Y = 6
    Z = 7
    N = 30
    # Function call
    print(minMove(X, Y, Z, N))
 
# This code is contributed by Tapesh(tapeshdua420)

C#

// C# code to implement the approach
 
using System;
 
public class GFG {
     
    // Function to check if the bit is set or not
    static int chk(int n, int bit)
    {
        return ((n & bit) != 0) ? 1 : 0;
    }
   
    // Function to find
    // the minimum number of moves
    public static int minMove(int X, int Y, 
                              int Z, int N)
    {
        int count = 0;
        bool ans = true;
        for (int i = 0; i <= N; i++) {
 
            if (X == Y && Y == Z)
                break;
 
            // Left shifting of bit
            int bit = (1 << i);
 
            int cnt
                = chk(X, bit) + chk(Y, bit) + chk(Z, bit);
 
            if (cnt == 0 || cnt == 3) {
                ans = false;
                break;
            }
            else if (cnt == 1) {
                if (chk(X, bit) == 1)
                    X += bit;
                else if (chk(Y, bit) == 1)
                    Y += bit;
                else
                    Z += bit;
            }
            else {
                if (chk(X, bit) == 0)
                    X += bit;
                else if (chk(Y, bit) == 0)
                    Y += bit;
                else
                    Z += bit;
            }
            count++;
        }
        return (ans && X == Y && Y == Z) ? count : -1;
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        int X = 1, Y = 6, Z = 7, N = 30;
 
        // Function call
        Console.WriteLine(minMove(X, Y, Z, N));
    }
}
 
// This code contributed by shikhasingrajput

Javascript

<script>
// Javascript code to implement the approach
 
// Function to check if the bit is set or not
function chk(n,bit) { return ((n & bit) != 0) ? 1 : 0; }
 
// Function to find
// the minimum number of moves
function minMove( X, Y, Z, N)
{
    let count = 0;
    let ans = true;
    for (let i = 0; i <= N; i++) {
 
        if (X == Y && Y == Z)
            break;
 
        // Left shifting of bit
        let bit = (1 << i);
 
        let cnt = chk(X, bit) + chk(Y, bit) + chk(Z, bit);
 
        if (cnt == 0 || cnt == 3) {
            ans = false;
            break;
        }
        else if (cnt == 1) {
            if (chk(X, bit) == 1)
                X += bit;
            else if (chk(Y, bit) == 1)
                Y += bit;
            else
                Z += bit;
        }
        else {
            if (chk(X, bit) == 0)
                X += bit;
            else if (chk(Y, bit) == 0)
                Y += bit;
            else
                Z += bit;
        }
        count++;
    }
    return (ans && X == Y && Y == Z) ? count : -1;
}
 
// Driver code
    let X = 1, Y = 6, Z = 7, N = 30;
 
    // Function call
    document.write(minMove(X, Y, Z, N));
 
// This code is contributed by satwik4409.
    </script>