Minimum number of given operation required to convert n to m

Last Updated : 09 Jun, 2022

Given two integers n and m, in a single operation n can be multiplied by either 2 or 3. The task is to convert n to m with a minimum number of given operations. If it is impossible to convert n to m with the given operation then print -1.
Examples:

Input: n = 120, m = 51840
Output: 7
120 * 2 * 2 * 2 * 2 * 3 * 3 * 3 = 51840
Input: n = 42, m = 42
Output: 0
No operation required.
Input: n = 48, m = 72
Output: -1

Approach: If m is not divisible by n then print -1 as n cannot be converted to m with the given operation. Else we can check if, on dividing, the quotient has only 2 and 3 as prime factors. If yes then the result will be the sum of powers of 2 and 3 else print -1
Below is the implementation of the above approach:

C++

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

// Function to return the minimum
// operations required
int minOperations(int n, int m)
{
    if (m % n != 0)
        return -1;

    int minOperations = 0;
    int q = m / n;

    // Counting all 2s
    while (q % 2 == 0) {
        q = q / 2;
        minOperations++;
    }

    // Counting all 3s
    while (q % 3 == 0) {
        q = q / 3;
        minOperations++;
    }

    // If q contained only 2 and 3
    // as the only prime factors
    // then it must be 1 now
    if (q == 1)
        return minOperations;

    return -1;
}

// Driver code
int main()
{
    int n = 120, m = 51840;
    cout << minOperations(n, m);

    return 0;
}

Java

// Java implementation of the approach
class GfG {

    // Function to return the minimum
    // operations required
    static int minOperations(int n, int m)
    {
        if (m % n != 0)
            return -1;

        int minOperations = 0;
        int q = m / n;

        // Counting all 2s
        while (q % 2 == 0) {
            q = q / 2;
            minOperations++;
        }

        // Counting all 3s
        while (q % 3 == 0) {
            q = q / 3;
            minOperations++;
        }

        // If q contained only 2 and 3
        // as the only prime factors
        // then it must be 1 now
        if (q == 1)
            return minOperations;

        return -1;
    }

    // Driver code
    public static void main(String[] args)
    {
        int n = 120, m = 51840;
        System.out.println(minOperations(n, m));
    }
}

Python3

# Python 3 implementation of the approach

# Function to return the minimum
# operations required
def minOperations(n, m):
    if (m % n != 0):
        return -1

    minOperations = 0
    q = int(m / n)

    # Counting all 2s
    while (q % 2 == 0):
        q = int(q / 2)
        minOperations += 1

    # Counting all 3s
    while (q % 3 == 0):
        q = int(q / 3)
        minOperations += 1

    # If q contained only 2 and 3
    # as the only prime factors
    # then it must be 1 now
    if (q == 1):
        return minOperations

    return -1

# Driver code
if __name__ == '__main__':
    n = 120
    m = 51840
    print(minOperations(n, m))
    
# This code is contributed by
# Surendra_Gangwar

// C# implementation of the approach
using System;

class GFG 
{

// Function to return the minimum
// operations required
static int minOperations(int n, int m)
{
    if (m % n != 0)
        return -1;

    int minOperations = 0;
    int q = m / n;

    // Counting all 2s
    while (q % 2 == 0)
    {
        q = q / 2;
        minOperations++;
    }

    // Counting all 3s
    while (q % 3 == 0)
    {
        q = q / 3;
        minOperations++;
    }

    // If q contained only 2 and 3
    // as the only prime factors
    // then it must be 1 now
    if (q == 1)
        return minOperations;

    return -1;
}

// Driver code
public static void Main()
{
    int n = 120, m = 51840;
    Console.WriteLine(minOperations(n, m));
}
}

// This code is contributed 
// by Akanksha Rai

PHP

<?php
// PHP implementation of the approach

// Function to return the minimum
// operations required
function minOperations($n, $m)
{
    if ($m % $n != 0)
        return -1;

    $minOperations = 0;
    $q = $m / $n;

    // Counting all 2s
    while ($q % 2 == 0) 
    {
        $q = $q / 2;
        $minOperations++;
    }

    // Counting all 3s
    while ($q % 3 == 0) 
    {
        $q = $q / 3;
        $minOperations++;
    }

    // If q contained only 2 and 3
    // as the only prime factors
    // then it must be 1 now
    if ($q == 1)
        return $minOperations;

    return -1;
}

// Driver code
$n = 120; $m = 51840;
echo(minOperations($n, $m));

// This code is contributed by Code_Mech
?>

JavaScript

<script>
// javascript implementation of the approach

    // Function to return the minimum
    // operations required
    function minOperations(n , m) {
        if (m % n != 0)
            return -1;

        var minOperations = 0;
        var q = m / n;

        // Counting all 2s
        while (q % 2 == 0) {
            q = q / 2;
            minOperations++;
        }

        // Counting all 3s
        while (q % 3 == 0) {
            q = q / 3;
            minOperations++;
        }

        // If q contained only 2 and 3
        // as the only prime factors
        // then it must be 1 now
        if (q == 1)
            return minOperations;

        return -1;
    }

    // Driver code
    
        var n = 120, m = 51840;
        document.write(minOperations(n, m));

// This code contributed by Rajput-Ji 
</script>

Output:

Time Complexity: O(log(m/n))

Auxiliary Space: O(1)

Analysis of Algorithms

anshuman_7

Improve

Article Tags :

Minimum number of given operation required to convert n to m

Similar Reads

Basics & Prerequisites

Data Structures

Algorithms

Advanced

Interview Preparation

Practice Problem

Thank You!

What kind of Experience do you want to share?