Das am wenigsten verbreitete Vielfache einer Menge positiver Ganzzahlen Aist die kleinste positive Ganzzahl, Bso dass für jedes kin Aeine positive Ganzzahl existiert, nso dass k*n = B.

Geben Sie bei mindestens zwei positiven Ganzzahlen als Eingabe das kleinste gemeinsame Vielfache aus.

Regeln

• Builtins sind zulässig. Wenn Ihre Lösung jedoch eine verwendet, sollten Sie eine alternative Lösung einbeziehen, die keine GCD / LCM-Builtins verwendet. Die alternative Lösung wird jedoch nicht für Ihre Punktzahl angerechnet, so dass dies völlig optional ist.
• Alle Ein- und Ausgaben liegen innerhalb des für Ihre Sprache nativ darstellbaren Bereichs. Wenn Ihre Sprache von Haus aus zu beliebig großen ganzen Zahlen fähig ist, muss Ihre Lösung mit beliebig großen Ein- und Ausgängen arbeiten.

Testfälle

[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

Eigentlich 12 1 Byte

Vorschläge zum Golfen sind immer noch willkommen, obwohl ich nicht sicher bin, wie ich das integrierte LCM verbessern kann. Probieren Sie es online!

▲

Eine 12-Byte-Version ohne den eingebauten. Golfvorschläge sind willkommen. Probieren Sie es online!

╗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

Ausgehend von 1der ersten Zahl, die durch alle geteilt werden kann.

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 Bytes

.¿

Probieren Sie es online! in 05AB1E
oder 2sable

Gelee , 3 Bytes

æl/

Reduziert um LCM. Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Alternative Version, 6 Bytes

ÆE»/ÆẸ

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

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

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

2 Bytes gespart dank Dennis!

Ziemlich einfache rekursive Lösung, Sie müssen das Rekursionslimit etwas erhöhen, damit einige der Testfälle funktionieren.

MATL , 7 Bytes

&YFX>^p

Kein eingebaut.

Probieren Sie es online!

Erläuterung

Nehmen wir [8, 2, 1, 10]als Beispiel die Eingabe .

&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. Juni 2017): YFmit zwei Ausgängen wurde in Release 20.1.0 geändert : Nicht-Faktor-Primzahlen und ihre (Null-) Exponenten werden übersprungen. Dies hat keinen Einfluss auf den obigen Code, der ohne Änderungen funktioniert.

Julia (3 Bytes) [Arbeiten an nicht eingebauten]

lcm     # Using LCM built-in (3 Bytes)

Wie Dennis betonte, vergesse ich immer wieder, dass Julia Eingaben automatisch vektorisiert.

Beispiel:

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

PowerShell v2 +, 73 - 60 Byte

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

Nimmt Eingaben auf $a, springt von $i=1mit nach oben $i++, basierend auf einer Bedingung. Die Bedingung wird ($a|?{!($i%$_)}).countsein -not equal zu $a.count. Das heißt, die Schleife endet, wenn die Elemente $adavon die Teiler von $isind, gleich den Elementen von sind $a. Dann $ibleibt ein Einzelgänger in der Pipeline und die Ausgabe ist implizit.

Testfälle

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

Verwendung:

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

Nichts super Neues.

Ungolfed

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

Grundsätzlich beginnt dies bei eins und nimmt zu, bis ein LCM gefunden wird

JavaScript (ES6), 63 bis 59 Byte

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

Findet rekursiv die LCM der letzten beiden Elemente.

Dyalog APL, 2 Bytes

∧/

Reduziert um LCM. Testen Sie es auf TryAPL .

JavaScript (ES6), 52 Byte

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

Ich habe reducediese Antwort so oft ich konnte, aber ich werde offensichtlich nicht annähernd die Einfachheit von @Hedis Antwort erreichen.

Java 8, 75, 59 121 89 Bytes

Verwendet den euklidischen Algorithmus und die Tatsache, dass LCM (A, B) = A * B / GCD (A, B)

• 16 Bytes aus. Vielen Dank an @carusocomputing
• Multi-Input + 62 Bytes hinzugefügt
• 32 Bytes aus. Vielen Dank an @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;
}

