El mínimo común múltiplo de un conjunto de números enteros positivos Aes el entero más pequeño postive Btal que, para cada uno ken A, existe un número entero positivo ntal que k*n = B.

Dado al menos dos enteros positivos como entrada, genera su mínimo común múltiplo.

Reglas

• Se permiten las soluciones integradas, pero si su solución usa una, se le recomienda que incluya una solución alternativa que no use las soluciones integrales GCD / LCM. Sin embargo, la solución alternativa no contará para su puntaje, por lo que es completamente opcional.
• Todas las entradas y salidas estarán dentro del rango representable de forma nativa para su idioma. Si su idioma es capaz de forma nativa de enteros arbitrariamente grandes, entonces su solución debe funcionar con entradas y salidas arbitrariamente grandes.

Casos de prueba

[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

En realidad, 12 1 byte

Las sugerencias de golf siguen siendo bienvenidas, aunque no estoy seguro de cómo mejorar el LCM sin procesar incorporado. Pruébalo en línea!

▲

Una versión de 12 bytes sin el incorporado. Sugerencias de golf bienvenidas. Pruébalo en línea!

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

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

A partir de 1este es el primer número que se puede dividir por todos.

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

.¿

Pruébalo en línea! en 05AB1E
o 2sable

Jalea , 3 bytes

æl/

Reduce por LCM. Pruébalo en línea! o verificar todos los casos de prueba .

Versión alternativa, 6 bytes.

ÆE»/ÆẸ

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo funciona

Æ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 guardados gracias a Dennis!

Solución recursiva bastante sencilla, deberá hacer que el límite de recurrencia sea un poco más alto para que funcionen algunos de los casos de prueba.

MATL , 7 bytes

&YFX>^p

No incorporado.

Pruébalo en línea!

Explicación

Tomemos la entrada [8, 2, 1, 10]como un ejemplo.

&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

EDITAR (9 de junio de 2017): YFcon dos salidas se ha modificado en la versión 20.1.0 : los primos sin factor y sus exponentes (cero) se omiten. Esto no afecta el código anterior, que funciona sin requerir ningún cambio.

Julia (3 Bytes) [Trabajando en no incorporado]

lcm     # Using LCM built-in (3 Bytes)

Como señaló Dennis, sigo olvidando que Julia vectoriza automáticamente las entradas.

Ejemplo:

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

Toma de entrada $a, bucles hacia arriba desde $i=1con $i++, basado en un condicional. La condición se ($a|?{!($i%$_)}).countsiendo -not equal a $a.count. Es decir, el ciclo termina cuando los elementos de $aque son divisores de $ies igual a los elementos de $a. Luego, $iqueda un solitario en la tubería, y la salida es implícita.

Casos de prueba

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

Uso:

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

Nada super nuevo.

Sin golf

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

Básicamente, esto comienza en uno y continúa aumentando hasta que encuentra un 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

Encuentra recursivamente el MCM de los dos últimos elementos.

Dyalog APL, 2 bytes

∧/

Reduce por LCM. Pruébelo en 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 esta respuesta tanto como pude, pero obviamente no voy a llegar a ninguna parte cerca de la simplicidad de la respuesta de Hedi @.

Java 8, 75 59 121 89 bytes

Utiliza el algoritmo euclidiano y el hecho de que LCM (A, B) = A * B / GCD (A, B)

• 16 bytes de descuento. Gracias a @carusocomputing
• Entrada múltiple agregada + 62 bytes
• 32 bytes de descuento. Gracias a @Olivier Grégoire

Código:

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

Eliminar saltos de línea:

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

Esto usa la función incorporada con entrada de matriz.

Pruébalo en línea!

Brachylog , 17 bytes

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

Pruébalo en línea!

Explicación

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

básicamente lo mismo que:

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

J, 11 bytes

>./&.(_&q:)

Hay una solución para 3 bytes usando el LCM incorporado.

*./

Explicación

>./&.(_&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 guardado gracias a Martin Ender.

Incrementando hasta encontrar el LCM.

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

Pruébalo en línea

Raqueta 13 bytes

mcm es una función incorporada en Racket:

(apply lcm l)

Pruebas:

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

Salida:

14
8
24
40
90
35
1144
3080
420
1260
2520

R, 36 bytes (no incorporado)

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

Toma la entrada. Luego prueba cada entero positivo tomando el mod.

Pyth, 9 bytes

.U/*bZibZ

Un programa que toma la entrada de una lista en STDIN e imprime el resultado.

Pruébelo en línea o verifique todos los casos de prueba

Cómo funciona

.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

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

C #, 50 + 18 = 68 bytes

50 bytes para la definición del método, +18 bytes para la importación LINQ.

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

Más o menos lo mismo que muchas otras respuestas. Cuenta recursivamente hasta encontrar el LCM. Me sorprendió un poco que esto no obtuviera una StackOverflowException, por lo que también tengo una versión no recursiva que en realidad es solo 1 byte más.

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

Sin golf:

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

Utiliza la estrategia "prueba cada número hasta que uno funcione". Pruébalo en línea!

            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;

directo:
bucle $fde 1 hacia arriba; si se $f*$adivide $bsin un resto, se encuentra el LCM.

Leí por completo el at least... aquí está el código para cualquier número de parámetros:

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

Bucle $fde 1 hacia arriba, mientras que el bucle interno no se ha ejecutado a $ argc.
Bucle $idesde 2hasta $argc-1mientras se $f*$argv[1]divide $argv[$i]sin un resto.
ambos bucles rotos: impresión $f*$argument 1.

Prólogo (SWI) , 46 bytes

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

Pruébalo en línea!

Otra solución, 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ℕ₁}ᵛ

Pruébalo en línea!

Es curioso cuán directamente esto se asigna a la definición dada en el desafío.

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

Una solución sospechosamente lenta pero significativamente más corta:

Brachylog v2, 5 bytes

f⊇p~d

Pruébalo en línea!

Toma entrada a través de la variable de salida y da salida a través de la variable de entrada. Desglosa los primeros cuatro casos de prueba, pero todavía estoy esperando el quinto ... Por lo general, todavía lo convertiría en mi solución principal y confío en que funcione correctamente, pero no sé por qué no lo ha hecho. confirmó que 90 es el MCM de 9, 6, 2, 1, 5cuando le di 90 hace veinte minutos.

(Editar: confirmó la respuesta después de no más de 16 horas y la generó junto con el LCM de 5, 5, 7, 1, 1aproximadamente dos días).

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

Y otro predicado completamente diferente que accidentalmente traduce más o menos la solución Brachylog v1 de Fatalize:

Brachylog v2, 10 bytes

;.gᵗ↔z%ᵛ0<

Pruébalo en línea!

Esto se rescató de una solución que había hecho para este desafío antes de darme cuenta de que la salida no se limitaba a ser un número entero.

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

*F{sPM

Pruébelo en línea aquí .