blocks|key|995709|text|a和b的最小公倍数是它们的乘积除以它们的最大公约数(即lcm(a,+b)+=+ab/gcd(a,b))。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|995710|因此，问题变成了，如何找到gcd？Euclidean+algorithm通常是计算gcd的方式。经典算法的直接实现是有效的，但是有一些变体利用二进制算法来做得更好一些。请参阅Knuth的"The+Art+of+Computer+Programming“Volume+2,+"Seminumerical+Algorithms"+§+4.5.2。|995711|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Euclidean_algorithm|1|https://en.wikipedia.org/wiki/Donald_Knuth|2|https://en.wikipedia.org/wiki/The_Art_of_Computer_Programming|3|https://en.wikipedia.org/wiki/The_Art_of_Computer_Programming#Volume_2.C2.A0.E2.80.93_Seminumerical_Algorithms^0|0|1|2|1|R|N|0|H|J|0|2F|5|1|2M|V|2|3I|18|3|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|12|8|@]|D|@$9|13|A|14|1|15]|$9|16|A|17|1|18]|$9|19|A|1A|1|1B]|$9|1C|A|1D|1|1E]]|E|$]]|$1|H|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]|P|$5|K|L|M|E|$N|Q]]|R|$5|K|L|M|E|$N|S]]|T|$5|K|L|M|E|$N|U]]]]

The least common multiple (lcm) of <code>a</code> and <code>b</code> is their product divided by their greatest common divisor (gcd) ( i.e. <code>lcm(a, b) = ab/gcd(a,b)</code>). 

So, the question becomes, how to find the gcd? The <a href="http://en.wikipedia.org/wiki/Euclidean_algorithm" rel="noreferrer">Euclidean algorithm</a> is generally how the gcd is computed. The direct implementation of the classic algorithm is efficient, but there are variations that take advantage of binary arithmetic to do a little better. See <a href="https://en.wikipedia.org/wiki/Donald_Knuth" rel="noreferrer">Knuth</a>'s "<a href="https://en.wikipedia.org/wiki/The_Art_of_Computer_Programming" rel="noreferrer">The Art of Computer Programming</a>" <a href="https://en.wikipedia.org/wiki/The_Art_of_Computer_Programming#Volume_2.C2.A0.E2.80.93_Seminumerical_Algorithms" rel="noreferrer">Volume 2, "Seminumerical Algorithms" § 4.5.2</a>.

blocks|key|1210105|text|我认为"reduction+by+the+greatest+common+divider“的方法应该更快。首先计算GCD+(例如使用Euclid's+algorithm)，然后将两个数字的乘积除以GCD。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1210106|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Lowest_common_multiple#Reduction_by_the_greatest_common_divisor|1|http://en.wikipedia.org/wiki/Euclidean_algorithm^0|4|14|0|1U|I|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

I think that the approach of "<a href="http://en.wikipedia.org/wiki/Lowest_common_multiple#Reduction_by_the_greatest_common_divisor" rel="nofollow noreferrer">reduction by the greatest common divider</a>" should be faster. Start by calculating the GCD (e.g. using <a href="http://en.wikipedia.org/wiki/Euclidean_algorithm" rel="nofollow noreferrer">Euclid's algorithm</a>), then divide the product of the two numbers by the GCD.

blocks|key|1210855|text|首先，你必须找到最大的公约数|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1210856|for(int+i=1;+i<=a+&&+i<=b;+i%2B%2B)+{

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

}|code-block|syntax|javascript|1210857|在此之后，使用GCD，您可以很容易地找到最小公倍数，如下所示|1210858|lcm+=+a+/+gcd+*+b;|1210859|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

First of all, you have to find the greatest common divisor

<pre><code>for(int i=1; i&lt;=a &amp;&amp; i&lt;=b; i++) {

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

}
</code></pre>

After that, using the GCD you can easily find the least common multiple like this

<pre><code>lcm = a / gcd * b;
</code></pre>

blocks|key|996692|text|在下面的C%2B%2B中没有溢出的最佳解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|996693|#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%25b);
}

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;
}|code-block|syntax|javascript|996694|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Best solution in C++ below without overflowing

