Skip to content
Related Articles

Related Articles

Minimize divisions by 2, 3, or 5 required to make two given integers equal
  • Last Updated : 16 Apr, 2021

Given two integers X and Y, the task is to make X and Y equal by dividing either of X or Y by 2, 3, or 5, minimum number of times, if found to be divisible. If the two integers can be made equal, then print “-1”.

Examples:

Input: X = 15, Y = 20
Output: 3
Explanation:
Operation 1: Reduce X(= 15) to 15/3 i.e., X = 15/3 = 5.
Operation 2: Reduce Y(= 20) to 20/2 i.e., Y = 20/2 = 10.
Operation 3: Reduce Y(= 20) to 10/2 i.e., Y = 10/2 = 5.
After the above operations, X and Y are equal i.e., 5.
Therefore, the count of operation required is 3.

Input: X = 6, Y = 6
Output: 0

Approach: The given problem can be solved greedily. The idea is to reduce the given integers to their GCD in order to make them equal. Follow the steps below to solve the problem:



  • Find the Greatest Common Divisor (GCD) of X and Y and divide X and Y by their GCD.
  • Initialize a variable, say count, to store the number of divisions required.
  • Iterate until X is not equal to Y and perform the following steps: 
    • If the value of X is greater than Y, then swap X and Y.
    • If the larger number(i.e., Y) is divisible by 2, 3, or 5, then divide it by that number. Increment count by 1. Otherwise, if it is not possible to make both the numbers equal, print “-1” and break out of the loop.
  • After completing the above steps, if both the numbers can be made equal, then print the value of count as the minimum number of divisions required to make X and Y equal.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate
// GCD of two numbers
int gcd(int a, int b)
{
    // Base Case
    if (b == 0) {
        return a;
    }
 
    // Calculate GCD recursively
    return gcd(b, a % b);
}
 
// Function to count the minimum
// number of divisions required
// to make X and Y equal
void minimumOperations(int X, int Y)
{
    // Calculate GCD of X and Y
    int GCD = gcd(X, Y);
 
    // Divide X and Y by their GCD
    X = X / GCD;
    Y = Y / GCD;
 
    // Stores the number of divisions
    int count = 0;
 
    // Iterate until X != Y
    while (X != Y) {
 
        // Maintain the order X <= Y
        if (Y > X) {
            swap(X, Y);
        }
 
        // If X is divisible by 2,
        // then divide X by 2
        if (X % 2 == 0) {
            X = X / 2;
        }
 
        // If X is divisible by 3,
        // then divide X by 3
        else if (X % 3 == 0) {
            X = X / 3;
        }
 
        // If X is divisible by 5,
        // then divide X by 5
        else if (X % 5 == 0) {
            X = X / 5;
        }
 
        // If X is not divisible by
        // 2, 3, or 5, then print -1
        else {
            cout << "-1";
            return;
        }
 
        // Increment count by 1
        count++;
    }
 
    // Print the value of count as the
    // minimum number of operations
    cout << count;
}
 
// Driver Code
int main()
{
    int X = 15, Y = 20;
    minimumOperations(X, Y);
 
    return 0;
}
Java



// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function to calculate
// GCD of two numbers
static int gcd(int a, int b)
{
     
    // Base Case
    if (b == 0)
    {
        return a;
    }
 
    // Calculate GCD recursively
    return gcd(b, a % b);
}
 
// Function to count the minimum
// number of divisions required
// to make X and Y equal
static void minimumOperations(int X, int Y)
{
     
    // Calculate GCD of X and Y
    int GCD = gcd(X, Y);
 
    // Divide X and Y by their GCD
    X = X / GCD;
    Y = Y / GCD;
 
    // Stores the number of divisions
    int count = 0;
 
    // Iterate until X != Y
    while (X != Y)
    {
         
        // Maintain the order X <= Y
        if (Y > X)
        {
            int t = X;
            X = Y;
            Y = t;
        }
 
        // If X is divisible by 2,
        // then divide X by 2
        if (X % 2 == 0)
        {
            X = X / 2;
        }
 
        // If X is divisible by 3,
        // then divide X by 3
        else if (X % 3 == 0)
        {
            X = X / 3;
        }
 
        // If X is divisible by 5,
        // then divide X by 5
        else if (X % 5 == 0)
        {
            X = X / 5;
        }
 
        // If X is not divisible by
        // 2, 3, or 5, then print -1
        else
        {
            System.out.print("-1");
            return;
        }
 
        // Increment count by 1
        count += 1;
    }
 
    // Print the value of count as the
    // minimum number of operations
    System.out.println(count);
}
 
