Related Articles

# Minimum number to be added to minimize LCM of two given numbers

• Difficulty Level : Expert
• Last Updated : 23 Jun, 2021

Given two numbers A and B, the task is to find the minimum number that needs to be added to A and B such that their LCM is minimized.

Examples:

Input: A = 6, B = 10
Output: 2
Explanation: On adding 2 to A and B, the value becomes 8 and 12 respectively. LCM of 8 and 12 is 24, which is the minimum LCM possible.

Input: A = 5, B = 10
Output: 0
Explanation:
10 is already the minimum LCM of both the given number.
Hence, the minimum number added is 0.

Approach: The idea is based on the generalized formula that the LCM of (A + x) and (B + x) is equal to (A + x)*(B + x) / GCD(A + x, B + x). It can be observed that GCD of (A + x) and (B + x) is is equal to the GCD of (B – A) and (A + x). So, the gcd is a divisor of (B − A).

Therefore, iterate over all the divisors of (B − A) and if A % M = B % M (if M is one of the divisors), then the value of X(the minimum value must be added) is equal to M − A % M.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include "bits/stdc++.h"``using` `namespace` `std;` `// Function for finding all divisors``// of a given number``vector<``int``> getDivisors(``int` `diff)``{``    ``// Stores the divisors of the``    ``// number diff``    ``vector<``int``> divisor;` `    ``for` `(``int` `i = 1; i * i <= diff; i++) {` `        ``// If diff is a perfect square``        ``if` `(i == diff / i) {``            ``divisor.push_back(i);``            ``continue``;``        ``}` `        ``// If i divides diff then``        ``// diff / i also a divisor``        ``if` `(diff % i == 0) {``            ``divisor.push_back(i);``            ``divisor.push_back(diff / i);``        ``}``    ``}` `    ``// Return the divisors stored``    ``return` `divisor;``}` `// Function to find smallest integer x``// such that LCM of (A + X) and (B + X)``// is minimized``int` `findTheSmallestX(``int` `a, ``int` `b)``{``    ``int` `diff = b - a;` `    ``// Find all the divisors of diff``    ``vector<``int``> divisor``        ``= getDivisors(diff);` `    ``// Find LCM of a and b``    ``int` `lcm = (a * b) / __gcd(a, b);` `    ``int` `ans = 0;` `    ``for` `(``int` `i = 0;``         ``i < (``int``)divisor.size(); i++) {` `        ``// From equation x = M - a % M``        ``// here M = divisor[i]``        ``int` `x = (divisor[i]``                 ``- (a % divisor[i]));` `        ``// If already checked for x == 0``        ``if` `(!x)``            ``continue``;` `        ``// Find the product``        ``int` `product = (b + x) * (a + x);` `        ``// Find the GCD``        ``int` `tempGCD = __gcd(a + x, b + x);``        ``int` `tempLCM = product / tempGCD;` `        ``// If current lcm is minimum``        ``// than previous lcm, update ans``        ``if` `(lcm > tempLCM) {``            ``ans = x;``            ``lcm = tempLCM;``        ``}``    ``}` `    ``// Print the number added``    ``cout << ans;``}` `// Driver Code``int` `main()``{``    ``// Given A & B``    ``int` `A = 6, B = 10;` `    ``// Function Call``    ``findTheSmallestX(A, B);` `    ``return` `0;``}`

