Minimum multiplications with {2, 3, 7} to make two numbers equal

Given two numbers A and B, the task is to find the minimum number of operations required to make A and B equal. In each operation, any number can be divided by either 2, 3 or 7. If it is not possible then print -1.

Examples:

Input: A = 14, B = 28 
Output: 1 
Operation 1: A * 2 = 14 * 2 = 28 which is equal to B.

Input: A = 3, B = 5 
Output: -1 
No matter how many times the operation is performed, A and B will never be equal. 

Approach: A and B can be written as A = x * 2^a1 * 3^a2 * 7^a3 and B = y * 2^b1 * 3^b2 * 7^b3 where x and y are not divisible by 2, 3 and 7. Now,  

• If x != y then A and B cannot be made equal with the given operation.
• If x = y then the minimum operations required will be |a1 – b1| + |a2 – b2| + |a3 – b3| because both the numbers need to have equal powers of 2, 3 and 7.

Below is the implementation of the above approach:  

C++

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;

// Function to find powers of 2, 3 and 7 in x
vector<int> Divisors(int x)
{
    // To keep count of each divisor
    int c = 0;

    // To store the result
    vector<int> v;

    // Count powers of 2 in x
    while (x % 2 == 0) {
        c++;
        x /= 2;
    }
    v.push_back(c);

    c = 0;

    // Count powers of 3 in x
    while (x % 3 == 0) {
        c++;
        x /= 3;
    }
    v.push_back(c);

    c = 0;

    // Count powers of 7 in x
    while (x % 7 == 0) {
        c++;
        x /= 7;
    }
    v.push_back(c);

    // Remaining number which is not
    // divisible by 2, 3 or 7
    v.push_back(x);

    return v;
}

// Function to return the minimum number of
// given operations required to make a and b equal
int MinOperations(int a, int b)
{
    // a = x * 2^a1 * 3^a2 * 7^a3
    // va[0] = a1
    // va[1] = a2
    // va[2] = a3
    // va[3] = x
    vector<int> va = Divisors(a);

    // Similarly for b
    vector<int> vb = Divisors(b);

    // If a and b cannot be made equal
    // with the given operation. Note
    // that va[3] and vb[3] contain
    // remaining numbers after repeated
    // divisions with 2, 3 and 7.
    // If remaining numbers are not same
    // then we cannot make them equal.
    if (va[3] != vb[3])
        return -1;

    // Minimum number of operations required
    int minOperations = abs(va[0] - vb[0])
                        + abs(va[1] - vb[1])
                        + abs(va[2] - vb[2]);

    return minOperations;
}

// Driver code
int main()
{
    int a = 14, b = 28;
    cout << MinOperations(a, b);

    return 0;
}

Java

// Java implementation of above approach
import java.util.Vector;

class GFG
{

    // Function to find powers of 2, 3 and 7 in x
    static Vector<Integer> Divisors(int x)
    {
        // To keep count of each divisor
        int c = 0;

        // To store the result
        Vector<Integer> v = new Vector<Integer>();

        // Count powers of 2 in x
        while (x % 2 == 0)
        {
            c++;
            x /= 2;
        }
        v.add(c);

        c = 0;

        // Count powers of 3 in x
        while (x % 3 == 0)
        {
            c++;
            x /= 3;
        }
        v.add(c);

        c = 0;

        // Count powers of 7 in x
        while (x % 7 == 0)
        {
            c++;
            x /= 7;
        }
        v.add(c);

        // Remaining number which is not
        // divisible by 2, 3 or 7
        v.add(x);

        return v;
    }

    // Function to return the minimum number of
    // given operations required to make a and b equal
    static int MinOperations(int a, int b)
    {
        // a = x * 2^a1 * 3^a2 * 7^a3
        // va[0] = a1
        // va[1] = a2
        // va[2] = a3
        // va[3] = x
        Vector<Integer> va = Divisors(a);

        // Similarly for b
        Vector<Integer> vb = Divisors(b);

        // If a and b cannot be made equal
        // with the given operation. Note
        // that va[3] and vb[3] contain
        // remaining numbers after repeated
        // divisions with 2, 3 and 7.
        // If remaining numbers are not same
        // then we cannot make them equal.
        if (va.get(3) != vb.get(3))
        {
            return -1;
        }

        // Minimum number of operations required
        int minOperations = Math.abs(va.get(0) - vb.get(0))
                + Math.abs(va.get(1) - vb.get(1))
                + Math.abs(va.get(2) - vb.get(2));

        return minOperations;
    }

