blocks|key|1522037|text|您可以通过迭代计算两个数字的LCM来计算两个以上数字的LCM，即|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522038|lcm(a,b,c)+=+lcm(a,lcm(b,c))|code-block|syntax|javascript|1522039|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|$]]

You can compute the LCM of more than two numbers by iteratively computing the LCM of two numbers, i.e.

<pre><code>lcm(a,b,c) = lcm(a,lcm(b,c))
</code></pre>

blocks|key|1737108|text|在Python中(修改后的primes.py)：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1737109|def+gcd(a,+b):
++++"""Return+greatest+common+divisor+using+Euclid's+Algorithm."""
++++while+b:++++++
++++++++a,+b+=+b,+a+%25+b
++++return+a

def+lcm(a,+b):
++++"""Return+lowest+common+multiple."""
++++return+a+*+b+//+gcd(a,+b)

def+lcmm(*args):
++++"""Return+lcm+of+args."""+++
++++return+reduce(lcm,+args)|code-block|syntax|javascript|1737110|用法：|1737111|>>>+lcmm(100,+23,+98)
112700
>>>+lcmm(*range(1,+20))
232792560|1737112|reduce()的工作原理类似于that|style|CODE|1737113|>>>+f+=+lambda+a,b:+"f(%25s,%25s)"+%25+(a,b)
>>>+print+reduce(f,+"abcd")
f(f(f(a,b),c),d)|1737114|entityMap|0|LINK|mutability|MUTABLE|url|http://www.4dsolutions.net/cgi-bin/py2html.cgi?script=/ocn/python/primes.py|1|http://ideone.com/353pA^0|D|9|0|0|0|0|0|0|8|G|4|1|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|F|7|16|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|17|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|18|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|19|8|@$A|1A|B|1B|O|P]]|9|@$A|1C|B|1D|1|1E]]|C|$]]|$1|Q|3|R|5|F|7|1F|8|@]|9|@]|C|$G|H]]|$1|S|3|-4|5|6|7|1G|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]|10|$5|V|W|X|C|$Y|11]]]]

In Python (modified <a href="http://www.4dsolutions.net/cgi-bin/py2html.cgi?script=/ocn/python/primes.py" rel="noreferrer">primes.py</a>):

<pre><code>def gcd(a, b):
 """Return greatest common divisor using Euclid's Algorithm."""
 while b: 
 a, b = b, a % b
 return a

def lcm(a, b):
 """Return lowest common multiple."""
 return a * b // gcd(a, b)

def lcmm(*args):
 """Return lcm of args.""" 
 return reduce(lcm, args)
</code></pre>

Usage:

<pre><code>&gt;&gt;&gt; lcmm(100, 23, 98)
112700
&gt;&gt;&gt; lcmm(*range(1, 20))
232792560
</code></pre>

<code>reduce()</code> works something like <a href="http://ideone.com/353pA" rel="noreferrer">that</a>:

<pre><code>&gt;&gt;&gt; f = lambda a,b: "f(%s,%s)" % (a,b)
&gt;&gt;&gt; print reduce(f, "abcd")
f(f(f(a,b),c),d)
</code></pre>

blocks|key|1737164|text|我在Haskell中发现了这一点：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1737165|lcm'+::+Integral+a+=>+a+->+a+->+a
lcm'+a+b+=+a`div`(gcd+a+b)+*+b
lcm+::+Integral+a+=>+[a]+->+a
lcm+(n:ns)+=+foldr+lcm'+n+ns|code-block|syntax|javascript|1737166|我甚至花时间编写了我自己的gcd函数，结果却在Prelude中找到了它！今天我学到了很多东西:D|offset|length|style|CODE|1737167|entityMap^0|0|0|D|3|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I just figured this out in Haskell:

<pre><code>lcm' :: Integral a =&gt; a -&gt; a -&gt; a
lcm' a b = a`div`(gcd a b) * b
lcm :: Integral a =&gt; [a] -&gt; a
lcm (n:ns) = foldr lcm' n ns
</code></pre>

I even took the time to write my own <code>gcd</code> function, only to find it in Prelude! Lots of learning for me today :D

blocks|key|1737198|text|下面是一个ECMA风格的实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1737199|function+gcd(a,+b){
++++//+Euclidean+algorithm
++++while+(b+!=+0){
++++++++var+temp+=+b;
++++++++b+=+a+%25+b;
++++++++a+=+temp;
++++}
++++return+a;
}

function+lcm(a,+b){
++++return+(a+*+b+/+gcd(a,+b));
}

function+lcmm(args){
++++//+Recursively+iterate+through+pairs+of+arguments
++++//+i.e.+lcm(args[0],+lcm(args[1],+lcm(args[2],+args[3])))

++++if(args.length+==+2){
++++++++return+lcm(args[0],+args[1]);
++++}+else+{
++++++++var+arg0+=+args[0];
++++++++args.shift();
++++++++return+lcm(arg0,+lcmm(args));
++++}
}|code-block|syntax|javascript|1737200|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's an ECMA-style implementation:
<pre><code>function gcd(a, b){
 // Euclidean algorithm
 while (b != 0){
 var temp = b;
 b = a % b;
 a = temp;
 }
 return a;
}

