Math 计算两个整数的最小公倍数最有效的方法是什么？

计算两个整数的最小公倍数最有效的方法是什么

我刚刚想到了这个，但它肯定留下了一些需要改进的地方

int n=7，m=4，n1=n，m1=m；
而（m1！=n1）{
如果（m1>n1）
n1+=n；
其他的
m1+=m；
}
系统输出打印项次（“lcm为”+m1）；

取两个数字中较大者的连续倍数，直到结果是较小者的倍数

这可能有用

   public int LCM(int x, int y)
   {
       int larger  = x>y? x: y,
           smaller = x>y? y: x,
           candidate = larger ;
       while (candidate % smaller  != 0) candidate += larger ;
       return candidate;
   }

a

和

b

的最小公倍数（lcm）是它们的乘积除以它们的最大公因数（gcd）（即

lcm（a，b）=ab/gcd（a，b）

）

---

因此，问题变成了，如何找到gcd？一般情况下，计算gcd的方式为。经典算法的直接实现是有效的，但也有一些变体利用二进制算法做得更好。请参阅“的”

我认为“”的方法应该更快。首先计算GCD（例如使用），然后将两个数字的乘积除以GCD。

记住 最小公倍数是两个或多个数字的倍数的最小整数。

如果要计算三个整数的LCM，请执行以下步骤：

  **Find the LCM of 19, 21, and 42.**

写出每个数字的素数分解。19是质数。你不需要系数19

21 = 3 × 7
42 = 2 × 3 × 7
19

重复每个素因子，使其在上述任何素因子分解中出现的次数最多

2×3×7×19=798

---

21、42和19的最小公倍数是798。

首先，你必须找到最大公因数

for(int i=1; i<=a && i<=b; i++) {

   if (i % a == 0 && i % b == 0)
   {
       gcd = i;
   }

}

---

我不知道它是否优化，但可能是最简单的一个：

public void lcm(int a, int b)
{
    if (a > b)
    {
        min = b;
        max = a;
    }
    else
    {
        min = a;
        max = b;
    }
    for (i = 1; i < max; i++)
    {
        if ((min*i)%max == 0)
        {
            res = min*i;
            break;
        }
    }
    Console.Write("{0}", res);
}

公共无效lcm（内部a、内部b）
{
如果（a>b）
{
min=b；
max=a；
}
其他的
{
min=a；
max=b；
}
对于（i=1；i<>代码>下面的C++最佳解决方案，不溢出

#包括
使用名称空间std；
长-长gcd（长-长INTA，长-长INTB）{
如果（b==0）
返回a；
返回gcd（b，a%b）；
}
长-长lcm（长-长a，长-长b）{
如果（a>b）
申报表（a/gcd（a、b））*b；
其他的
报税表（b/gcd（a，b））*a；
} 
int main（）
{
长内点a，b；
cin>>a>>b；
coutC++模板。编译时

#包括
常数int lhs=8，rhs=12；
模板结构计算{
计算（）{}
};
模板结构计算{
calc（）{std:：cout两个数字的乘积等于LCM*GCD或HCF。因此，找到LCM的最佳方法是找到GCD并将乘积除以GCD。也就是说，LCM（a，b）=（a*b）/GCD（a，b）。
欧几里德GCD代码片段

int findGCD(int a, int b) {
        if(a < 0 || b < 0)
            return -1;

        if (a == 0)
            return b;
        else if (b == 0)
            return a;
        else 
            return findGCD(b, a % b);
    }

intfindgcd（inta，intb）{
if（a<0 | | b<0）
返回-1；
如果（a==0）
返回b；
else如果（b==0）
返回a；
其他的
返回findGCD（b，a%b）；
}
这里是一种在python中查找两个数字的LCM的高效方法

def gcd(a, b):
    if min(a, b) == 0:
        return max(a, b)
    a_1 = max(a, b) % min(a, b)
    return gcd(a_1, min(a, b))

def lcm(a, b):
    return (a * b) // gcd(a, b)

没有比使用内置函数更有效的方法了！
从Python 3.8开始，数学库中添加了
lcm（）
函数。可以使用以下签名调用该函数：

math.lcm(*integers)

返回指定整数参数的最小公倍数。如果所有参数均为非零，则返回值为所有参数的倍数中最小的正整数。如果任何参数均为零，则返回值为0.lcm（）无参数返回1。
使用欧几里德算法找到gcd，然后计算lcm除以a与gcd和b的乘积，这对我很有用

int euclidgcd(int a, int b){
        if(b==0)
        return a;
        int a_rem = a % b;
        return euclidgcd(b, a_rem);
        }
    
long long lcm(int a, int b) {
        int gcd=euclidgcd(a, b);
        return (a/gcd*b);
        }

int main() {
      int a, b;
      std::cin >> a >> b;
      std::cout << lcm(a, b) << std::endl;
    return 0;           
    }

inteuclidGCD（intA，intB）{
如果（b==0）
返回a；
int a_rem=a%b；
返回euclidgcd（b，a_-rem）；
}
长lcm（内部a、内部b）{
int gcd=欧几里德gcd（a，b）；
申报表（a/gcd*b）；
}
int main（）{
INTA，b；
标准：cin>>a>>b；
std：：是的，使用GCD的LCM快速且易于编码。一个小但重要的细节：为了避免溢出，计算最终结果如下：
LCM=a/GCD*b
而不是
LCM=a*b/GCD
@Bolo-如果你“担心”关于溢出，您应该使用
long
或在其他情况下甚至使用
biginger
。两个
int
值的LCM可能是
long
@Stephen C，采用Bolo的方法，如果可以表示LCM，则可以在不溢出的情况下计算LCM。不需要仅为mult使用更大更慢的数字类型i应用。@starblue-但反过来说，LCM可以表示为
int
。我们知道，对于
m
和
n
的某些值，它不能表示。我的观点是，如果您担心计算中的溢出，您也应该担心最终结果中的溢出。@Stephen C可能发生两个输入整数的阶数为O（N），其LCM的阶数为O（N）。在原始方法中，中间结果的阶数为O（N^2），而在修改后的方法中，中间结果的阶数仅为O（N）。例如：p=2^31-1=2147483647，m=2*p，N=3*p。它们的LCM=6*p，这些都不是很大的数字（
long
可以表示最多为2^63-1=9223372036854775807的整数），但原始方法无论如何都会溢出（中间值为6*p*p）。简单的重新排序可以大大提高算法的适用性，而不必考虑类型（
short
、
int
或
long
）。这对x和y的小值来说是可行的，它很难缩放。伙计，这有助于解决欧几里德算法导致堆栈溢出的问题。我想放大它，你只需将它们视为字符串
int euclidgcd(int a, int b){
        if(b==0)
        return a;
        int a_rem = a % b;
        return euclidgcd(b, a_rem);
        }
    
long long lcm(int a, int b) {
        int gcd=euclidgcd(a, b);
        return (a/gcd*b);
        }

int main() {
      int a, b;
      std::cin >> a >> b;
      std::cout << lcm(a, b) << std::endl;
    return 0;           
    }