一组正整数的最小公倍数A是最小的正整数B，使得每个kin都A存在一个正整数n，使得k*n = B。

给定至少两个正整数作为输入，输出它们的最小公倍数。

规则

• 允许使用内置程序，但是如果您的解决方案使用一个内置程序，则建议您包括一个不使用GCD / LCM内置程序的替代解决方案。但是，替代解决方案完全不会计入您的分数，因此它是完全可选的。
• 所有输入和输出将在您的语言的本机表示范围内。如果您的语言本身具有任意大整数的能力，那么您的解决方案必须适用于任意大输入和输出。

测试用例

[7, 2] -> 14
[8, 1] -> 8
[6, 4, 8] -> 24
[8, 2, 1, 10] -> 40
[9, 6, 2, 1, 5] -> 90
[5, 5, 7, 1, 1] -> 35
[4, 13, 8, 8, 11, 1] -> 1144
[7, 2, 2, 11, 11, 8, 5] -> 3080
[1, 6, 10, 3, 4, 10, 7] -> 420
[5, 2, 9, 10, 3, 4, 4, 4, 7] -> 1260
[9, 7, 10, 9, 7, 8, 5, 10, 1] -> 2520

其实12 1个字节

尽管我不确定如何在内置的原始LCM上进行改进，但仍然欢迎打高尔夫球的建议。在线尝试！

▲

没有内置的12字节版本。欢迎打高尔夫球。在线尝试！

╗2`╜@♀%ΣY`╓N

开球

          Implicit input array.
╗         Save array in register 0.
2`...`╓   Starting with f(0), find the first (two) x where f(x) returns a truthy value.
          These two values will be 0 and our LCM.
  ╜         Push array from register 0.
  @         Swap the top two values. Stack: x, array
  ♀%        Map % over x and array, returning (x % item) for each item in array.
  ΣY        If the sum of all the modulos equals 0, x is either 0 or our LCM.

N         Push the last (second) value of our results. This is our LCM.
          Implicit return.

JavaScript（ES6），36个字节

f=(a,i=1)=>a.some(v=>i%v)?f(a,i+1):i

从1它开始是第一个可以除以所有人的数字。

f=(a,i=1)=>a.some(v=>i%v)?f(a,i+1):i
;

console.log(f([7, 2]));
console.log(f([8, 1]));
console.log(f([6, 4, 8]));
console.log(f([8, 2, 1, 10]));
console.log(f([9, 6, 2, 1, 5]));
console.log(f([5, 5, 7, 1, 1]));
console.log(f([4, 13, 8, 8, 11, 1]));
console.log(f([7, 2, 2, 11, 11, 8, 5]));
console.log(f([1, 6, 10, 3, 4, 10, 7]));
console.log(f([5, 2, 9, 10, 3, 4, 4, 4, 7]));
console.log(f([9, 7, 10, 9, 7, 8, 5, 10, 1]));

05AB1E / 2sable，2个字节

.¿

在线尝试！在05AB1E
或2sable中

果冻 3个字节

æl/

通过LCM减少。在线尝试！或验证所有测试用例。

备用版本，6字节

ÆE»/ÆẸ

在线尝试！或验证所有测试用例。

怎么运行的

ÆE»/ÆẸ  Main link. Argument: A (array)

ÆE      Yield all prime exponents of each integer in A.
  »/    Reduce columns (exponents that correspond to the same prime) by maximum.
    ÆẸ  Turn the resulting array of prime exponents into the corresponding integer.

Python，69 65 52 50字节

A=lambda l,i=1:any(i%a for a in l)and A(l,i+1)or i

感谢Dennis，节省了2个字节！

非常简单的递归解决方案，您需要将递归限制提高一些才能使某些测试用例正常工作。

MATL，7个字节

&YFX>^p

没有内置。

在线尝试！

说明

让我们以输入[8, 2, 1, 10]为例。

&YF    % Take array implicitly. Push vector of prime factors and matrix of exponents 
       % of factorization, where each row represents one of the input numbers
       %   STACK: [2 3 5], [3 0 0; 1 0 0; 0 0 0; 1 0 1]
X>     % Maximum of each column
       %   STACK: [2 3 5], [3 0 1]
^      % Element-wise power
       %   STACK: [8 1 5]
p      % Product of array
       %   STACK: 40
       % Implicitly display

编辑（2017年6月9日）：YF在版本20.1.0中修改了两个输出：非因数素数及其（零）指数被跳过。这不会影响上面的代码，该代码无需任何更改即可工作。

朱莉娅（3字节）[正在从事非内置工作]

lcm     # Using LCM built-in (3 Bytes)

正如Dennis所指出的，我一直忘了Julia会自动对输入进行矢量化处理。

例：

println(lcm(1,2,3,4,5,6,7,8,9)) #Prints 2520

PowerShell v2 +，73个 60字节

param($a)for($i=1;($a|?{!($i%$_)}).count-ne$a.count){$i++}$i

根据条件获取输入$a，从$i=1和向上循环$i++。该条件($a|?{!($i%$_)}).count是-nOT e资格赛来$a.count。意，当所述元素的循环结束$a那是的除数$i等于的元素$a。然后，$i在流水线上留下一个孤立句，并且输出是隐式的。

测试用例

PS C:\Tools\Scripts\golfing> @(7,2),@(8,1),@(6,4,8),@(8,2,1,10),@(9,6,2,1,5),@(5,5,7,1,1),@(4,13,8,8,11,1)|%{($_-join',')+" -> "+(.\least-common-multiple.ps1 $_)}
7,2 -> 14
8,1 -> 8
6,4,8 -> 24
8,2,1,10 -> 40
9,6,2,1,5 -> 90
5,5,7,1,1 -> 35
4,13,8,8,11,1 -> 1144

PS C:\Tools\Scripts\golfing> @(7,2,2,11,11,8,5),@(1,6,10,3,4,10,7),@(5,2,9,10,3,4,4,4,7),@(9,7,10,9,7,8,5,10,1)|%{($_-join',')+" -> "+(.\least-common-multiple.ps1 $_)}
7,2,2,11,11,8,5 -> 3080
1,6,10,3,4,10,7 -> 420
5,2,9,10,3,4,4,4,7 -> 1260
9,7,10,9,7,8,5,10,1 -> 2520

Mathematica，3个字节

LCM

用法：

In[1]:= LCM[9, 7, 10, 9, 7, 8, 5, 10, 1]                                        

Out[1]= 2520

Cheddar，33个字节

(n,i=1)f->n.any(i&(%))?f(n,i+1):i

没有什么超级新的。

不打高尔夫球

(n, i = 1) f ->
  n.any(j -> i % j) ?
    f(n, i + 1) :
    i

基本上，它从一开始就一直增加，直到找到LCM

JavaScript（ES6），63 59字节

f=([x,...a])=>a[0]?x*f(a)/(g=(m,n)=>n?g(n,m%n):m)(x,f(a)):x

递归地找到最后两个元素的LCM。

Dyalog APL，2个字节

∧/

通过LCM减少。在TryAPL上进行测试。

JavaScript（ES6），52个字节

a=>a.reduce((l,n)=>l*n/(g=(m,n)=>n?g(n,m%n):m)(l,n))

我reduce尽我所能回答这个问题，但是显然我不会得到@Hedi回答的简单性。

Java的8，75 59 121 89字节

使用欧几里得算法和LCM（A，B）= A * B / GCD（A，B）的事实

• 关闭16个字节。感谢@carusocomputing
• 添加了多输入+ 62字节
• 关闭32个字节。感谢@OlivierGrégoire

码：

public static int lcm(int l, int c){
  for(int i=1;i<=l&&i<=c;++i) 
    if (i%l==0&&i%c==0)
      return l*c/i;
}
public static int lcm(int...x){
  int y=x[0];
  for(int j:x){
    y=lcm(j,y);
  }
  return y;
}

删除换行符：

int g(int a,int b){return b<1?a:g(b,a%b);}

l->{int l=1;for(int n:a)l=l*n/g(l,n);return l;}

MATL，3个字节

&Zm

这将内置函数与数组输入一起使用。

在线尝试！

Brachylog，17个字节

,.#>=g:?z:%a#=h0,

在线尝试！

说明

,.#>=               Output is a strictly positive integer
     g:?z           Zip the Output with the Input
         :%a        Compute Output mod I for each I in the Input
            #=h0,   All results must be equal to 0

Perl 6，10个字节

{[lcm] @_}

基本上与：

sub ( *@_ ) { @_.reduce: &infix:< lcm > }

J，11个字节

>./&.(_&q:)

有使用LCM内置的3个字节的解决方案。

*./

说明

>./&.(_&q:)  Input: array of integers A
      _&q:   Get the prime exponents of each integer in A
>./&         Reduce by maximum on the lists
   &. _&q:   Convert the list of exponents back to an integer

*./  Input: array of integers A
  /  Reduce using
*.     LCM

CJam，18 17 16字节

感谢Martin Ender，节省了1个字节。

递增直到找到LCM。

q~0{)_2$f%:+}g\;

在线尝试

拍子13字节

lcm是Racket中的内置函数：

(apply lcm l)

测试：

(define (f l)
   (apply lcm l))

(f (list 7 2)) 
(f (list 8 1)) 
(f (list 6 4 8)) 
(f (list 8 2 1 10)) 
(f (list 9 6 2 1 5))
(f (list 5 5 7 1 1)) 
(f (list 4 13 8 8 11 1))
(f (list 7 2 2 11 11 8 5))
(f (list 1 6 10 3 4 10 7))
(f (list 5 2 9 10 3 4 4 4 7)) 
(f (list 9 7 10 9 7 8 5 10 1))