function lcm(a, b){
 return (a * b / gcd(a, b));
}

function lcmm(args){
 // Recursively iterate through pairs of arguments
 // i.e. lcm(args[0], lcm(args[1], lcm(args[2], args[3])))

 if(args.length == 2){
 return lcm(args[0], args[1]);
 } else {
 var arg0 = args[0];
 args.shift();
 return lcm(arg0, lcmm(args));
 }
}
</code></pre>

blocks|key|1522235|text|你可以用另一种方法--假设有n个numbers.Take，一对连续的数字，并将它的线性矩阵存储在另一个数组中。在第一次迭代时这样做，程序会像(0,1)，(2,3)那样从0开始n/2+iterations.Then下一个拾取对，因此on.Compute它们的线性矩阵并存储在另一个数组中。这样做，直到只剩下一个数组。(如果n是奇数，则不可能找到lcm+)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522236|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|$]]

you can do it another way - 
Let there be n numbers.Take a pair of consecutive numbers and save its lcm in another array. Doing this at first iteration program does n/2 iterations.Then next pick up pair starting from 0 like (0,1) , (2,3) and so on.Compute their LCM and store in another array. Do this until you are left with one array.
(it is not possible to find lcm if n is odd)

blocks|key|1522286|text|一些不需要gcd函数的Python代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522287|from+sys+import+argv+

def+lcm(x,y):
++++tmp=x
++++while+(tmp%25y)!=0:
++++++++tmp%2B=x
++++return+tmp

def+lcmm(*args):
++++return+reduce(lcm,args)

args=map(int,argv[1:])
print+lcmm(*args)|code-block|syntax|javascript|1522288|下面是它在终端中的样子：|1522289|$+python+lcm.py+10+15+17
510|1522290|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|$]]

Some Python code that doesn't require a function for gcd:

<pre><code>from sys import argv 

def lcm(x,y):
 tmp=x
 while (tmp%y)!=0:
 tmp+=x
 return tmp

def lcmm(*args):
 return reduce(lcm,args)

args=map(int,argv[1:])
print lcmm(*args)
</code></pre>

Here's what it looks like in the terminal:

<pre><code>$ python lcm.py 10 15 17
510
</code></pre>

blocks|key|1522339|text|这是Virgil+Disgr4ce实现的C#端口：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522340|public+class+MathUtils
{
++++///+<summary>
++++///+Calculates+the+least+common+multiple+of+2%2B+numbers.
++++///+</summary>
++++///+<remarks>
++++///+Uses+recursion+based+on+lcm(a,b,c)+=+lcm(a,lcm(b,c)).
++++///+Ported+from+http://stackoverflow.com/a/2641293/420175.
++++///+</remarks>
++++public+static+Int64+LCM(IList<Int64>+numbers)
++++{
++++++++if+(numbers.Count+<+2)
++++++++++++throw+new+ArgumentException("you+must+pass+two+or+more+numbers");
++++++++return+LCM(numbers,+0);
++++}

++++public+static+Int64+LCM(params+Int64[]+numbers)
++++{
++++++++return+LCM((IList<Int64>)numbers);
++++}

++++private+static+Int64+LCM(IList<Int64>+numbers,+int+i)
++++{
++++++++//+Recursively+iterate+through+pairs+of+arguments
++++++++//+i.e.+lcm(args[0],+lcm(args[1],+lcm(args[2],+args[3])))

++++++++if+(i+%2B+2+==+numbers.Count)
++++++++{
++++++++++++return+LCM(numbers[i],+numbers[i%2B1]);
++++++++}
++++++++else
++++++++{
++++++++++++return+LCM(numbers[i],+LCM(numbers,+i%2B1));
++++++++}
++++}

++++public+static+Int64+LCM(Int64+a,+Int64+b)
++++{
++++++++return+(a+*+b+/+GCD(a,+b));
++++}

++++///+<summary>
++++///+Finds+the+greatest+common+denominator+for+2+numbers.
++++///+</summary>
++++///+<remarks>
++++///+Also+from+http://stackoverflow.com/a/2641293/420175.
++++///+</remarks>
++++public+static+Int64+GCD(Int64+a,+Int64+b)
++++{
++++++++//+Euclidean+algorithm
++++++++Int64+t;
++++++++while+(b+!=+0)
++++++++{
++++++++++++t+=+b;
++++++++++++b+=+a+%25+b;
++++++++++++a+=+t;
++++++++}
++++++++return+a;
++++}
}'|code-block|syntax|javascript|1522341|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 C# port of Virgil Disgr4ce's implemenation:

