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|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|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|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|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|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|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|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|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...

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

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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