# Minimum prime number operations to convert A to B

Given two integers **A** and **B**, the task is to convert **A** to **B** with a minimum number of the following operations:

- Multiply
**A**by any**prime number**. - Divide
**A**by one of its**prime divisors**.

Print the minimum number of operations required.**Examples:**

Input:A = 10, B = 15Output:2

Operation 1: 10 / 2 = 5

Operation 2: 5 * 3 = 15Input:A = 9, B = 7Output:3

**Naive Approach:** If prime factorization of **A = p _{1}^{q}_{1} * p_{2}^{q}_{2} * … * p_{n}^{q}_{n}**. If we multiply

**A**by some prime then

**q**for that prime will increase by

_{i}**1**and if we divide

**A**by one of its prime factors then

**q**for that prime will decrease by

_{i}**1**. So for a prime

**p**if it occurs

**q**times in prime factorization of

_{A}**A**and

**q**times in prime factorization of

_{B}**B**then we only need to find the

**sum of |q**for all the primes to get a minimum number of operations.

_{A}– q_{B}|**Efficient Approach:** Eliminate all the common factors of **A** and **B** by dividing both **A** and **B** by their GCD. If **A** and **B** have no common factors then we only need the sum of powers of their prime factors to convert **A** to **B**.

Below is the implementation of the above approach:

## C++

`// C++ implementation of above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to return the count of` `// prime factors of a number` `int` `countFactors(` `int` `n)` `{` ` ` `int` `factors = 0;` ` ` `for` `(` `int` `i = 2; i * i <= n; i++) {` ` ` `while` `(n % i == 0) {` ` ` `n /= i;` ` ` `factors += 1;` ` ` `}` ` ` `}` ` ` `if` `(n != 1)` ` ` `factors++;` ` ` `return` `factors;` `}` `// Function to return the minimum number of` `// given operations required to convert A to B` `int` `minOperations(` `int` `A, ` `int` `B)` `{` ` ` `int` `g = __gcd(A, B); ` `// gcd(A, B);` ` ` `// Eliminate the common` ` ` `// factors of A and B` ` ` `A /= g;` ` ` `B /= g;` ` ` `// Sum of prime factors` ` ` `return` `countFactors(A) + countFactors(B);` `}` `// Driver code` `int` `main()` `{` ` ` `int` `A = 10, B = 15;` ` ` `cout << minOperations(A, B);` ` ` `return` `0;` `}` |

## Java

`// Java implementation of above approach` `import` `java .io.*;` `class` `GFG` `{` ` ` `// Function to return the count of` `// prime factors of a number` `static` `int` `countFactors(` `int` `n)` `{` ` ` `int` `factors = ` `0` `;` ` ` `for` `(` `int` `i = ` `2` `; i * i <= n; i++)` ` ` `{` ` ` `while` `(n % i == ` `0` `)` ` ` `{` ` ` `n /= i;` ` ` `factors += ` `1` `;` ` ` `}` ` ` `}` ` ` `if` `(n != ` `1` `)` ` ` `factors++;` ` ` `return` `factors;` `}` `static` `int` `__gcd(` `int` `a, ` `int` `b)` `{` ` ` `if` `(b == ` `0` `)` ` ` `return` `a;` ` ` `return` `__gcd(b, a % b);` `}` `// Function to return the minimum` `// number of given operations` `// required to convert A to B` `static` `int` `minOperations(` `int` `A, ` `int` `B)` `{` ` ` `int` `g = __gcd(A, B); ` `// gcd(A, B);` ` ` `// Eliminate the common` ` ` `// factors of A and B` ` ` `A /= g;` ` ` `B /= g;` ` ` `// Sum of prime factors` ` ` `return` `countFactors(A) + countFactors(B);` `}` `// Driver code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `A = ` `10` `, B = ` `15` `;` ` ` `System.out.println(minOperations(A, B));` `}` `}` `// This code is contributed` `// by Code_Mech` |

## Python3

`# Python3 implementation of above approach` `# from math lib import sqrt` `# and gcd function` `from` `math ` `import` `sqrt, gcd` `# Function to return the count of` `# prime factors of a number` `def` `countFactors(n) :` ` ` `factors ` `=` `0` `;` ` ` `for` `i ` `in` `range` `(` `2` `, ` `int` `(sqrt(n)) ` `+` `1` `) :` ` ` `while` `(n ` `%` `i ` `=` `=` `0` `) :` ` ` `n ` `/` `/` `=` `i` ` ` `factors ` `+` `=` `1` ` ` `if` `(n !` `=` `1` `) :` ` ` `factors ` `+` `=` `1` ` ` `return` `factors` `# Function to return the minimum number of` `# given operations required to convert A to B` `def` `minOperations(A, B) :` ` ` ` ` `g ` `=` `gcd(A, B)` ` ` `# Eliminate the common` ` ` `# factors of A and B` ` ` `A ` `/` `/` `=` `g` ` ` `B ` `/` `/` `=` `g` ` ` `# Sum of prime factors` ` ` `return` `countFactors(A) ` `+` `countFactors(B)` `# Driver code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `A, B ` `=` `10` `, ` `15` ` ` `print` `(minOperations(A, B))` `# This code is contributed by Ryuga` |

## C#

`// C# implementation of above approach` `using` `System;` ` ` `class` `GFG` `{` ` ` ` ` `// Function to return the count of` ` ` `// prime factors of a number` ` ` `static` `int` `countFactors(` `int` `n)` ` ` `{` ` ` `int` `factors = 0;` ` ` `for` `(` `int` `i = 2; i * i <= n; i++)` ` ` `{` ` ` `while` `(n % i == 0)` ` ` `{` ` ` `n /= i;` ` ` `factors += 1;` ` ` `}` ` ` `}` ` ` `if` `(n != 1)` ` ` `factors++;` ` ` `return` `factors;` ` ` `}` ` ` `static` `int` `__gcd(` `int` `a, ` `int` `b)` ` ` `{` ` ` `if` `(b == 0)` ` ` `return` `a;` ` ` `return` `__gcd(b, a % b);` ` ` `}` ` ` `// Function to return the minimum` ` ` `// number of given operations` ` ` `// required to convert A to B` ` ` `static` `int` `minOperations(` `int` `A, ` `int` `B)` ` ` `{` ` ` `int` `g = __gcd(A, B); ` `// gcd(A, B);` ` ` `// Eliminate the common` ` ` `// factors of A and B` ` ` `A /= g;` ` ` `B /= g;` ` ` `// Sum of prime factors` ` ` `return` `countFactors(A) + countFactors(B);` ` ` `}` ` ` `// Driver code` ` ` `public` `static` `void` `Main()` ` ` `{` ` ` `int` `A = 10, B = 15;` ` ` `Console.WriteLine(minOperations(A, B));` ` ` `}` `}` `// This code is contributed by` `// PrinciRaj1992` |

## PHP

`<?php` `// PHP implementation of above approach` `// Function to calculate gcd` `function` `__gcd(` `$a` `, ` `$b` `)` `{` ` ` ` ` `// Everything divides 0` ` ` `if` `(` `$a` `== 0 || ` `$b` `== 0)` ` ` `return` `0;` ` ` ` ` `// base case` ` ` `if` `(` `$a` `== ` `$b` `)` ` ` `return` `$a` `;` ` ` ` ` `// a is greater` ` ` `if` `(` `$a` `> ` `$b` `)` ` ` `return` `__gcd(` `$a` `- ` `$b` `, ` `$b` `);` ` ` ` ` `return` `__gcd(` `$a` `, ` `$b` `- ` `$a` `);` `}` `// Function to return the count of` `// prime factors of a number` `function` `countFactors(` `$n` `)` `{` ` ` `$factors` `= 0;` ` ` `for` `(` `$i` `= 2; ` `$i` `* ` `$i` `<= ` `$n` `; ` `$i` `++)` ` ` `{` ` ` `while` `(` `$n` `% ` `$i` `== 0)` ` ` `{` ` ` `$n` `/= ` `$i` `;` ` ` `$factors` `+= 1;` ` ` `}` ` ` `}` ` ` `if` `(` `$n` `!= 1)` ` ` `$factors` `++;` ` ` `return` `$factors` `;` `}` `// Function to return the minimum number of` `// given operations required to convert A to B` `function` `minOperations(` `$A` `, ` `$B` `)` `{` ` ` `$g` `= __gcd(` `$A` `, ` `$B` `); ` `// gcd(A, B);` ` ` `// Eliminate the common` ` ` `// factors of A and B` ` ` `$A` `/= ` `$g` `;` ` ` `$B` `/= ` `$g` `;` ` ` `// Sum of prime factors` ` ` `return` `countFactors(` `$A` `) +` ` ` `countFactors(` `$B` `);` `}` `// Driver code` `$A` `= 10; ` `$B` `= 15;` `echo` `minOperations(` `$A` `, ` `$B` `);` `// This code is contributed` `// by Akanksha Rai` `?>` |

## Javascript

`<script>` `// javascript implementation of above approach` ` ` `// Function to return the count of` ` ` `// prime factors of a number` ` ` `function` `countFactors(n) {` ` ` `var` `factors = 0;` ` ` `for` `(i = 2; i * i <= n; i++) {` ` ` `while` `(n % i == 0) {` ` ` `n /= i;` ` ` `factors += 1;` ` ` `}` ` ` `}` ` ` `if` `(n != 1)` ` ` `factors++;` ` ` `return` `factors;` ` ` `}` ` ` `function` `__gcd(a , b) {` ` ` `if` `(b == 0)` ` ` `return` `a;` ` ` `return` `__gcd(b, a % b);` ` ` `}` ` ` `// Function to return the minimum` ` ` `// number of given operations` ` ` `// required to convert A to B` ` ` `function` `minOperations(A , B) {` ` ` `var` `g = __gcd(A, B); ` `// gcd(A, B);` ` ` `// Eliminate the common` ` ` `// factors of A and B` ` ` `A /= g;` ` ` `B /= g;` ` ` `// Sum of prime factors` ` ` `return` `countFactors(A) + countFactors(B);` ` ` `}` ` ` `// Driver code` ` ` ` ` `var` `A = 10, B = 15;` ` ` `document.write(minOperations(A, B));` `// This code contributed by Rajput-Ji` `</script>` |

**Output:**

2

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.