<pre><code>public class MathUtils
{
 /// &lt;summary&gt;
 /// Calculates the least common multiple of 2+ numbers.
 /// &lt;/summary&gt;
 /// &lt;remarks&gt;
 /// Uses recursion based on lcm(a,b,c) = lcm(a,lcm(b,c)).
 /// Ported from http://stackoverflow.com/a/2641293/420175.
 /// &lt;/remarks&gt;
 public static Int64 LCM(IList&lt;Int64&gt; numbers)
 {
 if (numbers.Count &lt; 2)
 throw new ArgumentException("you must pass two or more numbers");
 return LCM(numbers, 0);
 }

 public static Int64 LCM(params Int64[] numbers)
 {
 return LCM((IList&lt;Int64&gt;)numbers);
 }

 private static Int64 LCM(IList&lt;Int64&gt; numbers, int i)
 {
 // Recursively iterate through pairs of arguments
 // i.e. lcm(args[0], lcm(args[1], lcm(args[2], args[3])))

 if (i + 2 == numbers.Count)
 {
 return LCM(numbers[i], numbers[i+1]);
 }
 else
 {
 return LCM(numbers[i], LCM(numbers, i+1));
 }
 }

 public static Int64 LCM(Int64 a, Int64 b)
 {
 return (a * b / GCD(a, b));
 }

 /// &lt;summary&gt;
 /// Finds the greatest common denominator for 2 numbers.
 /// &lt;/summary&gt;
 /// &lt;remarks&gt;
 /// Also from http://stackoverflow.com/a/2641293/420175.
 /// &lt;/remarks&gt;
 public static Int64 GCD(Int64 a, Int64 b)
 {
 // Euclidean algorithm
 Int64 t;
 while (b != 0)
 {
 t = b;
 b = a % b;
 a = t;
 }
 return a;
 }
}'
</code></pre>

blocks|key|1522367|text|GCD需要对负数进行一点修正：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522368|def+gcd(x,y):
++while+y:
++++if+y<0:
++++++x,y=-x,-y
++++x,y=y,x+%25+y
++++return+x

def+gcdl(*list):
++return+reduce(gcd,+*list)

def+lcm(x,y):
++return+x*y+/+gcd(x,y)

def+lcml(*list):
++return+reduce(lcm,+*list)|code-block|syntax|javascript|1522369|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|$]]

GCD needs a little correction for negative numbers:

<pre><code>def gcd(x,y):
 while y:
 if y&lt;0:
 x,y=-x,-y
 x,y=y,x % y
 return x

def gcdl(*list):
 return reduce(gcd, *list)

def lcm(x,y):
 return x*y / gcd(x,y)

def lcml(*list):
 return reduce(lcm, *list)
</code></pre>

blocks|key|1522378|text|这个怎么样？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522379|from+operator+import+mul+as+MULTIPLY

def+factors(n):
++++f+=+{}+#+a+dict+is+necessary+to+create+'factor+:+exponent'+pairs+
++++divisor+=+2
++++while+n+>+1:
++++++++while+(divisor+<=+n):
++++++++++++if+n+%25+divisor+==+0:
++++++++++++++++n+/=+divisor
++++++++++++++++f[divisor]+=+f.get(divisor,+0)+%2B+1
++++++++++++else:
++++++++++++++++divisor+%2B=+1
++++return+f


def+mcm(numbers):
++++#numbers+is+a+list+of+numbers+so+not+restricted+to+two+items
++++high_factors+=+{}
++++for+n+in+numbers:
++++++++fn+=+factors(n)
++++++++for+(key,+value)+in+fn.iteritems():
++++++++++++if+high_factors.get(key,+0)+<+value:+#+if+fact+not+in+dict+or+<+val
++++++++++++++++high_factors[key]+=+value
++++return+reduce+(MULTIPLY,+((k+**+v)+for+k,+v+in+high_factors.items()))|code-block|syntax|javascript|1522380|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|$]]

How about this?

<pre><code>from operator import mul as MULTIPLY

def factors(n):
 f = {} # a dict is necessary to create 'factor : exponent' pairs 
 divisor = 2
 while n &gt; 1:
 while (divisor &lt;= n):
 if n % divisor == 0:
 n /= divisor
 f[divisor] = f.get(divisor, 0) + 1
 else:
 divisor += 1
 return f


def mcm(numbers):
 #numbers is a list of numbers so not restricted to two items
 high_factors = {}
 for n in numbers:
 fn = factors(n)
 for (key, value) in fn.iteritems():
 if high_factors.get(key, 0) &lt; value: # if fact not in dict or &lt; val
 high_factors[key] = value
 return reduce (MULTIPLY, ((k ** v) for k, v in high_factors.items()))
</code></pre>

blocks|key|1522385|text|ES6样式|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522386|function+gcd(...numbers)+{
++return+numbers.reduce((a,+b)+=>+b+===+0+?+a+:+gcd(b,+a+%25+b));
}

function+lcm(...numbers)+{
++return+numbers.reduce((a,+b)+=>+Math.abs(a+*+b)+/+gcd(a,+b));
}|code-block|syntax|javascript|1522387|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|$]]

ES6 style

<pre><code>function gcd(...numbers) {
 return numbers.reduce((a, b) =&gt; b === 0 ? a : gcd(b, a % b));
}

function lcm(...numbers) {
 return numbers.reduce((a, b) =&gt; Math.abs(a * b) / gcd(a, b));
}
</code></pre>

blocks|key|1522451|text|使用LINQ，你可以这样写：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522452|static+int+LCM(int[]+numbers)
{
++++return+numbers.Aggregate(LCM);
}