<pre class="lang-cpp prettyprint-override"><code>#include &lt;iostream&gt;
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&gt;b)
 return (a/gcd(a,b))*b;
 else
 return (b/gcd(a,b))*a; 
} 

int main()
{
 long long int a ,b ;
 cin&gt;&gt;a&gt;&gt;b;
 cout&lt;&lt;lcm(a,b)&lt;&lt;endl; 
 return 0;
}
</code></pre>

blocks|key|1210905|text|我不知道它是否经过优化，但可能是最简单的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1210906|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%2B%2B)
++++{
++++++++if+((min*i)%25max+==+0)
++++++++{
++++++++++++res+=+min*i;
++++++++++++break;
++++++++}
++++}
++++Console.Write("{0}",+res);
}|code-block|syntax|javascript|1210907|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I don't know whether it is optimized or not, but probably the easiest one:

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

blocks|key|996844|text|这是一种在python中查找两个数字的LCM的高效方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|996845|def+gcd(a,+b):
++++if+min(a,+b)+==+0:
++++++++return+max(a,+b)
++++a_1+=+max(a,+b)+%25+min(a,+b)
++++return+gcd(a_1,+min(a,+b))

def+lcm(a,+b):
++++return+(a+*+b)+//+gcd(a,+b)|code-block|syntax|javascript|996846|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is a highly efficient approach to find the LCM of two numbers in python.
<pre><code>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)
</code></pre>

blocks|key|996949|text|使用欧几里德算法找到gcd，然后计算lcm除以gcd和b的乘积，这对我很有效。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|996950|int+euclidgcd(int+a,+int+b){
++++++++if(b==0)
++++++++return+a;
++++++++int+a_rem+=+a+%25+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;+++++++++++
++++}|code-block|syntax|javascript|996951|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Using Euclidean algorithm to find gcd and then calculating the lcm dividing a by the product of gcd and b worked for me.
<pre><code>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 &gt;&gt; a &gt;&gt; b;
 std::cout &lt;&lt; lcm(a, b) &lt;&lt; std::endl;
 return 0; 
 }
</code></pre>

blocks|key|995618|text|取两个数中较大数的连续倍数，直到结果是较小数的倍数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|995619|这也许行得通..|995620|+++public+int+LCM(int+x,+int+y)
+++{
+++++++int+larger++=+x>y?+x:+y,
+++++++++++smaller+=+x>y?+y:+x,
+++++++++++candidate+=+larger+;
+++++++while+(candidate+%25+smaller++!=+0)+candidate+%2B=+larger+;
+++++++return+candidate;
+++}|code-block|syntax|javascript|995621|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Take successive multiples of the larger of the two numbers until the result is a multiple of the smaller. 

this might work..

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

blocks|key|996718|text|C%2B%2B模板。编译时|type|unstyled|depth|inlineStyleRanges|entityRanges|data|996719|#include+<iostream>

const+int+lhs+=+8,+rhs+=+12;

template<int+n,+int+mod_lhs=n+%25+lhs,+int+mod_rhs=n+%25+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>();
}|code-block|syntax|javascript|996720|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

C++ template. Compile time

<pre class="lang-cpp prettyprint-override"><code>#include &lt;iostream&gt;

const int lhs = 8, rhs = 12;

template&lt;int n, int mod_lhs=n % lhs, int mod_rhs=n % rhs&gt; struct calc {
 calc() { }
};

template&lt;int n&gt; struct calc&lt;n, 0, 0&gt; {
 calc() { std::cout &lt;&lt; n &lt;&lt; std::endl; }
};

template&lt;int n, int mod_rhs&gt; struct calc&lt;n, 0, mod_rhs&gt; {
 calc() { }
};

template&lt;int n, int mod_lhs&gt; struct calc &lt;n, mod_lhs, 0&gt; {
 calc() { }
};

template&lt;int n&gt; struct lcm {
 lcm() {
 lcm&lt;n-1&gt;();
 calc&lt;n&gt;();
 }
};

template&lt;&gt; struct lcm&lt;0&gt; {
 lcm() {}
};

int main() {
 lcm&lt;lhs * rhs&gt;();
}
</code></pre>

