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

• Last Updated : 15 Jul, 2021

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:
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 * 2a1 * 3a2 * 7a3 and B = y * 2b1 * 3b2 * 7b3 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 ``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 = a1``    ``// va = a2``    ``// va = a3``    ``// va = 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 and vb 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 != vb)``        ``return` `-1;` `    ``// Minimum number of operations required``    ``int` `minOperations = ``abs``(va - vb)``                        ``+ ``abs``(va - vb)``                        ``+ ``abs``(va - vb);` `    ``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 Divisors(``int` `x)``    ``{``        ``// To keep count of each divisor``        ``int` `c = ``0``;` `        ``// To store the result``        ``Vector v = ``new` `Vector();` `        ``// 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 = a1``        ``// va = a2``        ``// va = a3``        ``// va = x``        ``Vector va = Divisors(a);` `        ``// Similarly for b``        ``Vector vb = Divisors(b);` `        ``// If a and b cannot be made equal``        ``// with the given operation. Note``        ``// that va and vb 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 = a1``    ``# va = a2``    ``# va = a3``    ``# va = 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 and vb 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 = a1``        ``// va = a2``        ``// va = a3``        ``// va = 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 and vb 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 != vb)``        ``{``            ``return` `-1;``        ``}` `        ``// Minimum number of operations required``        ``int` `minOperations = Math.Abs(va - vb) +``                            ``Math.Abs(va - vb) +``                            ``Math.Abs(va - vb);` `        ``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

 ``

## Javascript

 ``

Output:

`1`

My Personal Notes arrow_drop_up