static+int+LCM(int+a,+int+b)
{
++++return+a+*+b+/+GCD(a,+b);
}|code-block|syntax|javascript|1522453|应该添加using+System.Linq;，并且不要忘记处理异常...|offset|length|style|CODE|1522454|entityMap^0|0|0|4|I|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Using LINQ you could write:

<pre><code>static int LCM(int[] numbers)
{
 return numbers.Aggregate(LCM);
}

static int LCM(int a, int b)
{
 return a * b / GCD(a, b);
}
</code></pre>

Should add <code>using System.Linq;</code> and don't forget to handle the exceptions ...

blocks|key|1522470|text|clc;

data+=+[1+2+3+4+5]

LCM=1;

for+i=1:1:length(data)

++++LCM+=+lcm(LCM,data(i))

end+|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1522471|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>clc;

data = [1 2 3 4 5]

LCM=1;

for i=1:1:length(data)

 LCM = lcm(LCM,data(i))

end 
</code></pre>

blocks|key|1737534|text|我们有可以工作的实现of+Least+Common+Multiple+on+Calculla，它可以处理任意数量的输入，还可以显示步骤。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1737535|我们所做的是：|1737536|0:+Assume+we+got+inputs[]+array,+filled+with+integers.+So,+for+example:
+++inputsArray+=+[6,+15,+25,+...]
+++lcm+=+1

1:+Find+minimal+prime+factor+for+each+input.
+++Minimal+means+for+6+it's+2,+for+25+it's+5,+for+34+it's+17
+++minFactorsArray+=+[]

2:+Find+lowest+from+minFactors:
+++minFactor+=+MIN(minFactorsArray)

3:+lcm+*=+minFactor

4:+Iterate+minFactorsArray+and+if+the+factor+for+given+input+equals+minFactor,+then+divide+the+input+by+it:
++for+(inIdx+in+minFactorsArray)
++++if+minFactorsArray[inIdx]+==+minFactor
++++++inputsArray[inIdx]+\=+minFactor

5:+repeat+steps+1-4+until+there+is+nothing+to+factorize+anymore.+
+++So,+until+inputsArray+contains+only+1-s.|code-block|syntax|javascript|1737537|就是这样--你得到了你的lcm。|1737538|entityMap|0|LINK|mutability|MUTABLE|url|http://www.calculla.com/en/least_common_multiple^0|A|10|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

We have working implementation <a href="http://www.calculla.com/en/least_common_multiple" rel="nofollow">of Least Common Multiple on Calculla</a> which works for any number of inputs also displaying the steps.

What we do is:

<pre><code>0: Assume we got inputs[] array, filled with integers. So, for example:
 inputsArray = [6, 15, 25, ...]
 lcm = 1

1: Find minimal prime factor for each input.
 Minimal means for 6 it's 2, for 25 it's 5, for 34 it's 17
 minFactorsArray = []

2: Find lowest from minFactors:
 minFactor = MIN(minFactorsArray)

3: lcm *= minFactor

4: Iterate minFactorsArray and if the factor for given input equals minFactor, then divide the input by it:
 for (inIdx in minFactorsArray)
 if minFactorsArray[inIdx] == minFactor
 inputsArray[inIdx] \= minFactor

5: repeat steps 1-4 until there is nothing to factorize anymore. 
 So, until inputsArray contains only 1-s.
</code></pre>

And that's it - you got your lcm.

blocks|key|1522569|text|LCM既具有结合性，又具有交换性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522570|LCM(a，b，c)=LCM(LCM(a，b)，c)=LCM(a，LCM(b，c))|1522571|下面是用C编写的示例代码：|1522572|int+main()
{
++int+a[20],i,n,result=1;++//+assumption:+count+can't+exceed+20
++printf("Enter+number+of+numbers+to+calculate+LCM(less+than+20):");
++scanf("%25d",&n);
++printf("Enter+%25d++numbers+to+calculate+their+LCM+:",n);
++for(i=0;i<n;i%2B%2B)
++++scanf("%25d",&a[i]);
+for(i=0;i<n;i%2B%2B)
+++result=lcm(result,a[i]);
+printf("LCM+of+given+numbers+=+%25d\n",result);
+return+0;
}

int+lcm(int+a,int+b)
{
++int+gcd=gcd_two_numbers(a,b);
++return+(a*b)/gcd;
}

int+gcd_two_numbers(int+a,int+b)
{
+++int+temp;
+++if(a>b)
+++{
+++++temp=a;
+++++a=b;
+++++b=temp;
+++}
++if(b%25a==0)
++++return+a;
++else
++++return+gcd_two_numbers(b%25a,a);
}|code-block|syntax|javascript|1522573|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

LCM is both associative and commutative.

LCM(a,b,c)=LCM(LCM(a,b),c)=LCM(a,LCM(b,c))

here is sample code in C:

<pre><code>int main()
{
 int a[20],i,n,result=1; // assumption: count can't exceed 20
 printf("Enter number of numbers to calculate LCM(less than 20):");
 scanf("%d",&amp;n);
 printf("Enter %d numbers to calculate their LCM :",n);
 for(i=0;i&lt;n;i++)
 scanf("%d",&amp;a[i]);
 for(i=0;i&lt;n;i++)
 result=lcm(result,a[i]);
 printf("LCM of given numbers = %d\n",result);
 return 0;
}

int lcm(int a,int b)
{
 int gcd=gcd_two_numbers(a,b);
 return (a*b)/gcd;
}

int gcd_two_numbers(int a,int b)
{
 int temp;
 if(a&gt;b)
 {
 temp=a;
 a=b;
 b=temp;
 }
 if(b%a==0)
 return a;
 else
 return gcd_two_numbers(b%a,a);
}
</code></pre>

blocks|key|1522623|text|我会使用这个(C#)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522624|static+long+LCM(long[]+numbers)
{
++++return+numbers.Aggregate(lcm);
}
static+long+lcm(long+a,+long+b)
{
++++return+Math.Abs(a+*+b)+/+GCD(a,+b);
}
static+long+GCD(long+a,+long+b)
{
++++return+b+==+0+?+a+:+GCD(b,+a+%25+b);
}|code-block|syntax|javascript|1522625|只是一些澄清，因为乍一看并不是很清楚这段代码在做什么：|1522626|Aggregate是一种Linq扩展方法，因此您不能忘记在引用中添加using+System.Linq。|1522627|Aggregate得到一个累加函数，因此我们可以在IEnumerable上使用属性lcm(a，b，c)+=+lcm(a，lcm(b，c))。More+on+Aggregate|offset|length|1522628|GCD的计算使用了Euclidean+algorithm。|1522629|lcm计算使用Abs(a*+b)+/gcd(a，b)，参见Reduction+by+the+greatest+common+divisor。|1522630|希望这能帮上忙|1522631|entityMap|0|LINK|mutability|MUTABLE|url|https://msdn.microsoft.com/en-us/library/vstudio/bb548651(v=vs.100).aspx|1|http://en.wikipedia.org/wiki/Euclidean_algorithm|2|http://en.wikipedia.org/wiki/Least_common_multiple^0|0|0|0|0|1Y|H|0|0|9|J|1|0|T|14|2|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|18|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|19|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1A|8|@]|9|@$M|1B|N|1C|1|1D]]|A|$]]|$1|O|3|P|5|6|7|1E|8|@]|9|@$M|1F|N|1G|1|1H]]|A|$]]|$1|Q|3|R|5|6|7|1I|8|@]|9|@$M|1J|N|1K|1|1L]]|A|$]]|$1|S|3|T|5|6|7|1M|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]|12|$5|X|Y|Z|A|$10|13]]|14|$5|X|Y|Z|A|$10|15]]]]

I would go with this one (C#): 

<pre><code>static long LCM(long[] numbers)
{
 return numbers.Aggregate(lcm);
}
static long lcm(long a, long b)
{
 return Math.Abs(a * b) / GCD(a, b);
}
static long GCD(long a, long b)
{
 return b == 0 ? a : GCD(b, a % b);
}
</code></pre>

Just some clarifications, because at first glance it doesn't seams so clear what this code is doing:

Aggregate is a Linq Extension method, so you cant forget to add using System.Linq to your references.

Aggregate gets an accumulating function so we can make use of the property lcm(a,b,c) = lcm(a,lcm(b,c)) over an IEnumerable. <a href="https://msdn.microsoft.com/en-us/library/vstudio/bb548651(v=vs.100).aspx" rel="noreferrer">More on Aggregate</a>

GCD calculation makes use of the <a href="http://en.wikipedia.org/wiki/Euclidean_algorithm" rel="noreferrer">Euclidean algorithm</a>.

lcm calculation uses Abs(a*b)/gcd(a,b) , refer to <a href="http://en.wikipedia.org/wiki/Least_common_multiple" rel="noreferrer">Reduction by the greatest common divisor</a>.

Hope this helps,

blocks|key|1522704|text|方法compLCM接受一个向量并返回LCM。所有的数字都在向量in_numbers内。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522705|int+mathOps::compLCM(std::vector<int>+&in_numbers)
+{
++++int+tmpNumbers+=+in_numbers.size();
++++int+tmpMax+=+*max_element(in_numbers.begin(),+in_numbers.end());
++++bool+tmpNotDividable+=+false;

++++while+(true)
++++{
++++++++for+(int+i+=+0;+i+<+tmpNumbers+&&+tmpNotDividable+==+false;+i%2B%2B)
++++++++{
++++++++++++if+(tmpMax+%25+in_numbers[i]+!=+0+)
++++++++++++++++tmpNotDividable+=+true;
++++++++}

++++++++if+(tmpNotDividable+==+false)
++++++++++++return+tmpMax;
++++++++else
++++++++++++tmpMax%2B%2B;
++++}
}|code-block|syntax|javascript|1522706|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|$]]

Method compLCM takes a vector and returns LCM. All the numbers are within vector in_numbers.