## Java

 `// Java program for the``// above approach``import` `java.util.*;``class` `GFG{``  ` `// Recursive function to``// return gcd of a and b ``static` `int` `__gcd(``int` `a, ``int` `b) ``{ ``  ``return` `b == ``0` `? a :``         ``__gcd(b, a % b);    ``}``  ` `// Function for finding all``// divisors of a given number``static` `int``[] getDivisors(``int` `diff)``{``  ``// Stores the divisors of``  ``// the number diff``  ``Vector divisor =``         ``new` `Vector<>() ;` `  ``for` `(``int` `i = ``1``;``           ``i * i <= diff; i++)``  ``{``    ``// If diff is a perfect``    ``// square``    ``if` `(i == diff / i)``    ``{``      ``divisor.add(i);``      ``continue``;``    ``}` `    ``// If i divides diff then``    ``// diff / i also a divisor``    ``if` `(diff % i == ``0``)``    ``{``      ``divisor.add(i);``      ``divisor.add(diff / i);``    ``}``  ``}``  ` `  ``int` `[]ans = ``new` `int``[divisor.size()];``  ``int` `j = ``0``;``  ` `  ``for``(``int` `i: divisor)``    ``ans[j] = i;``  ` `  ``// Return the divisors``  ``// stored``  ``return` `ans;``}` `// Function to find smallest integer``// x such that LCM of (A + X) and``// (B + X) is minimized``static` `void` `findTheSmallestX(``int` `a,``                             ``int` `b)``{``  ``int` `diff = b - a;` `  ``// Find all the divisors``  ``// of diff``  ``int``[] divisor =``        ``getDivisors(diff);` `  ``// Find LCM of a and b``  ``int` `lcm = (a * b) /``             ``__gcd(a, b);` `  ``int` `ans = ``0``;` `  ``for` `(``int` `i = ``0``;``           ``i tempLCM)``    ``{``      ``ans = x;``      ``lcm = tempLCM;``    ``}``  ``}` `  ``// Print the number``  ``// added``  ``System.out.print(ans);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``  ``// Given A & B``  ``int` `A = ``6``, B = ``10``;` `  ``// Function Call``  ``findTheSmallestX(A, B);``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program for the above approach``from` `math ``import` `gcd` `# Function for finding all divisors``# of a given number``def` `getDivisors(diff):``    ` `    ``# Stores the divisors of the``    ``# number diff``    ``divisor ``=` `[]` `    ``for` `i ``in` `range``(``1``, diff):``        ``if` `i ``*` `i > diff:``            ``break` `        ``# If diff is a perfect square``        ``if` `(i ``=``=` `diff ``/``/` `i):``            ``divisor.append(i)``            ``continue` `        ``# If i divides diff then``        ``# diff / i also a divisor``        ``if` `(diff ``%` `i ``=``=` `0``):``            ``divisor.append(i)``            ``divisor.append(diff ``/``/` `i)` `    ``# Return the divisors stored``    ``return` `divisor` `# Function to find smallest integer x``# such that LCM of (A + X) and (B + X)``# is minimized``def` `findTheSmallestX(a, b):``    ` `    ``diff ``=` `b ``-` `a` `    ``# Find all the divisors of diff``    ``divisor ``=` `getDivisors(diff)` `    ``# Find LCM of a and b``    ``lcm ``=` `(a ``*` `b) ``/``/` `gcd(a, b)` `    ``ans ``=` `0` `    ``for` `i ``in` `range``(``len``(divisor)):` `        ``# From equation x = M - a % M``        ``# here M = divisor[i]``        ``x ``=` `(divisor[i] ``-` `(a ``%` `divisor[i]))` `        ``# If already checked for x == 0``        ``if` `(``not` `x):``            ``continue` `        ``# Find the product``        ``product ``=` `(b ``+` `x) ``*` `(a ``+` `x)` `        ``# Find the GCD``        ``tempGCD ``=` `gcd(a ``+` `x, b ``+` `x)``        ``tempLCM ``=` `product ``/``/` `tempGCD` `        ``# If current lcm is minimum``        ``# than previous lcm, update ans``        ``if` `(lcm > tempLCM):``            ``ans ``=` `x``            ``lcm ``=` `tempLCM` `    ``# Print the number added``    ``print``(ans)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Given A & B``    ``A ``=` `6``    ``B ``=` `10` `    ``# Function Call``    ``findTheSmallestX(A, B)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the``// above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{``  ` `// Recursive function to``// return gcd of a and b ``static` `int` `__gcd(``int` `a, ``int` `b) ``{ ``  ``return` `b == 0 ? a :``         ``__gcd(b, a % b);    ``}``  ` `// Function for finding all``// divisors of a given number``static` `int``[] getDivisors(``int` `diff)``{``  ` `  ``// Stores the divisors of``  ``// the number diff``  ``List<``int``> divisor = ``new` `List<``int``>();` `  ``for``(``int` `i = 1; i * i <= diff; i++)``  ``{``    ` `    ``// If diff is a perfect``    ``// square``    ``if` `(i == diff / i)``    ``{``      ``divisor.Add(i);``      ``continue``;``    ``}` `    ``// If i divides diff then``    ``// diff / i also a divisor``    ``if` `(diff % i == 0)``    ``{``      ``divisor.Add(i);``      ``divisor.Add(diff / i);``    ``}``  ``}``  ` `  ``int` `[]ans = ``new` `int``[divisor.Count];``  ``int` `j = 0;``  ` `  ``foreach``(``int` `i ``in` `divisor)``    ``ans[j] = i;``  ` `  ``// Return the divisors``  ``// stored``  ``return` `ans;``}` `// Function to find smallest integer``// x such that LCM of (A + X) and``// (B + X) is minimized``static` `void` `findTheSmallestX(``int` `a,``                             ``int` `b)``{``  ``int` `diff = b - a;` `  ``// Find all the divisors``  ``// of diff``  ``int``[] divisor = getDivisors(diff);` `  ``// Find LCM of a and b``  ``int` `lcm = (a * b) / __gcd(a, b);` `  ``int` `ans = 0;` `  ``for``(``int` `i = 0;``          ``i < divisor.Length; i++)``  ``{``    ` `    ``// From equation x = M - a % M``    ``// here M = divisor[i]``    ``int` `x = 0;``    ` `    ``if` `(divisor[i] != 0)``      ``x = (divisor[i] -``      ``(a % divisor[i]));` `    ``// If already checked for``    ``// x == 0``    ``if` `(x == 0)``      ``continue``;` `    ``// Find the product``    ``int` `product = (b + x) *``                  ``(a + x);` `    ``// Find the GCD``    ``int` `tempGCD = __gcd(a + x,``                        ``b + x);``    ``int` `tempLCM = product /``                  ``tempGCD;` `    ``// If current lcm is``    ``// minimum than previous``    ``// lcm, update ans``    ``if` `(lcm > tempLCM)``    ``{``      ``ans = x;``      ``lcm = tempLCM;``    ``}``  ``}``  ` `  ``// Print the number``  ``// added``  ``Console.Write(ans);``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``  ` `  ``// Given A & B``  ``int` `A = 6, B = 10;` `  ``// Function Call``  ``findTheSmallestX(A, B);``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``
Output:
`2`

Time Complexity: O(sqrt(B – A))
Auxiliary Space: O(max(A, B))

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