blocks|key|996748|text|2个数字的乘积等于LCM+*+GCD或HCF。因此，找到LCM的最好方法是找到GCD，然后用GCD划分产品。也就是说，LCM(a，b)+=+(a*+b)+/GCD(a，b)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|996749|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Product of 2 numbers is equal to LCM * GCD or HCF. So best way to find LCM is to find GCD and divide the product with GCD. That is, LCM(a,b) = (a*b)/GCD(a,b).

blocks|key|996802|text|欧几里得GCD代码片段|type|unstyled|depth|inlineStyleRanges|entityRanges|data|996803|int+findGCD(int+a,+int+b)+{
++++++++if(a+<+0+%7C%7C+b+<+0)
++++++++++++return+-1;

++++++++if+(a+==+0)
++++++++++++return+b;
++++++++else+if+(b+==+0)
++++++++++++return+a;
++++++++else+
++++++++++++return+findGCD(b,+a+%25+b);
++++}|code-block|syntax|javascript|996804|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Euclidean GCD code snippet

<pre><code>int findGCD(int a, int b) {
 if(a &lt; 0 || b &lt; 0)
 return -1;

 if (a == 0)
 return b;
 else if (b == 0)
 return a;
 else 
 return findGCD(b, a % b);
 }
</code></pre>

blocks|key|996913|text|没有比使用内置函数更有效的方法了！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|996914|从Python3.8开始，数学库中添加了lcm()函数。并且可以使用以下签名进行调用：|offset|length|style|CODE|996915|math.lcm(*integers)|code-block|syntax|javascript|996916|返回指定整数参数的最小公倍数。如果所有参数都非零，则返回值是所有参数的倍数的最小正整数。如果任一参数为零，则返回值为0。不带参数的lcm()返回1。|996917|entityMap^0|0|K|5|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|U|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

<h2>There is no way more efficient than using a built-in function!</h2>

As of Python 3.8 <code>lcm()</code> function has been added in math library. And can be called with folowing signature:

<pre><code>math.lcm(*integers)
</code></pre>

Returns the least common multiple of the specified integer arguments. If all arguments are nonzero, then the returned value is the smallest positive integer that is a multiple of all arguments. If any of the arguments is zero, then the returned value is 0. lcm() without arguments returns 1.