<pre><code>int mathOps::compLCM(std::vector&lt;int&gt; &amp;in_numbers)
 {
 int tmpNumbers = in_numbers.size();
 int tmpMax = *max_element(in_numbers.begin(), in_numbers.end());
 bool tmpNotDividable = false;

 while (true)
 {
 for (int i = 0; i &lt; tmpNumbers &amp;&amp; tmpNotDividable == false; i++)
 {
 if (tmpMax % in_numbers[i] != 0 )
 tmpNotDividable = true;
 }

 if (tmpNotDividable == false)
 return tmpMax;
 else
 tmpMax++;
 }
}
</code></pre>

blocks|key|1737719|text|int+gcd(int+a,+int+b)+{++++++++if+(b+==+0)+return+a;++++++++return+gcd(b,+a%25b);+++++}+++++int+lcm(int[]+a,+int+n)+{++++++++int+res+=+1,+i;++++++++for+(i+=+0;+i+<+n;+i%2B%2B)+{++++++++++++res+=+res*a[i]/gcd(res,+a[i]);++++++++}+++++return+res;+}|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1737720|entityMap^0|0|6O|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

<code>int gcd(int a, int b) {
 if (b == 0) return a;
 return gcd(b, a%b);
 }
 int lcm(int[] a, int n) {
 int res = 1, i;
 for (i = 0; i &lt; n; i++) {
 res = res*a[i]/gcd(res, a[i]);
 }
 return res;
}</code>

blocks|key|1522768|text|下面是一个Python行程序(不包括导入)，它返回从1到20的整数的LCM：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522769|Python+3.5%2B导入：|1522770|from+functools+import+reduce
from+math+import+gcd|code-block|syntax|javascript|1522771|Python+2.7导入：|1522772|from+fractions+import+gcd|1522773|常见逻辑：|1522774|lcm+=+reduce(lambda+x,y:+x*y+//+gcd(x,+y),+range(1,+21))|1522775|请注意，在Python+2和Python+3中，运算符优先规则规定*和//运算符具有相同的优先级，因此它们从左到右应用。因此，x*y+//+z的意思是(x*y)+//+z而不是x+*+(y//z)。这两者通常会产生不同的结果。这对于浮点数除法来说并不重要，但对于floor+division来说却很重要。|offset|length|style|CODE|1522776|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/2/reference/expressions.html#operator-precedence|1|https://docs.python.org/3/reference/expressions.html#operator-precedence|2|https://stackoverflow.com/a/183870/832230^0|0|0|0|0|0|0|0|X|1|Z|2|1R|8|23|A|2G|A|5|8|0|E|8|1|3N|E|2|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|19|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1A|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1B|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|1C|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|1D|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|1E|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|1F|8|@$S|1G|T|1H|U|V]|$S|1I|T|1J|U|V]|$S|1K|T|1L|U|V]|$S|1M|T|1N|U|V]|$S|1O|T|1P|U|V]]|9|@$S|1Q|T|1R|1|1S]|$S|1T|T|1U|1|1V]|$S|1W|T|1X|1|1Y]]|A|$]]|$1|W|3|-4|5|6|7|1Z|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]|14|$5|Z|10|11|A|$12|15]]|16|$5|Z|10|11|A|$12|17]]]]

Here is a Python one-liner (not counting imports) to return the LCM of the integers from 1 to 20 inclusive:

Python 3.5+ imports:

<pre><code>from functools import reduce
from math import gcd
</code></pre>

Python 2.7 imports:

<pre><code>from fractions import gcd
</code></pre>

Common logic:

<pre><code>lcm = reduce(lambda x,y: x*y // gcd(x, y), range(1, 21))
</code></pre>

Note that in both <a href="https://docs.python.org/2/reference/expressions.html#operator-precedence" rel="nofollow noreferrer">Python 2</a> and <a href="https://docs.python.org/3/reference/expressions.html#operator-precedence" rel="nofollow noreferrer">Python 3</a>, operator precedence rules dictate that the <code>*</code> and <code>//</code> operators have the same precedence, and so they apply from left to right. As such, <code>x*y // z</code> means <code>(x*y) // z</code> and not <code>x * (y//z)</code>. The two typically produce different results. This wouldn't have mattered as much for float division but it does for <a href="https://stackoverflow.com/a/183870/832230">floor division</a>.

blocks|key|1522807|text|和Scala版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522808|def+gcd(a:+Int,+b:+Int):+Int+=+if+(b+==+0)+a+else+gcd(b,+a+%25+b)
def+gcd(nums:+Iterable[Int]):+Int+=+nums.reduce(gcd)
def+lcm(a:+Int,+b:+Int):+Int+=+if+(a+==+0+%7C%7C+b+==+0)+0+else+a+*+b+/+gcd(a,+b)
def+lcm(nums:+Iterable[Int]):+Int+=+nums.reduce(lcm)|code-block|syntax|javascript|1522809|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|$]]

And the Scala version:

<pre><code>def gcd(a: Int, b: Int): Int = if (b == 0) a else gcd(b, a % b)
def gcd(nums: Iterable[Int]): Int = nums.reduce(gcd)
def lcm(a: Int, b: Int): Int = if (a == 0 || b == 0) 0 else a * b / gcd(a, b)
def lcm(nums: Iterable[Int]): Int = nums.reduce(lcm)
</code></pre>