// Driver Code
static public void main(String args[])
{
    int X = 15, Y = 20;
     
    minimumOperations(X, Y);
}
}
 
// This code is contributed by ipg2016107
Python3



# Python3 program for the above approach
 
# Function to calculate
# GCD of two numbers
def gcd(a, b):
     
    # Base Case
    if (b == 0):
        return a
 
    # Calculate GCD recursively
    return gcd(b, a % b)
 
# Function to count the minimum
# number of divisions required
# to make X and Y equal
def minimumOperations(X, Y):
     
    # Calculate GCD of X and Y
    GCD = gcd(X, Y)
 
    # Divide X and Y by their GCD
    X = X // GCD
    Y = Y // GCD
 
    # Stores the number of divisions
    count = 0
 
    # Iterate until X != Y
    while (X != Y):
 
        # Maintain the order X <= Y
        if (Y > X):
            X, Y = Y, X
 
        # If X is divisible by 2,
        # then divide X by 2
        if (X % 2 == 0):
            X = X // 2
 
        # If X is divisible by 3,
        # then divide X by 3
        elif (X % 3 == 0):
            X = X // 3
 
        # If X is divisible by 5,
        # then divide X by 5
        elif (X % 5 == 0):
            X = X // 5
             
        # If X is not divisible by
        # 2, 3, or 5, then pr-1
        else:
            print("-1")
            return
 
        # Increment count by 1
        count += 1
 
    # Print the value of count as the
    # minimum number of operations
    print (count)
 
# Driver Code
if __name__ == '__main__':
     
    X, Y = 15, 20
     
    minimumOperations(X, Y)
 
# This code is contributed by mohit kumar 29
C#



// C# program for the above approach
using System;
 
public class GFG
{
 
// Function to calculate
// GCD of two numbers
static int gcd(int a, int b)
{
   
    // Base Case
    if (b == 0) {
        return a;
    }
 
    // Calculate GCD recursively
    return gcd(b, a % b);
}
 
// Function to count the minimum
// number of divisions required
// to make X and Y equal
static void minimumOperations(int X, int Y)
{
   
    // Calculate GCD of X and Y
    int GCD = gcd(X, Y);
 
    // Divide X and Y by their GCD
    X = X / GCD;
    Y = Y / GCD;
 
    // Stores the number of divisions
    int count = 0;
 
    // Iterate until X != Y
    while (X != Y) {
 
        // Maintain the order X <= Y
        if (Y > X) {
            int t = X;
            X = Y;
            Y = t;
        }
 
        // If X is divisible by 2,
        // then divide X by 2
        if (X % 2 == 0) {
            X = X / 2;
        }
 
        // If X is divisible by 3,
        // then divide X by 3
        else if (X % 3 == 0) {
            X = X / 3;
        }
 
        // If X is divisible by 5,
        // then divide X by 5
        else if (X % 5 == 0) {
            X = X / 5;
        }
 
        // If X is not divisible by
        // 2, 3, or 5, then print -1
        else {
            Console.WriteLine("-1");
            return;
        }
 
        // Increment count by 1
        count++;
    }
 
    // Print the value of count as the
    // minimum number of operations
    Console.WriteLine(count);
}
 
// Driver Code
static public void Main()
{
    int X = 15, Y = 20;
    minimumOperations(X, Y);
}
}
 
// This code is contributed by sanjoy_62.
Javascript



<script>
 