blocks|key|1211275|text|扩展@John+D.+Cook答案，该答案也标记为此问题的答案。(+https://stackoverflow.com/a/3154503/13272795)，我正在分享算法来寻找n个数字的LCM，它可以是2个数字的LCM，也可以是任何数字的LCM。此代码的源代码是this|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1211276|+int+gcd(int+a,+int+b)
+{
+++++if+(b+==+0)
+++++++++return+a;
+++++return+gcd(b,+a+%25+b);
+}

++//+Returns+LCM+of+array+elements
+ll+findlcm(int+arr[],+int+n)
+{
++++//+Initialize+result
+++++ll+ans+=+arr[0];

+++//+ans+contains+LCM+of+arr[0],+..arr[i]
+++//+after+i'th+iteration,
+++++++for+(int+i+=+1;+i+<+n;+i%2B%2B)
+++++++++++ans+=+arr[i]+*+ans/gcd(arr[i],+ans);
+++++++return+ans;
+}|code-block|syntax|javascript|1211277|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/25188/john-d-cook|1|https://stackoverflow.com/a/3154503/13272795|2|https://www.geeksforgeeks.org/lcm-of-given-array-elements/^0|2|D|0|Y|18|1|3P|4|2|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]|$A|Y|B|Z|1|10]|$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|15|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]|Q|$5|L|M|N|C|$O|R]]|S|$5|L|M|N|C|$O|T]]]]

Extending <a href="https://stackoverflow.com/users/25188/john-d-cook">@John D. Cook</a> answer that is also marked answer for this question. ( <a href="https://stackoverflow.com/a/3154503/13272795">https://stackoverflow.com/a/3154503/13272795</a>), I am sharing algorithm to find LCM of n numbers, it maybe LCM of 2 numbers or any numbers. Source for this code is <a href="https://www.geeksforgeeks.org/lcm-of-given-array-elements/" rel="nofollow noreferrer">this</a>
<pre class="lang-cpp prettyprint-override"><code> int gcd(int a, int b)
 {
 if (b == 0)
 return a;
 return gcd(b, a % b);
 }

 // Returns LCM of array elements
 ll findlcm(int arr[], int n)
 {
 // Initialize result
 ll ans = arr[0];

 // ans contains LCM of arr[0], ..arr[i]
 // after i'th iteration,
 for (int i = 1; i &lt; n; i++)
 ans = arr[i] * ans/gcd(arr[i], ans);
 return ans;
 }
</code></pre>

blocks|key|997020|text|首先使用功效方法计算GCD，然后使用以下公式从gcd获得lcm|type|unstyled|depth|inlineStyleRanges|entityRanges|data|997021|++++++++++++++++++++++++lcm+=+(n1+*+n2)+/+gcd;|code-block|syntax|javascript|997022|对于GCD的计算，我们使用以下逻辑|997023|++++++++for+(int+i+=+1;+i+<=+n1+&&+i+<=+n2;+%2B%2Bi)+{
++++++++++++++++if+(n1+%25+i+==+0+&&+n2+%25+i+==+0)
++++++++++++++++++++gcd+=+i;
+++++++++}+|997024|我们也可以使用calculate+LCM+using+recursion。这是使用gcd查找lcm的java示例。|offset|length|997025|++public+class+LCMUsingGCD+{
++++++public+static+void+main(String[]+args)+{

++++int+n1+=+40,+n2+=+50,+gcd+=+1;

++++for+(int+i+=+1;+i+<=+n1+&&+i+<=+n2;+%2B%2Bi)+{
++++++++if+(n1+%25+i+==+0+&&+n2+%25+i+==+0)
++++++++++++gcd+=+i;
++++}

++++int+lcm+=+(n1+*+n2)+/+gcd;
++++System.out.println("LCM++:"+%2B+lcm+%2B+"+of+n1+:+"+%2B+n1+%2B+"+and+n2+:+"
++++++++++++%2B+n2);
}|997026|}|997027|entityMap|0|LINK|mutability|MUTABLE|url|https://www.javavogue.com/2015/01/java-program-to-find-lcm-of-two-numbers/^0|0|0|0|0|7|T|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|14|8|@]|9|@$M|15|N|16|1|17]]|A|$]]|$1|O|3|P|5|D|7|18|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

First calculate GCD using efficacy ways then get lcm from gcd using this formula
<pre><code> lcm = (n1 * n2) / gcd;
</code></pre>
For calculation for GCD we use this logic
<pre><code> for (int i = 1; i &lt;= n1 &amp;&amp; i &lt;= n2; ++i) {
 if (n1 % i == 0 &amp;&amp; n2 % i == 0)
 gcd = i;
 } 
</code></pre>
We can <a href="https://www.javavogue.com/2015/01/java-program-to-find-lcm-of-two-numbers/" rel="nofollow noreferrer">calculate LCM using recursion</a> also . This is java example for find lcm using gcd .
<pre><code> public class LCMUsingGCD {
 public static void main(String[] args) {

 int n1 = 40, n2 = 50, gcd = 1;

 for (int i = 1; i &lt;= n1 &amp;&amp; i &lt;= n2; ++i) {
 if (n1 % i == 0 &amp;&amp; n2 % i == 0)
 gcd = i;
 }

 int lcm = (n1 * n2) / gcd;
 System.out.println(&quot;LCM :&quot; + lcm + &quot; of n1 : &quot; + n1 + &quot; and n2 : &quot;
 + n2);
}
</code></pre>
}

What is the most efficient way to calculate the least common multiple of two integers?

I just came up with this, but it definitely leaves something to be desired.

<pre class="lang-java prettyprint-override"><code>int n=7, m=4, n1=n, m1=m;

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

System.out.println( "lcm is " + m1 );
</code></pre>

What is the most efficient way to calculate the least common multiple of two integers?

计算两个整数的最小公倍数的最有效方法是什么？我刚刚想出了这个，但它确实留下了一些令人期待的东西。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 );

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

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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