blocks|key|1737849|text|用于查找任意数字列表的lcm的函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1737850|+def+function(l):
+++++s+=+1
+++++for+i+in+l:
++++++++s+=+lcm(i,+s)
+++++return+s|code-block|syntax|javascript|1737851|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|$]]

Function to find lcm of any list of numbers:

<pre><code> def function(l):
 s = 1
 for i in l:
 s = lcm(i, s)
 return s
</code></pre>

blocks|key|1522887|text|为了好玩，这里有一个shell+(几乎任何shell)实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522888|#!/bin/sh
gcd()+{+++#+Calculate+$1+%25+$2+until+$2+becomes+zero.
++++++until+[+"$2"+-eq+0+];+do+set+--+"$2"+"$(($1%25$2))";+done
++++++echo+"$1"
++++++}

lcm()+{+++echo+"$((+$1+/+$(gcd+"$1"+"$2")+*+$2+))";+++}

while+[+$#+-gt+1+];+do
++++t="$(lcm+"$1"+"$2")"
++++shift+2
++++set+--+"$t"+"$@"
done
echo+"$1"|code-block|syntax|javascript|1522889|使用以下命令尝试：|1522890|$+./script+2+3+4+5+6|1522891|要获得|1522892|60|1522893|最大的输入和结果应该小于(2%5E63)-1，否则外壳数学将自动换行。|offset|length|style|CODE|1522894|entityMap^0|0|0|0|0|0|0|C|8|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|12|8|@$Q|13|R|14|S|T]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

Just for fun, a shell (almost any shell) implementation:

<pre><code>#!/bin/sh
gcd() { # Calculate $1 % $2 until $2 becomes zero.
 until [ "$2" -eq 0 ]; do set -- "$2" "$(($1%$2))"; done
 echo "$1"
 }

lcm() { echo "$(( $1 / $(gcd "$1" "$2") * $2 ))"; }

while [ $# -gt 1 ]; do
 t="$(lcm "$1" "$2")"
 shift 2
 set -- "$t" "$@"
done
echo "$1"
</code></pre>

try it with:

<pre><code>$ ./script 2 3 4 5 6
</code></pre>

to get

<pre><code>60
</code></pre>

The biggest input and result should be less than <code>(2^63)-1</code> or the shell math will wrap.

blocks|key|1522939|text|我正在寻找数组元素的gcd和lcm，并在下面的链接中找到了一个很好的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522940|https://www.hackerrank.com/challenges/between-two-sets/forum|offset|length|1522941|其中包括以下代码。gcd的算法使用欧几里德算法，在下面的链接中进行了很好的解释。|1522942|https://www.khanacademy.org/computing/computer-science/cryptography/modarithmetic/a/the-euclidean-algorithm|1522943|private+static+int+gcd(int+a,+int+b)+{
++++while+(b+>+0)+{
++++++++int+temp+=+b;
++++++++b+=+a+%25+b;+//+%25+is+remainder
++++++++a+=+temp;
++++}
++++return+a;
}

private+static+int+gcd(int[]+input)+{
++++int+result+=+input[0];
++++for+(int+i+=+1;+i+<+input.length;+i%2B%2B)+{
++++++++result+=+gcd(result,+input[i]);
++++}
++++return+result;
}

private+static+int+lcm(int+a,+int+b)+{
++++return+a+*+(b+/+gcd(a,+b));
}

private+static+int+lcm(int[]+input)+{
++++int+result+=+input[0];
++++for+(int+i+=+1;+i+<+input.length;+i%2B%2B)+{
++++++++result+=+lcm(result,+input[i]);
++++}
++++return+result;
}|code-block|syntax|javascript|1522944|entityMap|0|LINK|mutability|MUTABLE|url|1^0|0|0|1O|0|0|0|0|2Z|1|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@$D|Y|E|Z|1|10]]|A|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@$D|13|E|14|1|15]]|A|$]]|$1|J|3|K|5|L|7|16|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|C]]|V|$5|R|S|T|A|$U|I]]]]

i was looking for gcd and lcm of array elements and found a good solution in the following link. 

<a href="https://www.hackerrank.com/challenges/between-two-sets/forum" rel="nofollow noreferrer">https://www.hackerrank.com/challenges/between-two-sets/forum</a>

which includes following code. The algorithm for gcd uses The Euclidean Algorithm explained well in the link below.

<a href="https://www.khanacademy.org/computing/computer-science/cryptography/modarithmetic/a/the-euclidean-algorithm" rel="nofollow noreferrer">https://www.khanacademy.org/computing/computer-science/cryptography/modarithmetic/a/the-euclidean-algorithm</a>

<pre><code>private static int gcd(int a, int b) {
 while (b &gt; 0) {
 int temp = b;
 b = a % b; // % is remainder
 a = temp;
 }
 return a;
}

private static int gcd(int[] input) {
 int result = input[0];
 for (int i = 1; i &lt; input.length; i++) {
 result = gcd(result, input[i]);
 }
 return result;
}