Zeilenumbrüche entfernen:

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

Dies verwendet die eingebaute Funktion mit Array-Eingabe.

Probieren Sie es online!

Brachylog , 17 Bytes

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

Probieren Sie es online!

Erläuterung

,.#>=               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] @_}

im Grunde das gleiche wie:

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

J, 11 Bytes

>./&.(_&q:)

Es gibt eine Lösung für 3 Bytes mit dem LCM Builtin.

*./

Erläuterung

>./&.(_&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 gespart dank Martin Ender.

Inkrementieren, bis das LCM gefunden wurde.

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

Probieren Sie es online aus

Schläger 13 Bytes

lcm ist eine eingebaute Funktion in Racket:

(apply lcm l)

Testen:

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

Ausgabe:

14
8
24
40
90
35
1144
3080
420
1260
2520

R, 36 Bytes (nicht eingebaut)

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

Übernimmt die Eingabe. Dann testet jede positive ganze Zahl mit dem Mod.

Pyth, 9 Bytes

.U/*bZibZ

Ein Programm, das eine Liste in STDIN eingibt und das Ergebnis druckt.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle

Wie es funktioniert

.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

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

C #, 50 + 18 = 68 Bytes

50 Bytes für die Definition der Methode, +18 Bytes für den LINQ-Import.

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

So ziemlich das Gleiche wie viele andere Antworten. Zählt rekursiv, bis das LCM gefunden wird. Ich war ein bisschen überrascht, dass es keine StackOverflowException gab, daher habe ich auch eine nicht rekursive Version, die eigentlich nur 1 Byte länger ist.

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

Verwendet die Strategie "Versuche jede Zahl, bis eine funktioniert". Probieren Sie es 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;

geradeaus:
Schleife $fvon 1 aufwärts; wenn $f*$adividieren durch $bohne Rest wird das LCM gefunden.

Ich hatte das total überlesen at least... hier ist der Code für eine beliebige Anzahl von Parametern:

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

Schleife $fvon 1 aufwärts, während die innere Schleife nicht auf $ argc gelaufen ist.
Schleife $ivon 2bis, $argc-1während $f*$argv[1]sich $argv[$i]ohne Rest teilt .
beide schleifen sind gebrochen: print $f*$argument 1.

Prolog (SWI) , 46 Bytes

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

Probieren Sie es online!

Eine andere Lösung, 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ℕ₁}ᵛ

Probieren Sie es online!

Es ist lustig, wie direkt dies auf die in der Herausforderung angegebene Definition abbildet.

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

Eine verdächtig langsame, aber deutlich kürzere Lösung:

Brachylog v2, 5 Bytes

f⊇p~d

Probieren Sie es online!

Übernimmt die Eingabe über die Ausgabevariable und gibt die Ausgabe über die Eingabevariable aus. Rippt die ersten vier Testfälle durch, aber ich warte immer noch auf den fünften ... Normalerweise würde ich es immer noch zu meiner primären Lösung machen und darauf vertrauen, dass es richtig funktioniert, aber ich weiß nicht, warum es nicht funktioniert bestätigte, dass 90 das LCM von ist, 9, 6, 2, 1, 5als ich es 90 gab zwanzig Minuten ist, gab.

(Edit: Es bestätigte die Antwort nach nicht mehr als 16 Stunden und erzeugte sie zusammen mit dem LCM 5, 5, 7, 1, 1nach etwa zwei Tagen.)

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

Und noch ein völlig anderes Prädikat, das aus Versehen die Brachylog v1-Lösung von Fatalize mehr oder weniger übersetzt:

Brachylog v2, 10 Bytes

;.gᵗ↔z%ᵛ0<

Probieren Sie es online!

Dies wurde aus einer Lösung geborgen, die ich für diese Herausforderung entwickelt hatte, bevor mir klar wurde, dass die Ausgabe nicht auf eine Ganzzahl beschränkt war.

 .            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

Kein eingebaut.

*F{sPM

Probieren Sie es hier online aus .