// Javascript program for the above approach
 
    // Function to calculate
    // GCD of two numbers
    function gcd(a , b) {
 
        // Base Case
        if (b == 0) {
            return a;
        }
 
        // Calculate GCD recursively
        return gcd(b, a % b);
    }
 
    // Function to count the minimum
    // number of divisions required
    // to make X and Y equal
    function minimumOperations(X , Y) {
 
        // Calculate GCD of X and Y
        var GCD = gcd(X, Y);
 
        // Divide X and Y by their GCD
        X = X / GCD;
        Y = Y / GCD;
 
        // Stores the number of divisions
        var count = 0;
 
        // Iterate until X != Y
        while (X != Y) {
 
            // Maintain the order X <= Y
            if (Y > X) {
                var t = X;
                X = Y;
                Y = t;
            }
 
            // If X is divisible by 2,
            // then divide X by 2
            if (X % 2 == 0) {
                X = X / 2;
            }
 
            // If X is divisible by 3,
            // then divide X by 3
            else if (X % 3 == 0) {
                X = X / 3;
            }
 
            // If X is divisible by 5,
            // then divide X by 5
            else if (X % 5 == 0) {
                X = X / 5;
            }
 
            // If X is not divisible by
            // 2, 3, or 5, then prvar -1
            else {
                document.write("-1");
                return;
            }
 
            // Increment count by 1
            count += 1;
        }
 
        // Print the value of count as the
        // minimum number of operations
        document.write(count);
    }
 
    // Driver Code
        var X = 15, Y = 20;
 
        minimumOperations(X, Y);
 
// This code contributed by Rajput-Ji
 
</script>
Output: 
3
 
Time Complexity: O(log(max(X, Y)))
Auxiliary Space: O(1)
Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
My Personal Notes
arrow_drop_up
Previous
Count all unique outcomes possible by performing S flips on N coins
Next

Check if a given pattern exists in a given string or not
Recommended Articles
Page :
Minimize count of divisions by D to obtain at least K equal array elements
17, Jul 20
Minimize steps required to make two values equal by repeated division by any of their prime factor which is less than M
26, Feb 21
Minimize count of given operations required to make two given strings permutations of each other
23, Sep 20
Minimize count of flips required to make sum of the given array equal to 0
31, Jan 21
Minimize count of given operations required to be performed to make all array elements equal to 1
13, Jan 21
Minimize cost of insertions and deletions required to make all array elements equal
19, Jan 21
Minimize increments required to make count of even and odd array elements equal
22, Jan 21
Minimize cost required to make all array elements greater than or equal to zero
20, Feb 21
Minimize subtraction followed by increments of adjacent elements required to make all array elements equal
22, Mar 21
Minimize flips on K-length subarrays required to make all array elements equal to 1
09, Mar 21
Minimize cost to convert given two integers to zero using given operations
27, May 20
Minimize subset addition or multiplication to make two given triplets equal
25, Oct 20
Minimize replacements with values up to K to make sum of two given arrays equal
02, Mar 21
Remove two consecutive integers from 1 to N to make sum equal to S
27, Dec 19
Minimize count of connections required to be rearranged to make all the computers connected
09, Feb 21
Minimize count of increments of each element of subarrays required to make Array non-increasing
31, Aug 20
Minimize count of swaps of adjacent elements required to make an array increasing
02, Mar 21
Minimize insertions required to make ratio of maximum and minimum of all pairs of adjacent array elements at most K
03, Mar 21
Minimize cost of removals required to make all remaining characters of the string unique
13, Jan 21
Minimize increments or decrements required to make sum and product of array elements non-zero
09, Nov 20
Minimize replacements by previous or next alphabet required to make all characters of a string the same
19, Oct 20
Minimize steps required to make all array elements same by adding 1, 2 or 5
01, Sep 20
Minimize Bitwise XOR of array elements with 1 required to make sum of array at least K
21, Apr 21
Minimize cost to make X and Y equal by given increments
15, Jan 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
kothawade29
@kothawade29
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox