Skip to content
Related Articles

Related Articles

Improve Article

Minimum prime number operations to convert A to B

  • Last Updated : 23 Apr, 2021

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

  1. Multiply A by any prime number.
  2. Divide A by one of its prime divisors.

Print the minimum number of operations required.
Examples: 
 

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

Naive Approach: If prime factorization of A = p1q1 * p2q2 * … * pnqn. If we multiply A by some prime then qi for that prime will increase by 1 and if we divide A by one of its prime factors then qi for that prime will decrease by 1. So for a prime p if it occurs qA times in prime factorization of A and qB times in prime factorization of B then we only need to find the sum of |qA – qB| for all the primes to get a minimum number of operations.
 

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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :