Pozitif tamsayılar kümesinin en küçük ortak birden Aen küçük pozitif tam sayıdır Bher biri için, böyle kde A, tam sayı pozitif vardır nöyle ki k*n = B.

Giriş olarak en az iki pozitif tam sayı verildiğinde, en az ortak katlarını çıkar.

kurallar

• Yerleşiklere izin verilir, ancak çözümünüz bir tane kullanıyorsa, GCD / LCM yerleşikleri kullanmayan alternatif bir çözüm eklemeniz önerilir. Ancak, alternatif çözüm hiç bir şekilde puanınıza sayılmaz, bu yüzden tamamen isteğe bağlıdır.
• Tüm girişler ve çıkışlar, diliniz için yerel olarak temsil edilebilir bir aralıkta olacaktır. Diliniz yerel olarak keyfi büyüklükte tamsayılar yapabiliyorsa, çözümünüz isteğe bağlı olarak büyük girdi ve çıktılarla çalışmalıdır.

Test durumları

[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

Aslında, 12 1 bayt

Golf önerileri hala açıktır, ancak ham LCM'nin yerleşik özelliğini nasıl geliştireceğimi bilmiyorum. Çevrimiçi deneyin!

▲

Yerleşik olmayan 12 baytlık bir versiyon. Golf önerileri kabul edilir. Çevrimiçi deneyin!

╗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 bayt

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

Bundan başlayarak 1herkes tarafından bölünebilecek ilk sayı.

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 bayt

.¿

Çevrimiçi deneyin! 05AB1E
veya 2sable içinde

Jöle , 3 bayt

æl/

LCM ile azaltır. Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Alternatif sürüm, 6 bayt

ÆE»/ÆẸ

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Nasıl çalışır

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

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

Dennis sayesinde 2 bayt kurtarıldı!

Oldukça basit özyinelemeli çözüm, bazı test durumlarının çalışması için özyineleme sınırını biraz daha yükseğe çıkarmanız gerekecek.

MATL , 7 bayt

&YFX>^p

Yerleşik değil.

Çevrimiçi deneyin!

açıklama

[8, 2, 1, 10]Örnek olarak girdi alalım.

&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 (9 Haziran 2017): 20.1.0 sürümündeYF iki çıkışla değiştirildi : faktör dışı primerler ve (sıfır) üsleri atlandı. Bu, herhangi bir değişiklik gerektirmeden çalışan yukarıdaki kodu etkilemez.

Julia (3 Bayt) [Dahili Olmayan Üzerinde Çalışma]

lcm     # Using LCM built-in (3 Bytes)

Dennis'in belirttiği gibi, Julia'nın girdileri otomatik olarak vektörleştirdiğini unutmaya devam ediyorum.

Örnek:

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

PowerShell v2 +, 73 60 bayt

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

Girişi alır $a, yukarı doğru döngü $i=1ile $i++bir koşullu göre. Koşul olduğu ($a|?{!($i%$_)}).countolmanın -not equal için $a.count. Yani, unsurları ilmik uçları $abu vardır ve bölenler $iIS elemanları eşit $a. Daha sonra, $iboru hattında bir soliter kalır ve çıktı örtüktür.

Test Kılıfları

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 bayt

LCM

Kullanımı:

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

Out[1]= 2520

Çedar, 33 bayt

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

Süper yeni bir şey değil.

Ungolfed

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

Temelde bu bir başlar ve bir LCM bulana kadar artmaya devam eder

JavaScript (ES6), 63 59 bayt

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

Tekrar tekrar son iki elementin LCM'sini bulur.

Dyalog APL, 2 bayt

∧/

LCM ile azaltır. TryAPL'de test edin .

JavaScript (ES6), 52 bayt

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

Ben reduceelimden olduğu kadar bu cevabı d ama açıkçası Hedi cevabı @ sadeliği yakın yere ulaşmak için gitmiyorum.

Java 8, 75 59 121 89 bayt

Öklid Algoritmasını ve LCM (A, B) = A * B / GCD (A, B) gerçeğini kullanır

• 16 bayt kapalı. @Carusocomputing sayesinde
• Çoklu Giriş + 62 bayt eklendi
• 32 bayt kapalı. @Olivier Grégoire sayesinde

Kod:

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

Satır sonlarını kaldır:

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 bayt

&Zm

Bu, array girişli yerleşik işlevi kullanır.

Çevrimiçi deneyin!

Brachylog , 17 bayt

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

Çevrimiçi deneyin!

açıklama

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

{[lcm] @_}

temelde aynı:

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

J, 11 bayt

>./&.(_&q:)

LCM yerleşikini kullanan 3 baytlık bir çözüm var .

*./

açıklama

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

Martin Ender sayesinde 1 bayt kurtarıldı.

LCM bulunana kadar artırma.

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

Çevrimiçi deneyin

Raket 13 bayt

lcm, Raket'teki yerleşik bir işlevdir:

(apply lcm l)

Test yapmak:

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

Çıktı:

14
8
24
40
90
35
1144
3080
420
1260
2520

R, 36 bayt (yerleşik değil)

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

Girişi alır. Sonra her pozitif tamsayıyı mod alarak test eder.

Pyth, 9 bayt

.U/*bZibZ

STDIN'deki bir listenin girişini alan ve sonucu basan bir program.

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın

Nasıl çalışır

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

foldr1 lcm

Kullanım örneği: foldl1 lcm [5,2,9,10,3,4,4,4,7]-> 1260.

C #, 50 + 18 = 68 bayt

Yöntem tanımı için 50 bayt, LINQ içe aktarma için +18 bayt.

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

Pek çok başka cevabın aynısı. LCM'yi bulana kadar tekrarlı olarak sayılır. Bu bir StackOverflowException alamadığı için biraz şaşırdım, bu yüzden aslında sadece 1 byte uzunluğunda olan özyinelemeli olmayan bir sürümüm de var.

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 bayt

W$+o%g++oo

"Bir işe yarayana kadar her numarayı dene" stratejisini kullanır. Çevrimiçi deneyin!

            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 bayt

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

dümdüz ileri: 1'den yukarı doğru
döngü $f; Eğer $f*$ayoluyla böler $bbir kalan olmadan LCM bulunmuştur.

Ben tamamen yenmiştim at least... işte herhangi bir sayıda parametre için kod:

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

Döngü $f1 yukarı olan iç döngü $ argc çalıştırmak değil iken.
Döngü $igelen 2için $argc-1ise $f*$argv[1]böler yoluyla $argv[$i]geri kalan olmadan.
her iki döngüde de kırılmış: yazdırın $f*$argument 1.

Prolog (SWI) , 46 bayt

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

Çevrimiçi deneyin!

Başka bir çözüm, 59 bayt:

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

Python 3, 83 bayt

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

Brachylog v2, 8 bayt

{×↙Xℕ₁}ᵛ

Çevrimiçi deneyin!

Bu, tam olarak bunun, meydan okumada verilen tanımlarla ne kadar doğrudan eşleşmesi komik.

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

Şüpheli bir şekilde yavaş ama önemli ölçüde daha kısa bir çözüm:

Brachylog v2, 5 bayt

f⊇p~d

Çevrimiçi deneyin!

Çıktı değişkeni üzerinden girdi alır ve girdi değişkeni aracılığıyla çıktı verir. İlk dört test senaryosundan geçiyor ama hala beşinciyi bekliyorum ... Normalde, yine de birincil çözümüm olur ve sadece doğru şekilde çalıştığına güvenirim, ama neden olmadığını bilmiyorum Yirmi dakika önce 909, 6, 2, 1, 5 verdiğimde 90'ın LCM olduğunu doğruladı .

(Düzenleme: Cevabı 16 saatten uzun bir süre sonra onayladı ve 5, 5, 7, 1, 1yaklaşık iki gün sonra LCM ile birlikte oluşturdu .)

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

Ve bir diğerinden tamamen farklı bir tahmin, yanlışlıkla az çok Fatalize Brachylog v1 çözümünü çeviriyor:

Brachylog v2, 10 bayt

;.gᵗ↔z%ᵛ0<

Çevrimiçi deneyin!

Bu, çıktının bir tam sayı ile sınırlı olmadığını fark etmeden önce , bu zorluk için yaptığım bir çözümden kurtarıldı .

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

Yerleşik değil.

*F{sPM

Burada çevrimiçi deneyin .