输出：

14
8
24
40
90
35
1144
3080
420
1260
2520

R，36个字节（非内置）

v=scan();i=1;while(any(i%%v))i=i+1;i

接受输入。然后通过获取mod来测试每个正整数。

Pyth，9个字节

.U/*bZibZ

一个程序，在STDIN上输入列表并打印结果。

在线尝试或验证所有测试用例

怎么运行的

.U/*bZibZ  Program. Input: Q
.U         Reduce Q by (implicit input fill):
   *bZ      Product of current and next value
  /   ibZ   divided by GCD of current and next value
           Implicitly print

Haskell，10个字节

foldr1 lcm

用法示例：foldl1 lcm [5,2,9,10,3,4,4,4,7]-> 1260。

C＃，50 + 18 = 68字节

50个字节用于方法定义，+ 18个字节用于LINQ导入。

using System.Linq;int L(int[]n,int i=1)=>n.All(x=>1>i%x)?i:L(n,i+1);

与许多其他答案几乎相同。递归计数，直到找到LCM。我有点惊讶这没有得到StackOverflowException，所以我也有一个非递归版本，实际上只长了1个字节。

using System.Linq;n=>{for(int i=1;;i++)if(n.All(x=>1>i%x))return i;};

取消高尔夫：

using System.Linq;            // Import LINQ
int L(int[] n, int i = 1) =>  // Function declaration
    n.All(x => 1 > i % x)     // Check if each x in n divides i
        ? i                   // And if so return i
        : L(n, i + 1)         // Otherwise increment i and recurse
;

点，10字节

W$+o%g++oo

使用“尝试所有数字，直到一个可行”策略。在线尝试！

            o is preinitialized to 1, g is list of cmdline args
   o%g      Mod o by each arg
 $+         Sum (truthy if any nonzero, falsy if all zero)
W           Loop while that expression is truthy:
      ++o     Increment o
         o  Autoprint o

PHP，42 74字节

for(;($p=++$f*$argv[1])%$argv[2];);echo$p;

直接向前：从1向上
循环$f；如果$f*$a无余$b数分割，则找到LCM。

我完全已经覆盖了at least...这是任意数量参数的代码：

for(;$i<$argc;)for($p=$argv[$i=1]*++$f;++$i<$argc&$p%$argv[$i]<1;);echo$p;

$f从1向上循环，而内部循环未运行至$ argc。
循环$i从2到$argc-1而$f*$argv[1]分歧通过$argv[$i]没有剩余。
两个循环都中断了：print $f*$argument 1。

Prolog（SWI），46字节

l([],1).
l([X|Y],P):-l(Y,Q),P is X*Q/gcd(X,Q).

在线尝试！

另一种解决方案，59字节：

l(A,X):-between(1,inf,X),forall(member(Y,A),X mod Y=:=0),!.

Python 3，83个字节

import math,functools as i
t=lambda t:i.reduce(lambda a,b:int(a*b/math.gcd(a,b)),t)

Brachylog v2，8个字节

{×↙Xℕ₁}ᵛ

在线尝试！

有趣的是，它如何直接映射到挑战中给出的定义。

{     }ᵛ    Each element of
            the input
 ×          multiplied by
  ↙X        some arbitrary and inconsistent integer
    ℕ₁      is a natural number,
       ᵛ    which is the same for each element,
            and is the output.

一个可疑的缓慢但明显更短的解决方案：

Brachylog v2，5个字节

f⊇p~d

在线尝试！

通过输出变量获取输入，并通过输入变量提供输出。贯穿前四个测试用例，但我仍在等待第五个测试用例...通常，我仍将其作为主要解决方案，只是相信它可以正常工作，但是我不知道为什么它没有确认90是9, 6, 2, 1, 5我二十分钟前给它90时的LCM 。

（编辑：它在不超过16小时后确认了答案，并5, 5, 7, 1, 1在大约两天后与LCM一起生成了答案。）

         The output variable
   ~d    with duplicates removed
  p      is a permutation of
 ⊇       a sublist of
f        the factors of
         the input variable.

另一个完全不同的谓词偶然或多或少地转化了Fatalize的Brachylog v1解决方案：

Brachylog v2，10个字节

;.gᵗ↔z%ᵛ0<

在线尝试！

在我意识到输出并不仅限于整数之前，我从为这个挑战而提出的解决方案中解脱出来。

 .            The output
; gᵗ↔z        paired with each element of
              the input,
      %ᵛ      when the first element of each pair is taken mod the second, is always
        0     zero.
              Furthermore, the output
         <    is strictly greater than
        0     zero.

Pyth- 7 6个字节

没有内置。

*F{sPM

在这里在线尝试。