Bội số chung nhỏ nhất của một tập hợp các số nguyên dương Alà số nguyên postive nhỏ Bnhư vậy mà, đối với từng kở A, tồn tại một số nguyên dương nnhư vậy k*n = B.

Cho ít nhất hai số nguyên dương làm đầu vào, đầu ra bội số chung nhỏ nhất của chúng.

Quy tắc

• Nội dung được cho phép, nhưng nếu giải pháp của bạn sử dụng một, bạn được khuyến khích đưa vào một giải pháp thay thế không sử dụng nội dung GCD / LCM. Tuy nhiên, giải pháp thay thế sẽ không được tính vào điểm số của bạn, vì vậy nó hoàn toàn là tùy chọn.
• Tất cả đầu vào và đầu ra sẽ nằm trong phạm vi có thể biểu thị được cho ngôn ngữ của bạn. Nếu ngôn ngữ của bạn thực sự có khả năng là số nguyên lớn tùy ý, thì giải pháp của bạn phải hoạt động với đầu vào và đầu ra lớn tùy ý.

Các trường hợp thử nghiệm

[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

Trên thực tế, 12 1 byte

Đề xuất chơi gôn vẫn được hoan nghênh, mặc dù tôi không chắc cách cải thiện LCM thô tích hợp. Hãy thử trực tuyến!

▲

Phiên bản 12 byte không tích hợp. Gợi ý chơi golf chào mừng. Hãy thử trực tuyến!

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

Ungolfing

          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 byte

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

Bắt đầu từ 1đó là số đầu tiên có thể chia cho tất cả.

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 byte

.¿

Hãy thử trực tuyến! trong 05AB1E
hoặc 2sable

Thạch , 3 byte

æl/

Giảm bởi LCM. Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Phiên bản thay thế, 6 byte

ÆE»/ÆẸ

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

Æ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 byte

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

2 byte được lưu nhờ Dennis!

Giải pháp đệ quy khá đơn giản, bạn sẽ cần làm cho giới hạn đệ quy cao hơn một chút để một số trường hợp thử nghiệm hoạt động.

MATL , 7 byte

&YFX>^p

Không có nội dung.

Hãy thử trực tuyến!

Giải trình

Hãy lấy đầu vào [8, 2, 1, 10]làm ví dụ.

&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

EDIT (ngày 9 tháng 6 năm 2017): YFvới hai kết quả đầu ra đã được sửa đổi trong bản phát hành 20.1.0 : các số nguyên tố không yếu tố và số mũ (không) của chúng bị bỏ qua. Điều này không ảnh hưởng đến mã trên, hoạt động mà không yêu cầu bất kỳ thay đổi.

Julia (3 Bytes) [Working on Non-Built-in]

lcm     # Using LCM built-in (3 Bytes)

As Dennis pointed out, I keep forgetting that Julia automatically vectorizes inputs.

Example:

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

PowerShell v2+, 73 60 bytes

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

Takes input $a, loops upward from $i=1 with $i++, based on a conditional. The condition is ($a|?{!($i%$_)}).count being -notequal to $a.count. Meaning, the loop ends when the elements of $a that are divisors of $i is equal to the elements of $a. Then, a solitary $i is left on the pipeline, and output is implicit.

Test Cases

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 bytes

LCM

Usage:

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

Out[1]= 2520

Cheddar, 33 bytes

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

Nothing super new.

Ungolfed

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

Basically this starts at one and keeps increasing until it finds an LCM

JavaScript (ES6), 63 59 bytes

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

Recursively finds the LCM of the last two elements.

Dyalog APL, 2 bytes

∧/

Reduces by LCM. Test it on TryAPL.

JavaScript (ES6), 52 bytes

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

I reduced this answer as much as I could but I'm obviously not going to get anywhere near the simplicity of @Hedi's answer.

Java 8, 75 59 121 89 bytes

Uses the Euclidean Algorithm and the fact that LCM(A, B)= A * B / GCD(A, B)

• 16 bytes off. Thanks to @carusocomputing
• Added Multi-Input +62 bytes
• 32 bytes off. Thanks to @Olivier Grégoire

Code:

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

Remove line-breaks:

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 bytes

&Zm

This uses the builtin function with array input.

Try it online!

Brachylog, 17 bytes

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

Try it online!

Explanation

,.#>=               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 bytes

{[lcm] @_}

basically the same as:

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

J, 11 bytes

>./&.(_&q:)

There is a solution for 3 bytes using the LCM builtin.

*./

Explanation

>./&.(_&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 bytes

1 byte saved thanks to Martin Ender.

Incrementing until the LCM is found.

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

Try it online

Racket 13 bytes

lcm is a built-in function in Racket:

(apply lcm l)

Testing:

(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))

Output:

14
8
24
40
90
35
1144
3080
420
1260
2520

R, 36 bytes (not builtin)

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

Takes the input. Then tests each positive integer by taking the mod.

Pyth, 9 bytes

.U/*bZibZ

A program that takes input of a list on STDIN and prints the result.

Try it online or verify all test cases

How it works

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

foldr1 lcm

Usage example: foldl1 lcm [5,2,9,10,3,4,4,4,7] -> 1260.

C#, 50+18 = 68 bytes

50 bytes for method defintion, +18 bytes for LINQ import.

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

Pretty much the same as a lot of other answers. Counts up recursively until it finds the LCM. I was a bit surprised this didn't get a StackOverflowException, so I also have a non-recursive version which is actually just 1 byte longer.

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

Ungolfed:

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
;

Pip, 10 bytes

W$+o%g++oo

Uses the "try every number until one works" strategy. Try it online!

            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 bytes

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

straight forward:
loop $f from 1 upwards; if $f*$a divides through $b without a remainder, the LCM is found.

I totally had overread the at least ... here´s the code for any number of parameters:

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

Loop $f from 1 upwards while inner loop has not run to $argc.
Loop $i from 2 to $argc-1 while $f*$argv[1] divides through $argv[$i] without a remainder.
both loops broken: print $f*$argument 1.

Prolog (SWI), 46 bytes

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

Try it online!

Another solution, 59 bytes:

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

Python 3, 83 bytes

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

Brachylog v2, 8 bytes

{×↙Xℕ₁}ᵛ

Try it online!

It's funny just how directly this maps on to the definition given in the challenge.

{     }ᵛ    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.

A suspiciously slow but significantly shorter solution:

Brachylog v2, 5 bytes

f⊇p~d

Try it online!

Takes input through the output variable and gives output through the input variable. Rips right through the first four test cases but I'm still waiting on the fifth... Ordinarily, I'd still make it my primary solution and just trust that it works correctly, but I don't know why it hasn't confirmed that 90 is the LCM of 9, 6, 2, 1, 5 when I gave it 90 twenty minutes ago.

(Edit: It confirmed the answer after no more than 16 hours, and generated it alongside the LCM of 5, 5, 7, 1, 1 after about two days.)

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

And another completely different predicate that accidentally more-or-less translates Fatalize's Brachylog v1 solution:

Brachylog v2, 10 bytes

;.gᵗ↔z%ᵛ0<

Try it online!

This was salvaged from a solution I'd made for this challenge before I realized the output wasn't restricted to being an integer.

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

No builtin.

*F{sPM

Try it online here.