    // Driver code
    public static void main(String[] args)
    {
        int a = 14, b = 28;
        System.out.println(MinOperations(a, b));
    }
}

// This code is contributed by Rajput-JI

Python3

# python 3 implementation of the approach

# Function to find powers of 2, 3 and 7 in x
def Divisors(x):
    # To keep count of each divisor
    c = 0

    # To store the result
    v = []

    # Count powers of 2 in x
    while (x % 2 == 0):
        c += 1
        x /= 2

    v.append(c)

    c = 0

    # Count powers of 3 in x
    while (x % 3 == 0):
        c += 1
        x /= 3

    v.append(c)

    c = 0

    # Count powers of 7 in x
    while (x % 7 == 0):
        c += 1
        x /= 7

    v.append(c)

    # Remaining number which is not
    # divisible by 2, 3 or 7
    v.append(x)

    return v

# Function to return the minimum number of
# given operations required to make a and b equal
def MinOperations(a, b):
    # a = x * 2^a1 * 3^a2 * 7^a3
    # va[0] = a1
    # va[1] = a2
    # va[2] = a3
    # va[3] = x
    va = Divisors(a)

    # Similarly for b
    vb = Divisors(b)

    # If a and b cannot be made equal
    # with the given operation. Note
    # that va[3] and vb[3] contain
    # remaining numbers after repeated
    # divisions with 2, 3 and 7.
    # If remaining numbers are not same
    # then we cannot make them equal.
    if (va[3] != vb[3]):
        return -1

    # Minimum number of operations required
    minOperations = abs(va[0] - vb[0]) + abs(va[1] - vb[1]) + abs(va[2] - vb[2])

    return minOperations

# Driver code
if __name__ == '__main__':
    a = 14
    b = 28
    print(MinOperations(a, b))

# This code is contributed by
# Sanjit_Prasad

C#

// C# implementation of above approach
using System;
using System.Collections.Generic;

class GFG
{

    // Function to find powers
    // of 2, 3 and 7 in x
    static List<int> Divisors(int x)
    {
        // To keep count of each divisor
        int c = 0;

        // To store the result
        List<int> v = new List<int>();

        // Count powers of 2 in x
        while (x % 2 == 0)
        {
            c++;
            x /= 2;
        }
        v.Add(c);

        c = 0;

        // Count powers of 3 in x
        while (x % 3 == 0)
        {
            c++;
            x /= 3;
        }
        v.Add(c);

        c = 0;

        // Count powers of 7 in x
        while (x % 7 == 0)
        {
            c++;
            x /= 7;
        }
        v.Add(c);

        // Remaining number which is not
        // divisible by 2, 3 or 7
        v.Add(x);

        return v;
    }

    // Function to return the minimum
    // number of given operations required
    // to make a and b equal
    static int MinOperations(int a, int b)
    {
        // a = x * 2^a1 * 3^a2 * 7^a3
        // va[0] = a1
        // va[1] = a2
        // va[2] = a3
        // va[3] = x
        List<int> va = Divisors(a);

        // Similarly for b
        List<int> vb = Divisors(b);

        // If a and b cannot be made equal
        // with the given operation. Note
        // that va[3] and vb[3] contain
        // remaining numbers after repeated
        // divisions with 2, 3 and 7.
        // If remaining numbers are not same
        // then we cannot make them equal.
        if (va[3] != vb[3])
        {
            return -1;
        }

        // Minimum number of operations required
        int minOperations = Math.Abs(va[0] - vb[0]) +
                            Math.Abs(va[1] - vb[1]) +
                            Math.Abs(va[2] - vb[2]);

        return minOperations;
    }

    // Driver code
    public static void Main(String[] args)
    {
        int a = 14, b = 28;
        Console.WriteLine(MinOperations(a, b));
    }
}

// This code is contributed by
// PrinciRaj1992

PHP

<?php
// PHP implementation of the approach

// Function to find powers of 2, 3 and 7 in x
function Divisors($x)
{
    // To keep count of each divisor
    $c = 0;

    // To store the result
    $v = array();

    // Count powers of 2 in x
    while ($x % 2 == 0)
    {
        $c++;
        $x = floor($x / 2);
    }
    array_push($v, $c);

    $c = 0;

    // Count powers of 3 in x
    while ($x % 3 == 0)
    {
        $c++;
        $x = floor($x / 3);
    }
    array_push($v, $c) ;

    $c = 0;

    // Count powers of 7 in x
    while ($x % 7 == 0)
    {
        $c++;
        $x = floor($x / 7);
    }
    array_push($v, $c);

    // Remaining number which is not
    // divisible by 2, 3 or 7
    array_push($v, $x);

    return $v;
}

// Function to return the minimum number
// of given operations required to make
// a and b equal
function MinOperations($a, $b)
{

    // a = x * 2^a1 * 3^a2 * 7^a3
    // va[0] = a1
    // va[1] = a2
    // va[2] = a3
    // va[3] = x
    $va = Divisors($a);

    // Similarly for b
    $vb = Divisors($b);

    // If a and b cannot be made equal
    // with the given operation. Note
    // that va[3] and vb[3] contain
    // remaining numbers after repeated
    // divisions with 2, 3 and 7.
    // If remaining numbers are not same
    // then we cannot make them equal.
    if ($va[3] != $vb[3])
        return -1;

    // Minimum number of operations required
    $minOperations = abs($va[0] - $vb[0]) +
                     abs($va[1] - $vb[1]) +
                     abs($va[2] - $vb[2]);

    return $minOperations;
}

// Driver code
$a = 14 ;
$b = 28 ;
echo MinOperations($a, $b);

// This code is contributed by Ryuga
?>

Javascript

<script>
// javascript implementation of above approach

    // Function to find powers of 2, 3 and 7 in x
    function Divisors(x)
    {

        // To keep count of each divisor
        var c = 0;

        // To store the result
        var v = [];

        // Count powers of 2 in x
        while (x % 2 == 0) {
            c++;
            x /= 2;
        }
        v.push(c);

        c = 0;

        // Count powers of 3 in x
        while (x % 3 == 0) {
            c++;
            x /= 3;
        }
        v.push(c);

        c = 0;

        // Count powers of 7 in x
        while (x % 7 == 0) {
            c++;
            x /= 7;
        }
        v.push(c);

        // Remaining number which is not
        // divisible by 2, 3 or 7
        v.push(x);

        return v;
    }

    // Function to return the minimum number of
    // given operations required to make a and b equal
    function MinOperations(a , b) {
        // a = x * 2^a1 * 3^a2 * 7^a3
        // va[0] = a1
        // va[1] = a2
        // va[2] = a3
        // va[3] = x
        var va = Divisors(a);

        // Similarly for b
        var vb = Divisors(b);

        // If a and b cannot be made equal
        // with the given operation. Note
        // that va[3] and vb[3] contain
        // remaining numbers after repeated
        // divisions with 2, 3 and 7.
        // If remaining numbers are not same
        // then we cannot make them equal.
        if (va[3] != vb[3]) {
            return -1;
        }

        // Minimum number of operations required
        var minOperations = Math.abs(va[0] - vb[0]) + Math.abs(va[1] - vb[1])
                + Math.abs(va[2] - vb[2]);

        return minOperations;
    }

    // Driver code
        var a = 14, b = 28;
        document.write(MinOperations(a, b));

// This code is contributed by aashish1995
</script>

Output:

1

Time Complexity: O(log₂x) + O(log₃x) + O(log₇x)
Auxiliary Space: O(c), where c is the count of each divisor