Question

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

我想出了这个，但它肯定会留下一些不足之处。

int n=7, m=4, n1=n, m1=m;

while( m1 != n1 ){
    if( m1 > n1 )
        n1 += n;
    else 
        m1 += m;
}

System.out.println( "lcm is " + m1 );

Answer 1

a和b的最小公倍数（lcm）是它们的乘积除以它们的最大公约数（gcd）（即lcm(a, b) = ab/gcd(a,b)）。

那么，问题就变成了，如何找到gcd？ Euclidean algorithm通常是如何计算gcd的。经典算法的直接实现是有效的，但有些变体利用二进制算法做得更好。请参阅Knuth的“The Art of Computer Programming”Volume 2, "Seminumerical Algorithms" § 4.5.2。

Answer 2

<强>记住最小公倍数是最小整数，它是两个或多个数字中的每一个的倍数。

如果您想要找出三个整数的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。

Answer 3

我认为“reduction by the greatest common divider”的方法应该更快。首先计算GCD（例如使用Euclid's algorithm），然后将两个数字的乘积除以GCD。

Answer 4

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

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

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

}

之后，使用GCD，您可以轻松找到最不常见的多个

lcm = a / gcd * b;

Answer 5

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

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);
}

Answer 6

下面的C ++中没有溢出的最佳解决方案

#include <iostream>
using namespace std; 
long long gcd(long long int a, long long int b){        
    if(b==0)
        return a;
    return gcd(b,a%b);
}

long long lcm(long long a,long long b){     
    if(a>b)
        return (a/gcd(a,b))*b;
    else
        return (b/gcd(a,b))*a;    
} 

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

Answer 7

C ++模板。编译时间

#include <iostream>

const int lhs = 8, rhs = 12;

template<int n, int mod_lhs=n % lhs, int mod_rhs=n % rhs> struct calc {
  calc() { }
};

template<int n> struct calc<n, 0, 0> {
  calc() { std::cout << n << std::endl; }
};

template<int n, int mod_rhs> struct calc<n, 0, mod_rhs> {
  calc() { }
};

template<int n, int mod_lhs> struct calc <n, mod_lhs, 0> {
  calc() { }
};

template<int n> struct lcm {
  lcm() {
    lcm<n-1>();
    calc<n>();
  }
};

template<> struct lcm<0> {
  lcm() {}
};

int main() {
  lcm<lhs * rhs>();
}

Answer 8

这是一种在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)

Answer 9

取两个数中较大的一个的连续倍数，直到结果为较小的倍数。

这可能有用......

   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;
   }

Answer 10

欧几里得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);
    }

Answer 11

没有比使用内置功能更有效的方法！

自Python 3.8起，数学库中已添加lcm()函数。并可以通过以下签名来调用：

math.lcm(*integers)

返回指定整数参数的最小公倍数。如果所有参数都不为零，则返回值为最小的正整数，该整数是所有参数的倍数。如果任何参数为零，则返回值为0。不带参数的lcm（）返回1。

Answer 12

使用欧几里得算法找到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;           
    }

Answer 13

2个数字的乘积等于LCM * GCD或HCF。因此，找到LCM的最佳方法是找到GCD并将产品与GCD分开。也就是说，LCM（a，b）=（a * b）/ GCD（a，b）。

Answer 14

最有效的LCM计算方法- 时间复杂度- O（log（min（a（b，b）））

基本公式- LCM（a，b）=（a * b）/ GCD（a，b）

GCD（a，b）的时间复杂度为 O（log（min（a（b，b）））

在这里您可以找到C，C ++，C＃，Python等代码。click here

谢谢！

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

14 个答案:

没有比使用内置功能更有效的方法！