private static int lcm(int a, int b) {
 return a * (b / gcd(a, b));
}

private static int lcm(int[] input) {
 int result = input[0];
 for (int i = 1; i &lt; input.length; i++) {
 result = lcm(result, input[i]);
 }
 return result;
}
</code></pre>

blocks|key|1737950|text|这就是我用的--|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1737951|def+greater(n):

++++++a=num[0]

++++++for+i+in+range(0,len(n),1):
+++++++if(a<n[i]):
++++++++a=n[i]
++++++return+a

r=input('enter+limit')

num=[]

for+x+in+range+(0,r,1):

++++a=input('enter+number+')
++++num.append(a)
a=+greater(num)

i=0

while+True:

++++while+(a%25num[i]==0):
++++++++i=i%2B1
++++++++if(i==len(num)):
+++++++++++++++break
++++if+i==len(num):
++++++++print+'L.C.M+=+',a
++++++++break
++++else:
++++++++a=a%2B1
++++++++i=0|code-block|syntax|javascript|1737952|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|$]]

This is what I used --

<pre><code>def greater(n):

 a=num[0]

 for i in range(0,len(n),1):
 if(a&lt;n[i]):
 a=n[i]
 return a

r=input('enter limit')

num=[]

for x in range (0,r,1):

 a=input('enter number ')
 num.append(a)
a= greater(num)

i=0

while True:

 while (a%num[i]==0):
 i=i+1
 if(i==len(num)):
 break
 if i==len(num):
 print 'L.C.M = ',a
 break
 else:
 a=a+1
 i=0
</code></pre>

blocks|key|1523000|text|如果没有时间限制，这是相当简单和直接的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1523001|def+lcm(a,b,c):
++++for+i+in+range(max(a,b,c),+(a*b*c)%2B1,+max(a,b,c)):
++++++++if+i%25a+==+0+and+i%25b+==+0+and+i%25c+==+0:
++++++++++++return+i|code-block|syntax|javascript|1523002|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|$]]

If there's no time-constraint, this is fairly simple and straight-forward:

<pre><code>def lcm(a,b,c):
 for i in range(max(a,b,c), (a*b*c)+1, max(a,b,c)):
 if i%a == 0 and i%b == 0 and i%c == 0:
 return i
</code></pre>

blocks|key|1523022|text|对于python+3：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1523023|from+functools+import+reduce

gcd+=+lambda+a,b:+a+if+b==0+else+gcd(b,+a%25b)
def+lcm(lst):++++++++
++++return+reduce(lambda+x,y:+x*y//gcd(x,+y),+lst)++|code-block|syntax|javascript|1523024|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|$]]

for python 3:

<pre><code>from functools import reduce

gcd = lambda a,b: a if b==0 else gcd(b, a%b)
def lcm(lst): 
 return reduce(lambda x,y: x*y//gcd(x, y), lst) 
</code></pre>

blocks|key|1523049|text|在Ruby中，它很简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1523050|>+[2,+3,+4,+6].reduce(:lcm)
=>+12

>+[16,+32,+96].reduce(:gcd)
=>+16|code-block|syntax|javascript|1523051|(在Ruby+2.2.10和2.6.3上测试。)|1523052|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

In Ruby, it's as simple as:

<pre class="lang-rb prettyprint-override"><code>&gt; [2, 3, 4, 6].reduce(:lcm)
=&gt; 12

&gt; [16, 32, 96].reduce(:gcd)
=&gt; 16
</code></pre>

(tested on Ruby 2.2.10 and 2.6.3.)

blocks|key|1523086|text|Python3.9+math模块的gcd和lcm支持数字列表。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1523087|import+math

lst+=+[1,2,3,4,5,6,7,8,9]

print(math.lcm(*lst))

print(math.gcd(*lst))|code-block|syntax|javascript|1523088|entityMap^0|A|4|H|3|L|3|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|L|$]]

Python 3.9 <code>math</code> module's <code>gcd</code> and <code>lcm</code> support over a list of numbers.
<pre><code>import math

lst = [1,2,3,4,5,6,7,8,9]

print(math.lcm(*lst))

print(math.gcd(*lst))
</code></pre>

How do you calculate the least common multiple of multiple numbers?

So far I've only been able to calculate it between two numbers. But have no idea how to expand it to calculate 3 or more numbers.

So far this is how I did it 

<pre><code>LCM = num1 * num2 / gcd ( num1 , num2 )
</code></pre>

With gcd is the function to calculate the greatest common divisor for the numbers. Using euclidean algorithm

But I can't figure out how to calculate it for 3 or more numbers.

Least common multiple for 3 or more numbers

Python

如何计算多个数的最小公倍数？到目前为止，我只能计算两个数字之间的值。但是不知道如何扩展它来计算3个或更多的数字。到目前为止，我是这样做的LCM = num1 * num2 /  gcd ( num1 , num2 )使用gcd是计算数字的最大公约数的函数。使用欧几里得算法但是我不知道如何计算3个或更多的数字。

问3个或更多数字的最小公倍数
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问3个或更多数字的最小公倍数EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问3个或更多数字的最小公倍数
EN